expo-openpay 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 jgallaway2011
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# expo-openpay
+
+Expo module for integrating Openpay payments in React Native / Expo projects.
+
+**Supports:** iOS, Android, and Expo-managed workflow.
+
+---
+
+## Installation
+
+### Managed Expo Projects
+
+If you are using the Expo-managed workflow, you can install:
+
+```bash
+npm install expo-openpay react-native-svg
+# or
+yarn add expo-openpay react-native-svg
+```
+
+react-native-svg is required to display card logos.
+
+No additional linking is required for Expo-managed projects.
+
+Bare React Native Projects
+For bare React Native projects:
+
+```bash
+Copy code
+npm install expo-openpay react-native-svg
+# or
+yarn add expo-openpay react-native-svg
+```
+
+After installing, run CocoaPods for iOS:
+
+```bash
+Copy code
+npx pod-install
+```
+
+Follow any extra React Native setup for Expo modules if needed.
+
+Usage
+Basic Example
+
+```ts
+Copy code
+import ExpoOpenpay, { ExpoOpenpayView } from 'expo-openpay';
+
+// Initialize Openpay (example)
+ExpoOpenpay.initialize({
+  merchantId: 'YOUR_MERCHANT_ID',
+  publicKey: 'YOUR_PUBLIC_KEY',
+  production: false
+});
+
+// Use the component in JSX
+export default function PaymentScreen() {
+  return (
+    <ExpoOpenpayView
+      amount={100}
+      cardType="visa"
+      onPaymentSuccess={(response) => console.log('Success', response)}
+      onPaymentError={(error) => console.log('Error', error)}
+    />
+  );
+}
+```
+
+Notes
+This module requires react-native-svg to render card logos.
+
+Peer dependencies: react, react-native, expo, react-native-svg.
+
+API
+ExpoOpenpay.initialize(config) – Initialize with your Openpay keys.
+
+ExpoOpenpayView – React component for payment UI.
+
+Other exports from ./components and ./ExpoOpenpayModule are also available for advanced usage.
+
+Contributing
+Contributions are welcome! Please read the contributing guide.
+
+License
+MIT

package/android/build.gradle

@@ -0,0 +1,76 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.openpay'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 21)
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.openpay"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+  
+//   packagingOptions {
+//     resources {
+//       excludes += [
+//         "META-INF/DEPENDENCIES",
+//         "META-INF/LICENSE",
+//         "META-INF/LICENSE.txt",
+//         "META-INF/license.txt",
+//         "META-INF/NOTICE",
+//         "META-INF/NOTICE.txt",
+//         "META-INF/notice.txt",
+//         "META-INF/ASL2.0"
+//       ]
+//     }
+//     exclude("META-INF/DEPENDENCIES")
+//     exclude("META-INF/LICENSE")
+//     exclude("META-INF/LICENSE.txt")
+//     exclude("META-INF/license.txt")
+//     exclude("META-INF/NOTICE")
+//     exclude("META-INF/NOTICE.txt")
+//     exclude("META-INF/notice.txt")
+//     exclude("META-INF/ASL2.0")
+//     exclude("META-INF/*.kotlin_module")         
+//   }
+}
+
+dependencies {
+  implementation 'androidx.fragment:fragment:1.6.2'
+  implementation 'com.google.http-client:google-http-client:1.43.3'
+  implementation 'com.google.http-client:google-http-client-android:1.43.3'
+  implementation 'com.google.http-client:google-http-client-jackson2:1.43.3'
+  implementation 'com.fasterxml.jackson.core:jackson-core:2.19.1'
+  implementation 'org.slf4j:slf4j-log4j12:2.0.12'
+}

package/android/gradle.properties

@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/openpay/ExpoOpenpayModule.kt

