From 0bf23c2a773561ae0ff467ab9e2405061a053e36 Mon Sep 17 00:00:00 2001 From: ajp_anton Date: Sat, 3 Oct 2026 08:07:03 +0000 Subject: [PATCH] Add content search and improve log browsing Add persistent encrypted content searches with regex, literal, AND/OR terms and highlighted non-overlapping matches. Combine them with app filtering and clear both filters together. Index encrypted log chunks for direct access, bound the viewport cache, and prefetch around unloaded rows. Improve loading feedback, scroll-to-top timing, row spacing and expansion behavior, with unit and Android device coverage. --- .gitignore | 1 + README.md | 6 + .../LogSearchDeviceTest.kt | 164 +++++ .../notificationsmaster/LogViewDeviceTest.kt | 490 +++++++++++++++ .../data/NotificationLogIndexDeviceTest.kt | 151 +++++ .../LogSearchDialogFragment.kt | 135 +++++ .../notificationsmaster/MainActivity.kt | 41 +- .../notificationsmaster/SettingsFragment.kt | 7 +- .../notificationsmaster/ViewLogsFragment.kt | 572 ++++++++++++++---- .../data/EncryptedAtomicFile.kt | 4 +- .../data/EncryptedImageStore.kt | 2 +- .../data/EncryptedNotificationLogStore.kt | 197 ++++-- .../data/LogWindowCache.kt | 46 ++ .../data/NotificationLogIndex.kt | 65 ++ .../search/LogContentSearch.kt | 177 ++++++ .../settings/LogSearchStore.kt | 37 ++ .../res/drawable/ic_clear_log_filters.xml | 3 + app/src/main/res/drawable/ic_log_search.xml | 3 + .../res/drawable/ic_log_search_active.xml | 3 + .../main/res/layout/fragment_view_logs.xml | 27 + app/src/main/res/values-night/log_search.xml | 3 + app/src/main/res/values/log_search.xml | 7 + .../data/LogWindowCacheTest.kt | 44 ++ .../search/LogContentSearchTest.kt | 101 ++++ 24 files changed, 2104 insertions(+), 182 deletions(-) create mode 100644 app/src/androidTest/java/se/ajpanton/notificationsmaster/LogSearchDeviceTest.kt create mode 100644 app/src/androidTest/java/se/ajpanton/notificationsmaster/LogViewDeviceTest.kt create mode 100644 app/src/androidTest/java/se/ajpanton/notificationsmaster/data/NotificationLogIndexDeviceTest.kt create mode 100644 app/src/main/java/se/ajpanton/notificationsmaster/LogSearchDialogFragment.kt create mode 100644 app/src/main/java/se/ajpanton/notificationsmaster/data/LogWindowCache.kt create mode 100644 app/src/main/java/se/ajpanton/notificationsmaster/data/NotificationLogIndex.kt create mode 100644 app/src/main/java/se/ajpanton/notificationsmaster/search/LogContentSearch.kt create mode 100644 app/src/main/java/se/ajpanton/notificationsmaster/settings/LogSearchStore.kt create mode 100644 app/src/main/res/drawable/ic_clear_log_filters.xml create mode 100644 app/src/main/res/drawable/ic_log_search.xml create mode 100644 app/src/main/res/drawable/ic_log_search_active.xml create mode 100644 app/src/main/res/values-night/log_search.xml create mode 100644 app/src/main/res/values/log_search.xml create mode 100644 app/src/test/java/se/ajpanton/notificationsmaster/data/LogWindowCacheTest.kt create mode 100644 app/src/test/java/se/ajpanton/notificationsmaster/search/LogContentSearchTest.kt diff --git a/.gitignore b/.gitignore index 6bacd9b..f135ff3 100644 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,7 @@ keystore.properties # Gradle and Android build output /.gradle/ /.gradle-tmp/ +/.kotlin/ /build/ /*/build/ /.externalNativeBuild/ diff --git a/README.md b/README.md index 7ad1b9a..1200c31 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,12 @@ expanded for long entries, and exported as CSV, aligned text, or an HTML ZIP. Only the HTML ZIP includes saved notification images; CSV and aligned text use an `[image]` marker instead. +The viewer loads nearby logs on demand rather than keeping the whole history in +memory. Fast scrolling can briefly show empty rows while their contents load. +Filter by app or search notification text using literal text, regular +expressions, or all/any search terms. Matching text is highlighted; search +filters are remembered until cleared, and search text is stored encrypted. + ## Privacy Logs and retained notification images are encrypted on the device with an diff --git a/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogSearchDeviceTest.kt b/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogSearchDeviceTest.kt new file mode 100644 index 0000000..76edfca --- /dev/null +++ b/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogSearchDeviceTest.kt @@ -0,0 +1,164 @@ +package se.ajpanton.notificationsmaster + +import android.os.SystemClock +import android.text.Spanned +import android.text.style.BackgroundColorSpan +import android.view.View +import android.view.ViewGroup +import android.widget.CheckBox +import android.widget.Spinner +import android.widget.TextView +import androidx.appcompat.widget.Toolbar +import androidx.recyclerview.widget.RecyclerView +import androidx.test.core.app.ActivityScenario +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import se.ajpanton.notificationsmaster.data.EncryptedNotificationLogStore +import se.ajpanton.notificationsmaster.model.NotificationAction +import se.ajpanton.notificationsmaster.model.NotificationLogEntry +import se.ajpanton.notificationsmaster.search.LogSearchSettings +import se.ajpanton.notificationsmaster.search.SearchMode +import se.ajpanton.notificationsmaster.settings.LogAppFilterStore +import se.ajpanton.notificationsmaster.settings.LogSearchStore +import se.ajpanton.notificationsmaster.settings.LogViewSettings +import se.ajpanton.notificationsmaster.settings.LogViewSettingsStore +import java.io.File + +@RunWith(AndroidJUnit4::class) +class LogSearchDeviceTest { + private val context = InstrumentationRegistry.getInstrumentation().targetContext + private val store = EncryptedNotificationLogStore(context) + private val search = LogSearchStore(context) + private val apps = LogAppFilterStore(context) + + @Before @After fun clear() { + store.clear() + search.clear() + apps.clear() + LogViewSettingsStore(context).save(LogViewSettings()) + } + + private fun append(text: String?, packageName: String = "test.app", previous: String? = null) = store.append( + NotificationLogEntry(recordedAtEpochMillis = 0, packageName = packageName, appName = "Some app", + action = if (previous == null) NotificationAction.APPEARED else NotificationAction.EDITED, + contents = text, previousContents = previous)) + + @Test fun exactNonGreedyHighlightsCombineWithAppFilterAndResetTogether() { + append("there is some text and here is some more") + append("there is some text and here is some more", "test.other") + append("Other text") + search.save(LogSearchSettings("here there", SearchMode.AND)) + apps.save(listOf(LogAppFilterStore.App("Some app", "test.app"))) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { count(it) == 1 && message(it)?.text is Spanned } + scenario.onActivity { activity -> + val value = message(activity)!!.text as Spanned + val matches = value.getSpans(0, value.length, BackgroundColorSpan::class.java) + .map { value.subSequence(value.getSpanStart(it), value.getSpanEnd(it)).toString() } + assertEquals(listOf("there", "here"), matches) + val menu = activity.findViewById(R.id.toolbar).menu + assertNotNull(menu.findItem(3)) + activity.onOptionsItemSelected(menu.findItem(3)) + } + await(scenario) { count(it) == 3 && it.findViewById(R.id.loading_indicator).visibility == View.GONE } + assertFalse(search.load().active) + assertTrue(apps.selectedPackages().isEmpty()) + } + } + + @Test fun searchDialogKeepsDraftOnRotationAndRejectsInvalidRegex() { + append("Some test contents") + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { count(it) == 1 } + scenario.onActivity { logs(it).showSearch() } + await(scenario) { dialog(it)?.findViewById(R.id.log_search_text) != null } + scenario.onActivity { + dialog(it)!!.findViewById(R.id.log_search_text).text = "some some" + dialog(it)!!.findViewById(R.id.log_search_mode).setSelection(SearchMode.AND.ordinal) + dialog(it)!!.findViewById(R.id.log_search_case).isChecked = true + dialog(it)!!.findViewById(R.id.log_search_words).isChecked = true + } + await(scenario) { dialog(it)!!.findViewById(R.id.log_search_words).visibility == View.VISIBLE } + scenario.recreate() + await(scenario) { dialog(it)?.findViewById(R.id.log_search_text)?.text.toString() == "some some" } + scenario.onActivity { + assertTrue(dialog(it)!!.findViewById(R.id.log_search_case).isChecked) + assertTrue(dialog(it)!!.findViewById(R.id.log_search_words).isChecked) + assertEquals(SearchMode.AND.ordinal, dialog(it)!!.findViewById(R.id.log_search_mode).selectedItemPosition) + dialog(it)!!.findViewById(R.id.log_search_text).text = "[" + dialog(it)!!.findViewById(R.id.log_search_mode).setSelection(SearchMode.REGEX.ordinal) + } + await(scenario) { dialog(it)!!.findViewById(R.id.log_search_words).visibility == View.GONE } + scenario.onActivity { + (dialog(it) as androidx.appcompat.app.AlertDialog).getButton(-1).performClick() + assertTrue(dialog(it)!!.isShowing) + assertFalse(search.load().active) + dialog(it)!!.findViewById(R.id.log_search_text).text = "some.*contents" + dialog(it)!!.findViewById(R.id.log_search_case).isChecked = false + (dialog(it) as androidx.appcompat.app.AlertDialog).getButton(-1).performClick() + } + await(scenario) { dialog(it) == null && count(it) == 1 } + assertEquals("some.*contents", LogSearchStore(context).load().text) + } + } + + @Test fun previousContentIsHighlightedAndFiltersSurviveClearingLogs() { + append("New contents", previous = "Private old contents") + search.save(LogSearchSettings("Private old", SearchMode.LITERAL)) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { count(it) == 1 && message(it) != null } + scenario.onActivity { (message(it)!!.parent as View).performClick() } + await(scenario) { activity -> + val content = message(activity)?.parent as? ViewGroup + val previous = content?.getChildAt(2) as? TextView + val value = previous?.text as? Spanned + value?.getSpans(0, value.length, BackgroundColorSpan::class.java)?.isNotEmpty() == true + } + store.clear() + scenario.recreate() + await(scenario) { it.findViewById(R.id.empty_view).visibility == View.VISIBLE } + assertTrue(search.load().active) + assertEquals("Private old", search.load().text) + assertFalse(File(context.filesDir, "log-search.bin").readBytes().decodeToString().contains("Private old")) + } + } + + @Test fun anEditWithNoCurrentTextStillExposesPreviousSearchMatches() { + append(null, previous = "Previous searchable contents") + search.save(LogSearchSettings("searchable", SearchMode.LITERAL)) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { count(it) == 1 && message(it) != null } + scenario.onActivity { (message(it)!!.parent as View).performClick() } + await(scenario) { + val previous = (message(it)?.parent as? ViewGroup)?.getChildAt(2) as? TextView + val value = previous?.text as? Spanned + value?.getSpans(0, value.length, BackgroundColorSpan::class.java)?.size == 1 + } + } + } + + private fun logs(activity: MainActivity) = activity.supportFragmentManager.findFragmentById(R.id.content_frame) as ViewLogsFragment + private fun dialog(activity: MainActivity) = (activity.supportFragmentManager.findFragmentByTag("log-search") as? LogSearchDialogFragment)?.dialog + private fun count(activity: MainActivity) = activity.findViewById(R.id.log_list).adapter!!.itemCount + private fun message(activity: MainActivity): TextView? { + val list = activity.findViewById(R.id.log_list) + val root = list.findViewHolderForAdapterPosition(0)?.itemView as? ViewGroup ?: return null + val row = (root.getChildAt(0) as ViewGroup).getChildAt(0) as? ViewGroup ?: return null + return (row.getChildAt(1) as ViewGroup).getChildAt(0) as TextView + } + private fun await(scenario: ActivityScenario, ready: (MainActivity) -> Boolean) { + val deadline = SystemClock.uptimeMillis() + 10_000 + do { + var result = false + scenario.onActivity { result = ready(it) } + if (result) return + SystemClock.sleep(16) + } while (SystemClock.uptimeMillis() < deadline) + throw AssertionError("Search UI did not reach the expected state") + } +} diff --git a/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogViewDeviceTest.kt b/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogViewDeviceTest.kt new file mode 100644 index 0000000..874ff48 --- /dev/null +++ b/app/src/androidTest/java/se/ajpanton/notificationsmaster/LogViewDeviceTest.kt @@ -0,0 +1,490 @@ +package se.ajpanton.notificationsmaster + +import android.graphics.drawable.Animatable +import android.graphics.Bitmap +import android.os.SystemClock +import android.view.View +import android.view.ViewGroup +import android.widget.TextView +import android.widget.ProgressBar +import androidx.fragment.app.Fragment +import androidx.fragment.app.FragmentManager +import androidx.core.view.doOnPreDraw +import androidx.recyclerview.widget.LinearLayoutManager +import androidx.recyclerview.widget.RecyclerView +import androidx.test.core.app.ActivityScenario +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry +import androidx.test.runner.lifecycle.ActivityLifecycleCallback +import androidx.test.runner.lifecycle.Stage +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import se.ajpanton.notificationsmaster.data.EncryptedNotificationLogStore +import se.ajpanton.notificationsmaster.data.EncryptedImageStore +import se.ajpanton.notificationsmaster.data.LogWindowCache +import se.ajpanton.notificationsmaster.model.NotificationAction +import se.ajpanton.notificationsmaster.model.NotificationLogEntry +import se.ajpanton.notificationsmaster.settings.LogAppFilterStore +import se.ajpanton.notificationsmaster.settings.LogSearchStore +import se.ajpanton.notificationsmaster.settings.LogField +import se.ajpanton.notificationsmaster.settings.LogViewSettings +import se.ajpanton.notificationsmaster.settings.LogViewSettingsStore +import se.ajpanton.notificationsmaster.settings.StorageLimits +import se.ajpanton.notificationsmaster.settings.StorageLimitsStore +import java.io.ByteArrayOutputStream +import java.util.UUID + +@RunWith(AndroidJUnit4::class) +class LogViewDeviceTest { + private val context = InstrumentationRegistry.getInstrumentation().targetContext + private val store = EncryptedNotificationLogStore(context) + private val filters = LogAppFilterStore(context) + + @Before fun prepareLogs() { + clearLogs() + } + + private fun seedHistory() { + repeat(640) { index -> + store.append(NotificationLogEntry( + recordedAtEpochMillis = index.toLong(), + packageName = if (index % 160 == 0) "test.selected" else "test.other", + appName = "Test app", + action = NotificationAction.APPEARED, + contents = "Test message $index", + )) + } + } + + @After fun clearLogs() { + store.clear() + filters.clear() + LogSearchStore(context).clear() + LogViewSettingsStore(context).save(LogViewSettings()) + StorageLimitsStore(context).save(StorageLimits()) + } + + @Test fun sparseFilterLoadsOlderMatchesAndStopsTheIndicator() { + seedHistory() + filters.save(listOf(LogAppFilterStore.App("Test app", "test.selected"))) + var sawLoading = false + val monitor = ActivityLifecycleMonitorRegistry.getInstance() + val observer = ActivityLifecycleCallback { activity, stage -> + if (activity is MainActivity && stage == Stage.CREATED) { + activity.supportFragmentManager.registerFragmentLifecycleCallbacks( + object : FragmentManager.FragmentLifecycleCallbacks() { + override fun onFragmentResumed(manager: FragmentManager, fragment: Fragment) { + if (fragment is ViewLogsFragment) { + sawLoading = fragment.requireView().findViewById(R.id.loading_indicator) + .visibility == View.VISIBLE + } + } + }, false, + ) + } + } + monitor.addLifecycleCallback(observer) + try { + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { activity -> + activity.findViewById(R.id.loading_indicator).visibility == View.GONE && + activity.findViewById(R.id.log_list).adapter!!.itemCount == 4 + } + assertTrue("Loading should be visible before the filtered results arrive", sawLoading) + scenario.onActivity { activity -> + assertEquals(View.GONE, activity.findViewById(R.id.empty_view).visibility) + val spinner = activity.findViewById(R.id.loading_spinner) + assertFalse((spinner.indeterminateDrawable as Animatable).isRunning) + } + } + } finally { + monitor.removeLifecycleCallback(observer) + } + } + + @Test fun distantScrollReturnsToTopWithinOneSecondAndTimestampHasNoExtraInset() { + seedHistory() + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { it.findViewById(R.id.log_list).adapter!!.itemCount > 0 } + scenario.onActivity { it.findViewById(R.id.log_list).scrollToPosition(639) } + await(scenario) { + (it.findViewById(R.id.log_list).layoutManager as LinearLayoutManager) + .findFirstVisibleItemPosition() > 600 + } + var scrollStartedAt = 0L + var scrollCompletedAt = 0L + scenario.onActivity { activity -> + val button = activity.findViewById(R.id.scroll_to_top) + assertEquals(View.VISIBLE, button.visibility) + scrollStartedAt = SystemClock.uptimeMillis() + button.performClick() + } + // Allow two display frames beyond the animation's one-second limit. + await(scenario, 1_100) { activity -> + val list = activity.findViewById(R.id.log_list) + val manager = list.layoutManager as LinearLayoutManager + val completed = manager.findFirstVisibleItemPosition() == 0 && + manager.findViewByPosition(0)?.top == list.paddingTop + if (completed) scrollCompletedAt = SystemClock.uptimeMillis() + completed + } + // Measure on the UI thread, not after the instrumentation thread gets + // scheduled again; that delay is unrelated to the animation itself. + assertTrue("Scroll took ${scrollCompletedAt - scrollStartedAt}ms", scrollCompletedAt - scrollStartedAt <= 1_100) + await(scenario) { logRow(it) != null } + scenario.onActivity { activity -> + val list = activity.findViewById(R.id.log_list) + val row = (list.layoutManager as LinearLayoutManager).findViewByPosition(0) as ViewGroup + val metadata = ((row.getChildAt(0) as ViewGroup).getChildAt(0) as ViewGroup) + .getChildAt(0) as ViewGroup + assertTrue(metadata.getChildAt(0) is TextView) + assertEquals(0, metadata.paddingLeft) + assertEquals(0, metadata.getChildAt(0).left) + assertTrue(metadata.getChildAt(1).paddingLeft > 0) + } + scenario.onActivity { activity -> + (activity.findViewById(R.id.log_list).layoutManager as LinearLayoutManager) + .scrollToPositionWithOffset(3, 0) + } + await(scenario) { + (it.findViewById(R.id.log_list).layoutManager as LinearLayoutManager) + .findFirstVisibleItemPosition() == 3 + } + scenario.onActivity { + scrollStartedAt = SystemClock.uptimeMillis() + it.findViewById(R.id.scroll_to_top).performClick() + } + await(scenario, 400) { + val list = it.findViewById(R.id.log_list) + val manager = list.layoutManager as LinearLayoutManager + val completed = manager.findFirstVisibleItemPosition() == 0 && + manager.findViewByPosition(0)?.top == list.paddingTop + if (completed) scrollCompletedAt = SystemClock.uptimeMillis() + completed + } + assertTrue(scrollCompletedAt - scrollStartedAt <= 400) + } + } + + @Test fun fittingRowsIgnoreTapsAndForgetExpansionWhenSpaceReturns() { + useCompactFields() + appendRow(0, "A short message") + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it) != null } + scenario.onActivity { activity -> + val row = logRow(activity)!! + assertFalse(row.getChildAt(1).isClickable) + row.getChildAt(1).performClick() + assertEquals(1, message(row).maxLines) + assertEquals(null, row.background) + setNarrow(activity, true) + } + await(scenario) { logRow(it)?.getChildAt(1)?.isClickable == true } + var expandedHighlight = false + scenario.onActivity { activity -> + val row = logRow(activity)!! + assertEquals(1, message(row).maxLines) + row.getChildAt(1).performClick() + row.doOnPreDraw { expandedHighlight = row.background != null } + } + await(scenario) { message(logRow(it)!!).maxLines == Int.MAX_VALUE } + assertTrue("Expansion should highlight the row", expandedHighlight) + var collapsedHighlight = false + scenario.onActivity { activity -> + val row = logRow(activity)!! + row.getChildAt(1).performClick() + row.doOnPreDraw { collapsedHighlight = row.background != null } + } + await(scenario) { message(logRow(it)!!).maxLines == 1 } + assertTrue("Collapse should highlight the row", collapsedHighlight) + scenario.onActivity { activity -> + logRow(activity)!!.getChildAt(1).performClick() + } + await(scenario) { message(logRow(it)!!).maxLines == Int.MAX_VALUE } + scenario.onActivity { setNarrow(it, false) } + await(scenario) { + logRow(it)?.let { row -> !row.getChildAt(1).isClickable && message(row).maxLines == 1 } == true + } + scenario.onActivity { setNarrow(it, true) } + await(scenario) { logRow(it)?.getChildAt(1)?.isClickable == true } + scenario.onActivity { assertEquals(1, message(logRow(it)!!).maxLines) } + } + } + + @Test fun metadataPreviousContentsAndRetainedImagesCanExpandButMissingImagesCannot() { + useCompactFields() + val imageId = UUID.randomUUID().toString() + val bytes = ByteArrayOutputStream().apply { + Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888).compress(Bitmap.CompressFormat.PNG, 100, this) + }.toByteArray() + appendRow(0, "OK", name = "A very long app name that cannot fit on one line") + appendRow(1, "[image]", imageId = UUID.randomUUID().toString()) + appendRow(2, "[image]", imageId = imageId) + appendRow(3, "Now", action = NotificationAction.EDITED, previous = "Before") + EncryptedImageStore(context).save(imageId, bytes) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it, 3) != null } + scenario.onActivity { activity -> + assertTrue(logRow(activity, 0)!!.getChildAt(1).isClickable) + assertTrue(logRow(activity, 1)!!.getChildAt(1).isClickable) + assertFalse(logRow(activity, 2)!!.getChildAt(1).isClickable) + assertTrue(logRow(activity, 3)!!.getChildAt(0).isClickable) + logRow(activity, 0)!!.getChildAt(1).performClick() + } + await(scenario) { (logRow(it, 0)?.getChildAt(1) as? ViewGroup)?.childCount == 3 } + scenario.onActivity { + val cell = logRow(it, 0)!!.getChildAt(1) as ViewGroup + assertEquals("Before", (cell.getChildAt(2) as TextView).text.toString()) + cell.performClick() + logRow(it, 1)!!.getChildAt(1).performClick() + } + await(scenario) { + val cell = logRow(it, 1)?.getChildAt(1) as? ViewGroup + cell?.childCount == 2 && cell.getChildAt(1) is android.widget.ImageView + } + } + } + + @Test fun rowsOutsideTheViewportAlsoForgetExpansionWhenTheyWouldFit() { + useCompactFields() + repeat(40) { appendRow(it.toLong(), "A short message") } + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it) != null } + scenario.onActivity { setNarrow(it, true) } + await(scenario) { logRow(it)?.getChildAt(1)?.isClickable == true } + scenario.onActivity { logRow(it)!!.getChildAt(1).performClick() } + await(scenario) { message(logRow(it)!!).maxLines == Int.MAX_VALUE } + scenario.onActivity { it.findViewById(R.id.log_list).scrollToPosition(39) } + await(scenario) { logRow(it) == null } + scenario.onActivity { setNarrow(it, false) } + await(scenario) { logRow(it, 39)?.getChildAt(1)?.isClickable == false } + scenario.onActivity { setNarrow(it, true) } + await(scenario) { logRow(it, 39)?.getChildAt(1)?.isClickable == true } + scenario.onActivity { it.findViewById(R.id.log_list).scrollToPosition(0) } + await(scenario) { logRow(it) != null } + scenario.onActivity { assertEquals(1, message(logRow(it)!!).maxLines) } + } + } + + @Test fun distantJumpsLoadBothDirectionsAndForgetEvictedExpansion() { + seedHistory() + appendRow(640, "A long message ".repeat(100)) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it) != null } + scenario.onActivity { activity -> + val list = activity.findViewById(R.id.log_list) + assertEquals(641, list.adapter!!.itemCount) + assertTrue(windowCache(activity).size <= 480) + logRow(activity)!!.getChildAt(1).performClick() + } + await(scenario) { message(logRow(it)!!).maxLines == Int.MAX_VALUE } + scenario.onActivity { activity -> + assertEquals(null, windowCache(activity)[640]) + activity.findViewById(R.id.log_list).scrollToPosition(640) + } + await(scenario) { logRow(it, 640) != null } + scenario.onActivity { activity -> + assertEquals("Test message 0", message(logRow(activity, 640)!!).text.toString()) + assertEquals(null, windowCache(activity)[0]) + assertTrue(windowCache(activity).size <= 480) + activity.findViewById(R.id.log_list).scrollToPosition(0) + } + await(scenario) { logRow(it) != null } + scenario.onActivity { activity -> + assertTrue(message(logRow(activity)!!).maxLines != Int.MAX_VALUE) + assertEquals(null, windowCache(activity)[640]) + assertTrue(windowCache(activity).size <= 480) + } + await(scenario) { it.findViewById(R.id.loading_indicator).visibility == View.GONE } + SystemClock.sleep(250) + scenario.onActivity { activity -> + assertEquals(View.GONE, activity.findViewById(R.id.loading_indicator).visibility) + } + } + } + + @Test fun placeholdersHaveExactCollapsedHeightsAndPreserveTheViewportAnchor() { + LogViewSettingsStore(context).save(LogViewSettings( + visibleFields = setOf(LogField.TIMESTAMP, LogField.PACKAGE_NAME, LogField.CONTENTS), + )) + repeat(320) { appendRow(it.toLong(), "Hi") } + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it) != null } + var rowHeight = 0 + var placeholderHeight = 0 + var anchorTop = 0 + var list: RecyclerView? = null + val gate = java.util.concurrent.CountDownLatch(1) + val requested = java.util.concurrent.CountDownLatch(1) + // Hold the existing store lock briefly so we can observe an unloaded row deterministically. + val companion = EncryptedNotificationLogStore::class.java.getDeclaredField("lock") + .apply { isAccessible = true }.get(null)!! + val blocker = Thread { + synchronized(companion) { + requested.countDown() + gate.await() + } + } + try { + scenario.onActivity { activity -> + rowHeight = logRow(activity)!!.height + list = activity.findViewById(R.id.log_list) + } + blocker.start() + assertTrue(requested.await(5, java.util.concurrent.TimeUnit.SECONDS)) + scenario.onActivity { + (list!!.layoutManager as LinearLayoutManager).scrollToPositionWithOffset(300, -11) + } + await(scenario) { + (list!!.layoutManager as LinearLayoutManager).findFirstVisibleItemPosition() == 300 + } + scenario.onActivity { activity -> + assertEquals(null, logRow(activity, 300)) + val root = list!!.findViewHolderForAdapterPosition(300)!!.itemView as ViewGroup + placeholderHeight = (root.getChildAt(0) as ViewGroup).getChildAt(0).height + anchorTop = root.top + assertEquals(rowHeight, placeholderHeight) + assertEquals(View.VISIBLE, activity.findViewById(R.id.loading_indicator).visibility) + } + } finally { + gate.countDown() + blocker.join(5_000) + } + await(scenario) { logRow(it, 300) != null } + scenario.onActivity { + val root = list!!.findViewHolderForAdapterPosition(300)!!.itemView + assertEquals(anchorTop, root.top) + assertEquals(rowHeight, logRow(it, 300)!!.height) + list!!.scrollToPosition(0) + } + await(scenario) { logRow(it) != null } + scenario.onActivity { + assertEquals(null, windowCache(it)[300]) + (list!!.layoutManager as LinearLayoutManager).scrollToPositionWithOffset(300, -11) + } + await(scenario) { + (list!!.layoutManager as LinearLayoutManager).findFirstVisibleItemPosition() == 300 + } + scenario.onActivity { + val root = list!!.findViewHolderForAdapterPosition(300)!!.itemView as ViewGroup + assertEquals(rowHeight, (root.getChildAt(0) as ViewGroup).getChildAt(0).height) + } + } + } + + @Test fun collapsedHeightDependsOnMetadataNotContentLengthOrWidth() { + LogViewSettingsStore(context).save(LogViewSettings(visibleFields = LogField.entries.toSet())) + appendRow(0, "Hi") + appendRow(1, "Long text ".repeat(100)) + store.append(NotificationLogEntry(recordedAtEpochMillis = 2, packageName = "", appName = "", + action = NotificationAction.APPEARED, contents = "Long text ".repeat(100))) + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it, 2) != null } + var fullHeight = 0 + var reducedHeight = 0 + scenario.onActivity { + fullHeight = logRow(it, 1)!!.height + reducedHeight = logRow(it, 0)!!.height + assertEquals(fullHeight, logRow(it, 2)!!.height) + assertTrue(reducedHeight < fullHeight) + assertTrue(message(logRow(it, 0)!!).maxLines < message(logRow(it, 1)!!).maxLines) + setNarrow(it, true) + } + await(scenario) { + logRow(it, 1)?.width == (220 * context.resources.displayMetrics.density).toInt() - + it.findViewById(R.id.log_list).paddingLeft - + it.findViewById(R.id.log_list).paddingRight + } + scenario.onActivity { + assertEquals(fullHeight, logRow(it, 1)!!.height) + assertEquals(reducedHeight, logRow(it, 0)!!.height) + LogViewSettingsStore(context).save(LogViewSettings(visibleFields = setOf(LogField.CONTENTS))) + } + scenario.recreate() + await(scenario) { logRow(it, 2) != null } + scenario.onActivity { + val heights = (0..2).map { position -> logRow(it, position)!!.height } + assertEquals(1, heights.distinct().size) + val contents = logRow(it, 1)!!.getChildAt(0) as ViewGroup + assertEquals(1, (contents.getChildAt(0) as TextView).maxLines) + } + } + } + + private fun windowCache(activity: MainActivity): LogWindowCache { + val fragment = activity.supportFragmentManager.findFragmentById(R.id.content_frame) as ViewLogsFragment + return ViewLogsFragment::class.java.getDeclaredField("cache").apply { isAccessible = true } + .get(fragment) as LogWindowCache + } + + @Test fun longEntriesRespectTheCacheBudgetWithoutAnIdlePrefetchLoop() { + StorageLimitsStore(context).save(StorageLimits(logBytes = 16 * 1024 * 1024)) + repeat(200) { appendRow(it.toLong(), "x".repeat(16_000), + action = NotificationAction.EDITED, previous = "y".repeat(16_000)) } + ActivityScenario.launch(MainActivity::class.java).use { scenario -> + await(scenario) { logRow(it) != null && it.findViewById(R.id.loading_indicator).visibility == View.GONE } + var newest: NotificationLogEntry? = null + scenario.onActivity { + val cache = windowCache(it) + assertTrue(cache.bytes <= 4 * 1024 * 1024) + assertTrue(cache.size < 80) + newest = cache[0] + } + SystemClock.sleep(500) + scenario.onActivity { + assertEquals(View.GONE, it.findViewById(R.id.loading_indicator).visibility) + assertTrue(newest === windowCache(it)[0]) + it.findViewById(R.id.log_list).scrollToPosition(199) + } + await(scenario) { logRow(it, 199) != null && it.findViewById(R.id.loading_indicator).visibility == View.GONE } + scenario.onActivity { + assertTrue(windowCache(it).bytes <= 4 * 1024 * 1024) + assertEquals(null, windowCache(it)[0]) + } + } + } + + private fun useCompactFields() = LogViewSettingsStore(context).save( + LogViewSettings(visibleFields = setOf(LogField.APP_NAME, LogField.CONTENTS)), + ) + + private fun appendRow(time: Long, contents: String, name: String = "Test app", + action: NotificationAction = NotificationAction.APPEARED, previous: String? = null, imageId: String? = null, + ) = store.append(NotificationLogEntry( + recordedAtEpochMillis = time, packageName = "test.app", appName = name, + action = action, contents = contents, previousContents = previous, imageId = imageId, + )) + + private fun logRow(activity: MainActivity, position: Int = 0): ViewGroup? { + val list = activity.findViewById(R.id.log_list) + val root = list.findViewHolderForAdapterPosition(position)?.itemView as? ViewGroup ?: return null + return (root.getChildAt(0) as ViewGroup).getChildAt(0) as? ViewGroup + } + + private fun message(row: ViewGroup) = (row.getChildAt(1) as ViewGroup).getChildAt(0) as TextView + + private fun setNarrow(activity: MainActivity, narrow: Boolean) { + val viewport = activity.findViewById(R.id.logs_refresh) + viewport.layoutParams = viewport.layoutParams.apply { + width = if (narrow) (220 * context.resources.displayMetrics.density).toInt() + else ViewGroup.LayoutParams.MATCH_PARENT + } + } + + private fun await(scenario: ActivityScenario, timeout: Long = 10_000, ready: (MainActivity) -> Boolean) { + val deadline = SystemClock.uptimeMillis() + timeout + do { + var satisfied = false + scenario.onActivity { satisfied = ready(it) } + if (satisfied) return + SystemClock.sleep(16) + } while (SystemClock.uptimeMillis() < deadline) + throw AssertionError("Log view did not reach the expected state within ${timeout}ms") + } +} diff --git a/app/src/androidTest/java/se/ajpanton/notificationsmaster/data/NotificationLogIndexDeviceTest.kt b/app/src/androidTest/java/se/ajpanton/notificationsmaster/data/NotificationLogIndexDeviceTest.kt new file mode 100644 index 0000000..a13a91b --- /dev/null +++ b/app/src/androidTest/java/se/ajpanton/notificationsmaster/data/NotificationLogIndexDeviceTest.kt @@ -0,0 +1,151 @@ +package se.ajpanton.notificationsmaster.data + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import se.ajpanton.notificationsmaster.model.NotificationAction +import se.ajpanton.notificationsmaster.model.NotificationLogEntry +import se.ajpanton.notificationsmaster.settings.StorageLimits +import se.ajpanton.notificationsmaster.settings.StorageLimitsStore +import se.ajpanton.notificationsmaster.search.LogContentSearch +import se.ajpanton.notificationsmaster.search.LogSearchSettings +import se.ajpanton.notificationsmaster.search.SearchMode +import java.io.File + +@RunWith(AndroidJUnit4::class) +class NotificationLogIndexDeviceTest { + private val context = InstrumentationRegistry.getInstrumentation().targetContext + private val store = EncryptedNotificationLogStore(context) + private val directory = File(context.filesDir, "notification-log") + private val limits = StorageLimitsStore(context) + + @Before @After fun clear() { + store.clear() + limits.save(StorageLimits()) + } + + private fun row(position: Int, length: Int = 30) = NotificationLogEntry( + recordedAtEpochMillis = position.toLong(), packageName = "test.app${position % 3}", + appName = "Secret app ${position % 3}", + action = if (position % 4 == 0) NotificationAction.EDITED else NotificationAction.APPEARED, + contents = "Private contents $position " + "x".repeat(length), + ) + + @Test fun countsAndRandomFilteredRangesAgreeWithTheHistoryAcrossChunks() { + val rows = List(400) { row(it, 3_000) }.onEach(store::append) + assertTrue(directory.listFiles()!!.count { it.name.endsWith(".bin") } > 3) + listOf(LogQuery(), LogQuery(setOf("test.app1")), + LogQuery(setOf("test.app0", "test.app2"), setOf(NotificationAction.EDITED))).forEach { query -> + val index = store.openIndex(query) + val expected = rows.asReversed().filter(query::matches) + assertEquals(expected.size, index.count) + listOf(0, 5, expected.size / 2, expected.size - 3, expected.size + 1).forEach { start -> + assertEquals(expected.drop(start).take(37), store.readRange(index, start, 37)) + } + expected.forEachIndexed { position, entry -> assertEquals(entry.fieldsMask(), index.fieldsAt(position)) } + } + assertEquals(0, store.openIndex(LogQuery(actions = emptySet())).count) + assertTrue(directory.listFiles()!!.filter { it.name.endsWith(".index") }.all { file -> + val bytes = file.readBytes().decodeToString() + "Secret app" !in bytes && "Private contents" !in bytes && "test.app" !in bytes + }) + } + + @Test fun interruptedOrMissingIndexUpdatesRebuildWithoutChangingLogs() { + val first = row(1) + store.append(first) + val file = directory.listFiles()!!.single { it.name.endsWith(".index") } + val oldIndex = file.readBytes() + val second = row(2) + store.append(second) + file.writeBytes(oldIndex) // Simulate a chunk write completing without its index update. + val recovered = store.openIndex() + assertEquals(listOf(second, first), store.readRange(recovered, 0, 10)) + assertTrue(file.delete()) + val rebuilt = store.openIndex() + assertEquals(listOf(second, first), store.readRange(rebuilt, 0, 10)) + assertTrue(file.isFile) + val orphan = File(directory, "chunk-999999999999.bin.index") + file.copyTo(orphan) + store.openIndex() + assertFalse(orphan.exists()) + } + + @Test fun presenceFlagsReflectMissingMetadataRegardlessOfContentLength() { + val rows = listOf(row(0), row(1).copy(appName = ""), row(2).copy(packageName = "", contents = "x".repeat(16_000))) + rows.forEach(store::append) + val index = store.openIndex() + rows.asReversed().forEachIndexed { position, entry -> assertEquals(entry.fieldsMask(), index.fieldsAt(position)) } + assertTrue(index.fieldsAt(0) != index.fieldsAt(1)) + assertEquals(rows[0].copy(contents = "x".repeat(16_000)).fieldsMask(), rows[0].fieldsMask()) + } + + @Test fun appendsKeepOldSnapshotsUsableButDeletionInvalidatesAffectedRanges() { + val rows = List(20) { row(it) }.onEach(store::append) + val snapshot = store.openIndex() + store.append(row(20)) + assertEquals(rows.asReversed(), store.readRange(snapshot, 0, 30)) + assertEquals(21, store.openIndex().count) + assertTrue(store.delete(rows[10].id)) + assertNull(store.readRange(snapshot, 0, 30)) + assertEquals(20, store.openIndex().count) + assertFalse(store.delete(rows[10].id)) + } + + @Test fun retentionAndClearAlsoRemoveIndexesAndRespectTheCombinedLimit() { + repeat(160) { store.append(row(it, 3_000)) } + val old = store.openIndex() + limits.save(StorageLimits(logBytes = 32 * 1024)) + store.enforceLimits() + val retained = mutableListOf() + store.forEachNewest(retained::add) + val current = store.openIndex() + assertEquals(retained, store.readRange(current, 0, 500)) + assertTrue(directory.listFiles()!!.sumOf(File::length) <= 32 * 1024) + assertTrue(current.count < old.count) + assertNull(store.readRange(old, 0, old.count)) + assertTrue(directory.listFiles()!!.filter { it.name.endsWith(".index") } + .all { File(directory, it.name.removeSuffix(".index")).isFile }) + store.clear() + assertTrue(directory.listFiles().isNullOrEmpty()) + assertEquals(0, store.openIndex().count) + } + + @Test fun contentSearchCombinesWithAppAndEventFiltersAndKeepsRandomAccess() { + val rows = List(180) { position -> row(position, 3_000).copy( + contents = if (position % 7 == 0) "there is some text and here is some more" else "Other contents $position", + previousContents = if (position % 11 == 0) "previous searchable text" else null, + ) }.onEach(store::append) + listOf( + LogQuery(search = LogContentSearch(LogSearchSettings("here there", SearchMode.AND))), + LogQuery(setOf("test.app1"), search = LogContentSearch(LogSearchSettings("some", SearchMode.LITERAL))), + LogQuery(actions = setOf(NotificationAction.EDITED), + search = LogContentSearch(LogSearchSettings("previous.*text", SearchMode.REGEX))), + LogQuery(search = LogContentSearch(LogSearchSettings("Secret app", SearchMode.LITERAL))), + LogQuery(search = LogContentSearch(LogSearchSettings("mor ore", SearchMode.AND))), + ).forEach { query -> + val snapshot = store.openIndex(query) + val expected = rows.asReversed().filter(query::matches) + assertEquals(expected.size, snapshot.count) + assertEquals(expected.map { it.packageName }.toSet(), snapshot.apps.keys) + assertEquals(expected.map { it.action }.toSet(), snapshot.actions) + listOf(0, 3, expected.size / 2, expected.size + 1).forEach { start -> + assertEquals(expected.drop(start).take(7), store.readRange(snapshot, start, 7)) + } + expected.forEachIndexed { position, entry -> assertEquals(entry.fieldsMask(), snapshot.fieldsAt(position)) } + store.append(row(999)) + assertEquals(expected, store.readRange(snapshot, 0, 200)) + } + } + + @Test fun excludedAppsAndEventsAreNotContentSearched() { + store.append(row(1)) + val excessive = LogContentSearch(LogSearchSettings((0..128).joinToString(" ") { "term$it" }, SearchMode.AND)) + assertEquals(0, store.openIndex(LogQuery(setOf("not.logged"), search = excessive)).count) + assertEquals(0, store.openIndex(LogQuery(actions = emptySet(), search = excessive)).count) + } +} diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/LogSearchDialogFragment.kt b/app/src/main/java/se/ajpanton/notificationsmaster/LogSearchDialogFragment.kt new file mode 100644 index 0000000..1b66b92 --- /dev/null +++ b/app/src/main/java/se/ajpanton/notificationsmaster/LogSearchDialogFragment.kt @@ -0,0 +1,135 @@ +package se.ajpanton.notificationsmaster + +import android.app.Dialog +import android.os.Bundle +import android.text.InputFilter +import android.view.View +import android.view.WindowManager +import android.widget.AdapterView +import android.widget.ArrayAdapter +import android.widget.CheckBox +import android.widget.LinearLayout +import android.widget.Spinner +import android.widget.TextView +import androidx.core.os.bundleOf +import androidx.fragment.app.DialogFragment +import com.google.android.material.dialog.MaterialAlertDialogBuilder +import com.google.android.material.textfield.TextInputEditText +import com.google.android.material.textfield.TextInputLayout +import com.google.re2j.PatternSyntaxException +import se.ajpanton.notificationsmaster.search.LogContentSearch +import se.ajpanton.notificationsmaster.search.LogSearchSettings +import se.ajpanton.notificationsmaster.search.SearchMode +import se.ajpanton.notificationsmaster.settings.LogSearchStore +import se.ajpanton.notificationsmaster.settings.AppLockStore + +class LogSearchDialogFragment : DialogFragment() { + private lateinit var input: TextInputEditText + private lateinit var mode: Spinner + private lateinit var caseSensitive: CheckBox + private lateinit var wholeWords: CheckBox + + override fun onCreateDialog(savedInstanceState: Bundle?): Dialog { + val store = LogSearchStore(requireContext()) + val saved = store.load() + val settings = savedInstanceState?.let { + LogSearchSettings(it.getString("text").orEmpty(), SearchMode.valueOf(it.getString("mode")!!), + it.getBoolean("case"), it.getBoolean("words")) + } ?: saved + val context = requireContext() + val body = LinearLayout(context).apply { + orientation = LinearLayout.VERTICAL + val padding = (24 * resources.displayMetrics.density).toInt() + setPadding(padding, 0, padding, 0) + } + val inputLayout = TextInputLayout(context).apply { hint = "Search notification contents" } + input = TextInputEditText(inputLayout.context).apply { + id = R.id.log_search_text + filters = arrayOf(InputFilter.LengthFilter(4096)) + setText(settings.text) + setSelectAllOnFocus(true) + inputType = android.text.InputType.TYPE_CLASS_TEXT or android.text.InputType.TYPE_TEXT_FLAG_MULTI_LINE + maxLines = 4 + } + inputLayout.addView(input) + body.addView(inputLayout) + body.addView(TextView(context).apply { text = "Match using" }) + mode = Spinner(context, Spinner.MODE_DROPDOWN).apply { + id = R.id.log_search_mode + setPopupBackgroundDrawable(androidx.appcompat.content.res.AppCompatResources.getDrawable(context, R.drawable.dropdown_popup_background)) + adapter = ArrayAdapter(context, android.R.layout.simple_spinner_dropdown_item, SearchMode.entries.map { it.label }) + setSelection(settings.mode.ordinal) + } + body.addView(mode) + wholeWords = CheckBox(context).apply { + id = R.id.log_search_words + text = "Match whole words" + isChecked = settings.wholeWords + visibility = if (settings.mode.usesTerms) View.VISIBLE else View.GONE + } + body.addView(wholeWords) + caseSensitive = CheckBox(context).apply { + id = R.id.log_search_case + text = "Case sensitive" + isChecked = settings.caseSensitive + } + body.addView(caseSensitive) + val explanation = TextView(context).also(body::addView) + mode.onItemSelectedListener = object : AdapterView.OnItemSelectedListener { + override fun onNothingSelected(parent: AdapterView<*>?) = Unit + override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) { + wholeWords.visibility = if (SearchMode.entries[position].usesTerms) View.VISIBLE else View.GONE + explanation.text = when (SearchMode.entries[position]) { + SearchMode.REGEX -> "Use a regular expression. Matches notification text, not app names." + SearchMode.LITERAL -> "Match the text exactly as typed, including spaces, anywhere in the notification." + SearchMode.AND -> "Every space-separated term needs its own non-overlapping match." + SearchMode.OR -> "At least one term must match. Highlights as many distinct terms as possible." + } + } + } + val dialog = MaterialAlertDialogBuilder(context).setTitle("Search logs").setView(body) + .setNegativeButton("Cancel", null).setNeutralButton("Clear search") { _, _ -> + store.clear() + parentFragmentManager.setFragmentResult(RESULT, Bundle.EMPTY) + }.setPositiveButton("Apply", null).create() + dialog.setOnShowListener { + dialog.getButton(androidx.appcompat.app.AlertDialog.BUTTON_POSITIVE).setOnClickListener { + val updated = draft() + try { + LogContentSearch(updated) // Validate regex before persisting or closing. + } catch (error: PatternSyntaxException) { + inputLayout.error = "Invalid regular expression: ${error.description}" + return@setOnClickListener + } + store.save(updated) + parentFragmentManager.setFragmentResult(RESULT, Bundle.EMPTY) + dismiss() + } + } + return dialog + } + + private fun draft() = LogSearchSettings(input.text.toString(), SearchMode.entries[mode.selectedItemPosition], + caseSensitive.isChecked, wholeWords.isChecked) + + override fun onStart() { + super.onStart() + if (AppLockStore(requireContext()).enabled) dialog?.window?.addFlags(WindowManager.LayoutParams.FLAG_SECURE) + if ((activity as? MainActivity)?.canShowLogDialog() == false) dismissAllowingStateLoss() + } + + override fun onStop() { + // A separate dialog window must not remain above the activity's lock cover. + if (AppLockStore(requireContext()).enabled && activity?.isChangingConfigurations != true) dismissAllowingStateLoss() + super.onStop() + } + + override fun onSaveInstanceState(outState: Bundle) { + super.onSaveInstanceState(outState) + val settings = draft() + outState.putAll(bundleOf("text" to settings.text, "mode" to settings.mode.name, + "case" to settings.caseSensitive, "words" to settings.wholeWords)) + } + + companion object { const val RESULT = "log-search-changed" } +} diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/MainActivity.kt b/app/src/main/java/se/ajpanton/notificationsmaster/MainActivity.kt index add9ea1..3eada13 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/MainActivity.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/MainActivity.kt @@ -26,6 +26,7 @@ import com.google.android.material.navigation.NavigationView import se.ajpanton.notificationsmaster.databinding.ActivityMainBinding import se.ajpanton.notificationsmaster.settings.AppLockStore import se.ajpanton.notificationsmaster.settings.LogAppFilterStore +import se.ajpanton.notificationsmaster.settings.LogSearchStore class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelectedListener { private lateinit var binding: ActivityMainBinding @@ -293,12 +294,13 @@ class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelecte binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED, GravityCompat.START) binding.navViewDrawer.visibility = View.VISIBLE } - (binding.contentFrame.layoutParams as RelativeLayout.LayoutParams).also { params -> - params.removeRule(if (permanentSidebar) RelativeLayout.BELOW else RelativeLayout.ALIGN_PARENT_TOP) - params.addRule( - if (permanentSidebar) RelativeLayout.ALIGN_PARENT_TOP else RelativeLayout.BELOW, - if (permanentSidebar) RelativeLayout.TRUE else R.id.toolbar, - ) + val params = binding.contentFrame.layoutParams as RelativeLayout.LayoutParams + val anchorRule = if (permanentSidebar) RelativeLayout.ALIGN_PARENT_TOP else RelativeLayout.BELOW + val otherRule = if (permanentSidebar) RelativeLayout.BELOW else RelativeLayout.ALIGN_PARENT_TOP + val anchor = if (permanentSidebar) RelativeLayout.TRUE else R.id.toolbar + if (params.getRule(anchorRule) != anchor || params.getRule(otherRule) != 0) { + params.removeRule(otherRule) + params.addRule(anchorRule, anchor) binding.contentFrame.layoutParams = params } updateNavigationHeaderHeight(binding.navViewDrawer) @@ -337,6 +339,9 @@ class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelecte if (currentItemId == R.id.nav_view_logs) invalidateOptionsMenu() } + internal fun canShowLogDialog() = !appLockStore.enabled || + (currentItemId == R.id.nav_view_logs && !needsUnlock) + override fun onCreateOptionsMenu(menu: Menu): Boolean { return updateToolbarActions(menu) } @@ -354,15 +359,29 @@ class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelecte icon?.setTint(getColor(R.color.on_primary)) setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS) } + val searching = LogSearchStore(this).load().active + menu.add(Menu.NONE, MENU_LOG_SEARCH, Menu.NONE, "Search notification contents").apply { + setIcon(if (searching) R.drawable.ic_log_search_active else R.drawable.ic_log_search) + icon?.setTint(getColor(R.color.on_primary)) + setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS) + } + if (active || searching) menu.add(Menu.NONE, MENU_CLEAR_LOG_FILTERS, Menu.NONE, "Clear all filters").apply { + setIcon(R.drawable.ic_clear_log_filters) + icon?.setTint(getColor(R.color.on_primary)) + setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS) + } return true } override fun onOptionsItemSelected(item: MenuItem): Boolean { - if (item.itemId == MENU_LOG_FILTER) { - (supportFragmentManager.findFragmentById(R.id.content_frame) as? ViewLogsFragment)?.showAppFilter() - return true + val logs = supportFragmentManager.findFragmentById(R.id.content_frame) as? ViewLogsFragment + when (item.itemId) { + MENU_LOG_FILTER -> logs?.showAppFilter() + MENU_LOG_SEARCH -> logs?.showSearch() + MENU_CLEAR_LOG_FILTERS -> logs?.clearFilters() + else -> return super.onOptionsItemSelected(item) } - return super.onOptionsItemSelected(item) + return true } private enum class Page( @@ -391,6 +410,8 @@ class MainActivity : AppCompatActivity(), NavigationView.OnNavigationItemSelecte private companion object { const val STATE_CURRENT_ITEM_ID = "current_item_id" const val MENU_LOG_FILTER = 1 + const val MENU_LOG_SEARCH = 2 + const val MENU_CLEAR_LOG_FILTERS = 3 const val PERMANENT_SIDEBAR_FOLDED_WIDTH_MULTIPLIER = 1.1f } } diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/SettingsFragment.kt b/app/src/main/java/se/ajpanton/notificationsmaster/SettingsFragment.kt index 0f2cca8..7b74f66 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/SettingsFragment.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/SettingsFragment.kt @@ -20,6 +20,7 @@ import se.ajpanton.notificationsmaster.export.LogExporter import se.ajpanton.notificationsmaster.settings.StorageLimits import se.ajpanton.notificationsmaster.settings.StorageLimitsStore import se.ajpanton.notificationsmaster.settings.LogAppFilterStore +import se.ajpanton.notificationsmaster.settings.LogSearchStore import java.util.zip.ZipOutputStream import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch @@ -79,6 +80,7 @@ class SettingsFragment : Fragment(R.layout.fragment_settings) { private fun confirmClearLogs() { val filterStore = LogAppFilterStore(requireContext()) + val searchStore = LogSearchStore(requireContext()) val dialog = MaterialAlertDialogBuilder(requireContext()) .setTitle("Clear logs?") .setMessage("This permanently removes every stored notification log and copied image.") @@ -86,9 +88,10 @@ class SettingsFragment : Fragment(R.layout.fragment_settings) { .setPositiveButton("Clear") { _, _ -> clearLogs() } - if (filterStore.selectedPackages().isNotEmpty()) { - dialog.setNeutralButton("Clear and reset filter") { _, _ -> + if (filterStore.selectedPackages().isNotEmpty() || searchStore.load().active) { + dialog.setNeutralButton("Clear and reset filters") { _, _ -> filterStore.clear() + searchStore.clear() (activity as? MainActivity)?.updateLogFilterAction() clearLogs() } diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/ViewLogsFragment.kt b/app/src/main/java/se/ajpanton/notificationsmaster/ViewLogsFragment.kt index bfbee40..95cfdc3 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/ViewLogsFragment.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/ViewLogsFragment.kt @@ -12,15 +12,23 @@ import android.content.ComponentName import android.app.NotificationManager import android.text.TextPaint import android.text.TextUtils +import android.text.SpannableString +import android.text.Spanned +import android.text.style.BackgroundColorSpan import android.view.Gravity +import android.view.MotionEvent import android.view.View +import android.view.animation.DecelerateInterpolator import android.widget.ImageView import android.widget.LinearLayout import android.widget.TextView import com.google.android.material.dialog.MaterialAlertDialogBuilder import se.ajpanton.notificationsmaster.data.EncryptedImageStore import se.ajpanton.notificationsmaster.data.EncryptedNotificationLogStore -import se.ajpanton.notificationsmaster.data.NewestLogCursor +import se.ajpanton.notificationsmaster.data.LogQuery +import se.ajpanton.notificationsmaster.data.LogWindowCache +import se.ajpanton.notificationsmaster.data.NotificationLogIndex +import se.ajpanton.notificationsmaster.data.fieldsMask import se.ajpanton.notificationsmaster.databinding.FragmentViewLogsBinding import se.ajpanton.notificationsmaster.model.NotificationAction import se.ajpanton.notificationsmaster.model.NotificationLogEntry @@ -28,112 +36,289 @@ import se.ajpanton.notificationsmaster.settings.LogField import se.ajpanton.notificationsmaster.settings.LogViewSettings import se.ajpanton.notificationsmaster.settings.LogViewSettingsStore import se.ajpanton.notificationsmaster.settings.LogAppFilterStore +import se.ajpanton.notificationsmaster.settings.LogSearchStore +import se.ajpanton.notificationsmaster.search.LogContentSearch +import se.ajpanton.notificationsmaster.search.SearchTooComplexException import se.ajpanton.notificationsmaster.settings.TimestampFormatter import se.ajpanton.notificationsmaster.settings.DisplayEvent import se.ajpanton.notificationsmaster.capture.NotificationCaptureService import androidx.fragment.app.Fragment import androidx.core.content.ContextCompat import androidx.core.view.doOnPreDraw +import androidx.core.view.doOnAttach +import androidx.core.view.children import androidx.recyclerview.widget.LinearLayoutManager import androidx.recyclerview.widget.RecyclerView -import androidx.recyclerview.widget.DiffUtil import androidx.lifecycle.lifecycleScope import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job import kotlinx.coroutines.launch +import kotlinx.coroutines.runInterruptible import kotlinx.coroutines.withContext +import kotlin.math.roundToInt +import kotlin.math.sqrt +import java.util.Calendar class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { private var binding: FragmentViewLogsBinding? = null private val expandedIds = mutableSetOf() - private val rows = mutableListOf() - private var nextCursor: NewestLogCursor? = null + private val cache = LogWindowCache() + private var index: NotificationLogIndex? = null + private var metadataSamples = emptyList() + private var windowFirst = 0 + private var windowLast = 0 + private var prefetchLimited = false private var loading = false - private var noMoreRows = false private var loadGeneration = 0 - private val logAdapter = LogAdapter() + private var loadJob: Job? = null + private var windowJob: Job? = null + private var scrollToTopAnimator: ValueAnimator? = null + private val logAdapter by lazy { LogAdapter() } + private val imageStore by lazy { EncryptedImageStore(requireContext().applicationContext) } private lateinit var appFilterStore: LogAppFilterStore + private var search: LogContentSearch? = null + private var searchError: String? = null override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) binding = FragmentViewLogsBinding.bind(view) appFilterStore = LogAppFilterStore(requireContext()) - binding!!.logsRefresh.setOnRefreshListener { loadLogs(reset = true) } + parentFragmentManager.setFragmentResultListener(LogSearchDialogFragment.RESULT, viewLifecycleOwner) { _, _ -> + refreshAppFilter() + } + binding!!.logsRefresh.setOnRefreshListener { loadLogs() } binding!!.logList.layoutManager = LinearLayoutManager(requireContext()) binding!!.logList.adapter = logAdapter + binding!!.logList.addOnLayoutChangeListener { list, left, _, right, _, oldLeft, _, oldRight, _ -> + if (right - left != oldRight - oldLeft) list.post { + binding?.takeIf { it.logList === list }?.let(::render) + } + } binding!!.logList.addOnScrollListener(object : RecyclerView.OnScrollListener() { + override fun onScrollStateChanged(recyclerView: RecyclerView, newState: Int) { + if (newState == RecyclerView.SCROLL_STATE_IDLE && scrollToTopAnimator?.isRunning != true) requestWindow() + } + override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) { val scrollY = recyclerView.computeVerticalScrollOffset() binding?.scrollToTop?.visibility = if (scrollY > dp(SCROLL_TO_TOP_THRESHOLD_DP)) View.VISIBLE else View.GONE - if (!noMoreRows && !loading && !recyclerView.canScrollVertically(1)) { - loadLogs(reset = false) - } + if (scrollToTopAnimator?.isRunning != true) requestWindow() } }) - binding!!.scrollToTop.setOnClickListener { - binding?.logList?.smoothScrollToPosition(0) - } - loadLogs(reset = true) + binding!!.logList.addOnItemTouchListener(object : RecyclerView.SimpleOnItemTouchListener() { + override fun onInterceptTouchEvent(recyclerView: RecyclerView, event: MotionEvent): Boolean { + if (event.actionMasked == MotionEvent.ACTION_DOWN) scrollToTopAnimator?.cancel() + return false + } + }) + binding!!.scrollToTop.setOnClickListener { scrollToTop() } } override fun onResume() { super.onResume() - loadLogs(reset = true) + loadLogs() } override fun onDestroyView() { + scrollToTopAnimator?.cancel() + loadJob?.cancel() + windowJob?.cancel() + cache.clear() + expandedIds.clear() + index = null + metadataSamples = emptyList() + binding?.logList?.adapter = null binding = null super.onDestroyView() } - private fun loadLogs(reset: Boolean) { - if (loading && !reset) return - if (!reset && noMoreRows) return + private fun loadLogs() { val context = requireContext().applicationContext - if (reset) { - rows.clear() - nextCursor = null - noMoreRows = false - loadGeneration++ - } + loadJob?.cancel() + windowJob?.cancel() + scrollToTopAnimator?.cancel() + cache.clear() + expandedIds.clear() + index = null + metadataSamples = emptyList() + loadGeneration++ val generation = loadGeneration - loading = true - binding?.logsRefresh?.isRefreshing = true - viewLifecycleOwner.lifecycleScope.launch { - val page = withContext(Dispatchers.IO) { - EncryptedNotificationLogStore(context).readNewest(nextCursor, PAGE_SIZE) + val settings = LogViewSettingsStore(context).load() + search = LogSearchStore(context).load().takeIf { it.active }?.let(::LogContentSearch) + searchError = null + val query = LogQuery(appFilterStore.selectedPackages(), NotificationAction.entries + .filterTo(mutableSetOf()) { eventFor(it) in settings.visibleEvents }, search) + setLoading(true) + binding?.let(::render) + loadJob = viewLifecycleOwner.lifecycleScope.launch { + val snapshot = try { + runInterruptible(Dispatchers.IO) { EncryptedNotificationLogStore(context).openIndex(query) } + } catch (error: SearchTooComplexException) { + if (generation == loadGeneration) { + searchError = error.message + setLoading(false) + binding?.let(::render) + } + return@launch } if (generation != loadGeneration) return@launch - nextCursor = page.nextCursor - noMoreRows = nextCursor == null - val visibleBefore = visibleRows(LogViewSettingsStore(requireContext()).load()).size - rows += page.entries + index = snapshot + metadataSamples = snapshot.apps.map { (packageName, name) -> + NotificationLogEntry(id = "", recordedAtEpochMillis = System.currentTimeMillis(), + packageName = packageName, appName = name, action = NotificationAction.APPEARED, contents = null) + } + snapshot.actions.map { action -> + NotificationLogEntry(id = "", recordedAtEpochMillis = System.currentTimeMillis(), + packageName = "", appName = "", action = action, contents = null) + } + // Reserve timestamp width for every localized month and both AM/PM labels, + // without scanning the notification contents or widening on each loaded page. + if (LogField.TIMESTAMP in settings.visibleFields) { + val calendar = Calendar.getInstance() + val year = calendar.get(Calendar.YEAR) + metadataSamples += (0..11).flatMap { month -> listOf(11, 23).map { hour -> + calendar.set(year, month, 28, hour, 59, 59) + NotificationLogEntry(id = "", recordedAtEpochMillis = calendar.timeInMillis, + packageName = "", appName = "", action = NotificationAction.APPEARED, contents = null) + } } + } + setLoading(false) binding?.let(::render) - val visibleAfter = visibleRows(LogViewSettingsStore(requireContext()).load()).size - val skipFilteredPage = appFilterStore.selectedPackages().isNotEmpty() && - visibleAfter == visibleBefore && !noMoreRows - loading = false - binding?.logsRefresh?.isRefreshing = false - if (skipFilteredPage) loadLogs(reset = false) + requestWindow() + } + } + + private fun setLoading(value: Boolean) { + loading = value + binding?.loadingIndicator?.visibility = if (value) View.VISIBLE else View.GONE + binding?.loadingSpinner?.visibility = if (value) View.VISIBLE else View.GONE + if (!value) binding?.logsRefresh?.isRefreshing = false + } + + private fun requestWindow(first: Int? = null, last: Int? = null) { + val list = binding?.logList ?: return + if (list.isComputingLayout) { + list.post { requestWindow(first, last) } + return + } + val manager = list.layoutManager as LinearLayoutManager + val snapshot = index ?: return + if (snapshot.count == 0) return + val newFirst = (first ?: manager.findFirstVisibleItemPosition()).coerceAtLeast(0) + val newLast = (last ?: manager.findLastVisibleItemPosition()).coerceAtLeast(newFirst) + if (newFirst != windowFirst || newLast != windowLast) prefetchLimited = false + windowFirst = newFirst + windowLast = newLast + evictDistantRows() + if (windowJob?.isActive == true) return + if (nextPage(emptySet()) == null) return + val generation = loadGeneration + val context = requireContext().applicationContext + windowJob = viewLifecycleOwner.lifecycleScope.launch { + val attempted = mutableSetOf() + try { + val store = withContext(Dispatchers.IO) { EncryptedNotificationLogStore(context) } + while (true) { + val page = nextPage(attempted) ?: break + attempted += page + setLoading(true) + val start = page * PAGE_SIZE + val entries = withContext(Dispatchers.IO) { store.readRange(snapshot, start, PAGE_SIZE) } + if (generation != loadGeneration) return@launch + if (entries == null) { + loadLogs() + return@launch + } + // Keep the same visible row anchored when replacing placeholders. + val anchorPosition = manager.findFirstVisibleItemPosition() + val anchorTop = manager.findViewByPosition(anchorPosition)?.top + cache.put(start, entries) + evictDistantRows() + logAdapter.notifyItemRangeChanged(start, entries.size) + if (anchorTop != null && scrollToTopAnimator?.isRunning != true) { + manager.scrollToPositionWithOffset(anchorPosition, anchorTop - list.paddingTop) + } + } + } finally { + if (generation == loadGeneration) setLoading(false) + } + } + } + + private fun nextPage(attempted: Set): Int? { + val count = index?.count ?: return null + val margin = if (prefetchLimited) 0 else PREFETCH_ROWS + val first = (windowFirst - margin).coerceAtLeast(0) + val last = (windowLast + margin).coerceAtMost(count - 1) + return (first / PAGE_SIZE..last / PAGE_SIZE).filter { it !in attempted } + .sortedBy { page -> + val start = page * PAGE_SIZE + maxOf(windowFirst - (start + PAGE_SIZE - 1), start - windowLast, 0) + }.firstOrNull { page -> + (maxOf(first, page * PAGE_SIZE)..minOf(last, (page + 1) * PAGE_SIZE - 1)) + .any { cache[it] == null } + } + } + + private fun evictDistantRows() { + cache.retain(windowFirst, windowLast, PREFETCH_ROWS + PAGE_SIZE).forEach { (position, id) -> + if (position in (windowFirst - PREFETCH_ROWS)..(windowLast + PREFETCH_ROWS)) prefetchLimited = true + expandedIds.remove(id) + logAdapter.notifyItemChanged(position) } } private fun render(view: FragmentViewLogsBinding) { val settings = LogViewSettingsStore(requireContext()).load() - val visibleRows = visibleRows(settings) - view.emptyView.visibility = if (visibleRows.isEmpty()) View.VISIBLE else View.GONE - view.emptyView.text = if (hasNotificationAccess()) { - if (appFilterStore.selectedPackages().isEmpty()) "No logs yet." else "No logs match the app filter." + view.emptyView.visibility = if ((index?.count ?: 0) == 0 && !loading) View.VISIBLE else View.GONE + view.emptyView.text = searchError ?: if (hasNotificationAccess()) { + if (appFilterStore.selectedPackages().isEmpty() && search == null) "No logs yet." else "No logs match the filters." } else { "Notification access is disabled. Enable it in Settings." } - logAdapter.submit(visibleRows, settings, metadataColumnWidth(view.logList.width, visibleRows, settings)) + logAdapter.submit(settings, metadataColumnWidth(view.logList.width, metadataSamples, settings)) + } + + private fun scrollToTop() { + val list = binding?.logList ?: return + val manager = list.layoutManager as? LinearLayoutManager ?: return + val position = manager.findFirstVisibleItemPosition() + val first = manager.findViewByPosition(position) ?: return + list.stopScroll() + scrollToTopAnimator?.cancel() + val start = position + (list.paddingTop - first.top).toFloat() / first.height.coerceAtLeast(1) + if (start <= 0f) return + requestWindow(0, 12) + val distanceDp = start * first.height / resources.displayMetrics.density + scrollToTopAnimator = ValueAnimator.ofFloat(start, 0f).apply { + duration = (sqrt(distanceDp) * 12).toLong().coerceIn(80L, 1_000L) + interpolator = DecelerateInterpolator() + addUpdateListener { animator -> + val target = animator.animatedValue as Float + val rowPosition = target.toInt() + manager.scrollToPositionWithOffset(rowPosition, 0) + // Use the target row's actual height, including expanded contents. + list.doOnPreDraw { + if (scrollToTopAnimator !== animator || !animator.isRunning) return@doOnPreDraw + manager.findViewByPosition(rowPosition)?.let { row -> + list.scrollBy(0, ((target - rowPosition) * row.height).roundToInt()) + } + } + } + addListener(object : AnimatorListenerAdapter() { + override fun onAnimationEnd(animation: Animator) { + scrollToTopAnimator = null + requestWindow() + } + }) + } + scrollToTopAnimator?.start() } /** Called by MainActivity's header action. Selections persist until Reset is chosen. */ fun showAppFilter() { val appContext = requireContext().applicationContext viewLifecycleOwner.lifecycleScope.launch { - val apps = withContext(Dispatchers.IO) { + val apps = runInterruptible(Dispatchers.IO) { val byPackage = linkedMapOf() appFilterStore.selectedApps().forEach { app -> val name = app.name.takeUnless { it == app.packageName } ?: runCatching { @@ -143,8 +328,8 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { }.getOrDefault(app.packageName) byPackage[app.packageName] = LoggedApp(name, app.packageName) } - EncryptedNotificationLogStore(appContext).forEachNewest { entry -> - byPackage[entry.packageName] = LoggedApp(entry.appName, entry.packageName) + EncryptedNotificationLogStore(appContext).openIndex().apps.forEach { (packageName, name) -> + byPackage[packageName] = LoggedApp(name, packageName) } byPackage.values.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name }) } @@ -178,69 +363,122 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { private fun refreshAppFilter() { (activity as? MainActivity)?.updateLogFilterAction() - loadLogs(reset = true) + loadLogs() } - private fun visibleRows(settings: LogViewSettings): List { - val selectedPackages = appFilterStore.selectedPackages() - return rows.filter { entry -> - eventFor(entry.action) in settings.visibleEvents && - (selectedPackages.isEmpty() || entry.packageName in selectedPackages) + fun showSearch() { + if (parentFragmentManager.findFragmentByTag("log-search") == null) { + LogSearchDialogFragment().show(parentFragmentManager, "log-search") } } - private fun logRowView(entry: NotificationLogEntry, settings: LogViewSettings, metadataColumnWidth: Int): View = LinearLayout(requireContext()).apply { - orientation = LinearLayout.HORIZONTAL - gravity = android.view.Gravity.TOP - layoutParams = LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT).apply { - bottomMargin = 0 + fun clearFilters() { + appFilterStore.clear() + LogSearchStore(requireContext()).clear() + refreshAppFilter() + } + + private inner class LogRow( + private val entry: NotificationLogEntry, + settings: LogViewSettings, + private val metadataColumnWidth: Int, + private var expanded: Boolean = entry.id in expandedIds, + ) : LinearLayout(requireContext()) { + private val metadata = metadataValues(entry, settings) + private val contents = entry.contents + private val hasContents = LogField.CONTENTS in settings.visibleFields && + (!contents.isNullOrEmpty() || (entry.action == NotificationAction.EDITED && !entry.previousContents.isNullOrEmpty())) + private val collapsedHeight = logAdapter.collapsedHeight(entry.fieldsMask()) + private val collapsedContentLines = logAdapter.contentLines(collapsedHeight) + private var highlightAnimator: ValueAnimator? = null + + init { + orientation = HORIZONTAL + gravity = Gravity.TOP + layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT) + render() + addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> updateExpandability() } + setOnLongClickListener { showDeleteDialog(entry.id) } } - fun renderExpanded(expanded: Boolean) { + private fun render() { removeAllViews() - val metadata = metadataValues(entry, settings) - val contents = entry.contents - val hasContents = LogField.CONTENTS in settings.visibleFields && !contents.isNullOrEmpty() - val toggleExpanded = { - val collapsing = expanded - val collapseAnchor = if (collapsing) captureCollapseAnchor(this@apply) else null - if (!expandedIds.add(entry.id)) expandedIds.remove(entry.id) - renderExpanded(entry.id in expandedIds) - if (collapsing) { - val highlight = { highlightCollapsedRow(this@apply) } - if (collapseAnchor != null) { - restoreCollapseAnchor(collapseAnchor, highlight) - } else { - this@apply.doOnPreDraw { highlight() } - } - } - Unit - } - val metadataCell = metadataCell(metadata, expanded, toggleExpanded, entry.id).apply { - layoutParams = LinearLayout.LayoutParams( - if (hasContents) metadataColumnWidth else LinearLayout.LayoutParams.MATCH_PARENT, - LinearLayout.LayoutParams.WRAP_CONTENT, + layoutParams.height = if (expanded) LayoutParams.WRAP_CONTENT else collapsedHeight + val metadataCell = metadataCell(metadata, expanded, ::toggleExpanded, entry.id).apply { + layoutParams = LayoutParams( + if (hasContents) metadataColumnWidth else LayoutParams.MATCH_PARENT, + LayoutParams.WRAP_CONTENT, ).apply { if (hasContents) marginEnd = dp(COLUMN_GAP_DP) } } if (metadata.isNotEmpty()) addView(metadataCell) if (hasContents) { - val contentsCell = contentsCell(entry, contents!!, metadata.size.coerceAtLeast(1), expanded, toggleExpanded).apply { - layoutParams = LinearLayout.LayoutParams( - if (metadata.isNotEmpty()) 0 else LinearLayout.LayoutParams.MATCH_PARENT, - LinearLayout.LayoutParams.WRAP_CONTENT, + val contentsCell = contentsCell(entry, contents.orEmpty(), collapsedContentLines, expanded, ::toggleExpanded).apply { + layoutParams = LayoutParams( + if (metadata.isNotEmpty()) 0 else LayoutParams.MATCH_PARENT, + if (expanded) LayoutParams.WRAP_CONTENT else collapsedHeight, if (metadata.isNotEmpty()) 1f else 0f, ) } addView(contentsCell) } + doOnPreDraw { updateExpandability() } } - renderExpanded(entry.id in expandedIds) - setOnLongClickListener { - showDeleteDialog(entry.id) + private fun canExpand(): Boolean { + if (metadata.isNotEmpty()) { + val cell = getChildAt(0) as LinearLayout + if (cell.children.any { (it as TextView).hasHiddenText(1) }) return true + } + if (!hasContents) return false + val cell = getChildAt(childCount - 1) as LinearLayout + return (cell.getChildAt(0) as TextView).hasHiddenText(collapsedContentLines) || + (entry.action == NotificationAction.EDITED && !entry.previousContents.isNullOrEmpty()) || + (entry.imageId?.let(imageStore::exists) == true) } + + private fun updateExpandability() { + val enabled = canExpand() + if (!enabled) { + expandedIds.remove(entry.id) + if (expanded) { + expanded = false + render() + } + } + children.forEach { + it.isClickable = enabled + it.isFocusable = enabled + } + } + + private fun toggleExpanded() { + if (!canExpand()) return + val anchor = if (expanded) captureCollapseAnchor(this) else null + expanded = !expanded + if (expanded) expandedIds.add(entry.id) else expandedIds.remove(entry.id) + render() + val highlight = { + highlightAnimator?.cancel() + highlightAnimator = highlightLogRow(this) + } + if (anchor != null) restoreCollapseAnchor(anchor, highlight) + else doOnPreDraw { highlight() } + } + + override fun onDetachedFromWindow() { + highlightAnimator?.cancel() + highlightAnimator = null + super.onDetachedFromWindow() + } + } + + private fun TextView.hasHiddenText(collapsedLines: Int): Boolean { + val layout = layout ?: return false + return layout.lineCount > collapsedLines || + (0 until layout.lineCount).any { layout.getEllipsisCount(it) > 0 } || + (layout.lineCount > 0 && layout.getLineEnd(layout.lineCount - 1) < text.length) } private fun metadataCell( @@ -250,7 +488,7 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { entryId: String, ): LinearLayout = LinearLayout(requireContext()).apply { orientation = LinearLayout.VERTICAL - setPadding(dp(CELL_HORIZONTAL_PADDING_DP), dp(CELL_VERTICAL_PADDING_DP), dp(CELL_HORIZONTAL_PADDING_DP), dp(CELL_VERTICAL_PADDING_DP)) + setPadding(0, dp(CELL_VERTICAL_PADDING_DP), dp(METADATA_END_PADDING_DP), dp(CELL_VERTICAL_PADDING_DP)) isClickable = true isFocusable = true values.forEach { value -> @@ -290,20 +528,22 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { setLineSpacing(0f, 1f) } addView(message) + var previous: TextView? = null if (expanded && entry.action == NotificationAction.EDITED && !entry.previousContents.isNullOrEmpty()) { addView(previousDivider()) - addView(TextView(context).apply { + previous = TextView(context).apply { text = entry.previousContents setLineSpacing(0f, 1f) - }) + }.also(::addView) } + search?.let { matcher -> highlightContents(matcher, listOf(message, previous), + listOf(contents, entry.previousContents.orEmpty())) } if (expanded && entry.imageId != null) { val imageId = entry.imageId - val appContext = requireContext().applicationContext val contentsContainer = this viewLifecycleOwner.lifecycleScope.launch { val bitmap = withContext(Dispatchers.IO) { - EncryptedImageStore(appContext).read(imageId)?.let { bytes -> + imageStore.read(imageId)?.let { bytes -> BitmapFactory.decodeByteArray(bytes, 0, bytes.size) } } @@ -327,6 +567,56 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { setOnLongClickListener { showDeleteDialog(entry.id) } } + private fun highlightContents(matcher: LogContentSearch, views: List, texts: List) { + val generation = loadGeneration + // Only attached rows get spans; neither placeholders nor the viewport cache + // retain highlighted strings. Detaching cancels potentially expensive work. + val owner = views.first()!! + owner.doOnAttach { + val job = viewLifecycleOwner.lifecycleScope.launch { + val spans = try { + runInterruptible(Dispatchers.Default) { matcher.spans(texts) } + } catch (error: SearchTooComplexException) { + if (generation == loadGeneration && searchError == null) { + searchError = error.message + android.widget.Toast.makeText(requireContext(), "Cannot highlight this entry. ${error.message}", android.widget.Toast.LENGTH_LONG).show() + } + return@launch + } + if (generation != loadGeneration || !owner.isAttachedToWindow) return@launch + val color = ContextCompat.getColor(requireContext(), R.color.log_search_highlight) + views.forEachIndexed { field, view -> + val matches = spans.filter { it.field == field } + if (view == null || matches.isEmpty()) return@forEachIndexed + val highlighted = SpannableString(texts[field]) + // Adjacent hits share one background span, keeping long repeated + // literal/regex matches cheap for Android's text layout. + var start = -1 + var end = -1 + fun finish() { + if (start >= 0) highlighted.setSpan(BackgroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) + } + matches.forEach { span -> + if (span.start == end) end = span.end else { + finish() + start = span.start + end = span.end + } + } + finish() + view.text = highlighted + } + } + owner.addOnAttachStateChangeListener(object : View.OnAttachStateChangeListener { + override fun onViewAttachedToWindow(view: View) = Unit + override fun onViewDetachedFromWindow(view: View) { + job.cancel() + view.removeOnAttachStateChangeListener(this) + } + }) + } + } + private fun previousDivider(): LinearLayout = LinearLayout(requireContext()).apply { gravity = Gravity.CENTER_VERTICAL setPadding(0, dp(8), 0, dp(4)) @@ -347,8 +637,8 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { private fun metadataValues(entry: NotificationLogEntry, settings: LogViewSettings): List = buildList { if (LogField.TIMESTAMP in settings.visibleFields) add(MetadataValue(timestamp(entry.recordedAtEpochMillis, settings, entry.eventTimeZoneId), 12f, isTimestamp = true)) - if (LogField.APP_NAME in settings.visibleFields) add(MetadataValue(entry.appName, 15f, indented = true, bold = true)) - if (LogField.PACKAGE_NAME in settings.visibleFields) add(MetadataValue(entry.packageName, 12f, indented = true, breakBeforePeriods = true)) + if (LogField.APP_NAME in settings.visibleFields && entry.appName.isNotBlank()) add(MetadataValue(entry.appName, 15f, indented = true, bold = true)) + if (LogField.PACKAGE_NAME in settings.visibleFields && entry.packageName.isNotBlank()) add(MetadataValue(entry.packageName, 12f, indented = true, breakBeforePeriods = true)) if (LogField.ACTION in settings.visibleFields) add(MetadataValue(actionLabel(entry.action), 14f, indented = true)) } @@ -384,9 +674,9 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { ?: 0 val timestampMinimumWidth = maxOf( dp(MINIMUM_METADATA_COLUMN_DP), - widestTimestamp + dp(CELL_HORIZONTAL_PADDING_DP * 2), + widestTimestamp + dp(METADATA_END_PADDING_DP), ) - val preferredWidth = maxOf(timestampMinimumWidth, widestMetadata + dp(CELL_HORIZONTAL_PADDING_DP * 2)) + val preferredWidth = maxOf(timestampMinimumWidth, widestMetadata + dp(METADATA_END_PADDING_DP)) if (availableWidth <= 0) return preferredWidth val maximumWidth = maxOf( timestampMinimumWidth, @@ -410,24 +700,51 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { } private inner class LogAdapter : RecyclerView.Adapter() { - private var rows: List = emptyList() + private var snapshot: NotificationLogIndex? = null private var settings = LogViewSettings() private var metadataWidth = 0 + private var availableWidth = 0 + private val heights = IntArray(16) + private var contentLineHeight = 1 + private var contentFontPadding = 0 - fun submit(rows: List, settings: LogViewSettings, metadataWidth: Int) { - val previous = this.rows - this.rows = rows + fun collapsedHeight(fields: Int) = heights[fields and 15] + fun contentLines(height: Int) = + ((height - dp(CELL_VERTICAL_PADDING_DP * 2) - contentFontPadding) / contentLineHeight).coerceAtLeast(1) + + fun submit(settings: LogViewSettings, metadataWidth: Int) { + val width = binding?.logList?.let { it.width - it.paddingLeft - it.paddingRight } ?: 0 + val geometryChanged = width != availableWidth || metadataWidth != this.metadataWidth || settings != this.settings + if (width > 0 && geometryChanged) { + val body = TextView(requireContext()).apply { text = "Text" } + body.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED) + contentLineHeight = body.lineHeight + contentFontPadding = body.measuredHeight - body.lineHeight + val sample = NotificationLogEntry(id = "", recordedAtEpochMillis = System.currentTimeMillis(), + packageName = "example.app", appName = "App", action = NotificationAction.APPEARED, contents = null) + heights.indices.forEach { mask -> + val maskedSettings = settings.copy(visibleFields = settings.visibleFields.filterTo(mutableSetOf()) { + (mask and (1 shl it.ordinal)) != 0 + }) + val cell = metadataCell(metadataValues(sample, maskedSettings), false, {}, "") + cell.measure(View.MeasureSpec.makeMeasureSpec(metadataWidth, View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)) + heights[mask] = maxOf(cell.measuredHeight, body.measuredHeight + dp(CELL_VERTICAL_PADDING_DP * 2)) + } + // Re-check remembered rows too, even when they are outside the viewport. + cache.values().filter { it.id in expandedIds }.forEach { entry -> + val probe = LogRow(entry, settings, metadataWidth, expanded = false) + probe.measure(View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)) + probe.layout(0, 0, width, probe.measuredHeight) + } + } + val changed = snapshot !== index || geometryChanged + snapshot = index this.settings = settings this.metadataWidth = metadataWidth - DiffUtil.calculateDiff(object : DiffUtil.Callback() { - override fun getOldListSize() = previous.size - override fun getNewListSize() = rows.size - override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int) = - previous[oldItemPosition].id == rows[newItemPosition].id - override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int) = - previous[oldItemPosition] == rows[newItemPosition] - }).dispatchUpdatesTo(this) - notifyItemRangeChanged(0, itemCount) + this.availableWidth = width + if (changed) notifyDataSetChanged() } override fun onCreateViewHolder(parent: android.view.ViewGroup, viewType: Int): Holder { @@ -440,11 +757,23 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { override fun onBindViewHolder(holder: Holder, position: Int) { holder.content.removeAllViews() - holder.content.addView(logRowView(rows[position], settings, metadataWidth)) + val entry = cache[position] + if (entry == null) { + holder.content.addView(View(holder.content.context).apply { + layoutParams = LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, + collapsedHeight(snapshot!!.fieldsAt(position))) + importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO + }) + holder.content.contentDescription = "Loading log" + } else { + holder.content.contentDescription = null + val row = LogRow(entry, settings, metadataWidth) + holder.content.addView(row) + } holder.separator.visibility = if (position == itemCount - 1) View.GONE else View.VISIBLE } - override fun getItemCount(): Int = rows.size + override fun getItemCount(): Int = snapshot?.count ?: 0 inner class Holder(val root: LinearLayout, val content: LinearLayout) : RecyclerView.ViewHolder(root) { val separator: View get() = root.getChildAt(1) @@ -464,7 +793,7 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { withContext(Dispatchers.IO) { EncryptedNotificationLogStore(requireContext().applicationContext).delete(entryId) } - loadLogs(reset = true) + loadLogs() } } .show() @@ -508,19 +837,19 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { } } - private fun highlightCollapsedRow(row: View) { - if (!row.isAttachedToWindow) return + private fun highlightLogRow(row: View): ValueAnimator? { + if (!row.isAttachedToWindow) return null val baseColor = ContextCompat.getColor(row.context, R.color.primary) val startColor = Color.argb( - COLLAPSE_HIGHLIGHT_ALPHA, + ROW_HIGHLIGHT_ALPHA, Color.red(baseColor), Color.green(baseColor), Color.blue(baseColor), ) val endColor = Color.argb(0, Color.red(baseColor), Color.green(baseColor), Color.blue(baseColor)) row.setBackgroundColor(startColor) - ValueAnimator.ofObject(ArgbEvaluator(), startColor, endColor).apply { - duration = COLLAPSE_HIGHLIGHT_DURATION_MILLIS + return ValueAnimator.ofObject(ArgbEvaluator(), startColor, endColor).apply { + duration = ROW_HIGHLIGHT_DURATION_MILLIS addUpdateListener { row.setBackgroundColor(it.animatedValue as Int) } addListener(object : AnimatorListenerAdapter() { override fun onAnimationEnd(animation: Animator) { @@ -559,15 +888,16 @@ class ViewLogsFragment : Fragment(R.layout.fragment_view_logs) { private companion object { const val SCROLL_TO_TOP_THRESHOLD_DP = 120 const val PAGE_SIZE = 80 + const val PREFETCH_ROWS = 160 const val IMAGE_VIEWER_TAG = "image-viewer" const val MINIMUM_METADATA_COLUMN_DP = 120 - const val CELL_HORIZONTAL_PADDING_DP = 8 + const val METADATA_END_PADDING_DP = 8 const val CELL_VERTICAL_PADDING_DP = 6 const val COLUMN_GAP_DP = 6 const val ROW_SEPARATOR_MARGIN_DP = 4 const val METADATA_INDENT_DP = 8 const val MAXIMUM_METADATA_COLUMN_FRACTION = 0.45f - const val COLLAPSE_HIGHLIGHT_ALPHA = 52 - const val COLLAPSE_HIGHLIGHT_DURATION_MILLIS = 450L + const val ROW_HIGHLIGHT_ALPHA = 52 + const val ROW_HIGHLIGHT_DURATION_MILLIS = 450L } } diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedAtomicFile.kt b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedAtomicFile.kt index ec9a2a7..c797846 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedAtomicFile.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedAtomicFile.kt @@ -9,9 +9,9 @@ import java.io.DataOutputStream import java.io.File import java.io.FileNotFoundException -internal class EncryptedAtomicFile(context: Context, name: String) { +internal class EncryptedAtomicFile(context: Context, name: String, + private val cipher: AesGcmCipher = AesGcmCipher(LogEncryptionKeyProvider().getOrCreate())) { private val file = AtomicFile(File(context.filesDir, name)) - private val cipher = AesGcmCipher(LogEncryptionKeyProvider().getOrCreate()) val exists get() = file.baseFile.isFile diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedImageStore.kt b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedImageStore.kt index 368658b..b2b92d6 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedImageStore.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedImageStore.kt @@ -9,7 +9,7 @@ import java.io.FileNotFoundException /** Stores copied notification image bytes independently of the source app's URI lifetime. */ class EncryptedImageStore(context: Context) { private val directory = File(context.filesDir, "notification-images").also(File::mkdirs) - private val cipher = AesGcmCipher(LogEncryptionKeyProvider().getOrCreate()) + private val cipher by lazy { AesGcmCipher(LogEncryptionKeyProvider().getOrCreate()) } fun save(id: String, bytes: ByteArray) { require(id.matches(IMAGE_ID_PATTERN)) { "Invalid notification image ID." } diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedNotificationLogStore.kt b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedNotificationLogStore.kt index 3d041e2..5f4bc21 100644 --- a/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedNotificationLogStore.kt +++ b/app/src/main/java/se/ajpanton/notificationsmaster/data/EncryptedNotificationLogStore.kt @@ -2,6 +2,10 @@ package se.ajpanton.notificationsmaster.data import android.content.Context import android.util.AtomicFile +import android.util.Base64 +import org.json.JSONArray +import org.json.JSONObject +import se.ajpanton.notificationsmaster.model.NotificationAction import se.ajpanton.notificationsmaster.model.NotificationLogEntry import se.ajpanton.notificationsmaster.settings.StorageLimitsStore import java.io.BufferedInputStream @@ -11,16 +15,6 @@ import java.io.DataOutputStream import java.io.File import java.io.FileNotFoundException -data class NewestLogCursor( - val chunkName: String, - val entryIndex: Int, -) - -data class NotificationLogPage( - val entries: List, - val nextCursor: NewestLogCursor?, -) - /** * Independently encrypted log chunks. Reading or appending a record needs only * one bounded chunk; older chunks stay on disk until requested by the viewer. @@ -31,33 +25,107 @@ class EncryptedNotificationLogStore(context: Context) { private val imageDirectory = File(appContext.filesDir, IMAGE_DIRECTORY_NAME) private val cipher = AesGcmCipher(LogEncryptionKeyProvider().getOrCreate()) - fun readNewest(cursor: NewestLogCursor?, limit: Int): NotificationLogPage = synchronized(lock) { - require(limit > 0) - val result = ArrayList(limit) - val chunks = chunkFiles().asReversed() - var chunkIndex = cursor?.let { saved -> chunks.indexOfFirst { it.name == saved.chunkName } } ?: 0 - var entryIndex = cursor?.entryIndex ?: Int.MAX_VALUE - if (chunkIndex < 0) return@synchronized NotificationLogPage(emptyList(), null) - - while (chunkIndex < chunks.size) { - val chunk = chunks[chunkIndex] - val entries = readChunk(chunk) - var index = minOf(entryIndex, entries.lastIndex) - while (index >= 0 && result.size < limit) { - result += entries[index--] - } - if (result.size == limit) { - val next = if (index >= 0) { - NewestLogCursor(chunk.name, index) - } else { - chunks.getOrNull(chunkIndex + 1)?.let { NewestLogCursor(it.name, Int.MAX_VALUE) } + /** Reads small summaries; an existing unindexed chunk is indexed once on demand. */ + fun openIndex(query: LogQuery = LogQuery()): NotificationLogIndex { + val files = synchronized(lock) { + val files = chunkFiles().asReversed() + directory.listFiles()?.filter { INDEX_SUFFIX in it.name }?.forEach { + val chunkName = it.name.substringBefore(INDEX_SUFFIX) + if (!File(directory, chunkName).isFile) { + AtomicFile(File(directory, "$chunkName$INDEX_SUFFIX")).delete() } - return@synchronized NotificationLogPage(result, next) } - chunkIndex++ - entryIndex = Int.MAX_VALUE + files } - NotificationLogPage(result, null) + val chunks = mutableListOf() + val apps = linkedMapOf() + val actions = mutableSetOf() + var start = 0 + var rebuilt = false + files.forEach { file -> + if (Thread.currentThread().isInterrupted) throw InterruptedException("Log indexing cancelled") + val (summary, updated) = synchronized(lock) { + if (file.isFile) readIndex(file) else null + } ?: return@forEach + rebuilt = rebuilt || updated + val groups = summary.getJSONArray("groups") + val fields = Base64.decode(summary.getString("fields"), Base64.NO_WRAP) + require(fields.size == summary.getInt("records")) { "Invalid notification-log index." } + val matchingFields = ByteArray(fields.size) + var count = 0 + repeat(groups.length()) { position -> + val group = groups.getJSONArray(position) + val packageName = group.getString(0) + val action = NotificationAction.valueOf(group.getString(2)) + if (query.matches(packageName, action)) { + if (query.search == null) { + apps.putIfAbsent(packageName, group.getString(1)) + actions += action + } + count += group.getInt(3) + val positions = group.getJSONArray(4) + repeat(positions.length()) { offset -> + val record = positions.getInt(offset) + matchingFields[record] = fields[record] + } + } + } + var matchingPositions: IntArray? = null + if (count > 0 && query.search != null) { + val entries = synchronized(lock) { if (file.isFile) readChunk(file) else emptyList() } + if (entries.size < fields.size || entries.firstOrNull()?.id != summary.getString("first") || + entries.getOrNull(fields.size - 1)?.id != summary.getString("last")) return openIndex(query) + // App/action selection above avoids decrypting unrelated chunks. Match + // outside the capture lock, and retain positions rather than message text. + matchingPositions = fields.indices.reversed().filter { position -> + matchingFields[position] != 0.toByte() && query.search.matches(listOf( + entries[position].contents.orEmpty(), entries[position].previousContents.orEmpty())) + }.toIntArray() + count = matchingPositions.size + matchingPositions.forEach { position -> + val entry = entries[position] + apps.putIfAbsent(entry.packageName, entry.appName) + actions += entry.action + } + } + if (count > 0) { + val end = Math.addExact(start, count) + chunks += NotificationLogIndex.Chunk(file.name, summary.getInt("records"), + summary.getString("first"), summary.getString("last"), start, end, + matchingPositions?.map { fields[it] }?.toByteArray() + ?: matchingFields.reversedArray().filter { it != 0.toByte() }.toByteArray(), matchingPositions) + start = end + } + } + if (rebuilt) { + // Rebuilding adds storage overhead. Apply retention before returning authoritative counts. + synchronized(lock) { enforceLimits() } + return openIndex(query) + } + return NotificationLogIndex(chunks, query, apps, actions) + } + + /** Directly decrypts the chunks containing a range, not all earlier pages. Null means invalidated. */ + fun readRange(index: NotificationLogIndex, start: Int, limit: Int): List? { + require(start >= 0 && limit > 0) + val result = ArrayList(minOf(limit, (index.count - start).coerceAtLeast(0))) + var position = start + var chunkPosition = index.chunkAt(position) + while (chunkPosition < index.chunks.size && result.size < limit) { + val chunk = index.chunks[chunkPosition++] + val entries = synchronized(lock) { + val file = File(directory, chunk.name) + if (file.isFile) readChunk(file) else emptyList() + } + // Appends may extend a chunk; the snapshot's original prefix remains usable. + if (entries.size < chunk.records || entries.firstOrNull()?.id != chunk.firstId || + entries.getOrNull(chunk.records - 1)?.id != chunk.lastId) return null + val matching = chunk.positions?.map { entries[it] } + ?: entries.take(chunk.records).asReversed().filter(index.query::matches) + result += matching.drop(position - chunk.start).take(limit - result.size) + position = chunk.end + } + return result } /** @@ -82,9 +150,9 @@ class EncryptedNotificationLogStore(context: Context) { val current = newest?.let(::readChunk).orEmpty() val combined = NotificationLogEntryJson.encode(current + entry) if (newest == null || combined.size <= MAX_CHUNK_PLAINTEXT_BYTES) { - writeChunk(newest ?: nextChunkFile(chunks), combined) + writeChunk(newest ?: nextChunkFile(chunks), current + entry, combined) } else { - writeChunk(nextChunkFile(chunks), NotificationLogEntryJson.encode(listOf(entry))) + writeChunk(nextChunkFile(chunks), listOf(entry)) } enforceLimits() } @@ -99,7 +167,7 @@ class EncryptedNotificationLogStore(context: Context) { val entries = readChunk(chunk) val entry = entries.firstOrNull { it.id == id } ?: return@forEach val retained = entries.filterNot { it.id == id } - if (retained.isEmpty()) chunk.delete() else writeChunk(chunk, NotificationLogEntryJson.encode(retained)) + if (retained.isEmpty()) deleteChunk(chunk) else writeChunk(chunk, retained) entry.imageId?.let(::deleteImage) return true } @@ -124,27 +192,27 @@ class EncryptedNotificationLogStore(context: Context) { private fun trimLogBytes(limit: Long) { var chunks = chunkFiles() - var totalBytes = chunks.sumOf(File::length) + var totalBytes = logBytes() while (totalBytes > limit && chunks.isNotEmpty()) { val oldest = chunks.first() val entries = readChunk(oldest) if (entries.isEmpty()) { - oldest.delete() + deleteChunk(oldest) } else if (chunks.size > 1) { entries.mapNotNull { it.imageId }.forEach(::deleteImage) - oldest.delete() + deleteChunk(oldest) } else { var retained = entries while (totalBytes > limit && retained.isNotEmpty()) { retained.first().imageId?.let(::deleteImage) retained = retained.drop(1) - if (retained.isEmpty()) oldest.delete() - else writeChunk(oldest, NotificationLogEntryJson.encode(retained)) - totalBytes = chunkFiles().sumOf(File::length) + if (retained.isEmpty()) deleteChunk(oldest) + else writeChunk(oldest, retained) + totalBytes = logBytes() } } chunks = chunkFiles() - totalBytes = chunks.sumOf(File::length) + totalBytes = logBytes() } } @@ -205,7 +273,8 @@ class EncryptedNotificationLogStore(context: Context) { } } - private fun writeChunk(file: File, encoded: ByteArray) { + private fun writeChunk(file: File, entries: List, + encoded: ByteArray = NotificationLogEntryJson.encode(entries)) { val payload = cipher.encrypt(encoded) val atomicFile = AtomicFile(file) val output = atomicFile.startWrite() @@ -222,8 +291,43 @@ class EncryptedNotificationLogStore(context: Context) { atomicFile.failWrite(output) throw error } + writeIndex(file, entries, payload.initializationVector) } + private fun indexFile(file: File) = EncryptedAtomicFile(appContext, "$DIRECTORY_NAME/${file.name}$INDEX_SUFFIX", cipher) + + private fun readIndex(file: File): Pair { + val iv = DataInputStream(BufferedInputStream(AtomicFile(file).openRead())).use { input -> + require(input.readInt() == FILE_VERSION) { "Unsupported encrypted notification-log chunk." } + readByteArray(input, MAX_IV_BYTES) + } + val revision = Base64.encodeToString(iv, Base64.NO_WRAP) + val saved = indexFile(file).read()?.let { JSONObject(it.decodeToString()) } + if (saved?.getString("revision") == revision) return saved to false + // The IV changes on every write: a missing/interrupted index update cannot look current. + return writeIndex(file, readChunk(file), iv) to true + } + + private fun writeIndex(file: File, entries: List, iv: ByteArray): JSONObject { + val groups = JSONArray() + entries.indices.groupBy { entries[it].packageName to entries[it].action }.forEach { (key, positions) -> + groups.put(JSONArray().put(key.first).put(entries[positions.last()].appName) + .put(key.second.name).put(positions.size).put(JSONArray(positions))) + } + return JSONObject().put("revision", Base64.encodeToString(iv, Base64.NO_WRAP)) + .put("records", entries.size).put("first", entries.first().id).put("last", entries.last().id) + .put("groups", groups) + .put("fields", Base64.encodeToString(ByteArray(entries.size) { entries[it].fieldsMask().toByte() }, Base64.NO_WRAP)) + .also { indexFile(file).write(it.toString().encodeToByteArray()) } + } + + private fun deleteChunk(file: File) { + AtomicFile(file).delete() + AtomicFile(File(directory, "${file.name}$INDEX_SUFFIX")).delete() + } + + private fun logBytes() = directory.listFiles()?.sumOf(File::length) ?: 0L + private fun readByteArray(stream: DataInputStream, maximumLength: Int): ByteArray { val length = stream.readInt() require(length in 1..maximumLength) { "Invalid encrypted notification-log field length." } @@ -231,7 +335,7 @@ class EncryptedNotificationLogStore(context: Context) { } private fun clearChunksOnly() { - chunkFiles().forEach(File::delete) + directory.listFiles()?.forEach { AtomicFile(it).delete() } } private fun deleteImage(id: String) { @@ -244,6 +348,7 @@ class EncryptedNotificationLogStore(context: Context) { const val IMAGE_DIRECTORY_NAME = "notification-images" const val CHUNK_PREFIX = "chunk-" const val CHUNK_SUFFIX = ".bin" + const val INDEX_SUFFIX = ".index" const val CHUNK_NAME_WIDTH = 12 const val FILE_VERSION = 1 const val MAX_IV_BYTES = 32 diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/data/LogWindowCache.kt b/app/src/main/java/se/ajpanton/notificationsmaster/data/LogWindowCache.kt new file mode 100644 index 0000000..0354ddc --- /dev/null +++ b/app/src/main/java/se/ajpanton/notificationsmaster/data/LogWindowCache.kt @@ -0,0 +1,46 @@ +package se.ajpanton.notificationsmaster.data + +import se.ajpanton.notificationsmaster.model.NotificationLogEntry + +/** Decrypted content is bounded independently of the user's on-disk history limit. */ +internal class LogWindowCache( + private val maxEntries: Int = 480, + private val maxBytes: Long = 4 * 1024 * 1024, +) { + private val entries = sortedMapOf() + val size get() = entries.size + val bytes get() = entries.values.sumOf(::entryBytes) + operator fun get(position: Int) = entries[position] + fun values(): Collection = entries.values + fun clear() = entries.clear() + + fun put(start: Int, rows: List) { + rows.forEachIndexed { offset, entry -> entries[start + offset] = entry } + } + + /** Visible rows are never evicted; the byte limit can be exceeded by that working set alone. */ + fun retain(first: Int, last: Int, margin: Int): Map { + val removed = mutableMapOf() + entries.keys.filter { it < first - margin || it > last + margin }.forEach { + removed[it] = entries.remove(it)!!.id + } + var retainedBytes = bytes + if (size <= maxEntries && retainedBytes <= maxBytes) return removed + entries.keys.filter { it !in first..last } + .sortedByDescending { if (it < first) first - it else it - last } + .forEach { position -> + if (size > maxEntries || retainedBytes > maxBytes) { + val entry = entries.remove(position)!! + retainedBytes -= entryBytes(entry) + removed[position] = entry.id + } + } + return removed + } + + private fun entryBytes(entry: NotificationLogEntry): Long = 256L + 2L * ( + entry.id.length + entry.packageName.length + entry.appName.length + + (entry.contents?.length ?: 0) + (entry.previousContents?.length ?: 0) + + (entry.eventTimeZoneId?.length ?: 0) + (entry.imageId?.length ?: 0) + ) +} diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/data/NotificationLogIndex.kt b/app/src/main/java/se/ajpanton/notificationsmaster/data/NotificationLogIndex.kt new file mode 100644 index 0000000..4baf6b5 --- /dev/null +++ b/app/src/main/java/se/ajpanton/notificationsmaster/data/NotificationLogIndex.kt @@ -0,0 +1,65 @@ +package se.ajpanton.notificationsmaster.data + +import se.ajpanton.notificationsmaster.model.NotificationAction +import se.ajpanton.notificationsmaster.model.NotificationLogEntry +import se.ajpanton.notificationsmaster.settings.LogField +import se.ajpanton.notificationsmaster.search.LogContentSearch + +internal fun NotificationLogEntry.fieldsMask(): Int = + (1 shl LogField.TIMESTAMP.ordinal) or (1 shl LogField.ACTION.ordinal) or + (if (appName.isNotBlank()) 1 shl LogField.APP_NAME.ordinal else 0) or + (if (packageName.isNotBlank()) 1 shl LogField.PACKAGE_NAME.ordinal else 0) or + (if (!contents.isNullOrEmpty()) 1 shl LogField.CONTENTS.ordinal else 0) + +data class LogQuery( + val packages: Set = emptySet(), + val actions: Set = NotificationAction.entries.toSet(), + val search: LogContentSearch? = null, +) { + fun matches(entry: NotificationLogEntry) = matches(entry.packageName, entry.action) && + (search?.matches(listOf(entry.contents.orEmpty(), entry.previousContents.orEmpty())) != false) + fun matches(packageName: String, action: NotificationAction) = + action in actions && (packages.isEmpty() || packageName in packages) +} + +/** A filtered snapshot of chunk boundaries, app names and one-byte field flags; no contents. */ +class NotificationLogIndex internal constructor( + internal val chunks: List, + val query: LogQuery, + val apps: Map, + val actions: Set, +) { + val count: Int = chunks.lastOrNull()?.end ?: 0 + + fun fieldsAt(position: Int): Int { + require(position in 0 until count) + val chunk = chunks[chunkAt(position)] + return chunk.fields[position - chunk.start].toInt() + } + + internal fun chunkAt(position: Int): Int { + var low = 0 + var high = chunks.lastIndex + while (low <= high) { + val middle = (low + high).ushr(1) + val chunk = chunks[middle] + when { + position < chunk.start -> high = middle - 1 + position >= chunk.end -> low = middle + 1 + else -> return middle + } + } + return chunks.size + } + + internal data class Chunk( + val name: String, + val records: Int, + val firstId: String, + val lastId: String, + val start: Int, + val end: Int, + val fields: ByteArray, + val positions: IntArray? = null, + ) +} diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/search/LogContentSearch.kt b/app/src/main/java/se/ajpanton/notificationsmaster/search/LogContentSearch.kt new file mode 100644 index 0000000..0c72785 --- /dev/null +++ b/app/src/main/java/se/ajpanton/notificationsmaster/search/LogContentSearch.kt @@ -0,0 +1,177 @@ +package se.ajpanton.notificationsmaster.search + +import com.google.re2j.Pattern + +enum class SearchMode(val label: String) { + REGEX("Regex"), LITERAL("Literal text"), AND("All terms (AND)"), OR("Any term (OR)"); + + val usesTerms get() = this == AND || this == OR +} + +data class LogSearchSettings( + val text: String = "", + val mode: SearchMode = SearchMode.LITERAL, + val caseSensitive: Boolean = false, + val wholeWords: Boolean = false, +) { + val active get() = if (mode.usesTerms) text.isNotBlank() else text.isNotEmpty() +} + +data class SearchSpan(val field: Int, val start: Int, val end: Int) +class SearchTooComplexException : Exception("Search is too complex. Try fewer terms or whole words.") + +/** Offsets use UTF-16, like Android text spans. No text crosses a field boundary. */ +class LogContentSearch(val settings: LogSearchSettings) { + private val pattern = if (settings.mode == SearchMode.REGEX && settings.active) + Pattern.compile(settings.text, if (settings.caseSensitive) 0 else Pattern.CASE_INSENSITIVE) else null + private val terms = if (settings.mode.usesTerms) settings.text.trim().split(Regex("\\s+")) else emptyList() + + fun matches(fields: List): Boolean { + checkInterrupted() + if (!settings.active) return true + return when (settings.mode) { + SearchMode.REGEX -> fields.any { it.isNotEmpty() && pattern!!.matcher(it).find() } + SearchMode.LITERAL -> fields.any { it.contains(settings.text, !settings.caseSensitive) } + SearchMode.OR -> terms.any { term -> fields.any { occurrences(it, term).hasNext() } } + SearchMode.AND -> termSpans(fields).size == terms.size + } + } + + fun spans(fields: List): List { + checkInterrupted() + if (!settings.active) return emptyList() + if (settings.mode.usesTerms) return termSpans(fields) + return buildList { + fields.forEachIndexed { field, text -> + if (pattern != null) { + val matcher = pattern.matcher(text) + while (text.isNotEmpty() && matcher.find()) { + checkInterrupted() + if (matcher.end() > matcher.start()) add(SearchSpan(field, matcher.start(), matcher.end())) + } + } else { + var cursor = 0 + while (cursor <= text.length - settings.text.length) { + checkInterrupted() + val start = text.indexOf(settings.text, cursor, !settings.caseSensitive) + if (start < 0) break + cursor = start + settings.text.length + add(SearchSpan(field, start, cursor)) + } + } + } + } + } + + private fun occurrences(text: String, term: String): Iterator = sequence { + var cursor = 0 + while (cursor <= text.length - term.length) { + checkInterrupted() + val start = text.indexOf(term, cursor, !settings.caseSensitive) + if (start < 0) break + val end = start + term.length + if (!settings.wholeWords || + ((start == 0 || !wordCharacter(text.codePointBefore(start))) && + (end == text.length || !wordCharacter(text.codePointAt(end))))) yield(start) + cursor = start + 1 // Include overlapping candidates; the solver chooses compatible ones. + } + }.iterator() + + private fun termSpans(fields: List): List { + val groups = terms.groupingBy { it }.eachCount().entries.toList() + if (groups.size > 128 || terms.size > 4096) throw SearchTooComplexException() + if (groups.size == 1) { + val term = groups.single().key + val quota = groups.single().value + val selected = mutableListOf() + fields.forEachIndexed { field, text -> + var cursor = 0 + val matches = occurrences(text, term) + while (selected.size < quota && matches.hasNext()) { + val start = matches.next() + if (start >= cursor) { + cursor = start + term.length + selected += SearchSpan(field, start, cursor) + } + } + } + return if (settings.mode == SearchMode.AND && selected.size < quota) emptyList() else selected + } + var candidateCount = 0 + val candidates = groups.map { (term, _) -> buildList { + var offset = 0 + fields.forEachIndexed { field, text -> + occurrences(text, term).forEach { start -> + if (++candidateCount > MAX_CANDIDATES) throw SearchTooComplexException() + add(Candidate(offset + start, offset + start + term.length, SearchSpan(field, start, start + term.length))) + } + offset = Math.addExact(offset, text.length + 1) + } + } } + val quotas = groups.map { it.value } + if (settings.mode == SearchMode.AND && candidates.indices.any { candidates[it].size < quotas[it] }) return emptyList() + val target = candidates.indices.sumOf { minOf(quotas[it], candidates[it].size) } + if (target == 0) return emptyList() + if (settings.wholeWords) { + val ordered = candidates.flatMapIndexed { group, matches -> matches.map { group to it } }.sortedBy { it.second.start } + // Ordinary whole-word candidates do not overlap. Punctuation-containing + // terms can still overlap, so those use the exact solver below. + if (ordered.zipWithNext().all { (left, right) -> left.second.end <= right.second.start }) { + val remaining = quotas.toMutableList() + val selected = ordered.mapNotNull { (group, match) -> + if (remaining[group] > 0) { remaining[group]--; match.span } else null + } + return if (settings.mode == SearchMode.AND && selected.size < terms.size) emptyList() else selected + } + } + val pending = ArrayDeque() + pending.add(Node(0, quotas, 0, null, null)) + val earliest = mutableMapOf, Int>() + var best = pending.last() + var visited = 0 + while (pending.isNotEmpty()) { + checkInterrupted() + if (++visited > MAX_STATES) throw SearchTooComplexException() + val node = pending.removeLast() + if (node.count > best.count) best = node + if (best.count == target) break + if (node.count + node.remaining.sum() <= best.count || + earliest[node.remaining]?.let { it <= node.cursor } == true) continue + earliest[node.remaining] = node.cursor + // For a given term, its earliest compatible occurrence dominates later + // ones. Exploring term order still finds alternatives to greedy overlaps. + val next = candidates.indices.mapNotNull { group -> + if (node.remaining[group] == 0) return@mapNotNull null + val list = candidates[group] + var low = 0 + var high = list.size + while (low < high) { + val middle = (low + high).ushr(1) + if (list[middle].start < node.cursor) low = middle + 1 else high = middle + } + list.getOrNull(low)?.let { group to it } + }.sortedByDescending { it.second.end } + next.forEach { (group, candidate) -> + if (pending.size >= MAX_STATES) throw SearchTooComplexException() + val remaining = node.remaining.toMutableList().apply { this[group]-- } + pending.add(Node(candidate.end, remaining, node.count + 1, node, candidate.span)) + } + } + if (settings.mode == SearchMode.AND && best.count < terms.size) return emptyList() + return generateSequence(best) { it.parent }.mapNotNull { it.span }.toList().asReversed() + } + + private data class Candidate(val start: Int, val end: Int, val span: SearchSpan) + private data class Node(val cursor: Int, val remaining: List, val count: Int, val parent: Node?, val span: SearchSpan?) + + private companion object { + const val MAX_CANDIDATES = 100_000 + const val MAX_STATES = 10_000 + fun checkInterrupted() { + if (Thread.currentThread().isInterrupted) throw InterruptedException("Content search cancelled") + } + fun wordCharacter(codePoint: Int): Boolean = Character.isLetterOrDigit(codePoint) || codePoint == '_'.code || + Character.getType(codePoint) == Character.NON_SPACING_MARK.toInt() || + Character.getType(codePoint) == Character.COMBINING_SPACING_MARK.toInt() + } +} diff --git a/app/src/main/java/se/ajpanton/notificationsmaster/settings/LogSearchStore.kt b/app/src/main/java/se/ajpanton/notificationsmaster/settings/LogSearchStore.kt new file mode 100644 index 0000000..f50fced --- /dev/null +++ b/app/src/main/java/se/ajpanton/notificationsmaster/settings/LogSearchStore.kt @@ -0,0 +1,37 @@ +package se.ajpanton.notificationsmaster.settings + +import android.content.Context +import org.json.JSONObject +import se.ajpanton.notificationsmaster.data.EncryptedAtomicFile +import se.ajpanton.notificationsmaster.search.LogSearchSettings +import se.ajpanton.notificationsmaster.search.SearchMode + +/** Queries can contain private message text, so persist them encrypted too. */ +class LogSearchStore(context: Context) { + private val file = EncryptedAtomicFile(context.applicationContext, "log-search.bin") + + fun load(): LogSearchSettings = synchronized(lock) { + if (!file.exists) cached = null + cached ?: file.read()?.let { bytes -> + val json = JSONObject(bytes.decodeToString()) + LogSearchSettings(json.getString("text"), SearchMode.valueOf(json.getString("mode")), + json.getBoolean("caseSensitive"), json.getBoolean("wholeWords")) + }?.also { cached = it } ?: LogSearchSettings() + } + + fun save(settings: LogSearchSettings) = synchronized(lock) { + val bytes = JSONObject().put("text", settings.text).put("mode", settings.mode.name) + .put("caseSensitive", settings.caseSensitive).put("wholeWords", settings.wholeWords) + .toString().encodeToByteArray() + require(bytes.size <= 64 * 1024) { "Search text is too long." } + file.write(bytes) + cached = settings + } + + fun clear() = save(load().copy(text = "")) + + private companion object { + val lock = Any() + var cached: LogSearchSettings? = null + } +} diff --git a/app/src/main/res/drawable/ic_clear_log_filters.xml b/app/src/main/res/drawable/ic_clear_log_filters.xml new file mode 100644 index 0000000..578ee5a --- /dev/null +++ b/app/src/main/res/drawable/ic_clear_log_filters.xml @@ -0,0 +1,3 @@ + + + diff --git a/app/src/main/res/drawable/ic_log_search.xml b/app/src/main/res/drawable/ic_log_search.xml new file mode 100644 index 0000000..f29a52e --- /dev/null +++ b/app/src/main/res/drawable/ic_log_search.xml @@ -0,0 +1,3 @@ + + + diff --git a/app/src/main/res/drawable/ic_log_search_active.xml b/app/src/main/res/drawable/ic_log_search_active.xml new file mode 100644 index 0000000..84803d7 --- /dev/null +++ b/app/src/main/res/drawable/ic_log_search_active.xml @@ -0,0 +1,3 @@ + + + diff --git a/app/src/main/res/layout/fragment_view_logs.xml b/app/src/main/res/layout/fragment_view_logs.xml index 1b8560f..3657c96 100644 --- a/app/src/main/res/layout/fragment_view_logs.xml +++ b/app/src/main/res/layout/fragment_view_logs.xml @@ -26,6 +26,33 @@ android:layout_margin="24dp" android:text="No logs yet." /> + + + + + + + + #69521C + diff --git a/app/src/main/res/values/log_search.xml b/app/src/main/res/values/log_search.xml new file mode 100644 index 0000000..df3ff88 --- /dev/null +++ b/app/src/main/res/values/log_search.xml @@ -0,0 +1,7 @@ + + + + + + #FFE39A + diff --git a/app/src/test/java/se/ajpanton/notificationsmaster/data/LogWindowCacheTest.kt b/app/src/test/java/se/ajpanton/notificationsmaster/data/LogWindowCacheTest.kt new file mode 100644 index 0000000..b3c847f --- /dev/null +++ b/app/src/test/java/se/ajpanton/notificationsmaster/data/LogWindowCacheTest.kt @@ -0,0 +1,44 @@ +package se.ajpanton.notificationsmaster.data + +import org.junit.Assert.* +import org.junit.Test +import se.ajpanton.notificationsmaster.model.NotificationAction +import se.ajpanton.notificationsmaster.model.NotificationLogEntry + +class LogWindowCacheTest { + private fun row(position: Int, length: Int = 20) = NotificationLogEntry( + id = "$position", recordedAtEpochMillis = position.toLong(), packageName = "app", + appName = "App", action = NotificationAction.APPEARED, contents = "x".repeat(length), + ) + + @Test fun bothDirectionsKeepNearbyRowsAndEvictDistantOnes() { + val cache = LogWindowCache(maxEntries = 80) + cache.put(0, List(240) { row(it) }) + val removed = cache.retain(100, 110, 80) + assertTrue(cache.size <= 80) + (100..110).forEach { assertNotNull(cache[it]) } + assertNull(cache[0]) + assertNull(cache[239]) + assertEquals("0", removed[0]) + cache.put(0, List(40) { row(it) }) + cache.retain(0, 10, 80) + assertNotNull(cache[0]) + assertNull(cache[110]) + } + + @Test fun byteLimitAlsoBoundsLongMessagesButNeverDropsVisibleRows() { + val cache = LogWindowCache(maxEntries = 100, maxBytes = 16_000) + cache.put(0, List(100) { row(it, length = 2_000) }) + cache.retain(40, 41, 100) + assertTrue(cache.bytes <= 16_000) + assertNotNull(cache[40]) + assertNotNull(cache[41]) + cache.put(40, listOf(row(40, length = 100_000))) + cache.retain(40, 41, 100) + assertEquals(2, cache.size) + assertTrue(cache.bytes > 16_000) + cache.clear() + assertEquals(0, cache.size) + assertEquals(0L, cache.bytes) + } +} diff --git a/app/src/test/java/se/ajpanton/notificationsmaster/search/LogContentSearchTest.kt b/app/src/test/java/se/ajpanton/notificationsmaster/search/LogContentSearchTest.kt new file mode 100644 index 0000000..93bcb71 --- /dev/null +++ b/app/src/test/java/se/ajpanton/notificationsmaster/search/LogContentSearchTest.kt @@ -0,0 +1,101 @@ +package se.ajpanton.notificationsmaster.search + +import com.google.re2j.PatternSyntaxException +import org.junit.Assert.* +import org.junit.Test +import kotlin.random.Random + +class LogContentSearchTest { + private val text = "there is some text and here is some more" + private fun search(query: String, mode: SearchMode = SearchMode.AND, words: Boolean = false, case: Boolean = false) = + LogContentSearch(LogSearchSettings(query, mode, case, words)) + + @Test fun duplicateTermsNeedDistinctOccurrences() { + assertEquals(2, search("some some").spans(listOf(text)).size) + assertTrue(search("some some").matches(listOf(text))) + assertFalse(search("some some some").matches(listOf(text))) + assertEquals(2, search("some some some", SearchMode.OR).spans(listOf(text)).size) + assertEquals(2, search("aa aa").spans(listOf("aaaa")).size) + assertFalse(search("aa aa").matches(listOf("aaa"))) + } + + @Test fun overlapsAreNotGreedyAndOrMaximizesTerms() { + assertFalse(search("mor ore").matches(listOf(text))) + assertEquals(listOf("there", "here"), search("here there").spans(listOf(text)).map { text.substring(it.start, it.end) }) + assertEquals(1, search("mor ore", SearchMode.OR).spans(listOf(text)).size) + assertEquals(2, search("abcd ab cd", SearchMode.OR).spans(listOf("abcd")).size) + assertEquals(2, search("here there", SearchMode.OR).spans(listOf(text)).size) + } + + @Test fun literalSpacesRegexCaseAndWholeWords() { + assertTrue(search("some text", SearchMode.LITERAL).matches(listOf(text))) + assertFalse(search("some text", SearchMode.LITERAL).matches(listOf(text))) + assertEquals(2, search("some", SearchMode.LITERAL).spans(listOf(text)).size) + assertTrue(search("SOME", SearchMode.LITERAL).matches(listOf(text))) + assertFalse(search("SOME", SearchMode.LITERAL, case = true).matches(listOf(text))) + assertEquals(2, search("s.me", SearchMode.REGEX).spans(listOf(text)).size) + assertTrue(search("^there.*more$", SearchMode.REGEX).matches(listOf(text))) + assertFalse(search("ore", words = true).matches(listOf(text))) + assertTrue(search("some some", words = true).matches(listOf(text))) + assertFalse(search("cat", words = true).matches(listOf("cats cat_name caté cat\u0301"))) + assertTrue(search("cat", words = true).matches(listOf("(cat)!"))) + assertFalse(search("é", words = true).matches(listOf("café"))) + assertFalse(search("cat cat!", words = true).matches(listOf("cat!"))) + assertEquals(1, search("cat cat!", SearchMode.OR, words = true).spans(listOf("cat!")).size) + } + + @Test fun fieldsStaySeparateAndZeroWidthRegexDoesNotMatchMissingContents() { + val fields = listOf("first message", "previous message") + assertEquals(setOf(0, 1), search("message message").spans(fields).map { it.field }.toSet()) + assertFalse(search("message previous", SearchMode.LITERAL).matches(fields)) + assertTrue(search("^", SearchMode.REGEX).matches(fields)) + assertTrue(search("^", SearchMode.REGEX).spans(fields).isEmpty()) + assertFalse(search("^", SearchMode.REGEX).matches(listOf("", ""))) + assertTrue(search(" ").matches(fields)) // Inactive term query. + } + + @Test(expected = PatternSyntaxException::class) fun invalidRegexFailsClearly() { search("[", SearchMode.REGEX) } + + @Test(expected = SearchTooComplexException::class) fun excessiveSearchFailsInsteadOfGuessingMatches() { + search((0..128).joinToString(" ") { "term$it" }).matches(listOf(text)) + } + + @Test fun longDuplicateQueriesAndCancellationDoNotOverflowTheStack() { + val query = List(2000) { "a" }.joinToString(" ") + assertEquals(2000, search(query).spans(listOf("a".repeat(4000))).size) + Thread.currentThread().interrupt() + try { + search("some some").matches(listOf(text)) + fail("Cancelled searches must stop") + } catch (_: InterruptedException) { + // Do not leak the interrupt into the remaining test suite. + } finally { + Thread.interrupted() + } + } + + @Test fun solverAgreesWithExhaustiveSmallCases() { + val random = Random(53) + repeat(300) { + val haystack = (0 until 8).map { if (random.nextBoolean()) 'a' else 'b' }.joinToString("") + val terms = List(4) { List(random.nextInt(1, 4)) { if (random.nextBoolean()) 'a' else 'b' }.joinToString("") } + fun exhaustive(term: Int, occupied: Set): Int { + if (term == terms.size) return 0 + var best = exhaustive(term + 1, occupied) + for (start in 0..haystack.length - terms[term].length) { + val positions = (start until start + terms[term].length).toSet() + if (haystack.startsWith(terms[term], start) && positions.none { it in occupied }) { + best = maxOf(best, 1 + exhaustive(term + 1, occupied + positions)) + } + } + return best + } + val maximum = exhaustive(0, emptySet()) + val query = terms.joinToString(" ") + val spans = search(query, SearchMode.OR).spans(listOf(haystack)) + assertEquals("$haystack / $query", maximum, spans.size) + assertEquals(spans.sumOf { it.end - it.start }, spans.flatMap { it.start until it.end }.toSet().size) + assertEquals(maximum == terms.size, search(query).matches(listOf(haystack))) + } + } +}