Service——后台服务、前台服务、IntentService、跨进程服务、无障碍服务、系统服务

你的名字 2023-06-23 06:59 75阅读 0赞

阅读：  
[https://blog.csdn.net/m0\_37868230/article/details/81267672][https_blog.csdn.net_m0_37868230_article_details_81267672]  
1.一个已经启动的service，如果没有程序停止它或者它自己停止，service将一直运行。  
        在这种模式下，service开始调用Context.startService（），停止于Context.stopService（）。service可以通过调用Android Service生命周期或Service.stopSelfResult（）停止自己。不管调用多少次startService（），只需要调用一次stopService（）就可以一直停滞service。

2.可以通过接口被外部程序调用。  
        外部程序建立到service的连接，通过连接来操作service。建立连接开始于Context.bindService（），结束于Context.unbindService（），多个客户端可以绑定到同一个service，如果service没有启动，bindService（）可以选择启动它。

3.服务器不能自己运行，需要通过调用Context.startService（）或Context.bindService（）方法启动服务。  
        这两个方法都可以启动service，但它们使用场所有所不同。使用startService（）方法启用服务，调用者与服务之间没有关联，即使调用者退出了，服务仍然运行。使用bindService（）方法启动服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止。

**Context.startService()方法启动服务：**  
        在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStartCommand()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法或stopSelf()方法结束服务，服务结束时会调用onDestroy()方法。

**Context.bindService()方法启动服务：**  
        在服务未被创建时，系统会先调用服务的 onCreate()方法，接着调用onBind()方法。这个时候调用者和服务绑定在一起，调用者退出了，系统就会先调用服务的onUnbind()方 法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致 多次创建服务及绑定(也就是说**onCreate()和onBind()方法并不会被多次调用**)。如果调用者希望与正在绑定的服务解除绑定，可以调用 unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()–>onDestroy()方法。

## 前言 ##

作为四大组件之一的Service类，是面试和笔试的必备关卡，我把我所学到的东西总结了一遍，相信你看了之后你会对Service娓娓道来，在以后遇到Service的问题胸有成竹，废话不多说，开车啦

## Service简介 ##

Service是Android中实现程序后台运行的解决方案，它非常适用于去执行那些不需要和用户交互而且还要求长期运行的任务。Service默认并不会运行在子线程中，它也不运行在一个独立的进程中，它同样执行在UI线程中，因此，不要在Service中执行耗时的操作，除非你在Service中创建了子线程来完成耗时操作

Service的运行不依赖于任何用户界面，即使程序被切换到后台或者用户打开另一个应用程序，Service仍然能够保持正常运行，这也正是Service的使用场景。当某个应用程序进程被杀掉时，所有依赖于该进程的Service也会停止运行

## 1. 后台服务 ##

后台服务可交互性主要是体现在不同的启动服务方式，startService()和bindService()。bindService()可以返回一个代理对象，可调用Service中的方法和获取返回结果等操作，而startService()不行

#### 1.1 不可交互的后台服务 ####

不可交互的后台服务即是普通的Service，Service的生命周期很简单，分别为onCreate、onStartCommand、onDestroy这三个。当我们startService()的时候，首次创建Service会回调onCreate()方法，然后回调onStartCommand()方法，再次startService()的时候，就只会执行一次onStartCommand()。服务一旦开启后，我们就需要通过stopService()方法或者stopSelf()方法，就能把服务关闭，这时就会回调onDestroy()

**一、创建服务类**

创建一个服务非常简单，只要继承Service，并实现onBind()方法

public class BackGroupService extends Service { 
    
        /** * 綁定服务时调用 * * @param intent * @return */
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            Log.e("Service", "onBind");
            return null;
        }
    
        /** * 服务创建时调用 */
        @Override
        public void onCreate() {
            Log.e("Service", "onCreate");
            super.onCreate();
        }
    
        /** * 执行startService时调用 * * @param intent * @param flags * @param startId * @return */
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            Log.e("Service", "onStartCommand");
            //这里执行耗时操作
            new Thread() {
                @Override
                public void run() {
                    while (true){
                        try {
                            Log.e("Service", "doSomething");
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
            return super.onStartCommand(intent, flags, startId);
        }
    
        /** * 服务被销毁时调用 */
        @Override
        public void onDestroy() {
            Log.e("Service", "onDestroy");
            super.onDestroy();
        }
    }
     
      
     
      
       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
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61

**二、配置服务**

Service也是四大组件之一，所以必须在manifests中配置

<service android:name=".Service.BackGroupService"/>
     
      
     
      
       1

**三、启动服务和停止服务**

我们通过两个按钮分别演示启动服务和停止服务，通过startService()开启服务，通过stopService()停止服务

当你开启服务后，还有一种方法可以关闭服务，在设置中，通过应用->找到自己应用->停止

![20161124133116841][]

**四、运行代码**

运行程序后，我们点击开始服务，然后一段时间后关闭服务。我们以Log信息来验证普通Service的生命周期：onCreate->onStartCommand->onDestroy

11-24 00:19:51.483 16407-16407/com.handsome.boke2 E/Service: onCreate
    11-24 00:19:51.483 16407-16407/com.handsome.boke2 E/Service: onStartCommand
    11-24 00:19:51.485 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:19:53.490 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:19:55.491 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:19:57.491 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:19:58.056 16407-16407/com.handsome.boke2 E/Service: onDestroy
    11-24 00:19:59.492 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:20:01.494 16407-16613/com.handsome.boke2 E/Service: doSomething
    11-24 00:20:03.495 16407-16613/com.handsome.boke2 E/Service: doSomething
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10

其中你会发现我们的子线程进行的耗时操作是一直存在的，而我们Service已经被关闭了，关闭该子线程的方法需要直接通过Home键关闭该应用程序

#### 1.2 可交互的后台服务 ####

可交互的后台服务是指前台页面可以调用后台服务的方法，可交互的后台服务实现步骤是和不可交互的后台服务实现步骤是一样的，区别在于启动的方式和获得Service的代理对象

**一、创建服务类**

和普通Service不同在于这里返回一个代理对象，返回给前台进行获取，即前台可以获取该代理对象执行后台服务的方法

public class BackGroupService extends Service { 
    
        /** * 綁定服务时调用 * * @param intent * @return */
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            Log.e("Service", "onBind");
            //返回代理对象
            return new MyBinder();
        }
    
        /** * 代理类 */
        class MyBinder extends Binder {
            public void showToast() {
                Log.e("Service", "showToast");
            }
    
            public void showList() {
                Log.e("Service", "showList");
            }
        }
    
        /** * 解除绑定服务时调用 * @param intent * @return */
        @Override
        public boolean onUnbind(Intent intent) {
            Log.e("Service", "onUnbind");
            return super.onUnbind(intent);
        }
    
        /** * 服务创建时调用 */
        @Override
        public void onCreate() {
            Log.e("Service", "onCreate");
            super.onCreate();
        }
    
        /** * 服务被销毁时调用 */
        @Override
        public void onDestroy() {
            Log.e("Service", "onDestroy");
            super.onDestroy();
        }
    }
     
      
     
      
       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
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58

**二、配置服务**

<service android:name=".Service.BackGroupService"/>
     
      
     
      
       1

**三、绑定服务和解除绑定服务**

我们通过两个按钮分别演示绑定服务和解除绑定服务，通过bindService()开启服务，通过unbindService()停止服务

public class MainActivity extends AppCompatActivity { 
    
        Button bt_open, bt_close;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            bt_open = (Button) findViewById(R.id.open);
            bt_close = (Button) findViewById(R.id.close);
    
            final Intent intent = new Intent(this, BackGroupService.class);
    
            bt_open.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    bindService(intent, conn, BIND_AUTO_CREATE);
                }
            });
    
            bt_close.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    unbindService(conn);
                }
            });
    
    
        }
    
        ServiceConnection conn = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                //拿到后台服务代理对象
                BackGroupService.MyBinder myBinder = (BackGroupService.MyBinder) service;
                //调用后台服务的方法
                myBinder.showToast();
                myBinder.showList();
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) {
    
            }
        };
    }
     
      
     
      
       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
       46
       47

