public abstract class Service extends ContextWrapper implements ComponentCallbacks2, ContentCaptureManager.ContentCaptureClient {
        
    // 創(chuàng)建時(shí)回調(diào)
    public void onCreate() {
    }

    // startService 時(shí)回調(diào)
    public @StartResult int onStartCommand(Intent intent, @StartArgFlags int flags, int startId) {
        onStart(intent, startId);
        return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
    }
    
    // bindService 時(shí)的回調(diào)
    @Nullable
    public abstract IBinder onBind(Intent intent);
    
    // unbindService 時(shí)的回調(diào)
    public boolean onUnbind(Intent intent) {
        return false;
    }
    
    // 當(dāng) onUnbind 返回 true 時(shí)，重新綁定時(shí)的回調(diào)
    public void onRebind(Intent intent) {
    }
    
    // 銷毀停止時(shí)的回調(diào)
    public void onDestroy() {
    }
    
    // 內(nèi)部的停止方法，若想停止并獲取結(jié)果使用 stopSelfResult(startId)
    public final void stopSelf() {
        stopSelf(-1);
    }
}

         Service 只有一個(gè)，但綁定到 Service 上面的 client 可以有多個(gè)。

client 可以通過 IBinder 接口獲取 Service 實(shí)例，實(shí)現(xiàn) client 端調(diào)用 Service 中的方法以實(shí)現(xiàn)交互。

         啟動(dòng)的 Service 的生命周期與其綁定的 client 息息相關(guān)。當(dāng) client 銷毀時(shí)，會(huì)自動(dòng)與 Service 解除綁定，當(dāng)然，也可以調(diào)用 Context 的 `unbindService()` 方法手動(dòng)與 Service 解除綁定。當(dāng)沒有任何 client 與 Service 綁定時(shí)，Service 就會(huì)自行銷毀。

@Deprecated
public abstract class IntentService extends Service {

    // 該 Handler 在子線程中創(chuàng)建
    private final class ServiceHandler extends Handler {
        
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            // 處理完任務(wù)后自動(dòng)停止
            stopSelf(msg.arg1);
        }
    }
    
    @Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);    
    }
    
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        
        // startService() 時(shí)將信息發(fā)送到 ServiceHandler 中
        mServiceHandler.sendMessage(msg);
    }
    
    /**
	 * 該方法的返回值為 Service 的標(biāo)志位：
	 *
	 *  @see Service.START_STICKY_COMPATIBILITY： START_STICKY 的兼容版本，但不保證服務(wù)被kill后一定能重啟
	 *
	 *  @see Service.START_STICKY： 粘性的，如果 service 進(jìn)程被 kill 掉，保留 service 的狀態(tài)為開始狀態(tài)，但不保留傳送的 intent 對(duì)象。隨后系統(tǒng)會(huì)嘗試重新創(chuàng)建 service，創(chuàng)建后即會(huì)重新調(diào)用 onStartCommand(Intent,int,int) 方法。如果在此期間沒有任何啟動(dòng)命令被傳遞到 service，那么參數(shù) Intent 將為null
	 *
	 *  @see Service.START_NOT_STICKY： 非粘性的，在執(zhí)行完 onStartCommand 后，服務(wù)被異常 kill 掉，系統(tǒng)不會(huì)自動(dòng)重啟該服務(wù)
	 *
	 *  @see Service.START_REDELIVER_INTENT： 重傳 Intent，在執(zhí)行完 onStartCommand 后，服務(wù)被異常 kill 掉，系統(tǒng)會(huì)自動(dòng)重啟該服務(wù)，并將 Intent 的值傳入
	 *
	 */
    @Override
    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
    
    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }
    
    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }
    
    // startService() -----> ServiceHandler 的 handleMessage() ------> onHandleIntent()
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
    
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>

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

    <application ...>
        ...
    </application>
</manifest>

class TestService : Service() {
    
