每天進步一點點之Android基礎（1）——Android Service、IntentService，Service和組件間通信

Service

Service 和Activity 一樣同爲Android 的四大組件之一，並且他們都有各自的生命週期，要想掌握Service 的用法，那就要了解Service 的生命週期有哪些方法，並且生命週期中各個方法回調的時機和作用。有一點比較重要，Service 有兩種啓動方式，並且它的兩種啓動方式的生命週期是不一樣的。接下來來分別看一下兩種啓動方式各自的生命週期方法。

startService方式啓動Service

當應用組件通過startService方法來啓動Service 時，Service 則會處於啓動狀態，一旦服務啓動，它就會在後臺無限期的運行，生命週期獨立於啓動它的組件，即使啓動它的組件已經銷燬了也不受任何影響，由於啓動的服務長期運行在後臺，這會大量消耗手機的電量，因此，我們應該在任務執行完成之後調用stopSelf()來停止服務，或者通過其他應用組件調用stopService 來停止服務。

startService 啓動服務後，會執行如下生命週期：onCreate() －>onStartCommand() －> onStart()(現在已經廢棄) －> onDestroy() 。具體看一下它的幾個生命週期方法：

onCreate() :首次啓動服務的時候，系統會調用這個方法，在onStartCommand 和 onBind 方法之前，如果服務已經啓動起來了，再次啓動時，則不會調用此方法，因此可以在onCreate 方法中做一些初始化的操作，比如要執行耗時的操作，可以在這裏創建線程，要播放音樂，可以在這裏初始化音樂播放器。
onStartCommand(): 當通過startService 方法來啓動服務的時候，在onCreate 方法之後就會回調這個方法，此方法調用後，服務就啓動起來了，將會在後臺無限期的運行，直到通過stopService 或者 stopSelf 方法來停止服務。
onDestroy():當服務不再使用且將被銷燬時，系統將調用此方法。服務應該實現此方法來清理所有資源，如線程、註冊的偵聽器、接收器等。這是服務接收的最後一個調用。

瞭解了這幾個生命週期方法後，我們就來寫一個簡單Service 。

要使用Service 就要通過繼承Service類（或者繼承IntentService ,後文會講）來實現，代碼如下：

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        return null;
    }
 
    @Override
    public void onCreate() {
        Log.i(TAG,"call onCreate...");
    }
 
    @Override
    public void onStart(Intent intent, int startId) {
        Log.i(TAG,"call onStart...");
    }
 
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        return super.onStartCommand(intent, flags, startId);
    }
 
    @Override
    public void onDestroy() {
        Log.i(TAG,"call onDestroy...");
    }
 
 
 
}

Service類寫好了之後，我們需要在清單文件中註冊一下，在<application> 標籤下：

        <service android:name=".service.SimpleService"
                 android:exported="false"
            />

寫好了Service並且在清單文件註冊之後，我們就可以啓動Service了，啓動Service和啓動Activity 差不多，通過Intent 來啓動，代碼如下：

  @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.start_service:
                Intent intent = new Intent(this,SimpleService.class);
                // 啓動服務
                startService(intent);
                break;
            case R.id.stop_service:
                Intent service = new Intent(this,SimpleService.class);
                // 停止服務
                stopService(service);
                break;
        }
    }

小結：通過startService 方式啓動的服務，服務會無限期的在後臺運行，直到通過stopService 或 stopSelf 來終止服務。服務獨立於啓動它的組件，也就是說，當組件啓動服務後，組件和服務就再也沒有關係了，就算啓動它的組件被銷燬了，服務照樣在後臺運行。通過這種方式啓動的服務不好與組件之間通信。

bindService 方式啓動服務

除了startService 來啓動服務之外，另外一種啓動服務的方式就是通過bindService 方法了，也就是綁定服務，其實通過它的名字就容易理解，綁定即將啓動組件和服務綁定在一起。前面講的通過startService 方式啓動的服務是與組件相獨立的，即使啓動服務的組件被銷燬了，服務仍然在後臺運行不受干擾。但是通過bindSerivce 方式綁定的服務就不一樣了，它與綁定組件的生命週期是有關的。如下：

