android10 AudioService之音频输出通道切换

前言：android系统中，音频输出的方式有很多种，外放即扬声器（Speaker）、听筒（Telephone Receiver）、有线耳机（WiredHeadset）、蓝牙音箱（Bluetooth A2DP）等，

android 系统默认有自己的音频输出优先级，那我们可以按照需求定制自己的音频切换方式么？答案是可以的。即可以在应用层修改，也可以在Framework修改，今天讲的就是Framework层的修改，也就是修改AudioService。接下来我们先了解下基本的使用

一音频输出通道

//base/media/java/android/media/AudioSystem.java下
    @UnsupportedAppUsage
public static final int FORCE_NONE = 0;//默认通道
public static final int FORCE_SPEAKER = 1;//扬声器通道
public static final int FORCE_HEADPHONES = 2;//耳机通道
//下面两个是蓝牙耳机通道
public static final int FORCE_BT_SCO = 3;//是一种双向的音频数据的传输链路,只能用于普通语音的传输,不能用于播放音乐
public static final int FORCE_BT_A2DP = 4;//是一种单向的高品质音频数据传输链路，通常用于播放立体声音乐
public static final int FORCE_WIRED_ACCESSORY = 5;//有线设备通道，如有线耳机
    @UnsupportedAppUsage
    public static final int FORCE_BT_CAR_DOCK = 6;
    @UnsupportedAppUsage
    public static final int FORCE_BT_DESK_DOCK = 7;
    @UnsupportedAppUsage
    public static final int FORCE_ANALOG_DOCK = 8;
    @UnsupportedAppUsage
    public static final int FORCE_DIGITAL_DOCK = 9;
    public static final int FORCE_NO_BT_A2DP = 10;
    public static final int FORCE_SYSTEM_ENFORCED = 11;
    public static final int FORCE_HDMI_SYSTEM_AUDIO_ENFORCED = 12;
    public static final int FORCE_ENCODED_SURROUND_NEVER = 13;
    public static final int FORCE_ENCODED_SURROUND_ALWAYS = 14;
    public static final int FORCE_ENCODED_SURROUND_MANUAL = 15;
    public static final int NUM_FORCE_CONFIG = 16;
    public static final int FORCE_DEFAULT = FORCE_NONE;

常用的也就是：扬声器，有线耳机，听筒，蓝牙耳机等； 

二 音频模式的理解和使用

• 音频模式设置的使用：

   public static void setSpeakerNormal(Context context, int mode) {
          Log.e(TAG, "setSpeakerNormal: " + on);
          AudioManager am=(AudioManager)context.getSystemService(Context.AUDIO_SERVICE);    
          am.setMode(mode);
      }

•  音频模式的选项：

  在使用音频输出通道时，需要指定播放模式，设置音频模式的方法audioManager.setMode()方法的值有如下几种：

   

  //base/media/java/android/media/AudioManager.java下
      /* modes for setMode/getMode/setRoute/getRoute */
      /**
       * Audio harware modes.
       */
      /**
       * Invalid audio mode.
       */
      public static final int MODE_INVALID            = AudioSystem.MODE_INVALID;
      /**
       * Current audio mode. Used to apply audio routing to current mode.
       */
      public static final int MODE_CURRENT            = AudioSystem.MODE_CURRENT;
      /**
       * Normal audio mode: not ringing and no call established.
       */
      public static final int MODE_NORMAL             = AudioSystem.MODE_NORMAL;
      /**
       * Ringing audio mode. An incoming is being signaled.
       */
      public static final int MODE_RINGTONE           = AudioSystem.MODE_RINGTONE;
      /**
       * In call audio mode. A telephony call is established.
       */
      public static final int MODE_IN_CALL            = AudioSystem.MODE_IN_CALL;
      /**
       * In communication audio mode. An audio/video chat or VoIP call is established.
       */
      public static final int MODE_IN_COMMUNICATION   = AudioSystem.MODE_IN_COMMUNICATION;

  可用的模式有：MODE_NORMAL，//默认（平时）状态

                           MODE_RINGTONE，//响玲模式

                           MODE_IN_CALL，//通话模式

                           MODE_IN_COMMUNICATION//（非通话）切换至听筒模式
  

  其引用的AudioSystem，该类定义如下

  AudioSystem.java
  /* modes for setPhoneState, must match AudioSystem.h audio_mode */
  public static final int MODE_INVALID            = -2;
  public static final int MODE_CURRENT            = -1;
  public static final int MODE_NORMAL             = 0;//待机模式，既不是铃声模式也不是通话模式,如music
  public static final int MODE_RINGTONE           = 1;//铃声模式
  public static final int MODE_IN_CALL            = 2;//音频通话模式
  public static final int MODE_IN_COMMUNICATION   = 3;//通信模式，包括音/视频,VoIP通话.(3.0加入的，与通话模式类似)
  public static final int NUM_MODES               = 4;

