在Activity间传递的数据一般比较简单，但是有时候实际开发中也会传一些比较复杂的数据，尤其是面试问道当遇到需要在Activity间传递大量的数据怎么办？

Intent 传递数据的大小是有限制的，它大概能传的数据是1M-8K，原因是Binder锁映射的内存大小就是1M-8K.一般activity间传递数据会要使用到binder，因此这个就成为了数据传递的大小的限制。那么当activity间要传递大数据采用什么方式呢？其实方式很多，我们就举几个例子给大家说明一下，但是无非就是使用数据持久化，或者内存共享方案。一般大数据的存储不适宜使用SP， MMKV，DataStore。

Activity之间传递大量数据主要有如下几种方式实现：

• LruCache


• 持久化（sqlite、file等）


• 匿名共享内存

使用LruCache

LruCache是一种缓存策略，可以帮助我们管理缓存，想具体了解的同学可以去Glide章节中具体先了解下。在当前的问题下，我们可以利用LruCache存储我们数据作为一个中转，好比我们需要Activity A向Activity B传递大量数据，我们可以Activity A先向LruCache先写入数据，之后Activity B从LruCache读取。

首先我们定义好写入读出规则：

public interface IOHandler {

    //保存数据

    void put(String key, String value);

    void put(String key, int value);

    void put(String key, double value);

    void put(String key, float value);

    void put(String key, boolean value);

    void put(String key, Object value);



    //读取数据

    String getString(String key);

    double getDouble(String key);

    boolean getBoolean(String key);

    float getFloat(String key);

    int getInt(String key);

    Object getObject(String key);

}

我们可以根据规则也就是接口，写出具体的实现类。实现类中我们保存数据使用到LruCache，这里面我们一定要设置一个大小，因为内存中数据的最大值是确定，我们保存数据的大小最好不要超过最大值的1/8.

LruCache mCache = new LruCache<>( 10 * 1024*1024);

写入数据我们使用比较简单：

@Override

public void put(String key, String value) {

    mCache.put(key, value);

}

好比上面写入String类型的数据，只需要接收到的数据全部put到mCache中去。

读取数据也是比较简单方便：

@Override

public String getString(String key) {

    return String.valueOf(mCache.get(key));

}

持久化数据

那就是sqlite、file等方式。将需要传递的数据写在临时文件或者数据库中，再跳转到另外一个组件的时候再去读取这些数据信息，这种处理方式会由于读写文件较为耗时导致程序运行效率较低。这种方式特点如下：

优势：

（1）应用中全部地方均可以访问

（2）即便应用被强杀也不是问题了

缺点：

（1）操做麻烦

（2）效率低下

匿名共享内存

在跨进程传递大数据的时候，我们一般会采用binder传递数据，但是Binder只能传递1M一下的数据，所以我们需要采用其他方式完成数据的传递，这个方式就是匿名共享内存。

「Anonymous Shared Memory 匿名共享内存」是 Android 特有的内存共享机制，它可以将指定的物理内存分别映射到各个进程自己的虚拟地址空间中，从而便捷的实现进程间内存共享。

Android 上层提供了一些内存共享工具类，就是基于 Ashmem 来实现的，比如 MemoryFile、 SharedMemory。

1. 引言

平时Android开发中，启动Activity是非常常见的操作，而打开一个新Activity可以直接使用Intent，也可以每个Activity提供一个静态的启动方法。但是有些时候使用这些方法并不那么方便，比如：一个应用内的网页需要打开一个原生Activity页面时。这种情况下，网页的调用代码可能是app.openPage("/testPage")这样，或者是用app.openPage("local://myapp.com/loginPage")这样的方式，我们需要用一种方式把路径和页面关联起来。Android可以允许我们在Manifest文件中配置<data>标签来达到类似效果，也可以使用ARouter框架来实现这样的功能。本文就用200行左右的代码实现一个类似ARouter的简易界面路由。

2. 示例

2.1 初始化

这个操作建议放在Application的onCreate方法中，在第一次调用Router来打开页面之前。

public class AppContext extends Application {

    @Override

    public void onCreate() {

        super.onCreate();

        Router.init(this);

    }

}

2.2 启动无参数Activity

这是最简单的情况，只需要提供一个路径，适合“关于我们”、“隐私协议”这种简单无参数页面。

Activity配置：

@Router.Path("/testPage")

public class TestActivity extends Activity {

    //......

}

启动代码：

Router.from(mActivity).toPath("/testPage").start();

//或

Router.from(mActivity).to("local://my.app/testPage").start();

2.3 启动带参数Activity

这是比较常见的情况，需要在注解中声明需要的参数名称，这些参数都是必要参数，如果启动的时候没有提供对应参数，则发出异常。

Activity配置：

@Router.Path(value = "/testPage",args = {"id", "type"})

public class TestActivity extends Activity {

        @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //加载布局...



        String id = getIntent().getStringExtra("id"); //获取参数

        int type = getIntent().getIntExtra("type", 0);//获取参数

    }

}

启动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

2.4 启动带有静态启动方法的Activity

有一些Activity需要通过它提供的静态方法启动，就可以使用Path中的method属性和Entry注解来声明入口，可以提供参数。在提供了method属性时，需要用Entry的args来声明参数。

Activity配置：

@Router.Path(value = "/testPage", method = "open")

public class TestActivity extends Activity {



    @Router.Entry(args = {"id", "type"})

    public static void open(Activity activity, Bundle args) {

        Intent intent = new Intent(activity, NestWebActivity.class);

        intent.putExtras(args);

        activity.startActivity(intent);

    }



    @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //加载布局...



        String id = getIntent().getStringExtra("id"); //获取参数

        int type = getIntent().getIntExtra("type", 0);//获取参数

    }

}

启动代码：

Router.from(mActivity).toPath("/testPage").with("id", "t_123").with("type", 1).start();

3. API介绍

3.1 Path注解

这个注解只能用于Activity的子类，表示这个Activity需要页面路由的功能。这个类有三个属性：

• value：表示这个Activity的相对路径。


• args：表示这个Activity需要的参数，都是必要参数，如果打开页面时缺少指定参数，就会发出异常。


• method：如果这个Activity需要静态方法做为入口，就将这个属性指定为方法名，并给对应方法添加Entry注解。（注意：这个属性值不为空时，忽略这个注解中的args属性内容）

3.1 Entry注解

这个注解只能用于Activity的静态方法，表示这个方法作为打开Activity的入口。仅包含一个属性：

• args：表示这个方法需要的参数。

3.2 Router.init方法

• 方法签名：public static void init(Context context)


• 方法说明：这个方法用于初始化页面路由表，必须在第一次用Router打开页面之前完成初始化。建议在Application的onCreate方法中完成初始化。

3.3 Rouater.from方法

• 方法签名：public static Router from(Activity activity)


• 方法说明：这个方法用于创建Router实例，传入的参数通常为当前Activity。例如，要从AActivity打开BActivity，那么传入参数为AActivity的实例。

3.4 Rouater.to和Rouater.toPath方法

• 方法签名：

1. public RouterBuilder to(String urlString)


2. public RouterBuilder toPath(String path)

• 方法说明：这个方法用于指定目标的路径，to需要执行绝对路径，而toPath需要指定相对路径。返回的RouterBuilder用于接收打开页面需要的参数。

3.4 RouterBuilder.with方法

• 方法签名：

1. public RouterBuilder with(String key, String value)


2. public RouterBuilder with(String key, int value)

• 方法说明：这个方法用于添加参数，对应Bundle的各个put方法。目前只有常用的String和int两个类型。如有需要可自行在RouterBuilder中添加对应的方法。

3.4 RouterBuilder.start方法

• 方法签名：public void start()


• 方法说明：这个方法用于打开页面。如果存在路径错误、参数错误等异常情况，会发出对应运行时异常。

4. 实现

import android.app.Activity;

import android.content.Context;

import android.content.Intent;

import android.content.pm.ActivityInfo;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.net.Uri;

import android.os.Bundle;

import android.text.TextUtils;



import androidx.annotation.Keep;



import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import java.lang.reflect.Method;

import java.util.Map;

import java.util.Objects;

import java.util.concurrent.ConcurrentHashMap;



@Keep

public class Router {



    public static final String SCHEME = "local";

    public static final String HOST = "my.app";

    public static final String URL_PREFIX = SCHEME + "://" + HOST;



    private static final Map<String, ActivityStarter> activityPathMap = new ConcurrentHashMap<>();



