ConsentManager

https://help.consentmanager.net/
Admin
ConsentManager is a Consent Management Platform (CMP) that helps websites and apps become GDPR and...
Tokens:253,221
Snippets:3,280
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### Enable Magento 2 plugin

Source: https://help.consentmanager.net/books/cmp/page/how-to-integrate-the-cmp-into-a-magento-shop

Runs the setup upgrade command to register the newly installed module.

```bash
php bin/magento setup:upgrade
```

--------------------------------

### Initialize Kochava with App GUID

Source: https://help.consentmanager.net/books/cmp/page/android-3rd-party-app-attribution-partners-%28aaps%29

Use the Kochava tracker instance to start the SDK with your specific application GUID.

```kotlin
Tracker.getInstance().startWithAppGuid(applicationContext, "YOUR_ANDROID_APP_GUID")
```

--------------------------------

### Initialize CMP Manager

Source: https://help.consentmanager.net/books/cmp/page/unity-2-api-documentation

Initializes the consent layer and checks for consent requirements. This example demonstrates setup within Unity's Awake and Start lifecycle methods.

```csharp
private void Awake()
        {
            _cmpManager = CmpManager.Instance;
        }

        private void Start()
        {
            _mainThread = Thread.CurrentThread;
            Debug.Log("Consentmanager SampleScene started");

#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
            var config = new CmpConfig(CodeId, Domain, AppName, Language);
            // Example of using a custom layout 
            // var customRect = new Rect(0,0, 300, 600);
            // config.SetCustomLayout(customRect);

            // alternative create the instance directly with the required parameters
            // _cmpManager.Initialize(Domain, CodeId, AppName, Language); 

            _cmpManager.Initialize(config);
            _cmpManager.Launch();
#endif
        }
```

--------------------------------

### Setup CmpConfig with App ID and Domain

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide

Initializes the CmpConfig shared instance with essential app details. Ensure all required parameters are provided for proper SDK setup.

```swift
let cmpConfig : CmpConfig = CmpConfig.shared.setup(withId: config.appId, domain: config.domain, appName: config.appName, language: config.language);
```

--------------------------------

### Example Model Action Call

Source: https://help.consentmanager.net/books/cmp/page/general-api

Example of listing CMP models using the standard URL structure.

```text
https://[API-Endpoint]/model/CMP/list
```

--------------------------------

### Example &gcd= Parameter: Denied then Granted

Source: https://help.consentmanager.net/books/cmp/page/working-with-google-consent-mode

An example of the &gcd= parameter showing that the default consent was 'denied' and the user subsequently 'accepted' the consent settings.

```plaintext
&gcd=13r3r3r3r5
```

--------------------------------

### Initialize CMPConsentTool

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Setup the SDK within a ViewController by configuring the CmpConfig and initializing the CMPConsentTool instance.

```swift
class ViewController: UIViewController {
  var cmpManager: CMPConsentTool? = nil
  override func viewDidLoad() {
      super.viewDidLoad()
      let cmpConfig: CmpConfig = CmpConfig.shared.setup(
                                          withId: "<YOUR-CONSENTMANAGER-APP-ID>, example: a000aaaa0a", 
                                          domain: "<YOUR-CONSENTMANAGER-APP-DOMAIN>, example: delivery.consentmanager.net", 
                                          appName: "<YOUR-CONSENTMANAGER-APP-NAME>, example: testApp", 
                                          language: "<YOUR-CONSENTMANAGER-APP-LANGUAGE, example: DE");
      cmpConfig.logLevel = CmpLogLevel.verbose;
      cmpConfig.isAutomaticATTRequest = true;
      cmpManager = CMPConsentTool(cmpConfig: cmpConfig)
              .withErrorListener(onCMPError)
              .withCloseListener(onClose)
              .withOpenListener(onOpen)
              .withOnCMPNotOpenedListener(onCMPNotOpened)
              .withOnCmpButtonClickedCallback(onButtonClickedEvent)
              .initialize()  
  }
}
```

--------------------------------

### Initialize CMP Manager

Source: https://help.consentmanager.net/books/cmp/page/unity-1-consentmanager-sdk-integration

Setup logic for the CMP manager, including platform-specific initializations.

```csharp
private void InitializeCmpManager()
{
    _mainThread = Thread.CurrentThread;
    AppendLog("Consentmanager SampleScene started");

#if (UNITY_ANDROID || UNITY_IOS) && !UNITY_EDITOR
    _cmpManager.Initialize(_cmpConfig);
    _cmpManager.AddGoogleConsentModeListener(OnGoogleConsentUpdated);
    _cmpManager.AddEventListeners(OnOpen, OnClose, OnNotOpened, OnCmpButtonClicked, OnError);
#endif

#if UNITY_IOS
    CmpATTrackingManager.EnableAutomaticATTracking();
    CmpATTrackingManager.Instance.RegisterOnATTrackingStatusChangedListener(OnCmpATTrackingStatusChanged);
#endif
}
```

--------------------------------

### Initialize ConsentManager SDK (Legacy)

Source: https://help.consentmanager.net/books/cmp/page/android-0-migration-guide-31f

Demonstrates the setup of CmpConfig and initialization of CmpManager within an Activity.

```java
public class CmpDemoActivity extends AppCompatActivity {
    private CmpManager cmpManager;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        CmpConfig cmpConfig = CmpConfig.INSTANCE;
        cmpConfig.setId("<YOUR-CONSENTMANAGER-APP-ID>"); // example: a000aaaa1a
        cmpConfig.setDomain("<YOUR-CONSENTMANAGER-APP-DOMAIN>"); // example: delivery.consentmanager.net
        cmpConfig.setAppName("<YOUR-CONSENTMANAGER-APP-NAME>"); // example: testApp
        cmpConfig.setLanguage("<YOUR-CONSENTMANAGER-APP-LANGUAGE>"); // example: EN
        cmpConfig.setTimeout(4000);
        cmpManager = CmpManager.createInstance(this, cmpConfig);
        cmpManager.initialize(this)
    }
}
```

