Busy.Im

Android 自动化编译之 Github Actions

Tue, 20 Oct 2020 21:23:48 +0800

Actions 是 Github 2019年推出的自动化集成编译工具，在漫长的 Beta 等待后我也在去年获得了优先体验，当时也写了 actions-android-ci 的第一个版本，用来编译 CallerInfo 项目。

最近在写一个私有项目，自动化 CI 自然是必不可少的，为了简单方便，托管在了 Github。使用去年编写的 ci@v1.2.1 很快完成了编译，同时增加了对每次编译 apk 和 mapping.txt 上传到 artifacts 的支持。

但是每次编译都需要将近 8 分钟，而每个月只有 2000 分钟的免费编译时长，因此减少编译时间很重要。查看编译的日志，发现有 30 秒在编译 docker 镜像，还有 6 分钟都在编译，其中大部分时间都在下载 gradle 依赖。

所以通过预编译 docker 镜像和增加 sdk 及 gradle 依赖缓存可以大幅减少编译运行时间。

集成编译优化过程

1. 使用预编译 docker 镜像

在 v1.2.1 版本， Github Actions 在每次运行时都会从 actions-android-ci 仓库拉取最新的代码，然后根据 action.yml 文件中的配置，编译新的 docker 镜像。由于这个镜像包括 openjdk 等依赖，每次编译都会去拉取大量数据并重新编译 docker image：

runs:
 using: 'docker'
 image: 'Dockerfile'

直接从 docker hub 拉起最新的镜像则可以减少每次制作新镜像的耗时：

runs:
 using: 'docker'
 image: 'docker://xdtianyu/actions-android-ci'

2. 增加 sdk 及 gradle 缓存

这个 docker 复用了 Gitlab CI，而当时为了优化在 Gitlab runner 中编译，已经增加了缓存的支持，只是存储在了 /opt/cache/gradle /opt/sdk /opt/ndk 几个目录下，在 Gitlab Runner 运行时是预先挂载了宿主机的这几个目录来实现 runner 缓存的。

而 Github 目前是不支持使用 docker volume 挂载参数的，所以需要将这几个目录设定在可以访问的目录下，最后缓存这几个目录。所以重新编写了下载 sdk 的脚本和环境变量：

echo $GITHUB_WORKSPACE
SDK=/opt/sdk
NDK=/opt/ndk
GRADLE=/opt/cache/gradle
if [ ! -z "$GITHUB_WORKSPACE" ]; then
SDK="$GITHUB_WORKSPACE/.opt/sdk"
NDK="$GITHUB_WORKSPACE/.opt/ndk"
GRADLE="$GITHUB_WORKSPACE/.opt/cache/gradle"
fi
# ... setup sdk ...
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:$SDK/emulator/:$SDK/tools/bin:$SDK/tools:$SDK/platform-tools:$NDK:$SDK/cmake/3.10.2.4988404/bin
export ANDROID_HOME=$SDK
export ANDROID_SDK=$SDK
export ANDROID_SDK_ROOT=$SDK
export GRADLE_USER_HOME=$GRADLE

当有 GITHUB_WORKSPACE 环境变量时，说明当前运行环境为 Github Actions 环境，需要将 sdk 目录设定在 $GITHUB_WORKSPACE/.opt/sdk 目录下。完整内容请阅读代码 setup-android-sdk.sh

编译新的镜像并上传到 docker hub： xdtianyu/actions-android-ci (这里使用了 docker hub 的自动编译)。

然后在 .github/workflows/android.yml 编译前增加缓存配置：

 - name: Cache gradle and sdk
 uses: actions/cache@v2
 env:
 cache-name: cache-gradle-and-sdk
 with:
 path: |
 ${{ github.workspace }}/.opt/cache/gradle/wrapper
 ${{ github.workspace }}/.opt/cache/gradle/caches
 ${{ github.workspace }}/.opt/sdk
 key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/wrapper/gradle-wrapper.properties', '**/build.gradle') }}
 restore-keys: |
 ${{ runner.os }}-build-${{ env.cache-name }}-
 ${{ runner.os }}-build-
 ${{ runner.os }}-

这样，每次编译时都会下载 .opt/sdk 等目录下的缓存文件，并在编译完成后检查缓存是否需要更新，如需更新则上传新的目录。

这里的缓存校验使用了 build.gradle 和 gradle-wrapper.properties ，如果这些文件被修改则说明需要更新缓存，否则跳过新建缓存的过程。可以根据自己需要调整这里的校验配置。

3. 加密的环境变量 Secrets

可以在项目 Settings -> Secrets 中配置加密的环境变量，这里配置的环境变量很安全，有特殊处理，不会在日志中显示。同时也不会传递由 Fork 发起的 Pull Request。

我习惯性的使用了上图中的5个环境变量，用来将发布签名加密保存在代码仓库中。其中 ENCRYPTED_IV 和 ENCRYPTED_KEY 是使用 openssl 加密的 secrets.tar.enc 文件相关密钥。通过如下命令解密：

openssl aes-256-cbc -K $ENCRYPTED_KEY -iv $ENCRYPTED_IV -in secrets.tar.enc -out secrets.tar -d

如果不需要，可以在参考代码脚本中移除这部分内容。

在这个脚本中有详细的说明可以参考学习： .travis/env.sh

4. 增加 artifacts 上传

每次自动编译都会生成 apk 文件，可以将其和混淆文件一起发布出来提供下载。只需要增加如下 artifacts 配置即可完成对每次编译 apk 和 mapping.txt 文件上传。类似于 Gitlab job，在每个 Action 编译成功后都会有一个 Artifacts 链接能用来下载：

- name: Upload artifacts
 uses: actions/upload-artifact@v2
 with:
 name: artifacts
 path: |
 app/**/apk/release/*
 app/**/mapping/release/mapping.txt

完整的配置文件请阅读 xdtianyu/actions-android-ci README 文件。

总结

我从事开发过程的一大乐趣就是写各种各样的自动化脚本，在工作中也承担了内部 Gitlab 及 CI 的搭建维护工作。在 CallerInfo 项目中，已经集成了各式各样的 CI 服务如：Travis-ci、 Gitlab runner、Jenkins 、AppVeyor、Github Actions，也集成过 CircleCI 等服务，但是担心过多的权限要求导致我的其他私有仓库泄漏，所以没有集成。

本文主要是对 Gtihub Actions Android 应用编译缓存方面的实现，附带的介绍了加密环境变量及上报 artifacts ，没有涉及版本发布、自动化发布报告(sha1/commits/changes)和其他更多好玩的内容。这些内容已经在 Travis ci 上实现过了，就不再赘述，感兴趣的读者可以参考学习我的开源项目 CallerInfo 中的 .travis 目录和 .travis.yml 文件。

CI 平台大同小异，常见的几种平台中，AppVeyor 是在 Windows 宿主机上编译的，如果你也喜欢写自动化CI，建议也不要错过 AppVeyor。

使用枚举管理不同渠道版本常量

Mon, 10 Aug 2020 20:26:48 +0800

工作中遇到了需要根据不同渠道配置不同广告 ID 需求，而且渠道很多，变动可能很频繁，如何才能高效配置管理呢？通过思考实践，我最终使用了枚举来管理不同渠道的广告 ID。

一般的字符串常量

在项目刚开始时，是没有根据不同渠道使用不同广告位ID的需求的，最初只是使用了简单的字符串常量来保存这些初始化数据。

public final static String APP_ID = "54513248";
public final static String UM_ID = "RANDOM8TN2zx0QlLRfsXGRNU";
public final static String UM_CHANNEL = "Umeng";
public final static String SPLASH_AD_ID = "****";
public final static String INTERACTION_AD_ID = "****";
public final static String VIDEO_AD_ID = "****";
public final static String BANNER_AD_ID = "****";
public final static String FEED_AD_ID = "****";
public final static String PROFILE_BANNER_AD_ID = "****";
public final static String SCRATCH_REWARD_AD_ID = "****";
public final static String SCRATCH_BANNER_AD_ID = "****";

进化为枚举管理

在收到不同渠道不同广告位ID的需求后，首先考虑到便于编译，不能通过简单的更改和注释的方法来管理字符串常量，这样每次渠道编译都要修改，很麻烦。如果使用 flavor 直接填充变量，数据太多不宜在 build.gradle 中维护，扩展性也不好。

也考虑了使用 xml 中配置 strings-arrays 字符串配置，想想要调整不同的文件，还要引入到上下文加载，也不是一个好的选择。

再次想到了使用 interface来定义一个基类，返回实现不同的渠道实例来填充广告位ID，实现下来代码也很繁琐，有些过渡设计。而考虑到 Enum 是单实例 Class 的本质，想法自然向枚举靠拢。

1. 定义常量

首先在枚举中定义常量的列表

@Keep
public enum AdsIds {
public String APP_ID = "54513248";
public String UM_ID = "RANDOM8TN2zx0QlLRfsXGRNU";
public String UM_CHANNEL = "Umeng";
public String SPLASH_AD_ID;
public String INTERACTION_AD_ID;
public String VIDEO_AD_ID;
public String BANNER_AD_ID;
public String FEED_AD_ID;
public String PROFILE_BANNER_AD_ID;
public String SCRATCH_REWARD_AD_ID;
public String SCRATCH_BANNER_AD_ID;
}

2. 增加枚举实例内初始化

要在每个枚举实例内初始化数据，需要增加一个 init() 抽象方法，同时在枚举的构造方法中调用这个 init() 方法。

public enum AdsIds {
...
AdsIds() {
init();
}
protected abstract void init();
...
}

3. 增加枚举实例

这时就可以为每个渠道增加枚举实例并初始化常量了：

public enum AdsIds {
COMMON {
@Override
protected void init() {
SPLASH_AD_ID = "814272";
INTERACTION_AD_ID = "817562";
VIDEO_AD_ID = "815884";
BANNER_AD_ID = "889664";
FEED_AD_ID = "844311";
PROFILE_BANNER_AD_ID = "808569";
SCRATCH_REWARD_AD_ID = "815990";
SCRATCH_BANNER_AD_ID = "892691";
}
},
CHANNEL_A {
@Override
protected void init() {
UM_CHANNEL = "CHANNEL_1";
SPLASH_AD_ID = "812097";
INTERACTION_AD_ID = "814895";
VIDEO_AD_ID = "877058";
BANNER_AD_ID = "879158";
FEED_AD_ID = "896762";
PROFILE_BANNER_AD_ID = "832216";
}
},
...
;
}

注意最后一个枚举的结尾是分号;，如果需要再增加不同渠道，只需要再增加一个新的枚举实例就可以了。

4. 代码调用

public class Constants {
public static AdsIds IDS = AdsIds.COMMON;
}

使用

adsHolder.setAdId(Constants.IDS.BANNER_AD_ID);

语句调用即可。

为了配合 flavor 控制，可以在 Constants 中增加一个 CHANNEL 的常量，这部分只做示例，读者可以自己讨论扩展：

@Keep
public class Constants {
// Change this, use flavor to control CHANNEL...
 public static final Channel CHANNEL = Channel.COMMON;
public static AdsIds IDS = AdsIds.valueOf(CHANNEL.name());
}
public enum Channel {
COMMON,
EXTERNAL,
PLAY_STORE,
CHANNEL_A
}

完整代码示例

最终的实现简单明了，配置维护方便，代码如下：

@Keep
public enum AdsIds {
COMMON {
@Override
protected void init() {
SPLASH_AD_ID = "814272";
INTERACTION_AD_ID = "817562";
VIDEO_AD_ID = "815884";
BANNER_AD_ID = "889664";
FEED_AD_ID = "844311";
PROFILE_BANNER_AD_ID = "808569";
SCRATCH_REWARD_AD_ID = "815990";
SCRATCH_BANNER_AD_ID = "892691";
}
},
CHANNEL_A {
@Override
protected void init() {
UM_CHANNEL = "CHANNEL_1";
SPLASH_AD_ID = "812097";
INTERACTION_AD_ID = "814895";
VIDEO_AD_ID = "877058";
BANNER_AD_ID = "879158";
FEED_AD_ID = "896762";
PROFILE_BANNER_AD_ID = "832216";
}
},
EXTERNAL {
@Override
protected void init() {
SPLASH_AD_ID = "845812";
INTERACTION_AD_ID = "870659";
VIDEO_AD_ID = "893231";
BANNER_AD_ID = "851338";
FEED_AD_ID = "847696";
PROFILE_BANNER_AD_ID = "895238";
SCRATCH_REWARD_AD_ID = "840528";
SCRATCH_BANNER_AD_ID = "865717";
}
},
PLAY_STORE {
@Override
protected void init() {
UM_CHANNEL = "PLAY_STORE";
SPLASH_AD_ID = "868959";
INTERACTION_AD_ID = "874990";
VIDEO_AD_ID = "875137";
BANNER_AD_ID = "866426";
FEED_AD_ID = "839792";
PROFILE_BANNER_AD_ID = "864501";
SCRATCH_REWARD_AD_ID = "897767";
SCRATCH_BANNER_AD_ID = "863937";
}
};
public String APP_ID = "54513248";
public String UM_ID = "RANDOM8TN2zx0QlLRfsXGRNU";
public String UM_CHANNEL = "Umeng";
public String SPLASH_AD_ID;
public String INTERACTION_AD_ID;
public String VIDEO_AD_ID;
public String BANNER_AD_ID;
public String FEED_AD_ID;
public String PROFILE_BANNER_AD_ID;
public String SCRATCH_REWARD_AD_ID;
public String SCRATCH_BANNER_AD_ID;
AdsIds() {
init();
}
protected abstract void init();
}

上文代码中的 ID 和 Key 都是随机字符串，没有绑定到特定的应用信息。

从零开始的 Go 爬虫框架编程实战 - 下篇

Sun, 15 Mar 2020 16:46:23 +0800

这是一篇讲解如何编写 Go 爬虫框架的编程实战系列长文，是一个爬虫框架程序从无到有的成长进化史。

10. 多个站点信息合并

在抓取网页时，单一的网页上获取到的内容有限，有时需要在多个网页上获取信息后，综合返回站点信息。当前的数据结构不具备这种能力。为了实现这个能力，需要对 Site 结构体进行升级，增加链表的支持。

type Site struct {
Url string
...
Next *Site
}

同时，获取站点信息的 Meta() 函数增加获取子站点信息的调用，并将子站点信息传递给父站点。

func (site Site) Meta() Meta {
...
var next = Meta{}
if site.Next != nil {
next = site.Next.Meta()
}
meta.Title = combine(site.Title.Value(doc), next.Title)
meta.Actor = combine(site.Actor.Value(doc), next.Actor)
meta.Poster = combine(site.Poster.Value(doc), next.Poster)
...
return meta
}

此时站点配置清单内容如下：

func Mgs(id string) Site {
mobile := Site{
Url: fmt.Sprintf("https://sp.mgstage.com/product/product_detail/SP-%s/", id),
UserAgent: MobileUserAgent,
Cookies: []http.Cookie{{Name: "adc", Value: "1"}},
CssSelector: CssSelector{
Title: Selector(".sample-image-wrap.h1 > img").Attribute("alt"),
...
},
}
return Site{
Url: fmt.Sprintf("https://www.mgstage.com/product/product_detail/%s/", id),
UserAgent: UserAgent,
Cookies: mobile.Cookies,
CssSelector: CssSelector{
...
},
Next: &mobile,
}
}

完整内容参考 commit 修改记录。

11. 增加额外字段信息

再增加一个 heyzo.go 的站点配置清单，由于编码过程中需要对中间查找的 provider_id 属性进行保存，虽然最后没有用到，还是增加了配置清单中额外字段配置的支持。

首先在 Meta 结构体中增加一个 Extras 的 map：

type Meta struct {
Id string `json:"id"`
...
Extras map[string]string `json:"extras"`
}

然后在 Selector 结构体中增加一个 Extras 的 map :

type CssSelector struct {
Id *Item
...
Extras map[string]*Item
}
func (selectors CssSelector) AddExtra(key string, selector *Item) CssSelector {
if selectors.Extras == nil {
selectors.Extras = make(map[string]*Item)
}
selectors.Extras[key] = selector
return selectors
}

其中 AddExtra() 函数使选择器支持连续的添加额外字段能力，例如使用如下方法添加：

 return Site{
...
CssSelector: CssSelector{
Title: Selector("h1"),
...
}.AddExtra(providerId, Selector("input[name=provider_id]").Attribute("value")),
}

最后在站点抓取站点信息时，对 Extras 进行解析：

func (site Site) Meta() Meta {
...
// extract extras to meta
 if site.Extras != nil {
meta.Extras = make(map[string]string)
for key, value := range site.Extras {
meta.Extras[key] = value.Value(doc)
}
for key, value := range next.Extras {
meta.Extras[key] = value
}
} else {
meta.Extras = next.Extras
}
return meta
}

完整内容请参考修改 commit 记录。

12. 增加正则表达式匹配查找支持

之后又增加了 fantia.go 站点配置清单，已可以直接支持。又增加 getchu.go 站点配置清单时，由于时间直接存放在大块的 body 文字中，无法通过 Css Selector获取到时间信息。而时间又有相对固定的格式如 2017/02/06，这样结构的字符串很容易通过正则表达式获取到，所以再一次对 Selector 扩展，增加了正则表达式匹配查找的支持。

首先 Selector -> Item 结构体增加正则配置函数及字段：

type Item struct {
...
matcher string
}
func (selector Item) Match(matcher string) *Item {
selector.matcher = matcher
return &selector
}

然后实现正则匹配的能力：

func (selector Item) matcherValue(doc *goquery.Document) string {
re := regexp.MustCompile(selector.matcher)
text := doc.Text()
matches := re.FindAllString(text, -1)
if len(matches) > 0 {
return matches[0]
}
return ""
}
func (selector *Item) Value(doc *goquery.Document) string {
...
if len(selector.matcher) > 0 {
return selector.matcherValue(doc)
}
...
}

最后，增加站点配置清单：

func Getchu(id string) Site {
return Site{
...
CssSelector: CssSelector{
...
Release: Selector("~").Match(`\d{4}/\d{2}/\d{2}`),
Duration: Selector("~").Match(`動画.*分`),
Id: Selector("input[name=id]").Attribute("value"),
...
},
}
}

这里 Match() 函数即实现了正则匹配的配置，这是对 Selector 选择器的又一次升级，之后还将继续优化。

完整内容请查看 commit 记录。

增加了正则匹配之后，又增加了一个 tokyo.go 站点配置清单，爬虫框架可以轻松适用。

13. 增加 Json 站点解析能力

个别的网站如 1pondo 使用了完全的 Json 渲染，内容都是在浏览器 xhr 请求服务器 API 后动态加载的。一般来说这是最简单的爬虫爬取接口了，但是实际编写这个爬虫时，增加 Json 的解析确是最困难的部分。

爬虫的框架整体是基于 CSS Selector 实现的，它是不能支持文本内容检索的。所以类似正则表达式匹配，需要为 Json 格式解析另辟蹊径。

首先，在 Selector -> Item 结构体中增加匹配 json 节点的 query 字段及配置函数 Query()：

type Item struct {
selector string
attribute string
replacer *strings.Replacer
preset string
presets []string
matcher string // regex
 query string // json
}
func Query(query string) *Item {
return &Item{query: query}
}

Site 结构体中增加解析存储，这里使用了 interface{} 类型作为基本类型，方便之后通过 parseJson() 函数解析：

type Site struct {
...
Json bool
JsonData interface{}
....
}
func (site Site) parseJson() Meta {
var meta = Meta{}
body, err := ioutil.ReadAll(site.Body())
err = json.Unmarshal(body, &site.JsonData)
if err != nil {
log.Fatal(err)
}
data := make(map[string]interface{})
m, ok := site.JsonData.(map[string]interface{})
if ok {
for k, v := range m {
//fmt.Println(k, "=>", v)
 data[k] = v
}
}
next := Meta{}
if site.Next != nil {
next = site.Next.Meta()
}
// extract meta data from json data
 meta.Title = oneOf(site.Title.Query(data), next.Title)
...
return meta
}

然后实现解析 Json 的能力，下面代码中 Query() 函数是实现从 Site.JsonData 中提取单个字段值，而 Queries() 则为提取数组值。其中的关键函数或较难理解的函数为 queries() 函数，将解析到的值转为 []string 后返回：

// get item
func (selector *Item) Query(data map[string]interface{}) string {
if selector == nil {
return ""
}
if len(selector.preset) > 0 {
return selector.preset
}
return query(data, selector.query)
}
func query(data map[string]interface{}, key string) string {
value := data[key]
if value != nil {
return fmt.Sprintf("%v", value)
}
return ""
}
// get items array
func (selector *Item) Queries(data map[string]interface{}) []string {
if selector == nil {
return []string{}
}
if selector.presets != nil {
return selector.presets
}
return queries(data, selector.query)
}
func queries(data map[string]interface{}, key string) []string {
var res []string
x := data[key]
if x != nil {
// if json object is not slice then ignore
 if reflect.ValueOf(x).Kind() == reflect.Slice {
array := x.([]interface{})
for _, v := range array {
value := fmt.Sprintf("%v", v)
res = append(res, value)
}
}
}
return res
}

目前这段解析代码还不是很完美，只能支持单一层级的 Json 字符串，如果层级较深，则不能解析出来，以后应该还会根据需求优化。

最后，添加站点配置清单即可从 Json 数据中获取到站点信息。完整代码请参考 commit 记录。

14. 增加装饰器，支持配置清单自定义修改

在编写 pondo.go 清单过程中，因为解析到的 Image 字段是一个不定的结构类型，可能有两种字段 Img 和 FileName，以及有一个 Protected 类型表示是否可以公开访问：

type PondoImage struct {
Img string
Filename string
Protected bool
}

需要对这个字段做特殊处理，而不能简单的依赖爬虫框架库来实现解析逻辑，框架里实现这个解析可能会较为复杂。

Golang 不是完全面向对象的编程语言，不能简单的通过继承和重写 (override) 来在父类中调用子类方法，需要使用接口实现类似回调的方式。

首先在 Site 结构体中增加 Docor 接口。

type Site struct {
...
Decor Decor
...
}
type Decor interface {
Decorate(meta *Meta) *Meta
}
func (site Site) Decorate(meta *Meta) *Meta {
return &site.meta
}

然后在 podon.go 中实现装饰器并传递给 site：

func Pondo(id string) Site {
next := Site{
...
Json: true,
Decor: PondoDecor{},
Selector: Selector{
Images: Query("Rows"),
},
}
site := Site{
...
Next: &next,
}
return site
}
type PondoDecor struct {
Decor
}
type PondoImage struct {
Img string
Filename string
Protected bool
}
func (decor PondoDecor) Decorate(meta *Meta) *Meta {
origin := meta.Images
if len(origin) > 0 {
var images []string
var pondo PondoImage
for _, s := range origin {
err := json.Unmarshal([]byte(s), &pondo)
if err != nil {
log.Fatal(err)
}
if !pondo.Protected {
img := pondo.Img
if len(img) == 0 {
img = pondo.Filename
}
images = append(images, "https://www.1pondo.tv/dyn/dla/images/"+img)
}
}
meta.Images = images
}
return meta
}

最后，修改 Site.Meta() 函数，增加装饰器调用：

func (site Site) Meta() Meta {
...
if site.Decor != nil {
return *site.Decor.Decorate(&site.meta)
} else {
return site.meta
}
}

之后，每次爬虫框架在运行完后会执行站点配置清单的装饰器函数来修改元数据。完整的代码请参考 commit 记录。

结语

至此，一个完整的站点元数据爬虫框架就完成了，要成为一个完整的应用，还需要增加文件整理，上传下载等类似我之前写的 Dmaster 程序功能，这些能力将会继续更新。要获取到最新的更新和完整的工程代码，请关注仓库：

https://github.com/ruriio/tidy

TIL - 学到的小知识点

通过这周末两天的实战，学习到了以下几个零碎的小知识点：

Go 中方法和变量名称首字母大小写控制了访问权，大写表示公有，小写私有。
Go 不是面向对象的编程语言，没有子类函数继承和覆盖重写，父类里调用子类的实现函数，需要通过接口”绕路”实现。
CSS 选择器可以使用逗号( , ) 并联查询；可以使用 .classA.classB 精确匹配有多个 class的元素如 <div class="classA classB">text</div>。

从零开始的 Go 爬虫框架编程实战 - 中篇

Sun, 15 Mar 2020 16:42:56 +0800

这是一篇讲解如何编写 Go 爬虫框架的编程实战系列长文，是一个爬虫框架程序从无到有的成长进化史。

6. 增加通用获取属性的封装

在上一节的实战后，tidy 已经具备了基本爬虫框架，增加站点配置就可以支持新的站点爬虫。但是只支持文本查询是不够的，例如我们需要获取 <a href="value"> 和 <img src="value"> 中的 href 及 src 属性。我们在之前已经 Selector.Item.Attr(doc) 支持了属性的查找，需要将这个能力暴露给上次的配置清单。

首先在 Item 结构体中增加一个 attribute 的字段，用来保存清单配置的属性参数。为了结构或接口规范，0保持统一，我将 replacer 也提取进来。

type Item struct {
selector string
attribute string
replacer *strings.Replacer
}

通过如下方法配置这两个字段：

func (selector Item) replace(oldNew ...string) Item {
selector.replacer = strings.NewReplacer(oldNew...)
return selector
}
func (selector Item) attr(attr string) Item {
selector.attribute = attr
return selector
}

之后只需要通过 selector("a").attr("href") 方法配置，即可获取选择 a 标签并提取 href 属性的操作。

再新增一个 fc2.go 的站点，先看升级后最终的配置清单：

func Fc2(id string) Site {
return Site{
Url: fmt.Sprintf("https://adult.contents.fc2.com/article/%s/", id),
UserAgent: MobileUserAgent,
Selector: Selector{
Title: selector(".items_article_MainitemNameTitle"),
Actor: selector(".items_article_seller").replace("by ", ""),
Poster: selector("meta[property^=\"og:image\"]").attr("content"),
Producer: selector(".items_article_seller").replace("by ", ""),
Sample: selector(".main-video").attr("src"),
Series: selector(".items_article_seller").replace("by ", ""),
Release: selector(".items_article_Releasedate").replace("販売日 : ", ""),
Duration: selector(".items_article_MainitemThumb > p"),
Id: selector(".items_article_TagArea").attr("data-id"),
Label: selector("null"),
Genre: selector("null"),
Images: selector("li[data-img^=\"https://storage\"]").attr("data-img"),
},
}
}

可以从这里看到 Selector -> Item 结构体增加了 replace() 和 attr() 函数，有了文本替换和获取标签属性的能力。这是对选择器的第一次升级，可以在这里看到完成的 commits 记录。此时 Selector 已经有完整的扩展能力，为了结构明了，可以单独提取到 selector.go 中了。

继续增加一个 fc2club.go 的站点配置清单，可以看到爬虫代码无需做任何修改已经支持了匹配查询。

7. 增加 `gb2312` `euc-jp` 等编码支持

当前爬虫爬取到的网站内容都是使用 uft-8 编码的，在抓取 Carib 站点信息时，出现了乱码的问题，联想到了之前使用 Python 写爬虫抓取另一个站点时遇到的 euc-jp 解析错误问题。有了之前 Python 编程经验，这一次很快就定位到问题，并通过 charset.NewReaderLabel(encoding, body) 函数解决：

func decodeHTMLBody(body io.Reader, encoding string) (io.ReadCloser, error) {
body, err := charset.NewReaderLabel(encoding, body)
if err != nil {
log.Fatal(err)
}
return ioutil.NopCloser(body), nil
}

这里可以通过自动侦测检查网站的编码，也可以在配置清单中指定编码类型。为了准确性，我选择了在配置清单中配置的方法。此时 Site 结构体经过升级，增加 Charset 字段：

type Site struct {
Url string
UserAgent string
Charset string
CssSelector
}

在解析前执行此函数即可完成内容转码：

 // convert none utf-8 web page to utf-8
 if site.Charset != "" {
body, err = decodeHTMLBody(resp.Body, site.Charset)
if err != nil {
log.Fatal(err)
}
}
// load the HTML document
 doc, err := goquery.NewDocumentFromReader(body)

完整修改细节可以参考这里的 commit 记录。之后在配置清单 Site 初始化时增加 Charset: "euc-jp" 配置即可。

8. 扩展 `Selector` 选择器，增加预设值支持

再次增加一个 Carib.go 的站点配置清单，由于部分属性在爬取前就已经明确，可以直接预置，需要 Selector -> Item增加一个预置参数字段 preset 来储存，并在查找时直接返回这个值。

type Item struct {
selector string
attribute string
replacer *strings.Replacer
preset string
}
func Preset(preset string) Item {
return Item{selector: "", attribute: "", replacer: strings.NewReplacer("", ""), preset: preset}
}
func (selector Item) Value(doc *goquery.Document) string {
if len(selector.preset) > 0 {
return selector.preset
}
selection := doc.Find(selector.selector).First()
return selector.textOrAttr(selection)
}

可以参考这里的 commit 修改记录。Carib.go 站点配置清单完整内容如下：

func Carib(id string) Site {
return Site{
Url: fmt.Sprintf("https://www.caribbeancom.com/moviepages/%s/index.html", id),
UserAgent: MobileUserAgent,
Charset: "euc-jp",
CssSelector: CssSelector{
Title: Selector("h1[itemprop=name]"),
Actor: Selector("a[itemprop=actor]"),
Poster: Preset(fmt.Sprintf("https://www.caribbeancom.com/moviepages/%s/images/l_l.jpg", id)),
Producer: Preset("Caribbean"),
Sample: Preset(fmt.Sprintf("https://smovie.caribbeancom.com/sample/movies/%s/480p.mp4", id)),
Series: Selector("a[onclick^=gaDetailEvent\\(\\'Series\\ Name\\']"),
Release: Selector("span[itemprop=datePublished]"),
Duration: Selector("span[itemprop=duration]"),
Id: Preset(id),
Label: Selector("null"),
Genre: Selector("a[itemprop=genre]"),
Images: Selector("a[data-is_sample='1']").Attribute("href").Replace("/movie", "https://www.caribbeancom.com/movie"),
},
}
}

可以看到这里有四个 Preset 的属性：Poster Producer Id Sample ，此时 Selector 的函数已经变为大写字母开头的公开函数，是因为之前对选择器提取到了 selector 包中。增加 Preset 字段是选择期 Selector 的第二次升级。

再增加一个 caribpr.go 站点配置清单，可以看到已直接支持。

9. 支持 Cookies 配置

在增加 mgs.go 站点时，爬虫需要预置 cookies 才能正确抓取到网页，所以类似于编码格式 encoding，需要对 Site 结构体进行升级。

首先升级 Site.get() 函数，在请求时增加 cookies：

type Site struct {
...
Cookies []http.Cookie
...
}
func (site Site) get() (*http.Response, error) {
client := &http.Client{}
req, err := http.NewRequest("GET", site.Url, nil)
if err != nil {
log.Fatal(err)
}
req.Header.Set("User-Agent", site.UserAgent)
for _, cookie := range site.Cookies {
log.Println(cookie)
req.AddCookie(&cookie)
}
return client.Do(req)
}

再次增加配置清单，即可获取到正确的站点信息：

func Mgs(id string) Site {
return Site{
Url: fmt.Sprintf("https://sp.mgstage.com/product/product_detail/SP-%s/", id),
UserAgent: MobileUserAgent,
Cookies: []http.Cookie{{Name: "adc", Value: "1"}},
CssSelector: CssSelector{
Title: Selector(".sample-image-wrap.h1 > img").Attribute("alt"),
...
Images: Selector("a[class^=\"sample-image-wrap sample\"]").Attribute("href"),
},
}
}

完整内容参考 commit 修改记录。

从零开始的 Go 爬虫框架编程实战 - 上篇

Sun, 15 Mar 2020 16:40:16 +0800

这是一篇讲解如何编写 Go 爬虫框架的编程实战系列长文，是一个爬虫框架程序从无到有的成长进化史。

我是一个 Android 开发工程师，之前并没有 Golang 程序的编写历史，只学习过 Golang 的基本语法。不过我有较多的 Java/Kotlin/Python/Shell/C++ 编程经验，重视编码风格，尊重最佳实践，同时也是一个编程爱好者， Linux用户。

编程语言只是一个开发工具，代码的逻辑和架构思想是相同的，这大概也是我能在周末两天内快速完成编写这个程序的原因。

文中的写法和格式风格都是依据经验和现学现用，如果有不符合代码规范或最佳实践的地方，还请不吝赐教。

为什么选择 Go 爬虫

我写过几个爬虫类型的程序，基本都是在处理整理资源，这些代码大多是 Python 实现的，没有开源，也基本是自用。比如

MinorNews - 在主流和国外媒体上爬取指定关键字的旅游资讯新闻信息并发送邮件。
DFront - 浏览器插件，通过 Ctrl-Q 快捷键一键发送当前网页资源到后端 Dmaster。
Dmaster - 通过 DFront 接口上报的网址和信息，索引查找对应支持的站点并抓取资源链接，下载压缩、整理等操作，并发送通知提示。
PhoneNumber - 这是一个开源的号码查询库，其中有两个数据源是查询网页的搜索结果并解析。

