免责声明

本次技术分享仅用于逆向技术的交流与学习，请勿用于其他非法用途；技术是把双刃剑，请善用它。

逆向是什么、可以做什么、怎么做

• 简单讲，就是将别人打包好的 apk 进行反编译，得到源码并分析代码逻辑，最终达成自己的目的。


• 可以做的事：
  
  
  
  
  • 修改 smali 文件，使程序达到自己想要的效果，重新编译签名安装，如去广告、自动化操作、电商薅羊毛、单机游戏修改数值、破解付费内容、汉化、抓包等
  
  
  • 阅读源码，借鉴别人写好的技术实践
  
  
  • 破解：小组件盒子：http://www.coolapk.com/apk/io.ifte…
  
  
  
  


• 怎么做：
  
  
  
  
  • 这是门庞杂的技术活，需要知识的广度、经验、深度
  
  
  • 需要具体问题，具体分析，有针对性的学习与探索
  
  
  • 了解打包原理、ARM、Smali汇编语言
  
  
  • 加固、脱壳
  
  
  • Xposed、Substrate、Fridad等框架
  
  
  • 加解密
  
  
  • 使用好工具## 今日分享涉及工具
  
  
  
  


• apktool：反编译工具
  
  
  
  
  • 反编译：apktool d <apkPath> o <outputPath>
  
  
  • 重新打包：apktool b <fileDirPath> -o <apkPath>
  
  
  • 安装：brew install apktool
  
  
  
  


• jadx：支持命令行和图形界面，支持apk、dex、jar、aar等格式的文件查看
  
  
  
  
  • github.com/skylot/jadx
  
  
  
  


• apksigner：签名工具
  
  
  
  
  • developer.android.com/studio/comm…
  
  
  
  


• Charles：抓包工具
  
  
  
  
  • http://www.charlesproxy.com/
  
  
  • Android 7 以上抓包 HTTPS ，需要手机 Root 后将证书安装到系统中
  
  
  • Android 7 以下 HTTPS 直接抓
  
  
  
  

正题

• 正向编译
  
  
  
  
  • java -> class -> dex -> apk
  
  
  
  


• 反向编译
  
  
  
  
  • apk -> dex -> smali -> java
  
  
  
  


• Smali 是 Android 的 Dalvik 虚拟机所使用的一种 dex 格式的中间语言


• 官方文档source.android.com/devices/tec…


• code.flyleft.cn/posts/ac692…


• 正题开始，以反编译某瓣App为例：
  
  
  
  
  • jadx 查看 Java 源码，找到想修改的代码
  
  
  • 反编译得到 smali 源码：apktool d douban.apk -o doubancode --only-main-classes
  
  
  • 修改：找到 debug 界面入口并打开
  
  
  • 将修改后的 smali 源码正向编译成 apk：apktool b doubancode -o douban_mock1.apk
  
  
  • 重签名：jarsigner -verbose -keystore keys.jks test.apk key0
  
  
  • 此时的包不能正常访问接口，因为豆瓣 API 做了签名校验，而我们的新 apk 是用了新的签名，看接口抓包
  
  
  • 怎么办呢？
  
  
  • 继续分析代码，修改网络请求中的 apikey
  
  
  • 来看看新的 apk
  
  
  
  


• 也可以做爬虫等

启发与防范

• 混淆


• 加固


• 加密


• 运行环境监测


• 不写敏感信息或操作到客户端


• App 运行签名验证


• Api 接口签名验证

One More Thing

• 工具分享：code.flyleft.cn/posts/3e3d8…


• 书籍分享：book.douban.com/subject/205…


• 进阶(下次分享)：
  
  
  
  
  • 静态调试
  
  
  • 动态调试
  
  
  • 脱壳
  
  
  • NDK你想
  
  
  • so文件修改
  
  
  
  

Jetpack Compose 是个啥？为啥要学它？

谷歌对 Jetpack Compose 的定义：

Jetpack Compose 是推荐用于构建原生 Android 界面的新工具包。它可简化并加快 Android 上的界面开发，使用更少的代码、强大的工具和直观的 Kotlin API，快速打造生动而精彩的应用。

提取关键词：界面开发新工具包、简化并加快界面开发、Kotlin API。

对于大部分Android项目来说，如果基础库(如网络库、hybird、图片加载、热修复库等)已经搭好，那么平时大部分时间就是跟 UI界面、需求逻辑 打交道了，而谷歌提供的 Jetpack Compose 正好是加快界面开发的工具包。

就跟魂斗罗里的子弹类型似的，使用普通子弹(XML方式)也可以通关，但是相比之下耗时更长；而换成超级子弹(Jetpack Compose)体验就不一样了，耗时更少，而且游戏体验更爽！

命令式UI vs 声明式UI

长期以来，Android 视图层次结构一直可以表示为界面 widget 树。最常见的界面更新方式是使用 findViewById() 等函数遍历树，并通过调用 button.setText(String)、container.addChild(View) 或 img.setImageBitmap(Bitmap) 等方法更改节点。这些方法会改变 widget 的内部状态，这种手动更新UI的方式即是命令式UI。

在过去的几年中，整个行业已开始转向声明性界面模型，该模型大大简化了与构建和更新界面关联的工程任务。该技术的工作原理是在概念上从头开始重新生成整个屏幕，然后仅执行必要的更改。此方法可避免手动更新有状态视图层次结构的复杂性。Compose 即是一个声明式UI框架。

Jetpack Compose要学起来了？

很遗憾，Jetpack Compose 确实要学起来了（快起来，你还能学！哈哈...），随着Jetpack Compose 版本的不断迭代，API 逐渐稳定了，性能也越来越好了。

• 更少的代码：编写代码只需要采用Kotlin，而不用拆分成 Kotlin + XML方式了。


• 直观：只需描述界面，Compose会负责处理剩余工作。应用状态变化时，界面自动更新。


• 加速开发：View 与 Compose 之间可以相互调用，兼容现有的所有代码。借助AS可以实时预览界面，轻松执行界面检查。


• 功能强大：直接访问Android API，内置对Material Design、主题、动画等的支持。

Jetpack Compose vs Flutter

• Jetpack Compose的目的是为了提高 Android 原生的 UI 开发效率！声明式UI已经成为主流的开发方式了，就像当初谷歌将Kotlin定为Android主流语言时我们学习Kotlin一样，未来Jetpack Compose 一定会是Android UI开发的主流方式。


• Flutter 的定位是多平台 UI 框架，优势在于跨平台。

大家很喜欢把Jetpack Compose 和 Flutter作对比，不知道该学哪一个？的确，某些场景下它们确实挺像的，而且还都是谷歌在推的。

个人理解是：如果你未来的主攻方向还是Android，那么无脑选择Jetpack Compose，虽然Compose目前也能实现跨端，但跨端目前看并不是它的主要工作；而如果你的方向是多平台开发，那么学习Flutter是首选吧。

另外，与其一直纠结学哪一个，不如直接上手亲身感受下它们的不同，正所谓 “纸上得来终觉浅，绝知此事要躬行”。

Jetpack Compose入门

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContent {

            Text("Hello World!")

        }

    }

}

其中，setContent()传入一个@Composable作用域，其作用跟之前的setContentView()一样用来设置界面。Text()用来描述一个UI元素，里面有各种参数，这里我们只把文案填上去，执行结果：

一个最简单的功能就完成了。

1、@Composable 可组合函数

还是上述展示一个文本的功能，我们换一种写法：

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContent {

            MessageCard("Android")

        }

    }

}



@Composable

fun MessageCard(name: String) {

    Text(text = "Hello $name!")

}

执行效果跟上面一样。唯一的区别就是把文本展示单独抽离到一个方法中了，并且该方法上面加了@Composable 注解：