--------------------------------

### Example: Get CMP Data on Consent Event

Source: https://help.consentmanager.net/books/integration-guide/page/cmp-events

Demonstrates how to add an event listener for the 'consent' event and retrieve CMP data.

```APIDOC
## Example: Get CMP Data on Consent Event

### Description
This example shows how to register a callback function to be executed when the 'consent' event occurs. The callback function then retrieves CMP data using `__cmp('getCMPData')`.

### Method
`__cmp("addEventListener", ["consent", getInfos, false], null)`

### Request Example

```javascript
<script>
  function getInfos(e,o) {
    var result = __cmp('getCMPData');
    /*... do something with result ...*/
  }
  __cmp("addEventListener",["consent",getInfos,false],null);
</script>
```
```

--------------------------------

### Install React Native Bridge

Source: https://help.consentmanager.net/books/cmp/page/reactnative-1-consentmanager-sdk-integration-9b0

Commands to install the SDK bridge via NPM for different React Native architectures.

```bash
npm install cm-sdk-react-native-v3           // For the old architecture
npm install cm-sdk-react-native-v3-new-arch  // For the new architecture
```

--------------------------------

### Handle Link Clicks (New)

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide-a59

Example of the new link click handling approach using a callback.

```swift
cmpManager.setLinkClickHandler { url in
    // Handle links to specific domains externally. The user has full control over which behavior to follow
    // according to the URL. The previous whitelisted URL's should be migrated to inside the callback method, 
    // and the user has the choice to use a switch-case statement, pattern matching, etc.
    if url.host?.contains("google.com") == true || 
       url.host?.contains("facebook.com") == true {
        UIApplication.shared.open(url, options: [:], completionHandler: nil)
        return true // URL handled externally
    }
    
    // Let other URLs load in the WebView
    return false
}
```

--------------------------------

### Define manual installation directory

Source: https://help.consentmanager.net/books/cmp/page/how-to-integrate-the-cmp-into-a-magento-shop

The target directory path for manual plugin file uploads.

```text
app/code/Consentmanager/Cmp
```

--------------------------------

### Legacy SDK Implementation

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide-a59

Configuration and listener setup for older versions of the ConsentManager SDK.

```Swift
override func viewDidLoad({
  super.viewDidLoad()
    let vendoradded = NSNotification.Name.CmpConsentVendorAdded;
  NotificationCenter.default.addObserver(self, selector: #selector(handleVendorAdded(notification:)), name: vendoradded, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(handleConsentUpdated(notification:)), name: Notification.Name.CmpConsentConsentChanged, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(handleVendorRemoved(notification:)), name: Notification.Name.CmpConsentVendorRemoved, object: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(handleConsentUpdated(notification:)), name: Notification.Name.CmpConsentChanged, object: nil)
    setupCmpConfig();
```

```Swift
private func setupCmpConfig() {
  let cmpConfig : CmpConfig = CmpConfig.shared.setup(withId: "YOUR_CODE_ID_HERE, domain: myCmpConfig.domain, appName: myCmpConfig.appName, language: myCmpConfig.language);
  cmpConfig.logLevel = CmpLogLevel.verbose;
  cmpManager = CMPConsentTool(cmpConfig: cmpConfig)
    .withErrorListener(onCMPError)
    .withCloseListener(onClose)
    .withOpenListener(onOpen)
    .withOnCMPNotOpenedListener(onCMPNotOpened)
    .withOnCmpButtonClickedCallback(onButtonClickedEvent)
    .withCmpViewControllerConfigurationBlock { viewController in
      viewController?.modalPresentationStyle = .popover
      viewController?.modalTransitionStyle = .crossDissolve
                                              }
  .initialize()
  }
```

--------------------------------

### ProGuard Configuration

Source: https://help.consentmanager.net/books/cmp/page/android-1-consentmanager-sdk-integration-398

Example configuration to prevent obfuscation of required classes.

```proguard
# Kotlin serialization looks up the generated serializer classes through a function on companion
```

--------------------------------

### Example: Redirect on Consent Rejection

Source: https://help.consentmanager.net/books/integration-guide/page/cmp-events

Shows how to redirect the visitor to a different website if they reject all consent.

```APIDOC
## Example: Redirecting the visitor to a different website if no consent is given

### Description
This example registers a listener for the `consentrejected` event. If the visitor rejects consent, they are redirected to a specified URL. **Note:** This behavior is not recommended and might have legal implications.

### Method
`__cmp("addEventListener", ["consentrejected", getInfos, false], null)`

### Request Example

```javascript
<script>
  function getInfos(e,o) {
    location.href = "https://www.mywebsite.com/alternative-content.html";
  }
  __cmp("addEventListener",["consentrejected",getInfos,false],null);
</script>
```
```

--------------------------------

### Custom Settings Link

Source: https://help.consentmanager.net/books/cmp/page/manually-opening-resurfaceing-the-consent-layer

A simple link example to trigger the custom choices page.

```html
<a href="/?cmpscreen">Cookie settings</a>
```

--------------------------------

### Initialize CMPConsentTool in Android

Source: https://help.consentmanager.net/books/cmp/page/consentmanager-sdk-for-ios

Example of creating an instance of CMPConsentTool within an Android Activity.

```java
public class MainActivity extends AppCompatActivity { private CMPConsentTool consentTool; //create a CMPConsentTool @Override protected void onCreate(Bundle savedInstanceState) { // ... // create an inctance consentTool = CMPConsentTool.createInstance(this, 123456, "consentmanager.mgr.consensu.org", "MyFavouriteApp", ""); // ... } // ... }
```

--------------------------------

### Install SDK via CocoaPods

Source: https://help.consentmanager.net/link/234

