程序博客网 > 毒品网络剧情

android 音量控制

来源：互联网 发布：毒品网络剧情 编辑：程序博客网 时间：2024/06/05 05:02

目录(?)

[+]

在Android平台上，音量键，主页键(home),都是全局按键，但是主页键是个例外不能被应用所捕获。下面分析一下音量按键的流程，主要从framework层处理开始，至于

EventHub 从驱动的/dev/input/event0获取按键信息到上抛属于Android input 系统方面的流程，下面基于android KK平台分析。


系统层接收音量按键

ViewRootImpl.processKeyEvent 处理Activity 上面收到的按键

[java] view plain copy
  1. private int processKeyEvent(QueuedInputEvent q) {  
  2.     final KeyEvent event = (KeyEvent)q.mEvent;  
  3.   
  4.     if (event.getAction() != KeyEvent.ACTION_UP) {  
  5.         // If delivering a new key event, make sure the window is  
  6.         // now allowed to start updating.  
  7.         handleDispatchDoneAnimating();  
  8.     }  
  9.   
  10.     // Deliver the key to the view hierarchy.  
  11.     if (mView.dispatchKeyEvent(event)) {  
  12.         return FINISH_HANDLED;  
  13.     }  
  14.   
  15.     if (shouldDropInputEvent(q)) {  
  16.         return FINISH_NOT_HANDLED;  
  17.     }  
  18.   
  19.     // If the Control modifier is held, try to interpret the key as a shortcut.  
  20.     if (event.getAction() == KeyEvent.ACTION_DOWN  
  21.             && event.isCtrlPressed()  
  22.             && event.getRepeatCount() == 0  
  23.             && !KeyEvent.isModifierKey(event.getKeyCode())) {  
  24.         if (mView.dispatchKeyShortcutEvent(event)) {  
  25.             return FINISH_HANDLED;  
  26.         }  
  27.         if (shouldDropInputEvent(q)) {  
  28.             return FINISH_NOT_HANDLED;  
  29.         }  
  30.     }  
  31.   
  32.     // Apply the fallback event policy.  
  33.     if (mFallbackEventHandler.dispatchKeyEvent(event)) {  
  34.         return FINISH_HANDLED;  
  35.     }  
  36.     if (shouldDropInputEvent(q)) {  
  37.         return FINISH_NOT_HANDLED;  
  38.     }  
  39.   
  40.     // Handle automatic focus changes.  
  41.     if (event.getAction() == KeyEvent.ACTION_DOWN) {  
  42.         int direction = 0;  
  43.         switch (event.getKeyCode()) {  
  44.             case KeyEvent.KEYCODE_DPAD_LEFT:  
  45.                 if (event.hasNoModifiers()) {  
  46.                     direction = View.FOCUS_LEFT;  
  47.                 }  
  48.                 break;  
  49.             case KeyEvent.KEYCODE_DPAD_RIGHT:  
  50.                 if (event.hasNoModifiers()) {  
  51.                     direction = View.FOCUS_RIGHT;  
  52.                 }  
  53.                 break;  
  54.             case KeyEvent.KEYCODE_DPAD_UP:  
  55.                 if (event.hasNoModifiers()) {  
  56.                     direction = View.FOCUS_UP;  
  57.                 }  
  58.                 break;  
  59.             case KeyEvent.KEYCODE_DPAD_DOWN:  
  60.                 if (event.hasNoModifiers()) {  
  61.                     direction = View.FOCUS_DOWN;  
  62.                 }  
  63.                 break;  
  64.             case KeyEvent.KEYCODE_TAB:  
  65.                 if (event.hasNoModifiers()) {  
  66.                     direction = View.FOCUS_FORWARD;  
  67.                 } else if (event.hasModifiers(KeyEvent.META_SHIFT_ON)) {  
  68.                     direction = View.FOCUS_BACKWARD;  
  69.                 }  
  70.                 break;  
  71.         }  
  72.         if (direction != 0) {  
  73.             View focused = mView.findFocus();  
  74.             if (focused != null) {  
  75.                 View v = focused.focusSearch(direction);  
  76.                 if (v != null && v != focused) {  
  77.                     // do the math the get the interesting rect  
  78.                     // of previous focused into the coord system of  
  79.                     // newly focused view  
  80.                     focused.getFocusedRect(mTempRect);  
  81.                     if (mView instanceof ViewGroup) {  
  82.                         ((ViewGroup) mView).offsetDescendantRectToMyCoords(  
  83.                                 focused, mTempRect);  
  84.                         ((ViewGroup) mView).offsetRectIntoDescendantCoords(  
  85.                                 v, mTempRect);  
  86.                     }  
  87.                     if (v.requestFocus(direction, mTempRect)) {  
  88.                         playSoundEffect(SoundEffectConstants  
  89.                                 .getContantForFocusDirection(direction));  
  90.                         return FINISH_HANDLED;  
  91.                     }  
  92.                 }  
  93.   
  94.                 // Give the focused view a last chance to handle the dpad key.  
  95.                 if (mView.dispatchUnhandledMove(focused, direction)) {  
  96.                     return FINISH_HANDLED;  
  97.                 }  
  98.             } else {  
  99.                 // find the best view to give focus to in this non-touch-mode with no-focus  
  100.                 View v = focusSearch(null, direction);  
  101.                 if (v != null && v.requestFocus(direction)) {  
  102.                     return FINISH_HANDLED;  
  103.                 }  
  104.             }  
  105.         }  
  106.     }  
  107.     return FORWARD;  
  108. }  
