Mr He

【收藏】一些开源项目

Wed, 17 Apr 2019 18:00:00 +0000

开源灵魂公司

开源的项目

Android 三方库

另外在放一个国内的源

清华大学开源软件镜像站

备注：不定期更新

前行的路

Wed, 15 Aug 2018 21:30:00 +0000

2018

《鞋狗》 - 4月

《局外人》 - 6月

《富兰克林自传》 - 7月

《皮囊》 - 11月

《大学之路第一部》- 11月

《我的天才女友》那不勒斯四部曲之一 - 12月

《漫长告白》 - 12月 👍👍👍👍👍

2019

《人类灭绝》 - 1月

《人间失格》 - 1月

《娱乐至死》 - 2月 👍👍👍👍👍

《美妙的新世界》 - 2月 👍👍👍👍👍

《科学学习》 - 6月 👍👍👍

《人生海海》 - 6月 👍👍👍👍

《生吞》 - 7月 👍👍👍👍

《分身》 - 7月 👍👍👍

《白夜行》 - 9月 👍

2020

《恶意》 - 1月 👍👍👍

2021

《少即是多》 - 3月 👍👍👍

编码&解码

Tue, 14 Aug 2018 15:18:23 +0000

编码问题一直是软件开发过程中令人比较头疼的问题，有些东西不去搞明白它始终牵绊着你，最近查阅了一些资料，算是对编码有了一些认识，以下便是对最近学习的一些总结。

编码与解码的区别？

计算机中储存的信息都是用二进制数表示的；而我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果。通俗的说，按照何种规则将字符存储在计算机中，如’a’用什么表示，称为”编码”；反之，将存储在计算机中的二进制数解析显示出来，称为”解码”，如同密码学中的加密和解密。在解码过程中，如果使用了错误的解码规则，则导致’a’解析成’b’或者乱码。

字符集（Charser）

字符(Character)是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等。字符集(Character set)是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集名称：ASCII字符集、GB2312字符集、BIG5字符集、 GB18030字符集、Unicode字符集等。

字符编码

字符编码（英语：Character encoding）、字集码是把字符集中的字符编码为指定集合中某一对象（例如：比特模式、自然数序列、8位组或者电脉冲），以便文本在计算机中存储和通过通信网络的传递。常见的编码方式有：ASCII、GBK、GB2312、UTF-8等。

ASCII

60年代，美国制定了一套字符编码标准，对应英语中用到的字符和相应的二进制表示。这套标准被称为ASCII码，它一共规定了128个字符的编码，每个字符均用8个二进制位表示(最高位均为0)，这128个字符包括:

32个控制字符：十进制(0~31)，比如ESC (escape)，二进制表示为00011011。
空格(space)，二进制表示为00100000；DEL (delete)，二进制表示为01111111。
标点以及运算符：(33~47,58~64,91~96,123~126)，比如‘+’表示为00101011。
数字(48~57)，大写字母(65~90)，小写字母(97~122)。比如‘a’表示为01100001。

Unicode

ascii编码使用一个字节只能处理128个字符，要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

你可以想得到的是，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。

Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode标准也在不断发展，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

utf-8

统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。所以本着节约的精神，在存储和传输时，如果把Unicode中多余的信息压缩一下，就更完美了。UTF-8编码方式就是这其中的代表。从下图中可以看出，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

计算机系统通用的字符编码工作方式

1.在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码；
2.用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件；
3.浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器。

参考

Android 组件化

Thu, 09 Aug 2018 00:00:00 +0000

模块化和组件化有啥区别呢？

模块化的目的是为了重用，模块化后可以方便重复使用和插拨到不同的平台，不同的业务逻辑过程中。
组件化的目的是为了解耦，把系统拆分成多个组件，分离组件边界和责任，便于独立升级和维护。

单一工程模式

传统单一工程结构如上图所以，其调用关系如下图所示。

正如上图我们看到的那样，各个模块之间调用相互交错彼此影响，随着项目越来越大可能会造成如下情况：

增减需求如要命
一个小需求要编译运行整个项目
功能测试和需求测试每次都要进行
灵活性差，业务耦合
人力成本巨大

为了防止在项目迭代的过程中出现如上问题，我们开始着手研究组件化方案，关于组件化的好处我这里不再细数了，想要了解的可以自行搜索。

路由

