Utiq

https://docs.utiq.com/docs/
Admin
Utiq is a technology platform that provides privacy-compliant solutions for data activation and...
Tokens:112,203
Snippets:880
Trust Score:8.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install iOS SDK via CocoaPods

Source: https://docs.utiq.com/docs/ios-sdk

Add the UTIQ pod to your project's Podfile and install it using the CocoaPods command-line tool. Ensure you are using the latest stable version or update if necessary.

```bash
cd {PATH_TO_YOUR_PROJECT}
pod install
```

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

### Consent Experience

Source: https://docs.utiq.com/docs/web-sdk-integration

Guides the integration of Utiq consent within the native app, including initial consent, SDK loading, and passing consent/ATT choices to the Web SDK.

```APIDOC
## Consent Experience

### Description
This section outlines the steps for handling user consent for Utiq within a native application. It covers the initial consent flow, loading the Utiq Web SDK, and ensuring correct consent and ATT (App Tracking Transparency) choices are passed to the SDK.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

## Load Utiq Web SDK

### Description
Instructions for loading the Utiq Web SDK within a WebView, configuring it to avoid separate pop-ups, and passing necessary consent and ATT information.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

## Pass Utiq Consent to Web SDK

### Description
Details on how to use the `handleConsentChange(true)` API to notify the Utiq Web SDK when Utiq consent has been granted, triggering relevant workflows.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
// Assuming 'utiuWebSDK' is initialized and available
utiuWebSDK.handleConsentChange(true);
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A

## Store Utiq IDs on App Native Storage

### Description
Guidance on retrieving `martechpass` and `adtechpass` from the WebView's localStorage using `getIdGraphEntry()` and storing them in the app's native local storage.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
// Assuming 'utiuWebSDK' is initialized and available
const utiqIds = utiuWebSDK.getIdGraphEntry();
// Store utiqIds.martechpass and utiqIds.adtechpass in native storage
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

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

### Start Didomi and Observe Consent Status (Swift)

Source: https://docs.utiq.com/docs/ios-sdk

Starts the Didomi SDK and observes its consent status. The `forceStart` parameter, when set to `true`, ensures that Didomi is started even if it has already been initialized. This function is used to update Didomi's status.

```swift
self.startDidomiAndObserveConsentStatus(forceStart: true)

```

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

### Install iOS SDK via Swift Package Manager

Source: https://docs.utiq.com/docs/ios-sdk

Integrate the Utiq iOS SDK into your project using the Swift Package Manager by adding the provided GitHub repository URL to your Xcode project's package dependencies.

```text
https://github.com/UtiqTech/ios-sdk
```

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

### Initialize and Manage Didomi SDK in Kotlin

Source: https://docs.utiq.com/docs/android-sdk

Encapsulates Didomi SDK functionalities within a singleton class. Handles initialization with API keys and notice IDs, sets log levels, and manages event listeners for consent status changes and errors. It also provides methods to start the UI, check if the user has started before, and reset consent.

```kotlin
object DidomiSdk {

    private var isUtiqVendorEnabled = false
    private var isUtiqPurposeEnabled = false
    private val didomi = Didomi.getInstance()
    private lateinit var didomiEventListener: EventListener

    init {
        this.didomi.setLogLevel(Log.VERBOSE)
    }

    fun initialize(application: UtiqApplication) {
        /*
        The SDK will automatically use the remote configuration
        hosted by Didomi and cache it locally.
        The cached version is refreshed every 60 minutes.
        Config file example
            {
              "app": {
                "name": "My App Name",
                "privacyPolicyURL": "http://www.website.com/privacy",
                "vendors": {
                      "iab": {
                           "all": true
                       }
                },
                "gdprAppliesGlobally": true,
                "gdprAppliesWhenUnknown": true
              }
           }
       */
        val initializeParameters = DidomiInitializeParameters(
            apiKey = YOUR_API_KEY_GOES_HERE,
            null,
            null,
            null,
            false,
            null,
            noticeId = YOUR_NOTICE_ID_GOES_HER
        )
        this.didomi.initialize(application, initializeParameters)
        this.onInitialized {
            val currentUserStatus = this.didomi.currentUserStatus
            this.isUtiqVendorEnabled = currentUserStatus.vendors.entries.first { it.key.contains("utiq", false) }.value.enabled
            this.isUtiqPurposeEnabled = currentUserStatus.purposes.entries.first { it.key.contains("utiq", false) }.value.enabled
        }
        this.onError {
            Log.e("DemoApp", "Error while initializing Didomi SDK")
        }
    }

