长路漫漫伴你闯

武状元

老爹，我要上京考武状元。

儿子，我们苏察哈尔家等你这句话等了整整20年了！

错，我是为一个女人。

好！为女死为女亡，为女去考状元郎！英雄！敢问是谁家女子？

怡红院如霜姑娘。

啊？！妓！！

有何不妥？

敢爱人之所不敢爱，品味与众不同，老爹我佩服你！

置顶

展开全文 >>

Android-技能点

Android

Dalvik 和 ART

发展史

Android 2.2

  • Android 首次在 Dalvik 上使用 JIT (Just In Time Compiler)，在运行时对 dex/odex 进行编译与优化，将 Dalvik Code 编译为精简的 Native Code，JIT 的引入，将 Dalvik 的运行性能提升了 3~6倍
  • 缺点：每次运行时都需要进行编译，会造成额外的电量消耗

Android 4.4

  • Android 带来了全新的运行环境 ART(Android Run Time) 和全新的编译策略 AOT(Ahead Of Time)
  • AOT 是静态编译，在安装时，会启动 dex2oat 过程，将 dex 文件预编译为 ELF 文件，每次运行时不需要重新编译

Android 5.0

  • 全面替换为 ART 运行环境，编译策略也改为 AOT
  • 缺点：首次安装的时间会变长，会额外增加文件大小，一个 100M 的 App，预编译后可能达到 200M

Android 7.0

  • 运行环境仍是 ART，编译策略改为 AOT 和 JIT 混合编译
  • 特点：在首次安装时，不会进行预编译，直接运行，使用运行时编译，在手机处于空闲或者充电状态的时候，在进行预编译
  • 优点：集合了 AOT 和 JIT 的优点，使得安装速度加快，运行速度、存储空间和耗电量等指标都得到了优化
ART 相对于 Dalvik 的提升
  1. ART 在标记所有对象的时候不需要挂起所有的线程，ART 的 GC 要求对象在创建的时候，标记自身的堆栈，由于时间非常的短，不需要挂起线程
  2. 提供了 LOS (Large Object Space)，专门为 Bitmap 的分配提供了空间，提高了内存的管理效率和整体性能
  3. ART 中有 moving collector 来压缩对象，使内存变得更加紧凑

Bitmap

占用内存

Bitmap 的发小氛围 Bitmap 对象大小和像素大小

版本区别
  1. Android 3.0 之前 Bitmap 对象放在 Java 堆，而像素数据放在 Native 内存中，如果不手动调用 recycle() 方法，Bitmap Native 内存回收完全依赖 finilize() 函数回调
  2. Android 3.0 ~ Android 7.0 Bitmap 对象和像素数据都放在了Java 堆中，就算不手动调用 recycle() 方法，像素数据也会被 gc 回收，不过 Bitmap 是内存占用大户，Bitmap 频繁的销毁创建，会导致大量的 GC
  3. Android 8.0 将像素数据放入了 Native 的内存中，并且使用了 NativeAllocationRegistry 来确保，Bitmap 对象和数据一起被回收
BitmapFactory.Optins
  1. inBitmap & inMutable，告诉编译器，尝试使用已经存在的内存区域，新解码器的 Bitmap 尝试使用之前 Bitmap 在 head 中分配的 pixel data 内存区域，在 Android 3.0 ~ 4.4，只能是相同大小的 Bitmap 才能使用，Android 4.4 以后，只要比现在 bitmap 大，就可以用
  2. injustDecodeBounds，true 时只返回图片的宽高，不返回 Bitmap
  3. inSampleSize 压缩比
图片加载库对比

Fresco

  • 加载图片的流程
    1. 缓存中是否有数据，有则返回
    2. 如果缓存中没有，则开启后台线程进行后续工作
    3. 检查未解码的缓存，如果有，则进行解码，放入内存缓存中
    4. 未解码的缓存中没有，则查找为解码的文件是否有，有的话，则读取文件，解码，放入各个缓存中
    5. 为解码的文件缓存中没有，则直接从网上下载或者文件中加载
  • 关键概念
    • DraweeView，继承自 View，用于展示 UI，一般使用 SimpleDraweeView 即可
    • DraweeHierarchy，用于组织和维护最终绘制和展现的 Drawable 对象，相当于 MVC 中的 M
    • DraweeController，负责和 Image Loader 交互
    • DraweeControllerBuilder，通过 Builder 模式创建
  • 三级缓存
    1. 内存缓存，直接是 Bitmap 缓存，使用 LRUCache
    2. 内存未解码缓存，没有解码的图片缓存
    3. 文件未解码缓存
  • 三个线程池
    • IO 线程池，默认两个线程
    • 网络下载线程池，与手机的 CPU 核数一样
    • 用于解码的线程池，与手机的 CPU 核数一样
  • 优点
    1. Android 5.0 以下，Bitmap 的像素数据放在 Native 内存中，5.0 ~ 7.0 放在 Java 堆中，7.0 以后 Android 系统将 Bitmap 的像素数据放入到 Native 内存中
    2. 支持渐进式展现
    3. 支持 Gif 和 WebP 动画
  • 缺点
    • 框架体积比较大，大概 2M~3M

