Android AudioService安全音量设置逻辑

问题点描述：
还原出厂设置后，第一次启动安卓系统会自动降音量设成10，导致开机时音量不一致问题。

原因：安全音量逻辑将音量设置为10

安全音量配置和音量值
\frameworks\base\core\res\res\values\config.xml

1. <!-- Safe headphone volume index. When music stream volume is below this index

2. the SPL on headphone output is compliant to EN 60950 requirements for portable music

3. players. -->

4. <integer name="config_safe_media_volume_index">10</integer>

6. <!-- Whether safe headphone volume is enabled or not (country specific). -->

7. <bool name="config_safe_media_volume_enabled">true</bool>

安全音量逻辑：
frameworks\base\services\core\java\com\android\server\audio\AudioService.java

​​​​​​​

1. // mSafeMediaVolumeDevices lists the devices for which safe media volume is enforced,

2. private final int mSafeMediaVolumeDevices = AudioSystem.DEVICE_OUT_WIRED_HEADSET |

3. AudioSystem.DEVICE_OUT_WIRED_HEADPHONE |

4. AudioSystem.DEVICE_OUT_USB_HEADSET;

7. ///

8. // Construction

9. ///

10. /** @hide */

11. public AudioService(Context context) {

12. //...

14. // The default safe volume index read here will be replaced by the actual value when

15. // the mcc is read by onConfigureSafeVolume()

16. mSafeMediaVolumeIndex = mContext.getResources().getInteger(

17. com.android.internal.R.integer.config_safe_media_volume_index) * 10;

19. //...

20. }

22. public void onSystemReady() {

23. //...

24. sendMsg(mAudioHandler,

25. MSG_CONFIGURE_SAFE_MEDIA_VOLUME_FORCED,

26. SENDMSG_REPLACE,

27. 0,

28. 0,

29. TAG,

30. SystemProperties.getBoolean("audio.safemedia.bypass", false) ?

31. 0 : SAFE_VOLUME_CONFIGURE_TIMEOUT_MS);

32. //...

33. }

35. /** Handles internal volume messages in separate volume thread. */

36. private class AudioHandler extends Handler {

37. //...

38. @Override

39. public void handleMessage(Message msg) {

40. switch (msg.what) {

41. case MSG_CONFIGURE_SAFE_MEDIA_VOLUME_FORCED:

42. case MSG_CONFIGURE_SAFE_MEDIA_VOLUME:

43. onConfigureSafeVolume((msg.what == MSG_CONFIGURE_SAFE_MEDIA_VOLUME_FORCED),

44. (String) msg.obj);

45. break;

46. }

47. }

48. //...

49. }

51. private void onConfigureSafeVolume(boolean force, String caller) {

52. synchronized (mSafeMediaVolumeState) {

53. int mcc = mContext.getResources().getConfiguration().mcc;

54. if ((mMcc != mcc) || ((mMcc == 0) && force)) {

55. mSafeMediaVolumeIndex = mContext.getResources().getInteger(

56. com.android.internal.R.integer.config_safe_media_volume_index) * 10;

58. mSafeUsbMediaVolumeIndex = getSafeUsbMediaVolumeIndex();

60. boolean safeMediaVolumeEnabled =

61. SystemProperties.getBoolean("audio.safemedia.force", false)

62. || mContext.getResources().getBoolean(

63. com.android.internal.R.bool.config_safe_media_volume_enabled);

65. boolean safeMediaVolumeBypass =

66. SystemProperties.getBoolean("audio.safemedia.bypass", false);

68. // The persisted state is either "disabled" or "active": this is the state applied

69. // next time we boot and cannot be "inactive"

70. int persistedState;

71. if (safeMediaVolumeEnabled && !safeMediaVolumeBypass) {

72. persistedState = SAFE_MEDIA_VOLUME_ACTIVE;

73. // The state can already be "inactive" here if the user has forced it before

74. // the 30 seconds timeout for forced configuration. In this case we don't reset

75. // it to "active".

76. if (mSafeMediaVolumeState != SAFE_MEDIA_VOLUME_INACTIVE) {

77. if (mMusicActiveMs == 0) {

78. mSafeMediaVolumeState = SAFE_MEDIA_VOLUME_ACTIVE;

79. enforceSafeMediaVolume(caller);

80. } else {

81. // We have existing playback time recorded, already confirmed.

82. mSafeMediaVolumeState = SAFE_MEDIA_VOLUME_INACTIVE;

83. }

84. }

85. } else {

86. persistedState = SAFE_MEDIA_VOLUME_DISABLED;

87. mSafeMediaVolumeState = SAFE_MEDIA_VOLUME_DISABLED;

88. }

89. mMcc = mcc;

90. sendMsg(mAudioHandler,

91. MSG_PERSIST_SAFE_VOLUME_STATE,

92. SENDMSG_QUEUE,

93. persistedState,

94. 0,

95. null,

96. 0);

97. }

98. }

99. }

101. private void enforceSafeMediaVolume(String caller) {

102. VolumeStreamState streamState = mStreamStates[AudioSystem.STREAM_MUSIC];

103. int devices = mSafeMediaVolumeDevices;

104. int i = 0;

106. while (devices != 0) {

107. int device = 1 << i++;

108. if ((device & devices) == 0) {

109. continue;

110. }

111. int index = streamState.getIndex(device);

112. if (index > safeMediaVolumeIndex(device)) {

113. streamState.setIndex(safeMediaVolumeIndex(device), device, caller);

114. sendMsg(mAudioHandler,

115. MSG_SET_DEVICE_VOLUME,

116. SENDMSG_QUEUE,

117. device,

118. 0,

119. streamState,

120. 0);

121. }

122. devices &= ~device;

123. }

124. }

126. private int safeMediaVolumeIndex(int device) {

127. if ((device & mSafeMediaVolumeDevices) == 0) {

128. return MAX_STREAM_VOLUME[AudioSystem.STREAM_MUSIC];

129. }

130. if (device == AudioSystem.DEVICE_OUT_USB_HEADSET) {

131. return mSafeUsbMediaVolumeIndex;

132. } else {

133. return mSafeMediaVolumeIndex;

134. }

135. }

config_safe_media_volume_enabled

config_safe_media_volume_index

的配置是一个关键，决定了安全音量的功能是否有效已经安全音量的档位。

本文转载自: Android AudioService安全音量设置逻辑_快導碗里来的博客-优快云博客