765 lines
27 KiB
Java
Executable File
765 lines
27 KiB
Java
Executable File
package com.hyperling.apps.infinitetimer;
|
|
|
|
import android.app.NotificationManager;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.graphics.Color;
|
|
import android.media.AudioManager;
|
|
import android.media.MediaPlayer;
|
|
import android.media.Ringtone;
|
|
import android.media.RingtoneManager;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.provider.Settings;
|
|
import android.support.v7.app.AlertDialog;
|
|
import android.support.v7.app.AppCompatActivity;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.widget.Button;
|
|
import android.widget.EditText;
|
|
import android.widget.SeekBar;
|
|
import android.widget.TableRow;
|
|
import android.widget.TextView;
|
|
|
|
import java.net.URI;
|
|
import java.util.Map;
|
|
|
|
public class MainActivity extends AppCompatActivity {
|
|
|
|
String TAG = "MainActivity.",
|
|
keySharedPreferences, keyDebug, keyChronometerTime, keyLoopInterval,
|
|
keyStartStop, keyAppOpen, keyServiceRunning,
|
|
stringChronometerDefault, stringChronometerTime, stringLoopInterval;
|
|
|
|
// Try to make methods send and accept parameters to eliminate some of these, same with the string* Strings above
|
|
long longLoopInterval, longStartTime, longEndTime, longTimeLeft;
|
|
|
|
// Interrupt based checking would be nice
|
|
int waitInterval = 99;
|
|
|
|
boolean DEBUG, start, appOpen, serviceRunning;
|
|
|
|
SharedPreferences sharedPreferences;
|
|
|
|
TextView chronometer;
|
|
Button btnStartStop, btnChooseTime, btnResetPause;
|
|
EditText etHours, etMinutes, etSeconds, etMillis;
|
|
|
|
TableRow trTime;
|
|
TextView tvDot;
|
|
|
|
Uri ringtoneUri;
|
|
MediaPlayer mediaPlayer;
|
|
|
|
SeekBar seekBar;
|
|
AudioManager audioManager;
|
|
TextView tvSeekBar;
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
String tag = "onCreate";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
super.onCreate(savedInstanceState);
|
|
setContentView(R.layout.activity_main);
|
|
|
|
// Prevent the keyboard from popping up automatically
|
|
this.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
|
|
|
|
/***** Get Strings *****/
|
|
keySharedPreferences = getString(R.string.keySharedPreferences);
|
|
keyDebug = getString(R.string.keyDebug);
|
|
keyChronometerTime = getString(R.string.keyChronometerTime);
|
|
keyLoopInterval = getString(R.string.keyLoopInterval);
|
|
keyStartStop = getString(R.string.keyStartStop);
|
|
keyAppOpen = getString(R.string.keyAppOpen);
|
|
keyServiceRunning = getString(R.string.keyServiceRunning);
|
|
|
|
stringChronometerDefault = getString(R.string.chronometerDefault);
|
|
|
|
if (DEBUG) Log.d(tag, "Got strings.");
|
|
|
|
/***** Shared Preferences *****/
|
|
sharedPreferences = getSharedPreferences(keySharedPreferences, MODE_PRIVATE);
|
|
DEBUG = sharedPreferences.getBoolean(keyDebug, true);
|
|
appOpen = sharedPreferences.getBoolean(keyAppOpen, false);
|
|
serviceRunning = sharedPreferences.getBoolean(keyServiceRunning, false);
|
|
|
|
if (DEBUG) Log.d(tag, "Got preferences.");
|
|
|
|
// Sound
|
|
// Check exact alarm permission for Android 12+
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !Alert.isExactAlarmAllowed(this)) {
|
|
if (DEBUG) Log.w(tag, "Exact alarm permission not granted, requesting...");
|
|
new AlertDialog.Builder(MainActivity.this)
|
|
.setTitle("Alarm Permission Required")
|
|
.setMessage("To ensure the timer alerts you reliably, please grant 'Alarms & Reminders' permission in system settings.")
|
|
.setPositiveButton("Grant Permission", (d, w) -> {
|
|
Intent intent = new Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM);
|
|
startActivity(intent);
|
|
})
|
|
.setNegativeButton("Not Now", (d, w) -> d.dismiss())
|
|
.setCancelable(false)
|
|
.show();
|
|
}
|
|
|
|
if (DEBUG){
|
|
// Print all preferences
|
|
Map<String, ?> sharedPreferencesAll = sharedPreferences.getAll();
|
|
|
|
for (String key : sharedPreferencesAll.keySet()){
|
|
String value = sharedPreferencesAll.get(key).toString();
|
|
Log.d(tag, "key=" + key + " value=" + value);
|
|
|
|
// If app crashed, ensure buttons are correct.
|
|
if (key.equals(keyStartStop) && value.equals("true")) {
|
|
if (DEBUG) Log.d(tag, "Shutting off improper START value");
|
|
|
|
// Ensure START is always off if we are creating (not resuming).
|
|
int count = 0;
|
|
while (!sharedPreferences.edit().putBoolean(keyStartStop, false).commit() && count < 50) {
|
|
if (DEBUG) Log.d(tag, "Commit failed, trying again. count=" + count);
|
|
count++;
|
|
}
|
|
|
|
boolean checkStartStop = sharedPreferences.getBoolean(keyStartStop, false);;
|
|
Log.d(tag, "key=" + key + " value=" + checkStartStop);
|
|
}
|
|
}
|
|
}
|
|
|
|
/***** UI *****/
|
|
chronometer = (TextView) findViewById(R.id.chronometer);
|
|
chronometer.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
doTimeChooser();
|
|
}
|
|
});
|
|
|
|
btnChooseTime = (Button) findViewById(R.id.btnChooseTime);
|
|
btnChooseTime.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
doTimeChooser();
|
|
}
|
|
});
|
|
|
|
btnStartStop = (Button) findViewById(R.id.btnStartStop);
|
|
btnStartStop.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
Button b = (Button) v;
|
|
startStopChronometer(b.getText().toString());
|
|
}
|
|
});
|
|
|
|
btnResetPause = (Button) findViewById(R.id.btnResetPause);
|
|
btnResetPause.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
resetPauseChronometer();
|
|
}
|
|
});
|
|
|
|
etHours = (EditText) findViewById(R.id.etHours);
|
|
etMinutes = (EditText) findViewById(R.id.etMinutes);
|
|
etSeconds = (EditText) findViewById(R.id.etSeconds);
|
|
etMillis = (EditText) findViewById(R.id.etMillis);
|
|
|
|
trTime = (TableRow) findViewById(R.id.trTime);
|
|
trTime.setWeightSum(3);
|
|
|
|
tvDot = (TextView) findViewById(R.id.tvDot);
|
|
tvDot.setEnabled(false);
|
|
tvDot.setVisibility(View.GONE);
|
|
|
|
etMillis.setEnabled(false);
|
|
etMillis.setVisibility(View.GONE);
|
|
//(ViewManager) etMillis.getParent().remove
|
|
|
|
seekBar = findViewById(R.id.seekBar);
|
|
setVolumeControlStream(AudioManager.STREAM_MUSIC);
|
|
|
|
audioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
|
|
int maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
|
|
seekBar.setMax(maxVolume);
|
|
|
|
tvSeekBar = findViewById(R.id.tvSeekbar);
|
|
|
|
seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
|
|
@Override
|
|
public void onProgressChanged(SeekBar seekBar, int i, boolean b) {
|
|
audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, i, AudioManager.FLAG_SHOW_UI);
|
|
syncVolume();
|
|
}
|
|
|
|
@Override
|
|
public void onStartTrackingTouch(SeekBar seekBar) {
|
|
syncVolume();
|
|
}
|
|
|
|
@Override
|
|
public void onStopTrackingTouch(SeekBar seekBar) {
|
|
syncVolume();
|
|
}
|
|
});
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void doTimeChooser(){
|
|
String tag = TAG + "doTimeChooser";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
//stringLoopInterval = "00:00:07";
|
|
//setEditTexts(stringLoopInterval);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void setEditTexts(String interval){
|
|
String tag = TAG + "setEditTexts";
|
|
if (DEBUG) Log.d(tag, "Starting, interval=" + interval);
|
|
|
|
if (!interval.equals(stringChronometerDefault)) {
|
|
String[] time = interval.split(":");
|
|
|
|
for (int i = 0; i < time.length; i++){
|
|
while (time[i].length() < 2){
|
|
time[i] = "0" + time[i];
|
|
}
|
|
}
|
|
|
|
if (time.length == 3) {
|
|
etHours.setText(time[0]);
|
|
etMinutes.setText(time[1]);
|
|
etSeconds.setText(time[2]);
|
|
}
|
|
}
|
|
else{
|
|
etHours.setText("");
|
|
etMinutes.setText("");
|
|
etSeconds.setText("");
|
|
}
|
|
|
|
setLoopInterval();
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void setLoopInterval(){
|
|
String tag = TAG + "setLoopInterval";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
int hours = 0, minutes = 0, seconds = 0;
|
|
try {
|
|
hours = Integer.parseInt("0" + etHours.getText().toString());
|
|
} catch (Exception e) {
|
|
if (DEBUG) Log.d(tag, "Hours had an exception, using highest value");
|
|
hours = 99;
|
|
}
|
|
try {
|
|
minutes = Integer.parseInt("0" + etMinutes.getText().toString());
|
|
} catch (Exception e) {
|
|
if (DEBUG) Log.d(tag, "Minutes had an exception, using highest value");
|
|
minutes = 59;
|
|
}
|
|
try {
|
|
seconds = Integer.parseInt("0" + etSeconds.getText().toString());
|
|
} catch (Exception e) {
|
|
if (DEBUG) Log.d(tag, "Seconds had an exception, using highest value");
|
|
seconds = 59;
|
|
}
|
|
|
|
if ((hours + (minutes/60) + (seconds/60/60)) > 99) {
|
|
if (DEBUG) Log.d(tag, "Sum is over 99 hours, setting to 99:59:59");
|
|
hours = 99;
|
|
minutes = 59;
|
|
seconds = 59;
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "hours=" + hours);
|
|
if (DEBUG) Log.d(tag, "minutes=" + minutes);
|
|
if (DEBUG) Log.d(tag, "seconds=" + seconds);
|
|
|
|
if (hours > 0) etHours.setText("" + hours);
|
|
if (minutes > 0) etMinutes.setText("" + minutes);
|
|
if (seconds > 0) etSeconds.setText("" + seconds);
|
|
|
|
longLoopInterval = (((hours*60*60) + (minutes*60) + seconds) * 1000);
|
|
if (DEBUG) Log.d(tag, "longLoopInterval=" + longLoopInterval);
|
|
|
|
setChronometer(longLoopInterval);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void setChronometer(long milliseconds){
|
|
String tag = TAG + "setChronometer";
|
|
if (DEBUG) Log.d(tag, "Starting, milliseconds=" + milliseconds);
|
|
|
|
//chronometer = (TextView) findViewById(R.id.chronometer);
|
|
|
|
String[] time = {
|
|
Long.toString(milliseconds/(1000*60*60)),
|
|
Long.toString((milliseconds/(1000*60))%60),
|
|
Long.toString((milliseconds/(1000))%60)
|
|
};
|
|
|
|
for (int i = 0; i < time.length; i++){
|
|
while (time[i].length() < 2){
|
|
time[i] = "0" + time[i];
|
|
}
|
|
}
|
|
|
|
String display = time[0] + ":" + time[1] + ":" + time[2];
|
|
|
|
// Testing orientation change not allowing chronometer to update
|
|
/*
|
|
chronometer = (TextView) findViewById(R.id.chronometer);
|
|
chronometer.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
doTimeChooser();
|
|
}
|
|
});*/
|
|
if (DEBUG) Log.d(tag, "display=" + display);
|
|
sharedPreferences.edit().putString(keyChronometerTime, display).apply();
|
|
|
|
if (DEBUG) Log.d(tag, "Before=" + chronometer.getText());
|
|
chronometer.setText(display);
|
|
if (DEBUG) Log.d(tag, "After=" + chronometer.getText());
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void startStopChronometer(String buttonText){
|
|
String tag = TAG + "startStopChronometer";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
start = !start;
|
|
SharedPreferences.Editor editor = sharedPreferences.edit();
|
|
editor.putBoolean(keyStartStop, start);
|
|
editor.putBoolean(keyAppOpen, true);
|
|
editor.putBoolean(keyServiceRunning, false);
|
|
editor.apply();
|
|
|
|
// hours:minutes:seconds should be disabled during count down.
|
|
flipInputTexts();
|
|
|
|
if (buttonText.equals(getString(R.string.btnStart))){
|
|
incrementTime.sendEmptyMessage(0);
|
|
setLoopInterval();
|
|
resetTimeLeft();
|
|
setStartTime();
|
|
|
|
// Start the background alert service using Alert manager
|
|
long interval = longLoopInterval > 1000 ? longLoopInterval : 60000; // Minimum 1 minute interval for alarms
|
|
if (Alert.isExactAlarmAllowed(this)) {
|
|
Alert.start(this, interval);
|
|
} else {
|
|
if (DEBUG) Log.w(tag, "Cannot start alert: Exact alarm permission denied.");
|
|
new AlertDialog.Builder(MainActivity.this)
|
|
.setTitle("Permission Required")
|
|
.setMessage("Please grant 'All files access' or 'Alarm' permissions in system settings for this feature to work.")
|
|
.setPositiveButton("OK", (d, w) -> d.dismiss())
|
|
.show();
|
|
}
|
|
|
|
}
|
|
else if (buttonText.equals(getString(R.string.btnPause))){
|
|
btnStartStop.setText(getString(R.string.btnResume));
|
|
btnResetPause.setEnabled(false);
|
|
etHours.setEnabled(false);
|
|
etMinutes.setEnabled(false);
|
|
etSeconds.setEnabled(false);
|
|
}
|
|
else if (buttonText.equals(getString(R.string.btnStop))){
|
|
setChronometer(longLoopInterval);
|
|
}
|
|
else if (buttonText.equals(getString(R.string.btnResume))){
|
|
setStartTime();
|
|
incrementTime.sendEmptyMessage(0);
|
|
btnResetPause.setEnabled(true);
|
|
}
|
|
|
|
flipStartStopButton();
|
|
flipResetPauseButton();
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void recoverScreen(){
|
|
String tag = TAG + "recoverScreen";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
/***** Retrieve the last settings *****/
|
|
// Chronometer
|
|
stringChronometerTime = sharedPreferences.getString(keyChronometerTime, stringChronometerDefault);
|
|
chronometer.setText(stringChronometerTime);
|
|
|
|
// Loop interval
|
|
stringLoopInterval = sharedPreferences.getString(keyLoopInterval, stringChronometerDefault);
|
|
setEditTexts(stringLoopInterval);
|
|
|
|
// Start/Stop Button
|
|
start = sharedPreferences.getBoolean(keyStartStop, false);
|
|
if (DEBUG) Log.d(tag, "start=" + start);
|
|
flipStartStopButton();
|
|
|
|
flipResetPauseButton();
|
|
|
|
flipInputTexts();
|
|
|
|
// Testing how to keep timer ticking after rotation
|
|
//start = !start;
|
|
//startStopChronometer(stringChronometerTime);
|
|
|
|
//incrementTime.sendEmptyMessage(0);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void flipStartStopButton(){
|
|
String tag = TAG + "flipStartStopButton";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
start = sharedPreferences.getBoolean(keyStartStop, false);
|
|
serviceRunning = sharedPreferences.getBoolean(keyServiceRunning, false);
|
|
//if (start && !serviceRunning){
|
|
if (start){
|
|
btnStartStop.setText(getString(R.string.btnStop));
|
|
btnStartStop.setBackgroundColor(Color.RED);
|
|
}
|
|
else {
|
|
if (!btnStartStop.getText().toString().equals(getString(R.string.btnResume))) {
|
|
btnStartStop.setText(getString(R.string.btnStart));
|
|
}
|
|
btnStartStop.setBackgroundColor(Color.GREEN);
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void resetPauseChronometer(){
|
|
String tag = TAG + "resetPauseChronometer";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
start = sharedPreferences.getBoolean(keyStartStop, false);
|
|
serviceRunning = sharedPreferences.getBoolean(keyServiceRunning, false);
|
|
//if (start && !serviceRunning){
|
|
if (start){
|
|
startStopChronometer(btnResetPause.getText().toString());
|
|
}
|
|
else{
|
|
setEditTexts(stringChronometerDefault);
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void flipResetPauseButton(){
|
|
String tag = TAG + "flipResetPauseButton";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
start = sharedPreferences.getBoolean(keyStartStop, false);
|
|
serviceRunning = sharedPreferences.getBoolean(keyServiceRunning, false);
|
|
//if (start && !serviceRunning){
|
|
if (start){
|
|
btnResetPause.setText(getString(R.string.btnPause));
|
|
btnResetPause.setBackgroundColor(Color.YELLOW);
|
|
}
|
|
else {
|
|
btnResetPause.setText(getString(R.string.btnReset));
|
|
btnResetPause.setBackgroundColor(Color.RED);
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private final Handler incrementTime = new Handler(){
|
|
@Override
|
|
public void handleMessage(Message msg) {
|
|
String tag = TAG + "handleMessage";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
super.handleMessage(msg);
|
|
|
|
appOpen = sharedPreferences.getBoolean(keyAppOpen, true);
|
|
if (appOpen) {
|
|
sharedPreferences.edit().putBoolean(keyServiceRunning, false).apply();
|
|
} else {
|
|
sharedPreferences.edit().putBoolean(keyServiceRunning, true).apply();
|
|
}
|
|
|
|
start = sharedPreferences.getBoolean(keyStartStop, false);
|
|
if (start){
|
|
//start = !start;
|
|
//sharedPreferences.edit().putBoolean(keyStartStop, false).apply();
|
|
|
|
// Calculate new time and text
|
|
setTimeLeft();
|
|
|
|
if (DEBUG) Log.d(tag, "longTimeLeft=" + longTimeLeft);
|
|
|
|
// Check if we need to beep
|
|
if (longTimeLeft < 1000){
|
|
playSound();
|
|
resetTimeLeft();
|
|
setStartTime();
|
|
|
|
if (DEBUG) {
|
|
Log.d(tag, "longLoopInterval=" + longLoopInterval);
|
|
Log.d(tag, "longStartTime=" + longStartTime);
|
|
Log.d(tag, "longEndTime=" + longEndTime);
|
|
Log.d(tag, "longTimeLeft=" + longTimeLeft);
|
|
Log.d(tag, "waitInterval=" + waitInterval);
|
|
Log.d(tag, "start=" + start);
|
|
//chronometer.setText("Test");
|
|
//setChronometer(200);
|
|
/*
|
|
start=false;
|
|
startStopChronometer("Start");
|
|
*/
|
|
}
|
|
}
|
|
|
|
// Wait
|
|
Runnable task = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
|
|
synchronized (this){
|
|
try{
|
|
wait(waitInterval);
|
|
if (DEBUG) Log.d(tag, "Done waiting.");
|
|
}
|
|
catch (Exception e){
|
|
e.printStackTrace();
|
|
if (DEBUG) Log.d(tag, "Failed to wait.");
|
|
}
|
|
}
|
|
//sharedPreferences.edit().putBoolean(keyStartStop, true).apply();
|
|
incrementTime.sendEmptyMessage(0);
|
|
//startStopChronometer("Start");
|
|
}
|
|
};
|
|
Thread t = new Thread(task);
|
|
t.start();
|
|
}
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
};
|
|
|
|
private void setStartTime(){
|
|
String tag = TAG + "setStartTime";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
if (DEBUG) Log.d(tag, "System.currentTimeMillis()=" + System.currentTimeMillis());
|
|
|
|
if (longTimeLeft == 0) {
|
|
if (DEBUG) Log.d(tag, "longTimeLeft=" + longTimeLeft);
|
|
// Add extra 1000 so timer starts on interval and beeps after 1
|
|
longStartTime = System.currentTimeMillis() + 1000 - waitInterval;
|
|
if (DEBUG) Log.d(tag, "longStartTime=" + longStartTime);
|
|
longEndTime = longStartTime + longLoopInterval;
|
|
if (DEBUG) Log.d(tag, "longEndTime=" + longEndTime);
|
|
} else {
|
|
if (DEBUG) Log.d(tag, "longTimeLeft=" + longTimeLeft);
|
|
longStartTime = System.currentTimeMillis() - waitInterval;
|
|
if (DEBUG) Log.d(tag, "longStartTime=" + longStartTime);
|
|
longEndTime = longStartTime + longTimeLeft;
|
|
if (DEBUG) Log.d(tag, "longEndTime=" + longEndTime);
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void setTimeLeft(){
|
|
String tag = TAG + "setTimeLeft";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
longTimeLeft = longEndTime - System.currentTimeMillis() + waitInterval;
|
|
if (DEBUG) Log.d(tag, "longTimeLeft=" + longTimeLeft);
|
|
setChronometer(longTimeLeft);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void resetTimeLeft(){
|
|
String tag = TAG + "resetTimeLeft";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
longTimeLeft = 0;
|
|
setChronometer(longLoopInterval);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void playSound(){
|
|
String tag = TAG + "playSound";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
try {
|
|
// Safely instantiate MediaPlayer locally to prevent NPE
|
|
Uri uri = android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_NOTIFICATION);
|
|
MediaPlayer localPlayer = MediaPlayer.create(this, uri);
|
|
|
|
if (localPlayer != null) {
|
|
localPlayer.start();
|
|
localPlayer.release(); // Clean up resources immediately
|
|
} else {
|
|
// Fallback for edge cases where create() fails
|
|
android.media.Ringtone ringtone = android.media.RingtoneManager.getRingtone(this, uri);
|
|
if (ringtone != null) ringtone.play();
|
|
}
|
|
} catch (Exception e) {
|
|
sharedPreferences.edit().putBoolean(keyStartStop, false).apply();
|
|
|
|
String message = "Failed to play a notification sound.";
|
|
message += " Please screenshot this error and send it to me@hyperling.com:\n\n";
|
|
message += e.toString();
|
|
|
|
new AlertDialog.Builder(MainActivity.this)
|
|
.setTitle("Error")
|
|
.setMessage(message)
|
|
.setPositiveButton("Exit", new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
dialog.dismiss();
|
|
finish();
|
|
}
|
|
})
|
|
.setCancelable(false)
|
|
.show()
|
|
;
|
|
}
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void flipInputTexts() {
|
|
String tag = TAG + "flipInputTexts";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
etHours.setEnabled(!start);
|
|
etMinutes.setEnabled(!start);
|
|
etSeconds.setEnabled(!start);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
private void resetAll() {
|
|
String tag = TAG + "resetAll";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
// Stop the background alert service when resetting
|
|
Alert.stop(this);
|
|
|
|
if (DEBUG) Log.d(tag, "Resetting screen values...");
|
|
setChronometer(0);
|
|
setEditTexts("");
|
|
setLoopInterval();
|
|
if (DEBUG) Log.d(tag, "Values reset");
|
|
|
|
if (DEBUG) Log.d(tag, "Resetting SharedPreferences...");
|
|
start = false;
|
|
SharedPreferences.Editor editor = sharedPreferences.edit();
|
|
editor.putBoolean(keyStartStop, start);
|
|
editor.putBoolean(keyAppOpen, start);
|
|
editor.putBoolean(keyServiceRunning, start);
|
|
int count = 0;
|
|
while (!editor.commit() && count < 50) {
|
|
Log.i(tag, "Failed! Reattempting commit... count=" + count);
|
|
count++;
|
|
};
|
|
if (DEBUG) Log.d(tag, "SharedPreferences reset");
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
public void syncVolume() {
|
|
String tag = TAG + "syncVolume";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
int currVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
|
|
if (currVolume != seekBar.getProgress()) {
|
|
seekBar.setProgress(currVolume);
|
|
}
|
|
|
|
String volume = getString(R.string.tvSeekBar) + " " + seekBar.getProgress() + "/" + seekBar.getMax();
|
|
tvSeekBar.setText(volume);
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
@Override
|
|
protected void onPause() {
|
|
String tag = TAG + "onPause";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
stringLoopInterval =
|
|
etHours.getText().toString() + ":" +
|
|
etMinutes.getText().toString() + ":" +
|
|
etSeconds.getText().toString();
|
|
|
|
SharedPreferences.Editor editor = sharedPreferences.edit();
|
|
editor.putString(keyChronometerTime, chronometer.getText().toString());
|
|
editor.putString(keyLoopInterval, stringLoopInterval);
|
|
editor.putBoolean(keyAppOpen, false);
|
|
editor.apply();
|
|
|
|
if (DEBUG) Log.d(tag, "Done with local code, calling super.");
|
|
|
|
super.onPause();
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
@Override
|
|
protected void onResume() {
|
|
super.onResume();
|
|
|
|
String tag = TAG + "onResume";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
sharedPreferences.edit().putBoolean(keyServiceRunning, false).apply();
|
|
|
|
recoverScreen();
|
|
syncVolume();
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
@Override
|
|
protected void onDestroy() {
|
|
String tag = TAG + "onDestroy";
|
|
if (DEBUG) Log.d(tag, "Starting");
|
|
|
|
// Stop the background alert service when destroying activity
|
|
Alert.stop(this);
|
|
|
|
if (DEBUG) Log.d(tag, "Done with local code, calling super..");
|
|
|
|
super.onDestroy();
|
|
|
|
if (DEBUG) Log.d(tag, "Finished");
|
|
}
|
|
|
|
// TODO: This is somehow always 1 action behind the actual volume when pressing volume buttons.
|
|
// Like when doing down+up+down, the bar does nothing+down+up.
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent event) {
|
|
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
|
|
boolean bool = super.onKeyDown(keyCode, event);
|
|
syncVolume();
|
|
return bool;
|
|
}
|
|
return super.onKeyDown(keyCode, event);
|
|
}
|
|
}
|