Android 组件之Service详解

1.Service简单介绍（什么是Service）

Service(服务)是一个一种可以在后台执行长时间运行操作而没有用户界面的应用组件。

2.Service创建（怎么创建Service）

1.新建class去继承Service并实现生命周期相关方法

public class MyService extends Service {


    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("TAG", "onCreate.............................");

    }

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

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
        Log.e("TAG", "onStart.............................");
    }


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

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


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

}

2.清单文件中Service注册

<service android:enabled=["true" | "false"]
    android:exported=["true" | "false"]
    android:icon="drawable resource"
    android:isolatedProcess=["true" | "false"]
    android:label="string resource"
    android:name="string"
    android:permission="string"
    android:process="string" >
    . . .
</service>

属性值	含义
android:exported	代表是否能被其他应用隐式调用，其默认值是由service中有无intent-filter决定的，如果有intent-filter，默认值为true，否则为false。为false的情况下，即使有intent-filter匹配，也无法打开，即无法被其他应用隐式调用
android:name	对应Service类名
android:permission	是权限声明
android:process	是否需要在单独的进程中运行,当设置为android:process=”:remote”时，代表Service在单独的进程中运行。注意“：”很重要，它的意思是指要在当前进程名称前面附加上当前的包名，所以“remote”和”:remote”不是同一个意思，前者的进程名称为：remote，而后者的进程名称为：App-packageName:remote。
android:isolatedProcess	设置 true 意味着，服务会在一个特殊的进程下运行，这个进程与系统其他进程分开且没有自己的权限。与其通信的唯一途径是通过服务的API(bind and start)。
android:enabled	是否可以被系统实例化，默认为 true因为父标签 也有 enable 属性，所以必须两个都为默认值 true 的情况下服务才会被激活，否则不会激活

3.Service的启动（怎么开启Service）

开启服务有两种方式
1）采用startService的方式去启动
2）采用bindService方式去启动

1）start的方式去启动一个Service服务

（1）创建子类去集成Service类，并重写StartService方式需要走的生命周期方法。

public class MyService extends Service {


    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("TAG", "onCreate.............................");

    }
// 2.0 API level之后，onStart()方法被onStartCommand()取代了  
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e("TAG", "onStartCommand.............................");
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e("TAG", "onDestroy.............................");
    }

}

startService方式下生命周期的介绍

生命周期方法	方法含义
onBind()	该方法是必须重写的，但是由于此时是启动状态的服务，则该方法无须实现，返回null即可，只有在绑定状态的情况下才需要实现该方法并返回一个IBinder的实现类
onCreate()	首次创建服务时，如果服务已在运行，则不会调用此方法，该方法只调用一次
onStartCommand	当另一个组件（如 Activity）通过调用 startService() 请求启动服务时，系统将调用此方法。一旦执行此方法，服务即会启动并可在后台无限期运行。 如果自己实现此方法，则需要在服务工作完成后，通过调用 stopSelf() 或 stopService() 来停止服务。（在绑定状态下，无需实现此方法。）
onDestroy	当服务不再使用且将被销毁时，系统将调用此方法。服务应该实现此方法来清理所有资源，如线程、注册的侦听器、接收器等，这是服务接收的最后一个调用

（2） activity中启动Service

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

（3） activity停止Service

 stopService(intent);

多次startSevice和stopService的日志

04-24 17:14:19.207 18980-18980/com.phone.test_service E/TAG: onCreate.............................
04-24 17:14:19.208 18980-18980/com.phone.test_service E/TAG: onStartCommand.............................
04-24 17:14:22.297 18980-18980/com.phone.test_service E/TAG: onStartCommand.............................
04-24 17:14:26.295 18980-18980/com.phone.test_service E/TAG: onStartCommand.............................
04-24 17:14:27.137 18980-18980/com.phone.test_service E/TAG: onStartCommand.............................
04-24 17:14:27.966 18980-18980/com.phone.test_service E/TAG: onStartCommand.............................
04-24 17:14:42.146 18980-18980/com.phone.test_service E/TAG: onDestroy.............................

结论：
很明显多次启动服务生命周期的onCreate只会执行一次，但是onStartCommand会多次执行

