[Jedność] 1. consentmanager Integracja SDK

[Jedność] 1. consentmanager Integracja SDK

W tym dokumencie znajdziesz ogólne informacje na temat integracji naszego SDK z Twoim projektem. Więcej szczegółów znajdziesz w naszym Dokumentacja API dokumentacja.

1. Instalacja

Kurs consentmanager SDK dla aplikacji na Androida implementuje i zapewnia funkcjonalność informowania użytkownika o ochronie danych oraz pytania i zbierania zgody od użytkownika. Umożliwia programistom aplikacji łatwą integrację consentmanager usługi do swojej aplikacji. Jako główne funkcje zapewniamy:

• Obsługuje platformy iOS i Android.
• Most łączący Unity z natywnymi, specyficznymi dla platformy funkcjonalnościami CMP.
• Łatwy sposób na inicjalizację, zarządzanie zgodą użytkownika i obsługę danych związanych z prywatnością.

Jeśli chodzi o kompatybilność, mamy:

• Unity 20XX.XX lub nowsza wersja
• iOS (przez DllImport)
• Android (przez JNI)

Kroki - wysoki poziom

Consent Manager Diagram sekwencji zestawu SDK dostawcy

Aby zilustrować powyższe kroki, sprawdźmy na poniższym diagramie trzy możliwe przepływy sekwencji SDK. 

1. Podczas tworzenia instancji przy użyciu Initialize() funkcji, istnieją dwa możliwe wyniki. Pierwsza ma miejsce, gdy interfejs API zgody informuje zestaw SDK, że CMP nie zostanie otwarty, co powoduje wyzwolenie OnCmpNotOpenedWywołanie zwrotne. Drugim rezultatem jest otwarcie warstwy zgody, co pozwala użytkownikowi na interakcję z nią, a to wyzwala OnOpenCallback. Po wyrażeniu przez użytkownika zgody i przetworzeniu zgody, OnCmpCloseOddzwonienie nazywa się.

Należy pamiętać, że Przy oddzwonieniu po błędzie jest reprezentowany przez czerwone przerywane linie strzałek, aby podać przykłady błędów, które mogą wystąpić podczas procesu.

2. Tworzenie instancji i wywoływanie OpenConsentLayerOnCheck funkcje doprowadzą do podobnego procesu. Różnica polega na tym, że oddzielając tworzenie instancji od sprawdzania API zgody, zyskujesz możliwość dodawania logiki biznesowej i interakcji z API bibliotek.

3. Tworzenie instancji i wywoływanie OpenConsentLayer funkcja otworzy warstwę bez sprawdzania pliku consentmanager, jeśli to konieczne. Jeśli jest już wyrażona zgoda, opcje i ustawienia zostaną pokazane użytkownikowi. Przebieg procesu będzie wyglądał następująco:

Więcej informacji na temat naszego przeglądu wersji pakietu SDK i dziennika zmian można znaleźć w artykule pod tym linkiem.

Importowanie pakietu SDK

Wszystko możesz skonfigurować w zaledwie dwóch krokach.

• • Pobierz najnowszą wersję Wtyczki.
  • Zaimportuj pakiet do projektu Unity przy użyciu opcji Zasoby > Importuj pakiet > Pakiet niestandardowy.

Skonfiguruj JSON

W pliku CmpSdkConfig.json możesz ustawić natywną wersję SDK dla iOS i Androida, która będzie używana w procesie kompilacji: 

Znajdź kompatybilne natywne wersje SDK tutaj: 

{
  "displayName": "Consentmanager SDK",
  "name": "CmpSdk",
  "androidBasePath": "net.consentmanager.sdk",
  "version": "1.0.0",
  "androidLibraryVersion": "x.xx.x",
  "iosLibraryVersion": "x.xx.x",
  "description": "Unity plugin helps you to use native Consentmanager functionality on Android and iOS."
}

Ustawienia kompilacji

Aby zmienić ustawienia kompilacji, przejdź do Window -> CmpSdk 

Ustawienia kompilacji iOS

