由于wmqtt.jar库在android4.0以上实现有问题会报MqttException Null异常，原因是该库只支持4.0以下版本。无奈只有寻找其他解决方案，最后选择的是Paho库中的client版本，org.eclipse.paho.client.mqttv3.jar。利用该库可以在android4.0以上正常连接Mqtt的服务器，博主用的android5.1进行实验的。
博主利用mqtt实现的主要功能是android端要与特定的智能硬件进行通信，而且是双向通信，android要给智能硬件发控制信息，智能硬件要给android返回状态信息；关于订阅与发布的id问题是其中的关键，android端要获取智能硬件的id，作为android发布信息的主题，在绑定完智能硬件之后，智能硬件发布以智能硬件的id+后缀作为智能硬件的发布信息id，而android端订阅智能硬件的id+后缀的主题。（启动的时候默认订阅服务器主题，服务器发送目前已经绑定了的智能硬件的主题，拉取主题列表。主题列表中有智能硬件在线、离线状态，更新客户端状态。外部设置进行其他智能硬件的主题订阅，在接口中添加主题订阅操作，在接口中添加自定义主题发布操作。）
android端为了每个活动都可以更方便得对确定主题的发布，与订阅主题的接收。在android建立一个基础活动类MqttBaseActivity，而其他需要进行mqtt操作的活动都继承该活动，减少活动中非主要业务代码冗余，提高代码可维护性。
要实现上述设想，需要进行3方面的工作：
    1.MqttService类实现；
    2.MqttBaseActivity类实现；
    3.主活动调用示例；
MqttService提供给外界的接口主要包括内容订阅，自定义主题消息发送，全局广播消息接收。

package com.splxtech.powermanagor.engine;

import java.util.Locale;

import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.eclipse.paho.client.mqttv3.MqttDefaultFilePersistence;
import org.eclipse.paho.client.mqttv3.MqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.eclipse.paho.client.mqttv3.MqttPersistenceException;
import org.eclipse.paho.client.mqttv3.MqttTopic;
import org.eclipse.paho.client.mqttv3.internal.MemoryPersistence;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.provider.Settings.Secure;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;

import com.splxtech.powermanagor.IMqttService;


public class MqttService extends Service implements MqttCallback
{
    public static final String DEBUG_TAG = "MqttService"; // Debug TAG

    private static final String MQTT_THREAD_NAME = "MqttService[" + DEBUG_TAG + "]"; // Handler Thread ID

    private static final String MQTT_BROKER = ""; // Broker URL or IP Address
    private static final int MQTT_PORT = 1883; // Broker Port

    public static final int MQTT_QOS_0 = 0; // QOS Level 0 ( Delivery Once no confirmation )
    public static final int MQTT_QOS_1 = 1; // QOS Level 1 ( Delevery at least Once with confirmation )
    public static final int MQTT_QOS_2 = 2; // QOS Level 2 ( Delivery only once with confirmation with handshake )

    private static final int MQTT_KEEP_ALIVE = 240000; // KeepAlive Interval in MS
    private static final String MQTT_KEEP_ALIVE_TOPIC_FORAMT = "/users/%s/keepalive"; // Topic format for KeepAlives
    private static final byte[]     MQTT_KEEP_ALIVE_MESSAGE = { 0 }; // Keep Alive message to send
    private static final int MQTT_KEEP_ALIVE_QOS = MQTT_QOS_0; // Default Keepalive QOS

    private static final boolean MQTT_CLEAN_SESSION = true; // Start a clean session?

    private static final String MQTT_URL_FORMAT = "tcp://%s:%d"; // URL Format normally don't change

    private static final String ACTION_START  = DEBUG_TAG + ".START"; // Action to start
    private static final String ACTION_STOP   = DEBUG_TAG + ".STOP"; // Action to stop
    private static final String ACTION_KEEPALIVE= DEBUG_TAG + ".KEEPALIVE"; // Action to keep alive used by alarm manager
    private static final String ACTION_RECONNECT= DEBUG_TAG + ".RECONNECT"; // Action to reconnect


    private static final String DEVICE_ID_FORMAT = "andr_%s"; // Device ID Format, add any prefix you'd like
    // Note: There is a 23 character limit you will get
    // An NPE if you go over that limit
    private boolean mStarted = false;   // Is the Client started?
    private String mDeviceId;       // Device ID, Secure.ANDROID_ID
    private Handler mConnHandler;     // Seperate Handler thread for networking

    private MqttDefaultFilePersistence mDataStore; // Defaults to FileStore
    private MemoryPersistence mMemStore; // On Fail reverts to MemoryStore
    private MqttConnectOptions mOpts; // Connection Options

    private MqttTopic mKeepAliveTopic; // Instance Variable for Keepalive topic

    private MqttClient mClient; // Mqtt Client

    private AlarmManager mAlarmManager; // Alarm manager to perform repeating tasks
    private ConnectivityManager mConnectivityManager; // To check for connectivity changes

    private LocalBroadcastManager localBroadcastManager;
    public static final String MQTT_RECE_MESSAGE_ACTION = "com.splxtech.powermanagor.engine.mqttservice.recemessage";
    /**
     * Start MQTT Client
     * @param
     * @return void
     */
    public static void actionStart(Context ctx) {
        Intent i = new Intent(ctx,MqttService.class);
        i.setAction(ACTION_START);
        ctx.startService(i);
    }
    /**
     * Stop MQTT Client
     * @param
     * @return void
     */
    public static void actionStop(Context ctx) {
        Intent i = new Intent(ctx,MqttService.class);
        i.setAction(ACTION_STOP);
        ctx.startService(i);
    }
    /**
     * Send a KeepAlive Message
     * @param
     * @return void
     */
    public static void actionKeepalive(Context ctx) {
        Intent i = new Intent(ctx,MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        ctx.startService(i);
    }

    /**
     * Initalizes the DeviceId and most instance variables
     * Including the Connection Handler, Datastore, Alarm Manager
     * and ConnectivityManager.
     */
    @Override
    public void onCreate() {
        super.onCreate();

        mDeviceId = String.format(DEVICE_ID_FORMAT,
                Secure.getString(getContentResolver(), Secure.ANDROID_ID));

        HandlerThread thread = new HandlerThread(MQTT_THREAD_NAME);
        thread.start();

        mConnHandler = new Handler(thread.getLooper());

        try {
            mDataStore = new MqttDefaultFilePersistence(getCacheDir().getAbsolutePath());
        } catch(MqttPersistenceException e) {
            e.printStackTrace();
            mDataStore = null;
            mMemStore = new MemoryPersistence();
        }

        mOpts = new MqttConnectOptions();
        mOpts.setCleanSession(MQTT_CLEAN_SESSION);
        // Do not set keep alive interval on mOpts we keep track of it with alarm's

        mAlarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
        mConnectivityManager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
        localBroadcastManager = LocalBroadcastManager.getInstance(this);
    }

    /**
     * Service onStartCommand
     * Handles the action passed via the Intent
     *
     * @return START_REDELIVER_INTENT
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);

        String action = intent.getAction();

        Log.i(DEBUG_TAG,"Received action of " + action);

        if(action == null) {
            Log.i(DEBUG_TAG,"Starting service with no action\n Probably from a crash");
        } else {
            if(action.equals(ACTION_START)) {
                Log.i(DEBUG_TAG,"Received ACTION_START");
                start();
            } else if(action.equals(ACTION_STOP)) {
                stop();
            } else if(action.equals(ACTION_KEEPALIVE)) {
                keepAlive();
            } else if(action.equals(ACTION_RECONNECT)) {
                if(isNetworkAvailable()) {
                    reconnectIfNecessary();
                }
            }
        }

        return START_REDELIVER_INTENT;
    }

    /**
     * Attempts connect to the Mqtt Broker
     * and listen for Connectivity changes
     * via ConnectivityManager.CONNECTVITIY_ACTION BroadcastReceiver
     */
    private synchronized void start() {
        if(mStarted) {
            Log.i(DEBUG_TAG,"Attempt to start while already started");
            return;
        }

        if(hasScheduledKeepAlives()) {
            stopKeepAlives();
        }

        connect();

        registerReceiver(mConnectivityReceiver,new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
    }
    /**
     * Attempts to stop the Mqtt client
     * as well as halting all keep alive messages queued
     * in the alarm manager
     */
    private synchronized void stop() {
        if(!mStarted) {
            Log.i(DEBUG_TAG,"Attemtpign to stop connection that isn't running");
            return;
        }

        if(mClient != null) {
            mConnHandler.post(new Runnable() {
                @Override
                public void run() {
                    try {
                        mClient.disconnect();
                    } catch(MqttException ex) {
                        ex.printStackTrace();
                    }
                    mClient = null;
                    mStarted = false;

                    stopKeepAlives();
                }
            });
        }

        unregisterReceiver(mConnectivityReceiver);
    }
    /**
     * Connects to the broker with the appropriate datastore
     */
    private synchronized void connect() {
        String url = String.format(Locale.US, MQTT_URL_FORMAT, MQTT_BROKER, MQTT_PORT);
        Log.i(DEBUG_TAG,"Connecting with URL: " + url);
        try {
            if(mDataStore != null) {
                Log.i(DEBUG_TAG,"Connecting with DataStore");
                mClient = new MqttClient(url,mDeviceId,mDataStore);
            } else {
                Log.i(DEBUG_TAG,"Connecting with MemStore");
                mClient = new MqttClient(url,mDeviceId,mMemStore);
            }
        } catch(MqttException e) {
            e.printStackTrace();
        }

        mConnHandler.post(new Runnable() {
            @Override
            public void run() {
                try {
                    mClient.connect(mOpts);

                    mClient.subscribe("hello", 0);

                    mClient.setCallback(MqttService.this);

                    mStarted = true; // Service is now connected

                    Log.i(DEBUG_TAG,"Successfully connected and subscribed starting keep alives");

                    startKeepAlives();
                } catch(MqttException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    /**
     * Schedules keep alives via a PendingIntent
     * in the Alarm Manager
     */
    private void startKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
        mAlarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
                System.currentTimeMillis() + MQTT_KEEP_ALIVE,
                MQTT_KEEP_ALIVE, pi);
    }
    /**
     * Cancels the Pending Intent
     * in the alarm manager
     */
    private void stopKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getService(this, 0, i, 0);
        mAlarmManager.cancel(pi);
    }
    /**
     * Publishes a KeepALive to the topic
     * in the broker
     */
    private synchronized void keepAlive() {
        if(isConnected()) {
            try {
                sendKeepAlive();
                return;
            } catch(MqttConnectivityException ex) {
                ex.printStackTrace();
                reconnectIfNecessary();
            } catch(MqttPersistenceException ex) {
                ex.printStackTrace();
                stop();
            } catch(MqttException ex) {
                ex.printStackTrace();
                stop();
            }
        }
    }
    /**
     * Checkes the current connectivity
     * and reconnects if it is required.
     */
    private synchronized void reconnectIfNecessary() {
        if(mStarted && mClient == null) {
            connect();
        }
    }
    /**
     * Query's the NetworkInfo via ConnectivityManager
     * to return the current connected state
     * @return boolean true if we are connected false otherwise
     */
    private boolean isNetworkAvailable() {
        NetworkInfo info = mConnectivityManager.getActiveNetworkInfo();

        return (info == null) ? false : info.isConnected();
    }
    /**
     * Verifies the client State with our local connected state
     * @return true if its a match we are connected false if we aren't connected
     */
    private boolean isConnected() {
        if(mStarted && mClient != null && !mClient.isConnected()) {
            Log.i(DEBUG_TAG,"Mismatch between what we think is connected and what is connected");
        }

        if(mClient != null) {
            return (mStarted && mClient.isConnected()) ? true : false;
        }

        return false;
    }
    /**
     * Receiver that listens for connectivity chanes
     * via ConnectivityManager
     */
    private final BroadcastReceiver mConnectivityReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i(DEBUG_TAG,"Connectivity Changed...");
        }
    };
    /**
     * Sends a Keep Alive message to the specified topic
     * @return MqttDeliveryToken specified token you can choose to wait for completion
     */
    private synchronized MqttDeliveryToken sendKeepAlive()
            throws MqttConnectivityException, MqttPersistenceException, MqttException {
        if(!isConnected())
            throw new MqttConnectivityException();

        if(mKeepAliveTopic == null) {
            mKeepAliveTopic = mClient.getTopic(
                    String.format(Locale.US, MQTT_KEEP_ALIVE_TOPIC_FORAMT,mDeviceId));
        }

        Log.i(DEBUG_TAG,"Sending Keepalive to " + MQTT_BROKER);

        MqttMessage message = new MqttMessage(MQTT_KEEP_ALIVE_MESSAGE);
        message.setQos(MQTT_KEEP_ALIVE_QOS);

        return mKeepAliveTopic.publish(message);
    }
    /**
     * Query's the AlarmManager to check if there is
     * a keep alive currently scheduled
     * @return true if there is currently one scheduled false otherwise
     */
    private synchronized boolean hasScheduledKeepAlives() {
        Intent i = new Intent();
        i.setClass(this, MqttService.class);
        i.setAction(ACTION_KEEPALIVE);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, PendingIntent.FLAG_NO_CREATE);

        return (pi != null) ? true : false;
    }


    @Override
    public IBinder onBind(Intent arg0) {
        return iMqttService;
    }
    /**
     * Connectivity Lost from broker
     */
    @Override
    public void connectionLost(Throwable arg0) {
        stopKeepAlives();

        mClient = null;

        if(isNetworkAvailable()) {
            reconnectIfNecessary();
        }
    }
    /**
     * Publish Message Completion
     */
    @Override
    public void deliveryComplete(MqttDeliveryToken arg0) {

    }
    /**
     * Received Message from broker
     */
    @Override
    public void messageArrived(MqttTopic topic, MqttMessage message)
            throws Exception {
        Intent intent = new Intent(MQTT_RECE_MESSAGE_ACTION);
        intent.putExtra("Topic",topic.getName());
        intent.putExtra("Message",message.getPayload());
        localBroadcastManager.sendBroadcast(intent);
        Log.i(DEBUG_TAG,"  Topic:\t" + topic.getName() +
                "  Message:\t" + new String(message.getPayload()) +
                "  QoS:\t" + message.getQos());
    }
    /**
     * MqttConnectivityException Exception class
     */
    private class MqttConnectivityException extends Exception {
        private static final long serialVersionUID = -7385866796799469420L;
    }

    private IMqttService.Stub iMqttService = new IMqttService.Stub(){
        @Override
        public boolean mqttSubscribe(String topic,int mqttQOS)
        {
            if(isConnected()) {
                try {
                    mClient.subscribe(topic, mqttQOS);
                    return true;
                } catch (MqttException e) {
                    e.printStackTrace();
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        @Override
        public boolean mqttPubMessage(String topic,String Message,int mqttQOS)
        {
            if(isConnected())
            {
                MqttTopic mqttTopic = mClient.getTopic(topic);
                MqttMessage message = new MqttMessage(Message.getBytes());
                message.setQos(mqttQOS);
                try{
                    mqttTopic.publish(message);
                    return true;
                }
                catch (MqttException e)
                {
                    e.printStackTrace();
                    return false;
                }
            }
            else {
                return false;
            }
        }

    };
}

一、位置变化动画

  UIView.animateWithDuration(1) {

            self.viKuai.center.x = self.view.bounds.width - self.viKuai.center.x

        }

        UIView.animateKeyframesWithDuration(1, delay: 0.5, options: [], animations: {

            self.viKuai2.center.y = self.view.bounds.height - self.viKuai2.center.y
           //self.viKuai3.center.x = self.view.bounds.width - self.viKuai3.center.x
          //self.viKuai3.center.y = self.view.bounds.height - self.viKuai3.center.y

            }, completion: nil)


        UIView.animateKeyframesWithDuration(1, delay: 1, options: [], animations: {

            //self.viKuai2.center.y = self.view.bounds.height - self.viKuai2.center.y
            self.viKuai3.center.x = self.view.bounds.width - self.viKuai3.center.x
            self.viKuai3.center.y = self.view.bounds.height - self.viKuai3.center.y

            }, completion: nil)

二、透明度动画

   UIView.animateWithDuration(1) {

            self.viKuang.alpha = 0.1

        }

三、大小变化动画

   UIView.animateWithDuration(1) {

            self.viKuang.transform = CGAffineTransformMakeScale(2, 2)

        }

四，颜色变化动画

     UIView.animateWithDuration(1) {

            self.viKuang.backgroundColor = UIColor.redColor()

            self.lb.textColor = UIColor.whiteColor()

        }

五、旋转动画

 func spin(){

        print("1=====%@",NSDate.init(timeIntervalSinceNow: 0))





        UIView.animateKeyframesWithDuration(1, delay: 0, options:.CalculationModeLinear, animations: {

            self.viKuang.transform = CGAffineTransformRotate(self.viKuang.transform, CGFloat(M_PI))



            }, completion: {(finished) -> Void in

                print("2=====%@",NSDate.init(timeIntervalSinceNow: 0))

                self.spin()    

                })
    }

========点击下载代码demo========

此文主要以证书生成配置为主，实现简单推送，部分截图与内容来自于互联网,若对大家有所帮助,还请给个赞O(∩_∩)O~~。如有误，请指出，一起探讨。

一、 推送原理

Provider是指某个iPhone软件的Push服务器。APNS 是Apple Push Notification Service（Apple Push服务器）的缩写，是苹果的服务器。上图可以分为三个阶段。
* 第一阶段：Push服务器应用程序把要发送的消息、目的iPhone的标识打包，发给APNS。
* 第二阶段：APNS在自身的已注册Push服务的iPhone列表中，查找有相应标识的iPhone，并把消息发到iPhone。
* 第三阶段：iPhone把发来的消息传递给相应的应用程序， 并且按照设定弹出Push通知。

1. 应用程序注册消息推送。
2. IOS跟APNS Server要deviceToken。应用程序接受deviceToken。
3. 应用程序将deviceToken发送给PUSH服务端程序。
4. 服务端程序向APNS服务发送消息。
5. APNS服务将消息发送给iPhone应用程序。无论是iPhone客户端跟APNS,还是Provider和APNS都需要通过证书进行连接的。

二、 证书的创建

1. 创建本地请求证书文件–CertificateSigningRequest

• 钥匙串访问 –> 证书助理 –> 从证书颁发机构请求证书；
• 填写邮箱和名称（可以随意填写） –> 存储到磁盘
• 选择继续-保存至桌面即可(此文件可长期重复使用,只作为本机器的一个识别作用)

2. 进入苹果开发者网站，生成证书以及profiles

依次选择Member Center - Certificates, Identifiers &Profiles - Certificates

选择当前要设置通知的APP IDs
这里我以新建一个APP IDs为例,若公司已有项目APP IDs,则略过此步
选择右上角”+”号创建一个APPID
填写name以及Bundle ID

Bundle ID需要与Xcode里项目Bundle ID一致

勾选push notification 并完成提交
找到刚创建好的APP IDs,可以看到下面的通知选项处提示Configurable,表示证书还没配置,点击Edit进行编辑
这里看到推送证书分为2个版本,一个开发模式,一个生产模式,即我们在开发测试时使用开发模式证书,发布上线后采用生产模式证书,两个都要创建(本次只作开发模式演示,当然创建生产版证书的步骤也是一样的)
Choose File选择最开始创建在桌面的Request文件

创建证书OK后 下载到本地

开发版和生产版证书都创建好后,此时这里已经都是启用状态了。
生成XCODE使用的provisioning文件,该文件用于真机调试:

生成过程：
进入developer.apple.com，选择member center - Certificates, Identifiers & Profiles - Provisioning Profiles，然后选择创建Provisioning file，接着选择iOS App Development ，下一步选择AppId，选中之前建立的支持push的appid，接着下一步选择支持push的certificate，下一步勾选需要支持的device id，最后一步设置provisioning文件的文件名，这样provisioning文件就生成了。

3. 生成服务端使用的证书文件

• 首先双击前面保存的cer文件，此时会打开“钥匙串访问”软件，里面会出现一个Apple Development IOS push services证书，一个公用密钥和一个专用秘钥，秘钥的名称与证书助理中填写的名称一致。
• 选中证书，导出为 apns-dev-cert-development.p12 文件
• 选中专有秘钥，导出为apns-dev-key-development.p12文件
• 通过终端命令将这些文件转换为PEM格式：
• 设置密码，建议所有都为一个密码
  
openssl pkcs12 -clcerts -nokeys -out apns-dev-cert-development.pem -in apns-dev-cert-development.p12
openssl pkcs12 -nocerts -out apns-dev-key-development.pem -in apns-dev-key-development.p12

• 最后， 需要将两个pem文件合并成一个apns-dev.pem文件，此文件在连接到APNS时需要使用：
  “`
  cat apns-dev-cert-development.pem apns-dev-key-noenc-development.pem > apns-dev-development.pem

####4. 测试证书
执行下面命令：

telnet gateway.sandbox.push.apple.com 2195（apns的测试环境）
telnet gateway.push.apple.com 2195（apns的正式环境）

它将尝试发送一个规则的，不加密的连接到APNS。如果你看到下面的反馈，那说明你的MAC能够到达APNS。按下Ctrl+C关闭连接。如果得到一个错误信息，那么你需要确保你的防火墙允许2195端口，一般这里都不会出现什么问题。
![终端显示](http://upload-images.jianshu.io/upload_images/1085368-a72adc48d5be13db.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
下面我们使用生成的SSL证书和私钥来设置一个安全的链接去链接苹果服务器，执行命令如下：

openssl s_client -connect gateway.sandbox.push.apple.com:2195 -cert apns-dev-cert-development.pem -key apns-dev-key-development.pem
“`
执行之后需要输入密码，就是上面我们设置的密码即可。
如果链接是成功的，你可以随便输入一个字符，按下回车，服务器就会断开链接，如果建立连接时有问题，OpenSSL会给你返回一个错误信息。
输出结果如下，则说明是正确链接了，把上述合并的apns-dev-development.pem给服务端使用。


如果有错误，请检查是否导出正确的推送证书。

在使用AsyncHttpClient做简单的非断点上传功能时，我们要想实时检测任务的开始、结束以及进度，需要实现AsyncHttpResponseHandler，并复写其各种onXXX()方法。代码如下：

@Override
    public void onSuccess(int statusCode, Header[] headers, byte[] responseBody) {
 
    }
 
    @Override
    public void onFailure(int statusCode, Header[] headers, byte[] responseBody, Throwable error) {
 
    }
 
    @Override
    public void onProgress(long bytesWritten, long totalSize) {
 
    }
 
    @Override
    public void onCancel() {
 
    }
 
    @Override
    public void onFinish() {
 
    }
 
    @Override
    public void onRetry(int retryNo) {
 
    }
 
    @Override
    public void onStart() {
 
    }

/**
     * Fired when the request progress, override to handle in your own code
     *
     * @param bytesWritten offset from start of file
     * @param totalSize    total size of file
     */
    public void onProgress(long bytesWritten, long totalSize) {
        AsyncHttpClient.log.v(LOG_TAG, String.format("Progress %d from %d (%2.0f%%)", bytesWritten, totalSize, (totalSize > 0) ? (bytesWritten * 1.0 / totalSize) * 100 : -1));
    }

case PROGRESS_MESSAGE:
                    response = (Object[]) message.obj;
                    if (response != null && response.length >= 2) {
                        try {
                            onProgress((Long) response[0], (Long) response[1]);
                        } catch (Throwable t) {
                            AsyncHttpClient.log.e(LOG_TAG, "custom onProgress contains an error", t);
                        }
                    } else {
                        AsyncHttpClient.log.e(LOG_TAG, "PROGRESS_MESSAGE didn't got enough params");
                    }
                    break;

@Override
    final public void sendProgressMessage(long bytesWritten, long bytesTotal) {
        sendMessage(obtainMessage(PROGRESS_MESSAGE, new Object[]{bytesWritten, bytesTotal}));
    }

private void updateProgress(long count) {
        bytesWritten += count;
        progressHandler.sendProgressMessage(bytesWritten, totalSize);
    }

@Override
    public void writeTo(final OutputStream outstream) throws IOException {
        bytesWritten = 0;
        totalSize = (int) getContentLength();
        out.writeTo(outstream);
        updateProgress(out.size());
        for (FilePart filePart : fileParts) {
            filePart.writeTo(outstream);
        }
        outstream.write(boundaryEnd);
        updateProgress(boundaryEnd.length);
    }

private class FilePart {
        .
        .
        .
        public void writeTo(OutputStream out) throws IOException {
            out.write(header);
            updateProgress(header.length);
            FileInputStream inputStream = new FileInputStream(file);
            final byte[] tmp = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(tmp)) != -1) {
                out.write(tmp, 0, bytesRead);
                updateProgress(bytesRead);
            }
            out.write(CR_LF);
            updateProgress(CR_LF.length);
            out.flush();
            AsyncHttpClient.silentCloseInputStream(inputStream);
        }
    }

/**
 * Simplified multipart entity mainly used for sending one or more files.
 */

public BreakpointFileEntity(ResponseHandlerInterface progressHandler) {
        //        final StringBuilder buf = new StringBuilder();
        //        final Random rand = new Random();
        //        for (int i = 0; i < 30; i++) {
        //            buf.append(MULTIPART_CHARS[rand.nextInt(MULTIPART_CHARS.length)]);
        //        }
        //
        //        boundary = buf.toString();
        //        boundaryLine = ("--" + boundary + STR_CR_LF).getBytes();
        //        boundaryEnd = ("--" + boundary + "--" + STR_CR_LF).getBytes();
        this.progressHandler = progressHandler;
    }

private byte[] createContentType(String type) {
        String result = AsyncHttpClient.HEADER_CONTENT_TYPE + ": " + normalizeContentType(type) + STR_CR_LF;
        return result.getBytes();
    }
    private byte[] createContentDisposition(String key) {
        return (
                AsyncHttpClient.HEADER_CONTENT_DISPOSITION +
//                        ": form-data; name=\"" + key + "\"" + STR_CR_LF).getBytes();
                        ": attachment; name=\"" + key + "\"" + STR_CR_LF).getBytes();
                        //attachment; filename="Folder.jpg"
    }
    private byte[] createContentDisposition(String key, String fileName) {
        return (
                AsyncHttpClient.HEADER_CONTENT_DISPOSITION +
//                        ": form-data; name=\"" + key + "\"" +
//                        "; filename=\"" + fileName + "\"" + STR_CR_LF).getBytes();
                        ": attachment; name=\"" + key + "\"" +
                        "; filename=\"" + fileName + "\"" + STR_CR_LF).getBytes();
    }

// 修改为从指定位置开始读取
        public void writeTo(OutputStream out) throws IOException {
            
            out.write(header);
            updateProgress(header.length);
            FileInputStream inputStream = new FileInputStream(file);
            inputStream.skip(startPos);  // 从指定位置开始读
            final byte[] tmp = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(tmp)) != -1) {
                out.write(tmp, 0, bytesRead);
                updateProgress(bytesRead);
            }
            out.write(CR_LF);
            updateProgress(CR_LF.length);
            out.flush();
            AsyncHttpClient.silentCloseInputStream(inputStream);
        }

