Android音频子系统，音量的调节控制（七）

爱被打了一巴掌 2022-06-05 02:42 728阅读 0赞

音量的调节控制：

按下音量的加减键，对应的keyevent是：KEYCODE\_VOLUME\_DOWN，KEYCODE\_VOLUME\_UP。

主要看两个地方对这一事件的处理，一是：handleKeyDown()@AudioManager.java，一是：

interceptKeyBeforeQueueing ()@PhoneWindowManager.java。

先看AudioManager.java类中的处理：

frameworks/base/media/java/android/media/

public void handleKeyDown(KeyEvent event, int stream) @AudioManager.java{
    	int keyCode = event.getKeyCode();
    	switch (keyCode) {
    		case KeyEvent.KEYCODE_VOLUME_UP:
    		case KeyEvent.KEYCODE_VOLUME_DOWN:
    //在key-down事件时，调整音量，要更灵敏的相应用户，这里的flags是FLAG_SHOW_UI | FLAG_VIBRATE，会显示进度条，有震动，
    			adjustSuggestedStreamVolume(
    keyCode == KeyEvent.KEYCODE_VOLUME_UP ? ADJUST_RAISE: ADJUST_LOWER,
    stream, FLAG_SHOW_UI | FLAG_VIBRATE);
    		break;
    }
    }
    public void handleKeyUp(KeyEvent event, int stream) @AudioManager.java {
    	nt keyCode = event.getKeyCode();
    	switch (keyCode) {
    		case KeyEvent.KEYCODE_VOLUME_UP:
    		case KeyEvent.KEYCODE_VOLUME_DOWN:
    //在key-up时，播放调节音量的声音。
    			adjustSuggestedStreamVolume(ADJUST_SAME, stream,
    				FLAG_PLAY_SOUND);
    }
    }

根据音量加减键，进一步调用：adjustSuggestedStreamVolume。

public void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags) {
    	MediaSessionLegacyHelper helper = MediaSessionLegacyHelper.getHelper(getContext());
    	helper.sendAdjustVolumeBy(suggestedStreamType, direction, flags);
    	往下的过程，会通过ISessionManager这个Binder client 句柄，把调节音量的请求传到AudioService。
    	这个调用，接下来会走到MediaSessionService.java中，调用SessionManagerImpl中的方法：dispatchAdjustVolumeLocked ()，SessionManagerImpl是ISessionManager的服务端的实现类。
    	class SessionManagerImpl extends ISessionManager.Stub；
    }

MediaSessionService.java

private void dispatchAdjustVolumeLocked(int suggestedStream, int direction, int flags,
    	MediaSessionRecord session) @SessionManagerImpl{
    	String packageName = getContext().getOpPackageName();
    //这个mAudioService就是AUDIO_SERVICE = "audio"对应的Binder服务。所以请求就到了AudioService的server端。
    	mAudioService.adjustSuggestedStreamVolume(direction, suggestedStream,
    		flags, packageName, TAG);
    }

private void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags,
    	String callingPackage, String caller, int uid) {
    //声音分为STREAM_MUSIC，STREAM_VOICE_CALL，等多种流类型，当前要调节的是哪一种流类型的音量，先通过getActiveStreamType获取当前活跃的流类型。
    先判断是不是在通话，如果是通话，还要分是蓝牙STREAM_BLUETOOTH_SCO，还是STREAM_VOICE_CALL；然后是不是播放音乐，
    	int streamType;
    	streamType = getActiveStreamType(suggestedStreamType);
    //执行调整音量
    	adjustStreamVolume(streamType, direction, flags, callingPackage, caller, uid);
    }

adjustStreamVolume稍后分析，

下面看下PhoneWindowManager.java中对音量键的处理：

public int interceptKeyBeforeQueueing(KeyEvent event, int policyFlags) 
    @ PhoneWindowManager.java {
    	final int keyCode = event.getKeyCode();
    	switch (keyCode) {
    		case KeyEvent.KEYCODE_VOLUME_DOWN:
    		case KeyEvent.KEYCODE_VOLUME_UP:
    //对一些物理按键，系统有优先拦截的权利，做些预处理，这里会根据当前的具体情况，如是不是做截屏处理，是不是在通话等，然后决定需要调整的的stream类型。通过mediasession进一步处理按键事件，跟audiomanager类似。
    			MediaSessionLegacyHelper.getHelper(mContext)
    				.sendVolumeKeyEvent(event, true);
    }
    }

public void sendVolumeKeyEvent(KeyEvent keyEvent, boolean musicOnly) 
    @ MediaSessionLegacyHelper.java {
    //接下来的处理，就是通过MediaSessionManager.，SessionManagerImpl（位于MediaSessionService.java中），把请求传到audioservice那边。
    	mSessionManager.dispatchAdjustVolume(
    AudioManager.USE_DEFAULT_STREAM_TYPE, direction, flags);
    }

