securiti-consent-sdk 1.141.0-1rc → 1.141.0-21rc

package/NitroSecuritiConsentSdk.podspec

@@ -32,6 +32,6 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
-  s.dependency 'ConsentUI', "1.141.0-1rc"
+  s.dependency 'ConsentUI', "1.141.0-21rc"
   install_modules_dependencies(s)
 end

package/README.md

@@ -29,10 +29,12 @@ A React Native Library for managing user consent preferences and compliance with
     - [options()](#options)
     - [getSettingsPrompt()](#getsettingsprompt)
     - [uploadConsents(request)](#uploadconsentsrequest)
+    - [getGCMConsents()](#getgcmconsents)
     - [presentConsentBanner()](#presentconsentbanner)
     - [presentPreferenceCenter()](#presentpreferencecenter)
-6. [Types and Properties](#types-and-properties)
-7. [Using Methods](#using-methods)
+6. [Google Consent Mode Integration](#google-consent-mode-integration)
+7. [Types and Properties](#types-and-properties)
+8. [Using Methods](#using-methods)
 
 ---
 
@@ -554,6 +556,85 @@ uploadConsents(consentRequest)
 
 ---
 
+### getGCMConsents()
+
+**Description:**
+Retrieves Google Consent Mode (GCM) consent statuses for all configured Google consent types. This method is specifically designed for integration with Google services that require consent mode signals.
+
+**Return Value:**
+`Promise<GCMConsents>`
+
+**GCMConsents Interface:**
+A map of Google Consent Type strings to Consent Status strings.
+
+**Google Consent Type Values:**
+- `analytics_storage` - Controls consent for analytics cookies/storage
+- `ad_storage` - Controls consent for advertising cookies/storage
+- `ad_user_data` - Controls consent for sending user data to Google for advertising purposes
+- `ad_personalization` - Controls consent for personalized advertising
+
+**ConsentStatus Values:**
+- `granted`
+- `declined`
+- `not_determined`
+- `withdrawn`
+
+**Example:**
+```js
+import { getGCMConsents, GoogleConsentTypeValues } from 'securiti-consent-sdk';
+
+getGCMConsents()
+  .then((gcmConsents) => {
+    console.log('Google Consent Mode Statuses:', gcmConsents);
+
+    // Check specific consent types
+    const analyticsConsent = gcmConsents[GoogleConsentTypeValues.ANALYTICS_STORAGE];
+    const adStorageConsent = gcmConsents[GoogleConsentTypeValues.AD_STORAGE];
+    const adUserDataConsent = gcmConsents[GoogleConsentTypeValues.AD_USER_DATA];
+    const adPersonalizationConsent = gcmConsents[GoogleConsentTypeValues.AD_PERSONALIZATION];
+
+    // Example output format:
+    // {
+    //   "analytics_storage": "granted",
+    //   "ad_storage": "declined",
+    //   "ad_user_data": "granted",
+    //   "ad_personalization": "declined"
+    // }
+  })
+  .catch((error) => {
+    console.error('Failed to get GCM consents:', error);
+  });
+```
+
+**Integration with Google Analytics/Ads:**
+```js
+import { getGCMConsents } from 'securiti-consent-sdk';
+
+// Update Google Consent Mode based on user preferences
+async function updateGoogleConsentMode() {
+  try {
+    const gcmConsents = await getGCMConsents();
+
+    // For Google Analytics 4 (gtag.js)
+    if (typeof gtag !== 'undefined') {
+      gtag('consent', 'update', {
+        'analytics_storage': gcmConsents['analytics_storage'] === 'granted' ? 'granted' : 'denied',
+        'ad_storage': gcmConsents['ad_storage'] === 'granted' ? 'granted' : 'denied',
+        'ad_user_data': gcmConsents['ad_user_data'] === 'granted' ? 'granted' : 'denied',
+        'ad_personalization': gcmConsents['ad_personalization'] === 'granted' ? 'granted' : 'denied'
+      });
+    }
+  } catch (error) {
+    console.error('Error updating Google Consent Mode:', error);
+  }
+}
+
+// Call after user makes consent choices
+updateGoogleConsentMode();
+```
+
+---
+
 ### presentConsentBanner()
 
 **Description:**  
@@ -594,6 +675,356 @@ presentPreferenceCenter();
 
 ---
 
+## Google Consent Mode Integration
+
+Google Consent Mode is a framework that allows you to adjust how Google tags behave based on user consent choices. The Securiti Consent SDK provides seamless integration with Google Consent Mode through the `getGCMConsents()` method.
+
+### Overview
+
+Google Consent Mode v2 requires mobile apps to signal user consent choices for four specific consent types:
+
+1. **analytics_storage** - Permission to store analytics data
+2. **ad_storage** - Permission to store advertising data
+3. **ad_user_data** - Permission to send user data to Google for advertising
+4. **ad_personalization** - Permission to use data for personalized ads
+
+The SDK automatically maps your configured purposes to these Google consent types based on your Securiti platform configuration.
+
+### How It Works
+
+1. Configure purpose-to-Google-consent-type mappings in your Securiti platform
+2. Initialize the SDK in your React Native app
+3. Call `getGCMConsents()` to retrieve mapped consent statuses
+4. Pass the consent signals to Google Analytics or Google Ads SDKs
+
+### Configuration in Securiti Platform
+
+Before using Google Consent Mode in your app, ensure you have configured the mappings in the Securiti Privacy Center:
+
+1. Navigate to your mobile app configuration
+2. Go to the Purposes section
+3. For each purpose, configure the Google Consent Mode mapping
+4. Select which Google consent type (analytics_storage, ad_storage, etc.) each purpose should map to
+
+### Basic Usage
+
+```js
+import { getGCMConsents, GoogleConsentTypeValues } from 'securiti-consent-sdk';
+
+async function checkGoogleConsents() {
+  try {
+    const gcmConsents = await getGCMConsents();
+
+    // gcmConsents is an object with consent statuses:
+    // {
+    //   "analytics_storage": "granted",
+    //   "ad_storage": "declined",
+    //   "ad_user_data": "granted",
+    //   "ad_personalization": "declined"
+    // }
+
+    return gcmConsents;
+  } catch (error) {
+    console.error('Error fetching GCM consents:', error);
+    return {};
+  }
+}
+```
+
+### Integration with Firebase Analytics
+
+If you're using Firebase Analytics with Google Analytics 4, you can integrate consent signals:
+
+```js
+import analytics from '@react-native-firebase/analytics';
+import { getGCMConsents } from 'securiti-consent-sdk';
+
+async function updateFirebaseConsent() {
+  try {
+    const gcmConsents = await getGCMConsents();
+
+    // Set consent mode for Firebase Analytics
+    await analytics().setConsent({
+      analytics_storage: gcmConsents['analytics_storage'] === 'granted',
+      ad_storage: gcmConsents['ad_storage'] === 'granted',
+      ad_user_data: gcmConsents['ad_user_data'] === 'granted',
+      ad_personalization: gcmConsents['ad_personalization'] === 'granted'
+    });
+
+    console.log('Firebase consent updated successfully');
+  } catch (error) {
+    console.error('Error updating Firebase consent:', error);
+  }
+}
+```
+
+### Integration with Google Mobile Ads SDK
+
+For Google Mobile Ads (AdMob), you need to handle consent before initializing the ads:
+
+**iOS (Swift/Objective-C bridge):**
+
+```js
+import { NativeModules } from 'react-native';
+import { getGCMConsents } from 'securiti-consent-sdk';
+
+const { GoogleAdsConsentBridge } = NativeModules;
+
+async function updateGoogleAdsConsent() {
+  try {
+    const gcmConsents = await getGCMConsents();
+
+    // Pass consent to native module
+    await GoogleAdsConsentBridge.updateConsent({
+      analytics_storage: gcmConsents['analytics_storage'],
+      ad_storage: gcmConsents['ad_storage'],
+      ad_user_data: gcmConsents['ad_user_data'],
+      ad_personalization: gcmConsents['ad_personalization']
+    });
+  } catch (error) {
+    console.error('Error updating Google Ads consent:', error);
+  }
+}
+```
+
+**Android (Kotlin bridge):**
+
+```js
+import { NativeModules } from 'react-native';
+import { getGCMConsents } from 'securiti-consent-sdk';
+
+const { GoogleAdsConsentBridge } = NativeModules;
+
+async function updateGoogleAdsConsent() {
+  try {
+    const gcmConsents = await getGCMConsents();
+
+    // Pass consent to native module
+    await GoogleAdsConsentBridge.updateConsent(gcmConsents);
+  } catch (error) {
+    console.error('Error updating Google Ads consent:', error);
+  }
+}
+```
+
+### Real-World Example: Complete Integration
+
+Here's a complete example showing how to integrate Google Consent Mode into your app:
+
+```jsx
+import React, { useEffect, useState } from 'react';
+import { View, Button, Alert } from 'react-native';
+import {
+  initialize,
+  presentConsentBanner,
+  isReady,
+  getGCMConsents,
+  GoogleConsentTypeValues,
+  LoggerLevel
+} from 'securiti-consent-sdk';
+import analytics from '@react-native-firebase/analytics';
+
+export default function ConsentManager() {
+  const [sdkReady, setSdkReady] = useState(false);
+  const [consentsApplied, setConsentsApplied] = useState(false);
+
+  useEffect(() => {
+    initializeConsentSDK();
+  }, []);
+
+  const initializeConsentSDK = () => {
+    // Initialize SDK
+    const options = {
+      appURL: 'YOUR_APP_URL',
+      cdnURL: 'YOUR_CDN_URL',
+      tenantID: 'YOUR_TENANT_ID',
+      appID: 'YOUR_APP_ID',
+      testingMode: false,
+      loggerLevel: LoggerLevel.INFO,
+      consentsCheckInterval: 3600,
+      languageCode: 'en',
+      locationCode: 'US'
+    };
+
+    initialize(options);
+
+    // Check when SDK is ready
+    isReady(async (ready) => {
+      if (ready) {
+        setSdkReady(ready);
+
+        // Apply Google Consent Mode
+        await applyGoogleConsentMode();
+
+        // Show consent banner if needed
+        presentConsentBanner();
+      }
+    });
+  };
+
+  const applyGoogleConsentMode = async () => {
+    try {
+      const gcmConsents = await getGCMConsents();
+
+      // Log consent statuses
+      console.log('Google Consent Mode statuses:', gcmConsents);
+
+      // Apply to Firebase Analytics
+      await analytics().setConsent({
+        analytics_storage: gcmConsents[GoogleConsentTypeValues.ANALYTICS_STORAGE] === 'granted',
+        ad_storage: gcmConsents[GoogleConsentTypeValues.AD_STORAGE] === 'granted',
+        ad_user_data: gcmConsents[GoogleConsentTypeValues.AD_USER_DATA] === 'granted',
+        ad_personalization: gcmConsents[GoogleConsentTypeValues.AD_PERSONALIZATION] === 'granted'
+      });
+
+      setConsentsApplied(true);
+      console.log('Google Consent Mode applied successfully');
+    } catch (error) {
+      console.error('Error applying Google Consent Mode:', error);
+      Alert.alert('Error', 'Failed to apply consent settings');
+    }
+  };
+
+  const refreshConsents = async () => {
+    if (!sdkReady) {
+      Alert.alert('SDK Not Ready', 'Please wait for the SDK to initialize');
+      return;
+    }
+
+    await applyGoogleConsentMode();
+    Alert.alert('Success', 'Consent settings refreshed');
+  };
+
+  const showConsentBanner = () => {
+    if (!sdkReady) {
+      Alert.alert('SDK Not Ready', 'Please wait for the SDK to initialize');
+      return;
+    }
+
+    presentConsentBanner();
+  };
+
+  return (
+    <View style={{ padding: 20 }}>
+      <Button
+        title="Show Consent Banner"
+        onPress={showConsentBanner}
+        disabled={!sdkReady}
+      />
+      <View style={{ marginTop: 10 }} />
+      <Button
+        title="Refresh Google Consent Mode"
+        onPress={refreshConsents}
+        disabled={!sdkReady}
+      />
+    </View>
+  );
+}
+```
+
+### Listening to Consent Changes
+
+You may want to refresh Google Consent Mode settings when users update their preferences:
+
+```js
+import { useEffect } from 'react';
+import { getGCMConsents } from 'securiti-consent-sdk';
+import analytics from '@react-native-firebase/analytics';
+
+function useConsentSync() {
+  useEffect(() => {
+    // Sync consents periodically or after preference center closes
+    const syncInterval = setInterval(async () => {
+      try {
+        const gcmConsents = await getGCMConsents();
+
+        await analytics().setConsent({
+          analytics_storage: gcmConsents['analytics_storage'] === 'granted',
+          ad_storage: gcmConsents['ad_storage'] === 'granted',
+          ad_user_data: gcmConsents['ad_user_data'] === 'granted',
+          ad_personalization: gcmConsents['ad_personalization'] === 'granted'
+        });
+      } catch (error) {
+        console.error('Error syncing consents:', error);
+      }
+    }, 60000); // Check every minute
+
+    return () => clearInterval(syncInterval);
+  }, []);
+}
+```
+
+### Testing Google Consent Mode
+
+To verify your integration is working correctly:
+
+1. **Enable Debug Logging:**
+```js
+const options = {
+  // ... other options
+  loggerLevel: LoggerLevel.DEBUG,
+  testingMode: true
+};
+```
+
+2. **Check Console Output:**
+Look for log messages showing the consent statuses being retrieved and applied.
+
+3. **Use Google Analytics DebugView:**
+- Enable debug mode in Firebase Analytics
+- Check that consent signals are being sent correctly
+- Verify events are being processed according to consent choices
+
+4. **Verify Consent Updates:**
+```js
+async function verifyConsents() {
+  const gcmConsents = await getGCMConsents();
+  console.log('Current GCM Consents:', JSON.stringify(gcmConsents, null, 2));
+
+  // Expected output:
+  // {
+  //   "analytics_storage": "granted",
+  //   "ad_storage": "declined",
+  //   "ad_user_data": "granted",
+  //   "ad_personalization": "declined"
+  // }
+}
+```
+
+### Best Practices
+
+1. **Initialize Early:** Call `initialize()` as early as possible in your app lifecycle
+2. **Apply Before Tracking:** Update Google Consent Mode before sending any analytics events
+3. **Handle Errors:** Always wrap consent calls in try-catch blocks
+4. **Sync After Updates:** Refresh consent signals after users update preferences
+5. **Test Thoroughly:** Test with different consent combinations to ensure proper behavior
+6. **Check SDK Ready:** Always verify the SDK is ready before calling `getGCMConsents()`
+
+### Troubleshooting
+
+**Issue: getGCMConsents() returns empty object**
+- Ensure SDK is initialized and ready
+- Verify purpose-to-GCM mappings are configured in Securiti platform
+- Check that purposes have been loaded successfully
+
+**Issue: Consent signals not applied to Google services**
+- Verify you're calling the correct Google SDK consent methods
+- Check that consent updates happen before any tracking calls
+- Ensure proper integration with Firebase/Google Ads SDKs
+
+**Issue: Consent statuses not updating**
+- Call `getGCMConsents()` after user makes consent changes
+- Verify the SDK is returning updated values
+- Check for any errors in console logs
+
+### Additional Resources
+
+- [Google Consent Mode Documentation](https://developers.google.com/tag-platform/security/concepts/consent-mode)
+- [Firebase Analytics Consent](https://firebase.google.com/docs/analytics/configure-data-collection?platform=ios)
+- [Google Mobile Ads Consent](https://developers.google.com/admob/ump/android/quick-start)
+
+---
+
 ## Types and Properties
 
 ### ConsentStatus Values
@@ -671,6 +1102,49 @@ See [getSdksInPurpose(purposeId)](#getsdksinpurposepurposeid).
 | sdkVersion       | string            | No       | SDK version                                 |
 | platform         | string            | No       | Platform information                        |
 
+### GoogleConsentType
+
+Google Consent Mode consent type identifiers:
+
+| Constant                 | Value                | Description                                      |
+|--------------------------|----------------------|--------------------------------------------------|
+| ANALYTICS_STORAGE        | analytics_storage    | Controls consent for analytics cookies/storage   |
+| AD_STORAGE               | ad_storage           | Controls consent for advertising cookies/storage |
+| AD_USER_DATA             | ad_user_data         | Controls consent for sending user data to Google |
+| AD_PERSONALIZATION       | ad_personalization   | Controls consent for personalized advertising    |
+
+**Usage:**
+```js
+import { GoogleConsentTypeValues } from 'securiti-consent-sdk';
+
+// Access consent type constants
+const analyticsType = GoogleConsentTypeValues.ANALYTICS_STORAGE; // "analytics_storage"
+const adStorageType = GoogleConsentTypeValues.AD_STORAGE; // "ad_storage"
+const adUserDataType = GoogleConsentTypeValues.AD_USER_DATA; // "ad_user_data"
+const adPersonalizationType = GoogleConsentTypeValues.AD_PERSONALIZATION; // "ad_personalization"
+```
+
+### GCMConsents
+
+The response type from `getGCMConsents()` - a map of Google Consent Type strings to Consent Status strings.
+
+**Interface:**
+```typescript
+interface GCMConsents {
+  [consentType: string]: ConsentStatus
+}
+```
+
+**Example:**
+```js
+{
+  "analytics_storage": "granted",
+  "ad_storage": "declined",
+  "ad_user_data": "granted",
+  "ad_personalization": "declined"
+}
+```
+
 ---
 
 ## Using Methods
@@ -708,9 +1182,11 @@ import {
   setPermissionConsent,
   getBannerConfig,
   getSettingsPrompt,
+  getGCMConsents,
   options,
   LoggerLevel,
   ConsentStatusValues,
+  GoogleConsentTypeValues,
 } from 'securiti-consent-sdk';
 
 // For types
@@ -965,6 +1441,29 @@ export default function App() {
     }
   };
 
+  const handleGetGCMConsents = async () => {
+    setResponse(null);
+    setIsLoading(true);
+    try {
+      const gcmConsents = await getGCMConsents();
+      setResponse({
+        gcmConsents: gcmConsents,
+        timestamp: new Date().toISOString(),
+        details: {
+          analytics_storage: gcmConsents[GoogleConsentTypeValues.ANALYTICS_STORAGE],
+          ad_storage: gcmConsents[GoogleConsentTypeValues.AD_STORAGE],
+          ad_user_data: gcmConsents[GoogleConsentTypeValues.AD_USER_DATA],
+          ad_personalization: gcmConsents[GoogleConsentTypeValues.AD_PERSONALIZATION]
+        }
+      });
+    } catch (error) {
+      console.error('Error getting GCM consents:', error);
+      setResponse({ error: 'Failed to get GCM consents: ' + error });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
   const handleGetConsentForPurpose = async (purposeId: number) => {
     setResponse(null);
     setIsLoading(true);
@@ -1188,6 +1687,13 @@ export default function App() {
             >
               <Text style={styles.buttonText}>SDK Options</Text>
             </TouchableOpacity>
+
+            <TouchableOpacity
+              style={[styles.button, styles.secondaryButton]}
+              onPress={handleGetGCMConsents}
+            >
+              <Text style={styles.buttonText}>GCM Consents</Text>
+            </TouchableOpacity>
           </View>
         </View>
 

package/android/build.gradle

@@ -126,7 +126,7 @@ repositories {
   mavenCentral()
   google()
   maven {
-    url = uri("https://cdn-prod.securiti.ai/consent/maven")
+    url = uri("https://cdn-dev-intg-2.securiti.xyz/consent/maven")
   }
 }
 
@@ -138,7 +138,7 @@ dependencies {
   implementation "com.facebook.react:react-native:+"
 
 
-  implementation 'ai.securiti.cmpsdkcore:consent-sdk:1.139.0'
+  implementation 'ai.securiti.cmpsdkcore:consent-sdk:1.140.0'
 
   // Add a dependency on NitroModules
   implementation project(":react-native-nitro-modules")