JsView

# SDK java 文档

以下介绍些常用的接口

# MainPageProxy.java

# onCreate

接口声明：

/**
* 用于处理{@link Activity#onCreate(Bundle)}事件。
* 当{@link Activity#getIntent()}中有URL参数时会去自动加载这个链接。
* @param savedInstanceState
* @param rootView 用于显示小程序的容器，如果是{@code null}则会直接调用{@link Activity#setContentView(int)}
*/
public void onCreate(Bundle savedInstanceState,ViewGroup rootView);
public void onCreate(Bundle savedInstanceState){
    onCreate(savedInstanceState, (ViewGroup) null);
}
1
2
3
4
5
6
7
8
9
10

# onNewIntent

接口声明：

/**
* 用于处理{@link Activity#onNewIntent(Intent)} ,当启动URL与上次相同时，将会直接忽略
* @param intent 小程序启动参数
*/
public void onNewIntent(Intent intent);
1
2
3
4
5

# onResume

接口声明：

/**
* 处理{@link Activity#onResume()}事件
*/
public void onResume();
1
2
3
4

# onPause

接口声明：

/**
* 处理{@link Activity#onPause()}事件
*/
public void onPause();
1
2
3
4

# onDestroy

接口声明：

/**
* 处理{@link Activity#onDestroy()} ()}事件
*/
public void onDestroy();
1
2
3
4

# reload

接口声明：

/**
* 清空当前的所有小程序，重新去加载最后一次通过MainPageProxy启动的小程序
*/
public void reload();
1
2
3
4

# loadIntent

接口声明：

/**
* 清除当前所有的小程序然后加载Intent里的参数
* @param intent 小程序启动参数
*/
public void loadIntent(Intent intent);
1
2
3
4
5

# setMiniAppObserver

接口声明：

/**
* 监听小程序的启动状态
* @param miniAppObserver 监听接口
*/
public void setMiniAppObserver(MiniAppObserver miniAppObserver);
1
2
3
4
5

MiniAppObserver

# addJavascriptInterface

接口声明：

/**
* 添加供JS调用的接口
* @param bridge 接口对象
* @param name 接口名
*/
public synchronized void addJavascriptInterface(Object bridge,String name);
1
2
3
4
5
6

# setEnableStartUpRender

接口声明：

/**
* 设置启动图渲染开关,默认打开
* @param enableStartUpRender 是否允许sdk去渲染启动图与动画
*/
public void setEnableStartUpRender(boolean enableStartUpRender);
1
2
3
4
5

# getJSViewParent

接口声明：

/**
* 获取小程序容器,调用{@link #onCreate(Bundle, ViewGroup)} 之后才能获取到。
* @return 小程序容器
*/
public JSViewParent getJSViewParent();
1
2
3
4
5

# setJSViewExceptionReporter

接口声明：

/**
 * 设置监听 JSView 运行异常的回调
 * @param onJSViewRuntimeException JSView运行时异常回调
 */
public void setJSViewExceptionReporter(OnJSViewRuntimeException onJSViewRuntimeException) ;
1
2
3
4
5

OnJSViewRuntimeException 接口：

public interface OnJSViewRuntimeException {
    /**
     * JS 小程序异常回调
     * @param jsViewItem 发生异常的 jsview
     * @param bundle 异常信息
     * Bundle格式
     * { name(String):
     *   message(String):
     *   stack(String):
     * }
     * 例如: [{name=ReferenceError,
     *    stack=ReferenceError: a is not defined
     *      at <anonymous>:1:1
     *      at idle (file:///data/data/xxxxxx/jsview.index.bundle.js:1:4213),
     *      message=a is not defined}]
     */
    void onJsException(JSViewItem jsViewItem,Bundle bundle);

