Android 中的 Service 詳細介紹【下】

上一篇文章Android 中的 Service 全面總結詳解【下】 介紹了Service的一些知識以及本地Service的使用，如果對Service還不太了解的建議先看下上篇文章；本文主要接著上一篇講下遠程服務的使用；

在說到遠程服務的時候，我們需要先了解一些預備的知識：

首先來了解一下AIDL機制：
AIDL的作用
由於每個應用程序都運行在自己的進程空間，並且可以從應用程序UI運行另一個服務進程，而且經常會在不同的進程間傳遞對象。在Android平台，一個進程通常不能訪問另一個進程的內存空間，所以要想對話，需要將對象分解成操作系統可以理解的基本單元，並且有序的通過進程邊界。
通過代碼來實現這個數據傳輸過程是冗長乏味的，Android提供了AIDL工具來處理這項工作。

AIDL (Android Interface Definition Language) 是一種IDL 語言，用於生成可以在Android設備上兩個進程之間進行進程間通信(interprocess communication, IPC)的代碼。如果在一個進程中（例如Activity）要調用另一個進程中（例如Service）對象的操作，就可以使用AIDL生成可序列化的參數。
AIDL IPC機制是面向接口的，像COM或Corba一樣，但是更加輕量級。它是使用代理類在客戶端和實現端傳遞數據。
在Android中, 每個應用程序都有自己的進程，當需要在不同的進程之間傳遞對象時，該如何實現呢? 顯然, Java中是不支持跨進程內存共享的。因此要傳遞對象, 需要把對象解析成操作系統能夠理解的數據格式, 以達到跨界對象訪問的目的。在JavaEE中，采用RMI通過序列化傳遞對象。在Android中, 則采用AIDL(Android Interface Definition Language：接口描述語言)方式實現。
AIDL是一種接口定義語言，用於約束兩個進程間的通訊規則，供編譯器生成代碼，實現Android設備上的兩個進程間通信(IPC)。AIDL的IPC機制和EJB所采用的CORBA很類似，進程之間的通信信息，首先會被轉換成AIDL協議消息，然後發送給對方，對方收到AIDL協議消息後再轉換成相應的對象。由於進程之間的通信信息需要雙向轉換，所以android采用代理類在背後實現了信息的雙向轉換，代理類由android編譯器生成，對開發人員來說是透明的。

選擇AIDL的使用場合
官方文檔特別提醒我們何時使用AIDL是必要的：只有你允許客戶端從不同的應用程序為了進程間的通信而去訪問你的service，以及想在你的service處理多線程。

了解了AIDL之後下面來看一下項目的結構：
我們這個遠程服務是想在將服務端和客戶端分別放到一個應用中，所以這裡要建立兩個Android項目一個是remoteService,一個是remoteClient
首先來看一下Service端的項目結構：

在這裡我們需要定義一個aidl文件，具體步驟很簡單的：
因為AIDL相當於是一個接口，所以它的定義和interface的定義很類似的，使用interface關鍵字，有一點不同的是，AIDL中不能有修飾符(public,protected,private)，不然報錯，這個你們可以自己嘗試一下，然後將定義好的AIDL文件的後綴名.java改成.aidl，此時在gen文件夾下面就會多出一個與之對應的java文件，這個是編譯器干的事情。這個AIDL接口中定義的一般都是Client和Service交互的接口。
下面來看一下StudentQuery.aidl文件：

package cn.itcast.aidl;  
//注意沒有任何的訪問權限修飾符  
interface StudentQuery {  
    //通過number來訪問學生的name  
    String queryStudent(int number);  
} 

代碼結構和接口是大同小異的。
再來看一下服務端的代碼：

package cn.itcast.remote.service;  

import cn.itcast.aidl.StudentQuery;  
import android.app.Service;  
import android.content.Intent;  
import android.os.IBinder;  
import android.os.RemoteException;  
/** 
 * 遠程服務端 
 */  
public class StudentQueryService extends Service {  
    //姓名名稱  
    private String[] names = {"張飛", "李靜", "趙薇"};  

    private IBinder binder = new StudentQueryBinder();  

    @Override  
    public IBinder onBind(Intent intent) {  
        return binder;  
    }  
    /** 
     * 服務中定義的訪問方法 
     * @param number 
     * @return 
     */  
    private String query(int number){  
        if(number > 0 && number < 4){  
            return names[number - 1];  
        }  
        return null;  
    }  

