feat(keycard): Add support for keycard channel events

The keycard channel events will inform the app of the channel state (waiting for keycard, reading, error, idle). This will be used on mobile platforms to control a drawer that informs the user when it's required to tap the keycard.

Author: alexjba

src/app/boot/app_controller.nim

@@ -40,6 +40,7 @@ import app_service/service/market/service as market_service
 import app/modules/onboarding/module as onboarding_module
 import app/modules/onboarding/post_onboarding/[keycard_replacement_task, keycard_convert_account, save_biometrics_task]
 import app/modules/main/module as main_module
+import app/modules/keycard_channel/module as keycard_channel_module
 import app/core/notifications/notifications_manager
 import app/global/global_singleton
 import app/global/app_signals
@@ -105,6 +106,7 @@ type
     # Modules
     onboardingModule: onboarding_module.AccessInterface
     mainModule: main_module.AccessInterface
+    keycardChannelModule: keycard_channel_module.AccessInterface
 
 #################################################
 # Forward declaration section
@@ -233,6 +235,7 @@ proc newAppController*(statusFoundation: StatusFoundation): AppController =
   result.marketService = market_service.newService(statusFoundation.events, result.settingsService)
 
   # Modules
+  result.keycardChannelModule = keycard_channel_module.newModule(statusFoundation.events)
   result.onboardingModule = onboarding_module.newModule[AppController](
     result,
     statusFoundation.events,
@@ -299,6 +302,9 @@ proc delete*(self: AppController) =
     self.onboardingModule.delete
     self.onboardingModule = nil
   self.mainModule.delete
+  if not self.keycardChannelModule.isNil:
+    self.keycardChannelModule.delete
+    self.keycardChannelModule = nil
 
   self.appSettingsVariant.delete
   self.localAppSettingsVariant.delete
@@ -346,6 +352,9 @@ proc initializeQmlContext(self: AppController) =
   singletonInstance.engine.setRootContextProperty("globalUtils", self.globalUtilsVariant)
   singletonInstance.engine.setRootContextProperty("metrics", self.metricsVariant)
 
+  # Load keycard channel module (available before login for Session API)
+  self.keycardChannelModule.load()
+
   singletonInstance.engine.load(newQUrl("qrc:///main.qml"))
 
 proc onboardingDidLoad*(self: AppController) =

src/app/modules/keycard_channel/constants.nim

@@ -0,0 +1,9 @@
+## Constants for keycard channel operational states
+## These values must match the strings emitted by status-keycard-qt
+
+const KEYCARD_CHANNEL_STATE_IDLE* = "idle"
+const KEYCARD_CHANNEL_STATE_WAITING_FOR_KEYCARD* = "waiting-for-keycard"
+const KEYCARD_CHANNEL_STATE_READING* = "reading"
+const KEYCARD_CHANNEL_STATE_ERROR* = "error"
+
+

src/app/modules/keycard_channel/controller.nim

@@ -0,0 +1,27 @@
+import ./io_interface
+import app/core/eventemitter
+import app_service/service/keycardV2/service as keycard_serviceV2
+
+type
+  Controller* = ref object of RootObj
+    delegate: io_interface.AccessInterface
+    events: EventEmitter
+
+proc newController*(
+  delegate: io_interface.AccessInterface,
+  events: EventEmitter
+): Controller =
+  result = Controller()
+  result.delegate = delegate
+  result.events = events
+
+proc delete*(self: Controller) =
+  discard
+
+proc init*(self: Controller) =
+  # Listen to channel state changes
+  self.events.on(keycard_serviceV2.SIGNAL_KEYCARD_CHANNEL_STATE_UPDATED) do(e: Args):
+    let args = keycard_serviceV2.KeycardChannelStateArg(e)
+    self.delegate.setKeycardChannelState(args.state)
+
+

src/app/modules/keycard_channel/io_interface.nim

@@ -0,0 +1,23 @@
+type
+  AccessInterface* {.pure inheritable.} = ref object of RootObj
+  ## Abstract class for any input/interaction with this module.
+
+method delete*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method load*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method isLoaded*(self: AccessInterface): bool {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+# View Delegate Interface
+# Delegate for the view must be declared here due to use of QtObject and multi
+# inheritance, which is not well supported in Nim.
+method viewDidLoad*(self: AccessInterface) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+method setKeycardChannelState*(self: AccessInterface, state: string) {.base.} =
+  raise newException(ValueError, "No implementation available")
+
+

src/app/modules/keycard_channel/module.nim

@@ -0,0 +1,49 @@
+import nimqml
+
+import io_interface, view, controller
+import app/global/global_singleton
+import app/core/eventemitter
+import ./constants
+
+export io_interface
+export constants
+
+type
+  Module* = ref object of io_interface.AccessInterface
+    view: View
+    viewVariant: QVariant
+    controller: Controller
+    moduleLoaded: bool
+
+proc newModule*(
+  events: EventEmitter,
+): Module =
+  result = Module()
+  result.view = view.newView(result)
+  result.viewVariant = newQVariant(result.view)
+  result.controller = controller.newController(result, events)
+  result.moduleLoaded = false
+
+  singletonInstance.engine.setRootContextProperty("keycardChannelModule", result.viewVariant)
+
+method delete*(self: Module) =
+  self.view.delete
+  self.viewVariant.delete
+  self.controller.delete
+
+method load*(self: Module) =
+  self.controller.init()
+  self.view.load()
+
+method isLoaded*(self: Module): bool =
+  return self.moduleLoaded
+
+proc checkIfModuleDidLoad(self: Module) =
+  self.moduleLoaded = true
+
+method viewDidLoad*(self: Module) =
+  self.checkIfModuleDidLoad()
+
+method setKeycardChannelState*(self: Module, state: string) =
+  self.view.setKeycardChannelState(state)
+

src/app/modules/keycard_channel/view.nim

@@ -0,0 +1,62 @@
+import nimqml
+
+import ./io_interface
+import ./constants
+
+QtObject:
+  type
+    View* = ref object of QObject
+      delegate: io_interface.AccessInterface
+      keycardChannelState: string # Operational channel state
+
+  proc setup(self: View)
+  proc delete*(self: View)
+  proc newView*(delegate: io_interface.AccessInterface): View =
+    new(result, delete)
+    result.delegate = delegate
+    result.keycardChannelState = KEYCARD_CHANNEL_STATE_IDLE
+    result.setup()
+
+  proc load*(self: View) =
+    self.delegate.viewDidLoad()
+
+  proc keycardChannelStateChanged*(self: View) {.signal.}
+  proc setKeycardChannelState*(self: View, value: string) =
+    if self.keycardChannelState == value:
+      return
+    self.keycardChannelState = value
+    self.keycardChannelStateChanged()
+  proc getKeycardChannelState*(self: View): string {.slot.} =
+    return self.keycardChannelState
+  QtProperty[string] keycardChannelState:
+    read = getKeycardChannelState
+    write = setKeycardChannelState
+    notify = keycardChannelStateChanged
+
+  # Constants for channel states (readonly properties for QML)
+  proc getStateIdle*(self: View): string {.slot.} =
+    return KEYCARD_CHANNEL_STATE_IDLE
+  QtProperty[string] stateIdle:
+    read = getStateIdle
+
+  proc getStateWaitingForKeycard*(self: View): string {.slot.} =
+    return KEYCARD_CHANNEL_STATE_WAITING_FOR_KEYCARD
+  QtProperty[string] stateWaitingForKeycard:
+    read = getStateWaitingForKeycard
+
+  proc getStateReading*(self: View): string {.slot.} =
+    return KEYCARD_CHANNEL_STATE_READING
+  QtProperty[string] stateReading:
+    read = getStateReading
+
+  proc getStateError*(self: View): string {.slot.} =
+    return KEYCARD_CHANNEL_STATE_ERROR
+  QtProperty[string] stateError:
+    read = getStateError
+
+  proc setup(self: View) =
+    self.QObject.setup
+
+  proc delete*(self: View) =
+    self.QObject.delete
+

src/app_service/service/keycard/service.nim

@@ -125,6 +125,9 @@ QtObject:
       return
 
     let flowType = typeObj.getStr
+    if flowType == "channel-state-changed":
+        return #nothing related to flows here
+
     let flowEvent = toKeycardEvent(eventObj)
     self.lastReceivedKeycardData = (flowType: flowType, flowEvent: flowEvent)
     self.events.emit(SIGNAL_KEYCARD_RESPONSE, KeycardLibArgs(flowType: flowType, flowEvent: flowEvent))

src/app_service/service/keycardV2/service.nim

@@ -21,6 +21,7 @@ const PUKLengthForStatusApp* = 12
 const KeycardLibCallsInterval = 500 # 0.5 seconds
 
 const SIGNAL_KEYCARD_STATE_UPDATED* = "keycardStateUpdated"
+const SIGNAL_KEYCARD_CHANNEL_STATE_UPDATED* = "keycardChannelStateUpdated"
 const SIGNAL_KEYCARD_SET_PIN_FAILURE* = "keycardSetPinFailure"
 const SIGNAL_KEYCARD_AUTHORIZE_FINISHED* = "keycardAuthorizeFinished"
 const SIGNAL_KEYCARD_LOAD_MNEMONIC_FAILURE* = "keycardLoadMnemonicFailure"
@@ -60,6 +61,9 @@ type
   KeycardExportedKeysArg* = ref object of Args
     exportedKeys*: KeycardExportedKeysDto
 
+  KeycardChannelStateArg* = ref object of Args
+    state*: string
+
 include utils
 include app_service/common/async_tasks
 include async_tasks
@@ -100,7 +104,6 @@ QtObject:
     if status_const.IS_MACOS and status_const.IS_INTEL:
       sleep 700
     self.initializeRPC()
-    self.asyncStart(status_const.KEYCARDPAIRINGDATAFILE)
     discard
 
   proc initializeRPC(self: Service) {.slot, featureGuard(KEYCARD_ENABLED).} =
@@ -110,10 +113,15 @@ QtObject:
     try:
       # Since only one service can register to signals, we pass the signal to the old service too
       var jsonSignal = signal.parseJson
-      if jsonSignal["type"].getStr == "status-changed":
+      let signalType = jsonSignal["type"].getStr
+      
+      if signalType == "status-changed":
         let keycardEvent = jsonSignal["event"].toKeycardEventDto()
-
         self.events.emit(SIGNAL_KEYCARD_STATE_UPDATED, KeycardEventArg(keycardEvent: keycardEvent))
+      elif signalType == "channel-state-changed":
+        let state = jsonSignal["event"]["state"].getStr
+        debug "keycardV2 service: emitting channel state update", state=state, signal=SIGNAL_KEYCARD_CHANNEL_STATE_UPDATED
+        self.events.emit(SIGNAL_KEYCARD_CHANNEL_STATE_UPDATED, KeycardChannelStateArg(state: state))
     except Exception as e:
       error "error receiving a keycard signal", err=e.msg, data = signal