Alipay+ client SDK interfaces

InitConfig initConfig = new InitConfig();
// for your productron version, please use 'PROD'
initConfig.envType = "DEV";

IAPConnect.init(this, initConfig, new InitCallback() {
            @Override
            public void onSuccess() {
                // to open Alipay+ service center
                // IAPConnect.openACCenter();
            }

            @Override
            public void onFailure(String errorCode, String errorMessage) {
                Toast.makeText(MyApplication.get(),
                    "Initialize error, errorCode: " + errorCode + ", errorMessage: " + errorMessage,
                    Toast.LENGTH_LONG).show();
            }
        });

/**
 * Meta info associated to subclasses of the BaseService class
 */
@ServiceMetaInfo(
        serviceName = "aplus.service.xxx", //xxx = oauth, member, payment
        category = ServiceCategory.ACL,
        type = ServiceType.OAUTH //OAUTH, MEMBER, PAYMENT
)


//Application class for registration

@Override
public void onCreate() {
    super.onCreate();
    //...
    
    //Register an implementation, this is done by the wallet devs
    //This is just to demonstrate that the implementation is initialised and loaded
    WalletServiceManager.getInstance().registerService(MemberServiceProvider.class);
    WalletServiceManager.getInstance().registerService(PaymentServiceProvider.class);
    WalletServiceManager.getInstance().registerService(OAuthServiceProvider.class);
    WalletServiceManager.getInstance().registerService(OpenCapabilityServiceProvider.class);
    WalletServiceManager.getInstance().registerService(CodeServiceProvider.class);
    WalletServiceManager.getInstance().registerService(DeeplinkServiceProvider.class);
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    let config = IAPConnectInitConfig()
    config.envType = "PROD"

    IAPConnectClient.sharedInstance()?.initWithContext(config, success: {
        
    }, failure: { (error, errorMessage) in
        
    })
return true

// WalletAPI initialization
// during application setup 

 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // register the api manager to wallet context
    IAPWalletContextManager.instance.serviceManager = IAPWalletAPIManager()
     
    // This meta info can be loaded in a invisible swift file to load the real data
    let IAPWalletPaymentServiceMetaInfo = IAPWalletBaseServiceProvider(
            type: IAPWalletServiceType(category: .acl, type: "payment"),
            name: NSStringFromClass(PaymentService.self))
        
    let IAPWalletOAuthServiceMetaInfo = IAPWalletBaseServiceProvider(
            type: IAPWalletServiceType(category: .acl, type: "oauth"),
            name: NSStringFromClass(OAuthService.self))
        
    let IAPWalletMemberServiceMetaInfo = IAPWalletBaseServiceProvider(
            type: IAPWalletServiceType(category: .acl, type: "account"),
            name: NSStringFromClass(MemberInfoService.self))
     
    let IAPWalletCodeServiceMetaInfo = IAPWalletBaseServiceProvider(
            type: IAPWalletServiceType(category: .foundation, type: "code"),
            name: NSStringFromClass(CodeService.self))
     
    let IAPWalletDeeplinkServiceMetaInfo = IAPWalletBaseServiceProvider(
            type: IAPWalletServiceType(category: .foundation, type: "deeplink"),
            name: NSStringFromClass(Deeplink.self))
        
    IAPWalletContextManager.instance.serviceManager?.registerServices(metaInfos: [
            IAPWalletPaymentServiceMetaInfo,
            IAPWalletOAuthServiceMetaInfo,
            IAPWalletMemberServiceMetaInfo,
            IAPWalletDeeplinkServiceMetaInfo,
            IAPWalletCodeServiceMetaInfo
        ])
        
    // do rest of the setup for app ...
    return true
}

boolean result = IAPConnect.openACCenter();
if (result) {
	Log.d(TAG, "openACCenter succeeds");
} else {
	Log.e(TAG, "openACCenter fails");
}

   UIViewController *centerVc = [IAPConnect openACCenter];
    if (centerVc) {
        NSLog(@"openACCenter succeeds");
        [self.navigationController pushViewController:centerVc animated:YES];
    }
    else
    {
        NSLog(@"openACCenter fails");
    }

