Aller au contenu principal
Version: Next

API Publique

Référence complète des méthodes du SDK orientées partenaire. Les méthodes dépréciées et de compatibilité sont intentionnellement omises — consultez la documentation interne complète pour ces surfaces.

Bootstrap​

EixamConnectSdk.bootstrap(...)​

Crée le SDK, résout l'environnement sélectionné, valide la config et applique la session signée initiale lorsqu'elle est fournie.

Retourne : Future<EixamConnectSdk>

Entrées clés : appId, environment, initialSession

info

Le backend partenaire possède le secret de l'app et signe la session. L'app mobile reçoit appId, externalUserId et userHash. La même identité est réutilisée sur HTTP et MQTT.

final sdk = await EixamConnectSdk.bootstrap(
  const EixamBootstrapConfig(
    appId: 'partner-app',
    environment: EixamEnvironment.sandbox,
    initialSession: EixamSession.signed(
      appId: 'partner-app',
      externalUserId: 'partner-user-123',
      userHash: 'signed-session-hash',
    ),
  ),
);

final session = await sdk.getCurrentSession();
debugPrint('session user=${session?.externalUserId}');

Diagnostics​

getOperationalDiagnostics()​

Retourne le dernier snapshot opérationnel du runtime pour l'état de session, transport, bridge et réhydratation SOS.

Retourne : SdkOperationalDiagnostics

final diagnostics = await sdk.getOperationalDiagnostics();
debugPrint('mqtt=${diagnostics.connectionState.name}');
debugPrint('telTopic=${diagnostics.telemetryPublishTopic}');
debugPrint('lastDecision=${diagnostics.bridge.lastDecision}');
debugPrint('pendingSos=${diagnostics.bridge.pendingSos != null}');

watchOperationalDiagnostics()​

Émet les changements opérationnels après le bootstrap, les mises à jour de session, les reconnexions et les changements de bridge/runtime.

Retourne : Stream<SdkOperationalDiagnostics>

final sub = sdk.watchOperationalDiagnostics().listen((diagnostics) {
  debugPrint('mqtt=${diagnostics.connectionState.name}');
  debugPrint('bridge=${diagnostics.bridge.lastDecision}');
});

Cycle de vie du dispositif​

connectDevice(...)​

Appaire ou reconnecte le dispositif sélectionné par le partenaire et retourne le statut runtime résultant.

Retourne : DeviceStatus

final status = await sdk.connectDevice(pairingCode: '123456');
debugPrint('device=${status.deviceId}');
debugPrint('lifecycle=${status.lifecycleState.name}');
debugPrint('ready=${status.isReadyForSafety}');

getDeviceStatus()​

Lit le dernier snapshot runtime du dispositif en cache sans démarrer un nouveau flux d'appairage.

Retourne : DeviceStatus

final status = await sdk.getDeviceStatus();
debugPrint('connected=${status.connected}');
debugPrint('lastSeen=${status.lastSeen}');
debugPrint('firmware=${status.firmwareVersion}');

deviceStatusStream​

Émet les changements de cycle de vie pendant que le dispositif se connecte, s'active, se déconnecte ou se rétablit.

Retourne : Stream<DeviceStatus>

final sub = sdk.deviceStatusStream.listen((status) {
  debugPrint('lifecycle=${status.lifecycleState.name}');
  debugPrint('connected=${status.connected}');
  debugPrint('battery=${status.approximateBatteryPercentage}');
});

getDeviceSosStatus()​

Retourne l'état SOS actuel du dispositif suivi par le runtime du SDK.

Retourne : DeviceSosStatus

final status = await sdk.getDeviceSosStatus();
debugPrint('state=${status.state.name}');
debugPrint('event=${status.lastEvent}');
debugPrint('countdown=${status.countdownRemainingSeconds}');

SOS​

triggerSos(...)​

Crée un incident SOS initié par l'app en utilisant la session signée actuelle et le runtime opérationnel.

Retourne : SosIncident

final incident = await sdk.triggerSos(
  const SosTriggerPayload(
    message: 'Need assistance',
    triggerSource: 'button_ui',
  ),
);

debugPrint('incident=${incident.id}');
debugPrint('state=${incident.state.name}');

getCurrentSosIncident()​

Retourne le dernier incident SOS actif ou récemment clôturé connu après la réhydratation du runtime.

Retourne : Future<SosIncident?>