接着看audioservice，如何处理音量调节的。

private void adjustStreamVolume(int streamType, int direction, int flags,
    	String callingPackage, String caller, int uid) @ AudioService.java {
    //step1，为streamType查找alias归类，使用流类型别名是为了让有相同别名的流，有相同的行为。
    	int streamTypeAlias = mStreamVolumeAlias[streamType];
    	VolumeStreamState streamState = mStreamStates[streamTypeAlias];
    //step2，为streamtypealias寻找匹配的device。
    	final int device = getDeviceForStream(streamTypeAlias);
    //step3，获取对应的aliasindex
    	int aliasIndex = streamState.getIndex(device);
    //step4，调节index，把UI上的加1、减1的步骤，转成流别名上内部单元中的数字。
    	step = rescaleIndex(10, streamType, streamTypeAlias);
    //step5，对音量模式的影响，
    	if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||
    		(streamTypeAlias == getUiSoundsStreamType())) {
    		int ringerMode = getRingerModeInternal();
    //如果已经是震动模式，就不要震动了
    		if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {
    		flags &= ~AudioManager.FLAG_VIBRATE;
    }
    //检查这个调节是否会改变铃声模式，而不仅仅是调节音量，如果是这样，就要设置合适的铃声模式，在流状态上音量指数。
    final int result = checkForRingerModeChange(aliasIndex, direction, step,
    	streamState.mIsMuted, callingPackage, flags);
    adjustVolume = (result & FLAG_ADJUST_VOLUME) != 0;
    }	
    //step6，将调节音量的事件发给下一个处理者。
    	int oldIndex = mStreamStates[streamType].getIndex(device);
    	sendMsg(mAudioHandler, MSG_SET_DEVICE_VOLUME, SENDMSG_QUEUE,
    		device, 0, streamState,0);
    	int index = mStreamStates[streamType].getIndex(device);
    	sendVolumeUpdate(streamType, oldIndex, index, flags);
    }

Step1，流类型别名，虽然stream有多种类型，但他们在某些方面的行为是一样的，这就是stream-alias存在的意义。

private final int[] STREAM_VOLUME_ALIAS_DEFAULT = new int[] {
            AudioSystem.STREAM_VOICE_CALL,      // STREAM_VOICE_CALL
            AudioSystem.STREAM_RING,            // STREAM_SYSTEM
            AudioSystem.STREAM_RING,            // STREAM_RING
            AudioSystem.STREAM_MUSIC,           // STREAM_MUSIC
            AudioSystem.STREAM_ALARM,           // STREAM_ALARM
            AudioSystem.STREAM_RING,            // STREAM_NOTIFICATION
            AudioSystem.STREAM_BLUETOOTH_SCO,   // STREAM_BLUETOOTH_SCO
            AudioSystem.STREAM_RING,            // STREAM_SYSTEM_ENFORCED
            AudioSystem.STREAM_RING,            // STREAM_DTMF
            AudioSystem.STREAM_MUSIC            // STREAM_TTS
    };

Step3，通过VolumeStreamState获取音量值

public int getIndex(int device) {
                synchronized (VolumeStreamState.class) {
                    int index = mIndexMap.get(device, -1);
                    if (index == -1) {
            // there is always an entry for AudioSystem.DEVICE_OUT_DEFAULT
                        index = mIndexMap.get(AudioSystem.DEVICE_OUT_DEFAULT);
                    }
                    return index;
                }
            }

mIndexMap实际是个数组，不含映射的，记录了device对应的index值。

Step6，sendMsg把消息投到队列，有mAudioHandler处理，一方面把音量值保存到系统设置文件，另一方面调用audiopolicyservice接口调整音频设备的音量。

private void persistVolume(VolumeStreamState streamState, int device) 
    @ AudioHandler$ AudioService.java {
    //把音量值写到系统文件。
    	System.putIntForUser(mContentResolver,
    		streamState.getSettingNameForDevice(device),
    		(streamState.getIndex(device) + 5)/ 10,
    		UserHandle.USER_CURRENT);
    }

调用audiopolicyservice接口的流程：

public void applyDeviceVolume_syncVSS(int device)@ VolumeStreamState $ AudioService.java {
    	AudioSystem.setStreamVolumeIndex(mStreamType, index, device);
    }

setStreamVolumeIndex是native方法。

status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,…)
    @ AudioSystem.cpp {
    	const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
    	return aps->setStreamVolumeIndex(stream, index, device);
    }

IAudioPolicyService对应的服务端的实现：

status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, int index, 
    audio_devices_t device)@AudioPolicyInterfaceImplLegacy.cpp{
    	return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index);
    }

根据前面的分析，mpAudioPolicy的默认实现是legacy\_audio\_policy 结构体中的audio\_policy 。相关实现（create\_legacy\_ap()@audio\_policy\_hal.cpp）；

