repeatDays) {
ConstantsAndStatics.cancelScheduledPeriodicWork(this);
AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
- LocalDateTime alarmDateTime;
- LocalDate alarmDate = LocalDate.of(alarmEntity.alarmYear, alarmEntity.alarmMonth,
- alarmEntity.alarmDay);
- LocalTime alarmTime = LocalTime.of(alarmEntity.alarmHour, alarmEntity.alarmMinutes);
-
- if (alarmEntity.isRepeatOn && repeatDays != null && repeatDays.size() > 0) {
-
- Collections.sort(repeatDays);
-
- alarmDateTime = LocalDateTime.of(LocalDate.now(), alarmTime);
- int dayOfWeek = alarmDateTime.getDayOfWeek().getValue();
-
- for (int i = 0; i < repeatDays.size(); i++) {
- if (repeatDays.get(i) == dayOfWeek) {
- if (alarmTime.isAfter(LocalTime.now())) {
- // Alarm possible today, nothing more to do, break out of loop.
- break;
- }
- } else if (repeatDays.get(i) > dayOfWeek) {
- /////////////////////////////////////////////////////////////////////////
- // There is a day available in the same week for the alarm to ring;
- // select that day and break from loop.
- ////////////////////////////////////////////////////////////////////////
- alarmDateTime =
- alarmDateTime.with(TemporalAdjusters.next(DayOfWeek.of(repeatDays.get(i))));
- break;
- }
- if (i == repeatDays.size() - 1) {
- // No day possible in this week. Select the first available date from next week.
- alarmDateTime = alarmDateTime
- .with(TemporalAdjusters.next(DayOfWeek.of(repeatDays.get(0))));
- }
- }
-
- } else {
+ if (repeatDays != null) { Collections.sort(repeatDays); }
- alarmDateTime = LocalDateTime.of(alarmDate, alarmTime);
-
- if (! alarmDateTime.isAfter(LocalDateTime.now())) {
- alarmDateTime = alarmDateTime.plusDays(1);
- }
-
- }
+ LocalDateTime alarmDateTime = ConstantsAndStatics.getAlarmDateTime(LocalDate.of(alarmEntity.alarmYear,
+ alarmEntity.alarmMonth, alarmEntity.alarmDay), LocalTime.of(alarmEntity.alarmHour,
+ alarmEntity.alarmMinutes), alarmEntity.isRepeatOn, repeatDays);
///////////////////////////////////////////////////////////////////////////////////////////
// IMPORTANT:
@@ -336,8 +250,8 @@ private void addOrActivateAlarm(int mode, AlarmEntity alarmEntity,
data.putInt(ConstantsAndStatics.BUNDLE_KEY_ALARM_ID, alarmID);
intent.putExtra(ConstantsAndStatics.BUNDLE_KEY_ALARM_DETAILS, data);
- PendingIntent pendingIntent = PendingIntent
- .getBroadcast(Activity_AlarmsList.this, alarmID, intent, 0);
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(Activity_AlarmsList.this, alarmID, intent,
+ PendingIntent.FLAG_CANCEL_CURRENT);
ZonedDateTime zonedDateTime = ZonedDateTime.of(alarmDateTime.withSecond(0), ZoneId.systemDefault());
@@ -403,8 +317,8 @@ private void toggleAlarmState(int hour, int mins, final int newAlarmState) {
if (newAlarmState == 0) {
deleteOrDeactivateAlarm(MODE_DEACTIVATE_ONLY, hour, mins);
} else {
- addOrActivateAlarm(MODE_ACTIVATE_EXISTING_ALARM, viewModel.getAlarmEntity(alarmDatabase, hour,
- mins), viewModel.getRepeatDays(alarmDatabase, hour, mins));
+ addOrActivateAlarm(MODE_ACTIVATE_EXISTING_ALARM, viewModel.getAlarmEntity(alarmDatabase, hour, mins),
+ viewModel.getRepeatDays(alarmDatabase, hour, mins));
}
}
@@ -543,26 +457,6 @@ public void handleMessage(@NonNull Message msg) {
//--------------------------------------------------------------------------------------------------
- @Override
- public void onDialogPositiveClick(DialogFragment dialogFragment) {
- if (dialogFragment.getClass().equals(AlertDialog_PermissionReason.class)) {
- ActivityCompat.requestPermissions(this,
- new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, MY_PERMISSIONS_REQUEST);
- }
- }
-
- //--------------------------------------------------------------------------------------------------
-
- @Override
- public void onDialogNegativeClick(DialogFragment dialogFragment) {
- if (dialogFragment.getClass().equals(AlertDialog_PermissionReason.class)) {
- Toast.makeText(this, "Alarm may not ring without permission to read storage.",
- Toast.LENGTH_LONG).show();
- }
- }
-
- //--------------------------------------------------------------------------------------------------
-
private boolean isInstalledOnInternalStorage() {
ApplicationInfo io = getApplicationInfo();
return ! io.sourceDir.startsWith("/mnt/") &&
diff --git a/app/src/main/java/in/basulabs/shakealarmclock/Activity_IntentManager.java b/app/src/main/java/in/basulabs/shakealarmclock/Activity_IntentManager.java
new file mode 100644
index 0000000..0303faf
--- /dev/null
+++ b/app/src/main/java/in/basulabs/shakealarmclock/Activity_IntentManager.java
@@ -0,0 +1,333 @@
+package in.basulabs.shakealarmclock;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.app.VoiceInteractor;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.media.AudioManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.AlarmClock;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.ACTION_NEW_ALARM_FROM_INTENT;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.ALARM_TYPE_SOUND_AND_VIBRATE;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.ALARM_TYPE_SOUND_ONLY;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.ALARM_TYPE_VIBRATE_ONLY;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_DAY;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_DETAILS;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_HOUR;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_ID;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_MINUTE;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_MONTH;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_TONE_URI;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_TYPE;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_VOLUME;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_ALARM_YEAR;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_IS_REPEAT_ON;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.BUNDLE_KEY_REPEAT_DAYS;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_FILE_NAME;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_KEY_DEFAULT_ALARM_TONE_URI;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_KEY_DEFAULT_ALARM_VOLUME;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_KEY_DEFAULT_SNOOZE_FREQ;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_KEY_DEFAULT_SNOOZE_INTERVAL;
+import static in.basulabs.shakealarmclock.ConstantsAndStatics.SHARED_PREF_KEY_DEFAULT_SNOOZE_IS_ON;
+
+/**
+ * An activity to manage activity actions for this app.
+ *
+ * This activity has no display and is transparent. It handles incoming intents and finishes itself in {@link
+ * #onCreate(Bundle)}.
+ *
+ * The following activity actions are handled:
+ *
+ * - {@link android.provider.AlarmClock#ACTION_SET_ALARM}
+ * - {@link android.provider.AlarmClock#ACTION_DISMISS_ALARM}
+ * - {@link android.provider.AlarmClock#ACTION_SNOOZE_ALARM}
+ *
+ *
+ */
+public class Activity_IntentManager extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(@Nullable Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ Log.e(this.getClass().getSimpleName(), Objects.requireNonNull(getIntent().getAction()));
+
+ Intent intent = getIntent();
+
+ switch (Objects.requireNonNull(intent.getAction())) {
+
+ case AlarmClock.ACTION_SET_ALARM:
+
+ Log.e(this.getClass().getSimpleName(), "received action SET_ALARM.");
+
+ if (! intent.hasExtra(AlarmClock.EXTRA_HOUR) || ! intent.hasExtra(AlarmClock.EXTRA_MINUTES)) {
+ ///////////////////////////////////////////////////////////////////////
+ // These two extras are necessary for an alarm to be set. Without
+ // these, the user will be redirected to Activity_AlarmsList.
+ ///////////////////////////////////////////////////////////////////////
+ Log.e(this.getClass().getSimpleName(), "Intent does not have any extras.");
+
+ Intent intent1 = new Intent(this, Activity_AlarmsList.class);
+ intent1.setAction(ACTION_NEW_ALARM_FROM_INTENT)
+ .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
+ startActivity(intent1);
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (isVoiceInteraction()) {
+
+ Log.e(this.getClass().getSimpleName(), "Voice interaction.");
+
+ Bundle status = new Bundle();
+ VoiceInteractor.Prompt prompt = new VoiceInteractor.Prompt(
+ new String[]{"You can do that in the app."},
+ "You can do that in the app.");
+
+ VoiceInteractor.Request request = new VoiceInteractor.CompleteVoiceRequest(prompt, status);
+ getVoiceInteractor().submitRequest(request);
+ }
+ }
+ } else {
+ setAlarm();
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ if (isVoiceInteraction()) {
+
+ Log.e(this.getClass().getSimpleName(), "Voice interaction.");
+
+ Bundle status = new Bundle();
+ VoiceInteractor.Prompt prompt = new VoiceInteractor.Prompt(
+ new String[]{"Your alarm has been set by Shake Alarm Clock."},
+ "Your alarm has been set by Shake Alarm Clock.");
+
+ VoiceInteractor.Request request = new VoiceInteractor.CompleteVoiceRequest(prompt, status);
+ getVoiceInteractor().submitRequest(request);
+ }
+ }
+ }
+
+ break;
+
+ case AlarmClock.ACTION_DISMISS_ALARM:
+
+ if (Service_RingAlarm.isThisServiceRunning || Service_SnoozeAlarm.isThisServiceRunning) {
+ Intent intent1 = new Intent();
+ intent1.setAction(ConstantsAndStatics.ACTION_CANCEL_ALARM);
+ sendBroadcast(intent1);
+ } else {
+ Intent intent1 = new Intent(this, Activity_AlarmsList.class);
+ intent1.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
+ startActivity(intent1);
+ }
+
+ break;
+
+ case AlarmClock.ACTION_SNOOZE_ALARM:
+
+ Intent intent1 = new Intent();
+ intent1.setAction(ConstantsAndStatics.ACTION_SNOOZE_ALARM);
+ sendBroadcast(intent1);
+ break;
+ }
+
+ finish();
+
+ }
+
+ //-------------------------------------------------------------------------------------------------------------
+
+ private void setAlarm() {
+
+ SharedPreferences sharedPreferences = getSharedPreferences(SHARED_PREF_FILE_NAME, MODE_PRIVATE);
+
+ ///////////////////////////////////////////////
+ // Retrieve all data passed with intent:
+ //////////////////////////////////////////////
+
+ Intent intent = getIntent();
+
+ LocalTime alarmTime = LocalTime.of(Objects.requireNonNull(intent.getExtras()).getInt(AlarmClock.EXTRA_HOUR),
+ intent.getExtras().getInt(AlarmClock.EXTRA_MINUTES));
+
+ ArrayList repeatDays;
+ if (intent.hasExtra(AlarmClock.EXTRA_DAYS)) {
+
+ repeatDays = intent.getIntegerArrayListExtra(AlarmClock.EXTRA_DAYS);
+ assert repeatDays != null;
+
+ // The EXTRA_DAYS follow java.util.Calendar (Sunday is 1 and Saturday is 7). In this app, we follow
+ // java.time.DayOfWeek enum (Monday is 1 and Sunday is 7). We change repeatDays accordingly.
+ ArrayList temp = new ArrayList<>();
+ for (int i : repeatDays) {
+ if (i == 1) {
+ temp.add(7);
+ } else {
+ temp.add(i - 1);
+ }
+ }
+ repeatDays = temp;
+
+ Collections.sort(repeatDays);
+ } else {
+ repeatDays = null;
+ }
+
+ boolean isRepeatOn = repeatDays != null;
+
+ Uri alarmToneUri;
+ if (intent.hasExtra(AlarmClock.EXTRA_RINGTONE)) {
+
+ if (Objects.equals(intent.getExtras().getString(AlarmClock.EXTRA_RINGTONE), AlarmClock.VALUE_RINGTONE_SILENT)) {
+ alarmToneUri = null;
+ } else {
+
+ alarmToneUri = Uri.parse(intent.getExtras().getString(AlarmClock.EXTRA_RINGTONE));
+
+ if (! doesFileExist(alarmToneUri)) {
+ // Uri invalid or file doesn't exist; fall back to default tone
+ alarmToneUri = Uri.parse(sharedPreferences.getString(SHARED_PREF_KEY_DEFAULT_ALARM_TONE_URI,
+ "content://settings/system/alarm_alert"));
+ }
+
+ }
+ } else {
+ alarmToneUri = Uri.parse(sharedPreferences.getString(SHARED_PREF_KEY_DEFAULT_ALARM_TONE_URI,
+ "content://settings/system/alarm_alert"));
+ }
+
+ int volume;
+ if (alarmToneUri != null) {
+ AudioManager audioManager = (AudioManager) getSystemService(AUDIO_SERVICE);
+ volume = sharedPreferences.getInt(SHARED_PREF_KEY_DEFAULT_ALARM_VOLUME,
+ audioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM) - 1);
+ } else {
+ volume = 0;
+ }
+
+ int alarmType;
+ if (intent.hasExtra(AlarmClock.EXTRA_VIBRATE)) {
+ if (intent.getExtras().getBoolean(AlarmClock.EXTRA_VIBRATE)) {
+ alarmType = volume > 0 ? ALARM_TYPE_SOUND_AND_VIBRATE : ALARM_TYPE_VIBRATE_ONLY;
+ } else {
+ alarmType = ALARM_TYPE_SOUND_ONLY;
+ }
+ } else {
+ alarmType = volume > 0 ? ALARM_TYPE_SOUND_AND_VIBRATE : ALARM_TYPE_VIBRATE_ONLY;
+ }
+
+ ////////////////////////////////
+ // Now set the alarm:
+ ////////////////////////////////
+ AlarmDatabase alarmDatabase = AlarmDatabase.getInstance(this);
+
+ LocalDateTime alarmDateTime = ConstantsAndStatics.getAlarmDateTime(LocalDate.now(), alarmTime,
+ isRepeatOn, repeatDays);
+
+ if (intent.getExtras().getBoolean(AlarmClock.EXTRA_SKIP_UI, false)) {
+ // We have been asked to skip the UI. Alarm will be set by this activity itself.
+
+ AlarmEntity alarmEntity = new AlarmEntity(alarmTime.getHour(), alarmTime.getMinute(), true,
+ sharedPreferences.getBoolean(SHARED_PREF_KEY_DEFAULT_SNOOZE_IS_ON, true),
+ sharedPreferences.getInt(SHARED_PREF_KEY_DEFAULT_SNOOZE_INTERVAL, 5),
+ sharedPreferences.getInt(SHARED_PREF_KEY_DEFAULT_SNOOZE_FREQ, 3),
+ volume, isRepeatOn, alarmType, alarmDateTime.getDayOfMonth(), alarmDateTime.getMonthValue(),
+ alarmDateTime.getYear(), alarmToneUri, false);
+
+ AtomicInteger alarmID = new AtomicInteger();
+
+ Thread thread = new Thread(() -> {
+ alarmDatabase.alarmDAO().addAlarm(alarmEntity);
+ alarmID.set(alarmDatabase.alarmDAO().getAlarmId(alarmEntity.alarmHour, alarmEntity.alarmMinutes));
+ });
+
+ thread.start();
+ try {
+ thread.join();
+ } catch (InterruptedException ignored) {
+ }
+
+ AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
+
+ Intent intent1 = new Intent(this, AlarmBroadcastReceiver.class);
+ intent1.setAction(ConstantsAndStatics.ACTION_DELIVER_ALARM)
+ .setFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+
+ alarmEntity.alarmID = alarmID.get();
+ Bundle data = alarmEntity.getAlarmDetailsInABundle();
+ data.putIntegerArrayList(BUNDLE_KEY_REPEAT_DAYS, repeatDays);
+ data.remove(BUNDLE_KEY_ALARM_ID);
+ data.putInt(BUNDLE_KEY_ALARM_ID, alarmID.get());
+ intent1.putExtra(BUNDLE_KEY_ALARM_DETAILS, data);
+
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(this, alarmID.get(),
+ intent1, PendingIntent.FLAG_CANCEL_CURRENT);
+
+ ZonedDateTime zonedDateTime = ZonedDateTime.of(alarmDateTime.withSecond(0), ZoneId.systemDefault());
+
+ alarmManager.setAlarmClock(new AlarmManager.AlarmClockInfo(zonedDateTime.toEpochSecond() * 1000,
+ pendingIntent), pendingIntent);
+
+ ConstantsAndStatics.schedulePeriodicWork(this);
+
+ } else {
+ // We have been asked not to skip the UI. We have some data, and with that data we will start
+ // Activity_AlarmsList, which will, in turn, start Activity_AlarmDetails, and thereafter the UI will
+ // be shown. Any missing data will be filled in by Activity_AlarmDetails.
+
+ Intent intent1 = new Intent(this, Activity_AlarmsList.class);
+ intent1.setAction(ACTION_NEW_ALARM_FROM_INTENT)
+ .putExtra(BUNDLE_KEY_ALARM_HOUR, alarmDateTime.getHour())
+ .putExtra(BUNDLE_KEY_ALARM_MINUTE, alarmDateTime.getMinute())
+ .putExtra(BUNDLE_KEY_ALARM_DAY, alarmDateTime.getDayOfMonth())
+ .putExtra(BUNDLE_KEY_ALARM_MONTH, alarmDateTime.getMonthValue())
+ .putExtra(BUNDLE_KEY_ALARM_YEAR, alarmDateTime.getYear())
+ .putExtra(BUNDLE_KEY_ALARM_VOLUME, volume)
+ .putExtra(BUNDLE_KEY_ALARM_TONE_URI, alarmToneUri)
+ .putExtra(BUNDLE_KEY_ALARM_TYPE, alarmType)
+ .putExtra(BUNDLE_KEY_IS_REPEAT_ON, isRepeatOn)
+ .putExtra(BUNDLE_KEY_REPEAT_DAYS, repeatDays)
+ .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+ .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
+ startActivity(intent1);
+
+ }
+
+ }
+
+ //--------------------------------------------------------------------------------------------------------------
+
+ /**
+ * Finds whether a file exists or not.
+ *
+ * @param uri The Uri of the file.
+ *
+ * @return {@code true} if the file exists, otherwise {@code false}.
+ */
+ private boolean doesFileExist(Uri uri) {
+ try (Cursor cursor = getContentResolver().query(uri, null, null, null, null)) {
+ return cursor != null;
+ }
+ }
+
+ //---------------------------------------------------------------------------------------------------------------
+}
diff --git a/app/src/main/java/in/basulabs/shakealarmclock/AlarmDAO.java b/app/src/main/java/in/basulabs/shakealarmclock/AlarmDAO.java
index ac221ed..2623446 100644
--- a/app/src/main/java/in/basulabs/shakealarmclock/AlarmDAO.java
+++ b/app/src/main/java/in/basulabs/shakealarmclock/AlarmDAO.java
@@ -106,7 +106,7 @@ public interface AlarmDAO {
*
* @return The alarms that are currently active, i.e., in ON state.
*/
- @Query("SELECT * FROM alarm_entity WHERE isAlarmOn = 1")
+ @Query("SELECT * FROM alarm_entity WHERE isAlarmOn = 1 ORDER BY alarmHour, alarmMinutes")
List getActiveAlarms();
/**
diff --git a/app/src/main/java/in/basulabs/shakealarmclock/ConstantsAndStatics.java b/app/src/main/java/in/basulabs/shakealarmclock/ConstantsAndStatics.java
index 4ee7326..e27e788 100644
--- a/app/src/main/java/in/basulabs/shakealarmclock/ConstantsAndStatics.java
+++ b/app/src/main/java/in/basulabs/shakealarmclock/ConstantsAndStatics.java
@@ -4,13 +4,20 @@
import android.content.Intent;
import android.util.Log;
+import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatDelegate;
import androidx.work.Configuration;
import androidx.work.ExistingPeriodicWorkPolicy;
import androidx.work.PeriodicWorkRequest;
import androidx.work.WorkManager;
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
import java.time.LocalTime;
+import java.time.temporal.TemporalAdjusters;
+import java.util.ArrayList;
+import java.util.Collections;
import java.util.concurrent.TimeUnit;
/**
@@ -147,9 +154,12 @@ final class ConstantsAndStatics {
*/
static final String ACTION_EXISTING_ALARM = "in.basulabs.shakealarmclock.ACTION_EXISTING_ALARM";
+ static final String ACTION_NEW_ALARM_FROM_INTENT =
+ "in.basulabs.shakealarmclock.ACTION_NEW_ALARM_FROM_INTENT";
+
/**
- * Indicates whether {@link Activity_RingtonePicker} should play the ringtone when the user clicks on a
- * {@link android.widget.RadioButton}. Default: {@code true}.
+ * Indicates whether {@link Activity_RingtonePicker} should play the ringtone when the user clicks on a {@link
+ * android.widget.RadioButton}. Default: {@code true}.
*/
static final String EXTRA_PLAY_RINGTONE = "in.basulabs.shakealarmclock.EXTRA_PLAY_RINGTONE";
@@ -288,6 +298,8 @@ final class ConstantsAndStatics {
*/
static final String WORK_NAME_ACTIVATE_ALARMS = "in.basulabs.WORK_ACTIVATE_ALARMS";
+ //---------------------------------------------------------------------------------------------------------
+
/**
* Creates a {@link PeriodicWorkRequest} and enqueues a unique work using {@link
* WorkManager#enqueueUniquePeriodicWork(String, ExistingPeriodicWorkPolicy, PeriodicWorkRequest)}.
@@ -307,6 +319,8 @@ static void schedulePeriodicWork(Context context) {
ExistingPeriodicWorkPolicy.REPLACE, periodicWorkRequest);
}
+ //---------------------------------------------------------------------------------------------------------
+
/**
* Cancels a scheduled work using {@link WorkManager#cancelUniqueWork(String)}.
*
@@ -321,6 +335,8 @@ static void cancelScheduledPeriodicWork(Context context) {
WorkManager.getInstance(context).cancelUniqueWork(WORK_NAME_ACTIVATE_ALARMS);
}
+ //---------------------------------------------------------------------------------------------------------
+
/**
* Get the theme that can be applied using {@link AppCompatDelegate#setDefaultNightMode(int)}.
*
@@ -339,7 +355,7 @@ static int getTheme(int theme) {
case THEME_DARK:
return AppCompatDelegate.MODE_NIGHT_YES;
default:
- if (LocalTime.now().isAfter(LocalTime.of(22, 0))
+ if (LocalTime.now().isAfter(LocalTime.of(21, 59))
|| LocalTime.now().isBefore(LocalTime.of(6, 0))) {
return AppCompatDelegate.MODE_NIGHT_YES;
} else {
@@ -348,6 +364,8 @@ static int getTheme(int theme) {
}
}
+ //---------------------------------------------------------------------------------------------------------
+
static void killServices(Context context, int alarmID) {
if (Service_RingAlarm.isThisServiceRunning && Service_RingAlarm.alarmID == alarmID) {
Intent intent = new Intent(context, Service_RingAlarm.class);
@@ -359,4 +377,61 @@ static void killServices(Context context, int alarmID) {
}
}
+ //---------------------------------------------------------------------------------------------------------
+
+ /**
+ * Get the date and time when the alarm should ring.
+ *
+ * @param alarmDate The alarm date as chosen by the user.
+ * @param alarmTime The alarm time as chosen by the user.
+ * @param isRepeatOn Whether repeat is on or off.
+ * @param repeatDays The days when the alarm should be repeated. Should follow {@link DayOfWeek} enum.
+ *
+ * @return A {@link LocalDateTime} object representing when the alarm should ring. This should be transformed into a
+ * {@link java.time.ZonedDateTime} object and then passed to {@link android.app.AlarmManager}.
+ */
+ static LocalDateTime getAlarmDateTime(LocalDate alarmDate, LocalTime alarmTime, boolean isRepeatOn,
+ @Nullable ArrayList repeatDays) {
+
+ LocalDateTime alarmDateTime;
+
+ if (isRepeatOn && repeatDays != null && repeatDays.size() > 0) {
+
+ Collections.sort(repeatDays);
+
+ alarmDateTime = LocalDateTime.of(LocalDate.now(), alarmTime);
+ int dayOfWeek = alarmDateTime.getDayOfWeek().getValue();
+
+ for (int i = 0; i < repeatDays.size(); i++) {
+ if (repeatDays.get(i) == dayOfWeek) {
+ if (alarmTime.isAfter(LocalTime.now())) {
+ // Alarm possible today, nothing more to do, break out of loop.
+ break;
+ }
+ } else if (repeatDays.get(i) > dayOfWeek) {
+ /////////////////////////////////////////////////////////////////////////
+ // There is a day available in the same week for the alarm to ring;
+ // select that day and break from loop.
+ ////////////////////////////////////////////////////////////////////////
+ alarmDateTime = alarmDateTime.with(TemporalAdjusters.next(DayOfWeek.of(repeatDays.get(i))));
+ break;
+ }
+ if (i == repeatDays.size() - 1) {
+ // No day possible in this week. Select the first available date from next week.
+ alarmDateTime = alarmDateTime.with(TemporalAdjusters.next(DayOfWeek.of(repeatDays.get(0))));
+ }
+ }
+
+ } else {
+
+ alarmDateTime = LocalDateTime.of(alarmDate, alarmTime);
+
+ if (! alarmDateTime.isAfter(LocalDateTime.now())) {
+ alarmDateTime = alarmDateTime.plusDays(1);
+ }
+ }
+
+ return alarmDateTime;
+ }
+
}
diff --git a/app/src/main/java/in/basulabs/shakealarmclock/Service_RingAlarm.java b/app/src/main/java/in/basulabs/shakealarmclock/Service_RingAlarm.java
index dd0d307..c04dc62 100644
--- a/app/src/main/java/in/basulabs/shakealarmclock/Service_RingAlarm.java
+++ b/app/src/main/java/in/basulabs/shakealarmclock/Service_RingAlarm.java
@@ -250,7 +250,6 @@ private Notification buildRingNotification() {
*/
private void ringAlarm() {
-
notificationManager.notify(NOTIFICATION_ID, buildRingNotification());
initialiseShakeSensor();
@@ -330,6 +329,7 @@ private void snoozeAlarm() {
intent.putExtra(BUNDLE_KEY_NO_OF_TIMES_SNOOZED, numberOfTimesTheAlarmHasBeenSnoozed);
ContextCompat.startForegroundService(this, intent);
+ stopForeground(true);
stopSelf();
} else {
dismissAlarm();
@@ -367,8 +367,7 @@ private void dismissAlarm() {
LocalTime alarmTime = LocalTime.of(alarmDetails.getInt(ConstantsAndStatics.BUNDLE_KEY_ALARM_HOUR),
alarmDetails.getInt(ConstantsAndStatics.BUNDLE_KEY_ALARM_MINUTE));
- ArrayList repeatDays = alarmDetails
- .getIntegerArrayList(ConstantsAndStatics.BUNDLE_KEY_REPEAT_DAYS);
+ ArrayList repeatDays = alarmDetails.getIntegerArrayList(ConstantsAndStatics.BUNDLE_KEY_REPEAT_DAYS);
assert repeatDays != null;
Collections.sort(repeatDays);
@@ -397,6 +396,7 @@ private void dismissAlarm() {
}
ConstantsAndStatics.schedulePeriodicWork(this);
+ stopForeground(true);
stopSelf();
}
@@ -438,12 +438,12 @@ private void setAlarm(LocalDateTime alarmDateTime) {
intent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(ConstantsAndStatics.BUNDLE_KEY_ALARM_DETAILS, alarmDetails);
- PendingIntent pendingIntent = PendingIntent.getBroadcast(this, alarmID, intent, 0);
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(this, alarmID, intent, PendingIntent.FLAG_CANCEL_CURRENT);
ZonedDateTime zonedDateTime = ZonedDateTime.of(alarmDateTime.withSecond(0), ZoneId.systemDefault());
- alarmManager.setAlarmClock(
- new AlarmManager.AlarmClockInfo(zonedDateTime.toEpochSecond() * 1000, pendingIntent), pendingIntent);
+ alarmManager.setAlarmClock(new AlarmManager.AlarmClockInfo(zonedDateTime.toEpochSecond() * 1000,
+ pendingIntent), pendingIntent);
}
//---------------------------------------------------------------------------------------------------
diff --git a/app/src/main/java/in/basulabs/shakealarmclock/Service_SnoozeAlarm.java b/app/src/main/java/in/basulabs/shakealarmclock/Service_SnoozeAlarm.java
index 4a53746..4d0c2b2 100644
--- a/app/src/main/java/in/basulabs/shakealarmclock/Service_SnoozeAlarm.java
+++ b/app/src/main/java/in/basulabs/shakealarmclock/Service_SnoozeAlarm.java
@@ -235,6 +235,7 @@ private void dismissAlarm() {
pendingIntent2), pendingIntent2);
}
ConstantsAndStatics.schedulePeriodicWork(this);
+ stopForeground(true);
stopSelf();
}
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
index 1ca95f6..ed19651 100644
--- a/app/src/main/res/values/styles.xml
+++ b/app/src/main/res/values/styles.xml
@@ -29,7 +29,19 @@
- @color/defaultLabelColor
-
+
\ No newline at end of file