@Composable注解用于标记一个函数为可组合函数。可组合函数是一种特殊的函数，不需要返回任何UI元素，因为可组合函数描述的是所需的屏幕状态，而不是构造界面widget；而如果按我们以前的XML编程方式，必须在方法中返回UI元素才能使用它（如返回View类型）。

@Composable注解的函数之间可以相互调用，因为这样Compose框架才能正确处理依赖关系。另外，@Composable函数中也可以调用普通函数，而普通函数中却不能直接调用@Composable函数。 这里可以类比下kotlin中suspend挂起函数的用法，其用法是相似的。

几个定义：

• 组合：对 Jetpack Compose 在执行可组合项时所构建界面的描述。


• 初始组合：通过首次运行可组合项创建组合。


• 重组：在数据发生变化时重新运行可组合项以更新组合。

可组合函数的特点：

• 使用同一参数多次调用此函数时，它的行为方式相同，并且它不使用其他值，如全局变量或对 random() 的调用。


• 此函数描述界面而没有任何副作用，如修改属性或全局变量、点击事件的处理等。当需要执行附带效应时，应通过回调触发。如：

@Composable

private fun NamePickerItem(name: String, onClicked: (String) -> Unit) {

    Text(name, Modifier.clickable(onClick = { onClicked(name) }))

}

可见通过回调，点击事件这个附带效应是在调用方触发的。

在编译时，Jetpack Compose会将标记为@Composable的函数编译成字节码，并生成一个专门的ComposeNode类来管理其状态和属性。这个类会自动处理依赖关系，并在需要时计算UI元素。这样，开发者就可以专注于编写UI逻辑，而不用担心状态管理和UI更新的细节。

这里引出一个问题，Compose 是如何做 UI 更新的呢？总不能每次有一小部分数据的变化，整个UI都要跟着刷新一次吧，那性能肯定差的要死。其实，当有数据变化时，Compose实现的是增量更新，只会重新绘制数据有改动的UI（该过程称为重组），数据没有改动的则不会重新绘制了。

2、布局基础知识

Compose 通过元素组合、布局、绘制之后可以将状态转换为UI元素。

组合

在 Compose 中，可以通过从可组合函数中调用其他可组合函数来构建界面层次结构。

如图所示：

• Column ：可以将多个项垂直地放置在屏幕上；


• Row ：可以将多个项水平地放置在屏幕上；


• Box ：可将元素放在其他元素上，还支持为其包含的元素配置特定的对齐方式。

排列及对齐方式：

/**

 * @param verticalArrangement 竖直排列方式

 * @param horizontalAlignment 水平对齐方式

 */

inline fun Column(

    modifier: Modifier = Modifier,

    verticalArrangement: Arrangement.Vertical = Arrangement.Top,

    horizontalAlignment: Alignment.Horizontal = Alignment.Start,

    content: @Composable ColumnScope.() -> Unit

) {...}



/**

 * @param horizontalArrangement 水平排列方式

 * @param verticalAlignment 竖直对齐方式

 */

@Composable

inline fun Row(

    modifier: Modifier = Modifier,

    horizontalArrangement: Arrangement.Horizontal = Arrangement.Start,

    verticalAlignment: Alignment.Vertical = Alignment.Top,

    content: @Composable RowScope.() -> Unit

) {...}



/**

 * @param contentAlignment 内容对齐方式

 */

@Composable

inline fun Box(

    modifier: Modifier = Modifier,

    contentAlignment: Alignment = Alignment.TopStart,

    propagateMinConstraints: Boolean = false,

    content: @Composable BoxScope.() -> Unit

) {...}

verticalArrangement、horizontalArrangement 排列方式及效果：

布局

界面树布局通过单次传递即可完成。父节点会在其子节点之前进行测量，但会在其子节点的尺寸和放置位置确定之后再对自身进行调整。

当界面树较深时，Compose 可以通过只测量一次子项来实现高性能。

3、Modifier修饰符

可以通过Modifier修饰符更改可组合项的大小、布局、外观，还可以添加高级互动，例如使元素可点击等。如：

  Image(

    painter = painterResource(id = R.mipmap.icon_water_melon),

    contentDescription = "",

    modifier = Modifier

         .size(50.dp)

         .clip(CircleShape)

         .border(width = 2.dp, Color.Red, CircleShape)

   )

执行结果：，原图本身是长方形的，通过Modifier修饰符修饰后，很容易变成圆角图片。想一下如果用XML方式来写，是不是要写好多代码呢。

4、存储状态

可组合函数中可以使用 remember 将本地状态存储在内存中，并跟踪传递给 mutableStateOf 的值的变化。该值更新时，系统会自动重新绘制使用此状态的可组合项（及其子项），这也是上面所说的重组。如：

@Composable

fun MessageCard(msg: Message) {

  // We keep track if the message is expanded or not in this variable

  var isExpanded by remember { mutableStateOf(false) }

  // We toggle the isExpanded variable when we click on this Column

  Column(modifier = Modifier.clickable { isExpanded = !isExpanded }) {...}

}

当点击Column 元素时，每次都会重新执行MessageCard()可组合函数进行刷新，而通过remember和mutableStateOf可以保存了上次的isExpanded状态；如果不使用它们，重新执行 MessageCard() 时 isExpanded 也会重新初始化。

除了remember之外，还有rememberSaveable、savedStateHandle.saveable等。。。

总结

这篇文章主要讲了Compose是什么以及我们要开始学习它的必要性。作为Compose 第一篇介绍文章，本文旨在初步感受一下 Compose的能力，后续再详细研究 Compose 的精彩用法！

资料

【1】谷歌Jetpack Compose 教程：
https://developer.android.com/jetpack/compose/tutorial?hl=zh-cn

前言

最近对一个Java写的老项目进行了部分重构，测试过程中波澜不惊，顺利上线后几天通过APM平台查看发现Crash率上升了，查看堆栈定位到NPE类型的Crash，大部分发生在Java调用Kotlin的函数里，本篇将会分析具体的场景以及规避方式。

通过本篇文章，你将了解到：

1. NPE(空指针 NullPointerException)的本质


2. Java 如何预防NPE？


3. Kotlin NPE检测


4. Java/Kotlin 混合调用


5. 常见的Java/Kotlin互调场景

1. NPE(空指针 NullPointerException)的本质

变量的本质

    val name: String = "fish"

name是什么？

对此问题你可能嗤之以鼻：

不就是变量吗？更进一步说如果是在对象里声明，那就是成员变量(属性)，如果在方法(函数)里声明，那就是局部变量，如果是静态声明的，那就是全局变量。

回答没问题很稳当。

那再问为什么通过变量就能找到对应的值呢？

答案：变量就是地址，通过该地址即可寻址到内存里真正的值

无法访问的地址

如上图，若是name="fish"，表示的是name所指向的内存地址里存放着"fish"的字符串。

若是name=null，则说明name没有指向任何地址，当然无法通过它访问任何有用的信息了。

无论C/C++亦或是Java/Kotlin，如果一个引用=null，那么这个引用将毫无意义，无法通过它访问任何内存信息，因此这些语言在设计的过程中会将通过null访问变量/方法的行为都会显式(抛出异常)提醒开发者。

2. Java 如何预防NPE？

运行时规避

先看Demo：

public class TestJava {

   public static void main(String args[]) {

      (new TestJava()).test();

   }



   void test() {

      String str = getString();

      System.out.println(str.length());

   }



   String getString() {

      return null;

   }

}

执行上述代码将会抛出异常，导致程序Crash：

1. try...catch


2. 对象判空

try...catch 方式

public class TestJava {

    public static void main(String args[]) {

        (new TestJava()).testTryCatch();

    }



    void testTryCatch() {

        try {

            String str = getString();

            System.out.println(str.length());

        } catch (Exception e) {

        }

    }