Glide

  • 使用二级缓存，Java 的像素内存跟随这 Android

线程并发

AsyncTask

AsyncTask 内部由两个线程和一个 Handler 实现的，Handler 用于将信息切换到主线程，两个线程池一个用于排队，一个用于执行。AsyncTask.execute()，传入一个 FutureTask 的对象。Android 3.0 之前是并行，3.0以后是串行

HandlerThread

继承于 Thread，在 run 函数中，创建了 Looper 对象

IntentService

内部实现了 HandlerThread 和 Handler，可以执行性耗时操作，因为它是一个 Service，所以它的优先级比其他 Thread 要高很多

四大组件

Activity
  • 启动模式
    • Standard 模式，不论栈中是否已经有该 Activity，都会创建一个新的 Activity
    • SingleTop 模式，如果该 Activity 在栈顶，则不会创建新的 Activity
    • SingleTask 模式，一个栈中只有一个 Activity 的实例，如果该 Activity 不在栈顶，则将其上面的 Activity 推出栈
    • SingleInstance 模式，一个栈中有且只有该 Activity 一个实例对象
  • onRestart 的调用场景
    • 点击 home 后，然后切换回来
    • 切换到其他的 Activity，然后点击 back 键，返回去
    • 从本应用切换到其他应用，然后再切换回来
  • Activity 跳转生命周期
    • 启动 A：onCreate、onStart、onResume
    • A 启动 B：(A)onPause、(B)onCrete、(B)onStart、(B)onResume、(A)onStop
    • B 返回 A：(B)onPause、(A)onRestart、(A)onStart、(A)onResume、(B)onStop、(B)onDestroy
  • Activity 启动流程
    1. Launcher 点击 App，Launcher 也是一个桌面应用，通过 ActivityManager 向 ActivityManagerService 发送启动应用的请求
    2. AMS 通过 ServiceManager 查找相应的进程，如果没有进程，则通过 Binder 向 Zygote 进程发送创建进程的请求
    3. Zygote fork 出子进程，也就是 App 进程，执行 ActivityThread 中的 main 函数
    4. App 进程通过 IActivityManager 向 AMS 发送 attachApplication 的请求
    5. AMS 接到请求后，通过 IApplicationThread 向用户进程发送 bindApplication 的请求
    6. 用户进程接到 bindApplication 的消息后，通过 Instrumentation 创建 Application，onAttachApplication() -> contentProvider -> onCreate()
    7. 创建完 Application 后，AMS 向 App 进程发送启动 Activity 的请求
Service
  • 启动服务的两种方式
    • startService：onCreate、onStartCommand、onDestroy
    • bindService：onCreate、onBind、unBind、onDestroy
  • 如何保证 Service 不被杀死
    • onStartCommand 中返回 START_STICK
    • 提升 service 优先级，在 service 中创建一个 Notification，这样 service 就是前台的进程了
    • onDestroy 中发送广播，重新开启
  • IntentService，内部使用 HandlerThread 和 Handler 来异步处理消息，只需要重写 onHandlerIntent 函数即可
BroadCast
ContentProvider

View

View 的绘制流程
  1. View 的事件分发机制

JetPack

LifeCycle
LiveData
ViewModel
paging

进程保活

防止被杀死
  1. 使用 service 或者 foreground service 提高进程的优先级
  2. 监听锁屏的广播，启动一个透明或者 1 像素的 activity
被杀死后重启
  1. 监听静态广播
  2. 多进程互相拉起
  3. 链式调用 应用间相互启动
  4. service 的 onStartCommand 函数中，返回START_STICK，在杀死后，适当的时候会重新启动 service
  5. 文件死锁，一般在 Native 中进行

网络

TCP/IP 四层模型和 OSI 七层模型

HTTP 协议

HTTP 请求和响应格式

建立连接和断开连接

HTTPS/SSL(Secure Socket Layer)

HTTP 与 HTTPS 区别

Java

JVM

Java 内存结构以及分区
Java 判断对象是否存活，以及常见的垃圾回收算法
Java 常见的垃圾回收器
Java 类加载的步骤
Java 类加载器

设计模式

六大原则
  1. Single Responsibility 单一职责
  2. Open Close 开闭原则，对增加开发，对修改关闭
  3. Liscov Substitution 里氏替换原则，可以将父类替换为子类而不报错
  4. Least Knowledge，最小知道原则，高内聚，低耦合
  5. Interface Segregation 接口隔离原则，类和类之间的依赖，应该依赖最小的接口
  6. Dependence Inversion，依赖倒置原则，面向接口编程
