Android开发学习笔记(五) —— 温习Service

一、什么是Service

服务（Service）是Android四大组件之一（因此需要在AndroidManifest.xml中进行注册，否则系统无法识别该Service），是Android中实现程序后台运行的解决方案，非常适合去执行那些不需要和用户交互（因而也不需要UI界面）而且还要求长期运行的任务，例如播放音乐、下载文件、上传数据等。服务的运行不依赖于任何用户界面，即使程序被切换到后台，或者用户打开了另外一个应用程序，服务仍然能够保持正常运行。

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

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

二、Android多线程编程

2.1 线程的基本用法

定义一个线程只需要新建一个类继承自Thread，然后重写父类的run()方法，并在里面编写我们想要处理的事务的逻辑即可，如下所示：

1
2
3
4
5
6
class MyThread extends Thread{
    @Override
    public void run(){
        //处理事务的具体逻辑
    }
}

那么该如何启动这个线程呢？其实也很简单，只需要new出MyThread的实例，然后调用它的start()方法，这样run()方法中的代码就会在子线程当中运行了，如下所示：

1
new MyThread().start();

当然，更多的时候我们都会选择使用实现Runnable接口（Thread类也实现该接口）的方式来定义一个线程，如下所示：

1
2
3
4
5
6
class MyThread implements Runnable{
    @Override
    public void run() {
		//处理事务的具体逻辑
    }
}

如果使用了这种写法，启动线程的方法也需要进行相应的改变，如下所示：

1
new Thread(new MyThread()).start();

可以看到，Thread的构造函数接收一个Runnable参数（只是其中一个构造方法），而我们new出的MyThread正是一个实现了Runnable接口的对象，所以可以直接将它传入到Thread的构造函数里。接着调用Thread的start()方法，run()方法中的代码就会在子线程当中运行了。

当然，更常见的写法时使用匿名类的方式，如下所示：

1
2
3
4
5
6
new Thread(new Runnable() {
    @Override
    public void run() {
		//处理事务的具体逻辑
    }
}).start();

2.2 在子线程中更新UI

和许多其他的GUI库一样，Android的UI也是线程不安全的。也就是说，如果想要更新应用程序里的UI元素，则必须在主线程中进行，否则就会出现异常。

我们通过一个具例子来验证一下。新建一个项目，然后修改activity_main.xml中的代码，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:orientation="vertical"
    android:gravity="center">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="change text"
        android:onClick="ClickChangeUI"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:layout_marginTop="40dp"/>

</LinearLayout>

布局中定义了一个TextView控件，用于显示字符串，然后还有一个按钮，用于改变TextView显示的内容。

接下来是MainActivity中的代码，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MainActivity extends AppCompatActivity {

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

    public void ClickChangeUI(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                TextView textView = findViewById(R.id.id_text);
                textView.setText("aaaaaaaaaaa");
            }
        }).start();
    }

}

可以看到，我们在按钮的点击事件里面开启了一个子线程，然后在子线程中修改TextView控件的字符串。现在运行程序并点击按钮，我们会发现程序崩溃，错误信息如下所示。

1
2
FATAL EXCEPTION: Thread-2
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

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

对于这种情况，Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。我们先来学习一下异步消息处理的使用方法。

修改MainActivity中的代码，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class MainActivity extends AppCompatActivity {

    private static final int UPDATE_TEXT = 1;

    private Handler handler = new Handler(){
      public void handleMessage(Message msg){
          switch (msg.what){
              case UPDATE_TEXT:
                  TextView textView = findViewById(R.id.id_text);
                  textView.setText("aaaaaaaaaaa");
                  break;
              default:
                  break;
          }
      }
    };

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

    public void ClickChangeUI(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Message message = new Message();
                message.what = UPDATE_TEXT;
                handler.sendMessage(message);
            }
        }).start();
    }

}

