《深入理解Android 卷III》第三章 深入理解AudioService_getvalidindex

注意按照Android的输入事件派发策略，Window对象在事件的派发队列中排在Activity的后面（应该说排在队尾比较合适），所以应用程序可以重写自己的onKeyDown()函数，将音量键用作其他的功能。比如说，在一个相机应用中，按下音量键所执行的动作是拍照而不是调节音量。

......//加省略号，   略过一些内容

switch (keyCode) {

    caseKeyEvent.KEYCODE_VOLUME_UP:

    caseKeyEvent.KEYCODE_VOLUME_DOWN:

case KeyEvent.KEYCODE_VOLUME_MUTE: {

    // 直接调用到AudioManager的handleKeyUp里面去了。是不是很简单而且直接呢

        getAudioManager().handleKeyDown(event,mVolumeControlStreamType);

       return true;

}

……

}

getWindow().setVolumeControlStream(streamType);

public voidadjustSuggestedStreamVolume(int direction,

                  int suggestedStreamType,

                   int flags)

public void adjustSuggestedStreamVolume(intdirection, int suggestedStreamType,

                           int flags) {格式要调整好

int streamType;

// ①从这一小段代码中，可以看出在 AudioService中还有地方可以强行改变音量键控制的流类型

    if(mVolumeControlStream != -1) {

       streamType = mVolumeControlStream;

} else {

     // ②通过getActiveStreamType()函数获取要控制的流类型

     // 这里根据建议的流类型与AudioService的实际情况，返回一个值

       streamType = getActiveStreamType(suggestedStreamType);

    }

// ③这个啰嗦的if判断的目的，就是只有在特定的流类型下,并且没有处于锁屏状态时才会播放声音

    if((streamType != STREAM_REMOTE_MUSIC) &&

           (flags & AudioManager.FLAG_PLAY_SOUND) != 0 &&

           ((mStreamVolumeAlias[streamType] != AudioSystem.STREAM_RING)

            || (mKeyguardManager != null &&mKeyguardManager.isKeyguardLocked()))) {

        flags&= ~AudioManager.FLAG_PLAY_SOUND;

    }

    if(streamType == STREAM_REMOTE_MUSIC) {

…… //我们不讨论远程播放的情况

} else {

    // ④调用adjustStreamVolume

       adjustStreamVolume(streamType, direction, flags);

    }

}

注意初看着段代码时，可能有读者会对下面这句话感到疑惑：

VolumeStreamState streamState =mStreamStates[mStreamVolumeAlias[streamType]];

其实这是为了满足所谓的“将铃声音量用作通知音量”这种需求。这样就需要实现在两个有这个需求的流A与B之间建立起一个A→B映射。当我们对A流进行音量操作时，实际上是在操作B流。其实笔者个人认为这个功能对用户体验的提升并不大，但是却给AudioService的实现增加了不小的复杂度。直观上来想，我们可能想使用一个HashMap解决这个问题，键是源流类型，值目标流类型。而Android使用了一个更简单那但是却不是那么好理解的方法来完成这件事。AudioService用一个名为mStreamVolumeAlias的整形数组来描述这个映射关系。

如果想要实现“以铃声音量用作音乐音量”，只需要修改相应位置的值为STREAM_RING即可，就像下面这样：

mStreamVolumeAlias[AudioSystem.STREAM_MUSIC] =AudioSystem.STREAM_RING;

之后，因为需求要求对A流进行音量操作时，实际上是在操作B流，所以就不难理解为什么在很多和流相关的函数里都会先做这样的一个转换：

streamType = mStreamVolumeAlias[streamType];

其具体的工作方式就留给读者进行思考了。在本章的分析过程中，大可忽略这种转换，这并不影响我们对音量控制原理的理解。