路由是完成组件化的关键，是各个业务的衔接的桥梁[路由与业务关系如上图所示]，所以我们首要解决的就是这问题，由于android系统其开放性的特点[如果允许的话可以在打开任何app的任意界面]。android中一个Activity就代表一个可视界面，其打开方式包含显式启动和隐式启动这两种，显示启动没有什么好说的，一般用在App内部，而另一种隐式常被用来app之间的调用。所以路由实现原理也就这两种了，目前开源社区的主流框架也基本上基于这两种了，但是一个框架在保证其实现能力的同时，大牛支持、维护、大厂后盾等这些因素也是我们在选型的时候必须要考虑的。综上因素我们找到了ARouter框架，完全覆盖了我们对组件化的需求，所以我们就使用它作为我们路由框架了（其实最主要的还是好用、解耦🍻）。

工程结构

前面我们已经了解到了，传统的app架构所拥有的痛点，为了解决这个痛点我们引入了组件化架构设计，如何来设计组件化结构呢？其实关于这一点Android已经为我们做好了铺设，那就是利用Android library和gradle，我们可以在创建的Android工程下再创建一个或多个library，这是众所周知的事了，所以如上图所示，我们需要设计好app的业务模块，为每一个业务模块创建一个library工程，形成如上图所示的结构，当然一个app一般会依赖一些第三方库，我们就可以使用gradle来管理这些依赖。向上面我们介绍的ARouter也是属于第三方库，像这样一类库是各个模块都可能需要的，那么我们就可以把这些库组成一个公共组件库来使用，以方便统一管理，这样我们就将业务和公共组件分开了，有了这样的结构后我们就可以分模块开发了，但是这里还有如下问题需要解决。

如何解决引用库冲突问题？

一个工程中管理多个模块必然会有一些库重复引用或者版本冲突等问题，那么我们如何解决呢？其解决方案主要分两步。第一步，我们可以将各个模块引用的一些第三方库的版本号，在工程目录下的build.gradle文件中以常量的方式定义，然后在各个模块中引用这些常量。

ext {
    compileSdkVersion = 25
    buildToolsVersion = "25.0.2"
    minSdkVersion = 21
    targetSdkVersion = 25
}

第二步，我们将各个模块都会使用的一些第三方库提取出来，把他们放到单独的一个gradle文件中，一般我们将该文件放在项目的根目录下[与setting.gradle同级]，然后在各个模块中引用它。比如我们放置第三方库的文件叫third.gradle

dependencies {
    testCompile 'junit:junit:4.12'
    implementation 'com.squareup.okhttp3:okhttp:3.5.0'
    implementation 'com.google.code.gson:gson:2.6.1'
    implementation 'cn.isif.alibs:alibs:2.0.0'
}

在各个组件中引用

apply from: "../third.gradle"

如何独立开发调试一个模块呢？

我们知道独立的library要调试的话，必须将library作为一个应用才行，在gradle中将一个模块第一位库使用apply plugin: 'com.android.library'，一个应用则使用apply plugin: 'com.android.application'，所以我们解决方法就有了，我们可以在最外层的build.gradle文件中定义个一个isDebug常量，在每个模块中做一下判断：

if (isDebug.toBoolean()) {
    apply plugin: 'com.android.application'
} else {
    apply plugin: 'com.android.library'
}

只是将模块定义为application还是不能运行，我们还需要在mainfest文件定义启动页面，这里就有一个问题了，如果我们不做任何配置的话我们需要在切换组件的时候来回改这个文件，这显然不是一种好的方式，这里我们就需要到我们的gradle文件中去指定项目的mainfest文件了。如：我们在main目录下创建一个debug文件，里面copy一份mainfest文件用于配置调试阶段。在build.gradle文件中

sourceSets {
        main {
            if (isDebug.toBoolean()) {
                manifest.srcFile 'src/main/debug/AndroidManifest.xml'
            } else {
                manifest.srcFile 'src/main/AndroidManifest.xml'
            }
        }
    }

这样我们就解决模块的独立调试与开发的问题了。

如何解决资源冲突问题？

我们知道，一旦我们开始组件化后，每个组件都会引用一些资源文件，不可避免的会出现同名称的资源，那么我们如何解决这个问题呢？比较简单的做法是指定命名规范，不同模块下的资源名加上前缀，这样就能区分了。

如何管理多个组件之间相同的资源？

一旦我们将项目拆分成为多个工程，各个工程中必然涉及到引用相同的资源，当然我们可以把这些公共的资源在每一个工程里都放置一份，但这会引起安装包增大同时也会导致我们整个工程存在冗余文件的问题，为了避免这样的问题，我们可以创建一个用来管理公共资源文件的library库，将所有的资源都放在这个库中，这样可以解决公共资源管理的问题。

更多关于组件化实现的细节可以参考我们的ARouterDemo。

参考

在CentOS上安装MySQL并初始化

Sat, 16 Jun 2018 00:00:00 +0000

首先，你可能需要查看一下是否已经安装MySQL了。

yum list installed | grep mysql