具体实现
  1. 责任链模式
  2. 建造者模式
  3. 观察者模式
  4. 单例模式
  5. 代理模式
  6. 策略模式
  7. 工厂模式

数据集合

ArrayList
LinkedList
HashMap
LinkedHashMap
HashSet
ConcurrentHashMap
SparseArrayList

线程与并发

线程
锁
线程池

排序算法

冒泡排序
选择排序
插入排序
希尔排序
归并排序
快速排序

树

二叉树
二叉查找树
二叉平衡树
红黑树

性能优化

常见的性能问题

内存泄漏
OOM
耗电量问题
内存抖动

造成性能问题常见的原因

  • 在 ui 线程中进行了好使的操作，导致 ui 线程卡顿

如何解决这些问题

专项优化

RecyclerView 优化
数据存储
包体积优化
启动优化
Crash 优化
UI 优化
内存优化

进阶

组件化

什么是组件化
为什么要组件化
隔离
应用架构
实现技术

插件化

什么是插件化
为什么要用插件化
实现技术

热修复

主流修复框架的原理
Robust

AOP

AOP 概念
AOP 的使用场景
AOP 的实现
  • 静态植入(编译期)
  • 动态植入(运行期)
AOP 实战
  • Android 的打包过程
  • Transform
  • ASM code

shell 脚本

OpenGL

音视频

展开全文 >>

okdownloader 源码浅析

项目需要添加文件下载的功能，一开始想要用 FileDownLoader，后来再 github 上看到作者基于 FileDownloader 改版了一个 FileDownloader2，即 OkDownload 。看作者的意思 OKDownLoad 的存在是因为 FileDownloader 不方便进行单元测试，另一个原因是核心代码过于臃肿复杂，基于这些原因，才有了 OKDownload。OkDownload是一款多线程断点续传下载引擎，它的功能完整，性能高，可配置性高，可以注入自定义组件来修改下载策略、替换网络请求框架等等。

相对于FileDownloader的优势
  • 单元测试覆盖度非常高
  • 更简单的接口
  • 支持任务优先级
  • 使用Uri标识文件来存储output-stream
  • 核心代码更加轻量及纯净
  • 更灵活的回调、监听机制
  • 更容易扩展
  • 保持性能的基础上减少线程数量
  • 文件IO线程池独立于网络IO线程池
  • response header中不包含文件名时，自动从URL中获取（使用正则表达式实现）

展开全文 >>

Android 常用开源库总结

原文地址：https://blog.csdn.net/qq_21138819/article/details/89025776

一 、基本控件

TextView
EditText
ImageView
Button
Spinner
CheckBox
ProgressBar（包含loading动画）
Seekbar
RatingBar
  • MaterialRatingBar 与 Google 系应用设计相同、支持拉伸、修正原生实现诸多问题的星级评分条
Toast
RecyclerView
  • BaseRecyclerViewAdapterHelper 万能adapter
  • MultiChoiceAdapter 多选adapter
  • SwipeRecyclerView 基于RecyclerView的封装，提供了Item侧滑菜单、Item滑动删除、Item长按拖拽、添加HeaderView/FooterView、加载更多、Item点击监听等基本功能。
  • EasyRecyclerView 封装RecyclerView
  • StickyItemDecoration 悬浮头部
  • PinnedSectionItemDecoration 悬浮头部
  • recyclerview-animators RecycleView的项目动画的Android组件库

  • UltimateRecyclerView 能强大的Recyclerview，包括了下拉刷新，加载更多，多种动画，空数据提示，拖动排序，视差处理，工具栏渐变，滑动删除，自定义floating button，多种刷新效果，scrollbar等等元素，而且使用起来跟recyclerview一样的方便。

  • epoxy Epoxy采用可组合的方式来创建列表。列表中的每个item由一个model代表，model定义了item的布局，id以及span。model还负责处理数据到视图的绑定，在视图被回收的时候释放资源。如果要显示这些model则把它们添加到Epoxy的adapter中，adapter为你处理复杂的显示问题。

  • XRecyclerView XRecyclerView实现了下拉刷新，滚动到底部加载更多以及添加header功能的的RecyclerView。使用方式和RecyclerView完全一致，不需要额外的layout，不需要写特殊的adater。 加载效果内置了AVLoadingIndicatorView上的所有效果，可以根据需要指定。
  • RecyclerViewPager RecyclerViewPager基于 RecyclerView 实现的 ViewPager，可自定义 Page 切换敏感度，支持垂直 ViewPager，支持类 Gallary 效果，支持无限循环。
  • SuperRecyclerView SuperRecyclerView主要特性包括：1、当adapter没有设置的时候使用ProgressBar（进度条）；2、当adapter时空的时候使用EmptyView；3、SwipeRefreshLayout (Google’s one)；4、Swipe To Dismiss；5、Sticky headers；6、无限滚动，当到达最后一项时，加载更多数据；
  • LRecyclerView 下拉刷新，自动加载更多；仿IOS侧滑Item删除菜单
  • LayoutManagerGroup 自定义RecyclerView 的LayoutManager实现几种炫酷的效果。
  • android-advancedrecyclerview 自定义RecyclerView （2019-03-29）
  • RecyclerView-FlexibleDivider RecyclerView各种间隔线 （2019-04-02）