// 新增构造方法
        public FilePart(String key, File file, int startPos, String type, String customFileName) {
            header = createHeader(key, TextUtils.isEmpty(customFileName) ? file.getName() : customFileName, type);
            this.file = file;
            this.startPos = startPos;
        }

 // 新增
    public void addPart(String key, File file, int startPos, String type, String customFileName) {
        fileParts.add(new FilePart(key, file, startPos, normalizeContentType(type), customFileName));
    }

 // Add file params
//        for (ConcurrentHashMap.Entry<String, FileWrapper> entry : fileParams.entrySet()) {
//            FileWrapper fileWrapper = entry.getValue();
//            entity.addPart(entry.getKey(), fileWrapper.file, fileWrapper.contentType, fileWrapper.customFileName);
//        }
        // 新增
        for (ConcurrentHashMap.Entry<String, FileWrapper> entry : fileParams.entrySet()) {
            FileWrapper fileWrapper = entry.getValue();
            entity.addPart(entry.getKey(), fileWrapper.file, fileWrapper.startPos, fileWrapper.contentType, fileWrapper.customFileName);
        }

public static class FileWrapper implements Serializable {
        public final File file;
        public final String contentType;
        public final String customFileName;
        public final int startPos;
        public FileWrapper(File file, String contentType, String customFileName) {
            this.file = file;
            this.contentType = contentType;
            this.customFileName = customFileName;
            this.startPos = 0;
        }
        // 新增
        public FileWrapper(File file,int startPos, String contentType, String customFileName) {
            this.file = file;
            this.contentType = contentType;
            this.customFileName = customFileName;
            this.startPos = startPos;
        }
    }

/**
     * Adds a file to the request with both custom provided file content-type and file name
     *
     * @param key            the key name for the new param.
     * @param file           the file to add.
     * @param contentType    the content type of the file, eg. application/json
     * @param customFileName file name to use instead of real file name
     * @throws FileNotFoundException throws if wrong File argument was passed
     */
//    public void put(String key, File file, String contentType, String customFileName) throws FileNotFoundException {
//        if (file == null || !file.exists()) {
//            throw new FileNotFoundException();
//        }
//        if (key != null) {
//            fileParams.put(key, new FileWrapper(file, contentType, customFileName));
//        }
//    }
    // 转为断点上传准备的
    // int startPos 传输的起始位置, int fragmentLength 传输碎片的长度
    public void put(String key, File file, int startPos, String contentType, String customFileName) throws FileNotFoundException {
        if (file == null || !file.exists()) {
            throw new FileNotFoundException();
        }
        if (key != null) {
            fileParams.put(key, new FileWrapper(file, startPos, contentType, customFileName));
        }
    }

// 新增
    public void put(String key, File file, int startPos) throws FileNotFoundException {
        put(key, file, startPos, null, null);
    }

private void uploadSingleFile(final TranslistFileBean fileBean, final String startPos) {
        String token = ExitApplication.getInstance().getToken();
        AsyncHttpClient client = new AsyncHttpClient();
        String url = ControlEasyHttpUtils.getBaseUrlNoV1() + "upload?_token=" + token + "&folder_id=" + fileBean.getFolderId();
        BreakpointRequestParams params = new BreakpointRequestParams();
        File file = new File(fileBean.getPath());
        try {
            params.put("file", file, Integer.parseInt(startPos));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        // 不加这一段文件名字会变乱码
        String encode = null;
        try {
            encode = URLEncoder.encode(fileBean.getName(), "UTF-8");
            encode = encode.replace("+", "%20"); //  把转码后的+好还原为空格
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        // 添加请求头
        client.addHeader("Content-Length", (file.length() - Integer.parseInt(startPos)) + "");
        client.addHeader("Content-Disposition", "attachment;filename=\"" + encode + "\"");
        client.addHeader("Session-ID", fileBean.getSession_id());
        client.addHeader("X-Content-Range", "bytes " + startPos + "-" + (file.length() - 1) + "/" + (file.length()));
        client.addHeader("Content-Type", "application/octet-stream");  
        BreakpointAsyncHttpResponseHandler responseHandler = new BreakpointAsyncHttpResponseHandler(mContext, fileBean);
        // 设置 到了该获取加密进度的时候的监听
        responseHandler.setTime2GetPackPersentListener(this);
        RequestHandle requestHandle = client.post(mContext, url, params, responseHandler);
        //把 上传线程 添加到全局map变量中，或者替换原来的
        ExitApplication.getInstance().mCancelableMap.put(fileBean, requestHandle);
    }

// 修改为从指定位置开始读取
        public void writeTo(OutputStream out) throws IOException {
            // 这里如果不把header去掉的话，就会将头部一些信息写入到文件开头里，造成文件损坏！
//            out.write(header);
//            updateProgress(header.length);
            FileInputStream inputStream = new FileInputStream(file);
            inputStream.skip(startPos);  // 从指定位置开始读
            final byte[] tmp = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(tmp)) != -1) {
                out.write(tmp, 0, bytesRead);
                updateProgress(bytesRead);
            }
            out.write(CR_LF);
            updateProgress(CR_LF.length);
            out.flush();
            AsyncHttpClient.silentCloseInputStream(inputStream);
        }

标题有没有很标题党的样子？
实际上这篇文章改编自我对数据结构链表的笔记，只是我没有想到，当我想要用 Swift 来实现链表的时候，会发生这些有趣的事情。同时还让我对面向协议编程做了一次实践。
于是就有了这么一个唬人的标题，因为实际上我想复习的是链表，只是不小心发现了新大陆。我想这就跟 Bug 差不多，当你解决一个 Bug, 就会产生更多的 Bug.
程序员的生活就是有趣……

C 数据结构 – 线性表 之 链表

先复习一下链表吧，不然我总感觉不务正业。

• 定义: 由同类型数据元素构成的有序序列线性结构。
  
  • 长度: 表中元素的个数
  • 空表: 没有元素的时候
  • 表头: 起始位置
  • 表尾: 结束位置
• 常用操作
  
  • 初始化一个空表: List MakeEmpty()
  • 计算长度: int Length(List L)
  • 返回某个元素: ElementType FindK(int K, List L)
  • 查找元素位置: int Find(ElementType X, list L)
  • 插入元素: void Insert(ElementType X, int i, List L)
  • 删除某个元素: void Delete(int i, List L)
• 实现方式
  
  • 数组
  • 链表

代码实现

据说一言不合就丢代码是一个程序员的好习惯。总之对这部分没有兴趣的同学可以跳过她，这只是很普通的链表实现，如果你学过数据结构，你就肯定不会陌生。

#include <stdio.h>
#include <stdlib.h>

#define Type int

// MARK: - 线性表 (链表 ChainList)

/// 链表结构
typedef struct ChainListNode {
    Type data;
    struct ChainListNode *next;
} ChainList;

/// 创建空链表初始值为 -1
ChainList *chainListInit() {
    ChainList *list = (ChainList *)malloc(sizeof(ChainList));
    list->data = -1;
    list->next = NULL;
    return list;
}

/// 计算链表长度
int chainListLength(ChainList *list) {
    ChainList *p = list;
    int i = 0;
    while (p) {
        p = p->next;
        i++;
    }
    return i;
}

/// 根据序号查找链表节点，序号从 0 开始
ChainList *chainListFindWithIndex(int index, ChainList *list) {
    ChainList *p = list;
    int i = 0;
    while (p != NULL && i < index) {
        p = p->next;
        i++;
    }
    return p;
}

/// 根据值查找链表节点
ChainList *chainListFindWithData(Type data, ChainList *list) {
    ChainList *p = list;
    while (p != NULL && p->data != data) {
        p = p->next;
    }
    return p;
}

/// 插入: 新建节点; 查找到插入节点的上一个节点; 新节点指向下一个节点; 上一个节点指向新节点。
ChainList *chainListInsert(Type data, int index, ChainList *list) {
    ChainList *p, *n;

    // 在头结点处插入
    if (index == 0) {
        n = (ChainList *)malloc(sizeof(ChainList));
        n->data = data;
        n->next = list;
        return n;
    }

    // 获取插入位置
    p = chainListFindWithIndex(index, list);
    if (p == NULL) {
        return NULL;
    }

    // 插入
    n = (ChainList *)malloc(sizeof(ChainList));
    n->data = data;
    n->next = p->next;
    p->next = n;
    return list;
}