    /**
     * JSView内核异常回调
     * @param jsViewItem 发生异常的 jsview
     * @param bundle 异常信息
     * Bundle格式
     * { name(String):
     *   message(String):
     *   stack(String):
     * }
     * 例如: [{name=DownloadManager,
     *    stack=java.lang.RuntimeException: TestException
     *        at com.qcode.enhance.Download.DownloadManager.<init>(DownloadManager.java:127)
     *        at com.qcode.enhance.Download.DownloadManager.getInstance(DownloadManager.java:52)
     *        at com.qcode.enhance.Download.DownloadManagerProxy.<init>(DownloadManagerProxy.java:48)
     *      message=TestDebugReport}]
     */
    void onCoreFatalException(JSViewItem jsViewItem,Bundle bundle);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# JSViewParent.java

# registerMiniAppObserver

接口声明：

/**
* 注册小程序启动状态监听
* @param miniAppObserver 监听接口
*/
public void registerMiniAppObserver(MiniAppObserver miniAppObserver);
1
2
3
4
5

MiniAppObserver

# unregisterMiniAppObserver

接口声明：

/**
* 取消注册小程序启动状态监听
* @param miniAppObserver 监听接口
*/
public void unregisterMiniAppObserver(MiniAppObserver miniAppObserver);
1
2
3
4
5

# registerMiniAppLifecycleCallback

接口声明：

/**
* 注册小程序生命周期监听
* @param miniAppLifecycleCallback 监听接口
*/
public void registerMiniAppLifecycleCallback(MiniAppLifecycleCallback miniAppLifecycleCallback);
1
2
3
4
5

MiniAppLifecycleCallback

# unregisterMiniAppLifecycleCallback

接口声明：

/**
* 取消注册小程序生命周期监听
* @param miniAppLifecycleCallback 监听接口
*/
public void unregisterMiniAppLifecycleCallback(MiniAppLifecycleCallback miniAppLifecycleCallback);
1
2
3
4
5

# addJavascriptInterface

接口声明：

/**
* 添加供JS调用的接口
* @param bridge 接口对象
* @param name 接口名
*/
public void addJavascriptInterface(Object bridge,String name);
1
2
3
4
5
6

# getTopJSView

接口声明：

/**
* 获取当前显示的小程序
* @return 小程序显示载体
*/
public JSViewItem getTopJSView();
1
2
3
4
5

# setMiniAppTimeout

接口声明：

/**
 * 设置小程序加载超时的超时时间
 * @param miniAppTimeout 超时时间，单位毫秒
 */
public void setMiniAppTimeout(int miniAppTimeout) {
    this.mMiniAppTimeout = miniAppTimeout;
}
1
2
3
4
5
6
7

# MiniApp.java

# getJsView

接口声明：

/**
* 获取jsview对象的引用
* @return jsview对象的引用,有可能是{@code null}
* */
public JsView getJsView();
1
2
3
4
5

# addJavascriptInterface

接口声明：

/**
* 添加供JS调用的接口。
* 如果小程序已经加载了，则不会有效果，建议在 onAppCreate 时去调用。
* @param bridge 接口对象
* @param name 接口名
*/
public void addJavascriptInterface(Object bridge,String name);
1
2
3
4
5
6
7

# finish

接口声明：

/**
* 关闭小程序
* */
public void finish();
1
2
3
4

# reload

接口声明：

/**
* 重新加载小程序
* */
public void reload();
1
2
3
4

# getAppInfo

/**
* 获取小程序的信息
* @return 小程序信息，小程序信息，在MiniApp的loadSuccess回调后可用，否则为{@code null}
* */
public MiniAppInfo getAppInfo();
1
2
3
4
5

# getParams

/**
* 获取小程序的启动参数
* */
public MiniAppParams getParams();
1
2
3
4

# MiniAppInfo.java

小程序信息实体类 接口声明：

/**
* 可认为是小程序的包名
* */
public String getAppName();

/**
* 小程序名称
* */
public String getAppTitle();

/**
* 小程序版本
* */
public String getAppVersion();

/**
* 小程序图标
* */
public String getAppIcon();

/**
* 小程序签名
* */
public ArrayList<String> getAppSignature()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# MiniAppParams.java

小程序启动参数实体类

接口声明：

/**
* 获取小程序的加载链接
* 一般传给{@link com.qcode.jsview.JsView#loadUrl2(String, String)}
* @return  符合 uri 格式的小程序链接
* */
public String getUrl();

/**
* 获取小程序内核版本
* */
public String getCoreVersionRange();

/**
* 获取小程序引擎地址
* */
public String getEngineUrl();

/**
* 获取启动图链接
* @return 启动图的链接
*/
public String getStartupImage();

/**
* 与启动图参数冲突，不能同时存在
* @return 启动视频的链接
*/
public String getStartupVideo();

/**
* 获取设置启动倒计时，单位秒
* @return 启动倒计时
*/
public int getStartupDuration();

/**
*
* @return 小程序启动后是否会添加到历史记录，默认 true
*/
public boolean isAddToHistory();

/**
*
* @return 是否开启抗锯齿，默认 false
*/
public boolean isEnableAntiAliasing();

/**
* 获取启动模式,需要搭配{@link #getAppName()} 使用
* @return 启动模式
*                 <p>{@link #LAUNCHER_MODE_ADD} 新启动一个小程序(默认)，
*                 <p>{@link #LAUNCHER_MODE_RESUME}从已经启动的小程序中查找,如果存在就将这个小程序放到前台显示，否则新启动一个小程序。
*/
public int getLaunchMode();

/**
* 获取小程序的唯一标识，类似包名,这里是外面传进来的数值，不能当成真正的AppName使用
* @return 小程序的唯一标识
*/
public String getAppName();

/**
* 获取小程序显示模式
* @return  {@link com.tvcode.js_view_app.JSViewApp#CANVAS_VIEW_MODE_DEFAULT} 表示使用默认方式（{@link android.view.SurfaceView}）来渲染小程序。
*          {@link com.tvcode.js_view_app.JSViewApp#CANVAS_VIEW_MODE_TEXTURE} 表示使用{@link android.view.TextureView}来渲染小程序。
*/
public int getCanvasViewMode();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# MiniAppObserver.java

接口声明：

public interface MiniAppObserver {
    int ERROR_CODE_APP_FAIL = -1;
    int ERROR_CODE_CORE_LOAD_FAIL = -2;
    int ERROR_CODE_GET_URL_ERROR = -3;
    int ERROR_CODE_CORE_VERSION_MISMATCH = -4;
    int ERROR_CODE_SYSTEM_JS_LOAD_TIMEOUT = -5;
    int ERROR_CODE_ENGINE_JS_DOWNLOAD_TIMEOUT = -6;
    int ERROR_CODE_ENGINE_JS_LOAD_TIMEOUT = -7;
    int ERROR_CODE_MAIN_JS_DOWNLOAD_TIMEOUT = -8;
    int ERROR_CODE_MAIN_JS_LOAD_TIMEOUT = -9;
    int ERROR_CODE_APP_START_FAIL = -10;
    int ERROR_CODE_APP_START_TIMEOUT = -11;
    /**
     * 小程序开始加载, 传入URL时被回调(从js端发起的openWindow开启的同Core的JsView也会触发此回调)
     * @param miniApp 小程序的实体类
     * */
    void onMiniAppStartLoad(MiniApp miniApp);