    /** 
     * 定義Binder，這裡需要繼承StudentQuery.Stub 
     * StudentQuery是我們定義的AIDL 
     * @author weijiang204321 
     * 
     */  
    private final class StudentQueryBinder extends StudentQuery.Stub{  
        public String queryStudent(int number) throws RemoteException {           
            return query(number);  
        }         
    }  

}  

這個服務端的代碼和我們之前的本地服務代碼差不多，不同的是我們定義的Binder類是繼承了StudentQuery.Stub類，其中StudentQuery是我們定義的AIDL文件，編譯器幫我們生成的StudentQuery.java（在gen文件夾中）這個類，下面來看一下這個類吧：

/* 
 * This file is auto-generated.  DO NOT MODIFY. 
 * Original file: C:\\Users\\weijiang204321\\Desktop\\傳智播客Android視頻教程_源代碼\\remoteService\\src\\cn\\itcast\\aidl\\StudentQuery.aidl 
 */  
package cn.itcast.aidl;  
//注意沒有任何的訪問權限修飾符  

public interface StudentQuery extends android.os.IInterface  
{  
/** Local-side IPC implementation stub class. */  
public static abstract class Stub extends android.os.Binder implements cn.itcast.aidl.StudentQuery  
{  
private static final java.lang.String DESCRIPTOR = "cn.itcast.aidl.StudentQuery";  
/** Construct the stub at attach it to the interface. */  
public Stub()  
{  
this.attachInterface(this, DESCRIPTOR);  
}  
/** 
 * Cast an IBinder object into an cn.itcast.aidl.StudentQuery interface, 
 * generating a proxy if needed. 
 */  
public static cn.itcast.aidl.StudentQuery asInterface(android.os.IBinder obj)  
{  
if ((obj==null)) {  
return null;  
}  
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
if (((iin!=null)&&(iin instanceof cn.itcast.aidl.StudentQuery))) {  
return ((cn.itcast.aidl.StudentQuery)iin);  
}  
return new cn.itcast.aidl.StudentQuery.Stub.Proxy(obj);  
}  
@Override public android.os.IBinder asBinder()  
{  
return this;  
}  
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
{  
switch (code)  
{  
case INTERFACE_TRANSACTION:  
{  
reply.writeString(DESCRIPTOR);  
return true;  
}  
case TRANSACTION_queryStudent:  
{  
data.enforceInterface(DESCRIPTOR);  
int _arg0;  
_arg0 = data.readInt();  
java.lang.String _result = this.queryStudent(_arg0);  
reply.writeNoException();  
reply.writeString(_result);  
return true;  
}  
}  
return super.onTransact(code, data, reply, flags);  
}  
private static class Proxy implements cn.itcast.aidl.StudentQuery  
{  
private android.os.IBinder mRemote;  
Proxy(android.os.IBinder remote)  
{  
mRemote = remote;  
}  
@Override public android.os.IBinder asBinder()  
{  
return mRemote;  
}  
public java.lang.String getInterfaceDescriptor()  
{  
return DESCRIPTOR;  
}  
//通過number來訪問學生的name  

@Override public java.lang.String queryStudent(int number) throws android.os.RemoteException  
{  
android.os.Parcel _data = android.os.Parcel.obtain();  
android.os.Parcel _reply = android.os.Parcel.obtain();  
java.lang.String _result;  
try {  
_data.writeInterfaceToken(DESCRIPTOR);  
_data.writeInt(number);  
mRemote.transact(Stub.TRANSACTION_queryStudent, _data, _reply, 0);  
_reply.readException();  
_result = _reply.readString();  
}  
finally {  
_reply.recycle();  
_data.recycle();  
}  
return _result;  
}  
}  
static final int TRANSACTION_queryStudent = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
}  
//通過number來訪問學生的name  

public java.lang.String queryStudent(int number) throws android.os.RemoteException;  
}  

感覺好復雜，其實我們沒必要看懂的，這個是Android內部實現的，我們在這裡可以了解一下，看一下那個Stub抽象類，他實現了Binder接口，所以我們需要繼承這個類就可以了，還有一個問題就是我們注意到，就是返回StudentQuery接口對象的問題：

public static cn.itcast.aidl.StudentQuery asInterface(android.os.IBinder obj)  
{  
if ((obj==null)) {  
return null;  
}  
//如果bindService綁定的是同一進程的service,返回的是服務端Stub對象本身，那麼在客戶端是直接操作Stub對象，並不進行進程通信了  
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
if (((iin!=null)&&(iin instanceof cn.itcast.aidl.StudentQuery))) {  
return ((cn.itcast.aidl.StudentQuery)iin);  
}  
//bindService綁定的不是同一進程的service，返回的是代理對象，obj==android.os.BinderProxy對象，被包裝成一個AIDLService.Stub.Proxy代理對象  
//不過AIDLService.Stub.Proxy進程間通信通過android.os.BinderProxy實現  
return new cn.itcast.aidl.StudentQuery.Stub.Proxy(obj);  
}  