    public static void init(Context context) {

        try {

            PackageManager packageManager = context.getPackageManager();

            PackageInfo packageInfo = packageManager.getPackageInfo(

                    context.getPackageName(), PackageManager.GET_ACTIVITIES);



            for (ActivityInfo activityInfo : packageInfo.activities) {

                Class<?> aClass = Class.forName(activityInfo.name);

                Path annotation = aClass.getAnnotation(Path.class);

                if (annotation != null && !TextUtils.isEmpty(annotation.value())) {

                    activityPathMap.put(annotation.value(), (Activity activity, Bundle bundle) -> {

                        if (TextUtils.isEmpty(annotation.method())) {

                            for (String arg : annotation.args()) {

                                if (!bundle.containsKey(arg)) {

                                    throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));

                                }

                            }

                            Intent intent = new Intent(activity, aClass);

                            intent.putExtras(bundle);

                            activity.startActivity(intent);

                        } else {

                            try {

                                Method method = aClass.getMethod(annotation.method(), Activity.class, Bundle.class);

                                Entry entry = method.getAnnotation(Entry.class);

                                if (entry != null) {

                                    for (String arg : entry.args()) {

                                        if (!bundle.containsKey(arg)) {

                                            throw new IllegalArgumentException(String.format("Bundle does not contains argument[%s]", arg));

                                        }

                                    }

                                    method.invoke(null, activity, bundle);

                                } else {

                                    throw new IllegalStateException("can not find a method with [Entry] annotation!");

                                }

                            } catch (Exception e) {

                                throw new RuntimeException(e);

                            }

                        }

                    });

                }

            }

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }



    public static Router from(Activity activity) {

        return new Router(activity);

    }



    private final Activity activity;



    private Router(Activity activity) {

        this.activity = activity;

    }



    public RouterBuilder to(String urlString) {

        if (TextUtils.isEmpty(urlString)) {

            return new ErrorRouter(new IllegalArgumentException("argument [urlString] must not be null"));

        } else {

            return to(Uri.parse(urlString));

        }

    }



    public RouterBuilder toPath(String path) {

        return to(Uri.parse(URL_PREFIX + path));

    }



    public RouterBuilder to(Uri uri) {

        try {

            if (SCHEME.equals(uri.getScheme())) {

                if (HOST.equals(uri.getHost())) {

                    String path = uri.getPath();//note: 二级路径暂不考虑

                    ActivityStarter starter = activityPathMap.get(path);

                    if (starter == null) {

                        throw new IllegalStateException(String.format("path [%s] is not support", path));

                    } else {

                        NormalRouter router = new NormalRouter(activity, starter);

                        for (String key : uri.getQueryParameterNames()) {

                            if (!TextUtils.isEmpty(key)) {

                                router.with(key, uri.getQueryParameter(key));

                            }

                        }

                        return router;

                    }

                } else {

                    throw new IllegalArgumentException(String.format("invalid host : %s", uri.getHost()));

                }

            } else {

                throw new IllegalArgumentException(String.format("invalid scheme : %s", uri.getScheme()));

            }

        } catch (RuntimeException e) {

            return new ErrorRouter(e);

        }

    }



    public static abstract class RouterBuilder {

        public abstract RouterBuilder with(String key, String value);



        public abstract RouterBuilder with(String key, int value);



        public abstract void start();

    }





    private static class ErrorRouter extends RouterBuilder {

        private final RuntimeException exception;



        private ErrorRouter(RuntimeException exception) {

            this.exception = exception;

        }



        @Override

        public RouterBuilder with(String key, String value) {

            return this;

        }



        @Override

        public RouterBuilder with(String key, int value) {

            return this;

        }



        @Override

        public void start() {

            throw exception;

        }

    }



    private static class NormalRouter extends RouterBuilder {

        final Activity activity;

        final Bundle bundle = new Bundle();

        final ActivityStarter starter;



        private NormalRouter(Activity activity, ActivityStarter starter) {

            this.activity = Objects.requireNonNull(activity);

            this.starter = Objects.requireNonNull(starter);

        }



        @Override

        public RouterBuilder with(String key, String value) {

            bundle.putString(key, value);

            return this;

        }



        @Override

        public RouterBuilder with(String key, int value) {

            bundle.putInt(key, value);

            return this;

        }



        @Override

        public void start() {

            starter.start(activity, bundle);

        }

    }



    @FunctionalInterface

    private interface ActivityStarter {

        void start(Activity activity, Bundle bundle);

    }



    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.TYPE)

    public @interface Path {

        String value();



        String method() default "";



        String[] args() default {};

    }



    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.METHOD)

    public @interface Entry {

        String[] args() default {};

    }

}

5. 注意

一、背景

转转集团旗下有多款APP产品，随着业务发展，各APP发版频率变高。在持续交付的背景下，渠道包更新存在以下几个效率问题：

（1）Android渠道包提交应用市场审核，工作重复&人工成本高  

（2）公司目前存在多个APP、需更多人支持，有培训成本

（3）每次发版需要人工通知项目成员渠道包审核进度 

  针对以上问题，我们设计开发了渠道包自动更新后台，用来解决渠道更新的效率问题。

二、方案调研

1、基于业务现状，做了技术调研和逻辑抽象

  不同APP支持的渠道不同，不同渠道更包api不同，如下图：

针对以上调研结果，我们将通用的逻辑统一封装开发，将差异点进行配置，做到灵活配置可扩展。

2、整体的实现方案演变

初期方案，每个应用市场单独提审（需要先选择物料，选好物料后上传包文件，文件上传成功后再点击提交审核），多个应用市场需要重复该操作。

上线运行了一段时间后，发现存在一些问题：单个市场提交步骤繁琐、多个应用市场需要分开多次提交。这些步骤是重复且可简化的，因此我们又对提审的过程做了封装，提供批量上传的入口，简化交互过程，做到一键提审。以下是当前运行的第二版方案：

第二版方案上线后，提审同学只需要在入口处选择要更新的应用市场，然后一键上传全部物料，再点击提审按钮即可提审成功。代码内部会处理具体的逻辑，比如：根据配置规则将物料匹配到对应市场、自动匹配包文件进行提审。

三、方案设计

自动上传包含以下核心模块：

• APP管理：支持配置多个APP信息，包括转转、找靓机、采货侠等


• 包管理：支持下载不同渠道，不同版本的包


• 物料管理：包括历史物料的选择，和新增物料的存储（icon、市场截图）


• 提交审核：包括包下载、物料下载，支持按照APP配置账号密码提交审核


• 消息提醒：对提交的结果和审核的结果进行消息通知

实现效果：

提审前信息确认，选择APP，可选择单个或者多个渠道，系统自动选择包地址，用户选择物料后可一键提审多应用市场。操作简单便捷，使用成本低

提审后发送消息通知，便于各方了解渠道的审核结果，对审核异常信息进行及时干预。同时自动存储不同版本的审核记录，方便后续分析。

四、总结

渠道包自动更新功能，节省了大量的提交审核人力成本，打通了Android整体的持续交付过程，降低了人工学习成本。之后我们也会针对各种体验问题进行不断的改进和更新～

大家好，本篇文章仍然聊聊kotlin官方做的一些优化工作，主要包括以下三个方面：

接下来就带大家介绍下上面三个特性。

一. 数据对象data object的支持

该特性由kotlin1.7.20插件版本提供，并处于实验阶段。

这个特性主要是和原来的object声明的单例类的toString()方法输出有关，在了解这个特性之前，我们先看下下面一个例子：

object Single1



fun main() {

    println(Single1)

}

输出：

这个输出本质上就是一个类名、@、地址的拼接，有时候你想要打印输出的仅仅是类名，就得需要重写下toString()方法：

object Single1 {



    override fun toString(): String {

        return "Single1"

    }

}

然后再看一个密封类的例子：

sealed interface Response {

    

    data class Success(val response: String): Response

    

    data class Fail(val error: String): Response

    

    object Loading : Response

    

}



fun main() {

    println(Response.Success("{code: 200}"))

    println(Response.Fail("no net"))

    println(Response.Loading)

}

输出：

可以看到，大家都是密封子类，但就这个Loading类的输出比较"丑陋"，没有上面两个兄弟类的输出简洁清爽。

接下来我们就要介绍下主人公数据对象data object了，这个东西其实使用起来和object一模一样，核心的区别就是前者的toString() 更加简洁。

接下来从一个例子一探究竟：

data object Single2



fun main() {

    println(Single2)

}

看下输出：

输出是不是比上面的object Single1更加简单明了。最重要的是在密封类中使用效果更加，我们把上面密封类Loading声明为data object：

    data object Loading : Response

看下最终的输出结果：

这下子输出结果是不是清爽更多！！

讲完了应用，我们再java的角度看下其背后的实现机制，相比较于object，data object会多了下面这三个重写方法：

public final class Single2 {

    

   @NotNull

   public String toString() {

      return "Single2";

   }



   public int hashCode() {

      return -535782198;

   }



   public boolean equals(@Nullable Object var1) {

      if (this != var1) {

         if (!(var1 instanceof Single2)) {

            return false;

         }



         Single2 var2 = (Single2)var1;

      }



      return true;

   }

}

我们需要关心的toString()方法就是直接重写返回了当前的类名。

如果想要使用这个特性，我们只需要增加如下配置即可：

compileKotlin.kotlinOptions {

    languageVersion = "1.9"

}

二. @Repeatable注解优化

该特性由kotlin1.6.0插件版本提供优化。

在了解这个特性之前，我们先回忆下@Repeatable这个注解在java中的使用：

如果一个注解在某个方法、类等等上面需要重复使用，那就需要@Repeatable帮助。

• 首先定义需要重复使用的注解

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

@Repeatable(Fruits.class)

public @interface Fruit {

    String name();

    String color();

}

• 然后定义注解容器，用来指定可重复使用的注解类型

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.TYPE)

public @interface Fruits {

    Fruit[] value();

}

然后就可以在代码中这样使用：

@Fruits({

        @Fruit(name = "apple", color = "red"),

        @Fruit(name = "origin", color = "yellow"),

})

public class Detail {

}

大家有没有发现，可重复注解定义起来还是由一丢丢的麻烦，接下来轮到我们kotlin重磅出击了。先看下面一个例子：

@Repeatable 

annotation class Animal(val name: String)

在kotlin中我们只要声明一个需要重复使用的注解即可，kotlin编译器会自动帮助我们生成注解容器@Animal.Container，然后我们就能在代码中这样使用：

