WIP

app/src/main/java/org/thoughtcrime/securesms/components/SwitchPreferenceCompat.kt

@@ -3,11 +3,9 @@ package org.thoughtcrime.securesms.components
 import android.content.Context
 import android.util.AttributeSet
 import androidx.preference.CheckBoxPreference
-import com.squareup.phrase.Phrase
 import network.loki.messenger.R
 import org.session.libsession.utilities.StringSubstitutionConstants.APP_NAME_KEY
 import org.thoughtcrime.securesms.ui.getSubbedCharSequence
-import org.thoughtcrime.securesms.ui.getSubbedString
 
 class SwitchPreferenceCompat : CheckBoxPreference {
     private var listener: OnPreferenceClickListener? = null

app/src/main/java/org/thoughtcrime/securesms/preferences/CorrectedPreferenceFragment.java

@@ -1,6 +1,5 @@
 package org.thoughtcrime.securesms.preferences;
 
-
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Typeface;
@@ -9,11 +8,9 @@ import android.os.Bundle;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
 import androidx.core.content.ContextCompat;
 import androidx.core.view.ViewCompat;
-import androidx.fragment.app.DialogFragment;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceCategory;
 import androidx.preference.PreferenceFragmentCompat;
@@ -21,8 +18,8 @@ import androidx.preference.PreferenceGroupAdapter;
 import androidx.preference.PreferenceScreen;
 import androidx.preference.PreferenceViewHolder;
 import androidx.recyclerview.widget.RecyclerView;
-import org.thoughtcrime.securesms.conversation.v2.ViewUtil;
 import network.loki.messenger.R;
+import org.thoughtcrime.securesms.conversation.v2.ViewUtil;
 
 public abstract class CorrectedPreferenceFragment extends PreferenceFragmentCompat {
 

app/src/main/java/org/thoughtcrime/securesms/util/DateUtils.kt

@@ -20,10 +20,8 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.os.Build
 import android.text.format.DateFormat
-import androidx.compose.ui.text.capitalize
+import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsignal.utilities.Log
-import java.text.DateFormat.SHORT
-import java.text.DateFormat.getTimeInstance
 import java.text.ParseException
 import java.text.SimpleDateFormat
 import java.util.Calendar
@@ -44,6 +42,14 @@ object DateUtils : android.text.format.DateUtils() {
     private val DAY_PRECISION_DATE_FORMAT = SimpleDateFormat("yyyyMMdd")
     private val HOUR_PRECISION_DATE_FORMAT = SimpleDateFormat("yyyyMMddHH")
 
+    // Preferred date and time formats for the user - these are stored in the user's preferences.
+    // We set them as invalid on startup (range is 0..8 and 0..2 respectively) so we only have to
+    // retrieve the preference once rather than every time we wish to format a date or time.
+    // See: TextSecurePreferences.DATE_FORMAT_PREF and TextSecurePreferences for further details.
+    private var userPreferredDateFormat: Int = -1
+    private var userPreferredTimeFormat: Int = 2//-1
+
+
     private fun isWithin(millis: Long, span: Long, unit: TimeUnit): Boolean {
         return System.currentTimeMillis() - millis <= unit.toMillis(span)
     }
@@ -82,27 +88,110 @@ object DateUtils : android.text.format.DateUtils() {
             FORMAT_SHOW_DATE).toString()
     }
 
+    // THIS IS THE METHOD THAT ACTUALLY GETS USED TO GET THE DATE TIME
     fun getFormattedDateTime(time: Long, template: String, locale: Locale): String {
         val localizedPattern = getLocalizedPattern(template, locale)
         return SimpleDateFormat(localizedPattern, locale).format(Date(time))
     }
 
-    fun getHourFormat(c: Context?): String {
+    // Method to get the user's preferred time format, whether that's 12-hour or 24-hour
-        return if ((DateFormat.is24HourFormat(c))) "HH:mm" else "hh:mm a"
+    fun getHourFormat(c: Context): String {
+        // If this is the first run..
+        if (userPreferredTimeFormat == -1) {
+            // ..update our preferred time format (will return -1 if no saved pref).
+            userPreferredTimeFormat = TextSecurePreferences.getTimeFormatPref(c)
+
+            // If no saved value was written we'll write 0 for "Follow system setting" - this will only run on first install
+            if (userPreferredTimeFormat == -1) {
+                userPreferredTimeFormat = 0
+                TextSecurePreferences.setTimeFormatPref(c, userPreferredTimeFormat)
+            }
+
+            // If the preferred time format is "Follow system setting" then we need to find out what the system setting is!
+            if (userPreferredTimeFormat == 0) {
+                val is24HourFormat = DateFormat.is24HourFormat(c)
+
+                // Set the time format we'll use to either 24 or 12 hours.
+                // IMPORTANT: We don't WRITE this to the pref - we just use it while the app is running!
+                // Note: See TextSecurePreferences.TIME_FORMAT_PREF for further details of available formats.
+                userPreferredTimeFormat = if (is24HourFormat) 2 else 1
+            }
+        }
+
+        // At this point userPreferredTimeFormat will ALWAYS be either 1 or 2 - regardless of if the saved
+        // pref is 0 to "Follow system settings".
+        return if (userPreferredTimeFormat == 1) "hh:mm a" else "HH:mm"
     }
 
     fun getDisplayFormattedTimeSpanString(c: Context, locale: Locale, timestamp: Long): String {
-        // If the timestamp is within the last 24 hours we just give the time, e.g, "1:23 PM" or
+        // Note: Date-formats are in TR-35 format.
-        // "13:23" depending on 12/24 hour formatting.
+        // See: https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns
-        return if (isToday(timestamp)) {
+        val t = if (isToday(timestamp)) {
+            Log.w("ACL", "Within today")
+            // If it's within the last 24 hours we just give the time in 24-hour format, such as "13:27" for 1:27pm
             getFormattedDateTime(timestamp, getHourFormat(c), locale)
         } else if (isWithin(timestamp, 6, TimeUnit.DAYS)) {
+            Log.w("ACL", "Within week")
+            // If it's within the last week we give the day as 3 letters then the time in 24-hour format, such as "Fri 13:27" for Friday 1:27pm
             getFormattedDateTime(timestamp, "EEE " + getHourFormat(c), locale)
         } else if (isWithin(timestamp, 365, TimeUnit.DAYS)) {
+            Log.w("ACL", "Within year")
+            // If it's within the last year we give the month as 3 letters then the time in 24-hour format, such as "Mar 13:27" for March 1:27pm
+            // CAREFUL: "MMM d + getHourFormat(c)" actually turns out to be "8 July, 17:14" etc. - it is DAY-NUMBER and then MONTH (which can go up to 4 chars) - and THEN the time. Wild.
             getFormattedDateTime(timestamp, "MMM d " + getHourFormat(c), locale)
         } else {
+            // NOTE: The `userPreferredDateFormat` is ONLY ever used on dates which exceed one year!
+            // See the Figma linked in SES-360 for details.
+
+
+            Log.w("ACL", "More than 1 year")
+            // If the date is more than a year ago then we get "19 July 2023, 16:19" type format
+
+            // If this is the first run..
+            if (userPreferredDateFormat == -1) {
+                // ..update our preferred date format (will return -1 if no saved pref).
+                userPreferredDateFormat = TextSecurePreferences.getDateFormatPref(c)
+
+                // If no saved value was written we'll write 0 for "Follow system setting" - this will only run on first install
+                if (userPreferredDateFormat == -1) {
+                    userPreferredDateFormat = 0
+                    //TextSecurePreferences.setDateFormatPref(c, userPreferredDateFormat) ACL PUT THIS BACK!!!!!!!!!!!!!!!!!!!!!
+                }
+
+                // If the preferred date format is "Follow system setting" then we need to find out what the system setting is!
+                if (userPreferredDateFormat == 0) {
+                    val dateFormat = DateFormat.getDateFormat(c)
+
+                    // Check if the DateFormat instance is a SimpleDateFormat
+                    if (dateFormat is SimpleDateFormat) {
+                        Log.w("ACL", "Date pattern: " + dateFormat.toPattern())
+
+                        when (dateFormat) {
+                            "M/d/yy" -> FFS
+                        }
+
+
+                    } else {
+                        // If the dateFormat isn't a SimpleDateFormat from which we can extract a pattern then the best
+                        // we can do is pick a sensible default like DD/MM/YYYY - which equates to option 3 out of our
+                        // available options (see TextSecurePreferences.DATE_FORMAT_PREF for further details).
+                        userPreferredDateFormat = 3
+                        // IMPORTANT: We don't WRITE this to the pref - we just use it while the app is running!
+                    }
+
+                    // Set the time format we'll use to either 24 or 12 hours.
+                    // IMPORTANT: We don't WRITE this to the pref - we just use it while the app is running!
+                    // Note: See TextSecurePreferences.TIME_FORMAT_PREF for further details of available formats.
+                    //userPreferredTimeFormat = if (is24HourFormat) 2 else 1
+                }
+            }
+
             getFormattedDateTime(timestamp, "MMM d " + getHourFormat(c) + ", yyyy", locale)
         }
+
+        Log.w("ACL", "t is: $t")
+        return t
+
     }
 
     fun getDetailedDateFormatter(context: Context?, locale: Locale): SimpleDateFormat {

libsession/src/main/java/org/session/libsession/utilities/TextSecurePreferences.kt

@@ -310,6 +310,26 @@ interface TextSecurePreferences {
         // for the lifetime of the Session installation.
         const val HAVE_WARNED_USER_ABOUT_SAVING_ATTACHMENTS = "libsession.HAVE_WARNED_USER_ABOUT_SAVING_ATTACHMENTS"
 
+        // Key name for the user's preferred date format as an Int. See ticket SES-360 for further details & Figma design.
+        // Values for various formats are as follows:
+        //      0 - Follow system settings (default)
+        //      1 - M/D/YY         - example: 1/2/24     (which is 2nd Jan 2024),  or 12/25/24   (which is 25th Dec 2024)
+        //      2 - D/M/YY         - example: 2/1/24     (which is 2nd Jan 2024),  or 25/12/24   (which is 25th Dec 2024)
+        //      3 - DD/MM/YYYY     - example: 02/01/2024 (which is 2nd Jan 2024),  or 25/12/2024 (which is 25th Dec 2024)
+        //      4 - DD.MM.YYYY     - example: 02.01.2024 (which is 2nd Jan 2024),  or 25.12.2024 (which is 25th Dec 2024)
+        //      5 - DD-MM-YYYY     - example: 02-01-2024 (which is 2nd Jan 2024),  or 25-12-2024 (which is 25th Dec 2024)
+        //      6 - YYYY/M/D       - example: 2024/1/2   (which is 2nd Jan 2024),  or 2024/12/25 (which is 25th Dec 2024)
+        //      7 - YYYY.M.D       - example: 2024.1.2   (which is 2nd Jan 2024),  or 2024.12.25 (which is 25th Dec 2024)
+        //      8 - YYYY-M-D       - example: 2024-1-2   (which is 2nd Jan 2024),  or 2024-12-25 (which is 25th Dec 2024)
+        const val DATE_FORMAT_PREF = "libsession.DATE_FORMAT_PREF"
+
+        // Key name for the user's preferred time format as an Int
+        // Values for various formats are as follows:
+        //      0 - Follow system settings (default)
+        //      1 - 12h - example: 3:45 PM
+        //      2 - 24h - example: 15:45
+        const val TIME_FORMAT_PREF = "libsession.TIME_FORMAT_PREF"
+
         @JvmStatic
         fun getLastConfigurationSyncTime(context: Context): Long {
             return getLongPreference(context, LAST_CONFIGURATION_SYNC_TIME, 0)
@@ -990,8 +1010,14 @@ interface TextSecurePreferences {
             setBooleanPreference(context, FINGERPRINT_KEY_GENERATED, true)
         }
 
+        @JvmStatic
+        fun clearAll(context: Context) {
+            getDefaultSharedPreferences(context).edit().clear().commit()
+        }
+
 
         // ----- Get / set methods for if we have already warned the user that saving attachments will allow other apps to access them -----
+        // Note: We only ever show the warning dialog about this ONCE - when the user accepts this fact we write true to the flag & never show again.
         @JvmStatic
         fun getHaveWarnedUserAboutSavingAttachments(context: Context): Boolean {
             return getBooleanPreference(context, HAVE_WARNED_USER_ABOUT_SAVING_ATTACHMENTS, false)
@@ -1001,12 +1027,26 @@ interface TextSecurePreferences {
         fun setHaveWarnedUserAboutSavingAttachments(context: Context) {
             setBooleanPreference(context, HAVE_WARNED_USER_ABOUT_SAVING_ATTACHMENTS, true)
         }
-        // ---------------------------------------------------------------------------------------------------------------------------------
+
+        // ----- Get / set methods for the user's date format preference -----
+        @JvmStatic
+        fun getDateFormatPref(context: Context): Int {
+            // Note: 0 means "follow system setting" (default) - go to the declaration of DATE_FORMAT_PREF for further details.
+            return getIntegerPreference(context, DATE_FORMAT_PREF, -1)
+        }
 
         @JvmStatic
-        fun clearAll(context: Context) {
+        fun setDateFormatPref(context: Context, value: Int) { setIntegerPreference(context, DATE_FORMAT_PREF, value) }
-            getDefaultSharedPreferences(context).edit().clear().commit()
+
+        // ----- Get / set methods for the user's time format preference -----
+        @JvmStatic
+        fun getTimeFormatPref(context: Context): Int {
+            // Note: 0 means "follow system setting" (default) - go to the declaration of TIME_FORMAT_PREF for further details.
+            return getIntegerPreference(context, TIME_FORMAT_PREF, -1)
         }
+
+        @JvmStatic
+        fun setTimeFormatPref(context: Context, value: Int) { setIntegerPreference(context, TIME_FORMAT_PREF, value) }
     }
 }