Info
Innehåll

[Enhet] 1. consentmanager SDK-integration

[Enhet] 1. consentmanager SDK-integration

I det här dokumentet hittar du allmän information om hur du integrerar vår SDK i ditt projekt. För ytterligare information, se vår API-referens dokumentation.

1. Installation

Smakämnen consentmanager SDK för Android-appar implementerar och tillhandahåller funktionalitet för att informera användaren om dataskydd och fråga och samla in samtycke från användaren. Det gör det möjligt för app-utvecklare att enkelt integrera consentmanager tjänsten i sin app. Som huvudfunktioner tillhandahåller vi:

  • Stöd både iOS och Android-plattformar.
  • En brygga mellan Unity och inbyggda plattformsspecifika CMP-funktioner.
  • Ett enkelt sätt att initiera, hantera användarens samtycke och hantera integritetsrelaterad data.

När det gäller kompatibilitet har vi:

  • Unity 20XX.XX eller senare
  • iOS (via DllImport)
  • Android (via JNI)

Steg - Hög nivå

    1. Integration och konfiguration:

      • Integrera SDK:n i din app.
      • Konfigurera SDK-inställningarna efter dina behov.
    2. Skapa en instans:

      • Vid appstart skapar du en instans av CMPConsentTool klass. Denna instans kommer att hantera samtyckesprocessen.
    3. SDK-initiering:
      • När instansen är klar hämtar SDK automatiskt nödvändig information från consentmanager servrar för att förbereda för dess drift.
    4. Visar samtyckesskärmen:

      • SDK:n visar automatiskt samtyckesskärmen om det behövs när CMPConsentTool instans skapas.
    5. Behandling av personuppgifter:

      • När samtycken har samlats in lagras informationen och är tillgänglig för frågor genom olika egenskaper och metoder som exponeras av vår SDK. Du kommer att ha information om avvisade eller accepterade samtycken, leverantörer, syften etc.

    Genom att följa dessa steg säkerställer du att din app är kompatibel med samtyckeskraven och att användarens samtycke hanteras och lagras korrekt.

Consent Manager Leverantörs SDK-sekvensdiagram

För att illustrera stegen ovan, låt oss kolla i diagrammet nedan tre möjliga SDK-sekvensflöden. 

1. När du skapar en instans med hjälp av Initialize() funktion finns det två möjliga utfall. Den första är när consentmanger API informerar SDK om att CMP inte kommer att öppnas, vilket utlöser OnCmpNotOpenedCallback. Det andra resultatet är när samtyckesskiktet öppnas, så att användaren kan interagera med det, och detta utlöser OnOpenCallback. När användaren ger sitt samtycke och samtycket behandlats, PåCmpCloseCallback kallas.

Observera att Vid feluppringning representeras av de röda streckade pillinjerna för att ge exempel på när fel kan uppstå under processen.

Initialize-Cmp-Sequence-Diagram.png

2. Skapa en instans och anropa OpenConsentLayerOnCheck funktioner kommer att leda till en liknande process. Skillnaden är att genom att frikoppla skapandet av instansen och kontrollen för consentmanger API får du möjligheten att lägga till affärslogik och interagera med bibliotekens API.

3. Skapa en instans och anropa OpenConsentLayer funktionen öppnar lagret utan att markera consentmanager, om det är nödvändigt. Om det redan finns ett samtycke kommer alternativen och inställningarna att visas för användaren. Processflödet kommer att se ut så här:

openlayer-Cmp-Sequence-Diagram-.png

