@cashfreepayments/react-native-cashfree-cn-sdk 1.0.0-dev.0

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/com/reactnativecashfreecnsdk/CashfreePgApiModule.java

@@ -0,0 +1,319 @@
+package com.reactnativecashfreecnsdk;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.net.Uri;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.cashfree.pg.api.CFPaymentGatewayService;
+import com.cashfree.pg.cf_analytics.CFAnalyticsService;
+import com.cashfree.pg.cf_analytics.CFEventsSubscriber;
+import com.cashfree.pg.core.api.CFCorePaymentGatewayService;
+import com.cashfree.pg.core.api.CFSession;
+import com.cashfree.pg.core.api.base.CFPayment;
+import com.cashfree.pg.core.api.callback.CFCheckoutResponseCallback;
+import com.cashfree.pg.core.api.card.CFCard;
+import com.cashfree.pg.core.api.card.CFCardPayment;
+import com.cashfree.pg.core.api.exception.CFException;
+import com.cashfree.pg.core.api.exception.CFInvalidArgumentException;
+import com.cashfree.pg.core.api.persistence.CFPersistence;
+import com.cashfree.pg.core.api.upi.CFUPI;
+import com.cashfree.pg.core.api.upi.CFUPIPayment;
+import com.cashfree.pg.core.api.utils.CFErrorResponse;
+import com.cashfree.pg.core.api.webcheckout.CFWebCheckoutPayment;
+import com.cashfree.pg.ui.api.CFDropCheckoutPayment;
+import com.cashfree.pg.ui.api.upi.intent.CFUPIIntentCheckoutPayment;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.cashfree.pg.api.util.DropPaymentParser;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.List;
+import java.util.Map;
+
+@ReactModule(name = CashfreePgApiModule.NAME)
+public class CashfreePgApiModule extends ReactContextBaseJavaModule implements CFCheckoutResponseCallback, CFEventsSubscriber {
+    public static final String NAME = "CashfreePgApi";
+
+    public CashfreePgApiModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void doPayment(String cfPaymentString,String baseUrl) {
+        Log.d("CashfreePgApiModule", cfPaymentString);
+        try {
+            Activity activity = getCurrentActivity();
+          CFPersistence.getInstance().storeBaseUrl(baseUrl);
+          CFDropCheckoutPayment cfDropCheckoutPayment = DropPaymentParser.getDropCheckoutPayment(cfPaymentString);
+            cfDropCheckoutPayment.setCfsdkFramework(CFPayment.CFSDKFramework.REACT_NATIVE);
+            cfDropCheckoutPayment.setCfSDKFlavour(CFPayment.CFSDKFlavour.DROP);
+            if (activity != null) {
+                CFPaymentGatewayService.getInstance().doPayment(activity, cfDropCheckoutPayment);
+            } else {
+                throw new IllegalStateException("activity is null");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @ReactMethod
+    public void doUPIPayment(String cfPaymentString,String baseUrl) {
+        Log.d("CashfreePgApiModule", cfPaymentString);
+        try {
+            Activity activity = getCurrentActivity();
+          CFPersistence.getInstance().storeBaseUrl(baseUrl);
+
+          CFUPIIntentCheckoutPayment cfupiIntentCheckoutPayment = DropPaymentParser.getUPICheckoutPayment(cfPaymentString);
+            cfupiIntentCheckoutPayment.setCfsdkFramework(CFPayment.CFSDKFramework.REACT_NATIVE);
+            cfupiIntentCheckoutPayment.setCfSDKFlavour(CFPayment.CFSDKFlavour.INTENT);
+            if (activity != null) {
+                CFPaymentGatewayService.getInstance().doPayment(activity, cfupiIntentCheckoutPayment);
+            } else {
+                throw new IllegalStateException("activity is null");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @ReactMethod
+    public void doWebPayment(String sessionString,String baseUrl) {
+        Log.d("CashfreePgApiModule Web", sessionString);
+        CFSession cfSession = null;
+        try {
+            JSONObject jsonObject = new JSONObject(sessionString);
+          CFPersistence.getInstance().storeBaseUrl(baseUrl);
+          cfSession = new CFSession.CFSessionBuilder()
+                    .setEnvironment(CFSession.Environment.valueOf(jsonObject.getString("environment")))
+                    .setOrderId(jsonObject.getString("orderID"))
+                    .setBaseUrl(baseUrl)
+                    .setPaymentSessionID(jsonObject.getString("payment_session_id"))
+                    .build();
+        } catch (Exception exception) {
+            throw new IllegalStateException("Session is invalid");
+        }
+        try {
+            Activity activity = getCurrentActivity();
+            CFWebCheckoutPayment cfWebCheckoutPayment = new CFWebCheckoutPayment.CFWebCheckoutPaymentBuilder()
+                    .setSession(cfSession)
+                    .build();
+            cfWebCheckoutPayment.setCfsdkFramework(CFPayment.CFSDKFramework.REACT_NATIVE);
+            cfWebCheckoutPayment.setCfSDKFlavour(CFPayment.CFSDKFlavour.WEB_CHECKOUT);
+            if (activity != null) {
+                CFPaymentGatewayService.getInstance().doPayment(activity, cfWebCheckoutPayment);
+            } else {
+                throw new IllegalStateException("activity is null");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @ReactMethod
+    public void doCardPayment(String data,String baseUrl) {
+      CFSession cfSession = null;
+      CFCard card = null;
+      boolean saveCard;
+      try {
+        JSONObject jsonObject = new JSONObject(data);
+        JSONObject session = jsonObject.getJSONObject("session");
+        JSONObject cardObject = jsonObject.getJSONObject("card");
+        saveCard = cardObject.optBoolean("saveCard", false);
+        CFPersistence.getInstance().storeBaseUrl(baseUrl);
+        cfSession = new CFSession.CFSessionBuilder()
+          .setEnvironment(CFSession.Environment.valueOf(session.getString("environment")))
+          .setBaseUrl(baseUrl)
+          .setOrderId(session.getString("orderID"))
+          .setPaymentSessionID(session.getString("payment_session_id"))
+          .build();
+        if (cardObject.has("instrumentId")) {
+          card = new CFCard.CFCardBuilder()
+            .setInstrumentId(cardObject.getString("instrumentId"))
+            .setCVV(cardObject.getString("cardCvv"))
+            .build();
+        } else {
+          card = new CFCard.CFCardBuilder()
+            .setCardNumber(cardObject.getString("cardNumber"))
+            .setCardHolderName(cardObject.getString("cardHolderName"))
+            .setCardExpiryMonth(cardObject.getString("cardExpiryMM"))
+            .setCardExpiryYear(cardObject.getString("cardExpiryYY"))
+            .setCVV(cardObject.getString("cardCvv"))
+            .setChannel("post")
+            .build();
+        }
+      } catch (Exception exception) {
+        throw new IllegalStateException(exception.getMessage());
+      }
+      try {
+        Activity activity = getCurrentActivity();
+        CFCardPayment cardPayment = new CFCardPayment.CFCardPaymentBuilder()
+          .setSession(cfSession)
+          .setCard(card)
+          .setSaveCardDetail(saveCard)
+          .build();
+        cardPayment.setCfSDKFlow(CFPayment.CFSDKFlow.WITH_CASHFREE_FULLSCREEN_LOADER);
+        cardPayment.setCfsdkFramework(CFPayment.CFSDKFramework.REACT_NATIVE);
+        cardPayment.setCfSDKFlavour(CFPayment.CFSDKFlavour.ELEMENT);
+        if (activity != null) {
+          CFPaymentGatewayService.getInstance().doPayment(activity, cardPayment);
+        } else {
+          throw new IllegalStateException("activity is null");
+        }
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+
+    @ReactMethod
+    public void getInstalledUpiApps(Callback cb){
+      Activity activity = getCurrentActivity();
+      final Intent intent = new Intent();
+      intent.setAction(Intent.ACTION_VIEW);
+      intent.setData(Uri.parse("upi://pay"));
+      PackageManager pm = activity.getPackageManager();
+      final List<ResolveInfo> resInfo = pm.queryIntentActivities(intent, 0);
+      JSONArray packageNames = new JSONArray();
+      try {
+        for (ResolveInfo info : resInfo) {
+          JSONObject appInfo = new JSONObject();
+          String appName = (String)activity.getPackageManager().getApplicationLabel(info.activityInfo.applicationInfo);
+          appInfo.put("appName", appName);
+          appInfo.put("appPackage", info.activityInfo.packageName);
+          packageNames.put(appInfo);
+        }
+      } catch (Exception ex) {
+        ex.printStackTrace();
+      }
+      Log.d("CashfreePgApiModule", "getInstalledUpiApps::--" + packageNames);
+      cb.invoke(packageNames.toString());
+    }
+
+  @ReactMethod
+  public void doElementUPIPayment(String upiPaymentData,String baseUrl) {
+    Log.d("CashfreePgApiModule", upiPaymentData);
+    CFSession cfSession = null;
+    CFUPI cfupi = null;
+    try {
+      CFPersistence.getInstance().storeBaseUrl(baseUrl);
+      JSONObject jsonObject = new JSONObject(upiPaymentData);
+      JSONObject session = jsonObject.getJSONObject("session");
+      JSONObject upiObject = jsonObject.getJSONObject("upi");
+      cfSession = new CFSession.CFSessionBuilder()
+        .setEnvironment(CFSession.Environment.valueOf(session.getString("environment")))
+        .setOrderId(session.getString("orderID"))
+        .setBaseUrl(baseUrl)
+        .setPaymentSessionID(session.getString("payment_session_id"))
+        .build();
+      CFUPI.Mode mode = CFUPI.Mode.valueOf(upiObject.getString("mode"));
+      String upiId = upiObject.getString("id");
+      cfupi = new CFUPI.CFUPIBuilder()
+        .setMode(mode)
+        .setUPIID(upiId)
+        .build();
+    } catch (Exception exception) {
+      throw new IllegalStateException(exception.getMessage());
+    }
+    try {
+      CFUPIPayment cfupiPayment = new CFUPIPayment.CFUPIPaymentBuilder()
+        .setSession(cfSession)
+        .setCfUPI(cfupi)
+        .build();
+      cfupiPayment.setCfSDKFlow(CFPayment.CFSDKFlow.WITH_CASHFREE_FULLSCREEN_LOADER);
+      cfupiPayment.setCfsdkFramework(CFPayment.CFSDKFramework.REACT_NATIVE);
+      cfupiPayment.setCfSDKFlavour(CFPayment.CFSDKFlavour.ELEMENT);
+      Activity activity = getCurrentActivity();
+      if (activity != null) {
+        CFCorePaymentGatewayService.getInstance().doPayment(activity, cfupiPayment);
+      } else {
+        throw new IllegalStateException("activity is null");
+      }
+    } catch (CFException exception) {
+      exception.printStackTrace();
+    }
+  }
+
+    @ReactMethod
+    public void setCallback() {
+        try {
+            CFPaymentGatewayService.getInstance().setCheckoutCallback(this);
+        } catch (CFException cfException) {
+        }
+    }
+
+    @ReactMethod
+    public void setEventSubscriber() {
+        try {
+            CFAnalyticsService.getInstance().setSubscriber(this);
+        } catch (Exception ignored) {
+        }
+    }
+
+    @ReactMethod
+    public void removeEventSubscriber() {
+        try {
+            CFAnalyticsService.getInstance().removeSubscriber();
+        } catch (Exception ignored) {
+        }
+    }
+
+    @Override
+    public void onPaymentVerify(String orderID) {
+        this.getReactApplicationContext()
+                .getJSModule(RCTNativeAppEventEmitter.class)
+                .emit("cfSuccess", orderID);
+    }
+
+    @Override
+    public void onPaymentFailure(CFErrorResponse cfErrorResponse, String orderID) {
+        JSONObject jsonObject = new JSONObject();
+        try {
+            jsonObject.put("error", cfErrorResponse.toJSON().toString());
+            jsonObject.put("orderID", orderID);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        this.getReactApplicationContext()
+                .getJSModule(RCTNativeAppEventEmitter.class)
+                .emit("cfFailure", jsonObject.toString());
+    }
+
+    @Override
+    public void receivedEvent(String s, @Nullable Map<String, String> map) {
+        JSONObject jsonObject = new JSONObject();
+        JSONObject jsonMeta = new JSONObject();
+        try {
+            if (map != null) {
+                for (String key : map.keySet()) {
+                    jsonMeta.put(key, map.get(key));
+                }
+            }
+            jsonObject.put("eventName", s);
+            jsonObject.put("meta", jsonMeta);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        this.getReactApplicationContext()
+                .getJSModule(RCTNativeAppEventEmitter.class)
+                .emit("cfEvent", jsonObject.toString());
+    }
+}

package/android/src/main/java/com/reactnativecashfreecnsdk/CashfreePgApiPackage.java

@@ -0,0 +1,28 @@
+package com.reactnativecashfreecnsdk;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class CashfreePgApiPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new CashfreePgApiModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/ios/CashfreeEmitter.swift

@@ -0,0 +1,36 @@
+//
+//  CashfreeEmitter.swift
+//  react-native-cashfree-pg-api
+//
+//  Created by Aabhas Jindal on 14/06/22.
+//
+
+class CashfreeEmitter {
+
+    /// Shared Instance.
+    public static var sharedInstance = CashfreeEmitter()
+
+    // ReactNativeEventEmitter is instantiated by React Native with the bridge.
+    private var eventEmitter: CashfreeEventEmitter!
+
+    private init() {}
+
+    // When React Native instantiates the emitter it is registered here.
+    func registerEventEmitter(eventEmitter: CashfreeEventEmitter) {
+        self.eventEmitter = eventEmitter
+    }
+
+    func dispatch(name: String, body: Any?) {
+        eventEmitter.sendEvent(withName: name, body: body)
+    }
+
+    /// All Events which must be support by React Native.
+    lazy var allEvents: [String] = {
+        var allEventNames: [String] = ["cfSuccess", "cfFailure", "cfEvent", "cfUpiApps"]
+
+        // Append all events here
+
+        return allEventNames
+    }()
+
+}

package/ios/CashfreeEventEmitter.m

@@ -0,0 +1,16 @@
+//
+//  CashfreeEventEmitter.m
+//  DoubleConversion
+//
+//  Created by Aabhas Jindal on 13/06/22.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(CashfreeEventEmitter, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(supportedEvents)
+
+@end

package/ios/CashfreeEventEmitter.swift

@@ -0,0 +1,28 @@
+//
+//  CashfreeEventEmitter.swift
+//  DoubleConversion
+//
+//  Created by Aabhas Jindal on 13/06/22.
+//
+
+import Foundation
+
+@objc(CashfreeEventEmitter)
+open class CashfreeEventEmitter: RCTEventEmitter {
+
+    override init() {
+        super.init()
+        CashfreeEmitter.sharedInstance.registerEventEmitter(eventEmitter: self)
+    }
+
+    /// Base overide for RCTEventEmitter.
+    ///
+    /// - Returns: all supported events
+    @objc open override func supportedEvents() -> [String] {
+        return CashfreeEmitter.sharedInstance.allEvents
+    }
+
+    @objc public override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/ios/CashfreePgApi-Bridging-Header.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTUtils.h>
+#import <Foundation/Foundation.h>
+#import <React/RCTEventEmitter.h>

package/ios/CashfreePgApi.m

@@ -0,0 +1,21 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTUtils.h>
+
+@interface RCT_EXTERN_MODULE(CashfreePgApi, NSObject)
+
+RCT_EXTERN_METHOD(doPayment:(NSString)paymentObject)
+
+RCT_EXTERN_METHOD(doUPIPayment:(NSString)paymentObject)
+
+RCT_EXTERN_METHOD(doWebPayment:(NSString)paymentObject,(NSString)baseUrl)
+RCT_EXTERN_METHOD(doCardPayment:(NSString)paymentObject)
+RCT_EXTERN_METHOD(doElementUPIPayment:(NSString)paymentObject)
+RCT_EXTERN_METHOD(getInstalledUpiApps)
+
+RCT_EXTERN_METHOD(setCallback)
+
+RCT_EXTERN_METHOD(setEventSubscriber)
+
+RCT_EXTERN_METHOD(removeEventSubscriber)
+
+@end