可以在gradle.properties添加属性，指定R8是否启用

android.enableR8=true ；// true 启用R8

有时候上述配置并不一定生效，在编译时有可能还是使用Proguard，这时候可以在App 的build.gradle中配置useProguard false，强制关闭Proguard而启用R8

android {
    buildTypes {
        release {
            minifyEnabled true
            useProguard false  //强制关闭Proguard而启用R8，这时将忽略gradle.properties里关于android.enableR8的设置
            }
        }
}

adb usb ==== 重启 adb的 usb连接
adb shell pm list packages   ==== 列举所有应用包名
adb shell am monitor  ==== 监控手机上的应用启动
adb shell pm uninstall -k  --user 0 包名  ==== 删除包（屏蔽包）

对于Native WebView而言，Andoird/iOS都提供相应的方法/代理监听页面URL的变化。例如，Android可以重写doUpdateVisitedHistory方法监听URL变化，iOS可以实现shouldStartLoadWithRequest、decidePolicyForNavigationAction代理监听URL变化

@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
  //此处检测url是否有变化
  return super.shouldOverrideUrlLoading(view, url);
}

//UIWebView
- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType
{
    //此处检测url是否有变化
    return YES;
}

//WKWebView
- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler
{
    //此处检测url是否有变化
    decisionHandler(WKNavigationActionPolicyAllow);
}

上述技术实现对一些前端应用能正常工作。然而，遇到单页应用（SPA）时，以上方法并不会被触发--这里涉及单页应用的实现原理，尤其是基于 hash路由的单页应用，其前进/后退的问题更为突出。

解决思路

对于前端应用而言，如果开发者使用固定的框架，那么在框架的路由层面拦截监听应较为容易做到。但是实际情况是开发者使用的前端框架不确定，甚至开发者连前端框架都不用，所以我们在前端框架层面截获路由器变得不那么容易。

经过调研，要监听前端页面的URL变化，大致有两种模式：

• 定时器模式
• 观察者模式

定时器模式

定期监测URL是否变化，如100毫秒监测一次，与上次监测值对比来判断URL是否变化。定时器，前端可以使用setInterval来实现

var oldUrl = window.location.href;
setInterval(function(){
  if (oldUrl !== window.location.href) {
    //通知Native Url变化
    oldUrl = window.location.href;
  }
},100);

当然，Native也可以开启定时器监测window.location.href。

定时器模式的特点是实现简单，适用范围广；缺点也显而易见，监测结果不是十分准确，性能耗用高。而其性能耗用问题在移动端将会放大，故此我们不采用此模式。

观察者模式

上面提到的doUpdateVisitedHistory、shouldStartLoadWithRequest、decidePolicyForNavigationAction的实现可以算作观察者模式。

前面提到，单页应用页面切换在移动端webview的行为表现，并不会每次都通知Native，我们要做的就是通过某种方法来完善这个页面切换的事件通知。

对于观察者模式，iOS中有KVO（key-value-observing）机制，遍历UIWebView和WKWebView的属性发现：

• WKWebView的URL属性能够响应KVO机制，当前端页面（包括单页应用的页面）URL有变化时，KVO机制可以监测到。
• UIWebView的request属性并不能响应KVO机制，不能用它检测URL变化。也就是说，单纯使用UIWebView的能力接口不能完全监测URL变化

至此，在Native侧建立观察者的思路并不适用所有情况，我们需要再返回前端侧研究下单页应用的URL变化。

单页应用，通过hash或window.history可以做到改变URL，使得不刷新页面的情况下重新渲染。我们只要监测hash和window.history，当它们发生变化时去检测URL的变化：

• 通过hash改变URL，会触发hashchange事件。当监听到hashchange事件时，去检测URL的变化。

• window.history相关的事件为popstate。当监听到popstate事件时，去检测URL的变化。

  History.back()、History.forward()、History.go()会触发popstate事件

• 另外，History.pushState()和History.replaceState()不会触发popstate事件，所以我们要hook这两个方法，以检测URL的变化。

方案实现

结合以上，最终我们可以采用的可行方案如下 :

注意：上述方案并不是唯一方案，但确实是一个可行方案

WKWebView监测URL部分实现

//添加观察者
[self addObserver:wkwebview forKeyPath:@"URL" options:NSKeyValueObservingOptionNew context:nil];

//接收观察事件
- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context
{
  //url变化，触发相应动作
}

//使用完毕后移除观察者
[self removeObserver:wkwebview forKeyPath:@"URL"];

前端监测URL部分实现

