fidel-react-native 1.6.3 → 2.0.0

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

@@ -0,0 +1,35 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.Nullable;
+
+import com.fidelapi.entities.CardVerificationConfiguration;
+import com.fidelreactlibrary.adapters.abstraction.VerificationConfigurationAdapter;
+import com.facebook.react.bridge.ReadableMap;
+
+public class FidelVerificationConfigurationAdapter implements VerificationConfigurationAdapter {
+
+    @Override
+    public CardVerificationConfiguration adapt(ReadableMap data) {
+        String id = "";
+        String consentId = "";
+        String last4Digits = null;
+        if (data != null) {
+            id = getStringParam(data, CardVerificationConfigurationProperties.ID, "");
+            consentId = getStringParam(data, CardVerificationConfigurationProperties.CONSENT_ID, "");
+            last4Digits = getStringParam(data, CardVerificationConfigurationProperties.LAST_4_DIGITS, null);
+        }
+        return new CardVerificationConfiguration(id, consentId, last4Digits);
+    }
+
+    private static String getStringParam(ReadableMap data, CardVerificationConfigurationProperties key,
+            @Nullable String defaultValue) {
+        String value = defaultValue;
+        if (data.hasKey(key.jsName())) {
+            value = data.getString(key.jsName());
+            if (value == null) {
+                value = defaultValue;
+            }
+        }
+        return value;
+    }
+}

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