String region = "CN";
IPaymentCodeListener paymentCodeListener = new IPaymentCodeListener() {
    @Override
    public void onPaymentCodeUpdated(String paymentCode) {
        // handle the paymentCode
        // please to render the QR code and bar code in this callback
    }

    @Override
    public void onPaymentCodeUpdateFailed(Result result) {
        //handle the error code and error message
        // Display error information to user or try to refresh the payment code again
        Log.i(TAG, result.resultCode);
    }
};
IAPConnect.getPaymentCode(region, paymentCodeListener);

[IAPConnect getPaymentCode:@"CN" paymentCodeListener:self];
------------
- (void)onPaymentCodeUpdateFailed:(NSString *)resultCode resultMessage:(NSString *)resultMessage{
    //handle the error code and error message
    
}

- (void)onPaymentCodeUpdated:(NSString *)paymentCode{
    // handle the paymentCode
}

// handled by SDK if isAcCode is true
if (isAcCode){
    decode(context, codeValue, acDecodeConfig, new IDecodeCallback(){
        @Override
        public void onResult(Result result){
            Log.i(TAG, result.resultCode);
        }
        
        @Override
        public void showLoading() {
            // some SDK operation is time consuming, here to show loading dialog
            // or the other UI to remind user
        }

        @Override
        public void dismissLoading() {
            // dismiss the dialog or tips UI
        }
    });
} 
// handled by Mobile Payment Partner if isAcCode is false
else {
    
}

IAPConnectDecodeModel *model = [IAPConnectDecodeModel new];
    model.scene = fromScene;
    model.codeValue = codeValue;
    [[IAPConnectClient sharedInstance] decodeWithModel:model
                                        decodeCallback:^(IAPConnectDecodeResult *result) { 
                                          NSLog(@"resultCode:%@===resultMessage:%@",result.resultCode,result.resultMessage);
                                           }];

IAPConnect.clear();

[IAPConnect clear];

QuoteCurrency quoteCurrency = new QuoteCurrency();
quoteCurrency.sellCurrency = "KRW";
quoteCurrency.buyCurrency = "JPY";
IAPConnect.inquireQuote(quoteCurrency, new InquireQuoteCallback() {
    	@Override
		public void onResult(@NonNull String resultCode, @Nullable ForeignExchangeQuote foreignExchangeQuote) {
            if (TextUtils.equals(resultCode, ResultCode.SUCCESS
                                && foreignExchangeRate != null) {
                // get the foreignExchangeQuote to display
            } else {
            	// handle the fail case
                Log.e(TAG, "fail to inquire quote, errorCode: " + resultCode);
            }
        }
});

IAPConnectQuoteCurrency *quoteCurrency = [IAPConnectQuoteCurrency new];
quoteCurrency.sellCurrency = @"KRW";
quoteCurrency.buyCurrency = @"JPY";
    [IAPConnect inquireQuote:quoteCurrency quoteCallback:^(NSString * _Nonnull resultCode, IAPConnectForeignExchangeQuote * _Nonnull result) {
    if (([resultCode isEqualToString:kIAPACSUCCESS])) {
    	// get the foreignExchangeQuote to display
    } else {
    	// handle the fail case
    }
 }];

Uri data = getIntent().getData();
String source = data.getQueryParameter("source");
if ("AlipayConnect".equals(source)) {
    SignContractRequest request = new SignContractRequest();
    request.needCallback = data.getBooleanQueryParameter("needCallback", false);
    String bizContent = data.getQueryParameter("bizContent");
    request.bizContent = bizContent;
    if (TextUtils.isEmpty(bizContent)) {
        request.authUrl = data.toString();
    }
    IAPConnect.signContract(request, result -> {
            if (result.success) {
                Log.i(TAG, "sign contract is success.");
                return;
            }
            if (TextUtils.equals(result.errorCode, ResultCode.USER_CANCEL)) {
                Log.i(TAG, "sign contract is cancelled by user.");
            } else {
                Log.i(TAG, "sign contract is failed, resultMessage: " + result.errorMessage);
            }
        });
} else {
    // it is not the sign contract requirement from Alipay+
}

    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        
        var data : Dictionary<String, String> = [:]
        var needCallback :Bool?
        var bizContent :String?
        var source :String?
        var authUrl :String?
        
        let urlcomp = URLComponents(url: url, resolvingAgainstBaseURL: false)
        if let items = urlcomp?.queryItems {
            for item in items {
                if item.name == "code" {
                    data["code"] = item.value ?? ""
                }
                
                if item.name == "merchantType" {
                    data["merchantType"] = item.value ?? ""
                }
                if item.name == "needCallback" {
                    needCallback = (item.value! as NSString).boolValue
                }
                if item.name == "bizContent" {
                    bizContent = item.value!
                }
                if item.name == "source" {
                    source = item.value!
                }
            }
        }
        NotificationCenter.default.post(name: NSNotification.Name(rawValue: "alipayconnect"), object: data)
        
        if (source == "AlipayConnect") {
            let signContractRequest = IAPGOLSignContractRequest()
            if bizContent?.count ?? 0 > 0 {
                signContractRequest.bizContent = bizContent
            } else {
                signContractRequest.authUrl = url.absoluteString

            }
                  signContractRequest.needCallback = needCallback ?? true
                  IAPGOLSignContract.signContract(signContractRequest) { (result) in
                    if result?.success ?? false {
                        SVProgressHUD.showSuccess(withStatus: "success")
                    } else {
                        SVProgressHUD.showError(withStatus: result?.errorCode)
                    }
            }
        }
        
        return true
    }