@Animal(name = "dog")

@Animal(name = "horse")

public class Detail {

}

是不是非常简单便捷了。

如果你偏要显示指明一个包含注解，也可以，通过以下方式即可实现：

@JvmRepeatable(Animals::class)

annotation class Animal(val name: String)



annotation class Animals(val value: Array)

然后除了上面的使用方式，你在kotlin中还可以这样使用：

@Animals([Animal(name = "dog"), Animal(name = "dog")])

class Detail {

}

请注意：

另外，其实这个特性kotlin早就支持了，只不过kotlin1.6.0插件版本之前，kotlin这个特性只只支持RetentionPolicy.SOURCE生命周期的注解，并且还和java的可重复注解不兼容。

总结

这两个小技巧相信在大家日常开发中还是比较实用的，希望本篇能对你有所帮助。

参考文章：

Improved string representations for singletons and sealed class hierarchies with data objects

Repeatable annotations with runtime retention for 1.8 JVM target

1.Android Room 数据库的坑

在用Room数据库的时候 发现有需要一个字段的条件合到一起去写这个SQL

 @Query("SELECT * FROM 表名 WHERE 字段A = '1' and 字段B <= :Time " +

            "and 字段B >= :Time and 字段C <= :BTime and 字段C >= :BTime " +

            "and '(' || 字段D is null or 字段D = '' || ')'")

    List selectList(String Time, String BTime);

这里面的 “ ||” 是Room里面独特的表达方式 是替代了java里面的“+”号

正常在android中 使用 是这样的

String sql = "SELECT * FROM 表名 WHERE 字段A = '1' and 字段B <= "+传入的参数+" " +

            "and 字段B >= "+传入的参数+" and 字段C <= "+传入的参数+" and 字段c >= "+传入的参数+" " +

            "and '(' "+" 字段D is null or 字段D = '' "+" ')'"





cursor = db.rawQuery(sql, null);

而在Room 中 用 “||” 代替了 “+”

2.Android Room 查询语句的坑

@Query("SELECT * FROM 表名 WHERE 字段A = '0' order by id desc")

List selectList();

假如你正在查询一张表的面的内容,然后忽然跑出来一个异常

# [Android RoomDatabase Cruash "Cursor window allocation of 4194304 bytes failed"](https://stackoverflow.com/questions/75456123/android-roomdatabase-cruash-cursor-window-allocation-of-4194304-bytes-failed)

奔溃日志:

android.database.CursorWindowAllocationException: Could not allocate CursorWindow '/data/user/0/cn.xxx.xxx/databases/xxx.db' of size 2097152 due to error -13.

	at android.database.CursorWindow.nativeCreate(Native Method)

	at android.database.CursorWindow.(CursorWindow.java:139)

	at android.database.CursorWindow.(CursorWindow.java:120)

	at android.database.AbstractWindowedCursor.clearOrCreateWindow(AbstractWindowedCursor.java:202)

	at android.database.sqlite.SQLiteCursor.fillWindow(SQLiteCursor.java:147)

	at android.database.sqlite.SQLiteCursor.getCount(SQLiteCursor.java:140)

	at yd.d.m(SourceFile:21)

	at cn.xxx.control.y.y0(SourceFile:1)

	at e5.y.p(SourceFile:230)

	at e5.y.l(SourceFile:1)

	at e5.y.E(SourceFile:1)

	at cn.xxx.cluster.classin.viewmodel.SessionViewModel$d.invokeSuspend(SourceFile:42)

触发原因

• Room 对应的 Sqlite 数据库，其对 CursorWindows 分配的大小是有限制的，最大为 2M，超过之后会发生上述崩溃闪退现象（偶现且难以复现的 bug）

解决方法

需要业务方梳理这块的业务，优化数据库的调用，如果明确知道在一个方法里面会调用多个数据库的方法，需要让 controller 提供新的方法，且这个 controller 层的方法需要添加 @Transaction 进行注解，从而保证在同一个事物内进行数据库操作，以此避免 CursorWindows 大小超过 2M

那么问题来了 @Transaction 这个注解是干嘛的呢

翻译 事务的意思

@Transaction

@Query("SELECT * FROM 表名 WHERE 字段A = '0' order by id desc")

List selectList();

接着 问题完美解决

需求场景

我们在开发应用的时候经常会遇到先登录，登录成功后再跳转到目标页面。比如商品详情页面我们点击购买必须要先登录，登录完成才能去下单支付。针对这种场景，我们一般有两种做法：

第一种我们就不谈了产品经理不同意🐶。第二种我们一般是在 onActivityResult 里面获取到登录成功，然后根据 code 跳转到目标页面。这种方式缺点就是我们要在每个页面都处理相同的逻辑还有定义各种 code，如果应用里面很多这种场景也太繁琐了。那有没有统一的方式去处理这种场景就是我们今天的主题了。

封装方式

我们的应用是组件化的，APP 的页面跳转使用了 Arouter。所以我们统一处理使用 Arouter 封装。直接上代码

fun checkLoginToTarget(postcard: Postcard) {//Postcard 是 Arouter 的类

    if (User.isLogin()) {

        postcard.navigation()

    } else {

        //不能使用 postcard 切换 path 直接跳转，因为 group 可能不同，所以重新 build

        ARouter.getInstance().build(Constant.LOGIN)

            .with(postcard.extras)//获取携带的参数重新转入

            .withString(Constant.TAGACTIVIFY, postcard.path)//添加目标路由

            .navigation()

    }

}

//登录成功后在登录页面执行这个方法

fun loginSuccess() {

    val intent= intent

    val target = intent.getStringExtra(Constant.TAGACTIVIFY)//获取目标路由

    target?.apply { 

        if (isNotEmpty()){

            val build = ARouter.getInstance().build(this)

            val extras = intent.extras//获取携带的参数

            if (extras != null) {

                build.with(extras)

            }

            build.navigation()

        }

    }

    finish()

}

代码加了注释，使用 Kotlin 封装了顶层函数，登录页面在登录成功后跳转到目标页面，针对上面的场景直接调用 checkLoginToTarget 方法。

checkLoginToTarget(ARouter.getInstance().build(Constant.PAY_PAGE).withInt(Constant.GOOD_ID,id))

通过 Arouter 传入下单支付的路由地址，并且携带了商品的 ID，生成了 Postcard 参数。登录成功后能带着商品 ID
直接下单支付了。

最后

如果项目里没有使用路由库可以使用 Intent 封装实现，或者别的路由库也可以用上面的方式去做统一处理。

前言

在产品经理提需求时候提到，app在接收到报警信息时候能不能弹出一个弹框，告诉用户报警信息，这个弹框要在app的任意界面能够弹出，并且用户点击详情时候，会跳转到报警详情界面，查看具体信息，当用户将app至于后台的时候，接收到报警信息，app发送通知，当用户点击通知时候，跳转到报警详情界面。
功能大体总结如上，在实现弹框与通知在跳转界面时遇到一些问题，在此记录一下。效果图如下：

功能分析

弹框实现，使用DialogFragment。

前后台判断则是，创建一个继承自ActivityLifecycleCallbacks接口和Application的类，继承ActivityLifecycleCallbacks接口是为了前后台判断，继承Application则是方便在基类BaseActivity获取前后台相关数据。

项目原本采用单Activity多Fragment实现，后面因为添加了视频相关功能，改为了多Activity多Fragment。

原单Activity时候，实现比较容易。后面修改为多Activity，就有些头疼，最终用思路是创建基类BaseActivity，后面添加Activity时都要继承基类BaseActivity。使用基类原因是把相同的功能抽取出来，且若每个Activity都自己实现弹框和通知的话太容易出错，也太容易漏下代码了。

代码实现

弹框

在实现继承自DialogFragment的弹框时，需要在onCreateDialog方法内设置dialog的宽高模式以及背景，不然弹框会有默认的边距，导致显示效果与预期不符，未去边距与去掉边距的弹框效果如下：

关于onCreateDialog的代码如下：

override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {

    val dialog = Dialog(requireContext())

    dialog.setContentView(R.layout.custom_dialog_layout)

    dialog.window?.apply {

        setLayout(ViewGr0up.LayoutParams.MATCH_PARENT,ViewGr0up.LayoutParams.MATCH_PARENT)

        setBackgroundDrawable(ColorDrawable(Color.parseColor("#88000000")))//去掉DialogFragment的边距

    }

    dialog.setCancelable(false)

    return dialog

}

此外当弹框出现的时候，弹框背景色还会闪烁。这里采用属性值动画设置弹框背景色控件的透明度变换。完整的Dialog代码如下：

class AlarmDialogFragment: DialogFragment() {

    private lateinit var binding:CustomDialogLayoutBinding

    private var animator:ObjectAnimator? = null



    override fun show(manager: FragmentManager, tag: String?) {

        try {

            super.show(manager, tag)

        }catch (e:Exception){

            e.printStackTrace()

        }

    }



    override fun onCreateView(

        inflater: LayoutInflater,

        container: ViewGr0up?,

        savedInstanceState: Bundle?

    ): View? {

        binding = CustomDialogLayoutBinding.inflate(inflater)

        return binding.root

    }



    override fun onStart() {

        super.onStart()

        binding.viewAlarmDialogBg

        startAnimation()

    }



    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {

        val dialog = Dialog(requireContext())

        dialog.setContentView(R.layout.custom_dialog_layout)

        dialog.window?.apply {

            setLayout(ViewGr0up.LayoutParams.MATCH_PARENT,ViewGr0up.LayoutParams.MATCH_PARENT)

            setBackgroundDrawable(ColorDrawable(Color.parseColor("#88000000")))//去掉DialogFragment的边距

        }

        dialog.setCancelable(false)

        return dialog

    }



    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {

        super.onViewCreated(view, savedInstanceState)

        initView()

    }