@@ -27,7 +27,7 @@ import java.io.IOException;
 public final class ImageFromReadableMapAdapter implements DataProcessor<ReadableMap> {
 
     public DataOutput<Bitmap> bitmapOutput;
-    private Context context;
+    private final Context context;
 
     public ImageFromReadableMapAdapter(Context context) {
         this.context = context;
@@ -35,6 +35,10 @@ public final class ImageFromReadableMapAdapter implements DataProcessor<Readable
 
     @Override
     public void process(ReadableMap data) {
+        if (data == null || !data.hasKey("uri")) {
+            bitmapOutput.output(null);
+            return;
+        }
         String imageURIString = data.getString("uri");
         Uri imageURI = Uri.parse(imageURIString);
         if (imageURI.getScheme() != null && (imageURI.getScheme().equals("http") ||

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

@@ -0,0 +1,288 @@
+package com.fidelreactlibrary.adapters;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.CardScheme;
+import com.fidelapi.entities.Country;
+import com.fidelapi.entities.EnrollmentErrorType;
+import com.fidelapi.entities.FidelErrorType;
+import com.fidelapi.entities.VerificationErrorType;
+import com.fidelreactlibrary.adapters.abstraction.CardSchemesAdapter;
+import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
+import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
+import com.fidelreactlibrary.adapters.abstraction.DataAdapter;
+import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public final class ResultsAdapter implements DataAdapter<Object, WritableMap>, ConstantsProvider {
+
+    private final ObjectFactory<WritableMap> writableMapFactory;
+    private final CountryAdapter countryAdapter;
+    private final CardSchemesAdapter cardSchemesAdapter;
+
+    public ResultsAdapter(ObjectFactory<WritableMap> writableMapFactory,
+                          CountryAdapter countryAdapter,
+                          CardSchemesAdapter cardSchemesAdapter) {
+        this.writableMapFactory = writableMapFactory;
+        this.countryAdapter = countryAdapter;
+        this.cardSchemesAdapter = cardSchemesAdapter;
+    }
+
+    @Override
+    public WritableMap getAdaptedObjectFor(Object data) {
+        if (data == null) {
+            return null;
+        }
+        WritableMap map = writableMapFactory.create();
+        for (Field field: data.getClass().getDeclaredFields()) {
+            if (field.getType() == String.class) {
+                String fieldValue = null;
+                try {
+                    fieldValue = (String)field.get(data);
+                } catch (Throwable e) {
+                    String getterMethodName = String.format("get%s", field.getName());
+                    for (Method method: data.getClass().getDeclaredMethods()) {
+                        if (method.getName().toLowerCase().equals(getterMethodName) && method.getReturnType() == String.class) {
+                            try {
+                                fieldValue = (String)method.invoke(data);
+                            } catch (Throwable ignored) {}
+                            break;
+                        }
+                    }
+                }
+                if (fieldValue != null) {
+                    map.putString(field.getName(), fieldValue);
+                } else {
+                    map.putNull(field.getName());
+                }
+            } else if (field.getType() == boolean.class || field.getType() == Boolean.class) {
+                try {
+                    map.putBoolean(field.getName(), field.getBoolean(data));
+                } catch (Throwable e) {
+                    map.putBoolean(field.getName(), false);
+                }
+            } else if (field.getType() == int.class) {
+                try {
+                    map.putInt(field.getName(), field.getInt(data));
+                } catch (Throwable e) {
+                    map.putInt(field.getName(), -1);
+                }
+            } else if (field.getType() == long.class) {
+                try {
+                    map.putDouble(field.getName(), field.getLong(data));
+                } catch (Throwable e) {
+                    map.putDouble(field.getName(), (long)-1);
+                }
+            } else if (field.getType() == JSONObject.class) {
+                try {
+                    JSONObject jsonObject = (JSONObject)field.get(data);
+                    WritableMap mapToPut = this.getMapFor(jsonObject);
+                    map.putMap(field.getName(), mapToPut);
+                } catch (Throwable e) {
+                    map.putNull(field.getName());
+                }
+            } else if (field.getType() == Country.class) {
+                try {
+                    String countryValue = countryAdapter.jsCountryValue((Country)field.get(data));
+                    map.putString(field.getName(), countryValue);
+                } catch (Throwable e) {
+                    map.putNull(field.getName());
+                }
+            } else if (field.getType() == CardScheme.class) {
+                try {
+                    String cardSchemeValue = cardSchemesAdapter.jsValue((CardScheme)field.get(data));
+                    map.putString(field.getName(), cardSchemeValue);
+                } catch (Throwable e) {
+                    map.putNull(field.getName());
+                }
+            } else if (field.getType() == FidelErrorType.class) {
+                try {
+                    FidelErrorType errorType = (FidelErrorType) field.get(data);
+                    String jsErrorType = getJSErrorType(errorType);
+                    map.putString(field.getName(), jsErrorType);
+                    String jsErrorSubtype = getJSErrorSubtype(errorType);
+                    if (jsErrorSubtype != null) {
+                        map.putString("subtype", jsErrorSubtype);
+                    }
+                } catch (Throwable e) {
+                    map.putString(field.getName(), "unknown");
+                }
+            }
+        }
+        return map;
+    }
+
+    @NonNull
+    private String getJSErrorType(FidelErrorType errorType) {
+        if (errorType == FidelErrorType.UserCanceled.INSTANCE) {
+            return "userCanceled";
+        } else if (errorType == FidelErrorType.DeviceNotSecure.INSTANCE) {
+            return "deviceNotSecure";
+        } else if (errorType == FidelErrorType.SdkConfigurationError.INSTANCE) {
+            return "sdkConfigurationError";
+        } else if (errorType instanceof FidelErrorType.EnrollmentError) {
+            return "enrollmentError";
+        } else if (errorType instanceof FidelErrorType.VerificationError) {
+            return "verificationError";
+        }
+        return "unknown";
+    }
+
+    @Nullable
+    private String getJSErrorSubtype(FidelErrorType errorType) {
+        if (errorType instanceof FidelErrorType.EnrollmentError) {
+            FidelErrorType.EnrollmentError enrollmentError = (FidelErrorType.EnrollmentError)errorType;
+            return enrollmentErrorTypeJSValue(enrollmentError.type);
+        } else if (errorType instanceof FidelErrorType.VerificationError) {
+            FidelErrorType.VerificationError verificationError = (FidelErrorType.VerificationError)errorType;
+            return verificationErrorTypeJSValue(verificationError.type);
+        }
+        return null;
+    }
+
+    private String enrollmentErrorTypeJSValue(EnrollmentErrorType enrollmentErrorType) {
+        switch (enrollmentErrorType) {
+            case CARD_ALREADY_EXISTS:
+                return "cardAlreadyExists";
+            case INVALID_PROGRAM_ID:
+                return "invalidProgramId";
+            case INVALID_SDK_KEY:
+                return "invalidSdkKey";
+            case INEXISTENT_PROGRAM:
+                return "inexistentProgram";
+            case CARD_CONSENT_ISSUER_PROCESSING_CHARGE_ERROR:
+                return "cardConsentIssuerProcessingChargeError";
+            case CARD_CONSENT_DUPLICATE_TRANSACTION_ERROR:
+                return "cardConsentDuplicateTransactionError";
+            case CARD_CONSENT_INSUFFICIENT_FUNDS_ERROR:
+                return "cardConsentInsufficientFundsError";
+            case CARD_CONSENT_PROCESSING_CHARGE_ERROR:
+                return "cardConsentProcessingChargeError";
+            case CARD_CONSENT_INCORRECT_CARD_DETAILS_ERROR:
+                return "cardConsentIncorrectCardDetailsError";
+            case CARD_CONSENT_CARD_LIMIT_EXCEEDED:
+                return "cardConsentCardLimitExceeded";
+            case CARD_CONSENT_ERROR_GENERIC:
+                return "cardConsentErrorGeneric";
+            case UNAUTHORIZED:
+                return "unauthorized";
+            case UNEXPECTED:
+                return "unexpected";
+        }
+        return "unexpected";
+    }
+
+    private String verificationErrorTypeJSValue(VerificationErrorType enrollmentErrorType) {
+        switch (enrollmentErrorType) {
+            case UNEXPECTED:
+                return "unexpected";
+            case UNAUTHORIZED:
+                return "unauthorized";
+            case INCORRECT_AMOUNT:
+                return "incorrectAmount";
+            case MAXIMUM_ATTEMPTS_REACHED:
+                return "maximumAttemptsReached";
+            case CARD_ALREADY_VERIFIED:
+                return "cardAlreadyVerified";
+            case CARD_NOT_FOUND:
+                return "cardNotFound";
+            case VERIFICATION_NOT_FOUND:
+                return "verificationNotFound";
+            case GENERIC_ERROR:
+                return "genericError";
+        }
+        return "unexpected";
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        Map<String, Object> errorConstants = new HashMap<>();
+        Map<String, String> errorTypeConstants = new HashMap<>();
+        putErrorTypeConstant(errorTypeConstants, FidelErrorType.UserCanceled.INSTANCE);
+        putErrorTypeConstant(errorTypeConstants, FidelErrorType.DeviceNotSecure.INSTANCE);
+        putErrorTypeConstant(errorTypeConstants, FidelErrorType.SdkConfigurationError.INSTANCE);
+        putErrorTypeConstant(errorTypeConstants, new FidelErrorType.EnrollmentError(EnrollmentErrorType.CARD_ALREADY_EXISTS));
+        putErrorTypeConstant(errorTypeConstants, new FidelErrorType.VerificationError(VerificationErrorType.CARD_ALREADY_VERIFIED));
+        errorConstants.put("ErrorType", errorTypeConstants);
+
+        Map<String, String> enrollmentErrorTypeConstants = new HashMap<>();
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_ALREADY_EXISTS);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.INEXISTENT_PROGRAM);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.INVALID_PROGRAM_ID);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.INVALID_SDK_KEY);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_ISSUER_PROCESSING_CHARGE_ERROR);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_DUPLICATE_TRANSACTION_ERROR);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_INSUFFICIENT_FUNDS_ERROR);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_PROCESSING_CHARGE_ERROR);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_INCORRECT_CARD_DETAILS_ERROR);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_CARD_LIMIT_EXCEEDED);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.CARD_CONSENT_ERROR_GENERIC);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.UNAUTHORIZED);
+        putEnrollmentErrorTypeConstant(enrollmentErrorTypeConstants, EnrollmentErrorType.UNEXPECTED);
+        errorConstants.put("EnrollmentErrorType", enrollmentErrorTypeConstants);
+
+        Map<String, String> verificationErrorTypeConstants = new HashMap<>();
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.GENERIC_ERROR);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.UNEXPECTED);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.CARD_ALREADY_VERIFIED);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.VERIFICATION_NOT_FOUND);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.MAXIMUM_ATTEMPTS_REACHED);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.INCORRECT_AMOUNT);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.UNAUTHORIZED);
+        putVerificationErrorTypeConstant(verificationErrorTypeConstants, VerificationErrorType.CARD_NOT_FOUND);
+        errorConstants.put("VerificationErrorType", verificationErrorTypeConstants);
+        return errorConstants;
+    }
+
+    private void putErrorTypeConstant(Map<String, String> map, FidelErrorType errorType) {
+        String errorTypeJSValue = getJSErrorType(errorType);
+        map.put(errorTypeJSValue, errorTypeJSValue);
+    }
+
+    private void putEnrollmentErrorTypeConstant(Map<String, String> map, EnrollmentErrorType errorType) {
+        String errorTypeJSValue = enrollmentErrorTypeJSValue(errorType);
+        map.put(errorTypeJSValue, errorTypeJSValue);
+    }
+
+    private void putVerificationErrorTypeConstant(Map<String, String> map, VerificationErrorType errorType) {
+        String errorTypeJSValue = verificationErrorTypeJSValue(errorType);
+        map.put(errorTypeJSValue, errorTypeJSValue);
+    }
+
+    private WritableMap getMapFor(JSONObject json) {
+        Iterator<String> jsonKeyIterator = json.keys();
+        WritableMap map = writableMapFactory.create();
+        while (jsonKeyIterator.hasNext()) {
+            String key = jsonKeyIterator.next();
+            try {
+                Object value = json.get(key);
+                Class<?> valueClass = value.getClass();
+                if (valueClass == String.class) {
+                    map.putString(key, (String)value);
+                } else if (valueClass == Boolean.class) {
+                    map.putBoolean(key, (boolean)value);
+                } else if (valueClass == Integer.class) {
+                    map.putInt(key, (int)value);
+                } else if (valueClass == JSONObject.class) {
+                    WritableMap mapToPut = this.getMapFor((JSONObject)value);
+                    map.putMap(key, mapToPut);
+                }
+            }
+            catch (JSONException e) {
+                e.printStackTrace();
+            }
+        }
+        return map;
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/CardSchemesAdapter.java

@@ -1,10 +1,14 @@
 package com.fidelreactlibrary.adapters.abstraction;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
+import com.fidelapi.entities.CardScheme;
 
 import java.util.Set;
 
 public interface CardSchemesAdapter extends ConstantsProvider {
-    Set<Fidel.CardScheme> cardSchemesWithReadableArray(ReadableArray cardSchemes);
+    @NonNull Set<CardScheme> cardSchemesWithReadableArray(@Nullable ReadableArray cardSchemes);
+    @NonNull String jsValue(@NonNull CardScheme cardScheme);
 }

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/CardVerificationChoiceAdapter.java

@@ -0,0 +1,11 @@
+package com.fidelreactlibrary.adapters.abstraction;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.fidelapi.entities.CardVerificationChoice;
+
+public interface CardVerificationChoiceAdapter {
+
+    ReadableMap adapt(@NonNull CardVerificationChoice cardVerificationChoice);
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/CountryAdapter.java

@@ -1,9 +1,20 @@
 package com.fidelreactlibrary.adapters.abstraction;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
+import com.fidelapi.entities.Country;
+
+import java.util.Set;
 
 public interface CountryAdapter extends ConstantsProvider {
-    Fidel.Country countryWithInteger(int integer);
-    Fidel.Country[] parseAllowedCountries(ReadableArray inputArray);
+    @NonNull
+    Set<Country> parseAllowedCountries(@Nullable ReadableArray inputArray);
+
+    @Nullable
+    Country countryWithJSValue(String jsValue);
+
+    @NonNull
+    String jsCountryValue(@NonNull Country country);
 }

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/DataAdapter.java

@@ -0,0 +1,5 @@
+package com.fidelreactlibrary.adapters.abstraction;
+
+public interface DataAdapter<DataType, AdaptedDataType> {
+    AdaptedDataType getAdaptedObjectFor(DataType data);
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/ProgramTypeAdapter.java

@@ -0,0 +1,11 @@
+package com.fidelreactlibrary.adapters.abstraction;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.fidelapi.entities.ProgramType;
+
+public interface ProgramTypeAdapter extends ConstantsProvider {
+    @NonNull
+    ProgramType parseProgramType(@Nullable String programType);
+}

package/android/src/main/java/com/fidelreactlibrary/adapters/abstraction/VerificationConfigurationAdapter.java

@@ -0,0 +1,9 @@
+package com.fidelreactlibrary.adapters.abstraction;
+
+import com.fidelapi.entities.CardVerificationConfiguration;
+import com.facebook.react.bridge.ReadableMap;
+
+public interface VerificationConfigurationAdapter {
+
+    CardVerificationConfiguration adapt(ReadableMap data);
+}

package/android/src/main/java/com/fidelreactlibrary/events/BridgeLibraryEvent.java

@@ -0,0 +1,17 @@
+package com.fidelreactlibrary.events;
+
+public enum BridgeLibraryEvent {
+    RESULT_AVAILABLE("ResultAvailable"),
+    CARD_VERIFICATION_STARTED("CardVerificationStarted"),
+    CARD_VERIFICATION_CHOICE("CardVerificationChoiceSelected");
+
+    private final String eventName;
+
+    BridgeLibraryEvent(String eventName) {
+        this.eventName = eventName;
+    }
+
+    public String getEventName() {
+        return this.eventName;
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/events/BridgeLibraryEventEmitter.java

@@ -0,0 +1,24 @@
+package com.fidelreactlibrary.events;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
+import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+
+public final class BridgeLibraryEventEmitter implements DataProcessor<ReadableMap> {
+
+    private final ReactApplicationContext reactContext;
+    private final BridgeLibraryEvent eventToEmit;
+
+    public BridgeLibraryEventEmitter(ReactApplicationContext reactContext, BridgeLibraryEvent eventToEmit) {
+        this.reactContext = reactContext;
+        this.eventToEmit = eventToEmit;
+    }
+
+    @Override
+    public void process(ReadableMap data) {
+        reactContext
+                .getJSModule(RCTDeviceEventEmitter.class)
+                .emit(eventToEmit.getEventName(), data);
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/events/CardVerificationChoiceObserver.java

@@ -0,0 +1,29 @@
+package com.fidelreactlibrary.events;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.CardVerificationChoice;
+import com.fidelapi.entities.abstraction.OnCardVerificationChoiceSelectedObserver;
+import com.fidelapi.utils.FidelExperimental;
+import com.fidelreactlibrary.adapters.abstraction.CardVerificationChoiceAdapter;
+import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
+
+@FidelExperimental
+public class CardVerificationChoiceObserver implements OnCardVerificationChoiceSelectedObserver {
+    private final DataProcessor<ReadableMap> adaptedVerificationChoiceDetailsProcessor;
+    private final CardVerificationChoiceAdapter cardVerificationChoiceAdapter;
+
+    public CardVerificationChoiceObserver(DataProcessor<ReadableMap> adaptedVerificationChoiceDetailsProcessor,
+                                          CardVerificationChoiceAdapter cardVerificationChoiceAdapter) {
+        this.adaptedVerificationChoiceDetailsProcessor = adaptedVerificationChoiceDetailsProcessor;
+        this.cardVerificationChoiceAdapter = cardVerificationChoiceAdapter;
+    }
+
+    @Override
+    public void onCardVerificationChoiceSelected(@NonNull CardVerificationChoice cardVerificationChoice) {
+        adaptedVerificationChoiceDetailsProcessor.process(cardVerificationChoiceAdapter.adapt(cardVerificationChoice));
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/events/CardVerificationStartedObserver.java

@@ -0,0 +1,31 @@
+package com.fidelreactlibrary.events;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.ConsentDetails;
+import com.fidelapi.entities.abstraction.OnCardVerificationStartedObserver;
+import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
+
+public class CardVerificationStartedObserver implements OnCardVerificationStartedObserver {
+
+    private final DataProcessor<ReadableMap> adaptedConsentDetailsProcessor;
+    private final ObjectFactory<WritableMap> writableMapFactory;
+
+    public CardVerificationStartedObserver(DataProcessor<ReadableMap> adaptedConsentDetailsProcessor,
+                                           ObjectFactory<WritableMap> writableMapFactory) {
+        this.adaptedConsentDetailsProcessor = adaptedConsentDetailsProcessor;
+        this.writableMapFactory = writableMapFactory;
+    }
+
+    @Override
+    public void onCardVerificationStarted(@NonNull ConsentDetails consentDetails) {
+        WritableMap map = writableMapFactory.create();
+        map.putString("cardId", consentDetails.getCardId());
+        map.putString("consentId", consentDetails.getConsentId());
+        map.putString("programId", consentDetails.getProgramId());
+        adaptedConsentDetailsProcessor.process(map);
+    }
+}

package/android/src/main/java/com/fidelreactlibrary/events/ResultsObserver.java

@@ -0,0 +1,72 @@
+package com.fidelreactlibrary.events;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.EnrollmentResult;
+import com.fidelapi.entities.FidelError;
+import com.fidelapi.entities.FidelResult;
+import com.fidelapi.entities.VerificationResult;
+import com.fidelapi.entities.abstraction.OnResultObserver;
+import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
+import com.fidelreactlibrary.adapters.abstraction.DataAdapter;
+import com.fidelreactlibrary.adapters.abstraction.DataProcessor;
+import com.fidelreactlibrary.adapters.abstraction.ObjectFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class ResultsObserver implements OnResultObserver, ConstantsProvider {
+
+    private final DataAdapter<Object, WritableMap> resultAdapter;
+    private final DataProcessor<ReadableMap> resultHandler;
+    private final ObjectFactory<WritableMap> writableMapFactory;
+
+    private final String ENROLLMENT_RESULT_TYPE = "EnrollmentResult";
+    private final String ERROR_RESULT_TYPE = "Error";
+    private final String VERIFICATION_RESULT_TYPE = "VerificationResult";
+
+    public ResultsObserver(DataAdapter<Object, WritableMap> resultAdapter,
+                           DataProcessor<ReadableMap> resultHandler,
+                           ObjectFactory<WritableMap> writableMapFactory) {
+        this.resultAdapter = resultAdapter;
+        this.resultHandler = resultHandler;
+        this.writableMapFactory = writableMapFactory;
+    }
+
+    @Override
+    public void onResultAvailable(FidelResult fidelResult) {
+        WritableMap resultMap = writableMapFactory.create();
+        String RESULT_TYPE_KEY = "type";
+        if (fidelResult instanceof FidelResult.Enrollment) {
+            EnrollmentResult enrollmentResult = ((FidelResult.Enrollment) fidelResult).getEnrollmentResult();
+            WritableMap adaptedObject = resultAdapter.getAdaptedObjectFor(enrollmentResult);
+            resultMap.putString(RESULT_TYPE_KEY, ENROLLMENT_RESULT_TYPE);
+            resultMap.putMap("enrollmentResult", adaptedObject);
+        } else if (fidelResult instanceof FidelResult.Verification) {
+            VerificationResult verificationResult = ((FidelResult.Verification) fidelResult).getVerificationResult();
+            WritableMap adaptedObject = resultAdapter.getAdaptedObjectFor(verificationResult);
+            resultMap.putString(RESULT_TYPE_KEY, VERIFICATION_RESULT_TYPE);
+            resultMap.putMap("verificationResult", adaptedObject);
+        } else {
+            resultMap.putString(RESULT_TYPE_KEY, ERROR_RESULT_TYPE);
+            FidelError error = ((FidelResult.Error) fidelResult).getError();
+            WritableMap adaptedError = resultAdapter.getAdaptedObjectFor(error);
+            resultMap.putMap("error", adaptedError);
+        }
+        resultHandler.process(resultMap);
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        final Map<String, String> resultTypesMap = new HashMap<>();
+        resultTypesMap.put(ENROLLMENT_RESULT_TYPE, ENROLLMENT_RESULT_TYPE);
+        resultTypesMap.put(ERROR_RESULT_TYPE, ERROR_RESULT_TYPE);
+        resultTypesMap.put(VERIFICATION_RESULT_TYPE, VERIFICATION_RESULT_TYPE);
+        constants.put("ResultType", resultTypesMap);
+        return constants;
+    }
+}