阅读排行
首页 > 技术文章

Android 4.4音量键控制音量流程

1、在AudioManager.java中的handleKeyDown函数中接收音量键的按键消息
  1. public void handleKeyDown(KeyEvent event, int stream) {
  2.         int keyCode = event.getKeyCode();
  3.         switch (keyCode) {
  4.             case KeyEvent.KEYCODE_VOLUME_UP:
  5.             case KeyEvent.KEYCODE_VOLUME_DOWN:
  6.                 /*
  7.                  * Adjust the volume in on key down since it is more
  8.                  * responsive to the user.
  9.                  */
  10.                 int flags = FLAG_SHOW_UI | FLAG_VIBRATE;
  12.                 if (mUseMasterVolume) {
  13.                     adjustMasterVolume(
  14.                             keyCode == KeyEvent.KEYCODE_VOLUME_UP
  15.                                     ? ADJUST_RAISE
  16.                                     : ADJUST_LOWER,
  17.                             flags);
  18.                 } else {
  19.                     adjustSuggestedStreamVolume(
  20.                             keyCode == KeyEvent.KEYCODE_VOLUME_UP
  21.                                     ? ADJUST_RAISE
  22.                                     : ADJUST_LOWER,
  23.                             stream,
  24.                             flags);
  25.                 }
  26.                 break;
  27.             case KeyEvent.KEYCODE_VOLUME_MUTE:
  28.                 if (event.getRepeatCount() == 0) {
  29.                     if (mUseMasterVolume) {
  30.                         setMasterMute(!isMasterMute());
  31.                     } else {
  32.                         // TODO: Actually handle MUTE.
  33.                     }
  34.                 }
  35.                 break;
  36.         }
  37.     }
2、根据音量键调节走else分支，进入adjustSuggestedStreamVolume函数中
  1.     public void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags) {
  2.         IAudioService service = getService();
  3.         Log.d(TAG, "adjustSuggestedStreamVolume: Direction = " + direction
  4.         			+ ", streamType = " + suggestedStreamType);
  5.         try {
  6.             if (mUseMasterVolume) {
  7.                 service.adjustMasterVolume(direction, flags, mContext.getOpPackageName());
  8.             } else {
  9.                 service.adjustSuggestedStreamVolume(direction, suggestedStreamType, flags,
  10.                         mContext.getOpPackageName());
  11.             }
  12.         } catch (RemoteException e) {
  13.             Log.e(TAG, "Dead object in adjustSuggestedStreamVolume", e);
  14.         }
  15.     }
3、进入AudioService.java中的adjustSuggestedStreamVolume函数中
  1. public void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags,
  2.             String callingPackage) {
  3.         if (DEBUG_VOL) Log.d(TAG, "adjustSuggestedStreamVolume() stream="+suggestedStreamType+" direction ="+direction+" flags="+flags);
  4.         int streamType;
  5.         Log.d(TAG, "adjustSuggestedStreamVolume() mVolumeControlStream="+mVolumeControlStream);
  6.         if (mVolumeControlStream != -1) {
  7.             streamType = mVolumeControlStream;
  8.             Log.d(TAG, "adjustSuggestedStreamVolume() getMode()="+getMode());
  9.             Log.d(TAG, "adjustSuggestedStreamVolume() AudioSystem.isStreamActive(AudioSystem.STREAM_MUSIC, 0) ="+AudioSystem.isStreamActive(AudioSystem.STREAM_MUSIC, 0));
  10.             Log.d(TAG, "adjustSuggestedStreamVolume() AudioSystem.isStreamActive(AudioSystem.STREAM_VOICE_CALL, 0) ="+AudioSystem.isStreamActive(AudioSystem.STREAM_VOICE_CALL, 0));
  12.         } else {
  13.             streamType = getActiveStreamType(suggestedStreamType);
  14.         }
  15. 			Log.d(TAG, "adjustSuggestedStreamVolume() streamType2="+streamType);
  16.         // Play sounds on STREAM_RING only and if lock screen is not on.
  17.         if ((streamType != STREAM_REMOTE_MUSIC) &&
  18.                 (flags & AudioManager.FLAG_PLAY_SOUND) != 0 &&
  19.                 ((mStreamVolumeAlias[streamType] != AudioSystem.STREAM_RING)
  20.                  || (mKeyguardManager != null && mKeyguardManager.isKeyguardLocked()))) {
  21.             flags &= ~AudioManager.FLAG_PLAY_SOUND;
  22.         }
  24.         if (streamType == STREAM_REMOTE_MUSIC) {
  25.             // don‘t play sounds for remote
  26.             flags &= ~(AudioManager.FLAG_PLAY_SOUND|AudioManager.FLAG_FIXED_VOLUME);
  27.             //if (DEBUG_VOL) Log.i(TAG, "Need to adjust remote volume: calling adjustRemoteVolume()");
  28.             mMediaFocusControl.adjustRemoteVolume(AudioSystem.STREAM_MUSIC, direction, flags);
  29.         } else {
  30.             adjustStreamVolume(streamType, direction, flags, callingPackage);
  31.         }
  32.     }
