6543
/
BayernMessenger
forked from GitHub-Mirror/riotX-android
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

Rename PreferencesManager to VectorPreferences for code clarity

This commit is contained in:
Benoit Marty 2019-07-09 16:10:22 +02:00 committed by Benoit Marty
parent a79227424f
commit 8a0c9ae9b0
22 changed files with 114 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
vector/src/fdroid/java/im/vector/riotx/fdroid/features/settings/troubleshoot/TestAutoStartBoot.kt
View File

@ -18,7 +18,7 @@ package im.vector.riotx.fdroid.features.settings.troubleshoot
import androidx.appcompat.app.AppCompatActivity import androidx.appcompat.app.AppCompatActivity
import im.vector.riotx.R import im.vector.riotx.R
import im.vector.riotx.core.resources.StringProvider import im.vector.riotx.core.resources.StringProvider
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import im.vector.riotx.features.settings.troubleshoot.TroubleshootTest import im.vector.riotx.features.settings.troubleshoot.TroubleshootTest
import javax.inject.Inject import javax.inject.Inject


@ -30,7 +30,7 @@ class TestAutoStartBoot @Inject constructor(private val context: AppCompatActivi
: TroubleshootTest(R.string.settings_troubleshoot_test_service_boot_title) { : TroubleshootTest(R.string.settings_troubleshoot_test_service_boot_title) {


override fun perform() { override fun perform() {
if (PreferencesManager.autoStartOnBoot(context)) { if (VectorPreferences.autoStartOnBoot(context)) {
description = stringProvider.getString(R.string.settings_troubleshoot_test_service_boot_success) description = stringProvider.getString(R.string.settings_troubleshoot_test_service_boot_success)
status = TestStatus.SUCCESS status = TestStatus.SUCCESS
quickFix = null quickFix = null
@ -38,7 +38,7 @@ class TestAutoStartBoot @Inject constructor(private val context: AppCompatActivi
description = stringProvider.getString(R.string.settings_troubleshoot_test_service_boot_failed) description = stringProvider.getString(R.string.settings_troubleshoot_test_service_boot_failed)
quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_service_boot_quickfix) { quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_service_boot_quickfix) {
override fun doFix() { override fun doFix() {
PreferencesManager.setAutoStartOnBoot(context, true) VectorPreferences.setAutoStartOnBoot(context, true)
manager?.retry() manager?.retry()
} }
} }

4
vector/src/fdroid/java/im/vector/riotx/push/fcm/FcmHelper.kt
View File

@ -21,7 +21,7 @@ import android.content.Context
import im.vector.riotx.core.di.ActiveSessionHolder import im.vector.riotx.core.di.ActiveSessionHolder
import im.vector.riotx.core.pushers.PushersManager import im.vector.riotx.core.pushers.PushersManager
import im.vector.riotx.fdroid.receiver.AlarmSyncBroadcastReceiver import im.vector.riotx.fdroid.receiver.AlarmSyncBroadcastReceiver
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import timber.log.Timber import timber.log.Timber


/** /**
@ -65,7 +65,7 @@ object FcmHelper {


fun onEnterBackground(context: Context, activeSessionHolder: ActiveSessionHolder) { fun onEnterBackground(context: Context, activeSessionHolder: ActiveSessionHolder) {
//We need to use alarm in this mode //We need to use alarm in this mode
if (PreferencesManager.areNotificationEnabledForDevice(context) && activeSessionHolder.hasActiveSession()) { if (VectorPreferences.areNotificationEnabledForDevice(context) && activeSessionHolder.hasActiveSession()) {
val currentSession = activeSessionHolder.getActiveSession() val currentSession = activeSessionHolder.getActiveSession()
AlarmSyncBroadcastReceiver.scheduleAlarm(context, currentSession.myUserId, 4_000L) AlarmSyncBroadcastReceiver.scheduleAlarm(context, currentSession.myUserId, 4_000L)
Timber.i("Alarm scheduled to restart service") Timber.i("Alarm scheduled to restart service")

6
vector/src/gplay/java/im/vector/riotx/gplay/push/fcm/VectorFirebaseMessagingService.kt
View File

@ -39,7 +39,7 @@ import im.vector.riotx.features.notifications.NotifiableEventResolver
import im.vector.riotx.features.notifications.NotifiableMessageEvent import im.vector.riotx.features.notifications.NotifiableMessageEvent
import im.vector.riotx.features.notifications.NotificationDrawerManager import im.vector.riotx.features.notifications.NotificationDrawerManager
import im.vector.riotx.features.notifications.SimpleNotifiableEvent import im.vector.riotx.features.notifications.SimpleNotifiableEvent
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import im.vector.riotx.push.fcm.FcmHelper import im.vector.riotx.push.fcm.FcmHelper
import timber.log.Timber import timber.log.Timber


@ -72,7 +72,7 @@ class VectorFirebaseMessagingService : FirebaseMessagingService() {
* @param message the message * @param message the message
*/ */
override fun onMessageReceived(message: RemoteMessage?) { override fun onMessageReceived(message: RemoteMessage?) {
if (!PreferencesManager.areNotificationEnabledForDevice(applicationContext)) { if (!VectorPreferences.areNotificationEnabledForDevice(applicationContext)) {
Timber.i("Notification are disabled for this device") Timber.i("Notification are disabled for this device")
return return
} }
@ -107,7 +107,7 @@ class VectorFirebaseMessagingService : FirebaseMessagingService() {
if (refreshedToken == null) { if (refreshedToken == null) {
Timber.w("onNewToken:received null token") Timber.w("onNewToken:received null token")
} else { } else {
if (PreferencesManager.areNotificationEnabledForDevice(applicationContext) && activeSessionHolder.hasActiveSession()) { if (VectorPreferences.areNotificationEnabledForDevice(applicationContext) && activeSessionHolder.hasActiveSession()) {
pusherManager.registerPusherWithFcmKey(refreshedToken) pusherManager.registerPusherWithFcmKey(refreshedToken)
} }
} }

4
vector/src/main/java/im/vector/riotx/core/resources/UserPreferencesProvider.kt
View File

@ -17,12 +17,12 @@
package im.vector.riotx.core.resources package im.vector.riotx.core.resources


import android.content.Context import android.content.Context
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import javax.inject.Inject import javax.inject.Inject


class UserPreferencesProvider @Inject constructor(private val context: Context) { class UserPreferencesProvider @Inject constructor(private val context: Context) {


fun shouldShowHiddenEvents(): Boolean { fun shouldShowHiddenEvents(): Boolean {
return PreferencesManager.shouldShowHiddenEvents(context) return VectorPreferences.shouldShowHiddenEvents(context)
} }
} }

10
vector/src/main/java/im/vector/riotx/core/utils/RingtoneUtils.kt
View File

@ -22,7 +22,7 @@ import android.media.RingtoneManager
import android.net.Uri import android.net.Uri
import android.preference.PreferenceManager import android.preference.PreferenceManager
import androidx.core.content.edit import androidx.core.content.edit
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences


/** /**
* This file manages the sound ringtone for calls. * This file manages the sound ringtone for calls.
@ -41,7 +41,7 @@ import im.vector.riotx.features.settings.PreferencesManager
*/ */
fun getCallRingtoneUri(context: Context): Uri? { fun getCallRingtoneUri(context: Context): Uri? {
val callRingtone: String? = PreferenceManager.getDefaultSharedPreferences(context) val callRingtone: String? = PreferenceManager.getDefaultSharedPreferences(context)
.getString(PreferencesManager.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY, null) .getString(VectorPreferences.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY, null)


callRingtone?.let { callRingtone?.let {
return Uri.parse(it) return Uri.parse(it)
@ -96,7 +96,7 @@ fun getCallRingtoneName(context: Context): String? {
fun setCallRingtoneUri(context: Context, ringtoneUri: Uri) { fun setCallRingtoneUri(context: Context, ringtoneUri: Uri) {
PreferenceManager.getDefaultSharedPreferences(context) PreferenceManager.getDefaultSharedPreferences(context)
.edit { .edit {
putString(PreferencesManager.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY, ringtoneUri.toString()) putString(VectorPreferences.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY, ringtoneUri.toString())
} }
} }


@ -104,7 +104,7 @@ fun setCallRingtoneUri(context: Context, ringtoneUri: Uri) {
* Set using Riot default ringtone * Set using Riot default ringtone
*/ */
fun useRiotDefaultRingtone(context: Context): Boolean { fun useRiotDefaultRingtone(context: Context): Boolean {
return PreferenceManager.getDefaultSharedPreferences(context).getBoolean(PreferencesManager.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY, true) return PreferenceManager.getDefaultSharedPreferences(context).getBoolean(VectorPreferences.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY, true)
} }


/** /**
@ -113,7 +113,7 @@ fun useRiotDefaultRingtone(context: Context): Boolean {
fun setUseRiotDefaultRingtone(context: Context, useRiotDefault: Boolean) { fun setUseRiotDefaultRingtone(context: Context, useRiotDefault: Boolean) {
PreferenceManager.getDefaultSharedPreferences(context) PreferenceManager.getDefaultSharedPreferences(context)
.edit { .edit {
putBoolean(PreferencesManager.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY, useRiotDefault) putBoolean(VectorPreferences.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY, useRiotDefault)
} }
} }



10
vector/src/main/java/im/vector/riotx/features/home/room/detail/RoomDetailFragment.kt
View File

@ -98,7 +98,7 @@ import im.vector.riotx.features.media.VideoContentRenderer
import im.vector.riotx.features.media.VideoMediaViewerActivity import im.vector.riotx.features.media.VideoMediaViewerActivity
import im.vector.riotx.features.notifications.NotificationDrawerManager import im.vector.riotx.features.notifications.NotificationDrawerManager
import im.vector.riotx.features.reactions.EmojiReactionPickerActivity import im.vector.riotx.features.reactions.EmojiReactionPickerActivity
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import im.vector.riotx.features.themes.ThemeUtils import im.vector.riotx.features.themes.ThemeUtils
import kotlinx.android.parcel.Parcelize import kotlinx.android.parcel.Parcelize
import kotlinx.android.synthetic.main.fragment_room_detail.* import kotlinx.android.synthetic.main.fragment_room_detail.*
@ -419,7 +419,7 @@ class RoomDetailFragment :
composerLayout.sendButton.setOnClickListener { composerLayout.sendButton.setOnClickListener {
val textMessage = composerLayout.composerEditText.text.toString() val textMessage = composerLayout.composerEditText.text.toString()
if (textMessage.isNotBlank()) { if (textMessage.isNotBlank()) {
roomDetailViewModel.process(RoomDetailActions.SendMessage(textMessage, PreferencesManager.isMarkdownEnabled(requireContext()))) roomDetailViewModel.process(RoomDetailActions.SendMessage(textMessage, VectorPreferences.isMarkdownEnabled(requireContext())))
} }
} }
} }
@ -440,7 +440,7 @@ class RoomDetailFragment :
items.add(DialogListItem.SendFile) items.add(DialogListItem.SendFile)
// Send voice // Send voice


if (PreferencesManager.isSendVoiceFeatureEnabled(this)) { if (VectorPreferences.isSendVoiceFeatureEnabled(this)) {
items.add(DialogListItem.SendVoice.INSTANCE) items.add(DialogListItem.SendVoice.INSTANCE)
} }


@ -449,7 +449,7 @@ class RoomDetailFragment :
//items.add(DialogListItem.SendSticker) //items.add(DialogListItem.SendSticker)
// Camera // Camera


//if (PreferencesManager.useNativeCamera(this)) { //if (VectorPreferences.useNativeCamera(this)) {
items.add(DialogListItem.TakePhoto) items.add(DialogListItem.TakePhoto)
items.add(DialogListItem.TakeVideo) items.add(DialogListItem.TakeVideo)
//} else { //} else {
@ -829,7 +829,7 @@ class RoomDetailFragment :
// vibrate = true // vibrate = true
} }


// if (vibrate && PreferencesManager.vibrateWhenMentioning(context)) { // if (vibrate && VectorPreferences.vibrateWhenMentioning(context)) {
// val v= context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator // val v= context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
// if (v?.hasVibrator() == true) { // if (v?.hasVibrator() == true) {
// v.vibrate(100) // v.vibrate(100)

4
vector/src/main/java/im/vector/riotx/features/notifications/NotificationDrawerManager.kt
View File

@ -28,7 +28,7 @@ import im.vector.matrix.android.api.util.SecretStoringUtils
import im.vector.riotx.BuildConfig import im.vector.riotx.BuildConfig
import im.vector.riotx.R import im.vector.riotx.R
import im.vector.riotx.core.di.ActiveSessionHolder import im.vector.riotx.core.di.ActiveSessionHolder
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import me.gujun.android.span.span import me.gujun.android.span.span
import timber.log.Timber import timber.log.Timber
import java.io.File import java.io.File
@ -73,7 +73,7 @@ class NotificationDrawerManager @Inject constructor(private val context: Context
Events might be grouped and there might not be one notification per event! Events might be grouped and there might not be one notification per event!
*/ */
fun onNotifiableEventReceived(notifiableEvent: NotifiableEvent) { fun onNotifiableEventReceived(notifiableEvent: NotifiableEvent) {
if (!PreferencesManager.areNotificationEnabledForDevice(context)) { if (!VectorPreferences.areNotificationEnabledForDevice(context)) {
Timber.i("Notification are disabled for this device") Timber.i("Notification are disabled for this device")
return return
} }

8
vector/src/main/java/im/vector/riotx/features/notifications/NotificationUtils.kt
View File

@ -41,7 +41,7 @@ import im.vector.riotx.core.utils.startNotificationChannelSettingsIntent
import im.vector.riotx.features.home.HomeActivity import im.vector.riotx.features.home.HomeActivity
import im.vector.riotx.features.home.room.detail.RoomDetailActivity import im.vector.riotx.features.home.room.detail.RoomDetailActivity
import im.vector.riotx.features.home.room.detail.RoomDetailArgs import im.vector.riotx.features.home.room.detail.RoomDetailArgs
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import timber.log.Timber import timber.log.Timber
import java.util.* import java.util.*


@ -420,7 +420,7 @@ object NotificationUtils {
priority = NotificationCompat.PRIORITY_DEFAULT priority = NotificationCompat.PRIORITY_DEFAULT
if (roomInfo.shouldBing) { if (roomInfo.shouldBing) {
//Compat //Compat
PreferencesManager.getNotificationRingTone(context)?.let { VectorPreferences.getNotificationRingTone(context)?.let {
setSound(it) setSound(it)
} }
setLights(accentColor, 500, 500) setLights(accentColor, 500, 500)
@ -534,7 +534,7 @@ object NotificationUtils {
if (simpleNotifiableEvent.noisy) { if (simpleNotifiableEvent.noisy) {
//Compat //Compat
priority = NotificationCompat.PRIORITY_DEFAULT priority = NotificationCompat.PRIORITY_DEFAULT
PreferencesManager.getNotificationRingTone(context)?.let { VectorPreferences.getNotificationRingTone(context)?.let {
setSound(it) setSound(it)
} }
setLights(accentColor, 500, 500) setLights(accentColor, 500, 500)
@ -630,7 +630,7 @@ object NotificationUtils {
if (noisy) { if (noisy) {
//Compat //Compat
priority = NotificationCompat.PRIORITY_DEFAULT priority = NotificationCompat.PRIORITY_DEFAULT
PreferencesManager.getNotificationRingTone(context)?.let { VectorPreferences.getNotificationRingTone(context)?.let {
setSound(it) setSound(it)
} }
setLights(accentColor, 500, 500) setLights(accentColor, 500, 500)

2
vector/src/main/java/im/vector/riotx/features/settings/PreferencesManager.kt → vector/src/main/java/im/vector/riotx/features/settings/VectorPreferences.kt
View File

@ -32,7 +32,7 @@ import timber.log.Timber
import java.io.File import java.io.File
import java.util.* import java.util.*


object PreferencesManager { object VectorPreferences {


const val SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY = "SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY_2" const val SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY = "SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY_2"
const val SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY = "SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY" const val SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY = "SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY"

4
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsActivity.kt
View File

@ -78,9 +78,9 @@ class VectorSettingsActivity : VectorBaseActivity(),
override fun onPreferenceStartFragment(caller: PreferenceFragmentCompat?, pref: Preference?): Boolean { override fun onPreferenceStartFragment(caller: PreferenceFragmentCompat?, pref: Preference?): Boolean {
var oFragment: Fragment? = null var oFragment: Fragment? = null


if (PreferencesManager.SETTINGS_NOTIFICATION_TROUBLESHOOT_PREFERENCE_KEY == pref?.key) { if (VectorPreferences.SETTINGS_NOTIFICATION_TROUBLESHOOT_PREFERENCE_KEY == pref?.key) {
oFragment = VectorSettingsNotificationsTroubleshootFragment.newInstance(session.sessionParams.credentials.userId) oFragment = VectorSettingsNotificationsTroubleshootFragment.newInstance(session.sessionParams.credentials.userId)
} else if (PreferencesManager.SETTINGS_NOTIFICATION_ADVANCED_PREFERENCE_KEY == pref?.key) { } else if (VectorPreferences.SETTINGS_NOTIFICATION_ADVANCED_PREFERENCE_KEY == pref?.key) {
oFragment = VectorSettingsAdvancedNotificationPreferenceFragment.newInstance(session.sessionParams.credentials.userId) oFragment = VectorSettingsAdvancedNotificationPreferenceFragment.newInstance(session.sessionParams.credentials.userId)
} else { } else {
try { try {

36
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsAdvancedNotificationPreferenceFragment.kt
View File

@ -46,7 +46,7 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF
override val preferenceXmlRes = R.xml.vector_settings_notification_advanced_preferences override val preferenceXmlRes = R.xml.vector_settings_notification_advanced_preferences


override fun bindPref() { override fun bindPref() {
val callNotificationsSystemOptions = findPreference(PreferencesManager.SETTINGS_SYSTEM_CALL_NOTIFICATION_PREFERENCE_KEY) val callNotificationsSystemOptions = findPreference(VectorPreferences.SETTINGS_SYSTEM_CALL_NOTIFICATION_PREFERENCE_KEY)
if (supportNotificationChannels()) { if (supportNotificationChannels()) {
callNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener { callNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener {
NotificationUtils.openSystemSettingsForCallCategory(this) NotificationUtils.openSystemSettingsForCallCategory(this)
@ -56,7 +56,7 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF
callNotificationsSystemOptions.isVisible = false callNotificationsSystemOptions.isVisible = false
} }


val noisyNotificationsSystemOptions = findPreference(PreferencesManager.SETTINGS_SYSTEM_NOISY_NOTIFICATION_PREFERENCE_KEY) val noisyNotificationsSystemOptions = findPreference(VectorPreferences.SETTINGS_SYSTEM_NOISY_NOTIFICATION_PREFERENCE_KEY)
if (supportNotificationChannels()) { if (supportNotificationChannels()) {
noisyNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener { noisyNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener {
NotificationUtils.openSystemSettingsForNoisyCategory(this) NotificationUtils.openSystemSettingsForNoisyCategory(this)
@ -66,7 +66,7 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF
noisyNotificationsSystemOptions.isVisible = false noisyNotificationsSystemOptions.isVisible = false
} }


val silentNotificationsSystemOptions = findPreference(PreferencesManager.SETTINGS_SYSTEM_SILENT_NOTIFICATION_PREFERENCE_KEY) val silentNotificationsSystemOptions = findPreference(VectorPreferences.SETTINGS_SYSTEM_SILENT_NOTIFICATION_PREFERENCE_KEY)
if (supportNotificationChannels()) { if (supportNotificationChannels()) {
silentNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener { silentNotificationsSystemOptions.onPreferenceClickListener = Preference.OnPreferenceClickListener {
NotificationUtils.openSystemSettingsForSilentCategory(this) NotificationUtils.openSystemSettingsForSilentCategory(this)
@ -78,18 +78,18 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF




// Ringtone // Ringtone
val ringtonePreference = findPreference(PreferencesManager.SETTINGS_NOTIFICATION_RINGTONE_SELECTION_PREFERENCE_KEY) val ringtonePreference = findPreference(VectorPreferences.SETTINGS_NOTIFICATION_RINGTONE_SELECTION_PREFERENCE_KEY)


if (supportNotificationChannels()) { if (supportNotificationChannels()) {
ringtonePreference.isVisible = false ringtonePreference.isVisible = false
} else { } else {
ringtonePreference.summary = PreferencesManager.getNotificationRingToneName(requireContext()) ringtonePreference.summary = VectorPreferences.getNotificationRingToneName(requireContext())
ringtonePreference.onPreferenceClickListener = Preference.OnPreferenceClickListener { ringtonePreference.onPreferenceClickListener = Preference.OnPreferenceClickListener {
val intent = Intent(RingtoneManager.ACTION_RINGTONE_PICKER) val intent = Intent(RingtoneManager.ACTION_RINGTONE_PICKER)
intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, RingtoneManager.TYPE_NOTIFICATION) intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, RingtoneManager.TYPE_NOTIFICATION)


if (null != PreferencesManager.getNotificationRingTone(requireContext())) { if (null != VectorPreferences.getNotificationRingTone(requireContext())) {
intent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, PreferencesManager.getNotificationRingTone(requireContext())) intent.putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, VectorPreferences.getNotificationRingTone(requireContext()))
} }


startActivityForResult(intent, REQUEST_NOTIFICATION_RINGTONE) startActivityForResult(intent, REQUEST_NOTIFICATION_RINGTONE)
@ -152,14 +152,14 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF
if (resultCode == Activity.RESULT_OK) { if (resultCode == Activity.RESULT_OK) {
when (requestCode) { when (requestCode) {
REQUEST_NOTIFICATION_RINGTONE -> { REQUEST_NOTIFICATION_RINGTONE -> {
PreferencesManager.setNotificationRingTone(requireContext(), VectorPreferences.setNotificationRingTone(requireContext(),
data?.getParcelableExtra<Parcelable>(RingtoneManager.EXTRA_RINGTONE_PICKED_URI) as Uri?) data?.getParcelableExtra<Parcelable>(RingtoneManager.EXTRA_RINGTONE_PICKED_URI) as Uri?)


// test if the selected ring tone can be played // test if the selected ring tone can be played
val notificationRingToneName = PreferencesManager.getNotificationRingToneName(requireContext()) val notificationRingToneName = VectorPreferences.getNotificationRingToneName(requireContext())
if (null != notificationRingToneName) { if (null != notificationRingToneName) {
PreferencesManager.setNotificationRingTone(requireContext(), PreferencesManager.getNotificationRingTone(requireContext())) VectorPreferences.setNotificationRingTone(requireContext(), VectorPreferences.getNotificationRingTone(requireContext()))
findPreference(PreferencesManager.SETTINGS_NOTIFICATION_RINGTONE_SELECTION_PREFERENCE_KEY).summary = notificationRingToneName findPreference(VectorPreferences.SETTINGS_NOTIFICATION_RINGTONE_SELECTION_PREFERENCE_KEY).summary = notificationRingToneName
} }
} }
} }
@ -217,13 +217,13 @@ class VectorSettingsAdvancedNotificationPreferenceFragment : VectorSettingsBaseF


// preference name <-> rule Id // preference name <-> rule Id
private var mPrefKeyToBingRuleId = mapOf( private var mPrefKeyToBingRuleId = mapOf(
PreferencesManager.SETTINGS_CONTAINING_MY_DISPLAY_NAME_PREFERENCE_KEY to BingRule.RULE_ID_CONTAIN_DISPLAY_NAME, VectorPreferences.SETTINGS_CONTAINING_MY_DISPLAY_NAME_PREFERENCE_KEY to BingRule.RULE_ID_CONTAIN_DISPLAY_NAME,
PreferencesManager.SETTINGS_CONTAINING_MY_USER_NAME_PREFERENCE_KEY to BingRule.RULE_ID_CONTAIN_USER_NAME, VectorPreferences.SETTINGS_CONTAINING_MY_USER_NAME_PREFERENCE_KEY to BingRule.RULE_ID_CONTAIN_USER_NAME,
PreferencesManager.SETTINGS_MESSAGES_IN_ONE_TO_ONE_PREFERENCE_KEY to BingRule.RULE_ID_ONE_TO_ONE_ROOM, VectorPreferences.SETTINGS_MESSAGES_IN_ONE_TO_ONE_PREFERENCE_KEY to BingRule.RULE_ID_ONE_TO_ONE_ROOM,
PreferencesManager.SETTINGS_MESSAGES_IN_GROUP_CHAT_PREFERENCE_KEY to BingRule.RULE_ID_ALL_OTHER_MESSAGES_ROOMS, VectorPreferences.SETTINGS_MESSAGES_IN_GROUP_CHAT_PREFERENCE_KEY to BingRule.RULE_ID_ALL_OTHER_MESSAGES_ROOMS,
PreferencesManager.SETTINGS_INVITED_TO_ROOM_PREFERENCE_KEY to BingRule.RULE_ID_INVITE_ME, VectorPreferences.SETTINGS_INVITED_TO_ROOM_PREFERENCE_KEY to BingRule.RULE_ID_INVITE_ME,
PreferencesManager.SETTINGS_CALL_INVITATIONS_PREFERENCE_KEY to BingRule.RULE_ID_CALL, VectorPreferences.SETTINGS_CALL_INVITATIONS_PREFERENCE_KEY to BingRule.RULE_ID_CALL,
PreferencesManager.SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY to BingRule.RULE_ID_SUPPRESS_BOTS_NOTIFICATIONS VectorPreferences.SETTINGS_MESSAGES_SENT_BY_BOT_PREFERENCE_KEY to BingRule.RULE_ID_SUPPRESS_BOTS_NOTIFICATIONS
) )


fun newInstance(matrixId: String) = VectorSettingsAdvancedNotificationPreferenceFragment() fun newInstance(matrixId: String) = VectorSettingsAdvancedNotificationPreferenceFragment()

2
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsFlairFragment.kt
View File

@ -30,7 +30,7 @@ class VectorSettingsFlairFragment : VectorSettingsBaseFragment() {


// Group Flairs // Group Flairs
private val mGroupsFlairCategory by lazy { private val mGroupsFlairCategory by lazy {
findPreference(PreferencesManager.SETTINGS_GROUPS_FLAIR_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_GROUPS_FLAIR_KEY) as PreferenceCategory
} }


override fun bindPref() { override fun bindPref() {

26
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsGeneralFragment.kt
View File

@ -61,25 +61,25 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
private var mDisplayedPhoneNumber = ArrayList<String>() private var mDisplayedPhoneNumber = ArrayList<String>()


private val mUserSettingsCategory by lazy { private val mUserSettingsCategory by lazy {
findPreference(PreferencesManager.SETTINGS_USER_SETTINGS_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_USER_SETTINGS_PREFERENCE_KEY) as PreferenceCategory
} }
private val mUserAvatarPreference by lazy { private val mUserAvatarPreference by lazy {
findPreference(PreferencesManager.SETTINGS_PROFILE_PICTURE_PREFERENCE_KEY) as UserAvatarPreference findPreference(VectorPreferences.SETTINGS_PROFILE_PICTURE_PREFERENCE_KEY) as UserAvatarPreference
} }
private val mDisplayNamePreference by lazy { private val mDisplayNamePreference by lazy {
findPreference(PreferencesManager.SETTINGS_DISPLAY_NAME_PREFERENCE_KEY) as EditTextPreference findPreference(VectorPreferences.SETTINGS_DISPLAY_NAME_PREFERENCE_KEY) as EditTextPreference
} }
private val mPasswordPreference by lazy { private val mPasswordPreference by lazy {
findPreference(PreferencesManager.SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_CHANGE_PASSWORD_PREFERENCE_KEY)
} }


// Local contacts // Local contacts
private val mContactSettingsCategory by lazy { private val mContactSettingsCategory by lazy {
findPreference(PreferencesManager.SETTINGS_CONTACT_PREFERENCE_KEYS) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_CONTACT_PREFERENCE_KEYS) as PreferenceCategory
} }


private val mContactPhonebookCountryPreference by lazy { private val mContactPhonebookCountryPreference by lazy {
findPreference(PreferencesManager.SETTINGS_CONTACTS_PHONEBOOK_COUNTRY_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_CONTACTS_PHONEBOOK_COUNTRY_PREFERENCE_KEY)
} }




@ -147,15 +147,15 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
// Advanced settings // Advanced settings


// user account // user account
findPreference(PreferencesManager.SETTINGS_LOGGED_IN_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_LOGGED_IN_PREFERENCE_KEY)
.summary = session.sessionParams.credentials.userId .summary = session.sessionParams.credentials.userId


// home server // home server
findPreference(PreferencesManager.SETTINGS_HOME_SERVER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_HOME_SERVER_PREFERENCE_KEY)
.summary = session.sessionParams.homeServerConnectionConfig.homeServerUri.toString() .summary = session.sessionParams.homeServerConnectionConfig.homeServerUri.toString()


// identity server // identity server
findPreference(PreferencesManager.SETTINGS_IDENTITY_SERVER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_IDENTITY_SERVER_PREFERENCE_KEY)
.summary = session.sessionParams.homeServerConnectionConfig.identityServerUri.toString() .summary = session.sessionParams.homeServerConnectionConfig.identityServerUri.toString()




@ -165,7 +165,7 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
setContactsPreferences() setContactsPreferences()


// clear cache // clear cache
findPreference(PreferencesManager.SETTINGS_CLEAR_CACHE_PREFERENCE_KEY).let { findPreference(VectorPreferences.SETTINGS_CLEAR_CACHE_PREFERENCE_KEY).let {
/* /*
TODO TODO
MXSession.getApplicationSizeCaches(activity, object : SimpleApiCallback<Long>() { MXSession.getApplicationSizeCaches(activity, object : SimpleApiCallback<Long>() {
@ -185,7 +185,7 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
} }


// clear medias cache // clear medias cache
findPreference(PreferencesManager.SETTINGS_CLEAR_MEDIA_CACHE_PREFERENCE_KEY).let { findPreference(VectorPreferences.SETTINGS_CLEAR_MEDIA_CACHE_PREFERENCE_KEY).let {
val size = getSizeOfFiles(requireContext(), val size = getSizeOfFiles(requireContext(),
File(requireContext().cacheDir, DiskCache.Factory.DEFAULT_DISK_CACHE_DIR)) File(requireContext().cacheDir, DiskCache.Factory.DEFAULT_DISK_CACHE_DIR))


@ -232,7 +232,7 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
// Deactivate account section // Deactivate account section


// deactivate account // deactivate account
findPreference(PreferencesManager.SETTINGS_DEACTIVATE_ACCOUNT_KEY) findPreference(VectorPreferences.SETTINGS_DEACTIVATE_ACCOUNT_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
activity?.let { activity?.let {
notImplemented() notImplemented()
@ -834,7 +834,7 @@ class VectorSettingsGeneralFragment : VectorSettingsBaseFragment() {
override fun onSuccess(info: Void?) { override fun onSuccess(info: Void?) {
// refresh the settings value // refresh the settings value
PreferenceManager.getDefaultSharedPreferences(activity).edit { PreferenceManager.getDefaultSharedPreferences(activity).edit {
putString(PreferencesManager.SETTINGS_DISPLAY_NAME_PREFERENCE_KEY, value) putString(VectorPreferences.SETTINGS_DISPLAY_NAME_PREFERENCE_KEY, value)
} }


onCommonDone(null) onCommonDone(null)

16
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsHelpAboutFragment.kt
View File

@ -53,7 +53,7 @@ class VectorSettingsHelpAboutFragment : VectorSettingsBaseFragment() {
} }


// application version // application version
(findPreference(PreferencesManager.SETTINGS_VERSION_PREFERENCE_KEY)).let { (findPreference(VectorPreferences.SETTINGS_VERSION_PREFERENCE_KEY)).let {
it.summary = getVersion(longFormat = false, useBuildNumber = true) it.summary = getVersion(longFormat = false, useBuildNumber = true)


it.setOnPreferenceClickListener { pref -> it.setOnPreferenceClickListener { pref ->
@ -63,7 +63,7 @@ class VectorSettingsHelpAboutFragment : VectorSettingsBaseFragment() {
} }


// SDK version // SDK version
(findPreference(PreferencesManager.SETTINGS_SDK_VERSION_PREFERENCE_KEY)).let { (findPreference(VectorPreferences.SETTINGS_SDK_VERSION_PREFERENCE_KEY)).let {
it.summary = Matrix.getSdkVersion() it.summary = Matrix.getSdkVersion()


it.setOnPreferenceClickListener { pref -> it.setOnPreferenceClickListener { pref ->
@ -73,38 +73,38 @@ class VectorSettingsHelpAboutFragment : VectorSettingsBaseFragment() {
} }


// olm version // olm version
findPreference(PreferencesManager.SETTINGS_OLM_VERSION_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_OLM_VERSION_PREFERENCE_KEY)
.summary = session.getCryptoVersion(requireContext(), false) .summary = session.getCryptoVersion(requireContext(), false)


// copyright // copyright
findPreference(PreferencesManager.SETTINGS_COPYRIGHT_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_COPYRIGHT_PREFERENCE_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
activity?.displayInWebView(VectorSettingsUrls.COPYRIGHT) activity?.displayInWebView(VectorSettingsUrls.COPYRIGHT)
false false
} }


// terms & conditions // terms & conditions
findPreference(PreferencesManager.SETTINGS_APP_TERM_CONDITIONS_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_APP_TERM_CONDITIONS_PREFERENCE_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
activity?.displayInWebView(VectorSettingsUrls.TAC) activity?.displayInWebView(VectorSettingsUrls.TAC)
false false
} }


// privacy policy // privacy policy
findPreference(PreferencesManager.SETTINGS_PRIVACY_POLICY_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_PRIVACY_POLICY_PREFERENCE_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
activity?.displayInWebView(VectorSettingsUrls.PRIVACY_POLICY) activity?.displayInWebView(VectorSettingsUrls.PRIVACY_POLICY)
false false
} }


// third party notice // third party notice
findPreference(PreferencesManager.SETTINGS_THIRD_PARTY_NOTICES_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_THIRD_PARTY_NOTICES_PREFERENCE_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
activity?.displayInWebView(VectorSettingsUrls.THIRD_PARTY_LICENSES) activity?.displayInWebView(VectorSettingsUrls.THIRD_PARTY_LICENSES)
false false
} }


findPreference(PreferencesManager.SETTINGS_OTHER_THIRD_PARTY_NOTICES_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_OTHER_THIRD_PARTY_NOTICES_PREFERENCE_KEY)
.onPreferenceClickListener = Preference.OnPreferenceClickListener { .onPreferenceClickListener = Preference.OnPreferenceClickListener {
// See https://developers.google.com/android/guides/opensource // See https://developers.google.com/android/guides/opensource
startActivity(Intent(requireActivity(), OssLicensesMenuActivity::class.java)) startActivity(Intent(requireActivity(), OssLicensesMenuActivity::class.java))

4
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsIgnoredUsersFragment.kt
View File

@ -34,10 +34,10 @@ class VectorSettingsIgnoredUsersFragment : VectorSettingsBaseFragment() {


// displayed the ignored users list // displayed the ignored users list
private val mIgnoredUserSettingsCategoryDivider by lazy { private val mIgnoredUserSettingsCategoryDivider by lazy {
findPreference(PreferencesManager.SETTINGS_IGNORE_USERS_DIVIDER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_IGNORE_USERS_DIVIDER_PREFERENCE_KEY)
} }
private val mIgnoredUserSettingsCategory by lazy { private val mIgnoredUserSettingsCategory by lazy {
findPreference(PreferencesManager.SETTINGS_IGNORED_USERS_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_IGNORED_USERS_PREFERENCE_KEY) as PreferenceCategory
} }


override fun bindPref() { override fun bindPref() {

6
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsLabsFragment.kt
View File

@ -25,8 +25,8 @@ class VectorSettingsLabsFragment : VectorSettingsBaseFragment() {


override fun bindPref() { override fun bindPref() {
// Lab // Lab
// val useCryptoPref = findPreference(PreferencesManager.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_PREFERENCE_KEY) as SwitchPreference // val useCryptoPref = findPreference(VectorPreferences.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_PREFERENCE_KEY) as SwitchPreference
// val cryptoIsEnabledPref = findPreference(PreferencesManager.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_IS_ACTIVE_PREFERENCE_KEY) // val cryptoIsEnabledPref = findPreference(VectorPreferences.SETTINGS_ROOM_SETTINGS_LABS_END_TO_END_IS_ACTIVE_PREFERENCE_KEY)




if (session.isCryptoEnabled()) { if (session.isCryptoEnabled()) {
@ -102,7 +102,7 @@ class VectorSettingsLabsFragment : VectorSettingsBaseFragment() {
} }


// SaveMode Management // SaveMode Management
// findPreference(PreferencesManager.SETTINGS_DATA_SAVE_MODE_PREFERENCE_KEY) // findPreference(VectorPreferences.SETTINGS_DATA_SAVE_MODE_PREFERENCE_KEY)
// .onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue -> // .onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
// notImplemented() // notImplemented()
// /* TODO // /* TODO

10
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsNotificationFragment.kt
View File

@ -38,7 +38,7 @@ class VectorSettingsNotificationPreferenceFragment : VectorSettingsBaseFragment(
@Inject lateinit var activeSessionHolder: ActiveSessionHolder @Inject lateinit var activeSessionHolder: ActiveSessionHolder


override fun bindPref() { override fun bindPref() {
findPreference(PreferencesManager.SETTINGS_ENABLE_ALL_NOTIF_PREFERENCE_KEY).let { pref -> findPreference(VectorPreferences.SETTINGS_ENABLE_ALL_NOTIF_PREFERENCE_KEY).let { pref ->
val pushRuleService = session val pushRuleService = session
val mRuleMaster = pushRuleService.getPushRules() val mRuleMaster = pushRuleService.getPushRules()
.find { it.ruleId == RuleIds.RULE_ID_DISABLE_ALL } .find { it.ruleId == RuleIds.RULE_ID_DISABLE_ALL }
@ -65,15 +65,15 @@ class VectorSettingsNotificationPreferenceFragment : VectorSettingsBaseFragment(
override fun onPreferenceTreeClick(preference: Preference?): Boolean { override fun onPreferenceTreeClick(preference: Preference?): Boolean {


return when (preference?.key) { return when (preference?.key) {
PreferencesManager.SETTINGS_ENABLE_THIS_DEVICE_PREFERENCE_KEY -> { VectorPreferences.SETTINGS_ENABLE_THIS_DEVICE_PREFERENCE_KEY -> {
updateEnabledForDevice(preference) updateEnabledForDevice(preference)
true true
} }
PreferencesManager.SETTINGS_ENABLE_ALL_NOTIF_PREFERENCE_KEY -> { VectorPreferences.SETTINGS_ENABLE_ALL_NOTIF_PREFERENCE_KEY -> {
updateEnabledForAccount(preference) updateEnabledForAccount(preference)
true true
} }
else -> { else -> {
return super.onPreferenceTreeClick(preference) return super.onPreferenceTreeClick(preference)
} }
} }
@ -84,7 +84,7 @@ class VectorSettingsNotificationPreferenceFragment : VectorSettingsBaseFragment(
val switchPref = preference as SwitchPreference val switchPref = preference as SwitchPreference
if (switchPref.isChecked) { if (switchPref.isChecked) {
FcmHelper.getFcmToken(requireContext())?.let { FcmHelper.getFcmToken(requireContext())?.let {
if (PreferencesManager.areNotificationEnabledForDevice(requireContext())) { if (VectorPreferences.areNotificationEnabledForDevice(requireContext())) {
pushManager.registerPusherWithFcmKey(it) pushManager.registerPusherWithFcmKey(it)
} }
} }

16
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsPreferencesFragment.kt
View File

@ -37,10 +37,10 @@ class VectorSettingsPreferencesFragment : VectorSettingsBaseFragment() {
override val preferenceXmlRes = R.xml.vector_settings_preferences override val preferenceXmlRes = R.xml.vector_settings_preferences


private val selectedLanguagePreference by lazy { private val selectedLanguagePreference by lazy {
findPreference(PreferencesManager.SETTINGS_INTERFACE_LANGUAGE_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_INTERFACE_LANGUAGE_PREFERENCE_KEY)
} }
private val textSizePreference by lazy { private val textSizePreference by lazy {
findPreference(PreferencesManager.SETTINGS_INTERFACE_TEXT_SIZE_KEY) findPreference(VectorPreferences.SETTINGS_INTERFACE_TEXT_SIZE_KEY)
} }


@Inject lateinit var vectorConfiguration: VectorConfiguration @Inject lateinit var vectorConfiguration: VectorConfiguration
@ -72,7 +72,7 @@ class VectorSettingsPreferencesFragment : VectorSettingsBaseFragment() {
} }


// Url preview // Url preview
(findPreference(PreferencesManager.SETTINGS_SHOW_URL_PREVIEW_KEY) as SwitchPreference).let { (findPreference(VectorPreferences.SETTINGS_SHOW_URL_PREVIEW_KEY) as SwitchPreference).let {
/* /*
TODO TODO
it.isChecked = session.isURLPreviewEnabled it.isChecked = session.isURLPreviewEnabled
@ -112,18 +112,18 @@ class VectorSettingsPreferencesFragment : VectorSettingsBaseFragment() {
} }


// update keep medias period // update keep medias period
findPreference(PreferencesManager.SETTINGS_MEDIA_SAVING_PERIOD_KEY).let { findPreference(VectorPreferences.SETTINGS_MEDIA_SAVING_PERIOD_KEY).let {
it.summary = PreferencesManager.getSelectedMediasSavingPeriodString(requireContext()) it.summary = VectorPreferences.getSelectedMediasSavingPeriodString(requireContext())


it.onPreferenceClickListener = Preference.OnPreferenceClickListener { it.onPreferenceClickListener = Preference.OnPreferenceClickListener {
context?.let { context: Context -> context?.let { context: Context ->
AlertDialog.Builder(context) AlertDialog.Builder(context)
.setSingleChoiceItems(R.array.media_saving_choice, .setSingleChoiceItems(R.array.media_saving_choice,
PreferencesManager.getSelectedMediasSavingPeriod(context)) { d, n -> VectorPreferences.getSelectedMediasSavingPeriod(context)) { d, n ->
PreferencesManager.setSelectedMediasSavingPeriod(context, n) VectorPreferences.setSelectedMediasSavingPeriod(context, n)
d.cancel() d.cancel()


it.summary = PreferencesManager.getSelectedMediasSavingPeriodString(context) it.summary = VectorPreferences.getSelectedMediasSavingPeriodString(context)
} }
.show() .show()
} }

42
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsSecurityPrivacyFragment.kt
View File

@ -74,57 +74,57 @@ class VectorSettingsSecurityPrivacyFragment : VectorSettingsBaseFragment() {


// cryptography // cryptography
private val mCryptographyCategory by lazy { private val mCryptographyCategory by lazy {
findPreference(PreferencesManager.SETTINGS_CRYPTOGRAPHY_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_CRYPTOGRAPHY_PREFERENCE_KEY) as PreferenceCategory
} }
private val mCryptographyCategoryDivider by lazy { private val mCryptographyCategoryDivider by lazy {
findPreference(PreferencesManager.SETTINGS_CRYPTOGRAPHY_DIVIDER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_CRYPTOGRAPHY_DIVIDER_PREFERENCE_KEY)
} }
// cryptography manage // cryptography manage
private val mCryptographyManageCategory by lazy { private val mCryptographyManageCategory by lazy {
findPreference(PreferencesManager.SETTINGS_CRYPTOGRAPHY_MANAGE_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_CRYPTOGRAPHY_MANAGE_PREFERENCE_KEY) as PreferenceCategory
} }
private val mCryptographyManageCategoryDivider by lazy { private val mCryptographyManageCategoryDivider by lazy {
findPreference(PreferencesManager.SETTINGS_CRYPTOGRAPHY_MANAGE_DIVIDER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_CRYPTOGRAPHY_MANAGE_DIVIDER_PREFERENCE_KEY)
} }
// displayed pushers // displayed pushers
private val mPushersSettingsDivider by lazy { private val mPushersSettingsDivider by lazy {
findPreference(PreferencesManager.SETTINGS_NOTIFICATIONS_TARGET_DIVIDER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_NOTIFICATIONS_TARGET_DIVIDER_PREFERENCE_KEY)
} }
private val mPushersSettingsCategory by lazy { private val mPushersSettingsCategory by lazy {
findPreference(PreferencesManager.SETTINGS_NOTIFICATIONS_TARGETS_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_NOTIFICATIONS_TARGETS_PREFERENCE_KEY) as PreferenceCategory
} }
private val mDevicesListSettingsCategory by lazy { private val mDevicesListSettingsCategory by lazy {
findPreference(PreferencesManager.SETTINGS_DEVICES_LIST_PREFERENCE_KEY) as PreferenceCategory findPreference(VectorPreferences.SETTINGS_DEVICES_LIST_PREFERENCE_KEY) as PreferenceCategory
} }
private val mDevicesListSettingsCategoryDivider by lazy { private val mDevicesListSettingsCategoryDivider by lazy {
findPreference(PreferencesManager.SETTINGS_DEVICES_DIVIDER_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_DEVICES_DIVIDER_PREFERENCE_KEY)
} }
private val cryptoInfoDeviceNamePreference by lazy { private val cryptoInfoDeviceNamePreference by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_NAME_PREFERENCE_KEY) as VectorPreference findPreference(VectorPreferences.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_NAME_PREFERENCE_KEY) as VectorPreference
} }


private val cryptoInfoDeviceIdPreference by lazy { private val cryptoInfoDeviceIdPreference by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_ID_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_ID_PREFERENCE_KEY)
} }


private val manageBackupPref by lazy { private val manageBackupPref by lazy {
findPreference(PreferencesManager.SETTINGS_SECURE_MESSAGE_RECOVERY_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_SECURE_MESSAGE_RECOVERY_PREFERENCE_KEY)
} }


private val exportPref by lazy { private val exportPref by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_EXPORT_E2E_ROOM_KEYS_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_ENCRYPTION_EXPORT_E2E_ROOM_KEYS_PREFERENCE_KEY)
} }


private val importPref by lazy { private val importPref by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_IMPORT_E2E_ROOM_KEYS_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_ENCRYPTION_IMPORT_E2E_ROOM_KEYS_PREFERENCE_KEY)
} }


private val cryptoInfoTextPreference by lazy { private val cryptoInfoTextPreference by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_KEY_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_ENCRYPTION_INFORMATION_DEVICE_KEY_PREFERENCE_KEY)
} }
// encrypt to unverified devices // encrypt to unverified devices
private val sendToUnverifiedDevicesPref by lazy { private val sendToUnverifiedDevicesPref by lazy {
findPreference(PreferencesManager.SETTINGS_ENCRYPTION_NEVER_SENT_TO_PREFERENCE_KEY) as SwitchPreference findPreference(VectorPreferences.SETTINGS_ENCRYPTION_NEVER_SENT_TO_PREFERENCE_KEY) as SwitchPreference
} }


override fun bindPref() { override fun bindPref() {
@ -140,22 +140,22 @@ class VectorSettingsSecurityPrivacyFragment : VectorSettingsBaseFragment() {
// Analytics // Analytics


// Analytics tracking management // Analytics tracking management
(findPreference(PreferencesManager.SETTINGS_USE_ANALYTICS_KEY) as SwitchPreference).let { (findPreference(VectorPreferences.SETTINGS_USE_ANALYTICS_KEY) as SwitchPreference).let {
// On if the analytics tracking is activated // On if the analytics tracking is activated
it.isChecked = PreferencesManager.useAnalytics(requireContext()) it.isChecked = VectorPreferences.useAnalytics(requireContext())


it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue -> it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
PreferencesManager.setUseAnalytics(requireContext(), newValue as Boolean) VectorPreferences.setUseAnalytics(requireContext(), newValue as Boolean)
true true
} }
} }


// Rageshake Management // Rageshake Management
(findPreference(PreferencesManager.SETTINGS_USE_RAGE_SHAKE_KEY) as SwitchPreference).let { (findPreference(VectorPreferences.SETTINGS_USE_RAGE_SHAKE_KEY) as SwitchPreference).let {
it.isChecked = PreferencesManager.useRageshake(requireContext()) it.isChecked = VectorPreferences.useRageshake(requireContext())


it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue -> it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
PreferencesManager.setUseRageshake(requireContext(), newValue as Boolean) VectorPreferences.setUseRageshake(requireContext(), newValue as Boolean)
true true
} }
} }

4
vector/src/main/java/im/vector/riotx/features/settings/VectorSettingsVoiceVideoFragment.kt
View File

@ -34,10 +34,10 @@ class VectorSettingsVoiceVideoFragment : VectorSettingsBaseFragment() {
override val preferenceXmlRes = R.xml.vector_settings_voice_video override val preferenceXmlRes = R.xml.vector_settings_voice_video


private val mUseRiotCallRingtonePreference by lazy { private val mUseRiotCallRingtonePreference by lazy {
findPreference(PreferencesManager.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY) as SwitchPreference findPreference(VectorPreferences.SETTINGS_CALL_RINGTONE_USE_RIOT_PREFERENCE_KEY) as SwitchPreference
} }
private val mCallRingtonePreference by lazy { private val mCallRingtonePreference by lazy {
findPreference(PreferencesManager.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY) findPreference(VectorPreferences.SETTINGS_CALL_RINGTONE_URI_PREFERENCE_KEY)
} }


override fun bindPref() { override fun bindPref() {

2
vector/src/main/java/im/vector/riotx/features/settings/troubleshoot/TestBingRulesSettings.kt
View File

@ -72,7 +72,7 @@ class TestBingRulesSettings @Inject constructor(private val activeSessionHolder:
// override fun doFix() { // override fun doFix() {
// val activity = fragment.activity // val activity = fragment.activity
// if (activity is VectorSettingsFragmentInteractionListener) { // if (activity is VectorSettingsFragmentInteractionListener) {
// activity.requestHighlightPreferenceKeyOnResume(PreferencesManager.SETTINGS_NOTIFICATION_ADVANCED_PREFERENCE_KEY) // activity.requestHighlightPreferenceKeyOnResume(VectorPreferences.SETTINGS_NOTIFICATION_ADVANCED_PREFERENCE_KEY)
// } // }
// activity?.supportFragmentManager?.popBackStack() // activity?.supportFragmentManager?.popBackStack()
// } // }

6
vector/src/main/java/im/vector/riotx/features/settings/troubleshoot/TestDeviceSettings.kt
View File

@ -18,7 +18,7 @@ package im.vector.riotx.features.settings.troubleshoot
import androidx.appcompat.app.AppCompatActivity import androidx.appcompat.app.AppCompatActivity
import im.vector.riotx.R import im.vector.riotx.R
import im.vector.riotx.core.resources.StringProvider import im.vector.riotx.core.resources.StringProvider
import im.vector.riotx.features.settings.PreferencesManager import im.vector.riotx.features.settings.VectorPreferences
import javax.inject.Inject import javax.inject.Inject


/** /**
@ -30,14 +30,14 @@ class TestDeviceSettings @Inject constructor(private val context: AppCompatActiv


override fun perform() { override fun perform() {


if (PreferencesManager.areNotificationEnabledForDevice(context)) { if (VectorPreferences.areNotificationEnabledForDevice(context)) {
description = stringProvider.getString(R.string.settings_troubleshoot_test_device_settings_success) description = stringProvider.getString(R.string.settings_troubleshoot_test_device_settings_success)
quickFix = null quickFix = null
status = TestStatus.SUCCESS status = TestStatus.SUCCESS
} else { } else {
quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_device_settings_quickfix) { quickFix = object : TroubleshootQuickFix(R.string.settings_troubleshoot_test_device_settings_quickfix) {
override fun doFix() { override fun doFix() {
PreferencesManager.setNotificationEnabledForDevice(context, true) VectorPreferences.setNotificationEnabledForDevice(context, true)
manager?.retry() manager?.retry()
} }
} }