这里和startService的区别在于多了一个ServiceConnection对象，该对象是用户绑定后台服务后，可获取后台服务代理对象的回调，我们可以通过该回调，拿到后台服务的代理对象，并调用后台服务定义的方法，也就实现了后台服务和前台的交互

**四、运行代码**

运行程序后，我们点击绑定服务，然后一段时间后解除绑定服务。我们以Log信息来验证Service的生命周期：onCreate->onBind->onUnBind->onDestroy，其中也可以看到我们调用后台服务的方法showToast和showList

11-24 00:55:32.775 15408-15408/com.handsome.boke2 E/Service: onCreate
    11-24 00:55:32.775 15408-15408/com.handsome.boke2 E/Service: onBind
    11-24 00:55:32.796 15408-15408/com.handsome.boke2 E/Service: showToast
    11-24 00:55:32.796 15408-15408/com.handsome.boke2 E/Service: showList
    11-24 00:55:34.290 15408-15408/com.handsome.boke2 E/Service: onUnbind
    11-24 00:55:34.290 15408-15408/com.handsome.boke2 E/Service: onDestroy
     
      
     
      
       1
       2
       3
       4
       5
       6

#### 1.3 混合性交互的后台服务 ####

或许你会迷惑，startService和bindService之间有什么关系？其实简单的说两者之间是没有关联的，类似于你亲妈生了个双胞胎一样，只有纯粹的血缘关系。那么问题来了，这两个启动方式是否可以同时使用呢，答案是可以的