4、进入adjustStreamVolume函数中
  2.     /** @see AudioManager#adjustStreamVolume(int, int, int) */
  3.     public void adjustStreamVolume(int streamType, int direction, int flags,
  4.             String callingPackage) {
  5.         if (mUseFixedVolume) {
  6.             return;
  7.         }
  8.         if (DEBUG_VOL) Log.d(TAG, "adjustStreamVolume() stream="+streamType+", dir="+direction);
  10.         ensureValidDirection(direction);
  11.         ensureValidStreamType(streamType);
  12.         Log.v(TAG,"adjustStreamVolume streamType1 : "+streamType);
  13.         
  14.         
  15.         // use stream type alias here so that streams with same alias have the same behavior,
  16.         // including with regard to silent mode control (e.g the use of STREAM_RING below and in
  17.         // checkForRingerModeChange() in place of STREAM_RING or STREAM_NOTIFICATION)
  18.         int streamTypeAlias = mStreamVolumeAlias[streamType];
  19.         VolumeStreamState streamState = mStreamStates[streamTypeAlias];
  20. 		
  21.         final int device = getDeviceForStream(streamTypeAlias);
  22. 		Log.v(TAG,"adjustStreamVolume streamTypeAlias : "+streamTypeAlias+" device:"+device);
  23.         int aliasIndex = streamState.getIndex(device);
  24.         boolean adjustVolume = true;
  25.         int step;
  27.         // skip a2dp absolute volume control request when the device
  28.         // is not an a2dp device
  29.         if ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) == 0 &&
  30.             (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) != 0) {
  31.             return;
  32.         }
  34.         if (mAppOps.noteOp(STEAM_VOLUME_OPS[streamTypeAlias], Binder.getCallingUid(),
  35.                 callingPackage) != AppOpsManager.MODE_ALLOWED) {
  36.             return;
  37.         }
  39.         // reset any pending volume command
  40.         synchronized (mSafeMediaVolumeState) {
  41.             mPendingVolumeCommand = null;
  42.         }
  44.         flags &= ~AudioManager.FLAG_FIXED_VOLUME;
  45.         if ((streamTypeAlias == AudioSystem.STREAM_MUSIC) &&
  46.                ((device & mFixedVolumeDevices) != 0)) {
  47.             flags |= AudioManager.FLAG_FIXED_VOLUME;
  49.             // Always toggle between max safe volume and 0 for fixed volume devices where safe
  50.             // volume is enforced, and max and 0 for the others.
  51.             // This is simulated by stepping by the full allowed volume range
  52.             if (mSafeMediaVolumeState == SAFE_MEDIA_VOLUME_ACTIVE &&
  53.                     (device & mSafeMediaVolumeDevices) != 0) {
  54.                 step = mSafeMediaVolumeIndex;
  55.             } else {
  56.                 step = streamState.getMaxIndex();
  57.             }
  58.             if (aliasIndex != 0) {
  59.                 aliasIndex = step;
  60.             }
  61.         } else {
  62.             // convert one UI step (+/-1) into a number of internal units on the stream alias
  63.             step = rescaleIndex(10, streamType, streamTypeAlias);
  64.         }
  66.         // If either the client forces allowing ringer modes for this adjustment,
  67.         // or the stream type is one that is affected by ringer modes
  68.         if (((flags & AudioManager.FLAG_ALLOW_RINGER_MODES) != 0) ||
  69.                 (streamTypeAlias == getMasterStreamType())) {
  70.             int ringerMode = getRingerMode();
  71.             // do not vibrate if already in vibrate mode
  72.             if (ringerMode == AudioManager.RINGER_MODE_VIBRATE) {
  73.                 flags &= ~AudioManager.FLAG_VIBRATE;
  74.             }
  75.             // Check if the ringer mode changes with this volume adjustment. If
  76.             // it does, it will handle adjusting the volume, so we won‘t below
  77.             adjustVolume = checkForRingerModeChange(aliasIndex, direction, step);
  78.         }
  80.         int oldIndex = mStreamStates[streamType].getIndex(device);
  82.         if (adjustVolume && (direction != AudioManager.ADJUST_SAME)) {
  84.             // Check if volume update should be send to AVRCP
  85.             if (streamTypeAlias == AudioSystem.STREAM_MUSIC &&
  86.                 (device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0 &&
  87.                 (flags & AudioManager.FLAG_BLUETOOTH_ABS_VOLUME) == 0) {
  88.                 synchronized (mA2dpAvrcpLock) {
  89.                     if (mA2dp != null && mAvrcpAbsVolSupported) {
  90.                         mA2dp.adjustAvrcpAbsoluteVolume(direction);
  91.                     }
  92.                 }
  93.             }
  95.             if ((direction == AudioManager.ADJUST_RAISE) &&
  96.                     !checkSafeMediaVolume(streamTypeAlias, aliasIndex + step, device)) {
  97.                 Log.e(TAG, "adjustStreamVolume() safe volume index = "+oldIndex);
  98.                 mVolumePanel.postDisplaySafeVolumeWarning(flags);
  99.             } else if (streamState.adjustIndex(direction * step, device)) {
  100.                 // Post message to set system volume (it in turn will post a message
  101.                 // to persist). Do not change volume if stream is muted.
  102.                 sendMsg(mAudioHandler,
  103.                         MSG_SET_DEVICE_VOLUME,
  104.                         SENDMSG_QUEUE,
  105.                         device,
  106.                         0,
  107.                         streamState,
  108.                         0);
  109.             }
  110.         }
  111.         int index = mStreamStates[streamType].getIndex(device);
  112.         sendVolumeUpdate(streamType, oldIndex, index, flags);
  113.     }
