@byvik/capacitor-ump-consent 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 byVik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,284 @@
-# Temporary Holding Version
+# @byvik/capacitor-ump-consent
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Google's User Messaging Platform (UMP) consent form for Capacitor, with the answer translated to **Consent Mode v2**.
+
+- Standalone: it does not bundle or require an AdMob plugin, so it works with whatever ads integration you already have.
+- Reads the TCF answer UMP stores and maps it to the four Consent Mode signals.
+- Applies those signals to Firebase Analytics when your app includes it, and returns them either way.
+- Never rejects: a network error or a form that fails to load cannot keep your app from starting.
+- Android only. On iOS and web every method rejects, so guard calls with `Capacitor.getPlatform() === 'android'`.
+
+This plugin is a tool, not legal advice. You are responsible for how your app handles consent.
+
+## Install
+
+```bash
+npm install @byvik/capacitor-ump-consent
+npx cap sync
+```
+
+Requires Capacitor 8.
+
+## Setup
+
+1. Create a consent message for your app in AdMob under **Privacy & messaging**.
+
+2. UMP finds that message through your AdMob app ID. If your ads integration has not already added it, put it inside `<application>` in `android/app/src/main/AndroidManifest.xml`:
+
+   ```xml
+   <meta-data
+       android:name="com.google.android.gms.ads.APPLICATION_ID"
+       android:value="ca-app-pub-xxxxxxxxxxxxxxxx~yyyyyyyyyy" />
+   ```
+
+3. If you use Firebase Analytics, deny everything by default in the same place:
+
+   ```xml
+   <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" />
+   ```
+
+   The defaults have to live in the manifest. Firebase starts with the process, before any plugin code runs, so defaults set from JavaScript would leave a window in which the SDK is already collecting with its permissive factory settings.
+
+### Variables
+
+Set these in `android/variables.gradle` to override the defaults:
+
+- `umpVersion`: version of `com.google.android.ump:user-messaging-platform` (default: `3.1.0`)
+- `firebaseAnalyticsVersion`: version of `com.google.firebase:firebase-analytics` the plugin compiles against (default: `22.1.2`). The plugin does not add Firebase to your app.
+
+## Usage
+
+```ts
+import { UmpConsent } from '@byvik/capacitor-ump-consent';
+
+// On every launch, before initializing ads.
+const state = await UmpConsent.requestConsent();
+if (state.canRequestAds) {
+  // initialize your ads SDK
+}
+
+// In your settings screen.
+if (state.privacyOptionsRequired) {
+  showPrivacyRow(() => UmpConsent.showPrivacyOptionsForm());
+}
+```
+
+### Consent Mode
+
+After each request or change, the plugin reads what UMP stored and derives:
+
+| Signal               | Granted when                    |
+| -------------------- | ------------------------------- |
+| `analytics_storage`  | TCF purpose 1 is consented      |
+| `ad_storage`         | TCF purpose 1 is consented      |
+| `ad_user_data`       | TCF purposes 1 and 7 are consented |
+| `ad_personalization` | TCF purposes 3 and 4 are consented |
+
+The three ad signals follow the mapping Google documents for TCF. TCF has no purpose for analytics; tying `analytics_storage` to purpose 1 is this plugin's choice.
+
+Where GDPR does not apply (UMP reports that no consent is required), all four are granted. With the manifest defaults above, users outside the regulated regions would otherwise never be measured.
+
+Until UMP knows whether the user has to be asked, for example on a first launch without network, nothing is granted and nothing is applied: your manifest defaults stay in force.
+
+Google's SDKs can infer the three ad signals from the TC string on their own, but only when the CMP writes `IABTCF_EnableAdvertiserConsentMode = 1`. This plugin does not rely on that flag, and it also sets `analytics_storage`.
+
+Only TCF (GDPR) messages are mapped. Other message types, such as US state regulations, are not translated to Consent Mode: for those users the four signals are granted.
+
+The same signals are returned in `ConsentState.consentMode`. To apply them yourself, turn the automatic step off:
+
+<docgen-config>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+| Prop                      | Type                 | Description                                                                                                                                                                                                                                                   | Default           | Since |
+| ------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ----- |
+| **`firebaseConsentMode`** | <code>boolean</code> | Apply the consent to Firebase Analytics (Consent Mode v2) every time the consent is requested or changed. Has no effect in apps that do not include Firebase Analytics. Set it to `false` if you apply Consent Mode yourself from `ConsentState.consentMode`. | <code>true</code> | 0.1.0 |
+
+### Examples
+
+In `capacitor.config.json`:
+
+```json
+{
+  "plugins": {
+    "UmpConsent": {
+      "firebaseConsentMode": false
+    }
+  }
+}
+```
+
+In `capacitor.config.ts`:
+
+```ts
+/// <reference types="@byvik/capacitor-ump-consent" />
+
+import { CapacitorConfig } from '@capacitor/cli';
+
+const config: CapacitorConfig = {
+  plugins: {
+    UmpConsent: {
+      firebaseConsentMode: false,
+    },
+  },
+};
+
+export default config;
+```
+
+</docgen-config>
+
+### Testing
+
+Run the app once, find the line UMP prints to logcat with your device's hashed ID, and pass it:
+
+```ts
+await UmpConsent.reset();
+await UmpConsent.requestConsent({
+  debugGeography: 'eea',
+  testDeviceIds: ['33BE2250B43518CCDA7DE426D04EE231'],
+});
+```
+
+## API
+
+<docgen-index>
+
+* [`requestConsent(...)`](#requestconsent)
+* [`showPrivacyOptionsForm()`](#showprivacyoptionsform)
+* [`getConsentState()`](#getconsentstate)
+* [`reset()`](#reset)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### requestConsent(...)
+
+```typescript
+requestConsent(options?: RequestConsentOptions | undefined) => Promise<ConsentState>
+```
+
+Update the consent information and show the consent form if it is
+required. Call it on every app launch, before initializing any ads SDK.
+
+Never rejects: when the request or the form fails it resolves with the
+stored state and an `error` message.
+
+| Param         | Type                                                                    |
+| ------------- | ----------------------------------------------------------------------- |
+| **`options`** | <code><a href="#requestconsentoptions">RequestConsentOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#consentstate">ConsentState</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### showPrivacyOptionsForm()
+
+```typescript
+showPrivacyOptionsForm() => Promise<ConsentState>
+```
+
+Show the privacy options form so the user can change their choice.
+Offer it when `privacyOptionsRequired` is `true`. Never rejects.
+
+**Returns:** <code>Promise&lt;<a href="#consentstate">ConsentState</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### getConsentState()
+
+```typescript
+getConsentState() => Promise<ConsentState>
+```
+
+The stored consent state, without any network request or UI.
+
+`gdprApplies`, `purposeConsents` and `consentMode` are read from storage
+and are valid from the start. `status` and `canRequestAds` come from UMP,
+which reports `'unknown'` and `false` until `requestConsent()` has been
+called in the current launch.
+
+**Returns:** <code>Promise&lt;<a href="#consentstate">ConsentState</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### reset()
+
+```typescript
+reset() => Promise<void>
+```
+
+Forget the stored consent so the form shows again. For testing only.
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### ConsentState
+
+| Prop                         | Type                                                              | Description                                                                                                                                          | Since |
+| ---------------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`canRequestAds`**          | <code>boolean</code>                                              | Whether ads can be requested. Initialize your ads SDK only when this is `true`.                                                                      | 0.1.0 |
+| **`status`**                 | <code><a href="#consentstatus">ConsentStatus</a></code>           | UMP's consent status.                                                                                                                                | 0.1.0 |
+| **`privacyOptionsRequired`** | <code>boolean</code>                                              | Whether the app must offer a way to reopen the privacy options form, for example a row in its settings screen that calls `showPrivacyOptionsForm()`. | 0.1.0 |
+| **`gdprApplies`**            | <code>boolean</code>                                              | Whether GDPR applies to this user, as stored by UMP in `IABTCF_gdprApplies`.                                                                         | 0.1.0 |
+| **`purposeConsents`**        | <code>string</code>                                               | The raw `IABTCF_PurposeConsents` string: character `n - 1` is `'1'` when TCF purpose `n` is consented. Empty when there is none.                     | 0.1.0 |
+| **`consentMode`**            | <code><a href="#consentmodesignals">ConsentModeSignals</a></code> | The answer translated to Consent Mode v2. Everything is `false` until UMP knows whether this user has to be asked.                                   | 0.1.0 |
+| **`error`**                  | <code>string</code>                                               | Message of the error that interrupted the request or the form, if any. The rest of the state is still valid: it reflects what UMP has stored.        | 0.1.0 |
+
+
+#### ConsentModeSignals
+
+| Prop                    | Type                 | Since |
+| ----------------------- | -------------------- | ----- |
+| **`analyticsStorage`**  | <code>boolean</code> | 0.1.0 |
+| **`adStorage`**         | <code>boolean</code> | 0.1.0 |
+| **`adUserData`**        | <code>boolean</code> | 0.1.0 |
+| **`adPersonalization`** | <code>boolean</code> | 0.1.0 |
+
+
+#### RequestConsentOptions
+
+| Prop                          | Type                                                      | Description                                                                                                            | Default            | Since |
+| ----------------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
+| **`tagForUnderAgeOfConsent`** | <code>boolean</code>                                      | Tell UMP the user is under the age of consent.                                                                         | <code>false</code> | 0.1.0 |
+| **`debugGeography`**          | <code><a href="#debuggeography">DebugGeography</a></code> | Make a test device behave as if it were in this geography. Only applies to devices listed in `testDeviceIds`.          |                    | 0.1.0 |
+| **`testDeviceIds`**           | <code>string[]</code>                                     | Hashed IDs of the test devices. UMP prints the ID of the current device to logcat the first time consent is requested. |                    | 0.1.0 |
+
+
+### Type Aliases
+
+
+#### ConsentStatus
+
+<code>'unknown' | 'notRequired' | 'required' | 'obtained'</code>
+
+
+#### DebugGeography
+
+<code>'disabled' | 'eea' | 'regulatedUsState' | 'other'</code>
+
+</docgen-api>
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,57 @@
+ext {
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    umpVersion = project.hasProperty('umpVersion') ? rootProject.ext.umpVersion : '3.1.0'
+    firebaseAnalyticsVersion = project.hasProperty('firebaseAnalyticsVersion') ? rootProject.ext.firebaseAnalyticsVersion : '22.1.2'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "com.byvik.capacitor.umpconsent"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "com.google.android.ump:user-messaging-platform:$umpVersion"
+    // Compile-only: Consent Mode is applied only in apps that ship Firebase Analytics themselves.
+    compileOnly "com.google.firebase:firebase-analytics:$firebaseAnalyticsVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/byvik/capacitor/umpconsent/FirebaseConsentMode.java

@@ -0,0 +1,33 @@
+package com.byvik.capacitor.umpconsent;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import com.google.firebase.analytics.FirebaseAnalytics.ConsentStatus;
+import com.google.firebase.analytics.FirebaseAnalytics.ConsentType;
+import java.util.EnumMap;
+
+/**
+ * The only class that touches Firebase. Keeping it apart lets the plugin load in apps that do not
+ * ship Firebase Analytics: its types are resolved when apply() runs, not when the plugin loads.
+ */
+final class FirebaseConsentMode {
+
+    private FirebaseConsentMode() {}
+
+    // The permissions lint asks for come from Firebase's own manifest, which is present in every
+    // app where this code can run at all.
+    @SuppressLint("MissingPermission")
+    static void apply(Context context, boolean analyticsStorage, boolean adStorage, boolean adUserData, boolean adPersonalization) {
+        EnumMap<ConsentType, ConsentStatus> consent = new EnumMap<>(ConsentType.class);
+        consent.put(ConsentType.ANALYTICS_STORAGE, status(analyticsStorage));
+        consent.put(ConsentType.AD_STORAGE, status(adStorage));
+        consent.put(ConsentType.AD_USER_DATA, status(adUserData));
+        consent.put(ConsentType.AD_PERSONALIZATION, status(adPersonalization));
+        FirebaseAnalytics.getInstance(context).setConsent(consent);
+    }
+
+    private static ConsentStatus status(boolean granted) {
+        return granted ? ConsentStatus.GRANTED : ConsentStatus.DENIED;
+    }
+}

package/android/src/main/java/com/byvik/capacitor/umpconsent/UmpConsentPlugin.java

@@ -0,0 +1,285 @@
+package com.byvik.capacitor.umpconsent;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.google.android.ump.ConsentDebugSettings;
+import com.google.android.ump.ConsentInformation;
+import com.google.android.ump.ConsentRequestParameters;
+import com.google.android.ump.FormError;
+import com.google.android.ump.UserMessagingPlatform;
+
+/**
+ * Google User Messaging Platform (UMP) consent, plus the translation of the answer into the four
+ * Consent Mode v2 signals.
+ *
+ * <p>Showing the form is only half of the job: UMP stores the answer in TCF format, and without
+ * the second half nothing tells Firebase to stop measuring a player who said no.
+ *
+ * <p>No method here rejects. Every path (network error, form that fails to load) resolves with
+ * the current state, so a consent failure can never keep an app from starting.
+ */
+@CapacitorPlugin(name = "UmpConsent")
+public class UmpConsentPlugin extends Plugin {
+
+    // IAB TCF v2 keys. They are an IAB standard, not a Google one: every certified CMP, UMP
+    // included, writes them to the app's default SharedPreferences.
+    private static final String TCF_PURPOSE_CONSENTS = "IABTCF_PurposeConsents";
+    private static final String TCF_GDPR_APPLIES = "IABTCF_gdprApplies";
+
+    private ConsentInformation consentInformation;
+
+    private ConsentInformation info() {
+        if (consentInformation == null) {
+            consentInformation = UserMessagingPlatform.getConsentInformation(getContext());
+        }
+        return consentInformation;
+    }
+
+    @PluginMethod
+    public void requestConsent(PluginCall call) {
+        final Activity activity = getActivity();
+        if (activity == null) {
+            call.resolve(state("Activity not available"));
+            return;
+        }
+
+        ConsentRequestParameters.Builder params = new ConsentRequestParameters.Builder().setTagForUnderAgeOfConsent(
+            Boolean.TRUE.equals(call.getBoolean("tagForUnderAgeOfConsent", false))
+        );
+
+        // Debug settings make a test device behave as if it were somewhere else. Without them the
+        // EEA flow cannot be tried from outside the EEA, and the bug shows up with real users.
+        String geography = call.getString("debugGeography");
+        JSArray testDeviceIds = call.getArray("testDeviceIds");
+        if (geography != null || testDeviceIds != null) {
+            ConsentDebugSettings.Builder debug = new ConsentDebugSettings.Builder(getContext());
+            if (geography != null) {
+                debug.setDebugGeography(debugGeography(geography));
+            }
+            if (testDeviceIds != null) {
+                for (int i = 0; i < testDeviceIds.length(); i++) {
+                    String id = testDeviceIds.optString(i, null);
+                    if (id != null) {
+                        debug.addTestDeviceHashedId(id);
+                    }
+                }
+            }
+            params.setConsentDebugSettings(debug.build());
+        }
+
+        try {
+            info().requestConsentInfoUpdate(
+                activity,
+                params.build(),
+                () ->
+                    activity.runOnUiThread(() ->
+                        UserMessagingPlatform.loadAndShowConsentFormIfRequired(activity, (formError) -> finish(call, formError))
+                    ),
+                (requestError) -> finish(call, requestError)
+            );
+        } catch (Throwable t) {
+            call.resolve(state(String.valueOf(t.getMessage())));
+        }
+    }
+
+    @PluginMethod
+    public void showPrivacyOptionsForm(PluginCall call) {
+        final Activity activity = getActivity();
+        if (activity == null) {
+            call.resolve(state("Activity not available"));
+            return;
+        }
+        activity.runOnUiThread(() -> UserMessagingPlatform.showPrivacyOptionsForm(activity, (formError) -> finish(call, formError)));
+    }
+
+    @PluginMethod
+    public void getConsentState(PluginCall call) {
+        call.resolve(state(null));
+    }
+
+    @PluginMethod
+    public void reset(PluginCall call) {
+        try {
+            info().reset();
+        } catch (Throwable ignored) {
+            // Nothing to reset.
+        }
+        call.resolve();
+    }
+
+    // A failed form grants nothing by itself: what counts is whatever UMP has stored.
+    private void finish(PluginCall call, FormError error) {
+        applyConsentMode();
+        call.resolve(state(error == null ? null : error.getMessage()));
+    }
+
+    @ConsentDebugSettings.DebugGeography
+    private static int debugGeography(String value) {
+        switch (value) {
+            case "eea":
+                return ConsentDebugSettings.DebugGeography.DEBUG_GEOGRAPHY_EEA;
+            case "regulatedUsState":
+                return ConsentDebugSettings.DebugGeography.DEBUG_GEOGRAPHY_REGULATED_US_STATE;
+            case "other":
+                return ConsentDebugSettings.DebugGeography.DEBUG_GEOGRAPHY_OTHER;
+            default:
+                return ConsentDebugSettings.DebugGeography.DEBUG_GEOGRAPHY_DISABLED;
+        }
+    }
+
+    // ---------- TCF -> Consent Mode ----------
+
+    private static final class Signals {
+
+        // False until UMP has said whether this user needs to be asked. While it is false nothing
+        // is granted and nothing is applied, so the app's manifest defaults stay in force.
+        boolean known;
+        boolean gdprApplies;
+        String purposeConsents = "";
+        boolean analyticsStorage;
+        boolean adStorage;
+        boolean adUserData;
+        boolean adPersonalization;
+    }
+
+    private SharedPreferences defaultPreferences() {
+        Context context = getContext();
+        return context.getSharedPreferences(context.getPackageName() + "_preferences", Context.MODE_PRIVATE);
+    }
+
+    private int consentStatus() {
+        try {
+            return info().getConsentStatus();
+        } catch (Throwable t) {
+            return ConsentInformation.ConsentStatus.UNKNOWN;
+        }
+    }
+
+    // The TCF string is positional: the character at n - 1 is '1' when purpose n is consented.
+    private static boolean purpose(String purposeConsents, int n) {
+        return purposeConsents.length() >= n && purposeConsents.charAt(n - 1) == '1';
+    }
+
+    // The mapping Google documents for TCF, plus analytics_storage, which TCF does not cover and
+    // is tied here to purpose 1 (store and/or access information on a device):
+    //
+    //   analytics_storage   <- purpose 1
+    //   ad_storage          <- purpose 1
+    //   ad_user_data        <- purposes 1 and 7
+    //   ad_personalization  <- purposes 3 and 4
+    //
+    // Where GDPR does not apply everything is granted. That is the correct reading of "no need to
+    // ask here": apps that default to denied in the manifest would otherwise never measure anyone
+    // outside the regulated regions.
+    private Signals signals() {
+        Signals s = new Signals();
+        SharedPreferences prefs = defaultPreferences();
+        int status = consentStatus();
+        boolean hasGdprKey = prefs.contains(TCF_GDPR_APPLIES);
+
+        s.known =
+            hasGdprKey || status == ConsentInformation.ConsentStatus.NOT_REQUIRED || status == ConsentInformation.ConsentStatus.OBTAINED;
+        if (!s.known) {
+            return s;
+        }
+
+        try {
+            s.gdprApplies = hasGdprKey && prefs.getInt(TCF_GDPR_APPLIES, 0) == 1;
+            String purposes = prefs.getString(TCF_PURPOSE_CONSENTS, "");
+            s.purposeConsents = purposes == null ? "" : purposes;
+        } catch (ClassCastException e) {
+            // Unreadable preferences are treated as "GDPR applies, nothing consented".
+            s.gdprApplies = true;
+        }
+
+        if (!s.gdprApplies) {
+            s.analyticsStorage = true;
+            s.adStorage = true;
+            s.adUserData = true;
+            s.adPersonalization = true;
+        } else {
+            boolean p1 = purpose(s.purposeConsents, 1);
+            s.analyticsStorage = p1;
+            s.adStorage = p1;
+            s.adUserData = p1 && purpose(s.purposeConsents, 7);
+            s.adPersonalization = purpose(s.purposeConsents, 3) && purpose(s.purposeConsents, 4);
+        }
+        return s;
+    }
+
+    private void applyConsentMode() {
+        if (!getConfig().getBoolean("firebaseConsentMode", true)) {
+            return;
+        }
+        Signals s = signals();
+        if (!s.known) {
+            return;
+        }
+        try {
+            FirebaseConsentMode.apply(getContext(), s.analyticsStorage, s.adStorage, s.adUserData, s.adPersonalization);
+        } catch (Throwable t) {
+            // Firebase Analytics is not part of this app, or refused the update. Either way the
+            // manifest defaults stay in force: measuring too little is recoverable, too much is not.
+        }
+    }
+
+    private JSObject state(String error) {
+        Signals s = signals();
+        ConsentInformation info = null;
+        try {
+            info = info();
+        } catch (Throwable ignored) {
+            // Reported below as the most restrictive state.
+        }
+
+        boolean canRequestAds = false;
+        boolean privacyOptionsRequired = false;
+        if (info != null) {
+            try {
+                canRequestAds = info.canRequestAds();
+                privacyOptionsRequired =
+                    info.getPrivacyOptionsRequirementStatus() == ConsentInformation.PrivacyOptionsRequirementStatus.REQUIRED;
+            } catch (Throwable ignored) {
+                // Keep the restrictive defaults.
+            }
+        }
+
+        JSObject consentMode = new JSObject();
+        consentMode.put("analyticsStorage", s.analyticsStorage);
+        consentMode.put("adStorage", s.adStorage);
+        consentMode.put("adUserData", s.adUserData);
+        consentMode.put("adPersonalization", s.adPersonalization);
+
+        JSObject ret = new JSObject();
+        ret.put("canRequestAds", canRequestAds);
+        ret.put("status", statusName(consentStatus()));
+        ret.put("privacyOptionsRequired", privacyOptionsRequired);
+        ret.put("gdprApplies", s.gdprApplies);
+        ret.put("purposeConsents", s.purposeConsents);
+        ret.put("consentMode", consentMode);
+        if (error != null) {
+            ret.put("error", error);
+        }
+        return ret;
+    }
+
+    private static String statusName(int status) {
+        switch (status) {
+            case ConsentInformation.ConsentStatus.NOT_REQUIRED:
+                return "notRequired";
+            case ConsentInformation.ConsentStatus.REQUIRED:
+                return "required";
+            case ConsentInformation.ConsentStatus.OBTAINED:
+                return "obtained";
+            default:
+                return "unknown";
+        }
+    }
+}