Info
Inhalt
Bücher
CMP
Integration in Ihre App
[Einheit] 1. Zustimmungsmana...

[Einheit] 1. consentmanager SDK-Integration

Eigenschaften

  • Unterstützt sowohl iOS- als auch Android-Plattformen.
  • Bietet eine Brücke zwischen Unity und nativen plattformspezifischen CMP-Funktionen.
  • Ermöglicht Ihnen die Initialisierung, Verwaltung der Benutzereinwilligung und den Umgang mit datenschutzbezogenen Daten.

Erste Schritte

Installation

Anwendungsbereich

Befolgen Sie diese Schritte, um mit der Verwendung des Plugins zu beginnen.

Initialisierung: Um die CMP-Funktionalität zu nutzen, initialisieren Sie die CMPManager-Instanz.

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

Aussichten für domain Verwenden Sie die in Ihrem gefundene Server-Domain consentmanager Konto unter Menü > CMPs > Codes für Apps abrufen. For codeID Verwenden Sie die Code-ID, die Sie auf derselben Seite in Ihrem Consentmanger-Konto finden. Die Felder appName und language kann von Ihnen eingestellt werden.

CmpManager.Instance.OpenConsentLayer();

Überprüfen Sie die Einwilligung: Überprüfen Sie, ob der Benutzer seine Einwilligung gegeben hat:

bool hasConsent = CmpManager.Instance.HasConsent();

Rückrufe: Callback-Listener für verschiedene Ereignisse festlegen:

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

Zweck- und Lieferantenprüfungen: Prüfen Sie, ob die Zustimmung zu bestimmten Zwecken und Anbietern vorliegt:

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

Daten exportieren: CMP-Daten exportieren:

string cmpString = CmpManager.Instance.ExportCmpString();

JSON konfigurieren

In CmpSdkConfig.json können Sie die native SDK-Version für iOS und Android festlegen, die für den Build-Prozess verwendet wird: 

Finden Sie die kompatiblen nativen SDK-Versionen hier: 

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

Build-Einstellungen

Um die Build-Einstellungen zu ändern, gehen Sie zu Window -> CmpSdk 

Pluginwindow-Unity.png

iOS-Build-Einstellungen

  • Aktivieren Sie das iOS-Build-Skript: Schalten Sie dies um, um das Build-Skript zu aktivieren oder zu deaktivieren, das für die Integration des iOS SDK in das Unity-Projekt verantwortlich ist.
  • xcFramework-Pfad: Geben Sie den Pfad zum xcFramework-Verzeichnis an. Dieser Pfad kann direkt bearbeitet oder über die zugehörige Schaltfläche aufgerufen werden.
  • Versions-Tag einschließen: Wenn diese Option aktiviert ist, hängt die iOS SDK-Version an den xcFramework-Pfad an und ermöglicht so versionenspezifische Konfigurationen.
  • Resultierender Framework-Pfad: Zeigt den vollständig aufgelösten Pfad zum xcFramework an, einschließlich der SDK-Version, wenn das Versions-Tag enthalten ist.
  • Aktivieren Sie die App-Tracking-Transparenz: Schalten Sie diese Option um, um die App-Tracking-Transparenzfunktion für iOS zu aktivieren, die für die Zustimmung des Benutzers gemäß den iOS-Datenschutzrichtlinien erforderlich ist.
  • Einwilligungserklärung zur App-Tracking-Transparenz: Ein Textfeld zur Eingabe der benutzerdefinierten Nachricht, die Benutzern angezeigt wird, wenn sie ihre Zustimmung zur Nachverfolgung einholen. Diese Nachricht sollte klar und prägnant sein und erklären, warum die Einwilligung erforderlich ist.

Android-Build-Einstellungen

  • Aktivieren Sie das Android-Build-Skript: Schalten Sie um, um das Build-Skript für die Integration des Android SDK in das Unity-Projekt zu aktivieren oder zu deaktivieren. 
  • Benutzerdefiniertes Layout integrieren: Wenn diese Option aktiviert ist, ermöglicht dies die Verwendung eines benutzerdefinierten Layouts für die Zustimmungsebene für das Fragment UIView.

    Wenn Sie daran interessiert sind, ein benutzerdefiniertes Layout mit Fragmenten zu verwenden, stellen Sie sicher, dass Ihr Unity-Projekt die appcompat-Abhängigkeit hinzufügt. Fügen Sie eine benutzerdefinierte Hauptvorlage hinzu
    Assets/Plugins/Android/mainTemplate.gradle
    und füge die Abhängigkeit hinzu:
    Implementierung 'androidx.appcompat:appcompat:1.xx'

Ereignis-Listener

Rückrufereignis Beschreibung Übergebene Parameter
OnOpen Wird ausgelöst, wenn das CMP-Einwilligungstool geöffnet wird. Andere
Aufschließen Wird ausgelöst, wenn das CMP-Einwilligungstool geschlossen wird. Andere
OnNotOpened Wird ausgelöst, wenn das CMP-Einwilligungstool nicht geöffnet werden kann. Andere
OnCmpButtonClicked Wird ausgelöst, wenn auf eine Schaltfläche im CMP-Einwilligungstool geklickt wird. CmpButtonEvent buttonEvent
OnError Wird ausgelöst, wenn im CMP-Einwilligungstool ein Fehler auftritt. CmpErrorType errorType, string message
OnGoogleConsentAktualisiert Wird ausgelöst, wenn der Status des Google-Zustimmungsmodus aktualisiert wird. CmpGoogleConsentModeStatus status
OnCmpATTrackingStatusChanged (nur iOS) Wird ausgelöst, wenn sich der Status der App-Tracking-Transparenz ändert. ATTrackingManagerAuthorizationStatus oldStatus, ATTrackingManagerAuthorizationStatus newStatus, double lastUpdated

 

maßgeschneidertes Layout

Unity unterstützt verschiedene benutzerdefinierte Layouts: 

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

Beispielverwendung: 

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

Referenzdokumentation: Beginnen Sie mit Google Firebase für Unity

Integration : Unity-Setup

Um den Google-Zustimmungsmodus zu verwenden, unterstützt das CMP Unity SDK eine Schnittstelle zum Festlegen des Google-Zustimmungsstatus: 

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

In diesem Beispiel wird der OnGoogleConsentUpdate-Callback aufgerufen, wenn der Benutzer seine Einwilligung erteilt. 

FirebaseAnalytics.SetConsent(firebaseConsentDict);

In dieser Zeile wird der Einwilligungsstatus auf Firebase Analytics gesetzt. Die anderen beiden Funktionen ordnen den CMP-Zustimmungsstatus den Google-Zustimmungstypen und -Status zu.

Roadmap für zukünftige Funktionen

  • disableVendorList, enableVendorList
  • disablePurposeList, enablePurposeList

Kompatibilität

  • Unity 20XX.XX oder höher
  • iOS (über DllImport)
  • Android (über JNI)

Unterstützung

Für Fehlerberichte, Funktionsanfragen oder allgemeine Anfragen wenden Sie sich bitte an uns Öffnen Sie ein Problem auf dem Repository.

Credits

Erstellt und gepflegt von Skander Ben Abdelmalak.

Beispielskript

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

 

Details
Revision # 20
Erstellt 6 Monate her by Skander Ben
Aktualisiert 2 Wochen her by Januar
Sie haben noch kein Konto?

Werden Sie DSGVO-konform mit unserer DSGVO Cookie Consent Manager-Lösung. Probieren Sie es jetzt kostenlos aus!

DSGVO-Cookie Consent Manager
Nach oben