    override fun onDestroy() {

        super.onDestroy()

        if(animator?.isStarted == true){

            animator?.end()

        }

    }



    private fun initView() {

        binding.btnCloseDialog.setOnClickListener {

            dismiss()

        }



        binding.btnDialogNav.setOnClickListener {

            if(context is MainActivity){

                val bundle = Bundle()

                bundle.putString("alarmId","1")

                findNavController().navigate(R.id.alarmDetailFragment,bundle)

            }else{

                val intent = Intent(context,MainActivity::class.java)

                intent.putExtra("task","toAlarmDetail")

                startActivity(intent)

            }

            dismiss()

        }

    }



    private fun startAnimation() {

        animator = ObjectAnimator.ofFloat(binding.viewAlarmDialogBg, "alpha", 0f, 0.6f, 0f, 0.6f, 0f)

        animator?.duration = 1200

        animator?.interpolator = AccelerateInterpolator()

        animator?.start()

    }

}

需要注意地方是，由于弹框还负责跳转，而跳转有两种情况，一种是在ActivityA内，fragmentA与fragmentB间的跳转，这种情况使用findNavController().navigate()方法进行跳转，另一种是ActivityB到另一个ActivityA内的指定FragmentB界面。这种采用startActivity(intent)方式跳转，并且在ActivityA的onStart()的方法使用下面方法。

/** 跳转报警详情界面 */

private fun initToAlarmDetail() {

    val task = intent.getStringExtra("task")

    if (task == "toAlarmDetail"){

        val bundle = Bundle()

        bundle.putString("alarmId","1")

        findNavController(R.id.fragment_main_table).navigate(R.id.alarmDetailFragment,bundle)

    }

}

这样从ActivityB到另一个ActivityA时候，在onStart()方法内会触发上面的initToAlarmDetail()方法，获取跳转里面的信息，在决定具体跳转到哪个Fragment。这里解释的可能不太清楚，可以在Github下载源码看看可能更好理解些。

弹框对应的xml文件代码，可以在Github内查看，可以自己写一个，这个xml比较简单，只是xml代码比较占地方这里就不粘贴了。

前后台判断

关于前后台判断，需要创建一个继承ActivityLifecycleCallbacks和Application的类，这里命名为CustomApplication，在类里面实现ActivityLifecycleCallbacks接口相关方法，此外需要创建下面三个变量，分别表示activity数量，当前activity的名称，是否处于后台，代码如下：

private var activityCount = 0

private var nowActivityName:String? = null

private var isInBackground = true

之后需要在onActivityStarted，onActivityResumed，onActivityStopped方法内进行前后台相关处理，代码如下：

override fun onActivityStarted(activity: Activity) {

    activityCount++

    if (isInBackground){

        isInBackground = false

    }

    nowActivityName = activity.javaClass.name

}



override fun onActivityStopped(activity: Activity) {

    activityCount--

    if (activityCount == 0 && !isInBackground){

        isInBackground = true

    }

}

上面代码可以看出，当触发onActivityStarted方法时候，activityCount数量加一，且app处于前台。之后记录当前activity名称，这里记录activity名称是后面有个功能是app置于后台时候弹出通知，而通知相关操作，为了每个activity都能实现就放在基类执行，而弹出通知并不需要每个继承基类的activity都执行，到时候需要根据根据nowActivityName判断哪个继承了基类的activity执行通知操作。

当触发onActivityStopped方法时候，activityCount数量减一，且当activityCount数量为零时，app置于后台。
CustomApplication完整代码如下：

class CustomApplication: Application(),Application.ActivityLifecycleCallbacks {

    companion object{

        const val TAG = "CustomApplication"

        @SuppressLint("CustomContext")

        lateinit var context: Context 

    }



    private var activityCount = 0

    private var nowActivityName:String? = null

    private var isInBackground = true



    fun getNowActivityName(): String? {

        return nowActivityName

    }



    fun getIsInBackground():Boolean{

        return isInBackground

    }



    override fun onCreate() {

        super.onCreate()

        context = applicationContext

        registerActivityLifecycleCallbacks(this)

    }



    override fun onActivityCreated(activity: Activity, p1: Bundle?) {



    }



    override fun onActivityStarted(activity: Activity) {

        activityCount++

        if (isInBackground){

            isInBackground = false

        }

        nowActivityName = activity.javaClass.name

    }



    override fun onActivityResumed(activity: Activity) {



    }



    override fun onActivityPaused(activity: Activity) {



    }



    override fun onActivityStopped(activity: Activity) {

        activityCount--

        if (activityCount == 0 && !isInBackground){

            isInBackground = true

        }

    }



    override fun onActivitySaveInstanceState(activity: Activity, p1: Bundle) {



    }



    override fun onActivityDestroyed(activity: Activity) {



    }

}

弹框与通知弹出

开发中弹框与通知弹出的触发条件是，监听Websocket若有信息过来，app处于前台弹框，处于后台弹通知。这里使用Handler来模拟，弹框弹出比较简单，若有继承了DialogFragment的AlarmDialogFragment类。代码如下：

val dialog = AlarmDialogFragment()

dialog.show(supportFragmentManager,"tag")

通知弹出也不难，若只是弹出通知示例代码如下：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

    val channel =

        NotificationChannel("normal", "Normal", NotificationManager.IMPORTANCE_DEFAULT)

    notificationManager?.createNotificationChannel(channel)

}

val notification = NotificationCompat.Builder(this.applicationContext, "normal")

    .setContentTitle("标题")

    .setContentText("通知次数:${++alarmCount}")

    .setSmallIcon(R.drawable.ic_launcher_background)

    .setTimeoutAfter(5000)

    .setAutoCancel(true)

    .build()

notificationManager?.notify(notificationId,notification)

弹框与通知的特殊要求是，能在界面任意地方弹出且跳转到指定界面。弹框跳转相关代码在上面'弹框'部分，下面来说下通知的跳转，点击通知跳转是通过创建PendingIntent后在设置进NotificationCompat的setContentIntent方法内，不过通知跳转与弹框跳转一样需要分两种情况考虑，第一种同一Activity内Fragment与Fragment跳转，这种情况下PendingIntent如下代码所示：

var pendingIntent:PendingIntent? = null

val bundle = Bundle()

bundle.putString("alarmId","1")

pendingIntent = NavDeepLinkBuilder(this)

    .setGraph(R.navigation.main_navigation)

    .setDestination(R.id.alarmDetailFragment)

    .setArguments(bundle)

    .createPendingIntent()

上面代码中使用NavDeepLinkBuilder创建了一个PendingIntent，并且使用setGraph()指向使用的导航图，setDestination()则指向目标Fragment。
另一种情况则是ActivityB到另一个ActivityA内的指定FragmentB界面，这种情况下PendingIntent设置代码如下：

val intent = Intent(this@BaseActivity,MainActivity::class.java)

intent.putExtra("task","toAlarmDetail")

intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

pendingIntent = TaskStackBuilder.create(this@BaseActivity)

    .addNextIntentWithParentStack(intent)

    .getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT)

这种是创建一个跳转到MainActivity的Intent，并添加传递的参数task，接着设置Intent的启动方式，其中Intent.FLAG_ACTIVITY_NEW_TASK，表示启动Activity作为新任务启动，Intent.FLAG_ACTIVITY_CLEAR_TASK，表示清除任务栈中所有现有的Activity。之后调用TaskStackBuilder创建PendingIntent。
上面两种方式创建的PendingIntent可以通过NotificationCompat.setContentIntent(pendingIntent)添加进去，关于通知创建的代码如下：

/** 使用通知 - 通过pendingIntent实现跳转，缺点是任意界面进入报警详情界面，点击返回键只能返回MainFragment */

    private fun useNotificationPI() {

        var pendingIntent:PendingIntent? = null

        if(javaClass.simpleName == "MainActivity"){//主界面

            val bundle = Bundle()

            bundle.putString("alarmId","1")

            pendingIntent = NavDeepLinkBuilder(this)

                .setGraph(R.navigation.main_navigation)

                .setDestination(R.id.alarmDetailFragment)

                .setArguments(bundle)

                .createPendingIntent()

        }else {//其他界面时候切换后台通知

            val intent = Intent(this@BaseActivity,MainActivity::class.java)

            intent.putExtra("task","toAlarmDetail")

            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

            pendingIntent = TaskStackBuilder.create(this@BaseActivity)

                .addNextIntentWithParentStack(intent)

                .getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT)

        }



        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

            val channel =

                NotificationChannel("normal", "Normal", NotificationManager.IMPORTANCE_DEFAULT)

            notificationManager?.createNotificationChannel(channel)

        }

        val notification = NotificationCompat.Builder(this.applicationContext, "normal")

            .setContentTitle("标题")

            .setContentText("通知次数:${++alarmCount}")

            .setSmallIcon(R.drawable.ic_launcher_background)

            .setTimeoutAfter(5000)

            .setAutoCancel(true)

            .setContentIntent(pendingIntent)

            .build()

        notificationManager?.notify(notificationId,notification)

    }