那么多次执行的onStartCommand方法，我们了解下方法的参数和返回值都具体什么意思

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

onStartCommand各个参数的解释

参数名	含义
intent	startService(Intent intent)中的intent
flags	表示启动服务的方式，可选值有 0，START_FLAG_REDELIVERY，START_FLAG_RETRY，0代表没有具体参考Flags说明
startId	指明当前服务的唯一ID，与stopSelfResult (int startId)配合使用，stopSelfResult 可以更安全地根据ID停止服务

Flags说明

参数名	含义
START_FLAG_REDELIVERY	这个值代表了onStartCommand方法的返回值为 START_REDELIVER_INTENT，而且在上一次服务被杀死前会去调用stopSelf方法停止服务。其中START_REDELIVER_INTENT意味着当Service因内存不足而被系统kill后，则会重建服务，并通过传递给服务的最后一个 Intent 调用 onStartCommand()，此时Intent时有值的
START_FLAG_RETRY	表示服务之前被设为START_STICKY，则会被传入这个标记

onStartComand使用时，返回的是一个(int)整形,具体介绍下每种返回值的含义

返回值	含义
START_STICKY	如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null
START_NOT_STICKY	“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务
START_REDELIVER_INTENT	重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入
START_STICKY_COMPATIBILITY	START_STICKY的兼容版本，但不保证服务被kill后一定能重启

2）采用bindService方式去启动
（1）创建Sevice实现类，重写相关生命周期方法

public class MyService extends Service {


    private int count=1;

    @Override
    public void onCreate() {
        super.onCreate();
        Log.e("TAG", "onCreate.............................");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (count<100){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        }).start();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.e("TAG", "onBind.............................");
        return new Mybinder();
    }

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

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

    /**
     * 自定义类去继承Binder最终返回给绑定者
     */
    class Mybinder extends Binder{
        MyService getMyservice(){
            return MyService.this;
        }
        public String getName(){
            return "mybinder";
        }

    }

    /**
     * MyService 方法获取count变量
     * @return
     */
    public  int  getNumber(){
        return count;
    }

}

（2）布局文件

<?xml version="1.0" encoding="utf-8"?>
<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"
    android:orientation="vertical"
    tools:context="com.phone.test_service.MainActivity">
    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="绑定服务"
        android:onClick="bindService"
        />

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="解绑服务"
        android:onClick="unbindService"
        />

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="调用Myservice公共方法"
        android:onClick="callMethodgetNumber"
        />

    <Button
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="调用MyBind而内部类方法"
        android:onClick="callMethodgetName"
        />
</LinearLayout>

（3）操作Sevice的Activity

public class MainActivity extends AppCompatActivity {
    Intent intent;
    public MyService.Mybinder myBinder;

    //bindService的ServiceConnection 参数，Activity与Service通信的重要类

    private ServiceConnection conn=new ServiceConnection() {
    //其中service便是服务端返回的IBinder实现类对象，通过该对象我们便可以调用获取LocalService实例对象，进而调用服务端的公共方法。而ComponentName是一个封装了组件(Activity, Service, BroadcastReceiver, or ContentProvider)信息的类，如包名，组件描述等信息，较少使用该参数
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //绑定成功之后返回service实际上就是Myservice中的Mybinder内部类
            myBinder= (MyService.Mybinder) service;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //Android 系统会在与服务的连接意外中断时（例如当服务崩溃或被终止时）调用该方法。注意:当客户端取消绑定时，系统“绝对不会”调用该方法
            Log.e("TAG", "Service connected  error"+name.toString());
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    //调用Myservice方法
    public  void callMethodgetNumber(View view){
        if(null!=myBinder){
            MyService myservice = myBinder.getMyservice();
            int number = myservice.getNumber();
            Toast.makeText(this,number+"",Toast.LENGTH_LONG).show();
        }


    }
    //调用服务Myibiner自定义内部类的中的方法
    public  void callMethodgetName(View view){
        if(null!=myBinder){
            String name = myBinder.getName();
            Toast.makeText(this,name+"",Toast.LENGTH_LONG).show();
        }
    }
    //绑定服务
    public  void bindService(View view){
        intent=new Intent(this,MyService.class);
        bindService(intent,conn, Service.BIND_AUTO_CREATE);
    }
    //解绑服务
    public  void unbindService(View view){
        if(null!=conn){
            unbindService(conn);
        }
    }
    //生命周期结束的试试解绑服务
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if(conn!=null){
            unbindService(conn);
        }
    }
}