日历、时钟
Webview
ScrollView
ViewPager
WheelPicker
导航栏

二、功能相关

图片选择
图片加载
音视频
刷新控件
动画
轮播图
权限
二维码
新手引导
  • NewbieGuide Android 快速实现新手引导层的库，通过简洁链式调用，一行代码实现引导层的显示
  • GuideView 能够快速为任何一个View创建一个遮罩层，支持单个页面，多个引导提示，支持为高亮区域设置不同的图形，支持引导动画，方便扩展,良好支持fragment
数据库
  • greenDAO
  • ActiveAndroid Android Sqlite orm 的 db 工具类
  • realm-java 移动端的数据库，适用于 Phone、Tablet、Wearable，支持 ORM，线程安全、支持连表及数据库加密，比 SQLite 性能更好
  • DBFlow Android SQLite ORM 工具库。综合了 Active Android, Schematic, Ollie,Sprinkles 等库的优点；通过注解实现，性能好；能生成 ContentProvider。
  • SnappyDB key-value数据库，非常流行的NoSQL数据库
  • LitePal 不编写SQL语句的情况下完成大多数数据库操作，包括创建或升级表、CRUD操作、聚合函数等
  • objectbox-java ObjectBox是一个超高速的面向对象的数据库，具有很强的关系支持。ObjectBox嵌入到Android、Linux、MacOS或Windows应用程序中。
  • wcdb 一个高效、完整、易用的移动数据库框架，基于SQLCipher，支持iOS, macOS和Android。
  • Android-Debug-Database 数据库调试工具
图表
菜单
手势关闭
事件处理
换肤
状态栏
颜色选择器
布局相关
屏幕适配
其他

三、网络相关

http
  • retrofit
  • okhttp
  • okhttp-OkGo 封装了 OkHttp 的网络请求框架
  • {停止维护} okhttputils okhttp的辅助类
  • NoHttp 实现Http标准协议框架，支持多种缓存模式，底层可动态切换OkHttp、URLConnection。
  • xUtils3 xUtils 包含了orm, http(s), image, view注解
  • afinal Afinal是一个android的ioc，orm框架，内置了四大模块功能：FinalAcitivity,FinalBitmap,FinalDb,FinalHttp
  • Fast-Android-Networking 支持http2的网络库（2019-03-29）
json
下载、上传
rx
  • RxAndroid 对RxJava在Android上的扩展，使得Android上也很容易实现reactive components，简化线程操作，从而写出很漂亮的代码。
  • RxJava
  • RxCache 专门为Retrifit打造的缓存库
  • ReactiveNetwork 检测网络状态
  • RxLifecycle 管理rx的生命周期
  • AutoDispose rx 工具类

四、自定义View

蛛网图
翻书效果
图案解锁
望远镜效果（部分高亮）
其他

五、其他

工具类
  • AndroidUtilCode 强大易用的安卓工具类库
  • RxTools Android开发人员不得不收集的工具类集合
  • butterknife 利用 annotation 帮你快速完成 View 的初始化，减少代码

  • parceler 序列化（2019-03-29）

  • tray 替代SharedPreferences （2019-04-02）

热修复
插件化
  • RePlugin RePlugin是一套完整的、稳定的、适合全面使用的，占坑类插件化方案，由360手机卫士的RePlugin Team研发，也是业内首个提出”全面插件化“（全面特性、全面兼容、全面使用）的方案。（2019-03-27）
  • DDComponentForAndroid 一套完整有效的android组件化方案，支持组件的组件完全隔离、单独调试、集成调试、组件交互、UI跳转、动态加载卸载等功能（2019-04-02）
签名打包
  • walle Android Signature V2 Scheme签名下的新一代渠道包打包神器
  • packer-ng-plugin 100个渠道包只需要10秒钟
反编译
依赖注入
  • dagger 依赖注入，适用于 Android 和 Java
日志
路由
内存泄漏检测
布局优化
  • X2C 在编译生成APK期间，将需要翻译的layout翻译生成对应的java文件，这样对于开发人员来说写布局还是写原来的xml，但对于程序来说，运行时加载的是对应的java文件。 （2019-03-27）
画图
图片压缩
摄像头
富文本编辑器
指示器
自定义字体加载
文件加密
表情包
相机滤镜
车牌识别
键盘冲突
蓝牙
  • Android-BLE AndroidBLE蓝牙框架，包括扫描、连接、设置通知、发送数据、读取、接收数据和OTA升级以及各种直观的回调，近乎一行代码植入项目，可扩展配置蓝牙相关操作。
  • FastBle （2019-04-02）