   override fun onCreate() {
      super.onCreate()
       
        // Android 8.0 調(diào)用 startForefround() 方法啟動(dòng)服務(wù)
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            setForegroundService();
        }
   }
    
   private fun  setForegroundService() {
       
       // 創(chuàng)建通知渠道
        val CHANNEL_ID = 1
        val channelName = getString(R.string.channel_name)
       // 設(shè)置通知的優(yōu)先級(jí)
        val importance = NotificationManager.IMPORTANCE_LOW
        val channel = NotificationChannel(CHANNEL_ID, channelName, importance)
        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(channel)

       // 設(shè)置前臺(tái)服務(wù)通知的點(diǎn)擊事件
       val pendingIntent: PendingIntent =
        Intent(this, ExampleActivity::class.java).let { notificationIntent ->
            PendingIntent.getActivity(this, 0, notificationIntent, 0)
        }
       
       // 創(chuàng)建通知
        val notification: Notification = NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle(getText(R.string.notification_title))
                .setContentText(getText(R.string.notification_message))
                .setSmallIcon(R.drawable.icon)
                .setContentIntent(pendingIntent)
                .setTicker(getText(R.string.ticker_text))
                .build()

        // Notification ID cannot be 0.
        startForeground(NOTIFICATION_ID, notification)
   }

   override fun onBind(intent: Intent): IBinder? {
		return null
   }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>

    <application ...>

        <service
            android:name="com.hl.myplugin.TestService"
            android:enabled="true"
            android:exported="false" />
    </application>

</manifest>

<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>

    <application ...>

        <service ...
            android:foregroundServiceType="location|camera|microphone"/>
    </application>

</manifest>

val notification: Notification = ...
// 開啟前臺(tái)服務(wù)的重載方法
startForeground(NOTIFICATION_ID, notification, FOREGROUND_SERVICE_TYPE_LOCATION or FOREGROUND_SERVICE_TYPE_CAMERA)

Foreground service started from background can not have location/camera/microphone access: service SERVICE_NAME

// Android 8.0使用 startForegroundService 在前臺(tái)啟動(dòng)服務(wù)
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
   startForegroundService(Intent(this,TestService::class.java)
}else{
  startService(Intent(this,TestService::class.java))
}

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

<service android:name="SimpleJobIntentService" 
         android:permission="android.permission.BIND_JOB_SERVICE" > 
    ... 
</service>

class SimpleJobIntentService : JobIntentService() {

	companion object {
		private const val JOB_ID = 1

		fun enqueueWork(context: Context, work: Intent) {
			enqueueWork(context, SimpleJobIntentService::class.java, JOB_ID, work)
		}
	}

	override fun onHandleWork(intent: Intent) {
        // 具體邏輯
	}
}

SimpleJobIntentService.enqueueWork(context, new Intent());

public class MessengerService extends Service {
    
    // 存儲(chǔ)客戶端發(fā)送的 Messenger 對(duì)象
    ArrayList<Messenger> mClients = new ArrayList<Messenger>();
    
    int mValue = 0;
    
    /**
     *  客戶端請(qǐng)求注冊(cè) Messenger 
     */
    static final int MSG_REGISTER_CLIENT = 1;
    
    /**
     * 客戶端請(qǐng)求反注冊(cè) Messenger 
     */
    static final int MSG_UNREGISTER_CLIENT = 2;
    

    /**
     * 客戶端請(qǐng)求設(shè)值，相當(dāng)于請(qǐng)求其他命令
     */
    static final int MSG_SET_VALUE = 3;
    