后端都是用 Python - flask - celery 编写的，爬虫方面使用的多是 Beautiful soup 库，爬取新闻时有的网站使用了 PhantomJS 和 headless browser 爬取内容。

从开发效率角度看，Python 虽然很高效，但是需要集成 Python3 的环境，即使搭配 Docker 使用也不是很方便。最近一个月使用 Python 写了一组提取各个站点资源信息并整理资源到相应目录的脚本，各个脚本文件放到 ~/bin 目录后直接运行，虽然很方面实用，但是没有成系统的架构和统一的程序入口，迁移发布也不是很方便，而且每个脚本重复的代码太多，维护起来效率不高。

因为 Go 可以很方便的编译和发布，为了达成统一入口和方便发布的目的，这次的爬虫转入到 Go 编写爬虫。

从零开始，高效的 Go 开发环境

得益于之前的开源应用，我已经连续两年获取到了 IntelliJ IDEA 的免费开源许可，可以无限制的在开源项目中使用 IntelliJ 的全家桶，即全部平台 IDE，毫无疑问选择了 GoLand 开发环境。因为平时也会运行一些 Go 代码编译，所以本地已经有了 Go 环境，下载 GoLand linux zip 包以后，直接解压运行 bin/goland.sh 就可以使用了。

我之前没有写过 Go 程序，只写了 Go 的 hello world，学习过基本语法，并没有系统的学习和开发 Go 程序经验。在周末的两天里，从零开始到爬虫框架和 11 个站点爬虫配置，使我再次体会到高效的 IDE 工具对开发效率的巨大影响。

开发过程及框架介绍

这次的爬虫起的名字为 Tidy，预期通过它可以高效系统的整理文件和获取信息，目前只有抓取站点信息的能力，之后会加入文件整理，下载压缩解压等一系列的功能。开放源代码 ruriio/tidy 。

开发过程可以从 commits 日志来看，以下内容是对流水帐的整理。

1. 基础数据结构和架构

程序使用 Meta 结构体的基础数据结构，内容包含标题、发行时间、演员、发行商、作品编号等元数据信息，放在 model/meta.go 内。

type Meta struct {
Id string
Title string
Actor string
Producer string
Series string
Age string
Sample string
Poster string
Images []string
Label string
Genre string
}

为了方便打印，编写了 meta json 化输出的方法，也放置在 meta.go 文件中。

func (meta Meta) Json() string {
out, err := json.Marshal(meta)
if err != nil {
log.Panic(err)
}
return string(out)
}

目录结构方面，使用 model 目录存放模块代码，使用 sites 目录存放站点配置代码。在根目录放置了 main.go scrape.go 文件作为程序入口和爬虫的逻辑体。

为了统一站点配置，创建 Site 结构体，包含所有站点相关的信息如 Url UserAgent Title 等。同时将常用的桌面和移动端 UA内置在常量里，方便调用。

package sites
type Site struct {
Url string
UserAgent string
Title string
}
const UserAgent string = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.90 Safari/537.36"
const MobileUserAgent string = "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1"

2. 基础站点配置清单

Site 结构体类似于父类或者站点配置清单，真正的站点配置在单个的站点配置清单中返回，如 dmm.go

package sites
import "fmt"
func Dmm(id string) Site {
return Site{
Url: url(id),
UserAgent: MobileUserAgent,
Title: ".ttl-grp",
}
}
func url(id string) string {
return fmt.Sprintf("https://www.dmm.co.jp/mono/dvd/-/detail/=/cid=%s/", id)
}

在这个站点配置中，初始化了一个 Site 结构体，并通过 id 参数填充了 url，爬起使用移动端的网页，同时对应的 Title 标题字段，使用了 .ttl-grp 的 CSS Selector 。字段这一块会在后续过程中优化，现在的目标是先搭起框架跑起来。如果没有编写爬虫和写前端的经验，建议先阅读下 CSS3 选择器的相关文档。

如果要新建站点，只需要再创建一个类似的站点配置清单即可。

3. 基础爬虫逻辑代码

爬虫的库有很多，我选择了 goquery 库底层爬虫支持库。爬虫逻辑代码是爬虫类型程序的核心，基本都是用配置的 CSS selector 查找目标然后解析。例如 scrape.go 的代码片段。

func Scrape(site Site) Meta {
var meta = Meta{}
log.Printf("url: %s", site.Url)
resp, err := get(site)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
log.Fatalf("stats code error: %d %s", resp.StatusCode, resp.Status)
}
// Load the HTML document
 doc, err := goquery.NewDocumentFromReader(resp.Body)
if err != nil {
log.Fatal(err)
}
meta.Title = strings.TrimSpace(doc.Find(site.Title).First().Text())
doc.Find(".ttl-grp").Each(func(i int, s *goquery.Selection) {
// For each item found, get the band and title
 bind := s.Find("a").Text()
title := s.Find("i").Text()
fmt.Printf("Review %d: %s - %s\n", i, bind, title)
})
return meta
}

代码片段中，使用 goquery.NewDocumentFromReader(resp.Body) 创建了一个 Document 对象，然后通过 doc.Find(site.Title).First().Text() 查找到目标，并将字符串处理，返回 meta。

同时也对 http GET 请求进行了封装，这里填充了 header 字段，之后会增加 cookie 支持:

func get(site Site) (*http.Response, error) {
client := &http.Client{}
req, err := http.NewRequest("GET", site.Url, nil)
if err != nil {
log.Fatal(err)
}
req.Header.Set("User-Agent", site.UserAgent)
return client.Do(req)
}

同时为了调试方便，增加了打印 html 的方法:

func printBody(resp *http.Response) {
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
log.Fatal(err)
}
log.Printf("body: %s", string(body))
}

4. Selector 选择器封装

在上一节的代码片断中，可以看到使用了 doc.Find() 函数获取文本：

Site{
Url: url(id),
UserAgent: MobileUserAgent,
Title: ".ttl-grp",
}
meta.Title = strings.TrimSpace(doc.Find(site.Title).First().Text())

可以对这一断代码进行封装，作为预置项方便扩展和使用(site.go)：

type Selector struct {
Id Item
Title Item
Actor Item
Poster Item
Series Item
Producer Item
Release Item
Duration Item
Sample Item
Images Item
Label Item
Genre Item
}
type Item struct {
selector string
replacer *strings.Replacer
}
func selector(selector string) Item {
return Item{selector: selector, replacer: strings.NewReplacer("", "")}
}
func replacer(selector string, replacer *strings.Replacer) Item {
return Item{selector: selector, replacer: replacer}
}

Selector 中的每一个元素 Item 对应于 Meta 中的属性， Item 又包含一个 selector string 表示 css selector 的文本，replacer *strings.Replacer 是用来扩展 Selector 的能力，使它可以支持替换文本的操作，这个能力在后文中会再多次增强。此时的 dmm.go 中站点配置也得到升级：

func Dmm(id string) Site {
return Site{
Url: url(id),
UserAgent: MobileUserAgent,
Selector: Selector{
Title: selector(".ttl-grp"),
Actor: selector("ul.parts-maindata > li > a > span"),
Poster: replacer(".package", NewReplacer("ps.jpg", "pl.jpg")),
Producer: selector(".parts-subdata"),
Sample: selector(".play-btn"),
Series: selector("#work-mono-info > dl:nth-child(4) > dd"),
Release: selector("#work-mono-info > dl:nth-child(8) > dd"),
Duration: selector("#work-mono-info > dl:nth-child(9) > dd"),
Id: selector("#work-mono-info > dl:nth-child(10) > dd"),
Label: selector("#work-mono-info > dl:nth-child(6) > dd > ul > li > a"),
Genre: selector("#work-mono-info > dl.box-genreinfo > dd > ul > li > a"),
Images: replacer("#sample-list > ul > li > a > span > img", NewReplacer("-", "jp-")),
},
}
}

从这段代码可以看出，站点配置清单中的 Selector 结构体元素初始化已经变为使用 selector() 和 replacer()操作函数执行，这段代码仍将在后文中优化。

5. 获取标签文字和属性

在上一节的代码片断中，可以看到使用了 doc.Find(site.Title).First().Text() 来获取文本，同时也做了去首尾空白的处理，为了代码逻辑更合理，将这一块的代码提取到 Site -> Selector -> Item 结构体中：

func (selector Item) Text(doc *goquery.Document) string {
text := strings.TrimSpace(doc.Find(selector.selector).First().Text())
return selector.replacer.Replace(text)
}
func (selector Item) Texts(doc *goquery.Document) []string {
var texts []string
doc.Find(selector.selector).Each(func(i int, selection *goquery.Selection) {
text := strings.TrimSpace(selection.Text())
text = selector.replacer.Replace(text)
texts = append(texts, text)
})
return texts
}

这时，调用 Selector.Item.Text(doc) 函数就可以获取到文本或文本数组内容了。进一步扩展，获取标签的属性内容，函数如下：

func (selector Item) Attr(doc *goquery.Document, attr string) string {
src, exist := doc.Find(selector.selector).First().Attr(attr)
if exist {
return selector.replacer.Replace(strings.TrimSpace(src))
}
return ""
}
func (selector Item) Attrs(doc *goquery.Document, attr string) []string {
var attrs []string
doc.Find(selector.selector).Each(func(i int, selection *goquery.Selection) {
src, exist := selection.Attr(attr)
if exist {
text := strings.TrimSpace(src)
text = selector.replacer.Replace(text)
attrs = append(attrs, text)
}
})
return attrs
}

例如，使用 selector.Attr(doc, "href") 即可获取到当前 selector 的 href 属性值。

此时在 scrape.go 爬虫逻辑中，通过使用如下封装获取所有的查找值。

 // extract meta data from web page
 meta.Title = site.Title.Text(doc)
meta.Actor = site.Actor.Text(doc)
meta.Poster = site.Poster.Image(doc)
meta.Producer = site.Producer.Text(doc)
meta.Sample = site.Sample.Link(doc)
meta.Series = site.Series.Text(doc)
meta.Release = site.Release.Text(doc)
meta.Duration = site.Duration.Text(doc)
meta.Id = site.Id.Text(doc)
meta.Label = site.Label.Text(doc)
meta.Genre = site.Genre.Texts(doc)
meta.Images = site.Images.Images(doc)

可以看到此时 tidy 已经具备了基本的爬虫框架能力，即只需添加新的站点清单，执行代码就可以获取到新增加站点的信息。

当前是通过在单元测试代码中打印 meta 输出来检索信息的，例如：

func TestScrape(t *testing.T) {
meta := Scrape(sites.Dmm("ssxx678"))
fmt.Println(meta.Json())
}

下一步继续增加站点，看在版本不断升级的过程中会遇到什么问题，并不断完善和改进。

Kotlin 代码样式指南

Fri, 28 Feb 2020 00:16:15 +0800

在学习完语言语法后，要学好和用好一门开发语言，代码风格和单元测试是最基础的两个内容。其中单元测试在每个语言中基本相同，而代码风格或代码样式则需要以每个语言的推荐风格为标准，保持统一和规范使用，这在团队协作和开源项目中非常重要。

具体以方法或函数名命名来说例如 c 语言中使用 your_name 这种下划线和小写字母的命名方式，而 Android Java 则使用 yourName 这样的小驼峰式命名法。

代码样式是前行者在实践中总结出的优良写作风格，遵循代码样式规范，不仅是一种良好的编程习惯，更是一种认真的态度，是对前辈先行者和后进同业者的尊重。

不同的开发语言总是会有相应的推荐代码风格和单元测试方法，而这些在一般的教材书上却很少提及。我主要从事 Android 开发工作，常使用 Java 和 Kotlin 语言作为开发语言，遵循 Google 的 Android 开发代码样式规范。一般遵守 Android Studio 或 Intellij Idea 内置的代码风格规范即可，也可以根据需要自定义 IDE 中的代码风格配置文件。通常使用快捷键 ( Linux 下为 CTR+ALT+L) 快速格式化代码风格。

本文主要介绍 Kotlin 相对于 Java 在书写样式上的不同，摘自官方文档，全部规范内容可以直接参考文后的 Kotlin 样式指南。

大括号

when 分支不需要大括号，没有 else if/else 分支且适合放在一行上的 if 语句主体也不需要大括号。

 if (string.isEmpty()) return
when (value) {
0 -> return
// …
 }

除此以外，任何 if、for、when 分支、do 和 while 语句都需要大括号，即使主体为空或仅包含一个语句也是如此。

 if (string.isEmpty())
return // WRONG!

if (string.isEmpty()) {
return // Okay
 }

表达式

仅当整个表达式适合放在一行上时，用作表达式的 if/else 条件语句才能省略大括号。

 val value = if (string.isEmpty()) 0 else 1 // Okay

 val value = if (string.isEmpty()) // WRONG!
 0
else
1

 val value = if (string.isEmpty()) { // Okay
 0
} else {
1
}

换行

代码的列限制为最多 100 个字符。除非是下面说明的情况，否则任何超过此限制的行都必须换行，如下所述。

例外情况：

无法遵循列限制的行（例如，KDoc 中的长网址）
package 和 import 语句
注释中可以剪切并粘贴到 shell 中的命令行

在何处换行

换行的首要原则是：更倾向于在较高的句法级别换行。此外：

某行在非赋值运算符处换行时，换行符将在该符号前面。
- 这也适用于以下“类似运算符”的符号：
- 点分隔符 (.)。
- 成员引用的两个冒号 (::)。
某行在赋值运算符处换行时，换行符将在该符号后面。
方法或构造函数名称始终贴在它后面的左圆括号 (() 上。
逗号 (,) 始终贴在它前面的标记上。
lambda 箭头 (->) 始终贴在它前面的参数列表上。

注意：换行的主要目标是让代码清晰，而不一定是让代码适合放在最少数量的行中。

函数

当函数签名不适合放在一行上时，应让每个参数声明独占一行。以这种格式定义的参数应使用单缩进 (+4)。右圆括号 ()) 和返回类型独占一行，没有额外的缩进。

 fun <T> Iterable<T>.joinToString(
separator: CharSequence = ", ",
prefix: CharSequence = "",
postfix: CharSequence = ""
): String {
// …
 }

表达式函数

当函数只包含一个表达式时，它可以表示为表达式函数。

 override fun toString(): String {
return "Hey"
}

 override fun toString(): String = "Hey"

只有在表达式函数开始一个块时，才应换行。

 fun main() = runBlocking {
// …
 }

否则，如果表达式函数增长到需要换行，应改用普通函数主体、return 声明和普通表达式换行规则。

属性

当属性初始化式不适合放在一行上时，应在等号 (=) 后面换行，并使用缩进。

 private val defaultCharset: Charset? =
EncodingRegistry.getInstance().getDefaultCharsetForPropertiesFiles(file)

声明 get 和/或 set 函数的属性应让每个函数独占一行，并使用正常的缩进 (+4)。对它们进行格式设置时，使用的规则与函数相同。

 var directory: File? = null
set(value) {
// …
 }

只读属性可以使用适合放在一行上的较短语法。

 val defaultExtension: String get() = "kt"

枚举类

对于没有函数且没有关于其常量的文档的枚举，可以选择性地将其格式设为单行。

 enum class Answer { YES, NO, MAYBE }

将枚举中的常量放在单独的行上时，它们之间不需要空白行，但它们定义主体时除外。

 enum class Answer {
YES,
NO,
MAYBE {
override fun toString() = """¯\_(ツ)_/¯"""
}
}

由于枚举类是类，因此用于类格式设置的其他所有规则都适用。

注解

应将成员或类型注解放在单独的行上，让其紧接在标注的构造前面。

 @Retention(SOURCE)
@Target(FUNCTION, PROPERTY_SETTER, FIELD)
annotation class Global

可以将不带参数的注解放在一行上。

 @JvmField @Volatile
var disposable: Disposable? = null

如果只存在一个不带参数的注解，则可以将其与声明放在同一行上。

 @Volatile var disposable: Disposable? = null
@Test fun selectAll() {
// …
 }

隐式返回/属性类型

如果表达式函数主体或属性初始化式是标量值，或者可以根据主体明确推断出返回类型，则可以将其省略。

 override fun toString(): String = "Hey"
// becomes
 override fun toString() = "Hey"

 private val ICON: Icon = IconLoader.getIcon("/icons/kotlin.png")
// becomes
 private val ICON = IconLoader.getIcon("/icons/kotlin.png")

在编写库时，如果显式类型声明是公共 API 的一部分，则应将其保留。

命名

标识符仅使用 ASCII 字母和数字，在下面所述的少数情况下，还会使用下划线。因此，每个有效的标识符名称都可匹配正则表达式 \w+。

不使用特殊前缀或后缀（如在 name_、mName、s_name 和 kName 示例中看到的前缀或后缀），但后备属性除外（请参阅后备属性）。

软件包名称

软件包名称全部为小写字母，连续的单词直接连接在一起（没有下划线）。

 // Okay
 package com.example.deepspace
// WRONG!
 package com.example.deepSpace
// WRONG!
 package com.example.deep_space

类型名称

类名采用 PascalCase 大小写形式编写，通常是名词或名词短语。例如，Character 或 ImmutableList。接口名称也可以是名词或名词短语（例如 List），但有时还可以是形容词或形容词短语（例如 Readable）。

测试类的命名方式是以测试的类的名称开头且以 Test 结尾。例如，HashTest 或 HashIntegrationTest。

函数名称

函数名称采用 camelCase 大小写形式编写，通常是动词或动词短语。例如，sendMessage 或 stop。

允许在测试函数名称中出现下划线，用于分隔名称的逻辑组成部分。

 @Test fun pop_emptyStack() {
// …
 }

常量名称

常量名称使用 UPPER_SNAKE_CASE 大小写形式：全部为大写字母，单词用下划线分隔。但究竟什么是常量呢？

常量是没有自定义 get 函数的 val 属性，其内容绝对不可变，并且其函数没有可检测到的副作用。这包括不可变类型和不可变类型的不可变集合，以及标量和字符串（如果标记为 const）。如果某个实例的任何可观察状态可以改变，则它不是常量。仅仅打算永不改变对象是不够的。

 const val NUMBER = 5
val NAMES = listOf("Alice", "Bob")
val AGES = mapOf("Alice" to 35, "Bob" to 32)
val COMMA_JOINER = Joiner.on(',') // Joiner is immutable
 val EMPTY_ARRAY = arrayOf()

这些名称通常是名词或名词短语。

常量值只能在 object 内定义或定义为顶级声明。满足常量的要求但是在 class 内定义的值必须使用非常量名称。

作为标量值的常量必须使用 const 修饰符。

非常量名称

非常量名称采用 camelCase 大小写形式编写。这些适用于实例属性、本地属性和参数名称。

 val variable = "var"
val nonConstScalar = "non-const"
val mutableCollection: MutableSet = HashSet()
val mutableElements = listOf(mutableInstance)
val mutableValues = mapOf("Alice" to mutableInstance, "Bob" to mutableInstance2)
val logger = Logger.getLogger(MyClass::class.java.name)
val nonEmptyArray = arrayOf("these", "can", "change")

这些名称通常是名词或名词短语。

后备属性

需要后备属性时，其名称应与实际属性的名称完全匹配，只不过带有下划线前缀。

 private var _table: Map? = null
val table: Map
get() {
if (_table == null) {
_table = HashMap()
}
return _table ?: throw AssertionError()
}

更多关于注释、文档等内容基本和 Java 代码规范一致，请参考下面链接中的文档。

参考

如何管理多模块工程中的依赖?

Tue, 29 Oct 2019 16:42:34 +0800

如今，Android 应用程序的模块化已成为 Android 社区中的热门话题。每个模块的依赖性管理比以往任何时候都变得越来越重要。

通过阅读本文，您将学会使用不同的方法来管理项目的依赖关系：使用根项目的 ext 块，或通过在模块中引用包含依赖关系的独立文件中的依赖，或使用 buildSrc 模块管理依赖。

1. 使用 ext 块

我们需要在项目的 build.gradle 中定义所需的依赖项，以使该变量可以在所有子模块中访问

buildscript {
ext {
kotlin_version = '1.3.11'
appcompat_version = "28.0.0"
junit_version = "4.12"
test_runner_version = "1.0.2"
}
}

我们在 buildscript ext 块中定义了必需的依赖库版本，并更新模块的依赖关系为此处的版本变量。

dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
implementation "com.android.support:appcompat-v7:$appcompat_version"
testImplementation "junit:junit:$junit_version"
androidTestImplementation "com.android.support.test:runner:$test_runner_version"
}

总结： 这种方式非常简单明了，支持版本更新检查提示，可以方便的管理和维护。仅在单一项目中集成很合适，但是要在多个工程中共享依赖版本则需要拷贝 ext 块。

2. 从单独文件中引用

这个方法与上一个方法类似，但看起来更为简洁，因为所有依赖项和版本均从单独的文件中引用。

可以参考 dependencies.gradle 文件，我们新建一个 dependencies.gradle 文件：

ext {
kotlinVersion = '1.3.11'
appCompatVersion = "1.1.0"
constraintLayoutVersion = "1.1.0"
junit4Version = "4.12"
testRunnerVersion = "1.2.0"
libraries = [
kotlinStdLib : "org.jetbrains.kotlin:kotlin-stdlib-jdk7:" + kotlinVersion,
appCompat : "androidx.appcompat:appcompat:" + appCompatVersion,
constraintLayout: "androidx.constraintlayout:constraintlayout:" + constraintLayoutVersion
]
testLibraries = [
junit4: "junit:junit:" + junit4Version
]
androidTestLibraries = [
testRunner: "com.android.support.test:runner:" + testRunnerVersion
]
}

buildscript {
apply from: 'dependencies.gradle'
}

在项目 buildscript 块中的引用 dependencies.gradle 文件，以便所有模块可以访问依赖变量，并使用依赖变量更新子模块的依赖关系。

dependencies {
implementation libraries.kotlinStdLib
implementation libraries.appCompat
testImplementation testLibraries.junit4
androidTestImplementation androidTestLibraries.testRunner
}

总结： 这种方式可以隐藏在模块中依赖的版本细节，同时 apply from 方式引入 ext 块，可以将文件托管到网络上并从网络引入，可以方便的跨多个工程统一管理依赖版本，但是不能很直观的理解，不支持版本更新提示。

3. 使用 `buildSrc`

通过这种方法，我们可以在所有模块的 build.gradle 文件中使用代码补全。我们可以在项目结构里使用 Kotlin 或 Java 来定义和管理依赖项。

使用 Java

首先，我们需要在项目的根目录中创建 buildSrc 目录。如果要使用 Java，则需要创建 src/main/java/Dependency 类并定义依赖项。

我们将类命名为Dependencies，但是您可以根据需要随意命名。

public class Dependencies {
public final static String APP_COMPAT_VERSION = "1.1.0";
public final static String KOTLIN_VERSION = "1.3.41";
public final static String APP_COMPAT = "androidx.appcompat:appcompat:" + APP_COMPAT_VERSION;
public final static String KOTLIN_STDLIB = "org.jetbrains.kotlin:kotlin-stdlib-jdk7:" + KOTLIN_VERSION;
}

然后，在模块 build.gralde 文件中添加依赖关系：

使用 Kotlin

我们需要在项目的根目录中创建 buildSrc 目录，并在 buildSrc 目录中创建 build.gradle.kts。然后在 build.gradle.kts 中附加 kotlin-dsl 插件。

plugins {
`kotlin-dsl`
}
repositories {
jcenter()
}

import Versions.APP_COMPAT_VERSION
import Versions.CONSTRAINT_VERSION
import Versions.KOTLIN_VERSION
object Versions {
const val APP_COMPAT_VERSION = "1.1.0"
const val KOTLIN_VERSION = "1.3.41"
const val CONSTRAINT_VERSION = "1.1.0"
}
object Dependencies {
val APP_COMPAT = "androidx.appcompat:appcompat:$APP_COMPAT_VERSION"
val KOTLIN_STDLIB = "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$KOTLIN_VERSION"
val CONSTRAINT_LAYOUT = "androidx.constraintlayout:constraintlayout:$CONSTRAINT_VERSION"
}

最后，从 Deps 对象中引用依赖：

总结： 这种方式可以在代码中很方便的集中管理依赖关系，简单易懂，支持点击跳转和自动补全。但是不支持版本更新检查，也不能方便的跨项目使用，可以通过 git submodule 的方式跨项目使用。

使用场景

对于这三种方式，如每一个小结的总结，各有利弊，可以分为如下几个使用场景：

1. 如果考虑到版本更新提示，则方式一 ext 块最佳；

2. 如果不考虑版本更新提示，需要跨项目管理，则方式二独立文件最佳；

3. 如果不考虑版本更新提示，需要自动补全和点击跳转，则方式三 buildSrc 最佳；

4. 如果不考虑版本更新提示，需要自动补全，且需要跨项目管理，则可以使用方式三 buildSrc 搭配 git submodule 管理；

5. 如果考虑到版本更新提示，且需要跨项目管理，则可以仅在方式二独立文件中包含版本号信息，并托管到远程服务上，只统一管理版本号更新；

6. 如果需要版本更新提示，且需要自动补全，对不起，目前还没有方法；

7. 如果您既要版本更新提示，又要跨项目管理，又要自动补全，对不起，目前还没有方法，您可能需要自己编写插件来支持。当然您也可以单独创建一个工程，结合场景4和场景1共用版本号，同时可以使用 ci 每天自动编译通过 Lint 检查版本更新，有更新时手动或写脚本自动提交更新。

参考

How to manage dependencies in a multi module project?

Android 工程的 Vagrant Gitlab Runner

Mon, 29 Jul 2019 15:30:01 +0800

Gitlab runner 是一个优秀的持续集成工具，通过 runner 我们可以执行自动化编译、静态代码检查、单元测试、UI 测试，发布等操作，是高效快速迭代开发的必要工具。 GitLab Runner 独立运行于 Gitlab 实例，可以非常容易的扩展和安装。

排队竞争

当团队内项目增多后，代码提交会变得频繁，单一的 runner 实例执行 CI 操作会出现占用时间较长，排队等待时间较长的问题。尤其对于 Android 工程，一个编译任务一般需要几分钟才能执行完毕，这时我们就需要对 runner 服务进行扩充，增加 runner 的数量。

为了最佳化实践，我们团队使用的是 GitLab Runner + Docker 的运行方式，runner 的每一个编译任务都在 docker 容器 (xdtianyu/openjdk8) 内运行，容器内集成了 Java/SDK/NDK 基础环境。这种方式在 Linux/MacOS 安装和执行非常简单方便，但是在 Windows 环境下却不那么容易，因为 Gitlab Runner 和 docker 在 Windows 系统上配置和运行都很困难，不能快速分发给不同的 Windows 主机执行。

而团队内几乎所有开发机还在使用 Windows 系统，所以要利用闲置计算资源扩充 runner 数量就需要一个独立于宿主机环境，能快速分发且操作简单的解决方案。

扩充方案

要独立宿主环境，虚拟机是必然选择；要跨平台快速分发虚拟机且操作简单，Vagrant 则是必然选择。具体方案概括为 Vagrant + VirtualBox 虚拟机 + Gitlab Runner + Docker。

最终的代码请参考 xdtianyu/vagrant/gitlab-runner，克隆代码后，只需修改 .env 文件，添加 Gitlab 实例地址及 Runner Token, 执行 vagrant up --provision 命令后即可运行扩充 Runner 服务。

使用步骤

1. 系统安装 Vagrant 及 VirtualBox，如果是 Windows 系统，请升级 PowserShell 到 3.0 及以上版本。

2. 克隆代码，同时修改 .env 文件中的环境变量。

URL="YOUR_GITLAB_URL"
TOKEN="YOUR_TOKEN"
PROXY_HOST="YOUR_PROXY_HOST"
PROXY_PORT="YOUR_PROXY_PORT"

如果不需要适用代理，请将 PROXY_HOST PROXY_PORT 设置为空。

3. 执行 vagrant 命令启动 runner 服务

vagrant up --provision

关闭虚拟机

可以使用如下命令关闭虚拟机

vagrant halt

您可以通过 vagrant up --provision 命令再次启动虚拟机。

注册

Runner 服务只会在第一次运行时注册，之后运行不会再重复注册。这个功能是通过 bootstrap.sh 中的如下代码实现的：

if [ ! -z "$(cat /etc/gitlab-runner/config.toml |grep url\ =\ \"$URL\")" ]; then
echo "Runner is already registered."
exit 0
fi

销毁

可以使用如下命令销毁虚拟机

vagrant destroy

之后需要在 GitLab 移除已经销毁的 runner 服务。

主机名

虚拟机的主机名会根据运行其的宿主机自动命名，这个功能是在 Vagrantfile 文件中的如下代码实现的：

config.vm.hostname = "#{`hostname`[0..-2]}-runner"

例如，如果你的电脑主机名为 Peter-Desktop，那么虚拟机的主机名将会被设置为 Peter-Desktop-runner。同时， Gitlab Runner 的名称也将被设置为虚拟机主机名，这样可以使同一个 Gitlab 服务中辨识不同 runner 服务变得容易。

下载速度慢

如果您访问 vagrant 托管的速度较慢，可以使用任意文件下载工具下载如下镜像文件到本地：

https://vagrantcloud.com/xdtianyu/boxes/gitlab-runner/versions/1.0.0/providers/virtualbox.box

然后通过如下命令添加虚拟机镜像到仓库：

vagrant box add xdtianyu/gitlab-runner gitlab-runner.box

您也可以将此 box 文件托管到内网服务器，然后修改 Vagrantfile 文件中的下列行：

# config.vm.box_url = ["https://YOUR_LAN_HOSTING/gitlab-runner.box"]

例如，您将此文件托管在 http://10.0.0.1:8080/gitlab-runner.box，则修改配置为：

config.vm.box_url = ["http://10.0.0.1:8080/gitlab-runner.box"]

之后您可以将此仓库包含 .env 文件分发给同事，他们只需执行 vagrant up --provision 命令即可快速启动 runner 服务。

登录到虚拟机

通过如下命令登录到虚拟机：

vagrant ssh

默认的用户名及 root 密码都是 vagrant，您无需密码即可通过 sudo 执行命令。

.gitlab-ci.yml 示例

请参考 xdtianyu/CallerInfo 仓库中的 .gitlab-ci.yml 文件。您也可以在此 runner 虚拟机中使用 ndk 编译、单元测试、UI 测试。

项目地址

https://github.com/xdtianyu/vagrant

分布式 MinIO s3 云存储实践

Mon, 10 Jun 2019 15:27:57 +0800

MinIO 是一款优秀的开源云存储服务，兼容亚马逊 S3 云存储。它最适合存储非结构化数据，如照片，视频，日志文件，备份和容器/ VM映像。对象的大小可以从几KB到最大5TB。

MinIO 是一个轻量级服务器，可以与应用程序堆栈捆绑在一起，类似于 NodeJS，Redis 和 MySQL。

通过 docker 运行

docker pull minio/minio
docker run -p 9000:9000 minio/minio server /data

分布式运行实践

要通过分布式方式运行 minio，需要配置不少于4个的偶数 minio 运行实例。

我们首先编写一个 DockerFile 文件，用于快速配置及运行 minio 实例，再通过 docker-compose.yml 传入执行参数 MINIO_VOLUMES 并运行 docker 实例。

每一个实例对应不同的 MINIO_VOLUMES 参数，例如 hk 实例使用参数：

MINIO_VOLUMES: "https://minio:9199/data/1 https://s3-jp.xdty.org:443/data/2 https://s3-sh.xdty.org:443/data/3 https://s3-tx.xdty.org:443/data/4"

而 jp 实例使用参数：

MINIO_VOLUMES: "https://minio:9199/data/2 https://s3-hk.xdty.org:443/data/1 https://s3-sh.xdty.org:443/data/3 https://s3-tx.xdty.org:443/data/4"

其他节点依次类推，注意这里的节点可以运行在同一个服务器上，例如每个节点实例运行在同一个服务器的不同存储目录下；也可以运行在不同的服务器上。

其中 9199 端口是当前实例 docker 运行监听的端口，由于 minio 分布式实例不能同时使用 HTTP 和 HTTPS ，为了能和其他实例通信，docker 内的实例也启用了 TLS。

最后通过 nginx 作为前端代理，将 minio 服务转到 443 端口。

当所有节点实例运行起来后，会和其他节点实例通信并建立连接。这时当用户上传新文件到某一个节点时，其他节点也会同步数据；在某一个节点增加用户也会同步到其他节点。

更多关于分布式服务的细节请参考官方文档 https://docs.min.io/docs/distributed-minio-quickstart-guide.html

示例代码

如下代码仅供参考，已经包含了所有运行分布式 minio 实例配置文件。

Dockerfile

FROM alpine
MAINTAINER xdtianyu@gmail.com

ENV GID=33 UID=33

ADD https://dl.min.io/server/minio/release/linux-amd64/minio /usr/bin/minio

RUN apk \
 --update \
 --no-cache \
 add su-exec \
 ca-certificates \
 openssl \
 tini && \
 chmod +x /usr/bin/minio

COPY run.sh /run.sh

ENV MINIO_VOLUMES "/data"
ENV MINIO_OPTS "server --address 0.0.0.0:9199"
ENV MINIO_ACCESS_KEY "73mPXCPJzhpPLIiFnf"
ENV MINIO_SECRET_KEY "M56OsPqKxBFxNqnmSOBVtfbIziKHMCD8iugu"