这里我们先是定义了一个整型常量UPDATE_TEXT，用于表示更新TextView这个动作。然后新增一个Handler对象，并重写父类的handleMessage()方法，在这里对具体的Message进行处理。如果发现Message的what字段的值等于UPDATE_TEXT，就更改TextView的内容。

接下来是按钮的点击事件中的代码。可以看到，这次我们并没有在子线程里直接进行UI操作，而是创建了一个Message（android.os.Message）对象，并将它的what字段的值指定为UPDATE_TEXT，然后调用Handler的sendMessage()方法将这条Message发送出去。很快，Handler就会收到这条Message，并在handleMessage()方法中对它进行处理。注意此时handleMessage()方法中的代码就是在主线程当中运行的了，所以我们可以放心地在这里进行UI操作。

现在重新运行程序并点击按钮，发现程序并没有崩溃，而且TextView中的内容更改了。

现在可以说我们了解了Android异步消息处理的基本用法，但是我们并不了解它的工作原理，因此下面我们就来分析一下Android异步消息处理机制到底是如何工作的。

2.3 解析异步消息处理机制

Android中的异步消息处理主要由4个部分组成：Message、Handler、MessageQueue和Looper。

  1. Message
    Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。上一小节中我们使用到了Message的what字段，除此之外还可以使用arg1和arg2字段来携带一些整型数据，使用obj字段携带一个Object对象。
  2. Handler
    Handler顾名思义也就是处理者的意思，它主要是用于发送和处理消息的。发送消息一般是使用Handler的sendMessage()方法，而发出的消息经过一系列地辗转处理后，最终会传递到Handler的handleMessage()方法中。
  3. MessageQueue
    MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。
  4. Looper
    Looper是每个线程中的MessageQueue的管家，调用Looper的Loop()方法后，就会进入到一个无限循环当中，然后每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程中也只会有一个Looper对象。

了解了Message、Handler、MessageQueue以及Looper的基本概念后，我们再来把异步消息处理的整个流程梳理一遍。首先需要在主线程当中创建一个Handler对象，并重写handleMessage()方法。然后当子线程中需要进行UI操作时，就创建一个Message对象，并通
过Handler将这条消息发送出去。之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回Handler的handleMessage()方法中。由于Handler是在主线程中创建的，所以此时handleMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以安心地进行UI操作了。整个异步消息处理机制的流程示意图如图所示：

一条Message经过这样一个流程的辗转调用后，也就从子线程进入到了主线程，从不能更新UI变成了可以更新UI，整个异步消息处理的核心思想也就是如此。

2.4 使用AsyncTask

不过为了更加方便我们在子线程中对UI进行操作，Android还提供了另外一些好用的工具，比如AsyncTask。借助AsyncTask，即使你对异步消息处理机制完全不了解，也可以十分简单地从子线程切换到主线程。当然，AsyncTask背后的实现原理也是基于异步消息处理机制的，只是Android帮我们做了很好的封装而已。

首先来看一下AsyncTask的基本用法，由于AsyncTask是一个抽象类，所以如果我们想使用它，就必须要创建一个子类去继承它。在继承时我们可以为AsyncTask类指定3个泛型参数，这3个参数的用途如下：

  • Params

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

  • Progress

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

  • Result

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

因此，一个最简单的自定义AsyncTask就可以写成如下方式：

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

这里我们把AsyncTask的第一个泛型参数指定为Void，表示在执行AsyncTask的时候不需要传入参数给后台任务。第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean，则表示使用布尔型数据来反馈执行结果。