För ytterligare information om vår SDK-versionsöversikt och ändringslogg, se denna länk.

    Importera SDK-paketet

    Med bara två steg kan du ställa in allt.

    Konfigurera JSON

    I CmpSdkConfig.json kan du ställa in den ursprungliga SDK-versionen för iOS och Android som kommer att användas för byggprocessen: 

    Hitta de kompatibla inbyggda SDK-versionerna här.

    {
      "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."
    }
    

    Bygg inställningar

    Gå till för att ändra bygginställningarna Window -> CmpSdk 

    pluginwindow-unity.png

    iOS Bygginställningar

    • Aktivera iOS Build Script: Växla detta för att aktivera eller inaktivera byggskriptet som ansvarar för att integrera iOS SDK i Unity-projektet.
    • xcFramework-sökväg: Ange sökvägen till xcFramework-katalogen. Den här sökvägen kan redigeras direkt eller bläddra till med hjälp av den medföljande knappen.
    • Inkludera versionstagg: När det är aktiverat lägger du till iOS SDK-versionen till xcFramework-sökvägen, vilket möjliggör versionsspecifika konfigurationer.
    • Resulterande ramväg: Visar den fullständigt lösta sökvägen till xcFramework, inklusive SDK-versionen om versionstaggen ingår.
    • Aktivera insyn i appspårning: Växla detta för att aktivera funktionen App Tracking Transparency för iOS, vilket är nödvändigt för användarens samtycke enligt iOS sekretessriktlinjer.
    • App Tracking Transparency Consent Message: Ett textfält för att mata in det anpassade meddelande som visas för användare när de begär samtycke för spårning. Detta meddelande bör vara tydligt och kortfattat och förklara varför samtycke behövs.

    Android Build-inställningar

    • Aktivera Android Build Script: Växla för att aktivera eller inaktivera byggskriptet för att integrera Android SDK i Unity-projektet. 
    • Integrera anpassad layout: När det är aktiverat tillåter detta användning av en anpassad layout för samtyckesskiktet för fragmentet UIView.

      Om du är villig att använda en anpassad layout med fragment, se till att ditt Unity-projekt lägger till appcompat beroende. Lägg till en anpassad huvudmall: 
      Tillgångar/Plugins/Android/mainTemplate.gradle
      och lägg till beroendet:
      implementering 'androidx.appcompat:appcompat:1.xx'

    2. Initiera SDK

    Följ dessa steg för att börja använda plugin-programmet.

    Initiera samtyckesverktyget - automatiskt

    Inom app-start (vanligtvis den vanliga override onCreate() function), måste du skapa en instans av klass CMPConsentTool. De initialize() funktionen hämtar automatiskt nödvändig information från vår server och avgör om samtyckesskärmen måste visas eller inte. Om så är fallet kommer SDK automatiskt att visa samtyckesskärmen vid denna tidpunkt, samla in data och tillhandahålla data till appen. Instansen kan sedan användas för att få samtyckesinformation från SDK:n för att kunna använda den i appen.

    Exempel på initiering, med hjälp av det automatiska beteendet hos Initialize() metod.  

    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);                

    För domain använd serverdomänen som finns i din consentmanager konto under Meny > CMPs > Hämta koder för appar. För codeID använd kod-ID som finns på samma sida i ditt samtyckesmanagerkonto. De appName kan användas för att särskilja olika appar i consentmanager rapportering. För den language, kan du antingen använda en tom sträng ("") för automatisk identifiering eller en språkkod på två bokstäver ("EN", "DE", "FR" och så vidare).

    Initiera samtyckesverktyget - manuellt

    SDK erbjuder, för flexibilitetens skull, ett sätt att manuellt visa samtyckeslagret, som visas nedan: 

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

    3. Använda SDK

    Kontrollera samtycke: Kontrollera om användaren har gett sitt samtycke:

    bool hasConsent = CmpManager.Instance.HasConsent();

    callbacks: Ställ in återuppringningslyssnare för olika händelser:

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

    Syfte och leverantörskontroller: Kontrollera om samtycke relaterat till specifika ändamål och leverantörer:

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

    Exportera data: Exportera CMP-data:

    string cmpString = CmpManager.Instance.ExportCmpString();

    Händelselyssnare

    Återuppringningshändelse Beskrivning Parametrar godkända
    På Öppna Utlöses när CMP-samtyckesverktyget öppnas. Ingen
    På Stäng Utlöses när CMP-samtyckesverktyget stängs. Ingen
    OnNotOpened Utlöses om CMP-samtyckesverktyget inte öppnas. Ingen
    OnCmpButtonKlickade Utlöses när en knapp i CMP-samtyckesverktyget klickas. CmpButtonEvent buttonEvent
    OnError Utlöses när ett fel uppstår i CMP-samtyckesverktyget. CmpErrorType errorType, string message
    OnGoogleConsentUpdated Utlöses när Googles samtyckeslägesstatus uppdateras. CmpGoogleConsentModeStatus status
    OnCmpATtrackingStatusChanged (endast iOS) Utlöses när appspårningstransparensstatus ändras. ATTrackingManagerAuthorizationStatus oldStatus, ATTrackingManagerAuthorizationStatus newStatus, double lastUpdated

     

    Anpassad layout

    Unity stöder olika anpassade layouter: 

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

    Exempel på användning: 

                _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); 

    Referensdokumentation: Kom igång med Google Firebase för Unity

    Integration: Unity Setup

    För att använda Googles samtyckesläge stöder CMP Unity SDK ett gränssnitt för att ställa in Googles samtyckesstatus: 

    // 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}")
    };
    }

    i det här exemplet anropas OnGoogleConsentUpdate-återuppringningen när användaren ger sitt samtycke. 

    FirebaseAnalytics.SetConsent(firebaseConsentDict);

    På den här raden är samtyckesstatus inställd på Firebase Analytics. De andra två funktionerna mappar CMP-samtyckesstatusen till Googles samtyckestyper och -status.

    Exempelskript

      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
          }
      }

       

      Tillbaka till toppen