//监听hash变化
window.addEventListener('hashchange',function(event){
  //通过bridge通知Native URL变化
});

//监听history变化,popstate只能监听History.back(),History.forward()、History.go()
window.addEventListener('popstate',function(event){
  //通过bridge通知Native URL变化
});

//hook History.pushState()  History.replaceState()
var _wr = function(type) {
    var orig = history[type];
    return function() {
        var rv = orig.apply(this, arguments);
        var e = new Event('ffpd'+type);
        e.arguments = arguments;
        window.dispatchEvent(e);
        return rv;
    };
};
history.pushState = _wr('pushState');
history.replaceState = _wr('replaceState');

window.addEventListener('ffpdpushState',function(event){
  //通过bridge通知Native URL变化
});
window.addEventListener('ffpdreplaceState',function(event){
  //通过bridge通知Native URL变化
});

参考：https://stackoverflow.com/questions/4570093/how-to-get-notified-about-changes-of-the-history-via-history-pushstate

WindowManager

参考文章
WindowManager可以在其他应用最上层，甚至手机桌面最上层显示窗口。

• 使用Context.getSystemService(Context.WINDOW_SERVICE)来获取WindowManager。
• API 17推出了Presentation，它将自动获取display的Context和WindowManager，可以方便地在另一个display上显示窗口
• 使用WindowManager继承自基类的addView方法和removeView方法来显示和隐藏窗口
• WindowManager实现悬浮窗需要声明权限，在manifest中添加如下权限：
• 在MIUI上需要在设置中打开本应用的”显示悬浮窗”开关，并且重启应用，否则悬浮窗只能显示在本应用界面内，不能显示在手机桌面上。

具体过程

创建工程

用Android Studio创建一个Android Basic Activity工程

添加权限

修改AndroidManifest.xml，添加下面结构的数据

<?xml version="1.0" encoding="utf-8"?>
<manifest >
<!--    显示顶层浮窗权限  -->
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW">
    </uses-permission>
</manifest>

修改代码

给MainActivity添加两个属性

public class MainActivity extends AppCompatActivity {
    TextView textView; //用于显示时间
    Timer timer;//用于定时刷新时间
    ...
}

Android Basic Activity工程创建后，自带一个按钮，给按钮添加点击事件的处理

final View.OnClickListener listener = new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                final WindowManager.LayoutParams params = new WindowManager.LayoutParams();
                // 类型 TYPE_SYSTEM_OVERLAY ，当悬浮窗口在其他App窗口上面时，不会隔断触摸事件，其他App能正常使用。
                //若要隔断触摸事件，可以使用TYPE_SYSTEM_ALERT
                params.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
                // 设置flag
                int flags = WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
                // | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
                // 如果设置了WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE，弹出的View收不到Back键的事件
               // FLAG_NOT_TOUCH_MODAL不阻塞事件传递到后面的窗口
                // 设置 FLAG_NOT_FOCUSABLE 悬浮窗口较小时，后面的应用图标由不可长按变为可长按

                params.flags = flags;
                // 不设置这个弹出框的透明遮罩显示为黑色
                params.format = PixelFormat.TRANSLUCENT;
                params.width = 300;
                params.height = 50;
                params.gravity = Gravity.TOP;

                TextView top=new TextView(view.getContext());
                //控件字体位置位于左边
                top.setGravity(Gravity.LEFT);
                top.setText("悬浮窗口");

                WindowManager windowManager = (WindowManager)view.getContext().getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
                windowManager.addView(top,params);

                textView = top;
                startTimer();//启动定时器（实现在后面）
            }
        };

FloatingActionButton fab = findViewById(R.id.fab);
//添加点击事件处理
fab.setOnClickListener(listener);

定时器刷新时间

public  void  startTimer(){

        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {

                Date currentTime = new Date();
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                final String dateString = formatter.format(currentTime);

                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText(dateString);
                    }
                });

            }
        },1000,300);
    }

完整代码如下

package com.zxs.windonwtimer;

import android.content.Context;
import android.graphics.PixelFormat;
import android.os.Bundle;

import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.google.android.material.snackbar.Snackbar;

import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;