@@ -0,0 +1,127 @@
+package expo.modules.openpay
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+import java.net.URL
+import mx.openpay.android.Openpay
+import mx.openpay.android.OpCountry
+import mx.openpay.android.OperationCallBack
+import mx.openpay.android.OperationResult
+import mx.openpay.android.exceptions.OpenpayServiceException
+import mx.openpay.android.exceptions.ServiceUnavailableException
+import mx.openpay.android.model.Card
+import mx.openpay.android.model.Token
+
+class ExpoOpenpayModule : Module() {
+  private var openpay: Openpay? = null
+  // Each module class must implement the definition function. The definition consists of components
+  // that describes the module's functionality and behavior.
+  // See https://docs.expo.dev/modules/module-api for more details about available components.
+  override fun definition() = ModuleDefinition {
+    // Sets the name of the module that JavaScript code will use to refer to the module. Takes a string as an argument.
+    // Can be inferred from module's class name, but it's recommended to set it explicitly for clarity.
+    // The module will be accessible from `requireNativeModule('ExpoOpenpay')` in JavaScript.
+    Name("Openpay")
+
+    // Defines a JavaScript function that always returns a Promise and whose native code
+    // is by default dispatched on the different thread than the JavaScript runtime runs on.
+    AsyncFunction("initialize") { merchantId: String, apiKey: String, isProduction: Boolean, countryCode: String?, promise: Promise ->
+
+      if (merchantId.isEmpty() || apiKey.isEmpty()) {
+        promise.reject("OPENPAY_INVALID_PARAMS", "Merchant ID and API Key are required", Throwable("Missing parameters"))
+        return@AsyncFunction
+      }
+
+      val opCountry = when (countryCode?.uppercase()) {
+        "CO" -> OpCountry.COL
+        "PE" -> OpCountry.PE
+        null, "", "MX" -> OpCountry.MX
+        else -> {
+          promise.reject(
+            "OPENPAY_INVALID_COUNTRY_CODE",
+            "Invalid country code: ${countryCode?.uppercase()}. Please use 'MX', 'CO', or 'PE', or leave empty to default to 'MX'.",
+            Throwable("Invalid Country Code")
+          )
+          return@AsyncFunction
+        }
+      }
+
+      try {
+        openpay = Openpay(merchantId, apiKey, isProduction, opCountry)
+        promise.resolve("Openpay initialized")
+      } catch (e: Exception) {
+        promise.reject("OPENPAY_INITIALIZATION_FAILED", e.message, e)
+      }
+    }
+
+    AsyncFunction("isInitialized") { promise: Promise ->
+      promise.resolve(openpay != null)
+    }
+
+    AsyncFunction("createDeviceSessionId") { promise: Promise ->  
+      if (openpay == null) {
+        promise.reject("OPENPAY_NOT_INITIALIZED", "Openpay is not initialized", Throwable("Openpay init failed or never occured"))
+        return@AsyncFunction
+      }
+
+      val activity = appContext.currentActivity
+        
+      if (activity == null) {
+        promise.reject("NO_ACTIVITY", "Current activity is null", Throwable("No activity object"))
+        return@AsyncFunction
+      }
+
+      try {
+        val deviceId = openpay.deviceCollectorDefaultImpl.setup(activity)
+        promise.resolve(deviceId)
+      } catch (e: Exception) {
+        promise.reject("OPENPAY_DEVICE_SESSION_ID_ERROR", e.message, e)
+      }
+    }
+
+    AsyncFunction("tokenizeCard") { cardNumber: String, holderName: String, expirationYear: String, expirationMonth: String, cvv2: String, promise: Promise ->  
+      if (openpay == null) {
+        promise.reject("OPENPAY_NOT_INITIALIZED", "Openpay is not initialized", Throwable("Openpay init failed or never occured"))
+        return@AsyncFunction
+      }
+
+      try {
+        val card = Card().apply {
+          holderName(holderName)
+          cardNumber(cardNumber)
+          expirationMonth(expirationMonth.toInt())
+          expirationYear(expirationYear.toInt())
+          cvv2(cvv2)
+        }
+
+        openpay.createToken(card, object: OperationCallBack<Token> {
+          override fun onSuccess(result: OperationResult<Token>) {
+            promise.resolve(result.result.id)
+          }
+
+          override fun onError(e: OpenpayServiceException) {
+            promise.reject("OPENPAY_CARD_TOKEN_ERROR", e.message, e)
+          }
+
+          override fun onCommunicationError(e: ServiceUnavailableException) {
+            promise.reject("OPENPAY_CARD_TOKEN_ERROR", e.message, e)
+          }
+        })
+      } catch (e: Exception) {
+        promise.reject("OPENPAY_CARD_TOKEN_ERROR", e.message, e)
+      }
+    }
+
+    // Enables the module to be used as a native view. Definition components that are accepted as part of
+    // the view definition: Prop, Events.
+    View(ExpoOpenpayView::class) {
+      // Defines a setter for the `url` prop.
+      Prop("url") { view: ExpoOpenpayView, url: URL ->
+        view.webView.loadUrl(url.toString())
+      }
+      // Defines an event that the view can send to JavaScript.
+      Events("onLoad")
+    }
+  }
+}

