ARC1.2-ARC设备音量控制--安卓系统AudioService音量控制接口代码

已于 2025-04-01 17:48:44 修改
阅读量377 收藏 7
点赞数 3
分类专栏： ARC/CEC 文章标签： android
于 2025-03-08 16:48:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43479637/article/details/146117231
版权

代码路径：base/services/core/java/com/android/server/audio/AudioService.java

1、基本参数
1-1、streamType（音频流类型）

![[音频流.png]]

/frameworks/base/media/java/android/media/AudioSystem.java/
public static final int STREAM_VOICE_ CALL = 0； /通话声音/
public static final int STREAM SYSTEM = 1; /* 系统声音*/
public static final int STREAM RING = 2; /电话铃声和短信提示/
public static final int STREAM MUSIC = 3; /音乐播放/
Public static final int STREAM ALARM = 4; /闹铃/
public static final int STREAM_NOTIFICATION = 5； /* 通知声音*/

/下面几个是隐藏类型，不对上层应用开放/
public static final int STREAM BLUETOOTH SCO = 6； /蓝牙通话/
public static final int STREAM SYSTEM ENEORCED = 7； /* 强制的系统声音。比如有的国家强制要求摄像头拍照时有声音，以防止偷拍*/
public static final int STREAM_DTMF = 8; /* DTMF声音*/
public static final int STREAM TTS = 9； /* 即text to speech (TTS）

1-2、index（音量值）
_/** Maximum volume index values for audio streams */_
 protected static int[] MAX_STREAM_VOLUME = new int[] {
     5,  // STREAM_VOICE_CALL
     7,  // STREAM_SYSTEM
     7,  // STREAM_RING            // configured by config_audio_ring_vol_steps
     com.skg.services.manager.SkgVoiceManager.VOLUME_VALUE_MAX, 
     // STREAM_MUSIC
     7,  // STREAM_ALARM
     7,  // STREAM_NOTIFICATION    // configured by config_audio_notif_vol_steps
     15, // STREAM_BLUETOOTH_SCO
     7,  // STREAM_SYSTEM_ENFORCED
     15, // STREAM_DTMF
     15, // STREAM_TTS
     15, // STREAM_ACCESSIBILITY
     15  // STREAM_ASSISTANT
 };

 _/** Minimum volume index values for audio streams */_
 protected static int[] MIN_STREAM_VOLUME = new int[] {
     1,  // STREAM_VOICE_CALL
     0,  // STREAM_SYSTEM
     0,  // STREAM_RING
     0,  // STREAM_MUSIC
     1,  // STREAM_ALARM
     0,  // STREAM_NOTIFICATION
     0,  // STREAM_BLUETOOTH_SCO
     0,  // STREAM_SYSTEM_ENFORCED
     0,  // STREAM_DTMF
     0,  // STREAM_TTS
     1,  // STREAM_ACCESSIBILITY
     0   // STREAM_ASSISTANT
 };
1-3、device（声音输入输出设备）
// input devices
public static final int DEVICE_IN_COMMUNICATION = DEVICE_BIT_IN | 0x1;

public static final int DEVICE_IN_AMBIENT = DEVICE_BIT_IN | 0x2;

public static final int DEVICE_IN_BUILTIN_MIC = DEVICE_BIT_IN | 0x4;

public static final int DEVICE_IN_BLUETOOTH_SCO_HEADSET = DEVICE_BIT_IN | 0x8;

public static final int DEVICE_IN_WIRED_HEADSET = DEVICE_BIT_IN | 0x10;

public static final int DEVICE_IN_AUX_DIGITAL = DEVICE_BIT_IN | 0x20;

public static final int DEVICE_IN_HDMI = DEVICE_IN_AUX_DIGITAL;

public static final int DEVICE_IN_HDMI_1 = DEVICE_BIT_IN | 0x21;
public static final int DEVICE_IN_VOICE_CALL = DEVICE_BIT_IN | 0x40;

//output device
// audio device definitions: must be kept in sync with values in system/core/audio.h
public static final int DEVICE_NONE = 0x0;

public static final int DEVICE_OUT_SPEAKER = 0x2;

public static final int DEVICE_OUT_WIRED_HEADSET = 0x4;

public static final int DEVICE_OUT_WIRED_HEADPHONE = 0x8;

public static final int DEVICE_OUT_BLUETOOTH_SCO = 0x10;

public static final int DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20;

public static final int DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40;

public static final int DEVICE_OUT_BLUETOOTH_A2DP = 0x80;

public static final int DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100;

public static final int DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200;

public static final int DEVICE_OUT_AUX_DIGITAL = 0x400;

public static final int DEVICE_OUT_HDMI = DEVICE_OUT_AUX_DIGITAL;

public static final int DEVICE_OUT_HDMI_1 = 0x401;

public static final int DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800;

public static final int DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000;

public static final int DEVICE_OUT_USB_ACCESSORY = 0x2000;

