BLE 连接过程中有三个重要的数据包：SCAN_REQ, SCAN_RSP 和 CONNECT_REQ。

• SCAN_REQ：
  扫描请求，由主设备（MASTER DEVICE）向从设备（SLAVE DEVICE）发出，目的是为了获得从设备的响应以得到更多的从设备广播数据信息（包括设备名字，或者服务UUID，及其它如厂家特定格式的信息（如硬件版本，软件版本号，设备系列号等等）。
• SCAN_RSP:
  从设备对就主设备发起的SCAN_REQ的响应，作为广播包的补充，从设备可以给主设备更多的广播数据，比如说，有些设备在广播包里面没有设备名字，这个时候就可以把设备名字放在这个包里面发给主设备。
• CONNECT_REQ：
  主设备向从设备发出连接请求。至此连接建立完成（从设备不会响应这个请求），如果从设备没有连接上面的问题的话，以后主从双方会开始相互交换有效数据（基于GAP,GATT及SMP协议）或者交换空包。

更多内容参见一分钟读懂低功耗蓝牙（BLE)连接数据包

二、什么是MTU

MTU（MAXIMUM TRANSMISSION UNIT）最大传输单元，指在一个PDU（Protocol Data Unit：协议数据单元，在一个单元中的有效传输数据）能够传输的最大数据量（多少字节可以一次传输给对方）。

三、MTU交换的意义（设置reqeustMtu的意义）

MTU交换是为了在主从双方设置一个PDU中最大能够交换的数据量，通过MTU的交换和双方确认（注意这个MTU是不可以协商的，只是通知对方，双方在知道对方的极限后会选择一个较小的值作为以后的MTU。

比如说，主设备发出一个150个字节的MTU请求，但是从设备回应MTU是23字节，那么今后双方要以较小的值23字节作为以后的MTU），主从双方约定每次在做数据传输时不超过这个最大数据单元，MTU交换通常发生在主从双方建立连接关系后。

更多内容移步一分钟读懂低功耗蓝牙(BLE)MTU交换数据包

四、如何妥善处理数据包大小（MTU）限制

Android系统从4.3(API 18)开始支持BLE，且从5.1(API 21)才开始支持MTU修改(默认MTU仅为23字节，而且传输本身用掉3字节)。

1.为什么BLE默认限制数据传输长度为20个字节？

core spec里面定义了ATT的默认MTU为23个bytes，除去ATT的opcode一个字节以及ATT的handle 2个字节之后，剩下的20个字节便是留给GATT的了。

考虑到有些Bluetooth smart设备功能弱小，不敢太奢侈的使用内存空间，因此core spec规定每一个设备都必须支持MTU为23。

在两个设备连接初期，大家都像新交的朋友一样，不知对方底细，因此严格的按照套路来走，即最多一次发20个字节，是最保险的。

由于ATT的最大长度为512byte，因此一般认为MTU的最大长度为512个byte就够了，再大也没什么意义，你不可能发一个超过512的ATT的数据，就像是孙猴子跑不过五行山一样。

所以ATT的MTU的最大长度可视为512个bytes。

2.如何突破MTU 20字节的限制？

当我们需要传输 / 接收超过20字节长度的数据时，就需要在连接设备成功后通过BluetoothGatt#requestMtu(int mtu)方法进行对应的请求设置，示例代码如下：

private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
        @Override
        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
            super.onMtuChanged(gatt, mtu, status);
            if (status == BluetoothGatt.GATT_SUCCESS) {
                LogUtil.e(TAG, "request mtu success.约定后的MTU值为：" + mtu);
            } else {
                LogUtil.e(TAG, "request mtu failed.");
            }
        }

        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            if (status == BluetoothGatt.GATT_SUCCESS && newState == BluetoothProfile.STATE_CONNECTED) {//蓝牙连接成功
                gatt.requestMtu(39);
            }
        }
}

注意：上述代码的onMtuChanged可以发挥关键作用。MTU默认取的是23，当收到onMtuChanged后，会根据传递的值修改MTU，注意由于传输用掉3个字节，因此传递的值需要减3。

3.为什么专门记录MTU

记录MTU主要是用于传输过程中判断数据是否需要分包发送。按照MTU的大小严格约束每次发送的数据包大小，如果不这么做，很可能远端接收就会出错。除非你的数据包大小本身就很小。

4.设置完MTU后无法在BluetoothGattCallback#onConnectionStateChange方法中立即发现设备服务列表

当我们设置完MTU后，发现在BluetoothGattCallback#onConnectionStateChange方法中调用BluetoothGatt.discoverServices()无法立即触发BluetoothGattCallback#onServicesDiscovered回调。
我之前尝试过通过延迟调用BluetoothGatt#discoverServices()方法（经测大概需要延迟1000ms-1200ms）后才能够正常的获取到服务列表及发现相关特征，后来发现正确的解决方法应该是在BluetoothGattCallback#onMtuChanged回调中调用BluetoothGatt#discoverServices()方法即可解决问题。

#【本内内容参考自以下文章，侵删】

• BluetoothGatt.RequestMtu(Int32) Method