当然，目前我们自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，我们还需要去重写AsyncTask中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下4个：

  1. onPreExecute()
    这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。
  2. doInBackground (Params…)
    这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果返回，如果AsyncTask的第三个泛型参数指定的是Void,就可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress...)方法来完成。
  3. onProgressUpdate(Progress…)
    当在后台任务中调用了publishProgress(Progress...)方法后，onProgressUpdate(Progress...)方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。
  4. onPostExecute(Result)
    当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class DownloadTask extends AsyncTask<Void, Integer, Boolean> {

    protected void onPreExecute(){
        //显示进度对话框
        progressDialog.show();
    }

    @Override
    protected Boolean doInBackground(Void... params) {
        //任务处理
        try {
            while (true){
                int downloadPercent = doDownload();//虚构方法
                publishProgress(downloadPercent);
                if (downloadPercent >= 100){
                    break;
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return true;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        super.onProgressUpdate(values);
        //UI跟新，即更新下载进度
        progressDialog.setMessage("Downloaded " + values[0] + "%");
    }

    @Override
    protected void onPostExecute(Boolean result) {//任务执行完后被调用
        super.onPostExecute(result);
        //关闭进度对话框
        progressDialog.dismiss();
        //提示下载结果
        if (result){
            Toast.makeText(context, "Download succeeded", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "Download failed", Toast.LENGTH_SHORT).show();
        }
    }
}

在这个DownloadTask中，我们在doInBackground()方法里去执行具体的下载任务。这个方法里的代码都是在子线程中运行的，因而不会影响到主线程的运行。注意这里虚构了一个doDownload()方法，这个方法用于计算当前的下载进度并返回，我们假设这个方法已经存在了。在得到了当前的下载进度后，下面就该考虑如何把它显示到界面上了，由于doInBackground()方法是在子线程中运行的，在这里肯定不能进行UI操作，所以我们可以调用publishProgress()方法并将当前的下载进度传进来，这样onProgressUpdate()方法就会很快被调用，在这里就可以进行UI操作了。当下载完成后，doInBackground()方法会返回一个布尔型变量，这样onPostExecute()方法就会很快被调用，这个方法也是在主线程中运行的。然后在这里我们会根据下载的结果来弹出相应的Toast提示，从而完成整个DownloadTask任务。

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

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

1
new DownloadTask().execute();

以上就是AsyncTask的基本用法。从上面这个例子中，可以看出，我们并不需要去考虑什么异步消息处理机制，也不需要专门使用一个Handler来发送和接收消息，只需要调用一下publishProgress()方法，就可以轻松地从子线程切换到UI线程了。

三、Service的生命周期

3.1 生命周期方法

  • **onCreate()**：当Service第一次被创建后立即回调该方法，该方法在整个生命周期中只会调用一次！
  • **onDestory()**：当Service被关闭时会回调该方法，该方法只会回调一次！
  • onStartCommand(intent,flag,startId)：可多次调用StartService方法， 但不会再创建新的Service对象，而是继续复用前面产生的Service对象，但会继续回调 onStartCommand()方法。
  • onbind(intent)：该方法是Service都必须实现的方法，该方法会返回一个 IBinder对象，app通过该对象与Service组件进行通信！
  • onUnbind(intent)：当该Service上绑定的所有客户端都断开时会回调该方法！
  • **stopSelf()**：Service自身调用，用于关闭服务。

3.2 两种启动方式的区别

  1. StartService
    • 系统对同一个Service只会创建一个Service实例。如果Service实例不存在，调用startService()方法则会实例化一个Service对象，否则复用之前创建的Service实例。
    • 通过StopService()关闭Service。
    • 如果调用者直接退出而没有调用StopService()方法，Service会一直在后台运行。该Service的调用者再启动起来后可以通过StopService()关闭Service。
  2. BindService
    • 系统对同一个Service只会创建一个Service实例。如果Service实例不存在，调用bindService则会实例化一个Service对象，否则复用之前创建的Service实例。
    • 当Service只与一个客户端绑定时，调用unbindService()或者调用者退出，Service会被销毁。当Service与多个客户端绑定时，只有与所有客户端取消绑定后，Service才会被销毁。

3.3 体验Service的生命周期

3.3.1 非绑定启动

创建一个服务类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class MyService extends Service {
    private static final String TAG = "aaa";

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind: ");
        return null;
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.d(TAG, "onUnbind: ");
        return super.onUnbind(intent);
    }

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

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

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

不要忘记在AndroidManifest.xml中注册该服务！

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

另外activity_main.xml中的配置就两个按钮，绑定启动服务和销毁服务的功能，MainActivity.java如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
	
    public void StartService(View view) {
        startService(new Intent(this, MyService.class));
    }

    public void StopService(View view) {
        stopService(new Intent(this, MyService.class));
    }
    
}

主要使用到的方法是startService()启动服务和stopService()关闭服务。

通过上面代码，可以观察到非绑定服务的生命周期为：onCreate() -> onStartCommand() -> onDestroy()。

3.3.2 绑定启动

在 3.1.1的例子上，额外添加两个按钮，用于绑定和解绑服务，并额外创建一个ServiceConnection对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void BindService(View view) {
    bindService(new Intent(this, MyService.class),conn, Context.BIND_AUTO_CREATE);
}

public void UnbindService(View view) {
    unbindService(conn);
}

private ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {

    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {

    }
};

主要使用到的方法是bindService()绑定并启动服务和unbindService()解绑并关闭服务。

通过上面代码，可以观察到非绑定服务的生命周期为：onCreate() -> onBind() -> onUnbind() -> onDestroy()。

四、Service的基本用法

4.1 创建一个服务

在项目中右键包名 → New → Service → Service，在弹出的对话框中，需要我们给服务命名，同时还有两个属性，Exported属性表示是否允许除了当前程序之外的其他程序访问这个服务，Enabled属性表示是否启用这个服务。将两个属性都勾中，点击Finish完成创建。这样创建的服务，会自动在AndroidManifest.xml中进行声明，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

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

</manifest>

4.2 Activity与Service通信

Activity与Service之间的交流媒介是Service中的onBind()方法，它带有Intent参数，并且返回值为 IBinder，也就是说，可以通过IBinder来传递数据。

实现步骤如下：

  1. 在自定义Service类中，自定义一个Binder类，将要暴露的方法写到该类中，同时实例化这个类。
  2. 然后重写onBind()方法，将这个Binder对象返回。
  3. 在调用该Service的Activity中，实例化一个ServiceConnection对象，重写onServiceConnected()方法来获取Binder对象，之后调用相关方法即可！

以模拟下载为例。首先主活动的xml文件如下：

1
2
3
4
5
6
7
8
9
10
11
<android.widget.Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="点击下载"
        android:onClick="ClickDownload"/>

    <android.widget.Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="获取下载进度"
        android:onClick="getDownloadProgress"/>

一个用于模拟下载，一个用于获取下载进度。

创建MyService类，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class MyService extends Service {

    //实例化自定义Binder类
    private MyBinder myBinder = new MyBinder();
    //在onBind方法中返回binder类对象
    public IBinder onBind(Intent intent) {
        return myBinder;
    }
    //内部类
    public class MyBinder extends Binder{
        //进度条最大值
        private static final int MaxProgress = 100;
        //当前的进度
        private int currentProgress = 0;
        //获取当前进度
        public int getCurrentProgress() {
            return currentProgress;
        }
        //模拟下载,实现进度条的移动
        public void StartDownload(){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while(currentProgress < MaxProgress){
                        currentProgress += 1;
                        try{
                            Thread.sleep(500);
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }
    }

}

在其内部定义了MyBinder类，实现了获取下载进度和模拟下载的功能。

主活动的java代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class MainActivity extends AppCompatActivity {
	//Service内部类对象
    private MyService.MyBinder myBinder;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
		//绑定启动服务
        Intent intent = new Intent(this, MyService.class);
        bindService(intent,conn, Context.BIND_AUTO_CREATE);

    }
	
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //获取返回的binder对象 
            myBinder = (MyService.MyBinder)iBinder;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };
	//获取下载进度并弹窗显示
    public void getDownloadProgress(View view) {
        int currentProgress = myBinder.getCurrentProgress();
        Toast.makeText(this, "当前下载进度为: " + Integer.toString(currentProgress), Toast.LENGTH_SHORT).show();
    }
	//模拟下载
    public void ClickDownload(View view) {
        myBinder.StartDownload();
    }
}

4.3 简单的前台服务

通常情况下，Service都是运行在后台的。但是Service的系统优先级比较低，如果系统内存不足，就有可能回收正在后台运行的Service。

那如何解决上述情况呢？我们可以使用前台服务，从而让Service被杀死的可能性降低，所谓的前台服务就是状态栏显示的Notification。

实现方法：在自定义的Service类中重写onCreate()，根据自己的需求定制Notification，最后调用startForeground(id,notification)即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class MyService extends Service {

    public void onCreate() {
        super.onCreate();
        //获取通知管理服务
        NotificationManager notificationSystem = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
            //创建通知渠道对象
            NotificationChannel channel = new NotificationChannel("nid001", "随便",NotificationManager.IMPORTANCE_LOW);
            //通知渠道对象与通知管理服务对象绑定
            notificationSystem.createNotificationChannel(channel);
        }
        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_MUTABLE);

        Notification.Builder builder = new Notification.Builder(this,"nid001");
        builder.setContentIntent(pendingIntent)
                .setAutoCancel(false)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle("应用宝")
                .setContentText("正在下载XXX...");
        Notification notification = builder.build();
        startForeground(1,notification);

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

除此之外，还需要给应用android.permission.FOREGROUND_SERVICE权限，在AndroidManifest.xml中的<manifest>标签中声明：

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

4.4 执行定时任务

在实际开发中，Service也常用来执行定时任务，比如轮询，就是每间隔一段时间就请求一次服务器，确认客户端状态或者进行信息更新等。上述功能的实现需要依靠Android提供的定时方式：Timer类或Alarm机制。

Timer类不适合于需要长期在后台运行的定时任务，CPU一旦休眠，Timer中的定时任务就无法运行。而由于Alarm机制具有唤醒CPU的功能，所以不存在这种情况。

实现方法：

  1. 定义一个Service类并进行注册。重写Service的onStartCommand()方法。具体为：
    • 开辟线程处理事务
    • 通过getSystemService(ALARM_SERVICE)获得AlarmManager对象
    • 通过PendingIntent设置唤醒对象和唤醒方式
    • 通过AlarmManager.set()方法设置定时任务
  2. 定义一个Broadcast类并进行注册，通过context.startService()来唤醒服务。
  3. 在主活动中通过startService()方法来启动服务。

以一个例子来进行详细说明。

首先自定义BroadcastReceiver类，并在AndroidManifest.xml注册！

1
2
3
4
5
6
7
8
public class MyAlarmReceiver extends BroadcastReceiver {

    public void onReceive(Context context, Intent intent) {
		//发送广播来启动服务
        Intent intent1 = new Intent(context, MyService.class);
        context.startService(intent1);
    }
}

通过广播来启动MyService，这个MyAlarmReceiver类则通过Alarm机制来启动。

接下来是自定义Service类，同样在AndroidManifest.xml注册：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MyService extends Service {

    public int onStartCommand(Intent intent, int flags, int startId) {
        //开辟线程来进行想要的操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d("aaa", new Date().toString());
            }
        }).start();
        //获取AlarmManager
        AlarmManager alarmmanager = (AlarmManager)getSystemService(ALARM_SERVICE);
        //设置时间间隔，这里是每2s唤醒一次Service
        int anHour = 2 * 1000;
        long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
        //通过Intent设置唤醒的BroadcastReceiver
        Intent alarmIntent = new Intent(this, MyAlarmReceiver.class);
        //设置唤醒方式为Broadcast唤醒
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, alarmIntent, PendingIntent.FLAG_IMMUTABLE);
        //提交给AlarmManager完成
        alarmmanager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime,pendingIntent);
        return super.onStartCommand(intent, flags, startId);
    }

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