/**
 * OAuth, implement the OAuthService class
 * Call the getAuthorizedCodes to check which grant is provided to a clientId, before
 * making requests to the associated services of <? extends BaseService>
 */

import com.alipay.ap.android.wallet.acl.base.Callback;
import com.alipay.ap.android.wallet.acl.oauth.OAuthResult;
import com.alipay.ap.android.wallet.acl.oauth.OAuthService;

import java.util.Set;

/**
 * @since 0.1.1
 */
public class OAuthServiceProvider implements OAuthService {
    
    /**
     * Called to trigger the wallet to start the OAuth process, which will return the Authorisation
     * Code
     *
     * @param clientId clientId
     * @param scopes scopes of the client's request, 
     *          See authorization scopes
     * @param oauthFlowType The type of OAuth flow [Standard, Alipay_connect, local_mini_program]
     * @param extendedInfo Support specific scenario for non-unified scenarios,
     *                     etc Alipay+ has need for clientAuthId
     * @param callback The callback on the result of the user's OAuth approval
     * @since 0.3.0
     */
    void getAuthCode(String clientId, Set<String> scopes, OAuthCodeFlowType oauthFlowType,
                     Map<String, String> extendedInfo, APIContext apContext, Callback<OAuthResult> callback) {
        
        OAuthResult authResult = new OAuthResult();

        //Implement the OAuth flow and retrieve the authToken
        //...

        callback.result(authResult);
    }
    
    /**
     * This method is invoked when some service starts OAuth flow by passing in a agreement url
     * which needs to be rendered and signed by the user
     *
     * @param url The agreement url to open and sign
     * @param oauthFlowType The type of OAuth flow [Standard, Alipay_connect, local_mini_program]
     * @param extendedInfo Support specific scenario for non-unified scenarios,
     *                     etc Alipay+ has need for clientAuthId
     * @param callback The callback on the result of the user's OAuth approval
     * @since 0.3.0
     */
    void getAuthCode(String url, OAuthCodeFlowType oauthFlowType, Map<String, String> extendedInfo
                     , APIContext apContext, Callback<OAuthResult> callback) {
        OAuthResult oAuthResult = new OAuthResult();
        
        //Decodes the URL, and perform OAuth permission grant
        
        callback.result(oAuthResult);
    }
}
    /*
     Possible Auth Scopes: https://globaltech.alipay.com/docs/GPP/wallet-api/wallet-api
     */

final class OAuthService: IAPWalletOAuthServiceSignature {
    
    /*
     Possible Auth Scopes: https://globaltech.alipay.com/docs/GPP/wallet-api/wallet-api
    */
    
