1.Client >AMS

APP 向 ActivityManagerService（简称AMS）发起进程间通信，是通过IActivityManager接口。

//Instrumentation
public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
 ......   
       //发起通信
       int result = ActivityManager.getService()
            .startActivity(whoThread, who.getBasePackageName(), intent,
                   intent.resolveTypeIfNeeded(who.getContentResolver()),
                   token, target != null ? target.mEmbeddedID : null,
                   requestCode, 0, null, options);
 ......
        return null;
    }

//ActivityManager
public static IActivityManager getService() {
     return IActivityManagerSingleton.get();
}
 
private static final Singleton<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @Override
             protected IActivityManager create() {
                  //得到代表AMS的IBinder接口
                  final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                  //转成IActivityManager的接口
                  final IActivityManager am = IActivityManager.Stub.asInterface(b);
                  return am;
             }
};

//ServiceManager
//缓存系统服务
private static HashMap<String, IBinder> sCache = new HashMap<String, IBinder>();
public static IBinder getService(String name) {
       try {
           IBinder service = sCache.get(name);
           if (service != null) {
              return service;
            } else {
               return Binder.allowBlocking(rawGetService(name));
            }
        } catch (RemoteException e) {
            Log.e(TAG, "error in getService", e);
        }
        return null;
}

最后由ActivityManagerService 处理相关操作

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {......}

通过ServiceManager类的getService()函数，得到代表AMS的IBinder接口，也可传入其它服务名称，取得对应系统服务（具体看Context）

2.AMS > Activity

    //mService为ActivityManagerService   thread为本次ActivityThread
    mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken,
                        PauseActivityItem.obtain(prev.finishing, userLeaving,
                                prev.configChangeFlags, pauseImmediately));
                                
                                
    //ClientLifecycleManager
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        transaction.schedule();
......
    }

    //ClientTransaction
    public void schedule() throws RemoteException {
        mClient.scheduleTransaction(this);
    }

ActivityThread的内部类ApplicationThread派生这个接口类并实现了对应的方法。所以直接跳转到ApplicationThread中的scheduleTransaction方法，通过Binder服务回到ActivityThread

//ActivityThread
private class ApplicationThread extends IApplicationThread.Stub {
......
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            //回到ActivityThread
            ActivityThread.this.scheduleTransaction(transaction);
        }
}

//ClientTransactionHandler  ActivityThread继承自ClientTransactionHandler
void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        //通过消息循环执行相关方法
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}