import android.view.Gravity;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.TextView;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends AppCompatActivity {

    TextView textView;
    Timer timer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        final View.OnClickListener listener = new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                final WindowManager.LayoutParams params = new WindowManager.LayoutParams();
                // 类型
                params.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY;
                // WindowManager.LayoutParams.TYPE_SYSTEM_ALERT
                // 设置flag
                int flags = WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
                // | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
                // 如果设置了WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE，弹出的View收不到Back键的事件
                // FLAG_NOT_TOUCH_MODAL不阻塞事件传递到后面的窗口
                // 设置 FLAG_NOT_FOCUSABLE 悬浮窗口较小时，后面的应用图标由不可长按变为可长按
                // 不设置这个flag的话，home页的划屏会有问题
                params.flags = flags;
                // 不设置这个弹出框的透明遮罩显示为黑色
                params.format = PixelFormat.TRANSLUCENT;
                params.width = 300;//WindowManager.LayoutParams.MATCH_PARENT;
                params.height = 50;//WindowManager.LayoutParams.MATCH_PARENT;
                params.gravity = Gravity.TOP;

                TextView top=new TextView(view.getContext());
                //控件字体位置位于左边
                top.setGravity(Gravity.LEFT);
                top.setText("悬浮窗口");

                WindowManager windowManager = (WindowManager)view.getContext().getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
                windowManager.addView(top,params);

                textView = top;
                startTimer();
            }
        };
        FloatingActionButton fab = findViewById(R.id.fab);
        fab.setOnClickListener(listener);
    }

    public  void  startTimer(){

        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {

                Date currentTime = new Date();
                SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                final String dateString = formatter.format(currentTime);

                MainActivity.this.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        textView.setText(dateString);
                    }
                });

            }
        },1000,300);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

在Android Studio的Android工程中，需要在build.gradle文件内容里添加依赖指令，然后gradle构建就会自动化集成J2V8引擎

dependencies {
    implementation 'com.eclipsesource.j2v8:j2v8:5.0.103@aar'
}

J2V8的最新版本，可以在marven仓库中查看
https://mvnrepository.com/artifact/com.eclipsesource.j2v8/j2v8

使用示例

示例摘自https://eclipsesource.com/blogs/tutorials/getting-started-with-j2v8/

import com.eclipsesource.v8.V8;

public static void main(String[] args) {
 V8 runtime = V8.createV8Runtime();
 int result = runtime.executeIntegerScript(""
  + "var hello = 'hello, ';\n"
  + "var world = 'world!';\n"
  + "hello.concat(world).length;\n");
 System.out.println(result);
 runtime.release();
}

访问JavaScript对象（Object）

假设有这样一段JS脚本

var jsobj = {};
jsobj.hello = "world";

在J2V8中可以直接访问jsobj对象

import com.eclipsesource.v8.V8;

public static void main(String[] args) {
  V8 runtime = V8.createV8Runtime();
  runtime.executeVoidScript(""
    + "var jsobj = {};\n"
    + "jsobj.hello = 'world';\n");

// 访问jsobj的属性
  V8Object jsobj = runtime.getObject("jsobj");
  System.out.println(jsobj.getString("hello"));
  jsobj.release();

  runtime.release();
}

需要注意，V8Object需要自己手动释放

执行JavaScript函数

JS脚本

function test(a,b){
    return a+b;
}

var jsobj = {};
jsobj.func = test;

Java代码

V8 runtime = V8.createV8Runtime();
runtime.executeVoidScript("上面js脚本")

//包装参数
V8Array parameters = new V8Array(1).push(2);
//调用js test方法
runtime.executeIntegerFunction("test",parameters);
//调用jsobj.func
V8Object jsobj = runtime.getObject("jsobj");
jsob.executeIntegerFunction("func",parameters);

//释放
parameters.release();
jsobj.release();
runtime.release();

JS调用Java方法

需要注册实现了JavaCallback 接口的对象

JavaVoidCallback callback = new JavaVoidCallback() {
    @Override
    public void invoke(final V8Object receiver, final V8Array parameters) {
        System.out.println("xxxx");
    }
}

V8 runtime = V8.createV8Runtime();
// 注册到 js 全局函数，函数名为 <code>JavaFunc</code>
runtime.registerJavaMethod(callback, "JavaFunc");

在js中使用

JavaFunc(1,2,3);

JS调用Java对象实例方法

使用
V8Object.registerJavaMethod(object, javaMedthod, jsMethod, paramlist);

• object java对象
• javaMedthod object上的方法名
• jsMethod js环境中的方法名
• paramlist 这里指参数类型列表

V8 runtime = V8.createV8Runtime();

Object test = new test();
V8Object v8test = new V8Object(runtime);
runtime.add("test", v8test);

v8test.registerJavaMethod(test, "nativeFunc", "jsFunc", new Class<?>[] { String.class });

在js中使用

test.jsFunc('hello, world');