Android Audio音量设置原理流程分析

setStreamVolume(int streamType, int index, int flags)
index：音量等级，通常在0~31这个设置范围，音量可以突变设置，如上次音量为1，下次设置音量为5

adjustStreamVolume(int streamType, int direction, int flags)

direction：音量调整方向ADJUST_LOWER，ADJUST_RAISE，ADJUST_SAME，类似于每次只加/减一，匀速调整

最后，音量设置是针对音频流类型来设置的，而streamType是系统规定(在AudioSystem中)的音频流类型，如下：

public static final int STREAM_DEFAULT = -1;
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;
/** Used to identify the volume of audio streams for enforced system sounds in certain
* countries (e.g camera in Japan) */
@UnsupportedAppUsage
public static final int STREAM_SYSTEM_ENFORCED = 7;
/** Used to identify the volume of audio streams for DTMF tones */
public static final int STREAM_DTMF = 8;
/** Used to identify the volume of audio streams exclusively transmitted through the
*  speaker (TTS) of the device */
public static final int STREAM_TTS = 9;
/** Used to identify the volume of audio streams for accessibility prompts */
public static final int STREAM_ACCESSIBILITY = 10;

AudioService中音量处理

在分析AudioService的setStreamVolume和adjustStreamVolume函数之前，需要先掌握AudioService内部的几个知识点，这对我们分析音量设置极为重要；

mUseFixedVolume和mFixedVolumeDevices 固定音量

mSafeMediaVolumeDevices安全音量设备

STREAM_VOLUME_ALIAS 简称音频音量别名