Add the SDK dependency to your Podfile and update your local repository.

```ruby
pod 'cm-sdk-ios-v3', '3.2.0'
```

```bash
pod install --repo-update
```

--------------------------------

### Example: Display Message on Consent Rejection

Source: https://help.consentmanager.net/books/integration-guide/page/cmp-events

Demonstrates how to display a message to the user if they reject consent.

```APIDOC
## Example: Showing a message if the visitor rejected

### Description
This example displays a hidden message box when the `consentrejected` event is triggered. The message explains the impact of rejecting ads and offers a donation option.

### Method
`__cmp("addEventListener", ["consentrejected", getInfos, false], null)`

### Request Example

```html
<div id="mymessage" style="display:none; position:fixed; left:calc(50% - 300px); top:calc(50% - 200px); width:600px; height:400px; background-color: #fff0c7; padding: 20px; box-shadow: 0px 0px 5px 0px rgba(0, 0, 0, 0.25);">
  <b>Please consider</b><br>
  Our website is mainly financed by online advertising. Without consent we will not be able to show you tailored ads and our ad revenue will be much lower. As we respect your choice we like to ask you, if you maybe like to donate 1 EUR instead? This will help us keep the quality of our service up.<br>
  <br>
  <a href="donate.html"><b>Donate 1 EUR now!</b></a><br>
  <br>
  <a href="#" onclick="document.getElementById('mymessage').style.display = 'none';">No, thanks!</a>
</div>

<script>
  function getInfos(e,o) { document.getElementById('mymessage').style.display = 'block';}
  __cmp("addEventListener",["consentrejected",getInfos,false],null);
</script>
```
```

--------------------------------

### Get TCData in Non-compliant Setup

Source: https://help.consentmanager.net/books/cmp/page/javascript-api

Retrieves consent data in cases where the CMP setup is non-compliant with IAB TCF v2. Use this when standard methods fail due to configuration issues.

```javascript
__tcfapi('noncompliant_getTCData')
```

--------------------------------

### Initialize CMP SDK (v3 Implementation)

Source: https://help.consentmanager.net/books/cmp/page/android-0-migration-guide-31f

Configuration and lifecycle management for the v3 SDK implementation.

```kotlin
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        val urlConfig = UrlConfig(
            id = "09cb5dca91e6b",
            domain = "delivery.consentmanager.net",
            language = "EN",
            appName = "CMDemoAppKotlin"
        )

        // This UI Config for Android is limited, but you have the option to create an activity wrapper
        // to have full control over the appearance and the position
        val webViewConfig = ConsentLayerUIConfig(
            position = ConsentLayerUIConfig.Position.FULL_SCREEN, // that's the only position available for Android
            backgroundStyle = ConsentLayerUIConfig.BackgroundStyle.dimmed(Color.BLACK, 0.5f),
            cornerRadius = 10f,
            respectsSafeArea = true,
            isCancelable = false
        )

        cmpManager = CMPManager.getInstance(
            context = this,
            urlConfig = urlConfig,
            webViewConfig = webViewConfig,
            delegate = this
        )

        cmpManager.setActivity(this)

        checkAndOpen()
    }

    private fun checkAndOpenConsentLayer() {
        cmpManager.checkWithServerAndOpenIfNecessary { result ->
            result.onSuccess {
                showCMPDemoScreen()
            }.onFailure { error ->
                Log.e("DemoApp", "Check and open consent layer failed with error: $error")
            }
        }
    }

    private fun showCMPDemoScreen() {
        setContent {
            MaterialTheme {
                Surface(
                    modifier = Modifier.fillMaxSize(),
                    color = MaterialTheme.colorScheme.background
                ) {
                    CMPDemoScreen(cmpManager)
                }
            }
        }
    }

    override fun onConfigurationChanged(newConfig: Configuration) {
        Log.d("CMP DemoApp", "Configuration changed")
        super.onConfigurationChanged(newConfig)
        cmpManager.onApplicationResume()
    }

    override fun onPause() {
        Log.d("CMP DemoApp", "Activity paused")
        super.onPause()
        cmpManager.onApplicationPause()
    }

    override fun onDestroy() {
        Log.d("CMP DemoApp", "Activity destroyed")
        super.onDestroy()
        cmpManager.onActivityDestroyed()
    }

    override fun didReceiveConsent(consent: String, jsonObject: Map<String, Any>) {
        Log.d("CMP DemoApp", "Consent Layer successfully received consent message.")
        runOnUiThread {
            showCMPDemoScreen()
        }
    }

    override fun didShowConsentLayer() {
```

--------------------------------

### Initialize SDK and Configure Settings

Source: https://help.consentmanager.net/books/cmp/page/flutter-1-consentmanager-sdk-integration

Create an instance of CmpSdk using a CmpConfig object and initialize it within the app lifecycle.

```dart
import 'package:cmp_sdk/cmp_sdk.dart';
```

```dart
import 'package:cmp_sdk/cmp_config.dart';
```

```dart
void main() {
  runApp(const MyApp());
}
```

```dart
class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}
```

```dart
const String _cmpId = "Your-Code-ID-goes-here";
const String _cmpDomain = "delivery.consentmanager.net";
const String _cmpAppName = "Test";
const String _cmpLanguage = "EN";
```

