1.概述
对于耳麦的插拔，Android有两种模式，可以使用input子系统，也可以使用state dev(uevent)上报拔插操作。说明如下：
-
输入子系统：可以上报按键事件也可以上报开关事件(EV_SW)，事件类型包括headset、headPhone、lineOut。对于输入设备都需要指定能产生同步类事件EV_SYN。对于按键事件，输入子系统还需要设置按键值的范围，但是对于开关类事件不需要设置。
-
switch class子系统：通过uevent向用户空间发送数据，Android中有个线程专门监听这类事件。使用switch dev子系统时，名字必须要设置为"h2w"，Android系统监听/sys/class/switch/h2w这个虚拟设备。
具体使用哪种操作取决于config_useDevInputEventForAudioJack 这个配置值，定义在config.xml文件中，如下：
...
<!-- When true use the linux /dev/input/event subsystem to detect the switch changes
on the headphone/microphone jack. When false use the older uevent framework. -->
<bool name="config_useDevInputEventForAudioJack">false</bool>
...
该值为true时使用input子系统，为false时使用uevent机制。该值在下述文件中定义，后一个文件会覆盖前一个文件：
frameworks/base/core/res/res/values/config.xml
device/"平台厂商"/frameworks/base/core/res/res/values/config.xml
接下来我们对两种模式进行分析，两种模式前半段不一致，后半段处理是一致的。主要就是分析这样一个流程：底层的耳麦插拔是如何把事件一层层上报，最终通过ActivityManagerService将消息广播出去的过程。
2.前半段分析
两种模式到WiredAccessoryManager中updateLocked方法。
2.1 使用input子系统的流程
从input子系统到WiredAccessoryManager中updateLocked方法。input子系统通过InputReader开始读取事件并处理。代码如下：
// InputReader.cpp
void InputReader::loopOnce() {
//...
//获取事件
size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
{ // acquire lock
//...
//处理事件
processEventsLocked(mEventBuffer, count);
//...
} // release lock
// Send out a message that the describes the changed input devices.
if (inputDevicesChanged) {
mPolicy->notifyInputDevicesChanged(inputDevices);
}
mQueuedListener->flush();
}
InputReader线程通过EventHub中的getEvent方法从驱动中获取事件后使用processEventsLocked开始处理，processEventsLocked实现如下：
// InputReader.cpp
void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
for (const RawEvent* rawEvent = rawEvents; count;) {
int32_t type = rawEvent->type;
size_t batchSize = 1;
if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
//...
processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
} else {
//...
}
count -= batchSize;
rawEvent += batchSize;
}
}
这里继续分析processEventsForDeviceLocked的实现，代码如下：
// InputReader.cpp
void InputReader::processEventsForDeviceLocked(int32_t deviceId,
const RawEvent* rawEvents, size_t count) {
//...
InputDevice* device = mDevices.valueAt(deviceIndex);
//...
device->process(rawEvents, count);
}
继续分析InputDevice的process方法，代码如下：
// InputReader.cpp
void InputDevice::process(const RawEvent* rawEvents, size_t count) {
size_t numMappers = mMappers.size();
for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {
if (mDropUntilNextSync) {
//...
} else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
//...
} else {
for (size_t i = 0; i < numMappers; i++) {
InputMapper* mapper = mMappers[i];
mapper->process(rawEvent);
}
}
}
}
对于swicth事件来说，这里的map是SwitchInputMapper，它的process函数实现如下：
// InputReader.cpp
void SwitchInputMapper::process(const RawEvent* rawEvent) {
switch (rawEvent->type) {startOtherServices
case EV_SW:
processSwitch(rawEvent->code, rawEvent->value);
break;
case EV_SYN:
if (rawEvent->code == SYN_REPORT) {
sync(rawEvent->when);
}
}
}
继续分析processSwitch，代码如下：
// InputReader.cpp
void SwitchInputMapper::processSwitch(int32_t switchCode, int32_t switchValue) {
if (switchCode >= 0 && switchCode < 32) {
if (switchValue) {
mSwitchValues |= 1 << switchCode;
} else {
mSwitchValues &= ~(1 << switchCode);
}
mUpdatedSwitchMask |= 1 << switchCode;
}
}
这里主要是通过mSwitchValues的值进行状态存储，我们继续分析sync的实现，代码如下：
// InputReader.cpp
void SwitchInputMapper::sync(nsecs_t when) {
if (mUpdatedSwitchMask) {
uint32_t updatedSwitchValues = mSwitchValues & mUpdatedSwitchMask;
NotifySwitchArgs args(when, 0, updatedSwitchValues, mUpdatedSwitchMask);
getListener()->notifySwitch(&args);
mUpdatedSwitchMask = 0;
}
}
这里的getListener()->notifySwitch(&args)实际上就是InputDispatcher的notifySwitch方法，代码实现如下：
// InputDispatcher.cpp
void InputDispatcher::notifySwitch(const NotifySwitchArgs* args) {
uint32_t policyFlags = args->policyFlags;
policyFlags |= POLICY_FLAG_TRUSTED;
mPolicy->notifySwitch(args->eventTime,
args->switchValues, args->switchMask, policyFlags);
}
这里的mPolicy->notifySwitch 经过JNI的回调最终会调用到Java层的InputManagerService中的notifySwitch方法，代码如下：
// InputManagerService.java
// Native callback.
private void notifySwitch(long whenNanos, int switchValues, int switchMask) {
if ((switchMask & SW_LID_BIT) != 0) {
final boolean lidOpen = ((switchValues & SW_LID_BIT) == 0);
mWindowManagerCallbacks.notifyLidSwitchChanged(whenNanos, lidOpen);
}
if ((switchMask & SW_CAMERA_LENS_COVER_BIT) != 0) {
final boolean lensCovered = ((switchValues & SW_CAMERA_LENS_COVER_BIT) != 0);
mWindowManagerCallbacks.notifyCameraLensCoverSwitchChanged(whenNanos, lensCovered);
}
//mUseDevInputEventForAudioJack在这里被配置成true，会走该分支
if (mUseDevInputEventForAudioJack && (switchMask & SW_JACK_BITS) != 0) {
mWiredAccessoryCallbacks.notifyWiredAccessoryChanged(whenNanos, switchValues,
switchMask);
}
}
这里继续分析notifyWiredAccessoryChanged，代码实现如下：
// WiredAccessoryManager.java
@Override
public void notifyWiredAccessoryChanged(long whenNanos, int switchValues, int switchMask) {
synchronized (mLock) {
int headset;
mSwitchValues = (mSwitchValues & ~switchMask) | switchValues;
switch (mSwitchValues &
(SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_LINEOUT_INSERT_BIT)) {
case 0:
headset = 0;
break;
case SW_HEADPHONE_INSERT_BIT:
headset = BIT_HEADSET_NO_MIC;
break;
case SW_LINEOUT_INSERT_BIT:
headset = BIT_LINEOUT;
break;
case SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT:
headset = BIT_HEADSET;
break;
case SW_MICROPHONE_INSERT_BIT:
headset = BIT_HEADSET;
break;
default:
headset = 0;
break;
}
updateLocked(NAME_H2W,
(mHeadsetState & ~(BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_LINEOUT)) | headset);
}
}
这里调用到了updateLocked方法了。接下来的分析我们在后半段分析时继续。
2.2 使用uevent机制的流程
从uevent到WiredAccessoryManager中updateLocked方法。在systemserver中的startOtherServices中关于WiredAccessoryManager的创建和使用如下：
// SystemServer.java
private void startOtherServices() {
final Context context = mSystemContext;
//...
if (!disableMedia) {
try {
//关键点1
inputManager.setWiredAccessoryCallbacks(
new WiredAccessoryManager(context, inputManager));
} catch (Throwable e) {
reportWtf("starting WiredAccessoryManager", e);
}
}
//...
final InputManagerService inputManagerF = inputManager;
//...
try {
//关键点2
if (inputManagerF != null) inputManagerF.systemRunning();
} catch (Throwable e) {
reportWtf("Notifying InputManagerService running", e);
}
//...
}
2.2.1 WiredAccessoryManager创建
WiredAccessoryManager的构造器代码实现如下：
// WiredAccessoryManager.java
public WiredAccessoryManager(Context context, InputManagerService inputManager) {
//这里涉及三个服务：电源子系统、输入输出子系统、音频子系统
PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "WiredAccessoryManager");
mWakeLock.setReferenceCounted(false);
mAudioManager = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
mInputManager = inputManager;
mUseDevInputEventForAudioJack =
context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
mObserver = new WiredAccessoryObserver();
}
这里的WiredAccessoryObserver是继承UEventObserver类的，UEventObserver实现为空，WiredAccessoryObserver的构造器代码如下：
// WiredAccessoryManager.java#WiredAccessoryObserver.class
public WiredAccessoryObserver() {
mUEventInfo = makeObservedUEventList();
}
这里makeObservedUEventList的代码实现如下：
// WiredAccessoryManager.java#WiredAccessoryObserver.class
private List<UEventInfo> makeObservedUEventList() {
List<UEventInfo> retVal = new ArrayList<UEventInfo>();
UEventInfo uei;
//这里只监听这三个UEventInfo对应的事件，驱动程序通过uevent上报事件也只能上报这三个事件之一
// Monitor h2w
if (!mUseDevInputEventForAudioJack) {
//用于监听名为"h2w"这个Switch class驱动中创建的虚拟文件
//./devices/virtual/switch/h2w
//./class/switch/h2w
uei = new UEventInfo(NAME_H2W, BIT_HEADSET, BIT_HEADSET_NO_MIC, BIT_LINEOUT);
if (uei.checkSwitchExists()) {
retVal.add(uei);
}
}
// Monitor USB
uei = new UEventInfo(NAME_USB_AUDIO, BIT_USB_HEADSET_ANLG, BIT_USB_HEADSET_DGTL, 0);
if (uei.checkSwitchExists()) {
retVal.add(uei);
}
// Monitor hdmi_audio
uei = new UEventInfo(NAME_HDMI_AUDIO, BIT_HDMI_AUDIO, 0, 0);
if (uei.checkSwitchExists()) {
retVal.add(uei);
} else {
uei = new UEventInfo(NAME_HDMI, BIT_HDMI_AUDIO, 0, 0);
if (uei.checkSwitchExists()) {
retVal.add(uei);
}
}
return retVal;
}
2.2.2 inputManagerF的systemRunning()函数分析
inputManagerF.systemRunning()代码实现如下：
// InputManagerService.java
public void systemRunning() {
//...
if (mWiredAccessoryCallbacks != null) {
mWiredAccessoryCallbacks.systemReady();
}
}
这里systemReady代码实现如下：
// WiredAccessoryManager.java
@Override
public void systemReady() {
synchronized (mLock) {
mWakeLock.acquire();
Message msg = mHandler.obtainMessage(MSG_SYSTEM_READY, 0, 0, null);
mHandler.sendMessage(msg);
}
}
处理MSG_SYSTEM_READY消息的handler代码如下：
// WiredAccessoryManager.java
private final Handler mHandler = new Handler(Looper.myLooper(), null, true) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_NEW_DEVICE_STATE:
setDevicesState(msg.arg1, msg.arg2, (String)msg.obj);
mWakeLock.release();
break;
case MSG_SYSTEM_READY:
onSystemReady();
mWakeLock.release();
break;
}
}
};
这里会调用到onSystemReady，代码实现如下：
// WiredAccessoryManager.java
private void onSystemReady() {
if (mUseDevInputEventForAudioJack) {
int switchValues = 0;
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_HEADPHONE_INSERT) == 1) {
switchValues |= SW_HEADPHONE_INSERT_BIT;
}
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_MICROPHONE_INSERT) == 1) {
switchValues |= SW_MICROPHONE_INSERT_BIT;
}
if (mInputManager.getSwitchState(-1, InputDevice.SOURCE_ANY, SW_LINEOUT_INSERT) == 1) {
switchValues |= SW_LINEOUT_INSERT_BIT;
}
notifyWiredAccessoryChanged(0, switchValues,
SW_HEADPHONE_INSERT_BIT | SW_MICROPHONE_INSERT_BIT | SW_LINEOUT_INSERT_BIT);
}
mObserver.init();
}
继续分析mObserver的init()方法，代码实现如下：
// WiredAccessoryManager.java#WiredAccessoryObserver.class
void init() {
//...
for (int i = 0; i < mUEventInfo.size(); ++i) {
UEventInfo uei = mUEventInfo.get(i);
startObserving("DEVPATH="+uei.getDevPath());
}
}
这里继续分析startObserving，代码实现如下：
// UEventObserver.java
public final void startObserving(String match) {
final UEventThread t = getThread();
t.addObserver(match, this);
}
继续看getThread的实现，代码如下：
// UEventObserver.java
private static UEventThread getThread() {
synchronized (UEventObserver.class) {
if (sThread == null) {
sThread = new UEventThread();
sThread.start();
}
return sThread;
}
}
这里执行start时，会调用到UEventThread的run方法，代码实现如下：
// UEventObserver.java
public void run() {
nativeSetup();
while (true) {
//...
//等待事件，native层实现，从系统底层接收消息
String message = nativeWaitForNextEvent();
if (message != null) {
//发送消息
sendEvent(message);
}
}
}
发送消息实现如下：
// UEventObserver.java
private void sendEvent(String message) {
//...
if (!mTempObserversToSignal.isEmpty()) {
final UEvent event = new UEvent(message);
final int N = mTempObserversToSignal.size();
for (int i = 0; i < N; i++) {
final UEventObserver observer = mTempObserversToSignal.get(i);
observer.onUEvent(event);
}
mTempObserversToSignal.clear();
}
}
继续分析observer的onUEvent(...)方法的实现为空，这里会调用到子类WiredAccessoryObserver的实现，代码如下：
// WiredAccessoryManager.java#WiredAccessoryObserver.class
@Override
public void onUEvent(UEventObserver.UEvent event) {
try {
String devPath = event.get("DEVPATH");
String name = event.get("SWITCH_NAME");
int state = Integer.parseInt(event.get("SWITCH_STATE"));
synchronized (mLock) {
updateStateLocked(devPath, name, state);
}
} catch (NumberFormatException e) {
Slog.e(TAG, "Could not parse switch state from event " + event);
}
}
继续分析updateStateLocked，代码实现如下：
// WiredAccessoryManager.java#WiredAccessoryObserver.class
private void updateStateLocked(String devPath, String name, int state) {
for (int i = 0; i < mUEventInfo.size(); ++i) {
UEventInfo uei = mUEventInfo.get(i);
if (devPath.equals(uei.getDevPath())) {
updateLocked(name, uei.computeNewHeadsetState(mHeadsetState, state));
return;
}
}
}
这里调用到了updateLocked方法了。接下来的分析我们在后半段分析时继续。
3.后半段分析
从WiredAccessoryManager中updateLocked方法到上层ActivityManagerService发送广播。WiredAccessoryManager的updateLocked代码实现如下：
// WiredAccessoryManager.java
private void updateLocked(String newName, int newState) {
//...
mWakeLock.acquire();
//获得并发送message
Message msg = mHandler.obtainMessage(MSG_NEW_DEVICE_STATE, headsetState,
mHeadsetState, newName);
mHandler.sendMessage(msg);
mHeadsetState = headsetState;
}
这里的handler对于消息MSG_NEW_DEVICE_STATE的处理如下：
// WiredAccessoryManager.java
private final Handler mHandler = new Handler(Looper.myLooper(), null, true) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_NEW_DEVICE_STATE:
setDevicesState(msg.arg1, msg.arg2, (String)msg.obj);
mWakeLock.release();
break;
case MSG_SYSTEM_READY:
onSystemReady();
mWakeLock.release();
break;
}
}
};
这里关注setDevicesState的实现，代码如下：
// WiredAccessoryManager.java
private void setDevicesState(
int headsetState, int prevHeadsetState, String headsetName) {
synchronized (mLock) {
int allHeadsets = SUPPORTED_HEADSETS;
for (int curHeadset = 1; allHeadsets != 0; curHeadset <<= 1) {
if ((curHeadset & allHeadsets) != 0) {
setDeviceStateLocked(curHeadset, headsetState, prevHeadsetState, headsetName);
allHeadsets &= ~curHeadset;
}
}
}
}
这里关注setDeviceStateLocked的实现，代码如下：
private void setDeviceStateLocked(int headset,
int headsetState, int prevHeadsetState, String headsetName) {
if ((headsetState & headset) != (prevHeadsetState & headset)) {
int outDevice = 0;
int inDevice = 0;
int state;
if ((headsetState & headset) != 0) {
state = 1;
} else {
state = 0;
}
if (headset == BIT_HEADSET) {
outDevice = AudioManager.DEVICE_OUT_WIRED_HEADSET;
inDevice = AudioManager.DEVICE_IN_WIRED_HEADSET;
} else if (headset == BIT_HEADSET_NO_MIC){
outDevice = AudioManager.DEVICE_OUT_WIRED_HEADPHONE;
} else if (headset == BIT_LINEOUT){
outDevice = AudioManager.DEVICE_OUT_LINE;
} else if (headset == BIT_USB_HEADSET_ANLG) {
outDevice = AudioManager.DEVICE_OUT_ANLG_DOCK_HEADSET;
} else if (headset == BIT_USB_HEADSET_DGTL) {
outDevice = AudioManager.DEVICE_OUT_DGTL_DOCK_HEADSET;
} else if (headset == BIT_HDMI_AUDIO) {
outDevice = AudioManager.DEVICE_OUT_HDMI;
} else {
Slog.e(TAG, "setDeviceState() invalid headset type: "+headset);
return;
}
if (outDevice != 0) {
//进入了Audio系统，设置有线设备的连接状态
mAudioManager.setWiredDeviceConnectionState(outDevice, state, headsetName);
}
if (inDevice != 0) {
mAudioManager.setWiredDeviceConnectionState(inDevice, state, headsetName);
}
}
}
这里关注mAudioManager的setWiredDeviceConnectionState方法实现，代码如下：
// AudioManager.java
public void setWiredDeviceConnectionState(int device, int state, String name) {
IAudioService service = getService();
try {
service.setWiredDeviceConnectionState(device, state, name);
} catch (RemoteException e) {
Log.e(TAG, "Dead object in setWiredDeviceConnectionState "+e);
}
}
继续分析setWiredDeviceConnectionState，代码实现如下：
// AudioService.java
public void setWiredDeviceConnectionState(int device, int state, String name) {
synchronized (mConnectedDevices) {
int delay = checkSendBecomingNoisyIntent(device, state);
queueMsgUnderWakeLock(mAudioHandler,
MSG_SET_WIRED_DEVICE_CONNECTION_STATE,device,state,name,delay);
}
}
这里的queueMsgUnderWakeLock代码实现如下：
// AudioService.java
private void queueMsgUnderWakeLock(Handler handler, int msg,
int arg1, int arg2, Object obj, int delay) {
final long ident = Binder.clearCallingIdentity();
mAudioEventWakeLock.acquire();
Binder.restoreCallingIdentity(ident);
sendMsg(handler, msg, SENDMSG_QUEUE, arg1, arg2, obj, delay);
}
handler对于MSG_SET_WIRED_DEVICE_CONNECTION_STATE消息进行处理，代码如下：
// AudioService.java
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_SET_DEVICE_VOLUME:
setDeviceVolume((VolumeStreamState) msg.obj, msg.arg1);
break;
//...
case MSG_SET_WIRED_DEVICE_CONNECTION_STATE:
onSetWiredDeviceConnectionState(msg.arg1, msg.arg2, (String)msg.obj);
mAudioEventWakeLock.release();
break;
//...
}
}
onSetWiredDeviceConnectionState的代码实现如下：
// AudioService.java
private void onSetWiredDeviceConnectionState(int device, int state, String name)
{
synchronized (mConnectedDevices) {
//...
//关键点1:声道切换入口
handleDeviceConnection((state == 1), device, (isUsb ? name : ""));
if (state != 0) {
//...
if ((device & mSafeMediaVolumeDevices) != 0) {
sendMsg(mAudioHandler,MSG_CHECK_MUSIC_ACTIVE,SENDMSG_REPLACE,0,0,null,MUSIC_ACTIVE_POLL_PERIOD_MS);
}
//...
} else {
//...
}
if (!isUsb && (device != AudioSystem.DEVICE_IN_WIRED_HEADSET)) {
//关键点2:通过AMS上报intent
sendDeviceConnectionIntent(device, state, name);
}
}
}
从这里开始我们有两个关键点需要关注，声道切换入口handleDeviceConnection和给AMS上报intent的sendDeviceConnectionIntent。
3.1 handleDeviceConnection()
继续分析handleDeviceConnection，代码实现如下：
// AudioService.java
private boolean handleDeviceConnection(boolean connected, int device, String params) {
synchronized (mConnectedDevices) {
boolean isConnected = (mConnectedDevices.containsKey(device) &&
(params.isEmpty() || mConnectedDevices.get(device).equals(params)));
// 拔掉时去断开连接
if (isConnected && !connected) {
AudioSystem.setDeviceConnectionState(device,
AudioSystem.DEVICE_STATE_UNAVAILABLE,
mConnectedDevices.get(device));
mConnectedDevices.remove(device);
return true;
// 插入时去连接
} else if (!isConnected && connected) {
AudioSystem.setDeviceConnectionState(device,
AudioSystem.DEVICE_STATE_AVAILABLE,
params);
mConnectedDevices.put(new Integer(device), params);
return true;
}
}
return false;
}
这里会调用AudioSystem的setDeviceConnectionState方法，它的JNI映射关系为：
{"setDeviceConnectionState", "(IILjava/lang/String;)I", (void *)android_media_AudioSystem_setDeviceConnectionState}
继续分析android_media_AudioSystem_setDeviceConnectionState的实现，代码如下：
// android_media_AudioSystem.cpp
static jint
android_media_AudioSystem_setDeviceConnectionState(JNIEnv *env, jobject thiz, jint device, jint state, jstring device_address)
{
const char *c_address = env->GetStringUTFChars(device_address, NULL);
int status = check_AudioSystem_Command(AudioSystem::setDeviceConnectionState(static_cast <audio_devices_t>(device),
static_cast <audio_policy_dev_state_t>(state),
c_address));
env->ReleaseStringUTFChars(device_address, c_address);
return (jint) status;
}
这里专注分析Native层AudioSystem的setDeviceConnectionState，代码实现如下：
// AudioSystem.cpp
status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,
audio_policy_dev_state_t state,
const char *device_address)
{
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
const char *address = "";
//...
if (device_address != NULL) {
address = device_address;
}
return aps->setDeviceConnectionState(device, state, address);
}
这里返回的是AudioPolicyManager的setDeviceConnectionState方法，代码实现如下：
// AudioPolicyManager.cpp
status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
audio_policy_dev_state_t state,
const char *device_address)
{
return setDeviceConnectionStateInt(device, state, device_address);
}
在这里我们只需要知道从Java层AudioService的handleDeviceConnection方法最终可以直接调用到Native层AudioPolicyManager的setDeviceConnectionStateInt，后面我们会专门对setDeviceConnectionStateInt部分代码进行详细的解读。
3.2 sendDeviceConnectionIntent()
继续分析sendDeviceConnectionIntent，代码实现如下：
// AudioService.java
private void sendDeviceConnectionIntent(int device, int state, String name)
{
//构建一个Intent结构，然后向应用程序广播它，注册对这个Intent感兴趣的App就会收到它
Intent intent = new Intent();
intent.putExtra("state", state);
intent.putExtra("name", name);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
//...
//intent其他处理
//...
try {
// 发送广播
ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.USER_ALL);
} finally {
//...
}
}
到这里，通过构建一个Intent结构，然后向应用程序广播它，接下来注册对这个Intent感兴趣的App就会收到它，控制权交给APP。后面会以案例形式接收并处理该intent。
