OKHttp设置Header的那些坑

发表于 2017-06-21 | 更新于 2018-09-21 | 分类于 Android

项目中网络底层库使用的okhttp，但是上层使用的Volley和glide；于是就设计的到了通用的请求header设置。于是通过Interceptor给设置的统一的header，但是okhttp的api确实有点坑啊。上线后发现图片的请求有两个UA，而且两个UA一个是我们设置的一个是glide默认的。
排查发现我们调用的Request.Builder.addHeader(k, v) 这个api是添加header，不会移除调之前有的header信息，比如设置UA，glide库设置了一个默认值，而我们又调用了这个api，这就产生了两个重复的UA。
正确的api是调用Request.Builder.header(k, v)来设置header，这个api会覆盖之前已有的header。
也可以先通过Request.Builder.removeHeader(K)先移除，然后再调用addHeader(K, V)

序列化-transient修饰符

发表于 2017-06-21 | 更新于 2018-09-21 | 分类于 Java

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

常用git命令

发表于 2017-06-20 | 更新于 2018-09-21 | 分类于 Other

作者总结的很不错，非常适合git入门人员使用，转过来，并注明出处。来自于android开发精选公众号
常用git命令&version=12020110&nettype=WIFI&fontScale=100&pass_ticket=EECAVbQT98lTVrzTbXb78HOWwpX4a7eQQ7AS4ZidkNO3dzrZe6cK%2BFuOA8Jw47sk)

Gradle屏蔽指定的Task

发表于 2017-06-13 | 更新于 2018-09-21 | 分类于 Android

公司项目使用了Fabric 进行crash的统计，但是最近不知是何故，fabric的几个域名无法访问了，更悲催的是fabric的gradle插件中有个任务需要访问这个域名上传一些编译生成的信息，这就直接导致客户端无法打正式的release包，一直卡在crashlyticsUploadDeobsRelease这个task。
测试了各种办法:a. 公司网络有没有对fabric指定的域名做黑名单； b. 通过代理vpn访问指定fabric的域名；均没有结果。
好吧，活人不能被尿憋死，只能放大招了，屏蔽调这个task。原理很简单获取到这个task，然后将enable属性设置成false。
gradle屏蔽掉指定的task

allprojects {
    repositories {
        jcenter()
    }

    //skip Test tasks
    gradle.taskGraph.whenReady {
        tasks.each { task ->
            if (task.name.contains("crashlyticsUploadDeobsRelease"))
            {
                task.enabled = false
            }
        }
    }

}

Java堆和栈区别简介

发表于 2017-03-20 | 更新于 2018-09-21 | 分类于 Java

Heap: 堆
Stack: 栈
Heap内存的分配也叫动态内存分配

Stack内存相对于线程而言，执行函数时，内部变量的存储放在栈上边创建。Stack主要保存线程中方法中短期存在的变量值和对Heap中对象的引用。

区别:

堆不需要连续内存，空间较大；栈是连续内存的区域，大小有操作系统决定。
堆管理麻烦，频繁的new或者remove造成内存碎片，导致效率低下；栈，先进后出，进出不会产生碎片，效率高且稳定。
java的GC是针对heap内存的，因为stack内存在函数出栈时就被销毁了。
方法中变量:存在stack栈中；类成员变量存在Heap堆中

应用分包主dex过大那些事儿

发表于 2017-03-20 | 更新于 2018-09-21 | 分类于 Android

Too many classes in –main-dex-list, main dex capacity exceeded

com.android.dex.DexException: Too many classes in --main-dex-list, main dex capacity exceeded
  at com.android.dx.command.dexer.Main.processAllFiles(Main.java:494)
  at com.android.dx.command.dexer.Main.runMultiDex(Main.java:332)
  at com.android.dx.command.dexer.Main.run(Main.java:243)
  at com.android.dx.command.dexer.Main.main(Main.java:214)
  at com.android.dx.command.Main.main(Main.java:106)

