@capawesome/capacitor-age-signals 0.3.0 → 0.3.2

package/README.md

@@ -12,6 +12,20 @@ Capacitor plugin to use the [Play Age Signals API](https://developer.android.com
 
     The **Play Age Signals API** is returning "Not yet implemented" because its live functionality is scheduled to begin on January 1, 2026.
 
+## Features
+
+We are proud to offer one of the most complete and feature-rich Capacitor plugins for age verification. Here are some of the key features:
+
+- 🖥️ **Cross-platform**: Supports Android and iOS.
+- 🔍 **Age Verification**: Request user age signals using Play Age Signals API (Android) and DeclaredAgeRange (iOS).
+- 👨‍👩‍👧‍👦 **Parental Controls**: Support for supervised accounts with parental approval status.
+- 🧪 **Testing Support**: Built-in `FakeAgeSignalsManager` integration for testing different age verification scenarios (Android).
+- 🌍 **Compliance Ready**: Built for US state age verification requirements (effective January 1, 2026).
+- 📦 **SPM**: Supports Swift Package Manager for iOS.
+- 🔁 **Up-to-date**: Always supports the latest Capacitor version.
+
+Missing a feature? Just [open an issue](https://github.com/capawesome-team/capacitor-plugins/issues) and we'll take a look!
+
 ## Compatibility
 
 | Plugin Version | Capacitor Version | Status         |
@@ -36,6 +50,8 @@ If needed, you can define the following project variable in your app's `variable
 
 This can be useful if you encounter dependency conflicts with other plugins in your project.
 
+**Note**: The `FakeAgeSignalsManager` testing API is included in the main `age-signals` library, so no additional dependency is required for testing.
+
 ### iOS
 
 #### Entitlements
@@ -64,6 +80,110 @@ const checkAgeSignals = async () => {
   console.log('Age Lower:', result.ageLower);
   console.log('Age Upper:', result.ageUpper);
 };
+
+const checkEligibility = async () => {
+  const result = await AgeSignals.checkEligibility();
+  console.log('Is Eligible:', result.isEligible);
+};
+```
+
+## Testing
+
+The plugin includes support for the `FakeAgeSignalsManager` API on Android, which allows you to simulate different age signals scenarios in your tests without requiring live responses from Google Play.
+
+### Android Testing
+
+**Important**: Due to a known issue in versions 0.0.1 and 0.0.2 of the Age Signals API, you may encounter a `java.lang.VerifyError` when calling the builder method of `AgeSignalsResult` in unit tests. As a workaround, run your tests as Android instrumented tests within the `androidTest` source set.
+
+#### Example: Testing a Verified Adult User
+
+```typescript
+import { AgeSignals, UserStatus } from '@capawesome/capacitor-age-signals';
+
+// Enable the fake manager
+await AgeSignals.setUseFakeManager({ useFake: true });
+
+// Set up a verified adult user
+await AgeSignals.setNextAgeSignalsResult({
+  userStatus: UserStatus.Verified,
+});
+
+// Check age signals - will return the fake result
+const result = await AgeSignals.checkAgeSignals();
+console.log(result.userStatus); // 'VERIFIED'
+```
+
+#### Example: Testing a Supervised User (13-17 years old)
+
+```typescript
+import { AgeSignals, UserStatus } from '@capawesome/capacitor-age-signals';
+
+await AgeSignals.setUseFakeManager({ useFake: true });
+
+await AgeSignals.setNextAgeSignalsResult({
+  userStatus: UserStatus.Supervised,
+  ageLower: 13,
+  ageUpper: 17,
+  installId: 'fake_install_id',
+});
+
+const result = await AgeSignals.checkAgeSignals();
+console.log(result.userStatus); // 'SUPERVISED'
+console.log(result.ageLower); // 13
+console.log(result.ageUpper); // 17
+console.log(result.installId); // 'fake_install_id'
+```
+
+#### Example: Testing Parental Approval Scenarios
+
+```typescript
+import { AgeSignals, UserStatus } from '@capawesome/capacitor-age-signals';
+
+await AgeSignals.setUseFakeManager({ useFake: true });
+
+// Test pending approval
+await AgeSignals.setNextAgeSignalsResult({
+  userStatus: UserStatus.SupervisedApprovalPending,
+  ageLower: 13,
+  ageUpper: 17,
+  mostRecentApprovalDate: '2025-02-01',
+  installId: 'fake_install_id',
+});
+
+const result = await AgeSignals.checkAgeSignals();
+console.log(result.userStatus); // 'SUPERVISED_APPROVAL_PENDING'
+console.log(result.mostRecentApprovalDate); // '2025-02-01'
+```
+
+#### Example: Testing Error Scenarios
+
+```typescript
+import { AgeSignals, ErrorCode } from '@capawesome/capacitor-age-signals';
+
+await AgeSignals.setUseFakeManager({ useFake: true });
+
+// Simulate a network error
+await AgeSignals.setNextAgeSignalsException({
+  errorCode: ErrorCode.NetworkError,
+});
+
+try {
+  await AgeSignals.checkAgeSignals();
+} catch (error) {
+  console.log('Caught network error:', error);
+}
+```
+
+#### Disabling the Fake Manager
+
+```typescript
+import { AgeSignals } from '@capawesome/capacitor-age-signals';
+
+// Switch back to the production manager
+await AgeSignals.setUseFakeManager({ useFake: false });
+
+// This will now use the real Age Signals API
+const result = await AgeSignals.checkAgeSignals();
 ```
 
 ## API
@@ -71,6 +191,10 @@ const checkAgeSignals = async () => {
 <docgen-index>
 
 * [`checkAgeSignals(...)`](#checkagesignals)
+* [`checkEligibility()`](#checkeligibility)
+* [`setUseFakeManager(...)`](#setusefakemanager)
+* [`setNextAgeSignalsResult(...)`](#setnextagesignalsresult)
+* [`setNextAgeSignalsException(...)`](#setnextagesignalsexception)
 * [Interfaces](#interfaces)
 * [Enums](#enums)
 
@@ -98,6 +222,80 @@ Request the user's age signals.
 --------------------
 
 
+### checkEligibility()
+
+```typescript
+checkEligibility() => Promise<CheckEligibilityResult>
+```
+
+Check if the user is eligible for age-gated features.
+
+Only available on iOS.
+
+**Returns:** <code>Promise&lt;<a href="#checkeligibilityresult">CheckEligibilityResult</a>&gt;</code>
+
+**Since:** 0.3.1
+
+--------------------
+
+
+### setUseFakeManager(...)
+
+```typescript
+setUseFakeManager(options: SetUseFakeManagerOptions) => Promise<void>
+```
+
+Enable or disable the fake age signals manager for testing.
+
+Only available on Android.
+
+| Param         | Type                                                                          |
+| ------------- | ----------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#setusefakemanageroptions">SetUseFakeManagerOptions</a></code> |
+
+**Since:** 0.3.1
+
+--------------------
+
+
+### setNextAgeSignalsResult(...)
+
+```typescript
+setNextAgeSignalsResult(options: SetNextAgeSignalsResultOptions) => Promise<void>
+```
+
+Set the next age signals result to be returned by the fake manager.
+
+Only available on Android.
+
+| Param         | Type                                                                                      |
+| ------------- | ----------------------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#setnextagesignalsresultoptions">SetNextAgeSignalsResultOptions</a></code> |
+
+**Since:** 0.3.1
+
+--------------------
+
+
+### setNextAgeSignalsException(...)
+
+```typescript
+setNextAgeSignalsException(options: SetNextAgeSignalsExceptionOptions) => Promise<void>
+```
+
+Set the next exception to be thrown by the fake manager.
+
+Only available on Android.
+
+| Param         | Type                                                                                            |
+| ------------- | ----------------------------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#setnextagesignalsexceptionoptions">SetNextAgeSignalsExceptionOptions</a></code> |
+
+**Since:** 0.3.1
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -119,6 +317,38 @@ Request the user's age signals.
 | **`ageGates`** | <code>number[]</code> | The age ranges that the user falls into. The provided array must contain at least 2 and at most 3 ages. Only available on iOS. | <code>[13, 15, 18]</code> | 0.0.2 |
 
 
+#### CheckEligibilityResult
+
+| Prop             | Type                 | Description                                                                                                                                                                                   | Since |
+| ---------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`isEligible`** | <code>boolean</code> | Whether the user is eligible for age-gated features. Returns `true` if the user is in an applicable region that requires additional age-related obligations. Always returns `false` on macOS. | 0.3.1 |
+
+
+#### SetUseFakeManagerOptions
+
+| Prop          | Type                 | Description                                              | Default            | Since |
+| ------------- | -------------------- | -------------------------------------------------------- | ------------------ | ----- |
+| **`useFake`** | <code>boolean</code> | Whether to use the fake age signals manager for testing. | <code>false</code> | 0.3.1 |
+
+
+#### SetNextAgeSignalsResultOptions
+
+| Prop                         | Type                                              | Description                                                                                                                                                                                                                                                                            | Since |
+| ---------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`userStatus`**             | <code><a href="#userstatus">UserStatus</a></code> | The user's verification status.                                                                                                                                                                                                                                                        | 0.3.1 |
+| **`ageLower`**               | <code>number</code>                               | The (inclusive) lower bound of a supervised user's age range. Only available when `userStatus` is `SUPERVISED`, `SUPERVISED_APPROVAL_PENDING`, or `SUPERVISED_APPROVAL_DENIED`.                                                                                                        | 0.3.1 |
+| **`ageUpper`**               | <code>number</code>                               | The (inclusive) upper bound of a supervised user's age range. Only available when `userStatus` is `SUPERVISED`, `SUPERVISED_APPROVAL_PENDING`, or `SUPERVISED_APPROVAL_DENIED` and the user's age is under 18.                                                                         | 0.3.1 |
+| **`mostRecentApprovalDate`** | <code>string</code>                               | The effective from date of the most recent significant change that was approved. When an app is installed, the date of the most recent significant change prior to install is used. Only available when `userStatus` is `SUPERVISED_APPROVAL_PENDING` or `SUPERVISED_APPROVAL_DENIED`. | 0.3.1 |
+| **`installId`**              | <code>string</code>                               | An ID assigned to supervised user installs by Google Play, used for the purposes of notifying you of revoked app approval. Only available when `userStatus` is `SUPERVISED`, `SUPERVISED_APPROVAL_PENDING`, or `SUPERVISED_APPROVAL_DENIED`.                                           | 0.3.1 |
+
+
+#### SetNextAgeSignalsExceptionOptions
+
+| Prop            | Type                                            | Description                                      | Since |
+| --------------- | ----------------------------------------------- | ------------------------------------------------ | ----- |
+| **`errorCode`** | <code><a href="#errorcode">ErrorCode</a></code> | The error code to be thrown by the fake manager. | 0.3.1 |
+
+
 ### Enums
 
 
@@ -133,6 +363,22 @@ Request the user's age signals.
 | **`Unknown`**                   | <code>'UNKNOWN'</code>                     | The user is not verified or supervised in applicable jurisdictions and regions. These users could be over or under 18. To obtain an age signal from Google Play, ask the user to visit the Play Store to resolve their status.                                                                 | 0.0.1 |
 | **`Empty`**                     | <code>'EMPTY'</code>                       | All other users return this value.                                                                                                                                                                                                                                                             | 0.0.1 |
 
+
+#### ErrorCode
+
+| Members                           | Value                                         | Description                                                                                                                                                      | Since |
+| --------------------------------- | --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`ApiNotAvailable`**             | <code>'API_NOT_AVAILABLE'</code>              | The Play Age Signals API is not available. The Play Store app version installed on the device might be old.                                                      | 0.0.1 |
+| **`PlayStoreNotFound`**           | <code>'PLAY_STORE_NOT_FOUND'</code>           | No Play Store app is found on the device.                                                                                                                        | 0.0.1 |
+| **`NetworkError`**                | <code>'NETWORK_ERROR'</code>                  | No available network is found.                                                                                                                                   | 0.0.1 |
+| **`PlayServicesNotFound`**        | <code>'PLAY_SERVICES_NOT_FOUND'</code>        | Play Services is not available or its version is too old.                                                                                                        | 0.0.1 |
+| **`CannotBindToService`**         | <code>'CANNOT_BIND_TO_SERVICE'</code>         | Binding to the service in the Play Store has failed. This can be due to having an old Play Store version installed on the device or device memory is overloaded. | 0.0.1 |
+| **`PlayStoreVersionOutdated`**    | <code>'PLAY_STORE_VERSION_OUTDATED'</code>    | The Play Store app needs to be updated.                                                                                                                          | 0.0.1 |
+| **`PlayServicesVersionOutdated`** | <code>'PLAY_SERVICES_VERSION_OUTDATED'</code> | Play Services needs to be updated.                                                                                                                               | 0.0.1 |
+| **`ClientTransientError`**        | <code>'CLIENT_TRANSIENT_ERROR'</code>         | There was a transient error in the client device.                                                                                                                | 0.0.1 |
+| **`AppNotOwned`**                 | <code>'APP_NOT_OWNED'</code>                  | The app was not installed by Google Play.                                                                                                                        | 0.0.1 |
+| **`InternalError`**               | <code>'INTERNAL_ERROR'</code>                 | Unknown internal error.                                                                                                                                          | 0.0.1 |
+
 </docgen-api>
 
 ## Changelog

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/AgeSignals.java

@@ -1,13 +1,19 @@
 package io.capawesome.capacitorjs.plugins.agesignals;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import com.google.android.gms.tasks.Task;
 import com.google.android.play.agesignals.AgeSignalsManager;
 import com.google.android.play.agesignals.AgeSignalsManagerFactory;
 import com.google.android.play.agesignals.AgeSignalsRequest;
 import com.google.android.play.agesignals.AgeSignalsResult;
+import com.google.android.play.agesignals.testing.FakeAgeSignalsManager;
 import io.capawesome.capacitorjs.plugins.agesignals.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetNextAgeSignalsExceptionOptions;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetNextAgeSignalsResultOptions;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetUseFakeManagerOptions;
 import io.capawesome.capacitorjs.plugins.agesignals.classes.results.CheckAgeSignalsResult;
+import io.capawesome.capacitorjs.plugins.agesignals.interfaces.EmptyCallback;
 import io.capawesome.capacitorjs.plugins.agesignals.interfaces.NonEmptyResultCallback;
 
 public class AgeSignals {
@@ -15,12 +21,23 @@ public class AgeSignals {
     @NonNull
     private final AgeSignalsPlugin plugin;
 
+    private boolean useFakeManager = false;
+
+    @Nullable
+    private FakeAgeSignalsManager fakeManager = null;
+
     public AgeSignals(@NonNull AgeSignalsPlugin plugin) {
         this.plugin = plugin;
     }
 
     public void checkAgeSignals(@NonNull NonEmptyResultCallback<CheckAgeSignalsResult> callback) {
-        AgeSignalsManager manager = AgeSignalsManagerFactory.create(plugin.getActivity());
+        AgeSignalsManager manager;
+        if (useFakeManager && fakeManager != null) {
+            manager = fakeManager;
+        } else {
+            manager = AgeSignalsManagerFactory.create(plugin.getActivity());
+        }
+
         AgeSignalsRequest request = AgeSignalsRequest.builder().build();
 
         Task<AgeSignalsResult> task = manager.checkAgeSignals(request);
@@ -38,6 +55,46 @@ public class AgeSignals {
         });
     }
 
+    public void setUseFakeManager(@NonNull SetUseFakeManagerOptions options, @NonNull EmptyCallback callback) {
+        try {
+            this.useFakeManager = options.getUseFake();
+            if (this.useFakeManager) {
+                this.fakeManager = new FakeAgeSignalsManager();
+            } else {
+                this.fakeManager = null;
+            }
+            callback.success();
+        } catch (Exception exception) {
+            callback.error(exception);
+        }
+    }
+
+    public void setNextAgeSignalsResult(@NonNull SetNextAgeSignalsResultOptions options, @NonNull EmptyCallback callback) {
+        try {
+            if (!useFakeManager || fakeManager == null) {
+                throw CustomExceptions.FAKE_MANAGER_NOT_ENABLED;
+            }
+            com.google.android.play.agesignals.AgeSignalsResult result = options.buildAgeSignalsResult();
+            fakeManager.setNextAgeSignalsResult(result);
+            callback.success();
+        } catch (Exception exception) {
+            callback.error(exception);
+        }
+    }
+
+    public void setNextAgeSignalsException(@NonNull SetNextAgeSignalsExceptionOptions options, @NonNull EmptyCallback callback) {
+        try {
+            if (!useFakeManager || fakeManager == null) {
+                throw CustomExceptions.FAKE_MANAGER_NOT_ENABLED;
+            }
+            com.google.android.play.agesignals.AgeSignalsException exception = options.buildAgeSignalsException();
+            fakeManager.setNextAgeSignalsException(exception);
+            callback.success();
+        } catch (Exception exception) {
+            callback.error(exception);
+        }
+    }
+
     @NonNull
     private Exception mapErrorCodeToException(@NonNull Exception exception) {
         if (!(exception instanceof com.google.android.gms.common.api.ApiException)) {

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/AgeSignalsPlugin.java

@@ -8,7 +8,11 @@ import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetNextAgeSignalsExceptionOptions;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetNextAgeSignalsResultOptions;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.options.SetUseFakeManagerOptions;
 import io.capawesome.capacitorjs.plugins.agesignals.classes.results.CheckAgeSignalsResult;
+import io.capawesome.capacitorjs.plugins.agesignals.interfaces.EmptyCallback;
 import io.capawesome.capacitorjs.plugins.agesignals.interfaces.NonEmptyResultCallback;
 import io.capawesome.capacitorjs.plugins.agesignals.interfaces.Result;
 
@@ -50,6 +54,80 @@ public class AgeSignalsPlugin extends Plugin {
         }
     }
 
+    @PluginMethod
+    public void checkEligibility(PluginCall call) {
+        rejectCallAsUnimplemented(call);
+    }
+
+    @PluginMethod
+    public void setUseFakeManager(PluginCall call) {
+        try {
+            SetUseFakeManagerOptions options = new SetUseFakeManagerOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.setUseFakeManager(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void setNextAgeSignalsResult(PluginCall call) {
+        try {
+            SetNextAgeSignalsResultOptions options = new SetNextAgeSignalsResultOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.setNextAgeSignalsResult(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void setNextAgeSignalsException(PluginCall call) {
+        try {
+            SetNextAgeSignalsExceptionOptions options = new SetNextAgeSignalsExceptionOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.setNextAgeSignalsException(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
     private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
         String message = exception.getMessage();
         if (message == null) {
@@ -59,6 +137,14 @@ public class AgeSignalsPlugin extends Plugin {
         call.reject(message);
     }
 
+    private void rejectCallAsUnimplemented(@NonNull PluginCall call) {
+        call.unimplemented("This method is not available on this platform.");
+    }
+
+    private void resolveCall(@NonNull PluginCall call) {
+        call.resolve();
+    }
+
     private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
         if (result == null) {
             call.resolve();

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/classes/CustomExceptions.java

@@ -33,4 +33,6 @@ public class CustomExceptions {
     );
     public static final CustomException APP_NOT_OWNED = new CustomException("APP_NOT_OWNED", "The app was not installed by Google Play.");
     public static final CustomException INTERNAL_ERROR = new CustomException("INTERNAL_ERROR", "Unknown internal error.");
+    public static final CustomException USER_STATUS_MISSING = new CustomException(null, "userStatus must be provided.");
+    public static final CustomException FAKE_MANAGER_NOT_ENABLED = new CustomException(null, "Fake manager is not enabled.");
 }

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/classes/options/SetNextAgeSignalsExceptionOptions.java

@@ -0,0 +1,53 @@
+package io.capawesome.capacitorjs.plugins.agesignals.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+import com.google.android.play.agesignals.AgeSignalsException;
+import com.google.android.play.agesignals.model.AgeSignalsErrorCode;
+
+public class SetNextAgeSignalsExceptionOptions {
+
+    @NonNull
+    private final String errorCode;
+
+    public SetNextAgeSignalsExceptionOptions(@NonNull PluginCall call) throws Exception {
+        String errorCode = call.getString("errorCode");
+        if (errorCode == null) {
+            throw new Exception("errorCode must be provided.");
+        }
+        this.errorCode = errorCode;
+    }
+
+    @NonNull
+    public AgeSignalsException buildAgeSignalsException() throws Exception {
+        int errorCodeInt = mapErrorCodeToAgeSignalsErrorCode(this.errorCode);
+        return new AgeSignalsException(errorCodeInt);
+    }
+
+    private int mapErrorCodeToAgeSignalsErrorCode(@NonNull String errorCode) throws Exception {
+        switch (errorCode) {
+            case "API_NOT_AVAILABLE":
+                return AgeSignalsErrorCode.API_NOT_AVAILABLE;
+            case "PLAY_STORE_NOT_FOUND":
+                return AgeSignalsErrorCode.PLAY_STORE_NOT_FOUND;
+            case "NETWORK_ERROR":
+                return AgeSignalsErrorCode.NETWORK_ERROR;
+            case "PLAY_SERVICES_NOT_FOUND":
+                return AgeSignalsErrorCode.PLAY_SERVICES_NOT_FOUND;
+            case "CANNOT_BIND_TO_SERVICE":
+                return AgeSignalsErrorCode.CANNOT_BIND_TO_SERVICE;
+            case "PLAY_STORE_VERSION_OUTDATED":
+                return AgeSignalsErrorCode.PLAY_STORE_VERSION_OUTDATED;
+            case "PLAY_SERVICES_VERSION_OUTDATED":
+                return AgeSignalsErrorCode.PLAY_SERVICES_VERSION_OUTDATED;
+            case "CLIENT_TRANSIENT_ERROR":
+                return AgeSignalsErrorCode.CLIENT_TRANSIENT_ERROR;
+            case "APP_NOT_OWNED":
+                return AgeSignalsErrorCode.APP_NOT_OWNED;
+            case "INTERNAL_ERROR":
+                return AgeSignalsErrorCode.INTERNAL_ERROR;
+            default:
+                throw new Exception("Invalid errorCode: " + errorCode);
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/classes/options/SetNextAgeSignalsResultOptions.java

@@ -0,0 +1,109 @@
+package io.capawesome.capacitorjs.plugins.agesignals.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.PluginCall;
+import com.google.android.play.agesignals.AgeSignalsResult;
+import com.google.android.play.agesignals.model.AgeSignalsVerificationStatus;
+import io.capawesome.capacitorjs.plugins.agesignals.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.agesignals.enums.UserStatus;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+public class SetNextAgeSignalsResultOptions {
+
+    @NonNull
+    private final UserStatus userStatus;
+
+    @Nullable
+    private final Integer ageLower;
+
+    @Nullable
+    private final Integer ageUpper;
+
+    @Nullable
+    private final String mostRecentApprovalDate;
+
+    @Nullable
+    private final String installId;
+
+    public SetNextAgeSignalsResultOptions(@NonNull PluginCall call) throws Exception {
+        this.userStatus = SetNextAgeSignalsResultOptions.getUserStatusFromCall(call);
+        this.ageLower = call.getInt("ageLower");
+        this.ageUpper = call.getInt("ageUpper");
+        this.mostRecentApprovalDate = call.getString("mostRecentApprovalDate");
+        this.installId = call.getString("installId");
+    }
+
+    @NonNull
+    public AgeSignalsResult buildAgeSignalsResult() throws Exception {
+        AgeSignalsResult.Builder builder = AgeSignalsResult.builder();
+
+        // Set user status as integer
+        Integer verificationStatus = mapUserStatusToVerificationStatus(this.userStatus);
+        builder.setUserStatus(verificationStatus);
+
+        // Set optional fields
+        if (this.ageLower != null) {
+            builder.setAgeLower(this.ageLower);
+        }
+        if (this.ageUpper != null) {
+            builder.setAgeUpper(this.ageUpper);
+        }
+        if (this.mostRecentApprovalDate != null) {
+            Date date = parseDateString(this.mostRecentApprovalDate);
+            builder.setMostRecentApprovalDate(date);
+        }
+        if (this.installId != null) {
+            builder.setInstallId(this.installId);
+        }
+
+        return builder.build();
+    }
+
+    @NonNull
+    private static UserStatus getUserStatusFromCall(@NonNull PluginCall call) throws Exception {
+        String userStatusString = call.getString("userStatus");
+        if (userStatusString == null) {
+            throw new Exception(CustomExceptions.USER_STATUS_MISSING.getMessage());
+        }
+        try {
+            return UserStatus.valueOf(userStatusString);
+        } catch (IllegalArgumentException exception) {
+            throw new Exception("Invalid userStatus: " + userStatusString);
+        }
+    }
+
+    @NonNull
+    private Integer mapUserStatusToVerificationStatus(@NonNull UserStatus userStatus) {
+        switch (userStatus) {
+            case VERIFIED:
+                return AgeSignalsVerificationStatus.VERIFIED;
+            case SUPERVISED:
+                return AgeSignalsVerificationStatus.SUPERVISED;
+            case SUPERVISED_APPROVAL_PENDING:
+                return AgeSignalsVerificationStatus.SUPERVISED_APPROVAL_PENDING;
+            case SUPERVISED_APPROVAL_DENIED:
+                return AgeSignalsVerificationStatus.SUPERVISED_APPROVAL_DENIED;
+            case UNKNOWN:
+                return AgeSignalsVerificationStatus.UNKNOWN;
+            default:
+                return AgeSignalsVerificationStatus.UNKNOWN;
+        }
+    }
+
+    @NonNull
+    private Date parseDateString(@NonNull String dateString) throws Exception {
+        try {
+            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd", Locale.US);
+            Date date = format.parse(dateString);
+            if (date == null) {
+                throw new Exception("Failed to parse date: " + dateString);
+            }
+            return date;
+        } catch (Exception exception) {
+            throw new Exception("Invalid date format. Expected yyyy-MM-dd, got: " + dateString);
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/agesignals/classes/options/SetUseFakeManagerOptions.java

@@ -0,0 +1,16 @@
+package io.capawesome.capacitorjs.plugins.agesignals.classes.options;
+
+import com.getcapacitor.PluginCall;
+
+public class SetUseFakeManagerOptions {
+
+    private final boolean useFake;
+
+    public SetUseFakeManagerOptions(PluginCall call) {
+        this.useFake = call.getBoolean("useFake", false);
+    }
+
+    public boolean getUseFake() {
+        return useFake;
+    }
+}