public static AlertPlayer getPlayer() {
if (singletone == null) {
Log.i(TAG, "getPlayer: Creating a new AlertPlayer");
singletone = new AlertPlayer();
} else {
Log.i(TAG, "getPlayer: Using existing AlertPlayer");
}
return singletone;
}
private void Vibrate(
Context ctx,
AlertType alert,
String bgValue,
Boolean overrideSilent,
int timeFromStartPlaying) {
Log.d(TAG, "Vibrate called timeFromStartPlaying = " + timeFromStartPlaying);
Log.d("ALARM", "setting vibrate alarm");
int profile = getAlertProfile(ctx);
// We use timeFromStartPlaying as a way to force vibrating/ non vibrating...
if (profile != ALERT_PROFILE_ASCENDING) {
// We start from the non ascending part...
timeFromStartPlaying = MAX_ASCENDING;
}
String title = bgValue + " " + alert.name;
String content = "BG LEVEL ALERT: " + bgValue;
Intent intent = new Intent(ctx, SnoozeActivity.class);
NotificationCompat.Builder builder =
new NotificationCompat.Builder(ctx)
.setSmallIcon(R.drawable.ic_action_communication_invert_colors_on)
.setContentTitle(title)
.setContentText(content)
.setContentIntent(notificationIntent(ctx, intent))
.setDeleteIntent(snoozeIntent(ctx));
if (profile != ALERT_PROFILE_VIBRATE_ONLY && profile != ALERT_PROFILE_SILENT) {
if (timeFromStartPlaying >= MAX_VIBRATING) {
// Before this, we only vibrate...
float volumeFrac =
(float) (timeFromStartPlaying - MAX_VIBRATING) / (MAX_ASCENDING - MAX_VIBRATING);
volumeFrac = Math.min(volumeFrac, 1);
if (profile == ALERT_PROFILE_MEDIUM) {
volumeFrac = (float) 0.7;
}
Log.d(TAG, "Vibrate volumeFrac = " + volumeFrac);
boolean isRingTone = EditAlertActivity.isPathRingtone(ctx, alert.mp3_file);
if (isRingTone && !overrideSilent) {
builder.setSound(Uri.parse(alert.mp3_file));
} else {
if (overrideSilent || isLoudPhone(ctx)) {
PlayFile(ctx, alert.mp3_file, volumeFrac);
}
}
}
}
if (profile != ALERT_PROFILE_SILENT && alert.vibrate) {
builder.setVibrate(Notifications.vibratePattern);
}
NotificationManager mNotifyMgr =
(NotificationManager) ctx.getSystemService(Context.NOTIFICATION_SERVICE);
mNotifyMgr.cancel(Notifications.exportAlertNotificationId);
mNotifyMgr.notify(Notifications.exportAlertNotificationId, builder.build());
}
public synchronized void PreSnooze(Context ctx, String uuid, int repeatTime) {
Log.i(TAG, "PreSnooze called repeatTime = " + repeatTime);
stopAlert(ctx, true, false);
ActiveBgAlert.Create(uuid, true, new Date().getTime() + repeatTime * 60000);
ActiveBgAlert activeBgAlert = ActiveBgAlert.getOnly();
if (activeBgAlert == null) {
Log.wtf(TAG, "Just created the alert, where did it go...");
return;
}
activeBgAlert.snooze(repeatTime);
}
public synchronized void Snooze(Context ctx, int repeatTime) {
Log.i(TAG, "Snooze called repeatTime = " + repeatTime);
stopAlert(ctx, false, false);
ActiveBgAlert activeBgAlert = ActiveBgAlert.getOnly();
if (activeBgAlert == null) {
Log.w(
TAG,
"Error, snooze was called but no alert is active. alert was probably removed in ui ");
return;
}
activeBgAlert.snooze(repeatTime);
}
public synchronized void startAlert(
Context ctx, boolean trendingToAlertEnd, AlertType newAlert, String bgValue) {
Log.d(TAG, "startAlert called, Threadid " + Thread.currentThread().getId());
if (trendingToAlertEnd) {
Log.d(TAG, "startAlert: This alert is trending to it's end will not do anything");
return;
}
stopAlert(ctx, true, false);
int alertIn = newAlert.minutes_between;
if (alertIn < 1) {
alertIn = 1;
}
ActiveBgAlert.Create(newAlert.uuid, false, new Date().getTime() + alertIn * 60000);
Vibrate(ctx, newAlert, bgValue, newAlert.override_silent_mode, 0);
}
private void PlayFile(Context ctx, String FileName, float VolumeFrac) {
Log.i(TAG, "PlayFile: called FileName = " + FileName);
if (mediaPlayer != null) {
Log.i(TAG, "ERROR, PlayFile:going to leak a mediaplayer !!!");
}
if (FileName != null && FileName.length() > 0) {
mediaPlayer = MediaPlayer.create(ctx, Uri.parse(FileName), null);
}
if (mediaPlayer == null) {
Log.i(
TAG,
"PlayFile: Creating mediaplayer with file " + FileName + " failed. using default alarm");
mediaPlayer = MediaPlayer.create(ctx, R.raw.default_alert);
}
if (mediaPlayer != null) {
AudioManager manager = (AudioManager) ctx.getSystemService(Context.AUDIO_SERVICE);
int maxVolume = manager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
volumeBeforeAlert = manager.getStreamVolume(AudioManager.STREAM_MUSIC);
volumeForThisAlert = (int) (maxVolume * VolumeFrac);
manager.setStreamVolume(AudioManager.STREAM_MUSIC, volumeForThisAlert, 0);
context = ctx;
mediaPlayer.setOnCompletionListener(
new MediaPlayer.OnCompletionListener() {
@Override
public void onCompletion(MediaPlayer mp) {
Log.i(TAG, "PlayFile: onCompletion called (finished playing) ");
AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
int currentVolume = manager.getStreamVolume(AudioManager.STREAM_MUSIC);
if (volumeForThisAlert == currentVolume) {
// If the user has changed the volume, don't change it again.
manager.setStreamVolume(AudioManager.STREAM_MUSIC, volumeBeforeAlert, 0);
}
}
});
Log.i(TAG, "PlayFile: calling mediaPlayer.start() ");
mediaPlayer.start();
} else {
// TODO, what should we do here???
Log.wtf(TAG, "PlayFile: Starting an alert failed, what should we do !!!");
}
}
private static int getAlertProfile(Context ctx) {
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(ctx);
String profile = prefs.getString("bg_alert_profile", "ascending");
if (profile.equals("High")) {
Log.i(TAG, "getAlertProfile returning ALERT_PROFILE_HIGH");
return ALERT_PROFILE_HIGH;
}
if (profile.equals("ascending")) {
Log.i(TAG, "getAlertProfile returning ALERT_PROFILE_ASCENDING");
return ALERT_PROFILE_ASCENDING;
}
if (profile.equals("medium")) {
Log.i(TAG, "getAlertProfile returning ALERT_PROFILE_MEDIUM");
return ALERT_PROFILE_MEDIUM;
}
if (profile.equals("vibrate only")) {
Log.i(TAG, "getAlertProfile returning ALERT_PROFILE_VIBRATE_ONLY");
return ALERT_PROFILE_VIBRATE_ONLY;
}
if (profile.equals("Silent")) {
Log.i(TAG, "getAlertProfile returning ALERT_PROFILE_SILENT");
return ALERT_PROFILE_SILENT;
}
Log.wtf(TAG, "getAlertProfile unknown value " + profile + " ALERT_PROFILE_ASCENDING");
return ALERT_PROFILE_ASCENDING;
}
// Check the state and alrarm if needed
public void ClockTick(Context ctx, boolean trendingToAlertEnd, String bgValue) {
if (trendingToAlertEnd) {
Log.d(TAG, "ClockTick: This alert is trending to it's end will not do anything");
return;
}
ActiveBgAlert activeBgAlert = ActiveBgAlert.getOnly();
if (activeBgAlert == null) {
// Nothing to do ...
return;
}
if (activeBgAlert.ready_to_alarm()) {
stopAlert(ctx, false, false);
int timeFromStartPlaying = activeBgAlert.getUpdatePlayTime();
AlertType alert = AlertType.get_alert(activeBgAlert.alert_uuid);
if (alert == null) {
Log.w(TAG, "ClockTick: The alert was already deleted... will not play");
ActiveBgAlert.ClearData();
return;
}
Log.d(TAG, "ClockTick: Playing the alert again");
Vibrate(ctx, alert, bgValue, alert.override_silent_mode, timeFromStartPlaying);
}
}
public synchronized void stopAlert(
Context ctx, boolean ClearData, boolean clearIfSnoozeFinished) {
Log.d(
TAG,
"stopAlert: stop called ClearData "
+ ClearData
+ " ThreadID "
+ Thread.currentThread().getId());
if (ClearData) {
ActiveBgAlert.ClearData();
}
if (clearIfSnoozeFinished) {
ActiveBgAlert.ClearIfSnoozeFinished();
}
notificationDismiss(ctx);
if (mediaPlayer != null) {
mediaPlayer.stop();
mediaPlayer.release();
mediaPlayer = null;
}
}