从中可以看到mView.dispatchKeyEvent(event),完成将按键发送给Activity处理，由于每个Activity都是view的子类，所有这些按键将dispatchKeyEvent传递给onKeyDown

[java] view plain copy
  1. public boolean dispatchKeyEvent(KeyEvent event) {  
  2.     if (mInputEventConsistencyVerifier != null) {  
  3.         mInputEventConsistencyVerifier.onKeyEvent(event, 0);  
  4.     }  
  5.   
  6.     // Give any attached key listener a first crack at the event.  
  7.     //noinspection SimplifiableIfStatement  
  8.     ListenerInfo li = mListenerInfo;  
  9.     if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED  
  10.             && li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {  
  11.         return true;  
  12.     }  
  13.   
  14.     if (event.dispatch(this, mAttachInfo != null  
  15.             ? mAttachInfo.mKeyDispatchState : null, this)) {  
  16.         return true;  
  17.     }  
  18.   
  19.     if (mInputEventConsistencyVerifier != null) {  
  20.         mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);  
  21.     }  
  22.     return false;  
  23. }  
由上面View.dispatchKeyEvent方法可知，通过event.dispatch进一步分发

[java] view plain copy
  1. public final boolean dispatch(Callback receiver, DispatcherState state,  
  2.         Object target) {  
  3.     switch (mAction) {  
  4.         case ACTION_DOWN: {  
  5.             mFlags &= ~FLAG_START_TRACKING;  
  6.             if (DEBUG) Log.v(TAG, "Key down to " + target + " in " + state  
  7.                     + ": " + this);  
  8.             boolean res = receiver.onKeyDown(mKeyCode, this);  
  9.             if (state != null) {  
  10.                 if (res && mRepeatCount == 0 && (mFlags&FLAG_START_TRACKING) != 0) {  
  11.                     if (DEBUG) Log.v(TAG, "  Start tracking!");  
  12.                     state.startTracking(this, target);  
  13.                 } else if (isLongPress() && state.isTracking(this)) {  
  14.                     try {  
  15.                         if (receiver.onKeyLongPress(mKeyCode, this)) {  
  16.                             if (DEBUG) Log.v(TAG, "  Clear from long press!");  
  17.                             state.performedLongPress(this);  
  18.                             res = true;  
  19.                         }  
  20.                     } catch (AbstractMethodError e) {  
  21.                     }  
  22.                 }  
  23.             }  
  24.             return res;  
  25.         }  
  26.         case ACTION_UP:  
  27.             if (DEBUG) Log.v(TAG, "Key up to " + target + " in " + state  
  28.                     + ": " + this);  
  29.             if (state != null) {  
  30.                 state.handleUpEvent(this);  
  31.             }  
  32.             return receiver.onKeyUp(mKeyCode, this);  
  33.         case ACTION_MULTIPLE:  
  34.             final int count = mRepeatCount;  
  35.             final int code = mKeyCode;  
  36.             if (receiver.onKeyMultiple(code, count, this)) {  
  37.                 return true;  
  38.             }  
  39.             if (code != KeyEvent.KEYCODE_UNKNOWN) {  
  40.                 mAction = ACTION_DOWN;  
  41.                 mRepeatCount = 0;  
  42.                 boolean handled = receiver.onKeyDown(code, this);  
  43.                 if (handled) {  
  44.                     mAction = ACTION_UP;  
  45.                     receiver.onKeyUp(code, this);  
  46.                 }  
  47.                 mAction = ACTION_MULTIPLE;  
  48.                 mRepeatCount = count;  
  49.                 return handled;  
  50.             }  
  51.             return false;  
  52.     }  
  53.     return false;  
  54. }  