static int ap_set_stream_volume_index(struct audio_policy *pol, audio_stream_type_t stream,
    	int index)@ audio_policy_hal.cpp {
    	struct legacy_audio_policy *lap = to_lap(pol);
    	return lap->apm->setStreamVolumeIndex((AudioSystem::stream_type)stream,
    		index, AUDIO_DEVICE_OUT_DEFAULT);
    }

setStreamVolumeIndex的最终实现调用了AudioPolicyManagerBase.cpp中接口。

status_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type stream,
    	int index, audio_devices_t device)@ AudioPolicyManagerBase.cpp {
    //根据连接的设备，在所有的输出上计算、应用流音量，
    	for (size_t i = 0; i < mOutputs.size(); i++) {
    		audio_devices_t curDevice = getDeviceForVolume(mOutputs.valueAt(i)->device());
    		if ((device == AUDIO_DEVICE_OUT_DEFAULT) || (device == curDevice)) {
    status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), 
    curDevice);
    			status = volStatus;
    		}
    	}
    	return status;
    }

系统中有多个output，每个output又支持多个device，所以checkAndSetVolume函数，先计算音量，最终会调用Audioflinger的接口完成音量的设置。

主要看跳转到Audioflinger的流程：

status_t AudioPolicyManagerBase::checkAndSetVolume(…)@ AudioPolicyManagerBase.cpp{
    	mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, 
    delayMs);
    }

AudioPolicyClientInterface\*mpClientInterface;是在AudioPolicyManagerBase构造函数中赋值的。调用AudioPolicyManagerBase构造函数的根在audio\_policy\_hal.cpp

static int create_legacy_ap(struct audio_policy_service_ops *aps_ops,…)@ audio_policy_hal.cpp {
    	lap->service_client = new AudioPolicyCompatClient(aps_ops, service);
    //这个函数最终创建了AudioPolicyManagerBase实例。
    	lap->apm = createAudioPolicyManager(lap->service_client);
    }
    status_t AudioPolicyCompatClient::setStreamVolume(…){
    // mServiceOps即是函数create_legacy_ap中的aps_ops。想知道aps_ops是怎么来的，就是要知道谁调用了create_legacy_ap。
    	return mServiceOps->set_stream_volume(mService, (audio_stream_type_t)stream,
    		volume, output, delayMs);
    }

想知道create\_legacy\_ap函数中的参数aps\_ops是怎么来的，就是要知道谁调用了create\_legacy\_ap。

audio\_policy\_hal.cpp

//在打开一个hal层设备时，会执行这个函数：

static int legacy_ap_dev_open(…)@ audio_policy_hal.cpp{
    	dev->device.create_audio_policy = create_legacy_ap;
    }

函数指针create\_audio\_policy指向了create\_legacy\_ap。

AudioPolicyService.cpp

在AudioPolicyService实例第一次被引用时：

void AudioPolicyService::onFirstRef()@AudioPolicyService.cpp{
    //create_legacy_ap函数中的参数aps_op是在这里赋值的（aps_ops）
    	rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this,
    		&mpAudioPolicy);
    }

根据aps\_ops 结构体的定义，set\_stream\_volume实现指向了aps\_set\_stream\_volume。

struct audio_policy_service_ops aps_ops = {
    	.set_stream_volume     = aps_set_stream_volume,
    }

有函数aps\_set\_stream\_volume，经过AudioPolicyService.cpp，经过AudioCommandThread的SET\_VOLUME命令，在经过AudioSystem.cpp，最终实现是在Audioflinger。

status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
            audio_io_handle_t output)@ AudioSystem.cpp {
    	af->setStreamVolume(stream, value, output);
    	const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
    }
    status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
            audio_io_handle_t output)@ AudioFlinger.cpp {
    	PlaybackThread *thread = NULL;
    //根据output找到对应的playbackthread，
    	thread = checkPlaybackThread_l(output);
    //把新的值记录到mStreamTypes中。
    	mStreamTypes[stream].volume = value;
    	thread->setStreamVolume(stream, value);
    }

然后playbackthread对音量值做下记录，在混音线程准备音频数据时，会把playbackthread保存的值提取出来。

Frameworks/av/services/audiofligner/

AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
            Vector< sp<Track> > *tracksToRemove)@ Threads.cpp{
    //读取音量控制的原始值。
    	float typeVolume = mStreamTypes[track->streamType()].volume;
    	float v = masterVolume * typeVolume;
    	vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
    	vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
    //应用主音量和流类型音量。
    	vlf *= v;
    	vrf *= v;
    	mAudioMixer->setParameter(name, param, AudioMixer::VOLUME0, &vlf);
    	mAudioMixer->setParameter(name, param, AudioMixer::VOLUME1, &vrf);
    }

读出之前这种的音量值后，和主音量综合运算，把计算后的值，通过setParameter传给AudioMixer。