4.启动服务和绑定服务的区别

• startService

  该服务在其他组件调用 startService() 时创建，然后无限期运行，且必须通过调用 stopSelf() 来自行停止运行。此外，其他组件也可以通过调用 stopService() 来停止服务。服务停止后，系统会将其销毁

• bindServer

  该服务在另一个组件（客户端）调用 bindService() 时创建。然后，客户端通过 IBinder 接口与服务进行通信。客户端可以通过调用 unbindService() 关闭连接。多个客户端可以绑定到相同服务，而且当所有绑定全部取消后，系统即会销毁该服务。 （服务不必自行停止运行）

  5. startService和bindService混合使用？

  如果一个Service又被启动又被绑定，则该Service会一直在后台运行。首先不管如何调用，onCreate始终只会调用一次。对应startService调用多少次，Service的onStart方法便会调用多少次。Service的终止，需要unbindService和stopService同时调用才行。不管startService与bindService的调用顺序，如果先调用unbindService，此时服务不会自动终止，再调用stopService之后，服务才会终止；如果先调用stopService，此时服务也不会终止，而再调用unbindService或者之前调用bindService的Context不存在了（如Activity被finish的时候）之后，服务才会自动停止

什么情况下既使用startService，又使用bindService呢？

如果你只是想要启动一个后台服务长期进行某项任务，那么使用startService便可以了。如果你还想要与正在运行的Service取得联系，那么有两种方法：一种是使用broadcast，另一种是使用bindService。前者的缺点是如果交流较为频繁，容易造成性能上的问题，而后者则没有这些问题。因此，这种情况就需要startService和bindService一起使用了

6 .Android 5.0以上的隐式启动问题

在Android 5.0之前使用隐式调用Service，是没问题的，但是有log标识这样是不安全的。参考4.4contextImpl源码

private void validateServiceIntent(Intent service) {  
    if (service.getComponent() == null && service.getPackage() == null) {  
        if (true || getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.KITKAT) {  
            Log.w(TAG, "Implicit intents with startService are not safe: " + service  
                    + " " + Debug.getCallers(2, 3));  
            //IllegalArgumentException ex = new IllegalArgumentException(  
            //        "Service Intent must be explicit: " + service);  
            //Log.e(TAG, "This will become an error", ex);  
            //throw ex;  
        }  
    }  
}  

但是在Android 5.0之后，如果在使用隐式调用，系统是不允许的，就会报出异常信息，具体参考5.0源码ContextImpl

private void validateServiceIntent(Intent service) {  
    if (service.getComponent() == null && service.getPackage() == null) {  
        if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {  
            IllegalArgumentException ex = new IllegalArgumentException(  
                    "Service Intent must be explicit: " + service);  
            throw ex;  
        } else {  
            Log.w(TAG, "Implicit intents with startService are not safe: " + service  
                    + " " + Debug.getCallers(2, 3));  
        }  
    }  
}  

怎么解决5.0之后的问题呢？

• 设置包名

final Intent serviceIntent=new Intent(); serviceIntent.setAction("com.android.Myservice");
serviceIntent.setPackage(getPackageName());//设置应用的包名
startService(serviceIntent);

• 隐式调用转为显示调用

public static Intent getExplicitIntent(Context context, Intent implicitIntent) {
    // Retrieve all services that can match the given intent
     PackageManager pm = context.getPackageManager();
     List<ResolveInfo> resolveInfo = pm.queryIntentServices(implicitIntent, 0);
     // Make sure only one match was found
     if (resolveInfo == null || resolveInfo.size() != 1) {
         return null;
     }
     // Get component info and create ComponentName
     ResolveInfo serviceInfo = resolveInfo.get(0);
     String packageName = serviceInfo.serviceInfo.packageName;
     String className = serviceInfo.serviceInfo.name;
     ComponentName component = new ComponentName(packageName, className);
     // Create a new intent. Use the old one for extras and such reuse
     Intent explicitIntent = new Intent(implicitIntent);
     // Set the component to be explicit
     explicitIntent.setComponent(component);
     return explicitIntent;
    }