    String getString() {

        return null;

    }

}

NPE被捕获，程序没有Crash。

对象判空

public class TestJava {

    public static void main(String args[]) {

        (new TestJava()).testJudgeNull();

    }



    void testJudgeNull() {

        String str = getString();

        if (str != null) {

            System.out.println(str.length());

        }

    }



    String getString() {

        return null;

    }

}

因为提前判空，所以程序没有Crash。

编译时检测

在运行时再去做判断的缺点：

无法提前发现NPE问题，想要覆盖大部分的场景需要随时try...catch或是判空
总有忘记遗漏的时候，发布到线上就是个生产事故

那能否在编译时进行检测呢？

答案是使用注解。

public class TestJava {

    public static void main(String args[]) {

        (new TestJava()).test();

    }



    void test() {

        String str = getString();

        System.out.println(str.length());

    }



    @Nullable String getString() {

        return null;

    }

}

在编写getString()方法时发现其可能为空，于是给方法加上一个"可能为空"的注解：@Nullable

当调用getString()方法时，编译器给出如下提示：

意思是访问的getString()可能为空，最后访问String.length()时可能会抛出NPE。

看到编译器的提示我们就知道此处有NPE的隐患，因此可以针对性的进行处理(try...catch或是判空)。

当然此处的注解仅仅只是个"弱提示"，你即使没有进行针对性的处理也能编译通过，只是问题最后都流转到运行时更难挽回了。

有"可空"的注解，当然也有"非空"的注解：

@Nonnull 注解修饰了方法后，若是检测到方法返回null，则会提示修改，当然也是"弱提示"。

3. Kotlin NPE检测

编译时检测

Kotlin 核心优势之一：

空安全检测，变量分为可空型/非空型，能够在编译期检测潜在的NPE，并强制开发者确保类型一致，将问题在编译期暴露并解决

先看非空类型的变量声明：

class TestKotlin {



    fun test() {

        val str = getString()

        println("${str.length}")

    }



    private fun getString():String {

        return "fish"

    }

}



fun main() {

    TestKotlin().test()

}

此种场景下，我们能确保getString()函数的返回一定非空，因此在调用该函数时无需进行判空也无需try...catch。

你可能会说，你这里写死了"fish"，那我写成null如何？

编译期直接提示不能这么写，因为我们声明getString()的返回值为String，是非空的String类型，既然声明了非空，那么就需要言行一致，返回的也是非空的。

有非空场景，那也得有空的场景啊：

class TestKotlin {



    fun test() {

        val str = getString()

        println("${str.length}")

    }



    private fun getString():String? {

        return null

    }

}



fun main() {

    TestKotlin().test()

}

此时将getString()声明为非空，因此可以在函数里返回null。

然而调用之处就无法编译通过了：

意思是既然getString()可能返回null，那么就不能直接通过String.length访问，需要改为可空方式的访问：

class TestKotlin {



    fun test() {

        val str = getString()

        println("${str?.length}")

    }



    private fun getString():String? {

        return null

    }

}

str?.length 意思是：如果str==null，就不去访问其成员变量/函数，若不为空则可以访问，于是就避免了NPE问题。

由此可以看出：

Kotlin 通过检测声明与实现，确保了函数一定要言行一致（声明与实现），也确保了调用者与被调用者的言行一致

因此，若是用Kotlin编写代码，我们无需花太多时间去预防和排查NPE问题，在编译期都会有强提示。

4. Java/Kotlin 混合调用

回到最初的问题：既然Kotlin都能在编译期避免了NPE，那为啥使用Kotlin重构后的代码反而导致Crash率上升呢？

原因是：项目里同时存在了Java和Kotlin代码，由上可知两者在NPE的检测上有所差异导致了一些兼容问题。

Kotlin 调用 Java

调用无返回值的函数

Kotlin虽然有空安全检测，但是Java并没有，因此对于Java方法来说，不论你传入空还是非空，在编译期我都没法检测出来。

public class TestJava {

    void invokeFromKotlin(String str) {

        System.out.println(str.length());

    }

}

class TestKotlin {



    fun test() {

        TestJava().invokeFromKotlin(null)

    }

}



fun main() {

    TestKotlin().test()

}

如上无论是Kotlin调用Java还是Java之间互调，都没法确保空安全，只能由被调用者(Java)自己处理可能的异常情况。

调用有返回值的函数

public class TestJava {

    public String getStr() {

        return null;

    }

}

class TestKotlin {

    fun testReturn() {

        println(TestJava().str.length)

    }

}



fun main() {

    TestKotlin().testReturn()

}

如上，Kotlin调用Java的方法获取返回值，由于在编译期Kotlin无法确定返回值，因此默认把它当做非空处理，若是Java返回了null，那么将会Crash。

Java 调用 Kotlin

调用无返回值的函数

先定义Kotlin类：

class TestKotlin {



    fun testWithoutNull(str: String) {

        println("len:${str.length}")

    }



    fun testWithNull(str: String?) {

        println("len:${str?.length}")

    }

}

有两个函数，分别接收可空/非空参数。

在Java里调用，先调用可空函数：

public class TestJava {

    public static void main(String args[]) {

        (new TestKotlin()).testWithNull(null);

    }

}

因为被调用方是Kotlin的可空函数，因此即使Java传入了null，也不会有Crash。

再换个方式，在Java里调用非空函数：

public class TestJava {

    public static void main(String args[]) {

        (new TestKotlin()).testWithoutNull(null);

    }

}

却发现Crash了！

为什么会Crash呢？反编译查看Kotlin代码：

public final class TestKotlin {

   public final void testWithoutNull(@NotNull String str) {

      Intrinsics.checkNotNullParameter(str, "str");

      String var2 = "len:" + str.length();

      System.out.println(var2);

   }



   public final void testWithNull(@Nullable String str) {

      String var2 = "len:" + (str != null ? str.length() : null);

      System.out.println(var2);

   }

}

对于非空的函数来说，会有检测代码：

Intrinsics.checkNotNullParameter(str, "str")：

    public static void checkNotNullParameter(Object value, String paramName) {

        if (value == null) {

            throwParameterIsNullNPE(paramName);

        }

    }

    private static void throwParameterIsNullNPE(String paramName) {

        throw sanitizeStackTrace(new NullPointerException(createParameterIsNullExceptionMessage(paramName)));

    }

可以看出：

1. Kotlin对于非空的函数参数，先判断其是否为空，若是为空则直接抛出NPE


2. Kotlin对于可空的函数参数，没有强制检测是否为空

调用有返回值的函数

Java 本身就没有空安全，只能在运行时进行处理。

小结

很容看出来：

1. Java 调用Kotlin的非空函数有Crash的风险，编译器无法检查到传入的参数是否为空


2. Java 调用Kotlin的可空函数没有Crash风险，Kotlin编译期检查空安全


3. Kotlin 调用Java的函数有Crash风险，由Java代码规避风险


4. Kotlin 调用Java有返回值的函数有Crash风险，编译器无法检查到返回值是否为空

回到文章的标题，我们已经大致知道了Java切换到Kotlin，为啥Crash就升上了的原因了，接下来再详细分析。

5. 常见的Java/Kotlin互调场景

Android里的Java代码分布

在Kotlin出现之前，Java就是Android开发的唯一语言，Android Framework、Androidx很多是Java代码编写的，因此现在依然有很多API是Java编写的。

而不少的第三方SDK因为稳定性、迁移代价的考虑依然使用的是Java代码。

我们自身项目里也因为一些历史原因存在Java代码。

以下讨论的前提是假设现有Java代码我们都无法更改。

Kotlin 调用Java获取返回值

由于编译期无法判定Java返回的值是空还是非空，因此若是确认Java函数可能返回空，则可以通过在Kotlin里使用可空的变量接收Java的返回值。