    fun startIfNeeded(activity: FragmentActivity, forceStart: Boolean) {
        this.onInitialized {
            if (forceStart)
                this.didomi.forceShowNotice(activity)
            else
                this.didomi.setupUI(activity)
        }
    }

    fun startedBefore() = !this.didomi.shouldUserStatusBeCollected()

    fun isUtiqEnabled() = this.isUtiqVendorEnabled && this.isUtiqPurposeEnabled

    fun reset() {
        this.didomi.reset()
    }

    fun resetUtiq() {
        onInitialized {
            val currentUserStatus = this.didomi.currentUserStatus
            /*
              If you want to hardcode the ID, The vendor ID
              can also be found in the Didomi's console in the Data Manager
              section, select the VENDORS tab, then search for the vendor
              you want to enable or disable, and the APP ID is the vendor ID.
            */
            val utiqVendorId = currentUserStatus.vendors.keys.first { it.contains("utiq") }
            /*
              If you want to hardcode the ID, The purpose ID
              can also be found in the Didomi's console in the Data Manager
              section, select the Purposes tab, then search for the purpose
              you want to enable or disable and the APP ID is the purpose ID.
            */
            val utiqPurposeId = currentUserStatus.purposes.keys.first { it.contains("utiq") }
            this.didomi.openCurrentUserStatusTransaction()
                .disableVendor(utiqVendorId)
                .disablePurpose(utiqPurposeId)
                .commit()
        }
    }

    fun onConsentStatusChange(action: (enabled: Boolean) -> Unit) {
        /*
        Listen for changes on the user status linked to a specific vendor.
        We always need to listen for changes from Didomi as the user
        might open the screen from another place and reject his consent
        that he granted before, in this case we need to keep the synchronization
        between Didomi and Utiq
         */
        this.onInitialized {
            if (!::didomiEventListener.isInitialized) {
                this.didomiEventListener = this.createDidomiEventListener(action)
                this.didomi.addEventListener(this.didomiEventListener)
            }
        }
    }

    fun onError(errorAction: (errorMessage: String) -> Unit) {
        this.didomi.addEventListener(object : EventListener() {
            override fun error(event: ErrorEvent) {
                super.error(event)
                errorAction(event.errorMessage!!)
            }
        })
    }

    fun onInitialized(action: () -> Unit) {
        this.didomi.onReady(action)
    }