```dart
class _MyAppState extends State<MyApp> {
  String _consentStatus = '';
  String _callbackLogs = '';
  String _cmpString = '';
  String _idString = '1';
  ScreenConfig _selectedScreenConfig = ScreenConfig.fullScreen;

  final CmpConfig _cmpConfig = CmpConfig(
      id: _cmpId,
      domain: _cmpDomain,
      appName: _cmpAppName,
      language: _cmpLanguage,
      timeout: 8000,
      screenConfig: ScreenConfig.halfScreenBottom,
      isAutomaticATTRequest: true,
      iosPresentationStyle: IosPresentationStyle.pagesheet,
      androidPresentationStyle: AndroidPresentationStyle.dialog);

  late CmpSdk _cmpSdkPlugin;

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback((_) {
      initCmp();
    });
  }

  void _updateCmpUiConfig(ScreenConfig screenConfig) async {
    await _cmpSdkPlugin.configureConsentLayer(config: screenConfig);
  }

  Future<void> initCmp() async {
    try {
      _cmpSdkPlugin = CmpSdk.createInstanceWithConfig(_cmpConfig);
      await _cmpSdkPlugin.initialize();
      setEventCallbacks();                  // Set like on the example below, on the next topic
    } on PlatformException {
      if (kDebugMode) {
        print("platform not supported");
      }
    }

    if (!mounted) return;
  }
```

--------------------------------

### Handling ATT Status and CMP View

Source: https://help.consentmanager.net/books/cmp/page/ios-2-working-with-att-%28app-tracking-transparency-ios%29

Example implementation showing how to request permission, handle status cases, and open the CMP view after the ATT process.

```swift
@available(iOS 14, *)
    @objc func requestPermission() {
        cmpManager?.requestATTPermission(completion: { status in
            switch status {
            case .authorized:
                print("APP:Authorized %@",status)
                // Now that we are authorized we can get the IDFA
                print(ASIdentifierManager.shared().advertisingIdentifier)
            case .denied:
                // Tracking authorization dialog was
                // shown and permission is denied
                print("APP:Denied %@",status.rawValue)
            case .notDetermined:
                // Tracking authorization dialog has not been shown
                print("APP:Not Determined %@",status.rawValue)
            case .restricted:
                print("APP:Restricted %@",status.rawValue)
            @unknown default:
                print("APP:Unknown %@",status.rawValue)
            }
            self.cmpManager?.openView()
        });
    }
```

--------------------------------

### Install CMP via Composer

Source: https://help.consentmanager.net/books/cmp/page/how-to-integrate-the-cmp-into-an-oxid-eshop

Use Composer to install the consentmanager package in your OXID project directory.

```bash
composer require consentmanager/consentmanager4oxid
```

--------------------------------

### Initialize SDK with Direct Configuration

Source: https://help.consentmanager.net/books/cmp/page/reactnative-1-consentmanager-sdk-integration

Initialize the CMP SDK by providing your consentmanager Code-ID, Server-Domain, App Name, and Language directly as arguments.

```javascript
Consentmanager.createInstance('Code-ID from consentmanager, e.g. bfa712361a....',
```

```javascript
  'Server-Domain from consentmanager, e.g. delivery.consentmanager.net',
```

```javascript
  'App Name, e.g. MyReactApp',
```

```javascript
  'Language, e.g. FR');
```

--------------------------------

### Start AppsFlyer SDK

Source: https://help.consentmanager.net/books/cmp/page/ios-3rd-party-app-attribution-partners-%28aaps%29

Replace the CMP SDK's didReceiveMessage callback with this line to start the AppsFlyer SDK after consent is obtained.

```swift
AppsFlyerLib.shared().start()
```

--------------------------------

### Example &gcd= Parameter: No Consent Mode Active

Source: https://help.consentmanager.net/books/cmp/page/working-with-google-consent-mode

An example of the &gcd= parameter indicating that no consent mode was active or set on the page load.

```plaintext
&gcd=13l3l3l2l2
```

--------------------------------

### Initialize and Launch Consent Manager

Source: https://help.consentmanager.net/books/cmp/page/unity-1-consentmanager-sdk-integration

Initializes the Consent Manager SDK with the configured settings and then launches the consent interface to the user.

```csharp
// Initialize Consent Manager
            InitializeCmpManager();
            // Initialize UI buttons
            InitializeUIButtons();

            // Launch Consent Manager
            _cmpManager.Launch();
```

--------------------------------

### AMP Macro Insertion

Source: https://help.consentmanager.net/link/101

Example of how to insert macros in AMP by adding them as parameters to the AMP consent URL. For example, `&cmp_macro_websitename=myWebsite` replaces the `[websitename]` macro.

```html
&cmp_macro__name_=value
```

--------------------------------

### Initialize ConsentManager SDK (v3)

Source: https://help.consentmanager.net/books/cmp/page/android-0-migration-guide-31f

Implementation using the v3 SDK, including UI configuration and callback handling for consent events.

```java
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cmp_demo);
        UrlConfig urlConfig = new UrlConfig(
                "09cb5dca91e6b",
                "delivery.consentmanager.net",
                "EN",
                "CMDemoAppJava"
        );
        ConsentLayerUIConfig webViewConfig = new ConsentLayerUIConfig(
                ConsentLayerUIConfig.Position.FULL_SCREEN,
                ConsentLayerUIConfig.BackgroundStyle.dimmed(Color.BLACK, 0.5f),
                10f,
                true,
                false
        );
        JavaCMPManager cmpManager = JavaCMPManager.getInstance(this, urlConfig, webViewConfig, this);
        cmpManager.setActivity(this);
        cmpManager.checkAndOpen(result -> {
            if (result.isSuccess()) {
            } else {
                Log.e("JavaDemoAp", "Initialize method failed with error: " + result.exceptionOrNull());
            }
            return null;
        });
    }
    private void showCMPDemoScreen() {
        Intent intent = new Intent(this, CMPDemoActivity.class);
        startActivity(intent);
        finish();
    }
    @Override
    public void didShowConsentLayer() {
        Log.d("CMP JavaDemoAp", "Consent Layer open message received.");
    }
    @Override
    public void didCloseConsentLayer() {
        Log.d("CMP JavaDemoAp", "Consent Layer close message received.");
    }
    @Override
    public void didReceiveError(@NonNull String error) {
        Log.e("CMP JavaDemoAp", "SDK error: " + error);
    }
    @Override
    public void didReceiveConsent(@NonNull String consent, @NonNull Map<String, Any> jsonObject) {
        Log.d("CMP JavaDemoAp", "Consent received: " + consent);
        runOnUiThread(this::showCMPDemoScreen);
    }
    @Override
    public void onPointerCaptureChanged(boolean hasCapture) {
        super.onPointerCaptureChanged(hasCapture);
    }
    @Override
    public void addMenuProvider(@NonNull MenuProvider provider, @NonNull LifecycleOwner owner, @NonNull Lifecycle.State state) {
    }
```