• Włącz skrypt kompilacji iOS: Przełącz tę opcję, aby włączyć lub wyłączyć skrypt kompilacji odpowiedzialny za integrację zestawu SDK systemu iOS z projektem Unity.
• Ścieżka xcFramework: Określ ścieżkę do katalogu xcFramework. Ścieżkę tę można edytować bezpośrednio lub przeglądać za pomocą dołączonego przycisku.
• Dołącz znacznik wersji: Po włączeniu dołącza wersję zestawu SDK systemu iOS do ścieżki xcFramework, umożliwiając konfiguracje specyficzne dla wersji.
• Wynikowa ścieżka struktury: Wyświetla w pełni rozpoznaną ścieżkę do xcFramework, w tym wersję zestawu SDK, jeśli uwzględniono znacznik wersji.
• Włącz przejrzystość śledzenia aplikacji: Przełącz tę opcję, aby włączyć funkcję przejrzystości śledzenia aplikacji dla systemu iOS, która jest niezbędna do uzyskania zgody użytkownika zgodnie z wytycznymi dotyczącymi prywatności w systemie iOS.
• Wiadomość o zgodzie na przejrzystość śledzenia aplikacji: Pole tekstowe umożliwiające wprowadzenie niestandardowej wiadomości wyświetlanej użytkownikom podczas żądania zgody na śledzenie. Komunikat ten powinien być jasny i zwięzły oraz wyjaśniać, dlaczego potrzebna jest zgoda.

Ustawienia kompilacji Androida

• Włącz skrypt kompilacji Androida: Przełącz, aby włączyć lub wyłączyć skrypt kompilacji służący do integracji zestawu SDK systemu Android z projektem Unity. 
• Zintegruj układ niestandardowy: Po włączeniu tej opcji umożliwia użycie niestandardowego układu warstwy zgody dla fragmentu UIView.
  

  Jeśli chcesz użyć niestandardowego układu z fragmentami, upewnij się, że Twój projekt Unity dodaje appcompat zależność. Dodaj niestandardowy szablon główny: 
  Zasoby/Wtyczki/Android/mainTemplate.gradle
  i dodaj zależność:
  implementacja „androidx.appcompat:appcompat:1.xx”

2. Inicjowanie pakietu SDK

Wykonaj poniższe kroki, aby rozpocząć korzystanie z wtyczki.

Inicjowanie narzędzia ConsentTool — automatycznie

W ramach startu aplikacji (zwykle zwykły override onCreate() funkcja) , musisz utworzyć instancję klasy CMPConsentTool. Plik initialize() funkcja automatycznie pobierze niezbędne dane z naszego serwera i określi, czy należy wyświetlić ekran zgody, czy nie. Jeśli tak, SDK automatycznie wyświetli w tym momencie ekran zgody, zbierze dane i przekaże je aplikacji. Instancję można następnie wykorzystać w celu uzyskania szczegółów zgody z zestawu SDK w celu wykorzystania jej w aplikacji.

Przykład inicjalizacji z wykorzystaniem automatycznego zachowania pliku Initialize() Metoda.  

public string codeId = "<YOUR-CONSENTMANAGER-APP-ID>", // example: b238acdf1a
public string domain = "<YOUR-CONSENTMANAGER-APP-DOMAIN>", // example: delivery.consentmanager.net
public string appName = "<YOUR-CONSENTMANAGER-APP-NAME>", // example: testApp
public string language = "<YOUR-CONSENTMANAGER-APP-LANGUAGE>" // example: DE

CmpManager.Instance.Initialize(domain, codeId, appName, language);                

W razie zamówieenia projektu domain użyj domeny serwera znalezionej w twoim consentmanager konto pod Menu > CMP > Uzyskaj kody do aplikacji. Forum codeID użyj Code-ID znajdującego się na tej samej stronie w Twoim koncie consentmanger. appName można użyć w celu rozróżnienia różnych aplikacji w consentmanager raportowanie. Dla languagemożesz użyć pustego ciągu znaków ("") do automatycznego wykrywania lub 2-literowego kodu języka ("EN", "DE", "FR" itd.).

Inicjowanie narzędzia ConsentTool — ręcznie

Ze względu na elastyczność pakiet SDK oferuje sposób ręcznego wyświetlania warstwy zgody, jak pokazano poniżej: 

bool isConsentRequired = await _cmpManager.CheckConsentIsRequired();
if (isConsentRequired)
{
	_cmpManager.OpenConsentLayer();
}

3. Korzystanie z SDK

Sprawdzanie zgody

Sprawdź zgodę: Sprawdź, czy użytkownik wyraził zgodę:

bool hasConsent = CmpManager.Instance.HasConsent();

Callbacki: Ustaw słuchacze wywołań zwrotnych dla różnych zdarzeń:

CmpManager.Instance.AddEventListeners(OnOpen, OnClose, OnNotOpened, OnCmpButtonClicked, OnError);

Kontrola celu i dostawcy: Sprawdź zgodę związaną z określonymi celami i dostawcami:

bool hasPurpose = CmpManager.Instance.HasPurpose(id);
bool hasVendor = CmpManager.Instance.HasVendor(id);

Dane eksportowe: Eksportuj dane CMP:

string cmpString = CmpManager.Instance.ExportCmpString();

Słuchacz zdarzeń

Układ niestandardowy

Unity obsługuje różne niestandardowe układy: 

        public enum ScreenConfig
        {
            FullScreen,
            HalfScreenBottom,
            HalfScreenTop,
            CenterScreen,
            SmallCenterScreen,
            LargeTopScreen,
            LargeBottomScreen,
        }

Przykładowe użycie: 

            _cmpConfig = new CmpConfig(CodeId, Domain, AppName, Language)
            {
                Debug = true,
                Timeout = 8000
            };

                _cmpConfig.UIConfig.screenConfig = (CmpUIConfig.ScreenConfig) Enum.Parse(typeof(CmpUIConfig.ScreenConfig), s);  
                _cmpManager.SetUIConfig(_cmpConfig.UIConfig); 

Tryb zgody Google

Dokumentacja referencyjna: Rozpocznij korzystanie z Google Firebase dla Unity

Integracja : Konfiguracja Jedności

Aby skorzystać z trybu zgody Google, pakiet CMP Unity SDK obsługuje interfejs do ustawiania statusu zgody Google: 

// public class CmpSampleScript : MonoBehaviour, IOnCmpGoogleConsentUpdatedCallback { ... 
// Make sure to implement the Interface IOnCmpGoogleConsentUpdatedCallback
public void OnGoogleConsentUpdated(CmpGoogleConsentModeStatus status)
{
// Convert CmpGoogleConsentModeStatus to Firebase compatible dictionary
var firebaseConsentDict = new Dictionary<ConsentType, ConsentStatus>();

foreach (var consent in status.ConsentDictionary)
{
// Convert GoogleConsentType to Firebase ConsentType
var firebaseConsentType = ConvertToFirebaseConsentType(consent.Key);

// Convert GoogleConsentStatus to Firebase ConsentStatus
var firebaseConsentStatus = ConvertToFirebaseConsentStatus(consent.Value);

firebaseConsentDict[firebaseConsentType] = firebaseConsentStatus;
}

// Apply the consent settings to Firebase Analytics
FirebaseAnalytics.SetConsent(firebaseConsentDict);
AppendLog($"Google Consent Mode: {firebaseConsentDict}");
}

private static ConsentType ConvertToFirebaseConsentType(GoogleConsentType googleConsentType)
{
return googleConsentType switch
{
GoogleConsentType.AnalyticsStorage => ConsentType.AnalyticsStorage,
GoogleConsentType.AdStorage => ConsentType.AdStorage,
GoogleConsentType.AdUserData => ConsentType.AdUserData,
GoogleConsentType.AdPersonalization => ConsentType.AdPersonalization,
_ => throw new InvalidEnumArgumentException($"Unknown GoogleConsentType: {googleConsentType}")
};
}

private static ConsentStatus ConvertToFirebaseConsentStatus(GoogleConsentStatus googleConsentStatus)
{
return googleConsentStatus switch
{
GoogleConsentStatus.Granted => ConsentStatus.Granted,
GoogleConsentStatus.Denied => ConsentStatus.Denied,
_ => throw new InvalidEnumArgumentException($"Unknown GoogleConsentStatus: {googleConsentStatus}")
};
}

w tym przykładzie wywołanie zwrotne OnGoogleConsentUpdate jest wywoływane, gdy użytkownik wyrazi zgodę. 

FirebaseAnalytics.SetConsent(firebaseConsentDict);

W tym wierszu Stan zgody jest ustawiony na Firebase Analytics. Pozostałe dwie funkcje mapują stan zgody CMP na typy i stan zgody Google.

Przykładowy skrypt

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;
using CmpSdk.Callbacks;
#if UNITY_IOS
using CmpSdk.Delegates;
#endif
using CmpSdk.Models;
using Firebase.Analytics;
using Firebase.Extensions;
using UnityEngine;
using FirebaseApp = Firebase.FirebaseApp;