class TestKotlin {

    fun testReturn() {

        val str: String? = TestJava().str

        println(str?.length)

    }

}



fun main() {

    TestKotlin().testReturn()

}

Java 调用Kotlin函数

LiveData Crash的原因与预防

之前已经假设过我们无法改动Java代码，那么Java调用Kotlin函数的场景只有一个了：回调。

上面的有返回值场景还是比较容易防备，回调的场景就比较难发现，尤其是层层封装之后的代码。

这也是特别常见的场景，典型的例子如LiveData。

Crash原因

class TestKotlin(val lifecycleOwner: LifecycleOwner) {

    val liveData: MutableLiveData = MutableLiveData()

    fun testLiveData() {

        liveData.observe(lifecycleOwner) {

            println(it.length)

        }

    }



    init {

        testLiveData()

    }

}

如上，使用Kotlin声明LiveData，其类型是非空的，并监听LiveData的变化。

在另一个地方给LiveData赋值：

TestKotlin(this@MainActivity).liveData.value = null

虽然LiveData的监听和赋值的都是使用Kotlin编写的，但不幸的是还是Crash了。

发送和接收都是用Kotlin编写的，为啥还会Crash呢？

看看打印：

意思是接收到的字符串是空值(null)，看看编译器提示：

原来此处的回调传入的值被认为是非空的，因此当使用it.length访问的时候编译器不会有空安全提示。

再看看调用的地方：

可以看出，这回调是Java触发的。

Crash 预防

第一种方式：

我们看到LiveData的数据类型是泛型，因此可以考虑在声明数据的时候定为非空：

class TestKotlin(val lifecycleOwner: LifecycleOwner) {

    val liveData = MutableLiveData()

    fun testLiveData() {

        liveData.observe(lifecycleOwner) {

            println(it?.length)

        }

    }



    init {

        testLiveData()

    }

}

如此一来，当访问it.length时编译器就会提示可空调用。

第二种方式：

不修改数据类型，但在接收的地方使用可空类型接收：

class TestKotlin(val lifecycleOwner: LifecycleOwner) {

    val liveData = MutableLiveData()

    fun testLiveData() {

        liveData.observe(lifecycleOwner) {

            val dataStr:String? = it

            println(dataStr?.length)

        }

    }



    init {

        testLiveData()

    }

}

第三种方式：

使用Flow替换LiveData。

LiveData 修改建议：

1. 若是新写的API，建议使用第三种方式


2. 若是修改老的代码，建议使用第一种方式，因为可能有多个地方监听LiveData值的变化，如果第一种方式的话需要写好几个地方。

其它场景的Crash预防：

与后端交互的数据结构
比如与后端交互声明的类，后端有可能返回null，此时在客户端接收时若是使用了非空类型的字段去接收，那么会发生Crash。

通常来说，我们会使用网络框架（如retrofit）接收数据，数据的转换并不是由我们控制，因此无法使用针对LivedData的第二种方式。

有两种方式解决：

1. 与后端约定，不能返回null（等于白说）


2. 客户端声明的类的字段声明为可空（类似针对LivedData的第一种方式）

Json序列化/反序列化

Json字符串转换为对象时，有些字段可能为空，也需要声明为可空字段。

小结

在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<String, Object> 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。

今日分享到此结束，对你有帮助的话，点个赞再走呗，每日一个面试小技巧

关注公众号：Android老皮

解锁  《Android十大板块文档》 ，让学习更贴近未来实战。已形成PDF版

内容如下：

1.Android车载应用开发系统学习指南（附项目实战）

2.Android Framework学习指南，助力成为系统级开发高手

3.2023最新Android中高级面试题汇总+解析，告别零offer

4.企业级Android音视频开发学习路线+项目实战（附源码）

5.Android Jetpack从入门到精通，构建高质量UI界面

6.Flutter技术解析与实战，跨平台首要之选

7.Kotlin从入门到实战，全方面提升架构基础

8.高级Android插件化与组件化（含实战教程和源码）

9.Android 性能优化实战+360°全方面性能调优

10.Android零基础入门到精通，高手进阶之路

在 Android 应用开发中，网络请求必不可少，如何去封装才能使自己的请求代码显得更加简洁优雅，更加方便于以后的开发呢？这里利用 Kotlin 的函数式编程和 Retrofit 来从零开始封装一个网络请求框架，下面就一起来瞧瞧吧！

首先，引入网络请求框架的依赖。

implementation 'com.squareup.okhttp3:okhttp:4.9.1'

implementation 'com.squareup.okhttp3:logging-interceptor:4.9.1'

implementation 'com.squareup.retrofit2:retrofit:2.9.0'

implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

定义拦截器

我们可以先自定义一些拦截器，对一些公共提交的字段做封装，比如 token。在服务器注册成功或者登录成功之后获取 token，过期之后便无法正常请求接口，所以需要在请求接口时判断 token 是否过期，由于接口众多，不可能每个接口都进行判断，所以需要全局设置一个拦截器判断 token。

class TokenInterceptor : Interceptor {



    override fun intercept(chain: Interceptor.Chain): Response {

        // 当前拦截器中收到的请求对象

        val request = chain.request()

        // 执行请求

        var response = chain.proceed(request)

        if (response.body == null) {

            return response

        }

        val mediaType = response.body!!.contentType() ?: return response

        val type = mediaType.toString()

        if (!type.contains("application/json")) {

            return response

        }

        val result = response.body!!.string()

        var code = ""

        try {

            val jsonObject = JSONObject(result)

            code = jsonObject.getString("code")

        } catch (e: Exception) {

            e.printStackTrace()

        }

        // 重新构建 response

        response = response.newBuilder().body(result.toResponseBody(null)).code(200).build()

        if (isTokenExpired(code)) {

            // token 过期，需要获取新的 token

            val newToken = getNewToken() ?: return response

            // 重新构建新的 token 请求

            val builder = request.url.newBuilder().setEncodedQueryParameter("token", newToken)

            val newRequest = request.newBuilder().method(request.method, request.body)

                .url(builder.build()).build()

            return chain.proceed(newRequest)

        }

        return response

    }



    // 判断 token 是否过期

    private fun isTokenExpired(code: String) =

        TextUtils.equals(code, "401") || TextUtils.equals(code, "402")



    // 刷新 token

    private fun getNewToken() = ServiceManager.instance.refreshToken()



}

这里是 token 过期之后直接重新请求接口获取新的 token，这需要根据具体业务需求来，有些可能是过期之后跳转到登录页面，让用户重新登录等等。

我们还可以再定义一个拦截器，全局添加 token。

class TokenHeaderInterceptor : Interceptor {



    override fun intercept(chain: Interceptor.Chain): Response {

        var request = chain.request()

        val headers = request.headers

        var token = headers["token"]

        if (TextUtils.isEmpty(token)) {

            token = ServiceManager.instance.getToken()

            request = request.newBuilder().addHeader("token", token).build()

        }

        return chain.proceed(request)

    }

    

}

创建 retrofit

class RetrofitUtil {



    companion object {



        private const val TIME_OUT = 20L



        private fun createRetrofit(): Retrofit {



            // OkHttp 提供的一个拦截器，用于记录和查看网络请求和响应的日志信息。

            val interceptor = HttpLoggingInterceptor()

            // 打印请求和响应的所有内容，响应状态码和执行时间等等。

            interceptor.level = HttpLoggingInterceptor.Level.BODY



            val okHttpClient = OkHttpClient().newBuilder().apply {

                addInterceptor(interceptor)

                addInterceptor(TokenInterceptor())

                addInterceptor(TokenHeaderInterceptor())

                retryOnConnectionFailure(true)

                connectTimeout(TIME_OUT, TimeUnit.SECONDS)

                writeTimeout(TIME_OUT, TimeUnit.SECONDS)

                readTimeout(TIME_OUT, TimeUnit.SECONDS)

            }.build()



            return Retrofit.Builder().apply {

                addConverterFactory(GsonConverterFactory.create())

                baseUrl(ServiceManager.instance.baseHttpUrl)

                client(okHttpClient)

            }.build()



        }



        fun <T> getAPI(clazz: Class<T>): T {

            return createRetrofit().create(clazz)

        }



    }

}

