improve history - a lot

app/src/main/java/oppen/ariane/io/gemini/AddressBuilder.kt

@@ -3,7 +3,7 @@ package oppen.ariane.io.gemini
 import android.net.Uri
 import java.net.URI
 
-class AddressBuilder{
+class AddressBuilder {
 
     private var uri: Uri = Uri.EMPTY
 

app/src/main/java/oppen/ariane/io/gemini/Datasource.kt

@@ -7,6 +7,8 @@ import java.net.URI
 interface Datasource {
     fun request(uri: URI, forceDownload: Boolean, onUpdate: (state: GemState) -> Unit)
     fun request(uri: URI, onUpdate: (state: GemState) -> Unit)
+    fun canGoBack(): Boolean
+    fun goBack(onUpdate: (state: GemState) -> Unit)
 
     companion object{
         fun factory(context: Context): Datasource {

app/src/main/java/oppen/ariane/io/gemini/GeminiDatasource.kt

@@ -10,20 +10,18 @@ import oppen.isGemini
 import oppen.toURI
 import oppen.toUri
 import java.io.*
+import java.lang.IllegalStateException
 import java.net.ConnectException
 import java.net.URI
 import javax.net.ssl.*
 
 const val GEMINI_SCHEME = "gemini"
 
-class GeminiDatasource(
+class GeminiDatasource(private val context: Context): Datasource {
-    private val context: Context): Datasource {
 
     private val prefs = PreferenceManager.getDefaultSharedPreferences(context)
-    private var last: URI? = null
-
     private val addressBuilder = AddressBuilder()
-
+    private val runtimeHistory = mutableListOf<URI>()
     private var forceDownload = false
 
     override fun request(uri: URI, onUpdate: (state: GemState) -> Unit) = request(uri, false, onUpdate)
@@ -42,7 +40,6 @@ class GeminiDatasource(
                 val cached = RuntimeCache.get(uri)
                 when {
                     cached != null -> {
-                        last = uri
                         onUpdate(GemState.ResponseGemtext(uri, cached.first, cached.second))
                         return
                     }
@@ -59,11 +56,9 @@ class GeminiDatasource(
                 val parsedUri = addressBuilder.request(uri).uri()
                 if(parsedUri.isGemini()){
                     val cached = RuntimeCache.get(parsedUri)
-                    if(cached != null){
+                    when {
-                        last = parsedUri.toURI()
+                        cached != null -> onUpdate(GemState.ResponseGemtext(parsedUri.toURI(), cached.first, cached.second))
-                        onUpdate(GemState.ResponseGemtext(parsedUri.toURI(), cached.first, cached.second))
+                        else -> request(parsedUri.toURI(), forceDownload, onUpdate)
-                    }else{
-                        request(parsedUri.toURI(), forceDownload, onUpdate)
                     }
                 }else{
                     onUpdate(GemState.NotGeminiRequest(uri))
@@ -81,7 +76,6 @@ class GeminiDatasource(
      *
      */
     private fun geminiRequest(uri: URI, onUpdate: (state: GemState) -> Unit){
-        last = uri
         val port = if(uri.port == -1) 1965 else uri.port
 
         val protocol = prefs.getString("tls_protocol", "TLS")
@@ -184,9 +178,13 @@ class GeminiDatasource(
         val processed = GemtextHelper.findCodeBlocks(lines)
 
         when {
-            uri.toString().startsWith("gemini://") -> RuntimeCache.put(uri, header, processed)
+            !uri.toString().startsWith("gemini://") -> throw IllegalStateException("Not a Gemini Uri")
         }
 
+        RuntimeCache.put(uri, header, processed)
+
+        if(runtimeHistory.isEmpty() || runtimeHistory.last().toString() != uri.toString()) runtimeHistory.add(uri)
+
         onUpdate(GemState.ResponseGemtext(uri, header, processed))
     }
 
@@ -236,4 +234,11 @@ class GeminiDatasource(
             }
         }
     }
+
+    override fun canGoBack(): Boolean = runtimeHistory.size > 1
+
+    override fun goBack(onUpdate: (state: GemState) -> Unit) {
+        runtimeHistory.removeLast()
+        request(runtimeHistory.last(), onUpdate)
+    }
 }

app/src/main/java/oppen/ariane/ui/GemViewModel.kt

@@ -14,8 +14,6 @@ class GemViewModel: ViewModel() {
     private lateinit var bookmarks: BookmarksDatasource
     private var onState: (state: GemState) -> Unit = {}
 
-    private val history = mutableListOf<URI>()
-
     fun initialise(home: String, gemini: Datasource, bookmarks: BookmarksDatasource, onState: (state: GemState) -> Unit){
         this.gemini = gemini
         this.bookmarks = bookmarks
@@ -30,15 +28,6 @@ class GemViewModel: ViewModel() {
 
     fun request(uri: URI){
         gemini.request(uri){ state ->
-            if(state is GemState.ResponseGemtext) {
-                when {
-                    history.isEmpty() -> history.add(uri)
-                    !history.takeLast(5).contains(uri) -> {
-                        println("Adding $uri to runtime history")
-                        history.add(uri)
-                    }
-                }
-            }
             onState(state)
         }
     }
@@ -59,26 +48,6 @@ class GemViewModel: ViewModel() {
         }
     }
 
-    fun canGoBack(): Boolean = history.size > 1
+    fun canGoBack(): Boolean = gemini.canGoBack()
-
+    fun goBack() = gemini.goBack(onState)
-    @ExperimentalStdlibApi
-    fun goBack(){
-        when {
-            history.size >= 2 -> {
-                logHistory()
-                val previous = history[history.size - 2]
-                history.removeLast()
-
-                println("Requesting history item: $previous")
-                request(previous)
-                logHistory()
-            }
-        }
-    }
-
-    private fun logHistory(){
-        history.forEach { uri ->
-            println("History: $uri")
-        }
-    }
 }