上面代码中if(javaClass.simpleName == "MainActivity"),及第四行代码，该代码用处是当app置于后台时候，pp界面是MainActivity时，pendingIntent使用NavDeepLinkBuilder生成，当是其他Activity时使用TaskStackBuilder生成。之所以这样是因为，在MainActivity的xml，使用了FragmentContainerView用于fragment间跳转，其他的Activity没有FragmentContainerView，因此在生成pendingIntent需要采用不同的方式生成。

这示例代码中，主要涉及到的Avtivity有MainActivity与VideoActivity，MainActivity使用FragmentContainerView，而VideoActivity没有。弹框与通知跳转的界面是AlarmDetailFragment，这个fragment在MainActivity通过Navigation实现导航。

因此在MainActivity界面进入后台时，pendingIntent使用NavDeepLinkBuilder生成，NavDeepLinkBuilder则可以使用导航图中fragment生成深度链接URI，这个URI则可以导航到指定的fragment（关于NavDeepLinkBuilder了解不深入，这里说的可能有错误地方，欢迎大佬指正）。

而VideoActivity界面进入后台时，就需要使用TaskStackBuilder生成一个启动MainActivity的Intent。而在MainActivity的onStart方法内有下面initToAlarmDetail方法，判断跳转时携带参数决定是否跳转到AlarmDetailFragment界面。

/** 跳转报警详情界面 */

private fun initToAlarmDetail() {

    val task = intent.getStringExtra("task")

    if (task == "toAlarmDetail"){

        val bundle = Bundle()

        bundle.putString("alarmId","1")

        findNavController(R.id.fragment_main_table).navigate(R.id.alarmDetailFragment,bundle)

    }

}

至此弹框与通知的功能基本实现，完整的BaseActivity代码如下：

open class BaseActivity: AppCompatActivity() {

    companion object{

        const val TAG = "BaseActivity"

    }

    private var alarmCount = 0

    private val handler = Handler(Looper.myLooper()!!)

    //为了关闭通知，manager放在外面

    private val notificationId = 1

    private var alarmDialogFragment: AlarmDialogFragment? = null

    private var notificationManager:NotificationManager? = null

    private var bgServiceIntent:Intent? = null//前台服务



    private var nowClassName = ""



    /** 弹框定时任务 */

    private val dialogRunnable = object : Runnable {

        override fun run() {

            //在定时方法里面 javaClass.simpleName 不能获取当前所处Activity的名称

            if (nowClassName == "VideoActivity"){ //视频界面不弹弹框

                CustomLog.d(TAG,"不使用弹框 ${nowClassName}")

            }else{

                CustomLog.d(TAG,"使用弹框 ${nowClassName}")

                useDialog()

                handler.postDelayed(this, 10000)

            }

        }

    }



    /** 通知定时任务 */

    private val notificationRunnable = object :Runnable{

        override fun run() {

            useNotificationPI()

            handler.postDelayed(this,10000)

        }

    }



    override fun onCreateView(name: String, context: Context, attrs: AttributeSet): View? {

        initWindow()

        return super.onCreateView(name, context, attrs)

    }



    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {

        super.onCreate(savedInstanceState, persistentState)

        CustomLog.d(TAG,"onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) 当前类:${javaClass.simpleName}")

    }



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        CustomLog.d(TAG,"onCreate(savedInstanceState: Bundle?) 当前类:${javaClass.simpleName}")

        initData()

    }



    override fun onStart() {

        super.onStart()

        CustomLog.d(TAG,"onStart 当前类:${javaClass.simpleName}")

        nowClassName = javaClass.simpleName

        handler.postDelayed(dialogRunnable, 3000)

        initService()

    }



    override fun onResume() {

        super.onResume()

        CustomLog.d(TAG,"onResume 当前类:${javaClass.simpleName}")

    }



    override fun onRestart() {

        super.onRestart()

        CustomLog.d(TAG,"onRestart 当前类:${javaClass.simpleName}")

    }



    override fun onPause() {

        super.onPause()

        CustomLog.d(TAG,"onPause 当前类:${javaClass.simpleName}")

    }



    override fun onStop() {

        super.onStop()

        CustomLog.d(TAG,"onStop 当前类:${javaClass.simpleName}")

        val customApplication = applicationContext as CustomApplication

        val nowActivityName = customApplication.getNowActivityName()

        val activitySimpleName = nowActivityName?.substringAfterLast(".")

        CustomLog.d(TAG,"activitySimpleName:$activitySimpleName")

        val isInBackground = (this@BaseActivity.applicationContext as CustomApplication).getIsInBackground()

        if (isInBackground && activitySimpleName.equals(javaClass.simpleName)){// 处于后台 且 切换至后台app的activity页面名称等于当前基类里面获取activity类名

            handler.postDelayed(notificationRunnable,3000)

            CustomLog.d(TAG,"使用通知 $nowClassName")

        }else{

            CustomLog.d(TAG,"关闭所有定时任务 $nowClassName")

            closeAllTask()

        }

    }



    override fun onDestroy() {

        super.onDestroy()

        CustomLog.d(TAG,"onDestroy 当前类:${javaClass.simpleName}")

        closeAllTask()

        this.stopService(bgServiceIntent)

    }



    /** 关闭所有定时任务 */

    private fun closeAllTask() {

        handler.removeCallbacks(dialogRunnable)

        handler.removeCallbacks(notificationRunnable)

    }



    /** 初始化数据 - 关于弹框*/

    private fun initData() {

        notificationManager = notificationManager ?: this.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        alarmDialogFragment = alarmDialogFragment ?: AlarmDialogFragment()

    }



    /** 使用通知 - 通过pendingIntent实现跳转，缺点是任意界面进入报警详情界面，点击返回键只能返回MainFragment */

    private fun useNotificationPI() {

        var pendingIntent:PendingIntent? = null

        if(javaClass.simpleName == "MainActivity"){//主界面

            CustomLog.d(TAG,">>>通知：MainActivity")

            val bundle = Bundle()

            bundle.putString("alarmId","1")

            pendingIntent = NavDeepLinkBuilder(this)

                .setGraph(R.navigation.main_navigation)

                .setDestination(R.id.alarmDetailFragment)

                .setArguments(bundle)

                .createPendingIntent()

        }else {//其他界面时候切换后台通知

            CustomLog.d(TAG,">>>通知：else")

            val intent = Intent(this@BaseActivity,MainActivity::class.java)

            intent.putExtra("task","toAlarmDetail")

            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

            pendingIntent = TaskStackBuilder.create(this@BaseActivity)

                .addNextIntentWithParentStack(intent)

                .getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT)

        }



        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

            val channel =

                NotificationChannel("normal", "Normal", NotificationManager.IMPORTANCE_DEFAULT)

            notificationManager?.createNotificationChannel(channel)

        }

        val notification = NotificationCompat.Builder(this.applicationContext, "normal")

            .setContentTitle("标题")

            .setContentText("通知次数:${++alarmCount}")

            .setSmallIcon(R.drawable.ic_launcher_background)

            .setTimeoutAfter(5000)

            .setAutoCancel(true)

            .setContentIntent(pendingIntent)

            .build()

        notificationManager?.notify(notificationId,notification)

    }



    /** 弹框使用 - 因为此处涉及到fragment等生命周期，进入其他activity内时候，在前的activity使用useDialog会因为生命周期问题闪退*/

    private fun useDialog() {

        //弹出多个同种弹框

//        alarmDialogFragment = AlarmDialogFragment()

//        alarmDialogFragment?.show(supportFragmentManager,"testDialog")



        //不弹出多个同种弹框，一次只弹一个，若弹框存在不弹新框

        if (alarmDialogFragment?.isVisible == false){//如果不加这一句，当弹框存在时候在调用alarmDialogFragment.show的时候会报错，因为alarmDialogFragment已经存在

            alarmDialogFragment?.show(supportFragmentManager,"testDialog")

        }else{

            //更新弹框内信息

        }

    }



    /** 关闭报警弹框 */

    private fun closeAlarmDialog() {

        if (alarmDialogFragment?.isVisible == true) {

            alarmDialogFragment?.dismiss()//要关闭的弹框

        }

    }



    //状态栏透明,且组件占据了状态栏

    private fun initWindow() {

        window.statusBarColor = Color.TRANSPARENT

        window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

    }



    /** 初始化服务 */

    private fun initService() {

        CustomLog.d(TAG,"开启前台服务")

        bgServiceIntent = bgServiceIntent ?: Intent(this, BackgroundService::class.java)

        this.startService(bgServiceIntent)

    }

}

总结

只是弹出弹框和通知的话，实现很好实现，中间麻烦地方在于当app使用多个Activity，该怎么实现跳转到指定的界面。当然这里麻烦是，从ActivityB跳转到ActivityA的Fragment，如果是只有一个Activity应该会好办些。个人感觉fragment跳转应该有更好的方式实现希望能和大佬们交流下这种情况下，用什么技术实现。

PS：感觉原生Android在写界面和跳转方面写起来不太方便。不知道大家有便捷的方式吗。

代码地址

GitHub：github.com/SmallCrispy…

有些场景下需要显示一些提示弹窗，但把握不好弹出时机容易先弹出弹窗然后界面马上被杀掉进而看不到提示内容，例如强制下线：客户端退回登录界面并弹出提示弹窗。

如果是直接拿的栈顶activity去弹出，没有将弹窗逻辑写到具体activity中，或不好确定activty的变化就容易出现这种现象。

由于applicationContext没有AppWindowToken，所以dialog无法使用applicationContext创建，要么就使用windowManager配合WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY使用创建全局悬浮窗。但是这种做法需要申请权限。那么，在没有悬浮权限情况下如何做到让dialog不受栈顶activity变化的影响？

