fidel-react-native 1.6.4 → 2.1.0

package/android/src/main/java/com/fidelreactlibrary/FidelPackage.java

@@ -1,74 +1,89 @@
 
 package com.fidelreactlibrary;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.OptIn;
+
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.uimanager.ViewManager;
-import com.facebook.react.bridge.JavaScriptModule;
+import com.fidelapi.utils.FidelExperimental;
 import com.fidelreactlibrary.adapters.FidelCardSchemesAdapter;
-import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
+import com.fidelreactlibrary.adapters.FidelCardVerificationChoiceAdapter;
 import com.fidelreactlibrary.adapters.FidelCountryAdapter;
-import com.fidelreactlibrary.adapters.FidelOptionsAdapter;
+import com.fidelreactlibrary.adapters.FidelProgramTypeAdapter;
 import com.fidelreactlibrary.adapters.FidelSetupAdapter;
+import com.fidelreactlibrary.adapters.FidelVerificationConfigurationAdapter;
 import com.fidelreactlibrary.adapters.ImageFromReadableMapAdapter;
-import com.fidelreactlibrary.adapters.WritableMapDataConverter;
+import com.fidelreactlibrary.adapters.ResultsAdapter;
+import com.fidelreactlibrary.adapters.abstraction.CardSchemesAdapter;
 import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
-import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
-import com.fidelreactlibrary.events.CallbackActivityEventListener;
-import com.fidelreactlibrary.events.ErrorEventEmitter;
+import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
+import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+import com.fidelreactlibrary.events.BridgeLibraryEvent;
+import com.fidelreactlibrary.events.CardVerificationChoiceObserver;
+import com.fidelreactlibrary.events.CardVerificationStartedObserver;
+import com.fidelreactlibrary.events.ResultsObserver;
+import com.fidelreactlibrary.events.BridgeLibraryEventEmitter;
 
+@OptIn(markerClass = FidelExperimental.class)
 public class FidelPackage implements ReactPackage {
+
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-        ImageFromReadableMapAdapter imageAdapter =
-                new ImageFromReadableMapAdapter(reactContext);
-        CountryAdapter countryAdapter =
-                new FidelCountryAdapter();
-        FidelSetupAdapter setupAdapter =
-                new FidelSetupAdapter();
-        FidelCardSchemesAdapter cardSchemesAdapter =
-                new FidelCardSchemesAdapter();
-        FidelOptionsAdapter optionsAdapter =
-                new FidelOptionsAdapter(imageAdapter, countryAdapter, cardSchemesAdapter);
-        imageAdapter.bitmapOutput = optionsAdapter;
-        List<ConstantsProvider> constantsProviderList =
-                new ArrayList<>();
-        constantsProviderList.add(optionsAdapter);
-        WritableMapDataConverter linkResultConverter =
-                new WritableMapDataConverter(new ObjectFactory<WritableMap>() {
-                    @Override
-                    public WritableMap create() {
-                        return new WritableNativeMap();
-                    }
-                });
-        ErrorEventEmitter errorEventEmitter =
-                new ErrorEventEmitter(reactContext);
-        CallbackActivityEventListener activityEventListener =
-                new CallbackActivityEventListener(linkResultConverter, errorEventEmitter);
-        reactContext.addActivityEventListener(activityEventListener);
-      return Arrays.<NativeModule>asList(
-              new FidelModule(reactContext,
-                      setupAdapter,
-                      optionsAdapter,
-                      constantsProviderList,
-                      activityEventListener));
-    }
+    public @NonNull List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        ImageFromReadableMapAdapter imageAdapter = new ImageFromReadableMapAdapter(reactContext);
+        CountryAdapter countryAdapter = new FidelCountryAdapter();
+        CardSchemesAdapter cardSchemeAdapter = new FidelCardSchemesAdapter();
+        FidelSetupAdapter setupAdapter = new FidelSetupAdapter(
+                imageAdapter,
+                countryAdapter,
+                cardSchemeAdapter,
+                new FidelProgramTypeAdapter());
+        imageAdapter.bitmapOutput = setupAdapter;
+
+        List<ConstantsProvider> constantsProviderList = new ArrayList<>();
+
+        ResultsAdapter resultsAdapter = new ResultsAdapter(WritableNativeMap::new, countryAdapter, cardSchemeAdapter);
+        DataProcessor<ReadableMap> resultHandler = new BridgeLibraryEventEmitter(reactContext,
+                BridgeLibraryEvent.RESULT_AVAILABLE);
+        ResultsObserver resultsObserver = new ResultsObserver(resultsAdapter, resultHandler, WritableNativeMap::new);
+
+        DataProcessor<ReadableMap> cardVerificationStartedHandler = new BridgeLibraryEventEmitter(reactContext,
+                BridgeLibraryEvent.CARD_VERIFICATION_STARTED);
+        DataProcessor<ReadableMap> cardVerificationChoiceHandler = new BridgeLibraryEventEmitter(reactContext,
+                BridgeLibraryEvent.CARD_VERIFICATION_CHOICE);
+        CardVerificationStartedObserver cardVerificationStartedObserver = new CardVerificationStartedObserver(
+                cardVerificationStartedHandler, WritableNativeMap::new);
+        FidelCardVerificationChoiceAdapter cardVerificationChoiceAdapter = new FidelCardVerificationChoiceAdapter(WritableNativeMap::new);
+        CardVerificationChoiceObserver cardVerificationChoiceObserver = new CardVerificationChoiceObserver(
+                cardVerificationChoiceHandler, cardVerificationChoiceAdapter);
+
+        constantsProviderList.add(setupAdapter);
+        constantsProviderList.add(resultsAdapter);
+        constantsProviderList.add(resultsObserver);
+        constantsProviderList.add(cardVerificationChoiceAdapter);
 
