android 音量控制

目錄(?)

[+]

在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.     if (event.getAction() != KeyEvent.ACTION_UP) {  
4.         // If delivering a new key event, make sure the window is  
5.         // now allowed to start updating.  
6.         handleDispatchDoneAnimating();  
7.     }  
8.     // Deliver the key to the view hierarchy.  
9.     if (mView.dispatchKeyEvent(event)) {  
10.         return FINISH_HANDLED;  
11.     }  
12.     if (shouldDropInputEvent(q)) {  
13.         return FINISH_NOT_HANDLED;  
14.     }  
15.     // If the Control modifier is held, try to interpret the key as a shortcut.  
16.     if (event.getAction() == KeyEvent.ACTION_DOWN  
17.             && event.isCtrlPressed()  
18.             && event.getRepeatCount() == 0  
19.             && !KeyEvent.isModifierKey(event.getKeyCode())) {  
20.         if (mView.dispatchKeyShortcutEvent(event)) {  
21.             return FINISH_HANDLED;  
22.         }  
23.         if (shouldDropInputEvent(q)) {  
24.             return FINISH_NOT_HANDLED;  
25.         }  
26.     }  
27.     // Apply the fallback event policy.  
28.     if (mFallbackEventHandler.dispatchKeyEvent(event)) {  
29.         return FINISH_HANDLED;  
30.     }  
31.     if (shouldDropInputEvent(q)) {  
32.         return FINISH_NOT_HANDLED;  
33.     }  
34.     // Handle automatic focus changes.  
35.     if (event.getAction() == KeyEvent.ACTION_DOWN) {  
36.         int direction = 0;  
37.         switch (event.getKeyCode()) {  
38.             case KeyEvent.KEYCODE_DPAD_LEFT:  
39.                 if (event.hasNoModifiers()) {  
40.                     direction = View.FOCUS_LEFT;  
41.                 }  
42.                 break;  
43.             case KeyEvent.KEYCODE_DPAD_RIGHT:  
44.                 if (event.hasNoModifiers()) {  
45.                     direction = View.FOCUS_RIGHT;  
46.                 }  
47.                 break;  
48.             case KeyEvent.KEYCODE_DPAD_UP:  
49.                 if (event.hasNoModifiers()) {  
50.                     direction = View.FOCUS_UP;  
51.                 }  
52.                 break;  
53.             case KeyEvent.KEYCODE_DPAD_DOWN:  
54.                 if (event.hasNoModifiers()) {  
55.                     direction = View.FOCUS_DOWN;  
56.                 }  
57.                 break;  
58.             case KeyEvent.KEYCODE_TAB:  
59.                 if (event.hasNoModifiers()) {  
60.                     direction = View.FOCUS_FORWARD;  
61.                 } else if (event.hasModifiers(KeyEvent.META_SHIFT_ON)) {  
62.                     direction = View.FOCUS_BACKWARD;  
63.                 }  
64.                 break;  
65.         }  
66.         if (direction != 0) {  
67.             View focused = mView.findFocus();  
68.             if (focused != null) {  
69.                 View v = focused.focusSearch(direction);  
70.                 if (v != null && v != focused) {  
71.                     // do the math the get the interesting rect  
72.                     // of previous focused into the coord system of  
73.                     // newly focused view  
74.                     focused.getFocusedRect(mTempRect);  
75.                     if (mView instanceof ViewGroup) {  
76.                         ((ViewGroup) mView).offsetDescendantRectToMyCoords(  
77.                                 focused, mTempRect);  
78.                         ((ViewGroup) mView).offsetRectIntoDescendantCoords(  
79.                                 v, mTempRect);  
80.                     }  
81.                     if (v.requestFocus(direction, mTempRect)) {  
82.                         playSoundEffect(SoundEffectConstants  
83.                                 .getContantForFocusDirection(direction));  
84.                         return FINISH_HANDLED;  
85.                     }  
86.                 }  
87.                 // Give the focused view a last chance to handle the dpad key.  
88.                 if (mView.dispatchUnhandledMove(focused, direction)) {  
89.                     return FINISH_HANDLED;  
90.                 }  
91.             } else {  
92.                 // find the best view to give focus to in this non-touch-mode with no-focus  
93.                 View v = focusSearch(null, direction);  
94.                 if (v != null && v.requestFocus(direction)) {  
95.                     return FINISH_HANDLED;  
96.                 }  
97.             }  
98.         }  
99.     }  
100.     return FORWARD;  
101. }  