-----------------------------------

Intent mIntent=new Intent();//辅助Intent
mIntent.setAction("com.android.ForegroundService");
final Intent serviceIntent=new Intent(getExplicitIntent(this,mIntent));
startService(serviceIntent);

7.如何保证服务不被杀死

• 因内存资源不足而杀死Service

  这种情况比较容易处理，可将onStartCommand() 方法的返回值设为 START_STICKY或START_REDELIVER_INTENT ，该值表示服务在内存资源紧张时被杀死后，在内存资源足够时再恢复。也可将Service设置为前台服务，这样就有比较高的优先级，在内存资源紧张时也不会被杀掉

• 用户通过 settings -> Apps -> Running -> Stop 方式杀死Service

  这种情况是用户手动干预的，不过幸运的是这个过程会执行Service的生命周期，也就是onDestory方法会被调用，这时便可以在 onDestory() 中发送广播重新启动。这样杀死服务后会立即启动。这种方案是行得通的，但为程序更健全，我们可开启两个服务，相互监听，相互启动。服务A监听B的广播来启动B，服务B监听A的广播来启动A

public class ServiceKilledByAppStop extends Service{

    private BroadcastReceiver mReceiver;
    private IntentFilter mIF;

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

    @Override
    public void onCreate() {
        super.onCreate();
        mReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                Intent a = new Intent(ServiceKilledByAppStop.this, ServiceKilledByAppStop.class);
                startService(a);
            }
        };
        mIF = new IntentFilter();
        //自定义action
        mIF.addAction("com.restart.service");
        //注册广播接者
        registerReceiver(mReceiver, mIF);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();

        Intent intent = new Intent();
        intent.setAction("com.restart.service");
        //发送广播
        sendBroadcast(intent);

        unregisterReceiver(mReceiver);
    }
}

• 用户通过 settings -> Apps -> Downloaded -> Force Stop 方式强制性杀死Service
  理论上无法重启服务

8. Service和IntentService区别？

• Service
  Service 不是一个单独的进程，它和应用程序在同一个进程中，Service 也不是一个线程,它和线程没有任何关系，所以它不能直接处理耗时操作。如果直接把耗时操作放在 Service 的 onStartCommand() 中，很容易引起 ANR .如果有耗时操作就必须开启一个单独的线程来处理

• IntentService
  IntentService 是继承于 Service 并处理异步请求的一个类，在 IntentService 内有一个工作线程来处理耗时操作，启动 IntentService 的方式和启动传统 Service 一样，同时，当任务执行完后，IntentService 会自动停止，而不需要我们去手动控制。另外，可以启动 IntentService 多次，而每一个耗时操作会以工作队列的方式在IntentService 的 onHandleIntent 回调方法中执行，并且，每次只会执行一个工作线程，执行完第一个再执行第二个，以此类推

IntentService的好处：

• 省去了在 Service 中手动开线程的麻烦
• 当操作完成时，我们不用手动停止 Service

IntentService的使用：

package com.phone.test_service;

import android.app.IntentService;
import android.content.Intent;
import android.os.IBinder;
import android.support.annotation.Nullable;

/**
 * Created by zhang on 2018/4/26.
 */

public class MyIntentService extends IntentService {


    /**
     * 无参数构造方法必须实现，而且需要的调用父类的构造方法传入字符串作为线程名称
     */
    public MyIntentService(){
        super("MyIntentService");
    }

    //生命周期方法
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * 此方法用与接收传递过来数据，进行耗时操作，最终更新UI,任务执行完成之后，就会自动结束
     * @param intent
     */
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
            //耗时操作
    }

    @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();
    }



}

通过代码可以看出，我们继承了IntentService，这里有两个方法是必须实现的，一个是构造方法，必须传递一个线程名称的字符串，另外一个就是进行异步处理的方法onHandleIntent(Intent intent) 方法，其参数intent可以附带从activity传递过来的数据

参考资料：
https://blog.csdn.net/javazejian/article/details/52426425
https://blog.csdn.net/javazejian/article/details/52709857
https://blog.csdn.net/dfskhgalshgkajghljgh/article/details/51471108
开发艺术探索