package/android/src/main/java/expo/modules/openpay/ExpoOpenpayView.kt

@@ -0,0 +1,30 @@
+package expo.modules.openpay
+
+import android.content.Context
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+
+class ExpoOpenpayView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+  // Creates and initializes an event dispatcher for the `onLoad` event.
+  // The name of the event is inferred from the value and needs to match the event name defined in the module.
+  private val onLoad by EventDispatcher()
+
+  // Defines a WebView that will be used as the root subview.
+  internal val webView = WebView(context).apply {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    webViewClient = object : WebViewClient() {
+      override fun onPageFinished(view: WebView, url: String) {
+        // Sends an event to JavaScript. Triggers a callback defined on the view component in JavaScript.
+        onLoad(mapOf("url" to url))
+      }
+    }
+  }
+
+  init {
+    // Adds the WebView to the view hierarchy.
+    addView(webView)
+  }
+}

package/android/src/main/java/mx/openpay/android/BuildConfig.java

@@ -0,0 +1,8 @@
+package mx.openpay.android;
+
+/* loaded from: BuildConfig.class */
+public final class BuildConfig {
+    public static final boolean DEBUG = false;
+    public static final String LIBRARY_PACKAGE_NAME = "mx.openpay.android";
+    public static final String BUILD_TYPE = "release";
+}

package/android/src/main/java/mx/openpay/android/DeviceCollectorDefaultImpl.java

