Android初体验——探究服务

服务

服务是Android中实现程序后台运行的解决方案，它非常适合执行那些不需要和用户交互而且还要求长期运行的任务。服务的运行不依赖任何用户界面，即使程序被切换到后台，或者用户打开了另一个应用程序，服务仍然能够正常运行。

服务并不是运行在一个独立的进程当中，而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖该进程的服务也会停止运行。

服务并不会自动开启线程，所有的代码默认运行在主线程当中。我们需要在服务的内部手动创建子线程，并在这里执行具体的任务，否则就有可能出现主线程被阻塞的情况。

Android多线程编程

一些比较耗时的操作基本都会放在子线程中进行。

主线程也叫UI线程，如果我们把耗时的操作都放在UI线程中的话，如果UI线程超过5s没有响应用于请求，那么这个时候会引发ANR(Application Not Responding)异常，就是应用无响应。 最后还有一点就是：Android 4.0后禁止在UI线程中执行网络操作~不然会报:android.os.NetworkOnMainThreadException

线程的基本用法

Android的多线程其实与Java的类似，基本都是相同的语法。

• 新建一个类继承自Thread，重写父类的run（）方法，并在里面编写耗时的逻辑即可。

class MyThread extends Thread {
    @Override
    public void run() {
        //处理具体的逻辑
    }
}
new MyThread().start();

启动线程：new出MyThread的实例，调用start（）方法，这样run方法中的代码就会在子线程当中运行。

• 使用继承的方法耦合性较高，更多时候我们会选择使用实现Runnable接口的方法来定义一个线程

class MyThread implements Runnable{
    @Override
    public void run() {
        //处理具体的逻辑
    }
}
MyThread myThread = new MyThread();
new Thread(myThread).start();

Thread的构造函数中需要接受一个Runnable参数，而MyThread正是一个实现了Runnable接口的对象，所以可以直接将它传入，调用start方法即可。

• 也可使用匿名类的方法

new Thread(new Runnable() {
    @Override
    public void run() {
        //处理的具体逻辑
    }
}).start();

在子线程中更新UI

Android的UI是线程不安全的，如果想要更新UI必须在主线程中进行，否则会出现以下异常。

android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

由此证实Android确实不允许在子线程中进行UI操作。但是有些时候我们必须在子线程里去执行一些耗时任务，然后根据任务的执行结果来更新相应的UI控件。

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

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private TextView text;
    public static final int UPDATE_TEXT = 1;
    //定义了一个常量 用于表示更新TextView

    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            //重写handleMessage 如果what字段为1 执行更新操作
            switch (msg.what) {
                case UPDATE_TEXT:
                    //在这里可以进行UI操作
                    text.setText("Nice to meet you");
                    break;
                default:
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text);
        Button changeText = (Button) findViewById(R.id.change_text);
        changeText.setOnClickListener(this);
    }


    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.change_text:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //创建一个Message实例 将what字段设为1
                        Message message = new Message();
                        message.what = UPDATE_TEXT;
                        //将Message对象发送出去
                        handler.sendMessage(message);
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

注意
Handler的无参构造被废弃，会造成内存泄漏，程序崩溃，存在安全隐患。Java 中非静态内部类会隐匿地持有外部类的引用，如果一个 Activity 有一个非静态的 Handler ，当这个 Activity 要回收的时候，Handler 可能仍在执行耗时操作，此时 Handler 不能被释放，其对 Activity 的引用也就不能被释放，导致 Activity 不能被回收，停留在内存中，造成内存泄漏。

对于这个问题，有两种解决方法，一种是将 Handler 设置成静态内部类，同时让它持有 Activity 的弱引用；第二种是在 Activity 的生命周期 onDestroy() 中调用Handler的removeCallback()方法，撤销 Handler 在 Activity 上的回调，让Activity 能成功被释放，避免内存泄漏。

解析异步消息处理机制

主要由四部分组成：

• Message
  在线程之间传递信息，它可以在内部携带少量信息，用于在不同线程之间交换数据。有what字段，arg1和arg2字段用来携带一些整形数据，obj字段携带一个Object对象。
• Handler
  发送和处理信息。发送一般用sendMessage（）方法。而发出的信息经过一系列地辗转处理后，最终会传递到Handler的handleMessage（）中
• MessageQueue
  是一个消息队列，以先进先出的方式来管理 Message ，存放所有通过Handler发送的信息。MessageQueue 是 Looper 的一个成员变量，因此，在创建 Looper 的时候，MessageQueue 就被创建了，两者就已经关联到了一起；
• Looper
  每个线程中的MessageQueue的管家，调用loop（）后，就会进入到一个无限循环中，每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage（）中。每个线程也只有一个Looper对象。

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