VOLUME "/data"
EXPOSE 9199

CMD ["sh", "run.sh"]

run.sh

#!/bin/sh

set -e
mkdir -p /data
if [ ! -d "/certs" ]; then
mkdir -p /certs
cd /certs
openssl genrsa 1024 > private.key
chmod 400 private.key
openssl req -new -key private.key -out private.csr -subj "/C=UK/ST=Warwickshire/L=Leamington/O=OrgName/OU=IT Department/CN=minio"
openssl x509 -req -days 36500 -in private.csr -signkey private.key -out public.crt
cd -
fi
chown -R $UID:$GID /data /certs
echo "Starting minio..."
exec su-exec $UID:$GID /sbin/tini -- /usr/bin/minio $MINIO_OPTS $MINIO_VOLUMES

docker-compose.yml

version: '3'

services:

 nginx:
 image: xdtianyu/hub:nginx
 restart: always
 container_name: nginx
 volumes:
 - /etc/nginx/conf.d:/etc/nginx/conf.d
 - /etc/nginx/le:/etc/nginx/le
 - /var/www:/var/www

 minio:
 image: xdtianyu/hub:minio
 restart: always
 container_name: minio
 ports:
 - "127.0.0.1:9199:9199"
 volumes:
 - /home/minio/xdty/data:/data
 environment:
 MINIO_ACCESS_KEY: xxxxxxxx
 MINIO_SECRET_KEY: xxxxxxxxxxxxxxxx
 MINIO_OPTS: "-S /certs server --address minio:9199"
 MINIO_VOLUMES: "https://minio:9199/data/1 https://s3-jp.xdty.org:443/data/2 https://s3-sh.xdty.org:443/data/3 https://s3-tx.xdty.org:443/data/4"

nginx 配置文件 s3-xdty.conf

server {
include listen.conf;
server_name s3-jp.xdty.org s3-hk.xdty.org s3-tx.xdty.org s3-sh.xdty.org;
charset utf-8;
access_log /var/log/nginx/$host.access.log;
client_max_body_size 24M;
root /var/www/;
if ($scheme = http) {
return 301 https://$http_host$request_uri;
}
location / {
proxy_pass https://minio:9199;
include proxy_params;
proxy_http_version 1.1;
proxy_set_header Connection "";
}
}

参考

https://github.com/minio/minio

https://docs.min.io/docs/distributed-minio-quickstart-guide.html

Android 应用内存数据分析方法

Mon, 29 Apr 2019 16:20:44 +0800

内存优化是 Android 开发中一个非常重要的环节，如果不注意就可能出现>内存泄漏，内存溢出，应用运行缓慢，效率低下等问题，严重影响用户体验。本文主要介绍 Android 应用内存的抓取和内存数据分析方法。

一. Android Profiler 分析工具

1. Profiler 概览信息

使用 Android Studio profiler 工具对进程内存进行追踪，可以看到如下图的内存概览信息。

从概览信息中可以看到 Java, Code 部分内存占用较高，可以参考 Android 官网 memory-profiler 的相关内容。

内存计数中的类别如下所示：

Java：从 Java 或 Kotlin 代码分配的对象内存。
Native：从 C 或 C++ 代码分配的对象内存。

即使您的应用中不使用 C++，您也可能会看到此处使用的一些原生内存，因为 Android 框架使用原生内存代表您处理各种任务，如处理图像资源和其他图形时，即使您编写的代码采用 Java 或 Kotlin 语言。

Graphics：图形缓冲区队列向屏幕显示像素（包括 GL 表面、GL 纹理等等）所使用的内存。（请注意，这是与 CPU 共享的内存，不是 GPU 专用内存。）
Stack：您的应用中的原生堆栈和 Java 堆栈使用的内存。这通常与您的应用运行多少线程有关。
Code：您的应用用于处理代码和资源（如 dex 字节码、已优化或已编译的 dex 码、.so 库和字体）的内存。
Other：您的应用使用的系统不确定如何分类的内存。
Allocated：您的应用分配的 Java/Kotlin 对象数。它没有计入 C 或 C++ 中分配的对象。

2. Profiler 内存分析

点击左上角 dump java heap 按钮，或者使用 CTRL+D 快捷键，可以抓取进程的内存信息，在这里可以快速查看对象的分配数量及占用的大小和一些调用的堆栈。这里的功能比较有限，我们需要使用 Export Heap Dump 按钮将内存数据导出为 hprof 文件然后再使用 MAT 工具分析。使用 MAT 前，需要使用 SDK 中的 hprof-conv 工具转换版本：

hprof-conv memory-20190429T103715.hprof a.hprof

二. MAT 内存分析工具

1. 查看内存分配

MAT 是一个强大的 Java 内存分析工具，可以在 eclipse 官网下载。打开 Heap Dump a.hprof 文件，可以看到内存泄漏的概要信息。

在 Overview 界面点击 Leak Suspects，可以查看内存泄漏的详细信息。

在 Overview 界面点击 Histogram，可以查看内存分配的详细信息，可以看到对象分配的个数，占用的内存大小等。可以在这个界面查看分析为什么创建了大量的对象，如果不是必要的，可以考虑减少对象的分配来优化内存占用。

可以看到内存中分配了超过 7 万个 String 对象，可以考虑优化，减少 String 对象的创建。

点击 Dominator tree 按钮，可以以堆栈的形式查看内存的占用信息

从上图中可以看到 Bitmap 对象占用了大量的内存空间，可以考虑在低内存设备上优化。

2. 定位及导出 Bitmap 图片数据

对于没有堆栈的对象，可以使用 Path TO GC Roots 菜单，快速定位引用的位置，

通过引用的调用关系，就可以快速定位到代码位置了。

也可以通过导出内存中的 Bitmap 图片二进制数据，然后查看图片文件来直观的定位图片。

首先点击 Bitmap 对象，可以在 Inspector 中查看属性，可以看到宽度和长度信息。

然后再在 byte 对象上点击右键，Copy - Save Value To File 保存图片数据到文件 a.data。

之后通过开源图片处理工具 GIMP 打开刚才导出的 a.data 文件，图像类型选择 RGB Alpha，填入上一步 Bitmap 属性中看到的长度和高度，然后点击打开即可打开图片。

3. 定位及导出字符串

从 Histogram 中看到内存中分配了大量的 String 对象，首先使用菜单中的 List objects - withoutgoing references 查看所有的字符串对象。

之后使用 Path to GC Roots 菜单即可查看引用关系和调用栈：

也可以将这些 String 内容导出到 txt 文件，然后查看内存中具体是哪些字符串。首先在字符串列表选项卡使用快捷键 CTRL + A 全选，再点击右键使用 Copy - Save Value to File 菜单即可将文本内容导出到 txt 文件，之后使用常用的文本文档工具查看即可。

4. 内存数据安全的思考

从上述导出 Bitmap 图片和 String 字符串的方法可以看出，如果拿到应用进程内存的拷贝，可以很轻易的拿到敏感的应用数据。例如，如果用户的密码或者应用的 API key 等被储存并以 String 等对象在内存中引用，则可以轻易被获取到。

针对这个安全问题，应该避免用户密码的本地保存，可以使用 Json web token 等认证机制避免和服务器交互时用户密码的使用，同时服务端的 API 可以通过应用签名等额外信息作为和客户端通信的辅助验证信息。

三. 抓取内存的方法

除了通过 Android Studio Profiler 外，还可以通过以下几个方法抓取应用memory dump。

1. 通过 adb 命令

可以使用下面命令导出 hprof 文件，需要应用 apk 是 debug 版，如果 apk 是 release 版，则需要手机系统版本是 userdebug 或者 eng 版。

adb shell am dumpheap com.tencent.mm /data/local/tmp/a.hprof
adb pull /data/local/tmp/a.hprof
hprof-conv a.hprof b.hprof

从上面命令可以看出，只要使用模拟器或者手机是 eng 或 userdebug 版就可以轻易抓取 release 版本的应用内存，例如微信、支付宝等应用，可以看到内存安全问题应该得到重视。

2. 应用内主动抓取

可以在应用内使用 android.os.Debug.dumpHprofData(String fileName) 接口主动抓取应用的内存堆栈。只需要在程序运行时调用 dumpHprofData(String fileName) 静态接口即可将应用内存导出到文件。如下是一段在应用异常退出时抓取内存的示例代码仅供参考：

public class CaptureHeapDumpsApplication extends Application {
private static final String FILE_NAME = "/data/local/tmp/heap-dump.hprof";
@Override
public void onCreate() {
super.onCreate();
Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
String absolutePath = new File(FILE_NAME).getAbsolutePath();
try {
Debug.dumpHprofData(absolutePath);
} catch (IOException e1) {
e1.printStackTrace();
}
}
});
}
}

参考

使用 Memory Profiler 查看 Java 堆和内存分配

Memory Analyzer (MAT)

How to Capture Heap Dump From an Android App

代码仓库服务之 GitLab

Wed, 16 Jan 2019 22:11:12 +0800

GitLab 是一个优秀的协作代码仓库服务，拥有几乎所有 GitHub 的功能，可以当作后者的开源实现。不同于纯 git 仓库服务， GitLab 主打社区和自动化 Pipeline 功能，拥有众多优秀扩展如 CI/CD，Pages，Issue board 等。

关于 GitLab

GitLab是由GitLab Inc.开发，使用MIT许可证的基于网络的Git仓库管理工具，且具有wiki和issue跟踪功能。

GitLab 由乌克兰程序员 Dmitriy Zaporozhets 和 Valery Sizov 开发，它由 Ruby 写成。后来，一些部分用 Go 语言重写。截止 2018 年 5 月，该公司约有 290 名团队成员，以及 2000 多名开源贡献者。 GitLab 被 IBM，Sony，Jülich Research Center，NASA，Alibaba，Invincea，O’Reilly Media，Leibniz-Rechenzentrum (LRZ)，CERN，SpaceX 等组织使用。

CE 与 EE 版本

自建的 GitLab 服务分为开源社区版本 (CE) 和企业版本 (EE)，一般来说 CE 版本已经足够团队的开发使用了，企业版多了代码质量、GitLab geo 、Epics 等功能。

另外如果团队或个人有维护开源项目，也可以申请 GitLab 的开源许可，可以免费获得完整的企业版功能。

与 Gerrit 对比

Gerrit 是 Google Android 团队开发的代码仓库服务，主打的特性是代码 Review，不同于 GitHub 和 GitLab 这一类社区化仓库服务主要是以 Pull request 方式迭代代码，相对于 Gerrit，GitLab 服务功能更强大高效更现代化一些。

基本使用

添加 ssh key

注册成功后就可以按照提示在 /profile/keys 添加 ssh key 了，添加完成后就可以 push 提交代码了。

新建工程

点击主页的 New Project 就可以新建工程了，注意这里可以将工程设置三个可见状态，private 私有仓库任何其他人都不可见，也无权限访问和克隆；Internal 内部仓库则是任何注册的用户可见可访问；Public 公开仓库表示未注册的用户也可以访问。

另外也可以通过模板创建工程，也可以通过 Import project 导入外部的代码仓库。

新建组

点击右上角的加号，选择 New Group 即可创建新的群组，界面和创建新工程类似，也包括三个可见状态，和仓库类似。可以按照实际业务模块新建群组来将多个开发者和项目联系起来，方便管理和协作。

代码权限

可以点击工程设置中的 Permission 选项卡调整工程的权限，这里可以设置代码、Issue、Wiki 等权限。

Issue boards

Issue boards 类似于 trello，可以高效的可视化管理项目的问题和进度。

WIKI

每个工程都会有一个 wiki 库，这里可以托管公共文档，项目说明文档，操作手册，知识共享等内容。

集成 CI

GitLab 的一大优势就是集成的 CI，通过 GitLab Runner，可以自动化构建发布任何软件工程。同时可以确保在每次提交时检查代码质量、编译、测试、部署等。通过 Pipeline，可以方便的将每个阶段独立分离。

如下代码是一个简短的 Android 工程编译 CI 代码：

image: xdtianyu/docker:openjdk8
before_script:
 - source /opt/setup-android-sdk.sh

stages:
 - build
build:
 stage: build
 script:
 - ./gradlew build
 - mkdir -p dist
 - find app/build/outputs/ -name \*.apk -exec cp {} dist \;
 artifacts:
 paths:
 - "dist/*"

生成 pages

GitLab pages 是另一个强大的功能，可以方便的将文档或者 API 手册发布到 pages 网页服务上。

例如下面的 CI 代码可以自动运行 hexo 静态博客生成工具，将项目中的 md 文档生成 html 文件发布到 pages 服务，之后就可以通过浏览器打开网址直接访问了。类似的也可以将自己编写的 html， java api doc，单元测试报告，覆盖率报告等文件直接发布到 pages。

image: node:8.11.2

before_script:
 - git submodule sync --recursive
 - git submodule update --init --recursive

pages:
 cache:
 paths:
 - node_modules/

 script:
 - npm install hexo-cli -g
 - npm install
 - hexo deploy
 artifacts:
 paths:
 - public
 only:
 - master

轻量代码仓库

相对于功能强大的 GitLab，也有一些轻量级的代码仓库服务如 Gitea , Gogos 等。可以访问 awesome-selfhosted#project-management 查看。

参考

https://zh.wikipedia.org/zh-hans/Gitlab

GitLab Pricing

Android 外置 SD 卡写入权限问题

Tue, 25 Dec 2018 22:20:06 +0800

最近升级到 Android 9.0 后，发现文件管理器在写入外置 SD 卡时出现了写入失败的问题，定位到 File.canWrite() 方法，发现返回了 false。经过讨论追踪定位，发现是由于 Google 的一个更改导致的:

diff --git a/data/etc/platform.xml b/data/etc/platform.xml
index 04006b1..3021555 100644
--- a/data/etc/platform.xml
+++ b/data/etc/platform.xml
@@ -62,7 +62,6 @@

<permission name="android.permission.WRITE_MEDIA_STORAGE" >
<group gid="media_rw" />
- <group gid="sdcard_rw" />
 </permission>
<permission name="android.permission.ACCESS_MTP" >

diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index a0cb722..940d19f 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -20936,9 +20936,6 @@
 if (Process.isIsolated(uid)) {
return Zygote.MOUNT_EXTERNAL_NONE;
}
- if (checkUidPermission(WRITE_MEDIA_STORAGE, uid) == PERMISSION_GRANTED) {
- return Zygote.MOUNT_EXTERNAL_DEFAULT;
- }
 if (checkUidPermission(READ_EXTERNAL_STORAGE, uid) == PERMISSION_DENIED) {
return Zygote.MOUNT_EXTERNAL_DEFAULT;
}

这里的修改移除了 WRITE_MEDIA_STORAGE 权限相关权限，导致了外部 SD 卡存储不可写的问题。

平台签名应用受影响

这个修改对系统应用影响较大，在 9.0 之前的平台，申请了 WRITE_MEDIA_STORAGE 的权限后，平台签名的应用就可以通过 java.io.File 接口写入外置 SD 卡了。但是这个修改之后，想要写入外置 SD 卡，就需要像第三方应用一样，使用 DocumentFile 的接口，可以阅读 API 文档存储访问框架和使用作用域目录访问。

参考 google 的这个 bug ，平台类的应用，如文件管理器、相机、图库甚至 MediaProvider 都会出现外置 SD 卡只能读不可写，即写入失败的问题，因为这些系统应用都没有适配 DocumentProvider 的写入方式。

DocumentFile 适配方案

1. 请求写入外置 SD 卡权限

早在 Android 4.4，Android 就已经加入了存储访问框架，外置 SD 卡的访问由 DocumentsUI (com.android.documentsui) 提供支持，经过 5.0 版本的完善以及 7.0 的改进，目前有两种请求外置 SD 卡写入权限的交互方法：

Android 7.0 之前，使用 ACTION_OPEN_DOCUMENT_TREE 跳转到 DocumentsUI 的存储选择界面，之后用户手动打开外置存储并选择

Android 7.0 及之后，使用 StorageVolume.createAccessIntent(null) 跳转到权限写入提示框。(这个提示框也是 DocumentsUI 提供的，只是对之前的交互做了改进，避免繁琐的用户操作)

检查权限界面的属性，会发现这个权限提示框其实是 com.android.documentsui/com.android.documentsui.ScopedAccessActivity

也就是说 DocumentsUI 为了简化权限请求的流程，已经特意做了一个权限的提示框。

而 StorageVolume.createAccessIntent(String directoryName) 可以传入众多媒体类型，包括音乐、图片、电影、文档等，如果传入参数为 null ，则表示整个外置存储分区。

Parameters

directoryName String: must be one of Environment.DIRECTORY_MUSIC, Environment.DIRECTORY_PODCASTS, Environment.DIRECTORY_RINGTONES, Environment.DIRECTORY_ALARMS, Environment.DIRECTORY_NOTIFICATIONS, Environment.DIRECTORY_PICTURES, Environment.DIRECTORY_MOVIES, Environment.DIRECTORY_DOWNLOADS, Environment.DIRECTORY_DCIM, or Environment.DIRECTORY_DOCUMENTS, or null to request access to the entire volume.

Parameters
`directoryName`	`String`: must be one of `Environment.DIRECTORY_MUSIC`, `Environment.DIRECTORY_PODCASTS`, `Environment.DIRECTORY_RINGTONES`, `Environment.DIRECTORY_ALARMS`, `Environment.DIRECTORY_NOTIFICATIONS`, `Environment.DIRECTORY_PICTURES`, `Environment.DIRECTORY_MOVIES`, `Environment.DIRECTORY_DOWNLOADS`, `Environment.DIRECTORY_DCIM`, or `Environment.DIRECTORY_DOCUMENTS`, or `null` to request access to the entire volume.

Returns
`Intent`	intent to request access, or `null` if the requested directory is invalid for that volume.

权限请求及处理

权限请求需要在 Activity 或者 Fragment 中发起，同时在 onActivityResult 中捕获返回的 Uri，这个 Uri 可以保存在本地存储中，方便再次调用。请求的代码封装如下：

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// ...
 if (DocumentsUtils.checkWritableRootPath(getActivity(), rootPath)) {
showOpenDocumentTree();
}
// ...
}
private void showOpenDocumentTree() {
Intent intent = null;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
StorageManager sm = getActivity().getSystemService(StorageManager.class);
StorageVolume volume = sm.getStorageVolume(new File(rootPath));
if (volume != null) {
intent = volume.createAccessIntent(null);
}
}
if (intent == null) {
intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
}
startActivityForResult(intent, DocumentsUtils.OPEN_DOCUMENT_TREE_CODE);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode) {
case DocumentsUtils.OPEN_DOCUMENT_TREE_CODE:
if (data != null && data.getData() != null) {
Uri uri = data.getData();
DocumentsUtils.saveTreeUri(getActivity(), rootPath, uri);
}
break;
default:
break;
}
}

这里的 rootPath 是上下文中传入的外置 sd 卡根目录，如 /storage/0000-0000 这样的路径，可以通过 context.getExternalFilesDirs("external") 方法获取到。DocumentsUtils 工具类的实现方法见下文。

其中 DocumentsUtils.checkWritableRootPath() 方法用来检查 SD 卡根目录是否有写入权限，如果没有则跳转到权限请求；DocumentsUtils.saveTreeUri() 方法保存返回的 Uri 信息到本地存储，以便之后查询。

2. DocumentFile 文件操作封装

由于之前应用使用了 java.io.File 接口操作外置 SD 卡文件，期望对代码的修改量最小，则最好的方式是对已有的 File 操作再做一次封装。

由于 Android 9.0 之前系统应用默认是可以通过 java.io.File 接口写入外置 SD卡的，而如果作为公开市场第三方应用却在 4.4 之后就不可写，而且有的厂商定制版本 Android 9.0 外置 SD 卡也是可以直接写入而不需要 DocumentFile 接口，DocumentFile 接口也没有 java.io.File 效率高。

所以最好的办法是先检查是否有文件写入权限，如果有写入权限，则直接使用 File 接口操作，如果没有权限再检查文件是否在外置 SD 卡，如果文件在 SD 卡则使用 DocumentFile 接口操作。

封装的工具类 DocumentsUtils 方法说明，不兼容 表示没有封装 DocumentFile 操作：

DocumentsUtils 公共方法	功能描述
void cleanCache()	清除路径缓存，建议插拔 sd 卡后调用
boolean isOnExtSdCard(File file, Context c)	文件路径是否在外置 SD 卡上
DocumentFile getDocumentFile(final File file, final boolean isDirectory, Context context)	从 File 转到 DocumentFile
boolean mkdirs(Context context, File dir)	创建文件夹
boolean delete(Context context, File file)	删除文件
boolean canWrite(File file)	File 文件是否可写（如果文件不存在，则尝试创建文件再删除检查写入权限）不兼容
boolean canWrite(Context context, File file)	文件是否可写
boolean renameTo(Context context, File src, File dest)	文件重命名
boolean saveTreeUri(Context context, String rootPath, Uri uri)	保存 path 和 uri 到本地存储
boolean checkWritableRootPath(Context context, String rootPath)	检查路径是否可写，不可写返回 true
InputStream getInputStream(Context context, File destFile)	获取 InputStream，可用于读操作
OutputStream getOutputStream(Context context, File destFile)	获取 OutputStream，可用于写操作

封装的工具类 DocumentsUtils.java 内容如下：