将上面两种启动方式结合起来就是混合性交互的后台服务了，即可以单独运行后台服务，也可以运行后台服务中提供的方法，其完整的生命周期是：onCreate->onStartCommand->onBind->onUnBind->onDestroy

## 2. 前台服务 ##

由于后台服务优先级相对比较低，当系统出现内存不足的情况下，它就有可能会被回收掉，所以前台服务就是来弥补这个缺点的，它可以一直保持运行状态而不被系统回收。例如：墨迹天气在状态栏中的天气预报

![20161124155501133][]

**一、创建服务类**

前台服务创建很简单，其实就在Service的基础上创建一个Notification，然后使用Service的startForeground()方法即可启动为前台服务

public class ForegroundService extends Service { 
    
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            showNotification();
        }
    
        /** * 启动前台通知 */
        private void showNotification() {
            //创建通知详细信息
            Notification.Builder mBuilder = new Notification.Builder(this)
                    .setSmallIcon(R.mipmap.ic_launcher)
                    .setContentTitle("2016年11月24日")
                    .setContentText("今天天气阴天，8到14度");
            //创建点击跳转Intent
            Intent intent = new Intent(this, MainActivity.class);
            //创建任务栈Builder
            TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
            stackBuilder.addParentStack(MainActivity.class);
            stackBuilder.addNextIntent(intent);
            PendingIntent pendingIntent = stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
            //设置跳转Intent到通知中
            mBuilder.setContentIntent(pendingIntent);
            //获取通知服务
            NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            //构建通知
            Notification notification = mBuilder.build();
            //显示通知
            nm.notify(0, notification);
            //启动为前台服务
            startForeground(0, 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
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42

**二、配置服务**

<service android:name=".Service.ForegroundService"/>
     
      
     
      
       1

**三、启动前台服务**

startService(new Intent(this, ForegroundService.class));
     
      
     
      
       1

**四、运行代码**

我们可以看到状态栏确实增加了我们这条通知

![20161124161145289][]

当我们将该程序退出并杀掉的时候，通过设置->应用->选择正在运行中的应用，我们可以发现，我们的程序退出杀掉了，而服务还在进行着

![20161124161301095][]

## IntentService ##

IntentService是专门用来解决Service中不能执行耗时操作这一问题的，创建一个IntentService也很简单，只要继承IntentService并覆写onHandlerIntent函数，在该函数中就可以执行耗时操作了

public class TheIntentService extends IntentService { 
    
        public TheIntentService(String name) {
            super(name);
        }
    
        @Override
        protected void onHandleIntent(Intent intent) {
            //在这里执行耗时操作
        }
    }
     
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11

## 3. AIDL跨进程服务 ##

关于AIDL跨进程服务的使用和原理分析，可以见我另一篇博客：[Android基础——初学者必知的AIDL在应用层上的Binder机制][Android_AIDL_Binder]

## 4. AccessibilityService无障碍服务 ##

关于AccessibilityService无障碍服务的使用和实例，可以见我另一篇博客：[Android进阶——学习AccessibilityService实现微信抢红包插件][Android_AccessibilityService]

## 5. 系统服务 ##

系统服务提供了很多便捷服务，可以查询Wifi、网络状态、查询电量、查询音量、查询包名、查询Application信息等等等相关多的服务，具体大家可以自信查询文档，这里举例几个常见的服务

**一、判断Wifi是否开启**

WifiManager wm = (WifiManager) getSystemService(WIFI_SERVICE); boolean enabled = wm.isWifiEnabled();
     
      
     
      
       1
       2

需要权限

<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
     
      
     
      
       1
       2

**二、获取系统最大音量**

AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
    int max = am.getStreamMaxVolume(AudioManager.STREAM_SYSTEM);
     
      
     
      
       1
       2

**三、获取当前音量**

AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
    int current = am.getStreamMaxVolume(AudioManager.STREAM_RING);
     
      
     
      
       1
       2

**四、判断网络是否有连接**

ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    NetworkInfo info = cm.getActiveNetworkInfo();
    boolean isAvailable = info.isAvailable();
     
      
     
      
       1
       2
       3

需要权限

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

[部分源码下载][Link 1]

[https_blog.csdn.net_m0_37868230_article_details_81267672]: https://blog.csdn.net/m0_37868230/article/details/81267672
[20161124133116841]: https://img-blog.csdn.net/20161124133116841
[20161124155501133]: https://img-blog.csdn.net/20161124155501133
[20161124161145289]: https://img-blog.csdn.net/20161124161145289
[20161124161301095]: https://img-blog.csdn.net/20161124161301095
[Android_AIDL_Binder]: http://blog.csdn.net/qq_30379689/article/details/52253413
[Android_AccessibilityService]: http://blog.csdn.net/qq_30379689/article/details/53242953
[Link 1]: http://download.csdn.net/detail/qq_30379689/9692631