public static final int DEVICE_OUT_USB_DEVICE = 0x4000;

public static final int DEVICE_OUT_REMOTE_SUBMIX = 0x8000;

public static final int DEVICE_OUT_TELEPHONY_TX = 0x10000;

public static final int DEVICE_OUT_LINE = 0x20000;

public static final int DEVICE_OUT_HDMI_ARC = 0x40000;

public static final int DEVICE_OUT_HDMI_EARC = 0x40001;

public static final int DEVICE_OUT_SPDIF = 0x80000;

public static final int DEVICE_OUT_SPDIF_1 = 0x80001;
1-4、flags（是否显示音量条UI）
FLAG_SHOW_UI
1-5、direction（声音调节方向）
public static final int ADJUST_RAISE = 1;

public static final int ADJUST_LOWER = -1;

public static final int ADJUST_SAME = 0;

public static final int ADJUST_MUTE = -100;

public static final int ADJUST_UNMUTE = 100;

public static final int ADJUST_TOGGLE_MUTE = 101;
1-6、mStreamVolumeAlias[]

设置的是同一组stream音量，分组在Android源码中称之为"别名"，即alias。比如在电话中，5种stream（STREAM_SYSTEM、STREAM_RING、STREAM_NOTIFICATION、STREAM_SYSTEM_ENFORCED、STREAM_DTMF）的alias都是STREAM_RING，那么对应的滑动条即可控制这5种stream的音量
白板对应的是STREAM_VOLUME_ALIAS_DEFAULT

private final int[] STREAM_VOLUME_ALIAS_VOICE = 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  
    AudioSystem.STREAM_MUSIC,           // STREAM_ACCESSIBILITY  
    AudioSystem.STREAM_MUSIC            // STREAM_ASSISTANT  
};  
private final int[] STREAM_VOLUME_ALIAS_TELEVISION = new int[] {  
    AudioSystem.STREAM_MUSIC,       // STREAM_VOICE_CALL  
    AudioSystem.STREAM_MUSIC,       // STREAM_SYSTEM  
    AudioSystem.STREAM_MUSIC,       // STREAM_RING  
    AudioSystem.STREAM_MUSIC,       // STREAM_MUSIC  
    AudioSystem.STREAM_MUSIC,       // STREAM_ALARM  
    AudioSystem.STREAM_MUSIC,       // STREAM_NOTIFICATION  
    AudioSystem.STREAM_BLUETOOTH_SCO,       // STREAM_BLUETOOTH_SCO  
    AudioSystem.STREAM_MUSIC,       // STREAM_SYSTEM_ENFORCED  
    AudioSystem.STREAM_MUSIC,       // STREAM_DTMF  
    AudioSystem.STREAM_MUSIC,       // STREAM_TTS  
    AudioSystem.STREAM_MUSIC,       // STREAM_ACCESSIBILITY  
    AudioSystem.STREAM_MUSIC        // STREAM_ASSISTANT  
};  
private final int[] STREAM_VOLUME_ALIAS_NONE = new int[] {  
    AudioSystem.STREAM_VOICE_CALL,      // STREAM_VOICE_CALL  
    AudioSystem.STREAM_SYSTEM,          // STREAM_SYSTEM  
    AudioSystem.STREAM_RING,            // STREAM_RING  
    AudioSystem.STREAM_MUSIC,           // STREAM_MUSIC  
    AudioSystem.STREAM_ALARM,           // STREAM_ALARM  
    AudioSystem.STREAM_NOTIFICATION,    // STREAM_NOTIFICATION  
    AudioSystem.STREAM_BLUETOOTH_SCO,   // STREAM_BLUETOOTH_SCO  
    AudioSystem.STREAM_SYSTEM_ENFORCED, // STREAM_SYSTEM_ENFORCED  
    AudioSystem.STREAM_DTMF,            // STREAM_DTMF  
    AudioSystem.STREAM_TTS,             // STREAM_TTS  
    AudioSystem.STREAM_ACCESSIBILITY,   // STREAM_ACCESSIBILITY  
    AudioSystem.STREAM_ASSISTANT        // STREAM_ASSISTANT  
};  
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  
    AudioSystem.STREAM_MUSIC,           // STREAM_ACCESSIBILITY  
    AudioSystem.STREAM_MUSIC            // STREAM_ASSISTANT  
};
2、adjustStreamVolume（已当前音量为基础逐级调节）