多個組件可以綁定到同一個服務上，如果只有一個組件綁定服務，當綁定的組件被銷燬時，服務也就會停止了。如果是多個組件綁定到一個服務上，當綁定到該服務的所有組件都被銷燬時，服務纔會停止。

bindService 綁定服務和startService 的生命週期是不一樣，bindServie 的生命週期如下：onCreate －> onBind －> onUnbind －>onDestroy。其中重要的就是onBind 和onUnbind 方法。

onBind(): 當其他組件想通過bindService 與服務綁定時，系統將會回調這個方法，在實現中，你必須返回一個IBinder接口，供客戶端與服務進行通信，必須實現此方法，這個方法是Service 的一個抽象方法，但是如果你不允許綁定的話，返回null 就可以了。
onUnbind(): 當所有與服務綁定的組件都解除綁定時，就會調用此方法。

瞭解了這2個方法後，我們來看一下怎麼綁定一個服務。
1，首先，添加一個類繼承 Binder ,在Binder 類中添加其他組件要與服務交互的方法，並在onBind() 方法中返回IBinder 實例對象：

public class SimpleService extends Service {
    public static final String TAG = "SimpleService";
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG,"call onBind...");
        //返回IBinder 接口對象
        return new MyBinder();
    }
 
    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG,"call onUnbind...");
        return super.onUnbind(intent);
    }
 
    @Override
    public void onCreate() {
        Log.i(TAG,"call onCreate...");
    }
 
    @Override
    public void onStart(Intent intent, int startId) {
        Log.i(TAG,"call onStart...");
    }
 
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        return super.onStartCommand(intent, flags, startId);
    }
 
    @Override
    public void onDestroy() {
        Log.i(TAG,"call onDestroy...");
    }
 
    // 添加一個類繼承Binder
    public  class MyBinder extends Binder{
        // 添加要與外界交互的方法
        public String  getStringInfo(){
          return "調用了服務中的方法";
        }
    }
 
}

2, 綁定服務的時候，需要提供一個ServiceConnection 接口，在接口回調中獲取Binder 對象，與服務進行通信。

 private SimpleService.MyBinder mMyBinder;
    // 綁定/解除綁定 Service 回調接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 綁定成功後回調
            //1 ,獲取Binder接口對象
            mMyBinder = (SimpleService.MyBinder) service;
            //2, 從服務獲取數據
            String content = mMyBinder.getStringInfo();
            // 3,界面提示
            Toast.makeText(ServiceSimpleActivity.this,content,Toast.LENGTH_LONG).show();
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除綁定後回調
            mMyBinder = null;
        }
    };

3,綁定和解除綁定服務

            case R.id.bind_service:
                Intent intent = new Intent(this,SimpleService.class);
                // 綁定服務
                bindService(intent,mConnection, Context.BIND_AUTO_CREATE);
                break;
            case R.id.unbind_service:
                // 解除綁定服務
                unbindService(mConnection);
 
                break;

點擊綁定按鈕，即綁定服務，並且在onServiceConnected 中得到MyBinder 對象，就可以通過這個對象和服務通信了

多個組件綁定同一服務

Service 是支持多個組件綁定在同一個服務上的，第一個組件綁定是會回調 onCreate 生命週期方法，後續的綁定只會調用onBind方法，返回IBinder給客戶端。當綁定在服務上的組件都調用unbindService 解除綁定服務或者組件本身就已經被系統回收，那麼服務也就會被停止回收了，會回調onUnbind 和 onDestroy 方法。

Service 與應用組件通信的幾種方式

1,BroadcastReceiver

通過前文我們知道，startService方式啓動的服務在後臺，無限期地運行，並且與啓動它的組件是獨立的，啓動Service 之後也就與啓動它的組件沒有任何關係了。因此它是不能與啓動它的組件之間相互通信的。雖然Service 沒有提供這種啓動方式的通信方法，我們還是可以通過其他方式來解決的，這就用到了BroadcastReceiver。

場景描述：通過startService 啓動一個長期在後臺運行的下載圖片服務，然後在界面上點擊下載按鈕，通過intent 傳遞一個下載鏈接給Service，在下載完成後，通過BroadcastReceiver 通知Activity 界面顯示圖片。看一下代碼實現：

Service代碼如下：