由于Handler是在主线程中创建的，所以此时handleMessage（）方法中的代码也会在主线程中进行。

每个线程都有 Looper ，但是如果你要在这个线程中使用 Handler 来处理异步消息，你在使用之前需要调用 Looper.prepare() 和 Looper.loop() 方法，这样才能使用 Handler，不然会报错 Activity的UI线程在开启的时候就调用了这两个方法，所以不用我们再写，直接使用 Handler就行了，因为是在UI线程开启，所以在Handler中可以对UI的进行更新。

runOnUiThread（）其实就是一个异步消息处理机制的接口封装，背后实现原理与上述一样。

使用AsyncTask

AsyncTask是一个抽象类，必须创建一个子类继承它。在继承时需要指定三个泛型参数。
android.os.AsyncTask<Params, Progress, Result>
Params

参数	作用
Params	在执行AsyncTask时需要传入的参数，可用于在后台任务中使用
Progress	后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位
Result	任务执行完毕后，如果需要对结果进行返回，使用这里指定的泛型作为返回值类型

自定义可这样写：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
    ...
}

第一个泛型参数为void，表示在执行时不需要传入参数给后台服务。第二个指定为Integer，表示在使用整形数据来作为进度显示的单位。第三个为Boolean表示用布尔型数据来反馈执行结果。

此时自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，一般需要重写内部的几个方法实现对任务的定制。

1. onPreExecute（）
   会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作。
2. doInBackground（Rarams...）
   该方法中所有代码都会在子线程中运行，我们应该在这里去处理所有耗时的任务。任务一旦完成就会通过return来将结果返回。如果AsyncTask第三个参数是void，可以不返回执行的结果。该方法中不可以进行UI操作。
3. onProgressUpdate（Progress...)
   当在后台任务中调用了publishProgress（Progress…)方法后，该方法会被调用，该方法中携带的参数是后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数数值就可以对界面元素进行更新。
4. onPostExecute(Result result)
   在主线程中执行，在异步任务执行之后，此方法会被调用，其中result参数是后台任务的返回值，即doInBackground的返回值。

public class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
    ProgressDialog progressDialog;
    int downloadPercent;
    Context context;
    public DownloadTask(Context context) {
        this.context = context;
    }
    @Override
    protected void onPreExecute() {
        //后台任务执行之前调用，进行一些界面的初始化操作
        super.onPreExecute();
        progressDialog = new ProgressDialog(context);
        //显示对话框
        progressDialog.show();
    }

    @Override
    protected Boolean doInBackground(Void... voids) {
        //这个方法所有的代码都在子线程中运行，在这里处理费时操作
        while (true) {
            downloadPercent+=1;
            publishProgress(downloadPercent);
            if(downloadPercent >= 100) {
                break;
            }
        }
        return true;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        //当后台任务中调用了publishProgress(Progress...)方法之后，该方法很快被调用，可进行一些UI操作
        //更新下载进度
        progressDialog.setMessage("Downloaded " + values[0] + "%");
    }

    @Override
    protected void onPostExecute(Boolean aBoolean) {
        //关闭进度对话框
        progressDialog.dismiss();
        //在这里提示下载结果
        if(aBoolean) {
            Toast.makeText(context, "Download succeeded", Toast.LENGTH_SHORT).show();
        }else {
            Toast.makeText(context, "Download failed", Toast.LENGTH_SHORT).show();
        }
    }
}

在doInBackground中执行具体的下载任务，这个方法中的代码都是在子线程中运行的，不会影响到主线程的运行。调用publishProgress并将当前下载的进度传入，这样onProgressUpdate很快会被调用，在这里就可以进行UI操作了。

当下载完成后，doInBackground会返回一个布尔类型的参数，这样onPostExecute会被调用，这个方法也是在主线程中运行的，这里会根据下载结果给予不同提示。

使用AsyncTask诀窍在于，在doInBackground中执行具体的耗时任务，在onProgressUpdate中进行UI操作，在onPostExecute中进行收尾。

启动该任务

new DownloadTask(MainActivity.this).execute();

AsyncTask被废弃

于 AsyncTask 与 Activity 或 Fragment 的生命周期无关而导致的内存泄漏等等。 如果你对执行 AsyncTask使用不当，最终会在意想不到的地方发生崩溃。

服务的基本用法

定义一个服务

创建服务窗口中，Exported属性表示是否允许除了当前程序之外的其他程序访问这个服务。Enabled属性表示是否启用这个服务。

public class MyService extends Service {
    public MyService() {
    }

    //在服务创建时调用
    @Override
    public void onCreate() {
        super.onCreate();
    }