```java
protected void adjustStreamVolume(int streamType, int direction, int flags,  
        String callingPackage, String caller, int uid, int pid, String attributionTag,  
        boolean hasModifyAudioSettings, int keyEventMode) {  
    if (mUseFixedVolume) {  
        return;  
    }  
    if (DEBUG_VOL) Log.d(TAG, "adjustStreamVolume() stream=" + streamType + ", dir=" + direction  
            + ", flags=" + flags + ", caller=" + caller);  
  
    ensureValidDirection(direction);  
    ensureValidStreamType(streamType);  
  
    boolean isMuteAdjust = isMuteAdjust(direction);  
  
    if (isMuteAdjust && !isStreamAffectedByMute(streamType)) {  
        return;  
    }  
  
    // If adjust is mute and the stream is STREAM_VOICE_CALL or STREAM_BLUETOOTH_SCO, make sure  
    // that the calling app have the MODIFY_PHONE_STATE permission.    
    if (isMuteAdjust &&  
        (streamType == AudioSystem.STREAM_VOICE_CALL ||  
            streamType == AudioSystem.STREAM_BLUETOOTH_SCO) &&  
            mContext.checkPermission(android.Manifest.permission.MODIFY_PHONE_STATE, pid, uid)  
                != PackageManager.PERMISSION_GRANTED) {  
        Log.w(TAG, "MODIFY_PHONE_STATE Permission Denial: adjustStreamVolume from pid="  
                + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());  
        return;    
    }  
  
    // If the stream is STREAM_ASSISTANT,  
    // make sure that the calling app have the MODIFY_AUDIO_ROUTING permission.    
    if (streamType == AudioSystem.STREAM_ASSISTANT &&  
            mContext.checkPermission(  
            android.Manifest.permission.MODIFY_AUDIO_ROUTING, pid, uid)  
                != PackageManager.PERMISSION_GRANTED) {  
        Log.w(TAG, "MODIFY_AUDIO_ROUTING Permission Denial: adjustStreamVolume from pid="  
                + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());  
        return;    
    }  
  
    // use stream type alias here so that streams with same alias have the same behavior,  
	// including with regard to silent mode control (e.g the use of STREAM_RING below and in    
	// checkForRingerModeChange() in place of STREAM_RING or STREAM_NOTIFICATION)     

	int streamTypeAlias = mStreamVolumeAlias[streamType];  
  
    VolumeStreamState streamState = mStreamStates[streamTypeAlias];  
  
    final int device = getDeviceForStream(streamTypeAlias);  
  
    int aliasIndex = streamState.getIndex(device);  
    boolean adjustVolume = true;  
    int step;  
  
    // skip a2dp absolute volume control request when the device  
    // is neither an a2dp device nor BLE device    
    if ((!AudioSystem.DEVICE_OUT_ALL_A2DP_SET.contains(device)  
            && !AudioSystem.DEVICE_OUT_ALL_BLE_SET.contains(device))  
            && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) != 0) {  
        return;  
    }  
  
    // If we are being called by the system (e.g. hardware keys) check for current user  
    // so we handle user restrictions correctly.    
    if (uid == android.os.Process.SYSTEM_UID) {  
        uid = UserHandle.getUid(getCurrentUserId(), UserHandle.getAppId(uid));  
    }  
    // validate calling package and app op  
    if (!checkNoteAppOp(  
            STREAM_VOLUME_OPS[streamTypeAlias], uid, callingPackage, attributionTag)) {  
        return;  
    }  
  
    // reset any pending volume command  
    synchronized (mSafeMediaVolumeStateLock) {  
        mPendingVolumeCommand = null;  
    }  
  
    flags &= ~AudioManager.FLAG_FIXED_VOLUME;  
    if (streamTypeAlias == AudioSystem.STREAM_MUSIC && isFixedVolumeDevice(device)) {  
        flags |= AudioManager.FLAG_FIXED_VOLUME;  
  
        // Always toggle between max safe volume and 0 for fixed volume devices where safe  
        // volume is enforced, and max and 0 for the others.        
        // This is simulated by stepping by the full allowed volume range        
        if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&  
                mSafeMediaVolumeDevices.contains(device)) {  
            step = safeMediaVolumeIndex(device);  
        } else {  
            step = streamState.getMaxIndex();  
        }  
        if (aliasIndex != 0) {  
            aliasIndex = step;  
        }  
    } else {  
        // convert one UI step (+/-1) into a number of internal units on the stream alias  
        step = rescaleStep(10, streamType, streamTypeAlias);  
    }  
  
    // If either the client forces allowing ringer modes for this adjustment,  
    // or the stream type is one that is affected by ringer modes    
    if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||  
            (isUiSoundsStreamType(streamTypeAlias))) {  
        int ringerMode = getRingerModeInternal();  
        // do not vibrate if already in vibrate mode  
        if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {  
            flags &= ~AudioManager.FLAG_VIBRATE;  
        }  
        // Check if the ringer mode handles this adjustment. If it does we don't  
        // need to adjust the volume further.        
        final int result = checkForRingerModeChange(aliasIndex, direction, step,  
                streamState.mIsMuted, callingPackage, flags);  
        adjustVolume = (result & FLAG_ADJUST_VOLUME) != 0;  
        // If suppressing a volume adjustment in silent mode, display the UI hint  
        if ((result & AudioManager.FLAG_SHOW_SILENT_HINT) != 0) {  
            flags |= AudioManager.FLAG_SHOW_SILENT_HINT;  
        }  
        // If suppressing a volume down adjustment in vibrate mode, display the UI hint  
        if ((result & AudioManager.FLAG_SHOW_VIBRATE_HINT) != 0) {  
            flags |= AudioManager.FLAG_SHOW_VIBRATE_HINT;  
        }  
    }  
  
    // If the ringer mode or zen is muting the stream, do not change stream unless  
    // it'll cause us to exit dnd    if (!volumeAdjustmentAllowedByDnd(streamTypeAlias, flags)) {  
        adjustVolume = false;  
    }  
    int oldIndex = mStreamStates[streamType].getIndex(device);  
    Log.d(TAG,"zfp#device = " + device);  
    // Check if the volume adjustment should be handled by an absolute volume controller instead  
    if (isAbsoluteVolumeDevice(device)  
            && (flags & AudioManager.FLAG_ABSOLUTE_VOLUME) == 0) {  
        if (device == AudioSystem.DEVICE_OUT_HDMI_ARC || device == AudioSystem.DEVICE_OUT_HDMI_EARC){  
            Log.d(TAG,"zfp#device is arc device = ");  
        }else {  
            AbsoluteVolumeDeviceInfo info = mAbsoluteVolumeDeviceInfoMap.get(device);  
            if (info.mHandlesVolumeAdjustment) {  
                dispatchAbsoluteVolumeAdjusted(streamType, info, oldIndex, direction,  
                        keyEventMode);  
                return;            }  
        }  
    }  
    Log.d(TAG,"zfp#adjustVolume = " + adjustVolume);  
    if (adjustVolume && (direction != AudioManager.ADJUST_SAME)  
            && (keyEventMode != AudioDeviceVolumeManager.ADJUST_MODE_END)) {  
        mAudioHandler.removeMessages(MSG_UNMUTE_STREAM);  
        if (isMuteAdjust) {  
            boolean state;  
            if (direction == AudioManager.ADJUST_TOGGLE_MUTE) {  
                state = !streamState.mIsMuted;  
            } else {  
                state = direction == AudioManager.ADJUST_MUTE;  
            }  
            for (int stream = 0; stream < mStreamStates.length; stream++) {  
                if (streamTypeAlias == mStreamVolumeAlias[stream]) {  
                    if (!(readCameraSoundForced()  
                                && (mStreamStates[stream].getStreamType()  
                                    == AudioSystem.STREAM_SYSTEM_ENFORCED))) {  
                        mStreamStates[stream].mute(state);  
                    }  
                }  
            }  
        } else if ((direction == AudioManager.ADJUST_RAISE) &&  
                !checkSafeMediaVolume(streamTypeAlias, aliasIndex + step, device)) {  
            Log.e(TAG, "adjustStreamVolume() safe volume index = " + oldIndex);  
            mVolumeController.postDisplaySafeVolumeWarning(flags);  
        } else if ((streamState.adjustIndex(direction * step, device, caller,  
                        hasModifyAudioSettings)  
                        || streamState.mIsMuted)) {  
            // Post message to set system volume (it in turn will post a  
            // message to persist).            if (streamState.mIsMuted) {  
                // Unmute the stream if it was previously muted  
                if (direction == AudioManager.ADJUST_RAISE) {  
                    // unmute immediately for volume up  
                    streamState.mute(false);  
                } else if (direction == AudioManager.ADJUST_LOWER) {  
                    if (mIsSingleVolume) {  
                        sendMsg(mAudioHandler, MSG_UNMUTE_STREAM, SENDMSG_QUEUE,  
                                streamTypeAlias, flags, null, UNMUTE_STREAM_DELAY);  
                    }  
                }  
            }  
            sendMsg(mAudioHandler,  
                    MSG_SET_DEVICE_VOLUME,  
                    SENDMSG_QUEUE,  
                    device,  
                    0,  
                    streamState,  
                    0);  
        }  
  
        int newIndex = mStreamStates[streamType].getIndex(device);  
  
        // Check if volume update should be send to AVRCP  
        if (streamTypeAlias == AudioSystem.STREAM_MUSIC  
                && AudioSystem.DEVICE_OUT_ALL_A2DP_SET.contains(device)  
                && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
            if (DEBUG_VOL) {  
                Log.d(TAG, "adjustSreamVolume: postSetAvrcpAbsoluteVolumeIndex index="  
                        + newIndex + "stream=" + streamType);  
            }  
            mDeviceBroker.postSetAvrcpAbsoluteVolumeIndex(newIndex / 10);  
        } else if (isAbsoluteVolumeDevice(device)  
                && (flags & AudioManager.FLAG_ABSOLUTE_VOLUME) == 0) {  
            AbsoluteVolumeDeviceInfo info = mAbsoluteVolumeDeviceInfoMap.get(device);  
            dispatchAbsoluteVolumeChanged(streamType, info, newIndex);  
        }  
  
        if (AudioSystem.isLeAudioDeviceType(device)  
                && streamType == getBluetoothContextualVolumeStream()  
                && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
            if (DEBUG_VOL) {  
                Log.d(TAG, "adjustSreamVolume postSetLeAudioVolumeIndex index="  
                        + newIndex + " stream=" + streamType);  
            }  
            mDeviceBroker.postSetLeAudioVolumeIndex(newIndex,  
                mStreamStates[streamType].getMaxIndex(), streamType);  
        }  
  
        // Check if volume update should be send to Hearing Aid  
        if (device == AudioSystem.DEVICE_OUT_HEARING_AID) {  
            // only modify the hearing aid attenuation when the stream to modify matches  
            // the one expected by the hearing aid            
            if (streamType == getBluetoothContextualVolumeStream()) {  
                if (DEBUG_VOL) {  
                    Log.d(TAG, "adjustSreamVolume postSetHearingAidVolumeIndex index="  
                            + newIndex + " stream=" + streamType);  
                }  
                mDeviceBroker.postSetHearingAidVolumeIndex(newIndex, streamType);  
            }  
        }  
    }  
  
    final int newIndex = mStreamStates[streamType].getIndex(device);  
    if (adjustVolume) {  
        synchronized (mHdmiClientLock) {  
            if (mHdmiManager != null) {  
                // At most one of mHdmiPlaybackClient and mHdmiTvClient should be non-null  
                HdmiClient fullVolumeHdmiClient = mHdmiPlaybackClient;  
                if (mHdmiTvClient != null) {  
                    fullVolumeHdmiClient = mHdmiTvClient;  
                }  
                if (fullVolumeHdmiClient != null  
                        && mHdmiCecVolumeControlEnabled  
                        && streamTypeAlias == AudioSystem.STREAM_MUSIC  
                        // vol change on a full volume device  
                        && isFullVolumeDevice(device)) {  
                    int keyCode = KeyEvent.KEYCODE_UNKNOWN;  
                    switch (direction) {  
                        case AudioManager.ADJUST_RAISE:  
                            keyCode = KeyEvent.KEYCODE_VOLUME_UP;  
                            break;                        
                        case AudioManager.ADJUST_LOWER:  
                            keyCode = KeyEvent.KEYCODE_VOLUME_DOWN;  
                            break;                        
                        case AudioManager.ADJUST_TOGGLE_MUTE:  
                        case AudioManager.ADJUST_MUTE:  
                        case AudioManager.ADJUST_UNMUTE:  
                            // Many CEC devices only support toggle mute. Therefore, we send the  
                            // same keycode for all three mute options.                            
                            keyCode = KeyEvent.KEYCODE_VOLUME_MUTE;  
                            break;                        
                        default:  
                            break;  
                    }  
                    Log.d(TAG,"zfp#keyCode = " + keyCode);  
                    if (keyCode != KeyEvent.KEYCODE_UNKNOWN) {  
                        final long ident = Binder.clearCallingIdentity();  
                        try {  
                            switch (keyEventMode) {  
                                case AudioDeviceVolumeManager.ADJUST_MODE_NORMAL:  
                                    fullVolumeHdmiClient.sendVolumeKeyEvent(keyCode, true);  
                                    fullVolumeHdmiClient.sendVolumeKeyEvent(keyCode, false);  
                                    break;                                
                                case AudioDeviceVolumeManager.ADJUST_MODE_START:  
                                    fullVolumeHdmiClient.sendVolumeKeyEvent(keyCode, true);  
                                    break;                                
                                case AudioDeviceVolumeManager.ADJUST_MODE_END:  
                                    fullVolumeHdmiClient.sendVolumeKeyEvent(keyCode, false);  
                                    break;                               
                                default:  
                                    Log.e(TAG, "Invalid keyEventMode " + keyEventMode);  
                            }  
                        } finally {  
                            Binder.restoreCallingIdentity(ident);  
                        }  
                    }  
                }  
  
                if (streamTypeAlias == AudioSystem.STREAM_MUSIC  
                        && (oldIndex != newIndex || isMuteAdjust)) {  
                    maybeSendSystemAudioStatusCommand(isMuteAdjust);  
                }  
            }  
        }  
    }  
    sendVolumeUpdate(streamType, oldIndex, newIndex, flags, device);  
}

#### 3、setStreamVolume（设置音量为指定的值）


private void setStreamVolume(int streamType, int index, int flags,  
        @Nullable AudioDeviceAttributes ada,  
        String callingPackage, String caller, String attributionTag, int uid,  
        boolean hasModifyAudioSettings) {  
    if (DEBUG_VOL) {  
        Log.d(TAG, "setStreamVolume(stream=" + streamType+", index=" + index  
                + ", dev=" + ada  
                + ", calling=" + callingPackage + ")");  
    }  
    if (mUseFixedVolume) {  
        return;  
    }  
  
    ensureValidStreamType(streamType);  
    int streamTypeAlias = mStreamVolumeAlias[streamType];  
    VolumeStreamState streamState = mStreamStates[streamTypeAlias];  
  
    final int device = (ada == null)  
            ? getDeviceForStream(streamType)  
            : ada.getInternalType();  
    int oldIndex;  
  
    // skip a2dp absolute volume control request when the device  
    // is neither an a2dp device nor BLE device    
    if ((!AudioSystem.DEVICE_OUT_ALL_A2DP_SET.contains(device)  
            && !AudioSystem.DEVICE_OUT_ALL_BLE_SET.contains(device))  
            && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) != 0) {  
        return;  
    }  
    // If we are being called by the system (e.g. hardware keys) check for current user  
    // so we handle user restrictions correctly.    
    if (uid == android.os.Process.SYSTEM_UID) {  
        uid = UserHandle.getUid(getCurrentUserId(), UserHandle.getAppId(uid));  
    }  
    if (!checkNoteAppOp(  
            STREAM_VOLUME_OPS[streamTypeAlias], uid, callingPackage, attributionTag)) {  
        return;  
    }  
  
    if (isAndroidNPlus(callingPackage)  
            && wouldToggleZenMode(getNewRingerMode(streamTypeAlias, index, flags))  
            && !mNm.isNotificationPolicyAccessGrantedForPackage(callingPackage)) {  
        throw new SecurityException("Not allowed to change Do Not Disturb state");  
    }  
  
    if (!volumeAdjustmentAllowedByDnd(streamTypeAlias, flags)) {  
        return;  
    }  
  
    synchronized (mSafeMediaVolumeStateLock) {  
        // reset any pending volume command  
        mPendingVolumeCommand = null;  
  
        oldIndex = streamState.getIndex(device);  
  
        index = rescaleIndex(index * 10, streamType, streamTypeAlias);  
  
        if (streamTypeAlias == AudioSystem.STREAM_MUSIC  
                && AudioSystem.DEVICE_OUT_ALL_A2DP_SET.contains(device)  
                && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
            if (DEBUG_VOL) {  
                Log.d(TAG, "setStreamVolume postSetAvrcpAbsoluteVolumeIndex index=" + index  
                        + "stream=" + streamType);  
            }  
            mDeviceBroker.postSetAvrcpAbsoluteVolumeIndex(index / 10);  
        } else if (isAbsoluteVolumeDevice(device)  
                && ((flags & AudioManager.FLAG_ABSOLUTE_VOLUME) == 0)) {  
            AbsoluteVolumeDeviceInfo info = mAbsoluteVolumeDeviceInfoMap.get(device);  
  
            dispatchAbsoluteVolumeChanged(streamType, info, index);  
        }  
  
        if (AudioSystem.isLeAudioDeviceType(device)  
                && streamType == getBluetoothContextualVolumeStream()  
                && (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {  
            if (DEBUG_VOL) {  
                Log.d(TAG, "adjustSreamVolume postSetLeAudioVolumeIndex index="  
                        + index + " stream=" + streamType);  
            }  
            mDeviceBroker.postSetLeAudioVolumeIndex(index,  
                mStreamStates[streamType].getMaxIndex(), streamType);  
        }  
  
        if (device == AudioSystem.DEVICE_OUT_HEARING_AID  
                && streamType == getBluetoothContextualVolumeStream()) {  
            Log.i(TAG, "setStreamVolume postSetHearingAidVolumeIndex index=" + index  
                    + " stream=" + streamType);  
            mDeviceBroker.postSetHearingAidVolumeIndex(index, streamType);  
        }  
  
        flags &= ~AudioManager.FLAG_FIXED_VOLUME;  
        if (streamTypeAlias == AudioSystem.STREAM_MUSIC && isFixedVolumeDevice(device)) {  
            flags |= AudioManager.FLAG_FIXED_VOLUME;  
  
            // volume is either 0 or max allowed for fixed volume devices  
            if (index != 0) {  
                if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&  
                        mSafeMediaVolumeDevices.contains(device)) {  
                    index = safeMediaVolumeIndex(device);  
                } else {  
                    index = streamState.getMaxIndex();  
                }  
            }  
        }  
  
        if (!checkSafeMediaVolume(streamTypeAlias, index, device)) {  
            mVolumeController.postDisplaySafeVolumeWarning(flags);  
            mPendingVolumeCommand = new StreamVolumeCommand(  
                                                streamType, index, flags, device);  
        } else {  
            onSetStreamVolume(streamType, index, flags, device, caller, hasModifyAudioSettings);  
            index = mStreamStates[streamType].getIndex(device);  
        }  
    }  
    synchronized (mHdmiClientLock) {  
        if (streamTypeAlias == AudioSystem.STREAM_MUSIC  
                && (oldIndex != index)) {  
            maybeSendSystemAudioStatusCommand(false);  
        }  
    }  
    sendVolumeUpdate(streamType, oldIndex, index, flags, device);  
}
4、isStreamMute（获取当前流静音状态）

```java