在sendMsg发送Message进入handler中处理，调用setDeviceVolume函数
  2.         private void setDeviceVolume(VolumeStreamState streamState, int device) {
  4.             // Apply volume
  5.             streamState.applyDeviceVolume(device);
  7.             // Apply change to all streams using this one as alias
  8.             int numStreamTypes = AudioSystem.getNumStreamTypes();
  9.             for (int streamType = numStreamTypes - 1; streamType >= 0; streamType--) {
  10.                 if (streamType != streamState.mStreamType &&
  11.                         mStreamVolumeAlias[streamType] == streamState.mStreamType) {
  12.                     // Make sure volume is also maxed out on A2DP device for aliased stream
  13.                     // that may have a different device selected
  14.                     int streamDevice = getDeviceForStream(streamType);
  15.                     if ((device != streamDevice) && mAvrcpAbsVolSupported &&
  16.                             ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0)) {
  17.                         mStreamStates[streamType].applyDeviceVolume(device);
  18.                     }
  19.                     mStreamStates[streamType].applyDeviceVolume(streamDevice);
  20.                 }
  21.             }
  23.             // Post a persist volume msg
  24.             sendMsg(mAudioHandler,
  25.                     MSG_PERSIST_VOLUME,
  26.                     SENDMSG_QUEUE,
  27.                     device,
  28.                     0,
  29.                     streamState,
  30.                     PERSIST_DELAY);
  32.         }
调用applyDeviceVolume函数
  2.         public void applyDeviceVolume(int device) {
  3.             int index;
  4.             if (isMuted()) {
  5.                 index = 0;
  6.             } else if ((device & AudioSystem.DEVICE_OUT_ALL_A2DP) != 0 &&
  7.                        mAvrcpAbsVolSupported) {
  8.                 index = (mIndexMax + 5)/10;
  9.             } else {
  10.                 index = (getIndex(device) + 5)/10;
  11.             }
  12. 	    	Log.d(TAG,"applyDeviceVolume  index:"+index + " mStreamType:" + mStreamType + ",device:" + device);
  13.             AudioSystem.setStreamVolumeIndex(mStreamType, index, device);
  14.         }
5、调用AudioSystem.java中的setStreamVolumeIndex函数
  1.     public static native int setStreamVolumeIndex(int stream, int index, int device);