--------------------------------

### Install cm-sdk-ios-v3 via CocoaPods

Source: https://help.consentmanager.net/books/cmp/page/ios-1-consentmanager-sdk-integration-b83

Add this line to your Podfile to include the cm-sdk-ios-v3 library. Ensure you run 'pod install --repo-update' afterwards.

```ruby
pod 'cm-sdk-ios-v3', '3.2.0'
```

--------------------------------

### Initialize Consent Manager SDK

Source: https://help.consentmanager.net/books/cmp/page/reactnative-1-consentmanager-sdk-integration-9b0

Configure CMP settings, WebView appearance, and open the consent layer. Requires a stable network connection. Errors during initialization will be logged.

```typescript
import {
  setUrlConfig,
  setWebViewConfig,
  setATTStatus,
  BackgroundStyle,
  BackgroundStyleType,
  BlurEffectStyle,
  WebViewPosition,
  ATTStatus,
} from 'cm-sdk-react-native-v3';

const HomeScreen: React.FC = () => {
  const [isLoading, setIsLoading] = useState(true);
  const [toastMessage, setToastMessage] = useState<string | null>(null);

  useEffect(() => {
    initializeConsent();
  }, []);

  const initializeConsent = async () => {
    try {
      await setWebViewConfig({
        position: WebViewPosition.HalfScreenBottom,
        backgroundStyle: BackgroundStyle.blur(BlurEffectStyle.Dark),
        cornerRadius: 25,
        respectsSafeArea: true,
        allowsOrientationChanges: true,
        // customRect is required if you pick WebViewPosition.Custom (iOS only;
        // Android falls back)
      });

      await setUrlConfig({
        id: '<your-Code-id>',
        domain: 'delivery.consentmanager.net',
        language: 'EN',
        appName: 'MyApp',
        noHash: true, // optional; defaults to false
      });

      await CmSdkReactNativeV3.checkAndOpen(false);
      console.log('CMPManager initialized and open consent layer opened if necessary');
    } catch (error) {
      console.error('Error initializing consent:', error);
    } finally {
      setIsLoading(false);
    }
};

```

--------------------------------

### Add iOS SDK Dependency with Cocoapods

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide-a59

Update your Podfile to include the new version of the cm-sdk-ios-v3. Run 'pod install --repo-update' to install the dependency.

```bash
pod 'cm-sdk-ios-v3', '3.8.0'
```

```bash
pod install --repo-update
```

--------------------------------

### Initialize CMP SDK (Legacy Version)

Source: https://help.consentmanager.net/books/cmp/page/android-0-migration-guide-31f

Configuration and initialization of the CMP manager for older SDK versions.

```kotlin
class CmpDemoActivity : FragmentActivity() {

    private lateinit var cmpManager: CmpManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val config = CmpConfig.apply {
            id = "<YOUR-CONSENTMANAGER-APP-ID>" // example: b238acdf1a
            domain = "<YOUR-CONSENTMANAGER-APP-DOMAIN>" // example: delivery.consentmanager.net
            appName = "<YOUR-CONSENTMANAGER-APP-NAME>" // example: testApp
            language = "<YOUR-CONSENTMANAGER-APP-LANGUAGE>" // example: DE
        }
        
        cmpManager = CmpManager.createInstance(this, config)
        cmpManager.initialize(this)
    }
}
```

--------------------------------

### Start AppsFlyer SDK within didReceiveMessage Callback

Source: https://help.consentmanager.net/books/cmp/page/android-3rd-party-app-attribution-partners-%28aaps%29

Replace the line inside the didReceiveMessage callback with this code to start the AppsFlyer SDK after user consent is confirmed.

```java
AppsFlyerLib.getInstance().start(this);
```

--------------------------------

### Initialize

Source: https://help.consentmanager.net/books/cmp/page/unity-2-api-documentation

Initializes the consent layer.

```APIDOC
## Initialize

### Description
Initializes the consent layer and checks if the user needs to provide consent. Interacts with the Apple Tracking Transparency API if necessary.

### Parameters
#### Request Body
- **domain** (String) - Required - The domain of the Consent Management Platform.
- **codeId** (String) - Required - The code ID for the application.
- **appName** (String) - Required - The name of the application.
- **language** (String) - Required - The language code (e.g., "EN", "DE").

### Request Example
```csharp
var config = new CmpConfig(CodeId, Domain, AppName, Language);
_cmpManager.Initialize(config);
```
```

--------------------------------

### Get All Vendors

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Retrieves a comma-separated string of all vendor IDs.

```swift
@objc func getAllVendorsAction() {
    if let allPurposes = cmpManager?.getAllVendors() {
        print("Printing all Vendors: \(allPurposes)")
    } else {
        print("Failed to retrieve all vendors.")
    }
}
```

--------------------------------

### CMPManager Constructors

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide

Demonstrates the two main constructors for initializing the CMPManager, with and without CmpConfig, and how to optionally chain callbacks.