    class IncomingHandler extends Handler {
        
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_REGISTER_CLIENT:
                    mClients.add(msg.replyTo);
                    break;
                case MSG_UNREGISTER_CLIENT:
                    mClients.remove(msg.replyTo);
                    break;
                case MSG_SET_VALUE:
                    mValue = msg.arg1;
                    for (int i=mClients.size()-1; i>=0; i--) {
                        try {
                            // 取得客戶端傳送的 Messenger，發(fā)送消息回 Messenger 實(shí)現(xiàn)雙向通信
                            mClients.get(i).send(Message.obtain(null, MSG_SET_VALUE, mValue, 0));
                        } catch (RemoteException e) {
							// 客戶端有可能在此過程中死了產(chǎn)生異常，需要移除
                            mClients.remove(i);
                        }
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    
    final Messenger mMessenger = new Messenger(new IncomingHandler());
    
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

public class MessengerServiceActivities extends Activity{

    // 向服務(wù)端發(fā)送命令的 Messenger
    private Messenger mService = null;
    
    private boolean mIsBound;
    
    private TextView mCallbackText;
    
    private class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MessengerService.MSG_SET_VALUE:
                    mCallbackText.setText("Received from service: " + msg.arg1);
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    
    // 接收服務(wù)端返回消息的 Messenger
    private final Messenger mMessenger = new Messenger(new IncomingHandler());

    private ServiceConnection mConnection = new ServiceConnection() {
        
        public void onServiceConnected(ComponentName className, IBinder service) {
			// 連接時(shí)獲取與服務(wù)端交互的 Messenger
            mService = new Messenger(service);
            mCallbackText.setText("Attached.");

            try {
                // 將需要接收服務(wù)端返回消息的 Messenger 發(fā)送在消息體中
                Message msg = Message.obtain(null, MessengerService.MSG_REGISTER_CLIENT);
                msg.replyTo = mMessenger;
                mService.send(msg);
                
                // 向服務(wù)端發(fā)送設(shè)值命令
                msg = Message.obtain(null, MessengerService.MSG_SET_VALUE, this.hashCode(), 0);
                mService.send(msg);
            } catch (RemoteException e) {
                // xxx
            }

            Toast.makeText(this, R.string.remote_service_connected, Toast.LENGTH_SHORT).show();
        }
        
        public void onServiceDisconnected(ComponentName className) {
            mService = null;
            mCallbackText.setText("Disconnected.");
            Toast.makeText(this, R.string.remote_service_disconnected,Toast.LENGTH_SHORT).show();
        }
    };
    
    void doBindService() {
        bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);
        mIsBound = true;
        mCallbackText.setText("Binding.");
    }
    
    void doUnbindService() {
        if (mIsBound) {
            if (mService != null) {
                try {
                    // 解綁時(shí)移除服務(wù)端中添加的 Messenger，取消消息接收
                    Message msg = Message.obtain(null, MessengerService.MSG_UNREGISTER_CLIENT);
                    msg.replyTo = mMessenger;
                    mService.send(msg);
                } catch (RemoteException e) {
                    //xxx
                }
            }
            
            unbindService(mConnection);
            mIsBound = false;
            mCallbackText.setText("Unbinding.");
        }
    }
}

public interface IInterface{
    public IBinder asBinder();
}

public interface xxxInterface extends android.os.IInterface{

    public static abstract class Stub extends android.os.Binder implements xxxInterface{
        
        @Override 
        public android.os.IBinder asBinder() {
          	return this;
        }
        
        xxxx
    }
    
    // AIDL 中聲明的抽象方法
    xxxx
}

package com.xfhy.allinone.ipc.aidl;
import com.xfhy.allinone.ipc.aidl.Person;
interface IPersonManager {
    List<Person> getPersonList();
    //in: 從客戶端流向服務(wù)端
    boolean addPerson(in Person person);
}

class Person(var name: String? = "") : Parcelable {
    constructor(parcel: Parcel) : this(parcel.readString())

    override fun toString(): String {
        return "Person(name=$name) hashcode = ${hashCode()}"
    }

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(name)
    }

    fun readFromParcel(parcel: Parcel) {
        this.name = parcel.readString()
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<Person> {
        override fun createFromParcel(parcel: Parcel): Person {
            return Person(parcel)
        }

        override fun newArray(size: Int): Array<Person?> {
            return arrayOfNulls(size)
        }
    }

package com.xfhy.allinone.ipc.aidl;

parcelable Person;

class RemoteService : Service() {

    private val mPersonList = mutableListOf<Person?>()

    private val mBinder: Binder = object : IPersonManager.Stub() {
        
        override fun getPersonList(): MutableList<Person?> = mPersonList

        override fun addPerson(person: Person?): Boolean {
            return mPersonList.add(person)
        }
    }

    override fun onBind(intent: Intent?): IBinder? {
        return mBinder
    }

    override fun onCreate() {
        super.onCreate()
        mPersonList.add(Person("Garen"))
        mPersonList.add(Person("Darius"))
    }
}

class AidlActivity : TitleBarActivity() {

    companion object {
        const val TAG = "xfhy_aidl"
    }

    private var remoteServer: IPersonManager? = null

    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            log(TAG, "onServiceConnected")
            //在onServiceConnected調(diào)用IPersonManager.Stub.asInterface 獲取接口類型的實(shí)例
            //通過這個(gè)實(shí)例調(diào)用服務(wù)端的服務(wù)
            remoteServer = IPersonManager.Stub.asInterface(service)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            log(TAG, "onServiceDisconnected")
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_aidl)

        btnConnect.setOnClickListener {
            connectService()
        }
        btnGetPerson.setOnClickListener {
            getPerson()
        }
        btnAddPerson.setOnClickListener {
            addPerson()
        }
    }