随着项目的不断更新迭代，第三方sdk的不断引入，我们虽然很早之前就进行了分包的操作，然而最近却又发生了，令人感到可恶的事情，那就是不知不觉中main-dex竟然又超了。这可如何是好，真是没有救了。好吧，不废话了，直接说一下我们的处理。
首先关注你的项目的buildToolsVersion版本号 :
一、情况之一就是buildToolsVersion < 24
我们最初就是这种情况，于是我们商定了几个解决的方案:
a. 通过对proguard文件的处理，尽量减小keep住的代码，希望能以此保证dex中class类数量不超限。
由于之前没有对proguard文件进行限制，所以导致很多keep的范围特别广，比如keep com.google和keep com.tencent这种的，这种其实不可避免的会导致dex中可能含有一些不必要的类。
经过我们的kepp处理，确实达到了一个能够是主dex不超限的临界值，但是，这个不能解决问题，因为版本迭代更新肯定会再次变大，于是我们想到了使用b方案
b. 从主dex中移除第三方sdk中的activity以及activity引用的类
如果你去查资料你会发现，好多国外的项目也同样遇到了，这种尴尬的问题，他们的方法其实就是移除了所有的activity和activity引用类。详情查看blog: http://blog.osom.info/2014/12/too-many-methods-in-main-dex.html .
此处我说一下Android gradle插件版本在2.0之上的解决方式，更低版本的插件，其实解决方式更为简单，请google一下即可

afterEvaluate {
        tasks.matching {
            it.name.startsWith('collect') && it.name.endsWith('MultiDexComponents')
        }.each{
            println "main-dex-filter: found task $it.name"
            it.filter { name, attrs ->
                def componentName = attrs.get('android:name')
                if ('activity'.equals(name)) {
                    //注意此处的过滤条件，写你自己需要过滤的类的相关过滤条件
                    if(componentName.contains("com.netease.newsreader.activity.debug") || componentName.contains("com.netease.epay.sdk") ){
                        //包含debug和epay相关的activity
                        println "debug code and epay code : main-dex-filter: skipping, detected activity [$componentName]"
                        return false
                    }
                    else if(componentName.contains("com.netease.newsreader.activity") || componentName.contains("com.netease.nr")){
//                      当前包代码
                        println "main-dex-filter: keeping, detected $name [$componentName]"
                        return true
                    }
                    return true
                } else {
                    println "main-dex-filter: keeping, detected $name [$componentName]"
                    return true
                }
            }
        }
}

简单的说明一下这种方式的原理: 就是在生成主dex组件之前，我们强制过滤调含有第三方activity的类，这样，根据main-dex-list文件生成的maindexComponent就不包含第三方主dex，类分析工具根据这个生成的maindexComponent的jar包分析依赖的时候也不会包含移除的这部分activity的依赖。
注意:此处需要大致了解一下dex分包的过程，我就大概说一下，不太理解的地方可以google一下: 1. 首先buildTools会分析proguard文件和AndroidManifest.xml文件，将四大组件、Application、instrumentation和keep住的类，生成一个componentClasses.jar(在build/intermediates/multi-dex/release/componentClasses.jar路径下)；2. 然后会根据这个jar中的类，去分析类依赖生成一个maindexList.txt文件，此文件中包含了分析出来的需要放到主dex中的类； 3. 根据这个文件进行分包的操作。

二、 buildToolsVersion > 24 的情况
省省心吧，你不会发生这个问题，buildToolsVersion >24之后，发现会吧四大组件等不必要放到主dex中的东西，默认放到其他地方，因此你的buildToolsVersion大于24，就不会发生此问题。不要问我如何发现的？其实我是搞了一周减小主dex包之后偶然发现的，当时真是蓝瘦香菇啊。
好了，到此你应该明白了，大招就是将buildToolsVersion的版本号提高到24以上。祝好吧!!

Glide使用中的问题

发表于 2017-02-27 | 更新于 2018-09-21 | 分类于 Android

总结一下最近使用glide的过程中出现的两个比较棘手的问题

glide没有提供从缓存中找到对应资源的api。
对于这个问题，其实解决方案想到两个:第一个通过反射不改变源码的情况下能够做到；第二个只能是修改一下相关的源码，自己提供一个api让开发团队小伙伴使用。面对这两个选择我们只能选择第二个了，虽然改了源码对以后版本升级可能会出现一定的影响，但相对于反射来说其优势还是比较明显的。

/**
 * add by guangcong
 * 根据url, 从本地缓存中获取到缓存的图片
 */
public static File findDiskCache(Context context, String url) {
    OriginalKey originalKey = new OriginalKey(url, EmptySignature.obtain());
    if (DiskLruCacheWrapper.wrapper == null){
        get(context).getEngine().initDiskCacheProvider();
    }
    if(DiskLruCacheWrapper.wrapper != null){
        try {
            File file = DiskLruCacheWrapper.wrapper.get(originalKey);
            if(file != null && file.exists()){
                return file;
            }
        } catch (Throwable e){
            e.printStackTrace();
        }
    }
    return null;
}