public class DocumentsUtils {
private static final String TAG = DocumentsUtils.class.getSimpleName();
public static final int OPEN_DOCUMENT_TREE_CODE = 8000;
private static List<String> sExtSdCardPaths = new ArrayList<>();
private DocumentsUtils() {
}
public static void cleanCache() {
sExtSdCardPaths.clear();
}
/**
 * Get a list of external SD card paths. (Kitkat or higher.)
 *
 * @return A list of external SD card paths.
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
private static String[] getExtSdCardPaths(Context context) {
if (sExtSdCardPaths.size() > 0) {
return sExtSdCardPaths.toArray(new String[0]);
}
for (File file : context.getExternalFilesDirs("external")) {
if (file != null && !file.equals(context.getExternalFilesDir("external"))) {
int index = file.getAbsolutePath().lastIndexOf("/Android/data");
if (index < 0) {
Log.w(TAG, "Unexpected external file dir: " + file.getAbsolutePath());
} else {
String path = file.getAbsolutePath().substring(0, index);
try {
path = new File(path).getCanonicalPath();
} catch (IOException e) {
// Keep non-canonical path.
 }
sExtSdCardPaths.add(path);
}
}
}
if (sExtSdCardPaths.isEmpty()) sExtSdCardPaths.add("/storage/sdcard1");
return sExtSdCardPaths.toArray(new String[0]);
}
/**
 * Determine the main folder of the external SD card containing the given file.
 *
 * @param file the file.
 * @return The main folder of the external SD card containing this file, if the file is on an SD
 * card. Otherwise,
 * null is returned.
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
private static String getExtSdCardFolder(final File file, Context context) {
String[] extSdPaths = getExtSdCardPaths(context);
try {
for (int i = 0; i < extSdPaths.length; i++) {
if (file.getCanonicalPath().startsWith(extSdPaths[i])) {
return extSdPaths[i];
}
}
} catch (IOException e) {
return null;
}
return null;
}
/**
 * Determine if a file is on external sd card. (Kitkat or higher.)
 *
 * @param file The file.
 * @return true if on external sd card.
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
public static boolean isOnExtSdCard(final File file, Context c) {
return getExtSdCardFolder(file, c) != null;
}
/**
 * Get a DocumentFile corresponding to the given file (for writing on ExtSdCard on Android 5).
 * If the file is not
 * existing, it is created.
 *
 * @param file The file.
 * @param isDirectory flag indicating if the file should be a directory.
 * @return The DocumentFile
 */
public static DocumentFile getDocumentFile(final File file, final boolean isDirectory,
Context context) {
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
return DocumentFile.fromFile(file);
}
String baseFolder = getExtSdCardFolder(file, context);
boolean originalDirectory = false;
if (baseFolder == null) {
return null;
}
String relativePath = null;
try {
String fullPath = file.getCanonicalPath();
if (!baseFolder.equals(fullPath)) {
relativePath = fullPath.substring(baseFolder.length() + 1);
} else {
originalDirectory = true;
}
} catch (IOException e) {
return null;
} catch (Exception f) {
originalDirectory = true;
//continue
 }
String as = PreferenceManager.getDefaultSharedPreferences(context).getString(baseFolder,
null);
Uri treeUri = null;
if (as != null) treeUri = Uri.parse(as);
if (treeUri == null) {
return null;
}
// start with root of SD card and then parse through document tree.
 DocumentFile document = DocumentFile.fromTreeUri(context, treeUri);
if (originalDirectory) return document;
String[] parts = relativePath.split("/");
for (int i = 0; i < parts.length; i++) {
DocumentFile nextDocument = document.findFile(parts[i]);
if (nextDocument == null) {
if ((i < parts.length - 1) || isDirectory) {
nextDocument = document.createDirectory(parts[i]);
} else {
nextDocument = document.createFile("image", parts[i]);
}
}
document = nextDocument;
}
return document;
}
public static boolean mkdirs(Context context, File dir) {
boolean res = dir.mkdirs();
if (!res) {
if (DocumentsUtils.isOnExtSdCard(dir, context)) {
DocumentFile documentFile = DocumentsUtils.getDocumentFile(dir, true, context);
res = documentFile != null && documentFile.canWrite();
}
}
return res;
}
public static boolean delete(Context context, File file) {
boolean ret = file.delete();
if (!ret && DocumentsUtils.isOnExtSdCard(file, context)) {
DocumentFile f = DocumentsUtils.getDocumentFile(file, false, context);
if (f != null) {
ret = f.delete();
}
}
return ret;
}
public static boolean canWrite(File file) {
boolean res = file.exists() && file.canWrite();
if (!res && !file.exists()) {
try {
if (!file.isDirectory()) {
res = file.createNewFile() && file.delete();
} else {
res = file.mkdirs() && file.delete();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return res;
}
public static boolean canWrite(Context context, File file) {
boolean res = canWrite(file);
if (!res && DocumentsUtils.isOnExtSdCard(file, context)) {
DocumentFile documentFile = DocumentsUtils.getDocumentFile(file, true, context);
res = documentFile != null && documentFile.canWrite();
}
return res;
}
public static boolean renameTo(Context context, File src, File dest) {
boolean res = src.renameTo(dest);
if (!res && isOnExtSdCard(dest, context)) {
DocumentFile srcDoc;
if (isOnExtSdCard(src, context)) {
srcDoc = getDocumentFile(src, false, context);
} else {
srcDoc = DocumentFile.fromFile(src);
}
DocumentFile destDoc = getDocumentFile(dest.getParentFile(), true, context);
if (srcDoc != null && destDoc != null) {
try {
if (src.getParent().equals(dest.getParent())) {
res = srcDoc.renameTo(dest.getName());
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
res = DocumentsContract.moveDocument(context.getContentResolver(),
srcDoc.getUri(),
srcDoc.getParentFile().getUri(),
destDoc.getUri()) != null;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return res;
}
public static InputStream getInputStream(Context context, File destFile) {
InputStream in = null;
try {
if (!canWrite(destFile) && isOnExtSdCard(destFile, context)) {
DocumentFile file = DocumentsUtils.getDocumentFile(destFile, false, context);
if (file != null && file.canWrite()) {
in = context.getContentResolver().openInputStream(file.getUri());
}
} else {
in = new FileInputStream(destFile);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return in;
}
public static OutputStream getOutputStream(Context context, File destFile) {
OutputStream out = null;
try {
if (!canWrite(destFile) && isOnExtSdCard(destFile, context)) {
DocumentFile file = DocumentsUtils.getDocumentFile(destFile, false, context);
if (file != null && file.canWrite()) {
out = context.getContentResolver().openOutputStream(file.getUri());
}
} else {
out = new FileOutputStream(destFile);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return out;
}
public static boolean saveTreeUri(Context context, String rootPath, Uri uri) {
DocumentFile file = DocumentFile.fromTreeUri(context, uri);
if (file != null && file.canWrite()) {
SharedPreferences perf = PreferenceManager.getDefaultSharedPreferences(context);
perf.edit().putString(rootPath, uri.toString()).apply();
return true;
} else {
Log.e(TAG, "no write permission: " + rootPath);
}
return false;
}
public static boolean checkWritableRootPath(Context context, String rootPath) {
File root = new File(rootPath);
if (!root.canWrite()) {
if (DocumentsUtils.isOnExtSdCard(root, context)) {
DocumentFile documentFile = DocumentsUtils.getDocumentFile(root, true, context);
return documentFile == null || !documentFile.canWrite();
} else {
SharedPreferences perf = PreferenceManager.getDefaultSharedPreferences(context);
String documentUri = perf.getString(rootPath, "");
if (documentUri == null || documentUri.isEmpty()) {
return true;
} else {
DocumentFile file = DocumentFile.fromTreeUri(context, Uri.parse(documentUri));
return !(file != null && file.canWrite());
}
}
}
return false;
}
}

参考

Media process should run with “write” access.

[Developer Preview Android P]WRITE_MEDIA_STORAGE is not working for system apps to access the secondary storage.

AmazeFileManager/FileUtil.java

MotionLayout 实现顶部栏拉伸效果

Mon, 17 Dec 2018 21:44:56 +0800

MotionLayout 是 google 新推出的 UI 组件，是 ConstraintLayout 2.0 库的一个大更新。它继承自 ConstraintLayout 可以方便的制作复杂动画界面，通过在 xml 中设置起始状态，关键帧，结束状态，快速实现界面动效或动画效果。

本文以代码示例介绍，如何使用 MotionLayout 实现复杂的凸显型顶部栏(Prominent top app bars) 。

实现效果

1. 凸显型顶部栏上下滑动拉伸效果

https://i.xdty.org/motionlayout-1.mp4

2. 上下滑动拉伸效果及旋转和变色效果

https://i.xdty.org/motionlayout-2.mp4

代码分析

1. 凸显型顶部栏上下滑动实现

从界面布局上分析，如果只是静态布局，外部使用 ConstraitLayout，上半部分凸显型顶部栏直接使用布局填充，下半部分使用 RecyclerView 列表，每个 Item 做独立布局实现即可，这是很好实现的。

但使用常规的方法，实现这个上下滑动效果是比较复杂的。使用 MotionLayout 替换 ConstraitLayout, 再在 app:layoutDescription 属性中指定描述文件，描述文件中增加起始状态、中间帧、结束状态，就可以快速实现这个效果。

状态描述文件保存在 res/xml 目录下，包含 MotionScene 根节点，Transition 节点及若干 ConstraintSet 节点。

Transition 定义了起始状态和结束状态及关键帧。例如下面状态片段中，指定了开始状态 @id/expanded 结束状态 @id/collapsed，OnSwipe 操作的方向则是 dragUp，同时以 @id/list 顶部为锚点。KeyFrameSet 中则指定了两个关键帧，进度 60 时 @id/toolbar_image 的 alpha 修改为不透明，而进度到 90 时则修改为全透明，即滑动快到顶部时隐藏背景图片。

<Transition
app:constraintSetEnd="@id/collapsed"
app:constraintSetStart="@id/expanded"
app:interpolator="bounce">
<OnSwipe
app:dragDirection="dragUp"
app:touchAnchorId="@id/list"
app:touchAnchorSide="top" />
<KeyFrameSet>
<KeyAttribute
app:framePosition="60"
app:target="@id/toolbar_image">
<CustomAttribute
app:attributeName="imageAlpha"
app:customIntegerValue="255" />
</KeyAttribute>
<KeyAttribute
app:framePosition="90"
app:target="@id/toolbar_image">
<CustomAttribute
app:attributeName="imageAlpha"
app:customIntegerValue="0" />
</KeyAttribute>
</KeyFrameSet>
</Transition>

ConstraintSet 则和 ConstraitLayout 内容没有太大区别，只是将变动的View 名统一修改为 Constraint，移除部分不受影响或不变化的属性，将变动的属性填写即可。

例如下面的代码片段中，扩展状态 @+id/expanded 下 @+id/toolbar_image 的高度为 @dimen/notification_toolbar_height；@+id/mesh_image 的 alpha 调整为 1 。

合并状态 @+id/collapsed 下则刚好相反，@id/toolbar_image 高度变更为 71dp，@id/mesh_image 高度也变更为 71dp 且透明度调整为 0 。这样设置后，上下滑动时就能在这两个状态中切换。

<ConstraintSet android:id="@+id/expanded">
<Constraint
android:id="@+id/toolbar_image"
android:layout_height="@dimen/notification_toolbar_height"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@+id/mesh_image"
android:layout_height="@dimen/notification_toolbar_height"
android:alpha="1"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />

<ConstraintSet android:id="@+id/collapsed">
<Constraint
android:id="@id/toolbar_image"
android:layout_height="71dp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@id/mesh_image"
android:layout_height="71dp"
android:alpha="0"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />

由于目前 2.0.0alpha2 编辑器支持不太好，可以先按照 ConstraitLayout 实现布局，之后再调整 MotionScene 中的状态信息。

实现步骤：

使用 ConstraitLayout 实现凸显型顶部栏布局
将 ConstraitLayout 替换为 MotionLayout
添加 app:layoutDescription="@xml/collapsing_notification" 描述
新建 res/xml/collapsing_notification 状态描述文件
填写 Transition 内容，定义起始状态及关键帧状态
填写 ConstraintSet 布局内容，定义起始状态布局和结束状态布局

主布局代码 activity_group_notification.xml 如下：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.motion.widget.MotionLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:layoutDescription="@xml/collapsing_notification"
app:showPaths="false"
tools:context=".activity.InboxGroupActivity">
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/list"
android:layout_width="0dp"
android:layout_height="0dp"
android:background="@color/notification_content_background"
android:clipToPadding="false"
android:paddingBottom="8dp"
app:layout_constraintBottom_toTopOf="@+id/bottom_bar"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/toolbar_image" />
<ImageView
android:id="@+id/toolbar_image"
android:layout_width="0dp"
android:layout_height="@dimen/notification_toolbar_height"
android:adjustViewBounds="true"
android:background="@color/notification_top_end"
android:contentDescription="@null"
android:fitsSystemWindows="true"
android:scaleType="center"
android:src="@drawable/notification_top_background"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<ImageView
android:id="@+id/mesh_image"
android:layout_width="0dp"
android:layout_height="@dimen/notification_toolbar_height"
android:adjustViewBounds="true"
android:contentDescription="@null"
android:fitsSystemWindows="true"
android:scaleType="center"
android:src="@drawable/notification_mesh_bg"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/status"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="0"
android:textColor="?android:attr/textColorPrimaryInverse"
android:textSize="64sp"
android:textStyle="bold"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.48"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/toolbar_image" />
<TextView
android:id="@+id/status_unit"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="4dp"
android:layout_marginEnd="8dp"
android:gravity="center"
android:text="@string/notification_unit"
android:textColor="?android:attr/textColorPrimaryInverse"
app:layout_constraintBottom_toBottomOf="@+id/status"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toEndOf="@+id/status"
app:layout_constraintTop_toTopOf="@+id/status"
app:layout_constraintVertical_bias="0.32" />
<TextView
android:id="@+id/description"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:layout_marginEnd="8dp"
android:layout_marginBottom="8dp"
android:gravity="center"
android:text="@string/notification_description"
android:textColor="?android:attr/textColorPrimaryInverse"
android:textSize="15sp"
app:layout_constraintBottom_toBottomOf="@+id/toolbar_image"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/status" />
<ImageView
android:id="@+id/home_button"
android:layout_width="wrap_content"
android:layout_height="0dp"
android:layout_marginTop="25dp"
android:contentDescription="@null"
android:paddingStart="12dp"
android:paddingTop="8dp"
android:paddingEnd="8dp"
android:paddingBottom="8dp"
android:src="@drawable/home_arrow"
android:tint="?android:attr/textColorPrimaryInverse"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
tools:ignore="PrivateResource" />
<ImageView
android:id="@+id/menu_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:contentDescription="@null"
android:paddingStart="16dp"
android:paddingTop="8dp"
android:paddingEnd="16dp"
android:paddingBottom="8dp"
android:src="@drawable/ic_more_vert_white_24dp"
android:tint="?android:attr/textColorPrimaryInverse"
app:layout_constraintBottom_toBottomOf="@+id/home_button"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintTop_toTopOf="@+id/home_button"
tools:ignore="PrivateResource" />
<TextView
android:id="@+id/title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/notification_title"
android:textColor="?android:attr/textColorPrimaryInverse"
android:textSize="16sp"
app:layout_constraintBottom_toBottomOf="@+id/home_button"
app:layout_constraintStart_toEndOf="@+id/home_button"
app:layout_constraintTop_toTopOf="@+id/home_button" />
<View
android:id="@+id/bottom_bar"
android:layout_width="match_parent"
android:layout_height="64dp"
android:background="#FFFAFAFA"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent" />
<TextView
android:id="@+id/clean_text"
android:layout_width="240dp"
android:layout_height="34dp"
android:layout_marginStart="8dp"
android:layout_marginTop="8dp"
android:layout_marginEnd="8dp"
android:layout_marginBottom="-1dp"
android:background="@drawable/prompt_button_background"
android:gravity="center"
android:text="@string/notification_clean_btn"
android:textColor="#FFFFFFFF"
android:textSize="14sp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/bottom_bar" />
<View
android:id="@+id/top_bar_line"
android:layout_width="match_parent"
android:layout_height="1px"
android:background="@color/line_color"
app:layout_constraintBottom_toTopOf="@+id/bottom_bar"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent" />
</androidx.constraintlayout.motion.widget.MotionLayout>

状态描述代码 res/xml/collapsing_notification.xml 如下：

<?xml version="1.0" encoding="utf-8"?>
<MotionScene xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<Transition
app:constraintSetEnd="@id/collapsed"
app:constraintSetStart="@id/expanded"
app:interpolator="bounce">
<OnSwipe
app:dragDirection="dragUp"
app:touchAnchorId="@id/list"
app:touchAnchorSide="top" />
<KeyFrameSet>
<KeyAttribute
app:framePosition="60"
app:target="@id/toolbar_image">
<CustomAttribute
app:attributeName="imageAlpha"
app:customIntegerValue="255" />
</KeyAttribute>
<KeyAttribute
app:framePosition="90"
app:target="@id/toolbar_image">
<CustomAttribute
app:attributeName="imageAlpha"
app:customIntegerValue="0" />
</KeyAttribute>
</KeyFrameSet>
</Transition>
<ConstraintSet android:id="@+id/expanded">
<Constraint
android:id="@+id/toolbar_image"
android:layout_height="@dimen/notification_toolbar_height"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@+id/mesh_image"
android:layout_height="@dimen/notification_toolbar_height"
android:alpha="1"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@+id/status"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="1"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.48"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/toolbar_image" />
<Constraint
android:id="@+id/status_unit"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="1"
app:layout_constraintBottom_toBottomOf="@+id/status"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toEndOf="@+id/status"
app:layout_constraintTop_toTopOf="@+id/status"
app:layout_constraintVertical_bias="0.32" />
<Constraint
android:id="@+id/description"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="1"
app:layout_constraintBottom_toBottomOf="@+id/toolbar_image"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/status" />
</ConstraintSet>
<ConstraintSet android:id="@+id/collapsed">
<Constraint
android:id="@id/toolbar_image"
android:layout_height="71dp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@id/mesh_image"
android:layout_height="71dp"
android:alpha="0"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<Constraint
android:id="@id/status"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="0"
app:layout_constraintBottom_toTopOf="@+id/list"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.48"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="@+id/toolbar_image" />
<Constraint
android:id="@id/status_unit"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="0"
app:layout_constraintBottom_toBottomOf="@+id/status"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.0"
app:layout_constraintStart_toEndOf="@+id/status"
app:layout_constraintTop_toTopOf="@+id/status"
app:layout_constraintVertical_bias="0.32" />
<Constraint
android:id="@id/description"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:alpha="0"
app:layout_constraintBottom_toBottomOf="@+id/toolbar_image"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/status" />
</ConstraintSet>
</MotionScene>

2. 上下滑动效果及旋转变色效果融合

要实现视频二里的效果也很简单，可以拆分为三部分：

上下滑动实现效果
背景色渐变切换动画
背景圆圈图片旋转动画及数字切换

上下滑动实现效果，背景圆圈设定 90 度旋转

这部分内容和上一小节基本一致，只需加入背景圆圈设定 90 度旋转即可：

<Constraint
android:id="@+id/cleaner_circle"
android:layout_width="200dp"
android:layout_height="200dp"
android:layout_marginTop="4dp"
android:layout_marginBottom="54dp"
android:alpha="1"
android:contentDescription="@null"
android:rotation="90"
android:src="@drawable/cleaner_circle_bg"
app:layout_constraintBottom_toBottomOf="@+id/light_image"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="@+id/toolbar_image"
app:layout_constraintTop_toTopOf="@+id/home_button" />

背景颜色渐变动画

背景过渡动画由四个 gradient 背景色组成，通过 AnimationDrawable 添加需要的过渡背景帧然后播放动画：

@SuppressWarnings("ConstantConditions")
private void animateToolbarDrawable(int percent) {
final AnimationDrawable animationDrawable = new AnimationDrawable();
List<Integer> rgbColors = new ArrayList<>();
int level = range(percent);
int duration = ANIMATION_DURATION / level;
if (level >= 0) {
animationDrawable.addFrame(getDrawable(R.drawable.status_color_low), duration);
rgbColors.add(ContextCompat.getColor(this, R.color.status_low_end));
}
if (level >= 2) {
animationDrawable.addFrame(getDrawable(R.drawable.status_color_medium), duration);
rgbColors.add(ContextCompat.getColor(this, R.color.status_medium_end));
}
if (level >= 3) {
animationDrawable.addFrame(getDrawable(R.drawable.status_color_high), duration);
rgbColors.add(ContextCompat.getColor(this, R.color.status_high_end));
}
if (level >= 4) {
animationDrawable.addFrame(getDrawable(R.drawable.status_color_critical), duration);
rgbColors.add(ContextCompat.getColor(this, R.color.status_critical_end));
}
mToolbarImage.setImageDrawable(animationDrawable);
animationDrawable.setOneShot(true);
animationDrawable.setEnterFadeDuration(duration - 200);
animationDrawable.setExitFadeDuration(duration - 300);
animationDrawable.start();
final ValueAnimator valueAnimator = ValueAnimator.ofArgb(toIntArray(rgbColors));
valueAnimator.setInterpolator(new LinearInterpolator());
valueAnimator.setDuration(ANIMATION_DURATION);
valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
mToolbarImage.setBackgroundColor((Integer) valueAnimator.getAnimatedValue());
}
});
valueAnimator.start();
}
int[] toIntArray(List<Integer> list) {
int[] ret = new int[list.size()];
int i = 0;
for (Integer e : list) {
ret[i++] = e;
}
return ret;
}
public static int range(int percent) {
if (percent < 40) {
return 1;
} else if (percent < 65) {
return 2;
} else if (percent < 85) {
return 3;
} else if (percent <= 100) {
return 4;
} else {
return 0;
}
}

gradient 背景色 status_color_low.xml 示例：

<?xml version="1.0" encoding="UTF-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item>
<shape>
<gradient android:angle="90" android:centerColor="@color/status_low_center" android:endColor="@color/status_low_end" android:startColor="@color/status_low_start" />
</shape>
</item>
</selector>

背景圆圈图片旋转动画及数字切换

背景图片旋转图片使用 RotateAnimation 实现，并设置加速减速产生器，其中的结束角度计算 (360 * Math.ceil(12 / 3.0) 则是按照动画时长 ANIMATION_DURATION 估算的一个值。

private void animateCleanerCircle() {
RotateAnimation animation = new RotateAnimation(0,
(float) (360 * Math.ceil(12 / 3.0)),
Animation.RELATIVE_TO_SELF, 0.5f,
Animation.RELATIVE_TO_SELF, 0.5f);
animation.setDuration((long) (ANIMATION_DURATION));
animation.setRepeatCount(0);
animation.setInterpolator(new AccelerateDecelerateInterpolator());
mCleanerCircle.clearAnimation();
mCleanerCircle.startAnimation(animation);
}

数字切换动画也是类似：

private void animateMemoryText(float usedMemory) {
ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, usedMemory);
valueAnimator.setDuration((long) (ANIMATION_DURATION));
valueAnimator.setInterpolator(new AccelerateDecelerateInterpolator());
valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
float value = (float) valueAnimator.getAnimatedValue();
mMemoryText.setText(String.format(Locale.US, "%.2f", value));
}
});
valueAnimator.start();
}

参考资料

Introduction to MotionLayout (part I)

Android-ConstraintLayoutExamples

域名转移到 CloudFlare Registrar 和掉年问题

Sat, 08 Dec 2018 19:37:40 +0800

CloudFlare 是一家优秀的 CDN 服务提供商，同时提供 DNS 解析服务。最近又推出了域名注册服务 CloudFlare Registrar，因为只收取注册局的费用而没有中介费，可以说是最便宜的域名注册服务商了。同时以 CloudFlare 的强大实力和服务质量，相信可以非常放心的将域名托管在这里。

域名转移

我之前申请了优先体验，前几天收到了转移邀请邮件，所以就快速转移了三个域名做尝试体验。目前 CloudFlare 还不支持 ccTLD 即国家类域名，如 .in .io .im 这一类域名，需要再等一段时间才能支持，常见的 .com .net .org 和 .xyz .love 这种新域名自然是支持的，共有上百种域名。

从 NameSilo 转移到 CloudFlare 的过程很顺利，没有遇到什么问题，虽然有一些小 Bug，但是可以忽视。

域名转移过期时间掉年问题

但是在域名概览里查看注册信息时却发现了过期日期少了一年的问题。在2018/11/01 我收到了 NameSilo 的域名即将过期提醒邮件，然后我就立刻续费了，所以下次过期时间已经被更新为 2019/11/29，而在转移域名后应该会增加一年，但是转移后有两个域名过期日期没有变，以为是新服务测试阶段有 bug，就提了工单，同时也在社区里咨询。

社区有个网友反馈也遇到了类似的问题，他等待了两天 whois 信息就正常了。在跟客服沟通时，客服说是域名过期后 45 天内续费再转移导致的注册局退款，即就是域名转移掉年问题，需要找 NameSilo 退款。但是我的域名并没有过期，是过期前一个月就已经续费了的。

在工单交流的过程中，CloudFlare 客服甚至提出了他们可以给予退款来补偿我的损失，这一点让我很感动，不得不为 CloudFlare 的服务点赞。在搜索后发现续费后 60 天内转移容易出现掉年问题，同时我也在 NameSilo 网站中搜索到了相关的信息 Transfer-of-Recently-Renewed-Domains ，所以又发邮件给 NameSilo 询问相关情况。

NameSilo 没有工单系统，而且邮件回复很慢，等待过程中甚至认为它的服务太差想要将剩余的几个域名尽快转出的想法。在他们回复邮件问我 “What would you like from us?” 时，我回复了更详细的问题描述，同时张贴了与 Cloudflare 的工单交流记录（网页打印为PDF作为附件）。

收到退款

之后差不多两天后终于收到了 NameSilo 的回复，他们确认了这个问题正是我在他们网站中找到的转移近期续费域名出现的问题，他们需要时间联系注册局检查退款信息，同时也已经对我的这两个域名发起了退款。NameSilo 也不忘提醒我这不是 CloudFlare 的错误，不应该由后者承担退款。当然我也从没想过去向 CloudFlare 索要退款，即使真的找不到问题原因，我也愿意自己承担损失。

我对这个回复表达了感谢，也对他们长期以来的优质服务表达感谢，同时我也在 CloudFlare 工单中张贴了 NameSilo 的回复和截图，并对他们的热心服务表达了感谢。虽然续费的金额不多，期间我甚至想要放弃这笔退款，没想到 NameSilo 处理的很干脆，对他们的服务信心也大增。至此，掉年的问题圆满解决了。

自建稍后阅读服务之 Wallabag

Tue, 13 Nov 2018 16:49:20 +0800

Wallabag 是一款优秀的开源免费稍后阅读工具，可以将网络上的文章保存并分类，再稍后阅读。类似于 Pocket 和 Instapaper 等商业服务，是它们的可靠替代品。

什么是 wallabag？

Wallabag 是一款可自行托管的 PHP 应用程序，让你不再错过任何内容。点击，保存然后在你有时间时阅读。它可以提取网页内容，以便你有空时阅读。

更多信息请访问官网 https://wallabag.org/

如果你没有自己的服务器，请考虑使用 wallabag.it 托管解决方案。

也可以使用我搭建的服务 https://wb.xdty.org/ ，我已经将它作为稍后阅读的生产力工具使用。

安装 wallabag

请阅读文档以查看 wallabag 安装依赖。

然后，可以通过执行以下命令来安装 wallabag：

git clone https://github.com/wallabag/wallabag.git
cd wallabag && make install

现在，配置虚拟主机以使用 wallabag 。

特性

开源 PHP 程序，易托管
界面美观，易于阅读
浏览器插件 - 一键保存网页到服务
开放的 API - 可以根据 API 自由编写客户端
迁移 - 从 Pocket, Readability, Instapaper 或 Pinboard 服务导入数据
导出 - 可以导出文章到 epub, mobi, pdf 等格式
随处可用 - 由于是 Web 服务，可以在使用浏览器的系统上使用，同时支持 Android 客户端
RSS 阅读器兼容

问题

实际使用中遇到部分网页内容不能保存的问题，~~期待后续版本能支持知乎等网站的抓取~~。

更新-20181212: 不能抓取知乎是因为 user-agent 导致的，已在上游提交 PR : fivefilters/ftr-site-config/pull/578。

修改 vendor/j0k3r/graby-site-config/zhihu.com.txt ，增加如下内容：
http_header(user-agent): Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36
然后再重新编译更新下即可：
make update

许可证

MIT

开源项目地址

https://github.com/wallabag/wallabag

Java 语言 Glob 语法规则

Tue, 23 Oct 2018 20:01:33 +0800

最近在做 Android 下应用专清的功能，需要检索微信、微博这类应用的垃圾文件，尝试了 apache 的 common-io 以及 java 的 nio ，最后使用 nio 的 Files.walkFileTree 遍历目录，并使用 PathMatcher 和 glob 规则做文件匹配，本文是对 glob 语法的总结。

什么是 Glob

Glob 是一种模式匹配，类似于正则表达式但是语法相对简单。Glob 语句是一个含有 *,?{}[] 这些特殊字符的字符串，并与目标字符串匹配。可以用来做文件路径匹配或文件查找。例如 Linux 下的命令 ls *.txt ，其中的 *.txt 就是一个 glob 语句。

语法规则

Java 语言中的 Glob 语法遵循几个简单的规则：

一个星号 *

匹配任意个数的字符，包括空。不包括路径边界 / 或 \。例如 /path/*/abc 可以匹配 /path/a/abc 和 /path/b/abc 等。

两个星号 **

和一个星号类似，区别是可以跨路径边界，一般用来匹配多级目录。例如 /path/**/abc 可以用来匹配 /path/a/abc 、/path/b/abc 、/path/a/b/abc、/path/a/b/c/abc 等。

一个问号 ?

匹配任意一个字符

大括号 {}

大括号用来指定一个子模式匹配集合，例如：{sun,moon,stars} 可以匹配 sun moon starts ， {temp*, tmp*} 可以匹配任何以 temp tmp 开头的字符串等。

方括号[]

方括号表示匹配括号内的任意一个单个字符，当有 - 时表示匹配任意一个连续范围内的单个字符。例如：[aeiou] 匹配任意一个小写元音字符，[0-9] 匹配任意一个数字，[A-Z] 匹配任意一个大写字母，[a-z,A-Z] 匹配任意一个大写或小写字母。另外，在方括号内， * ? \ 字符仅匹配它们自身。

任意其它字符

任意的其他字符表示匹配它们自身。

反斜杠\转义

匹配 * ? 或其他特殊字符需要使用反斜杠\转义。例如： \\ 匹配一个反斜杠，\? 匹配一个问号。

举例

Glob	说明
`*.html`	匹配所有 `.html` 结尾的字符串
`???`	匹配所有由三个数字或字母构成字符串，如 `aaa` `abc` `ab1` `123`
`[0-9]`	匹配所有含有一个数字的字符串
`*.{htm,html,pdf}`	匹配所有以 `.htm` `.html 或` `.pdf` 结尾的字符串
`a?*.java`	匹配所有以 `a` 开头，且`a` 之后至少由一个字母或数字，且以 `.java` 结尾的字符传
`{foo,[0-9]*}`	匹配所有以 `foo` 开头，或含有数字的字符串，如 `foobar` `x1y` `foo1xyz`

代码实例

JDK 中 glob 相关的内容主要集中在 java.nio.file 包内，其中 glob 语法转正则表达式的实现在 sun.nio.fs.Globs.java 中。下面代码是一个检索 /sdcard/tencent 目录下所有 png 文件的例子：

String match = "glob:/sdcard/tencent/**/*.png";
System.out.println("scanning: " + match);
final PathMatcher pathMatcher = FileSystems.getDefault().getPathMatcher(match);
SimpleFileVisitor<Path> fileVisitor = new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
throws IOException {
if (pathMatcher.matches(file)) {
System.out.println("find: " + file.toFile().toString())
}
return super.visitFile(file, attrs);
}
};
try {
Files.walkFileTree(Paths.get(dir.getPath()), fileVisitor);
} catch (IOException e) {
e.printStackTrace();
}

Glob 语句转正则表达式的实现

http://hg.openjdk.java.net/jdk7/jdk7/jdk/file/tip/src/share/classes/sun/nio/fs/Globs.java

package sun.nio.fs;
import java.util.regex.PatternSyntaxException;
public class Globs {
private Globs() { }
private static final String regexMetaChars = ".^$+{[]|()";
private static final String globMetaChars = "\\*?[{";
private static boolean isRegexMeta(char c) {
return regexMetaChars.indexOf(c) != -1;
}
private static boolean isGlobMeta(char c) {
return globMetaChars.indexOf(c) != -1;
}
private static char EOL = 0; //TBD

private static char next(String glob, int i) {
if (i < glob.length()) {
return glob.charAt(i);
}
return EOL;
}
/**
 * Creates a regex pattern from the given glob expression.
 *
 * @throws PatternSyntaxException
 */
private static String toRegexPattern(String globPattern, boolean isDos) {
boolean inGroup = false;
StringBuilder regex = new StringBuilder("^");
int i = 0;
while (i < globPattern.length()) {
char c = globPattern.charAt(i++);
switch (c) {
case '\\':
// escape special characters
 if (i == globPattern.length()) {
throw new PatternSyntaxException("No character to escape",
globPattern, i - 1);
}
char next = globPattern.charAt(i++);
if (isGlobMeta(next) || isRegexMeta(next)) {
regex.append('\\');
}
regex.append(next);
break;
case '/':
if (isDos) {
regex.append("\\\\");
} else {
regex.append(c);
}
break;
case '[':
// don't match name separator in class
 if (isDos) {
regex.append("[[^\\\\]&&[");
} else {
regex.append("[[^/]&&[");
}
if (next(globPattern, i) == '^') {
// escape the regex negation char if it appears
 regex.append("\\^");
i++;
} else {
// negation
 if (next(globPattern, i) == '!') {
regex.append('^');
i++;
}
// hyphen allowed at start
 if (next(globPattern, i) == '-') {
regex.append('-');
i++;
}
}
boolean hasRangeStart = false;
char last = 0;
while (i < globPattern.length()) {
c = globPattern.charAt(i++);
if (c == ']') {
break;
}
if (c == '/' || (isDos && c == '\\')) {
throw new PatternSyntaxException("Explicit 'name separator' in class",
globPattern, i - 1);
}
// TBD: how to specify ']' in a class?
 if (c == '\\' || c == '[' ||
c == '&' && next(globPattern, i) == '&') {
// escape '\', '[' or "&&" for regex class
 regex.append('\\');
}
regex.append(c);
if (c == '-') {
if (!hasRangeStart) {
throw new PatternSyntaxException("Invalid range",
globPattern, i - 1);
}
if ((c = next(globPattern, i++)) == EOL || c == ']') {
break;
}
if (c < last) {
throw new PatternSyntaxException("Invalid range",
globPattern, i - 3);
}
regex.append(c);
hasRangeStart = false;
} else {
hasRangeStart = true;
last = c;
}
}
if (c != ']') {
throw new PatternSyntaxException("Missing ']", globPattern, i - 1);
}
regex.append("]]");
break;
case '{':
if (inGroup) {
throw new PatternSyntaxException("Cannot nest groups",
globPattern, i - 1);
}
regex.append("(?:(?:");
inGroup = true;
break;
case '}':
if (inGroup) {
regex.append("))");
inGroup = false;
} else {
regex.append('}');
}
break;
case ',':
if (inGroup) {
regex.append(")|(?:");
} else {
regex.append(',');
}
break;
case '*':
if (next(globPattern, i) == '*') {
// crosses directory boundaries
 regex.append(".*");
i++;
} else {
// within directory boundary
 if (isDos) {
regex.append("[^\\\\]*");
} else {
regex.append("[^/]*");
}
}
break;
case '?':
if (isDos) {
regex.append("[^\\\\]");
} else {
regex.append("[^/]");
}
break;

 default:
if (isRegexMeta(c)) {
regex.append('\\');
}
regex.append(c);
}
}
if (inGroup) {
throw new PatternSyntaxException("Missing '}", globPattern, i - 1);
}
return regex.append('$').toString();
}
static String toUnixRegexPattern(String globPattern) {
return toRegexPattern(globPattern, false);
}
static String toWindowsRegexPattern(String globPattern) {
return toRegexPattern(globPattern, true);
}
}

参考

密码管理工具之 keeweb

Thu, 18 Oct 2018 20:16:05 +0800

keeweb 是一款优秀的免费开源密码管理软件，兼容 KeePass 数据库，跨平台，也可以托管在任何静态网页服务上作为 web 应用使用。数据库文件可以方便的同步到 Dropbox 和 Google drive 。与知名商业类应用 LastPass 和 1Password 相比，有开源、免费、开放、界面简洁美观等优点。

因为所有密码和代码由用户控制和存储，所以也不存在因服务商漏洞导致密码数据库泄漏的风险。博主也早已将所有密码托管到自建的 keeweb 服务上 ( https://www.xdty.org/kee/ )，可以在电脑桌面、手机等同步无缝切换，非常方便。

特性

跨平台 - Windows, Linux, Mac
离线网页应用 - https://app.keeweb.info/
主题 - 暗色亮色主题
颜色收藏 - 使用颜色标记项目来快速找到它们
多文件支持 - 打开多个文件，在一个列表中搜索任何条目或查看所有文件中的所有项目
拖放操作 - 打开密码文件或存储附件
内嵌图片查看器 - 可以方便的存储银行卡照片
Dropbox 同步
轻松标签输入
受保护的字段
密码生成器
离线访问
快捷键
高级搜索
历史记录
手机浏览器支持
条目图标
表视图
开源免费

自托管

这个应用是纯 HTML 应用，不需要任何后端服务，只需要下载 gh-pages 分支并托管在任何静态文件服务上即可。

要在自托管的服务上开启 Dropbox 支持，请阅读 WIKI 文档。

许可证

MIT

开源项目地址

https://github.com/keeweb/keeweb

Cleaner 应用工程及架构设计

Tue, 09 Oct 2018 22:01:58 +0800

Cleaner 是一个新开发的工具类应用，主要集成了内存、通知、应用、大文件、冗余文件、相册清理等功能。同时提供对外的数据提供者接口和 Deeplink 入口。

功能模块

根据功能最终将工程设计为四个模块开发，功能模块之间互相独立且没有耦合。这四个模块独立生成 aar 库文件被主应用引用，主应用只提供入口而不提供任何清理功能。

工程结构如下图

工程主要分为四个子模块：storage notification provider 和 utils。

模块	功能
storage	实现文件类清理、内存清理
notification	实现通知清理、通知白名单及设置
provider	数据依赖 storage 和 notification，实现 `deeplink` 和对外数据接口
utils	基础公共方法和基础常量
app	launcher 应用入口，不提供任何功能
example	provider 数据客户端示例

代码架构

功能模块采用 MVP 架构。用户交互接口如 Activity Service 作为 View 层抽象，逻辑及数据操作全部放在 Presenter 中处理，数据操作封装在 Model 层的 DataSource 中。每一类的数据源都是一个独立不相关的 DataSource，如数据库，应用列表，存储文件都放在不同的 DataSource 中。

下文以通知清理模块为例介绍代码架构。

通知清理 MVP 架构

通知清理工程目录

MVP 接口

通知主界面 InboxGroupActivity 的 MVP 接口如下

public interface NotificationContract {
interface View {
void loadData(List<Notification> notifications);
void notifyWhitelistChanged();
void notifyDataExported();
void notifyDataImported();
void notifyCleaned(int size);
}
interface Presenter {
void takeView(View view);
void loadHistoryNotifications();
void start();
void cleanAll();
void filter(String packageName);
void exportHistory();
void importHistory();
}
}

通知监听服务 NotificationListenerService 的 MVP 接口如下

public interface ListenerContract {
interface View {
void recheckActiveNotifications();
void dispatchIntent(Notification notification);
void removeNotification(String key);
void showMissedNotification(List<Notification> notifications);
}
interface Presenter {
void start();
void takeView(View view);
void addNotification(Notification notification);
void calculateMissedNotifications();
void performNotificationAction(String key);
}
}

Presenter 数据依赖注入

DataSource 作为数据源依赖，需要在实例化时注入到 Presenter 中，工程中没有使用 Dagger，所以需要在new Presenter 时手动注入依赖。注入依赖的代码片段如下：

// InboxGroupActivity Presenter 的数据依赖注入
EntityDataStore<Persistable> dataStore = DataRepository.get().provideDatabaseSource(
getApplicationContext());
DataRepository.get().init(dataStore);
AppStore.get().init(this);
AppDataSource appDataSource = new AppDataRepository(AppStore.get(), getPackageManager(),
dataStore);
mPresenter = new NotificationPresenter(DataRepository.get(), appDataSource,
AppStore.get());
mPresenter.takeView(this);

// NotificationListenerService Presenter 的数据依赖注入
EntityDataStore<Persistable> dataStore = DataRepository.get().provideDatabaseSource(
getApplicationContext());
DataRepository.get().init(dataStore);
Setting setting = new SettingImpl(DataRepository.get());
AppStore.get().init(this);
AppStore appStore = AppStore.get();
mPresenter = new ListenerPresenter(DataRepository.get(), setting, appStore);

// SettingsActivity Presenter 的数据依赖注入
AppStore.get().init(this)
mAppStore = AppStore.get()
val dataStore = DataRepository.get().provideDatabaseSource(this);
DataRepository.get().init(dataStore)
val mAppDataSource = AppDataRepository(mAppStore, packageManager, dataStore)
val setting = SettingImpl(DataRepository.get())
mPresenter = SettingsPresenter(mAppDataSource, setting)
mPresenter.takeView(this)

单元测试

通知清理模块包含完整的单元测试，同时也集成了 UI 测试。和白名单设置界面一样，为了熟练 kotlin语言并节省代码，测试使用了 kotlin 编写。

通知监听服务的单元测试代码

class ListenerPresenterTest {
lateinit var mListenerPresenter: ListenerPresenter
val mDataSource = mock<DataSource>()
val mSetting = mock<Setting>()
val mAppStore = mock<AppStore>()
val mView = mock<ListenerContract.View>()
@Before
fun setup() {
doReturn(Single.just(true)).`when`(mSetting).isFilterEnabled
doReturn(Single.just(true)).`when`(mDataSource)
.isNotificationWhitelist("com.example.test")
doReturn(Single.just(true)).`when`(mDataSource)
.saveNotification(any())
doReturn(Single.just(ArrayList<Notification>())).`when`(mDataSource)
.notifications
doReturn(Completable.complete()).`when`(mAppStore)
.cache(any<List<Notification>>())
mListenerPresenter = ListenerPresenter(mDataSource, mSetting, mAppStore)
mListenerPresenter.takeView(mView)
}
@Test
fun start() {
mListenerPresenter.start()
verify(mSetting).isFilterEnabled
verify(mView).recheckActiveNotifications()
}
@Test
fun addNotification() {
val notification = Notification()
notification.packageName = "com.example.test"
mListenerPresenter.addNotification(notification)
verify(mDataSource).saveNotification(eq(notification))
}
@Test
fun calculateMissedNotifications() {
mListenerPresenter.calculateMissedNotifications()
verify(mDataSource).notifications
verify(mView).showMissedNotification(any())
}
@Test
fun performNotificationAction() {
val notification = Notification()
doReturn(Single.just(notification)).`when`(mDataSource)
.getNotification("com.example.test")
mListenerPresenter.performNotificationAction("com.example.test")
verify(mView).dispatchIntent(eq(notification))
}
}

DeepLink 入口

为了便于第三方应用拉起，将主要界面都做了 DeepLink 支持，实现放在 provider 模块。所有的界面注册都统一放在 Router 中，同时支持带来源和任意参数拉起。

例如可以使用 com.qiku.android.cleaner:///storage?refer=com.example.app&customData=3 拉起主界面。

可以通过手机浏览器打开 https://cleaner01.netlify.com 测试各个 DeepLink 拉起。

<activity
android:name=".ui.DeepLinkActivity"
android:exported="true"
android:noHistory="true"
android:theme="@android:style/Theme.NoDisplay">
<intent-filter>
<data android:scheme="com.qiku.android.cleaner" />
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
</intent-filter>
</activity>

public class DeepLinkActivity extends Activity {
private static final String TAG = DeepLinkActivity.class.getSimpleName();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_deep_link);
Intent intent = getIntent();
if (intent != null && intent.getData() != null) {
Router router = Router.get();
router.open(this, intent.getData());
}
finish();
}
}

public final class Router {
private static final String TAG = Router.class.getSimpleName();
private static final String SCHEME = Constants.DEEP_LINK_SCHEME;
private static final String HOST = Constants.DEEP_LINK_HOST;
private static final Map<String, Class> PATHS = new HashMap<>();
private Router() {
register("/storage", CleanerActivity.class);
register("/storage/app", AppClearActivity.class);
register("/storage/apk", ApkClearActivity.class);
register("/storage/file", LargeFilesActivity.class);
register("/storage/redundancy", RedundancyActivity.class);
register("/storage/photo", PhotoSimilarEntryActivity.class);
register("/storage/memory", CleanerMemoryActivity.class);
register("/storage/finish", ClearFinishActivity.class);
register("/notification", InboxGroupActivity.class);
register("/notification/history", InboxActivity.class);
register("/notification/prompt", PromptActivity.class);
register("/notification/whitelist", SettingsActivity.class);
}
private void register(String path, Class activity) {
PATHS.put(path, activity);
}
public void open(Context context, Uri uri) {
Log.d(TAG, "open: " + uri);
String scheme = uri.getScheme();
String host = uri.getHost();
String path = uri.getPath();
if (scheme == null || host == null || path == null ||
!scheme.equals(SCHEME) || !host.equals(HOST) || !PATHS.containsKey(path)) {
Log.e(TAG, "illegal uri");
return;
}
Intent intent = new Intent(context, PATHS.get(path));
for (String name : uri.getQueryParameterNames()) {
intent.putExtra(name, uri.getQueryParameter(name));
}
context.startActivity(intent);
Log.d(TAG, "start activity: " + intent.toString());
if (intent.getExtras() != null) {
Log.d(TAG, "extras: " + intent.getExtras());
}
}
public static Router get() {
return SingletonHelper.sINSTANCE;
}
private static final class SingletonHelper {
private static final Router sINSTANCE = new Router();
}
}

CleanerProvider 数据提供者

为了第三方应用快速查询清理状态如存储空间，内存占用等信息，cleaner 应用对当前的数据状态做了封装，作为 provider 提供数据。

CleanEvent 数据结构

private static final class CleanEvent {
static final String URL = "content://com.qiku.android.cleaner/events";
static final Uri CONTENT_URI = Uri.parse(URL);
int id;
@EventType
int type; // 功能模块类型
 String data; // 提示语数字大小
 float weight;
String name; // 功能模块类型描述
 String text; // 按钮文字
 String prompt; // 提示语
 String appName; // 类型为 应用 时的应用名
 String link; // 调用页面

String promptText; // 提示语
 String value; // 数值
 String unit; // 单位
 int version; // 版本

String extra;
int fileCount = 0; // 文件个数

long totalLength = 0; // 所有文件大小

@Retention(RetentionPolicy.SOURCE)
@IntDef({STORAGE, MEMORY, LARGE_FILE, APPLICATION, APK, REDUNDANCY, PHOTO, NOTIFICATION})
public @interface EventType {
}
public static final int ERROR = -1;
public static final int STORAGE = 0;
public static final int MEMORY = 1;
public static final int LARGE_FILE = 2;
public static final int APPLICATION = 3;
public static final int APK = 4;
public static final int REDUNDANCY = 5;
public static final int PHOTO = 6;
public static final int NOTIFICATION = 7;
@Override
public String toString() {
return "CleanEvent{" +
"id=" + id +
", type=" + type +
", data='" + data + '\'' +
", weight=" + weight +
", name='" + name + '\'' +
", text='" + text + '\'' +
", prompt='" + prompt + '\'' +
", appName='" + appName + '\'' +
", link='" + link + '\'' +
", promptText='" + promptText + '\'' +
", value='" + value + '\'' +
", unit='" + unit + '\'' +
", version=" + version +
", extra='" + extra + '\'' +
", fileCount=" + fileCount +
", totalLength=" + totalLength +
'}';
}
}

客户端查询数据代码示例

private List<CleanEvent> getCleanEvents(Context context) {
List<CleanEvent> cleanEventList = new ArrayList<>();
Cursor cursor = context.getContentResolver().query(CleanEvent.CONTENT_URI, null, null, null,
null);
if (cursor != null) {
if (!cursor.moveToFirst()) {
Log.e(TAG, "no data");
} else {
do {
CleanEvent event = new CleanEvent();
event.type = cursor.getInt(cursor.getColumnIndex("type"));
event.data = cursor.getString(cursor.getColumnIndex("data"));
event.weight = cursor.getFloat(cursor.getColumnIndex("weight"));
event.name = cursor.getString(cursor.getColumnIndex("name"));
event.text = cursor.getString(cursor.getColumnIndex("text"));
event.prompt = cursor.getString(cursor.getColumnIndex("prompt"));
event.appName = cursor.getString(cursor.getColumnIndex("appName"));
event.link = cursor.getString(cursor.getColumnIndex("link"));
event.promptText = cursor.getString(cursor.getColumnIndex("promptText"));
event.value = cursor.getString(cursor.getColumnIndex("value"));
event.unit = cursor.getString(cursor.getColumnIndex("unit"));
event.version = cursor.getInt(cursor.getColumnIndex("version"));
cleanEventList.add(event);
} while (cursor.moveToNext());
}
cursor.close();
}
return cleanEventList;
}

生产力工具之 StackEdit

Tue, 09 Oct 2018 13:29:22 +0800

StackEdit 是一款优秀的在线 Markdown 文本编辑工具，可以方便的创建和管理文档，记录日记等。

StackEdit 开源免费，支持同步文档到 Google drive Gitlab Github Dropbox，支持实时预览，支持目录结构。

StackEdit 可以

在线或离线管理多个 Markdown 文件
以 Markdown，HTML，PDF，Word，EPUB 导出文件…
在云中同步 Markdown 文件
从 Google云端硬盘，Dropbox 和本地硬盘驱动器编辑现有的 Markdown 文件
在 Blogger / Blogspot，WordPress，Zendesk上发布您的 Markdown 文件
在 GitHub，Gist，Google Drive，Dropbox 上发布您的 Markdown 文件
通过 Google Drive，CouchDB 共享工作区

功能

使用滚动同步功能进行实时 HTML 预览以绑定编辑器和预览滚动条
Markdown Extra / GitHub Flavored Markdown 支持和 Prism.js 语法高亮显示
使用 KaTeX 的 LaTeX 数学表达式
使用 Mermaid 的图表和流程图
所见即所得控制按钮
智能布局
离线编辑
使用 Google Drive，Dropbox 和 GitHub 进行在线同步
只需点击一下即可发布到 Blogger，Dropbox，Gist，GitHub，Google Drive，WordPress，Zendesk

开源项目地址

https://github.com/benweet/stackedit

如何使用 Dagger 编写测试

Fri, 05 Oct 2018 14:44:12 +0800

使用像 Dagger 这样的依赖注入框架的一个好处是可以让你更容易编写测试代码。本文档探讨了测试使用 Dagger 构建的应用程序的一些策略。

替换功能/集成/端到端测试的绑定

功能、集成、端到端测试通常使用生产应用程序，但是使用伪造的对象(不要在大型功能测试中使用模拟！) 来替代持久化、后端或认证系统，让应用程序的其余部分正常运行。

方法1：通过子类化模块(modules) 替换绑定 (不要这样做！)

替换测试组件中的绑定的最简单方法是覆盖子类中的模块的 @Provides 方法。（但请看下面的问题。）

创建 Dagger 组件的实例时，会传入它使用的模块的实例。（你不必为没有arg构造函数的模块或没有实例方法的模块传递实例，但你可以。）这意味着你可以传递这些模块的子类的实例，并且这些子类可以覆盖某些 @Provides 方法来替换某些绑定。

@Component(modules = {AuthModule.class, /* … */})
interface MyApplicationComponent { /* … */ }
@Module
class AuthModule {
@Provides AuthManager authManager(AuthManagerImpl impl) {
return impl;
}
}
class FakeAuthModule extends AuthModule {
@Override
AuthManager authManager(AuthManagerImpl impl) {
return new FakeAuthManager();
}
}
MyApplicationComponent testingComponent = DaggerMyApplicationComponent.builder()
.authModule(new FakeAuthModule())
.build();

但这种方法存在局限性：

使用模块子类不能更改绑定图的静态形状：它不能添加或删除绑定，也不能更改绑定的依赖关系。特别的：
- 覆盖 @Provides 方法不能更改其参数类型，并且缩小返回类型对绑定图没有影响，因为 Dagger 理解它。在上面的示例中，testingComponent 仍然需要绑定 AuthManagerImpl 及其所有依赖项，即使它们未被使用。
- 同样，覆盖模块无法向图形添加绑定，包括新的 multibinding（虽然你仍可以覆盖一个 SET_VALUES 方法来返回一个不同的集合）。Dagger 会默默忽略子类中的任何新 @Provides 方法。实际上，这意味着你的伪造对象无法利用依赖注入。
@Provides 以这种方式可覆盖的方法不能是静态的，因此不能省略它们的模块实例。

方法2：单独的组件配置

另一种方法需要在应用程序中更多地预先设计模块，应用程序的每个配置（生产和测试）都使用不同的组件配置。测试组件类型继承了生产组件类型并安装了一组不同的模块。

@Component(modules = {
OAuthModule.class, // real auth
 FooServiceModule.class, // real backend
 OtherApplicationModule.class,
/* … */ })
interface ProductionComponent {
Server server();
}
@Component(modules = {
FakeAuthModule.class, // fake auth
 FakeFooServiceModule.class, // fake backend
 OtherApplicationModule.class,
/* … */})
interface TestComponent extends ProductionComponent {
FakeAuthManager fakeAuthManager();
FakeFooService fakeFooService();
}

现在，测试的主要方法是调用DaggerTestComponent.builder() 而不是DaggerProductionComponent.builder()。请注意，测试组件接口可以向伪实例（fakeAuthManager()和fakeFooService()）添加额外方法，以便测试代码可以在必要时访问它们来实现控制。

但是，如何设计模块以简化这种模式？

组织模块以实现可测试性

模块类是一种实用类：一个独立的 @Providers 方法的收集器，每一个模块类都可能被注射器使用来提供某种类型给应用程序。

虽然几个 @Provides 方法可能相关，因为它们依赖于另一个提供的类型，但它们通常不会明确地相互调用或依赖于相同的可变状态。一些 @Provides 方法确实引用相同的实例字段，在这种情况下它们实际上不是独立的。这里给出的建议是将 @Provides 方法视为实用方法，这样模块就可以很容易地被替代从而方便测试。

那么如何确定哪些 @Provides 方法应该合并到一个模块类？

考虑它的一种方法是将绑定分类为已发布的绑定和内部绑定，然后进一步确定哪些已发布的绑定具有合理的替代方案。

已发布的绑定是提供应用程序其他部分使用的功能的绑定。例如 AuthManager 或 User 或 DocDatabase 等类型是已发布类：它们绑定在一个模块中，以便应用程序的其余部分可以使用它们。

内部绑定是除已发布之外的绑定：在某些已发布类型的实现中使用的绑定，并且除此之外不被其他地方使用。例如，OAuth客户端 ID 配置的绑定或仅供AuthManager 的 OAuth 实现使用而不被程序其他部分使用的 OAuthKeyStore。这些绑定通常用于包私有类型，或者使用包私有限定符进行限定。

一些已发布的绑定将具有合理的替代方案，尤其是用于测试，而其他绑定则不会。例如，对于类似AuthManager 的类型，可能存在替代绑定：一个用于测试，另一个用于不同的身份验证/授权协议。

但另一方面，如果 AuthManager 接口有一个返回当前登录用户的方法，您可能希望通过在 AuthManager 上调用 getCurrentUser() 来发布为User提供的绑定。这种发布的绑定不太可能需要替代方案。

一旦您将绑定分类为具有合理替代方案的已发布绑定，没有合理替代方案的发布绑定和内部绑定，考虑将它们安排到这样的模块中：

每个需要合理替代方案的已发布绑定作为一个模块。（如果你也在编写备选方案，则每个方案都有自己的模块。）该模块只包含一个已发布的绑定，以及发布绑定所需的所有内部绑定。
所有不需要合理替代方案的已发布绑定都会进入沿功能线组织的模块。
已发布的绑定模块应各自包含需要公共绑定的无需替代方案模块。

通过描述该模块提供了哪些已发布绑定来记录每个模块是个好主意。

下面是使用认证域的示例。如果存在 AuthManager 接口，则可能具有 OAuth 实现和用于测试的虚假实现。如上所述，你不希望在配置之间进行更改当前用户可能存在的明显的绑定。

/**
 * Provides auth bindings that will not change in different auth configurations,
 * such as the current user.
 */
@Module
class AuthModule {
@Provides static User currentUser(AuthManager authManager) {
return authManager.currentUser();
}
// Other bindings that don’t differ among AuthManager implementations.
}
/** Provides a {@link AuthManager} that uses OAuth. */
@Module(includes = AuthModule.class) // Include no-alternative bindings.
class OAuthModule {
@Provides static AuthManager authManager(OAuthManager authManager) {
return authManager;
}
// Other bindings used only by OAuthManager.
}
/** Provides a fake {@link AuthManager} for testing. */
@Module(includes = AuthModule.class) // Include no-alternative bindings.
class FakeAuthModule {
@Provides static AuthManager authManager(FakeAuthManager authManager) {
return authManager;
}
// Other bindings used only by FakeAuthManager.
}

然后您的生产配置将使用真实模块，测试配置假模块，如上所述。

你不必使用 `Dagger` 进行单类单元测试

如果要编写仅测试一个被 @Inject 注解的类的小型单元测试，则不需要使用 Dagger 来实例化该类。如果你想编写传统的单元测试，可以直接调用被 @Inject 注解的构造函数和方法并设置被 @Inject 注解的字段。如果有需要的话，直接传递假的或模拟的依赖，就像它们没有被注解一样。

final class ThingDoer {
private final ThingGetter getter;
private final ThingPutter putter;
@Inject ThingDoer(ThingGetter getter, ThingPutter putter) {
this.getter = getter;
this.putter = putter;
}
String doTheThing(int howManyTimes) { /* … */ }
}
public class ThingDoerTest {
@Test
public void testDoTheThing() {
ThingDoer doer = new ThingDoer(fakeGetter, fakePutter);
assertEquals("done", doer.doTheThing(5));
}
}

参考

Testing with Dagger

Android 四大组件单元测试之 Receiver

Fri, 05 Oct 2018 14:40:35 +0800

测试工具

Junit4 Mockito Robolectric

本文假定读者已经配置好了库及环境。

测试内容

Receiver 测试相对比较简单，很容易得到 100% 的覆盖率。测试主要覆盖如下场景：

可以被 Manifest 中 Intent-filter 正确拉起
onReceiver(Context, Intent) 中 intent 输入
其他内部逻辑方法
如果有线程且其中有逻辑代码，分拆成独立方法测试

验证条件

普通方法验证输入输出
onReceive() 可以验证 Context.startService(Intent) Context.startActivity(Intent) 方法是否被执行，且捕获 Intent 参数，验证参数是否与预期一致
有其他操作如写入数据库等，可以验证这些操作被执行，且参数一致

通过分析验证条件，我们可以总结出需要 mock 或 spy 的对象要有 Context 和 Receiver 本身。

代码实例

下面代码以日历中找的一个最简单的 LanguageChangeReceiver 为例一步一步完成测试覆盖：

Receiver 代码

<receiver android:name=".receiver.LanguageChangeReceiver"
android:exported="false">
<intent-filter>
<action android:name="android.intent.action.LOCALE_CHANGED"/>
</intent-filter>
</receiver>

public class LanguageChangeReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (intent == null || intent.getAction() == null) {
return;
}
if (intent.getAction().equals(Intent.ACTION_LOCALE_CHANGED)) {
loadFestXmlData(context);
}
}
void loadFestXmlData(final Context context) {
IoThread.get().post(new Runnable() {
@Override
public void run() {
FestXmlUtils.getInstance().reloadData(context);
}
});
}
}