测试
  • Matrix 通过各种性能监控方案，对性能监控项的异常数据进行采集和分析，输出相应的问题分析、定位与优化建议，从而帮助开发者开发出更高质量的应用。
  • pandora 一款无需ROOT、可以直接在应用内查看和修改包括网络、数据库、UI等的工具箱，适合开发和测试阶段的各种问题的快速定位。
  • ArgusAPM 。ArgusAPM是360移动端产品使用的可视化性能监控平台，为移动端APP提供性能监控与管理，可以迅速发现和定位各类APP性能和使用问题，帮助APP不断的提升用户体验。（2019-03-27）
  • AndroidPerformanceMonitor 非侵入式的性能监控组件
  • UETool 一个各方人员（设计师、程序员、测试）都可以使用的调试工具。它可以作用于任何显示在屏幕上的 view，比如 Activity/Fragment/Dialog/PopupWindow 等等。（2019-03-27）
  • robolectric 单元测试 （2019-03-29）
  • AppMethodOrder 无需侵入式代码,让你了解所有函数调用顺序以及函数耗时的Android库 （2019-04-02）
传感器
  • sensey 玩转Android传感器
其他

展开全文 >>

Kotlin 使用技巧

1、无需 findViewById

在布局中定义

1
2
3
4
5
<TextView
    android:id="@+id/tv_content"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!" />

直接设置 TextView 的文本

1
tv_content.text = "改变文本"

2、Lambda

1
2
3
4
5
tv_content.setOnClickListener(View.OnClickListener(
    fun(v : View) {
        v.visibility = View.GONE
    }
))

可以写成下面

1
tv_content.setOnClickListener { v -> v.visibility = View.GONE }

3、函数变量

在 kotlin 语法中函数是可以作为变量进行传递的

1
2
3
var result = fun(number1 : Int, number2 : Int) : Int {
    return number1 + number2
}

使用这个函数变量

1
println(result(1, 2))

4、空安全

在 Java 不用强制我们处理空对象，所以常常会导致 NullPointerException 空指针出现，现在 Kotlin 对空对象进行了限定，必须在编译时处理对象是否为空的情况，不然会编译不通过.

在对象不可空的情况下，可以直接使用这个对象.

1
2
3
4
5
6
fun getText() : String {
    return "text"
}

val text = getText()
print(text.length)

在对象可空的情况下，必须要判断对象是否为空

1
2
3
4
5
6
7
fun getText() : String? {
    return null
}
val text = getText()
if (text != null) {
    print(text.length)
}

如果不想判断是否为空，可以直接这样，如果 text 对象为空，则会报空指针异常，一般情况下不推荐这样使用

1
2
val text = getText()
print(text!!.length)

还有一种更好的处理方式，如果 text 对象为空则不会报错，但是 text.length 的结果会等于 null

1
2
val text = getText()
print(text?.length)

5、方法支持添加默认函数

在 Java 上，我们可能会为了扩展某个方法而进行多次重载

1
2
3
4
5
6
7
8
9
10
11
public void toast(String text) {
    toast(this, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text) {
    toast(context, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text, int time) {
    Toast.makeText(context, text, time).show();
}
1
2
3
toast("弹个吐司");
toast(this, "弹个吐司");
toast(this, "弹个吐司", Toast.LENGTH_LONG);

但是在 Kotlin 上面，我们无需进行重载，可以直接在方法上面直接定义参数的默认值

1
2
3
4
5
6
7
fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
    Toast.makeText(context, text, time).show()
}

toast(text = "弹个吐司")
toast(this, "弹个吐司")
toast(this, "弹个吐司", Toast.LENGTH_LONG)

6、类方法扩展

可以在不用继承的情况下对扩展原有类的方法，例如对 String 类进行扩展方法

1
2
3
4
5
6
fun String.handle() : String {
    return this + "Android轮子哥"
}
// 需要注意，handle 方法在哪个类中被定义，这种扩展只能在那个类里面才能使用
print("HJQ = ".handle())
HJQ = Android轮子哥

7、运算重载符

在 Kotlin 中使用运算符最终也会调用对象对应的方法，我们可以通过重写这些方法使得这个对象支持运算符，这里不再演示代码

运算符 调用方法
+a a.unaryPlus()
-a a.unaryMinus()
!a a.not()
运算符 调用方法
a++ a.inc()
a– a.dec()
运算符 调用方法
a + b a.plus(b)
a - b a.minus(b)
a * b a.times(b)
a / b a.div(b)
a % b a.rem(b), a.mod(b) (deprecated)
a..b a.rangeTo(b)
运算符 调用方法
a in b b.contains(a)
a !in b !b.contains(a)
运算符 调用方法
a[i] a.get(i)
a[i, j] a.get(i, j)
a[i_1, …, i_n] a.get(i_1, …, i_n)
a[i] = b a.set(i, b)
a[i, j] = b a.set(i, j, b)
a[i_1, …, i_n] = b a.set(i_1, …, i_n, b)
运算符 调用方法
a() a.invoke()
a(i) a.invoke(i)
a(i, j) a.invoke(i, j)
a(i_1, …, i_n) a.invoke(i_1, …, i_n)
运算符 调用方法
a += b a.plusAssign(b)
a -= b a.minusAssign(b)
a *= b a.timesAssign(b)
a /= b a.divAssign(b)
a %= b a.remAssign(b), a.modAssign(b) (deprecated)
运算符 调用方法
a == b a?.equals(b) ?: (b === null)
a != b !(a?.equals(b) ?: (b === null))
运算符 调用方法
a > b a.compareTo(b) > 0
a < b a.compareTo(b) < 0
a >= b a.compareTo(b) >= 0
a <= b a.compareTo(b) <= 0

8、扩展函数

扩展函数是 kotlin 用于简化一些代码的书写产生的，其中有 let、with、run、apply、also 五个函数。

let 函数

在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式。

一般写法

1
2
3
4
5
6
fun main() {
    val text = "Android轮子哥"
    println(text.length)
    val result = 1000
    println(result)
}

let 写法

1
2
3
4
5
6
7
fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result)
}