注意: 1. 需要设置内存缓存包含DiskCacheStrategy.SOURCE(即至少要缓存original data)；2. 上述api需要更改某些类的修饰类型为public

用户反馈图片无法展示的问题。
对于这个问题，绝逼是一个大坑啊。最初遇到这个问题，排查了所有可能性根本找不出问题所在。于是只能通过记录日志打log的方式，查找问题所在。在log中我们发现图片的请求是成功的，但是再想磁盘写的时候莫名的出错了，而且错误比较奇怪

总是在DecodeJob的上述方法中报错 Failed to ensureFile java.io.IOException: open failed: ENOENT (No such file or directory) 而且文件不存在再次创建也不成功。这真是逆天了，根本不知道为什么这样。
黄天不负有心人，我组的大神竟然用一个反馈最多的机型复现了。复现步骤也很简单，就是vivo的一个手机自带了360清理软件，使用清理软件的时候回吧sdcard上我们创建的缓存目录删除掉，之后再创建就无法成功了。
到此我们也发现了问题，最主要的原因是我们使用了Context.getExternalCacheDir()作为缓存目录，此目录是在sdcard上的，清理软件会进行清理。至于为什么清理之后无法再次创建了，真个还是不太明白。于是我们吧缓存目录设置到了/data/data下，问题就完美解决了。glide默认也是缓存到/data/data下的。

Gradle之Transform

发表于 2017-02-15 | 更新于 2018-09-21 | 分类于 Gradle

Transfrom

Trasnform API是gradle 1.5.0之后版本提供的，该API的作用是:允许第三方在打包Dex文件之前的编译过程中操作.class文件，目前Android gradle插件中的jarMerge, proguard, multi-dex，instantRun等一些列操作都已经转换为Transform的实现了。

如何使用Transform API

使用Transform基本分两个步骤:

先继承Transform类实现子类
将实现的Transform进行注册进android编译流程中 android.registerTransform(transform) 或android.registerTransform(theTransform, dependencies)
Transform类中必须的实现

getName()
Transform中的抽象方法,实现之后返回当前Transform子类的名字.该方法return出去的名字并不是最终编译时的名字。
gradle core的代码中可以找到Transform的管理类， com.android.build.gradle.internal.pipeline.TransformManager在此类中会根据transform返回的name按照transform${InputType1}And${InputType2}And${InputTypeN}And${name}For${flavor}${BuildType}的形式进行拼装成完成的名字

private static String getTaskNamePrefix(@NonNull Transform transform) {
    StringBuilder sb = new StringBuilder(100);
    sb.append("transform");
    Iterator<ContentType> iterator = transform.getInputTypes().iterator();
    // there's always at least one
    sb.append(capitalize(iterator.next().name().toLowerCase(Locale.getDefault())));
    while (iterator.hasNext()) {
        sb.append("And").append(capitalize(
                iterator.next().name().toLowerCase(Locale.getDefault())));
    }
    sb.append("With").append(capitalize(transform.getName())).append("For");
    return sb.toString();
}

getInputTypes()
指名当前的Transform要处理的数据类型。具体类型包含两种:

QualifiedContent.DefaultContentType.CLASSES 代表要处理的数据是编译之后字节码，这些数据的容器可以是jar包也可以是文件夹

QualifiedContent.DefaultContentType.RESOURCES标识要处理的是标准的java资源

/**
 * 指明当前Trasfrom要处理的数据类型
 */
@Override
public Set<QualifiedContent.ContentType> getInputTypes() {
    //ImmutableSet 表示不可变的set
    //此处的inputType包含两个大类
    //1. CLASSES标识要处理的数据是编译过后的java字节码，这些数据的容器可以是jar包也可以是文件夹
    //2. RESOURCES标识要处理的是java资源
    return ImmutableSet.<QualifiedContent.ContentType>of(QualifiedContent.DefaultContentType.CLASSES);
}