```APIDOC
## CMPManager Constructors

### Description
Initializes the CMPManager using one of two constructors. The first constructor takes a `CmpConfig` object, while the second allows for manual configuration of domain, app ID, app name, language, and a view controller. Callbacks can be optionally chained to the manager.

### Method
Initialization

### Endpoint
N/A (Class Initialization)

### Parameters
#### Constructor 1: With CmpConfig
- **cmpConfig** (CmpConfig) - Required - Configuration object for the CMP.
- **viewController** (UIViewController) - Required - The view controller for presenting consent UI.

#### Constructor 2: Without CmpConfig
- **domain** (string) - Required - The domain for the CMP.
- **codeId** (string) - Required - The application's unique code ID.
- **appName** (string) - Required - The name of the application.
- **language** (string) - Required - The language code for the CMP UI.
- **viewController** (UIViewController) - Required - The view controller for presenting consent UI.

#### Optional Chained Callbacks
- **onOpen** (callback) - Optional - Callback function executed when the CMP is opened.
- **onButtonClickedEvent** (callback) - Optional - Callback function executed when a button in the CMP is clicked.
- **onClose** (callback) - Optional - Callback function executed when the CMP is closed.
- **onCmpError** (callback) - Optional - Callback function executed when an error occurs in the CMP.

### Request Example
```swift
// Initialize with CmpConfig
let cmpManager = CMPManager(cmpConfig: cmpConfig, viewController: self)

// Initialize without CmpConfig
let cmpManager = CMPManager(domain: myCmpConfig.domain, codeId: myCmpConfig.appId, appName: myCmpConfig.appName, language: myCmpConfig.language, viewController: self)

// Initialize with chained callbacks
cmpManager = CMPManager.withOpenListener(onOpen)
                       .withOnCmpButtonClickedCallback(onButtonClickedEvent)
                       .withCloseListener(onClose)
                       .withErrorListener(onCmpError)
```

### Response
N/A (Initialization)

```

--------------------------------

### Get All Purposes

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Retrieves a comma-separated string of all purpose IDs.

```swift
@objc func getAllPurposesAction() {
    if let allPurposes = cmpManager?.getAllPurposes() {
        print("All purposes: \(allPurposes)")
        // Additional actions for getAllPurposes function can be added here
    } else {
        print("Failed to retrieve all purposes.")
    }
}
```

--------------------------------

### GET /api/data

Source: https://help.consentmanager.net/books/cmp/page/general-api-action-types

Retrieves one or more entries of a specific model from the database by their IDs. This endpoint is designed for displaying data in an editable form and provides detailed field information in the response. An empty 'ids' array can be sent to get only the field definitions, useful for creating new entries.

```APIDOC
## GET /api/data

### Description
Retrieves one or more entries of a specific model from the database by their IDs. This endpoint is designed for displaying data in an editable form and provides detailed field information in the response. An empty 'ids' array can be sent to get only the field definitions, useful for creating new entries.

### Method
GET

### Endpoint
/api/data

### Parameters
#### Query Parameters
- **model** (string) - Required - The model name to retrieve data from.
- **ids** (array of integer) - Required - An array of IDs for the entries to retrieve. An empty array can be used to fetch field definitions only.

### Request Example
```json
{
  "model": "Subaccount",
  "ids": [542]
}
```

### Response
#### Success Response (200)
- **status** (string) - The status of the operation (e.g., "Success").
- **statuscode** (integer) - The status code of the operation (0 for success).
- **msg** (string) - A message indicating the result of the operation.
- **model** (string) - The name of the model retrieved.
- **action** (string) - The action performed (e.g., "get").
- **data** (object) - An object containing the retrieved data and field information.
  - **fields** (array of objects) - Detailed information about each field in the model.
    - **fieldname** (string) - The internal name of the field.
    - **displayname** (string) - The user-friendly name of the field.
    - **type** (integer) - The data type of the field.
    - **subtype** (integer) - The subtype of the data type.
    - **required** (boolean) - Indicates if the field is mandatory.
    - **defaultvalue** (any) - The default value of the field.
    - **disabled** (boolean) - Indicates if the field is disabled.
    - **infotext** (boolean) - Indicates if informational text is available for the field.
    - **value** (any) - The current value of the field for the retrieved entry.
    - **displayvalue** (string) - The display-ready value of the field.
    - **listkeys** (array) - Keys for enumerated list values.
    - **listvalues** (array) - Display values for enumerated lists.
  - **caption** (string) - A caption for the retrieved data.
  - **groups** (array) - Groups associated with the data.
  - **ids** (array of integer) - The IDs of the retrieved entries.
  - **canDelete** (boolean) - Indicates if the entries can be deleted.
  - **canSave** (boolean) - Indicates if the entries can be saved.
  - **canSaveNew** (boolean) - Indicates if new entries can be saved.

#### Response Example
```json
{
  "status": "Success",
  "statuscode": 0,
  "msg": "Erfolgreich",
  "model": "Subaccount",
  "action": "get",
  "data": {
    "fields": [
      {
        "fieldname": "intID",
        "displayname": "ID",
        "type": 2,
        "subtype": 8,
        "required": true,
        "defaultvalue": null,
        "disabled": false,
        "infotext": false,
        "value": "542",
        "displayvalue": "",
        "listkeys": [],
        "listvalues": []
      },
      {
        "fieldname": "strLogin",
        "displayname": "Nutzername",
        "type": 1,
        "subtype": 0,
        "required": true,
        "defaultvalue": null,
        "disabled": false,
        "infotext": false,
        "value": "aaa",
        "displayvalue": "aaa",
        "listkeys": [],
        "listvalues": []
      },
      {
        "fieldname": "strPass",
        "displayname": "Passwort",
        "type": 1,
        "subtype": 5,
        "required": true,
        "defaultvalue": null,
        "disabled": false,
        "infotext": false,
        "value": "%%unchanged%%",
        "displayvalue": "********",
        "listkeys": [],
        "listvalues": []
      },
      {
        "fieldname": "intStatus",
        "displayname": "Status",
        "type": 2,
        "subtype": 1,
        "required": false,
        "defaultvalue": null,
        "disabled": false,
        "infotext": false,
        "value": "1",
        "displayvalue": "Aktiv",
        "listkeys": [ 0, 1 ],
        "listvalues": [ "Inaktiv", "Aktiv" ]
      }
    ],
    "caption": "User: aaa",
    "groups": [],
    "ids": [ 542 ],
    "canDelete": true,
    "canSave": true,
    "canSaveNew": true
  }
}
```
```

