编写android服务
服务（Service）是Android的四大组件之一，它利用底层Binder机制，实现了RPC机制。 一个服务即可以存在于一个独立的进程，也可以依附于已存在的某个进程中。服务可被同一进程中的Activity调用，也可以被位于不同进程中的某个Activity调用。 本文主要探讨怎样编写一个远程服务接口的过程。为演示作用，本文不介绍通过AIDL语言自动生成服务接口代码的过程。
首先，我们定义接口：
public interface IRemoteService extends IInterface {
/**
* serviceMethod
*/
public void serviceMethod(int arg0, float arg1, long arg2, boolean arg3, double arg4, String arg5) throws RemoteException;
}
需要说明的是，由于受Binder机制的约束，除基本数据类型外，对于自定义的数据类型，必须实现Parceable接口，才能作为服务方法的参数。本文将不考虑自定义类型作为参数传递的情况。
接下来的重点就是实现上述定义的服务接口，这里，为了支持同一进程和不同进程的Activity都能够调用该服务接口，我们需要两个接口实现，一个是本地实现，一个是远程实现。在介绍这两个实现代码之前，我们先看下对应的RemoteService类的实现：
public RemoteService extends Service {
@Override
public void onCreate() {
}
@Override
public void onDestroy() {
}
@Override
public IBinder onBind(Intent intent) {
// Select the interface to return. If your service only implements
// a single interface, you can just return it here without checking
// the Intent.
if (IRemoteService.class.getName().equals(intent.getAction())) {
return mBinder;
}
return null;
}
/**
* The IRemoteInterface is defined through IDL
*/
private final RemoteServiceStub mBinder = new RemoteServiceStub() {
public void serviceMethod(int arg0, float arg1, long arg2, boolean arg3, double arg4, String arg5)
{
//do something here
}
};
}
在Android App开发中，定义自己的服务需要从Service类中派生，启动一个Service可以通过startService，也可以通过bindService， 对于通过bindService调用一个服务接口的方式，同时需要实现onBind()方法，它返回的IBinder对应就是我们下面将要介绍的服务实现类。
首先是本地接口实现类，代码如下：
/** Local-side IPC implementation stub class. */
public abstract class RemoteServiceStub extends Binder implements IRemoteService {
private static final String DESCRIPTOR = "com.fyj.test.IRemoteService";
/** Construct the stub at attach it to the interface. */
public RemoteServiceStub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an
* com.fyj.test.IRemoteService interface, generating a
* proxy if needed.
*/
public static IRemoteService asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
IInterface iin = (android.os.IInterface) obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IRemoteService))) {
return ((IRemoteService) iin);
}
return new RemoteServiceProxy(obj);
}
public IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_methodService: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
float _arg1;
_arg1 = data.readFloat();
long _arg2;
_arg2 = (0!=data.readLong());
boolean _arg3;
_arg3 = data.readInt()?true:false;
double _arg4;
_arg4 = data.readDouble();
String _arg5;
_arg5 = data.readString();
this.serviceMethod(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
public void serviceMethod(int arg0, float arg1, long arg2, boolean arg3, double arg4, String arg5) throws RemoteException;
static final int TRANSACTION_methodService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
它实现为一个抽象类，将接口的具体实现延迟到RemoteService中去实现。在本类 中，主要实现了onTransact()方法，它将处理客户的调用请求。asInterface()接口将自动判断当前是本地调用还是远程调用，如果是远程调用，将使用 RemoteServiceProxy类的实例的接口调用服务，它的实现代码如下：
/** Local-side IPC implementation stub class. */
public class RemoteServiceProxy implements IRemoteService {
private static final String DESCRIPTOR = "com.fyj.test.IRemoteService";
private IBinder mRemote;
RemoteServiceProxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
public void serviceMethod(int arg0, float arg1, long arg2, boolean arg3, double arg4, String arg5) throws RemoteException
{
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(anInt);
_data.writeFloat(aFloat);
_data.writeLong(aLong);
_data.writeInt(((aBoolean)?(1):(0)));
_data.writeDouble(aDouble);
_data.writeString(aString);
mRemote.transact(TRANSACTION_methodService, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
static final int TRANSACTION_methodService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
该类是代理类，对服务的调用者是透明的。
在调用bindService的过程中，需要传递一个ServiceConnection对象，该对象将在服务连接成功后，会接收到服务类的对象，以此可以判断当前应该使用本地服务类实现，还是远程服务类实现，关于具体的实现细节，将另外专题分析。 下面给出ServiceConnection对象实现创建的代码：
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
// TODO Auto-generated method stub
mService = RemoteServiceStub.asInterface(service);
...
}
public void onServiceDisconnected(ComponentName className) {
// TODO Auto-generated method stub
mService = null;
...
}
};