/// 删除节点: 找到前一个节点; 获取删除节点; 前一个节点指向后一个节点; 释放删除节点
ChainList *chainListDelete(int index, ChainList *list) {
    ChainList *p, *d;

    // 如果列表为空
    if (list == NULL) {
        return NULL;
    }

    // 删除头元素
    if (index == 0) {
        p = list->next;
        free(list);
        return p;
    }

    // 查找删除元素的上一个位置
    p = chainListFindWithIndex(index - 1, list);
    if (p == NULL) {
        return NULL;
    }

    // 删除
    d = p->next;
    p->next = d->next;
    free(d);
    return list;
}

Swift 面向协议编程

开了那么大篇幅才讲到重点，如果我的职业是编辑的话，估计连睡大街都会被别的小编嫌碍眼。幸运的是，我是个程序员……一步步来是很重要的。

我使用泛型协议来定义了链表。并且使用协议扩展来实现关于链表的常用操作。这样只要任意一个类遵从该协议就可以自动获得这些实现而不需要进行额外的操作。(在我第一次感受到这个特性的强大时，内心被满满的 awesome 刷屏。如果你有我的博客的话，可以在上面看到我利用这个特性实现了 Notify 协议，只要在类声明上添加一下这个协议就可以自动获得一些非常建议的消息发送和接收功能。)

由于语言特性的不同，这个链表跟传统的链表有所不同。你应该通过一个指向头结点的 optional 变量来操作链表，当变量为 nil 时链表为空。

我在代码中除了实现该协议，还写了一个遵从该协议的类作为示例，并有它的调用方法。欢迎吐槽。

// MARK: - 线性表

/* 
在这个泛型协议中，我定义了一个准守 Equatable 协议的泛型 Element, 这是为了后面按值查找的时候可以直接使用等号进行判断。
但实际上这并不是一种聪明的做法，在进行判断的时候完全可以使用闭包来进行处理，这样就能获取更多的类型支持。这里只是为了能表现泛型类型约束的用法，才就这样做。
协议后面的 class 表示这个协议只能被 class 遵从，这种约束是必要的，如果你想使用 struct 类型来实现链表，不是说不可以，但这明显不是一个适用值拷贝场景的地方。
*/
protocol ChainList: class {
    associatedtype Element: Equatable
    var data: Element { get set }
    var next: Self? { get set }
    init()
}

extension ChainList {

    /// 返回当前节点到链表结尾的长度
    var length: Int {
        var i = 1
        var p: Self? = self
        while p?.next != nil {
            p = p?.next
            i += 1
        }
        return i
    }

    /// 查找元素
    subscript(index: Int) -> Self? {
        var i = 0
        var p: Self? = self
        while p != nil && i < index {
            p = p?.next
            i += 1
        }
        return p
    }

    /// 通过值来查找元素
    func find(value: Element) -> Self? {
        var p: Self? = self
        while p != nil && value != p?.data {
            p = p?.next
        }
        return p
    }

    /// 插入元素
    @discardableResult func insert(value: Element, to: Int) -> Self? {
        if to == 0 {
            let node  = Self.init()
            node.data = value
            node.next = self
            return node
        }

        if let pre = self[to - 1] {
            let node  = Self.init()
            node.data = value
            node.next = pre.next
            pre.next  = node
            return self
        }

        return nil
    }

    /// 删除元素
    @discardableResult func delete(index: Int) -> Self? {
        if index == 0 {
            return self.next
        }

        if let pre = self[index - 1] {
            pre.next = pre.next?.next
            return self
        }

        return nil
    }

}

// MARK: - 使用示例

/*
遗憾的是，由于协议当中使用了 Self 类型，所以遵从这个协议的类不得不设置为 final。也就是无法继承了。
*/
final class List: ChainList {
    typealias Element = String
    var data: List.Element = ""
    var next: List?
    required init() { }
}

var top: List? = List()
top?.data = "0"

for i in 1 ..< 5 {
    let _ = top?.insert(value: "\(i)", to: i)
}

if let length = top?.length {
    for i in 0 ..< length {
        print(top?[i]?.data)
    }

    for _ in 0 ..< length-1 {
        let _ = top?.delete(index: 1)
    }
}

print("Tag")

if let length = top?.length {
    for i in 0 ..< length {
        print(top?[i]?.data)
    }
}

print("Done")

/* 打印输出

Optional("0")
Optional("1")
Optional("2")
Optional("3")
Optional("4")
Tag
Optional("0")
Done
Program ended with exit code: 0

 */

如果你看到这里了，那说明你居然坚持看完了…… awesome ….
我相信你此刻的内心会有一个疑惑，为什么不直接用一个数组呢？Swift 的数组完美的解决了链表所需要解决的问题。是的，之所以这么做，原因只是 because we can …

观察者模式（从放弃到入门）

今天分享第二个模式，观察者模式。相信作Android开发或者Java开发的童鞋都听说过这个模式，而且有很多流行的框架都是使用了观察者模式，例如著名的RxJava。而且Java中直接就自带了观察者模式，可见它有多常用。

然后文中的例子也是来自 Head First 设计模式，很棒的一本书，推荐大家看看。

废话不多说了，直接上需求：

需求1：错误示范

系统中有3个东东：气象站（温度，湿地，气压等），WeatherData对象（获取各种消息的变化），广告板（显示变化）。直接上一张书上的图好了：

注意一定，公告板只是一种展示，可能还有其他功能的公告板，获取相同的数据，但是做不同的处理。图中是做目前的状态展示，还可能有气候统计，天气预测等。
意思就是说：我们可以将 WeatherData对象看作一个消息的来源，它的各项参数会不停的变化，他的每一次变化，都需要通知广告板做出相应的处理。

那么最简单的设计就来了，既然后很多公告板，那么我的WeatherData对象中，存放他们的引用，然后当我的值变化的时候，依次调用公告板的change() 函数通知变化不久搞定了。代码如下：

WeatherData .java

public class WeatherData {

    CurrentConditionDisplay cDisplay;
    StaticsDisplay sDisplay;
    ForecastDisplay fDisplay;

    public WeatherData(){
        cDisplay = new CurrentConditionDisplay();
        sDisplay = new StaticsDisplay();
        fDisplay = new ForecastDisplay();
    }

    // 冲气象站获取到数据时执行更新
    public void measurementsChanged(){
        double temp = getTemperature();
        double humidity = getHumidity();
        double pressure = getPressure();

        cDisplay.update(temp, humidity, pressure);
        sDisplay.update(temp, humidity, pressure);
        fDisplay.update(temp, humidity, pressure);
    }

    public float getTemperature(){
        //TODO: 冲气象站获取温度
        return 1.0f;
    }

    public float getHumidity(){
        //TODO: 冲气象站获取湿度
        return 2.0f;
    }

    public float getPressure(){
        //TODO: 冲气象站获取气压
        return 3.0f;
    }
}

其他代码都不用看，我们关注measurementsChanged() 方法，通过 getXXX() 方法获取到变化之后，通知本类中的3个广告板对象调用 update(…) 方法，做出相应的更新。

IUpdate.java

public interface IUpdate {
    void update(double temp, double humidity, double presure);
}

ForecastDisplay.java

public class ForecastDisplay implements IUpdate{
    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing forecast work:"+temp+","+humidity+","+presure);
    }

}

StaticsDisplay.java

public class StaticsDisplay implements IUpdate{

    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing statics work:"+temp+","+humidity+","+presure);
    }
}

CurrentConditionDisplay .java

public class CurrentConditionDisplay implements IUpdate{

    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing current work:"+temp+","+humidity+","+presure);
    }
}

客户端调用：
Main.java

public class Main {

    public static void main(String[] args) {
        WeatherData wd = new WeatherData();
        wd.measurementsChanged();
    }
}

输出

I doing current work:1.0,2.0,3.0
I doing statics work:1.0,2.0,3.0
I doing forecast work:1.0,2.0,3.0

首先必须说，这样写问题真是太大了：

1. 没有面相接口编程的思想（WeatherData类中直接使用CurrentConditionDisplay ，其实可以使用 IUpdate接口
2. 如果还有新的广告板，需要修改WeatherData
3. 如果通知的信号（温度，湿度，气压）再增加一个风力，那么IUpdate需要修改，所有的广告版都需要修改。

需求2：观察者模式

先上一张图：

现在我们要解决上面的3个问题：

认识观察者模式

在上面的示范中，我们其实可以看作，广告板（观察者Observer），时刻关注着 WeatherData （主题Subject） 的变化，如果有变化，则通知广告板更新。看看代码：

首先提供主题和观察者两个接口：

ISubject.java

public interface ISubject {
    void registObserver(IObserver o);
    void removeObserver(IObserver o);
    void notifyObservers();
}

IObserver .java

public interface IObserver {
    public void update(double temp, double humidity, double pressure);
}

WeatherData.java

public class WeatherData implements ISubject {
    private Set<IObserver> observers = new HashSet<IObserver>();

    double temp;
    double humidity;
    double pressure;

    public void registObserver(IObserver o) {
        observers.add(o);
    }

    public void removeObserver(IObserver o) {
        observers.remove(o);
    }

    public void notifyObservers() {
        for (IObserver o : observers) {
            o.update(temp, humidity, pressure);
        }
    }

    public void mesurementsChanged(double temp, double humidity, double pressure) {
        this.temp = temp;
        this.humidity = humidity;
        this.pressure = pressure;

        notifyObservers();
    }
}

用一个 Set observers 来装所有关注这个Subject的观察者，在 mesurementsChanged() 中先更新自己的数据，然后通知所有观察者并做出反应。

CurrentConditionDisplay.java

public class CurrentConditionDisplay implements IObserver{

    private ISubject weatherData;

    public CurrentConditionDisplay(ISubject weatherData){
        this.weatherData = weatherData;
        weatherData.registObserver(this);
    }

    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing current work:"+temp+","+humidity+","+presure);
    }
}

ForecastDisplay.java

public class ForecastDisplay implements IObserver{

    private ISubject weatherData;

    public ForecastDisplay(ISubject weatherData){
        this.weatherData = weatherData;
        weatherData.registObserver(this);
    }

    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing forecast work:"+temp+","+humidity+","+presure);
    }
}

StaticsDisplay.java

public class StaticsDisplay implements IObserver{

    private ISubject weatherData;

    public StaticsDisplay(ISubject weatherData){
        this.weatherData = weatherData;
        weatherData.registObserver(this);
    }

    public void update(double temp, double humidity, double presure) {
        System.out.println("I doing statics work:"+temp+","+humidity+","+presure);
    }
}

3个广告板类，每个包含一个要观察的主题，在初始化时添加要观察的主题，并将自己添加到主题的观察者列表中。

客户端调用：

Main.java

public class Main {

    public static void main(String[] args) {

        WeatherData weatherData = new WeatherData();

        IObserver cDisplay = new CurrentConditionDisplay(weatherData);
        IObserver sDisplay = new StaticsDisplay(weatherData);
        IObserver fDisplay = new ForecastDisplay(weatherData);

        weatherData.mesurementsChanged(1.0, 2.0, 3.0);
    }
}

改进的地方：

1. 首先现在 WeatherData 可以添加任意多个观察者
2. 主题和观察者解耦，类中保持的是接口对象。
3. 观察主题的具体内容解耦了，WeatherData获取的信息，和Observer关心的数据分开。（简单的说就是，如果另外一种Observer之关心温度，也可是使用WeatherData，只是update方法不一样就可以了），但是也有不足指出，因为数据是由IObserver中的update方法决定的，这里感觉还可以改进。

需求3：Java中自带的观察者模式

Java 的 java.util包 中自带了 Observer接口和Observable类和我们前面的 Subject接口和Observer接口很像。

我们来看看使用Java的观察者模式，重写上面的例子：

WeatherData.java

public class WeatherData extends Observable {

    private double temperature;
    private double humidity;
    private double pressure;

    public WeatherData() {
    }

    public void measurementsChanged() {
        setChanged();
        notifyObservers();
    }

    public void setMeasurements(double temperature, double humidity,
            double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;

        measurementsChanged();
    }

    public double getTemperature() {
        return temperature;
    }

    public double getHumidity() {
        return humidity;
    }

    public double getPressure() {
        return pressure;
    }
}

主要修改了几个地方：
1. 继承自Observable，等下讲完，我们来看看Observable里面写了什么。
2. setMeasurements()还是更新数据，然后调用notifyObservers()通知所有注册的Observer修改数据。所以我们应该关注 Observerable类中的两个方法：update() 和 notifyObservers()

CurrentConditionDisplay.java

public class CurrentConditionDisplay implements Observer {

    private Observable observable;

    public CurrentConditionDisplay(Observable observable) {
        this.observable = observable;
        observable.addObserver(this);
    }

    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData wd = (WeatherData) o;
            display(wd.getTemperature(), wd.getHumidity(), wd.getPressure());
        }
    }

    public void display(double temp, double humidity, double presure) {
        System.out.println("I doing current work:" + temp + "," + humidity
                + "," + presure);
    }
}

修改的地方：
1. 与之前一样，首先还是在构造方法中添加 主题对象，并注册自己。
2. 然后看我们重写的方法 void update(Observable o, Object arg)，先判断发送update消息的主题对象是不是WeatherData，然后从主题中获取并更新数据。

思考

至于调用和之前一样，看到这里有些童鞋可能看出一掉猫腻，我们在需求2中最后提到，我们关心的消息是由 IObserver中的update 方法中的具体参数决定的，不够完善。但是这里呢？完全跟参数无关，到底从 WeatherData 中获取什么数据，可以任意获取。

我们还可以做一定的解耦，就是说 WeatherData 这个主题现在提供3种数据，但是我们完全可以将3中数据分开为3个主题，然后所有的观察者都关心自己的数据，而不需要通过WeatherData 同时获取3中数据。至于 update 中我们就需要判断 到底是 TemperatureData, HumidityData，还是 PressureData，将关心的消息也解耦了，不知道你理解没有。

源码Observable ， Observer 解析

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }


    public void notifyObservers() {
        notifyObservers(null);
    }


    public void notifyObservers(Object arg) {

        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }


    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }


    protected synchronized void setChanged() {
        changed = true;
    }


    protected synchronized void clearChanged() {
        changed = false;
    }


    public synchronized boolean hasChanged() {
        return changed;
    }


    public synchronized int countObservers() {
        return obs.size();
    }
}

为了节省篇幅，我狠心的把注释全删掉了，其实有很多注释的。

如果前面的内容都理解的童鞋，看这个代码也应该很好理解。套路一样，但是有一些点我们应该注意：

1. 有 addObserver(), deleteObserver()添加和删除观察者对象
2. 代码中用一个 changed 关键字来表示是否有改变，在发送改变前我们需要先使用setChanged()将其设置为true。 在 notifyObservers()之后自动调用 clearChanged() 恢复 changed 为false。所以不需要我们自己来重置。
3. 我们应该注意所有的方法都是 synchronized 的，而且存储观察者对象的集合类也是 Vector obs，所以整个 Observable 都是线程安全的。

还需要看一下 Observer 接口吗？

public interface Observer {
    void update(Observable o, Object arg);
}

确实精简，只有一个 update 方法。看看 Obsererable 对象中的 notifyObservers 方法 调用的 update：

 ((Observer)arrLocal[i]).update(this, arg);

对没错，就是这样调用的。

一些体会

感觉设计模式确实很有意思，但是上大学的时候，我们居然没有看这门课，我的天！！这个例子完整的结合了书本，自己的思考，以及Java的源码，感觉写下来我自己也受益匪浅。

GCD:Grand Central Dispatch(GCD) 是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的，因此可以统一管理，也可执行任务，这样就比以前的线程更有效率。

1 Dispatch Queue

“Dispatch Queue”是什么，如其名称所示，是执行处理的等待队列。Dispatch Queue 按照追加的顺序执行处理。先进先出FIFO，first－in－first－out。

队列类型：

1 Serial Dispatch Queue    等待现在执行处理结束

2 Concurrent Dispatch Queue  不等待现在执行处理结束

比较两种Dispatch Queue。

dispatch_sync(queue,block1);
dispatch_sync(queue,block2);
dispatch_sync(queue,block3);
dispatch_sync(queue,block4);
dispatch_sync(queue,block5);
dispatch_sync(queue,block6);

block1 －> block2－> block3－> block4－> block5－> block6

当queue为Concurrent Dispatch Queue时，首先执行block1，不管block1是否结束，都开始执行后面的block2，不管block2是否结束，都开始执行block3，如此重复循环。（同时执行的处理数量取决于当前系统的状态。）

创建方式

第一种方式：dispatch_queue_create

// 创建串行队列    <span style="font-family: Arial, Helvetica, sans-serif;">DISPATCH_QUEUE_SERIAL = NULL</span>
    dispatch_queue_t queue = dispatch_queue_create("com.baidu.queue", DISPATCH_QUEUE_SERIAL);

// 1.创建一个并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.baidu.queue", DISPATCH_QUEUE_CONCURRENT);

当生成多个Serial Dispatch Queue时，虽然在一个Serial Dispatch Queue中同时只能执行一个追加处理，但多个Serial Dispatch Queue之间可以并行执行。

通过dispatch_queue_create 函数生成的Dispatch Queue，在使用结束后需要释放。

//释放
dispatch_release(queue);

第二种方式：获取系统标准提供的Dispatch Queue。

Main Dispatch Queue，是在主线程中执行的Dispatch Queue，属于Serial Dispatch Queue。

// 1.获得主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();

Global Dispatch Queue是ConCurrent Dispatch Queue。所有应用程序都可以使用，没有必要通过dispatch_queue_create函数逐个生成Concurrent Dispatch Queue。

// 1.获得全局的并发队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

#define DISPATCH_QUEUE_PRIORITY_HIGH 2
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN

2 执行任务方式

GCD有两种方法执行任务。

1 同步的方式执行任务

dispatch_sync(dispatch_queue_t queue,dispatch_block_t block);

2 异步的方式执行任务

dispatch_async(dispatch_queue_t queue,dispatch_block_t block);

同步和异步的区别

同步：只能在当前线程中执行任务，不具备开启新线程的能力