--------------------------------

### SDK v3 Implementation

Source: https://help.consentmanager.net/books/cmp/page/ios-0-migration-guide-a59

Modern implementation using CMPManager for configuration and delegate-based event handling.

```Swift
class DemoAppViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        
        let cmpManager = CMPManager.shared
        cmpManager.setUrlConfig(UrlConfig(id: "YOUR_CODE_ID_HERE", domain: "delivery.consentmanager.net", language: "IT", appName: "CMDemoAppSwift"))
        cmpManager.setWebViewConfig(ConsentLayerUIConfig(
            position: .fullScreen,
            backgroundStyle: .dimmed(.black, 0.5),
            cornerRadius: 5,
            respectsSafeArea: true,
            allowsOrientationChanges: true
        ))

        cmpManager.setPresentingViewController(self)
        cmpManager.delegate = self
        cmpManager.checkAndOpen() { result in
            print("CMPManager initialized and open consent layer opened if necessary")
        }
    }
}
```

```Swift
extension DemoAppViewController: CMPManagerDelegate {
    func didChangeATTStatus(oldStatus: Int, newStatus: Int, lastUpdated: Date?) {
        print("DemoApp received a change in the ATTStatus")

    }
    
    func didReceiveError(error: String) {
        print("DemoApp received consent layer error: \(error)")
    }
    
    func didReceiveConsent(consent: String, jsonObject: [String : Any]) {
        print("DemoApp received consent.")
    }
    
    func didShowConsentLayer() {
        print("DemoApp displayed Consent Layer.")

    }
  
    func didCloseConsentLayer()
        print("DemoApp received close consent message.")
        
        let homeView = HomeView()
        let hostingController = UIHostingController(rootView: homeView)
        self.view.window?.rootViewController = hostingController
    }
}
```

--------------------------------

### Initialize SDK with Config Object

Source: https://help.consentmanager.net/books/cmp/page/reactnative-1-consentmanager-sdk-integration

Initialize the CMP SDK by passing a configuration object to the createInstanceByConfig method.

```javascript
Consentmanager.createInstanceByConfig(yourConfigObject);
```

--------------------------------

### GET /getAllPurposes

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Returns all purposes' IDs. This method consumes no pageviews.

```APIDOC
## GET /getAllPurposes

### Description
Returns all purposes' IDs. This method consumes no pageviews.

### Method
GET

### Endpoint
/getAllPurposes

### Parameters
None.

### Request Example
```javascript
if (let allPurposes = cmpManager?.getAllPurposes()) {
    console.log("All purposes: " + allPurposes)
} else {
    console.log("Failed to retrieve all purposes.")
}
```

### Response
#### Success Response (200)
- **purposes** (string) - A comma-separated string containing all purpose IDs.

#### Response Example
```json
{
  "purposes": "1,2,3,4"
}
```
```

--------------------------------

### Get US Privacy String

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation

Retrieves the US Privacy String.

```APIDOC
## GET /api/us-privacy-string

### Description
Retrieves the US Privacy String, which stores information about disclosures made and choices selected by the website visitor regarding their consumer rights.

### Method
GET

### Endpoint
/api/us-privacy-string

### Parameters
None.

### Response
#### Success Response (200)
- **usPrivacyString** (string) - The US Privacy data set by consentmanager.

#### Response Example
```json
{
  "usPrivacyString": "some_us_privacy_string_value"
}
```
```

--------------------------------

### Get All Vendors List

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Retrieves a list of all vendor IDs as a List<String>.

```swift
@objc func getAllVendorsListAction() {
    if let allVendors = cmpManager?.getAllVendorsList() {
        print("All vendors list: \(allVendors.joined(separator: ", "))")
    } else {
        print("Failed to retrieve all vendors list.")
    }
}
```

--------------------------------

### Initialize CMPManager in Flutter

Source: https://help.consentmanager.net/books/cmp/page/flutter-1-consentmanager-sdk-integration-55a

Demonstrates setting up the CMPManager instance, configuring URL settings, and registering event listeners within a StatefulWidget.

```dart
void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'CMP SDK Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
        useMaterial3: true,
      ),
      home: const MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key});

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  final CMPmanager _cmpManager = CMPManager.instance;
  String _lastAction = '';

  @override
  void initState() {
    super.initState();
    _initializeCMP();
  }

  Future<void> _initializeCMP() async {
    try {
      await _cmpManager.setUrlConfig(
        id: "YOUR-CODE-ID-GOES-HERE",
        domain: "delivery.consentmanager.net", // or any other domain from your CMP dashboard
        appName: "CMDemoAppFlutter", // or any other app name, according to 
        language: "EN",
      );

      _cmpManager.addEventListeners(
        didReceiveConsent: (consent, jsonObject) {
          setState(() => _lastAction = 'Received consent: $consent');
        },
        didShowConsentLayer: () {
          setState(() => _lastAction = 'Consent layer shown');
        },
        didCloseConsentLayer: () {
          setState(() => _lastAction = 'Consent layer closed');
        },
        didReceiveError: (error) {
          setState(() => _lastAction = 'Error: $error');
        },
      );
    } catch (e) {
      setState(() => _lastAction = 'Initialization error: $e');
    }
  }
}
```

--------------------------------

### Get All Purpose List

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Retrieves a list of all purpose IDs as a List<String>.

```swift
@objc func getAllPurposeListAction() {
    // Action for getAllPurposeList function
    if let allPurposes = cmpManager?.getAllPurposesList() {
        print("All purposes list: \(allPurposes.joined(separator: ", "))")
    } else {
        print("Failed to retrieve all purposes list.")
    }
}
```