网络请求封装

定义通用基础请求返回的数据结构

private const val SERVER_SUCCESS = "200"



data class BaseResp<T>(val code: String, val message: String, val data: T)



fun <T> BaseResp<T>?.isSuccess() = this?.code == SERVER_SUCCESS

请求状态流程封装，可以根据具体业务流程实现方法。

class RequestAction<T> {



    // 开始请求

    var start: (() -> Unit)? = null

        private set



    // 发起请求

    var request: (suspend () -> BaseResp<T>)? = null

        private set



    // 请求成功

    var success: ((T?) -> Unit)? = null

        private set



    // 请求失败

    var error: ((String) -> Unit)? = null

        private set



    // 请求结束

    var finish: (() -> Unit)? = null

        private set



    fun request(block: suspend () -> BaseResp<T>) {

        request = block

    }



    fun start(block: () -> Unit) {

        start = block

    }



    fun success(block: (T?) -> Unit) {

        success = block

    }



    fun error(block: (String) -> Unit) {

        error = block

    }



    fun finish(block: () -> Unit) {

        finish = block

    }



}

因为网络请求都是在 ViewModel 中进行的，我们可以定义一个 ViewModel 的扩展函数，用来处理网络请求。

fun <T> ViewModel.netRequest(block: RequestAction<T>.() -> Unit) {



    val action = RequestAction<T>().apply(block)



    viewModelScope.launch {

        try {

            action.start?.invoke()

            val result = action.request?.invoke()

            if (result.isSuccess()) {

                action.success?.invoke(result!!.data)

            } else {

                action.error?.invoke(result!!.message)

            }

        } catch (ex: Exception) {

            // 可以做一些定制化的返回错误提示

            action.error?.invoke(getErrorTipContent(ex))

        } finally {

            action.finish?.invoke()

        }

    }



}

private const val SERVER_ERROR = "HTTP 500 Internal Server Error"

private const val HTTP_ERROR_TIP = "服务器或者网络连接错误"



fun getErrorTipContent(ex: Throwable) = if (ex is ConnectException || ex is UnknownHostException

    || ex is SocketTimeoutException || SERVER_ERROR == ex.message.toString()

) HTTP_ERROR_TIP else ex.message.toString()

使用案例

定义网络请求接口

interface HttpApi {

    

    @GET("/exampleA/exampleP/exampleI/exampleApi/getNetData")

    suspend fun getNetData(@QueryMap params: HashMap<String, String>): BaseResp<NetDataBean>



    @GET("/exampleA/exampleP/exampleI/exampleApi/getTestData")

    suspend fun getTestData(

        @Query("param1") param1: String,

        @Query("param2") param2: String

    ): BaseResp<NetDataBean>



    @GET("/exampleA/exampleP/exampleI/exampleApi/{id}")

    fun getNetTask(

        @Path("id") id: String,

        @QueryMap params: HashMap<String, String>,

    ): Call<BaseResp<TaskBean>>



    @FormUrlEncoded

    @POST("/exampleA/exampleP/exampleI/exampleApi/confirm")

    suspend fun confirm(@Field("id") id: String, @Field("token") token: String): BaseResp<String>



    @FormUrlEncoded

    @POST("/exampleA/exampleP/exampleI/exampleApi/upload")

    suspend fun upload(@FieldMap params: Map<String, String>): BaseResp<String>



}

我们可以写一个网络请求帮助类，用于请求的创建。

class RequestHelper {



    private val httpApi = RetrofitUtil.getAPI(HttpApi::class.java)



    companion object {

        val instance: RequestHelper by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {

            RequestHelper()

        }

    }



    suspend fun getNetData(params: HashMap<String, String>) = httpApi.getNetData(params)



    suspend fun getTestData(branchCode: String, token: String) =

        httpApi.getTestData(branchCode, token)



    suspend fun getNetTask(id: String, params: HashMap<String, String>) =

        httpApi.getNetTask(id, params)



    suspend fun confirm(id: String, token: String) = httpApi.confirm(id, token)



    suspend fun upload(params: HashMap<String, String>) = httpApi.upload(params)



}

定义用户的意图和 UI 状态

// 定义用户意图

sealed class MainIntent {

    object FetchData : MainIntent()

}



// 定义 UI 状态

sealed class MainUIState {

    object Loading : MainUIState()

    data class NetData(val data: NetDataBean?) : MainUIState()

    data class Error(val error: String?) : MainUIState()

}

ViewModel 中做意图的处理和 UI 状态的变更，根据网络请求结果传递不同的状态，使用定义的扩展方法去执行网络请求，封装过后的网络请求就很简洁方便了，下面演示下具体使用。

class MainViewModel : ViewModel() {



    val mainIntent = Channel<MainIntent>(Channel.UNLIMITED)



    private val _mainUIState = MutableStateFlow<MainUIState>(MainUIState.Loading)

    val mainUIState: StateFlow<MainUIState>

        get() = _mainUIState



    init {

        viewModelScope.launch {

            mainIntent.consumeAsFlow().collect {

                if (it is MainIntent.FetchData) {

                    getNetDataResult()

                }

            }

        }

    }

    // 使用

    private fun getNetDataResult() = netRequest {

        start { _mainUIState.value = MainUIState.Loading }

        request {

            val paramMap = hashMapOf<String, String>()

            paramMap["param1"] = "param1"

            paramMap["param2"] = "param2"

            RequestHelper.instance.getNetData(paramMap)

        }

        success { _mainUIState.value = MainUIState.NetData(it) }

        error { _mainUIState.value = MainUIState.Error(it) }

    }

    

}

这样是不是看起来很简洁呢？接下来，Activity 负责发送意图和接收 UI 状态进行相关的处理就行啦！

class MainActivity : AppCompatActivity() {



    private val viewModel by viewModels<MainViewModel>()

    private lateinit var binding: ActivityMainBinding



    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        binding = DataBindingUtil.setContentView(this, R.layout.activity_main)

        initData()

        observeViewModel()

    }



    private fun initData() {

        lifecycleScope.launch {

            // 发送意图

            viewModel.mainIntent.send(MainIntent.FetchData)

        }

    }

    

    private fun observeViewModel() {

        lifecycleScope.launch {

            viewModel.mainUIState.collect {

                when (it) {

                    is MainUIState.Loading -> showLoading()

                    // 这里拿到网络请求返回的数据，根据业务自行操作，这里只做简单的显示。

                    is MainUIState.NetData -> showText(it.data.toString())

                    is MainUIState.Error -> showText(it.error)

                }

            }

        }

    }



    private fun showLoading() {

        binding.progressBar.visibility = View.VISIBLE

        binding.netText.visibility = View.GONE

    }



    private fun showText(result: String?) {

        binding.progressBar.visibility = View.GONE

        binding.netText.visibility = View.VISIBLE

        binding.netText.text = result

    }

    

}

文件的上传与下载

如果是文件的上传和下载呢？其实文件还不太一样，这涉及到上传进度，文件的处理等方面，所以，为了方便开发使用，我们可以针对文件单独再做一下封装。

定义文件上传对象

data class UpLoadFileBean(val file: File, val fileKey: String)

自定义 RequestBody，从中获取上传进度。

