core-testing/org.meshtastic.core.testing/FakeRadioInterfaceService

FakeRadioInterfaceService

class FakeRadioInterfaceService(val serviceScope: CoroutineScope = MainScope()) : RadioInterfaceService(source)

A test double for RadioInterfaceService that provides an in-memory implementation.

The connectionState here mirrors the transport-level semantics of the real implementation. In production, only MeshConnectionManager observes this flow; tests should verify that bridging behavior rather than consuming it directly from UI/feature test code (use FakeServiceRepository.connectionState instead). Address selection remains separate from transport admission: connect and an in-flight restartTransport publish a fresh monotonically increasing session generation.

Constructors

constructor(serviceScope: CoroutineScope = MainScope())

Properties

activeSession

open override val activeSession: StateFlow<RadioSessionContext?>

connectCalled

var connectCalled: Boolean

connectionError

open override val connectionError: Flow<String>

connectionState

open override val connectionState: StateFlow<ConnectionState>

currentDeviceAddressFlow

open override val currentDeviceAddressFlow: StateFlow<String?>

isReplayTransportAvailable

open override var isReplayTransportAvailable: Boolean

No capture asset in tests; flip per-test when exercising replay-gated behaviour.

meshActivity

open override val meshActivity: Flow<MeshActivity>

mockTransportEnabled

open override val mockTransportEnabled: MutableStateFlow<Boolean>

receivedData

open override val receivedData: Flow<ReceivedRadioFrame>

rejectAdmittedSends

var rejectAdmittedSends: Boolean

Set to true to simulate an admitted transport rejecting the byte handoff.

restartTransportCalled

var restartTransportCalled: Boolean

sentToRadio

val sentToRadio: List<ByteArray>

Thread-safe lifetime history of writes accepted across all admitted fake transport sessions.

serviceScope

open override val serviceScope: CoroutineScope

sessionGeneration

open override val sessionGeneration: StateFlow<Long>

sessionLeaseInvariantViolations

val sessionLeaseInvariantViolations: Int

supportedDeviceTypes

open override val supportedDeviceTypes: List<DeviceType>

Functions

connect

open override fun connect()

consumeGattCacheInvalidationRequest

open override fun consumeGattCacheInvalidationRequest(): Boolean

disconnect

open suspend override fun disconnect()

emitFromRadio

fun emitFromRadio(bytes: ByteArray, session: RadioSessionContext)

getDeviceAddress

open override fun getDeviceAddress(): String?

handleFromRadio

open override fun handleFromRadio(bytes: ByteArray)

isSessionActive

open override fun isSessionActive(session: RadioSessionContext): Boolean

onConnect

open override fun onConnect()

onDisconnect

open override fun onDisconnect(isPermanent: Boolean, errorMessage: String?, reason: TransportDisconnectReason?)

requestGattCacheInvalidationOnNextConnect

open override fun requestGattCacheInvalidationOnNextConnect()

resetReceivedBuffer

open override fun resetReceivedBuffer()

restartTransport

open suspend override fun restartTransport()

runIfSessionActive

open override fun runIfSessionActive(session: RadioSessionContext, block: () -> Unit): Boolean

runWhileSessionActive

open suspend override fun runWhileSessionActive(session: RadioSessionContext, block: suspend () -> Unit): Boolean

runWithSessionLease

open suspend override fun runWithSessionLease(session: RadioSessionContext, block: suspend (RadioSessionLease) -> Unit): Boolean

sendToRadio

open fun sendToRadio(bytes: ByteArray)

setConnectionState

fun setConnectionState(state: ConnectionState)

setDeviceAddress

open override fun setDeviceAddress(deviceAddr: String?): Boolean

toInterfaceAddress

open override fun toInterfaceAddress(interfaceId: InterfaceId, rest: String): String

trySendToRadio

open override fun trySendToRadio(bytes: ByteArray): Boolean

Records bytes only while a transport session is admitted. Tests must select a non-null device address and call connect before sending; attempts outside that lifecycle return false and leave sentToRadio unchanged.