最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理

1
2
3
4
5
6
7
8
mVideoPlayer?.setVideoView(activity.course_video_view)
mVideoPlayer?.setControllerView(activity.course_video_controller_view)
mVideoPlayer?.setCurtainView(activity.course_video_curtain_view)
mVideoPlayer?.let {
   it.setVideoView(activity.course_video_view)
   it.setControllerView(activity.course_video_controller_view)
   it.setCurtainView(activity.course_video_curtain_view)
}

又或者是需要去明确一个变量所处特定的作用域范围内可以使用。

with 函数

前面的几个函数使用方式略有不同，因为它不是以扩展的形式存在的。它是将某对象作为函数的参数，在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式

定义 Person 类

1
class Person(var name : String, var age : Int)

一般写法

1
2
3
4
5
6
fun main() {
    var person = Person("Android轮子哥", 100)
    println(person.name + person.age)
    var result = 1000
    println(result)
}

with 写法

1
2
3
4
5
6
7
fun main() {
    var result = with(Person("Android轮子哥", 100)) {
        println(name + age)
        1000
    }
    println(result)
}

适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于Android中RecyclerView中onBinderViewHolder中，数据model的属性映射到UI上

1
2
3
4
5
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名：${item.name}"
    holder.ageView.text = "年龄：${item.age}"
}
1
2
3
4
5
6
7
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    with(item){
        holder.nameView.text = "姓名：$name"
        holder.ageView.text = "年龄：$age"
    }
}
run 函数

实际上可以说是let和with两个函数的结合体，run函数只接收一个lambda函数为参数，以闭包形式返回，返回值为最后一行的值或者指定的return的表达式

一般写法

1
2
3
4
var person = Person("Android轮子哥", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)

run 写法

1
2
3
4
5
6
var person = Person("Android轮子哥", 100)
var result = person.run {
    println("$name + $age")
    1000
}
println(result)

适用于let,with函数任何场景。因为run函数是let,with两个函数结合体，准确来说它弥补了let函数在函数体内必须使用it参数替代对象，在run函数中可以像with函数一样可以省略，直接访问实例的公有属性和方法，另一方面它弥补了with函数传入对象判空问题，在run函数中可以像let函数一样做判空处理，这里还是借助 onBindViewHolder 案例进行简化。

1
2
3
4
5
6
7
8
9
10
11
12
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名：${item.name}"
    holder.ageView.text = "年龄：${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    item?.run {
        holder.nameView.text = "姓名：$name"
        holder.ageView.text = "年龄：$age"
    }
}
apply 函数

从结构上来看apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身

一般写法

1
2
3
val person = Person("Android轮子哥", 100)
person.name = "HJQ"
person.age = 50

apply 写法

1
2
3
4
val person = Person("Android轮子哥", 100).apply {
    name = "HJQ"
    age = 50
}

整体作用功能和run函数很像，唯一不同点就是它返回的值是对象本身，而run函数是一个闭包形式返回，返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与run函数有点不一样。apply一般用于一个对象实例初始化的时候，需要对对象中的属性进行赋值。

或者动态inflate出一个XML的View的时候需要给View绑定数据也会用到，这种情景非常常见。特别是在我们开发中会有一些数据model向View model转化实例化的过程中需要用到。

1
2
3
4
5
mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0

使用 apply 函数后的代码是这样的

1
2
3
4
5
6
mRootView = View.inflate(activity, R.layout.example_view, null).apply {
   tv_cancel.paint.isFakeBoldText = true
   tv_confirm.paint.isFakeBoldText = true
   seek_bar.max = 10
   seek_bar.progress = 0
}

