Add automatic night mode support

This commit is contained in:
Moez Bhatti
2018-02-06 04:07:49 -05:00
parent 6791fb2a9c
commit cdba70c6da
16 changed files with 389 additions and 93 deletions
@@ -22,6 +22,7 @@ import common.QKApplication
import common.util.ContactImageLoader
import dagger.Component
import presentation.common.widget.*
import presentation.receiver.NightModeReceiver
import presentation.feature.compose.ComposeActivity
import presentation.feature.compose.ComposeViewModel
import presentation.feature.compose.DetailedChipView
@@ -60,6 +61,7 @@ interface AppComponent {
fun inject(receiver: MmsReceivedReceiver)
fun inject(receiver: MmsSentReceiver)
fun inject(receiver: MmsUpdatedReceiver)
fun inject(receiver: NightModeReceiver)
fun inject(receiver: RemoteMessagingReceiver)
fun inject(view: AvatarView)
+34 -34
View File
@@ -64,60 +64,60 @@ class Colors @Inject constructor(private val context: Context, prefs: Preference
val theme: Observable<Int> = prefs.theme.asObservable()
.distinctUntilChanged()
val appThemeResources: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.style.AppThemeDark else R.style.AppThemeLight }
val appThemeResources: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.style.AppThemeDark else R.style.AppThemeLight }
val popupThemeResource: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.style.PopupThemeDark else R.style.PopupThemeLight }
val popupThemeResource: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.style.PopupThemeDark else R.style.PopupThemeLight }
@SuppressLint("InlinedApi")
val statusBarIcons: Observable<Int> = prefs.dark.asObservable()
.map { dark -> dark || Build.VERSION.SDK_INT < Build.VERSION_CODES.M }
val statusBarIcons: Observable<Int> = prefs.night.asObservable()
.map { night -> night || Build.VERSION.SDK_INT < Build.VERSION_CODES.M }
.map { lightIcons -> if (lightIcons) 0 else View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR }
.distinctUntilChanged()
val statusBar: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.statusBarDark else R.color.statusBarLight }
val statusBar: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.statusBarDark else R.color.statusBarLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val toolbarColor: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.toolbarDark else R.color.toolbarLight }
val toolbarColor: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.toolbarDark else R.color.toolbarLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val background: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.backgroundDark else R.color.white }
val background: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.backgroundDark else R.color.white }
.map { res -> getColor(res) }
.distinctUntilChanged()
val field: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.fieldDark else R.color.fieldLight }
val field: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.fieldDark else R.color.fieldLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val composeBackground: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.backgroundDark else R.color.backgroundLight }
val composeBackground: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.backgroundDark else R.color.backgroundLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val separator: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.separatorDark else R.color.separatorLight }
val separator: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.separatorDark else R.color.separatorLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textPrimary: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.textPrimaryDark else R.color.textPrimary }
val textPrimary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textPrimaryDark else R.color.textPrimary }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textSecondary: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.textSecondaryDark else R.color.textSecondary }
val textSecondary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textSecondaryDark else R.color.textSecondary }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textTertiary: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.textTertiaryDark else R.color.textTertiary }
val textTertiary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textTertiaryDark else R.color.textTertiary }
.map { res -> getColor(res) }
.distinctUntilChanged()
@@ -145,28 +145,28 @@ class Colors @Inject constructor(private val context: Context, prefs: Preference
.map { res -> getColor(res) }
.distinctUntilChanged()
val bubble: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.bubbleDark else R.color.bubbleLight }
val bubble: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.bubbleDark else R.color.bubbleLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchThumbEnabled: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.switchThumbEnabledDark else R.color.switchThumbEnabledLight }
val switchThumbEnabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchThumbEnabledDark else R.color.switchThumbEnabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchThumbDisabled: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.switchThumbDisabledDark else R.color.switchThumbDisabledLight }
val switchThumbDisabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchThumbDisabledDark else R.color.switchThumbDisabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchTrackEnabled: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.switchTrackEnabledDark else R.color.switchTrackEnabledLight }
val switchTrackEnabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchTrackEnabledDark else R.color.switchTrackEnabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchTrackDisabled: Observable<Int> = prefs.dark.asObservable()
.map { dark -> if (dark) R.color.switchTrackDisabledDark else R.color.switchTrackDisabledLight }
val switchTrackDisabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchTrackDisabledDark else R.color.switchTrackDisabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
@@ -71,4 +71,18 @@ class DateFormatter @Inject constructor(val context: Context) {
}.format(date)
}
fun formatTime(hour: Int, minute: Int): String {
val calendar = Calendar.getInstance()
calendar.set(Calendar.HOUR_OF_DAY, hour)
calendar.set(Calendar.MINUTE, minute)
val simpleDateFormat = getFormatter("h:mm a")
return simpleDateFormat.format(calendar.time)
}
fun parseTime(time: String): Calendar {
val simpleDateFormat = if (time.contains(" ")) getFormatter("h:mm a") else SimpleDateFormat("H:mm", Locale.US)
return Calendar.getInstance().apply { this.time = simpleDateFormat.parse(time) }
}
}
@@ -0,0 +1,78 @@
/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package common.util
import android.app.AlarmManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import presentation.receiver.NightModeReceiver
import java.util.*
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class NightModeManager @Inject constructor(
private val context: Context,
private val dateFormatter: DateFormatter,
private val prefs: Preferences) {
fun updateNightMode(mode: Int) {
prefs.nightMode.set(mode)
// If it's not on auto mode, set the appropriate night mode
if (mode != Preferences.NIGHT_MODE_AUTO) {
prefs.night.set(mode == Preferences.NIGHT_MODE_ON)
}
updateAlarms()
}
fun updateAlarms() {
val dayCalendar = createCalendar(prefs.nightEnd.get())
val day = Intent(context, NightModeReceiver::class.java)
val dayIntent = PendingIntent.getBroadcast(context, 0, day, 0)
val nightCalendar = createCalendar(prefs.nightStart.get())
val night = Intent(context, NightModeReceiver::class.java)
val nightIntent = PendingIntent.getBroadcast(context, 1, night, 0)
context.sendBroadcast(day)
context.sendBroadcast(night)
val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
if (prefs.nightMode.get() == Preferences.NIGHT_MODE_AUTO) {
alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, dayCalendar.timeInMillis, AlarmManager.INTERVAL_DAY, dayIntent)
alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, nightCalendar.timeInMillis, AlarmManager.INTERVAL_DAY, nightIntent)
} else {
alarmManager.cancel(dayIntent)
alarmManager.cancel(nightIntent)
}
}
private fun createCalendar(time: String): Calendar {
val calendar = dateFormatter.parseTime(time)
return Calendar.getInstance().apply {
set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY))
set(Calendar.MINUTE, calendar.get(Calendar.MINUTE))
}
}
}
+10 -1
View File
@@ -26,9 +26,18 @@ import javax.inject.Singleton
@Singleton
class Preferences @Inject constructor(rxPrefs: RxSharedPreferences) {
companion object {
const val NIGHT_MODE_OFF = 0
const val NIGHT_MODE_ON = 1
const val NIGHT_MODE_AUTO = 2
}
val defaultSms = rxPrefs.getBoolean("defaultSms", false)
val theme = rxPrefs.getInteger("theme", 0xFF008389.toInt())
val dark = rxPrefs.getBoolean("dark", false)
val night = rxPrefs.getBoolean("night", false)
val nightMode = rxPrefs.getInteger("nightModeSummary", NIGHT_MODE_OFF)
val nightStart = rxPrefs.getString("nightStart", "6:00 PM")
val nightEnd = rxPrefs.getString("nightEnd", "6:00 AM")
val autoEmoji = rxPrefs.getBoolean("autoEmoji", true)
val notifications = rxPrefs.getBoolean("notifications", true)
val vibration = rxPrefs.getBoolean("vibration", true)