react-native-payengine 1.0.5 → 2.0.2

package/android/src/main/java/com/reactnativepayengine/GooglePayModule.java

@@ -0,0 +1,196 @@
+package com.reactnativepayengine;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.Promise;
+
+import com.google.android.gms.wallet.PaymentsClient;
+import com.google.android.gms.wallet.WalletConstants;
+import com.google.android.gms.wallet.IsReadyToPayRequest;
+import com.google.android.gms.wallet.AutoResolveHelper;
+import com.google.android.gms.wallet.PaymentData;
+import com.google.android.gms.wallet.PaymentDataRequest;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.reactnativepayengine.util.PaymentsUtil;
+
+import androidx.annotation.NonNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class GooglePayModule extends ReactContextBaseJavaModule {
+
+  private static final String TAG = "ReactNative";
+
+  private static final String ENVIRONMENT_PRODUCTION_KEY = "ENVIRONMENT_PRODUCTION";
+
+  private static final String ENVIRONMENT_TEST_KEY = "ENVIRONMENT_TEST";
+
+  private final ReactApplicationContext reactContext;
+
+  private PaymentsClient mPaymentsClient;
+
+  private Promise requestPaymentPromise = null;
+
+  private static final int LOAD_PAYMENT_DATA_REQUEST_CODE = 991;
+
+  private final ActivityEventListener activityEventListener = new BaseActivityEventListener() {
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+      switch (requestCode) {
+        // value passed in AutoResolveHelper
+        case LOAD_PAYMENT_DATA_REQUEST_CODE:
+          switch (resultCode) {
+            case Activity.RESULT_OK:
+              PaymentData paymentData = PaymentData.getFromIntent(data);
+              handlePaymentSuccess(paymentData);
+              break;
+            case Activity.RESULT_CANCELED:
+              requestPaymentPromise.reject("PAYMENT_RESULT_CANCELED", "Payment has been canceled");
+              break;
+            case AutoResolveHelper.RESULT_ERROR:
+              Status status = AutoResolveHelper.getStatusFromIntent(data);
+              int statusCode = status.getStatusCode();
+              String errorMessage = String.format("loadPaymentData failed. Error code: %d", statusCode);
+              Log.w(TAG, "[GooglePay] " + errorMessage);
+              requestPaymentPromise.reject("PAYMENT_RESULT_ERROR", errorMessage);
+              break;
+            default:
+              // Do nothing.
+          }
+          break;
+      }
+    }
+  };
+
+  public GooglePayModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    reactContext.addActivityEventListener(activityEventListener);
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put(ENVIRONMENT_PRODUCTION_KEY, WalletConstants.ENVIRONMENT_PRODUCTION);
+    constants.put(ENVIRONMENT_TEST_KEY, WalletConstants.ENVIRONMENT_TEST);
+    return constants;
+  }
+
+  @ReactMethod
+  public void setEnvironment(int environment) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      return;
+    }
+    mPaymentsClient = PaymentsUtil.createPaymentsClient(environment, activity);
+  }
+
+  @ReactMethod
+  public void isReadyToPay(ReadableArray allowedCardNetworks, ReadableArray allowedCardAuthMethods, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(TAG, "[GooglePay] activity is null");
+      promise.resolve(false);
+      return;
+    }
+    final JSONObject isReadyToPayJson = PaymentsUtil.getIsReadyToPayRequest(allowedCardNetworks.toArrayList(), allowedCardAuthMethods.toArrayList());
+    if (isReadyToPayJson == null) {
+      Log.w(TAG, "[GooglePay] isReadyToPayJson == null");
+      promise.resolve(false);
+      return;
+    }
+    IsReadyToPayRequest request = IsReadyToPayRequest.fromJson(isReadyToPayJson.toString());
+    if (request == null) {
+      Log.w(TAG, "[GooglePay] IsReadyToPayRequest == null");
+      promise.resolve(false);
+      return;
+    }
+
+    // The call to isReadyToPay is asynchronous and returns a Task. We need to provide an
+    // OnCompleteListener to be triggered when the result of the call is known.
+    Task<Boolean> task = mPaymentsClient.isReadyToPay(request);
+    task.addOnCompleteListener(activity,
+      new OnCompleteListener<Boolean>() {
+        @Override
+        public void onComplete(@NonNull Task<Boolean> task) {
+          if (task.isSuccessful()) {
+            if (task.getResult()) {
+              promise.resolve(true);
+            } else {
+              Log.w(TAG, "[GooglePay] Not available");
+              promise.resolve(false);
+            }
+          } else {
+            Log.w(TAG, "[GooglePay] isReadyToPay failed. May add com.google.android.gms.wallet.api.enabled to your manifest?");
+            promise.resolve(false);
+          }
+        }
+      });
+  }
+
+  @ReactMethod
+  public void requestPayment(ReadableMap requestData, final Promise promise) {
+    final Activity activity = getCurrentActivity();
+    if (activity == null) {
+      Log.w(TAG, "[GooglePay] activity is null");
+      promise.reject("NO_ACTIVITY", "activity is null");
+      return;
+    }
+    JSONObject paymentDataRequestJson = PaymentsUtil.getPaymentDataRequest(requestData);
+    if (paymentDataRequestJson == null) {
+      promise.reject("PAYMENT_DATA_REQUEST_JSON", "paymentDataRequestJson is null");
+      return;
+    }
+
+    this.requestPaymentPromise = promise;
+
+    PaymentDataRequest request = PaymentDataRequest.fromJson(paymentDataRequestJson.toString());
+    if (request != null) {
+      AutoResolveHelper.resolveTask(mPaymentsClient.loadPaymentData(request), activity, LOAD_PAYMENT_DATA_REQUEST_CODE);
+    }
+  }
+
+  private void handlePaymentSuccess(PaymentData paymentData) {
+    String paymentInformation = paymentData.toJson();
+
+    // Token will be null if PaymentDataRequest was not constructed using fromJson(String).
+    if (paymentInformation == null) {
+      requestPaymentPromise.reject("NULL_PAYMENT_INFORMATION", "paymentInformation is null");
+      return;
+    }
+    JSONObject paymentMethodData;
+
+    try {
+      paymentMethodData = new JSONObject(paymentInformation).getJSONObject("paymentMethodData");
+      // If the gateway is set to "example", no payment information is returned - instead, the
+      // token will only consist of "examplePaymentMethodToken".
+
+      // Logging token string.
+      String token = paymentMethodData.getJSONObject("tokenizationData").getString("token");
+      requestPaymentPromise.resolve(token);
+    } catch (JSONException e) {
+      Log.e(TAG, "[GooglePay] handlePaymentSuccess error: " + e.toString());
+      return;
+    }
+  }
+
+  @Override
+  public String getName() {
+    return "GooglePay";
+  }
+}