class ProgressRequestBody(

    private var requestBody: RequestBody,

    var onProgress: ((Int) -> Unit)?,

) : RequestBody() {



    private var bufferedSink: BufferedSink? = null



    override fun contentType(): MediaType? = requestBody.contentType()



    override fun contentLength(): Long {

        return requestBody.contentLength()

    }



    override fun writeTo(sink: BufferedSink) {

        if (bufferedSink == null) bufferedSink = createSink(sink).buffer()

        bufferedSink?.let {

            requestBody.writeTo(it)

            it.flush()

        }

    }



    private fun createSink(sink: Sink): Sink = object : ForwardingSink(sink) {

        // 当前写入字节数

        var bytesWritten = 0L



        // 总字节长度

        var contentLength = 0L



        override fun write(source: Buffer, byteCount: Long) {

            super.write(source, byteCount)



            if (contentLength == 0L) {

                contentLength = contentLength()

            }



            // 增加当前写入的字节数

            bytesWritten += byteCount



            CoroutineScope(Dispatchers.Main).launch {

                // 进度回调

                onProgress?.invoke((bytesWritten * 100 / contentLength).toInt())

            }

        }

    }



}

创建 MultipartBody.Part

fun <T> createPartList(action: UpLoadFileAction<T>): List<MultipartBody.Part> =

    MultipartBody.Builder().apply {

        // 公共参数 token

        addFormDataPart("token", ServiceManager.instance.getToken())



        // 其他基本参数

        action.params?.forEach {

            if (it.key.isNotBlank() && it.value.isNotBlank()) {

                addFormDataPart(it.key, it.value)

            }

        }



        // 文件校验

        action.fileData?.let {

            addFormDataPart(

                it.fileKey, it.file.name, ProgressRequestBody(

                    requestBody = it.file

                    .asRequestBody("application/octet-stream".toMediaTypeOrNull()),

                    onProgress = action.progress

                )

            )

        }

    }.build().parts

定义文件上传行为

class UpLoadFileAction<T> {



    // 请求体

    lateinit var request: (suspend () -> BaseResp<T>)

        private set



    lateinit var parts: List<MultipartBody.Part>



    // 其他普通参数

    var params: HashMap<String, String>? = null

        private set



    // 文件参数

    var fileData: UpLoadFileBean? = null

        private set



    // 初始化参数

    fun init(params: HashMap<String, String>?, fileData: UpLoadFileBean?) {

        this.params = params

        this.fileData = fileData

        parts = createPartList(this)

    }



    var start: (() -> Unit)? = null

        private set



    var success: (() -> Unit)? = null

        private set



    var error: ((String) -> Unit)? = null

        private set



    var progress: ((Int) -> Unit)? = null

        private set



    var finish: (() -> Unit)? = null

        private set



    fun start(block: () -> Unit) {

        start = block

    }



    fun success(block: () -> Unit) {

        success = block

    }



    fun error(block: (String) -> Unit) {

        error = block

    }



    fun progress(block: (Int) -> Unit) {

        progress = block

    }



    fun finish(block: () -> Unit) {

        finish = block

    }



    fun request(block: suspend () -> BaseResp<T>) {

        request = block

    }



}

同样，定义 ViewModel 的扩展函数，用来执行文件上传。

fun <T> ViewModel.upLoadFile(

    block: UpLoadFileAction<T>.() -> Unit,

    params: HashMap<String, String>?,

    fileData: UpLoadFileBean?,

) = viewModelScope.launch {

    val action = UpLoadFileAction<T>().apply(block)

    try {

        action.init(params, fileData)

        action.start?.invoke()

        val result = action.request.invoke()

        if (result.isSuccess()) {

            action.success?.invoke()

        } else {

            action.error?.invoke(result.message)

        }

    } catch (ex: Exception) {

        action.error?.invoke(getErrorTipContent(ex))

    } finally {

        action.finish?.invoke()

    }

}

定义文件上传接口

interface HttpApi {

    //...

    

    @Multipart

    @POST("/exampleA/exampleP/exampleI/exampleApi/uploadFile")

    suspend fun uploadFile(@Part partLis: List<MultipartBody.Part>): BaseResp<String>



}

在 RequestHelper 中定义上传文件方法

class RequestHelper {



    private val httpApi = RetrofitUtil.getAPI(HttpApi::class.java)



    companion object {

        val instance: RequestHelper by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {

            RequestHelper()

        }

    }

    

    //...



    suspend fun uploadFile(partList: List<MultipartBody.Part>) = httpApi.uploadFile(partList)



}

封装过后的文件上传就很简洁方便了，下面演示下具体使用。

private fun uploadMyFile() = upLoadFile(

    params = hashMapOf("param1" to "param1", "param2" to "param2"),

    fileData = UpLoadFileBean(File(absoluteFilePath), "file"),

) {

    start {

        // TODO: 开始上传，此处可以显示加载动画

    }

    request { RequestHelper.instance.uploadFile(parts) }

    success {

        // TODO: 上传成功

    }

    error {

        // TODO: 上传失败

    }

    finish {

        // TODO: 上传结束，此处可以关闭加载动画

    }

}

既然上传文件都有了，那怎么少得了下载呢？其实，下载比上传更简单，下面就来写一下，同样利用了 kotlin 的函数式编程，我们添加 ViewModel 的扩展函数，需要注意的是，由于这边是直接使用 OkHttp 的同步请求，所以把这部分代码放在了 IO 线程中。

fun ViewModel.downLoadFile(

    downLoadUrl: String,

    dirPath: String,

    fileName: String,

    progress: ((Int) -> Unit)?,

    success: (File) -> Unit,

    failed: (String) -> Unit,

) = viewModelScope.launch(Dispatchers.IO) {

    try {

        val fileDir = File(dirPath)

        if (!fileDir.exists()) {

            fileDir.mkdirs()

        }

        val downLoadFile = File(fileDir, fileName)

        val request = Request.Builder().url(downLoadUrl).get().build()

        val response = OkHttpClient.Builder().build().newCall(request).execute()

        if (response.isSuccessful) {

            response.body?.let {

                val totalLength = it.contentLength().toDouble()

                val stream = it.byteStream()

                stream.copyTo(downLoadFile.outputStream()) { currentLength ->

                    // 当前下载进度

                    val process = currentLength / totalLength * 100

                    progress?.invoke(process.toInt())

                }

                success.invoke(downLoadFile)

            } ?: failed.invoke("response body is null")

        } else failed.invoke("download failed：$response")

    } catch (ex: Exception) {

        failed.invoke("download failed：${getErrorTipContent(ex)}")

    }

}





// InputStream 添加扩展函数，实现字节拷贝。

private fun InputStream.copyTo(

    out: OutputStream,

    bufferSize: Int = DEFAULT_BUFFER_SIZE,

    progress: (Long) -> Unit,

): Long {

    var bytesCopied: Long = 0

    val buffer = ByteArray(bufferSize)

    var bytes = read(buffer)

    while (bytes >= 0) {

        out.write(buffer, 0, bytes)

        bytesCopied += bytes

        bytes = read(buffer)

        progress(bytesCopied)

    }

    return bytesCopied

}

然后，使用就会变得很简洁了，如下所示：

fun downloadMyFile(downLoadUrl: String, dirPath: String, fileName: String) =

    downLoadFile(

        downLoadUrl = downLoadUrl,

        dirPath = dirPath,

        fileName = fileName,

        progress = {

            // TODO: 这里可以拿到进度

        },

        success = {

            // TODO: 下载成功，拿到下载的文件对象 File

        },

        failed = {

            // TODO: 下载失败，返回原因

        }



    )

元宇宙虽然被炒概念，一直不温不火的，但这里面涉及的技术是比较前沿的，在游戏领域跟元宇宙的结合，如果能找到愿意投入企业，未尝不是一个不错的方向。