异步：可以在新的线程中执行任务，具备开启新线程的能力

串行队列  同步函数

/**
 * 串行队列 + 同步函数：不会开启新的线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务
 */
-(void)syncSerial{
    NSLog(@"syncSerial ----- begin");
    //创建串行队列 serial
    dispatch_queue_t serialQueue = dispatch_queue_create("com.vn.serial", NULL);
    dispatch_sync(serialQueue, ^{
        NSLog(@"1...sync....%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"2...sync....%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"3...sync....%@",[NSThread currentThread]);
    });
    NSLog(@"syncSerial ----- end");
}

2016-10-19 15:36:43.810 GCD基本使用[9712:1396171] syncSerial ----- begin
2016-10-19 15:36:43.810 GCD基本使用[9712:1396171] 1...sync....<NSThread: 0x60000006bd40>{number = 1, name = main}
2016-10-19 15:36:43.811 GCD基本使用[9712:1396171] 2...sync....<NSThread: 0x60000006bd40>{number = 1, name = main}
2016-10-19 15:36:43.811 GCD基本使用[9712:1396171] 3...sync....<NSThread: 0x60000006bd40>{number = 1, name = main}
2016-10-19 15:36:43.811 GCD基本使用[9712:1396171] syncSerial ----- end

串行队列 异步函数

/**
 * 串行队列 + 异步函数 ：会开启新的线程，但是任务是串行的，执行完一个任务，再执行下一个任务
 */
-(void)asyncSerial{
    NSLog(@"asyncSerial ----- begin");
    //创建串行队列 serial
    dispatch_queue_t serialQueue = dispatch_queue_create("com.vn.serial", NULL);
    dispatch_async(serialQueue, ^{
        NSLog(@"1...async....%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"2...async....%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"3...async....%@",[NSThread currentThread]);
    });
    NSLog(@"asyncSerial ----- end");
}

打印：

2016-10-19 15:38:55.354 GCD基本使用[9730:1397289] asyncSerial ----- begin
2016-10-19 15:38:55.354 GCD基本使用[9730:1397289] asyncSerial ----- end
2016-10-19 15:38:55.354 GCD基本使用[9730:1397758] 1...async....<NSThread: 0x608000070d40>{number = 3, name = (null)}
2016-10-19 15:38:55.355 GCD基本使用[9730:1397758] 2...async....<NSThread: 0x608000070d40>{number = 3, name = (null)}
2016-10-19 15:38:55.355 GCD基本使用[9730:1397758] 3...async....<NSThread: 0x608000070d40>{number = 3, name = (null)}

主队列  同步函数

/**
 * 主队列 ＋ 同步函数： 死锁，不应该这样使用
 */
- (void)syncMain{
    NSLog(@"syncMain ----- begin");
    // 1.获得主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_sync(mainQueue, ^{
        NSLog(@"1--syncMain---%@", [NSThread currentThread]);
    });
    NSLog(@"syncMain ----- end");
}

syncMain ----- begin

主队列 异步函数

/**
 * 主队列 ＋ 异步函数： 在主线程中执行任务,不会阻塞主线程。任务是串行的，执行完一个任务，再执行下一个任务
 */
- (void)asyncMain{
    NSLog(@"asyncMain ----- begin");
    // 1.获得主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_async(mainQueue, ^{
        NSLog(@"1--asyncMain---%@", [NSThread currentThread]);
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"2--asyncMain---%@", [NSThread currentThread]);
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"3--asyncMain---%@", [NSThread currentThread]);
    });
    NSLog(@"asyncMain ----- end");
}

2016-10-19 15:39:56.747 GCD基本使用[9750:1398368] asyncMain ----- begin
2016-10-19 15:39:56.748 GCD基本使用[9750:1398368] asyncMain ----- end
2016-10-19 15:39:56.748 GCD基本使用[9750:1398368] 1--asyncMain---<NSThread: 0x60000006ab80>{number = 1, name = main}
2016-10-19 15:39:56.753 GCD基本使用[9750:1398368] 2--asyncMain---<NSThread: 0x60000006ab80>{number = 1, name = main}
2016-10-19 15:39:56.753 GCD基本使用[9750:1398368] 3--asyncMain---<NSThread: 0x60000006ab80>{number = 1, name = main}

并行队列 同步函数

/**
 * 并发队列 ＋ <span style="font-family: Arial, Helvetica, sans-serif;">同步函数</span><span style="font-family: Arial, Helvetica, sans-serif;">：不会开启新的线程，由于不开启新线程，需要等待执行完，所以任务执行完一个，再执行下一个。</span>
 */
- (void)syncConcurrent{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1--syncConcurrent---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2--syncConcurrent---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3--syncConcurrent---%@", [NSThread currentThread]);
    });
    NSLog(@"syncConcurrent--------end");
}

2016-10-19 15:52:30.536 GCD基本使用[9790:1404534] syncConcurrent--------begin
2016-10-19 15:52:30.536 GCD基本使用[9790:1404534] 1--syncConcurrent---<NSThread: 0x60000006b140>{number = 1, name = main}
2016-10-19 15:52:30.536 GCD基本使用[9790:1404534] 2--syncConcurrent---<NSThread: 0x60000006b140>{number = 1, name = main}
2016-10-19 15:52:30.537 GCD基本使用[9790:1404534] 3--syncConcurrent---<NSThread: 0x60000006b140>{number = 1, name = main}
2016-10-19 15:52:30.537 GCD基本使用[9790:1404534] syncConcurrent--------end

并行队列 异步函数

/**
 * 并发队列 + 异步函数：可以同时开启多条线程
 */
- (void)asyncConcurrent{
    NSLog(@"asyncConcurrent--------begin");
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.将任务加入队列
    dispatch_async(queue, ^{
        NSLog(@"1--asyncConcurrent---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2--asyncConcurrent---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"3--asyncConcurrent---%@", [NSThread currentThread]);
    });
    NSLog(@"asyncConcurrent--------end");
}

2016-10-19 15:55:34.637 GCD基本使用[9820:1406397] asyncConcurrent--------begin
2016-10-19 15:55:34.637 GCD基本使用[9820:1406397] asyncConcurrent--------end
2016-10-19 15:55:34.637 GCD基本使用[9820:1406608] 1--asyncConcurrent---<NSThread: 0x600000069e00>{number = 3, name = (null)}
2016-10-19 15:55:34.637 GCD基本使用[9820:1406613] 2--asyncConcurrent---<NSThread: 0x608000077a00>{number = 4, name = (null)}
2016-10-19 15:55:34.637 GCD基本使用[9820:1406614] 3--asyncConcurrent---<NSThread: 0x600000072680>{number = 5, name = (null)}

3 线程间通信

dispatch_async(dispatch_get_main_queue(), ^{//});

- (void)threadCommunication{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];
        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];
        // 生成图片
        UIImage *image = [UIImage imageWithData:data];
        // 回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
    });
}

4 延时

// 延时追加
- (void)delay{
    NSLog(@"delay-----begin");
    //延时1s
    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
    dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"after------%@",[NSThread currentThread]);
    });
    NSLog(@"delay-----end");
}

2016-10-19 16:35:45.680 GCD基本使用[9932:1427078] delay-----begin
2016-10-19 16:35:45.680 GCD基本使用[9932:1427078] delay-----end
2016-10-19 16:35:46.752 GCD基本使用[9932:1427078] after------<NSThread: 0x6000000635c0>{number = 1, name = main}

其中dispatch_time(DISPATCH_TIME_NOW,1ull*NSEC_PER_SEC);表示从现在开始1s后时间的值。

DISPATCH_TIME_NOW   表示当前的时间。
第二个参数单位为纳秒。

#define NSEC_PER_SEC 1000000000ull  //每秒有多少纳秒
#define NSEC_PER_MSEC 1000000ull    //每毫秒有多少纳秒
#define USEC_PER_SEC 1000000ull     //每秒有多少微秒
#define NSEC_PER_USEC 1000ull       //每微秒有多少纳秒

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
dispatch_time_t time1 = dispatch_time(DISPATCH_TIME_NOW, 1000ull*NSEC_PER_MSEC);
dispatch_time_t time2 = dispatch_time(DISPATCH_TIME_NOW, 1000ull*USEC_PER_SEC);

5 Dispatch Group

开发中会有这种需求，执行多个任务，只有这几个任务都执行完成后才执行最终任务。这种情况可以使用Dispatch Queue。

- (void)group{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 创建一个队列组
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        for (int i=0; i<5; i++) {
            NSLog(@"任务1-－－－－－－%d",i);
        }
    });
    dispatch_group_async(group, queue, ^{
        for (int i=0; i<5; i++) {
            NSLog(@"任务2-－－－－－－%d",i);
        }
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"end.....");
    });
}

2016-10-19 18:05:56.138 GCD基本使用[10052:1471672] 任务1-－－－－－－0
2016-10-19 18:05:56.138 GCD基本使用[10052:1471674] 任务2-－－－－－－0
2016-10-19 18:05:56.139 GCD基本使用[10052:1471674] 任务2-－－－－－－1
2016-10-19 18:05:56.139 GCD基本使用[10052:1471672] 任务1-－－－－－－1
2016-10-19 18:05:56.139 GCD基本使用[10052:1471674] 任务2-－－－－－－2
2016-10-19 18:05:56.139 GCD基本使用[10052:1471672] 任务1-－－－－－－2
2016-10-19 18:05:56.139 GCD基本使用[10052:1471674] 任务2-－－－－－－3
2016-10-19 18:05:56.139 GCD基本使用[10052:1471672] 任务1-－－－－－－3
2016-10-19 18:05:56.139 GCD基本使用[10052:1471674] 任务2-－－－－－－4
2016-10-19 18:05:56.139 GCD基本使用[10052:1471672] 任务1-－－－－－－4
2016-10-19 18:05:56.139 GCD基本使用[10052:1471672] end....

6 dispatch_barrier_async

在访问数据库或文件时，写入处理确实不可与其他的写入处理以及其他包含读写的处理并行执行。但是读取处理只是和读取处理并行执行就不会发生问题。

为了高效的进行访问，读取处理追加到Concurrent Dispatch Queue中，写入处理在一个读取都没有的情况下，追加到Serial Dispatch Queue中可。利用Dispatch Group和dispatch_set_target_queue也可以实现，但是会很复杂。

GCD提供了简便方法——dispatch_barrier_async函数。

- (void)barrier{
    dispatch_queue_t queue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"----1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----2-----%@", [NSThread currentThread]);
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----3-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----4-----%@", [NSThread currentThread]);
    });
}

2016-10-19 19:18:30.739 GCD基本使用[10096:1490892] ----2-----<NSThread: 0x600000073d40>{number = 4, name = (null)}
2016-10-19 19:18:30.739 GCD基本使用[10096:1490890] ----1-----<NSThread: 0x608000075300>{number = 3, name = (null)}
2016-10-19 19:18:30.740 GCD基本使用[10096:1490890] ----barrier-----<NSThread: 0x608000075300>{number = 3, name = (null)}
2016-10-19 19:18:30.740 GCD基本使用[10096:1490890] ----3-----<NSThread: 0x608000075300>{number = 3, name = (null)}
2016-10-19 19:18:30.740 GCD基本使用[10096:1490892] ----4-----<NSThread: 0x600000073d40>{number = 4, name = (null)}

7 dispatch_apply

- (void)apply{
    NSLog(@"apply------begin");
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //该函数按指定的次数 将block追加到Dispatch Queue中。并等待全部处理执行结束。
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"apply------%zu",index);
    });
    NSLog(@"apply------end");
}

2016-10-19 19:45:19.186 GCD基本使用[10114:1500525] apply------begin
2016-10-19 19:45:19.187 GCD基本使用[10114:1500525] apply------1
2016-10-19 19:45:19.187 GCD基本使用[10114:1500833] apply------0
2016-10-19 19:45:19.187 GCD基本使用[10114:1500837] apply------2
2016-10-19 19:45:19.187 GCD基本使用[10114:1500838] apply------3
2016-10-19 19:45:19.187 GCD基本使用[10114:1500525] apply------4
2016-10-19 19:45:19.187 GCD基本使用[10114:1500833] apply------5
2016-10-19 19:45:19.187 GCD基本使用[10114:1500837] apply------6
2016-10-19 19:45:19.187 GCD基本使用[10114:1500838] apply------7
2016-10-19 19:45:19.188 GCD基本使用[10114:1500525] apply------8
2016-10-19 19:45:19.188 GCD基本使用[10114:1500833] apply------9
2016-10-19 19:45:19.188 GCD基本使用[10114:1500525] apply------end

dispatch_apply([array count]，queue,^(size_t index){});

由于dispatch_apply函数与dispatch_sync相同，会等待处理执行结束，因此推荐在dispatch_async函数中异步执行dispatch_apply函数。

- (void)apply1{
    NSLog(@"apply1------begin");
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, ^{
        dispatch_apply(5, queue, ^(size_t index) {
            NSLog(@"apply------%zu",index);
        });
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"done");
        });
    });
    NSLog(@"apply1------end");
}

2016-10-19 20:26:16.245 GCD基本使用[10143:1518627] apply1------begin
2016-10-19 20:26:16.246 GCD基本使用[10143:1518627] apply1------end
2016-10-19 20:26:16.246 GCD基本使用[10143:1518924] apply------0
2016-10-19 20:26:16.246 GCD基本使用[10143:1518928] apply------1
2016-10-19 20:26:16.246 GCD基本使用[10143:1518929] apply------2
2016-10-19 20:26:16.246 GCD基本使用[10143:1518930] apply------3
2016-10-19 20:26:16.246 GCD基本使用[10143:1518924] apply------4
2016-10-19 20:26:16.251 GCD基本使用[10143:1518627] done

8 dispatch_once

dispatch_once 函数保证应用程序中只执行一次。

- (void)once{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"------run");
    });
}

为了让界面可以在平板上更好地展示，Android在3.0版本引入了Fragment(碎片)功能。

首先需要注意，Fragment是在3.0版本引入的，如果你使用的是3.0之前的系统，需要先导入android-support-v4的jar包才能使用Fragment功能。

①静态创建Fragment

这是使用Fragment最简单的一种方式，把Fragment当成普通的控件，直接写在Activity的布局文件中。步骤：

1、继承Fragment，重写onCreateView决定Fragemnt的布局

2、在Activity中声明此Fragment，就当和普通的View一样

就是把Fragment当成普通的View一样声明在Activity的布局文件中，然后所有控件的事件处理等代码都由各自的Fragment去处理，瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~

新建一个项目叫做Fragments，然后在layout文件夹下新建一个名为fragment1.xml的布局文件：

<span style="font-family:SimSun;font-size:12px;"><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:background="#00ff00" >  
  
    <TextView  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="This is fragment 1"  
        android:textColor="#000000"  
        android:textSize="25sp" />  
  
</LinearLayout> </span>

可以看到，这个布局文件非常简单，只有一个LinearLayout，里面加入了一个TextView。我们如法炮制再新建一个fragment2.xml ：

<span style="font-family:SimSun;font-size:12px;"><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:background="#ffff00" >  
  
    <TextView  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="This is fragment 2"  
        android:textColor="#000000"  
        android:textSize="25sp" />  
  
</LinearLayout>  </span>

然后新建一个类Fragment1，这个类是继承自Fragment的：

<span style="font-family:SimSun;font-size:12px;">public class Fragment1 extends Fragment {  
  
    @Override  
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
        return inflater.inflate(R.layout.fragment1, container, false);  
    }  
  
}  </span>

我们可以看到，这个类也非常简单，主要就是加载了我们刚刚写好的fragment1.xml布局文件并返回。同样的方法，我们再写好Fragment2 ：

<span style="font-family:SimSun;font-size:12px;">public class Fragment2 extends Fragment {  
  
    @Override  
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
        return inflater.inflate(R.layout.fragment2, container, false);  
    }  
 
} </span>

然后打开或新建activity_main.xml作为主Activity的布局文件，在里面加入两个Fragment的引用，使用android:name前缀来引用具体的Fragment：

<span style="font-size:12px;"><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:baselineAligned="false" >  
  
    <fragment  
        android:id="@+id/fragment1"  
        android:name="com.example.fragmentdemo.Fragment1"  
        android:layout_width="0dip"  
        android:layout_height="match_parent"  
        android:layout_weight="1" />  
  
    <fragment  
        android:id="@+id/fragment2"  
        android:name="com.example.fragmentdemo.Fragment2"  
        android:layout_width="0dip"  
        android:layout_height="match_parent"  
        android:layout_weight="1" />  
  
</LinearLayout> </span>

最后打开或新建MainActivity作为程序的主Activity，里面的代码非常简单，都是自动生成的：

public class MainActivity extends Activity {  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
    }  
  
}  

②动态创建Fragment

动态添加Fragment主要分为4步：

1.获取到FragmentManager，在Activity中可以直接通过getFragmentManager得到。

2.开启一个事务，通过调用beginTransaction方法开启。

3.向容器内加入Fragment，一般使用replace方法实现，需要传入容器的id和Fragment的实例。

4.提交事务，调用commit方法提交

public class MainActivity extends Activity {  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        Display display = getWindowManager().getDefaultDisplay();  
        if (display.getWidth() > display.getHeight()) {  
            Fragment1 fragment1 = new Fragment1();  
            getFragmentManager().beginTransaction().replace(R.id.main_layout, fragment1).commit();  
        } else {  
            Fragment2 fragment2 = new Fragment2();  
            getFragmentManager().beginTransaction().replace(R.id.main_layout, fragment2).commit();  
        }  
    }  
  
} 

③Fragment家族常用的API

Fragment常用的三个类：

android.app.Fragment 主要用于定义Fragment

android.app.FragmentManager 主要用于在Activity中操作Fragment

android.app.FragmentTransaction 保证一些列Fragment操作的原子性，熟悉事务这个词，一定能明白~

a、获取FragmentManage的方式：

getFragmentManager() // v4中，getSupportFragmentManager