getScopes()
配置当前Transform的影响范围,相当于作用域.其中Scope的属性解释如下图所示.
|Type | Des|
|——–|——-|——-|
|PROJECT| 只处理当前项目|
|SUB_PROJECTS| 只处理子项目|
|PROJECT_LOCAL_DEPS |只处理当前项目的本地依赖,例如jar, aar|
|SUB_PROJECTS_LOCAL_DEPS |只处理子项目的本地依赖,例如jar, aar|
|EXTERNAL_LIBRARIES| 只处理外部的依赖库|
|PROVIDED_ONLY| 只处理本地或远程以provided形式引入的依赖库|
|TESTED_CODE| 测试代码|
跟getInputTypes方法一样, getScopes也是返回一个集合,那么就可以根据自己的需求配置多种Scope
isIncremental()
当前Transform是否支持增量编译

Groovy语法简介

发表于 2017-02-13 | 更新于 2018-09-21 | 分类于 Gradle

Groovy

Groovy是一门JVM语言，也就是说Groovy的代码最终也会编译成JVM字节码，交给虚拟机去执行。gradle之所以选择groovy语言，很重要的一个因素是groovy的结构看起来非常通俗移动，如同配置文件一般。
Groovy语法的简介:

变量

groovy中没有固定的类型，有点类似于若类型的语言，变量可以通过def关键字引用

1 2	def name = 'Glan' def hello = "Hello, $name"

注意: 单引号表示这个字符串只是单纯的字符串；而双引号则可以在字符中引用变量,进行插值操作。

方法

groovy的方法也是通过def关键字进行定义的。方法如果不指定返回值，默认返回最后一行代码的值。

def square(def num){
    num*num
}
square 4

类

class MyGroovyClass {
    String greeting //变量
    //方法
}

Groovy中，默认所有的类和方法都是public的，所有的类的字段都是private的；
new关键字穿件实例，使用def接受对象引用: def instance = new MyGroovyClass()
类中声明的字段，默认都会生成对应的setter和getter方法(有点类似于Object C)。所以代码中可以直接使用get和set方法。 instance.setGreeting 'hello, groovy'。
注意:groovy的方法调用是可以没有括号的，而且也不需要分号结尾(使用分号也不会报错)。也可以直接通过instance.greeting这样的方式获取字段，其实调用的还是get方法。
Map、 Collections
创建list
1
List list = [1, 2, 3, 4, 5]

遍历列表

1
2
3

list.each(){ element -> 
    println element
}

定义一个Map, map的key必须为字符，不写单双引号默认也是字符串

1	Map map = ['glan' : g, 'wang':2]

获取map的值

1 2	map.get('glan') map['glan']

定义Range类:Range为List的一个拓展，

def aRange = 1..5  <==Range类型的变量 由begin值+两个点+end值表示
                      左边这个aRange包含1,2,3,4,5这5个值

如果不想包含最后一个元素，则

def aRangeWithoutEnd = 1..<5  <==包含1,2,3,4这4个元素
println aRange.from
println aRange.to

闭包

闭包(Closure)，是一种数据类型，它代表了一段可执行的代码，是Grooovy中一个非常重要的数据类型或者说一种概念。外型如下:

def aClosure = {//闭包是一段代码，所以需要用花括号括起来
    param1, param2 ->   //箭头前边标识参数，后面是代码
    println "this is code"   //这是代码，最后一句是返回值
    //也可以使用return进行返回，类似于Groovy函数
}
//总结:
def xxx = {paramters -> code}  //或者  
def xxx = {无参数，纯code}  这种case不需要->符号

调用闭包: 闭包对象.call(参数) 或者更像函数的调用方法 : 闭包对象(参数)
例如:

1 2	aClosure.call("hello", 100) 或者 aClosure("hello", 100)

注意:如果闭包没定义参数的话，则隐含有一个参数，这个参数名字叫it，和this的作用类似。it代表闭包的参数。
例如:

def greeting = {"hello, $it"}
//等同与
def greeting = { it ->  "hello, $it"}

def noParamClosure = { -> true} //标识没有参数的闭包，此时调用就不能传递参数否则报错

def square  = {num ->
    num * num 
   }
   square 8

如果只有一个参数，我们甚至可以省略这个参数，默认使用it作为参数，最后代码是这样的：

Closure square = {
    it * it
}
square 16

####Groovy I/O操作

读文件

def targetFile = new File(文件名)  //创建file对象
//1. 每一行兑取
targetFile.eachLine { line -> 
        println line
}
//2. 直接得到文件内容
targetFile.getBytes()  //或者直接targetFile.bytes
//3. 操作流
def  ism = targetFile.newInputStream()
//操作ism后需要关闭
ism.close
//4. 使用闭包操作inputStream，这种方式再gradle中常用.而且不需要自己关闭流
targetFile.withInputStrem { ism ->
    操作ism， 不用调用close， Groovy在闭包中会自动关闭
}

