register static method

Future<void> register({ required SDKEnvironment environment, String? baseURL, String? accessToken, })

Register device callbacks with C++ (full async init, Phase 2) Must be called during SDK init after platform adapter

Implementation

static Future<void> register({
  required SDKEnvironment environment,
  String? baseURL,
  String? accessToken,
}) async {
  _baseURL = baseURL;
  _accessToken = accessToken;

  // Register callbacks if not already done in Phase 1
  if (!_callbacksRegistered) {
    registerCallbacks();
  }

  if (_isRegistered) {
    _logger.debug('Device already fully registered');
    return;
  }

  // Initialize SharedPreferences
  _prefs = await SharedPreferences.getInstance();

  // Pre-cache device ID
  await _getOrCreateDeviceId();
  await _configureClientInfo();
  await _refreshDeviceInfoSnapshot();

  // Callbacks are already registered (Phase 1 or the guard above).
  // Refresh the callback snapshot after the asynchronous device metadata
  // caches are ready. Reuse the existing pointer to avoid leaking the
  // Phase-1 allocation.
  try {
    final lib = PlatformLoader.loadCommons();

    final callbacks = _callbacksPtr;
    if (callbacks == null) {
      _logger.warning('No callbacks pointer available for Phase 2');
      return;
    }

    // Register with C++ device manager
    final setCallbacks = lib
        .lookupFunction<
          Int32 Function(Pointer<RacDeviceCallbacksStruct>),
          int Function(Pointer<RacDeviceCallbacksStruct>)
        >('rac_device_manager_set_callbacks');

    final result = setCallbacks(callbacks);
    if (result != RacResultCodes.success) {
      _logger.warning(
        'Failed to register device callbacks',
        metadata: {'code': result},
      );
      return;
    }

    _isRegistered = true;
    _logger.debug('Device callbacks registered successfully');
  } catch (_) {
    _logger.debug('Device registration is unavailable');
    _isRegistered = true; // Mark as registered to avoid retry loops
  }
}