Initialize the SDK

pod 'PayPalCheckout'

binary "https://github.com/paypal/paypalcheckout-ios/raw/main/Carthage/PayPalCheckout.json"

carthage update --platform iOS

let package = Package(
    name: "MyPackage",
    dependencies: [
        .package(url: "https://github.com/paypal/paypalcheckout-ios.git", from: "x.x.x"),
    ],
    ...
)

func configurePayPalCheckout() {
    let config = CheckoutConfig(
        clientID: "YOUR_CLIENT_ID",
        createOrder: { action in
        let orderRequest = OrderRequest.init(
          intent: .capture,
          purchaseUnits: [
            PurchaseUnit(
                amount: PurchaseUnit.Amount(
                    currencyCode: .usd, value: "10.00"
                    )
                )
          ],
          applicationContext: OrderApplicationContext(userAction: .payNow)
        )
        action.create(order: orderRequest)
        }
      },
        environment: .sandbox
    )
    Checkout.set(config: config)
}

PPCheckoutConfig *config = [
    [PPCheckoutConfig alloc] initWithClientID:'Client-ID';
createOrder:^(PPCCreateOrderAction*action) {
          PPCPurchaseUnitAmount *purchaseUnitAmount = [
            [PPCPurchaseUnitAmount alloc] initWithCurrencyCode:PPCCurrencyCodeUsd
              value:@"5.00"
              breakdown:nil;
              value:@"2.00"
            ]
          ];
PPCPurchaseUnit*purchaseUnit = [
            [PPCPurchaseUnit alloc] initWithAmount:purchaseUnitAmount
            referenceId:nil
            payee:nil
            paymentInstruction:nil
            purchaseUnitDescription:nil
            customId:nil
            invoiceId:nil
            softDescriptor:nil
            items:nil
            shipping:shippingOptions
          ];
          PPCOrderRequest *order = [
            [PPCOrderRequest alloc] initWithIntent:PPCOrderIntentAuthorize
            purchaseUnits:@[purchaseUnit]
            payer:nil
            applicationContext:nil
          ];
          [action createWithOrder:order completion:nil];
        }
    [PPCheckoutConfig environment:PPCEnvironmentSandbox];
    [PPCheckout setConfig:config];
];

import PayPalCheckout
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        configurePayPalCheckout()
        addPayPalButtons()
    }
    // MARK: PayPal Checkout
    private func configurePayPalCheckout() {
        Checkout.setCreateOrderCallback { action in
            let amount = PurchaseUnit.Amount(currencyCode: .usd, value: "10.00")
            let purchaseUnit = PurchaseUnit(amount: amount)
            let order = OrderRequest(intent: .capture, purchaseUnits: [purchaseUnit])
            action.create(order: order)
        }
        Checkout.setOnApproveCallback { approval in
              print("Order ID: (approval.data.orderId)")
            }
        }
    }
    private func addPayPalButtons() {
        let container = PaymentButtonContainer()
        view.addSubview(container)
        NSLayoutConstraint.activate(
            [
                container.centerYAnchor.constraint(equalTo: view.centerYAnchor),
                container.centerXAnchor.constraint(equalTo: view.centerXAnchor)
            ]
        )
    }
}

PPCheckoutConfig *config = [
    [PPCheckoutConfig alloc] initWithClientID:'Client-ID';
createOrder:^(PPCCreateOrderAction*action) {
          PPCPurchaseUnitAmount *purchaseUnitAmount = [
            [PPCPurchaseUnitAmount alloc] initWithCurrencyCode:PPCCurrencyCodeUsd
              value:@"5.00"
              breakdown:nil;
              value:@"2.00"
            ]
          ];
          PPCPurchaseUnit*purchaseUnit = [
            [PPCPurchaseUnit alloc] initWithAmount:purchaseUnitAmount
            referenceId:nil
            payee:nil
            paymentInstruction:nil
            purchaseUnitDescription:nil
            customId:nil
            invoiceId:nil
            softDescriptor:nil
            items:nil
            shipping:shippingOptions
          ];
          PPCOrderRequest *order = [
            [PPCOrderRequest alloc] initWithIntent:PPCOrderIntentAuthorize
            purchaseUnits:@[purchaseUnit]
            payer:nil
            applicationContext:nil
          ];
          [action createWithOrder:order completion:nil];
        }
        onApprove:^(PPCApproval*approval) {
          NSLog(@"Order ID:" %@, approval.data.orderId);
    }
    [PPCheckoutConfig environment:PPCEnvironmentSandbox];
    [PPCheckout setConfig:config];
    // Display the container
