Android音频(7)——项目实战——耳麦插拔

a. 确定在状态栏上图标的位置 
   修改 frameworks/base/core/res/res/values/config.xml 
   添加一行：<item><xliff:g id="id">headset</xliff:g></item> 
 
b. 创建图标文件 
   从①中下载对应图片保存在如下位置 
   frameworks/base/packages/SystemUI/res/drawable-hdpi/stat_sys_headset_with_mic.png 
   frameworks/base/packages/SystemUI/res/drawable-hdpi/stat_sys_headset_without_mic.png 
 
c. 修改源码, 当接收到消息时显示/清除图标 :  
   frameworks/base/packages/SystemUI/src/com/android/systemui/statusbar/phone/PhoneStatusBarPolicy.java 
   参考①中的修改。 
    
d. 编译源文件 
d.1 mmm frameworks/base/core/res    // 编译config.xml 
    得到  out/target/product/tiny4412/system/framework/framework-res.apk 
d.2 mmm frameworks/base/packages/SystemUI   // 编译图标文件, 编译源码 
    得到 out/target/product/tiny4412/system/priv-app/SystemUI/SystemUI.apk 
 
e. 替换单板上的文件 
   adb push到 /system/framework/framework-res.apk 
   adb push到 /system/priv-app/SystemUI/SystemUI.apk  
 
f. 测试 
   使用5.1所编译得到的zImage启动开发板, 
   执行以下命令: 
     触发上报headset插入:   echo 4 1 > /sys/class/input/input0/test_input  #4=SW_MICROPHONE_INSERT，1=PlugIn 
     触发上报headset取下:   echo 4 0 > /sys/class/input/input0/test_input   
     触发上报headphone插入: echo 2 1 > /sys/class/input/input0/test_input  #2=SW_HEADPHONE_INSERT，1=PlugIn 
     触发上报headphone取下: echo 2 0 > /sys/class/input/input0/test_input   
     触发上报lineout插入:   echo 6 1 > /sys/class/input/input0/test_input  #6=SW_LINEOUT_INSERT，1=PlugIn 
     触发上报lineout取下:   echo 6 0 > /sys/class/input/input0/test_input   
 
测试结果：input的测试成功。但是uevent的失败，原因见下文

mUseDevInputEventForAudioJack的赋值： 
InputManagerService(Context context) //InputManagerService.java 
    mUseDevInputEventForAudioJack = context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);

InputReader::loopOnce() //InputReader.cpp 
    mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE); 
    processEventsLocked(mEventBuffer, count); 
        InputReader::processEventsForDeviceLocked 
            device->process(rawEvents, count); //输入子系统中为每一个/dev/input/eventX都创建一个InputDevice 
                mapper->process(rawEvent); //对于开关事件，这里的InputMapper mapper是SwitchInputMapper 
                    SwitchInputMapper::process(const RawEvent* rawEvent) 
                        case EV_SW: processSwitch(rawEvent->code, rawEvent->value); //只是简单记录下来按键值 
                        case EV_SYN: sync(rawEvent->when); //收到sync(type=EV_SYN,code=SYN_REPORT)后处理 
                            //获取监听器，调用监听器的notifySwitch，这里的监听器是InputDispatch 
                            getListener()->notifySwitch(&args); 
 
InputDispatcher::notifySwitch(const NotifySwitchArgs* args) //InputDispatcher.cpp 
    mPolicy->notifySwitch(args->eventTime, args->switchValues, args->switchMask, policyFlags); 
    //上面调用的就是com_android_server_input_InputManagerService.cpp中的下面这个函数 
    NativeInputManager::notifySwitch(nsecs_t when, uint32_t switchValues, uint32_t switchMask, uint32_t policyFlags) //com_android_server_input_InputManagerService.cpp 
        //调用java的同名函数notifySwitch，位于InputManagerService.java中 
        env->CallVoidMethod(mServiceObj, gServiceClassInfo.notifySwitch, when, switchValues, switchMask); 
            notifySwitch(long whenNanos, int switchValues, int switchMask) //InputManagerService.java 
                //调用到mWiredAccessoryCallbacks中的notifyWiredAccessoryChanged 
                if (mUseDevInputEventForAudioJack) //这个就是来自上面的config.xml文件配置，为true才会选择输入子系统 
                    mWiredAccessoryCallbacks.notifyWiredAccessoryChanged(whenNanos, switchValues, switchMask); 
 