如果，你需要卸载？

yum -y remove + 数据库名称

那么，接下来就是下载安装了，我使用wget工具来下载MySQL，如果没有安装wget工具可以参考如下安装方式：

yum install wget

成功安装好wget后，我们就可以使用wget去下载MySQL啦，例如下载http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm：

wget http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm

添加MySQL Yum Repository 到你的系统respository列表中，

yum localinstall mysql-community-release-el7-5.noarch.rpm

验证一下是否添加成功

yum repolist enabled | grep "mysql.*-community.*"

选择要启用的版本

查看MySQL版本

yum repolist all | grep mysql

可以看到5.5，5.7版本是默认禁用的，因为现在最新的稳定版本是5.6，查看当前的启动的MySQL版本

yum repolist enabled | grep mysql

执行如下命令进行安装

yum install mysql-community-server

以上，就是我们在centos上安装mysql的详细步骤，但是作为一个基础服务工具来说这个并没有结束，所以

启动MySQL服务

systemctl start mysqld

查看MySQL服务状态

systemctl status mysqld

关闭MySQL服务

systemctl stop mysqld

安装完成并且启动服务后，我们需要对MySQL进行安全设置，也就是对MySQL进行初始化，比如，设置root用户的密码，设置root用户的是否具有远程访问的权限等等。

mysql_secure_installation

至此，安装并初始化MySQL基本结束。

ubuntu 安装nginx

Sat, 02 Jun 2018 00:00:00 +0000

安装gcc g++的依赖库

apt-get install build-essential
apt-get install libtool

安装pcre依赖库

sudo apt-get update
sudo apt-get install libpcre3 libpcre3-dev

安装 zlib依赖库

apt-get install zlib1g-dev

安装ssl依赖库

apt-get install openssl

安装Nginx

#载最新版本：
wget http://nginx.org/download/nginx-1.11.3.tar.gz
#解压：
tar -zxvf nginx-1.11.3.tar.gz
#进入解压目录：
cd nginx-1.11.3
#配置：
./configure --prefix=/usr/local/nginx 
#注意：在Ubuntu中这里可以出现‘ checking for C compiler ... not found’问题，这里应该是上面的gcc g++库没有安装成功，可是执行：apt-get install gcc gcc-c++ kernel-devel
#编辑nginx：
make
#注意：这里可能会报错，提示“pcre.h No such file or directory”,具体详见：http://stackoverflow.com/questions/22555561/error-building-fatal-error-pcre-h-no-such-file-or-directory
#需要安装 libpcre3-dev,命令为：sudo apt-get install libpcre3-dev
#安装nginx：
sudo make install
#启动nginx：
sudo /usr/local/nginx/sbin/nginx -c /usr/local/nginx/conf/nginx.conf
注意：-c 指定配置文件的路径，不加的话，nginx会自动加载默认路径的配置文件，可以通过 -h查看帮助命令。
#查看nginx进程：
ps -ef|grep nginx

特别注意在上面执行make命令的时候可能会出现‘The program ‘make’ can be found in the following packages:’，这说明make没有安装，运行下面命令安装：

sudo apt-get install build-essential

启动Nginx

#-s都是采用向 Nginx 发送信号的方式。
./sbin/nginx -s stop
./sbin/nginx -s quit

Nginx重新加载配置

./sbin/nginx -s reload

指定配置文件

./sbin/nginx -c /usr/local/nginx/conf/nginx.conf

更多参考

Linux 安装Shadowsocks

Thu, 03 May 2018 00:00:00 +0000

最近需要科学上网查点资料，于是就在linode上买了一个vps，linode性价比不算高，但是为了图省事也就忍了。下面我记录一下搭建科学上网环境的具体步骤。

ubuntu篇

第一步安装Shadowsocks

#更新软件源
sudo apt-get update
#安装pip环境
sudo apt-get install python-pip
#安装shadowsock客户端
sudo pip install shadowsocks
#安装加密库
sudo apt–get install python–m2crypto

第二步新建配置文件

在任意目录下新建一个json文件，命名无所谓，我的全路径：/home/shadowsocks.json，添加按如下内容进行编辑（正式的内容没有后面#）：

{
"server":"67.209.xxx.xxx",      #你买的vps的ip
"server_port":443,              #vps端口号
"local_address":"127.0.0.1",    #客户机本机环回地址 ,可以不写
"local_port":1080,              #客户机端口号,可以自己设置
"password":"xxxxxxxx",          #vps密码
"timeout":300,                  #连接超时时间,可以不写
"method":"aes-256-cfb"          #加密方式
}

最后一步启动

ssserver -c /home/shadowsocks.json -d start

Centos 篇

