Save/Restore state works

android/app/src/main/kotlin/com/felipecsl/knes/app/MainActivity.kt

@@ -2,7 +2,6 @@ package com.felipecsl.knes.app
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.content.SharedPreferences
 import android.os.Bundle
 import android.os.Handler
 import android.os.HandlerThread
@@ -18,7 +17,6 @@ import androidx.core.content.ContextCompat
 import com.felipecsl.android.NesGLSurfaceView
 import com.felipecsl.knes.*
 import com.google.android.material.floatingactionbutton.FloatingActionButton
-import com.google.android.material.snackbar.BaseTransientBottomBar
 import com.google.android.material.snackbar.Snackbar
 
 class MainActivity : AppCompatActivity(), Runnable {
@@ -39,6 +37,8 @@ class MainActivity : AppCompatActivity(), Runnable {
   private var handler: Handler
   private var isRunning = false
   private var isPaused = false
+  @Volatile private var shouldSaveState = false
+  @Volatile private var shouldRestoreState = false
   private val audioEngine = AudioEngineWrapper()
   private lateinit var director: Director
   private val buttons = BooleanArray(8)
@@ -122,12 +122,10 @@ class MainActivity : AppCompatActivity(), Runnable {
   private fun startConsole(cartridgeData: ByteArray, glSprite: GLSprite) {
     audioEngine.start()
     if (implSwitch.isChecked) {
-      Snackbar.make(implSwitch, "Using Kotlin/Native implementation",
-          BaseTransientBottomBar.LENGTH_SHORT).show()
+      Snackbar.make(implSwitch, "Using Kotlin/Native implementation", Snackbar.LENGTH_SHORT).show()
       nativeStartConsole(cartridgeData)
     } else {
-      Snackbar.make(implSwitch, "Using JVM implementation",
-          BaseTransientBottomBar.LENGTH_SHORT).show()
+      Snackbar.make(implSwitch, "Using JVM implementation", Snackbar.LENGTH_SHORT).show()
       director = Director(cartridgeData)
       glSprite.director = director
       staticConsole = director.console
@@ -136,6 +134,8 @@ class MainActivity : AppCompatActivity(), Runnable {
   }
 
   override fun run() {
+    maybeSaveState()
+    maybeRestoreState()
     director.run()
   }
 
@@ -149,32 +149,46 @@ class MainActivity : AppCompatActivity(), Runnable {
     // automatically handle clicks on the Home/Up button, so long
     // as you specify a parent activity in AndroidManifest.xml.
     return when (item!!.itemId) {
-      R.id.action_save_state -> saveState()
-      R.id.action_restore_state -> restoreState()
+      R.id.action_save_state -> {
+        director.pause()
+        shouldSaveState = true
+        handler.post(this)
+        return true
+      }
+      R.id.action_restore_state -> {
+        director.pause()
+        shouldRestoreState = true
+        handler.post(this)
+        return true
+      }
       else -> super.onOptionsItemSelected(item)
     }
   }
 
-  private fun saveState(): Boolean {
-    val stateMap = director.dumpState()
-    val sharedPrefs = getSharedPreferences(STATE_PREFS_KEY, Context.MODE_PRIVATE)
-    sharedPrefs.edit().also { p ->
-      stateMap.forEach { (k, v) ->
-        p.putString(k, v)
-      }
-    }.apply()
-    Snackbar.make(implSwitch, "Game state saved", BaseTransientBottomBar.LENGTH_SHORT).show()
-    return true
+  private fun maybeSaveState() {
+    if (shouldSaveState) {
+      val stateMap = director.dumpState()
+      val sharedPrefs = getSharedPreferences(STATE_PREFS_KEY, Context.MODE_PRIVATE)
+      sharedPrefs.edit().also { p ->
+        stateMap.forEach { (k, v) ->
+          p.putString(k, v)
+        }
+      }.apply()
+      Snackbar.make(implSwitch, "Game state saved", Snackbar.LENGTH_SHORT).show()
+      shouldSaveState = false
+    }
   }
 
-  private fun restoreState(): Boolean {
-    val sharedPrefs = getSharedPreferences(STATE_PREFS_KEY, Context.MODE_PRIVATE)
-    val state = sharedPrefs.all
-    if (state.isNotEmpty()) {
-      director.restoreState(state)
-      Snackbar.make(implSwitch, "Game state restored", BaseTransientBottomBar.LENGTH_SHORT).show()
+  private fun maybeRestoreState() {
+    if (shouldRestoreState) {
+      val sharedPrefs = getSharedPreferences(STATE_PREFS_KEY, Context.MODE_PRIVATE)
+      val state = sharedPrefs.all
+      if (state.isNotEmpty()) {
+        director.restoreState(state)
+        Snackbar.make(implSwitch, "Game state restored", Snackbar.LENGTH_SHORT).show()
+      }
+      shouldRestoreState = false
     }
-    return true
   }
 
   companion object {

common/src/main/kotlin/com/felipecsl/knes/APU.kt

@@ -314,7 +314,9 @@ internal class APU(
         noiseEnvelopeStart, noiseEnvelopePeriod, noiseEnvelopeValue, noiseEnvelopeVolume,
         noiseConstantVolume, dmcEnabled, dmcValue, dmcSampleAddress, dmcSampleLength,
         dmcCurrentAddress, dmcCurrentLength, dmcShiftRegister, dmcBitCount, dmcTickPeriod,
-        dmcTickValue, dmcLoop, dmcIrq).joinToString("\n")
+        dmcTickValue, dmcLoop, dmcIrq).joinToString("\n").also {
+      println("APU state saved")
+    }
   }
 
   fun restoreState(state: String) {
@@ -401,6 +403,7 @@ internal class APU(
     dmcTickValue = parts[i++].toInt()
     dmcLoop = parts[i++].toBoolean()
     dmcIrq = parts[i].toBoolean()
+    println("APU state restored")
   }
 
   fun writeRegister(address: Int, value: Int /* Byte */) {

common/src/main/kotlin/com/felipecsl/knes/CPU.kt

@@ -8,7 +8,7 @@ internal class CPU(
     private val apu: APU,
     val controller1: Controller,
     private val controller2: Controller,
-    private val ram: IntArray = IntArray(2048),
+    private var ram: IntArray = IntArray(2048),
     private val stepCallback: CPUStepCallback? = null
 ) {
   private var stepAddress: Int = 0
@@ -572,13 +572,16 @@ internal class CPU(
   }
 
   fun dumpState(): String {
-    return listOf(cycles, PC, SP, A, X, Y, C, Z, I, D, B, U, V, N, interrupt, stall)
-        .joinToString()
+    return listOf(ram.joinToString(), cycles, PC, SP, A, X, Y, C, Z, I, D, B, U, V, N, interrupt,
+        stall).joinToString("\n").also {
+      println("CPU state saved")
+    }
   }
 
   fun restoreState(state: String) {
-    val parts = state.split(", ")
+    val parts = state.split("\n")
     var i = 0
+    ram = parts[i++].toIntArray()
     cycles = parts[i++].toLong()
     PC = parts[i++].toInt()
     SP = parts[i++].toInt()
@@ -595,6 +598,7 @@ internal class CPU(
     N = parts[i++].toInt()
     interrupt = parts[i++].toInt()
     stall = parts[i].toInt()
+    println("CPU state restored")
   }
 
   private inline fun pagesDiffer(a: Int, b: Int) =

common/src/main/kotlin/com/felipecsl/knes/Console.kt

@@ -39,17 +39,20 @@ internal class Console(
     val cpuState = cpu.dumpState()
     val ppuState = ppu.dumpState()
     val apuState = apu.dumpState()
+    val mapperState = mapper.dumpState()
     return mapOf(
         "cpu" to cpuState,
         "ppu" to ppuState,
-        "apu" to apuState
+        "apu" to apuState,
+        "mapper" to mapperState
     )
   }
 
   fun restoreState(state: Map<String, *>) {
     cpu.restoreState(state["cpu"] as String)
     ppu.restoreState(state["ppu"] as String)
     apu.restoreState(state["apu"] as String)
+    mapper.restoreState(state["mapper"] as String)
   }
 
   companion object {

common/src/main/kotlin/com/felipecsl/knes/Director.kt

@@ -25,17 +25,22 @@ class Director(
     while (isRunning) {
       totalCycles += console.step()
       if (totalCycles >= FREQUENCY) {
-        val currentTime = currentTimeMs()
-        val msSpent = currentTime - startTime
-        val clock = (totalCycles * 1000) / msSpent
-        val speed = clock / FREQUENCY.toFloat()
-        println("Clock=${clock}Hz (${speed}x)")
+        val currentTime = trackConsoleSpeed(startTime, totalCycles)
         totalCycles = 0
         startTime = currentTime
       }
     }
   }
 
+  private fun trackConsoleSpeed(startTime: Long, totalCycles: Long): Long {
+    val currentTime = currentTimeMs()
+    val msSpent = currentTime - startTime
+    val clock = (totalCycles * 1000) / msSpent
+    val speed = clock / FREQUENCY.toFloat()
+    println("Clock=${clock}Hz (${speed}x)")
+    return currentTime
+  }
+
   fun setButtons1(buttons: BooleanArray) {
     console.setButtons(buttons)
   }

common/src/main/kotlin/com/felipecsl/knes/MMC1.kt

@@ -97,6 +97,14 @@ internal class MMC1(
     }
   }
 
+  override fun restoreState(state: String) {
+    TODO("not implemented")
+  }
+
+  override fun dumpState(): String {
+    TODO("not implemented")
+  }
+
   private fun writeControl(value: Int) {
     control = value
     chrMode = (value shr 4) and 1 and 0xFF

common/src/main/kotlin/com/felipecsl/knes/MMC3.kt

@@ -49,6 +49,37 @@ internal class MMC3(
     }
   }
 
+  override fun restoreState(state: String) {
+    val parts = state.split("\n")
+    var i = 0
+    register = parts[i++].toInt()
+    registers = parts[i++].toIntArray()
+    prgMode = parts[i++].toInt()
+    chrMode = parts[i++].toInt()
+    prgOffsets = parts[i++].toIntArray()
+    chrOffsets = parts[i++].toIntArray()
+    reload = parts[i++].toInt()
+    counter = parts[i++].toInt()
+    irqEnable = parts[i].toBoolean()
+    println("MMC3 state restored")
+  }
+
+  override fun dumpState(): String {
+    return listOf(
+        register,
+        registers.joinToString(),
+        prgMode,
+        chrMode,
+        prgOffsets.joinToString(),
+        chrOffsets.joinToString(),
+        reload,
+        counter,
+        irqEnable
+    ).joinToString("\n").also {
+      println("MMC3 state saved")
+    }
+  }
+
   override fun write(address: Int, value: Int) {
     when {
       address < 0x2000 -> {

common/src/main/kotlin/com/felipecsl/knes/Mapper.kt

@@ -5,6 +5,8 @@ internal interface Mapper {
   fun read(address: Int): Int
   fun write(address: Int, value: Int)
   fun step()
+  fun restoreState(state: String)
+  fun dumpState(): String
 
   companion object {
     fun newMapper(cartridge: Cartridge, stepCallback: MapperStepCallback?): Mapper =

common/src/main/kotlin/com/felipecsl/knes/PPU.kt

@@ -195,19 +195,20 @@ internal class PPU(
         flagSpriteTable, flagBackgroundTable, flagSpriteSize, flagMasterSlave, flagGrayscale,
         flagShowLeftBackground, flagShowLeftSprites, flagShowBackground, flagShowSprites,
         flagRedTint, flagGreenTint, flagBlueTint, flagSpriteZeroHit, flagSpriteOverflow,
-        oamAddress, bufferedData).joinToString("\n")
+        oamAddress, bufferedData).joinToString("\n").also {
+      println("PPU state saved")
+    }
   }
 
   fun restoreState(state: String) {
     val parts = state.split("\n")
-    val stringToIntArray = { s: String -> s.split(", ").map { it.toInt() }.toIntArray() }
     var i = 0
     cycle = parts[i++].toInt()
     scanLine = parts[i++].toInt()
     frame = parts[i++].toInt()
-    paletteData = stringToIntArray(parts[i++])
-    nameTableData = stringToIntArray(parts[i++])
-    oamData = stringToIntArray(parts[i++])
+    paletteData = parts[i++].toIntArray()
+    nameTableData = parts[i++].toIntArray()
+    oamData = parts[i++].toIntArray()
     v = parts[i++].toInt()
     t = parts[i++].toInt()
     x = parts[i++].toInt()
@@ -224,10 +225,10 @@ internal class PPU(
     highTileByte = parts[i++].toInt()
     tileData = parts[i++].toLong()
     spriteCount = parts[i++].toInt()
-    spritePatterns = stringToIntArray(parts[i++])
-    spritePositions = stringToIntArray(parts[i++])
-    spritePriorities = stringToIntArray(parts[i++])
-    spriteIndexes = stringToIntArray(parts[i++])
+    spritePatterns = parts[i++].toIntArray()
+    spritePositions = parts[i++].toIntArray()
+    spritePriorities = parts[i++].toIntArray()
+    spriteIndexes = parts[i++].toIntArray()
     flagNameTable = parts[i++].toInt()
     flagIncrement = parts[i++].toInt()
     flagSpriteTable = parts[i++].toInt()
@@ -246,6 +247,7 @@ internal class PPU(
     flagSpriteOverflow = parts[i++].toInt()
     oamAddress = parts[i++].toInt()
     bufferedData = parts[i].toInt()
+    println("PPU state restored")
   }
 
   fun step(): Boolean {

common/src/main/kotlin/com/felipecsl/knes/Util.kt

@@ -12,4 +12,7 @@ fun Int.ensurePositive(): Int {
     throw RuntimeException("Value is not positive: $this")
   }
   return this
-}
+}
+
+fun String.toIntArray() =
+  split(", ").map(String::toInt).toIntArray()