securiti-consent-sdk 1.132.0

package/android/src/main/java/com/margelo/nitro/securiticonsentsdk/HybridConsentSDK.kt

@@ -0,0 +1,669 @@
+package com.margelo.nitro.securiticonsentsdk
+
+import android.util.Log
+import android.app.Application
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.runBlocking
+import ai.securiti.cmpsdkcore.main.SecuritiMobileCmp
+import ai.securiti.cmpsdkcore.main.CmpSDKLoggerLevel
+import ai.securiti.cmpsdkcore.ui.SecuritiMobileCmpExtensions.Companion.presentConsentBanner
+import ai.securiti.cmpsdkcore.ui.SecuritiMobileCmpExtensions.Companion.presentPreferenceCenter
+import com.margelo.nitro.NitroModules
+
+/**
+ * Implementation of the HybridConsentSDK Android for React Native.
+ */
+class HybridConsentSDK : HybridConsentSDKSpec() {
+  private var sdkOptions: CmpSDKOptions? = null
+  private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  
+  companion object {
+    private const val TAG = "ConsentSDK"
+  }
+  
+  /**
+   * Initialize the Securiti SDK with the provided options.
+   */
+  override fun initialize(options: CmpSDKOptions) {
+    Log.d(TAG, "Initialize called with options: $options")
+    this.sdkOptions = options
+    
+    try {
+      // Get the application context from NitroModules
+      val appContext = NitroModules.applicationContext
+      if (appContext == null) {
+        Log.e(TAG, "Application context is null, cannot initialize SDK")
+        return
+      }
+      
+      // Convert logger level string to SDK's enum
+      val loggerLevel = when (options.loggerLevel.uppercase()) {
+        "DEBUG" -> CmpSDKLoggerLevel.DEBUG
+        "INFO" -> CmpSDKLoggerLevel.INFO
+        "WARNING" -> CmpSDKLoggerLevel.WARNING
+        "ERROR" -> CmpSDKLoggerLevel.ERROR
+        else -> CmpSDKLoggerLevel.DEBUG
+      }
+      
+      // Create the native SDK options
+      val securitiOptions = ai.securiti.cmpsdkcore.main.CmpSDKOptions(
+        options.appURL,
+        options.cdnURL,
+        options.tenantID,
+        options.appID,
+        options.testingMode,
+        loggerLevel,
+        options.consentsCheckInterval.toInt(),
+        options.subjectId,
+        options.languageCode,
+        options.locationCode
+      )
+      
+      // Initialize the SDK
+      SecuritiMobileCmp.initialize(appContext.applicationContext as Application, securitiOptions)
+      Log.d(TAG, "SDK initialized successfully")
+    } catch (e: Exception) {
+      Log.e(TAG, "Error initializing SDK: ${e.message}", e)
+    }
+  }
+
+  /**
+   * Check if the SDK is ready.
+   */
+  override fun isSdkReady(): Boolean {
+    Log.d(TAG, "isSdkReady called")
+    return try {
+      SecuritiMobileCmp.isReady()
+    } catch (e: Exception) {
+      Log.e(TAG, "Error checking if SDK is ready: ${e.message}")
+      false
+    }
+  }
+
+  /**
+   * Present the preference center UI.
+   */
+  override fun presentPreferenceCenter() {
+    Log.d(TAG, "presentPreferenceCenter called")
+    try {
+      val appContext = NitroModules.applicationContext
+      if (appContext == null) {
+        Log.e(TAG, "Application context is null, cannot present preference center")
+        return
+      }
+      
+      val activity = appContext.currentActivity
+      if (activity != null) {
+        SecuritiMobileCmp.presentPreferenceCenter(activity)
+      } else {
+        Log.e(TAG, "Cannot present preference center: Current activity is null")
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error presenting preference center: ${e.message}")
+    }
+  }
+
+  /**
+   * Present the consent banner UI.
+   */
+  override fun presentConsentBanner() {
+    Log.d(TAG, "presentConsentBanner called")
+    try {
+      val appContext = NitroModules.applicationContext
+      if (appContext == null) {
+        Log.e(TAG, "Application context is null, cannot present consent banner")
+        return
+      }
+      
+      val activity = appContext.currentActivity
+      if (activity != null) {
+        SecuritiMobileCmp.presentConsentBanner(activity)
+      } else {
+        Log.e(TAG, "Cannot present consent banner: Current activity is null")
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error presenting consent banner: ${e.message}")
+    }
+  }
+  
+  /**
+   * Check if the SDK is ready with a callback.
+   */
+  override fun isReady(callback: (Boolean) -> Unit) {
+    Log.d(TAG, "isReady called")
+    try {
+      SecuritiMobileCmp.isReady { isReady ->
+        callback(isReady)
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Error in isReady callback: ${e.message}")
+      callback(false)
+    }
+  }
+  
+  /**
+   * Reset all stored consents.
+   */
+  override fun resetConsents() {
+    Log.d(TAG, "resetConsents called")
+    try {
+      if (!SecuritiMobileCmp.isReady()) {
+        Log.e(TAG, "SDK is not ready, cannot reset consents")
+        return
+      }
+      
+      SecuritiMobileCmp.resetConsents()
+    } catch (e: Exception) {
+      Log.e(TAG, "Error resetting consents: ${e.message}")
+    }
+  }
+  
+  /**
+   * Get consent status for a purpose by ID.
+   */
+  override fun getConsentByPurposeId(purposeId: Double): Promise<String> {
+    Log.d(TAG, "getConsentByPurposeId called with id: $purposeId")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get consent by purpose ID")
+          return@async "not_determined"
+        }
+        
+        val consentStatus = SecuritiMobileCmp.getConsent(purposeId.toInt())
+        convertConsentStatusToString(consentStatus)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting consent by purpose ID: ${e.message}")
+        "not_determined"
+      }
+    }
+  }
+  
+  /**
+   * Get consent status for a permission by ID.
+   */
+  override fun getConsentByPermissionId(permissionId: String): Promise<String> {
+    Log.d(TAG, "getConsentByPermissionId called with id: $permissionId")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get consent by permission ID")
+          return@async "not_determined"
+        }
+        
+        val consentStatus = SecuritiMobileCmp.getConsent(permissionId)
+        convertConsentStatusToString(consentStatus)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting consent by permission ID: ${e.message}")
+        "not_determined"
+      }
+    }
+  }
+  
+  /**
+   * Get all available permissions.
+   */
+  override fun getPermissions(): Promise<Array<AppPermission>> {
+    Log.d(TAG, "getPermissions called")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get permissions")
+          return@async arrayOf()
+        }
+        
+        val nativePermissions = SecuritiMobileCmp.getPermissions()
+        nativePermissions.map { nativePermission ->
+          AppPermission(
+            id = nativePermission.id?.toDouble(),
+            name = nativePermission.name,
+            permissionId = nativePermission.permissionId,
+            description = this.getString(nativePermission.description),
+            group = nativePermission.group,
+            groupId = nativePermission.groupId?.toDouble(),
+            consentStatus = convertConsentStatusToString(nativePermission.consentStatus),
+            nameMap = this.getString(nativePermission.nameMap),
+            isSettingsPromptEnabled = nativePermission.isSettingsPromptEnabled
+          )
+        }.toTypedArray()
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting permissions: ${e.message}")
+        arrayOf()
+      }
+    }
+  }
+  
+  /**
+   * Get all available purposes.
+   */
+  override fun getPurposes(): Promise<Array<Purpose>> {
+    Log.d(TAG, "getPurposes called")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get purposes")
+          return@async arrayOf()
+        }
+        
+        val nativePurposes = SecuritiMobileCmp.getPurposes()
+        nativePurposes.map { nativePurpose ->
+          Purpose(
+            purposeId = nativePurpose.purposeId?.toDouble(),
+            purposeName = this.getString(nativePurpose.purposeName),
+            purposeDescription = this.getString(nativePurpose.purposeDescription),
+            // Convert SDK list if available
+            sdks = nativePurpose.sdks?.map { nativeSdk ->
+              SDK(
+                sdkId = nativeSdk.sdkId?.toDouble(),
+                namespaceId = nativeSdk.namespaceId,
+                sdkName = this.getString(nativeSdk.sdkName),
+                sdkDescription = this.getString(nativeSdk.sdkDescription),
+                vendor = nativeSdk.vendor,
+                logoBase64 = nativeSdk.logoBase64,
+                website = nativeSdk.website,
+                matchedBy = nativeSdk.matchedBy?.toTypedArray(),
+                collectingData = nativeSdk.collectingData
+              )
+            }?.toTypedArray(),
+            consentStatus = convertConsentStatusToString(nativePurpose.consentStatus),
+            disableOptOut = nativePurpose.disableOptOut,
+            optOutText = this.getString(nativePurpose.optOutText),
+            hideDetails = nativePurpose.hideDetails,
+            isGADMapped = nativePurpose.isGADMapped,
+            gadDescription = this.getString(nativePurpose.gadDescription),
+            isATTMapped = false,
+            attDescription = ""
+          )
+        }.toTypedArray()
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting purposes: ${e.message}")
+        arrayOf()
+      }
+    }
+  }
+  
+  /**
+   * Get all SDKs associated with a purpose.
+   */
+  override fun getSdksInPurpose(purposeId: Double): Promise<Array<SDK>> {
+    Log.d(TAG, "getSdksInPurpose called with purposeId: $purposeId")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get SDKs in purpose")
+          return@async arrayOf()
+        }
+        
+        val nativeSdks = SecuritiMobileCmp.getSdksInPurpose(purposeId.toInt())
+        nativeSdks.map { nativeSdk ->
+          SDK(
+            sdkId = nativeSdk.sdkId?.toDouble(),
+            namespaceId = nativeSdk.namespaceId,
+            sdkName = this.getString(nativeSdk.sdkName),
+            sdkDescription = this.getString(nativeSdk.sdkDescription),
+            vendor = nativeSdk.vendor,
+            logoBase64 = nativeSdk.logoBase64,
+            website = nativeSdk.website,
+            matchedBy = nativeSdk.matchedBy?.toTypedArray(),
+            collectingData = nativeSdk.collectingData
+          )
+        }.toTypedArray()
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting SDKs in purpose: ${e.message}")
+        arrayOf()
+      }
+    }
+  }
+  
+  /**
+   * Set consent status for a purpose.
+   */
+  override fun setPurposeConsent(purpose: Purpose, consent: String): Boolean {
+    Log.d(TAG, "setPurposeConsent called with purpose ID: ${purpose.purposeId}, consent: $consent")
+    
+    try {
+      if (!SecuritiMobileCmp.isReady()) {
+        Log.e(TAG, "SDK is not ready, cannot set purpose consent")
+        return false
+      }
+      
+      val purposeId = purpose.purposeId?.toInt() ?: run {
+        Log.e(TAG, "Purpose ID is null")
+        return false
+      }
+      
+      val consentStatus = convertStringToConsentStatus(consent)
+      
+      // Create native purpose object directly with the required fields
+      // Only the purposeId and disableOptOut properties are used in the native implementation
+      val nativePurpose = ai.securiti.cmpsdkcore.network.models.common.Purpose(
+        purposeId = purposeId,
+        purposeName = null, // Using null since we don't need to map this for setConsent
+        purposeDescription = null, // Using null since we don't need to map this for setConsent
+        disableOptOut = purpose.disableOptOut,
+        sdks = null, // Not needed for setting consent
+        consentStatus = null, // Will be updated by the setConsent method
+        // Other fields are not needed for consent setting
+        optOutText = null,
+        hideDetails = null,
+        isGADMapped = null,
+        gadDescription = null
+      )
+      
+      // Set consent directly without fetching all purposes first
+      return SecuritiMobileCmp.setConsent(nativePurpose, consentStatus)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error in setPurposeConsent: ${e.message}")
+      return false
+    }
+  }
+  
+  /**
+   * Set consent status for a permission.
+   */
+  override fun setPermissionConsent(permission: AppPermission, consent: String): Boolean {
+    Log.d(TAG, "setPermissionConsent called with permission ID: ${permission.permissionId}, consent: $consent")
+    
+    try {
+      if (!SecuritiMobileCmp.isReady()) {
+        Log.e(TAG, "SDK is not ready, cannot set permission consent")
+        return false
+      }
+      
+      val permissionId = permission.permissionId ?: run {
+        Log.e(TAG, "Permission ID is null")
+        return false
+      }
+      
+      val consentStatus = convertStringToConsentStatus(consent)
+      
+      // Create a native AppPermission with just the permissionId field
+      // This matches what the actual implementation requires
+      val nativePermission = ai.securiti.cmpsdkcore.network.models.common.AppPermission(
+        id = null,
+        name = null,
+        permissionId = permissionId,
+        description = null,
+        group = null,
+        groupId = null,
+        consentStatus = null,
+        nameMap = null,
+        isSettingsPromptEnabled = null
+      )
+      
+      // Call setConsent directly with the native AppPermission
+      return SecuritiMobileCmp.setConsent(nativePermission, consentStatus)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error in setPermissionConsent: ${e.message}")
+      return false
+    }
+  }
+  
+  /**
+   * Get the banner configuration.
+   */
+  override fun getBannerConfig(): Promise<BannerConfig?> {
+    Log.d(TAG, "getBannerConfig called")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get banner config")
+          return@async null
+        }
+        
+        // Pass null for now since converting MainConfiguration is complex
+        val nativeBannerConfig = SecuritiMobileCmp.getBannerConfig(null)
+        
+        if (nativeBannerConfig != null) {
+          // Convert native banner config to our format
+          val customColors = nativeBannerConfig.customPaletteTheme?.let {
+            CustomColors(
+              buttonBackground = it.buttonBackground,
+              buttonText = it.buttonText,
+              buttonBorder = it.buttonBorder,
+              bannerBackground = it.bannerBackground,
+              bannerText = it.bannerText,
+              bannerLinks = it.bannerLinks,
+              preferenceCenterFooterBackground = it.preferenceCenterFooterBackground,
+              preferenceCenterFooterSelector = it.preferenceCenterFooterSelector
+            )
+          }
+          
+          // Create our BannerConfig from the native one
+          BannerConfig(
+            hideCloseButton = nativeBannerConfig.hideCloseButton,
+            hideAcceptButton = nativeBannerConfig.hideAcceptButton,
+            embedDSRPortalLink = nativeBannerConfig.embedDSRPortalLink,
+            recordConsentUponAppStart = nativeBannerConfig.recordConsentUponAppStart,
+            hideToggleForEssentialCategories = nativeBannerConfig.hideToggleForEssentialCategories,
+            name = nativeBannerConfig.name,
+            dsrPortalLink = nativeBannerConfig.dsrPortalLink,
+            complianceType = nativeBannerConfig.complianceType?.toString(),
+            bannerReappearanceTime = nativeBannerConfig.bannerReappearanceTime?.toString(),
+            privacyNoticeLink = nativeBannerConfig.privacyNoticeLink,
+            accept = this.getString(nativeBannerConfig.accept),
+            reject = this.getString(nativeBannerConfig.reject),
+            bannerText = this.getString(nativeBannerConfig.bannerText),
+            bannerHeading = this.getString(nativeBannerConfig.bannerHeading),
+            sdkTabHeading = this.getString(nativeBannerConfig.sdkTabHeading),
+            privacyNoticeText = this.getString(nativeBannerConfig.privacyNoticeText),
+            preferenceCenterLink = this.getString(nativeBannerConfig.preferenceCenterLink),
+            permissionsTabHeading = this.getString(nativeBannerConfig.permissionsTabHeading),
+            permissionsTabGuidance = this.getString(nativeBannerConfig.permissionsTabGuidance),
+            preferenceCenterHeading = this.getString(nativeBannerConfig.preferenceCenterHeading),
+            preferenceCenterGuidance = this.getString(nativeBannerConfig.preferenceCenterGuidance),
+            permissionsTabDescription = this.getString(nativeBannerConfig.permissionsTabDescription),
+            preferenceCenterDescription = this.getString(nativeBannerConfig.preferenceCenterDescription),
+            showPoweredBySecuritiLogo = nativeBannerConfig.showPoweredBySecuritiLogo,
+            showDescriptionTextWithPrefCenterToggle = nativeBannerConfig.showDescriptionTextWithPrefCenterToggle,
+            paletteTheme = nativeBannerConfig.paletteTheme?.toDouble(),
+            bannerPosition = nativeBannerConfig.bannerPosition?.toString(),
+            buttonShape = nativeBannerConfig.buttonShape?.toString(),
+            companyLogo = nativeBannerConfig.companyLogo,
+            customPaletteTheme = customColors,
+            shouldShowSettingsPrompt = nativeBannerConfig.shouldShowSettingsPrompt,
+            // Convert nested HashMap structure to a flattened Map
+            translations = nativeBannerConfig.translations?.entries?.associate { entry ->
+              // For each parent key (e.g., "Go back")
+              val parentKey = entry.key
+              // Get the inner HashMap and access the "_" value directly
+              val value = entry.value?.get("_") ?: ""
+              // Create a direct mapping from parent key to value
+              parentKey to value
+            }
+          )
+        } else {
+          null
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting banner config: ${e.message}")
+        null
+      }
+    }
+  }
+  
+  /**
+   * Get the current SDK options.
+   */
+  override fun options(): CmpSDKOptions? {
+    Log.d(TAG, "options called")
+    return sdkOptions
+  }
+  
+  /**
+   * Get the settings prompt configuration.
+   */
+  override fun getSettingsPrompt(): Promise<SettingsPrompt?> {
+    Log.d(TAG, "getSettingsPrompt called")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot get settings prompt")
+          return@async null
+        }
+        
+        try {
+          // Get the native SettingsPrompt from the SDK
+          val nativeSettingsPrompt = SecuritiMobileCmp.getSettingsPrompt()
+          
+          if (nativeSettingsPrompt != null) {
+            // Log the structure and content of the native SettingsPrompt
+            Log.d(TAG, "Native SettingsPrompt found")
+            
+            // Convert boolean permissions map to string-based permissions map
+            val permissionsMap = mutableListOf<String>()
+            nativeSettingsPrompt.permissions?.forEach { (key, value) ->
+              // Convert Boolean to String "true" or "false"
+              if(value) {
+                permissionsMap.add(key)
+              }
+            }
+            
+            // Return our Nitro SettingsPrompt with converted values
+            return@async SettingsPrompt(
+              promptHeading = this.getString(nativeSettingsPrompt.promptHeading),
+              promptMessage = this.getString(nativeSettingsPrompt.promptMessage),
+              settingsButtonText = this.getString(nativeSettingsPrompt.settingsButtonText),
+              notNowButtonText = this.getString(nativeSettingsPrompt.notNowButtonText),
+              permissions = permissionsMap.toTypedArray()
+            )
+          } else {
+            // If native SDK returns null, return an empty SettingsPrompt
+            Log.d(TAG, "Native SettingsPrompt is null, returning empty SettingsPrompt")
+            return@async SettingsPrompt(
+              promptHeading = "",
+              promptMessage = "",
+              settingsButtonText = "",
+              notNowButtonText = "",
+              permissions = emptyArray()
+            )
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "Error processing settings prompt: ${e.message}", e)
+          // Return an empty SettingsPrompt in case of error
+          Log.d(TAG, "Returning empty SettingsPrompt due to error")
+          return@async SettingsPrompt(
+            promptHeading = "",
+            promptMessage = "",
+            settingsButtonText = "",
+            notNowButtonText = "",
+            permissions = emptyArray()
+          )
+        }
+      } catch (e: Exception) {
+        Log.e(TAG, "Error getting settings prompt: ${e.message}")
+        // Return an empty SettingsPrompt in case of error
+        Log.d(TAG, "Returning empty SettingsPrompt due to error")
+        return@async SettingsPrompt(
+          promptHeading = "", 
+          promptMessage = "",
+          settingsButtonText = "",
+          notNowButtonText = "",
+          permissions = emptyArray()
+        )
+      }
+    }
+  }
+  
+  /**
+   * Upload consents to the server.
+   */
+  override fun uploadConsents(request: PostConsentsRequest): Promise<Boolean> {
+    Log.d(TAG, "uploadConsents called")
+    
+    return Promise.async {
+      try {
+        if (!SecuritiMobileCmp.isReady()) {
+          Log.e(TAG, "SDK is not ready, cannot upload consents")
+          return@async false
+        }
+        
+        // Convert our request to native request
+        val purposeConsents = request.purposeConsents.map { purposeConsent ->
+          ai.securiti.cmpsdkcore.network.models.request.PurposeConsent(
+            purposeID = purposeConsent.purposeID.toInt(),
+            consentStatus = convertStringToConsentStatus(purposeConsent.consentStatus),
+            timestamp = purposeConsent.timestamp.toLong(),
+            isEssential = purposeConsent.isEssential
+          )
+        }
+        
+        val permissionConsents = request.permissions.map { permissionConsent ->
+          ai.securiti.cmpsdkcore.network.models.request.PermissionConsent(
+            permission = permissionConsent.permission,
+            consentStatus = convertStringToConsentStatus(permissionConsent.consentStatus),
+            timestamp = permissionConsent.timestamp.toLong()
+          )
+        }
+        
+        val nativeRequest = ai.securiti.cmpsdkcore.network.models.request.PostConsentsRequest(
+          uuid = request.uuid,
+          appUUID = request.appUUID,
+          device = request.device,
+          implicitConsent = request.implicitConsent,
+          version = request.version.toInt(),
+          purposeConsents = purposeConsents,
+          permissions = permissionConsents,
+          isTestMode = request.isTestMode,
+          adId = request.adId,
+          bannerInfo = request.bannerInfo,
+          sdkVersion = request.sdkVersion,
+          platform = request.platform ?: "android"
+        )
+        
+        // Upload consents
+        SecuritiMobileCmp.uploadConsents(nativeRequest)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error uploading consents: ${e.message}")
+        false
+      }
+    }
+  }
+  
+  /**
+   * Convert Securiti SDK's ConsentStatus to string representation.
+   */
+  private fun convertConsentStatusToString(status: ai.securiti.cmpsdkcore.network.models.common.ConsentStatus?): String {
+    return when (status) {
+      ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.GRANTED -> "granted"
+      ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.DECLINED -> "declined"
+      ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.NOT_DETERMINED -> "not_determined"
+      ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.WITHDRAWN -> "withdrawn"
+      else -> "not_determined"
+    }
+  }
+  
+  /**
+   * Convert string representation to Securiti SDK's ConsentStatus.
+   */
+  private fun convertStringToConsentStatus(status: String): ai.securiti.cmpsdkcore.network.models.common.ConsentStatus {
+    return when (status.lowercase()) {
+      "granted" -> ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.GRANTED
+      "declined" -> ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.DECLINED
+      "not_determined" -> ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.NOT_DETERMINED
+      "withdrawn" -> ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.WITHDRAWN
+      else -> ai.securiti.cmpsdkcore.network.models.common.ConsentStatus.NOT_DETERMINED
+    }
+  }
+
+  // Convert HashMap<String, String>? to String
+  private fun getString(map: HashMap<String, String>?) : String {
+    return map?.get("_") ?: ""
+  }
+  
+  // Overload for handling String? input
+  private fun getString(value: String?) : String {
+    return value ?: ""
+  }
+}

package/android/src/main/java/com/margelo/nitro/securiticonsentsdk/NitroSecuritiConsentSdkPackage.java

@@ -0,0 +1,33 @@
+package com.margelo.nitro.securiticonsentsdk;
+
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.core.HybridObject;
+
+import java.util.HashMap;
+import java.util.function.Supplier;
+
+public class NitroSecuritiConsentSdkPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+        return new HashMap<>();
+    };
+  }
+
+  static {
+    NitroSecuritiConsentSdkOnLoad.initializeNative();
+  }
+}