代码分析

从代码可以看出这个 receiver 只监听了一个 LOCALE_CHANGED 的事件，我们首先需要对能否接收到这个事件做校验；再看 onReceive(Context context, Intent intent) 方法，可以看到需要注入 Context 和 Intent 依赖，同时需要对 intent 的数据内容做分支测试。

测试代码

首先我们需要准备上下文环境，并准备 Context 和 LanguageChangeReceiver 对象。可以从 ShadowApplication 对象中拿到 receiver 对象，同时使用 spy() 对 receiver 和 context 对象监听，这样我们就可以校验 context 和 receiver 中的方法是否被执行。

@RunWith(RobolectricTestRunner.class)
public class LanguageChangeReceiverTest {
private Context mContext;
private LanguageChangeReceiver receiver;
@Before
public void setup() {
ShadowApplication shadowApplication = Shadows.shadowOf(RuntimeEnvironment.application);
List<ShadowApplication.Wrapper> receivers = shadowApplication.getRegisteredReceivers();
for (ShadowApplication.Wrapper wrapper : receivers) {
if (wrapper.getBroadcastReceiver() instanceof LanguageChangeReceiver) {
receiver = spy((LanguageChangeReceiver) wrapper.getBroadcastReceiver());
break;
}
}
mContext = spy(RuntimeEnvironment.application);
}
}

1. 测试 `intent-filter`

我们首先要测试 receiver 是否能收到期望的事件，需要通过 PackageManager.queryBroadcastReceivers() 方法拉起期望过滤到的 intent，然后断言被拉起的广播中有当前的 LanguageChangeReceiver：

// Test if LanguageChangeReceiver could receive defined intent action
@Test
public void testIntentHandling() {
ShadowApplication shadowApplication = ShadowApplication.getInstance();
PackageManager packageManager =
shadowApplication.getApplicationContext().getPackageManager();
List<String> stringList = new ArrayList<String>(
Arrays.asList(
"android.intent.action.LOCALE_CHANGED"));
for (String action : stringList) {
Intent intent = new Intent(action);
Boolean hasReceiver = false;
for (ResolveInfo resolveInfo : packageManager.queryBroadcastReceivers(intent, 0)) {
if (LanguageChangeReceiver.class.getCanonicalName().equals(
resolveInfo.activityInfo.name)) {
hasReceiver = true;
break;
}
}
Assert.assertTrue(hasReceiver);
}
}

2. 测试空 Intent

这是一个边界条件，我们需要测试传入的 Intent 为空时不会出现异常且没有执行其他非预期操作。

@Test
public void onReceive_withNoIntentAction() {
receiver.onReceive(mContext, null);
verify(receiver, never()).loadFestXmlData(any(Context.class));
receiver.onReceive(mContext, new Intent());
verify(receiver, never()).loadFestXmlData(any(Context.class));
}

3. 测试预期的 Intent 行为

这个是我们的正常业务逻辑，我们需要传入正确的 Intent 并验证预期的方法被执行：

@Test
public void onReceive_withAction() {
receiver.onReceive(mContext, new Intent(Intent.ACTION_LOCALE_CHANGED));
verify(receiver).loadFestXmlData(eq(mContext));
}

总结

通过上面三个测试已经完整覆盖了 LanguageChangeReceiver 所有业务逻辑和分支。测试代码非常简单，更多的代码是在准备上下文环境。如果 Receiver 中含有大量业务逻辑是需要详细的测试覆盖的，这些测试内容和普通的 mockito 单元测试没有区别。

最后附一个业务逻辑较为复杂的 MobileCalendarBackupRecoverReceiver 测试代码供参考，测试的方法是一样的，只是含有更多的逻辑分支所有测试内容较多。

附

MobileCalendarBackupRecoverReceiver 测试实例，包含测试代码和 Receiver 代码：

MobileCalendarBackupRecoverReceiverTest.java

@RunWith(RobolectricTestRunner.class)
public class MobileCalendarBackupRecoverReceiverTest {
private Context mContext;
private MobileCalendarBackupRecoverReceiver receiver;
@Before
public void setup() {
ShadowApplication shadowApplication = Shadows.shadowOf(RuntimeEnvironment.application);
List<ShadowApplication.Wrapper> receivers = shadowApplication.getRegisteredReceivers();
for (ShadowApplication.Wrapper wrapper : receivers) {
if (wrapper.getBroadcastReceiver() instanceof MobileCalendarBackupRecoverReceiver) {
receiver = spy(
(MobileCalendarBackupRecoverReceiver) wrapper.getBroadcastReceiver());
break;
}
}
mContext = spy(RuntimeEnvironment.application);
}
@Test
public void testIntentHandling() {
ShadowApplication shadowApplication = ShadowApplication.getInstance();
PackageManager packageManager =
shadowApplication.getApplicationContext().getPackageManager();
List<String> stringList = new ArrayList<String>(
Arrays.asList(
"com.qiku.android.mobile.backup.action.BACKUPCALENDAR",
"com.android.providers.calendar.spacesize",
"com.qiku.android.mobile.backup.action.CALENDARSIZE"));
for (String action : stringList) {
Intent intent = new Intent(action);
Boolean hasReceiver = false;
for (ResolveInfo resolveInfo : packageManager.queryBroadcastReceivers(intent, 0)) {
if (MobileCalendarBackupRecoverReceiver.class.getCanonicalName().equals(
resolveInfo.activityInfo.name)) {
hasReceiver = true;
break;
}
}
Assert.assertTrue(hasReceiver);
}
}
@Test
public void onReceive_withoutIntentData() {
receiver.onReceive(mContext, null);
verify(receiver, never()).getPayload(any(Intent.class));
}
@Test
public void onReceive_withIntentData_querySize() {
Intent intent = new Intent();
intent.setAction(IntentUtil.MOBILE_ACTION_QUERY_SIZE);
receiver.onReceive(mContext, intent);
verify(receiver).getPayload(any(Intent.class));
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext).sendBroadcast(argument.capture());
assertEquals(
"Intent { act=com.qiku.android.backup.action.APPLICATIONSIZE cmp=com.qiku.android"
+ ".backup/.receiver.SpaceReceiver (has extras) }",
argument.getValue().toString());
assertEquals(
"Bundle[{size=0, application=calendar}]",
argument.getValue().getExtras().toString());
}
@Test
public void onReceive_withIntentData_backup_cancel() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.action = IntentUtil.MOBILE_APPLICATION_BACKUP_RECEIVER;
assertEquals(ProcessResult.DATA_INVALID, receiver.processData(mContext, data));
data.notifyAction = "notify_action_test";
data.operation = MobileCalendarBackupRecoverReceiver.Operation.CANCEL;
data.identity = 1;
assertEquals(ProcessResult.PROCESS_CANCEL, receiver.processData(mContext, data));
}
@Test
public void onReceive_withIntentData_backup_fileError() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.action = IntentUtil.MOBILE_APPLICATION_BACKUP_RECEIVER;
assertEquals(ProcessResult.DATA_INVALID, receiver.processData(mContext, data));
data.notifyAction = "notify_action_test";
data.operation = MobileCalendarBackupRecoverReceiver.Operation.BACKUP;
data.identity = 1;
when(receiver.isFileTooLarge(mContext, data)).thenReturn(true);
assertEquals(ProcessResult.FILE_ERROR, receiver.processData(mContext, data));
when(receiver.isFileTooLarge(mContext, data)).thenReturn(false);
when(receiver.isEmptyBackupFile(mContext, data)).thenReturn(true);
assertEquals(ProcessResult.FILE_ERROR, receiver.processData(mContext, data));
}
@Test
public void onReceive_withIntentData_backup() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.action = IntentUtil.MOBILE_APPLICATION_BACKUP_RECEIVER;
assertEquals(ProcessResult.DATA_INVALID, receiver.processData(mContext, data));
data.notifyAction = "notify_action_test";
data.operation = MobileCalendarBackupRecoverReceiver.Operation.BACKUP;
data.identity = 1;
assertEquals(ProcessResult.FINISHED, receiver.processData(mContext, data));
verify(receiver).startBackupService(mContext, data);
}
@Test
public void onReceive_withIntentData_noSpace() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.action = IntentUtil.NO_SPACE_ACTION;
receiver.prepareBackupIntent();
assertEquals(ProcessResult.FINISHED, receiver.processData(mContext, data));
verify(receiver).stopBackupService(mContext, data);
}
@Test
public void startBackgroundService_withInvalidDataType() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.dataType = null;
data.notifyAction = "notify_action_test";
data.operation = MobileCalendarBackupRecoverReceiver.Operation.BACKUP;
data.identity = 1;
receiver.startBackupService(mContext, data);
verify(receiver).notifyBackupRecover(mContext, data);
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext).sendBroadcast(argument.capture());
assertEquals("Intent { act=notify_action_test (has extras) }",
argument.getValue().toString());
assertEquals("Bundle[{return=0, percent=0, identity=1, application=calendar}]",
argument.getValue().getExtras().toString());
}
@Test
public void startBackgroundService_withInvalidOperation() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.dataType = "calendar";
data.notifyAction = "notify_action_test";
data.identity = 1;
data.operation = MobileCalendarBackupRecoverReceiver.Operation.CANCEL;
receiver.startBackupService(mContext, data);
verify(receiver).notifyBackupRecover(mContext, data);
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext).sendBroadcast(argument.capture());
assertEquals("Intent { act=notify_action_test (has extras) }",
argument.getValue().toString());
assertEquals("Bundle[{return=0, percent=0, identity=1, application=calendar}]",
argument.getValue().getExtras().toString());
}
@Test
public void startBackgroundService_withValidOperation() {
MobileCalendarBackupRecoverReceiver.Data data =
new MobileCalendarBackupRecoverReceiver.Data();
data.dataType = "calendar";
data.notifyAction = "notify_action_test";
data.identity = 1;
data.operation = MobileCalendarBackupRecoverReceiver.Operation.BACKUP;
receiver.prepareBackupIntent();
receiver.startBackupService(mContext, data);
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(receiver).startService(eq(mContext), argument.capture());
assertEquals(
"Intent { act=com.qiku.android.mobile.backup.action.BACKUPSERVICE pkg=com.qiku"
+ ".android.calendar (has extras) }",
argument.getValue().toString());
assertEquals(
"Bundle[{qihoo_type=null, notify_action=notify_action_test, opr_type=0, "
+ "identity=1, folder_path=null}]",
argument.getValue().getExtras().toString());
}
@After
public void tearDown() {
CalendarDatabaseHelperTest.closeDatabase(RuntimeEnvironment.application);
}
}

MobileCalendarBackupRecoverReceiver.java

public class MobileCalendarBackupRecoverReceiver extends BroadcastReceiver {
private static final String TAG = MobileCalendarBackupRecoverReceiver.class.getSimpleName();
private static final String STR_OPER_TYPE = "opr_type";
private static final String STR_NOTIFY_ACTION = "notify_action";
private static final String STR_FOLD_PATH = "folder_path";
private static final String STR_PERCENT = "percent";
/**
 * ics文件最大字节数(800K)
 */ public static final int MAX_FILE_SIZE = 600 * 1024;
private static final String APPLICATION_STR = "application";
private static final String QIHOO_TYPE = "qihoo_type";
private static final String IDENTITY_STR = "identity";
public static Intent mServiceIntent = null;
public static int mServiceNum = 0;
@IntDef({ReturnOperation.INTERRUPT, ReturnOperation.CANCEL, ReturnOperation.COMPLETE})
@Retention(RetentionPolicy.SOURCE)
public @interface ReturnOperation {
int INTERRUPT = 0;
int CANCEL = -1;
int COMPLETE = 1;
}
@IntDef({Operation.CANCEL, Operation.BACKUP, Operation.RESTORE, Operation.UPDATE})
@Retention(RetentionPolicy.SOURCE)
public @interface Operation {
int CANCEL = -1;
int BACKUP = 0;
int RESTORE = 1;
int UPDATE = 2;
}
public static boolean mIsBackupRecover = false; // 是否在备份恢复

@Override
public void onReceive(Context context, Intent intent) {
if (intent == null || intent.getAction() == null) {
return;
}
Data data = getPayload(intent);
prepareBackupIntent();
processData(context, data);
}
int processData(Context context, Data data) {
switch (data.action) {
case IntentUtil.MOBILE_ACTION_QUERY_SIZE:
sendSizeBroadcast(context);
break;
case IntentUtil.MOBILE_APPLICATION_BACKUP_RECEIVER:
if (data.isInvalid()) {
mServiceIntent = null;
mServiceNum = 0;
return ProcessResult.DATA_INVALID;
}
if (data.operation == Operation.CANCEL) {
Log.d(TAG, "cancel");
cancelBackupService(context, data);
return ProcessResult.PROCESS_CANCEL;
}
if (isFileTooLarge(context, data) || isEmptyBackupFile(context, data)) {
return ProcessResult.FILE_ERROR;
}
startBackupService(context, data);
break;
case IntentUtil.NO_SPACE_ACTION:
stopBackupService(context, data);
break;
}
return ProcessResult.FINISHED;
}
void startBackupService(Context context, Data data) {
if (data.dataType != null && data.dataType.equals("calendar")) {
if (!(data.operation == Operation.BACKUP
|| data.operation == Operation.RESTORE)) {
//操作失败
 notifyBackupRecover(context, data);
} else {
if (mServiceNum == 0) {
mServiceIntent.putExtra(STR_NOTIFY_ACTION, data.notifyAction);
mServiceIntent.putExtra(IDENTITY_STR, data.identity);
mServiceIntent.putExtra(STR_OPER_TYPE, data.operation);
mServiceIntent.putExtra(STR_FOLD_PATH, data.folderPath);
mServiceIntent.putExtra(QIHOO_TYPE, data.qihooType);
mServiceNum = 1;
Log.v(CalendarConsts.QK_CALENDAR,
"startService, mServiceNum = " + mServiceNum);
mIsBackupRecover = true;
startService(context, mServiceIntent);
}
}
} else {
//操作失败
 notifyBackupRecover(context, data);
}
}
void startService(Context context, Intent intent) {
if (Build.VERSION.SDK_INT >= 26) {
context.startForegroundService(intent);
} else {
context.startService(intent);
}
}
void prepareBackupIntent() {
if (mServiceIntent == null && mServiceNum == 0) {
// 防止连续收到多个备份恢复的消息。
 // 如果 mServiceIntent 不为空或者 mServiceNum 大于0，表示服务已经起来了，就不需要再new Intent。
 mServiceIntent = new Intent();
mServiceIntent.setAction(IntentUtil.MOBILE_BACKUP_SERVICE);//你定义的service的action
 mServiceIntent.setPackage("com.qiku.android.calendar");//这里你需要设置你应用的包名
 } else {
Log.v(CalendarConsts.QK_CALENDAR,
"mServiceIntent != null, mServiceNum= " + mServiceNum);
}
}
boolean isEmptyBackupFile(Context context, Data data) {
if (data.hasPath()) {
String fileName = "\\calendar.vcs";
File file = new File(data.folderPath + fileName);
if ((data.operation == Operation.RESTORE) && (file.exists() && file.length() == 0)) {
// 如果需要恢复的备份文件为空，直接返回恢复成功
 Log.v(CalendarConsts.QK_CALENDAR, "Backup File is empty");
data.percent = BackupConsts.NUM_100;
data.returnOperation = ReturnOperation.COMPLETE;
notifyBackupRecover(context, data);
mServiceIntent = null;
mServiceNum = 0;
return true;
}
}
return false;
}
boolean isFileTooLarge(Context context, Data data) {
if (data.hasPath()) {
String fileName = "\\calendar.vcs";
File file = new File(data.folderPath + fileName);
// 600 * 1024是只恢复的ics文件的大小，该大小的ics文件估计存储了2000条左右的日历，
 // 但是如果日程每个字段都填满的话，就只有600条日程。定义该大小的原因是：
 // 如果ics文件超出该大小，在framework层解析ics文件时，会出现异常
 if (file.length() > MAX_FILE_SIZE) {
notifyBackupRecover(context, data);
Toast.makeText(context, ResUtil.getString(R.string.file_lenth_beyond_limit),
Toast.LENGTH_SHORT).show();
mServiceIntent = null;
mServiceNum = 0;
return true;
}
}
return false;
}
private void cancelBackupService(Context context, Data data) {
if (context != null && mServiceIntent != null) {
context.stopService(mServiceIntent);
}
mServiceIntent = null;
mServiceNum = 0;
data.returnOperation = ReturnOperation.CANCEL;
notifyBackupRecover(context, data);
mIsBackupRecover = false;
}
Data getPayload(Intent intent) {
Data data = new Data();
//标示身份(当前时间，用于验证是否是本次操作)
 data.identity = intent.getLongExtra(IDENTITY_STR, 0);
data.notifyAction = intent.getStringExtra(STR_NOTIFY_ACTION);
//获取处理类型，判断是否为日程类型
 data.dataType = intent.getStringExtra(APPLICATION_STR);
data.qihooType = intent.getStringExtra(QIHOO_TYPE);
data.operation = intent.getIntExtra(STR_OPER_TYPE, Operation.BACKUP);
data.folderPath = intent.getStringExtra(STR_FOLD_PATH);
data.action = intent.getAction();
return data;
}
void stopBackupService(Context context, Data data) {
// 空间不足取消操作
 context.stopService(mServiceIntent);
mServiceIntent = null;
mServiceNum = 0;
data.returnOperation = ReturnOperation.CANCEL;
notifyBackupRecover(context, data);
}
void sendSizeBroadcast(Context context) {
ListBufferInfoBean bean = provideEditEvent(context);
if (bean != null) {
//每个设置3.5k
 int size = 7 * bean.getCount() / 2;
Intent i = new Intent(IntentUtil.ACTION_ANSWER_SIZE);
i.putExtra(APPLICATION_STR, "calendar");
i.putExtra("size", size);
i.setClassName(IntentUtil.BACKUP_PACKAGE, IntentUtil.SPACE_RECEIVER);
context.sendBroadcast(i);
}
}
ListBufferInfoBean provideEditEvent(Context context) {
return EditEventLogicImpl.getInstance(context).getEventsTableInfoForBackUp(-1);
}
/**
 * 发广播消息通知备份应用程序
 */
void notifyBackupRecover(Context context, Data data) {
Intent intent = new Intent(data.notifyAction);
intent.putExtra(APPLICATION_STR, "calendar");
intent.putExtra("return", data.returnOperation);
if (data.percent > BackupConsts.NUM_100) {
intent.putExtra(STR_PERCENT, BackupConsts.NUM_100);
} else {
intent.putExtra(STR_PERCENT, data.percent);
}
intent.putExtra(IDENTITY_STR, data.identity);
context.sendBroadcast(intent);
}
static class Data {
@Operation
int operation;
@ReturnOperation
int returnOperation = ReturnOperation.INTERRUPT;
long identity;
String notifyAction;
String dataType;
String qihooType;
String folderPath;
String action;
int percent;
boolean isInvalid() {
return TextUtils.isEmpty(notifyAction) || identity == 0;
}
boolean hasPath() {
return !TextUtils.isEmpty(folderPath);
}
}
}

