AMSC
AppleMediaServiceClient
初始化
发现AMS服务

AppleMediaServiceClient
AMSC即AppleMediaServiceClient.

本文主要讲述如何基于nordic平台添加AppleMediaServeceClient服务，用来发现IOS系统的AMS服务，并用来控制音乐播放，和获取音乐播放信息。
初始化

添加AMS UUID ，AMS一共有一个服务，3个特性分别是：

service:UUID 89D3502B-0F36-433A-8EF4-C502AD55F8DC

Remote Command:UUID 9B3C81D8-57B1-4A8A-B8DF-0E56F7CA51C2 (writeable, notifiable)

Entity Update:UUID 2F7CABCE-808D-411F-9A0C-BB92BA96C102 (writeable with response, notifiable)

Entity Attribute: UUID C6B2F38C-23AB-46D8-A6AB-A3A870BBD5D7 (readable, writeable)
使用函数sd_ble_uuid_vs_add(&ble_ams_base_uuid128, &p_ams_c->service.service.uuid.type);来依次添加4个UUID并返回相应的uuid.type。
使用registered_handler_set(p_uuid, m_evt_handler);注册发现服务 89D3502B-0F36-433A-8EF4-C502AD55F8DC。
添加相应的AMS服务事件处理函数，和操作错误回调函数。

发现AMS服务

蓝牙连接IOS系统后会在服务发现回调函数里面，通知发现服务完成。可以筛选出AMS服务发现完成的事件。	  if(   (p_evt->evt_type == BLE_DB_DISCOVERY_COMPLETE)

&& (p_evt->params.discovered_db.srv_uuid.uuid == AMS_UUID_SERVICE) )

{

ble_ams_c_on_db_disc_evt(&m_ams_c, p_evt);

}

保存3个特性的handle和前两个特性的cccdhandle。

1． Ams --- ActivityManagerService.java， android系统服务,Activity管理的服务端，用于管理activity的各种行为，控制activity的生命周期，派发消息事件，低内存管理等等。实现了IBinder接口，可以用于进程间通信。

2． ApplicationThread.java, 实现了IBinder接口，activity整个框架中客户端和服务端(Ams)通信的接口。同时也是类ActivityThread的内部类。这样就有效地把Ams和ActivityThread绑在了一起。代理模式?有点像。。。

3． ActivityThread.java，如第2点所述，ApplicationThread所绑定的客户端就是ActivityThread。ActivityThread这个类在Activity客户端非常重要。

a. 它是应用程序的入口，众所周知，java程序的入口时main()方法，同样，当Ams拉起一个新的进程，同时启动一个主线程的时候，主线程就从ActivityThread.main方法开始执行，它会初始化一些对象，然后自己进入消息等待队列, 也就是Looper.loop(); 一旦进入loop()方法，线程就进入了死循环，再也不会退出；一直在等待别人给他消息，然后执行这个消息。这也是edt(事件驱动模型)的原理。

b. 它是Activity客户端的管理类，由它来决定，什么时候调用onCreate()，什么时候调用onResume()方法。当Activity发起一个请求时，比如startActivity(),或者finish()的时候，它会来处理这个请求，然后调用其它的人来具体做事。


4． Instrumentation.java, 这个类除了跟android的测试有关之外，还是activity管理中实际做事情的人。比如，startActivity(), 在某种情况下，就是调用这个类，然后调用到ams.当然有个时候是通过ApplicationThread去访问Ams的。

问题：有的同学就会想了，既然ApplicationThread可以访问Ams，那么我们应用程序是不是可以调用ApplicationThread类来访问ams，直接启动Activity呢？

答案是不可以的。因为ApplicationThread是ActivityThead的私有内部类，外界无法访问。而ActivityThread是hide的，所以，我们应用程序不能通过sdk去访问ActivityThread类。同理，拿到Ams引用的接口是ActivityManagerNative类，而这个类也是hide的。所以应用程序也不能直接操作ams.

5． Activity.java，这个类大家就再熟悉不过了，android最重要的组件之一；其实从java角度看，它一点也不特殊，它就是一个java对象，它会被创建，同时也会被垃圾回收机制销毁，只不过它受ams管理，所以它才有它的生命周期。所以显得比较重要。

6． ActivityResult.java， Activity管理服务端中，activity的记录缓存。换句话说，就是客户端启动一个activity, ams会对它进行缓存，类型就是ActivityResult。我们可能会想，为什么不直接缓存Activity类型的值，而要新定义一个ActivityResult类型呢？