    private fun connectService() {
        val intent = Intent()
        //action 和 package(app的包名)
        intent.action = "com.xfhy.aidl.Server.Action"
        intent.setPackage("com.xfhy.allinone")
        val bindServiceResult = bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        log(TAG, "bindService $bindServiceResult")

        //如果targetSdk是30,那么需要處理Android 11中的程序包可見性  具體參見:        https://developer.android.com/about/versions/11/privacy/package-visibility
    }

    private fun addPerson() {
        //客戶端調(diào)服務(wù)端方法時(shí),需要捕獲以下幾個(gè)異常:
        //RemoteException 異常：
        //DeadObjectException 異常：連接中斷時(shí)會(huì)拋出異常；
        //SecurityException 異常：客戶端和服務(wù)端中定義的 AIDL 發(fā)生沖突時(shí)會(huì)拋出異常；
        try {
            val addPersonResult = remoteServer?.addPerson(Person("蓋倫"))
            log(TAG, "addPerson result = $addPersonResult")
        } catch (e: RemoteException) {
            e.printStackTrace()
        } catch (e: DeadObjectException) {
            e.printStackTrace()
        } catch (e: SecurityException) {
            e.printStackTrace()
        }
    }

    private fun getPerson() {
        val personList = remoteServer?.personList
        log(TAG, "person 列表 $personList")
    }

    override fun onDestroy() {
        super.onDestroy()
        //最后記得unbindService
        unbindService(serviceConnection)
    }
}

2020-12-24 12:41:00.170 24785-24785/com.xfhy.allinone D/xfhy_aidl: bindService true
2020-12-24 12:41:00.906 24785-24785/com.xfhy.allinone D/xfhy_aidl: onServiceConnected
2020-12-24 12:41:04.253 24785-24785/com.xfhy.allinone D/xfhy_aidl: person 列表 [Person(name=Garen), Person(name=Darius)]
2020-12-24 12:41:05.952 24785-24785/com.xfhy.allinone D/xfhy_aidl: addPerson result = true
2020-12-24 12:41:09.022 24785-24785/com.xfhy.allinone D/xfhy_aidl: person 列表 [Person(name=Garen), Person(name=Darius), Person(name=蓋倫)]

override fun addPerson(person: Person?): Boolean {
    log(TAG, "服務(wù)端 addPerson() 當(dāng)前線程 : ${Thread.currentThread().name}")
    return mPersonList.add(person)
}

//日志輸出
服務(wù)端 addPerson() 當(dāng)前線程 : Binder:3961_3

//服務(wù)端
private val mPersonList = CopyOnWriteArrayList<Person?>()

override fun getPersonList(): MutableList<Person?> = mPersonList

//客戶端
private fun getPerson() {
    val personList = remoteServer?.personList
    personList?.let {
        log(TAG, "personList ${it::class.java}")
    }
}

//輸出日志
personList class java.util.ArrayList

interface IPersonChangeListener {
 	 // 這里由服務(wù)端調(diào)用此接口，因此服務(wù)端其實(shí)充當(dāng) "Client"，數(shù)據(jù)流通方向標(biāo)記為 in 更合理
	  void onPersonDataChanged(in Person person);
}

interface IPersonManager {
    ......
    void registerListener(IPersonChangeListener listener);
    void unregisterListener(IPersonChangeListener listener);
}

//RemoteCallbackList.java  源碼有刪減
public class RemoteCallbackList<E extends IInterface> {
    ArrayMap<IBinder, Callback> mCallbacks = new ArrayMap<IBinder, Callback>();

    private final class Callback implements IBinder.DeathRecipient {
        final E mCallback;
        final Object mCookie;

        Callback(E callback, Object cookie) {
            mCallback = callback;
            mCookie = cookie;
        }
    }

