Android学习(后台劳动者-探究服务)

 Android可以使应用程序即使在关闭的情况下仍然可以继续在后台运行。后台是四大组件之一，四大组件是什么？在这里复习一下：活动、广播接收器、内容提供器、服务。

一、服务：

服务（Service）是Android中实现程序后台运行的解决方案，适合执行不需要和用户交互且需长期运行的任务，不依赖于任何用户界面。

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

服务并不会自动开启线程，所有代码默认在主线程中运行（一般在服务的内部手动创建子线程，并在这里执行具体的任务，否则主线程可能被堵塞）。

二、Android多线程编程：

1.线程的基本用法：

定义线程的方法是新建一个类继承自Thread，然后在该类内重写父类的run()方法，并在里面编写耗时逻辑即可（继承方式耦合性较高时，通过实现Runnable接口定义线程）<使用匿名类的方式，new Thread(new Runnable(){  //  run()方法的逻辑 }).start()>；启动线程的方法是new一个新建类的实例，然后调用其start()方法（ new Thread(新建类名).start()：Thread的构造函数接收一个Runnable参数，新建类是实现了Runnable接口的对象，所以将其传入Thread的构造函数里 ）。

2.在子线程中更新UI：

Android的UI是线程不安全的。若想更新应用程序里的UI元素，必须在主线程中进行，否则就会出现异常。

*动手操作：创建一个项目AndroidThreadTest项目。

（1）修改主活动布局文件的代码：

（2）修改主活动的代码：

package com.example.androidthreadtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;


public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    public static final int UPDATE_TEXT = 1;  //定义一个静态整型常量UPDATE_TEXT，用于表示更新TextView这个动作

    private TextView text;
    private Handler handler = new Handler(){  //定义一个Handler对象
        @Override
        public void handleMessage(Message msg) {  //重写其父类方法handleMessage
            switch (msg.what){  //如果msg的what字段是指定值UPDATE_TEXT
                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 chaneText = (Button) findViewById(R.id.change_text);
        chaneText.setOnClickListener(this);  //为按钮注册监听器
    }

    @Override
    public void onClick(View v) {  //监听事件
        switch (v.getId()){  
            case R.id.change_text:
                new Thread(new Runnable() {  //采用匿名类的方式创建线程
                    @Override
                    public void run() {  //线程的执行方法
                        Message message = new Message();
                        message.what = UPDATE_TEXT;  //定义message的what字段为UPDATE_TEXT
                        handler.sendMessage(message);  //将Message对象发送出去
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

上述方法即安卓异步消息处理的基本用法，使用这种方法可以出色解决掉在子线程中更新UI的问题。

3.解析异步消息处理机制：

• 异步消息处理主要由4个部分组成：

        a.Message：在线程之间传递的消息，可以在内部携带少量信息，用于在不同线程之间交换数据，可使用what字段、arg1/arg2字段（携带整型数据）、obj字段（携带Object对象）。

        b.Handler：处理者，主要用于发送和处理消息，发送消息一般是使用Handler的sendMessage()方法，发出的消息经过一系列处理后，会传递进Handler的handleMessage方法中。

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

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

• 异步消息处理流程：

        a.在主线程中创建一个Handler对象，并重写其handleMessage()方法；

        b.当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将这条消息发送出去；

        c.发送出去的消息会被添加到MessageQueue中等待被处理；

        d.Looper会一直尝试取出待处理消息，最后分发回Handler的handleMessage()方法中。

注：由于Handler在主线程中创建，所以相应的handleMessage()方法中的代码也在主线程中运行，可在此进行UI操作（消息从子线程进入主线程）。

4.使用AsynaTask：

AsyncTask的实现原理基于异步消息处理机制，安卓对其做了很好的封装，使用它可以简单地从子线程切换到主线程。

• AsyncTask类的基本用法：AsyncTask是一个抽象类，如果想要使用它，需要创建一个子类继承它。在继承时可以为AsyncTask类指定3个泛型参数：

                a.Params：在执行AsyncTask时需传入的参数，可用于在后台任务中使用；

                b.Progress：后台任务执行时，如需在界面上显示当前进度，则使用此泛型单位；

                c.Result：任务执行完毕后，如需返回结果，则使用此泛型作为返回值类型。

• 自定义AsyncTask的写法如下：

        class DownloadTask extends AsyncTask{

                ........        

        }

• 重写AsyncTask中的方法，常用的有四个：

                a. onPreExecute()：在后台任务开始之前调用，用于进行界面上的初始化操作（如显示进度条对话框）；

                b. doInBackground(Params…)：方法中代码在子线程中运行，处理所有耗时任务，完成通过return返回结果（如Rusult指定为Void则不返回结果），这个方法不可以进行UI操作，如需更新UI，可调用publishProgress(Progress…)完成；

                c. onProgressUpdate(Progress…)：当后台调用publishProgress后，会被很快调用，参数是后台传递过来的，可利用参数操作UI；

                d. onPostExecute(Result)：后台任务完成并通过return返回时很快被调用，可利用返回的数据进行UI操作（如提醒执行结果、关闭进度条等）

• 使用AsyncTask的诀窍是：在doInBackground()方法中执行具体的耗时任务，在onProgressUpdate()方法中进行UI操作，在onPostExecute()方法中执行一些任务的收尾工作。
• 启动AsyncTask任务的方法：

                new DownloadTask().execute();

三、服务的基本用法：

1.定义一个服务：

（1）创建一个项目ServiceTest项目，右击包名->New->Service->Service，Exported和Enableed都勾选，Exported属性表示是否允许除了当前程序之外的其他程序访问这个服务，Enableed属性表示是否启用这个服务：

public class MyService extends Service {  //MyService继承自Service类，说明这是一个服务
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {  //这个方法是Service中唯一一个抽象方法，所以必须要在子类里实现
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

（2）要让服务处理事情，还需重写一些方法：

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

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
    
    @Override
    public void onCreate() {  //服务创建时调用
        super.onCreate();
    }
    
    @Override
    //当我们希望服务一旦启动就立即执行一些动作，就可以将逻辑写在onStartCommand方法里
    public int onStartCommand(Intent intent, int flags, int startId) {  //每次服务启动时调用
        return super.onStartCommand(intent, flags, startId);
    }
   
    @Override
    public void onDestroy() {  //服务销毁时调用
        super.onDestroy();
    }

}

注：每个服务都必须在AndroidManifest文件里进行注册，这是四大组件的共同特点：活动；广播接收器；内容提供器；服务。

2.启动和停止服务：

启动和停止服务主要借助Intent实现。

（1）修改主活动布局文件的代码：

（2）修改主活动的代码：

package com.example.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);  //重写父类方法
        setContentView(R.layout.activity_main);  //绑定布局
        Button startService = (Button) findViewById(R.id.start_service);  //获取按钮控件id
        Button stopService = (Button) findViewById(R.id.stop_service);  //获取按钮控件id
        startService.setOnClickListener(this);  //注册监听器
        stopService.setOnClickListener(this);  //注册监听器
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent);//启动服务，startService定义在Context类中
                break;
            case R.id.stop_service:
                Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent);//停止服务，stopService定义在Context类中
                break;
            default:
                break;
        }
    }

}

（3）在日志中打印从而观察启动停止调用的函数，修改MyService文件的代码：

    @Override
    public void onCreate() {  //服务创建时调用
        super.onCreate();
        Log.d(TAG,"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() {  //服务销毁时调用
        super.onDestroy();
        Log.d(TAG,"onDestroy()");
    }

运行程序，打印日志内容如下：

D/MyService: onCreate()
D/MyService: onStartCommand()
V/AudioManager: querySoundEffectsEnabled...
D/MyService: onDestroy()

3.活动和服务进行通信：

借助onBind()方法。

*动手操作：假设在MyService里提供一个下载功能，在活动中可以决定何时开始下载及随时查看下载进度。

（1）创建一个专门的Binder对象管理下载功能，修改MyService：

public class MyService extends Service {
    private static final String TAG = "MyService";
    private DownloadBinder mBinder = new DownloadBinder();  //创建一个下载管理器mBinder

    class DownloadBinder extends Binder {  //定义一个类DownloadBinder继承自Binder
        public void startDownload(){
            Log.d("MyService", "startDownload executed");
        }
        public int getProgress(){
            Log.d("MyService", "getProgress executed");
            return 0;
        }
    }

    public MyService() {
    }

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

    @Override
    public void onCreate() {  //服务创建时调用
        super.onCreate();
        Log.d(TAG,"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() {  //服务销毁时调用
        super.onDestroy();
        Log.d(TAG,"onDestroy()");
    }

}

（2）在主活动布局文件中添加两个按钮，分别用于绑定服务和取消绑定服务。绑定服务的对象就是活动。当一个活动和服务绑定之后就可以调用服务里的Binder方法了。修改主活动的代码：

package com.example.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private MyService.DownloadBinder downloadBinder;

    private ServiceConnection connection = new ServiceConnection() {  //创建ServiceConnection匿名类

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {  //活动与服务成功绑定时调用
            downloadBinder = (MyService.DownloadBinder) service;//向下转型得到DownloadBinder实例，这个实例使活动与服务直接的联系变得紧密
            //通过DownloadBinder实例可以在活动中根据具体的场景调用DownloadBinder中任何public方法
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {  //活动与服务解除绑定时调用

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);  //重写父类方法
        setContentView(R.layout.activity_main);  //绑定布局
        Button startService = (Button) findViewById(R.id.start_service);  //获取按钮控件id
        Button stopService = (Button) findViewById(R.id.stop_service);  //获取按钮控件id
        Button bindService = (Button) findViewById(R.id.bind_service);  //获取按钮控件id
        Button unbindService = (Button) findViewById(R.id.unbind_service);  //获取按钮控件id
        startService.setOnClickListener(this);  //注册监听器
        stopService.setOnClickListener(this);  //注册监听器
        bindService.setOnClickListener(this);  //注册监听器
        unbindService.setOnClickListener(this);  //注册监听器
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent);//启动服务，startService定义在Context类中
                break;
            case R.id.stop_service:
                Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent);//停止服务，stopService定义在Context类中
                break;
            case R.id.bind_service:
                Intent bindIntent = new Intent(this,MyService.class);
                /**
                 * bindService()方法接收3个参数：
                 * 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;
        }
    }

}

运行程序，日志打印结果如下：

D/MyService: onCreate()
D/MyService: startDownload executed
D/MyService: getProgress executed
V/AudioManager: querySoundEffectsEnabled...
D/MyService: onDestroy()

四、服务的生命周期：

        调用Context的startService()，服务启动并回调onStartCommand()方法，如果服务之前没创建则先执行onCreate()方法；服务启动后一直保持运行状态，直到stopService()/stopSelf()被调用。每个服务只存在一个实例，只需调用一次stopService()/stopSelf()就会停止。

        可调用Context的bindService()获取服务的持久连接，同时会回调服务中的onBind()方法，类似，如果服务之前没创建则先调用onCreate()方法。之后，调用方可以获取到onBind()返回的IBinder对象的实例，就可以与服务自由通信。只要调用方与服务之间的连接没断开，服务会一直保持运行状态。

        当调用了startService()后，又调用stopService()，onDestroy()会被执行，表示服务已经被销毁了。

        对于Android系统机制，服务只要被启动或被绑定，就会一直处于运行状态，必须同时不满足以上两种条件，服务才能被销毁。所以，如果对服务既调用了startService()又调用了bindService()，要同时调用stopService()和unbindService()方法，onDestroy()才会被执行。

五、服务的更多技巧：

1.使用前台服务：

        服务的系统优先级较低，系统内存不足时可能被回收。如想让服务一直保持运行状态不会被回收（如天气预报应用），可使用前台服务。        

        前台服务与普通服务的区别：一直有一个正在运行的图标在系统状态栏显示（下拉后可看到更详细信息，与通知的效果类似）。

动手操作：修改MyService的代码：

package com.example.servicetest;

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.graphics.BitmapFactory;
import android.os.Binder;
import android.os.Build;
import android.os.IBinder;
import android.util.Log;

import androidx.annotation.RequiresApi;
import androidx.core.app.NotificationCompat;

public class MyService extends Service {
    private static final String TAG = "MyService";
    private DownloadBinder mBinder = new DownloadBinder();  //创建一个下载管理器mBinder

    class DownloadBinder extends Binder {  //定义一个类DownloadBinder继承自Binder
        public void startDownload(){
            Log.d("MyService", "startDownload executed");
        }
        public int getProgress(){
            Log.d("MyService", "getProgress executed");
            return 0;
        }
    }

    public MyService() {
    }

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

    @RequiresApi(api = Build.VERSION_CODES.O)
    @Override
    public void onCreate() {  //服务创建时调用
        super.onCreate();
        Log.d(TAG,"onCreate()");

        //实现前台服务
        String ID = "com.example.servicetest";	//id里输入本项目包的路径
        String NAME = "Channel One";

        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pi = PendingIntent.getActivity(this, 0, intent, 0);  //延迟执行的Intent

        NotificationCompat.Builder notification;  //创建一个通知

        NotificationChannel channel = new NotificationChannel(ID, NAME, NotificationManager.IMPORTANCE_HIGH);
        channel.enableLights(true);
        channel.setShowBadge(true);
        channel.setLockscreenVisibility(Notification.VISIBILITY_PUBLIC);
        notification = new NotificationCompat.Builder(MyService.this).setChannelId(ID);

        notification.setContentTitle("This is content title")
                .setContentText("This is content text")
                .setWhen(System.currentTimeMillis())
                .setSmallIcon(R.mipmap.ic_launcher)
                .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher))
                .setContentIntent(pi)
                .build();
        /**
         * startForeground()方法，2个参数：
         * 1.通知的id；
         * 2.构建的通知对象。
         */
        Notification notification1 = notification.build();
        startForeground(1, notification1);  //startForeground方法是让MyService成为一个前台服务，并在系统状态栏显示
    }

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

    @Override
    public void onDestroy() {  //服务销毁时调用
        super.onDestroy();
        Log.d(TAG,"onDestroy()");
    }

}

运行程序：点击Start Service或Bind Service按钮，MyService就会以前台服务的模式启动了。

2.使用IntentService：

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

        所以应该在服务每个具体方法里开启一个子线程去处理耗时操作，这种服务一旦启动就会一直处于运行状态，要让服务自动停止还需调用stopSelf()方法。

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

（1）新建一个MyIntentService类继承自IntentService：
 

package com.example.servicetest;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

public class MyIntentService extends IntentService {

    private static final String TAG = "MyIntentService";

    public MyIntentService(){
        super("MyIntentService"); //调用父类的有参构造函数
    }

    @Override
    protected void onHandleIntent(Intent intent){  //抽象方法
        //打印当前线程的id
        Log.d(TAG,"Thread id is"+Thread.currentThread().getId());
    }

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

}

（2）修改主活动布局文件的代码，添加一个按钮控件，用于启动MyIntentService服务：

    ...

    

（3）修改主活动的代码：

public class MainActivity extends AppCompatActivity implements View.OnClickListener{
    private static final String TAG = "MainActivity";
    private MyService.DownloadBinder downloadBinder;

    private ServiceConnection connection = new ServiceConnection() {  //创建ServiceConnection匿名类

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {  //活动与服务成功绑定时调用
            downloadBinder = (MyService.DownloadBinder) service;//向下转型得到DownloadBinder实例，这个实例使活动与服务直接的联系变得紧密
            //通过DownloadBinder实例可以在活动中根据具体的场景调用DownloadBinder中任何public方法
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {  //活动与服务解除绑定时调用

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);  //重写父类方法
        setContentView(R.layout.activity_main);  //绑定布局
        ...
        Button startIntentService = (Button) findViewById(R.id.start_intent_service); //获取按钮控件id
        startIntentService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            ...
            case R.id.start_intent_service:
                Log.d(TAG,"Thread id is"+Thread.currentThread().getId());
                Intent intentService = new Intent(this,MyIntentService.class);
                startService(intentService);  //启动IntentService
                break;
            default:
                break;
        }
    }

}

（4）在AndroidManifest代码中注册服务：

  ——参考《Android第一行代码》整理上述笔记