写文件: 和对文件基本差不多。

def srcFile = new File(源文件名)  
def targetFile = new File(目标文件名)  
targetFile.withOutputStream{ os->  
  srcFile.withInputStream{ ins->  
      os << ins   //利用OutputStream的<<操作符重载，完成从inputstream到OutputStream  的输出
   }  
}

Groovy in Gradle

了解了groovy的基本语法，我们来看看gradle的代码

apply

1	apply plugin: 'com.android.application'

这段代码其实就是掉用了project对象的apply方法，传入的是一个以plugin为key的map对象。完整的写法为

1	project.apply([plugin: 'com.android.application'])

dependencies

1
2
3

dependencies {
    compile 'com.google.code.gson:gson:2.2'
}

时机调用的时候会传入一个DependencyHandler的闭包，完整如下:

project.dependencies({
    add('compile' , 'com.google.code.gson:gson:2.2' , {
        //configuration statements
        })   
     })

Task

创建Task

1
2
3

task hello {
    println 'hello, world'
}

gradle的声明周期有三步，初始化，配置和执行。上面的代码在配置过程中就已经支行了，所以打印出的字符串发生在任务执行之前，如果要再执行的阶段执行任务代码则需要如下:

1
2
3

task hello << {
    println ‘Hello, world’
}

添加Action :
Task包含一系列的action，当task执行的时候，所有的action都会一次执行。如果我们想加入自己的action，我们可以通过复写doFirst()和doLast()方法:
1
2
3
4
5
6
7
8
9
task hello {
println 'Configuration' //执行阶段之前
doLast {
println 'Bye bye'
}
doFirst {
println 'Hello '
}
}

运行gradle hello执行结果为

Configuration
:hello
Hello
Bye bye

Task依赖: task的依赖关系有两种， mustRunAfter和dependsOn。

task task1 << {
    println 'task1'
}
task task2 <<{
    println 'task2'
}
task2.mustRunAfter task1  //第一种关系
task2.dependsOn task1  //第二种

他们的区别是，运行的的时候前者必须要都按顺序加入gradlew task2 task1执行才可以顺利执行，否则单独执行每个任务，后者只需要执行gradlew task2即可同时执行两个任务。

Gradle 的编译周期

编译过程分为三个阶段：

首先是初始化阶段。对我们前面的multi-project build而言，就是执行settings.gradle
Initiliazation phase的下一个阶段是Configration阶段。
Configration阶段的目标是解析每个project中的build.gradle。比如multi-project build例子中，解析每个子目录中的build.gradle。在这两个阶段之间，我们可以加一些定制化的Hook。这当然是通过API来添加的。
-Configuration阶段完了后，整个build的project以及内部的Task关系就确定了。恩？前面说过，一个Project包含很多Task，每个Task之间有依赖关系。Configuration会建立一个有向图来描述Task之间的依赖关系。所以，我们可以添加一个HOOK，即当Task关系图建立好后，执行一些操作。
最后一个阶段就是执行任务了。当然，任务执行完后，我们还可以加Hook。

在解析 Gradle 的编译过程之前我们需要理解在 Gradle 中非常重要的两个对象。Project和Task。

每个项目的编译至少有一个 Project,一个 build.gradle就代表一个project,每个project里面包含了多个task,task 里面又包含很多action，action是一个代码块，里面包含了需要被执行的代码。

在编译过程中， Gradle 会根据 build 相关文件，聚合所有的project和task，执行task 中的 action。因为 build.gradle文件中的task非常多，先执行哪个后执行那个需要一种逻辑来保证。这种逻辑就是依赖逻辑，几乎所有的Task 都需要依赖其他 task 来执行，没有被依赖的task 会首先被执行。所以到最后所有的 Task 会构成一个有向无环图（DAG Directed Acyclic Graph）的数据结构。

AspectJ之android应用

发表于 2017-02-13 | 更新于 2018-09-21 | 分类于 Android

之前也写过一下AOP在android上的应用和AspectJ如果再android上使用，而然近期看到一片非常好的文章，详细介绍了AspectJ的概念，以及给出了如何在android上使用AspectJ。好了废话不多少，直接上作者原文:
http://blog.csdn.net/eclipsexys/article/details/54425414