public class DownloadService extends Service {
    public static final String IMAGE = "iamge_url";
    public static final String RECEIVER_ACTION = "com.zhouwei.simpleservice";
    private static final String TAG = "DownloadService";
    public static final String ACTION_START_SERVICER = "com.zhouwei.startservice";
    public static final String ACTION_DOWNLOAD = "com.zhouwei.startdownload";
    private Looper mServiceLooper;
    private ServiceHandler mServiceHandler;
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper){
            super(looper);
        }
 
        @Override
        public void handleMessage(Message msg) {
            // 工作線程做耗時下載
            String url = (String) msg.obj;
            Bitmap bitmap = null;
            try {
                bitmap = Picasso.with(getApplicationContext()).load(url).get();
                Intent intent = new Intent();
                intent.putExtra("bitmap",bitmap);
                intent.setAction(RECEIVER_ACTION);
                // 通知顯示
                LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
            } catch (IOException e) {
                e.printStackTrace();
            }
 
 
            //工作完成之後，停止服務
            stopSelf();
        }
    }
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public void onCreate() {
        // 開啓一個工作線程做耗時工作
        HandlerThread thread = new HandlerThread("ServiceHandlerThread", Process.THREAD_PRIORITY_BACKGROUND);
        thread.start();
        // 獲取工作線程的Looper
        mServiceLooper = thread.getLooper();
        // 創建工作線程的Handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
 
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(TAG,"call onStartCommand...");
        if(intent.getAction().equals(ACTION_DOWNLOAD)){
            handleCommand(intent);
        }else if(intent.getAction().equals(ACTION_START_SERVICER)){
            //do nothing
        }
 
        return START_STICKY;
    }
 
    private void handleCommand(Intent intent){
        String url = intent.getStringExtra(IMAGE);
        // 發送消息下載
        Message message = mServiceHandler.obtainMessage();
        message.obj = url;
        mServiceHandler.sendMessage(message);
    }
}

新建了一個DownloadService ，在裏面啓動了一個工作線程，在線程裏下載圖片，然後通過BroadcastReceiver 通知Activity顯示。

Activity的代碼很簡單，註冊BroadcastReceiver，在onReceiver中顯示圖片就好了，代碼如下：

private ImageView mImageView;
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // 顯示圖片
            Bitmap bitmap = intent.getParcelableExtra("bitmap");
            mImageView.setImageBitmap(bitmap);
        }
    };

 
    /**
     * 啓動下載
     */
    private void startDownload(){
        Intent intent = new Intent(this,DownloadService.class);
        // 啓動服務
        intent.putExtra(DownloadService.IMAGE,"http://www.8kmm.com/UploadFiles/2012/8/201208140920132659.jpg");
        intent.setAction(DownloadService.ACTION_DOWNLOAD);
        startService(intent);
    }

如上就完成了使用BroadcastReceiver 完成和組件和Service的通信。

2, LocaService 使用Binder 和服務通信
既然通過startService 啓動的服務與啓動它的組件是獨立的。相互通信比較麻煩，那麼Google也提供了兩者之間的通信方法，那就是組件綁定服務，也就是上文講的通過bindService 將組件和服務綁定到一起。組件可以獲取Service 通過onBind返回的一個IBinder接口，這樣兩者就可以通信了，這也是Service 應用類通信比較常用的方式。

下面就模擬一個用服務播放音樂的例子來講一下組件通過Binder 接口和服務之間通信。
首先定義一個通信的接口 IPlayer：

/**
 * Created by zhouwei on 17/5/11.
 */
 
public interface IPlayer {
    // 播放
    public void play();
    // 暫停
    public void pause();
    // 停止
    public void stop();
    // 獲取播放進度
    public int getProgress();
    // 獲取時長
    public int getDuration();
}

然後添加一個MusicService 類，繼承Service 實現 Iplayer 接口：

public class MusicService extends Service implements IPlayer{
    public static final String TAG = "MusicService";
    private LocalService mBinder = new LocalService();
    public class LocalService extends Binder{
        public MusicService getService(){
            return MusicService.this;
        }
    }
 
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
 
    @Override
    public void play() {
        Log.i(TAG,"music play...");
    }
 