前面记录了在Ubuntu下安装shadowsocks的方法。下面我们再记录一下在centos7下安装ss。

安装pip

与Ubuntu有些不一样，我们使用curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py 命令安装。

[root@ssserver ~]# curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 1604k  100 1604k    0     0  11.1M      0 --:--:-- --:--:-- --:--:-- 11.2M

下载完成后再在终端执行：python get-pip.py，执行成功会看到类似如下信息：

Installing collected packages: pip, wheel
Successfully installed pip-18.0 wheel-0.31.1

安装shadowsocks

在终端输入pip install shadowsocks命令，成功会看到类似如下：

Successfully built shadowsocks
Installing collected packages: shadowsocks
Successfully installed shadowsocks-2.8.2

配置shadowsocks

输入编辑文件命令vi /etc/shadowsocks.json并回车，配置类似：

{
    "server":"0.0.0.0",
    "server_port":50013,  //服务器的端口
    "password":"1234567890",    //自己设定的密码
    "method":"aes-256-cfb"  //加密方法，推荐使用"aes-256-cfb"
}

若是多用户模式，将server_port和password合并为port_password：

"port_password": {
         "50013": " mypassword 1”,  //对应端口设定不同的密码
         "8888": " mypassword 2”
     },

将shadowsocks加入系统服务

输入编辑文件命令vi /etc/systemd/system/shadowsocks.service并回车，粘贴下面内容：

[Unit]
Description=Shadowsocks
[Service]
TimeoutStartSec=0
ExecStart=/usr/bin/ssserver -c /etc/shadowsocks.json
[Install]
WantedBy=multi-user.target

保存并退出vi。

启动shadowsocks服务并设置开机自启

设置开机自启命令：systemctl enable shadowsocks
启动命令：systemctl start shadowsocks
查看状态命令：systemctl status shadowsocks

如果成功的话，会看到类似如下信息：

[root@ssserver ~]# systemctl start shadowsocks
[root@ssserver ~]# systemctl status shadowsocks
● shadowsocks.service - Shadowsocks
   Loaded: loaded (/etc/systemd/system/shadowsocks.service; enabled; vendor preset: disabled)
   Active: active (running) since Tue 2018-08-28 13:27:53 UTC; 7s ago
 Main PID: 1259 (ssserver)
   CGroup: /system.slice/shadowsocks.service
           └─1259 /usr/bin/python /usr/bin/ssserver -c /etc/shadowsocks.json

Aug 28 13:27:53 ssserver systemd[1]: Started Shadowsocks.
Aug 28 13:27:53 ssserver systemd[1]: Starting Shadowsocks...
Aug 28 13:27:54 ssserver ssserver[1259]: INFO: loading config from /etc/shadowsocks.json
Aug 28 13:27:54 ssserver ssserver[1259]: 2018-08-28 13:27:54 INFO     loading libcrypto from libcrypto.so.10
Aug 28 13:27:54 ssserver ssserver[1259]: 2018-08-28 13:27:54 INFO     starting server at 0.0.0.0:50013

防火墙问题

有时候我们按照上面的方式配置了，也在ss客户端配置，但就是无法科学上网，这时问题可能出现在我们设置的端口被防火墙禁用了，在centos7下使用的filewalle防火墙，我们只需修改/etc/firewalld/zones/public.xml文件，在标签中添加如下：

<port protocol="tcp" port="8088"/>
<port protocol="udp" port="8088"/>

保存后，运行:

# firewall-cmd --complete-reload

性能提升

Gevent可以提高ss性能，由于gevent依赖于libevent和greenlet

$ yum install -y libevent
$ pip install greenlet
$ pip install gevent

Android6.0权限

Tue, 01 Aug 2017 00:00:00 +0000

Android6.0之后将权限分为了两类：普通和危险权限，普通权限和危险权限都需要在AndroidManifest文件中声明，同时还引入了权限组的概念。

权限组

Android将同类型的权限分为一组，如下图中location组权限中包含：ACCESS_FINE_LOCATION和ACCESS_COARSE_LOCATION这两个权限，当同一组中的某一个权限被授权，其他权限也一并被授权。

重要API

新的权限Api主要有三个重要方法：

检查权限方法

//用于检查某个权限是否得到授权
public static int checkSelfPermission(@NonNull Context context, @NonNull String permission);

该方法返回PERMISSION_GRANTED'或'PERMISSION_DENIED分别表示接受和拒绝，但是，当用户拒绝并且点击不再询问时，这个方法始终返回’PERMISSION_GRANTED，此时我们就需要利用第三个方法shouldShowRequestPermissionRationale了。

请求权限

public static void requestPermissions(final @NonNull Activity activity, final @NonNull String[] permissions, final @IntRange(from = 0) int requestCode)