VolumeStreamState 是AudioService的一个内部类
AudioService内部知识点理解
mUseFixedVolume和mFixedVolumeDevices固定音量
mUseFixedVolume状态标志来源于：framework的config.xml内的配置字com.android.internal.R.bool.config_useFixedVolume，如果true，则所有的设备都不可进行音量调节，音量值为max值
mFixedVolumeDevices：是一个数组，里面是输出设备out device集合，在此范围内的设备不可进行音量调节，音量值取值max
mSafeMediaVolumeDevices安全音量设备
所谓安全音量设备，它也是一个输出设备集合数组，包含了耳机相关输出设备；在改变音量时或插入耳机设备时，防止音量突变过大，对人耳造成伤害；如手机上music的音量设置到最大值，当我们插上耳机戴上时，如果音量仍不变保持最大输出，听力可能会受损，这时这个安全音量设备就其作用了，插入耳机时音量值变为安全音量值，保护我们的听力
音频音量别名
音频音量别名是一个数组，在AudioService中定义，数组内部还是由streamType组成，如下：
```
private final int[] STREAM_VOLUME_ALIAS_DEFAULT = 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_RING,            // STREAM_SYSTEM_ENFORCED
    AudioSystem.STREAM_RING,            // STREAM_DTMF
    AudioSystem.STREAM_MUSIC,           // STREAM_TTS
    AudioSystem.STREAM_MUSIC            // STREAM_ACCESSIBILITY
}; 
```
如何获取某个streamType的音频音量别名呢？
数组取值，如STREAM_VOLUME_ALIAS_DEFAULT[STREAM_TTS]得到的别名是AudioSystem.STREAM_MUSIC；
那它有什么作用呢？
就是在设置音量时，将不同音频流进行分组来处理他们的音量；因为在不同设备上，不同类型音频流管理一致，如Android TV设备，STREAM_MUSIC和STREAM_RING音量管理方式是一样的
VolumeStreamState
概念
它是AudioService内部的音量状态管理类，以streamType为单位，每一种音频流，都会创建一个VolumeStreamState内部对象，App应用层设置某个streamType的音量时，就会调用它对应的VolumeStreamState对象来处理音量，分析一下它的创建过程，如下：
```
private void createStreamStates() {
   // 一共11个types，定义在Audioystem中
   int numStreamTypes = AudioSystem.getNumStreamTypes();
   VolumeStreamState[] streams = mStreamStates = new VolumeStreamState[numStreamTypes];
   //相当于mStreamStates实实在在有numStreamTypes个，但是内部的name可能是相同的
   for (int i = 0; i  
getNumStreamTypes获取streamType的数量11个，创建11个VolumeStreamState对象
i其实就对应streamType，mStreamVolumeAlias[i]就是取streamType的音频音量别名，VOLUME_SETTINGS_INT就是转换为字符串名字
VolumeStreamState构造方法 
private class VolumeStreamState {
   private final int mStreamType;
   private int mIndexMin;  //最小音量等级
   private int mIndexMax;	//最大音量等级
   private boolean mIsMuted;  //是否静音
   private String mVolumeIndexSettingName;
   private int mObservedDevices;
   //保存了每个device的音量等级index值
   private final SparseIntArray mIndexMap = new SparseIntArray(8);
   private final Intent mVolumeChanged;
   private final Intent mStreamDevicesChanged;
   //settingName来源于Settings.java中的VOLUME_SETTINGS_INT数组，如字符串volume_music、volume_voice等
   private VolumeStreamState(String settingName, int streamType) {
       mVolumeIndexSettingName = settingName;
       mStreamType = streamType;
       /* 默认是min-0 max-31，但是在AudioService构造方法中，已经获取了每个streamType的indexMin和indexMax;
       * ,所以这里MIN_STREAM_VOLUME和MAX_STREAM_VOLUME是实际值，而不是默认值；
       * 乘10扩大倍数，防止浮点型计算*/
       mIndexMin = MIN_STREAM_VOLUME[streamType] * 10;
       mIndexMax = MAX_STREAM_VOLUME[streamType] * 10;
       //实质是设置VolumeCurves对象的mIndexMin和mIndexMax成员
       AudioSystem.initStreamVolume(streamType, mIndexMin / 10, mIndexMax / 10);
       readSettings();
       .......
   }
}
 以上这种VolumeStreamState创建对象有11个，不同的VolumeStreamState对应，其内部的mVolumeIndexSettingName可能有相同的，但是streamType是唯一的；
mIndexMin和mIndexMax表示此类streamType音量等级调节的范围，不能超过此范围，这个值min和max其实来源于音量曲线文件中的配置，和标签的值如下：
        oem_traffic_anouncement
        0
        40
        
            0,-4200
            33,-2800
            66,-1400
            100,0
        

 那它是怎么获取得到这个值，建议先看看我这边文章Audio解析strategy配置文件，解析strategy配置文件，得到strategy与volumeGroup数据的连接关系；从streamType获取到attribute，在从attribute获取到volumeGroup，然后就拿到volumeGroup的indexMin和indexMax了。
3. mIndexMap是map结构，key对应device，value对应音量等级index，device对应了AudioSystem.DEVICE_OUT_ALL许多设备，如DEVICE_OUT_EARPIECE、DEVICE_OUT_SPEAKER等等，也就是说每个每个VolumeStreamState保存了所有输出设备的音量等级index
VolumeStreamState之read_settings
读取配置，也就是为VolumeStreamState的部分成员赋值，具体代码如下：
 public void readSettings() {
  synchronized (mSettingsLock) {
      synchronized (VolumeStreamState.class) {
          // force maximum volume on all streams if fixed volume property is set
          if (mUseFixedVolume) {
              //DEVICE_OUT_DEFAULT应该是默认设备的默认音量
              mIndexMap.put(AudioSystem.DEVICE_OUT_DEFAULT, mIndexMax);
              return;
          }
          // do not read system stream volume from settings: this stream is always aliased
          // to another stream type and its volume is never persisted. Values in settings can
          // only be stale values
          if ((mStreamType == AudioSystem.STREAM_SYSTEM) ||
                  (mStreamType == AudioSystem.STREAM_SYSTEM_ENFORCED)) {
              //如果stream是系统类型，则从读取系统中此类型的默认音量,默认都是12
              int index = 10 * AudioSystem.DEFAULT_STREAM_VOLUME[mStreamType];
              if (mCameraSoundForced) {
                  index = mIndexMax;
              }
              //此streamType下，无论任何输出设备，音量都是固定值
              mIndexMap.put(AudioSystem.DEVICE_OUT_DEFAULT, index);
              return;
          }
      }
  }
	synchronized (VolumeStreamState.class) {
      //DEVICE_OUT_ALL是所有设备的输出或的结果，每个设备device占一个bit，如A设备为0x01 B设备0x02 C设备0x04这样依次，或之后的结果互不冲突
      int remainingDevices = AudioSystem.DEVICE_OUT_ALL;
      for (int i = 0; remainingDevices != 0; i++) {
         //依次取出每一个device设备
          int device = (1 
              continue;
          }
         //从remainingDevices设备集合中剔除掉当前这个device
          remainingDevices &= ~device;
          // retrieve current volume for device
          // if no volume stored for current stream and device, use default volume if default
          // device, continue otherwise
          int defaultIndex = (device == AudioSystem.DEVICE_OUT_DEFAULT) ?
                  AudioSystem.DEFAULT_STREAM_VOLUME[mStreamType] : -1;
          int index;
          //不是有效的名字，null或空字符
          if (!hasValidSettingsName()) {
              index = defaultIndex;
          } else {
              //为这个的device拿到自己的字符串名字，是一个组合名字，stream类型家输出设备，如stream_music_speaker、stream_music_earpiece等
              String name = getSettingNameForDevice(device);
              //通过ContentResolver方式获取上次保存的index
              index = Settings.System.getIntForUser(
                      mContentResolver, name, defaultIndex, UserHandle.USER_CURRENT);
          }
          if (index == -1) {
              continue;
          }
         //getValidIndex确保index在indexMin和indexMax范围之间的合法值
          mIndexMap.put(device, getValidIndex(10 * index));
      }
  }
}

	if (mUseFixedVolume) {
	    return;
	}
	.......
	
	boolean isMuteAdjust = isMuteAdjust(direction);
	if (isMuteAdjust && !isStreamAffectedByMute(streamType)) {
	    return;
	}
	.........
	//获取别名
	int streamTypeAlias = mStreamVolumeAlias[streamType];
	//获取volumeStreamState
	VolumeStreamState streamState = mStreamStates[streamTypeAlias];
	//获取stream的输出设备
	final int device = getDeviceForStream(streamTypeAlias);
	//获取此stream的这个输出设备的音量等级index
	int aliasIndex = streamState.getIndex(device);
	boolean adjustVolume = true;
	int step;
	.......
	
	// reset any pending volume command
	synchronized (mSafeMediaVolumeStateLock) {
	    mPendingVolumeCommand = null;
	}
	flags &= ~AudioManager.FLAG_FIXED_VOLUME;
	if ((streamTypeAlias == AudioSystem.STREAM_MUSIC) &&
	        ((device & mFixedVolumeDevices) != 0)) {
	    flags |= AudioManager.FLAG_FIXED_VOLUME;
	    //media safe安全状态是否激活，并且device又属于安全设备范围headset headphone
	    if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&
	            (device & mSafeMediaVolumeDevices) != 0) {
	        //获取耳机设备的最大安全音量，防止声音突变对耳朵造成伤害
	        step = safeMediaVolumeIndex(device);
	    } else {
	        //不在safe状态或不属于safedevice，就拿它的最大音量等级
	        step = streamState.getMaxIndex();
	    }
	    if (aliasIndex != 0) {
	        aliasIndex = step;
	    }
	} else {
	    //又可能上层streamType和streamTypeAlias不一样，这种情况在不同设备上，比如TV设备，music、voice对应的alias都属于music
	    step = rescaleIndex(10, streamType, streamTypeAlias);
	}
    //flag和uiSoundStreamType符合就要处理RingMode，uiSound就是获取Stream_system的别名
	if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||
	        (streamTypeAlias == getUiSoundsStreamType())) {
        //获取当前ringmode模式
	    int ringerMode = getRingerModeInternal();
	    // 如果已经是vibrator震动模式，就没必要再次设置震动了
	    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;
	    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);
	
	//不等于ADJUST_SAME说明声音要作出改变，如何改变就是要看他的direction
	if (adjustVolume && (direction != AudioManager.ADJUST_SAME)) {
	    mAudioHandler.removeMessages(MSG_UNMUTE_STREAM);
	
	    if (isMuteAdjust) {
	        boolean state;
	        //就是与之前的mute取反向操作
	        if (direction == AudioManager.ADJUST_TOGGLE_MUTE) {
	            state = !streamState.mIsMuted;
	        } else {
	            state = direction == AudioManager.ADJUST_MUTE;
	        }
	        if (streamTypeAlias == AudioSystem.STREAM_MUSIC) {
	            //设置是否mute
	            setSystemAudioMute(state);
	        }
	        for (int stream = 0; stream  applyAllVolumes，直接看最后的方法： 
public void applyAllVolumes() {
    final boolean isAvrcpAbsVolSupported = mDeviceBroker.isAvrcpAbsoluteVolumeSupported();
    synchronized (VolumeStreamState.class) {
        // apply device specific volumes first
        int index;
        for (int i = 0; i  
i. 因为这里处理的mute和unmute，所以针对的所有的设备，故会遍历mIndexMap中的所有device，依次为其调整音量；如果是mute，index就是0；unmute则为之前保存的音量加5除10，不清楚为何要加5？  除10好理解因为VolumeStreamState内的index整体都扩大10倍了，setStreamVolumeIndex向下底层设置音量时要缩小10倍
ii. 不论怎么处理，最后都是调用setStreamVolumeIndex方法，走到这个方法后，后续的方法基本和AudioService不会有交集了，所以这里暂不往下分析，把AudioService分析完成。
 最后，这里总结就是： mute就是音量等级index设置为0，unmute就是从mIndexMap中获取之前保存的音量等级index，并加5除10，最后调用setStreamVolumeIndex向下设置音量
第三个条件处理策略：关键点在于条件中的判断streamState.adjustIndex就已经把音量等级index设置到indexMap集合中去了
if (((device & mFullVolumeDevices) == 0)
                    && (streamState.adjustIndex(direction * step, device, caller)
                            || streamState.mIsMuted)) 
 direction取值有：ADJUST_LOWER(-1)、ADJUST_RAISE(1)、ADJUST_SAME(0)，还有几个mute和unmute取值，但是那种情况不会进入到这里，而step又是前面10转换而来的，也就是index这里每次以10/-10向上或向下进行调整，进入adjustIndex方法：
 public boolean adjustIndex(int deltaIndex, int device, String caller) {
    //之前的音量加上这次变化的音量10/-10
    return setIndex(getIndex(device) + deltaIndex, device, caller);
}
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;
    }
}
//设在音量等级
public boolean setIndex(int index, int device, String caller) {
    boolean changed;
    int oldIndex;
    synchronized (mSettingsLock) {
        synchronized (VolumeStreamState.class) {
            oldIndex = getIndex(device);
            index = getValidIndex(index);       //index必须在min和max等级范围中
            if ((mStreamType == AudioSystem.STREAM_SYSTEM_ENFORCED) && mCameraSoundForced) {
                index = mIndexMax;
            }
            //将新的音量等级index设置到map中
            mIndexMap.put(device, index);
            changed = oldIndex != index;  //音量等级是否有变化
            
            final boolean isCurrentDevice = (device == getDeviceForStream(mStreamType));
            final int numStreamTypes = AudioSystem.getNumStreamTypes();
            for (int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {
                final VolumeStreamState aliasStreamState = mStreamStates[streamType];
                //跳过自己  寻找alias别名与自己相同 且也拥有此设备device的volumestate，并为其设置index
                if (streamType != mStreamType &&
                        mStreamVolumeAlias[streamType] == mStreamType &&
                        (changed || !aliasStreamState.hasIndexForDevice(device))) {
                    final int scaledIndex = rescaleIndex(index, mStreamType, streamType);
                        //mStreamStates数组中，其他不同流类型streamType，但是映射到alias里面流相同的设置相同的device一下，
                    aliasStreamState.setIndex(scaledIndex, device, caller);
                    if (isCurrentDevice) {
                        aliasStreamState.setIndex(scaledIndex,
                                getDeviceForStream(streamType), caller);
                    }
                }
            }
            // Mirror changes in SPEAKER ringtone volume on SCO when
            if (changed && mStreamType == AudioSystem.STREAM_RING
                    && device == AudioSystem.DEVICE_OUT_SPEAKER) {
                for (int i = 0; i  
细节看代码中的注释，最主要的是把新的音量等级设置到indexMap集合中，同时再遍历所有VolumeStreamState对象，别名和自己相同的对象，也要为其设置音量等级，为什么呢？
我的理解，因为相同streamType，他们的输出device可能也是一样的，所以它的音量也应该要改变才对；
后续的第三个条件中的处理，也是根据direction判断是raise还是lower音量，然后发送sendMsg对应的消息，进行处理，同条件if一是一样的，最后也是调用setStreamVolumeIndex向下设置音量。 
setStreamVolume 
设置过程同adjustStreamVolume相差无几，在此就略过，如果需要可以找我要一份相关添加注释的代码，里面有详细的批注解答！ 
AudioService章节总结 
1）利用设置的音频流类型streamType找到对应的音量状态管理类VolumeStreamState，此类集合的音量管理的核心方法，内部有一个map集合保存了所有输出设备及其对应的音量等级index，最终也是调整这个index
2）同时使用streamType根据strategy找到对应的输出设备，为此设备device设置index
3）一旦某个VolumeStreamState音量做出了调整，则需要把别名相同的另一个VolumeStreamState也要进行音量调整
4）其他就是要处理RingMode、fix固定音量和safe安全音量的问题
5）音量等级设置好后，就是向下调用setStreamVolumeIndex方法，进行音量等级到分贝的处理 
AudioPolicyManager音量调整 
记住，上面AudioService最后向下调用setStreamVolumeIndex函数传递的重要参数是：
1）输出设备device； 2）音量等级index； 
分析AudioPolicyManager模块的音量设置之前建议先阅读Audio解析strategy配置文件文章，因为这块涉及了很多strategy策略、VolumeCurves音量曲线概念，以及他们之间的依赖连接关系； 
setStreamVolumeIndex 
status_t AudioPolicyManager::setStreamVolumeIndex(audio_stream_type_t stream,
   int index,
   audio_devices_t device)
{
    auto attributes = mEngine->getAttributesForStreamType(stream);
    ALOGV("%s: stream %s attributes=%s", __func__,
          toString(stream).c_str(), toString(attributes).c_str());
    return setVolumeIndexForAttributes(attributes, index, device);
}
 这块代码主要是将streamType转换到他对应的属性attribute，然后调用setVolumeIndexForAttributes函数继续往下设置，那streamType怎么转换得到的attribute呢？
答案就是系统启动时解析strategy和VolumeCurves配置文件得到的strategy和VolumeCurves的数据依赖关系，利用这个依赖关系得到的：
streamType–>productStrategy–>遍历其内部所有的attribute，若它内部的streamType与传入的streamType相等就返回attribute
插入一个知识点AudioOutputDescriptor
还记得AudioOutputDescriptor类吗？在AudioPolicyManager初始化时每打开一个输出通道，就会用mOutputs保存一个此类，它是负责连接App应用端和中间件AudioFlinger通道端的一个中间类，而下面介绍的知识点就是和应用端相关的成员，如下：
 using RoutingActivities = std::map;
using VolumeActivities = std::map;
class AudioOutputDescriptor: public AudioPortConfig, public AudioIODescriptorInterface
        //ClientMapHandler是std::map>类型,通过addClient往里面添加,那这个client就
        //代表客户端应用层的AudioTrack
    , public ClientMapHandler
{
    RoutingActivities mRoutingActivities; /** 
因为多个App应用端可能在中间层都是使用的同一个通道，所以这个AudioOutputDescriptor就集成ClientMapHandler这个集合对象，父类ClientMapHandler内有一个ActiveClients成员是保存客户端client信息的，同样在AudioOutputDescriptor也有一个mActiveClients也是保存客户端信息的，他们二者有何不同，我也不是太清楚，哈哈！
mVolumeActivities: 是保存与客户端音量方面的对象，音量加减时会用到
mRoutingActivities： 保存与客户端路由方面的对象 
client是如何被添加进来的？
如下代码： 
void AudioOutputDescriptor::setClientActive(const sp& client, bool active)
{
    //查找成功则返回一个指向指定元素的迭代器，查找失败则返回end迭代器
    auto clientIter = std::find(begin(mActiveClients), end(mActiveClients), client);
        //首先判断是否存在，不存在情况括号内部是false，如果参数active是true，说明是第一次进来，反之参数是false，则没必要继续往下
        //同理，后半部分为true，就是存在情况下，同理
    if (active == (clientIter != end(mActiveClients))) {
        ALOGW("%s(%s): ignored active: %d, current stream count %d", __func__,
              client->toShortString().c_str(), active,
              mRoutingActivities.at(client->strategy()).getActivityCount());
        return;
    }
    if (active) {
        //尾巴添加
        mActiveClients.push_back(client);
    } else {
        //删除
        mActiveClients.erase(clientIter);
    }
    const int delta = active ? 1 : -1;
    //  []这种方式相当于直接创建一个内部元素 delta是存活次数
    mRoutingActivities[client->strategy()].changeActivityCount(delta);
    mVolumeActivities[client->volumeSource()].changeActivityCount(delta);
    // Handle non-client-specific activity ref count
    int32_t oldGlobalActiveCount = mGlobalActiveCount;
    if (!active && mGlobalActiveCount toShortString().c_str(), mGlobalActiveCount);
        mGlobalActiveCount = 1;
    }
    mGlobalActiveCount += delta;
    ......
    client->setActive(active);
}
 如果客户端App使用AudioTrack时播放音频时，就会为其寻找一个输出通道，成功找到通道后就会调用此方法；
设置客户端根据其active状态来添加，首先检查client是否存在，不存在且active是true就添加进来
存活active就加入到mActiveClients，反之则移除
创建mRoutingActivities和mVolumeActivities对应词客户端的元素，并赋予其存活次数
setVolumeIndexForAttributes
 status_t AudioPolicyManager::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
          int index,
          audio_devices_t device)
{
    // 从attributes中获取其连接的volumeGroup
    auto group = mEngine->getVolumeGroupForAttributes(attributes);
    if (group == VOLUME_GROUP_NONE) {
        ALOGD("%s: no group matching with %s", __FUNCTION__, toString(attributes).c_str());
        return BAD_VALUE;
    }
    status_t status = NO_ERROR;
    //从attribute获取与之对应的volumeGroup，在从volumeGroup中获取到VolumeCurves
    IVolumeCurves &curves = getVolumeCurves(attributes);
    //static强转,子类向基类转换安全，但反之没有运行时检查，不安全
    VolumeSource vs = toVolumeSource(group);
    product_strategy_t strategy = mEngine->getProductStrategyForAttributes(attributes);
    //将当前的音量等级设置到volumeCurves的mIndexCur成员中去
    status = setVolumeCurveIndex(index, device, curves);
    if (status != NO_ERROR) {
        ALOGE("%s failed to set curve index for group %d device 0x%X", __func__, group, device);
        return status;
    }
    audio_devices_t curSrcDevice;
    auto curCurvAttrs = curves.getAttributes();
    //取attrs的首节点，并且根据attribute获取当前系统最新的一个输出设备curSrcDevice
    if (!curCurvAttrs.empty() && curCurvAttrs.front() != defaultAttr) {
        auto attr = curCurvAttrs.front();
        //获取attr适合的device
        curSrcDevice = mEngine->getOutputDevicesForAttributes(attr, nullptr, false).types();
    } else if (!curves.getStreamTypes().empty()) {
        auto stream = curves.getStreamTypes().front();
        curSrcDevice = mEngine->getOutputDevicesForStream(stream, false).types();
    } else {
        ALOGE("%s: Invalid src %d: no valid attributes nor stream",__func__, vs);
        return BAD_VALUE;
    }
    //多个设备的情况下，选择一个
    curSrcDevice = Volume::getDeviceForVolume(curSrcDevice);
    //遍历每一个输出通道
    for (size_t i = 0; i devices().types();
        if (curDevice & AUDIO_DEVICE_OUT_SPEAKER_SAFE) {
            curDevice |= AUDIO_DEVICE_OUT_SPEAKER;
            curDevice &= ~AUDIO_DEVICE_OUT_SPEAKER_SAFE;
        }
        
        bool applyVolume = false;
        //此设备能进行gain增益控制，检查desc的openDevice的device，查看device的配置标签gain对应的AudioGains是否支持音量调节
        if (desc->useHwGain()) {
            //必须有对应的volumegroup客户端client存活
            if (!(desc->isActive(toVolumeSource(group)) || isInCall())) {
                continue;
            }
            for (const auto &productStrategy : mEngine->getOrderedProductStrategies()) {
                auto activeClients = desc->clientsList(true /*activeOnly*/, productStrategy,
        false /*preferredDevice*/);
                //无存活客户端，不做音量调整
                if (activeClients.empty()) {
                    continue;
                }
                bool isPreempted = false;
                bool isHigherPriority = productStrategy volumeSource() != vs)) {
                        applyVolume = false;
                        isPreempted = true;
                        break;
                    }
                    // However, continue for loop to ensure no higher prio clients running on output
                    //client有一个符合音量曲线的设备
                    if (client->volumeSource() == vs) {
                        applyVolume = true;
                    }
                }
                if (isPreempted || applyVolume) {
                    break;
                }
            }
            if (!applyVolume) {
                continue; // next output
            }
            //最终会把index由音量等级转化为分贝db，把分贝值设置到AudioutputDescriptor的VolumeActivities成员变量中去
            status_t volStatus = checkAndSetVolume(curves, vs, index, desc, curDevice,
    (vs == toVolumeSource(AUDIO_STREAM_SYSTEM)?
         TOUCH_SOUND_FIXED_DELAY_MS : 0));
            if (volStatus != NO_ERROR) {
                status = volStatus;
            }
            continue;
        }
        ......
        if (device != AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME) {
            curSrcDevice |= device;  //合并当前设备与上层传入设备
                //getDeviceForVolume是选择一个设备，与后者取交集，有交集说明和调节音量设备有关系
            applyVolume = (Volume::getDeviceForVolume(curDevice) & curSrcDevice) != 0;
        } else {
                //检查curves内mIndexCur是否包含curSrcDevice
            applyVolume = !curves.hasVolumeIndexForDevice(curSrcDevice);
        }
        if (applyVolume) {
            //FIXME: workaround for truncated touch sounds
            // delayed volume change for system stream to be removed when the problem is
            // handled by system UI
            status_t volStatus = checkAndSetVolume(
                        curves, vs, index, desc, curDevice,
                        ((vs == toVolumeSource(AUDIO_STREAM_SYSTEM))?
                             TOUCH_SOUND_FIXED_DELAY_MS : 0));
            if (volStatus != NO_ERROR) {
                status = volStatus;
            }
        }
    }
   //group是attribute绑定的group，也就是streamType对应的attribute
    mpClientInterface->onAudioVolumeGroupChanged(group, 0 /*flags*/);
    return status;
}
 代码很多，阅读下来就做了几件事：
以attribute属性找到volumegroup、VolumeCurves和productStrategy，然后将device的音量等级设置到VolumeCurves的内部成员mIndexCur中去，原始的音量数据
以attribute按照系统当前的音频策略，找到当前的输出设备curDevice，再遍历所有输出通道mOutputs，看是哪个通道设备AudioOutputDescriptor在使用这个设备curDevice
简称AudioOutputDescriptor保存的打开设备为Curdevice，如果这个Curdevice使用hwGain(硬件音量设置)，也就是device-port标签配置了gain，name就去查找这个AudioOutputDescriptor的client是否有与之匹配的volumeGroup，与我们的attribute的volumeGroup相等，相等就说这个通道需要设置音量，调用checkAndSetVolume进行设置
如果Curdevice没有使用hwGain，那就需要看看这个Curdevice和我们传入的设备device有没有交集，有交集说明也需要对此通道进行音量调整；没有交集则查看音量曲线volumeCurves内有没有已经设置过curSrcDevice的音量，没有就需要设置音量，充满疑问的是为啥没有就要设置，应该是有才会去设置，而且代码写在这个地方和外层的for循环遍历mOutputs一点关系也没有到这一步，还是在确定哪些通道需要调整音量值！！！
checkAndSetVolume
 status_t AudioPolicyManager::checkAndSetVolume(IVolumeCurves &curves,
VolumeSource volumeSource,
int index,
const sp& outputDesc,
audio_devices_t device,
int delayMs,
bool force)
{
    // 查看其内的VolumeActivities的muteCount是否大于0，大于0不能进行音量调节
    if (outputDesc->isMuted(volumeSource)) {
        ALOGVV("%s: volume source %d muted count %d active=%d", __func__, volumeSource,
               outputDesc->getMuteCount(volumeSource), outputDesc->isActive(volumeSource));
        return NO_ERROR;
    }
    ........
    if (device == AUDIO_DEVICE_NONE) {
        //devices返回的是open时传入的设备
        device = outputDesc->devices().types();
    }
    //计算音量值dB,device转化为device_category，根据它在找到curve，传入index获取其分贝值
    float volumeDb = computeVolume(curves, volumeSource, index, device);
    if (outputDesc->isFixedVolume(device) ||
            // Force VoIP volume to max for bluetooth SCO
            ((isVoiceVolSrc || isBtScoVolSrc) && (device & AUDIO_DEVICE_OUT_ALL_SCO) != 0)) {
        volumeDb = 0.0f;
    }
    //设置到其内部成员volumeActivities里面去
    outputDesc->setVolume(volumeDb, volumeSource, curves.getStreamTypes(), device, delayMs, force);
        if (isVoiceVolSrc || isBtScoVolSrc) {
        float voiceVolume;
        // Force voice volume to max or mute for Bluetooth SCO as other attenuations are managed by the headset
        if (isVoiceVolSrc) {
            voiceVolume = (float)index/(float)curves.getVolumeIndexMax();
        } else {
            voiceVolume = index == 0 ? 0.0 : 1.0;
        }
        if (voiceVolume != mLastVoiceVolume) {
            mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
            mLastVoiceVolume = voiceVolume;
        }
    }
    return NO_ERROR;
}
 以上代码主要完成两个任务：
将音量等级index转换为分贝db，computeVolume函数
将分贝值写入到输出设备outputDesc中去，如果是通话音量的话voice话，则调用setVoiceVolume直通hal层去调整音量
1. index转dB过程依次调用
AudioPolicyManager::computeVolume -->> VolumeCurves::volIndexToDb(device_category deviceCat, int indexInUi) -->> VolumeCurve::VolIndexToDb(int indexInUi, int volIndexMin, int volIndexMax)
在VolumeCurves里面，是按map存储的，所以根据传入deviceCat拿到VolumeCurve，然后在VolumeCurve里：
 //indexUi是上层传递下来的音量等级，max和min是可调整的最大最小值
float VolumeCurve::volIndexToDb(int indexInUi, int volIndexMin, int volIndexMax) const
{
    ALOG_ASSERT(!mCurvePoints.isEmpty(), "Invalid volume curve");
    if (volIndexMin  0
        if (indexInUi == 0) {
            ALOGV("VOLUME forcing mute for index 0 with min index %d", volIndexMin);
            return VOLUME_MIN_DB;
        }
        ALOGV("VOLUME remapping index from %d to min index %d", indexInUi, volIndexMin);
        indexInUi = volIndexMin;
    } else if (indexInUi > volIndexMax) {
        ALOGV("VOLUME remapping index from %d to max index %d", indexInUi, volIndexMax);
        indexInUi = volIndexMax;
    }
    size_t nbCurvePoints = mCurvePoints.size();
    // the volume index in the UI is relative to the min and max volume indices for this stream
    //nbSteps总的音量等级范围总共值 1~nbSteps，加一就是最小值从1开始，防止为0时是mute，特别注意，这个去就是index，不要理解成健值对的value了
    int nbSteps = 1 + mCurvePoints[nbCurvePoints - 1].mIndex - mCurvePoints[0].mIndex;
    //nbSteps是总的音量等级，后者是当前设置音量index占可调整范围(min,max)占比多少，乘以后就是映射到总的音量等级的映射值
    int volIdx = (nbSteps * (indexInUi - volIndexMin)) / (volIndexMax - volIndexMin);
    // Where would this volume index been inserted in the curve point
   //只比教，不插入，从而知道对应的分贝值
    size_t indexInUiPosition = mCurvePoints.orderOf(CurvePoint(volIdx, 0));
    if (indexInUiPosition >= nbCurvePoints) {
        //use last point of table
        return mCurvePoints[nbCurvePoints - 1].mAttenuationInMb / 100.0f;
    }
    if (indexInUiPosition == 0) {
        if (indexInUiPosition != mCurvePoints[0].mIndex) {
            return VOLUME_MIN_DB; // out of bounds
        }
        return mCurvePoints[0].mAttenuationInMb / 100.0f;
    }
    // linear interpolation in the attenuation table in dB
    //这个求值原理就是，取插入前一个位置的分贝值作为基础，加上后部分的比例值，比例值采用插入前和后这两个位置的间距比，计算出对应的分贝值
    //思考：因为分贝是非线性的，这里采用比例换算出分贝合理吗？
    //我觉得应该合理，首先基础值是插入前一个位置的分贝，这个值是xml文件配置的，它是非线性的合理值，占据大部分；关键在于后部分的比例换算值是否合理，我觉得合理因为也占据小部分值，人耳听不出
    float decibels = (mCurvePoints[indexInUiPosition - 1].mAttenuationInMb / 100.0f) +
            ((float)(volIdx - mCurvePoints[indexInUiPosition - 1].mIndex)) *
                ( ((mCurvePoints[indexInUiPosition].mAttenuationInMb / 100.0f) -
                        (mCurvePoints[indexInUiPosition - 1].mAttenuationInMb / 100.0f)) /
                    ((float)(mCurvePoints[indexInUiPosition].mIndex -
                            mCurvePoints[indexInUiPosition - 1].mIndex)) );
    ALOGV("VOLUME vol index=[%d %d %d], dB=[%.1f %.1f %.1f]",
            mCurvePoints[indexInUiPosition - 1].mIndex, volIdx,
            mCurvePoints[indexInUiPosition].mIndex,
            ((float)mCurvePoints[indexInUiPosition - 1].mAttenuationInMb / 100.0f), decibels,
            ((float)mCurvePoints[indexInUiPosition].mAttenuationInMb / 100.0f));
        if(indexInUi >=0 && indexInUi
    // We actually change the volume if:
    // - the float value returned by computeVolume() changed 与之前的音量不同
    // - the force flag is set 强制标记
    if (volumeDb != getCurVolume(volumeSource) || force) {
        ALOGV("%s for volumeSrc %d, volume %f, delay %d", __func__, volumeSource, volumeDb, delayMs);
        //设置到VolumeActivities的db成员中，本类中会getCurVolume获取当前音量，并向AudioFlinger设置到回播线程中，根据streamType设置到对应的stream上去
        setCurVolume(volumeSource, volumeDb);
        return true;
    }
    return false;
}
bool SwAudioOutputDescriptor::setVolume(float volumeDb,
                                        VolumeSource vs, const StreamTypeVector &streamTypes,
                                        audio_devices_t device,
                                        uint32_t delayMs,
                                        bool force)
{
    StreamTypeVector streams = streamTypes;
    if (!AudioOutputDescriptor::setVolume(volumeDb, vs, streamTypes, device, delayMs, force)) {
        return false;
    }
    if (streams.empty()) {
        streams.push_back(AUDIO_STREAM_MUSIC);
    }
    for (const auto& devicePort : devices()) {
        // 设备相等，且支持gain硬件调整音量的去设置
        if (device == devicePort-type() &&
                devicePort->hasGainController(true) && isActive(vs)) {
            ALOGV("%s: device %s has gain controller", __func__, devicePort->toString().c_str());
            //将0dB转换为功率值
            float volumeAmpl = Volume::DbToAmpl(0);
            //为此类型的软件音量值设置0就是不发声，
            for (const auto &stream : streams) {
                mClientInterface->setStreamVolume(stream, volumeAmpl, mIoHandle, delayMs);
            }
            //硬件音量更新
            AudioGains gains = devicePort->getGains();
            int gainMinValueInMb = gains[0]->getMinValueInMb();
            int gainMaxValueInMb = gains[0]->getMaxValueInMb();
            int gainStepValueInMb = gains[0]->getStepValueInMb();
            int gainValueMb = ((volumeDb * 100)/ gainStepValueInMb) * gainStepValueInMb;
            gainValueMb = std::max(gainMinValueInMb, std::min(gainValueMb, gainMaxValueInMb));
            audio_port_config config = {};
            devicePort->toAudioPortConfig(&config);
            config.config_mask = AUDIO_PORT_CONFIG_GAIN;
            config.gain.values[0] = gainValueMb;
            //硬件音量设置
            return mClientInterface->setAudioPortConfig(&config, 0) == NO_ERROR;
        }
    }
    //上述走过硬件音量后，下面的都是软件音量，获取当前音量并转换为功率值ampl
    float volumeAmpl = Volume::DbToAmpl(getCurVolume(vs));
    if (hasStream(streams, AUDIO_STREAM_BLUETOOTH_SCO)) {
        mClientInterface->setStreamVolume(AUDIO_STREAM_VOICE_CALL, volumeAmpl, mIoHandle, delayMs);
    }
    //设置功率值
    for (const auto &stream : streams) {
        ALOGV("%s output %d for volumeSource %d, volume %f, delay %d stream=%s", __func__,
              mIoHandle, vs, volumeDb, delayMs, toString(stream).c_str());
        mClientInterface->setStreamVolume(stream, volumeAmpl, mIoHandle, delayMs);
    }
    return true;
}
 首先将音量值分贝Db设置到volumeActivities成员中，然后遍历当前打开的device
如果这个device支持gain硬件方式设置音量，就使用硬件音量调整setAudioPortConfig，此方法会调用到hal的set_audio_port_config指针函数；否则就是软件音量调整设置setStreamVolume
在进行第2步时，需要先把Db分贝转换为功率值ampl，转换方法如下：
Volume::DbToAmpl
 static inline float DbToAmpl(float decibels)
{
    //VOLUME_MIN_DB = -758估计在小的话人耳就听不见了
    if (decibels 
        return 0.0f;
    }
    //exp是以e为底的指数函数,常数 e 的值约为 2.718282;是由分贝算式推导过来的db = 20* ln(P1/P0);P0是基本功率
    return exp( decibels * 0.115129f); // exp( dB * ln(10) / 20 )
}
{\ln10} + {\frac{db}{20}}} 
        
       
     P1=10∗e20db=eln10∗e20db=eln10+20db
    // check calling permissions
    if (!settingsAllowed()) {
        return PERMISSION_DENIED;
    }    
    status_t status = checkStreamType(stream);
    if (status != NO_ERROR) {
        return status;
    }    
    if (output == AUDIO_IO_HANDLE_NONE) {
        return BAD_VALUE;
    }    
    LOG_ALWAYS_FATAL_IF(stream == AUDIO_STREAM_PATCH && value != 1.0f,
                        "AUDIO_STREAM_PATCH must have full scale volume");
    AutoMutex lock(mLock);
    //从mPlaybackThreads集合中拿到一个回播线程实例
    VolumeInterface *volumeInterface = getVolumeInterface_l(output);
    if (volumeInterface == NULL) {
        return BAD_VALUE;
    }    
    //设置音量对应功率值到playbackthread中的stream对应的音量值去
    volumeInterface-setStreamVolume(stream, value);
    return NO_ERROR;
}
 代码很简单了，主要是通过句柄output拿到通道回播线程PlaybackThread，设置音量进去就可以了
PlaybackThread中音量处理
setStreamVolume
 void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
{
    Mutex::Autolock _l(mLock);
    mStreamTypes[stream].volume = value;
    broadcast_l();
}
 回播线程按照streamType类型集合保存了音量值，准确说应该是音量值对应的功率值，在播放音频或混音时，回播线程会将音频数据与音量数据相乘，最后将结果传送到Hal去播放，至此，软件音量调节过程就完结了！
```