Android Service

Service能以两种形式启动：startService()和bindService()。
- startService
startService()启动的服务，即使启动它的组件销毁，服务也会一直运行，通常需要service做完工作之后自己去停止。startService时，Service的onStartCommand()会被调用。实现onStartCommand()，Service才会允许start。
- bindService
bindService()启动的服务，一旦所有绑在该服务上的组件都销毁，服务会自动销毁。bindService时，Service的onBind()会被调用。实现onBind()才允许bind。

startService

创建可启动的Service可以通过继承Service类或者IntentService类实现。直接继承Service的方式就不用说了，就看看IntentService。IntentService实际上也是继承自Service，其内部通过创建一个工作线程并使用Handler依次处理任务，所以适合不需要同时处理多个请求的情况，继承该类只需要实现onHandleIntent()方法。

public abstract class IntentService extends Service {
    ...
    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    @Override
    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);
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }
    ...
}

可以看到IntentService代码非常简单，创建的HandlerThread实际上是继承自Thread，在其run方法中会创建一个Looper。

bindService

创建一个可绑定的服务实际上有三种方式。
- 直接继承Binder类
这种方式适用于相同进程绑定服务时，在onBind方法中返回Binder实例即可。
- 使用Messenger
这种方式适用于需要跨进程绑定服务且不需要处理并发时。实际上Messenger也是基于AIDL方式，但是其使用Handler来发送消息，也就是说通过消息队列的形式按顺序来处理请求，这样一来，我们在不需要关注并发的同时也失去了处理并发的能力。
- 使用AIDL
这种方式适用于需要跨进程绑定服务且需要处理并发时。使用这种方式需要自己在服务中处理好并发问题。

来简单看看Messenger源码。

public final class Messenger implements Parcelable {
    ...
    // 服务端用该构造方法自定义一个Handler，并创建Messenger实例，
    // onBind方法中返回mMessenger.getBinder()即可
    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }

    public void send(Message message) throws RemoteException {
        mTarget.send(message);
    }

    public IBinder getBinder() {
        return mTarget.asBinder();
    }

    // 客户端在用ServiceConnection的onServiceConnected中用该构造方法
    // 实例化一个Messenger，与服务器的交互就调用该实例的send方法发送消息
    // 即可
    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }
    ...
}

public class Handler {
    ...
    final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

    private final class MessengerImpl extends IMessenger.Stub {
        public void send(Message msg) {
            msg.sendingUid = Binder.getCallingUid();
            Handler.this.sendMessage(msg);
        }
    }
    ...
}

IMessenger.aidl实际上只规定了一个接口，就是send。可以看到，使用Messenger的send方法，实际上调到的就是MessengerImpl的send，其内部实现用的是Handler的sendMessage方法，通过这种方式，保证了依次处理所有请求。

这里只是分析Messenger不用处理并发，至于为什么可以跨进程，需要Binder知识，以后再谈。

具体怎么创建Service，怎么启动或绑定Service，可以看下面几篇官方文档。
Creating a Started Service
Creating a Bound Service
AIDL