因为Activity类没有实现IBinder接口，不能用于进程之间通信。而这个缓存值是Ams和客户端通信用的。所以必须实现IBinder接口。而且Activity设计的时候，也没有打算让它用于进程通信，看它的成员变量就可以知道，里面有很多的庞大对象，如list, map等等。这些对象是不适合跨进程传输的。因为java里面跨进程调用就是序列化和反序列化，那些庞大对象在序列化和反序列化的时候，会消耗大量的时间和资源。另外，根据设计法则，一个类的作用尽可能的单一，不要出现那种万能类。所以，这也是原因之一。


AMS是什么？

全名是ActivityManagerService, 顾名思义，就是Activity管理机制的服务器端。属于一个系统服务，位置systemProcess进程中。

可以从多个角度来看ams;

1. 从java的角度来看，ams就是一个java对象，实现了IBinder接口，所以它是一个用于进程间通信的接口。

这个对象初始化是在SystemServer.java的run()方法里面。

Slog.i(TAG, "Activity Manager");

context = ActivityManagerService.main(factoryTest);

这是一段很普通的java静态工厂代码，我们在这里创建我们的Ams对象。

初始化方法

public static final Context main(int factoryTest) {

AThread thr = new AThread();

thr.start(); //启动一个线程去初始化Ams对象

synchronized (thr) {

while (thr.mService == null) {

try {

thr.wait(); //等待AThread初始化Ams完成

} catch (InterruptedException e) {

}

}

}

//…

//…..

}

AThread的run()方法

public void run() {

Looper.prepare();

android.os.Process.setThreadPriority(

android.os.Process.THREAD_PRIORITY_FOREGROUND);

android.os.Process.setCanSelfBackground(false);


ActivityManagerService m = new ActivityManagerService(); //初始化Ams对象 


synchronized (this) {

mService = m;

notifyAll(); //初始化完成 ，notify main方法的wait()方法，告诉它已经完成，可以往下面走了。

}

//……

Looper.loop(); //自己进入消息循环等待状态

}

思考：

这里是另外启动了一个线程AThread去创建Ams对象，然后用wait/notify机制来实现线程之间的同步。

a. 创建一个对象完全不必要另外开启个线程来处理，直接new出来不就可以了。有画蛇添足的感觉

b. AThread在创建了Ams对象之后，进入消息循环状态而不是直接退出。但是看代码没有发现有向这个线程的handler发送消息的地方，也就是说AThread线程的状态接下来会永远阻塞。不明白这样做有什么意义。

思考结果：

它是AThread的run方法里面new ActivityManagerService()， 而ActivityManagerService里面有个变量mHandler，这样的话mHandler绑定的线程就是AThread这个线程了。通过向mHandler发消息，AThread就不停地从消息队列获取消息，处理消息。所以，上面a,b问题都已经解决。


2． AMS是一个服务

ActivityManagerService从名字就可以看出，它是一个服务，用来管理Activity,而且是一个系统服务，就像包管理服务，电池管理，震动管理服务一样。

3． Ams是一个Binder

Ams实现了IBinder接口，所以它是一个Binder，这意味着它不但可以用于进程间通信，还是一个线程。因为一个Binder就是一个线程。

这个怎么理解呢？可以这么理解，如果我们启动一个Hello World安卓应用程序，里面不另外启动其他线程，那我觉得，这个进程里面我们最起码启动了4个线程

a. Main线程， 这是程序的主线程，也是我们日常编写代码时用到最多的那个线程。比如我们重写了Activity的onCreate()方法，一般就是这个main线程来执行代码，也叫ui线程。这是因为安卓的组件(包括TextView, Button等等这些ui控件)都是非线程安全的，所以只允许main线程来操作。

b. GC线程。我们都知道，java有垃圾回收机制，每个java程序(一个java虚拟机)都有一个垃圾回收线程，专门回收不再使用的对象。

c. Binder1 就是我们的ApplicationThread，这个类实现了IBinder接口，用于进程间通信。具体来说，是我们的应用程序和Ams通信的工具。

d. Binder2 就是我们的ViewRoot.W对象，它也是实现了IBinder接口，是用于我们的应用程序和Wms通信的工具。

Ps: wms就是WindowManagerServier，和Ams差不多的概念，不过它是管理窗口的系统服务。


4． Ams是一个单独的线程