    /**
     * 小程序加载的进度回调
     * @param miniApp 小程序的实体类
     * @param progress 加载进度，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_NONE}：初始状态，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_SYSTEM_JS_LOADED}：系统js加载完成，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_ENGINE_JS_DOWNLOADED}：Engine Js 下载完成，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_ENGINE_JS_LOADED}：Engine Js 加载完成，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_MAIN_JS_DOWNLOADED}：Main Js 下载完成，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_MAIN_JS_LOADED}：Main Js 加载完成，</br>
     *                 {@link com.tvcode.js_view_app.view.JSViewItem#LOAD_STATE_APP_JS_START}：开始运行框架的主入口处理，</br>
     */
    void onMiniAppLoadProgress(MiniApp miniApp,int progress);

    /**
     * 小程序加载成功，对应js端小程序调用notifyPageLoaded时机
     * @param miniApp 小程序的实体类
     * */
    void onMiniAppLoadSuccess(MiniApp miniApp);

    /**
     * 小程序加载失败，对应内核加载失败或者小程序js加载超时的时机
     * @param miniApp 小程序的实体类
     * @param errorCode {@link MiniAppObserver#ERROR_CODE_APP_FAIL}：小程序加载失败，
     *                  {@link MiniAppObserver#ERROR_CODE_CORE_LOAD_FAIL}：内核加载失败，
     *                  {@link MiniAppObserver#ERROR_CODE_GET_URL_ERROR}：网络错误，
     *                  {@link MiniAppObserver#ERROR_CODE_CORE_VERSION_MISMATCH}：core版本与当前已经加载的core对不上
     *                  {@link MiniAppObserver#ERROR_CODE_SYSTEM_JS_LOAD_TIMEOUT}：系统js下载超时
     *                  {@link MiniAppObserver#ERROR_CODE_ENGINE_JS_DOWNLOAD_TIMEOUT}：engineJs下载超时
     *                  {@link MiniAppObserver#ERROR_CODE_ENGINE_JS_LOAD_TIMEOUT}：engineJs加载超时
     *                  {@link MiniAppObserver#ERROR_CODE_MAIN_JS_DOWNLOAD_TIMEOUT}：mainJs下载超时
     *                  {@link MiniAppObserver#ERROR_CODE_MAIN_JS_LOAD_TIMEOUT}：mainJs加载超时
     *                  {@link MiniAppObserver#ERROR_CODE_APP_START_FAIL}：运行框架的主入口失败
     *                  {@link MiniAppObserver#ERROR_CODE_APP_START_TIMEOUT}：mainJs启动超时
     * */
    void onMiniAppLoadFail(MiniApp miniApp,int errorCode);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# MiniAppLifecycleCallback.java

接口声明：

/**
 * 小程序生命周期回调接口
 * */
public interface MiniAppLifecycleCallback {
    /**
    * 小程序创建
    * */
    void onAppCreate(MiniApp app);
    /**
     * 小程序到前台显示
     * */
    void onAppStart(MiniApp app);
    /**
     * 小程序获得焦点
     * */
    default void onAppResume(MiniApp app){}
    /**
     * 小程序失去焦点
     * */
    default void onAppPause(MiniApp app){}
    /**
     * 小程序退到后台
     * */
    void onAppStop(MiniApp app);
    /**
     * 小程序销毁
     * */
    void onAppRelease(MiniApp app);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# JSViewCoreManager.java

管理core加载的类，单例模式，使用JSViewCoreManager.getInstance()获取对象。

小程序支持单进程多内核模式，每当本进程此内核首次加载时，其CoreLoading状态都会回调。

内核加载场景可分为:

# 内核已经下载过：
onCoreStartLoad 被回调后，回调会跳过 onProgress 步骤，直接进入 onCoreReady 

# 内核未下载过:
onCoreStartLoad 被回调后，经过onProgress回调(内核下载)完毕后，进入 onCoreReady

# 新内核不能本进程运行:
需要留意的是，不是所有版本的内核都适合加在到同一个进程中，当大版本变更(主要是版本号前3位，
例如102)时，不同两个大版本的内核由于技术限制，还无法做到单进程并存，当出现内核不能同进程
并存的场景。 onCoreReady 回调时， suggest 内容会为 
JsView.JsViewReadyCallback#SUGGEST_NEW_PROCESS，
此时建议操作为：将所有启动参数(URL, CoreVersionRange, Engine)打包成intent，
启动另一个进程的内含MainPageProxy的Activity来承接此小程序启动。

PS: 新的进程启动时，由于内核已经在上一个进程中下载完毕，所以新进程一般会很快进入 onCoreReady 状态

# registerCoreLoadingStateListener

接口声明：

/**
* 注册core加载状态的监听
* @param listener 监听接口
*/
public void registerCoreLoadingStateListener(CoreLoadingStateListener listener);
1
2
3
4
5

# unregisterCoreLoadingStateListener

接口声明：

/**
* 取消注册core加载状态的监听
* @param listener 监听接口
*/
1
2
3
4

# 内部接口CoreLoadingStateListener

接口声明：

public interface CoreLoadingStateListener {
    /**
     * 开始加载core的回调
     * @param coreVersion core版本
     */
    void onCoreStartLoad(String coreVersion);