從中可以看到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.     // Give any attached key listener a first crack at the event.  
6.     //noinspection SimplifiableIfStatement  
7.     ListenerInfo li = mListenerInfo;  
8.     if (li != null && li.mOnKeyListener != null && (mViewFlags & ENABLED_MASK) == ENABLED  
9.             && li.mOnKeyListener.onKey(this, event.getKeyCode(), event)) {  
10.         return true;  
11.     }  
12.     if (event.dispatch(this, mAttachInfo != null  
13.             ? mAttachInfo.mKeyDispatchState : null, this)) {  
14.         return true;  
15.     }  
16.     if (mInputEventConsistencyVerifier != null) {  
17.         mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);  
18.     }  
19.     return false;  
20. }  

由上面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.     final int action = event.getAction();  
3.     final int keyCode = event.getKeyCode();  
4.     if (action == KeyEvent.ACTION_DOWN) {  
5.         return onKeyDown(keyCode, event);  
6.     } else {  
7.         return onKeyUp(keyCode, event);  
8.     }  
9. }  

進入onKeyDown

[java]  view plain  copy

1. boolean onKeyDown(int keyCode, KeyEvent event) {  
2.     final KeyEvent.DispatcherState dispatcher = mView.getKeyDispatcherState();  
3.     switch (keyCode) {  
4.         case KeyEvent.KEYCODE_VOLUME_UP:  
5.         case KeyEvent.KEYCODE_VOLUME_DOWN:  
6.         case KeyEvent.KEYCODE_VOLUME_MUTE: {  
7.             getAudioManager().handleKeyDown(event, AudioManager.USE_DEFAULT_STREAM_TYPE);  
8.             return true;  
9.         }  
10.         ......  
11.     }  
12.     return false;  
13. }  

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.             int flags = FLAG_SHOW_UI | FLAG_VIBRATE;  
7.             if (mUseMasterVolume) {  
8.                 adjustMasterVolume(  
9.                         keyCode == KeyEvent.KEYCODE_VOLUME_UP  
10.                                 ? ADJUST_RAISE  
11.                                 : ADJUST_LOWER,  
12.                         flags);  
13.             } else {  
14.                 adjustSuggestedStreamVolume(  
15.                         keyCode == KeyEvent.KEYCODE_VOLUME_UP  
16.                                 ? ADJUST_RAISE  
17.                                 : ADJUST_LOWER,  
18.                         stream,  
19.                         flags);  
20.             }  
21.             break;  
22.         case KeyEvent.KEYCODE_VOLUME_MUTE:  
23.             if (event.getRepeatCount() == 0) {  
24.                 if (mUseMasterVolume) {  
25.                     setMasterMute(!isMasterMute());  
26.                 } else {  
27.                     // TODO: Actually handle MUTE.  
28.                 }  
29.             }  
30.             break;  
31.     }  
32. }  

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.     ensureValidDirection(direction);  
8.     ensureValidStreamType(streamType);  
9.     // use stream type alias here so that streams with same alias have the same behavior,  
10.     // including with regard to silent mode control (e.g the use of STREAM_RING below and in  
11.     // checkForRingerModeChange() in place of STREAM_RING or STREAM_NOTIFICATION)  
12.     int streamTypeAlias = mStreamVolumeAlias[streamType];  
13.     VolumeStreamState streamState = mStreamStates[streamTypeAlias];  
14.     final int device = getDeviceForStream(streamTypeAlias);  
15.     int aliasIndex = streamState.getIndex(device);  
16.     boolean adjustVolume = true;  
17.     int step;  
18.     // skip a2dp absolute volume control request when the device  
19.     // is not an a2dp device  
20.     if ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) == 0 &&  
21.         (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) != 0) {  
22.         return;  
23.     }  
24.     if (mAppOps.noteOp(STEAM_VOLUME_OPS[streamTypeAlias], Binder.getCallingUid(),  
25.             callingPackage) != AppOpsManager.MODE_ALLOWED) {  
26.         return;  
27.     }  
28.     // reset any pending volume command  
29.     synchronized (mSafeMediaVolumeState) {  
30.         mPendingVolumeCommand = null;  
31.     }  
32.     flags &= ~AudioManager.FLAG_FIXED_VOLUME;  
33.     if ((streamTypeAlias == AudioSystem.STREAM_MUSIC) &&  
34.            ((device & mFixedVolumeDevices) != 0)) {  
35.         flags |= AudioManager.FLAG_FIXED_VOLUME;  
36.         // Always toggle between max safe volume and 0 for fixed volume devices where safe  
37.         // volume is enforced, and max and 0 for the others.  
38.         // This is simulated by stepping by the full allowed volume range  
39.         if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&  
40.                 (device & mSafeMediaVolumeDevices) != 0) {  
41.             step = mSafeMediaVolumeIndex;  
42.         } else {  
43.             step = streamState.getMaxIndex();  
44.         }  
45.         if (aliasIndex != 0) {  
46.             aliasIndex = step;  
47.         }  
48.     } else {  
49.         // convert one UI step (+/-1) into a number of internal units on the stream alias  
50.         step = rescaleIndex(10, streamType, streamTypeAlias);  
51.     }  
52.     // If either the client forces allowing ringer modes for this adjustment,  
53.     // or the stream type is one that is affected by ringer modes  
54.     if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||  
55.             (streamTypeAlias == getMasterStreamType())) {  
56.         int ringerMode = getRingerMode();  
57.         // do not vibrate if already in vibrate mode  
58.         if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {  
59.             flags &= ~AudioManager.FLAG_VIBRATE;  
60.         }  
61.         // Check if the ringer mode changes with this volume adjustment. If  
62.         // it does, it will handle adjusting the volume, so we won't below  
63.         adjustVolume = checkForRingerModeChange(aliasIndex, direction, step);  
64.     }  
65.     int oldIndex = mStreamStates[streamType].getIndex(device);  
66.     if (adjustVolume && (direction != AudioManager.ADJUST_SAME)) {  
67.         // Check if volume update should be send to AVRCP  
68.         if (streamTypeAlias == AudioSystem.STREAM_MUSIC &&  
69.             (device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0 &&  
70.             (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
71.             synchronized (mA2dpAvrcpLock) {  
72.                 if (mA2dp != null && mAvrcpAbsVolSupported) {  
73.                     mA2dp.adjustAvrcpAbsoluteVolume(direction);  
74.                 }  
75.             }  
76.         }  
77.         if ((direction == AudioManager.ADJUST_RAISE) &&  
78.                 !checkSafeMediaVolume(streamTypeAlias, aliasIndex + step, device)) {  
79.             Log.e(TAG, "adjustStreamVolume() safe volume index = "+oldIndex);  
80.             mVolumePanel.postDisplaySafeVolumeWarning(flags);  
81.         } else if (streamState.adjustIndex(direction * step, device)) {  
82.             // Post message to set system volume (it in turn will post a message  
83.             // to persist). Do not change volume if stream is muted.  
84.             sendMsg(mAudioHandler,  
85.                     MSG_SET_DEVICE_VOLUME,  
86.                     SENDMSG_QUEUE,  
87.                     device,  
88.                     0,  
89.                     streamState,  
90.                     0);  
91.         }  
92.     }  
93.     int index = mStreamStates[streamType].getIndex(device);  
94.     sendVolumeUpdate(streamType, oldIndex, index, flags);  
95. }  

藍牙音量的控制

有上可知，如果目前連接配接了藍牙也将對音量進行控制，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.     // Apply volume  
3.     streamState.applyDeviceVolume(device);  
4.     // Apply change to all streams using this one as alias  
5.     int numStreamTypes = AudioSystem.getNumStreamTypes();  
6.     for (int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {  
7.         if (streamType != streamState.mStreamType &&  
8.                 mStreamVolumeAlias[streamType] == streamState.mStreamType) {  
9.             // Make sure volume is also maxed out on A2DP device for aliased stream  
10.             // that may have a different device selected  
11.             int streamDevice = getDeviceForStream(streamType);  
12.             if ((device != streamDevice) && mAvrcpAbsVolSupported &&  
13.                     ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0)) {  
14.                 mStreamStates[streamType].applyDeviceVolume(device);  
15.             }  
16.             mStreamStates[streamType].applyDeviceVolume(streamDevice);  
17.         }  
18.     }  
19.     // Post a persist volume msg  
20.     sendMsg(mAudioHandler,  
21.             MSG_PERSIST_VOLUME,  
22.             SENDMSG_QUEUE,  
23.             device,  
24.             0,  
25.             streamState,  
26.             PERSIST_DELAY);  
27. }  

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

更多音頻政策相關流程後續分析。