```java
public boolean isStreamMute(int streamType) {  
    if (streamType == AudioManager.USE_DEFAULT_STREAM_TYPE) {  
        streamType = getActiveStreamType(streamType);  
    }  
    synchronized (VolumeStreamState.class) {  
        ensureValidStreamType(streamType);  
        return mStreamStates[streamType].mIsMuted;  
    }  
}
5、getStreamVolume（获取当前流音量值）
public int getStreamVolume(int streamType) {  
    ensureValidStreamType(streamType);  
    int device = getDeviceForStream(streamType);  
    synchronized (VolumeStreamState.class) {  
        int index = mStreamStates[streamType].getIndex(device);  
  
        // by convention getStreamVolume() returns 0 when a stream is muted.  
        if (mStreamStates[streamType].mIsMuted) {  
            index = 0;  
        }  
        if (index != 0 && (mStreamVolumeAlias[streamType] == AudioSystem.STREAM_MUSIC) &&  
                isFixedVolumeDevice(device)) {  
            index = mStreamStates[streamType].getMaxIndex();  
        }  
        return (index + 5) / 10;  
    }  
}





#### 6、各接口的具体流程请参考AudioService.xmind
![[AudioService.xmind]]
Android Audio音量——音量调节基础（一）
小旭的专栏
06-09 1745
前面的文章中提到过，AudioService 的主要功能之一就是负责调节音量，这一篇文章主要详细介绍一下 AudioService 中音量调节相关的知识点。
Android Audio基础——系统服务（二）
小旭的专栏
05-10 1540
AudioService 继承自 IAudioService.Stub。IAudioService.Stub 类很明显是通过 IAudioService.aidl 自动生成的。AudioService 位于 Binder Native 端。AudioManager 拥有 AudioService 的 Binder Proxy 端，是 AudioService 在客户端的一个代理。几乎所有客户端对 AudioManager 进行的请求，最终都会交由 AudioService 实现。
36-Android之恢复出厂设置STREAM_VOICE_CALL通话音量为0的问题
陌上
11-10 1662
36-Android恢复出厂设置STREAM_VOICE_CALL通话音量为0的问题 平台: MTK 6739 Android10 测试人员发现, 设备在恢复出厂设置之后, 通话音量变为0. 通过排查发现, 在AudioService中STREAM_VOICE_CALL初始化设置的时候出现错误. 类: frameworks/base/services/core/java/com/android/server/audio/AudioService.java public AudioService(Conte
Android 9 按音量键音量调节流程
suwen8100的博客
05-12 3454
安卓音量调节
【音频系列】——音量调节、音量增益修改与通信音量无法静音的问题
carolven的博客
02-12 9121
一、标准Android系统（基于Android M，其他基本也是这样）音量调节基本流程: 见大神三部曲 1、[RK3288][Android6.0] Audio的音量设置流程小结 ：http://blog.csdn.net/kris_fei/article/details/72929999 简明梳理了音量设置代码流程 2、[RK3288][Android6.0] Audio的音量计算过程小...
Android音量调节（一）音量键的处理流程
m0_59157760的博客
07-14 4558
1.Android音量键调节音量流程 整个流程分析是基于Android 8.0来进行讲解的 2.Android流定义 在Android系统中，音量都是分开控制的，比如媒体音量，铃声音量，闹钟音量，蓝牙音量，通话音量都是分开控制的。各种音量都是通过音频流来区别不同音量类型的。在Android 8.0里面，一共定义了11种流的类型，每种流类型都定义了最大音量（MAX_STREAM_VOLUME），最小音量（MIN_STREAM_VOLUME），以及默认音量（DEFAULT_STREAM_VOLUME），细
初学Android,音频管理器之控制音频(六十六)
热门推荐
lee576的专栏
10-10 1万+
下面要写的是AudioManager这个音频管理器,它可以通过getSystemService得到有一个重要方法adjustStreamVolumn(int streamType,int direction,int flags)streamType 这个参数指定了声音的类型，如下STREAM_ALARM:手机闹铃声音STREAM_DTMF:DTMF音调的声音STREAM_MUSIC:手机音乐的声音
Android 音量调节（二）-Android10 音量调节源码实现流程
最新发布
03-19 2999
上一篇文章描述了在app开发中怎么调节系统不同音频流的音量大小。这次我们看下在android10中系统调节音量的实现和系统默认音量的修改。（本次源码以Android10为主）
android 音量 广播,Android平台音量调节（一）音量键调节音量
weixin_32799203的博客
05-25 2082
Android平台音量调节本文基于Android 8.0讲述Android平台原生音量控制功能。流的定义Android中，音量都是分开控制，各种流定义各种流的音量。在Android8.0中，定义了11种流类型。对每种流类型都定义了最大音量(MAX_STREAM_VOLUME)，默认音量(DEFAULT_STREAM_VOLUME)和最小音量(MIN_STREAM_VOLUME)。一个流也可以用另外...
Audio声音模式定制--声音大小定制
十年饮冰，难凉热血
08-28 4970
实际场景： 应付客户电子产品的3C认证，声音大小必须小于85DB，但是产品以K歌为特色，外响声音必须大。 解决思路： 设备定义两个声音模式，承认模式和儿童模式。成人模式的音量为原始音量，儿童模式的音量最大值为原始音量最大值得一半，或者更小 解决方案： 自己应用层实现，音量条最大值是自己定义的。 直接系统层Framework层，在Audio层写代码，定制自己的功能。 说明：方案一太LowB,下面...
Android音频子系统，音量的调节控制（七）
lin20080410的专栏
11-15 5478
音量的调节控制： 按下音量的加减键，对应的keyevent是：KEYCODE_VOLUME_DOWN，KEYCODE_VOLUME_UP。 主要看两个地方对这一事件的处理，一是：handleKeyDown()@AudioManager.java，一是： interceptKeyBeforeQueueing ()@PhoneWindowManager.java。   先看AudioMana
Android 音频管理AudioManager使用
废墟的树的专栏
10-29 7437
1.api解析 2.api使用 1.音频的三种模式（静音，震动，响铃） 2.音频的分类（电话，通知，媒体，闹钟） 3.音频单独控制（控制是通知，电话静音，震动等） 3.实用场景
Android音频框架相关概念理解
虎哥LoveDroid
11-16 850
1. 音频驱动设备 底层相关背景知识，主要是pcm设备和mix设备： 其中pcm设备是音频数据的采集/输出设备，mix设备是音频通道，音量增益控制相关的设备，所有的音频相关的逻辑最终都是在和这两个设备打交道。因此从系统设计角度来说，不可能让每个应用都自己去操作这些音频设备。自然地，Android框架层会去承担这个管理者的角色，然后每个应用都去和框架打交道即可。另一方面，应用开发者并不需要理解这些底层设备，那么Android就抽象了一些更容易懂的概念，比如有了stream, strategy等。下文主要是讲
RTMP语音通讯
qq_24477797的博客
09-17 4271
前言 最近在搞即时语音聊天的功能，经过几个月的努力，目前基本稳定，达到了可以上线的标准，在此写篇博客记录下。 客户端采用rtmp协议做推流和拉流，在网络稳定的情况下，实测延迟在200ms～500ms。 RTMP/RTSP协议说明 RTMP仅支持TCP协议、RTSP支持TCP和UDP两种协议。针对推流端，不管使用RTMP还是RTSP都需要使用TCP协议，以保证源头数据的正确性。拉流端如...
音视频开发之旅（三）AudioTrack播放PCM音频
yabin的专栏
10-14 2499
目录 AudioTrack和MediaPlayer AudioTrack的API介绍（构造、操作、状态机） 具体实现（Static和Stream两种模式） 遇到的问题 收获 一、MediaPlayer和AudioTrack Android SDK 中提供了三种播放声音的API，常见的是MediaPlayer和AudioTrack 其中AudioTrack管理、播放单一音频资源。可以将PCM音频数据传输到音频接收器，以供播放，只能播放源码流即PCM，wav封
android 蓝牙sco stream_voice_call,bluetooth - how to: use AudioManager startBluetoothSco() function in...
weixin_39650756的博客
05-30 302
The link you provided to the Android SDK docs says the following:"... if a SCO connection is established, the following restrictions apply on audio output streams so that they can be routed to SCO hea...
Android音量相关知识总结（三）调节音量流程梳理
xiangzaixiansheng的博客
03-21 2652
一、在响铃过程中，按音量键或者电源键停止铃声 二、调节音量流程梳理 三、相关文章推荐 一、在响铃过程中，按音量键或者电源键停止铃声 这里的逻辑一般都没有修改的，这里我们只做了解。首先会被PhoneWindowManager.java方法接受到。 frameworks/base/services/core/java/com/android/server/policy/PhoneWind...
Android Framework 音频子系统（02）音频系统框架
wangdsh的博客
04-13 6997
​本章节主要关注➕ 以上思维导图下边 音频系统框架 部分 即可。主要是对音频系统框架 有一个基本的认识。1 Android 音频系统框架简介音频系统的 整个框架图如下所示：​针对这张框架图。AudioFlinger：接收多个APP的数据，合并下发；是策略的执行者，例如具体如何与音频设备通信，如何维护现有系统中的音频设备，以及多个音频流的混音如何处理等等都得由它来完 成。AudioPolicyService：决定选择哪个设备输出，接上耳机用耳机，接上蓝牙设备用蓝牙；
Android原生音量控制深度解析与代码示例
本文详细解析了Android原生音量控制的相关实践，重点聚焦于AudioService在音量管理中的核心角色。首先，AudioService的核心组件是VolumeStreamState，它负责存储各个流类型的音量信息，包括运行时的音量值。音量调整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值