/**
 * Whether to force update when opening the mini program (effective for cold startup). false: Prioritizes using local cache while asynchronously fetching the latest data. true: Opens the mini program only after receiving a network response.
 */
public boolean isForceUpdate = false;
/**
 * Entry address, supports adding parameters: path?key=value&key1=value1
 */
public String entryPath;
/**
 * Receives error messages during the mini program launch process
 */
public ResultReceiver resultReceiver;

/**
 * Mini program launch parameters
 */
public String params;

/**
 * Sets the task mode to be used when opening the mini program
 *
 * false: Multi-task mode; true: Single-task mode
 */
public boolean isSingleTask;

// Open a mini program using the mini program appid
//
TmfMiniSDK.startMiniApp(activity, appId, new MiniStartOptions());

TmfMiniSDK.startMiniApp(activity, appId, miniStartOptions);

TmfMiniSDK.startMiniAppByScan(activity);

<string name="mini_sdk_intent_filter_scheme">your scheme</string>

/**
 * Mini program search
 *
 * @param searchOptions
 * @param callback
 */
public static void searchMiniApp(SearchOptions searchOptions, MiniCallback<List<MiniApp>> callback) 

/**
 * Gets the list of recently accessed mini programs 
 * @param callback 
 */
public static void getRecentList(IRecentMiniCallback callback)

// Implement the MiniAppProxy API
public class YourMiniAppProxyImpl extends BaseMiniAppProxyImpl {
    @Override
    public Locale getLocale() {
        // Return the language you want to set
        return Locale.SIMPLIFIED_CHINESE; // Simplified Chinese
        // or return Locale.US; // English
        // or return new Locale("ar", "SA"); // Arabic
        // or return new Locale("in", "ID"); // Indonesian
        // or return Locale.FRANCE; // French
    }
}

/**
 * User account, must be unique. After setting, data will be stored in isolation based on the account. Typically, use uin or openid
 */
@Override
public String getAccount() {
    return "tmf_test";
}

TmfMiniSDK.stopAllMiniApp(MainActivity.this);

/**
 * Tap event for the capsule button's close option
 * Called in the subprocess.
 *
 * @param miniAppContext Mini program runtime environment (mini program process, not main process)
 * @param onCloseClickedListener Callback when the mini program is closed
 * @return - Returns false if this API is not supported
 */
public abstract boolean onCapsuleButtonCloseClick(IMiniAppContext miniAppContext,
        DialogInterface.OnClickListener onCloseClickedListener);

/**
 * Tap event for the More options on the capsule button
 *
 * @param miniAppContext Mini program runtime environment
 * @return - Returns false if this API is not supported
 */
public abstract boolean onCapsuleButtonMoreClick(IMiniAppContext miniAppContext);

/**
 * Returns the buttons for the capsule's More panel. The IDs for extension buttons must be set within the range of [100, 200]; otherwise, the addition will be invalid.
 * Calling environment: Subprocess
 *
 * @param builder
 * @return
 */
public abstract ArrayList<MoreItem> getMoreItems(MoreItemList.Builder builder);


@Override
public ArrayList<MoreItem> getMoreItems(IMiniAppContext miniAppContext, MoreItemList.Builder builder) {
    MoreItem item1 = new MoreItem();
    // Set the menu ID (required), the ID for extension buttons must be within the range of [100, 200]; otherwise, the addition will be invalid.
    item1.id = ShareProxyImpl.OTHER_MORE_ITEM_1;
    // Set the menu title (optional)
    item1.text = getString(miniAppContext, R.string.applet_mini_proxy_impl_other1);
    // Set the menu icon (optional)
    item1.drawable = R.mipmap.mini_demo_about;
    // Set the visual accessibility description (optional). Defaults to the menu title.
    item2.contentDescription = "Visual accessibility description for the menu";
    // Listen for tap events
    item2.onClickListener = new MoreItem.MoreItemClickListener() {
        @Override
        public void onClick(IMiniAppContext context, MoreItem item) {
            // Handle tap event
        }
    };

    // Adjust the order as needed
    builder.addMoreItem(item1)
            // Add built-in menu items as needed
            .addRestart(getString(miniAppContext, R.string.applet_mini_proxy_impl_restart),
                    R.mipmap.mini_demo_restart_miniapp)
            // Add built-in menu items as needed
            .addAbout(getString(miniAppContext, R.string.applet_mini_proxy_impl_about),
                    R.mipmap.mini_demo_about)
            // Add built-in menu items as needed
            .addSetting(getString(miniAppContext, R.string.mini_sdk_more_item_setting_0),
                    R.drawable.mini_sdk_setting,
                    // Set the visual accessibility description (optional). Defaults to the menu title.
                    "Mini program settings");
    return builder.build();
}