    /// This method is invoked when some service starts OAuth process from the wallet
    /// - Parameters:
    ///   - clientId: the cliend Id of the service registered from the
    ///   - scopes: the scopes the client plans to apply
    ///   - type: the type of the authCode grant flow, default as standard the API caller can also specify it as a .alipayConnect specific flow.
    ///   - extendedInfo: Extended info parameters for non standard authflow
    ///   - callback: callback which will be used to inform the service caller about the service result
    override func getAuthCode(clientId: String, 
                              scopes: Set<String>, 
                              type: IAPWalletOAuthCodeFlowType, 
                              extendedInfo: [String: String],
                              in context: IAPWalletAPIContext?,
                              callback: @escaping (IAPWalletOAuthResult) -> Void) {
        // 1. execute auth process
        // type: .standard -> only the clientId is needed to get the authCode.
        // type: .localMiniProgram / .alipayConnect -> need to pass both the clientId as well as the authClientId
        
        // 2. based on auth result, cache current authorized scopes under userId and clientId
        // the scopes are granted via step 1. from the PSP OAuth server
        updateScopes(clientId: "clientId", incrementedScopes: ["BASE_USER_INFO"], decrementedScopes: ["USER_INFO"])
        
        // 3. after the authcode has been retrieved (in an asynchronous loop), trigger the callback
        // ----> async remote call: {
        callback(IAPWalletOAuthResult(authCode: "${server-issued-authCode}",
                                      authState: "${server-issued-authState}",
                                      authErrorScopes: ["USER_INFO": "${failed reasons}"],
                                      authSuccessScopes: ["BASE_USER_INFO"]))
        // ----> async remote call: }

    }
    
    /// This method is invoked when some service starts OAuth flow by passing in a agreement url which needs to be
    /// rendered and signed by the user
    /// - Parameters:
    ///   - url: The aggreement url to open and sign
    ///   - type: the type of the authCode grant flow, default as standard the API caller can also specify it as a .alipayConnect specific flow.
    ///   - extendedInfo: Extended info parameters for non strandard authflow
    ///   - callback: callback which will be user to inform the service caller about the service result
    override func getAuthCode(url: String, 
                              type: IAPWalletOAuthCodeFlowType, 
                              extendedInfo: [String: String], 
                              in context: IAPWalletAPIContext?,
                              callback: @escaping (IAPWalletOAuthResult) -> Void) {
        // 1. open the webview via url, check whether the following params are presented in the url
        // type: .standard -> only the clientId is needed to get the authCode.
        // type: .localMiniProgram / .alipayConnect -> need to pass both the clientId as well as the authClientId
        
        // 2. detect the universal link/redirect link triggered by the webpage
        
        // 3. based on auth result, cache current authorized scopes under userId and clientId
        // the scopes are retrieved from step 2.
        updateScopes(clientId: "clientId", incrementedScopes: ["BASE_USER_INFO"], decrementedScopes: ["USER_INFO"])
        
        // 4. after the authcode has been retrieved (in an asynchronous loop), trigger the callback
        // ----> async remote call: {
        callback(IAPWalletOAuthResult(authCode: "${server-issued-authCode}",
                                      authState: "${server-issued-authState}",
                                      authErrorScopes: ["USER_INFO": "${failed reasons}"],
                                      authSuccessScopes: ["BASE_USER_INFO"]))
        // ----> async remote call: }
    }
    
    // Provide updateScopes for store authScope info at the point when OAuth success, 
    // and getScopes for retrieving previously granted authScopes of the specific user.
    
    func updateScopes(clientId: String, incrementedScopes: [String] = [], decrementedScopes: [String] = []) {
        let userId = "${current-user-id-in-app}"
        let key = String(format: "IAPWalletAuthScope-%@-%@", userId, clientId)
        let raw = UserDefaults.standard.array(forKey: key) as? [String] ?? []
        let currentScopes = Set(raw)
        UserDefaults.standard.set(currentScopes
            .union(incrementedScopes)
            .subtracting(decrementedScopes)
            .sorted(), forKey: key)
    }
    
    func getScopes(clientId: String) -> [String] {
        let userId = "${current-user-id-in-app}"
        let key = String(format: "IAPWalletAuthScope-%@-%@", userId, clientId)
        return UserDefaults.standard.array(forKey: key) as? [String] ?? []
    }
}
 

/**
 * OAuth, implement the OAuthService class
 * Call the getAuthorizedCodes to check which grant is provided to a clientId, before
 * making requests to the associated services of <? extends BaseService>
 */

