【Anroid学习笔记】 Handler、AsyncTask、服务的基本使用

Handler

Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。

先来学习下异步消息处理的使用：

class MainActivity extends AppCompatActivity implements View.onClickListener{ 
    static final int UPDATE_TEXT = 1; 
    TextView text; 
    Handler handler = new Handler(){ 
        handleMessage(Message msg){ 
            switch(msg.what){ 
                case UPDATE_TEXT: 
                    //在这里进行UI操作 
                    text.setText("Nice to meet you"); 
                    break; 
                default: 
                    break; 
                } 
            } 
        } 

    onClick(){ 
        switch(v.getId()){ 
            case R.id.change_text: 
                new Thread(new Runnable(){ 
                    run(){ 
                        Message message = new Message(); 
                        message.what = UPDATE_TEXT; 
                        //将message对象发送出去 
                        handler.sendMessage(message); 
                    } 
                }).start(); 
                break; 
            default: 
                break; 
        } 
    } 
}

 

解析异步消息处理机制

Android中的异步消息处理主要由4部分组成：

1.Message

Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。

2.Handler

Handler主要是用于发送和处理消息的。发送消息一般是使用Handler的sendMessage()方法，而发出的消息经过一系列的辗转处理之后，最终会传递到Handler的handleMessage()方法中。

3.MessageQueue

MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。

4.Looper

Looper是每个线程中的MessageQueue的管家，调用Looper的loop()方法后，就会进入到讴歌无限循环中，每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程中也只会有一个Looper对象。

 

异步消息处理的整个流程：首先需要在主线程当中创建一个Handler对象，并重写handleMessage()方法。然后当子线程中需要进行UI操作时，就会创建一个Message对象，并通过Handler将这条消息发送出去。之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回Handler的handleMessage()方法中。

 

使用AsyncTask

即使你对异步消息处理机制不了解，借助AsyncTask，也可以非常简单地从子线程切换回主线程中。

 

AsyncTask是一个抽象类，使用前必须要创建一个子类去继承它，在继承时我们可以为AsyncTask类指定3个泛型参数，这三个参数的用途如下：

Parms：在执行AsyncTask时需要传入的参数，可用于后台任务中使用。

Progress：后台任务执行时，如果需要在界面上显示当前进度，使用这里指定的泛型作为进度单位。

Result：当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

 

因此，一个最简单的AsyncTask就可以写成这样：

//不需要传入参数给后台任务，使用整形数据来作为进度显示单位 
//使用布尔类型数据来反馈执行效果 
class DownLoadTask extends AsyncTask{ 
    ... 
}

 

目前我们自定义的DownloadTask还是个空任务，接下来我们需要去重写AsyncTask中的几个方法来完成对任务的定制，经常需要去重写的方法有以下4个：

1.onPreExecute()

这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作。

2.doInBackground(Params...)

这个方法的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。如果需要返回数据，任务一旦完成，就可以使用return将任务的执行结果返回。如果要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress...)方法来完成。

3.onProgressUpdate(Progress...)

当在后台任务中调用了publishProgress(Progress...)方法后，onProgressUpdate(Progress...)方法很快会被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。

4.onPostExecute(Result)

当后台任务执行完毕并通过return语句进行返回时，这个方法很快就会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关掉进度条对话框等。

因此，一个比较完成的自定义AsyncTask可以写成如下格式：

class DownloadTask extends AsyncTask{ 
    void onPreExecute(){ 
        progressDialog.show();//显示进度条对话框 
    } 

    Boolean doInBackground(Void... params){ 
        try{ 
                while(true){ 
                    int downloadPercent = doDownload(); 
                    publishProgress(downloadPercent); 
                    if(downloadPercent>=100){ 
                    break; 
                    } 
                } 
        }catch(Exception e){ 
            ... 
        } 
    } 

    void onProgressUpdate(Integer... values){ 
        //在这里更新下载进度 
        progressDialog.setMessage("Downloaded "+values[0]+"%"); 
    } 

    void onPostExecute(Boolean result){ 
        progressDialog.dismiss();//关闭进度对话框 
        //在这里提示下载结果 
        if(result){ 
            ... 
        }else{ 
            ... 
        } 
    } 
}

简单地说，使用AsyncTask的诀窍就是，在doInBackground()方法中执行具体的耗时任务，在onProgressUpdate()方法中进行UI操作，在onPostExecute()方法中执行一些任务的收尾工作。

 

如果想要启动这个任务，只需编写如下代码：

new DownloadTask().execute();

 

服务的基本用法

定义一个服务