3. IoT物联网

万物互联方向，比如智能家居，智能创新硬件产品，类似小米IoT相关的产品，智能手环、扫地机器人等等。这里面也有庞大的市场需求，另外软硬件结合对开发人员要求更高，更接近底层。

4. 新能源车载系统

新能源车的其中一个核心就是智能中控，比如特斯拉的中控系统是Linux，比亚迪还有蔚小理和大多数造车新势力用的是Android系统，这里面也有很多车载系统应用的需求，也是很多人都求职热门方向。

5. 音视频技术领域

当下流行的短视频，涉及到的核心就是音视频技术，有这方面的技术积累的同学应该也能获得不错的发展机会，而且这方面的人才相对而言比较稀缺。

6. 跨平台技术

从企业降本的角度，未来可能会更倾向招聘懂跨平台开发的，希望能统一技术栈能够实现多端发布的能力。比如Flutter、React Native、UniApp等。

7. 鸿蒙OS应用开发

国产替代是个很深远的话题，卡脖子问题现在越演越烈，从软件产业我们跟漂亮国还存在很多差距，我们能够正视这些差距并且迎头突围是一个非常值得敬佩和骄傲的事情。鸿蒙OS有望成为第一个完全去Android化的操作系统，Mate60系列手机产品我认为是一个标志性里程碑，我们不谈什么遥遥领先，我相信华为一定会越来越好，鸿蒙OS应用开发也是我觉得有较好前景的方向。

当然还有很多其他技术方向无法一一列举，我个人觉得一专多能可能是未来我们更应追求的目标，仅靠写几个UI页面就能打天下的时代已经不再适用了，想让自己有足够的竞争力，就必须要多涉猎各种技术，打通任督二脉，很多时候单一视角很难获得创新，只有多维度思考才有可能让自己突围。

最后

作为互联网从业人员，保持一定的危机感是必要的，另外多扩展自己的视野，除了专注于本身的专业领域，也要多关注技术趋势的变化，很多时候技术的价值是需要匹配业务的。移动开发有没有未来这个问题可以转化为：我们自己当前要做哪些选择，才能让自己拥有更多的未来。最后跟大家分享一句话作为结尾：

个人努力固然重要，也要考虑历史进程。

最近改了个隐式app 拉起，启动图标也有不同的玩法

0 个启动图标

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />



    <category android:name="android.intent.category.BROWSABLE" />

    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />

    <data

        android:host="app"

        android:path="/"

        android:port="8080"

        android:scheme="lb">

    </data>

</intent-filter>

这里是对接受所有隐式拉起，这个是告诉系统app 启动不需要用户手动拉起，是为了被代码或者其他中转站调用，所以不需要用户手动拉起，自然就不用再显示图标

1个启动图标

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>

LAUNCHER 是决定是不是要显示在程序列表里，默认为主动唤起，也是Android 标准启动模式，会正常在手机的界面显示

2 个启动图标

<application

    android:allowBackup="true"

    android:icon="@mipmap/ic_launcher"

    android:label="@string/app_name"

    android:theme="@style/AppTheme">



    <activity android:name="com.camera.demo.1Activity"

        android:label="@string/app_name">

        <intent-filter>

            <action android:name="android.intent.action.MAIN" />



            <category android:name="android.intent.category.LAUNCHER" />

        </intent-filter>

    </activity>



    <activity android:name="com.camera.demo.2Activity"

        android:icon="@mipmap/ic_launcher" >

        <intent-filter>

            <action android:name="android.intent.action.MAIN" />



            <category android:name="android.intent.category.LAUNCHER" />

        </intent-filter>

    </activity>



</application>

上面说了android.intent.category.LAUNCHER 为是否显示在应用列表内，所以我们配置多个LAUNCHER，就会有多个图标显示在手机列表内

intent-filter 相关说明

接受页面隐式跳转的过滤器，

action

必须的包含，定义一些操作.android.intent.action.MAIN/android.intent.action.WEB_SEARCH

category

一个字符串， 包含了处理该Intent的组件的种类信息, 起着对action的补充说明作用

data

要指定接受的 Intent 数据，Intent 过滤器既可以不声明任何 <data> 元素，也可以声明多个此类元素，如下例所示：

<intent-filter>

    <data android:mimeType="video/mpeg" android:scheme="http" ... />

    <data android:mimeType="audio/mpeg" android:scheme="http" ... />

    ...

</intent-filter>

每个 <data> 元素均可指定 URI 结构和数据类型（MIME 媒体类型）。URI 的每个部分都是一个单独的属性：scheme、host、port 和 path：

<scheme>://<host>:<port>/<path>

下例所示为这些属性的可能值：

content://com.example.project:200/folder/subfolder/etc

在此 URI 中，架构是 content，主机是 com.example.project，端口是 200，路径是 folder/subfolder/etc。
在 <data> 元素中，上述每个属性均为可选，但存在线性依赖关系：

• 如果未指定架构，则会忽略主机。


• 如果未指定主机，则会忽略端口。


• 如果未指定架构和主机，则会忽略路径。

将 Intent 中的 URI 与过滤器中的 URI 规范进行比较时，它仅与过滤器中包含的部分 URI 进行比较。例如：

• 如果过滤器仅指定架构，则具有该架构的所有 URI 均与该过滤器匹配。


• 如果过滤器指定架构和权限，但未指定路径，则具有相同架构和权限的所有 URI 都会通过过滤器，无论其路径如何均是如此。


• 如果过滤器指定架构、权限和路径，则仅具有相同架构、权限和路径的 URI 才会通过过滤器。

最后贴张LAUNCHER 的原理图

前言

粒子动画经常用于大画幅的渲染效果，实际上难度并不高，但是在使用粒子动画时，必须要遵循的一些要素，主要是：

• 起点


• 矢量速度


• 符合运动学公式

在之前的文章中，如《烟花效果》和《粒子喷泉》是典型的粒子动画，起点之所以重要是因为其实位置决定粒子出现的位置，矢量速度则决定了快慢和方向，运动学公式属于粒子动画的一部分，当然不是物理性的，毕竟平面尺寸也就那么长，这里的物理学公式使得画面更加丝滑而无跳动感觉。

本篇将实现下面的效果

注意：gif图有些卡，实际上流畅很多

本篇效果实现

本篇效果是无数圆随机产生然后渐渐变大并外旋，另外也有雨滴，这里的雨滴相对简单一些。

首先定义粒子对象

定义粒子对象是非常重要的，绝大部分倾下粒子本身就是需要单独控制的，因为每个粒子的轨迹都是有所差别的。

定义圆圈粒子

private static class Circle {

    float x;

    float y;

    int color;



    float radius;



    Circle(float x, float y, float radius) {

        reset(x, y, radius);

    }



    private void reset(float x, float y, float radius) {

        this.x = x;

        this.y = y;

        this.radius = radius;

        this.color = Color.rgb((int) (Math.random() * 256), (int) (Math.random() * 256), (int) (Math.random() * 256));

    }

}

定义雨滴

private static class RainDrop {

    float x;

    float y;



    RainDrop(float x, float y) {

        this.x = x;

        this.y = y;

    }

}

定义粒子管理集合

private ArrayList mParticles;

private ArrayList mRainDrops;

private long mLastUpdateTime; //记录执行时间

生成粒子对象

• 生成雨滴是从顶部屏幕意外开始，而y = -50f值是雨滴的高度决定。


• 圆圈是随机产生，在中心位置圆圈内。

// 创建新的雨滴

if (mRainDrops.size() < 80) {

    int num = getWidth() / padding;

    double nth = num * Math.random() * padding;

    double x = nth + padding / 2f * Math.random();

    RainDrop drop = new RainDrop((float) x, -50f);

    mRainDrops.add(drop);

}