此方法可以同时申请一组权限。

判断是否选择不再询问

//用于检查某个权限申请是够被设为不再询问，face表示你可以展示权限申请提示，true表示否
public static boolean shouldShowRequestPermissionRationale(@NonNull Activity activity, @NonNull String permission)

这个API主要用于给用户一个申请权限的解释，该方法只有在用户在上一次已经拒绝过你的这个权限申请。也就是说，用户已经拒绝一次了，你又弹个授权框，你需要给用户一个解释，为什么要授权，则使用该方法。

除了上面三个API方法外，还有一个需要我们注意，那就是回调方法（一般在Activity和fragment中）。

//requestCode同requestPermissions中一样，主要用来标识权限请求
//permissions 对应的相关权限
//grantResults 里面存放表示同意还是拒绝的结果值
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,@NonNull int[] grantResults)

这里需要注意一点：你使用fragment发起的请求只能在fragment中监听，同理Activity。

不在询问

关于不在询问的情况处理分为两种，为啥分为两种呢？主要是为了匹配第三方rom（坚果pro、小米系列等）。官方rom中是否设置为不再询问，我们可以通过shouldShowRequestPermissionRationale()方法来判断。但第三方rom由于定制原因不能通过该方法进行判断，在第三方rom中该方法一直返回false，观察了很多app的做法是直接给出提示。

DEMO

在最后我们来一个常规的demo：

public class PermissionUtils {

    public static void requestPermission(Object obj, String[] args, int requestCode) {
        List<String> permissions = denyFilterPermission(getActivity(obj), args);
        if (permissions.size() > 0) {
            String[] per = permissions.toArray(new String[permissions.size()]);
            if (obj instanceof Activity) {
                ((Activity) obj).requestPermissions(per, requestCode);
            } else if (obj instanceof Fragment) {
                ((Fragment) obj).requestPermissions(per, requestCode);
            } else {
                throw new IllegalArgumentException(obj.getClass().getName() + " is not supported");
            }
        }
    }

    public static Activity getActivity(Object obj) {
        if (obj instanceof Activity) {
            return (Activity) obj;
        } else if (obj instanceof Fragment) {
            return ((Fragment) obj).getActivity();
        }
        return null;
    }
    
    public static List<String> denyFilterPermission(Activity activity, String... permission) {
        List<String> pem = new ArrayList<>();
        for (String p : permission) {
            if (ActivityCompat.checkSelfPermission(activity, p) != PackageManager.PERMISSION_GRANTED) {
                pem.add(p);
            }
        }
        return pem;
    }
}

我们先写一个工具类用于权限的请求。