我的想法是通过application.registerActivityLifecycleCallbacks在activity变化时，关闭原来的弹窗，并重新创建一个一样的dialog并显示。

效果演示：

1. 栈顶界面被杀

2. 有新界面弹出

以下是代码实现：

/**

 * @Description 无需悬浮权限的全局弹窗，栈顶activity变化后通过反射重建，所以子类构造方法需无参

 */

open class BaseAppDialog<T : ViewModel>() : Dialog(topActivity!!.get()!!), ViewModelStoreOwner {



    companion object {

        private val TAG = BaseAppDialog::class.java.simpleName

        private var topActivity: WeakReference<Activity>? = null

        private val staticRestoreList = linkedMapOf<Class<*>, Boolean>()    //第二个参数：是否临时关闭

        private val staticViewModelStore: ViewModelStore = ViewModelStore()



        @JvmStatic

        fun init(application: Application) {

            application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {

                override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {

                    topActivity = WeakReference(activity)

                }



                override fun onActivityStarted(activity: Activity) {



                }



                override fun onActivityResumed(activity: Activity) {

                    topActivity = WeakReference(activity)

                    val tempList = arrayListOf<BaseAppDialog<*>>()

                    val iterator = staticRestoreList.iterator()

                    while (iterator.hasNext()) {

                        val next = iterator.next()

                        val topName = (topActivity?.get() ?: "")::class.java.name

                        if (next.value == true) {  //避免onCreate创建的弹窗重复弹出

                            val newInstance = Class.forName(next.key.name).getConstructor().newInstance() as BaseAppDialog<*>

                            tempList.add(newInstance)

                            Log.e(TAG, "重新创建${next.key.name}，于$topName")

                            iterator.remove()

                        }



                    }



                    tempList.forEach {

                        it.show()

                    }



                    if (staticRestoreList.size == 0) {

                        staticViewModelStore.clear()

                    }

                }



                override fun onActivityPaused(activity: Activity) {

                }



                override fun onActivityStopped(activity: Activity) {



                }



                override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {

                }



                override fun onActivityDestroyed(activity: Activity) {

                }

            })

        }

    }





    var vm: T? = null



    init {

        val genericClass = getGenericClass()

        if (vm == null) {

            (genericClass as? Class<T>)?.let {

                vm = ViewModelProvider(this)[it]

            }

        }



        topActivity?.get()?.let {

            (it as LifecycleOwner).lifecycle.addObserver(object : DefaultLifecycleObserver {

                override fun onPause(owner: LifecycleOwner) {

                    super.onPause(owner)

                    dismissSilent()

                }

            })

        }

    }





    //用于栈顶变化时的关闭

    private fun dismissSilent() {

        super.dismiss()

        staticRestoreList.replace(this::class.java, true)

    }



    override fun show() {

        super.show()

        staticRestoreList.put(this::class.java, false)

    }



    override fun dismiss() {

        super.dismiss()

        staticRestoreList.remove(this::class.java)

    }





    //获取泛型实际类型

    private fun getGenericClass(): Class<*>? {

        val superclass = javaClass.genericSuperclass

        if (superclass is ParameterizedType) {

            val actualTypeArguments: Array<Type>? = superclass.actualTypeArguments

            if (!actualTypeArguments.isNullOrEmpty()) {

                val type: Type = actualTypeArguments[0]

                if (type is Class<*>) {

                    return type

                }

            }

        }

        return ViewModel::class.java

    }





    //自己管理viewModel以便恢复数据

    override fun getViewModelStore(): ViewModelStore {

        return staticViewModelStore

    }

}

参数传递的话，直接通过修改dialog的viewmodel变量或调用其方法来实现。

class TipDialogVm : ViewModel() {

    val content = MutableLiveData<String>("")

}





class TipDialog2 : BaseAppDialog<TipDialogVm>() {



    var binding : DialogTip2Binding? = null



    init {

        binding = DataBindingUtil.inflate(LayoutInflater.from(context), R.layout.dialog_tip2, null, false)

        binding?.lifecycleOwner = context as? LifecycleOwner

        binding?.vm = vm

        setContentView(binding!!.root)



    }

}

弹出弹窗

TipDialog2().apply {

    vm?.content?.value = "嗨嗨嗨"

}.show()

前言

众所周知，Region是android graphics一族中比较低调的工具类，主要原因还是在碰撞检测方面存在一些不足，甚至可以说成事不足败事有余，以至于难以用于2D游戏开发，这也是耽误你们成为2D游戏大师路上的一道坎 。既然Region这么失败的工具为什么要介绍呢，一方面本篇通过路径检测的方式解决了成事不足败事有余的问题，另外一方面我们也要介绍他可用的部分，以及正确的用法。最后，本篇其实主要是通过PathMeasure和Region相互配合，优化了碰撞检测逻辑精确度问题。

预览效果

这是我们最终要达到的效果。

异常效果

我们需要重点处理两个问题

• 没接触到就检测到碰撞


• 接触已经很多距离了才检测到碰撞

Region 碰撞检测问题

• Region类能成事的部份主要还是Op布尔操作和矩阵操作，但是这个似乎又和Path的作用重合，不知道是不是因为性能更高呢？本文没有去测试，有机会测试一下。另外一部分containXXX包含关系判断，containXXX能准确的判断点和矩形是不是被包含了，但是其他形状那就没办法了。


• quickXXX 快速检测方法，返回值true-能确保物体没有碰撞，但false无法确保是不是已经碰撞了，换句话说true是100%没碰撞，但是false还需要你自己进一步确认，不过这点可以作为减少判断的优化方法，但不是判定方法。

学习Region & PathMeasure 的意义

对于一些粒子，我们不太关注大小，这个时候是可以利用中心点去检测的，那对于多边形或者半圆等形状，点是非常多的，显然得找一种更好的方法。实际上看似quickXXX其实用处不大，其实可以减少一部分检测逻辑，quickXXX虽然比不上contains的精确度，但是仍然能检测到没有碰撞，本篇需要了解它的用法，然后配合PathMeasure，实现精确检测。

非Path用法

对于非Path用法，Region还是相当简单的，直接使用set方法即可

mainRegion.set((int) -radius, (int) -radius, (int) radius, (int) radius);

Path方法

这个用法比较奇怪，需要2个参数，最后一个是Region类，弄不好就是鸡生蛋蛋生鸡一样令人迷惑，第二个可以看作被裁剪的区域，如下操作，求并集区域。不过话说回来，这个意义在哪里？

circlePath.reset();

circlePath.addCircle(x- width/2f,y - height/2f,10, Path.Direction.CCW);

circleRegion.setPath(circlePath,mainRegion);

小试一下

实现开头的图片效果，定义一些Path和形状。

定义一些变量

 private float x; //x事件坐标

 private float y; //y事件坐标



 //所以形状

 Path[] objectPaths = new Path[5];

 //形状区域检测

 Region objectRegion = new Region();

 

 //小圆球区域

 Region circleRegion = new Region();

//小圆

 Path circlePath = new Path();

 //绘制区域

 Region mainRegion = new Region();

构建物体

三角形、圆等物体

for (int i = 0; i < objectPaths.length; i++) {

    Path path = objectPaths[i];

    if (path == null) {

        path = new Path();

        objectPaths[i] = path;

    } else {

        path.reset();

    }

}



Path path = objectPaths[0];

path.moveTo(radius / 2, -radius / 2);

path.lineTo(0, -radius);

path.lineTo(radius / 2, -radius);

path.close();



path = objectPaths[1];

path.moveTo(-radius / 2, radius / 2);

path.lineTo(-radius / 2 - 100, radius / 2);

path.arcTo(-radius / 2 - 100, radius / 2, -radius / 2, radius / 2 + 100, 0, 180, false);

path.lineTo(-radius / 2, radius / 2);

path.close();



path = objectPaths[2];

path.addCircle(-radius + 200f, -radius + 100f, 50f, Path.Direction.CCW);



path = objectPaths[3];

path.addRoundRect(-radius / 2, -radius / 2, -radius / 2 + 20, 0, 10, 10, Path.Direction.CCW);



path = objectPaths[4];

path.addRect(120, 120, 200, 200, Path.Direction.CCW);

区域检测

检测是否发生了碰撞，准确度不高，但还能凑合

circlePath.reset();

circlePath.addCircle(x- width/2f,y - height/2f,10, Path.Direction.CCW);

circleRegion.setPath(circlePath,mainRegion);



mCommonPaint.setColor(Color.CYAN);

for (int i = 0; i < objectPaths.length; i++) {

    objectRegion.setPath(objectPaths[i],mainRegion);

    if(!objectRegion.quickReject(circleRegion)){

        Log.d("RegionView"," 可能发生了碰撞");

        mCommonPaint.setColor(Color.YELLOW);

    }else{

        mCommonPaint.setColor(Color.CYAN);

    }

    canvas.drawPath(objectPaths[i], mCommonPaint);

}

到这里我们完成了简单的检测，但其实它的精确度很差，这个效果显然不是我们想要的，尤其没有实际接触的情况就染色了。这样会产生很多争议，比如游戏中刘备不可能超出攻击范围去打你一样。

精准区域检测优化