/* 
 * Copyright (C) 2006 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */  

package android.os;  

/** 
 * Base class for Binder interfaces.  When defining a new interface, 
 * you must derive it from IInterface. 
 */  
public interface IInterface  
{  
    /** 
     * Retrieve the Binder object associated with this interface. 
     * You must use this instead of a plain cast, so that proxy objects 
     * can return the correct result. 
     */  
    public IBinder asBinder();  
}  

上面的是Interface接口，他只有一個方法asBinder()這個方法就是返回一個IBinder對象，而我們的AIDL接口需要實現這個接口的，所以說這個asBinder()方法的功能就是將AIDL接口轉化成IBinder對象，這個是內部實現的，在asInterface()方法中可以看到：

private static class Proxy implements com.demo.aidl.StudentAIDL  
        {  
            private android.os.IBinder mRemote;  
            Proxy(android.os.IBinder remote)  
            {  
                mRemote = remote;  
            }  
            @Override public android.os.IBinder asBinder()  
            {  
                return mRemote;  
            }  
            public java.lang.String getInterfaceDescriptor()  
            {  
                return DESCRIPTOR;  
            }  
            @Override public java.lang.String queryNameByNo(int no) throws android.os.RemoteException  
            {  
                android.os.Parcel _data = android.os.Parcel.obtain();  
                android.os.Parcel _reply = android.os.Parcel.obtain();  
                java.lang.String _result;  
                try {  
                    _data.writeInterfaceToken(DESCRIPTOR);  
                    _data.writeInt(no);  
                    mRemote.transact(Stub.TRANSACTION_queryNameByNo, _data, _reply, 0);  
                    _reply.readException();  
                    _result = _reply.readString();  
                }  
                finally {  
                    _reply.recycle();  
                    _data.recycle();  
                }  
                return _result;  
            }  
        }  

這個是代理生成類，我們可以看到這個類中是返回的mRemote對象就是IBinder的一個引用，同時也返回了一個StudentQuery實現對象。
在StudentQuery.Stub中有一個asInterface方法，這個方法中我們可以看到，如果這個Service和Client是在同一個進程中，則在Client中的StudentConnection類中返回的是IBinder就是實際的對象，如果不是在同一個進程中的話，返回的是IBinder的代理對象。
其他的問題我們暫時不看了，也不去做深入的了解了，

再來看一下AndroidMainfest.xml文件中配置Service:

service android:name=".StudentQueryService">  
              
                                  
                          

這裡我們開啟服務的話，需要用到隱式意圖了，而不能直接用Service類了，因為是在不同的應用中，這樣服務端的代碼就差不多了，我們現在來看一下客戶端的代碼結構：

首先來看一下，客戶端肯定要有aidl文件，所以我們將服務端的aidl的文件拷到Client中(包括AIDL所在的包也要拷過來，刷新一下，在gen文件夾中出現了StudentQuery.java類)，下面來看一下Client的代碼(MainActivity.java):

package cn.itcast.remoteservice.client;  

import android.app.Activity;  
import android.content.ComponentName;  
import android.content.Intent;  
import android.content.ServiceConnection;  
import android.os.Bundle;  
import android.os.IBinder;  
import android.os.RemoteException;  
import android.util.Log;  
import android.view.View;  
import android.widget.EditText;  
import android.widget.TextView;  
import cn.itcast.aidl.StudentQuery;  

/** 
 * 客戶端的測試代碼 
 * @author weijiang204321 
 * 
 */  
public class MainActivity extends Activity {  
    //定義控件  
    private EditText numberText;  
    private TextView resultView;  
    private StudentQuery studentQuery;  

    //定義一個連接  
    private StudentConnection conn = new StudentConnection();  

    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  