KeyEvent.dispatch通过receiver.onKeyDown将最终的按键消息发送给当前的Activity，而receiver即为KeyEvent.Callback的实现类(View的子类等等)，至此如果上面上传

应用处理完了就会返回，如果没有处理就会流向mFallbackEventHandler.dispatchKeyEvent(event),其实mFallbackEventHandler就是PhoneFallbackEventHandler,接着看

PhoneFallbackEventHandler.dispatchKeyEvent的处理流程

[java] view plain copy
  1. public boolean dispatchKeyEvent(KeyEvent event) {  
  2.   
  3.     final int action = event.getAction();  
  4.     final int keyCode = event.getKeyCode();  
  5.   
  6.     if (action == KeyEvent.ACTION_DOWN) {  
  7.         return onKeyDown(keyCode, event);  
  8.     } else {  
  9.         return onKeyUp(keyCode, event);  
  10.     }  
  11. }  
进入onKeyDown

[java] view plain copy
  1. boolean onKeyDown(int keyCode, KeyEvent event) {  
  2.     /* **************************************************************************** 
  3.      * HOW TO DECIDE WHERE YOUR KEY HANDLING GOES. 
  4.      * See the comment in PhoneWindow.onKeyDown 
  5.      * ****************************************************************************/  
  6.     final KeyEvent.DispatcherState dispatcher = mView.getKeyDispatcherState();  
  7.   
  8.     switch (keyCode) {  
  9.         case KeyEvent.KEYCODE_VOLUME_UP:  
  10.         case KeyEvent.KEYCODE_VOLUME_DOWN:  
  11.         case KeyEvent.KEYCODE_VOLUME_MUTE: {  
  12.             getAudioManager().handleKeyDown(event, AudioManager.USE_DEFAULT_STREAM_TYPE);  
  13.             return true;  
  14.         }  
  15.   
  16.         ......  
  17.   
  18.     }  
  19.     return false;  
  20. }  

AudioManager处理音量

从上面分析知道PhoneFallbackEventHandler处理一些Activity没有处理的全局按键，音量键接着进入handleKeyDown处理流程
[java] view plain copy
  1. public void handleKeyDown(KeyEvent event, int stream) {  
  2.     int keyCode = event.getKeyCode();  
  3.     switch (keyCode) {  
  4.         case KeyEvent.KEYCODE_VOLUME_UP:  
  5.         case KeyEvent.KEYCODE_VOLUME_DOWN:  
  6.             /* 
  7.              * Adjust the volume in on key down since it is more 
  8.              * responsive to the user. 
  9.              */  
  10.             int flags = FLAG_SHOW_UI | FLAG_VIBRATE;  
  11.   
  12.             if (mUseMasterVolume) {  
  13.                 adjustMasterVolume(  
  14.                         keyCode == KeyEvent.KEYCODE_VOLUME_UP  
  15.                                 ? ADJUST_RAISE  
  16.                                 : ADJUST_LOWER,  
  17.                         flags);  
  18.             } else {  
  19.                 adjustSuggestedStreamVolume(  
  20.                         keyCode == KeyEvent.KEYCODE_VOLUME_UP  
  21.                                 ? ADJUST_RAISE  
  22.                                 : ADJUST_LOWER,  
  23.                         stream,  
  24.                         flags);  
  25.             }  
  26.             break;  
  27.         case KeyEvent.KEYCODE_VOLUME_MUTE:  
  28.             if (event.getRepeatCount() == 0) {  
  29.                 if (mUseMasterVolume) {  
  30.                     setMasterMute(!isMasterMute());  
  31.                 } else {  
  32.                     // TODO: Actually handle MUTE.  
  33.                 }  
  34.             }  
  35.             break;  
  36.     }  
  37. }  