在我们做推箱子游戏和珠珠碰撞的时候，我们都是用圆心之间的距离去检测，显然这里是不行的，不光障碍物本身有形状且不规则，而且中心区域正中可能是空白区域，显然圆心之间的距离是不合适的。我们之前学过PathMeasure很多用法《心跳效果》，其中之一是使用粒子描线，下图是我们的效果，在这篇中我们利用PathMeasure对获取路径坐标，并对线周围布置粒子。

那么，使用PathMeasure方式获取线条边缘的点不就更准确了么 ？好的，我们开干。

优化逻辑

• 获取障碍物和圆的Bounds，计算面积，这样把检测物体和被检测物体中最小的设置给PathMeasure


• 利用PathMeasure的getPosTan获取点


• 使用Region的contain进行判断点是不是在区域内

下面是优化逻辑

circlePath.reset();

circlePath.addCircle(x- width/2f,y - height/2f,20, Path.Direction.CCW);

circleRegion.setPath(circlePath,mainRegion);





mCommonPaint.setColor(Color.CYAN);

for (int i = 0; i < objectPaths.length; i++) {

    objectRegion.setPath(objectPaths[i],mainRegion);

    if(!objectRegion.quickReject(circleRegion)){

        mCommonPaint.setColor(Color.YELLOW);

        if (circleRegion.getBounds(circleRect)

                && objectRegion.getBounds(objectRect)) {



            Region regionChecker = null;

            if (circleRect.width() * circleRect.height() > objectRect.width() * objectRect.height()) {

                pathMeasure.setPath(objectPaths[i], false);

                regionChecker = circleRegion;

            } else {

                pathMeasure.setPath(circlePath, false);

                regionChecker = objectRegion;

            }



            for (int len = 0; len < pathMeasure.getLength(); len++) {

                pathMeasure.getPosTan(len, pos, tan);

                if(regionChecker.contains((int) pos[0], (int) pos[1])){

                    Log.d("RegionView"," 可能发生了碰撞");

                    mCommonPaint.setColor(Color.YELLOW);

                }

            }



        }



    }else{

        mCommonPaint.setColor(Color.CYAN);

    }

    canvas.drawPath(objectPaths[i], mCommonPaint);

}

我们再来看效果，就是文章开头的效果

总结

到这里结束了，对于Region类，对点的检测是非常精准的，但是在数学中，所有图形都是点构成线、线构成面，我们本篇利用PathMeasure和Region配合实现了精准检测逻辑，扫平了2D游戏开发过程中的一道门槛。希望看过本篇之后，你能成为游戏大师。

全部代码

有个小插曲，演示精确度低的时候导致代码被还原了，所以重新画了一些东西。

public class RegionView extends View {

    private final DisplayMetrics mDM;

    private TextPaint mCommonPaint;



    public RegionView(Context context) {

        this(context, null);

    }



    public RegionView(Context context, AttributeSet attrs) {

        super(context, attrs);

        mDM = getResources().getDisplayMetrics();

        initPaint();

        setClickable(true); //触发hotspot

    }



    private void initPaint() {

        //否则提供给外部纹理绘制

        mCommonPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);

        mCommonPaint.setAntiAlias(true);

        mCommonPaint.setStyle(Paint.Style.FILL);

        mCommonPaint.setStrokeCap(Paint.Cap.ROUND);

        mCommonPaint.setFilterBitmap(true);

        mCommonPaint.setDither(true);

        mCommonPaint.setStrokeWidth(dp2px(20));



    }



    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int widthMode = MeasureSpec.getMode(widthMeasureSpec);

        int widthSize = MeasureSpec.getSize(widthMeasureSpec);

        if (widthMode != MeasureSpec.EXACTLY) {

            widthSize = mDM.widthPixels / 2;

        }

        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int heightSize = MeasureSpec.getSize(heightMeasureSpec);



        if (heightMode != MeasureSpec.EXACTLY) {

            heightSize = widthSize / 2;

        }

        setMeasuredDimension(widthSize, heightSize);



    }



    private float x;

    private float y;



    //所以形状

    Path[] objectPaths = new Path[7];

    //形状区域检测

    Region objectRegion = new Region();



    //小圆球区域

    Region circleRegion = new Region();

    //小圆

    Path circlePath = new Path();

    //绘制区域

    Region mainRegion = new Region();



    Rect circleRect = new Rect();

    Rect objectRect = new Rect();



    float[] pos = new float[2];

    float[] tan = new float[2];



    PathMeasure pathMeasure = new PathMeasure();



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        int width = getWidth();

        int height = getHeight();

        if (width < 1 || height < 1) {

            return;

        }



        int save = canvas.save();

        canvas.translate(width / 2f, height / 2f);

        float radius = Math.min(width / 2f, height / 2f);



        mainRegion.set((int) -radius, (int) -radius, (int) radius, (int) radius);



        for (int i = 0; i < objectPaths.length; i++) {

            Path path = objectPaths[i];

            if (path == null) {

                path = new Path();

                objectPaths[i] = path;

            } else {

                path.reset();

            }

        }



        Path path = objectPaths[0];

        path.moveTo(radius / 2, -radius / 2);

        path.lineTo(0, -radius);

        path.lineTo(radius / 2, -radius);

        path.close();



        path = objectPaths[1];

        path.moveTo(-radius / 2, radius / 2);

        path.lineTo(-radius / 2 - 100, radius / 2);

        path.arcTo(-radius / 2 - 100, radius / 2, -radius / 2, radius / 2 + 100, 0, 180, false);

        path.lineTo(-radius / 2, radius / 2);

        path.close();



        path = objectPaths[2];

        path.addCircle(-radius + 200f, -radius + 200f, 50f, Path.Direction.CCW);



        path = objectPaths[3];

        path.addRoundRect(-radius + 50, -radius / 2, -radius  + 90, 0, 10, 10, Path.Direction.CCW);



        path = objectPaths[4];

        path.addRect(120, 120, 200, 200, Path.Direction.CCW);



        path = objectPaths[5];

        path.addCircle(250, 0, 100, Path.Direction.CCW);



        Path tmp = new Path();

        tmp.addCircle(250,-80,80,Path.Direction.CCW);

        path.op(tmp, Path.Op.DIFFERENCE);



        tmp.reset();

        path = objectPaths[6];

        path.addCircle(0, 0, 100, Path.Direction.CCW);

        tmp.addCircle(0, 0, 80, Path.Direction.CCW);

        path.op(tmp, Path.Op.DIFFERENCE);





        circlePath.reset();

        circlePath.addCircle(x- width/2f,y - height/2f,20, Path.Direction.CCW);

        circleRegion.setPath(circlePath,mainRegion);





        mCommonPaint.setColor(Color.CYAN);

        for (int i = 0; i < objectPaths.length; i++) {

            objectRegion.setPath(objectPaths[i],mainRegion);

            if(!objectRegion.quickReject(circleRegion)){

                if (circleRegion.getBounds(circleRect)

                        && objectRegion.getBounds(objectRect)) {



                    Region regionChecker = null;

                    if (circleRect.width() * circleRect.height() > objectRect.width() * objectRect.height()) {

                        pathMeasure.setPath(objectPaths[i], false);

                        regionChecker = circleRegion;

                    } else {

                        pathMeasure.setPath(circlePath, false);

                        regionChecker = objectRegion;

                    }



                    for (int len = 0; len < pathMeasure.getLength(); len++) {

                        pathMeasure.getPosTan(len, pos, tan);

                        if(regionChecker.contains((int) pos[0], (int) pos[1])){

                            Log.d("RegionView"," 可能发生了碰撞");

                            mCommonPaint.setColor(Color.YELLOW);

                        }

                    }



                }



            }else{

                mCommonPaint.setColor(Color.CYAN);

            }

            canvas.drawPath(objectPaths[i], mCommonPaint);

        }



        mCommonPaint.setColor(Color.WHITE);

        canvas.drawPath(circlePath,mCommonPaint);

        canvas.restoreToCount(save);

    }



    @Override

    public void dispatchDrawableHotspotChanged(float x, float y) {

        super.dispatchDrawableHotspotChanged(x, y);

        this.x = x;

        this.y = y;

        postInvalidate();

    }



    @Override

    protected void dispatchSetPressed(boolean pressed) {

        super.dispatchSetPressed(pressed);

        postInvalidate();

    }



    public float dp2px(float dp) {

        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, mDM);

    }



    public static int argb(float red, float green, float blue) {

        return ((int) (1 * 255.0f + 0.5f) << 24) |

                ((int) (red * 255.0f + 0.5f) << 16) |

                ((int) (green * 255.0f + 0.5f) << 8) |

                (int) (blue * 255.0f + 0.5f);

    }





}

Android原生ProgressBar

原生ProgressBar样式比较固定，主要是圆形和线条；也可以通过style来设置样式。

style：

原生的特点就是单调，实现基本的功能，使用简单样式不复杂；要满足我们期望的效果就只能自定义View了。

自定义ProgressBar

自定义View的实现方式有很多种，继承已有的View，如ImageView，ProgressBar等等；也可以直接继承自View，在onDraw中绘制需要的效果。
要实现的效果是一个横向圆角矩形进度条，内容为渐变色。
所以在设计时要考虑到可以定义的属性：渐变色、进度等。

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <declare-styleable name="progress">

        <attr name="progress" format="float" />

        <attr name="startColor" format="color" />

        <attr name="endColor" format="color" />

    </declare-styleable>

</resources>

View实现

这里直接继承子View，读取属性，在onDraw中绘制进度条。实现思路是通过定义Path来绘制裁切范围，确定绘制内容；再实现线性渐变LinearGradient来填充进度条。然后监听手势动作onTouchEvent，动态绘制长度。

