Merge remote-tracking branch 'origin/dev' into release/1.27.1

# Conflicts:
#	app/build.gradle.kts

Author: SessionHero01

.github/workflows/build_and_test.yml

@@ -25,7 +25,7 @@ jobs:
           - variant: 'play'
             run_test: true
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           submodules: 'recursive'
 
@@ -38,14 +38,14 @@ jobs:
           key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties', 'gradle.properties') }}-${{ matrix.variant }}
 
       - name: Set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           distribution: 'temurin'
           java-version: '21'
 
       - name: Build with gradle
         id: build
-        run: ./gradlew assemble${{ matrix.variant }}${{ matrix.build_type }} ${{ matrix.extra_build_command_options }}
+        run: ./gradlew assemble${{ matrix.variant }}${{ matrix.build_type }} ${{ matrix.extra_build_command_options }} --stacktrace
 
       - name: Run unit tests
         if: ${{ matrix.run_test == true }}

app/build.gradle.kts

@@ -12,6 +12,7 @@ plugins {
     alias(libs.plugins.hilt.android)
     alias(libs.plugins.dependency.analysis)
     alias(libs.plugins.google.services)
+    alias(libs.plugins.protobuf.compiler)
 
     id("generate-ip-country-data")
     id("rename-apk")
@@ -47,6 +48,7 @@ val getGitHash = providers
 
 val firebaseEnabledVariants = listOf("play", "fdroid")
 val nonPlayVariants = listOf("fdroid", "website") + if (huaweiEnabled) listOf("huawei") else emptyList()
+val nonDebugBuildTypes = listOf("release", "qa", "automaticQa")
 
 fun VariantDimension.devNetDefaultOn(defaultOn: Boolean) {
     val fqEnumClass = "org.session.libsession.utilities.Environment"
@@ -84,6 +86,23 @@ kotlin {
     }
 }
 
+protobuf {
+    protoc {
+        artifact = libs.protoc.get().toString()
+    }
+
+    plugins {
+        generateProtoTasks {
+            all().forEach {
+                it.builtins {
+                    create("java") {
+                    }
+                }
+            }
+        }
+    }
+}
+
 android {
     namespace = "network.loki.messenger"
     useLibrary("org.apache.http.legacy")
@@ -114,10 +133,6 @@ android {
         buildConfig = true
     }
 
-    composeOptions {
-        kotlinCompilerExtensionVersion = libs.versions.kotlinComposeCompilerVersion.get()
-    }
-
     defaultConfig {
         versionCode = canonicalVersionCode * postFixSize
         versionName = canonicalVersionName
@@ -208,6 +223,14 @@ android {
                 resources.srcDirs("$nonPlayCommonDir/resources")
             }
         }
+
+        val nonDebugDir = "src/nonDebug"
+        nonDebugBuildTypes.forEach { buildType ->
+            maybeCreate(buildType).apply {
+                java.srcDirs("$nonDebugDir/kotlin")
+                resources.srcDirs("$nonDebugDir/resources")
+            }
+        }
     }
 
 
@@ -329,6 +352,7 @@ dependencies {
     implementation(libs.androidx.activity.compose)
     implementation(libs.androidx.fragment.ktx)
     implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.interpolator)
 
     // Add firebase dependencies to specific variants
     for (variant in firebaseEnabledVariants) {
@@ -355,15 +379,13 @@ dependencies {
     implementation(libs.android)
     implementation(libs.photoview)
     implementation(libs.glide)
-    implementation(libs.compose)
-    implementation(libs.eventbus)
+    implementation(libs.glide.compose)
+    implementation(libs.coil.compose)
+    implementation(libs.coil.gif)
     implementation(libs.android.image.cropper)
     implementation(libs.subsampling.scale.image.view) {
         exclude(group = "com.android.support", module = "support-annotations")
     }
-    implementation(libs.tooltips) {
-        exclude(group = "com.android.support", module = "appcompat-v7")
-    }
     implementation(libs.stream)
     implementation(libs.androidx.sqlite.ktx)
     implementation(libs.sqlcipher.android)
@@ -450,6 +472,8 @@ dependencies {
     implementation(libs.zxing.core)
 
     implementation(libs.androidx.biometric)
+
+    debugImplementation(libs.sqlite.web.viewer)
 }
 
 fun getLastCommitTimestamp(): String {

app/src/debug/kotlin/org/thoughtcrime/securesms/debugmenu/DatabaseInspector.kt

@@ -0,0 +1,56 @@
+package org.thoughtcrime.securesms.debugmenu
+
+import dev.fanchao.sqliteviewer.StartedInstance
+import dev.fanchao.sqliteviewer.model.SupportQueryable
+import dev.fanchao.sqliteviewer.startDatabaseViewerServer
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import org.thoughtcrime.securesms.database.helpers.SQLCipherOpenHelper
+import org.thoughtcrime.securesms.dependencies.ManagerScope
+import org.thoughtcrime.securesms.util.CurrentActivityObserver
+import javax.inject.Inject
+import javax.inject.Provider
+import javax.inject.Singleton
+
+@Singleton
+class DatabaseInspector @Inject constructor(
+    @param:ManagerScope private val coroutineScope: CoroutineScope,
+    private val currentActivityObserver: CurrentActivityObserver,
+    private val openHelper: Provider<SQLCipherOpenHelper>,
+) {
+    val available: Boolean get() = true
+
+    private val instance = MutableStateFlow<StartedInstance?>(null)
+
+    val enabled: StateFlow<Boolean> = instance
+        .flatMapLatest { st ->
+            st?.state?.map {
+                it is StartedInstance.State.Running
+            } ?: flowOf(false)
+        }
+        .stateIn(coroutineScope, SharingStarted.Eagerly, false)
+
+    fun start() {
+        instance.update { inst ->
+            inst?.takeIf { it.state.value !is StartedInstance.State.Stopped } ?: startDatabaseViewerServer(
+                currentActivityObserver.currentActivity.value!!,
+                port = 3000,
+                queryable = SupportQueryable(openHelper.get().writableDatabase)
+            )
+        }
+    }
+
+    fun stop() {
+        instance.update {
+            it?.stop()
+            null
+        }
+    }
+}

app/src/main/AndroidManifest.xml

@@ -167,6 +167,10 @@
             android:theme="@style/Theme.Session.DayNight.NoActionBar"
             android:label="@string/sessionSettings"
             android:screenOrientation="portrait" />
+        <activity
+            android:name="org.thoughtcrime.securesms.preferences.prosettings.ProSettingsActivity"
+            android:theme="@style/Theme.Session.DayNight.NoActionBar"
+            android:screenOrientation="portrait" />
         <activity
             android:name="org.thoughtcrime.securesms.recoverypassword.RecoveryPasswordActivity"
             android:screenOrientation="portrait" />
@@ -395,14 +399,6 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_provider_paths" />
         </provider>
-        <provider
-            android:name="org.thoughtcrime.securesms.database.DatabaseContentProviders$Conversation"
-            android:authorities="network.loki.securesms.database.conversation${authority_postfix}"
-            android:exported="false" />
-        <provider
-            android:name="org.thoughtcrime.securesms.database.DatabaseContentProviders$ConversationList"
-            android:authorities="network.loki.securesms.database.conversationlist${authority_postfix}"
-            android:exported="false" />
         <provider
             android:name="org.thoughtcrime.securesms.database.DatabaseContentProviders$Attachment"
             android:authorities="network.loki.securesms.database.attachment${authority_postfix}"
@@ -415,10 +411,6 @@
             android:name="org.thoughtcrime.securesms.database.DatabaseContentProviders$StickerPack"
             android:authorities="network.loki.securesms.database.stickerpack${authority_postfix}"
             android:exported="false" />
-        <provider
-            android:name="org.thoughtcrime.securesms.database.DatabaseContentProviders$Recipient"
-            android:authorities="network.loki.securesms.database.recipient${authority_postfix}"
-            android:exported="false" />
 
         <receiver android:name="org.thoughtcrime.securesms.service.BootReceiver"
             android:exported="true">

app/src/main/java/org/session/libsession/avatars/AvatarCacheCleaner.kt

@@ -0,0 +1,69 @@
+package org.session.libsession.avatars
+
+import android.app.Application
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.session.libsession.utilities.recipients.RemoteFile
+import org.session.libsignal.utilities.Log
+import org.thoughtcrime.securesms.attachments.RemoteFileDownloadWorker
+import org.thoughtcrime.securesms.database.RecipientSettingsDatabase
+import org.thoughtcrime.securesms.dependencies.ManagerScope
+import org.thoughtcrime.securesms.glide.RecipientAvatarDownloadManager
+import java.io.File
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AvatarCacheCleaner @Inject constructor(
+    private val application: Application,
+    private val recipientAvatarDownloadManager: RecipientAvatarDownloadManager,
+    private val recipientSettingsDatabase: RecipientSettingsDatabase,
+    @param:ManagerScope private val coroutineScope: CoroutineScope
+) {
+
+    companion object {
+        const val TAG = "AvatarCacheCleaner"
+    }
+
+    /**
+     * Deletes avatar files under cache/remote_files that are no longer referenced
+     * in the current config. Returns number of files deleted.
+     */
+    private suspend fun cleanUpAvatars(): Int = withContext(Dispatchers.IO) {
+        // 1) Build the set of still-wanted Avatars from:
+        // -> Config
+        // -> Recipient Settings DB
+
+        // config
+        val avatarsFromConfig: Set<RemoteFile> = recipientAvatarDownloadManager.getAllAvatars()
+        // recipient_settings
+        val recipientAvatars : Set<RemoteFile> = recipientSettingsDatabase.getAllReferencedAvatarFiles()
+
+        // 3) Union of everything we want to keep
+        val filesToKeep: Set<RemoteFile> =
+            (avatarsFromConfig + recipientAvatars).toSet()
+
+        // 4) Map to actual files (same hashing/location as downloader)
+        val wantedFiles: Set<File> = filesToKeep
+            .map { RemoteFileDownloadWorker.computeFileName(application, it) }
+            .toSet()
+
+        // 5) Delete everything not wanted in cache/remote_files
+        val files = RemoteFileDownloadWorker.listDownloadedFiles(application)
+        var deleted = 0
+        for (file in files) {
+            if (file !in wantedFiles && file.delete()) deleted++
+        }
+
+        deleted
+    }
+
+    fun launchAvatarCleanup() {
+        coroutineScope.launch(Dispatchers.IO) {
+            val deleted = cleanUpAvatars()
+            Log.d(TAG, "Avatar cache removed: $deleted files")
+        }
+    }
+}

app/src/main/java/org/session/libsession/avatars/AvatarHelper.java

@@ -19,6 +19,15 @@
 import java.util.LinkedList;
 import java.util.List;
 
+/**
+ * @deprecated We no longer use these address-based avatars. All avatars are now stored as sha256 of
+ * urls encrypted locally. Look at {@link org.thoughtcrime.securesms.attachments.LocalEncryptedFileOutputStream},
+ * {@link org.thoughtcrime.securesms.attachments.RemoteFileDownloadWorker},
+ * {@link org.thoughtcrime.securesms.glide.RecipientAvatarDownloadManager} for more information.
+ *
+ * Once the migration grace period is over, this class shall be removed.
+ */
+@Deprecated(forRemoval = true)
 public class AvatarHelper {
 
   private static final String AVATAR_DIRECTORY = "avatars";