--------------------------------

### initialize

Source: https://help.consentmanager.net/books/cmp/page/ios-3-api-documentation

Initializes the consent layer and checks if the user needs to provide consent.

```APIDOC
## initialize

### Description
Initialize function will initialize the consent layer and checks automatically if the user needs a consent or not. This function will eventually open the consent layer and will interact with the Apple Tracking Transparency API to ask the user for Consent. This method consumes one pageview.

### Parameters
#### Request Body
- **cmpConfig** (CmpConfig) - Required - The CmpConfig object is passed with the info regarding the appId, Domain, appName and language (optional)

### Response
- **Return** (CMPManager) - The CMPManager object.
```

--------------------------------

### Get Enabled Vendor List

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation

Retrieves a list of all enabled vendors' IDs.

```APIDOC
## GET /api/enabled-vendors/list

### Description
Retrieves a list containing all enabled vendors' IDs.

### Method
GET

### Endpoint
/api/enabled-vendors/list

### Parameters
None.

### Response
#### Success Response (200)
- **enabledVendors** (List<String>) - A list of enabled vendors' IDs.

#### Response Example
```json
{
  "enabledVendors": ["11", "26", "51"]
}
```
```

--------------------------------

### Get Enabled Vendors

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation

Retrieves a comma-separated string of all enabled vendors' IDs.

```APIDOC
## GET /api/enabled-vendors

### Description
Retrieves a comma-separated string containing all enabled vendors' IDs.

### Method
GET

### Endpoint
/api/enabled-vendors

### Parameters
None.

### Response
#### Success Response (200)
- **enabledVendors** (string) - A comma-separated string of enabled vendors' IDs.

#### Response Example
```json
{
  "enabledVendors": "11,26,51"
}
```
```

--------------------------------

### Initialize CMPManager with Configuration

Source: https://help.consentmanager.net/books/cmp/page/google-consent-mode-v2-support-for-inapp-sdks-bca

Initializes the CMPManager with the provided configuration, including URL settings, web view settings, and a delegate. This setup is crucial for the CMP to function correctly.

```kotlin
cmpManager = CMPManager.getInstance(
    context = this,
    urlConfig = urlConfig,
    webViewConfig = webViewConfig,
    delegate = this
)
```

--------------------------------

### Initialize UrlConfig for Consent Manager

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation-371

Configure the URL settings for the Consent Manager. Ensure you replace 'YOUR_CODE_ID_HERE' with your actual Code-ID.

```kotlin
val urlConfig = UrlConfig(
    id = "YOUR_CODE_ID_HERE",
    domain = "delivery.consentmanager.net",
    language = "EN",
    appName = "CMDemoAppKotlin"
)
```

--------------------------------

### Get Enabled Purpose List

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation

Retrieves a list of all enabled purposes' IDs.

```APIDOC
## GET /api/enabled-purposes/list

### Description
Retrieves a list containing all enabled purposes' IDs.

### Method
GET

### Endpoint
/api/enabled-purposes/list

### Parameters
None.

### Response
#### Success Response (200)
- **enabledPurposes** (List<String>) - A list of enabled purposes' IDs.

#### Response Example
```json
{
  "enabledPurposes": ["2", "4", "6"]
}
```
```

--------------------------------

### Initialize Services Based on User Consent

Source: https://help.consentmanager.net/books/cmp/page/consent-management-guideline-for-mobile-apps

This hypothetical example demonstrates how to conditionally initialize services like OneSignal, AdMob, and Firebase Analytics based on user consent status. It checks if a consent decision exists and if consent is granted for specific purposes before initializing each service.

```string
// This hypothetical example assumes you have implemented:
//   - OneSignal (s1448)
//   - Google Ads/AdMob (s1)
//   - Google Analytics (s26)

```

```string
class yourGreatApp {
    void function onAppLaunch() {
        if shouldInitializeService("s148") {
            OneSignal.initialize("your-token")
        }
    
        if shouldInitializeService("s1") {
            AdMobService.initialize()
        }
    
        if shouldInitializeService("s26") {
            FirebaseAnalytics.initializeApp("your-token")
        }   
    }
    
    
    boolean private function shouldInitializeService(string: purposeId):
        // Phase 1: Check if user has made any decision
        consentStatus = CMPManager.getUserStatus()
        if consentStatus.status = "choiceDoesntExist"
            return false  // Consent Layer was not yet displayed to this client
        
        return CMPManager.shared.getStatusForPurpose(id: purposeId) == "granted"
    }
}
```

--------------------------------

### Get Enabled Purposes

Source: https://help.consentmanager.net/books/cmp/page/android-2-api-documentation

Retrieves a comma-separated string of all enabled purposes' IDs.

```APIDOC
## GET /api/enabled-purposes

### Description
Retrieves a comma-separated string containing all enabled purposes' IDs.

### Method
GET

### Endpoint
/api/enabled-purposes

### Parameters
None.

### Response
#### Success Response (200)
- **enabledPurposes** (string) - A comma-separated string of enabled purposes' IDs.

#### Response Example
```json
{
  "enabledPurposes": "2,4,6"
}
```
```

--------------------------------

### Show Welcome Screen using __cmp

Source: https://help.consentmanager.net/books/cmp/page/javascript-api

Displays the welcome screen for consent management. This may depend on the visitor's location and account setup.

```javascript
__cmp('showScreen')
```

--------------------------------

### Initialize Consentlayer

Source: https://help.consentmanager.net/books/cmp/page/android-0-migration-guide

Use the initialize() method on the instance returned by createInstance() to check for the consentlayer.

```java
createInstance(
    applicationContext,
    CMP_ID,
    CMP_DOMAIN,
    CMP_APP_NAME,
    LANG
).initialize(this)
```
Tokens:
Raw