6、调用AudioSystem.cpp函数中的setStreamVolumeIndex
  2. status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
  3.                                            int index,
  4.                                            audio_devices_t device)
  5. {
  6.     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
  7.     if (aps == 0) return PERMISSION_DENIED;
  8.     return aps->setStreamVolumeIndex(stream, index, device);
  9. }
7、调用AudioPolicyService.cpp中的setStreamVolumeIndex
  2. status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
  3.                                                   int index,
  4.                                                   audio_devices_t device)
  5. {
  6. 	ALOGD("AudioPolicyService::setStreamVolumeIndex");
  7.     if (mpAudioPolicy == NULL) {
  8.         return NO_INIT;
  9.     }
  10.     if (!settingsAllowed()) {
  11.         return PERMISSION_DENIED;
  12.     }
  13.     if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
  14.         return BAD_VALUE;
  15.     }
  16.     Mutex::Autolock _l(mLock);
  17.     if (mpAudioPolicy->set_stream_volume_index_for_device) {
  18. 		ALOGD("mpAudioPolicy->set_stream_volume_index_for_device");
  19.         return mpAudioPolicy->set_stream_volume_index_for_device(mpAudioPolicy,
  20.                                                                 stream,
  21.                                                                 index,
  22.                                                                 device);
  23.     } else {
  24.     	ALOGD("mpAudioPolicy->set_stream_volume_index");
  25.         return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index);
  26.     }
  27. }
8、调用AudioMTKPolicyManager.cpp中的setStreamVolumeIndex函数
  2. status_t AudioMTKPolicyManager::setStreamVolumeIndex(AudioSystem::stream_type stream,
  3.                                                       int index,
  4.                                                       audio_devices_t device)
  5. {
  6.     ALOGD("AudioMTKPolicyManager setStreamVolumeIndex stream = %d index = %d device = 0x%x",stream,index,device);
  7.     if ((index < mStreams[stream].mIndexMin) || (index > mStreams[stream].mIndexMax)) {
  8.         return BAD_VALUE;
  9.     }
  10.     if (!audio_is_output_device(device)) {
  11.         return BAD_VALUE;
  12.     }
  14.     // Force max volume if stream cannot be muted
  15.     if (!mStreams[stream].mCanBeMuted) index = mStreams[stream].mIndexMax;
  17.     ALOGV("setStreamVolumeIndex() stream %d, device %04x, index %d",
  18.           stream, device, index);
  20.     // if device is AUDIO_DEVICE_OUT_DEFAULT set default value and
  21.     // clear all device specific values
  22.     if (device == AUDIO_DEVICE_OUT_DEFAULT) {
  23.         mStreams[stream].mIndexCur.clear();
  24.     }
  25.     mStreams[stream].mIndexCur.add(device, index);
  27. #ifdef MTK_AUDIO
  28. #ifdef MTK_AUDIO_GAIN_TABLE
  29.         mAudioUCM->setStreamVolIndex(stream,index,device);
  30. #endif
  31. #endif
  33.     // compute and apply stream volume on all outputs according to connected device
  34.     status_t status = NO_ERROR;
  35.     for (size_t i = 0; i < mOutputs.size(); i++) {
  36.         audio_devices_t curDevice =
  37.                 getDeviceForVolume(mOutputs.valueAt(i)->device());
  38.         if ((device == AUDIO_DEVICE_OUT_DEFAULT) || (device == curDevice)) {
  39. #ifdef MTK_AUDIO
  40.             status_t volStatus;
  41.             // alps00053099  adjust matv volume  when record sound stoping, matv sound will out through speaker.
  42.             //  delay  -1 to put this volume command at the end of command queue in audiopolicy service
  43.             if(stream ==AudioSystem::MATV  &&(mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADSET ||mAvailableOutputDevices & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE))
  44.             {
  45.                 volStatus =checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice,-1);
  46.             }
  47.             else
  48.             {
  49.                 volStatus =checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice);
  50.             }
  51. #else
  52.             status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice);
  53. #endif
  54.             if (volStatus != NO_ERROR) {
  55.                 status = volStatus;
  56.             }
  57.         }
  58.     }
  59.     return status;
  60. }
