2020-01-09 10:44:32 +01:00
/ * Copyright ( C ) 2019 - 2020 Andreas Shimokawa , Cre3per
2019-11-23 21:52:46 +01:00
This file is part of Gadgetbridge .
Gadgetbridge is free software : you can redistribute it and / or modify
it under the terms of the GNU Affero General Public License as published
by the Free Software Foundation , either version 3 of the License , or
( at your option ) any later version .
Gadgetbridge 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 Affero General Public License for more details .
You should have received a copy of the GNU Affero General Public License
along with this program . If not , see < http : //www.gnu.org/licenses/>. */
2019-04-21 21:18:08 +02:00
package nodomain.freeyourgadget.gadgetbridge.activities.devicesettings ;
2021-11-18 12:22:43 +01:00
import android.content.Intent ;
2021-12-12 19:38:14 +01:00
import android.content.SharedPreferences ;
2019-04-21 21:18:08 +02:00
import android.os.Bundle ;
2019-06-05 14:11:44 +02:00
import android.text.InputType ;
import android.widget.EditText ;
2019-04-21 21:18:08 +02:00
2019-05-22 00:42:22 +02:00
import androidx.annotation.NonNull ;
import androidx.fragment.app.DialogFragment ;
2021-11-18 12:22:43 +01:00
import androidx.localbroadcastmanager.content.LocalBroadcastManager ;
2019-06-05 14:11:44 +02:00
import androidx.preference.EditTextPreference ;
2021-10-07 14:32:09 +02:00
import androidx.preference.ListPreference ;
2019-05-22 00:42:22 +02:00
import androidx.preference.Preference ;
2021-12-12 19:38:14 +01:00
import androidx.preference.PreferenceCategory ;
2019-04-21 21:18:08 +02:00
import androidx.preference.PreferenceFragmentCompat ;
2021-12-12 19:38:14 +01:00
import androidx.preference.PreferenceGroup ;
import androidx.preference.PreferenceScreen ;
import androidx.preference.SeekBarPreference ;
import androidx.preference.SwitchPreference ;
2019-04-21 21:18:08 +02:00
2020-11-06 11:26:50 +01:00
import com.mobeta.android.dslv.DragSortListPreference ;
import com.mobeta.android.dslv.DragSortListPreferenceFragment ;
2021-10-07 14:32:09 +02:00
import org.apache.commons.lang3.ArrayUtils ;
2019-06-05 16:00:18 +02:00
import org.slf4j.Logger ;
import org.slf4j.LoggerFactory ;
2020-10-13 00:25:43 +02:00
import java.util.ArrayList ;
2022-05-14 15:20:28 +02:00
import java.util.HashSet ;
2019-06-05 16:00:18 +02:00
import java.util.Objects ;
2022-05-14 15:20:28 +02:00
import java.util.Set ;
2019-06-05 16:00:18 +02:00
2019-05-22 00:42:22 +02:00
import nodomain.freeyourgadget.gadgetbridge.GBApplication ;
2021-10-07 14:32:09 +02:00
import nodomain.freeyourgadget.gadgetbridge.R ;
2022-06-16 23:28:17 +02:00
import nodomain.freeyourgadget.gadgetbridge.activities.CalBlacklistActivity ;
2022-05-09 20:47:08 +02:00
import nodomain.freeyourgadget.gadgetbridge.activities.ConfigureWorldClocks ;
2022-06-16 23:28:17 +02:00
import nodomain.freeyourgadget.gadgetbridge.activities.SettingsActivity ;
2022-07-05 20:29:16 +02:00
import nodomain.freeyourgadget.gadgetbridge.capabilities.password.PasswordCapabilityImpl ;
2022-05-09 20:47:08 +02:00
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceCoordinator ;
2021-11-18 12:22:43 +01:00
import nodomain.freeyourgadget.gadgetbridge.devices.DeviceManager ;
2019-11-14 12:33:36 +01:00
import nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst ;
2019-05-22 10:49:59 +02:00
import nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst ;
2022-05-09 20:47:08 +02:00
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice ;
2020-10-13 00:25:43 +02:00
import nodomain.freeyourgadget.gadgetbridge.model.CannedMessagesSpec ;
2022-06-19 16:03:37 +02:00
import nodomain.freeyourgadget.gadgetbridge.model.DeviceType ;
2022-05-09 20:47:08 +02:00
import nodomain.freeyourgadget.gadgetbridge.util.DeviceHelper ;
2019-05-22 00:42:22 +02:00
import nodomain.freeyourgadget.gadgetbridge.util.Prefs ;
import nodomain.freeyourgadget.gadgetbridge.util.XTimePreference ;
import nodomain.freeyourgadget.gadgetbridge.util.XTimePreferenceFragment ;
2019-04-21 21:18:08 +02:00
2022-01-09 12:56:29 +01:00
import static nodomain.freeyourgadget.gadgetbridge.activities.devicesettings.DeviceSettingsPreferenceConst.* ;
2020-10-13 00:25:43 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_FELL_SLEEP_BROADCAST ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_FELL_SLEEP_SELECTION ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_SELECTION_BROADCAST ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_SELECTION_OFF ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_START_NON_WEAR_BROADCAST ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_START_NON_WEAR_SELECTION ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_WOKE_UP_BROADCAST ;
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DEVICE_ACTION_WOKE_UP_SELECTION ;
2019-08-02 00:11:11 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DISPLAY_ITEMS ;
2020-11-06 21:47:54 +01:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_DISPLAY_ITEMS_SORTABLE ;
2019-08-27 11:13:45 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_EXPOSE_HR_THIRDPARTY ;
2020-05-13 10:15:12 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_SHORTCUTS ;
2020-11-06 21:47:54 +01:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_SHORTCUTS_SORTABLE ;
2022-05-09 15:05:08 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.huami.HuamiConst.PREF_WORKOUT_ACTIVITY_TYPES_SORTABLE ;
2019-05-23 21:33:35 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_MI2_DATEFORMAT ;
2019-06-05 16:00:18 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_MI2_ROTATE_WRIST_TO_SWITCH_INFO ;
2019-05-22 10:49:59 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_NIGHT_MODE ;
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_NIGHT_MODE_END ;
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_NIGHT_MODE_OFF ;
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_NIGHT_MODE_SCHEDULED ;
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_NIGHT_MODE_START ;
2019-05-22 00:42:22 +02:00
import static nodomain.freeyourgadget.gadgetbridge.devices.miband.MiBandConst.PREF_SWIPE_UNLOCK ;
2021-11-28 01:34:29 +01:00
public class DeviceSpecificSettingsFragment extends PreferenceFragmentCompat implements DeviceSpecificSettingsHandler {
2019-06-05 16:00:18 +02:00
private static final Logger LOG = LoggerFactory . getLogger ( DeviceSpecificSettingsFragment . class ) ;
2019-05-22 00:42:22 +02:00
static final String FRAGMENT_TAG = " DEVICE_SPECIFIC_SETTINGS_FRAGMENT " ;
2021-12-12 19:38:14 +01:00
private final SharedPreferencesChangeHandler sharedPreferencesChangeHandler = new SharedPreferencesChangeHandler ( ) ;
2022-01-14 23:01:42 +01:00
private DeviceSpecificSettingsCustomizer deviceSpecificSettingsCustomizer ;
2022-05-09 20:47:08 +02:00
private GBDevice device ;
2021-10-07 14:32:09 +02:00
private void setSettingsFileSuffix ( String settingsFileSuffix , @NonNull int [ ] supportedSettings , String [ ] supportedLanguages ) {
2019-04-21 21:18:08 +02:00
Bundle args = new Bundle ( ) ;
args . putString ( " settingsFileSuffix " , settingsFileSuffix ) ;
2019-05-22 00:42:22 +02:00
args . putIntArray ( " supportedSettings " , supportedSettings ) ;
2021-10-07 14:32:09 +02:00
args . putStringArray ( " supportedLanguages " , supportedLanguages ) ;
2019-04-21 21:18:08 +02:00
setArguments ( args ) ;
}
2022-01-14 23:01:42 +01:00
private void setDeviceSpecificSettingsCustomizer ( final DeviceSpecificSettingsCustomizer customizer ) {
final Bundle args = getArguments ( ) ! = null ? getArguments ( ) : new Bundle ( ) ;
args . putParcelable ( " deviceSpecificSettingsCustomizer " , customizer ) ;
setArguments ( args ) ;
}
2019-04-21 21:18:08 +02:00
2022-05-09 20:47:08 +02:00
private void setDevice ( final GBDevice device ) {
final Bundle args = getArguments ( ) ! = null ? getArguments ( ) : new Bundle ( ) ;
args . putParcelable ( " device " , device ) ;
setArguments ( args ) ;
}
2019-04-21 21:18:08 +02:00
@Override
public void onCreatePreferences ( Bundle savedInstanceState , String rootKey ) {
2019-05-22 00:42:22 +02:00
Bundle arguments = getArguments ( ) ;
if ( arguments = = null ) {
return ;
}
String settingsFileSuffix = arguments . getString ( " settingsFileSuffix " , null ) ;
int [ ] supportedSettings = arguments . getIntArray ( " supportedSettings " ) ;
2021-10-07 14:32:09 +02:00
String [ ] supportedLanguages = arguments . getStringArray ( " supportedLanguages " ) ;
2022-01-14 23:01:42 +01:00
this . deviceSpecificSettingsCustomizer = arguments . getParcelable ( " deviceSpecificSettingsCustomizer " ) ;
2022-05-09 20:47:08 +02:00
this . device = arguments . getParcelable ( " device " ) ;
2021-10-07 14:32:09 +02:00
2019-05-22 00:42:22 +02:00
if ( settingsFileSuffix = = null | | supportedSettings = = null ) {
return ;
}
2019-04-21 21:18:08 +02:00
getPreferenceManager ( ) . setSharedPreferencesName ( " devicesettings_ " + settingsFileSuffix ) ;
2019-05-22 00:42:22 +02:00
if ( rootKey = = null ) {
// we are the main preference screen
boolean first = true ;
for ( int setting : supportedSettings ) {
if ( first ) {
setPreferencesFromResource ( setting , null ) ;
first = false ;
} else {
addPreferencesFromResource ( setting ) ;
}
2021-10-07 14:32:09 +02:00
if ( setting = = R . xml . devicesettings_language_generic ) {
ListPreference languageListPreference = findPreference ( " language " ) ;
CharSequence [ ] entries = languageListPreference . getEntries ( ) ;
CharSequence [ ] values = languageListPreference . getEntryValues ( ) ;
for ( int i = entries . length - 1 ; i > = 0 ; i - - ) {
if ( ! ArrayUtils . contains ( supportedLanguages , values [ i ] ) ) {
entries = ArrayUtils . remove ( entries , i ) ;
values = ArrayUtils . remove ( values , i ) ;
}
}
languageListPreference . setEntries ( entries ) ;
languageListPreference . setEntryValues ( values ) ;
}
2019-05-22 00:42:22 +02:00
}
} else {
// Now, this is ugly: search all the xml files for the rootKey
for ( int setting : supportedSettings ) {
try {
setPreferencesFromResource ( setting , rootKey ) ;
} catch ( Exception ignore ) {
continue ;
}
break ;
}
}
setChangeListener ( ) ;
2019-04-21 21:18:08 +02:00
}
2021-12-12 19:38:14 +01:00
@Override
public void onStart ( ) {
super . onStart ( ) ;
final SharedPreferences sharedPreferences = getPreferenceManager ( ) . getSharedPreferences ( ) ;
reloadPreferences ( sharedPreferences , getPreferenceScreen ( ) ) ;
sharedPreferences . registerOnSharedPreferenceChangeListener ( sharedPreferencesChangeHandler ) ;
}
@Override
public void onStop ( ) {
getPreferenceManager ( ) . getSharedPreferences ( ) . unregisterOnSharedPreferenceChangeListener ( sharedPreferencesChangeHandler ) ;
super . onStop ( ) ;
}
2019-05-22 00:42:22 +02:00
/ *
* delayed execution so that the preferences are applied first
* /
private void invokeLater ( Runnable runnable ) {
getListView ( ) . post ( runnable ) ;
}
2022-01-15 00:50:00 +01:00
/ *
* delayed execution so that the preferences are applied first
* /
@Override
public void notifyPreferenceChanged ( final String preferenceKey ) {
invokeLater ( new Runnable ( ) {
@Override
public void run ( ) {
GBApplication . deviceService ( ) . onSendConfiguration ( preferenceKey ) ;
}
} ) ;
}
2019-05-22 00:42:22 +02:00
private void setChangeListener ( ) {
2022-07-05 20:29:16 +02:00
final DeviceCoordinator coordinator = DeviceHelper . getInstance ( ) . getCoordinator ( device ) ;
2020-10-13 00:25:43 +02:00
final Prefs prefs = new Prefs ( getPreferenceManager ( ) . getSharedPreferences ( ) ) ;
2019-05-24 23:46:20 +02:00
String disconnectNotificationState = prefs . getString ( PREF_DISCONNECT_NOTIFICATION , PREF_DO_NOT_DISTURB_OFF ) ;
boolean disconnectNotificationScheduled = disconnectNotificationState . equals ( PREF_DO_NOT_DISTURB_SCHEDULED ) ;
2019-05-22 00:42:22 +02:00
final Preference disconnectNotificationStart = findPreference ( PREF_DISCONNECT_NOTIFICATION_START ) ;
if ( disconnectNotificationStart ! = null ) {
disconnectNotificationStart . setEnabled ( disconnectNotificationScheduled ) ;
disconnectNotificationStart . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DISCONNECT_NOTIFICATION_START ) ;
2019-05-22 00:42:22 +02:00
return true ;
}
} ) ;
}
final Preference disconnectNotificationEnd = findPreference ( PREF_DISCONNECT_NOTIFICATION_END ) ;
if ( disconnectNotificationEnd ! = null ) {
disconnectNotificationEnd . setEnabled ( disconnectNotificationScheduled ) ;
disconnectNotificationEnd . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DISCONNECT_NOTIFICATION_END ) ;
2019-05-22 00:42:22 +02:00
return true ;
}
} ) ;
}
final Preference disconnectNotification = findPreference ( PREF_DISCONNECT_NOTIFICATION ) ;
if ( disconnectNotification ! = null ) {
disconnectNotification . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2019-05-24 23:46:20 +02:00
final boolean scheduled = PREF_DO_NOT_DISTURB_SCHEDULED . equals ( newVal . toString ( ) ) ;
2019-05-22 00:42:22 +02:00
2019-06-05 16:00:18 +02:00
Objects . requireNonNull ( disconnectNotificationStart ) . setEnabled ( scheduled ) ;
Objects . requireNonNull ( disconnectNotificationEnd ) . setEnabled ( scheduled ) ;
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DISCONNECT_NOTIFICATION ) ;
2019-05-22 00:42:22 +02:00
return true ;
}
} ) ;
}
2019-05-22 10:49:59 +02:00
String nightModeState = prefs . getString ( MiBandConst . PREF_NIGHT_MODE , PREF_NIGHT_MODE_OFF ) ;
boolean nightModeScheduled = nightModeState . equals ( PREF_NIGHT_MODE_SCHEDULED ) ;
final Preference nightModeStart = findPreference ( PREF_NIGHT_MODE_START ) ;
if ( nightModeStart ! = null ) {
nightModeStart . setEnabled ( nightModeScheduled ) ;
nightModeStart . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_NIGHT_MODE_START ) ;
2019-05-22 10:49:59 +02:00
return true ;
}
} ) ;
}
final Preference nightModeEnd = findPreference ( PREF_NIGHT_MODE_END ) ;
if ( nightModeEnd ! = null ) {
nightModeEnd . setEnabled ( nightModeScheduled ) ;
nightModeEnd . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_NIGHT_MODE_END ) ;
2019-05-22 10:49:59 +02:00
return true ;
}
} ) ;
}
final Preference nightMode = findPreference ( PREF_NIGHT_MODE ) ;
if ( nightMode ! = null ) {
nightMode . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean scheduled = PREF_NIGHT_MODE_SCHEDULED . equals ( newVal . toString ( ) ) ;
2019-06-05 16:00:18 +02:00
Objects . requireNonNull ( nightModeStart ) . setEnabled ( scheduled ) ;
Objects . requireNonNull ( nightModeEnd ) . setEnabled ( scheduled ) ;
2019-05-22 10:49:59 +02:00
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_NIGHT_MODE ) ;
2019-05-22 10:49:59 +02:00
return true ;
}
} ) ;
}
2019-05-24 23:46:20 +02:00
2022-03-06 23:48:47 +01:00
String doNotDisturbState = prefs . getString ( PREF_DO_NOT_DISTURB , PREF_DO_NOT_DISTURB_OFF ) ;
2019-05-24 23:46:20 +02:00
boolean doNotDisturbScheduled = doNotDisturbState . equals ( PREF_DO_NOT_DISTURB_SCHEDULED ) ;
final Preference doNotDisturbStart = findPreference ( PREF_DO_NOT_DISTURB_START ) ;
if ( doNotDisturbStart ! = null ) {
doNotDisturbStart . setEnabled ( doNotDisturbScheduled ) ;
doNotDisturbStart . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DO_NOT_DISTURB_START ) ;
2019-05-24 23:46:20 +02:00
return true ;
}
} ) ;
}
final Preference doNotDisturbEnd = findPreference ( PREF_DO_NOT_DISTURB_END ) ;
if ( doNotDisturbEnd ! = null ) {
doNotDisturbEnd . setEnabled ( doNotDisturbScheduled ) ;
doNotDisturbEnd . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DO_NOT_DISTURB_END ) ;
2019-05-24 23:46:20 +02:00
return true ;
}
} ) ;
}
final Preference doNotDisturb = findPreference ( PREF_DO_NOT_DISTURB ) ;
if ( doNotDisturb ! = null ) {
doNotDisturb . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean scheduled = PREF_DO_NOT_DISTURB_SCHEDULED . equals ( newVal . toString ( ) ) ;
2019-06-05 16:00:18 +02:00
Objects . requireNonNull ( doNotDisturbStart ) . setEnabled ( scheduled ) ;
Objects . requireNonNull ( doNotDisturbEnd ) . setEnabled ( scheduled ) ;
2019-05-24 23:46:20 +02:00
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DO_NOT_DISTURB ) ;
2019-05-24 23:46:20 +02:00
return true ;
}
} ) ;
}
2022-05-15 23:15:10 +02:00
final Preference enableHeartrateSleepSupport = findPreference ( PREF_HEARTRATE_USE_FOR_SLEEP_DETECTION ) ;
if ( enableHeartrateSleepSupport ! = null ) {
enableHeartrateSleepSupport . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
GBApplication . deviceService ( ) . onEnableHeartRateSleepSupport ( Boolean . TRUE . equals ( newVal ) ) ;
return true ;
}
} ) ;
}
2022-05-16 18:42:02 +02:00
final ListPreference heartrateMeasurementInterval = findPreference ( PREF_HEARTRATE_MEASUREMENT_INTERVAL ) ;
2022-05-15 23:15:10 +02:00
if ( heartrateMeasurementInterval ! = null ) {
2022-05-16 18:42:02 +02:00
final SwitchPreference activityMonitoring = findPreference ( PREF_HEARTRATE_ACTIVITY_MONITORING ) ;
final SwitchPreference heartrateAlertEnabled = findPreference ( PREF_HEARTRATE_ALERT_ENABLED ) ;
final SwitchPreference stressMonitoring = findPreference ( PREF_HEARTRATE_STRESS_MONITORING ) ;
2022-05-15 23:15:10 +02:00
heartrateMeasurementInterval . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
2022-05-16 18:42:02 +02:00
public boolean onPreferenceChange ( final Preference preference , final Object newVal ) {
2022-05-15 23:15:10 +02:00
GBApplication . deviceService ( ) . onSetHeartRateMeasurementInterval ( Integer . parseInt ( ( String ) newVal ) ) ;
2022-05-16 18:42:02 +02:00
final boolean isMeasurementIntervalEnabled = ! newVal . equals ( " 0 " ) ;
if ( activityMonitoring ! = null ) {
activityMonitoring . setEnabled ( isMeasurementIntervalEnabled ) ;
}
if ( heartrateAlertEnabled ! = null ) {
heartrateAlertEnabled . setEnabled ( isMeasurementIntervalEnabled ) ;
}
if ( stressMonitoring ! = null ) {
stressMonitoring . setEnabled ( isMeasurementIntervalEnabled ) ;
}
2022-05-15 23:15:10 +02:00
return true ;
}
} ) ;
2022-05-16 18:42:02 +02:00
final boolean isMeasurementIntervalEnabled = ! heartrateMeasurementInterval . getValue ( ) . equals ( " 0 " ) ;
if ( activityMonitoring ! = null ) {
activityMonitoring . setEnabled ( isMeasurementIntervalEnabled ) ;
}
if ( heartrateAlertEnabled ! = null ) {
heartrateAlertEnabled . setEnabled ( isMeasurementIntervalEnabled ) ;
}
if ( stressMonitoring ! = null ) {
stressMonitoring . setEnabled ( isMeasurementIntervalEnabled ) ;
}
2022-05-15 23:15:10 +02:00
}
2019-06-05 12:16:10 +02:00
addPreferenceHandlerFor ( PREF_SWIPE_UNLOCK ) ;
addPreferenceHandlerFor ( PREF_MI2_DATEFORMAT ) ;
2019-08-02 00:11:11 +02:00
addPreferenceHandlerFor ( PREF_DATEFORMAT ) ;
addPreferenceHandlerFor ( PREF_DISPLAY_ITEMS ) ;
2020-11-06 21:47:54 +01:00
addPreferenceHandlerFor ( PREF_DISPLAY_ITEMS_SORTABLE ) ;
2022-05-09 15:05:08 +02:00
addPreferenceHandlerFor ( PREF_WORKOUT_ACTIVITY_TYPES_SORTABLE ) ;
2020-05-13 10:15:12 +02:00
addPreferenceHandlerFor ( PREF_SHORTCUTS ) ;
2020-11-06 21:47:54 +01:00
addPreferenceHandlerFor ( PREF_SHORTCUTS_SORTABLE ) ;
2019-08-02 00:11:11 +02:00
addPreferenceHandlerFor ( PREF_LANGUAGE ) ;
2019-08-27 11:13:45 +02:00
addPreferenceHandlerFor ( PREF_EXPOSE_HR_THIRDPARTY ) ;
2020-12-06 00:09:19 +01:00
addPreferenceHandlerFor ( PREF_BT_CONNECTED_ADVERTISEMENT ) ;
2019-10-05 22:35:30 +02:00
addPreferenceHandlerFor ( PREF_WEARLOCATION ) ;
2021-09-21 16:37:19 +02:00
addPreferenceHandlerFor ( PREF_VIBRATION_ENABLE ) ;
addPreferenceHandlerFor ( PREF_NOTIFICATION_ENABLE ) ;
2019-10-05 22:35:30 +02:00
addPreferenceHandlerFor ( PREF_SCREEN_ORIENTATION ) ;
addPreferenceHandlerFor ( PREF_TIMEFORMAT ) ;
2020-10-13 03:06:05 +02:00
addPreferenceHandlerFor ( PREF_BUTTON_1_FUNCTION_SHORT ) ;
addPreferenceHandlerFor ( PREF_BUTTON_2_FUNCTION_SHORT ) ;
addPreferenceHandlerFor ( PREF_BUTTON_3_FUNCTION_SHORT ) ;
addPreferenceHandlerFor ( PREF_BUTTON_1_FUNCTION_LONG ) ;
addPreferenceHandlerFor ( PREF_BUTTON_2_FUNCTION_LONG ) ;
addPreferenceHandlerFor ( PREF_BUTTON_3_FUNCTION_LONG ) ;
addPreferenceHandlerFor ( PREF_BUTTON_1_FUNCTION_DOUBLE ) ;
addPreferenceHandlerFor ( PREF_BUTTON_2_FUNCTION_DOUBLE ) ;
addPreferenceHandlerFor ( PREF_BUTTON_3_FUNCTION_DOUBLE ) ;
2020-03-20 17:14:00 +01:00
addPreferenceHandlerFor ( PREF_VIBRATION_STRENGH_PERCENTAGE ) ;
2020-04-22 22:36:09 +02:00
addPreferenceHandlerFor ( PREF_POWER_MODE ) ;
addPreferenceHandlerFor ( PREF_LIFTWRIST_NOSHED ) ;
addPreferenceHandlerFor ( PREF_DISCONNECTNOTIF_NOSHED ) ;
addPreferenceHandlerFor ( PREF_BUTTON_BP_CALIBRATE ) ;
addPreferenceHandlerFor ( PREF_ALTITUDE_CALIBRATE ) ;
2022-03-07 14:33:10 +01:00
addPreferenceHandlerFor ( PREF_INACTIVITY_ENABLE ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_START ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_END ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_THRESHOLD ) ;
2022-05-29 21:18:53 +02:00
addPreferenceHandlerFor ( PREF_INACTIVITY_THRESHOLD_EXTENDED ) ;
2022-03-07 14:33:10 +01:00
addPreferenceHandlerFor ( PREF_INACTIVITY_MO ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_TU ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_WE ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_TH ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_FR ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_SA ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_SU ) ;
2022-03-07 15:51:54 +01:00
addPreferenceHandlerFor ( PREF_INACTIVITY_DND ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_DND_START ) ;
addPreferenceHandlerFor ( PREF_INACTIVITY_DND_END ) ;
2021-09-21 16:37:19 +02:00
addPreferenceHandlerFor ( PREF_AUTOHEARTRATE_SWITCH ) ;
addPreferenceHandlerFor ( PREF_AUTOHEARTRATE_SLEEP ) ;
addPreferenceHandlerFor ( PREF_AUTOHEARTRATE_INTERVAL ) ;
addPreferenceHandlerFor ( PREF_AUTOHEARTRATE_START ) ;
addPreferenceHandlerFor ( PREF_AUTOHEARTRATE_END ) ;
2022-05-16 18:42:02 +02:00
addPreferenceHandlerFor ( PREF_HEARTRATE_ACTIVITY_MONITORING ) ;
addPreferenceHandlerFor ( PREF_HEARTRATE_ALERT_THRESHOLD ) ;
addPreferenceHandlerFor ( PREF_HEARTRATE_ALERT_ENABLED ) ;
addPreferenceHandlerFor ( PREF_HEARTRATE_STRESS_MONITORING ) ;
2020-04-22 22:36:09 +02:00
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_NOAUTO ) ;
2021-09-21 16:37:19 +02:00
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_NOAUTO_START ) ;
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_NOAUTO_END ) ;
2022-03-06 23:48:47 +01:00
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB ) ;
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_START ) ;
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_END ) ;
2021-12-12 00:15:33 +01:00
addPreferenceHandlerFor ( PREF_DO_NOT_DISTURB_LIFT_WRIST ) ;
2022-03-07 17:42:46 +01:00
addPreferenceHandlerFor ( PREF_FIND_PHONE ) ;
addPreferenceHandlerFor ( PREF_FIND_PHONE_DURATION ) ;
2020-12-20 00:22:35 +01:00
addPreferenceHandlerFor ( PREF_AUTOLIGHT ) ;
addPreferenceHandlerFor ( PREF_AUTOREMOVE_MESSAGE ) ;
2021-03-08 14:29:08 +01:00
addPreferenceHandlerFor ( PREF_AUTOREMOVE_NOTIFICATIONS ) ;
2020-12-20 00:22:35 +01:00
addPreferenceHandlerFor ( PREF_KEY_VIBRATION ) ;
addPreferenceHandlerFor ( PREF_OPERATING_SOUNDS ) ;
addPreferenceHandlerFor ( PREF_FAKE_RING_DURATION ) ;
2020-10-05 22:20:20 +02:00
addPreferenceHandlerFor ( PREF_ANTILOST_ENABLED ) ;
addPreferenceHandlerFor ( PREF_HYDRATION_SWITCH ) ;
addPreferenceHandlerFor ( PREF_HYDRATION_PERIOD ) ;
addPreferenceHandlerFor ( PREF_AMPM_ENABLED ) ;
2021-03-24 20:02:48 +01:00
addPreferenceHandlerFor ( PREF_SOUNDS ) ;
2019-06-05 14:11:44 +02:00
2020-04-12 03:57:13 +02:00
addPreferenceHandlerFor ( PREF_HYBRID_HR_DRAW_WIDGET_CIRCLES ) ;
addPreferenceHandlerFor ( PREF_HYBRID_HR_FORCE_WHITE_COLOR ) ;
2020-04-22 01:27:06 +02:00
addPreferenceHandlerFor ( PREF_HYBRID_HR_SAVE_RAW_ACTIVITY_FILES ) ;
2021-05-31 10:16:33 +02:00
addPreferenceHandlerFor ( PREF_HYBRID_HR_DANGEROUS_EXTERNAL_INTENTS ) ;
2022-01-06 13:31:00 +01:00
addPreferenceHandlerFor ( PREF_HYBRID_HR_ACTIVITY_RECOGNITION_RUNNING ) ;
addPreferenceHandlerFor ( PREF_HYBRID_HR_ACTIVITY_RECOGNITION_BIKING ) ;
addPreferenceHandlerFor ( PREF_HYBRID_HR_ACTIVITY_RECOGNITION_WALKING ) ;
addPreferenceHandlerFor ( PREF_HYBRID_HR_ACTIVITY_RECOGNITION_ROWING ) ;
2020-04-12 03:57:13 +02:00
2020-10-02 21:58:48 +02:00
addPreferenceHandlerFor ( PREF_SONYSWR12_STAMINA ) ;
addPreferenceHandlerFor ( PREF_SONYSWR12_LOW_VIBRATION ) ;
addPreferenceHandlerFor ( PREF_SONYSWR12_SMART_INTERVAL ) ;
2020-04-22 22:36:09 +02:00
2021-09-30 22:40:18 +02:00
addPreferenceHandlerFor ( PREF_NOTHING_EAR1_INEAR ) ;
addPreferenceHandlerFor ( PREF_NOTHING_EAR1_AUDIOMODE ) ;
2021-10-24 10:02:45 +02:00
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_AMBIENT_VOICE_FOCUS ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_AMBIENT_VOLUME ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_LOCK_TOUCH ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_GAME_MODE ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_EQUALIZER ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_EQUALIZER_DOLBY ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_EQUALIZER_MODE ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_TOUCH_LEFT ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_TOUCH_RIGHT ) ;
2021-11-03 22:06:35 +01:00
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_LIVE_ANC ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRESSURE_RELIEF ) ;
2022-05-17 22:18:49 +02:00
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_ANC_LEVEL ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_AMBIENT_SOUND ) ;
addPreferenceHandlerFor ( PREF_GALAXY_PRO_DOUBLE_TAP_EDGE ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_IN_EAR_DETECTION ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_VOICE_DETECT ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_VOICE_DETECT_DURATION ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_BALANCE ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_READ_NOTIFICATIONS_OUTLOUD ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_AMBIENT_MODE_DURING_CALL ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_AMBIENT_VOLUME_RIGHT ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_AMBIENT_VOLUME_LEFT ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_PRO_AMBIENT_SOUND_TONE ) ;
addPreferenceHandlerFor ( PREFS_NOISE_CONTROL_WITH_ONE_EARBUD ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_AMBIENT_MODE ) ;
addPreferenceHandlerFor ( PREFS_GALAXY_BUDS_SEAMLESS_CONNECTION ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_TOUCH_LEFT_SWITCH ) ;
addPreferenceHandlerFor ( PREF_GALAXY_BUDS_TOUCH_RIGHT_SWITCH ) ;
2021-10-24 10:02:45 +02:00
2021-11-18 22:33:07 +01:00
addPreferenceHandlerFor ( PREF_SONY_AMBIENT_SOUND_CONTROL ) ;
addPreferenceHandlerFor ( PREF_SONY_FOCUS_VOICE ) ;
addPreferenceHandlerFor ( PREF_SONY_AMBIENT_SOUND_LEVEL ) ;
addPreferenceHandlerFor ( PREF_SONY_SOUND_POSITION ) ;
addPreferenceHandlerFor ( PREF_SONY_SURROUND_MODE ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_MODE ) ;
2021-12-12 19:48:14 +01:00
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BAND_400 ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BAND_1000 ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BAND_2500 ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BAND_6300 ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BAND_16000 ) ;
addPreferenceHandlerFor ( PREF_SONY_EQUALIZER_BASS ) ;
addPreferenceHandlerFor ( PREF_SONY_AUDIO_UPSAMPLING ) ;
2021-11-18 22:33:07 +01:00
addPreferenceHandlerFor ( PREF_SONY_TOUCH_SENSOR ) ;
2021-12-24 15:20:57 +01:00
addPreferenceHandlerFor ( PREF_SONY_PAUSE_WHEN_TAKEN_OFF ) ;
addPreferenceHandlerFor ( PREF_SONY_BUTTON_MODE_LEFT ) ;
addPreferenceHandlerFor ( PREF_SONY_BUTTON_MODE_RIGHT ) ;
2021-11-18 22:33:07 +01:00
addPreferenceHandlerFor ( PREF_SONY_AUTOMATIC_POWER_OFF ) ;
addPreferenceHandlerFor ( PREF_SONY_NOTIFICATION_VOICE_GUIDE ) ;
2022-01-09 12:56:29 +01:00
addPreferenceHandlerFor ( PREF_SONY_SPEAK_TO_CHAT ) ;
addPreferenceHandlerFor ( PREF_SONY_SPEAK_TO_CHAT_SENSITIVITY ) ;
addPreferenceHandlerFor ( PREF_SONY_SPEAK_TO_CHAT_FOCUS_ON_VOICE ) ;
addPreferenceHandlerFor ( PREF_SONY_SPEAK_TO_CHAT_TIMEOUT ) ;
addPreferenceHandlerFor ( PREF_SONY_CONNECT_TWO_DEVICES ) ;
2021-10-31 16:01:50 +01:00
2021-12-27 15:37:04 +01:00
addPreferenceHandlerFor ( PREF_QC35_NOISE_CANCELLING_LEVEL ) ;
2022-03-06 17:46:12 +01:00
addPreferenceHandlerFor ( PREF_USER_FITNESS_GOAL ) ;
2022-05-14 22:08:32 +02:00
addPreferenceHandlerFor ( PREF_USER_FITNESS_GOAL_NOTIFICATION ) ;
2021-12-27 15:37:04 +01:00
2022-04-15 02:08:51 +02:00
addPreferenceHandlerFor ( PREF_UM25_SHOW_THRESHOLD_NOTIFICATION ) ;
addPreferenceHandlerFor ( PREF_UM25_SHOW_THRESHOLD ) ;
2021-09-21 16:37:19 +02:00
String sleepTimeState = prefs . getString ( PREF_SLEEP_TIME , PREF_DO_NOT_DISTURB_OFF ) ;
boolean sleepTimeScheduled = sleepTimeState . equals ( PREF_DO_NOT_DISTURB_SCHEDULED ) ;
final Preference sleepTimeInfo = findPreference ( PREF_SLEEP_TIME ) ;
if ( sleepTimeInfo ! = null ) {
//sleepTimeInfo.setEnabled(!PREF_DO_NOT_DISTURB_OFF.equals(sleepTimeInfo));
sleepTimeInfo . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_SLEEP_TIME ) ;
2021-09-21 16:37:19 +02:00
return true ;
}
} ) ;
}
final Preference sleepTimeStart = findPreference ( PREF_SLEEP_TIME_START ) ;
if ( sleepTimeStart ! = null ) {
sleepTimeStart . setEnabled ( sleepTimeScheduled ) ;
sleepTimeStart . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_SLEEP_TIME_START ) ;
2021-09-21 16:37:19 +02:00
return true ;
}
} ) ;
}
final Preference sleepTimeEnd = findPreference ( PREF_SLEEP_TIME_END ) ;
if ( sleepTimeEnd ! = null ) {
sleepTimeEnd . setEnabled ( sleepTimeScheduled ) ;
sleepTimeEnd . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_SLEEP_TIME_END ) ;
2021-09-21 16:37:19 +02:00
return true ;
}
} ) ;
}
final Preference sleepTime = findPreference ( PREF_SLEEP_TIME ) ;
if ( sleepTime ! = null ) {
sleepTime . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean scheduled = PREF_DO_NOT_DISTURB_SCHEDULED . equals ( newVal . toString ( ) ) ;
Objects . requireNonNull ( sleepTimeStart ) . setEnabled ( scheduled ) ;
Objects . requireNonNull ( sleepTimeEnd ) . setEnabled ( scheduled ) ;
if ( sleepTimeInfo ! = null ) {
//sleepTimeInfo.setEnabled(!PREF_DO_NOT_DISTURB_OFF.equals(newVal.toString()));
}
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_SLEEP_TIME ) ;
2021-09-21 16:37:19 +02:00
return true ;
}
} ) ;
}
2019-06-05 16:00:18 +02:00
String displayOnLiftState = prefs . getString ( PREF_ACTIVATE_DISPLAY_ON_LIFT , PREF_DO_NOT_DISTURB_OFF ) ;
boolean displayOnLiftScheduled = displayOnLiftState . equals ( PREF_DO_NOT_DISTURB_SCHEDULED ) ;
2022-05-09 14:57:44 +02:00
boolean displayOnLiftOff = displayOnLiftState . equals ( PREF_DO_NOT_DISTURB_OFF ) ;
2019-06-05 16:00:18 +02:00
final Preference rotateWristCycleInfo = findPreference ( PREF_MI2_ROTATE_WRIST_TO_SWITCH_INFO ) ;
if ( rotateWristCycleInfo ! = null ) {
rotateWristCycleInfo . setEnabled ( ! PREF_DO_NOT_DISTURB_OFF . equals ( displayOnLiftState ) ) ;
rotateWristCycleInfo . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_MI2_ROTATE_WRIST_TO_SWITCH_INFO ) ;
2019-06-05 16:00:18 +02:00
return true ;
}
} ) ;
}
final Preference displayOnLiftStart = findPreference ( PREF_DISPLAY_ON_LIFT_START ) ;
if ( displayOnLiftStart ! = null ) {
displayOnLiftStart . setEnabled ( displayOnLiftScheduled ) ;
displayOnLiftStart . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DISPLAY_ON_LIFT_START ) ;
2019-06-05 16:00:18 +02:00
return true ;
}
} ) ;
}
final Preference displayOnLiftEnd = findPreference ( PREF_DISPLAY_ON_LIFT_END ) ;
if ( displayOnLiftEnd ! = null ) {
displayOnLiftEnd . setEnabled ( displayOnLiftScheduled ) ;
displayOnLiftEnd . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_DISPLAY_ON_LIFT_END ) ;
2019-06-05 16:00:18 +02:00
return true ;
}
} ) ;
}
2022-05-09 14:57:44 +02:00
final Preference displayOnLiftSensitivity = findPreference ( PREF_DISPLAY_ON_LIFT_SENSITIVITY ) ;
if ( displayOnLiftSensitivity ! = null ) {
displayOnLiftSensitivity . setEnabled ( ! displayOnLiftOff ) ;
displayOnLiftSensitivity . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
notifyPreferenceChanged ( PREF_DISPLAY_ON_LIFT_SENSITIVITY ) ;
return true ;
}
} ) ;
}
2019-06-05 16:00:18 +02:00
final Preference displayOnLift = findPreference ( PREF_ACTIVATE_DISPLAY_ON_LIFT ) ;
if ( displayOnLift ! = null ) {
displayOnLift . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean scheduled = PREF_DO_NOT_DISTURB_SCHEDULED . equals ( newVal . toString ( ) ) ;
2022-05-09 14:57:44 +02:00
final boolean off = PREF_DO_NOT_DISTURB_OFF . equals ( newVal . toString ( ) ) ;
2019-06-05 16:00:18 +02:00
Objects . requireNonNull ( displayOnLiftStart ) . setEnabled ( scheduled ) ;
Objects . requireNonNull ( displayOnLiftEnd ) . setEnabled ( scheduled ) ;
if ( rotateWristCycleInfo ! = null ) {
2022-05-09 14:57:44 +02:00
rotateWristCycleInfo . setEnabled ( ! off ) ;
}
if ( displayOnLiftSensitivity ! = null ) {
displayOnLiftSensitivity . setEnabled ( ! off ) ;
2019-06-05 16:00:18 +02:00
}
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( PREF_ACTIVATE_DISPLAY_ON_LIFT ) ;
2019-06-05 16:00:18 +02:00
return true ;
}
} ) ;
}
2022-05-09 20:47:08 +02:00
final Preference worldClocks = findPreference ( PREF_WORLD_CLOCKS ) ;
if ( worldClocks ! = null ) {
worldClocks . setOnPreferenceClickListener ( new Preference . OnPreferenceClickListener ( ) {
@Override
public boolean onPreferenceClick ( Preference preference ) {
final Intent intent = new Intent ( getContext ( ) , ConfigureWorldClocks . class ) ;
intent . putExtra ( GBDevice . EXTRA_DEVICE , device ) ;
startActivity ( intent ) ;
return true ;
}
} ) ;
}
2022-06-16 23:28:17 +02:00
final Preference calendarBlacklist = findPreference ( " blacklist_calendars " ) ;
if ( calendarBlacklist ! = null ) {
calendarBlacklist . setOnPreferenceClickListener ( new Preference . OnPreferenceClickListener ( ) {
public boolean onPreferenceClick ( Preference preference ) {
Intent intent = new Intent ( getContext ( ) , CalBlacklistActivity . class ) ;
intent . putExtra ( GBDevice . EXTRA_DEVICE , device ) ;
startActivity ( intent ) ;
return true ;
}
} ) ;
}
2020-10-13 00:25:43 +02:00
final Preference cannedMessagesDismissCall = findPreference ( " canned_messages_dismisscall_send " ) ;
if ( cannedMessagesDismissCall ! = null ) {
cannedMessagesDismissCall . setOnPreferenceClickListener ( new androidx . preference . Preference . OnPreferenceClickListener ( ) {
public boolean onPreferenceClick ( androidx . preference . Preference preference ) {
ArrayList < String > messages = new ArrayList < > ( ) ;
for ( int i = 1 ; i < = 16 ; i + + ) {
String message = prefs . getString ( " canned_message_dismisscall_ " + i , null ) ;
if ( message ! = null & & ! message . equals ( " " ) ) {
messages . add ( message ) ;
}
}
CannedMessagesSpec cannedMessagesSpec = new CannedMessagesSpec ( ) ;
cannedMessagesSpec . type = CannedMessagesSpec . TYPE_REJECTEDCALLS ;
cannedMessagesSpec . cannedMessages = messages . toArray ( new String [ 0 ] ) ;
GBApplication . deviceService ( ) . onSetCannedMessages ( cannedMessagesSpec ) ;
return true ;
}
} ) ;
}
2019-11-14 12:33:36 +01:00
setInputTypeFor ( HuamiConst . PREF_BUTTON_ACTION_BROADCAST_DELAY , InputType . TYPE_CLASS_NUMBER ) ;
setInputTypeFor ( HuamiConst . PREF_BUTTON_ACTION_PRESS_MAX_INTERVAL , InputType . TYPE_CLASS_NUMBER ) ;
setInputTypeFor ( HuamiConst . PREF_BUTTON_ACTION_PRESS_COUNT , InputType . TYPE_CLASS_NUMBER ) ;
setInputTypeFor ( MiBandConst . PREF_MIBAND_DEVICE_TIME_OFFSET_HOURS , InputType . TYPE_CLASS_NUMBER | InputType . TYPE_NUMBER_FLAG_SIGNED ) ;
2022-03-07 17:42:46 +01:00
setInputTypeFor ( DeviceSettingsPreferenceConst . PREF_FIND_PHONE_DURATION , InputType . TYPE_CLASS_NUMBER ) ;
2019-12-14 23:43:54 +01:00
setInputTypeFor ( DeviceSettingsPreferenceConst . PREF_RESERVER_ALARMS_CALENDAR , InputType . TYPE_CLASS_NUMBER ) ;
2021-12-04 16:55:09 +01:00
setInputTypeFor ( DeviceSettingsPreferenceConst . PREF_RESERVER_REMINDERS_CALENDAR , InputType . TYPE_CLASS_NUMBER ) ;
2022-05-14 22:08:32 +02:00
setInputTypeFor ( DeviceSettingsPreferenceConst . PREF_INACTIVITY_THRESHOLD , InputType . TYPE_CLASS_NUMBER ) ;
2020-08-16 22:07:55 +02:00
2022-07-05 20:29:16 +02:00
new PasswordCapabilityImpl ( ) . registerPreferences ( getContext ( ) , coordinator . getPasswordCapability ( ) , this ) ;
2020-08-16 22:07:55 +02:00
String deviceActionsFellSleepSelection = prefs . getString ( PREF_DEVICE_ACTION_FELL_SLEEP_SELECTION , PREF_DEVICE_ACTION_SELECTION_OFF ) ;
final Preference deviceActionsFellSleep = findPreference ( PREF_DEVICE_ACTION_FELL_SLEEP_SELECTION ) ;
final Preference deviceActionsFellSleepBroadcast = findPreference ( PREF_DEVICE_ACTION_FELL_SLEEP_BROADCAST ) ;
boolean deviceActionsFellSleepSelectionBroadcast = deviceActionsFellSleepSelection . equals ( PREF_DEVICE_ACTION_SELECTION_BROADCAST ) ;
if ( deviceActionsFellSleep ! = null ) {
deviceActionsFellSleep . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean broadcast = PREF_DEVICE_ACTION_SELECTION_BROADCAST . equals ( newVal . toString ( ) ) ;
Objects . requireNonNull ( deviceActionsFellSleepBroadcast ) . setEnabled ( broadcast ) ;
return true ;
}
} ) ;
}
if ( deviceActionsFellSleepBroadcast ! = null ) {
deviceActionsFellSleepBroadcast . setEnabled ( deviceActionsFellSleepSelectionBroadcast ) ;
}
2022-07-05 20:29:16 +02:00
2020-08-16 22:07:55 +02:00
String deviceActionsWokeUpSelection = prefs . getString ( PREF_DEVICE_ACTION_WOKE_UP_SELECTION , PREF_DEVICE_ACTION_SELECTION_OFF ) ;
final Preference deviceActionsWokeUp = findPreference ( PREF_DEVICE_ACTION_WOKE_UP_SELECTION ) ;
final Preference deviceActionsWokeUpBroadcast = findPreference ( PREF_DEVICE_ACTION_WOKE_UP_BROADCAST ) ;
boolean deviceActionsWokeUpSelectionBroadcast = deviceActionsWokeUpSelection . equals ( PREF_DEVICE_ACTION_SELECTION_BROADCAST ) ;
if ( deviceActionsWokeUp ! = null ) {
deviceActionsWokeUp . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean broadcast = PREF_DEVICE_ACTION_SELECTION_BROADCAST . equals ( newVal . toString ( ) ) ;
Objects . requireNonNull ( deviceActionsWokeUpBroadcast ) . setEnabled ( broadcast ) ;
return true ;
}
} ) ;
}
if ( deviceActionsWokeUpBroadcast ! = null ) {
deviceActionsWokeUpBroadcast . setEnabled ( deviceActionsWokeUpSelectionBroadcast ) ;
}
2022-07-05 20:29:16 +02:00
2020-08-16 22:07:55 +02:00
String deviceActionsStartNonWearSelection = prefs . getString ( PREF_DEVICE_ACTION_START_NON_WEAR_SELECTION , PREF_DEVICE_ACTION_SELECTION_OFF ) ;
final Preference deviceActionsStartNonWear = findPreference ( PREF_DEVICE_ACTION_START_NON_WEAR_SELECTION ) ;
final Preference deviceActionsStartNonWearBroadcast = findPreference ( PREF_DEVICE_ACTION_START_NON_WEAR_BROADCAST ) ;
boolean deviceActionsStartNonWearSelectionBroadcast = deviceActionsStartNonWearSelection . equals ( PREF_DEVICE_ACTION_SELECTION_BROADCAST ) ;
if ( deviceActionsStartNonWear ! = null ) {
deviceActionsStartNonWear . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
@Override
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
final boolean broadcast = PREF_DEVICE_ACTION_SELECTION_BROADCAST . equals ( newVal . toString ( ) ) ;
Objects . requireNonNull ( deviceActionsStartNonWearBroadcast ) . setEnabled ( broadcast ) ;
return true ;
}
} ) ;
}
if ( deviceActionsStartNonWearBroadcast ! = null ) {
deviceActionsStartNonWearBroadcast . setEnabled ( deviceActionsStartNonWearSelectionBroadcast ) ;
}
2021-11-18 12:22:43 +01:00
2021-12-04 20:33:30 +01:00
// this is to ensure that Control Center device cards are refreshed on preference changes
2021-11-18 12:22:43 +01:00
final Preference activityInDeviceCard = findPreference ( PREFS_ACTIVITY_IN_DEVICE_CARD ) ;
final Preference activityInDeviceSteps = findPreference ( PREFS_ACTIVITY_IN_DEVICE_CARD_STEPS ) ;
final Preference activityInDeviceSleep = findPreference ( PREFS_ACTIVITY_IN_DEVICE_CARD_SLEEP ) ;
final Preference activityInDeviceDistance = findPreference ( PREFS_ACTIVITY_IN_DEVICE_CARD_DISTANCE ) ;
2021-12-04 20:33:30 +01:00
final Preference chartsTabsOrderSelection = findPreference ( PREFS_DEVICE_CHARTS_TABS ) ;
2021-11-18 12:22:43 +01:00
Preference . OnPreferenceClickListener sendIntentRefreshDeviceListListener = new Preference . OnPreferenceClickListener ( ) {
@Override
public boolean onPreferenceClick ( Preference arg0 ) {
Intent refreshIntent = new Intent ( DeviceManager . ACTION_REFRESH_DEVICELIST ) ;
LocalBroadcastManager . getInstance ( getContext ( ) ) . sendBroadcast ( refreshIntent ) ;
return true ;
}
} ;
2021-12-04 20:33:30 +01:00
Preference [ ] preferencesInControlCenter = {
activityInDeviceCard ,
activityInDeviceSteps ,
activityInDeviceSleep ,
activityInDeviceDistance ,
2021-12-05 10:32:35 +01:00
chartsTabsOrderSelection ,
2021-12-04 20:33:30 +01:00
} ;
2021-11-18 12:22:43 +01:00
2021-12-04 20:33:30 +01:00
for ( Preference preferenceInControlCenter : preferencesInControlCenter ) {
if ( preferenceInControlCenter ! = null ) {
preferenceInControlCenter . setOnPreferenceClickListener ( sendIntentRefreshDeviceListListener ) ;
}
}
2021-11-28 01:34:29 +01:00
if ( deviceSpecificSettingsCustomizer ! = null ) {
2022-05-17 22:18:49 +02:00
deviceSpecificSettingsCustomizer . customizeSettings ( this , prefs ) ;
2021-11-28 01:34:29 +01:00
}
2019-05-22 00:42:22 +02:00
}
2022-06-19 16:03:37 +02:00
static DeviceSpecificSettingsFragment newInstance ( GBDevice device , DeviceSettingsActivity . MENU_ENTRY_POINTS applicationSpecificSettings ) {
2022-05-09 20:47:08 +02:00
final DeviceCoordinator coordinator = DeviceHelper . getInstance ( ) . getCoordinator ( device ) ;
2022-06-19 16:03:37 +02:00
int [ ] supportedSettings = new int [ 0 ] ;
String [ ] supportedLanguages = null ;
if ( applicationSpecificSettings . equals ( DeviceSettingsActivity . MENU_ENTRY_POINTS . APPLICATION_SETTINGS ) ) { //assemble device settings specific to the application
supportedSettings = ArrayUtils . insert ( 0 , supportedSettings , coordinator . getSupportedDeviceSpecificConnectionSettings ( ) ) ;
supportedSettings = ArrayUtils . addAll ( supportedSettings , coordinator . getSupportedDeviceSpecificApplicationSettings ( ) ) ;
if ( coordinator . supportsActivityTracking ( ) ) {
supportedSettings = ArrayUtils . addAll ( supportedSettings , R . xml . devicesettings_chartstabs ) ;
supportedSettings = ArrayUtils . addAll ( supportedSettings , R . xml . devicesettings_device_card_activity_card_preferences ) ;
}
} else if ( applicationSpecificSettings . equals ( DeviceSettingsActivity . MENU_ENTRY_POINTS . AUTH_SETTINGS ) ) { //auth settings screen
supportedSettings = ArrayUtils . insert ( 0 , supportedSettings , coordinator . getSupportedDeviceSpecificAuthenticationSettings ( ) ) ;
supportedSettings = ArrayUtils . addAll ( supportedSettings , R . xml . devicesettings_pairingkey_explanation ) ;
if ( coordinator . getDeviceType ( ) = = DeviceType . MIBAND6 ) { // miband6 might require new protocol and people do not know what to do, hint them:
supportedSettings = ArrayUtils . addAll ( supportedSettings , R . xml . devicesettings_miband6_new_protocol ) ;
supportedSettings = ArrayUtils . addAll ( supportedSettings , R . xml . devicesettings_miband6_new_auth_protocol_explanation ) ;
}
} else { //device settings
supportedSettings = ArrayUtils . insert ( 0 , supportedSettings , coordinator . getSupportedDeviceSpecificSettings ( device ) ) ;
supportedLanguages = coordinator . getSupportedLanguageSettings ( device ) ;
if ( supportedLanguages ! = null ) {
supportedSettings = ArrayUtils . insert ( 0 , supportedSettings , R . xml . devicesettings_language_generic ) ;
}
supportedSettings = ArrayUtils . addAll ( supportedSettings , coordinator . getSupportedDeviceSpecificAuthenticationSettings ( ) ) ;
2022-05-09 20:47:08 +02:00
}
final DeviceSpecificSettingsCustomizer deviceSpecificSettingsCustomizer = coordinator . getDeviceSpecificSettingsCustomizer ( device ) ;
final String settingsFileSuffix = device . getAddress ( ) ;
2022-01-14 23:01:42 +01:00
final DeviceSpecificSettingsFragment fragment = new DeviceSpecificSettingsFragment ( ) ;
2021-10-07 14:32:09 +02:00
fragment . setSettingsFileSuffix ( settingsFileSuffix , supportedSettings , supportedLanguages ) ;
2022-01-14 23:01:42 +01:00
fragment . setDeviceSpecificSettingsCustomizer ( deviceSpecificSettingsCustomizer ) ;
2022-05-09 20:47:08 +02:00
fragment . setDevice ( device ) ;
2019-05-22 00:42:22 +02:00
return fragment ;
}
@Override
public void onDisplayPreferenceDialog ( Preference preference ) {
2019-06-05 16:00:18 +02:00
DialogFragment dialogFragment ;
2019-05-22 00:42:22 +02:00
if ( preference instanceof XTimePreference ) {
dialogFragment = new XTimePreferenceFragment ( ) ;
Bundle bundle = new Bundle ( 1 ) ;
bundle . putString ( " key " , preference . getKey ( ) ) ;
dialogFragment . setArguments ( bundle ) ;
dialogFragment . setTargetFragment ( this , 0 ) ;
2019-06-05 16:00:18 +02:00
if ( getFragmentManager ( ) ! = null ) {
dialogFragment . show ( getFragmentManager ( ) , " androidx.preference.PreferenceFragment.DIALOG " ) ;
}
2020-11-06 11:26:50 +01:00
} else if ( preference instanceof DragSortListPreference ) {
dialogFragment = new DragSortListPreferenceFragment ( ) ;
Bundle bundle = new Bundle ( 1 ) ;
bundle . putString ( " key " , preference . getKey ( ) ) ;
dialogFragment . setArguments ( bundle ) ;
dialogFragment . setTargetFragment ( this , 0 ) ;
if ( getFragmentManager ( ) ! = null ) {
dialogFragment . show ( getFragmentManager ( ) , " androidx.preference.PreferenceFragment.DIALOG " ) ;
}
2019-05-22 00:42:22 +02:00
} else {
super . onDisplayPreferenceDialog ( preference ) ;
}
}
2019-06-05 12:16:10 +02:00
2021-11-28 01:34:29 +01:00
@Override
public void addPreferenceHandlerFor ( final String preferenceKey ) {
addPreferenceHandlerFor ( preferenceKey , null ) ;
}
@Override
public void addPreferenceHandlerFor ( final String preferenceKey , final Preference . OnPreferenceChangeListener extraListener ) {
2019-06-05 12:16:10 +02:00
Preference pref = findPreference ( preferenceKey ) ;
if ( pref ! = null ) {
pref . setOnPreferenceChangeListener ( new Preference . OnPreferenceChangeListener ( ) {
public boolean onPreferenceChange ( Preference preference , Object newVal ) {
2022-01-15 00:50:00 +01:00
notifyPreferenceChanged ( preferenceKey ) ;
2021-11-28 01:34:29 +01:00
if ( extraListener ! = null ) {
return extraListener . onPreferenceChange ( preference , newVal ) ;
}
2019-06-05 12:16:10 +02:00
return true ;
}
} ) ;
}
}
2019-11-14 12:33:36 +01:00
2022-05-14 15:20:28 +02:00
@Override
public void setInputTypeFor ( final String preferenceKey , final int editTypeFlags ) {
2019-11-14 12:33:36 +01:00
EditTextPreference textPreference = findPreference ( preferenceKey ) ;
if ( textPreference ! = null ) {
textPreference . setOnBindEditTextListener ( new EditTextPreference . OnBindEditTextListener ( ) {
@Override
public void onBindEditText ( @NonNull EditText editText ) {
editText . setInputType ( editTypeFlags ) ;
}
} ) ;
}
}
2021-12-12 19:38:14 +01:00
2022-05-14 15:20:28 +02:00
/ * *
* Keys of preferences which should print its values as a summary below the preference name .
* /
protected Set < String > getPreferenceKeysWithSummary ( ) {
final Set < String > keysWithSummary = new HashSet < > ( ) ;
2022-05-14 22:08:32 +02:00
keysWithSummary . add ( PREF_INACTIVITY_THRESHOLD ) ;
2022-05-14 15:20:28 +02:00
if ( deviceSpecificSettingsCustomizer ! = null ) {
keysWithSummary . addAll ( deviceSpecificSettingsCustomizer . getPreferenceKeysWithSummary ( ) ) ;
}
return keysWithSummary ;
}
2021-12-12 19:38:14 +01:00
/ * *
* Reload the preferences in the current screen . This is needed when the user enters or exists a PreferenceScreen ,
* otherwise the settings won ' t be reloaded by the { @link SharedPreferencesChangeHandler } , as the preferences return
* null , since they ' re not visible .
*
* @param sharedPreferences the { @link SharedPreferences } instance
* @param preferenceGroup the { @link PreferenceGroup } for which preferences will be reloaded
* /
private void reloadPreferences ( final SharedPreferences sharedPreferences , final PreferenceGroup preferenceGroup ) {
for ( int i = 0 ; i < preferenceGroup . getPreferenceCount ( ) ; i + + ) {
final Preference preference = preferenceGroup . getPreference ( i ) ;
LOG . debug ( " Reloading {} " , preference . getKey ( ) ) ;
if ( preference instanceof PreferenceCategory ) {
reloadPreferences ( sharedPreferences , ( PreferenceCategory ) preference ) ;
continue ;
}
sharedPreferencesChangeHandler . onSharedPreferenceChanged ( sharedPreferences , preference . getKey ( ) ) ;
}
}
/ * *
* Handler for preference changes , update UI accordingly ( if device updates the preferences ) .
* /
private class SharedPreferencesChangeHandler implements SharedPreferences . OnSharedPreferenceChangeListener {
@Override
public void onSharedPreferenceChanged ( SharedPreferences prefs , String key ) {
LOG . debug ( " Preference changed: {} " , key ) ;
2022-05-14 15:20:28 +02:00
if ( key = = null ) {
2021-12-26 15:40:12 +01:00
LOG . warn ( " Preference null, ignoring " ) ;
return ;
}
2021-12-12 19:38:14 +01:00
final Preference preference = findPreference ( key ) ;
if ( preference = = null ) {
2022-01-14 01:31:58 +01:00
LOG . warn ( " Preference {} not found " , key ) ;
2021-12-12 19:38:14 +01:00
return ;
}
if ( preference instanceof SeekBarPreference ) {
final SeekBarPreference seekBarPreference = ( SeekBarPreference ) preference ;
seekBarPreference . setValue ( prefs . getInt ( key , seekBarPreference . getValue ( ) ) ) ;
} else if ( preference instanceof SwitchPreference ) {
final SwitchPreference switchPreference = ( SwitchPreference ) preference ;
switchPreference . setChecked ( prefs . getBoolean ( key , switchPreference . isChecked ( ) ) ) ;
} else if ( preference instanceof ListPreference ) {
final ListPreference listPreference = ( ListPreference ) preference ;
listPreference . setValue ( prefs . getString ( key , listPreference . getValue ( ) ) ) ;
2022-01-14 01:31:58 +01:00
} else if ( preference instanceof EditTextPreference ) {
final EditTextPreference editTextPreference = ( EditTextPreference ) preference ;
editTextPreference . setText ( prefs . getString ( key , editTextPreference . getText ( ) ) ) ;
2021-12-12 19:38:14 +01:00
} else if ( preference instanceof PreferenceScreen ) {
// Ignoring
} else {
LOG . warn ( " Unknown preference class {}, ignoring " , preference . getClass ( ) ) ;
}
2022-01-14 01:31:58 +01:00
2022-05-14 15:20:28 +02:00
if ( getPreferenceKeysWithSummary ( ) . contains ( key ) ) {
final String summary = prefs . getString ( key , preference . getSummary ( ) ! = null ? preference . getSummary ( ) . toString ( ) : " " ) ;
preference . setSummary ( summary ) ;
}
2022-01-14 01:31:58 +01:00
if ( deviceSpecificSettingsCustomizer ! = null ) {
deviceSpecificSettingsCustomizer . onPreferenceChange ( preference , DeviceSpecificSettingsFragment . this ) ;
}
2021-12-12 19:38:14 +01:00
}
}
2019-05-22 00:42:22 +02:00
}