public void adjustStreamVolume(int streamType, intdirection, int flags) {

// 首先还是获取streamType映射到的流类型。这个映射的机制确实给我们的分析带来不小的干扰

// 在非必要的情况下忽略它们吧

int streamTypeAlias = mStreamVolumeAlias[streamType];

// 注意VolumeStreamState类

   VolumeStreamState streamState = mStreamStates[streamTypeAlias];

    final intdevice = getDeviceForStream(streamTypeAlias);

    // 获取当前音量，注意第二个参数的值，它的目的是如果这个流被静音，则取出它被静音前的音量

    final intaliasIndex = streamState.getIndex(device,

                                             (streamState.muteCount()!= 0)

    booleanadjustVolume = true;

// rescaleIndex用于将音量值的变化量从源流类型变换到目标流类型下

// 由于不同的流类型的音量调节范围不同，所以这个转换是必需的

    int step= rescaleIndex(10, streamType, streamTypeAlias);

//上面准备好了所需的所有信息，接下来要做一些真正有用的动作了

// 比如说checkForRingerModeChange()。调用这个函数可能变更情景模式

// 它的返回值adjustVolume是一个布尔变量，用来表示是否有必要继续设置音量值

// 这是因为在一些情况下，音量键用来改变情景模式，而不是设置音量值

    if(((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||

           (streamTypeAlias == getMasterStreamType())) {

……

       adjustVolume = checkForRingerModeChange(aliasIndex, direction, step);

……

    }

int index;

// 取出调整前的音量值。这个值稍后被用在sendVolumeUpdate()的调用中

    final intoldIndex = mStreamStates[streamType].getIndex(device,

           (mStreamStates[streamType].muteCount() != 0) /* lastAudible */);

// 接下来我们可以看到，只有流没有被静音时，才会设置音量到底层去，否则只调整其静音前的音量

// 为了简单起见，暂不考虑静音时的情况

    if(streamState.muteCount() != 0) {

        ……

} else {

    // 为什么还要判断streamState.adjustIndex的返回值呢?

    // 因为如果音量值在adjust之后并没有发生变化，比如说达到了最大值，就不需要继续后面的操作了

        if(adjustVolume && streamState.adjustIndex(direction * step, device)) {

           // 发送消息给AudioHandler

           // 这个消息在setStreamVolumeInt()函数的分析中已经看到过了

           // 这个消息将把音量设置到底层去，并将其存储到SettingsProvider中去

           sendMsg(mAudioHandler,

                   MSG_SET_DEVICE_VOLUME,

                   SENDMSG_QUEUE,

                   device,

                   0,

                   streamState,

                   0);

        }

        index= mStreamStates[streamType].getIndex(device, false  /* lastAudible */);

    }

    // 最后，调用sendVolumeUpdate函数，通知外界音量值发生了变化

   sendVolumeUpdate(streamType, oldIndex, index, flags);

}

public boolean adjustIndex(int deltaIndex, intdevice) {

// 将现有的音量值加上变化量，然后调用setIndex设置下去

// 返回值与setIndex一样

    return setIndex(getIndex(device,  false /* lastAudible */) + deltaIndex,

                            device,

                            true  /* lastAudible */);

}

public synchronized boolean setIndex(int index, intdevice, boolean lastAudible) {

    intoldIndex = getIndex(device, false  /*lastAudible */);

    index =getValidIndex(index);

    // 在VolumeStreamState中保存设置的音量值，注意是用了一个HashMap

   mIndex.put(device, getValidIndex(index));

    if(oldIndex != index) {

        // 保存到lastAudible

        if(lastAudible) {

           mLastAudibleIndex.put(device, index);

        }

        // 同时设置所有映射到当前流类型的其他流的音量

       boolean currentDevice = (device == getDeviceForStream(mStreamType));

        intnumStreamTypes = AudioSystem.getNumStreamTypes();

        for(int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {

            ……

        }

       return true;

    } else {

       return false;

    }

}

private void setDeviceVolume(VolumeStreamStatestreamState, int device) {

// 调用VolumeStreamState的applyDeviceVolume。

// 这个函数的内容很简单，就是在调用AudioSystem.setStreamVolumeIndex()

// 到这里，音量就被设置到底层的AudioFlinger里面去了

   streamState.applyDeviceVolume(device);

    // 和上面一样，需要处理流音量映射的情况。这段代码和上面setIndex的相关代码很像，不是么

    intnumStreamTypes = AudioSystem.getNumStreamTypes();

for (int streamType = numStreamTypes - 1; streamType >= 0;streamType--) {

     ……

        }

    }

     // 发送消息给mAudioHandler，其处理函数将会调用persitVolume()函数这将会把音量的
   //设置信息存储到SettingsProvider中

// AudioService在初始化时，将会从SettingsProvider中将音量设置读取出来并进行设置

   sendMsg(mAudioHandler,

           MSG_PERSIST_VOLUME,

           SENDMSG_QUEUE,

           PERSIST_CURRENT|PERSIST_LAST_AUDIBLE,

           device,

           streamState,

           PERSIST_DELAY);

}

注意 sendMsg()是一个异步的操作，这就意味着，完成adjustIndex()更新音量信息后adjustStreamVolume()函数就返回了，但是音量并没有立刻地被设置到底层。而且由于Handler处理多个消息的过程是串行的，这就隐含着一个风险：当Handler正在处理某一个消息时发生了阻塞，那么当按下音量键时，调用adjustStreamVolume()虽然可以立刻返回，而且从界面上看或者用getStreamVolume()获取音量值发现都是没有问题的，但是手机发出声音时的音量大小并没有改变。

private void sendVolumeUpdate(int streamType, intoldIndex, int index, int flags) {

    // 读者可能会对这句话感到有点奇怪，mVoiceCapable是从SettingsProvider中取出来的一个常量

    // 从某种意义上来说，它可以用来判断设备是否拥有通话功能。对于没有通话能力的设备来说，RING流类

    // 型自然也就没有意义了。这句话应该算是一种从语义操作上进行的保护

    if(!mVoiceCapable && (streamType == AudioSystem.STREAM_RING)) {

       streamType = AudioSystem.STREAM_NOTIFICATION;

    }

    //mVolumePanel是一个VolumePanel类的实例，就是它显示了音量提示框

   mVolumePanel.postVolumeChanged(streamType, flags);

    // 发送广播。可以看到它们都有(x+5)/10的一个操作。为什么要除以10可以理解，但是+5的意义呢

    // 原来是为了实现四舍五入

    oldIndex= (oldIndex + 5) / 10;

    index =(index + 5) / 10;

    Intentintent = new Intent(AudioManager.VOLUME_CHANGED_ACTION);

   intent.putExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, streamType);

   intent.putExtra(AudioManager.EXTRA_VOLUME_STREAM_VALUE, index);

   intent.putExtra(AudioManager.EXTRA_PREV_VOLUME_STREAM_VALUE, oldIndex);

   mContext.sendBroadcast(intent);

}

private enum StreamResources {

   BluetoothSCOStream(AudioManager.STREAM_BLUETOOTH_SCO,

           R.string.volume_icon_description_bluetooth,

           R.drawable.ic_audio_bt,

           R.drawable.ic_audio_bt,

           false),

    // 后面的几个枚举项我们省略了其构造参数，与BluetoothSCOStream的内容是一致的

   RingerStream(……),

   VoiceStream(……),

   AlarmStream(……),

   MediaStream(……),

   NotificationStream(……),

   MasterStream(……),

    RemoteStream(……);

    intstreamType; // 流类型

    intdescRes;     // 描述信息

    inticonRes;     // 图标

    inticonMuteRes;// 静音图标

    booleanshow;    // 是否显示

    StreamResources(intstreamType, int descRes, int iconRes, int iconMuteRes, boolean show) {

        ……

    }

};

private static final StreamResources[] STREAMS = {

   StreamResources.BluetoothSCOStream,

   StreamResources.RingerStream,

   StreamResources.VoiceStream,

   StreamResources.MediaStream,

   StreamResources.NotificationStream,

   StreamResources.AlarmStream,

   StreamResources.MasterStream,

   StreamResources.RemoteStream

};

private class StreamControl {

    intstreamType;

    ViewGroupgroup;

    ImageViewicon;

    SeekBarseekbarView;

    inticonRes;

    inticonMuteRes;

}

private void createSliders() {

    ……

    // 遍历STREAM中所有的StreamResources实例

    for (inti = 0; i < STREAMS.length; i++) {

       StreamResources streamRes = STREAMS[i];

        intstreamType = streamRes.streamType;

        ……

        // 为streamType创建一个StreamControl

       StreamControl sc = new StreamControl();

        // 这里将初始化sc的成员变量

        ……

        // 将初始化好的sc放入mStreamControls中去。

       mStreamControls.put(streamType, sc);

    }

}

注意 VolumePanel在MSG_VOLUME_CHANGED的消息处理函数中调用onVolumeChanged()函数而不直接在postVolumeChanged()函数中直接调，。这么做是有实际意义的。由于Android要求只能在创建控件的线程中对控件进行操作。postVolumeChanged()作为一个回调性质的函数，不能要求调用者位于哪个线程中。所以必须通过向Handler发送消息的方式，将后续的操作转移到指定的线程中去。在大家设计具有UI Controller功能的类时，VolumePanel的实现方式有很好的参考意义。

protected void onVolumeChanged(int streamType, intflags) {

    //  需要flags中包含AudioManager.FLAG_SHOW_UI才会显示音量调通知框

    if((flags & AudioManager.FLAG_SHOW_UI) != 0) {

       synchronized (this) {

           if (mActiveStreamType != streamType) {

               reorderSliders(streamType); // 在Dialog里装载需要的StreamControl

            }

           // 这个函数负责最终的显示

           onShowVolumeChanged(streamType, flags);

        }

    }

    // 是否要播出Tone音，注意有个小延迟

    if((flags & AudioManager.FLAG_PLAY_SOUND) != 0 && ! mRingIsSilent) {

       removeMessages(MSG_PLAY_SOUND);

       sendMessageDelayed(obtainMessage(MSG_PLAY_SOUND, streamType, flags),PLAY_SOUND_DELAY);

    }

    // 取消声音与振动的播放

    if((flags & AudioManager.FLAG_REMOVE_SOUND_AND_VIBRATE) != 0) {

       removeMessages(MSG_PLAY_SOUND);

       removeMessages(MSG_VIBRATE);

       onStopSounds();

    }

    // 开始安排回收资源

   removeMessages(MSG_FREE_RESOURCES);

   sendMessageDelayed(obtainMessage(MSG_FREE_RESOURCES), FREE_DELAY);

    // 重置音量框超时关闭的时间。

   resetTimeout();

}

    protectedvoid onShowVolumeChanged(int streamType, int flags) {

        // 获取音量值

        intindex = getStreamVolume(streamType);

        // 获取音量最大值，这两个将用来设置进度条

        intmax = getStreamMaxVolume(streamType);

       switch (streamType) {

           // 这个switch语句中，我们要根据每种流类型的特点，进行各种调整。

           // 例如Music就有时就需要更新它的图标，因为使用蓝牙耳机时的图标和和平时的不一样

           // 所以每一次都需要更新一下

           case AudioManager.STREAM_MUSIC: {

               // Special case for when Bluetooth is active for music

               if ((mAudioManager.getDevicesForStream(AudioManager.STREAM_MUSIC) &

                       (AudioManager.DEVICE_OUT_BLUETOOTH_A2DP |

                        AudioManager.DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES|

                       AudioManager.DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER)) != 0) {

                   setMusicIcon(R.drawable.ic_audio_bt,

                                    R.drawable.ic_audio_bt_mute);// 设置蓝牙图标

               } else {

                   setMusicIcon(R.drawable.ic_audio_vol,

                                    R.drawable.ic_audio_vol_mute);//设置为普通图标

               }

               break;

            }

            ……

        }

        // 取出Music流类型对应的StreamControl。并设置其SeekBar的音量显示

       StreamControl sc = mStreamControls.get(streamType);

        if(sc != null) {

           if (sc.seekbarView.getMax() != max) {

               sc.seekbarView.setMax(max);

            }

           sc.seekbarView.setProgress(index);

            ……

        }

        if(!mDialog.isShowing()) {  //  如果对话框还没有显示

            /* forceVolumeControlStream()的调用在这里，一旦此通知框被显示，之后的按下音量键，都只能调节当前流类型的音量。直到通知框关闭时，重新调用forceVolumeControlStream()，并设置streamType为-1。*/

           mAudioManager.forceVolumeControlStream(streamType);

           // 为Dialog设置显示控件

           // 注意,mView目前已经在reorderSlider()函数中安装好了Music流所对应的

           //StreamControl了

           mDialog.setContentView(mView);

            ……

            //显示对话框

           mDialog.show();

        }

}

public void setStreamVolume(int streamType, intindex, int flags) {

    // 这里先判断一下流类型这个参数的有效性

    ensureValidStreamType(streamType);

    // 获取保存了指定流类型音量信息的VolumeStreamState对象。

    // 注意这里面使用mStreamVolumeAlias对这个数组进行了流类型的转换

   VolumeStreamState streamState =mStreamStates[mStreamVolumeAlias[streamType]];

    // 获取当前流将使用哪一个音频设备进行播放。它最终会调用到AudioPolicyService里去

    final intdevice = getDeviceForStream(streamType);

    // 获取流当前的音量

    final intoldIndex = streamState.getIndex(device,

                        (streamState.muteCount()!= 0) /* lastAudible */);

    // 将原流类型下的音量值映射到目标流类型下的音量值

    // 因为不同流类型的音量值刻度不一样，所以需要进行这个转换

    index =rescaleIndex(index * 10, streamType, mStreamVolumeAlias[streamType]);

    //暂时先忽略下面这段if中的代码。它的作用根据flags的要求修改手机的情景模式

    if(((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||

           (mStreamVolumeAlias[streamType] == getMasterStreamType())) {

        ……

    }

    // 调用setStreamVolumeInt()

   setStreamVolumeInt(mStreamVolumeAlias[streamType], index, device, false,true);

    // 获取设置的结果

    index =mStreamStates[streamType].getIndex(device,

(mStreamStates[streamType].muteCount() != 0) /*lastAudible */);

    // 广播通知

   sendVolumeUpdate(streamType, oldIndex, index, flags);

}

private void setStreamVolumeInt(int streamType,

                                int index,

                                int device,

                                boolean force,

                                booleanlastAudible) {

    // 获取保存音量信息的VolumeStreamState对象

   VolumeStreamState streamState = mStreamStates[streamType];

    if(streamState.muteCount() != 0) {

        // 这里的内容是为了处理当流已经被静音后的情况。我们在讨论静音的实现时在考虑这段代码

        ……

    } else {

        // 调用streamState.setIndex()

        if(streamState.setIndex(index, device, lastAudible) || force) {

           // 如果setIndex返回true或者force参数为true的话就在这里给mAudioHandler

           //

           sendMsg(mAudioHandler,

                   MSG_SET_DEVICE_VOLUME,

                   SENDMSG_QUEUE,

                   device,

                   0,

                   streamState,

                   0);

        }

    }

}

注意看到这个序列图后，是否有读者感到眼熟呢？如果我们把setStreamVolumeInt()的内容替换掉在setStreamVolume()的对它的调用，再和adjustStreamVolume()函数进行以下比较，就会发现他们的内容出奇地相似。Android在其他地方也有这样的情况出现。从这一点上来说，已经发展到4.1版本的Android源码仍然尚不够精致。读者可以思考一下，有没有办法把这两个函数融合为一个函数呢？

public void setStreamMute(int streamType, booleanstate) {

   IAudioService service = getService();

try {

    // 调用AudioService的setStreamMute，注意第三个参数mICallBack。

       service.setStreamMute(streamType, state, mICallBack);

    } catch(RemoteException e) {

       Log.e(TAG, "Dead object in setStreamMute", e);

    }

}

private final IBinder mICallBack = new Binder();

注意服务端把客户端传入的这个Binder对象作为客户端的一个唯一标识，能做的事情不仅仅DeathRecipient这一个。还以这个标识为键创建一个Hashtable，用来保存每个客户端相关信息。这在Android各个系统服务的实现中是一种很常见的用法。

另外，本例中传入的mICallBack是直接从Binder类实例化出来的，是一个很原始的IBinder对象。进一步讲，如果传递了一个通过AIDL定义的IBinder对象，这个对象就有了交互能力，服务端可以它向客户端进行回调。在后面探讨AudioFocus机制时会遇到这种情况。

public void setStreamMute(int streamType, booleanstate, IBinder cb) {

    // 只有可以静音的流类型才能执行静音操作。这说明，并不是所有的流都可以被静音

    if(isStreamAffectedByMute(streamType)) {

        // 直接调用了流类型对应的mStreamStates的mute()函数

        // 这里没有做那个令人讨厌的流类型的映射。这是出于操作语义上的原因。读者可以自行思考一下

       mStreamStates[streamType].mute(cb, state);

    }

}

public synchronized void mute(IBinder cb, booleanstate) {

    // 这句话是一个重点，VolumeDeathHandler与cb一一对应

    // 用来管理客户端的静音操作，并且监控客户端的生命状态

   VolumeDeathHandler handler = getDeathHandler(cb, state);

    if(handler == null) {

        Log.e(TAG, "Could not get client deathhandler for stream: "+mStreamType);

       return;

    }

    // 通过VolumeDeathHandler执行静音操作

   handler.mute(state);

}

public void mute(boolean state) {

if (state) {

    // 静音操作

        if(mMuteCount == 0) {

           // 如果mMuteCount等于0，则表示客户端是第一次执行静音操作

           //此时我们linkToDeath，开始对客户端的生命状况进行监听

           //这样做的好处是可以避免非静音状态下对Binder资源的额外占用

           try {

               // linkToDeath! 为什么要判断是否为空？AudioManager不是写死了会把一个有效的

               // Binder传递进来么？原来AudioManager也可能会调用mute()

               // 此时的mICallback为空

               if (mICallback != null) {

                   mICallback.linkToDeath(this, 0);

               }

               // 保存的mDeathHandlers列表中去

               mDeathHandlers.add(this);

               // muteCount() 我们在后面会介绍，这是全局的静音操作的引用计数

               // 如果它的返回值为0，则表示这个流目前还没有被静音

               if (muteCount() == 0) {

                   // 在这里设置流的音量为0

                  ......//你打出来的省略号咋这么小呢？^_^

               }

            }catch (RemoteException e) {

                   ......

            }

        }

        // 引用计数加1

       mMuteCount++;

} else {

    // 暂时先不看取消静音的操作

……

    }

}

public void mute(boolean state) {

if (state) {

    // 忽略掉静音操作

  ......

    } else {

        if(mMuteCount == 0) {

           Log.e(TAG, "unexpected unmute for stream: "+mStreamType);

        }else {

           // 引用计数减1先

           mMuteCount--;

           if (mMuteCount == 0) {

// 如果这是客户端最后一次有效地取消静音

               mDeathHandlers.remove(this);

               if (mICallback != null) {

                   mICallback.unlinkToDeath(this, 0);

               }

               if (muteCount() == 0) {

                   // 将流的音量值设置回静音前的音量，也就是lastAudibleIndex

……

               }

            }

        }

    }

}

public void binderDied() {

    if(mMuteCount != 0) {

       mMuteCount = 1;

       mute(false);

    }

}