9、真正设置是在checkAndSetVolume函数中执行
  2. status_t AudioMTKPolicyManager::checkAndSetVolume(int stream,
  3.                                                    int index,
  4.                                                    audio_io_handle_t output,
  5.                                                    audio_devices_t device,
  6.                                                    int delayMs,
  7.                                                    bool force)
  8. {
  10.     ALOGD(" checkAndSetVolume stream = %d index = %d output = %d device = 0x%x delayMs = %d force = %d"
  11.         ,stream,index,output,device,delayMs,force);
  13.     // do not change actual stream volume if the stream is muted
  14.     if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) {
  15.         ALOGVV("checkAndSetVolume() stream %d muted count %d",
  16.               stream, mOutputs.valueFor(output)->mMuteCount[stream]);
  17.         return NO_ERROR;
  18.     }
  20.     // do not change in call volume if bluetooth is connected and vice versa
  21.     if ((stream == AudioSystem::VOICE_CALL && mForceUse[AudioSystem::FOR_COMMUNICATION] == AudioSystem::FORCE_BT_SCO) ||
  22.         (stream == AudioSystem::BLUETOOTH_SCO && mForceUse[AudioSystem::FOR_COMMUNICATION] != AudioSystem::FORCE_BT_SCO)) {
  23.         ALOGD("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
  24.              stream, mForceUse[AudioSystem::FOR_COMMUNICATION]);
  25.         return INVALID_OPERATION;
  26.     }
  28. 	
  29.     float volume = computeVolume(stream, index, output, device);
  30. 	ALOGD("checkAndSetVolume volume = %f stream=%d device=%d",volume,stream,device);
  31.     
  32. #ifdef MTK_AUDIO
  33. #ifdef MTK_AUDIO_GAIN_TABLE
  34.     updateAnalogVolume(output,device,delayMs);
  35. #endif
  36. #endif
  38. #ifdef MTK_AUDIO
  39.      //for VT notify tone when incoming call. it‘s volume will be adusted in hardware.
  40.      if((stream == AudioSystem::VOICE_CALL ||stream == AudioSystem::BLUETOOTH_SCO) && mOutputs.valueFor(output)->mRefCount[stream]!=0 && mPhoneState==AudioSystem::MODE_IN_CALL)
  41.      {
  42.         volume =1.0;
  43.      }
  45.      // ALPS00554824 KH: If notifiaction is exist, FM should be mute
  46.      if ((stream == AudioSystem::FM) &&
  47.      	   (mOutputs.valueFor(output)->mRefCount[AudioSystem::NOTIFICATION]
  48.      	   	 || mOutputs.valueFor(output)->mRefCount[AudioSystem::RING]
  49.      	   	 || mOutputs.valueFor(output)->mRefCount[AudioSystem::ALARM]))
  50.      {
  51.         volume =0.0;
  52.      }
  54.     // ALPS001125976 Mute music at ringtone from BT to primary
  55.     //if ( (stream == AudioSystem::MUSIC) && (mPhoneState ==AudioSystem::MODE_RINGTONE) && (mStreams[AudioSystem::RING].getVolumeIndex(device)!=mStreams[AudioSystem::RING].mIndexMin) ) {
  56.     //    volume =0.0;
  57.     //}
  58. #endif
  59.     //ALOGD("checkAndSetVolume newvolume %f, oldvolume %f,output %d",volume,mOutputs.valueFor(output)->mCurVolume[stream],output);
  60.     // We actually change the volume if:
  61.     // - the float value returned by computeVolume() changed
  62.     // - the force flag is set
  63.     if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||
  64.             force
  65. #ifdef MTK_AUDIO
  66.     ||(stream==AudioSystem::FM && output==mPrimaryOutput && (device == AUDIO_DEVICE_OUT_WIRED_HEADSET ||device == AUDIO_DEVICE_OUT_WIRED_HEADPHONE) )//WFD output can‘t affect HwGain,however affect mFmVolume . But PrimaryOutput will use mFmVolume setting
  67. #endif
  68.     ) {
  70. #ifdef MTK_AUDIO
  71.         int bSetStreamVolume=1;
  72.         //Overall, Don‘t set volume to affect direct mode volume setting if the later routing is still direct mode . HoChi . This is very tricky that WFD support FM,others(BT/...) don‘t.
  73. #ifdef MATV_AUDIO_SUPPORT
  74. 		if( matv_use_analog_input == true){
  75.             if((stream==AudioSystem::MATV)&&(output!=mPrimaryOutput||device==AUDIO_DEVICE_NONE)&&device!=AUDIO_DEVICE_OUT_REMOTE_SUBMIX){
  76.                 bSetStreamVolume=0; //MATV with line-in path is only ouput from primaryoutput
  77.             }
  78. 		}
  79. #endif
  80.             //Add device==AUDIO_DEVICE_NONE for ALPS
  81.             if((stream==AudioSystem::FM)&&(output!=mPrimaryOutput||device==AUDIO_DEVICE_NONE)&&device!=AUDIO_DEVICE_OUT_REMOTE_SUBMIX){
  82.                 bSetStreamVolume=0; //FM with line-in path is only ouput from primaryoutput
  83.             }
  85.         if(bSetStreamVolume==1)
  86.         {
  87. #endif
  88.         mOutputs.valueFor(output)->mCurVolume[stream] = volume;
  89.         ALOGD("checkAndSetVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs);
  90.         // Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is
  91.         // enabled
  92.         if (stream == AudioSystem::BLUETOOTH_SCO) {
  93.             mpClientInterface->setStreamVolume(AudioSystem::VOICE_CALL, volume, output, delayMs);
  94.         }
  95.         mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);
  96. #ifdef MTK_AUDIO
  97.         }
  98.         else
  99.         {
  100.             ALOGD("skip setStreamVolume for output %d stream %d, volume %f, delay %d",output, stream, volume, delayMs);
  101.         }
  102. #endif
  103.     }
  105.     ALOGD("checkAndSetVolume() for output %d stream %d, volume %f, delay %d, loc 2", output, stream, volume, delayMs);
  107.     if (stream == AudioSystem::VOICE_CALL ||
  108.         stream == AudioSystem::BLUETOOTH_SCO) {
  109.         float voiceVolume;
  110.         // Force voice volume to max for bluetooth SCO as volume is managed by the headset
  111.         if (stream == AudioSystem::VOICE_CALL) {
  112. #ifdef MTK_AUDIO
  113. #ifndef MTK_AUDIO_GAIN_TABLE
  114.             voiceVolume = computeCustomVoiceVolume(stream, index, output, device);
  115. #endif
  116. #else
  117.             voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
  118. #endif
  120.         } else {
  121.             voiceVolume = 1.0;
  122.         }
  124. 		 ALOGD("checkAndSetVolume() voiceVolume %f mLastVoiceVolume %f mPrimaryOutput %d output %d",voiceVolume, mLastVoiceVolume,mPrimaryOutput,output);
  125.         if (voiceVolume != mLastVoiceVolume && output == mPrimaryOutput) {
  126. 			
  127. 			
  128.             mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
  129. #ifdef MTK_AUDIO
  130. #ifdef EVDO_DT_SUPPORT
  131.             ALOGD("SetVoiceVolumeIndex=%d %f,%f,%d", index, voiceVolume, mLastVoiceVolume, output == mPrimaryOutput);            
  132.             //set Volume Index ( for external modem)
  133.             AudioParameter param = AudioParameter();
  134.             param.addInt(String8("SetVoiceVolumeIndex"), index);
  135.             mpClientInterface->setParameters (0 , param.toString(), 0);
  136. #endif
  137. #endif
  138.             mLastVoiceVolume = voiceVolume;
  139.         }
  140.     }
  142.     return NO_ERROR;
  143. }
  1.  if (voiceVolume != mLastVoiceVolume && output == mPrimaryOutput) {
  2. 			
  3. 			
  4.             mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
  5. #ifdef MTK_AUDIO
  6. #ifdef EVDO_DT_SUPPORT
  7.             ALOGD("SetVoiceVolumeIndex=%d %f,%f,%d", index, voiceVolume, mLastVoiceVolume, output == mPrimaryOutput);            
  8.             //set Volume Index ( for external modem)
  9.             AudioParameter param = AudioParameter();
  10.             param.addInt(String8("SetVoiceVolumeIndex"), index);
  11.             mpClientInterface->setParameters (0 , param.toString(), 0);
  12. #endif
  13. #endif
  14.             mLastVoiceVolume = voiceVolume;
  15.         }
函数中经过判断本次音量与上次音量的比较 以及输出设备的比较正确的话，设置到底层
其中之前音量的设置会经过多次的计算，与音频参数等的计算




文章来自：http://www.cnblogs.com/Michelangelo/p/4710068.html
© 2021 jiaocheng.bubufx.com  联系我们
ICP备案：鲁ICP备09046678号-3