    @Override
    public void pause() {
        Log.i(TAG,"music pause...");
    }
 
    @Override
    public void stop() {
        Log.i(TAG,"music stop...");
    }
 
    @Override
    public int getProgress() {
        return 100;
    }
 
    @Override
    public int getDuration() {
        return 10240;
    }
}

其中比較重要的就是內部類LocalService ，繼承Binder ,裏面提供一個getService 方法，返回MusicService 實例，組件通過IBinder 獲取到Music 實例後，就可以和Service之間相互通信啦！

Activity中代碼如下：

 private MusicService.LocalService mLocalService;
    private MusicService mMusicService;
    // 綁定/解除綁定 Service 回調接口
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //1 ,獲取Binder接口對象
            mLocalService = (MusicService.LocalService) service;
            //2, 獲取MusicService 實例
            mMusicService = mLocalService.getService();
 
            // 只要拿到Music Service 實例之後，就可以調用接口方法了
            // 可以通過它來播放／暫停音樂，還可以通過它來獲取當前播放音樂的進度，時長等等
 
            mMusicService.play();
 
            mMusicService.pause();
 
            mMusicService.stop();
 
            int progress = mMusicService.getProgress();
            Log.i(MusicService.TAG,"progress:"+progress);
 
            int duration = mMusicService.getDuration();
            Log.i(MusicService.TAG,"duration:"+duration);
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
           // 解除綁定後回調
            mMusicService = null;
            mLocalService = null;
        }
    };

獲取到MusicService 後，就可以調用接口方法了，比如：播放音樂，暫停、停止、獲取進度等等。

** 使用AIDL 通信（跨進城通信IPC）**
AIDL（Android 接口定義語言）執行所有將對象分解成原語的工作，操作系統可以識別這些原語並將它們編組到各進程中，以執行 IPC。如果不是多線程訪問服務的話，也可以使用Messenger來跨進城通信，Messenger
方法實際上是以 AIDL 作爲其底層結構。Messenger
會在單一線程中創建包含所有客戶端請求的隊列，以便服務一次接收一個請求。不過，如果您想讓服務同時處理多個請求，則可直接使用 AIDL。在此情況下，您的服務必須具備多線程處理能力，並採用線程安全式設計。如需直接使用 AIDL，您必須創建一個定義編程接口的 .aidl
文件。Android SDK 工具利用該文件生成一個實現接口並處理 IPC 的抽象類，您隨後可在服務內對其進行擴展。

注意：只有允許不同的客戶端用IPC 方式訪問服務，並且想要在服務中處理多線程時，採用AIDL,如果不想通過IPC實現不同應用的訪問，直接用前面所講的繼承Binder ，用接口通信就可以了。

Service 總結

Service 有2種啓動方式，startService 啓動服務，服務啓動起來後，在後臺無限期運行，直到通過stopService 或者 stopSelf 停止服務，服務與組件獨立，通信比較困難（但還是有辦法的，通過BroadcastReceiver ）。另一種方式就是 bindService 即綁定服務，組件和服務綁定在一起，服務的生命後期受組件影響，如果綁定到服務的組件全部被銷燬了，那麼服務也就會停止了。綁定服務的方式通常用於組件和服務之間需要相互通信。startService 這種方式一般用於在後臺執行任務，而不需要返回結果給組件。 這兩種方式並非完全獨立，也就是說，你可以綁定已經通過 startService 啓動起來的服務，可以通過在Intent 中添加Action 來標示要執行的動作。比如：通過Intent Action 標記要播放的音樂，調用startService 來啓動音樂服務播放音樂，在界面需要顯示播放進度的時候，可以通過binderService 來綁定服務，從而獲取歌曲信息。這種情況下，Service 需要實現兩種方式的生命週期。這種情況下，除非所有客戶端都已經取消綁定，否則通過stopService 或者 stopSelf 是不能停止服務的。

Service 是運行在主線程中的，因此不能執行耗時的或者密集型的任務，如果要執行耗時操作或者密集型計算任務，請在服務中開啓工作線程，在線程中執行。或者使用下面一節將要講的IntentService。

IntentService