多层级判空问题

1
2
3
4
5
6
7
8
9
10
11
if (mSectionMetaData == null || mSectionMetaData.questionnaire == null || mSectionMetaData.section == null) {
    return;
}
if (mSectionMetaData.questionnaire.userProject != null) {
    renderAnalysis();
    return;
}
if (mSectionMetaData.section != null && !mSectionMetaData.section.sectionArticles.isEmpty()) {
    fetchQuestionData();
    return;
}

kotlin的apply函数优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mSectionMetaData?.apply {

    //mSectionMetaData不为空的时候操作mSectionMetaData

}?.questionnaire?.apply {

    //questionnaire不为空的时候操作questionnaire

}?.section?.apply {

    //section不为空的时候操作section

}?.sectionArticle?.apply {

    //sectionArticle不为空的时候操作sectionArticle

}
also 函数

also函数的结构实际上和let很像唯一的区别就是返回值的不一样，let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fun main() {
    val result = "Android轮子哥".let {
        println(it.length)
        1000
    }
    println(result) // 打印：1000
}


fun main() {
    val result = "Android轮子哥".also {
        println(it.length)
    }
    println(result) // 打印：Android轮子哥
}

适用于let函数的任何场景，also函数和let很像，只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

总结

通过以上几种函数的介绍，可以很方便优化kotlin中代码编写，整体看起来几个函数的作用很相似，但是各自又存在着不同。使用的场景有相同的地方比如run函数就是let和with的结合体

9、协程

子任务协作运行，优雅的处理异步问题解决方案。

协程实际上就是极大程度的复用线程，通过让线程满载运行，达到最大程度的利用CPU，进而提升应用性能。

https://www.kotlincn.net/docs/reference/coroutines/coroutines-guide.html

展开全文 >>

Okhttp3

以 post 为例，请求过程大致分四步：

  1. 构建 OKHTTPClient 对象
  2. 构建 Request 请求对象
  3. 购将 Call 对象
  4. 发起请求
Dispatcher

调度器。内部维护者最大请求数，每个主机最大请求数，还有三个最重要的队列，分别是 “将要执行的异步请求队列”、”正在执行的异步请求队列”、”正在执行的同步请求队列”。

getResponseWithInterceptorChain()

在这个方法中，将用户自定义的一些拦截器和默认的拦截器封装到一个 list 中，然后创建 RealInterceptorChain 对象并执行 proceed(originalRequest) 方法。在 proceed 中，会遍历调用拦截器列表中的拦截器，并调用每一个拦截器的 intercept 方法。

例如第一个拦截器 RetryAndFollowUpInterceptor 中的 intercept 方法，有 while 循环，在重连次数 followUpCount 超过 20 次的时候，停止重连。循环中，会执行 RealInterceptorChain.proceed() ，会去除下一个拦截器并执行 intercept 方法，以此种方法遍历拦截器列表中的拦截器。

最后一个拦截器是 CallServerInterceptor 。HttpCodec 这个接口用来编码 http 请求并解码 http 返回结果，也就是说真正的处理请求和结果在这个接口中，它有两个实现类分别是Http1Codec和Http2Codec分别对应Http/1.x和Http/2.x。

img

展开全文 >>

Android总结之图片相关

图片相关，主要想记录一下 Fresco 跟Glide 相关的一些内容。

优缺点对比

优点

Glide

  • 多种图片格式的缓存，适用于更多的内容表现形式 (如 Gif、WebP、缩略图、Video)
  • 生命周期集成 (根据 Activity 或者 Fragment 生命周期管理图片加载请求)
  • 高效处理 Bitmap (bitmap 的复用和主动回收，减少系统回收压力)
  • 高效的缓存策略，灵活 (Picasso 只会缓存原始尺寸的图片，Glide 缓存的事多种规格)，加载速度快且内存开销小 (默认 Bitmap 格式的不同，是的内存开销是 Picasso 的一般)

Fresco

  • 最大的优势在于5.0以下(最低2.3)的bitmap加载。在5.0以下系统，Fresco将图片放到一个特别的内存区域(Ashmem区)
  • 大大减少OOM（在更底层的Native层对OOM进行处理，图片将不再占用App的内存）
  • 适用于需要高性能加载大量图片的场景
缺点

Glide

  • 没有文件缓存
  • Java heap 比 Fresco 高

Fresco

  • 包较大（2~3M）
  • 用法复杂
  • 底层涉及c++领域，阅读源码深入学习难度大

Glide源码解析

Glide 源码基本用法分为三步：with()、load()、into()。

with()

在 with 中传入一个 Application 类型的对象或者非 Application 类型的参数，会向当前的 Activity 添加一个隐藏的 Fragment，用来监听当前的生命周期。

如果在非主线程中使用 Glide，不管传入的是 Activity 还是 Fragment，都会被强制当成 Application 来处理。