Android 四大组件单元测试之 Activity

Fri, 05 Oct 2018 14:30:53 +0800

测试工具

Junit4 Mockito Robolectric

本文假定读者已经配置好了库及环境。

测试内容

Activity 测试相对比较简单，很容易得到 100% 的覆盖率。测试主要覆盖如下场景：

onCreate(Bundle savedInstanceState) 中的逻辑过程，需要通过 getIntent() 方法传入不同的 Intent 覆盖。
其他内部逻辑方法
如果有线程且其中有逻辑代码，分拆成独立方法测试

验证条件

逻辑执行过程中，可以验证 Activity.startActivity(Intent) 这样的方法是否被执行，及断言他们传入的 intent 是我们期望的值；可以验证 UI 界面中的状态变化，如 TextView 的文字等。

通过分析验证条件，我们可以总结出需要 mock 或 spy 的对象要为Activity 本身。同时我们可以借助 ActivityController<T> 来模拟一些 Activity 的行为如生命周期。

代码实例

下面代码以日历中找的一个最简单的 DeepLinkActivity 为例一步一步完成测试覆盖：

Activity 代码

<activity
android:name=".ui.DeepLinkActivity"
android:noHistory="true"
android:exported="true"
android:screenOrientation="portrait"
android:theme="@android:style/Theme.NoDisplay">
<intent-filter>
<data android:scheme="com.qiku.android.calendar" />
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
</intent-filter>
</activity>

DeepLinkActivity.java

public class DeepLinkActivity extends Activity {
private static final String TAG = DeepLinkActivity.class.getSimpleName();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_deep_link);
Intent intent = getIntent();
if (intent != null && intent.getData() != null) {
openDeepLink(intent.getData());
}
finish();
}
private void openDeepLink(Uri deepLink) {
Log.d(TAG, "openDeepLink: " + deepLink);
String scheme = deepLink.getScheme();
String host = deepLink.getHost();
String path = deepLink.getPath();
if (!Constants.DEEP_LINK_SCHEME.equals(scheme)) {
Log.e(TAG, "wrong scheme: " + scheme);
return;
}
switch (host) {
case Constants.DEEP_LINK_HOST_HOME:
if (Constants.DEEP_LINK_PATH_MONTH.equals(path)) {
startActivity(new Intent(this, MenuAnimationActivity.class));
} else {
startActivity(new Intent(this, SplashActivity.class));
}
break;
default:
startActivity(new Intent(this, SplashActivity.class));
break;
}
}
}

代码分析

从代码可以看出这个 Acitivyt 监听了一个 com.qiku.android.calendar://xxx 的事件，我们首先需要对能否接收到这个事件做校验；再看 onCreate() 方法，可以看到需要在 getIntent() 方法执行时提供不同的数据场景来覆盖业务逻辑。这些逻辑分支整理为以下几条：

空 Intent 或 Intent data 为空
错误的 Intent scheme
正确 scheme 时默认拉起界面
拉起主界面 SplashActivity
拉起主界面 MenuAnimationActivity

测试代码

首先我们需要准备上下文环境，我们可以通过 Robolectric.buildActivity(DeepLinkActivity.class) 方法构建一个 ActivityController 对象，同时通过 controller.get() 来拿到 DeepLinkActivity 对象：

private ActivityController<DeepLinkActivity> controller;
private DeepLinkActivity activity;
private DeepLinkActivity spy;
@Before
public void setup() {
controller = Robolectric.buildActivity(DeepLinkActivity.class);
activity = controller.get();
}

1. 测试空 Intent 拉起

先对空边界进行覆盖，可以在 onCreate 方法中看出，当 getIntent() 返回空时，没有执行任何业务逻辑就退出了。我们首先 spy() Activity 对象，同时假定 getIntent() 被执行时返回一个 null ，然后调用 onCreate 方法。这时我们期望 finish() 方法被执行，同时 startActivity() 方法没有被执行。

@Test
public void deepLink_finishActivity() {
spy = Mockito.spy(activity);
when(spy.getIntent()).thenReturn(null);
spy.onCreate(null);
verify(spy).finish();
verify(spy, never()).startActivity(any(Intent.class));
}

2. 测试错误的 Intent 拉起

再对错误的 Intent 拉起做覆盖。和第一个测试相同，我们假定 getIntent() 返回了一个错误的 Intent，然后再执行 onCreate() 方法，我们的期望和第一个测试相同。

@Test
public void deepLink_wrongSchemeActivity() {
spy = Mockito.spy(activity);
Intent intent = new Intent();
intent.setData(Uri.parse("com.android.calendar://home"));
when(spy.getIntent()).thenReturn(intent);
spy.onCreate(null);
verify(spy).finish();
verify(spy, never()).startActivity(any(Intent.class));
}

3. 拉起默认的界面

传入了正确的 scheme 后，如果 HOST 不匹配需要拉起默认的界面。假定执行 getIntent() 时，返回了一个含有 com.qiku.android.calendar://home1 数据的 Intent，然后执行 onCreate() 方法，校验 finish() 方法被执行，再校验 startActivity(Intent) 方法被执行，同时捕获它的 Intent 参数，断言这个 Intent 和我们期望的值相同。

@Test
public void deepLink_defaultActivity() {
spy = Mockito.spy(activity);
Intent intent = new Intent();
intent.setData(Uri.parse("com.qiku.android.calendar://home1"));
when(spy.getIntent()).thenReturn(intent);
spy.onCreate(null);
verify(spy).finish();
// check startActivity() is called and check argument value
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(spy).startActivity(argument.capture());
assertEquals("Intent { cmp=com.qiku.android.calendar/.ui.SplashActivity }",
argument.getValue().toString());
}

4. 拉起主界面 `SplashActivity`

这个测试和第三个测试基本相同，只是 Intent Data 为我们期望的值 com.qiku.android.calendar://home。

@Test
public void deepLink_startHomeActivity() {
spy = Mockito.spy(activity);
Intent intent = new Intent();
intent.setData(Uri.parse("com.qiku.android.calendar://home"));
when(spy.getIntent()).thenReturn(intent);
spy.onCreate(null);
// check startActivity() is called and check argument value
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(spy).startActivity(argument.capture());
assertEquals("Intent { cmp=com.qiku.android.calendar/.ui.SplashActivity }",
argument.getValue().toString());
}

5. 拉起主界面 `MenuAnimationActivity`

这个测试和第三、四个测试基本相同，只是 Intent Data 中增加了 path 字段，为我们期望的值 com.qiku.android.calendar://home/month，这时我们期望拉起了 MenuAnimationActivity。

@Test
public void deepLink_startHomeMonthActivity() {
spy = Mockito.spy(activity);
Intent intent = new Intent();
intent.setData(Uri.parse("com.qiku.android.calendar://home/month"));
when(spy.getIntent()).thenReturn(intent);
spy.onCreate(null);
// check startActivity() is called and check argument value
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(spy).startActivity(argument.capture());
assertEquals("Intent { cmp=com.qiku.android.calendar/.ui.MenuAnimationActivity }",
argument.getValue().toString());
}

总结

通过上面的测试代码，我们已经完整覆盖了 DeepLinkActivity 的所有业务逻辑分支，可以看出 Activity 的测试还是很简单的。如果上下文中涉及到生命周期，view 等内容，仍需要 ActivityController<T> 的参与。

最后附一个含有 UI 内容的 FeedSettingsActivity 单元测试，这个测试中校验了 ListView 的每个 Item，同时对标题栏、Item 点击，返回按钮等事件做了验证。

附

FeedSettingsActivity.java

public class FeedSettingsActivity extends QkCalendarCommonActivity {
private static final String TAG = AdViewerActivity.class.getSimpleName();
TopBar mTopBar;
ListView mListView;
ListAdapter mAdapter;
FeedSettings mSettings;
boolean hasParent = false;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setBodyLayout(R.layout.activity_feed_manage);
mSettings = FeedSettingsImpl.getInstance();
mSettings.init(getApplicationContext());
mListView = findViewById(R.id.list);
mAdapter = new ListAdapter(mSettings);
List<ListItem> items = loadListItems();
mAdapter.reload(items);
mListView.setAdapter(mAdapter);
mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
ListItem item = (ListItem) mAdapter.getItem(position);
if (item.hasChild()) {
mAdapter.reload(item.children);
mAdapter.notifyDataSetChanged();
hasParent = true;
setTitle(item.title);
}
}
});
}
@Override
public void onBackPressed() {
if (hasParent) {
List<ListItem> items = loadListItems();
mAdapter.reload(items);
mAdapter.notifyDataSetChanged();
hasParent = false;
setTitle(R.string.feed_manager);
} else {
super.onBackPressed();
}
}
@Override
protected void onResume() {
super.onResume();
setTitle(R.string.feed_manager);
}
@Override
protected void onCreateTopBar(TopBar topBar) {
super.onCreateTopBar(topBar);
topBar.setTopBarStyle(TopBar.TopBarStyle.TOP_BAR_NOTMAL_STYLE);
topBar.setDisplayUpView(true);
mTopBar = topBar;
getLayoutInflater();
}
@Override
public void setTitle(CharSequence title) {
if (!((String) title).isEmpty()) {
mTopBar.setTopBarTitle(title);
}
}
List<ListItem> loadListItems() {
List<ListItem> listItems = new ArrayList<>();
listItems.add(new ListItem("黄历八字", FeedTypeEx.FORTUNE.getString()));
listItems.add(new ListItem("天气", FeedTypeEx.WEATHER.getString()));
listItems.add(new ListItem("历史上的今天", FeedType.HISTORY.getString()));
listItems.add(new ListItem("星座", loadSignItems()));
List<StoryType> storyTypes = mSettings.getAllStoryTypes();
for (StoryType storyType : storyTypes) {
listItems.add(new ListItem(storyType.getName(), FeedType.STORY.getString() +
"_" + storyType.getId()));
}
listItems.add(new ListItem("今日要闻", FeedTypeEx.FLOW_NEWS.getString()));
return listItems;
}
List<ListItem> loadSignItems() {
List<ListItem> listItems = new ArrayList<>();
for (SignType type : SignType.values()) {
listItems.add(new ListItem(type.getName(), type.key()));
}
return listItems;
}
static class ListAdapter extends BaseAdapter {
private FeedSettings mSettings;
List<ListItem> items = new ArrayList<>();
ListAdapter(FeedSettings settings) {
mSettings = settings;
}
void reload(List<ListItem> types) {
items.clear();
items.addAll(types);
}
@Override
public int getCount() {
return items.size();
}
@Override
public Object getItem(int position) {
return items.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(final int position, View convertView, final ViewGroup parent) {
final ListItem item = items.get(position);
if (convertView == null) {
convertView = View.inflate(parent.getContext(), R.layout.calendar_setting_item,
null);
convertView.setTag(new ViewHolder(convertView));
}
final ViewHolder viewHolder = (ViewHolder) convertView.getTag();
viewHolder.mainTitle.setText(item.title);
viewHolder.subTitle.setVisibility(View.GONE);
convertView.setClickable(false);
if (item.hasChild()) {
viewHolder.switchButton.setVisibility(View.GONE);
viewHolder.arrow.setVisibility(View.VISIBLE);
} else {
viewHolder.arrow.setVisibility(View.GONE);
viewHolder.switchButton.setVisibility(View.VISIBLE);
viewHolder.switchButton.setOnCheckedChangeListener(null);
viewHolder.switchButton.setCheckedImmediately(mSettings.getValue(item.key));
viewHolder.switchButton.setOnCheckedChangeListener(
new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
mSettings.setValue(item.key, isChecked);
if (isChecked && item.key.equals(FeedTypeEx.WEATHER.getString())) {
WeatherController.getInstance().init(parent.getContext());
}
}
});
convertView.setClickable(true);
convertView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
viewHolder.switchButton.toggle();
}
});
}
return convertView;
}
final static class ViewHolder {
TextView mainTitle;
TextView subTitle;
QkSwitch switchButton;
ImageView arrow;
private ViewHolder(View parent) {
mainTitle = parent.findViewById(R.id.main_title);
subTitle = parent.findViewById(R.id.sub_title);
switchButton = parent.findViewById(R.id.common_switch_button);
arrow = parent.findViewById(R.id.icon_arrow);
}
}
}
static class ListItem {
ListItem(String title, String key) {
this.title = title;
this.key = key;
}
ListItem(String title, List<ListItem> children) {
this.title = title;
this.children.addAll(children);
}
String title;
String key;
List<ListItem> children = new ArrayList<>();
boolean hasChild() {
return children.size() > 0;
}
@Override
public String toString() {
String s = "{" +
"title='" + title + '\'' +
", key='" + key + '\'';
if (children.size() > 0) {
s += ", children=" + children;
}
s += '}';
return s;
}
}
}

FeedSettingsActivityTest.java

@RunWith(RobolectricTestRunner.class)
public class FeedSettingsActivityTest {
private ActivityController<FeedSettingsActivity> controller;
private FeedSettingsActivity activity;
@Before
public void setup() {
controller = Robolectric.buildActivity(FeedSettingsActivity.class);
activity = controller.get();
}
@Test
public void feedSettingList() {
FeedSettingsActivity spy = spy(activity);
spy.onCreate(null);
verify(spy).loadListItems();
verify(spy).loadSignItems();
assertEquals(5, spy.mAdapter.items.size());
assertEquals(
"[{title='黄历八字', key='fortune'}, "
+ "{title='天气', key='weather'}, "
+ "{title='历史上的今天', key='history'}, "
+ "{title='星座', key='null', children=["
+ "{title='白羊座', key='sign_aries'},"
+ " {title='金牛座', key='sign_taurus'}, "
+ "{title='双子座', key='sign_gemini'}, "
+ "{title='巨蟹座', key='sign_cancer'}, "
+ "{title='狮子座', key='sign_leo'}, "
+ "{title='处女座', key='sign_virgo'}, "
+ "{title='天秤座', key='sign_libra'}, "
+ "{title='天蝎座', key='sign_scorpio'}, "
+ "{title='射手座', key='sign_sagittarius'}, "
+ "{title='摩羯座', key='sign_capricorn'}, "
+ "{title='水瓶座', key='sign_aquarius'}, "
+ "{title='双鱼座', key='sign_pisces'}]}, "
+ "{title='今日要闻', key='flow_news'}]",
spy.mAdapter.items.toString());
}
@Test
public void signParentItemClick() {
FeedSettingsActivity spy = spy(activity);
spy.onCreate(null);
spy.mListView.performItemClick(spy.mListView, 3, 0);
assertEquals(12, spy.mAdapter.items.size());
assertEquals(
"[{title='白羊座', key='sign_aries'}, "
+ "{title='金牛座', key='sign_taurus'}, "
+ "{title='双子座', key='sign_gemini'}, "
+ "{title='巨蟹座', key='sign_cancer'}, "
+ "{title='狮子座', key='sign_leo'}, "
+ "{title='处女座', key='sign_virgo'}, "
+ "{title='天秤座', key='sign_libra'}, "
+ "{title='天蝎座', key='sign_scorpio'}, "
+ "{title='射手座', key='sign_sagittarius'}, "
+ "{title='摩羯座', key='sign_capricorn'}, "
+ "{title='水瓶座', key='sign_aquarius'}, "
+ "{title='双鱼座', key='sign_pisces'}]",
spy.mAdapter.items.toString());
assertTrue(spy.hasParent);
spy.onBackPressed();
assertEquals(5, spy.mAdapter.items.size());
assertEquals(
"[{title='黄历八字', key='fortune'}, "
+ "{title='天气', key='weather'}, "
+ "{title='历史上的今天', key='history'}, "
+ "{title='星座', key='null', children=["
+ "{title='白羊座', key='sign_aries'},"
+ " {title='金牛座', key='sign_taurus'}, "
+ "{title='双子座', key='sign_gemini'}, "
+ "{title='巨蟹座', key='sign_cancer'}, "
+ "{title='狮子座', key='sign_leo'}, "
+ "{title='处女座', key='sign_virgo'}, "
+ "{title='天秤座', key='sign_libra'}, "
+ "{title='天蝎座', key='sign_scorpio'}, "
+ "{title='射手座', key='sign_sagittarius'}, "
+ "{title='摩羯座', key='sign_capricorn'}, "
+ "{title='水瓶座', key='sign_aquarius'}, "
+ "{title='双鱼座', key='sign_pisces'}]}, "
+ "{title='今日要闻', key='flow_news'}]",
spy.mAdapter.items.toString());
assertFalse(spy.hasParent);
}
@Test
public void backButtonPressed() {
FeedSettingsActivity spy = spy(activity);
spy.onCreate(null);
assertFalse(spy.hasParent);
spy.mListView.performItemClick(spy.mListView, 3, 0);
assertTrue(spy.hasParent);
spy.onBackPressed();
assertFalse(spy.hasParent);
assertFalse(activity.isFinishing());
spy.onBackPressed();
assertTrue(activity.isFinishing());
}
@Test
public void feedSettingTitle() {
Locale locale = new Locale("zh");
Locale.setDefault(locale);
RuntimeEnvironment.setQualifiers(locale.getLanguage());
FeedSettingsActivity spy = spy(activity);
spy.onCreate(null);
spy.onResume();
assertEquals("订阅管理", spy.mTopBar.getTopBarTitle());
spy.mListView.performItemClick(spy.mListView, 3, 0);
assertTrue(spy.hasParent);
assertEquals("星座", spy.mTopBar.getTopBarTitle());
spy.onBackPressed();
assertEquals("订阅管理", spy.mTopBar.getTopBarTitle());
}
@Test
public void listView_item() {
FeedSettingsActivity spy = spy(activity);
spy.onCreate(null);
spy.onResume();
controller.visible();
View view = spy.mListView.getChildAt(0);
FeedSettingsActivity.ListAdapter.ViewHolder viewHolder =
(FeedSettingsActivity.ListAdapter.ViewHolder) view.getTag();
assertEquals("黄历八字", viewHolder.mainTitle.getText());
assertTrue(viewHolder.switchButton.isEnabled());
}
}

Android 开发人员自动化测试

Fri, 05 Oct 2018 13:09:22 +0800

编写测试的目的是为了验证程序是否正确执行、行为无误及是否稳定可用。同时，拥有充分测试代码的项目易于维护，便于交接、团队协作。

有很多的 Android 架构如 MVP、Clean、DataBinding 等，这些架构的一个共同点是分离视图界面、数据模型、业务/控制逻辑，最大限度的降低代码耦合，减少函数/方法的副作用。网上介绍这些架构、框架的文章很多，但是很少有提及为什么要这么做。使用规范的代码架构，降低代码耦合，直观上可以使代码易于维护，提高代码利用率、便于重构，其实最直接的作用是为了方便的写测试代码，这一点却很少有人提及。

以 MVP 架构举例，将 APP 代码分离为三个层次：Model, View, Presenter。Model 层封装数据模型，不做任何逻辑操作，View 层即 Activity、Fragment 等只用来展示界面、返回界面事件，Presenter 层来和数据交互，控制界面显示逻辑，响应界面事件及数据变化。View 不直接和 Model 交互，同时 Model 和 Presenter 不依赖于 Android 系统库的代码，这样可以方便的在本地电脑对 Presenter 和 Model 做单元测试。

本文档主要是对 Android 开发人员如何编写单元测试及 UI 自动化测试代码的整理，其中大部分篇幅是对 Android 官方文档翻译，要阅读英文原文，请点击每小节的参考链接或文档最后的参考资料链接。

一. 测试类型

Android 测试类型可以分为三大类：单元测试、集成测试、压力测试。单元测试又可以分为本地单元测试、仪表 (Instrumented) 单元测试；集成测试分为应用内、跨应用测试；压力测试可以分为 Monkey 、Monkey Runner。除了压力测试中的 Monkey 测试，其他五类测试都需要开发人员编写测试代码。

其中 Monkey 测试不需要开发人员编写测试代码，而 Monkey Runner 是 Python 程序，一般 Android 开发人员不直接编写此类测试代码。由于篇幅关系，本文不讨论压力测试的内容。

类型	子类型	描述
单元测试	本地单元测试	运行在本地 Java 虚拟机，不依赖于 Android 框架或者可以通过 Mock 来模拟 Android 框架的测试。因为不依赖与 Android 框架及模拟器或开发机，执行快
	Instrumented 单元测试	运行于开发机或模拟器，这些测试可以访问应用的运行状态信息，如应用的 Context。用这些测试来测试不能通过Mock模拟而必须依赖于 Android 框架的组件。因为要运行在真实的 Android 环境下，执行较慢。
集成测试	仅应用内组件测试	这类测试用来确认目标应用在用户执行某特定操作或输入时，能够正确响应。例如，可以用来确认用户与应用交互时响应了正确的用户界面。UI 测试框架如 Espresso 允许开发者程序化的模仿用户行为并验证复杂的程序内用户交互。
	跨应用组件测试	这类测试用来验证用户在多个不同应用之间或应用与系统交互时是否正确。例如可以通过这类测试来验证用户操作后系统状态栏的通知是否正确，也可以通过这类测试来点击状态栏通知、点击权限确认按钮。UI 测试框架如 UI Automator 可以用来创建此类测试。
压力测试	Monkey	Monkey 是一个命令行工具，可以通过 adb 接口随机触摸、点击、按键或触发手势。它可以循环执行这些随机的触摸等事件，并返回遇到的错误。
	monkeyrunner	monkeyrunner 是一个 Python 程序，是一个测试 API 及运行环境。API 包括连接设备、安装/卸载软件包、截取屏幕、对比两个图片及运行测试软件包等。使用这个 API 可以编写强大复杂的测试。

二. 测试支持库

Android 官方的测试支持库包括 AndroidJUnit4，Espresso，UI Automator 。其中 Espresso 和 UI Automator 可以结合在一起使用，来模拟完整的用户行为。

1. AndroidJUnit4

AndroidJUnit4 是 Android 单元测试的主要方法，在本地计算机或持续集成环境中运行，不需要测试机或者模拟器。

2. Espresso

Espresso 是用来测试 Android 应用界面的主要方法，运行于测试机或者持续集成环境中的模拟器。不同于 UI Automator，Espresso 只能用来测试应用本身的界面，但是 Espresso 更加便捷易用，可以非常轻松的实现点击、滑动、长按、触摸等操作。

3. UI Automator

UIAutomator 也是用来测试 Android 应用界面的主要方法，运行于测试机或者持续集成环境中的模拟器。不同于 Espresso， UIAutomator 还可以用来测试与系统界面的交互，如状态栏、通知、系统权限对话框等。

这些测试编写完成后，都可以通过自动集成环境（如 Jenkins、Gitlab Runner 、Travis-ci、AppVeyor 等）自动编译、检查错误并生成报告。其中本地单元测试最容易集成但功能有限；仪表 (Instrumented) 单元测试、Espresso、 UI Automator 都需要在自动集成环境的无用户界面环境下启动模拟器并运行，可以附加配置自动抓日志、截屏等方式自动编译、检查错误并生成报告，集成配置相对会复杂一些。

三. 编写 Android 测试

注意： 强烈建议使用 Android Studio 编写测试应用，因为它已经集成了工程配置、依赖库和便利的包管理。本文档假定你已经在使用 Android Studio。

1. 本地单元测试

本小节介绍如何编写本地单元测试，这类测试无依赖或者可以通过 mock 伪造依赖，运行于本地 JVM 。

参考 Building Local Unit Tests

当你编写的单元测试没有依赖或者对 Android 仅有一些简单依赖时，你就可以在本地开发环境运行测试。这个测试过程很高效，因为本地测试可以避免加载目标应用，同时也避免了将测试代码加载到开发机或者模拟器上，所以节省了测试执行过程花费的时间。通常，你需要使用一个 mocking 框架，例如 Mockito 来满足代码的依赖关系。

配置测试环境

在你的 Android Studio 工程中，你必须将本地单元测试的代码存放在 module-name/src/test/java/ 目录下。这个目录在你新建工程时已经被默认创建。你同时也需要为你的工程配置测试依赖库，这个标准 API 库是由 JUnit 4 框架提供的。如果你的测试代码需要依赖 Android，则需要引入 Mockito 库来简化你的本地测试。阅读更多关于如何在你本地单元测试中使用 mock objects，请查看 Mocking Android dependencies 。

在你 app 顶层的 build.gradble 文件中，你需要指定如下依赖库：

dependencies {
// Required -- JUnit 4 framework
 testCompile 'junit:junit:4.12'
// Optional -- Mockito framework
 testCompile 'org.mockito:mockito-core:1.10.19'
}

创建本地单元测试类

本地单元测试类应该是一个纯粹的 JUnit 4 单元测试类。 JUnit 是一个广泛使用的 Java 单元测试框架。JUnit 4 是此框架的最新版本，与之前的几个版本相比，这个版本可以以更简洁和灵活的方式写测试。不同于之前的版本，你的测试类不再需要继承自 junit.framework.TestCase ，同时你也不再需要为测试方法增加 test 关键字前缀，或者使用任何 jnit.framework 或 jnit.extensions 包。

创建一个基本的 JUnit 4 测试类，你需要创建一个含有至少一个测试方法的 Java 类。一个测试方法需要以 @Test 注解开始，同时包含一个执行并验证组件中单一功能的代码块。

例如下面的代码块，测试方法 emailValidator_CorrectEmailSimple_ReturnsTrue 验证 isValidEmail() 方法返回正确的值。

import org.junit.Test;
import java.util.regex.Pattern;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class EmailValidatorTest {
@Test
public void emailValidator_CorrectEmailSimple_ReturnsTrue() {
assertThat(EmailValidator.isValidEmail("name@email.com"), is(true));
}
...
}

使用 junit.Assert 一系列方法来验证检查组件执行的状态或结果是否符合预期，为了更好的可读性，你可以使用

Hamcrest matchers （如 is() 和 equalTo() 方法）来匹配返回值和预期结果。

模拟 (mock) Android 依赖

Android Gradle 插件默认会使用一个修改版的 android.jar 库来执行你的本地单元测试，这个修改版的库不包含任何实现代码。与此同时，你本地的单元测试调用的 Android 类会抛出一个异常。这样做是为了确保你的单元测试代码不依赖于任何特定的 Android 平台行为（除非你明确 mock 这些类）。

你可以使用 mocking 框架来模拟你代码中的外部依赖，来轻松的测试你的组件与依赖交互的结果符合预期。通过 Mock 对象替换 Android 依赖，你可以将单元测试和 Android 系统的其他部分分离，而只验证某些有简单依赖的代码块能够被正确执行。Java 的模拟框架 Mockito 从 1.9.5 版本开始兼容 Android 单元测试。使用 Mockito，你可以配置 mock 对象在调用时返回一些特定的值。

使用此框架为你本地的单元测试添加 mock 对象，请遵守如下编程模式：

1. 在 build.gradle 中导入 Mockito 库依赖，如上文 设置你的测试环境 描述。

2. 在你单元测试的类声明前添加 @RunWith(MockitoJUnitRunner.class) 注解。这个注解告诉 Mockito 测试执行者验证开发者是否正确的使用此框架，同时简化 mock 对象的初始化。

3. 要为一个 Android 依赖如 Context 创建 mock 对象，请在变量声明前添加 @Mock 注解。

4. 为了保持或者说模仿依赖行为，你可以使用 when() 和 thenReturn() 方法来指定当满足某一特定条件时返回某个值。

下面的代码示例展示了在单元测试中如何 mock 一个 Context 对象。

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.CoreMatchers.*;
import static org.mockito.Mockito.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import android.content.SharedPreferences;
@RunWith(MockitoJUnitRunner.class)
public class UnitTestSample {
private static final String FAKE_STRING = "HELLO WORLD";
@Mock
Context mMockContext;
@Test
public void readStringFromContext_LocalizedString() {
// Given a mocked Context injected into the object under test...
 when(mMockContext.getString(R.string.hello_word))
.thenReturn(FAKE_STRING);
ClassUnderTest myObjectUnderTest = new ClassUnderTest(mMockContext);
// ...when the string is returned from the object under test...
 String result = myObjectUnderTest.getHelloWorldString();
// ...then the result should be the expected one.
 assertThat(result, is(FAKE_STRING));
}
}

想要学习更多如何使用 Mockito 框架库的内容，请参考 Mockito API reference 及 sample code 中的 SharedPreferencesHelperTest 类。

Error: “Method … not mocked”

如果你运行的测试调用了没有 mock 的 Android SDK API，你会收到一个 method is not mocked 的错误。这是因为单元测试执行过程中使用的 android.jar 文件没有包含任何实际的实现代码（这些 API 仅被提供在物理设备的系统镜像中）。

相对的，所有的方法调用默认会抛出异常。这是为了确保你的单元测试中仅仅测试你的代码块，而你的代码不依赖于任何特定的 Android 平台行为（那些你没有明确模拟即 mock 的行为）。

如果你认为抛出异常是个问题，你可以修改方法行为使它不抛出异常而返回空或者零，你需要在 build.gradle 文件中添加如下的代码段：

android {
...
testOptions {
unitTests.returnDefaultValues = true
}
}

注意： 应该谨慎设置 returnDefaultValues 属性为 true 。返回空或零值可能会使你的测试变得不可靠，将可能很难调试或者可能会允许失败的测试通过。此方法应该仅作为不能解决问题时的最后手段。

运行本地单元测试

使用如下步骤运行你本地的单元测试：

1. 确保你的工程已经和 Gradle 同步，点击工具栏的 Sync Project 按钮。

2. 使用如下几种途径之一运行你的测试：

只运行一个测试，打开 Project 窗口，在这个测试上点击右键再点击 Run
要测试某个类的所有测试，右键点击这个类或者类中的一个方法，再点击 Run
要测试某个目录中的所有测试，右键点击这个目录，再选择 Run tests

Android gradle 插件会编译位于默认目录 (src/test/java/) 的本地单元测试，编译一个测试 app，然后使用默认的 test runner 类在本地执行它。之后 Android Studio 会在 Run 窗口显示执行结果。

2. 仪表 (Instrumented) 单元测试

本小节介绍如何编写 Instrumented 单元测试，这类测试不能通过 mock 来伪造依赖，需要运行在开发机或者模拟器上。

参考 Building Instrumented Unit Tests

Instrumented 测试或者称为仪表测试是运行在物理设备或者模拟器上，可以利用 Android 框架 API 及支持 API，如 Android 测试支持库。如果你的测试需要访问运行时仪表信息如 APP 的 Context，或者你的测试需要真实的 Android 框架组件实现如 Parcelable 或 SharedPreferences 对象，则你应该创建 Instrumented 测试。

使用 Instrumented 单元测试可以帮助你减少编写和维护 mock 代码。当然你也可以自由的使用上一节的 mocking 框架来模拟任何依赖关系。

配置测试环境

在你的 Android Studio 工程中，你必须将 Instrumented 测试代码保存在 module-name/src/androidTest/java/ 目录下。在你创建工程时这个目录已经被默认创建，同时包含了一个 Instrumented 测试示例代码。

在你开始前，你应该先在 Android SDK 里下载 Android Testing Support Library，这个支持库提供了一些API 允许你快速的编写和运行 instrumented 测试代码。此测试支持库包含了 JUnit 4 test runner (AndroidJUnitRunner ) 和 UI 测试工具 (Espresso 和 UI Automator) 的 API。

和本地单元测试一样，为了访问测试支持库提供的 API，你也需要配置测试依赖。为了简化你的测试开发，你应该包含 Hamcrest 库，使用这个库的匹配器 API，你可以创建更灵活的断言。

在顶层的 build.gradle 文件中，你需要指定如下依赖库：

dependencies {
androidTestCompile 'com.android.support:support-annotations:24.0.0'
androidTestCompile 'com.android.support.test:runner:0.5'
androidTestCompile 'com.android.support.test:rules:0.5'
// Optional -- Hamcrest library
 androidTestCompile 'org.hamcrest:hamcrest-library:1.3'
// Optional -- UI testing with Espresso
 androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
// Optional -- UI testing with UI Automator
 androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.2'
}