@@ -0,0 +1,70 @@
+package mx.openpay.android;
+
+import android.app.Activity;
+import android.util.Log;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import java.util.UUID;
+
+/* loaded from: DeviceCollectorDefaultImpl.class */
+public class DeviceCollectorDefaultImpl {
+    private String baseUrl;
+    private String merchantId;
+    private String errorMessage;
+    private WebView webView;
+
+    public DeviceCollectorDefaultImpl(final String baseUrl, final String merchantId) {
+        this.baseUrl = baseUrl;
+        this.merchantId = merchantId;
+    }
+
+    public String setup(final Activity activity) {
+        try {
+            char[] sessionIdChars = UUID.randomUUID().toString().replace("-", "").toCharArray();
+            sessionIdChars[12] = 'A';
+            String sessionId = String.valueOf(sessionIdChars);
+            Log.i("OpenpaySDK", "buildedDeviceId: " + sessionId);
+            this.webView = new WebView(activity);
+            this.webView.setWebViewClient(new WebViewClient() { // from class: mx.openpay.android.DeviceCollectorDefaultImpl.1
+                @Override // android.webkit.WebViewClient
+                public void onPageFinished(WebView view, String url) {
+                    super.onPageFinished(view, url);
+                    Log.i("OpenpaySDK", "oc loaded");
+                }
+
+                @Override // android.webkit.WebViewClient
+                public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
+                    super.onReceivedError(view, request, error);
+                    Log.i("OpenpaySDK", "page error: " + error.toString());
+                }
+            });
+            WebSettings webSettings = this.webView.getSettings();
+            webSettings.setJavaScriptEnabled(true);
+            String urlAsString = String.format("%s/oa/logo.htm?m=%s&s=%s", this.baseUrl, this.merchantId, sessionId);
+            this.webView.loadUrl(urlAsString);
+            return sessionId;
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+            e.printStackTrace();
+            logError(getClass().getName(), e.getMessage());
+            this.errorMessage = e.getMessage();
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void logError(final String tag, final String content) {
+        if (content.length() > 4000) {
+            Log.e(tag, content.substring(0, 4000));
+            logError(tag, content.substring(4000));
+        } else {
+            Log.e(tag, content);
+        }
+    }
+
+    public String getErrorMessage() {
+        return this.errorMessage;
+    }
+}

package/android/src/main/java/mx/openpay/android/JavaScriptInterface.java

@@ -0,0 +1,19 @@
+package mx.openpay.android;
+
+import android.app.Activity;
+import android.provider.Settings;
+import android.webkit.JavascriptInterface;
+
+/* loaded from: JavaScriptInterface.class */
+public class JavaScriptInterface {
+    private Activity activity;
+
+    JavaScriptInterface(final Activity activity) {
+        this.activity = activity;
+    }
+
+    @JavascriptInterface
+    public String getIdentifierForVendor() {
+        return Settings.Secure.getString(this.activity.getContentResolver(), "android_id");
+    }
+}

package/android/src/main/java/mx/openpay/android/OpCountry.java

@@ -0,0 +1,24 @@
+package mx.openpay.android;
+
+/* loaded from: OpCountry.class */
+public enum OpCountry {
+    MX("https://sandbox-api.openpay.mx", "https://api.openpay.mx"),
+    COL("https://sandbox-api.openpay.co", "https://api.openpay.co"),
+    PE("https://sandbox-api.openpay.pe", "https://api.openpay.pe");
+
+    private final String urlSandbox;
+    private final String urlProduction;
+
+    OpCountry(String urlSandbox, String urlProduction) {
+        this.urlSandbox = urlSandbox;
+        this.urlProduction = urlProduction;
+    }
+
+    protected String getUrlProduction() {
+        return this.urlProduction;
+    }
+
+    protected String getUrlSandbox() {
+        return this.urlSandbox;
+    }
+}

package/android/src/main/java/mx/openpay/android/OpenPayResult.java

@@ -0,0 +1,35 @@
+package mx.openpay.android;
+
+import mx.openpay.android.exceptions.OpenpayServiceException;
+import mx.openpay.android.exceptions.ServiceUnavailableException;
+
+/* loaded from: OpenPayResult.class */
+public class OpenPayResult<T> {
+    private OpenpayServiceException openpayServiceException;
+    private OperationResult<T> operationResult;
+    private ServiceUnavailableException serviceUnavailableException;
+
+    public OpenpayServiceException getOpenpayServiceException() {
+        return this.openpayServiceException;
+    }
+
+    public void setOpenpayServiceException(final OpenpayServiceException openpayServiceException) {
+        this.openpayServiceException = openpayServiceException;
+    }
+
+    public OperationResult<T> getOperationResult() {
+        return this.operationResult;
+    }
+
+    public void setOperationResult(final OperationResult<T> operationResult) {
+        this.operationResult = operationResult;
+    }
+
+    public ServiceUnavailableException getServiceUnavailableException() {
+        return this.serviceUnavailableException;
+    }
+
+    public void setServiceUnavailableException(final ServiceUnavailableException serviceUnavailableException) {
+        this.serviceUnavailableException = serviceUnavailableException;
+    }
+}

package/android/src/main/java/mx/openpay/android/Openpay.java

@@ -0,0 +1,98 @@
+package mx.openpay.android;
+
+// import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Looper;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import mx.openpay.android.exceptions.OpenpayServiceException;
+import mx.openpay.android.exceptions.ServiceUnavailableException;
+import mx.openpay.android.model.Card;
+import mx.openpay.android.model.Token;
+import mx.openpay.android.services.ServicesFactory;
+import mx.openpay.android.services.TokenService;
+
+/* loaded from: Openpay.class */
+public class Openpay {
+    private TokenService tokenService;
+    private DeviceCollectorDefaultImpl deviceCollectorDefaultImpl;
+    private final ExecutorService executor = Executors.newSingleThreadExecutor();
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+
+    public Openpay(final String merchantId, final String apiKey, final Boolean productionMode) {
+        this(merchantId, apiKey, productionMode, OpCountry.MX);
+    }
+
+    public Openpay(final String merchantId, final String apiKey, final Boolean productionMode, final OpCountry opCountry) {
+        String baseUrl = opCountry.getUrlSandbox();
+        baseUrl = productionMode.booleanValue() ? opCountry.getUrlProduction() : baseUrl;
+        ServicesFactory servicesFactory = ServicesFactory.getInstance(baseUrl, merchantId, apiKey);
+        try {
+            this.tokenService = (TokenService) servicesFactory.getService(TokenService.class);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+        this.deviceCollectorDefaultImpl = new DeviceCollectorDefaultImpl(baseUrl, merchantId);
+    }
+
+    public void createToken(final Card card, final OperationCallBack<Token> operationCallBack) {
+    executor.execute(() -> {
+        OpenPayResult<Token> result = new OpenPayResult<>();
+        try {
+            Token newToken = Openpay.this.tokenService.create(card);
+            result.setOperationResult(new OperationResult<>(newToken));
+        } catch (OpenpayServiceException e) {
+            result.setOpenpayServiceException(e);
+        } catch (ServiceUnavailableException e) {
+            result.setServiceUnavailableException(e);
+        }
+
+        // Post result back to the main thread
+        mainHandler.post(() -> {
+            if (result.getOperationResult() != null) {
+                operationCallBack.onSuccess(result.getOperationResult());
+            } else if (result.getOpenpayServiceException() != null) {
+                operationCallBack.onError(result.getOpenpayServiceException());
+            } else if (result.getServiceUnavailableException() != null) {
+                operationCallBack.onCommunicationError(result.getServiceUnavailableException());
+            }
+        });
+    });
+}
+
+    /* JADX WARN: Type inference failed for: r0v0, types: [mx.openpay.android.Openpay$1] */
+    // public void createToken(final Card card, final OperationCallBack<Token> operationCallBack) {
+    //     new AsyncTask<Void, Void, OpenPayResult<Token>>() { // from class: mx.openpay.android.Openpay.1
+    //         /* JADX INFO: Access modifiers changed from: protected */
+    //         @Override // android.os.AsyncTask
+    //         public OpenPayResult<Token> doInBackground(final Void... params) {
+    //             OpenPayResult<Token> openPayResult = new OpenPayResult<>();
+    //             try {
+    //                 Token newToken = Openpay.this.tokenService.create(card);
+    //                 openPayResult.setOperationResult(new OperationResult<>(newToken));
+    //             } catch (OpenpayServiceException e) {
+    //                 openPayResult.setOpenpayServiceException(e);
+    //             } catch (ServiceUnavailableException e2) {
+    //                 openPayResult.setServiceUnavailableException(e2);
+    //             }
+    //             return openPayResult;
+    //         }
+
+    //         /* JADX INFO: Access modifiers changed from: protected */
+    //         @Override // android.os.AsyncTask
+    //         public void onPostExecute(final OpenPayResult<Token> result) {
+    //             if (result.getOperationResult() != null) {
+    //                 operationCallBack.onSuccess(result.getOperationResult());
+    //             } else if (result.getOpenpayServiceException() != null) {
+    //                 operationCallBack.onError(result.getOpenpayServiceException());
+    //             } else if (result.getServiceUnavailableException() != null) {
+    //                 operationCallBack.onCommunicationError(result.getServiceUnavailableException());
+    //             }
+    //         }
+    //     }.execute(new Void[0]);
+    // }
+
+    public DeviceCollectorDefaultImpl getDeviceCollectorDefaultImpl() {
+        return this.deviceCollectorDefaultImpl;
+    }
+}

package/android/src/main/java/mx/openpay/android/OpenpayUrls.java

@@ -0,0 +1,11 @@
+package mx.openpay.android;
+
+/* loaded from: OpenpayUrls.class */
+public class OpenpayUrls {
+    protected static final String MX_URL_SANDBOX = "https://sandbox-api.openpay.mx";
+    protected static final String MX_URL_PRODUCTION = "https://api.openpay.mx";
+    protected static final String COL_URL_SANDBOX = "https://sandbox-api.openpay.co";
+    protected static final String COL_URL_PRODUCTION = "https://api.openpay.co";
+    protected static final String PE_URL_SANDBOX = "https://sandbox-api.openpay.pe";
+    protected static final String PE_URL_PRODUCTION = "https://api.openpay.pe";
+}

package/android/src/main/java/mx/openpay/android/OperationCallBack.java

@@ -0,0 +1,13 @@
+package mx.openpay.android;
+
+import mx.openpay.android.exceptions.OpenpayServiceException;
+import mx.openpay.android.exceptions.ServiceUnavailableException;
+
+/* loaded from: OperationCallBack.class */
+public interface OperationCallBack<T> {
+    void onError(final OpenpayServiceException error);
+
+    void onCommunicationError(final ServiceUnavailableException error);
+
+    void onSuccess(final OperationResult<T> operationResult);
+}

package/android/src/main/java/mx/openpay/android/OperationResult.java

@@ -0,0 +1,14 @@
+package mx.openpay.android;
+
+/* loaded from: OperationResult.class */
+public class OperationResult<T> {
+    private T result;
+
+    public OperationResult(final T result) {
+        this.result = result;
+    }
+
+    public T getResult() {
+        return this.result;
+    }
+}