$《第一行代码：Android》读书笔记——第9章 服务

（一）Service简介

　　服务适合执行那种不需要和用户交互而且还要长期运行的任务。所有的服务代码都是默认运行在主线程中，需要在服务内部手动添加子线程，在子线程中执行耗时任务。

 

（二）线程

1、线程的3种用法：

（1）继承Thread：

 class MyThread extends Thread{
         public void run( ){
                 //执行耗时操作
         }
 }
 new MyThread( ).start( );

（2）实现Runnable接口：

 class MyRunnable implements Runnable{
         public void run( ){
                 //执行耗时操作
         }
 }
 new Thread(new MyRunnable).start( );

（3）使用匿名类：

 new Thread(new Runnable( ){
         public void run( ){
                 //执行耗时操作
         }
 }).start( );

2、Android不允许在子线程中更新UI，只能在主线程中更新。

（三）异步消息处理

1、不直接在子线程中进行UI操作，而是在子线程中通过Handler将Message传送给主线程，主线程中的Handler接收这个message，然后进行UI操作，这叫异步消息处理。

2、异步消息处理四步曲：

（1）在主线程中创建一个Handler类型的类成员变量对象，并重写handleMessage方法，用于处理相应事件：

 private Handler handler = new Handler( ){
         public void handleMessage(Message msg){
                 switch(msg.what){        //msg的what字段是一个标志字段，整型
                         case xxx:
                                 //在这里可以进行UI操作
                                 textView.setText("Change text succeed!")        //改变textView的字符
                                 break;
                         default:
                                 break;
                 }
         }
 }

（2）在子线程中需要进行UI操作时（如按钮点击事件中），创建一个Message对象，并通过Handler对象的sendMessage方法将该消息发送出去，比如：

 public static final int UPDATE_TEXT = 1;        //修改UI的标志值
 ......
 @Override
 public void onClick(View v){
         switch(v.getId( )){
                 case R.id.chage_text_btn:
                         new Thread(new Runnable( ){
                                 @Override
                                 public void run( ){
                                         Message msg = new Message( );
                                         msg.what = UPDATE_TEXT ;
                                         handler.sendMessage(msg);
                                 }
                         }).start( );
                         break;

                 default:
                         break;
         }
 }

（3）发出的Message进入MessageQueue队列等待处理。

（4）Looper一直尝试从MessageQueue中取出等待处理的消息，最后分发回handleMessage方法。

注：Message有一个what字段，可以携带标志识别信息（整型），还有arg1和arg2字段，可以携带整型数据，还有一个obj字段可以带一个Object对象。

3、异步消息处理机制示意图：

（四）AsyncTask

1、AsyncTask类是Android对异步消息处理的封装。

2、使用AsyncTask需要自定义一个类去继承它：

 class MyAsyncTask extends AsyncTask<Params, Progress, Result>

三个泛型的含义：

（1）Params：如果在执行AsyncTask时需要传递信息给后台，则传入此参数，如果不需要则为Void。

（2）Progress：如果在后台执行任务过程中，需要在界面上显示进程，则使用这个参数作为进程的单位，一般为Integer。

（3）Result：后台任务执行完后，如果需要对结果进行返回，则使用这个参数作为返回值的类型，如Boolean。

3、继承时需要实现的几个方法：

（1）void onPreExecute( );

该方法运行在UI线程中，可以进行UI的初始化等操作。

（2）boolean doInBackground(Void... params);

该方法的所有代码都在子线程中运行，在该方法中处理耗时任务，需要调用publicProgress(Progress)方法传递进度。

（3）void onProgressUpdate(Integer... values);

当在doInBackground中调用publicProgress方法时，会自动调用此方法，在这里进行UI操作。

（4）void onPostExecute(Boolean result);

执行收尾工作。

4、要启用MyAsyncTask，在主线程中这样用：new MyAsyncTask.execute( );

 

（五）Service

1、定义Service：

 public class MyService extends Service {
     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }

     @Override
     public void onCreate() {
         super.onCreate();
         Log.d("MyService", "onCreate executed");
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         Log.d("MyService", "onStartCommand executed");
         return super.onStartCommand(intent, flags, startId);
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         Log.d("MyService", "onDestroy executed");
     }
 }

2、Service类中有一个抽象方法onBind，还有三个常用方法：

（1）onCreate( )：会在Service创建时调用。

（2）onStartCommand( )：会在Service启动时调用。

（3）onDestory( )：在Service销毁时调用。

3、Service需要在AndroidManifest.xml中注册。

 <application
         ... >
         <service android:name=".MyService" >
         </service>
         ...
 </application>

4、启动和停止Service：

（1）启动：

 Intent startIntent = new Intent(this, MyService.class);
 startService(startIntent);

（2）停止：

 Intent stopIntent = new Intent(this, MyService.class);
 stopService(stopIntent);

5、Activity和Service通信：

（1）在Service中安插内线Binder，并在onBind方法中发送这个内线：

 public class MyService extends Service {

     private DownloadBinder mBinder = new DownloadBinder();

     class DownloadBinder extends Binder {    //自定义Binder，模拟下载功能
         public void startDownload() {
             Log.d("MyService", "startDownload executed");
         }

         public int getProgress() {
             Log.d("MyService", "getProgress executed");
             return 0;
         }
     }

     @Override
     public IBinder onBind(Intent intent) {
         return mBinder;
     }
     ...    //其他方法
 }