a. 首先系统服务不可能运行在systemProcess进程的主线程中。因为这么多系统服务如果都是运行在主线程中的话，肯定会发生阻塞。比如这个线程正在管理Activity，然后手机来电震动，那就没人来处理震动管理。所以一般服务都是运行在单独的线程里面(有些服务例外)

b. Ams实现了IBinder接口，所以它就是一个单独的线程了，就是这个线程来处理Ams对Activity的管理。

疑问: 如果Ams只有一个线程来执行Activity管理的话，会不会发生阻塞。比如两个客户端同时发起请求。

我自己的看法是应该不会。因为手机操作系统是单界面的操作系统，就是说，在同一个时刻，只有一个Activity能展示在用户面前(TabActivity看起来同时展示了多个Activity，但安卓做了特殊的处理，暂不讨论)，不像windows是多任务多窗口的操作系统。单窗口的话，那么发送的onPause(),onResume()之类的请求时，在同一时刻，应该只有一个人发起。


Ams管理Activity流程

1. 以Activity.startActivityForResult()为例说明,一般我们见的最多的是调用Activity.startActivity()方法。不过startActivity()的内部实现也是调用startActivityForResult()方法，只不过requestCode=-1

。 Activity.startActivity();

这里Activity start一个Activity 是异步的。换句话说，Activity不必等待ams结果的返回，直接往下面执行。当把接下来的代码执行完毕后，它就进入消息循环等待队列，继续等待别人给他消息。否则就一直阻塞。不过ams很快就会给它发送一个暂停当前activity的消息。就是下面的调用流程。

Instrumentation. execStartActivity ();

Ams.startActivity();

ActivityStack. startActivityMayWait ();


调用ActivityThread的暂停方法时候，同时向自己发送一个暂停消息，延迟500ms执行，如果500ms之后没有remove掉这个消息，就会说暂停出现异常。

这里要说明的是，Ams发送暂停消息给ActivityThread之后，就直接往下面走了。所以这是一个异步调用，非阻塞。发送消息后，再等待ActivityThread把暂停完毕的消息返回给自己。

ActivityThread. schedulePauseActivity ();


暂停完毕调用ActivityManagerNative.getDefault().activityPaused(token, state);

告诉Ams自己已经暂停完毕.


在Ams.activityPaused()方法内会移除掉上面那个500ms的消息。然后调用新activity的onResume之类的方法。


2. startActivityForResult()方法启动一个Activity，目标Acitivty结束后，会调用到onActivityResult()方法。

这个流程也是类似的,以Activity.finish()方法是入口，ams在接到finishActivity()之后，就会辗转调用到Activity.onActivityResult()方法。


这里Activity和ActivityManagerService就是通过Binder来完成进程间通信.


四 关系图 

应用程序进程 系统进程

Activity1


Activity2 ActivityThread ApplicationThread Ams


Activity3 


本来想上传个图，但是公司上传实在不方便，只能用文字描述了。。 sorry.. 

这里的意思是ActivityThread通过AppliactionThread这个Binder来和Ams通信



这里只是初略的分析了下ams，其实它的功能还有很多，如进程方面的，task方面的管理，低内存的管理等等。

Android里面有oom模块，当系统内存不够用的时候，这个模块会发生作用。其实ams并不能直接操作oom模块，不过oom模块在杀死进程释放资源的时候有一个优先级哦oom_adj(-16~15)，值越低，说明越重要。Ams也正是通过给killer设置oom_adj这个值来管理各个应用程序的。

其实我们分析这些东西也不是为了修改ams，只是为了知其然，知其所以然。这样我们才会写出更健壮的应用程序。同时对我们的代码能力也是一种提高。

http://gityuan.com/2016/03/12/start-activity/


http://gityuan.com/2016/10/09/app-process-create-2/



http://blog.csdn.net/tfygg/article/details/52093463

前言
其实在网上已经有数不尽的Activity启动流程分析,但是我很多时候喜欢自己在去跟着源码看一遍.加上今年花了很长时间学习Binder所以在次看源码的时候发现思考的方向也有所不同.

本文讲解的源码版本为Android 5.0,不会像其他文章一样深入
本文所需的前置知识:

Binder驱动源码分析目录
AMS 和App的关系
AMS基础知识
AMS全称为ActivityManagerService,在AMS启动时会向ServiceManager注册服务,服务名为activity(binder基础知识可参考博主).既然像ServiceManager注册过服务那么开发者便可以通过名称获取,如下代码所示:
class MainActivity : Activity() {