mWiredAccessoryCallbacks是何时注册的： 
startOtherServices() //SystemServer.java 
    //WiredAccessoryManager作为一个callback传给了inputManager 
    inputManager.setWiredAccessoryCallbacks(new WiredAccessoryManager(context, inputManager)); 
        mWiredAccessoryCallbacks = callbacks; 
 
因此上面调用的就是 
WiredAccessoryManager.notifyWiredAccessoryChanged 
mSwitchValues = (mSwitchValues & ~switchMask) | switchValues; 
    //根据上报的值确定变量headset的取值，显示那个图标由变量headset决定的 
    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; 
    } 
    //WiredAccessoryManager的函数，这个函数将会进入Audio系统，uevent分支最终也是调用这个函数。 
    updateLocked(NAME_H2W, (mHeadsetState & ~(BIT_HEADSET | BIT_HEADSET_NO_MIC | BIT_LINEOUT)) | headset);

(1)初始化： 
WiredAccessoryManager //WiredAccessoryManager.java 
    //创建一个观察者 
    mObserver = new WiredAccessoryObserver(); 
        //WiredAccessoryObserver构造函数调用 
        WiredAccessoryObserver()  
            //创建一个观察者事件的列表 
            mUEventInfo = makeObservedUEventList(); 
                //当上面的config.xml中配置这个变量为false时就使用uevent机制 
                if (!mUseDevInputEventForAudioJack) { 
                    //用于监听名为"h2w"这个Switch class驱动中创建的虚拟文件 
                    //shell@tiny4412:/sys # find ./ -name h2w                                         
                    //./devices/virtual/switch/h2w 
                    //./class/switch/h2w 
                    //这里只监听这三个事件，所以驱动程序通过uevent上报事件也只能上报这三个事件之一 
                    uei = new UEventInfo("h2w", BIT_HEADSET, BIT_HEADSET_NO_MIC, BIT_LINEOUT); 
         
         
init() //WiredAccessoryManager.java 
    startObserving("DEVPATH="+uei.getDevPath());     
        //往UEventThread里面添加观察者 
        UEventThread t = getThread(); 
        //这里的this就是子类WiredAccessoryObserver 
        t.addObserver(match, this);    //① 
 
 
(2)从native代码中获取uevent事件 
run() 
    //本地初始化 
    nativeSetup(); 
        uevent_init() //android_os_UEventObserver.cpp 
            s = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT); //hardware/uevent.c 
            setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)); 
            bind(s, (struct sockaddr *) &addr, sizeof(addr)) 
    //等待下一个事件 
    nativeWaitForNextEvent(); //UEventObserver.java 
        uevent_next_event(char* buffer, int buffer_length) //hardware/uevent.c 
            poll(&fds, 1, -1); 
            recv(fd, buffer, buffer_length, 0); 
    //读取到数据后发送 
    sendEvent(message); 
        observer.onUEvent(event); 
            //取出上面①中设置的观察者 
            UEventObserver observer = mTempObserversToSignal.get(i); 
            observer.onUEvent(UEventObserver.UEvent event) //WiredAccessoryManager.java 
                String devPath = event.get("DEVPATH"); 
                String name = event.get("SWITCH_NAME"); 
                int state = Integer.parseInt(event.get("SWITCH_STATE")); 
                updateStateLocked(devPath, name, state); 
                    //WiredAccessoryManager的函数，两条分支(input和Switch class)在这里汇合了 
                    updateLocked(String newName, int newState)

updateLocked(String newName, int newState) //WiredAccessoryManager.java 
    //获得message，然后发送message 
    Message msg = mHandler.obtainMessage(MSG_NEW_DEVICE_STATE, headsetState, mHeadsetState, newName); 
    mHandler.sendMessage(msg); 
 