• 低功耗蓝牙（BLE）开发——如何妥善处理包大小（MTU）限制

• Android BLE中传输数据的最大长度怎么破

• BLE设备发送超过20个字节

• BLE：使用Android / iOS读取长特征值(BLE: Read Long Characteristics Value using Android / iOS)

• ble连接之后onServicesDiscovered 不被调用

• Android BLE开发设置MTU

#【写在最后】

经测，iOS在9.0以后能够正常的处理数据包过长的问题，CoreBluetooth针对长数据已经内部做出了处理，不需要额外的多次调用getValue方法，详见BLE：使用Android / iOS读取长特征值(BLE: Read Long Characteristics Value using Android / iOS)。

当前项目采用的是MVP（Model-View-Presenter）架构模式，改善了原版本简易MVP的架构方式（原MVP架构其实是VP架构——Presenter层承担了Model的工作）。

二、Project-模块化

为了各个功能模块之间解耦、便于团队协作开发及后期维护，本次新版将原有的双Module架构升级为更加细致的多Module架构，各Module命名及释义如下：

• app
  App入口，一般只包含Application、SplashActivity和MainActivity。
• base
  标准基础库，新项目可以直接使用进行开发，不涉及项目中的相关业务，一般只包含能够在各个项目中直接通用的基础类。
  如：相关的Base类、基础的Log类等。
• common
  公共资源库，base库的补充。部分工具类、UI组件等根据项目需求抽取集成，但不会涉及到具体的业务逻辑。
  如：公用的Util类、自定义的各种控件、常量类等。
• component-xxx
  部件/成分库（也叫Project组成部分），提供基础的功能实现，但不涉及具体的业务。
  如：网络请求（component-net）、视频播放（component-video）等等。
• module-xxx
  业务功能库，提供完整的业务功能实现及对应的UI效果展示。
  如：我的（module-mine）、推拿（module-mass）等。

三、屏幕（分辨率适配）

依据实际的UI设计图，我们以sw-375dp为基准进行屏幕的适配工作，相应适配文件存放于base->res/values、values-swxxxdp/measure.xml内。
在实际开发中根据UI设计图尺寸直接设置对应控件的尺寸即可（@dimen/common_measure_xxxdp），具体使用示例如下：

// 在需要使用地方添加对应的尺寸
android:layout_height="@dimen/common_measure_xxxdp"

四、项目中三方库使用规范及示例

• Java 8
  项目原则上是基于Java 8，我们使用到的部分库（ButterKnife、Retrofit、ARouter等）中也使用了Java 8的特性（比较常见的是Lambda表达式），为了确保能够正常的编译使用，我们必须在对应Module/build.gradle文件中手动添加Java 8支持，具体如下：

  android {
      ...
      compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
      }
      ...
  }
  

• ButterKnife
  • 概述
    一个专注于Android系统的View依赖注入框架，省去了findViewById、setOnClickListener等重复代码，简化代码、提高开发效率。
  • 使用规范
    这里我们使用的是ButterKnife-10.2.3版本，区别于app中使用的R.id.xxx映射方式，在Module/Library中需要通过R2.id.xxx去映射对应的控件。
  • 示例

        @BindView(R2.id.mine_iv_icon)
        RoundImageView mIvIcon;
    

  • 注意事项
    在使用该库的每个类的build.gradle文件中要添加如下配置：

    apply plugin: 'com.android.library'
    apply plugin: 'com.jakewharton.butterknife'
    
        dependencies {
            ...
            annotationProcessor rootProject.ext.dependencies['butterknife-compiler']
            ...
        }
    