        numberText = (EditText) this.findViewById(R.id.number);  
        resultView = (TextView) this.findViewById(R.id.resultView);  
        //這裡開啟一個Service使用隱式意圖action的名稱必須和remoteService中AndroidMainfest.xml中定義的服務的action的name一樣  
        Intent service = new Intent("cn.itcast.student.query");  
        bindService(service, conn, BIND_AUTO_CREATE);  
    }  

    /** 
     * 給按鈕定義點擊事件 
     * @param v 
     */  
    public void queryStudent(View v) {  
        String number = numberText.getText().toString();  
        int num = Integer.valueOf(number);  
        try {  
            resultView.setText(studentQuery.queryStudent(num));  
        } catch (RemoteException e) {  
            e.printStackTrace();  
        }  
    }  

    @Override  
    protected void onDestroy() {  
        unbindService(conn);  
        super.onDestroy();  
    }  

    /** 
     * 自定義StudentConnection實現了ServiceConnection 
     * @author weijiang204321 
     * 
     */  
    private final class StudentConnection implements ServiceConnection {  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            //這裡就用到了Stub類中的asInterface方法，將IBinder對象轉化成接口  
            studentQuery = StudentQuery.Stub.asInterface(service);  
        }  
        public void onServiceDisconnected(ComponentName name) {  
            studentQuery = null;  
        }  
    }  
}  

Client端的代碼結構和我們之前的本地服務的代碼結構差不多，有幾處不同，第一處不同就是那個開啟服務的方式，這裡使用的是隱式的方式開啟服務的，因為是跨應用訪問的，還有一處不同的是返回的StudentQuery接口對象不同，本地服務的話是通過強制轉化的，而遠程服務這裡是用asInterface方法進行轉化的。
客戶端和服務端的代碼結構看完了，下面我們來運行一下，首先安裝remoteService包，然後運行remoteClient包，在文本框中輸入學號，查詢到名稱了，運行成功。在不同的應用中，一定是跨進程的，不行我們可以查看一下系統的進程：
這裡我們使用adb命令查看：
http://blog.csdn.net/jiangwei0910410003/article/details/17114491
在這篇blog中我說到了怎麼使用這條命令

我們可以看到有兩個進程Proc #9和Proc #12
到這裡我們就介紹了本地服務和遠程服務的使用了，下面我們再來看一下額外的知識，就是怎麼在一個應用中進行遠程服務的訪問，我們之前涉及到的是跨應用的訪問，這裡其實很簡單，只需要改動一處就可以：下面是我改過的一個項目，在同一個應用中進行遠程服務的訪問，代碼都是一樣的，這裡就不做介紹了；

這裡需要修改的地方就是要在AndroidManifest.xml中修改一下Service的定義屬性：<喎?/kf/ware/vc/" target="_blank" class="keylink">vcD4NCjxwcmUgY2xhc3M9"brush:java;">

這裡我們添加了一個屬性就是android:process=”:remote”,這個屬性就是將該服務設置成遠程的，就是和Activity不在同一個進程中，具體的Service屬性說明請看我的另外的一篇blog:
http://blog.csdn.net/jiangwei0910410003/article/details/18794945
運行結果是一樣的，為了證明服務是遠程服務，我們在使用上面的命令打印一下當前系統中的進程信息：

系統中的Proc #9和Proc #10兩個進程，這裡就介紹了怎麼在同一個應用中跨進程訪問服務。

下面在來看一下AIDL:

我們上面說到的AIDL是說他怎麼用，而且很是簡單，我現在來具體看一下AIDL文件的定義：
Aidl默認支持的類型包話java基本類型（int、long、boolean等）和（String、List、Map、CharSequence），如果要傳遞自定義的類型該如何實現呢？
要傳遞自定義類型，首先要讓自定義類型支持parcelable協議，實現步驟如下：
1>自定義類型必須實現Parcelable接口，並且實現Parcelable接口的publicvoid writeToParcel(Parcel dest, int flags)方法 。
2>自定義類型中必須含有一個名稱為CREATOR的靜態成員，該成員對象要求實現Parcelable.Creator接口及其方法。
3> 創建一個aidl文件聲明你的自定義類型。
Parcelable接口的作用：實現了Parcelable接口的實例可以將自身的狀態信息（狀態信息通常指的是各成員變量的值）寫入Parcel，也可以從Parcel中恢復其狀態。Parcel用來完成數據的序列化傳遞。
下面來看一下例子：
1> 創建自定義類型，並實現Parcelable接口,使其支持parcelable協議。如：在cn.itcast.domain包下創建Person.java:

package cn.itcast.domain;  
import android.os.Parcel;  
import android.os.Parcelable;  
public class Person implements Parcelable  
  privateInteger id;  
  private Stringname;  

  public Person(){}  
  publicPerson(Integer id, String name) {  
  this.id = id;  
  this.name = name;  
  }  
  public IntegergetId() {  
  return id;  
  }  
  public voidsetId(Integer id) {  
  this.id = id;  
  }  
  public StringgetName() {  
  return name;  
  }  
  public voidsetName(String name) {  
  this.name = name;  
  }   
  @Override  
  public intdescribeContents() {  
  return 0;  
  }  
  @Override  
  public voidwriteToParcel(Parcel dest, int flags) {//把javanbean中的數據寫到Parcel  
  dest.writeInt(this.id);  
  dest.writeString(this.name);  
  }  
  //添加一個靜態成員,名為CREATOR,該對象實現了Parcelable.Creator接口  
  publicstatic final Parcelable.Creator CREATOR = newParcelable.Creator(){  
  @Override  
  public PersoncreateFromParcel(Parcel source) {//從Parcel中讀取數據，返回person對象  
  return newPerson(source.readInt(), source.readString());  
  }  
  @Override  
  public Person[]newArray(int size) {  
  return newPerson[size];  
  }  
  };  
}  

package cn.itcast.aidl;  
import cn.itcast.domain.Person;  
interface IPersonService {  
      void save(inPerson person);  
}  

public class ServiceBinder extends IPersonService.Stub {  
       @Override  
       public voidsave(Person person) throws RemoteException {  
  Log.i("PersonService",person.getId()+"="+ person.getName());  
       }   
}  

public class PersonService extends Service {  
  privateServiceBinder serviceBinder = new ServiceBinder();  
  @Override  
  public IBinderonBind(Intent intent) {  
  return serviceBinder;  
  }  
public class ServiceBinder extends IPersonService.Stub {  
       @Override  
       public void save(Person person) throwsRemoteException {  
  Log.i("PersonService",person.getId()+"="+ person.getName());  
       }  
}  
}  

public class ClientActivity extends Activity {  
  private IPersonService personService;  
  @Override  
  public void onCreate(Bundle savedInstanceState) {  
  super.onCreate(savedInstanceState);  
  setContentView(R.layout.main);  
  this.bindService(newIntent("cn.itcast.process.aidl.PersonService"),this.serviceConnection, BIND_AUTO_CREATE);//綁定到服務  
  }  
  @Override  
  protected voidonDestroy() {  
  super.onDestroy();  
  this.unbindService(serviceConnection);//解除服務  
  }   

  privateServiceConnection serviceConnection = new ServiceConnection() {  
  @Override  
  public void onServiceConnected(ComponentName name, IBinder service) {  
  personService =IPersonService.Stub.asInterface(service);  
  try {  
  personService.save(new Person(56,"liming"));  
  } catch(RemoteException e) {  
  Log.e("ClientActivity",e.toString());  
  }  
  }  
  @Override  
  public void onServiceDisconnected(ComponentName name) {  
  personService =null;  
  }  
  };  
}  

package cn.itcast.aidl;  
interfaceIDownloadService {  
  void download(String path);  
}  

public class ServiceBinder extends IDownloadService.Stub {  
  @Override  
  public void download(String path) throws RemoteException {  
  Log.i("DownloadService",path);  
  }   
}  

public class DownloadService extendsService {  
  private ServiceBinder serviceBinder = new ServiceBinder();  
  @Override  
  public IBinder onBind(Intent intent) {  
  return serviceBinder;  
  }  
  public class ServiceBinder extends IDownloadService.Stub {  
  @Override  
  public void download(String path) throws RemoteException {  
  Log.i("DownloadService",path);  
  }   
  }  
}  

public class ClientActivity extendsActivity {  
  private IDownloadService downloadService;  
  @Override  
  public void onCreate(Bundle savedInstanceState) {  
  super.onCreate(savedInstanceState);  
  setContentView(R.layout.main);  
  this.bindService(newIntent("cn.itcast.process.aidl.DownloadService"), this.serviceConnection,BIND_AUTO_CREATE);//綁定到服務  
  }  
  @Override  
  protected void onDestroy() {  
  super.onDestroy();  
  this.unbindService(serviceConnection);//解除服務  
  }   

  private ServiceConnection serviceConnection = new ServiceConnection() {  
  @Override  
  public void onServiceConnected(ComponentName name, IBinder service){  
  downloadService = IDownloadService.Stub.asInterface(service);  
  try {  
  downloadService.download("http://www.itcast.cn");  
  } catch (RemoteException e) {  
  Log.e("ClientActivity", e.toString());  
  }  
  }  
  @Override  
  public void onServiceDisconnected(ComponentName name) {  
  downloadService = null;  
  }  
  };  
}