DEV Community

vmodal_ai
vmodal_ai

Posted on Originally published at v-modal.com

Developing a Robot Robot OTA Firmware Update SDK for Android

#android #kotlin #robotics #ota

Developing a Robot OTA Firmware Update SDK for Android

Deploying Over-The-Air (OTA) firmware updates to deployed field robots carries significant operational risks. Interrupted flashing, corrupted binary transfers, or power loss mid-update can brick hardware embedded microcontrollers. An Android OTA Firmware SDK must provide chunked binary streaming, cryptographic SHA-256 checksum validation, progress telemetry, and A/B dual-bank rollback safety checks.

This tutorial demonstrates how to build a production-grade OTA Update Engine in Kotlin.

1. OTA Update Workflow Architecture 

+-------------------------------------------------------------+
|                     Android OTA SDK Engine                  |
+-------------------------------------------------------------+
                               |
 1. Download & Verify SHA-256  | 2. Initiate Transfer Handshake
                               v
+-------------------------------------------------------------+
|                     Robot Embedded Gateway                  |
|               (Bank A Active / Flashing to Bank B)          |
+-------------------------------------------------------------+
                               |
 3. Chunked Binary Transfer    | 4. Verify & Swap Partition
                               v
+-------------------------------------------------------------+
|                Bootloader Swap & Verification               |
+-------------------------------------------------------------+
Enter fullscreen mode Exit fullscreen mode

2. Defining OTA Models and Update States 

package com.vmodal.sdk.ota.model

import java.io.File

data class FirmwareManifest(
    val version: String,
    val targetHardwareModel: String,
    val fileSizeBytes: Long,
    val sha256Checksum: String
)

sealed class OtaProgressState {
    object Idle : OtaProgressState()
    object VerifyingChecksum : OtaProgressState()
    data class Transferring(val bytesSent: Long, val totalBytes: Long, val percentage: Float) : OtaProgressState()
    object FlashingTargetBank : OtaProgressState()
    object VerifyingBoot : OtaProgressState()
    object CompletedSuccessfully : OtaProgressState()
    data class Failed(val reason: String) : OtaProgressState()
}
Enter fullscreen mode Exit fullscreen mode

3. Implementing Cryptographic SHA-256 Verification 

package com.vmodal.sdk.ota.security

import java.io.File
import java.io.FileInputStream
import java.security.MessageDigest

class FirmwareIntegrityVerifier {

    fun verifySha256(file: File, expectedHashHex: String): Boolean {
        val digest = MessageDigest.getInstance("SHA-256")
        val inputStream = FileInputStream(file)
        val buffer = ByteArray(8192)
        var bytesRead: Int

        while (inputStream.read(buffer).also { bytesRead = it } != -1) {
            digest.update(buffer, 0, bytesRead)
        }
        inputStream.close()

        val computedHashHex = digest.digest().joinToString("") { "%02x".format(it) }
        return computedHashHex.equals(expectedHashHex, ignoreCase = true)
    }
}
Enter fullscreen mode Exit fullscreen mode

4. Building the Core OTA Flashing Engine 

package com.vmodal.sdk.ota

import com.vmodal.sdk.ota.model.FirmwareManifest
import com.vmodal.sdk.ota.model.OtaProgressState
import com.vmodal.sdk.ota.security.FirmwareIntegrityVerifier
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.withContext
import java.io.File
import java.io.FileInputStream

class OtaUpdateManager {

    private val _progressState = MutableStateFlow<OtaProgressState>(OtaProgressState.Idle)
    val progressState: StateFlow<OtaProgressState> = _progressState.asStateFlow()

    private val verifier = FirmwareIntegrityVerifier()

    suspend fun executeOtaUpdate(firmwareFile: File, manifest: FirmwareManifest): Boolean {
        return withContext(Dispatchers.IO) {
            // Step 1: Checksum Verification
            _progressState.value = OtaProgressState.VerifyingChecksum
            if (!verifier.verifySha256(firmwareFile, manifest.sha256Checksum)) {
                _progressState.value = OtaProgressState.Failed("SHA-256 Checksum Mismatch! Binary corrupted.")
                return@withContext false
            }

            // Step 2: Stream Chunked Binary to Hardware
            val chunkSize = 4096
            val totalBytes = firmwareFile.length()
            var bytesSent = 0L

            val inputStream = FileInputStream(firmwareFile)
            val buffer = ByteArray(chunkSize)
            var read: Int

            while (inputStream.read(buffer).also { read = it } != -1) {
                bytesSent += read
                val pct = (bytesSent.toFloat() / totalBytes.toFloat()) * 100f
                _progressState.value = OtaProgressState.Transferring(bytesSent, totalBytes, pct)

                // Simulate low-level CAN / Serial transport packet frame transmission delay
                delay(10)
            }
            inputStream.close()

            // Step 3: Flash Bank Execution
            _progressState.value = OtaProgressState.FlashingTargetBank
            delay(1000)

            // Step 4: Boot Verification
            _progressState.value = OtaProgressState.VerifyingBoot
            delay(1000)

            _progressState.value = OtaProgressState.CompletedSuccessfully
            true
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

5. End-to-End OTA Test Script 

import com.vmodal.sdk.ota.OtaUpdateManager
import com.vmodal.sdk.ota.model.FirmwareManifest
import com.vmodal.sdk.ota.model.OtaProgressState
import kotlinx.coroutines.runBlocking
import java.io.File

fun main() = runBlocking {
    val otaManager = OtaUpdateManager()

    // Create dummy firmware binary file
    val dummyFile = File.createTempFile("firmware_v2", ".bin").apply {
        writeBytes(ByteArray(1024 * 50)) // 50 KB dummy payload
    }

    // Compute simple expected hash for testing
    val manifest = FirmwareManifest(
        version = "2.1.0",
        targetHardwareModel = "VModal-Rover-X1",
        fileSizeBytes = dummyFile.length(),
        sha256Checksum = "0000000000000000000000000000000000000000000000000000000000000000" // Intentional failure demonstration
    )

    println("Starting OTA Update Process...")
    val success = otaManager.executeOtaUpdate(dummyFile, manifest)

    println("OTA Final State: ${otaManager.progressState.value}")
    dummyFile.delete()
}
Enter fullscreen mode Exit fullscreen mode

Conclusion

By enforcing pre-flash SHA-256 integrity verification, chunked binary streaming, and state-machine boot checks, your Android OTA SDK provides a secure, fail-safe firmware upgrade mechanism for embedded robotics hardware.

Useful Links

Top comments (0)