b、主要的操作都是FragmentTransaction的方法

FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务

transaction.add() 

往Activity中添加一个Fragment

transaction.remove()

从Activity中移除一个Fragment，如果被移除的Fragment没有添加到回退栈（回退栈后面会详细说），这个Fragment实例将会被销毁。

transaction.replace()

使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体~

transaction.hide()

隐藏当前的Fragment，仅仅是设为不可见，并不会销毁

transaction.show()

显示之前隐藏的Fragment

detach()

会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。

attach()

重建view视图，附加到UI上并显示。

transatcion.commit()//提交一个事务

注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：State loss这样的错误。主要是因为：commit方法一定要在Activity.onSaveInstance()之前调用。

上述，基本是操作Fragment的所有的方式了，在一个事务开启到提交可以进行多个的添加、移除、替换等操作。

值得注意的是：如果你喜欢使用Fragment，一定要清楚这些方法，哪个会销毁视图，哪个会销毁实例，哪个仅仅只是隐藏，这样才能更好的使用它们。

a、比如：我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望回到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。

b、再比如：我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果。

c、remove和detach有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach。

④生命周期

· onAttach方法：Fragment和Activity建立关联的时候调用。

· onCreateView方法：为Fragment加载布局时调用。

· onActivityCreated方法：当Activity中的onCreate方法执行完后调用。

· onDestroyView方法：Fragment中的布局被移除时调用。

· onDetach方法：Fragment和Activity解除关联的时候调用。

启动Activity

销毁Activity

可以看出针对Activity状态的改变Fragment状态的改变就如果入栈出栈的操作，Activity启动的时候相应的Fragment状态总是后执行，当我们要销毁Activity时，Fragment的状态总是优先销毁。就如同进栈的时候Activity先进入，出栈的时候Activity后出，先进后出，恰好符合栈的操作。

⑤Activity 和 Fragment之间传值

可以使用bundle进行参数传递、这样在两个Fragment跳转的时候就可以带上参数了、同样也可以传递一个复杂的对象

ft.hide(getActivity().getSupportFragmentManager().findFragmentByTag(""));
	DemoFragment demoFragment = new DemoFragment();  
	Bundle bundle = new Bundle();  
	bundle.putString("key", "这是方法二");  
	demoFragment.setArguments(bundle);  
	ft.add(R.id.fragmentRoot, demoFragment, SEARCHPROJECT);  
	ft.commit(); 

在另外一个Fragment获取参数的方式只需要一个语句、key是自己定义的一个标识、参数的形式只要bundle能传递都可以实现

String string = getArguments().getString("key"); 

Activity主动传值到Fragment

Fragment主动传值到Activity

这种方式更简单了就是通过intent传值

Activity或Fragment获取值

例如获取Fragment中EditText中的值，或者Activity获取Fragment中EditText值：

在这里所讲的获取值指的是一个Fragment在某个Activity中的情况,也就是上面所讲的生命周期部分，Fragment的生命周期受Activity控制的情况，这也是最常见的传值方式。无论是Activity获取Fragment中的值还是Fragment获取Activity中的值，应该都不是太难，因为一个Fragment一定属于这个Activity了，所以在Fragment中可以通过getActivity()就获取到了Activity，再通过Activity中的UI控件或方法得到所要的值都是一件很简单的事。

同样的道理，Activity获取某一个Fragment中值也同上面说的一样，既然Activity已经有了这个Fragment的对象，想拿到你控件或方法值都轻而易举了。

回调函数传值

简单的举个例子，在Activity中获取Fragment中某个控件的值：

1.07-20 08:23:12.952: E/FragmentOne(1782): Bundle[{android:fragments=android.app.FragmentManagerState@40d0b7b8, 

android:viewHierarchyState=Bundle[{android:focusedViewId=2131230721, android:views=android.util.SparseArray@40d0af68}]}]  

 public class MainActivity extends Activity  {  
     private static final String TAG = "FragmentOne";  
     private FragmentOne mFOne;  
   
     @Override  
     protected void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         requestWindowFeature(Window.FEATURE_NO_TITLE);  
         setContentView(R.layout.activity_main);  
   
         Log.e(TAG, savedInstanceState+"");  
           
         if(savedInstanceState == null)   {  
             mFOne = new FragmentOne();  
             FragmentManager fm = getFragmentManager();  
             FragmentTransaction tx = fm.beginTransaction();  
             tx.add(R.id.id_content, mFOne, "ONE");  
             tx.commit();  
         }  
     }  
 } 

上篇博客分析到setUpHWComposer函数，这里我们继续分析图像合成的过程从doComposition函数开始，以及在这过程中解答一些上篇博客提出的疑问。

一、doComposition合成图层

doComposition这个函数就是合成所有层的图像

void SurfaceFlinger::doComposition() {
    ATRACE_CALL();
    const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
    for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
        const sp<DisplayDevice>& hw(mDisplays[dpy]);
        if (hw->isDisplayOn()) {
            // transform the dirty region into this screen's coordinate space
            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));

            // repaint the framebuffer (if needed)
            doDisplayComposition(hw, dirtyRegion);

            hw->dirtyRegion.clear();
            hw->flip(hw->swapRegion);
            hw->swapRegion.clear();
        }
        // inform the h/w that we're done compositing
        hw->compositionComplete();
    }
    postFramebuffer();
}

上面函数遍历所有的DisplayDevice然后调用doDisplayComposition函数。然后我们再看看doDisplayComposition函数

void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
        const Region& inDirtyRegion)
{
    bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
    if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
        return;
    }

    Region dirtyRegion(inDirtyRegion);

    //swapRegion设置为需要更新的区域
    hw->swapRegion.orSelf(dirtyRegion);

    uint32_t flags = hw->getFlags();//获得显示设备支持的更新方式标志
    if (flags & DisplayDevice::SWAP_RECTANGLE) {//支持矩阵更新        
        dirtyRegion.set(hw->swapRegion.bounds());
    } else {
        if (flags & DisplayDevice::PARTIAL_UPDATES) {//支持部分更新
            dirtyRegion.set(hw->swapRegion.bounds());
        } else {
            //将更新区域调整为整个窗口大小
            dirtyRegion.set(hw->bounds());
            hw->swapRegion = dirtyRegion;
        }
    }

    if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
        if (!doComposeSurfaces(hw, dirtyRegion)) return;//合成
    } else {
        RenderEngine& engine(getRenderEngine());
        mat4 colorMatrix = mColorMatrix;
        if (mDaltonize) {
            colorMatrix = colorMatrix * mDaltonizer();
        }
        mat4 oldMatrix = engine.setupColorTransform(colorMatrix);
        doComposeSurfaces(hw, dirtyRegion);//合成
        engine.setupColorTransform(oldMatrix);
    }

    // update the swap region and clear the dirty region
    hw->swapRegion.orSelf(dirtyRegion);

    // swap buffers (presentation)
    hw->swapBuffers(getHwComposer());//使用egl将egl中的合成好的图像，输出到DisplayDevice的mSurface中
}

这个函数设置下需要更新的区域，后面调用doComposeSurfaces函数来合成图层，调用完doComposeSurfaces函数后，如果需要egl合成图像话，在这个函数中合成好。而最后调用swapBuffers只是将egl合成好的图像输出到DisplayDevice的mSurface中。

我们再来看看doComposeSurfaces函数,我们先来看一开始的代码，先判断是否有egl合成，然后再看是否有hwc合成（硬件合成）

bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)
{
    RenderEngine& engine(getRenderEngine());
    const int32_t id = hw->getHwcDisplayId();
    HWComposer& hwc(getHwComposer());
    HWComposer::LayerListIterator cur = hwc.begin(id);
    const HWComposer::LayerListIterator end = hwc.end(id);

    bool hasGlesComposition = hwc.hasGlesComposition(id);
    if (hasGlesComposition) {//是否有egl合成
        if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
            ALOGW("DisplayDevice::makeCurrent failed. Aborting surface composition for display %s",
                  hw->getDisplayName().string());
            eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
            if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
              ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
            }
            return false;
        }

        // Never touch the framebuffer if we don't have any framebuffer layers
        const bool hasHwcComposition = hwc.hasHwcComposition(id);
        if (hasHwcComposition) {//是否有hwc合成
            // when using overlays, we assume a fully transparent framebuffer
            // NOTE: we could reduce how much we need to clear, for instance
            // remove where there are opaque FB layers. however, on some
            // GPUs doing a "clean slate" clear might be more efficient.
            // We'll revisit later if needed.
            engine.clearWithColor(0, 0, 0, 0);
        } else {
            // we start with the whole screen area
            const Region bounds(hw->getBounds());

            // we remove the scissor part
            // we're left with the letterbox region
            // (common case is that letterbox ends-up being empty)
            const Region letterbox(bounds.subtract(hw->getScissor()));

            // compute the area to clear
            Region region(hw->undefinedRegion.merge(letterbox));

            // but limit it to the dirty region
            region.andSelf(dirty);

            // screen is already cleared here
            if (!region.isEmpty()) {
                // can happen with SurfaceView
                drawWormhole(hw, region);
            }
        }

        if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
            // just to be on the safe side, we don't set the
            // scissor on the main display. It should never be needed
            // anyways (though in theory it could since the API allows it).
            const Rect& bounds(hw->getBounds());
            const Rect& scissor(hw->getScissor());
            if (scissor != bounds) {
                // scissor doesn't match the screen's dimensions, so we
                // need to clear everything outside of it and enable
                // the GL scissor so we don't draw anything where we shouldn't

                // enable scissor for this frame
                const uint32_t height = hw->getHeight();
                engine.setScissor(scissor.left, height - scissor.bottom,
                        scissor.getWidth(), scissor.getHeight());
            }
        }
    }
......

我们来看hasGlesComposition函数和hasHwcComposition函数，就是看其对应的DisplayData中是否有hasFbComp和hasOvComp。

bool HWComposer::hasGlesComposition(int32_t id) const {
    if (!mHwc || uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
        return true;
    return mDisplayData[id].hasFbComp;
}

bool HWComposer::hasHwcComposition(int32_t id) const {
    if (!mHwc || uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
        return false;
    return mDisplayData[id].hasOvComp;
}

status_t HWComposer::prepare() {
   ......
   int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
    ALOGE_IF(err, "HWComposer: prepare failed (%s)", strerror(-err));

    if (err == NO_ERROR) {
        // here we're just making sure that "skip" layers are set
        // to HWC_FRAMEBUFFER and we're also counting how many layers
        // we have of each type.
        //
        // If there are no window layers, we treat the display has having FB
        // composition, because SurfaceFlinger will use GLES to draw the
        // wormhole region.
        for (size_t i=0 ; i<mNumDisplays ; i++) {
            DisplayData& disp(mDisplayData[i]);
            disp.hasFbComp = false;
            disp.hasOvComp = false;
            if (disp.list) {
                for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {
                    hwc_layer_1_t& l = disp.list->hwLayers[i];

                    //ALOGD("prepare: %d, type=%d, handle=%p",
                    //        i, l.compositionType, l.handle);

                    if (l.flags & HWC_SKIP_LAYER) {
                        l.compositionType = HWC_FRAMEBUFFER;
                    }
                    if (l.compositionType == HWC_FRAMEBUFFER) {
                        disp.hasFbComp = true;//只要有一个layer是HWC_FRAMEBUFFER
                    }
                    if (l.compositionType == HWC_OVERLAY) {
                        disp.hasOvComp = true;//有一个layer是HWC_OVERLAY
                    }
                    if (l.compositionType == HWC_CURSOR_OVERLAY) {
                        disp.hasOvComp = true;//有一个layer是HWC_CURSOR_OVERLAY
                    }
                }
                if (disp.list->numHwLayers == (disp.framebufferTarget ? 1 : 0)) {//layer的数量 有framebufferTarget为1 没有为0
                    disp.hasFbComp = true;
                }
            } else {
                disp.hasFbComp = true;//没有list
            }
        }
    }
    return (status_t)err;
}

我们继续看doComposeSurfaces函数，下面这个函数当cur!=end代表起码有两个以上图层，然后遍历图层，当layer是HWC_FRAMEBUFFER代表是需要egl合成的，而HWC_FRAMEBUFFER_TARGET是egl合成后使用的直接就跳了，HWC_CURSOR_OVERLAY和HWC_OVERLAY是用HWC模块（硬件合成）的，也就不用调用Layer的draw方法。而如果图层只要1个或者没有，那么直接使用egl合成。

    HWComposer::LayerListIterator cur = hwc.begin(id);
    const HWComposer::LayerListIterator end = hwc.end(id);
    ......

    const Vector< sp<Layer> >& layers(hw->getVisibleLayersSortedByZ());
    const size_t count = layers.size();
    const Transform& tr = hw->getTransform();
    if (cur != end) { //代表起码有两个以上图层
        // we're using h/w composer
        for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {//遍历图层
            const sp<Layer>& layer(layers[i]);
            const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
            if (!clip.isEmpty()) {
                switch (cur->getCompositionType()) {
                    case HWC_CURSOR_OVERLAY:
                    case HWC_OVERLAY: {
                        const Layer::State& state(layer->getDrawingState());
                        if ((cur->getHints() & HWC_HINT_CLEAR_FB)
                                && i
                                && layer->isOpaque(state) && (state.alpha == 0xFF)
                                && hasGlesComposition) {
                            // never clear the very first layer since we're
                            // guaranteed the FB is already cleared
                            layer->clearWithOpenGL(hw, clip);
                        }
                        break;
                    }
                    case HWC_FRAMEBUFFER: {
                        layer->draw(hw, clip);//只有是HWC_FRAMEBUFFER才会调用Layer的draw合成
                        break;
                    }
                    case HWC_FRAMEBUFFER_TARGET: {
                        // this should not happen as the iterator shouldn't
                        // let us get there.
                        ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
                        break;
                    }
                }
            }
            layer->setAcquireFence(hw, *cur);
        }
    } else {
        // we're not using h/w composer
        for (size_t i=0 ; i<count ; ++i) {//只有一个或者没有图层  就直接使用Layer的draw合成
            const sp<Layer>& layer(layers[i]);
            const Region clip(dirty.intersect(
                    tr.transform(layer->visibleRegion)));
            if (!clip.isEmpty()) {
                layer->draw(hw, clip);
            }
        }
    }

    // disable scissor at the end of the frame
    engine.disableScissor();
    return true;
}

Layer的draw我们就不看了主要是使用egl合成纹理，但是有一点疑问，我们从来没有把layer中的mActiveBuffer放到egl中去，那么egl又是怎么合成各个layer的呢，我想肯定客户进程在绘制各个layer的时候，也是用egl绘制的，所有后面合成的时候egl有各个layer的buffer。

后面我们再来看下DisplayDevice::swapBuffers函数，是使用eglSwapBuffers来把egl合成的数据放到mSurface中去。

void DisplayDevice::swapBuffers(HWComposer& hwc) const {
    // We need to call eglSwapBuffers() if:
    //  (1) we don't have a hardware composer, or
    //  (2) we did GLES composition this frame, and either
    //    (a) we have framebuffer target support (not present on legacy
    //        devices, where HWComposer::commit() handles things); or
    //    (b) this is a virtual display
    if (hwc.initCheck() != NO_ERROR ||
            (hwc.hasGlesComposition(mHwcDisplayId) &&
             (hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL))) {
        EGLBoolean success = eglSwapBuffers(mDisplay, mSurface);
        if (!success) {
            EGLint error = eglGetError();
            if (error == EGL_CONTEXT_LOST ||
                    mType == DisplayDevice::DISPLAY_PRIMARY) {
                LOG_ALWAYS_FATAL("eglSwapBuffers(%p, %p) failed with 0x%08x",
                        mDisplay, mSurface, error);
            } else {
                ALOGE("eglSwapBuffers(%p, %p) failed with 0x%08x",
                        mDisplay, mSurface, error);
            }
        }
    }
    else if(hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL)
    {
        EGLBoolean success = eglSwapBuffersVIV(mDisplay, mSurface);
        if (!success) {
            EGLint error = eglGetError();
            ALOGE("eglSwapBuffersVIV(%p, %p) failed with 0x%08x",
                        mDisplay, mSurface, error);
        }
    }

    status_t result = mDisplaySurface->advanceFrame();
    if (result != NO_ERROR) {
        ALOGE("[%s] failed pushing new frame to HWC: %d",
                mDisplayName.string(), result);
    }
}

二、FramebufferSurface收到egl合成数据

之前分析DisplayDevice时候，还分析了FramebufferSurface，我们这里再来看下。

在SurfaceFlinger.cpp中的init函数，在创建DisplayDevice之前，我们先调用createBufferQueue来创建了一个buffer的生产者和消费者，然后把消费者放入了FramebufferSurface，生产者放入了DisplayDevice中。

          sp<IGraphicBufferProducer> producer;
            sp<IGraphicBufferConsumer> consumer;
            BufferQueue::createBufferQueue(&producer, &consumer,
                    new GraphicBufferAlloc());

            sp<FramebufferSurface> fbs = new FramebufferSurface(*mHwc, i,
                    consumer);
            int32_t hwcId = allocateHwcDisplayId(type);
            sp<DisplayDevice> hw = new DisplayDevice(this,
                    type, hwcId, mHwc->getFormat(hwcId), isSecure, token,
                    fbs, producer,
                    mRenderEngine->getEGLConfig());

我们先来看生产者，下面是DisplayDevice的构造函数，生产者作为参数直接新建了一个Surface，然后把这个Surface作为参数调用eglCreateWindowSurface返回的就是mSurface，之前我们分析最后egl合成的数据时调用eglSwapBuffers并且把数据放到mSurface，这样最后肯定就到消费者（FramebufferSurface）去了。

    mNativeWindow = new Surface(producer, false);
    ANativeWindow* const window = mNativeWindow.get();

    /*
     * Create our display's surface
     */

    EGLSurface surface;
    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    if (config == EGL_NO_CONFIG) {
        config = RenderEngine::chooseEglConfig(display, format);
    }
    surface = eglCreateWindowSurface(display, config, window, NULL);

最后到消费者那端的onFrameAvailable，也就是FramebufferSurface的onFrameAvailable中，我们现在来分析下这个过程，也就解答了一个onFrameAvailable的疑惑。

FramebufferSurface的父类是ConsumerBase类，我们来看其构造函数。先是构造了mConsumer，这里其实就是BufferQueueConsumer类，后面调用了其consumerConnect方法。

ConsumerBase::ConsumerBase(const sp<IGraphicBufferConsumer>& bufferQueue, bool controlledByApp) :
        mAbandoned(false),
        mConsumer(bufferQueue) {
    mName = String8::format("unnamed-%d-%d", getpid(), createProcessUniqueId());

    wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
    sp<IConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);

    status_t err = mConsumer->consumerConnect(proxy, controlledByApp);
    if (err != NO_ERROR) {
        CB_LOGE("ConsumerBase: error connecting to BufferQueue: %s (%d)",
                strerror(-err), err);
    } else {
        mConsumer->setConsumerName(mName);
    }
}