-    // Deprecated from RN 0.47
-    public List<Class<? extends JavaScriptModule>> createJSModules() {
-      return Collections.emptyList();
+        FidelModule fidelModule = new FidelModule(
+                reactContext,
+                setupAdapter,
+                resultsObserver,
+                cardVerificationStartedObserver,
+                cardVerificationChoiceObserver,
+                constantsProviderList,
+                new FidelVerificationConfigurationAdapter());
+        return Collections.singletonList(fidelModule);
     }
 
+    @NonNull
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-      return Collections.emptyList();
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
     }
-}
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/CardVerificationConfigurationProperties.java

@@ -0,0 +1,22 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.NonNull;
+
+public enum CardVerificationConfigurationProperties {
+    ID("id"),
+    CONSENT_ID("consentId"),
+    LAST_4_DIGITS("last4Digits");
+
+    private final @NonNull String jsName;
+
+    /**
+     * @param jsName The name of the key that will be available in JavaScript
+     */
+    CardVerificationConfigurationProperties(final @NonNull String jsName) {
+        this.jsName = jsName;
+    }
+
+    public String jsName() {
+        return jsName;
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelCardSchemesAdapter.java

@@ -1,12 +1,15 @@
 package com.fidelreactlibrary.adapters;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
+import com.facebook.react.bridge.ReadableType;
+import com.fidelapi.entities.CardScheme;
 import com.fidelreactlibrary.adapters.abstraction.CardSchemesAdapter;
 
-import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
@@ -23,41 +26,55 @@ public final class FidelCardSchemesAdapter implements CardSchemesAdapter {
     @Override
     public @Nonnull Map<String, Object> getConstants() {
         final Map<String, Object> constants = new HashMap<>();
-        Map<String, Object> cardSchemesConstants = new HashMap<>();
-        for (Fidel.CardScheme cardScheme : Fidel.CardScheme.values()) {
-            String cardSchemeKey = null;
-            switch (cardScheme) {
-                case VISA: cardSchemeKey = VISA_CARD_SCHEME_VALUE; break;
-                case MASTERCARD: cardSchemeKey = MASTERCARD_SCHEME_VALUE; break;
-                case AMERICAN_EXPRESS: cardSchemeKey = AMERICAN_EXPRESS_CARD_SCHEME_VALUE; break;
-            }
-            cardSchemesConstants.put(cardSchemeKey, cardScheme.ordinal());
+        Map<String, String> cardSchemesConstants = new HashMap<>();
+        for (CardScheme cardScheme : CardScheme.values()) {
+            String cardSchemeKey = jsValue(cardScheme);
+            cardSchemesConstants.put(cardSchemeKey, cardSchemeKey);
         }
         constants.put(EXPORTED_CARD_SCHEME_KEY, cardSchemesConstants);
         return constants;
     }
 
+    @NonNull
     @Override
-    public Set<Fidel.CardScheme> cardSchemesWithReadableArray(ReadableArray arrayToAdapt) {
+    public String jsValue(@NonNull CardScheme cardScheme) {
+        switch (cardScheme) {
+            case VISA:
+                return VISA_CARD_SCHEME_VALUE;
+            case MASTERCARD:
+                return MASTERCARD_SCHEME_VALUE;
+            case AMERICAN_EXPRESS:
+                return AMERICAN_EXPRESS_CARD_SCHEME_VALUE;
+        }
+        return "notFound";
+    }
+
+    @Nullable
+    private CardScheme cardSchemeWithJsValue(String jsValue) {
+        switch (jsValue) {
+            case VISA_CARD_SCHEME_VALUE:
+                return CardScheme.VISA;
+            case MASTERCARD_SCHEME_VALUE:
+                return CardScheme.MASTERCARD;
+            case AMERICAN_EXPRESS_CARD_SCHEME_VALUE:
+                return CardScheme.AMERICAN_EXPRESS;
+        }
+        return null;
+    }
+
+    @Override
+    public @NonNull Set<CardScheme> cardSchemesWithReadableArray(@Nullable ReadableArray arrayToAdapt) {
+        Set<CardScheme> cardSchemeSet = EnumSet.noneOf(CardScheme.class);
         if (arrayToAdapt == null) {
-            return null;
+            return cardSchemeSet;
         }
-        ArrayList<Integer> integerArrayToAdapt = new ArrayList<>();
-        ArrayList<Object> arrayToAdaptObjects = arrayToAdapt.toArrayList();
-        for (Object objectToAdapt: arrayToAdaptObjects) {
-            if (objectToAdapt.getClass() == Integer.class) {
-                integerArrayToAdapt.add((Integer)objectToAdapt);
+        for (int i = 0; i < arrayToAdapt.size(); i++) {
+            if (arrayToAdapt.getType(i) != ReadableType.String) {
+                continue;
             }
-            else if (objectToAdapt.getClass() == Double.class) {
-                Double doubleObjectToAdapt = (Double)objectToAdapt;
-                integerArrayToAdapt.add(doubleObjectToAdapt.intValue());
-            }
-        }
-        Set<Integer> receivedObjectsSet = new HashSet<>(integerArrayToAdapt);
-        Set<Fidel.CardScheme> cardSchemeSet = new HashSet<>();
-        for (Fidel.CardScheme scheme : Fidel.CardScheme.values()) {
-            if (receivedObjectsSet.contains(scheme.ordinal())) {
-                cardSchemeSet.add(scheme);
+            CardScheme cardScheme = cardSchemeWithJsValue(arrayToAdapt.getString(i));
+            if (cardScheme != null) {
+                cardSchemeSet.add(cardScheme);
             }
         }
         return cardSchemeSet;

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelCardVerificationChoiceAdapter.java

@@ -0,0 +1,57 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.OptIn;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.CardVerificationChoice;
+import com.fidelapi.utils.FidelExperimental;
+import com.fidelreactlibrary.adapters.abstraction.CardVerificationChoiceAdapter;
+import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
+import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@OptIn(markerClass = FidelExperimental.class)
+public class FidelCardVerificationChoiceAdapter implements CardVerificationChoiceAdapter, ConstantsProvider {
+    protected static final String CARD_VERIFICATION_ON_THE_SPOT = "onTheSpot";
+    protected static final String CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY = "delegatedToThirdParty";
+    public static final String CARD_VERIFICATION_CHOICE = "CardVerificationChoice";
+    private final ObjectFactory<WritableMap> writableMapFactory;
+
+    public FidelCardVerificationChoiceAdapter(ObjectFactory<WritableMap> writableMapFactory) {
+        this.writableMapFactory = writableMapFactory;
+    }
+
+    @Override
+    public ReadableMap adapt(@NonNull CardVerificationChoice cardVerificationChoice) {
+        WritableMap map = writableMapFactory.create();
+        map.putString(CARD_VERIFICATION_CHOICE, jsValue(cardVerificationChoice));
+        return map;
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        final Map<String, String> verificationChoicesMap = new HashMap<>();
+        for (CardVerificationChoice choice : CardVerificationChoice.values()) {
+            String verificationChoiceKeyAndValue = jsValue(choice);
+            verificationChoicesMap.put(verificationChoiceKeyAndValue, verificationChoiceKeyAndValue);
+        }
+        constants.put(CARD_VERIFICATION_CHOICE, verificationChoicesMap);
+        return constants;
+    }
+
+    private String jsValue(@NonNull CardVerificationChoice cardVerificationChoice) {
+        switch (cardVerificationChoice) {
+            case DELEGATED_TO_THIRD_PARTY:
+                return CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY;
+            case ON_THE_SPOT:
+                return CARD_VERIFICATION_ON_THE_SPOT;
+        }
+        return "notFound";
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelCountryAdapter.java

@@ -1,13 +1,17 @@
 package com.fidelreactlibrary.adapters;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
+import com.facebook.react.bridge.ReadableType;
+import com.fidelapi.entities.Country;
 import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
 
+import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
-
-import javax.annotation.Nonnull;
+import java.util.Set;
 
 public final class FidelCountryAdapter implements CountryAdapter {
 
@@ -20,10 +24,12 @@ public final class FidelCountryAdapter implements CountryAdapter {
     private static final String SWEDEN_COUNTRY_KEY = "sweden";
     private static final String IRELAND_COUNTRY_KEY = "ireland";
     private static final String CANADA_COUNTRY_KEY = "canada";
+    private static final String NORWAY_COUNTRY_KEY = "norway";
 
     private static final String NOT_FOUND_COUNTRY_KEY = "notFound";
 
-    public @Nonnull String keyFor(@Nonnull Fidel.Country country) {
+    @NonNull
+    private String keyFor(@NonNull Country country) {
         switch (country) {
             case UNITED_KINGDOM: return UNITED_KINGDOM_COUNTRY_KEY;
             case UNITED_STATES: return UNITED_STATES_COUNTRY_KEY;
@@ -32,36 +38,58 @@ public final class FidelCountryAdapter implements CountryAdapter {
             case SWEDEN: return SWEDEN_COUNTRY_KEY;
             case IRELAND: return IRELAND_COUNTRY_KEY;
             case CANADA: return CANADA_COUNTRY_KEY;
+            case NORWAY: return NORWAY_COUNTRY_KEY;
         }
         return NOT_FOUND_COUNTRY_KEY;
     }
 
+    public @Nullable Country countryWithJSValue(String jsValue) {
+        switch (jsValue) {
+            case UNITED_KINGDOM_COUNTRY_KEY: return Country.UNITED_KINGDOM;
+            case UNITED_STATES_COUNTRY_KEY: return Country.UNITED_STATES;
+            case UNITED_ARAB_EMIRATES_KEY: return Country.UNITED_ARAB_EMIRATES;
+            case JAPAN_COUNTRY_KEY: return Country.JAPAN;
+            case SWEDEN_COUNTRY_KEY: return Country.SWEDEN;
+            case IRELAND_COUNTRY_KEY: return Country.IRELAND;
+            case CANADA_COUNTRY_KEY: return Country.CANADA;
+            case NORWAY_COUNTRY_KEY: return Country.NORWAY;
+        }
+        return null;
+    }
+
+    @NonNull
     @Override
-    public @Nonnull Map<String, Object> getConstants() {
+    public String jsCountryValue(@NonNull Country country) {
+        return keyFor(country);
+    }
+
+    @Override
+    public @NonNull Map<String, Object> getConstants() {
         final Map<String, Object> constants = new HashMap<>();
-        final Map<String, Integer> countriesMap = new HashMap<>();
-        for (Fidel.Country country :
-                Fidel.Country.values()) {
+        final Map<String, String> countriesMap = new HashMap<>();
+        for (Country country :
+                Country.values()) {
             String countryKey = keyFor(country);
-            countriesMap.put(countryKey, country.ordinal());
+            countriesMap.put(countryKey, countryKey);
         }
         constants.put(EXPORTED_COUNTRY_KEY, countriesMap);
         return constants;
     }
 
     @Override
-    public Fidel.Country countryWithInteger(int integer) {
-        if (integer < Fidel.Country.values().length) {
-            return Fidel.Country.values()[integer];
+    public @NonNull Set<Country> parseAllowedCountries(@Nullable ReadableArray inputArray) {
+        Set<Country> countries = EnumSet.noneOf(Country.class);
+        if (inputArray == null) {
+            return countries;
         }
-        return null;
-    }
-
-    @Override
-    public Fidel.Country[] parseAllowedCountries(ReadableArray inputArray) {
-        Fidel.Country[] countries = new Fidel.Country[inputArray.size()];
         for (int i = 0; i < inputArray.size(); i++) {
-            countries[i] = countryWithInteger(inputArray.getInt(i));
+            if (inputArray.getType(i) != ReadableType.String) {
+                continue;
+            }
+            Country country = countryWithJSValue(inputArray.getString(i));
+            if (country != null) {
+                countries.add(country);
+            }
         }
         return countries;
     }

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelProgramTypeAdapter.java

@@ -0,0 +1,46 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.fidelapi.entities.ProgramType;
+import com.fidelreactlibrary.adapters.abstraction.ProgramTypeAdapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FidelProgramTypeAdapter implements ProgramTypeAdapter {
+
+    public @NonNull String keyFor(@NonNull ProgramType programType) {
+        switch (programType) {
+            case TRANSACTION_SELECT: return "transactionSelect";
+            case TRANSACTION_STREAM: return "transactionStream";
+            default: return "notFound";
+        }
+    }
+
+    @NonNull
+    @Override
+    public ProgramType parseProgramType(@Nullable String programType) {
+        ProgramType programTypeToReturn;
+        try {
+            programTypeToReturn = ProgramType.valueOf(programType);
+        } catch (Exception e) {
+            programTypeToReturn = ProgramType.TRANSACTION_SELECT;
+        }
+        return programTypeToReturn;
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        final Map<String, String> programTypesMap = new HashMap<>();
+        for (ProgramType programType : ProgramType.values()) {
+            String programTypeKey = keyFor(programType);
+            programTypesMap.put(programTypeKey, programType.name());
+        }
+        constants.put("ProgramType", programTypesMap);
+        return constants;
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelSetupAdapter.java

@@ -1,16 +1,118 @@
 package com.fidelreactlibrary.adapters;
 
+import android.graphics.Bitmap;
+
+import androidx.annotation.NonNull;
+
 import com.facebook.react.bridge.ReadableMap;
-import com.fidel.sdk.Fidel;
+import com.fidelapi.Fidel;
+import com.fidelapi.entities.Country;
+import com.fidelreactlibrary.adapters.abstraction.CardSchemesAdapter;
+import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
+import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
+import com.fidelreactlibrary.adapters.abstraction.DataOutput;
 import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+import com.fidelreactlibrary.adapters.abstraction.ProgramTypeAdapter;
+
+import org.json.JSONObject;
+
+import java.util.Map;
 
-public final class FidelSetupAdapter implements DataProcessor<ReadableMap> {
-    public static final String API_KEY = "apiKey";
-    public static final String PROGRAM_ID_KEY = "programId";
+public final class FidelSetupAdapter implements DataProcessor<ReadableMap>, DataOutput<Bitmap>, ConstantsProvider {
+
+    private final DataProcessor<ReadableMap> imageAdapter;
+    private final CountryAdapter countryAdapter;
+    private final CardSchemesAdapter cardSchemesAdapter;
+    private final ProgramTypeAdapter programTypeAdapter;
+
+    public FidelSetupAdapter(DataProcessor<ReadableMap> imageAdapter, CountryAdapter countryAdapter,
+            CardSchemesAdapter cardSchemesAdapter, ProgramTypeAdapter programTypeAdapter) {
+        this.imageAdapter = imageAdapter;
+        this.countryAdapter = countryAdapter;
+        this.cardSchemesAdapter = cardSchemesAdapter;
+        this.programTypeAdapter = programTypeAdapter;
+    }
 
     @Override
     public void process(ReadableMap data) {
-        Fidel.apiKey = data.getString(API_KEY);
-        Fidel.programId = data.getString(PROGRAM_ID_KEY);
+        if (data.hasKey(FidelSetupProperties.SDK_KEY.jsName())) {
+            Fidel.sdkKey = data.getString(FidelSetupProperties.SDK_KEY.jsName());
+        }
+        if (data.hasKey(FidelSetupProperties.PROGRAM_ID.jsName())) {
+            Fidel.programId = data.getString(FidelSetupProperties.PROGRAM_ID.jsName());
+        }
+        if (data.hasKey(FidelSetupProperties.PROGRAM_TYPE.jsName())) {
+            String programTypeValue = data.getString(FidelSetupProperties.PROGRAM_TYPE.jsName());
+            Fidel.programType = programTypeAdapter.parseProgramType(programTypeValue);
+        }
+        ReadableMap optionsMap = data.getMap(FidelSetupProperties.OPTIONS.jsName());
+        if (optionsMap != null) {
+            if (optionsMap.hasKey(FidelSetupProperties.Options.BANNER_IMAGE.jsName())) {
+                imageAdapter.process(optionsMap.getMap(FidelSetupProperties.Options.BANNER_IMAGE.jsName()));
+            }
+            if (optionsMap.hasKey(FidelSetupProperties.Options.ALLOWED_COUNTRIES.jsName())) {
+                Fidel.allowedCountries = countryAdapter
+                        .parseAllowedCountries(optionsMap.getArray(FidelSetupProperties.Options.ALLOWED_COUNTRIES.jsName()));
+            }
+            if (optionsMap.hasKey(FidelSetupProperties.Options.DEFAULT_SELECTED_COUNTRY.jsName())) {
+                Country defaultSelectedCountry = countryAdapter.countryWithJSValue(
+                        optionsMap.getString(FidelSetupProperties.Options.DEFAULT_SELECTED_COUNTRY.jsName()));
+                if (defaultSelectedCountry != null) {
+                    Fidel.defaultSelectedCountry = defaultSelectedCountry;
+                }
+            }
+            if (optionsMap.hasKey(FidelSetupProperties.Options.SUPPORTED_CARD_SCHEMES.jsName())) {
+                Fidel.supportedCardSchemes = cardSchemesAdapter.cardSchemesWithReadableArray(
+                        optionsMap.getArray(FidelSetupProperties.Options.SUPPORTED_CARD_SCHEMES.jsName()));
+            }
+            if (optionsMap.hasKey(FidelSetupProperties.Options.THIRD_PARTY_VERIFICATION_CHOICE.jsName())) {
+                Fidel.thirdPartyVerificationChoice = optionsMap
+                        .getBoolean(FidelSetupProperties.Options.THIRD_PARTY_VERIFICATION_CHOICE.jsName());
+            }
+            if (optionsMap.hasKey(FidelSetupProperties.Options.META_DATA.jsName())) {
+                ReadableMap metaDataMap = optionsMap.getMap(FidelSetupProperties.Options.META_DATA.jsName());
+                if (metaDataMap != null) {
+                    Fidel.metaData = new JSONObject(metaDataMap.toHashMap());
+                } else {
+                    Fidel.metaData = null;
+                }
+            }
+        }
+
+        ReadableMap consentTextMap = data.getMap(FidelSetupProperties.CONSENT_TEXT.jsName());
+        if (consentTextMap != null) {
+            if (consentTextMap.hasKey(FidelSetupProperties.ConsentText.COMPANY_NAME.jsName())) {
+                Fidel.companyName = consentTextMap.getString(FidelSetupProperties.ConsentText.COMPANY_NAME.jsName());
+            }
+            if (consentTextMap.hasKey(FidelSetupProperties.ConsentText.TERMS_AND_CONDITIONS_URL.jsName())) {
+                Fidel.termsAndConditionsUrl = consentTextMap
+                        .getString(FidelSetupProperties.ConsentText.TERMS_AND_CONDITIONS_URL.jsName());
+            }
+            if (consentTextMap.hasKey(FidelSetupProperties.ConsentText.PRIVACY_POLICY_URL.jsName())) {
+                Fidel.privacyPolicyUrl = consentTextMap
+                        .getString(FidelSetupProperties.ConsentText.PRIVACY_POLICY_URL.jsName());
+            }
+            if (consentTextMap.hasKey(FidelSetupProperties.ConsentText.PROGRAM_NAME.jsName())) {
+                Fidel.programName = consentTextMap.getString(FidelSetupProperties.ConsentText.PROGRAM_NAME.jsName());
+            }
+            if (consentTextMap.hasKey(FidelSetupProperties.ConsentText.DELETE_INSTRUCTIONS.jsName())) {
+                Fidel.deleteInstructions = consentTextMap
+                        .getString(FidelSetupProperties.ConsentText.DELETE_INSTRUCTIONS.jsName());
+            }
+        }
+    }
+
+    @Override
+    public void output(Bitmap data) {
+        Fidel.bannerImage = data;
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> constants = countryAdapter.getConstants();
+        constants.putAll(cardSchemesAdapter.getConstants());
+        constants.putAll(programTypeAdapter.getConstants());
+        return constants;
     }
 }

package/android/src/main/java/com/fidelreactlibrary/adapters/FidelSetupProperties.java

@@ -0,0 +1,67 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.NonNull;
+
+public enum FidelSetupProperties {
+    SDK_KEY("sdkKey"),
+    PROGRAM_ID("programId"),
+    PROGRAM_TYPE("programType"),
+    OPTIONS("options"),
+    CONSENT_TEXT("consentText");
+
+    public enum Options {
+        BANNER_IMAGE("bannerImage"),
+        ALLOWED_COUNTRIES("allowedCountries"),
+        DEFAULT_SELECTED_COUNTRY("defaultSelectedCountry"),
+        SUPPORTED_CARD_SCHEMES("supportedCardSchemes"),
+        THIRD_PARTY_VERIFICATION_CHOICE("thirdPartyVerificationChoice"),
+        META_DATA("metaData");
+
+        private final @NonNull String jsName;
+
+        /**
+         * @param jsName The name of the key that will be available in JavaScript
+         */
+        Options(final @NonNull String jsName) {
+            this.jsName = jsName;
+        }
+
+        public String jsName() {
+            return jsName;
+        }
+    }
+
+    public enum ConsentText {
+        COMPANY_NAME("companyName"),
+        TERMS_AND_CONDITIONS_URL("termsAndConditionsUrl"),
+        PRIVACY_POLICY_URL("privacyPolicyUrl"),
+        PROGRAM_NAME("programName"),
+        DELETE_INSTRUCTIONS("deleteInstructions");
+
+        private final @NonNull String jsName;
+
+        /**
+         * @param jsName The name of the key that will be available in JavaScript
+         */
+        ConsentText(final @NonNull String jsName) {
+            this.jsName = jsName;
+        }
+
+        public String jsName() {
+            return jsName;
+        }
+    }
+
+    private final @NonNull String jsName;
+
+    /**
+     * @param jsName The name of the key that will be available in JavaScript
+     */
+    FidelSetupProperties(final @NonNull String jsName) {
+        this.jsName = jsName;
+    }
+
+    public String jsName() {
+        return jsName;
+    }
+}