• 设备默认模式：MODE_NORMAL：

  public static void setSpeakerNormal(Context context) {
          AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);  
  am.setMode(AudioManager.MODE_NORMAL); 
   }

•   设置听筒模式（非通话）：MODE_IN_COMMUNICATION

  public static void setTingtong(Context context) {
     Log.e(TAG, "setTingtong start ");
     AudioManager am = (AudioManager)context.
                 getSystemService(Context.AUDIO_SERVICE);
     am.setSpeakerphoneOn(false);
     am.setMode(AudioManager.MODE_IN_COMMUNICATION);
  }

  •  设置通话模式

          public static void setInCall(Context context) {
            Log.e(TAG, "setTingtong start ");
            AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
            am.setSpeakerphoneOn(false);
            am.setMode(AudioManager.MODE_IN_CALL);
        }

    三 流类型

    设置播放模式的时候，需要考虑流类型，常用的流类型有：

    //base/media/java/android/media/AudioSystem.java下
    /* These values must be kept in sync with system/audio.h */
        /*
         * If these are modified, please also update Settings.System.VOLUME_SETTINGS
         * and attrs.xml and AudioManager.java.
         */
        /** Used to identify the default audio stream volume */
        public static final int STREAM_DEFAULT = -1;
        /** Used to identify the volume of audio streams for phone calls */
        public static final int STREAM_VOICE_CALL = 0;//用于电话通话的音频流。
        /** Used to identify the volume of audio streams for system sounds */
        public static final int STREAM_SYSTEM = 1;//用于系统声音的音频流
        /** Used to identify the volume of audio streams for the phone ring and message alerts */
        public static final int STREAM_RING = 2;//用于电话铃声的音频流
        /** Used to identify the volume of audio streams for music playback */
        public static final int STREAM_MUSIC = 3;//用于音乐播放的音频流
        /** Used to identify the volume of audio streams for alarms */
        public static final int STREAM_ALARM = 4;//用于警报的音频流
        /** Used to identify the volume of audio streams for notifications */
        public static final int STREAM_NOTIFICATION = 5;//用于通知的音频流
        /** Used to identify the volume of audio streams for phone calls when connected on bluetooth */
        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;//DTMF音调的音频流。
        /** Used to identify the volume of audio streams exclusively transmitted through the
         *  speaker (TTS) of the device */
        public static final int STREAM_TTS = 9;//文本到语音转换（TTS）的音频流。	
        /** Used to identify the volume of audio streams for accessibility prompts */
        public static final int STREAM_ACCESSIBILITY = 10;//辅助功能提示音频流

    四 音频输出通道，播放模式和流类型的关系

    音频通道是与播放模式一起用的，而播放模式与音频流类型有关系；
    (1)音频通道是指声音从哪里出来，这个容易理解；
    (2)播放模式，也叫音频状态，手机有4种音频状态：待机状态，音视频通话状态，视频/VoIP通话状态与响铃状态。这4种状态对底层的音频输出设备的选择影响很大，相应的情景下就得使用相应的模式，如视频情景的播放模式就是MODE_IN_COMMUNICATION，或者，播放音乐情景的播放模式就是MODE_NORMAL，什么样的情形就得用什么样的播放模式，不能搞混，比如MODE_IN_CALL，就只能由通话时才能使用；
    (3)音频流类型，我们操作手机的音频时需要指定操作的是哪一个流，虽然手机的中音频流类型有很多，但是一旦进入到属性里，android就会将其整理成几种类型，这才是实际的类型，与上面的播放模式对应；

      五 audioManager.setMode(int mode)的源码实现

    1.    在AudioManager类中的实现

       /**
            * Sets the audio mode.
            * 
       
            * The audio mode encompasses audio routing AND the behavior of
            * the telephony layer. Therefore this method should only be used by applications that
            * replace the platform-wide management of audio settings or the main telephony application.
            * In particular, the {@link #MODE_IN_CALL} mode should only be used by the telephony
            * application when it places a phone call, as it will cause signals from the radio layer
            * to feed the platform mixer.
            *
            * @param mode  the requested audio mode ({@link #MODE_NORMAL}, {@link #MODE_RINGTONE},
            *              {@link #MODE_IN_CALL} or {@link #MODE_IN_COMMUNICATION}).
            *              Informs the HAL about the current audio state so that
            *              it can route the audio appropriately.
            */
           public void setMode(int mode) {
               final IAudioService service = getService();
               try {
                   service.setMode(mode, mICallBack, mApplicationContext.getOpPackageName());
               } catch (RemoteException e) {
                   throw e.rethrowFromSystemServer();
               }
           }

    2.  接下来是AudioService中方法的实现

         /** @see AudioManager#setMode(int) */
           public void setMode(int mode, IBinder cb, String callingPackage) {
               if (DEBUG_MODE) { Log.v(TAG, "setMode(mode=" + mode + ", callingPackage=" + callingPackage + ")"); }
              //检测权限不合法，return 
              if (!checkAudioSettingsPermission("setMode()")) {
                   return;
               }
               //通话模式下，无权限return
               if ( (mode == AudioSystem.MODE_IN_CALL) &&
                       (mContext.checkCallingOrSelfPermission(
                               android.Manifest.permission.MODIFY_PHONE_STATE)
                                   != PackageManager.PERMISSION_GRANTED)) {
                   Log.w(TAG, "MODIFY_PHONE_STATE Permission Denial: setMode(MODE_IN_CALL) from pid="
                           + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
                   return;
               }
               //新的mode值不合法return
               if (mode = AudioSystem.NUM_MODES) {
                   return;
               }
               int oldModeOwnerPid = 0;
               int newModeOwnerPid = 0;
               synchronized (mDeviceBroker.mSetModeLock) {
                   if (!mSetModeDeathHandlers.isEmpty()) {
                       oldModeOwnerPid = mSetModeDeathHandlers.get(0).getPid();
                   }
                   if (mode == AudioSystem.MODE_CURRENT) {
                       mode = mMode;
                   }
                   //设置新的模式值，如果此次设置的音频播放模式和上一次的不同,返回这次使用新音频播放模式的进程的pid
                   newModeOwnerPid = setModeInt(mode, cb, Binder.getCallingPid(), callingPackage);
               }
               // when entering RINGTONE, IN_CALL or IN_COMMUNICATION mode, clear all
               // SCO connections not started by the application changing the mode when 
       pid changes
               ///如果进入了RINGTONE, IN_CALL 或者IN_COMMUNICATION模式,清除掉当前更改音频模式的应用进程的蓝牙SCO连接
               if ((newModeOwnerPid != oldModeOwnerPid) && (newModeOwnerPid != 0)) {
                   mDeviceBroker.postDisconnectBluetoothSco(newModeOwnerPid);
               }
           }
       

    //设置新的模式值

    newModeOwnerPid = setModeInt(mode, cb, Binder.getCallingPid(), callingPackage);

           3.  setModeInt的实现

    // setModeInt() returns a valid PID if the audio mode was successfully set to
        // any mode other than NORMAL.
        @GuardedBy("mDeviceBroker.mSetModeLock")
        private int setModeInt(int mode, IBinder cb, int pid, String caller) {
            if (DEBUG_MODE) { Log.v(TAG, "setModeInt(mode=" + mode + ", pid=" + pid + ", caller="
                    + caller + ")"); }
            int newModeOwnerPid = 0;
            if (cb == null) {
                Log.e(TAG, "setModeInt() called with null binder");
                return newModeOwnerPid;
            }
            if(caller != null && caller.equals("com.android.soundrecorder") && mode == AudioSystem.MODE_IN_CALL) {
                mIsSoundRecorderPlayInEARPIECE = true;
            }else{
                mIsSoundRecorderPlayInEARPIECE = false;
            }
            SetModeDeathHandler hdlr = null;
            Iterator iter = mSetModeDeathHandlers.iterator();
            //循环遍历mSetModeDeathHandlers,找到与传递进来的相同pid的SetModeDeathHandler,并赋值给hdlr,
        //相同的pid也就是相同的应用,即找到相同的应用
            while (iter.hasNext()) {
                SetModeDeathHandler h = (SetModeDeathHandler)iter.next();
                if (h.getPid() == pid) {
                    hdlr = h;
                    // Remove from client list so that it is re-inserted at top of list
                    iter.remove();
                    hdlr.getBinder().unlinkToDeath(hdlr, 0);
                    break;
                }
            }
            final int oldMode = mMode;
            int status = AudioSystem.AUDIO_STATUS_OK;
            int actualMode;
            do {
                //将传递进来的mode赋值初始化实际的播放模式
                actualMode = mode;
                //如果设置的模式是正常的播放模式,那就从mSetModeDeathHandlers列表的顶端获取一个模式给actualMode,
            //最近一次设置非正常音频模式的应用都会被放在mSetModeDeathHandlers的顶端
                if (mode == AudioSystem.MODE_NORMAL) {
                    // get new mode from client at top the list if any
                    if (!mSetModeDeathHandlers.isEmpty()) {
                        hdlr = mSetModeDeathHandlers.get(0);
                        cb = hdlr.getBinder();
                        actualMode = hdlr.getMode();
                        if (DEBUG_MODE) {
                            Log.w(TAG, " using mode=" + mode + " instead due to death hdlr at pid="
                                    + hdlr.mPid);
                        }
                    }
                } else {
                    if (hdlr == null) {
                        hdlr = new SetModeDeathHandler(cb, pid);
                    }
                    // Register for client death notification
                    try {
                        cb.linkToDeath(hdlr, 0);
                    } catch (RemoteException e) {
                        // Client has died!
                        Log.w(TAG, "setMode() could not link to "+cb+" binder death");
                    }
                    // Last client to call setMode() is always at top of client list
                    // as required by SetModeDeathHandler.binderDied()
                    //将hdlr加到mSetModeDeathHandlers中,并放到首位,也就是最后一个调用setMode()的进程位于列表的顶部
                    mSetModeDeathHandlers.add(0, hdlr);
                //设置当前进程的音频播放模式,hdlr.setMode()会将mode设置给mMode,这个要注意,要不然很容易跟下面的"actualMode != mMode"混淆
                    hdlr.setMode(mode);
                }
                if (actualMode != mMode) {
                    final long identity = Binder.clearCallingIdentity();
                //通过AudioSystem将当前的音频模式设置到底层去,status返回设置的结果
                    status = AudioSystem.setPhoneState(actualMode);
                    Binder.restoreCallingIdentity(identity);
                    if (status == AudioSystem.AUDIO_STATUS_OK) {
                        if (DEBUG_MODE) { Log.v(TAG, " mode successfully set to " + actualMode); }
                    //如果设置成功,保存当前的音频播放模式
                        mMode = actualMode;
                    } else {
                        if (hdlr != null) {
                    //如果设置不成功,从mSetModeDeathHandlers中删除该应用
                            mSetModeDeathHandlers.remove(hdlr);
                            cb.unlinkToDeath(hdlr, 0);
                        }
                        // force reading new top of mSetModeDeathHandlers stack
                        if (DEBUG_MODE) { Log.w(TAG, " mode set to MODE_NORMAL after phoneState pb"); }
                        mode = AudioSystem.MODE_NORMAL;
                    }
                } else {
                    status = AudioSystem.AUDIO_STATUS_OK;
                }
            } while (status != AudioSystem.AUDIO_STATUS_OK && !mSetModeDeathHandlers.isEmpty());
            if (status == AudioSystem.AUDIO_STATUS_OK) {
                if (actualMode != AudioSystem.MODE_NORMAL) {
                    if (mSetModeDeathHandlers.isEmpty()) {
                        Log.e(TAG, "setMode() different from MODE_NORMAL with empty mode client stack");
                    } else {
                    //如果这个进程设置的音频模式为非正常模式,那就返回这个进程的pid
                        newModeOwnerPid = mSetModeDeathHandlers.get(0).getPid();
                    }
                }
                // Note: newModeOwnerPid is always 0 when actualMode is MODE_NORMAL
                mModeLogger.log(
                        new PhoneStateEvent(caller, pid, mode, newModeOwnerPid, actualMode));
            //下面的代码用来设置当前音频流类型的音量
                int streamType = getActiveStreamType(AudioManager.USE_DEFAULT_STREAM_TYPE);
                int device = getDeviceForStream(streamType);
                int index = mStreamStates[mStreamVolumeAlias[streamType]].getIndex(device);
                setStreamVolumeInt(mStreamVolumeAlias[streamType], index, device, true, caller);
                updateStreamVolumeAlias(true /*updateVolumes*/, caller);
                // change of mode may require volume to be re-applied on some devices
                updateAbsVolumeMultiModeDevices(oldMode, actualMode);
            }
            return newModeOwnerPid;
        }
    

    AudioService用mMode来保存当前的音频播放模式。

    六 设置音频输出管道

     设置音频输出管道的方法有两个分别是setSpeakerphoneOn()和setBluetoothScoOn()，我们来就看下最常用的设置扬声器播放；

     /**
         * Sets the speakerphone on or off.
         * 
    
         * This method should only be used by applications that replace the platform-wide
         * management of audio settings or the main telephony application.
         *
         * @param on set true to turn on speakerphone;
         *           false to turn it off
         *true 是开启扬声器，false关闭扬声器
         */
        public void setSpeakerphoneOn(boolean on){
            final IAudioService service = getService();
            try {
                service.setSpeakerphoneOn(on);
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }

    以上方法是调用AudioService中的setSpeakerphoneOn（boolean on）

    看下AudioSevice中该方法的实现

    /** @see AudioManager#setSpeakerphoneOn(boolean) */
        public void setSpeakerphoneOn(boolean on){
            //检查android.Manifest.permission.MODIFY_AUDIO_SETTINGS是否允许
            if (!checkAudioSettingsPermission("setSpeakerphoneOn()")) {
                return;
            }
            //通话模式，检查权限是否允许
            if (mContext.checkCallingOrSelfPermission(
                    android.Manifest.permission.MODIFY_PHONE_STATE)
                    != PackageManager.PERMISSION_GRANTED) {
                synchronized (mSetModeDeathHandlers) {
                    for (SetModeDeathHandler h : mSetModeDeathHandlers) {
                        if (h.getMode() == AudioSystem.MODE_IN_CALL) {
                            Log.w(TAG, "getMode is call, Permission Denial: setSpeakerphoneOn from pid="
                                    + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
                            return;
                        }
                    }
                }
            }
            // for logging only
            final String eventSource = new StringBuilder("setSpeakerphoneOn(").append(on)
                    .append(") from u/pid:").append(Binder.getCallingUid()).append("/")
                    .append(Binder.getCallingPid()).toString();
            //设置扬声器开/关
            final boolean stateChanged = mDeviceBroker.setSpeakerphoneOn(on, eventSource);
            if (stateChanged) {
                //设置成功
                final long ident = Binder.clearCallingIdentity();
                try {
                    //发送成功后，发送扬声器状态改变的广播
                    mContext.sendBroadcastAsUser(
                            new Intent(AudioManager.ACTION_SPEAKERPHONE_STATE_CHANGED)
                                    .setFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY), UserHandle.ALL);
                } finally {
                    Binder.restoreCallingIdentity(ident);
                }
            }
        }

    以上方法体中使用 final boolean stateChanged = mDeviceBroker.setSpeakerphoneOn(on, eventSource); 修改扬声器开关。返回true，则修改成功。该方法在AudioDeviceBroker中实现

    /**
         * Turns speakerphone on/off
         * @param on
         * @param eventSource for logging purposes
         * @return true if speakerphone state changed
         */
        /*package*/ boolean setSpeakerphoneOn(boolean on, String eventSource) {
            synchronized (mDeviceStateLock) {
                final boolean wasOn = isSpeakerphoneOn();
                if (on) {
            //开启扬声器
                    if (mForcedUseForComm == AudioSystem.FORCE_BT_SCO) {
                        setForceUse_Async(AudioSystem.FOR_RECORD, AudioSystem.FORCE_NONE, eventSource);
                    }
            //进入扬声器播放的标志AudioSystem.FORCE_SPEAKER
                    mForcedUseForComm = AudioSystem.FORCE_SPEAKER;
                } else if (mForcedUseForComm == AudioSystem.FORCE_SPEAKER) {
                    //取消扬声器
                    mForcedUseForComm = AudioSystem.FORCE_NONE;
                }
                mForcedUseForCommExt = mForcedUseForComm;
        //此时是语音模式AudioSystem.FOR_COMMUNICATION,mForcedUseForComm表示当前是哪种音频通道
                setForceUse_Async(AudioSystem.FOR_COMMUNICATION, mForcedUseForComm, eventSource);
                return (wasOn != isSpeakerphoneOn());
            }
        }

    以上方法中可以看到AudioService用mForcedUseForComm和mForcedUseForCommExt保存了当前的音频通道。以上方法根据状态设置对应的模式使用方法 setForceUse_Async(AudioSystem.FOR_COMMUNICATION, mForcedUseForComm, eventSource);

    /*package*/ void setForceUse_Async(int useCase, int config, String eventSource) {
             //传递进来的参数封装,交给mAudioHandler处理；
            //arg1是AudioSystem.FOR_COMMUNICATION, arg2是mForcedUseForComm, 
            //obj是eventSource,eventSource就是调用扬声器的进程的信息
                sendIILMsgNoDelay(MSG_IIL_SET_FORCE_USE, SENDMSG_QUEUE,
                    useCase, config, eventSource);
        }
    

    我们看下sendIILMsgNoDelay方法的实现

    private void sendIILMsgNoDelay(int msg, int existingMsgPolicy, int arg1, int arg2, Object obj) {
            sendIILMsg(msg, existingMsgPolicy, arg1, arg2, obj, 0);
        }
        private void sendIILMsg(int msg, int existingMsgPolicy, int arg1, int arg2, Object obj,
                                int delay) {
            if (existingMsgPolicy == SENDMSG_REPLACE) {
                mBrokerHandler.removeMessages(msg);
            } else if (existingMsgPolicy == SENDMSG_NOOP && mBrokerHandler.hasMessages(msg)) {
                return;
            }
            if (isMessageHandledUnderWakelock(msg)) {
                final long identity = Binder.clearCallingIdentity();
                try {
                    mBrokerEventWakeLock.acquire(BROKER_WAKELOCK_TIMEOUT_MS);
                } catch (Exception e) {
                    Log.e(TAG, "Exception acquiring wakelock", e);
                }
                Binder.restoreCallingIdentity(identity);
            }
            synchronized (sLastDeviceConnectionMsgTimeLock) {
                long time = SystemClock.uptimeMillis() + delay;
                switch (msg) {
                    case MSG_IL_SET_A2DP_SOURCE_CONNECTION_STATE:
                    case MSG_IL_SET_A2DP_SINK_CONNECTION_STATE:
                    case MSG_IL_SET_HEARING_AID_CONNECTION_STATE:
                    case MSG_L_SET_WIRED_DEVICE_CONNECTION_STATE:
                    case MSG_IL_BTA2DP_DOCK_TIMEOUT:
                    case MSG_L_A2DP_DEVICE_CONFIG_CHANGE:
                    case MSG_L_A2DP_ACTIVE_DEVICE_CHANGE:
                        if (sLastDeviceConnectMsgTime >= time) {
                            // add a little delay to make sure messages are ordered as expected
                            time = sLastDeviceConnectMsgTime + 30;
                        }
                        sLastDeviceConnectMsgTime = time;
                        break;
                    default:
                        break;
                }
    private void sendIILMsgNoDelay(int msg, int existingMsgPolicy, int arg1, int arg2, Object obj) {
            sendIILMsg(msg, existingMsgPolicy, arg1, arg2, obj, 0);
        }
        private void sendIILMsg(int msg, int existingMsgPolicy, int arg1, int arg2, Object obj,
                                int delay) {
            if (existingMsgPolicy == SENDMSG_REPLACE) {
                mBrokerHandler.removeMessages(msg);
            } else if (existingMsgPolicy == SENDMSG_NOOP && mBrokerHandler.hasMessages(msg)) {
                return;
            }
            if (isMessageHandledUnderWakelock(msg)) {
                final long identity = Binder.clearCallingIdentity();
                try {
                    mBrokerEventWakeLock.acquire(BROKER_WAKELOCK_TIMEOUT_MS);
                } catch (Exception e) {
                    Log.e(TAG, "Exception acquiring wakelock", e);
                }
                Binder.restoreCallingIdentity(identity);
            }
            synchronized (sLastDeviceConnectionMsgTimeLock) {
                long time = SystemClock.uptimeMillis() + delay;
                switch (msg) {
                    case MSG_IL_SET_A2DP_SOURCE_CONNECTION_STATE:
                    case MSG_IL_SET_A2DP_SINK_CONNECTION_STATE:
                    case MSG_IL_SET_HEARING_AID_CONNECTION_STATE:
                    case MSG_L_SET_WIRED_DEVICE_CONNECTION_STATE:
                    case MSG_IL_BTA2DP_DOCK_TIMEOUT:
                    case MSG_L_A2DP_DEVICE_CONFIG_CHANGE:
                    case MSG_L_A2DP_ACTIVE_DEVICE_CHANGE:
                        if (sLastDeviceConnectMsgTime >= time) {
                            // add a little delay to make sure messages are ordered as expected
                            time = sLastDeviceConnectMsgTime + 30;
                        }
                        sLastDeviceConnectMsgTime = time;
                        break;
                    default:
                        break;
                }
             //传递进来的参数封装,交给mAudioHandler处理；
            //arg1是AudioSystem.FOR_COMMUNICATION, arg2是mForcedUseForComm, 
            //obj是eventSource,eventSource就是调用扬声器的进程的信息
            mBrokerHandler.sendMessageAtTime(mBrokerHandler.obtainMessage(msg, arg1, arg2, obj),
                        time);
            }
        }
                mBrokerHandler.sendMessageAtTime(mBrokerHandler.obtainMessage(msg, arg1, arg2, obj),
                        time);
            }
        }

    根据代码逻辑看Message的参数arg1,arg2,obj 三个参数的意义

     arg1 = AudioSystem.FOR_COMMUNICATION

    arg2  = mForcedUseForComm,

    obj = eventSource//eventSource就是调用扬声器的进程的信息

    以上方法发送消息 消息接收

     case MSG_IIL_SET_FORCE_USE: // intended fall-through
                    case MSG_IIL_SET_FORCE_BT_A2DP_USE:
                        onSetForceUse(msg.arg1, msg.arg2, (String) msg.obj);

     该方法的实现

    //---------------------------------------------------------------------
        // Internal handling of messages
        // These methods are ALL synchronous, in response to message handling in BrokerHandler
        // Blocking in any of those will block the message queue
        private void onSetForceUse(int useCase, int config, String eventSource) {
            Log.d(TAG, "onSetForceUse  usage= "+useCase+"  config= "+config+"  eventSource="+eventSource);
            if (useCase == AudioSystem.FOR_MEDIA) {
                postReportNewRoutes();
            }
            AudioService.sForceUseLogger.log(
                    new AudioServiceEvents.ForceUseEvent(useCase, config, eventSource));
            //将语音模式AudioSystem.FOR_COMMUNICATION,音频通道mForcedUseForComm交给AudioSystem,
            //AudioSystem会将其设置到HAL底层        
            AudioSystem.setForceUse(useCase, config);
        }

    AudioService在调用AudioSystem.setForceUse(usage, config)方法时，会将相应的音频播放模式和音频通道设置到底层，从这里可以就看出，为什么在调用setSpeakerphoneOn()时要结合setMode()一起使用了；

    我们看到调用了AudioSystem的setForceUse方法，该在AudioSystem中的实现 是一个native方法。

    //base/media/java/android/media/AudioSystem.java
    @UnsupportedAppUsage
    public static native int setForceUse(int usage, int config);

    总结：

    疑惑：

    前面介绍中就说了android手机中有很多的音频输出通道，为啥AudioService只提供了setSpeakerphoneOn()和setBluetoothScoOn这两个手动切换音频输出通道的方法呢？

    之所以AudioService只提供这两个方法，是因为有些切换是系统自动完成的，比如有线耳机，蓝牙耳机的插入和拔出等，这些音频外设的切换在应用层是无法处理的；

    听筒，扬声器，有线耳机这三个输出设备的切换

    1)听筒通道

    听筒模式一般只会在通话或者语音过程中才会用到，所以，要使用听筒模式，必须得指定播放模式为MODE_IN_CALL或者是MODE_IN_COMMUNICATION；MODE_IN_CALL只有在通话时才可以用到。非通话时使用MODE_IN_COMMUNICATION。

    2)扬声器通道

    在不插入音频外设如耳机的情况下，手机中的输出设备只有听筒和扬声器，要想在听筒和扬声器中切换是比较容易的，无非就是setSpeakerphoneOn(boolean)方法调用以及设置播放模式为MODE_IN_CALL或者MODE_IN_COMMUNICATION；

    3)有线耳机

    耳机是音频外设，此时手机中的音频输出设备有3个，除了耳机还有听筒和扬声器；那底层是怎样选择一个设备进行音频输出的呢？这就和音频系统中的音频路由策略有关，底层在播放音频时会选择一个设备，这个逻辑跟设备的优先级有关，代码在AudoPolicyServcie中，有时间在剖析这个具体原理；

    所以，当手机中的音频输出设备有耳机，听筒和扬声器时，会根据设备的优先级来进行选择；

    从测试的结果来看，3个当中，耳机的优先级最高，其次是听筒；

    参考文章：android音频系统(6)：AudioService之音频输出通道切换