import com.alipay.ap.android.wallet.acl.base.Callback;
import com.alipay.ap.android.wallet.acl.oauth.OAuthResult;
import com.alipay.ap.android.wallet.acl.oauth.OAuthService;

import java.util.Set;

/**
 * @since 0.1.1
 */
public class OAuthServiceProvider implements OAuthService {
    

    /**
     * This method is invoked when some service starts OAuth flow by passing in a agreement url
     * which needs to be rendered and signed by the user
     *
     * @param clientId the clientId of the app which triggers the authpage
     * @param name the name of the app to be displayed in the auth page
     * @param logo the app's logo, in form of a valid http/https resource 'url' to a logo image
     * @param scopes: the auth scopes the app is applying for, refer to this reference here: https://yuque.antfin-inc.com/imobile-end/tva9vq/tvq2t9
     * @param extendedInfo Support specific scenario for non-unified scenarios,
     *                     etc Alipay+ has need for clientAuthId
     * @param callback The callback on the result of the user's OAuth approval
     * @since 0.3.1
     */
    public void showAuthPage(String clientId, String name, String logo, Set<String> scopes,
                      Map<String, String> extendedInfo, APIContext apContext, Callback<OAuthPageConfirmResult> callback) {
        
        //Generate the OAuth permission page as required.
        //UI design of the page is specific to PSP implementation.
        
        OAuthPageConfirmResult confirmResult = null;
        String referenceAgreementId = ${OAuth service returns a reference approval id}; //optional, can be null
        
        if(${user approved}) {//If success
            confirmResult = new OAuthPageConfirmResult(referenceAgreementId);
        } else { //If fail/error
            confirmResult = new OAuthPageConfirmResult(null);
            //Error handling reference
            //https://yuque.antfin-inc.com/global-integration-technology/hhc5bf/ez52pl#iHVrc
        }
        
        callback.result(confirmResult);
    }
}

 /*
   Possible Auth Scopes: https://globaltech.alipay.com/docs/GPP/wallet-api/wallet-api
 */

import IAPWalletContext

final class OAuthService: IAPWalletOAuthServiceSignature {
    
    /// **Note: ** the following SPIs are not used by Ant SDKs
    /// consultAuthPage(authId: String, extendedInfo: [String : String] = [:], callback: @escaping (IAPWalletOAuthConsultResult) -> Void)
    /// consultAuthPage(clientId: String, scopes: Set<String>, extendedInfo: [String : String] = [:], callback: @escaping (IAPWalletOAuthConsultResult) -> Void)
    
