fix(PR): Auto Open stabilization and Spotlight/Story video download fixes by Kaladin

Auto Open stabilization and Spotlight/Story video download fixes.

app/src/main/kotlin/me/eternal/purrfectsnap/download/FFMpegProcessor.kt

@@ -146,8 +146,8 @@ class FFMpegProcessor(
 
         val outputArguments = ArgumentList().apply {
             this += "-preset" to (ffmpegOptions.preset.getNullable() ?: "ultrafast")
-            this += "-c:v" to (ffmpegOptions.customVideoCodec.get().takeIf { it.isNotEmpty() } ?: "libx264")
-            this += "-c:a" to (ffmpegOptions.customAudioCodec.get().takeIf { it.isNotEmpty() } ?: "copy")
+            this += "-c:v" to (ffmpegOptions.customVideoCodec.get().takeIf { it.isNotEmpty() }?.lowercase() ?: "libx264")
+            this += "-c:a" to (ffmpegOptions.customAudioCodec.get().takeIf { it.isNotEmpty() }?.lowercase() ?: "copy")
             this += "-crf" to ffmpegOptions.constantRateFactor.get().let { "\"$it\"" }
             this += "-b:v" to ffmpegOptions.videoBitrate.get().toString() + "K"
             this += "-b:a" to ffmpegOptions.audioBitrate.get().toString() + "K"

app/src/main/kotlin/me/eternal/purrfectsnap/ui/util/AndroidDialogCustom.kt

@@ -466,22 +466,26 @@ private class DialogWrapper(
         this.onDismissRequest = onDismissRequest
         this.properties = properties
         setLayoutDirection(layoutDirection)
-        if (properties.usePlatformDefaultWidth && !dialogLayout.usePlatformDefaultWidth) {
+        val dialogWindow = window
+        val canUpdateWindowLayout = dialogWindow?.decorView?.let { decorView ->
+            isShowing && decorView.isAttachedToWindow && decorView.windowToken != null
+        } == true
+        if (canUpdateWindowLayout && properties.usePlatformDefaultWidth && !dialogLayout.usePlatformDefaultWidth) {
             // Undo fixed size in internalOnLayout, which would suppress size changes when
             // usePlatformDefaultWidth is true.
-            window?.setLayout(
+            dialogWindow.setLayout(
                 WindowManager.LayoutParams.WRAP_CONTENT,
                 WindowManager.LayoutParams.WRAP_CONTENT
             )
         }
         dialogLayout.usePlatformDefaultWidth = properties.usePlatformDefaultWidth
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+        if (canUpdateWindowLayout && Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
             @OptIn(ExperimentalComposeUiApi::class)
             if (properties.decorFitsSystemWindows) {
-                window?.setSoftInputMode(defaultSoftInputMode)
+                dialogWindow?.setSoftInputMode(defaultSoftInputMode)
             } else {
                 @Suppress("DEPRECATION")
-                window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
+                dialogWindow?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)
             }
         }
     }

build.gradle.kts

@@ -33,8 +33,8 @@ tasks.register<GetVersionTask>("getVersion") {
 }
 
 // You can still set these for legacy use by submodules or scripts:
-rootProject.ext.set("appVersionName", providers.gradleProperty("APP_VERSION_NAME").orElse("1.6.6").get())
-rootProject.ext.set("appVersionCode", providers.gradleProperty("APP_VERSION_CODE").orElse("322").get().toInt())
+rootProject.ext.set("appVersionName", providers.gradleProperty("APP_VERSION_NAME").orElse("1.6.8").get())
+rootProject.ext.set("appVersionCode", providers.gradleProperty("APP_VERSION_CODE").orElse("324").get().toInt())
 rootProject.ext.set("applicationId", "me.eternal.purrfectsnap")
 // buildHash: when PurrfectSnap or Snapchat is updated, mappings become outdated and auto-regenerate.
 // Include version code so each release has a different hash; use random for uniqueness within same version.

changelogs-stable.txt

@@ -1,3 +1,18 @@
+## v1.6.8
+- Fix: Many improvements to the Performance Mode feature(Max, turned on by Default), changes are pretty noticeable: faster loading of chats, long group messages optimizations, many snapmap optimizations
+- Fix: Crash issues for some devices
+- Fix: Block Ads
+- Fix: Snapchat automatically restarting if kept idle
+- Fix: Feed Flickering issue for some devices
+- Fix: Implemented Dual-Thread Sync Architecture with a 1,000 depth that proactively scans the database for missed history, thus resolving the "failed to open..." and "Tap to load" snaps before marking them, clearing historical gaps automatically(tq to Kaladin)
+- New: Implemented Screen Guard where Auto Open Engine now detects screen state and stops all notification work while the device is locked, thus reducing excessive battery drain and heat spike during background processing(tq to Kaladin)
+- Fix: Disk read/write frequency increased from 1s to 5 minutes, to eliminate constant background disk friction, thus reducing overheating of the device while processing(tq to Kaladin)
+- Fix: Slid chat switching delays from 2.0s down to 40ms, thus achieving near-instant processing of 1000+ snap bursts(tq to Kaladin)
+- Fix: Removed "Auto Open pause while Gaming" toggle(tq to Kaladin)
+- Fix: Reworked "Snap Pre-Fetch" toggle to the global Messaging settings page(tq to Kaladin)
+- Fix: Refactored Auto Open engine notification cards to declutter it and removed redundant stats(tq to Kaladin)
+- Fix: Corrected speed labels in the Auto Open notification to show "Idle" when monitoring and accurate notions (Full Speed/Throttled) when active(tq to Kaladin)
+
 ## v1.6.6
 - Fix: Persistent auto open snap disabled notification(tq to Kaladin)
 - Fix: Crash issues for some devices

common/src/main/assets/lang/en_US.json

@@ -1481,6 +1481,7 @@
                         "name": "Bypass Message Action Restrictions",
                         "description": "Allows you to react to a snap without having opened it or to save an unsaveable message"
                     },
+                    "pre_fetch_snaps": { "name": "Snap Pre-Fetch", "description": "Fetches snap media into Snapchat's internal cache once the snap arrives. Note: Turning it on increases background data usage." },
                     "remove_groups_locked_status": {
                         "name": "Remove Groups Locked Status",
                         "description": "Allows you to view group information after being kicked"
@@ -1696,7 +1697,6 @@
                                 "description": "Automatically throttles the engine and increases delays if the device temperature exceeds 40°C to prevent overheating"
                             },
                             "only_on_wifi": { "name": "Auto Open only on Wi-Fi", "description": "Only process queue when connected to a Wi-Fi network to save mobile data" },
-                            "pre_fetch_snaps": { "name": "Pre-fetch Snaps", "description": "Fetches snap media into Snapchat's internal cache once the snap arrives. Note: Turning it on increases background data usage." },
                             "content_type_snap": "Snap",
                             "only_when_idle": {
                                 "name": "Auto Open Schedule",
@@ -1706,10 +1706,14 @@
                                 "name": "Auto Open Scheduler",
                                 "description": "Define the start and end times for scheduled throttled processing."
                             },
-                            "pause_during_gaming": { "name": "Pause Auto Open During Gaming", "description": "Automatically slow down processing when a resource intensive app or a game is in the foreground" },
                             "safe_processing": { "name": "Auto Open with stealth pace", "description": "Adds variable delays and natural breaks to remain undetected. Turn off for maximum speed." }
                         }
                     },