    /**
     * core加载完成的回调
     * @param coreVersion core版本
     * @param coreStatus core版本的完成状态 :
     *                              {@link JsView.JsViewReadyCallback#CORE_NO_READY}
     *                              {@link JsView.JsViewReadyCallback#CORE_SYNCED}
     *                              {@link JsView.JsViewReadyCallback#CORE_DEX_LOADED}
     *                              {@link JsView.JsViewReadyCallback#CORE_SO_LOADED}
     * @param suggest 建议操作：
     *                {@link JsView.JsViewReadyCallback#SUGGEST_NOTHING}
     *                {@link JsView.JsViewReadyCallback#SUGGEST_NEW_PROCESS}
     */
    void onCoreReady(String coreVersion,int coreStatus,int suggest);

    /**
     * 加载进度的回调
     * @param coreVersion core版本
     * @param maxSteps 步骤总数
     * @param currentStep 当前的步骤
     * @param downloadTotal 若该步骤有下载动作，为下载的总字节数，否则为0
     * @param downloaded 若该步骤有下载，为当前的下载字节数，否则为0
     * @param info
     */
    void onProgress(String coreVersion,int maxSteps, // 步骤总数
                    int currentStep, // 当前的步骤
                    int downloadTotal, // 若该步骤有下载动作，为下载的总字节数，否则为0
                    int downloaded,    // 若该步骤有下载，为当前的下载字节数，否则为0
                    String info);

    /**
     * core加载失败的回调
     * @param coreVersion core版本
     * @param info 失败信息
     */
    void onCoreFail(String coreVersion,String info);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# isCoreReady

/**
 * 查看core加载是否完成
 * @param context 应用上下文
 * @param coreVersion core 版本
 * @return core是否加载完成
 */
public boolean isCoreReady(Context context,String coreVersion);
1
2
3
4
5
6
7

# isCoreDownloaded

/**
 * 查看core下载是否完成
 * @param context 应用上下文
 * @param coreVersion core 版本
 * @return core 是否下载完成
 */
public boolean isCoreDownloaded(Context context,String coreVersion);
1
2
3
4
5
6
7

# isCoreLoading

/**
 * 查看core是否正在加载
 * @param coreVersion core版本
 * @return core是否正在加载
 */
public boolean isCoreLoading(String coreVersion);
1
2
3
4
5
6

# setDebugPort

/**
 * 设置 dev tool 的调试端口
 * @param debugPort 端口
 */
public void setDebugPort(int debugPort);
1
2
3
4
5
Last Updated: 4/19/2024, 8:40:44 AM

← JSView 小程序本地化 →