同时开放公共方法，可以动态设置进度颜色，监听进度回调，根据需求实现即可。

package com.cs.app.view



/**

 *

 */

import android.content.Context

import android.graphics.Canvas

import android.graphics.Color

import android.graphics.LinearGradient

import android.graphics.Paint

import android.graphics.Path

import android.graphics.RectF

import android.graphics.Shader

import android.util.AttributeSet

import android.view.View

import com.cs.app.R



class CustomProgressView(context: Context, attrs: AttributeSet?) : View(context, attrs) {

    private val progressPaint = Paint()

    private val backgroundPaint = Paint()

    private var progress = 50f

    private var startColor = Color.parseColor("#4C87B7")

    private var endColor = Color.parseColor("#A3D5FE")

    private var x = 0f

    private var progressCallback: ProgressChange? = null



    init {

        // 初始化进度条画笔

        progressPaint.isAntiAlias = true

        progressPaint.style = Paint.Style.FILL



        // 初始化背景画笔

        backgroundPaint.isAntiAlias = true

        backgroundPaint.style = Paint.Style.FILL

        backgroundPaint.color = Color.GRAY



        if (attrs != null) {

            val typedArray = context.obtainStyledAttributes(attrs, R.styleable.progress)

            startColor = typedArray.getColor(R.styleable.progress_startColor, startColor)

            endColor = typedArray.getColor(R.styleable.progress_endColor, endColor)

            progress = typedArray.getFloat(R.styleable.progress_progress, progress)

            typedArray.recycle()

        }

    }



    override fun onDraw(canvas: Canvas) {

        super.onDraw(canvas)



        val width = width.toFloat()

        val height = height.toFloat()



        //绘制Path，限定Canvas边框

        val path = Path()

        path.addRoundRect(0f, 0f, width, height, height / 2, height / 2, Path.Direction.CW)

        canvas.clipPath(path)



        //绘制进度条

        val progressRect = RectF(0f, 0f, width * progress / 100f, height)

        val colors = intArrayOf(startColor, endColor)

        val shader = LinearGradient(0f, 0f, width * progress / 100f, height, colors, null, Shader.TileMode.CLAMP)

        progressPaint.shader = shader

        canvas.drawRect(progressRect, progressPaint)

    }



    override fun onTouchEvent(event: android.view.MotionEvent): Boolean {

        when (event.action) {

            android.view.MotionEvent.ACTION_DOWN -> {

                x = event.rawX

                

                //实现点击调整进度

                progress = (event.rawX - left) / width * 100

                progressCallback?.onProgressChange(progress)

                invalidate()

            }



            android.view.MotionEvent.ACTION_MOVE -> {

                //实现滑动调整进度

                progress = (event.rawX - left) / width * 100

                progress = if (progress < 0) 0f else if (progress > 100) 100f else progress

                progressCallback?.onProgressChange(progress)

                invalidate()

            }



            else -> {}

        }

        return true

    }



    fun setProgress(progress: Float) {

        this.progress = progress

        invalidate()

    }



    fun setOnProgressChangeListener(callback: ProgressChange) {

        progressCallback = callback

    }



    interface ProgressChange {

        fun onProgressChange(progress: Float)

    }

}

示例

class CustomViewActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_custom_view)

        val progressTv: TextView = findViewById(R.id.progress_textview)

        val view: CustomProgressView = findViewById(R.id.progress)

        view.setProgress(50f)



        view.setOnProgressChangeListener(object : CustomProgressView.ProgressChange {

            override fun onProgressChange(progress: Float) {

                progressTv.text = "${progress.toInt()}%"

            }

        })

    }

}

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    android:layout_width="match_parent"

    android:background="#0E1D3C"

    android:layout_height="match_parent">



    <com.cs.app.view.CustomProgressView

        android:id="@+id/progress"

        android:layout_width="200dp"

        android:layout_height="45dp"

        app:endColor="#A3D5FE"

        app:layout_constraintBottom_toBottomOf="parent"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toTopOf="parent"

        app:layout_constraintVertical_bias="0.274"

        app:progress="60"

        app:startColor="#4C87B7" />



    <TextView

        android:id="@+id/progress_textview"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:layout_marginTop="100dp"

        android:textColor="#ffffff"

        app:layout_constraintEnd_toEndOf="parent"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toBottomOf="@+id/progress" />

</androidx.constraintlayout.widget.ConstraintLayout>

效果如下：

现在大部分网站都有扫码登录功能，搭配相应的App就能免去输入账号密码实现快速登录。本文简单介绍如何实现扫码登录功能。

实现扫码登录

之前参与过一个电视App的开发，采用扫码登录，需要使用配套的App扫码登录后才能进入到主页。那么扫码登录该怎么实现呢？大致流程如下：

PS: 此为大致流程，具体使用需要根据实际需求进行调整。

接下来简单演示一下此流程。

添加依赖库

添加需要的SDK依赖库，在项目app module的build.gradle中的dependencies中添加依赖:

dependencies { 

    // 实现服务端（http、socket）

    implementation("org.nanohttpd:nanohttpd:2.3.1") 

    implementation("org.nanohttpd:nanohttpd-websocket:2.3.1")

    

    // 与服务端通信

    implementation("com.squareup.okhttp3:okhttp:4.12.0")

    

    // 扫描解析、生成二维码

    implementation("com.github.jenly1314:zxing-lite:3.1.0")

}

服务端

使用NanoHttpD实现Socket服务端（与被扫端通信）和Http服务端（与扫码端通信），示例代码如下：

Socket服务

与被扫端保持通讯，在Http服务接收并处理完扫码登录请求后，将获取到的用户id发送给被扫端。

class ServerSocketClient : NanoWSD(9090) {



    private var serverWebSocket: ServerWebSocket? = null



    override fun openWebSocket(handshake: IHTTPSession?): WebSocket {

        return ServerWebSocket(handshake).also { serverWebSocket = it }

    }



    private class ServerWebSocket(handshake: IHTTPSession?) : WebSocket(handshake) {

        override fun onOpen() {}



        override fun onClose(code: WebSocketFrame.CloseCode?, reason: String?, initiatedByRemote: Boolean) {}



        override fun onMessage(message: WebSocketFrame?) {}



        override fun onPong(pong: WebSocketFrame?) {}



        override fun onException(exception: IOException?) {}

    }



    override fun stop() {

        super.stop()

        serverWebSocket = null

    }



    fun sendMessage(message: String) {

        serverWebSocket?.send(message)

    }

}

Http服务

接收并处理来自扫码端的扫码登录请求，通过设备id和用户id判断被扫端是否可以登录。

const val APP_SCAN_INTERFACE = "loginViaScan"



const val USER_ID = "userId"

const val EXAMPLE_USER_ID = "123456789"



const val DEVICE_ID = "deviceId"

const val EXAMPLE_DEVICE_ID = "example_device_id0001"



class ServerHttpClient(private var scanLoginSucceedListener: ((userId: String) -> Unit)? = null) : NanoHTTPD(8080) {



    override fun serve(session: IHTTPSession?): Response {

        val uri = session?.uri

        return if (uri == "/$APP_SCAN_INTERFACE" &&

            session.parameters[USER_ID]?.first() == EXAMPLE_USER_ID &&

            session.parameters[DEVICE_ID]?.first() == EXAMPLE_DEVICE_ID

        ) {

            scanLoginSucceedListener?.invoke(session.parameters[USER_ID]?.first() ?: "")

            newFixedLengthResponse("Login Succeed")

        } else {

            super.serve(session)

        }

    }

}

服务控制类

启动或停止Socket服务和Http服务。

object ServerController {



    private var serverSocketClient: ServerSocketClient? = null

    private var serverHttpClient: ServerHttpClient? = null



    fun startServer() {

        (serverSocketClient ?: ServerSocketClient().also {

            serverSocketClient = it

        }).run {

            if (!isAlive) {

                start(0)

            }

        }



        (serverHttpClient ?: ServerHttpClient {

            serverSocketClient?.sendMessage("Login Succeed, user id is $it")

        }.also {

            serverHttpClient = it

        }).run {

            if (!isAlive) {

                start(NanoHTTPD.SOCKET_READ_TIMEOUT, true)

            }

        }

    }



    fun stopServer() {

        serverSocketClient?.stop()

        serverSocketClient = null



        serverHttpClient?.stop()

        serverHttpClient = null

    }

}

被扫端

Socket辅助类

使用OkHttp与服务端进行Socket通信。

class DevicesSocketHelper(private val messageListener: ((message: String) -> Unit)? = null) {



    private var webSocket: WebSocket? = null



    private val webSocketListener = object : WebSocketListener() {

        override fun onMessage(webSocket: WebSocket, bytes: ByteString) {

            super.onMessage(webSocket, bytes)

            messageListener?.invoke(bytes.utf8())

        }



        override fun onMessage(webSocket: WebSocket, text: String) {

            super.onMessage(webSocket, text)

            messageListener?.invoke(text)

        }

    }



    fun openSocketConnection(serverPath: String) {

        val okHttpClient = OkHttpClient.Builder()

            .connectTimeout(120, TimeUnit.SECONDS)

            .readTimeout(120, TimeUnit.SECONDS)

            .build()

        val request = Request.Builder().url(serverPath).build()

        webSocket = okHttpClient.newWebSocket(request, webSocketListener)

    }



    fun release() {

        webSocket?.close(1000, "")

        webSocket = null

    }

}