fix(app): activate Neo after BLE connect

Author: AnkushMalaker

app/app.json

@@ -2,7 +2,7 @@
   "expo": {
     "name": "chronicle",
     "slug": "friend-lite-app",
-    "version": "1.13.0",
+    "version": "1.14.0",
     "scheme": "chronicle",
     "orientation": "portrait",
     "icon": "./assets/icon.png",

app/app/diagnostics.tsx

@@ -11,6 +11,7 @@ const EVENT_BADGE_TONES: Record<ConnectionEventType, Tone> = {
   scan_stop: 'neutral',
   scan_result: 'suggest',
   connect_start: 'warning',
+  device_active: 'success',
   connect_success: 'success',
   connect_fail: 'danger',
   disconnect: 'danger',

app/package.json

@@ -8,6 +8,7 @@
     "ios": "expo run:ios",
     "web": "expo start --web",
     "typecheck": "tsc --noEmit",
+    "test:wearable-activation": "node scripts/test-wearable-activation.cjs",
     "test:voice-protocol": "node scripts/test-voice-protocol.cjs",
     "test:phone-duplex": "node scripts/test-phone-duplex-controller.cjs",
     "check:theme": "node scripts/check-theme-tokens.mjs"

app/scripts/test-wearable-activation.cjs

@@ -0,0 +1,116 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const Module = require('node:module');
+const path = require('node:path');
+const ts = require('typescript');
+
+function loadTypeScript(sourcePath) {
+  const source = fs.readFileSync(sourcePath, 'utf8');
+  const compiled = ts.transpileModule(source, {
+    compilerOptions: {
+      esModuleInterop: true,
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2020,
+      strict: true,
+    },
+    fileName: sourcePath,
+  });
+  const loaded = new Module(sourcePath, module);
+  loaded.filename = sourcePath;
+  loaded.paths = Module._nodeModulePaths(path.dirname(sourcePath));
+  loaded._compile(compiled.outputText, sourcePath);
+  return loaded.exports;
+}
+
+const activationPath = path.join(__dirname, '../src/services/wearableActivation.ts');
+const {
+  NEO_ACTIVE_CONTROL_UUID,
+  NEO_ACTIVE_VALUE_BASE64,
+  WEARABLE_SERVICE_UUID,
+  activateWearableAfterConnect,
+} = loadTypeScript(activationPath);
+
+(async () => {
+  const writes = [];
+  const neoTransport = {
+    characteristicsForDevice: async (deviceId, serviceUuid) => {
+      assert.equal(deviceId, 'neo-1');
+      assert.equal(serviceUuid, WEARABLE_SERVICE_UUID);
+      return [{
+        uuid: NEO_ACTIVE_CONTROL_UUID.toUpperCase(),
+        isWritableWithResponse: true,
+      }];
+    },
+    writeCharacteristicWithResponseForDevice: async (...args) => {
+      writes.push(args);
+    },
+  };
+
+  assert.equal(
+    await activateWearableAfterConnect(neoTransport, 'neo-1'),
+    'neo_activated',
+  );
+  assert.deepEqual(writes, [[
+    'neo-1',
+    WEARABLE_SERVICE_UUID,
+    NEO_ACTIVE_CONTROL_UUID,
+    NEO_ACTIVE_VALUE_BASE64,
+  ]]);
+  assert.equal(NEO_ACTIVE_VALUE_BASE64, 'AQ==', 'Neo Active is the single byte 0x01');
+
+  let genericWriteCount = 0;
+  const genericTransport = {
+    characteristicsForDevice: async () => [{
+      uuid: '19b10001-e8f2-537e-4f6c-d104768a1214',
+      isWritableWithResponse: true,
+    }],
+    writeCharacteristicWithResponseForDevice: async () => {
+      genericWriteCount += 1;
+    },
+  };
+  assert.equal(
+    await activateWearableAfterConnect(genericTransport, 'omi-1'),
+    'not_required',
+  );
+  assert.equal(genericWriteCount, 0, 'ordinary OMI devices remain unchanged');
+
+  const invalidNeoTransport = {
+    characteristicsForDevice: async () => [{
+      uuid: NEO_ACTIVE_CONTROL_UUID,
+      isWritableWithResponse: false,
+    }],
+    writeCharacteristicWithResponseForDevice: async () => {
+      throw new Error('must not attempt an unsupported write');
+    },
+  };
+  await assert.rejects(
+    activateWearableAfterConnect(invalidNeoTransport, 'neo-bad'),
+    /does not support writes with response/,
+  );
+
+  let releaseWrite;
+  const delayedWrite = new Promise((resolve) => {
+    releaseWrite = resolve;
+  });
+  const delayedTransport = {
+    characteristicsForDevice: async () => [{
+      uuid: NEO_ACTIVE_CONTROL_UUID,
+      isWritableWithResponse: true,
+    }],
+    writeCharacteristicWithResponseForDevice: async () => delayedWrite,
+  };
+  let activationFinished = false;
+  const activation = activateWearableAfterConnect(delayedTransport, 'neo-slow')
+    .then(() => { activationFinished = true; });
+  await Promise.resolve();
+  await Promise.resolve();
+  assert.equal(activationFinished, false, 'connection readiness must wait for the Active write');
+  releaseWrite();
+  await activation;
+  assert.equal(activationFinished, true);
+
+  console.log('wearable activation contract tests passed');
+})().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

app/src/contexts/ConnectionLogContext.tsx

@@ -16,6 +16,7 @@ export type ConnectionEventType =
   | 'scan_stop'
   | 'scan_result'
   | 'connect_start'
+  | 'device_active'
   | 'connect_success'
   | 'connect_fail'
   | 'disconnect'

app/src/hooks/useDeviceConnection.ts

@@ -3,6 +3,7 @@ import { Alert } from 'react-native';
 import { OmiConnection, BleAudioCodec, OmiDevice } from 'friend-lite-react-native';
 import { BleError, BleManager, Subscription } from 'react-native-ble-plx';
 import { useConnectionLog } from '../contexts/ConnectionLogContext';
+import { activateWearableAfterConnect } from '../services/wearableActivation';
 
 interface UseDeviceConnection {
   connectedDevice: OmiDevice | null;
@@ -91,7 +92,7 @@ export const useDeviceConnection = (
           if (onDisconnect) onDisconnect();
         }, 500);
     }
-  }, [onDisconnect, onConnect]);
+  }, [addEvent, onDisconnect, onConnect]);
 
   const connectToDevice = useCallback(async (deviceId: string) => {
     // Connect debounce: ignore rapid double-taps within 100ms
@@ -130,9 +131,33 @@ export const useDeviceConnection = (
       },
     );
 
+    let connectionReady = false;
+    let connectionDroppedBeforeReady = false;
+    let connectedStateDeviceId: string | null = null;
+    let reportedConnected = false;
+    const reportConnectionStateWhenReady = (id: string, state: string) => {
+      if (state === 'connected') {
+        connectedStateDeviceId = id;
+        if (!connectionReady || reportedConnected) return;
+        reportedConnected = true;
+      } else if (!connectionReady) {
+        connectionDroppedBeforeReady = true;
+      }
+      handleConnectionStateChange(id, state);
+    };
+
     try {
-      const success = await omiConnection.connect(deviceId, handleConnectionStateChange);
+      const success = await omiConnection.connect(deviceId, reportConnectionStateWhenReady);
       if (success) {
+        const activation = await activateWearableAfterConnect(diagnosticBleManager, deviceId);
+        if (activation === 'neo_activated') {
+          addEvent('device_active', 'Neo Active mode enabled', { deviceId });
+        }
+        connectionReady = true;
+        if (connectionDroppedBeforeReady) {
+          throw new Error('Device disconnected before the Active handshake completed');
+        }
+        reportConnectionStateWhenReady(connectedStateDeviceId ?? deviceId, 'connected');
         console.log('Successfully initiated connection to device:', deviceId);
       } else {
         setIsConnecting(false);
@@ -143,6 +168,12 @@ export const useDeviceConnection = (
       }
     } catch (error) {
       console.error('Connection error:', error);
+      intentionalDisconnectRef.current = true;
+      try {
+        await omiConnection.disconnect();
+      } catch (disconnectError) {
+        console.warn('Cleanup after connection error failed:', disconnectError);
+      }
       setIsConnecting(false);
       setConnectedDevice(null);
       setConnectedDeviceId(null);

app/src/services/wearableActivation.ts

@@ -0,0 +1,51 @@
+export const WEARABLE_SERVICE_UUID = '19b10000-e8f2-537e-4f6c-d104768a1214';
+export const NEO_ACTIVE_CONTROL_UUID = '19b10003-e8f2-537e-4f6c-d104768a1214';
+export const NEO_ACTIVE_VALUE_BASE64 = 'AQ==';
+
+interface WearableCharacteristic {
+  uuid: string;
+  isWritableWithResponse: boolean;
+}
+
+export interface WearableControlTransport {
+  characteristicsForDevice(
+    deviceId: string,
+    serviceUuid: string,
+  ): Promise<WearableCharacteristic[]>;
+  writeCharacteristicWithResponseForDevice(
+    deviceId: string,
+    serviceUuid: string,
+    characteristicUuid: string,
+    valueBase64: string,
+  ): Promise<unknown>;
+}
+
+export type WearableActivationResult = 'neo_activated' | 'not_required';
+
+export async function activateWearableAfterConnect(
+  transport: WearableControlTransport,
+  deviceId: string,
+): Promise<WearableActivationResult> {
+  const characteristics = await transport.characteristicsForDevice(
+    deviceId,
+    WEARABLE_SERVICE_UUID,
+  );
+  const neoControl = characteristics.find(
+    (characteristic) => characteristic.uuid.toLowerCase() === NEO_ACTIVE_CONTROL_UUID,
+  );
+
+  if (!neoControl) {
+    return 'not_required';
+  }
+  if (!neoControl.isWritableWithResponse) {
+    throw new Error('Neo Active control does not support writes with response');
+  }
+
+  await transport.writeCharacteristicWithResponseForDevice(
+    deviceId,
+    WEARABLE_SERVICE_UUID,
+    NEO_ACTIVE_CONTROL_UUID,
+    NEO_ACTIVE_VALUE_BASE64,
+  );
+  return 'neo_activated';
+}