最后是主活动：

1
2
3
4
5
6
7
8
9
10
11
12
public class MainActivity extends AppCompatActivity {

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

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

注意！！！不能使用bindService()方法启动服务！！！因为bindService()方法不会执行生命周期的onStartCommand()方法！！！

4.5 使用IntentService

服务中的代码都是默认运行在主线程当中的，如果直接在服务里去处理一些耗时的逻辑，就很容易出现ANR(Application Not Responding)的情况。

所以这个时候就需要用到Android多线程编程的技术了，我们应该在服务的每个具体的方法里开启一个子线程，然后在这里去处理那些耗时的逻辑。因此，一个比较标准的服务就可以写成如下形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MyService extends Service {
	
    ......
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //处理具体的逻辑
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
}

但是，这种服务一旦启动之后，就会一直处于运行状态，必须调用stopService()或者stopSelf()方法才能让服务停止下来。所以，如果想要实现让一个服务在执行完毕后自动停止的功能，就可以这样写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MyService extends Service {
	
    ......
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //处理具体的逻辑
            	stopSelf();
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
}

虽说这种写法并不复杂，但是总会有一些程序员忘记开启线程，或者忘记调用stopSelf()方法。为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个IntentService类，这个类就很好地解决了前面所提到的两种尴尬，下面我们就来看一下它的用法。

手动建一个MyIntentService类继承自IntentService，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService");
    }

    public MyIntentService(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        //打印当前线程id
        Log.d("MyIntentService", "Thread id is " + Thread.currentThread().getId());
    }

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