    /// This API is triggered by some of the Ant SDK use cases, like local miniprogram to ask App for displaying an authPage.
    /// - Parameter clientId: the clientId of the app which triggers the authpage
    /// - Parameter name: the name of the app to be displayed in the auth page
    /// - Parameter logo: the app's logo, in form of `url`
    /// - Parameter scopes: the auth scopes the app is applying for, refer to this [link](https://yuque.antfin-inc.com/docs/share/8bfa2603-7d4e-4ef7-b4f3-11565bf763c1?#) for the complete list of scopes.
    /// - Parameter extendedInfo: the extra optional information which the app might require to display on the authPage, refer to this [link]() for complete list of optional params
    /// - Parameter callback: the async callback to inform whether the user abort or confirm the authPage. If error object is not nil in the service result, it means the user reject/aborts the authPage. 
    override func showAuthPage(clientId: String,
                               name: String,
                               logo: String,
                               scopes: Set<String>,
                               extendedInfo: [String : String]? = nil,
                               in context: IAPWalletAPIContext?,
                               callback: @escaping (IAPWalletAuthPageConfirmResult) -> Void) {
        // override the method to provide a authpage confirmation popover
        var scopeInfo = ""
        for scope in scopes {
            if (scope == OAuthService.SCOPE_BASE_USER_INFO) {
                scopeInfo += "- Access basic user information\n"
            } else if (scope == OAuthService.SCOPE_AGREEMENT_PAY) {
                scopeInfo += "- Conduct aggreement pay automatically\n"
            } else if (scope == OAuthService.SCOPE_USER_NAME) {
                scopeInfo += "- Access to user's real name\n"
            } else if (scope == OAuthService.SCOPE_USER_LOGIN_ID) {
                scopeInfo += "- Retrieve user login id in the app.\n"
            } // ... iterate through all possible scopes
        }
        
        let authPage = UIAlertController(title: "Authorisation Confirmation",
                                         message: "\(name) wants to access for the following information: \n\(scopeInfo)" ,
                                         preferredStyle: .alert)
        
        authPage.addAction(UIAlertAction(title: NSLocalizedString("OK", comment: "Default action"),
                                         style: .default,
                                         handler: { _ in
                                            // 1. synchronize with wallet server regarding aggreement check
                                            // ----> async remote call: {
                                                ----- case 1 -----
                                                // 2.1 Option 1: when confirmation is purely checked offline
                                                // then inform the SDK that agreement has ben confirmed
                                                let result = IAPWalletAuthPageConfirmResult()
                                                callback(result)
                                                
                                                ----- case 2 ----- 
                                                // 2.2 Option 2: when confirmation is passed to server for ack
                                                // then inform the SDK with the agreementId from server
                                                let result = IAPWalletAuthPageConfirmResult("${agreementReferenceId}")
                                                callback(result)
                                            // ----> }
        }))
        
        authPage.addAction(UIAlertAction(title: NSLocalizedString("Cancel", comment: "User reject"),
                                         style: .cancel,
                                         handler: { _ in
                                            
                                            // 1. if error is presented, the SDK will assume user abort the operation.
                                            let result = IAPWalletAuthPageConfirmResult()
                                            result.error = NSError(domain: "${psp-wallet-domain}",
                                                                   code: IAPWalletBaseServiceResult.ERROR_CODE_USER_CANCEL, // or any ${psp-wallet-domain-code}
                                                                   userInfo: [NSLocalizedDescriptionKey: "user canceled"])
                                            callback(result)
                                            
        }))
    }
    

    /*
     Possible Auth Scopes: https://globaltech.alipay.com/docs/GPP/wallet-api/wallet-api
     */
}

public class PaymentServiceProvider implements PaymentService {
    
    /**
     * The method that is call for any payment request to bring up e.g. the cashier pay to fulfill
     * payment to the payment requestee
     * @param request The request object
     * @param callback The callback on the payment result, success/failures
     */
    @Override
    public void pay(PaymentRequest request, APIContext apContext, Callback<PaymentResult> callback) {
        PaymentResult paymentResult = new PaymentResult();
        
        //Implement logic to open the cashier page
        // e.g. With Griver, Griver.openUrl(...)
        //...
        
        //To handle callbacks - Griver-H5 typed
        // 1. Consider having a custom JSAPI that is able to passing payment status
        // to the native level, to callback to the Callback<PaymentResult> object
        // 2. Have the JSAPI implement observer pattern, to intercept requests specific
        // to payment result page closure, and register the Callback<PaymentResult> object
        // as an observer to it.
        
        //To handle callbacks - Native/Java typed
        // 1. Consider designing an observer pattern for your native cashier to observe for
        // Cashier result page closure e.g. activity.finish()
        // 2. And register the register the Callback<PaymentResult> object as observer
        
        callback.result(paymentResult);
    }
}

/*
 * Referring to payment codes from:
 * - Miniprogram : https://opendocs.alipay.com/mini/api/openapi-pay
 * provide a superset of the payment codes.
 */
//Payment: ACL standardized Result Codes
public static final String CODE_PENDING = "8000";
public static final String CODE_FAILURE = "4000";
public static final String CODE_SUCCESS = "9000";
public static final String CODE_USER_CANCEL = "6001";

final class PaymentService: IAPWalletPaymentServiceSignature {
    
    /*
      Referring to payment codes from:
        - Alipay+ 2.0 : https://yuque.antfin-inc.com/docs/share/d2577213-2311-45b3-871a-670cceb64fcf?#TMqJ0
      provide a superset of the payment codes. This codes can be consumed by Miniprogram & Alipay+ directly
     */
    public static let CODE_PENDING = "8000" // PAY_PENDING
    public static let CODE_FAILURE = "4000" // PAY_FAILURE
    public static let CODE_SUCCESS = "9000" // PAY_SUCCESS
    public static let CODE_USER_CANCEL = "6001" // USER_CANCEL
    