// 创建新的粒子

if (mParticles.size() < 100) {

    float x = (float) (getWidth() / 2f - radius + 2*radius * Math.random());

    float y = (float) (getHeight()/2f - radius + 2*radius * Math.random() );



    Circle particle = new Circle(x, y,5);

    mParticles.add(particle);

}

绘制雨滴

雨滴的绘制非常简单，调用相应的canvas方法即可

// 绘制雨滴

mPaint.setColor(Color.WHITE);

for (RainDrop drop : mRainDrops) {

    canvas.drawLine(drop.x, drop.y, drop.x, drop.y + 20, mPaint);

}



// 绘制粒子

for (Circle particle : mParticles) {

    mPaint.setColor(particle.color);

    canvas.drawCircle(particle.x, particle.y, particle.radius, mPaint);

}

更新粒子位置

雨滴的更新相对简单，但是圆圈的旋转是一个难点，一个重要的问题是如何旋转粒子的，其实有很多方法，其中最笨的方法是旋转Canvas坐标系，底层有很多矩阵计算，但是这个似乎使用Math.atan2(y,x)显然更加方便，我们只需要在当前角度加上偏移量就能旋转。

float angle = (float) Math.atan2(dy, dx) + deltaTime * 0.65f;

下面是完整的更新逻辑

// 更新雨滴位置

Iterator rainIterator = mRainDrops.iterator();

while (rainIterator.hasNext()) {

    RainDrop drop = rainIterator.next();

    if (drop.y > getHeight() + 50) {

        int num = getWidth() / padding;

        double nth = num * Math.random() * padding;

        double x = nth + padding * Math.random();



        drop.x = (float) (x);

        drop.y = -50;

    } else {

        drop.y += 20;

    }



}



// 更新粒子位置

long currentTime = System.currentTimeMillis();

float deltaTime = (currentTime - mLastUpdateTime) / 1000f;

mLastUpdateTime = currentTime;



float centerX = getWidth() / 2f;

float centerY = getHeight() / 2f;



Iterator iterator = mParticles.iterator();

while (iterator.hasNext()) {

    Circle particle = iterator.next();

    float dx = particle.x - centerX;

    float dy = particle.y - centerY;

    float distance = (float) Math.sqrt(dx * dx + dy * dy) + 4.5f;//  增加偏移

    float angle = (float) Math.atan2(dy, dx) + deltaTime * 0.5f;

    particle.radius += 1f;



    particle.x = centerX + (float) Math.cos(angle) * distance;

    particle.y = centerY + (float) Math.sin(angle) * distance;



    if (particle.radius > 10) {

        int maxRadius = 100;

        float fraction = (particle.radius - 10) / (maxRadius - 10);

        if (fraction >= 1) {

            fraction = 1;

        }

        particle.color = argb((int) (255 * (1 - fraction)), Color.red(particle.color), Color.green(particle.color), Color.blue(particle.color));

    }

    if (Color.alpha(particle.color) == 0) {



        float x = (float) (getWidth() / 2f - radius + 2* radius * Math.random());

        float y = (float) (getHeight()/2f - radius + 2*radius * Math.random() );

        particle.reset(x,y, 5);

    }



}

粒子刷新

其实刷新机制我们以前经常使用，调用postInvalidate即可，本身就是View自身的方法。

总结

本篇主要内容总体上就是这些，下面是全部代码逻辑

public class VortexView extends View {



    private Paint mPaint;

    private ArrayList mParticles;

    private ArrayList mRainDrops;

    private long mLastUpdateTime;

    private int padding = 20;



    public VortexView(Context context) {

        super(context);

        mPaint = new Paint();

        mParticles = new ArrayList<>();

        mRainDrops = new ArrayList<>();

        mLastUpdateTime = System.currentTimeMillis();

    }



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        float radius = Math.min(getWidth(), getHeight()) / 3f;



        // 创建新的雨滴

        if (mRainDrops.size() < 80) {

            int num = getWidth() / padding;

            double nth = num * Math.random() * padding;

            double x = nth + padding / 2f * Math.random();

            RainDrop drop = new RainDrop((float) x, -50f);

            mRainDrops.add(drop);

        }



        // 创建新的粒子

        if (mParticles.size() < 100) {

            float x = (float) (getWidth() / 2f - radius + 2*radius * Math.random());

            float y = (float) (getHeight()/2f - radius + 2*radius * Math.random() );



            Circle particle = new Circle(x, y,5);

            mParticles.add(particle);

        }



        // 绘制雨滴

        mPaint.setColor(Color.WHITE);

        for (RainDrop drop : mRainDrops) {

            canvas.drawLine(drop.x, drop.y, drop.x, drop.y + 20, mPaint);

        }



        // 绘制粒子

        for (Circle particle : mParticles) {

            mPaint.setColor(particle.color);

            canvas.drawCircle(particle.x, particle.y, particle.radius, mPaint);

        }



        // 更新雨滴位置

        Iterator rainIterator = mRainDrops.iterator();

        while (rainIterator.hasNext()) {

            RainDrop drop = rainIterator.next();

            if (drop.y > getHeight() + 50) {

                int num = getWidth() / padding;

                double nth = num * Math.random() * padding;

                double x = nth + padding * Math.random();



                drop.x = (float) (x);

                drop.y = -50;

            } else {

                drop.y += 20;

            }



        }



        // 更新粒子位置

        long currentTime = System.currentTimeMillis();

        float deltaTime = (currentTime - mLastUpdateTime) / 1000f;

        mLastUpdateTime = currentTime;



        float centerX = getWidth() / 2f;

        float centerY = getHeight() / 2f;



        Iterator iterator = mParticles.iterator();

        while (iterator.hasNext()) {

            Circle particle = iterator.next();

            float dx = particle.x - centerX;

            float dy = particle.y - centerY;

            float distance = (float) Math.sqrt(dx * dx + dy * dy) + 3.5f;//  增加偏移

            float angle = (float) Math.atan2(dy, dx) + deltaTime * 0.65f;

            particle.radius += 1f;



            particle.x = centerX + (float) Math.cos(angle) * distance;

            particle.y = centerY + (float) Math.sin(angle) * distance;



            if (particle.radius > 10) {

                int maxRadius = 100;

                float fraction = (particle.radius - 10) / (maxRadius - 10);

                if (fraction >= 1) {

                    fraction = 1;

                }

                particle.color = argb((int) (255 * (1 - fraction)), Color.red(particle.color), Color.green(particle.color), Color.blue(particle.color));

            }

            if (Color.alpha(particle.color) == 0) {



                float x = (float) (getWidth() / 2f - radius + 2* radius * Math.random());

                float y = (float) (getHeight()/2f - radius + 2*radius * Math.random() );

                particle.reset(x,y, 5);

            }



        }



        Collections.sort(mParticles, comparator);



        // 使view无效从而重新绘制，实现动画效果

        invalidate();

    }

    Comparator comparator = new Comparator() {

        @Override

        public int compare(Circle left, Circle right) {

            return (int) (left.radius - right.radius);

        }

    };



    public static int argb(

            int alpha,

            int red,

            int green,

            int blue) {

        return (alpha << 24) | (red << 16) | (green << 8) | blue;

    }



    private static class Circle {

        float x;

        float y;

        int color;



        float radius;



        Circle(float x, float y, float radius) {

            reset(x, y, radius);

        }



        private void reset(float x, float y, float radius) {

            this.x = x;

            this.y = y;

            this.radius = radius;

            this.color = Color.rgb((int) (Math.random() * 256), (int) (Math.random() * 256), (int) (Math.random() * 256));

        }

    }



    private static class RainDrop {

        float x;

        float y;



        RainDrop(float x, float y) {

            this.x = x;

            this.y = y;

        }

    }

}