| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.cellbroadcastreceiver; |
| |
| import static android.telephony.PhoneStateListener.LISTEN_NONE; |
| |
| import static com.android.cellbroadcastreceiver.CellBroadcastReceiver.DBG; |
| import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRSRC_CBR; |
| import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRTYPE_PLAYFLASH; |
| import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRTYPE_PLAYSOUND; |
| import static com.android.cellbroadcastservice.CellBroadcastMetrics.ERRTYPE_PLAYTTS; |
| |
| import android.app.AlarmManager; |
| import android.app.PendingIntent; |
| import android.app.Service; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.SharedPreferences; |
| import android.content.pm.PackageManager; |
| import android.content.res.AssetFileDescriptor; |
| import android.content.res.Resources; |
| import android.hardware.camera2.CameraAccessException; |
| import android.hardware.camera2.CameraCharacteristics; |
| import android.hardware.camera2.CameraManager; |
| import android.media.AudioAttributes; |
| import android.media.AudioDeviceInfo; |
| import android.media.AudioManager; |
| import android.media.MediaPlayer; |
| import android.media.MediaPlayer.OnCompletionListener; |
| import android.media.MediaPlayer.OnErrorListener; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.os.VibrationEffect; |
| import android.os.Vibrator; |
| import android.preference.PreferenceManager; |
| import android.provider.Settings; |
| import android.speech.tts.TextToSpeech; |
| import android.telephony.PhoneStateListener; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| |
| import com.android.cellbroadcastreceiver.CellBroadcastAlertService.AlertType; |
| import com.android.internal.annotations.VisibleForTesting; |
| |
| import java.util.Locale; |
| |
| /** |
| * Manages alert audio and vibration and text-to-speech. Runs as a service so that |
| * it can continue to play if another activity overrides the CellBroadcastListActivity. |
| */ |
| public class CellBroadcastAlertAudio extends Service implements TextToSpeech.OnInitListener, |
| TextToSpeech.OnUtteranceCompletedListener, AudioManager.OnAudioFocusChangeListener { |
| private static final String TAG = "CellBroadcastAlertAudio"; |
| |
| /** Action to start playing alert audio/vibration/speech. */ |
| @VisibleForTesting |
| public static final String ACTION_START_ALERT_AUDIO = "ACTION_START_ALERT_AUDIO"; |
| |
| /** Extra for message body to speak (if speech enabled in settings). */ |
| public static final String ALERT_AUDIO_MESSAGE_BODY = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_MESSAGE_BODY"; |
| |
| /** Extra for text-to-speech preferred language (if speech enabled in settings). */ |
| public static final String ALERT_AUDIO_MESSAGE_LANGUAGE = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_MESSAGE_LANGUAGE"; |
| |
| /** Extra for alert tone type */ |
| public static final String ALERT_AUDIO_TONE_TYPE = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_TONE_TYPE"; |
| |
| /** Extra for alert vibration pattern (unless main volume is silent). */ |
| public static final String ALERT_AUDIO_VIBRATION_PATTERN_EXTRA = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_VIBRATION_PATTERN"; |
| |
| /** Extra for playing alert sound in full volume regardless Do Not Disturb is on. */ |
| public static final String ALERT_AUDIO_OVERRIDE_DND_EXTRA = |
| "com.android.cellbroadcastreceiver.ALERT_OVERRIDE_DND_EXTRA"; |
| |
| /** Extra for cutomized alert duration in ms. */ |
| public static final String ALERT_AUDIO_DURATION = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_DURATION"; |
| |
| /** Extra for alert subscription index */ |
| public static final String ALERT_AUDIO_SUB_INDEX = |
| "com.android.cellbroadcastreceiver.ALERT_AUDIO_SUB_INDEX"; |
| |
| private static final String TTS_UTTERANCE_ID = "com.android.cellbroadcastreceiver.UTTERANCE_ID"; |
| |
| /** Pause duration between alert sound and alert speech. */ |
| private static final long PAUSE_DURATION_BEFORE_SPEAKING_MSEC = 1000L; |
| |
| private static final int STATE_IDLE = 0; |
| private static final int STATE_ALERTING = 1; |
| private static final int STATE_PAUSING = 2; |
| private static final int STATE_SPEAKING = 3; |
| private static final int STATE_STOPPING = 4; |
| |
| /** Default LED flashing frequency is 250 milliseconds */ |
| private static final long DEFAULT_LED_FLASH_INTERVAL_MSEC = 250L; |
| |
| /** Default delay for resent alert audio intent */ |
| private static final long DEFAULT_RESENT_DELAY_MSEC = 200L; |
| |
| private int mState; |
| |
| private TextToSpeech mTts; |
| private boolean mTtsEngineReady; |
| |
| private AlertType mAlertType; |
| private String mMessageBody; |
| private String mMessageLanguage; |
| private int mSubId; |
| private boolean mTtsLanguageSupported; |
| private boolean mEnableVibrate; |
| private boolean mEnableAudio; |
| private boolean mEnableLedFlash; |
| private boolean mIsMediaPlayerStarted; |
| private boolean mIsTextToSpeechSpeaking; |
| private boolean mOverrideDnd; |
| private boolean mResetAlarmVolumeNeeded; |
| private int mUserSetAlarmVolume; |
| private int[] mVibrationPattern; |
| private int mAlertDuration = -1; |
| |
| private Vibrator mVibrator; |
| private MediaPlayer mMediaPlayer; |
| @VisibleForTesting |
| public MediaPlayer mMediaPlayerInjected; |
| private AudioManager mAudioManager; |
| private TelephonyManager mTelephonyManager; |
| private int mInitialCallState; |
| private int mStartId; |
| private ScreenOffReceiver mScreenOffReceiver; |
| |
| // Internal messages |
| private static final int ALERT_SOUND_FINISHED = 1000; |
| private static final int ALERT_PAUSE_FINISHED = 1001; |
| private static final int ALERT_LED_FLASH_TOGGLE = 1002; |
| |
| @VisibleForTesting |
| public Handler mHandler; |
| |
| private PhoneStateListener mPhoneStateListener; |
| |
| /** |
| * Callback from TTS engine after initialization. |
| * |
| * @param status {@link TextToSpeech#SUCCESS} or {@link TextToSpeech#ERROR}. |
| */ |
| @Override |
| public void onInit(int status) { |
| if (DBG) log("onInit() TTS engine status: " + status); |
| if (status == TextToSpeech.SUCCESS) { |
| mTtsEngineReady = true; |
| mTts.setOnUtteranceCompletedListener(this); |
| // try to set the TTS language to match the broadcast |
| setTtsLanguage(); |
| } else { |
| mTtsEngineReady = false; |
| mTts = null; |
| loge("onInit() TTS engine error: " + status); |
| } |
| } |
| |
| /** |
| * Try to set the TTS engine language to the preferred language. If failed, set |
| * it to the default language. mTtsLanguageSupported will be updated based on the response. |
| */ |
| private void setTtsLanguage() { |
| Locale locale = null; |
| if (!TextUtils.isEmpty(mMessageLanguage)) { |
| locale = new Locale(mMessageLanguage); |
| } |
| if (locale == null || locale.getLanguage().equalsIgnoreCase( |
| Locale.getDefault().getLanguage())) { |
| // If the cell broadcast message does not specify the language, use device's default |
| // language. |
| locale = Locale.getDefault(); |
| } |
| |
| if (DBG) log("Setting TTS language to '" + locale + '\''); |
| int result = mTts.setLanguage(locale); |
| if (DBG) log("TTS setLanguage() returned: " + result); |
| mTtsLanguageSupported = (result >= TextToSpeech.LANG_AVAILABLE); |
| } |
| |
| /** |
| * Callback from TTS engine. |
| * |
| * @param utteranceId the identifier of the utterance. |
| */ |
| @Override |
| public void onUtteranceCompleted(String utteranceId) { |
| if (utteranceId.equals(TTS_UTTERANCE_ID)) { |
| // When we reach here, it could be TTS completed or TTS was cut due to another |
| // new alert started playing. We don't want to stop the service in the later case. |
| if (getState() == STATE_SPEAKING) { |
| if (DBG) log("TTS completed. Stop CellBroadcastAlertAudio service"); |
| stopAlertAudioService(); |
| } |
| } |
| } |
| |
| @Override |
| public void onCreate() { |
| mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE); |
| mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); |
| // Listen for incoming calls to kill the alarm. |
| mTelephonyManager = ((TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE)); |
| mHandler = new Handler(Looper.getMainLooper()) { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case ALERT_SOUND_FINISHED: |
| if (DBG) log("ALERT_SOUND_FINISHED"); |
| stop(); // stop alert sound |
| // if we can speak the message text |
| if (mMessageBody != null && mTtsEngineReady && mTtsLanguageSupported) { |
| sendMessageDelayed(mHandler.obtainMessage(ALERT_PAUSE_FINISHED), |
| PAUSE_DURATION_BEFORE_SPEAKING_MSEC); |
| setState(STATE_PAUSING); |
| } else { |
| if (DBG) { |
| log("MessageEmpty = " + (mMessageBody == null) |
| + ", mTtsEngineReady = " + mTtsEngineReady |
| + ", mTtsLanguageSupported = " + mTtsLanguageSupported); |
| } |
| stopAlertAudioService(); |
| } |
| // Set alert reminder depending on user preference |
| CellBroadcastAlertReminder.queueAlertReminder(getApplicationContext(), |
| mSubId, |
| true); |
| break; |
| |
| case ALERT_PAUSE_FINISHED: |
| if (DBG) log("ALERT_PAUSE_FINISHED"); |
| int res = TextToSpeech.ERROR; |
| if (mMessageBody != null && mTtsEngineReady && mTtsLanguageSupported) { |
| if (DBG) log("Speaking broadcast text: " + mMessageBody); |
| |
| mTts.setAudioAttributes(getAlertAudioAttributes()); |
| // Flush the text to speech queue |
| mTts.speak("", TextToSpeech.QUEUE_FLUSH, null, null); |
| res = mTts.speak(mMessageBody, 2, null, TTS_UTTERANCE_ID); |
| mIsTextToSpeechSpeaking = true; |
| setState(STATE_SPEAKING); |
| } |
| if (res != TextToSpeech.SUCCESS) { |
| loge("TTS engine not ready or language not supported or speak() " |
| + "failed"); |
| stopAlertAudioService(); |
| } |
| break; |
| |
| case ALERT_LED_FLASH_TOGGLE: |
| if (enableLedFlash(msg.arg1 != 0)) { |
| sendMessageDelayed(mHandler.obtainMessage( |
| ALERT_LED_FLASH_TOGGLE, msg.arg1 != 0 ? 0 : 1, 0), |
| DEFAULT_LED_FLASH_INTERVAL_MSEC); |
| } |
| break; |
| |
| default: |
| loge("Handler received unknown message, what=" + msg.what); |
| } |
| } |
| }; |
| mPhoneStateListener = new PhoneStateListener() { |
| @Override |
| public void onCallStateChanged(int state, String ignored) { |
| // Stop the alert sound and speech if the call state changes. |
| if (state != TelephonyManager.CALL_STATE_IDLE |
| && state != mInitialCallState) { |
| if (DBG) log("Call interrupted. Stop CellBroadcastAlertAudio service"); |
| stopAlertAudioService(); |
| } |
| } |
| }; |
| mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); |
| } |
| |
| @Override |
| public void onDestroy() { |
| setState(STATE_STOPPING); |
| // stop audio, vibration and TTS |
| if (DBG) log("onDestroy"); |
| stop(); |
| // Stop listening for incoming calls. |
| mTelephonyManager.listen(mPhoneStateListener, LISTEN_NONE); |
| // shutdown TTS engine |
| if (mTts != null) { |
| try { |
| mTts.shutdown(); |
| } catch (IllegalStateException e) { |
| // catch "Unable to retrieve AudioTrack pointer for stop()" exception |
| loge("exception trying to shutdown text-to-speech"); |
| } |
| } |
| if (mEnableAudio) { |
| // Release the audio focus so other audio (e.g. music) can resume. |
| // Do not do this in stop() because stop() is also called when we stop the tone (before |
| // TTS is playing). We only want to release the focus when tone and TTS are played. |
| mAudioManager.abandonAudioFocus(this); |
| } |
| } |
| |
| @Override |
| public IBinder onBind(Intent intent) { |
| return null; |
| } |
| |
| @Override |
| public int onStartCommand(Intent intent, int flags, int startId) { |
| if (DBG) log("onStartCommand"); |
| // No intent, tell the system not to restart us. |
| if (intent == null) { |
| if (DBG) log("Null intent. Stop CellBroadcastAlertAudio service"); |
| stopAlertAudioService(); |
| return START_NOT_STICKY; |
| } |
| |
| // Check if service stop is in progress |
| if (getState() == STATE_STOPPING) { |
| if (DBG) log("stop is in progress"); |
| PendingIntent pi; |
| pi = PendingIntent.getService(this, 1 /*REQUEST_CODE_CONTENT_INTENT*/, intent, |
| PendingIntent.FLAG_ONE_SHOT |
| | PendingIntent.FLAG_UPDATE_CURRENT |
| | PendingIntent.FLAG_IMMUTABLE); |
| AlarmManager alarmManager = getSystemService(AlarmManager.class); |
| if (alarmManager == null) { |
| loge("can't get Alarm Service"); |
| return START_NOT_STICKY; |
| } |
| if (DBG) log("resent intent"); |
| // resent again |
| long triggerTime = SystemClock.elapsedRealtime() + DEFAULT_RESENT_DELAY_MSEC; |
| alarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP, |
| triggerTime, pi); |
| return START_STICKY; |
| } |
| |
| mStartId = startId; |
| return handleStartIntent(intent); |
| } |
| |
| /** |
| * Handle the start intent |
| * |
| * @param intent the intent to start the service |
| */ |
| @VisibleForTesting |
| public int handleStartIntent(Intent intent) { |
| // Get text to speak (if enabled by user) |
| mMessageBody = intent.getStringExtra(ALERT_AUDIO_MESSAGE_BODY); |
| mMessageLanguage = intent.getStringExtra(ALERT_AUDIO_MESSAGE_LANGUAGE); |
| mSubId = intent.getIntExtra(ALERT_AUDIO_SUB_INDEX, |
| SubscriptionManager.INVALID_SUBSCRIPTION_ID); |
| |
| SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this); |
| |
| // retrieve whether to play alert sound in full volume regardless Do Not Disturb is on. |
| mOverrideDnd = intent.getBooleanExtra(ALERT_AUDIO_OVERRIDE_DND_EXTRA, false); |
| // retrieve the vibrate settings from cellbroadcast receiver settings. |
| mEnableVibrate = prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_VIBRATE, true) |
| || mOverrideDnd; |
| // retrieve the vibration patterns. |
| mVibrationPattern = intent.getIntArrayExtra(ALERT_AUDIO_VIBRATION_PATTERN_EXTRA); |
| |
| Resources res = CellBroadcastSettings.getResourcesByOperator(getApplicationContext(), |
| mSubId, CellBroadcastReceiver.getRoamingOperatorSupported(getApplicationContext())); |
| mEnableLedFlash = res.getBoolean(R.bool.enable_led_flash); |
| |
| // retrieve the customized alert duration. -1 means play the alert with the tone's duration. |
| mAlertDuration = intent.getIntExtra(ALERT_AUDIO_DURATION, -1); |
| // retrieve the alert type |
| mAlertType = AlertType.DEFAULT; |
| if (intent.getSerializableExtra(ALERT_AUDIO_TONE_TYPE) != null) { |
| mAlertType = (AlertType) intent.getSerializableExtra(ALERT_AUDIO_TONE_TYPE); |
| } |
| |
| switch (mAudioManager.getRingerMode()) { |
| case AudioManager.RINGER_MODE_SILENT: |
| if (DBG) log("Ringer mode: silent"); |
| if (!mOverrideDnd) { |
| mEnableVibrate = false; |
| } |
| // If the phone is in silent mode, we only enable the audio when override dnd |
| // setting is turned on. |
| mEnableAudio = mOverrideDnd; |
| break; |
| case AudioManager.RINGER_MODE_VIBRATE: |
| if (DBG) log("Ringer mode: vibrate"); |
| // If the phone is in vibration mode, we only enable the audio when override dnd |
| // setting is turned on. |
| mEnableAudio = mOverrideDnd; |
| break; |
| case AudioManager.RINGER_MODE_NORMAL: |
| default: |
| if (DBG) log("Ringer mode: normal"); |
| mEnableAudio = true; |
| break; |
| } |
| |
| if (mMessageBody != null && mEnableAudio) { |
| if (mTts == null) { |
| mTts = new TextToSpeech(this, this); |
| } else if (mTtsEngineReady) { |
| setTtsLanguage(); |
| } |
| } |
| |
| if ((mEnableAudio || mEnableVibrate) && (mAlertType != AlertType.MUTE)) { |
| playAlertTone(mAlertType, mVibrationPattern); |
| } else { |
| if (DBG) log("No audio/vibrate playing. Stop CellBroadcastAlertAudio service"); |
| stopAlertAudioService(); |
| return START_NOT_STICKY; |
| } |
| |
| // Record the initial call state here so that the new alarm has the |
| // newest state. |
| mInitialCallState = mTelephonyManager.getCallState(); |
| |
| return START_STICKY; |
| } |
| |
| // Volume suggested by media team for in-call alarms. |
| private static final float IN_CALL_VOLUME_LEFT = 0.125f; |
| private static final float IN_CALL_VOLUME_RIGHT = 0.125f; |
| |
| /** |
| * Start playing the alert sound. |
| * |
| * @param alertType the alert type (e.g. default, earthquake, tsunami, etc..) |
| * @param patternArray the alert vibration pattern |
| */ |
| private void playAlertTone(AlertType alertType, int[] patternArray) { |
| // stop() checks to see if we are already playing. |
| stop(); |
| |
| log("playAlertTone: alertType=" + alertType + ", mEnableVibrate=" + mEnableVibrate |
| + ", mEnableAudio=" + mEnableAudio + ", mOverrideDnd=" + mOverrideDnd |
| + ", mSubId=" + mSubId); |
| Resources res = CellBroadcastSettings.getResourcesByOperator(getApplicationContext(), |
| mSubId, CellBroadcastReceiver.getRoamingOperatorSupported(getApplicationContext())); |
| |
| // Vibration duration in milliseconds |
| long vibrateDuration = 0; |
| |
| // Get the alert tone duration. Negative tone duration value means we only play the tone |
| // once, not repeat it. |
| int customAlertDuration = mAlertDuration; |
| |
| // Start the vibration first. |
| if (mEnableVibrate) { |
| long[] vibrationPattern = new long[patternArray.length]; |
| |
| for (int i = 0; i < patternArray.length; i++) { |
| vibrationPattern[i] = patternArray[i]; |
| vibrateDuration += patternArray[i]; |
| } |
| |
| AudioAttributes.Builder attrBuilder = new AudioAttributes.Builder(); |
| attrBuilder.setUsage(AudioAttributes.USAGE_ALARM); |
| if (mOverrideDnd) { |
| // Set the flags to bypass DnD mode if override dnd is turned on. |
| attrBuilder.setFlags(AudioAttributes.FLAG_BYPASS_INTERRUPTION_POLICY |
| | AudioAttributes.FLAG_BYPASS_MUTE); |
| } |
| AudioAttributes attr = attrBuilder.build(); |
| // If we only play the tone once, then we also play the vibration pattern once. |
| int repeatIndex = (customAlertDuration < 0) |
| ? -1 /* not repeat */ : 0 /* index to repeat */; |
| VibrationEffect effect = VibrationEffect.createWaveform(vibrationPattern, repeatIndex); |
| log("vibrate: effect=" + effect + ", attr=" + attr + ", duration=" |
| + customAlertDuration); |
| mVibrator.vibrate(effect, attr); |
| // Android default behavior will stop vibration when screen turns off. |
| // if mute by physical button is not allowed, press power key should not turn off |
| // vibration. |
| if (!res.getBoolean(R.bool.mute_by_physical_button)) { |
| mScreenOffReceiver = new ScreenOffReceiver(effect, attr); |
| registerReceiver(mScreenOffReceiver, new IntentFilter(Intent.ACTION_SCREEN_OFF)); |
| } |
| } |
| |
| if (mEnableLedFlash) { |
| log("Start LED flashing"); |
| mHandler.sendMessage(mHandler.obtainMessage(ALERT_LED_FLASH_TOGGLE, 1, 0)); |
| } |
| |
| if (mEnableAudio) { |
| // future optimization: reuse media player object |
| mMediaPlayer = mMediaPlayerInjected != null ? mMediaPlayerInjected : new MediaPlayer(); |
| mMediaPlayer.setOnErrorListener(new OnErrorListener() { |
| public boolean onError(MediaPlayer mp, int what, int extra) { |
| loge("Error occurred while playing audio."); |
| mHandler.sendMessage(mHandler.obtainMessage(ALERT_SOUND_FINISHED)); |
| return true; |
| } |
| }); |
| |
| // If the duration is not specified by the config, just play the alert tone |
| // with the tone's duration. |
| if (customAlertDuration < 0) { |
| mMediaPlayer.setOnCompletionListener(new OnCompletionListener() { |
| public void onCompletion(MediaPlayer mp) { |
| if (DBG) log("Audio playback complete."); |
| mHandler.sendMessage(mHandler.obtainMessage(ALERT_SOUND_FINISHED)); |
| return; |
| } |
| }); |
| } |
| |
| try { |
| log("Locale=" + res.getConfiguration().getLocales() + ", alertType=" + alertType); |
| |
| // Load the tones based on type |
| switch (alertType) { |
| case ETWS_EARTHQUAKE: |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.etws_earthquake); |
| break; |
| case ETWS_TSUNAMI: |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.etws_tsunami); |
| break; |
| case OTHER: |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.etws_other_disaster); |
| break; |
| case ETWS_DEFAULT: |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.etws_default); |
| break; |
| case INFO: |
| case AREA: |
| if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) { |
| //TODO(b/279183006): remove watch workaround when URI supported. |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.watch_info); |
| } else { |
| mMediaPlayer.setDataSource(this, |
| Settings.System.DEFAULT_NOTIFICATION_URI); |
| } |
| break; |
| case TEST: |
| case DEFAULT: |
| default: |
| setDataSourceFromResource(res, mMediaPlayer, R.raw.default_tone); |
| } |
| |
| // Request audio focus (though we're going to play even if we don't get it). The |
| // only scenario we are not getting focus immediately is a voice call is holding |
| // focus, since we are passing AUDIOFOCUS_FLAG_DELAY_OK, the focus will be granted |
| // once voice call ends. |
| mAudioManager.requestAudioFocus(this, |
| new AudioAttributes.Builder().setLegacyStreamType( |
| (alertType == AlertType.INFO || alertType == AlertType.AREA) ? |
| AudioManager.STREAM_NOTIFICATION |
| : AudioManager.STREAM_ALARM).build(), |
| AudioManager.AUDIOFOCUS_GAIN_TRANSIENT, |
| AudioManager.AUDIOFOCUS_FLAG_DELAY_OK); |
| mMediaPlayer.setAudioAttributes(getAlertAudioAttributes()); |
| setAlertVolume(); |
| |
| // If we are using the custom alert duration, set looping to true so we can repeat |
| // the alert. The tone playing will stop when ALERT_SOUND_FINISHED arrives. |
| // Otherwise we just play the alert tone once. |
| mMediaPlayer.setLooping(customAlertDuration >= 0); |
| mMediaPlayer.prepare(); |
| // If the duration is specified by the config, stop playing the alert after |
| // the specified duration. |
| if (customAlertDuration >= 0) { |
| mHandler.sendMessageDelayed(mHandler.obtainMessage(ALERT_SOUND_FINISHED), |
| customAlertDuration); |
| } |
| mMediaPlayer.start(); |
| mIsMediaPlayerStarted = true; |
| |
| } catch (Exception ex) { |
| loge("Failed to play alert sound: " + ex); |
| CellBroadcastReceiverMetrics.getInstance().logModuleError( |
| ERRSRC_CBR, ERRTYPE_PLAYSOUND); |
| // Immediately move into the next state ALERT_SOUND_FINISHED. |
| mHandler.sendMessage(mHandler.obtainMessage(ALERT_SOUND_FINISHED)); |
| } |
| } else { |
| // In normal mode (playing tone + vibration), this service will stop after audio |
| // playback is done. However, if the device is in vibrate only mode, we need to stop |
| // the service right after vibration because there won't be any audio complete callback |
| // to stop the service. Unfortunately it's not like MediaPlayer has onCompletion() |
| // callback that we can use, we'll have to use our own timer to stop the service. |
| mHandler.sendMessageDelayed(mHandler.obtainMessage(ALERT_SOUND_FINISHED), |
| customAlertDuration >= 0 ? customAlertDuration : vibrateDuration); |
| } |
| setState(STATE_ALERTING); |
| } |
| |
| private static void setDataSourceFromResource(Resources resources, |
| MediaPlayer player, int res) throws java.io.IOException { |
| AssetFileDescriptor afd = resources.openRawResourceFd(res); |
| if (afd != null) { |
| player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), |
| afd.getLength()); |
| afd.close(); |
| } |
| } |
| |
| /** |
| * Turn on camera's LED |
| * |
| * @param on {@code true} if turned on, otherwise turned off. |
| * @return {@code true} if successful, otherwise false. |
| */ |
| private boolean enableLedFlash(boolean on) { |
| log("enbleLedFlash=" + on); |
| CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE); |
| if (cameraManager == null) return false; |
| final String[] ids; |
| try { |
| ids = cameraManager.getCameraIdList(); |
| } catch (CameraAccessException e) { |
| CellBroadcastReceiverMetrics.getInstance() |
| .logModuleError(ERRSRC_CBR, ERRTYPE_PLAYFLASH); |
| log("Can't get camera id"); |
| return false; |
| } |
| |
| boolean success = false; |
| for (String id : ids) { |
| try { |
| CameraCharacteristics c = cameraManager.getCameraCharacteristics(id); |
| Boolean flashAvailable = c.get(CameraCharacteristics.FLASH_INFO_AVAILABLE); |
| if (flashAvailable != null && flashAvailable) { |
| cameraManager.setTorchMode(id, on); |
| success = true; |
| } |
| } catch (CameraAccessException e) { |
| CellBroadcastReceiverMetrics.getInstance().logModuleError( |
| ERRSRC_CBR, ERRTYPE_PLAYFLASH); |
| log("Can't flash. e=" + e); |
| // continue with the next available camera |
| } |
| } |
| return success; |
| } |
| |
| /** |
| * Stops alert audio and speech. |
| */ |
| public void stop() { |
| if (DBG) log("stop()"); |
| |
| mHandler.removeMessages(ALERT_SOUND_FINISHED); |
| mHandler.removeMessages(ALERT_PAUSE_FINISHED); |
| mHandler.removeMessages(ALERT_LED_FLASH_TOGGLE); |
| |
| resetAlarmStreamVolume(); |
| |
| // Stop audio playing |
| if (mMediaPlayer != null && mIsMediaPlayerStarted) { |
| try { |
| mMediaPlayer.stop(); |
| mMediaPlayer.release(); |
| } catch (IllegalStateException e) { |
| // catch "Unable to retrieve AudioTrack pointer for stop()" exception |
| loge("exception trying to stop media player"); |
| } |
| mIsMediaPlayerStarted = false; |
| mMediaPlayer = null; |
| } |
| |
| // Stop vibrator |
| mVibrator.cancel(); |
| if (mScreenOffReceiver != null) { |
| try { |
| unregisterReceiver(mScreenOffReceiver); |
| } catch (Exception e) { |
| // already unregistered |
| } |
| mScreenOffReceiver = null; |
| } |
| |
| if (mEnableLedFlash) { |
| enableLedFlash(false); |
| } |
| |
| if (mTts != null && mIsTextToSpeechSpeaking) { |
| try { |
| mTts.stop(); |
| } catch (IllegalStateException e) { |
| // catch "Unable to retrieve AudioTrack pointer for stop()" exception |
| loge("exception trying to stop text-to-speech"); |
| CellBroadcastReceiverMetrics.getInstance() |
| .logModuleError(ERRSRC_CBR, ERRTYPE_PLAYTTS); |
| } |
| mIsTextToSpeechSpeaking = false; |
| } |
| |
| // Service will be destroyed if the state is STATE_STOPPING, |
| // so it should not be changed to another state. |
| if (getState() != STATE_STOPPING) { |
| setState(STATE_IDLE); |
| } |
| } |
| |
| @Override |
| public void onAudioFocusChange(int focusChange) { |
| log("onAudioFocusChanged: " + focusChange); |
| // Do nothing, as we don't care if focus was steal from other apps, as emergency alerts will |
| // play anyway. |
| } |
| |
| /** |
| * Get audio attribute for the alarm. |
| */ |
| private AudioAttributes getAlertAudioAttributes() { |
| AudioAttributes.Builder builder = new AudioAttributes.Builder(); |
| |
| builder.setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION); |
| builder.setUsage((mAlertType == AlertType.INFO || mAlertType == AlertType.AREA) ? |
| AudioAttributes.USAGE_NOTIFICATION : AudioAttributes.USAGE_ALARM); |
| if (mOverrideDnd) { |
| // Set FLAG_BYPASS_INTERRUPTION_POLICY and FLAG_BYPASS_MUTE so that it enables |
| // audio in any DnD mode, even in total silence DnD mode (requires MODIFY_PHONE_STATE). |
| |
| // Note: this only works when the audio attributes usage is set to USAGE_ALARM. If |
| // regulatory concerns mean that we need to bypass DnD for AlertType.INFO or |
| // AlertType.AREA as well, we'll need to add a config flag to have INFO go over the |
| // alarm stream as well for those jurisdictions in which those regulatory concerns apply |
| builder.setFlags(AudioAttributes.FLAG_BYPASS_INTERRUPTION_POLICY |
| | AudioAttributes.FLAG_BYPASS_MUTE); |
| } |
| |
| return builder.build(); |
| } |
| |
| /** |
| * Set volume for alerts. |
| */ |
| private void setAlertVolume() { |
| if (mTelephonyManager.getCallState() != TelephonyManager.CALL_STATE_IDLE |
| || isOnEarphone()) { |
| // If we are in a call, play the alert |
| // sound at a low volume to not disrupt the call. |
| log("in call: reducing volume"); |
| mMediaPlayer.setVolume(IN_CALL_VOLUME_LEFT, IN_CALL_VOLUME_RIGHT); |
| } else if (mOverrideDnd) { |
| // If override DnD is turned on, |
| // we overwrite volume setting of STREAM_ALARM to full, play at |
| // max possible volume, and reset it after it's finished. |
| setAlarmStreamVolumeToFull(); |
| } |
| } |
| |
| private boolean isOnEarphone() { |
| AudioDeviceInfo[] deviceList = mAudioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS); |
| |
| for (AudioDeviceInfo devInfo : deviceList) { |
| int type = devInfo.getType(); |
| if (type == AudioDeviceInfo.TYPE_WIRED_HEADSET |
| || type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES |
| || type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO |
| || type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Set volume of STREAM_ALARM to full. |
| */ |
| private void setAlarmStreamVolumeToFull() { |
| if (mAlertType != AlertType.INFO && mAlertType != AlertType.AREA) { |
| log("setting alarm volume to full for cell broadcast alerts."); |
| int streamType = AudioManager.STREAM_ALARM; |
| mUserSetAlarmVolume = mAudioManager.getStreamVolume(streamType); |
| mResetAlarmVolumeNeeded = true; |
| mAudioManager.setStreamVolume(streamType, |
| mAudioManager.getStreamMaxVolume(streamType), 0); |
| } else { |
| log("Skipping setting alarm volume to full for alert type INFO and AREA"); |
| } |
| } |
| |
| /** |
| * Reset volume of STREAM_ALARM, if needed. |
| */ |
| private void resetAlarmStreamVolume() { |
| if (mResetAlarmVolumeNeeded) { |
| log("resetting alarm volume to back to " + mUserSetAlarmVolume); |
| mAudioManager.setStreamVolume(AudioManager.STREAM_ALARM, mUserSetAlarmVolume, 0); |
| mResetAlarmVolumeNeeded = false; |
| } |
| } |
| |
| /** |
| * Stop CellBroadcastAlertAudio Service and set state to STATE_STOPPING |
| */ |
| private boolean stopAlertAudioService() { |
| if (DBG) log("stopAlertAudioService, current state is " + getState()); |
| boolean result = false; |
| if (getState() != STATE_STOPPING) { |
| setState(STATE_STOPPING); |
| result = stopSelfResult(mStartId); |
| if (DBG) log((result ? "Successful" : "Failed") |
| + " to stop AlertAudioService[" + mStartId + "]"); |
| } |
| return result; |
| } |
| |
| /** |
| * Set AlertAudioService state |
| * |
| * @param state service status |
| */ |
| private synchronized void setState(int state) { |
| if (DBG) log("Set state from " + mState + " to " + state); |
| mState = state; |
| } |
| |
| /** |
| * Get AlertAudioService status |
| * @return service status |
| */ |
| @VisibleForTesting |
| public synchronized int getState() { |
| return mState; |
| } |
| |
| /* |
| * BroadcastReceiver for screen off events. Used for Latam. |
| * CMAS requirements to make sure vibration continues when screen goes off |
| */ |
| private class ScreenOffReceiver extends BroadcastReceiver { |
| VibrationEffect mVibrationEffect; |
| AudioAttributes mAudioAttr; |
| |
| ScreenOffReceiver(VibrationEffect effect, AudioAttributes attributes) { |
| this.mVibrationEffect = effect; |
| this.mAudioAttr = attributes; |
| } |
| |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| // Restart the vibration after screen off |
| if (mState == STATE_ALERTING) { |
| mVibrator.vibrate(mVibrationEffect, mAudioAttr); |
| } |
| } |
| } |
| |
| private static void log(String msg) { |
| Log.d(TAG, msg); |
| } |
| |
| private static void loge(String msg) { |
| Log.e(TAG, msg); |
| } |
| } |