[[self view] addSubview: container];
[NSLayoutConstraint activateConstraints: @[
    [[container centerYAnchor] constraintEqualToAnchor: self.view.centerYAnchor],
    [[container centerXAnchor] constraintEqualToAnchor: self.view.centerXAnchor],
]];
];

  <manifest xmlns:android="http://schemas.android.com/apk/res/android">

      <uses-permission android:name="android.permission.INTERNET" />
      ...

  </manifest>

allprojects {
    repositories {
        mavenCentral()
        // This private repository is required to resolve the Cardinal SDK transitive dependency.
        maven {
            url  "https://cardinalcommerceprod.jfrog.io/artifactory/android"
            credentials {
                // Be sure to add these non-sensitive credentials in order to retrieve dependencies from
                // the private repository.
                username "paypal_sgerritz"
                password "REDACTED_SEE_PAYPAL_DOCS"
            }
        }
    }
}

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

dependencies {
    implementation('com.paypal.checkout:android-sdk:X.X.X')
}

class YourApp : Application() {
        override fun onCreate() {
            super.onCreate()
            val config = CheckoutConfig(
                application = this,
                clientId = YOUR_CLIENT_ID,
                environment = Environment.SANDBOX,
                returnUrl = "${BuildConfig.APPLICATION_ID}://paypalpay",
                currencyCode = CurrencyCode.USD,
                userAction = UserAction.PAY_NOW,
                settingsConfig = SettingsConfig(
                    loggingEnabled = true,
                    showWebCheckout = false
                )
            )
            PayPalCheckout.setConfig(config)
        }
      }
    

public class ExApplications extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        PayPalCheckout.setConfig(new CheckoutConfig(
                this,
                YOUR_CLIENT_ID,
                Environment.SANDBOX,
                CurrencyCode.USD,
                UserAction.PAY_NOW,
                PaymentButtonIntent.CAPTURE,
                new SettingsConfig(true, false),
                new UIConfig(true),
                BuildConfig.APPLICATION_ID + "://paypalpay"
));
    }
}
    

<com.paypal.checkout.paymentbutton.PaymentButtonContainer
    android:id="@+id/payment_button_container"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:paypal_button_color="silver"
    app:paypal_button_label="pay"
    app:paypal_button_shape="rectangle"
    app:paypal_button_size="large"
    app:paypal_button_enabled="true" />

class CheckoutActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...
        paymentButtonContainer.setup(
            createOrder =
                CreateOrder { createOrderActions ->
                    val order =
                        OrderRequest(
                            intent = OrderIntent.CAPTURE,
                            appContext = AppContext(userAction = UserAction.PAY_NOW),
                            purchaseUnitList =
                                listOf(
                                    PurchaseUnit(
                                        amount =
                                            Amount(currencyCode = CurrencyCode.USD, value = "10.00")
                                    )
                                )
                        )
                    createOrderActions.create(order)
                },
            onApprove =
                OnApprove { approval ->
                    Log.i(TAG, "OrderId: ${approval.data.orderId}")
                }
        )
    }
}

public class CheckoutActivity extends AppCompatActivity {
    PaymentButtonContainer paymentButtonContainer;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
        paymentButtonContainer.setup(
            createOrderActions -> {
                ArrayList<PurchaseUnit> purchaseUnits = new ArrayList<>();
                purchaseUnits.add(
                    new PurchaseUnit.Builder()
                        .amount(
                            new Amount.Builder()
                                .currencyCode(CurrencyCode.USD)
                                .value("10.00")
                                .build()
                        ).build()
                );
                OrderRequest order = new OrderRequest(
                    OrderIntent.CAPTURE,
                    new AppContext.Builder()
                        .userAction(UserAction.PAY_NOW)
                        .build(),
                    purchaseUnits
                );
                createOrderActions.create(order, (CreateOrderActions.OnOrderCreated) null);
            },
            approval -> {
                Log.i(TAG, "OrderId: " + approval.getData().getOrderId());
            }
        );
    }
}