package/android/src/main/java/com/reactnativepayengine/PayengineModule.java

@@ -22,12 +22,8 @@ public class PayengineModule extends ReactContextBaseJavaModule {
         return NAME;
     }
 
-
-    // Example method
-    // See https://reactnative.dev/docs/native-modules-android
     @ReactMethod
     public void multiply(double a, double b, Promise promise) {
-        promise.resolve(a * b);
+      promise.resolve(a * b);
     }
-
 }

package/android/src/main/java/com/reactnativepayengine/PayenginePackage.java

@@ -6,40 +6,23 @@ import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
-import com.reactnativepayengine.collect.VGSCollectModule;
-import com.reactnativepayengine.collect.VGSCollectOnCreateViewInstanceListener;
-import com.reactnativepayengine.collect.fields.VGSCVCField;
-import com.reactnativepayengine.collect.fields.VGSCardHolderNameField;
-import com.reactnativepayengine.collect.fields.VGSCardNumberField;
-import com.reactnativepayengine.collect.fields.VGSExpDateField;
-import com.reactnativepayengine.collect.fields.VGSTextField;
-import com.reactnativepayengine.collect.fields.VGSZipCodeField;
-import com.verygoodsecurity.vgscollect.view.InputFieldView;
+import com.reactnativepayengine.v2.RNPayEngineNative;
+import com.reactnativepayengine.v2.securefields.bankaccount.RNPEBankAccountViewManager;
+import com.reactnativepayengine.v2.securefields.creditcard.RNPECreditCardViewManager;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class PayenginePackage implements ReactPackage, VGSCollectOnCreateViewInstanceListener {
-
-  private VGSCollectModule module;
-
-  public VGSCollectOnCreateViewInstanceListener getListener() {
-    return this;
-  }
-
-  public VGSCollectModule getVGSCollectModule() {
-    return module;
-  }
-
+public class PayenginePackage implements ReactPackage {
 
   @NonNull
   @Override
   public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-    module = new VGSCollectModule(reactContext);
 
     List<NativeModule> modules = new ArrayList<>();
+    modules.add(new RNPayEngineNative(reactContext));
     modules.add(new PayengineModule(reactContext));
-    modules.add(module);
+    modules.add(new GooglePayModule(reactContext));
 
     return modules;
   }
@@ -48,17 +31,9 @@ public class PayenginePackage implements ReactPackage, VGSCollectOnCreateViewIns
   @Override
   public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
     List<ViewManager> views = new ArrayList<>();
-    views.add(new VGSExpDateField(this, reactContext));
-    views.add(new VGSCardNumberField(this, reactContext));
-    views.add(new VGSCardHolderNameField(this, reactContext));
-    views.add(new VGSCVCField(this, reactContext));
-    views.add(new VGSZipCodeField(this, reactContext));
-    views.add(new VGSTextField(this, reactContext));
+    views.add(new RNPECreditCardViewManager(reactContext));
+    views.add(new RNPEBankAccountViewManager(reactContext));
     return views;
   }
 