    override fun onCreate(savedInstanceState: Bundle?) {
       	//获取ams服务  public static final String ACTIVITY_SERVICE = "activity";
        val activityService = this.getSystemService(Context.ACTIVITY_SERVICE)
    }
}

AMS并不是一个单独的进程而是一个运行在system_server进程中的一个线程.

您可用ps | grep system_server查看到这个进程,如下图:



我们当然还可以通过ps -t -p system_server进程id去查看对应的线程信息.(高版本模拟器请用ps -T system_server进程id)


你可以看到system_server这个进程里面其实包含了很多其他服务所以当你想调试AMS的java代码只需选中这个进程即可(AMS是java代码所以自然运行到虚拟机里面,而android虚拟机也实现了JDWP,所以我们调试的原理也是这个,你可以看到上面的线程信息中存在一个JDWP线程).
AMS和我们所在开发App是在不同的进程.而AMS掌控的四大组件的生命的调度与创建.如下举例一个打开一个界面:



我们知道App和AMS处于不同进程,所以之间需要通过Binder通信.

App给AMS发送信息

App可以通过ServiceManager查询到AMS,从而获取到AMS对应的接口代理类,通过这个AMS接口代理类我们可以像AMS发送各种消息.这个代理接口是IActivityManager.

AMS给App发送消息

假设用户关闭了某个App的界面,AMS有必要告诉App这个Activity应该被销毁.但是如何回调呢?App可没有像ServiceManager注册过服务.这个问题读者问了在大厂的一些同学貌似也没能回答上.	

解决方案:

让App进程创建一个IBinder的服务端,即App有一个类实现了IBinder接口,在App获取ASM代理接口类时,通过代理接口类写入这个IBinder对象即可.这样AMS便可以通过这个类跟App交互.

下面是一个小的Demo并非官方代码,不过对于理解AMS交互很有帮助
class MyApplicationThread : Binder() {
 //注意onTransact回调到binder线程池
  override fun onTransact(code: Int, data: Parcel?, reply: Parcel?, flags: Int): Boolean {
    //AMS发来一个code表示启动一个activity
    if (code == 20) {
      if (data != null) {
        //获取这个activity名字
        val activityName = data.readString()
        //启动
        launcherActivity(activityName)
        return true
      }
    }
    return super.onTransact(code, data, reply, flags)
  }
  //启动activity
  fun launcherActivity(activityName: String) {
    //略
  }

}

//通过AMS代理接口写入
class MyData() : Parcelable {

  var ipcObj: MyApplicationThread? = null;

  constructor(parcel: Parcel) : this() {
  }

  override fun writeToParcel(parcel: Parcel, flags: Int) {
    parcel.writeStrongBinder(ipcObj)
  }
}


//xxx函数在app启动时调用
fun xxx(){
    //获取AMS代理接口
    val ams:IActivityManager=//略
    //构造一个对象准备传给ams,这里我们甚至可以不通过Parcelable类传输.
    var myData=MyData();
    //赋值好用于交互的远程对象
    myData.ipcObj=//略
    //attachApplication是ams预定义的函数,用于告诉ams你的远程调用类,后面有事件我会通过他驱动
    ams.attachApplication(myData)
}


上面便是AMS怎么与App通信的伪代码,我们接下来分析下实际这块相关源码
我们知道App启动时会调用ActivityThread.main函数
class ActivityThread{
	public static void main(String[] args) {
	        //loop相关代码这里就不将可
	        Looper.prepareMainLooper();
			 ActivityThread thread = new ActivityThread();
			 //关联ams
        	 thread.attach(false);
			//启动loop循环
			Looper.loop();

	}
	//一个实现了IBinder了IBinder远程调用类
	final ApplicationThread mAppThread = new ApplicationThread();

	private void attach(boolean system) {
	 	if (!system) {
	 	    //获取ams代理接口,通过ServiceManager的名字查询到ams.
	 		final IActivityManager mgr = ActivityManagerNative.getDefault();
            try {
               //将一个Ibinder对象写入到AMS
                mgr.attachApplication(mAppThread);
            } catch (RemoteException ex) {
                // Ignore
            }
	 	}
	 }
}


tip:上面在写入一个Binder对象给AMS时,会在Binder驱动的app进程的上下文对象的binder红黑树中多挂载一个与之对应的对象.如果你有兴趣可以参考博主binder源码分析系列.

其实在腾讯开源的插件化框架shadow中你也看到类似的代码.

我们总结AMS的交互方式下:

App调用调用ASM进行交互



AMS调用App函数