在Activity中我们定义了一个textview并设置了一个点击事件，当点击这个rextview的时候我们就检测是否被授权，在回调中我们处理相应的操作：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private TextView tv;
    private final int reCode = 0x11;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) this.findViewById(R.id.test);
        tv.setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        PermissionUtils.requestPermission(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION
        ,Manifest.permission.ACCESS_COARSE_LOCATION}, reCode);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode) {
            case reCode:
                boolean canDo = true;
                for (int i = 0; i < grantResults.length; i++) {
                    if (grantResults[i]== PackageManager.PERMISSION_DENIED){
                        canDo = false;
                        //如果用户勾选了不再询问，我们将引导用户去设置开启权限
                        if (!ActivityCompat.shouldShowRequestPermissionRationale(this,permissions[i])) {
                            Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                            Uri uri = Uri.fromParts("package", getApplicationContext().getPackageName(), null);
                            intent.setData(uri);
                            startActivity(intent);
                        }
                        break;
                    }
                }
                break;
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

总结

使用中应当注意targetSdkVersion的配置，如果希望在项目中启用新的权限验证，需将target版本设置大于或等于23版本。
为了兼容低版本可以使用兼容包里的Api

参考

开源框架

GitHub - permissions-dispatcher

Android GradleScript配置

Mon, 06 Jun 2016 00:00:00 +0000

编译时动态设置 Android resValue

语法：resValue "string", "AppName", "app1" 编译后会在res/string.xml中增加一个名为AppName，值为app1的资源。位置：buildTypes、productFlavors、defaultConfig等

在编译时动态设置 Android BuildConfig

语法：buildConfigField "String", "ENDPOINT", "\"http://example.com\""编译后会在BuildConfig中新增一个ENDPOINT字段。位置：buildTypes、productFlavors、defaultConfig等

通常可以做一些全局性的配置，比如一般我们在测试环境的时候会有一些日志需要输出，正式环境的时候为保证性能就需要关掉日志输出，这时就可以在buildTypes中配置

动态设置Android Manifest

在AndroidManifest中定义一个变量，在build.gradle中动态的替换掉，十分方便，语法也十分简单。对比上面的功能，我们需要动态替换友盟的appkey，需要在AndroidManifest中定义一个变量

<meta-data
         android:name="UMENG_APPKEY"
         android:value="${umeng_app_key}"/>

接着，我们在build.gradle文件中根据不同的环境，生成不同appkey的apk。

buildTypes {
        debug {
         manifestPlaceholders = [umeng_app_key: "你替代的内容"]
        }
        release {
     　　manifestPlaceholders = [umeng_app_key: "你替代的内容"]
        }
        develop {
    　　 manifestPlaceholders = [umeng_app_key: "你替代的内容"]
        }
    }

注意：这里的“你替代的内容”，不能为特殊关键词，比如：TRUE，否则在Java代码中获取不到meta-data中的值。

读取properties文件

Android开发中我们会经常配置一些跨模块的全局变量：版本号、一些key值等。这时可以将这些变量定义在properties里面，比如：

appVersionCode = 515
appVersionName = 5.1.5

## TODO: Supply YouTube API key and sender ID for your project
youtube_api_key = UNDEFINED

使用

defaultConfig {
        versionCode = Integer.valueOf("" + appVersionCode).intValue()
        versionName "${appVersionName}"
        buildConfigField("String", "YOUTUBE_API_KEY", "\"${youtube_api_key}\"")
        ...
    }

参考

[使用 gradle 在编译时动态设置 Android resValue / BuildConfig / Manifes中变量的值](http://blog.csdn.net/xx326664162/article/details/49247815)

Android File存储

Fri, 20 May 2016 00:00:00 +0000

Android File存储

Android系统为我们提供了多种途径可以实现持久化储存，本专题主要讨论常用5种存储方案之一的File存储。

基本概念

内存（memory）

内部存储（InternalStorage）

外部存储（ExternalStorage）

首先我们得搞清楚这三个概念，内存，我们在英文中称作memory，内部存储，我们称为InternalStorage，外部存储我们称为ExternalStorage。

Android系统提供的持久化方案大致有如下五种

网络
File
Shared Preference
ContentProvider
SQLite

其中网络、Shared Preference、ContentProvider、SQLite都是我们经常使用的，但不是我们本专题的的重点，本专题的重点是File存储，File存储在我们日常开发中经常使用（显示的或隐式的），但也是我们比较容易忽略的知识点，Android很多框架都是基于它实现的，所以掌握好File存储对学习Android系统有很大帮助。

Android 文件结构

上图就是Android文件的结构图了，这里给大家介绍一下/data、/mnt、/storage这三个文件夹（因为这涉及到我们接下来的内容），/data这个文件夹下中有一个app文件夹是用来存放我们安装应用的apk文件的，同时下面还有一个data目录这个就是我们的内部存储空间了（sharedpreference、数据库文件等都是存在这里的），不同的应用用以包命名的文件夹作区分。mnt和storage就是我们的外部存储空间了，mnt下只是一个storage的链接，真正空间位置还是storage。

内部存储和外部存储

在进入主题之前我得明白，所有 Android 设备都有两个文件存储区域：“内部”和“外部”存储。这些名称在 Android 早期产生，当时大多数设备都提供内置的非易失性内存（内部存储），以及移动存储介质，比如微型 SD 卡（外部存储）。一些设备将永久性存储空间划分为“内部”和“外部”分区，即便没有移动存储介质，也始终有两个存储空间，并且无论外部存储设备是否可移动，API 的行为均一致。下面我们来看一下相对于程序来说它们各自有什么区别呢？

内部存储：什么是内部存储呢？可以这样理解，除了应用程序本身其他程序无法读取（Root情况不考虑），同时还具有如下性质：
- 它始终可用（在足够空间下）
- 当用户卸载您的应用时，系统会从内部存储中移除您的应用的所有文件
外部存储
- 它并非始终可用，因为用户可采用 USB - 存储设备的形式装载外部存储，并在某些情况下会从设备中将其移除。
- 它是全局可读的，因此此处保存的文件可能不受您控制地被读取。
- 当用户卸载您的应用时，只有在您通过 getExternalFilesDir() 将您的应用的文件保存在目录中时，系统才会从此处移除您的应用的文件。

常见使用内部存储方法

public class Context{
/**
    * 作用：可以方便地再手机中创建文件，并返回文件输出流，用于对文件做写入操作。
    * 
    * @param name 用于指定文件名称，不能包含路径分隔符“/”，如果文件不存在，Android会自动创建它。
    *            创建的文件保存在/data/data/<package name>/files/目录中
    * @param mode mode取值：
    *            MODE_APPEND    私有（只有创建此文件的程序能够使用，其他应用程序不能访问），在原有内容基础上增加数据
    *            MODE_PRIVATE  私有，每次打开文件都会覆盖原来的内容
    * @return
    */
public abstract FileOutputStream openFileOutput(String name, int mode);
public abstract File getFilesDir(); //获取文件系统的绝对路径:/data/data/<package name>/files/
String[] fileList (); //当前应用内部存储路径下的所有文件名
public abstract FileInputStream openFileInput(String name);//与openFileOutput对应
public abstract File getDir(String name, int mode);//在应用程序的数据文件下获取或创建name对应的子目录
public abstract File getCacheDir();//方法可以获得当前的手机自带的存储空间中的当前包文件的路径:/data/data/<package name>/cache/
...
}

常见使用外部部存储方法

public class Context{
    /**
      *
      * @param type The type of files directory to return. May be {@code null}
    *            for the root of the files directory or one of the following
    *            constants for a subdirectory:
    *            {@link android.os.Environment#DIRECTORY_MUSIC}, //mnt/sdcard/android/data/包名/files/music
    *            {@link android.os.Environment#DIRECTORY_PODCASTS}, 
    *            {@link android.os.Environment#DIRECTORY_RINGTONES},
    *            {@link android.os.Environment#DIRECTORY_ALARMS},
    *            {@link android.os.Environment#DIRECTORY_NOTIFICATIONS},
    *            {@link android.os.Environment#DIRECTORY_PICTURES}, or
    *            {@link android.os.Environment#DIRECTORY_MOVIES}.
    */
public abstract File getExternalFilesDir(@Nullable String type);

public abstract File getExternalCacheDir();//mnt/sdcard/android/data/包名/cache/
...
}

public class Environment{
public static String getExternalStorageState();//获取shared/external storage的状态
public static File getExternalStorageDirectory();//返回mnt/sdcard/
...
}

Context和Environment都可以用来操作外部存储空间，那么这两这有什么区别呢？一般Context所操作的是私有空间即：/mnt/sdcard/android/data/包名/，而Environment操作的是共有空间：/mnt/sdcard/。

最后福利

public class ExternalStorageHelper {

    // 判断SD卡是否被挂载
    public static boolean isSDCardMounted() {
        // return Environment.getExternalStorageState().equals("mounted");
        return Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED);
    }

    // 获取SD卡的根目录
    public static String getSDCardBaseDir() {
        if (isSDCardMounted()) {
            return Environment.getExternalStorageDirectory().getAbsolutePath();
        }
        return null;
    }

    // 获取SD卡的完整空间大小，返回MB
    public static long getSDCardSize() {
        if (isSDCardMounted()) {
            StatFs fs = new StatFs(getSDCardBaseDir());
            long count = fs.getBlockCountLong();
            long size = fs.getBlockSizeLong();
            return count * size / 1024 / 1024;
        }
        return 0;
    }

    // 获取SD卡的剩余空间大小
    public static long getSDCardFreeSize() {
        if (isSDCardMounted()) {
            StatFs fs = new StatFs(getSDCardBaseDir());
            long count = fs.getFreeBlocksLong();
            long size = fs.getBlockSizeLong();
            return count * size / 1024 / 1024;
        }
        return 0;
    }

    // 获取SD卡的可用空间大小
    public static long getSDCardAvailableSize() {
        if (isSDCardMounted()) {
            StatFs fs = new StatFs(getSDCardBaseDir());
            long count = fs.getAvailableBlocksLong();
            long size = fs.getBlockSizeLong();
            return count * size / 1024 / 1024;
        }
        return 0;
    }

    // 往SD卡的公有目录下保存文件
    public static boolean saveFileToSDCardPublicDir(byte[] data, String type,
            String fileName) {
        BufferedOutputStream bos = null;
        if (isSDCardMounted()) {
            File file = Environment.getExternalStoragePublicDirectory(type);
            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(
                        file, fileName)));
                bos.write(data);
                bos.flush();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 往SD卡的自定义目录下保存文件
    public static boolean saveFileToSDCardCustomDir(byte[] data, String dir,
            String fileName) {
        BufferedOutputStream bos = null;
        if (isSDCardMounted()) {
            File file = new File(getSDCardBaseDir() + File.separator + dir);
            if (!file.exists()) {
                file.mkdirs();// 递归创建自定义目录
            }
            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(
                        file, fileName)));
                bos.write(data);
                bos.flush();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 往SD卡的私有Files目录下保存文件
    public static boolean saveFileToSDCardPrivateFilesDir(byte[] data,
            String type, String fileName, Context context) {
        BufferedOutputStream bos = null;
        if (isSDCardMounted()) {
            File file = context.getExternalFilesDir(type);
            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(
                        file, fileName)));
                bos.write(data);
                bos.flush();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 往SD卡的私有Cache目录下保存文件
    public static boolean saveFileToSDCardPrivateCacheDir(byte[] data,
            String fileName, Context context) {
        BufferedOutputStream bos = null;
        if (isSDCardMounted()) {
            File file = context.getExternalCacheDir();
            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(
                        file, fileName)));
                bos.write(data);
                bos.flush();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    // 保存bitmap图片到SDCard的私有Cache目录
    public static boolean saveBitmapToSDCardPrivateCacheDir(Bitmap bitmap,
            String fileName, Context context) {
        if (isSDCardMounted()) {
            BufferedOutputStream bos = null;
            // 获取私有的Cache缓存目录
            File file = context.getExternalCacheDir();

            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(
                        file, fileName)));
                if (fileName != null
                        && (fileName.contains(".png") || fileName
                                .contains(".PNG"))) {
                    bitmap.compress(Bitmap.CompressFormat.PNG, 100, bos);
                } else {
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
                }
                bos.flush();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (bos != null) {
                    try {
                        bos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return true;
        } else {
            return false;
        }
    }

    // 从SD卡获取文件
    public static byte[] loadFileFromSDCard(String fileDir) {
        BufferedInputStream bis = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            bis = new BufferedInputStream(
                    new FileInputStream(new File(fileDir)));
            byte[] buffer = new byte[8 * 1024];
            int c = 0;
            while ((c = bis.read(buffer)) != -1) {
                baos.write(buffer, 0, c);
                baos.flush();
            }
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                baos.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    // 从SDCard中寻找指定目录下的文件，返回Bitmap
    public Bitmap loadBitmapFromSDCard(String filePath) {
        byte[] data = loadFileFromSDCard(filePath);
        if (data != null) {
            Bitmap bm = BitmapFactory.decodeByteArray(data, 0, data.length);
            if (bm != null) {
                return bm;
            }
        }
        return null;
    }

    // 获取SD卡公有目录的路径
    public static String getSDCardPublicDir(String type) {
        return Environment.getExternalStoragePublicDirectory(type).toString();
    }

    // 获取SD卡私有Cache目录的路径
    public static String getSDCardPrivateCacheDir(Context context) {
        return context.getExternalCacheDir().getAbsolutePath();
    }

    // 获取SD卡私有Files目录的路径
    public static String getSDCardPrivateFilesDir(Context context, String type) {
        return context.getExternalFilesDir(type).getAbsolutePath();
    }

    public static boolean isFileExist(String filePath) {
        File file = new File(filePath);
        return file.isFile();
    }

    // 从sdcard中删除文件
    public static boolean removeFileFromSDCard(String filePath) {
        File file = new File(filePath);
        if (file.exists()) {
            try {
                file.delete();
                return true;
            } catch (Exception e) {
                return false;
            }
        } else {
            return false;
        }
    }
}

Mr He

【收藏】一些开源项目

开源灵魂公司

开源的项目

Android 三方库

另外在放一个国内的源

前行的路

2018

2019

2020

2021

编码&解码

编码与解码的区别？

字符集（Charser）

字符编码

ASCII

Unicode

utf-8

计算机系统通用的字符编码工作方式

参考

Android 组件化

模块化和组件化有啥区别呢？

单一工程模式

路由

工程结构

如何解决引用库冲突问题？

如何独立开发调试一个模块呢？

如何解决资源冲突问题？

如何管理多个组件之间相同的资源？

参考

在CentOS上安装MySQL并初始化

ubuntu 安装nginx

安装gcc g++的依赖库

安装pcre依赖库

安装 zlib依赖库

安装ssl依赖库

安装Nginx

启动Nginx

Nginx重新加载配置

指定配置文件

Linux 安装Shadowsocks

ubuntu篇

第一步 安装Shadowsocks

第二步 新建配置文件

最后一步 启动

Centos 篇

安装pip

安装shadowsocks

配置shadowsocks

将shadowsocks加入系统服务

启动shadowsocks服务并设置开机自启

防火墙问题

性能提升

Android6.0权限

权限组

重要API

不在询问

DEMO

总结

参考

Android GradleScript配置

编译时动态设置 Android resValue

在编译时动态设置 Android BuildConfig

动态设置Android Manifest

读取properties文件

参考

Android File存储

Android File存储

基本概念

Android系统提供的持久化方案大致有如下五种

Android 文件结构

内部存储和外部存储

常见使用内部存储方法

常见使用外部部存储方法

最后福利

第一步安装Shadowsocks

第二步新建配置文件

最后一步启动