public static OcrOverseasCloudKit getInstance()

public void init(Context context)

public void updateConfig(OcrSDKConfig config)

public void startCloudOcr(Activity activity,
                          OcrCloudConfig config,
                          IOcrCloudResultListener listener)

public void release()

public String getCurrentToken()

public String createMetaData()

public String getVersion()

public void setCloudEventListener(IOcrCloudEventListener listener)

/**
 * Event callback interface for the public cloud OCR capture process
 */
public interface IOcrCloudEventListener {

    /**
     * Callback for when the main View for OCR recognition is created
     *
     * @param mainView The main View
     */
    void onMainViewCreate(View mainView);

    /**
     * Callback for when the page is recycled
     */
    void onMainViewDestroy();

    /**
     * Pass through additional parameters
     *
     * @param map Parameters to pass through
     */
    void onEventParamMap(HashMap<String, Object> map);
}

/**
 * Callback interface for public cloud OCR recognition results
 */
public interface IOcrCloudResultListener {

    /**
     * Success callback for recognition
     *
     * @param result The success result, which contains the sdkToken and status.
     */
    void onSuccess(OcrCloudResult result);

    /**
     * Failure callback for recognition
     *
     * @param error The failure result, which contains the sdkToken, error code (int), and error message.
     */
    void onFailed(OcrCloudError error);
}

sequenceDiagram
    participant App as Business App
    participant Backend as Business Backend
    participant SDK as OcrOverseasCloudKit
    participant Cloud as OCR Cloud

    App->>SDK: getInstance().init(context)
    App->>SDK: Calls createMetaData() to obtain metadata.
    SDK-->>App: Returns the metaData.
    App->>Backend: Uploads metaData and requests sdkToken / serverParamInfo.
    Backend-->>App: Delivers sdkToken + serverParamInfo.
    App->>SDK: startCloudOcr(activity, OcrCloudConfig, listener)
    SDK->>SDK: Decrypts serverParamInfo and determines single-sided or double-sided capture.
    SDK->>SDK: Starts camera capture and obtains the optimal jpg frame.
    SDK->>Cloud: POSTs the optimal OCR frame for recognition.
    Cloud-->>SDK: Sends the recognition completion response.
    SDK-->>App: onSuccess(OcrCloudResult{status=SUCCESS, sdkToken})
    App->>Backend: Pulls structured recognition results using sdkToken.

// Step 1: Initialize in the onCreate method of the Application or business page (only once).
OcrOverseasCloudKit.getInstance().init(getApplicationContext());

// Step 2: Before requesting the sdkToken or serverParamInfo from the business backend,
// First, use createMetaData() to synchronously collect device and application metadata (encrypted inside the SDK), and submit it together with the application request.
// This field remains consistent with the server-side protocol so that the backend can pass it through when calling the cloud CreateOCRToken API for risk control and parameter validation.
String metaData = OcrOverseasCloudKit.getInstance().createMetaData();
// TODO: Submit metaData as a request parameter (for example, with the field name metaData) to the business backend. For more information, see app-public.
//       Implementation of TokenApiHelper#applyToken: body.put("metaData", OcrOverseasCloudKit.getInstance().createMetaData())

// Step 3: Obtain the sdkToken / serverParamInfo from the business backend.
String sdkToken = "...";          // Issued by the business backend.
String serverParamInfo = "...";   // Issued by the business backend as an encrypted string.

// Step 4: Construct the startup configuration.
OcrCloudConfig config = new OcrCloudConfig();
config.setSdkToken(sdkToken);
config.setServerParamInfo(serverParamInfo);
config.setLanguageStyle(LanguageStyle.SIMPLIFIED_CHINESE);
config.setShowPrivacyPolicyDialog(true);
// Optional: Customize the UI.
CustomConfigUi customConfigUi = new CustomConfigUi();
customConfigUi.setShowTitleBar(true);
customConfigUi.setTitleBarText("ID Card Recognition");
config.setCustomConfigUi(customConfigUi);

// Optional: Register a capture event listener.
OcrOverseasCloudKit.getInstance().setCloudEventListener(new IOcrCloudEventListener() {
    @Override
    public void onMainViewCreate(View mainView) {
        // The main View is created. You can add custom views here.
    }

    @Override
    public void onMainViewDestroy() {
        // The main View is destroyed.
    }

    @Override
    public void onEventParamMap(HashMap<String, Object> map) {
        // Pass through parameters
    }
});

// Step 5: Start recognition.
OcrOverseasCloudKit.getInstance().startCloudOcr(activity, config,
        new IOcrCloudResultListener() {
            @Override
            public void onSuccess(OcrCloudResult result) {
                // Recognition is complete. The business party can use result.getSdkToken() to pull structured results on the server.
                if (result.getStatus() == OcrCloudStatus.SUCCESS) {
                    String token = result.getSdkToken();
                    // TODO: Notify the business backend to pull the recognition result.
                }
            }

            @Override
            public void onFailed(OcrCloudError error) {
                // Error handling: error.getErrorCode() / error.getErrorMsg()
            }
        });

// Step 5: Release resources at an appropriate time (for example, in the onDestroy method of the business page).
OcrOverseasCloudKit.getInstance().release();