namespace CmpSdk.Samples.Scripts
{
    // V prefix for Vendor
    public static class Vendors
    {
        public const string GoogleAnalytics = "S26";
        public const string AmazonAD = "793";
        public const string Facebook = "S7";
        public const string S1 = "S1";
    }

    // P prefix for Purpose
    public static class Purposes
    {
        public const string P1 = "1";
        public const string Marketing = "C2";
        public const string Technical = "S2";
        public const string Security = "S1";
    }


    public class CmpSampleScript : MonoBehaviour, IOnOpenCallback, IOnCloseCallback, IOnCmpNotOpenedCallback,
        IOnCmpButtonClickedCallback, IOnErrorCallback, IOnCmpGoogleConsentUpdatedCallback
    {
        readonly List<string> _purposeList = new() { Purposes.P1, Purposes.Marketing, Purposes.Technical, Purposes.Security };

        readonly List<string> _vendorList = new() { Vendors.S1, Vendors.GoogleAnalytics, Vendors.AmazonAD, Vendors.Facebook };

        // UI elements
        private string _idPurposeOrVendorInputField;
        private string _importStringInputField;
        [SerializeField] private CmpUIManager uiManager;

        // CmpManager Instance
        private CmpConfig _cmpConfig;
        private CmpManager _cmpManager;
        private Thread _mainThread;

        // Configuration constants
        private const string CodeId = "TOOD Your CMP Code ID";
        private const string Domain = "delivery.consentmanager.net";
        private const string AppName = "UnityExample";
        private const string Language = "DE";
        private FirebaseApp _app; 
        
        private void Awake()
        {
            if (!Application.isPlaying)
            {
                Debug.Log("Application is not playing.");
                return;
            }
            
            FirebaseApp.CheckAndFixDependenciesAsync().ContinueWithOnMainThread(task => {
                var dependencyStatus = task.Result;
                if (dependencyStatus == Firebase.DependencyStatus.Available) {
                    // Create and hold a reference to your FirebaseApp,
                    // where app is a Firebase.FirebaseApp property of your application class.
                    _app = FirebaseApp.DefaultInstance;

                    // Set a flag here to indicate whether Firebase is ready to use by your app.
                } else {
                    Debug.LogError($"Could not resolve all Firebase dependencies: {dependencyStatus}");
                    // Firebase Unity SDK is not safe to use here.
                }
            });
            _cmpManager = CmpManager.Instance;
        }
        
        private void Start()
        {
            _cmpConfig = new CmpConfig(CodeId, Domain, AppName, Language)
            {
                Debug = true,
                Timeout = 8000
            };
#if UNITY_ANDROID
            _cmpConfig.UIConfig.isOutsideTouchable = true;
            _cmpConfig.UIConfig.SetAndroidUiType(AndroidUiType.Dialog);
#endif
            // Initialize Consent Manager
            InitializeCmpManager();
            // Initialize UI buttons
            InitializeUIButtons();

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

        private void InitializeUIButtons()
        {
            uiManager.CreateButtons(
                new ButtonData("Open", OnClickOpenConsentLayer),
                new ButtonData("Check", OnClickOpenConsentLayerOnCheck),
                new ButtonData("Check?", OnclickCheckConsentRequired),
                new ButtonData("ATT?", OnClickRequestATTrackingStatus),
                new ButtonData("Get Status", OnClickDebugConsentStatus),
                new ButtonData("Initialize", OnClickInitialize),
                new ButtonData("Accept All", OnClickAcceptAll),
                new ButtonData("Reject All", OnClickRejectAll),
                new ButtonData("Reset", OnClickResetConsentData),
                new ButtonData("Import", OnClickImportCmpString),
                new ButtonData("Export", OnClickExportCmpString)
            );
            uiManager.CreateDropdown("Screen Config", GetScreenConfigOptions(), s =>
            {
                AppendLog($"Set Screen ${s}");
                _cmpConfig.UIConfig.screenConfig = (CmpUIConfig.ScreenConfig) Enum.Parse(typeof(CmpUIConfig.ScreenConfig), s);  
                _cmpManager.SetUIConfig(_cmpConfig.UIConfig); 
            });
            uiManager.CreateDropdown("Purposes", _purposeList, s =>
            {
                _idPurposeOrVendorInputField = s;
                CheckHasPurpose(s);
            });
            uiManager.CreateDropdown("Vendors", _vendorList, s =>
            {
                _idPurposeOrVendorInputField = s; 
                CheckHasVendor(s);
            }); 
        }

        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
        }
        
        #region Button Events

        private void OnClickInitialize()
        {
            AppendLog("Initialize");
            _cmpManager.Launch();
        }

        private async void OnClickRejectAll()
        {
            AppendLog("Calling Reject All"); 
            await _cmpManager.RejectAll();
            AppendLog("Rejected All");
        }

        private async void OnClickAcceptAll()
        {
            AppendLog("Calling Accept All");
            await _cmpManager.AcceptAll();
            AppendLog("Accepted All");
        }

        private void OnClickRequestATTrackingStatus()
        {
            AppendLog("Request AT Tracking Status");
            _ = _cmpManager.RequestATTrackingPermission();
        }

        private async void OnclickCheckConsentRequired()
        {
            AppendLog("Calling Check Consent Required");
            var isRequired = await _cmpManager.CheckConsentIsRequired();
            AppendLog($"Is consent required: {isRequired}");
        }

        private void OnClickOpenConsentLayer()
        {
            AppendLog("Open Consent Layer");
            _cmpManager.OpenConsentLayer();
        }

        private void OnClickOpenConsentLayerOnCheck()
        {
            AppendLog("Open Consent Layer on Check");
            _cmpManager.OpenConsentLayerOnCheck();
        }

        private void OnClickImportCmpString()
        {
            AppendLog("Click Import");
            ImportCmpString();
        }

        private void OnClickResetConsentData()
        {
            _cmpManager.Reset();
            AppendLog("Reset");
        }

        private void OnClickDebugConsentStatus()
        {
            DebugConsentStatus();
        }

        private void OnClickExportCmpString()
        {
            var cmpString = _cmpManager.ExportCmpString();
            AppendLog($"Exported CMP String: {cmpString}");
        }

        private void CheckHasPurpose(string purposeId)
        {
            var hasPurpose = _cmpManager.HasPurpose(purposeId);
            AppendLog($"Has Purpose ({purposeId}): {hasPurpose}");
        }

        private void CheckHasVendor(string vendorId)
        {
            var hasVendor = _cmpManager.HasVendor(vendorId);
            AppendLog($"Has Vendor ({vendorId}): {hasVendor}");
        }

        private async void ImportCmpString()
        {
            var cmpString = _importStringInputField;
            CmpImportResult result;

            if (!string.IsNullOrEmpty(cmpString))
            {
                AppendLog($"Importing CMP String from input field: {cmpString}");
                result = await _cmpManager.ImportCmpString(cmpString);
            }
            else
            {
                AppendLog($"Importing CMP String from sample string: {cmpString}");
                result = await _cmpManager.ImportCmpString(cmpString);
            }

            AppendLog($"Unity import result: {result.IsSuccess} with message: {result.Message}");
        }

        #endregion

        #region Callbacks

        public void OnGoogleConsentUpdated(CmpGoogleConsentModeStatus status)
        {
            // Convert CmpGoogleConsentModeStatus to Firebase compatible dictionary
            var firebaseConsentDict = new Dictionary<ConsentType, ConsentStatus>();

            foreach (var consent in status.ConsentDictionary)
            {
                // Convert GoogleConsentType to Firebase ConsentType
                var firebaseConsentType = ConvertToFirebaseConsentType(consent.Key);

                // Convert GoogleConsentStatus to Firebase ConsentStatus
                var firebaseConsentStatus = ConvertToFirebaseConsentStatus(consent.Value);

                firebaseConsentDict[firebaseConsentType] = firebaseConsentStatus;
            }
            
            // Apply the consent settings to Firebase Analytics
            FirebaseAnalytics.SetConsent(firebaseConsentDict);
            AppendLog($"Google Consent Mode: {firebaseConsentDict}");
        }

        private static ConsentType ConvertToFirebaseConsentType(GoogleConsentType googleConsentType)
        {
            return googleConsentType switch
            {
                GoogleConsentType.AnalyticsStorage => ConsentType.AnalyticsStorage,
                GoogleConsentType.AdStorage => ConsentType.AdStorage,
                GoogleConsentType.AdUserData => ConsentType.AdUserData,
                GoogleConsentType.AdPersonalization => ConsentType.AdPersonalization,
                _ => throw new InvalidEnumArgumentException($"Unknown GoogleConsentType: {googleConsentType}")
            };
        }

        private static ConsentStatus ConvertToFirebaseConsentStatus(GoogleConsentStatus googleConsentStatus)
        {
            return googleConsentStatus switch
            {
                GoogleConsentStatus.Granted => ConsentStatus.Granted,
                GoogleConsentStatus.Denied => ConsentStatus.Denied,
                _ => throw new InvalidEnumArgumentException($"Unknown GoogleConsentStatus: {googleConsentStatus}")
            };
        }

        public void OnClose()
        {
            LogThreadContext("OnClose");
            AppendLog("CMPConsentTool closed");
        }

        public void OnCmpButtonClicked(CmpButtonEvent buttonEvent)
        {
            LogThreadContext("OnCmpButtonClicked");
            AppendLog($"CMPButton clicked. Event: {buttonEvent}");
        }

        public void OnNotOpened()
        {
            LogThreadContext("OnNotOpened");
            AppendLog("CMPConsentTool not opened");
        }

        public void OnError(CmpErrorType errorType, string message)
        {
            LogThreadContext("OnError");
            AppendLog($"Error: {errorType}, {message}");
        }

        public void OnOpen()
        {
            LogThreadContext("OnOpen");
            AppendLog("CMPConsentTool opened");
        }
#if UNITY_IOS 
        private void OnCmpATTrackingStatusChanged(ATTrackingManagerAuthorizationStatus oldStatus,
            ATTrackingManagerAuthorizationStatus newStatus, double lastUpdated)
        {
            var unixTime = lastUpdated;
            var dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            dtDateTime = dtDateTime.AddSeconds(unixTime).ToLocalTime();
            AppendLog("OnCmpATTrackingStatusChanged: " + newStatus + " lastUpdated: " + dtDateTime);
        }
#endif
        
        #endregion

        private void DebugConsentStatus()
        {
            var hasConsent = _cmpManager.HasConsent();
            var allPurposes = _cmpManager.GetAllPurposes();
            var disabledPurposes = _cmpManager.GetAllPurposes();
            var enabledPurposes = _cmpManager.GetEnabledPurposes();
            var allVendors = _cmpManager.GetAllVendors();
            var disabledVendors = _cmpManager.GetDisabledVendors();
            var enabledVendors = _cmpManager.GetEnabledVendors();
            var exportCmp = _cmpManager.ExportCmpString();
            
            AppendLog("-----------------");
            AppendLog($"Unity All Purposes: {string.Join(", ", allPurposes)}");
            AppendLog($"Unity Disabled Purposes: {string.Join(", ", disabledPurposes)}");
            AppendLog($"Unity Enabled Purposes: {string.Join(", ", enabledPurposes)}");
            AppendLog($"Unity All Vendors: {string.Join(", ", allVendors)}");
            AppendLog($"Unity Disabled Vendors: {string.Join(", ", disabledVendors)}");
            AppendLog($"Unity Enabled Vendors: {string.Join(", ", enabledVendors)}");
            AppendLog($"Unity Exported CMP String: {exportCmp}");
            AppendLog($"Unity Has Consent: {hasConsent}");
            AppendLog($"Unity US Privacy String: {_cmpManager.GetUsPrivacyString()}");
            AppendLog($"Unity Google Ac String: {_cmpManager.GetGoogleAcString()}");
            AppendLog($"Unity Has Purpose C1: {_cmpManager.HasPurpose("c1")}");
            AppendLog($"Unity Has Vendor 10: {_cmpManager.HasVendor("628")}");
            AppendLog($"Unity Google Consent Mode Status: {_cmpManager.GetGoogleConsentModeStatus()}");
            AppendLog("-----------------");
        }

        #region Helper

        private void LogThreadContext(string callbackName)
        {
            var onMainThread = IsMainThread();
            var threadId = Thread.CurrentThread.ManagedThreadId;
            AppendLog($"{callbackName} called. Is main thread: {onMainThread} ID: {threadId}");
        }

        private bool IsMainThread()
        {
            return _mainThread.Equals(Thread.CurrentThread);
        }

        private void AppendLog(string message)
        {
            Debug.Log(message); 

            if (uiManager != null)
            {
                uiManager.AddLogText(message);
            }
        }
                
        private List<string> GetScreenConfigOptions()
        {
            var options = new List<string>();
            foreach (var config in Enum.GetValues(typeof(CmpUIConfig.ScreenConfig)))
            {
                options.Add(config.ToString());
            }

            return options;
        }

        #endregion
    }
}