使用AS创建一个Service，勾选Exported和enable选项，重写Service的一些方法，如下：

public class MyService extends Service{ 
    
    onBind(){ 
        ... 
    } 
    
    //服务创建时调用 
    onCreate(){ 
        ... 
    } 

    //服务启动时调用 
    onStartCommand(Intent intent,int flags,int startId){ 
        ... 
    } 

    //服务销毁时调用 
    onDestroy(){ 
        ... 
    } 
}

 

每个服务都需要在AndroidManifest.xml文件中注册才能生效（AS已帮我们自动生成）：

 

这样的话，就已经将一个服务定义好了。

 

启动和停止服务

核心代码：

onClick(View v){ 
    switch(v.getId()){ 
        case R.id.start_service: 
            Intent startIntent = new Intent(this,MyService.class);             
            startService(startIntent);//启动服务 
        case R.id.stop_service: 
            Intent stopintent = new Intent(this,MyService.class);         
            stopService(stopIntent);//停止服务 
            break; 
        default: 
            break; 
    } 
}

补充：服务可以调用stopSelf()让自身停止下来。

 

活动和服务进行通信

借助服务中的onBind()方法，可以让活动和服务建立起更紧密的联系：

class MyService extends Service{ 
    private DownloadBinder mbinder = new DownloadBind(); 

    class DownloadBinder extends Binder{ 
        void startDownload(){
             ... 
        } 

        int getProgress(){ 
            ... 
        } 
    } 

    IBinder onBind(Intent intent){ 
        return mBinder; 
    } 

    ... 
}

 

当活动和服务绑定了之后，就可以调用该服务里的Binder提供的方法了：

class MainActivity extends AppCompatActivity implements View.OnClickListener{ 
    private MyService.DownloadBinder downloadBinder; 
    private ServiceConnection connection = new ServiceConnection(){ 
        onServiceDisconnected(){ 
        } 
        onServiceConnected(ComponentName name,IBinder service){ 
            downloadBinder = (MyService.DownloadBinder)service; 
            downloadBinder.startDownload(); 
            downloadBinder.getProgress(); 
        } 
    }; 

    onCreate(){ 
        ... 
    } 

    onClick(View v){ 
        switch(v.getId()){ 
            case R.id.bind_service: 
                Intent bindIntent = new Intent(this,MyService.class); 
                //参数1：intent；参数2:ServiceConnection实例 
                //参数3：标志位，BIND_AUTO_CREATE自动创建服务但不启动         
                bindService(bindIntent,connection,BIND_AUTO_CREATE);//绑定服务 
                break; 
            case R.id.unbind_service: 
                unbindService(connection);//解绑服务 
                break; 
            default: 
                break; 
        } 
    } 
}

onServiceConnected()会在绑定时执行，onServiceDisconnected()会在解绑时执行，当MyService与活动绑定完之后，我们就可以在活动的任意地方调用downloadBinder中的任何public方法了。另外，任何一个服务在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity绑定，还可以和任何其他一个活动进行绑定。

 

使用前台服务

前台服务会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似通知的效果。

核心代码：

class MyService extends Service{ 
    onCreate(){ 
        Intent intent = new Intent(this,MainActivity.class); 
        PendingIntent pi = PendingIntent.getActivity(this,0,intent,0); 
        Notification notification = new NotificationCompat.Builder(this)     
                                    .setContentTitle("This is content title")         
                                    .setContentText("This is content text")     
                                    .setWhen(System.currentTimeMillis()) 
                                    .setSmallIcon(R.mipmap.ic_launcher) 
                                    .setLargeIcon(BitmapFactory.decodeResource(     
                                    getResourses(),R.mipmap.ic_launcher))     
                                    .setContentIntent(pi) 
                                    .build(); 
        //调用startForeground()会让MyService变成一个前台服务 
        //参数1：通知的ID；参数2：Notification对象 
        startForeground(1,notification); 
    } 
}

 

使用IntentService

为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个IntentService类。

新建一个MyIntentService类继承自IntentService：

class MyIntentService extends IntentService{ 
    public MyIntentService(){ 
        super("MyIntentService"); 
    } 

    //此方法代码位于子线程执行，可以防止主线程阻塞 
    //代码执行完毕之后，会自动停止服务 
    protected void onHandleIntent(Intent intent){ 
        ... 
    } 

    public void onDestroy(){ 
        ... 
    } 
}

 

调用MyIntentService：

Intent intentService = new Intent(this,MyIntentService.class); 
startService(intentService);

另外，不要忘记在AndroidManifest.xml对服务进行注册：