    private fun createDidomiEventListener(action: (enabled: Boolean) -> Unit) = object : EventListener() {


```

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

### Initialize SDK (Basic)

Source: https://docs.utiq.com/docs/android-sdk

Initializes the Utiq SDK with the application context and an SDK token. This should be called within the onCreate() method of your Application class.

```kotlin
Utiq.initialize(this, SDK_TOKEN)
```

```java
Utiq.initialize(this, SDK_TOKEN);
```

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

### Start Didomi SDK and Observe Consent Changes in Kotlin

Source: https://docs.utiq.com/docs/android-sdk

This Kotlin function initializes the Didomi SDK and sets up a listener for consent status changes. When consent is accepted, it clears Utiq data, sets a stub token (for testing), accepts Utiq consent, and fetches Utiq IDs. If consent is rejected, it rejects Utiq consent. This function requires an Activity context and a boolean to force start.

```kotlin
private fun startDidomiAndObserveConsentStatus(forceStart: Boolean) {
        DidomiSdk.apply {
            startIfNeeded(requireActivity(), forceStart)
            onConsentStatusChange { accepted ->
                if (accepted) {
                    Utiq.clearData()
                    // Only use stub if you are testing and do not have an eligible SIM card
                    stubToken = YOUR_STUB_TOKEN_GOES_HERE
                    Utiq.acceptConsent()
                    fetchUtiqIds()
                } else {
                    rejectUtiqConsent()
                    // Do any further actions if needed
                }
            }
        }
    }
```

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

### Start Didomi and Observe Consent Status (Swift)

Source: https://docs.utiq.com/docs/ios-sdk

This Swift function initializes the Didomi SDK if needed and sets up a listener for consent status changes. Upon acceptance, it clears UTIQ data, accepts UTIQ consent (optionally using a stub token for testing), and fetches UTIQ IDs. If consent is rejected, it rejects UTIQ consent. Dependencies: Didomi SDK, UTIQ SDK.

```swift
private func startDidomiAndObserveConsentStatus(forceStart: Bool) {
        DidomiSdk.shared.startIfNeeded(viewController: self, forceStart: forceStart)
        DidomiSdk.shared.consentStatusDidChange { accepted in
            if (accepted) {
                try? Utiq.shared.clearData()
                // Only use stub if you are testing and do not have an eligible SIM card
                self.stubToken = YOUR_STUB_TOKEN_GOES_HERE
                try? Utiq.shared.acceptConsent()
                self.fetchUtiqIds()
            } else {
                self.rejectUtiqConsent()
               // Do any further actions if needed
            }
        }
    }
```

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

### Initialize SDK (Custom Options)

Source: https://docs.utiq.com/docs/android-sdk

Initializes the Utiq SDK with custom options, such as enabling logging and setting a fallback configuration. This allows for more control over SDK behavior.

```kotlin
val fallbackConfigJson : String = "{ /* fallbackConfigJson */ }"
val options = UtiqOptions().enableLogging().setFallBackConfigJson(fallbackConfigJson)
Utiq.initialize(this, SDK_TOKEN, options)
```

```java
String fallbackConfigJson = "{ /* fallbackConfigJson */ }";
UtiqOptions options = new UtiqOptions().enableLogging().setFallBackConfigJson(fallbackConfigJson);
Utiq.initialize(this, SDK_TOKEN, options);
```

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

### Consent Synchronization

Source: https://docs.utiq.com/docs/web-sdk-integration

Describes how to synchronize user consent status changes originating from the Utiq Consent Hub with the native application and Web SDK.

```APIDOC
## Consent Synchronization

### Description
This section covers synchronizing user consent status when a user revokes consent via the Utiq Consent Hub (`consenthub.utiq.com`). It involves listening for consent updates from the Web SDK and managing consent and IDs in both WebView and native storage.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
// Assuming 'utiuWebSDK' is initialized and available
utiuWebSDK.onConsentUpdateFinished = (isValid) => {
  if (isValid === false) {
    // Web SDK deletes Utiq IDs from WebView
    // Delete Utiq consent from native app
    deleteUtiqConsentFromNativeStorage(); // Implement this function
    // Delete Utiq IDs from native app
    deleteUtiqIdsFromNativeStorage(); // Implement this function
  } else {
    // Web SDK updates Utiq IDs on WebView
    // Update Utiq IDs on native app
    updateUtiqIdsInNativeStorage(); // Implement this function
  }
};
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

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

### iOS ATT Synchronization

Source: https://docs.utiq.com/docs/web-sdk-integration

Explains how to synchronize Apple's App Tracking Transparency (ATT) status changes with the Utiq Web SDK and native storage.

```APIDOC
## iOS ATT Synchronization

### Description
This section details the process of synchronizing Apple's App Tracking Transparency (ATT) status changes with the Utiq integration. It covers checking ATT status on app start, updating the WebView, and managing `AdTechPass` in native storage.

### Method
N/A (Client-side implementation)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```javascript
// On app start, check ATT status
const attStatus = checkAttStatus(); // Implement this function based on iOS SDK

if (attStatus === 'rejected') {
  // Pass ATT choice to WebView
  webView.postMessage({ type: 'ATT_STATUS_UPDATE', payload: 'rejected' });
  // Remove AdTechPass from native storage
  removeAdTechPassFromNativeStorage(); // Implement this function
} else {
  // Pass ATT choice to WebView if accepted or not determined
  webView.postMessage({ type: 'ATT_STATUS_UPDATE', payload: 'accepted' });
}
```

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

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

### Check if iOS SDK is Initialized

Source: https://docs.utiq.com/docs/ios-sdk

Verify if the Utiq SDK has been successfully initialized before calling other SDK functions. This prevents potential errors if the SDK is not ready.

```swift
Utiq.shared.isInitialized()
```

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

### Add Current Repository (Groovy/Kotlin DSL)

Source: https://docs.utiq.com/docs/android-sdk

Configures the Maven repository for current versions of the SDK (0.1.76+). This should be added to your project's or settings.gradle file.

```groovy
allprojects {
   repositories {
      maven {
         url 'https://maven.pkg.github.com/UtiqTech/android-sdk'
      }
   }
}
```

```kotlin
allprojects {
   repositories {
       maven (url = uri("https://maven.pkg.github.com/UtiqTech/android-sdk"))
   }
}
```

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

### Add Legacy Repository (Groovy/Kotlin DSL)

Source: https://docs.utiq.com/docs/android-sdk

Configures the Maven repository for legacy versions of the SDK (before 0.1.76). This is typically added to the project's or settings.gradle file.

```groovy
allprojects {
   repositories {
      maven {
         url 'https://jitpack.io'
      }
   }
}
```

```kotlin
allprojects {
   repositories {
       maven (url = uri("https://jitpack.io"))
   }
}
```

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

### Synchronize Didomi Status with UTIQ (Swift)

Source: https://docs.utiq.com/docs/ios-sdk

This Swift code synchronizes Didomi's consent status with UTIQ. It initializes Didomi and checks if it was started previously. If Didomi is enabled and started, it accepts UTIQ consent (using a stub token if provided for testing) and fetches UTIQ IDs. Otherwise, it starts Didomi or handles rejected consent. Dependencies: Didomi SDK, UTIQ SDK.

```swift
DidomiSdk.shared.didInitialize {
            if (DidomiSdk.shared.startedBefore()) {
                if (DidomiSdk.shared.isUtiqEnabled()) {
                    // Only use stub if you are testing and do not have an eligible SIM card
                    self.stubToken = YOUR_STUB_TOKEN_GOES_HERE
                    try? Utiq.shared.acceptConsent()
                    self.fetchUtiqIds()
                } else {
                    // Didomi Consent was rejected before, Utiq will not start!
                }
            } else {
                self.startDidomiAndObserveConsentStatus(forceStart: false)
            }
        }
```

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

### Initialize iOS SDK with Custom Options

Source: https://docs.utiq.com/docs/ios-sdk

Initialize the Utiq SDK with custom options, such as enabling logging or setting a fallback configuration JSON. This allows for more granular control over SDK behavior.

```swift
let fallbackConfigJson : String = "{ /* fallbackConfigJson */ }"
let options = UtiqOptions().enableLogging().setFallBackConfigJson(json: configJsonString)
Utiq.shared.initialize(sdkToken: "test123", options: options)
```

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

### Get Utiq ConsentHub URL (Kotlin & Java)

Source: https://docs.utiq.com/docs/android-sdk

Retrieves the ConsentHub URL, which can be used in a web view. A stub token can be passed if not using a supported SIM.

```kotlin
Utiq.getConsentHubUrl()
```

```java
Utiq.getConsentHubUrl();
```

```kotlin
Utiq.getConsentHubUrl(stubToken: STUB_TOKEN)
```

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

### Initialize iOS SDK (Basic)

Source: https://docs.utiq.com/docs/ios-sdk

Initialize the Utiq SDK in your AppDelegate or main application class using your provided SDK token. This is a fundamental step before utilizing other SDK functionalities.

```swift
Utiq.shared.initialize(sdkToken: SDK_TOKEN)
```

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

### Integrate Utiq Loader and Management Scripts in HTML

Source: https://docs.utiq.com/docs/manage-utiq-page

A minimal HTML example demonstrating the integration of Utiq's loader and management scripts. It includes necessary configurations for the Utiq loader and custom styling.

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <script>
      window.Utiq ||= {};
      window.Utiq.config = {
        CMP: "", // Only if you use Integrated Model
        cmpUtiqPurposeId: "", // Only if you use Integrated Model
        cmpUtiqVendorId: "", // Only if you use Integrated Model
        customizationOptions: {
          language: "en" // Optional attribute. Allowed values: en, de, es, fr or it
        }
      };
      (() => {
        const s = document.createElement("script")
        s.type = 'text/javascript';
        s.src = "https://utiq.example.com/utiqLoader.js"
        s.async = true;
        document.head.appendChild(s)
      })();
      (() => {
        const s = document.createElement("script")
        s.type = 'text/javascript';
        s.src = "https://utiq.example.com/utiqManagePage.js"
        s.async = true;
        document.head.appendChild(s)
      })();
    </script>
    <style>
      /* Example Manage Utiq CSS Styles */
  
      #utiq-manage-page h2,
      #utiq-manage-page p,
      #utiq-manage-page a,
      #utiq-manage-page li {
        font-family: "Poppins", "Century Gothic", "Arial", sans-serif;
      }
  
      #utiq-manage-page h2 {
        font-size: 1.5em;
      }
  
      #utiq-manage-page a {
        color: #db214f;
      }
  
      #utiq-manage-page a:hover {
        color: #7a0320;
      }
  
    </style>
    <title>Manage Utiq</title>
  </head>
  <body>
    <h1>Manage your Utiq technology consents</h1>
    <div id="utiq-manage-page"></div>
  </body>
</html>
```

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

### Get ConsentHub URL (Swift)

Source: https://docs.utiq.com/docs/ios-sdk

Retrieves the ConsentHub URL, which can be used within a web view in the mobile app. An optional stub token can be passed if not using an eligible SIM.

```swift
Utiq.shared.consentHubUrl()
```

```swift
Utiq.shared.consentHubUrl(stubToken: STUB_TOKEN)
```

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

### Synchronize Didomi and Utiq Consent Status in Kotlin

Source: https://docs.utiq.com/docs/android-sdk

This Kotlin code snippet synchronizes Didomi's consent status with Utiq upon Didomi SDK initialization. If Didomi was started previously and Utiq is enabled within Didomi, it accepts Utiq consent and fetches IDs using a stub token if provided. Otherwise, it starts the Didomi SDK observation process. This ensures Utiq's consent state reflects Didomi's settings.

```kotlin
 DidomiSdk.onInitialized {
                if (DidomiSdk.startedBefore()) {
                    if (DidomiSdk.isUtiqEnabled()) {
                        // Only use stub if you are testing and do not have an eligible SIM card
                        stubToken = YOUR_STUB_TOKEN_GOES_HERE
                        Utiq.acceptConsent()
                        fetchUtiqIds()
                    } else
                       // Didomi Consent was rejected before, Utiq will not start!
                } else
                    startDidomiAndObserveConsentStatus(false)
            }
```

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

### Implement 'Manage Utiq' Modal via JavaScript

Source: https://docs.utiq.com/docs/2-setup-the-dedicated-manage-utiq-page-linked-via-

This code snippet demonstrates how to implement the 'Manage Utiq' modal by adding a hyperlink to the footer. When clicked, it triggers the Utiq SDK's consent modal functionality. Ensure the Utiq SDK is properly initialized before this link is used.

```html
<a id="utiq__modal-manager" href="javascript:window.Utiq.queue.push(() => window.Utiq.API.showConsentModal())">Manage Utiq</a>
```

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

### Configure `onInitialised` Event Listener

Source: https://docs.utiq.com/docs/event-listeners

Sets up a listener for the `onInitialised` event, which fires when Utiq is fully initialized. This example shows how to configure a single callback or an array of callbacks using the configuration object.

```javascript
window.Utiq ||= {};
window.Utiq.config = {
  listeners: {
    onInitialised: () => {
      // Single callback action
    }
  }
};

window.Utiq ||= {};
window.Utiq.config = {
  listeners: {
    onInitialised: [
      () => {
        // First callback action
      },
      () => {
        // Second callback action
      }
    ]
  }
};
```

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

### Reject Utiq Consent and Clear Data (Swift)

Source: https://docs.utiq.com/docs/ios-sdk

Rejects Utiq consent and clears Utiq data. This function is intended to be called when a user manually rejects Utiq consent from within the app, for example, from a 'Manage Utiq' page. It includes an optional `postAction` closure to execute after consent rejection and data clearing.

```swift
private func rejectUtiqConsent(postAction: @escaping () -> () = {}) {
    Utiq.shared.rejectConsent {
        try? Utiq.shared.clearData()
        postAction()
    } errorCallback: {
        // Handle the error
    }
}

```

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

### Initialize Didomi SDK in Swift

Source: https://docs.utiq.com/docs/ios-sdk

Initializes the Didomi SDK with provided API key and notice ID. It also sets up event listeners for initialization completion and errors, and checks the initial consent status for the 'utiq' vendor and purpose.

```swift
import OSLog
import Didomi

class DidomiSdk {
    
    private var didomiEventListener: EventListener?
    private var isUtiqVendorEnabled = false
    private var isUtiqPurposeEnabled = false
    private let didomi = Didomi.shared
    //
    static let shared = DidomiSdk()
    
    private init() {
        self.didomi.setLogLevel(minLevel: OSLogType.default.rawValue)
    }
    
    func initialize() {
        /*
            The SDK will automatically use the remote configuration
            hosted by Didomi and cache it locally.
            The cached version is refreshed every 60 minutes.
            Config file example
                {
                   "app": {
                   "name": "My App Name",
                   "privacyPolicyURL": "http://www.website.com/privacy",
                   "vendors": {
                       "iab": {
                          "all": true
                        }
                   },
                   "gdprAppliesGlobally": true,
                   "gdprAppliesWhenUnknown": true
                  }
               }
        */
        let initializeParameters = DidomiInitializeParameters(
            apiKey: "5252a0d1-edad-4c60-8103-82aa49bd5432",
            localConfigurationPath: nil,
            remoteConfigurationURL: nil,
            providerID: nil,
            disableDidomiRemoteConfig: false,
            languageCode: nil,
            noticeID: "3RDba8E8"
        )
        self.didomi.initialize(initializeParameters)
        self.didInitialize {
            let currentUserStatus = self.didomi.getCurrentUserStatus()
            self.isUtiqVendorEnabled = currentUserStatus.vendors.first(where: { $0.key.lowercased().contains("utiq") })?.value.enabled ?? false
            self.isUtiqPurposeEnabled = currentUserStatus.purposes.first(where: { $0.key.lowercased().contains("utiq") })?.value.enabled ?? false
        }
        self.onError {
            os_log("Error while initializing Didomi SDK", log: .default, type: .error, $0)
        }
    }
    
    func startIfNeeded(viewController: UIViewController, forceStart: Bool) {
        self.didInitialize {
            self.didomi.setupUI(containerController: viewController)
            if (forceStart) {
                self.didomi.forceShowNotice()
            }
        }
    }
    
    func startedBefore() -> Bool {
        !self.didomi.shouldUserStatusBeCollected()
    }
    
    func isUtiqEnabled() -> Bool {
        self.isUtiqVendorEnabled && self.isUtiqPurposeEnabled
    }
    
    func reset() {
        self.didomi.reset()
    }
    
    func resetUtiq() {
        self.didInitialize {
            let currentUserStatus = self.didomi.getCurrentUserStatus()
            /*
             If you want to hardcode the ID, The vendor ID
             can also be found in the Didomi's console in the Data Manager
             section, select the VENDORS tab, then search for the vendor
             you want to enable or disable, and the APP ID is the vendor ID.
             */
            let utiqVendorId = currentUserStatus.vendors.keys.first { $0.lowercased().contains("utiq") }
            /*
             If you want to hardcode the ID, The purpose ID
             can also be found in the Didomi's console in the Data Manager
             section, select the Purposes tab, then search for the purpose
             you want to enable or disable and the APP ID is the purpose ID.
             */
            let utiqPurposeId = currentUserStatus.purposes.keys.first { $0.lowercased().contains("utiq") }
            if(utiqVendorId != nil && utiqPurposeId != nil) {
                _ = self.didomi.openCurrentUserStatusTransaction()
                    .disableVendor(utiqVendorId!)
                    .disablePurpose(utiqPurposeId!)
                    .commit()
            }
        }
    }
    
    func consentStatusDidChange(action: @escaping (_ enabled: Bool) -> ()) {
        /*
         Listen for changes on the user status linked to a specific vendor.
         We always need to listen for changes from Didomi as the user
         might open the screen from another place and reject his consent
         that he granted before, in this case we need to keep the synchronization
         between Didomi and Utiq
         */
        self.didInitialize {
            if (self.didomiEventListener == nil) {
                self.didomiEventListener = self.createDidomiEventListener(action: action)
            }
            else {
                self.didomi.removeEventListener(listener: self.didomiEventListener!)
            }

```

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

### Add Internet Permission

Source: https://docs.utiq.com/docs/android-sdk

Declares the necessary internet permission in the AndroidManifest.xml file, allowing the SDK to access network resources.

```xml
<uses-permission android:name="android.permission.INTERNET"/>
```

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

### UTIQ Initialization Script

Source: https://docs.utiq.com/docs/integrated-model-utiq-cmp-apis

This section provides the JavaScript snippet for loading the UTIQ SDK into your website.

```APIDOC
## UTIQ Initialization Script

### Description
This script loads the UTIQ SDK. Ensure this script is included in your website's HTML to enable UTIQ functionality.

### Method
N/A (Client-side JavaScript)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```javascript
window.Utiq.config = {
  CMP: 'none',
};

(() => {
  const a = document.createElement('script');
  a.type = 'text/javascript';
  a.src = 'https://utiq.example.com/utiqLoader.js';
  document.head.appendChild(a);
})();
```

### Response
N/A
```
Tokens:
Raw