（2）在Activity中创建内线及ServiceConnection，其中的onServiceConnected方法即可接收内线IBinder并通过向下转型获取Binder：

   ...
     private MyService.DownloadBinder downloadBinder;
     private ServiceConnection connection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             downloadBinder = (MyService.DownloadBinder) service;
             downloadBinder.startDownload();
             downloadBinder.getProgress();
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {

         };
     };
     ...

（3）在合适的时候（如按钮的点击事件等）绑定Activity与Service：

 Intent bindIntent = new Intent(this, MyService.class);
 bindService(bindIntent, connection, BIND_AUTO_CREATE);    //BIND_AUTO_CREATE指当绑定后，自动创建Service

（4）解除绑定：

 if(connection != null){
     unbindService(connection);
 }

6、Service的生命周期：

（1）每个Service都只会存在一个实例。

（2）方法：

 startService( )
 onCreate( )
 onStartCommand( )
 onDestory( )
 bindService( )
 unbindService( )
 stopService( )
 stopSelf( )    //在Service中任何地方都可以用这个方法结束服务本身
 onBind( )

（3）如果startService( )和bindService( )都调用了，那么必须同时满足unbindService( )和stopService( )都被调用才会执行onDestory( )方法。

7、前台Service：在系统状态栏中一直显示的可见Service，只需在Service的onCreate方法中添加如下代码即可（其实是通知的用法）：

 　　@Override
     public void onCreate() {
         super.onCreate();
         ...
         Notification notification = new Notification(R.drawable.ic_launcher,
                 "Notification comes", System.currentTimeMillis());
         Intent notificationIntent = new Intent(this, MainActivity.class);
         PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                 notificationIntent, 0);
         notification.setLatestEventInfo(this, "This is title",
                 "This is content", pendingIntent);
         startForeground(1, notification);
     }

8、IntentService：

　　服务的代码默认都是在主线程中的，如果直接在服务里去处理一些耗时逻辑，就很容易出现ANR(Application Not Responding)的情况。这时就可以方便的使用已经把多线程封装好的IntentService类：

 public class MyIntentService extends IntentService {

     public MyIntentService() {        //需要一个无参的构造方法，调用父类的有参构造方法
         super("MyIntentService");
     }

     @Override
     protected void onHandleIntent(Intent intent) {    //这个方法默认在子线程中运行
         // 打印当前线程ID
         Log.d("MyIntentService", "Thread id is "
                 + Thread.currentThread().getId());

         // 在这里已经是在子线程中运行了，可以执行一些耗时操作，但不能执行UI操作
         try {
             Thread.sleep(1000);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         Log.d("MyIntentService", "onDestroy executed");
     }
 }

　　IntentService在任务处理完后，会自动调用onDestory方法，不用再去人工调用unbindService或stopService方法。其他用法和普通Service一样。

（六）Service最佳实践：后台定时任务

1、Android中的定时任务实现方式有两种：Java API的Timer类和Android的Alarm机制。前者会受CPU休眠的影响，后者会唤醒CPU。

2、首先创建一个LongRunningService服务，重写其onStartCommand方法，在这里面执行定时任务：

 import java.util.Date;

 import android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Intent;
 import android.os.IBinder;
 import android.os.SystemClock;
 import android.util.Log;

 public class LongRunningService extends Service {

     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         //创建子线程打印当前时间，模拟定时任务
         new Thread(new Runnable() {
             @Override
             public void run() {
                 Log.d("LongRunningService",
                         "executed at " + new Date().toString());
             }
         }).start();
         //1.创建AlarmManager
         AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
         int aMinute = 60 * 1000; // 一分钟的毫秒数
         long triggerAtTime = SystemClock.elapsedRealtime() + aMinute;
         //2.创建跳到广播接收器的Intent
         Intent i = new Intent(this, AlarmReceiver.class);
         //3.创建PendingIntent
         PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
         //4.使用AlarmManager的set方法
         //第一个参数：指定工作类型，有四种：ELAPSED_REALTIME_WAKEUP表示定时任务触发时间从
         //系统开机算起，会唤醒CPU；ELAPSED_REALTIME，同ELAPSED_REALTIME_WAKEUP，但不会唤醒CPU；
         //RTC表示从1970-1-1 00:00算起，不会唤醒CPU，RTC_WAKEUP同RTC，但会唤醒CPU。
         //注：唤醒CPU和唤醒屏幕是不同的概念。
         manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);

         return super.onStartCommand(intent, flags, startId);
     }
 }

3、创建AlarmReceiver类：

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;

 public class AlarmReceiver extends BroadcastReceiver {

     @Override
     public void onReceive(Context context, Intent intent) {
         Intent i = new Intent(context, LongRunningService.class);
         context.startService(i);    //反过来再启动服务，交替循环进行下去
     }
 }

4、在活动中启动服务：

 import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;

 public class MainActivity extends Activity {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);

         Intent i = new Intent(this, LongRunningService.class);
         startService(i);
     }
 }

5、在AndroidManifest.xml中注册服务和广播接收器。

6、分析：刚刚创建的这个定时任务，会每隔一分钟执行一次。

【本章结束】