    //在每次服务启动时调用
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    //在服务销毁时调用
    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    //唯一一个抽象方法
    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

每一个服务都需要在AndroidManifest.xml中注册。

onCreate() 主要在服务第一次创建时调用，onStartCommand()在每次启动服务时调用。

启动和停止服务

借助Intent实现

Intent startIntent = new Intent(this, MyService.class);
//启动服务 利用Context.startService
startService(startIntent);

Intent stopIntent = new Intent(this, MyService.class);
//停止服务
stopService(stopIntent);

首先构造出一个Intent对象，并调用startService与stopService两个方法来实现启动和停止服务。在这里完全是由活动来决定服务何时停止的，服务也可以让自己停下来，只需要在MyService的任何位置调用stopSelf（）即可。

活动和服务进行通信

实现在活动中指挥服务，需要借助onBind（）方法。
如果想在MyService中提供一个下载功能，在活动中决定何时开始下载，以及随时查看下载进度。思路：创建一个专门的Binder对象来对下载功能进行管理。

private DownloadBinder mBinder = new DownloadBinder();

class DownloadBinder extends Binder {
    public void startDownload() {
       Log.d("TAG", "startDownload executed");
    }

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

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

新建一个DownloadBinder类，让它继承Binder，在内部提供开始下载以及查看下载进度的两个模拟方法。在MyService中创建DownloadBinder实例，在onBind（）方法中返回这个实例。

private MyService.DownloadBinder downloadBinder;
    private ServiceConnection connection = new ServiceConnection() {
        //活动与服务成功绑定
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //得到DownloadBinder实例
            downloadBinder = (MyService.DownloadBinder) iBinder;
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        //活动与服务连接断开
        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

MainActivity中首先创建了ServiceConnection的匿名类，重写了两个方法，分别在绑定后以及解除后调用。在绑定所调方法中通过向下转型得到了DownloadBinder实例。可以在活动中根据具体的场景来调用DownloadBinder 中的方法。
进行绑定：

Intent bindIntent = new Intent(this, MyService.class);
//绑定服务
//接收三个参数 第一个时Intent对象 第二个是前面创建的ServiceConnection实例 第三个是一个标志位
//BIND_AUTO_CREATE表示在活动和服务进行绑定后自动创建服务 使得MyService的onCreate（）得到执行
bindService(bindIntent, connection, BIND_AUTO_CREATE);

解除绑定：

//解绑服务
unbindService(connection);

任何服务器在整个应用程序内都是通用的，即MyService可以与任何一个其他活动进行绑定，且绑定后都可以获取到相同的DownloadBinder实例。

服务的生命周期

• onCreate()

首次创建时调用

• onStartCommand()

启动服务的时候调用，调用startService方法或者startForegroundService方法，回调此方法，如果这个服务还没有被创建过，onCreate()方法会先于这个方法调用

• onBind()

在使用bindService()与服务绑定后回调此方法

• onDestroy()

服务销毁时调用，比如调用了stopService(),stopSelf(),unbindService()方法

注意
虽然每次调用startService（）方法，onStartCommand()会被执行一次，但实际上每个服务都只会存在一个实例。所以不管调用多少次startService，只需要调用一次stopService（）或stopSelf（）方法，服务就会停下来。

调用bindService()方法前，如果服务还没有创建过，onCreate()方法会先于这个方法调用。

如果一个服务既调用了startService（）又调用了bindService()，需要同时调用unbindService()，stopService()才会销毁服务。

使用前台服务

由于服务的系统优先级较低，当系统出现内存不足时，有可能会回收掉正在后台运行的服务。使用前台服务可以使服务一直保持运行的状态，而不会由于系统内存不足的原因导致被回收。
前台服务会一直有一个正在运行的图标在状态栏显示，下拉后可看到详细信息，类似于通知。

//传入的参数用于确定获取系统的哪个服务
NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
            NotificationChannel channel = new NotificationChannel("1","1",NotificationManager.IMPORTANCE_DEFAULT);
            manager.createNotificationChannel(channel);
        }
        Notification notification = new NotificationCompat.Builder(MyService.this,"1")
                .setChannelId("1")
                .setContentTitle("this is Title")
                .setContentText("this is text")
                .setSmallIcon(R.mipmap.ic_launcher)
                .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher))
                .build();
        startForeground(1,notification);

上述大多数代码与通知类似，通过startForeground（）可以让MyService变成一个前台服务，并在状态栏显示。该方法接收两个参数，第一个是通知的id，第二个是构建出的notification对象。

使用IntentService

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

public class MyIntentService extends IntentService {
    public MyIntentService(String name) {
        //无参构造，在内部调用父类的有参构造器
        super("MyIntentService");
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        //这个方法是在子线程运行的
        Log.d("TAG", "Thread id is " + Thread.currentThread().getId());
    }

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

注册：

<service android:name=".MyIntentService"/>

调用：

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