final incident = await sdk.getCurrentSosIncident();
if (incident != null) {
  debugPrint('incident=${incident.id}');
  debugPrint('state=${incident.state.name}');
  debugPrint('hasPosition=${incident.positionSnapshot != null}');
}

getSosState()​

Retourne l'état actuel du cycle de vie SOS.

Retourne : Future<SosState>

Valeurs : idle, sent, acknowledged, cancelRequested, cancelled

final state = await sdk.getSosState();
debugPrint('sosState=${state.name}');

Contacts​

listEmergencyContacts()​

Charge les contacts d'urgence synchronisés avec le backend pour l'utilisateur signé.

Retourne : Future<List<EmergencyContact>>

final contacts = await sdk.listEmergencyContacts();
for (final contact in contacts) {
  debugPrint('${contact.priority}: ${contact.name} ${contact.phone}');
}

createEmergencyContact(...)​

Crée un nouveau contact d'urgence et retourne l'enregistrement sauvegardé.

Retourne : EmergencyContact

final contact = await sdk.createEmergencyContact(
  name: 'Mountain Rescue Desk',
  phone: '+34600000000',
  email: 'rescue@example.com',
  priority: 1,
);

debugPrint('contact=${contact.id}');
debugPrint('priority=${contact.priority}');

updateEmergencyContact(...)​

Met à jour un contact existant et retourne l'enregistrement sauvegardé.

Retourne : EmergencyContact

final current = (await sdk.listEmergencyContacts()).first;
final updated = await sdk.updateEmergencyContact(
  current.copyWith(name: 'Mountain Rescue 24/7'),
);

debugPrint('contact=${updated.id}');
debugPrint('name=${updated.name}');
debugPrint('updatedAt=${updated.updatedAt}');

Autorisations​

getPermissionState()​

Retourne un snapshot agrégé pour la localisation, les notifications, le Bluetooth et la disponibilité du service Bluetooth.

Retourne : PermissionState

final state = await sdk.getPermissionState();
debugPrint('location=${state.location.name}');
debugPrint('notifications=${state.notifications.name}');
debugPrint('bluetoothReady=${state.canUseBluetooth}');

Mode Protection​

remarque

La continuité en arrière-plan est significativement meilleure sur Android lorsque le Mode Protection (service natif en premier plan) possède le transport BLE. Le BLE géré uniquement par Flutter ne garantit pas une exécution complète en arrière-plan.

getProtectionStatus()​

Retourne le statut runtime actuel pour l'état armé/dégradé/désactivé et la propriété native du BLE.

Retourne : ProtectionStatus

final status = await sdk.getProtectionStatus();
debugPrint('mode=${status.modeState.name}');
debugPrint('runtime=${status.runtimeState.name}');
debugPrint('owner=${status.bleOwner.name}');
debugPrint('protectedDevice=${status.protectedDeviceId}');

getProtectionDiagnostics()​

Retourne les derniers diagnostics natif/runtime pour les reconnexions, les événements de réveil, les files d'attente et le routage des commandes.

Retourne : ProtectionDiagnostics

final diagnostics = await sdk.getProtectionDiagnostics();
debugPrint('wake=${diagnostics.lastWakeReason}');
debugPrint('reconnects=${diagnostics.reconnectAttemptCount}');
debugPrint('lastCommandRoute=${diagnostics.lastCommandRoute}');

Registre des appareils backend​

listRegisteredDevices()​

Retourne les enregistrements d'appareils backend associés à l'utilisateur signé.

Retourne : Future<List<BackendRegisteredDevice>>

final devices = await sdk.listRegisteredDevices();
for (final device in devices) {
  debugPrint('${device.hardwareId} ${device.firmwareVersion}');
}

:::note Synchronisation de l'appareil appairé Après l'appairage/connexion d'un appareil et lorsque l'identité de la session signée est prête, le SDK peut tenter une synchronisation automatique avec le backend. La synchronisation utilise hardware_id, firmware_version, hardware_model et paired_at, et n'est sûre que lorsqu'un hardware ID canonique compatible backend peut être résolu. :::

Omis du chemin partenaire​

L'API partenaire omet intentionnellement :

  • Les méthodes dépréciées de compatibilité maintenues uniquement pour la migration
  • Les groupes de capacités internes de validation tels que Guided Rescue Phase 1
  • Les exemples de contrôle de dispositif bas niveau en dehors du chemin d'onboarding recommandé