Android開發之低調的Service

            //采用startService啟動服務
            btn_start.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent= new Intent(MainActivity.this,MyService.class );
                     startService(intent);
                }
           });

            //銷毀服務
            btn_stop.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                      Intent intent=new Intent(MainActivity.this,MyService. class);
                     stopService(intent);
                }
           });

我們發現再次啟動時系統並沒有重新實例化這個Service，因為系統發現這個服務已經啟動了，此時它會直接調用onStartCommand方法，在onStartCommand方法中會調用onStart方法

onStartCommand方法的源碼：

     /* @param intent The Intent supplied to {@link android.content.Context#startService},
     * as given.  This may be null if the service is being restarted after
     * its process has gone away, and it had previously returned anything
     * except {@link #START_STICKY_COMPATIBILITY}.
     * @param flags Additional data about this start request.  Currently either
     * 0, {@link #START_FLAG_REDELIVERY}, or {@link #START_FLAG_RETRY}.
     * @param startId A unique integer representing this specific request to
     * start.  Use with {@link #stopSelfResult(int)}.
     *
     * @return The return value indicates what semantics the system should
     * use for the service's current started state.  It may be one of the
     * constants associated with the {@link #START_CONTINUATION_MASK} bits.
     *
     * @see #stopSelfResult(int)
     */
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent , startId);
        return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;
    }

發現當調用 stopService(intent)這個方法是會調用Service的onDestroy方法從而銷毀服務。

2.綁定服務和解除綁定的學習

          //綁定服務
            btn_bind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     Intent intent = new Intent(MainActivity.this,MyService.class );
                     bindService(intent, conn,Context. BIND_AUTO_CREATE);
                }
           });
            //解除綁定
            btn_unbind.setOnClickListener( new OnClickListener() {
                
                 public void onClick(View v) {
                     unbindService( conn);
                }
           });

  private ServiceConnection conn= new ServiceConnection() {
     /**
     * Called when a connection to the Service has been established, with
     * the {@link android.os.IBinder} of the communication channel to the
     * Service.
     *
     * @param name The concrete component name of the service that has
     * been connected.
     *
     * @param service The IBinder of the Service's communication channel,
     * which you can now make calls on.
     */
       public void onServiceConnected(ComponentName name, IBinder service) {
                 //connected
                Log. i( TAG,onServiceConnection called. );
           }
     
     /**
     * Called when a connection to the Service has been lost.  This typically
     * happens when the process hosting the service has crashed or been killed.
     * This does not  remove the ServiceConnection itself -- this
     * binding to the service will remain active, and you will receive a call
     * to {@link #onServiceConnected} when the Service is next running.
     *
     * @param name The concrete component name of the service whose
     * connection has been lost.
     */
      public void onServiceDisconnected(ComponentName name) {
           
     }
};

     @Override
     public IBinder onBind(Intent intent) {
           Log. i(TAG,onBind called );
            return new Binder(){};
     }

     //定義一個變量，標識這個服務是否處於綁定狀態
     private boolean binded; 
     //定義一個綁定服務的方法
     private void unbindService(){
         if( binded){
                unbindService( conn);
                 binded= false;
           }
      }

      //解除綁定
    btn_unbind.setOnClickListener( new OnClickListener() {
                
     public void onClick(View v) {
         unbindService();
           }
     });
   //在onDestroy方法中調用解除綁定的方法
      protected void onDestroy() {
           unbindService();
     };

1、在調用 bindService 綁定到Service的時候，你就應當保證在某處調用 unbindService 解除綁定（盡管 Activity 被 finish 的時候綁定會自動解除，並且Service會自動停止）；

2、在使用 startService 啟動服務之後，一定要使用 stopService停止服務，不管你是否使用bindService；

3、同時使用 startService 與 bindService 要注意到，Service 的終止，需要unbindService與stopService同時調用，才能終止 Service，不管 startService 與 bindService 的調用順序，如果先調用 unbindService 此時服務不會自動終止，再調用 stopService 之後服務才會停止，如果先調用 stopService 此時服務也不會終止，而再調用 unbindService 或者 之前調用 bindService 的 Context 不存在了（如Activity 被 finish 的時候）之後服務才會自動停止；

4、當在旋轉手機屏幕的時候，當手機屏幕在“橫”“豎”變換時，此時如果你的Activity 如果會自動旋轉的話，旋轉其實是 Activity 的重新創建，因此旋轉之前的使用 bindService 建立的連接便會斷開（Context 不存在了），對應服務的生命周期與上述相同。

5、在 sdk 2.0 及其以後的版本中，對應的 onStart 已經被否決變為了 onStartCommand，不過之前的 onStart 任然有效。這意味著，如果你開發的應用程序用的 sdk 為 2.0 及其以後的版本，那麼你應當使用 onStartCommand 而不是 onStart。

6、startService 啟動服務想要用startService啟動服務，不管Local (本地)還是 Remote(遠程) 我們需要做的工作都是一樣簡單。當然要記得在Androidmanifest.xml 中注冊 service。