[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å
-
-
Integration och konfiguration:
- Integrera SDK:n i din app.
- Konfigurera SDK-inställningarna efter dina behov.
-
Skapa en instans:
- Vid appstart skapar du en instans av
CMPConsentTool
klass. Denna instans kommer att hantera samtyckesprocessen.
- Vid appstart skapar du en instans av
-
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.
-
Visar samtyckesskärmen:
- SDK:n visar automatiskt samtyckesskärmen om det behövs när
CMPConsentTool
instans skapas.
- SDK:n visar automatiskt samtyckesskärmen om det behövs när
-
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.
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:
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.
-
- Ladda ner den senaste versionen av plugin.
- Importera paketet till ditt Unity-projekt med tillgångar > Importera paket > Anpassat paket.
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
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
Kontrollerar samtycke
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);
Googles samtycke-läge
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
}
}