    override func pay(with request: IAPWalletPaymentRequest, 
                      in context: IAPWalletAPIContext?,
                      callback: (IAPWalletPaymentResult) -> Void) -> Void {
        // Step 1. Check the payment type request parameters, which could be:
        //  - orderId: orderId
        //  - paymentId: paymentId
        //  - cashierUrl: cashier url to be rendered by web cashier
        //  - orderString: a string which contains complete order information. (in mini program case, this payment type is not currently used)
        
        // Step 2. Render cashier and conduct payment process
        
        // Step 3. Invoke callback to inform mini program about the payment result
        // result code please refer to the code const listed above the pay() method.
        // result message there is not strict limitation.
        // ----> async remote call: {
        callback(IAPWalletPaymentResult(resultCode: CODE_SUCCESS, resultMessage: "payment success"))
        // ----> async remote call: }
    }
}

@end

public interface MemberService extends BaseService {

    /**
     * Gets the current member info for this user
     *
     * @param fetchStrategy the strategy used to fetch user info, can be a
     * <br>userId only - {@link com.alipay.iap.android.wallet.acl.member.MemberService.MemberInfoFetchStrategy#LOCAL_USER_ID_ONLY},
     * <br>locally cached full memberInfo - {@link com.alipay.iap.android.wallet.acl.member.MemberService.MemberInfoFetchStrategy#LOCAL_CACHED}, or
     * <br>force to fetch from remote - {@link com.alipay.iap.android.wallet.acl.member.MemberService.MemberInfoFetchStrategy#REMOTE_FETCH}
     * <br><br>Depending on user info sensitivity, you may have to consider also to validate if the
     * related OAuth scope for MemberInfo has been granted via {@link com.alipay.iap.android.wallet.acl.oauth.OAuthService#getAuthorizedScopes(String, Map, APIContext, Callback)},
     * if not, you may have to request {@link com.alipay.iap.android.wallet.acl.oauth.OAuthService#getAuthCode(String, OAuthCodeFlowType, Map, APIContext, Callback)} first
     * @param memberInfoScope the scope of the member information should cover
     * @param apiContext The api context associated with this request {@link com.alipay.iap.android.wallet.acl.base.APIContext} - Optional, set as null if not used
     * @param memberInfoCallback callback returning the MemberInfoResult
     *
     * @version 0.4.1 added APIContext parameter in method signature
     */
    void getMemberInfo(MemberInfoFetchStrategy fetchStrategy, MemberInfoScope memberInfoScope, APIContext apiContext, Callback<MemberInfoResult> memberInfoCallback);

    /**
     * Defines the type of strategy to return the MemberInfo details
     */
    enum MemberInfoFetchStrategy {

        /**
         * Strategy to return only the userId
         * The MemberService.getMemberInfo(), should immediately invoke the callback
         * to simulate a synchronous response
         */
        LOCAL_USER_ID_ONLY,

        /**
         * Strategy to returns the locally cached MemberInfo
         * The MemberService.getMemberInfo(), should immediately invoke the callback
         * to simulate a synchronous response
         */
        LOCAL_CACHED,

        /**
         * Strategy to return the remote up to date MemberInfo
         * The MemberService.getMemberInfo(), this response can be asynchronously responded
         * based on network/remote response.
         */
        REMOTE_FETCH
    }

}

final class MemberInfoService: IAPWalletMemberServiceSignature {
    
    override func getMemberInfo(strategy: IAPWalletMemberInfoFetchStrategy,
                                scope: IAPWalletMemberInfoScope?,
                                in context: IAPWalletAPIContext?,
                                callback: @escaping (IAPWalletMemberInfoFetchResult) -> Void) {
        
        if (strategy == .localCached) {
            
            // return the full amount of userInformation from local cache
            let memberInfo = IAPWalletMemberInfo(
                userId: "${user-id}",
                sessionId: "${session-id}",
                loginId: "${login-id}",
                gender: "m/f",
                avatar: "${avatar-url}",
                userName: "${user-name}")
            memberInfo.extendedInfo = [
                "nickName": "nick name of user",
                "countryCode": "65/86",
                "province": "xxx",
                "province": "xxx",
                                      ]
            // synchronized call
            callback(IAPWalletMemberInfoFetchResult(memberInfo: memberInfo))
            
        } else if (strategy == .localUserIdOnly) {
            
            // return user id only, this strategy is used when some of the SDK's internal logic wants
            // to get a user specified path for data storage
            let memberInfo = IAPWalletMemberInfo(userId: "${user-id}")
            
            // synchronized call
            callback(IAPWalletMemberInfoFetchResult(memberInfo: memberInfo))
            
        }
    }
}