mUseMasterVolume ( = com.android.internal.R.bool.config_useMasterVolume)，配置文件config.xml中该值为0，那么将进入adjustSuggestedStreamVolume，
再接着就进入adjustSuggestedStreamVolume，如果当前的streamType为STREAM_REMOTE_MUSIC，则走mMediaFocusControl.adjustRemoteVolume，其它类型
走音量的通用设置流程adjustStreamVolume

AudioService音量控制流程

从adjustSuggestedStreamVolume 过渡到adjustStreamVolume，进入音量设置的主要流程，主要对流类型，设备，声音设备状态，步进大小进行判断处理，另外蓝牙设
备音量和主设备音量进行了控制，最后通过mVolumePanel刷新界面音量显示，并且广播通过上层应用。
[java] view plain copy
  1. public void adjustStreamVolume(int streamType, int direction, int flags,  
  2.         String callingPackage) {  
  3.     if (mUseFixedVolume) {  
  4.         return;  
  5.     }  
  6.     if (DEBUG_VOL) Log.d(TAG, "adjustStreamVolume() stream="+streamType+", dir="+direction);  
  7.   
  8.     ensureValidDirection(direction);  
  9.     ensureValidStreamType(streamType);  
  10.   
  11.     // use stream type alias here so that streams with same alias have the same behavior,  
  12.     // including with regard to silent mode control (e.g the use of STREAM_RING below and in  
  13.     // checkForRingerModeChange() in place of STREAM_RING or STREAM_NOTIFICATION)  
  14.     int streamTypeAlias = mStreamVolumeAlias[streamType];  
  15.     VolumeStreamState streamState = mStreamStates[streamTypeAlias];  
  16.   
  17.     final int device = getDeviceForStream(streamTypeAlias);  
  18.   
  19.     int aliasIndex = streamState.getIndex(device);  
  20.     boolean adjustVolume = true;  
  21.     int step;  
  22.   
  23.     // skip a2dp absolute volume control request when the device  
  24.     // is not an a2dp device  
  25.     if ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) == 0 &&  
  26.         (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) != 0) {  
  27.         return;  
  28.     }  
  29.   
  30.     if (mAppOps.noteOp(STEAM_VOLUME_OPS[streamTypeAlias], Binder.getCallingUid(),  
  31.             callingPackage) != AppOpsManager.MODE_ALLOWED) {  
  32.         return;  
  33.     }  
  34.   
  35.     // reset any pending volume command  
  36.     synchronized (mSafeMediaVolumeState) {  
  37.         mPendingVolumeCommand = null;  
  38.     }  
  39.   
  40.     flags &= ~AudioManager.FLAG_FIXED_VOLUME;  
  41.     if ((streamTypeAlias == AudioSystem.STREAM_MUSIC) &&  
  42.            ((device & mFixedVolumeDevices) != 0)) {  
  43.         flags |= AudioManager.FLAG_FIXED_VOLUME;  
  44.   
  45.         // Always toggle between max safe volume and 0 for fixed volume devices where safe  
  46.         // volume is enforced, and max and 0 for the others.  
  47.         // This is simulated by stepping by the full allowed volume range  
  48.         if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&  
  49.                 (device & mSafeMediaVolumeDevices) != 0) {  
  50.             step = mSafeMediaVolumeIndex;  
  51.         } else {  
  52.             step = streamState.getMaxIndex();  
  53.         }  
  54.         if (aliasIndex != 0) {  
  55.             aliasIndex = step;  
  56.         }  
  57.     } else {  
  58.         // convert one UI step (+/-1) into a number of internal units on the stream alias  
  59.         step = rescaleIndex(10, streamType, streamTypeAlias);  
  60.     }  
  61.   
  62.     // If either the client forces allowing ringer modes for this adjustment,  
  63.     // or the stream type is one that is affected by ringer modes  
  64.     if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||  
  65.             (streamTypeAlias == getMasterStreamType())) {  
  66.         int ringerMode = getRingerMode();  
  67.         // do not vibrate if already in vibrate mode  
  68.         if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {  
  69.             flags &= ~AudioManager.FLAG_VIBRATE;  
  70.         }  
  71.         // Check if the ringer mode changes with this volume adjustment. If  
  72.         // it does, it will handle adjusting the volume, so we won't below  
  73.         adjustVolume = checkForRingerModeChange(aliasIndex, direction, step);  
  74.     }  
  75.   
  76.     int oldIndex = mStreamStates[streamType].getIndex(device);  
  77.   
  78.     if (adjustVolume && (direction != AudioManager.ADJUST_SAME)) {  
  79.   
  80.         // Check if volume update should be send to AVRCP  
  81.         if (streamTypeAlias == AudioSystem.STREAM_MUSIC &&  
  82.             (device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0 &&  
  83.             (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
  84.             synchronized (mA2dpAvrcpLock) {  
  85.                 if (mA2dp != null && mAvrcpAbsVolSupported) {  
  86.                     mA2dp.adjustAvrcpAbsoluteVolume(direction);  
  87.                 }  
  88.             }  
  89.         }  
  90.   
  91.         if ((direction == AudioManager.ADJUST_RAISE) &&  
  92.                 !checkSafeMediaVolume(streamTypeAlias, aliasIndex + step, device)) {  
  93.             Log.e(TAG, "adjustStreamVolume() safe volume index = "+oldIndex);  
  94.             mVolumePanel.postDisplaySafeVolumeWarning(flags);  
  95.         } else if (streamState.adjustIndex(direction * step, device)) {  
  96.             // Post message to set system volume (it in turn will post a message  
  97.             // to persist). Do not change volume if stream is muted.  
  98.             sendMsg(mAudioHandler,  
  99.                     MSG_SET_DEVICE_VOLUME,  
  100.                     SENDMSG_QUEUE,  
  101.                     device,  
  102.                     0,  
  103.                     streamState,  
  104.                     0);  
  105.         }  
  106.     }  
  107.     int index = mStreamStates[streamType].getIndex(device);  
  108.     sendVolumeUpdate(streamType, oldIndex, index, flags);  
  109. }  

蓝牙音量的控制

有上可知，如果当前连接了蓝牙也将对音量进行控制，mA2dp.adjustAvrcpAbsoluteVolume，以后分析。

音频处理设置

音频处理由AudioHandler来进行，adjustStreamVolume做完相关处理后，通过sendMsg发送音量变化消息MSG_SET_DEVICE_VOLUME进入
AudioHandler.handleMessage调用AudioHandler.setDeviceVolume
[java] view plain copy
  1. private void setDeviceVolume(VolumeStreamState streamState, int device) {  
  2.   
  3.     // Apply volume  
  4.     streamState.applyDeviceVolume(device);  
  5.   
  6.     // Apply change to all streams using this one as alias  
  7.     int numStreamTypes = AudioSystem.getNumStreamTypes();  
  8.     for (int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {  
  9.         if (streamType != streamState.mStreamType &&  
  10.                 mStreamVolumeAlias[streamType] == streamState.mStreamType) {  
  11.             // Make sure volume is also maxed out on A2DP device for aliased stream  
  12.             // that may have a different device selected  
  13.             int streamDevice = getDeviceForStream(streamType);  
  14.             if ((device != streamDevice) && mAvrcpAbsVolSupported &&  
  15.                     ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0)) {  
  16.                 mStreamStates[streamType].applyDeviceVolume(device);  
  17.             }  
  18.             mStreamStates[streamType].applyDeviceVolume(streamDevice);  
  19.         }  
  20.     }  
  21.   
  22.     // Post a persist volume msg  
  23.     sendMsg(mAudioHandler,  
  24.             MSG_PERSIST_VOLUME,  
  25.             SENDMSG_QUEUE,  
  26.             device,  
  27.             0,  
  28.             streamState,  
  29.             PERSIST_DELAY);  
  30.   
  31. }  
VolumeStreamState.applyDeviceVolume设置设备音量
[java] view plain copy
  1. public void applyDeviceVolume(int device) {  
  2.     int index;  
  3.     if (isMuted()) {  
  4.         index = 0;  
  5.     } else if ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0 &&  
  6.                mAvrcpAbsVolSupported) {  
  7.         index = (mIndexMax + 5)/10;  
  8.     } else {  
  9.         index = (getIndex(device) + 5)/10;  
  10.     }  
  11.     AudioSystem.setStreamVolumeIndex(mStreamType, index, device);  
  12. }  