-  @Override
-  public void onCreateViewInstance(InputFieldView inputFieldView) {
-    module.bindView(inputFieldView);
-  }
 }

package/android/src/main/java/com/reactnativepayengine/util/MetricsUtil.kt

@@ -0,0 +1,44 @@
+package com.reactnativepayengine.util
+
+import android.content.Context
+import android.content.res.Resources
+import android.util.DisplayMetrics
+
+object MetricsUtil {
+
+  /**
+   * This method converts dp unit to equivalent pixels, depending on device density.
+   * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
+   * @param context Context to get resources and device specific display metrics. If you don't have
+   * access to Context, just pass null.
+   * @return A float value to represent px equivalent to dp depending on device density
+   */
+  fun convertDpToPixel(dp: Float, context: Context?): Float {
+    return if (context != null) {
+      val resources = context.resources
+      val metrics = resources.displayMetrics
+      dp * (metrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
+    } else {
+      val metrics = Resources.getSystem().displayMetrics
+      dp * (metrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
+    }
+  }
+
+  /**
+   * This method converts device specific pixels to density independent pixels.
+   * @param px A value in px (pixels) unit. Which we need to convert into db
+   * @param context Context to get resources and device specific display metrics. If you don't have
+   * access to Context, just pass null.
+   * @return A float value to represent dp equivalent to px value
+   */
+  fun convertPixelsToDp(px: Float, context: Context?): Float {
+    return if (context != null) {
+      val resources = context.resources
+      val metrics = resources.displayMetrics
+      px / (metrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
+    } else {
+      val metrics = Resources.getSystem().displayMetrics
+      px / (metrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
+    }
+  }
+}

package/android/src/main/java/com/reactnativepayengine/util/PaymentsUtil.java

@@ -0,0 +1,113 @@
+package com.reactnativepayengine.util;
+import android.app.Activity;
+
+import com.google.android.gms.wallet.PaymentsClient;
+import com.google.android.gms.wallet.Wallet;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+import com.facebook.react.bridge.ReadableMap;
+
+public class PaymentsUtil {
+
+  private PaymentsUtil() {
+  }
+
+  private static JSONObject getBaseRequest() throws JSONException {
+    return new JSONObject().put("apiVersion", 2).put("apiVersionMinor", 0);
+  }
+
+  private static JSONObject getBaseCardPaymentMethod(ArrayList allowedCardNetworks, ArrayList allowedCardAuthMethods) throws JSONException {
+    JSONObject cardPaymentMethod = new JSONObject();
+    cardPaymentMethod.put("type", "CARD");
+
+    JSONObject parameters = new JSONObject();
+    parameters.put("allowedAuthMethods", new JSONArray(allowedCardAuthMethods));
+    parameters.put("allowedCardNetworks", new JSONArray(allowedCardNetworks));
+
+    cardPaymentMethod.put("parameters", parameters);
+
+    return cardPaymentMethod;
+  }
+
+  public static PaymentsClient createPaymentsClient(int environment, Activity activity) {
+    Wallet.WalletOptions walletOptions = new Wallet.WalletOptions.Builder().setEnvironment(environment).build();
+    return Wallet.getPaymentsClient(activity, walletOptions);
+  }
+
+  public static JSONObject getIsReadyToPayRequest(ArrayList allowedCardNetworks, ArrayList allowedCardAuthMethods) {
+    try {
+      JSONObject isReadyToPayRequest = getBaseRequest();
+      JSONArray allowedPaymentMethods = new JSONArray().put(getBaseCardPaymentMethod(allowedCardNetworks, allowedCardAuthMethods));
+      isReadyToPayRequest.put("allowedPaymentMethods", allowedPaymentMethods);
+      return isReadyToPayRequest;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  private static JSONObject getTransactionInfo(ReadableMap transaction) throws JSONException {
+    JSONObject transactionInfo = new JSONObject();
+    transactionInfo.put("totalPrice", transaction.getString("totalPrice"));
+    transactionInfo.put("totalPriceStatus", transaction.getString("totalPriceStatus"));
+    transactionInfo.put("currencyCode", transaction.getString("currencyCode"));
+
+    return transactionInfo;
+  }
+
+  private static JSONObject getMerchantInfo(String merchantName) throws JSONException {
+    return new JSONObject().put("merchantName", merchantName);
+  }
+
+  private static JSONObject getTokenizationSpecification(final ReadableMap tokenizationSpecification) throws JSONException {
+    return new JSONObject() {{
+      put("type", tokenizationSpecification.getString("type"));
+      put("parameters", new JSONObject() {
+        {
+          if (tokenizationSpecification.hasKey("gateway")) {
+            put("gateway", tokenizationSpecification.getString("gateway"));
+          }
+          if (tokenizationSpecification.hasKey("gatewayMerchantId")) {
+            put("gatewayMerchantId", tokenizationSpecification.getString("gatewayMerchantId"));
+          }
+          if (tokenizationSpecification.hasKey("publicKey")) {
+            put("protocolVersion", "ECv2");
+            put("publicKey", tokenizationSpecification.getString("publicKey"));
+          }
+          if (tokenizationSpecification.hasKey("stripe")) {
+            final ReadableMap stripe = tokenizationSpecification.getMap("stripe");
+            put("stripe:publishableKey", stripe.getString("publishableKey"));
+            put("stripe:version", stripe.getString("version"));
+          }
+        }
+      });
+    }};
+  }
+
+  private static JSONObject getCardPaymentMethod(ReadableMap cardPaymentMethodData) throws JSONException {
+    ArrayList allowedCardNetworks = cardPaymentMethodData.getArray("allowedCardNetworks").toArrayList();
+    ArrayList allowedCardAuthMethods = cardPaymentMethodData.getArray("allowedCardAuthMethods").toArrayList();
+    JSONObject cardPaymentMethod = getBaseCardPaymentMethod(allowedCardNetworks, allowedCardAuthMethods);
+    cardPaymentMethod.put("tokenizationSpecification", getTokenizationSpecification(cardPaymentMethodData.getMap("tokenizationSpecification")));
+
+    return cardPaymentMethod;
+  }
+
+  public static JSONObject getPaymentDataRequest(ReadableMap requestData) {
+    try {
+      JSONObject paymentDataRequest = PaymentsUtil.getBaseRequest();
+      paymentDataRequest.put(
+        "allowedPaymentMethods", new JSONArray().put(PaymentsUtil.getCardPaymentMethod(requestData.getMap("cardPaymentMethod"))));
+      paymentDataRequest.put("transactionInfo", PaymentsUtil.getTransactionInfo(requestData.getMap("transaction")));
+      paymentDataRequest.put("merchantInfo", PaymentsUtil.getMerchantInfo(requestData.getString("merchantName")));
+
+      return paymentDataRequest;
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+}

package/android/src/main/java/com/reactnativepayengine/v2/RNPEFraudAnalyticsApplication.java

@@ -0,0 +1,55 @@
+package com.reactnativepayengine.v2;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.kount.api.analytics.AnalyticsApplication;
+import com.kount.api.analytics.enums.EventEnums;
+
+public class RNPEFraudAnalyticsApplication extends Application implements Application.ActivityLifecycleCallbacks {
+  @Override
+  public void onCreate() {
+    AnalyticsApplication.init();
+    registerActivityLifecycleCallbacks(this);
+    super.onCreate();
+  }
+
+  @Override
+  public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
+
+  }
+
+  @Override
+  public void onActivityStarted(@NonNull Activity activity) {
+    AnalyticsApplication.registerKountEvents(EventEnums.EVENT_STARTED, activity);
+  }
+
+  @Override
+  public void onActivityResumed(@NonNull Activity activity) {
+    AnalyticsApplication.registerKountEvents(EventEnums.EVENT_RESUMED, activity);
+  }
+
+  @Override
+  public void onActivityPaused(@NonNull Activity activity) {
+    AnalyticsApplication.registerKountEvents(EventEnums.EVENT_PAUSED, activity);
+  }
+
+  @Override
+  public void onActivityStopped(@NonNull Activity activity) {
+    AnalyticsApplication.registerKountEvents(EventEnums.EVENT_STOPPED, activity);
+  }
+
+  @Override
+  public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {
+
+  }
+
+  @Override
+  public void onActivityDestroyed(@NonNull Activity activity) {
+
+  }
+}

package/android/src/main/java/com/reactnativepayengine/v2/RNPayEngineNative.kt

@@ -0,0 +1,71 @@
+package com.reactnativepayengine.v2
+
+import android.app.Activity
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
+import com.payengine.paymentsdk.PayEngine
+import com.payengine.paymentsdk.models.PEConfig
+import kotlin.concurrent.thread
+
+class RNPayEngineNative: ReactContextBaseJavaModule {
+
+  constructor(context: ReactApplicationContext): super(context) {
+
+  }
+
+  override fun getName(): String {
+    return "RNPayEngineNative"
+  }
+
+  @ReactMethod
+  fun setConfig(publicKey: String, baseURL: String?) {
+    Log.d("PayEngine", "setConfig is called $publicKey $baseURL")
+    val config = PEConfig(publicKey, baseURL)
+    instance = PayEngine(config)
+  }
+
+  @ReactMethod
+  fun createFraudMonitorSession(merchantId: String, promise: Promise) {
+    val currentActivity = reactApplicationContext.currentActivity
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "No activity found")
+      return
+    }
+
+
+    val sessionId = instance?.createFraudMonitorSession(currentActivity, merchantId) { sessionId ->
+      if (sessionId != null) {
+        promise.resolve(sessionId)
+      } else {
+        promise.reject("NO_SESSION", "No session found")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun getBrowserInfo(promise: Promise) {
+    val currentActivity = reactApplicationContext.currentActivity
+    if (currentActivity == null) {
+      promise.reject("NO_ACTIVITY", "No activity found")
+      return
+    }
+
+    runOnUiThread {
+      instance?.getBrowserInfo(currentActivity) { browserInfo ->
+        if (browserInfo != null) {
+          promise.resolve(browserInfo)
+        } else {
+          promise.reject("NO_BROWSER_INFO", "No browser info found")
+        }
+      }
+    }
+  }
+
+  companion object {
+    var instance: PayEngine? = null
+  }
+}

package/android/src/main/java/com/reactnativepayengine/v2/securefields/RNPEEvents.kt

@@ -0,0 +1,8 @@
+package com.reactnativepayengine.v2.securefields
+
+object RNPEEvents {
+  val ON_READY = "onReady"
+  val ON_SIZE_CHANGES = "onSizeChanges"
+  val ON_CARD_RESPOND = "onCardRespond"
+  val ON_BANK_ACCOUNT_RESPOND = "onBankAccountRespond"
+}

package/android/src/main/java/com/reactnativepayengine/v2/securefields/RNPEField.kt

@@ -0,0 +1,17 @@
+package com.reactnativepayengine.v2.securefields
+
+import com.payengine.paymentsdk.models.PEField
+import com.payengine.paymentsdk.models.PEKeyboardType
+
+data class RNPEField(val name: String, val type: String, val placeholder: String, val keyboardType: String, val isRequired: Boolean, val pattern: String?) {
+
+  fun toNative(): PEField {
+    val nativeKeyboardType = when (keyboardType) {
+      "number" -> PEKeyboardType.NUMBER
+      "alphabet" -> PEKeyboardType.ALPHABET
+      "phone" -> PEKeyboardType.PHONE
+      else -> PEKeyboardType.NORMAL
+    }
+    return PEField(name, type, placeholder, isRequired, nativeKeyboardType, pattern)
+  }
+}