我们来看下BufferQueueConsumer类的consumerConnect方法，就是调用了connect方法。

    virtual status_t consumerConnect(const sp<IConsumerListener>& consumer,
            bool controlledByApp) {
        return connect(consumer, controlledByApp);
    }

这个方法中将mCore->mConsumerListener = consumerListener，这个mCore就是BufferQueueCore类。我们再从ConsumerBase的构造函数看这个consumerListener参数其实就是FrameBufferSurface对象本身。

status_t BufferQueueConsumer::connect(
        const sp<IConsumerListener>& consumerListener, bool controlledByApp) {
    ATRACE_CALL();

    if (consumerListener == NULL) {
        BQ_LOGE("connect(C): consumerListener may not be NULL");
        return BAD_VALUE;
    }

    BQ_LOGV("connect(C): controlledByApp=%s",
            controlledByApp ? "true" : "false");

    Mutex::Autolock lock(mCore->mMutex);

    if (mCore->mIsAbandoned) {
        BQ_LOGE("connect(C): BufferQueue has been abandoned");
        return NO_INIT;
    }

    mCore->mConsumerListener = consumerListener;//设置回调
    mCore->mConsumerControlledByApp = controlledByApp;

    return NO_ERROR;
}

我们再看BufferQueueProducer::queueBuffer函数，这个函数应该是生产者已经使用好buffer了，这个使用会调用如下代码这个listener就是BufferQueueCore的mConsumerListener，传输的数据时BufferItem。再传之前把BufferItem的mGraphicBuffer清了，因为消费者可以自己获取buffer，不用通过BufferItem传。

    item.mGraphicBuffer.clear();
    item.mSlot = BufferItem::INVALID_BUFFER_SLOT;

    // Call back without the main BufferQueue lock held, but with the callback
    // lock held so we can ensure that callbacks occur in order
    {
        Mutex::Autolock lock(mCallbackMutex);
        while (callbackTicket != mCurrentCallbackTicket) {
            mCallbackCondition.wait(mCallbackMutex);
        }

        if (frameAvailableListener != NULL) {
            frameAvailableListener->onFrameAvailable(item);
        } else if (frameReplacedListener != NULL) {
            frameReplacedListener->onFrameReplaced(item);
        }

        ++mCurrentCallbackTicket;
        mCallbackCondition.broadcast();
    }

这样就要FramebufferSurface的onFrameAvailable函数中去了，我们来看下这个函数。

void FramebufferSurface::onFrameAvailable(const BufferItem& /* item */) {
    sp<GraphicBuffer> buf;
    sp<Fence> acquireFence;
    status_t err = nextBuffer(buf, acquireFence);
    if (err != NO_ERROR) {
        ALOGE("error latching nnext FramebufferSurface buffer: %s (%d)",
                strerror(-err), err);
        return;
    }
    err = mHwc.fbPost(mDisplayType, acquireFence, buf);
    if (err != NO_ERROR) {
        ALOGE("error posting framebuffer: %d", err);
    }
}

status_t FramebufferSurface::nextBuffer(sp<GraphicBuffer>& outBuffer, sp<Fence>& outFence) {
    Mutex::Autolock lock(mMutex);

    BufferItem item;
    status_t err = acquireBufferLocked(&item, 0);
    if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
        outBuffer = mCurrentBuffer;
        return NO_ERROR;
    } else if (err != NO_ERROR) {
        ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err);
        return err;
    }

    if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT &&
        item.mBuf != mCurrentBufferSlot) {
        // Release the previous buffer.
        err = releaseBufferLocked(mCurrentBufferSlot, mCurrentBuffer,
                EGL_NO_DISPLAY, EGL_NO_SYNC_KHR);
        if (err < NO_ERROR) {
            ALOGE("error releasing buffer: %s (%d)", strerror(-err), err);
            return err;
        }
    }
    mCurrentBufferSlot = item.mBuf;
    mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer;
    outFence = item.mFence;
    outBuffer = mCurrentBuffer;
    return NO_ERROR;
}

status_t ConsumerBase::acquireBufferLocked(BufferItem *item,
        nsecs_t presentWhen, uint64_t maxFrameNumber) {
    status_t err = mConsumer->acquireBuffer(item, presentWhen, maxFrameNumber);
    if (err != NO_ERROR) {
        return err;
    }

    if (item->mGraphicBuffer != NULL) {
        mSlots[item->mBuf].mGraphicBuffer = item->mGraphicBuffer;
    }

    mSlots[item->mBuf].mFrameNumber = item->mFrameNumber;
    mSlots[item->mBuf].mFence = item->mFence;

    CB_LOGV("acquireBufferLocked: -> slot=%d/%" PRIu64,
            item->mBuf, item->mFrameNumber);

    return OK;
}

三、egl合成数据在HWComposer的处理

继上面调用fbPost方法，我们来看下，这里是调用了setFramebufferTarget方法。

int HWComposer::fbPost(int32_t id,
        const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buffer) {
    if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
        return setFramebufferTarget(id, acquireFence, buffer);
    } else {
        acquireFence->waitForever("HWComposer::fbPost");
        return mFbDev->post(mFbDev, buffer->handle);
    }
}

我们来看下setFramebufferTarget方法，这里就是把该设备的DisplayData数据中的framebufferTarget填充，主要是其handle数据，这里就是egl合成好的数据buffer。

也就是最终egl合成好的数据放在DisplayData的framebufferTarget变量的handle中。

status_t HWComposer::setFramebufferTarget(int32_t id,
        const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf) {
    if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
        return BAD_INDEX;
    }
    DisplayData& disp(mDisplayData[id]);
    if (!disp.framebufferTarget) {
        // this should never happen, but apparently eglCreateWindowSurface()
        // triggers a Surface::queueBuffer()  on some
        // devices (!?) -- log and ignore.
        ALOGE("HWComposer: framebufferTarget is null");
        return NO_ERROR;
    }

    int acquireFenceFd = -1;
    if (acquireFence->isValid()) {
        acquireFenceFd = acquireFence->dup();
    }

    // ALOGD("fbPost: handle=%p, fence=%d", buf->handle, acquireFenceFd);
    disp.fbTargetHandle = buf->handle;//egl合成好的数据
    disp.framebufferTarget->handle = disp.fbTargetHandle;//egl合成好的数据，最终是放在这里
    disp.framebufferTarget->acquireFenceFd = acquireFenceFd;
    return NO_ERROR;
}

四、硬件模块合成

这样就剩最后一步了，把不管是普通layer的数据，还是egl合成好的数据发送到硬件模块合成了，最后就到显示设备了。

继第一节分析的doComposition函数最后会调用postFramebuffer函数，我们再来分析下这个函数,这个函数主要是调用了HWComposer的commit函数。

void SurfaceFlinger::postFramebuffer()
{
    ATRACE_CALL();

    const nsecs_t now = systemTime();
    mDebugInSwapBuffers = now;

    HWComposer& hwc(getHwComposer());
    if (hwc.initCheck() == NO_ERROR) {
        if (!hwc.supportsFramebufferTarget()) {
            // EGL spec says:
            //   "surface must be bound to the calling thread's current context,
            //    for the current rendering API."
            getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
        }
        hwc.commit();
    }
......

status_t HWComposer::commit() {
    int err = NO_ERROR;
    if (mHwc) {
        if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
            // On version 1.0, the OpenGL ES target surface is communicated
            // by the (dpy, sur) fields and we are guaranteed to have only
            // a single display.
            mLists[0]->dpy = eglGetCurrentDisplay();//设置下egl相关变量
            mLists[0]->sur = eglGetCurrentSurface(EGL_DRAW);
        }

        for (size_t i=VIRTUAL_DISPLAY_ID_BASE; i<mNumDisplays; i++) {
            DisplayData& disp(mDisplayData[i]);
            if (disp.outbufHandle) {//只有虚拟设备需要设置outbuf
                mLists[i]->outbuf = disp.outbufHandle;
                mLists[i]->outbufAcquireFenceFd =
                        disp.outbufAcquireFence->dup();
            }
        }

        err = mHwc->set(mHwc, mNumDisplays, mLists);//调用硬件模块合成
......

TextPaint是paint的子类，用它可以很方便的进行文字的绘制，一般情况下遇到绘制文字的需求时，我们一般用TextPaint所提供的方法。开始学习如何绘制文字之前，我们必须要先了解下android中文字是怎么绘制到屏幕上的，文字的格式又是怎么样的。

一、FontMetrics(字体度量)
1.1理论知识
它是一个Paint的内部类，作用是“字体测量”。它里面呢就定义了top,ascent,descent,bottom,leading五个成员变量其他什么也没有，和rect很相似。如果你不信，我们可以去看看源码：

 /**
     * Class that describes the various metrics for a font at a given text size.
     * Remember, Y values increase going down, so those values will be positive,
     * and values that measure distances going up will be negative. This class
     * is returned by getFontMetrics().
     */
    public static class FontMetrics {
        /**
         * The maximum distance above the baseline for the tallest glyph in
         * the font at a given text size.
         */
        public float   top;
        /**
         * The recommended distance above the baseline for singled spaced text.
         */
        public float   ascent;
        /**
         * The recommended distance below the baseline for singled spaced text.
         */
        public float   descent;
        /**
         * The maximum distance below the baseline for the lowest glyph in
         * the font at a given text size.
         */
        public float   bottom;
        /**
         * The recommended additional space to add between lines of text.
         */
        public float   leading;
    }

为了很好的理解这5个变量的意义，我们用下面的图示来进行说明。

Baseline是基线
在Android中，文字的绘制都是从Baseline处开始的，Baseline往上至字符“最高处”的距离我们称之为ascent（上坡度），Baseline往下至字符“最低处”的距离我们称之为descent（下坡度）；

leading（行间距）则表示上一行字符的descent到该行字符的ascent之间的距离；

　　top和bottom文档描述地很模糊，其实这里我们可以借鉴一下TextView对文本的绘制，TextView在绘制文本的时候总会在文本的最外层留出一些内边距，为什么要这样做？因为TextView在绘制文本的时候考虑到了类似读音符号，下图中的A上面的符号就是一个拉丁文的类似读音符号的东西：
　　
　　top的意思其实就是除了Baseline到字符顶端的距离外还应该包含这些符号的高度，bottom的意思也是一样。一般情况下我们极少使用到类似的符号所以往往会忽略掉这些符号的存在，但是Android依然会在绘制文本的时候在文本外层留出一定的边距，这就是为什么top和bottom总会比ascent和descent大一点的原因。而在TextView中我们可以通过xml设置其属性android:includeFontPadding=”false”去掉一定的边距值但是不能完全去掉。

1.2 代码验证

private static final String TEXT = "ap卡了ξτβбпшㄎㄊěǔぬも┰┠№＠↓"; 

 @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        mTextPaint.setTextSize(50);  
        mTextPaint.setColor(Color.BLACK);  

        FontMetrics fontMetrics = mTextPaint.getFontMetrics();  
        Log.d("Aige", "ascent：" + fontMetrics.ascent);  
        Log.d("Aige", "top：" + fontMetrics.top);  
        Log.d("Aige", "leading：" + fontMetrics.leading);  
        Log.d("Aige", "descent：" + fontMetrics.descent);  
        Log.d("Aige", "bottom：" + fontMetrics.bottom);  

        mTextPaint.clearShadowLayer();
        canvas.drawText(TEXT, 0, Math.abs(fontMetrics.top), mTextPaint);
    }

结果：

打印的Log：

ascent：-46.38672
top：-52.807617
leading：0.0
descent：12.207031
bottom：13.549805

注：Baseline上方的值为负，下方的值为正
我们来分析一下这个结果：

因为基线上方为负，所以ascent和top的值都是负数，而且top要大于ascent，原因是要为符号留出位置。
因为只有一行文本所以leading恒为0。
基线下方为正，所以descent和bottom都是正的，bottom要略大于descent
在得到的结果中，我们发现文字是紧紧贴着屏幕顶端的，再看下我们的程序代码：
canvas.drawText(TEXT, 0, Math.abs(fontMetrics.top), mTextPaint);

x坐标是0，y坐标是Math.abs(fontMetrics.top)，因为android是从基线开始绘制的，所以我们为了让字体顶端紧贴屏幕就必须让它移下来一点，移动的距离是top的距离，也就是基线到文字对顶部的距离。有人可能会问，如果不设置呢？x，y坐标都是0，是什么效果呢？因为android会从基线开始绘制，所以如果不做处理，基线就是屏幕的顶部，因此会出现如下的效果：

1.3 fontMetrics中的变量和文字的size、typeface有关
从代码中我们可以看到一个很特别的现象，在我们绘制文本之前我们便可以获取文本的FontMetrics属性值，也就是说我们FontMetrics的这些值跟我们要绘制什么文本是无关的，而仅与绘制文本Paint的size和typeface有关。当你改变了paint绘制文字的size或typeface时，FontMetrics中的top、bottom等值就会发生改变。如果我们仅仅更改了文字，这些值是不会发生任何改变的。

1.4 绘制居中屏幕的文字
我们知道了这些理论知识，也知道android是怎么绘制文字的，一会我们要做一个实际的例子来巩固巩固。首先，我们要先来扩展认识两个方法：

float android.graphics.Paint.descent()
解释：the distance below (positive) the baseline (descent) based on the current typeface and text size. 
一句话解释：得到下坡度的值

float android.graphics.Paint.ascent()
解释：the distance above (negative) the baseline (ascent) based on the current typeface and text size. 
一句话解释：就是得到上坡度的值

实际代码：

@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        mTextPaint.setTextSize(50);
        mTextPaint.setColor(Color.BLACK);

        // 计算Baseline绘制的起点X轴坐标 ，计算方式：画布宽度的一半 - 文字宽度的一半
        int baseX = (int) (canvas.getWidth() / 2 - mTextPaint.measureText(TEXT) / 2);

        // 计算Baseline绘制的Y坐标 ，计算方式：画布高度的一半 - 文字总高度的一半
        int baseY = (int) ((canvas.getHeight() / 2) - ((mTextPaint.descent() + mTextPaint.ascent()) / 2));

        // 居中画一个文字
        canvas.drawText(TEXT, baseX, baseY, mTextPaint);

        mPaint.setColor(Color.RED);
        mPaint.setStrokeWidth(2);
        // 为了便于理解我们在画布中心处绘制一条中线
        canvas.drawLine(0, canvas.getHeight() / 2, canvas.getWidth(), canvas.getHeight() / 2, mPaint);
    }

x坐标的计算方法是（屏幕宽度-文字宽度）/2，如果文字宽度比屏幕宽度长得到的就是负数，如果文字宽度比屏幕宽度短，得到的就是正数，这个很容易理解；

y坐标的的计算方式是（屏幕高度-文字高度）/2，这里的文字高度用的是：descent+ascent（忽略了音标）。

结果：

这里的TextPaint.FontMetrics(); 就是帮助我们得到我们字体的各种距离属性的，然后方便我们对文字进行绘制。
这里我们需要牢记的就是TOP ASCENT DESCENT BOTTOM LEADING等等属性值。这些都可以让我们在自定义View的时候画Text更得心应手，更精确。

二、TextPaint中的各种方法

float ascent()：顾名思义就是返回上坡度的值
float descent()：得到下坡度的值

public int breakText (String text, boolean measureForwards, float maxWidth, float[] measuredWidth)
public int breakText (char[] text, int index, int count, float maxWidth, float[] measuredWidth)
public int breakText (CharSequence text, int start, int end, boolean measureForwards, float maxWidth, float[] measuredWidth)

这个方法让我们设置一个最大宽度，在不超过这个宽度的范围内返回实际测量值否则停止测量。
**text表示我们的字符串；
start表示从第几个字符串开始测量；
end表示从测量到第几个字符串为止；
measureForwards表示向前还是向后测量；
maxWidth表示一个给定的最大宽度在这个宽度内能测量出几个字符；
measuredWidth为一个可选项，可以为空，不为空时返回真实的测量值**

这些方法在一些结合文本处理的应用里比较常用，比如文本阅读器的翻页效果，我们需要在翻页的时候动态折断或生成一行字符串，这就派上用场了~

getFontMetrics()；//得到一个FontMetrics对象。 然后可以得到这个对象下面对于文字测量所需要的一些数值。

**getFontMetrics (Paint.FontMetrics metrics)
这个和我们之前用到的getFontMetrics()相比多了个参数，getFontMetrics()返回的是FontMetrics对象，而getFontMetrics(Paint.FontMetrics metrics)返回的是文本的行间距，如果metrics的值不为空则返回FontMetrics对象的值。**

**getFontMetricsInt()
该方法返回了一个FontMetricsInt对象，FontMetricsInt和FontMetrics是一样的，只不过getFontMetricsInt()得到的对象中的参数都是int类型，而getFontMetrics()返回对象中的参数都是float。**