private String getString(IMiniAppContext miniAppContext, int id) {
    return miniAppContext.getContext().getString(id);
}

public abstract class LogProxy {

    /**
     * Log printing
     *
     @param logLevel Log print level
     * @param tag log tag
     * @param msg Print message
     * @param t Exception
     */
    abstract public void log(int logLevel, String tag, String msg, Throwable t);

    /**
     * Whether to use colored output, used to control log display.
     */
    abstract public boolean isColorLevel();
}

public interface IDarkModeProxy {
    boolean isDarkMode();
}

@JsPlugin(secondary = true)
public class CustomPlugin extends BaseJsPlugin {

    @JsEvent("testSync")
    public String custom1(final RequestEvent req) {
        // Get the parameters
        //req.jsonParams
        // Return the data synchronously
        JSONObject jsonObject = new JSONObject();
        try {
            jsonObject.put("key", "value");
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
        return req.okSync(jsonObject);
    }

    @JsEvent("testAsync")
    public void getAppBaseInfo(final RequestEvent req) {
        // Get the parameters
        //req.jsonParams
        // Return the data asynchronously
        //req.fail();
        //req.ok();
        JSONObject jsonObject = new JSONObject();
        try {
            jsonObject.put("key", "test");
        } catch (JSONException e) {
            e.printStackTrace();
        }
        req.ok(jsonObject);
    }
}

// Asynchronous API call
var opts = {
   api_name: 'testAsync',
   success: function(res) {},
   fail: function(res) {},
   complete: function(res) {},
   data: { // Input parameters
      name: 'kka',
      Age 22
   }
 }
 wx.invokeNativePlugin(opts); 

// Synchronous API call
var opts = {
   api_name: 'testSync',
   sync:true
}
var rst = wx.invokeNativePlugin(opts);

@ProxyService(proxy = ExternalElementProxy.class)
public class MyExternalElementProxy extends ExternalElementProxy{}

/**
 * Sends the onExternalElementEvent event to the mini program
 *
 * @param jsonObject JSON data carried with the event
 */
public final void onExternalElementEvent(JSONObject jsonObject);

/**
 * Calls the success callback method provided by the  mini program
 *
 * @param jsonObject JSON data for the callback, can be null
 */
public final void callbackSuccess(JSONObject jsonObject);

/**
 * Calls the fail callback method provided by the mini program
 *
 * @param jsonObject JSON data for the callback, can be null
 /// @param message Error message
 */
public final void callbackFail(JSONObject jsonObject, String message);

<external-element
    id="comp1"
    type="maTestView"
    _insert2WebLayer="true"
    style="width: 200px;height: 100px;"
    bindexternalelementevent="handleEvent"
></external-element>

{
    target,
    currentTarget,
    timeStamp,
    touches,
    detail, // parameters passed from native
}

this.ctx = wx.createExternalElementContext('comp1');

this.ctx.call({
  params1: {
    name: 'name1',
    age: 11
  },
  params2: {
    name: 'name2',
    age: 22
  },
  success: (e) => {
    console.log('====operate success=====', e)
  },
  fail: (e) => {
    console.log('====operate fail=====', e)
  },
  complete: (e) => {
    console.log('====operate complete=====', e)
  }
})