IntentService 是Service 的子類，它使用工作線程逐一處理所有啓動請求，果您不要求服務同時處理多個請求，這是最好的選擇。您只需實現 onHandIntent方法即可，該方法會接收每個啓動請求的 Intent，使您能夠執行後臺工作。

IntentService 示例

IntentService 默認爲我們開啓了一個工作線程，在任務執行完畢後，自動停止服務，因此在我們大多數的工作中，使用IntentService 就夠了，並且IntentService 比較簡單，只要實現一個方法OnHandleIntent，接下來看一下示例：

IntentService 擴展類：

public class MyIntentService extends IntentService {
    public static final String TAG ="MyIntentService";
    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public MyIntentService() {
        super("MyIntentService");
    }
 
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
      // 這裏已經是工作線程，在這裏執行操作就行
 
       boolean isMainThread =  Thread.currentThread() == Looper.getMainLooper().getThread();
        Log.i(TAG,"is main thread:"+isMainThread);
 
        // 執行耗時下載操作
        mockDownload();
    }
 
    /**
     * 模擬執行下載
     */
    private void mockDownload(){
       try {
           Thread.sleep(5000);
           Log.i(TAG,"下載完成...");
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

IntentService 源碼淺析

IntentService 自動爲我們開啓了一個線程來執行耗時操作，並且在任務完成後自動停止服務，那麼它是怎麼做的呢？我們看一下源碼一探究竟。其實IntentService 的源碼非常簡單，就一百多行。一起看一下：

   // 1,有一個Looper 變量和一個ServiceHandler 變量，ServiceHander 繼承Handler 處理消息
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;
 
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }
 
        @Override
        public void handleMessage(Message msg) {
           // 在工作線程中調用onHandleIntent，子類根據Intent傳遞的數據執行具體的操作
            onHandleIntent((Intent)msg.obj);
          // 任務執行完畢後，自動停止Service
            stopSelf(msg.arg1);
        }
    }
//2, 在OnCreate 方法中，創建了一個線程HandlerThread ，並啓動線程
// 然後獲取工作線程的Looper ，並用Looper 初始化Handler(我們都知道Handler 的創建需要一依賴Looper)
 public void onCreate() {
        // TODO: It would be nice to have an option to hold a partial wakelock
        // during processing, and to have a static startService(Context, Intent)
        // method that would launch the service & hand off a wakelock.
 
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
 
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
//3, 在onStart()方法中發送消息給Handler,並且把Intent 傳給了Handler 處理
 @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }
// 4，onStartCommand 直接調用的是onStart方法
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
// 5 最後就是一個子類需要實現的抽象方法，這個方法在handleMessage中調用，也就是在工作線程中執行。
 protected abstract void onHandleIntent(@Nullable Intent intent);

代碼很簡單，IntentService的源碼看着是不是很熟悉？當然很熟悉，前面使用Service的時候，在Service 裏面開啓工作線程其實就和Intent Service的代碼差不多。在onCreate中創建線程，啓動，初始化Handler和Looper ，然後在onStartCommand中發送消息給Handler 處理任務。

IntentService 總結

IntentService是Service 的子類，默認給我們開啓了一個工作線程執行耗時任務，並且執行完任務後自動停止服務。擴展IntentService比較簡單，提供一個構造方法和實現onHandleIntent 方法就可了，不用重寫父類的其他方法。但是如果要綁定服務的話，還是要重寫onBind 返回一個IBinder 的。使用Service 可以同時執行多個請求，而使用IntentService 只能同時執行一個請求。

每天進步一點點之Android基礎（1）——Android Service、IntentService，Service和組件間通信

Service

startService方式啓動Service

bindService 方式啓動服務

多個組件綁定同一服務

Service 與應用組件通信的幾種方式

Service 總結

IntentService

IntentService 示例

IntentService 源碼淺析

IntentService 總結

【面試準備】又一次失敗的面試經歷，題目離譜～資深軟件測試工程師

dotnet 8 版本與銀河麒麟V10和UOS系統的 glibc 兼容性

Android RecyclerView 實現position列表倒序排列（彙總）

Android 調用系統藍牙發送文件

每天進步一點點之Android基礎（2）——Android Application的使用及其生命週期

Android POI對Excel進行數據讀寫

用Fiddler抓包Android應用（解決手機設置代理後無法上網）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結