with 方法主要作用是得到一个 RequestManager 对象，监听生命周期。

load()

最后会返回一个 RequestBuilder 对象。RequestBuilder 中包含了 Glide 绝大多数的 API。

into()

资料https://blog.csdn.net/guolin_blog/article/details/53939176

展开全文 >>

Android总结之Handler

本来想简单记录一下 Handler 的，但是发现其主要作用就是在 Android 上的消息传递，那就大概记录一下 Android 上的消息机制吧。

Handler 是 Android 消息机制的上层接口，用来将一个任务切换到 Handler 所在的线程中执行。

Android 的消息机制主要是指 Handler 的运行机制，Handler 的运行需要底层的 MessageQueue 和 Looper 的支撑。MessageQueue 内部存储了一组采用单链表的数据结构来存储的消息队列，以消息队列的形式对外提供插入和删除的工作。Looper 以无限循环的形式去查看 MessageQueue 中是否又新消息并处理，没有的话则一直等待。

Looper 中的 ThreadLocal 可以在不同的线程中互不干扰的存储并提供数据。线程默认没有 Looper，需要创建。

系统不允许在子线程访问 UI 线程是因为 Android 的 UI 控件不是线程安全的，多线程兵法访问会造成不可预期的结果。

消息队列工作流程

  • MessageQueue 消息队列包含两个操作，enqueueMessage 插入消息和 next 删除消息
  • Looper 通过 Looper.prepare() 方法创建一个 Looper，接着通过 Looper.loop() 方法开启消息循环，从 MessageQueue 消息队列中去无线获取消息。消息为空时，在阻塞在 next 方法中。消息不为空时，会调用 Handler 的dispatchMessage 方法来处理消息。
  • Handler 发送消息，即向 MessageQueue 中插入一条消息。

展开全文 >>

Android设计模式

设计模式说起来总是那么抽象，自己也没做过总结，今天就来记录一下吧。

先记录下浴缸主席的几个心得，慢慢去领会一下：

  1. 设计没有对错，只有好坏之分(对于同一东西产出的不同设计，可能差异很大，可能对立，但可能都是优秀的设计)
  2. 个人要形成自己的架构观(我们熟知的设计模式，很多模式可能是不完美的，实际使用中可能要从生搬硬套开始，熟知该模式的好坏，逐步完善，形成自己的架构观)
  3. 设计的目标总是正向收益
  4. 设计的过程总会带来负面收益

3、4的意思大概是要经历九九八十一难，才能到达西天取得真经，修成正果吧。

再记录下主席关于评价一个设计好坏的几个要素，还是实践中慢慢去领会：

  1. 开闭性是否良好(一个好的设计应该能应对未来一段长时间的业务变动，业务变动时应该不能涉及到核心代码的变动)
  2. 可维护性是否良好(设计的目的应该是让代码更清晰易懂)
  3. 性能(好的设计就得性能牛逼，就算不牛逼，也不能很差才是)

设计模式基本原则

  • 单一职责原则 (Single Responsibility Principle)
  • 里氏代换原则 (Liskov Substitution Principle)—任何基类可以出现的地方，子类一定可以出现
  • 依赖倒置原则 (Dependence Inversion Principle)–抽象不应该依赖于细节，细节应该依赖于抽象。换言之，要针对接口编程，而非针对实现编程
  • 接口隔离原则 (Interfere Segregation Principle)—客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上
  • 迪米特法则 (最少知道法则) (Demeter Principle)
  • 开闭原则 (Open Close Principle)

设计模式的分类

范围 创建型 结构型 行为型
类 Factory Method (工厂方法) Adapter (类) Interpreter (解释器)
Template Method (模板方法)
对象 Abstract Factory (抽象工厂)
Builder (建造者)
Prototype (原型)
Singleton (单例)		 Adapter(对象)
Bridge(桥接)
Composite(组合)
Decorator(装饰者)
Facade(外观)
Flyweight(享元)
Proxy(代理)		 Chain of Responsibility (职责链)
Command (命令)
Iterator (迭代器)
Mediator (中介者)
Memento (备忘录)
Observer (观察者)
State (状体)
Strategy (策略)
Visitor (访问者)

更详细的分类可以看这里。

在安卓开发中，接触到的设计模式有：

  • 单例模式，application 类的使用
  • Builder 模式，Glide、AlertDialog 的使用。该模式是开闭原则的完全体现
  • Adapter 模式，RecyclerView 适配器
  • Java IO 库中，涉及到两个设计模式：装饰模式和适配器模式
  • Retrofit中使用了外观模式和动态代理模式
  • Okhttp 中 Intercepter 就是典型的职责链模式
  • RxJava 是典型的观察者模式，Android 中，点击事件也是经典的观察者模式

参考资料在这里，留着慢慢看，慢慢补充吧

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

android屌丝码农<br><br>贪财好色<br>一身正气