这里首先要提供一个无参的构造函数，并且必须在其内部调用父类的有参构造函数。然后要在子类中去实现onHandleIntent()这个抽象方法，在这个方法中可以去处理一些具体的逻辑，而且不用担心ANR的问题，因为这个方法已经是在子线程中运行的了。这里为了证实一下，我们在onHandleIntent()方法中打印了当前线程的id。另外根据IntentService的特性，这个服务在运行结束后应该是会自动停止的，所以我们又重写了onDestroy()方法，在这里也打印了一行日志，以证实服务是不是停止掉了。

虽然MyIntentService继承于IntentService，但IntentService是继承于Service的，所以MyIntentService仍然是个服务，因此不要忘记在AndroidManifest.xml中进行注册。

接下来修改activity_main.xml中的代码，加入一个用于启动MyIntentService这个服务的按钮，如下所示：

1
2
3
4
5
6
7
8
9
10
11
<LinearLayout 
    ......
    android:gravity="center">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Start IntentService"
        android:onClick="StartIntentService"/>

</LinearLayout>

然后修改MainActivity中的代码，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MainActivity extends AppCompatActivity {

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

    public void StartIntentService(View view) {
        Log.d("MainActivity", "Thread id is " + Thread.currentThread().getId());
        Intent intent = new Intent(this, MyIntentService.class);
        startService(intent);
    }

}

我们在按钮的点击事件里面去启动MyIntentService这个服务，并在这里打印了一下主线程的id，用于和IntentService进行比对。其实我们可以发现IntentService的启动和普通服务的启动代码没有区别。

之后运行程序并点击按钮，观察logcat中的打印日志。可以看到，不仅MyIntentService和MainActivity所在的线程id不一样，而且onDestroy()方法也得到了执行，说明MyIntentService在运行完毕后确实自动停止了。

经过这个例子，我们应该可以知道IntentService其实就是集成了开启线程和自动停止的服务。

Android
#Android开发
Android开发学习笔记(五) —— 温习Service
http://example.com/2023/08/12/Android安全/Android开发学习笔记(五) —— 温习Service/
作者
gla2xy
发布于
2023年8月12日
许可协议