上面发送消息会触发消息的handler被调用： 
handleMessage(Message msg) { 
case MSG_NEW_DEVICE_STATE: 
    setDevicesState(msg.arg1, msg.arg2, (String)msg.obj); 
        setDeviceStateLocked(curHeadset, headsetState, prevHeadsetState, headsetName); 
            //终于进入了Audio系统了，设置有线设备的连接状态 
            mAudioManager.setWiredDeviceConnectionState(inDevice, state, headsetName); 
                IAudioService service = getService(); //AudioManager.java 
                service.setWiredDeviceConnectionState(device, state, name); 
                    //指定一个延时时间后又把消息放到一个消息队列中 
                    delay = checkSendBecomingNoisyIntent(device, state); 
                    queueMsgUnderWakeLock(mAudioHandler, MSG_SET_WIRED_DEVICE_CONNECTION_STATE, delay); 
                        //会触发消息的handler被调用 
                        handleMessage(Message msg)  
                             onSetWiredDeviceConnectionState(msg.arg1, msg.arg2, (String)msg.obj); 
                                sendDeviceConnectionIntent(device, state, name); 
                                    //构建一个Intent结构，然后向应用程序广播它，注册对这个Intent感兴趣的App就会收到它 
                                    Intent intent = new Intent(); 
                                    intent.putExtra("state", state); 
                                    intent.putExtra("name", name);     
                                    intent.setAction(Intent.ACTION_HEADSET_PLUG);                         
                                    ActivityManagerNative.broadcastStickyIntent(intent, null, UserHandle.USER_ALL);

//构造函数中添加 
PhoneStatusBarPolicy(Context context, CastController cast) //PhoneStatusBarPolicy.java 
    filter.addAction(Intent.ACTION_HEADSET_PLUG); 
 
收到消息后onReceive被调用，updateHeadset是处理函数 
onReceive(Context context, Intent intent) 
if (action.equals(Intent.ACTION_HEADSET_PLUG)) 
    updateHeadset(intent); 
 
在状态栏中设置head set图标的状态 
private final void updateHeadset(Intent intent) { 
    final String action = intent.getAction(); 
    final int state = intent.getIntExtra("state", 4); 
    final int mic = intent.getIntExtra("microphone", 4); 
 
    switch (state) { 
        case 0: //拔出 
            mService.setIconVisibility("headset", false); 
    break; 
        case 1: //插入 
            if (mic == 1) { //耳机上有mic显示这张图标 
                mService.setIcon("headset", R.drawable.stat_sys_headset_with_mic, 0, null); 
            } else {         //耳机上没有mic显示这张图标 
                mService.setIcon("headset", R.drawable.stat_sys_headset_without_mic, 0, null); 
            } 
            mService.setIconVisibility("headset", true); 
            break; 
    } 
}

主要涉及的文件是AudioPolicyManager.cpp，参考0006_handleDeviceConnection UML 
 
一旦插上USB声卡，就会创建一个对应的播放线程 
 
驱动程序上报音频拔插事件, 该事件为某个device插入或拔出, Android系统需要切换声音通道。 
 
过程为(核心文件为frameworks/av/services/audiopolicy/AudioPolicyManager.cpp): (核心函数为 setDeviceConnectionState) 
a. checkOutputsForDevice 
针对该device, 打开新的output, 创建新的playbackthread. 
方法: 
从audio_policy.conf中确定"本该有多少个output"可以支持它, mOutputs表示"已经打开的output", 两者对比即可确定"尚未打开的output" 
 
b. checkOutputForAllStrategies / checkOutputForStrategy 
对所有的strategy分组声音, 判断是否需要迁移到新的output, 如果需要则迁移对应Track到新的output，方法:  
b.1 判断是否需要迁移 
对于该strategy, 得到它的oldDevice, 进而得到它的outputs (srcOutputs); 
对于该strategy, 得到它的newDevice, 进而得到它的outputs (dstOutputs); 
如果这2个srcOutputs、dstOutputs不相同, 表示需要迁移 
 
b.2 如果迁移: 
把对应的Track设置为invalidate状态即可, App写AudioTrack时发现它是invalidate状态, 就会重新创建新的Track 
    audio_devices_t oldDevice = getDeviceForStrategy(strategy, true /*fromCache*/); 
    audio_devices_t newDevice = getDeviceForStrategy(strategy, false /*fromCache*/); 
    SortedVector<audio_io_handle_t> srcOutputs = getOutputsForDevice(oldDevice, mPreviousOutputs); 
    SortedVector<audio_io_handle_t> dstOutputs = getOutputsForDevice(newDevice, mOutputs); 
 
c. getNewOutputDevice/setOutputDevice 
这要操作HAL

audio_hw_modules { 
  primary { 
    outputs { 
      primary {    //这些参数信息会构造成一个profile