Android Integration

class MainActivity : ComponentActivity() {
    private val emulator = EmulatorBridge()
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Initialize with application context
        EmulatorBridge.initialize(applicationContext)
        
        // Set preferred backend (optional)
        emulator.setBackend("rust") // or "cemu"
        
        // Create emulator instance
        if (!emulator.create()) {
            Log.e(TAG, "Failed to create emulator")
            return
        }
        
        // ... UI setup
    }
    
    override fun onDestroy() {
        super.onDestroy()
        emulator.destroy()
    }
}

// Load ROM from ByteArray
val romBytes: ByteArray = loadRomFromFile()
val result = emulator.loadRom(romBytes)

if (result == 0) {
    // ROM loaded successfully
    Log.i(TAG, "ROM loaded: ${romBytes.size} bytes")
    
    // Power on the calculator
    emulator.powerOn()
} else {
    Log.e(TAG, "Failed to load ROM: error $result")
}

val CYCLES_PER_FRAME = 800_000  // 48MHz / 60 FPS
val FRAME_INTERVAL_MS = 16L     // ~60 FPS

LaunchedEffect(isRunning) {
    if (isRunning) {
        while (isRunning) {
            val frameStart = System.nanoTime()
            
            // Run emulation
            val executed = withContext(Dispatchers.Default) {
                emulator.runCycles(CYCLES_PER_FRAME)
            }
            
            // Throttle to 60 FPS
            val elapsedMs = (System.nanoTime() - frameStart) / 1_000_000
            val remainingMs = FRAME_INTERVAL_MS - elapsedMs
            if (remainingMs > 0) {
                delay(remainingMs)
            }
        }
    }
}

// Create bitmap for framebuffer
val bitmap = Bitmap.createBitmap(
    emulator.getWidth(),   // 320
    emulator.getHeight(),  // 240
    Bitmap.Config.ARGB_8888
)

// Copy framebuffer to bitmap
emulator.copyFramebufferToBitmap(bitmap)

// Display in Compose
Image(
    bitmap = bitmap.asImageBitmap(),
    contentDescription = "Emulator screen",
    modifier = Modifier.fillMaxSize(),
    contentScale = ContentScale.Fit,
    filterQuality = FilterQuality.None  // Nearest-neighbor for pixels
)

// Press a key
emulator.setKey(row = 6, col = 0, down = true)  // ENTER key

// Release a key
emulator.setKey(row = 6, col = 0, down = false)

// Save state
val stateData: ByteArray? = emulator.saveState()
if (stateData != null) {
    // Write to file or database
    File(filesDir, "emulator.state").writeBytes(stateData)
    Log.i(TAG, "State saved: ${stateData.size} bytes")
}

// Load state
val stateData = File(filesDir, "emulator.state").readBytes()
val result = emulator.loadState(stateData)
if (result == 0) {
    Log.i(TAG, "State restored")
} else {
    Log.e(TAG, "Failed to load state: error $result")
}

// Load ROM first
emulator.loadRom(romBytes)

// Inject program files BEFORE powering on
val programBytes = File("DOOM.8xp").readBytes()
val count = emulator.sendFile(programBytes)

if (count >= 0) {
    Log.i(TAG, "Injected $count entries")
} else {
    Log.e(TAG, "Failed to inject file: error $count")
}

// Now power on - programs will appear in the PRGM menu
emulator.powerOn()

// Get available backends
val backends = EmulatorBridge.getAvailableBackends()  // ["rust", "cemu"]

// Check current backend
val current = emulator.getCurrentBackend()  // "rust"

// Switch backend (destroys current instance)
emulator.destroy()
emulator.setBackend("cemu")
emulator.create()
emulator.loadRom(romBytes)  // Reload ROM

private external fun nativeCreate(): Long
private external fun nativeDestroy(handle: Long)
private external fun nativeLoadRom(handle: Long, romBytes: ByteArray): Int
private external fun nativeRunCycles(handle: Long, cycles: Int): Int
private external fun nativeCopyFramebuffer(handle: Long, outArgb: IntArray): Int
private external fun nativeSetKey(handle: Long, row: Int, col: Int, down: Boolean)
private external fun nativeGetBacklight(handle: Long): Int
private external fun nativeIsLcdOn(handle: Long): Boolean
private external fun nativeSaveState(handle: Long, outData: ByteArray): Int
private external fun nativeLoadState(handle: Long, stateData: ByteArray): Int

cmake_minimum_required(VERSION 3.22.1)
project("emu_jni")

# Build Rust backend
add_library(emu_rust SHARED backend_wrapper.cpp)
target_link_libraries(emu_rust emu_core android log)

# JNI bridge
add_library(emu_jni SHARED jni_loader.cpp)
target_link_libraries(emu_jni android log)

// Real-time (1x speed)
val CYCLES_PER_FRAME = 800_000

// 2x speed (fast-forward)
val CYCLES_PER_FRAME = 1_600_000

// 0.5x speed (slow motion)
val CYCLES_PER_FRAME = 400_000

if (emulator.isLcdOn()) {
    emulator.copyFramebufferToBitmap(bitmap)
} else {
    // Show black screen (calculator is off or sleeping)
    canvas.drawColor(Color.BLACK)
}

override fun onPause() {
    super.onPause()
    isRunning = false
    
    // Save state
    val stateData = emulator.saveState()
    // ... persist to storage
}

override fun onResume() {
    super.onResume()
    // Load state
    // ...
    isRunning = true
}