+                    "pre_fetch_snaps": { "name": "Snap Pre-Fetch", "description": "Fetches snap media into Snapchat's internal cache once the snap arrives. Note: Turning it on increases background data usage." },
+                    "instant_translation": {
+                        "name": "Message Translator",
+                        "description": "Configure the message translator"
+                    },
                     "auto_delete_sent_messages": {
                         "name": "Auto Delete Sent Messages",
                         "description": "Automatically deletes sent messages after a specified time period",
@@ -3677,12 +3681,13 @@
         "failed_gallery_toast": "Failed saving to gallery {error}",
         "dash_no_chapter": "No chapter found",
         "dash_dialog": {
-            "title": "Download dash media",
+            "title": "DASH Download",
             "download_all": "Download All",
-            "segment_text": "Segment {from} - {to}"
+            "snap_text": "Snap {from} - {to}"
         },
         "story_snap_dialog": {
             "title": "Download story snaps",
+            "download_all": "Download All",
             "select_all": "Select All",
             "deselect_all": "Deselect All",
             "snap_item": "Snap {index} of {total}"

common/src/main/kotlin/me/eternal/purrfectsnap/common/config/impl/MessagingTweaks.kt

@@ -180,10 +180,7 @@ class MessagingTweaks : ConfigContainer() {
         val showQueuePreview = boolean("show_queue_preview", true)
         val thermalProtection = boolean("thermal_protection", false)
         
-        // Resource Intelligence: Smart triggers for battery and data safety
         val onlyOnWifi = boolean("only_on_wifi", false)
-        val preFetchSnaps = boolean("pre_fetch_snaps", false)
-        val pauseDuringGaming = boolean("pause_during_gaming", false)
         val safeProcessing = boolean("safe_processing", true)
         val onlyWhenIdle = boolean("only_when_idle", false)
         val sleepWindow = string("sleep_window", defaultValue = "23:00-07:00") {
@@ -210,6 +207,38 @@ class MessagingTweaks : ConfigContainer() {
         val showNotification = boolean("show_notification", defaultValue = true)
     }
 
+    class InstantTranslationConfig : ConfigContainer(hasGlobalState = true) {
+        val enabled = boolean("enabled", false)
+        val sourceLanguage = string("source_language", defaultValue = "auto") {
+            inputCheck = { it.isNotBlank() }
+        }
+        val targetLanguage = string("target_language", defaultValue = "en") {
+            inputCheck = { it.isNotBlank() }
+        }
+        val showOriginal = boolean("show_original", defaultValue = true)
+        val showTranslation = boolean("show_translation", defaultValue = true)
+        val translationPosition = unique("translation_position", "above", "below", "inline") {
+            customOptionTranslationPath = "translation_position"
+        }.apply { set("below") }
+        val autoTranslate = boolean("auto_translate", defaultValue = true)
+        val translateOnTap = boolean("translate_on_tap", defaultValue = false)
+        val pauseOnError = boolean("pause_on_error", defaultValue = true)
+        val maxRetries = integer("max_retries", defaultValue = 3) {
+            inputCheck = { it.toIntOrNull()?.coerceIn(1, 10) != null }
+        }
+        val retryDelay = integer("retry_delay", defaultValue = 1000) {
+            inputCheck = { it.toIntOrNull()?.coerceAtLeast(500) != null }
+        }
+
+        val supportedLanguages = multiple("supported_languages",
+            "en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh", "ar", "hi", "tr", "nl", "pl", "sv", "da", "no", "fi", "cs", "hu", "ro", "bg", "hr", "sk", "sl", "et", "lv", "lt", "mt", "ga", "cy"
+        ) {
+            customOptionTranslationPath = "language_codes"
+        }.apply {
+            set(mutableListOf("en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh", "ar", "hi", "tr"))
+        }
+    }
+
     val bypassScreenshotDetection = boolean("bypass_screenshot_detection") { requireRestart() }
     val anonymousStoryViewing = boolean("anonymous_story_viewing")
     val preventStoryRewatchIndicator = boolean("prevent_story_rewatch_indicator") { requireRestart() }
@@ -297,40 +326,9 @@ class MessagingTweaks : ConfigContainer() {
     val doubleTapChatActionCustomEmoji = string("double_tap_chat_action_custom_emoji") {
         inputCheck = { it.length == 2 && it.toByteArray(Charsets.UTF_8).size >= 4 } }
     val autoReply = container("auto_reply", AutoReplyConfig()) { requireRestart() }
-    val autoOpenSnaps = container("auto_open_snaps", AutoOpenSnapsConfig()) { requireRestart(); addNotices(FeatureNotice.BAN_RISK, FeatureNotice.UNSTABLE) }
     val autoDeleteSentMessages = container("auto_delete_sent_messages", AutoDeleteSentMessagesConfig()) { requireRestart() }
     
-    class InstantTranslationConfig : ConfigContainer(hasGlobalState = true) {
-        val enabled = boolean("enabled", false)
-        val sourceLanguage = string("source_language", defaultValue = "auto") {
-            inputCheck = { it.isNotBlank() }
-        }
-        val targetLanguage = string("target_language", defaultValue = "en") {
-            inputCheck = { it.isNotBlank() }
-        }
-        val showOriginal = boolean("show_original", defaultValue = true)
-        val showTranslation = boolean("show_translation", defaultValue = true)
-        val translationPosition = unique("translation_position", "above", "below", "inline") {
-            customOptionTranslationPath = "translation_position"
-        }.apply { set("below") }
-        val autoTranslate = boolean("auto_translate", defaultValue = true)
-        val translateOnTap = boolean("translate_on_tap", defaultValue = false)
-        val pauseOnError = boolean("pause_on_error", defaultValue = true)
-        val maxRetries = integer("max_retries", defaultValue = 3) {
-            inputCheck = { it.toIntOrNull()?.coerceIn(1, 10) != null }
-        }
-        val retryDelay = integer("retry_delay", defaultValue = 1000) {
-            inputCheck = { it.toIntOrNull()?.coerceAtLeast(500) != null }
-        }
-
-        val supportedLanguages = multiple("supported_languages",
-            "en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh", "ar", "hi", "tr", "nl", "pl", "sv", "da", "no", "fi", "cs", "hu", "ro", "bg", "hr", "sk", "sl", "et", "lv", "lt", "mt", "ga", "cy"
-        ) {
-            customOptionTranslationPath = "language_codes"
-        }.apply {
-            set(mutableListOf("en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "zh", "ar", "hi", "tr"))
-        }
-    }
-    
+    val autoOpenSnaps = container("auto_open_snaps", AutoOpenSnapsConfig()) { requireRestart(); addNotices(FeatureNotice.BAN_RISK, FeatureNotice.UNSTABLE) }
+    val preFetchSnaps = boolean("pre_fetch_snaps", false)
     val instantTranslation = container("instant_translation", InstantTranslationConfig()) { requireRestart() }
 }

common/src/main/kotlin/me/eternal/purrfectsnap/common/data/FileType.kt

@@ -72,24 +72,10 @@ enum class FileType(
             if (majorBrand in imageBrands) return false
 
             return majorBrand in setOf(
-                "mp41",
-                "mp42",
-                "isom",
-                "iso2",
-                "iso3",
-                "iso4",
-                "iso5",
-                "iso6",
-                "avc1",
-                "dash",
-                "cmfc",
-                "msnv",
-                "3gp4",
-                "3gp5",
-                "3gp6",
-                "3g2a",
-                "3g2b"
-            ) || majorBrand.isNotEmpty() // FALLBACK: If it has the ftyp box and isn't a known image brand, it's a video
+                "mp41", "mp42", "isom", "iso2", "iso3", "iso4", "iso5", "iso6",
+                "avc1", "dash", "cmfc", "msnv", "3gp4", "3gp5", "3gp6", "3g2a", "3g2b",
+                "mp4v", "mp4a", "m4v ", "m4a ", "f4v ", "f4a "
+            ) || majorBrand.isNotEmpty()
         }
 
         fun fromFile(file: File): FileType {

core/src/main/kotlin/me/eternal/purrfectsnap/core/bridge/BridgeClient.kt

@@ -168,11 +168,10 @@ class BridgeClient(
                 Log.d("BridgeClient", "service is dead, restarting")
                 val canLoad = connect {
                     Log.e("BridgeClient", "connection failed", it)
-                    context.softRestartApp()
                 }
                 if (canLoad != true) {
                     Log.e("BridgeClient", "failed to reconnect to service, result=$canLoad")
-                    context.softRestartApp()
+                    return@runBlocking
                 }
             }
         }
@@ -188,9 +187,6 @@ class BridgeClient(
                     block()
                 }.getOrElse {
                     Log.e("BridgeClient", "service call failed", it)
-                    if (it is DeadObjectException) {
-                        context.softRestartApp()
-                    }
                     throw it
                 }
             }

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/FeatureManager.kt

@@ -80,6 +80,7 @@ class FeatureManager(
             MessageLogger(),
             ConvertMessageLocally(),
             SnapchatPlus(),
+            AdBlockFix(),
             DisableMetrics(),
             EndpointsBlocker(),
             PreventMessageSending(),

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/ConfigurationOverride.kt

@@ -109,6 +109,10 @@ class ConfigurationOverride : Feature("Configuration Override") {
                 { true })
             overrideProperty("MEDIA_RECORDER_MAX_QUALITY_LEVEL", { context.config.camera.forceCameraSourceEncoding.get() },
                 { true })
+            overrideProperty("ENABLE_MESSAGE_WINDOW_MANAGER", { context.config.global.performanceMode.profile.getNullable() != null },
+                { true })
+            overrideProperty("ENABLE_SIMPLE_CONVERSATION_RESET", { context.config.global.performanceMode.profile.getNullable() == "max" },
+                { false })
             overrideProperty("PREVIEW_PRELOAD_ACTIVATOR", { context.config.global.performanceMode.profile.getNullable() != null },
                 { true })
             overrideProperty("BUFFERED_VIDEO_RECORDING_ACTIVATOR", { context.config.global.performanceMode.profile.getNullable() != null },
@@ -120,27 +124,32 @@ class ConfigurationOverride : Feature("Configuration Override") {
 
             arrayOf(
                 "FEATURE_PRELOADER",
-                "USER_STORY_PRELOAD",
-                "STARTUP_LENS_ACTIVATOR",
-                "LENSES_PREVIEW_ACTIVATOR",
-                "THUMBNAIL_PRESENTER_ACTIVATOR",
-                "SINGLE_SEGMENT_THUMBNAIL_ACTIVATOR",
                 "SERVER_PREFETCH",
                 "SERVER_PREFETCH_WITH_COF",
                 "DISCOVER_FEED_PERFORMANCE",
-                "DISCOVER_FEED_STORY_PREFETCH",
-                "DISCOVER_FEED_THUMBNAILS",
                 "LOGIN_PRELOAD",
                 "PREFETCH_REPO_SUBSCRIBE_ON_CPU",
                 "COMPUTE_FEED_CACHE_WITH_TTL",
                 "COMPUTE_FEED_NETWORK_WITH_CACHE",
                 "OPERA_WARMUP",
-                "REFACTORED_WITH_WARMUP_LENS",
                 "SHOW_PREFETCH",
             ).forEach { key ->
                 overrideProperty(key, { context.config.global.performanceMode.profile.getNullable() != null }, { true })
             }
 
+            arrayOf(
+                "USER_STORY_PRELOAD",
+                "STARTUP_LENS_ACTIVATOR",
+                "LENSES_PREVIEW_ACTIVATOR",
+                "THUMBNAIL_PRESENTER_ACTIVATOR",
+                "SINGLE_SEGMENT_THUMBNAIL_ACTIVATOR",
+                "DISCOVER_FEED_STORY_PREFETCH",
+                "DISCOVER_FEED_THUMBNAILS",
+                "REFACTORED_WITH_WARMUP_LENS",
+            ).forEach { key ->
+                overrideProperty(key, { context.config.global.performanceMode.profile.getNullable() == "max" }, { false })
+            }
+
             overrideProperty("LOAD_LATENCY_TRACKER_ACTIVATOR", { context.config.global.performanceMode.profile.getNullable() != null },
                 { false })
             overrideProperty("ANALYTICS_ACTIVATOR", { context.config.global.performanceMode.profile.getNullable() != null },

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/downloader/MediaDownloader.kt

@@ -166,7 +166,29 @@ class MediaDownloader : MessagingRuleFeature("MediaDownloader", MessagingRuleTyp
             callback = object: DownloadCallback.Stub() {
                 override fun onSuccess(outputFile: String) {
                     if (!downloadLogging.contains("success")) return
-                    context.log.verbose("onSuccess: outputFile=$outputFile")
+                    
+                    var finalOutputFile = outputFile
+                    runCatching {
+                        val file = java.io.File(outputFile)
+                        if (file.exists()) {
+                            val header = file.inputStream().use { input ->
+                                val buffer = ByteArray(16)
+                                input.read(buffer)
+                                buffer
+                            }
+                            val fileType = FileType.fromByteArray(header)
+                            if (fileType.isVideo && !outputFile.endsWith(".mp4", ignoreCase = true)) {
+                                val newPath = outputFile.removeSuffix(".dat") + ".mp4"
+                                val newFile = java.io.File(newPath)
+                                if (file.renameTo(newFile)) {
+                                    finalOutputFile = newPath
+                                    context.log.verbose("corrected video extension: $outputFile -> $newPath")
+                                }
+                            }
+                        }
+                    }
+
+                    context.log.verbose("onSuccess: outputFile=$finalOutputFile")
                     context.inAppOverlay.showStatusToast(
                         icon = Icons.Outlined.DownloadDone,
                         durationMs = 1300,
@@ -685,74 +707,120 @@ class MediaDownloader : MessagingRuleFeature("MediaDownloader", MessagingRuleTyp
             }
 
             context.runOnUiThread {
-                val selectedChapters = mutableListOf<Int>()
-                val dialogTranslation = translations.getCategory("dash_dialog")
+                val tr = context.translation.getCategory("download_processor.dash_dialog")
                 val chapters = snapChapterList.mapIndexed { index, snapChapter ->
                     val nextChapter = snapChapterList.getOrNull(index + 1)
                     val duration = nextChapter?.startTimeMs?.minus(snapChapter.startTimeMs)
                     SnapChapterInfo(snapChapter.startTimeMs, duration)
                 }
-                ViewAppearanceHelper.newAlertDialogBuilder(context.mainActivity!!).apply {
-                    setTitle(dialogTranslation["title"])
-                    setMultiChoiceItems(
-                        chapters.map { dialogTranslation.format("segment_text", "from" to prettyPrintTime(it.offset), "to" to prettyPrintTime(it.offset + (it.duration ?: 0))) }.toTypedArray(),
-                        List(chapters.size) { index ->
-                            if (currentChapterIndex == index) {
-                                selectedChapters.add(index)
-                                true
-                            } else false
-                        }.toBooleanArray()
-                    ) { _, which, isChecked ->
-                        if (isChecked) {
-                            selectedChapters.add(which)
-                        } else if (selectedChapters.contains(which)) {
-                            selectedChapters.remove(which)
-                        }
-                    }
-                    setNegativeButton(this@MediaDownloader.context.translation["button.cancel"]) { dialog, _ -> dialog.dismiss() }
-                    setNeutralButton(dialogTranslation["download_all"]) { _, _ ->
-                        provideDownloadManagerClient(
-                            mediaIdentifier = paramMap["STORY_ID"].toString(),
-                            downloadSource = MediaDownloadSource.PUBLIC_STORY,
-                            mediaAuthor = storyName
-                        ).downloadDashMedia(playlistUrl, 0, null)
-                    }
-                    setPositiveButton(this@MediaDownloader.context.translation["button.download"]) { _, _ ->
-                        val groups = mutableListOf<MutableList<SnapChapterInfo>>()
+                val cancelStr = context.translation["button.cancel"]
+                val downloadStr = context.translation["button.download"]
 
-                        var lastChapterIndex = -1
-                        // group consecutive chapters
-                        chapters.forEachIndexed { index, snapChapter ->
-                            lastChapterIndex = if (selectedChapters.contains(index)) {
-                                if (lastChapterIndex == -1) {
-                                    groups.add(mutableListOf())
+                createComposeAlertDialog(context.mainActivity!!) { alertDialog ->
+                    PurrfectOverlayTheme {
+                        val selected = remember { mutableStateListOf<Int>().apply { add(currentChapterIndex) } }
+                        PurrfectGlassCard(
+                            title = tr["title"],
+                            modifier = Modifier.fillMaxWidth()
+                        ) {
+                            Column(
+                                modifier = Modifier.fillMaxWidth(),
+                                verticalArrangement = Arrangement.spacedBy(12.dp)
+                            ) {
+                                LazyColumn(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .heightIn(min = 120.dp, max = 320.dp)
+                                        .background(Color.White.copy(alpha = 0.08f), RoundedCornerShape(14.dp))
+                                        .padding(8.dp),
+                                    verticalArrangement = Arrangement.spacedBy(4.dp)
+                                ) {
+                                    itemsIndexed(chapters) { index, item ->
+                                        val label = tr.format("snap_text", "from" to prettyPrintTime(item.offset), "to" to prettyPrintTime(item.offset + (item.duration ?: 0)))
+                                        Row(
+                                            modifier = Modifier
+                                                .fillMaxWidth()
+                                                .padding(vertical = 10.dp, horizontal = 8.dp),
+                                            verticalAlignment = Alignment.CenterVertically,
+                                            horizontalArrangement = Arrangement.spacedBy(12.dp)
+                                        ) {
+                                            Checkbox(
+                                                checked = selected.contains(index),
+                                                onCheckedChange = { checked ->
+                                                    if (checked) selected.add(index) else selected.remove(index)
+                                                },
+                                                colors = CheckboxDefaults.colors(checkedColor = PurrfectOverlayPalette.glowPrimary)
+                                            )
+                                            Text(
+                                                label,
+                                                style = MaterialTheme.typography.bodyMedium,
+                                                color = PurrfectOverlayPalette.textPrimary
+                                            )
+                                        }
+                                    }
                                 }
-                                groups.last().add(snapChapter)
-                                index
-                            } else {
-                                -1
-                            }
-                        }
 
-                        groups.forEach { group ->
-                            val firstChapter = group.first()
-                            val lastChapter = group.last()
-                            val duration = if (firstChapter == lastChapter) {
-                                firstChapter.duration
-                            } else {
-                                lastChapter.duration?.let { lastChapter.offset - firstChapter.offset + it }
-                            }
+                                Row(verticalAlignment = Alignment.CenterVertically) {
+                                    Checkbox(
+                                        checked = selected.size == chapters.size,
+                                        onCheckedChange = { checked ->
+                                            if (checked) {
+                                                selected.clear()
+                                                selected.addAll(0 until chapters.size)
+                                            } else {
+                                                selected.clear()
+                                            }
+                                        },
+                                        colors = CheckboxDefaults.colors(checkedColor = PurrfectOverlayPalette.glowPrimary)
+                                    )
+                                    Text(
+                                        tr["download_all"] ?: "Select All",
+                                        style = MaterialTheme.typography.bodyMedium,
+                                        color = PurrfectOverlayPalette.textPrimary
+                                    )
+                                }
 
-                            provideDownloadManagerClient(
-                                mediaIdentifier = "${paramMap["STORY_ID"]}-${firstChapter.offset}-${lastChapter.offset}",
-                                downloadSource = MediaDownloadSource.PUBLIC_STORY,
-                                mediaAuthor = storyName,
-                                forceAllowDuplicate = forceAllowDuplicate,
-                            ).downloadDashMedia(
-                                playlistUrl,
-                                firstChapter.offset.plus(100),
-                                duration
-                            )
+                                Row(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    horizontalArrangement = Arrangement.spacedBy(12.dp),
+                                    verticalAlignment = Alignment.CenterVertically
+                                ) {
+                                    OutlinedButton(
+                                        onClick = { alertDialog.dismiss() },
+                                        modifier = Modifier.weight(1f),
+                                        shape = RoundedCornerShape(14.dp),
+                                        colors = ButtonDefaults.outlinedButtonColors(contentColor = PurrfectOverlayPalette.textPrimary)
+                                    ) {
+                                        Text(cancelStr)
+                                    }
+                                    Button(
+                                        onClick = {
+                                            val groups = mutableListOf<MutableList<SnapChapterInfo>>()
+                                            var lastIdx = -1
+                                            chapters.forEachIndexed { index, info ->
+                                                if (selected.contains(index)) {
+                                                    if (lastIdx == -1 || index != lastIdx + 1) groups.add(mutableListOf())
+                                                    groups.last().add(info)
+                                                    lastIdx = index
+                                                }
+                                            }
+                                            groups.forEach { group ->
+                                                val first = group.first()
+                                                val last = group.last()
+                                                val duration = if (first == last) first.duration else last.duration?.let { last.offset - first.offset + it }
+                                                provideDownloadManagerClient("${paramMap["STORY_ID"]}-${first.offset}", storyName, null, MediaDownloadSource.PUBLIC_STORY, null, forceAllowDuplicate)
+                                                    .downloadDashMedia(playlistUrl, first.offset.plus(100), duration)
+                                            }
+                                            alertDialog.dismiss()
+                                        },
+                                        modifier = Modifier.weight(1f),
+                                        shape = RoundedCornerShape(14.dp),
+                                        colors = ButtonDefaults.buttonColors(containerColor = PurrfectOverlayPalette.glowPrimary)
+                                    ) {
+                                        Text(downloadStr)
+                                    }
+                                }
+                            }
                         }
                     }
                 }.show()

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/experiments/AutoOpenSnaps.kt

@@ -34,6 +34,7 @@ import me.eternal.purrfectsnap.core.util.hook.HookStage
 import me.eternal.purrfectsnap.core.util.hook.hook
 import me.eternal.purrfectsnap.core.util.hook.hookConstructor
 import java.util.*
+import java.util.Objects
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
@@ -48,87 +49,76 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
         private const val STATUS_NOTIFICATION_ID = 54321
         private const val NOTIFICATION_GROUP_KEY = "purrfectsnap.AUTO_OPEN"
         private const val PREF_TOTAL_OPENED = "auto_open_total_opened"
-        private const val PREF_TOTAL_DETECTED = "auto_open_total_detected"
         private const val PREF_SESSION_START = "auto_open_session_start"
         private const val PREF_SAVED_QUEUE = "auto_open_saved_queue"
     }
 
     private val gson = Gson()
     private val isPaused = AtomicBoolean(false)
-    private val totalProcessed = AtomicInteger(0)
-    private val totalDetected = AtomicInteger(0)
-    private val sessionProcessed = AtomicInteger(0)
+    private val totalProcessed = AtomicInteger(0) 
+    private val sessionProcessed = AtomicInteger(0) 
     private val sessionStartTime = AtomicLong(System.currentTimeMillis())
     private val totalPausedDuration = AtomicLong(0)
     private var lastPausedAt = AtomicLong(0)
     private val averageProcessingTime = AtomicLong(800)
     private val hasBeenActive = AtomicBoolean(false)
+    private val isScreenOn = AtomicBoolean(true)
 
     private val snapQueue = MutableSharedFlow<Long>(extraBufferCapacity = 100)
     private val openedSnaps = ConcurrentHashMap.newKeySet<Long>()
     private val queuedSnaps = mutableListOf<SnapQueueItem>()
     private val deadLetterQueue = mutableListOf<SnapQueueItem>()
 
-    private val nameCache = ConcurrentHashMap<String, String>()
-    private val conversationTypeCache = ConcurrentHashMap<String, String>()
+    private val metadataCache = Collections.synchronizedMap(object : LinkedHashMap<String, String>() {
+        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, String>?): Boolean = size > 500
+    })
 
     private val config by lazy { context.config.messaging.autoOpenSnaps }
     private val notificationManager by lazy { context.androidContext.getSystemService(NotificationManager::class.java) }
     private val prefs by lazy { context.androidContext.getSharedPreferences("me.eternal.purrfectsnap_preferences", Context.MODE_PRIVATE) }
 
     private var lastConversationId: String? = null
-    private var batchSnapCount = 0
     private var currentStatusText = "Monitoring..."
     private var currentSpeedText = "Full Speed"
     private var isCurrentlyWaiting = false
     private var wakeLock: PowerManager.WakeLock? = null
+    private var wakeLockCooldownJob: Job? = null
     private var lastQueueActivity = System.currentTimeMillis()
 
-    // Throttling & Performance fields
     private val lastNotificationUpdate = AtomicLong(0)
     private val notificationUpdateDelay = 1000L
     private val pendingNotificationUpdate = AtomicBoolean(false)
-    private val processedSinceLastSave = AtomicInteger(0)
     private val snapTimestamps = LinkedList<Long>()
     
-    // Safety & Synergy
     private val isSaving = AtomicBoolean(false)
     private val needsSaving = AtomicBoolean(false)
     private var isThermalThrottled = false
     private var lastThermalThrottleAt = 0L
 
     private fun cancelStatusNotification() {
-        runCatching {
-            notificationManager.cancel(STATUS_NOTIFICATION_ID)
-        }.onFailure {
-            context.log.warn("Failed to cancel Auto Open Snaps notification: ${it.message}")
-        }
+        runCatching { notificationManager.cancel(STATUS_NOTIFICATION_ID) }
     }
 
     data class SnapQueueItem(
         val conversationId: String,
         val messageId: Long,
+        val serverMessageId: Long?,
         val senderId: String,
         var senderName: String = "Pending...",
         var conversationType: String = "Processing",
         val contentType: String,
-        val timestamp: Long = System.currentTimeMillis(),
-        var retryCount: Int = 0
+        val timestamp: Long = System.currentTimeMillis()
     )
 
     private val autoOpenInterface = object : AutoOpenInterface.Stub() {
-        override fun getProcessedCount(): Int = totalProcessed.get()
+        override fun getProcessedCount(): Int = sessionProcessed.get()
         override fun getQueueItems(): List<String> = synchronized(queuedSnaps) { queuedSnaps.map { gson.toJson(it) } }
-        override fun reset() {
-            clearInternalState()
-        }
+        override fun reset() { clearInternalState() }
     }
 
     private fun clearInternalState() {
-        resetPersistence()
-        totalProcessed.set(0)
-        totalDetected.set(0)
         sessionProcessed.set(0)
+        totalProcessed.set(0)
         totalPausedDuration.set(0)
         lastPausedAt.set(0)
         sessionStartTime.set(System.currentTimeMillis())
@@ -137,15 +127,16 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
         openedSnaps.clear()
 
         prefs.edit()
-            .putInt(PREF_TOTAL_OPENED, 0)
-            .putInt(PREF_TOTAL_DETECTED, 0)
             .putLong(PREF_SESSION_START, System.currentTimeMillis())
             .remove(PREF_SAVED_QUEUE)
+            .remove(PREF_TOTAL_OPENED)
             .apply()
 
-        updateStatusNotification()
+        updateStatusNotification(force = true)
     }
 
+    fun getSnapMetadata(clientMessageId: Long): SnapQueueItem? = synchronized(queuedSnaps) { queuedSnaps.find { it.messageId == clientMessageId } }
+
     fun getInterface(): AutoOpenInterface = autoOpenInterface
 
     private val actionReceiver = object : BroadcastReceiver() {
@@ -154,32 +145,16 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
                 ACTION_PAUSE_RESUME -> {
                     val paused = !isPaused.get()
                     isPaused.set(paused)
-                    if (paused) {
-                        lastPausedAt.set(System.currentTimeMillis())
-                    } else {
-                        if (lastPausedAt.get() > 0) {
-                            totalPausedDuration.addAndGet(System.currentTimeMillis() - lastPausedAt.get())
-                        }
+                    if (paused) lastPausedAt.set(System.currentTimeMillis())
+                    else {
+                        if (lastPausedAt.get() > 0) totalPausedDuration.addAndGet(System.currentTimeMillis() - lastPausedAt.get())
                         snapQueue.tryEmit(System.currentTimeMillis())
                     }
-                    updateStatusNotification()
-                }
-                ACTION_CLEAR_QUEUE -> {
-                    synchronized(queuedSnaps) { 
-                        queuedSnaps.clear() 
-                    }
-                    synchronized(deadLetterQueue) { 
-                        deadLetterQueue.clear() 
-                    }
-                    
-                    // Reset session and persistent counters to zero
-                    totalProcessed.set(0)
-                    sessionProcessed.set(0)
-                    totalDetected.set(0)
-                    
-                    triggerLazySave()
-                    updateStatusNotification()
+                    updateStatusNotification(force = true)
                 }
+                ACTION_CLEAR_QUEUE -> clearInternalState()
+                Intent.ACTION_SCREEN_ON -> { isScreenOn.set(true); updateStatusNotification(force = true) }
+                Intent.ACTION_SCREEN_OFF -> isScreenOn.set(false)
             }
         }
     }
@@ -187,14 +162,7 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
     override fun init() {
         val messaging = context.feature(Messaging::class)
         restorePersistence()
-
-        // Verify configuration state before marking as active to prevent background process notification spam
-        if (config.globalState == true) {
-            hasBeenActive.set(true)
-        } else {
-            // Feature is disabled; silent exit to avoid process-wide 'Deactivated' notices
-            return
-        }
+        hasBeenActive.set(config.globalState == true)
 
         if (config.allowRunningInBackground.get()) {
             acquireWakeLock()
@@ -202,38 +170,26 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
                 hook("appStateChanged", HookStage.BEFORE) { param ->
                     if (config.allowRunningInBackground.get()) {
                         val state = param.arg<Any>(0).toString()
-                        if (state == "INACTIVE" || state == "BACKGROUND") {
-                            param.setResult(null)
-                        }
+                        if (state == "INACTIVE" || state == "BACKGROUND") param.setResult(null)
                     }
                 }
                 hookConstructor(HookStage.AFTER) { param ->
                     methods.firstOrNull { it.name == "appStateChanged" }?.let { method ->
                         val enumClass = method.parameterTypes[0]
-                        val activeState = enumClass.enumConstants?.firstOrNull { 
-                            it.toString() == "ACTIVE" || it.toString() == "FOREGROUND" 
-                        }
-                        if (activeState != null) {
-                            method.invoke(param.thisObject<Any>(), activeState)
-                        }
+                        val activeState = enumClass.enumConstants?.firstOrNull { it.toString() == "ACTIVE" || it.toString() == "FOREGROUND" }
+                        if (activeState != null) method.invoke(param.thisObject<Any>(), activeState)
                     }
                 }
             }
             findClass("com.snapchat.client.network_manager.NetworkManager\$CppProxy").apply {
-                hook("onAppForegrounded", HookStage.BEFORE) { param ->
-                    if (config.allowRunningInBackground.get()) param.setResult(null)
-                }
-                hook("onAppBackgrounded", HookStage.BEFORE) { param ->
-                    if (config.allowRunningInBackground.get()) param.setResult(null)
-                }
+                hook("onAppForegrounded", HookStage.BEFORE) { param -> if (config.allowRunningInBackground.get()) param.setResult(null) }
+                hook("onAppBackgrounded", HookStage.BEFORE) { param -> if (config.allowRunningInBackground.get()) param.setResult(null) }
             }
         }
 
         createNotificationChannels()
         val filter = IntentFilter().apply {
-            addAction(ACTION_PAUSE_RESUME)
-            addAction(ACTION_CLEAR_QUEUE)
-            addAction(Intent.ACTION_BATTERY_CHANGED)
+            addAction(ACTION_PAUSE_RESUME); addAction(ACTION_CLEAR_QUEUE); addAction(Intent.ACTION_BATTERY_CHANGED); addAction(Intent.ACTION_SCREEN_ON); addAction(Intent.ACTION_SCREEN_OFF)
         }
         
         val batteryReceiver = object : BroadcastReceiver() {
@@ -241,12 +197,9 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
                 if (intent?.action == Intent.ACTION_BATTERY_CHANGED && config.thermalProtection.get()) {
                     val temp = intent.getIntExtra("temperature", 0) / 10f
                     if (temp >= 40f && !isThermalThrottled) {
-                        isThermalThrottled = true
-                        lastThermalThrottleAt = System.currentTimeMillis()
-                        context.log.warn("[THERMAL] Device hit ${temp}C. Throttling AutoOpen.")
+                        isThermalThrottled = true; lastThermalThrottleAt = System.currentTimeMillis()
                     } else if (isThermalThrottled && temp <= 36f && System.currentTimeMillis() - lastThermalThrottleAt > 600000) {
                         isThermalThrottled = false
-                        context.log.info("[THERMAL] Device cooled to ${temp}C. Resuming full speed.")
                     }
                 }
             }
@@ -260,121 +213,69 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
             context.androidContext.registerReceiver(batteryReceiver, filter)
         }
 
-        if (synchronized(queuedSnaps) { queuedSnaps.isNotEmpty() }) {
-            snapQueue.tryEmit(System.currentTimeMillis())
-        }
+        if (synchronized(queuedSnaps) { queuedSnaps.isNotEmpty() }) snapQueue.tryEmit(System.currentTimeMillis())
 
+        // Watchdog Loop
         context.coroutineScope.launch(Dispatchers.Default) {
             while (isActive) {
-                if (config.globalState != true) {
-                    shutdownFeature()
-                    break
-                }
+                if (config.globalState != true) { shutdownFeature(); break }
                 val remainingCount = synchronized(queuedSnaps) { queuedSnaps.size }
-                if (remainingCount == 0 && sessionProcessed.get() > 0) {
-                    sessionProcessed.set(0)
-                    triggerLazySave()
-                }
                 
                 if (remainingCount > 0) {
-                    lastQueueActivity = System.currentTimeMillis()
-                    acquireWakeLock()
+                    lastQueueActivity = System.currentTimeMillis(); acquireWakeLock()
                     if (!isPaused.get()) snapQueue.tryEmit(System.currentTimeMillis())
                 } else {
-                    // IDLE REVIVAL: Check dead letter queue every 5 mins when idle
                     if (!isPaused.get() && System.currentTimeMillis() - lastQueueActivity > 300000) {
-                        val revived = synchronized(deadLetterQueue) {
-                            if (deadLetterQueue.isNotEmpty()) deadLetterQueue.removeAt(0) else null
-                        }
-                        if (revived != null) {
-                            synchronized(queuedSnaps) { queuedSnaps.add(revived) }
-                            snapQueue.tryEmit(System.currentTimeMillis())
-                        }
+                        val revived = synchronized(deadLetterQueue) { if (deadLetterQueue.isNotEmpty()) deadLetterQueue.removeAt(0) else null }
+                        if (revived != null) { synchronized(queuedSnaps) { queuedSnaps.add(revived) }; snapQueue.tryEmit(System.currentTimeMillis()) }
                     }
-                    
-                    if (System.currentTimeMillis() - lastQueueActivity > 600000) { // 10 mins true idle
-                        releaseWakeLock()
+                    if (System.currentTimeMillis() - lastQueueActivity > 300000) {
+                        startWakeLockCooldown()
                     }
                 }
-
                 updateStatusNotification()
                 delay(5000)
             }
         }
 
-        context.coroutineScope.launch(Dispatchers.Default, CoroutineStart.UNDISPATCHED) {
-            snapQueue.collect { _ ->
+        // Processing Loop
+        context.coroutineScope.launch(Dispatchers.Default) {
+            snapQueue.collect {
+                if (isPaused.get() || config.globalState != true) return@collect
                 while (isActive && config.globalState == true) {
-                    if (isPaused.get()) {
-                        delay(1000)
-                        continue
-                    }
-                    
-                    val item = synchronized(queuedSnaps) { 
-                        if (queuedSnaps.isNotEmpty()) queuedSnaps.removeAt(0) else null 
-                    } ?: break
+                    val item = synchronized(queuedSnaps) { if (queuedSnaps.isNotEmpty()) queuedSnaps.removeAt(0) else null } ?: break
 
                     var resourceWaiting = true
                     while (resourceWaiting) {
                         if (config.globalState != true || isPaused.get()) break
                         val isWifi = isWifiConnected()
                         val isIdle = isDeviceIdle()
-                        val isGaming = isGaming()
-                        val inSleepWindow = if (config.onlyWhenIdle.get()) isInsideSleepWindow() else false
+                        val onlyIdle = config.onlyWhenIdle.get()
+                        val inSleepWindow = if (onlyIdle) isInsideSleepWindow() else false
 
                         when {
                             config.onlyOnWifi.get() && !isWifi -> {
-                                currentStatusText = context.translation["auto_open_snaps.only_on_wifi.name"] ?: "Waiting for WiFi..."
-                                currentSpeedText = "Throttled"
-                                isCurrentlyWaiting = true
-                                delay(5000)
+                                currentStatusText = "Waiting for WiFi..."; currentSpeedText = "Throttled"; isCurrentlyWaiting = true; delay(5000)
                             }
-                            config.onlyWhenIdle.get() && !isIdle && !inSleepWindow -> {
-                                currentStatusText = context.translation["auto_open_snaps.only_when_idle.name"] ?: "Waiting for idle..."
-                                currentSpeedText = "Throttled"
-                                isCurrentlyWaiting = true
-                                delay(5000)
+                            onlyIdle && !isIdle && !inSleepWindow -> {
+                                currentStatusText = "Waiting for idle..."; currentSpeedText = "Throttled"; isCurrentlyWaiting = true; delay(5000)
                             }
-                            config.pauseDuringGaming.get() && isGaming -> {
-                                currentStatusText = context.translation["auto_open_snaps.pause_during_gaming.name"] ?: "Paused (Gaming Mode)"
-                                currentSpeedText = "Paused"
-                                isCurrentlyWaiting = true
-                                delay(60000)
-                            }
-                            else -> {
-                                resourceWaiting = false
-                                currentSpeedText = if (inSleepWindow || isThermalThrottled) "Throttled" else "Full Speed"
+                            else -> { 
+                                resourceWaiting = false; 
+                                val thermalActive = config.thermalProtection.get() && isThermalThrottled
+                                currentSpeedText = if (inSleepWindow || thermalActive) "Throttled" else "Full Speed" 
                             }
                         }
                         if (resourceWaiting) updateStatusNotification()
                     }
 
-                    if (isPaused.get() || config.globalState != true) {
-                        synchronized(queuedSnaps) { queuedSnaps.add(0, item) }
-                        continue
-                    }
+                    if (isPaused.get() || config.globalState != true) { synchronized(queuedSnaps) { queuedSnaps.add(0, item) }; continue }
                     isCurrentlyWaiting = false
 
-                    val inSleepWindow = if (config.onlyWhenIdle.get()) isInsideSleepWindow() else false
-                    if (inSleepWindow || isThermalThrottled) {
-                        currentStatusText = if (isThermalThrottled) context.translation["auto_open_snaps.thermal_status_title"] ?: "Thermal Cooling" else context.translation["auto_open_snaps.speed_throttled"] ?: "Throttled"
-                        delay(Random.nextLong(3000, 5000))
-                    } else if (lastConversationId != null && lastConversationId != item.conversationId) {
-                        currentStatusText = "Switching chats..."
-                        delay(Random.nextLong(1500, 2500))
-                        batchSnapCount = 0
-                        triggerLazySave()
-                    } else if (lastConversationId == item.conversationId) {
-                        when {
-                            isThermalThrottled -> delay(Random.nextLong(100, 150))
-                            config.safeProcessing.get() -> delay(Random.nextLong(50, 150))
-                            else -> delay(Random.nextLong(10, 40))
-                        }
-                    }
-
+                    // TIMING: 40ms switch
+                    if (lastConversationId != null && lastConversationId != item.conversationId) { delay(40) }
                     lastConversationId = item.conversationId
-                    currentStatusText = context.translation["auto_open_snaps.status_active"] ?: "Opening snap..."
-                    updateStatusNotification()
+                    currentStatusText = "Active"; updateStatusNotification()
 
                     var success = false
                     val startTime = System.currentTimeMillis()
@@ -382,233 +283,163 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
 
                     for (i in 0 until config.retryAttempts.get()) {
                         if (isPaused.get() || config.globalState != true) break
-                        while ((!config.allowRunningInBackground.get() && context.isMainActivityPaused) || (messaging.conversationManager == null && !config.allowRunningInBackground.get())) {
-                            if (config.globalState != true || isPaused.get()) break
-                            currentStatusText = "Waiting for UI..."
-                            isCurrentlyWaiting = true
-                            updateStatusNotification()
-                            delay(2000)
+                        
+                        // Bridge Handshake
+                        if (messaging.conversationManager == null) {
+                            runCatching { context.messagingBridge.triggerSessionStart() }
+                            var waitTime = 0
+                            while (messaging.conversationManager == null && waitTime < 2000) { delay(100); waitTime += 100 }
                         }
-                        if (isPaused.get() || config.globalState != true) break
-                        isCurrentlyWaiting = false
 
                         success = performOpen(messaging, item)
                         if (success) {
-                            totalProcessed.incrementAndGet()
                             sessionProcessed.incrementAndGet()
-                            synchronized(snapTimestamps) { 
-                                snapTimestamps.addLast(System.currentTimeMillis())
-                                if (snapTimestamps.size > 100) snapTimestamps.removeFirst()
-                            }
+                            totalProcessed.incrementAndGet()
+                            synchronized(snapTimestamps) { snapTimestamps.addLast(System.currentTimeMillis()); if (snapTimestamps.size > 100) snapTimestamps.removeFirst() }
                             val duration = System.currentTimeMillis() - startTime
                             averageProcessingTime.set((averageProcessingTime.get() * 0.7 + duration * 0.3).toLong())
-                            
-                            val remaining = synchronized(queuedSnaps) { queuedSnaps.size }
-                            val threshold = if (remaining > 100) 100 else 25
-                            if (processedSinceLastSave.incrementAndGet() >= threshold) {
-                                triggerLazySave()
-                                processedSinceLastSave.set(0)
-                            }
+                            delay(5)
                             break
                         }
                         if (i < config.retryAttempts.get() - 1) {
-                            currentStatusText = context.translation["auto_open_snaps.status_retrying"] ?: "Retrying..."
-                            updateStatusNotification()
-                            delay(currentRetryDelay); currentRetryDelay *= 2
+                            currentStatusText = "Retrying..."; updateStatusNotification(); delay(currentRetryDelay); currentRetryDelay *= 2
                         }
                     }
 
                     if (!success && !isPaused.get()) {
-                        currentStatusText = context.translation["auto_open_snaps.status_failed"]?.replace("{sender}", item.senderName) ?: "Failed to open"
-                        updateStatusNotification()
-                        
-                        // MOVE TO DEAD LETTER QUEUE (Revival Engine)
-                        synchronized(deadLetterQueue) {
-                            if (deadLetterQueue.size < 100) deadLetterQueue.add(item)
-                            else { deadLetterQueue.removeAt(0); deadLetterQueue.add(item) }
-                        }
-                        delay(2000)
+                        currentStatusText = "Failed: ${item.senderName}"; updateStatusNotification()
+                        synchronized(openedSnaps) { openedSnaps.remove(item.messageId) }
+                        synchronized(deadLetterQueue) { if (deadLetterQueue.size < 100) deadLetterQueue.add(item) else { deadLetterQueue.removeAt(0); deadLetterQueue.add(item) } }
                     }
 
-                    if (synchronized(queuedSnaps) { queuedSnaps.isEmpty() }) {
-                        delay(500)
-                        if (synchronized(queuedSnaps) { queuedSnaps.isEmpty() }) {
-                            currentStatusText = context.translation["auto_open_snaps.status_monitoring"] ?: "Monitoring..."
-                            isCurrentlyWaiting = false
-                            triggerLazySave()
-                            updateStatusNotification()
-                        }
+                    if (synchronized(queuedSnaps) { queuedSnaps.isEmpty() }) { 
+                        currentStatusText = "Monitoring..."; updateStatusNotification()
+                        delay(50) 
                     }
                 }
             }
         }
 
+        // Global Detector
         context.event.subscribe(BuildMessageEvent::class, priority = 103) { event ->
+            // GLOBAL SILENCE GUARD
             if (config.globalState != true) return@subscribe
             
             val message = event.message
-            // Stability: Only process committed messages to avoid ghost events during sending/failure
-            if (message.messageState != me.eternal.purrfectsnap.common.data.MessageState.COMMITTED) return@subscribe
-            if (message.senderId?.toString() == context.database.myUserId) return@subscribe
+            if (message.messageState != MessageState.COMMITTED || message.senderId?.toString() == context.database.myUserId) return@subscribe
             
             val conversationId = message.messageDescriptor?.conversationId?.toString() ?: return@subscribe
             val clientMessageId = message.messageDescriptor?.messageId ?: return@subscribe
+            val serverMsgId = message.orderKey
             val contentType = message.messageContent?.contentType
-            
-            // Validation: Only process viewable snaps and external media
             if (contentType != ContentType.SNAP && contentType != ContentType.EXTERNAL_MEDIA) return@subscribe
-            if (contentType == ContentType.SNAP_NOT_VIEWABLE) return@subscribe
             
-            if (message.messageMetadata?.openedBy?.any { it.toString() == context.database.myUserId } == true) return@subscribe
+            if (config.globalState != true) return@subscribe
+            
+            // Whitelist Resilience: Robust rule check
+            val ruleState = context.config.rules.getRuleState(ruleType)
+            val isWhitelisted = getState(conversationId)
+            val canProcess = if (ruleState == me.eternal.purrfectsnap.common.data.RuleState.BLACKLIST) !isWhitelisted else isWhitelisted
+            
+            if (!canProcess) return@subscribe
 
             acquireWakeLock()
-            
-            context.coroutineScope.launch(Dispatchers.Default) {
-                if (!canUseRule(conversationId)) return@launch
-                
-                synchronized(openedSnaps) {
-                    if (openedSnaps.contains(clientMessageId)) return@launch
-                    openedSnaps.add(clientMessageId)
-                    // Periodic cache maintenance to ensure O(1) performance
-                    if (openedSnaps.size > 5000) openedSnaps.clear()
-                }
-
-                val senderId = message.senderId?.toString() ?: "unknown"
-                val item = SnapQueueItem(conversationId, clientMessageId, senderId, getSenderDisplayName(senderId), getConversationType(conversationId, senderId), getSnapContentType(contentType))
-                
-                val currentQueueSize = synchronized(queuedSnaps) {
-                    if (queuedSnaps.size >= config.queueSize.get()) queuedSnaps.removeFirstOrNull()
-                    queuedSnaps.add(item)
-                    queuedSnaps.size
-                }
-                totalDetected.incrementAndGet()
-
-                // Smart Pre-fetch Engine: Early media loading into internal cache
-                if (config.preFetchSnaps.get()) {
-                    val isWifi = isWifiConnected()
-                    val mobileLimit = 250
-                    
-                    // Connection-Aware Limit: 1000 for WiFi, 250 for Mobile
-                    val canFetch = if (isWifi) currentQueueSize <= 1000 else currentQueueSize <= mobileLimit
-                    
-                    // Dynamic RAM Window (20/50/100) to prevent UI jitter on low-end devices
-                    if (canFetch && currentQueueSize <= getFetchWindowSize()) {
-                        runCatching {
-                            // Stable feature access via explicit KClass resolution
-                            context.feature(Messaging::class).conversationManager?.fetchMessage(conversationId, clientMessageId, {}, {})
-                        }
-                    }
-                }
-
-                if (!isPaused.get()) {
-                    snapQueue.tryEmit(System.currentTimeMillis())
-                }
-                
-                updateStatusNotification()
-                triggerLazySave()
+            synchronized(openedSnaps) {
+                if (openedSnaps.contains(clientMessageId)) return@subscribe
+                openedSnaps.add(clientMessageId)
+                if (openedSnaps.size > 5000) openedSnaps.clear()
             }
-        }
-    }
 
-    private fun getFetchWindowSize(): Int {
-        val am = context.androidContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        val memInfo = ActivityManager.MemoryInfo()
-        am.getMemoryInfo(memInfo)
-        val totalRamGb = memInfo.totalMem / (1024 * 1024 * 1024)
-        return when {
-            totalRamGb <= 2 -> 20
-            totalRamGb <= 4 -> 50
-            else -> 100
+            val senderId = message.senderId?.toString() ?: "unknown"
+            val item = SnapQueueItem(conversationId, clientMessageId, serverMsgId, senderId, getSenderDisplayName(senderId), getConversationType(conversationId, senderId), getSnapContentType(contentType))
+            
+            synchronized(queuedSnaps) {
+                if (queuedSnaps.size >= config.queueSize.get()) queuedSnaps.removeFirstOrNull()
+                queuedSnaps.add(item)
+            }
+
+            if (context.config.messaging.preFetchSnaps.get()) {
+                runCatching { messaging.conversationManager?.fetchMessage(conversationId, clientMessageId, {}, {}) }
+            }
+
+            if (!isPaused.get()) snapQueue.tryEmit(System.currentTimeMillis())
+            updateStatusNotification()
+            triggerLazySave()
         }
     }
 
     private suspend fun performOpen(messaging: Messaging, item: SnapQueueItem): Boolean = withContext(Dispatchers.IO) {
         val manager = messaging.conversationManager ?: return@withContext false
-        withTimeoutOrNull(5000) {
-            suspendCancellableCoroutine<Boolean> { cont ->
-                runCatching {
-                    manager.updateMessage(item.conversationId, item.messageId, MessageUpdate.READ) { result ->
-                        cont.resume(result == null || result == "DUPLICATEREQUEST")
+        suspendCancellableCoroutine<Boolean> { cont ->
+            runCatching {
+                manager.updateMessage(item.conversationId, item.messageId, MessageUpdate.READ) { result ->
+                    if (result == null || result == "DUPLICATEREQUEST") {
+                        cont.resume(true)
+                    } else if (item.serverMessageId != null) {
+                        manager.updateMessage(item.conversationId, item.serverMessageId, MessageUpdate.READ) { serverResult ->
+                            cont.resume(serverResult == null || serverResult == "DUPLICATEREQUEST")
+                        }
+                    } else {
+                        cont.resume(false)
                     }
-                }.onFailure { cont.resume(false) }
-            }
-        } ?: false
-    }
-
-    private fun formatDuration(millis: Long): String {
-        val s = (millis / 1000) % 60; val m = (millis / 60000) % 60; val h = millis / 3600000
-        return when { h > 0 -> "${h}h ${m}m ${s}s"; m > 0 -> "${m}m ${s}s"; else -> "${s}s" }
+                }
+            }.onFailure { cont.resume(false) }
+        }
     }
 
     private fun getSnapsPerSecond(): Double {
-        val now = System.currentTimeMillis()
-        val window = 5000L
+        val now = System.currentTimeMillis(); val window = 5000L
         synchronized(snapTimestamps) {
-            snapTimestamps.removeIf { now - it > window }
-            return (snapTimestamps.size.toDouble() / (window / 1000.0))
+            snapTimestamps.removeIf { now - it > window }; return (snapTimestamps.size.toDouble() / (window / 1000.0))
         }
     }
 
-    private fun updateStatusNotification() {
-        val currentTime = System.currentTimeMillis()
-        val lastUpdate = lastNotificationUpdate.get()
-
-        if ((currentTime - lastUpdate) < notificationUpdateDelay) {
+    private fun updateStatusNotification(force: Boolean = false) {
+        val currentTime = System.currentTimeMillis(); val lastUpdate = lastNotificationUpdate.get()
+        val remaining = synchronized(queuedSnaps) { queuedSnaps.size }
+        if (!isScreenOn.get() && !force) return
+        if (!force && (currentTime - lastUpdate) < notificationUpdateDelay) {
             if (pendingNotificationUpdate.compareAndSet(false, true)) {
-                context.coroutineScope.launch {
-                    delay(notificationUpdateDelay - (currentTime - lastUpdate))
-                    pendingNotificationUpdate.set(false)
-                    updateStatusNotificationInternal()
-                }
+                context.coroutineScope.launch { delay(notificationUpdateDelay - (currentTime - lastUpdate)); pendingNotificationUpdate.set(false); updateStatusNotificationInternal() }
             }
             return
         }
-
-        lastNotificationUpdate.set(currentTime)
-        updateStatusNotificationInternal()
+        lastNotificationUpdate.set(currentTime); updateStatusNotificationInternal()
     }
 
-    // Notification state cache to prevent redundant UI updates and save battery
-    private var lastNotificationState: String? = null
+    private var lastNotificationStateHash: Int = 0
 
     private fun updateStatusNotificationInternal() {
         val processed = sessionProcessed.get()
         val total = totalProcessed.get()
         val remaining = synchronized(queuedSnaps) { queuedSnaps.size }
         
-        // Generate a state fingerprint to check if a notification update is actually necessary
-        val currentStateFingerprint = "$processed|$total|$remaining|$currentStatusText|$isPaused"
-        if (currentStateFingerprint == lastNotificationState && remaining == 0) return
-        lastNotificationState = currentStateFingerprint
+        val currentStateHash = Objects.hash(processed, total, remaining, currentStatusText, isPaused.get())
+        if (currentStateHash == lastNotificationStateHash && remaining == 0) return
+        lastNotificationStateHash = currentStateHash
 
         if (total <= 0 && remaining <= 0 && processed <= 0) return
 
         val isWorking = remaining > 0
         val isCompact = config.compactNotification.get() == true
         val sessionTotal = processed + remaining
-        val progressPercent = if (sessionTotal > 0) (processed * 100) / sessionTotal else 0
         val speed = getSnapsPerSecond()
+        val progressPercent = if (sessionTotal > 0) (processed * 100) / sessionTotal else 0
+        val eta = if (isWorking && !isCurrentlyWaiting && !isPaused.get()) formatDuration(remaining * averageProcessingTime.get()) else "..."
 
         val builder = Notification.Builder(context.androidContext, "auto_open_snaps")
             .setSmallIcon(if (isPaused.get()) android.R.drawable.ic_media_pause else android.R.drawable.ic_media_play)
-            .setOngoing(isWorking).setAutoCancel(!isWorking).setOnlyAlertOnce(true)
-            .setGroup(NOTIFICATION_GROUP_KEY).setGroupSummary(false)
-
-        val eta = if (isWorking && !isCurrentlyWaiting && !isPaused.get()) formatDuration(remaining * averageProcessingTime.get()) else null
+            .setOngoing(isWorking).setOnlyAlertOnce(true).setGroup(NOTIFICATION_GROUP_KEY).setGroupSummary(false)
 
         builder.setContentTitle("Auto-Open: $currentStatusText")
         
         if (isWorking) {
-            builder.setContentText("Opened: $processed │ ETA: ${eta ?: "..."}")
-            builder.setSubText("$progressPercent% • $remaining Queued")
-            // Show progress bar only when actively processing snaps
+            builder.setContentText("Opened: $processed │ Queue: $remaining")
+            builder.setSubText("$progressPercent% • Ends in: ${eta ?: "..."}")
             builder.setProgress(sessionTotal, processed, false)
         } else {
-            // Static status for monitoring stage to save battery
-            builder.setContentText("$processed Opened Today │ $total Lifetime")
-            // Remove subtext entirely when idle to prevent redundancy with the title
+            builder.setContentText("$processed Opened Today │ $total Total")
             builder.setSubText(null)
-            // Remove progress bar entirely during idle/monitoring stage to stop animation CPU drain
             builder.setProgress(0, 0, false)
         }
 
@@ -617,26 +448,26 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
 
         if (!isCompact) {
             val recentSnaps = synchronized(queuedSnaps) { queuedSnaps.takeLast(5) }
-            val bigTextStyle = Notification.BigTextStyle()
-            
-            // Set summary text to empty to force the header to stay clean in expanded view
-            bigTextStyle.setSummaryText("")
-
+            val bigTextStyle = Notification.BigTextStyle().setSummaryText("")
             val detailText = buildString {
                 append("QUEUE STATISTICS\n")
                 append("├─ Opened: $processed snaps\n")
-                append("├─ Remaining: $remaining snaps\n")
-                if (eta != null) append("├─ Estimated time: $eta\n")
-                append("├─ Lifetime Opened: $total snaps\n")
-                append("└─ Speed: $currentSpeedText (${String.format("%.1f", speed)}/s)\n\n")
+                append("├─ Queue: $remaining snaps\n")
+                append("├─ Total Opened: $total snaps\n")
+                val speedNotion = if (remaining > 0) currentSpeedText else "Idle"
+                val speedValue = if (remaining > 0) "${String.format("%.1f", speed)}/s" else "0.0/s"
+                append("└─ Speed: $speedNotion ($speedValue)\n\n")
 
-                append("QUEUE PREVIEW\n")
-                if (isWorking) {
-                    recentSnaps.reversed().forEach { item ->
-                        append("• ${item.senderName} │ ${item.conversationType} (${item.contentType})\n")
+
+                if (config.showQueuePreview.get()) {
+                    append("\n\nQUEUE PREVIEW\n")
+                    if (isWorking) {
+                        recentSnaps.reversed().forEach { item ->
+                            append("• ${item.senderName} │ ${item.conversationType} (${item.contentType})\n")
+                        }
+                    } else {
+                        append("Monitoring snaps in background...")
                     }
-                } else {
-                    append(context.translation["auto_open_snaps.notification_no_snaps_queue"] ?: "Monitoring snaps in background...")
                 }
             }
             bigTextStyle.bigText(detailText)
@@ -646,35 +477,28 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
         notificationManager.notify(STATUS_NOTIFICATION_ID, builder.build())
     }
 
+    private fun formatDuration(m: Long): String {
+        val s = (m / 1000) % 60; val min = (m / 60000) % 60; val h = m / 3600000
+        return when { h > 0 -> "${h}h ${min}m"; min > 0 -> "${min}m ${s}s"; else -> "${s}s" }
+    }
+
     private fun shutdownFeature() {
-        cancelStatusNotification()
-        val finalCount = totalProcessed.get()
-        if (hasBeenActive.get()) {
-            val elapsedMillis = System.currentTimeMillis() - sessionStartTime.get() - totalPausedDuration.get()
-            val durationMins = maxOf(0, elapsedMillis / 60000)
-            val summary = Notification.Builder(context.androidContext, "auto_open_snaps")
-                .setSmallIcon(android.R.drawable.ic_dialog_info)
-                .setContentTitle("Auto-Open: Deactivated")
-                .setContentText("Opened: $finalCount snaps | Session: ${durationMins}m")
-                .setGroup(NOTIFICATION_GROUP_KEY)
-                .setAutoCancel(true).build()
-            // Use static ID to overwrite previous deactivate notice and prevent icon stacking
-            notificationManager.notify(STATUS_NOTIFICATION_ID + 1, summary)
-            hasBeenActive.set(false)
+        cancelStatusNotification(); releaseWakeLock(); hasBeenActive.set(false); triggerLazySave()
+    }
+
+    private fun startWakeLockCooldown() {
+        wakeLockCooldownJob?.cancel()
+        wakeLockCooldownJob = context.coroutineScope.launch {
+            delay(30000)
+            releaseWakeLock()
         }
-        triggerLazySave()
-        releaseWakeLock()
     }
 
     private fun triggerLazySave() {
         needsSaving.set(true)
         if (isSaving.compareAndSet(false, true)) {
             context.coroutineScope.launch(Dispatchers.IO) {
-                while (needsSaving.get()) {
-                    needsSaving.set(false)
-                    saveToDiskInternal()
-                    delay(1000)
-                }
+                while (needsSaving.get()) { needsSaving.set(false); saveToDiskInternal(); delay(300000) }
                 isSaving.set(false)
             }
         }
@@ -683,62 +507,39 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
     private fun saveToDiskInternal() {
         prefs.edit {
             putInt(PREF_TOTAL_OPENED, totalProcessed.get())
-            putInt(PREF_TOTAL_DETECTED, totalDetected.get())
             putLong(PREF_SESSION_START, sessionStartTime.get())
-            synchronized(queuedSnaps) {
-                putString(PREF_SAVED_QUEUE, gson.toJson(queuedSnaps))
-            }
+            synchronized(queuedSnaps) { putString(PREF_SAVED_QUEUE, gson.toJson(queuedSnaps)) }
         }
     }
 
     private fun restorePersistence() {
+        val savedStartTime = prefs.getLong(PREF_SESSION_START, 0)
+        val now = System.currentTimeMillis()
+        if (now - savedStartTime > 3600000) {
+            prefs.edit().remove(PREF_SAVED_QUEUE).remove(PREF_TOTAL_OPENED).apply(); return
+        }
         totalProcessed.set(prefs.getInt(PREF_TOTAL_OPENED, 0))
-        totalDetected.set(prefs.getInt(PREF_TOTAL_DETECTED, 0))
-        sessionStartTime.set(prefs.getLong(PREF_SESSION_START, System.currentTimeMillis()))
+        sessionStartTime.set(savedStartTime)
         val savedQueueJson = prefs.getString(PREF_SAVED_QUEUE, null)
         if (!savedQueueJson.isNullOrBlank()) {
             try {
-                val type = object : TypeToken<List<SnapQueueItem>>() {}.type
-                val restored: List<SnapQueueItem> = gson.fromJson(savedQueueJson, type)
-                val now = System.currentTimeMillis()
-                synchronized(queuedSnaps) { 
-                    queuedSnaps.clear()
-                    queuedSnaps.addAll(restored.filter { (now - it.timestamp) < 3600000 }) 
-                }
-            } catch (e: Exception) { 
-                prefs.edit().remove(PREF_SAVED_QUEUE).apply()
-            }
+                val restored: List<SnapQueueItem> = gson.fromJson(savedQueueJson, object : TypeToken<List<SnapQueueItem>>() {}.type)
+                synchronized(queuedSnaps) { queuedSnaps.addAll(restored.filter { (now - it.timestamp) < 3600000 }) }
+            } catch (e: Exception) { prefs.edit().remove(PREF_SAVED_QUEUE).apply() }
         }
     }
 
-    private fun resetPersistence() {
-        prefs.edit().remove(PREF_TOTAL_OPENED).remove(PREF_TOTAL_DETECTED).remove(PREF_SESSION_START).remove(PREF_SAVED_QUEUE).apply()
-        synchronized(queuedSnaps) { queuedSnaps.clear() }
-    }
-
     private fun isInsideSleepWindow(): Boolean {
         try {
-            val sleepWindow = config.sleepWindow.get()
-            if (!sleepWindow.contains("-") || !sleepWindow.contains(":")) return false
-            val window = sleepWindow.split("-")
-            if (window.size != 2) return false
-            val startStr = window[0].split(":")
-            val endStr = window[1].split(":")
-            if (startStr.size != 2 || endStr.size != 2) return false
+            val window = config.sleepWindow.get().split("-"); if (window.size != 2) return false
+            val start = window[0].split(":"); val end = window[1].split(":")
             val now = Calendar.getInstance().apply { set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) }
-            val start = Calendar.getInstance().apply { set(Calendar.HOUR_OF_DAY, startStr[0].toInt()); set(Calendar.MINUTE, startStr[1].toInt()); set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) }
-            val end = Calendar.getInstance().apply { set(Calendar.HOUR_OF_DAY, endStr[0].toInt()); set(Calendar.MINUTE, endStr[1].toInt()); set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) }
-            return if (end.before(start)) now.after(start) || now.before(end) else now.after(start) && now.before(end)
+            val s = Calendar.getInstance().apply { set(Calendar.HOUR_OF_DAY, start[0].toInt()); set(Calendar.MINUTE, start[1].toInt()); set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) }
+            val e = Calendar.getInstance().apply { set(Calendar.HOUR_OF_DAY, end[0].toInt()); set(Calendar.MINUTE, end[1].toInt()); set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) }
+            return if (e.before(s)) now.after(s) || now.before(e) else now.after(s) && now.before(e)
         } catch (e: Exception) { return false }
     }
 
-    private fun isGaming(): Boolean {
-        val am = context.androidContext.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
-        return am.runningAppProcesses?.firstOrNull { it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND }?.processName?.let {
-            !it.contains("snapchat") && !it.contains("purrfectsnap")
-        } ?: false
-    }
-
     private fun isWifiConnected(): Boolean {
         val cm = context.androidContext.getSystemService(ConnectivityManager::class.java) ?: return false
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -751,50 +552,31 @@ class AutoOpenSnaps: MessagingRuleFeature("Auto Open Snaps", MessagingRuleType.A
     private fun isDeviceIdle(): Boolean = (context.androidContext.getSystemService(Context.POWER_SERVICE) as PowerManager).isDeviceIdleMode
 
     private fun acquireWakeLock() {
+        wakeLockCooldownJob?.cancel()
         if (wakeLock == null) {
             val pm = context.androidContext.getSystemService(Context.POWER_SERVICE) as PowerManager
-            wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "PurrfectSnap:AutoOpen")
+            wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "PurrfectSnap:AutoOpen").apply { setReferenceCounted(false) }
             wakeLock?.acquire(8 * 60 * 60 * 1000L)
         }
     }
 
     private fun releaseWakeLock() {
-        if (wakeLock?.isHeld == true) wakeLock?.release()
-        wakeLock = null
+        if (wakeLock?.isHeld == true) wakeLock?.release(); wakeLock = null
     }
 
-    private fun createPendingIntent(action: String): PendingIntent {
-        val intent = Intent(action).apply { setPackage(context.androidContext.packageName) }
-        return PendingIntent.getBroadcast(context.androidContext, action.hashCode(), intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+    private fun createPendingIntent(a: String): PendingIntent {
+        val i = Intent(a).apply { setPackage(context.androidContext.packageName) }
+        return PendingIntent.getBroadcast(context.androidContext, a.hashCode(), i, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
     }
 
     private fun createNotificationChannels() {
-        runCatching {
-            val channel = NotificationChannel("auto_open_snaps", "Auto Open Snaps", NotificationManager.IMPORTANCE_LOW).apply {
-                enableVibration(false); setSound(null, null)
-            }
-            notificationManager.createNotificationChannel(channel)
-        }.onFailure {
-            context.log.warn("Failed to create Auto Open Snaps notification channel: ${it.message}")
-        }
+        val c = NotificationChannel("auto_open_snaps", "Auto Open Snaps", NotificationManager.IMPORTANCE_LOW).apply { enableVibration(false); setSound(null, null) }
+        notificationManager.createNotificationChannel(c)
     }
 
-    private fun getSenderDisplayName(senderId: String): String {
-        // Memory Safety: Prevent cache bloat during high-volume bursts
-        if (nameCache.size > 500) nameCache.clear()
-        return nameCache.getOrPut(senderId) {
-            context.database.getFriendInfo(senderId)?.let { it.displayName ?: it.mutableUsername } ?: "Unknown"
-        }
-    }
+    private fun getSenderDisplayName(id: String): String = metadataCache.getOrPut(id) { context.database.getFriendInfo(id)?.let { it.displayName ?: it.mutableUsername } ?: "Unknown" }
 
-    private fun getConversationType(conversationId: String, senderId: String): String {
-        // Memory Safety: Prevent cache bloat during high-volume bursts
-        if (conversationTypeCache.size > 500) conversationTypeCache.clear()
-        return conversationTypeCache.getOrPut("$conversationId:$senderId") {
-            if (context.database.getDMOtherParticipant(conversationId) != null) "Friend DM"
-            else context.database.getFeedEntryByConversationId(conversationId)?.feedDisplayName ?: "Group Chat"
-        }
-    }
+    private fun getConversationType(cid: String, sid: String): String = metadataCache.getOrPut("$cid:$sid") { if (context.database.getDMOtherParticipant(cid) != null) "Friend DM" else context.database.getFeedEntryByConversationId(cid)?.feedDisplayName ?: "Group Chat" }
 
     private fun getSnapContentType(type: ContentType?): String = when (type) {
         ContentType.SNAP -> "Photo/Video"

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/global/AdBlockFix.kt

@@ -0,0 +1,254 @@
+package me.eternal.purrfectsnap.core.features.impl.global
+
+import android.os.SystemClock
+import android.view.View
+import me.eternal.purrfectsnap.core.event.events.impl.BindViewEvent
+import me.eternal.purrfectsnap.core.features.Feature
+import me.eternal.purrfectsnap.core.ui.hideViewCompletely
+import me.eternal.purrfectsnap.core.ui.dispatchSyntheticTap
+import me.eternal.purrfectsnap.core.util.dataBuilder
+import me.eternal.purrfectsnap.core.util.hook.HookStage
+import me.eternal.purrfectsnap.core.util.hook.hook
+import me.eternal.purrfectsnap.core.util.hook.hookConstructor
+import me.eternal.purrfectsnap.core.util.ktx.getObjectField
+import me.eternal.purrfectsnap.core.util.ktx.getObjectFieldOrNull
+import me.eternal.purrfectsnap.core.wrapper.impl.SnapUUID
+import me.eternal.purrfectsnap.core.wrapper.impl.media.opera.Layer
+import me.eternal.purrfectsnap.core.wrapper.impl.media.opera.ParamMap
+import me.eternal.purrfectsnap.mapper.impl.CallbackMapper
+import me.eternal.purrfectsnap.mapper.impl.OperaPageViewControllerMapper
+import java.util.ArrayList
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
+
+class AdBlockFix : Feature("AdBlockFix") {
+    private val adConversationIds = Collections.newSetFromMap(ConcurrentHashMap<String, Boolean>())
+
+    @Volatile
+    private var lastAutoSkippedOperaFingerprint: String? = null
+
+    @Volatile
+    private var lastAutoSkippedOperaAt = 0L
+
+    override fun init() {
+        if (!context.config.global.blockAds.get()) return
+
+        hookFeedEntryTracking()
+        hookMessagingFeedCallbacks()
+        hookChatFeedRowSuppression()
+        hookOperaAutoSkip()
+    }
+
+    private fun hookFeedEntryTracking() {
+        findClass("com.snapchat.client.messaging.FeedEntry").hookConstructor(HookStage.AFTER) { param ->
+            val feedEntry = param.thisObject<Any>()
+            val conversationId = feedEntry.getObjectFieldOrNull("mConversationId")?.let(::SnapUUID)?.toString()
+                ?: return@hookConstructor
+
+            if (isCampaignFeedEntry(feedEntry) || isChatAdShareFeedEntry(feedEntry)) {
+                adConversationIds.add(conversationId)
+            }
+        }
+    }
+
+    private fun hookMessagingFeedCallbacks() {
+        context.mappings.useMapper(CallbackMapper::class) {
+            classLoader = context.androidContext.classLoader
+            val callbackMap = callbacks.getAsMap().orEmpty()
+            val hookedCallbacks = mutableSetOf<String>()
+
+            fun hookOnce(
+                callbackClassName: String,
+                methodName: String,
+                block: (param: me.eternal.purrfectsnap.core.util.hook.HookAdapter) -> Unit
+            ) {
+                val hookKey = "$callbackClassName#$methodName"
+                if (!hookedCallbacks.add(hookKey)) return
+                runCatching {
+                    findClass(callbackClassName).hook(methodName, HookStage.BEFORE) { param ->
+                        block(param)
+                    }
+                }.onFailure {
+                    context.log.warn("Failed to hook $methodName on $callbackClassName")
+                }
+            }
+
+            callbackMap.entries.forEach { (callbackName, callbackClassName) ->
+                val className = callbackClassName ?: return@forEach
+                when {
+                    callbackName.startsWith("FetchAndSyncFeed") && callbackName.endsWith("Callback") -> {
+                        hookOnce(className, "onFetchAndSyncFeedComplete") { param ->
+                            val deletedEntries = param.argNullable<ArrayList<Any>>(2)
+                            filterCampaignFeed(param.arg(0), deletedEntries)
+                            if (deletedEntries?.isNotEmpty() == true) {
+                                param.setArg(4, true)
+                            }
+                        }
+                    }
+
+                    callbackName.contains("SyncFeed") && callbackName.endsWith("Callback") -> {
+                        hookOnce(className, "onSyncFeedComplete") { param ->
+                            filterCampaignFeed(param.arg(0), param.argNullable(2))
+                        }
+                    }
+
+                    callbackName == "FetchFeedCallback" || callbackName.contains("FetchFeedCallback") -> {
+                        hookOnce(className, "onFetchFeedComplete") { param ->
+                            filterCampaignFeed(param.arg(0))
+                        }
+                    }
+
+                    callbackName == "FetchFeedEntriesCallback" || callbackName.contains("FetchFeedEntriesCallback") -> {
+                        hookOnce(className, "onFetchFeedEntriesComplete") { param ->
+                            filterCampaignFeed(param.arg(0))
+                        }
+                    }
+
+                    callbackName == "QueryFeedCallback" || callbackName.contains("QueryFeedCallback") -> {
+                        hookOnce(className, "onQueryFeedComplete") { param ->
+                            filterCampaignFeed(param.arg(0))
+                        }
+                    }
+
+                    callbackName == "FeedManagerDelegate" -> {
+                        hookOnce(className, "onFeedEntriesUpdated") { param ->
+                            filterCampaignFeed(param.arg(0))
+                        }
+                        hookOnce(className, "onInternalSyncFeed") { param ->
+                            filterCampaignFeed(param.arg(0))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun hookChatFeedRowSuppression() {
+        context.event.subscribe(BindViewEvent::class) { event ->
+            val modelDump = event.prevModel.toString()
+            event.friendFeedItem { conversationId ->
+                if (adConversationIds.contains(conversationId) || isChatAdShareModel(modelDump)) {
+                    hideBoundChatFeedRow(event.view)
+                }
+            }
+        }
+    }
+
+    private fun hideBoundChatFeedRow(view: View) {
+        view.hideViewCompletely()
+        (view.parent as? View)?.hideViewCompletely()
+        (view.parent?.parent as? View)?.hideViewCompletely()
+    }
+
+    private fun hookOperaAutoSkip() {
+        onNextActivityCreate {
+            context.mappings.useMapper(OperaPageViewControllerMapper::class) {
+                arrayOf(onDisplayStateChange, onDisplayStateChangeGesture).forEach { methodName ->
+                    val resolvedMethod = methodName.get() ?: return@forEach
+                    classReference.get()?.hook(resolvedMethod, HookStage.AFTER) { param ->
+                        val viewState = runCatching {
+                            param.thisObject<Any>().getObjectField(viewStateField.get()!!)?.toString()
+                        }.getOrNull() ?: return@hook
+                        if (viewState != "FULLY_DISPLAYED") return@hook
+
+                        val layerList = runCatching {
+                            param.thisObject<Any>().getObjectField(layerListField.get()!!) as? ArrayList<*>
+                        }.getOrNull() ?: return@hook
+                        val paramMap = runCatching {
+                            layerList.map { Layer(it).paramMap }.firstOrNull()
+                        }.getOrNull() ?: return@hook
+
+                        if (!isSpotlightCommercialPage(paramMap)) return@hook
+
+                        val fingerprint = buildOperaFingerprint(paramMap)
+                        val now = SystemClock.elapsedRealtime()
+                        if (fingerprint == lastAutoSkippedOperaFingerprint && now - lastAutoSkippedOperaAt < 1_500L) {
+                            return@hook
+                        }
+                        lastAutoSkippedOperaFingerprint = fingerprint
+                        lastAutoSkippedOperaAt = now
+
+                        runOnUiThread {
+                            context.mainActivity?.window?.decorView?.postDelayed({
+                                context.mainActivity?.window?.decorView?.let { decorView ->
+                                    val x = decorView.width * 0.88f
+                                    val y = decorView.height * 0.5f
+                                    decorView.dispatchSyntheticTap(x, y)
+                                }
+                            }, 70L)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun filterCampaignFeed(entries: ArrayList<Any>, deletedEntries: ArrayList<Any>? = null) {
+        entries.removeIf { feedEntry ->
+            if (!isCampaignFeedEntry(feedEntry)) return@removeIf false
+            val conversationIdInstance = feedEntry.getObjectFieldOrNull("mConversationId") ?: return@removeIf true
+            deletedEntries?.add(createDeletedFeedEntry(conversationIdInstance))
+            true
+        }
+    }
+
+    private fun createDeletedFeedEntry(conversationIdInstance: Any) =
+        findClass("com.snapchat.client.messaging.DeletedFeedEntry").dataBuilder {
+            from("mFeedEntryIdentifier") {
+                set("mConversationId", conversationIdInstance)
+            }
+            set("mReason", "AD_CAMPAIGN_COMPLETE")
+        }!!
+
+    private fun isCampaignFeedEntry(feedEntry: Any?): Boolean {
+        if (feedEntry == null) return false
+        if (feedEntry.getObjectFieldOrNull("mConversationSubType")?.toString() == "CAMPAIGN") {
+            return true
+        }
+        return feedEntry.getObjectFieldOrNull("mConversationSubTypeMetadata")
+            ?.getObjectFieldOrNull("mCampaignMetadata") != null
+    }
+
+    private fun isChatAdShareFeedEntry(feedEntry: Any): Boolean {
+        val interactionDump = feedEntry.getObjectFieldOrNull("mInteractionInfo")?.toString().orEmpty()
+        val displayDump = feedEntry.getObjectFieldOrNull("mDisplayInfo")?.toString().orEmpty()
+        val combined = "$interactionDump $displayDump"
+        return isChatAdShareModel(combined)
+    }
+
+    private fun isChatAdShareModel(modelDump: String): Boolean {
+        if (modelDump.isBlank()) return false
+        return modelDump.contains("CHAT_AD_SHARE") ||
+            modelDump.contains("AD_SHARE") ||
+            modelDump.contains("ChatAd") ||
+            modelDump.contains("chat_ad_share") ||
+            modelDump.contains("chat_sponsored_snap") ||
+            modelDump.contains("CommonAttachmentViewModel") ||
+            modelDump.contains("visibilityFeedbackURL") ||
+            modelDump.contains("pageLoadPingURL")
+    }
+
+    private fun isSpotlightCommercialPage(paramMap: ParamMap): Boolean {
+        val snapSource = paramMap["SNAP_SOURCE"]?.toString()
+        if (snapSource != "SINGLE_SNAP_STORY" && snapSource != "SPOTLIGHT" && snapSource != "PUBLIC_STORY") {
+            return false
+        }
+
+        val adProductType = paramMap["ad_product_type"]?.toString()
+        if (!adProductType.isNullOrBlank() && adProductType != "UNKNOWN" && adProductType != "null") {
+            return true
+        }
+
+        val pageDump = paramMap.toString().uppercase()
+        return pageDump.contains("COMMERCIAL") || pageDump.contains("PROMOTED_STORY")
+    }
+
+    private fun buildOperaFingerprint(paramMap: ParamMap): String {
+        val storyId = paramMap["STORY_ID"]?.toString()
+        val snapId = paramMap["SNAP_ID"]?.toString()
+            ?: paramMap["snap_id"]?.toString()
+        val index = paramMap["snap_index_in_story"]?.toString()
+            ?: paramMap["SNAP_POSITION_IN_STORY"]?.toString()
+        return listOfNotNull(storyId, snapId, index, paramMap["ad_product_type"]?.toString()).joinToString("|")
+    }
+}

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/tweaks/CameraTweaks.kt

@@ -12,6 +12,7 @@ import android.hardware.camera2.CameraCharacteristics.Key
 import android.hardware.camera2.CameraManager
 import android.media.Image
 import android.media.ImageReader
+import android.os.Build
 import android.util.Range
 import me.eternal.purrfectsnap.core.features.Feature
 import me.eternal.purrfectsnap.core.util.hook.HookStage
@@ -28,6 +29,9 @@ class CameraTweaks : Feature("Camera Tweaks") {
     @SuppressLint("MissingPermission", "DiscouragedApi")
     override fun init() {
         val config = context.config.camera
+        val skipUnstableStillCaptureTweaks = Build.MANUFACTURER.equals("samsung", ignoreCase = true) ||
+            Build.HARDWARE.contains("exynos", ignoreCase = true) ||
+            Build.BRAND.equals("samsung", ignoreCase = true)
 
         // Toggle A: Audio & Video Optimizations (Bitrates)
         if (config.audioVideoOptimizations.get()) {
@@ -44,7 +48,7 @@ class CameraTweaks : Feature("Camera Tweaks") {
         }
 
         // Toggle B: Camera Optimizations (Hardware ISP - UNSTABLE)
-        if (config.cameraOptimizations.get()) {
+        if (config.cameraOptimizations.get() && !skipUnstableStillCaptureTweaks) {
             CaptureRequest.Builder::class.java.hook("set", HookStage.BEFORE) { param ->
                 val key = param.arg<CaptureRequest.Key<*>>(0)
                 when (key) {

core/src/main/kotlin/me/eternal/purrfectsnap/core/features/impl/tweaks/PerformanceMode.kt

@@ -3,37 +3,55 @@ package me.eternal.purrfectsnap.core.features.impl.tweaks
 import android.animation.ValueAnimator
 import android.app.Activity
 import android.app.Dialog
+import android.content.Context
 import android.database.Cursor
 import android.database.MatrixCursor
 import android.database.sqlite.SQLiteDatabase
-import android.hardware.camera2.CaptureRequest
 import android.media.MediaRecorder
-import android.os.Build
-import android.transition.Transition
 import android.os.HandlerThread
 import android.os.Process
 import android.util.Base64
 import android.util.Range
 import android.view.View
-import android.view.ViewPropertyAnimator
-import android.view.WindowManager
-import android.view.animation.Animation
 import android.widget.OverScroller
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.StaggeredGridLayoutManager
 import java.io.File
 import java.lang.Thread
+import java.lang.reflect.Method
+import java.util.LinkedHashMap
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.ThreadPoolExecutor
+import com.google.gson.reflect.TypeToken
 import me.eternal.purrfectsnap.core.features.Feature
+import me.eternal.purrfectsnap.core.features.impl.messaging.Messaging
 import me.eternal.purrfectsnap.core.event.events.impl.NetworkApiRequestEvent
+import me.eternal.purrfectsnap.core.wrapper.impl.SnapUUID
+import me.eternal.purrfectsnap.mapper.impl.CallbackMapper
 import me.eternal.purrfectsnap.core.util.hook.HookStage
+import me.eternal.purrfectsnap.core.util.hook.findRestrictedMethod
 import me.eternal.purrfectsnap.core.util.hook.hook
 import me.eternal.purrfectsnap.core.util.hook.hookConstructor
+import me.eternal.purrfectsnap.core.util.ktx.getObjectField
+import me.eternal.purrfectsnap.core.util.ktx.setObjectField
 import okhttp3.Dispatcher
 
 class PerformanceMode : Feature("Performance Mode") {
+    companion object {
+        private const val CHAT_FEED_CACHE_MAX_ROWS = 400
+        private const val CHAT_FEED_CACHE_MAX_BLOB_BYTES = 512
+        private const val CHAT_FEED_CACHE_MIN_REFRESH_INTERVAL_MS = 15_000L
+        private const val MESSAGE_WINDOW_STATE_MAX_CONVERSATIONS = 64
+        private const val MESSAGE_WINDOW_STATE_MAX_AGE_MS = 7L * 24L * 60L * 60L * 1000L
+        private const val SNAP_PREFETCH_GROUP_MESSAGES = 48
+        private const val SNAP_PREFETCH_DM_MESSAGES = 24
+        private const val REOPEN_WARMUP_GROUP_MESSAGES = 160
+        private const val REOPEN_WARMUP_DM_MESSAGES = 96
+    }
+
     private data class SnapshotCell(
         val type: Int,
         val stringValue: String? = null,
@@ -47,6 +65,15 @@ class PerformanceMode : Feature("Performance Mode") {
         val rows: List<List<SnapshotCell>>,
     )
 
+    private data class MessageWindowState(
+        val conversationId: String,
+        val currentSize: Int,
+        val oldestOrderKey: Long?,
+        val newestOrderKey: Long?,
+        val updatedAt: Long,
+        val isGroup: Boolean,
+    )
+
     override fun init() {
         val profile = context.config.global.performanceMode.profile.getNullable() ?: return
         val isMaxProfile = profile == "max"
@@ -56,6 +83,7 @@ class PerformanceMode : Feature("Performance Mode") {
             Process.THREAD_PRIORITY_MORE_FAVORABLE
         }
         val minimumFrameRate = if (isMaxProfile) 60 else 45
+        val minimumRecordingFrameRate = if (isMaxProfile) 30 else 24
         val durationScale = if (isMaxProfile) 0.35f else 0.55f
         val recyclerViewCacheSize = if (isMaxProfile) 64 else 32
         val maxRequests = if (isMaxProfile) 192 else 96
@@ -63,11 +91,16 @@ class PerformanceMode : Feature("Performance Mode") {
         val minimumCoreThreads = if (isMaxProfile) 16 else 8
         val prefetchItemCount = if (isMaxProfile) 24 else 12
         val maxAnimationDurationMs = if (isMaxProfile) 90L else 140L
-        val maxScrollDurationMs = if (isMaxProfile) 120 else 180
+        val maxScrollDurationMs = if (isMaxProfile) 72 else 180
         val preferredRefreshRate = if (isMaxProfile) 120f else 90f
+        val snapMapTransitionDurationMs = if (isMaxProfile) 0L else 24L
+        val snapMapCameraDurationMs = if (isMaxProfile) 16L else 64L
+        val snapMapMoveDurationMs = if (isMaxProfile) 8L else 40L
+        val snapMapPrefetchZoomDelta = if (isMaxProfile) 6 else 3
+        val preferredJavaThreadPriority = if (isMaxProfile) Thread.NORM_PRIORITY + 2 else Thread.NORM_PRIORITY + 1
 
         context.log.info(
-            "Performance mode enabled: profile=$profile, threadPriority=$threadPriority, minFps=$minimumFrameRate, durationScale=$durationScale, rvCache=$recyclerViewCacheSize, maxRequests=$maxRequests/$maxRequestsPerHost, minCoreThreads=$minimumCoreThreads, prefetch=$prefetchItemCount, maxAnimMs=$maxAnimationDurationMs, maxScrollMs=$maxScrollDurationMs, preferredRefreshRate=$preferredRefreshRate",
+            "Performance mode enabled: profile=$profile, threadPriority=$threadPriority, minFps=$minimumFrameRate, minRecordingFps=$minimumRecordingFrameRate, durationScale=$durationScale, rvCache=$recyclerViewCacheSize, maxRequests=$maxRequests/$maxRequestsPerHost, minCoreThreads=$minimumCoreThreads, prefetch=$prefetchItemCount, maxAnimMs=$maxAnimationDurationMs, maxScrollMs=$maxScrollDurationMs, preferredRefreshRate=$preferredRefreshRate, snapMapTransitionMs=$snapMapTransitionDurationMs, snapMapCameraMs=$snapMapCameraDurationMs, snapMapMoveMs=$snapMapMoveDurationMs, snapMapPrefetchZoomDelta=$snapMapPrefetchZoomDelta, javaThreadPriority=$preferredJavaThreadPriority",
             "PerformanceMode"
         )
 
@@ -91,38 +124,58 @@ class PerformanceMode : Feature("Performance Mode") {
         val executorLog = firstHitLogger("ThreadPoolExecutor.constructor")
         val dispatcherLog = firstHitLogger("OkHttp.Dispatcher.constructor")
         val animatorLog = firstHitLogger("ValueAnimator.getDurationScale")
-        val animatorDurationLog = firstHitLogger("ValueAnimator.setDuration")
-        val viewAnimatorDurationLog = firstHitLogger("ViewPropertyAnimator.setDuration")
-        val transitionDurationLog = firstHitLogger("Transition.setDuration")
-        val animationDurationLog = firstHitLogger("Animation.setDuration")
         val recyclerCtorLog = firstHitLogger("RecyclerView.constructor")
         val recyclerAdapterLog = firstHitLogger("RecyclerView.setAdapter")
         val recyclerLayoutManagerLog = firstHitLogger("RecyclerView.setLayoutManager")
         val sqliteOpenLog = firstHitLogger("SQLiteDatabase.openDatabase")
         val sqliteCreateLog = firstHitLogger("SQLiteDatabase.openOrCreateDatabase")
         val mediaRecorderLog = firstHitLogger("MediaRecorder.setVideoFrameRate")
-        val captureRequestLog = firstHitLogger("CaptureRequest.Builder.set")
-        val sustainedModeLog = firstHitLogger("Window.setSustainedPerformanceMode")
-        val refreshRateLog = firstHitLogger("Activity.preferredRefreshRate")
         val overScrollerLog = firstHitLogger("OverScroller.startScroll")
-        val chatFeedCacheServeLog = firstHitLogger("ChatFeed.cacheServe")
-        val chatFeedCacheRefreshLog = firstHitLogger("ChatFeed.cacheRefresh")
         val mapDialogLog = firstHitLogger("Dialog.show")
         val mapViewLog = firstHitLogger("MapView.constructor")
         val mapboxNetworkBlockLog = firstHitLogger("SnapMap.telemetryBlock")
         val mapCameraAnimLog = firstHitLogger("SnapMap.mapAnimatorDuration")
         val mapThreadLog = firstHitLogger("SnapMap.mapThread")
         val mapRendererFpsLog = firstHitLogger("SnapMap.mapRendererFps")
-
+        val mapTransitionLog = firstHitLogger("SnapMap.transitionOptions")
+        val mapMoveLog = firstHitLogger("SnapMap.moveDuration")
         fun isPerformanceSensitiveThread(name: String?): Boolean {
             val normalizedName = name?.lowercase() ?: return false
-            return listOf("camera", "preview", "codec", "render", "gl", "transcod", "lens", "feed", "story", "opera", "messag", "network", "db", "disk", "map", "mapbox", "snapmap", "viewport").any {
+            return listOf("codec", "transcod", "feed", "story", "opera", "messag", "network", "db", "disk", "map", "mapbox", "snapmap", "viewport").any {
                 normalizedName.contains(it)
             }
         }
 
+        fun clampPositiveDuration(durationMs: Long, maxDurationMs: Long): Long {
+            if (durationMs <= 0L) return durationMs
+            return durationMs.coerceAtMost(maxDurationMs)
+        }
+
         val performanceCacheDir = File(context.androidContext.filesDir, "performance_mode_cache").apply { mkdirs() }
         val chatFeedSnapshotFile = File(performanceCacheDir, "chat_feed_snapshot.json")
+        val lastChatFeedSnapshotWrite = AtomicLong(0L)
+        val chatFeedSnapshotServedThisProcess = AtomicBoolean(false)
+
+        val windowStatePrefs = context.androidContext.getSharedPreferences("purrfectsnap_perf_message_windows", Context.MODE_PRIVATE)
+        val messageWindowStates = runCatching {
+            val raw = windowStatePrefs.getString("states", null).orEmpty()
+            if (raw.isBlank()) {
+                LinkedHashMap<String, MessageWindowState>()
+            } else {
+                context.gson.fromJson<LinkedHashMap<String, MessageWindowState>>(
+                    raw,
+                    object : TypeToken<LinkedHashMap<String, MessageWindowState>>() {}.type
+                ) ?: LinkedHashMap()
+            }
+        }.getOrElse { LinkedHashMap() }
+
+        fun persistMessageWindowStates() {
+            runCatching {
+                windowStatePrefs.edit().putString("states", context.gson.toJson(messageWindowStates)).apply()
+            }.onFailure {
+                context.log.error("Failed to persist message window states", it, "PerformanceMode")
+            }
+        }
 
         fun isChatFeedQuery(sql: String): Boolean {
             val normalized = sql.uppercase()
@@ -144,7 +197,9 @@ class PerformanceMode : Feature("Performance Mode") {
                 Cursor.FIELD_TYPE_STRING -> SnapshotCell(Cursor.FIELD_TYPE_STRING, stringValue = cursor.getString(index))
                 Cursor.FIELD_TYPE_BLOB -> SnapshotCell(
                     Cursor.FIELD_TYPE_BLOB,
-                    blobValue = Base64.encodeToString(cursor.getBlob(index), Base64.NO_WRAP)
+                    blobValue = cursor.getBlob(index)
+                        ?.takeIf { it.size <= CHAT_FEED_CACHE_MAX_BLOB_BYTES }
+                        ?.let { Base64.encodeToString(it, Base64.NO_WRAP) }
                 )
                 else -> SnapshotCell(Cursor.FIELD_TYPE_STRING, stringValue = cursor.getString(index))
             }
@@ -154,9 +209,11 @@ class PerformanceMode : Feature("Performance Mode") {
             val columns = cursor.columnNames.toList()
             val rows = mutableListOf<List<SnapshotCell>>()
             if (cursor.moveToFirst()) {
+                var rowCount = 0
                 do {
                     rows += columns.indices.map { index -> cursorCell(cursor, index) }
-                } while (cursor.moveToNext())
+                    rowCount++
+                } while (rowCount < CHAT_FEED_CACHE_MAX_ROWS && cursor.moveToNext())
             }
             return CursorSnapshot(columns, rows)
         }
@@ -201,12 +258,6 @@ class PerformanceMode : Feature("Performance Mode") {
                     context.log.info("Invalidated chat feed snapshot after friends mutation sync", "PerformanceMode")
                 }
             }
-            if (url.contains("messaging") || url.contains("conversation") || url.contains("feed")) {
-                if (chatFeedSnapshotFile.exists()) {
-                    chatFeedSnapshotFile.delete()
-                    context.log.info("Invalidated chat feed snapshot after messaging/feed network activity", "PerformanceMode")
-                }
-            }
             if (url.contains("mapbox") && (url.contains("events.") || url.contains("telemetry"))) {
                 event.canceled = true
                 mapboxNetworkBlockLog("url=$url")
@@ -237,7 +288,7 @@ class PerformanceMode : Feature("Performance Mode") {
             val thread = param.thisObject<Thread>()
             if (!isPerformanceSensitiveThread(thread.name)) return@hook
             runCatching {
-                thread.priority = Thread.MAX_PRIORITY
+                thread.priority = preferredJavaThreadPriority
             }
             threadStartLog("name=${thread.name} priority=${thread.priority}")
             if ((thread.name ?: "").contains("map", ignoreCase = true) || (thread.name ?: "").contains("mapbox", ignoreCase = true)) {
@@ -272,51 +323,10 @@ class PerformanceMode : Feature("Performance Mode") {
             animatorLog("durationScale=$durationScale")
         }
 
-        ValueAnimator::class.java.hook("setDuration", HookStage.BEFORE) { param ->
-            val original = param.arg<Long>(0)
-            val updated = original.coerceAtMost(maxAnimationDurationMs)
-            if (updated != original) {
-                param.setArg(0, updated)
-            }
-            animatorDurationLog("requested=$original applied=${param.arg<Long>(0)}")
-            val thisObject = param.nullableThisObject<Any>()?.javaClass?.name ?: ""
-            if (thisObject.contains("map", ignoreCase = true)) {
-                mapCameraAnimLog("owner=$thisObject requested=$original applied=${param.arg<Long>(0)}")
-            }
-        }
-
-        ViewPropertyAnimator::class.java.hook("setDuration", HookStage.BEFORE) { param ->
-            val original = param.arg<Long>(0)
-            val updated = original.coerceAtMost(maxAnimationDurationMs)
-            if (updated != original) {
-                param.setArg(0, updated)
-            }
-            viewAnimatorDurationLog("requested=$original applied=${param.arg<Long>(0)}")
-        }
-
-        Transition::class.java.hook("setDuration", HookStage.BEFORE) { param ->
-            val original = param.arg<Long>(0)
-            val updated = original.coerceAtMost(maxAnimationDurationMs)
-            if (updated != original) {
-                param.setArg(0, updated)
-            }
-            transitionDurationLog("requested=$original applied=${param.arg<Long>(0)}")
-        }
-
-        Animation::class.java.hook("setDuration", HookStage.BEFORE) { param ->
-            val original = param.arg<Long>(0)
-            val updated = original.coerceAtMost(maxAnimationDurationMs)
-            if (updated != original) {
-                param.setArg(0, updated)
-            }
-            animationDurationLog("requested=$original applied=${param.arg<Long>(0)}")
-        }
-
         RecyclerView::class.java.hookConstructor(HookStage.AFTER) { param ->
             val recyclerView = param.thisObject<RecyclerView>()
             recyclerView.setItemViewCacheSize(recyclerViewCacheSize)
             recyclerView.overScrollMode = View.OVER_SCROLL_NEVER
-            recyclerView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
             if (isMaxProfile) {
                 recyclerView.itemAnimator = null
             }
@@ -326,7 +336,6 @@ class PerformanceMode : Feature("Performance Mode") {
         RecyclerView::class.java.hook("setAdapter", HookStage.AFTER) { param ->
             val recyclerView = param.thisObject<RecyclerView>()
             recyclerView.setItemViewCacheSize(recyclerViewCacheSize)
-            recyclerView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
             if (isMaxProfile) {
                 recyclerView.itemAnimator = null
             }
@@ -346,7 +355,6 @@ class PerformanceMode : Feature("Performance Mode") {
                     layoutManager.gapStrategy = StaggeredGridLayoutManager.GAP_HANDLING_MOVE_ITEMS_BETWEEN_SPANS
                 }
             }
-            recyclerView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
             recyclerLayoutManagerLog("layoutManager=${layoutManager?.javaClass?.name} prefetch=$prefetchItemCount")
         }
 
@@ -375,8 +383,11 @@ class PerformanceMode : Feature("Performance Mode") {
 
         MediaRecorder::class.java.hook("setVideoFrameRate", HookStage.BEFORE) { param ->
             val currentRate = param.arg<Int>(0)
-            if (currentRate < minimumFrameRate) {
-                param.setArg(0, minimumFrameRate)
+            val applied = currentRate
+                .coerceAtLeast(minimumRecordingFrameRate)
+                .coerceAtMost(if (isMaxProfile) 60 else 45)
+            if (applied != currentRate) {
+                param.setArg(0, applied)
             }
             mediaRecorderLog("requested=$currentRate applied=${param.arg<Int>(0)}")
         }
@@ -401,27 +412,9 @@ class PerformanceMode : Feature("Performance Mode") {
             }
         }
 
-        CaptureRequest.Builder::class.java.hook("set", HookStage.BEFORE) { param ->
-            val key = param.arg<CaptureRequest.Key<*>>(0)
-            captureRequestLog("key=${key.name} value=${param.argNullable<Any>(1)}")
-        }
-
         fun applyActivityPerformanceTuning(activity: Activity) {
             runCatching {
-                activity.window.decorView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
-                val display = activity.display
-                val targetRefreshRate = display?.supportedModes?.maxByOrNull { it.refreshRate }?.refreshRate
-                    ?.coerceAtLeast(preferredRefreshRate) ?: preferredRefreshRate
-                activity.window.attributes = activity.window.attributes.apply {
-                    this.preferredRefreshRate = targetRefreshRate
-                }
-                refreshRateLog("activity=${activity::class.java.name} refreshRate=$targetRefreshRate")
-            }
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isMaxProfile) {
-                runCatching {
-                    activity.window.setSustainedPerformanceMode(true)
-                    sustainedModeLog("activity=${activity::class.java.name}")
-                }
+                activity.window.setWindowAnimations(0)
             }
         }
 
@@ -434,10 +427,6 @@ class PerformanceMode : Feature("Performance Mode") {
             val window = dialog.window ?: return@hook
             runCatching {
                 window.setWindowAnimations(0)
-                window.decorView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
-                window.attributes = window.attributes.apply {
-                    flags = flags or WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED
-                }
                 if (dialog::class.java.name.contains("map", ignoreCase = true) || dialog::class.java.name.contains("snap", ignoreCase = true)) {
                     mapDialogLog("class=${dialog::class.java.name}")
                 }
@@ -447,7 +436,6 @@ class PerformanceMode : Feature("Performance Mode") {
         runCatching {
             findClass("com.mapbox.mapboxsdk.maps.MapView").hookConstructor(HookStage.AFTER) { param ->
                 val mapView = param.nullableThisObject<Any>() as? View ?: return@hookConstructor
-                mapView.setLayerType(View.LAYER_TYPE_HARDWARE, null)
                 mapView.overScrollMode = View.OVER_SCROLL_NEVER
                 mapViewLog("class=${mapView::class.java.name}")
             }
@@ -464,14 +452,165 @@ class PerformanceMode : Feature("Performance Mode") {
             }
         }
 
+        runCatching {
+            val nativeMapViewClass = findClass("com.mapbox.mapboxsdk.maps.NativeMapView")
+            val transitionOptionsClass = findClass("com.mapbox.mapboxsdk.style.layers.TransitionOptions")
+            val transitionOptionsCtor = transitionOptionsClass.getDeclaredConstructor(Long::class.javaPrimitiveType, Long::class.javaPrimitiveType, Boolean::class.javaPrimitiveType).apply {
+                isAccessible = true
+            }
+
+            fun findNativeMapMethod(name: String, predicate: (Method) -> Boolean): Method? {
+                return nativeMapViewClass.findRestrictedMethod { method ->
+                    method.name == name && predicate(method)
+                }?.apply {
+                    isAccessible = true
+                }
+            }
+
+            val nativeCancelTransitions = findNativeMapMethod("nativeCancelTransitions") { it.parameterCount == 0 }
+            val nativeSetPrefetchTiles = findNativeMapMethod("nativeSetPrefetchTiles") { it.parameterCount == 1 && it.parameterTypes[0] == Boolean::class.javaPrimitiveType }
+            val nativeSetPrefetchZoomDelta = findNativeMapMethod("nativeSetPrefetchZoomDelta") { it.parameterCount == 1 && it.parameterTypes[0] == Int::class.javaPrimitiveType }
+            val nativeSetTransitionDelay = findNativeMapMethod("nativeSetTransitionDelay") { it.parameterCount == 1 && it.parameterTypes[0] == Long::class.javaPrimitiveType }
+            val nativeSetTransitionDuration = findNativeMapMethod("nativeSetTransitionDuration") { it.parameterCount == 1 && it.parameterTypes[0] == Long::class.javaPrimitiveType }
+            val nativeSetTransitionOptions = findNativeMapMethod("nativeSetTransitionOptions") { it.parameterCount == 1 && it.parameterTypes[0].name == transitionOptionsClass.name }
+
+            nativeMapViewClass.hookConstructor(HookStage.AFTER) { param ->
+                val nativeMapView = param.thisObject<Any>()
+                runCatching {
+                    nativeSetPrefetchTiles?.invoke(nativeMapView, true)
+                    nativeSetPrefetchZoomDelta?.invoke(nativeMapView, snapMapPrefetchZoomDelta)
+                    nativeSetTransitionDelay?.invoke(nativeMapView, 0L)
+                    nativeSetTransitionDuration?.invoke(nativeMapView, snapMapTransitionDurationMs)
+                    nativeSetTransitionOptions?.invoke(
+                        nativeMapView,
+                        transitionOptionsCtor.newInstance(snapMapTransitionDurationMs, 0L, false)
+                    )
+                    nativeCancelTransitions?.invoke(nativeMapView)
+                    mapTransitionLog("transitionMs=$snapMapTransitionDurationMs prefetchZoomDelta=$snapMapPrefetchZoomDelta placementTransitions=false")
+                }
+            }
+
+            nativeMapViewClass.findRestrictedMethod { method ->
+                method.name == "g" &&
+                    method.parameterCount == 6 &&
+                    method.parameterTypes.last() == Long::class.javaPrimitiveType
+            }?.hook(HookStage.BEFORE) { param ->
+                val original = param.arg<Long>(5)
+                val applied = clampPositiveDuration(original, snapMapCameraDurationMs)
+                if (applied != original) {
+                    param.setArg(5, applied)
+                }
+                runCatching { nativeCancelTransitions?.invoke(param.thisObject<Any>()) }
+                mapCameraAnimLog("requested=$original applied=${param.arg<Long>(5)}")
+            }
+
+            nativeMapViewClass.findRestrictedMethod { method ->
+                method.name == "v" &&
+                    method.parameterCount == 3 &&
+                    method.parameterTypes[0] == Double::class.javaPrimitiveType &&
+                    method.parameterTypes[1] == Double::class.javaPrimitiveType &&
+                    method.parameterTypes[2] == Long::class.javaPrimitiveType
+            }?.hook(HookStage.BEFORE) { param ->
+                val original = param.arg<Long>(2)
+                val applied = clampPositiveDuration(original, snapMapMoveDurationMs)
+                if (applied != original) {
+                    param.setArg(2, applied)
+                }
+                runCatching { nativeCancelTransitions?.invoke(param.thisObject<Any>()) }
+                mapMoveLog("requested=$original applied=${param.arg<Long>(2)}")
+            }
+        }.onFailure {
+            context.log.error("Failed to install Snap Map transition hooks", it, "PerformanceMode")
+        }
+
+        runCatching {
+            findClass("com.snapchat.client.messaging.MessageWindowManager\$CppProxy").hook("initWindow", HookStage.BEFORE) { param ->
+                if (!isMaxProfile) return@hook
+
+                val conversationId = runCatching {
+                    SnapUUID(param.arg(0)).toString()
+                }.getOrNull()?.takeIf { it.isNotBlank() } ?: return@hook
+
+                val initParams = param.arg<Any>(1)
+                val conversationType = context.database.getConversationType(conversationId) ?: return@hook
+                val isGroup = conversationType == 1
+                val savedState = synchronized(messageWindowStates) {
+                    messageWindowStates[conversationId]
+                        ?.takeIf { System.currentTimeMillis() - it.updatedAt <= MESSAGE_WINDOW_STATE_MAX_AGE_MS }
+                }
+
+                val enumConstants = initParams.getObjectField("mStartingType")?.javaClass?.enumConstants ?: return@hook
+                if (savedState != null) {
+                    val restoredMaxSize = if (savedState.isGroup) {
+                        savedState.currentSize.coerceAtLeast(220).coerceAtMost(520)
+                    } else {
+                        savedState.currentSize.coerceAtLeast(140).coerceAtMost(320)
+                    }
+                    val restoredForward = (savedState.currentSize + if (savedState.isGroup) 24 else 16).coerceAtMost(restoredMaxSize)
+                    val restoredBack = if (savedState.isGroup) 180 else 120
+                    initParams.setObjectField("mStartingType", enumConstants.firstOrNull { it.toString() == "MESSAGE" } ?: return@hook)
+                    initParams.setObjectField("mStartingOrderKey", savedState.oldestOrderKey ?: savedState.newestOrderKey)
+                    initParams.setObjectField("mMaxSize", restoredMaxSize)
+                    initParams.setObjectField("mNumMessagesForward", restoredForward)
+                    initParams.setObjectField("mNumMessagesBack", restoredBack)
+
+                    val warmupAmount = if (savedState.isGroup) REOPEN_WARMUP_GROUP_MESSAGES else REOPEN_WARMUP_DM_MESSAGES
+                    val oldestKey = savedState.oldestOrderKey
+                    if (oldestKey != null) {
+                        context.feature(Messaging::class).conversationManager?.fetchConversationWithMessagesPaginated(
+                            conversationId = conversationId,
+                            lastMessageId = oldestKey,
+                            amount = warmupAmount,
+                            onSuccess = {},
+                            onError = {}
+                        )
+                    }
+                }
+            }
+        }.onFailure {
+            context.log.error("Failed to install saved message window restore hooks", it, "PerformanceMode")
+        }
+
+        context.mappings.useMapper(CallbackMapper::class) {
+            callbacks.getClass("MessageWindowManagerDelegate")?.hook("onWindowUpdated", HookStage.AFTER) { param ->
+                if (!isMaxProfile) return@hook
+
+                val conversationId = runCatching { SnapUUID(param.arg(0)).toString() }.getOrNull() ?: return@hook
+                val update = param.arg<Any>(2)
+                val pagination = update.getObjectField("mPagination") ?: return@hook
+                val currentSize = pagination.getObjectField("mCurrentSize") as? Int ?: return@hook
+                val oldestOrderKey = pagination.getObjectField("mOldestOrderKey") as? Long
+                val newestOrderKey = pagination.getObjectField("mNewestOrderKey") as? Long
+                val conversationType = context.database.getConversationType(conversationId) ?: 0
+                val isGroup = conversationType == 1
+
+                synchronized(messageWindowStates) {
+                    messageWindowStates[conversationId] = MessageWindowState(
+                        conversationId = conversationId,
+                        currentSize = currentSize.coerceAtMost(if (isGroup) 420 else 260),
+                        oldestOrderKey = oldestOrderKey,
+                        newestOrderKey = newestOrderKey,
+                        updatedAt = System.currentTimeMillis(),
+                        isGroup = isGroup
+                    )
+                    while (messageWindowStates.size > MESSAGE_WINDOW_STATE_MAX_CONVERSATIONS) {
+                        val eldestKey = messageWindowStates.entries.minByOrNull { it.value.updatedAt }?.key ?: break
+                        messageWindowStates.remove(eldestKey)
+                    }
+                    persistMessageWindowStates()
+                }
+            }
+        }
+
         runCatching {
             findClass("io.requery.android.database.sqlite.SQLiteDatabase").hook("rawQueryWithFactory", HookStage.BEFORE) { param ->
                 if (!isMaxProfile) return@hook
                 val sql = param.argNullable<String>(1) ?: return@hook
                 if (!isChatFeedQuery(sql)) return@hook
+                if (chatFeedSnapshotServedThisProcess.get()) return@hook
                 readSnapshot(chatFeedSnapshotFile)?.let { snapshot ->
                     param.setResult(snapshotToMatrixCursor(snapshot))
-                    chatFeedCacheServeLog("rows=${snapshot.rows.size} file=${chatFeedSnapshotFile.name}")
+                    chatFeedSnapshotServedThisProcess.set(true)
                 }
             }
 
@@ -479,15 +618,18 @@ class PerformanceMode : Feature("Performance Mode") {
                 if (!isMaxProfile) return@hook
                 val sql = param.argNullable<String>(1) ?: return@hook
                 if (!isChatFeedQuery(sql)) return@hook
+                if (chatFeedSnapshotFile.exists()) return@hook
                 val cursor = param.getResult() as? Cursor ?: return@hook
+                val now = System.currentTimeMillis()
+                if (now - lastChatFeedSnapshotWrite.get() < CHAT_FEED_CACHE_MIN_REFRESH_INTERVAL_MS) return@hook
                 val snapshot = snapshotFromCursor(cursor)
+                if (snapshot.rows.isEmpty()) return@hook
                 writeSnapshot(chatFeedSnapshotFile, snapshot)
-                param.setResult(snapshotToMatrixCursor(snapshot))
-                runCatching { cursor.close() }
-                chatFeedCacheRefreshLog("rows=${snapshot.rows.size} file=${chatFeedSnapshotFile.name}")
+                lastChatFeedSnapshotWrite.set(now)
             }
         }.onFailure {
             context.log.error("Failed to install chat feed cache hooks", it, "PerformanceMode")
         }
+
     }
 }

core/src/main/kotlin/me/eternal/purrfectsnap/core/wrapper/impl/ConversationManager.kt

@@ -30,6 +30,7 @@ class ConversationManager(
     private val fetchConversationWithMessagesMethod by lazy { findMethodByName("fetchConversationWithMessages") }
     private val fetchMessageByServerId by lazy { findMethodByName("fetchMessageByServerId") }
     private val fetchMessagesByServerIds by lazy { findMethodByName("fetchMessagesByServerIds") }
+    private val fetchPrefetchableMessagesForConversationsMethod by lazy { findMethodByName("fetchPrefetchableMessagesForConversations") }
     private val displayedMessagesMethod by lazy { findMethodByName("displayedMessages") }
     private val fetchMessage by lazy { findMethodByName("fetchMessage") }
     private val clearConversation by lazy { findMethodByName("clearConversation") }
@@ -163,6 +164,37 @@ class ConversationManager(
         )
     }
 
+    fun fetchPrefetchableMessagesForConversations(
+        conversationIds: List<String>,
+        strategyName: String,
+        messagesPerConversation: Int,
+        onSuccess: (List<Message>) -> Unit = {},
+        onError: (error: String) -> Unit = {}
+    ) {
+        val prefetchRequestClass = fetchPrefetchableMessagesForConversationsMethod.parameterTypes.firstOrNull {
+            it.name == "com.snapchat.client.messaging.PrefetchRequest"
+        } ?: error("PrefetchRequest parameter type not found")
+        val strategyClass = context.androidContext.classLoader.loadClass("com.snapchat.client.messaging.PrefetchStrategy")
+        val strategy = strategyClass.enumConstants?.firstOrNull { it.toString() == strategyName }
+            ?: error("PrefetchStrategy $strategyName not found")
+        val prefetchRequest = prefetchRequestClass
+            .getConstructor(strategyClass, Int::class.javaPrimitiveType)
+            .newInstance(strategy, messagesPerConversation)
+
+        fetchPrefetchableMessagesForConversationsMethod.invoke(
+            instanceNonNull(),
+            conversationIds.map { it.toSnapUUID().instanceNonNull() }.toCollection(ArrayList()),
+            prefetchRequest,
+            CallbackBuilder(getCallbackClass("FetchMessagesCallback"))
+                .override("onFetchMessagesComplete") { param ->
+                    onSuccess(param.arg<List<*>>(0).map { Message(it) })
+                }
+                .override("onError") {
+                    onError(it.arg<Any>(0).toString())
+                }.build()
+        )
+    }
+
     fun clearConversation(conversationId: String, onSuccess: () -> Unit, onError: (error: String) -> Unit) {
         val callback = CallbackBuilder(getCallbackClass("Callback"))
             .override("onSuccess") { onSuccess() }

core/src/main/kotlin/me/eternal/purrfectsnap/core/wrapper/impl/SnapUUID.kt

@@ -19,6 +19,14 @@ fun UUID.toBytes(): ByteArray =
 class SnapUUID(
     private val obj: Any?
 ) : AbstractWrapper(obj) {
+    private fun extractUuidBytesFromObject(any: Any): ByteArray? {
+        runCatching { any.getObjectField("mId") as? ByteArray }.getOrNull()?.let { return it }
+        runCatching { any.javaClass.getMethod("getId").invoke(any) as? ByteArray }.getOrNull()?.let { return it }
+        runCatching { any.javaClass.getMethod("getUuid").invoke(any) as? ByteArray }.getOrNull()?.let { return it }
+        runCatching { any.javaClass.getMethod("uuid").invoke(any) as? ByteArray }.getOrNull()?.let { return it }
+        return null
+    }
+
     private val uuidBytes by lazy {
         when {
             obj is String -> {
@@ -38,6 +46,10 @@ class SnapUUID(
                     any.getObjectField("mId") as ByteArray
                 }
             }
+            obj is Any -> {
+                extractUuidBytesFromObject(obj)
+                    ?: runCatching { UUID.fromString(obj.toString()).toBytes() }.getOrElse { ByteArray(16) }
+            }
             else -> ByteArray(16)
         }
     }

gradle.properties

@@ -7,8 +7,8 @@ org.gradle.configuration-cache=true
 org.gradle.configuration-cache.problems=warn
 nativeAbis=arm64-v8a
 
-APP_VERSION_NAME=1.6.6
-APP_VERSION_CODE=322
+APP_VERSION_NAME=1.6.8
+APP_VERSION_CODE=324
 debug_build_hash=18fe2a814d0e2eb5
 psIntegrityPinnedSha256=
 EXPECTED_CERT_SHA256=0f188cb17d8ea4902ee15ce98f4928ba4226a4790fa3c52f62d776b08e46ca1c

valdi/src/main/ts/imports.ts

@@ -5,10 +5,16 @@ declare var _runtimeName: string;
 export const runtimeName = _runtimeName;
 
 let remoteImports: any = null;
-try {
-    remoteImports = require(_runtimeName + "_core/DeviceBridge")?.[_getImportsFunctionName]?.();
-} catch {
-    remoteImports = null;
+for (const moduleName of ["DeviceBridge", "Device"]) {
+    try {
+        const imports = require(_runtimeName + "_core/" + moduleName)?.[_getImportsFunctionName]?.();
+        if (imports != null) {
+            remoteImports = imports;
+            break;
+        }
+    } catch {
+        // Some Snapchat builds expose DeviceBridge, others only Device.
+    }
 }
 
 function callRemoteFunction(method: string, ...args: any[]): any | null {