Redesign: Material 3, a landing screen that lists your documents, and actions where the thumb is

app/build.gradle

@@ -244,13 +244,19 @@ dependencies {
     implementation libs.androidx.core
     implementation libs.material
     implementation libs.androidx.webkit
+    implementation libs.androidx.recyclerview
+    implementation libs.androidx.lifecycle.viewmodel
+    implementation libs.androidx.lifecycle.livedata
 
     implementation libs.asset.extractor
 
     testImplementation libs.junit
 
     androidTestImplementation libs.espresso.core
     androidTestImplementation libs.espresso.intents
+    // RecyclerViewActions: the landing screen is one list, and what a test wants to reach
+    // is regularly a row that has not been bound yet on a small screen
+    androidTestImplementation libs.espresso.contrib
     androidTestImplementation libs.androidx.test.rules
     androidTestImplementation libs.androidx.test.runner
     androidTestImplementation libs.androidx.test.junit

app/src/androidTest/java/app/opendocument/droid/test/CoreTest.kt

@@ -31,6 +31,10 @@ class CoreTest {
     private var passwordTestFile: File? = null
     private var spreadsheetTestFile: File? = null
     private var docxTestFile: File? = null
+    private var pptxTestFile: File? = null
+    private var docTestFile: File? = null
+    private var pptTestFile: File? = null
+    private var xlsTestFile: File? = null
 
     private val coreLoader: CoreLoader
         get() = checkNotNull(sharedLoader) { "the core loader was not started" }
@@ -58,6 +62,22 @@ class CoreTest {
                 assetManager.open("style-various-1.docx"),
                 File(appCtx.cacheDir, "style-various-1.docx"),
             )
+        pptxTestFile =
+            extract(
+                assetManager.open("style-various-1.pptx"),
+                File(appCtx.cacheDir, "style-various-1.pptx"),
+            )
+        docTestFile = extract(assetManager.open("11KB.doc"), File(appCtx.cacheDir, "11KB.doc"))
+        pptTestFile =
+            extract(
+                assetManager.open("style-various-1.ppt"),
+                File(appCtx.cacheDir, "style-various-1.ppt"),
+            )
+        xlsTestFile =
+            extract(
+                assetManager.open("file_example_XLS_10.xls"),
+                File(appCtx.cacheDir, "file_example_XLS_10.xls"),
+            )
     }
 
     @After
@@ -66,6 +86,10 @@ class CoreTest {
         passwordTestFile?.delete()
         spreadsheetTestFile?.delete()
         docxTestFile?.delete()
+        pptxTestFile?.delete()
+        docTestFile?.delete()
+        pptTestFile?.delete()
+        xlsTestFile?.delete()
     }
 
     @Test
@@ -109,6 +133,90 @@ class CoreTest {
         Assert.assertTrue("the edited document should have been saved", result.isFile)
     }
 
+    /**
+     * The formats that used to be sent off for conversion instead: presentations, and the legacy
+     * binary microsoft ones. The core renders all four, so the app hands them to it.
+     */
+    @Test
+    fun testPptx() {
+        val views =
+            coreLoader.host(
+                prefix = "pptx-test",
+                inputPath = requireFile(pptxTestFile).absolutePath,
+                cachePath = File(cacheDir(), "pptx_cache").path,
+            )
+        Assert.assertFalse("hosting the PPTX file should produce a view", views.isEmpty())
+    }
+
+    @Test
+    fun testDoc() {
+        val views =
+            coreLoader.host(
+                prefix = "doc-test",
+                inputPath = requireFile(docTestFile).absolutePath,
+                cachePath = File(cacheDir(), "doc_cache").path,
+            )
+        Assert.assertFalse("hosting the DOC file should produce a view", views.isEmpty())
+    }
+
+    @Test
+    fun testPpt() {
+        val views =
+            coreLoader.host(
+                prefix = "ppt-test",
+                inputPath = requireFile(pptTestFile).absolutePath,
+                cachePath = File(cacheDir(), "ppt_cache").path,
+            )
+        Assert.assertFalse("hosting the PPT file should produce a view", views.isEmpty())
+    }
+
+    @Test
+    fun testXls() {
+        val views =
+            coreLoader.host(
+                prefix = "xls-test",
+                inputPath = requireFile(xlsTestFile).absolutePath,
+                cachePath = File(cacheDir(), "xls_cache").path,
+            )
+        Assert.assertFalse("hosting the XLS file should produce a view", views.isEmpty())
+    }
+
+    /**
+     * Which of the formats the core renders it can also write back again - the answer
+     * `DocumentFragment` puts the Edit button up by. Offering it for a document the core will not
+     * save only gets as far as a failed save, which is what happened to the legacy binary formats
+     * when they started going through the core.
+     */
+    @Test
+    fun testEditableFormats() {
+        assertEditable("odt-editable", requireFile(testFile), true)
+        assertEditable("docx-editable", requireFile(docxTestFile), true)
+
+        // the core declares these read only: the three legacy binary formats, ooxml presentations
+        // and every spreadsheet - the last being issue #442, which the core has its own TODO for
+        assertEditable("doc-editable", requireFile(docTestFile), false)
+        assertEditable("ppt-editable", requireFile(pptTestFile), false)
+        assertEditable("xls-editable", requireFile(xlsTestFile), false)
+        assertEditable("pptx-editable", requireFile(pptxTestFile), false)
+        assertEditable("ods-editable", requireFile(spreadsheetTestFile), false)
+    }
+
+    private fun assertEditable(prefix: String, file: File, expected: Boolean) {
+        coreLoader.host(
+            prefix = prefix,
+            inputPath = file.absolutePath,
+            cachePath = File(cacheDir(), prefix).path,
+            editable = true,
+            keepDocument = true,
+        )
+
+        Assert.assertEquals(
+            "the core should report ${file.name} as ${if (expected) "editable" else "read only"}",
+            expected,
+            coreLoader.isDocumentEditable,
+        )
+    }
+
     @Test
     fun testPasswordProtectedDocumentWithoutPassword() {
         Assert.assertThrows(OdrException.FileEncrypted::class.java) {
@@ -176,7 +284,7 @@ class CoreTest {
             // set of statics. nothing here goes through loadAsync, so both handlers can be the main
             // looper and the listener is never called back
             val handler = Handler(Looper.getMainLooper())
-            val loader = CoreLoader(appCtx, true)
+            val loader = CoreLoader(appCtx)
             sharedLoader = loader
             loader.initialize(
                 object : FileLoader.FileLoaderListener {