• ARouter
  • 概述
    一款阿里开源的路由框架，是一个帮助Android进行模块化、组件化开发的开源库。它支持模块间的路由、通信、解耦。
  • 使用规范
    在开发过程中，当我们对要进行跳转的页面上添加支持路由的注解时，我们需要遵循以下规则：
    路径需要注意的是至少需要有两级，/xx/xx，我们以/moduleName/className为基准进行对应的命名。
  • 使用示例

        @Route(path = "/mine/mineActivity")
        public class MineActivity{
        ...
        }
        ```
    

  • 注意事项
    在使用该库的每个类的build.gradle文件中要添加如下配置：

    android {
        ...
        defaultConfig {
            ...
            // ARouter--每个使用到路由的Module必须加
            javaCompileOptions {
                annotationProcessorOptions {
                    arguments = [AROUTER_MODULE_NAME: project.getName()]
                }
            }
            ...
        }
        ...
    }
    dependencies {
        // ARouter--每个使用到路由的Module必须加
        annotationProcessor rootProject.ext.dependencies['arouter-compiler']
    }
    

五、数据存储

• SQLite
  一个轻量级的数据库。数据库操作Helper类，放置在common中，相关的常量Key类也可以放置在common，其它具体的表操作由各个Module自行维护。
• SharedPreferences
  一个轻量级的存储类，解决在开发过程中我们需要保存一些简单的、轻量的数据。如：用户设置、一些开关/判断的标记等，这些需要保存的数据往往可能只是一两个字符，这种数据我们使用SharedPreferences保存即可。
  放置在common中，相关的常量Key类也可以放置在common.
• Native Files
  当我们在开发过程涉及到一些需要缓存的文件时，很多应用采取的策略是到SD卡的根目录上创建自己的文件夹然后保存到对应的文件路径下（之前的泰邦设计也是这样做的），虽然达到了缓存文件的目的，但它并不被Android所推荐——当应用卸载后，这些被创建的文件夹仍然存在，造成手机内多出了不少的垃圾文件，这样是极不友好的。
  Android建议我们在缓存文件时使用应用专属（这里又分内部存储与外部存储，建议是尽可能使用外部存储进行缓存）的缓存路径进行文件的缓存，当应用被卸载后，这些数据也会随之而消失，从而规避了上述问题。
  关于应用专属内、外部存储的更多了解，建议阅读以下文章或自行了解后再进行相关的操作：
  彻底搞懂Android文件存储---内部存储，外部存储以及各种存储路径解惑
  Android文件缓存目录
  重点关注：getExternalCacheDir、getExternalFilesDir。

六、Other

未完待续...

IDE：AndroidStudio 4.0.1版本
通过Build->Generate Singed Bundle or APK生成debug版本的apk，不能够在其它手机上正常安装（亲测在华为、VIVO上出现），具体如图：

错误分析

经查证是因为Android Studio 3.0.0以后的版本默认会在debug apk的Manifest文件的Application的标签里自动添加andorid:testOnly="true"属性，导致IDE中跑出来的、打包的APK只能用adb install -t <apk>来安装了。

什么是android:testOnly？
它是用于判断应用是否是用于测试用途的一个标识。当值为true时，代表它时测试用途，一般情况下时不能够安装到其它设备上的，需要通过特殊的方式去安装（只能通过USB调试安装或adb安装——安装时需要加上-t这个标记）。

解决办法

在项目根目录的gradle.properties中添加andorid:testOnly="false"即可。

相关文章

Android Studio 3.0 and FLAG_TEST_ONLY
ADB Install Fails With INSTALL_FAILED_TEST_ONLY

其它状态码参照：Android BLE Gatt返回错误对应宏
BLE操作成功或失败status code对应解释

// 自动化打包配置-签名信息
signingConfigs {
    release {// 线上环境
        keyAlias 'xxx'// key别名，如taibang
        keyPassword 'xxxxxxxx'// key密码
        storeFile file('/xxx.jks')// 密钥文件路径，如/taibang.jsk
        storePassword 'xxxxxxxx'// 密钥文件密码
        v1SigningEnabled true
        v2SigningEnabled true
    }

    debug {// 开发环境
        keyAlias 'xxx'
        keyPassword 'xxxxxxxx'
        storeFile file('/xxx.jks')
        storePassword 'xxxxxxxx'
        v1SigningEnabled true
        v2SigningEnabled true
    }
}

二、产品风味（特点）的DefaultConfig配置

flavorDimensions "channel" // 特点维度，为了让多渠道包间的纬度统一，方便productFlavors维度统一

关于flavorDimensions的具体解释可参考下文：
FLAVORDIMENSIONS多维度理解(版本差异化打包)

三、产品风味（特点）/ 多渠道配置productFlavors

// 多渠道信息配置
productFlavors {
    taibang {// 默认就是泰邦健康管家渠道
        dimension "channel"
    }

    qfjp {
        dimension "channel"
    }
}

#四、 统一配置多渠道信息

// 统一配置多渠道信息
productFlavors.all { flavor ->
    flavor.manifestPlaceholders = [XXX_CHANNEL: name] // 如BUGLY_APP_CHANNEL
}

五、配置自动构建后的apk文件名称

    // 配置构建后apk的文件名称
    applicationVariants.all { variant ->
        variant.outputs.all { output ->
            def buildName = "TaiBang"
            def type = variant.buildType.name
            def releaseApkName
            releaseApkName = buildName + '_' + "${defaultConfig.versionName}" + '_' + type + "_" + "${releaseTime()}" + '.apk'
            outputFileName = releaseApkName
        }
    }

在app/build.gradle内的android标签外新增releaseTime方法：

android {
    ...
}

/**
 * 定义的打包时间
 * @return
 */
static def releaseTime() {
    return new Date().format("yyyyMMddHHmm", TimeZone.getTimeZone("GMT+08:00"))
}

六、构建类型buildTypes配置

buildTypes默认有debug、release两个构建类型，可以根据需要新增

buildTypes {
    release {
        minifyEnabled false
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        signingConfig signingConfigs.release
    }

    debug {
        minifyEnabled false
        signingConfig signingConfigs.debug
    }
}

七、自动构建对应渠道/类型的apk包

点开Android Studio右侧的Gradle工具栏，找到ProjectName->Tasks->Build->assembleDebug/assembleRelease/assembleBuildTypes/assembleProductFlavors即可构建对应渠道/类型下的apk包，输出路径为默认的app/build/outputs/apk/对应路径。

AndroidStudio多渠道打包，生成不同app
Android Studio配置Gradle（包括signingConfigs、buildTypes和productFlavors等）

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用Decorator（装饰者）模式。
扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

例如，你可以为一个你不能修改的、来自第三方库中的类编写一个新的函数。 这个新增的函数就像那个原始类本来就有的函数一样，可以用普通的方法调用。 这种机制称为 扩展函数 。此外，也有 扩展属性 ， 允许你为一个已经存在的类添加新的属性。

在Java中没有扩展方法这个概念，Kotlin的扩展方法类似于Java中的工具类中的方法。

二、扩展函数

扩展函数可以在已有类中添加新的方法，不会对原类做修改。

• 扩展函数定义形式

  fun receiverType.functionName(params) {
      // body    
  }
  

  • receiverType：表示函数的接收者
  • functionName：扩展函数的名称
  • params：扩展函数的参数，可以为NULL

• 扩展函数示例

  class User(var name: String)
  
  // 扩展函数
  fun User.printName(){
      println("用户名 $name")
  }
  
  fun main(args: Array<String>) {
      var user = User("Robin")
      user.printName();
  }
  

三、扩展函数是静态解析的

扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的，具体示例如下：

open class SimpleClass
class SubClass: SimpleClass

fun SimpleClass.foo() = "ABC"// 扩展函数 foo
fun SubCLass.f00() = "DEF"

func printFoo(c: SimpleClass) {
    println(c.foo())
}

fun main(args: Array<String>) {
    printlnFoo(SubClass())
}

输出结果为：
ABC

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

class SimpleClass {
    fun foo() {
        println("成员函数")
    }
}

fun SimpleClass.foo() {
    println("扩展函数")
}

fun main(args: Array<String>) {
    var c = SimpleClass()
    c.foo()
}

实际输出结果为：
成员函数

四、扩展一个空对象

在扩展函数内，可以通过this来判断接收者是否为NULL，即使接收者为NULL，也可以调用扩展函数，如：

fun Any?.toString(): String {
    if (this == null) return "null"
    // 空检测之后，"this"会自动转换为非空类型，所以下面的toString()解析为Any类的成员函数
    return toString()
}

fun main(args: Array<String>) {
    var t = null
    println(t.toString())
}

实际输出结果为：
null

五、扩展属性

除了函数，Kotlin也支持对属性进行扩展：

val <T> List<T>.lastIndex: Int
    get() = size - 1

扩展属性允许定义在类或者Kotlin文件中，不允许定义在函数中。初始化属性因为属性没有后端字段（back field），所以不允许被初始化，只能由显式的getter/setter定义。

val Foo.bar = 1 // 错误：扩展属性不能有初始化器

六、伴生对象的扩展

如果一个类定义有一个伴生对象，你也可以为伴生对象定义扩展函数和属性。
伴生对象通过“类名.”形式调用伴生对象，伴生对象声明的扩展函数，通过用类名限定符来调用：

class MyClass {
    companion object { } //将被称为companion
}

fun MyClass.Companion.foo() {
    println("伴生对象的扩展函数")
}

val MyClass.Companion.no: Int
    get() = 10

fun main(args: Array<String>) {
    println("no:${MyClass.no}")
    MyClass.foo()
}

实力执行后输出结果为：

no:10
伴生对象的扩展函数

伴生对象内的成员相当于 Java 中的静态成员，其生命周期伴随类始终，在伴生对象内部可以定义变量和函数，这些变量和函数可以直接用类名引用。

对于伴生对象扩展函数，有两种形式，一种是在类内扩展，一种是在类外扩展，这两种形式扩展后的函数互不影响（甚至名称都可以相同），即使名称相同，它们也完全是两个不同的函数，并且有以下特点：

1. 类内扩展的伴随对象函数和类外扩展的伴随对象可以同名，它们是两个独立的函数，互不影响；
2. 当类内扩展的伴随对象函数和类外扩展的伴随对象同名时，类内的其它函数优先引用类内扩展的伴随对象函数，即对于类内其它成员函数来说，类内扩展屏蔽类外扩展；
3. 类内扩展的伴随对象函数只能被类内的函数引用，不能被类外的函数和伴随对象内的函数引用；
4. 类外扩展的伴随对象函数可以被伴随对象内的函数引用
   例如以下代码：

class MyClass {
    companion object {
        val myClassField1: Int = 1
        var myClassField2 = "this is myClassField2"
        fun companionFun1() {
            println("this is 1st companion function.")
            foo()
        }
        fun companionFun2() {
            println("this is 2st companion function.")
            companionFun1()
        }
    }
    fun MyClass.Companion.foo() {
        println("伴随对象的扩展函数（内部）")
    }
    fun test2() {
        MyClass.foo()
    }
    init {
        test2()
    }
}
val MyClass.Companion.no: Int
    get() = 10
fun MyClass.Companion.foo() {
    println("foo 伴随对象外部扩展函数")
}
fun main(args: Array<String>) {
    println("no:${MyClass.no}")
    println("field1:${MyClass.myClassField1}")
    println("field2:${MyClass.myClassField2}")
    MyClass.foo()
    MyClass.companionFun2()
}

运行结果：

no:10
field1:1
field2:this is myClassField2
foo 伴随对象外部扩展函数
this is 2st companion function.
this is 1st companion function.
foo 伴随对象外部扩展函数

七、扩展的作用域

通常扩展函数或属性定义在顶级包下：

package foo.bar

fun Baz.goo() {...}

要使用所定义包之外的一个扩展，通过import到入扩展函数名进行使用：

package com.example.usage

import foo.bar.goo // 导入所有名为goo的扩展
// 或者从foo.bar导入一切
import foo.bar.*

fun usage(baz: Baz) {
    baz.goo()
}

八、扩展声明为成员

在一个类内部你可以为另一个类声明扩展。
在这个扩展中，有多个隐含的接收者，其中扩展方法定义所在类的实例成为分发接收者，而扩展方法的目标类型的实例成为扩展接收者。

class D {
    fun bar () { println("D bar") }
}

class C {
    fun baz() { println("C baz") }

    fun D.foo() {
        bar () // 调用D.bar
        baz () // 调用C.baz
    }

    fun caller(d: D) {
        d.foo() // 调用扩展函数
    }
}

fun main(args: Array<String>) {
    val c: C = C()
    val d: D = D()
    c.caller(d)
}

实力输出结果为:

D bar
C baz

在C类中，创建了D类的扩展。此时，C被称为分发接收者，而D为扩展接收者。
从上例中，可以清楚的看到，在扩展函数中，可以调用派发接收者的成员函数。
假如在调用某一个函数，而该函数在分发接收者和扩展接收者均存在，则以扩展接收者优先，要引用分发接收者的成员你可以使用限定的this语法。

class D {
    fun bar () { println("D bar") }
}

class C {
    fun bar() { println("C bar") } // 与D类的bar同名

    fun D.foo() {
        bar () // 调用D.bar，扩展接收者优先
        this@C.bar () // 调用C.bar
    }

    fun caller(d: D) {
        d.foo() // 调用扩展函数
    }
}

fun main(args: Array<String>) {
    val c: C = C()
    val d: D = D()
    c.caller(d)
}

实力输出结果为:

D bar
C bar

以成员的形式定义的扩展函数，可以声明为open，而且可以在子类中覆盖，也就是说，在这类扩展函数的派发过程中，针对分发接收者是虚拟的（Virtual），但针对扩展接收者仍然是静态的。

open class D {
}

open class D1: D {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()
    }
}

class C1: C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

fun main(args: Array<String>) {
    C().caller(D()) // 输出“D.foo in C”
    C1().caller(D()) // 输出“D.foo in C1”--分发接收者虚拟解析
    C().caller(D1()) // 输出“D.foo in C”--扩展接收者静态解析
}

实力执行输出结果为：

D.foo in C
D.foo in C1
D.foo in C

• java中定义类

  public class SimpleClass {
      // 定义成员变量
      public int x;
  
      // 定义构造方法
      public SimpleClass(int x) {
          this.x = x;
      }
  
      // 定义方法
      public void y() {
      }
  }
  

• kotlin中定义类

  • 副构造器写法

    class SimpleClass {// Kotlin中的类默认都是public
        // 定义成员变量，Kotlin中必须初始化
        var x: Int = 0
    
        // 定义构造方法，对应Kotlin中的副构造器
        constructor(x: Int) {
            this.x = x
        }
    
        // 定义方法
        fun y() {
        }
    }
    

  • 主构造器写法

    // 对应Kotlin中的主构造器的概念，主构造器要求其它所有的构造器都要调用它
    class SimpleClass
            constructor(x: Int){
                var x: Int = x
    }
    
    // 精简写法
    class SimpleClass(x: Int){
                var x: Int = x
    }
    
    // 精简写法2
    class SimpleClass(var x: Int){
    }
    

二、类的实例化

• Java中类的实例化

  SimpleClass simpleClass = new SimpleClass(1)
  System.out.println(simpleClass.x);
  simpleClass.y();
  

• Kotlin中类的实例化

  val simpleClass = SimpleClass(2)
  println(simpleClass.x)
  simpleClass.y()
  

三、接口的定义

• Java中接口的定义

  public interface SimpleInterface {
      void simpleMethod();
  }
  

• Kotlin中接口的定义

  interface SimpleInterface {
      fun simpleMethod()
  }
  

四、接口的实现

• Java中接口的实现

  public class SimpleClass
          implements SimpleInterface {
              ...
              @Override
              public void simpleMethod(){
              }
  }
  

• Kotlin中接口的实现

  class SimpleClass(var x: Int)
      : SimpleInterface {
          ...
          override fun simpleMethod() {
          }
  }
  

注：Java中的Override是jdk 1.5以后引入的一个注解，在Java中它不是强制必须要添加的，在Kotlin中你必须要添加override关键字；
Override表示覆盖，它是一个比较危险的行为——有可能会覆写到别人的方法。

五、抽象类的定义

• Java中抽象类的定义

  public abstract class AbsClass {
      // 抽象方法，它是一定用来被覆写的
      public abstract void absMethod();
      // 未添加final关键字的方法默认也是可以被覆写的
      protected void overrideable() { }
      // 添加final关键字的方法不能被覆写
      public final void nonOverrideable() { }
  }
  

• Kotlin中抽象类的定义

  abstract class AbsClass {
      // 抽象方法，它是一定用来被覆写的
      abstract fun absMethod()
      // Kotlin抽象类中的方法默认不可以被覆写，你必须添加open关键字才能够对它进行覆写
      open fun overrideable() { }
      fun nonOverrideable() { }
  }
  

注意：
1.Java和Kotlin抽象类中的抽象方法都可以被覆写；
2.Java抽象类中的其它方法默认是可以被覆写的，而Kotlin中则默认不可以被覆写；
3.Java抽象类中在方法前添加final关键字可以保证该方法不能被覆写；
4.Kotlin抽象类中在方法前添加open关键字可以允许该方法能被覆写。

六、类的继承

• Java中类的继承

  public class SimpleClass
      extends AbsClass implements SimpleInterface {
          ...
  }
  

• Kotlin中类的继承

  // kotlin在继承类的时候相对实现接口会在类名后多一个()，因为它调用了父类的构造方法
  class SimpleClass(var x: Int)
      : AbsClass(), SimpleInterface {
          ...
  }
  

七、属性Property

Java中没有属性这个概念，而是通过语法约定的形式来实现

public class Person {
    private int age;// field-领域
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Kotlin中的属性Property

class Person(age: Int) {
    var age: Int = age // Property，它等于Java中的filed+get+set
        get() {
            return filed
        }
        set(value) {
            filed = value
        }
}

八、属性引用

Kotlin中的属性引用类似于函数引用

// 未绑定Receiver
val ageRef = Person::age
val person = Person(18)
ageRef.set(person, 22)

// 绑定Receiver
val ageRef2 = person::age
ageRef2.set(33)

• 格式：
  关键字(fun) 函数名(参数列表): 返回值类型{
  // 函数体
  }
• 示例：

  fun main(args: Array<String>): Unit {// Unit等价于Java中的void，函数返回值为Unit可省略
      println(args.contentToString)
  }
  

二、函数 vs 方法

• 方法可以认为是函数的一种特殊类型
• 从形式上，有receiver(接收者)的函数即为方法

      @JvmStatic
      fun main(vararg args: String) {
          val foo: Foo = Foo();
          foo.bar("helloKotlin", 0L) // foo就是上文所述的receiver
      }
  
      class Foo {
          fun bar(p0: String, p1: Long): Any {
              println("The first param is $p0")
              return p1
          }
      }
  

注：其实所谓的方法就是外面套了一个类，它的receiver就是外面套的类的实例。

三、函数的类型

四、函数的引用

• 函数的引用类似于C语言中的函数指针，可以用于函数传递

  fun foo() {}// 定义函数
  ::foo// 函数引用
  val f: () -> Unit = ::foo// 定义变量接收引用
  
  fun foo(p0: Int): String {...}
  ::foo
  val g: (Int) -> String = ::foo
  
  // 带有receiver的函数引用
  class Foo {
      fun bar(p0: String,p1: Long): Any {...}
  }
  Foo::bar
  val h: (Foo, String, Long) -> Any = Foo::bar
  
  val foo = Foo()
  val m: (String, Long) -> Any = foo::bar // 绑定receiver的函数引用
  

五、变长参数

变长参数就是指我们在调用一个函数的时候可以根据情况传入不同数量的参数，个数在调用之前是不确定的，在调用的时候长度、类型都是确定的。

• java中的变长参数:

  public static void main(String[] args) {
  //
  }
  

• kotlin中的变长参数：

  fun main(args: Array<String>) {
  //
  }
  

六、多返回值

多返回值返回值的个数是确定的，但是是多个。

• kotlin中的多返回值

  fun multiReturnValues(): Triple<Int, Long, Double> {
      return Triple(3, 4L, 5.0);
  }
  
  val (a, b, c) = multiReturnValues()
  

七、默认参数

• 函数的定义：

      /**
      * 默认参数
      */
      fun defaultParameter(x: Int, y: String, z: Long = 0L) {
          println("defaultParameter")
      }
  

• 函数的使用

      // 默认参数
      defaultParameter(1, "test")
  

八、具名参数

    /**
     * 默认参数
     */
    fun defaultParameter(x: Int = 5, y: String, z: Long = 0L) {
        println("defaultParameter")
    }

    // 具名参数--形参y来显示接收参数
    defaultParameter(y = "HelloX")

1. 基础的指令配置

-optimizationpasses 5 # 指定代码的压缩级别
-dontusemixedcaseclassnames # 混淆后类名都为小写
-dontskipnonpubliclibraryclasses #指定不去忽略非公共的库的类
-dontskipnonpubliclibraryclassmembers #指定不去忽略非公共的库的类的成员
-dontpreverify # 不做预校验的操作
-verbose # 混淆时是否记录日志
-printmapping proguardMapping.txt #生成原类名和混淆后的类名的映射文件
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*  # 混淆时所采用的算法
-keepattributes *Annotation*,InnerClasses #不混淆Annotation
-keepattributes Signature #不混淆泛型
-keepattributes SourceFile,LineNumberTable #抛出异常时保留代码行号
-ignorewarnings #抑制警告

2. 一些通用的必要配置

#系统类不需要混淆
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class * extends android.view.View
-keep public class com.android.vending.licensing.ILicensingS
-keep class android.support.** {*;}
-keep public class * extends android.app.Fragment

-keepclasseswithmembernames class * {  # 保持 native 方法不被混淆
    native <methods>;
}
-keepclassmembers class * extends android.app.Activity { # 保持自定义控件类不被混淆
    public void *(android.view.View);
}
-keepclassmembers enum * {# 保持枚举 enum 类不被混淆
    public static **[] values();
    public static ** valueOf(java.lang.String);
}
-keep public class * extends android.view.View{# 保持View类不被混淆
    *** get*();
    void set*(***);
    public <init>(android.content.Context);
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keepclasseswithmembers class * {# 保持自定义控件类不被混淆
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keep class * implements android.os.Parcelable { # 保持 Parcelable 不被混淆
    public static final android.os.Parcelable$Creator *;
}
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}
-keep class **.R$* {
 *;
}
-keepclassmembers class * {
    void *(**On*Event);
}

#WebView相关
-keepclassmembers class fqcn.of.javascript.interface.for.Webview {
   public *;
}
-keepclassmembers class * extends android.webkit.WebViewClient {
    public void *(android.webkit.WebView, java.lang.String, android.graphics.Bitmap);
    public boolean *(android.webkit.WebView, java.lang.String);
}
-keepclassmembers class * extends android.webkit.WebViewClient {
    public void *(android.webkit.WebView, java.lang.String);
}

# 其它
-keep class com.google.android.gms.** {*;}
-dontwarn com.google.android.gms.**
-dontwarn com.viewpagerindicator.*
-dontwarn com.amazonaws.**
-dontnote com.google.vending.licensing.ILicensingService
-dontnote com.android.vending.licensing.ILicensingService


# Androidx相关
-keep class com.google.android.material.** {*;}
-keep class androidx.** {*;}
-keep public class * extends androidx.**
-keep interface androidx.** {*;}
-dontwarn com.google.android.material.**
-dontnote com.google.android.material.**
-dontwarn androidx.**

3. 实体类

# 可能会存在多处，需要一一添加
-keep class 包名.bean.** {*;}

4. 第三方Library

# 本地.so库文件声明
-libraryjars libs/armeabi/xxx.so
-libraryjars libs/armeabi-v7/xxx.so
-libraryjars libs/x86/xxx.so

# 常用第三方Library混淆配置
# Glide
-keep public class * implements com.bumptech.glide.module.GlideModule
-keep public class * extends com.bumptech.glide.module.AppGlideModule
-keep public enum com.bumptech.glide.load.resource.bitmap.ImageHeaderParser$** {
  **[] $VALUES;
  public *;
}

# Alipay
-dontwarn com.alipay.**
-dontwarn com.ta.utdid2.**
-dontwarn com.ut.device.**
-dontwarn android.net.**
-keep class com.alipay.** {*;}
-keep class com.ta.utdid2.** {*;}
-keep class com.ut.device.** {*;}
-keep class android.net.SSLCertificateSocketFactory

# butterknife
-keep class butterknife.** {*;}
-dontwarn butterknife.internal.**
-keep class **$$ViewBinder {*;}
-keepclasseswithmembernames class * {
    @butterknife.* <fields>;
}
-keepclasseswithmembernames class * {
    @butterknife.* <methods>;
}

# eventbus
-keepattributes *Annotation*
-keepclassmembers class ** {
    @com.google.common.eventbus.Subscribe <methods>;
        public void onEvent*(**);
        void onEvent*(**);
}
-keep enum de.greenrobot.event.ThreadMode {*;}
-keepclassmembers class * extends de.greenrobot.event.util.ThrowableFailureEvent {
    <init>(java.lang.Throwable);
}

# Gson
-dontwarn com.google.gson.**
-keep class com.google.gson.** {*;}
-keep class sun.misc.Unsafe {*;}

# 科大讯飞相关(ifly_push_sdk && Msc)
-dontwarn com.iflytek.**
-keep class com.iflytek.** {*;}

# 腾讯相关(libammsdk && open_sdk)
-dontwarn com.tencent.**
-keep class com.tencent.** {*;}

# weibosdkcore
-dontwarn com.sina.weibo.sdk.**
-keep class com.sina.weibo.sdk.** {*;}

# Dagger
-dontwarn dagger.internal.codegen.**
-dontwarn javax.inject.**
-keepclassmembers,allowobfuscation class * {
    @javax.inject.* *;
    @dagger.* *;
    <init>();
}
-keep class dagger.** {*;}
-keep class javax.inject.** {*;}
-keep class * extends dagger.internal.Binding
-keep class * extends dagger.internal.ModuleAdapter
-keep class * extends dagger.internal.StaticInjection

这里要注意的一点是，要避免重复声明jar包——如果在build.gradle中使用了compile fileTree(include: ['*.jar'], dir: 'libs')，就不需要在混淆文件中添加-libraryjars libs/xxx.jar去声明对应的jar了，否则会报错提示重复添加。

5. 反射类及其相关方法

-keep class java.lang.annotation.** {*;}

6. JS相关交互类(方法互调)

二、Module（aar、lib)混淆配置

我们在封装aar、lib提供给他人使用时，为了保证功能能够正常的被使用，往往需要告知别人针对aar、lib进行免混淆配置以保证aar、lib中的一些关键类不被混淆以免影响正常使用。（github上很多Library的README.md文件中都有对应的混淆清单提示）
但是在实际的使用过程中，经常有用户会忘记在App中进行对应的aar、lib的免混淆配置，导致其功能不能正常使用（打包后关键类被混淆），这样的的操作是很不友好的。

AndroidStudio在3.x之后，其实已经为我们提供了新的解决办法，在新建Module后，我们会发现Module下有了proguard-rules.pro、consumer-rules.pro两个文件，而在Module/build.gradle配置文件的defaultConfig中，我们会发现有个consumerProguardFiles配置，它其实就是为了解决aar、lib混淆配置后App没有进行对应的配置导致aar、lib的配置未生效的问题。

正确的解决方案（只需在aar、lib中进行对应的混淆配置，即便引用的App在混淆时不针对aar、lib进行对应的配置，打包后也不会影响aar、lib的正确混淆）：
在Module/build.gradle中配置（Android 3.x后会默认生成该配置）：

android {
    defaultConfig {
        consumerProguardFiles 'consumer-rules.pro'
    }
}

然后在在Module/consumer-rules.pro文件中进行具体的混淆配置。

拓展阅读

整理Android最全的混淆规则大全（最新的开源框架混淆）
Android混淆
Android Studio的Proguard（代码混淆）
Android 配置中的 consumerProguardFiles

Kotlin中集合框架相对于Java：

1. 增加了“不可变”集合框架的接口；
2. 没有另起炉灶，复用Java API的所有实现类型；
3. 提供了丰富易用的方法，例如forEach/map/flatMap；
4. 运算符级别的支持，简化了集合框架的访问。

二、集合框架的接口类型对比

注：Mutable标识可变的。

三、集合框架的创建

1.List的创建

• Java中创建List

    List<Integer> intList = new ArrayList<>(Arrays.asList(1, 2, 3));
  

• Kotlin中创建List

    // 不可变List：不能添加或者删除元素
    val intList: List<Int> = listOf(1, 2, 3)
  
    // 可变List：可以添加或者删除元素
    val intList2: MutableList<Int> = mutableListOf(1, 2, 3)
  

2.Map的创建

• Java中创建Map

     Map<String, Object> map = new HashMap<>();
      map.put("zhangsan", 20)；
  

• Kotlin中创建Map

     // 不可变
      // "name" to "zhangsan"，这里可以理解为K-V(Key to Value)即可
      // Any等价于Java中的Object
      val map: Map<String, Any> = mapOf("name" to "zhangsan", "age" to 22)
  
      // 可变
      val map2: MutableMap<String, Any> = mutableMapOf("name" to "zhangsan", "age" to 22)
  

四、集合实现类服用与类型别名(Kotlin特性)

以下是集合对应的类型别名：

    typealias ArrayList<E> = java.util.ArrayList<E>
    typealias LinkedHashMap<K, V> = java.util.LinedHashMap<K, V>
    typealias HashMap<K, V> = java.util.HashMap<K, V>
    typealias LinedHashSet<E> = java.util.LinedHashSet<E>
    typealias HashSet<E> = java.util.HashSet<E>

五、集合框架的修改

1. 添加元素
   • java

        for(int i = 0; i< 10; i++){
                stringList.add("num:" + i);
        }
     

   • kotlin

        for(i in 0 .. 10){
            stringList += "num:$i"
        }
     

2. 移除元素
   • java

        for(int i = 0; i< 10; i++){
                stringList.remove("num:" + i);
        }
     

   • kotlin

        for(i in 0 .. 10){
            stringList -= "num:$i"
        }
     

六、集合框架的读写

• java

    // List的读写
    stringList.set(3, "HelloWorld");
    String valueAt3 = stringList.get(3);

    // Map的读写
    HashMap<String, Integer> map = new HashMap<>();
    map.put("Hello", 10);
    System.out.println(map.get("Hello"));

• kotlin

    // List的读写
    stringList[3] = "HelloWorld"
    val valueAt3 = stringList[3]

    // Map的读写
    val map = HashMap<String, Int>()
    map["Hello"] = 10
    println(map["Hello"])

    // []内的值实际上就是key

七、Pair

Pair表示两个值的通用对（键值对），这个是Kotlin独有的。

    val pair = "Hello" to "Kotlin"
    val pair2 = Pair("Hello", "Kotlin")
    val first = pair.first
    val second = pair.second

    // 解构表达式，相当于把pair拆分给x,y
    val (x, y) = pair

八、Triple（类似Pair，用于三个元素的键值对维护）

    val triple = Triple("x", 2, 3.0)
    val first = triple.first
    val second = triple.second
    val third = triple.third
    val (x, y, z) = triple

--