注意： 如果你的配置中引入了 support-annotations 编译依赖库和 espresso-core 测试编译依赖库，那么你可能会遇到依赖冲突的失败提示。为了修改这个问题，你需要更新 espresso-core 依赖如下：

androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
})

要使用 JUnit 4 测试类，请确保指定 AndroidJUnitRunner 为默认的仪表测试执行者，可以在 app 模块下的 build.gradle 文件中加入如下代码：

android {
defaultConfig {
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
}

创建 Instrumented 单元测试类

你的 Instrumented 单元测试类应该按照 JUnit 4 测试类格式编写。要了解更多创建 JUnit 4 测试类和使用 JUnit 4 断言和注解，请阅读上一节本地单元测试中创建本地单元测试类的内容。

要创建一个 instrumented JUnit 4 测试类，你需要为该类开头添加一个 @RunWith(AndroidJUnit4.class) 的注解。如下示例代码展示了一个用来测试 LogHistory 类是否正确实现 Parcelable 接口的 instrumented 单元测试。

import android.os.Parcel;
import android.support.test.runner.AndroidJUnit4;
import android.util.Pair;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.List;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;
@RunWith(AndroidJUnit4.class)
@SmallTest
public class LogHistoryAndroidUnitTest {
public static final String TEST_STRING = "This is a string";
public static final long TEST_LONG = 12345678L;
private LogHistory mLogHistory;
@Before
public void createLogHistory() {
mLogHistory = new LogHistory();
}
@Test
public void logHistory_ParcelableWriteRead() {
// Set up the Parcelable object to send and receive.
 mLogHistory.addEntry(TEST_STRING, TEST_LONG);
// Write the data.
 Parcel parcel = Parcel.obtain();
mLogHistory.writeToParcel(parcel, mLogHistory.describeContents());
// After you're done with writing, you need to reset the parcel for reading.
 parcel.setDataPosition(0);
// Read the data.
 LogHistory createdFromParcel = LogHistory.CREATOR.createFromParcel(parcel);
List<Pair<String, Long>> createdFromParcelData = createdFromParcel.getData();
// Verify that the received data is correct.
 assertThat(createdFromParcelData.size(), is(1));
assertThat(createdFromParcelData.get(0).first, is(TEST_STRING));
assertThat(createdFromParcelData.get(0).second, is(TEST_LONG));
}
}

创建测试套件

要组织 instrumented 单元测试，开发者可以将这些测试分组，之后将这些测试一起执行。测试套件可以被嵌套，测试套件可以和其他测试套件组合在一起来同时测试其他类组件。

一个测试套件被包含在一个测试包中，类似于 main 应用包。按惯例，测试套件的包名通常会以 .suite 结尾，例如 com.example.android.testing.mysample.suite。

要为单元测试创建一个测试套件，请导入 JUnit RunWith 和 Suite 类。在你的测试套件类中，添加 @RunWith(Suite.class) 和 @Suite.SuitClasses() 注解。然后将独立的测试类或测试套件加入到 @Suite.SuiteClasses() 的参数中。下面示例代码展示了一个名称为 UnitTestSuite 的测试套件，它包含了 CalculatorInstrumentationTest and CalculatorAddParameterizedTest 两个单元测试。

import com.example.android.testing.mysample.CalculatorAddParameterizedTest;
import com.example.android.testing.mysample.CalculatorInstrumentationTest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
// Runs all unit tests.
@RunWith(Suite.class)
@Suite.SuiteClasses({CalculatorInstrumentationTest.class,
CalculatorAddParameterizedTest.class})
public class UnitTestSuite {}

运行 Instrumented 单元测试

请按照如下步骤运行 Instrumented 单元测试：

1. 确保你的工程和 Gradle 保持同步，点击工具栏的 Sync Project 按钮。

2. 按照以下步骤之一运行测试：

只运行一个测试，打开 Project 窗口，在这个测试上点击右键再点击 Run
要测试某个类的所有测试，右键点击这个类或者类中的一个方法，再点击 Run
要测试某个目录中的所有测试，右键点击这个目录，再选择 Run tests

位于默认位置 (src/androidTest/java/) 的 Instrumented 测试代码会被 Android Gradle 插件编译，生成一个测试 APK 和一个生产 APK 文件，同时安装两个 APK 文件到已连接的设备或模拟器，然后运行测试。之后 Android Studio 会在 Run 窗口展示 Instrumented 测试的执行结果。

3. 自动化用户界面测试

本小节介绍如何编写运行于单 APP 和多个 APP ，用于验证用户交互处理是否正确的测试。

参考 Automating User Interface Tests

用户界面(UI) 测试可以确保应用满足功能要求，同时也验证应用具有较高的质量，由此保证应用能够成功被用户接受。

一个简单的 UI 测试方法是让测试人员在目标应用上执行一系列预定的用户操作，然后验证应用行为是否符合预期。然而，这种人工方式有很多缺点如耗时、乏味、容易出错。一个更高效的方法是编写可以运行触发特定操作的自动化 UI 测试。自动化测试的方法有很多优点如快速、可靠、可重复。

要自动化UI 测试你的应用，你需要将测试代码放置到 (src/androidTest/java) 目录。Android 的 Gradle 插件会基于你的测试代码编译一个测试 app，然后将它加载到目标设备上。你可以在你的测试代码中，使用 UI 测试框架模拟用户行为来操作目标应用，达到测试特定使用场景的目的。

一般会创建两种 Android 应用自动化 UI 测试：

1. 单应用 UI 测试：这种测试用来验证目标应用在用户执行某特定操作或输入后能得到期望的行为。例如验证点击了设置菜单可以跳转到设置界面。这种测试允许开发者检查目标应用是否能在用户交互后响应了正确的界面。 UI 测试框架如 Espresso 允许开发者通过编程模拟用户操作并测试复杂的应用内用户交互行为。

2. 跨应用 UI 测试：这种测试用来验证多个应用之间的交互行为或应用于系统之间的交互行为。例如，开发者可以测试相机应用将图片分享给三方的社交媒体应用或分享给 Android 默认相册应用行为是否正确。支持跨应用的 UI 测试框架如 UI Automator 允许你创建此类场景的测试。

本节后的内容将介绍如何使用 Android 测试支持库提供的工具和 API 来编写这些自动化测试。开始之前你应该已经按照上文配置测试环境的内容下载安装了测试支持库。

3.1. 单应用 UI 测试 - Espresso

测试单应用的用户交互行为可以帮助开发者确保用户在与应用交互时不会遇到不期望的结果或者糟糕的用户体验。如果开发者需要验证应用的用户界面功能正常，则应该习惯于创建用户界面测试。

由 Android 测试支持库提供的 Espresso 测试框架，提供了编写 UI 测试的 API 来模拟单应用用户交互行为。 Espresso 库可以运行在 Android 2.3.3 (API level 10) 和更高的设备上。在测试应用时使用 Espresso 的一个关键的好处是它提供了自动化同步测试行为。Espresso 检测到应用的主线程空闲后，会寻找合适的时机运行你的测试命令，这样提高了开发者编写的测试的可靠性。这种特性同时可以将开发者从不得不增加如 Thread.sleep() 延时到测试代码的应急方案中解放出来。

配置 Espresso

开始编写 Espresso UI 测试前，开发者需要确保正确放置测试代码到目录，并且已经添加了工程依赖，如上文中配置测试环境的内容。

在你 app 模块的 build.gradle 文件中，你必须已经配置了 Espresso 库依赖：

dependencies {
// Other dependencies ...
 androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

关闭测试设备中的动画效果 – 当测试设备中有系统动画时，可能会引起不可预料的结果而导致你的测试失败。在设备或模拟器中的 设置 - 开发者选项 中关闭所有的下列动画选项：

Window animation scale
Transition animation scale
Animator duration scale

如果你想要配置你的工程使用所有的 Espresso 功能而不仅仅是核心提供的 API，请阅读这里的资源。

创建 Espresso 测试类

请遵守如下编程模型来创建一个 Espresso 测试类：

1. 通过 onView() 方法找到你想要测试的 Acvitivity UI 组件，或者onData() 方法找到AdapterView中的元素。例如应用中的登录按钮。

2. 通过 ViewInteraction.perform() 或 DataInteraction.perform()方法模拟一个特定的用户交互操作例如点击登录按钮。要序列化的在该组件上执行多个操作，可以在方法中使用逗号分隔的列表参数。

3. 如果有必要，重复上边的步骤，来模拟用户在多个 Activity 间操作目标应用。

4. 使用 ViewAssertions 方法来检查上述交互操作执行后 UI 返回了期望的状态或行为。

这几步在下文会有更加详细的描述。下面示例是一个基本的代码片段：

onView(withId(R.id.my_view)) // withId(R.id.my_view) is a ViewMatcher
 .perform(click()) // click() is a ViewAction
 .check(matches(isDisplayed())); // matches(isDisplayed()) is a ViewAssertion

结合 ActivityTestRule 使用 Espresso

下面部分描述了如何创建一个 JUnit 4 风格的 Espresso 测试，以及如何使用 ActivityTestRule 来减少重复的代码。通过使用 ActivityTestRule，测试框架会为每个注解为 @Test 的方法运行要测试的 Activity。测试前，注解为 @Before 的所有方法都会被执行。在每个测试完成后，所有注解为 @After 的方法都会被执行，之后测试框架会关闭 Activity。

package com.example.android.testing.espresso.BasicSample;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
...
@RunWith(AndroidJUnit4.class)
@LargeTest
public class ChangeTextBehaviorTest {
private String mStringToBetyped;
@Rule
public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>(
MainActivity.class);
@Before
public void initValidString() {
// Specify a valid string.
 mStringToBetyped = "Espresso";
}
@Test
public void changeText_sameActivity() {
// Type text and then press the button.
 onView(withId(R.id.editTextUserInput))
.perform(typeText(mStringToBetyped), closeSoftKeyboard());
onView(withId(R.id.changeTextBt)).perform(click());
// Check that the text was changed.
 onView(withId(R.id.textToBeChanged))
.check(matches(withText(mStringToBetyped)));
}
}

访问 UI 组件

在 Espresso 与应用交互前，开发者必须指定 UI 组件或 *view*， Espresso 支持使用 Hamcrest matchers 来匹配查找应用或者 adapter 中的 view 。

要找到 view，使用 onView() 方法并传入一个你的目标视图的 view matcher。在下一节指定一个 view matcher 有更详细的介绍。 onView() 方法会返回一个 ViewInteraction 对象来允许开发者的测试和视图交互。然而，如果你想要获取一个 RecyclerView 中的视图，调用 onView() 方法可能会失效。在这种场景下，应该使用下文的在 AdapterView 中获取视图的方法。

注意： onView() 方法不会检查开发者指定的视图是否有效，Espresso 也仅在当前的布局层搜索匹配，如果找不到视图则会抛出一个 NoMatchingViewException 异常。

下面的代码片段展示了开发者如何编写一个测试来访问一个 EditText 成员，输入一个字符串，关闭虚拟键盘，然后执行一个按钮点击。

public void testChangeText_sameActivity() {
// Type text and then press the button.
 onView(withId(R.id.editTextUserInput))
.perform(typeText(STRING_TO_BE_TYPED), closeSoftKeyboard());
onView(withId(R.id.changeTextButton)).perform(click());
// Check that the text was changed.
 ...
}

指定一个视图匹配器 View Matcher

开发者可以使用如下方法来指定一个视图匹配器：

使用 ViewMatchers 类中的方法，例如，要查找一个显示了某字符串的视图，可以使用如下方法：
```
onView(withText("Sign-in"));
```

类似的可以使用 withId() 方法并提供视图的资源 ID (R.id) 如下所示：

 onView(withId(R.id.button_signin));

Android 的资源 ID 在设计上并不是唯一的。如果开发者编写的测试尝试匹配一个被多个视图使用了的资源 ID Espresso 则会抛出 AmbiguousViewMatcherException 异常。

使用 Hamcrest Matchers 类。可以使用 allOf() 方法来连接多个匹配器，如 containsString() 和 instanceOf() 。这个方法允许开发者更精确的过滤匹配结果，如下代码所示：
```
onView(allOf(withId(R.id.button_signin), withText("Sign-in")));
```

可以使用 not 关键字来过滤不匹配的视图，如下代码所示：

 onView(allOf(withId(R.id.button_signin), not(withText("Sign-out"))));

要在代码中使用这些方法，请导入 org.hamcrest.Matchers 包。要学习更多关于 Hamcrest 匹配器的内容，请阅读 Hamcrest 网站。

在 AdapterView 中查找视图

在一个 AdapterView 部件中，子视图是被运行时动态加载的。如果要测试的目标视图在 AdapterView (例如 ListView, GridView, 或 Spinner) 中， onView() 可能会失效，因为可能只有视图的一部分被加载在可见布局层。

取而代之的，可以使用 onData() 方法来获取一个 DataInteraction 对象然后访问目标视图元素。 Espresso 会处理加载目标视图到当前的视图层。 Espresso 同样会处理目标视图元素的滚动操作，同时将目标视图聚焦。

注意： onData() 方法不会检查开发者指定的数据对应于某个视图。 Espresso 只在当前视图层查找。如果没有找到任何匹配，将会抛出 NoMatchingViewException 异常。

下面的代码展示了如何使用 onData() 方法和 Hamcrest 来匹配查找包含给定字符串的行。在这个例子中 LongListActivity 类包含了由 SimpleAdapter 暴露的字符串列表。

onData(allOf(is(instanceOf(Map.class)),
hasEntry(equalTo(LongListActivity.ROW_TEXT), is("test input")));

模拟或执行用户操作

使用 ViewInteraction.perform() 或 DataInteraction.perform() 方法来模拟用户在 UI 组件上的交互行为。开发者必须在参数中传递一个或多个 ViewAction 对象，Espresso 会按照给定的参数顺序在主线程执行每个操作。

ViewActions 类提供了一系列的帮助方法用来模拟常见行为。开发者可以使用这些方法来快捷方便的模拟行为而不是自己去创建配置独立的 ViewAction 对象。包括如下行为：

ViewActions.click()：点击视图。
ViewActions.typeText()：点击视图并输入字符串。
ViewActions.scrollTo()：滚动到视图，目标视图必须是 ScrollView 子类而且它的android:visibility 属性必须是 VISIBLE。对于扩展了 AdapterView (如 ListView) 的视图，onData() 方法会处理好滚动。
ViewActions.pressKey()：执行一个特定的按键事件。
ViewActions.clearText()：清除目标上的字符。

如果目标视图在 ScrollView 内，执行 ViewActions.scrollTo() 操作会先将目标视图展示到屏幕上，再执行其他操作。如果视图已经被显示在界面上。则 ViewActions.scrollTo() 操作不会执行任何动作。

使用 Espresso Intents 隔离测试 Activity

Espresso Intents 可以验证并保持应用发出的 Intent 。使用Espresso Intents ，开发者可以拦截并保持发出的 Intent 和返回的结果，并发送他们到要测试的组件，从而达到隔离测试 app、activity、或 service 的目的。

要使用 Espresso Intents 做测试，需要添加如下内容到应用的 build.gradle 文件：

dependencies {
// Other dependencies ...
 androidTestCompile 'com.android.support.test.espresso:espresso-intents:2.2.2'
}

要测试一个 Intent ，你需要创建一个类似于 ActivityTestRule 的 IntentsTestRule 类实例。IntentsTestRule 会在每个测试前初始化 Espresso Intents ，终止 activity ，并在每次测试完成后释放 Espresso Intents 。

如下测试类代码片段展示了如何测试 intent ，它测试了 Building Your First App 教程中创建的 activity 和intent。

@Large
@RunWith(AndroidJUnit4.class)
public class SimpleIntentTest {
private static final String MESSAGE = "This is a test";
private static final String PACKAGE_NAME = "com.example.myfirstapp";
/* Instantiate an IntentsTestRule object. */
@Rule
public IntentsTestRule<MainActivity> mIntentsRule =
new IntentsTestRule<>(MainActivity.class);
@Test
public void verifyMessageSentToMessageActivity() {
// Types a message into a EditText element.
 onView(withId(R.id.edit_message))
.perform(typeText(MESSAGE), closeSoftKeyboard());
// Clicks a button to send the message to another
 // activity through an explicit intent.
 onView(withId(R.id.send_message)).perform(click());
// Verifies that the DisplayMessageActivity received an intent
 // with the correct package name and message.
 intended(allOf(
hasComponent(hasShortClassName(".DisplayMessageActivity")),
toPackage(PACKAGE_NAME),
hasExtra(MainActivity.EXTRA_MESSAGE, MESSAGE)));
}
}

更多关于 Espresso Intents 的内容，请阅读 Espresso Intents documentation on the Android Testing Support Library 网站。你也可以下载并阅读 IntentsBasicSample 和 IntentsAdvancedSample 代码示例。

使用 Espresso Web 测试 WebView

Espresso Web 可以用来测试 Activity 内的 WebView 组件。它使用 WebDriver API 来检查和控制 WebView 的行为。

开始使用 Espresso Web 前，你需要添加如下依赖到 app 的 build.gradle 文件：

dependencies {
// Other dependencies ...
 androidTestCompile 'com.android.support.test.espresso:espresso-web:2.2.2'
}

使用 Espresso Web 创建测试，实例化 ActivityTestRule 对象来测试 activity 时，开发者需要启用 WebView 上的 JavaScript 支持。在测试中，开发者可以选择展示在 WebView 上的 HTML 元素，然后模拟用户交互行为。例如可以在一个 text box 中输入字符然后点击一个按钮。当操作执行完成后，开发者可以验证网页上的结果是不是符合预期。

在下面的代码中，测试了一个 ID 为 ‘webview’ 的 WebView 。测试单元verifyValidInputYieldsSuccesfulSubmission() 选择了网页上的一个 <input> 元素，输入一些字符，然后检查出现在另一个元素上的字符串。

@LargeTest
@RunWith(AndroidJUnit4.class)
public class WebViewActivityTest {
private static final String MACCHIATO = "Macchiato";
private static final String DOPPIO = "Doppio";
@Rule
public ActivityTestRule mActivityRule =
new ActivityTestRule(WebViewActivity.class,
false /* Initial touch mode */, false /* launch activity */) {
@Override
protected void afterActivityLaunched() {
// Enable JavaScript.
 onWebView().forceJavascriptEnabled();
}
}
@Test
public void typeTextInInput_clickButton_SubmitsForm() {
// Lazily launch the Activity with a custom start Intent per test
 mActivityRule.launchActivity(withWebFormIntent());
// Selects the WebView in your layout.
 // If you have multiple WebViews you can also use a
 // matcher to select a given WebView, onWebView(withId(R.id.web_view)).
 onWebView()
// Find the input element by ID
 .withElement(findElement(Locator.ID, "text_input"))
// Clear previous input
 .perform(clearElement())
// Enter text into the input element
 .perform(DriverAtoms.webKeys(MACCHIATO))
// Find the submit button
 .withElement(findElement(Locator.ID, "submitBtn"))
// Simulate a click via JavaScript
 .perform(webClick())
// Find the response element by ID
 .withElement(findElement(Locator.ID, "response"))
// Verify that the response page contains the entered text
 .check(webMatches(getText(), containsString(MACCHIATO)));
}
}

要学习更多关于 Espresso Web 的内容，请阅读 Espresso Web documentation on the Android Testing Support Library 网站。你也可以下载并阅读 Espresso Web 示例代码。

验证结果

调用 ViewInteraction.check() 或 DataInteraction.check() 方法来断言用户界面符合期望的状态。开发者必须将 ViewAssertion 对象作为参数传入。如果断言失败，Espresso 会抛出一个 AssertionFailedError 错误。

ViewAssertions 类提供了一些列一般场景断言的帮助方法。可以使用的断言包括：

doesNotExist: 断言当前视图界面不存在指定的视图。
matches: 断言指定的视图存在于当前的视图层且它的状态匹配给定的 Hamcrest 匹配器。
selectedDescendentsMatch：断言父视图中存在指定的子视图，且它的状态匹配给定的 Hamcrest 匹配器。

如下代码片段展示了如何验证上文中输入字符到 EditText 成员后显示的字符串：

public void testChangeText_sameActivity() {
// Type text and then press the button.
 ...
// Check that the text was changed.
 onView(withId(R.id.textToBeChanged))
.check(matches(withText(STRING_TO_BE_TYPED)));
}

在设备或模拟器运行 Espresso 测试

开发者可以从 Android Studio 或命令行运行 Espresso 测试。请确保已按照上文内容指定 AndroidJUnitRunner 作为工程默认的 instrumentation runner 。要运行 Espresso 测试，请参考上文 运行 Instrumented 单元测试。

3.2. 跨应用 UI 测试 - UI Automator

一个支持跨应用的 UI 测试可以让开发者验证应用在与其他应用或与系统交互时行为正常。例如，一个消息应用让用户输入一些文本，启动 Android 联系人选择器，然后用户可以选择消息的接收人，然后再返回到原应用控制，让用户提交信息。

本小结将说明如何使用 Android 测试支持库提供的 UI Automator 测试框架来编写此类 UI 测试。UI Automator API 允许开发者与设备上的可见元素交互，而不管哪个 Activity 正持有焦点。测试可以通过方便的描述方法查找 UI 组件，如组件显示的文本或组件的内容描述。UI Automator 测试可以运行在 Android 4.3 (API 18) 及更高本版的设备上。

UI Automator 测试框架是一个基于 instrumentation 的 API 且运行在 AndroidJUnitRunner 测试执行者上。

配置 UI Automator

在开始编写你的 UI 测试前，请先确保已经正确配置了工程依赖及测试代码存放路径，如上文开始测试内容。

在工程的 app 模块 build.gradle 文件中，你需要配置 UI Automator 的库依赖。

dependencies {
...
androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.1'
}

编写 UI Automator 测试前，开发者需要先检查目标 app 的 UI 组件并确保它们可以被访问。下面两个小节将介绍这些优化的要点。

检查设备上的 UI

在开始设计的测试前，开发者需要检查设备上的 UI 组件是可见的。为了确保 UI Automator 测试可以访问这些组件，请检查这些组件有可见的文字标签，android:contentDescription 值。

uiautomatorviewer 工具提供了一个便利的可视化界面检查工具来查看在设备前台显示的组件的属性。有了这些信息就可以创建更高细粒度的 UI Automator 测试。例如，开发者可以创建一个匹配特定可见属性的 UI 选择器。

按照以下步骤运行 uiautomatorviewer 工具：

1. 在物理设备上运行目标 app。

2. 将设备与开发计算机连接。

3. 打开终端窗口并进入 <android-sdk>/tools/ 目录。

4. 运行命令 uiautomatorviewer

要查看应用的 UI 属性，请按照如下步骤：

1. 在 uiautomatorviewer 界面，点击 Device Screenshot 按钮。

2. 在 uiautomatorviewer 工具里，移动鼠标到快照左侧面板来查看 UI 组件，组件属性将在右下面板显示，布局层次将在右上面板显示。

3. 可选的，点击 Toggle NAF Nodes 按钮来查看不可访问的 UI 组件，这些组件可能只会显示组件的部分可用信息。

确保 Activity 可被访问

UI Automator 测试框架在实现了 Android 可访问性功能的应用上表现的更好。当开发者使用一个视图元素 View 或者一个继承了 View 的子类时，就不需要实现可访问性支持，因为 SDK 或支持库已经在这些类里实现了此功能。

有些应用会使用自定义个 UI 元素来提供一个更丰富的用户体验。这些元素不会提供自动的可访问性支持。如果开发者的应用包含了非 SDK 或支持库 View 子类的实例，请确保已经按照如下步骤实现了可访问性功能：

1. 创建一个继承自 ExploreByTouchHelper 的实现类。

2. 通过调用 setAccessibilityDelegate() 方法将自定义的 UI 元素实例关联。

要学习更多关于自定义视图增加可访问性的功能，请阅读 Building Accessible Custom Views 。要学习更多关于 Android 可访问性的最佳实践，请阅读 Making Apps More Accessible 。

创建 UI Automator 测试

UI Automator 测试类的编写应该和 JUnit 4 测试类一致。要学习更多关于创建 JUnit 4 测试类和使用 Junit4 断言及注解，请阅读上文的创建 Instrumented 单元测试类。

在类的声明部分前增加 @RunWith(AndroidJUnit4.class) 注解。开发者同样需要指定由 Android 测试支持库提供的 AndroidJUnitRunner 类为默认的测试运行者。

请遵循如下变成模型来编写 UI Automator 测试类：

1. 通过 getInstance() 方法获取测试设备的 UIDevice 对象，同时传入一个 Instrumentation 对象参数。

2. 通过 findObject() 方法获取一个 UiObject 对象来访问设备上显示的 UI 组件。

3. 通过 UiObject 的方法如 performMultiPointerGesture() (模拟多点手势) 或 setText() (编辑文本) 模拟一个特定的用户交互行为。如果有必要，可以重复使用 API 重复创建步骤 2 和步骤 3 中的操作来实现更复杂的用户交互行为。

4. 执行用户交互行为后，检查 UI 反映结果是否符合预期的状态或行为。

这些步骤将在下面几小节详细描述。

访问 UI 组件

UiDevice 对象是开发者访问和操作设备状态的主要方式。在测试中，开发者可以调用 UiDevice 方法来检查不同的属性状态，例如当前的屏幕方向或显示大小。测试可以使用 UiDevice 对象执行设备级别的操作，如强制设备屏幕转向，按下 D-pad 硬件按钮，按下 Home 或菜单按钮。

从设备的主屏幕开始测试是个很好的做法。从主屏幕开始，开发者可以调用 UI Automator API 提供的方法来选择特定的 UI 组件并交互。如下代码片段展示了如何获取 UiDevice 实例并模拟按下 Home 按钮。

import org.junit.Before;
import android.support.test.runner.AndroidJUnit4;
import android.support.test.uiautomator.UiDevice;
import android.support.test.uiautomator.By;
import android.support.test.uiautomator.Until;
...
@RunWith(AndroidJUnit4.class)
@SdkSuppress(minSdkVersion = 18)
public class ChangeTextBehaviorTest {
private static final String BASIC_SAMPLE_PACKAGE
= "com.example.android.testing.uiautomator.BasicSample";
private static final int LAUNCH_TIMEOUT = 5000;
private static final String STRING_TO_BE_TYPED = "UiAutomator";
private UiDevice mDevice;
@Before
public void startMainActivityFromHomeScreen() {
// Initialize UiDevice instance
 mDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
// Start from the home screen
 mDevice.pressHome();
// Wait for launcher
 final String launcherPackage = mDevice.getLauncherPackageName();
assertThat(launcherPackage, notNullValue());
mDevice.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
LAUNCH_TIMEOUT);
// Launch the app
 Context context = InstrumentationRegistry.getContext();
final Intent intent = context.getPackageManager()
.getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
// Clear out any previous instances
 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
context.startActivity(intent);
// Wait for the app to appear
 mDevice.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
LAUNCH_TIMEOUT);
}
}

在示例代码中， @SdkSuppress(minSdkVersion = 18) 声明确保了测试只会运行在 Android 4.3 (API 18) 或更高的版本上，正如 UI Automator 框架所要求的那样。

使用 findObject() 方法获取一个展现在屏幕上，匹配了给定选择器的 UiObject 对象。如果需要，可以在代码中重复利用已经创建的 UiObject 实例。注意 UI Automator 测试框架会在每次使用 UiObject 点击或查询属性时在当前界面重新查找匹配。

如下代码展示了如何使用 UiObject 实例来操作应用中的 Cancel 按钮和 OK 按钮。

UiObject cancelButton = mDevice.findObject(new UiSelector()
.text("Cancel"))
.className("android.widget.Button"));
UiObject okButton = mDevice.findObject(new UiSelector()
.text("OK"))
.className("android.widget.Button"));
// Simulate a user-click on the OK button, if found.
if(okButton.exists() && okButton.isEnabled()) {
okButton.click();
}

指定选择器

请使用 UiSelector 类来访问特定的 UI 组件。如果找到了多个视图元素，布局层次中的第一个匹配元素将被返回为 UiObject 。构造 UiSelector 时，可以将多个属性串联来提炼查找。如果没有找到匹配的元素，将抛出 UiAutomatorObjectNotFoundException 异常。

可以使用 childSelector() 方法来嵌套多个 UiSelector 实例。例如下面代码展示了一个测试，在当前显示的视图中，找到第一个 ListView ，然后在这个 ListView 中查找匹配文本属性 Apps 的视图元素。

UiObject appItem = new UiObject(new UiSelector()
.className("android.widget.ListView")
.instance(0)
.childSelector(new UiSelector()
.text("Apps")));

作为最佳实践，开发者应该使用资源 ID 来指定一个选择器，而不是使用文本值或者内容描述。不是所有的视图元素都含有文本内容。文本选择器很脆弱，可能会在 UI 发生很小变化时导致测试失败。同样，文本选择器可能在多语言环境下失效，它们可能匹配不到翻译后的字符串。

在选择器中指定对象状态可能会很有用。例如可以通过 checked() 方法传入参数 true 选择列表中所有的已选择元素，然后可以取消这些元素的选择。

执行用户操作

当获取到 UiObject 对象后，开发者可以通过调用 UiObject 类中的方法来执行 UI 组件的用户交互行为。可以执行的操作包括：

click() : 点击可见 UI 与元素边界的中心位置。
dragTo() : 拖动对象到任意位置。
setText() : 清除内容并设置可编辑区域的文字；类似的 clearTextField() 方法清除可编辑区域的文字。
swipeUp() : 在 UiObject 对象上执行向上滑动操作。类似的 swipeDown(), swipeLeft(), 和 swipeRight() 会执行相应的操作。

UI Automator 测试框架允许开发者通过 getContext() 方法获得一个 Context 对象来发送 Intent 或启动 Activity ，不依赖 shell 命令。

下面代码片段展示了测试中如何发送一个Intent 来启动应用。当只对测试计算器应用感兴趣时，此方法非常有用，这个途径并不关心谁是启动器。

public void setUp() {
...
// Launch a simple calculator app
 Context context = getInstrumentation().getContext();
Intent intent = context.getPackageManager()
.getLaunchIntentForPackage(CALC_PACKAGE);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
// Clear out any previous instances
 context.startActivity(intent);
mDevice.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT);
}

在集合上执行操作

如果要模拟一个集合上（如音乐专辑里的歌曲或收件箱里的邮件）的用户操作，可以使用 UiCollection 类。要创建一个 UiCollection 对象，指定一个 UiSelector 来查找一个 UI 包装器或其他 UI 元素的包装器，如一个包含子 UI 元素的布局视图。

如下代码展示了如何构造一个 UiCollection ：

UiCollection videos = new UiCollection(new UiSelector()
.className("android.widget.FrameLayout"));
// Retrieve the number of videos in this collection:
int count = videos.getChildCount(new UiSelector()
.className("android.widget.LinearLayout"));
// Find a specific video and simulate a user-click on it
UiObject video = videos.getChildByText(new UiSelector()
.className("android.widget.LinearLayout"), "Cute Baby Laughing");
video.click();
// Simulate selecting a checkbox that is associated with the video
UiObject checkBox = video.getChild(new UiSelector()
.className("android.widget.Checkbox"));
if(!checkBox.isSelected()) checkbox.click();

在可滚动视图上执行操作

使用 UiScrollable 模拟垂直或水平滚动显示。UI 元素位于屏幕外时，需要滚动以将其置于视图中。如下的代码片段展示了模拟向下滚动设置菜单，然后点击一个 “About tablet” 选项：

UiScrollable settingsItem = new UiScrollable(new UiSelector()
.className("android.widget.ListView"));
UiObject about = settingsItem.getChildByText(new UiSelector()
.className("android.widget.LinearLayout"), "About tablet");
about.click();

验证结果

InstrumentationTestCase 类继承自 TestCase，所以可以使用 JUnit Assert 方法来测试 UI 组件返回了期望的结果。下面的代码片段展示了如何定位计算器应用中的多个按钮，然后按顺序点击，最后确认显示了正确的结果：

private static final String CALC_PACKAGE = "com.myexample.calc";
public void testTwoPlusThreeEqualsFive() {
// Enter an equation: 2 + 3 = ?
 mDevice.findObject(new UiSelector()
.packageName(CALC_PACKAGE).resourceId("two")).click();
mDevice.findObject(new UiSelector()
.packageName(CALC_PACKAGE).resourceId("plus")).click();
mDevice.findObject(new UiSelector()
.packageName(CALC_PACKAGE).resourceId("three")).click();
mDevice.findObject(new UiSelector()
.packageName(CALC_PACKAGE).resourceId("equals")).click();
// Verify the result = 5
 UiObject result = mDevice.findObject(By.res(CALC_PACKAGE, "result"));
assertEquals("5", result.getText());
}

在设备或模拟器运行 UI Automator 测试

开发者可以从 Android Studio 或命令行运行 UI Automator 测试。请确保已指定 AndroidJUnitRunner 作为工程默认的 instrumentation runner 。要运行 UI Automator 测试，请参考上文运行 Instrumented 单元测试。

4. 应用组件集成测试

本小节介绍如何编写用户不直接参与交互的组件测试，如 Service 和 Content provider。

参考 Testing App Compontent Integrations