接着发送MSG_PERSIST_VOLUME消息通过handleMessage进入persistVolume，最终调用System.putIntForUser将用户设置的内容设置到Settings.system中。

AudioSystem处理

applyDeviceVolume处理完，AudioSystem就开始接着往下设置setStreamVolumeIndex，该接口也即android_media_AudioSystem_setStreamVolumeIndex
在frameworks\base\core\jni\android_media_AudioSystem.cpp中有定义。
[cpp] view plain copy
  1. static int android_media_AudioSystem_setStreamVolumeIndex(JNIEnv *env,  
  2.                                                jobject thiz,  
  3.                                                jint stream,  
  4.                                                jint index,  
  5.                                                jint device)  
  6. {  
  7.     return check_AudioSystem_Command(  
  8.             AudioSystem::setStreamVolumeIndex(static_cast <audio_stream_type_t>(stream),  
  9.                                               index,  
  10.                                               (audio_devices_t)device));  
  11. }  
进入AudioSystem.cpp中setStreamVolumeIndex
[cpp] view plain copy
  1. status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,  
  2.                                            int index,  
  3.                                            audio_devices_t device)  
  4. {  
  5.     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();  
  6.     if (aps == 0) return PERMISSION_DENIED;  
  7.     return aps->setStreamVolumeIndex(stream, index, device);  
  8. }  