**getFontMetricsInt(Paint.FontMetricsInt fmi)
得到文字的间距，距离是int类型**

getFontSpacing();//返回字符行间距

setUnderlineText(boolean underlineText);//设置文字的下划线

setTypeface(Typeface typeface);//设置字体类型，上面我们也使用过。
Android中字体有四种样式：BOLD（加粗）,BOLD_ITALIC（加粗并倾斜）,ITALIC（倾斜）,NORMAL（正常）； 这四个是静态常量，直接传入即可 和WORD是很像的。

　 **Paint p = new Paint();  
     String familyName = "宋体";  
     **Typeface** font = Typeface.create(familyName, Typeface.BOLD);  
     p.setColor(Color.RED);  
     p.setTypeface(font);** 

setTextSkewX(float skewX)

设置文本在水平方向上的倾斜。这个倾斜值没有具体的范围，但是官方推崇的值为-0.25可以得到比较好的倾斜文本效果，值为负右倾值为正左倾，默认值为0。

setTextSize (float textSize)
设置文字的大小，但是要注意该值必需大于零。

setTextScaleX (float scaleX)
将文本沿X轴水平缩放，默认值为1，当值大于1会沿X轴水平放大文本，当值小于1会沿X轴水平缩放文本

setTextLocale (Locale locale)
设置地理位置，这里如果你要使用，直接传入Locale.getDefault()即可。

setTextAlign (Paint.Align align)
设置文本的对齐方式，可供选的方式有三种：CENTER,LEFT和RIGHT。

我们的文本大小是通过size和typeface确定的（其实还有其他的因素但这里影响不大忽略），一旦baseline确定，对不对齐好像不相干吧。但是，你要知道一点，文本的绘制是从baseline开始没错，但是是从哪边开始绘制的呢？左端还是右端呢？而这个Align就是为我们定义在baseline绘制文本究竟该从何处开始，上面我们在进行对文本的水平居中时是用Canvas宽度的一半减去文本宽度的一半：

@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        mTextPaint.setTextSize(50);
        mTextPaint.setColor(Color.BLACK);
        // 计算Baseline绘制的起点X轴坐标 ，计算方式：画布宽度的一半 - 文字宽度的一半
        int baseX = (int) (canvas.getWidth() / 2 - mTextPaint.measureText(TEXT) / 2);

        // 计算Baseline绘制的Y坐标 ，计算方式：画布高度的一半 - 文字总高度的一半
        int baseY = (int) ((canvas.getHeight() / 2) - ((mTextPaint.descent() + mTextPaint.ascent()) / 2));

        // 居中画一个文字
        canvas.drawText(TEXT, baseX, baseY, mTextPaint);

        mPaint.setColor(Color.RED);
        mPaint.setStrokeWidth(2);
        // 为了便于理解我们在画布中心处绘制一条中线
        canvas.drawLine(0, canvas.getHeight() / 2, canvas.getWidth(), canvas.getHeight() / 2, mPaint);
    }

实际上我们大可不必这样计算，我们只需设置Paint的文本对齐方式为CENTER，drawText的时候起点x = canvas.getWidth() / 2即可。产生的效果是，文字先算好一个基准线，从这个基准线的中点开始向左右开始绘制文字，最终自然就变成了居中显示了。如果你设定了RIGHT，那么从baseline的右边的顶点开始，文字开始慢慢绘制。

**textPaint.setTextAlign(Align.CENTER);
canvas.drawText(TEXT, canvas.getWidth() / 2, baseY, textPaint);**
注：这里的剧中还是 左右是根据你传入的点进行计算的，即传入点把这个点看成中心点然后画出文字。

当我们将文本对齐方式设置为CENTER后就相当于告诉Android我们这个文本绘制的时候从文本的中点开始向两端绘制；如果设置为LEFT则从文本的左端开始往右绘制；如果为RIGHT则从文本的右端开始往左绘制：

setSubpixelText (boolean subpixelText)
设置是否打开文本的亚像素显示，什么叫亚像素显示呢？你可以理解为对文本显示的一种优化技术，如果大家用的是Win7+系统可以在控制面板中找到一个叫ClearType的设置，该设置可以让你的文本更好地显示在屏幕上就是基于亚像素显示技术。

setStrikeThruText (boolean strikeThruText);//文本删除线

**setLinearText (boolean linearText)
设置是否打开线性文本标识，这玩意对大多数人来说都很奇怪不知道这玩意什么意思。想要明白这东西你要先知道文本在Android中是如何进行存储和计算的。在Android中文本的绘制需要使用一个bitmap作为单个字符的缓存，既然是缓存必定要使用一定的空间，我们可以通过setLinearText (true)告诉Android我们不需要这样的文本缓存。**

setFakeBoldText (boolean fakeBoldText);//设置文本仿粗体

measureText (String text)
measureText (CharSequence text, int start, int end)
measureText (String text, int start, int end)
measureText (char[] text, int index, int count)
测量文本宽度，上面我们已经使用过了，这四个方法都是一样的只是参数稍有不同罢了。

三、Typeface中的方法

defaultFromStyle(int style)
最简单的，简而言之就是把上面所说的四种Style封装成Typeface。传入的参数是：BOLD（加粗）,BOLD_ITALIC（加粗并倾斜）,ITALIC（倾斜）,NORMAL（正常）

mTextPaint.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));

create(String familyName, int style)
create(Typeface family, int style)
**textPaint.setTypeface(Typeface.create(“SERIF”, Typeface.NORMAL));
textPaint.setTypeface(Typeface.create(Typeface.SERIF, Typeface.NORMAL));**
这两个方法执行的效果完全一样。

**createFromAsset(AssetManager mgr, String path)
createFromFile(String path)
createFromFile(File path)
这三者也是一样的，它们都允许我们使用自己的字体比如我们从asset目录读取一个字体文件。下面是一个简单的例子：**

// 获取字体并设置画笔字体
Typeface typeface = Typeface.createFromAsset(context.getAssets(), “kt.ttf”);
textPaint.setTypeface(typeface);

3.2 扩展到TextView

说到文本大家第一时间想到的应该是TextView，其实在TextView里我们依然可以找到上面很多方法的影子，比如我们可以从TextView中获取到TextPaint：

TextPaint paint = mTextView.getPaint();
当然也可以设置TextView的字体等等：

Typeface typeface = Typeface.createFromAsset(getAssets(), “kt.ttf”);
mTextView.setTypeface(typeface);

其实写到这里，我希望大家能清楚这样一个概念，在Android的View上进行绘制文字，和我们在Word上绘制是一样的，我们有的时候需要对文字的各种属性进行设置，那么我们的TextPaint同样提供这些方法， 这要和WORD相对应就可以了，不要把这个类想的很复杂，他就是一个代码化的WORD他甚至比WORD更精确灵活，让你随心所欲的对文字进行处理。

那么常用的就是：我们选择我们喜欢的字体 这里的格式是 ttf把文字放到asset当中就可以了
我们设置文字的位置，那么这个属性就是Align
我们设置文字的大小，TextSize
我们设置文字的颜色，TextColor
等等只要你需要的这个类都会提供相应的方法给你！

     Android OkHttp（一）初识，这篇文章最后提供了一个封装Okhttp请求的类，今天就来看看在项目中具体的使用情况。

一、简单接口请求。

     接口请求，需要有一个服务端，这里就使用之前用SpringMVC做的一个接口服务，接口有关的详细开发步骤，请参考这篇文章，SpringMVC 开发接口。

1.启动接口服务后，运行后的效果截图如下，

可以看到 ，接口返回的是json格式的数据，json数据定义了返回状态、返回码以及返回数据等，有关接口定义，可以看这篇文章，java web开发(二) 接口开发。

2.客户端程序开发。

    客户端使用Android小程序去调用接口。这个更加详细的描述，请参考， java web开发(三) 接口使用。记得加入网络访问请求权限

<uses-permission android:name="android.permission.INTERNET"/>

下面主要展示具体的调用，

public class MainActivity extends AppCompatActivity {

    private Button btn;
    private TextView tv;
    private ImageView iv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = (Button) findViewById(R.id.btn);
        tv = (TextView) findViewById(R.id.tv);
        iv = (ImageView) findViewById(R.id.iv);
        Log.e("Thread.currentThread()--->", Thread.currentThread().getId() + "");//打印当前线程的id
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
            getAllStudent();
            }
        });
    }
}

MainActivity界面有Button和TextView，点击Button去调用接口，TextView则用来显示接口数据。下面是具体调用方法，

  /**
     * 获取接口数据`
     */
    private void getAllStudent() {
        //接口返回的json
        TypeToken<ListResponse<Students>> typeToken = new TypeToken<ListResponse<Students>>() {
        };
        OkHttpUtils.getInstance().getAsyn(Constant.GET_ALL_STUDENT, null, typeToken, new BaseResponseCallback<ListResponse<Students>>() {
            @Override
            public void onCompleted(final Throwable e, ListResponse<Students> result) {
                if (e != null) {
                    tv.post(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_LONG).show();
                        }
                    });
                } else {
                    Log.e("Thread.currentThread()--->", Thread.currentThread().getId() + "");//打印当前线程的id
                    //获取接口返回的列表数据
                    List<Students> list = result.getItems();
                    final StringBuffer sb = new StringBuffer();
                    for (Students students : list) {
                        sb.append("姓名：" + students.getName() + ", 年龄" + students.getAge() + ", 电话" + students.getMobile()).append("\n");
                    }
                    //更新UI,在子线程中，不能直接更新UI
                    tv.post(new Runnable() {
                        @Override
                        public void run() {
                            tv.setText(sb.toString());
                        }
                    });
                }
            }
        });
    }

再看下面这种截图，

可以看到打印了两个线程的id是不一样的，一个是主线程，一个是子线程。程序运行后的效果截图，

  PS：  我们还可以在点击Button时，显示一个进度条（模态对话框），当请求结束后，关闭该进度条。这样在请求时，有一个比较好的用户体验，明确告诉用户，程序现在在做什么！

      更新UI，有多种方式，还可以使用handler发消息到主线程中，让主线程更新UI!

二、文件下载。

   1.服务端。

下载一张图片。该图片位于Tomact服务器路径底下。

启动在Tomact服务器，然后在浏览器中输入图片地址，截图如下所示，

2.客户端程序开发。

MainActivity界面有Button和ImageView，点击Button去调用接口，ImageView则用来显示下载的图片。

首先记得加入读写sd卡权限，

 <!-- 在SD卡中创建与删除文件权限 -->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
    <!-- 向SD卡写入数据权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_SETTINGS"/>

  /**
     * 下载图片
     */
    private void downLoadPic() {
        OkHttpUtils.getInstance().downloadFileAsyn(Constant.PIC_URL, null, FileUtils.createFile(MainActivity.this, "pic", "1.png"), new BaseResponseCallback() {
            @Override
            public void onCompleted(final Throwable e, final Object result) {
                if (e != null) {
                    tv.post(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_LONG).show();
                        }
                    });
                } else {
                    if (result != null) {
                        iv.post(new Runnable() {
                            @Override
                            public void run() {
                                String path = (String) result;
                                Log.e("path--->", path);
                                Bitmap bitmap = BitmapFactory.decodeFile(path);
                                iv.setImageBitmap(bitmap);
                            }
                        });
                    }
                }
            }
        });
    }

FileUtils.createFile(MainActivity.this,"pic","1.png") //是创建一个文件

点击Button去调用下载图片，下载完成后在ImageView中加载图片，点击运行后的效果如下，

打印出下载文件的路径，我们在手机上去该目录底下看看文件是否存在，

在目录下，已经存在下载的文件了，下面显示手机运行后的效果截图，

三、文件上传。

      在调用接口上传文件前，先做了一个JSP网页上传一个文件。

1. 使用form 上传一个文件。

(1). 首先需要创建一个上传的JSP网页，具体代码

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
<form action="./upLoadFile.dbo" method="post" enctype="multipart/form-data"> 
   选择文件：<input type="file" name="file"/> 
   <input type="submit" value="提交"/> 
 </form> 

</body>
</html>

(3).创建一个上传接口，具体代码如下，

public interface UpLoadFileService {
	 public boolean uploadFile(String destinationDir, MultipartFile file);
}

public class UploadFileServiceImpl implements UpLoadFileService {

	public boolean upload(String destinationDir, MultipartFile file) {
		return uploadFile(destinationDir, file);
	}

	/**
	 * 保存文件
	 * 
	 * @param stream
	 * @param path
	 * @param filename
	 * @throws IOException
	 */
	private void SaveFileFromInputStream(InputStream stream, String path, String filename) throws IOException {
		FileOutputStream outputStream = new FileOutputStream(path + "/" + filename);
		int byteCount = 0;
		byte[] bytes = new byte[1024];
		while ((byteCount = stream.read(bytes)) != -1) {
			outputStream.write(bytes, 0, byteCount);
		}
		outputStream.close();
		stream.close();
	}