如果应用使用了用户不会直接参与交互的组件，例如 Service 和 Content Provider，则应当验证应用内的这些组件行文正确。

当开发这些组件时，编写验证这些组件功能是否正确的集成测试是个好习惯。

注意： Android 没有提供独立 BroadcastReceiver 的测试类。要验证 BroadcastReceiver 响应，需要测试发送出 Intent 对象的组件。另外，可以通过 InstrumentationRegistry.getTargetContext() 方法创建一个 BroadcastReceiver 的实例，然后测试 BroadcastReceiver 的方法 ( 通常是 onReceive() 方法 ) 。

这一节将介绍如何使用 Android 平台提供的 API 和工具编写自动化集成测试。

4.1. 测试 Service

如果实现了一个本地 Service 作为应用的一个组件，那么开发者应当通过测试确保它按照预期的行为运行。可以创建 instrumented 单元测试来验证 Service 中的行为正确。例如，服务储存并返回了有效的数据同时数据操作正确。

Android 测试支持库提供了隔离测试 Service 对象的 API， ServiceTestRule 类是一个用来在测试运行前启动Service 并在测试结束后完成 Service 的 JUnit 4 规则。通过这个测试规则，可以确保在每次测试运行前，已建立到服务的连接。

注意： ServiceTestRule 类不提供对 IntentService 对象测试的支持。如果需要测试一个 IntentService 对象，请将它的逻辑实现分离到另一个独立的类里，然后创建类的单元测试。

配置测试环境

请参考上文的配置测试环境内容。

创建一个 Service 的集成测试

Service 的集成测试应该被写作 JUnit 4 测试类的格式。要创建一个 Service 的测试，请在测试类的声明前增加 @RunWith(AndroidJUnit4.class) 注解。同时，如上文内容所述，需要指定 AndroidJUnitRunner 类为默认的测试运行者。

然后通过 @Rule 注解，创建一个 ServiceTestRule 实例：

@Rule
public final ServiceTestRule mServiceRule = new ServiceTestRule();

如下代码片段展示了如何实现一个 service 的集成测试。测试方法 testWithBoundService 验证了应用是否成功绑定到一个本地服务，同时验证了服务接口行为是否正确。

@Test
public void testWithBoundService() throws TimeoutException {
// Create the service Intent.
 Intent serviceIntent =
new Intent(InstrumentationRegistry.getTargetContext(),
LocalService.class);
// Data can be passed to the service via the Intent.
 serviceIntent.putExtra(LocalService.SEED_KEY, 42L);
// Bind the service and grab a reference to the binder.
 IBinder binder = mServiceRule.bindService(serviceIntent);
// Get the reference to the service, or you can call
 // public methods on the binder directly.
 LocalService service =
((LocalService.LocalBinder) binder).getService();
// Verify that the service is working correctly.
 assertThat(service.getRandomInt(), is(any(Integer.class)));
}

运行 Service 集成测试

开发者可以从 Android Studio 或命令行运行 Service 集成测试。请确保已指定 AndroidJUnitRunner 作为工程默认的 instrumentation runner 。要运行 Service 集成测试，请参考上文运行 Instrumented 单元测试。

4.2. 测试 Content Provider

如果实现了一个 content provider 来保存或获取数据，或向其他应用提供可访问的数据，开发者应当编写测试来确保 content provider 的行为正确无误。这一小节将介绍如何编写 content provider 测试。

创建 Content Provider 集成测试

在 Android 中，应用把 content provider 看作提供数据表的数据 API ，而看不到它们的内部实现。一个内容提供者可能有很多公共常量，但是很少有 public 方法或 public 变量。因为这个原因，需要编写只基于 provider 公开成员的测试。

Content Provider 允许访问实际的用户数据，因此对 content provider 的测试应该在隔离环境，这同样意味着测试不应该修改实际的用户数据。例如，应该避免由于之前的测试遗留数据导致当前测试失败。同样的，测试应该避免增加或删除 provider 的实际数据。

为了将 content provider 隔离，需要使用 ProviderTestCase2 类。这个类允许开发者使用 Android mock 对象类，如 IsolatedContext 和 MockContentResolver 来访问文件和数据库信息而不影响真实用户数据。

Content Provider 的集成测试应该编写为 JUnit 4 测试类，更多关于创建 JUnit 4 测试类和使用 JUnit 4 断言，请阅读上文中创建本地单元测试类的内容。

要创建 content provider 的集成测试，请按照如下几个步骤：

创建一个继承自 ProviderTestCase2 的子类。
类声明部分前添加 @RunWith(AndroidJUnit4.class) 注解。
指定 AndroidJUnitRunner 类为默认的测试执行者。

从 InstrumentationRegistry 设置 Context 对象，如下所示：

@Override
protected void setUp() throws Exception {
setContext(InstrumentationRegistry.getTargetContext());
super.setUp();
}

ProviderTestCase2 是如何工作的

通过 ProviderTestCase2 的子类测试 provider，这个类继承自 AndroidTestCase，所以它提供了 JUnit 测试框架和用来测试应用的 Android 特定方法。这个类的最重要的一个功能是在它初始化时创建了一个独立的测试环境。

初始化过程是在 ProviderTestCase2 的构造器中完成的，ProviderTestCase2 构造器创建了一个 IsolatedContext 对象，以允许文件和数据库操作与 Android 系统隔离。文件和数据库操作会被放在设备或模拟器的一个有特殊前缀的独立目录中。

之后构造器会创建一个 MockContentResolver 来作为测试的 resolver。最终，构造器创建一个 provider 实例用来测试。这是一个普通的 ContentProvider 对象，同时它从 IsolatedContext 中获取所有的环境信息。由此 provider 被限制在独立的测试环境中。

Content Provider 的集成测试和 instrumented 单元测试一致，要运行 integration 测试，请参考上文运行 integration 测试的内容。

测试什么

如下是几条测试 content provider 的具体指导：

使用 Resolver 方法测试：即使开发者可以在 ProviderTestCase2 中实例化一个 provider 对象，也应该使用一个 resolver 对象及适当的 URI 测试 provider。使用 resolver 可以确保开发者像常规应用交互那样测试 provider 。
像合约一样测试一个公开的 provider，如果开发者期望 provider 公开的被其他应用访问，则需要将它作为一个合约测试，一些如何做的例子如下：
- 测试 provider 暴露的常量。例如，检查 provider 数据表的栏目名常量，这些数据库字段名总是公开的常量。
- 测试所有 provider 提供的 URI。provider 可能提供多个 URI，每个 URI 代表着不同的数据。
- 测试无效 URI ：开发者的单元测试应该故意调用一个无效的 URI，来检查是否报错。一个好的 Provider 设计会为无效 URI 抛出 IllegalArgumentException 异常。
测试标准的 Provider 交互：大多数 Provider 提供六个方法： query(), insert(), delete(), update(), getType(), and onCreate()。开发者的测试应该验证所有的这些方法可以工作。这些方法在 Content Providers 中有更多描述。
测试业务逻辑：如果 content provider 实现了业务逻辑，则开发者需要测试它。

5. 测试 UI 性能

UI 性能测试不需要开发人员编写代码，请参考 Testing Display Performance

四. 代码覆盖率

代码覆盖率即 Code Coverage 是编写的测试代码完整度的衡量标准。一个完整的工程应该有代码覆盖率报告。

请参考 https://github.com/codecov/example-android

五. 参考资料

Testing Apps on Android

Testing UI for Multiple Apps

Android Architecture Blueprints

MainActivityTest.java

2017-08-01

Mockito 单元测试实例

Fri, 05 Oct 2018 11:54:49 +0800

Mockito 是一款优秀的 Java 单元测试库，本文介绍如何使用 Mockito 来编写 Android 本地单元测试。

mockito 库接入

添加 mockito 支持是很简单的，只需要在 build.gradle 中加入如下库依赖即可

testImplementation 'org.mockito:mockito-core:2.19.0'

代码实例

首先我们先来看一段日历主界面 EventAdapter 中的代码，这段代码是点击天气后的业务逻辑。

这段代码主要有三个逻辑：

根据配置拉起天气应用
没有天气应用时拉起市场安装应用
没有天气应用时根据配置拉起网页

这段代码包含了 EventAdpater 的成员 mWeatherController，通过它获取天气的配置；Context 是需要传入的上下文，另外两个参数是没有使用的预留参数，可以忽视。这不是一个静态的全局类，又依赖于 WeatherController 和 Context 要怎么测试呢？

public int performClick(Context context, WeatherView weatherView, Weather weather) {
try {
List<WeatherConf> weatherConfList = mWeatherController.loadWeatherConf();
for (WeatherConf conf : weatherConfList) {
try {
// 拉起应用
 Intent intent = new Intent();
intent.setClassName(conf.getPackageName(), conf.getActivityName());
context.startActivity(intent);
Action.WEATHER_CLICK.put(Attribute.PACKAGE.with(conf.getPackageName()))
.anchor(context);
Log.d(TAG, "onWeatherViewClicked: " + conf.getPackageName());
return WeatherEvent.CLICK;
} catch (Exception | Error e) {
e.printStackTrace();
}
}
Log.d(TAG, "onWeatherViewClicked: no package installed -> " + weatherConfList);
if (weatherConfList.size() > 0) {
WeatherConf weatherConf = weatherConfList.get(0);
if (weatherConf.getWebUrl() != null) {
// 拉起网页
 Intent intent = new Intent(Intent.ACTION_VIEW)
.setData(Uri.parse(weatherConf.getWebUrl()));
context.startActivity(intent);
Action.WEATHER_INSTALL.put(Attribute.PACKAGE.with(weatherConf.getWebUrl()))
.anchor(context);
Log.d(TAG, "onWeatherViewClicked: visit url " + weatherConf.getWebUrl());
return WeatherEvent.WEB_URL;
} else {
// 拉起应用市场安装应用
 Intent goToMarket = new Intent(Intent.ACTION_VIEW)
.setData(Uri.parse("market://details?id=" +
weatherConf.getPackageName()));
context.startActivity(goToMarket);
Action.WEATHER_INSTALL.put(Attribute.PACKAGE.with(weatherConf.getPackageName()))
.anchor(context);
Log.d(TAG, "onWeatherViewClicked: install " + weatherConf.getPackageName());
return WeatherEvent.INSTALL;
}
}
} catch (Exception | Error e) {
e.printStackTrace();
}
return WeatherEvent.NONE;
}

测试分析

通过普通的 Junit 单元测试是不能测试这个方法的，我们不能 new 一个 Context 出来，我们也不知道 new 一个 WeatherController 对象会有什么结果，也许这个类有严重的耦合和依赖关系，创建一个陌生的对象是不可预期的。这时我们就需要使用 mockito 来模拟这些依赖关系并在这些依赖类的方法被调用时做预期处理和检查断言。

我们有怎样的输入？阅读代码我们可以看到在执行过程中，mWeatherController.loadWeatherConf() 被执行，WeatherConf 是一个简单的数据模块类，可以轻松的 new 出来，我们需要在此方法被调用时返回这个对象的列表；我们需要输入一个模拟的上下文。整理的期望如下：

模拟上下文 Context 对象，WeatherView 和 Weather 对象无关紧要
模拟 mWeatherController 对象，并准备期望的数据

要覆盖到所有的逻辑分支，我们需要多种情况的输入和预期：

空的配置列表！这是一个边缘场景 –> 不做任何事
有效的配置列表，含有应用包名和主界面名，同时应用存在 –> 拉起应用
有效的配置列表，含有应用包名和主界面名，同时应用不存在 –> 拉起应用商店安装应用
有效的配置列表，含有应用包名、主界面名和拉起网页地址，同时应用不存在 –> 拉起网页

测试代码

准备工作

首先我们需要模拟依赖类，我们通过 mock 方法，将 EventAdapter 的依赖类都模拟出来，然后再创建一个 EventAdapter 的对象。因为每个单元测试都是独立无关的，而又都需要这些预置条件，我们可以将这部分代码抽出来放在 @Before 中作为公共部分，每次测试时都会重新走 @Before 方法，所以不需要担心数据被共享或混乱。

private Context mContext;
private AdController mAdController;
private FeedController mFeedController;
private WeatherController mWeatherController;
private EventAdapter mEventAdapter;
@Before
public void setup() {
mContext = mock(Activity.class);
mAdController = mock(AdController.class);
mFeedController = mock(FeedController.class);
mWeatherController = mock(WeatherController.class);
mEventAdapter = new EventAdapter(mAdController, mFeedController,
mWeatherController);
}

第一个场景

空的配置列表！这是一个边缘场景 –> 不做任何事

我们先模拟实际操作，添加一个 Weather 对象到 EventAdapter 中，然后断言只含有一个 Weather 对象。之后我们再检查执行 performClick() 方法执行后的返回值，我们期望 WeatherEvent.NONE 的结果。

@Test
public void testWeatherViewClickWithNoneConfig() {
List<Weather> weathers = new ArrayList<>();
Weather weather = new Weather();
weathers.add(weather);
mEventAdapter.reloadWeather(weathers);
assertEquals(1, mEventAdapter.getWeather().size());
WeatherView weatherView = mock(WeatherView.class);
assertEquals(WeatherEvent.NONE, mEventAdapter.performClick(mContext, weatherView, null));
}

第二个场景

有效的配置列表，含有应用包名和主界面名，同时应用存在 –> 拉起应用

我们需要创建一个 WeatherConf 对象，并设定预期的字段；然后我们需要设定，在 WeatherController.loadWeatherConf() 方法调用时会返回刚才创建的对象。

when(mWeatherController.loadWeatherConf()).thenReturn(weatherConfList);

之后，我们执行 performClick() 方法，并断言期望的返回值为 WeatherEvent.CLICK 。

assertEquals(WeatherEvent.CLICK, mEventAdapter.performClick(mContext, weatherView, null));

这个预期可能已经足够了，但是我们期望得到更细节的预期：真的拉起了应用吗？

最后，我们检查 Context.startActivity(Intent intent) 方法是否被执行，同时检查它的 Intent 参数是否是我们预设的字段。

// check startActivity() is called and check argument value
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext).startActivity(argument.capture());
assertEquals("Intent { cmp=com.example/.activity.MainActivity }", argument.getValue().toString());

这个测试场景的完整代码如下：

@Test
public void testWeatherViewClickWithInstalledPackageConfig() {
// add weather item
 List<Weather> weathers = new ArrayList<>();
Weather weather = new Weather();
weathers.add(weather);
mEventAdapter.reloadWeather(weathers);
assertEquals(1, mEventAdapter.getWeather().size());
// mock WeatherView
 WeatherView weatherView = mock(WeatherView.class);
List<WeatherConf> weatherConfList = new ArrayList<>();
WeatherConf weatherConf = new WeatherConf();
weatherConf.setActivityName("com.example.activity.MainActivity");
weatherConf.setPackageName("com.example");
weatherConfList.add(weatherConf);
when(mWeatherController.loadWeatherConf()).thenReturn(weatherConfList);
// check performClick() return value
 assertEquals(WeatherEvent.CLICK, mEventAdapter.performClick(mContext, weatherView, null));
// check startActivity() is called and check argument value
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext).startActivity(argument.capture());
assertEquals("Intent { cmp=com.example/.activity.MainActivity }",
argument.getValue().toString());
}

第三个场景

有效的配置列表，含有应用包名和主界面名，同时应用不存在 –> 拉起应用商店安装应用

这个场景和第二个场景类似，相同点不在赘述，只是我们需要在拉起应用时抛出一个运行时异常，然后才会走到拉起应用商店的代码：

// throw an no package found exception when startActivity() is called
doThrow(new RuntimeException("no package found")).when(mContext).startActivity(argThat(
new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Intent argument) {
return argument.toString().equals(
"Intent { cmp=com.example/.activity.MainActivity }");
}
}));

这个场景的完整测试代码如下：

@Test
public void testWeatherViewClickWithNoInstalledPackageConfig() {
// add weather item
 List<Weather> weathers = new ArrayList<>();
Weather weather = new Weather();
weathers.add(weather);
mEventAdapter.reloadWeather(weathers);
assertEquals(1, mEventAdapter.getWeather().size());
// mock WeatherView
 WeatherView weatherView = mock(WeatherView.class);
List<WeatherConf> weatherConfList = new ArrayList<>();
WeatherConf weatherConf = new WeatherConf();
weatherConf.setActivityName("com.example.activity.MainActivity");
weatherConf.setPackageName("com.example");
weatherConfList.add(weatherConf);
when(mWeatherController.loadWeatherConf()).thenReturn(weatherConfList);
// throw an no package found exception when startActivity() is called
 doThrow(new RuntimeException("no package found")).when(mContext).startActivity(argThat(
new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Intent argument) {
return argument.toString().equals(
"Intent { cmp=com.example/.activity.MainActivity }");
}
}));
// check performClick() return value
 assertEquals(WeatherEvent.INSTALL, mEventAdapter.performClick(mContext, weatherView, null));
// check startActivity() is called and check argument value is start app market
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext, times(2)).startActivity(argument.capture());
assertEquals(
"Intent { act=android.intent.action.VIEW dat=market://details?id=com.example }",
argument.getValue().toString());
}

第四个场景

有效的配置列表，含有应用包名、主界面名和拉起网页地址，同时应用不存在 –> 拉起网页

这个场景和前两个场景类似，只是输入的配置字段多了一个拉起链接，我们期望拉起的网页和我们输入的字段相同：

// check startActivity() is called and check argument value is start web view intent
ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext, times(2)).startActivity(argument.capture());
Intent intent = argument.getValue();
assertEquals("android.intent.action.VIEW", intent.getAction());
assertEquals("https://www.example.com/weather.html", intent.getData().toString());

这个场景的完整测试代码如下：

@Test
public void testWeatherViewClickWithNoInstalledPackageAndWithUrlConfig() {
// add weather item
 List<Weather> weathers = new ArrayList<>();
Weather weather = new Weather();
weathers.add(weather);
mEventAdapter.reloadWeather(weathers);
assertEquals(1, mEventAdapter.getWeather().size());
// mock WeatherView
 WeatherView weatherView = mock(WeatherView.class);
List<WeatherConf> weatherConfList = new ArrayList<>();
WeatherConf weatherConf = new WeatherConf();
weatherConf.setActivityName("com.example.activity.MainActivity");
weatherConf.setPackageName("com.example");
weatherConf.setWebUrl("https://www.example.com/weather.html");
weatherConfList.add(weatherConf);
when(mWeatherController.loadWeatherConf()).thenReturn(weatherConfList);
// throw an no package found exception when startActivity() is called
 doThrow(new RuntimeException("no package found")).when(mContext).startActivity(argThat(
new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Intent argument) {
return argument.toString().equals(
"Intent { cmp=com.example/.activity.MainActivity }");
}
}));
// check performClick() return value
 assertEquals(WeatherEvent.WEB_URL, mEventAdapter.performClick(mContext, weatherView, null));
// check startActivity() is called and check argument value is start web view intent
 ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
verify(mContext, times(2)).startActivity(argument.capture());
Intent intent = argument.getValue();
assertEquals("android.intent.action.VIEW", intent.getAction());
assertEquals("https://www.example.com/weather.html", intent.getData().toString());
}

总结

运行覆盖率检查，我们可以看到这个方法的业务逻辑已经被完全覆盖到了，可以说明这些测试代码是必要的。

从代码示例中也可以看出 mockito 的使用是很简单和强大的，可以帮助我们快速的开发测试代码，断言预期。同时通过这些测试，可以让我们明晰代码的依赖关系，避免编写出来耦合太多或依赖混乱的代码。

如何编写出不可测试的代码

Fri, 05 Oct 2018 11:50:23 +0800

这份指南列举了一些可以帮助你写出不可测试代码的原理或方法。或者，避免这些技术点可以帮助你写出可测试的代码。

创建你自己的依赖

不要传入对象实例，在方法中间执行 new 操作来实例化对象。这是一个邪恶的手段，因为无论何时，你在代码块中实例化一个对象然后使用它，任何想要测试这块代码的人都被强制使用这个你实例化的具体对象。他们不能注入一个假的或者其他 mock 对象来简化这个行为或对你做了什么做出断言。

重型构造器

创建做很多工作的构造方法，在构造函数中执行的工作越多，在测试夹具中创建对象就越困难。另外，如果你的构造器能够构建出其他比较难构建的对象，那就更好了！你应该期望每个构造方法的依赖传递性都是巨大的，巨大到难以测试。

依赖于特定的类

和特定的类做绑定 - 在任何可能的地方都避免使用接口。（接口可以让别人替换你使用的特定类为他们自己创建的类，他们的类可以实现接口或抽象类里的约定，想要写出好测试的家伙可能会这样做来测试你的代码 - 不要让这些家伙得逞！）

条件障碍

写冗长的 if 分支和 switch 声明，并总是对此感觉良好。这样做可以增加测试时需要覆盖的可能执行路径。这个条件圈越复杂，测试越困难！当有人建议使用多态替代条件时，嘲笑他们对测试的体贴。是条件分支即深又宽：如果你不能保持至少5个条件深度，你就是在喂养可测试代码给那些 TDD 狂热者。

依赖大型上下文对象

传递巨大的上下文对象（或难以构造的小型对象），这将降低方法的清晰度。myMethod(Context ctx) 不如 myMethod(User user, Label lable) 清晰。为了进行测试，需要创建，填充和传递上下文对象。

使用静态

静态，静态无处不在！它们在可测试性方面创造了巨大的危机。他们不能被模拟，同时是一个可以任意获取到的方法， OO (面向对象) 狂热者会说静态方法是其中一个参数应该拥有该方法的标志。但你是3v1L！

使用更多的静态

静态是一个非常强大的工具，可以使被感染 TDD 的工程师们屈服。静态方法不能被子类重写（有时编写一个子类重写方法是一个测试技术点）。当你使用静态方法时，它们不能被 mock 库模拟（掣肘亲测试工程师的另一个好办法）。

使用全局标志

为什么要明确调用一个方法？就像 L Ron Hubbard 那样，使用 “mind over matter” （精神高于物质）格言来在你的一段代码中设置一个标记，以便在你的应用程序的完全不同的部分产生影响（当你在不同的线程中同时这样做时，它会更有趣！）。测试人员会疯狂地试图弄清楚为什么突然之间有一个条件是 true，突然又变为 false。

到处使用单实例

为什么要显而易见的将依赖传递进来而不是使用单实例来隐藏这个依赖？建立一个需要单实例的测试时很难的，当所有测试都依赖于彼此的状态时，TDD 工程师们将会被刺痛到怀疑人生。

要防守 - 他们为了获取你的代码出击！

对传入方法、构造器和中间方法的参数状态采取防卫断言。如果有人能传入一个 null，那就说明你已经放松警惕。你看，有一些测试怪胎在那想要实例化你的对象，或者在测试中调用你的方法并传入 null！要积极防止这种情况发生：用铁拳捍卫你的代码！（同时铭记：如果获取到了你的代码，那他们就不是偏执狂了）

在任何可能的地方使用基本类型

每次需要一个值时，与其使用 曲奇饼对象，不如将基本类型传入后再做你需要的所有解析。基本类型需要人们解析和传递才能得到想要的数据，这使工作变得更艰难 – 而对象是可以伪造的（喘口气）同时也可以为空，并且可以封装状态（谁才会想要这样做？）。

查找你想要找的任何东西

通过随意的查找你可以确保你的对象处于霸主地位，它知道其他任何东西在哪。这样可以让测试开发困难一些，因为他必须模仿环境，以便你的代码能够掌握它所需要的东西。不要害怕你需要获取多少对象，查找的越多，测试越难伪造这些对象。如果你是 InvoiceTaxCalculator 类，随意做这样的调用 invoiceTaxCalculator.getUser().getDbManager().getCaRateTables().getSalesTaxRate()。当那些测试维尼告诉你关于 “依赖注入“、”得墨忒耳定律” 或者不要查找别的东西时，请捂住你的耳朵。

使用静态初始化

加载类时，做尽可能多地工作。当想要写测试的疯子们发现加载你的类会导致如网络或文件访问这些令人讨厌的东西时会变得抓狂。

将外部系统依赖和逻辑代码直接挂钩（耦合）

如果你的产品依赖于外部系统如数据库、文件系统或网络，请确保你的业务逻辑编码时引用了尽可能多的这些底层系统实现细节。这样可以阻止其他人不按照你的本意使用你的代码，（如运行2毫秒的小测试而不是5分钟）。

混合对象生命周期

长生命周期的对象引用短生命周期的对象。这使其他人感到困惑，因为长寿命对象在它不再有效或活着之后仍然引用它，这样做特别阴险，不仅是糟糕的设计，而且是邪恶的且难以测试。

副作用是个好帮手

你最好的选择是在您的方法中执行大量副作用生成操作，对于设置器来说尤其如此。副作用越不明显越好，特殊和看似不合理的副作用对单元测试特别有用。使用未初始化或初始化为无效状态的成员字段可以再为副作用锦上添花，一旦你实现这一点，请确保在设置器方法调用时访问这些未经初始化的成员，来产生段错误(SEGV)或空指针(NPE)。为什么要这么做？干净的、可读的代码然后才是可以测试的代码，这就是为什么！副作用方法是专门写给那些智力弱者的，他们认为方法名程应该表明这个方法该干什么。

创建实用工具类 Utility 和函数/方法

例如：你有一个要传递的 URL 为内容的 String（遵守尽可能使用基本类型的原则），创建另一个含有静态方法的类比如 isValidUrl(String url)，不要让面向对象规则告诉你要将这个方法修改为一个 URL 对象。如果你的静态工具方法能够同时调用外部服务那就更好了！

创建 Manager 和 Controller

到处使用这些 Manager 和 Controller 来干预其他对象的职责，不要理睬想将这些职责被移除到其他独立的对象的想法。看看这个你完全不知道要干什么的 SomeObjectManager 类。

在对象中做复杂的创建工作

每当有人建议你使用工厂来实例化对象时，你要知道你比他们更聪明。你一定比他们更聪明，因为你的类可以有多个职责而且有上千行代码。

对 if 和 switch 分支亮绿灯

不要对嵌套的 if 分支感到肮脏，这样写 “可读性更高”。面向对象思想的牛仔们想要用多态来串联对象，对这些面向对象的家伙说不。当你嵌套条件分支时，你唯一需要做的是从顶到底阅读代码。就像一个伟大的小说，一个简单的线性散文代码。使用 OO-overbard 范例，就像是一个恐怖的 choose-your-own-adventure 孩子的书，你需要经常在多个类、模式戏法和太多的复杂的概念中翻转。就只使用 if 就对了。

Utils, Utils, Utils!

代码异味？没门 - 代码香水！按你的期望将尽可能多的 util 和 helper 类乱扔，这些东西是很有帮助的，而且当你把它们粘在某个地方，其他人也可以使用。这就是代码复用，同时对每个人都好，对吧？当心，面向对象规则会说这些方法逻辑数序某些对象，是这些对象的职责。算了吧，你要务实地破坏他们的意愿。毕竟你有一个可以推送的产品！

每当你需要逃避某些事情时，请使用“重构”

“重构”是一个测试驱动、面向对象的家伙们喜欢用的词。因此，如果你想做一些有意义的事情，涉及新的功能，没有测试，只要告诉他们你是“重构”。这可以每次骗到他们。他们认为你需要在重构之前对所有内容进行测试，并且在这之前永远不应该添加新的功能。无视他们的喧哗，按照自己的方式做事吧！

final 方法

总是使用 final 类和方法。他们不能为了测试而重载。(-; 不过不要担心没将变量或值对象（除了 setter）写为 final- 让你的对象状态可以被任何人任何东西改写，保证状态毫无意义，这样做可以让事情变得太容易了。

指定特定的类型

尽可能多的使用 instanceof，这可以使伪造对象变得头疼，这样可以告诉他们你掌控着被允许的对象。

参考

How to Write 3v1L, Untestable Code

附

Top 10 things which make your code hard to test

MS-DOS 在 GITHUB 上托管源码

Sun, 30 Sep 2018 23:54:13 +0800

为了更便于查找和下载，MS-DOS 即微软磁盘操作系统，在经历了将近 40 年历史后，将早期代码托管在了 Github 上开源。

这并不是 MS-DOS 第一次开源，早在 2014 年，微软就已经提供 MS-DOS 2.0 版本的源码公开下载。

开源项目地址

https://github.com/Microsoft/MS-DOS

Android 屏幕控制工具 scrcpy

Sun, 30 Sep 2018 23:51:07 +0800

scrcpy 是 Genymobile 出品的一款优秀 Android 屏幕控制软件，可以通过 adb 连接或 adb over TCP/IP 控制手机屏幕。

支持 Linux, Windows, Mac OS 平台，使用 Apache2 协议，开源免费。

同时也支持键盘输入、复制电脑剪切板和拖放 APK 文件安装应用。

快捷键

Action	Shortcut
切换到全屏模式	`Ctrl`+`f`
调整窗口到 1:1 (pixel-perfect)	`Ctrl`+`g`
调整窗口以移除黑边	`Ctrl`+`x` \| 双击¹
点击 `HOME`	`Ctrl`+`h` \| 鼠标中键
点击 `BACK`	`Ctrl`+`b` \| 鼠标右键²
点击 `APP_SWITCH`	`Ctrl`+`s`
点击 `MENU`	`Ctrl`+`m`
点击 `VOLUME_UP`	`Ctrl`+`↑` (上键)
点击 `VOLUME_DOWN`	`Ctrl`+`↓` (下键)
点击 `POWER`	`Ctrl`+`p`
点亮屏幕	鼠标右键²
复制计算机剪贴板到设备	`Ctrl`+`v`
启用或禁用 FPS 计数器 (在标准输出)	`Ctrl`+`i`
从计算机安装 APK	拖放 APK 文件到窗口上

¹在黑边上双击来移除它们。
²灭屏状态下点击右键会点亮屏幕，否则触发返回键。

下载地址

https://github.com/Genymobile/scrcpy/releases

开源项目地址

https://github.com/Genymobile/scrcpy

关于

Sat, 29 Sep 2018 22:11:50 +0800

Busy.Im - Too much to learn, too busy to live? You can be more productive!

Creator

ty

一个兴趣使然的软件工程师

技能

Java/Android
Linux/Archlinux/Ubuntu/Centos
Shell/Python/C++/C/Javascript
System Admin/Backend/Gitlab/Docker
Hosting/Dedicated Server/KVM/VPS/Seedbox

Github

开源项目

CallerInfo - 一个获取号码归属地和其他信息（诈骗、骚扰等）的开源 Android 应用
Scripts - Shell 脚本集合：backup/ddns/le-dns/lets-encrypt 等
PhoneNumber - 一个获取号码归属地和其他信息（诈骗、骚扰等）的开源库
SourceAnalysis - 源码分析文档
ColorPicker - 一个颜色选择库
docker-auto-builds 常用服务 docker 化部署
Certs - 利用 Gitlab ci 自动更新和部署 ssl 证书
CallerBackend - CallerInfo 后台数据服务
LanCamera - 局域网摄像头监控观看应用
hugo-clean-theme - 一个 hugo 博客的 clean 主题

Busy.Im

Android 自动化编译之 Github Actions

集成编译优化过程

1. 使用预编译 docker 镜像

2. 增加 sdk 及 gradle 缓存

3. 加密的环境变量 Secrets

4. 增加 artifacts 上传

总结

使用枚举管理不同渠道版本常量

一般的字符串常量

进化为枚举管理

1. 定义常量

2. 增加枚举实例内初始化

3. 增加枚举实例

4. 代码调用

完整代码示例

从零开始的 Go 爬虫框架编程实战 - 下篇

10. 多个站点信息合并

11. 增加额外字段信息

12. 增加正则表达式匹配查找支持

13. 增加 Json 站点解析能力

14. 增加装饰器，支持配置清单自定义修改

结语

TIL - 学到的小知识点

从零开始的 Go 爬虫框架编程实战 - 中篇

6. 增加通用获取属性的封装

7. 增加 gb2312 euc-jp 等编码支持

8. 扩展 Selector 选择器，增加预设值支持

9. 支持 Cookies 配置

从零开始的 Go 爬虫框架编程实战 - 上篇

为什么选择 Go 爬虫

从零开始，高效的 Go 开发环境

开发过程及框架介绍

1. 基础数据结构和架构

2. 基础站点配置清单

3. 基础爬虫逻辑代码

4. Selector 选择器封装

5. 获取标签文字和属性

Kotlin 代码样式指南

大括号

表达式

换行

函数

表达式函数

属性

枚举类

注解

隐式返回/属性类型

命名

软件包名称

类型名称

函数名称

常量名称

非常量名称

后备属性

参考

如何管理多模块工程中的依赖?

1. 使用 ext 块

2. 从单独文件中引用

3. 使用 buildSrc

使用场景

参考

Android 工程的 Vagrant Gitlab Runner

排队竞争

扩充方案

使用步骤

关闭虚拟机

注册

销毁

主机名

下载速度慢

登录到虚拟机

.gitlab-ci.yml 示例

项目地址

分布式 MinIO s3 云存储实践

通过 docker 运行

分布式运行实践

示例代码

参考

Android 应用内存数据分析方法

7. 增加 `gb2312` `euc-jp` 等编码支持

8. 扩展 `Selector` 选择器，增加预设值支持

3. 使用 `buildSrc`