public class CodeServiceProvider implements CodeService {
    @Override
    public void scan(ScannerOption scannerOption, APIContext apContext, Callback<ScannerResult> scannerResultCallback) {
        ScannerResult scannerResult = new ScannerResult("xxxxcodexxxx");
        scannerResult.setExtendedInfo(null);
        scannerResult.getExtendedInfo();
        scannerResultCallback.result(scannerResult);
    }
}

final class CodeService: IAPWalletCodeServiceSignature {
    
    // Mark: this API is currently used by Miniprogram combined with Alipay+ 2.0 case.
    override func scan(with option: IAPWalletScannerOption, 
                       in context: IAPWalletAPIContext?,
                       callback: @escaping (IAPWalletScannerResult) -> Void) {
        // open up your qrcode scanner in your app based on the following option:
        // option.type = .qrCode -> qrcode scanner
        // option.type = .barCode -> barcode scanner
        
        // invoke the callback to passback the result, this can be invoked asynchronously.
        // ----> async remote call: {
        callback(IAPWalletScannerResult(code: "${code extracted}"))
        // ----> async remote call: }
    }
}

public class DeeplinkServiceProvider implements DeeplinkService {
    @Override
    public boolean open(Uri deepLink) {
        
        //Your operation to open this URI
        if(isAuthorised(deepLink)) {
            //Handles the deeplink either natively, or as webview
        } else {
            //Returns false if deeplink is not handled
            return false;
        }
        
        return true;
    }
}

final class DeeplinkService: IAPWalletDeeplinkService {
    
    // Mark: this API is currently used by Miniprogram combined with Alipay+ 2.0 case.
    override func open(scheme: URL,
                       in context: IAPWalletAPIContext?) -> Bool {
        // the wallet app can choose to process the scheme as deeplink,
        // or ordinary url open in webview, the follow is returned synchronously
        if UIApplication.shared.canOpenURL(scheme) {
            if #available(iOS 10.0, *) {
                UIApplication.shared.open(scheme, options: [:], completionHandler: nil)
                return true
            } else {
                UIApplication.shared.openURL(scheme)
                return true
            }
        } else {
            return false
        }
    }
}

public class DeeplinkServiceProvider implements DeeplinkService {

    @Override
    public void open(@NonNull String sceneCode,
                     @NonNull Map<String, String> params,
                     @Nullable APIContext apiContext,
                     @NonNull Callback<BaseResult> openBizSceneCallback) {

        BaseResult baseResult = new BaseResult();
        baseResult.setExtendedInfo(params);
        try {
            // mock handle the navigate scene.
            if (sceneCode.contains("FAILURE")) {
                // mock fail callback
                baseResult.setResultError(new ResultError(
                        ResultError.ERROR_CODE_UNKNOWN_ERROR, "the is mock errorDesc in baseResult."));
            }
        }catch (Exception e) {
            Toast.makeText(MyApplication.get(), "openBizScene exception: " + e, Toast.LENGTH_LONG).show();
        }

        openBizSceneCallback.result(baseResult);
    }
}

final class DeeplinkService: IAPWalletDeeplinkServiceSignature {
    
    // Mark: this API is designed for future AC-Combo use cases. currently not in use. developers may leave it empty.
    override func open(bizSceneCode: String, with params: [String:String], in context: IAPWalletAPIContext? = nil, callback: @escaping (IAPWalletBaseServiceResult) -> Void) {
        
        let result = IAPWalletBaseServiceResult()
        if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_WEB_PAGE) {
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        } else if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_SCAN) {
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        } else if (bizSceneCode == IAPWalletDeeplinkServiceSignature.SCENE_TOP_UP) {
            result.extendedInfo = ["${result-param-1-key}" : "${result-param-1-value}"]
            callback(result)
        }
        
        // implement all the relevant scene codes here.
    }
}