Integrazione Android

il pubconsent sdk è l'integrazione del nostro pubconsent cmp nelle applicazioni android il punto di forza della nostra integrazione è che non richiede molti aggiornamenti poiché molte delle modifiche apportate all'interno del configuratore saranno riflesse automaticamente all'interno dell'app versione sdk minimo 21 ogni volta che verranno introdotte modifiche rilevanti, sarete contattati via email all'indirizzo tecnico che avete configurato nel nostro dashboard per consentirvi di aggiornare la versione del sdk all'ultima che abbiamo pubblicato per ulteriori api o maggiori informazioni su come funziona, non esitate a contattare il nostro supporto clienti se riscontrate bug o problemi durante l'integrazione per favore non esitate a contattarci, ogni vostro feedback è prezioso per noi installazione il nostro sdk cmp è disponibile su maven central cliccando qui https //central sonatype com/artifact/ai pubtech/pubconsent per utilizzare il pubconsent sdk nel tuo progetto android, aggiungi la seguente dipendenza al tuo file build gradle implementation 'ai pubtech pubconsent\ pubconsent sdk 3 0 0' permessi questo sdk richiede i seguenti permessi, per favore assicurati di aggiungerli al tuo androidmanifest xml \<uses permission android\ name="android permission access network state" /> \<uses permission android\ name="android permission internet" /> come funziona una volta che l'sdk è integrato in un'app, l'sdk chiederà automaticamente e mostrerà l'interfaccia utente se necessario nel caso sia necessario mostrare l'interfaccia utente l'sdk recupererà le informazioni dal nostro server per preparare e fornire la tua cmp l'app può chiedere all'sdk se è stato dato il consenso per lo scopo e/o il fornitore specifici attraverso le api esposte kotlin example import ai pubtech pubconsent cmp import ai pubtech pubconsent cmpcallbacks import ai pubtech pubconsent cmpconfig import ai pubtech pubconsent dto googleconsentmodestatus import ai pubtech pubconsent dto googleconsentmodetype import ai pubtech pubconsent utility cmplogger import androidx appcompat app appcompatactivity import android os bundle import android widget button class mainactivity appcompatactivity() { override fun oncreate(savedinstancestate bundle?) { super oncreate(savedinstancestate) setcontentview(r layout activity main) // (se configuri cmpuiconfig uitype = cmpuitype fragment) allora devi assegnare il tuo fragmentcontainerid cmpuiconfig fragmentcontainerid = android r id content // configurazione della ui della cmp cmpuiconfig configurecenterscreen(this) val cmp = cmp createinstance(this) &#x9; // creazione ed assegnazione della callbacks (opzionale) val cmpcallbacks = cmpcallbacks( { if (consentapiinterface getcmptype() == cmptype tcf v2 gdpr) { consentapiinterface as tcfgdprconsentapi cmplogger d("la cmp è basata su tcf v2 per il gdpr ed il consenso è pronto") cmplogger d("il vendor 1 è abilitato? ${cmp isvendorconsentenabled(1)}") cmplogger d("features ${cmp isfeaturecookiesenabled()}") cmplogger d("user experience ${cmp isuserexperiencecookiesenabled()}") cmplogger d("measurement ${cmp ismeasurementcookiesenabled()}") // da usare solo se il tcf mobile flag non è abilitato nel configuratore val firebaseconsentmap = consentapiinterface getgoogleconsentmode()? entries? associate { entry > val firebaseconsenttype = when (entry key) { googleconsentmodetype analytics storage > "firebaseanalytics consenttype analytics storage" googleconsentmodetype ad storage > "firebaseanalytics consenttype ad storage" googleconsentmodetype ad user data > "firebaseanalytics consenttype ad user data" googleconsentmodetype ad personalization > "firebaseanalytics consenttype ad personalization" googleconsentmodetype functionality storage > "opzionale" googleconsentmodetype personalization storage > "opzionale" googleconsentmodetype security storage > "opzionale" } val firebaseconsentstatus = when (entry value) { googleconsentmodestatus granted > "firebaseanalytics consentstatus granted" googleconsentmodestatus denied > "firebaseanalytics consentstatus denied" googleconsentmodestatus unknown > "non mappato nel caso in cui non siano disponibili i tipi opzionali " } firebaseconsenttype to firebaseconsentstatus } cmplogger d("firebase mapping $firebaseconsentmap") } if (consentapiinterface getcmptype() == cmptype google consent mode) { consentapiinterface as gcmconsentapi cmplogger d("la cmp è basata sul google consent mode ed è il consenso è pronto!") val firebaseconsentmap = consentapiinterface getgoogleconsentmode()? entries? associate { entry > val firebaseconsenttype = when (entry key) { googleconsentmodetype analytics storage > "firebaseanalytics consenttype analytics storage" googleconsentmodetype ad storage > "firebaseanalytics consenttype ad storage" googleconsentmodetype ad user data > "firebaseanalytics consenttype ad user data" googleconsentmodetype ad personalization > "firebaseanalytics consenttype ad personalization" googleconsentmodetype functionality storage > "opzionale da abilitare nel configuratore" googleconsentmodetype personalization storage > "opzionale da abilitare nel configuratore" googleconsentmodetype security storage > "opzionale da abilitare nel configuratore" } val firebaseconsentstatus = when (entry value) { googleconsentmodestatus granted > "firebaseanalytics consentstatus granted" googleconsentmodestatus denied > "firebaseanalytics consentstatus denied" googleconsentmodestatus unknown > "non mappato nel caso in cui non siano disponibili i tipi opzionali " } firebaseconsenttype to firebaseconsentstatus } cmplogger d("firebase mapping $firebaseconsentmap") } }, { cmplogger d("la cmp ui è stata chiusa (chiamata poco prima del consenso pronto)") }, { cmplogger d("la cmp ui è stata mostrata") }, { cmplogger d("un errore è stato lanciato dalla cmp $it") }, // esempio di utilizzo del googleconsentmode mapping // attenzione questa callback è deprecata, verrà rimossa nella versione v3 0 0 { consentmap > val firebaseconsentmap = consentmap entries associate { entry > val firebaseconsenttype = when (entry key) { googleconsentmodetype analytics storage > "firebaseanalytics consenttype analytics storage" googleconsentmodetype ad storage > "firebaseanalytics consenttype ad storage" googleconsentmodetype ad user data > "firebaseanalytics consenttype ad user data" googleconsentmodetype ad personalization > "firebaseanalytics consenttype ad personalization" } val firebaseconsentstatus = when (entry value) { googleconsentmodestatus granted > "firebaseanalytics consentstatus granted" googleconsentmodestatus denied > "firebaseanalytics consentstatus denied" } firebaseconsenttype to firebaseconsentstatus } cmplogger d("firebase mapping $firebaseconsentmap") } ) &#x9; // creazione della configurazione per avviare la cmp val cmpconfig = cmpconfig("your cmp id", appname = "your app name", true, cmpcallbacks) &#x9; // avvio della cmp cmp run(this, cmpconfig) val button = findviewbyid\<button>(r id button) // utilizzo del metodo shownotice (il precedente askconsent nella 2 0 0) per associarlo ad un bottone di riapertura della cmp button setonclicklistener { cmp shownotice(this) } } } java example import ai pubtech pubconsent cmp; import ai pubtech pubconsent cmpcallbacks; import ai pubtech pubconsent cmpconfig; import ai pubtech pubconsent dto googleconsentmodestatus; import ai pubtech pubconsent dto googleconsentmodetype; import ai pubtech pubconsent utility cmplogger; import androidx appcompat app appcompatactivity; import android os bundle; import android widget button; import java util map; public class mainactivity extends appcompatactivity { @override protected void oncreate(bundle savedinstancestate) { super oncreate(savedinstancestate); setcontentview(r layout activity main); // (se configuri cmpuiconfig uitype = cmpuitype fragment) allora devi assegnare il tuo fragmentcontainerid cmpuiconfig fragmentcontainerid = android r id content; // configurazione della ui della cmp cmpuiconfig instance configurecenterscreen(this); // creazione dell'istanza cmp cmp cmp = cmp instance createinstance(this); // creazione ed assegnazione della callbacks (opzionale) cmpcallbacks cmpcallbacks = new cmpcallbacks( consentapiinterface > { if (consentapiinterface getcmptype() == cmptype tcf v2 gdpr) { tcfgdprconsentapi gdprconsentapi = (tcfgdprconsentapi) consentapiinterface; cmplogger d("la cmp è basata su tcf v2 per il gdpr ed il consenso è pronto"); cmplogger d("il vendor 1 è abilitato? " + cmp isvendorconsentenabled(1)); cmplogger d("features " + cmp isfeaturecookiesenabled()); cmplogger d("user experience " + cmp isuserexperiencecookiesenabled()); cmplogger d("measurement " + cmp ismeasurementcookiesenabled()); map\<string, string> firebaseconsentmap = gdprconsentapi getgoogleconsentmode() entryset() stream() collect(collectors tomap( entry > { switch (entry getkey()) { case analytics storage return "firebaseanalytics consenttype analytics storage"; case ad storage return "firebaseanalytics consenttype ad storage"; case ad user data return "firebaseanalytics consenttype ad user data"; case ad personalization return "firebaseanalytics consenttype ad personalization"; case functionality storage return "opzionale"; case personalization storage return "opzionale"; case security storage return "opzionale"; default return ""; } }, entry > { switch (entry getvalue()) { case granted return "firebaseanalytics consentstatus granted"; case denied return "firebaseanalytics consentstatus denied"; case unknown return "non mappato nel caso in cui non siano disponibili i tipi opzionali "; default return ""; } } )); cmplogger d("firebase mapping " + firebaseconsentmap); } else if (consentapiinterface getcmptype() == cmptype google consent mode) { gcmconsentapi gcmconsentapi = (gcmconsentapi) consentapiinterface; cmplogger d("la cmp è basata sul google consent mode ed è il consenso è pronto!"); map\<string, string> firebaseconsentmap = gcmconsentapi getgoogleconsentmode() entryset() stream() collect(collectors tomap( entry > { switch (entry getkey()) { case analytics storage return "firebaseanalytics consenttype analytics storage"; case ad storage return "firebaseanalytics consenttype ad storage"; case ad user data return "firebaseanalytics consenttype ad user data"; case ad personalization return "firebaseanalytics consenttype ad personalization"; case functionality storage return "opzionale da abilitare nel configuratore"; case personalization storage return "opzionale da abilitare nel configuratore"; case security storage return "opzionale da abilitare nel configuratore"; default return ""; } }, entry > { switch (entry getvalue()) { case granted return "firebaseanalytics consentstatus granted"; case denied return "firebaseanalytics consentstatus denied"; case unknown return "non mappato nel caso in cui non siano disponibili i tipi opzionali "; default return ""; } } )); cmplogger instance d("firebase mapping " + firebaseconsentmap); } }, () > { cmplogger instance d("la cmp ui è stata chiusa (chiamata poco prima del consenso pronto)"); }, () > { cmplogger instance d("la cmp ui è stata mostrata"); }, error > { cmplogger instance d("un errore è stato lanciato dalla cmp " + error); }, consentmap > { map\<string, string> firebaseconsentmap = consentmap entryset() stream() collect(collectors tomap( entry > { switch (entry getkey()) { case analytics storage return "firebaseanalytics consenttype analytics storage"; case ad storage return "firebaseanalytics consenttype ad storage"; case ad user data return "firebaseanalytics consenttype ad user data"; case ad personalization return "firebaseanalytics consenttype ad personalization"; default return ""; } }, entry > { switch (entry getvalue()) { case granted return "firebaseanalytics consentstatus granted"; case denied return "firebaseanalytics consentstatus denied"; default return ""; } } )); cmplogger instance d("firebase mapping " + firebaseconsentmap); } ); // creazione della configurazione per avviare la cmp cmpconfig cmpconfig = new cmpconfig("your cmp id", "your app name", true, cmpcallbacks); // avvio della cmp cmp run(this, cmpconfig); // pulsante di apertura cmp button button = findviewbyid(r id button); button setonclicklistener(v > cmp shownotice(this)); } } condivisione consenso con una webview se hai bisogno di riutilizzare il consenso collezionato attraverso la nostra sdk ad una webview che punta al tuo sito web puoi consultare la documentazione condivisione consensi alle webview docid\ qobtyq9cdn12ny4sqg eg configurazione del layout per configurare il layout puoi usare la classe cmpuiconfig con diverse opzioni di stile questa classe offre anche alcuni layout preimpostati come configurehalfscreenbottom configurehalfscreentop configurecenterscreen configuresmallcenterscreen configurelargetopscreen configurelargebottomscreen il tipo di interfaccia utente predefinito sarà quello che utilizza la finestra popup puoi cambiare il tipo di interfaccia utente impostando il parametro uiconfig cmpuiconfig uitype = cmpuitype dialog cmpuiconfig uitype = cmpuitype popup cmpuiconfig uitype = cmpuitype fragment cmpuiconfig uitype = cmpuitype activity due importanti parametri determineranno il comportamento del popup e del dialogo comportamento del popup parametro isfocusable = true isfocusable = false isoutsidetouchable = true rimuove toccando all'esterno può acquisire il focus per eventi di input rimuove toccando all'esterno non acquisisce il focus o intercetta l'input della tastiera isoutsidetouchable = false non viene rimosso toccando all'esterno può acquisire il focus e intercettare eventi di input non viene rimosso toccando all'esterno non acquisisce il focus o intercetta l'input della tastiera comportamento del dialog parametro isfocusable = true isfocusable = false isoutsidetouchable = true rimuove con un tocco all'esterno ( setcanceledontouchoutside(true) ) il dialogo è di default focusabile il dialogo non viene chiuso toccando all'esterno e potrebbe non comportarsi come previsto poiché i dialoghi sono tipicamente focusabili isoutsidetouchable = false non viene rimosso toccando all'esterno ( setcanceledontouchoutside(false) ) il dialogo rimane focusabile e può intercettare eventi di input il dialogo non viene chiuso toccando all'esterno e potrebbe non comportarsi come previsto a causa della mancanza di focusabilità esempio per il fragmentlayout r id cmpcontainer è un framelayout che potrebbe apparire così nel file xml del layout dell'attività in layout/{tua attività} xml prevenire l'azione back quando la ui è mostrata per evitare la chiusura dell'interfaccia utente (ui), è necessario eseguire l'override della funzione onbackpressed e verificare che la cmp non sia mostrata per controllare se la ui della cmp è visualizzata, potete affidarvi alle callback precedentemente illustrate inside your activity class override fun onbackpressed() { if (iscmpopen) { return } super onbackpressed() } integrazione google consent mode (v2) google consent mode ti permette di regolare il comportamento dei tag google e del firebase sdk in base allo stato del consenso dell'utente per conformarsi alla policy aggiornata di google (eu user consent policy), il pubtech cmp supporta i quattro parametri obbligatori ad storage, analytics storage, ad user data, e ad personalization 1\ imposta gli stati di consenso predefiniti (default states) prima che il cmp venga inizializzato, dovresti definire gli stati di consenso predefiniti nei file di configurazione della tua app android (androidmanifest xml) aggiungi i seguenti tag \<meta data> all'interno del tag \<application> \<meta data android\ name="google analytics default allow analytics storage" android\ value="false" /> \<meta data android\ name="google analytics default allow ad storage" android\ value="false" /> \<meta data android\ name="google analytics default allow ad user data" android\ value="false" /> \<meta data android\ name="google analytics default allow ad personalization signals" android\ value="false" /> 2\ sincronizzazione del consenso con firebase sdk devi aggiornare il firebase sdk ogni volta che la cmp cattura o aggiorna il consenso dell'utente usa la callback onconsentready per mappare i tipi di consenso di pubtech su firebase import com google firebase analytics firebaseanalytics val cmpcallbacks = cmpcallbacks( onconsentreadycallback = { consentapi > val gcm = consentapi getgoogleconsentmode() val consentmap = mutablemapof\<firebaseanalytics consenttype, firebaseanalytics consentstatus>() gcm? foreach { (type, status) > val firebasetype = when(type) { googleconsentmodetype analytics storage > firebaseanalytics consenttype analytics storage googleconsentmodetype ad storage > firebaseanalytics consenttype ad storage googleconsentmodetype ad user data > firebaseanalytics consenttype ad user data googleconsentmodetype ad personalization > firebaseanalytics consenttype ad personalization else > null } val firebasestatus = if (status == googleconsentmodestatus granted) firebaseanalytics consentstatus granted else firebaseanalytics consentstatus denied firebasetype? let { consentmap\[it] = firebasestatus } } firebaseanalytics getinstance(context) setconsent(consentmap) } ) 3\ verifica per verificare che i segnali vengano inviati correttamente esegui adb shell setprop log tag fa svc verbose e controlla logcat cercando la stringa "setting consent" sdk & apis documentation cmp class constructors cmp(context context) descrizione inizializza il cmp con il contesto specificato e l'id della vista del contenuto parametri context il context della tua application/activity public methods run(context context, cmpconfig cmpconfig) descrizione avvia il cmp con la configurazione fornita parametri context il context della tua application/activity cmpconfig l'oggetto di configurazione per il cmp uso questo metodo inizializza e avvia il cmp con la configurazione specificata shownotice(activity activity) descrizione visualizza la finestra del cmp per chiedere il consenso dell'utente parametri activity il contesto dell'attività dove verrà visualizzata la finestra del cmp uso chiama questo metodo per richiedere il consenso dell'utente utilizzando la finestra del cmp (per implementare il bottone di riapertura) cmpconfig class constructors cmpconfig(id string, appname string, callbacks cmpcallbacks, debug boolean, retryconfig retryconfig) descrizione constructs a configuration object for the cmp parametri id l'id del cmp appname il nome dell'applicazione callbacks funzioni di callback per gli eventi del cmp debug per scopi di debug retryconfig per configurare i parametri disponibili dal meccanismo di riprova retryconfig class constructors retryconfig(maxretries int, retrydelay int, retriesbackofffactor double, timeout long) descrizione oggetto per il meccanismo di retry di apertura della cmp nel caso di problemi con la rete parametri maxretries il numero massimo di tentativi di riprova il valore predefinito è 3 retrydelay il ritardo (in millisecondi) tra i tentativi di riprova consecutivi il valore predefinito è 200 retriesbackofffactor il fattore con cui il ritardo di riprova dovrebbe essere moltiplicato per il ritardo esponenziale il valore predefinito è 1 3 timeout la durata massima (in millisecondi) entro la quale i tentativi di riprova devono essere completati il valore predefinito è 7500 cmpcallbacks interface methods onconsentreadycallback(consentapiinterface consentapiinterface) descrizione callback function chiamata quando il consenso è presente nota in seguito trovate la documentazione sulle implementazioni disponibili dell'interfaccia consentapiinterface oncmpuiclosedcallback() descrizione callback function chiamata quando la ui della cmp viene chiusa oncmpuiopencallback() descrizione callback function chiamata quando la ui della cmp viene mostrata all'utente onerrorcallback(error string) descrizione callback function chiamata quando accade un errore parametri error descrizione dell'errore ongoogleconsentmodecallback(consentmap map\<int, int>) descrizione callback function chiamata quando il mapping per il google consent mode è pronto parametri consentmap contiente il mapping dei consensi per google consent mode pubconsent consentapiinterface utilizzando l'api esposta tramite onconsentreadycallback potete verificare tramite il metodo getcmptype() quali delle seguenti implementazioni avete a disposizione (questa scelta dipende dalla configurazione salvata attraverso il configuratore pubconsent) di seguito vi mostriamo le api per ogni cmp type che offriamo seguenti metodi sono accessibili tramite l'istanza consentapiinstance any pubconsent consentapiinterface disponibile come parametro alla callback onconsentreadycallback api per il cmptype tcf v2 gdpr quando il consenso è relativo alla cmp tcf (ovvero consentapiinterface getcmptype() == cmptype tcf v2 gdpr ) avrete a disposizione le seguenti api isvendorconsentenabled(vendorid int) boolean descrizione verifica se il consenso è abilitato per un fornitore specifico parametri vendorid l'id del fornitore per cui verificare il consenso returns true se il consenso è abilitato per il fornitore specificato, altrimenti false uso utilizza questo metodo per determinare se il consenso è stato concesso per un particolare fornitore ispurposeconsentenabled(purposeid int) boolean descrizione verifica se il consenso è abilitato per un fornitore specifico parametri purposeid l'id dello scopo per il quale verificare il consenso returns true se il consenso è abilitato per lo scopo specificato, altrimenti false uso utilizza questo metodo per determinare se il consenso è stato concesso per uno scopo particolare isfeaturecookiesenabled() boolean descrizione verifica se il consenso è abilitato per i cookie delle funzionalità returns true se il consenso è abilitato per i cookie delle funzionalità, altrimenti false uso utilizza questo metodo per determinare se il consenso è stato concesso per i cookie delle funzionalità isuserexperiencecookiesenabled() boolean descrizione verifica se il consenso è abilitato per i cookie dell'esperienza utente returns true se il consenso è abilitato per i cookie dell'esperienza utente, altrimenti false uso utilizza questo metodo per determinare se il consenso è stato concesso per i cookie dell'esperienza utente ismeasurementcookiesenabled() boolean descrizione verifica se il consenso è abilitato per i cookie di misurazione returns true se il consenso è abilitato per i cookie di misurazione, altrimenti uso utilizza questo metodo per determinare se il consenso è stato concesso per i cookie di misurazione getgoogleconsentmode() map\<googleconsentmodetype, googleconsentmodestatus>? descrizione recupera lo stato del google consent mode per i vari tipi di consenso supportati returns una mappa contenente i tipi di consenso (googleconsentmodetype) e il relativo stato (googleconsentmodestatus) restituisce null se nessuna configurazione è disponibile uso utilizza questo metodo per ottenere lo stato dei consensi associati al google consent mode e determinare se il consenso è stato concesso, negato o è sconosciuto per ciascun tipo di consenso api per il cmptype google consent mode quando il consenso è relativo alla cmp basata solo su google consent mode (ovvero consentapiinterface getcmptype() == cmptype google consent mode ) avrete a disposizione le seguenti api getgoogleconsentmode() map\<googleconsentmodetype, googleconsentmodestatus>? descrizione recupera lo stato del google consent mode per i vari tipi di consenso supportati returns una mappa contenente i tipi di consenso (googleconsentmodetype) e il relativo stato (googleconsentmodestatus) restituisce null se nessuna configurazione è disponibile uso utilizza questo metodo per ottenere lo stato dei consensi associati al google consent mode e determinare se il consenso è stato concesso, negato o è sconosciuto per ciascun tipo di consenso troubleshooting proguard bugs proguard può talvolta offuscare i nomi delle classi o rimuovere i metodi che vengono richiamati dinamicamente tramite reflection per risolvere questo problema, è necessario specificare le classi e i metodi che devono rimanere intatti nel file di configurazione di proguard utilizzando la direttiva keep