    public boolean register(E callback, Object cookie) {
        synchronized (mCallbacks) {
            IBinder binder = callback.asBinder();
            Callback cb = new Callback(callback, cookie);
            mCallbacks.put(binder, cb);
            return true;
        }
    }
}

private val mListenerList = RemoteCallbackList<IPersonChangeListener?>()

private val mBinder: Binder = object : IPersonManager.Stub() {
    .....
    override fun registerListener(listener: IPersonChangeListener?) {
        mListenerList.register(listener)
    }

    override fun unregisterListener(listener: IPersonChangeListener?) {
        mListenerList.unregister(listener)
    }
}

//死循環(huán) 每隔5秒添加一次person,通知觀察者
private val serviceWorker = Runnable {
    while (!Thread.currentThread().isInterrupted) {
        Thread.sleep(5000)
        val person = Person("name${Random().nextInt(10000)}")
        log(AidlActivity.TAG, "服務(wù)端 onDataChange() 生產(chǎn)的 person = $person}")
        mPersonList.add(person)
        onDataChange(person)
    }
}
private val mServiceListenerThread = Thread(serviceWorker)

//數(shù)據(jù)變化->通知觀察者
private fun onDataChange(person: Person?) {
    //1. 使用RemoteCallbackList時(shí),必須首先調(diào)用beginBroadcast(), 最后調(diào)用finishBroadcast(). 得成對(duì)出現(xiàn)
    //這里拿到的是監(jiān)聽器的數(shù)量
    val callbackCount = mListenerList.beginBroadcast()
    for (i in 0 until callbackCount) {
        try {
            //這里try一下避免有異常時(shí)無法調(diào)用finishBroadcast()
            mListenerList.getBroadcastItem(i)?.onPersonDataChanged(person)
        } catch (e: RemoteException) {
            e.printStackTrace()
        }
    }
    
    //3. 最后調(diào)用finishBroadcast()  必不可少
    mListenerList.finishBroadcast()
}

override fun onCreate() {
    .....
    mServiceListenerThread.start()
}

override fun onDestroy() {
    super.onDestroy()
    mServiceListenerThread.interrupt()
}

private val mPersonChangeListener = object : IPersonChangeListener.Stub() {
    override fun onPersonDataChanged(person: Person?) {
        log(TAG, "客戶端 onPersonDataChanged() person = $person}")
    }
}

private fun registerListener() {
    remoteServer?.registerListener(mPersonChangeListener)
}

private fun unregisterListener() {
    remoteServer?.asBinder()?.isBinderAlive?.let {
        remoteServer?.unregisterListener(mPersonChangeListener)
    }
}

服務(wù)端 onDataChange() 生產(chǎn)的 person = Person(name=name9398) hashcode = 130037351}
客戶端 onPersonDataChanged() person = Person(name=name9398) hashcode = 217703225}

private val mDeathRecipient = object : IBinder.DeathRecipient {
    
    override fun binderDied() {
        //監(jiān)聽 binder died
        log(TAG, "binder died")
        //移除死亡通知
        mService?.unlinkToDeath(this, 0)
        mService = null
        //重新連接
        connectService()
    }
}

private val serviceConnection = object : ServiceConnection {
    
    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
        this@AidlActivity.mService = service
        log(TAG, "onServiceConnected")

        //給binder設(shè)置一個(gè)死亡代理
        service?.linkToDeath(mDeathRecipient, 0)

        mRemoteServer = IPersonManager.Stub.asInterface(service)
    }

    override fun onServiceDisconnected(name: ComponentName?) {
        log(TAG, "onServiceDisconnected")
    }
}

//第一次連接
bindService true
onServiceConnected, thread = main

//殺掉服務(wù)端 
binder died, thread = Binder:29391_3
onServiceDisconnected, thread = main

//重連
bindService true
onServiceConnected, thread = main

<permission
    android:name="com.xfhy.allinone.ipc.aidl.ACCESS_PERSON_SERVICE"
    android:protectionLevel="normal" />

<uses-permission android:name="com.xfhy.allinone.ipc.aidl.ACCESS_PERSON_SERVICE"/>

override fun onBind(intent: Intent?): IBinder? {
    val check = checkCallingOrSelfPermission("com.xfhy.allinone.ipc.aidl.ACCESS_PERSON_SERVICE")
    if (check == PackageManager.PERMISSION_DENIED) {
        log(TAG,"沒有權(quán)限")
        return null
    }
    log(TAG,"有權(quán)限")
    return mBinder
}