	@Override
	public boolean uploadFile(String destinationDir, MultipartFile file) {
		StringBuffer sb = new StringBuffer();
		sb.append("文件长度: " + file.getSize());
		sb.append("文件类型: " + file.getContentType());
		sb.append("文件名称: " + file.getName());
		sb.append("文件原名: " + file.getOriginalFilename());
		System.out.println(sb.toString());
		try {
			SaveFileFromInputStream(file.getInputStream(), destinationDir, file.getOriginalFilename());
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

}

@Controller
public class UpLoadFileServlet {

	@RequestMapping(value = "/upLoadFile.dbo", method = RequestMethod.POST)
	public ModelAndView getAllStudent(HttpServletRequest request, HttpServletResponse response,
			 ModelMap modelMap) {
		 // 转型为MultipartHttpRequest：     
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;     
        // 获得文件：     
        MultipartFile file = multipartRequest.getFile("file"); 
		String realPath = "D:/java_web/upload";//文件存放路径，需要首先创建
		boolean result = false;
		result = UploadFileBusiness.upload(realPath, file);
		String resultJsp = "";
		SingleObject singleObject = new SingleObject();
		if (result) {
			resultJsp = "uploadFileSuccess";
			singleObject.setCode(StatusCode.CODE_SUCCESS);
			singleObject.setMsg("上传成功");
		} else {
			resultJsp = "uploadFileFail";
			singleObject.setCode(StatusCode.CODE_ERROR);
			singleObject.setMsg("上传失败");
		}
		singleObject.setObject("");
		modelMap.addAttribute("result", singleObject);
		return new ModelAndView(resultJsp, modelMap);
	}
}

public class UploadFileBusiness {
	
	/**
	 * 上传文件
	 * @param destinationDir
	 * @param file
	 * @return
	 */
	public static boolean upload(String destinationDir, MultipartFile file) {
		return new UploadFileServiceImpl().upload(destinationDir, file);
	}

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

	<!--配置自动解析的包 -->
	<context:component-scan base-package="cn.springmvc"></context:component-scan>
	<!--配置视图解析器：如何把handler 方法返回值解析为实际的物理视图  -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/views/"></property>
	<property name="suffix" value=".jsp"></property>
	</bean>
	
	<!-- SpringMVC上传文件时，需要配置MultipartResolver处理器 -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="defaultEncoding" value="UTF-8"/>
		<!-- 指定所上传文件的总大小不能超过200KB。注意maxUploadSize属性的限制不是针对单个文件，而是所有文件的容量之和 -->
		<property name="maxUploadSize" value="200000"/>
	</bean>
	...
	<!-- SpringMVC在超出上传文件限制时，会抛出org.springframework.web.multipart.MaxUploadSizeExceededException -->
	<!-- 该异常是SpringMVC在检查上传的文件信息时抛出来的，而且此时还没有进入到Controller方法中 -->
	<bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
		<property name="exceptionMappings">
			<props>
				<!-- 遇到MaxUploadSizeExceededException异常时，自动跳转到/WEB-INF/jsp/error_fileupload.jsp页面 -->
				<prop key="org.springframework.web.multipart.MaxUploadSizeExceededException">error_fileupload</prop>
			</props>
		</property>
	</bean>
	...
</beans>

因为需要上传文件，所以还要导入几个jar包才可以，commons-fileupload-*.jar和commons-io-*.jar等包。

此致，上传功能已经完成了！下面展示一张，项目截图，

点击提交后，如果上传成功，会跳转至上传成功(uploadFileSuccess.jsp),并且在管理端打印了该文件的信息，

我们去上传文件的保存目录（D:/java_web/upload）看看是否有上传文件，

点击提交后，如果上传失败，会跳转至上传失败(uploadFileFail.jsp)，在控制台会输出上传失败原因，便于大家分析出错原因。

2.客户端调用接口上传文件。

  在Android设备上，选择一张图片，上传至后台。

(1). 选择图片，

  /**
     * 选择图片
     */
    private void selectPic() {
        Intent intent = new Intent();
        if (Build.VERSION.SDK_INT < 19) {//因为Android SDK在4.4版本后图片action变化了 所以在这里先判断一下
            intent.setAction(Intent.ACTION_GET_CONTENT);
        } else {
            intent.setAction(Intent.ACTION_OPEN_DOCUMENT);
        }
        intent.setType("image/*");
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        startActivityForResult(intent, PICTURE);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (data == null) {
            return;
        }
        Uri uri = data.getData();
        switch (requestCode) {
            case PICTURE:
                String imagePath = FileUtils.getUriPath(this, uri); //（因为4.4以后图片uri发生了变化）通过文件工具类 对uri进行解析得到图片路径
                if (!TextUtils.isEmpty(imagePath)) {
                    uploadFile(imagePath);
                }
                break;
            default:
                break;
        }
    }

  /**
     * 文件上传
     *
     * @param filePath
     */
    private void uploadFile(String filePath) {
        File file = new File(filePath);
        TypeToken<EntityResponse<Image>> typeToken = new TypeToken<EntityResponse<Image>>() {
        };
        OkHttpUtils.getInstance().postAsyn(Constant.UPLOAD_PIC_URL, null, file,"file",typeToken, new BaseResponseCallback<EntityResponse<Image>>() {

            @Override
            public void onCompleted(final Throwable e, EntityResponse<Image> result) {
                if (e != null) {
                    tv.post(new Runnable() {
                        @Override
                        public void run() {
                            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_LONG).show();
                        }
                    });
                } else {
                    //获取接口返回的列表数据
                   Image image = result.getObject();
                    final StringBuffer sb = new StringBuffer();
                    sb.append("文件名称：" + image.getName() + ", 下载地址：" + image.getUrl() );
                    //更新UI,在子线程中，不能直接更新UI
                    tv.post(new Runnable() {
                        @Override
                        public void run() {
                            tv.setText(sb.toString());
                        }
                    });
                }
            }
        });
    }

选择完成后，上传成功返回json数据截图，

上传成功截图，

再看看服务端截图，控制台输入日志截图，

然后打开上传文件目录，

上传文件也OK了！

四、总结

     本文主要是基于封装Okhttp请求的类调用后台服务接口，实现不同的功能！经测试，该类基本满足功能！本文对上篇文章封装的Okhttp请求类有所优化，更加详细的代码，请看本篇的例子工程源代码！本文需要有点Okhttp和SpringMVC方面的知识！

PS: Demo下载链接（包含服务端和客户端程序）。

由于项目需要，所以用SurfaceView写了一个自定义View，根据晓风飞雨的温度计源码做了一部分修改而来，效果是双汞柱 不废话了 先上源码

package view;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.example.sc.bloodpressuremeter.R;

import java.text.DecimalFormat;

/**
 * TODO: document your custom view class.
 */
public class Thermometer extends SurfaceView implements SurfaceHolder.Callback, Runnable {
    private SurfaceHolder mHolder;
    private Canvas mCanvas;

    //定义左侧范围
    int left_temperatureRange = 15;
    //定义右侧范围
    int right_temperatureRange = 20;
    //定义一个盘快的范围
    private RectF mRange = new RectF();
    //定义温度计的宽度和中心宽度
    int mWith;
    int mHeight;
    int centerWith;
    int centerHeight;

    //定义温度计刻度总长度
    int temperatureAllLong;

    //定义一下水银的宽度
    int MercuryWith;
    //十的倍数的线长度
    int MaxLineLong;
    //五的倍数的线的长度
    int MidLineLong;
    //其他刻度线的长度
    int MinLineLong;
    //左侧刻度间隔
    float left_scaleLong;
    //右侧刻度间隔
    float right_scaleLong;

    //定义温度计距离画布的上宽度
    float abHeight;

    //绘制线条的画笔
    private Paint LinePaint;
    //绘制文本的画笔
    private Paint TextPaint1;
    //绘制单位的画笔
    private Paint TextPaint;


    //设置温度上升的速度
    private volatile float mSpeed = 0;
    //kpa上升的速度
    private volatile float mSpeed_kpa = 0;

    //设置背景图
    private Bitmap mBitmap;

    /**
     * 定义初始温度，当前显示正在变化也就是显示的温度，还有目标温度
     * 其中，初始温度不变，
     * 当前温度是有程序根据不同的速度和目标温度计算出来的，
     * 目标温度则是由仪器传送过来的数据
     */
    private float BeginTenperature = (float) 0;
    private int left_EndTenperature = 300;
    private int right_EndTenperature = 40;
    private volatile float CurrentTemperature = (float) 0;
    private volatile float CurrentLow_hight = (float) 0;

    float TargetTemperature = 0;
    float Targetlow_hight = 0;

    /**
     * 定义每一秒绘制的次数
     */
    int everySecondTime = 100;

    //设置文字的大小
    private float mTextSize = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SHIFT, 25, getResources().getDisplayMetrics());
    private float mTextSize_ten = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SHIFT, 10, getResources().getDisplayMetrics());
    private float mSymbolTextSize = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SHIFT, 35, getResources().getDisplayMetrics());
    private float mShowSymbolTextSize = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SHIFT, 45, getResources().getDisplayMetrics());
    /**
     * 用户绘制的线程
     */
    private Thread mThread;
    /**
     * 根据目标温度改变要显示的当前温度的线程
     */
    private Thread mChangeTemperatureThread;

    /**
     * 设置一个标志位，用于线程的开启还是关闭的标志
     *
     * @param context
     */
    private Boolean isRunning, isRunning_kpa;

    private DecimalFormat fomat;//格式化float

    public Thermometer(Context context) {
        this(context, null);
    }

    public Thermometer(Context context, AttributeSet attrs) {
        super(context, attrs);
        mHolder = getHolder();
        mHolder.addCallback(this);

    }

    @Override
    protected void onMeasure(int with, int height) {
        super.onMeasure(with, height);
        this.mWith = getMeasuredWidth() / 2;
        this.mHeight = getMeasuredHeight();
        //这里先把中心设置在屏幕的中心
        this.centerWith = mWith / 2 + 100;
        this.centerHeight = mHeight / 2;
        //设置水银的宽度
        MercuryWith = mWith / 6;
        MinLineLong = MercuryWith;
        MidLineLong = MinLineLong * 8 / 6;
        MaxLineLong = MidLineLong * 3 / 2;
        //temperatureAllLong表示温度刻度总长度
        temperatureAllLong = mHeight * 9 / 10;
        //设置左侧刻度间隔,包含了刻度线的长度
        left_scaleLong = temperatureAllLong / left_temperatureRange / 10.0f;//表示一个温度十个刻度

        //设置右侧刻度间隔,包含了刻度线的长度
        right_scaleLong = temperatureAllLong / right_temperatureRange / 5.0f;//表示一个温度5个刻度

        abHeight = mHeight / 30.0f;
    }

    @Override
    public void surfaceCreated(SurfaceHolder surfaceHolder) {
        //初始化画笔
        LinePaint = new Paint();
        //去锯齿
        LinePaint.setAntiAlias(true);
        LinePaint.setColor(Color.WHITE);
        LinePaint.setStyle(Paint.Style.STROKE);
        LinePaint.setStrokeWidth(1);
        //初始化画笔
        TextPaint1 = new Paint();
        TextPaint1.setColor(Color.WHITE);
        TextPaint1.setTextSize(mTextSize);
        TextPaint1.setShader(null);
        //初始化画笔
        TextPaint = new Paint();
        TextPaint.setColor(Color.WHITE);
        TextPaint.setTextSize(mTextSize_ten);
        TextPaint.setShader(null);
        //初始化温度计的范围
        mRange = new RectF(0, 0, mWith, mHeight);
        isRunning = true;
        isRunning_kpa = true;
        mThread = new Thread(this);
        mThread.start();

    }

    @Override
    public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder surfaceHolder) {

        isRunning = false;
        isRunning_kpa = false;

    }

    @Override
    public void run() {
        //不断进行绘制
        while (isRunning) {
            long start = System.currentTimeMillis();
            draw();
            long end = System.currentTimeMillis();
            if (end - start < everySecondTime) {
                //这里控制一下，一秒绘制二十次。也就是五十秒绘制一次
                try {
                    Thread.sleep(everySecondTime - (end - start));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void draw() {

        try {
            mCanvas = mHolder.lockCanvas();
            //这里要判断是不是为空，之因为在用户点击了home以后，可能已经执行到这里
            if (mCanvas != null) {
                //这里是开始绘制自己要的东西
                //先绘制背景,
                drawBg();
                //绘制水银的高度还有，显示体温
                drawShowHeightAndShow();
            }
        } catch (Exception e) {
            // e.printStackTrace();这里的异常不处理，
        } finally {
            if (mCanvas != null) {
                mHolder.unlockCanvasAndPost(mCanvas);
            }
        }

    }


    private void drawShowHeightAndShow() {
        float kpa = Targetlow_hight;
        float CurrentKpa = CurrentLow_hight;
        //这里控制水银的上升速度
        float difference = Math.abs(TargetTemperature - CurrentTemperature);
        float difference_kpa = Math.abs(kpa - CurrentKpa);
        /**
         * //这里定义一个boolean来控制是使用加法还是减法，其中true表示当前温度小于
         * 目标温度，要使用加法，false表示当前温度大于目标温度，要使用减法。
         */
        boolean addORsub = CurrentTemperature >= TargetTemperature ? false : true;
        boolean addOrsub_kpa = CurrentKpa >= kpa ? false : true;
        if (difference == 0 || difference <= 0.005) {
            mSpeed = 0;
            CurrentTemperature = TargetTemperature;
        } else {
            if (difference > 20) {
                mSpeed = (float) 0.5;
            } else {
                if (difference > 10) {
                    mSpeed = (float) 0.15;
                } else {
                    mSpeed = (float) 0.05;
                }
            }
        }
        if (difference_kpa == 0 || difference_kpa <= 0.005) {
            mSpeed_kpa = 0;
            CurrentKpa = kpa;
        } else {
            if (difference_kpa > 2) {
                mSpeed_kpa = (float) 0.6;
            } else {
                if (difference_kpa > 1) {
                    mSpeed_kpa = (float) 0.5;
                } else {
                    mSpeed_kpa = (float) 0.1;
                }
            }
        }
        if (addORsub) {
            CurrentTemperature += 20 * mSpeed;
        } else {
            CurrentTemperature -= 20 * mSpeed;
        }
        if (addOrsub_kpa) {
            CurrentKpa += 2 * mSpeed_kpa;
        } else {
            CurrentKpa -= 2 * mSpeed_kpa;
        }

        //

        Paint RightRectPaint = new Paint();
        RightRectPaint.setColor(Color.WHITE);
        RightRectPaint.setStyle(Paint.Style.FILL);
        Paint LeftRectPaint = new Paint();
        LeftRectPaint.setColor(Color.WHITE);
        LeftRectPaint.setStyle(Paint.Style.FILL);
        //这里主要是对温度的显示，画矩形的过程中，唯一改变的就是Top这一个值了
        //左侧水银柱
        if (Math.abs(CurrentTemperature - TargetTemperature) > 10) {
            float left = (temperatureAllLong / (left_temperatureRange * 1.0f)) * (int) (CurrentTemperature / 20) + (CurrentTemperature % 20) / 2 * (left_scaleLong);
            mCanvas.drawRect(centerWith - MercuryWith / 2, temperatureAllLong + abHeight * 2 - left, centerWith, temperatureAllLong + abHeight * 2, LeftRectPaint);
//            float right = (temperatureAllLong / (right_temperatureRange * 1.0f)) * (int) (CurrentKpa / 2) + (CurrentKpa % 2) / 2 * 4 * (right_scaleLong);
            float right = (temperatureAllLong / (left_temperatureRange * 1.0f)) * (int) (CurrentKpa / 20) + (CurrentKpa % 20) / 2 * (left_scaleLong);
            mCanvas.drawRect(centerWith + MercuryWith / 8, temperatureAllLong + abHeight * 2 - right, centerWith + MercuryWith / 2, temperatureAllLong + abHeight * 2, RightRectPaint);
            isRunning = true;
        } else {
            float left = (temperatureAllLong / (left_temperatureRange * 1.0f)) * (int) (TargetTemperature / 20) + (TargetTemperature % 20) / 2 * (left_scaleLong);
            mCanvas.drawRect(centerWith - MercuryWith / 2, temperatureAllLong + abHeight * 2 - left, centerWith, temperatureAllLong + abHeight * 2, LeftRectPaint);
//            float right = (temperatureAllLong / (right_temperatureRange * 1.0f)) * (int) (kpa / 2) + (kpa % 2) / 2 * 4 * (right_scaleLong);
            float right = (temperatureAllLong / (left_temperatureRange * 1.0f)) * (int) (kpa / 20) + (kpa % 20) / 2 * (left_scaleLong);
            mCanvas.drawRect(centerWith + MercuryWith / 8, temperatureAllLong + abHeight * 2 - right, centerWith + MercuryWith / 2, temperatureAllLong + abHeight * 2, RightRectPaint);
            isRunning = false;
        }
    }

    private void drawBg() {
        mCanvas.drawColor(getResources().getColor(R.color.class_blue));
        //画右边的刻度
        //定义每一个长刻度的高度
        float left_everyTemparaturHeight = temperatureAllLong / (left_temperatureRange * 1.0f);
        float right_everyTemparaturHeight = temperatureAllLong / (right_temperatureRange * 1.0f);
        mCanvas.drawLine(centerWith + MercuryWith / 2, abHeight * 2, centerWith + MercuryWith / 2, right_everyTemparaturHeight * 20 + abHeight * 2, LinePaint);
        for (int i = 0; i < right_temperatureRange; i++) {
            mCanvas.drawLine(centerWith + MercuryWith / 2, right_everyTemparaturHeight * i + abHeight * 2, centerWith + MercuryWith / 2 + MaxLineLong, right_everyTemparaturHeight * i + abHeight * 2, LinePaint);
            if (i == 0) {
                mCanvas.drawText(right_EndTenperature - i * 2 + "", centerWith + MercuryWith / 2 + MaxLineLong + MinLineLong / 3, right_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
                mCanvas.drawText("Kpa", centerWith + MercuryWith / 2 + MaxLineLong + MinLineLong / 3 + 5, right_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2 + 15, TextPaint);
            } else {
                mCanvas.drawText(right_EndTenperature - i * 2 + "", centerWith + MercuryWith / 2 + MaxLineLong + MinLineLong / 3, right_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
            }
            for (int j = 1; j < 5; j++) {
                mCanvas.drawLine(centerWith + MercuryWith / 2, right_everyTemparaturHeight * i + j * (right_scaleLong) + abHeight * 2, centerWith + MercuryWith / 2 + MinLineLong, right_everyTemparaturHeight * i + j * (right_scaleLong) + abHeight * 2, LinePaint);
            }
            //画最后一个刻度
            if (i == right_temperatureRange - 1) {

                mCanvas.drawLine(centerWith + MercuryWith / 2,
                        right_everyTemparaturHeight * (i + 1) + abHeight * 2,//这里加上两倍的上距离
                        centerWith + MercuryWith / 2 + MaxLineLong,
                        right_everyTemparaturHeight * (i + 1) + abHeight * 2, LinePaint);
                mCanvas.drawText(right_EndTenperature - (i + 1) * 2 + "", centerWith + MercuryWith / 2 + MaxLineLong + MinLineLong / 3,
                        right_everyTemparaturHeight * (i + 1) + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
            }
        }
        //画左边的刻度
        mCanvas.drawLine(centerWith - MercuryWith / 2, abHeight * 2, centerWith - MercuryWith / 2, left_everyTemparaturHeight * left_temperatureRange + abHeight * 2, LinePaint);
        for (int i = 0; i < left_temperatureRange; i++) {
            mCanvas.drawLine(centerWith - MercuryWith / 2, left_everyTemparaturHeight * i + abHeight * 2, centerWith - MercuryWith / 2 - MaxLineLong, left_everyTemparaturHeight * i + abHeight * 2, LinePaint);
            if (i == 0) {
                mCanvas.drawText(left_EndTenperature - i * 20 + "", centerWith - (MercuryWith / 2 + MaxLineLong + MinLineLong) - TextPaint1.getTextSize(), left_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
                mCanvas.drawText("mmHg", centerWith - (MercuryWith / 2 + MaxLineLong + MinLineLong) - TextPaint1.getTextSize() + 5, left_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2 + 20, TextPaint);
            } else {
                mCanvas.drawText(left_EndTenperature - i * 20 + "", centerWith - (MercuryWith / 2 + MaxLineLong + MinLineLong) - TextPaint1.getTextSize(), left_everyTemparaturHeight * i + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
            }
            for (int j = 1; j <= 9; j++) {
                if (j == 5) {
                    mCanvas.drawLine(centerWith - MercuryWith / 2, left_everyTemparaturHeight * i + j * (left_scaleLong) + abHeight * 2, centerWith - MercuryWith / 2 - MidLineLong, left_everyTemparaturHeight * i + j * (left_scaleLong) + abHeight * 2, LinePaint);
                } else {
                    mCanvas.drawLine(centerWith - MercuryWith / 2, left_everyTemparaturHeight * i + j * (left_scaleLong) + abHeight * 2, centerWith - MercuryWith / 2 - MinLineLong, left_everyTemparaturHeight * i + j * (left_scaleLong) + abHeight * 2, LinePaint);
                }

            }
            //画最后一个刻度
            if (i == left_temperatureRange - 1) {
                mCanvas.drawLine(centerWith - MercuryWith / 2, left_everyTemparaturHeight * (i + 1) + abHeight * 2, centerWith - MercuryWith / 2 - MaxLineLong, left_everyTemparaturHeight * (i + 1) + abHeight * 2, LinePaint);
                mCanvas.drawText(left_EndTenperature - (i + 1) * 20 + "", centerWith - (MercuryWith / 2 + MaxLineLong + MinLineLong / 3) - TextPaint1.getTextSize(), left_everyTemparaturHeight * (i + 1) + TextPaint1.getTextSize() / 2 + abHeight * 2, TextPaint1);
            }
        }     
    }

    private float trueTemperature = 0;

    public void setTargetTemperature(float targetTemperature, float low_hight) {
        trueTemperature = targetTemperature;
        if (targetTemperature < 0) {
            targetTemperature = 0;
        }
        if (targetTemperature > left_EndTenperature) {
            targetTemperature = left_EndTenperature;
        }
        if (low_hight > left_EndTenperature) {
            low_hight = left_EndTenperature;
        }
        if (low_hight - targetTemperature > 10 && false) {
            TargetTemperature = targetTemperature;
            Targetlow_hight = targetTemperature + 10;
        } else {
            TargetTemperature = targetTemperature;
            Targetlow_hight = low_hight;
        }

        isRunning = true;
        draw();
    }

    public void setTargetTemperatureToZero() {
        TargetTemperature = 0;
        Targetlow_hight = 0;
        isRunning = true;
        run();
    }
}