获取去音频策略服务(AudioPolicyService.cpp)，进行设置
[cpp] view plain copy
  1. status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,  
  2.                                                   int index,  
  3.                                                   audio_devices_t device)  
  4. {  
  5.     if (mpAudioPolicy == NULL) {  
  6.         return NO_INIT;  
  7.     }  
  8.     if (!settingsAllowed()) {  
  9.         return PERMISSION_DENIED;  
  10.     }  
  11.     if (uint32_t(stream) >= AUDIO_STREAM_CNT) {  
  12.         return BAD_VALUE;  
  13.     }  
  14.     Mutex::Autolock _l(mLock);  
  15.     if (mpAudioPolicy->set_stream_volume_index_for_device) {  
  16.         return mpAudioPolicy->set_stream_volume_index_for_device(mpAudioPolicy,  
  17.                                                                 stream,  
  18.                                                                 index,  
  19.                                                                 device);  
  20.     } else {  
  21.         return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index);  
  22.     }  
  23. }  
AudioPolicyService为音频策略系统服务在main_mediaserver.cpp中注册，AudioFlinger也在其中注册。
        mpAudioPolicy作为audio_policy类型的对象，其方法主要在Hardware层实现，可以查看相关文件audio_policy_hal.cpp 或者 audio_policy.c，也就是在库
audio.a2dp.xxx.so ,audio.btmic.xxx.so，audio.primary.xxxx 库中实现.

AudioPolicyService.cpp构造函数中就有hw_get_module(AUDIO_POLICY_HARDWARE_MODULE_ID, &module);打印HAL层的库。


通知上层应用

sendVolumeUpdate在音量设置完成之后，完成画面刷新，并广播通知上层应用。


扩展连接：http://www.2cto.com/kf/201409/337102.html


更多音频策略相关流程后续分析。

0 0
毒品网络剧情 毒品网络剧情
原创粉丝点击
热门IT博客
纯棉衬衫 知乎纯棉衬衫 知乎
苏州哪里买苏绣好 知乎苏州哪里买苏绣好 知乎
美国东密西根大学知乎
.us域名
java反射机制优缺点
如何做一名淘宝客
网络教育统考难么
6月淘客不计入淘宝权重
安全网络征文大赛
linux mv 文件
阅读软件
手机淘宝取消短信验证
gta53md针对笔记本优化
知乎 骑士团
卫计委大数据
疯狂java讲义第3版pdf
大数据如何获取及用途
日本好用的护肤品知乎
排版图片软件
机甲世纪革新版数据号
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 金州刻章 金州九里 金州 瓦房店 金州酒席 金州到天津 金州洗浴 金州到鞍山 金州人工湖 金州教育 沈阳 金州 金州售楼 金州大桥 金州步行街 沈阳至金州 金州桶装水 金州到旅顺 辽阳到金州 山东金州 嘉兴金州 金州做人流 金州至苏州 金州楼房 金州教育云平台 大连金州湾国际机场 金州教育云平台登录 大连金州机场 金州云平台登录 金州教育云平台登录入口 金州勇士队球员名单 大连金州邮编 金州慈航股票股吧 金州勇士队图片 大连金州房价 大连到金州火车时刻表 金州湾国际机场 金州勇士队标图片 金州勇士在哪个城市 金州到沈阳火车时刻表 金州到普兰店火车时刻表 普兰店到金州火车时刻表 金州洗浴哪家姑娘漂亮2018

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里