register static method

void register()

Register platform adapter with C++. Must be called FIRST during SDK init (before any C++ operations).

Implementation

static void register() {
  if (_isRegistered) {
    _logger.debug('Platform adapter already registered');
    return;
  }

  try {
    final lib = PlatformLoader.loadCommons();

    // Allocate the platform adapter struct
    _adapterPtr = calloc<RacPlatformAdapterStruct>();
    final adapter = _adapterPtr!;

    // Logging callback
    adapter.ref.log = Pointer.fromFunction<RacLogCallbackNative>(
      _platformLogCallback,
    );

    // File operations
    adapter.ref.fileExists =
        Pointer.fromFunction<RacFileExistsCallbackNative>(
      _platformFileExistsCallback,
      _exceptionalReturnFalse,
    );
    adapter.ref.fileRead = Pointer.fromFunction<RacFileReadCallbackNative>(
      _platformFileReadCallback,
      _exceptionalReturnInt32,
    );
    adapter.ref.fileWrite = Pointer.fromFunction<RacFileWriteCallbackNative>(
      _platformFileWriteCallback,
      _exceptionalReturnInt32,
    );
    adapter.ref.fileDelete =
        Pointer.fromFunction<RacFileDeleteCallbackNative>(
      _platformFileDeleteCallback,
      _exceptionalReturnInt32,
    );

    // Secure storage (async operations - need special handling)
    adapter.ref.secureGet = Pointer.fromFunction<RacSecureGetCallbackNative>(
      _platformSecureGetCallback,
      _exceptionalReturnInt32,
    );
    adapter.ref.secureSet = Pointer.fromFunction<RacSecureSetCallbackNative>(
      _platformSecureSetCallback,
      _exceptionalReturnInt32,
    );
    adapter.ref.secureDelete =
        Pointer.fromFunction<RacSecureDeleteCallbackNative>(
      _platformSecureDeleteCallback,
      _exceptionalReturnInt32,
    );

    // Clock - returns int64, use 0 as exceptional return
    adapter.ref.nowMs = Pointer.fromFunction<RacNowMsCallbackNative>(
      _platformNowMsCallback,
      _exceptionalReturnInt64,
    );

    // Memory info callback - returns errorNotImplemented (platform-specific)
    adapter.ref.getMemoryInfo =
        Pointer.fromFunction<RacGetMemoryInfoCallbackNative>(
      _platformGetMemoryInfoCallback,
      _exceptionalReturnInt32,
    );

    // Error tracking (Sentry)
    adapter.ref.trackError =
        Pointer.fromFunction<RacTrackErrorCallbackNative>(
      _platformTrackErrorCallback,
    );

    // Optional callbacks (handled by Dart directly)
    adapter.ref.httpDownload = nullptr;
    adapter.ref.httpDownloadCancel = nullptr;
    adapter.ref.extractArchive = nullptr;
    adapter.ref.userData = nullptr;

    // Register with C++
    final setAdapter = lib.lookupFunction<
        Int32 Function(Pointer<RacPlatformAdapterStruct>),
        int Function(
            Pointer<RacPlatformAdapterStruct>)>('rac_set_platform_adapter');

    final result = setAdapter(adapter);
    if (result != RacResultCode.success) {
      _logger.error('Failed to register platform adapter', metadata: {
        'error_code': result,
      });
      calloc.free(adapter);
      _adapterPtr = null;
      return;
    }

    _isRegistered = true;
    _logger.debug('Platform adapter registered successfully');

    // Note: We don't free the adapter here as C++ holds a reference to it
    // It will be valid for the lifetime of the application
  } catch (e, stack) {
    _logger.error('Exception registering platform adapter', metadata: {
      'error': e.toString(),
      'stack': stack.toString(),
    });
  }
}