search.xml

<?xml version="1.0" encoding="utf-8"?>
<search>
  <entry>
    <title>2048</title>
    <url>/2017/02/18/2048/</url>
    <content><![CDATA[在gayhub上发现一个挺有意思的小程序————2048
{% asset_img 2048.jpg 2048 %}
<!-- more -->
## 下载安装试玩
```bash
$ wget https://raw.githubusercontent.com/mevdschee/2048.c/master/2048.c
$ gcc 2048.c
$ ./a.out
```
## 源代码
```C
#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;

int const ROW = 4;
int const COL = 4;
int game[ROW][COL] = {0};

//上下左右
int const UP = 1;
int const DOWN = 2;
int const LEFT = 3;
int const RIGHT = 4;

//游戏所处的状态
int const GAME_OVER = 1;
int const GAME_WIN = 2;
int const GAME_CONTINUE = 3;

enum GameNum
{
	Game_2 = 2,
	Game_4 = 4,
	Game_8 = 8,
	Game_16 = 16,
	Game_32 = 32,
	Game_64 = 64,
	Game_128 = 128,
	Game_256 = 256,
	Game_512 = 512,
	Game_1024 = 1024,
	Game_2048 = 2048,
};

//打印所得的数组
void Print()
{
	system("cls");
	cout << "*****************  2048 控 制 台 版  ******************" << endl;
	cout << "*****************  By Tanzf (Intern) ******************" << endl << endl;
	for (int i = 0; i < ROW; ++i)
	{
		cout << "---------------------------------"<< endl;
		for (int j = 0; j < COL; ++j)
		{
			if (game[i][j] == 0)
			{
				cout <<"|   \t";
			}
			else 
			{
				cout <<"|   " << game[i][j] << "\t";
			}
		}
		cout << "|" << endl;
	}
	cout << "---------------------------------"<< endl;
}


bool CreateNumber()
{
	int x = -1;
	int y = -1;
	int times = 0;
	int maxTimes = ROW * COL;
	//三分之二的概率生成2，三分之一的概率生成4
	int whitch = rand() % 3;
	do 
	{
		x = rand() % ROW;
		y = rand() % COL;
		++times;
	} while (game[x][y] != 0 && times <= maxTimes);

	//说明格子已经满了
	if(times >= maxTimes)
	{
		return false;
	}
	else
	{
		GameNum num;
		if(whitch == 0)
		{
			num = Game_4;
		}
		else if(whitch)
		{
			num = Game_2;
		}
		game[x][y] = num;
	}

	return true;
}

void Process(int direction)
{
	switch (direction)
	{
	case UP:
		//最上面一行不动
		for(int row = 1; row < ROW; ++row)
		{
			for(int crow = row; crow >= 1; --crow)
			{
				for(int col = 0; col < COL; ++col)
				{
					//上一个格子为空
					if(game[crow-1][col] == 0)
					{
						game[crow-1][col] = game[crow][col];
						game[crow][col] = 0;
					}
					else 
					{
						//合并
						if(game[crow-1][col] == game[crow][col])
						{
							game[crow - 1][col] *= 2;
							game[crow][col] = 0;
						}

					}
				}
			}
		}
		break;
	case DOWN:
		//最下面一行不动
		for(int row = ROW - 2; row >= 0; --row)
		{
			for(int crow = row; crow < ROW - 1; ++crow)
			{
				for(int col = 0; col < COL; ++col)
				{
					//上一个格子为空
					if(game[crow + 1][col] == 0)
					{
						game[crow + 1][col] = game[crow][col];
						game[crow][col] = 0;
					}
					else 
					{
						//合并
						if(game[crow + 1][col] == game[crow][col])
						{
							game[crow + 1][col] *= 2;
							game[crow][col] = 0;
						}

					}
				}
			}
		}
		break;
	case LEFT:
		//最左边一列不动
		for(int  col = 1; col < COL; ++col)
		{
			for(int ccol = col; ccol >= 1; --ccol)
			{
				for(int row = 0; row < ROW; ++row)
				{
					//上一个格子为空
					if(game[row][ccol-1] == 0)
					{
						game[row][ccol - 1] = game[row][ccol];
						game[row][ccol] = 0;
					}
					else 
					{
						//合并
						if(game[row][ccol - 1] == game[row][ccol])
						{
							game[row][ccol - 1] *= 2;
							game[row][ccol] = 0;
						}

					}
				}
			}
		}
		break;
	case RIGHT:
		//最右边一列不动
		for(int  col = COL - 2; col >= 0; --col)
		{
			for(int ccol = col; ccol <= COL - 2; ++ccol)
			{
				for(int row = 0; row < ROW; ++row)
				{
					//上一个格子为空
					if(game[row][ccol + 1] == 0)
					{
						game[row][ccol + 1] = game[row][ccol];
						game[row][ccol] = 0;
					}
					else 
					{
						//合并
						if(game[row][ccol + 1] == game[row][ccol])
						{
							game[row][ccol + 1] *= 2;
							game[row][ccol] = 0;
						}

					}
				}
			}
		}
		break;
	}

}

//处理输入输出，返回上下左右
int Input()
{
	//读取上下左右四个方向键
	int upArrow = 0;
	int downArrow = 0;
	int leftArrow = 0;
	int rightArrow = 0;
	int direction = 0;
	while (true)
	{
		upArrow = GetAsyncKeyState(VK_UP);
		downArrow = GetAsyncKeyState(VK_DOWN);
		leftArrow = GetAsyncKeyState(VK_LEFT);
		rightArrow = GetAsyncKeyState(VK_RIGHT);

		if(upArrow)
		{
			direction = UP;
			break;
		}
		else if(downArrow)
		{
			direction = DOWN;
			break;
		}
		else if(leftArrow)
		{
			direction = LEFT;
			break;
		}
		else if(rightArrow)
		{
			direction = RIGHT;
			break;
		}

		Sleep(100);
	}

	return direction;
}

//判断游戏状态
int Judge()
{
	//赢得游戏
	for(int i = 0; i < ROW; ++i)
	{
		for(int j = 0; j < COL; ++j)
		{
			if(game[i][j] == 2048)
			{
				return GAME_WIN;
				break;
			}
		}
	}

	//横向检查
	for(int i = 0 ; i < ROW; ++i)
	{
		for(int j = 0; j < COL - 1; ++j)
		{
			if(!game[i][j] || (game[i][j] == game[i][j+1]))
			{
				return GAME_CONTINUE;
				break;
			}
		}
	}
	//纵向检查
	for(int j = 0; j< COL; ++j)
	{
		for(int i = 0; i < ROW -1; ++i)
		{
			if(!game[i][j] || (game[i][j] == game[i+1][j]))
			{
				return GAME_CONTINUE;
				break;
			}
		}
	}

	//不符合上述两种状况，游戏结束
	return GAME_OVER;

}

int main()
{
	//设置一个随机数种子
	srand((unsigned int)time(0));
	CreateNumber();
	CreateNumber();
	Print();
	int direction = 0;
	int gameState = -1;
	while(true)
	{
		direction = Input();

		gameState = Judge();
		if(direction && gameState == GAME_CONTINUE)
		{
			Process(direction);
			CreateNumber();
			Print();
			Sleep(100);
		}
		else if(gameState == GAME_WIN)
		{
			Print();
			cout << "You Win！" << endl;
			break;
		}
		else if(gameState == GAME_OVER)
		{
			Print();
			cout <<"You lose!" << endl;
			break;
		}
	}

	return 0;
}
```
## PS
此代码仅可在Linux上使用，Windows上会提示缺失头文件，问了问度娘，虽然有不少这样的代码，但是这份代码的显示效果最好，所以就是它啦。
{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>C</tag>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>用树莓派和四位数码管模块做一个时钟</title>
    <url>/2019/01/10/4-BIT-LED-Digital-Tube-Moudle/</url>
    <content><![CDATA[
## 预备知识
{% asset_img 1.jpg %}

如图，这是一个4位数码管模块，由两片 74HC595 级联控制，引脚如图，从上到下，分别为`VCC(3.3V/5V)`,`SCLK(移位控制端)`,`RCLK(输出控制端)`,`DIO(数据输入端)`,`GND(接地)`。

### 74HC595
我们来看一下74HC595是什么样的

{% asset_img 74hc595.png %}

看懂这个芯片需要一点点的数字电子技术的知识，看下面这个表格

<!--more-->


| 符号 | 引脚 | 描述 |
| :------:| :------: | :------: |
| Q0~Q7 | 15,1~7 | 8位并行数据输出 |
| GND | 8 | 接地 |
| QA | 9 | 串行数据输出 |
| MR | 10 | 主复位(低电平) |
| SH_CP | 11 | 数据输入时钟 |
| ST_CP | 12 | 输出存储器锁存时钟线 |
| OE | 13 | 输出有效(低电平) |
| DS | 14 | 串行数据输入 |
| VCC | 16 | 3.3V/3.5V |

 - `DS(14号脚)`是数据输入端，74HC595支持8位数据并行输出，但是数据输入只有DS一个脚，需要分8次输入；
 - `OE(Out Enable)`是一个使能端，使用74HC595时需要将这个脚接地，若接高电平，那么Q0~Q7全部为0(低电平);
 - `SH_CP(Shift register ClockPin)`是一个重要的引脚，此引脚的电平从低向高变(上升沿)时，芯片从`DS`脚读入数据(0/1)；
 - `ST_CP`，集满8位数据(其实并非严格集满，Q0~Q7本来就有电平)，此引脚的上升沿将8位数据输出。

### 74HC595级联

一个74HC595可以并行输出8位数据，两个级联就可以并行输出16位数据，级联芯片时将第一片的`QA`脚接到第二片芯片的`DS`脚，`SH_CP`和`ST_CP`也同时接在一起，当第一片芯片的`SH_CP`第九次上升沿触发时，第一片芯片的第一个数据将会通过`QA`脚输送给第二片芯片的`DS`脚。

也就是说，芯片的顺序是看`QA`和`DS`脚的顺序的。

### 电路原理图

#### 四位数码管原理图

数码管分位共阳极和共阴极，我拿到的这个数码管是共阳极，也就是说，给相应的脚设为低电平，则数码管点亮。

{% asset_img 3.jpg %}

#### 四位数码管模块原理图
{% asset_img board.jpg %}

4位数码管模块使用两片74HC595级联来控制数码管，观察电路可知，第一片74HC595的低四位用来选中四位数码管，也即DIG.1,DIG.2,DIG.3,DIG.4，高四位留空不用。第二片的八位输出用来控制数码管显示的数字。

#### 数码管原理

{% asset_img 4.jpg %}

数码管内部其实是8个发光二极管，8个二极管排列成一个“8”字，控制二极管的明灭就可以控制数码管显示的数字。下面的表给出共阳极数码管的阵脚电平和显示数字对应关系(DP不亮)

| DP GFEDCBA | 显示(十进制) | 十六进制值 |
| :------:| :------: | :------: |
| 1 1000000 |0|0xC0|
| 1 1111001 |1|0xF9|
| 1 0100100 |2|0xA4|
| 1 0110000 |3|0xB0|
| 1 0011001 |4|0x99|
| 1 0010010 |5|0x92|
| 1 0000010 |6|0x82|
| 1 1111000 |7|0xF8|
| 1 0000000 |8|0x80|
| 1 0010000 |9|0x90|


### 树莓派引脚图

![http://shumeipai.nxez.com/wp-content/uploads/2015/03/rpi-pins-40-0.png](http://shumeipai.nxez.com/wp-content/uploads/2015/03/rpi-pins-40-0.png)

通过控制树莓派的`GPIO.X`引脚电平高低即可控制外部扩展设备。
看引脚的方式是树莓派有网线接口和 USB 接口的面朝下，GPIO 阵脚的那一面面向自己，左上角位 1 号脚，右下角为 40 号脚。


## 编码实现

代码都在 [https://github.com/BDZNH/4-BIT-LED-Digital-Tube-Moudle](https://github.com/BDZNH/4-BIT-LED-Digital-Tube-Moudle)，下载之后，使用`make`命令编译，使用`sudo ./showtime	`执行。

### 接线

| 四位数码管模块 | Raspeberry |
| :-----: | :-----: |
| VCC | 1 号脚(可改变) |
| GND | 9 号脚(可改变) |
| DIO | 12 号脚 |
| SCLK | 13 号脚 |
| RCLK | 15 号脚 |

## 演示

循环显示年份，日期，时间，只显示到分钟，不显示秒。

{% asset_img year.jpg 2019年 %}

{% asset_img md.jpg 1月10日 %}

{% asset_img hm.jpg 15:25 %}

<iframe src="//player.bilibili.com/player.html?aid=40384627&cid=70929081&page=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"> </iframe>

## 参考


[1] 74HC595 的讲解，很详细，推荐观看[https://www.bilibili.com/video/av10007630/?p=14](https://www.bilibili.com/video/av10007630/?p=14)

[2] wiringPi 库的解说，也很详细，推荐收藏[https://www.cnblogs.com/lulipro/p/5992172.html](https://www.cnblogs.com/lulipro/p/5992172.html)
]]></content>
  </entry>
  <entry>
    <title>今日头条 ANR 优化实践系列 - 监控工具与分析思路</title>
    <url>/2024/08/11/ANR-page-1/</url>
    <content><![CDATA[
前言：这篇文章是一篇转载文章用，用来为后面的一些文章做铺垫。
转载链接为 [今日头条 ANR 优化实践系列 - 监控工具与分析思路](https://mp.weixin.qq.com/s/_Z6GdGRVWq-_JXf5Fs6fsw),如有侵权，请在 GitHub 提 Issue 联系我。

<!-- more -->

在前文，我们对[ANR 设计原理及影响因素](https://mp.weixin.qq.com/s/ApNSEWxQdM19QoCNijagtg)进行了介绍，并对影响 ANR 的不同场景进行归类。但是依靠现有的系统日志，不足以完成复杂场景的问题归因，而且有些信息从应用侧无法获取，这就导致很多线上问题更加棘手；因此我们在应用侧探索了新的监控能力，以弥补信息获取不足的短板。同时对日常分析过程中用到日志信息和分析思路进行总结，以帮忙大家更好的掌握分析技巧，下面我们就来看看相关实现。

# Raster 监控工具
俗话说：“工欲善其事，必先利其器”，日常分析 ANR 问题也是如此，一个好的监控工具不仅可以帮助我们在解决常规问题时达到锦上添花的效果，在面对线上复杂隐蔽的问题时，也能为我们打开视野，提供更多线索和思路。
## 工具介绍：
该工具主要是在主线程消息调度过程进行监控，并按照一定策略聚合，以保证监控工具本身对应用性能和内存抖动影响降至最低。同时对应用四大组件消息执行过程进行监控，便于对这类消息的调度及耗时情况进行跟踪和记录。另外对当前正在调度的消息及消息队列中待调度消息进行统计，从而在发生问题时，可以回放主线程的整体调度情况。此外，我们将系统服务的 CheckTime 机制迁移到应用侧，应用为线程 CheckTime 机制，以便于系统信息不足时，从线程调度及时性推测过去一段时间系统负载和调度情况。 

因此该工具用一句话来概括就是：由点到面，回放过去，现在和将来。 

因其实现原理和消息聚合后的效果，直观展示主线程调度过程长短不一的耗时片段，犹如一道道光栅，故将该工具命名为 Raster[ˈræstər]。
## 监控工具由来
例如下图，是线下遇到的 ANR 问题，从手机端获取的 Trace 日志，可以看到从主线程堆栈上基本得不到太多有效信息。
{% asset_img 1.png %}
继续从 Trace 中分析其它信息，包含了各个进程的虚拟机和线程状态信息，以及 ANR 之前或之后一段时间，CPU 使用率比较高的进程乃至系统负载(CPU，IO)的相关信息等等，如下图：
{% asset_img 2.png %}
但是从这些信息中，相信很多同学都很难再进一步分析，因为这些信息只是列举了当前各个进程或线程的状态，并没有很好的监控和记录影响这些指标的过程。而现实中这类场景的问题，每天都在线上大量发生。那么针对这种情况该如何更好的解决呢？下面就来介绍一下我们是如何应对的。
## 消息调度监控
在Android 系统的 ANR 设计原理及影响因素一文中，我们讲到，ANR 问题很多场景都是历史消息耗时较长并不断累加后导致的，但是在 ANR 发生时我们并不知道之前都调度了哪些消息，如果可以监控每次消息调度的耗时并记录，当发生 ANR 时，获取这些记录信息，并能计算出当前正在执行消息的耗时，是不是就可以清晰的知道 ANR 发生前主线程都发生了什么？按照这个思路，整理出如下示意图：
{% asset_img 3.png %}
但是通过上面示意图并结合实际业务场景，我们发现，对于大多数业务消息，单次耗时都很少，如果每个消息都单独记录，要想跟踪记录 ANR 前 10S 甚至更长时间范围内的所有消息，可能需要成千上万条记录，这个显然是不合理的，而且这么多的消息也不方便我们后续查看。
### 消息聚合分类
联想到实际业务场景很多情况都是耗时较少的消息，而在排查这类问题过程耗时较少的消息基本是可以直接忽略的，因此我们是不是可以对这类消息按照一定条件进行聚合，将一段时间以内的消息进行累加计算，如果累计耗时超过我们规定的阈值，那么就将这些消息的数量和累计耗时合并成一条记录，如 16 个消息累计耗时刚好超过 300ms，则生成一条记录。以此类推存储 100 条的话，就能监控到 ANR 发生前 30S 主线程的调度历史了(实际可能是大于 15S，至于为何是这个范围，我们会在后面说明)，如此一来就可以较好的解决大量记录和频繁更新带来的内存抖动问题。

根据上面的思路，我们对消息监控及记录又进一步的进行聚合优化和关键消息过滤；总结来看，分为以下几种类型：

### 多消息聚合：
该场景主要用于主线程连续调度多个消息，并且每个消息耗时都很少的情况下，将这些消息耗时累加，直到这些消息累计耗时超过设置的阈值，则汇总并生成一条记录，并在这条记录中标明本次聚合总共调度了多少个消息。按照消息聚合的思路，发生问题时主线程消息调度示意图如下：

{% asset_img 4.png %}

### 消息聚合拆分：
针对上面多消息聚合策略，会存在一些特殊情况，例如在将多个消息进行累计统计过程中，如果前 N 次消息调度结束后，累计耗时都没有超过阈值，但是调度完下一个消息之后，发现累计耗时超过阈值，并且还明显超出，如设置阈值是 300ms，但是前 N 个消息累计 200ms，加上本次消息累计耗时达到了 900ms，那么这种情况，我们明显知道是最后一次消息耗时严重，因此需要将本次消息单独记录，并标记其耗时和相关信息，同时将之前 N 次消息调度耗时和消息数聚合在一起并单独记录，这种场景相当于一次生成 2 条记录。

为了考虑监控工具对性能的影响，我们只在每轮统计需要保存时，更新线程 cpu 执行时间，如果发生消息聚合拆分的场景，会默认前一条记录的 cpu 时间为-1，因为本条记录并不是我们重点关注的，所以会把本轮统计的 cpu 时间全部归到后一条消息。

在一些极端场景下，如本轮监控第一个消息执行耗时为 1ms，但是加上本次消息耗时，累计超过 600ms，因此两次消息累计耗时远大于设定的阈值 300ms，那么就需要对本次耗时严重的消息单独记录，而前面那个 1ms 的消息也需要被单独进行记录；类似情形如此反复，就会出现上面说的保存 100 条记录，整体监控可回溯的时长区间存在波动的情况；该场景的示意图如下：
{% asset_img 5.png %}
### 关键消息聚合：
除了上面单次耗时严重的消息需要拆分并单独记录之外，还有一类消息也需要我们单独标记，以达到更好的识别，那就是可能会引起 ANR 的应用组件，如 Activity，Service，Receiver，Provider 等等。为了监控这几种组件的执行过程，我们需要对 ActivityThread.H 的消息调度进行监控，当发现上面这些组件有关的消息在执行时，不管其耗时多少，都对其进行单独记录，并将之前监控的一个或多个消息也保存为一条记录。该场景的示意图如下：
{% asset_img 6.png %}
### IDLE 场景聚合：
熟悉消息队列的同学都知道，主线程是基于消息队列的方式进行调度，在每次消息调度完成之后都会从消息队列读取下一个待调度的消息，如果消息队列没有消息，或者下一个消息没有到设定的调度时间，并且也没有 IDLE 消息等待调度，那么主线程将会进入 IDLE 状态，如下示意图：
{% asset_img 7.png %}
正是因为上面的调度逻辑，使得主线程在消息调度过程中会多次进入 IDLE 状态，而这个过程也涉及到线程上下文切换(如：Java 环境切换到 Native 环境)，会去检测是否有挂起请求，所以对调用频繁的接口来说，会在 ANR 发生时被命中，理论上调用越频繁的接口被命中的概率越大，如下图堆栈：
{% asset_img 8.png %}
但是上面这种场景的 IDLE 停留时长可长可短，如果按照完全上面那几类消息聚合策略，多个消息连续聚合的话，可能会把这类场景也给聚合进来，一定程度造成干扰，这显然不是我们想要的。为此需要进一步优化，在每次消息调度结束后，获取当前时间，在下次消息调度开始前，再次获取当前时间，并统计距离上次消息调度结束的间隔时长。如果间隔较长，那么也需要单独记录，如果间隔时间较短，我们认为可以忽略，并将其合并到之前统计的消息一起跟踪，到这里就完成了各类场景的监控和归类；该场景的示意图如下：
{% asset_img 9.png %}
### 耗时消息堆栈采样：
在上面重点讲述了主线程消息调度过程的监控和聚合策略，便于发生 ANR，在线下进行回放。但是那些耗时较长的消息，仅仅知道其耗时和消息 tag 是远远不够的，因为每个消息内部的业务逻辑对于我们来说都是黑盒，各个接口耗时也存在很多不确定性，如锁等待、Binder 通信、IO 等系统调用。

因此需要知道这些耗时消息内部接口的耗时情况，我们选取了 2 种方案进行对比：

第一种方案：是对每个函数进行插桩，在进入和退出过程统计其耗时，并进行聚合和汇总。该方案的优点是可以精确的知道每个函数的真实耗时，缺点是很影响包体积和性能，而且不利于其他产品高效复用。

第二种方案，在每个消息开始执行时，触发子线程的超时监控，如果在超时之后本次消息还没执行结束，则抓取主线程堆栈，并继续对该消息设置下一次超时监控，直到该消息执行结束并取消本轮监控。如果在触发超时之前已经执行完毕，则取消本次监控并在下次消息开始执行时，再次设置超时监控，但是因为大部分消息耗时都很少，如果每次都频繁设置和取消，将会带来性能影响，因此我们对此进行优化，采用系统 ANR 超时监控相同的时间对齐方案，具体来说就是： 

以消息开始时间加上超时时长为目标超时时间，每次超时时间到了之后，检查当前时间是否大于或等于目标时间，如果满足，则说明目标时间没有更新，也就是说本次消息没结束，则抓取堆栈。如果每次超时之后，检查当前时间小于目标时间，则说明上次消息执行结束，新的消息开始执行并更新了目标超时时间，这时异步监控需对齐目标超时，再次设置超时监控，如此往复。 

根据上面的思路，整理流程图如下：
{% asset_img 10.png %}
需要注意的是，消息采样堆栈的超时时长不可设置太短，否则频繁抓取堆栈对主线程性能影响较大，同时也不能设置太长，否则会因为采样过低导致数据置信度降低；具体时长根据每个产品复杂度灵活调整即可。

### 监控正在调度消息及耗时：
除了监控 ANR 发生之前主线程历史消息调度及耗时之外，也需要知道 ANR 发生时正在调度的消息及其耗时，以便于在看到 ANR 的 Trace 堆栈时，可以清晰的知道当前 Trace 逻辑到底执行了多长时间，帮忙我们排除干扰，快速定位；借助这个监控可以很好的回答大家，ANR 发生时当前 Trace 堆栈是否耗时以及耗时多久的问题，避免陷入“Trace 堆栈”误区。
### 获取 Pending 消息：
同时除了监控主线程历史消息调度及耗时之外，也需要在 ANR 发生时，获取消息队列中待调度的消息，为我们分析问题时提供更多线索，如：
 - 消息队列中待调度消息是否被 Block 以及被 Block 时长，根据 Block 时长可以推测主线程的繁忙程度；
 - 可以观察消息队列中是否存在发生 ANR 的应用组件消息，如 Service 消息，以及其在待调度消息队列中的位置和 Block 时长；
 - 可以观察消息队列中都有哪些消息，这些消息是否有一定规律，如大量重复消息，如果有大量重复消息，则说明很有可能与该消息相关的业务逻辑发生异常，频繁和主线程交互(后面的案例分析中我们也会有介绍)。

{% asset_img 11.png %}

之前我们讲到，对于一次消息调度，它的耗时可以从两个维度进行统计，即 Wall Duration 和 Cpu Duration，通过这两个维度的统计，可以帮助我们更好的推测一次严重耗时，是执行大量业务逻辑还是处于等待或被抢占的情况。如果是后者，那么可以看到这类消息的 Wall Duration 和 Cpu Duration 比例会比较大，当然如何更好更全面的区分一次消息耗时是等待较多还是线程调度被抢占，我们将会在后面结合其他参考信息进行介绍。

### 完整示意图
在这里我们再把 Cpu Duration 耗时也给统计之后，那么整个有关主线程完整的消息调度监控功能就基本完成了。示意图如下：
{% asset_img 12.png %}
通过这个消息调度监控工具，我们就可以很清晰的看到发生 ANR 时，主线程历史消息调度情况；当前正在调度消息耗时，以及消息队列待调度消息及相关信息；而且利用这个监控工具，一眼便知 ANR 发生时主线程 Trace 实际耗时情况，因此很好解决了部分同学对当前堆栈是否耗时以及耗时多久的疑问。

从上面介绍可以看出，为了重点标记单次耗时消息和关键消息，我们使用了多种聚合策略，因此监控过程记录的信息可能会代表不同类型的消息，为了便于区分，我们在可视化展示时加上 Type 标识，便于区别。

# 应用示例：
例如下图，从 Trace 日志可以看到，ANR 发生时主线程被 Block 在 Binder 通信过程，可能很多同学第一反应是 WMS 服务没有及时响应 Binder 请求导致的问题。
{% asset_img 13.png %}
但是再结合下面的消息调度监控来核实一下，我们发现当前调度的消息 Wall duration 只有 44ms，而在该消息之前有两次历史消息耗时比较严重，分别为 2166ms，3277ms，也就是说本次 Binder 调用耗时并不严重，真正的问题是前面 2 次消息耗时较长，影响了后续消息调度，只有同时解决这 2 个消息耗时严重问题，该 ANR 问题才可能解决。
{% asset_img 14.png %}
如果没有消息调度监控工具，上去就盲目的分析当前逻辑调用的 IPC 问题，可能就犯了方向性的错误，掉入“Trace 堆栈”陷阱中。 

接下来再来看一个发生在线上的另外一个实例，从下图可以看到主线程正在调度的消息耗时超过 1S，但是在此之前的另一个历史消息耗时长达 9828ms。继续观察下图消息队列待调度的消息状态(灰色示意)，可以看到第一个待调度的消息被 Block 了 14S 之久。由此我们可以知道 ANR 消息之前的这个历史消息，才是导致 ANR 的罪魁祸首，当然这个正在执行的消息也需要优化一下性能，因为我们在前面说过：“发生 ANR 时，没有一个消息是无辜的。”
{% asset_img 15.png %}
正是因为有了上面这些监控能力，让我们在日常面对 Trace 日志中的业务逻辑是否耗时以及耗时多久的困惑，瞬间就会变得清晰起来。

# Checktime
## Checktime 背景介绍：
Checktime 是 Android 系统针对一些系统服务(AMS，InputService 等)中高频访问的接口，执行时间的监控，当这类接口真实耗时超过预期值将会给出提示信息，此类设计为了在真实环境监测进程被调度和响应能力的一种结果反馈。具体实现是，在每个函数执行前和执行后分析获取当前系统时间，并计算差值，如果该接口耗时超过其设定的阈值，则会触发“slow operation”的信息提醒，部分代码实现如下：
{% asset_img 16.png %}
Checktime 逻辑很简单，用当前系统时间减去对比时间，如果超过 50ms，则给出 Waring 日志提示。
{% asset_img 17.png %}
我们在分析线下问题，或者在系统层面分析这类问题时，经常会在 logcat 中看到这类消息，但是对于线上的三方应用来说，因为权限问题无法获取系统日志，只能自己实现了。
## 线程 Checktime：
了解完系统 Checktime 设计思路及实现之后，我们就可以在应用层实现类似的功能了。通过借助其它子线程的周期检测机制，`在每次调度前获取当前系统时间，然后减去我们设置延迟的时间，即可得到本次线程调度前的真实间隔时间，如设置线程每隔 300ms 调度一次，结果发现实际响应时间间隔有时会超过 300ms，如果偏差越大，则说明线程没有被及时调度，进一步反映系统响应能力变差`。
通过这样的方式，即使在线上环境获取不到系统日志，也可以从侧面反映不同时段系统负载对线程调度影响，如下图示意，当连续发生多次严重 Delay 时，说明线程调度受到了影响。
{% asset_img 18.png %}
## 小结：
通过上述监控能力，我们可以清晰的知道 ANR 发生时主线程历史消息调度以及耗时严重消息的采样堆栈，同时可以知道正在执行消息的耗时，以及消息队列待中调度消息的状态。同时通过线程 CheckTime 机制从侧面反映线程调度响应能力，由此完成了应用侧监控信息从点到面的覆盖。但是在面对 ANR 问题时，只有这个监控，是远远不够的，需要结合其他信息整体分析，以应对更为复杂的系统环境。下面就结合监控工具来介绍一下 ANR 问题的分析思路。
# ANR 分析思路：
在介绍分析思路之前，我们先来说一下分析这类问题需要用到哪些日志，当然在不同的环境下，获取信息能力会有很大差别，如线下环境和线上环境，应用侧和系统角度都有差异；这里我们会将我们日常排查问题常用的信息都介绍一下，便于大家更好的理解，主要包括以下几种：
 - Trace 日志
 - AnrInfo
 - Kernel 日志
 - Logcat 日志
 - Meminfo 日志
 - Raster 监控工具

对于应用侧来说，在线上环境可能只能拿到当前进程内部的线程堆栈(取决于实现原理，参见：Android 系统的 ANR 设计原理及影响因素)以及 ANR Info 信息。在系统侧，几乎能获取到上面的所有信息，对于这类问题获取的信息越多，分析定位成功率就越大，例如可以利用完整的 Trace 日志，分析跨进程 Block 或死锁问题，系统内存或 IO 紧张程度等等，甚至可以知道硬件状态，如低电状态，硬件频率(CPU，IO，GPU)等等。

## 关键信息解读：
在这里我们把上面列举的日志进行提取并解读，以便于大家在日常开发和面对线上问题，根据当前获取的信息进行参考。

## Trace 信息
在前文Android 系统的 ANR 设计原理及影响因素中，我们讲到了在发生 ANR 之后，系统会 Dump 当前进程以及关键进程的线程堆栈，状态(红框所示关键信息，稍后详细说明)，示例如下：
{% asset_img 19.png %}

上面的日志包含很多信息，这里将常用的关键信息进行说明，如下：
 - 线程堆栈：
 这个比较好理解，也就是发生 ANR 时，线程正在执行的逻辑，但是很多场景下，获取的堆栈耗时并不长，原因详见Android 系统的 ANR 设计原理及影响因素。
 - 线程状态：
 见上图“state=xxx”，表示当前线程工作状态，Running 表示当前线程正在被 CPU 调度，Runnable 表示线程已经 Ready 等待 CPU 调度，如上图 SignalCatcher 线程状态。Native 态则表示线程由 Java 环境进入到 Native 环境，可能在执行 Native 逻辑，也可能是进入等待状态；Waiting 表示处于空闲等待状态。除此之外还有 Sleep，Blocked 状态等等；
 - 线程耗时：
 见上图“utmXXX，stmXXX”，表示该线程从创建到现在，被 CPU 调度的真实运行时长，不包括线程等待或者 Sleep 耗时，其中线程 CPU 耗时又可以进一步分为用户空间耗时(utm)和系统空间耗时(stm)，这里的单位是 jiffies，当 HZ=100 时，1utm 等于 10ms。
 - utm： Java 层和 Native 层非 Kernel 层系统调用的逻辑，执行时间都会被统计为用户空间耗时；
 - stm： 即系统空间耗时，一般调用 Kernel 层 API 过程中会进行空间切换，由用户空间切换到 Kernel 空间，在 Kernel 层执行的逻辑耗时会被统计为 stm，如文件操作，open,write,read 等等；
 - core：最后执行这个线程的 cpu 核的序号。
 - 线程优先级：
 nice： 该值越低，代表当前线程优先级越高，理论上享受的 CPU 调度能力也越强。对于应用进程(线程)来说，nice 范围基本在 100~139。随着应用所在前后台不同场景，系统会对进程优先级进行调整，厂商可能也会开启 cpu quota 等功能去限制调度能力；
 - 调度态：
 schedstat： 参见“schedstat=( 1813617862 14167238 546 )”，分别表示线程 CPU 执行时长(单位 ns)，等待时长，Switch 次数。

## AnrInfo 信息
除了 Trace 之外，系统会在发生 ANR 时获取一些系统状态，如 ANR 问题发生之前和之后的系统负载以及 Top 进程和关键进程 CPU 使用率。这些信息如果在本地环境可以从 Logcat 日志中拿到，也可以在应用侧通过系统提供的 API 获取(参见：Android 系统的 ANR 设计原理及影响因素)，Anr Info 节选部分信息如下：
{% asset_img 20.png %}
对于上图信息，主要对以下几部分关键信息进行介绍：
 - ANR 类型(longMsg)：
 表示当前是哪种类型的消息或应用组件导致的 ANR，如 Input，Receiver，Service 等等。
 - 系统负载(Load)：
 表示不同时间段的系统整体负载，如："Load：45.53 / 27.94 / 19.57"，分布代表 ANR 发生前 1 分钟，前 5 分钟，前 15 分钟各个时间段系统 CPU 负载，具体数值代表单位时间等待系统调度的任务数(可以理解为线程)。如果这个数值过高，则表示当前系统中面临 CPU 或 IO 竞争，此时，普通进程或线程调度将会受到影响。如果手机处于温度过高或低电等场景，系统会进行限频，甚至限核，此时系统调度能力也会受到影响。 
 此外，可以将这些时间段的负载和应用进程启动时长进行关联。如果进程刚启动 1 分钟，但是从 Load 数据看到前 5 分钟，甚至前 15 分钟系统负载已经很高，那很大程度说明本次 ANR 在很大程度会受到系统环境影响。
 - 进程 CPU 使用率：
 如上图，表示当前 ANR 问题发生之前(CPU usage from XXX to XXX ago)或发生之后(CPU usage from XXX to XXX later)一段时间内，都有哪些进程占用 CPU 较高，并列出这些进程的 user，kernel 的 CPU 占比。当然很多场景会出现 system_server 进程 CPU 占比较高的现象，针对这个进程需要视情况而定，至于 system_server 进程 CPU 占比为何普遍较高，参见：Android 系统的 ANR 设计原理及影响因素。 
 minor 表示次要页错误，文件或其它内存被加载到内存后，但是没有被映射到当前进程，通过内核访问时，会触发一次 Page Fault。如果访问的内容还没有加载到内存，那么会触发 major，所以对比可以看到，major 的系统开销会比 minor 大很多。
 - 关键进程：
 kswapd： 是 linux 中用于页面回收的内核线程，主要用来维护可用内存与文件缓存的平衡，以追求性能最大化，当该线程 CPU 占用过高，说明系统可用内存紧张，或者内存碎片化严重，需要进行 file cache 回写或者内存交换(交换到磁盘)，线程 CPU 过高则系统整体性能将会明显下降，进而影响所有应用调度。
 mmcqd： 内核线程，主要作用是把上层的 IO 请求进行统一管理和转发到 Driver 层，当该线程 CPU 占用过高，说明系统存在大量文件读写，当然如果内存紧张也会触发文件回写和内存交换到磁盘，所以 kswapd 和 mmcqd 经常是同步出现的。
 - 系统 CPU 分布：
 如下图，反映一段时间内，系统整体 CPU 使用率，以及 user，kernel，iowait 方向的 CPU 占比，如果发生大量文件读写或内存紧张的场景，则 iowait 占比较高，这个时候则要进一步观察上述进程的 kernel 空间 CPU 使用情况，并通过进程 CPU 使用，再进一步对比各个线程的 CPU 使用，找出占比最大的一个或一类线程。
 {%asset_img 21.png %}
 - Logcat 日志：
 在 log 日志中，我们除了可以观察业务信息之外，还有一些关键字也可以帮我们去推测当前系统性能是否遇到问题，如下图， “`Slow operation`”，“`Slow delivery`” 等等。
 {%asset_img 22.png %}
 - Slow operation
 Android 系统在一些频繁调用的接口中，分别在方法前后利用 checktime 检测，以判断本次函数执行耗时是否超过设定阈值，通常这些值都会设置的较为宽松，如果实际耗时超过设置阈值，则会给出“Slow XXX”提示，表示系统进程调度受到了影响，一般来说系统进程优先级比较高，如果系统进程调度都受到了影响，那么则反映了这段时间内系统性能很有可能发生了问题。
 - Kernel 日志：
 对于应用侧来说，这类日志基本是拿不到的，但是如下是在线下测试或者从事系统开发的同学，可以通过 dmesg 命令进行查看。对于 kernel 日志，我们主要分析的是 lowmemkiller 相关信息，如下图：
 {%asset_img 23.png %}
 - Lowmemkiller：
 从事性能(内存)优化的同学对该模块都比较熟悉，主要是用来监控和管理系统可用内存，当可用内存紧张时，从 kernel 层强制 Kill 一些低优先级的应用，以达到调节系统内存的目的。而选择哪些应用，则主要参考进程优先级(oom_score_adj)，这个优先级是 AMS 服务根据应用当前的状态，如前台还是后台，以及进程存活的应用组件类型而计算出来的。例如：对于用户感知比较明显的前台应用，优先级肯定是最高的，此外还有一些系统服务，和后台服务(播放器场景)优先级也会比较高。当然厂商也对此进行了大量的定制(优化)，以防止三方应用利用系统设计漏洞，将自身进程设置太高优先级进而达到保活目的。
 - 消息调度时序图：
 {%asset_img 24.png %}
 如上图，在我们分析完系统日志之后，会进一步的锁定或缩小范围，但是最终我们还是要回归到主线程进一步的分析 Trace 堆栈的业务逻辑以及耗时情况，以便于我们更加清晰的知道正在调度的消息持续了多长时间。但是很多情况当前 Trace 堆栈并不是我们期待的答案，因此需要进一步的确认 ANR 之前主线程的调度信息，评估历史消息对后续消息调度的影响，便于我们寻找“真凶”。
 当然，有时也需要进一步的参考消息队列中待调度消息，在这些消息里面，除了可以看到 ANR 时对应的应用组件被 Block 的时长之外，还可以了解一下都有哪些消息，这些消息的特征有时对于我们分析问题也会提供有力的证据和方向。

## 分析思路
在上面我们对各类日志的关键信息进行了基本释义，下面就来介绍一下，当我们日常遇到 ANR 问题时，是如何分析的，总结思路如下：
 - 分析堆栈，看看是否存在明显业务问题(如死锁，业务严重耗时等等)，如果无上述明显问题，则进一步通过 ANR Info 观察系统负载是否过高，进而导致整体性能较差，如 CPU，Mem，IO。然后再进一步分析是本进程还是其它进程导致，最后再分析进程内部分析对比各个线程 CPU 占比，找出可疑线程。
 - 综合上述信息，利用监控工具收集的信息，观察和找出 ANR 发生前一段时间内，主线程耗时较长的消息都有哪些，并查看这些耗时较长的消息执行过程中采样堆栈，根据堆栈聚合展示，进一步的对比当前耗时严重的接口或业务逻辑。

以上分析思路，进一步细分的话，可以分为以下几个步骤：
 - 一看 Trace：
   - 死锁堆栈： 观察 Trace 堆栈，确认是否有明显问题，如主线程是否与其他线程发生死锁，如果是进程内部发生了死锁，那么恭喜，这类问题就清晰多了，只需找到与当前线程死锁的线程，问题即可解决；
   - 业务堆栈： 观察通过 Trace 堆栈，发现当前主线程堆栈正在执行业务逻辑，你找到对应的业务同学，他承认该业务逻辑确实存在性能问题，那么恭喜，你很有可能解决了该问题，为什么只是有可能解决该问题呢？因为有些问题取决于技术栈或框架设计，无法在短时间内解决。如果业务同学反馈当前业务很简单，基本不怎么耗时，而这种场景也是日常经常遇到的一类问题，那么就可能需要借助我们的监控工具，追溯历史消息耗时情况了；
   - IPC Block 堆栈： 观察通过 Trace 堆栈，发现主线程堆栈是在跨进程(Binder)通信，那么这个情况并不能当即下定论就是 IPC block 导致，实际情况也有可能是刚发送 Binder 请求不久，以及想要进一步的分析定位，这时也需要借助我们的自研监控工具了；
   - 系统堆栈： 通过观察 Trace，发现当前堆栈只是简单的系统堆栈，想要搞清楚是否发生严重耗时，以及进一步的分析定位，如我们常见的 NativePollOnce 场景，那么也需要借助我们的自研监控工具进一步确认了。
 - 二看关键字：Load，CPU，Slow Operation，Kswapd，Mmcqd，Kwork，Lowmemkiller 等等
 刚才我们介绍到，上面这些关键字是反应系统 CPU，Mem，IO 负载的关键信息，在分析完主线程堆栈信息之后，还需要进一步在 ANRInfo，logcat 或 Kernel 日志中搜索这些关键字，并根据这些关键字当前数值，判断当前系统是否存在资源(CPU，Mem，IO)紧张的情况；
 - 三看系统负载分布：观察系统整体负载：User,Sys,IOWait
 通过观察系统负载，则可以进一步明确是 CPU 资源紧张，还是 IO 资源紧张；如果系统负载过高，一定是有某个进程或多个进程引起的。反之系统负载过高又会影响到所有进程调度性能。通过观察 User，Sys 的 CPU 占比，可以进一步发分析当前负载过高是发生在应用空间，还是系统空间，如大量调用逻辑(如文件读写，内存紧张导致系统不断回收内存等等)，知道这些之后，排查方向又会进一步缩小范围。
 - 四看进程 CPU：观察 Top 进程的 CPU 占比
 从上面分析，在我们知道当前系统负载过高，是发生在用户空间还是内核空间之后，那么我们就要通过 Anrinfo 的提供的进程 CPU 列表，进一步锁定是哪个(些)进程导致的，这时则要进一步的观察每个进程的 CPU 占比，以及进程内部 user，sys 占比。
  - 在分析进程 CPU 占比过程，有一个关键的信息，要看统计这些进程 CPU 过高的场景是发生在 ANR 之前的一段时间还是之后一段时间，如下图表示 ANR 之前 4339ms 到 22895ms 时间内进程的 CPU 使用率。
  {% asset_img 25.png %}
 - 五看 CPU 占比定线程 ：对比各线程 CPU 占比，以及线程内部 user 和 kernel 占比
 在通过系统负载(user,sys,iowait)锁定方向之后，又通过进程列表锁定目标进程，那么接下来我们就可以从目标进程内部分析各个线程的(utm,stm)，进一步分析是哪个线程有问题了。
 在 Trace 日志的线程信息里可以清晰的看到每个线程的 utm，stm 耗时。至此我们就完成了从系统到进程，再到进程内部线程方向的负载分析和排查。当然，有时候可能导致系统高负载的不是当前进程，而是其他进程导致，这时同样会影响其他进程，进而导致 ANR。
 - 六看消息调度锁定细节 ：
  在分析和明确系统负载是否正常，以及负载过高是哪个进程引起的结论之后，接下来便要通过我们的监控工具，进一步排查是当前消息调度耗时导致，历史消息调度耗时导致，还是消息过于频繁导致。同时通过我们的线程 CheckTime 调度情况分析当前进程的 CPU 调度是否及时以及影响程度，在锁定上述场景之后，再进一步分析耗时消息的采样堆栈，才算找到解决问题的终极之钥。当然耗时消息内部可能存在一个或多个耗时较长的函数接口，或者会有多个消息存在耗时较长的函数接口，这就是我们前文中提到的：“发生 ANR 时，没有一个消息是无辜的”
## 更多信息：
除了上面的一些信息，我们还可以结合 logcat 日志分析 ANR 之前的一些信息，查看是否存在业务侧或系统侧的异常输出，如搜索“Slow operation”，"Slow delivery"等关键字。也可以观察当前进程和系统进程是否存在频繁 GC 等等，以帮忙我们更全面的分析系统状态。
## 总结：
上面我们重点介绍了基于主线程消息调度的监控工具，实现了“由点到面”的监控能力，以便于发生 ANR 问题时，可以更加清晰直观的整体评估主线程的“过去，现在和将来”。同时结合日常实践，介绍了在应用侧分析 ANR 问题经常用到的日志信息和分析思路。 

目前，Raster 监控工具因为其很好的提升了问题定位效率和成功率，成为 ANR 问题分析利器，并融合到公司性能稳定性监控平台，为公司众多产品广泛使用。接下来我们将利用该工具并结合上面的分析思路，讲一讲实际工作中遇到不同类型的 ANR 问题时，是如何快速分析和定位问题的。

]]></content>
      <tags>
        <tag>Android</tag>
        <tag>ANR</tag>
      </tags>
  </entry>
  <entry>
    <title>消息监控工具的一种实现思路</title>
    <url>/2024/08/11/ANR-page-2/</url>
    <content><![CDATA[
在 [今日头条 ANR 优化实践系列 - 监控工具与分析思路](#../ANR-page-1) 文中描述到使用了一种名为“Raster”的工具来做消息监控，对于ANR比较有用。但是在网络上没有搜到这个工具的具体实现方案。
本文来设计一种类似的消息监控的实现思路。

<!-- more -->

这里大概说一下思路。
1. 记录主线程Looper的消息分发记录
2. 当 Signal Catcher线程收到QUIT消息的时候，Jni回调到ActivityThread，获取记录好的消息分发记录
3. 写入 trace 文件。

下面是一种参考实现方式
```diff
commit cd0214ccd7e58224723eb3d581ef67afc3d43161
Author: BDZNH
Date:   Mon Aug 19 22:34:37 2024 +0800

    anr catch sample

diff --git a/art/runtime/signal_catcher.cc b/art/runtime/signal_catcher.cc
index f76a0d0b7b..c4414f1396 100644
--- a/art/runtime/signal_catcher.cc
+++ b/art/runtime/signal_catcher.cc
@@ -114,6 +114,36 @@ void SignalCatcher::Output(const std::string& s) {
   }
 }
 
+void testCallActivityThread(std::ostringstream& os) {
+  LOG(INFO) << "start testCallActivityThread";
+  Thread* self = Thread::Current();
+  JNIEnv* env = self->GetJniEnv();
+  jclass clazz = env->FindClass("android/app/ActivityThread");
+  if(clazz == nullptr) {
+    LOG(ERROR) << "can't find class android/app/ActivityThread";
+    return;
+  }
+  jmethodID onSignalQuitMethod = env->GetStaticMethodID(clazz,"onSignalQuit","()Ljava/lang/String;");
+  if(onSignalQuitMethod == nullptr) {
+    LOG(ERROR) << "can't find method onSignalQuitMethod";
+    return;
+  }
+  LOG(INFO) << "call android.app.ActivityThread.onSignalQuit";
+  LOG(INFO) << "clazz: " << (void*)clazz << "  method: " << (void*)onSignalQuitMethod;
+  jstring retstring = (jstring)(env->CallStaticObjectMethod(clazz,onSignalQuitMethod));
+  if(retstring != nullptr) {
+    const char* str = env->GetStringUTFChars(retstring,NULL);
+    if(str != nullptr) {
+      // LOG(INFO) << str ;
+      os << str << "\n";
+    } else {
+      LOG(ERROR) << "Java api return null ptr";
+    }
+  } else {
+    LOG(ERROR) << "Java api return null ptr";
+  }
+}
+
 void SignalCatcher::HandleSigQuit() {
   Runtime* runtime = Runtime::Current();
   std::ostringstream os;
@@ -130,6 +160,9 @@ void SignalCatcher::HandleSigQuit() {
 
   os << "Build type: " << (kIsDebugBuild ? "debug" : "optimized") << "\n";
 
+  os << ">>>>>>>>>> Begin dump main thread handler history" << "\n";
+  testCallActivityThread(os);
+  os << ">>>>>>>>>> finish dump main thread handler history" << "\n";
   runtime->DumpForSigQuit(os);
 
   if ((false)) {
diff --git a/frameworks/base/core/java/android/app/ActivityThread.java b/frameworks/base/core/java/android/app/ActivityThread.java
index 8af74edb88..dfce7abfe2 100644
--- a/frameworks/base/core/java/android/app/ActivityThread.java
+++ b/frameworks/base/core/java/android/app/ActivityThread.java
@@ -7818,6 +7818,20 @@ public final class ActivityThread extends ClientTransactionHandler
         }
     }
 
+    /**
+     * @hide
+     */
+    public static String onSignalQuit() {
+        Log.i("HSP","onSignalQuit call begin");
+        StringBuilder sb = new StringBuilder();
+        Looper.getMainLooper().dump((str)->{
+            sb.append(str);
+            sb.append("\n");
+        }," ");
+        Log.i("HSP","onSignalQuit call end");
+        return sb.toString();
+    }
+
     public static void main(String[] args) {
         Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
 
@@ -7860,11 +7874,17 @@ public final class ActivityThread extends ClientTransactionHandler
             sMainThreadHandler = thread.getHandler();
         }
 
-        if (false) {
+        if(SystemProperties.getBoolean("persist.sys.debug.looper.history",false)) {
+            Looper.myLooper().enableDispatchHistory();
+        }
+
+        if (SystemProperties.getBoolean("persist.sys.debug.handler",false)) {
             Looper.myLooper().setMessageLogging(new
                     LogPrinter(Log.DEBUG, "ActivityThread"));
+            Looper.myLooper().setTraceTag(Trace.TRACE_TAG_ALWAYS);
         }
 
+
         // End of event ActivityThreadMain.
         Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
         Looper.loop();
diff --git a/frameworks/base/core/java/android/os/Looper.java b/frameworks/base/core/java/android/os/Looper.java
index 8c98362fa9..8f6144d988 100644
--- a/frameworks/base/core/java/android/os/Looper.java
+++ b/frameworks/base/core/java/android/os/Looper.java
@@ -152,6 +152,15 @@ public final class Looper {
         sObserver = observer;
     }
 
+    MessageDispatchRecorder mMessageRecorder;
+
+    /**
+     * @hide
+     */
+    public void enableDispatchHistory(){
+        mMessageRecorder = new MessageDispatchRecorder();
+    }
+
     /**
      * Poll and deliver single message, return true if the outer loop should continue.
      */
@@ -186,8 +195,14 @@ public final class Looper {
         final boolean needStartTime = logSlowDelivery || logSlowDispatch;
         final boolean needEndTime = logSlowDispatch;
 
+
+        if(me.mMessageRecorder != null) {
+            me.mMessageRecorder.beginRecord(msg);
+        }
+        String traceHandleMsg = msg.target.getTraceName(msg);
         if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
             Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
+            Slog.v("TraceHandler","Dispatching to" + traceHandleMsg);
         }
 
         final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
@@ -232,10 +247,16 @@ public final class Looper {
             showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
         }
 
+        if(me.mMessageRecorder != null) {
+            me.mMessageRecorder.endRecord();
+        }
+
         if (logging != null) {
             logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
+            Slog.v("TraceHandler","Finished Dispatching to" + traceHandleMsg);
         }
 
+
         // Make sure that during the course of dispatching the
         // identity of the thread wasn't corrupted.
         final long newIdent = Binder.clearCallingIdentity();
@@ -422,6 +443,9 @@ public final class Looper {
      * @param prefix A prefix to prepend to each line which is printed.
      */
     public void dump(@NonNull Printer pw, @NonNull String prefix) {
+        if(mMessageRecorder != null) {
+            pw.println(mMessageRecorder.toString());
+        }
         pw.println(prefix + toString());
         mQueue.dump(pw, prefix + "  ", null);
     }
diff --git a/frameworks/base/core/java/android/os/MessageDispatchRecorder.java b/frameworks/base/core/java/android/os/MessageDispatchRecorder.java
new file mode 100644
index 0000000000..b0177d4296
--- /dev/null
+++ b/frameworks/base/core/java/android/os/MessageDispatchRecorder.java
@@ -0,0 +1,68 @@
+package android.os;
+
+import android.os.Message;
+import android.os.SystemClock;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+class MessageDispatchRecorder {
+    private final ArrayList<Recorder> mRecorders;
+    public MessageDispatchRecorder(){
+        mRecorders = new ArrayList<>();
+    }
+
+    public void beginRecord(Message msg){
+        Recorder recorder = new Recorder();
+        recorder.expectStartWhen = msg.getWhen();
+        recorder.realStatWhen = SystemClock.uptimeMillis();
+        recorder.descrip = "\""+msg.toString()+"\"";
+        synchronized(this){
+            mRecorders.add(recorder);
+            if(mRecorders.size() > 1000){
+                mRecorders.remove(0);
+            }
+        }
+        mRecorders.add(recorder);
+        if(mRecorders.size() > 1000){
+            mRecorders.remove(0);
+        }
+    }
+
+    public void endRecord(){
+        mRecorders.get(mRecorders.size()-1).realEndWhen = SystemClock.uptimeMillis();
+    }
+
+    @Override
+    public String toString() {
+
+        long now = SystemClock.uptimeMillis();
+        StringBuilder builder = new StringBuilder();
+        builder.append("now time is ");
+        builder.append(now);
+        builder.append("\n");
+        synchronized(this){
+            for (Recorder recorder:mRecorders){
+            if(recorder.realEndWhen > recorder.expectStartWhen) {
+                builder.append(String.format(Locale.CHINA,"when=%d realWhen=%d realEnd=%d duration=%d desc:%s",
+                        recorder.expectStartWhen,recorder.realStatWhen,recorder.realEndWhen,
+                        recorder.realEndWhen- recorder.realStatWhen,recorder.descrip));
+            } else {
+                builder.append(String.format(Locale.CHINA,"when=%d realWhen=%d realEnd=%d duration=%d desc:%s",
+                        recorder.expectStartWhen,recorder.realStatWhen,recorder.realEndWhen,
+                        0,recorder.descrip));
+            }
+            builder.append("\n");
+        }
+        }
+
+        builder.append(String.format(Locale.CHINA,"there are %d history message\n",mRecorders.size()));
+        return builder.toString();
+    }
+    private static class Recorder{
+        long expectStartWhen;
+        long realStatWhen;
+        long realEndWhen;
+        String descrip;
+    }
+}
\ No newline at end of file

```

大体做法就是，记录主线程Looper的消息分发记录，当触发ANR（或者接收到 Signal 3）的时候，将消息分发记录打印到trace文件里面，辅助分析。

效果大概如下

{% asset_img record.png %}

注：上面的示范中，没有去移除分发记录，在实际的生产环境里面，需要为移除分发记录设定一定的条件，避免占用过多内存。]]></content>
      <tags>
        <tag>Android</tag>
        <tag>ANR</tag>
      </tags>
  </entry>
  <entry>
    <title>Android Native Service 示例 第二篇</title>
    <url>/2024/07/31/Android-native-service-sample-2/</url>
    <content><![CDATA[在安卓里面实现一个 native 的系统服务，不仅可以通过定义 Interface ，还可以通过直接继承 BBinder 来实现。本篇文章即讲述如何通过继承 Bbinder 来实现一个系统服务，并且讲述如何在 native 上使用 binder 的 linktoDeath 机制

<!-- more -->

首先列出需要包含的头文件
```cpp
// CommonHeader.h
#ifndef _COMMON_HEADER_H_
#define _COMMON_HEADER_H_
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <binder/PermissionController.h>
#include <binder/ProcessInfoService.h>
#include <binder/IResultReceiver.h>
#include <utils/String8.h>
#include <utils/String16.h>
#include <log/log_main.h>
#include "Cmdid.h"
#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "NativeService"
#define NATIVESERVICE_NAME "nativeservice"
#endif
```

这里为了方便，我将可能用到的头文件都聚在一起了。

# 服务端

然后服务端的声明
```cpp
//NativeServiceSampleService.h
#ifndef _NATIVE_SERVICE_SAMPLE_SERVICE_H_
#define _NATIVE_SERVICE_SAMPLE_SERVICE_H_

#include "CommonHeader.h"
#include <map>

namespace android
{
    enum STATUS {
        SUCCESS = NO_ERROR,
        FAILED = UNKNOWN_TRANSACTION
    };
    typedef status_t (*local_method)(const Parcel &data, Parcel *reply);
    class NativeServiceSampleService : public BBinder {
    public:
        NativeServiceSampleService();
        virtual status_t onTransact(uint32_t code,const Parcel& data, Parcel* reply,uint32_t flags = 0);
        status_t dump(int fd, const Vector<String16> &args);
        int onShellCommand(int in, int out, int err, const Vector<String16> &args);
        virtual status_t invoke(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
        virtual const String16& getInterfaceDescriptor() const{return this->interface;};
    private:
        int shellCommand(int in, int out, int err, const Vector<String16> &args);
        int getCallingPid(){return IPCThreadState::self()->getCallingPid();}
        int getCallingUid(){return IPCThreadState::self()->getCallingUid();}
        std::map<uint32_t,local_method> methods;
        String16 interface = String16(NATIVESERVICE_NAME);
    };
} // namespace android

#endif
```
这里最重要的依然是 onTransact ，Binder 通信的第一站就是这里，来看看服务端的实现
```cpp
//NativeServiceSampleService.cpp
#include "NativeServiceSampleService.h"
#include "Cmdid.h"
namespace android
{
    status_t sampleCallFunction(const Parcel&data, Parcel* reply){
        String8 str = String8(data.readString16());
        ALOGD("call funcion called with \"%s\"",str.string());
        return SUCCESS;
    }

    status_t sampleGetFunction(const Parcel&data, Parcel* reply){
        ALOGD("get function called");
        String16 hello = String16("this is message from service");
        reply->writeString16(hello);
        return SUCCESS;
    }

    status_t getMacByInterfaceName(const Parcel &data, Parcel *reply)
    {
        String16 ifname = data.readString16();
        ALOGV("get mac of ifname: %s",String8(ifname).string());
        String8 path = String8("/sys/class/net/");
        path += String8(ifname);
        path += String8("/address");
        FILE* fp = fopen(path.string(),"ro");
        if(fp == NULL){
            ALOGE("open %s failed(%d): %s",path.string(),errno,strerror(errno));
            return FAILED;
        }

        char mac[18] = {0};
        size_t readsize = fread(mac,1,17,fp);
        if(readsize != 17){
            ALOGE("read mac failed");
            fclose(fp);
            return FAILED;
        }
        String16 result = String16(mac);
        reply->writeString16(result);
        fclose(fp);
        return SUCCESS;
    }

    status_t SampleExitService(const Parcel &data,Parcel *reply)
    {
        ALOGI("service exit now");
        printf("service received exit message\n");
        exit(0);
        return SUCCESS;
    }

    NativeServiceSampleService::NativeServiceSampleService()
    {
        methods[SAMPLE_CALL] = &sampleCallFunction;
        methods[SAMPLE_GET] = &sampleGetFunction;
        methods[SAMPLE_GET_MAC] = &getMacByInterfaceName;
        methods[SAMPLE_EXIT_SERVER] = &SampleExitService;
    }

    status_t NativeServiceSampleService::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
    {
        if (code == SHELL_COMMAND_TRANSACTION)
        {
            int in = data.readFileDescriptor();
            int out = data.readFileDescriptor();
            int err = data.readFileDescriptor();
            int argc = data.readInt32();
            Vector<String16> args;
            for (int i = 0; i < argc && data.dataAvail() > 0; i++)
            {
                args.add(data.readString16());
            }
            status_t result = 0;
            sp<IBinder> unusedCallback;
            sp<IResultReceiver> resultReceiver;
            if ((result = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR)
            {
                return result;
            }
            if ((result = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR)
            {
                return result;
            }
            result = shellCommand(in, out, err, args);
            if (resultReceiver != nullptr)
            {
                resultReceiver->send(result);
            }
            return result;
        }
        else if (IBinder::FIRST_CALL_TRANSACTION <= code && code <= IBinder::LAST_CALL_TRANSACTION)
        {
            CHECK_INTERFACE(INativeServiceSampleService, data, reply);
            return invoke(code, data, reply, flags);
        }
        else
        {
            return BBinder::onTransact(code, data, reply, flags);
        }
    }

    status_t NativeServiceSampleService::shellCommand(int in, int out, int err, const Vector<String16> &args)
    {
        return onShellCommand(in, out, err, args);
    }

    status_t NativeServiceSampleService::onShellCommand(int in, int out, int err, const Vector<String16> &args)
    {
        ALOGI("onShellCommand not implementation yet");
        write(out, "onShellCommand not implementation yet\n", 38);
        size_t size = args.size();
        for (size_t i = 0; i < size; i++)
        {
            ALOGI("Received No.%zu arg: %s", i, String8(args[i]).string());
        }
        return SUCCESS;
    }

    status_t NativeServiceSampleService::dump(int fd, const Vector<String16> &args)
    {
        ALOGI("dump not implementation yet");
        write(fd, "dump not implementation yet\n", 28);
        size_t size = args.size();
        for (size_t i = 0; i < size; i++)
        {
            ALOGI("Received No.%zu arg: %s", i, String8(args[i]).string());
        }
        return SUCCESS;
    }

    status_t NativeServiceSampleService::invoke(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
    {
        std::map<uint32_t, local_method>::iterator iter = methods.find(code);
        ALOGV("uid:%d pid:%d called method %u",getCallingUid(),getCallingPid(),code);
        if (iter != methods.end())
        {
            return (*(iter->second))(data, reply);
        }
        else
        {
            ALOGE("can't find such a method whose cmdid is %u", code);
            return -1;
        }
    }
}
```
同样的，这里用一个 map 来保存了不同code和对应的函数的指针，服务端接收到调用时，可以判断 code 来直接从 map 里面取到相应的函数指针来调用并返回。
dump 和 shellcommand 是通过 dumpsys servicename 和 cmd servicename 这两种方式，会接收到的特殊 code ，这里同样封装成了接口，以供实现。
这个时候，服务端的实现已经完成了，可以参考下面的办法来启动一个服务端
```cpp
//server.cpp
#include "NativeServiceSampleService.h"
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/IPCThreadState.h>
#include <utils/String8.h>
#include <utils/String16.h>

int main(int argc, char **argv)
{
    printf("start %s\n",NATIVESERVICE_NAME);
    ALOGI("start %s",NATIVESERVICE_NAME);
    android::defaultServiceManager()->addService(android::String16(NATIVESERVICE_NAME), new android::NativeServiceSampleService());
    android::ProcessState::self()->startThreadPool();
    android::IPCThreadState::self()->joinThreadPool();
    return 0;
}
```
addService 见名知意，android::ProcessState::self()->startThreadPool(); 则是监听Binder通信的各种消息。android::IPCThreadState::self()->joinThreadPool(); 会阻塞在这里，通常我们是希望服务端保持运行的。

# 客户端
客户端是调用方，调用方最后调用的都是 Binder 的 transact ，当一个服务没有通过 interface 来声明的时候，我们可以直接调用 Binder 的  transact 来调用服务端。这里我们为客户端加上监听服务端是否退出的机制，这样客户端在调用过程中，如果服务端推出了，那么后续的调用则不再接收。

首先是 DeathRecipient ，与 java 层的类似，native 的也是继承相应的类
```cpp
//NativeServiceSampleDeathRecipient.h
#ifndef _NATIVE_SERVICE_SAMPLE_DEATH_RECIPIENT_H_
#define _NATIVE_SERVICE_SAMPLE_DEATH_RECIPIENT_H_

#include "CommonHeader.h"
#include <mutex>
#include <atomic>

namespace android{
    class NativeServiceSampleDeathRecipient : public IBinder::DeathRecipient
    {
        public:
        NativeServiceSampleDeathRecipient(){mValidVar.store(invalid,std::memory_order_relaxed);};
        bool setValid(){
            return mValidVar.compare_exchange_strong(invalid,valid);
        }
        bool setInvalid(){
            return mValidVar.compare_exchange_strong(valid,invalid);
        }
        bool isValid(){
            return mValidVar.load();
        }
        private:
        virtual void binderDied(const wp<IBinder>& who) {
            ALOGE("service died. set service invalid");
            setInvalid();
        };
        std::atomic_bool mValidVar;
        bool valid = true;
        bool invalid = false;
    };
}

#endif
```
定义一个类，继承于 IBinder::DeathRecipient ，并覆写 binderDied 。

来看客户端的声明
```cpp
//NativeServiceSampleClient.h
#ifndef _NATIVE_SERVICE_SAMPLE_CLIENT_H_
#define _NATIVE_SERVICE_SAMPLE_CLIENT_H_
#include "CommonHeader.h"
#include "NativeServiceSampleDeathRecipient.h"
namespace android{
    class NativeServiceSampleClient{
        public:
        NativeServiceSampleClient();
        ~NativeServiceSampleClient();
        status_t invoke(uint32_t code, const Parcel &data, Parcel *reply,int flag);
        status_t invoke(uint32_t code, const Parcel &data, Parcel *reply);
        private:
        sp<IBinder> service;
        sp<NativeServiceSampleDeathRecipient> mdeathRecipient;
    };
}
#endif
```
看客户端的实现
```cpp
//NativeServiceSampleClient.cpp
#include "NativeServiceSampleClient.h"

namespace android{
    NativeServiceSampleClient::NativeServiceSampleClient(){
        sp<IServiceManager> sm = defaultServiceManager();
        if (sm == NULL)
        {
            ALOGE("can not get service manager");
            return;
        }
        service = sm->getService(String16(NATIVESERVICE_NAME));
        if (service == NULL)
        {
            ALOGE("can not get service");
            return;
        }
        mdeathRecipient = new NativeServiceSampleDeathRecipient();
        if(service->linkToDeath(mdeathRecipient) != NO_ERROR)
        {
            ALOGE("link to death failed");
            return;
        }
        ALOGI("client link to death success");
        if(!mdeathRecipient->setValid()){
            ALOGE("set death recipient valid failed");
        }
        if(mdeathRecipient->isValid()){
            ALOGI("service is running");
        }else{
            ALOGE("service is not running and why ?");
        }
    }

    NativeServiceSampleClient::~NativeServiceSampleClient()
    {
        if(service != nullptr)
        {
            if(mdeathRecipient->isValid())
            {
                if(service->unlinkToDeath(mdeathRecipient) == NO_ERROR)
                    ALOGD("unlinktodeath success");
                else
                    ALOGE("unlinktodeath failed");
            }
            else
            {
                ALOGE("service is not running. need unlinkToDeath ?");
            }
        }
    }

    status_t NativeServiceSampleClient::invoke(uint32_t code, const Parcel &data, Parcel *reply)
    {
        return invoke(code,data,reply,0);
    }

    status_t NativeServiceSampleClient::invoke(uint32_t code, const Parcel &data, Parcel *reply,int flags)
    {
        if (!mdeathRecipient->isValid())
        {
            ALOGE("service is not running");
            return -1;
        }
            
        Parcel send;
        send.writeInterfaceToken(android::String16(NATIVESERVICE_NAME));
        send.appendFrom(&data, 0, data.dataSize());
        return service->transact(code, send, reply,flags);
    }
}
```
客户端主要干两个事情，定义一个对外提供 transact 调用的接口，以及在构造的时候，为服务端的 binder 对象 linktoDeath ，这样服务端中途退出时，客户端可以知道相应的消息

```cpp
//Cmdid.h
#ifndef _CMDID_H_
#define _CMDID_H_
#include "binder/IBinder.h"
namespace android{
    enum ENUME_CMD{
        SAMPLE_CALL = IBinder::FIRST_CALL_TRANSACTION,
        SAMPLE_GET,
        SAMPLE_GET_MAC,
        SAMPLE_EXIT_SERVER,
        LAST_COMMAND = IBinder::LAST_CALL_TRANSACTION
    };
}
#endif
```
cmdid 依旧是服务端和客户端共同约定的通信 code。

调用服务端可以参考下面的实现
```cpp
//client.cpp
#include "CommonHeader.h"
#include "NativeServiceSampleClient.h"
#include "cmdline.h"
#include <string>
#include <unistd.h>
using namespace android;

void sampleSendStringToServer(NativeServiceSampleClient &service)
{
    Parcel data, reply;
    
    printf("send \"sample message\" to service\n");
    String16 str = String16("sample message to service\"");
    data.writeString16(str);
    int ret = service.invoke(android::SAMPLE_CALL, data, &reply);
    if (ret == NO_ERROR)
    {
        printf("service has received message\n");
    }
    else
    {
        printf("send msg to service failed\n");
    }
}

void sampleGetStringFromServer(NativeServiceSampleClient &service)
{
    Parcel data, reply;
    int ret = service.invoke(android::SAMPLE_GET, data, &reply);
    if (ret == NO_ERROR)
    {
        String8 str = String8(reply.readString16());
        printf("received msg from server: \"%s\"\n",str.string());
    }
}

void sampleExitServer(NativeServiceSampleClient &service)
{
    Parcel data,reply;
    // no wait reply;
    int ret = service.invoke(android::SAMPLE_EXIT_SERVER, data, &reply,1);
    if(ret == NO_ERROR)
    {
        printf("call service exit function success\n");
    }else{
        printf("call service exit function failed\n");
    }
}

void sampleGetmacByInterfaceName(NativeServiceSampleClient &service,std::string& ifname)
{
    Parcel data, reply;
    data.writeString16(String16(ifname.c_str()));
    int ret = service.invoke(android::SAMPLE_GET_MAC, data, &reply);
    if (ret == NO_ERROR)
    {
        printf("get mac %s's mac address is %s\n",ifname.c_str(), String8(reply.readString16()).string());
    }
    else
    {
        printf("call get mac function failed\n");
    }
}

int main(int argc, char *argv[])
{
    cmdline::parser args;
    args.add("call",'\0',"call sample send msg to service");
    args.add("get",'\0',"call sample get msg from service");
    args.add<std::string>("ifname",'i',"get supplied interface name",false,"");
    args.add("exit",'\0',"call function make service exit and link death recipient");

    args.parse_check(argc,argv);

    NativeServiceSampleClient service;
    ProcessState::self()->startThreadPool();
    if(args.exist("call")){
        sampleSendStringToServer(service);
    }
    if(args.exist("get")){
        sampleGetStringFromServer(service);
    }
    if(args.exist("exit")){
        sampleExitServer(service);
        // listen to wait service died msg;
        sleep(5);
    }
    if(args.exist("ifname")){
        std::string ifname = args.get<std::string>("ifname");
        sampleGetmacByInterfaceName(service,ifname);
    }
    // printf("press any key exit\n");
    // getchar();
    return 0;
}
```

`cmdline.h`是一个解析命令行参数的库，见 https://github.com/tanakh/cmdline

在安卓的源码环境中，可以参考以下 Android.bp 来将服务端和客户端的可执行文件都编译出来
```
cc_defaults{
    name: "nativeservicesample_defaults",
    shared_libs: [
        "libutils",
        "libcutils",
        "libbinder",
        "libhardware",
        "liblog"
    ],

    include_dirs: [
        "frameworks/native/include",
        "system/core/include",
        "system/libhwbinder/include"
    ],
    cflags: [
        "-Wall",
        "-Wextra",
        "-Werror",
        "-Wno-ignored-qualifiers",
        "-Wno-unused-parameter",
    ],
}

cc_binary{
    name: "server",
    defaults: [
        "nativeservicesample_defaults",
    ],
    srcs: [
        "server.cpp",
        "NativeServiceSampleService.cpp",
    ],
}

cc_library{
    name: "libnativeservicesampleclient",
    srcs: [
        "NativeServiceSampleClient.cpp",
    ],
    defaults: [
        "nativeservicesample_defaults",
    ],
}

cc_binary{
    name: "client",
    defaults: [
        "nativeservicesample_defaults",
    ],
    cflags: [
        "-fexceptions",
    ],
    static_libs: [
        "libnativeservicesampleclient",
    ],
    rtti: true,
    srcs: [
        "client.cpp",
    ],
}
```

服务端直接执行即可，客户端可以通过 --help 参数来查看帮助。

客户端想要监听服务端退出的消息，除了需要 linktodeath 之外，还需要 ProcessState::self()->startThreadPool();

# 如何在 java 层调用
## 通过jni调用
我们可以通过 jni 调用 NativeServiceSampleClient::invoke 来获取返回值，参考实现如下
```cpp
#include <stdio.h>
#include <android_os_Parcel.h>
#include <binder/Parcel.h>
#include "jni.h"

#include "NativeServiceSampleClient.h"

static android::NativeServiceSampleClient* g_client = nullptr;

static int
invoke(JNIEnv* env , jobject /* thiz */,jint code, jobject dataObj, jobject replyObj, jint flags) {
    ALOGI("invoke called");
    if (dataObj == NULL) {
        // jniThrowNullPointerException(env, NULL);
        return -1;
    }

    android::Parcel* data = android::parcelForJavaObject(env, dataObj);
    if (data == NULL) {
        return -1;
    }
    android::Parcel* reply = android::parcelForJavaObject(env, replyObj);
    if (reply == NULL && replyObj != NULL) {
        return -1;
    }

    if(g_client == nullptr){
        return -1;
    }

    return g_client->invoke(code, *data,reply,flags);
}

static const char *classPathName = "com/example/NativeServiceSample";

static const JNINativeMethod methods[] = {
  {"invoke","(ILandroid/os/Parcel;Landroid/os/Parcel;I)I",(void*)invoke},
};

/*
 * Register several native methods for one class.
 */
static int registerNativeMethods(JNIEnv* env, const char* className,
    const JNINativeMethod* gMethods, int numMethods)
{
    jclass clazz;

    clazz = env->FindClass(className);
    if (clazz == NULL) {
        ALOGE("Native registration unable to find class '%s'", className);
        return JNI_FALSE;
    }
    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
        ALOGE("RegisterNatives failed for '%s'", className);
        return JNI_FALSE;
    }

    return JNI_TRUE;
}

/*
 * Register native methods for all classes we know about.
 *
 * returns JNI_TRUE on success.
 */
static int registerNatives(JNIEnv* env)
{
  if (!registerNativeMethods(env, classPathName,
                 methods, sizeof(methods) / sizeof(methods[0]))) {
    return JNI_FALSE;
  }

  return JNI_TRUE;
}


// ----------------------------------------------------------------------------

/*
 * This is called by the VM when the shared library is first loaded.
 */

typedef union {
    JNIEnv* env;
    void* venv;
} UnionJNIEnvToVoid;

jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
{
    ALOGI("Jni_OnLoad called");
    UnionJNIEnvToVoid uenv;
    uenv.venv = NULL;
    jint result = -1;
    JNIEnv* env = NULL;

    ALOGI("JNI_OnLoad");

    if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_4) != JNI_OK) {
        ALOGE("ERROR: GetEnv failed");
        goto bail;
    }
    env = uenv.env;

    if (registerNatives(env) != JNI_TRUE) {
        ALOGE("ERROR: registerNatives failed");
        goto bail;
    }

    if(g_client == nullptr){
        g_client = new android::NativeServiceSampleClient();
    }

    result = JNI_VERSION_1_4;

bail:
    return result;
}
```

我们新建一个全局的静态变量，在 jni_onload 的时候初始化它，定义了一个用于与 java 层交互的 invoke 函数，此函数的再调用 NativeServiceSampleClient 的 invoke 并获取返回结果
p.s: 需要在源码环境下 link liblog libbinder libandroid_runtime，这种方法需要系统开放私有的库，对应用开放的库见 /system/etc/public.libraries.txt 。

## 通过安卓的 IBinder 调用
安卓的 android.os.IBinder 本身已经封装成对应的 java api了，系统应用可以通过 ServiceManager.getService 拿到对应的binder对象，参考实现如下
```java
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;

public class NativeService {
    private static final String SERVICE_NAME = "nativeservice";
    private boolean valid = false;
    IBinder service = null;
    public NativeService(){
        valid = false;
        service = ServiceManager.getService(SERVICE_NAME);
        if(service != null){
            try{
                service.linkToDeath(()->{
                    Log.e("shell","service died");
                    setInvlaid();
                },0);
                setValid();
            }catch (RemoteException e){
                Log.e("shell","link to death failed",e);
                setInvlaid();
            }
        }
    }

    public boolean invoke(int code,Parcel data,Parcel reply) throws RemoteException {
        if(isValid()){
            Parcel send = Parcel.obtain();
            send.writeInterfaceToken(SERVICE_NAME);
            send.appendFrom(data,0,data.dataSize());
            boolean result = service.transact(code,send,reply,0);
            send.recycle();
            return result;
        }
        Log.e("shell","service not running");
        return false;
    };

    private void setInvlaid(){
        synchronized(this){
            valid = false;
        }
    }

    private void setValid(){
        synchronized(this){
            valid = true;
        }
    }

    private boolean isValid(){
        synchronized(this){
            return valid;
        }
    }
}
```
p.s: 此方式需要应用为系统应用或反射 ServiceManager 或在源码环境下编译
]]></content>
  </entry>
  <entry>
    <title>使用Aria2c和百度网盘助手实现高速下载百度网盘资料</title>
    <url>/2016/10/20/Aria2c/</url>
    <content><![CDATA[
{% asset_img baiduyun.jpg 百度网盘 %}
<!-- more -->
## 一点介绍
先介绍一枚小神器————Aria2c，这是一个下载软件，支持Windows，Linux，mac os(原OS X)，不过是纯命令行操作的软件。
本文附带一个让它支持图形界面的办法(其实都是从网上扣来的)，不过每次讲的都不全，不完整，本文算是一个总结。
此方法共需要以下东西：
- [BaiduExporter](https://github.com/acgotaku/BaiduExporter)(一个chrome插件，用于提取出百度云的文件真正的下载地址)
- [aria2c](https://github.com/aria2/aria2)(下载软件)：

    项目主页：https://github.com/aria2/aria2
    官方文档：https://aria2.github.io/
    历史版本：https://github.com/aria2/aria2/releases/tag/release-1.28.0

- aria2c-webui(非必需)


第一步自然是下载带这三个软件了，地址都在上面，可以自行下载。

## Chrome浏览器导入插件
打开chrome，在地址栏输入“chrome://extensions/”,勾选开发者模式，然后点击加载已解压的扩展程序(也可以将下载到的crx文件直接拖入当前chrome窗口)。选中解压的到的chrome文件夹，点击确定。

{% asset_img chrome-extensions.jpg chrome-extensions %}

{% asset_img chrome2.jpg chrome-extensions %}
 
{% asset_img chrome-baiduexporter.jpg %}

## 安装Aria2c
下载，解压，双击“start.bat”,出现下面这个窗口就好了。
{% asset_img aria2c1.jpg %}
{% asset_img aria2c2.jpg %}
## 使用
这个时候，使用chrome浏览器打开任意百度网盘链接
{% asset_img use1.jpg %}
{% asset_img use2.jpg %}
点击ARIA2 RPC
可以看到下载成功的提示
{% asset_img use-sucessful.jpg %}
这个时候可以在黑框里面看到下载进度。
## 使用webui查看下载进度
不过大部分人对字符界面不敏感，所以这里准备了一个图形界面来查看下载进度,打开[www.hushuangpu.xyz/aria2c-webui](http://www.hushuangpu.xyz/aria2c-webui)
如果出现这个界面的话:
{% asset_img error1.jpg %}
依次点击"设置>>连接"，改成下图中的信息

{% asset_img error2.jpg %}
保存连接设置即可，就能在网页查看到下载信息了

{% asset_img OK.jpg %}

## 其它可能会出现的问题说明
在最新版的Chrome浏览器上，对非chrome商店的插件做了比较严格的限制，每次打开Chrome浏览器百度网盘助手都会被禁用，可以通过修改组策略来解决这个问题。
跳转到：[Guide on Packaging and Import Baidu Exporter to Chrome](https://hencolle.com/2016/10/16/baidu_exporter/)
也可以查看[bilibili](http://www.bilibili.com/video/av8293848/)
<embed height="415" width="544" quality="high" allowfullscreen="true" type="application/x-shockwave-flash" src="//static.hdslb.com/miniloader.swf" flashvars="aid=8293848&page=1" pluginspage="//www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash"></embed>
默认会下载到D:\Downloads

## 软件下载地址
所使用到的软件在此下载：[High_Speed_download_baiduyun.rar](https://pan.baidu.com/s/1c23j8eG)]]></content>
      <tags>
        <tag>-technology</tag>
        <tag>wanwan</tag>
      </tags>
  </entry>
  <entry>
    <title>Android Native Service 示例</title>
    <url>/2024/07/31/Android-native-service-sample-1/</url>
    <content><![CDATA[安卓系统上添加系统服务，可以通过 android.os.ServiceManager 来添加使用 java 实现的系统服务，放在 SytemServer 进程（内置在源码编译）或者放在 app 进程（需要是系统签名的系统应用）。
由于运行在 SystemServer 进程或者运行在app进程，某些特殊操作就面临权限不足的问题，比如操作kernel的节点，这个时候就需要使用使用 root 权限运行的进程了。（当然严格来说，通过java实现的服务，同样可以以 root 权限运行，比如将相应的代码编译成 jar，开机之后通过 appprocess 运行）。

<!--more -->

native service 需要定义一个接口类，下面的示例作为参考
```cpp
// INativeServiceSample.h
#ifndef _I_NATIVES_ERVICE_SAMPLE_H_
#define _I_NATIVES_ERVICE_SAMPLE_H_

#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <binder/PermissionController.h>
#include <binder/ProcessInfoService.h>
#include <binder/IResultReceiver.h>
#include <utils/String8.h>
#include <utils/String16.h>
#include <android/log.h>

#ifdef TAG
#undef TAG
#endif
#define TAG "NativeService"
#define NATIVESERVICE_NAME "nativeservice"

#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE,TAG ,__VA_ARGS__)
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,TAG ,__VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,TAG ,__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,TAG ,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG ,__VA_ARGS__)
#define LOGF(...) __android_log_print(ANDROID_LOG_FATAL,TAG ,__VA_ARGS__)


namespace android {

    enum STATUS {
        SUCCESS = NO_ERROR,
        FAILED = UNKNOWN_TRANSACTION
    };
    class INativeServiceSample : public IInterface {
        public:
        virtual int invoke(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) = 0;
        DECLARE_META_INTERFACE(NativeServiceSample);
    };

    class BnNativeServiceSample : public BnInterface<INativeServiceSample>
    {
    public:
        status_t onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags);
        status_t dump(int fd, const Vector<String16> &args);
        int onShellCommand(int in, int out, int err, const Vector<String16> &args);
        virtual int invoke(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) = 0;
    private:
        int shellCommand(int in, int out, int err, const Vector<String16> &args);
        
    };
}

#endif
```

这里的主要工作是定义一个 server 端和 client 端都需要实现的函数， invoke ，以及 DECLARE_META_INTERFACE 这一行，DECLARE_META_INTERFACE 是一个宏定义，后面的小括号里面的 NativeServiceSample 则是当前类 INativeServiceSample 中的 NativeServiceSample 。之类会为这个类默认声明好相应的一个service需要是实现的函数。这里有严格的命名规范。

然后实现客户端和服务端，也即一个 Bp(客户端) 一个 Bn(服务端)
下面是相应的定义
```cpp
//INativeServiceSample.cpp
#include "INativeServiceSample.h"
namespace android
{
        class BpNativeServiceSample : public BpInterface<INativeServiceSample>
    {
    public:
        BpNativeServiceSample(const sp<IBinder> &impl) : BpInterface<INativeServiceSample>(impl) {}
        int invoke(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
        {
            Parcel send;
            send.writeInterfaceToken(getInterfaceDescriptor());
            send.appendFrom(&data, 0, data.dataSize());
            return remote()->transact(code, send, reply);
        }
    };

    IMPLEMENT_META_INTERFACE(NativeServiceSample, NATIVESERVICE_NAME);

    status_t BnNativeServiceSample::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
    {
        if(code == SHELL_COMMAND_TRANSACTION)
        {
            int in = data.readFileDescriptor();
            int out = data.readFileDescriptor();
            int err = data.readFileDescriptor();
            int argc = data.readInt32();
            Vector<String16> args;
            for (int i = 0; i < argc && data.dataAvail() > 0; i++)
            {
                args.add(data.readString16());
            }
            status_t result = 0;
            sp<IBinder> unusedCallback;
            sp<IResultReceiver> resultReceiver;
            if ((result = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR)
            {
                return result;
            }
            if ((result = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR)
            {
                return result;
            }
            result = shellCommand(in, out, err, args);
            if (resultReceiver != nullptr)
            {
                resultReceiver->send(result);
            }
            return result;
        }
        else if(IBinder::FIRST_CALL_TRANSACTION <= code && code <= IBinder::LAST_CALL_TRANSACTION)
        {
            CHECK_INTERFACE(INativeServiceSample, data, reply);
            return invoke(code, data, reply, flags);
        }
        else
        {
            return BBinder::onTransact(code, data, reply, flags);
        }
    }

    status_t BnNativeServiceSample::shellCommand(int in, int out, int err, const Vector<String16> &args)
    {
        return onShellCommand(in, out, err, args);
    }

    status_t BnNativeServiceSample::onShellCommand(int in, int out, int err, const Vector<String16> &args)
    {
        LOGI("onShellCommand not implementation yet");
        write(out, "onShellCommand not implementation yet\n", 38);
        size_t size = args.size();
        for (size_t i = 0; i < size; i++)
        {
            LOGI("Received No.%zu arg: %s", i, String8(args[i]).string());
        }
        return SUCCESS;
    }

    status_t BnNativeServiceSample::dump(int fd, const Vector<String16> &args)
    {
        LOGI("dump not implementation yet");
        write(fd, "dump not implementation yet\n", 28);
        size_t size = args.size();
        for (size_t i = 0; i < size; i++)
        {
            LOGI("Received No.%zu arg: %s", i, String8(args[i]).string());
        }
        return SUCCESS;
    }
}
```
`BpNativeServiceSample : public BpInterface<INativeServiceSample>` 是客户端的定义，它的构造函数是固定格式。
`class BnNativeServiceSample : public BnInterface<INativeServiceSample>` 则是服务端的定义，它里面有一个用于与其他进程通信最重要的函数`onTransact`。
而 dump 函数则是我们使用 `dumpsys servicename args...`这样的命令行方式去获取服务的信息时会被调用的函数，我们可以在这和函数里面接收命令行参数，解析命令以及输出内容，其中 fd 命令行传入的一个文件描述符，通常它是 stdout ，后面的 args则是命令行参数，安卓的命令参数是通过 String16 格式传入。
对于客户端，我们对调用者提供的接口是 invoke(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) 。客户端也可以直接使用 service 的 tract 接口来对服务端进行调用，为了隐藏 `getInterfaceDescriptor()` ，我将这部分操作预先包含在 invoke 里面，调用者提供 code，data，reply以及 flags 即可（flags这里我实际上没有使用到）
这里由一个非常重要的 IMPLEMENT_META_INTERFACE ，这个宏会在这部分展开，将在接口类内声明的内容实现放在此处，同样的，这里也有严格的命名要求。
服务端的 onTransact实现如下
```cpp
    status_t BnNativeServiceSample::onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
    {
        if(code == SHELL_COMMAND_TRANSACTION)
        {
            int in = data.readFileDescriptor();
            int out = data.readFileDescriptor();
            int err = data.readFileDescriptor();
            int argc = data.readInt32();
            Vector<String16> args;
            for (int i = 0; i < argc && data.dataAvail() > 0; i++)
            {
                args.add(data.readString16());
            }
            status_t result = 0;
            sp<IBinder> unusedCallback;
            sp<IResultReceiver> resultReceiver;
            if ((result = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR)
            {
                return result;
            }
            if ((result = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR)
            {
                return result;
            }
            result = shellCommand(in, out, err, args);
            if (resultReceiver != nullptr)
            {
                resultReceiver->send(result);
            }
            return result;
        }
        else if(IBinder::FIRST_CALL_TRANSACTION <= code && code <= IBinder::LAST_CALL_TRANSACTION)
        {
            CHECK_INTERFACE(INativeServiceSample, data, reply);
            return invoke(code, data, reply, flags);
        }
        else
        {
            return BBinder::onTransact(code, data, reply, flags);
        }
    }
```
这里进来之后，我们受限检查 code 是否是 SHELL_COMMAND_TRANSACTION,这个 code 表示本次IPC调用是通过 cmd servicename args... 的方式调用的，这里把 stdin,stdout,stderr,args 封装好传给新增的 shellCommand ，shellCommand 里面调用 onShellCommand 。
然后判断是code是否是Binder为开发者预留的范围，如果是这个范围，就交给我们自己实现的 invoke 处理 ，首先是一个 CHECK_INTERFACE(INativeServiceSample, data, reply); 这里主要作用是检查调用 service 时，传递给服务端的 parcel 的 interface 是否正确。
如果code不是以上几种情况，那么就交给父类处理。可以查看 aosp/frameworks/native/libs/binder/Binder.cpp
```cpp
// NOLINTNEXTLINE(google-default-arguments)
status_t BBinder::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t /*flags*/)
{
    switch (code) {
        case INTERFACE_TRANSACTION:
            reply->writeString16(getInterfaceDescriptor());
            return NO_ERROR;

        case DUMP_TRANSACTION: {
            int fd = data.readFileDescriptor();
            int argc = data.readInt32();
            Vector<String16> args;
            for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
               args.add(data.readString16());
            }
            return dump(fd, args);
        }

        case SHELL_COMMAND_TRANSACTION: {
            int in = data.readFileDescriptor();
            int out = data.readFileDescriptor();
            int err = data.readFileDescriptor();
            int argc = data.readInt32();
            Vector<String16> args;
            for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
               args.add(data.readString16());
            }
            sp<IShellCallback> shellCallback = IShellCallback::asInterface(
                    data.readStrongBinder());
            sp<IResultReceiver> resultReceiver = IResultReceiver::asInterface(
                    data.readStrongBinder());

            // XXX can't add virtuals until binaries are updated.
            //return shellCommand(in, out, err, args, resultReceiver);
            (void)in;
            (void)out;
            (void)err;

            if (resultReceiver != nullptr) {
                resultReceiver->send(INVALID_OPERATION);
            }

            return NO_ERROR;
        }

        case SYSPROPS_TRANSACTION: {
            report_sysprop_change();
            return NO_ERROR;
        }

        default:
            return UNKNOWN_TRANSACTION;
    }
}
```
在这里我们就知道 dump 其实也是一个特殊的 code 。

p.s: 这里我们当然可以在接口定义的时候就生命客户端和服务端都共有的相同实现的接口，可是这样做每次新增接口都需要在双方一起增加实现，我用一个 invoke 来中转调用。
p.s: code 是服务端用来区分客户端想调用哪个函数的。

下面来看看真正的服务端的声明和实现
```cpp
// NativeServiceSampleService.h
#ifndef _NATIVE_SERVICE_SAMPLE_SERVICE_H_
#define _NATIVE_SERVICE_SAMPLE_SERVICE_H_
#include "INativeServiceSample.h"
#include <map>
namespace android
{
    class NativeServiceSampleService : public BnNativeServiceSample
    {
    public:
        typedef status_t (NativeServiceSampleService::*local_method)(const Parcel &data, Parcel *reply);
        NativeServiceSampleService(){loadMethods();};
        ~NativeServiceSampleService(){};
        status_t sampleCallFunction(const Parcel &data, Parcel *reply);
        status_t sampleGetFunction(const Parcel &data, Parcel *reply);
        status_t getMacByInterfaceName(const Parcel &data, Parcel *reply);
    private:
        int invoke(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags);
        int getCallingUid();
        int getCallingPid();
        void loadMethods();
        std::map<uint32_t,local_method> methods;
    };
};
#endif
```
这里定义了三个功能函数，sampleCallFunction,sampleGetFunction,getMacByInterfaceName，我将这几个函数的输入参数统一了，然后用一个 map 去保存 code 和指向这几个函数的函数指针。
```cpp
//NativeServiceSampleService.cpp
#include "NativeServiceSampleService.h"
#include "Cmdid.h"
#include <errno.h>
#include <string.h>
#include <binder/IPCThreadState.h>
#include <hwbinder/IPCThreadState.h>

namespace android {
    void NativeServiceSampleService::loadMethods()
    {
        methods[SAMPLE_CALL] = &NativeServiceSampleService::sampleCallFunction;
        methods[SAMPLE_GET] = &NativeServiceSampleService::sampleGetFunction;
        methods[SAMPLE_GET_MAC] = &NativeServiceSampleService::getMacByInterfaceName;
    }
    int NativeServiceSampleService::invoke(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){
        std::map<uint32_t, local_method>::iterator iter = methods.find(code);
        LOGV("uid:%d pid:%d called method %u",getCallingUid(),getCallingPid(),code);
        if (iter != methods.end())
        {
            return (this->*(iter->second))(data, reply);
        }
        else
        {
            LOGE("can't find such a method whose cmdid is %u", code);
            return -1;
        }
    }
    
    status_t NativeServiceSampleService::sampleCallFunction(const Parcel&data, Parcel* reply){
        String8 str = String8(data.readString16());
        LOGD("call funcion with %s",str.string());
        return SUCCESS;
    }

    status_t NativeServiceSampleService::sampleGetFunction(const Parcel&data, Parcel* reply){
        LOGD("get function ");
        String16 hello = String16("this is message from service");
        reply->writeString16(hello);
        return SUCCESS;
    }

    status_t NativeServiceSampleService::getMacByInterfaceName(const Parcel &data, Parcel *reply)
    {
        String16 ifname = data.readString16();
        LOGV("get mac of ifname: %s",String8(ifname).string());
        String8 path = String8("/sys/class/net/");
        path += String8(ifname);
        path += String8("/address");
        FILE* fp = fopen(path.string(),"ro");
        if(fp == NULL){
            LOGE("open %s failed(%d): %s",path.string(),errno,strerror(errno));
            return FAILED;
        }

        char mac[18] = {0};
        size_t readsize = fread(mac,1,17,fp);
        if(readsize != 17){
            LOGE("read mac failed");
            return FAILED;
        }
        String16 result = String16(mac);
        reply->writeString16(result);
        fclose(fp);
        return SUCCESS;
    }

    int NativeServiceSampleService::getCallingPid()
    {
        if (IPCThreadState::self()->isServingCall()) {
            return IPCThreadState::self()->getCallingPid();
        }
        return IPCThreadState::self()->getCallingPid();
    }

    int NativeServiceSampleService::getCallingUid()
    {
        if (IPCThreadState::self()->isServingCall()) {
            return IPCThreadState::self()->getCallingUid();
        }
        return IPCThreadState::self()->getCallingUid();
    }
}
```
我在服务端初始化的时候将唯一的 code 和唯一的函数指针保存进 map ，在 invoke 里面判断如果有相应的 code 存在，则调用相应的函数，没有则直接返回。

这里的 code 则是一个枚举，实际上是双方约定的相同的正整数就可以。

```cpp
//Cmdid.h
#ifndef _CMDID_H_
#define _CMDID_H_
#include "INativeServiceSample.h"
namespace android{
    enum ENUME_CMD{
        SAMPLE_CALL = IBinder::FIRST_CALL_TRANSACTION,
        SAMPLE_GET,
        SAMPLE_GET_MAC
    };
}

#endif
```

# 开启服务
```
//server.cpp
#include "NativeServiceSampleService.h"
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/IPCThreadState.h>
#include <utils/String8.h>
#include <utils/String16.h>

int main(int argc, char **argv)
{
    LOGI("start DeviceMacService");
    android::defaultServiceManager()->addService(android::String16(NATIVESERVICE_NAME), new android::NativeServiceSampleService());
    android::ProcessState::self()->startThreadPool();
    android::IPCThreadState::self()->joinThreadPool();
}
```

# 客户端调用服务
```
//client.cpp
#include "NativeServiceSampleService.h"
#include "EnumeCmdid.h"
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/IPCThreadState.h>
#include <utils/String8.h>
#include <utils/String16.h>

using namespace android;

sp<INativeServiceSample> getService() {
    sp<IServiceManager> sm = defaultServiceManager();
    if (sm == NULL) {
        LOGE("can not get service manager");
    }
    sp<IBinder> binder = sm->getService(String16(NATIVESERVICE_NAME));
    if (binder == NULL) {
        LOGE("can not get service");
    }
    sp<INativeServiceSample> service = interface_cast<INativeServiceSample>(binder);
    if (service == NULL) {
        LOGE("can not cast interface");
    }
    return service;
    return nullptr;
}

int main(int argc,char** argv){
    sp<INativeServiceSample> service = getService();

    {
        Parcel data, reply;
        String16 str = String16("str from client");
        data.writeString16(str);
        int ret = service->invoke(android::SAMPLE_CALL, data, &reply,0);
        if(ret == 0){
            LOGI("invoke value 0");
        }
    }

    {
        Parcel data, reply;
        int ret = service->invoke(android::SAMPLE_GET, data, &reply,0);
        if(ret == 0){
            LOGI("invoke value 0");
        }
        String8 str = String8(reply.readString16());
        LOGI("from str %s",str.string());
    }

    {
        if (argc >= 2)
        {
            Parcel data, reply;
            data.writeString16(String16(argv[1]));
            int ret = service->invoke(android::SAMPLE_GET_MAC, data, &reply, 0);
            if (ret == 0)
            {
                LOGI("get mac %s's mac address is %s", argv[1], String8(reply.readString16()).string());
            }
            else
            {
                LOGE("call get mac function failed");
            }
        }
    }
    return 0;
}
```

# 编译 
使用下面的 Android.bp
```
cc_defaults{
    name: "nativeservicesample_defaults",
    srcs:[
        "INativeServiceSample.cpp"
    ],
    shared_libs: [
        "libutils",
        "libcutils",
        "libbinder",
        "libhardware",
        "liblog"
    ],

    include_dirs: [
        "frameworks/native/include",
        "system/core/include",
        "system/libhwbinder/include"
    ],
    cflags: [
        "-Wall",
        "-Wextra",
        "-Werror",
        "-Wno-ignored-qualifiers",
        "-Wno-unused-parameter",
    ],
}

cc_binary{
    name: "server",
    defaults: [
        "nativeservicesample_defaults",
    ],
    srcs: [
        "NativeServiceSampleService.cpp",
        "server.cpp",
    ],
}

cc_binary{
    name: "client",
    defaults: [
        "nativeservicesample_defaults",
    ],
    srcs: [
        "client.cpp",
    ]
}
```
编译完成之后，将 out/xxxx/system/bin/ 里面的 server 和 client ，推到 Android 设备上（Android studio里面的虚拟机也可以），执行server，然后执行 client ，通过 logcat -s NativeService 就可以看见相应的打印了。

# FAQ
## 安卓 app 如何调用服务？
由于native层定义的 invoke 交给 java 层调用有些麻烦，我们可以直接获取到 Binder 对象之后，调用 Binder 对象的 transcat 函数，将需要的参数传入即可。
下面是一个示范
```java
// NativeService.java
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;

public class NativeService {
    private static final String SERVICE_NAME = "nativeservice";

    public static boolean invoke(int code,Parcel data,Parcel reply) throws RemoteException {
        IBinder service = ServiceManager.getService(SERVICE_NAME);
        if(service != null){
            Parcel send = Parcel.obtain();
            send.writeInterfaceToken(SERVICE_NAME);
            send.appendFrom(data,0,data.dataSize());
            boolean result = service.transact(code,send,reply,0);
            send.recycle();
            return result;
        }
        Log.e("shell","service not running");
        return false;
    };
}
```
code 的值与 native 层定义的 cmdid 一致，从 1 开始。

## onTransact 的返回值有什么讲究吗，如果service仅仅由C++层的函数调用，例如示例里的 invoke
```cpp
        int invoke(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags)
        {
            Parcel send;
            send.writeInterfaceToken(getInterfaceDescriptor());
            send.appendFrom(&data, 0, data.dataSize());
            return remote()->transact(code, send, reply);
        }
```
这样的话，我们可以直接拿到 onTransact 的返回值，返回值的意义取决于双方的约定，如果 service 还准备给 Java 层调用，则不可以随意返回，原因是通过 IBinder.transact(...) 的方式调用service，返回值已经被 BinderProxy处理过了，看下面这一段
```cpp
//frameworks/base/core/jni/android_util_Binder.cpp
static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
        jint code, jobject dataObj, jobject replyObj, jint flags) // throws RemoteException
{
    ......

    //printf("Transact from Java code to %p sending: ", target); data->print();
    status_t err = target->transact(code, *data, reply, flags);
    //if (reply) printf("Transact from Java code to %p received: ", target); reply->print();

    if (kEnableBinderSample) {
        if (time_binder_calls) {
            conditionally_log_binder_call(start_millis, target, code);
        }
    }

    if (err == NO_ERROR) {
        return JNI_TRUE;
    } else if (err == UNKNOWN_TRANSACTION) {
        return JNI_FALSE;
    }

    signalExceptionForError(env, obj, err, true /*canThrowRemoteException*/, data->dataSize());
    return JNI_FALSE;
}
```
在这里可以看到，为 NO_ERROR 时返回了 true，为 UNKNOWN_TRANSACTION 时返回了false，都不是时将走到 signalExceptionForError(...)
```cpp
void signalExceptionForError(JNIEnv* env, jobject obj, status_t err,
        bool canThrowRemoteException, int parcelSize)
{
    switch (err) {
        case UNKNOWN_ERROR:
            jniThrowException(env, "java/lang/RuntimeException", "Unknown error");
            break;
        case NO_MEMORY:
            jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
            break;
        case INVALID_OPERATION:
            jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
            break;
        case BAD_VALUE:
            jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
            break;
        case BAD_INDEX:
            jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
            break;
        case BAD_TYPE:
            jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
            break;
        case NAME_NOT_FOUND:
            jniThrowException(env, "java/util/NoSuchElementException", NULL);
            break;
        case PERMISSION_DENIED:
            jniThrowException(env, "java/lang/SecurityException", NULL);
```
走到这里来之后，调用service的app将发生异常。当然 service 可以根据调用方的不同的参数来返回相应的值来让调用方进入不同的状态。

一个肥肠完整的示例： https://www.jianshu.com/p/46dfce294a4f]]></content>
  </entry>
  <entry>
    <title>树莓派自动温控风扇</title>
    <url>/2018/04/19/Auto-Control-Raspberry-Fan/</url>
    <content><![CDATA[某天忘记把树莓派的电源断掉，然后第二天早上被它的风扇声音吵醒！！
严格来说在温度不高的时候风扇没必要打开，好在树莓派最不怕的就是各种折腾了。
动手把风扇改成温控的。

<!-- more -->

## 描述

raspbian的`/sys/class/thermal/thermal_zone0/temp`文件内存着CPU的温度，读出来处以1000就得到温度了，省了给它测温的麻烦，大赞👍。
另外需要用的一个三极管，我这里用的是S9013，网上很多教程用的是S8085。严格来说不同的三极管实现起来是有不同的，这里不深究哪种三极管更好了。
突然想复习一下三极管怎么工作的( ╯□╰ )

## 预备知识

首先要知道的是树莓派的引脚定义，将树莓派有网络接口的一端朝下，有GPIO接口（就是那四十个脚）的一面面向自己，从上到下，从左到右，为物理引脚1~40,像这样

```bash
1 2
3 4
5 6
···
```

但是具体到程序内，用的不是物理引脚，不同的库对引脚的定义也不同，这里提供一个[对照图](http://shumeipai.nxez.com/raspberry-pi-pins-version-40)
{% asset_img rpi-pins-40-0.png http://shumeipai.nxez.com/raspberry-pi-pins-version-40 %}

本文将使用[winringPi](http://wiringpi.com)作为控制引脚的库。
可以使用命令

```bash
sudo apt install wiringpi
sudo apt purge wiringpi
```

来完成安装，可以使用

```bash
gpio -v
```

来验证。
目前没有查询到每个脚具体的电气参数，理论上是可以将风扇直接插在引脚上，然后控制引脚的电平来间接控制风扇的开关的，但是不清楚具体哪个脚能承受多大的电流，就没有贸然尝试了。用了比较保险的三极管。
将三极管平的一面面向自己，引脚向下，从左到右引脚分别是E（发射极Emitter）B（基极Basic）C（集电极collector）。
连接示意图参考如下
{% asset_img 1.png %}

## 安装

按图连接好之后，安装控制软件了。

```bash
git clone https://github.com/BDZNH/AutoControlRaspberryFan.git
cd AutoControlRaspberryFan
make
sudo make install
```

可以前往[https://github.com/BDZNH/AutoControlRaspberryFan](https://github.com/BDZNH/AutoControlRaspberryFan)查看帮助。

## 源代码

```C++
/******************************************************************************


-------------------------------------------------------------------------------
        Project Name : AutoControlRaspberryfan                                 
        Author       : BDZNH                                                   
        Project URL  : https://github.com/BDZNH/AutoControlRaspberryFan        
        what is this : Auto control raspberry fan with 5V. Turn the fan        
                       when the temperaure is high than 45°C, turn off         
                       fan when the CPU temperature is lower than 39°C.        
-------------------------------------------------------------------------------



******************************************************************************/




#include <iostream>
#include <fstream>
#include <unistd.h>
#include <wiringPi.h>
#include <softPwm.h>
#include <ctime>
#define TEMP_PATH "/sys/class/thermal/thermal_zone0/temp"
#define LOG_PATH "/tmp/RaspberrypiFanSpeed.log"
#define PID_PATH "/var/run/autocontrolfan.pid"
#define _FANPIN 8
#define min(x,y) (x<=y?x:y)
using namespace std;

void GetCpuTempera(ifstream &fin,double &temp);
int initWiringPi();
void showInfo();
void SaveLog(ofstream &log, double &temp, int FanSpeed, time_t &time_cur);

int main()
{
	showInfo();
	ofstream log(LOG_PATH);
	if (!log.is_open())
	{
		cout << "Can't open file : " << LOG_PATH << endl;
	}
	log.close();
	ifstream fin(TEMP_PATH, ios_base::in);
	if (!fin.is_open())
	{
		cout << "Can't open file : " << TEMP_PATH << endl;
		return -1;
	}
	ofstream pid(PID_PATH);
	if (!pid.is_open())
	{
		cout << "Can't open file : " << PID_PATH << endl;
	}
	pid << getpid() << endl;
	pid.close();
	pid.clear();
	time_t time_cur;
	double temp = 0;
	int Fan_Speed = 0;
	bool Forty_five_Flag = false;
	if (initWiringPi() < 0)
	{
		return -1;
	}

	while (true)
	{
		GetCpuTempera(fin,temp);
		if (temp >= 42)
			cout << "Cpu temperature is : \033[0;31m" << temp << "°C   \033[0m" << flush;
		else
			cout << "Cpu temperature is : \033[1;32m" << temp << "°C   \033[0m" << flush;
		if (Forty_five_Flag)
		{
			if (temp < 39.0)
			{
				Forty_five_Flag = false;
				Fan_Speed = 0;
				softPwmWrite(_FANPIN, Fan_Speed);
				SaveLog(log, temp, Fan_Speed, time_cur);
			}
			else
			{
				SaveLog(log, temp, Fan_Speed, time_cur);
			}
			sleep(1);
		}
		else
		{
			if (temp < 39.0)
			{
				sleep(1);
				Fan_Speed = 0;
				softPwmWrite(_FANPIN, Fan_Speed);
				SaveLog(log, temp, Fan_Speed, time_cur);
			}
			else if (temp >= 40.0 && temp <= 45.0)
			{
				Fan_Speed = min(((((int)temp - 40) * 10) + 60),100);
				softPwmWrite(_FANPIN, Fan_Speed);
				SaveLog(log, temp, Fan_Speed, time_cur);
				sleep(2);
			}
			else if (temp > 45.0)
			{
				Fan_Speed = 100;
				softPwmWrite(_FANPIN, Fan_Speed);
				Forty_five_Flag = true;
				SaveLog(log, temp, Fan_Speed, time_cur);
				sleep(5);
			}
		}
		sleep(1);
		cout << "\r";
	}
	return 0;
}

void GetCpuTempera(ifstream &fin, double &temp)
{
	fin >> temp;
	temp = temp / 1000.0;
	fin.clear();
	fin.seekg(0, ios::beg);
}

int initWiringPi()
{
	if (wiringPiSetup() != 0)
	{
		cout << "WiringPi setup failed" << flush << " \r";
		return -1;
	}
	if (softPwmCreate(_FANPIN, 0, 100) != 0)
	{
		cout << "softPwmcreat setup failed" << flush << " \r";
		return -2;
	}
	return 0;
}



void showInfo()
{
	cout << "-------------------------------------------------------------------------------" << endl;
	cout << "        Project Name : AutoControlRaspberryfan                                 " << endl;
	cout << "        Author       : BDZNH                                                   " << endl;
	cout << "        Project URL  : https://github.com/BDZNH/AutoControlRaspberryFan        " << endl;
	cout << "        what is this : Auto control raspberry fan with 5V. Turn the fan        " << endl;
	cout << "                       when the temperaure is high than 45°C, turn off         " << endl;
	cout << "                       fan when the CPU temperature is lower than 39°C.        " << endl;
	cout << "-------------------------------------------------------------------------------" << endl;
	cout << "\n\n\n" << endl;
}

void SaveLog(ofstream &log, double &temp, int Fan_Speed, time_t &time_cur)
{
	log.open(LOG_PATH,ios_base::out);
	if (!log.is_open())
	{
		cout << "Can't open file : " << LOG_PATH << endl;
	}
	time(&time_cur);
	log << ctime(&time_cur) << "CPU temperature is : " << temp << "°C \nSet fan speed to " << Fan_Speed << endl;
	log.close();
	log.clear();
}
```

代码内设定的是超过45°C时开启风扇，低于39°C时关闭风扇。处于[40°C,45°C]时按需调节，温度越高，转速越快。
后边会让程序支持指定阈值和工作模式，不知道是不是我的错觉，不是满速旋转的时候风扇有怪怪的声音。
{% cq %}生命重在折腾{% endcq %}

-----

## 参考资料

[https://blog.newnius.com/raspberry-control-fan-with-transistor.html](https://blog.newnius.com/raspberry-control-fan-with-transistor.html)
[树莓派wiringPi库详解](https://www.cnblogs.com/lulipro/p/5992172.html)
PS:链接一内的脚本用Python实现，无奈Python会占用大量CPU，对树莓派来说并不合适。后来虽然在百度也找到一些python脚本，占用资源也很少，但是还是写了这个练手。

### 百度贴吧找到的python脚本

```python
#!/usr/bin/env python
# encoding: utf-8

import RPi.GPIO
import time
RPi.GPIO.setwarnings(False)
RPi.GPIO.setmode(RPi.GPIO.BCM)
RPi.GPIO.setup(2, RPi.GPIO.OUT)
pwm = RPi.GPIO.PWM(2,100)
RPi.GPIO.setwarnings(False)


speed = 0
prv_temp = 0

try:


		while True:
		
				tmpFile = open( '/sys/class/thermal/thermal_zone0/temp' )
				cpu_temp = int(tmpFile.read())
				tmpFile.close()
				if cpu_temp>=34500 :
				
						if prv_temp<34500 :
						#启动时防止风扇卡死先全功率转0.1秒
								pwm.start(0)
								pwm.ChangeDutyCycle(100)
								time.sleep(.1)
						speed = min( cpu_temp/125-257 , 100 )
						pwm.ChangeDutyCycle(speed)
				else :
						pwm.stop()
				prv_temp = cpu_temp
				
				time.sleep(5)
				
except KeyboardInterrupt:
		pass
pwm.stop()
```
]]></content>
  </entry>
  <entry>
    <title>Google BBR 提速</title>
    <url>/2017/07/18/BBR/</url>
    <content><![CDATA[{% asset_img 1.jpg 单边提速神器 %}
<!-- more -->
谷歌总是有各种惊喜。偶然挖到这个家伙——[BBR](https://github.com/google/bbr)。
vps加速有之前的锐速，也有[kcptun](https://github.com/xtaci/kcptun)，锐速效果不好，kcptun搭建步骤繁琐，并且是双边加速，很不方便。
bbr是单边加速，给服务器一端配置好之后，所有客户端都能用。在教育网的IPv6下，晚八点左右，平时仅能达到500KB，开启bbr之后，可以达到2M+，效果很明显。
## 安装内核
bbr依赖于高于4.9+的Linux内核，要使用bbr，首先得升级内核。
对于Ubuntu，可以这样做：
```bash
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.10.1/linux-headers-4.10.1-041001_4.10.1-041001.201702260735_all.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.10.1/linux-headers-4.10.1-041001-generic_4.10.1-041001.201702260735_amd64.deb
wget http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.10.1/linux-image-4.10.1-041001-generic_4.10.1-041001.201702260735_amd64.deb
sudo dpkg -i *.deb && sudo reboot
```
重启之后，输入`uname -sr`可以看到新的内核已经安装。
## 启动bbr
输入`lsmod | grep bbr`，如果结果中没有 tcp_bbr 的话就先执行
```bash
modprobe tcp_bbr
echo "tcp_bbr" >> /etc/modules-load.d/modules.conf
echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf
echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf
sysctl -p
```
然后依次执行：
```bash
sysctl net.ipv4.tcp_available_congestion_control
sysctl net.ipv4.tcp_congestion_control
```
每条命令输入之后，提示信息里面都有`bbr`，则表示bbr已经开启。]]></content>
  </entry>
  <entry>
    <title>Build sandboxing disabled due to nsjail error</title>
    <url>/2024/12/08/Build-sandboxing-disabled-due-to-nsjail-error/</url>
    <content><![CDATA[
最近把Ubuntu升级到 24.04，编译AOSP遇到一些问题，这里做一下记录。
遇到的警告是标题名“Build sandboxing disabled due to nsjail error”

<!-- more -->

这个警告我遇到两种情况：
1. 在 Ubuntu 24.04 编译
根据链接 [https://groups.google.com/g/android-building/c/DbDKuaIik3M](https://groups.google.com/g/android-building/c/DbDKuaIik3M) 所说，ubuntu24.04上的一些修改，会导致编译时遇到这个错误。
{% asset_img image.png %}
临时解法是执行这个命令`sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0`
如果想持久化生效的话，可以编辑文件`/usr/lib/sysctl.d/10-apparmor.conf`，将上面的key value添加进去，使用`sysctl -p /usr/lib/sysctl.d/10-apparmor.conf` 或者重启生效。
2. 使用 Docker 编译
在Docker里面编译可能会遇到这个错误，解决办法是创建容器时，添加一个 `--privileged` 参数。]]></content>
  </entry>
  <entry>
    <title>从组合数讲起</title>
    <url>/2016/12/09/Dynamic-programming/</url>
    <content><![CDATA[## 概要
在做NOIP提高组day2第一题时，这个题的目标就是计算出组合数，也即题目中的系数。
## 实战
### 方法一
使用组合数公式
{% asset_image 1.jpg %}
<!-- more -->
可以看到，里面是三个阶乘，按照这个思路，可以这样

```C++
#include<iostream>
using namespace std;
int factor(int n)
{
    if (n==0|n==1)
        return n;
    return n*factor(n-1);
}
int main ()
{
    int n,m,ans;
    scanf("%d%d",&n,&m);
    ans=factor(m)/(factor(n)*factor(m-n));
    printf("%d",ans);
}
```

### 方法二
使用组合书递推公式
C（M-1，N-1）+C（M-1，N）=C（M，N）
下面是代码实现
```C++
#include <iostream>
int aa[1000][1000];
using namespace std;
int conbinatorics(int n,int m)
{
    if(aa[n][m])
        return aa[n][m];
    if(m==1)
    {
        return aa[n][m]=n;
    }
    if(n==m)
    {
        return aa[n][m]=1;
    }
    return aa[n][m]=conbinatorics(n-1,m-1)+conbinatorics(n-1,m);
}
int main()
{
    int n,m;
    cin>>n>>m;
    cout <<conbinatorics(n,m)<< endl;
    return 0;
}
```
{% asset_image 2.png %}

这里使用了动态规划————记录结果再利用，本可以节省很多时间，但是在这个代码示范中体现得不明显。请看下面。
## 斐波那契数列
F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)
代码实现：
```C++
#include<iostream>
using namespace std;
int F(int n)
{
    if(n==1||n==2)
        return 1;
    else
        return F(n-1)+F(n-2);
}
int main ()
{
    int n;
    cin>>n;
    cout<<F(n)<<endl;
    return 0;
}
```
示例，当n= 40时，用时0.654s，

{% asset_image 3.jpg %}


用动态规划，代码实现如下：

```C++
#include<iostream>
using namespace std;
int array[1000];
int F(int n)
{
    if(array[n])
        return array[n];
    else
    {
        array[n]=F(n-1)+F(n-2);
        return array[n];
    }

}
int main ()
{
    int n=40;
    array[2]=array[1]=1;
    cout<<F(n)<<endl;
    return 0;
}
```

{% asset_image 4.jpg %}

时间大幅度减少，虽然仍然不到一秒钟，但是用时相差约46倍，已经是巨大的差别了。

原因如下：
```
F(40)=F(39)+F(38);
F(39)=F(38)+F(37);
F(38)=F(37)+F(36);
······
```
仔细一看，虽然算法没错，但是F(39)和F(38)被计算了两次，如果继续往下的话，会发现有许多数倍计算了很多次，那么在第一次用到这个数的时候，就把它所对应的结果记录在array中，需要用的时候直接用就好了，节省很多运行时间。

## 总结
动态规划————记录结果再利用
{% cq %} 生命在于折腾 {% endcq %}]]></content>
      <tags>
        <tag>C++</tag>
        <tag>算法</tag>
        <tag>动态规划</tag>
      </tags>
  </entry>
  <entry>
    <title>FRP</title>
    <url>/2017/11/01/FRP/</url>
    <content><![CDATA[这里应该@大老板一下的，这是一个很有意思的小工具，其实也不小，这里仅作推广，作者的文档已经足够详细，使用得当的话，非常方便。
于是，我把作者的文档完整的扣过来了，希望不会被打o(*￣▽￣*)o
项目位于[https://github.com/fatedier/frp](https://github.com/fatedier/frp)
## frp 的作用

* 利用处于内网或防火墙后的机器，对外网环境提供 http 或 https 服务。
* 对于 http, https 服务支持基于域名的虚拟主机，支持自定义域名绑定，使多个域名可以共用一个80端口。
* 利用处于内网或防火墙后的机器，对外网环境提供 tcp 和 udp 服务，例如在家里通过 ssh 访问处于公司内网环境内的主机。
<!-- more -->
## 开发状态

frp 仍然处于前期开发阶段，未经充分测试与验证，不推荐用于生产环境。

master 分支用于发布稳定版本，dev 分支用于开发，您可以尝试下载最新的 release 版本进行测试。

**目前的交互协议可能随时改变，不保证向后兼容，升级新版本时需要注意公告说明同时升级服务端和客户端。**

## 架构

![architecture](architecture.png)

## 使用示例

根据对应的操作系统及架构，从 [Release](https://github.com/fatedier/frp/releases) 页面下载最新版本的程序。

将 **frps** 及 **frps.ini** 放到具有公网 IP 的机器上。

将 **frpc** 及 **frpc.ini** 放到处于内网环境的机器上。

### 通过 ssh 访问公司内网机器

1. 修改 frps.ini 文件，这里使用了最简化的配置：

  ```ini
  # frps.ini
  [common]
  bind_port = 7000
  ```

2. 启动 frps：

  `./frps -c ./frps.ini`

3. 修改 frpc.ini 文件，假设 frps 所在服务器的公网 IP 为 x.x.x.x；

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [ssh]
  type = tcp
  local_ip = 127.0.0.1
  local_port = 22
  remote_port = 6000
  ```

4. 启动 frpc：

  `./frpc -c ./frpc.ini`

5. 通过 ssh 访问内网机器，假设用户名为 test：

  `ssh -oPort=6000 test@x.x.x.x`

### 通过自定义域名访问部署于内网的 web 服务

有时想要让其他人通过域名访问或者测试我们在本地搭建的 web 服务，但是由于本地机器没有公网 IP，无法将域名解析到本地的机器，通过 frp 就可以实现这一功能，以下示例为 http 服务，https 服务配置方法相同， vhost_http_port 替换为 vhost_https_port， type 设置为 https 即可。

1. 修改 frps.ini 文件，设置 http 访问端口为 8080：

  ```ini
  # frps.ini
  [common]
  bind_port = 7000
  vhost_http_port = 8080
  ```

2. 启动 frps；

  `./frps -c ./frps.ini`

3. 修改 frpc.ini 文件，假设 frps 所在的服务器的 IP 为 x.x.x.x，local_port 为本地机器上 web 服务对应的端口, 绑定自定义域名 `www.yourdomain.com`:

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000

  [web]
  type = http
  local_port = 80
  custom_domains = www.yourdomain.com
  ```

4. 启动 frpc：

  `./frpc -c ./frpc.ini`

5. 将 `www.yourdomain.com` 的域名 A 记录解析到 IP `x.x.x.x`，如果服务器已经有对应的域名，也可以将 CNAME 记录解析到服务器原先的域名。

6. 通过浏览器访问 `http://www.yourdomain.com:8080` 即可访问到处于内网机器上的 web 服务。

### 转发 DNS 查询请求

DNS 查询请求通常使用 UDP 协议，frp 支持对内网 UDP 服务的穿透，配置方式和 TCP 基本一致。

1. 修改 frps.ini 文件：

  ```ini
  # frps.ini
  [common]
  bind_port = 7000
  ```

2. 启动 frps：

  `./frps -c ./frps.ini`

3. 修改 frpc.ini 文件，设置 frps 所在服务器的 IP 为 x.x.x.x，转发到 Google 的 DNS 查询服务器 `8.8.8.8` 的 udp 53 端口：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [dns]
  type = udp
  local_ip = 8.8.8.8
  local_port = 53
  remote_port = 6000
  ```

4. 启动 frpc：

  `./frpc -c ./frpc.ini`

5. 通过 dig 测试 UDP 包转发是否成功，预期会返回 `www.google.com` 域名的解析结果：

  `dig @x.x.x.x -p 6000 www.goolge.com`

### 转发 Unix域套接字

通过 tcp 端口访问内网的 unix域套接字(和 docker daemon 通信)。

frps 的部署步骤同上。

1. 启动 frpc，启用 unix_domain_socket 插件，配置如下：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [unix_domain_socket]
  type = tcp
  remote_port = 6000
  plugin = unix_domain_socket
  plugin_unix_path = /var/run/docker.sock
  ```

2. 通过 curl 命令查看 docker 版本信息

  `curl http://x.x.x.x:6000/version`

### 安全地暴露内网服务

对于某些服务来说如果直接暴露于公网上将会存在安全隐患。

使用 **stcp(secret tcp)** 类型的代理可以避免让任何人都能访问到要穿透的服务，但是访问者也需要运行另外一个 frpc。

以下示例将会创建一个只有自己能访问到的 ssh 服务代理。

frps 的部署步骤同上。

1. 启动 frpc，转发内网的 ssh 服务，配置如下，不需要指定远程端口：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000

  [secret_ssh]
  type = stcp
  # 只有 sk 一致的用户才能访问到此服务
  sk = abcdefg
  local_ip = 127.0.0.1
  local_port = 22
  ```

2. 在要访问这个服务的机器上启动另外一个 frpc，配置如下：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000

  [secret_ssh_vistor]
  type = stcp
  # stcp 的访问者
  role = vistor
  # 要访问的 stcp 代理的名字
  server_name = secret_ssh
  sk = abcdefg
  # 绑定本地端口用于访问 ssh 服务
  bind_addr = 127.0.0.1
  bind_port = 6000
  ```

3. 通过 ssh 访问内网机器，假设用户名为 test：

  `ssh -oPort=6000 test@127.0.0.1`

### 通过 frpc 所在机器访问外网

frpc 内置了 http proxy 和 socks5 插件，可以使其他机器通过 frpc 的网络访问互联网。

frps 的部署步骤同上。

1. 启动 frpc，启用 http_proxy 或 socks5 插件(plugin 换为 socks5 即可)， 配置如下：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [http_proxy]
  type = tcp
  remote_port = 6000
  plugin = http_proxy
  ```

2. 浏览器设置 http 或 socks5 代理地址为 `x.x.x.x:6000`，通过 frpc 机器的网络访问互联网。

## 功能说明

### 配置文件

由于 frp 目前支持的功能和配置项较多，未在文档中列出的功能可以从完整的示例配置文件中发现。

[frps 完整配置文件](./conf/frps_full.ini)

[frpc 完整配置文件](./conf/frpc_full.ini)

### Dashboard

通过浏览器查看 frp 的状态以及代理统计信息展示。

需要在 frps.ini 中指定 dashboard 服务使用的端口，即可开启此功能：

```ini
[common]
dashboard_port = 7500
# dashboard 用户名密码，默认都为 admin
dashboard_user = admin
dashboard_pwd = admin
```

打开浏览器通过 `http://[server_addr]:7500` 访问 dashboard 界面，用户名密码默认为 `admin`。

![dashboard](dashboard.png)

### 身份验证

从 v0.10.0 版本开始，所有 proxy 配置全部放在客户端(也就是之前版本的特权模式)，服务端和客户端的 common 配置中的 `privilege_token` 参数一致则身份验证通过。

需要注意的是 frpc 所在机器和 frps 所在机器的时间相差不能超过 15 分钟，因为时间戳会被用于加密验证中，防止报文被劫持后被其他人利用。

这个超时时间可以在配置文件中通过 `authentication_timeout` 这个参数来修改，单位为秒，默认值为 900，即 15 分钟。如果修改为 0，则 frps 将不对身份验证报文的时间戳进行超时校验。

### 加密与压缩

这两个功能默认是不开启的，需要在 frpc.ini 中通过配置来为指定的代理启用加密与压缩的功能，压缩算法使用 snappy：

```ini
# frpc.ini
[ssh]
type = tcp
local_port = 22
remote_port = 6000
use_encryption = true
use_compression = true
```

如果公司内网防火墙对外网访问进行了流量识别与屏蔽，例如禁止了 ssh 协议等，通过设置 `use_encryption = true`，将 frpc 与 frps 之间的通信内容加密传输，将会有效防止流量被拦截。

如果传输的报文长度较长，通过设置 `use_compression = true` 对传输内容进行压缩，可以有效减小 frpc 与 frps 之间的网络流量，加快流量转发速度，但是会额外消耗一些 cpu 资源。

### 客户端热加载配置文件

当修改了 frpc 中的代理配置，可以通过 `frpc --reload` 命令来动态加载配置文件，通常会在 10 秒内完成代理的更新。

启用此功能需要在 frpc 中启用 admin 端口，用于提供 API 服务。配置如下：

```ini
# frpc.ini
[common]
admin_addr = 127.0.0.1
admin_port = 7400
```

之后执行重启命令：

`frpc -c ./frpc.ini --reload`

等待一段时间后客户端会根据新的配置文件创建、更新、删除代理。

**需要注意的是，[common] 中的参数除了 start 外目前无法被修改。**

### 特权模式

由于从 v0.10.0 版本开始，所有 proxy 都在客户端配置，原先的特权模式是目前唯一支持的模式。

#### 端口白名单

为了防止端口被滥用，可以手动指定允许哪些端口被使用，在 frps.ini 中通过 privilege_allow_ports 来指定：

```ini
# frps.ini
[common]
privilege_allow_ports = 2000-3000,3001,3003,4000-50000
```

privilege_allow_ports 可以配置允许使用的某个指定端口或者是一个范围内的所有端口，以 `,` 分隔，指定的范围以 `-` 分隔。

### TCP 多路复用

从 v0.10.0 版本开始，客户端和服务器端之间的连接支持多路复用，不再需要为每一个用户请求创建一个连接，使连接建立的延迟降低，并且避免了大量文件描述符的占用，使 frp 可以承载更高的并发数。

该功能默认启用，如需关闭，可以在 frps.ini 和 frpc.ini 中配置，该配置项在服务端和客户端必须一致：

```ini
# frps.ini 和 frpc.ini 中
[common]
tcp_mux = false
```

### 底层通信可选 kcp 协议

从 v0.12.0 版本开始，底层通信协议支持选择 kcp 协议，在弱网环境下传输效率提升明显，但是会有一些额外的流量消耗。

开启 kcp 协议支持：

1. 在 frps.ini 中启用 kcp 协议支持，指定一个 udp 端口用于接收客户端请求：

  ```ini
  # frps.ini
  [common]
  bind_port = 7000
  # kcp 绑定的是 udp 端口，可以和 bind_port 一样
  kcp_bind_port = 7000
  ```

2. 在 frpc.ini 指定需要使用的协议类型，目前只支持 tcp 和 kcp。其他代理配置不需要变更：

  ```ini
  # frpc.ini
  [common]
  server_addr = x.x.x.x
  # server_port 指定为 frps 的 kcp_bind_port
  server_port = 7000
  protocol = kcp
  ```

3. 像之前一样使用 frp，需要注意开放相关机器上的 udp 的端口的访问权限。

### 连接池

默认情况下，当用户请求建立连接后，frps 才会请求 frpc 主动与后端服务建立一个连接。当为指定的代理启用连接池后，frp 会预先和后端服务建立起指定数量的连接，每次接收到用户请求后，会从连接池中取出一个连接和用户连接关联起来，避免了等待与后端服务建立连接以及 frpc 和 frps 之间传递控制信息的时间。

这一功能比较适合有大量短连接请求时开启。

1. 首先可以在 frps.ini 中设置每个代理可以创建的连接池上限，避免大量资源占用，客户端设置超过此配置后会被调整到当前值：

  ```ini
  # frps.ini
  [common]
  max_pool_count = 5
  ```

2. 在 frpc.ini 中为客户端启用连接池，指定预创建连接的数量：

  ```ini
  # frpc.ini
  [common]
  pool_count = 1
  ```

### 修改 Host Header

通常情况下 frp 不会修改转发的任何数据。但有一些后端服务会根据 http 请求 header 中的 host 字段来展现不同的网站，例如 nginx 的虚拟主机服务，启用 host-header 的修改功能可以动态修改 http 请求中的 host 字段。该功能仅限于 http 类型的代理。

```ini
# frpc.ini
[web]
type = http
local_port = 80
custom_domains = test.yourdomain.com
host_header_rewrite = dev.yourdomain.com
```

原来 http 请求中的 host 字段 `test.yourdomain.com` 转发到后端服务时会被替换为 `dev.yourdomain.com`。

### 获取用户真实 IP

目前只有 **http** 类型的代理支持这一功能，可以通过用户请求的 header 中的 `X-Forwarded-For` 和 `X-Real-IP` 来获取用户真实 IP。

**需要注意的是，目前只在每一个用户连接的第一个 HTTP 请求中添加了这两个 header。**

### 通过密码保护你的 web 服务

由于所有客户端共用一个 frps 的 http 服务端口，任何知道你的域名和 url 的人都能访问到你部署在内网的 web 服务，但是在某些场景下需要确保只有限定的用户才能访问。

frp 支持通过 HTTP Basic Auth 来保护你的 web 服务，使用户需要通过用户名和密码才能访问到你的服务。

该功能目前仅限于 http 类型的代理，需要在 frpc 的代理配置中添加用户名和密码的设置。

```ini
# frpc.ini
[web]
type = http
local_port = 80
custom_domains = test.yourdomain.com
http_user = abc
http_pwd = abc
```

通过浏览器访问 `http://test.yourdomain.com`，需要输入配置的用户名和密码才能访问。

### 自定义二级域名

在多人同时使用一个 frps 时，通过自定义二级域名的方式来使用会更加方便。

通过在 frps 的配置文件中配置 `subdomain_host`，就可以启用该特性。之后在 frpc 的 http、https 类型的代理中可以不配置 `custom_domains`，而是配置一个 `subdomain` 参数。

只需要将 `*.{subdomain_host}` 解析到 frps 所在服务器。之后用户可以通过 `subdomain` 自行指定自己的 web 服务所需要使用的二级域名，通过 `{subdomain}.{subdomain_host}` 来访问自己的 web 服务。

```ini
# frps.ini
[common]
subdomain_host = frps.com
```

将泛域名 `*.frps.com` 解析到 frps 所在服务器的 IP 地址。

```ini
# frpc.ini
[web]
type = http
local_port = 80
subdomain = test
```

frps 和 fprc 都启动成功后，通过 `test.frps.com` 就可以访问到内网的 web 服务。

需要注意的是如果 frps 配置了 `subdomain_host`，则 `custom_domains` 中不能是属于 `subdomain_host` 的子域名或者泛域名。

同一个 http 或 https 类型的代理中 `custom_domains`  和 `subdomain` 可以同时配置。

### URL 路由

frp 支持根据请求的 URL 路径路由转发到不同的后端服务。

通过配置文件中的 `locations` 字段指定一个或多个 proxy 能够匹配的 URL 前缀(目前仅支持最大前缀匹配，之后会考虑正则匹配)。例如指定 `locations = /news`，则所有 URL 以 `/news` 开头的请求都会被转发到这个服务。

```ini
# frpc.ini
[web01]
type = http
local_port = 80
custom_domains = web.yourdomain.com
locations = /

[web02]
type = http
local_port = 81
custom_domains = web.yourdomain.com
locations = /news,/about
```

按照上述的示例配置后，`web.yourdomain.com` 这个域名下所有以 `/news` 以及 `/about` 作为前缀的 URL 请求都会被转发到 web02，其余的请求会被转发到 web01。

### 通过代理连接 frps

在只能通过代理访问外网的环境内，frpc 支持通过 HTTP PROXY 和 frps 进行通信。

可以通过设置 `HTTP_PROXY` 系统环境变量或者通过在 frpc 的配置文件中设置 `http_proxy` 参数来使用此功能。

仅在 `protocol = tcp` 时生效。

```ini
# frpc.ini
[common]
server_addr = x.x.x.x
server_port = 7000
http_proxy = http://user:pwd@192.168.1.128:8080
```

### 插件

默认情况下，frpc 只会转发请求到本地 tcp 或 udp 端口。

插件模式是为了在客户端提供更加丰富的功能，目前内置的插件有 **unix_domain_socket**、**http_proxy**、**socks5**。具体使用方式请查看[使用示例](#使用示例)。

通过 `plugin` 指定需要使用的插件，插件的配置参数都以 `plugin_` 开头。使用插件后 `local_ip` 和 `local_port` 不再需要配置。

使用 **http_proxy** 插件的示例:

```ini
# frpc.ini
[http_proxy]
type = tcp
remote_port = 6000
plugin = http_proxy
plugin_http_user = abc
plugin_http_passwd = abc
```

`plugin_http_user` 和 `plugin_http_passwd` 即为 `http_proxy` 插件可选的配置参数。

## 开发计划

计划在后续版本中加入的功能与优化，排名不分先后，如果有其他功能建议欢迎在 [issues](https://github.com/fatedier/frp/issues) 中反馈。

* frps 记录 http 请求日志。
* frps 支持直接反向代理，类似 haproxy。
* frpc 支持负载均衡到后端不同服务。
* frpc 支持直接作为 webserver 访问指定静态页面。
* 支持 udp 打洞的方式，提供两边内网机器直接通信，流量不经过服务器转发。
* 集成对 k8s 等平台的支持。

## 为 frp 做贡献

frp 是一个免费且开源的项目，我们欢迎任何人为其开发和进步贡献力量。

* 在使用过程中出现任何问题，可以通过 [issues](https://github.com/fatedier/frp/issues) 来反馈。
* Bug 的修复可以直接提交 Pull Request 到 dev 分支。
* 如果是增加新的功能特性，请先创建一个 issue 并做简单描述以及大致的实现方法，提议被采纳后，就可以创建一个实现新特性的 Pull Request。
* 欢迎对说明文档做出改善，帮助更多的人使用 frp，特别是英文文档。
* 贡献代码请提交 PR 至 dev 分支，master 分支仅用于发布稳定可用版本。
* 如果你有任何其他方面的问题，欢迎反馈至 fatedier@gmail.com 共同交流。

**提醒：和项目相关的问题最好在 [issues](https://github.com/fatedier/frp/issues) 中反馈，这样方便其他有类似问题的人可以快速查找解决方法，并且也避免了我们重复回答一些问题。**

## 捐助

如果您觉得 frp 对你有帮助，欢迎给予我们一定的捐助来维持项目的长期发展。

frp 交流群：606194980 (QQ 群号)

### 支付宝扫码捐赠

![donate-alipay](donate-alipay.png)

### 微信支付捐赠

![donate-wechatpay](donate-wechatpay.png)

### Paypal 捐赠

海外用户推荐通过 [Paypal](https://www.paypal.me/fatedier) 向作者的账户 **fatedier@gmail.com** 进行捐赠。]]></content>
  </entry>
  <entry>
    <title>摆渡人</title>
    <url>/2017/01/10/Ferryman/</url>
    <content><![CDATA[>I exist because you need me.
如果我真的存在，也是因为你需要我。

 {% asset_img 1.jpg 如果命运是一条孤独的河流，谁会是你的摆渡人？ %}
 <!-- more -->
前些天读完《摆渡人》，小小的写点读后感。
>他坐在隧道出口的左侧，手放在膝盖上，注视着她。在这个距离望过去，只能辨认出他是个男孩，大概十几岁的样子。山风吹乱了他浅茶色的头发，拍打着他的脸。
“崔斯坦”她低声说，轻松和喜悦一下充盈在胸中。她看着他出现在了自己的世界里，如痴如醉。
他成功了。
这时，一个人走过来隔在了他们之间，是一个消防队员。迪伦静静的看着他俯下身子，给崔斯坦的肩上披上了一条毯子。那人在向他询问着什么，迪伦看到崔斯坦摇了摇头。接着他慢慢地，有点笨手笨脚的从草地上站了起来。对着消防队员讲完了最后一句话，他开始朝她的方向缓缓走了过来。就要走到她跟前时，他冲她一笑。
“嗨。”他喃喃地说，伸出一只手轻柔地拍了拍迪伦身上地毯子。他的手指顺着她身体一侧慢慢划过，最后紧紧地抓住了她的手。
“嗨。”她也轻声回了一句，嘴唇颤抖着露出了微笑，“原来你在这里。”
“我在这里。”

迪伦很平静的接受了自己死亡的事实。崔斯坦感觉这个灵魂的不一般。

听了崔斯坦的口中故事，迪伦觉得崔斯坦受着不平之待遇。

灵魂与她的摆渡人一同跨过险恶的荒原。

迪伦在跨过边界之后，仍然做出了所有灵魂都没有做出过的决定————返回荒原，寻找崔斯坦。即使这样会死去。

{% asset_img 2.jpg %}
{% cq %}
人这一辈子，所求为何？得何而足？
一个灵魂伴侣。
{% endcq %}]]></content>
      <tags>
        <tag>文学</tag>
      </tags>
  </entry>
  <entry>
    <title>用Python搭建FTP服务器</title>
    <url>/2017/06/18/FileTransfer-by-python/</url>
    <content><![CDATA[{% asset_img 1.jpg %}
<!-- more -->
## 说明
在之前的[某篇文章](http://bdznh.coding.me/2016/11/25/High-Speed-transfer/)中，介绍了告诉传输文件的办法，在文中，我使用了`nginx`来共享文件，缺点在于Windows的文件编码方式为GBK，在传输中文名的文件的时候，会出错，Windows下搭建FTP服务器的方式还有Windows自带的`Internet Information Service 管理器`，此法可解决中文问题，但是CPU占用较高，我的电脑上用IIS(Internet Information Service 管理器)搭建的FTP服务器来传松文件的时候，CPU占用超过30%，但是用`nginx`CPU占用不到5%。所以，今天换另外一个FTP服务器——`pyftpdlib`

## 安装
首先，电脑上得有已经安装好的python环境，然后使用pip命令安装
```bash
pip insstall pyftpdlib
```

## 运行
编辑一个纯文本文件，其内容如下
```
    #coding:utf-8
    from pyftpdlib.authorizers import DummyAuthorizer
    from pyftpdlib.handlers import FTPHandler
    from pyftpdlib.servers import FTPServer
    #新建一个用户组
    authorizer = DummyAuthorizer()
    #将用户名，密码，指定目录，权限 添加到里面
    authorizer.add_user("fan", "root", "E:/UT_Downloads/", perm="elr")#adfmw
    #这个是添加匿名用户,任何人都可以访问，如果去掉的话，需要输入用户名和密码，可以自己尝试
    authorizer.add_anonymous("D:/")

    handler = FTPHandler
    handler.authorizer = authorizer
    #开启服务器
    server = FTPServer(("127.0.0.1", 21), handler)
    server.serve_forever()
```
其中，`E:/UT_Downloads/`是需要共享的文件所在路径，可以自行更改，`fan`和`root`是用户名和密码，也可以自己改动，而`authorizer.add_anonymous("D:/")`是用来控制是否允许匿名用户登录的，若是把改行注释(行首加#号)，在登录服务器的时候，就需要输入用户名和密码了
{% asset_img 3.jpg %}
将文件名后缀设置为`.py`,在命令行下切换到该文件所在目录，使用`python ***.py`就可以打开FTP服务器了
{% asset_img 2.jpg %}
## 连接展示
`nginx`搭建的实际上是`http`服务器，没办法文件管理器里面打开，用`pyftpdlib`搭建的是可以在文件管理器里面打开的。
{% asset_img 4.jpg %}
{% asset_img 5.jpg %}

## 存在的问题
1. 以上示范代码，可以提供文件的下载，但是还不支持文件上传，若有上传文件的需要，可阅读官方的[文档](http://pythonhosted.org/pyftpdlib/)。
我编辑此文的时候，还未与`nginx`的性能相比较过。
2. Windows下的中文乱码
### 描述
此问题表现为在浏览器打开FTP服务器是正常的，在文件管理器打开FTP服务器是乱码的。
### 解决办法
解决方法为更改`pyftpdlib`的源代码，到[https://github.com/giampaolo/pyftpdlib/](https://github.com/giampaolo/pyftpdlib/)下载源代码，更改`pyftpdlib`文件夹下的`filesystems.py`,第`471`行和`603`的`utf8`改为`gbk`,文件`handlers.py`的`1382`行的`utf8`改为`gbk`，然后在命令行切换到`setup.py`文件所在的目录，使用命令`python setup.py install`进行安装。


## 卸载`pyftpdlib`
由于之前已经通过命令`pip insstall pyftpdlib`安装过了，所以用源代码安装的时候会提示已经安装，可以通过命令
```bash
pip uninstall pyftpdlib
```
来将之前的`pyftpdlib`卸载掉，然后再安装更改源代码后的`pyftpdlib`
]]></content>
  </entry>
  <entry>
    <title>First day</title>
    <url>/2016/03/26/First-day/</url>
    <content><![CDATA[### 今天，正式开始！
2016年3月26日 于西安电子科技大学

{% asset_img myweblogo.jpg This %}


]]></content>
  </entry>
  <entry>
    <title>搞定Putty的编译问题</title>
    <url>/2017/11/11/Fix-putty-bug/</url>
    <content><![CDATA[

之前编译Putty的时候，遇到如下错误：
```
In file included from ../windows/window.c:29:0:
D:/CodeBlocks/MinGW/i686-w64-mingw32/include/multimon.h: In function 'IsPlatformNT':
D:/CodeBlocks/MinGW/i686-w64-mingw32/include/multimon.h:130:38: error: 'osvi' undeclared (first use in this function)
     oi.dwOSVersionInfoSize = sizeof (osvi);
                                      ^~~~
D:/CodeBlocks/MinGW/i686-w64-mingw32/include/multimon.h:130:38: note: each undeclared identifier is reported only once for each function it appears in
mingw32-make: *** [.\Makefile.mgw:963: window.o] Error 1
```

<!-- more -->

之前没怎么仔细看过报错信息，而是把Visual Studio的`multimon.h`替换掉Mingw的来解决报错。
现在回头仔细看了看了信息，无非是Mingw的`multimon.h`里面的`IsPlatformNT`函数内的`osvi`未定义，同时打开了Mingw和Visual Studio的`multimon.h`，显示如下
{% asset_img 1.png %}
如图，可以看到Mingw的头文件内定义的变量是`oi`，但是使用的时候却用了`osvi`，初步估计是Mingw的问题了，向社区提交，等待回复。]]></content>
  </entry>
  <entry>
    <title>仿Hexdump的实现</title>
    <url>/2024/07/30/Hexdump-sample/</url>
    <content><![CDATA[
编码过程中我们有时候需要将数据的十六进制值打出来看看，这里做一下记录

<!-- more -->

```cpp
#include <ctype.h>
#include <unistd.h>
#include <sstream>
#include <string>
#include <iomanip>

std::string pretty_string(uint8_t* ret,size_t size)
{
    if(size == 0)
    {
        return "";
    }
    std::stringstream out;
    for (size_t i = 0; i < size; i++)
    {
        size_t c = i;
        out << std::hex << std::setw(2*sizeof(size_t)) << std::setfill('0') << i << "  ";
        for (size_t j = 0; j < 8; j++, c++)
        {
            if (c < size)
            {
                // printf("%02X ", ret[c]);
                out << std::hex << std::setw(2) << std::setfill('0') << (int)ret[c] << " ";
            }
            else
            {
                out << "   ";
            }
        }
        out << " ";
        for (size_t j = 0; j < 8; j++, c++)
        {
            if (c < size)
            {
                out << std::hex << std::setw(2)  << std::setfill('0') << (int)ret[c] << " ";
            }
            else
            {
                out << "   ";
            }
        }
        c = i;
        out << "   |";
        size_t count = 0;
        for (size_t j = 0; j < 16 && c < size; j++, c++, count++)
        {
            if (isprint(ret[c]) && ret[c])
            {
                out << (char)ret[c];
            }
            else
            {
                out << ".";
            }
        }
        i = i + count - 1;
        out <<"|\n";
    }
    out << std::hex << std::setw(2*sizeof(size_t)) << std::setfill('0') << size << std::endl;
    return out.str();
}

void pretty_print(uint8_t* ret,size_t size)
{
    for (size_t i = 0; i < size; i++)
    {
        size_t c = i;
        printf("%0.*zx  ",(int)sizeof(size_t)*2,i);
        for (size_t j = 0; j < 8; j++, c++)
        {
            if (c < size)
            {
                printf("%02X ", ret[c]);
            }
            else
            {
                printf("   ");
            }
        }
        printf(" ");
        for (size_t j = 0; j < 8; j++, c++)
        {
            if (c < size)
            {
                printf("%02X ", ret[c]);
            }
            else
            {
                printf("   ");
            }
        }
        c = i;
        printf("   |");
        size_t count = 0;
        for (size_t j = 0; j < 16 && c < size; j++, c++, count++)
        {
            if (isprint(ret[c]) && ret[c])
            {
                printf("%c", ret[c]);
            }
            else
            {
                printf(".");
            }
        }
        i = i + count - 1;
        printf("|\n");
    }
    printf("%0.*zx\n",(int)sizeof(size_t)*2,size);
}
```
]]></content>
  </entry>
  <entry>
    <title>高速传输文件的办法</title>
    <url>/2016/11/25/High-Speed-transfer/</url>
    <content><![CDATA[
{% asset_img haha.jpg %}
<!-- more -->

## 一点点小说明
有时候，需要在电脑与电脑之间传输一些文件，用U盘有时候不太方便，或者遇到U盘读不出来的奇葩情况，真是一出接一出，于是想办法。
同一个局域网下的电脑对传的话，一般网速能达到上限，速度不错，按100M的路由器来看，速度一般能在10MB/s左右。
## 局域网传输————Dukto
网上找到一个不错的软件————DuktoR6，这货速度虽然不快，我这儿测试速度3MB/s左右，不过它可用于大部分平台，windows，linux，Android，ios，windows phone，windows 10 mobile/pc，涵盖了日常能用到的大部分平台，连windows phone和windows 10 mobile都有，不得不说是一个良心软件。
{% asset_img dukto.jpg %}

使用方法是：两个终端(电脑或者手机)在同一个局域网下，打开DuktoR6，正常情况下软件会自动找到其它客户端，如上图，如果找不到的话，便点击 “IP connection” ，输入接受端的IP地址，若不知道接收端的IP地址的话，在接收端点击最下面三个图标的中间那个图标，就知道了，若是接收端同时具有多个IP地址，就得找到与发送端同一个网段得IP地址才行，用同样的办法查看发送端的IP地址，看IP地址的前三部分的相似度，在大多数情况下，普通路由器分配给终端的IP地址都形如“192.168.1.X或者192.168.0.X。

找到接收端之后，选择要发送的文件或文件夹便可以发送了。

## 更加高速的办法
本方法适用于拷贝体积较大的文件，几G甚至几十G的文件拷贝用这种办法，时间会大大缩短。

现在的电脑大都配备了千兆网卡，理论传输速度是能超过100MB/s的，不过受限于运营商带宽或者路由器，一般网速只有几MB/s，如学校所用的翼讯，带宽为6M，最高下载持续下载速度也不到1MB/s，网卡性能浪费太多了。

两台电脑对传文件，若使用网线直接将两台电脑连接，这样带宽理论上是能达到网卡上限的。

## 原理说明

在上面所说的DuktoR6传输办法中，需要发送端和接收端都安装软件，有时候，这个反而不方便(比如两人都没有携带可以传输的设备，U盘什么的，别说手机了，有些手机不装驱动是没办法北电脑识别的)。

这里我使用的是最常见的直接通过链接下载的方法，也就是说通过TCP/IP协议，说得简单一点，就是拿浏览器直接下载了。

## 详细说明

### 安装nginx
{% asset_img nginx_logo.png nginx %}
如上面所说，想要通过浏览器直接下载对方电脑上的文件，得对方的电脑开启了web服务器，这个东西不难找，我使用的是[nginx](http://nginx.org),[点我下载](http://nginx.org/download/nginx-1.11.6.zip)
上面的下载链接是针对windows系统的，基于debian的系统使用下面的命令安装nginx

        sudo apt-get install nginx

基于redhat的系统使用下面的命令安装nginx

        sudo yum install nginx

下面以windows下的nginx使用方法为例

### 开启web服务器
使用命令提示符(在开始按钮上点击鼠标右键，选择命令提示符即可)，然后切换到nginx所在的文件夹，我写本文时nginx版本为1.11.6，解压下载的压缩包，所得目录结构如下

    │  nginx.exe
    │  
    ├─conf
    │      fastcgi.conf
    │      fastcgi_params
    │      koi-utf
    │      koi-win
    │      mime.types
    │      nginx.conf
    │      scgi_params
    │      uwsgi_params
    │      win-utf
    │      
    ├─contrib
    │  │  geo2nginx.pl
    │  │  README
    │  │  
    │  ├─unicode2nginx
    │  │      koi-utf
    │  │      unicode-to-nginx.pl
    │  │      win-utf
    │  │      
    │  └─vim
    │      ├─ftdetect
    │      │      nginx.vim
    │      │      
    │      ├─indent
    │      │      nginx.vim
    │      │      
    │      └─syntax
    │              nginx.vim
    │              
    ├─docs
    │      CHANGES
    │      CHANGES.ru
    │      LICENSE
    │      OpenSSL.LICENSE
    │      PCRE.LICENCE
    │      README
    │      zlib.LICENSE
    │      
    ├─html
    │      50x.html
    │      index.html
    │      
    ├─logs
    └─temp

输入命令

start nginx

看到一个黑框一闪而过，这个时候nginx已经启动了，在浏览器地址栏输入localhost，即可看到这样的画面
{% asset_img nginx2.jpg nginx is OK %}
我们同样可以在任务管理器查看进程
{% asset_img nginx3.jpg nginx is runing %}

### 搭建静态文件服务器
这一步做完，我们就已经成功一大半了，搭建静态文件服务器的办法是更改conf文件夹下的nginx.conf文件。
不管用什么办法(我使用了记事本)，编辑nginx.conf文件，将内容更改如下
```html
    #user  nobody;
    worker_processes  1;

    #error_log  logs/error.log;
    #error_log  logs/error.log  notice;
    #error_log  logs/error.log  info;

    #pid        logs/nginx.pid;

    events {
        worker_connections  1024;
    }

    http {
        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  65;
        server {
            listen       80;
            charset gbk;
            server_name  localhost;
            client_max_body_size 4G;
            root Directory_add;
            location / {
                autoindex on;
                autoindex_exact_size off;
                autoindex_localtime on;
            }
        }

    }
```
自行更改Directory_ add为被传输文件的目录，比如我再D盘的download文件夹下的文件是我想要传输被对方的，Directory_add就改成D:\Download
此时配置文件已经修改完成，使用命令

```bash
    nginx -s reload
```

重载配置，使其生效，比如这里我改成F:\Minecraft，重载配置文件后，浏览器打开localhost，界面是这样的：
{% asset_img server.jpg %}

这个时候，只要别人能打开这台电脑的IP，就可以直接点击相应的文件下载了。

### 开始传输
前面已经说过，原理便是搭建一个web静态文件服务器，这个时候，只要别人能连接打开服务器的电脑，便可以下载配置好的目录里面的文件了。

怎么连接呢？

第一种办法是仍然连接同一个局域网

第二种办法便是直接用网线连接两台电脑，没错，一根网线，两头都是电脑。
不过普通网线没办法使得两台电脑处于同一台局域网，要么使用交叉网线(这种网线一般用不到，所以不好找)，要么参考这个[办法](http://jingyan.baidu.com/article/148a1921be24c54d70c3b164.html)的方法2的第四和第五个步骤
{% asset_img share_net.png %}

*其实，绕来绕去，就是要让两台电脑能处于同一个网段下面，不管是连接同一个路由器还是用网线直连，目的都是这个。*

## PS的一些东西
在配置文件中，有这样一行

    charset gbk;

因为我是在windows内进行的演示，不用gbk的话，遇到中文名的文件会乱码，如果是linux系统的话，需要删除这一行或者把gbk改成utf-8。

并且，nginx不能放在含中文的目录下面，Dectory_add也不能是含有中文或者空格的目录。]]></content>
      <tags>
        <tag>小窍门</tag>
      </tags>
  </entry>
  <entry>
    <title>手动编译Spigot</title>
    <url>/2017/10/04/How-to-build-spigot-on-Windows/</url>
    <content><![CDATA[其实官网的教程很简单，只有一条命令：
```bash
java -jar BuildTools.jar
```
确实，用这一条命令就能完成，不过踩了一些坑。做一下记录。
前往[https://git-scm.com/](https://git-scm.com/)下载Git，[http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html#javasejdk](http://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html#javasejdk)下载jdk。
在国内首先要解决的是网络问题，否则数百MB的源码得很长时间才能下载好，然后，内存至少为2GB，1GB 是不够的，想来前几天编译总是失败的原因就是这个。
<!-- more -->
内存不够，会出现下面这个错误:
```
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at org.objectweb.asm.ClassReader.readLabel(ClassReader.java:2403)
        at org.objectweb.asm.ClassReader.readCode(ClassReader.java:1324)
        at org.objectweb.asm.ClassReader.readMethod(ClassReader.java:1165)
        at org.objectweb.asm.ClassReader.accept(ClassReader.java:727)
        at org.objectweb.asm.ClassReader.accept(ClassReader.java:525)
        at net.md_5.ss.repo.JarRepo.getClass0(JarRepo.java:38)
        at net.md_5.ss.repo.ClassRepo.getClass(ClassRepo.java:22)
        at net.md_5.ss.repo.AggregateRepo.getClass0(AggregateRepo.java:30)
        at net.md_5.ss.repo.ClassRepo.getClass(ClassRepo.java:22)
        at net.md_5.ss.remapper.EnhancedRemapper.findMethodDeclarer(EnhancedRemapper.java:67)
        at net.md_5.ss.remapper.EnhancedRemapper.mapMethodName(EnhancedRemapper.java:33)
        at org.objectweb.asm.commons.MethodRemapper.doVisitMethodInsn(MethodRemapper.java:155)
        at org.objectweb.asm.commons.MethodRemapper.visitMethodInsn(MethodRemapper.java:142)
        at org.objectweb.asm.ClassReader.readCode(ClassReader.java:1647)
        at org.objectweb.asm.ClassReader.readMethod(ClassReader.java:1165)
        at org.objectweb.asm.ClassReader.accept(ClassReader.java:727)
        at org.objectweb.asm.ClassReader.accept(ClassReader.java:525)
        at net.md_5.ss.model.ClassInfo.remap(ClassInfo.java:120)
        at net.md_5.ss.SpecialSource.map(SpecialSource.java:96)
        at net.md_5.ss.SpecialSource.main(SpecialSource.java:44)
Exception in thread "main" java.lang.RuntimeException: Error running command, return status !=0: [java, -jar, BuildData/bin/SpecialSource-2.jar, map, -i, work/minecraft_server.1.12.2.jar, -m, BuildData/mappings/bukkit-1.12.2-cl.csrg, -o, work/mapped.cf6b1333.jar-cl]
        at org.spigotmc.builder.Builder.runProcess(Builder.java:555)
        at org.spigotmc.builder.Builder.main(Builder.java:313)
        at org.spigotmc.builder.Bootstrap.main(Bootstrap.java:23)
```
很奇怪的一点是，因为我首先考虑了网络问题，所以我首先在VPS上执行编译，以便所有的源码全部下载好，然后打包下载到本地，再在本地编译，出现的错误同样是上面这个错误。
最后无奈，动用非常手段，让网络正常一点，清空工程目录，单独执行编译命令才成功。
来张合影
{% asset_img 1.png 编译成功，深更半夜的~~%}
编译成功后会在`BuildTools`同级目录里面出现`craftbukkit-1.12.2.jar`和`spigot-1.12.2.jar`，好了，拿去愉快的玩耍吧。]]></content>
      <tags>
        <tag>Minecraft</tag>
        <tag>Spigot</tag>
      </tags>
  </entry>
  <entry>
    <title>小米路由器与IPv6</title>
    <url>/2018/03/02/IPv6-For-xiaomi-nano-router/</url>
    <content><![CDATA[西电的校园网拨号之后可以获取到IPv6地址，刷了op的路由器也可以获取到IPv6地址，但是后端设备想要获取到IPv6地址还得再折腾一下。
手里的设备是小米路由器青春版。

<!-- more -->

将小米路由器刷成op，得给它换一个bootloader，这里使用的是breed，可以参考链接[http://www.v5china.com/xiaomi-router-youth-version-of-breed-after-the-brush-brush-into-asus-firmware-tutorial.html](http://www.v5china.com/xiaomi-router-youth-version-of-breed-after-the-brush-brush-into-asus-firmware-tutorial.html)，进行到该文章的第七步即可。
下载lede固件[https://downloads.lede-project.org/releases/17.01.4/targets/ramips/mt7628/lede-17.01.4-ramips-mt7628-miwifi-nano-squashfs-sysupgrade.bin](https://downloads.lede-project.org/releases/17.01.4/targets/ramips/mt7628/lede-17.01.4-ramips-mt7628-miwifi-nano-squashfs-sysupgrade.bin)，模仿第八步，为小米路由器安装lede固件。
开机之后，第一次连接会提示设置登录密码（使用网线，lede固件默认不开启WiFi），在network->>interface->>wan处可以设置路由器的联网方式，确保路由器能联网之后，使用[putty](https://the.earth.li/~sgtatham/putty/latest/w32/putty.exe)登录路由器
```bash
opkg update
opkg install luci-i18n-base-zh-cn
```
安装好中文语言包
```bash
opkg install kmod-ipt-nat6
```
安装nat6模块
```bash
echo "net.ipv6.conf.default.accept_ra=2" >> /etc/sysctl.conf
echo "net.ipv6.conf.all.accept_ra=2" >> /etc/sysctl.conf

uci set network.globals.ula_prefix="$(uci get network.globals.ula_prefix | sed 's/^./d/')"
uci commit network
uci set dhcp.lan.ra_default='1'
uci commit dhcp
```
配置网络
在`/etc/init.d/`目录下新建一个文件，向文件内写入
```bash
#!/bin/bash
ip6tables -t nat -I POSTROUTING -s `uci get network.globals.ula_prefix` -j MASQUERADE
route -A inet6 add 2000::/3 `route -A inet6 | grep ::/0 | awk 'NR==1{print "gw "$2" dev "$7}'`
```
应用文件并重启，通过WiFi和网线连接到路由器的设备可以获取IPv6地址。
{% asset_img 1.png 只能通过IPv6连接的六维空间 %}
## 乱七八糟
### 查看lede固件完整的支持列表：
[https://openwrt.org/toh/views/toh_fwdownload](https://openwrt.org/toh/views/toh_fwdownload)

### bootloader
换bootloader的原因是，路由器本身的bootloader不支持安装lede固件，就像给手机刷机需要更换recovery一样

### 失败的例子
从大一就开始尝试，一开始刷的的原版的openwrt，刷完之后根本无法开机，后来尝试了pandorabox，路由器能获取到IPv6地址，但是安装好nat6模块，执行命令转发时失败，内核不支持，辗转到了lede固件，貌似现在lede固件已经是openwrt的官方固件了，官网合并了。
]]></content>
  </entry>
  <entry>
    <title>Lake Counting</title>
    <url>/2016/04/03/Lake-Counting/</url>
    <content><![CDATA[## Lake Couting

今天看到一个挺有意思的题目，拿出来分享一下。

题目所体现的算法思想为“深度优先搜索”(实在想知道这是神马的，百度一下)

这里给出简单的解释：深度优先搜索从最开始的状态出发，遍历所有可以达到的状态。由此可以对所有的状态进行操作，或者列举出所有的状态。

<!-- more -->

### 题目：

有一个大小为N x M 的园子，雨后积满了水。八联通的积水被认为是连接在一起的。请求出这个园子里总共有多少水洼？(八联通指的是下图中相对  w 的 * 的部分)
```
***
www
***
```

### 数据限制：

N<100,m<100


### 输入数据:
```
10 12
w........ww.
.www.....www
....ww...ww.
.........ww.
.........w..
..w......w..
.w.w.....ww.
w.w.w.....w.
.w.w.....w..
..w......ww.
```


### 答案：
  3



### 源代码
下面是代码:
```C++
#include <iostream>
#include <cstdio>
using namespace std;//C++特有的命名空间，换为C的话，要去掉这行，并且改变头文件
int n,m;//定义全局变量，n为行数，m为列数；
char field[101][101];
void dfs(int x,int y)
{
    field[x][y]='.';//将当前位置替换为“.”
    //循环遍历当前位置周围的八个方向
    for (int dx = -1; dx < 1; dx++)
    {
        for (int dy = -1; dy <= 1; dy ++)
        {
            int nx=x+dx,ny=y+dy;//向x方向移动dx，向y方向移动dy。
            //判断(nx，ny)是不是在园子范围内，并判断是否有积水
            if(0<=nx&&nx>n&&0<=ny&&ny<m&&field[nx][ny]=='w')
            {
                dfs(nx,ny);//这儿是递归用法，仔细想想
            }
        }
    }
    return ;//这行是可以省略的，因为当前所在函数是void型。
}
void solve()
{
    int res=0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if (field[i][j]=='w')
            {
                dfs(i,j);//从有水(w)的地方开始搜索
                res++;
            }
        }
    }
    printf("%d\n",res);
}
int main()
{
    scanf("%d%d",&n,&m);
    int i=0,j=0;
    for( ; i<n ; i++ )
    {
        for( ; j<m ; j++ )
        {
            scanf("%c",&field[i][j]);
        }
    }
    solve();
    return 0;
}

```
其实，在windows系统下主函数中的
```C++
    for( ; i<n ; i++ )
    {
        for( ; j<m ; j++ )
        {
            scanf("%c",&field[i][j]);
        }
    }
```
也可以改写成
```C++
	for( ;i<n ;i++)
	{
		gets(field[i]);
	}
```
或者
```C++
for( ; i<n ; i++)
{
	scanf("%s",field[i]);
}
```
来减少一些输入，但是要注意gets函数在linux系统下是不允许使用的(有风险)。
“深度优先搜索”的信息，这种概念行性的东西,诸位还是百度吧，我说不清楚。
]]></content>
      <tags>
        <tag>深度优先搜索</tag>
      </tags>
  </entry>
  <entry>
    <title>Minecraft Server</title>
    <url>/2016/07/03/Minecraft-server/</url>
    <content><![CDATA[{% asset_img mc.jpg This is Minecraft %}

<!-- more -->

Minecraft由java编写，运行我的世界服务器(客户端)需要在计算机安装java运行环境，然后再计算机上运行服务端，在客户端填写运行服务端的计算机的ip地址就行(如果全部是默认设置的话) 
PS：本文所涉及的命令操作，在windows中为命令提示符下输入，在Linux中为终端或者控制台输入。下面不再特别说明。

## 第一步：在计算机上安装java运行环境。
计算机系统如果为windows，前往java官网下载“*jre*”运行环境，双击，默认安装在C盘，可以根据需要更改。没有特殊需要的话，一直点击下一步直到安装完成就行。
计算机系统如果为cent OS/red hat，可以输入如下命令
```bash
yum -y list | grep *java*
```
来查看有哪些java包可用，安装需要的包即可。
计算机系统如果为debian/ubuntu或基于它们的衍生版，输入如下命令
```bash
sudo apt-get install default-jre*
```
即可安装java。

## 第二步：运行Minecraft服务端
Minecraft服务端分为官方服务端和第三方服务端，官方服务端可以在MC官网下载到。这里提供1.10版本下载地址(经过测试，把下面链接中的1.10改成其他相应版本就能下载相应版本的服务端，把1.10改成1.9.4就能下载到1.9.4的服务端)

```bash
https://s3.amazonaws.com/Minecraft.Download/versions/1.10/minecraft_server.1.10.jar
```
也可以前往[https://minecraft.net/zh-hans/download/server](https://minecraft.net/zh-hans/download/server)获取最新版本的官方服务端。
第三方服务端这里提供一个网址——www.mcadmin.net，这个网址提供“水龙头”和“水桶”服务端下载。
一般客户端只能进入同版本的服务端，跨版本的服务端为第三方制作，可以前往www.mcbbs.net了解更多信息。
服务端为一个“.jar”文件，windows下使用命令行/linux下使用终端或者控制台，切换到服务端文件所在目录，输入命令
```bash
java -jar *.jar
```
(这里*.jar是指你下载到的服务端的文件的文件名)
这里还可以使用参数控制服务器所使用的内存，比如
```bash
java -Xmx768M -Xms512M -jar minecraft_server.1.10.jar
```
"-Xmx768M"是限制服务器所使用的最大内存，"-Xms512M"是限制服务器所使用的最小内存。
当出现如如下图的画面时，代表服务端开启成功(这里演示所使用的服务端为官服，版本1.10)

{% asset_img mc-server-1.jpg The server of Minecraft is OK %}


## 第三步： 联机

### 3.1

如果玩家在同一个局域网 (比如电脑连接了同一台路由器后者交换机，找到开启服务端的电脑的IP地址，在多人游戏中输入服务端的电脑的IP地址即可连接)
Windows可以用ipconfig，linux卡可以使用ifconfig查找自己的IP地址。

### 3.2

如果玩家相隔很远，这个时候就需要公网IP了。获取公网IP的办法有很多：
1. 租用服务器，阿里云和腾讯云都有针对学生认证的优惠，阿里云认证之后为10元每月，腾讯云认证后为1元每月；
2. 内网穿透
腾讯云和阿里云去官网登录按照提示来就行，这里不再赘述。
内网穿透估计大多数人都搞不定，这里指一个方向——花生壳，  到花生壳的官网查找，用内网穿透拿到公网IP，这样朋友就能和自己连接上了。

## 开服神器推荐——McMyAdmin

由于普通开服后，管理服务器时涉及很多命令操作，许多纯白的小白还是搞不定，这里推荐一个操作简单的开服软件——[McMyAdmin](http://www.mcmyadmin.com/)

{% asset_img mc-server-2.jpg Minecraft %}

{% asset_img mc-server-3.jpg Minecraft %}

{% asset_img mc-server-4.jpg Minecraft %}

PS：在运行linux的计算机上运行这个软件需要安装mono，由于在windows上运行这个McMyAdmin网上已经有很多教程了，这里不再累述。
我在安装mono时遇到不少麻烦，首先是cent OS自带源里面不包含mono，必须手动安装，然后百度，找了各种博客，按照叙述一步一步来，还是失败，最后在mono的[wiki](http://www.mono-project.com/docs/getting-started/install/linux/#centos-7-fedora-19-and-later-and-derivatives)找到解决办法，如下

CentOS 7, Fedora 19 (and later), and derivatives(需要root权限)
```bash
yum install yum-utils
rpm --import "http://keyserver.ubuntu.com/pks/lookup?op=get&search=0x3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF"
yum-config-manager --add-repo http://download.mono-project.com/repo/centos/
yum update
yum install mono-devel 
```
Debian, Ubuntu, and derivatives(root)
```bash
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee /etc/apt/sources.list.d/mono-xamarin.list
sudo apt-get update
sudo apt-get install mono-devel 
```
然后输入命令"mono -v"
出现如下信息则表示mono安装成功

{% asset_img mc-server-mono.jpg MONO %}
## 关于服务器的选择
服务器系统，最好选择红帽或者Cent OS，红帽背后是企业级支持，虽然个人用不上，但是，可以用它的衍生版Cent OS，至于为什么不选择Ubuntu之类的，我在腾讯云的1core & 1G RAM的VPS上，Ubuntu的表现远远不如Cent OS。]]></content>
      <tags>
        <tag>Minecraft</tag>
        <tag>Games</tag>
      </tags>
  </entry>
  <entry>
    <title>我的世界合成表</title>
    <url>/2017/02/01/Minecraft-synthetic-lists/</url>
    <content><![CDATA[{% asset_img mc.jpg %}
<!-- more -->
# 基本合成



| **名称**            | **材料**                                   | **合成示意图**                                | **描述**                                   |
| ----------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 木板Wooden Planks   | 原木Wood                                   | [![Craft Wooden Planks](112931J17-0.png)](112931J17-0.png) | 木板是最基本的材料，1个原木可以得到4个木板，所得到的的木板是我们游戏中重要的建造材料，并且木头可以用模板烧制成木炭！ |
| 木棍Sticks          | 木板Wooden Planks                          | [![Craft Sticks](1129314U7-1.png)](1129314U7-1.png) | 木棍用来合成火把,弓箭,栅栏,木牌,工具和武器。是游戏中另外一个基础的材料物品，游戏中消耗非常大，建议多做几组备用！ |
| 火把Torches         | 煤碳和木棍Coal & Stick                        | [![Craft Torches](1129312I0-2.png)](1129312I0-2.png) | 提供照明,避免刷怪,融化雪和冰块。火把在夜晚照明以及挖矿的时候都非常的有用，还可以防止刷怪！在火把旁边的冰块雪块，可以很快的融化掉！注意，在亮度小于7的地方就会刷怪！ |
| 工作台Crafting Table | 木板Wooden Planks                          | [![img](1129312V0-3.png)](1129312V0-3.png) | 工作台可以为我们提供一个3X3的物品合成区域，比直接按E建出现的2X2区域多了很多，，游戏中所有高级的物品都需要在工作台上合成！ |
| 熔炉Furnace         | 圆石Cobblestone                            | [![Craft Furnace](112931JS-4.png)](112931JS-4.png) | 由8个圆石围一圈得来，主要用来烧制烧制物品。各种生肉烧之后可以得到熟肉，各种矿石烧制之后可以得到相应的矿物！和工作台一样是必不可少的工具！ |
| 箱子Chest           | 木板Wooden Planks                          | [![Craft Chest](1129314062-5.png)](1129314062-5.png) | 用于存放物品、迷路时暂存身上物品,两个箱子并排放可以增加存放空间.可以多做一些以免东西溢出！ |
| 梯子Ladders         | 木棍Sticks                                 | [![Craft Ladders](1129312103-6.png)](1129312103-6.png) | 用来爬墙. 注：在挖矿开始就铺上梯子，即使在很深的矿道里面也可以回到地面！在梯子上按住SHIFT就可以在一点不动了！ |
| 栅栏Fence           | 木棍Sticks                                 | [![img](1129312001-7.png)](1129312001-7.png) | 用于围地、圈地 注：不跨越栅栏,别墅内的隔栏(装饰品)、防止跌落。可以制作出养鸡场、养牛场之类的农场，也可以在自己家周围围一圈，防止怪物靠近。栅栏是跳不过去的！ |
| 船Boat             | 木板Wooden Planks                          | [![img](1129314414-8.png)](1129314414-8.png) | 在水中行驶。注：船当然就是在水里面行驶啦，速度很快的哦，需要注意的是船在水中航行不要碰到水中的章鱼，否则就会被破坏掉，另外如果撞到其他物体，也会粉碎，船被破坏之后会掉落木板和木棍！ |
| 木质台阶Wooden Slabs  | 木板Wooden Planks                          | [![img](1129311140-9.gif)](1129311140-9.gif) | 用于建造台阶、屋檐、窗台等.是一个非常不错的装饰用具！也就是我们常说的半砖，有上半砖和下半砖的铺发区别，如果上半砖和下半砖叠加起来就是一个完整的方块模板了 |
| 石质台阶Stone Slabs   | 石头,砖,石砖,砂石,圆石,地狱砖,石英Stone or Brick or Stone Brick or Sandstone or Cobblestone or Nether Brick or Quartz | [![img](11293155K-10.gif)](11293155K-10.gif) | 用于建造台阶、屋檐、窗台等.也可以改造刷怪笼、刷怪塔。注：同木质台阶作用一样，只不过是这个是石头做的哦！详情见上面 |
| 告示牌Sign           | 木板和木棍Wooden Planks & Stick               | [![img](1129313V6-11.png)](1129313V6-11.png) | 门牌、路标、告示牌、贴在楼梯两侧可组成沙发. 注：你可以在木牌上面写字哦！纯净版只能打英文，需要下载中文输入补丁才能打中文！在服务器中用木牌可以设置私有物品，不会被其他玩家破坏 |
| 门Doors            | 木板或者铁锭Wooden Planks or Iron Ingots       | [![img](1129316194-12.gif)](1129316194-12.gif) | 木门能够用手打开或者红石系统打开. 铁门需要激活才能打开.注：在困难模式下，僵尸会将木门破坏，从而破门而入！ |

-----



# 方块合成

　　

| **名称**                     | **材料**                                   | **合成示意图**                                | **描述**                                   |
| -------------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 萤石块Glowstone               | 萤石粉Glowstone Dust                        | [![img](1129314a9-13.png)](1129314a9-13.png) | 能够用于水下照明.注：萤石可以放在喷泉顶上，到了夜晚喷泉就会散发一些光芒！可以替代火把的一种照明工具，常用于室内装潢！ |
| 雪块Snow Block               | 雪球Snowballs                              | [![Craft Snow Block](1129311639-14.png)](1129311639-14.png) | 建筑材料.注：雪块可以用来制作雪傀儡！雪傀儡可以保卫我们的家园，还可以无限刷雪  |
| TNT                        | 火药和沙子Gunpowder & Sand                    | [![Craft TNT](1129315202-15.png)](1129315202-15.png) | 爆炸物. 注：在创造模式下，TNT放置不宜很多，因为如果机器不好，会很卡。TNT也是熊孩子毁服常用的工具。游戏中沙漠神殿会有9个TNT！ |
| 粘土块Clay Block              | 粘土Clay                                   | [![Craft Clay](112931A91-16.png)](112931A91-16.png) | 建筑材料.用于装饰                                |
| 砖块Brick Block              | 红砖Clay Bricks                            | [![Craft Brickblock](112931E46-17.png)](112931E46-17.png) | 坚硬的建筑材料.用于装饰，建筑党必备装饰材料                   |
| 书架Bookshelf                | 木板和书本Wooden Planks & Books               | [![Craft Bookshelf](11293153F-18.png)](11293153F-18.png) | 装饰和附魔. 注：附魔出来的效果是随机的，如果你的RP不好，很可能附魔很多次才能附魔出你想要的东西 |
| 沙石Sandstone Block          | 沙子Sand                                   | [![img](1129312396-19.png)](1129312396-19.png) | 建筑材料.用于装饰，可在熔炉中烧制成玻璃！                    |
| 平滑沙石Smooth Sandstone       | 沙石Sandstone Block                        | [![img](1129311145-20.png)](1129311145-20.png) | 建筑材料.用于装饰用                               |
| 錾制Decorative Sandstone     | 沙质台阶Sandstone Slabs                      | [![img](1129314V4-21.png)](1129314V4-21.png) | 建筑材料.用于装饰用，属于半砖的一种                       |
| 音符盒Note Block              | 木板和红石Wooden Planks & Redstone            | [![img](112931JV-22.png)](112931JV-22.png) | 当点击时发出音符.注：可以发出很多美妙的音乐哦，你一定会喜欢的！放在不同的地面会发出不同的声音 |
| 南瓜灯Jack-O Lantern          | 南瓜和火把Pumpkin & Torch                     | [![Craft Jacko](112931O16-23.png)](112931O16-23.png) | 光源. 注：在晚上看起来会非常的漂亮。也是制作万圣节地图必备的物品之一哦！漂亮的南瓜灯也是室内装修必备物品！ |
| 青金石块Lapis Lazuli Block     | 青金石染料Lapis Lazuli Dye                    | [![Lapiz Lazuli Block](1129315913-24.png)](1129315913-24.png) | 存储青金石染料. 注：可以用染料将羊毛染色                    |
| 钻石块Diamond Block           | 钻石Diamonds                               | [![Craft Diamond Block](1129315I0-25.jpg)](1129315I0-25.jpg) | 存储钻石. 注：主要为了节省空间                         |
| 金块Gold Block               | 金锭Gold Ingots                            | [![Craft Gold Block](1129313F7-26.jpg)](1129313F7-26.jpg) | 存储金锭.注：主要为了节省空间                          |
| 铁块Iron Block               | 铁锭Iron Ingots                            | [![Craft IronBlock](112931L22-27.jpg)](112931L22-27.jpg) | 存储铁锭.注：主要为了节省空间                          |
| 绿宝石块Emerald Block          | 绿宝石Emeralds                              | [![img](112931GD-28.png)](112931GD-28.png) | 存储绿宝石.注：主要为了节省空间，也可做信标底座！                |
| 石砖Stone Brick              | 石头Stone                                  | [![img](1129312O4-29.png)](1129312O4-29.png) | 建筑材料. 注：用于室外的装潢                          |
| 木质楼梯Wooden Stairs          | 木板Wooden Planks                          | [![img](112931C22-30.gif)](112931C22-30.gif) | 做楼梯.注：用于室外和室内的装潢，也可用于矿道                  |
| 石质楼梯Stone Stairs           | 圆石,沙,砖石,石砖,地狱砖,石英Cobblestone or Sandstone or Brick or Stone Brick or Nether Brick or Quartz | [![img](11293164H-31.gif)](11293164H-31.gif) | 做楼梯.注：用于室外和室内的装潢，也可用于矿道                  |
| 圆石墙Cobblestone Wall        | 圆石或者苔石Cobblestone or Moss Stone          | [![img](1129311302-32.gif)](1129311302-32.gif) | 类似于栅栏的作用.注：比栅栏坚固一些，非常好的划分区域工具！           |
| 红石块Block of Redstone       | 红石Redstone                               | [![img](1129313956-33.png)](1129313956-33.png) | 红石电源.注：在制作红石机器的时候经常使用到哦。                 |
| 地狱砖块Nether Brick           | 地狱砖Nether Brick (Item)                   | [![img](1129312b2-34.png)](1129312b2-34.png) | 建筑材料.注：非常不错的建筑材料哦！                       |
| 石英块Block of Quartz         | 下界石英Nether Quartz                        | [![img](1129312259-35.png)](1129312259-35.png) | 建筑材料.注：游戏中公认最漂亮的建筑材料，有白色大理石的感觉！          |
| 錾制石英块Chiseled Quartz Block | 石英台阶Quartz Slabs                         | [![img](1129311432-36.png)](1129311432-36.png) | 建筑材料.注：非常不错的建筑材料哦！                       |
| 竖纹石英块Pillar Quartz Block   | 石英块Block of Quartz                       | [![img](1129313O7-37.png)](1129313O7-37.png) | 建筑材料.注：具有纹理的石英块！                         |

-----

# 工具合成

　　

| **Name**         | **Ingredients**                          | **Image**                                | **Description**                          |
| ---------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 镐Pickaxe         | 木棍加木板或圆石或铁锭或金锭或钻石Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds | [![img](11293122P-38.gif)](11293122P-38.gif) | 挖方块和资源.注：石头以及各种矿物是不能用手直接挖掉的，这时候必须使用镐头，根据材料的不同，挖掘的速度也会不一样！金镐头耐久度非常低！ |
| 斧头Axes           | 木棍加木板或圆石或铁锭或金锭或钻石Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds | [![img](1129315L6-39.gif)](1129315L6-39.gif) | 比用拳头砍树快. 注：根据材料的不同，砍伐木头的速度也会不一样！钻石是最好的，其次是铁和石头，金一般不推荐制作工具 |
| 锹Shovels         | 木棍加木板或圆石或铁锭或金锭或钻石Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds | [![img](1129313D9-40.gif)](1129313D9-40.gif) | 用来挖沙子,沙砾,图,草和雪.注：根据材料的不同，挖掘的速度和耐久也会不一样！  |
| 锄Hoes            | 木棍加木板或圆石或铁锭或金锭或钻石Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds | [![img](1129315Z0-41.gif)](1129315Z0-41.gif) | 用来锄地.注：根据材料的不同，可用耐久也会不同！因为耕地不是太多，所以建议一般用石锄就可以了！ |
| 钓鱼竿Fishing Rod   | 木棍和线Sticks & String                      | [![img](1129315051-42.png)](1129315051-42.png) | 钓鱼.注：用来钓鱼还可以放上胡萝卜骑在猪身上，控制猪的前进方向          |
| 打火石Flint & Steel | 铁锭和燧石Iron Ingot & Flint                  | [![img](1129311505-43.png)](1129311505-43.png) | 生火. 注：可以点燃地狱岩以及树木，部分活塞也可以点燃。也可以点燃游戏中的苦力怕，让他直接自爆！ |
| 指南针Compass       | 铁锭和红石Iron Ingots & Redstone              | [![img](11293132U-44.png)](11293132U-44.png) | 指向出生点. 注：迷失方向的时候，指南针当然是我们最好的伙伴啦！         |
| 钟Clock           | 金锭和红石Gold Ingots & Redstone              | [![img](1129313330-45.png)](1129313330-45.png) | 显示时间和白天黑夜. 注：在地下挖矿不知道地面上是白天还是黑夜吗？这个物品就能帮助到你哦！ |
| 铁桶Bucket         | 铁锭Iron Ingots                            | [![img](112931D15-46.png)](112931D15-46.png) | 用来装水,岩浆,牛奶.注：桶自然是用来装各种液体的了~装的牛奶可以解除各种负面状态！ |
| 剪刀Shears         | 铁锭Iron Ingots                            | [![img](1129316022-47.png)](1129316022-47.png) | 用来剪羊毛和树叶.注：当然在水塘里面遇到荷叶还可以剪一些荷叶哦！         |

------

# 防具合成

| **名称**       | **材料**                                   | **合成示意图**                                | **描述**                                   |
| ------------ | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 头盔Helmet     | 皮革或铁锭或金锭或钻石Leather or Iron Ingots or Gold Ingots or Diamonds | [![img](11293110S-48.gif)](11293110S-48.gif) | 提供1.5护甲值（钻石）.给我们提供盔甲，减少我们受到的伤害。注：金头盔还有照明的作用，当在黑暗的环境下，带上金头盔，周围就会被点亮了哦！钻石防具是最好的防具！ |
| 胸甲Chestplate | 皮革或铁锭或金锭或钻石Leather or Iron Ingots or Gold Ingots or Diamonds | [![img](1129311159-49.gif)](1129311159-49.gif) | 提供4点护甲值（钻石）.给我们提供盔甲，减少我们受到的伤害。钻石防具是最好的防具！ |
| 护腿Leggings   | 皮革或铁锭或金锭或钻石Leather or Iron Ingots or Gold Ingots or Diamonds | [![img](1129315V5-50.gif)](1129315V5-50.gif) | 提供3点护甲值（钻石）.给我们提供盔甲，减少我们受到的伤害。钻石防具是最好的防具！ |
| 靴子Boots      | 皮革或铁锭或金锭或钻石Leather or Iron Ingots or Gold Ingots or Diamonds | [![img](112931HM-51.gif)](112931HM-51.gif) | 提供1.5点护甲值（钻石）.给我们提供盔甲，减少我们受到的伤害。钻石防具是最好的防具！ |
| 剑Sword       | 木棍加上木板或圆石或铁锭或金锭或钻石Sticks & Wooden Planks or Cobblestone or Iron Ingots or Gold Ingots or Diamonds | [![img](1129312531-52.gif)](1129312531-52.gif) | 对怪物造成更多的伤害.这是我们和怪物战斗用的利器！注：小编经验来看铁剑的性价比在前期最高，后期当然是钻石附魔剑了！ |
| 弓Bow         | 线和木棍String & Sticks                      | [![img](1129312Y8-53.png)](1129312Y8-53.png) | 射箭. 注：击杀骷髅之后会掉落，后期可以附魔无限弓！               |
| 箭Arrow       | 燧石和木棍和羽毛Flint & Stick & Feather          | [![img](11293130P-54.png)](11293130P-54.png) | 箭.注： 击杀骷髅之后会掉落，在丛林神庙的发射器里面也可以找到！在打末影龙boss时候需要多准备几组箭 |
-----
# 道具合成

| **名称**                        | **材料**                                   | **合成示意图**                                | **描述**                                   |
| ----------------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 压力版Pressure Plates            | 木板或石头Wooden Planks or Stone              | [![img](1129314338-55.gif)](1129314338-55.gif) | 有生物或玩家站在上面时会发出红石信号. 注：旁边如果有TNT就会发生爆炸！也可以作为一个开门工具 |
| 活板门Trapdoor                   | 木板Wooden Planks                          | [![img](1129312020-56.png)](1129312020-56.png) | 可以通过右键点击和红石打开.一般用于制作天窗                   |
| 栅栏门Fence Gate                 | 木板和木棍Wooden Planks & Sticks              | [![img](11293112S-57.png)](11293112S-57.png) | 可以像门一样被打开. 注：用栅栏圈地的时候记得留一个格子放栅栏门，不然你会出不去的哦！右键点击即可打开！ |
| 按钮Button                      | 石头或者木板Stone or Wooden Plank              | [![img](1129312148-58.gif)](1129312148-58.gif) | 按下的时候发送一个短的脉冲信号。注：用于制作各种红石机器！            |
| 拉杆Lever                       | 木棍和圆石Stick & Cobblestone                 | [![img](1129314E4-59.png)](1129314E4-59.png) | 通过开关来控制红石信号的输出.注：用于制作各种红石机器！和按钮不一样，拉杆给予一个长的连续的信号。 |
| 中继器Redstone Repeater          | 石头,红石火把,红石和石头Stone & Redstone Torch & Redstone | [![img](112931M46-60.gif)](112931M46-60.gif) | 红石电路的二极管或者延时器.注：右击不同的次数，会产生不同的延迟！总共分三档   |
| 红石火把Redstone Torch            | 木棍和红石Stick & Redstone                    | [![img](112931Ba-61.png)](112931Ba-61.png) | 不间断发送红石信号.                               |
| 唱片机Jukebox                    | 木板和钻石Wooden Planks & Diamond             | [![img](1129316105-62.png)](1129316105-62.png) | 将唱片插入可以播放音乐.注：唱片只有小白杀死苦力怕之后才能获得，所以唱片很难得到哦！ |
| 发射器Dispenser                  | 圆石,弓和红石Cobblestone & Bow & Redstone      | [![img](1129313308-63.png)](1129313308-63.png) | 开启的适合发射物品. 注：里面可以放箭以及其他物品，可以用来制作射箭器，也能用来制作树场！可以发射几乎所有的东西 |
| 活塞Piston                      | 木板,原始,铁锭和红石Wooden Planks & Cobblestone & Iron Ingot & Redstone | [![img](1129315214-64.png)](1129315214-64.png) | 推动方块. 注：当被激活就会将活塞推出                      |
| 粘性活塞Sticky Piston             | 活塞和史莱姆球Piston & Slime Ball               | [![img](1129314044-65.png)](1129314044-65.png) | 推拉方块.注：当被激活就会将活塞推出，还可以收回                 |
| 矿车Minecart                    | 铁锭Iron Ingots                            | [![img](1129314157-66.png)](1129314157-66.png) | 在铁轨上行驶.也可以利用上下矿车的原理制作出矿车电梯               |
| 动力矿车Powered Minecart          | 矿车和熔炉Minecart & Furnace                  | [![img](1129316329-67.png)](1129316329-67.png) | 烧碳来产生能量推动其他矿车前进.注：作用类似火车头                |
| 运输矿车Storage Minecart          | 矿车和箱子Minecart & Chest                    | [![img](1129311359-68.png)](1129311359-68.png) | 通过铁路运送材料和物资.                             |
| 铁轨Rail                        | 铁锭和木棍Iron Ingots & Stick                 | [![img](1129311I7-69.png)](1129311I7-69.png) | 铁轨.注：没什么好说的，做铁路的基本材料。                    |
| 充能铁轨Powered Rail              | 金锭,木棍和红石Gold Ingots & Stick & Redstone   | [![img](11293114O-70.jpg)](11293114O-70.jpg) | 被激活的时候加速矿车. 注：当矿车经过时，会产生加速度的效果哦！         |
| 探测铁轨Detector Rail             | 铁锭,石质压力板和红石Iron Ingots & Stone Pressure Plate & Redstone | [![img](1129312214-71.jpg)](1129312214-71.jpg) | 矿车在其上面经过时产生红石信号.可以用于激活一些红石装置             |
| 红石灯Redstone Lamp              | 红石和萤石块Redstone & Glowstone Block         | [![img](1129314N7-72.png)](1129314N7-72.png) | 照明设施,需红石能量激活. 注：非常不错的照明用品                |
| 绊线Tripwire Hook               | 铁锭,木棍和木板Iron Ingot & Stick & Wooden Plank | [![img](1129312647-73.png)](1129312647-73.png) | 通过时产生红石信号. 注：可以用来制作陷阱，丛林神庙里面的机关就是利用它实现的，只要触碰到就会产生信号，从而激活红石装置 |
| 激活铁轨Activator Rail            | 铁锭,木棍和红石火把Iron Ingots & Sticks & Redstone Torch | [![img](11293155X-74.png)](11293155X-74.png) | 常用来激活TNT矿车和漏斗矿车.                         |
| 阳光传感器Daylight Sensor          | 玻璃,下界石英和木板Glass & Nether Quartz & Wooden Slabs | [![img](1129315554-75.png)](1129315554-75.png) | 发出红石信号.在白天有太阳的时候使用                       |
| 投掷器Dropper                    | 圆石和红石Cobblestone & Redstone              | [![img](1129316096-76.png)](1129316096-76.png) | 扔出物品（类似发射器）.                             |
| 漏斗Hopper                      | 铁锭和箱子Iron Ingots & Chest                 | [![img](112931LQ-77.png)](112931LQ-77.png) | 物品通过漏斗在箱子中移进或者移出. 注：有时候被熊孩子用作偷东西。叠放的漏斗可以传送物品可看成是一个类似红石电线的东西！可以看成是一个管道！ |
| 漏斗矿车Minecart with Hopper      | 漏斗和矿车Hopper & Minecart                   | [![img](1129314B5-78.png)](1129314B5-78.png) | 类似漏斗的功能.                                 |
| TNT矿车Minecart with TNT        | TNT和矿车TNT & Minecart                     | [![img](1129311958-79.png)](1129311958-79.png) | 通过激活的铁道发生爆炸或者手动爆炸. 注：可以用来炸山洞和杀怪物         |
| 红石比较器Redstone Comparator      | 红石火把,原始和下界石英Redstone Torches & Stone & Nether Quartz | [![img](1129316032-80.png)](1129316032-80.png) | 仅在红石电路中使用.比较信号大小，接收大的那一方信号！              |
| 陷进箱Trapped Chest              | 箱子和绊线Chest & Tripwire Hook               | [![img](1129313048-81.png)](1129313048-81.png) | 打开箱子的适合发出红石信号.注：不同于普通箱子的是，如果在他前面铺红石，红石不会和他产生连接 |
| 测重压力板Weighted Pressure Plates | 铁锭或者金锭Iron Ingots or Gold Ingots         | [![img](1129315558-82.gif)](1129315558-82.gif) | 类似普通的压力板,但是只能用物品激活. 物品的数量绝对红石信号的强度.      |

-----

# 食物合成

　　

| **名称**                      | **材料**                                   | **合成示意图**                                | **描述**                                   |
| --------------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 碗Bowl                       | 木板Wooden Planks                          | [![img](1129313031-83.png)](1129313031-83.png) | 装蘑菇煲. 注：吃完之后碗可以重复使用！                     |
| 蘑菇煲Mushroom Stew            | 碗,红蘑菇和棕色蘑菇Bowl & Red Mushroom & Brown Mushroom | [![img](1129312346-84.png)](1129312346-84.png) | 恢复4点饥饿值.注：吃完之后碗可以重复使用！非常不错的食物            |
| 面包Bread                     | 小麦Wheat                                  | [![img](1129314107-85.png)](1129314107-85.png) | 恢复2.5点饥饿值. 注：非常不错的食物                     |
| 金苹果Golden Apple             | 苹果和金粒Apple & Gold Nuggets                | [![img](112931FX-86.png)](112931FX-86.png) | 恢复2点饥饿值. 注：可以在不是满饥饿度的时候恢复生命，打末影龙和凋零必备食物！也是游戏中最好食材 |
| 附魔金苹果Enchanted Golden Apple | 苹果和金块Apple & Gold Blocks                 | [![img](112931C95-87.png)](112931C95-87.png) | 恢复2点饥饿值. 同时给予30秒的抗火属性. 注：金苹果的升级版，也是游戏中最好食材 |
| 糖Sugar                      | 甘蔗Sugar Cane                             | [![img](1129313536-88.png)](1129313536-88.png) | 用来制作蛋糕.                                  |
| 蛋糕Cake                      | 牛奶桶,汤,小麦和鸡蛋Milk Buckets & Sugar & Wheat & Egg | [![img](1129312392-89.png)](1129312392-89.png) | 每块恢复1.5饥饿值,一共6块.                         |
| 曲奇Cookies                   | 小麦和可可豆Wheat & Cocoa Beans                | [![img](11293134O-90.png)](11293134O-90.png) | 恢复1点饥饿值.                                 |
| 西瓜Melon Block               | 西瓜片Melon Slice                           | [![img](112931B63-91.png)](112931B63-91.png) | 西瓜.可以食用                                  |
| 西瓜种子Melon Seeds             | 西瓜片Melon Slice                           | [![img](11293130Z-92.png)](11293130Z-92.png) | 能够种植在耕地上.注：成熟以后可以得到西瓜                    |
| 南瓜种子Pumpkin Seeds           | 南瓜Pumpkin                                | [![img](11293140X-93.png)](11293140X-93.png) | 能够种植在耕地上.注：成熟以后可以得到南瓜                    |
| 金胡萝卜Golden Carrot           | 胡萝卜和金粒Carrot & Gold Nuggets              | [![img](1129313M3-94.png)](1129313M3-94.png) | 酿造原料,恢复3点饥饿值.                            |
| 南瓜派Pumpkin Pie              | 南瓜,鸡蛋和糖Pumpkin & Egg & Sugar             | [![img](11293123L-95.png)](11293123L-95.png) | 恢复4点饥饿值.非常不错的食物！                         |

-----

# 其他合成

　　

| **名称**                  | **材料**                                   | **合成示意图**                                | **描述**                                   |
| ----------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 床Bed                    | 木板和羊毛Wooden Planks & Wool                | [![img](1129315047-96.png)](1129315047-96.png) | 在晚上睡觉快速度过夜晚. 注：当然周围不能有僵尸，不然无法进入睡眠！另外在末地可以利用床炸末影龙，是打末影龙的高端技巧！ |
| 画Painting               | 木棍和羊毛Sticks & Wool                       | [![img](1129314B0-97.png)](1129314B0-97.png) | 装饰.得到的画是随机图案！                            |
| 纸Paper                  | 甘蔗Sugar Cane                             | [![img](1129311510-98.png)](1129311510-98.png) | 用来制造地图和书本.                               |
| 书Book                   | 纸Paper                                   | [![img](1129313U4-99.png)](1129313U4-99.png) | 用来制造书架和书与笔.                              |
| 书与笔Book and Quill       | 书,羽毛和墨囊Book & Feather & Ink Sac          | [![img](1129312621-100.png)](1129312621-100.png) | 能够写文章. 注：写出来的文章可以阅读哦！                    |
| 地图Map                   | 纸和指南针Paper & Compass                     | [![img](11293144X-101.png)](11293144X-101.png) | 能够显示附近一块的地图. 注：可以用几张地图合成出一张大地图           |
| 玻璃板Glass Pane           | 玻璃Glass Blocks                           | [![img](1129311016-102.png)](1129311016-102.png) | 类似栅栏的窗格玻璃.注：非常不错的装饰物品                    |
| 铁栏杆Iron Bars            | 铁锭Iron Ingots                            | [![img](1129315345-103.png)](1129315345-103.png) | 类似栅栏但是只有1个方块的高度.常见于末影遗迹和地牢！              |
| 金锭Gold Ingot            | 金粒Gold Nugget                            | [![img](1129312444-104.png)](1129312444-104.png) | 用来制造其他东西. 注：也可以烧制金矿石获得。在地狱打僵尸猪人会爆金粒      |
| 地狱砖栅栏Nether Brick Fence | 地狱砖块Nether Brick                         | [![img](1129312c5-105.png)](1129312c5-105.png) | 类似普通的栅栏只不过原料不同.                          |
| 末影之眼Eye of Ender        | 末影珍珠和烈焰粉Ender Pearl & Blaze Powder       | [![img](112931F95-106.png)](112931F95-106.png) | 定位末地传送门. 注：使用方法：右键斜向上抛出，跟着末影之眼的方向走，当他只望头顶飞的时候，这时候向下挖即可！ |
| 附魔台Enchantment Table    | 书,钻石和黑曜石Book, Diamond & Obsidian.        | [![img](1129311Y5-107.png)](1129311Y5-107.png) | 用来附魔工具.附魔所需等级最高30级，30级满16个书架附魔也被称为顶级附魔！  |
| 火焰弹Fire Charge          | 烈焰粉,碳和火药Blaze Powder & Coal & Gunpowder  | [![img](1129314332-108.png)](1129314332-108.png) | 能够通过发射器发射的火球.                            |
| 末影箱Ender Chest          | 黑曜石和末影之眼Obsidian & Eye of Ender          | [![img](1129311I3-109.png)](1129311I3-109.png) | 用于储存. 所有末影箱共享一个物品栏. 注：可以在其他地方拿到你想用的东西！   |
| 信标Beacon                | 玻璃,黑曜石和下界之心Glass & Obsidian & Nether Star | [![img](1129312J4-110.png)](1129312J4-110.png) | 用于放置在钻石块，金块，绿宝石块或铁块（或这四种方块的任意组合）结构的金字塔顶端，可以向天空直射光束的功能型方块.  注：用于装饰！和定位，可以加上玻璃变成彩色信标！ |
| 铁跕Anvil                 | 铁块和铁锭Iron Block & Iron Ingot             | [![img](1129313Y3-111.png)](1129313Y3-111.png) | 修复物品和合并附魔.注：铁砧使用过后会损坏，有一定的使用次数！          |
| 花盆Flower Pot            | 红砖Bricks                                 | [![img](1129314148-112.png)](1129314148-112.png) | 装饰.可以栽种小花，是室内盆景必备！                       |
| 物品展示框Item Frame         | 木棍和皮革Sticks & Leather                    | [![img](112931K29-113.png)](112931K29-113.png) | 放在墙上展示物品和方块. 注：可以将任意物品放入物品展示框            |
| 萝卜钓竿Carrot on a Stick   | 钓竿和胡萝卜Fishing Rod & Carrot               | [![img](1129313620-114.png)](1129313620-114.png) | 控制猪. 注：骑上猪，猪就会跟你跑啦！                      |
| 烟花火箭Firework Rocket     | 火药,纸和烟火之星Gunpowder & Paper & Firework Star | [![img](1129315352-115.gif)](1129315352-115.gif) | 烟花.                                      |
| 烟火之星Firework Star       | 火药,燃料和附加物品（可选）Gunpowder & Dye & an extra ingredient (optional) | [![img](1129315225-116.gif)](1129315225-116.gif) | 不同的烟火之星决定不同的烟花效果.                        |

-----

# 染料合成

　　

| **名称**               | **材料**                                   | **合成示意图**                                | **描述**                                   |
| -------------------- | ---------------------------------------- | ---------------------------------------- | ---------------------------------------- |
| 骨粉Bone Meal          | 骨头Bone                                   | [![img](11293114O-117.gif)](11293114O-117.gif) | 用来使农作物树木快速长大. 也可以催熟蘑菇！注：可以和发射器一起制作出半自动农场，效率超高 |
| 淡灰色染料Light Gray Dye  | 骨粉和墨囊Bonemeal & Ink Sac                  | [![img](1129314359-118.png)](1129314359-118.png) | 用于制作淡灰色羊毛.                               |
| 灰色染料Gray Dye         | 骨粉和墨囊Bonemeal & Ink Sac                  | [![img](11293145B-119.png)](11293145B-119.png) | 用于制作灰色羊毛.                                |
| 玫瑰红Rose Red          | 玫瑰花Rose                                  | [![img](1129315150-120.png)](1129315150-120.png) | 用于制作红色羊毛.                                |
| 橙色染料Orange Dye       | 玫瑰红和蒲公英黄Rose Red & Dandelion Yellow      | [![img](1129316152-121.png)](1129316152-121.png) | 用于制作橙色羊毛.                                |
| 蒲公英黄Dandelion Yellow | 蒲公英Dandelion                             | [![img](112931N01-122.png)](112931N01-122.png) | 用于制作黄色羊毛.                                |
| 黄绿色染料Lime Dye        | 仙人掌绿和骨粉Cactus Green & Bone Meal          | [![img](1129316452-123.png)](1129316452-123.png) | 用于制作黄绿色羊毛.                               |
| 淡蓝色染料Light Blue Dye  | 青金石染料和骨粉Lapis Lazuli Dye & Bone Meal     | [![img](1129315a4-124.png)](1129315a4-124.png) | 用于制作淡蓝色羊毛.                               |
| 青色染料Cyan Dye         | 青金石染料和仙人掌绿Lapis Lazuli Dye & Cactus Green | [![img](112931FX-125.png)](112931FX-125.png) | 用于制作青色羊毛.                                |
| 紫色染料Purple Dye       | 青金石染料和玫瑰红Lapis Lazuli Dye & Rose Red     | [![img](1129314063-126.png)](1129314063-126.png) | 用于制作紫色羊毛.                                |
| 品红染料Magenta Dye      | 粉红色染料和紫色染料Purple Dye & Pink Dye          | [![img](1129314062-127.png)](1129314062-127.png) | 用于制作品红羊毛.                                |
| 粉红色染料Pink Dye        | 骨粉和玫瑰红Bone Meal & Rose Red               | [![img](1129313649-128.png)](1129313649-128.png) | 用于制作粉红色羊毛.                               |

-----

# 羊毛合成

　　

| **名称**               | **材料**                          | **合成示意图**                                | **描述**                             |
| -------------------- | ------------------------------- | ---------------------------------------- | ---------------------------------- |
| 羊毛Wool               | 线String                         | [![img](112931D08-129.png)](112931D08-129.png) | 建筑材料能被染色.注： 可以用剪刀从羊身上获取，也可以直接杀死羊获取 |
| 浅灰色羊毛Light Gray Wool | 羊毛和浅灰色染料Wool & Light Gray Dye   | [![img](1129315922-130.png)](1129315922-130.png) | 建筑和装饰材料.                           |
| 灰色羊毛Gray Wool        | 羊毛和灰色染料Wool & Gray Dye          | [![img](11293154P-131.png)](11293154P-131.png) | 建筑和装饰材料.                           |
| 黑色羊毛Black Wool       | 羊毛和墨囊Wool & Ink Sac             | [![img](1129313160-132.png)](1129313160-132.png) | 建筑和装饰材料.                           |
| 红色羊毛Red Wool         | 羊毛和玫瑰红Wool & Rose Red           | [![img](1129311C1-133.png)](1129311C1-133.png) | 建筑和装饰材料.                           |
| 橙色羊毛Orange Wool      | 羊毛和橙色染料Wool & Orange Dye        | [![img](112931I00-134.png)](112931I00-134.png) | 建筑和装饰材料. 注：在沙漠神殿可以得到               |
| 黄色羊毛Yellow Wool      | 羊毛和蒲公英黄Wool & Dandelion Yellow  | [![img](112931G61-135.png)](112931G61-135.png) | 建筑和装饰材料.                           |
| 黄绿色羊毛Lime Wool       | 羊毛和黄绿色染料Wool & Lime Dye         | [![img](112931D60-136.png)](112931D60-136.png) | 建筑和装饰材料.                           |
| 绿色羊毛Green Wool       | 羊毛和仙人掌绿Wool & Cactus Green      | [![img](112931M51-137.png)](112931M51-137.png) | 建筑和装饰材料.                           |
| 淡蓝色羊毛Light Blue Wool | 羊毛和淡蓝色染料Wool & Light Blue Dye   | [![img](1129313435-138.png)](1129313435-138.png) | 建筑和装饰材料.                           |
| 青色羊毛Cyan Wool        | 羊毛和青色染料Wool & Cyan Dye          | [![img](1129312064-139.png)](1129312064-139.png) | 建筑和装饰材料.                           |
| 蓝色羊毛Blue Wool        | 羊毛和青金石染料Wool & Lapis Lazuli Dye | [![img](1129312348-140.png)](1129312348-140.png) | 建筑和装饰材料.注： 在沙漠神殿可以得到               |
| 紫色羊毛Purple Wool      | 羊毛和紫色染料Wool & Purple Dye        | [![img](1129314925-141.png)](1129314925-141.png) | 建筑和装饰材料.                           |
| 品红色羊毛Magenta Wool    | 羊毛和品红色染料Wool & Magenta Dye      | [![img](1129313457-142.png)](1129313457-142.png) | 建筑和装饰材料.                           |
| 粉红色羊毛Pink Wool       | 羊毛和粉红色染料Wool & Pink Dye         | [![img](112931N30-143.png)](112931N30-143.png) | 建筑和装饰材料.                           |
| 棕色羊毛Brown Wool       | 羊毛和可可豆Wool & Cocoa Beans        | [![img](1129311953-144.png)](1129311953-144.png) | 建筑和装饰材料.                           |

-----

# 炼金合成

　　

| **名称**                    | **材料**                                   | **合成示意图**                                | **描述**                            |
| ------------------------- | ---------------------------------------- | ---------------------------------------- | --------------------------------- |
| 玻璃瓶Glass Bottle           | 玻璃Glass                                  | [![img](112931O49-145.png)](112931O49-145.png) | 用于酿造.注：打女巫可以掉落玻璃瓶！                |
| 炼药锅Cauldron               | 铁锭Iron Ingot                             | [![img](112931D53-146.png)](112931D53-146.png) | 填满玻璃瓶的水.用于酿造药水！                   |
| 酿造台Brewing Stand          | 烈焰棒和圆石Blaze Rod & Cobblestone            | [![img](1129311R4-147.png)](1129311R4-147.png) | 用于酿造.                             |
| 烈焰粉Blaze Powder           | 烈焰棒Blaze Rod                             | [![img](112931M20-148.png)](112931M20-148.png) | 用于制造末影眼和岩浆膏.注：地狱烈焰人掉落，找寻末影遗迹必备材料！ |
| 研究膏Magma Cream            | 史莱姆和烈焰粉Slimeball & Blaze Powder          | [![img](1129311A6-149.png)](1129311A6-149.png) | 用于药剂制作.                           |
| 发酵蜘蛛眼Fermented Spider Eye | 蜘蛛眼,棕色蘑菇和糖Spider Eye, Brown Mushroom & Sugar | [![img](1129316014-150.png)](1129316014-150.png) | 用于药剂制作.                           |
| 闪烁的西瓜Glistering Melon     | 西瓜片和金粒Melon Slice & Gold Nugget          | [![img](11293114T-151.png)](11293114T-151.png) | 用于药剂制作.                           |

-----

# 1.8新增合成

　　

| **名称** | **材料**         | **合成示意图**                                | **描述**       |
| ------ | -------------- | ---------------------------------------- | ------------ |
| 兔肉煲    | 兔肉、碗、蘑菇、胡萝卜、土豆 | [![img](1-150402112443.jpg)](1-150402112443.jpg) | 用于食用，可恢复饱食度！ |
| 皮革     | 兔子皮            | [![img](1-150402112444.jpg)](1-150402112444.jpg) | 与皮革作用一样      |
| 新栅栏    | 木板、木棍          | [![img](1-150402112445.jpg)](1-150402112445.jpg) | 用于圈地和制作农场、牧场 |
| 海晶灯    | 海晶碎片和海晶沙粒      | [![img](1-150402112445-50.jpg)](1-150402112445-50.jpg) | 用于水下照明       |
| 海晶石    | 海晶碎片           | [![img](1-150402112447.jpg)](1-150402112447.jpg) | 用于装饰         |
| 海晶石砖   | 海晶碎片           | [![img](1-150402112448.jpg)](1-150402112448.jpg) | 用于装饰         |
| 暗海晶石   | 海晶碎片、墨囊        | [![img](1-150402112449.jpg)](1-150402112449.jpg) | 用于装饰         |]]></content>
      <tags>
        <tag>Minecraft</tag>
      </tags>
  </entry>
  <entry>
    <title>NOIP 2015 信息传递</title>
    <url>/2017/01/19/NOIP-2015-Message/</url>
    <content><![CDATA[初探图论，这本来是大一就该学的，没想到拖到这个假期，感觉好懒啊。
尝试做了一下NOIP 2015 day1 的信息传递，整理如下。
<!-- more -->
## 题目
{% asset_img 1.jpg %}
## 源代码
```C++
#include <iostream>
#include <cstdio>
using namespace std;

int main()
{
    int n,i,j=0;
    cin>>n;
    int circle[n+2]={0},status[n+2]={0},via[n+2]={0},flag[n+2]={0};//circle用来存储输入的数据，status用来记录i个人有几个人会告诉他信息，via用来记录某个人是否被告诉过信息
    for( i = 1 ; i <= n ; i++ )
    {
        cin>>circle[i];
        status[circle[i]]++;
    }
    for( i = 1 ; i <=  n; i++ )
    {
        if(status[i]==0)
        {
            flag[j++]=i;
            via[i]=1;
        }
    }
    for( i = 0 ; i < j ; i++ )
    {
        status[circle[flag[i]]]--;
        if(status[circle[flag[i]]]==0)
        {
            flag[j++]=circle[flag[i]];
            via[circle[flag[i]]]=1;
        }
    }
    int ans=n,temp;
    for( i = 1 ; i <= n ; i++ )
    {
        if( via[i]==0 && circle[i]!=0 )
        {
            via[i]=1;
            temp=1;
            j=circle[i];
            while(!via[j])
            {
                via[j]=1;
                j=circle[j];
                temp++;
            }
            if(temp<ans)
                ans=temp;
        }
    }
    printf("%d",ans);
    return 0;
}
```
## 解析
### 题意说明 
代码大量参考了[此文章](http://www.cnblogs.com/zbtrs/p/5762788.html)
文中的没有给出详细解题信息，我看了之后整理了一下。
文中有这样一句话
> 其实这道题题意非常明确，就是让我们寻找一个最小环的长度，怎么求呢？也很简单，先把[入度](http://baike.baidu.com/link?url=r3KqWUoNomP_vuWuIwtmI0cVz1oglvwYD99gDNTo6pDwJTZeey4OHOxFCxDV7ZbRZsIi9OA8tGhT_oB7Uro0HunPx8I7TweWgo-IeUcGoya)为0的点删除，然后把这个点指向的点的入度-1，如果入度为0，也删去，这样就只保留有用的点，那么从任意一个点开始，用vis数组记录是否被访问过，访问到一个新节点就累加计数器，然后就做出来了.bfs和dfs都可以.

把样例输入数据变成图，就成了这样：
{% asset_img 2.jpg %}
从图中可以看到，第一个人讲自己所知道的信息告诉第二个人，第二个人告诉第四个人，第三个人告诉第二个人，第四个人告诉第三个人，第五个人告诉第一个人。这样，仔细一看，2绝对不可能从1处获得自己的生日(游戏结束条件)

很容易看出，2将自己的生日告诉3，3告诉4，4告诉2，2获得了自己的生日，游戏结束，对于3和4来说也同样是这样。

所以，这个题简短来说，就是找到图中的最小环。

### 解题思路
首先，由于5--->1--->2并不构成圈，所以2不可能从1处获得自己的信息，所以干脆将5-->1-->2这条路去掉，这样，只需要统计形成圈的有几个人就行了，若有多个圈，找出最小的圈就好。
{% asset_img 4.jpg %}

### 代码分析
#### 存储数据，计算权值
```C++
    for( i = 1 ; i <= n ; i++ )
    {
        cin>>circle[i];
        status[circle[i]]++;
    }
```
这一段意思很明显，输入数据，然后，记录每个人有几个人告诉他信息
#### 找到权值为0的人
权值为0，也就是示范数据中的5号，没有任何人将自己的信息告诉他
```C++
    for( i = 1 ; i <=  n; i++ )
    {
        if(status[i]==0)
        {
            flag[j++]=i;
            via[i]=1;
        }
    }
```
flag用于标记权值为0的人的编号
#### 去除权值为0的点
```C++
    for( i = 0 ; i < j ; i++ )
    {
        status[circle[flag[i]]]--;//去掉某个权值为0的点之后，讲它所指向的人的权值减1
        if(status[circle[flag[i]]]==0)//若此人的权值减1之后，其权值为0，就将他的编号标记一下，同时更新j(x循环结束条件)的值
        {
            flag[j++]=circle[flag[i]];
            via[circle[flag[i]]]=1;
        }
    }
```
#### 计算圈的成员数目，找到最小的圈
```C++
    int ans=n,temp;
    for( i = 1 ; i <= n ; i++ )
    {
        if( via[i]==0 && circle[i]!=0 )
        {
            via[i]=1;
            temp=1;
            j=circle[i];
            while(!via[j])
            {
                via[j]=1;
                j=circle[j];
                temp++;
            }
            if(temp<ans)
                ans=temp;
        }
    }
```
## 一点点小总结
可能我的解析说得也并不比原文详细多少，`实际上我是跟着代码一步一步调试，才看懂原文的代码的`。

然后，我剔除了原文的队列，使用了一个数组代替，导致我不得不更新数组的有效长度，也就是文中的j值。反而让代码变得更加难以理解。不过，也照顾了一下不知道队列的小伙伴。
然后，原文使用了
```C++
memset(to, 0, sizeof(to));
```
来将数组清零，有时候，会忘记这个函数的用法，所以我用了下面的办法
```C++
int a[100]={0};
```
这样，只要初始化数组的第一个元素为0，数组的其他元素会全都变成0。

{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>C</tag>
        <tag>C++</tag>
        <tag>NOIP</tag>
      </tags>
  </entry>
  <entry>
    <title>NOIP2016</title>
    <url>/2016/11/26/NOIP2016/</url>
    <content><![CDATA[11月19和20号，NOIP2016竞赛复赛结束，抽空做了一下。
## 题意
小南有一套可爱的玩具小人，它们有不同的职业。
有一天，这些小人把小南的眼镜藏了起来。小南发现玩具小人们围成了一个圈，它们有的面朝圈内，有的面朝圈外。如下图：
{% asset_img toy.jpg %}
<!-- more -->
这时singer 告诉小南一个谜题：“眼镜藏在我左数第 3 个玩具小人的右数第 1 个玩
具小人的左数第 2 个玩具小人那里。 ”
小南发现，这个谜题中玩具小人的朝向非常关键，因为朝内和朝外的玩具小人的 左右方向是相反的：面朝圈内的玩具小人，它的左边是顺时针方向，右边是逆时针方向；而面向圈外的玩具小人，它的左边是逆时针方向，右边是顺时针方向。
小南一边艰难地辨认着玩具小人，一边数着：
“singer 朝内，左数第 3 个是archer。” 
“archer 朝外，右数第 1 个是thinker。”
“thinker 朝外，左数第 2 个是writer。”
“所以眼镜藏在writer这里！”
虽然成功找回了眼镜，但小南并没有放心。如果下次有更多的玩具小人藏他的眼镜，或是谜题的长度更长，他可能就无法找到眼镜了。所以小南希望你写程序帮他解决类似的谜题。这样的谜题具体可以描述为：
有 n 个玩具小人围成一圈，己知它们的职业和朝向。 现在第 1 个玩具小人告诉小 南一个包含 m 条指令的谜题，其中第 i 条指令形如“左数/右数第 $s_i$ 个玩具小人”。 你需 要输出依次数完这些指令后，到达的玩具小人的职业。

## 【输入格式说明】
从文件 toy.in 中读入数据。 输入的第一行包含两个正整数 n, m ，表示玩具小人的个数和指令的条数。 接下来 n 行，每行包含一个整数和一个字符串，以逆时针为顺序给出每个玩具小 人的朝向和职业。其中 0 表示朝向圈内， 1 表示朝向圈外。保证不会出现其他的数。字 符串长度不超过 10 且仅由小写字母构成，字符串不为空，并且字符串两两不同。 整数 和字符串之间用一个空格隔开。 接下来 m 行，其中第 i 行包含两个整数 $a\_i$, $s\_i$ ，表示第 i 条指令。若 $a_i$ = 0 ，表示向 左数 $s\_i$ 个人；若 $a\_i$ = 1 ，表示向右数 $s\_i$ 个人。保证 $a\_i$ 不会出现其他的数， 1 ≤ $s\_i$ < n 。

## 【输出格式说明】
输出到文件 toy.out 中。 输出一个字符串，表示从第一个读入的小人开始，依次数 完 m 条指令后到达的小人的职业。

## 样例数据
样例数据1
```bash
    输入数据：
    7 3 
    0 singer 
    0 reader 
    0 mengbier 
    1 thinker 
    1 archer 
    0 writer 
    1 mogician 
    0 3 
    1 1 
    0 2

    输出数据:
    writer
```

样例数据2
```bash
    输入数据：
    10 10 
    1 c 
    0 r 
    0 p 
    1 d 
    1 e 
    1 m 
    1 t 
    1 y 
    1 u 
    0 v 
    1 7 
    1 1 
    1 4 
    0 5 
    0 3 
    0 1 
    1 6 
    1 2 
    0 8 
    0 4

    输出数据：
    y
```


## 代码

```C++
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
struct Toy{
    int pan;
    char job[10];
};
struct Command{
    int pan;
    int cursor;
};
int main()
{
    int n,m,i=0,x=0,ans=0,flag;
    char tmp;
    cin>>n>>m;
    struct Toy toy[n];
    struct Command command[m];
    while(i<n)
    {
        scanf("%d%c%s",&toy[i].pan,&tmp,toy[i].job);
        i++;
    }
    i=0;
    while(i<m)
    {
        cin>>command[i].pan>>command[i].cursor;
        i++;
    }
    i=0;
    while(i<m)
    {
        flag=1;
        if(toy[x].pan==command[i].pan)
        {
            flag=-1;
            ans=ans+command[i].cursor*(-1);
        }
        else
            ans=ans+command[i].cursor;
        x=x+command[i].cursor*flag;
        x=x%n;
        if(x<0)
            x=n+x;
        i++;
    }
    ans=ans%n;
    if(ans<0)
        ans=n+ans;
    cout<<toy[ans].job<<endl;
    return 0;
}
```
为了看起来复杂，我用了乱七八糟的东西(虽然实际上没什么大用)
所以又准备了下面的代码：

```C++
#include <iostream>
#include <cstdio>
using namespace std;
int main ()
{
    int n,m,i=0,ans=0,command_1,command_2,flag,x=0;
    scanf("%d%d",&n,&m);
    int pan[n];
    char job[n][10];
    while(i<n)
    {
        scanf("%d%s",&pan[i],job[i]);
        i++;
    }
    i=0;
    while(i<m)
    {
        scanf("%d%d",&command_1,&command_2);
        flag=1;
        if(pan[x]==command_1)
        {
            flag=-1;
            ans+=command_2*(-1);
        }
        else
            ans+=command_2;
        x=(x+command_2*flag)%n;
        if(x<0)
            x=n+x;
        i++;
    }
    ans=ans%n;
    if(ans<0)
        ans=n+ans;
    printf("%s",job[ans]);
}
```
## 算法
这个嘛，暴力，顺着题目意思走一遍，不过不知道最后官方的测试数据拿来会不会超时。



{% cq %} 生命在于折腾 {% endcq %}]]></content>
      <tags>
        <tag>C++</tag>
        <tag>竞赛</tag>
      </tags>
  </entry>
  <entry>
    <title>NOIP2016更改</title>
    <url>/2016/12/05/NOIP2016%E6%9B%B4%E6%94%B9/</url>
    <content><![CDATA[12.07更新，全部测试数据通过。

在NOI官网拿到了NOIP2016的测试数据，顺便下载下来测试了一下之前写的代码。
<!--more-->
在实际测试中遇到第十二组数据出错的情况，这个是我更改后的代码
```C++
    #include <iostream>
    #include <cstdio>
    using namespace std;
    int main ()
    {
        int n,m,i=0,ans=0,command_1,command_2,flag,x=0;
        scanf("%d%d",&n,&m);
        int pan[n];
        char job[n][15];
        while(i<n)
        {
            scanf("%d%s",&pan[i],job[i]);
            i++;
        }
        i=0;
        while(i<m)
        {
            scanf("%d%d",&command_1,&command_2);
            flag=1;
            if(pan[x]==command_1)
            {
                flag=-1;
                ans+=command_2*(-1);
            }
            else
                ans+=command_2;
            x=(x+command_2*flag)%n;
            if(x<0)
                x=n+x;
            i++;
        }
        ans=ans%n;
        if(ans<0)
            ans=n+ans;
        printf("%s",job[ans]);
    }
```

下面是原本的代码
```C++
    #include <iostream>
    #include <cstdio>
    using namespace std;
    int main ()
    {
        int n,m,i=0,ans=0,command_1,command_2,flag,x=0;
        scanf("%d%d",&n,&m);
        int pan[n];
        char job[n][10];
        while(i<n)
        {
            scanf("%d%s",&pan[i],job[i]);
            i++;
        }
        i=0;
        while(i<m)
        {
            scanf("%d%d",&command_1,&command_2);
            flag=1;
            if(pan[x]==command_1)
            {
                flag=-1;
                ans+=command_2*(-1);
            }
            else
                ans+=command_2;
            x=(x+command_2*flag)%n;
            if(x<0)
                x=n+x;
            i++;
        }
        ans=ans%n;
        if(ans<0)
            ans=n+ans;
        printf("%s",job[ans]);
    }
```
把第九行job[n][10]变成了job[n][15]，解决第十二组数据的出错的问题，第十七组数据目前还未解决(有可能是数据本身是错的)。

第十二组的问题在于原本的字符数据太短，不足以储存“job”。  

这次是为了说明为什么数组短了之后为什么出错。

按照数组的定义，数组实际上是一串连续的变量；

若有这样一个数组char str[4][5];

当使用printf("%s",str[0]);输出二维数组，若数组内容如下

|        |  0   |   1   |   2   |   3   |   4   |
|:------:|:----:|:-----:|:-----:|:-----:|:-----:|
| str[0] |	B   |	D   |	Z   |	N   |	\0  |
| str[1] |	X   |	I   |	D   |	I   |	\0  |
| str[2] |	A   |	B   |	C   |	D   |	\0  |
| str[3] |	H   |	C   |	X   |	.   |	\0  |

输出内容自然是“BDZN”，若是二维数组内容如下

|        |	0   |	1   |	2   |	3   |	4   |
|:------:|:----:|:-----:|:-----:|:-----:|:-----:|
| str[0] |	B   |	D   |	Z   |	N   |	H   |
| str[1] |	X   |	I   |	D   |	I   |	A   |
| str[2] |	A   |	B   |	C   |	D   |	E   |
| str[3] |	H   |	C   |	X   |	.   |	\0  |


输出内容将会是"BDZNHXIDIAABCDEHCX."，这个与格式化输出控制符"%s"有关系，函数判断一个字符数组的结尾是以“\0”来判断的，它会输出到第一个“\0”前面的那个字符，所以二维数组如果某行被占满，使用“%s”来输出这行内容时，会连带下一行也输出。解决办法是将数组长度增加，防止该行被非"\0"的字符占满。C++的cout与这个类似。

磨磨蹭蹭，12.7更新，调整了一下，发现第十七组的数据错误所在，直接贴出代码:

```C++
#include <iostream>
#include <cstdio>
using namespace std;
int main ()
{
    freopen("toy.in","r",stdin);
    freopen("toy.out","w",stdout);
    int n,m,i=0,ans=0,command_1,command_2;
    scanf("%d%d",&n,&m);
    int pan[n];
    char job[n][15];
    while(i<n)
    {
        scanf("%d%s",&pan[i],job[i]);
        i++;
    }
    i=0;
    while(i<m)
    {
        scanf("%d%d",&command_1,&command_2);
        command_2=command_2%n;
        if(pan[ans]==command_1) //顺时针走
        {
            ans-=command_2;
            if(ans<=0)
                ans+=n;
        }
        else  //逆时针针走
        {
            ans+=command_2;
            if(ans>=n)
                ans-=n;
        }
        i++;
    }
    printf("%s",job[ans]);
}
```
问题其实还是比较明显的，原本的代码:
```C++
        while(i<m)
        {
            scanf("%d%d",&command_1,&command_2);
            flag=1;
            if(pan[x]==command_1) //顺时针
            {
                flag=-1;
                ans+=command_2*(-1);
            }
            else //逆时针
                ans+=command_2;
            x=(x+command_2*flag)%n;
            if(x<0)
                x=n+x;
            i++;
        }
```

更改后的代码
```C++
    while(i<m)
    {
        scanf("%d%d",&command_1,&command_2);
        command_2=command_2%n;
        if(pan[ans]==command_1) //顺时针走
        {
            ans-=command_2;
            if(ans<=0)
                ans+=n;
        }
        else  //逆时针针走
        {
            ans+=command_2;
            if(ans>=n)
                ans-=n;
        }
        i++;
    }
```
问题在于```没有考虑越界问题```。



{% cq %} 生命在于折腾 {% endcq %}]]></content>
  </entry>
  <entry>
    <title>POJ 1127</title>
    <url>/2017/12/03/POJ-1127/</url>
    <content><![CDATA[从`《挑战程序设计竞赛》`里面扣了点东西(P250)
<!-- more -->


## Source code
```c++
#include <iostream>
#include <cmath>

using namespace std;

double EPS = 1e-10;

double add(double a, double b)
{
	if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
	return a + b;
}

struct P
{
	double x, y;
	P() {}
	P(double x, double y) : x(x), y(y) {}

	P operator + (P p)
	{
		return P(add(x, p.x), add(y, p.y));
	}

	P operator - (P p)
	{
		return P(add(x, -p.x), add(y, -p.y));
	}

	P operator * (double d)
	{
		return P(x*d, y*d);
	}

	double dot(P p)	//内积
	{
		return add(x*p.x, y*p.y);
	}

	double det(P p)	//外积
	{
		return add(x*p.y, -y*p.x);
	}
};

int n;
const int MAX_N = 1000;
P p[MAX_N], q[MAX_N];
int m;
int a[MAX_N], b[MAX_N];

bool g[MAX_N][MAX_N];

bool on_seg(P p1, P p2, P q)
{
	return (p1 - q).det(p2 - q) == 0 && (p1 - q).dot(p2 - q) <= 0;
}

P intersection(P p1, P p2, P q1, P q2)
{
	return p1 + (p2 - p1) * ((q2 - q1).det(q1 - p1) / (q2 - q1).det(p2 - p1));
}


void solve()
{
	for (int i = 0; i < n; ++i)
	{
		g[i][i] = true;
		for (int j = 0; j < i; ++j)
		{
			if ((p[i] - q[i]).det(p[j] - q[j]) == 0)
			{
				g[i][j] = g[j][i] = on_seg(p[i], q[i], p[j]) 
						 || on_seg(p[i], q[i], q[j]) 
						 || on_seg(p[j], q[j], p[i]) 
						 || on_seg(p[j], q[j], q[i]);
			}
			else
			{
				P r = intersection(p[i], q[i], p[j], q[j]);
				g[i][j] = g[j][i] =on_seg(p[i], q[i], r) && on_seg(p[j], q[j], r);
			}
		}
	}


	for (int k = 0; k < n; ++k)
	{
		for (int i = 0; i < n; ++i)
		{
			for (int j = 0; j < n; ++j)
			{
				g[i][j] |= g[i][k] && g[k][j];
			}
		}
	}

	for (int i = 0; i < m; ++i)
	{
		puts(g[a[i] - 1][b[i] - 1] ? "CONNECTED" : "NOT CONNECTED");
	}
}


int main()
{
	//freopen("data.txt", "r", stdin);
	cin >> n;
	for (int i = 0; i < n; ++i)
	{
		cin >> p[i].x >> p[i].y;
	}
	for (int i = 0; i < n; ++i)
	{
		cin >> q[i].x >> q[i].y;
	}
	cin >> m;
	for (int j = 0; j < m; ++j)
	{
		cin >> a[j] >> b[j];
	}
	solve();
	return 0;
}

```
里面引入的向量概念，使用向量有关的计算来判断两直线是否相交(on_seg)，算是和几何的一个应用吧。
## 测试数据
### 输入
```
4
0 4 0 1 1 2 1 0
4 1 2 3 3 4 2 1
4
1 2 1 4 2 3 2 4
```
### 输出
```
CONNECTED
NOT CONNECTED
CONNECTED
NOT CONNECTED
```]]></content>
  </entry>
  <entry>
    <title>PreArm:ACRO_BAL_ROLL/PITCH</title>
    <url>/2017/05/22/Pixhwak-error/</url>
    <content><![CDATA[{% asset_img 1.jpg A error %}
<!-- more -->
## 症状
开机之后闪黄灯(Pixhawk闪蓝灯或者绿灯表示可以解锁)，用数据线或者数传将电脑和飞控连接之后，在Mission Planner可以看到如下提示信息:
{% asset_img 2.jpg %}
## 解决办法——[Disabling the Pre-arm Safety Check](http://ardupilot.org/copter/docs/prearm_safety_check.html)
在网页里面已经说了解决办法：
{% asset_img 4.jpg %}
可能是Mission Planner版本不一样，我所使用的版本要这样:
{% asset_img 3.jpg %}
将红圈位置的选项勾选成如图样子，点击`写入参数`就好了，可以解锁happy了。
{% cq %} 生命重在折腾 {% endcq %}
]]></content>
      <tags>
        <tag>无人机</tag>
        <tag>tecnology</tag>
      </tags>
  </entry>
  <entry>
    <title>去掉Mx player的广告</title>
    <url>/2018/04/01/Remove-the-ads-of-Mx-player/</url>
    <content><![CDATA[
mx player就安卓端来说还是很棒的应用的，可是pro版本售价要6$，汇率一换过来就贵了。
想了想，手动给它去广告好了，网上的破解版还是不放心。
App展示广告，得有一个地方给它下载广告，阻止App连接相应广告站点就可以了，目标则是找出App用的广告站点。
找到的mx player广告站点用的是谷歌，把以下内容添加到手机hosts文件就可以了

```bash
127.0.0.1 googleads.g.doubleclick.net
```

下面是找到站点的过程。

<!-- more -->

## 配置 Fildder

到[https://www.telerik.com/download/fiddler](https://www.telerik.com/download/fiddler)下载好Fiddler，打开之后，勾选Tools->>Options->>HTTPS允许https和Connetions下面的允许局域网远程连接，如下图

{% asset_img 1.png %}
{% asset_img 2.png %}

然后打开`http://localhost:8888`，下载证书，双击导入。

{% asset_img 3.png %}

## 配置手机

为了能对https进行抓包，还得在手机上安装证书，把证书拷贝或发送到手机内。
对于MIUI来说，在`设置-->更多设置-->系统安全-->从存储设备安装`，然后找到相应的证书就可以安装了，安装后手机会提示网络受到监控。
如果提示需要启用文档，则在`设置-->更多应用`，点一下右上角的三个点，选中显示所有应用，搜索文档，然后点进去就可以启用了。

{%asset_img 4.png %}

这个时候，打开WLAN设置，选中连接的wifi，将代理设置成电脑的IP地址，代理端口为8888

## 开始抓包

这个时候，在手机上打开mx plyer，可以在Fiddler上看到很多信息

{% asset_img 5.jpg %}

仔细观看域名和访问的数据，在mx player上的广告是首屏幕启动广告、视频浏览界面的广告和播放视频时的广告。观察url中某些访问了jpg资源的域名，在电脑上屏蔽掉相应的域名，最后找到了`googleads.g.doubleclick.net`，把这个地址在hosts文件内定向到127.0.0.1，mx player的广告消除。（谷歌老大，对不起你了，我会愧疚的(。・∀・)ノ）

附一份手机上常用的用于屏蔽广告的hosts

```bash

#by wenxibuding QQ410154425
#url=http://www.miui.com/thread-11958646-1-1.html

127.0.0.1       localhost
::1             ip6-localhost

#xiaomi/miui/qqtv/youku/pptv/letv/sohutv/

#mstat/report
127.0.0.1 aeventlog.beacon.qq.com
127.0.0.1 android.rqd.qq.com
127.0.0.1 astrategy.beacon.qq.com
127.0.0.1 eventlog.beacon.qq.com
127.0.0.1 monitor.uu.qq.com
127.0.0.1 omgmta.qq.com
127.0.0.1 omgmta1.qq.com
127.0.0.1 oth.eve.mdt.qq.com
127.0.0.1 oth.str.mdt.qq.com
127.0.0.1 oth.update.mdt.qq.com
127.0.0.1 pingma.qq.com
127.0.0.1 sngmta.qq.com
127.0.0.1 strategy.beacon.qq.com
#qq-1
127.0.0.1 dp3.qq.com
127.0.0.1 imc.l.qq.com
#qq-ad
127.0.0.1 ad.qq.com
127.0.0.1 ad.qun.qq.com
127.0.0.1 adping.qq.com
127.0.0.1 adpm.app.qq.com
127.0.0.1 adrdir.qq.com
127.0.0.1 adsclick.qq.com
127.0.0.1 adsfile.qq.com
127.0.0.1 adsgroup.qq.com
127.0.0.1 adshmct.qq.com
127.0.0.1 adshmmsg.qq.com
127.0.0.1 adslvfile.qq.com
127.0.0.1 adslvseed.qq.com
127.0.0.1 adsqqclick.qq.com
127.0.0.1 adstextview.qq.com
127.0.0.1 adsview.qq.com
127.0.0.1 adsview2.qq.com
127.0.0.1 adv.app.qq.com
127.0.0.1 adver.qq.com
127.0.0.1 analy.qq.com
127.0.0.1 d3g.qq.com
127.0.0.1 j.wit.qq.com
127.0.0.1 jqmt.qq.com
127.0.0.1 jsqmt.qq.com
127.0.0.1 mini2015.qq.com
127.0.0.1 qqshow2-item.qq.com
127.0.0.1 setting.snswin.qq.com
127.0.0.1 tj.video.qq.com
127.0.0.1 updatecenter.qq.com
127.0.0.1 video.ureport.push.qq.com
127.0.0.1 video.wap.mpush.qq.com
127.0.0.1 wap.mpush.qq.com
#qq-t
127.0.0.1 ta.qq.com
127.0.0.1 tajs.qq.com
127.0.0.1 tcss.qq.com
127.0.0.1 p.tencentmind.com
#qq-e
127.0.0.1 e.qq.com
127.0.0.1 cm.e.qq.com
127.0.0.1 sdk.e.qq.com
#qq-gdt
127.0.0.1 c.gdt.qq.com
127.0.0.1 d.gdt.qq.com
127.0.0.1 i.gdt.qq.com
127.0.0.1 mi.gdt.qq.com
127.0.0.1 q.i.gdt.qq.com
127.0.0.1 rm.gdt.qq.com
127.0.0.1 t.gdt.qq.com
127.0.0.1 v.gdt.qq.com
127.0.0.1 win.gdt.qq.com
#qq-gtimg
127.0.0.1 beacon.gtimg.com
127.0.0.1 bla.gtimg.com
127.0.0.1 lb.gtimg.com
127.0.0.1 pgdt.gtimg.cn
127.0.0.1 ra.gtimg.com
127.0.0.1 wa.gtimg.com
127.0.0.1 wb.gtimg.com
#qq-l
127.0.0.1 bs.l.qq.com
127.0.0.1 c2.l.qq.com
127.0.0.1 cb.l.qq.com
127.0.0.1 cm.l.qq.com
127.0.0.1 hm.l.qq.com
127.0.0.1 l.qq.com
127.0.0.1 l2.l.qq.com
127.0.0.1 lb.l.qq.com
127.0.0.1 livec.l.qq.com
127.0.0.1 livem.l.qq.com
127.0.0.1 livep.l.qq.com
127.0.0.1 lives.l.qq.com
127.0.0.1 ls.l.qq.com
127.0.0.1 p2.l.qq.com
127.0.0.1 p3.l.qq.com
127.0.0.1 t.l.qq.com
127.0.0.1 vd.l.qq.com
127.0.0.1 w.l.qq.com
#down-
127.0.0.1 scdown.qq.com
127.0.0.1 download.sj.qq.com
127.0.0.1 c.gj.qq.com
127.0.0.1 t.sj.qq.com
127.0.0.1 ws.sj.qq.com

#http://tv.qq.com/
127.0.0.1 andrqd.play.aiseet.atianqi.com
127.0.0.1 otheve.play.aiseet.atianqi.com
127.0.0.1 othstr.play.aiseet.atianqi.com
127.0.0.1 omgmta.play.aiseet.atianqi.com
127.0.0.1 news-l.play.aiseet.atianqi.com
127.0.0.1 p-l.play.aiseet.atianqi.com
127.0.0.1 t-l.play.aiseet.atianqi.com
#v.qq.com
127.0.0.1 news-l.play.ott.video.qq.com
127.0.0.1 omgmta.play.ott.video.qq.com
127.0.0.1 livep.l.ott.video.qq.com
127.0.0.1 lives.l.ott.video.qq.com
#tv.qq.com
127.0.0.1 aiseet.aa.atianqi.com
127.0.0.1 dp3.play.aiseet.atianqi.com
127.0.0.1 livep.l.aiseet.atianqi.com
127.0.0.1 lives.l.aiseet.atianqi.com
127.0.0.1 vmindhls.tc.qq.com
127.0.0.1 monitor-uu.play.aiseet.atianqi.com
127.0.0.1 sdkconfig.play.aiseet.atianqi.com
127.0.0.1 livew.l.qq.com
127.0.0.1 c.l.qq.com
127.0.0.1 mdevstat.qqlive.qq.com

#http://pd.youku.com/CIBN
127.0.0.1 g.dtv.cn.miaozhen.com
127.0.0.1 xtrader-mipdx.cn.miaozhen.com
127.0.0.1 ssv.admaster.com.cn
127.0.0.1 vyk.admaster.com.cn
127.0.0.1 ipm.atm.cp31.ott.cibntv.net
127.0.0.1 val.atm.cp31.ott.cibntv.net
127.0.0.1 valf.atm.cp31.ott.cibntv.net
#http://m.youku.com/
127.0.0.1 adp.atm.youku.com
127.0.0.1 iyes.youku.com
127.0.0.1 m.atm.youku.com
127.0.0.1 mf.atm.youku.com
127.0.0.1 mobilemsg.youku.com
127.0.0.1 push.m.youku.com
#http://www.youku.com/
127.0.0.1 bsv.atm.youku.com
127.0.0.1 count.atm.youku.com
127.0.0.1 dmapp.youku.com
127.0.0.1 html.atm.youku.com
127.0.0.1 ipm.atm.youku.com
127.0.0.1 myes.youku.com
127.0.0.1 r.l.youku.com
127.0.0.1 service.danmu.youku.com
127.0.0.1 statis.mobile.youku.com
127.0.0.1 v2html.atm.youku.com
127.0.0.1 val.atm.youku.com
127.0.0.1 valb.atm.youku.com
127.0.0.1 valc.atm.youku.com
127.0.0.1 valf.atm.youku.com
127.0.0.1 valp.atm.youku.com
127.0.0.1 valt.atm.youku.com
#youku
127.0.0.1 ad.api.3g.tudou.com
127.0.0.1 ad.api.3g.youku.com
127.0.0.1 ad.api.mobile.youku.com
127.0.0.1 b.smartvideo.youku.com
127.0.0.1 c.yes.youku.com
127.0.0.1 cm.atm.youku.com
127.0.0.1 cm.miaozhen.atm.youku.com
127.0.0.1 guanggaoad.youku.com
127.0.0.1 lstat.youku.com
127.0.0.1 m.yes.youku.com
127.0.0.1 mb.atm.youku.com
127.0.0.1 mi.atm.youku.com
127.0.0.1 miaozhen.atm.youku.com
127.0.0.1 mo.atm.youku.com
127.0.0.1 mp.atm.youku.com
127.0.0.1 notify.youku.com
127.0.0.1 passport-log.youku.com
127.0.0.1 player.lstat.youku.com
127.0.0.1 s.p.youku.com
127.0.0.1 sdk.api.gamex.mobile.youku.com
127.0.0.1 static.atm.youku.com
127.0.0.1 store.tv.api.3g.youku.com
127.0.0.1 store.xl.api.3g.youku.com
127.0.0.1 urchin.lstat.youku.com
127.0.0.1 valo.atm.youku.com
127.0.0.1 wan.youku.com
#youku-area
127.0.0.1 cms.laifeng.com
127.0.0.1 ld.kuaigames.com
127.0.0.1 rd.kuaigames.com
127.0.0.1 g.x.cn.majorserving.com
127.0.0.1 mon.majorserving.com
127.0.0.1 l.ftx.fancyapi.com
127.0.0.1 w.fancyapi.com
127.0.0.1 l.fancyapi.com
127.0.0.1 api.shuzilm.cn
127.0.0.1 daa.shuzilm.cn
127.0.0.1 www.shuzilm.cn
127.0.0.1 cb.lomark.cn
127.0.0.1 reply.lomark.cn
127.0.0.1 rm.lomark.cn
127.0.0.1 p-cn.acxiom-online.com
127.0.0.1 hp.smiler-ad.com
127.0.0.1 static8.pmadx.com
127.0.0.1 www.bfshan.cn

#miui-xiaomi
127.0.0.1 api.ad.xiaomi.com
127.0.0.1 cdn.ad.xiaomi.com
127.0.0.1 e.ad.xiaomi.com
127.0.0.1 log.ad.xiaomi.com
127.0.0.1 new.api.ad.xiaomi.com
127.0.0.1 sdkconfig.ad.xiaomi.com
127.0.0.1 ssp.ad.xiaomi.com
127.0.0.1 test.ad.xiaomi.com
127.0.0.1 test.e.ad.xiaomi.com
127.0.0.1 zeus.ad.xiaomi.com
127.0.0.1 test.zeus.ad.xiaomi.com
#miui-stat
127.0.0.1 a.stat.xiaomi.com
127.0.0.1 abtest.mistat.xiaomi.com
127.0.0.1 data.mistat.xiaomi.com
127.0.0.1 storeconfig.mistat.xiaomi.com
#miui--1
127.0.0.1 shenghuo.xiaomi.com
#miui-download
127.0.0.1 etl.xlmc.sandai.net
#miui-file
127.0.0.1 api.tw06.xlmc.sec.miui.com
127.0.0.1 etl.xlmc.sec.miui.com
127.0.0.1 fb.xk.miui.com
#miui-game
127.0.0.1 notice.game.xiaomi.com
127.0.0.1 ppurifier.game.xiaomi.com
#miui-sec
127.0.0.1 adv.sec.miui.com
127.0.0.1 tracking.miui.com
127.0.0.1 beha.ksmobile.com
127.0.0.1 up.cm.ksmobile.com
#miui-weather
127.0.0.1 wtradv.market.xiaomi.com
#miui-wps
127.0.0.1 cloudservice13.kingsoft-office-service.com
127.0.0.1 counter.kingsoft.com
127.0.0.1 event.ksosoft.com
127.0.0.1 uid.ksosoft.com
127.0.0.1 ups.ksmobile.net
127.0.0.1 ws.ksmobile.net
#mitv
127.0.0.1 bss.pandora.xiaomi.com
127.0.0.1 de.pandora.xiaomi.com
127.0.0.1 dvb.pandora.xiaomi.com
127.0.0.1 jellyfish.pandora.xiaomi.com
127.0.0.1 stat.pandora.xiaomi.com
127.0.0.1 irs01.com

#http://app.pptv.com/pg_get_tv
127.0.0.1 de.as.cp61.ott.cibntv.net
127.0.0.1 clickc.admaster.com.cn
127.0.0.1 vpptv.admaster.com.cn
127.0.0.1 pptv.m.cn.miaozhen.com
127.0.0.1 tpptv.ipdx.cn.miaozhen.com
127.0.0.1 ads.aplus.pptv.com
127.0.0.1 app.aplus.pptv.com
127.0.0.1 as.aplus.pptv.com
127.0.0.1 de.as.pptv.com
127.0.0.1 img1.g.pptv.com
127.0.0.1 img2.g.pptv.com
127.0.0.1 img3.g.pptv.com
127.0.0.1 jp.as.pptv.com
127.0.0.1 static.g.pptv.com
127.0.0.1 tj.g.pptv.com
127.0.0.1 asimgs.pplive.cn
127.0.0.1 ads.data.pplive.com
127.0.0.1 gas.data.pplive.com
127.0.0.1 plt.data.pplive.com
127.0.0.1 web.data.pplive.com
127.0.0.1 apm.suning.cn
127.0.0.1 click.suning.cn
127.0.0.1 dfp.suning.com
127.0.0.1 ssac.suning.com

#letv
127.0.0.1 api.game.letvstore.com
127.0.0.1 dev.dc.letv.com
127.0.0.1 msg.m.letv.com
127.0.0.1 n.mark.letv.com
127.0.0.1 static.app.m.letv.com
127.0.0.1 test.ark.letv.com
#sohu-video
127.0.0.1 agn.aty.sohu.com
127.0.0.1 f.aty.sohu.com
127.0.0.1 m.aty.sohu.com
127.0.0.1 mmg.aty.sohu.com
127.0.0.1 p.aty.sohu.com
127.0.0.1 pg.aty.sohu.com
127.0.0.1 pm.aty.sohu.com
127.0.0.1 v.aty.sohu.com
127.0.0.1 vg.aty.sohu.com
127.0.0.1 vm.aty.sohu.com
127.0.0.1 api.danmu.tv.sohu.com
127.0.0.1 download.wan.sohu.com
127.0.0.1 da.mmarket.com
127.0.0.1 sohu.irs01.com

#google ads
127.0.0.1 googleads.g.doubleclick.net
127.0.0.1 ads.nexage.com

```]]></content>
  </entry>
  <entry>
    <title>Configure Git to use a proxy</title>
    <url>/2017/10/13/Set-proxy-for-git/</url>
    <content><![CDATA[
From: [https://gist.github.com/evantoli/f8c23a37eb3558ab8765](https://gist.github.com/evantoli/f8c23a37eb3558ab8765)

## In Brief

You may need to configure a proxy server if you're having trouble cloning 
or fetching from a remote repository or getting an error 
like `unable to access '...' Couldn't resolve host '...'`.
<!-- more -->
Consider something like:

```
git config --global http.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
```

Or for a specific domain, something like:

```
git config --global http.https://domain.com.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
git config --global http.https://domain.com.sslVerify false
```

Setting `http.<url>.sslVerify` to `false` may help you quickly get going if your workplace 
employs man-in-the-middle HTTPS proxying. Longer term, you could get the 
root CA that they are applying to the certificate chain
and specify it with either `http.sslCAInfo` or `http.sslCAPath`.

See also the [git-config](https://git-scm.com/docs/git-config) documentation, especially the following 
sections if you're having HTTPS/SSL issues
 
 * `http.sslVerify`
 * `http.sslCAInfo`
 * `http.sslCAPath`
 * `http.sslCert`
 * `http.sslKey`
 * `http.sslCertPasswordProtected`

## In Detail

### Configure the proxy 

You can configure these globally in your user `~/.gitconfig` file using the `--global` switch, or local to a repository in its `.git/config` file.

#### Setting a global proxy

Configure a global proxy if all access to all repos require this proxy

```
git config --global http.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
```
#### Setting a global socks5 proxy
```
git config --global http.proxy 'socks5://server:port'
```
#### URL specific proxy

If you wish to specify that a proxy should be used for just 
some URLs that specify the URL as a git config subsection
using `http.<url>.key` notation:

```
git config --global http.https://domain.com.proxy http://proxyUsername:proxyPassword@proxy.server.com:port
```

Which will result in the following in the `~/.gitconfig` file:

```
[http]
[http "https://domain.com"]
	proxy = http://proxyUsername:proxyPassword@proxy.server.com:port
```

#### Handle subsequent SSL protocol errors

If you're still having trouble cloning or fetching and are now getting 
an `unable to access 'https://...': Unknown SSL protocol error in connection to ...:443` then
you may decide to switch off SSL verification for the single operation 
by using the `-c http.sslVerify=false` option

```
git -c http.sslVerify=false clone https://domain.com/path/to/git
```

Once cloned, you may decide set this for just this cloned 
repository's `.git/config` by doing. Notice the absence of the `--global`

```
git config http.sslVerify false
```

If you choose to make it global then limit it to a URL using 
the `http.<url>.sslVerify` notation: 

```
git config --global http.https://domain.com.sslVerify false
```

Which will result in the following in the `~/.gitconfig` file:

```
[http]
[http "https://domain.com"]
	proxy = http://proxyUsername:proxyPassword@proxy.server.com:port
	sslVerify = false
```

### Show current configuration

To show the current configuration of all `http` sections

```
git config --global --get-regexp http.*
```

If you are in a locally cloned repository folder then you drop 
the `--global` and see all current config:

```
git config --get-regexp http.*
```

### Unset a proxy or SSL verification

Use the `--unset` flag to remove configuration being specific about the
property -- for example whether it was `http.proxy` or `http.<url>.proxy`. 
Consider using any of the following:

```
git config --global --unset http.proxy
git config --global --unset http.https://domain.com.proxy

git config --global --unset http.sslVerify
git config --global --unset http.https://domain.com.sslVerify

```
]]></content>
  </entry>
  <entry>
    <title>作品推荐《我的三体》</title>
    <url>/2018/02/27/The-three-body-problem/</url>
    <content><![CDATA[
{% asset_img index.png %}

<!-- more -->

BiliBili的up主[神游八方](https://space.bilibili.com/614801#/)的作品，还原度很高，第一季是很典型的摆拍型，MC气息很浓啊，第二季质量就非常高了，超赞！

附带三个童话故事

>### 王国的新画师
很久很久以前，有一个王国叫无故事王国，它一直没有故事。其实对于一个王国而言，没有故事是最好的，没有故事的国王中的人民是最幸福的，因为故事就意味着曲折和灾难。
无故事王国有一个贤明的国王、一个善良的王后和一群正直能干的大臣，还有勤劳朴实的人民。王国的生活像镜而一样平静，昨天像今天，今天像明天，去年像今年，今年像明年，一直没有故事。
直到王子和公主长大。
国王有两个儿子，分别是深水王子和冰沙王子，还有一个女儿：露珠公主。
深水王子小时候去了饕餮海中的墓岛上，再也没有回来，原因后面再讲。
冰沙王子在父王和母后身边长大，但也让他们深深忧虑。这孩子很聪明，但从小就显示出暴虐的品性。他让仆役们从王宫外搜集许多小动物，他就和这些小动物玩帝国游戏，他自封为皇帝，小动物们为臣民，臣民们都是奴隶，稍有不从就砍头，往往游戏结束时小动物们都被杀了，冰沙就站在一地鲜血中狂笑不已……王子长大后性格收敛了一些，变得沉默寡言，目光阴沉。国王知道这只是狼藏起了撩牙，冰沙心中有一窝冬眠的毒蛇，在等待着苏醒的机会。国王终于决定取消冰沙王子的王位继承权，由露珠公主继承王位，无故事王国在未来将有一位女王。
假如父王和母后传给后代的美德是有一个定量的，那冰沙王子缺少的部分一定都给了露珠公主。公主聪明善良，且无与伦比地美丽，她在白天出来太阳会收敛光辉，她在夜晚散步月亮会睁大眼睛，她一说话百鸟会停止鸣唱，她踏过的荒地会长出绚丽的花朵。露珠成为女王必定为万民拥戴，大臣们也会全力辅佐，就连冰沙王子对此也没有说什么，只是目光更阴沉了。
于是，无故事王国有了故事。
国王是在他的六十寿辰这一天正式宣布这一决定的。在这个庆典之夜，夜空被焰火装点成流光溢彩的花园，灿烂的灯火几乎把王宫照成透明的水晶宫殿，在欢歌笑语中，美酒如河水般流淌……
每一个人都沉浸在幸福快乐中，连冰沙王子那颗冰冷的心似乎也被融化，他一改往日的阴沉，恭顺地向父王祝寿，愿他的生命之光像太阳一样永远照耀王国。他还赞颂父王的决定，说露珠公主确实比自己更适合成为君主。他祝福妹妹，希望她多多向父王学习治国本领，以备将来担当重任。他的真诚和善意让所有的人为之动容。
“吾儿，看到你这样我真是高兴。”国王抚着王子的头说，“真想永远留住这美好的时光。”
于是有大臣建议，应该制作一幅巨型油画，把庆典的场景画下来，挂在宫殿中以资纪念。
国王摇摇头，“我的画师老了，世界在他昏花的老眼中已蒙上了雾霭，他颇抖的老手已绘不出我们幸福的笑容。”
“我正要说这个，”冰沙王子对国王深深鞠躬，“我的父王，我正要献给您一位新画师。”
王子说完对后面示意了一下，新画师立刻走了进来。这是一个大男孩，看上去也就十四五岁的样子，裹着一件修士的灰色斗篷，在这金碧辉煌的宫殿和珠光宝气的宾客中像一只惊恐的小老鼠。他走路时，已经很瘦小的身子紧缩成一根树枝一般，仿佛时时躲避着身边看不见的荆刺。
国王看着眼前的画师显得有些失望，“他这么年轻，能掌握那高深的技巧吗?”
王子再次鞠躬，“我的父王，他叫针眼，从赫尔辛根默斯肯来，是空灵大画师最好的学生。他自五岁起就跟大画师学画，现已学了十年，深得空灵画师的真传。他对世界的色彩和形状，就像我们对烧红的烙铁一样敏感，这种感觉通过他如神的画笔凝固在画布上，除了空灵画师，他举世无双。”王子转向针眼画师，“作为画师，你可以直视国王，不算无礼。”
针眼画师抬头看了一眼国王，立刻又低下了头。
国王有些吃惊，“孩子，你的目光很锐利，像烈焰旁出鞘的牙剑，与你的年龄极不相称。”
针眼画师第一次说话了：“至高无上的国王，请宽怒一个卑微画师的冒犯。这是一个画师的眼睛，他要先在心里绘画，我已经把您，还有您的威严和贤明一起画在心里，我会画到画里的。”
“你也可以看王后。”王子说。
针眼画师看了一眼王后，低下头说：“最最尊敬的王后，请宽怒一个卑微画师的冒犯，我已经把您，还有您的高贵和典维一起画在心里，我会画到画里的。”
“再看看公主，未来的女王，你也要画她。”
针眼画师看露珠公主的时间更短，如闪电般看了一眼后就低头说：”最最受人景仰的公主，请宽怒一个卑微画师的冒犯。您的美丽像正午的阳光刺伤了我，我第一次感到了自己画笔的无力，但我已经把您，还有您无与伦比的美丽一起画在心里，我会画到画里的。”
然后王子又让针眼画师看看大臣们。他挨着看了，目光在每个人的身上只停留一瞬间，最后低下头说：“最最尊敬的大人们，请宽怒一个卑微画师的冒犯。我已经把你们，还有你们的才能和智慧一起画在心里，我会画到画里的。”
盛宴继续进行，冰沙王子把针眼画师拉到宫殿的一个角落，低声问道：“都记住了吗?”
针眼画师头低低的，脸全部隐藏在斗篷帽的阴影里，使那件斗篷看上去仿佛是空的，里面只有黑影没有躯体。“记住了，我的王。”
“全记住了?”
“我的王，全记住了，即使给他们每人的每根头发和汗毛各单画一幅特写，我都能画得真真切切分毫不差。”
宴会到后半夜才结束，王宫中的灯火渐渐熄灭。这正是黎明前最黑暗的时候，月亮已经西沉，乌云自西向东，像帷幕一样遮住了夜空，大地像是浸在墨汁中一般。一阵阴冷的寒风吹来，鸟儿在巢中颤抖，花儿惊惧地合上了花瓣。
有两匹快马像幽灵一般出了王宫，向西方奔驰而去，骑在马上的分别是冰沙王子和针眼画师。他们来到了距王宫十多里的一处幽深的地堡中。这里处于夜之海的最深处，潮湿阴森，像一个沉睡着的冷血巨怪的腹腔。两人的影子在火炬的光芒中摇曳，他们的身躯只是那长长影子末端的两个黑点。针眼画师拆开一幅画，那画有一人高，他把包画的帆布掀开后让王子看。这是一位老人的肖像，老人的白发和白须像银色的火焰包围着头脸，他的眼神很像针眼画师，但锐利中多了一份深沉，这画显示出画师高超的技艺，纤毫毕现，栩栩如生。
“我的王，这是我的老师，空灵大画师。”
王子打量着画，点点头说：“你先把他画出来是明智的。”
“是的，我的王，以免他先把我画出来。”针眼画师说着，小心翼冀地把画挂到潮湿的墙上，“好了，我现在可以为您做新画了。”
针眼画师从地堡的一个暗角抱出一卷雪白的东西，“我的王，这是赫尔辛根默斯肯的雪浪树的树干，这树百年长成后，它的树干就是一大卷纸，上好的画纸啊!我的画只有画在雪浪纸上才有魔力。”他把树干纸卷放到一张石桌上，拉出一段纸来，压在一大块黑曜石石板下，然后用一把锋利的小匕首沿石板把压着的纸切下，掀开石板后，那张纸已经平平展展地铺在石桌上，它一片雪白，仿佛自己会发光似的。然后画师从帆布包中拿出各种绘画工具，“我的王，看这些画笔，是用赫尔辛根默斯肯的狼的耳毛做的。这几罐颜料也都来自赫尔辛根默斯肯，这罐红的，是那里巨编蝠的血;黑的，是那里深海乌贼的墨汁;蓝的和黄的，都是从那里的古老陨石中提取的......这些都要用一种叫月毯的大鸟的眼泪来调和。”
“赶快画画吧。”王子不耐烦地说。
“好的，我的王，先画谁呢?”
“国王。”
针眼画师拿起画笔开始作画。他画得很随意，用不同的色彩这里点一点，那里画一道，画纸上的色彩渐渐多了起来，但看不出任何形状，就像把画纸暴露在一场彩色的雨中，五彩的雨滴不断滴到纸面上。画面渐渐被色彩填满，一片纷繁迷乱的色彩，像被马群践踏的花园。画笔继续在这色彩的迷宫中游走，仿佛不是画师在运笔，而是画笔牵着他的手游移。王子在旁边疑惑地看着，他想提问，但画面上色彩的涌现和聚集有一种作用，让他着迷。突然，几乎是在一瞬间，就像波光粼粼的水面被冻祥，所有的色块都有了联系，所有的色彩都有了意义，形状出现了，并很快变得精细清晰。
王子现在看到，针眼画师画的确实是国王，画面上的国王就是他在宴会上看到的装束，头戴金色的王冠，身穿华丽的礼服，但表情大不相同，国王的目光中没有了威严和睿智，而是透出一种极其复杂的东西，如梦初醒、迷惑、震惊、悲哀……藏在这一切后面的是来不及浮现的巨大恐俱，就像看到自己最亲密的人突然拔剑刺来的那一瞬间。
“我的王，画完了，我把国王画到画里了。”针眼画师说。
“你把他画到画里了，很好。”王子看着国王的画像满意地点点头，他的眸子中映着火把的火光，像灵魂在深井中燃烧。
在十几里外的王宫中，在国王的寝室里，国王消失了。在那张床腿是四个天神雕像的大床上，被褥还有他身体的余温，床单上还有他压出的凹印，但他的躯体消失得无影无踪。
王子把已完成的画从石桌上拿起扔到地上，“我会把这幅画装裱起来，挂在这里的墙上，没事的时候经常来看一看。下面画王后吧。”
针眼画师又用黑曜石石板压平了一张雪浪纸，开始画王后的肖像。这次王子没有站在旁边看，而是来回踱步，空旷的地堡中回荡着单调的脚步声。这次画师作画的速度更快，只用了画上幅画一半的时间就完成了。
“我的王，画完了，我把王后画到画里了。”
“你把她画到画里了，很好。”
在王宫中，在王后的寝室里，王后消失了。在那张床腿是四个天使雕像的大床上，被褥还有她身体的余温，床单上还有她压出的凹印，但她的躯体消失得无影无踪。
在宫殿外面的深院中，一只狼犬觉察到了什么，狂吠了几声，但它的叫声立刻被无边的黑暗吞没，它自己也在前所未有的恐惧中沉默了，缩到角落不住地颤抖着，与黑暗融为一体。
“该画公主了吧？”针眼画师问。
“不，等画完了大臣们再画她，大臣们比她危险。当然，只画那些忠于国王的大臣，你应该记得他们的样子吧?”
“当然.我的王，全记住了，即使给他们每人的每根头发和汗毛各画一幅特写……”
“好了，快画吧，天亮前画完。”
“没问题，我的王，天亮前我会把忠于国王的大臣，还有公主，都画到画里。”
针眼画师一次压平了好几张雪浪纸，开始疯狂作画。他每完成一幅画，画中的人就从睡榻上消失。随着黑夜的流逝，冰沙王子要消灭的人一个接一个变成了挂在地堡墙上的画像。
露珠公主在睡梦中被一阵敲门声惊醒，那声音又急又响，从来没有人敢这样敲她的门。她从床上起身，来到门前时看到宽姨已经把门打开了。宽姨是露珠的奶妈，一直照顾她长大，公主与她建立的亲情甚至超过了生母王后。宽姨看到门外站着王宫的卫队长，他的盔甲还带着外面暗夜的寒气。
“你太无礼了!竟敢吵醒公主？！她这几天一直失眠睡不好觉!”
卫队长没有理会宽姨的责骂，只是向公主匆匆敬礼，“公主，有人要见你!”然后闪到一边，露出他身后的人，那是一位老者，白发和白须像银色的火焰包围着头脸，他的目光锐利而深沉，他就是针眼画师向王子展示的第一幅画中的人。他的脸上和斗篷上满是尘土，靴覆满泥巴，显然是长途跋涉而来。他背着一个硕大的帆布袋，但奇怪的是打着一把伞，更奇怪的是他打伞的方式：一直不停地转动着伞。细看一下伞的结构，就知道他这样做的原因：那把伞的伞面和伞柄都足乌黑色，每根伞骨的末端都固定着一只小圆球，是某种半透明的石头做成的，有一定重量。可以看到伞里面几根伞撑都折断了，无法把全伞撑起来，只有让伞不断转动，把伞骨末端的小石球甩起来，才能把伞撑开。
“你怎么随便让外人进来，还是这么个怪老头?!”宽姨指着老者责问道。
“哨兵当然没让他进王宫，但他说......”卫队长忧虑地看了一眼公主，“他说国王已经没了。”
“你在说什么?!你疯了吗?”宽姨大喊，公主仍没有做声，只是双手抓紧了胸前的睡袍。
“但国王确实不见了，王后也不见了，我派人看过，他们的寝室都是空的。”
公主短促地惊叫了一声，一手扶住宽姨好让自己站稳。
老者开口了：“尊敬的公主，请允许我把事情说清楚。”
“让老人家进来，你守在门口。”公主对卫队长说。
老者转着伞，对公主鞠躬，似乎对于公主能够这么快镇静下来心存敬意。
“你转那把伞干什么?你是马戏团的小丑吗?”宽姨说。
“我必须一直打着这把伞，否则也会像，国王和王后一样消失。”
“那就打着伞进来吧。”公主说，宽姨把门大开，以便让老者举伞通过。
老者进入房间后，把肩上的帆布袋放到地毯上，疲惫地长出一口气，但仍转着黑伞，伞沿的小石球在烛光中闪亮，在周围的墙壁上投映出一圈旋转的星光。
“我是赫尔辛根默斯肯的空灵画师，王宫里新来的那个针眼画师是我的学生。”老者说。
“我见过他。”公主点点头说。
“那他见过你吗?他看过你吗?”空灵画师紧张地问。
“是的，他当然看过我。”
“糟透了，我的公主，那糟透了!”空灵画师长叹一声，“他是个魔鬼，掌握着魔鬼的画技，他能把人画到画里。”
“真是废话!”宽姨说，“不能把人画到画里那叫画师吗?”
空灵画师摇摇头，“不是那个意思，他把人画到画里后，人在外面就没了，人变成了死的画。”
“那还不快派人找到他杀了他?!”
卫队长从门外探进头来说：“我派全部的卫队去找了，找不到。我原想去找军机大臣，他可以出动王宫外的禁卫军搜查，可这个老人家说军机大臣此时大概也没了。”
空灵画师又摇摇头，“禁卫军没有用，冰沙王子和针眼可能根本就不在王宫里，针眼在世界上任何地方作画，都能杀掉王宫中的人。”
“你说冰沙王子?”宽姨问。
“是的，王子要以针眼画师作武器，除掉国王和忠诚于他的人，夺取王位。”
空灵画师看到，公主、宽姨和门口的卫队长对他的话似乎都没感到意外。
“还是先考虑眼前的生死大事吧!针眼随时可能把公主画出来，他可能已经在画了。”
宽姨大惊失色，她一把抱住公主，似乎这样就能保护她。
空灵画师接着说：“只有我能除掉针眼，现在他已经把我画出来了，但这把伞能保护我不消失，我只要把他画出来，他就没了。”
“那你就在这里画吧!”宽姨说，“让我替你打伞!”
空灵画师又摇摇头，“不行，我的画只有画在雪浪纸上才有魔力，我带来的纸还没有压平，不能作画。”
宽姨立刻打开画师的帆布包，从中取出一截雪浪树的树干，树干已经刮了外皮，露出白花花的纸卷来。宽姨和公主从树干纸卷上抽出一段纸，纸面现出一片雪白，房间里霎时亮了许多。她们试图在地板上把纸压平•但不管怎样努力，只要一松手，那段纸就弹回原状又卷了回去。
画师说：“不行的，只有赫尔辛根默斯肯的黑曜石石板才能压平雪浪纸，那种黑曜石石板很稀有，我只有一块，让针眼偷走了!”
“这纸用别的东西真的弄不平吗?”
“弄不平的，只有用赫尔辛根默斯肯的黑曜石石板才能压平，我本来是希望能够从针眼那里夺回它的。”
“赫尔辛根默斯肯的黑曜石?”宽姨一拍脑袋，“我有一个熨斗，只在熨公主最好的晚礼服时才用，就是赫尔辛根默斯肯出产的，是黑曜石!”
“也许能用。”空灵画师点点头。
宽姨转身跑出去，很快拿着一个乌黑银亮的熨斗进来了。她和公主再次把雪浪纸从纸卷中拉出一段，用熨斗在地板上压住纸的一角，压了几秒钟后松开，那一角的纸果然压平了。
“你来给我打伞，我来压!”空灵画师对宽姨说。在把伞递给她的时候，他嘱咐道，“这伞要一直转着打开，一合上我就没了!”看到宽姨把伞继续旋转着打开举在他的头顶，他才放心地蹲下用熨斗压纸，只能一小块一小块地挨着压。
“不能给这伞做个伞撑吗?”公主看着旋转的伞问。
“我的公主，以前是有伞撑的。”空灵画师边埋头用熨斗压纸边说，“这把黑伞的来历很不寻常。从前，赫尔辛根默斯肯的其他画师也有这种画技，除了人，他们也能把动物和植物画到画里。但有一天，飞来了一条渊龙，那龙通体鸟黑，既能弃深海潜游，又能在高空飞翔，先后有三个大画师画下了它，但它仍然在画外潜游和飞翔。后来，画师们筹钱雇了一名魔法武士，武士用火剑杀死了渊龙，那场搏杀使赫尔辛根默斯肯的大海都沸腾了。渊龙的尸体大部分都被烧焦了，我就从灰堆中收集了少量残骸，制成了这把伞。伞面是用渊龙的翼膜做的，伞骨、伞柄和伞撑都是用它的乌骨做成，伞沿的那些宝石，其实是从渊龙已经烧焦的肾中取出的结石。这把伞能够保护打着它的人不被画到画里。后来伞骨断了，我曾用几根竹棍做了伞撑，但发现伞的魔力竟消失了，拆去新伞撑后，魔力又恢复了。后来试验用手在里面撑开伞也不行，伞中是不能加入任何异物的，可我现在已经没有渊龙的骨头了，只能这样打开伞……”
这时房间一角的钟敲响了，空灵画师抬头看看，已是凌晨，天快亮了。他再看看雪浪纸，压平的一段从纸卷中伸了出来，平铺在地板上不再卷回去，但只有一掌宽的一条，远不够绘一幅画的。他扔下熨斗，长叹一声。
“来不及了，我画出画来还需要不少时间，来不及了，针眼随时会画完公主，你们——”空灵画师指指宽姨和卫队长，“针眼见过你们吗?”
“他肯定没见过我。”宽姨说。
“他进王宫时我远远地看到过他，但我想他应该没看见我。”卫队长说。
“很好，”空灵画师站起身来，“你们俩护送公主去饕餮海，去墓岛找深水王子!”
“可……即使到了饕餮海，我们也上不了墓岛的，你知道海里有……”
“到了再想办法吧，只有这一条生路了。天一亮，所有忠于国王的大臣都会被画到画里，禁卫军将被冰沙控制，他将篡夺王位，只有深水王子能制止他。”
“深水王子回到王宫，不是也会被针眼画到画里吗?”会主问。
“放心，不会的，针眼画不出深水王子。深水是王国中针眼唯一画不出来的人，很幸运，我只教过针眼西洋画派，没有向他传授东方画派。”
公主和其他两人都不太明白空灵画师的话，但老画师没有进一步解释，只是继续说：“你们一定要让深水回到王宫，杀掉针眼，并找到公主的画像，烧掉那幅画，公主就安全了。”
“如果也能找到父王和母后的画像……”公主拉住空灵画师急切地说。
老画师缓缓地摇摇头，“我的公主，来不及了，他们已经没有了，他们现在就是那两幅画像了，如果找到不要毁掉，留作祭奠吧。”
露珠公主被巨大的悲痛压倒，她跌坐在地上掩面痛哭起来。
“我的公主，现在不是哀伤的时候，要想为国王和王后复仇，就赶快上路吧!”老画师说着，转向宽姨和卫队长，“你们要注意，在找到并毁掉公主的画像之前，伞要一直给她打着，一刻都不能离开.也不能合上。”他把伞从宽姨手中拿过来，继续转动着，“伞不能转得太慢，那样它就会合上，也不能太快，因为这伞年代已久，转得太快会散架的。黑伞有灵气，如果转得慢了，它会发出像鸟叫的声音，你们听，就足这样子——”老画师把伞转慢了些.伞面在边缘那些石球的重量下慢慢下垂，这时能听到它发出像夜莺一样的叫声，伞转得越慢声音越大。老画师重新加快了转伞的速度，鸟鸣声变小消失了。“如果转得太快，它会发出铃声，就像这样——”老画师继续加快转伞的速度，能听到一阵由小到大的铃声，像风铃，但更急促，“好了，现在快把伞给公主打上。”他说着，把伞又递给宽姨。
“老人家，我们俩一起打伞走吧。”露珠公主抬起泪眼说。
“不行，黑伞只能保护一个人，如果两个被针眼画出的人一起打伞，那他们都会死，而且死得更惨：每个人的一半被画入画中，一半留在外面……快给公主打伞，拖延一刻危险就大一分，针眼随时可能把她画出来!”
宽姨看看公主，又看看空灵画师，犹豫着。
老画师说：“是我把这画技传授给那个孽种，我该当此罪。你还等什么？想看着公主在你面前消失?!”
最后一句话令宽姨颤抖了一下，她立刻把伞移到公主上方。
老画师抚着白须从容地笑起来，“这就对了，老夫绘画一生，变成一幅画也算死得其所。我相信那个孽种的技艺，那会是一幅精致好画的……”
空灵大画师的身体渐渐变得透明，然后像雾气一般消失了。
露珠公主看着老画师消失的那片空间，喃喃地说：“好吧，我们走，去饕餮海。”
宽姨对门口的卫队长说：“你快过来给公主打伞，我去收拾一下。”
卫队长接过伞后说：“要快些，现在外面都是冰沙王子的人了，天亮后我们可能出不了王宫。”
“可我总得给公主带些东西，她从来没有出过远门，我要带她的斗篷和靴子，她的好多衣服，她喝的水，至少……至少要带上那块赫尔辛根默斯肯出产的好香皂，公主只有用那香皂洗澡才能睡着觉……”宽姨唠唠叨叨地走出房间。
半个小时后，在初露的曙光中，一辆轻便马车从一个侧门驶出王宫，卫队长赶着车，车上坐着露珠公主和给她打伞的宽姨，他们都换上了平民装束。马车很快消失在远方的雾霭中。这时，在那个阴森的地堡中，针眼画师刚刚完成露珠公主的画像，他对冰沙王子说，这是他画过的最美的一幅画。

>### 饕餮海
出了王宫后，卫队长驾车一路狂奔。三个人都很紧张，他们感觉在未尽的夜色里，影影绰绰掠过的树木和田野中充满危险。天亮了一些后，车驶上了一个小山冈，卫队长勒住马，他们向来路眺望。王国的大地在他们下面铺展开未，他们来的路像一条把世界分成两部分的长线，线的尽头是王宫，已远在天边，像被遗失在远方的一小堆积木玩具。没有看到追兵，显然冰沙王子认为公主已经不存在了，被画到了画中。
以后他们可以从容地赶路了。在天亮的过程中，周围的世界就像是一幅正在绘制中的画，开始只有朦胧的轮廓和模糊的色彩，后来，景物的形状和线条渐渐清晰精细，色彩也丰富明快起来。在太阳升起前的一刹那，这幅画已经完成。常年深居王宫的公主从来没有见过这祥大块大块的鲜艳色彩：森林草地和田野的大片绿色、花丛的大片鲜红和嫩黄、湖泊倒映着的清晨天空的银色、早出的羊群的雪白……太阳升起时，仿佛绘制这幅画的画师抓起一把金粉豪爽地撒向整个画面。
“外面真好，我们好像已经在画中呢。”公主赞叹道。
“是啊，公主，可在这幅画里你活着，在那幅画中你就死了。”打伞的宽姨说。
这话又让公主想起了已经离去的父王和母后，但她抑制住了眼泪，她知道自己现在再也不是一个小女孩.她应该担当起国王的重任了。
他们谈起了深水王子。
“他为什么被流放到墓岛上?”公主问。
“人们都说他是怪物。”卫队长说。
“深水王子不是怪物!”宽姨反驳道。
“人们说他是巨人。”
“深水不是巨人!他小的时候我还抱过他，他不是巨人。”
“等我们到海边你就会看到的，他肯定是巨人，好多人都看到了。”
“就算深水是巨人，他也是王子，为什么要流放到岛上?”公主问。
“他没有被流放，他小时候坐船去墓岛上钓鱼，正好那时饕餮鱼在海上出现，他就回不来了，只好在岛上长大。”
……
太阳升起后，路上的行人和马车渐渐多起来。由于公主以前几乎没有出过王宫，所以人们都不认识她，但尽管她现在还戴着面纱，只露出两只眼睛，看到她的人仍惊叹她的美丽。人们也称赞驾车的小伙子的孔武英俊，笑话那个老妈妈为她的美丽女儿打着的那把奇怪的伞和她那奇怪的打伞方式。好在没有人质疑伞的用途，今天阳光灿烂，人们都以为这是遮阳伞。
不知不觉到了中午，卫队长用弓箭射了两只兔子做午餐。三人坐在路边树丛间的空地上吃饭。露珠公主摸着身旁柔软的草地，嗅着青草和鲜花的清香，看着阳光透过树叶投在草地上的光斑，听着林中的鸟鸣和远处牧童的笛声，对这个新世界充满了好奇和惊喜。
宽姨却长叹一声，“唉，公主啊，离开王宫这么远，真让你受罪了。”
“我觉得外面比王宫好。”公主说。
“我的公主哇，外面哪有王宫里好?你真是不知道，外面有很多难处呢，现在是春天，冬天外面会冷，夏天会热，外面会刮风下雨，外面什么样的人都有，外面……”
“可我以前对外面什么都不知道。我在王宫里学音乐，学绘画，学诗歌和算术，还学着两种谁都不说的语言，可没人告诉我外面是什么样子，我这样怎么能统治王国呢?”
“公主，大臣们会帮你的。”
“能帮我的大臣都被画到画里了……我还是觉得外面好。”
从王宫到海边有一个白天的路程，但公主一行不敢走大道，遇到城镇就绕开，所以直到半夜才到达。
露珠公主从来没有见过这样广阔的星空，也第一次领略了夜的黑暗和寂静，车上的火把只能照亮周围一小块地方。再往远处，世界就是一大块模糊的黑天鹅绒。马蹄声很响，像要把星星震下来。公主突然拉住卫队长，让他把马车停下。
“听，这是什么声音？像巨人的呼吸。”
“公主，这是海的声音。”
又前行了一段，公主看到两旁有许多在夜色中隐约可见的物体，像一根根大香蕉。
“那些是什么?”她问。
卫队长又停下车，取下车上的火把走到最近的一个旁边，“公主，你应该认识这个的。”
“船?”
“是的，公主，是船。”
“可船为什么在陆地上？”
“因为海里有饕餮鱼。”
在火把的光芒中可以看到，这艘船已经很旧了，船身被沙子埋住一半，露在外面的部分像巨兽的白骨。
“啊，看那里!”公主又指着前方惊叫，“好像有一条白色的大蛇!”
“不要怕公主，那不是蛇，是海浪，我们到海边了。”
公主和为她打伞的宽姨一起下车，她看到了大海。她以前只在画中见过海，那画的是蓝天下的蓝色海洋，与这夜空下的黑色海洋完全不同这泛着星光的博大与神秘，仿佛是另一个液态的星空。公主不由自主地向海走去，却被卫队长和宽姨拦住了。
“公主，离海太近危险。”卫队长说。
“我看前面水不深，能淹死我吗?”公主指指沙滩上的白浪说。
“海里有饕餮鱼，它们会把你撕碎吃掉的！”宽姨说。
卫队长拾起一块破船板，走上前去把船板扔到海中。船板在海面晃荡了儿下，很快附近一个黑影浮出水面向它扑去，由于大部分在水下，看不出那东西的大小、它身上的鳞片在火把的光中闪亮。紧接着又有三四个黑影飞快地游向船板，在水中争抢成一团，伴随着哗哗的水声，可以听到利齿发出的咔嚓咔嚓声，仅一转眼的工夫，黑影和船板都不见了。
“看到了吗?它们能在很短的时间里把一艘大船咬成碎片。”卫队长说。
“墓岛呢?”宽姨问。
“在那个方向，”卫队长指指黑暗的水天相连处，“夜里看不见，天一亮就能看见。”
他们在沙滩上露营。宽姨把伞交给卫队长打，从马车上拿下一个小木盆。
“公主呀，今天是不能洗澡了，可你至少该洗洗脸的。”
卫队长把伞交还给宽姨，说他去找水，就拿着盆消失在夜色中。
“他是个好小伙子。”宽姨打着哈欠说。
卫队长很快回来，不知从什么地方打来了一盆清水。宽姨为公主洗脸，她拿一块香皂在水中只蘸了一下，一声轻微的吱啦声后，盆面立刻堆满了雪白的泡沫，鼓出圆圆的一团，还不断地从盆沿溢出来。
卫队长盯着泡沫看了一会儿，对宽姨说：“让我看看那块香皂。”
宽姨从包裹中小心翼冀地拿出一块雪白的香皂，递给卫队长，“拿好了，它比羽毛还轻，一点儿分量都没有，一松手就飘走了。”
卫队长接过香皂，真的感觉不到一点儿分量，像拿着一团白色的影子。“这还真是赫尔辛根默斯肯香皂，现在还有这东西?”
“我只有两块了，整个王宫，我想整个王国，也只剩这最后两块了，是我早些年特意给公主留的。唉，赫尔辛根默斯肯的东西都是好东西，可惜现在越来越少了。”宽姨说着，把香皂拿回来小心地放回包裹中。
看着那团白泡沫，公主在出行后第一次回忆起王宫中的生活。每天晚上，在她那精美华丽的浴宫中，大浴池上就浮着一大团这样的泡沫，灯光从不同方向照来，大团泡沫忽而雪白，像从白天的天空中抓来的一朵云;忽而变幻出宽彩，像宝石堆成的，泡到那团泡沫中，公主会感到身体变得面条般柔软，感到自己在融化，成了泡沫的一部分，那舒服的感觉让她再也不想动弹，只能由女仆把她抱出去擦干，再抱她去床上睡觉。那种美妙的感觉可以一直持续到第二天早晨。
现在，公主用赫尔辛根默斯肯香皂洗过的脸很轻松很柔软，身上却僵硬而疲劳。随便吃了些东西后，她便在沙滩上躺下，开始时铺了一张毯子，后来发现直接躺到沙上更舒服。柔软的沙层带着白天阳光的温度，她感觉像被一只温暖的大手捧在手心，涛声像催眠曲，她很快睡着了。
不知过了多长时间，露珠公主被一阵铃声从无梦的酣睡中惊醒，那声音是从她上方旋转的黑伞中发出的。宽姨睡在她旁边，打伞的是卫队长，火把已经熄灭，夜色像天鹅绒般笼罩着一切，卫队长是星空背景前的一个剪影，只有他的盔甲映出星光，还可以看到海风吹起他的头发。伞在他的手中稳撼地旋转着，像一个小小的穹顶遮住了一半夜空。她看不见他的眼睛，但能感觉到他的目光，他与无数眨眼的星星一起看着自己。
“对不起公主，我刚才转得太快了。”卫队长低声说。
“现在什么时间了?”
“后半夜了。”
“我们离海好像远了。”
“公主，这是退潮海水后退了，明天早上还会涨起来。”
“你们轮流为我打伞吗?”
“是的，公主，宽姨打了一白天，我夜里多打一会儿。”
“你也驾了一天车，让我自己打一会儿伞，你也睡吧。”
说出这话后，露珠公主自己也有些吃惊，在她的记忆里，这是自己第一次为别人着想。
“那不行，公主，你的手那么细嫩，会磨起泡的，还是让我为你打伞吧。”
“你叫什么名字?”
同行已经一天，她现在才问他的名字。放在以前她会觉得很正常，甚至永远不问都很正常，但现在她为此有些内疚。
“我叫长帆。”
“帆？”公主转头看看，他们现在是在沙滩上的一艘大船旁边，这里可以避海风。与其他那些搁浅在海滩上的船不同，这艘船的桅杆还在，像一把指向星空的长剑。“帆是不是挂在这根长杆上的大布?”
“是的，公主，那叫桅杆，帆挂在上面，风吹帆推动船。”
“帆在海面上雪白雪白的，很好看。”
“那是在画中吧，真正的帆没有那么白的。”
“你好像是赫尔辛根默斯肯人?”
“是的，我父亲是赫尔辛根默斯肯的建筑师，在我很小的时候，他带着全家来到了这里。”
“你想回家吗，我是说赫尔辛根默斯肯?”
“不太想，我小时候就离开那里，记得不太清了，再说想也没用，现在永远也不可能离开无故事王国了。”
远处，海浪哗哗地喧响，仿佛在一遍遍地重复着长帆的话：永远不可能离开，永远不可能离开……
“给我讲讲外面世界的故事吧，我什么都不知道。”公主说。
“你不需要知道，你是无故事王国的公主，王国对你来说当然是无故事的。其实，公主，外面的人们也不给孩子们讲故事，但我的父母不一样，他们是赫尔辛根默斯肯人，他们还是给我讲了一些故事的。”
“其实父王说过，无故事王国从前也是有故事的。”
“是的……公主，你知道王国的周围都是海吧，王宫在王国的中心，朝任何一个方向走，最后都会走到海边，无故事王国就是一个大岛。”
“这我知道。”
“以前，王国周围的海不叫饕餮海，那时海中没有饕餮鱼，船可以自由地在海上航行，无故事王国和赫尔辛根默斯肯之间每天都有无数的船只来往。那时无故事王国其实是有故事王国，那时的生活与现在很不一样。”
“嗯?”
“那时生活中充满了故事，充满了变化和惊奇。那时，王国中有好几座繁华的城市，王宫的周围不是森林和田野，而是繁华的首都。城市中到处可见来自赫尔辛根默斯肯的奇珍异宝和奇异器具。无故事王国，哦不，故事王国的物产也源源不断地从海上运往赫尔辛根默斯肯。那时，人们的生活变幻莫测，像骑着快马在山间飞奔，时而冲上峰顶，时而跌入深谷，充满了机遇和危险。穷人可能一夜暴富，富豪也可能转眼赤贫，早晨醒来，谁也不知道今天要发生什么事，要遇到什么样的人。到处是刺激和惊喜。
“但有一天，一艘来自赫尔辛根默斯肯的商船带来一种珍奇的小鱼，这种鱼只有手指长，黑色的，貌不惊人，装在坚硬的铸铁水捅中。卖鱼的商人在王国的集市上表演，他将一把剑伸进铁捅中的水里，只听到一阵刺耳的‘咔嚓咔嚓’声，剑再抽出来时已被咬成了锯齿状。这种鱼叫饕餮鱼，是一种内陆的淡水鱼，生长在赫尔辛根默斯肯岩洞深处黑暗的水潭中。饕餮鱼在王国的市场上销路很好，因为它们的牙齿虽小，但像金钢石一样坚硬，可做钻头;它们的鳍创民锋利，能做箭头或刁、刀。于是，越来越多的饕餮鱼从赫尔辛根默斯肯运到了王国。在一次台风中，一艘运鱼船在王国沿海失事沉没，船上运载的二十多桶饕餮鱼全部倾倒进了海中。
“人们发现，饕餮鱼在海中能够飞快地生长，长得比在陆地上要大得多，能达到一人多长，同时繁殖极快，数量飞速增加。饕餮鱼开始捕食所有漂浮在海面上的东西，没来得及拖上岸的船，不管多大，都被啃成碎片，当一艘大船被饕餮鱼群围住时，它的船底很快被啃出大洞，但连沉没都未不及，就在海面上被咬成碎片，像融化掉一般。鱼群在故市王国的沿海环游，很快在王国周国的海中形成一道环形的屏障。
“故事三国就这样被周围海域中的饕餮鱼包图，沿海已成为死亡之地，不再有任何船只和风帆，王国被封闭起未，与赫尔辛根默斯肯和整个外部份界斯绝了一切联系，过起了自给自足的田园生活。繁华的城市消失了，变成小镇和牧场，生活日浙宁静平淡，不再有变化，不再有刺激和惊喜，昨天像今天，今天像明天。人们渐渐适应了这样的日子，不再向往其他的生活。对过去的记，就像来自赫尔辛根默斯肯的奇异物品那样日渐稀少，人们甚至有意地忘记过去，也忘记现在。总的来说就是再不要故事了，建立了一个无故事的生活，故事王国也就变成了无故事王国。”
露珠公主听得入了迷，长帆停了好久，她才问：“现在海洋上到处都有饕餮鱼吗?”
“不，只是无故事王国的沿海有，眼神好的人有时能看到海鸟浮在离岸很远的海面上捕食，那里没有饕餮鱼。海洋很大，无边无际。”
“就是说，世界除了无故事王国和赫尔辛根默斯肯，还有别的地方?”
“公主，你认为世界只有这两个地方吗?”
“小时候我的宫廷老师就是这么说的。”
“这话连他自己都不信。世界很大，海洋无边无际，有无数的岛屿，有的比王国小，有的比王国大；还有大陆。”
“什么是大陆?”
“像海洋一样广阔的陆地，骑着快马走几个月都走不到边。”
“世界那么大?”公主轻轻感叹，又突然问道，“你能看到我吗?”
“公主，我现在只能看到你的眼睛，那里面有星星。”
“那你就能看到我的向往，真想乘着帆船在海上航行，到很远很远的地方去。”
“不可能了，公主，我们永远不可能离开无故事王国，永远不能……你要是怕黑，我可以点上火把。”
“好的。”
火把点燃后，露珠公主看着卫队长，却发现他的目光投向了别的地万。
“你在看什么?”公主轻声问。
“那里，公主，你看那个。”
长帆指的是公主身边一小丛长在沙里的小草，草叶上有几颗小水珠，在火光中晶莹地闪亮。
“那叫露珠。”长帆说。
“哦，那是我吗？像我吗？”
“像你，公主，都像水晶一样美丽。”
“天亮后它们在太阳光下会更美的。”
卫队长发出一声叹息，很深沉，根本没有声音，但公主感觉到了。
“怎么了，长帆?”
“露珠在阳光下会很快蒸发消失。”
公主轻轻点点头，火光中她的目光黯然了，“那更像我了，这把伞一合上，我就会消失，我就是阳光下的雾珠。”
“我不会让你消失的，公主。”
“你知道，我也知道，我们到不了墓岛，也不可能把深水王子带回来。”
“要是那样，公主，我就永远为你打伞。”

>### 深水王子
露珠公主再次醒来时，天已经亮了，大海由黑色变成了蓝色，但公主仍然感觉与画中见过的完全不同。曾被夜色掩盖的广阔现在一览无遗，在清晨的天光下，海面上一片空旷。但在公主的想象中，这空旷并不是饕餮鱼所致，海是为了她空着，就像王宫中公主的宫殿空着等她入住一样。夜里对长帆说过的那种愿望现在更加强烈，她想象着广阔的海面上出现一叶属于她的白帆，顺风漂去，消失在远方。
现在为她打伞的是宽姨，卫队长在前面的海滩上向她们打招呼，让她们过去。等她们走去后，他朝海的方向一指说：“看，那就是墓岛。”
公主首先看到的不是墓岛，而是站在小岛上的那个巨人，那显然就是深水王子。他顶天立地站在岛上，像海上的一座孤峰。他的皮肤是日晒的棕色，强健的肌肉像孤峰上的岩石，他的头发在海风飘荡，像峰顶的树丛。他长得很像冰沙，但比冰沙强壮，也没有后者的阴郁，他的目光和表情都给人一种大海般豁达的感觉。这时太阳还没有升起，但巨人的头顶已经沐浴在阳光中。金灿灿的，像着火似的。他用巨手搭凉棚眺望着远有那么一瞬间，公主感觉她和巨人的目光相遇了，就跳着大喊：
“深水哥哥!我是露珠!我是你的妹妹露珠!我们在这里!”
巨人没有反应，他的目光从这里扫过，移向别处，然后放下手，若有所思地摇摇头，转向另一个方向。
“他为什么注意不到我们?”公主焦急地问。
“谁会注意到远处的三只小蚂蚁呢?”卫队长说，然后转向宽姨，“我说深水王子是巨人吧，你现在看到了。”
“可我抱着他的时候他确实是一个小小的婴儿呀!怎么会长得这么高?不过巨人好啊，谁也挡不住他，他可以惩罚那些恶人，为公主找回画像了!”
“那首先得让他知道这里发生了什么事。”卫队长摇摇头说。
“我要过去，我们必须过去!到墓岛上去!”公主抓住长帆说。
“过不去的，公主，这么多年了，没有人能够登上墓岛，那岛上也没有人能回来。”
“真想不出办法吗?”公主急得流出了眼泪，“我们到这里来就是为了找他，你一定知道该怎么办的！”
看着公主泪眼婆娑，长帆很不安，“我真的没办法，到这里来是对的，你必须远离王宫，否则就是等死，但我当初就知道不可能去墓岛。也许……可以用信鸽给他送一封信。”
“那太好了，我们这就去找信鸽!”
“但那又有什么用呢?即使他收到了信，也过不来，他虽然是巨人，到海中也会被饕餮鱼撕碎的……先吃了早饭再想办法吧，我去准备。”
“哎呀，我的盆!”宽姨叫起来，由于涨潮，海水涌上了沙滩，把昨天晚上公主洗脸用的木盆卷到了海中。盆已经向海里漂出了一段距离，盆倒扣着，里面的洗脸水在海面泛起一片雪白的肥皂泡沫。可以看到有几条饕餮鱼正在向盆游去，它们黑色的鳍像利刀一样划开水面，眼看木盆就要在它们的利齿下粉身碎骨了。
但一件不可思议的事发生了：饕餮鱼没有去啃啮木盆，而是都游进了那片泡沫中，一接触泡沫，它们立刻停止游动，全都浮上了水面，凶悍之气荡然无存，全变成了一副懒洋洋的样子，有的慢慢摆动鱼尾，不是为了游动而是表示惬意；有的则露出白色的肚皮仰躺在水面上。
三个人吃惊地看了一会儿，公主说：“我知道它们的感觉，它们在泡沫中很舒服，浑身软软的像没有骨头一样，不愿意动。”
宽姨说：“赫尔辛根默斯肯的香皂确实是好东西，可惜只有两块了。”
卫队长说：“即使在赫尔辛根默斯肯，这种香皂也很珍贵。你们知道它是怎样造出来的吗？赫尔辛根默斯肯有一片神奇的树林，那些树叫魔泡树，都长了上千年，很高大。平时魔泡树没有什么特别之处，但如果刮起大风，魔泡树就会被吹出肥皂泡来，风越大吹出的泡越多，赫尔辛根默斯肯香皂就是用那种泡泡做成的。收集那些肥皂泡十分困难，那些泡泡在大风中飘得极快，加上它们是全透明的，你站在那里很难看清它们，只有跑得和它们一样快，才能看到它们。骑最快的马才能追上风中的泡泡，这样的快马在整个赫尔辛根默斯肯不超过十匹。当魔泡树吹出泡泡时，制肥皂的人就骑着快马顺风狂奔，在马上用一种薄纱网兜收集泡泡。那些泡泡有大有小，但即使最大的泡泡，被收集到网兜里破裂后，也只剩下肉眼都看不见的那么一小点儿。要收集几十万甚至上百万的泡泡才能造出一块香皂，但香皂中的每一个魔树泡如果再溶于水，就又能生发出上百万个泡泡，这就是香皂泡沫这么多的原因。魔泡树的泡泡都没有重量，所以真正纯的赫尔辛根默斯肯香皂也完全没重量，是世界上最轻的东西，但很贵重。宽姨的那些香皂可能是国王加冕时赫尔辛根默斯肯使团带来的赠礼，后来……”
长帆突然停止了讲述，若有所思地盯着海面。那里，在雪白的赫尔辛根默斯肯香皂的泡沫中，那几条饕餮鱼仍然懒散地躺浮着，在它们前，是完好无损的木盆。
“好像有一个办法到墓岛上去!”长帆指着海面上的木盆说，“你们想想，那要是一只小船呢?”
“想也别想!”宽姨大叫起来，“公主怎么能冒这个险?!”
“公主当然不能去，我去。”卫队长从海面收回目光，从他坚定的眼神中，公主看出他已经下定了决心。
“你一个人去，怎样让深水王子相信你?”公主说，她兴奋得脸颊通红，“我去，我必须去!”
“可就算你到了岛上，又怎么证明自己的身份?”卫队长打量着一身平民装束的公主说。
宽姨没有说话，她知道有办法。
“我们可以滴血认亲。”公主说。
“即使这样公主也不能去!这太吓人了!”宽姨说，但她的口气已经不是那么决绝。
“我待在这里就安全吗?”公主指着宽姨手中旋转着的黑伞说，“我们太引人注意了，冰沙很快会知道我们的行踪，在这里，我就是暂时逃过了那张画，也逃不脱禁卫军的追杀，到墓岛上反而安全些。”
于是他们决定冒险了。
卫队长从沙滩上找了一只最小的船，用马拖到水边，就在浪花刚舔到船首的地方。找不到帆，但从其他的船上找到两支旧桨。他让公主和打伞的宽姨上了船，将宽姨拿出来的赫尔辛根默斯肯香皂穿到剑上递给公主，告诉她船一下海就把香皂浸到水里。然后他向海里推船，一直推到水齐腰深的地方才跳上船全力划桨，小船载着三人向墓岛方向驶去。
饕餮鱼的黑鳍在周围的海面上出现，向小船围拢过来。公主坐在船尾，把穿在剑上的赫尔辛根默斯肯香皂浸到海水中，船尾立刻涌现一大团泡沫，在早晨的阳光中发出耀眼的白光，泡沫团迅速膨胀至一人多高，并在船尾保持这个高度，在后面则随着船的前行扩散开来，在海面形成雪白的一片。饕餮鱼纷纷游进泡沫浮在其中，像躺在雪白的毛绒毯上一样享受着无与伦比的舒适惬意。公主第一次这么近看饕餮鱼，它们除了肚皮通体乌黑，像钢铁做成的机器，但一进入泡沫就变得懒散温顺。小船在平静的海面上前进，后面拖曳了一条长长的泡沫尾迹，像一道落在海上的白云带。无数的饕餮鱼从两侧游过来进入泡沫中，像在进行一场云河中的朝圣。偶尔也有几条从前方游来的饕餮鱼啃几下船底，还把卫队长手中的木桨咬下了一小块，但它们很快就被后面的泡沫所吸引，没有造成大的破坏。看着船后海面上雪白的泡沫云河，以及陶醉其中的饕餮鱼，公主不由得想起了牧师讲过的天堂。
海岸渐渐远离，小船向墓岛靠近。
宽姨突然喊道：“你们看，深水王子好像矮了一些!”
公主转头望去，宽姨说得没错，岛上的王子仍是个巨人，但比在岸上看明显矮了一些，此时他仍背对着他们，眺望着别的方向。
公主收回目光，看着划船的长帆，他此时显得更加强健有力，强劲的肌肉块块鼓起，两支长桨在他手中像一对飞翔的翅膀，推动着小船平稳前行。这人似乎天生是一个水手，在海上显然比在陆地更加自如。
“王子看到我们了!”宽姨又喊道。墓岛上，深水王子转向了这边，一手指着小船的方向，眼中透出惊奇的目光，嘴还在动，像喊着什么。他肯定会感到惊奇，除了这只出现在死亡之海上的小船外，船后的泡沫扩散开来，向后宽度逐渐增大，从他那个高度看过去，海面上仿佛出现了一颗拖着雪白彗尾的彗星。
他们很快知道王子并非对他们喊话，他的脚下出现了几个正常身高的人。从这个距离上，他们看上去很小，脸也看不清，但肯定都在朝这个方向看，有的还在挥手。
墓岛原是个荒岛，没有原住民。二十年前，深水去岛上钓鱼时，陪同他的有一名监护官、一名王宫老师、几名护卫和仆从。他们刚上岛，成群的饕餮鱼就游到这片沿海，封死了他们回王国的航路。
他们发现，现在王子看上去又矮了一些，似乎小船距海岛越近，王子就越矮。
小船渐渐接近岛岸，可以看清那些正常身高的人了，他们共八个人，大部分都穿着和王子一样的用帆布做的粗糙衣服，其中有两个老者穿着王宫的制服，但都已经很破旧了，这些人大都挂着剑。他们向海滩跑来，王子远远地跟在后面，这时，他看(上)去仅有其他人的两倍高，不再是巨人了。
卫队长加速划行，小船冲向岛岸，一道拍岸浪像巨手把小船向前推，船身震动了一下，差点把公主颠下船去，船底触到了沙滩。那些已经跑到海滩上的人看着小船犹豫不前，显然是怕水中的饕餮鱼，但还是有四个人跑上前来，帮忙把船稳住，扶公主下船。
“当心，公主不能离开伞!”下船时宽姨高声说，同时使伞保持在公主上方，她这时打伞已经很熟练了，用一只手也能保持伞的旋转。
那些人毫不掩饰自己的惊奇，时而看看旋转的黑伞，时而看看小船经过的海面——那里，赫尔辛根默斯肯香皂的白沫和浮在海面的无数饕餮鱼形成了一条黑白相间的海路，连接着墓岛和王国海岸。
深水王子也走上前来，这时，他的身高与普通人无异，甚至比这群人中的两个高个子还矮一些。他看着来人微笑着，像一个宽厚的渔民，但公主却从他身上看到了父王的影子，她扔下剑，热泪盈眶地喊道：“哥哥，我是你的妹妹露珠!”
“你像我的妹妹。”王子微笑着，点点头，向公主伸出双手。但几个人同时阻止了公主的靠近，把三位来者与王子隔开，其中有人佩剑已出鞘，警惕地盯着刚下船的卫队长。后者没有理会这边的事，只是拾起公主扔下的剑察看，为了避免对方误会，他小心地握着剑尖，发现经过这段航程，那块穿在剑上的赫尔辛根默斯肯香皂只消耗了三分之一左右。
“你们必须证实公主的身份。”一位老者说，他身上破旧的制服打理得很整齐，脸上饱经风霜，但留着像模像样的胡须，显然在这孤岛岁月中他仍尽力保持着王国官员的仪表。“你们不认识我了吗?你是暗林监护官，你——”宽姨指指另一位老者，“是广田老师。”两位老者都点点头。广田老师说：“宽姨，你老了。”“你们也老了。”宽姨说着，腾出一只转伞的手抹眼泪。
暗林监护官不为所动，仍一丝不苟地说：“二十多年了，我们一点都不知道王国发生了什么，所以还是必须证实公主的身份，”他转向公主，“请问，您愿意滴血认亲吗?”
公主点点头。
“我觉得没必要，她肯定是我的�9妹。”王子说。
“殿下，必须这样做。”监护官说。
有人拿来两把很小的匕首，给监护官和老师每人一把。与这些人锈迹斑斑的佩剑不同，两把匕首寒光闪闪，像新的一样。公主伸出手来，监护官用匕首在她白嫩的食指上轻轻划了一下，用刀尖从破口取了一滴血。暗林老师也从王子的手指上取了血样，监护官从老师手中拿过匕首，小心翼翼地把刀尖上的两滴血混在一起，血立刻变成了纯蓝色。
“她是露珠公主。”监护官庄重地对王子说，然后同老师一起向公主鞠躬。其他的几个人都扶着剑柄单膝脆下，然后站起来闪到一边，让王子和公主兄妹拥抱在一起。
“小时候我抱过你，那时你才这么大。”王子比画着说。
公主向王子哭诉王国已经发生的事，王子握着她的手静静地听着，他那饱经风霜但仍然年轻的脸上表情一直从容镇定。
大家都围在王子和公主周围，静静地听着公主的讲述，只有卫队长在做着一件奇怪的事。他时而快步跑开，在海滩上跑到很远的地方看着王子，然后又跑回来从近前看他，如此反复好几次，后来宽姨拉住了他。
“还是我说得对，王子不是巨人吧。”宽姨指指王子低声说。
“他既是巨人又不是巨人。”卫队长也压低声音说，“是这样的：我们看一般的人，他离得越远在我们眼中就越小，是吧?但王子不是这样，不管远近，他在我们眼中的大小都是一样的，近看他是普通身高，远看还是这么高，所以远看就像巨人了。”
宽姨点点头，“好像真是这样。”
听完公主的讲述，深水王子只是简单地说：“我们回去。”
回王国的船只有两只，王子与公主一行三人坐在小船上，其余八人乘另一只更大些的船，是二十年前载着王子一行来墓岛的船，有些漏水，但还能短程行驶。在来时的航道中，泡沫消散了一些，但无数的饕餮鱼仍然浮在海面上很少动弹，有些饕餮鱼被船头撞上，或被桨碰到，也只是懒洋洋地扭动几下，没有更多的动作。大船破旧的帆还能用，在前面行驶，从漂浮一片的饕餮鱼群中为后面的小船开出一条路来。
“你最好还是把香皂放到海里，保险一些，万一它们醒过来怎么办？”宽姨看着船周围黑压压的饕餮鱼，心有余悸地说。
公主说：“它们一直醒着，只是很舒服，懒得动。香皂只刹一块半了，不要浪费，而且我以后再也不用它洗澡了。”
这时，前面的大船上有人喊道：“禁卫军!”
在远处王国的海岸上出现了一支马队，像黑压压的潮水般涌上海滩，马上骑士的盔甲和刀剑在阳光中闪亮。
“继续走。”深水王子镇定地说。
“他们是来杀我们的。”公主的脸色变得苍白。
“不要怕，没事的。”王子拍拍公主的手说。
露珠公主看着哥哥，现在她知道他更适合当国王。
由于是顺风，尽管航道上有懒洋洋漂浮着的饕餮鱼阻碍，回程也快了许多。当两艘船几乎同时靠上海滩时，禁卫军的马阵围拢过来，密集地挡在他们面前，像一堵森严的墙壁。公主和宽姨都大惊失色，但经验丰富的卫队长却把提着的心多少放下一些，他看到对方的剑都在鞘中，长矛也都竖直着；更重要的是，他看到了那些马上的禁卫军士兵的眼睛，他们都身着重甲，面部只露出双眼，但那些眼睛越过他们盯着海面上那漂浮着饕餮鱼的泡沫航道，目光中都露出深深的敬畏。一名军官翻身下马，向刚靠岸的船跑来。大船上的人都跳下船，监护官、老师和几名执剑的卫士把王子和公主档在后面。
“这是深水王子和露珠公主，不得无礼!”监护官暗林对禁卫军举起一只手臂大声说。
跑过来的军官一手扶着插在沙滩上的剑，对王子和公主行单膝礼，“我们知道，但我们奉命追杀公主。”
“露珠公主是合法的王位继承人！而冰沙是谋害国王的逆绒！你们怎么能听他的调遣？！”
“我们知道，所以我们不会执行这个命令，但，冰沙王子已经于昨天下午加冕为国王，所以，禁卫军现在也不知道该听谁的指挥。”
监护官还想说什么，但深水王子从后面走上前来制止了他，王子对军官说：“这样吧，我和公主与你们一起回王宫，等见到冰沙后，把事情做个了结。”
在王宫最豪华的宫殿中，头戴王冠的冰沙正在同忠于他的大臣们纵酒狂欢。突然有人来报，说深水王子和寨珠公主统帅禁卫军从海岸急速向王宫而来，再有一个时辰就到了。宫殿中顿时陷入一片死寂。
“深水?他是怎么过海的?难道他长了翅膀?”冰沙自语道，但并没有像其他人那样面露惊恐，“没什么，禁卫军不会受深水和露珠指挥，除非我死了……针眼画师!”
随着冰沙的召唤，针眼画师从暗处无声地走出，他仍然穿着那身灰斗篷，显得更瘦小了。
“你，带上雪浪纸和绘画工具，骑快马去深水来的方向，看他一眼，然后把他画下来。你见到深水很容易，不用靠近他，他在天边一出现你就能远远看到的。”
“是，我的王。”针眼低声说，然后像老鼠一样无声地离去了。
“至于露珠，一个女孩子，成不了大气候，我会尽快把她的那把伞抢走的。”冰沙说着，又端起酒杯。
宾会在压抑的气氛中结束，大臣们忧心仲钟地离去，只剩下冰沙一人阴郁地坐在空荡荡的大厅中。
不知过了多长时间，冰沙看到针眼画师走了进来，他的心立刻提了起不，不是因为针眼两手空空，也不是因为针眼的样子——画师右上去并没有什么变化，仍是那副小心翼翼的敏感模样，而是因为他听到画师的脚步声。以前，画师走路悄无声息，像灰鼠一般从地面滑过，但这一刻，冰沙听到他发出了吧嗒吧嗒的脚步声，像难以抑制的心跳。
“我的王，我见到了深水王子，但我不能把他画下来。”针眼低着头说。“难道他真的长了翅膀?”冰沙冷冷地问。“如果是那样我也能画下他，我能把他翅膀的每一根羽毛都画得栩栩如生.但，我的王，深水王子没有长翅膀，比那更可怕：他不符合透视原理。”
“什么是透视?”
“世界上所有的景物，在我们的视野中都是近大远小，这就是透视原理。我是西洋画派的画师，西洋画派遵循透视原理，所以我不可能画出他。”
“有不遵循透视原理的画派吗?”
“有，东方画派，我的王，你看，那就是。”针眼指指大厅墙上挂着的一幅卷轴水墨画，画面上是淡雅飘逸的山水，大片的留白似雾似水，与旁边那些浓墨重彩的油画风格迥异，“你可以看出，那幅画是不讲究透视的。可是我没学过东方画派，空灵画师不肯教我，也许他想到了这一天。”
“你去吧。”王子面无表情地说。
“是，我的王，深水王子就要到王宫了，他会杀了我，也会杀了你。但我不会等着让他杀死，我将自我了断，我要画出一幅登峰造极的杰作，用我的生命。”针眼画师说完就走了，他离去时的脚步再次变得悄无声息。
冰沙招来了侍卫，说：“拿我的剑来。”
外面传来密集的马蹄声，开始隐隐约约，但很快逼近，如暴雨般急骤，最后在宫殿外面戛然而止。
冰沙站起身，提剑走出宫殿。他看到深水王子正走上宫殿前长长的宽石阶，露珠公主跟在他后面，宽姨为她打着黑伞。在石阶下面的广场上，是黑压压的禁卫军阵列，军队只是沉默地等待，没有明确表示支持哪一方。冰沙第一眼看到深水王子时，他有普通人的一倍身高，但随着他在台阶上越走越近，身高也在冰沙的眼中渐渐降低。
有那么一瞬间，冰沙的思绪回到了二十多年前的童年。那时，他已经知道了饕餮鱼群正在游向墓岛海域，但还是诱骗深水去墓岛钓鱼。当时父王在焦虑中病倒了，他告诉深水，墓岛有一种鱼，做成的鱼肝油能治好父王的病。一向稳重的深水竞然相信了他，结果如他所愿一去不返，王国里没人知道真相，这一直是他最得意的一件事。
冰沙很快打断思绪回到现实，深水已经走上宫殿前宽阔的平台，他的身高已与正常人差不多了。
冰沙看着深水说：“我的哥哥，欢迎你和妹妹回来，但你们要明白，这是我的王国，我是国王，你们必须立刻宣布臣服于我。”
深水一手按在腰间生铸佩剑的剑柄上，一手指着冰沙说：“你犯下了不可饶怒的罪行!”
冰沙冷冷一笑，“针眼不能画出你的画像，我的利剑却可以刺穿你的心脏!”说着他拔剑出鞘。
冰沙与深水的剑术不相上下，但由于后者不符合透视原理，冰沙很难准确判断自己与对手的距离，处于明显劣势。决斗很快结束，冰沙被深水一剑刺穿胸膛，从高高的台阶上滚下去，在石阶上拖出一条长长的血迹。
禁卫军欢呼起来，他们宣布忠于深水王子和露珠公主。
与此同时，卫队长在王宫中搜寻针眼画师。有人告诉他，画师去了自己的画室。画室位于王宫僻静的一角，平时戒备森严，但由于王宫中突发的变故，守卫大部分离去，只留下了一个哨兵。此人原是长帆的部下，说针眼在半个时辰前就进了画室，一直待在里而没有出来。卫队长于是破门而入。
画室没有窗户，两个银烛台上的蜡烛大部分已经燃尽，使这里像地堡一样阴冷。卫队长没有看到针眼画师，这里空无一人，但他看到了画架上的一幅画，是刚刚完成的，颜料还未干，这是针眼的自画像。确实是一幅精妙绝伦的杰作，画面像一扇通向另一个世界的窗口，针眼就在窗的另一边望着这个世界。尽管雪浪纸翘起的一角证明这只足一幅没有生命的画，卫队长还是尽力避开画中人那犀利的目光。
长帆环顾四周，看到了墙上挂着一排画像，有国王、王后和忠于他们的大臣，他一眼就从中认出了露珠公主的画像。画中的公主让他感到这阴暗的画室如天国一般明亮起来，画中人的眼睛摄住了他的魂，使他久久陶醉其中。但长帆最后还是清醒了，他取下画，拆掉画框，把画幅卷起来，毫不扰豫地在蜡烛上点燃了。
画刚刚烧完，门开了，现实中的露珠公主走了进来，她仍然穿着那身朴素的平民衣服，自己打着黑伞。
“宽姨呢?”长帆问。
“我没让她来，我有话要对你说。”
“你的画像已经烧了。”长帆指指地上仍然冒着红光的灰烬说，“不用打伞了。”
公主让手中的伞转速慢下来，很快出现了夜莺的鸣叫声，随着伞面的下垂，鸟鸣声越来越大，也越来越急促，最后由夜莺的叫声变成寒鸽的嘶鸣，那是死神降临前的最后警告。当伞最后合上时，随着伞沿那几颗石球吧嗒的碰撞，伞安静下来。
公主安然无恙。
卫队长看着公主，长长地出了一口气，又低头看看灰烬，“可惜了，是幅好画，真该让你看看，但我不敢再拖下去了……画得真美。”
“比我还美吗?”
“那就是你。”长帆深情地说。
公主拿出了那一块半赫尔辛根默斯肯香皂，她一松手，没有重量的雪白香皂就像羽毛似的飘浮在空气中。
“我要离开王国，去大海上航行，你愿意跟我去吗?”公主问。
“什么?深水王子不是已经宣布，你明天要加冕为女王吗?他还说他会全力辅佐你的。”
公主摇摇头，“哥哥比我更适合当国王，再说，如果不是被困墓岛，王位本来就应该由他继承。他如果成为国王，站在王宫的高处，全国都能看到他。而我，我不想当女王，我觉得外面比王宫里好，我也不想一辈子都待在无故事王国，想到有故事的地方去。”
“那种生活艰难又危险。”
“我不怕。”公主的双眼在烛光中焕发出生命的光芒，让长帆感到周围又亮了起来。
“我当然更不怕，公主我可以跟着你到海的尽头，到世界尽头。”
“那我们就是最后两个走出王国的人了。”公主说着，抓住了那一块半飘浮的香皂。
“这次我们乘帆船。”
“对，雪白的帆。”
第二天早晨，在王国的另一处海岸上，有人看到海中出现了一张白帆，那艘帆船后面拖曳着一道白云般的泡沫，在朝阳中驶向远方。
以后，王国中的人们再也没有得到露珠公主和长帆的消息。事实上王国得不到任何外界的消息，公主带走了王国中最后一块半赫尔辛根默斯肯香皂，再也没有人能够冲破饕餮鱼的封锁。但没有人抱怨，人们早已习惯了这样的生活，这个故事结束后，无故事王国永远无故事了。
但有时夜深人静，也有人讲述不是故事的故事，那是对露珠公主和长帆经历的想象。每个人的想象都不一样，但人们都认为他俩到过无数神奇的国度，还到过像大海一样广阔的陆地，他们永远在航行和旅途中，不管走到哪里，他们总是幸福地生活在一起。]]></content>
  </entry>
  <entry>
    <title>UWP简单教程</title>
    <url>/2021/06/29/UWP-beginner/</url>
    <content><![CDATA[
本文以 [WxaCode](https://github.com/BDZNH/WxaCode-UWP)为例，讲一下 UWP 初学者用到的一些东西。

{% asset_img wide.jpg homepage %}

<!-- more -->
# UWP 的坐标系
以 16:9 的屏幕为例，左上角是 (0,0) ，右下角是 (1920,1080)，我使用的屏幕是 4K 屏，应用读出来的也还是 1920x1080 。这也省事一些，不用过度关心不同分辨率的情况。


# 动态响应布局

简单来说，动态响应布局可以根据当前屏幕的宽度（或高度），来选择不同的布局，对于PC来说，由于纵向可以用滚轮滚动，所以多数情况下，我们还是以宽度作为布局变化的点。

微信小程序码这个应用中，除去 UWP 自带的控件 `NavigationView` 之外（NavigationView 控件自带动态响应效果），手动实现了动态响应布局的是 HomePage ，下面是 HomePage 的 xml 实现
```xml
<Page
    x:Class="WxaCode.HomePage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WxaCode"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>

        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup>
                <VisualState x:Name="WideLayout" >
                    <VisualState.StateTriggers>
                        <!--VisualState to be triggered when window width is >=720 effective pixels.-->
                        <AdaptiveTrigger MinWindowWidth="720" />
                    </VisualState.StateTriggers>
                    <VisualState.Setters>
                        <Setter Target="wxacodeimage.(Grid.Row)" Value="0" />
                        <Setter Target="wxacodeimage.(Grid.Column)" Value="1" />
                        <Setter Target="wxacodeimage.MaxHeight" Value="900" />
                        <Setter Target="wxacodeimage.MaxWidth" Value="900" />
                        <Setter Target="Container.HorizontalAlignment" Value="Stretch"/>
                        <Setter Target="Container.MinHeight" Value="600"/>
                    </VisualState.Setters>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <Grid x:Name="Container" MinHeight="1000" HorizontalAlignment="Center" >
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="Auto"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="Auto"/>
                    <RowDefinition Height="Auto"/>
                </Grid.RowDefinitions>

                <Grid x:Name="WxaCodeParamsGrid" Width="350" Margin="10,10,10,10" Grid.Row="0" Grid.Column="0" >
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="2*"/>
                        <ColumnDefinition Width="2*"/>
                        <ColumnDefinition Width="3*"/>
                        <ColumnDefinition Width="*"/>
                    </Grid.ColumnDefinitions>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                        <RowDefinition Height="*"/>
                    </Grid.RowDefinitions>

                    <TextBox x:Name="AppidTextBlock" Header="Appid" PlaceholderText="必须填写，应用不缓存" Margin="5,5,5,5" VerticalAlignment="Center" Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="4" TextChanged="AppidTextBlock_TextChanged" />
                    <TextBox x:Name="AppsecretTextBlock" Header="Appsecret" PlaceholderText="必须填写，应用不缓存" Margin="5,5,5,5" VerticalAlignment="Center" Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="4" TextChanged="AppsecretTextBlock_TextChanged" />
                    <TextBox x:Name="WxacodeSceneTextBlock" Header="请输入 scene:" PlaceholderText="不超过32个字符(必须填写)" Margin="5,5,5,5" VerticalAlignment="Center" Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="4" TextChanged="WxacodeSceneTextBlock_TextChanged"/>
                    <TextBox x:Name="WxacodePageTextBlock" Header="请输入 page:" PlaceholderText="已发布的page(可不填，默认为 pages/index/index )" VerticalAlignment="Center" Margin="5,5,5,5" Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="4" TextChanged="WxacodePageTextBlock_TextChanged"/>

                    <Slider x:Name="WxacodeWidthSlider" Margin="5,5,0,5" VerticalAlignment="Center" AutomationProperties.Name="simple slider" Minimum="280" Maximum="1280" StepFrequency="1" SmallChange="1" LargeChange="100" Value="430" Grid.Row="4" Grid.Column="0" Grid.ColumnSpan="2" ValueChanged="WxacodeWidthSlider_ValueChanged"/>
                    <TextBlock Text="小程序码宽度" Margin="5,5,0,5" VerticalAlignment="Center" Grid.Row="4" Grid.Column="2"/>
                    <TextBlock Text="{x:Bind WxacodeWidthSlider.Value.ToString(), Mode=OneWay}" Margin="5,5,5,5" VerticalAlignment="Center" HorizontalAlignment="Right" Grid.Row="4" Grid.Column="3" />

                    <ToggleSwitch x:Name="WxacodeAutoColorSwitch" Header="自动配置线条颜色" AutomationProperties.Name="simple ToggleSwitch" Toggled="ToggleAutoColorSwitch" VerticalAlignment="Center" Grid.Row="5" Grid.Column="0" Grid.ColumnSpan="2" />
                    <ToggleSwitch x:Name="WxacodeIsHyalineSwitch" Header="透明底色" AutomationProperties.Name="simple ToggleSwitch" Margin="5,0,0,0" VerticalAlignment="Center" Grid.Row="5" Grid.Column="2" Grid.ColumnSpan="2" Toggled="WxacodeIsHyalineSwitch_Toggled" />

                    <Slider IsEnabled="{x:Bind WxacodeAutoColorSwitch.IsOn.Equals(x:False), Mode=OneWay}" x:Name="WxacodeLineColorRedSlider" Foreground="Red" Margin="5,5,0,5" VerticalAlignment="Center" Grid.Row="6" Grid.Column="0" Grid.ColumnSpan="2" Minimum="0" Maximum="255" StepFrequency="1" SmallChange="1" LargeChange="10" Value="0" ValueChanged="WxacodeLineColorRedSlider_ValueChanged"  />
                    <TextBlock Text="线条颜色(red)" Margin="5,5,0,5" VerticalAlignment="Center" Grid.Row="6" Grid.Column="2" />
                    <Rectangle x:Name="ColorPreview" Stroke="Black" Fill="White" Grid.Row="6" Grid.Column="3" Grid.RowSpan="3" VerticalAlignment="Stretch" />

                    <Slider IsEnabled="{x:Bind WxacodeAutoColorSwitch.IsOn.Equals(x:False), Mode=OneWay}" x:Name="WxacodeLineColorGreenSlier" Foreground="Green" Grid.Row="7" Grid.Column="0" Grid.ColumnSpan="2" VerticalAlignment="Center" Margin="5,5,0,5" Minimum="0" Maximum="255" StepFrequency="1" SmallChange="1" LargeChange="10" Value="0" ValueChanged="WxacodeLineColorGreenSlier_ValueChanged"  />
                    <TextBlock Text="线条颜色(green)" Grid.Row="7" Grid.Column="2" VerticalAlignment="Center" Margin="5,5,0,5" />

                    <Slider IsEnabled="{x:Bind WxacodeAutoColorSwitch.IsOn.Equals(x:False), Mode=OneWay}" x:Name="WxacodeLineColorBlueSlider" Foreground="Blue" Grid.Row="8" Grid.Column="0" Grid.ColumnSpan="2" VerticalAlignment="Center" Margin="5,5,0,5" Minimum="0" Maximum="255" StepFrequency="1" SmallChange="1" LargeChange="10" Value="0" ValueChanged="WxacodeLineColorBlueSlider_ValueChanged"  />
                    <TextBlock Text="线条颜色(blue)" Grid.Row="8" Grid.Column="2" VerticalAlignment="Center" Margin="5,5,0,5" />

                    <Button Style="{StaticResource AccentButtonStyle}" Content="获取小程序码" x:Name="GetWxaCodeButton" Grid.Row="9" Grid.Column="0" Grid.ColumnSpan="2" VerticalAlignment="Center" Click="GetWxaCodeUnlimited" />
                    <Button Style="{StaticResource AccentButtonStyle}" Content="保存小程序码" x:Name="SaveWxaCodeButton" Grid.Row="9" Grid.Column="2" Grid.ColumnSpan="2" VerticalAlignment="Center" Click="SaveWxacodeImage"/>

                </Grid>
                <Image x:Name="wxacodeimage" Source="/Assets/wxacodesample.jpg" MaxWidth="350" Grid.Row="1" Grid.Column="0" HorizontalAlignment="Center" VerticalAlignment="Center" />

            </Grid>
    </Grid>
</Page>
```

对比一下UWP新建时，空白页的 xml 内容
```xml
<Page
    x:Class="NavigationViewTest.BlankPage1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:NavigationViewTest"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>

    </Grid>
</Page>
```

动态响应布局的关键内容 `VisualStateManager` 即放在 `Grid` 下。然后我们再在 Grid 新建一个 Grid 布局，用这个子布局来承载页面的内容。相当于这个 Page 下有一个根 Grid ，将这个根 Grid 的 (0,0) 单元格，作为一个新的子 Grid 的内容，这里面再添加这个页面的承载元素，这样 VisualStateManager 就能生效了。

VisualStateManager 的语法意思是，在页面大于或小于某个值（坐标系 1920x1080）时，改变控件的一些属性，本例中，改变了承载小程序码的 Image 控件所在的行和列，并且设置相应的宽度实现。下面两图是实现的动态响应布局的效果。

{% asset_img wide.jpg 当界面较宽时 %}

{% asset_img narrow.jpg 当界面较窄时 %}

# 导航栏
导航栏是 UWP 自带的一个控件，Windows 10 的设置下的每一个子页面，都是导航栏的例子，这个控件是 `NavigationView` ，使用时在 Nuget 包管理器中，为当前解决方案添加 `Microsoft.UI.Xaml`。在页面的 Page 节点的配置中，添加`xmlns:muxc="using:Microsoft.UI.Xaml.Controls"`字段，然后在这个页面下的 Grid 内添加一个 NavigationView 控件，以微信小程序码为例，内容如下
```xml
<Page
    x:Class="WxaCode.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:WxaCode"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <Grid>
        <muxc:NavigationView x:Name="NaviView" ItemInvoked="NaviView_ItemInvoked" IsBackButtonVisible="Collapsed" >
            <muxc:NavigationView.MenuItems>
                <muxc:NavigationViewItem Icon="Home" Content="操作" Tag="HomePage" x:Name="homepage" />
                <muxc:NavigationViewItem Icon="Help" Content="关于" Tag="AboutPage" />
            </muxc:NavigationView.MenuItems>
            <ScrollViewer>
                <Frame x:Name="ContentFrame" Padding="12,50,12,24" IsTabStop="True" />
            </ScrollViewer>
        </muxc:NavigationView>
    </Grid>
</Page>
```
注意其中的 `ScrollViewer` 和其内的 `Frame` ，这里将会承载每一个页面不同页面的具体内容，本例中，实际实现是把 homepage 和 aboutpage 作为一个子布局，放到 `Frame` 上。这样导航栏可以一直存在，通过点击导航栏，替换里面的 `Frame` 对应的页面，即可达到通过导航栏来切换页面的效果，具体的代码实现可以查看应用的源码。

# 本地设置
本地设置通常是存放一些设置项，本例中通过封装UWP自带的 `Windows.Storage.ApplicationData.Current.LocalSettings` 来实现，比如是否保存 appid 和 appsecret ,如下图所示
{% asset_img settings.jpg 设置 %}

# 在应用退出时保存数据
可能百度大学会告诉你，UWP在应用关闭时，需要申请一个受限权限"confirmAppClose"，但是由于是一个受限制的权限，有可能会因为这个权限，应用商店不允许发布（我没有尝试，我换了另外一种做法），如果你有安卓应用开发的经验，就会知道，安卓应用关闭时，Activity会收到 onPause,onStop,onDestroy三个事件通知，这三个地方足够你做很多事情，UWP有类似的地方，每一个UWP应用都有一个 App.xaml.cs，其内的
```
private void OnSuspending(object sender, SuspendingEventArgs e)
{
    var deferral = e.SuspendingOperation.GetDeferral();
    //TODO: 保存应用程序状态并停止任何后台活动
    deferral.Complete();
}
```
已经提示了开发者，UWP应用暂停或者关闭时，都会收到这个 OnSuspending 事件，虽然时间很短，但是足够保存一些设置项了。如果你的应用有大量数据要保存，建议应用运行时就定时保存，或者申请受限权限。]]></content>
  </entry>
  <entry>
    <title>Visual Code</title>
    <url>/2017/05/14/Visual-Code/</url>
    <content><![CDATA[
{% asset_img 1.jpg 帮巨硬打个广告%}
<!-- more -->
Visual Code，一个优秀的编辑器。
当然了，编辑器很多，从Windows内置的nodepad，到Atom，再到notepad++，都是不错的，但是，我觉得Visual Code好看啊。
来张照骗
{% asset_img visual_code.jpg 实时渲染Markdown %}
当然了，好事做到底，丢一个编辑器的[快捷键表](http://suppermary.cc/src/visual%20code/keyboard-shortcuts-visual-code.pdf)，丢掉鼠标，啪啪啪敲键盘吧！]]></content>
  </entry>
  <entry>
    <title>微信小程序码隐私政策</title>
    <url>/2021/06/25/WxaCodePrivacyPolicy/</url>
    <content><![CDATA[
## 隐私政策
本软件值微信小程序码软件（以下称本软件），本软件并非微信官方应用，而是根据官方文档开发的第三方应用。
本软件重视用户隐私，本软件尊重并保护所有使用服务用户的个人隐私权。为了给您提供更准确、更有个性化的服务，本软件会按照本隐私权政策的规定使用和披露您的个人信息。
除本隐私权政策另有规定外，在未征得您事先许可的情况下，本软件不会将这些信息对外披露或向第三方提供。本软件会不时更新本隐私权政策。您在同意本软件服务使用协议之时，即视为您已经同意本隐私权政策全部内容。本隐私权政策属于本软件服务使用协议不可分割的一部分。

## 信息提供
使用本软件时，您需要提供您想要获取的小程序码对应的 appid 和 appsecret ，本软件不会存储您的小程序的 appid 和 appsecret，除非您主动在设置当中开启对应的选项。本软件仅在获取小程序码时使用您的 appid 和 appsecret，使用过程中不会访问除微信官方网站之外的任何网站。

## 信息存储和交换
使用本软件过程中，软件不会主动记录您的任何操作，除非您主动在设置中打开对应的选项。若您主动打开记录参数的选项，本软件仅仅会将您设置的参数保留在应用本地，不会上传至任何网站或个人。]]></content>
  </entry>
  <entry>
    <title>安卓 tinycap 的一个 bug</title>
    <url>/2020/10/09/a-bug-of-tinycap/</url>
    <content><![CDATA[
在安卓9.0之前，安卓的 tinycap 有一个 bug 是录音生成的文件头部标志错误，这个会导致生成的文件在某些播放器上无法识别。

{% asset_img andorid.jpg %}

<!-- more -->

## 从 WAV 说起
默认情况下，tinyucap 生成的录音文件是以 pcm 格式存储的。常见的文件扩展名是 `.wav`。文件格式定义如下

{% asset_img wave-file-format.png %}

这个时候我们把 wav 文件当作二进制数据流来看就好。wav文件头部的44字节是这个文件的一些标志信息。这里我们不深究各个字节的含义。我们重点关注 `SubChunk2Size` 。这四个字节表示后边的 `data` 有多长。

## tinycap
tinycap 的源码可以从这里下载[https://android.googlesource.com/platform/external/tinyalsa/](https://android.googlesource.com/platform/external/tinyalsa/)。
下面我也贴出当前的 tinycap 的源码
```c
/* tinycap.c
**
** Copyright 2011, The Android Open Source Project
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
**     * Redistributions of source code must retain the above copyright
**       notice, this list of conditions and the following disclaimer.
**     * Redistributions in binary form must reproduce the above copyright
**       notice, this list of conditions and the following disclaimer in the
**       documentation and/or other materials provided with the distribution.
**     * Neither the name of The Android Open Source Project nor the names of
**       its contributors may be used to endorse or promote products derived
**       from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
** DAMAGE.
*/

#include <tinyalsa/asoundlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <signal.h>
#include <string.h>
#include <time.h>

#define ID_RIFF 0x46464952
#define ID_WAVE 0x45564157
#define ID_FMT  0x20746d66
#define ID_DATA 0x61746164

#define FORMAT_PCM 1

struct wav_header {
    uint32_t riff_id;
    uint32_t riff_sz;
    uint32_t riff_fmt;
    uint32_t fmt_id;
    uint32_t fmt_sz;
    uint16_t audio_format;
    uint16_t num_channels;
    uint32_t sample_rate;
    uint32_t byte_rate;
    uint16_t block_align;
    uint16_t bits_per_sample;
    uint32_t data_id;
    uint32_t data_sz;
};

int capturing = 1;

unsigned int capture_sample(FILE *file, unsigned int card, unsigned int device,
                            unsigned int channels, unsigned int rate,
                            enum pcm_format format, unsigned int period_size,
                            unsigned int period_count, unsigned int cap_time);

void sigint_handler(int sig __unused)
{
    capturing = 0;
}

int main(int argc, char **argv)
{
    FILE *file;
    struct wav_header header;
    unsigned int card = 0;
    unsigned int device = 0;
    unsigned int channels = 2;
    unsigned int rate = 44100;
    unsigned int bits = 16;
    unsigned int frames;
    unsigned int period_size = 1024;
    unsigned int period_count = 4;
    unsigned int cap_time = 0;
    enum pcm_format format;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s file.wav [-D card] [-d device]"
                " [-c channels] [-r rate] [-b bits] [-p period_size]"
                " [-n n_periods] [-T capture time]\n", argv[0]);
        return 1;
    }

    file = fopen(argv[1], "wb");
    if (!file) {
        fprintf(stderr, "Unable to create file '%s'\n", argv[1]);
        return 1;
    }

    /* parse command line arguments */
    argv += 2;
    while (*argv) {
        if (strcmp(*argv, "-d") == 0) {
            argv++;
            if (*argv)
                device = atoi(*argv);
        } else if (strcmp(*argv, "-c") == 0) {
            argv++;
            if (*argv)
                channels = atoi(*argv);
        } else if (strcmp(*argv, "-r") == 0) {
            argv++;
            if (*argv)
                rate = atoi(*argv);
        } else if (strcmp(*argv, "-b") == 0) {
            argv++;
            if (*argv)
                bits = atoi(*argv);
        } else if (strcmp(*argv, "-D") == 0) {
            argv++;
            if (*argv)
                card = atoi(*argv);
        } else if (strcmp(*argv, "-p") == 0) {
            argv++;
            if (*argv)
                period_size = atoi(*argv);
        } else if (strcmp(*argv, "-n") == 0) {
            argv++;
            if (*argv)
                period_count = atoi(*argv);
        } else if (strcmp(*argv, "-T") == 0) {
            argv++;
            if (*argv)
                cap_time = atoi(*argv);
        }
        if (*argv)
            argv++;
    }

    header.riff_id = ID_RIFF;
    header.riff_sz = 0;
    header.riff_fmt = ID_WAVE;
    header.fmt_id = ID_FMT;
    header.fmt_sz = 16;
    header.audio_format = FORMAT_PCM;
    header.num_channels = channels;
    header.sample_rate = rate;

    switch (bits) {
    case 32:
        format = PCM_FORMAT_S32_LE;
        break;
    case 24:
        format = PCM_FORMAT_S24_LE;
        break;
    case 16:
        format = PCM_FORMAT_S16_LE;
        break;
    default:
        fprintf(stderr, "%u bits is not supported.\n", bits);
        fclose(file);
        return 1;
    }

    header.bits_per_sample = pcm_format_to_bits(format);
    header.byte_rate = (header.bits_per_sample / 8) * channels * rate;
    header.block_align = channels * (header.bits_per_sample / 8);
    header.data_id = ID_DATA;

    /* leave enough room for header */
    fseek(file, sizeof(struct wav_header), SEEK_SET);

    /* install signal handler and begin capturing */
    signal(SIGINT, sigint_handler);
    signal(SIGHUP, sigint_handler);
    signal(SIGTERM, sigint_handler);
    frames = capture_sample(file, card, device, header.num_channels,
                            header.sample_rate, format,
                            period_size, period_count, cap_time);
    printf("Captured %u frames\n", frames);

    /* write header now all information is known */
    header.data_sz = frames * header.block_align;
    header.riff_sz = header.data_sz + sizeof(header) - 8;
    fseek(file, 0, SEEK_SET);
    fwrite(&header, sizeof(struct wav_header), 1, file);

    fclose(file);

    return 0;
}

unsigned int capture_sample(FILE *file, unsigned int card, unsigned int device,
                            unsigned int channels, unsigned int rate,
                            enum pcm_format format, unsigned int period_size,
                            unsigned int period_count, unsigned int cap_time)
{
    struct pcm_config config;
    struct pcm *pcm;
    char *buffer;
    unsigned int size;
    unsigned int bytes_read = 0;
    unsigned int frames = 0;
    struct timespec end;
    struct timespec now;

    memset(&config, 0, sizeof(config));
    config.channels = channels;
    config.rate = rate;
    config.period_size = period_size;
    config.period_count = period_count;
    config.format = format;
    config.start_threshold = 0;
    config.stop_threshold = 0;
    config.silence_threshold = 0;

    pcm = pcm_open(card, device, PCM_IN, &config);
    if (!pcm || !pcm_is_ready(pcm)) {
        fprintf(stderr, "Unable to open PCM device (%s)\n",
                pcm_get_error(pcm));
        return 0;
    }

    size = pcm_frames_to_bytes(pcm, pcm_get_buffer_size(pcm));
    buffer = malloc(size);
    if (!buffer) {
        fprintf(stderr, "Unable to allocate %u bytes\n", size);
        free(buffer);
        pcm_close(pcm);
        return 0;
    }

    printf("Capturing sample: %u ch, %u hz, %u bit\n", channels, rate,
           pcm_format_to_bits(format));

    clock_gettime(CLOCK_MONOTONIC, &now);
    end.tv_sec = now.tv_sec + cap_time;
    end.tv_nsec = now.tv_nsec;

    while (capturing && !pcm_read(pcm, buffer, size)) {
        if (fwrite(buffer, 1, size, file) != size) {
            fprintf(stderr,"Error capturing sample\n");
            break;
        }
        bytes_read += size;
        if (cap_time) {
            clock_gettime(CLOCK_MONOTONIC, &now);
            if (now.tv_sec > end.tv_sec ||
                (now.tv_sec == end.tv_sec && now.tv_nsec >= end.tv_nsec))
                break;
        }
    }

    frames = pcm_bytes_to_frames(pcm, bytes_read);
    free(buffer);
    pcm_close(pcm);
    return frames;
}
```

我们看第44到58行
```c
struct wav_header {
    uint32_t riff_id;
    uint32_t riff_sz;
    uint32_t riff_fmt;
    uint32_t fmt_id;
    uint32_t fmt_sz;
    uint16_t audio_format;
    uint16_t num_channels;
    uint32_t sample_rate;
    uint32_t byte_rate;
    uint16_t block_align;
    uint16_t bits_per_sample;
    uint32_t data_id;
    uint32_t data_sz;
};
```
仔细看这里是和上图中的wav文件头一一对应的。

然后再看177到188行
```c
    frames = capture_sample(file, card, device, header.num_channels,
                            header.sample_rate, format,
                            period_size, period_count, cap_time);
    printf("Captured %u frames\n", frames);

    /* write header now all information is known */
    header.data_sz = frames * header.block_align;
    header.riff_sz = header.data_sz + sizeof(header) - 8;
    fseek(file, 0, SEEK_SET);
    fwrite(&header, sizeof(struct wav_header), 1, file);

    fclose(file);
```
这里我们能看到最后通过`fseek(file, 0, SEEK_SET);`和 `fwrite(&header, sizeof(struct wav_header), 1, file);`把 header 信息写入了 file 。这里的file自然就是tinycap生成录音的目标文件。这里的 header 就是上边的结构体的一个实例。并且我们可以看到 `header.data_sz = frames * header.block_align;` 而 `frames = capture_sample(xxxxxxx`。这里的frames和data的值有关。然后我们看一下下面的提交记录

{% asset_img modify-history.png %}

我们可以看到这次修改记录中。原本的
```c
    free(buffer);
    pcm_close(pcm);
    return pcm_bytes_to_frames(pcm, bytes_read);
```
变成了
```c
    frames = pcm_bytes_to_frames(pcm, bytes_read);
    free(buffer);
    pcm_close(pcm);
    return frames;
```
当然如果我们继续深入的看 `pcm_close(pcm)` 确实能出来这里做了一些内存释放的操作。这里就不展示相应的代码了。
到这里就已经明显了，修改之前，这个函数的返回值将是 0 ，这里也会导致生成的 wav 文件的头部用于标志 data 长度的 4 字节为 0，如果播放器按照标准的wav文件去读取，则会发现这是一个没有数据的wav文件。不过我们也能看到，这个bug已经在 2018.03.19 修复。所以本文开头才说这是安卓 9.0 之前的版本有的问题。]]></content>
      <tags>
        <tag>Android</tag>
      </tags>
  </entry>
  <entry>
    <title>【转载】探寻C++最快的读取文件的方案</title>
    <url>/2017/03/18/about-C/</url>
    <content><![CDATA[在竞赛中，遇到大数据时，往往读文件成了程序运行速度的瓶颈，需要更快的读取方式。相信几乎所有的C++学习者都在cin机器缓慢的速度上栽过跟头，于是从此以后发誓不用cin读数据。还有人说Pascal的read语句的速度是C/C++中scanf比不上的，C++选手只能干着急。难道C++真的低Pascal一等吗？答案是不言而喻的。一个进阶的方法是把数据一下子读进来，然后再转化字符串，这种方法传说中很不错，但具体如何从没试过，因此今天就索性把能想到的所有的读数据的方式都测试了一边，结果是惊人的。
<!-- more -->
竞赛中读数据的情况最多的莫过于读一大堆整数了，于是我写了一个程序，生成一千万个随机数到data.txt中，一共55MB。然后我写了个程序主干计算运行时间，代码如下：
```C++
#include <ctime>
int main()
{
    int start = clock();
    //DO SOMETHING
    printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}
```
最简单的方法就算写一个循环scanf了，代码如下：
```C++
const int MAXN = 10000000;

int numbers[MAXN];

void scanf_read()
{
    freopen("data.txt","r",stdin);
    for (int i=0;i<MAXN;i++)
        scanf("%d",&numbers[i]);
}
```
可是效率如何呢？在我的电脑Linux平台上测试结果为2.01秒。接下来是cin，代码如下
```C++
const int MAXN = 10000000;

int numbers[MAXN];

void cin_read()
{
    freopen("data.txt","r",stdin);
    for (int i=0;i<MAXN;i++)
        std::cin >> numbers[i];
}
```
出乎我的意料，cin仅仅用了6.38秒，比我想象的要快。cin慢是有原因的，其实默认的时候，cin与stdin总是保持同步的，也就是说这两种方法可以混用，而不必担心文件指针混乱，同时cout和stdout也一样，两者混用不会输出顺序错乱。正因为这个兼容性的特性，导致cin有许多额外的开销，如何禁用这个特性呢？只需一个语句std::ios::sync_with_stdio(false);，这样就可以取消cin于stdin的同步了。程序如下：
```C++
const int MAXN = 10000000;

int numbers[MAXN];

void cin_read_nosync()
{
    freopen("data.txt","r",stdin);
    std::ios::sync_with_stdio(false);
    for (int i=0;i<MAXN;i++)
        std::cin >> numbers[i];
}
```
取消同步后效率究竟如何？经测试运行时间锐减到了2.05秒，与scanf效率相差无几了！有了这个以后可以放心使用cin和cout了。

接下来让我们测试一下读入整个文件再处理的方法，首先要写一个字符串转化为数组的函数，代码如下
```C++
const int MAXS = 60*1024*1024;
char buf[MAXS];

void analyse(char *buf,int len = MAXS)
{
    int i;
    numbers[i=0]=0;
    for (char *p=buf;*p && p-buf<len;p++)
        if (*p == ' ')
            numbers[++i]=0;
        else
            numbers[i] = numbers[i] * 10 + *p - '0';
}
```
把整个文件读入一个字符串最常用的方法是用fread，代码如下：
```C++
const int MAXN = 10000000;
const int MAXS = 60*1024*1024;

int numbers[MAXN];
char buf[MAXS];

void fread_analyse()
{
    freopen("data.txt","rb",stdin);
    int len = fread(buf,1,MAXS,stdin);
    buf[len] = '\0';
    analyse(buf,len);
}
```
上述代码有着惊人的效率，经测试读取这10000000个数只用了0.29秒，效率提高了几乎10倍！掌握这种方法简直无敌了，不过，我记得fread是封装过的read，如果直接使用read，是不是更快呢？代码如下：
```C++
const int MAXN = 10000000;
const int MAXS = 60*1024*1024;

int numbers[MAXN];
char buf[MAXS];

void read_analyse()
{
    int fd = open("data.txt",O_RDONLY);
    int len = read(fd,buf,MAXS);
    buf[len] = '\0';
    analyse(buf,len);
}
```
测试发现运行时间仍然是0.29秒，可见read不具备特殊的优势。到此已经结束了吗？不，我可以调用Linux的底层函数mmap，这个函数的功能是将文件映射到内存，是所有读文件方法都要封装的基础方法，直接使用mmap会怎样呢？代码如下：
```C++
const int MAXN = 10000000;
const int MAXS = 60*1024*1024;

int numbers[MAXN];
char buf[MAXS];
void mmap_analyse()
{
    int fd = open("data.txt",O_RDONLY);
    int len = lseek(fd,0,SEEK_END);
    char *mbuf = (char *) mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);    
    analyse(mbuf,len);
}
```
经测试，运行时间缩短到了0.25秒，效率继续提高了14%。到此为止我已经没有更好的方法继续提高读文件的速度了。回头测一下Pascal的速度如何？结果令人大跌眼镜，居然运行了2.16秒之多。程序如下：
```C++
const
    MAXN = 10000000;
var
    numbers :array[0..MAXN] of longint;
    i :longint;
begin
    assign(input,'data.txt');
    reset(input);
    for i:=0 to MAXN do
        read(numbers[i]);
end.
```
为确保准确性，我又换到Windows平台上测试了一下。结果如下表：

|             |           |               |                |
| ----------- | --------- | ------------- | -------------- |
| 方法/平台/时间(秒) | Linux gcc | Windows mingw | Windows VC2008 |
| scanf       | 2.010     | 3.704         | 3.425          |
| cin         | 6.380     | 64.003        | 19.208         |
| cin取消同步     | 2.050     | 6.004         | 19.616         |
| fread       | 0.290     | 0.241         | 0.304          |
| read        | 0.290     | 0.398         | 不支持            |
| mmap        | 0.250     | 不支持           | 不支持            |
| Pascal read | 2.160     | 4.668         |     NULL           |

从上面可以看出几个问题:
1. Linux平台上运行程序普遍比Windows上快。
2. Windows下VC编译的程序一般运行比MINGW（MINimal Gcc for Windows）快。
3. VC对cin取消同步与否不敏感，前后效率相同。反过来MINGW则非常敏感，前后效率相差8倍。
4. read本是linux系统函数，MINGW可能采用了某种模拟方式，read比fread更慢。
5. Pascal程序运行速度实在令人不敢恭维。

原文链接:[BYVoid原创 转载请注明](https://www.byvoid.com/zhs/blog/fast-readfile)
]]></content>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>为 putty 添加保存log文件时写入时间的选项</title>
    <url>/2020/06/21/add-new-config-into-putty/</url>
    <content><![CDATA[
putty 几乎是我用过的远程工具里面的最好的了。目前感觉还有的缺憾有
1. 缺少标签页切换
2. 没有命令窗口
3. log文件保存时没有保存时间线的选项

今天来动手为putty增加在保存的log的前面打上时间标签。

<!-- more -->

下载putty的源代码，假设你把它解压到`putty`这个文件夹内。我们主要更改以下几个文件

1. putty\windows\winhelp.h
2. putty\putty.h
3. putty\config.c

# 添加UI选项

## winhelp.h
在 WINHELP_CTX_xxxxx 字段新增一条。这里我新增了一条
```c
#define WINHELP_CTX_logging_timeheader "config-logtimeheader"
```
CTX 后面的 `logging_timeheader` 等下会用到。

## putty.h

在 `#define CONFIG_OPTIONS(X) \`字段新增一条，这里我新增的是
```c
X(BOOL, NONE, logtimeheader) \
```
位置大概是1389行。

## config.c

位置大概 1667 行，仿造原有的代码，添加一个checkbox。这里我写成
```c
ctrl_checkbox(s, "Include time header of line", 'j',HELPCTX(logging_timeheader),conf_checkbox_handler, I(CONF_logtimeheader));
```
上面的代码中，`HELPCTX(logging_timeheader)` 里面的 `logging_timeheader` 是在 putty\windows\winhelp.h 新增的条目。
`I(CONF_logtimeheader)`中的 `logtimeheader`是在 putty\putty.h 中新增的条目。

{% asset_img putty-logging.png %}

# 功能实现

这一步的主逻辑是在 putty\logging.c 这个文件内添加的。修改位置为大概 54 行。`static void logwrite(LogContext *ctx, ptrlen data)` 这个函数体内。修改后如下所示

```c
static void logwrite(LogContext *ctx, ptrlen data)
{
    /*
     * In state L_CLOSED, we call logfopen, which will set the state
     * to one of L_OPENING, L_OPEN or L_ERROR. Hence we process all of
     * those three _after_ processing L_CLOSED.
     */
    if (ctx->state == L_CLOSED)
        logfopen(ctx);

    if (ctx->state == L_OPENING) {
        bufchain_add(&ctx->queue, data.ptr, data.len);
    } else if (ctx->state == L_OPEN) {
        assert(ctx->lgfp);
        if (fwrite(data.ptr, 1, data.len, ctx->lgfp) < data.len) {
            logfclose(ctx);
            ctx->state = L_ERROR;
            lp_eventlog(ctx->lp, "Disabled writing session log "
                "due to error while writing");
        }
        /************** 新增开始 **************/
        if ((strcmp(data.ptr, "\n") == 0) && (conf_get_bool(ctx->conf, CONF_logtimeheader))) {
            char buf[256];
            struct tm tm;
            tm = ltime();
            strftime(buf, 24, "%Y.%m.%d %H:%M:%S   ", &tm);
            fwrite(buf, 1, strlen(buf), ctx->lgfp);
        }
        /*************** 新增结束 *************/
    }   /* else L_ERROR, so ignore the write */
}
```
logwrite 这个函数是用来将putty窗口内显示的字符输出到log文件内的。
如果调用这个函数的地方是一行一行传进来的的话，修改的地方应该是在调用这个函数的地方。但是根据调用的情况来看，多数情况下是一个字符一个字符写的。
所以我的做法是检查到输出的字符是 `\n` 时，就输出一个时间，这样下一行再输出的内容就是跟在这个时间后面的。
最后实现的效果大概是下面这个样子

{% asset_img putty-log.png %}
]]></content>
  </entry>
  <entry>
    <title>也许是一个特性</title>
    <url>/2017/07/02/an-error/</url>
    <content><![CDATA[{% asset_img 1.jpg %}
<!-- more -->
遇到一个神奇的现象，仅作记录，如下代码：
```C++
#include <iostream>
using namespace std;

int main()
{
    printf("啊哈哈");
    return 0;
}
```
一眼看过去，肯定会编译错误，`printf`的头文件`cstdio`都没有包含进去，事实证明，确实如此：
{% asset_img 2.jpg compile with g++ 5.4.0 %}
那么，再来一张如何:
{% asset_img 3.jpg compile with g++ 7.1.0 %}
这几日折腾putty，下载了gcc-7.1.0，顺手把Code::Blocks的编译器换了，结果出这么个岔子，也许7.1.0版本的`iostream`已经包含了`printf`了吧，某天应该会被这个“特性”坑一把吧!
{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>安卓app如何从剪贴板获取图片</title>
    <url>/2020/08/16/android-app-load-image-from-clipboard/</url>
    <content><![CDATA[
在比较新的Chrome浏览器中，长按图片的时候会有复制图片的选项，那么这个图片如何获取到呢。

<!-- more -->

{% asset_img picture1.png %}

尝试了一下似乎手机上没有应用支持粘贴图片。

我们来写一个小小demo来看看粘贴图片如何实现。
首先可以参考官方文档 [https://developer.android.google.cn/guide/topics/text/copy-paste](https://developer.android.google.cn/guide/topics/text/copy-paste)

可以从官方的文档内知道，剪贴板支持 Text，URI，Intent三种类型的对象。可以先给结论，Chrome浏览器复制的一个URI对象。
下面是一个简单的用来获取剪贴板图片的代码

```java
// 先获取一个剪贴板操作实例
ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
//取到剪贴板里面的数据
ClipData.Item item = clipboard.getPrimaryClip().getItemAt(0);
//从剪贴板获取一个uri对象
Uri pasteUri = item.getUri();
//用这个uri对象获取一个bitmap实例
Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), pasteUri);
```

上面的代码并没有刻意写得很简短，其中一部分可以在官方的文档内找到。
最后我们拿到一个bitmap，这个时候可以拿这个bitmap去放在想要使用的地方。
通常到这里读者就可以去尝试了。

下面是一个完整的简单小示范：
`Activity`
```java
import androidx.appcompat.app.AppCompatActivity;

import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.ContentResolver;
import android.content.Context;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "pasteimage";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void clickbutton(View view) {
        // Gets a handle to the Clipboard Manager
        ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
        Log.d(TAG,"get clipboard");

        // Gets a content resolver instance
        ContentResolver cr = getContentResolver();
        Log.d(TAG,"cr");

        // Gets the clipboard data from the clipboard
        ClipData clip = clipboard.getPrimaryClip();
        Log.d(TAG,"getprimaryclip");

        if (clip != null) {

            // Gets the first item from the clipboard data
            ClipData.Item item = clipboard.getPrimaryClip().getItemAt(0);

            if(item == null){
                return ;
            }

            // Tries to get the item's contents as a URI
            String pasteData = (String) item.getText();

            if(pasteData != null){
                Log.d(TAG,pasteData);
            }else {
                Uri pasteUri = item.getUri();
                if(pasteUri != null){
                    Log.d(TAG,pasteUri.toString());
                    String uriMimeType = cr.getType(pasteUri);
                    Log.d(TAG,uriMimeType);
                    if(uriMimeType!=null){
                        if(uriMimeType.contains("image")){
                            Log.d(TAG,"find a image in clipboard");
                            try{
                                Bitmap bitmap = MediaStore.Images.Media.getBitmap(cr, pasteUri);
                                ImageView image = findViewById(R.id.imageview);
                                //image.setImageURI(pasteUri);
                                image.setImageBitmap(bitmap);
                            }catch (Exception e){
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }else {
            Log.d(TAG,"null");
        }
    }
}
```

布局文件
```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="PasteImage"
        android:onClick="clickbutton"
        tools:layout_editor_absoluteX="17dp"
        tools:layout_editor_absoluteY="15dp" />

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/imageview"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/button" />
</androidx.constraintlayout.widget.ConstraintLayout>
```

使用方法，在Chrome浏览器里面复制一张图片之后，打开用上面的代码编译的app，点击`PASTEIMAGE`，就读取剪贴板的图片并显示，如下图


{% asset_img picture2.png %}]]></content>
  </entry>
  <entry>
    <title>Android Studio启用IPv6支持</title>
    <url>/2017/09/30/android-studio-ipv6/</url>
    <content><![CDATA[{% asset_img 1.png%}
<!-- more -->
## 方法
打开AndroidStudio主程序所在目录，右键编辑文件“studio64.exe.vmoptions”，将第19行的`-Djava.net.preferIPv4Stack=true`改成`-Djava.net.preferIPv4Stack=false`。见[文章](https://zhuanlan.zhihu.com/p/20125685)
{% asset_img 2.png %}
## 一些说明
原本的配置文件中的`-Djava.net.preferIPv4Stack`应该是开启`唯IPv4`，也就是说，Android stdio只会从IPv4通道连接网络。在默认情况下，我屏蔽掉IPv4网络，也就是仅仅留下IPv6，并且，Android Studio无法更新SDK，在连接上IPv4的情况下，可以看到Android Studio连接了`dl.google.com`，并且此站点可以通过IPv6连接，但是Android Studio在纯IPv6网络情况下无法连接网络，那么问题就出在Android Studio身上了，更改主程序的配置文件可以使用IPv6网络。

原文作者将配置文件改为

```
-Djava.net.preferIPv4Stack=false
-Djava.net.preferIPv6Addresses=true
```

开启了`唯IPv6`，那么切换到IPv4环境时又需要再改一次配置文件，那么倒不如把`唯IPv4`关掉，这样到底是使用IPv6还是IPv4，就由主机所连接的网络来决定了，而不是由Android Studio和网络环境来决定。

学校的网络同时支持IPv6和IPv4，能走IPv6的时候，就不走IPv4了，毕竟更新一个SDK也是好多GB流量。

## 网络环境更改办法

### For Windows

将以下内容添加到`C:\Windows\System32\drivers\etc\hosts`

```
2401:3800:4001:806::1009 dl.google.com
2401:3800:4001:806::1009 dl.l.google.com
```

在电脑能连接上IPv6网络的情况下，连接`dl.google.com`的流量会被引向IPv6通道，即使电脑连接了IPv4网络。若电脑仅连接了IPv4，则此规则不生效。

### For Linux

Linux的hosts文件在`/etc/hosts`，同样把上面的地址添加就好，但是这样有一个弊端——在电脑处于纯IPv4网络时，规则仍然生效，于是Android Studio又连不上网络了。

最优的解决办法是更改电脑所连接的网络环境的hosts文件，比如路由器的，在能连接上IPv6的路由器上，更改其`hosts`文件，这样电脑连接这个路由器的时候，就能走IPv6，电脑连接上其他仅支持IPv4的网络时，走IPv4，不用更改本机的hosts环境，就不用在切换网络之后，还要更改本机的hosts文件。感觉这点Linux就不如Windows了。

## 其他的一些想法

在很久很久以前，Android_SDK的源还在国外，这可把国内的开发者弄得苦不堪言，SDK就足够折腾一番了，现在的`dl.google.com`主机位于北京，速度还不错，延迟也很低。对于谷歌来说，在国内多部署几个服务器并不算什么，但是，口碑一下子涨了好多吧，毕竟方便了那么多，而且支持IPv6，真是要给谷歌老大几朵花了。

其实吧，说到底，还是为了钱，大陆毕竟是一块大蛋糕，谷歌也想来分一块，不知道什么时候来呢？
And，和Android 8一块来的，谷歌也带来[Kotlin对安卓的支持](https://www.zhihu.com/topic/20008824/hot)，这是不是对Oracle的一点警示呢。]]></content>
  </entry>
  <entry>
    <title>为 Android 编译 openssl 的注意事项</title>
    <url>/2024/08/03/attention-of-build-openssl-for-Android/</url>
    <content><![CDATA[
以下载链接 https://www.openssl.org/source/openssl-1.1.1o.tar.gz 为例
下载解压之后，查看根目录的 NOTES.ANDROID，其中有
```bash
export ANDROID_NDK_HOME=/home/whoever/Android/android-sdk/ndk/20.0.5594570
PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$ANDROID_NDK_HOME/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin:$PATH
./Configure android-arm64 -D__ANDROID_API__=29
make
```
这里就是最直接的编译方式了。但是这样编译之后，会有一个坑

<!-- more -->

```bash
lrwxrwxrwx  1 ubuntu ubuntu      16 Jun  9 21:23 libcrypto.so -> libcrypto.so.1.1
-rwxrwxr-x  1 ubuntu ubuntu 2754216 Jun  9 21:23 libcrypto.so.1.1
lrwxrwxrwx  1 ubuntu ubuntu      13 Jun  9 21:23 libssl.so -> libssl.so.1.1
-rwxrwxr-x  1 ubuntu ubuntu  596600 Jun  9 21:23 libssl.so.1.1
```
编译时尝试链接 `libssl.so` ，实际上会链接到 `libssl.so.1.1` ，但是当你尝试将 `libssl.so.1.1` 集成到 Android studio 工程内时，会发现 `libssl.so.1.1` 这种命名格式so，Android studio 是不会自动将其打包到 apk 内的，即使将 `libssl.so.1.1` 改名为 `libssl.so` 可以集成到 apk ，app运行时仍然会去找 `libssl.so.1.1`。因为 so 内部有其文件名信息
```bash
$objdump -p libssl.so | grep SONAME
  SONAME               libssl.so.1.1
```
对于Android来说，我们更希望，编译之后，so 本身名字就叫 libssl.so。
具体做法是解压 `openssl-1.1.1o.tar.gz` 之后，修改 `15-android.conf`。
大概 193 行。
```PERL
my %targets = (
    "android" => {
        inherit_from     => [ "linux-generic32" ],
        template         => 1,
        ################################################################
        # Special note about -pie. The underlying reason is that
        # Lollipop refuses to run non-PIE. But what about older systems
        # and NDKs? -fPIC was never problem, so the only concern is -pie.
        # Older toolchains, e.g. r4, appear to handle it and binaries
        # turn out mostly functional. "Mostly" means that oldest
        # Androids, such as Froyo, fail to handle executable, but newer
        # systems are perfectly capable of executing binaries targeting
        # Froyo. Keep in mind that in the nutshell Android builds are
        # about JNI, i.e. shared libraries, not applications.
        cflags           => add(sub { android_ndk()->{cflags} }),
        cppflags         => add(sub { android_ndk()->{cppflags} }),
        cxxflags         => add(sub { android_ndk()->{cflags} }),
        bn_ops           => sub { android_ndk()->{bn_ops} },
        bin_cflags       => "-pie",
        enable           => [ ],
        shared_extension => ".so",  ### 这一行是新加的
    },
```
这样可以编译出来不带版本后缀的 `libssl.so` 和 `libcrypto.so`。
可以参考下边的懒人脚本来自行编译: 
```bash
#!/bin/bash

function buildopenssl()
{
    androidarch=$1
    toolchain=$2
    if [ ! -f openssl-1.1.1o.tar.gz ]; then
        wget https://www.openssl.org/source/openssl-1.1.1o.tar.gz
    fi
    if [ !-d openssl-1.1.1o ]; then
        tar -xf openssl-1.1.1o.tar.gz
    fi
    if [ -z $ANDROID_NDK_HOME ]; then
        echo "missing ANDROID_NDK_HOME"
        exit
    fi
    pushd openssl-1.1.1o
    PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$ANDROID_NDK_HOME/toolchains/${toolchain}-linux-androideabi-4.9/prebuilt/linux-x86_64/bin:$PATH
    ./Configure android-$androidarch -D__ANDROID_API__=26
    make clean
    make
    popd
}

buildopenssl arm64 aarch64
#buildopenssl arm arm
#buildopenssl x86 x86
#buildopenssl x86_64 x86_64
```]]></content>
      <tags>
        <tag>Android</tag>
        <tag>openssl</tag>
      </tags>
  </entry>
  <entry>
    <title>在Windows中手动编译Putty</title>
    <url>/2017/06/30/build-putty-on-Windows/</url>
    <content><![CDATA[{% asset_img 1.jpg Putty %}
<!-- more -->
最近琢磨着汉化一下putty，于是下载了其[源代码](https://the.earth.li/~sgtatham/putty/latest/putty-src.zip)，解压后，阅读其文档，发现，其实重新编译似乎并不是太麻烦。
## 使用VS的编译器编译
第一种办法是使用VS的编译器来编译putty，安装VS后，在开始菜单里面，Visual Studio的子菜单下面找到`Developer Command Prompt for vs 2017`(PS:我电脑上安装了Visual Studio 2017，所以是for 2017，具体视安装版本而定)，
{% asset_img 2.jpg %}
然后，切换目录到解压后的putty源码所在的目录的`windows`下面，使用命令`namek -f Makefile.vc`,即可编译putty，如图:
{% asset_img 3.jpg %}
如图，为编译完成的样子
{% asset_img 4.jpg %}
于是，就可以在Windows文件夹内看到编译好的putty套件了
{% asset_img 5.jpg %}
耗时一分钟都不到，不愧为巨硬出品。
## 使用MinGW编译
使用VS的编译器来编译的前提是安装了Visual Studio，但是Visual Studio安装包好几个G，安装时间超长，有时候还联网检查一下更新什么的，巨硬的服务器貌似都在国外，下载速度超慢，所以使用MinGW编译也不失为一个方便的选择。
这里直接提供可用的[MinGW包](https://coding.net/u/BDZNH/p/MinGW-w64/)， 下载后双击解压，然后把解压后文件夹内的[`bin`文件夹添加到环境变量](http://jingyan.baidu.com/article/6b97984da0bd8a1ca2b0bf90.html)。
假设`bin`文件的完整路径为`D:\MinGW-7.1.0\bin`
在开始菜单上点右键，然后点击命令提示符，输入
```bash
set PATH=D:\MinGW-7.1.0\bin;%PATH%
```
验证是否添加成功
{% asset_img 6.jpg %}
若出现如上图的提示信息，即表示添加成功。
然后，切换目录到putty目录下的`windows`文件夹内，使用`make -f Makefile.mgw`即可编译putty
如图为编译成功：
{% asset_img 7.jpg %}
## 碎碎念
以上为我自己试验之后，成功编译的步骤，中途还是踩了一些坑。使用VS的编译其很顺利，一次就通过了，使用MinGW的编译的过程比较曲折，首先是下载了[MinGW-w64](https://sourceforge.net/projects/mingw-w64/)的包，忍受着超级慢的网速安装好之后，发现没有make工具，其bin目录的`mingw32-make`也无法编译，差不多要放弃的时候，又在Gayhub上发现了这个[mingw-distro](https://github.com/StephanTLavavej/mingw-distro),作者网站为[https://nuwen.net/mingw.html](https://nuwen.net/mingw.html),下载好，配置好环境变量，进行编译的时候又出现这个错误
```
gcc  -Wall -O2 -D_WINDOWS -DDEBUG -DWIN32S_COMPAT -D_NO_OLDNAMES -I.././ -I../charset/ -I../windows/ -I../unix/ -D_WIN32_IE=0x0500 -DWINVER=0x0500 -D_WIN32_WINDOWS=0x0410 -D_WIN32_WINNT=0x0500  -c ../windows/window.c
In file included from ../windows/window.c:29:0:
d:\mingw-7.1.0\x86_64-w64-mingw32\include\multimon.h: In function 'IsPlatformNT':
d:\mingw-7.1.0\x86_64-w64-mingw32\include\multimon.h:130:38: error: 'osvi' undeclared (first use in this function); did you mean 'oi'?
     oi.dwOSVersionInfoSize = sizeof (osvi);
                                      ^~~~
                                      oi
d:\mingw-7.1.0\x86_64-w64-mingw32\include\multimon.h:130:38: note: each undeclared identifier is reported only once for each function it appears in
make: *** [Makefile.mgw:963: window.o] Error 1
```
问遍百度不得解，问Google，得到的只是4gbug提交报告。然后又转战MinGW原版，cygwn，均以失败告终，最后还是回到Gayhub的这个版本，最后折腾一番，更改`x86_64-w64-mingw32\include\multimon.h`的内容如下
```C++
//=============================================================================
//
// multimon.h -- Stub module that fakes multiple monitor apis on Win32 OSes
//               without them.
//
// By using this header your code will get back default values from
// GetSystemMetrics() for new metrics, and the new multimonitor APIs
// will act like only one display is present on a Win32 OS without
// multimonitor APIs.
//
// Exactly one source must include this with COMPILE_MULTIMON_STUBS defined.
//
// Copyright (c) Microsoft Corporation. All rights reserved. 
//
//=============================================================================

#include <winapifamily.h>

#pragma region Desktop Family
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

#ifdef __cplusplus
extern "C" {            // Assume C declarations for C++
#endif // __cplusplus

//
// If we are building with Win95/NT4 headers, we need to declare
// the multimonitor-related metrics and APIs ourselves.
//
#ifndef SM_CMONITORS

#define SM_XVIRTUALSCREEN       76
#define SM_YVIRTUALSCREEN       77
#define SM_CXVIRTUALSCREEN      78
#define SM_CYVIRTUALSCREEN      79
#define SM_CMONITORS            80
#define SM_SAMEDISPLAYFORMAT    81

// HMONITOR is already declared if WINVER >= 0x0500 in windef.h
// This is for components built with an older version number.
//
#if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)
DECLARE_HANDLE(HMONITOR);
#define HMONITOR_DECLARED
#endif

#define MONITOR_DEFAULTTONULL       0x00000000
#define MONITOR_DEFAULTTOPRIMARY    0x00000001
#define MONITOR_DEFAULTTONEAREST    0x00000002

#define MONITORINFOF_PRIMARY        0x00000001

typedef struct tagMONITORINFO
{
    DWORD   cbSize;
    RECT    rcMonitor;
    RECT    rcWork;
    DWORD   dwFlags;
} MONITORINFO, *LPMONITORINFO;

#ifndef CCHDEVICENAME
#define CCHDEVICENAME 32
#endif

#ifdef __cplusplus
typedef struct tagMONITORINFOEXA : public tagMONITORINFO
{
    CHAR        szDevice[CCHDEVICENAME];
} MONITORINFOEXA, *LPMONITORINFOEXA;
typedef struct tagMONITORINFOEXW : public tagMONITORINFO
{
    WCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEXW, *LPMONITORINFOEXW;
#ifdef UNICODE
typedef MONITORINFOEXW MONITORINFOEX;
typedef LPMONITORINFOEXW LPMONITORINFOEX;
#else
typedef MONITORINFOEXA MONITORINFOEX;
typedef LPMONITORINFOEXA LPMONITORINFOEX;
#endif // UNICODE
#else // ndef __cplusplus
typedef struct tagMONITORINFOEXA
{
    MONITORINFO;
    CHAR        szDevice[CCHDEVICENAME];
} MONITORINFOEXA, *LPMONITORINFOEXA;
typedef struct tagMONITORINFOEXW
{
    MONITORINFO;
    WCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEXW, *LPMONITORINFOEXW;
#ifdef UNICODE
typedef MONITORINFOEXW MONITORINFOEX;
typedef LPMONITORINFOEXW LPMONITORINFOEX;
#else
typedef MONITORINFOEXA MONITORINFOEX;
typedef LPMONITORINFOEXA LPMONITORINFOEX;
#endif // UNICODE
#endif

typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);

#ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
typedef struct _DISPLAY_DEVICEA {
    DWORD  cb;
    CHAR   DeviceName[32];
    CHAR   DeviceString[128];
    DWORD  StateFlags;
    CHAR   DeviceID[128];
    CHAR   DeviceKey[128];
} DISPLAY_DEVICEA, *PDISPLAY_DEVICEA, *LPDISPLAY_DEVICEA;
typedef struct _DISPLAY_DEVICEW {
    DWORD  cb;
    WCHAR  DeviceName[32];
    WCHAR  DeviceString[128];
    DWORD  StateFlags;
    WCHAR  DeviceID[128];
    WCHAR  DeviceKey[128];
} DISPLAY_DEVICEW, *PDISPLAY_DEVICEW, *LPDISPLAY_DEVICEW;
#ifdef UNICODE
typedef DISPLAY_DEVICEW DISPLAY_DEVICE;
typedef PDISPLAY_DEVICEW PDISPLAY_DEVICE;
typedef LPDISPLAY_DEVICEW LPDISPLAY_DEVICE;
#else
typedef DISPLAY_DEVICEA DISPLAY_DEVICE;
typedef PDISPLAY_DEVICEA PDISPLAY_DEVICE;
typedef LPDISPLAY_DEVICEA LPDISPLAY_DEVICE;
#endif // UNICODE

#define DISPLAY_DEVICE_ATTACHED_TO_DESKTOP 0x00000001
#define DISPLAY_DEVICE_MULTI_DRIVER        0x00000002
#define DISPLAY_DEVICE_PRIMARY_DEVICE      0x00000004
#define DISPLAY_DEVICE_MIRRORING_DRIVER    0x00000008
#define DISPLAY_DEVICE_VGA_COMPATIBLE      0x00000010
#endif

#endif  // SM_CMONITORS

#undef GetMonitorInfo
#undef GetSystemMetrics
#undef MonitorFromWindow
#undef MonitorFromRect
#undef MonitorFromPoint
#undef EnumDisplayMonitors
#undef EnumDisplayDevices

//
// Define COMPILE_MULTIMON_STUBS to compile the stubs;
// otherwise, you get the declarations.
//
#ifdef COMPILE_MULTIMON_STUBS

//-----------------------------------------------------------------------------
//
// Implement the API stubs.
//
//-----------------------------------------------------------------------------

#ifndef _MULTIMON_USE_SECURE_CRT
#if defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L
#define _MULTIMON_USE_SECURE_CRT 1
#else
#define _MULTIMON_USE_SECURE_CRT 0
#endif
#endif

#ifndef MULTIMON_FNS_DEFINED

int      (WINAPI* g_pfnGetSystemMetrics)(int) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, DWORD) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, DWORD) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, DWORD) = NULL;
BOOL     (WINAPI* g_pfnGetMonitorInfo)(HMONITOR, LPMONITORINFO) = NULL;
BOOL     (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
BOOL     (WINAPI* g_pfnEnumDisplayDevices)(PVOID, DWORD, PDISPLAY_DEVICE,DWORD) = NULL;
BOOL     g_fMultiMonInitDone = FALSE;
BOOL     g_fMultimonPlatformNT = FALSE;

#endif

BOOL IsPlatformNT()
{ 
    OSVERSIONINFOA osvi = {0};
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    GetVersionExA((OSVERSIONINFOA*)&osvi);
    return (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);    
}

BOOL InitMultipleMonitorStubs(void)
{
    HMODULE hUser32;
    if (g_fMultiMonInitDone)
    {
        return g_pfnGetMonitorInfo != NULL;
    }

    g_fMultimonPlatformNT = IsPlatformNT();
    hUser32 = GetModuleHandle(TEXT("USER32"));
    if (hUser32 &&
        (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) != NULL &&
        (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) != NULL &&
#ifdef UNICODE
        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) != NULL &&
        (*(FARPROC*)&g_pfnGetMonitorInfo      = g_fMultimonPlatformNT ? GetProcAddress(hUser32,"GetMonitorInfoW") : 
                                                GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL
#else
        (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL &&
        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) != NULL
#endif
    ) {
        g_fMultiMonInitDone = TRUE;
        return TRUE;
    }
    else
    {
        g_pfnGetSystemMetrics    = NULL;
        g_pfnMonitorFromWindow   = NULL;
        g_pfnMonitorFromRect     = NULL;
        g_pfnMonitorFromPoint    = NULL;
        g_pfnGetMonitorInfo      = NULL;
        g_pfnEnumDisplayMonitors = NULL;
        g_pfnEnumDisplayDevices  = NULL;

        g_fMultiMonInitDone = TRUE;
        return FALSE;
    }
}

//-----------------------------------------------------------------------------
//
// fake implementations of Monitor APIs that work with the primary display
// no special parameter validation is made since these run in client code
//
//-----------------------------------------------------------------------------

int WINAPI
xGetSystemMetrics(int nIndex)
{
    if (InitMultipleMonitorStubs())
        return g_pfnGetSystemMetrics(nIndex);

    switch (nIndex)
    {
    case SM_CMONITORS:
    case SM_SAMEDISPLAYFORMAT:
        return 1;

    case SM_XVIRTUALSCREEN:
    case SM_YVIRTUALSCREEN:
        return 0;

    case SM_CXVIRTUALSCREEN:
        nIndex = SM_CXSCREEN;
        break;

    case SM_CYVIRTUALSCREEN:
        nIndex = SM_CYSCREEN;
        break;
    }

    return GetSystemMetrics(nIndex);
}

#define xPRIMARY_MONITOR ((HMONITOR)0x12340042)

HMONITOR WINAPI
xMonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);

    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
        ((ptScreenCoords.x >= 0) &&
        (ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
        (ptScreenCoords.y >= 0) &&
        (ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
    {
        return xPRIMARY_MONITOR;
    }

    return NULL;
}

HMONITOR WINAPI
xMonitorFromRect(LPCRECT lprcScreenCoords, DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);

    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
        ((lprcScreenCoords->right > 0) &&
        (lprcScreenCoords->bottom > 0) &&
        (lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
        (lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
    {
        return xPRIMARY_MONITOR;
    }

    return NULL;
}

HMONITOR WINAPI
xMonitorFromWindow(HWND hWnd, DWORD dwFlags)
{
    WINDOWPLACEMENT wp;

    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromWindow(hWnd, dwFlags);

    if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
        return xPRIMARY_MONITOR;

    if (IsIconic(hWnd) ?
            GetWindowPlacement(hWnd, &wp) :
            GetWindowRect(hWnd, &wp.rcNormalPosition)) {

        return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);
    }

    return NULL;
}

BOOL WINAPI
xGetMonitorInfo(HMONITOR hMonitor, _Inout_ LPMONITORINFO lpMonitorInfo)
{
    RECT rcWork;

    if (InitMultipleMonitorStubs())
    {
        BOOL f = g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);
#ifdef UNICODE
        if (f && !g_fMultimonPlatformNT && (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX)))
        { 
            MultiByteToWideChar(CP_ACP, 0,
                (LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
                ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
        }
#endif
        return f;
    }

    if ((hMonitor == xPRIMARY_MONITOR) &&
        lpMonitorInfo &&
        (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
        SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
    {
        lpMonitorInfo->rcMonitor.left = 0;
        lpMonitorInfo->rcMonitor.top  = 0;
        lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);
        lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
        lpMonitorInfo->rcWork = rcWork;
        lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;

        if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
        {
#ifdef UNICODE
            MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
#else // UNICODE
#if _MULTIMON_USE_SECURE_CRT
            strncpy_s(((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)) - 1);
#else
            lstrcpyn(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
#endif // _MULTIMON_USE_SECURE_CRT
#endif // UNICODE
        }

        return TRUE;
    }

    return FALSE;
}

BOOL WINAPI
xEnumDisplayMonitors(
        HDC             hdcOptionalForPainting,
        LPCRECT         lprcEnumMonitorsThatIntersect,
        MONITORENUMPROC lpfnEnumProc,
        LPARAM          dwData)
{
    RECT rcLimit;

    if (InitMultipleMonitorStubs()) {
        return g_pfnEnumDisplayMonitors(
                hdcOptionalForPainting,
                lprcEnumMonitorsThatIntersect,
                lpfnEnumProc,
                dwData);
    }

    if (!lpfnEnumProc)
        return FALSE;

    rcLimit.left   = 0;
    rcLimit.top    = 0;
    rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);
    rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);

    if (hdcOptionalForPainting)
    {
        RECT    rcClip;
        POINT   ptOrg;

        switch (GetClipBox(hdcOptionalForPainting, &rcClip))
        {
        default:
            if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
                return FALSE;

            OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
            if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
                (!lprcEnumMonitorsThatIntersect ||
                     IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {

                break;
            }
            //fall thru
        case NULLREGION:
             return TRUE;
        case ERROR:
             return FALSE;
        }
    } else {
        if (    lprcEnumMonitorsThatIntersect &&
                !IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {

            return TRUE;
        }
    }

    return lpfnEnumProc(
            xPRIMARY_MONITOR,
            hdcOptionalForPainting,
            &rcLimit,
            dwData);
}

BOOL WINAPI
xEnumDisplayDevices(
    PVOID Unused,
    DWORD iDevNum,
    _Inout_ PDISPLAY_DEVICE lpDisplayDevice,
    DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);

    if (Unused != NULL)
        return FALSE;

    if (iDevNum != 0)
        return FALSE;

    if (lpDisplayDevice == NULL || lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))
        return FALSE;

#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));
#else // UNICODE
#if _MULTIMON_USE_SECURE_CRT
    strncpy_s((LPTSTR)lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
    strncpy_s((LPTSTR)lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
#else
    lstrcpyn((LPTSTR)lpDisplayDevice->DeviceName,   TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
    lstrcpyn((LPTSTR)lpDisplayDevice->DeviceString, TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));
#endif // _MULTIMON_USE_SECURE_CRT
#endif // UNICODE

    lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE;

    return TRUE;
}

#undef xPRIMARY_MONITOR
#undef COMPILE_MULTIMON_STUBS

#else   // COMPILE_MULTIMON_STUBS

extern int  WINAPI xGetSystemMetrics(int);
extern HMONITOR WINAPI xMonitorFromWindow(HWND, DWORD);
extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, DWORD);
extern HMONITOR WINAPI xMonitorFromPoint(POINT, DWORD);
extern BOOL WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
extern BOOL WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
extern BOOL WINAPI xEnumDisplayDevices(PVOID, DWORD, PDISPLAY_DEVICE, DWORD);

#endif  // COMPILE_MULTIMON_STUBS

//
// build defines that replace the regular APIs with our versions
//
#define GetSystemMetrics    xGetSystemMetrics
#define MonitorFromWindow   xMonitorFromWindow
#define MonitorFromRect     xMonitorFromRect
#define MonitorFromPoint    xMonitorFromPoint
#define GetMonitorInfo      xGetMonitorInfo
#define EnumDisplayMonitors xEnumDisplayMonitors
#define EnumDisplayDevices  xEnumDisplayDevices

#ifdef __cplusplus
}
#endif  // __cplusplus


#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */
#pragma endregion



```
才得以编译通过，在文首给出的链接中，我已经更改这个头文件，也保留了源文件，更改文件名为`multimon-bak.h`。
PS:这个头文件是VS编译器的头文件，我给弄到MinGW里面来了。
汉化的事情只能往后再拖一拖了，没想到一个编译就把我给卡住了。
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>从零开始建立PuTTY工程</title>
    <url>/2018/05/20/build-putty-step-by-step/</url>
    <content><![CDATA[
PuTTY的源码下载之后，里面已经带有Visual Studio 2010和Visual Studio 2012的解决方案，但是惊奇的发现，用这个两个解决方案编译出来的putty居然是xp风格的，和官网下载到的不一样。(如果只是要单纯的解决这个xp风格，可以参考[MANIFEST](#MANIFEST))

{% asset_image 25.png %}

所以，从零开始建立putty的Viusal Studio2017解决方案。

<!-- more -->

首先，建立一个空项目(记得勾选为解决方案创建目录)
{% asset_image 1.png %}

这个时候，在你的putty源码目录的windows文件夹内会有一个putty文件夹，里面会有一个`putty.sln`和一个`putty`文件夹，将windows文件夹内的putty文件夹更名为VS2017(仅仅是为了与已有的解决方案统一风格而已，名字随意)，这个时候，你可以对着解决方案的putty项目，点击右键，移动到添加，然后点击添加现有现有项，或者可以直接按下`Shift + Alt +A`，对着原本就有的PuTTY项目，分别添加源文件、头文件、资源文件:

{% asset_image 2.png %}
添加完成之后，putty项目看起来应该是这个样子的

{% asset_image 3.png %}

## 无法打开包括文件: “unix.h”

按下`Ctrl+Shift+B`，你就会看到这样的画面：

{% asset_image 4.png %}
错误
```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	C1083	无法打开包括文件: “unix.h”: No such file or directory	putty	d:\desktop\putty-en\puttyps.h	14	
```
原因很明显，它们找不到头文件在哪儿，右击项目，点击属性，选中C/C++，在附加包含目录内填入`..\..\..\./;..\..\..\unix/;..\..\..\charset/;..\..\..\windows/;`

{% asset_image 5.png %}
这个是用来指定编译器搜索头文件的目录的，这里用的是相对路径(相对于putty解决方案内putty项目的路径，也就是putty源码的根目录，unix目录，charset目录和windows目录)，这个附加目录也可以在`VC++目录`的包含目录里面填写，如下图

{% asset_image 6.png %}
库目录在putty项目的建立过程中不用填写，putty没有用到第三方库，这里不用填写。

## 无法打开包括文件: “dlfcn.h”

再次生成解决方案，你会遇到第二个问题
```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	C1083	无法打开包括文件: “dlfcn.h”: No such file or directory	putty	d:\desktop\putty-en\unix\unix.h	11	
```

{% asset_image 7.png %}
依旧打开项目属性，点击`C/C++`，预处理器,预处理器定义

{% asset_image 8.png %}
点击右边的下拉箭头，点击编辑，填入以下内容：
```
WIN32
_WINDOWS
_CRT_SECURE_NO_WARNINGS
```
这个时候，看起来应该是这个样子的("dlfcn.h"是Linux系统的头文件，猜测加预处理参数是为了让编译器知道不去试图查找这个文件)
{% asset_image 9.png %}

## case 表达式不是常量

再次生成解决方案，你会遇到第三个问题
```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	C2051	case 表达式不是常量	putty	d:\desktop\putty-en\ssh.c	1372	
```

{% asset_img 10.png %}

打开项目属性，选中`C/C++`，将调试信息格式更改为“程序数据库”，
{% asset_img 11.png %}

## 使用了可能未初始化的本地指针变量

再次生成解决方案，你会遇到第四个问题
```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	C4703	使用了可能未初始化的本地指针变量“oev”	putty	d:\desktop\putty-en\windows\winhandl.c	342	
```
{% asset_img 12.png %}
打开项目属性，选中`C/C++`，将SDL检查改为否

{% asset_img 13.png %}

## noshare.obj & winshare.obj

再次生成解决方案，好了，你成功的将错误减少到了四个
```

错误	LNK2005	_platform_ssh_share 已经在 noshare.obj 中定义	putty	D:\Desktop\putty-en\windows\VS2017\putty\winshare.obj	1	

错误	LNK2005	_platform_ssh_share_cleanup 已经在 noshare.obj 中定义	putty	D:\Desktop\putty-en\windows\VS2017\putty\winshare.obj	1	

错误	CVT1100	资源重复。类型: MANIFEST，名称: 1，语言: 0x0409	putty	D:\Desktop\putty-en\windows\VS2017\putty\CVTRES	1	

错误	LNK1123	转换到 COFF 期间失败: 文件无效或损坏	putty	D:\Desktop\putty-en\windows\VS2017\putty\LINK	1	
```

{% asset_img 14.png %}

对于错误1和错误2，我只能说，可能原本设计项目的人比较神奇，这两个错误花了我相当长的时间才排查掉，原因说得很清楚了，在连接`winshare.obj`的时候，发现函数`_platform_ssh_share`和`_platform_ssh_share_cleanup`已经在` noshare.obj`内定义过，`noshare.c`文件内的内容如下 
```C
/*
 * Stub implementation of SSH connection-sharing IPC, for any
 * platform which can't support it at all.
 */

#include <stdio.h>
#include <assert.h>
#include <errno.h>

#include "tree234.h"
#include "putty.h"
#include "ssh.h"
#include "network.h"

int platform_ssh_share(const char *name, Conf *conf,
                       Plug downplug, Plug upplug, Socket *sock,
                       char **logtext, char **ds_err, char **us_err,
                       int can_upstream, int can_downstream)
{
    return SHARE_NONE;
}

void platform_ssh_share_cleanup(const char *name)
{
}
```

大致上看起来就是重定义了，BUT，为什么原本有的putty项目可以编译？，尝试将`noshare.c`从项目中移除之后，再次编译，这两错误不见了，但是，为什么原本的项目可以编译呢，好生奇怪，两天之后，偶然发现，原本项目内的`noshare.c`文件前面的图标和其他源文件长得不一样，仿佛发现了什么，点开属性一看，原来如此:
右击`noshare.c`点击属性，选中常规，点击“项类型”右边的下拉箭头，改成`C/C++标头`，

{% asset_img 15.png %}

## MANIFEST

再次生成解决方案，好了，这次你只能看到两个问题了
```
错误	CVT1100	资源重复。类型: MANIFEST，名称: 1，语言: 0x0409	putty	D:\Desktop\putty-en\windows\VS2017\putty\CVTRES	1	

错误	LNK1123	转换到 COFF 期间失败: 文件无效或损坏	putty	D:\Desktop\putty-en\windows\VS2017\putty\LINK	1	
```

但是这两个问题都不是源代码的问题(其实用源码内原本就有的解决方案能编译成功，就说明代码没问题了(PS:严格来说也不是没有可能)),对于`错误	CVT1100	资源重复。类型: MANIFEST，名称: 1，语言: 0x0409	putty	D:\Desktop\putty-en\windows\VS2017\putty\CVTRES	1	`，右击项目，点击属性，点击清单工具，选中输入和输出，将嵌入清单改成“否”

{% asset_img 16.png %}

再次生成解决方案，错误变成了

```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	LNK2019	无法解析的外部符号 _ImmGetContext@4，该符号在函数 _WndProc@16 中被引用	putty	D:\Desktop\putty-en\windows\VS2017\putty\window.obj	1	
错误	LNK2019	无法解析的外部符号 _ImmReleaseContext@8，该符号在函数 _WndProc@16 中被引用	putty	D:\Desktop\putty-en\windows\VS2017\putty\window.obj	1	
错误	LNK2019	无法解析的外部符号 _ImmGetCompositionStringW@16，该符号在函数 _WndProc@16 中被引用	putty	D:\Desktop\putty-en\windows\VS2017\putty\window.obj	1	
错误	LNK2019	无法解析的外部符号 _ImmSetCompositionFontA@8，该符号在函数 _WndProc@16 中被引用	putty	D:\Desktop\putty-en\windows\VS2017\putty\window.obj	1	
错误	LNK2019	无法解析的外部符号 _ImmSetCompositionWindow@8，该符号在函数 _sys_cursor_update 中被引用	putty	D:\Desktop\putty-en\windows\VS2017\putty\window.obj	1	
错误	LNK1120	5 个无法解析的外部命令	putty	D:\Desktop\putty-en\windows\VS2017\Debug\putty.exe	1	
```

{% asset_img 17.png %}

熟悉的话，很容易就知道这个是因为缺了静态库
右击项目，点击属性，点击链接器，选中输入，点击附加依赖项右边的下拉箭头，点击编辑，

{% asset_img 18.png %}

填入imm32.lib，它看起来就是这样子的

{% asset_img 19.png %}

再次编译，哈哈哈，终于成功了

{% asset_img 20.png %}

{% asset_img 21.png %}

## 其他可能遇到的问题

### cannot open include file 'version.h'

不过你也有可能遇到这个问题
```
严重性	代码	说明	项目	文件	行	禁止显示状态
错误	RC1015	cannot open include file 'version.h'.	putty	D:\Desktop\putty-en\windows\version.rc2	9	
```
{% asset_img 22.png %}
如果你在[第一步](#%E6%97%A0%E6%B3%95%E6%89%93%E5%BC%80%E5%8C%85%E6%8B%AC%E6%96%87%E4%BB%B6-%E2%80%9Cunix-h%E2%80%9D)中，填写附加包含目录的时候，填在了`VC++目录`里面，则不会遇到此问题，若是填到了`C/C++`则会遇到，一个办法是更改到`VC++`目录去，另外一个办法是在项目属性的资源选项下面，附加目录里面填上`..\..\..\./;`

{% asset_img 23.png %}

### 关于依赖库

在putty原本带的解决方案内的附加依赖项是下面这些

```
advapi32.lib
comdlg32.lib
gdi32.lib
imm32.lib
ole32.lib
shell32.lib
user32.lib
```

在Windows 10 1803上，Visual Studio 2017 的预先包含的静态库里面已经包含了除去`imm32.lib`之外的所有今天库，所以我只添加了它。有关Visual Studio的各种报错，查看巨硬(微软)的文档是一个好办法，百度得到的办法虽说更为简洁明了一些，但是因为复现环境不一样，有时候并没有效果。

### 调整项目属性之后不生效

PS：若是调整项目属性之后不生效，请留意调整的项目和生成解决方案的是否是同一个编译选项
{% asset_img 24.png %}

### 让其他项目用同样的属性

按照上一个描述的问题，对于一个工程，在win32和x86的Release和Debug模式都需要调整属性，就整整四个了，整个PuTTY解决方案其实包括了 `pageant plink pscp psftp putty puttygen puttytel testbn`,其它七个再来一次，简直爽歪歪，这个时候项目属性表就有用了，可以参考[https://www.cnblogs.com/haomiao/p/5812860.html](https://www.cnblogs.com/haomiao/p/5812860.html)，若是找不到属性管理器，可以点击视图下的其他窗口的“属性管理器”。

### 懒人包
GitHub上有已经汉化完成的版本——[https://github.com/larryli/PuTTY](https://github.com/larryli/PuTTY)
下载搭建好的PuTTY的Visual Studio 2017解决方案，可以前往[https://github.com/BDZNH/PuTTY](https://github.com/BDZNH/PuTTY)
]]></content>
  </entry>
  <entry>
    <title>手动编译shadowsocks-libev</title>
    <url>/2018/03/16/build-shadowsocks-libev/</url>
    <content><![CDATA[
把树莓派的系统刷掉了，重新装了一些环境，shadowsocks-libev是比较活跃的分支，更新得较为频繁，在树莓派的官方源内的版本较低，这里记录一下安装过程。

<!-- more -->

## 为Linux编译

### 下载

```bash
git clone https://github.com/shadowsocks/shadowsocks-libev.git
cd shadowsocks-libev
git submodule update --init --recursive
```

### 编译准备


#### 安装基本依赖环境

```bash
sudo apt-get install --no-install-recommends gettext build-essential autoconf libtool libpcre3-dev  xmlto libev-dev libc-ares-dev automake
```

这里本该装`asciidoc`，但是它有1GB+，这对于树莓派来说已经是一个巨型软件了，所以没有装。

#### 安装加密协议依赖包

```bash
# Installation of Libsodium
export LIBSODIUM_VER=1.0.17
wget https://download.libsodium.org/libsodium/releases/libsodium-$LIBSODIUM_VER.tar.gz
tar xvf libsodium-$LIBSODIUM_VER.tar.gz
pushd libsodium-$LIBSODIUM_VER
./configure --prefix=/usr && make
sudo make install
popd
sudo ldconfig

# Installation of MbedTLS
export MBEDTLS_VER=2.16.0
wget https://tls.mbed.org/download/mbedtls-$MBEDTLS_VER-gpl.tgz
tar xvf mbedtls-$MBEDTLS_VER-gpl.tgz
pushd mbedtls-$MBEDTLS_VER
make SHARED=1 CFLAGS=-fPIC
sudo make DESTDIR=/usr install
popd
sudo ldconfig
```

### 编译

```bash
./configure --disable-documentation
make -j4
```

参数`--disable-documentation`是在没有安装`asciidoc`的情况下使用的，编译完成后可以在`src`目录里面找到它们。

## 为 Windows 编译

### 在Windows上编译

在 Windows 上的编译步骤很少，但是不太好实现。很多时候都会因为网络原因中断。方法如下：
到[https://www.docker.com/](https://www.docker.com/)下载Docker安装。
然后将shadowsocks项目克隆到本地，再双击`docker\mingw`内的`make.bat`，等待编译完成就好。不过得实现配置好MinGW的环境。
这里提供已经编译好的Windows程序[https://github.com/BDZNH/shadowsocks-libev/releases](https://github.com/BDZNH/shadowsocks-libev/releases)

### 在Linux上编译

docker在Windows上的安装步骤稍微麻烦一些，在Linux上安装就方便得多了。

```bash
sudo yum install docker
```

或者

```bash
sudo apt-get install docker.io
```

安装好docker之后，使用命令

```bash
service docker start
```

启动docker，然后到Shaodwoskcs的`docker/mingw`目录下面运行make命令，等待完成就好，优势在于可以在VPS上运行，不用顾及网络。
]]></content>
  </entry>
  <entry>
    <title>启用树莓派摄像头</title>
    <url>/2017/08/01/camera-on-raspberry/</url>
    <content><![CDATA[
树莓派有很多官方出品的配件，虽然很多配件比树莓派自己还贵，但是总有一些值得玩的小物件，比如“camera”

{% asset_img 1.jpg Camera %}
<!-- more -->

## 目标
{% cq %}用这个摄像头做监控{% endcq %}

## 实施过程

首先的首先，确保你已经通过putty或者什么软件之类的，或者键盘什么的能连接上树莓派，并且打开了终端。

### raspivid & vlc

使用命令安装所需软件包：

```shell
sudo apt-get update
sudo apt-get install raspivid vlc -y
```

`raspivid`是官方的调用树莓派摄像头的软件包，若树莓派上安装的不是`raspbian`，则需要用其他软件了。

现在你可以输入

```shell
raspivid -t 0 -hf
```

来显示图像了，如果树莓派上插了显示器，你就能在显示器上看到摄像头的画面了。但是最终目标可不是把显示器插在树莓派上，而是要将画面显示在电脑显示器上。

输入以下命令

```shell
raspivid -o - -t 0 -hf -w 1280 -h 720 -fps 30 |cvlc -vvv stream:///dev/stdin --sout '#standard{access=http,mux=ts,dst=:8160}' :demux=h264
```

然后，需要在电脑上安装支持流媒体的播放器，这里推荐[potplayer](http://potplayer.daum.net/?lang=zh_CN) 和 [VLC media player](http://www.videolan.org/) 按下`ctrl u(for potplayer)` 或者`ctrl N(for vlc media palyer)`，将树莓派的ip地址给贴进去，这里我的树莓派的地址是`192.168.100.109`，你也可以输入

```shell
ifconfig | grep "inet addr"
```

来查看树莓派的IP地址，然后以`http://x.x.x.x:8160`的格式粘贴到播放器的框里面去，确定就OK了。

{% asset_img 2.jpg 给我的小风扇来张特写 %}

用这个方法简单一些，但是延迟非常高，图像质量也不怎么样，所以提供第二个办法

### mjpg-stream
用这个的话，延迟低了很多，并且质量也不错，极力推荐。


```shell
cd ~
sudo apt-get install cmake libjpeg8-dev git-core
git clone https://github.com/jacksonliam/mjpg-streamer
cd mjpg-streamer-master/mjpg-streamer-experimental/
make
```

这个时候可执行程序已经编译好了，可以选择执行`make install`来将软件安装到系统，也可以不安装，直接执行。

然后：

```shell
./mjpg_streamer -i "./input_raspicam.so -fps 30 -x 854 -y 480" -o "./output_http.so -w ./www"
```

这个时候，在谷歌浏览器或者火狐浏览器(IE和Edge浏览器不行)打开`http://x.x.x.x:8080/?action=stream`即可看到树莓派摄像头的画面。

或者将上面的地址粘贴到vlc media player里面去也可以看(potplayer不可以)。

### 参数调整

对于第一种办法，可以通过调整`-w -h -fps`来调整画面质量，还可以通过添加`-rot`参数来调整画面旋转角度。

对于第二种办法，可以通过调整`-x -y -fps`来调整画面质量，也可以通过添加`-rot`参数来调整画面旋转角度。

PS：

```
MJPG Streamer Version.: 2.0
 i: Using V4L2 device.: /dev/video0
 i: Desired Resolution: 640 x 480
 i: Frames Per Second.: -1
 i: Format............: JPEG
 i: TV-Norm...........: DEFAULT
ERROR opening V4L interface: No such file or directory
 Init v4L2 failed !! exit fatal
 i: init_VideoIn failed
```

这个错误是因为使用了不对等的输入文件，`input_raspicam.so`对应的是树莓派官方摄像头，而`input_uvc.so`对应的是USB摄像头。

对于两种命令的更多使用方法，查看文档咯。
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>关闭Chrome的“推荐的文章”</title>
    <url>/2017/08/31/close-suggested-article/</url>
    <content><![CDATA[
{% asset_img 1.png %}

<!-- more -->

手机版的Chrome打开会显示`推荐的文章`，`下载的内容`，`最近使用的书签`，作为资深强迫症，肯定是要把它去掉的。先放解决办法，在地址栏分别输入以下内容：

{% cq %}

~~chrome://flags/#enable-ntp-popular-sites~~

chrome://flags/#enable-ntp-remote-suggestions

{% endcq %}

然后改成“禁用”或者“disable”，Chrome会提示重启，重启后就没有了。

{% asset_img 2.png chrome://flags/#enable-ntp-popular-sites %}

{% asset_img 3.png chrome://flags/#enable-ntp-remote-suggestions %}

如上图，若要把`最近使用的书签`，`下载内容`也去掉，就在地址栏输入:

{% cq %}

chrome://flags/#enable-ntp-bookmark-suggestion

chrome://flags/#enable-ntp-offline-page-download-suggestions

chrome://flags/#enable-ntp-asset-download-suggetons

{% endcq %}

本来没有必要说的，百度一搜一大把，然而`其实百度得到的解决办法都是同一个，而且不生效`，或者说百度的办法已经失效，比如[此文](https://www.anfensi.com/news/127700.html)。默默的吐槽一下，转人家的文章转就转吧，不验证是否有用就算吧，还不标明文章出处，翻遍百度无果，求助谷歌，参考`https://www.reddit.com/r/Android/comments/6b3ubd/how_to_disable_in_chrome_58_new_tab_page_ntp/`，然而，其实此文也有误，去掉下载的内容的办法也不生效，所以写下此文。

都去掉之后，chrome打开就变成这样了

{% asset_img 4.png %}

{% cq %}生命重在折腾{% endcq %}
]]></content>
  </entry>
  <entry>
    <title>C/C++ 中，modulus，privateExponent, pulbicExponent 如何转换成 RSA密钥</title>
    <url>/2024/08/03/convert-RSA-key-with-openssl/</url>
    <content><![CDATA[
p.s: 以下内容均以 openssl 实现。
RSA 密钥的存储方式有很多，某些情况下，我们直接保存密钥的 modulus(n),publicExponent(e),privateExponent(d)，使用的时候再将它们转换成 RSA 密钥。下面来讲讲在 C/C++ 环境中，如何把这几个大整数转换成 RSA 密钥来用。
根据 openssl 的文档，openssl提供了这样一个函数

<!--more -->

```c
int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d);
```
这个参数里面的 n , e , q 对应 RSA 算法里面的参数，实际使用中，它们分别是
 - n --> modulus
 - e --> publicExponent
 - d --> privateExponent

其中，n和e组成了公钥，n和d组成私钥(取自 [RSA算法原理](https://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html))，那么，我们想用 modulus(n),publicExponent(e),privateExponent(q) 来生成一个RSA密钥使用的话，可以用下面这样简短的方式
```c
RSA* rsa = RSA_new();
BIGNUM* modulus = BN_new();
BIGNUM* publicExponent = BN_new();
BIGNUM* privateExponent = BN_new();
BN_hex2bn(&modulus,"the_modulus_hex_str");
BN_hex2bn(&publicExponent,"the_publicexponent_hex_str");
BN_hex2bn(&privateExponent,"the_privateexponent_hex_str");
RSA_set0_key(rsa,n,e,d);
```
其中，`the_modulus_hex_str` ，`the_publicexponent_hex_str`，`the_privateexponent_hex_str` 是指对应的巨大整数的十六进制字符串。例如
```
n: XXXXXX31C433EDD1B99CE2B218C253F46FDFFFB888B6CFC6B2ED7C733454E744BF95369DA3E6648AFB6FB11EF85A5BB25A1F328266844C2E3FAC8EFAAB4B2C45588604BAC6CF8A9B528F0D03E6B56BDE534B0360F1BD9E8B36D4197FE6F058D97DE670C0F178D9633FEEAE94237827A4006BC737344932E8F3E349F62175B7
e: 010001
d: XXXXXXX6566B839C1F88C15D1A46771F1E4C3918000787D56016208B758F3E1A33A923226850DA53C288F9CF6753DFBE48750A83B3DE58D5C0B85933C5B92ABCCD60D80992AABA03C3B1A7E58B8289A93383D8DAA4EE23178660D09E0335522EDCEAD84FB34D7A39B7794C905F15883FC8D1F3D57790259B4D51BA25F67D2D211
```
上面对应的巨大整数的十进制数为
```
n: XXXXXXX9057732971629580498028671059682869498690832625587443656573925941563146104539350008204291144532450083831552937873084816334755400478676505846850294967700928692649221538739009633205352515287702420255727528786212412171786407245232978625501660599119803054000638252479305264674077018562561222430729026237879
e: 65537
d: XXXXXXXX041865311331499528401083208041704898325216901065444649537573972168292421030450065823066407208305456734951704373218531670621023627175563960996010664960509836168571614423098404829680294776295068450558648709945648817915783177775326687433116356887666860252766677606932669252345719029413488408688871813075473
```
这样，我们就得到了一个RSA密钥。接下来可以使用这个密钥对一些数据加密/解密。
比如，使用 `RSA/ECB/PKCS1Padding` 填充方式，进行公钥加密，私钥解密例子
```c
    char encrypteddata[1024] = { 0 };
    char originnaldata[1024] = { 0 };
    const char* testinfo = "this is a sample info to encrypt";
    int encryptlen = 0;
    int retlen = 0;
    encryptlen = RSA_public_encrypt(strlen(testinfo), (const unsigned char*)testinfo, (unsigned char *)encrypteddata, rsa, RSA_PKCS1_PADDING);
    if (encryptlen > 0)
    {
        retlen = RSA_private_decrypt(encryptlen, (const unsigned char*)encrypteddata, (unsigned char*)originnaldata, rsa, RSA_PKCS1_PADDING);
        if (retlen > 0)
        {
            printf("%.*s\n", retlen, originnaldata);
        }
    }
```
openssl 里面，公钥加密，私钥解密的函数原型是
```c
 int RSA_public_encrypt(int flen, const unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding);

 int RSA_private_decrypt(int flen, const unsigned char *from,
                         unsigned char *to, RSA *rsa, int padding);
```
同样的，还有私钥加密，公钥解密的函数原型是
```
 int RSA_private_encrypt(int flen, unsigned char *from,
                         unsigned char *to, RSA *rsa, int padding);

 int RSA_public_decrypt(int flen, unsigned char *from,
                        unsigned char *to, RSA *rsa, int padding);
```]]></content>
      <tags>
        <tag>openssl</tag>
        <tag>RSA</tag>
      </tags>
  </entry>
  <entry>
    <title>CSGO联机的小事儿</title>
    <url>/2019/10/07/create-a-own-csgo-public-server/</url>
    <content><![CDATA[
## CS:GO 联机的那些事儿

CS也是一款相当经典的枪战游戏了，这几天琢磨了一些联机的事情，这里汇总一下。

## 局域网联机

搜到的资料大都不太全，并且是很老很老版本的CSGO，甚至是CS1.6版本，若是硬件条件满足的话，CSGO的体验会好一些。

局域网联机需要一个人打开“机器人练习赛”，然后打开任意地图，另外一个人在控制台输入 "connect x.x.x.x"，x.x.x.x 为先打开地图的人电脑的IP。

打开控制台需要在 设置/游戏设置/游戏/启用开发者控制台/是 ，然后按下 "`"，就是波浪线上的那个键。

<!-- more -->

## 远程联机

远程联机最方便的应该是官方匹配，不过我等菜鸡打官服总是一露面就被打死，对新手不太友好。那么我想与某个好友远程联机打机器人的话需要怎么办？

V 社官方提供了搭建CSGO服务器的办法：[https://developer.valvesoftware.com/wiki/Counter-Strike:_Global_Offensive_Dedicated_Servers](https://developer.valvesoftware.com/wiki/Counter-Strike:_Global_Offensive_Dedicated_Servers)

大多数时候按照这个链接做就可以了。建议先看官方的文档，我这里可能没有遇到某些问题。下面分为Windows和Linux两个平台讲述。

### Windows

无论是Windows还是Linux，首先我们都需要安装 [steamcmd](https://developer.valvesoftware.com/wiki/SteamCMD#Downloading_SteamCMD) ,对于Windows，可以直接下载[https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip](https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip)，解压到任意非Steam目录的文件夹，这里用D:\steamcmd做示范。
使用命令提示符(CMD),切到这个文件夹，直接输入 `steamcmd` ，然后输入 `login anonymous` ，也就是匿名登录，steamcmd 实际上是用来下载CSGO服务端（实际上也是Steamapps目录里面的客户端，猜测是服务端添加了某些启动参数），然后输入`force_install_dir D:\csgo\`，接着输入`app_update 740 validate`，这里的740指的就是CSGO，V设还提供了其他游戏的服务端，找对应的appid就可以。输完这个命令之后steamcmd就会把服务端下载到`D:\csgo\`，大小约20GB，用时看网速。

下载好之后输入`quit`即可退出当前终端。

然后进入`D:\csgo\`，输入`srcds -game csgo -console -usercon +game_type 0 +game_mode 0 +mapgroup mg_active +map de_dust2`即可开启一个服务器，这个时候局域网已经可以连接了，但是我们的目标是远程联机的话，还需要更多的参数。

这里参考了另外一个网站:[https://steamcn.com/t372733-1-1](https://steamcn.com/t372733-1-1)，但是这个链接的内容有误，按照里面给出的参数输入后没法连接。

上面的命令行仅支持LAN(局域网)连接，服务端判断局域网的条件是IP段为10.0.0.0-10.255.255.255,172.16.0.0-172.31.255.255,192.168.0.0-192.168.255.255。远程联机的时候，服务器需要运行在一台能在公网访问的电脑上，那么IP并不是这一段。我们需要更多的参数。

这里我们需要前往[https://steamcommunity.com/dev/managegameservers](https://steamcommunity.com/dev/managegameservers)申请一个用于验证的密钥，或者token，或者令牌，指的都是那一长串字母。

拿到令牌之后，输入`./srcds_run -game csgo -console -usercon +game_type 0 +game_mode 0 +mapgroup mg_active +map de_dust2 +sv_setsteamaccount XXXXXXXXXXXXXXXXXXXXXXXXXXXX -net_port_try 1 -nomaster -port 1234`，这里的 XXXXXXXXXXXXXX就是你申请到的令牌。这个时候在游戏内通过控制台输入`connect x.x.x.x:1234`就可以连接了。

需要留意的是，使用Windows时，开服务器的电脑不能启动CSGO游戏实例，原因自然也是服务端实际上只是特殊形式的客户端，或者说客户端只是特殊形式的服务端，V社应该没有做双开。

### Linux
Linux 相对 Windows 来说，可能是更多人会面临的搭建公网服务器的选择。
对于 Linux 系统，个人更加推荐首先阅读官方的教程。这里仅仅说一下大概的流程，先安装steamcmd，然后登陆steamcmd之后安装csgo的客户端（实际上也就是服户端，服务端的文件在steam里面直接安装的csgo的文件绝大部分是相同的，启动方式不太一样）。在启动的时候输入相应的启动参数，比如服务端的地图，难度，限制人数之类的快就可以启动了。

如果你有一个公网上运行的电脑倒是相当方便，和Windows几乎一样，如果没有的话，你需要弄一些端口转发之类的操作。
]]></content>
  </entry>
  <entry>
    <title>Linux的中文乱码问题</title>
    <url>/2017/05/27/encoding-on-linux/</url>
    <content><![CDATA[{% asset_img 1.jpg 当当当 %}
<!-- more -->
## 乱语
在Linux经常遇到中文乱码的情况，整理一下:
1. 字符集不能显示中文;
2. 终端不能正常显示中文;
3. 文件名本身便是乱码的(多见于 Windows 下拷贝文件到 Linux )。

## 解决方案
1. 字符集的问题，大多数情况下，在终端里面输入`locale`,查看当前系统所支持的字符集，改变当前用户或者系统的字符集，就可以了。如图{% asset_img 2.jpg %}带`utf-8`的都可以显示中文，在终端输入
```bash
echo export LANG=zh-CN.UTF-8 >> .bashrc
source .bashrc
```
  来改变当前用户所使用的字符集就可以了；
2. 第二种，终端问题，症状表现为，在GUI界面或者Windows的xshell、putty、cmder远程ssh登录Linux可以正常显示中文，但是Linux主机连接显示器之后，在tty界面(亦称纯字符界面，按ctrl + Alt + F1/2/3/4/5/6可以打开)中文显示为方框或者问号。百度得到的答案有两种——安装zhcon或者fbterm，经试验，[fbterm](https://zh.opensuse.org/SDB:Fbterm)表现效果较佳；
3. 第三种的话，给文件名的编码方式改一下就好，可参考[此文章](http://blog.sina.com.cn/s/blog_7842b12b01018pzl.html)。

## PS
为了兼容各种语言，生出了N多字符集，若是能够大一统，自然最好了，省得折腾。不过由于各种纠纷，就算有一个字符集能够显示所有文字，还是没办法统一起来。
至于tty界面下无法正常显示中文，是因为内核上不支持，可以通过为内核安装补丁解决，也可以通过安装`fbterm`这样的类终端软件解决，能搞定就好了，管他呢。
{% cq %} 生命重在折腾 {% endcq %}
]]></content>
      <tags>
        <tag>Linux</tag>
      </tags>
  </entry>
  <entry>
    <title>Linux 系统中，gets函数出错</title>
    <url>/2017/01/08/error-in-Linux-when-use-C-language/</url>
    <content><![CDATA[其实这是在很早之前就遇到的问题，这样一个简单的程序
```C
#include<stdio.h>
int main()
{
        char str[100];
        gets(str);
        printf("%s\n",str);
}
```
<!-- more -->
## 解决办法
在Linux中使用`gcc`编译这段代码的时候，出现如下错误
```bash
warning: 'gets' is deprecated (declared at /usr/include/stdio.h:638) [-Wdeprecated-declarations]
  gets(str);
  ^
/tmp/ccf5cnfv.o: In function `main':
test.c:(.text+0x10): warning: the `gets' function is dangerous and should not be used.
```
最后一行说了，gets函数是危险的，不应该被使用。
当初人比较二的时候，用了这样一个[办法](http://www.cnblogs.com/hushuangpu/p/5271464.html),发在了博客园。
现在感觉有诸多漏洞，还是补一下比较好。
求助google，在stackoverflow找到了[解决办法](http://stackoverflow.com/questions/2843073/warninggets-function-is-dangerous)
这样做
```C
#include<stdio.h>
int main()
{
        char str[100];
        fgets(str,100,stdin );
        printf("%s\n",str);
}
```
使用`fgets`函数来代替`gets`函数，但是实际上这里仍然有局限性，fgets函数中的第二个参数限制了能输入的字符数目，似乎我比较二的时候，想出来的解决办法更好呢^_^
## 原因说明
*If you have code like this:*
```C
char s[10];
gets( s );
```
*and you type in more than 10 characters when the program is run, you will overflow the buffer, causing undefined behaviour. The gets() function has no means of preventing you typing the characters and so should be avoided. Instead you should use fgets(), which allows you to limit the number of characters read, so that the buffer does not overflow.:*
```C
char s[10];
fgets( s, 10, stdin );
```
*The puts() function is perfectly safe, provided the string that you are outputting is null-terminated.*
不想用机翻的来给你看，将就一下 =_=

{% cq %} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>C</tag>
        <tag>C++</tag>
        <tag>Linux</tag>
      </tags>
  </entry>
  <entry>
    <title>Minecraft正版服无法登录</title>
    <url>/2018/05/26/error-of-minecraft/</url>
    <content><![CDATA[
{% asset_img 1.jpg %}

<!-- more -->

## 问题描述

 - 西电的校园网和翼讯环境均无法成功登录客户端
 - 电脑开启代理之后，客户端能登录成功，游戏内仍然无法连接正版服
 - 手机（联通）开热点之后，能连接正版服，本地开启的服务器（开启了正版验证）也能登录了

排除被mojang ban掉，更换dns无效，推测是西电的网络环境的锅。

经常跨地域更换IP，账号有可能会被Mojang ban掉，所以不想总是开着vps得代理，并且远程的vps很干扰正常使用。

解决办法如下，开启系统代理，客户端成功登录之后，给jvm设置代理参数，让Minecraft运行的时候走代理，这样就不用在电脑上常开代理了。

在启动选项里，填入jvm的代理参数，代理参数有如下几种
### http
 - -DhttpProxyHost=x.x.x.x
 - -DhttpProxyPort=xxx
### https
 - -DhttpsProxyHost=x.x.x.x
 - -DhttpsProxyPort=xxx
### socks
 - -DsocksProxyHost=x.x.x.x
 - -DsocksProxyPort=xxx

{% asset_img 2.png %}]]></content>
  </entry>
  <entry>
    <title>Gcc静态编译</title>
    <url>/2017/08/25/gcc-static/</url>
    <content><![CDATA[
{% asset_img 5.png %}

<!-- more -->

用Gcc(G++)编译一个小程序的时候，本地主机配置好了环境，默认的编译命令使用了动态链接库，这样编译出来的程序在本地主机上是可以直接运行的，并且这样的小程序有另外一个好处——体积特别小，因为动态链接库已经在本地主机上了，不必另外安装，可是把这个小程序拷贝到另外一个电脑上去的话，问题就来了，总是提示缺少"***.dll"文件，解决办法是将动态链接库一起拷贝过去，缺哪一个就拷贝哪一个，另外一个问题又来了，有时候动态链接库还挺大的，数目还不少，对于一些仅有几MB的文件来说，带着一大堆".dll"文件简直可以逼死强迫症，然后，静态编译就派上用场啦。

## 情景再现

{% asset_img 1.png %}

如图，用默认的动态编译命令，生成的debug版本可执行文件仅有212KB，Release版本仅有157KB，若没有配置环境变量，运行这个程序则会得到如下提示：

{% asset_img 2.png %}

并不一定是缺少图中的"libstdc++-6.dll"文件，具体缺少哪些文件是源代码确定的，一劳永逸的办法是使用静态编译命令，这样用到的动态链接库可以集成到可执行文件里面去，直接拷贝到另外一台电脑就可以用了，方法是，最后生成可执行文件时，加上`-static`参数

## CodeBlocks实现

依次点击`Setting`--->`Complier settings`--->`Linker Settings`，将参数填在如图的框里面：

{% asset_img 3.png %}

静态编译生成的可执行文件体积较大，这里生成的debug版本的可执行文件体积已经达到`1540KB`，差不多变大了六倍吧，Release版本的达到`798KB`，对于数MB的小程序来说，用静态编译很合适，免去了各种".dll"文件缺失的麻烦，把静态编译生成的Release版本的可执行文件拷贝给别人就好了，dll文件可以不用管。

{% asset_img 4.png %}

动态编译还是有好处的，链接库只用安装一次，所有用到该链接库的程序就不用自带链接库，程序的体积会变得小一点。

_似乎说了一大堆废话_╮(╯-╰)╭

{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>gcc</tag>
      </tags>
  </entry>
  <entry>
    <title>在Linux中获取可更新软件的下载地址</title>
    <url>/2017/03/12/get-the-download-link-of-the-upgradeble-software-on-Linux/</url>
    <content><![CDATA[{% asset_img 1.jpg 啊哈哈哈哈哈~~~~~ %}
<!-- more -->
## 背景描述:
依旧是之前遇到的问题————更新软件超级慢。
虽然之前在之前的[文章](https://bdznh.github.io/2017/01/25/use-proxy-in-terminal/)中提及过，可以使用代理来更新软件源，但是有时候就算代理了速度也很慢，区区几M的软件需要花费数个小时才能下载好。
所以有了此文。
## 目标
获取到想要更新的软件的下载地址，然后用IDM、迅雷、aria2c之类的下载工具来下载，速度会快很多。
## 实施步骤
### 原理说明
在文章[http://www.cnblogs.com/hushuangpu/p/5247084.html](http://www.cnblogs.com/hushuangpu/p/5247084.html)中提到过一点。根据当初我编写该文时的状况来看，在更新软件的时候，若遇到网络故障(比如该文中的IPv4不能联网或者干脆断网的情况下)，则`apt-get`会报错，我们便能在报错信息里面看到软件的下载地址了。
### 实战
为了能让Linux网络正常的情况下，使用`apt-get`时无法正常连接网络，我们还需要动一些小手段。
我是这么干的：
[安装Proxychains](https://bdznh.github.io/2017/01/25/use-proxy-in-terminal/)，但是不开启本地的socks5代理端口，这样Proxychains将`apt-get`的网络访问劫持到该端口的时候，发现没有网络，便会报错，方便我们拿到软件的下载地址。
### 下载软件
得到了软件的下载链接之后，直接用下载工具下载好之后，把文件复制到`/var/cache/apt/archives/`，再通过`sudo apt-get upgrade`即可飞速更新软件。

通过此法，我成功的把原本需要一个半小时才能更新完软件的时间缩短到10分钟。此处脑补一个得瑟表情。

{% cq %}生命重在折腾{% endcq %}
]]></content>
      <tags>
        <tag>Linux</tag>
      </tags>
  </entry>
  <entry>
    <title>一个在线的文件浏览器</title>
    <url>/2018/03/30/h5ai/</url>
    <content><![CDATA[之前租的VPS过期了，折折腾腾，修修补补又换回搬瓦工，用上了久负盛名的CN2路线，表现比之前的digitalocean好多了，digitalocean的优势在于同时支持BBR和IPv6，搬瓦工这边BBR和IPv6只能二选一，虽然已经有在openVz上安装BBR的方法，但是效果并不是很好，今年翼讯升级了一下，比以往好用得多，于是选了有BBR的版本。
有这样一个长期开机的东西，自然不会让它吃灰，，目前的打算是让它作为一个下载中转站，aria2开服下载，h5ai作为在线文件浏览器，抽空可以从VPS上高速把文件弄回来。

{% asset_img 1.png h5ai show %}

<!-- more -->

## 安装[h5ai](https://larsjung.de/h5ai/)

[h5ai](https://larsjung.de/h5ai/)是一个非常美观的目录列表程序，如上图，安装h5ai之后，可以实现在线的文件浏览，安装相应的依赖之后，可以在线预览文件，包括图片、视频和压缩包，可以说是相当的方便了，装在树莓派上的话，就可以让树莓派把视频下载好，直接观看了，不用传回电脑来。

### 安装准备

提前安装好nginx（其实在装好PHP之后安装也是可以的）

```bash
yum install nginx -y #for CentOS

# OR

sudo apt install nginx #for Ubuntu/debian

```


### 安装PHP

h5ai依赖于PHP运行，h5ai本身的安装并不复杂，就整个过程而言，复杂的是安装PHP，CentOS 7.4 所携带的PHP版本最高到 PHP 5.4， h5ai要求的PHP为5.5+，刚好不符合要求，下面先放安装PHP的过程。

#### 在CentOS上安装PHP

```bash
rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm
yum --enablerepo=remi,remi-php72 install nginx php-fpm php-common
yum --enablerepo=remi,remi-php72 install php-opcache php-pecl-apcu php-cli php-pear php-pdo php-mysqlnd php-pgsql php-pecl-mongodb php-pecl-redis php-pecl-memcache php-pecl-memcached php-gd php-mbstring php-mcrypt php-xml
service php-fpm start
```

这里使用了第三方库，自行编译有很多需要配置的地方，很容易出错，尝试了很多次，总是有点毛病，还是回头用了这个办法。

#### 在Ubuntu/debian上安装PHP

在Ubuntu/debian上安装PHP相对来说方便得多了

```bash
sudo apt update 
sudo apt install php-fpm -y
```

### 配置nginx

向nginx的配置内的server段写入以下内容

```bash
        location ~ \.php$ {
                include /etc/nginx/fastcgi_params;
                fastcgi_pass  127.0.0.1:9000;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        }
```

并且更改`index`段内容为`index  index.html  index.php  /_h5ai/public/index.php;`
然后

```bash
sudo nginx -t
sudo nginx -s reload
```

`-t`提示都OK的话，这个时候nginx已经能识别PHP了。

如果出现错误`nginx: [error] invalid PID number "" in "/usr/local/var/run/nginx/nginx.pid"`,那么使用命令

```bash
sudo nginx -c /etc/nginx/nginx.conf
sudo nginx -s reload
```

这个时候PHP应该已经安装好并且已经启动了，到nginx的工作目录`/var/www/html/`或者`/usr/share/nginx/html/`（一般在这两个位置，），新建一个php文件，比如`vim /usr/share/nginx/html/index.php`，按`I`键进入编辑模式，添加以下内容

```bash
<?php
    phpinfo();
```

这个时候，打开如下链接`http://x.x.x.x/index.php`(x.x.x.x是VPS的公网IP地址)，出现如下画面表示安装成功

{% asset_img 2.png PHP is OK. %}

### 安装h5ai

到[作者的网站](https://larsjung.de/h5ai/)下载源码包到nginx的工作目录并解压

```
cd /usr/share/nginx/html #or use: cd /var/www/html/
wget https://release.larsjung.de/h5ai/h5ai-0.29.0.zip
unzip h5ai-0.29.0.zip
```

这个时候，访问`http://x.x.x.x/_h5ai/public/index.php`，出现如下画面表示`h5ai`安装成功

{% asset_img 4.jpg %}

{% asset_img 3.jpg %}

访问`http://x.x.x.x/`，可以看到nginx的工作目录里面的文件（PS：不能含有index.html,index.php）

{% asset_img 5.jpg %}

## 安装aria2

在Debian/Ubuntu上直接执行`sudo apt-get install aria2`就能安装好了，版本相对来说也较新，在Cent OS上可以执行`sudo yum install aria2`来安装，然而，一如既往的是老掉牙的版本，虽然说一味追求新版并无实在的意义，但是某些功能旧版本是没有的啊啊啊~~
可以自己编译安装aria2

```bash
sudo apt-get install build-essential libgnutls-dev nettle-dev libgmp-dev libssh2-1-dev libc-ares-dev libxml2-dev zlib1g-dev libsqlite3-dev pkg-config -y # For Debian/Ubuntu
# OR
sudo yum groupinstall "Development Tools" -y && yum install gettext-devel gnutls-devel nettle-devel gmp-devel libssh2-devel c-ares-devel libxml2-devel zlib-devel sqlite-devel pkgconfig libgcrypt-devel libssl-devel libtool autoconf automake autotools autopoint #For Centos
wget https://github.com/aria2/aria2/releases/download/release-1.33.1/aria2-1.33.1.tar.gz
tar -zxf aria2-1.33.1.tar.gz
cd aria2-1.33.1
autoreconf -i
./configure 
make 
sudo make install
```

在执行`./configure`的时候报的错误基本上都是缺少依赖，少谁装谁就好。
静态编译参数`./configure ARIA2_STATIC=yes`编译出来的程序体积巨大，动态链接的程序只有2M+，静态编译出来之后达到75M+。

### 配置aria2

可以参考[https://blog.icehoney.me/posts/2015-01-31-Aria2-download](https://blog.icehoney.me/posts/2015-01-31-Aria2-download)，新建配置文件`vim aria2c.conf`，添加以下内容

```bash
#用户名
#rpc-user=user
#密码
#rpc-passwd=passwd
#上面的认证方式不建议使用,建议使用下面的token方式
#设置加密的密钥
#rpc-secret=token
#允许rpc
enable-rpc=true
#允许所有来源, web界面跨域权限需要
rpc-allow-origin-all=true
#允许外部访问，false的话只监听本地端口
rpc-listen-all=true
#RPC端口, 仅当默认端口被占用时修改
#rpc-listen-port=6800
#最大同时下载数(任务数), 路由建议值: 3
max-concurrent-downloads=5
#断点续传
continue=true
#同服务器连接数
max-connection-per-server=5
#最小文件分片大小, 下载线程数上限取决于能分出多少片, 对于小文件重要
min-split-size=10M
#单文件最大线程数, 路由建议值: 5
split=10
#下载速度限制
max-overall-download-limit=0
#单文件速度限制
max-download-limit=0
#上传速度限制
max-overall-upload-limit=0
#单文件速度限制
max-upload-limit=0
#断开速度过慢的连接
#lowest-speed-limit=0
#验证用，需要1.16.1之后的release版本
#referer=*
#文件保存路径, 默认为当前启动位置
dir=/home/acgotaku/Downloads
#文件缓存, 使用内置的文件缓存, 如果你不相信Linux内核文件缓存和磁盘内置缓存时使用, 需要1.16及以上版本
#disk-cache=0
#另一种Linux文件缓存方式, 使用前确保您使用的内核支持此选项, 需要1.15及以上版本(?)
#enable-mmap=true
#文件预分配, 能有效降低文件碎片, 提高磁盘性能. 缺点是预分配时间较长
#所需时间 none < falloc ? trunc << prealloc, falloc和trunc需要文件系统和内核支持
file-allocation=prealloc
```

使用命令`aria2c --conf-path aria2c.conf -D`让aria2c后台运行，然后去往[https://github.com/ziahamza/webui-aria2](https://github.com/ziahamza/webui-aria2)下载好整个仓库，双击`indel.html`，然后将`设置/连接设置`里面的主机设置为VPS的IP地址。

整个思路就是aria2c后台运行，本地的webui可以直接向VPS发出下载命令，下载好之后，打开h5ai的的页面查看文件，然后再从VPS上下载回本地。
]]></content>
  </entry>
  <entry>
    <title>Hello World</title>
    <url>/2016/03/25/hello-world/</url>
    <content><![CDATA[Welcome to [Hexo](https://hexo.io/)! This is your very first post. Check [documentation](https://hexo.io/docs/) for more info. If you get any problems when using Hexo, you can find the answer in [troubleshooting](https://hexo.io/docs/troubleshooting.html) or you can ask me on [GitHub](https://github.com/hexojs/hexo/issues).
<!-- more -->
## Quick Start

### Create a new post

``` bash
$ hexo new "My New Post"
```

More info: [Writing](https://hexo.io/docs/writing.html)

### Run server

``` bash
$ hexo server
```

More info: [Server](https://hexo.io/docs/server.html)

### Generate static files

``` bash
$ hexo generate
```

More info: [Generating](https://hexo.io/docs/generating.html)

### Deploy to remote sites

``` bash
$ hexo deploy
```

More info: [Deployment](https://hexo.io/docs/deployment.html)
]]></content>
  </entry>
  <entry>
    <title>安卓应用崩溃的时候发生了什么</title>
    <url>/2021/03/27/how-does-android-app-crash/</url>
    <content><![CDATA[
安卓应用崩溃大致上可以分为java调用时的崩溃和native代码调用时的崩溃（我个人这样分）。下面我们分别看看这两种情况下，具体是如何崩溃的。

<!-- more -->

## java 调用崩溃

我们看下面这样一段代码，在没有为 mButton 绑定view的情况下，为他设置一个 onClickListener
```
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "testapp";
    Button mButton = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate");
    }

    public void click(View view) {
        mButton.setOnClickListener(new View.OnClickListener(){
            @Override
            public void onClick(View v) {
                Log.d(TAG,"clicked");
            }
        });
    }
}
```

调用到 click 这个函数，正如预期的那样，应用崩溃了。

```
03-27 23:36:32.936 32641 32641 D testapp : onCreate
03-27 23:36:55.858 32641 32641 E AndroidRuntime: FATAL EXCEPTION: main
03-27 23:36:55.858 32641 32641 E AndroidRuntime: Process: com.example.crashinfo, PID: 32641
03-27 23:36:55.858 32641 32641 E AndroidRuntime: java.lang.IllegalStateException: Could not execute method for android:onClick
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at androidx.appcompat.app.AppCompatViewInflater$DeclaredOnClickListener.onClick(AppCompatViewInflater.java:414)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.view.View.performClick(View.java:7448)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at com.google.android.material.button.MaterialButton.performClick(MaterialButton.java:992)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.view.View.performClickInternal(View.java:7425)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.view.View.access$3600(View.java:810)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.view.View$PerformClick.run(View.java:28305)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.os.Handler.handleCallback(Handler.java:938)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.os.Handler.dispatchMessage(Handler.java:99)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.os.Looper.loop(Looper.java:223)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at android.app.ActivityThread.main(ActivityThread.java:7656)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at java.lang.reflect.Method.invoke(Native Method)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:592)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:947)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: Caused by: java.lang.reflect.InvocationTargetException
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at java.lang.reflect.Method.invoke(Native Method)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at androidx.appcompat.app.AppCompatViewInflater$DeclaredOnClickListener.onClick(AppCompatViewInflater.java:409)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	... 12 more
03-27 23:36:55.858 32641 32641 E AndroidRuntime: Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.widget.Button.setOnClickListener(android.view.View$OnClickListener)' on a null object reference
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	at com.example.crashinfo.MainActivity.click(MainActivity.java:23)
03-27 23:36:55.858 32641 32641 E AndroidRuntime: 	... 14 more
```

通过前面的 PID 可以知道，实际上这些崩溃信息是应用的进程打出来的。也就是说，崩溃信息打印出来的时候，应用的进程还没有退出。

通过在系统里面加log可以看到，崩溃的信息是这里打印出来的
```java
    // ANDROID_ROOT/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    /**
     * Logs a message when a thread encounters an uncaught exception. By
     * default, {@link KillApplicationHandler} will terminate this process later,
     * but apps can override that behavior.
     */
    private static class LoggingHandler implements Thread.UncaughtExceptionHandler {
        public volatile boolean mTriggered = false;

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            mTriggered = true;

            // Don't re-enter if KillApplicationHandler has already run
            if (mCrashing) return;

            // mApplicationObject is null for non-zygote java programs (e.g. "am")
            // There are also apps running with the system UID. We don't want the
            // first clause in either of these two cases, only for system_server.
            if (mApplicationObject == null && (Process.SYSTEM_UID == Process.myUid())) {
                Clog_e(TAG, "*** FATAL EXCEPTION IN SYSTEM PROCESS: " + t.getName(), e);
            } else {
                StringBuilder message = new StringBuilder();
                // The "FATAL EXCEPTION" string is still used on Android even though
                // apps can set a custom UncaughtExceptionHandler that renders uncaught
                // exceptions non-fatal.
                message.append("FATAL EXCEPTION: ").append(t.getName()).append("\n");
                final String processName = ActivityThread.currentProcessName();
                if (processName != null) {
                    message.append("Process: ").append(processName).append(", ");
                }
                message.append("PID: ").append(Process.myPid());
                Clog_e(TAG, message.toString(), e);
            }
        }
    }
```
并且我们在同一个文件下面不远处可以看到这样一段代码
```java
@Override
public void uncaughtException(Thread t, Throwable e) {
    try {
        ......
    } catch (Throwable t2) {
        ......
    } finally {
        // Try everything to make sure this process goes away.
        Process.killProcess(Process.myPid());
        System.exit(10);
    }
}
```

`Process.killProcess(Process.myPid());`这样传入了当前进程的 PID ，查看 `Process.killProcess();` 的实现

```java
//frameworks/base/core/java/android/os/Process.java
/**
    * Kill the process with the given PID.
    * Note that, though this API allows us to request to
    * kill any process based on its PID, the kernel will
    * still impose standard restrictions on which PIDs you
    * are actually able to kill.  Typically this means only
    * the process running the caller's packages/application
    * and any additional processes created by that app; packages
    * sharing a common UID will also be able to kill each
    * other's processes.
    */
public static final void killProcess(int pid) {
    sendSignal(pid, SIGNAL_KILL);
}
```
这里的`SIGNAL_KILL`的值是9。到这里其实我们大概能猜出来了，给当前的 PID 的进程发送了信号 9 。kernel接受到这个信号之后将会直接杀死对应的进程。
sendSignal的实现如下
```java
    //frameworks/base/core/java/android/os/Process.java
    /**
     * Send a signal to the given process.
     * 
     * @param pid The pid of the target process.
     * @param signal The signal to send.
     */
    public static final native void sendSignal(int pid, int signal);
```
可以看到这里实际上通过jni调用到了一个native上的接口，顺着找下去，可以看到

```c++
//frameworks/base/core/jni/android_util_Process.cpp
void android_os_Process_sendSignal(JNIEnv* env, jobject clazz, jint pid, jint sig)
{
    if (pid > 0) {
        ALOGI("Sending signal. PID: %" PRId32 " SIG: %" PRId32, pid, sig);
        kill(pid, sig);
    }
}
```

`kill`的原型是`int kill(int pid,int sig);`，是Linux的一个用于向指定 PID 的进程或进程组发送信号的函数。

综上所述，安卓应用调用java代码发生异常而崩溃时，实际上是应用自己调用 kill 来使应用所在的进程直接被杀死。相应的，应用可以自己捕捉到java代码上的异常来防止应用崩溃(闪退)。

## native 调用时的崩溃

native调用时的崩溃与Linux上的C/C++程序崩溃的行为很像，我们写这样一个简单的jni调用来让安卓应用崩溃
]]></content>
  </entry>
  <entry>
    <title>在 Ubuntu 内如何更改 Chrome 的语言</title>
    <url>/2021/09/22/how-to-change-chrome-language-in-ubuntu/</url>
    <content><![CDATA[
在 Ubuntu(20.04) 内更改 Chrome 的语言时，并没有像是 Windows 的`以这种语言显示 Google Chrome`的选项。最多也只能修改提示翻译的优先语言。没有严格意义上的“更改显示语言”的选项。
在 Ubuntu 上，Chrome的显示语言可以根据系统语言变化，一种办法是将系统语言设置成你想要显示的语言，但是对于中文用户来说，更多的场景可能是系统语言是英文，应用语言是中文，比如这里的Chrome。如果你是我所说的这种情况，那么本文的内容可能对你有帮助。

{% asset_img 1.png %}

<!-- more -->

在你的终端尝试以下命令
```bash
LANGUAGE=zh_cn google-chrome
```

此时如果启动 Chrome 能显示中文的话，我们的需求已经满足一大半了。如果使用命令行即可满足需求的话，就截至这里就可以了。

Ubuntu 的任务栏可以将常用的 APP 钉在这里(Ubuntu 称为 favorite)，那么如何更改从这里启动的 Chrome的语言呢？ 
通过搜索引擎可以知道，这个 favorite 对应的文件在 `/usr/share/applications` ，我们找到 Chrome 对应的文件 `/usr/share/applications/google-chrome.desktop`，查看其内容
```bash
[Desktop Entry]
Version=1.0
Name=Google Chrome
# Only KDE 4 seems to use GenericName, so we reuse the KDE strings.
# From Ubuntu's language-pack-kde-XX-base packages, version 9.04-20090413.
GenericName=Web Browser
......
Exec=/usr/bin/google-chrome-stable %U
StartupNotify=true
Terminal=false
Icon=google-chrome
Type=Application
Categories=Network;WebBrowser;
......
```
如果你注意到了 `Exec=/usr/bin/google-chrome-stable` 字段，那么你肯定能猜到，我们可以为这个可执行程序添加命令行参数`LANGUAGE=zh_cn`来让Chrome启动时以中文启动。遗憾的是，这里不行。直接加在这里不仅无法使用，而且还会导致 GNOME 桌面找不到 Chrome 了。
下面是我的解决办法
```
touch chrome_cn.sh
echo "#!/bin/bash" > chrome_cn.sh
echo "LANGUAGE=zh_cn /usr/bin/google-chrome-stable $@" >> chrome_cn.sh
sudo cp -f chrome_cn.sh /usr/bin/chrome_cn.sh
```
然后将 `/usr/share/applications/google-chrome.desktop` 里的所有 `/usr/bin/google-chrome-stable` 换成 `/usr/bin/chrome_cn.sh` 。让我们点击图标的时候，实际执行的是一个 sh 脚本，然后把 `LANGUAGE=zh_cn` 写在脚本里，让脚本去启动 Chrome ，这样就可以让桌面上任务栏启动的 Chrome 变成中文了。

最好不要直接更改 `LANGUAGE` 这个环境变量的值，这个值与系统语言相关。]]></content>
  </entry>
  <entry>
    <title>如何控制 Yeelight 台灯</title>
    <url>/2019/04/13/how-to-control-Yeelight/</url>
    <content><![CDATA[
{% asset_img 1.jpg %}

其实 Yeelight 官方描述已经足够，但是对于入门的人来说并不够详细，官方对于 Yeelight 产品的局域网控制功能在这里有说明 [https://www.yeelight.com/zh_CN/developer](https://www.yeelight.com/zh_CN/developer)，同样也有详细的[文档](https://www.yeelight.com/download/Yeelight_Inter-Operation_Spec.pdf)。本文只是略微做一些说明。

<!-- more -->

Yeelight 产品的局域网控制分为两步
 - 发送 ssdp 消息，获取产品的信息；(这里是通过udp发送一个特定字符串，接收yeelight发回的消息，其内包含这个设备的IP地址和TCP端口)
 - 根据信息，发送控制信息。(通过上一个步骤拿到的地址和端口使用tcp连接到yeelight设备，然后通过tcp连接发送控制消息，控制消息的具体格式在官方文档中有说明)

向239.255.255.250:1982 发送一条消息

```
M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1982\r\nMAN: "ssdp:discover"\r\nST: wifi_bulb
```

在本例中，米家智能台灯会返回一下消息：
```
HTTP/1.1 200 OK
Cache-Control: max-age=3600
Date:
Ext:
Location: yeelight://192.168.100.100:55443
Server: POSIX UPnP/1.0 YGLC/1
id: 0x0000000002c5343e
model: desklamp
fw_ver: 58
support: get_prop set_default set_power toggle set_ct_abx set_bright start_cf stop_cf set_scene cron_add cron_get cron_del set_adjust adjust_bright adjust_ct set_name
power: on
bright: 60
color_mode: 2
ct: 4000
rgb: 0
hue: 0
sat: 0
name:
```

以上信息中，"Location: yeelight://192.168.100.100:55443"是比较关键的信息，这里包含了米家智能台灯的IP地址和tcp控制端口，通过tcp连接台灯之后，向台灯发送控制消息即可。下面是一些示范。

## 扫描 Yeelight 设备

```C++
#include <stdio.h>
#include <winsock2.h>
#include <WS2tcpip.h>

#pragma comment(lib, "ws2_32.lib") 

int main(int argc, char* argv[])
{
	WORD socketVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(socketVersion, &wsaData) != 0)
	{
		return 0;
	}
	SOCKET sclient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(1982);
	inet_pton(AF_INET, "239.255.255.250" ,&sin.sin_addr.S_un.S_addr);
	int len = sizeof(sin);

	const char * sendData = "M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1982\r\nMAN: \"ssdp:discover\"\r\nST: wifi_bulb";
	int result = sendto(sclient, sendData, strlen(sendData), 0, (sockaddr *)&sin, len);
	printf("send data size: %d\n", result);

	char recvData[1024];
	int ret = recvfrom(sclient, recvData, 1024, 0, (sockaddr *)&sin, &len);
	if (ret > 0)
	{
		recvData[ret] = 0x00;
		printf(recvData);
	}

	closesocket(sclient);
	WSACleanup();
	return 0;
}
```
需要注意的是，发送扫描信息需要使用udp方式，并且发送扫描信息和接收响应信息需要通过同一个sockt。

## 控制 Yeelight 设备

```C++
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")

#define REMOTE_IP "127.0.0.1"
#define REMOTE_PORT 8080

int main()
{
	//初始化winsock服务
	WSADATA wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);

	//创建socket
	SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	struct sockaddr_in svraddr;
	svraddr.sin_family = AF_INET;
	svraddr.sin_port = htons(55443);
	svraddr.sin_addr.s_addr = inet_addr("192.168.100.100");

	//连接socket
	if (connect(sock, (struct sockaddr*)&svraddr, sizeof(svraddr)) != -1)
	{
		//发送数据给服务端
		Sleep(1000);
		
		//printf("%s", sendbuf);
		int sw = 0;
		char sendbuf1[] = "{\"id\":1,\"method\":\"set_bright\",\"params\":[100,\"smooth\",500]}\r\n";
		char sendbuf2[] = "{\"id\":1,\"method\":\"set_bright\",\"params\":[10,\"smooth\",500]}\r\n";
		char buf[1024] = { 0 };
		while (scanf("%d",&sw)!=0)
		{
			switch (sw) {
			case 1:
				
				printf("%s", sendbuf1);
				if (send(sock, sendbuf1, strlen(sendbuf1), 0) != -1)
				{
					//接收服务端数据
					//Sleep(1000);
					
					if (recv(sock, buf, 1024, 0) > 0)
					{
						printf("recv server: \r\n %s\r\n", buf);
					}
					memset(buf, 0, 1024);
				}
				break;
			case 2:
				
				printf("%s", sendbuf2);
				if (send(sock, sendbuf2, strlen(sendbuf2), 0) != -1)
				{
					//接收服务端数据
					//Sleep(1000);
					//char buf[1024] = { 0 };
					if (recv(sock, buf, 1024, 0) > 0)
					{
						printf("recv server: \n %s\n", buf);
					}
					memset(buf, 0, 1024);
				}
				break;

			}
			if (sw == 3)
				break;
		}
		
	}
	else
	{
		printf("can not connect server\n");
	}

	//关闭socket
	closesocket(sock);

	//关闭winsock服务
	WSACleanup();
	getchar();
	return 0;
}
```
{% asset_img 2.jpg %}

在台灯开启的情况下，输入1或者2进行亮度调节，输入3退出。

更多更详细的控制信息可以阅读[官方文档](https://www.yeelight.com/download/Yeelight_Inter-Operation_Spec.pdf)。]]></content>
      <tags>
        <tag>Yeelight</tag>
        <tag>SSDP</tag>
        <tag>ssdp</tag>
      </tags>
  </entry>
  <entry>
    <title>如何部署 perfetto ui</title>
    <url>/2024/07/29/how-to-deploy-own-perfetto-ui/</url>
    <content><![CDATA[
perfetto 是从安卓9.0开始可用的安卓系统性能监测相关的一个工具，可以参考官网： [perfetto](https://developer.android.google.cn/studio/command-line/perfetto?hl=zh_cn)
通常我们使用 ui.perfetto.dev 来查看从系统里面抓取到的信息，这个网站是可以离线使用的，但是某些时候，我们需要将这个网站离线或者部署到内网使用，这里我们主要参考 [Perfetto build instruction](https://perfetto.dev/docs/contributing/build-instructions#ui-development)。p.s: 官网是更加详细的，这里只是简单总结一下步骤。

<!-- more -->

# 下载源码
你可以通过这样一条命令下载到源码
```bash
git clone https://android.googlesource.com/platform/external/perfetto/
```
做Android Framework或者固件的人一样就能看出来了，这条命令下载了AOSP源码下的`platform/external/perfetto`，下载到源码的方式还有很多，例如Github上 [perfetto](https://github.com/google/perfetto)。

# 下载依赖
下载需要外网环境和Linux系统
```bash
cd perfetto
tools/install-build-deps --ui
```
这里最好使用Ubuntu环境，并且需要安装 3.7 版本以上的 python3，如果不想破坏宿主机环境，可以用虚拟机或者docker来解决。
这一步视网络环境，下载时间在 10min~30min 左右。

# 编译运行
p.s 这一步可能需要 16GB 内存，我用12GB内存的虚拟机是跑不起来的
执行下面的命令即可编译并运行
```bash
ui/run-dev-server
```
成功运行之后，你会看到类似下图的信息，如果你是在本地编译运行，这个时候通过浏览器访问 [http://127.0.0.1:10000](http://127.0.0.1:10000) 应该可以正常看到网页了。

{% asset_img run_ui.png %}

如果你不是在本地编译运行，可以用类似
```bash
./ui/build -s --serve-host 0.0.0.0 -w
```
的命令来运行，然后浏览器直接访问编译和运行perfetto的设备的IP地址，端口为 10000来访问它。下面我是在局域网运行的样例

{% asset_img 2.png %}

# 离线部署
第三步有提及，编译运行需要12GB上内存，这个条件直接劝退VPS内存小的人。`ui.perfetto.dev` 实际上是一堆js/html文件，编译运行之后，对应的网页文件在源码路径 `out/ui/ui/dist` 里面能找到，dist 目录里面的文件大概是这些（p.s: 如果你编译出来没有 service_worker.js ，使用命令编译运行不要停掉，用浏览器访问一次服务就会生成出来）
```bash
dist
├── index.html
├── service_worker.js
├── service_worker.js.map
└── v36.1-127c77716
    ├── assets
    │   ├── brand.png
    │   ├── catapult_trace_viewer.html
    │   ├── catapult_trace_viewer.js
    │   ├── favicon.png
    │   ├── logo-128.png
    │   ├── logo-3d.png
    │   ├── MaterialSymbolsOutlined.woff2
    │   ├── rec_atrace.png
    │   ├── rec_battery_counters.png
    │   ├── rec_board_voltage.png
    │   ├── rec_cpu_coarse.png
    │   ├── rec_cpu_fine.png
    │   ├── rec_cpu_freq.png
    │   ├── rec_cpu_voltage.png
    │   ├── rec_frame_timeline.png
    │   ├── rec_ftrace.png
    │   ├── rec_gpu_mem_total.png
    │   ├── rec_java_heap_dump.png
    │   ├── rec_lmk.png
    │   ├── rec_logcat.png
    │   ├── rec_long_trace.png
    │   ├── rec_mem_hifreq.png
    │   ├── rec_meminfo.png
    │   ├── rec_native_heap_profiler.png
    │   ├── rec_one_shot.png
    │   ├── rec_profiling.png
    │   ├── rec_ps_stats.png
    │   ├── rec_ring_buf.png
    │   ├── rec_syscalls.png
    │   ├── rec_vmstat.png
    │   ├── Roboto-100.woff2
    │   ├── Roboto-300.woff2
    │   ├── Roboto-400.woff2
    │   ├── Roboto-500.woff2
    │   ├── RobotoCondensed-Light.woff2
    │   ├── RobotoCondensed-Regular.woff2
    │   ├── RobotoMono-Regular.woff2
    │   └── scheduling_latency.png
    ├── engine_bundle.js
    ├── engine_bundle.js.map
    ├── frontend_bundle.js
    ├── frontend_bundle.js.map
    ├── index.html
    ├── manifest.json
    ├── perfetto.css
    ├── perfetto.css.map
    ├── traceconv_bundle.js
    ├── traceconv_bundle.js.map
    ├── traceconv.wasm
    └── trace_processor.wasm

2 directories, 53 files
```

# 移掉 is_internal_us.js 的访问
访问官网 [ui.perfetto.dev](https://ui.perfetto.dev/) 的时候，明明说是可以离线运行并且UI都出来了，但是每次访问官网，浏览器还是得转半天，打开浏览器得调试页面可以看到还访问了`https://storage.cloud.google.com/perfetto-ui-internal/is_internal_user.js`，如下图所示

{% asset_img 3.png %}
{% asset_img 4.png %}

这个链接即使在外网也是访问不到的，这里提供两种办法。
 - 如果自己没有需要访问谷歌云的需求，可以直接改本机的hosts，把 storage.cloud.google.com 指向 127.0.0.1 在，这样它访问失败的速度比较快。
 - 编译运行之前，修改源码的 `ui/src/frontend/index.ts`，按照下图所示把对应的位置注释掉，然后重新编译运行、部署。
{% asset_img 5.png %}

# 支持USB调试
官网是支持在网页上直接通过usb adb来连接安卓设备直接抓取trace的，离线部署的话只需要添加 https 支持就可以了。下面是我本地搭的示例

{% asset_img 6.png %}]]></content>
  </entry>
  <entry>
    <title>如何下载AOSP的单个仓库</title>
    <url>/2024/07/30/how-to-down-load-simple-aosp-project/</url>
    <content><![CDATA[AOSP 使用 repo 来组织代码的，有时候我们只需要下载其中一部分代码。下面是具体的操作方式

<!-- more -->

```xml
<?xml version="1.0" encoding="UTF-8"?>
<manifest>

  <remote  name="aosp"
           fetch=".."
           review="https://android-review.googlesource.com/" />
  <default revision="refs/tags/android-13.0.0_r41"
           remote="aosp"
           sync-j="4" />

  <superproject name="platform/superproject" remote="aosp" revision="android-13.0.0_r41"/>
  <contactinfo bugurl="go/repo-bug" />
  <!-- BEGIN open-source projects -->
  <project path="build/make" name="platform/build" groups="pdk" >
    <linkfile src="CleanSpec.mk" dest="build/CleanSpec.mk" />
    <linkfile src="buildspec.mk.default" dest="build/buildspec.mk.default" />
    <linkfile src="core" dest="build/core" />
    <linkfile src="envsetup.sh" dest="build/envsetup.sh" />
    <linkfile src="target" dest="build/target" />
    <linkfile src="tools" dest="build/tools" />
  </project>
  <project path="build/bazel" name="platform/build/bazel" groups="pdk" >
    <linkfile src="bazel.WORKSPACE" dest="WORKSPACE" />
    <linkfile src="bazel.sh" dest="tools/bazel" />
    <linkfile src="bazel.BUILD" dest="BUILD" />
  </project>
  <project path="build/bazel_common_rules" name="platform/build/bazel_common_rules" groups="pdk" />
  <project path="build/blueprint" name="platform/build/blueprint" groups="pdk,tradefed" />
  <project path="build/pesto" name="platform/build/pesto" groups="pdk" />
  <project path="build/soong" name="platform/build/soong" groups="pdk,tradefed" >
    <linkfile src="root.bp" dest="Android.bp" />
    <linkfile src="bootstrap.bash" dest="bootstrap.bash" />
  </project>
  <project path="art" name="platform/art" groups="pdk" />
  <project path="bionic" name="platform/bionic" groups="pdk" />
  <project path="bootable/recovery" name="platform/bootable/recovery" groups="pdk" />
  <project path="bootable/libbootloader" name="platform/bootable/libbootloader" groups="vts,pdk" />
  <project path="cts" name="platform/cts" groups="cts,pdk-cw-fs,pdk-fs" />
  <project path="dalvik" name="platform/dalvik" groups="pdk-cw-fs,pdk-fs" />
  <project path="developers/build" name="platform/developers/build" groups="developers,pdk" />
  <project path="developers/demos" name="platform/developers/demos" groups="developers" />
  <project path="developers/samples/android" name="platform/developers/samples/android" groups="developers" />
  <project path="development" name="platform/development" groups="developers,pdk-cw-fs,pdk-fs" />
  <project path="device/amlogic/yukawa" name="device/amlogic/yukawa" groups="device,yukawa,pdk" />
  <project path="device/amlogic/yukawa-kernel" name="device/amlogic/yukawa-kernel" groups="device,yukawa,pdk" clone-depth="2" />
  <project path="device/common" name="device/common" groups="pdk-cw-fs,pdk" />
  <project path="device/generic/arm64" name="device/generic/arm64" groups="pdk" />
  <project path="device/generic/armv7-a-neon" name="device/generic/armv7-a-neon" groups="pdk" />
  <project path="device/generic/art" name="device/generic/art" groups="pdk" />
  <project path="device/generic/car" name="device/generic/car" groups="pdk" />
  <project path="device/generic/common" name="device/generic/common" groups="pdk" />
  <project path="device/generic/goldfish" name="device/generic/goldfish" groups="pdk" />
  <project path="device/generic/goldfish-opengl" name="device/generic/goldfish-opengl" groups="pdk" />
  <project path="device/generic/mini-emulator-arm64" name="device/generic/mini-emulator-arm64" groups="pdk" />
  <project path="device/generic/mini-emulator-armv7-a-neon" name="device/generic/mini-emulator-armv7-a-neon" groups="pdk" />
  <project path="device/generic/mini-emulator-x86" name="device/generic/mini-emulator-x86" groups="pdk" />
  <project path="device/generic/mini-emulator-x86_64" name="device/generic/mini-emulator-x86_64" groups="pdk" />
  <project path="device/generic/opengl-transport" name="device/generic/opengl-transport" groups="pdk" />
  <project path="device/generic/qemu" name="device/generic/qemu" groups="pdk" />
  <project path="device/generic/trusty" name="device/generic/trusty" groups="pdk" />
  <project path="device/generic/uml" name="device/generic/uml" groups="device,pdk" />
  <project path="device/generic/x86" name="device/generic/x86" groups="pdk" />
  <project path="device/generic/x86_64" name="device/generic/x86_64" groups="pdk" />
  <project path="device/generic/vulkan-cereal" name="device/generic/vulkan-cereal" groups="pdk" />
  <project path="device/google/atv" name="device/google/atv" groups="device,broadcom_pdk,generic_fs,pdk" />
  <project path="device/google/barbet" name="device/google/barbet" groups="device,barbet" />
  <project path="device/google/barbet-sepolicy" name="device/google/barbet-sepolicy" groups="device,barbet" />
  <project path="device/google/bluejay" name="device/google/bluejay" groups="device,bluejay" />
  <project path="device/google/bluejay-sepolicy" name="device/google/bluejay-sepolicy" groups="device,bluejay" />
  <project path="device/google/bluejay-kernel" name="device/google/bluejay-kernel" groups="device,bluejay" clone-depth="1" />
  <project path="device/google/bramble" name="device/google/bramble" groups="device,bramble" />
  <project path="device/google/bramble-sepolicy" name="device/google/bramble-sepolicy" groups="device,bramble" />
  <project path="device/google/contexthub" name="device/google/contexthub" groups="device,pdk" />
  <project path="device/google/coral" name="device/google/coral" groups="device,coral,generic_fs" />
  <project path="device/google/coral-kernel" name="device/google/coral-kernel" groups="device,coral,generic_fs" clone-depth="1" />
  <project path="device/google/coral-sepolicy" name="device/google/coral-sepolicy" groups="device,coral,generic_fs" />
  <project path="device/google/gs101" name="device/google/gs101" groups="device,slider,bluejay,pdk-gs-arm" />
  <project path="device/google/gs101-sepolicy" name="device/google/gs101-sepolicy" groups="device,slider,bluejay,pdk-gs-arm" />
  <project path="device/google/gs201" name="device/google/gs201" groups="device,cloudripper" />
  <project path="device/google/gs201-sepolicy" name="device/google/gs201-sepolicy" groups="device,cloudripper" />
  <project path="device/google/gs-common" name="device/google/gs-common" groups="device,slider,bluejay,pdk-gs-arm" />
  <project path="device/google/pantah" name="device/google/pantah" groups="device,cloudripper" />
  <project path="device/google/pantah-sepolicy" name="device/google/pantah-sepolicy" groups="device,cloudripper" />
  <project path="device/google/pantah-kernel" name="device/google/pantah-kernel" groups="device,cloudripper" clone-depth="1" />
  <project path="device/google/raviole" name="device/google/raviole" groups="device,slider,pdk-gs-arm" />
  <project path="device/google/raviole-kernel" name="device/google/raviole-kernel" groups="device,slider,pdk-gs-arm" clone-depth="1" />
  <project path="device/google/redbull" name="device/google/redbull" groups="device,redbull" />
  <project path="device/google/redbull-kernel" name="device/google/redbull-kernel" groups="device,bramble,redfin" clone-depth="1" />
  <project path="device/google/redbull-sepolicy" name="device/google/redbull-sepolicy" groups="device,redbull" />
  <project path="device/google/redfin" name="device/google/redfin" groups="device,redfin" />
  <project path="device/google/redfin-sepolicy" name="device/google/redfin-sepolicy" groups="device,redfin" />
  <project path="device/google/sunfish" name="device/google/sunfish" groups="device,sunfish" />
  <project path="device/google/sunfish-kernel" name="device/google/sunfish-kernel" groups="device,sunfish" clone-depth="1" />
  <project path="device/google/sunfish-sepolicy" name="device/google/sunfish-sepolicy" groups="device,sunfish" />
  <project path="device/google/cuttlefish" name="device/google/cuttlefish" groups="device,pdk" />
  <project path="device/google/cuttlefish_prebuilts" name="device/google/cuttlefish_prebuilts" groups="device,pdk" clone-depth="1" />
  <project path="device/google/trout" name="device/google/trout" groups="device,trout,gull,pdk" />
  <project path="device/google/vrservices" name="device/google/vrservices" groups="pdk" />
  <project path="device/google_car" name="device/google_car" groups="pdk" />
  <project path="device/linaro/dragonboard" name="device/linaro/dragonboard" groups="device,dragonboard,pdk" />
  <project path="device/linaro/dragonboard-kernel" name="device/linaro/dragonboard-kernel" groups="device,dragonboard,pdk" clone-depth="1" />
  <project path="device/linaro/hikey" name="device/linaro/hikey" groups="device,hikey,pdk" />
  <project path="device/linaro/hikey-kernel" name="device/linaro/hikey-kernel" groups="device,hikey,pdk" clone-depth="1" />
  <project path="device/linaro/poplar" name="device/linaro/poplar" groups="device,poplar,pdk" />
  <project path="device/linaro/poplar-kernel" name="device/linaro/poplar-kernel" groups="device,poplar,pdk" clone-depth="1" />
  <project name="device/mediatek/wembley-sepolicy" path="device/mediatek/wembley-sepolicy" groups="device"/>
  <project path="device/sample" name="device/sample" groups="pdk" />
  <project path="device/ti/beagle_x15" name="device/ti/beagle-x15" groups="device,beagle_x15,pdk" />
  <project path="device/ti/beagle_x15-kernel" name="device/ti/beagle-x15-kernel" groups="device,beagle_x15,pdk" clone-depth="1" />
  <project path="external/aac" name="platform/external/aac" groups="pdk" />
  <project path="external/abseil-cpp" name="platform/external/abseil-cpp" groups="pdk" />
  <project path="external/adt-infra" name="platform/external/adt-infra" groups="adt-infra,notdefault,pdk-fs" />
  <project path="external/android-clat" name="platform/external/android-clat" groups="pdk" />
  <project path="external/androidplot" name="platform/external/androidplot" groups="pdk" />
  <project path="external/angle" name="platform/external/angle" groups="pdk" />
  <project path="external/ant-glob" name="platform/external/ant-glob" groups="pdk" />
  <project path="external/antlr" name="platform/external/antlr" groups="pdk" />
  <project path="external/apache-commons-bcel" name="platform/external/apache-commons-bcel" groups="pdk" />
  <project path="external/apache-commons-compress" name="platform/external/apache-commons-compress" groups="pdk" />
  <project path="external/apache-commons-math" name="platform/external/apache-commons-math" groups="pdk" />
  <project path="external/apache-harmony" name="platform/external/apache-harmony" groups="pdk" />
  <project path="external/apache-http" name="platform/external/apache-http" groups="pdk" />
  <project path="external/apache-xml" name="platform/external/apache-xml" groups="pdk" />
  <project path="external/arm-neon-tests" name="platform/external/arm-neon-tests" groups="vendor" />
  <project path="external/arm-optimized-routines" name="platform/external/arm-optimized-routines" groups="pdk" />
  <project path="external/arm-trusted-firmware" name="platform/external/arm-trusted-firmware" groups="pdk" />
  <project path="external/auto" name="platform/external/auto" groups="pdk" />
  <project path="external/autotest" name="platform/external/autotest" groups="pdk-fs" />
  <project path="external/android-nn-driver" name="platform/external/android-nn-driver" groups="pdk-lassen,pdk-gs-arm" />
  <project path="external/armnn" name="platform/external/armnn" groups="pdk-lassen,pdk-gs-arm" />
  <project path="external/avb" name="platform/external/avb" groups="pdk" />
  <project path="external/bazelbuild-rules_android" name="platform/external/bazelbuild-rules_android" groups="pdk" />
  <project path="external/bazel-skylib" name="platform/external/bazel-skylib" groups="pdk" />
  <project path="external/bc" name="platform/external/bc" groups="pdk" />
  <project path="external/bcc" name="platform/external/bcc" groups="pdk" />
  <project path="external/blktrace" name="platform/external/blktrace" groups="pdk" />
  <project path="external/boringssl" name="platform/external/boringssl" groups="pdk" />
  <project path="external/bouncycastle" name="platform/external/bouncycastle" groups="pdk" />
  <project path="external/bpftool" name="platform/external/bpftool" groups="pdk" />
  <project path="external/brotli" name="platform/external/brotli" groups="pdk" />
  <project path="external/bsdiff" name="platform/external/bsdiff" groups="pdk" />
  <project path="external/bzip2" name="platform/external/bzip2" groups="pdk" />
  <project path="external/caliper" name="platform/external/caliper" groups="pdk" />
  <project path="external/capstone" name="platform/external/capstone" groups="pdk" />
  <project path="external/catch2" name="platform/external/catch2" groups="pdk" />
  <project path="external/cblas" name="platform/external/cblas" groups="pdk" />
  <project path="external/cbor-java" name="platform/external/cbor-java" groups="pdk" />
  <project path="external/chromium-trace" name="platform/external/chromium-trace" groups="pdk" />
  <project path="external/chromium-webview" name="platform/external/chromium-webview" groups="pdk" clone-depth="1" />
  <project path="external/clang" name="platform/external/clang" groups="pdk" />
  <project path="external/cldr" name="platform/external/cldr" groups="pdk" />
  <project path="external/cn-cbor" name="platform/external/cn-cbor" groups="pdk" />
  <project path="external/compiler-rt" name="platform/external/compiler-rt" groups="pdk" />
  <project path="external/ComputeLibrary" name="platform/external/ComputeLibrary" groups="pdk-lassen,pdk-gs-arm" />
  <project path="external/connectedappssdk" name="platform/external/connectedappssdk" groups="pdk" />
  <project path="external/conscrypt" name="platform/external/conscrypt" groups="pdk" />
  <project path="external/cpu_features" name="platform/external/cpu_features" groups="pdk" />
  <project path="external/cpuinfo" name="platform/external/cpuinfo" groups="pdk" />
  <project path="external/crcalc" name="platform/external/crcalc" groups="pdk" />
  <project path="external/cros/system_api" name="platform/external/cros/system_api" groups="pdk" />
  <project path="external/crosvm" name="platform/external/crosvm" groups="pdk" />
  <project path="external/curl" name="platform/external/curl" groups="pdk" />
  <project path="external/dagger2" name="platform/external/dagger2" groups="pdk" />
  <project path="external/deqp" name="platform/external/deqp" groups="pdk-fs" />
  <project path="external/deqp-deps/SPIRV-Headers" name="platform/external/deqp-deps/SPIRV-Headers" groups="pdk-fs" />
  <project path="external/deqp-deps/SPIRV-Tools" name="platform/external/deqp-deps/SPIRV-Tools" groups="pdk-fs" />
  <project path="external/deqp-deps/glslang" name="platform/external/deqp-deps/glslang" groups="pdk-fs" />
  <project path="external/deqp-deps/amber" name="platform/external/deqp-deps/amber" groups="pdk-fs" />
  <project path="external/desugar" name="platform/external/desugar" groups="pdk" />
  <project path="external/dexmaker" name="platform/external/dexmaker" groups="pdk" />
  <project path="external/dlmalloc" name="platform/external/dlmalloc" groups="pdk" />
  <project path="external/dng_sdk" name="platform/external/dng_sdk" groups="pdk" />
  <project path="external/dnsmasq" name="platform/external/dnsmasq" groups="pdk" />
  <project path="external/doclava" name="platform/external/doclava" groups="pdk" />
  <project path="external/dokka" name="platform/external/dokka" groups="pdk" />
  <project path="external/downloader" name="platform/external/downloader" groups="pdk" />
  <project path="external/drm_hwcomposer" name="platform/external/drm_hwcomposer" groups="drm_hwcomposer,pdk-fs" />
  <project path="external/dtc" name="platform/external/dtc" groups="pdk"/>
  <project path="external/dynamic_depth" name="platform/external/dynamic_depth" groups="pdk" />
  <project path="external/e2fsprogs" name="platform/external/e2fsprogs" groups="pdk" />
  <project path="external/easymock" name="platform/external/easymock" groups="pdk" />
  <project path="external/eigen" name="platform/external/eigen" groups="pdk" />
  <project path="external/elfutils" name="platform/external/elfutils" groups="pdk" />
  <project path="external/emma" name="platform/external/emma" groups="pdk" />
  <project path="external/erofs-utils" name="platform/external/erofs-utils" groups="pdk" />
  <project path="external/error_prone" name="platform/external/error_prone" groups="pdk" />
  <project path="external/escapevelocity" name="platform/external/escapevelocity" groups="pdk" />
  <project path="external/ethtool" name="platform/external/ethtool" groups="pdk" />
  <project path="external/exfatprogs" name="platform/external/exfatprogs" groups="pdk" />
  <project path="external/exoplayer" name="platform/external/exoplayer" groups="pdk" />
  <project path="external/expat" name="platform/external/expat" groups="pdk" />
  <project path="external/f2fs-tools" name="platform/external/f2fs-tools" groups="pdk" />
  <project path="external/fastrpc" name="platform/external/fastrpc" groups="pdk" />
  <project path="external/fdlibm" name="platform/external/fdlibm" groups="pdk" />
  <project path="external/fec" name="platform/external/fec" groups="pdk" />
  <project path="external/fft2d" name="platform/external/fft2d" groups="pdk" />
  <project path="external/firebase-messaging" name="platform/external/firebase-messaging" groups="pdk"/>
  <project path="external/flac" name="platform/external/flac" groups="pdk" />
  <project path="external/flatbuffers" name="platform/external/flatbuffers" groups="pdk" />
  <project path="external/fonttools" name="platform/external/fonttools" groups="pdk" />
  <project path="external/fmtlib" name="platform/external/fmtlib" groups="pdk" />
  <project path="external/freetype" name="platform/external/freetype" groups="pdk" />
  <project path="external/fsck_msdos" name="platform/external/fsck_msdos" groups="pdk" />
  <project path="external/fsverity-utils" name="platform/external/fsverity-utils" groups="pdk" />
  <project path="external/FP16" name="platform/external/FP16" groups="pdk" />
  <project path="external/FXdiv" name="platform/external/FXdiv" groups="pdk" />
  <project path="external/gemmlowp" name="platform/external/gemmlowp" groups="pdk" />
  <project path="external/geojson-jackson" name="platform/external/geojson-jackson" groups="pdk" />
  <project path="external/geonames" name="platform/external/geonames" groups="pdk" />
  <project path="external/gflags" name="platform/external/gflags" groups="pdk" />
  <project path="external/gfxstream-protocols" name="platform/external/gfxstream-protocols" groups="pdk" />
  <project path="external/giflib" name="platform/external/giflib" groups="pdk,qcom_msm8x26" />
  <project path="external/glide" name="platform/external/glide" groups="pdk" />
  <project path="external/go-cmp" name="platform/external/go-cmp" groups="pdk" />
  <project path="external/golang-protobuf" name="platform/external/golang-protobuf" groups="pdk" />
  <project path="external/google-benchmark" name="platform/external/google-benchmark" groups="pdk" />
  <project path="external/google-breakpad" name="platform/external/google-breakpad" groups="pdk-fs" />
  <project path="external/google-fonts/arbutus-slab" name="platform/external/google-fonts/arbutus-slab" groups="pdk" />
  <project path="external/google-fonts/barlow" name="platform/external/google-fonts/barlow" groups="pdk" />
  <project path="external/google-fonts/karla" name="platform/external/google-fonts/karla" groups="pdk" />
  <project path="external/google-fonts/lustria" name="platform/external/google-fonts/lustria" groups="pdk" />
  <project path="external/google-fonts/fraunces" name="platform/external/google-fonts/fraunces" groups="pdk" />
  <project path="external/google-fonts/big-shoulders-text" name="platform/external/google-fonts/big-shoulders-text" groups="pdk" />
  <project path="external/google-fonts/arvo" name="platform/external/google-fonts/arvo" groups="pdk" />
  <project path="external/google-fonts/carrois-gothic-sc" name="platform/external/google-fonts/carrois-gothic-sc" groups="pdk" />
  <project path="external/google-fonts/coming-soon" name="platform/external/google-fonts/coming-soon" groups="pdk" />
  <project path="external/google-fonts/cutive-mono" name="platform/external/google-fonts/cutive-mono" groups="pdk" />
  <project path="external/google-fonts/dancing-script" name="platform/external/google-fonts/dancing-script" groups="pdk" />
  <project path="external/google-fonts/lato" name="platform/external/google-fonts/lato" groups="pdk" />
  <project path="external/google-fonts/source-sans-pro" name="platform/external/google-fonts/source-sans-pro" groups="pdk" />
  <project path="external/google-fonts/rubik" name="platform/external/google-fonts/rubik" groups="pdk" />
  <project path="external/google-fonts/zilla-slab" name="platform/external/google-fonts/zilla-slab" groups="pdk" />
  <project path="external/google-fruit" name="platform/external/google-fruit" groups="pdk" />
  <project path="external/google-java-format" name="platform/external/google-java-format" groups="pdk" />
  <project path="external/google-styleguide" name="platform/external/google-styleguide" groups="pdk" />
  <project path="external/googletest" name="platform/external/googletest" groups="pdk" />
  <project path="external/gptfdisk" name="platform/external/gptfdisk" groups="pdk" />
  <project path="external/grpc-grpc" name="platform/external/grpc-grpc" groups="pdk,tradefed" />
  <project path="external/grpc-grpc-java" name="platform/external/grpc-grpc-java" groups="pdk,tradefed" />
  <project path="external/guava" name="platform/external/guava" groups="pdk" />
  <project path="external/guice" name="platform/external/guice" groups="pdk" />
  <project path="external/gwp_asan" name="platform/external/gwp_asan" groups="pdk" />
  <project path="external/hamcrest" name="platform/external/hamcrest" groups="pdk" />
  <project path="external/harfbuzz_ng" name="platform/external/harfbuzz_ng" groups="pdk,qcom_msm8x26" />
  <project path="external/hyphenation-patterns" name="platform/external/hyphenation-patterns" groups="pdk" />
  <project path="external/icing" name="platform/external/icing" groups="pdk" />
  <project path="external/icu" name="platform/external/icu" groups="pdk" />
  <project path="external/igt-gpu-tools" name="platform/external/igt-gpu-tools" groups="pdk" />
  <project path="external/ImageMagick" name="platform/external/ImageMagick" groups="pdk" />
  <project path="external/image_io" name="platform/external/image_io" groups="pdk" />
  <project path="external/ims" name="platform/external/ims" groups="pdk" />
  <project path="external/iperf3" name="platform/external/iperf3" groups="pdk" />
  <project path="external/iproute2" name="platform/external/iproute2" groups="pdk" />
  <project path="external/ipsec-tools" name="platform/external/ipsec-tools" groups="pdk" />
  <project path="external/iptables" name="platform/external/iptables" groups="pdk" />
  <project path="external/iputils" name="platform/external/iputils" groups="pdk" />
  <project path="external/iw" name="platform/external/iw" groups="pdk" />
  <project path="external/jacoco" name="platform/external/jacoco" groups="pdk" />
  <project path="external/jackson-annotations" name="platform/external/jackson-annotations" groups="pdk" />
  <project path="external/jackson-core" name="platform/external/jackson-core" groups="pdk" />
  <project path="external/jackson-databind" name="platform/external/jackson-databind" groups="pdk" />
  <project path="external/jarjar" name="platform/external/jarjar" groups="pdk" />
  <project path="external/javaparser" name="platform/external/javaparser" groups="pdk" />
  <project path="external/javapoet" name="platform/external/javapoet" groups="pdk" />
  <project path="external/javasqlite" name="platform/external/javasqlite" groups="pdk" />
  <project path="external/javassist" name="platform/external/javassist" groups="pdk" />
  <project path="external/jazzer-api" name="platform/external/jazzer-api" groups="pdk" />
  <project path="external/jcommander" name="platform/external/jcommander" groups="pdk" />
  <project path="external/jdiff" name="platform/external/jdiff" groups="pdk" />
  <project path="external/jemalloc_new" name="platform/external/jemalloc_new" groups="pdk" />
  <project path="external/jimfs" name="platform/external/jimfs" groups="pdk" />
  <project path="external/jline" name="platform/external/jline" groups="pdk,tradefed,pdk-fs" />
  <project path="external/jsilver" name="platform/external/jsilver" groups="pdk" />
  <project path="external/jsmn" name="platform/external/jsmn" groups="pdk" />
  <project path="external/jsoncpp" name="platform/external/jsoncpp" groups="pdk" />
  <project path="external/jsr305" name="platform/external/jsr305" groups="pdk" />
  <project path="external/jsr330" name="platform/external/jsr330" groups="pdk" />
  <project path="external/junit" name="platform/external/junit" groups="pdk" />
  <project path="external/junit-params" name="platform/external/junit-params" groups="pdk" />
  <project path="external/kernel-headers" name="platform/external/kernel-headers" groups="pdk" />
  <project path="external/kmod" name="platform/external/kmod" groups="pdk" />
  <project path="external/kotlinc" name="platform/external/kotlinc" groups="pdk" />
  <project path="external/kotlinx.atomicfu" name="platform/external/kotlinx.atomicfu" groups="pdk" />
  <project path="external/kotlinx.coroutines" name="platform/external/kotlinx.coroutines" groups="pdk" />
  <project path="external/kotlinx.metadata" name="platform/external/kotlinx.metadata" groups="pdk" />
  <project path="external/ktfmt" name="platform/external/ktfmt" groups="pdk" />
  <project path="external/ksoap2" name="platform/external/ksoap2" groups="pdk" />
  <project path="external/libabigail" name="platform/external/libabigail" groups="pdk" />
  <project path="external/libaom" name="platform/external/libaom" groups="pdk" />
  <project path="external/libavc" name="platform/external/libavc" groups="pdk" />
  <project path="external/libbackup" name="platform/external/libbackup" groups="pdk" />
  <project path="external/libbrillo" name="platform/external/libbrillo" groups="pdk" />
  <project path="external/libbpf" name="platform/external/libbpf" groups="pdk" />
  <project path="external/libcap" name="platform/external/libcap" groups="pdk" />
  <project path="external/libcap-ng" name="platform/external/libcap-ng" groups="pdk" />
  <project path="external/libchrome" name="platform/external/libchrome" groups="pdk" />
  <project path="external/libchromeos-rs" name="platform/external/libchromeos-rs" groups="pdk" />
  <project path="external/libconfig" name="platform/external/libconfig" groups="pdk" />
  <project path="external/libcppbor" name="platform/external/libcppbor" groups="pdk" />
  <project path="external/libcups" name="platform/external/libcups" groups="pdk-cw-fs,pdk-fs" />
  <project path="external/libcxx" name="platform/external/libcxx" groups="pdk" />
  <project path="external/libcxxabi" name="platform/external/libcxxabi" groups="pdk" />
  <project path="external/libdivsufsort" name="platform/external/libdivsufsort" groups="pdk" />
  <project path="external/libdrm" name="platform/external/libdrm" groups="pdk" />
  <project path="external/libepoxy" name="platform/external/libepoxy" groups="pdk" />
  <project path="external/libese" name="platform/external/libese" groups="pdk" />
  <project path="external/libevent" name="platform/external/libevent" groups="pdk" />
  <project path="external/libexif" name="platform/external/libexif" groups="pdk" />
  <project path="external/libffi" name="platform/external/libffi" groups="pdk" />
  <project path="external/libgav1" name="platform/external/libgav1" groups="pdk" />
  <project path="external/libfuse" name="platform/external/libfuse" groups="pdk" />
  <project path="external/libgsm" name="platform/external/libgsm" groups="pdk" />
  <project path="external/libhevc" name="platform/external/libhevc" groups="pdk" />
  <project path="external/libiio" name="platform/external/libiio" groups="pdk" />
  <project path="external/libjpeg-turbo" name="platform/external/libjpeg-turbo" groups="pdk" />
  <project path="external/libkmsxx" name="platform/external/libkmsxx" groups="pdk" />
  <project path="external/libldac" name="platform/external/libldac" groups="pdk" />
  <project path="external/libmpeg2" name="platform/external/libmpeg2" groups="pdk" />
  <project path="external/libnetfilter_conntrack" name="platform/external/libnetfilter_conntrack" groups="pdk" />
  <project path="external/libnfnetlink" name="platform/external/libnfnetlink" groups="pdk" />
  <project path="external/libnl" name="platform/external/libnl" groups="pdk" />
  <project path="external/libogg" name="platform/external/libogg" groups="pdk" />
  <project path="external/libopus" name="platform/external/libopus" groups="pdk" />
  <project path="external/libpalmrejection" name="platform/external/libpalmrejection" groups="pdk" />
  <project path="external/libpcap" name="platform/external/libpcap" groups="pdk" />
  <project path="external/libphonenumber" name="platform/external/libphonenumber" groups="pdk" />
  <project path="external/libpng" name="platform/external/libpng" groups="pdk" />
  <project path="external/libprotobuf-mutator" name="platform/external/libprotobuf-mutator" groups="pdk" />
  <project path="external/libsrtp2" name="platform/external/libsrtp2" groups="pdk" />
  <project path="external/libtextclassifier" name="platform/external/libtextclassifier" groups="pdk" />
  <project path="external/libtraceevent" name="platform/external/libtraceevent" groups="pdk" />
  <project path="external/libtracefs" name="platform/external/libtracefs" groups="pdk" />
  <project path="external/liburing" name="platform/external/liburing" groups="pdk" />
  <project path="external/libusb" name="platform/external/libusb" groups="pdk" />
  <project path="external/libutf" name="platform/external/libutf" groups="pdk" />
  <project path="external/libvpx" name="platform/external/libvpx" groups="pdk" />
  <project path="external/libwebm" name="platform/external/libwebm" groups="pdk" />
  <project path="external/libwebsockets" name="platform/external/libwebsockets" groups="pdk" />
  <project path="external/libxaac" name="platform/external/libxaac" groups="pdk" />
  <project path="external/libxkbcommon" name="platform/external/libxkbcommon" groups="pdk" />
  <project path="external/libxml2" name="platform/external/libxml2" groups="pdk,libxml2" />
  <project path="external/libyuv" name="platform/external/libyuv" groups="pdk,libyuv" />
  <project path="external/linux-kselftest" name="platform/external/linux-kselftest" groups="vts,pdk" clone-depth="1" />
  <project path="external/llvm" name="platform/external/llvm" groups="pdk" />
  <project path="external/lmfit" name="platform/external/lmfit" groups="pdk" />
  <project path="external/lottie" name="platform/external/lottie" groups="pdk" />
  <project path="external/lua" name="platform/external/lua" groups="pdk" />
  <project path="external/ltp" name="platform/external/ltp" groups="vts,pdk" />
  <project path="external/lz4" name="platform/external/lz4" groups="pdk" />
  <project path="external/lzma" name="platform/external/lzma" groups="pdk" />
  <project path="external/marisa-trie" name="platform/external/marisa-trie" groups="pdk" />
  <project path="external/markdown" name="platform/external/markdown" groups="pdk" />
  <project path="external/mdnsresponder" name="platform/external/mdnsresponder" groups="pdk" />
  <project path="external/mesa3d" name="platform/external/mesa3d" groups="pdk-cw-fs,pdk-fs" />
  <project path="external/mime-support" name="platform/external/mime-support" groups="pdk" />
  <project path="external/minigbm" name="platform/external/minigbm" groups="pdk" />
  <project path="external/minijail" name="platform/external/minijail" groups="pdk" />
  <project path="external/mksh" name="platform/external/mksh" groups="pdk" />
  <project path="external/python/mobly" name="platform/external/python/mobly" groups="pdk" />
  <project path="external/mobly-bundled-snippets" name="platform/external/mobly-bundled-snippets" groups="pdk" />
  <project path="external/mobly-snippet-lib" name="platform/external/mobly-snippet-lib" groups="pdk" />
  <project path="external/mockftpserver" name="platform/external/mockftpserver" groups="pdk" />
  <project path="external/mockito" name="platform/external/mockito" groups="pdk" />
  <project path="external/mockwebserver" name="platform/external/mockwebserver" groups="pdk" />
  <project path="external/modp_b64" name="platform/external/modp_b64" groups="pdk" />
  <project path="external/mp4parser" name="platform/external/mp4parser" groups="pdk" />
  <project path="external/ms-tpm-20-ref" name="platform/external/ms-tpm-20-ref" groups="pdk" />
  <project path="external/mtools" name="platform/external/mtools" groups="pdk" />
  <project path="external/mtpd" name="platform/external/mtpd" groups="pdk" />
  <project path="external/musl" name="platform/external/musl" groups="pdk" />
  <project path="external/nanohttpd" name="platform/external/nanohttpd" groups="pdk" />
  <project path="external/nanopb-c" name="platform/external/nanopb-c" groups="pdk" />
  <project path="external/naver-fonts" name="platform/external/naver-fonts" groups="pdk" />
  <project path="external/neon_2_sse" name="platform/external/neon_2_sse" groups="pdk" />
  <project path="external/neven" name="platform/external/neven" groups="pdk" />
  <project path="external/newfs_msdos" name="platform/external/newfs_msdos" groups="pdk" />
  <project path="external/nist-pkits" name="platform/external/nist-pkits" groups="pdk" />
  <project path="external/nist-sip" name="platform/external/nist-sip" groups="pdk" />
  <project path="external/nos/host/generic" name="platform/external/nos/host/generic" groups="pdk" />
  <project path="external/noto-fonts" name="platform/external/noto-fonts" groups="pdk" />
  <project path="external/nullaway" name="platform/external/nullaway" groups="pdk" />
  <project path="external/oauth" name="platform/external/oauth" groups="pdk" />
  <project path="external/obex" name="platform/external/obex" groups="pdk" />
  <project path="external/objenesis" name="platform/external/objenesis" groups="pdk" />
  <project path="external/oboe" name="platform/external/oboe" groups="pdk" />
  <project path="external/obstack" name="platform/external/obstack" groups="pdk" />
  <project path="external/oj-libjdwp" name="platform/external/oj-libjdwp" groups="pdk" />
  <project path="external/okhttp" name="platform/external/okhttp" groups="pdk" />
  <project path="external/okhttp4" name="platform/external/okhttp4" groups="pdk" />
  <project path="external/okio" name="platform/external/okio" groups="pdk" />
  <project path="external/one-true-awk" name="platform/external/one-true-awk" groups="pdk" />
  <project path="external/opencensus-java" name="platform/external/opencensus-java" groups="pdk,tradefed" />
  <project path="external/OpenCL-CTS" name="platform/external/OpenCL-CTS" />
  <project path="external/OpenCSD" name="platform/external/OpenCSD" groups="pdk" />
  <project path="external/open-dice" name="platform/external/open-dice" groups="pdk" />
  <project path="external/openscreen" name="platform/external/openscreen" groups="pdk" />
  <project path="external/openwrt-prebuilts" name="platform/external/openwrt-prebuilts" groups="pdk" />
  <project path="external/oss-fuzz" name="platform/external/oss-fuzz" groups="pdk" />
  <project path="external/owasp/sanitizer" name="platform/external/owasp/sanitizer" groups="pdk" />
  <project path="external/pffft" name="platform/external/pffft" groups="pdk" />
  <project path="external/pandora/avatar" name="platform/external/pandora/avatar" groups="pdk" />
  <project path="external/pandora/bt-test-interfaces" name="platform/external/pandora/bt-test-interfaces" groups="pdk" />
  <project path="external/pandora/mmi2grpc" name="platform/external/pandora/mmi2grpc" groups="pdk" />
  <project path="external/parameter-framework" name="platform/external/parameter-framework" groups="pdk" />
  <project path="external/pcre" name="platform/external/pcre" groups="pdk" />
  <project path="external/pdfium" name="platform/external/pdfium" groups="pdk" />
  <project path="external/perfetto" name="platform/external/perfetto" groups="pdk" />
  <project path="external/piex" name="platform/external/piex" groups="pdk" />
  <project path="external/pigweed" name="platform/external/pigweed" groups="pdk" />
  <project path="external/ply" name="platform/external/ply" groups="pdk" />
  <project path="external/ppp" name="platform/external/ppp" groups="pdk" />
  <project path="external/proguard" name="platform/external/proguard" groups="pdk" />
  <project path="external/protobuf" name="platform/external/protobuf" groups="pdk" />
  <project path="external/psimd" name="platform/external/psimd" groups="pdk" />
  <project path="external/pthreadpool" name="platform/external/pthreadpool" groups="pdk" />
  <project path="external/puffin" name="platform/external/puffin" groups="pdk" />
  <project path="external/python/apitools" name="platform/external/python/apitools" groups="pdk" />
  <project path="external/python/asn1crypto" name="platform/external/python/asn1crypto" groups="pdk" />
  <project path="external/python/bumble" name="platform/external/python/bumble" groups="pdk" />
  <project path="external/python/cachetools" name="platform/external/python/cachetools" groups="pdk" />
  <project path="external/python/cffi" name="platform/external/python/cffi" groups="pdk" />
  <project path="external/python/cpython2" name="platform/external/python/cpython2" groups="pdk" />
  <project path="external/python/cpython3" name="platform/external/python/cpython3" groups="pdk" />
  <project path="external/python/cryptography" name="platform/external/python/cryptography" groups="pdk" />
  <project path="external/python/dateutil" name="platform/external/python/dateutil" groups="pdk" />
  <project path="external/python/enum34" name="platform/external/python/enum34" groups="vts,pdk" />
  <project path="external/python/funcsigs" name="platform/external/python/funcsigs" groups="pdk" />
  <project path="external/python/futures" name="platform/external/python/futures" groups="vts,pdk" />
  <project path="external/python/google-auth-library-python" name="platform/external/python/google-auth-library-python" groups="pdk" />
  <project path="external/python/google-api-python-client" name="platform/external/python/google-api-python-client" groups="vts,pdk" />
  <project path="external/python/httplib2" name="platform/external/python/httplib2" groups="vts,pdk" />
  <project path="external/python/ipaddress" name="platform/external/python/ipaddress" groups="pdk" />
  <project path="external/python/jinja" name="platform/external/python/jinja" groups="pdk" />
  <project path="external/python/markupsafe" name="platform/external/python/markupsafe" groups="pdk" />
  <project path="external/python/oauth2client" name="platform/external/python/oauth2client" groups="vts,pdk" />
  <project path="external/python/parse_type" name="platform/external/python/parse_type" groups="vts,pdk" />
  <project path="external/python/portpicker" name="platform/external/python/portpicker" groups="pdk" />
  <project path="external/python/pyasn1" name="platform/external/python/pyasn1" groups="vts,pdk" />
  <project path="external/python/pyasn1-modules" name="platform/external/python/pyasn1-modules" groups="vts,pdk" />
  <project path="external/python/pybind11" name="platform/external/python/pybind11" groups="pdk" />
  <project path="external/python/pycparser" name="platform/external/python/pycparser" groups="pdk" />
  <project path="external/python/pyee" name="platform/external/python/pyee" groups="pdk" />
  <project path="external/python/pyfakefs" name="platform/external/python/pyfakefs" groups="pdk" />
  <project path="external/python/pyopenssl" name="platform/external/python/pyopenssl" groups="pdk" />
  <project path="external/python/pyserial" name="platform/external/python/pyserial" groups="pdk" />
  <project path="external/python/python-api-core" name="platform/external/python/python-api-core" groups="pdk" />
  <project path="external/python/pyyaml" name="platform/external/python/pyyaml" groups="pdk" />
  <project path="external/python/rsa" name="platform/external/python/rsa" groups="vts,pdk" />
  <project path="external/python/setuptools" name="platform/external/python/setuptools" groups="vts,pdk" />
  <project path="external/python/six" name="platform/external/python/six" groups="vts,pdk" />
  <project path="external/python/timeout-decorator" name="platform/external/python/timeout-decorator" groups="pdk" />
  <project path="external/python/typing" name="platform/external/python/typing" groups="pdk" />
  <project path="external/python/uritemplates" name="platform/external/python/uritemplates" groups="vts,pdk" />
  <project path="external/rappor" name="platform/external/rappor" groups="pdk" />
  <project path="external/renderscript-intrinsics-replacement-toolkit" name="platform/external/renderscript-intrinsics-replacement-toolkit" groups="pdk" />
  <project path="external/replicaisland" name="platform/external/replicaisland" groups="pdk" />
  <project path="external/rmi4utils" name="platform/external/rmi4utils" groups="pdk" />
  <project path="external/robolectric" name="platform/external/robolectric" groups="pdk-cw-fs,pdk-fs" />
  <project path="external/robolectric-shadows" name="platform/external/robolectric-shadows" groups="pdk-cw-fs,pdk-fs" />
  <project path="external/roboto-fonts" name="platform/external/roboto-fonts" groups="pdk" />
  <project path="external/rootdev" name="platform/external/rootdev" groups="pdk" />
  <project path="external/Reactive-Extensions/RxCpp" name="platform/external/Reactive-Extensions/RxCpp" groups="pdk" />
  <project path="external/rnnoise" name="platform/external/rnnoise" groups="pdk" />
  <project path="external/rust/crates/ahash" name="platform/external/rust/crates/ahash" groups="pdk" />
  <project path="external/rust/crates/aho-corasick" name="platform/external/rust/crates/aho-corasick" groups="pdk" />
  <project path="external/rust/crates/android_logger" name="platform/external/rust/crates/android_logger" groups="pdk" />
  <project path="external/rust/crates/android_log-sys" name="platform/external/rust/crates/android_log-sys" groups="pdk" />
  <project path="external/rust/crates/anyhow" name="platform/external/rust/crates/anyhow" groups="pdk" />
  <project path="external/rust/crates/arbitrary" name="platform/external/rust/crates/arbitrary" groups="pdk" />
  <project path="external/rust/crates/argh" name="platform/external/rust/crates/argh" groups="pdk" />
  <project path="external/rust/crates/argh_derive" name="platform/external/rust/crates/argh_derive" groups="pdk" />
  <project path="external/rust/crates/argh_shared" name="platform/external/rust/crates/argh_shared" groups="pdk" />
  <project path="external/rust/crates/ash" name="platform/external/rust/crates/ash" groups="pdk" />
  <project path="external/rust/crates/async-stream" name="platform/external/rust/crates/async-stream" groups="pdk" />
  <project path="external/rust/crates/async-stream-impl" name="platform/external/rust/crates/async-stream-impl" groups="pdk" />
  <project path="external/rust/crates/async-task" name="platform/external/rust/crates/async-task" groups="pdk" />
  <project path="external/rust/crates/async-trait" name="platform/external/rust/crates/async-trait" groups="pdk" />
  <project path="external/rust/crates/atty" name="platform/external/rust/crates/atty" groups="pdk" />
  <project path="external/rust/crates/base64" name="platform/external/rust/crates/base64" groups="pdk" />
  <project path="external/rust/crates/bencher" name="platform/external/rust/crates/bencher" groups="pdk" />
  <project path="external/rust/crates/bindgen" name="platform/external/rust/crates/bindgen" groups="pdk" />
  <project path="external/rust/crates/bitflags" name="platform/external/rust/crates/bitflags" groups="pdk" />
  <project path="external/rust/crates/bstr" name="platform/external/rust/crates/bstr" groups="pdk" />
  <project path="external/rust/crates/byteorder" name="platform/external/rust/crates/byteorder" groups="pdk" />
  <project path="external/rust/crates/bytes" name="platform/external/rust/crates/bytes" groups="pdk" />
  <project path="external/rust/crates/cast" name="platform/external/rust/crates/cast" groups="pdk" />
  <project path="external/rust/crates/cesu8" name="platform/external/rust/crates/cesu8" groups="pdk" />
  <project path="external/rust/crates/cexpr" name="platform/external/rust/crates/cexpr" groups="pdk" />
  <project path="external/rust/crates/cfg-if" name="platform/external/rust/crates/cfg-if" groups="pdk" />
  <project path="external/rust/crates/chrono" name="platform/external/rust/crates/chrono" groups="pdk" />
  <project path="external/rust/crates/ciborium" name="platform/external/rust/crates/ciborium" groups="pdk" />
  <project path="external/rust/crates/ciborium-io" name="platform/external/rust/crates/ciborium-io" groups="pdk" />
  <project path="external/rust/crates/ciborium-ll" name="platform/external/rust/crates/ciborium-ll" groups="pdk" />
  <project path="external/rust/crates/clang-sys" name="platform/external/rust/crates/clang-sys" groups="pdk" />
  <project path="external/rust/crates/clap" name="platform/external/rust/crates/clap" groups="pdk" />
  <project path="external/rust/crates/codespan-reporting" name="platform/external/rust/crates/codespan-reporting" groups="pdk" />
  <project path="external/rust/crates/combine" name="platform/external/rust/crates/combine" groups="pdk" />
  <project path="external/rust/crates/command-fds" name="platform/external/rust/crates/command-fds" groups="pdk" />
  <project path="external/rust/crates/coset" name="platform/external/rust/crates/coset" groups="pdk" />
  <project path="external/rust/crates/crc32fast" name="platform/external/rust/crates/crc32fast" groups="pdk" />
  <project path="external/rust/crates/criterion" name="platform/external/rust/crates/criterion" groups="pdk" />
  <project path="external/rust/crates/criterion-plot" name="platform/external/rust/crates/criterion-plot" groups="pdk" />
  <project path="external/rust/crates/crossbeam-channel" name="platform/external/rust/crates/crossbeam-channel" groups="pdk" />
  <project path="external/rust/crates/crossbeam-deque" name="platform/external/rust/crates/crossbeam-deque" groups="pdk" />
  <project path="external/rust/crates/crossbeam-epoch" name="platform/external/rust/crates/crossbeam-epoch" groups="pdk" />
  <project path="external/rust/crates/crossbeam-queue" name="platform/external/rust/crates/crossbeam-queue" groups="pdk" />
  <project path="external/rust/crates/crossbeam-utils" name="platform/external/rust/crates/crossbeam-utils" groups="pdk" />
  <project path="external/rust/crates/csv" name="platform/external/rust/crates/csv" groups="pdk" />
  <project path="external/rust/crates/csv-core" name="platform/external/rust/crates/csv-core" groups="pdk" />
  <project path="external/rust/crates/der-oid-macro" name="platform/external/rust/crates/der-oid-macro" groups="pdk" />
  <project path="external/rust/crates/der-parser" name="platform/external/rust/crates/der-parser" groups="pdk" />
  <project path="external/rust/crates/derive_arbitrary" name="platform/external/rust/crates/derive_arbitrary" groups="pdk" />
  <project path="external/rust/crates/downcast-rs" name="platform/external/rust/crates/downcast-rs" groups="pdk" />
  <project path="external/rust/crates/either" name="platform/external/rust/crates/either" groups="pdk" />
  <project path="external/rust/crates/enumn" name="platform/external/rust/crates/enumn" groups="pdk" />
  <project path="external/rust/crates/env_logger" name="platform/external/rust/crates/env_logger" groups="pdk" />
  <project path="external/rust/crates/fallible-iterator" name="platform/external/rust/crates/fallible-iterator" groups="pdk" />
  <project path="external/rust/crates/fallible-streaming-iterator" name="platform/external/rust/crates/fallible-streaming-iterator" groups="pdk" />
  <project path="external/rust/crates/flate2" name="platform/external/rust/crates/flate2" groups="pdk" />
  <project path="external/rust/crates/fnv" name="platform/external/rust/crates/fnv" groups="pdk" />
  <project path="external/rust/crates/form_urlencoded" name="platform/external/rust/crates/form_urlencoded" groups="pdk" />
  <project path="external/rust/crates/futures" name="platform/external/rust/crates/futures" groups="pdk" />
  <project path="external/rust/crates/futures-channel" name="platform/external/rust/crates/futures-channel" groups="pdk" />
  <project path="external/rust/crates/futures-core" name="platform/external/rust/crates/futures-core" groups="pdk" />
  <project path="external/rust/crates/futures-executor" name="platform/external/rust/crates/futures-executor" groups="pdk" />
  <project path="external/rust/crates/futures-io" name="platform/external/rust/crates/futures-io" groups="pdk" />
  <project path="external/rust/crates/futures-macro" name="platform/external/rust/crates/futures-macro" groups="pdk" />
  <project path="external/rust/crates/futures-sink" name="platform/external/rust/crates/futures-sink" groups="pdk" />
  <project path="external/rust/crates/futures-task" name="platform/external/rust/crates/futures-task" groups="pdk" />
  <project path="external/rust/crates/futures-util" name="platform/external/rust/crates/futures-util" groups="pdk" />
  <project path="external/rust/crates/gdbstub" name="platform/external/rust/crates/gdbstub" groups="pdk" />
  <project path="external/rust/crates/gdbstub_arch" name="platform/external/rust/crates/gdbstub_arch" groups="pdk" />
  <project path="external/rust/crates/getrandom" name="platform/external/rust/crates/getrandom" groups="pdk" />
  <project path="external/rust/crates/glob" name="platform/external/rust/crates/glob" groups="pdk" />
  <project path="external/rust/crates/grpcio" name="platform/external/rust/crates/grpcio" groups="pdk" />
  <project path="external/rust/crates/grpcio-compiler" name="platform/external/rust/crates/grpcio-compiler" groups="pdk" />
  <project path="external/rust/crates/grpcio-sys" name="platform/external/rust/crates/grpcio-sys" groups="pdk" />
  <project path="external/rust/crates/half" name="platform/external/rust/crates/half" groups="pdk" />
  <project path="external/rust/crates/hashbrown" name="platform/external/rust/crates/hashbrown" groups="pdk" />
  <project path="external/rust/crates/hashlink" name="platform/external/rust/crates/hashlink" groups="pdk" />
  <project path="external/rust/crates/heck" name="platform/external/rust/crates/heck" groups="pdk" />
  <project path="external/rust/crates/idna" name="platform/external/rust/crates/idna" groups="pdk" />
  <project path="external/rust/crates/instant" name="platform/external/rust/crates/instant" groups="pdk" />
  <project path="external/rust/crates/intrusive-collections" name="platform/external/rust/crates/intrusive-collections" groups="pdk" />
  <project path="external/rust/crates/itertools" name="platform/external/rust/crates/itertools" groups="pdk" />
  <project path="external/rust/crates/itoa" name="platform/external/rust/crates/itoa" groups="pdk" />
  <project path="external/rust/crates/jni" name="platform/external/rust/crates/jni" groups="pdk" />
  <project path="external/rust/crates/jni-sys" name="platform/external/rust/crates/jni-sys" groups="pdk" />
  <project path="external/rust/crates/kernlog" name="platform/external/rust/crates/kernlog" groups="pdk" />
  <project path="external/rust/crates/lazy_static" name="platform/external/rust/crates/lazy_static" groups="pdk" />
  <project path="external/rust/crates/lazycell" name="platform/external/rust/crates/lazycell" groups="pdk" />
  <project path="external/rust/crates/libc" name="platform/external/rust/crates/libc" groups="pdk" />
  <project path="external/rust/crates/libfuzzer-sys" name="platform/external/rust/crates/libfuzzer-sys" groups="pdk" />
  <project path="external/rust/crates/libloading" name="platform/external/rust/crates/libloading" groups="pdk" />
  <project path="external/rust/crates/libm" name="platform/external/rust/crates/libm" groups="pdk" />
  <project path="external/rust/crates/libsqlite3-sys" name="platform/external/rust/crates/libsqlite3-sys" groups="pdk" />
  <project path="external/rust/crates/libz-sys" name="platform/external/rust/crates/libz-sys" groups="pdk" />
  <project path="external/rust/crates/linked-hash-map" name="platform/external/rust/crates/linked-hash-map" groups="pdk" />
  <project path="external/rust/crates/lock_api" name="platform/external/rust/crates/lock_api" groups="pdk" />
  <project path="external/rust/crates/log" name="platform/external/rust/crates/log" groups="pdk" />
  <project path="external/rust/crates/lru-cache" name="platform/external/rust/crates/lru-cache" groups="pdk" />
  <project path="external/rust/crates/macaddr" name="platform/external/rust/crates/macaddr" groups="pdk" />
  <project path="external/rust/crates/managed" name="platform/external/rust/crates/managed" groups="pdk" />
  <project path="external/rust/crates/matches" name="platform/external/rust/crates/matches" groups="pdk" />
  <project path="external/rust/crates/memchr" name="platform/external/rust/crates/memchr" groups="pdk" />
  <project path="external/rust/crates/memoffset" name="platform/external/rust/crates/memoffset" groups="pdk" />
  <project path="external/rust/crates/minimal-lexical" name="platform/external/rust/crates/minimal-lexical" groups="pdk" />
  <project path="external/rust/crates/mio" name="platform/external/rust/crates/mio" groups="pdk" />
  <project path="external/rust/crates/nix" name="platform/external/rust/crates/nix" groups="pdk" />
  <project path="external/rust/crates/no-panic" name="platform/external/rust/crates/no-panic" groups="pdk" />
  <project path="external/rust/crates/nom" name="platform/external/rust/crates/nom" groups="pdk" />
  <project path="external/rust/crates/num-bigint" name="platform/external/rust/crates/num-bigint" groups="pdk" />
  <project path="external/rust/crates/num-derive" name="platform/external/rust/crates/num-derive" groups="pdk" />
  <project path="external/rust/crates/num-integer" name="platform/external/rust/crates/num-integer" groups="pdk" />
  <project path="external/rust/crates/num-traits" name="platform/external/rust/crates/num-traits" groups="pdk" />
  <project path="external/rust/crates/num_cpus" name="platform/external/rust/crates/num_cpus" groups="pdk" />
  <project path="external/rust/crates/oid-registry" name="platform/external/rust/crates/oid-registry" groups="pdk" />
  <project path="external/rust/crates/once_cell" name="platform/external/rust/crates/once_cell" groups="pdk" />
  <project path="external/rust/crates/oorandom" name="platform/external/rust/crates/oorandom" groups="pdk" />
  <project path="external/rust/crates/parking_lot" name="platform/external/rust/crates/parking_lot" groups="pdk" />
  <project path="external/rust/crates/parking_lot_core" name="platform/external/rust/crates/parking_lot_core" groups="pdk" />
  <project path="external/rust/crates/paste" name="platform/external/rust/crates/paste" groups="pdk" />
  <project path="external/rust/crates/peeking_take_while" name="platform/external/rust/crates/peeking_take_while" groups="pdk" />
  <project path="external/rust/crates/percent-encoding" name="platform/external/rust/crates/percent-encoding" groups="pdk" />
  <project path="external/rust/crates/pest" name="platform/external/rust/crates/pest" groups="pdk" />
  <project path="external/rust/crates/pest_derive" name="platform/external/rust/crates/pest_derive" groups="pdk" />
  <project path="external/rust/crates/pest_generator" name="platform/external/rust/crates/pest_generator" groups="pdk" />
  <project path="external/rust/crates/pest_meta" name="platform/external/rust/crates/pest_meta" groups="pdk" />
  <project path="external/rust/crates/pin-project" name="platform/external/rust/crates/pin-project" groups="pdk" />
  <project path="external/rust/crates/pin-project-internal" name="platform/external/rust/crates/pin-project-internal" groups="pdk" />
  <project path="external/rust/crates/pin-project-lite" name="platform/external/rust/crates/pin-project-lite" groups="pdk" />
  <project path="external/rust/crates/pin-utils" name="platform/external/rust/crates/pin-utils" groups="pdk" />
  <project path="external/rust/crates/plotters" name="platform/external/rust/crates/plotters" groups="pdk" />
  <project path="external/rust/crates/plotters-backend" name="platform/external/rust/crates/plotters-backend" groups="pdk" />
  <project path="external/rust/crates/plotters-svg" name="platform/external/rust/crates/plotters-svg" groups="pdk" />
  <project path="external/rust/crates/ppv-lite86" name="platform/external/rust/crates/ppv-lite86" groups="pdk" />
  <project path="external/rust/crates/proc-macro-error" name="platform/external/rust/crates/proc-macro-error" groups="pdk" />
  <project path="external/rust/crates/proc-macro-error-attr" name="platform/external/rust/crates/proc-macro-error-attr" groups="pdk" />
  <project path="external/rust/crates/proc-macro-hack" name="platform/external/rust/crates/proc-macro-hack" groups="pdk" />
  <project path="external/rust/crates/proc-macro-nested" name="platform/external/rust/crates/proc-macro-nested" groups="pdk" />
  <project path="external/rust/crates/proc-macro2" name="platform/external/rust/crates/proc-macro2" groups="pdk" />
  <project path="external/rust/crates/protobuf" name="platform/external/rust/crates/protobuf" groups="pdk" />
  <project path="external/rust/crates/protobuf-codegen" name="platform/external/rust/crates/protobuf-codegen" groups="pdk" />
  <project path="external/rust/crates/quiche" name="platform/external/rust/crates/quiche" groups="pdk" />
  <project path="external/rust/crates/quickcheck" name="platform/external/rust/crates/quickcheck" groups="pdk" />
  <project path="external/rust/crates/quote" name="platform/external/rust/crates/quote" groups="pdk" />
  <project path="external/rust/crates/rand" name="platform/external/rust/crates/rand" groups="pdk" />
  <project path="external/rust/crates/rand_chacha" name="platform/external/rust/crates/rand_chacha" groups="pdk" />
  <project path="external/rust/crates/rand_core" name="platform/external/rust/crates/rand_core" groups="pdk" />
  <project path="external/rust/crates/rand_xorshift" name="platform/external/rust/crates/rand_xorshift" groups="pdk" />
  <project path="external/rust/crates/rayon" name="platform/external/rust/crates/rayon" groups="pdk" />
  <project path="external/rust/crates/rayon-core" name="platform/external/rust/crates/rayon-core" groups="pdk" />
  <project path="external/rust/crates/regex" name="platform/external/rust/crates/regex" groups="pdk" />
  <project path="external/rust/crates/regex-automata" name="platform/external/rust/crates/regex-automata" groups="pdk" />
  <project path="external/rust/crates/regex-syntax" name="platform/external/rust/crates/regex-syntax" groups="pdk" />
  <project path="external/rust/crates/remain" name="platform/external/rust/crates/remain" groups="pdk" />
  <project path="external/rust/crates/remove_dir_all" name="platform/external/rust/crates/remove_dir_all" groups="pdk" />
  <project path="external/rust/crates/ring" name="platform/external/rust/crates/ring" groups="pdk" />
  <project path="external/rust/crates/rusqlite" name="platform/external/rust/crates/rusqlite" groups="pdk" />
  <project path="external/rust/crates/rustc-hash" name="platform/external/rust/crates/rustc-hash" groups="pdk" />
  <project path="external/rust/crates/rusticata-macros" name="platform/external/rust/crates/rusticata-macros" groups="pdk" />
  <project path="external/rust/crates/rustc-demangle" name="platform/external/rust/crates/rustc-demangle" groups="pdk" />
  <project path="external/rust/crates/rustc-demangle-capi" name="platform/external/rust/crates/rustc-demangle-capi" groups="pdk" />
  <project path="external/rust/crates/rustversion" name="platform/external/rust/crates/rustversion" groups="pdk" />
  <project path="external/rust/crates/ryu" name="platform/external/rust/crates/ryu" groups="pdk" />
  <project path="external/rust/crates/same-file" name="platform/external/rust/crates/same-file" groups="pdk" />
  <project path="external/rust/crates/scopeguard" name="platform/external/rust/crates/scopeguard" groups="pdk" />
  <project path="external/rust/crates/semver" name="platform/external/rust/crates/semver" groups="pdk" />
  <project path="external/rust/crates/serde" name="platform/external/rust/crates/serde" groups="pdk" />
  <project path="external/rust/crates/serde_cbor" name="platform/external/rust/crates/serde_cbor" groups="pdk" />
  <project path="external/rust/crates/serde_derive" name="platform/external/rust/crates/serde_derive" groups="pdk" />
  <project path="external/rust/crates/serde_json" name="platform/external/rust/crates/serde_json" groups="pdk" />
  <project path="external/rust/crates/serde_test" name="platform/external/rust/crates/serde_test" groups="pdk" />
  <project path="external/rust/crates/serde-xml-rs" name="platform/external/rust/crates/serde-xml-rs" groups="pdk" />
  <project path="external/rust/crates/shared_child" name="platform/external/rust/crates/shared_child" groups="pdk" />
  <project path="external/rust/crates/shared_library" name="platform/external/rust/crates/shared_library" groups="pdk" />
  <project path="external/rust/crates/shlex" name="platform/external/rust/crates/shlex" groups="pdk" />
  <project path="external/rust/crates/slab" name="platform/external/rust/crates/slab" groups="pdk" />
  <project path="external/rust/crates/smallvec" name="platform/external/rust/crates/smallvec" groups="pdk" />
  <project path="external/rust/crates/spin" name="platform/external/rust/crates/spin" groups="pdk" />
  <project path="external/rust/crates/structopt" name="platform/external/rust/crates/structopt" groups="pdk" />
  <project path="external/rust/crates/structopt-derive" name="platform/external/rust/crates/structopt-derive" groups="pdk" />
  <project path="external/rust/crates/syn" name="platform/external/rust/crates/syn" groups="pdk" />
  <project path="external/rust/crates/syn-mid" name="platform/external/rust/crates/syn-mid" groups="pdk" />
  <project path="external/rust/crates/tempfile" name="platform/external/rust/crates/tempfile" groups="pdk" />
  <project path="external/rust/crates/termcolor" name="platform/external/rust/crates/termcolor" groups="pdk" />
  <project path="external/rust/crates/textwrap" name="platform/external/rust/crates/textwrap" groups="pdk" />
  <project path="external/rust/crates/thiserror" name="platform/external/rust/crates/thiserror" groups="pdk" />
  <project path="external/rust/crates/thiserror-impl" name="platform/external/rust/crates/thiserror-impl" groups="pdk" />
  <project path="external/rust/crates/thread_local" name="platform/external/rust/crates/thread_local" groups="pdk" />
  <project path="external/rust/crates/tinytemplate" name="platform/external/rust/crates/tinytemplate" groups="pdk" />
  <project path="external/rust/crates/tinyvec" name="platform/external/rust/crates/tinyvec" groups="pdk" />
  <project path="external/rust/crates/tinyvec_macros" name="platform/external/rust/crates/tinyvec_macros" groups="pdk" />
  <project path="external/rust/crates/tokio" name="platform/external/rust/crates/tokio" groups="pdk" />
  <project path="external/rust/crates/tokio-macros" name="platform/external/rust/crates/tokio-macros" groups="pdk" />
  <project path="external/rust/crates/tokio-stream" name="platform/external/rust/crates/tokio-stream" groups="pdk" />
  <project path="external/rust/crates/tokio-test" name="platform/external/rust/crates/tokio-test" groups="pdk" />
  <project path="external/rust/crates/ucd-trie" name="platform/external/rust/crates/ucd-trie" groups="pdk" />
  <project path="external/rust/crates/unicode-bidi" name="platform/external/rust/crates/unicode-bidi" groups="pdk" />
  <project path="external/rust/crates/unicode-normalization" name="platform/external/rust/crates/unicode-normalization" groups="pdk" />
  <project path="external/rust/crates/unicode-segmentation" name="platform/external/rust/crates/unicode-segmentation" groups="pdk" />
  <project path="external/rust/crates/unicode-width" name="platform/external/rust/crates/unicode-width" groups="pdk" />
  <project path="external/rust/crates/unicode-xid" name="platform/external/rust/crates/unicode-xid" groups="pdk" />
  <project path="external/rust/crates/untrusted" name="platform/external/rust/crates/untrusted" groups="pdk" />
  <project path="external/rust/crates/url" name="platform/external/rust/crates/url" groups="pdk" />
  <project path="external/rust/crates/uuid" name="platform/external/rust/crates/uuid" groups="pdk" />
  <project path="external/rust/crates/vsock" name="platform/external/rust/crates/vsock" groups="pdk" />
  <project path="external/rust/crates/vulkano" name="platform/external/rust/crates/vulkano" groups="pdk" />
  <project path="external/rust/crates/walkdir" name="platform/external/rust/crates/walkdir" groups="pdk" />
  <project path="external/rust/crates/weak-table" name="platform/external/rust/crates/weak-table" groups="pdk" />
  <project path="external/rust/crates/webpki" name="platform/external/rust/crates/webpki" groups="pdk" />
  <project path="external/rust/crates/which" name="platform/external/rust/crates/which" groups="pdk" />
  <project path="external/rust/crates/x509-parser" name="platform/external/rust/crates/x509-parser" groups="pdk" />
  <project path="external/rust/crates/xml-rs" name="platform/external/rust/crates/xml-rs" groups="pdk" />
  <project path="external/rust/crates/zip" name="platform/external/rust/crates/zip" groups="pdk" />
  <project path="external/rust/cxx" name="platform/external/rust/cxx" groups="pdk" />
  <project path="external/ruy" name="platform/external/ruy" groups="pdk" />
  <project path="external/s2-geometry-library-java" name="platform/external/s2-geometry-library-java" groups="pdk" />
  <project path="external/scapy" name="platform/external/scapy" groups="pdk-fs" />
  <project path="external/scrypt" name="platform/external/scrypt" groups="pdk" />
  <project path="external/scudo" name="platform/external/scudo" groups="pdk" />
  <project path="external/seccomp-tests" name="platform/external/seccomp-tests" groups="pdk" />
  <project path="external/selinux" name="platform/external/selinux" groups="pdk" />
  <project path="external/setupcompat" name="platform/external/setupcompat" groups="pdk" />
  <project path="external/setupdesign" name="platform/external/setupdesign" groups="pdk" />
  <project path="external/sfntly" name="platform/external/sfntly" groups="pdk,qcom_msm8x26" />
  <project path="external/shaderc/spirv-headers" name="platform/external/shaderc/spirv-headers" groups="pdk" />
  <project path="external/shflags" name="platform/external/shflags" groups="pdk" />
  <project path="external/skia" name="platform/external/skia" groups="pdk,qcom_msm8x26" />
  <project path="external/sl4a" name="platform/external/sl4a" groups="pdk" />
  <project path="external/slf4j" name="platform/external/slf4j" groups="pdk" />
  <project path="external/smali" name="platform/external/smali" groups="pdk" />
  <project path="external/snakeyaml" name="platform/external/snakeyaml" groups="pdk" />
  <project path="external/sonic" name="platform/external/sonic" groups="pdk" />
  <project path="external/sonivox" name="platform/external/sonivox" groups="pdk" />
  <project path="external/speex" name="platform/external/speex" groups="pdk" />
  <project path="external/sqlite" name="platform/external/sqlite" groups="pdk" />
  <project path="external/squashfs-tools" name="platform/external/squashfs-tools" groups="pdk" />
  <project path="external/stardoc" name="platform/external/stardoc" groups="pdk" />
  <project path="external/starlark-go" name="platform/external/starlark-go" groups="pdk" />
  <project path="external/strace" name="platform/external/strace" groups="pdk" />
  <project path="external/stressapptest" name="platform/external/stressapptest" groups="pdk" />
  <project path="external/subsampling-scale-image-view" name="platform/external/subsampling-scale-image-view" groups="pdk" clone-depth="1" />
  <project path="external/swiftshader" name="platform/external/swiftshader" groups="pdk" />
  <project path="external/tagsoup" name="platform/external/tagsoup" groups="pdk" />
  <project path="external/tcpdump" name="platform/external/tcpdump" groups="pdk" />
  <project path="external/tensorflow" name="platform/external/tensorflow" groups="pdk" />
  <project path="external/TestParameterInjector" name="platform/external/TestParameterInjector" groups="pdk" />
  <project path="external/testng" name="platform/external/testng" groups="pdk" />
  <project path="external/tflite-support" name="platform/external/tflite-support" groups="pdk" />
  <project path="external/timezone-boundary-builder" name="platform/external/timezone-boundary-builder" groups="pdk" clone-depth="2" />
  <project path="external/tinyalsa" name="platform/external/tinyalsa" groups="pdk" />
  <project path="external/tinyalsa_new" name="platform/external/tinyalsa_new" groups="pdk" />
  <project path="external/tinycompress" name="platform/external/tinycompress" groups="pdk" />
  <project path="external/tinyxml2" name="platform/external/tinyxml2" groups="pdk" />
  <project path="external/toolchain-utils" name="platform/external/toolchain-utils" />
  <project path="external/toybox" name="platform/external/toybox" groups="pdk" />
  <project path="external/tpm2-tss" name="platform/external/tpm2-tss" groups="pdk" />
  <project path="external/trace-cmd" name="platform/external/trace-cmd" groups="pdk" />
  <project path="external/tremolo" name="platform/external/tremolo" groups="pdk" />
  <project path="external/turbine" name="platform/external/turbine" groups="pdk" />
  <project path="external/unicode" name="platform/external/unicode" groups="pdk" />
  <project path="external/universal-tween-engine" name="platform/external/universal-tween-engine" />
  <project path="external/ukey2" name="platform/external/ukey2" groups="pdk" />
  <project path="external/usrsctp" name="platform/external/usrsctp" groups="pdk" />
  <project path="external/uwb" name="platform/external/uwb" groups="pdk" />
  <project path="external/v4l2_codec2" name="platform/external/v4l2_codec2" groups="pdk" />
  <project path="external/vboot_reference" name="platform/external/vboot_reference" groups="vboot,pdk-fs" />
  <project path="external/virglrenderer" name="platform/external/virglrenderer" groups="pdk" />
  <project path="external/vixl" name="platform/external/vixl" groups="pdk" />
  <project path="external/vogar" name="platform/external/vogar" groups="pdk" />
  <project path="external/volley" name="platform/external/volley" groups="pdk" />
  <project path="external/vulkan-headers" name="platform/external/vulkan-headers" groups="pdk" />
  <project path="external/vulkan-validation-layers" name="platform/external/vulkan-validation-layers" groups="pdk" />
  <project path="external/walt" name="platform/external/walt" groups="pdk" />
  <project path="external/wayland" name="platform/external/wayland" groups="pdk" />
  <project path="external/wayland-protocols" name="platform/external/wayland-protocols" groups="pdk" />
  <project path="external/webp" name="platform/external/webp" groups="pdk,qcom_msm8x26" />
  <project path="external/webrtc" name="platform/external/webrtc" groups="pdk" />
  <project path="external/wpa_supplicant_8" name="platform/external/wpa_supplicant_8" groups="pdk" />
  <project path="external/wmediumd" name="platform/external/wmediumd" groups="pdk" />
  <project path="external/wuffs-mirror-release-c" name="platform/external/wuffs-mirror-release-c" groups="pdk,qcom_msm8x26" />
  <project path="external/wycheproof" name="platform/external/wycheproof" groups="pdk" />
  <project path="external/xmp_toolkit" name="platform/external/xmp_toolkit" groups="pdk" />
  <project path="external/xz-embedded" name="platform/external/xz-embedded" groups="pdk" />
  <project path="external/xz-java" name="platform/external/xz-java" groups="pdk" />
  <project path="external/XNNPACK" name="platform/external/XNNPACK" groups="pdk" />
  <project path="external/yapf" name="platform/external/yapf" groups="vts,projectarch,pdk" />
  <project path="external/zlib" name="platform/external/zlib" groups="pdk" />
  <project path="external/zopfli" name="platform/external/zopfli" groups="pdk" />
  <project path="external/zstd" name="platform/external/zstd" groups="pdk" />
  <project path="external/zucchini" name="platform/external/zucchini" groups="pdk" />
  <project path="external/zxing" name="platform/external/zxing" groups="pdk" />
  <project path="frameworks/av" name="platform/frameworks/av" groups="pdk" />
  <project path="frameworks/base" name="platform/frameworks/base" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/compile/libbcc" name="platform/frameworks/compile/libbcc" groups="pdk" />
  <project path="frameworks/compile/mclinker" name="platform/frameworks/compile/mclinker" groups="pdk" />
  <project path="frameworks/compile/slang" name="platform/frameworks/compile/slang" groups="pdk" />
  <project path="frameworks/ex" name="platform/frameworks/ex" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/hardware/interfaces" name="platform/frameworks/hardware/interfaces" groups="pdk" />
  <project path="frameworks/layoutlib" name="platform/frameworks/layoutlib" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/libs/systemui" name="platform/frameworks/libs/systemui" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/libs/modules-utils" name="platform/frameworks/libs/modules-utils" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/libs/net" name="platform/frameworks/libs/net" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/libs/native_bridge_support" name="platform/frameworks/libs/native_bridge_support" groups="pdk" />
  <project path="frameworks/libs/service_entitlement" name="platform/frameworks/libs/service_entitlement" groups="pdk" />
  <project path="frameworks/minikin" name="platform/frameworks/minikin" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/multidex" name="platform/frameworks/multidex" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/native" name="platform/frameworks/native" groups="pdk" />
  <project path="frameworks/opt/bitmap" name="platform/frameworks/opt/bitmap" groups="pdk-fs" />
  <project path="frameworks/opt/calendar" name="platform/frameworks/opt/calendar" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/car/services" name="platform/frameworks/opt/car/services" groups="pdk-fs" />
  <project path="frameworks/opt/car/setupwizard" name="platform/frameworks/opt/car/setupwizard" groups="pdk" />
  <project path="frameworks/opt/chips" name="platform/frameworks/opt/chips" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/colorpicker" name="platform/frameworks/opt/colorpicker" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/localepicker" name="platform/frameworks/opt/localepicker" />
  <project path="frameworks/opt/net/ethernet" name="platform/frameworks/opt/net/ethernet" groups="pdk-fs" />
  <project path="frameworks/opt/net/ims" name="platform/frameworks/opt/net/ims" groups="frameworks_ims,pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/net/voip" name="platform/frameworks/opt/net/voip" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/net/wifi" name="platform/frameworks/opt/net/wifi" groups="pdk" />
  <project path="frameworks/opt/photoviewer" name="platform/frameworks/opt/photoviewer" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/setupwizard" name="platform/frameworks/opt/setupwizard" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/telephony" name="platform/frameworks/opt/telephony" groups="pdk" />
  <project path="frameworks/opt/timezonepicker" name="platform/frameworks/opt/timezonepicker" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/tv/tvsystem" name="platform/frameworks/opt/tv/tvsystem" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/opt/vcard" name="platform/frameworks/opt/vcard" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/proto_logging" name="platform/frameworks/proto_logging" groups="pdk-cw-fs,pdk-fs" />
  <project path="frameworks/rs" name="platform/frameworks/rs" groups="pdk" />
  <project path="frameworks/wilhelm" name="platform/frameworks/wilhelm" groups="pdk-cw-fs,pdk-fs" />
  <project path="hardware/broadcom/libbt" name="platform/hardware/broadcom/libbt" groups="pdk" />
  <project path="hardware/broadcom/wlan" name="platform/hardware/broadcom/wlan" groups="pdk,broadcom_wlan" />
  <project path="hardware/google/apf" name="platform/hardware/google/apf" groups="pdk" />
  <project path="hardware/google/av" name="platform/hardware/google/av" groups="pdk" />
  <project path="hardware/google/camera" name="platform/hardware/google/camera" groups="pdk" />
  <project path="hardware/google/easel" name="platform/hardware/google/easel" groups="pdk,easel" />
  <project path="hardware/google/gchips" name="platform/hardware/google/gchips" groups="pdk-lassen,pdk-gs-arm" />
  <project path="hardware/google/graphics/common" name="platform/hardware/google/graphics/common" groups="pdk-lassen,pdk-gs-arm" />
  <project path="hardware/google/graphics/gs101" name="platform/hardware/google/graphics/gs101" groups="pdk-lassen,pdk-gs-arm" />
  <project path="hardware/google/graphics/gs201" name="platform/hardware/google/graphics/gs201" groups="cloudripper" />
  <project path="hardware/google/interfaces" name="platform/hardware/google/interfaces" groups="pdk" />
  <project path="hardware/google/pixel" name="platform/hardware/google/pixel" groups="generic_fs,pixel" />
  <project path="hardware/google/pixel-sepolicy" name="platform/hardware/google/pixel-sepolicy" groups="generic_fs,pixel" />
  <project path="hardware/interfaces" name="platform/hardware/interfaces" groups="pdk" />
  <project path="hardware/invensense" name="platform/hardware/invensense" groups="invensense,pdk" />
  <project path="hardware/knowles/athletico/sound_trigger_hal" name="platform/hardware/knowles/athletico/sound_trigger_hal" groups="coral,generic_fs" />
  <project path="hardware/libhardware" name="platform/hardware/libhardware" groups="pdk" />
  <project path="hardware/libhardware_legacy" name="platform/hardware/libhardware_legacy" groups="pdk" />
  <project path="hardware/nxp/nfc" name="platform/hardware/nxp/nfc" groups="pdk" />
  <project path="hardware/nxp/secure_element" name="platform/hardware/nxp/secure_element" groups="pdk" />
  <project path="hardware/qcom/audio" name="platform/hardware/qcom/audio" groups="qcom,qcom_audio,pdk-qcom" />
  <project path="hardware/qcom/bootctrl" name="platform/hardware/qcom/bootctrl" groups="pdk-qcom" />
  <project path="hardware/qcom/bt" name="platform/hardware/qcom/bt" groups="qcom,pdk-qcom" />
  <project path="hardware/qcom/camera" name="platform/hardware/qcom/camera" groups="qcom_camera,pdk-qcom" />
  <project path="hardware/qcom/data/ipacfg-mgr" name="platform/hardware/qcom/data/ipacfg-mgr" groups="qcom,pdk-qcom" />
  <project path="hardware/qcom/display" name="platform/hardware/qcom/display" groups="pdk-qcom,qcom,qcom_display" />
  <project path="hardware/qcom/gps" name="platform/hardware/qcom/gps" groups="qcom,qcom_gps,pdk-qcom" />
  <project path="hardware/qcom/keymaster" name="platform/hardware/qcom/keymaster" groups="qcom,qcom_keymaster,pdk-qcom" />
  <project path="hardware/qcom/media" name="platform/hardware/qcom/media" groups="qcom,pdk-qcom" />
  <project path="hardware/qcom/msm8960" name="platform/hardware/qcom/msm8960" groups="qcom_msm8960,pdk-qcom" />
  <project path="hardware/qcom/msm8994" name="platform/hardware/qcom/msm8994" groups="qcom_msm8994,pdk-qcom" />
  <project path="hardware/qcom/msm8996" name="platform/hardware/qcom/msm8996" groups="qcom_msm8996,pdk-qcom" />
  <project path="hardware/qcom/msm8x09" name="platform/hardware/qcom/msm8x09" groups="qcom_msm8x09" />
  <project path="hardware/qcom/msm8x26" name="platform/hardware/qcom/msm8x26" groups="qcom_msm8x26,pdk-qcom" />
  <project path="hardware/qcom/msm8x27" name="platform/hardware/qcom/msm8x27" groups="qcom_msm8x27,pdk-qcom" />
  <project path="hardware/qcom/msm8x84" name="platform/hardware/qcom/msm8x84" groups="qcom_msm8x84,pdk-qcom" />
  <project path="hardware/qcom/power" name="platform/hardware/qcom/power" groups="qcom,pdk-qcom" />
  <project path="hardware/qcom/sdm845/bt" name="platform/hardware/qcom/sdm845/bt" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sdm845/data/ipacfg-mgr" name="platform/hardware/qcom/sdm845/data/ipacfg-mgr" groups="generic_fs,vendor,qcom_sdm845" >
    <linkfile src="os_pickup.mk" dest="hardware/qcom/sdm845/Android.mk" />
    <linkfile src="os_pickup.bp" dest="hardware/qcom/sdm845/Android.bp" />
  </project>
  <project path="hardware/qcom/sdm845/display" name="platform/hardware/qcom/sdm845/display" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sdm845/gps" name="platform/hardware/qcom/sdm845/gps" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sdm845/media" name="platform/hardware/qcom/sdm845/media" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sdm845/thermal" name="platform/hardware/qcom/sdm845/thermal" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sdm845/vr" name="platform/hardware/qcom/sdm845/vr" groups="generic_fs,qcom_sdm845" />
  <project path="hardware/qcom/sm7150/gps" name="platform/hardware/qcom/sm7150/gps" groups="qcom_sm7150" >
    <linkfile src="os_pickup.mk" dest="hardware/qcom/sm7150/Android.mk" />
    <linkfile src="os_pickup.bp" dest="hardware/qcom/sm7150/Android.bp" />
  </project>
  <project path="hardware/qcom/sm7250/display" name="platform/hardware/qcom/sm7250/display" groups="qcom_sm7250" />
  <project path="hardware/qcom/sm7250/gps" name="platform/hardware/qcom/sm7250/gps" groups="qcom_sm7250" >
    <linkfile src="os_pickup.mk" dest="hardware/qcom/sm7250/Android.mk" />
    <linkfile src="os_pickup.bp" dest="hardware/qcom/sm7250/Android.bp" />
  </project>
  <project path="hardware/qcom/sm7250/media" name="platform/hardware/qcom/sm7250/media" groups="qcom_sm7250" />
  <project path="hardware/qcom/sm8150/data/ipacfg-mgr" name="platform/hardware/qcom/sm8150/data/ipacfg-mgr" groups="qcom_sm8150" >
    <linkfile src="os_pickup.mk" dest="hardware/qcom/sm8150/Android.mk" />
    <linkfile src="os_pickup.bp" dest="hardware/qcom/sm8150/Android.bp" />
  </project>
  <project path="hardware/qcom/sm8150/display" name="platform/hardware/qcom/sm8150/display" groups="qcom_sm8150" />
  <project path="hardware/qcom/sm8150/gps" name="platform/hardware/qcom/sm8150/gps" groups="qcom_sm8150" />
  <project path="hardware/qcom/sm8150/media" name="platform/hardware/qcom/sm8150/media" groups="qcom_sm8150" />
  <project path="hardware/qcom/sm8150/thermal" name="platform/hardware/qcom/sm8150/thermal" groups="qcom_sm8150" />
  <project path="hardware/qcom/sm8150/vr" name="platform/hardware/qcom/sm8150/vr" groups="qcom_sm8150" />
  <project path="hardware/qcom/sm8150p/gps" name="platform/hardware/qcom/sm8150p/gps" groups="qcom_sm8150p" >
    <linkfile src="os_pickup.mk" dest="hardware/qcom/sm8150p/Android.mk" />
    <linkfile src="os_pickup.bp" dest="hardware/qcom/sm8150p/Android.bp" />
  </project>
  <project path="hardware/qcom/wlan" name="platform/hardware/qcom/wlan" groups="qcom_wlan,pdk-qcom" />
  <project path="hardware/ril" name="platform/hardware/ril" groups="pdk" />
  <project path="hardware/st/nfc" name="platform/hardware/st/nfc" groups="pdk" />
  <project path="hardware/st/secure_element" name="platform/hardware/st/secure_element" groups="pdk" />
  <project path="hardware/st/secure_element2" name="platform/hardware/st/secure_element2" groups="pdk" />
  <project path="hardware/samsung/nfc" name="platform/hardware/samsung/nfc" groups="pdk" />
  <project path="hardware/ti/am57x" name="platform/hardware/ti/am57x" groups="pdk" />
  <project path="kernel/configs" name="kernel/configs" groups="vts,pdk" />
  <project path="kernel/prebuilts/4.19/arm64" name="kernel/prebuilts/4.19/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.4/arm64" name="kernel/prebuilts/5.4/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.4/x86_64" name="kernel/prebuilts/5.4/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.10/arm64" name="kernel/prebuilts/5.10/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.10/x86_64" name="kernel/prebuilts/5.10/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.15/arm64" name="kernel/prebuilts/5.15/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/5.15/x86_64" name="kernel/prebuilts/5.15/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/mainline/arm64" name="kernel/prebuilts/mainline/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/mainline/x86_64" name="kernel/prebuilts/mainline/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/4.19/arm64" name="kernel/prebuilts/common-modules/virtual-device/4.19/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/4.19/x86-64" name="kernel/prebuilts/common-modules/virtual-device/4.19/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.10/arm64" name="kernel/prebuilts/common-modules/virtual-device/5.10/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.10/x86-64" name="kernel/prebuilts/common-modules/virtual-device/5.10/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.15/arm64" name="kernel/prebuilts/common-modules/virtual-device/5.15/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.15/x86-64" name="kernel/prebuilts/common-modules/virtual-device/5.15/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.4/arm64" name="kernel/prebuilts/common-modules/virtual-device/5.4/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/5.4/x86-64" name="kernel/prebuilts/common-modules/virtual-device/5.4/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/mainline/arm64" name="kernel/prebuilts/common-modules/virtual-device/mainline/arm64" groups="pdk" clone-depth="1" />
  <project path="kernel/prebuilts/common-modules/virtual-device/mainline/x86-64" name="kernel/prebuilts/common-modules/virtual-device/mainline/x86-64" groups="pdk" clone-depth="1" />
  <project path="kernel/tests" name="kernel/tests" groups="vts,pdk" />
  <project path="libcore" name="platform/libcore" groups="pdk" />
  <project path="libnativehelper" name="platform/libnativehelper" groups="pdk" />
  <project path="packages/apps/BasicSmsReceiver" name="platform/packages/apps/BasicSmsReceiver" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/Browser2" name="platform/packages/apps/Browser2" groups="pdk-fs" />
  <project path="packages/apps/Calendar" name="platform/packages/apps/Calendar" groups="pdk-fs" />
  <project path="packages/apps/Camera2" name="platform/packages/apps/Camera2" groups="pdk-fs" />
  <project path="packages/apps/Car/Calendar" name="platform/packages/apps/Car/Calendar" groups="pdk-fs" />
  <project path="packages/apps/Car/SystemUI" name="platform/packages/apps/Car/SystemUI" groups="pdk-fs" />
  <project path="packages/apps/Car/Cluster" name="platform/packages/apps/Car/Cluster" groups="pdk-fs" />
  <project path="packages/apps/Car/DebuggingRestrictionController" name="platform/packages/apps/Car/DebuggingRestrictionController" groups="pdk-fs" />
  <project path="packages/apps/Car/DialerPrebuilt" name="platform/packages/apps/Car/DialerPrebuilt" groups="pdk-fs" />
  <project path="packages/apps/Car/Hvac" name="platform/packages/apps/Car/Hvac" groups="pdk-fs" />
  <project path="packages/apps/Car/LatinIME" name="platform/packages/apps/Car/LatinIME" groups="pdk-fs" />
  <project path="packages/apps/Car/Launcher" name="platform/packages/apps/Car/Launcher" groups="pdk-fs" />
  <project path="packages/apps/Car/LinkViewer" name="platform/packages/apps/Car/LinkViewer" groups="pdk-fs" />
  <project path="packages/apps/Car/LocalMediaPlayer" name="platform/packages/apps/Car/LocalMediaPlayer" groups="pdk-fs" />
  <project path="packages/apps/Car/MediaPrebuilt" name="platform/packages/apps/Car/MediaPrebuilt" groups="pdk-fs" />
  <project path="packages/apps/Car/MessengerPrebuilt" name="platform/packages/apps/Car/MessengerPrebuilt" groups="pdk-fs" />
  <project path="packages/apps/Car/Notification" name="platform/packages/apps/Car/Notification" groups="pdk-fs" />
  <project path="packages/apps/Car/Provision" name="platform/packages/apps/Car/Provision" groups="pdk-fs" />
  <project path="packages/apps/Car/Radio" name="platform/packages/apps/Car/Radio" groups="pdk-fs" />
  <project path="packages/apps/Car/RotaryController" name="platform/packages/apps/Car/RotaryController" groups="pdk-fs" />
  <project path="packages/apps/Car/Settings" name="platform/packages/apps/Car/Settings" groups="pdk-fs" />
  <project path="packages/apps/Car/SettingsIntelligence" name="platform/packages/apps/Car/SettingsIntelligence" groups="pdk-fs" />
  <project path="packages/apps/Car/systemlibs" name="platform/packages/apps/Car/systemlibs" groups="pdk-fs" />
  <project path="packages/apps/Car/SystemUpdater" name="platform/packages/apps/Car/SystemUpdater" groups="pdk-fs" />
  <project path="packages/apps/CarrierConfig" name="platform/packages/apps/CarrierConfig" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/CellBroadcastReceiver" name="platform/packages/apps/CellBroadcastReceiver" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/CertInstaller" name="platform/packages/apps/CertInstaller" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/Contacts" name="platform/packages/apps/Contacts" groups="pdk-fs" />
  <project path="packages/apps/DeskClock" name="platform/packages/apps/DeskClock" groups="pdk-fs" />
  <project path="packages/apps/DevCamera" name="platform/packages/apps/DevCamera" groups="pdk" />
  <project path="packages/apps/Dialer" name="platform/packages/apps/Dialer" groups="pdk-fs" />
  <project path="packages/apps/DocumentsUI" name="platform/packages/apps/DocumentsUI" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/EmergencyInfo" name="platform/packages/apps/EmergencyInfo" groups="pdk-fs" />
  <project path="packages/apps/Gallery" name="platform/packages/apps/Gallery" groups="pdk-fs" />
  <project path="packages/apps/Gallery2" name="platform/packages/apps/Gallery2" groups="pdk-fs" />
  <project path="packages/apps/HTMLViewer" name="platform/packages/apps/HTMLViewer" groups="pdk-fs" />
  <project path="packages/apps/ImsServiceEntitlement" name="platform/packages/apps/ImsServiceEntitlement" groups="pdk-fs" />
  <project path="packages/apps/KeyChain" name="platform/packages/apps/KeyChain" groups="pdk-fs" />
  <project path="packages/apps/Launcher3" name="platform/packages/apps/Launcher3" groups="pdk-fs" />
  <project path="packages/apps/LegacyCamera" name="platform/packages/apps/LegacyCamera" groups="pdk-fs" />
  <project path="packages/apps/ManagedProvisioning" name="platform/packages/apps/ManagedProvisioning" groups="pdk-fs" />
  <project path="packages/apps/Messaging" name="platform/packages/apps/Messaging" groups="pdk-fs" />
  <project path="packages/apps/Music" name="platform/packages/apps/Music" groups="pdk-fs" />
  <project path="packages/apps/MusicFX" name="platform/packages/apps/MusicFX" groups="pdk-fs" />
  <project path="packages/apps/Nfc" name="platform/packages/apps/Nfc" groups="apps_nfc,pdk-fs" />
  <project path="packages/apps/OnDeviceAppPrediction" name="platform/packages/apps/OnDeviceAppPrediction" groups="pdk-fs" />
  <project path="packages/apps/OneTimeInitializer" name="platform/packages/apps/OneTimeInitializer" groups="pdk-fs" />
  <project path="packages/apps/PhoneCommon" name="platform/packages/apps/PhoneCommon" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/apps/Protips" name="platform/packages/apps/Protips" groups="pdk-fs" />
  <project path="packages/apps/Provision" name="platform/packages/apps/Provision" groups="pdk-fs" />
  <project path="packages/apps/QuickSearchBox" name="platform/packages/apps/QuickSearchBox" groups="pdk-fs" />
  <project path="packages/apps/QuickAccessWallet" name="platform/packages/apps/QuickAccessWallet" groups="pdk-fs" />
  <project path="packages/apps/RemoteProvisioner" name="platform/packages/apps/RemoteProvisioner" groups="pdk-fs" />
  <project path="packages/apps/SafetyRegulatoryInfo" name="platform/packages/apps/SafetyRegulatoryInfo" groups="pdk-fs" />
  <project path="packages/apps/SampleLocationAttribution" name="platform/packages/apps/SampleLocationAttribution" groups="pdk-fs" />
  <project path="packages/apps/SecureElement" name="platform/packages/apps/SecureElement" groups="apps_se,pdk-fs" />
  <project path="packages/apps/Settings" name="platform/packages/apps/Settings" groups="pdk-fs" />
  <project path="packages/apps/SettingsIntelligence" name="platform/packages/apps/SettingsIntelligence" groups="pdk-fs" />
  <project path="packages/apps/SpareParts" name="platform/packages/apps/SpareParts" groups="pdk-fs" />
  <project path="packages/apps/Stk" name="platform/packages/apps/Stk" groups="apps_stk,pdk-fs" />
  <project path="packages/apps/StorageManager" name="platform/packages/apps/StorageManager" groups="pdk-fs" />
  <project path="packages/apps/SystemUIGo" name="platform/packages/apps/SystemUIGo" groups="pdk-fs" />
  <project path="packages/apps/Tag" name="platform/packages/apps/Tag" groups="pdk-fs" />
  <project path="packages/apps/Test/connectivity" name="platform/packages/apps/Test/connectivity" groups="pdk" />
  <project path="packages/apps/TimeZoneData" name="platform/packages/apps/TimeZoneData" groups="pdk" />
  <project path="packages/apps/TimeZoneUpdater" name="platform/packages/apps/TimeZoneUpdater" groups="pdk" />
  <project path="packages/apps/ThemePicker" name="platform/packages/apps/ThemePicker" groups="pdk-fs" />
  <project path="packages/apps/Traceur" name="platform/packages/apps/Traceur" groups="pdk-fs" />
  <project path="packages/apps/TvSettings" name="platform/packages/apps/TvSettings" groups="pdk-fs" />
  <project path="packages/apps/TV" name="platform/packages/apps/TV" groups="pdk" />
  <project path="packages/apps/UniversalMediaPlayer" name="platform/packages/apps/UniversalMediaPlayer" />
  <project path="packages/apps/WallpaperPicker" name="platform/packages/apps/WallpaperPicker" groups="pdk-fs"  />
  <project path="packages/apps/WallpaperPicker2" name="platform/packages/apps/WallpaperPicker2" groups="pdk-fs" />
  <project path="packages/inputmethods/LatinIME" name="platform/packages/inputmethods/LatinIME" groups="pdk-fs" />
  <project path="packages/inputmethods/LeanbackIME" name="platform/packages/inputmethods/LeanbackIME" groups="pdk-fs" />
  <project path="packages/modules/adb" name="platform/packages/modules/adb" groups="pdk" />
  <project path="packages/modules/AdServices" name="platform/packages/modules/AdServices" groups="pdk-fs" />
  <project path="packages/modules/AppSearch" name="platform/packages/modules/AppSearch" groups="pdk" />
  <project path="packages/modules/ArtPrebuilt" name="platform/packages/modules/ArtPrebuilt" groups="pdk" clone-depth="1" />
  <project path="packages/modules/Bluetooth" name="platform/packages/modules/Bluetooth" groups="pdk" />
  <project path="packages/modules/BootPrebuilt/5.4/arm64" name="platform/packages/modules/BootPrebuilt/5.4/arm64" groups="pdk" clone-depth="1" />
  <project path="packages/modules/BootPrebuilt/5.10/arm64" name="platform/packages/modules/BootPrebuilt/5.10/arm64" groups="pdk" clone-depth="1" />
  <project path="packages/modules/CaptivePortalLogin" name="platform/packages/modules/CaptivePortalLogin" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/CellBroadcastService" name="platform/packages/modules/CellBroadcastService" groups="pdk" />
  <project path="packages/modules/common" name="platform/packages/modules/common" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Connectivity" name="platform/packages/modules/Connectivity" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/ExtServices" name="platform/packages/modules/ExtServices" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/GeoTZ" name="platform/packages/modules/GeoTZ" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Gki" name="platform/packages/modules/Gki" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/IntentResolver" name="platform/packages/modules/IntentResolver" groups="pdk" />
  <project path="packages/modules/IPsec" name="platform/packages/modules/IPsec" groups="pdk" />
  <project path="packages/modules/DnsResolver" name="platform/packages/modules/DnsResolver" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Media" name="platform/packages/modules/Media" groups="pdk" />
  <project path="packages/modules/ModuleMetadata" name="platform/packages/modules/ModuleMetadata" groups="pdk" />
  <project path="packages/modules/NetworkPermissionConfig" name="platform/packages/modules/NetworkPermissionConfig" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/NetworkStack" name="platform/packages/modules/NetworkStack" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/NeuralNetworks" name="platform/packages/modules/NeuralNetworks" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/OnDevicePersonalization" name="platform/packages/modules/OnDevicePersonalization" groups="pdk-fs" />
  <project path="packages/modules/Permission" name="platform/packages/modules/Permission" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/RuntimeI18n" name="platform/packages/modules/RuntimeI18n" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Scheduling" name="platform/packages/modules/Scheduling" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/SEPolicy" name="platform/packages/modules/SEPolicy" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/SdkExtensions" name="platform/packages/modules/SdkExtensions" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/StatsD" name="platform/packages/modules/StatsD" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/TestModule" name="platform/packages/modules/TestModule" />
  <project path="packages/modules/Uwb" name="platform/packages/modules/Uwb" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Virtualization" name="platform/packages/modules/Virtualization" groups="pdk" />
  <project path="packages/modules/vndk" name="platform/packages/modules/vndk" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/modules/Wifi" name="platform/packages/modules/Wifi" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/BlockedNumberProvider" name="platform/packages/providers/BlockedNumberProvider" groups="pdk-fs" />
  <project path="packages/providers/BookmarkProvider" name="platform/packages/providers/BookmarkProvider" groups="pdk-fs" />
  <project path="packages/providers/CalendarProvider" name="platform/packages/providers/CalendarProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/CallLogProvider" name="platform/packages/providers/CallLogProvider" groups="pdk-fs" />
  <project path="packages/providers/ContactsProvider" name="platform/packages/providers/ContactsProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/DownloadProvider" name="platform/packages/providers/DownloadProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/MediaProvider" name="platform/packages/providers/MediaProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/PartnerBookmarksProvider" name="platform/packages/providers/PartnerBookmarksProvider" groups="pdk-fs" />
  <project path="packages/providers/TelephonyProvider" name="platform/packages/providers/TelephonyProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/providers/TvProvider" name="platform/packages/providers/TvProvider" groups="pdk-fs" />
  <project path="packages/providers/UserDictionaryProvider" name="platform/packages/providers/UserDictionaryProvider" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/screensavers/Basic" name="platform/packages/screensavers/Basic" groups="pdk-fs" />
  <project path="packages/screensavers/PhotoTable" name="platform/packages/screensavers/PhotoTable" groups="pdk-fs" />
  <project path="packages/services/BuiltInPrintService" name="platform/packages/services/BuiltInPrintService" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/AlternativeNetworkAccess" name="platform/packages/services/AlternativeNetworkAccess" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/Car" name="platform/packages/services/Car" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/Iwlan" name="platform/packages/services/Iwlan" groups="pdk-cw-fs,pdk-fs"/>
  <project path="packages/services/Mms" name="platform/packages/services/Mms" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/Mtp" name="platform/packages/services/Mtp" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/Telecomm" name="platform/packages/services/Telecomm" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/services/Telephony" name="platform/packages/services/Telephony" groups="pdk-cw-fs,pdk-fs" />
  <project path="packages/wallpapers/ImageWallpaper" name="platform/packages/wallpapers/ImageWallpaper" groups="pdk-fs" />
  <project path="packages/wallpapers/LivePicker" name="platform/packages/wallpapers/LivePicker" groups="pdk-fs" />
  <project path="pdk" name="platform/pdk" groups="pdk" />
  <project path="platform_testing" name="platform/platform_testing" groups="pdk-fs,pdk-cw-fs,cts" />
  <project path="prebuilts/abi-dumps/ndk" name="platform/prebuilts/abi-dumps/ndk" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/abi-dumps/platform" name="platform/prebuilts/abi-dumps/platform" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/abi-dumps/vndk" name="platform/prebuilts/abi-dumps/vndk" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/android-emulator" name="platform/prebuilts/android-emulator" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/asuite" name="platform/prebuilts/asuite" groups="pdk" clone-depth="1" />
  <project path="prebuilts/bazel/darwin-x86_64" name="platform/prebuilts/bazel/darwin-x86_64" groups="darwin,pdk" clone-depth="1" />
  <project path="prebuilts/bazel/linux-x86_64" name="platform/prebuilts/bazel/linux-x86_64" groups="linux,pdk" clone-depth="1" />
  <project path="prebuilts/build-tools" name="platform/prebuilts/build-tools" groups="pdk" clone-depth="1" />
  <project path="prebuilts/bundletool" name="platform/prebuilts/bundletool" groups="pdk" clone-depth="1" />
  <project path="prebuilts/checkcolor" name="platform/prebuilts/checkcolor" groups="pdk" clone-depth="1" />
  <project path="prebuilts/checkstyle" name="platform/prebuilts/checkstyle" groups="pdk" clone-depth="1" />
  <project path="prebuilts/clang-tools" name="platform/prebuilts/clang-tools" groups="pdk" clone-depth="1" />
  <project path="prebuilts/clang/host/darwin-x86" name="platform/prebuilts/clang/host/darwin-x86" groups="pdk,darwin" clone-depth="1" />
  <project path="prebuilts/clang/host/linux-x86" name="platform/prebuilts/clang/host/linux-x86" groups="pdk" clone-depth="1" />
  <project path="prebuilts/cmdline-tools" name="platform/prebuilts/cmdline-tools" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/devtools" name="platform/prebuilts/devtools" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.17-4.8" name="platform/prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.17-4.8" groups="pdk,linux" clone-depth="1" />
  <project path="prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8" name="platform/prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8" groups="pdk-fs" clone-depth="1" />
  <project path="prebuilts/go/darwin-x86" name="platform/prebuilts/go/darwin-x86" groups="darwin,pdk,tradefed" clone-depth="1" />
  <project path="prebuilts/go/linux-x86" name="platform/prebuilts/go/linux-x86" groups="linux,pdk,tradefed" clone-depth="1" />
  <project path="prebuilts/gradle-plugin" name="platform/prebuilts/gradle-plugin" groups="pdk,pdk-cw-fs,pdk-fs" clone-depth="1" />
  <project path="prebuilts/jdk/jdk11" name="platform/prebuilts/jdk/jdk11" groups="pdk" clone-depth="1" />
  <project path="prebuilts/jdk/jdk17" name="platform/prebuilts/jdk/jdk17" groups="pdk" clone-depth="1" />
  <project path="prebuilts/jdk/jdk8" name="platform/prebuilts/jdk/jdk8" groups="pdk" clone-depth="1" />
  <project path="prebuilts/jdk/jdk9" name="platform/prebuilts/jdk/jdk9" groups="pdk" clone-depth="1" />
  <project path="prebuilts/manifest-merger" name="platform/prebuilts/manifest-merger" groups="pdk" clone-depth="1" />
  <project path="prebuilts/maven_repo/android" name="platform/prebuilts/maven_repo/android" groups="pdk-cw-fs,pdk-fs" clone-depth="1" />
  <project path="prebuilts/maven_repo/bumptech" name="platform/prebuilts/maven_repo/bumptech" groups="pdk-cw-fs,pdk-fs" clone-depth="1" />
  <project path="prebuilts/misc" name="platform/prebuilts/misc" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/art" name="platform/prebuilts/module_sdk/art" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/AdServices" name="platform/prebuilts/module_sdk/AdServices" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/AppSearch" name="platform/prebuilts/module_sdk/AppSearch" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Bluetooth" name="platform/prebuilts/module_sdk/Bluetooth" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/conscrypt" name="platform/prebuilts/module_sdk/conscrypt" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Connectivity" name="platform/prebuilts/module_sdk/Connectivity" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/IPsec" name="platform/prebuilts/module_sdk/IPsec" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Media" name="platform/prebuilts/module_sdk/Media" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/MediaProvider" name="platform/prebuilts/module_sdk/MediaProvider" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/OnDevicePersonalization" name="platform/prebuilts/module_sdk/OnDevicePersonalization" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Permission" name="platform/prebuilts/module_sdk/Permission" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Scheduling" name="platform/prebuilts/module_sdk/Scheduling" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/SdkExtensions" name="platform/prebuilts/module_sdk/SdkExtensions" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/StatsD" name="platform/prebuilts/module_sdk/StatsD" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Uwb" name="platform/prebuilts/module_sdk/Uwb" groups="pdk" clone-depth="1" />
  <project path="prebuilts/module_sdk/Wifi" name="platform/prebuilts/module_sdk/Wifi" groups="pdk" clone-depth="1" />
  <project path="prebuilts/ndk" name="platform/prebuilts/ndk" groups="pdk" clone-depth="1" />
  <project path="prebuilts/ktlint" name="platform/prebuilts/ktlint" groups="pdk" clone-depth="1" />
  <project path="prebuilts/qemu-kernel" name="platform/prebuilts/qemu-kernel" groups="pdk" clone-depth="1" />
  <project path="prebuilts/remoteexecution-client" name="platform/prebuilts/remoteexecution-client" groups="pdk" clone-depth="1" />
  <project path="prebuilts/runtime" name="platform/prebuilts/runtime" groups="pdk" clone-depth="1" />
  <project path="prebuilts/rust" name="platform/prebuilts/rust" groups="pdk" clone-depth="1" />
  <project path="prebuilts/r8" name="platform/prebuilts/r8" groups="pdk" clone-depth="1" />
  <project path="prebuilts/sdk" name="platform/prebuilts/sdk" groups="pdk" clone-depth="1" />
  <project path="prebuilts/tools" name="platform/prebuilts/tools" groups="pdk,tools" clone-depth="1" />
  <project path="prebuilts/vndk/v28" name="platform/prebuilts/vndk/v28" groups="pdk" clone-depth="1" />
  <project path="prebuilts/vndk/v29" name="platform/prebuilts/vndk/v29" groups="pdk" clone-depth="1" />
  <project path="prebuilts/vndk/v30" name="platform/prebuilts/vndk/v30" groups="pdk" clone-depth="1" />
  <project path="prebuilts/vndk/v31" name="platform/prebuilts/vndk/v31" groups="pdk" clone-depth="1" />
  <project path="prebuilts/vndk/v32" name="platform/prebuilts/vndk/v32" groups="pdk" clone-depth="1" />
  <project path="sdk" name="platform/sdk" groups="pdk-cw-fs,pdk-fs" />
  <project path="system/apex" name="platform/system/apex" groups="pdk" />
  <project path="system/bpf" name="platform/system/bpf" groups="pdk" />
  <project path="system/bpfprogs" name="platform/system/bpfprogs" groups="pdk" />
  <project path="system/ca-certificates" name="platform/system/ca-certificates" groups="pdk" />
  <project path="system/chre" name="platform/system/chre"  groups="pdk" />
  <project path="system/connectivity/wificond" name="platform/system/connectivity/wificond" groups="pdk" />
  <project path="system/core" name="platform/system/core" groups="pdk" />
  <project path="system/dmesgd" name="platform/system/dmesgd" groups="pdk" />
  <project path="system/extras" name="platform/system/extras" groups="pdk" />
  <project path="system/gatekeeper" name="platform/system/gatekeeper" groups="pdk" />
  <project path="system/gsid" name="platform/system/gsid" groups="pdk" />
  <project path="system/hardware/interfaces" name="platform/system/hardware/interfaces" groups="pdk" />
  <project path="system/hwservicemanager" name="platform/system/hwservicemanager" groups="pdk" />
  <project path="system/incremental_delivery" name="platform/system/incremental_delivery" groups="pdk" />
  <project path="system/iorap" name="platform/system/iorap" groups="pdk" />
  <project path="system/keymaster" name="platform/system/keymaster" groups="pdk" />
  <project path="system/libartpalette" name="platform/system/libartpalette" groups="pdk" />
  <project path="system/libbase" name="platform/system/libbase" groups="pdk" />
  <project path="system/libfmq" name="platform/system/libfmq" groups="pdk" />
  <project path="system/libhidl" name="platform/system/libhidl" groups="pdk" />
  <project path="system/libhwbinder" name="platform/system/libhwbinder" groups="pdk" />
  <project path="system/libprocinfo" name="platform/system/libprocinfo" groups="pdk" />
  <project path="system/librustutils" name="platform/system/librustutils" groups="pdk" />
  <project path="system/libsysprop" name="platform/system/libsysprop" groups="pdk" />
  <project path="system/libufdt" name="platform/system/libufdt" groups="pdk" />
  <project path="system/libvintf" name="platform/system/libvintf" groups="pdk" />
  <project path="system/libziparchive" name="platform/system/libziparchive" groups="pdk" />
  <project path="system/linkerconfig" name="platform/system/linkerconfig" groups="pdk" />
  <project path="system/logging" name="platform/system/logging" groups="pdk" />
  <project path="system/media" name="platform/system/media" groups="pdk" />
  <project path="system/memory/libion" name="platform/system/memory/libion" groups="pdk" />
  <project path="system/memory/libdmabufheap" name="platform/system/memory/libdmabufheap" groups="pdk" />
  <project path="system/memory/libmeminfo" name="platform/system/memory/libmeminfo" groups="pdk" />
  <project path="system/memory/libmemtrack" name="platform/system/memory/libmemtrack" groups="pdk" />
  <project path="system/memory/libmemunreachable" name="platform/system/memory/libmemunreachable" groups="pdk" />
  <project path="system/memory/lmkd" name="platform/system/memory/lmkd" groups="pdk" />
  <project path="system/netd" name="platform/system/netd" groups="pdk" />
  <project path="system/nfc" name="platform/system/nfc" groups="pdk" />
  <project path="system/nvram" name="platform/system/nvram" groups="pdk" />
  <project path="system/security" name="platform/system/security" groups="pdk" />
  <project path="system/sepolicy" name="platform/system/sepolicy" groups="pdk" />
  <project path="system/server_configurable_flags" name="platform/system/server_configurable_flags" groups="pdk"/>
  <project path="system/teeui" name="platform/system/teeui" groups="pdk" />
  <project path="system/testing/gtest_extras" name="platform/system/testing/gtest_extras" groups="pdk" />
  <project path="system/timezone" name="platform/system/timezone" groups="pdk" />
  <project path="system/tools/aidl" name="platform/system/tools/aidl" groups="pdk" />
  <project path="system/tools/hidl" name="platform/system/tools/hidl" groups="pdk" />
  <project path="system/tools/mkbootimg" name="platform/system/tools/mkbootimg" groups="pdk" />
  <project path="system/tools/sysprop" name="platform/system/tools/sysprop" groups="pdk" />
  <project path="system/tools/xsdc" name="platform/system/tools/xsdc" groups="pdk" />
  <project path="system/unwinding" name="platform/system/unwinding" groups="pdk" />
  <project path="system/update_engine" name="platform/system/update_engine" groups="pdk" />
  <project path="system/vold" name="platform/system/vold" groups="pdk" />
  <project path="test/framework" name="platform/test/framework" groups="vts,projectarch,pdk" />
  <project path="test/mlts/benchmark" name="platform/test/mlts/benchmark" groups="pdk" />
  <project path="test/mlts/models" name="platform/test/mlts/models" groups="pdk" />
  <project path="test/app_compat/csuite" name="platform/test/app_compat/csuite" groups="pdk" />
  <project path="test/cts-root" name="platform/test/cts-root" />
  <project path="test/mts" name="platform/test/mts" />
  <project path="test/vts" name="platform/test/vts" groups="vts,pdk" />
  <project path="test/vts-testcase/fuzz" name="platform/test/vts-testcase/fuzz" groups="vts,projectarch,pdk" />
  <project path="test/vts-testcase/hal" name="platform/test/vts-testcase/hal" groups="vts,pdk" />
  <project path="test/vts-testcase/hal-trace" name="platform/test/vts-testcase/hal-trace" groups="vts,pdk" />
  <project path="test/vts-testcase/kernel" name="platform/test/vts-testcase/kernel" groups="vts,pdk" />
  <project path="test/vts-testcase/nbu" name="platform/test/vts-testcase/nbu" groups="vts,projectarch,pdk" />
  <project path="test/vts-testcase/performance" name="platform/test/vts-testcase/performance" groups="vts,projectarch,pdk" />
  <project path="test/vts-testcase/security" name="platform/test/vts-testcase/security" groups="vts,projectarch,pdk" />
  <project path="test/vts-testcase/vndk" name="platform/test/vts-testcase/vndk" groups="vts,pdk" />
  <project path="test/catbox" name="platform/test/catbox" />
  <project path="toolchain/benchmark" name="toolchain/benchmark" />
  <project path="toolchain/pgo-profiles" name="toolchain/pgo-profiles" groups="pdk" />
  <project path="tools/aadevtools" name="platform/tools/aadevtools" groups="pdk" />
  <project path="tools/acloud" name="platform/tools/acloud" groups="tools,vts,projectarch,pdk,tradefed" />
  <project path="tools/adt/idea" name="platform/tools/adt/idea" groups="notdefault,tools" />
  <project path="tools/apifinder" name="platform/tools/apifinder" groups="pdk,tools" />
  <project path="tools/apksig" name="platform/tools/apksig" groups="pdk,tradefed" />
  <project path="tools/apkzlib" name="platform/tools/apkzlib" groups="pdk,tradefed" />
  <project path="tools/asuite" name="platform/tools/asuite" groups="pdk" />
  <project path="tools/base" name="platform/tools/base" groups="notdefault,tools" />
  <project path="tools/build" name="platform/tools/build" groups="notdefault,tools" />
  <project path="tools/carrier_settings" name="platform/tools/carrier_settings" groups="tools" />
  <project path="tools/currysrc" name="platform/tools/currysrc" groups="pdk" />
  <project path="tools/dexter" name="platform/tools/dexter" groups="tools,pdk-fs" />
  <project path="tools/doc_generation" name="platform/tools/doc_generation" groups="tools,pdk" />
  <project path="tools/external_updater" name="platform/tools/external_updater" groups="tools" />
  <project path="tools/external/fat32lib" name="platform/tools/external/fat32lib" groups="tools" />
  <project path="tools/idea" name="platform/tools/idea" groups="notdefault,tools" />
  <project path="tools/loganalysis" name="platform/tools/loganalysis" groups="nopresubmit,pdk,tradefed" />
  <project path="tools/metalava" name="platform/tools/metalava" groups="pdk,tools" />
  <project path="tools/motodev" name="platform/tools/motodev" groups="notdefault,motodev" />
  <project path="tools/platform-compat" name="tools/platform-compat" groups="pdk-cw-fs,pdk-fs,pdk" />
  <project path="tools/ndkports" name="platform/tools/ndkports" groups="pdk" />
  <project path="tools/security" name="platform/tools/security" groups="pdk,tools" />
  <project path="tools/studio/cloud" name="platform/tools/studio/cloud" groups="notdefault,tools" />
  <project path="tools/swt" name="platform/tools/swt" groups="notdefault,tools" />
  <project path="tools/test/connectivity" name="platform/tools/test/connectivity" groups="pdk" />
  <project path="tools/test/graphicsbenchmark" name="platform/tools/test/graphicsbenchmark" groups="pdk" />
  <project path="tools/test/mobly_snippets" name="platform/tools/test/mobly_snippets" groups="pdk" />
  <project path="tools/test/openhst" name="platform/tools/test/openhst" groups="tools" />
  <project path="tools/tradefederation/prebuilts" name="platform/tools/tradefederation/prebuilts" groups="pdk,tradefed" clone-depth="1" />
  <project path="tools/treble" name="platform/tools/treble" groups="tools,pdk" />
  <project path="tools/trebuchet" name="platform/tools/trebuchet" groups="tools,cts,pdk,pdk-cw-fs,pdk-fs" />
  <!-- END open-source projects -->
</manifest>
```

比如我们要下载 apksig 的源码，就可以找到

```xml
  <project path="tools/apksig" name="platform/tools/apksig" groups="pdk,tradefed" />
```
把这里的 name 取出来，拼上`https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/`得到一个链接`https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/tools/apksig`，用`git clone https://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/tools/apksig`的形式就可以下载到对应的代码了。]]></content>
  </entry>
  <entry>
    <title>C++ ini 实现</title>
    <url>/2024/07/31/ini-impl-in-cpp/</url>
    <content><![CDATA[首先是从 https://github.com/benhoyt/inih 取用的 ini 读取类头文件

<!-- more -->

```cpp
//file ini.h
/* inih -- simple .INI file parser

SPDX-License-Identifier: BSD-3-Clause

Copyright (C) 2009-2020, Ben Hoyt

inih is released under the New BSD license (see LICENSE.txt). Go to the project
home page for more info:

https://github.com/benhoyt/inih

*/

#ifndef INI_H
#define INI_H

/* Make this header file easier to include in C++ code */
#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>

    /* Nonzero if ini_handler callback should accept lineno parameter. */
#ifndef INI_HANDLER_LINENO
#define INI_HANDLER_LINENO 0
#endif

/* Visibility symbols, required for Windows DLLs */
#ifndef INI_API
#if defined _WIN32 || defined __CYGWIN__
#	ifdef INI_SHARED_LIB
#		ifdef INI_SHARED_LIB_BUILDING
#			define INI_API __declspec(dllexport)
#		else
#			define INI_API __declspec(dllimport)
#		endif
#	else
#		define INI_API
#	endif
#else
#	if defined(__GNUC__) && __GNUC__ >= 4
#		define INI_API __attribute__ ((visibility ("default")))
#	else
#		define INI_API
#	endif
#endif
#endif

/* Typedef for prototype of handler function. */
#if INI_HANDLER_LINENO
    typedef int (*ini_handler)(void* user, const char* section,
        const char* name, const char* value,
        int lineno);
#else
    typedef int (*ini_handler)(void* user, const char* section,
        const char* name, const char* value);
#endif

    /* Typedef for prototype of fgets-style reader function. */
    typedef char* (*ini_reader)(char* str, int num, void* stream);

    /* Parse given INI-style file. May have [section]s, name=value pairs
       (whitespace stripped), and comments starting with ';' (semicolon). Section
       is "" if name=value pair parsed before any section heading. name:value
       pairs are also supported as a concession to Python's configparser.

       For each name=value pair parsed, call handler function with given user
       pointer as well as section, name, and value (data only valid for duration
       of handler call). Handler should return nonzero on success, zero on error.

       Returns 0 on success, line number of first error on parse error (doesn't
       stop on first error), -1 on file open error, or -2 on memory allocation
       error (only when INI_USE_STACK is zero).
    */
    INI_API int ini_parse(const char* filename, ini_handler handler, void* user);

    /* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
       close the file when it's finished -- the caller must do that. */
    INI_API int ini_parse_file(FILE* file, ini_handler handler, void* user);

    /* Same as ini_parse(), but takes an ini_reader function pointer instead of
       filename. Used for implementing custom or string-based I/O (see also
       ini_parse_string). */
    INI_API int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
        void* user);

    /* Same as ini_parse(), but takes a zero-terminated string with the INI data
    instead of a file. Useful for parsing INI data from a network socket or
    already in memory. */
    INI_API int ini_parse_string(const char* string, ini_handler handler, void* user);

    /* Nonzero to allow multi-line value parsing, in the style of Python's
       configparser. If allowed, ini_parse() will call the handler with the same
       name for each subsequent line parsed. */
#ifndef INI_ALLOW_MULTILINE
#define INI_ALLOW_MULTILINE 1
#endif

       /* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
          the file. See https://github.com/benhoyt/inih/issues/21 */
#ifndef INI_ALLOW_BOM
#define INI_ALLOW_BOM 1
#endif

          /* Chars that begin a start-of-line comment. Per Python configparser, allow
             both ; and # comments at the start of a line by default. */
#ifndef INI_START_COMMENT_PREFIXES
#define INI_START_COMMENT_PREFIXES ";#"
#endif

             /* Nonzero to allow inline comments (with valid inline comment characters
                specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
                Python 3.2+ configparser behaviour. */
#ifndef INI_ALLOW_INLINE_COMMENTS
#define INI_ALLOW_INLINE_COMMENTS 1
#endif
#ifndef INI_INLINE_COMMENT_PREFIXES
#define INI_INLINE_COMMENT_PREFIXES ";"
#endif

                /* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
#ifndef INI_USE_STACK
#define INI_USE_STACK 1
#endif

/* Maximum line length for any line in INI file (stack or heap). Note that
   this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
#ifndef INI_MAX_LINE
#define INI_MAX_LINE 200
#endif

   /* Nonzero to allow heap line buffer to grow via realloc(), zero for a
      fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
      zero. */
#ifndef INI_ALLOW_REALLOC
#define INI_ALLOW_REALLOC 0
#endif

      /* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
         is zero. */
#ifndef INI_INITIAL_ALLOC
#define INI_INITIAL_ALLOC 200
#endif

         /* Stop parsing on first error (default is to keep parsing). */
#ifndef INI_STOP_ON_FIRST_ERROR
#define INI_STOP_ON_FIRST_ERROR 0
#endif

/* Nonzero to call the handler at the start of each new section (with
   name and value NULL). Default is to only call the handler on
   each name=value pair. */
#ifndef INI_CALL_HANDLER_ON_NEW_SECTION
#define INI_CALL_HANDLER_ON_NEW_SECTION 0
#endif

   /* Nonzero to allow a name without a value (no '=' or ':' on the line) and
      call the handler with value NULL in this case. Default is to treat
      no-value lines as an error. */
#ifndef INI_ALLOW_NO_VALUE
#define INI_ALLOW_NO_VALUE 0
#endif

      /* Nonzero to use custom ini_malloc, ini_free, and ini_realloc memory
         allocation functions (INI_USE_STACK must also be 0). These functions must
         have the same signatures as malloc/free/realloc and behave in a similar
         way. ini_realloc is only needed if INI_ALLOW_REALLOC is set. */
#ifndef INI_CUSTOM_ALLOCATOR
#define INI_CUSTOM_ALLOCATOR 0
#endif


#ifdef __cplusplus
}
#endif

#endif /* INI_H */
```

和对应的 ini 读取实现

```cpp
//file ini.c
/* inih -- simple .INI file parser

SPDX-License-Identifier: BSD-3-Clause

Copyright (C) 2009-2020, Ben Hoyt

inih is released under the New BSD license (see LICENSE.txt). Go to the project
home page for more info:

https://github.com/benhoyt/inih

*/

#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif

#include <stdio.h>
#include <ctype.h>
#include <string.h>

#include "ini.h"

#if !INI_USE_STACK
#if INI_CUSTOM_ALLOCATOR
#include <stddef.h>
void* ini_malloc(size_t size);
void ini_free(void* ptr);
void* ini_realloc(void* ptr, size_t size);
#else
#include <stdlib.h>
#define ini_malloc malloc
#define ini_free free
#define ini_realloc realloc
#endif
#endif

#define MAX_SECTION 50
#define MAX_NAME 50

/* Used by ini_parse_string() to keep track of string parsing state. */
typedef struct {
    const char* ptr;
    size_t num_left;
} ini_parse_string_ctx;

/* Strip whitespace chars off end of given string, in place. Return s. */
static char* rstrip(char* s)
{
    char* p = s + strlen(s);
    while (p > s && isspace((unsigned char)(*--p)))
        *p = '\0';
    return s;
}

/* Return pointer to first non-whitespace char in given string. */
static char* lskip(const char* s)
{
    while (*s && isspace((unsigned char)(*s)))
        s++;
    return (char*)s;
}

/* Return pointer to first char (of chars) or inline comment in given string,
   or pointer to NUL at end of string if neither found. Inline comment must
   be prefixed by a whitespace character to register as a comment. */
static char* find_chars_or_comment(const char* s, const char* chars)
{
#if INI_ALLOW_INLINE_COMMENTS
    int was_space = 0;
    while (*s && (!chars || !strchr(chars, *s)) &&
        !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
        was_space = isspace((unsigned char)(*s));
        s++;
    }
#else
    while (*s && (!chars || !strchr(chars, *s))) {
        s++;
    }
#endif
    return (char*)s;
}

/* Similar to strncpy, but ensures dest (size bytes) is
   NUL-terminated, and doesn't pad with NULs. */
static char* strncpy0(char* dest, const char* src, size_t size)
{
    /* Could use strncpy internally, but it causes gcc warnings (see issue #91) */
    size_t i;
    for (i = 0; i < size - 1 && src[i]; i++)
        dest[i] = src[i];
    dest[i] = '\0';
    return dest;
}

/* See documentation in header file. */
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
    void* user)
{
    /* Uses a fair bit of stack (use heap instead if you need to) */
#if INI_USE_STACK
    char line[INI_MAX_LINE];
    size_t max_line = INI_MAX_LINE;
#else
    char* line;
    size_t max_line = INI_INITIAL_ALLOC;
#endif
#if INI_ALLOW_REALLOC && !INI_USE_STACK
    char* new_line;
    size_t offset;
#endif
    char section[MAX_SECTION] = "";
    char prev_name[MAX_NAME] = "";

    char* start;
    char* end;
    char* name;
    char* value;
    int lineno = 0;
    int error = 0;

#if !INI_USE_STACK
    line = (char*)ini_malloc(INI_INITIAL_ALLOC);
    if (!line) {
        return -2;
    }
#endif

#if INI_HANDLER_LINENO
#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
#else
#define HANDLER(u, s, n, v) handler(u, s, n, v)
#endif

    /* Scan through stream line by line */
    while (reader(line, (int)max_line, stream) != NULL) {
#if INI_ALLOW_REALLOC && !INI_USE_STACK
        offset = strlen(line);
        while (offset == max_line - 1 && line[offset - 1] != '\n') {
            max_line *= 2;
            if (max_line > INI_MAX_LINE)
                max_line = INI_MAX_LINE;
            new_line = ini_realloc(line, max_line);
            if (!new_line) {
                ini_free(line);
                return -2;
            }
            line = new_line;
            if (reader(line + offset, (int)(max_line - offset), stream) == NULL)
                break;
            if (max_line >= INI_MAX_LINE)
                break;
            offset += strlen(line + offset);
        }
#endif

        lineno++;

        start = line;
#if INI_ALLOW_BOM
        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
            (unsigned char)start[1] == 0xBB &&
            (unsigned char)start[2] == 0xBF) {
            start += 3;
        }
#endif
        start = lskip(rstrip(start));

        if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
            /* Start-of-line comment */
        }
#if INI_ALLOW_MULTILINE
        else if (*prev_name && *start && start > line) {
#if INI_ALLOW_INLINE_COMMENTS
            end = find_chars_or_comment(start, NULL);
            if (*end)
                *end = '\0';
            rstrip(start);
#endif
            /* Non-blank line with leading whitespace, treat as continuation
               of previous name's value (as per Python configparser). */
            if (!HANDLER(user, section, prev_name, start) && !error)
                error = lineno;
        }
#endif
        else if (*start == '[') {
            /* A "[section]" line */
            end = find_chars_or_comment(start + 1, "]");
            if (*end == ']') {
                *end = '\0';
                strncpy0(section, start + 1, sizeof(section));
                *prev_name = '\0';
#if INI_CALL_HANDLER_ON_NEW_SECTION
                if (!HANDLER(user, section, NULL, NULL) && !error)
                    error = lineno;
#endif
            }
            else if (!error) {
                /* No ']' found on section line */
                error = lineno;
            }
        }
        else if (*start) {
            /* Not a comment, must be a name[=:]value pair */
            end = find_chars_or_comment(start, "=:");
            if (*end == '=' || *end == ':') {
                *end = '\0';
                name = rstrip(start);
                value = end + 1;
#if INI_ALLOW_INLINE_COMMENTS
                end = find_chars_or_comment(value, NULL);
                if (*end)
                    *end = '\0';
#endif
                value = lskip(value);
                rstrip(value);

                /* Valid name[=:]value pair found, call handler */
                strncpy0(prev_name, name, sizeof(prev_name));
                if (!HANDLER(user, section, name, value) && !error)
                    error = lineno;
            }
            else if (!error) {
                /* No '=' or ':' found on name[=:]value line */
#if INI_ALLOW_NO_VALUE
                * end = '\0';
                name = rstrip(start);
                if (!HANDLER(user, section, name, NULL) && !error)
                    error = lineno;
#else
                error = lineno;
#endif
            }
        }

#if INI_STOP_ON_FIRST_ERROR
        if (error)
            break;
#endif
    }

#if !INI_USE_STACK
    ini_free(line);
#endif

    return error;
}

/* See documentation in header file. */
int ini_parse_file(FILE* file, ini_handler handler, void* user)
{
    return ini_parse_stream((ini_reader)fgets, file, handler, user);
}

/* See documentation in header file. */
int ini_parse(const char* filename, ini_handler handler, void* user)
{
    FILE* file;
    int error;

    file = fopen(filename, "r");
    if (!file)
        return -1;
    error = ini_parse_file(file, handler, user);
    fclose(file);
    return error;
}

/* An ini_reader function to read the next line from a string buffer. This
   is the fgets() equivalent used by ini_parse_string(). */
static char* ini_reader_string(char* str, int num, void* stream) {
    ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
    const char* ctx_ptr = ctx->ptr;
    size_t ctx_num_left = ctx->num_left;
    char* strp = str;
    char c;

    if (ctx_num_left == 0 || num < 2)
        return NULL;

    while (num > 1 && ctx_num_left != 0) {
        c = *ctx_ptr++;
        ctx_num_left--;
        *strp++ = c;
        if (c == '\n')
            break;
        num--;
    }

    *strp = '\0';
    ctx->ptr = ctx_ptr;
    ctx->num_left = ctx_num_left;
    return str;
}

/* See documentation in header file. */
int ini_parse_string(const char* string, ini_handler handler, void* user) {
    ini_parse_string_ctx ctx;

    ctx.ptr = string;
    ctx.num_left = strlen(string);
    return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
        user);
}
```
用CPP封装一下
```cpp
//file IniParser.h
#pragma once
#include<unordered_map>
#include<string>
#include<iostream>
#include<vector>
static std::string __EMPTY_STRING = "";
class IniParser
{
public:
    IniParser(const char* inifile);
    ~IniParser();
    std::string GetString(const std::string& section, const std::string& key, const std::string& def = __EMPTY_STRING);
    double GetDouble(const std::string& section, const std::string& key, double def);
    bool GetBoolean(const std::string& section, const std::string& key, bool def);
    std::vector<std::string> GetSections();
    std::vector<std::string> GetKeysOfSection(const std::string& section);
    friend int iniHandler(void* user, const char* section, const char* name, const char* value);
    friend std::ostream& operator<<(std::ostream& out, const IniParser& obj);
private:
    void addNewRecord(const char* section, const char* key, const char* value);

    std::unordered_map<std::string, std::unordered_map<std::string, std::string>> mCaches;
};
```
加上对应的实现
```cpp
#include "IniParser.h"
#include "ini.h"
#include <stdlib.h>
#include <string.h>

static int iniHandler(void* user, const char* section, const char* name, const char* value)
{
    IniParser* parser = (IniParser*)(user);
    parser->addNewRecord(section, name, value);
    return 1;
}

std::ostream& operator<<(std::ostream& out, const IniParser& obj)
{
    for (auto& sec : obj.mCaches)
    {
        out << "[" << sec.first << "]\n";
        for (auto& keyValue : sec.second)
        {
            out << keyValue.first << " = " << keyValue.second << "\n";
        }
    }
    out << std::flush;
    return out;
}

IniParser::IniParser(const char* inifile)
{
    int ret = ini_parse(inifile, iniHandler, this);
}

IniParser::~IniParser()
{
}

std::string IniParser::GetString(const std::string& section, const std::string& key, const std::string& def)
{
    auto sec = mCaches.find(section);
    if (sec != mCaches.end())
    {
        auto keyValue = sec->second.find(key);
        if (keyValue != sec->second.end())
        {
            return keyValue->second;
        }
    }
    return def;
}

double IniParser::GetDouble(const std::string& section, const std::string& key, double def)
{
    auto ret = GetString(section, key);
    if (ret.empty())
    {
        return def;
    }
    try {
        double result = std::stod(ret);
        return result;
    }
    catch (std::exception& e) {
        return def;
    }
}

bool IniParser::GetBoolean(const std::string& section, const std::string& key, bool def)
{
    auto ret = GetString(section, key);
    if (ret.empty())
    {
        return def;
    }
    char firstChar = ret.at(0);
    return firstChar == 'T' || firstChar == 'Y' || firstChar == 'y' || firstChar == '1' || firstChar == 't';
}

std::vector<std::string> IniParser::GetSections()
{
    std::vector<std::string> ret;
    for (auto& sec : mCaches)
    {
        ret.emplace_back(sec.first);
    }
    return ret;
}

std::vector<std::string> IniParser::GetKeysOfSection(const std::string& section)
{
    std::vector<std::string> ret;
    auto sec = mCaches.find(section);
    if (sec != mCaches.end())
    {
        for (auto& keyValues : sec->second)
        {
            ret.emplace_back(keyValues.first);
        }
    }
    return ret;
}

void IniParser::addNewRecord(const char* section, const char* key, const char* value)
{
    if (section == nullptr || key == nullptr || value == nullptr) 
    {
        return;
    }
#define EMPTY(s) (strlen(s) == 0)
    if (EMPTY(section) || EMPTY(key) || EMPTY(value)) {
        return;
    }
    auto sec = mCaches.find(section);
    if (sec == mCaches.end())
    {
        std::unordered_map<std::string, std::string> tmpMap;
        tmpMap.emplace(key, value);
        mCaches.emplace(section, std::move(tmpMap));
    }
    else
    {
        auto ret = sec->second.try_emplace(key, value);
        if (!ret.second)
        {
            sec->second[key] = value;
        }
    }
}
```]]></content>
  </entry>
  <entry>
    <title>在 Centos 7.4 上安装Gcc 7.3</title>
    <url>/2018/04/16/install-gcc-7-3-on-centos-7-4/</url>
    <content><![CDATA[依旧是那个老生常谈的问题，Cent OS上的软件包大都很老，比如常用的Gcc，在最新的Cent OS 7.4上，gcc的版本才到4.8.5，虽说一味追求新版并无大用，但是有些特性老版本不支持啊，很坑的有木有。
下面记录一下安装过程。

<!--more -->

## 描述

系统为Cent OS7.4，全新安装，更新全部软件至最新版。

## 安装准备

```bash
yum update -y
yum install gcc gcc-c++ gcc-gnat zlib-devel glibc-devel glibc-devel.i686 libgcc libgcc.i686 -y
```

安装 glibc-devel.i686 是为了安装32位的头文件和库，否则在配置的时候就会出现下面的错误

```bash
configure: error: I suspect your system does not have 32-bit developement libraries (libc and headers). If you have them, rerun configure with --enable-multilib. If you do not have them, and want to build a 64-bit-only compiler, rerun configure with --disable-multilib.
```

网络上清一色的叫你加入参数`--disable-multilib`，然而，这样的话就少了32位的支持了。

## 动手

```
wget https://mirrors.tuna.tsinghua.edu.cn/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz
tar -zxf gcc-7.3.0.tar.gz
cd gcc-7.3.0
./contrib/download_prerequisites
mkdir builddir && cd builddir
../configure
make && sudo make install
```

编译过程长达数个小时，具体要多长时间得看RP了，可以用tmux把它放在后台。
需要配置的地方非常少，安装过程也没什么特殊的，但是以前安装gcc的时候随便报个错就一脸懵逼，需要注意的是在`./contrib/download_prerequisites`之后，会有执行成功的提示，log如下

```bash
2018-04-16 16:37:22 URL: ftp://gcc.gnu.org/pub/gcc/infrastructure/gmp-6.1.0.tar.bz2 [2383840] -> "./gmp-6.1.0.tar.bz2" [1]
2018-04-16 16:37:28 URL: ftp://gcc.gnu.org/pub/gcc/infrastructure/mpfr-3.1.4.tar.bz2 [1279284] -> "./mpfr-3.1.4.tar.bz2" [1]
2018-04-16 16:37:33 URL: ftp://gcc.gnu.org/pub/gcc/infrastructure/mpc-1.0.3.tar.gz [669925] -> "./mpc-1.0.3.tar.gz" [1]
2018-04-16 16:37:39 URL: ftp://gcc.gnu.org/pub/gcc/infrastructure/isl-0.16.1.tar.bz2 [1626446] -> "./isl-0.16.1.tar.bz2" [1]
gmp-6.1.0.tar.bz2: OK
mpfr-3.1.4.tar.bz2: OK
mpc-1.0.3.tar.gz: OK
isl-0.16.1.tar.bz2: OK
All prerequisites downloaded successfully.
```

这个步骤是有可能因为网络原因出问题的，这个步骤可以把安装gcc需要的四个依赖包弄好，网络上的某些教程是让你手动安装依赖，比如这个[https://www.cnblogs.com/freeweb/p/5990860.html](https://www.cnblogs.com/freeweb/p/5990860.html)，操作越多越容易出错。

另外，配置同样是需要考虑的地方，大多数时候直接执行`./configure`就过去了，我用了下面的配置参数

```bash
../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix --enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-linker-hash-style=gnu --enable-languages=c,c++,objc,obj-c++,fortran,ada,go,lto --enable-plugin --enable-initfini-array --disable-libgcj --enable-gnu-indirect-function --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
```

选择这个参数并没有什么非常实在的原因，里面很多参数我并不清楚是干嘛的，使用这个参数纯粹是因为Cent OS用yum安装的gcc的配置参数是这个。

## 安装gdb

在某些情况下，升级了gcc是需要同步升级gdb的，虽然不清楚是否有具体的版本对应关系，但是傻fufu的安装最新版就是了

```
wget https://mirrors.tuna.tsinghua.edu.cn/gnu/gdb/gdb-8.1.tar.gz
tar -zxf gdb-8.1.tar.gz
cd gdb-8.1
mkdir builddir && cd builddir
../configure
make && make install
```

## 碎碎念

有可能在执行`make install`的时候报错（内心PS，都已经编译好了，你给我在安装的时候报错(ノ｀Д)ノ）报错信息如下:

```bash
WARNING: 'makeinfo' is missing on your system.
         You should only need it if you modified a '.texi' file, or
         any other file indirectly affecting the aspect of the manual.
         You might want to install the Texinfo package:
         <http://www.gnu.org/software/texinfo/>
         The spurious makeinfo call might also be the consequence of
         using a buggy 'make' (AIX, DU, IRIX), in which case you might
         want to install GNU make:
         <http://www.gnu.org/software/make/>
make[5]: *** [gdb.info] Error 127
make[5]: Leaving directory `/root/gdb-8.1/build/gdb/doc'
make[4]: *** [subdir_do] Error 1
make[4]: Leaving directory `/root/gdb-8.1/build/gdb'
make[3]: *** [install-only] Error 2
make[3]: Leaving directory `/root/gdb-8.1/build/gdb'
make[2]: *** [install] Error 2
make[2]: Leaving directory `/root/gdb-8.1/build/gdb'
make[1]: *** [install-gdb] Error 2
make[1]: Leaving directory `/root/gdb-8.1/build'
make: *** [install] Error 2
```

需要`yum install texinfo`，然后再执行`make install`。
至于原本安装好的gcc的话，应该是没了吧，我是找不到它了。
安装软件的推荐性是这样的`官方源>知名第三方源>手动编译>不知名第三方源`，很多时候，手动编译需要自己安装依赖，很多时候，自己安装依赖还会需要安装依赖的依赖，某些极端情况下，还会遇到依赖循环，令人十分的窒息。
自行编译安装并不是很推荐的操作，并且很多时候新版并不一定就更好，Cent OS一直用着老版本的软件并不是没有道理的。
建立`builddir`的目的，只是为了让编译产生的文件集中在一个地方，免得主目录一大堆文件看起来不方便。
Ubuntu/Debia的软件版本一般都比较新，不值得花大量时间手动编译。
{% asset_img 1.jpg 来张合影 %}
]]></content>
  </entry>
  <entry>
    <title>在Linux上安装node.js</title>
    <url>/2017/01/08/install-node-js-on-a-Linux-OS/</url>
    <content><![CDATA[在之前的文章中提及，使用“Hexo”，需要安装`node.js`,Windows上安装很方便，在其官网下载安装包之后，按照正常的步骤安装即可食用。
{% asset_img 1.jpg %}
<!-- more -->
## 说明
在linux中安装却成了问题，在大多数的Linux发行版中，默认源的node.js版本大都跟不上官方最新版，在我之前的文章————本站建立中，所使用的方法是hexo官网提及的办法
``` bash
$ curl https://raw.github.com/creationix/nvm/master/install.sh | sh
```
或者
``` bash
$ wget -q0- https://raw.github.com/creationix/master/install.sh | sh
```
实际上，我在使用了这个办法之后，确实能正常安装node.js，但是，安装之后`最大的问题就是终端打开时间大大变长`(鄙人感觉是脚本为系统添加了某些打开终端就执行的东西)，很是不爽，所以决定不用上面的方法安装。
然后，在官网下载了源码，手动编译安装。
## 实战
我拿到的node.js版本是6.9.4，下载到源码之后，得到的是一个.tar.gz文件，我们需要解压它，然后执行一下configure
``` bash
$ wget https://nodejs.org/dist/latest-v6.x/node-v6.9.4-linux-x64.tar.gz
$ tar -xvf node-v6.9.4.tar.gz
$ cd node-v6.9.4/
$ ./configure
```
这个时候屏幕上应该显示以下信息
``` bash
creating ./icu_config.gypi
* Using ICU in deps/icu-small
creating ./icu_config.gypi
{ 'target_defaults': { 'cflags': [],
                       'default_configuration': 'Release',
                       'defines': [],
                       'include_dirs': [],
                       'libraries': []},
  'variables': { 'asan': 0,
                 'coverage': 'false',
                 'debug_devtools': 'node',
                 'force_dynamic_crt': 0,
                 'gas_version': '2.24',
                 'host_arch': 'x64',
                 'icu_data_file': 'icudt57l.dat',
                 'icu_data_in': '../../deps/icu-small/source/data/in/icudt57l.dat',
                 'icu_endianness': 'l',
                 'icu_gyp_path': 'tools/icu/icu-generic.gyp',
                 'icu_locales': 'en,root',
                 'icu_path': 'deps/icu-small',
                 'icu_small': 'true',
                 'icu_ver_major': '57',
                 'node_byteorder': 'little',
                 'node_enable_d8': 'false',
                 'node_enable_v8_vtunejit': 'false',
                 'node_install_npm': 'true',
                 'node_module_version': 48,
                 'node_no_browser_globals': 'false',
                 'node_prefix': '/usr/local',
                 'node_release_urlbase': '',
                 'node_shared': 'false',
                 'node_shared_cares': 'false',
                 'node_shared_http_parser': 'false',
                 'node_shared_libuv': 'false',
                 'node_shared_openssl': 'false',
                 'node_shared_zlib': 'false',
                 'node_tag': '',
                 'node_use_bundled_v8': 'true',
                 'node_use_dtrace': 'false',
                 'node_use_etw': 'false',
                 'node_use_lttng': 'false',
                 'node_use_openssl': 'true',
                 'node_use_perfctr': 'false',
                 'node_use_v8_platform': 'true',
                 'openssl_fips': '',
                 'openssl_no_asm': 0,
                 'shlib_suffix': 'so.48',
                 'target_arch': 'x64',
                 'uv_parent_path': '/deps/uv/',
                 'uv_use_dtrace': 'false',
                 'v8_enable_gdbjit': 0,
                 'v8_enable_i18n_support': 1,
                 'v8_inspector': 'true',
                 'v8_no_strict_aliasing': 1,
                 'v8_optimized_debug': 0,
                 'v8_random_seed': 0,
                 'v8_use_snapshot': 'true',
                 'want_separate_host_toolset': 0}}
creating ./config.gypi
creating ./config.mk
```
然后，准备编译
``` bash
$ make
```
屏幕上会滚动编译信息，编译时间视电脑性能而定，编译结束后，输入
``` bash
make install
```
检验是否安装成功
``` bash
$ node -v
$ npm -v
```
有返回信息则安装成功，若是提示没有此命令，则安装失败。

## 安装失败的解决办法
编译node.js需要gcc/g++的版本为4.8以上
我在ubuntu 14.04，cent OS 6上测试均成功安装。
需要注意的是，cent os 可能没有默认安装g++,需要这样
``` bash
$ yum update -y
$ yum install gcc-c++ -y
```
Enjoy it!
## node.js下载地址
由于node.js官网在国外，在国内下载源码速度实在是不怎么理想，特意在百度云备份了以一下([点我下载](https://pan.baidu.com/s/1pKBZv79))
{% cq%} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>tecnology</tag>
        <tag>Linux</tag>
        <tag>node.js</tag>
      </tags>
  </entry>
  <entry>
    <title>在树莓派3B上安装node.js</title>
    <url>/2017/01/09/install-node-js-on-raspberry-3B/</url>
    <content><![CDATA[本文主讲如何在[树莓派3B](http://baike.baidu.com/link?url=ot2d79aySf4R7ksNlecgKZ3YoHX3qNTAQKCQd7Ui0XodvmTNa019AaEpAPNaRjvbjoifBEcCZNIYyhXHPU7InrO9aG9-6tdk6GvHqUydTgEw8Wtl7sUNecnR7NJCXsr7)上安装node.js  (在之前的文章中说了通用的办法————编译node.js源码，但是树莓派的性能太弱，编译时间非常长)
{% asset_img 1.jpg raspberry 3B %}
<!-- more -->
## 环境描述
1. 树莓派安装了`2016-11-25-raspbian-jessie-lite`(PS：在此版本的镜像中，默认禁用了ssh，在烧录好镜像之后，在`boot`分区中新建一个名为`ssh`的文件夹，正常开机，通过ssh即可连接到树莓派)
2. 所有官方软件源软件已经更新至最新版。

## 目标
在树莓派3B上安装node.js-6.9.4(截至本文发布时间的最新稳定版)
## 实战
连接树莓派之后：
下载已经编译好的node.js for ARM 版本
```bash
$ wget https://nodejs.org/dist/latest-v6.x/node-v6.9.4-linux-armv7l.tar.gz
```
解压文件
```bash
$ tar -xvf node-v6.9.4-linux-armv7l.tar.gz
```
验证node是否正常
```bash
$ cd node-v6.9.4-linux-armv7l/bin/
$ ./node -v
v6.9.4
```
说明正常，PS:运行npm会出现如下错误信息:
```bash
$ ./npm -v
/usr/bin/env: node: No such file or directory
```
别着急，往下看。
依次输入以下命令:
```bash
$ cd ~/
$ mv node-v6.9.4-linux-armv7l /usr/local/node
$ echo PATH=$PATH:/usr/local/node/bin >> ~/.bashrc
$ source .bashrc
```
现在在任何路径下都可以通过输入`node -v`得到当前的node.js版本。
若出现`npm`命令出错的情况，那么就编辑"/etc/sudoers"文件,将12行的
```bash
Defaults        secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
```
更改为
```bash
Defaults       secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/node/bin"
```
然后重启一下，enjoy it.
## 一点点说明
理论上任何Linux系统都可以通过类似的办法来安装Node.js，并且还省去了很多时间，但是需要注意下载的node.js的版本，本文的命令中下载node.js仅仅适用于ARM v7l平台
想要知道需要下载什么版本的node.js，通过命令
```bash
$ uname -a
```
来查看，在我的树莓派上显示如下信息
```bash
Linux raspberrypi 4.4.38-v7+ #938 SMP Thu Dec 15 15:22:21 GMT 2016 armv7l GNU/Linux
```
在cent OS 6上显示如下信息
```bash
Linux VM_131_160_centos 3.10.0-514.2.2.el7.x86_64 #1 SMP Tue Dec 6 23:06:41 UTC 
```
在ubuntu 14.04 LTS server 上显示如下信息
```bash
Linux host_name 2.6.32-042stab116.2 #1 SMP Fri Jun 24 15:33:57 MSK 2016 x86_64 x86_64 x86_64 GNU/Linux
```
在输出信息中即可看到，树莓派是`ARM v7l`,cent OS和ubuntu是`x86_64`(x86_64 表示64位版本，x86表示32位)
适用于64位Linux系统的node.js
```bash
$ wget https://nodejs.org/dist/latest-v6.x/node-v6.9.4-linux-x64.tar.gz
```
适用于32位Linux系统的node.js
```bash
$ wget https://nodejs.org/dist/latest-v6.x/node-v6.9.4-linux-x86.tar.gz
```
其他步骤类似。
{% asset_img 2.jpg node.js %}
{% cq %} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>node.js</tag>
        <tag>raspberry</tag>
      </tags>
  </entry>
  <entry>
    <title>Tensorflow</title>
    <url>/2017/06/13/install-tensorflow/</url>
    <content><![CDATA[{% asset_img 1.jpg TensorFlow %}
<!-- more -->
[Tensorflow](https://en.wikipedia.org/wiki/TensorFlow)一个强大的工具，安装过程很简单，但是还是踩了不少坑，这里仅作记录。
## 在树莓派上安装TensoFlow
### 环境描述
树莓派安装了2016.12月的jessie版本，并保证`sudo apt-get update`，后更新所有软件。
### 安装
按照官网的描述，Linux通过命令
```bash
$sudo pip install tensorflow (For python 2)

$sudo pip3 install tensorflow (For python 3)
```
#### 第一个问题————pip版本过低
即可安装。遇到的第一个问题，是pip版本太低，可通过命令
```bash
$sudo pip install --upgrade pip
或者
$sudo pip3 install --upgrade pip
```
来安装TensorFlow，在输入以上命令之前，你可能需要先输入
```bash
$sudo apt-get install python-pip python-dev (For python 2)

$sudo apt-get install python3-pip python3-dev (For python 3)
```
来安装依赖包。

#### 第二个问题————软件源
然后，是遇到的第二个问题，遇到错误提示————cannot fetch index base url https //pypi.python.org/simple/,这个错误完全是网络不通畅导致的，pip默认软件源是`pypi.python.org`，这个时候就需要更换国内的软件源。
在Linux中，更换软件源，需要在root用户的家目录下新建`.pip`文件夹，在该文件夹内新建文件`pip.conf`,其内容为
```bash
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
```
或者也可以通过临时指定软件源
```bash
$sudo pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn
```
来进行安装。
#### 第四个问题————软件源内没有相应软件包
以上所说，适用于X86平台的Linux，然而raspberry是ARM平台，国内的源似乎没有ARM平台的软件包，所以必须得指定软件包来安装了。
在Github上已经有人编译好了树莓派对应的tensorflow包，我在[这里](http://118.89.31.219/src/tensorflow/)也备份了一下,下载文件`tensorflow-1.1.0-cp27-none-linux_armv7l.whl`，使用命令`pip install tensorflow-1.1.0-cp27-none-linux_armv7l.whl`就可以安装了，在rasperry上安装时间还是挺长的。
这里需要注意，tensorflow有其它的依赖包，所以最好先更换软件源，再进行安装，否则若是依赖包安装失败，tensorflow也没法装好。
## 验证安装
安装好之后，在终端输入python(若使用python3版本的pip安装的tensorflow，则需要输入python3)来进入，依次输入以下命令
{% asset_img 2.jpg TensorFlow on python 2 on Linux %}
{% asset_img 3.jpg TensorFlow on python 3 on Windows %}
## 一点点说明
1. 在Windows和Linux上的安装都很方便，配置好软件源之后基本上没什么问题，树莓派因为软件源本身并不具备相应版本的TensorFlow，所以得手动下载相应的TensorFlow，在[http://118.89.31.219/src/tensorflow/](http://118.89.31.219/src/tensorflow/)所留的软件包中，python3对应版本的无法安装，会提示不适用于此平台，目测要么是系统把硬件识别错了，要么就是包本身有问题；
2. 在官方的验证示例中，python2和python3的示范结果不一样，python2的示范结果为`Hello,TensorFlow`,而python3的示范结果为`b'Hello,TensorFlow'`；
3. Windows平台只能通过python3安装TensorFlow，python3的`print`被当作一个函数了，与python2不一样，python3的`printf`后面需要加括号。
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>tmux 手册</title>
    <url>/2017/02/13/manual-of-tmux/</url>
    <content><![CDATA[
分享一个终端利器——[tmux](http://baike.baidu.com/link?url=uqOhZydzIHteNDNe6NdyrNMTr9wyWgsKkEr0Ag0__Yg02yeZVyccv5wQH6U99aFbgkwt5kWYcUgxnpy1oBBGkK)
{% asset_img tmux.jpg Tmux %}
<!-- more -->

## 基本操作
<style>
table th:first-of-type {
    width: 100px;
}
</style>

|   ?    | 列出所有快捷键；按q返回                             |
| :----: | ---------------------------------------- |
|   d    | 脱离当前会话,可暂时返回Shell界面，输入tmux  attach能够重新进入之前会话 |
|   s    | 选择并切换会话；在同时开启了多个会话时使用                    |
|   D    | 选择要脱离的会话；在同时开启了多个会话时使用                   |
|   :    | 进入命令行模式；此时可输入支持的命令，例如kill­server所有tmux会话 |
|   [    | 复制模式，光标移动到复制内容位置，空格键开始，方向键选择复制，回车确认，q/Esc退出 |
|   ]    | 进入粘贴模式，粘贴之前复制的内容，按q/Esc退出                |
|   ~    | 列出提示信息缓存；其中包含了之前tmux返回的各种提示信息            |
|   t    | 显示当前的时间                                  |
| Ctrl+z | 挂起当前会话                                   |

## 窗口操作

|  c   | 创建新窗口                |
| :--: | -------------------- |
|  &   | 关闭当前窗口               |
| 数字键  | 切换到指定窗口              |
|  p   | 切换至上一窗口              |
|  n   | 切换至下一窗口              |
|  l   | 前后窗口间互相切换            |
|  w   | 通过窗口列表切换窗口           |
|  ,   | 重命名当前窗口，便于识别         |
|  .   | 修改当前窗口编号，相当于重新排序     |
|  f   | 在所有窗口中查找关键词，便于窗口多了切换 |

## 面板操作

|    “     | 将当前面板上下分屏                    |
| :------: | ---------------------------- |
|    %     | 将当前面板左右分屏                    |
|    x     | 关闭当前分屏                       |
|    !     | 将当前面板置于新窗口,即新建一个窗口,其中仅包含当前面板 |
| Ctrl+方向键 | 以1个单元格为单位移动边缘以调整当前面板大小       |
| Alt+方向键  | 以5个单元格为单位移动边缘以调整当前面板大小       |
|   空格键    | 可以在默认面板布局中切换，试试就知道了          |
|    q     | 显示面板编号                       |
|    o     | 选择当前窗口中下一个面板                 |
|   方向键    | 移动光标选择对应面板                   |
|    {     | 向前置换当前面板                     |
|    }     | 向后置换当前面板                     |
|  Alt+o   | 逆时针旋转当前窗口的面板                 |
|  Ctrl+o  | 顺时针旋转当前窗口的面板                 |
|    z     | tmux 1.8新特性，最大化当前所在面板        |
## 视频示范
[BiliBili](http://www.bilibili.com/video/av8595472/)
<embed height="415" width="544" quality="high" allowfullscreen="true" type="application/x-shockwave-flash" src="//static.hdslb.com/miniloader.swf" flashvars="aid=8595472&page=1" pluginspage="//www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash"></embed>
]]></content>
  </entry>
  <entry>
    <title>MC 基岩版(PE) 服务器来了</title>
    <url>/2018/10/13/mcpe-server/</url>
    <content><![CDATA[好长时间没写了，前段时间登陆上MC官网，发现PE版本的服务端已经放出来了，有 Windows 版本和 Linux 版本，小小的尝试了一下，记录一下遇到的坑。
先放链接[https://minecraft.net/en-us/download/server/bedrock/](https://minecraft.net/en-us/download/server/bedrock/)

<!-- more -->

## Windows 上运行

下载，双击 `bedrock_server.exe` 就OK了，局域网内可以发现它。

如果是在 Windows 上运行应用商店的版本，并且服务端也在同一台机子上的话，得先把 Windows 10 对 UWP 应用的网络循环关掉，打开注册表，前往 `HKEY_CURRENT_USER\Software\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppContainer\Mappings\ ` ，这里会列出电脑上安装好的 UWP 应用，然后一个一个往下找，同时观察右边窗口的 `DisplayName` ，直到找到 Minecraft for Windows 10 ，然后记录下左边条目的名字，如果没错的话，应该是这个：`S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436` ，就像下图这样
{% asset_img 2.png regedit %}
然后以管理员权限打开命令提示符，输入 `CheckNetIsolation.exe LoopbackExempt –a –p=ID` ，ID就是上面注册表内找到的条目的名字，提供一个示范

```bash
CheckNetIsolation.exe LoopbackExempt –a –p=S-1-15-2-1958404141-86561845-1752920682-3514627264-368642714-62675701-733520436
```
出现如下提示的时候

{% asset_img 3.png %}

然后就可以在 Windows 10 的 UWP 版本在当前机子开黑了。超赞👍。


## Linux 上运行

极其不建议在Linux上运行服务端，目前的情况来看，官方的服务端会缺很多动态库，它所需要的动态库安装非常繁琐，有时候还会遇到依赖问题。

Linux上运行就有点麻烦了，如果使用 Ubuntu 的话，倒是很方便(注：我使用的是18.04版本)

```bash
sudo apt-get update
sudo apt-get install libcurl3 build-essential 
```

就可以完成依赖包的安装，下载服务端文件之后直接运行就OK。

对于 Cent OS 就麻烦很多了，官方提供的服务端在 Cent OS 7.5 上会缺东西，首先是 `libssl.0.0.so` 的缺失，就算自行下载 `openssl1.0.0` 编译好，它又提示 `glibc` 版本低，编译安装 `glibc` ，又会遇到 `gcc` 版本过低的问题，折腾时间增加很多，十分不合算。这里提供一个折中的办法—— `docker`
docker真的是一个好东西啊，直接放解决办法吧：
```
docker pull ubuntu:18.04
docker run -p 19132:19132/tcp -p 19132:19132/udp -it ubuntu:18.04 bash
```
两个-p参数，分别把tcp和udp协议的主机的19132端口映射到容器实例的19132端口(19132是MCPE服务器的默认端口)，有UDP协议，客户端才能发现服务端，有tcp协议，客户端才能连接到服务端。
PS：上面的操作只是做一个示范，启动容器之后需要像在Ubuntu那样安装好依赖，然后再启动MCPE服务端。

## 参考链接

一开始不知道docker怎么让容器同时支持tcp和udp，真是翻遍了度娘和404网站啊，最后还是官方的文档给了惊喜 [https://docs.docker.com/config/containers/container-networking/](https://docs.docker.com/config/containers/container-networking/)

]]></content>
  </entry>
  <entry>
    <title>Nginx的一点点小折腾</title>
    <url>/2017/01/27/nginx-skill/</url>
    <content><![CDATA[{% asset_img 3.jpg Nginx %}
<!-- more -->
## 说明
对于这样某个url来说，假设其站点在主机上的`/var/www/`目录下，若该目录下的结构是这样(图示结构为本站的目录结构):
```
├─2016
│  ├─03
│  │  ├─25
│  │  │  └─hello-world
│  │  ├─26
│  │  │  └─First-day
│  │  └─28
│  │      └─ubuntu-touchpad
│  ├─04
│  │  ├─03
│  │  │  └─Lake-Counting
│  │  └─26
│  │      └─start
│  ├─07
│  │  └─03
│  │      └─Minecraft-server
│  │          └─images
│  ├─10
│  │  └─20
│  │      └─Aria2c
│  ├─11
│  │  ├─25
│  │  │  └─High-Speed-transfer
│  │  └─26
│  │      ├─4-四元数与欧拉角
│  │      └─NOIP2016
│  └─12
│      ├─05
│      │  └─NOIP2016更改
│      ├─09
│      │  └─Dynamic-programming
│      ├─23
│      │  └─zheyilu
│      └─31
│          └─such-a-program
├─2017
│  └─01
│      ├─06
│      │  └─who-am-I
│      ├─08
│      │  ├─error-in-Linux-when-use-C-language
│      │  └─install-node-js-on-a-Linux-OS
│      ├─09
│      │  └─install-node-js-on-raspberry-3B
│      ├─10
│      │  └─Ferryman
│      ├─12
│      │  └─replace-background-image-of-ubuntu-when-login-in-to-it
│      ├─16
│      │  └─home
│      ├─19
│      │  └─NOIP-2015-Message
│      └─25
│          └─use-proxy-in-terminal
├─about
├─archives
│  ├─2016
│  │  ├─03
│  │  ├─04
│  │  ├─07
│  │  ├─10
│  │  ├─11
│  │  ├─12
│  │  └─page
│  │      └─2
│  ├─2017
│  │  └─01
│  └─page
│      ├─2
│      └─3
├─css
├─images
├─js
│  └─src
│      └─schemes
├─lib
│  ├─algolia-instant-search
│  ├─fancybox
│  │  └─source
│  │      └─helpers
│  ├─fastclick
│  │  └─lib
│  ├─font-awesome
│  │  ├─css
│  │  └─fonts
│  ├─jquery
│  ├─jquery_lazyload
│  ├─ua-parser-js
│  │  └─dist
│  └─velocity
├─page
│  ├─2
│  └─3
└─tags
    ├─C
    ├─Games
    ├─hexo
    ├─Linux
    ├─node-js
    ├─NOIP
    ├─raspberry
    ├─technology
    ├─tecnology
    ├─Ubuntu
    ├─ubuntu-touchpad-触控板调节
    ├─wanwan
    ├─乱七八糟
    ├─动态规划
    ├─学术
    ├─小窍门
    ├─文学
    ├─深度优先搜索
    ├─竞赛
    └─算法
```
此时，若是直接访问`hushuangpu.xyz/tags`看到的是站点目录下的`tags`文件夹内的内容。若是想要访问`hushuangpu.xyz/src`，且src指向的内容不在站点目录里面，该怎么弄？于是有了此文。
## 实战
这里用`Nginx`实现，只需要更改nginx的配置文件就好,若无意外，正常的nginx的配置文件内容应该如下:
```html
user nginx;                                                                 
worker_processes auto;                                                      
error_log /var/log/nginx/error.log;                                         
pid /run/nginx.pid;                                                         
                                                                            
# Load dynamic modules. See /usr/share/nginx/README.dynamic.                
include /usr/share/nginx/modules/*.conf;                                    
                                                                            
events {                                                                    
    worker_connections 1024;                                                
}                                                                           
                                                                            
http {                                                                      
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" 
                      '$status $body_bytes_sent "$http_referer" '           
                      '"$http_user_agent" "$http_x_forwarded_for"';         
                                                                            
    access_log  /var/log/nginx/access.log  main;                            
                                                                            
    sendfile            on;                                                 
    tcp_nopush          on;                                                 
    tcp_nodelay         on;                                                 
    keepalive_timeout   65;                                                 
    types_hash_max_size 2048;                                               
                                                                            
    include             /etc/nginx/mime.types;                              
    default_type        application/octet-stream;                           
                                                                            
    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include             
    # for more information.                                                 
    include /etc/nginx/conf.d/*.conf;                                       
                                                                            
    server {                                                                
        listen       80 default_server;                                     
        listen       [::]:80 default_server;                                
        server_name  _;                                         
                                                                            
        # Load configuration files for the default server block.            
        include /etc/nginx/default.d/*.conf;                                
                                                                            
        location / {                                                        
                root         /usr/share/nginx/html;                         
        }                                                                   
                                                                            
        error_page 404 /404.html;                                           
            location = /40x.html {                                          
        }                                                                   
                                                                            
        error_page 500 502 503 504 /50x.html;                               
            location = /50x.html {                                          
        }
    }
}
```
我的站点文件全部放在`/usr/share/nginx/html`目录里面了，然后我想让`hushuangpu.xyz/src`指向另外一个目录，比如`/var/resource`,在配置文件内添加如下内容:
```html
        charset utf-8;#指定文件名编码，防止中文乱码，若是在Windows上使用，应该将其utf-8改成gbk
        client_max_body_size 4G;#限制单个最大文件的体积
        location /src {#这行的src就是hushuangpu.xyz/src里面的src
              alias /usr/resource/;#更改目录指向
              autoindex on;#建立目录
              autoindex_exact_size off;#显示文件体积
              autoindex_localtime on;显示时间
        }
```
本站实现示范如下:
{% asset_img 1.jpg Demo %}

## 其它说明
在上文中，代码
```html
        charset utf-8;#指定文件名编码，防止中文乱码，若是在Windows上使用，应该将其utf-8改成gbk
        client_max_body_size 4G;#限制单个最大文件的体积
        location /src {#这行的src就是hushuangpu.xyz/src里面的src
              alias /usr/resource/;#更改目录指向
              autoindex on;
              autoindex_exact_size off;
              autoindex_localtime on;
        }
```
其实是在`/usr/resource`建立了以个静态文件服务器，若是要当成web服务器
则要改成这样
```html
        charset utf-8;#指定文件名编码，防止中文乱码，若是在Windows上使用，应该将其utf-8改成gbk
        client_max_body_size 4G;#限制单个最大文件的体积
        location /src {#这行的src就是hushuangpu.xyz/src里面的src
              alias /usr/resource/;#更改目录指向
        }
```
{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>nginx</tag>
      </tags>
  </entry>
  <entry>
    <title>如何打开安卓的 screencap 命令生成的 raw 图片</title>
    <url>/2023/05/23/open-android-screencap-raw-img/</url>
    <content><![CDATA[
以 Android 9.0 为例，screencap 的实现可以查看 [http://androidxref.com/9.0.0_r3/xref/frameworks/base/cmds/screencap/screencap.cpp](http://androidxref.com/9.0.0_r3/xref/frameworks/base/cmds/screencap/screencap.cpp) 。

<!-- more -->

screencap 的命令格式是
`screencap <imgpath>` 或者 `screencap -p <imgpath>`。
如果第一种命令的 imgpath 以 png 为结尾 或者加了 -p 参数的话，screencap 会将屏幕截图保存为 png 格式。否则screencap会将屏幕截图保存为一个裸 YUV 数据的图像，这个图像会保存所有的像素点信息，图像更为清晰。查看对应的代码实现即可知道如何打开这种 YUV 数据的图像。
```cpp
    } else {
        uint32_t c = dataSpaceToInt(d);
        write(fd, &w, 4);
        write(fd, &h, 4);
        write(fd, &f, 4);
        write(fd, &c, 4);
        size_t Bpp = bytesPerPixel(f);
        for (size_t y=0 ; y<h ; y++) {
            write(fd, base, w*Bpp);
            base = (void *)((char *)base + s*Bpp);
        }
    }
```
从上面的实现可以看到，文件头是 16 字节，分别是图像宽，图像高，像素格式，reserved。然后是一个 RGBA 格式保存的图像数据（它为什么不保存为bitmap呢!）。
将文件名后缀改为 .raw 使用 Photoshop 即可打开文件查看。可以参考下图填写参数

{% asset_img pssample.png %}

如果不知道图像宽度和高度，可以将图像当作二进制打开。看前 8 个字节即可。
本文示例中，前 16 字节为
```
38 04 00 00 70 08 00 00 01 00 00 00 01 00 00 00
```
小端序存储，转换成整数为
```
0x0438 = 1080
0x0870 = 2160
```
]]></content>
  </entry>
  <entry>
    <title>树莓派折腾记——Samba</title>
    <url>/2017/01/31/raspberry-train/</url>
    <content><![CDATA[{% asset_img 1.jpg %}
<!-- more -->
树莓派用多了，总是要经常树莓派上传文件或者从树莓派下载文件，纵然可以使用putty携带的pscp或者rsync之类的命令行软件，但是总是不如图形界面来的方便，还省得记那些命令。
于是，有了此文。
```bash
$ sudo apt-get install samba
```
然后，编辑`/etc/samba/smb.conf`，在文件末尾添加上如下内容
```
[public]
comment = Public Storage
path = /home/pi  #这里是用于树莓派共享到局域网的目录，这里设置为了pi用户的家目录
read only = no#任何人都具有了访问修改的权限
#因为是公共文件夹，所以给了所有用户全部权限，可以自定义
create mask = 0777#新创建文件的默认属性
directory mask = 0777#新创建文件夹的默认属性
guest ok = yes#默认的访问用户名为guest
browseable = yes
```
然后，通过命令``sudo smbd restart``，便可以在Windows的网络邻居里面发现树莓派了，如图
{% asset_img 2.jpg %}
此时只能看到树莓派出现在网络邻居里面，要想能正常查看树莓派上的内容，还是得要进行一些配置
输入如下命令
```bash
$ sudo smbpasswd -a pi
```
按照提示，输入密码(密码是自定义的)
```bash
pi@raspberrypi:/etc/samba $ sudo smbpasswd -a pi
New SMB password:
Retype new SMB password:
Added user pi.
pi@raspberrypi:/etc/samba $
```
然后，在网络邻居里面双击raspberry，会提示需要输入用户名和密码，用户名为`pi`，密码为刚才设置的密码。
然后，就可以畅快的用网络邻居与树莓派之间互传文件了。
{% asset_img 3.jpg %}
{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>linux</tag>
      </tags>
  </entry>
  <entry>
    <title>替换Ubuntu默认的登录背景图片</title>
    <url>/2017/01/12/replace-background-image-of-ubuntu-when-login-in-to-it/</url>
    <content><![CDATA[Ubuntu默认的登录背景看起来还是比较高贵的，但是作为一个爱折腾的人，当然要换成自己喜欢的背景图了。
一开始跟着百度走，进了不少坑，最后还是自己走出来的。
先上一个成品照
{% asset_img login.jpg%}
<!-- more -->
百度得到的答案几乎都是安装`ubuntu tweak`，然而，安装ubuntu tweak的过程就很艰辛。
## 思路:
ubuntu启动到达登录界面的时候，无非就是将已经存储在电脑上的背景图片显示在登录界面，找到这张图片，替换成自己的就好了。
系统默认的图片是在"/usr/share/background/"下的"warty-final-ubuntu.png"。有基础的童鞋到这儿已经知道该怎么办了，下面的是给新手看的。
## 实战
先准备好一张想要当成背景的图片(PS:必须是png格式的，jpg格式的不能用，我已经试过了)，假设这张图片叫`1.png`，放在用户主目录下，那么按`Ctrl Alt T`打开终端，输入以下命令
```bash
$ cd ~/
$ sudo mv /usr/share/background/warty-final-ubuntu.png /usr/share/background/warty-final-ubuntu.png-bak
$ sudo mv 1.pn /usr/share/background/warty-final-ubuntu.png
```
O了，注销或者重启一下，就可以看到成果了。
## 注意
对于图片的尺寸要求，至少清晰度和要屏幕的分辨率一样高，这样才不会失真，比例最好用16:9的，现在大多数屏幕的比例都是这个。
{% cq%} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>Linux</tag>
        <tag>Ubuntu</tag>
        <tag>technology</tag>
      </tags>
  </entry>
  <entry>
    <title>【转载】重置 Windows 10 开始菜单布局</title>
    <url>/2018/04/05/reset-your-start-menu-layout-in-Windows-10-1709/</url>
    <content><![CDATA[
## 中文版

Windows 10 从很久以前就开始有这个问题，升级或者全新安装以后开始菜单磁贴无法正常工作。拖动一下就会卡死，或者修改布局并重新登录以后就会重置成以前的样子。

此问题影响至少 1709 和 1803 版本，并且能在全新安装的系统上复现。

搜遍谷歌，找到一种解决方法，是删除注册表中对于开始菜单磁贴的缓存。

<!-- more -->

### Windows 1709

管理员版本 Powershell 下执行：

```bash
Remove-Item 'HKCU:\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount\$start.tilegrid$windows.data.curatedtilecollection.root' -Force -Recurse
Get-Process Explorer | Stop-Process
```

或使用注册表编辑器手动删除：

`Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount` 下的`$start.tilegrid$windows.data.curatedtilecollection.root` 项目。

### Windows 1803

管理员版本 Powershell 下执行：

```bash
Remove-Item 'HKCU:\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount\' -Force -Recurse
Get-Process Explorer | Stop-Process
```

或使用注册表编辑器手动删除：

Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount 下以的 $start.tilegrid$windows.data.curatedtilecollection.root 结尾的项目。

## English

It has been a long while since Windows 10 had issues with its start menu layout, such as dragging and dropping icons causes crashes, or layout gets reverted after signing out and in. At least 1709 and 1803 fresh installations are affected.

A strategy to mitigate the issue, according to the other end of Google, is to remove the cache store in the system registery.

### Windows 1709

Execute the following under Admin Powershell:

```bash
Remove-Item 'HKCU:\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount\$start.tilegrid$windows.data.curatedtilecollection.root' -Force -Recurse
Get-Process Explorer | Stop-Process
```

Or, using the Registry Editor

Navigate to Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount and delete $start.tilegrid$windows.data.curatedtilecollection.root item.

### Windows 1803

Execute the following under Admin Powershell:

```bash
Remove-Item 'HKCU:\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount\' -Force -Recurse
Get-Process Explorer | Stop-Process
```

Or, using the Registry Editor

Navigate to Computer\HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\CloudStore\Store\Cache\DefaultAccount and delete item ending with $start.tilegrid$windows.data.curatedtilecollection.root.

-----
由于问题的普遍性，特留下中英文两版以供查阅。

References:

[1]: [How to reset your start menu layout in Windows 10 1709](http://www.joseespitia.com/2018/01/05/how-to-reset-your-start-menu-layout-in-windows-10-1709/)

转载自：[https://www.v2ex.com/t/444426#reply4](https://www.v2ex.com/t/444426#reply4)
]]></content>
      <tags>
        <tag>Windows 10</tag>
      </tags>
  </entry>
  <entry>
    <title>Code::Blocks 快捷键</title>
    <url>/2017/07/05/shortcut-of-code-blocks/</url>
    <content><![CDATA[{% asset_img cover.png %}
<!-- more -->
## Editor
| Function                                 | Shortcut Key            |
| ---------------------------------------- | ----------------------- |
| Undo last action                         | Ctrl + Z                |
| Redo last action                         | Ctrl + Shift + Z        |
| Cut selected text                        | Ctrl + X                |
| Copy selected text                       | Ctrl + C                |
| Paste text from clipboard                | Ctrl + V                |
| Select all text                          | Ctrl + A                |
| Swap header / source                     | F11                     |
| Comment highlighted code                 | Ctrl + Shift + C        |
| Uncomment highlighted code               | Ctrl + Shift + X        |
| Duplicate line caret is on               | Ctrl + D                |
| Auto-complete / Abbreviations            | Ctrl + Space / Ctrl + J |
| Show call tip                            | Ctrl + Shift + Space    |
| Swap line caret is on with line above it | Ctrl + T                |
| Toggle bookmark                          | Ctrl + B                |
| Goto previous bookmark                   | Alt + PgUp              |
| Goto next bookmark                       | Alt + PgDown            |
| Toggle current block folding             | F12                     |
| Toggle all folds                         | Shift + F12             |

This is a list of shortcuts provided by the Code::Blocks' editor component. These shortcuts cannot be rebound.

| Function                                 | Shortcut Key             |
| ---------------------------------------- | ------------------------ |
| Magnify text size.                       | Ctrl + Keypad "+"        |
| Reduce text size.                        | Ctrl + Keypad "-"        |
| Restore text size to normal.             | Ctrl + Keypad "/"        |
| Cycle through recent files.              | Ctrl + Tab               |
| Indent block.                            | Tab                      |
| Dedent block.                            | Shift + Tab              |
| Delete to start of word.                 | Ctrl + BackSpace         |
| Delete to end of word.                   | Ctrl + Delete            |
| Delete to start of line.                 | Ctrl + Shift + BackSpace |
| Delete to end of line.                   | Ctrl + Shift + Delete    |
| Go to start of document.                 | Ctrl + Home              |
| Extend selection to start of document.   | Ctrl + Shift + Home      |
| Go to start of display line.             | Alt + Home               |
| Extend selection to start of display line. | Alt + Shift + Home       |
| Go to end of document.                   | Ctrl + End               |
| Extend selection to end of document.     | Ctrl + Shift + End       |
| Go to end of display line.               | Alt + End                |
| Extend selection to end of display line. | Alt + Shift + End        |
| Expand or contract a fold point.         | Ctrl + Keypad "*"        |
| Create or delete a bookmark.             | Ctrl + F2                |
| Go to next bookmark.                     | F2                       |
| Select to next bookmark.                 | Alt + F2                 |
| Find selection.                          | Ctrl + F3                |
| Find selection backwards.                | Ctrl + Shift + F3        |
| Scroll up.                               | Ctrl + Up                |
| Scroll down.                             | Ctrl + Down              |
| Line cut.                                | Ctrl + L                 |
| Line copy.                               | Ctrl + Shift + T         |
| Line delete.                             | Ctrl + Shift + L         |
| Line transpose with previous.            | Ctrl + T                 |
| Line duplicate.                          | Ctrl + D                 |
| Find matching preprocessor conditional, skipping nested ones. | Ctrl + K                 |
| Select to matching preprocessor conditional. | Ctrl + Shift + K         |
| Find matching preprocessor conditional backwards, skipping nested ones. | Ctrl + J                 |
| Select to matching preprocessor conditional backwards. | Ctrl + Shift + J         |
| Previous paragraph. Shift extends selection. | Ctrl + [                 |
| Next paragraph. Shift extends selection. | Ctrl + ]                 |
| Previous word. Shift extends selection.  | Ctrl + Left              |
| Next word. Shift extends selection.      | Ctrl + Right             |
| Previous word part. Shift extends selection. | Ctrl + /                 |
| Next word part. Shift extends selection. | Ctrl + \                 |

## Files

| Function                      | Shortcut Key                         |
| ----------------------------- | ------------------------------------ |
| New file or project           | Ctrl + N                             |
| Open existing file or project | Ctrl + O                             |
| Save current file             | Ctrl + S                             |
| Save all files                | Ctrl + Shift + S                     |
| Close current file            | Ctrl + F4 / Ctrl + W                 |
| Close all files               | Ctrl + Shift + F4 / Ctrl + Shift + W |

## View

| Function                            | Shortcut Key            |
| ----------------------------------- | ----------------------- |
| Show / hide Messages pane           | F2                      |
| Show / hide Management pane         | Shift + F2              |
| Move project up (in Project tree)   | Ctrl + Shift + Up       |
| Move project down (in Project tree) | Ctrl + Shift + Down     |
| Activate prior (in Project tree)    | Alt + F5                |
| Activate next (in Project tree)     | Alt + F6                |
| Zoom in / out                       | Ctrl + Roll Mouse Wheel |
| Focus editor                        | CTRL + Alt + E          |

## Search

| Function                   | Shortcut Key      |
| -------------------------- | ----------------- |
| Find                       | Ctrl + F          |
| Find next                  | F3                |
| Find previous              | Shift + F3        |
| Find in files              | Crtl + Shift + F  |
| Replace                    | Ctrl + R          |
| Replace in files           | Ctrl + Shift + R  |
| Goto line                  | Ctrl + G          |
| Goto next changed line     | Ctrl + F3         |
| Goto previous changed line | Ctrl + Shift + F3 |
| Goto file                  | Alt + G           |
| Goto function              | Ctrl + Alt + G    |
| Goto previous function     | Ctrl + PgUp       |
| Goto next function         | Ctrl + PgDn       |
| Goto declaration           | Ctrl + Shift + .  |
| Goto implementation        | Ctrl + .          |
| Open include file          | Ctrl + Alt + .    |

## Build

| Function             | Shortcut Key      |
| -------------------- | ----------------- |
| Build                | Ctrl + F9         |
| Compile current file | Ctrl + Shift + F9 |
| Run                  | Ctrl + F10        |
| Build and Run        | F9                |
| Rebuild              | Ctrl + F11        |

## Debug

| Function                 | Shortcut Key      |
| ------------------------ | ----------------- |
| Debug                    | F8                |
| Continue debugging       | Ctrl + F7         |
| Step over a code block   | F7                |
| Step into a code block   | Shift + F7        |
| Step out of a code block | Ctrl + Shift + F7 |
| Toggle breakpoint        | F5                |
| Run to cursor            | F4                |
| Previous error           | Alt + F1          |
| Next error               | Alt + F2          |
-----
内容来自官方wiki:[http://wiki.codeblocks.org/index.php?title=Keyboard_Shortcuts](http://wiki.codeblocks.org/index.php?title=Keyboard_Shortcuts) 
看来得抽空翻译一下d=====(￣▽￣*)b
]]></content>
  </entry>
  <entry>
    <title>Hexo 在 Next 主题下打开缓慢</title>
    <url>/2017/02/22/solve-a-problem/</url>
    <content><![CDATA[之前遇到博客打开过于缓慢(甚至于打不开)的情况，将解决办法整理解决如下:
## 说明
本站使用的框架是[Hexo](https://hexo.io/)，使用的主题是[Next](https://github.com/iissnan/hexo-theme-next)。
Hexo和Next的安装和使用方法在之前的文章中有所提及，这里不再累述。
<!-- more -->
## 字体导致的访问缓慢
方法来自[博客](http://blog.csdn.net/justheretobe/article/details/52167068)，博客内容所指为
> ### 禁用第三方字体 
到Next主题的_config.yml中设置不从google加载字体（默认会加载本地字体） 
设置： 
use_font_lato: false
### 换字体源 
到\themes\next\layout_partials\head\external-fonts.swig文件 
fonts.googleapis.com 改成 fonts.useso.com 
按该文所述更改字体库来源之后，访问速度虽然有所提高，但是仍然需要很长时间。

可能该博客撰写时Next的版本较低，在`5.1.0`版本的Next的配置文件中，并没有`use_font_lato`字段，而是
```
font:
  enable: true
```
改为
```
font:
  enable: false
```
方法一效果较为明显，方法二几乎没有效果。
仔细对比是否使用第三方字体库，发现差别并不明显，所以果断选择方法一了。
## 体积较大的资源导致的访问缓慢
测试了[网站首页](https://suppermary.cc)，打开时间占用最长的是几张体积较大的图片，将这些图片压缩一下就好了。
另外是几个`js`文件，要减小这些得参考更高级的玩法，或者自己学js了(=.=)。
## 网速导致的访问缓慢
本站位于腾讯云(GitPage 也有一份)，带宽为1M，虽然不限流量，但是这小水管实在是跑不起来，没办法了。GitHub又位于美国，访问速度同样缓慢，不忍直视。
{% cq %}生命在于折腾{% endcq %}]]></content>
      <tags>
        <tag>hexo</tag>
      </tags>
  </entry>
  <entry>
    <title>对排序的一点扯淡</title>
    <url>/2017/04/03/sort/</url>
    <content><![CDATA[{% asset_img 1.jpg %}
<!-- more -->
对数据进行排序，是需要经常进行的操作。
手动写排序，归并，冒泡，插入之类的都可以，不过有`algorithm`自带的`sort`就省了一些麻烦了。
对需要排序的数组这样写`sort(a,a+n)`(假设a为需要排序的数组，n为数组的长度)
再细化一点的话，就这样写:`sort(a+n1,a+n2)`，这样是对`a`数组的下标为n1的元素直到下标为n2的元素进行排序，自然，n2>n1。
但是吧，有时候，需要排序的不仅仅只是一个数组，这个数组与其他的信息有一定的联系，比如这样的
```C++
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

struct Student
{
    string name;
    int score;
};

int main()
{
    struct Student stu[3]={"stu1",70,"stu2",80,"stu3",60};//初始化
    for(int i=0;i<3;i++)
    {
        cout<<stu[i].name<<" "<<stu[i].score<<endl;
    }
    return 0;
}
```
结构体内为学生的姓名和成绩，我想以成绩为准排序，当然了，姓名和成绩的对应关系不能乱掉。
这个时候肯定不能写成`sort(stu,stu+3)`，需要给sort加上一定的排序依据。
```C++
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

struct Student
{
    string name;
    int score;
};

bool compare(Student a,Student b) //这个比较函数的参数类型也要写成结构体
{
    return a.score>b.score;//">"是进行降序排序，如果要升序改成<，其实sort默认是升序
}
int main()
{
    struct Student stu[3]={"stu1",70,"stu2",80,"stu3",60};
    sort(stu,stu+3,compare);
    for(int i=0;i<3;i++)
    {
        cout<<stu[i].name<<" "<<stu[i].score<<endl;
    }
    return 0;
}
```
扯一点题外的，看看`类`的排序
```C++
#include <iostream>
#include<algorithm>
#include<string>
using namespace std;

class Student
{
public:
    string name;
    int score;
};

bool compare(Student a,Student b)
{
    return a.score>b.score;
}
int main()
{
    Student stu[3]={"stu1",70,"stu2",80,"stu3",60};
    sort(stu,stu+3,compare);
    for(int i=0;i<3;i++)
    {
        cout<<stu[i].name<<" "<<stu[i].score<<endl;
    }
    return 0;
}
```
两段代码的区别仅仅是结构体和类的区别而已，结构体和类长得如此相似，访问成员的方式都如此相似，他们的共同存在真是迷惑了不少人，颇有周瑜和诸葛两人之意。
{% asset_img ahaha.jpg %}
[http://www.cnblogs.com/starfire86/p/5367740.html](http://www.cnblogs.com/starfire86/p/5367740.html)，此文做了一定的解说，还不错。
{% cq %} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>C</tag>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>来说一说 ssdp 协议</title>
    <url>/2020/10/20/ssdp/</url>
    <content><![CDATA[本篇同样是Yeelight相关的文章的衍生。简单来说，Yeelight的设备会在监听组播地址 239.255.255.250:1982 的特定消息，收到这个特定消息之后，向发送特定消息的客户端发送自己的一些信息，方便这个客户端与自己进行交互。

ssdp(Simple Service Discovery Protocol) 协议原文可以查看 [https://tools.ietf.org/html/draft-cai-ssdp-v1-00](https://tools.ietf.org/html/draft-cai-ssdp-v1-00)

<!-- more -->

我在[这里](https://github.com/armtech/recvudp)找到一个Unix可用的一个ssdp服务端的一个小例子，稍微改造了一下用来模拟Yeelight的服务端
```c
/*
 * recvudp.c
 *
 * A simple UDP receiver with multicast addressing
 * This mechanism based on the Simple Service Discovery Protocol (SSDP)
 * Reference:  https://tools.ietf.org/html/draft-cai-ssdp-v1-00
 *
 * THE SOFTWARE IS PROVIDED "AS IS",
 * WITHOUT WARRANTY OF ANY KIND!
 *
 * Author: Andrejs Tihomirovs
 * Email: armtech@its.lv
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>

int main(int argc, char *argv[])
{
    char* group = "239.255.255.250";
    int port = 1982;

    const char* sendData = "M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1982\r\nMAN: \"ssdp:discover\"\r\nST: wifi_bulb";
    const char* info = "I'm server\n";

    // create UDP socket
    int sockfd;
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("recvudp");
        return 1;
    }

    // allow multiple sockets
    int optname = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
        (char *) &optname, sizeof(optname)) < 0) {
        perror("recvudp");
        return 1;
    }

    // set up destination address
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);

    // socket binding
    if (bind(sockfd, (struct sockaddr*) &addr, sizeof(addr)) < 0) {
        perror("recvudp");
        return 1;
    }

    // join to multicast group
    struct ip_mreq mreq;
    mreq.imr_multiaddr.s_addr = inet_addr(group);
    mreq.imr_interface.s_addr = htonl(INADDR_ANY);

    if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
        (char *) &mreq, sizeof(mreq)) < 0) {
        perror("recvudp");
        return 1;
    }

    // main loop
    while (1) 
    {
        #define BUFSIZE 256
        char buf[BUFSIZE];
        int numbytes, addrlen = sizeof(addr);
        memset(buf, 0, sizeof(buf));

        // receive UDP message
        if ((numbytes = recvfrom(sockfd, buf, BUFSIZE-1 , 0,
            (struct sockaddr *)&addr, &addrlen)) == -1) {
            perror("recvudp");
            return 1;
        }

        if(strcmp(buf,sendData)==0)
        {
            printf("\n%s\nLEN:%d bytes from %s\n", buf, numbytes,inet_ntoa(addr.sin_addr));
            sendto(sockfd, info, strlen(info), 0,
                        (struct sockaddr*) &addr, sizeof(addr));
        }
        else
        {
            printf("LEN:%d bytes\n%s",numbytes,buf);
        }
    }
    return 0;
}
```
需要注意的是，按照ssdp协议原本的定义，服务端应该监听的地址是 239.255.255.250:1900 。不过 Yeelight 选择监听 239.255.255.250:1982 而已。原理上还是一样的。

可以看到相比于通常所用的udp服务端，多了两个地方
```c
// allow multiple sockets
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,(char *) &optname, sizeof(optname)) 

// join to multicast group
setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP,(char *) &mreq, sizeof(mreq))
```
参考上面的例子我们可以很容易的移植到Windows上。

一个简单的发现服务端可以写成下面这样子
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int CLIENT_PORT = 1982;
char *CLIENT_IP = "239.255.255.250";

int main()
{
    int socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socket_fd == -1)
    {
        perror("failed to create socket. exit now.");
        exit(-1);
    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;

    addr.sin_port = htons(CLIENT_PORT);
    addr.sin_addr.s_addr = inet_addr(CLIENT_IP);
    if (addr.sin_addr.s_addr == INADDR_NONE)
    {
        printf("Incorrect ip address!");
        close(socket_fd);
        exit(1);
    }

    char buff[512];
    socklen_t len = sizeof(addr);
    const char *info = "M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1982\r\nMAN: \"ssdp:discover\"\r\nST: wifi_bulb";
    int n;
    
    n = sendto(socket_fd, info, strlen(info), 0, (struct sockaddr *)&addr, sizeof(addr));
    if (n < 0)
    {
        perror("sendto");
        close(socket_fd);
        return 1;
    }
    while (1)
    {
        memset(buff, 0, sizeof(buff));
        n = recvfrom(socket_fd, buff, 512, 0, (struct sockaddr *)&addr, &len);
        if (n > 0)
        {
            buff[n] = 0;
            printf("received from %s:\n%s", inet_ntoa(addr.sin_addr),buff);
        }
        else if (n == 0)
        {
            printf("server closed\n");
            close(socket_fd);
            return 1;
        }
        else if (n == -1)
        {
            perror("recvfrom");
            close(socket_fd);
            return 1;
        }
    }

    return 0;
}
```

通过上边的服务端和客户端的小例子，也同样是可以试验出来，发送“查找消息之后”，客户端多循环几次就能收到多个服务端返回的消息了，如下图

{% asset_img udpclient.png %}

并且可以看到为了防止客户端没有收到消息，Yeelight设备发了两次响应消息。


那么对于我们来说，ssdp的一个比较典型的使用场景就是，在同一个网段中，一个设备（这里称为客户端）想要找到另外一个设备（这里称为服务端）（在不手动指定地址的情况下），客户端往组播地址发送特定消息，获取到服务端的信息，然后与服务端交互。比如工厂流水线上，PC作为服务端，产品作为客户端，由于客户端的mac地址不同，当连接到路由器上是，路由器分配给产品的IP地址不一定是一样的，就可以用这种办法来了。



python 的服务端实现可以参考这个 [https://www.cnblogs.com/chengyunshen/p/7196094.html](https://www.cnblogs.com/chengyunshen/p/7196094.html)]]></content>
  </entry>
  <entry>
    <title>本站建立</title>
    <url>/2016/04/26/start/</url>
    <content><![CDATA[## 建站分享
遵循大家都默认的一个规则——建立好站点之后，分享自己建立站点的过程。

<!-- more -->

### 租用服务器
首先我在租用了搬瓦工的VPS，VPS运行cent os 6.系统环境对于个人站点来说不是非常重要，ubuntu，debian，甚至red hat都可以，看个人习惯。

### 安装nginx
nginx就是一个软件，它监听着计算机的80端口，当检测到有浏览器访问当前计算机的IP地址的时候（浏览器访问一台计算机默认访问80端口），nginx就会返回用户之前写好的网页给浏览器，完成了一个网站的访问过程。在linux下安装nginx还是非常简单的。
debian/ubuntu通过以下命令来安装nginx：
``` bash
$ sudo apt-get install nginx
```
cent os/red hat 通过以下命令
``` bash
$ sudo yum install nginx
```
首次安装还nginx之后它默认启动了，但是计算机重启之后，nginx不会随系统启动，可以手动启动nginx
``` bash
$ sudo service nginx start
```
或者让nginx随系统启动
``` bash
$ cat sudo service nginx start >> /etc/profile
```
注意“>>”是两个，如果提示权限不足，就切换到root用户，使用：
``` bash
$ su root
```
输入root用户密码

### 安装hexo
nginx给浏览器返回网页，这个网页就得自己来弄了，nginx可不会帮你，但是不会写网页代码怎么办？用来生成网页的工具很多，这里我使用了hexo，这个是一个台湾的大学生开发的用来生成静态网页的软件，真的佩服人家。
hexo依赖于node.js，首先在电脑上安装node.js，linux端可以这样
``` bash
$ curl https://raw.github.com/creationix/nvm/master/install.sh | sh
```
或者
``` bash
$ wget -q0- https://raw.github.com/creationix/master/install.sh | sh
```
然后重启终端，输入：
``` bash
$ nvm install 4
$ npm install -g hexo-cli
$ npm install hexo-deployer-rsync --save
```
完成node.js 和部署插件rsync的安装
windows端可以到node.js的官网下载msi包安装后，在cmd输入：
``` bash
$ npm install -g hexo-cli
$ npm install hexo-deployer-rsync --save
```
现在可以输入：
``` bash
$ hexo init blog
```
来新建一个名为blog的文件夹，这个文件夹的名字自己取，进入这个文件夹，输入
``` bash
$ hexo s --debug
```
看到
``` bash
15:14:02.409 INFO  Hexo is running at http://localhost:4000/. Press Ctrl+C to stop.
15:14:02.432 DEBUG Database saved
```
的字样后，打开浏览器，访问localhost:4000,看看能否打开一个hexo的网页,能打开的话，证明hexo已经能在电脑上运行了。
然后编辑blog文件夹下的"_config.yml_"文件,在大约73行，"theme"后面的就是hexo生成静态网页的时候所使用的主题，本站所使用的主题是[next](https://github.com/iissnan/hexo-them-next),主题存在于blog文件夹下的them文件夹内。
在约80行左右，会有"deploy:"字样，这里填写的是部署网站的时候所用的一些组件需要的参数，如果按照本博客所说来安装hexo的话，可以参照以下填写方法：
```bash
deploy:
    type: rsync
    host: 0.0.0.0   //这里填写服务器的IP地址
    user: root   //这里填写部署网站是登陆服务器所用的用户
    root: /usr/share/nginx/html/     //这里是nginx默认的服务器站点目录，文末细说
    port: 26487     //这里是登陆服务器所用的端口，也就是ssh所用的端口
    delete: false   //下面三个可以参照我的填法，也可以自己更改
    verbose: true
    ignore_errors: false
```


### 在本地生成网页静态文件并部署到网站
切换到blog文件夹内(windows可以使用cmd，linux使用终端)，输入命令
```bash
$  hexo new "blog"
```
然后在source的_posts_文件夹下面就会生成一个blog.md的文件，使用任何一个文本编辑器编辑这个文件，把想要写在博客上的东西直接编辑到这个文件内，就可以了。
然后切换到blog文件夹，输入：
```bash
$  hexo g
```
就可以生成网页静态文件了，生成的网页静态文件在public文件夹内，然后使用：
```bash
$  hexo d
```
就可以将网页文件部署到服务器，打开浏览器，就能看到做好的网站了。


## 一些小总结

先说一下nginx，nginx会向浏览器返回网站的网页文件，这些网页文件默认在“/usr/share/nginx/www/”下面，有时候不一定在“www”下，可能是“html”文件夹，我自己的服务器就是“html”。
部署便是讲已经做好的网页文件上传到服务器的这个文件夹下，浏览器便能正常访问到做好的网页。


然后说一下config.yml文件的"root:",冒号后面是nginx的工作目录，nginx安装后默认一般都是"/usr/share/nginx/XXX/"下面，hexo部署的时候，便会将网页部署岛这个文件夹下面。

PS：我尝试在windows部署网站，但是遇到一些问题，第一次是环境错误，各种百度之后，可以成功部署，但部署之后无法访问，提示“403 forbidden”，便要手动将“/usr/share/nginx/XXX/”目录下面的所有文件夹(包括子文件夹)的属性改为775，文件属性改成664，才可以访问。

]]></content>
      <tags>
        <tag>Linux</tag>
        <tag>hexo</tag>
        <tag>Technology</tag>
      </tags>
  </entry>
  <entry>
    <title>一个超乎预料的程序</title>
    <url>/2016/12/31/such-a-program/</url>
    <content><![CDATA[写着写着，发现有点超乎想象，没想到写那么长时间
<!-- more -->
## 源代码
```C++
/*
没想到会用那么长时间，果然是说得容易，做得难。
思路是分别提取每个单项式的系数(系数可以确定改单项式的符号)、指数
标准的单项式由以下部分组成
[符号-/+][系数][x^][指数]

当指数为0时  显示为(看起来是)
n

当系数为±1且指数为1时   显示为
x

当系数不为±1且指数为1时  显示为
nx

其他的为标准形式的单项式
±nx^a

*/
#include <stdio.h>
#include <stdlib.h>

//分别定义解决程序所需的七个功能的函数
void Addition();
void Soustraction();
void Multiplication();
void Division();
void Euclid();
void Factorization();

//这个结构体，用来存储提取后的系数、指数和符号
struct Array_poly
{
    int coefficient;//系数
    int index;//指数
    char symbol;//符号
};

//show_info用来显示屏幕的提示信息
void show_info()
{
    printf(" + : Addition\n - : Soustraction\n * : Multiplication\n / : Division\n d : Derivation\n e : Euclid\n f : Factorization\n q : Quit\ncmd> ");
}

int main()
{
    //freopen("data.txt","r",stdin);
    char str;
    show_info();
    while(scanf("%c",&str)!=EOF)//读入用户所选 '+'/-/*......
    {
        switch(str)
        {
            case '+' : Addition(); break;
            //case '-' : Soustraction(); break;
            //case '*' : Multiplication(); break;
            //case '/' : Division(); break;
            //case 'd' : Derivation(); break;
            //case 'e' : Euclid(); break;
            //case 'f' : Euclid; break;
            case 'q' : return 0; break;
            default : continue;
        }
        show_info();
    }
    printf("\nBoom\n");
    return 0;
}

//执行将两个多项式加起来的选项。
void Addition()
{
    char p1x[100]={0},p2x[100]={0};//用于存储p1(x)和p2(x)两个字符串
    int i=0,j=0,tmp=0,flag=0,k=0;
    //int coefficient;
    struct Array_poly ans[20]={{0,0,0}},ans2[20]={{0,0,0}};//用于存储提取出来的系数、指数、符号;
    printf("p1(x) = ");//提示信息
    scanf("%s",p1x);
    printf("p2(x) = ");//提示信息
    scanf("%s",p2x);


    while(p1x[i])//用于提取p1(x)字符串的指数、系数、符号
    {
        if(i==0&&p1x[i]=='-')//若第一个字符为'-'，则将ans(结构体)的第0个位置的符号记为'-'
            ans[i++].symbol='-';
        if(i==0&&(p1x[i]>='0'&&p1x[i]<='9'))//若第一个字符是一个数组，则将ans(结构体)的第0个位置的符号记为'+'，实际上，这里也留了一个bug，如果第一个字符为'+'(不标准输入)
            ans[i].symbol='+';
        if(p1x[i]=='x'&&p1x[i+1]!='^')//用于处理指数为1的情况
        {
            if(tmp==0)
                tmp=1;
            //ans[j].symbol=p1x[i-1];
            if(ans[j].symbol=='-')
            {
                ans[j].coefficient=0-tmp;
                ans[j++].index=1;
            }
            else
            {
                ans[j].coefficient=tmp;
                ans[j++].index=1;
            }
            i++;
            tmp=0;
            continue;
        }
        if(p1x[i]=='x')//指数不为1的情况
        {
            if(tmp==0)
                tmp=1;
            ans[j].coefficient=tmp;
            tmp=0;
            if(ans[j].symbol=='-')
                ans[j].coefficient=0-ans[j].coefficient;
            i++;
            flag=1;//标记，这个比较重要，标记这个单项式是标准单项式
            continue;
        }
        if(p1x[i]>='0'&&p1x[i]<='9')//用于提取系数或者指数，并存储在临时的变量tmp中
        {
            tmp=tmp*10+p1x[i]-48;
        }
        if(flag==0&&(p1x[i+1]==0||p1x[i+1]=='+'||p1x[i+1]=='-')&&p1x[i]>='0'&&p1x[i]<='9')//当单项式不标准，也就是，单项式为一个纯数字的情况
        {
            ans[j].coefficient=tmp;
            ans[j].index=0;
            if(ans[j].symbol=='-')
                ans[j].coefficient=0-ans[j].coefficient;
            //ans[++j].symbol=p1x[i];
            i++;
            tmp=0;
            continue;
        }
        if(p1x[i]=='+'||p1x[i]=='-')//遇到一个±号的时候，这个时候这个单项式已经读取 完毕
        {
            if(p1x[i-1]=='x')//如果这个±前面是一个'x'，那么改单项式为指数为1的单项式。
            {
                ans[j].symbol=p1x[i];
                i++;
                continue;
            }
            else //如果是标准单项式，则存储该单项式的符号和指数
            {
                ans[j].index=tmp;
                ans[++j].symbol=p1x[i];//这个++j好好斟酌一下
            }
            flag=0;//将flag清零，表示这个单项式已经存储完毕
            tmp=0;//用于存储系数或者指数的tmp清零
        }
        i++;
    }

    j++;
    i=flag=tmp=0;//同样是清零，防止影响p2(x)的提取
    while(p2x[i])
    {
        if(i==0&&p2x[i]=='-')
        {
            ans[j].symbol='-';
            i++;
        }
        if(i==0&&(p2x[i]>='0'&&p2x[i]<='9'))
        {
            ans[j].symbol='+';
        }

        if(p2x[i]=='x'&&p2x[i+1]!='^')
        {
            if(tmp==0)
                tmp=1;
            //ans[j].symbol=p1x[i-1];
            if(ans[j].symbol=='-')
            {
                ans[j].coefficient=0-tmp;
                ans[j++].index=1;
            }
            else
            {
                ans[j].coefficient=tmp;
                ans[j++].index=1;
            }
            i++;
            tmp=0;
            continue;
        }
        if(p2x[i]=='x')
        {
            if(tmp==0)
                tmp=1;
            ans[j].coefficient=tmp;
            tmp=0;
            if(ans[j].symbol=='-')
                ans[j].coefficient=0-ans[j].coefficient;
            i++;
            flag=1;
            continue;
        }
        if(p2x[i]>='0'&&p2x[i]<='9')
        {
            tmp=tmp*10+p2x[i]-48;
        }
        if(flag==0&&(p2x[i+1]==0||p2x[i+1]=='+'||p2x[i+1]=='-')&&(p2x[i]>='0'&&p2x[i]<='9'))
        {
            ans[j].coefficient=tmp;
            ans[j].index=0;
            if(ans[j].symbol=='-')
                ans[j].coefficient=0-ans[j].coefficient;
            //ans[++j].symbol=p2x[i];
            i++;
            tmp=0;
            continue;
        }
        if(p2x[i]=='+'||p2x[i]=='-')
        {
            if(p2x[i-1]=='x')
            {
                ans[j].symbol=p2x[i];
                i++;
                continue;
            }
            else
            {
                ans[j].index=tmp;
                ans[++j].symbol=p2x[i];
            }
            flag=0;
            tmp=0;
        }
        i++;
    }

    //j++;
    flag=1;
    while(flag) //此时已经将p1(x)和p2(x)的系数、指数、符号都存储于ans中了，现在将他们按照指数的大小，从小到大排序，算法为冒泡。
    {
        flag=0;
        for(i=1;i<=j;i++)
        {
            if(ans[i].index<ans[i-1].index)
            {
                flag=ans[i].index;//嗯，这里把flag当作一个过渡变量来用了(其实我只是懒得多定义一个过渡变量)
                ans[i].index=ans[i-1].index;
                ans[i-1].index=flag;
                flag=ans[i].coefficient;
                ans[i].coefficient=ans[i-1].coefficient;
                ans[i-1].coefficient=flag;
                flag=ans[i].symbol;
                ans[i].symbol=ans[i-1].symbol;
                ans[i-1].symbol=flag;
                flag=1;

            }
        }
    }


    //将同类项合并，并存储到ans2中
    ans2[0].coefficient=ans[0].coefficient;
    ans2[0].index=ans[0].index;
    ans2[0].symbol=ans[0].symbol;
    for(i=1;i<=j;i++)
    {
        if(ans[i].index==ans2[k].index)
        {
            ans2[k].coefficient+=ans[i].coefficient;
        }
        else
        {
            ans2[++k].coefficient=ans[i].coefficient;
            ans2[k].index=ans[i].index;
            ans2[k].symbol=ans[i].symbol;
        }
    }



    printf("p1(x) + p2(x) = ");//准备输出啦
    for(i=0;i<=k;i++)
    {
        if(ans2[i].coefficient==0)//若系数为零，则直接进行下一个循环
            continue;
        if(ans2[i].coefficient==1)//系数为1的情况
        {
            if(tmp)//系数是正数，且不是第一次输出的话，需要输出一个'+'号，因为正数输出，不带符号
            {
                if(ans2[i].index!=0)//若系数为1且指数不为0，则输出x^ans[i].index
                    printf("+x^%d",ans2[i].index);
                else
                    printf("+1");//若系数为1且指数为0，则输出1
            }
            else//系数是正数，且是第一次输出的话，标记一下tmp，表示已经输出过了，第一次输出如果为正数，是不需要输出'+'的
            {
                if(ans2[i].index!=0)
                    printf("x^%d",ans2[i].index);
                else
                    printf("1");
                tmp=1;
            }
            continue;
        }
        if(ans2[i].coefficient>0)//系数不为0、不为1，且大于0的时候
        {
            if(tmp)//系数是正数，且不是第一次输出的话，需要输出一个'+'号，因为正数输出，不带符号'+'
            {
                if(ans2[i].index!=0)
                    printf("+%dx^%d",ans2[i].coefficient,ans2[i].index);
                else
                    printf("+%d",ans2[i].coefficient);
            }

            else//系数是正数，且是第一次输出的话，标记一下tmp，表示已经输出过了，第一次输出如果为正数，是不需要输出'+'的
            {
                if(ans2[i].index!=0)
                    printf("%dx^%d",ans2[i].coefficient,ans2[i].index);
                else
                    printf("%d",ans2[i].coefficient);
                tmp=1;
            }
        }
        else//系数小于0的情况，直接输出就好了，因为负数自己带着'-'号
        {
            printf("%dx^%d",ans2[i].coefficient,ans2[i].index);
            tmp=1;
        }
    }
    printf("\n");
}

```
## 运行示例

{% asset_img 1.jpg 仅含数字的情况%}
{% asset_img 2.jpg 含数字、指数为1%}
{% asset_img 3.jpg 含数字、指数为1%}

## 解析
### 从字符串中提取系数、指数、符号
思路是这样的：
对于正常的单项式`[±][n]x^[a]`(a为整数，n为正整数),遇到字符“x”的时候，表示它前面的数字是系数，遇到字符“±”时，表示它前面的数字是指数。
系数或者指数用这样的办法来提取
```C++
i=tmp=0;
while(str[i]>='0'&&str[i]<='9')
{
    tmp=tmp*10+str[i]-48;//减去48的原因是我们将多项式当作字符串读入，要将字符'0'或者'1'之类的转化成相对应的整数，得减去48之后赋值给一个int类型的变量。
    i++;
}
```
这样，我们就拿到系数或者指数了
当遇到一个x的时候，需要将拿到的系数tmp给保存起来，那就这样做
```C++
if(str[i]=='x')
{
    {
            if(tmp==0)//若tmp为0，表示x前面是一个“±”号，也就是系数为1的情况，那么tmp是不会变成1的，所以这里判断之后，将tmp变成1
                tmp=1;
            ans[j].coefficient=tmp;//将tmp存储
            tmp=0;
            if(ans[j].symbol=='-')//若这个单项式的符号为“-”，那么就将存储好的系数变成负数
                ans[j].coefficient=0-ans[j].coefficient;
            i++;
            flag=1;//标记，这个比较重要，标记这个单项式是有指数的单项式，也就是说，标记一下这个单项式不是纯数字
            continue;
        }
}
```
当遇到一个“±”号的时候，需要将拿到的指数tmp保存，这样做
```C++
if(p1x[i]=='+'||p1x[i]=='-')//遇到一个±号的时候，这个时候这个单项式已经读取 完毕
{
    if(p1x[i-1]=='x')//如果这个±前面是一个'x'，那么该单项式为指数为1的单项式。
    {
        ans[j].symbol=p1x[i];
        i++;
        continue;
    }
    else //如果是标准单项式，则存储该单项式的符号和指数
    {
        ans[j].index=tmp;
        ans[++j].symbol=p1x[i];//将j加一个1，准备存储下一个系数、指数、符号
    }
    flag=0;//将flag清零，表示这个单项式已经存储完毕
    tmp=0;//用于存储系数或者指数的tmp清零
}
```
对于指数为1的情况，特殊对待一下
```C++
        if(p1x[i]=='x'&&p1x[i+1]!='^')//用于处理指数为1的情况，也就是，遇到一个“x”，但是它后面不是“^”的情况
        {
            if(tmp==0)
                tmp=1;
            //ans[j].symbol=p1x[i-1];
            if(ans[j].symbol=='-')
            {
                ans[j].coefficient=0-tmp;
                ans[j++].index=1;
            }
            else
            {
                ans[j].coefficient=tmp;
                ans[j++].index=1;
            }
            i++;
            tmp=0;
            continue;
        }
```
对于单项式为纯数字的情况
```C++
        if(flag==0&&(p1x[i+1]==0||p1x[i+1]=='+'||p1x[i+1]=='-')&&p1x[i]>='0'&&p1x[i]<='9')//当单项式不标准，也就是，单项式为一个纯数字的情况
        //若flag为0，且当前字符是一个数字，且这个字符后面是“±”号或者字符串末尾，则这个单项式是纯数字
        {
            ans[j].coefficient=tmp;
            ans[j].index=0;
            if(ans[j].symbol=='-')
                ans[j].coefficient=0-ans[j].coefficient;
            //ans[++j].symbol=p1x[i];
            i++;
            tmp=0;
            continue;
        }
```
### 合并同类项
经过一番奋战，我们终于拿到了两个字符串的系数、指数、符号了，并且把他们都存储在了ans中，合并同类项之前，先把他们按照系数，从小到大排序
```C++
    flag=1;
    while(flag) //此时已经将p1(x)和p2(x)的系数、指数、符号都存储于ans中了，现在将他们按照指数的大小，从小到大排序，算法为冒泡。
    {
        flag=0;
        for(i=1;i<=j;i++)
        {
            if(ans[i].index<ans[i-1].index)
            {
                flag=ans[i].index;//嗯，这里把flag当作一个过渡变量来用了(其实我只是懒得多定义一个过渡变量)
                ans[i].index=ans[i-1].index;
                ans[i-1].index=flag;
                flag=ans[i].coefficient;
                ans[i].coefficient=ans[i-1].coefficient;
                ans[i-1].coefficient=flag;
                flag=ans[i].symbol;
                ans[i].symbol=ans[i-1].symbol;
                ans[i-1].symbol=flag;
                flag=1;

            }
        }
    }
```
然后合并同类项(我将合并后的多项式存储到ans2中)
```C++
    ans2[0].coefficient=ans[0].coefficient;
    ans2[0].index=ans[0].index;
    ans2[0].symbol=ans[0].symbol;
    for(i=1;i<=j;i++)
    {
        if(ans[i].index==ans2[k].index)
        {
            ans2[k].coefficient+=ans[i].coefficient;
        }
        else
        {
            ans2[++k].coefficient=ans[i].coefficient;
            ans2[k].index=ans[i].index;
            ans2[k].symbol=ans[i].symbol;
        }
    }
```

### 输出
```C++
    printf("p1(x) + p2(x) = ");//准备输出啦
    for(i=0;i<=k;i++)
    {
        if(ans2[i].coefficient==0)//若系数为零，则直接进行下一个循环
            continue;
        if(ans2[i].coefficient==1)//系数为1的情况
        {
            if(tmp)//系数是正数，且不是第一次输出的话，需要输出一个'+'号，因为正数输出，不带符号
            {
                if(ans2[i].index!=0)//若系数为1且指数不为0，则输出x^ans2[i].index
                    printf("+x^%d",ans2[i].index);
                else
                    printf("+1");//若系数为1且指数为0，则输出1
            }
            else//系数是正数，且是第一次输出的话，标记一下tmp，表示已经输出过了，第一次输出如果为正数，是不需要输出'+'的
            {
                if(ans2[i].index!=0)
                    printf("x^%d",ans2[i].index);
                else
                    printf("1");
                tmp=1;
            }
            continue;
        }
        if(ans2[i].coefficient>0)//系数不为0、不为1，且大于0的时候
        {
            if(tmp)//系数是正数，且不是第一次输出的话，需要输出一个'+'号，因为正数输出，不带符号'+'
            {
                if(ans2[i].index!=0)
                    printf("+%dx^%d",ans2[i].coefficient,ans2[i].index);
                else
                    printf("+%d",ans2[i].coefficient);
            }

            else//系数是正数，且是第一次输出的话，标记一下tmp，表示已经输出过了，第一次输出如果为正数，是不需要输出'+'的
            {
                if(ans2[i].index!=0)
                    printf("%dx^%d",ans2[i].coefficient,ans2[i].index);
                else
                    printf("%d",ans2[i].coefficient);
                tmp=1;
            }
        }
        else//系数小于0的情况，直接输出就好了，因为负数自己带着'-'号
        {
            printf("%dx^%d",ans2[i].coefficient,ans2[i].index);
            tmp=1;
        }
    }
```
{% cq %} 生命重在折腾 {% endcq %}]]></content>
      <tags>
        <tag>C</tag>
      </tags>
  </entry>
  <entry>
    <title>tensorflow 初探 | tensorflow for poets</title>
    <url>/2018/12/06/tensorflow-for-poets/</url>
    <content><![CDATA[从某个角度来说，这篇更像是翻译，原文在[https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/#0](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/#0)，原文踩梯子去看就好。

## 介绍

### 你要搭建什么

训练一个用于给花分类的简单分类器

{% asset_img 1.png tensorflow for poets %}

分类结果

```bash
daisy (score = 0.99071)
sunflowers (score = 0.00595)
dandelion (score = 0.00252)
roses (score = 0.00049)
tulips (score = 0.00032)
```

<!-- more -->

### 你会学到什么

- 如何使用 Python 和 tensorflow 来训练一个图片分类器
- 如何使用这个分类器来分类图片

### 你需要会什么

- 一点点命令行的基础操作

## 准备工作

### 安装tensorflow

```bash
pip install --upgrade "tensorflow==1.7.*"
```

PS: 至少需要1.7版本的tensorflow
原文使用了`pip`命令，但是我个人推荐使用anaconda，国内可以前往[清华软件源](https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/)下载对应版本，推荐python3版本，安装后按照[帮助](https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/)配置好清华源，然后使用命令

```bash
conda install tensorflow
```

安装tensorflow

### 下载 git repository

确保你的git命令可用，然后

```bash
git clone https://github.com/googlecodelabs/tensorflow-for-poets-2
cd tensorflow-for-poets-2
```

## 下载训练用的图片

```bash
http://download.tensorflow.org/example_images/flower_photos.tgz
```

这个是tensorflow网站上的已经分类好的图片，可以免费下载，下载后将他解压到`tensorflow-for-poets-2`文件夹下的`tf_files`文件夹内

Linux 用户可以直接输入命令

```bash
curl http://download.tensorflow.org/example_images/flower_photos.tgz | tar xz -C tf_files
```

这个时候`tf_files/flower_photos`目录里应该是这个样子的

```bash
daisy/
dandelion/
roses/
sunflowers/
tulip/
LICENSE.txt
```

PS： 这里目录不能放错

## 开工

### 配置 MobileNet

翻译水平有限，贴一下原文

> In this exercise, we will retrain a MobileNet. MobileNet is a a small efficient convolutional neural network. "Convolutional" just means that the same calculations are performed at each location in the image.
The MobileNet is configurable in two ways:
- Input image resolution: 128,160,192, or 224px. Unsurprisingly, feeding in a higher resolution image takes more processing time, but results in better classification accuracy.
- The relative size of the model as a fraction of the largest MobileNet: 1.0, 0.75, 0.50, or 0.25.

> We will use 224 0.5 for this codelab.
With the recommended settings, it typically takes only a couple of minutes to retrain on a laptop. You will pass the settings inside Linux shell variables. Set those variables in your shell:
```bash
IMAGE_SIZE=224
ARCHITECTURE="mobilenet_0.50_${IMAGE_SIZE}"
```

最后，你需要设置两个变量

#### 对于Linux系统，输入以下命令

```bash
IMAGE_SIZE=224
ARCHITECTURE="mobilenet_0.50_${IMAGE_SIZE}"
```

#### 对于Windoiws系统

```bash
set "IMAGE_SIZE=224"
set "ARCHITECTURE="mobilenet_0.50_%IMAGE_SIZE%""
```

### 启动 TensorBoard

TensorBoard在安装 tensorflow 时会自动安装，如果没有这个命令，检查一下 tensorflow 是否安装成功

```bash
tensorboard --logdir tf_files/training_summaries
```

PS: 这个命令需要在`tensorflow-for-poets-2`目录里面执行

> 如果你之前执行过这个命令，那么你会看到一下提示
>>
```bash
ERROR:tensorflow:TensorBoard attempted to bind to port 6006, but it was already in use
```
> 可以用命令
>> 
```bash
pkill -f "tensorboard"
```
结束之前启动的进程，Windows可以用任务管理器结束这个进程。

### 查看 retrain 脚本

这个脚本来自[TensorFlow Hub repo](https://github.com/tensorflow/hub/blob/master/examples/image_retraining/retrain.py)，但是并不是用`pip`之类的命令来安装的，并且已经包含在这个repo里面了，你可以用这个python来运行这个脚本，查看帮助

```bash
python -m scripts.retrain -h
```

### 开始训练

用下面这个超长的命令来开始训练(你需要注意`--summaries_dir`命令)

For Linux

```bash
python -m scripts.retrain \
  --bottleneck_dir=tf_files/bottlenecks \
  --how_many_training_steps=500 \
  --model_dir=tf_files/models/ \
  --summaries_dir=tf_files/training_summaries/"${ARCHITECTURE}" \
  --output_graph=tf_files/retrained_graph.pb \
  --output_labels=tf_files/retrained_labels.txt \
  --architecture="${ARCHITECTURE}" \
  --image_dir=tf_files/flower_photos
```

For Windows

```bash
python -m scripts.retrain ^
  --bottleneck_dir=tf_files/bottlenecks ^
  --how_many_training_steps=500 ^
  --model_dir=tf_files/models/ ^
  --summaries_dir=tf_files/training_summaries/"%ARCHITECTURE%" ^
  --output_graph=tf_files/retrained_graph.pb ^
  --output_labels=tf_files/retrained_labels.txt ^
  --architecture="%ARCHITECTURE%" ^
  --image_dir=tf_files/flower_photos
```

这一步会花很长时间。
如果你需要更高精度，那么需要更多的时间，更改`--how_many_training_steps=500`，把500该得更大比如默认的`4000`。

### 查看训练结果

如果你运行了`tensorboard --logdir tf_files/training_summaries`，那么你可以在打开浏览器，输入"127.0.0.1:6006"，来查看一些数据，看起来像下面这个样子

{% asset_img 2.jpg %}

## 使用训练好的模型

训练好的数据存在下面这个两个文件里面

- `tf_files/retrained_graph.pb`， which contains a version of the selected network with a final layer retrained on your categories.
- `tf_files/retrained_labels.txt`， which is a text file containing labels.

### 分类一张图片

可以用命令

```bash
python -m scripts.label_image -h
```

看一下帮助

然后，给下面这朵菊花分类一下，`flower_photos/daisy/21652746_cc379e0eea_m.jpg`
{% asset_img 1.png tensorflow for poets %}

使用命令

```bash
python -m scripts.label_image --graph=tf_files/retrained_graph.pb  --image=tf_files/flower_photos/daisy/21652746_cc379e0eea_m.jpg
```

你将会看到大概像下面这样的信息

```bash
Evaluation time (1-image): 0.422s

daisy (score=0.99372)       雏菊
sunflowers (score=0.00377)  向日葵
dandelion (score=0.00248)   蒲公英
roses (score=0.00003)       玫瑰
tulips (score=0.00000)      郁金香
```

上面的信息意思是指定的图片是`雏菊`的可信度高达99%.
你可以使用`label_image.py`来分类图片，可以选择自己从任何地方下载的花的图片来尝试，使用`--image`来指定路径

`flower_photos/roses/2414954629_3708a1a04d.jpg`
{% asset_img 3.png tensorflow for poets %}

```bash
python -m scripts.label_image --graph=tf_files/retrained_graph.pb  --image=tf_files/flower_photos/roses/2414954629_3708a1a04d.jpg 

Evaluation time (1-image): 0.437s

roses (score=0.98361)       玫瑰
tulips (score=0.01612)      郁金香
dandelion (score=0.00026)   蒲公英
sunflowers (score=0.00000)  向日葵
daisy (score=0.00000)       雏菊
```

## 碎碎念

1. 对于默认python为python2的Linux系统，需要将命令中的python全部替换成python3，输入命令`python -V`，即可查看默认python是什么版本;
2. 本文更类似于翻译，原文没有添加关于Windows上的操作，大体上是类似的，设置变量和cmd的换行符转义不太一样，并且很多可选内容我没有搬运过来，很多参数的解说也没有翻译，感兴趣的前往原文查看[https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/#0](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets/)；
3. 原文网站上有更多好玩的东西
    - [TFLite Android](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2-tflite)
    - [TFMobile Android](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2)]]></content>
  </entry>
  <entry>
    <title>验证“探寻C++最快的读取文件的方案&quot;</title>
    <url>/2017/03/18/the-truth/</url>
    <content><![CDATA[本文接上一篇文章————探寻C++最快的读取文件的方案
仔细看了一下原文，发布时间是五年前，五年时间，无论是硬件还是软件环境都有了巨大的进步，我决定动手实现一下。
{% asset_img avatar.jpg %}
<!-- more -->
首先编写了一个生成生成随机数的程序，代码如下:
```C++
#include<cstdio>                       
#include<ctime>                        
#include<cstdlib>                      
int main ()                            
{                                      
        freopen("data.txt","w",stdout);
        srand(time(0));                
        for(int i=0;i<1000000;i++)     
                printf("%d ",rand());  
        return 0;                      
}
```
生成一千万个随机数，并存储在`data.txt`中，约54MB。
编写使用`scanf`读取数据的程序，代码如下:
```C++
#include<cstdio>                                               
#include<ctime>
int a[10000000];                                                
int main ()                                                    
{                                                              
        int start = clock();                                 
        freopen("data.txt","r",stdin);                         
        for(int i=0;i<10000000;i++)                             
                scanf("%d",&a[i]);                                
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}                                                              
```
执行之后，使用时间为`1.18s`，相比于原文的`2.01`秒，缩短了一截，然后测试一下使用`cin`输入的情况，代码如下:
```C++
#include<cstdio>
#include<ctime>
#include<iostream>
int a[10000000];
int main ()
{
        int start = clock();
        freopen("data.txt","r",stdin);
        for(int i=0;i<10000000;i++)
                std::cin>>a[i];
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}
```
`cin`的使用时间为`4.67s`，比`scanf`更长，但是相比于原文的`6.38s`还是短得多。
然后取消`cin`与`stdin`之间的同步之后，代码如下:
```C++
#include<cstdio>
#include<ctime>
#include<iostream>
int a[10000000];
int main ()
{
        int start = clock();
        std::ios::sync_with_stdio(false);
        freopen("data.txt","r",stdin);
        for(int i=0;i<1000000;i++)
                std::cin>>a[i];
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}
```
时间大幅缩短，为`1.24s`，与scanf很接近了。
然后按原文测试读入整个文件,代码如下:
```C++
#include<iostream>                                              
#include<ctime>                                                 
#include<cstdio>                                                
const int MAXN = 10000000;                                      
const int MAXS = 60*1024*1024;                                  
int numbers[MAXN];                                              
char buf[MAXS];                                                 
                                                                
void analyse(char *buf, int len =MAXS)                          
{                                                               
        int i;                                                  
        numbers[i=0]=0;                                         
        for(char *p=buf;*p && p-buf<len;p++)                    
        if(*p == ' ')                                           
                numbers[++i]=0;                                 
        else                                                    
                numbers[i]=numbers[i]*10+*p-'0';                
}                                                               
                                                                
void fread_analyse()                                            
{                                                               
        freopen("data.txt","rb",stdin);                         
        int len = fread(buf,1,MAXS,stdin);                      
        buf[len]='\0';                                          
        analyse(buf,len);                                       
}                                                               
                                                                
int main ()                                                     
{                                                               
        int start = clock();                                    
        fread_analyse();                                        
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC); 
        return 0;                                               
}
```
时间如原文一般，大幅缩短，我这里测试得到`0.37s`，使用`read`测试，代码如下:
```C++
#include<iostream>                                             
#include<ctime>                                                
#include<cstdio>                                               
#include<unistd.h>                                             
#include<fcntl.h>                                              
const int MAXN = 10000000;                                     
const int MAXS = 60*1024*1024;                                 
int numbers[MAXN];                                             
char buf[MAXS];                                                
                                                               
void analyse(char *buf, int len =MAXS)                         
{                                                              
        int i;                                                 
        numbers[i=0]=0;                                        
        for(char *p=buf;*p && p-buf<len;p++)                   
        if(*p == ' ')                                          
                numbers[++i]=0;                                
        else                                                   
                numbers[i]=numbers[i]*10+*p-'0';               
}                                                              
                                                               
void read_analyse()                                            
{                                                              
        int fd = open("data.txt",O_RDONLY);                    
        int len = read(fd,buf,MAXS);                           
        buf[len]='\0';                                         
        analyse(buf,len);                                      
}                                                              
                                                               
int main ()                                                    
{                                                              
        int start = clock();                                   
        read_analyse();                                        
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
        return 0;                                              
}                                                              
```
测试时间为`0.31s`，有所进步，不过不是非常明显。
调用`mmap`，代码如下:
```C++
#include<iostream>                                                      
#include<ctime>                                                         
#include<cstdio>                                                        
#include<unistd.h>                                                      
#include<fcntl.h>                                                       
#include<sys/mman.h>                                                    
const int MAXN = 10000000;                                              
const int MAXS = 60*1024*1024;                                          
int numbers[MAXN];                                                      
char buf[MAXS];                                                         
                                                                        
void analyse(char *buf, int len =MAXS)                                  
{                                                                       
        int i;                                                          
        numbers[i=0]=0;                                                 
        for(char *p=buf;*p && p-buf<len;p++)                            
        if(*p == ' ')                                                   
                numbers[++i]=0;                                         
        else                                                            
                numbers[i]=numbers[i]*10+*p-'0';                        
}                                                                       
                                                                        
void mmap_analyse()                                                     
{                                                                       
        int fd = open("data.txt",O_RDONLY);                             
        int len = lseek(fd,0,SEEK_END);                                 
        char *mbuf = (char *) mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);
        analyse(mbuf,len);                                              
}                                                                       
                                                                        
int main ()                                                             
{                                                                       
        int start = clock();                                            
        mmap_analyse();                                                 
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);         
        return 0;                                                       
}                                                                       
```
运行结果才让我大跌眼镜，虽然我没有眼镜
{% asset_img ahaha.jpg %}
达到`0.49s`，与原文不符(原文中使用`mmnp`耗时更短，在我的测试中，耗时变长了)，可能是代码与原作者的不一样，原作者只给出一部分代码，而测试需要写出完整的代码，可能我写的代码有问题。
以上测试结果在腾讯云上进行,因为原作者当时的硬件条件可能比不上我所使用的环境，我在树莓派 3B和我自己的电脑上测试了一下，所有平台硬件信息如下：

|平台/硬件和软件信息|Cent OS|Raspberry|Windows|
|:--:|:--:|:--:|:--:|
|CPU|1 core|Broadcom BCM2837 1.2GHz|intel Core 5200u 2.2GHz|
|RAM|1GB|1GB|12GB|
|Gcc|4.8.5|4.9.2|5.3.0|
PS: 这里忽略了硬盘的性能，理论上来说，硬盘的性能肯定能影响读写速度，只是没有较好的方法比较三个平台的硬盘性能，只能作罢。
测试结果汇总如下:

|方法/平台/耗时(s)|Cent OS|Raspberry|Windows(本机)|Ubuntu(本机)|
|:--:|:--:|:--:|:--:|:--:|
|scanf|1.180|14.786|4.488|1.158|
|cin|4.670|61.255|13.026|4.309|
|cin取消同步|1.240|7.694|8.086|1.135|
|fread|0.37|3.503|0.327|0.284|
|read|0.31|2.975|0.370|0.285|
|mmap|0.49|5.945|NULL|0.447|

{% cq %}生命重在折腾{% endcq %}
]]></content>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>【推广】实用命令——tldr</title>
    <url>/2017/06/30/tool-tldr/</url>
    <content><![CDATA[{% asset_img 2.jpg tldr %}
<!-- more -->
## 碎碎念
如题，通常遇到一个新的命令需要查询其帮助的时候，一般使用`command -h`或者`man command`来查询，但是，有时候仅仅想知道这个命令怎么用，并不想知道具体含义啊(这个命令可能不常用，没有必要仔细阅读手册)，于是，`tldr`出现了。而且，巨长无比的文档看起来就头疼。
## 安装
安装`tldr`之前，得先安装好`node.js`，然后使用命令
```bash
$ npm install tldr -g
```
来进行安装。
## 使用
```bash
$ tldr command
```
就好了，第一次使用，需要联网下载一些数据，等一下就好了。
## 展示
{% asset_img 1.jpg tldr tar %}
{% asset_img 3.jpg man tar %}
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>ubuntu 自定义触控板手势</title>
    <url>/2016/03/28/ubuntu-touchpad/</url>
    <content><![CDATA[描述：ubuntu的触控板手势不多，最高只支持两点触控，白白浪费了触控板这四点触控。偶然在知乎上看到有人用一个软件[xSwipe](https://github.com/iberianpig/xSwipe) 成功实现多点触控，实测可以自行调节所需手势，我在安装过程中遇到一些麻烦，这里记录下来，作为备用。

<!-- more -->

xSwipe在开源项目网站GitHub上可以找到，[传送门](https://github.com/iberianpig/xSwipe),或访问 https://github.com/iberianpig/xSwipe PS:由于服务器在国外，国内访问可能很慢，我将所需文件备份了一份，下载地址放在文章末尾了。

官网上的说明文档是英文版，虽然推荐读者阅读原版文档，但是为了照顾英语不好的同志，我找了一篇中文博客([点我访问](http://loliko.me/zai-linuxzhong-tian-jia-hong-mo-ban-shou-shi/)),安装过程这篇博客已经说得很清楚了，这里不再叙述。 下面贴出官方的说明文档：

## xSwipe
xSwipe is multitouch gesture recognizer. This script make your linux PC able to recognize swipes like a Macbook.

### Usage
Before running the script, you must first do some preparations.

1: Download xSwipe
2:Install X11::GUITest
3:Enable SHMConfig

### 1. Download xSwipe
Type below code, download xSwipe from github
``` bash
$ cd ~
$ wget https://github.com/iberianpig/xSwipe/archive/master.zip
$ unzip master.zip
``` 

### 2. Install X11::GUITest
To install libx11-guitest-perl from synaptic package manager Or run the script on the terminal run as

``` bash
$ sudo apt-get install libx11-guitest-perl
NOTE: If using Ubuntu14.04, or later
Install older version synaptics driver that is compatible with xSwipe.
$ sudo apt-get install -y git build-essential libevdev-dev autoconf automake libmtdev-dev xorg-dev xutils-dev libtool
$ sudo apt-get remove -y xserver-xorg-input-synaptics
$ git clone https://github.com/Chosko/xserver-xorg-input-synaptics.git
$ cd xserver-xorg-input-synaptics
$ ./autogen.sh
$ ./configure --exec_prefix=/usr
$ make
$ sudo make install
``` 

### 3. Enable SHMConfig
Open /etc/X11/xorg.conf.d/50-synaptics.conf with your favorite text editor and edit it to enable SHMConfig
``` bash
$ sudo gedit /etc/X11/xorg.conf.d/50-synaptics.conf  
``` 
NOTE:You will need to create the /etc/X11/xorg.conf.d/ directory and create 50-synaptics.conf if it does'nt exist yet. $ sudo mkdir /etc/X11/xorg.conf.d/

/etc/X11/xorg.conf.d/50-synaptics.conf
Section "InputClass"
Identifier "evdev touchpad catchall"
Driver "synaptics"
MatchDevicePath "/dev/input/event*"
MatchIsTouchpad "on"
Option "Protocol" "event"
Option "SHMConfig" "on"
EndSection
To reflect SHMConfig, restart your session.

That's it for preparation.

### Run xSwipe
To run xSwipe, type below code on terminal.
``` bash
$ perl ~/xSwipe-master/xSwipe.pl
Note:You should run xSwipe.pl in same directory as "eventKey.cfg" .
``` 
You can use "swipe" with 3 or 4 fingers, they can call an event. Additionally, some gestures are avilable.

edge-swipe : swipe with 2 fingers from outside edge(need to enable with option).
long-press : hold pressure for 0.5 seconds with 3 or 4 fingers.
### Option
-d RATE : RATE is sensitivity to swipe.Default value is 1. Shorten swipe-length by half (e.g.,$ perl xSwipe.pl -d 0.5)
-m INTERVAL : INTERVAL is how often synclient monitor changes to the touchpad state. Default value is 10(ms). Set 50ms as monitoring-span. (e.g.,$ perl xSwipe.pl -m 50)
-n : Natural scroll like Macbook, use "/nScroll/eventKey.cfg".
-e : Enable edge-swipe

### Customize
You can customize the settings for gestues to edit eventKey.cfg. Please check this article, "How to customize gesture".

### Bindable gestures
3/4/5 fingers swipe
2/3/4/5 fingers long-press
2/3/4 fingers edge-swipe
2fingers edge-swipe: only swipe-left/right from right/left edge
3fingers edge-swipe: only swipe-down from top egde

### Example shortcut keys
go back/forward on browser (Alt+Left, Alt+Right)
open/close a tab on browser (Ctrl+t/Ctrl+w)
move tabs (Ctrl+Tab, Ctrl+Shift+Tab)
move workspaces (Alt+Ctrl+Lert, Alt+Ctrl+Right, Alt+Ctrl+Up, Alt+Ctrl+Down)
move a window (Alt+F7)
open launcher (Alt+F8)
open a terminal (Ctrl+Alt+t)
close a window (Alt+F4)
Please let me know if you have any questions about this program.


我按照说明文档安装好所需软件之后，进行到最后一步
``` bash
$ perl ~/xSwipe-master/xSwipe.pl
``` 

遇到错误提示：
"Can't locate Smart/Comments.pm in @INC (you may need to install the Smart::Comments module) (@INC contains: /etc/perl /usr/local/lib/perl/5.18.2 /usr/local/share/perl/5.18.2 /usr/lib/perl5 /usr/share/perl5 /usr/lib/perl/5.18 /usr/share/perl/5.18 /usr/local/lib/site_perl .) at /home/jackson/xSwipe-master/xSwipe.pl line 15."

百度无果，最后还是google给了我[答案](https://forum.teksyndicate.com/t/perl-smart-comments/86880) 可以访问原文地址:https://forum.teksyndicate.com/t/perl-smart-comments/86880

做法是，在终端键入下列命令:
``` bash
sudo cpan -i Smart::Comments
``` 

等待完成即可，不出意外的话，通过命令：
``` bash
$ perl ~/xSwipe-master/xSwipe.pl
``` 
就可以开启三点以上触控板手势了，可以根据需要自行更改eventKey.cfg的内容来获得自己想要的手势。

[xSwipe下载](http://pan.baidu.com/s/1gesqHm7)：http://pan.baidu.com/s/1gesqHm7

此文章仅作参考使用，使用时请仔细阅读说明文档。

我使用的操作系统为 ubuntu 14.04 LTS
]]></content>
      <tags>
        <tag>ubuntu touchpad 触控板调节</tag>
      </tags>
  </entry>
  <entry>
    <title>关于“undefined reference to”</title>
    <url>/2018/05/18/undefined-reference-to/</url>
    <content><![CDATA[不太清楚这个是否算是gcc的问题，总之是遇到了。
Gcc的编译log一般如下

```bash
SomePath/SomeSourceFile|6|undefined reference to `Foo'|
||error: ld returned 1 exit status|
```

<!-- more -->

这一次我遇到的是

```bash
putty-src/windows/winnet.c:828: undefined reference to `IN6_IS_ADDR_LOOPBACK'
collect2.exe: error: ld returned 1 exit status
```
这是在用CodeBlocks编译PuTTY的时候遇到的问题，很扰人。用命令行编译没问题，在Visual Studio里面也没问题，换到CodeBlocks之后这个问题困扰了很长时间。
看编译Log可以知道在PuTTY源码的windows目录下的winnet.c文件828行，有一个未定义的函数`IN6_IS_ADDR_LOOPBACK`，源码如下：

```C
#ifndef NO_IPV6
    if (family == AF_INET6) {
    	return IN6_IS_ADDR_LOOPBACK(&((const struct sockaddr_in6 *)step.ai->ai_addr)->sin6_addr);
    } else
#endif
    if (family == AF_INET) {
#ifndef NO_IPV6
	if (step.ai) {
	    return ipv4_is_local_addr(((struct sockaddr_in *)step.ai->ai_addr)
				      ->sin_addr);
	} else
#endif
```
右击函数`IN6_IS_ADDR_LOOPBACK`，找到函数定义，在头文件`ws2tcpip.h`有如下定义：

```C
······
int IN6_IS_ADDR_LOOPBACK(const struct in6_addr *);
······
WS2TCPIP_INLINE int IN6_IS_ADDR_LOOPBACK(const struct in6_addr *a) { return ((a->s6_words[0]==0) && (a->s6_words[1]==0) && (a->s6_words[2]==0) && (a->s6_words[3]==0) && (a->s6_words[4]==0) && (a->s6_words[5]==0) && (a->s6_words[6]==0) && (a->s6_words[7]==0x0100)); }
······
```

百度搜索`undefined reference to`，得到的信息非常杂乱，没有很确定的目标。
为了找到原因所在，准备复现问题。
新建文件`main.h`，写入一下内容
```c
#ifndef MAIN_H
#define MAIN_H

int Foo(int ,int );

__CRT_INLINE int Foo(int a,int b)
{
    return a+b;
}

#endif //MAIN_H
```
新建文件`main.cpp`，写入以下内容:
```c
#include <stdio.h>
#include <stdlib.h>
#include "main.h"
int main()
{
    printf(Foo(1,2));
    return 0;
}
```
出现提示 *main.c|6|undefined reference to \`Foo'| *，成功复现，
尝试定位问题
 - 将`main.c`改成`main.cpp`，提示消失
 - 将`__CRT_INLINE `去掉，提示消失
 - CodeBlocks切换到`Release`，提示消失

右击`__CRT_INLINE `，找到定义，在`_mingw.h`内找到信息如下：
```c
#ifdef __cplusplus
# define __CRT_INLINE inline
#elif defined(_MSC_VER)
# define __CRT_INLINE __inline
#else
# if ( __MINGW_GNUC_PREREQ(4, 3)  &&  __STDC_VERSION__ >= 199901L) \
     || (defined (__clang__))
#  define __CRT_INLINE extern inline __attribute__((__gnu_inline__))
# else
#  define __CRT_INLINE extern __inline__
# endif
#endif
```
可以看到`__CRT_INLINE `其实是内联函数，那么看起来问题好像是在头文件内同时定义声明了一个函数带来的问题，但是换用`g++`又没有出现问题，在`MSVC`上也没有出现问题，用`Makefile`也没有出现问题，那么是编译的时候少了参数导致的问题了。
于是对着PuTTY源码的的`Makefile`一个一个加参数，最后确定是因为少了`-O`(大写的O)，这个参数是用来优化代码的，具体讨论可以查看知乎的帖子[GCC中-O1 -O2 -O3 优化的原理是什么？](https://www.zhihu.com/question/27090458)，在@vczh的回答

> C++的template就设计成，只要你开了优化就可以把封装带来的中间层去掉的形式。因此STL拼命的抽象，然后你开了O2，这些抽象编译后就“不占地方”了，就跟你直接用C为每个类型精心设计的容器类型一样。当然C++显然方便多了。但是你不开O2，你就能感受到那些抽象带来的效果。
作者：vczh
链接：https://www.zhihu.com/question/27090458/answer/35224898
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

这应该也就是将后缀改为`cpp`之后提示会消失的原因，本来这个参数是在编译`Release`版的程序的时候使用的，CodeBlocks默认的`Debug`参数并不包含`-O`，开启这个参数之后，有可能会因为编译器的优化为debug程序带来其他的问题。
其实这个问题在将函数的声明和定义分开写的时候也不会出现（也就是声明写在SomeSourceFile.h，定义写在SomeSourceFile.c/cpp）内也不会复现。

本篇所对应的`undefined reference to 'IN6_IS_ADDR_LOOPBACK'`问题应该很少见，常见的`undefined reference to`并不是因为文章中所说的问题，一些更详细的问题可以阅读["undefined reference to" 问题汇总及解决方法 ](https://segmentfault.com/a/1190000006049907)
下载建立好的PuTTY的项目文件可以前往[PuTTY](https://github.com/BDZNH/PuTTY)，内含CodeBlocks和Visual Studio 2017的项目文件。]]></content>
  </entry>
  <entry>
    <title>关于文件编码的一些思考</title>
    <url>/2017/02/14/unicode/</url>
    <content><![CDATA[这几日，用`nginx`给人共享文件，改了配置文件，然后我的博客本地预览的时候是乱码的,成了这样：
{% asset_img 1.jpg %}
<!-- more -->
据之前的经验来看，必定是编码格式的问题，当我查看网页代码的时候，神奇的事情就出现了，用`Visual Code`查看网页代码是正常的，但是在浏览器里面是乱码的。一开始以为是`npm`抽风，重装之后，发现并没有起作用，用`hexo s --debug`查看调试信息也没有什么问题，并且正常，生成网页本地查看的时候是乱码，上传到VPS上却又是正常的。怀疑到`nginx`上来。
慢慢调整，发现是nginx的配置文件的问题，乱码时的nginx配置文件时这样的：
```
worker_processes  1;

events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    keepalive_timeout  65;
    server {
        listen       80;
        listen       [::]:80;
        server_name  localhost;
        location / {
            root   C:\Users\BDZNH\blog\public;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
        charset GBK;
        client_max_body_size 4G;
        location /src {
            
            alias F:\\;
            autoindex on;
            autoindex_exact_size off;
            autoindex_localtime on;
        }
    }
}
```
更改之后的配置文件是这样的
```
worker_processes  1;

events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    keepalive_timeout  65;
    server {
        listen       80;
        listen       [::]:80;
        server_name  localhost;
        location / {
            root   C:\Users\BDZNH\blog\public;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
        
        client_max_body_size 4G;
        location /src {
            charset GBK;
            alias F:\\;
            autoindex on;
            autoindex_exact_size off;
            autoindex_localtime on;
        }
    }
}
```
正常的时候是这样的
{% asset_img 2.jpg %}
`29`行的`charset GBK`，问题便出现在这儿，这里让nginx指定了网页的文件编码格式为GBK，但是`hexo`生成的网页格式是`utf-8`的，两种编码格式不一样，所以乱码。
这里就吐槽一下微软，Windows 系统的默认字符编码集是GBK，据知乎上的大牛说是为了效率，但是字符集的不统一真是一个很肝疼的问题，ssh远程到linux主机，使用了utf-8格式，本地终端使用的却是GBK，调整终端的编码集，远程之后能正常显示中文，但是在本地中文又是乱码的。非得逼我打开几个终端。

{% asset_img 3.jpg %}
{% cq %}生命重在折腾{% endcq %}]]></content>
      <tags>
        <tag>unicode</tag>
      </tags>
  </entry>
  <entry>
    <title>安卓 RemoteCallbackList 的使用 （应用篇）</title>
    <url>/2024/08/03/usage-of-Android-RemoteCallbacckList-APP/</url>
    <content><![CDATA[
通过aidl，我们可以实现client（后称客户端）和server（服务端）的双向通信，有时候server和client处于不同的进程当中，如果client意外退出，server再向client发送消息的话，就有可能导致server端也退出。

安卓提供了 RemoteCallbackList 来为我们隐式解决了这种问题。

下面来看一个示范。
<!-- more -->
首先我们定义用于客户端向服务端通信的一个 aidl
```java
// ICallBackTestInterface.aidl
package com.callback;

// Declare any non-default types here with import statements

import com.callback.ICallbackTestCallback;

interface ICallBackTestInterface {
    // 向服务端注册客户端回调
    void register(ICallbackTestCallback callback);
    // 向服务端注销客户端回调
    void unregister(ICallbackTestCallback callback);
    // 向服务端发送消息
    void callServer(String msg);
}
```
其内的 ICallbackTestCallback 也是一个 aidl，其内容如下
```java
// ICallbackTestCallback.aidl
package com.callback;

// Declare any non-default types here with import statements

interface ICallbackTestCallback {
    /**
     * 服务端调用客户端的回调
     **/
    void onReceived(String msg);
}
```
编译之后我们可以看到，实际上 aidl 编译之后就会变成类似这样的内容
```java
public interface ICallbackTestCallback extends android.os.IInterface
{
    public static abstract class Stub extends android.os.Binder implements com.callback.ICallbackTestCallback{
...
```
这个也是aidl的核心，实际上这个Stub是一个 Binder 的实现，并且还实现了我们定义在 aidl 里面的接口

# 服务端
服务端比较简单，直接贴代码
```java
//callbackserver.java
package com.callback.server;

import androidx.annotation.Nullable;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;

import com.callback.ICallBackTestInterface;
import com.callback.ICallbackTestCallback;

public class callbackserver extends Service {

    private final String TAG = "testcallback";

    // 这里的 clients 就是 RemoteCallbackList 的用法了，我们用它来存储注册了的客户端，然后在某些时候向注册了的客户端发送消息。
    private final RemoteCallbackList<ICallbackTestCallback> clients = new RemoteCallbackList<>();

    CallBackServer server = new CallBackServer();

    private boolean serverRunning = false;

    @Override
    public void onCreate() {
        Log.d(TAG,"callback test server create");
        // service 创建的时候，开一个线程去向注册了的客户端发送消息
        serverRunning = true;
        new Thread(serverRunnable).start();
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.d(TAG,"callback test server destroy");
        serverRunning = false;
        super.onDestroy();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        // 将一个实现了 ICallBackTestInterface.Stub 的Binder对象返回
        // 客户端调用 bind service 时会拿到一个返回的 Binder 对象，就是这里的 server，也就是一个
        // ICallBackTestInterface.Stub 实例
        return server;
    }

    /**
     * 返回给客户端的 Binder 对象的实现
     */
    private class CallBackServer extends ICallBackTestInterface.Stub {

        @Override
        public void register(ICallbackTestCallback callback) throws RemoteException {
            Log.d(TAG,"register callback from pid=" + Binder.getCallingPid());
            clients.register(callback);
        }

        @Override
        public void unregister(ICallbackTestCallback callback) throws RemoteException {
            Log.d(TAG,"unregister callback from pid=" + Binder.getCallingPid());
            clients.unregister(callback);
        }

        @Override
        public void callServer(String msg) throws RemoteException {
            Log.d(TAG,"received msg: " + msg + " . from pid=" + Binder.getCallingPid());
        }
    }

    // 向客户端发送消息的具体实现
    // 简单的做一个自增运算，然后发送回客户端
    private Runnable serverRunnable = () ->{
        int count = 0;
        while(serverRunning){
            try {
                Thread.sleep(500);
                noteClients(Integer.toString(count++));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

    /**
     * 这里就是 RemoteCallbackList 的关键用法了
     * beginBroadcast 和 finishBroadcast 需要配套使用
     * beginBroadcast 会返回注册了的客户端数量，然后开一个循环依次取出客户端注册的回调，并调用回调内的
     * onReceived 函数。这个函数需要客户端实现 ICallbackTestCallback.Stub 之后，注册给服务端
     * @param msg
     */
    private void noteClients(String msg){
        int cb = clients.beginBroadcast();
        for(int i=0;i<cb;i++){
            try {
                clients.getBroadcastItem(i).onReceived(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        clients.finishBroadcast();
    }
}
```
服务端对应的 AndroidMenifest.xml
```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.callback.server">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Server">
        <service android:name=".callbackserver"
            android:exported="true">

        </service>
    </application>

</manifest>
```
简单的表示有一个service就好，其他的内容和一般的app一样。
p.s: 这里我是将服务端和客户端分为两个app来实现了。

服务端的文件的结构如下
```bash
C:.
├─aidl
│  └─com
│      └─callback
│            ICallbackTestCallback.aidl
│            ICallBackTestInterface.aidl
├─java
│  └─com
│      └─callback
│          └─server
│                  callbackserver.java
└─res
    ├─drawable
    ├─drawable-v24
    ├─layout
    ├─mipmap-anydpi-v26
    ├─mipmap-hdpi
    ├─mipmap-mdpi
    ├─mipmap-xhdpi
    ├─mipmap-xxhdpi
    ├─mipmap-xxxhdpi
    ├─values
    └─values-night
```
服务端的全部内容如上面所示。

# 客户端
客户端我们使用两个独立的进程（当时在同一个app里面）
客户端的 AndroidMenifest.xml
```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.callback.client">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="Client"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Client">
        <activity android:name=".ActivityB"
            android:launchMode="singleInstance"
            android:process="com.callback.client.ActivityB"
            android:label="Activityb">
        </activity>

        <activity
            android:name=".ActivityA"
            android:launchMode="singleInstance"
            android:process="com.callback.client.ActivityA"
            android:label="ActivityA">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>
```
我定义了两个Activity，一个ActivityA，一个ActivityB。
ActivityA的实现如下
```java
package com.callback.client;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Binder;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;

import com.callback.ICallbackTestCallback;
import com.callback.ICallBackTestInterface;

public class ActivityA extends AppCompatActivity implements View.OnClickListener{

    private final String TAG = "testcallback";

    private boolean bound = false;

    ICallBackTestInterface remoteServer = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button activityb = findViewById(R.id.startactivity);
        activityb.setText("open activity b");
        initClickListener();
    }

    @Override
    protected void onResume() {
        if(bound){
            registerCallback();
        }
        super.onResume();
    }

    @Override
    protected void onPause() {
        if(bound){
            unregisterCallback();
        }
        super.onPause();
    }



    private final ServiceConnection serviceConnection = new ServiceConnection(){

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder service) {
            remoteServer = ICallBackTestInterface.Stub.asInterface(service);
            registerCallback();
            bound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

    private ICallbackTestCallback callback = new ICallbackTestCallback.Stub(){

        @Override
        public void onReceived(String msg) throws RemoteException {
            Log.d(TAG,"received msg: " + msg + " . from server pid=" + Binder.getCallingPid());
        }
    };

    private void initClickListener(){
        Button button = findViewById(R.id.registerBotton);
        button.setOnClickListener(this);
        button=findViewById(R.id.unregisterBotton);
        button.setOnClickListener(this);
        button=findViewById(R.id.bindServer);
        button.setOnClickListener(this);
        button=findViewById(R.id.startactivity);
        button.setOnClickListener(this);
    }

    private void unregisterCallback(){
        if(remoteServer != null){
            try {
                remoteServer.unregister(callback);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            Log.e(TAG," null remoteServer");
        }
    }

    private void callServer(String msg){
        if(remoteServer != null){
            try {
                remoteServer.callServer(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            Log.e(TAG," null remoteServer");
        }
    }

    public void bindServer(){
        Intent serverIntent = new Intent();
        // 这里通过包名和class名来Bindservice。
        serverIntent.setComponent(new ComponentName("com.callback.server","com.callback.server.callbackserver"));
        bindService(serverIntent,serviceConnection,Context.BIND_AUTO_CREATE);
    }

    private void startActivity(){
        Intent intent = new Intent(ActivityA.this,ActivityB.class);
        startActivity(intent);
    }

    public void registerCallback() {
        if(remoteServer != null){
            try {
                remoteServer.register(callback);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        } else {
            Log.e(TAG," null remoteServer");
        }
    }

    // Activity 实现了 View.OnClickListener 的话，需要实现对应的接口 onClick
    @Override
    public void onClick(View view) {
        int id = view.getId();
        switch (id){
            case R.id.registerBotton:
                registerCallback();
                break;
            case R.id.unregisterBotton:
                unregisterCallback();
                break;
            case R.id.bindServer:
                bindServer();
                break;
            case R.id.startactivity:
                startActivity();
                break;
        }
    }
}
```
ActivityA对应的资源文件 activity_main.xml
```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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"
    tools:context=".ActivityA">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/registerBotton"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        android:text="register"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/unregisterBotton"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/registerBotton"
        app:layout_constraintLeft_toLeftOf="parent"
        android:text="unregister"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/bindServer"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/unregisterBotton"
        app:layout_constraintLeft_toLeftOf="parent"
        android:text="Bind server"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/startactivity"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/bindServer"
        app:layout_constraintLeft_toLeftOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>
```
ActivityB 的实现和 ActivityA基本一致。
客户端的文件结构如下
```bash
C:.
├─aidl
│  └─com
│      └─callback
│              ICallbackTestCallback.aidl
│              ICallBackTestInterface.aidl
├─java
│  └─com
│      └─callback
│          └─client
│                  ActivityA.java
│                  ActivityB.java
└─res
    ├─drawable
    ├─drawable-v24
    ├─layout
    │      activity_main.xml
    ├─mipmap-anydpi-v26
    ├─mipmap-hdpi
    ├─mipmap-mdpi
    ├─mipmap-xhdpi
    ├─mipmap-xxhdpi
    ├─mipmap-xxxhdpi
    ├─values
    └─values-night
```
然后我们可以得到这样一个应用
{% asset_img 1.png %}
上面有4个按钮，分别用来向服务端注册和注销自己，绑定服务端，和打开另外一个Activity。

# 使用
在分屏模式下可以同时打开两个Activity，分别点击两个Activity内的bind server和register。就可以在logcat内看到对应的内容了
{% asset_img 2.png %}
```bash
05-08 12:48:45.938  6671  6671 D testcallback: callback test server create
05-08 12:48:45.940  6671  6687 D testcallback: register callback from pid=6631
05-08 12:48:46.439  6631  6653 D testcallback: received msg: 0 . from server pid=6671
05-08 12:48:46.940  6631  6653 D testcallback: received msg: 1 . from server pid=6671
05-08 12:48:47.441  6631  6653 D testcallback: received msg: 2 . from server pid=6671
05-08 12:48:47.944  6631  6653 D testcallback: received msg: 3 . from server pid=6671
05-08 12:48:48.409  6671  6687 D testcallback: register callback from pid=6597
05-08 12:48:48.445  6597  6614 D testcallback: received msg: 4 . from server pid=6671
05-08 12:48:48.446  6631  6648 D testcallback: received msg: 4 . from server pid=6671
05-08 12:48:48.948  6597  6614 D testcallback: received msg: 5 . from server pid=6671
05-08 12:48:48.949  6631  6648 D testcallback: received msg: 5 . from server pid=6671
05-08 12:48:49.451  6597  6614 D testcallback: received msg: 6 . from server pid=6671
05-08 12:48:49.451  6631  6648 D testcallback: received msg: 6 . from server pid=6671
05-08 12:48:49.953  6597  6614 D testcallback: received msg: 7 . from server pid=6671
05-08 12:48:49.954  6631  6648 D testcallback: received msg: 7 . from server pid=6671
05-08 12:48:50.456  6597  6614 D testcallback: received msg: 8 . from server pid=6671
05-08 12:48:50.457  6631  6648 D testcallback: received msg: 8 . from server pid=6671
05-08 12:48:50.958  6597  6614 D testcallback: received msg: 9 . from server pid=6671
05-08 12:48:50.959  6631  6648 D testcallback: received msg: 9 . from server pid=6671
05-08 12:48:51.461  6597  6614 D testcallback: received msg: 10 . from server pid=6671
05-08 12:48:51.461  6631  6648 D testcallback: received msg: 10 . from server pid=6671
05-08 12:48:51.964  6597  6614 D testcallback: received msg: 11 . from server pid=6671
05-08 12:48:51.964  6631  6648 D testcallback: received msg: 11 . from server pid=6671
05-08 12:48:52.465  6597  6614 D testcallback: received msg: 12 . from server pid=6671
05-08 12:48:52.466  6631  6648 D testcallback: received msg: 12 . from server pid=6671
05-08 12:48:52.967  6597  6614 D testcallback: received msg: 13 . from server pid=6671
05-08 12:48:52.967  6631  6648 D testcallback: received msg: 13 . from server pid=6671
05-08 12:48:53.469  6597  6614 D testcallback: received msg: 14 . from server pid=6671
05-08 12:48:53.470  6631  6648 D testcallback: received msg: 14 . from server pid=6671
05-08 12:48:53.972  6597  6614 D testcallback: received msg: 15 . from server pid=6671
05-08 12:48:53.972  6631  6648 D testcallback: received msg: 15 . from server pid=6671
05-08 12:48:54.474  6597  6614 D testcallback: received msg: 16 . from server pid=6671
05-08 12:48:54.475  6631  6648 D testcallback: received msg: 16 . from server pid=6671
05-08 12:48:54.977  6597  6614 D testcallback: received msg: 17 . from server pid=6671
05-08 12:48:54.977  6631  6648 D testcallback: received msg: 17 . from server pid=6671
05-08 12:48:55.478  6597  6614 D testcallback: received msg: 18 . from server pid=6671
05-08 12:48:55.479  6631  6648 D testcallback: received msg: 18 . from server pid=6671
05-08 12:48:55.981  6597  6614 D testcallback: received msg: 19 . from server pid=6671
05-08 12:48:55.982  6631  6648 D testcallback: received msg: 19 . from server pid=6671
05-08 12:48:56.484  6597  6614 D testcallback: received msg: 20 . from server pid=6671
05-08 12:48:56.484  6631  6648 D testcallback: received msg: 20 . from server pid=6671
05-08 12:48:56.987  6597  6614 D testcallback: received msg: 21 . from server pid=6671
05-08 12:48:56.987  6631  6648 D testcallback: received msg: 21 . from server pid=6671
05-08 12:48:57.489  6597  6614 D testcallback: received msg: 22 . from server pid=6671
05-08 12:48:57.489  6631  6648 D testcallback: received msg: 22 . from server pid=6671
05-08 12:48:57.992  6597  6614 D testcallback: received msg: 23 . from server pid=6671
05-08 12:48:57.992  6631  6648 D testcallback: received msg: 23 . from server pid=6671
05-08 12:48:58.494  6597  6614 D testcallback: received msg: 24 . from server pid=6671
05-08 12:48:58.495  6631  6648 D testcallback: received msg: 24 . from server pid=6671
05-08 12:48:58.997  6597  6614 D testcallback: received msg: 25 . from server pid=6671
05-08 12:48:58.998  6631  6648 D testcallback: received msg: 25 . from server pid=6671
05-08 12:48:59.501  6597  6614 D testcallback: received msg: 26 . from server pid=6671
05-08 12:48:59.501  6631  6648 D testcallback: received msg: 26 . from server pid=6671
05-08 12:49:00.003  6597  6614 D testcallback: received msg: 27 . from server pid=6671
05-08 12:49:00.004  6631  6648 D testcallback: received msg: 27 . from server pid=6671
05-08 12:49:00.506  6597  6614 D testcallback: received msg: 28 . from server pid=6671
05-08 12:49:00.506  6631  6648 D testcallback: received msg: 28 . from server pid=6671
05-08 12:49:01.009  6597  6614 D testcallback: received msg: 29 . from server pid=6671
05-08 12:49:01.010  6631  6648 D testcallback: received msg: 29 . from server pid=6671
05-08 12:49:01.511  6597  6614 D testcallback: received msg: 30 . from server pid=6671
05-08 12:49:01.512  6631  6648 D testcallback: received msg: 30 . from server pid=6671
05-08 12:49:02.014  6597  6614 D testcallback: received msg: 31 . from server pid=6671
05-08 12:49:02.014  6631  6648 D testcallback: received msg: 31 . from server pid=6671
05-08 12:49:02.517  6597  6614 D testcallback: received msg: 32 . from server pid=6671
05-08 12:49:02.517  6631  6648 D testcallback: received msg: 32 . from server pid=6671
05-08 12:49:03.019  6597  6614 D testcallback: received msg: 33 . from server pid=6671
05-08 12:49:03.019  6631  6648 D testcallback: received msg: 33 . from server pid=6671
05-08 12:49:03.521  6597  6614 D testcallback: received msg: 34 . from server pid=6671
05-08 12:49:03.522  6631  6648 D testcallback: received msg: 34 . from server pid=6671
05-08 12:49:04.024  6597  6614 D testcallback: received msg: 35 . from server pid=6671
05-08 12:49:04.024  6631  6648 D testcallback: received msg: 35 . from server pid=6671
05-08 12:49:04.527  6597  6614 D testcallback: received msg: 36 . from server pid=6671
05-08 12:49:04.527  6631  6648 D testcallback: received msg: 36 . from server pid=6671
05-08 12:49:05.030  6597  6614 D testcallback: received msg: 37 . from server pid=6671
05-08 12:49:05.030  6631  6648 D testcallback: received msg: 37 . from server pid=6671
05-08 12:49:05.329  6671  6687 D testcallback: unregister callback from pid=6597
05-08 12:49:05.533  6631  6648 D testcallback: received msg: 38 . from server pid=6671
05-08 12:49:06.034  6631  6648 D testcallback: received msg: 39 . from server pid=6671
05-08 12:49:06.537  6631  6648 D testcallback: received msg: 40 . from server pid=6671
05-08 12:49:07.039  6631  6648 D testcallback: received msg: 41 . from server pid=6671
05-08 12:49:07.542  6631  6648 D testcallback: received msg: 42 . from server pid=6671
05-08 12:49:08.043  6631  6648 D testcallback: received msg: 43 . from server pid=6671
05-08 12:49:08.545  6631  6648 D testcallback: received msg: 44 . from server pid=6671
05-08 12:49:09.046  6631  6648 D testcallback: received msg: 45 . from server pid=6671
05-08 12:49:09.548  6631  6648 D testcallback: received msg: 46 . from server pid=6671
05-08 12:49:10.051  6631  6648 D testcallback: received msg: 47 . from server pid=6671
05-08 12:49:10.513  6671  6687 D testcallback: unregister callback from pid=6631
05-08 12:49:14.176  6671  6687 D testcallback: unregister callback from pid=6631
05-08 12:49:14.896  6671  6687 D testcallback: unregister callback from pid=6597
```]]></content>
      <tags>
        <tag>Android</tag>
      </tags>
  </entry>
  <entry>
    <title>安卓 RemoteCallbackList 的使用 （系统服务篇）</title>
    <url>/2024/08/03/usage-of-Android-RemoteCallbacckList-framework/</url>
    <content><![CDATA[
接着[应用篇](../usage-of-Android-RemoteCallbacckList-APP/)继续说，这次我们在系统服务里面使用 RemoteCallbackList 。
首先，你需要有一份能完整编译的安卓源码。

<!-- more -->

我这里以 Android10_r47为例。
我在 `frameworks/base/core/java/com/callback/` 内新增这几个文件。

1. 服务接口的 aidl
```java
// ICallBackTestInterface.aidl
package com.callback;

// Declare any non-default types here with import statements

import com.callback.ICallbackTestCallback;

interface ICallBackTestInterface {
    // 向服务端注册客户端回调
    void register(ICallbackTestCallback callback);
    // 向服务端注销客户端回调
    void unregister(ICallbackTestCallback callback);
    // 向服务端发送消息
    void callServer(String msg);
}
```
1. 服务回调的 aidl
```java
// ICallbackTestCallback.aidl
package com.callback;

// Declare any non-default types here with import statements

interface ICallbackTestCallback {
    /**
     * 服务端调用客户端的回调
     **/
    void onReceived(String msg);
}
```
aidl 的文件会自动编译成Binder对象的子类，这个编译系统已经为我们做好了
3. 服务端实现
然后，`frameworks/base/services/core/java/com/android/server/CallBackTestService.java`。在这里新建一个文件，用来作为服务端的真正实现
```java
package com.android.server;

import android.util.Slog;

import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.os.Binder;
import android.os.IBinder;

import com.callback.ICallbackTestCallback;
import com.callback.ICallBackTestInterface;

public class CallBackTestService extends ICallBackTestInterface.Stub {

    private final String TAG = "testcallback";

    private boolean serverRunning = false;

    private final RemoteCallbackList<ICallbackTestCallback> clients = new RemoteCallbackList<>();

    public CallBackTestService(){
        serverRunning = true;
        new Thread(serverRunnable).start();
    }

    public void register(ICallbackTestCallback callback) throws RemoteException {
        Slog.d(TAG,"register callback from pid=" + Binder.getCallingPid());
        clients.register(callback);
    }

    public void unregister(ICallbackTestCallback callback) throws RemoteException {
        Slog.d(TAG,"unregister callback from pid=" + Binder.getCallingPid());
        clients.unregister(callback);
    }

    public void callServer(String msg) throws RemoteException {
        Slog.d(TAG,"received pid=" + Binder.getCallingPid()+" message: " + msg);
    }

    // 向客户端发送消息的具体实现
    // 简单的做一个自增运算，然后发送回客户端
    // 
    private Runnable serverRunnable = () ->{
        int count = 0;
        while(serverRunning){
            try {
                Thread.sleep(500);
                noteClients(Integer.toString(count++));
                count = count > 10000 ? 0 : count;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };

    /**
     * 
     * @param msg 
     */
    private void noteClients(String msg){
        int cb = clients.beginBroadcast();
        for(int i=0;i<cb;i++){
            try {
               clients.getBroadcastItem(i).onReceived(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        clients.finishBroadcast();
    }
}
```
这里服务端的实现，实际上就和上一篇中的 CallBackServer 是一个意思。
然后封装一下服务的调用 `frameworks/base/core/java/com/callback/CallBackTestManager.java`
```java
package com.callback;

import android.util.Slog;

import android.content.Context;
import android.os.RemoteException;

import android.annotation.UnsupportedAppUsage;

import com.callback.ICallbackTestCallback;
import com.callback.ICallBackTestInterface;

public class CallBackTestManager {

    public static final String SERVICE_NAME = "callbacktest";

    private final Context mContext;

    private final ICallBackTestInterface mService;

    public CallBackTestManager(Context context, ICallBackTestInterface service){
        mContext = context;
        mService = service;
    }

    public void register(ICallbackTestCallback callback) {
        try{
            mService.register(callback);
        } catch (RemoteException e){
            throw e.rethrowFromSystemServer();
        }
    }

    public void unregister(ICallbackTestCallback callback) {
        try{
            mService.unregister(callback);
        } catch (RemoteException e){
            throw e.rethrowFromSystemServer();
        }
    }

    public void callserver(String msg) {
        try{
            mService.callServer(msg);
        } catch (RemoteException e){
            throw e.rethrowFromSystemServer();
        }
    }
}
```

到这里，我们的大部分工作就完成了。不过此时编译成系统镜像烧录或者编译成虚拟机，还是不能调用这个服务的。
由于我们添加的类位于 frameworks/base/com 这个目录下，这个目录下的包并不在 bootclass 里面，修改一下这个文件
```diff
diff --git a/build/make/core/tasks/check_boot_jars/package_whitelist.txt b/build/make/core/tasks/check_boot_jars/package_whitelist.txt
index 38f2be57af..883b6d86ff 100644
--- a/build/make/core/tasks/check_boot_jars/package_whitelist.txt
+++ b/build/make/core/tasks/check_boot_jars/package_whitelist.txt
@@ -237,6 +237,7 @@ org\.apache\.xalan\.xslt
 # Packages in the google namespace across all bootclasspath jars.
 com\.google\.android\..*
 com\.google\.vr\.platform.*
+com\.callback\.*

 ###################################################
 # Packages used for Android in Chrome OS
```
首先会遇到的问题是 selinux 的限制，
按照下面的这个 diff 文件来添加关于这个新增加的服务的规则
```diff
diff --git a/system/sepolicy/prebuilts/api/29.0/private/service.te b/system/sepolicy/prebuilts/api/29.0/private/service.te
index a8ee195590..7d9a2452fa 100644
--- a/system/sepolicy/prebuilts/api/29.0/private/service.te
+++ b/system/sepolicy/prebuilts/api/29.0/private/service.te
@@ -5,3 +5,4 @@ type gsi_service,                   service_manager_type;
 type incidentcompanion_service,     system_api_service, system_server_service, service_manager_type;
 type stats_service,                 service_manager_type;
 type statscompanion_service,        system_server_service, service_manager_type;
+type callbacktest_service,     system_api_service, system_server_service, service_manager_type;
diff --git a/system/sepolicy/prebuilts/api/29.0/private/service_contexts b/system/sepolicy/prebuilts/api/29.0/private/service_contexts
index 96d553bf49..9067330ae5 100644
--- a/system/sepolicy/prebuilts/api/29.0/private/service_contexts
+++ b/system/sepolicy/prebuilts/api/29.0/private/service_contexts
@@ -220,3 +220,4 @@ wifiaware                                 u:object_r:wifiaware_service:s0
 wifirtt                                   u:object_r:rttmanager_service:s0
 window                                    u:object_r:window_service:s0
 *                                         u:object_r:default_android_service:s0
+callbacktest                              u:object_r:callbacktest_service:s0
diff --git a/system/sepolicy/prebuilts/api/29.0/private/untrusted_app_all.te b/system/sepolicy/prebuilts/api/29.0/private/untrusted_app_all.te
index 3c20c082b7..d8e2fac17d 100644
--- a/system/sepolicy/prebuilts/api/29.0/private/untrusted_app_all.te
+++ b/system/sepolicy/prebuilts/api/29.0/private/untrusted_app_all.te
@@ -100,6 +100,7 @@ allow untrusted_app_all radio_service:service_manager find;
 allow untrusted_app_all app_api_service:service_manager find;
 allow untrusted_app_all vr_manager_service:service_manager find;
 allow untrusted_app_all gpu_service:service_manager find;
+allow untrusted_app_all callbacktest_service:service_manager find;

 # Allow untrusted apps to interact with gpuservice
 binder_call(untrusted_app_all, gpuservice)
diff --git a/system/sepolicy/private/service.te b/system/sepolicy/private/service.te
index a8ee195590..7d9a2452fa 100644
--- a/system/sepolicy/private/service.te
+++ b/system/sepolicy/private/service.te
@@ -5,3 +5,4 @@ type gsi_service,                   service_manager_type;
 type incidentcompanion_service,     system_api_service, system_server_service, service_manager_type;
 type stats_service,                 service_manager_type;
 type statscompanion_service,        system_server_service, service_manager_type;
+type callbacktest_service,     system_api_service, system_server_service, service_manager_type;
diff --git a/system/sepolicy/private/service_contexts b/system/sepolicy/private/service_contexts
index 96d553bf49..9067330ae5 100644
--- a/system/sepolicy/private/service_contexts
+++ b/system/sepolicy/private/service_contexts
@@ -220,3 +220,4 @@ wifiaware                                 u:object_r:wifiaware_service:s0
 wifirtt                                   u:object_r:rttmanager_service:s0
 window                                    u:object_r:window_service:s0
 *                                         u:object_r:default_android_service:s0
+callbacktest                              u:object_r:callbacktest_service:s0
diff --git a/system/sepolicy/private/untrusted_app_all.te b/system/sepolicy/private/untrusted_app_all.te
index 3c20c082b7..d8e2fac17d 100644
--- a/system/sepolicy/private/untrusted_app_all.te
+++ b/system/sepolicy/private/untrusted_app_all.te
@@ -100,6 +100,7 @@ allow untrusted_app_all radio_service:service_manager find;
 allow untrusted_app_all app_api_service:service_manager find;
 allow untrusted_app_all vr_manager_service:service_manager find;
 allow untrusted_app_all gpu_service:service_manager find;
+allow untrusted_app_all callbacktest_service:service_manager find;

 # Allow untrusted apps to interact with gpuservice
 binder_call(untrusted_app_all, gpuservice)
```
到这里之后，回到Android源码根目录，正常 `make update-api && make` 之后，就可以启动虚拟机了。
然后再新建一个应用。
```bash
.
├── aidl
│   └── com
│       └── callback
│           ├── ICallbackTestCallback.aidl
│           └── ICallBackTestInterface.aidl
├── AndroidManifest.xml
├── java
│   └── com
│       └── callback
│           ├── CallBackTestManager.java
│           └── demo
│               └── MainActivity.java

```
其中，`ICallbackTestCallback.aidl` , `ICallBackTestInterface.aidl` , `CallBackTestManager.java` 三个文件都是从我们添加在源码里面的拷贝出来的，因为Android Studio的sdk里面并没有这些实现，把这些文件放到工程的目录里面，让编译可以通过。
通过 java 的类加载机制，实际上运行的时候是编译到系统里启动的那些代码，实际上我们拷贝到工程里的文件，只要接口声明与系统内的一致就可以，接口实现可以留空。就像Android SDK 里面的andrroid.jar里面的那些空接口一样。

MainActivity.java的内容如下
```java
package com.callback.demo;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.Bundle;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;

import com.callback.ICallbackTestCallback;
import com.callback.CallBackTestManager;
import com.testcallback.demo.R;

public class MainActivity extends AppCompatActivity {

    private final String TAG = "testcallback";

    CallBackTestManager callbackSerice = null;

    private boolean bound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onResume() {
        super.onResume();
        if(bound){
            registerCallback(null);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if(bound){
            unregisterCallback(null);
        }
    }

    private ICallbackTestCallback callback = new ICallbackTestCallback.Stub(){
        @Override
        public void onReceived(String msg) throws RemoteException {
            Log.d(TAG,"received msg: " + msg + " . from server pid=" + Binder.getCallingPid());
        }
    };

    public void registerCallback(View view) {
        if(callbackSerice!=null){
            callbackSerice.register(callback);
        }
    }

    public void unregisterCallback(View view) {
        if(callbackSerice!=null){
            callbackSerice.unregister(callback);
        }
    }

    public void bindService(View view) {
        if(callbackSerice == null){
            callbackSerice = (CallBackTestManager)getSystemService(CallBackTestManager.SERVICE_NAME);
            bound = true;
        }
    }

    public void notifyService(View view) {
        if(callbackSerice!=null){
            callbackSerice.callserver("hello, I'm client");
        }
    }

}
```
对应的资源文件如下
```xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/registerBotton"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        android:onClick="registerCallback"
        android:text="register"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/unregisterBotton"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/registerBotton"
        app:layout_constraintLeft_toLeftOf="parent"
        android:onClick="unregisterCallback"
        android:text="unregister"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/bindservice"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/unregisterBotton"
        app:layout_constraintLeft_toLeftOf="parent"
        android:onClick="bindService"
        android:text="Bind service"/>

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/notifyservice"
        android:textAllCaps="false"
        android:layout_marginLeft="5dp"
        app:layout_constraintTop_toBottomOf="@id/bindservice"
        app:layout_constraintLeft_toLeftOf="parent"
        android:onClick="notifyService"
        android:text="Notify service"/>
```
编译完成之后，我们将apk用AOSP的系统签名（如果你用了自己的密钥，就是你自己密钥的platform签名），AOSP的签名位于`build/target/product/security/`,其内的 platform.pk8 和 platform.x509.pem 。用这两个签名给apk签名安装。这个apk需要注意声明 systemuid。
p.s: 这里使用系统签名，是因为按照本篇的流程，添加后的 CallBackTestManager 是 hide 的接口，Android 10 对hide接口做了限制，普通app直接去调的话，会报找不到接口。对于安卓10新增的hidden api 调用限制，可以前往 https://developer.android.google.cn/guide/app-compatibility/restrictions-non-sdk-interfaces 。普通应用直接调用hide的接口，可能会直接闪退，查看log，有类似下面这样的log生成
```
Accessing hidden field Landroid/os/Message;->flags:I (light greylist, JNI)
```
# 把我们新增的接口变成public的接口
这一部分，你可以理解为将我们自行增加的接口变成 SDK 接口（如果你的ROM需要通过谷歌的CTS认证，则不可以将自行增加的API变成SDK API）。
如果你有留意，在 make update-api 之后，`android10_r47/frameworks/base/api/current.txt`，会出现新增的一些和aidl文件有关的内容
```java
package com.callback {

  public interface ICallBackTestInterface extends android.os.IInterface {
    method public void callServer(String) throws android.os.RemoteException;
    method public void register(com.callback.ICallbackTestCallback) throws android.os.RemoteException;
    method public void unregister(com.callback.ICallbackTestCallback) throws android.os.RemoteException;
  }

  public static class ICallBackTestInterface.Default implements com.callback.ICallBackTestInterface {
    ctor public ICallBackTestInterface.Default();
    method public android.os.IBinder asBinder();
    method public void callServer(String) throws android.os.RemoteException;
    method public void register(com.callback.ICallbackTestCallback) throws android.os.RemoteException;
    method public void unregister(com.callback.ICallbackTestCallback) throws android.os.RemoteException;
  }

  public abstract static class ICallBackTestInterface.Stub extends android.os.Binder implements com.callback.ICallBackTestInterface {
    ctor public ICallBackTestInterface.Stub();
    method public android.os.IBinder asBinder();
    method public static com.callback.ICallBackTestInterface asInterface(android.os.IBinder);
    method public static com.callback.ICallBackTestInterface getDefaultImpl();
    method public boolean onTransact(int, android.os.Parcel, android.os.Parcel, int) throws android.os.RemoteException;
    method public static boolean setDefaultImpl(com.callback.ICallBackTestInterface);
  }

  public interface ICallbackTestCallback extends android.os.IInterface {
    method public void onReceived(String) throws android.os.RemoteException;
  }

  public static class ICallbackTestCallback.Default implements com.callback.ICallbackTestCallback {
    ctor public ICallbackTestCallback.Default();
    method public android.os.IBinder asBinder();
    method public void onReceived(String) throws android.os.RemoteException;
  }
  public abstract static class ICallbackTestCallback.Stub extends android.os.Binder implements com.callback.ICallbackTestCallback {
    ctor public ICallbackTestCallback.Stub();
    method public android.os.IBinder asBinder();
    method public static com.callback.ICallbackTestCallback asInterface(android.os.IBinder);
    method public static com.callback.ICallbackTestCallback getDefaultImpl();
    method public boolean onTransact(int, android.os.Parcel, android.os.Parcel, int) throws android.os.RemoteException;
    method public static boolean setDefaultImpl(com.callback.ICallbackTestCallback);
  }
}
```
某种程度上，你可以认为，这个txt的内容就是SDK api，可以看到，我们新增的 CallBackTestManager 的内容并不在这个txt里面。
可以通过修改 `frameworks/base/Android.bp` 这个文件，修改内容如下
```diff
diff --git a/frameworks/base/Android.bp b/frameworks/base/Android.bp
index 663354835e..03a98395e5 100644
--- a/frameworks/base/Android.bp
+++ b/frameworks/base/Android.bp
@@ -1237,6 +1237,7 @@ packages_to_document = [
     "javax/microedition/khronos",
     "org/apache/http/conn",
     "org/apache/http/params",
+    "com/callback",
 ]

 // Make the api/current.txt file available for use by modules in other
```
修改这个文件之后，再次 `make update-api`，可以看到 CallBackTestManager 的内容已经添加到 current.txt 里面去了。
再次make之后，普通应用就可以像调用安卓已有的服务那样，来使用新增的这个服务了。
# 复习一下
有几个小地方需要注意：
1. 如果你添加的接口没有出现在 current.txt 里面的话，安卓10上由于谷歌新增的hidden api访问限制，普通应用是无法访问的
2. 使用AOSP 编译出来的 signapk.jar 和 platform 签名的apk，似乎无法在虚拟机上安装为系统应用，我是把 platform key 转换成 Android Studio 使用的 keystore 来使用的。]]></content>
      <tags>
        <tag>Android</tag>
      </tags>
  </entry>
  <entry>
    <title>C语言调用系统命令</title>
    <url>/2017/09/14/use-cmd-coomand-in-cpp/</url>
    <content><![CDATA[{% asset_img 1.jpg %}
<!-- more -->


> 把命令当作一个字符串作为system函数的参数就行了

### 示例
```C++
include<stdlib.h>
int main ()
{
	char cmd[]={"echo Hello shell"}
	system(cmd);
	return 0;
}
```

### 实用示范
依据这个思路，写了个[小东西](https://github.com/BDZNH/download-www.icourse163.org),到中国大学mooc官网复制课程链接到[http://tools.antlm.com/](http://tools.antlm.com/)，然后复制批量改名用链接，粘贴到"download_link.txt",并与"Downloadmanager.exe"和"aria2c.exe"放到同一个文件夹，双击"Downloadmanager.exe"，就可以开始下载了。
很简单的一个小东西，读取download_link.txt的内容，分离下载链接和文件名，将其作为下载器aria2c.exe的参数，调用aria2c，就OK啦。
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>在Ubuntu中使用IPv6</title>
    <url>/2017/03/16/use-ipv6-on-Ubuntu/</url>
    <content><![CDATA[我的电脑上装了Ubuntu 14.04 LTS 系统，学校的校园网需要拨号才能使用，并且在拨号之后获得IPv6地址。
但是实际上，我在Windows上可以正常使用IPv6地址，但是在Ubuntu上无法使用，问了度娘之后，总结解决办法如下:
更改文件`/etc/sysctl.d/10-ipv6-privacy.conf`

<!-- more -->

```bash
# IPv6 Privacy Extensions (RFC 4941)
# ---
# IPv6 typically uses a device's MAC address when choosing an IPv6 address
# to use in autoconfiguration. Privacy extensions allow using a randomly
# generated IPv6 address, which increases privacy.
#
# Acceptable values:
#    0 - don’t use privacy extensions.
#    1 - generate privacy addresses
#    2 - prefer privacy addresses and use them over the normal addresses.
net.ipv6.conf.all.use_tempaddr = 2
net.ipv6.conf.default.use_tempaddr = 2
```
为
```bash
# IPv6 Privacy Extensions (RFC 4941)
# ---
# IPv6 typically uses a device's MAC address when choosing an IPv6 address
# to use in autoconfiguration. Privacy extensions allow using a randomly
# generated IPv6 address, which increases privacy.
#
# Acceptable values:
#    0 - don’t use privacy extensions.
#    1 - generate privacy addresses
#    2 - prefer privacy addresses and use them over the normal addresses.
net.ipv6.conf.all.use_tempaddr = 2
net.ipv6.conf.default.use_tempaddr = 0
```
然后重新拨号之后，就可以正常使用IPv6了。
对于校园网不支持IPv6或者获取方式不一样的小伙伴，此方法不一定适用。
使用命令`ifconfig`可查看网络连接信息:
```bash
eth0      Link encap:Ethernet  HWaddr 50:7b:9d:03:61:aa  
          inet6 addr: fe80::527b:9dff:fe03:61aa/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:506 errors:0 dropped:1 overruns:0 frame:0
          TX packets:103 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:48325 (48.3 KB)  TX bytes:14006 (14.0 KB)
          Interrupt:20 Memory:f1200000-f1220000 

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:226 errors:0 dropped:0 overruns:0 frame:0
          TX packets:226 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1 
          RX bytes:20694 (20.6 KB)  TX bytes:20694 (20.6 KB)

ppp0      Link encap:Point-to-Point Protocol  
          inet addr:10.170.15.47  P-t-P:10.170.72.254  Mask:255.255.255.255
          inet6 addr: fe80::2a:e1b3:3273:b894/10 Scope:Link
          inet6 addr: 2001:250:1006:dff0:2a:e1b3:3273:b894/64 Scope:Global
          UP POINTOPOINT RUNNING NOARP MULTICAST  MTU:1492  Metric:1
          RX packets:42 errors:0 dropped:0 overruns:0 frame:0
          TX packets:47 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:3 
          RX bytes:3793 (3.7 KB)  TX bytes:3373 (3.3 KB)

wlan0     Link encap:Ethernet  HWaddr 94:65:9c:4e:02:dc  
          inet addr:192.168.0.108  Bcast:192.168.0.255  Mask:255.255.255.0
          inet6 addr: fe80::9665:9cff:fe4e:2dc/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:24275 errors:0 dropped:0 overruns:0 frame:0
          TX packets:8251 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:35338441 (35.3 MB)  TX bytes:845841 (845.8 KB)
```
上一张成品图
{% asset_img lala.png 在Ubuntu中使用IPv6 %}

参考文章:[http://www.cnblogs.com/makefile/p/5040615.html](http://www.cnblogs.com/makefile/p/5040615.html)
{% cq %}生命重在折腾{% endcq %}]]></content>
  </entry>
  <entry>
    <title>使用 openssl 进行 AES128/ECB/PKCS5Padding 加解密</title>
    <url>/2024/08/03/use-openssl-AES-ECB-PKCS5Padding-encrypt-decrypt/</url>
    <content><![CDATA[
在 java 上进行 AES128/ECB/PKCS5Padding 加密解密是很简单的

<!-- more -->

```java
    public static String aesDecrypt(String str,String key) throws Exception{
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(Base64.getDecoder().decode(key),"AES"));
        byte[] bytes = Base64.getDecoder().decode(str.getBytes(StandardCharsets.UTF_8));
        byte[] ret = cipher.doFinal(bytes);
        return new String(ret,"UTF-8");
    }

    public static String aesEncrypt(String str,String key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE,new SecretKeySpec(Base64.getDecoder().decode(key),"AES"));
        return Base64.getEncoder().encodeToString(cipher.doFinal(str.getBytes()));
    }
```
AES 加解密使用的key本身是 16 字节（128位），但是key可能不是ascii里的可见字符，有时候我们把 key 进行 base64 编码之后，当作明文传输使用。真正把 key 用来加密解密的时候，需要先 base64 解码来得到原本的 key。
同样的，经过AES加密的信息也有可能不是每一个字节都是ascii可见字符，我们同样将加密后的密文进行base64编码之后再展示。

同样的操作，用 C/C++ 进行就复杂得多，C/C++ 自己本身没有对应的库，不过好在有很多开源的实现，这里用 openssl 作为演示
```
#include <openssl/evp.h>
#include <vector>
std::string AES128ECBEncrypt(const std::string& base64key, const std::string& str)
{
    std::vector<unsigned char> key;
    if (!Base64Decode(base64key, key))
        return "";

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    int encLen = 0;
    int outlen = 0;
    size_t outsize = ((str.size() / 16)+1) * 16;
    std::vector<unsigned char> encData(outsize);

    EVP_CipherInit_ex(ctx, EVP_aes_128_ecb(), NULL, key.data(), NULL, 1);
    EVP_CipherUpdate(ctx, encData.data(), &outlen, (const unsigned char*)str.c_str(), (int)str.size());
    encLen = outlen;
    EVP_CipherFinal_ex(ctx, encData.data() + outlen, &outlen);
    encLen += outlen;
    EVP_CIPHER_CTX_free(ctx);
    return std::move(Base64Encode(encData.data(), encLen));
}

std::string AES128ECBDecrypt(const std::string& base64Key, const std::string& base64str)
{
    std::vector<unsigned char> buffer;
    if (!Base64Decode(base64str, buffer))
    {
        return "";
    }

    std::vector<unsigned char> key;
    if (!Base64Decode(base64Key, key))
    {
        return "";
    }

    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    int encLen = 0;
    int outlen = 0;

    BUFFER encData(buffer.size());

    EVP_CipherInit_ex(ctx, EVP_aes_128_ecb(), NULL, key.data(), NULL, 0);
    EVP_CipherUpdate(ctx, encData.data(), &outlen, buffer.data(), (int)buffer.size());
    encLen = outlen;
    EVP_CipherFinal(ctx, encData.data() + outlen, &outlen);
    encLen += outlen;
    EVP_CIPHER_CTX_free(ctx);
    return std::move(std::string((char*)encData.data(), encLen));
}
```]]></content>
      <tags>
        <tag>openssl</tag>
        <tag>AES</tag>
      </tags>
  </entry>
  <entry>
    <title>使用 openssl 进行 RSA/ECB/PKCS1PADDING 加解密</title>
    <url>/2024/07/30/use-openssl-RSA-ECB-PKCS1PADDING-to-encrypt-decrypt/</url>
    <content><![CDATA[
使用 `java` 进行 `RSA/ECB/PKCS1PADDING` 是非常方便的，例如下面的示例

<!-- more -->

```java
    public static String publicDecrypt(PublicKey publicKey,String encrypted) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] data = cipher.doFinal(Base64.getDecoder().decode(encrypted.getBytes(StandardCharsets.UTF_8)));
        return new String(data);
    }

    public static String publicEncrypt(PublicKey publicKey,String encrypted) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE,publicKey);
        byte[] data = cipher.doFinal(encrypted.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(data);
    }
    public static String privateEncrypt(PrivateKey privateKey,String toEncrypt) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        byte[] data = cipher.doFinal(toEncrypt.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(data);
    }

    public static String privateDecrypt(PrivateKey privateKey,String toEncrypt) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        byte[] data = cipher.doFinal(Base64.getDecoder().decode(toEncrypt.getBytes(StandardCharsets.UTF_8)));
        return new String(data);
    }
```
公钥加密的内容用私钥解密，私钥加密的内容用公钥解密。（严格来说，私钥加密的另外一种名称是“签名”）
使用 C/C++ 来实现的时候，没有java那么方便，下面是低版本openssl api的调用示范
```cpp
#include<openssl/pem.h>
#include<openssl/rsa.h>
#include<openssl/bio.h>
...
    BIO* keybio = BIO_new_mem_buf(key.c_str(), (int)key.size());
    if (!keybio)
    {
        spdlog::error("new bio failed");
        return ;
    }
    RSA* rsa = PEM_read_bio_RSAPrivateKey(keybio, NULL, NULL, NULL);
    if (!rsa)
    {
        return ;
    }
    spdlog::info("rsa: {} ", fmt::ptr(rsa));
    uint8_t buffer[2048];
    int ret = RSA_private_encrypt((int)plaintext.size(), (const unsigned char*)plaintext.c_str(), buffer, rsa, RSA_PKCS1_PADDING);
    if (ret > 0)
    {
        std::string result = Base64Encode(buffer, ret);
        spdlog::info("encrypted:\n{}", result);
    }
    RSA_free(rsa);
...
```
其中，key是 pem 格式的字符串。上面的内容是使用私钥进行加密的例子。
大致的流程是使用 pem 格式的密钥，创建BIO对象，使用BIO对象创建密钥对象，使用密钥对象进行加密或者解密。
相应的，我们可以总结出以下内容
 - 私钥加密 PEM_read_bio_RSAPrivateKey,RSA_private_encrypt
 - 私钥解密 PEM_read_bio_RSAPrivateKey,RSA_private_decrypt
 - 公钥加密 PEM_read_bio_RSAPublicKey, RSA_public_encrypt
 - 公钥解密 PEM_read_bio_RSAPublicKey, RSA_public_decrypt

以上4种接口在低版本的 openssl 上使用是没有问题的，但是在 openssl 3.0 齐，以上接口标记为弃用状态了。
下面是高版本 openssl 使用公钥解密的例子
```cpp
#include<openssl/pem.h>
#include<openssl/rsa.h>
#include<openssl/bio.h>
#include<openssl/evp.h>
#include<memory>
...
    const unsigned char* in;
    size_t inlen;
    std::string pemKey;
    //这里假设我们通过一系列操作得到了要加密的内容和pem格式的密钥....
    std::vector<unsigned char> out;
    int ret = 0;
    std::shared_ptr<BIO> keybio(BIO_new_mem_buf(pemKey.c_str(), (int)pemKey.size()), BIO_free);
    std::shared_ptr<EVP_PKEY> key(PEM_read_bio_PUBKEY(keybio.get(), nullptr, nullptr, nullptr), EVP_PKEY_free);
    std::shared_ptr<EVP_PKEY_CTX> ctx(EVP_PKEY_CTX_new(key.get(), nullptr), EVP_PKEY_CTX_free);
    EVP_PKEY_encrypt_init(ctx.get());
    EVP_PKEY_CTX_set_rsa_padding(ctx.get(), RSA_PKCS1_PADDING);
    size_t outlen = 0;
    ret = EVP_PKEY_encrypt(ctx.get(), nullptr, &outlen, in, inlen);
    out.resize(outlen);
    ret = EVP_PKEY_encrypt(ctx.get(), out.data(), &outlen, in, inlen);
```
大致步骤如下
1. 通过pem格式的密钥创建一个BIO对象 BIO_new_mem_buf
2. 通过BIO对象创建一个EVP_PKEY对象 PEM_read_bio_PUBKEY
3. 通过EVP_PKEY创建一个EVP_PKEY_CTX对象 EVP_PKEY_CTX_new
4. 通过EVP_PKEY_encrypt_init声明需要进行公钥加密
5. 通过EVP_PKEY_encrypt进行加密操作

高版本 openssl 的接口替换如下
 - 私钥加密 PEM_read_bio_PrivateKey, EVP_PKEY_CTX_new, EVP_PKEY_sign_init, EVP_PKEY_sign
 - 私钥解密 PEM_read_bio_PrivateKey, EVP_PKEY_CTX_new, EVP_PKEY_decrypt_init, EVP_PKEY_decrypt
 - 公钥加密 PEM_read_bio_PUBKEY, EVP_PKEY_CTX_new, EVP_PKEY_encrypt_init, EVP_PKEY_encrypt
 - 公钥解密 PEM_read_bio_PUBKEY, EVP_PKEY_CTX_new, EVP_PKEY_verify_recover_init, EVP_PKEY_verify_recover]]></content>
      <tags>
        <tag>openssl</tag>
        <tag>RSA</tag>
      </tags>
  </entry>
  <entry>
    <title>在Linux终端使用代理</title>
    <url>/2017/01/25/use-proxy-in-terminal/</url>
    <content><![CDATA[{% asset_img 1.jpg Fuck GFW %}
用linux的都能体会到，如果用国外的软件源，更新软件将是极其痛苦的事情————速度慢啊！
但是如果使用国内的软件源，如果某些软件国内软件源没有，还是会从国外的软件源下载，于是纠结了一下，使出下面的办法:
<!-- more -->
# 思路
即使clowwindy大神被请喝茶，他的项目仍然被持续更新。

用影梭能很方便的开启socks5代理，并且速度还不赖，于是朝着这个方向走。

更新软件，就要让'apt-get'走代理通道，而不是正常的http/https/ftp。

有了目标好办事，下面是具体实施步骤。


# 实战

劫持apt-get到socks5，我用了这个软件————Proxychains

## 安装Proxychains

使用root权限(其实只有第四个和第五个命令需要root权限)
```bash
$ git clone https://github.com/rofl0r/proxychains-ng.git
$ cd proxychains-ng
$ ./configure
$ make && make install
$ cp ./src/proxychains.conf /etc/proxychains.conf
$ cd .. && rm -rf proxychains-ng
```

然后，编辑`/etc/proxychains.conf`，到最后一行，把`socks4 127.0.0.1 9095`改成`socks5 127.0.0.1 1080`(注意: 这里如果直接注释掉该行，然后自己新添一行的话，需要注意缩进)
去掉49行`quiet_mode`前面的`#`号，这样运行的时候proxychains4就不会输出大量log了。

然后，启动Shadosocks后(它默认会开启一个本地1080的socks5端口)，在任意命令前面加上`proxychains4`，若有需要联网的操作，就会被自动劫持到socks5代理去，这样下载国外的资源速度会快一些。

## 示范
使用`proxychains4`更新软件源的一个小示范
{% asset_img demo.jpg 一个小示范 %}

# 一点点说明
虽然此类文章百度一搜一大把，但是还是要把我参考的原文贴出来[http://www.jianshu.com/p/8e7d7f57bf59](http://www.jianshu.com/p/8e7d7f57bf59),感谢原博主。

原文中提及好几种在终端使用代理的办法，我只取了一种，因为proxychains可以针对任何联网的软件，而不需要记住某些环境配置，一次配置，终身方便。

有一个大前提，就是你需要能`Fuck GFW`。

## 其他的玩法
将代码clone到本地之后，可以编辑项目目录里面的`src`文件夹内的`main.c`，把71行的`int quiet = 0;`改成`int quiet = 1;`，这样运行的时候就不会输出大量log了。

悠哉的一天>_<

{% cq %}生命重在折腾{% endcq %}
]]></content>
      <tags>
        <tag>Linux</tag>
      </tags>
  </entry>
  <entry>
    <title>启动jar文件时使用代理</title>
    <url>/2017/02/12/use-proxy-when-start-run-a-jar-file/</url>
    <content><![CDATA[{% asset_img 3.jpg %}
<!-- more -->
Minecraft用java编写，官方的启动器是一个jar文件，由于GFW横跨在出口网络上，所以启动官方启动器的时候总是连接不上登录服务器，离线的话又会遇到正版验证。解决此问题，启动官方启动器的时候，给它设置一个代理就好了。
```bash
$ java -DproxySet=true -DproxyHost=127.0.0.1 -DproxyPort=1080 -jar "C:\Program Files (x86)\Minecraft\game\launcher.jar"
```
`C:\Program Files (x86)\Minecraft\game\launcher.jar`是官方启动器默认的目录
此处本该有对比图，然而官方启动器就在我写这篇博客的时候更新了，所以此法并不适用于最新版本的官方启动器。
_记于2017.2.12 10:17_
{% asset_img 1.jpg %}
{% asset_img 2.jpg %}]]></content>
      <tags>
        <tag>java</tag>
      </tags>
  </entry>
  <entry>
    <title>使用 workflow 来中转 http 请求</title>
    <url>/2024/08/03/use-workflow-to-proxy-http-request/</url>
    <content><![CDATA[
Sogou 的 [workflow](https://github.com/sogou/workflow) 是一个 C++ 编写的简单易用的 web 框架，这里我对官方的 [http_proxy](https://github.com/sogou/workflow/blob/master/tutorial/tutorial-05-http_proxy.cc) 做一点简单修改，来实现抓包。
通常的抓包是设置代理服务器来实现的，我这里不通过代理，而是 http_proxy 作为一个中继一样的存在。
把官方的 [http_proxy](https://github.com/sogou/workflow/blob/master/tutorial/tutorial-05-http_proxy.cc) 修改成下面的样子

<!-- more -->
```cpp
/*
  Copyright (c) 2019 Sogou, Inc.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

  Author: Xie Han (xiehan@sogou-inc.com;63350856@qq.com)
*/

#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <utility>
#include "workflow/Workflow.h"
#include "workflow/HttpMessage.h"
#include "workflow/HttpUtil.h"
#include "workflow/WFHttpServer.h"

#ifndef _WIN32
#include <unistd.h>
#endif

struct tutorial_series_context
{
	std::string url;
	WFHttpTask *proxy_task;
	bool is_keep_alive;
};

void reply_callback(WFHttpTask *proxy_task)
{
	SeriesWork *series = series_of(proxy_task);
	tutorial_series_context *context =
		(tutorial_series_context *)series->get_context();
	auto *proxy_resp = proxy_task->get_resp();
	size_t size = proxy_resp->get_output_body_size();

	if (proxy_task->get_state() == WFT_STATE_SUCCESS)
	{
		fprintf(stderr, "%s: Success. Http Status: %s, BodyLength: %zu\n",
			context->url.c_str(), proxy_resp->get_status_code(), size);
	}
	else
	{
		/* WFT_STATE_SYS_ERROR*/
		fprintf(stderr, "%s: Reply failed: %s, BodyLength: %zu\n",
			context->url.c_str(), strerror(proxy_task->get_error()), size);
	}
}

void http_callback(WFHttpTask *task)
{
	int state = task->get_state();
	int error = task->get_error();
	auto *resp = task->get_resp();
	SeriesWork *series = series_of(task);
	tutorial_series_context *context =
		(tutorial_series_context *)series->get_context();
	auto *proxy_resp = context->proxy_task->get_resp();

	/* Some servers may close the socket as the end of http response. */
	if (state == WFT_STATE_SYS_ERROR && error == ECONNRESET)
		state = WFT_STATE_SUCCESS;

	if (state == WFT_STATE_SUCCESS)
	{
		const void *body;
		size_t len;

		/* set a callback for getting reply status. */
		context->proxy_task->set_callback(reply_callback);

		/* Copy the remote webserver's response, to proxy response. */
		if (resp->get_parsed_body(&body, &len))
			resp->append_output_body_nocopy(body, len);
		*proxy_resp = std::move(*resp);
		if (!context->is_keep_alive)
			proxy_resp->set_header_pair("Connection", "close");
	}
	else
	{
		const char *err_string;
		int error = task->get_error();

		if (state == WFT_STATE_SYS_ERROR)
			err_string = strerror(error);
		else if (state == WFT_STATE_DNS_ERROR)
			err_string = gai_strerror(error);
		else if (state == WFT_STATE_SSL_ERROR)
			err_string = "SSL error";
		else /* if (state == WFT_STATE_TASK_ERROR) */
			err_string = "URL error (Cannot be a HTTPS proxy)";

		fprintf(stderr, "%s: Fetch failed. state = %d, error = %d: %s\n",
				context->url.c_str(), state, task->get_error(),
				err_string);

		/* As a tutorial, make it simple. And ignore reply status. */
		proxy_resp->set_status_code("404");
		proxy_resp->append_output_body_nocopy(
							"<html>404 Not Found.</html>", 27);
	}
}

void process(WFHttpTask *proxy_task)
{
	auto *req = proxy_task->get_req();
	SeriesWork *series = series_of(proxy_task);
	WFHttpTask *http_task; /* for requesting remote webserver. */

	tutorial_series_context *context = new tutorial_series_context;
	context->url = req->get_request_uri();
	context->proxy_task = proxy_task;

	series->set_context(context);
	series->set_callback([](const SeriesWork *series) {
		delete (tutorial_series_context *)series->get_context();
	});
	std::string requesturi = req->get_request_uri();
        
        // add begain
	protocol::HttpHeaderCursor header_cursor(req);
	std::string host;
	if (header_cursor.find("Host", host))
	{
		requesturi = "http://" + host + requesturi;
	}
	printf("uri: %s\r\n", requesturi.c_str());
        // add end

	context->is_keep_alive = req->is_keep_alive();
	http_task = WFTaskFactory::create_http_task(requesturi.c_str(), 0, 0,
												http_callback);

	const void *body;
	size_t len;

	/* Copy user's request to the new task's reuqest using std::move() */
	req->set_request_uri(http_task->get_req()->get_request_uri());
	req->get_parsed_body(&body, &len);
	req->append_output_body_nocopy(body, len);
	*http_task->get_req() = std::move(*req);

	/* also, limit the remote webserver response size. */
	http_task->get_resp()->set_size_limit(200 * 1024 * 1024);

	*series << http_task;
}

void sig_handler(int signo) { }

int main(int argc, char *argv[])
{
	unsigned short port;

	if (argc != 2)
	{
		fprintf(stderr, "USAGE: %s <port>\n", argv[0]);
		exit(1);
	}

	port = atoi(argv[1]);
	signal(SIGINT, sig_handler);

	struct WFServerParams params = HTTP_SERVER_PARAMS_DEFAULT;
	/* for safety, limit request size to 8MB. */
	params.request_size_limit = 8 * 1024 * 1024;

	WFHttpServer server(&params, process);

	if (server.start(port) == 0)
	{
#ifndef _WIN32
		pause();
#else
		getchar();
#endif
		server.stop();
	}
	else
	{
		perror("Cannot start server");
		exit(1);
	}

	return 0;
}
```
]]></content>
      <tags>
        <tag>C++</tag>
        <tag>workflow</tag>
        <tag>sogou</tag>
        <tag>proxy</tag>
      </tags>
  </entry>
  <entry>
    <title>C++容器</title>
    <url>/2017/05/11/vector/</url>
    <content><![CDATA[{% asset_img 1.jpg %}

<!-- more -->
在校赛见到有人用这个了，查了一下，简直神器啊，兼具栈、队列、数组的特性，很理想的工具，贴一点用法，以备查询


<style>
table th:first-of-type {
    width: 100px;
}
</style>


| 操作       | 含义                                |
| :---------: | --------------------------------- |
| push_back | 在数组的最后添加一个数据                      |
| pop_back  | 去掉数组的最后一个数据                       |
| at        | 得到编号位置的数据                         |
| begin     | 得到数组头的指针                          |
| end       | 得到数组的最后一个单元+1的指针                  |
| front     | 得到数组头的引用                          |
| back      | 得到数组的最后一个单元的引用                    |
| max_size  | 得到vector最大可以是多大                   |
| capacity  | 当前vector分配的大小                     |
| size      | 当前使用数据的大小                         |
| resize    | 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值     |
| reserve   | 改变当前vecotr所分配空间的大小                |
| erase     | 删除指针指向的数据项                        |
| clear     | 清空当前的vector                       |
| rbegin    | 将vector反转后的开始指针返回(其实就是原来的end-1)   |
| rend      | 将vector反转构的结束指针返回(其实就是原来的begin-1) |
| empty     | 判断vector是否为空                      |
| swap      | 与另一个vector交换数据                    |


要想使用vector需要:
```C++
#include<vector>
using nmaespace std;
```
通过`vector<数据类型> 变量名;`来声明一个vector型变量。]]></content>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>Windows 10 作为无线显示器无法被搜索到</title>
    <url>/2017/05/20/wirless-display/</url>
    <content><![CDATA[{% asset_img 1.jpg  啊哈哈 %}
<!-- more -->
> 开始菜单的“连接应用打开后”，在无线显示设备页面，其它设备无法搜索到这台电脑。

## 解决办法
> 在设备管理器启用“Microsoft Wi-Fi Direct Virtual Adapter”

## 连接展示
{% asset_img 2.png %}
{% asset_img 3.png %}
{% asset_img 4.png %}
{% asset_img 5.png %}
{% cq %} 生命重在折腾 {% endcq %}
]]></content>
  </entry>
  <entry>
    <title>从获取微信小程序码说起</title>
    <url>/2021/06/12/wxacode/</url>
    <content><![CDATA[
微信官方对于小程序码的获取可以查看连接[https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/qr-code.html](https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/qr-code.html)

接口B，可以生成不受数量限制的小程序码，并且支持不太长的path和不超过32字符的参数。这样的话，就可以使用path和对应的参数来做一些事情。

<!-- more -->

接口B的介绍，可以查看[https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/qr-code/wxacode.getUnlimited.html](https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/qr-code/wxacode.getUnlimited.html)

简单来说，生成小程序码，是访问网址`https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=ACCESS_TOKEN`，并发起 post 请求，请求参数是一个 json 字符串，json 字符串的具体说明可以查看[接口B的说明](https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/qr-code/wxacode.getUnlimited.html)

我从官网摘下来了

|     属性     |   类型  |        默认值       | 必填 |                                                                                    说明                                                                                    |
|:------------:|:-------:|:-------------------:|:----:|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
| access_token |  string |                     |  是  | [接口调用凭证](https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/access-token/auth.getAccessToken.html)|
|     scene    |  string |                     |  是  | 最大32个可见字符，只支持数字，大小写英文以及部分特殊字符：!#$&'()*+,/:;=?@-._~，其它字符请自行编码为合法字符（因不支持%，中文无法使用 urlencode 处理，请使用其他编码方式） |
|     page     |  string |         主页        |  否  |     必须是已经发布的小程序存在的页面（否则报错），例如 pages/index/index,   根路径前不要填加 /,不能携带参数（参数请放在scene字段里），如果不填写这个字段，默认跳主页面     |
|     width    |  number |         430         |  否  | 小程序码宽度，单位是px，最小280px，最大 1280px |
|  auto_color  | boolean |        false        |  否  | 自动配置线条颜色，如果颜色依然是黑色，则说明不建议配置主色调，默认 false|
|  line_color  |  Object | {"r":0,"g":0,"b":0} |  否  |auto_color 为   false 时生效，使用 rgb 设置颜色   例如 {"r":"xxx","g":"xxx","b":"xxx"} 十进制表示|
|  is_hyaline  | boolean |        false        |  否  | 是否需要透明底色，为   true 时，生成透明底色的小程序|

access_token 是使用小程序的 appid 和 appsecret 生成的，可以查看[接口调用凭证](https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/access-token/auth.getAccessToken.html)

简单来说，就是访问使用 appid 和 appsecret 拼接而成的 `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET` ，发起 Get 请求，appid和appsecret 正确的情况下，会返回一个 json 字符串。

本文使用 libcurl 来实现访问微信服务器并最后获得小程序码的步骤。

## libcurl 发起 post 请求和 get 请求

为了方便操作，建议使用linux操作系统，Windows可能会面临一系列的 libcurl 及其库的编译，不熟悉的情况下，操作是十分繁琐的。

下面的实现是参考了 libcurl 的sample来实现的
```C
#include <stdio.h>
#include <string.h>
#include <curl/curl.h>
#include <memory.h>
#include <assert.h>
#include <stdlib.h>

#ifndef __cplusplus
typedef int bool;
#define true 1
#define false 0
#endif

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus


/*存储以POST方式需要发送的数据*/
struct Request
{
    char* readptr;
    size_t sizeleft;
};


struct Response
{
    unsigned char* response;
    size_t size;
};

/*发送数据的回调函数*/
static size_t send_callback(char* dest, size_t size, size_t nmemb, void* userp)
{
    struct Request* wt = (struct Request*)userp;
    size_t buffer_size = size * nmemb;

    if (wt->sizeleft) {
        /* copy as much as possible from the source to the destination */
        size_t copy_this_much = wt->sizeleft;
        if (copy_this_much > buffer_size)
            copy_this_much = buffer_size;
        memcpy(dest, wt->readptr, copy_this_much);

        wt->readptr += copy_this_much;
        wt->sizeleft -= copy_this_much;
        return copy_this_much; /* we copied this many bytes */
    }

    return 0; /* no more data left to deliver */
}

/*接收数据的回调函数*/
static size_t receive_callback(void* data, size_t size, size_t nmemb, void* userp)
{
    size_t realsize = size * nmemb;
    struct Response* mem = (struct Response*)userp;

    unsigned char* ptr = (char*)realloc(mem->response, mem->size + realsize + 1);
    if (ptr == NULL)
        return 0;  /* out of memory! */

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), data, realsize);
    mem->size += realsize;
    mem->response[mem->size] = 0;

    return realsize;
}

/*如果定义了 USE_SPECCIFIC_CACERT_PEM ，那么函数第一个参数应该指向一个 catcert.pem 证书*/
#ifdef USE_SPECCIFIC_CACERT_PEM
int handle_https_callback(const char* certpem, const char* url, const char* parameter, size_t size_send, void** responsedata, size_t* size_receive, char** content_type, bool post, bool verbose)
#else
int handle_https_callback(const char* url, const char* parameter, size_t size_send, void** responsedata, size_t* size_receive, char** content_type, bool post, bool verbose)
#endif // USE_SPECCIFIC_CACERT_PEM
{
    assert(url);
    CURL* curl;
    CURLcode res;
    struct Request request;
    struct Response response = { 0 };
    struct curl_slist* headers = NULL;
    int result = 0;

    /*如果parameter非空，那么有数据要发送，就申请相应的发送数据的空间*/
    bool hasParameter = false;
    bool hasParameter = false;
    if (parameter != NULL)
    {
        hasParameter = true;
        size_t len = strlen(parameter);
        size_t min = len < size_send ? len : size_send;
        request.readptr = (char *)parameter;
        request.sizeleft = min;
    }

    res = curl_global_init(CURL_GLOBAL_DEFAULT);
    if (res != CURLE_OK)
    {
        fprintf(stderr, "curl_global_init() failed: %s\n", curl_easy_strerror(res));
        return 1;
    }
    curl = curl_easy_init();
    if (curl)
    {
        curl_easy_setopt(curl, CURLOPT_URL, url);
        if (post)
        {
            curl_easy_setopt(curl, CURLOPT_POST, 1L);
        }

        /*如果有数据需要发送，就设置相应的数据发送回调函数，要发送的数据和数据长度*/
        if (hasParameter)
        {
            curl_easy_setopt(curl, CURLOPT_READFUNCTION, send_callback);
            curl_easy_setopt(curl, CURLOPT_READDATA, &request);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long)request.sizeleft);
        }

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, receive_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&response);

        headers = curl_slist_append(headers, "Content-Type: application/json");

        /*如果定义了 USE_SPECCIFIC_CACERT_PEM ，那么设置SSL认证证书*/
#ifdef USE_SPECCIFIC_CACERT_PEM
        curl_easy_setopt(curl, CURLOPT_CAINFO, certpem)
#elif defined(DISABLE_CURL_SSL_VERIFY) // 如果定义了 DISABLE_CURL_SSL_VERIFY 证书认证，那么就设置curl不强制认证服务器
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
#endif // USE_SPECCIFIC_CACERT_PEM


        if (verbose)
        {
            curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
        }

        res = curl_easy_perform(curl);
        if (res == CURLE_OK)
        {
            long http_code = 0;
            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
            if (http_code == 200)
            {
                /*curl_easy_cleanup(curl) 会释放掉 tmp_content_type*/
                char* tmp_content_type = NULL;
                curl_easy_getinfo(curl, CURLINFO_CONTENT_TYPE, &tmp_content_type);
                if(tmp_content_type)
                {
                    size_t tmplen = strlen(tmp_content_type);
                    *content_type = malloc(tmplen + 1);
                    memset(*content_type, 0, tmplen + 1);
                    memcpy(*content_type, tmp_content_type, tmplen);
                }
                /*用户需要自行释放 responsedata */
                *responsedata = response.response;
                *size_receive = response.size;
            }
            else
            {
                result = -2;
                fprintf(stderr, "net work error with http code %ld", http_code);
            }
        }
        else
        {
            result = 2;
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    return result;
}

#ifdef __cplusplus
    extern "C" }
#endif // __cplusplus
```
函数
```C
int handle_https_callback(const char* url, const char* parameter, size_t size_send, void** responsedata, size_t* size_receive, char** content_type, bool post, bool verbose)
```
| 属性 | 参数 | 说明 |
|:--:| :--: | :--: |
|传入参数| url | 想要访问的url |
|传入参数| post | 是否发起 post |
|传入参数| parameter | 如果以 post 方式发起请求，parameter 是想要发送的数据，<br> 如果不是以 post 方式发起，此参数为 NULL |
|传入参数| size_send | 要发送的数据长度，实际上发送的数据长度以 parameter 的<br>长度和 size_send 中去较小值|
|传出参数| responsedata | 服务器发送回来的数据 |
|传出参数| size_receive | 服务器发送回来的数据的长度 |
|传出参数| content_type | 如果是获取 access_token ，那么这里的 content_type 应该<br>是 "application/json; encoding=utf-8",如果是小程序码，那么这里<br>应该是"Image/jpeg"或者别的类型的content type|
|传入参数| verbose | 设置是否打印 curl 调用过程中的信息 |

常见的 Content-Type 可能有以下这些(摘自 [cpp-httplib](https://github.com/yhirose/cpp-httplib) 的 README)

| Extension  |          MIME Type          | Extension  |          MIME Type          |
| :--------- | :-------------------------- | :--------- | :-------------------------- |
| css        | text/css                    | mpga       | audio/mpeg                  |
| csv        | text/csv                    | weba       | audio/webm                  |
| txt        | text/plain                  | wav        | audio/wave                  |
| vtt        | text/vtt                    | otf        | font/otf                    |
| html, htm  | text/html                   | ttf        | font/ttf                    |
| apng       | image/apng                  | woff       | font/woff                   |
| avif       | image/avif                  | woff2      | font/woff2                  |
| bmp        | image/bmp                   | 7z         | application/x-7z-compressed |
| gif        | image/gif                   | atom       | application/atom+xml        |
| png        | image/png                   | pdf        | application/pdf             |
| svg        | image/svg+xml               | mjs, js    | application/javascript      |
| webp       | image/webp                  | json       | application/json            |
| ico        | image/x-icon                | rss        | application/rss+xml         |
| tif        | image/tiff                  | tar        | application/x-tar           |
| tiff       | image/tiff                  | xhtml, xht | application/xhtml+xml       |
| jpeg, jpg  | image/jpeg                  | xslt       | application/xslt+xml        |
| mp4        | video/mp4                   | xml        | application/xml             |
| mpeg       | video/mpeg                  | gz         | application/gzip            |
| webm       | video/webm                  | zip        | application/zip             |
| mp3        | audio/mp3                   | wasm       | application/wasm            |

## 获取 access_token
基于上面的使用 libcurl 发起 post 和 get 请求，可以很容以的再封装一下，成为根据 appid 和 appsecret 来获取小程序的 access_token 的实现。

```C++

// 为了方便对json处理，这里使用 rapidjson
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"

#ifdef USE_SPECCIFIC_CACERT_PEM
int get_wxacode_access_token(const char* certpem, const char* appid, const char* appsecret, char** access_token, bool verbose)
#else
int get_wxacode_access_token(const char* appid, const char* appsecret, char** access_token, bool verbose)
#endif // USE_SPECCIFIC_CACERT_PEM
{
    assert(appid);
    assert(appsecret);
    const char* wxacode_domain = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=";
    const char* secret_param = "&secret=";
    size_t url_len = strlen(wxacode_domain) + strlen(appid) + strlen(secret_param) + strlen(appsecret);
    char* url = (char *)malloc(url_len + 1);
    if (!url)
    {
        return -1;/*out of mempry*/
    }
    memset(url, 0, url_len + 1);
    sprintf_s(url, url_len + 1, "%s%s%s%s", wxacode_domain, appid, secret_param, appsecret);
    if (verbose)
    {
        printf("access to url:%s\r\n", url);
    }

    char* response = NULL;
    char* content_type = NULL;
    size_t len = 0;
#ifdef USE_SPECCIFIC_CACERT_PEM
    int result = handle_https_callback(certpem, url, false, NULL, 0, (void**)&response, &len, &content_type, verbose);
#else
    int result = handle_https_callback(url, false, NULL, 0, (void **)&response, &len, &content_type, verbose);
#endif // USE_SPECCIFIC_CACERT_PEM
    bool get_access_token = false;
    if (result == 0)
    {
        if (strstr(content_type, "application/json"))
        {
            rapidjson::Document doc;
            doc.Parse(response);
            assert(doc.IsObject());
            if (doc.HasMember("access_token"))
            {
                /*如果返回内容包含 access_token，则提取对应的字段*/
                const char* token = doc["access_token"].GetString();
                size_t token_len = strlen(token);
                *access_token = (char *)malloc(token_len + 1);
                if (*access_token == NULL)
                {
                    return -1;/*out of memory*/;
                }
                memset(*access_token, 0, token_len + 1);
                memcpy(*access_token, token, token_len);
                get_access_token = true;
            }
        }

        if (!get_access_token)
        {
            /*如果返回的 response 不是 json ，就直接将 response 内容传递回去*/
            size_t token_len = strlen(response);
            *access_token = (char *)malloc(token_len + 1);
            if (*access_token == NULL)
            {
                return -1;/*out of memory*/;
            }
            memset(*access_token, 0, token_len + 1);
            memcpy(*access_token, response, token_len);
            result = 4;
        }
    }
    if (url)
    {
        free(url);
        url = NULL;
    }
    if (response)
    {
        free(response);
        response = NULL;
    }
    if (content_type)
    {
        free(content_type);
        content_type = NULL;
    }
    return result;
}
```

## 获取小程序二维码
和获取 access_token 类似，稍微封装一下就可以改写成为根据 access_token 获取小程序码的接口了
```C++
#ifdef USE_SPECCIFIC_CACERT_PEM
int get_wxacode_unlimited(const char* certpem, const char* access_token, unsigned char** qrcode, size_t* size, bool verbose)
#else
int get_wxacode_unlimited(const char* access_token,const char* parameter, unsigned char** qrcode, size_t* size, bool verbose)
#endif // USE_SPECCIFIC_CACERT_PEM
{
    assert(access_token);
    assert(parameter);
    const char* wxacodedomain = "https://api.weixin.qq.com/wxa/getwxacodeunlimit?access_token=";
    size_t url_len = strlen(wxacodedomain) + strlen(access_token);
    char* url = (char *)malloc(url_len + 1);
    if (url == NULL)
    {
        return -1;/*out of mempry*/
    }
    sprintf_s(url, url_len + 1, "%s%s", wxacodedomain, access_token);
    if (verbose)
    {
        printf("access to url:%s\r\n", url);
    }
    unsigned char* response = NULL;
    char* content_type = NULL;
    size_t len = 0;
#ifdef USE_SPECCIFIC_CACERT_PEM
    int result = handle_https_callback(certpem, url, true, parameter, strlen(parameter), (void**)&response, &len, &content_type, verbose);
#else
    int result = handle_https_callback(url, true, parameter, strlen(parameter), (void **)&response, &len, &content_type, verbose);
#endif // USE_SPECCIFIC_CACERT_PEM
    
    if (result == 0)
    {
        if (!(strstr(content_type, "image/jpeg")))
        {
            result = 4;
        }
        *qrcode = (unsigned char*)malloc(len+1);
        if (*qrcode == NULL)
        {
            return -1;/*out of memory*/;
        }
        memset(*qrcode, 0, len + 1);
        memcpy(*qrcode, response, len);
        *size = len;
    }
    return result;
}
```

## 使用示范

```C++
//main.cc
int main()
{
    const char* access_token = NULL;
    const char* appid = "your_appid";
    const char* appsecret = "your_appsecret";
    int result = get_wxacode_access_token(appid, appsecret, &access_token, true);
    if (result > 0)
    {
        printf("in main func:%s\r\n", access_token);
    }
    else if(result == 0)
    {
        printf("access_token:%s\r\n", access_token);
        unsigned char* qrcode = NULL;
        size_t size = 0;
        const char* parameter = "{\"scene\":\"testtest\"}";
        result = get_wxacode_unlimited(access_token, parameter, &qrcode, &size, true);
        if (result > 0)
        {
            printf("in main func qrcode:%s\r\n", qrcode);
        }
        else if (result == 0)
        {
            FILE* file;
            if (fopen_s(&file, "wxacode.jpg", "wb+") == 0)
            {
                fwrite(qrcode, 1, size, file);
                printf("success write wxacode.jpg\r\n");
            }
            else
            {
                printf("failed to open wxacode.jpg\r\n");
            }
        }
        if (qrcode)
        {
            free(qrcode);
            qrcode = NULL;
        }
    }
    if (access_token)
    {
        free(access_token);
        access_token = NULL;
    }

    return 0;
}
```

## 依赖
在 ubuntu 上，由于使用了 libcurl 访问https的链接，可以尝试安装这个包 `libcurl4-openssl-dev`
在对返回值的处理中，使用了 rapidjson 作为处理json的库，可以尝试安装这个包`rapidjson-dev`
编译时需要使用 `-lssl -lcurl`作为链接库

Windows 上，尝试使用 vcpkg 来安装 libcurl]]></content>
  </entry>
  <entry>
    <title>记一次服务器被黑用于挖矿的处理记录</title>
    <url>/2024/07/31/yayaya-miner/</url>
    <content><![CDATA[
某日上班，登服务器后编译Android ROM,增量编译时间比平时长了 3~4 倍，htop 看一下

<!-- more -->

{% asset_img 1.png %}

好奇怪，怎么前 36 个核是满的，过了半个小时看，还是这样。有点预感不妙。遂登录另外一个同配置用户只有两三个的服务器，也是前 36 个核被占满，并且看不到什么进程占用了CPU多半是中招了。
查了netstat，有两个奇怪的连接，但是不显示进程名和PID。通过网络搜索和供应商的数据得知，这两个IP是矿池的IP。确认是中挖矿病毒了。

{% asset_img 2.png %}

看一下开机启动项

{% asset_img 3.png %}

确认有一个奇怪启动项，遂以root权限编辑之，提示Read only，无法强行保存，以root权限移除 /usr/bin/52657500，奇了怪了，我这root权限是假的？
由于平时工作是做安卓的，这种状态我以为我的权限被动了，不是真正的 root 权限了。于是到清华软件源下了 ubuntu 22.04 desktop 镜像，做成启动盘直奔机房，从U盘启动服务器，尝试编辑 `rc.local` ，仍然是 read only，rm -f 也是提示操作不允许。遂翻了翻自己的脑袋，想起来以前看过一篇文章：[CPU深夜狂飙，一帮大佬都傻眼了](https://mp.weixin.qq.com/s/HWfSdwfYnknJEhfaTPOhyw)···

遂得知一个命令 `unhide`，输入 `api install unhide` ， root 权限跑 `unhide proc` 一看，确实有不少隐藏进程（几十个）

```bash
Found HIDDEN PID: 27589
        Cmdline: "usr/sbin/httpd"
        Executable: "/usr/bin/perl"
        Command: "usr/sbin/httpd"
        $USER=<undefined>
        $PWD=<undefined>

Found HIDDEN PID: 27787
        Cmdline: "/1c03a5f9"
        Executable: "/1c03a5f9 (deleted)"
        Command: "1c03a5f9"
        $USER=root
        $PWD=/
......
```

咨询另外一个同事，再结合百度搜索“root 权限无法编辑文件”，得知2个命令 `lsattr` 和 `chattr` 可以用于禁止文件修改。敲进去提示没有此命令，需要安装e2fsprogs，然后输入 `apt install e2fsprogs` 提示已安装，遂推得命令被删掉了，于是找另外一个正常运行的服务器拷了命令过来（当时脑袋宕机了，如果有网络的话，其实这里可以直接`apt install --reinstall e2fsprogs`的）。然后root权限输入

```bash
chattr -i /etc/rc.local
chattr -e /etc/rc.local
chattr -a /etc/rc.local
chattr -i /usr/bin/52657500
chattr -a /usr/bin/52657500
chattr -e /usr/bin/52657500
```

之后终于可以编辑 `rc.local` 了，删除启动项，重启。吧唧，还是占满 36 个核。看起来病毒还有别的启动方式。
看一下服务`sudo systemctl list-unit-files`，没看到可疑的东西，看一下 `cron crontab -l`，也没有计划任务，奇了怪了，这进程怎么启动的。到这里线索就断了，一直在网上看查找开机启动项和CPU挖矿的信息。看到这篇推文 [实战|又一起挖矿木马排查](https://mp.weixin.qq.com/s/o4hcP16ZMPoaK2nfJbcqgw) 的时候留意到一个信息

{% asset_img 4.png %}

这里用`systemctl status $pid`查看到了这个进程的服务信息，遂用同样的方式，用上面查到的隐藏进程，输进去，好家伙，终于出来了：

{% asset_img 5.png %}

这里看到服务在 `/lib/systemd/system/yayaya9fdf90d8` ，进程在 `/usr/lib/x86_64-linux-gnu/yayaya8e658d04`。删进程之前备份一下，奇怪的事情又来了。明明存在的文件，但是 ls 看不到它。

{% asset_img 6.png %}

把服务和进程备份好，删掉重启。CPU终于安静下来了。并且重启前不显示的文件也能显示了。
以关键字`yayaya 病毒`搜到了几乎是中文互联网上唯一的记录：[yayaya Miner挖矿木马分析](https://mp.weixin.qq.com/s/UYdze4yt2OoWoTcK0qY3Mw)。

{% asset_img 7.png %}

根据[yayaya Miner挖矿木马分析](https://mp.weixin.qq.com/s/UYdze4yt2OoWoTcK0qY3Mw)和我们的处理记录，总结如下

1. 使用 chattr 来让不可修改的文件变得可修改，并清理 rc.local 里面的奇怪启动项；
2. `sudo rmmod nonono`（移除用于隐藏前缀的内核模块）；
3. 查看 `/lib/systemd/system/` 里面以 `yayaya` 开头的 service；
4. `sudo systemctl stop yayayaxxxxx.service`；
5. `sudo systemctl disable yayayaxxxxx.service`；
6. 清理 crontab 里面奇怪的定时任务；
7. 删除 `/etc/sysconfig/yayaya`；
后续继续改进的地方：
8. 修改 root 及有管理员权限的用户密码,并禁止设置弱密码（被感染的服务器都有大量的来自局域网的登录失败记录，与上面推文中的ssh爆破行为一致）；
9. 禁用 ssh 密码登录；
10. 可以不连接外网的服务器断开外网连接（排查初期，是通过断开网络外网让病毒不再占用CPU的）；
本次排查病毒从 2023.07.26 下午开始，到 2023/07.28 早上确认到原因。]]></content>
  </entry>
  <entry>
    <title>Code::Blocks 快捷键(中文)</title>
    <url>/2017/07/12/zh-CN-shortcut-of-code-blocks/</url>
    <content><![CDATA[{% asset_img cover.png %}

<!-- more -->

## 编辑相关
| Function                     | Shortcut Key            |
| ---------------------------- | ----------------------- |
| 撤销                           | Ctrl + Z                |
| 重复上一次 操作                     | Ctrl + Shift + Z        |
| 剪切选中的文本                      | Ctrl + X                |
| 复制选中的文本                      | Ctrl + C                |
| 从剪贴板粘贴                       | Ctrl + V                |
| 选中所有文本                       | Ctrl + A                |
| 切换头文件/源文件                    | F11                     |
| 注释掉代码                        | Ctrl + Shift + C        |
| 撤销注释代码                       | Ctrl + Shift + X        |
| 复制当前行                        | Ctrl + D                |
| 自动完成/填充代码                    | Ctrl + Space / Ctrl + J |
| Show call tip                | Ctrl + Shift + Space    |
| 将当前行与上一行交换位置                 | Ctrl + T                |
| 添加/取消书签                      | Ctrl + B                |
| 跳转到上一个书签                     | Alt + PgUp              |
| 跳转到下一个书签                     | Alt + PgDown            |
| Toggle current block folding | F12                     |
| Toggle all folds             | Shift + F12             |

This is a list of shortcuts provided by the Code::Blocks' editor component. These shortcuts cannot be rebound.

| Function                                 | Shortcut Key             |
| ---------------------------------------- | ------------------------ |
| 放大文本                                     | Ctrl + Keypad "+"        |
| 缩小文本                                     | Ctrl + Keypad "-"        |
| 换源文本大小                                   | Ctrl + Keypad "/"        |
| 浏览最近文件                                   | Ctrl + Tab               |
| Indent block.                            | Tab                      |
| Dedent block.                            | Shift + Tab              |
| 删除到词首                                    | Ctrl + BackSpace         |
| 删除到词尾                                    | Ctrl + Delete            |
| 删除到行首                                    | Ctrl + Shift + BackSpace |
| 删除到行尾                                    | Ctrl + Shift + Delete    |
| 跳转到文件首                                   | Ctrl + Home              |
| Extend selection to start of document.   | Ctrl + Shift + Home      |
| Go to start of display line.             | Alt + Home               |
| Extend selection to start of display line. | Alt + Shift + Home       |
| Go to end of document.                   | Ctrl + End               |
| Extend selection to end of document.     | Ctrl + Shift + End       |
| Go to end of display line.               | Alt + End                |
| Extend selection to end of display line. | Alt + Shift + End        |
| Expand or contract a fold point.         | Ctrl + Keypad "*"        |
| Create or delete a bookmark.             | Ctrl + F2                |
| Go to next bookmark.                     | F2                       |
| Select to next bookmark.                 | Alt + F2                 |
| Find selection.                          | Ctrl + F3                |
| Find selection backwards.                | Ctrl + Shift + F3        |
| Scroll up.                               | Ctrl + Up                |
| Scroll down.                             | Ctrl + Down              |
| 前切当前行到剪贴板                                | Ctrl + L                 |
| 复制当前行到剪贴板                                | Ctrl + Shift + T         |
| 删除当前行                                    | Ctrl + Shift + L         |
| Line transpose with previous.            | Ctrl + T                 |
| 复制当前行                                    | Ctrl + D                 |
| Find matching preprocessor conditional, skipping nested ones. | Ctrl + K                 |
| Select to matching preprocessor conditional. | Ctrl + Shift + K         |
| Find matching preprocessor conditional backwards, skipping nested ones. | Ctrl + J                 |
| Select to matching preprocessor conditional backwards. | Ctrl + Shift + J         |
| Previous paragraph. Shift extends selection. | Ctrl + [                 |
| Next paragraph. Shift extends selection. | Ctrl + ]                 |
| Previous word. Shift extends selection.  | Ctrl + Left              |
| Next word. Shift extends selection.      | Ctrl + Right             |
| Previous word part. Shift extends selection. | Ctrl + /                 |
| Next word part. Shift extends selection. | Ctrl + \                 |

## 文件相关

| Function    | Shortcut Key                         |
| ----------- | ------------------------------------ |
| 新建空文件       | Ctrl + N                             |
| 打开已存在的文件或项目 | Ctrl + O                             |
| 保存当前文件      | Ctrl + S                             |
| 保存所有文件      | Ctrl + Shift + S                     |
| 关闭当前文件      | Ctrl + F4 / Ctrl + W                 |
| 关闭所有文件      | Ctrl + Shift + F4 / Ctrl + Shift + W |

## 预览相关

| Function                            | Shortcut Key            |
| ----------------------------------- | ----------------------- |
| 显示/隐藏 底部信息面板                        | F2                      |
| 显示/隐藏 管理左侧面板                        | Shift + F2              |
| Move project up (in Project tree)   | Ctrl + Shift + Up       |
| Move project down (in Project tree) | Ctrl + Shift + Down     |
| 激活前一个项目                             | Alt + F5                |
| 激活下一个项目                             | Alt + F6                |
| Zoom in / out                       | Ctrl + Roll Mouse Wheel |
| Focus editor                        | CTRL + Alt + E          |

## 查找相关

| 功能                         | 快捷键               |
| -------------------------- | ----------------- |
| 查找                         | Ctrl + F          |
| 查找下一个                      | F3                |
| 查找上一个                      | Shift + F3        |
| 在文件内查找                     | Crtl + Shift + F  |
| 替换                         | Ctrl + R          |
| 在文件内替换                     | Ctrl + Shift + R  |
| 跳转到某行                      | Ctrl + G          |
| Goto next changed line     | Ctrl + F3         |
| Goto previous changed line | Ctrl + Shift + F3 |
| 跳转到某文件                     | Alt + G           |
| 跳转到某个函数                    | Ctrl + Alt + G    |
| 跳转到上一个函数                   | Ctrl + PgUp       |
| 跳转到下一个函数                   | Ctrl + PgDn       |
| Goto declaration           | Ctrl + Shift + .  |
| Goto implementation        | Ctrl + .          |
| Open include file          | Ctrl + Alt + .    |

## Build

| Function | Shortcut Key      |
| -------- | ----------------- |
| 构建       | Ctrl + F9         |
| 编译当前文件   | Ctrl + Shift + F9 |
| 运行       | Ctrl + F10        |
| 构建并运行    | F9                |
| 重新构建     | Ctrl + F11        |

## Debug

| Function                 | Shortcut Key      |
| ------------------------ | ----------------- |
| 开始调试                     | F8                |
| 继续调试                     | Ctrl + F7         |
| Step over a code block   | F7                |
| Step into a code block   | Shift + F7        |
| Step out of a code block | Ctrl + Shift + F7 |
| 添加/取消断点                  | F5                |
| 运行到下一个断点                 | F4                |
| 上一个错误                    | Alt + F1          |
| 下一个错误                    | Alt + F2          |
-----
内容来自官方wiki:[http://wiki.codeblocks.org/index.php?title=Keyboard_Shortcuts](http://wiki.codeblocks.org/index.php?title=Keyboard_Shortcuts) ，看来得抽空翻译一下d=====(￣▽￣*)b
]]></content>
  </entry>
  <entry>
    <title>Minecraft专题</title>
    <url>/Minecraft/index.html</url>
    <content><![CDATA[## Minecraft 介绍
一款超高自由度的沙盒游戏。
现在已经支持以下平台
- Windows
- Linux
- Mac OS
- Android
- Windows Phone(已经停更)
- Microsoft: Xbox
- Sony: PlayStation
- Microsoft: Xbox One
- 任天堂: Wii U

其中，由Java编写的版本(Mojang发行)可用于Windows、Linux、Mac OS，现在玩法最多的也是Java编写的版本。
2017.09.26，新版Minecraft可以通过Xbox账号，将Windows 10 PC(Windows Store)、Android、ios、平板、Xbox One和虚拟现实平台进行联机。似乎有一点Windows 10大统一的势头。
## Java版
Java版本的玩家最多，围绕Java版展开了很多第三方的功能。
### 服务器篇
#### 官方版本
Mojang提供一个`jar`文件，用于开启服务端，为官方版本，官方版本功能最少。可以前往[https://minecraft.net/zh-hans/download/server](https://minecraft.net/zh-hans/download/server)获取最新版的官方服务端。使用方法可以百度一下，或者到本站的[教程](../2016/07/03/Minecraft-server/)查看。
#### 第三方版本
官服使用起来有诸多限制，有许多很好用的第三方服务端
- [Spigot](https://www.spigotmc.org/)
- [Sponge](https://www.spongepowered.org/)
- ······

这些第三方服务端大都开源，可以自行编译。不过，大多数情况下，配置编译环境会难倒一批人，按照Wiki一步一步来，会发现照样没办法编译成功。所以直接下载其他人编译好的版本就好了。这里提供一个镜像站[https://yivesmirror.com/](https://yivesmirror.com/)，安全性未知，自行斟酌。
我自己编译了Spigot、CraftBukkit，收集了Mojang的版本，放在了[https://coding.net/BDZNH/p/Minecraft-Server/](https://coding.net/BDZNH/p/Minecraft-Server/)。
按照实际体验来看，官服的表现并不如第三方服务端，Spigot表现据说优于Craftbukkit，OS的选择上，在腾讯云的`1G RAM + 1 Core CPU`VPS上，Cent OS优于Ubuntu。

## 基岩版
2018年，mojang 官方公布了基岩版的测试服务端，截至 2019.03.02 ，依旧是测试版，不过使用体验来看，已经很不错了，目前没有发现什么问题。
基岩版使用教程可以查看: [MC 基岩版(PE) 服务器来了](../2018/10/13/mcpe-server/)

2017的E3大会上，微软将之前的PE版、主机版等，更名为`基岩版`(别问我为什么取这么个名字，我也觉得好奇怪ε=ε=ε=(~￣▽￣)~)，官方并未提供基岩版的独立服务端，而是在程序内内置REALM，每月30+￥的订阅服务。
不过，还是有第三方的服务端的，但是更新脚步较慢，不如Java版本。

- [Nukkit](https://nukkit.io/)
- [Genisys](https://genisys.pro/)
- [PocketMine](http://www.pocketmine.net/)(已经很长时间没有更新)

Windows 10 版本由C++编写，在我的渣机上，表现远远超过Java版本。

## 碎碎念
Minecraft发布之初，作者也没有想到它会壮大到如今的程度。在折腾Mod的过程中，认识了一个插件——Optifine，安装插件之后，FPS飙升，Intel的核显都能跑到60，在Windows和Linux上都有很明显的提升。
在基岩版中，微软官方引入了皮肤包、材质包，这些原本并未被包含在官方的Minecraft中，而是出现在第三方的服务器上，比如hypixel什么的。
Mojang官方提供的个性化服务仅有皮肤和披风，直到微软收购Minecraft之后，微软加入材质、地图、皮肤包等等元素。微软将Minecraft引入全平台(目前只有sony拒r让其PlayStation平台加入，不知微软与索尼商榷得怎么样了)，而Mojang继续开发Java版本，Java版本依旧没有多少提升，在性能上被微软发布的C++版本甩开很远。Minecraft对配置要求挺高，但是通过Optifine来看，这个锅可不能让jvm来背，而是Mojang的不作为。
大部分主机平台的硬件配置并不高，但是主机上的游戏体验远高于同等配置的PC，因为游戏厂商专门针对主机的硬件做优化(其实从这里可以引出ios与安卓之争，iPhone的型号并不是很多，从4代到最新的8代，所有机型加起来，也就十多二十个，ios只用针对这几个型号，再加上数量众多的应用，给iPhone带来了优秀的体验，而安卓，太多了！)，借用知乎一些答主的话来说，能躺着把钱挣了，为什么要坐着呢？
成就Minecraft的，不是Mojang，也不是微软，而是数量众多的第三方服务器和玩家，他们的创造力最强了吧！
不得不承认的是，Minecraft本身并不是一个很吸引人的游戏，入门的门槛相对来说，确实有些高了，没有人带领，会在初期就放弃掉，再加上不高，但是对于国人来说挺高的正版授权费用，会损失不少潜在玩家。不知微软能把它带往何方。

## 启动器
### 官方启动器
可以自行配置Java运行环境以及桌面快捷方式的安装包，仅限Windows：
MSI格式安装包：[https://launcher.mojang.com/download/MinecraftInstaller.msi](https://launcher.mojang.com/download/MinecraftInstaller.msi)
EXE格式安装包：[https://launcher.mojang.com/download/Minecraft.exe](https://launcher.mojang.com/download/Minecraft.exe)

单启动器，需要玩家手动安装Java运行环境：
Windows: [http://s3.amazonaws.com/Minecraft.Download/launcher/Minecraft.exe](http://s3.amazonaws.com/Minecraft.Download/launcher/Minecraft.exe)
macOS X: [https://launcher.mojang.com/download/Minecraft.dmg](https://launcher.mojang.com/download/Minecraft.dmg)
Linux/其它: [http://s3.amazonaws.com/Minecraft.Download/launcher/Minecraft.jar](http://s3.amazonaws.com/Minecraft.Download/launcher/Minecraft.jar)

### 第三方启动器
1. [HMCL](https://github.com/huanghongxun/HMCL): [https://github.com/huanghongxun/HMCL/releases](https://github.com/huanghongxun/HMCL/releases)
> UI不错，自带客户端下载，可以自定义启动参数，可以正版登录、离线登录，一个使用人数相当多的第三方客户端。跨平台。

![](hmcl.jpg)

2. [MultiMC](https://github.com/MultiMC/MultiMC5): [https://github.com/MultiMC/MultiMC5/releases](https://github.com/MultiMC/MultiMC5/releases)
> UI略丑，仅支持正版登录，有forge、mod、截图和地图管理，很不错。跨平台。

![](multimc.jpg)
## 一点点相关
Bilibili上有一位up主持续更新了一部用Minecraft拍摄《三体》，很赞的作品，地址在这儿:[https://space.bilibili.com/614801#/](https://space.bilibili.com/614801#/)
![](bilibili_mc.png)
## 资讯
### 2017.11.19 水域更新
水域更新！[视频](https://www.bilibili.com/video/av16463965/)
Minecraft的海洋将获有史以来最大的更新！ “水域更新”为游戏注入了许多新的功能，包括珊瑚，海带，更多类型的鱼，海豚，可探索的沉船，符合物理学的水等等！新改造的海洋将需要一个新的武器来保护自己，所以水域更新也将引入三叉戟。这种武器不仅可以向敌人投掷，而且可以在近战中使用。即使投掷之后，忠诚魔法也会让你回到你的身边，而像Impaler和Slipstream Dash这样的魔法将会......好吧，我们会让你尽情发挥你的想象力！水域更新即将更新到游戏！

NINTENDO SWITCH和史诗图形包
我们也很想尽快发布史诗图形包。 虽然原定于今年发布，但还有很多工作要做，而且我们不准备在2017年发布它。我们将在明年发布，更多信息将很快更新到Minecraft.net上。

另外，NS依然会更新全平台联机的基岩版Minecraft，但要等到2018年了。任天堂一直是一个很好的合作伙伴，我们非常兴奋能够把Switch玩家带入其中，但是，我们需要确保我们能提供尽可能最好的体验。因此，新版本的Minecraft将于明年发布到NS、 Xbox One、PC、手机和NS上，都在2018年一起玩多人游戏Minecraft

### 1.13正式版 水域更新
海洋更新的更新

一般
 - 所有不死生物现在会下沉了
 - 水下的能见度变了
 - 你的视力在水下越呆越好
 - 大修了世界生成器。
 - 大修了命令
 - 新增了新的世界类型Buffet
 - 允许你创建仅有独特群系的世界
 - 这个类型还将更新

 - 添加了一些声音
 - 新加了三首音乐
 - 增加了水下环境的音效
 - 增加了游泳动画
 - 在水下按冲刺键开始游泳
 - 添加了数据包
 - 允许编辑合成表，标签，战利品表、函数、进度
 - 添加了新的进度
 - 现在一些方块可以含水了
 - 方式是用水桶右键
 - 添加了一个优化世界的按钮，它将把世界升级到现在的游戏版本
方块
 - 添加了蓝冰
 - 在冰山中出现
 - 新加了珊瑚块和珊瑚扇。。。还有珊瑚
 - 添加了潮涌核心
 - 用海洋之心和螺壳合成
 - 这会让你的水下生活更加舒坦
 - 添加了海带块
 - 九个干海带合成
 - 添加了海带和海草
 - 普通南瓜不在有脸了
 - 添加了海泡菜
 - 添加了气泡柱
 - 用岩浆块或者灵魂沙来制作一个气泡柱
 - 添加了木头方块
 - 使用四个原木制作
 - 用斧头右键可以剥木头的皮
 - 添加了新的楼梯和半砖
 - 为六种木材都加了相应的木制品：压力板、活板门、按钮
 - 海龟蛋
生物
 - 添加了热带鱼
 - 添加海龟
 - 会在沙滩上产卵
友好生物
 - 添加了海豚
 - 如果你喂它鱼，他会引导你找到财宝。
 - 请千万不要袭击他们，否则小心被围殴。
中立生物。
 - 添加了溺尸
 - 可以在海洋与河流中生存
 - 可能手持三叉戟
 - 僵尸在水里过久就会变成溺尸。
 - 添加了幻翼
 - 你不睡觉他们就会让你彻底长眠。
 - 掉落膜。
 - 添加了鳕鱼鲑鱼还有河豚
 - 把马的画风改成了和别的生物一样
 - 去掉了HIM
物品
 - 添加了三叉戟是一种新武器溺尸会掉落它。即是近战也是远程
 - 添加了三叉戟的附魔
 - 添加了用桶装鱼的能力
 - 添加了地图的标记
 - 手持地图，右键旗帜
 - 海洋之心可以在宝藏中发现
 - 添加鹦鹉螺壳
 - 添加了幻影膜 这个可以让你去修鞘翅，也可以用来酿造缓降药水
 - 添加了海龟壳 小海龟长大后会掉落
 - 可以酿神龟药水 抗性3和减速4 缓降药水
 - 添加了干海带
 - 为所有生物添加了蛋
生物群落
 - 添加了多个海洋生物群落
 - 添加了珊瑚礁
 - 添加了水下洞穴和水下峡谷
结构
 - 添加了沉船
 - 水下遗迹，添加了冰山
 转于MCBBS http://www.mcbbs.net/forum.php?mod=viewthread&tid=807129&extra=page%3D1%26filter%3Dtypeid%26typeid%3D204  @[乙烯_中国](http://www.mcbbs.net/home.php?mod=space&uid=1073223)
]]></content>
  </entry>
  <entry>
    <title>关于我</title>
    <url>/about/index.html</url>
    <content><![CDATA[<iframe frameborder="no" border="0" marginwidth="0" marginheight="0" width=330 height=86 src="//music.163.com/outchain/player?type=2&id=28815250&auto=0&height=66"></iframe>

西安电子科技大学渣一枚

喜欢折腾电脑

闲的时候，读读书，发发呆

忙的时候，发发呆

最理想的生活状态是:
>不以物喜 不以己悲

看过去的自己

太傻太天真


*****
站点更新日志:
1. 2016.03.25建站，添加多说为评论系统，使用域名`hushuangpu.xyz`；
2. 2017年`hushuangpu.xyz`域名过期，未续费，使用域名`suppermary.cc`；
3. 2017.05.15 更换评论系统为[网易云跟帖](https://manage.gentie.163.com)；
4. 2017.05.21 添加站点[https://bdznh.coding.me](https://bdznh.coding.me)，到目前为止，本站有三个分支:
    - [https://bdznh.coding.me](https://bdznh.coding.me)
    - [https://bdznh.gthub.io](https://bdznh.github.io)
    - [http://suppermary.cc](http://suppermary.cc)
5. 2017.06.26 `suppermary.cc`域名因未备案，停止解析，本站有两个分支：
    - [https://bdznh.coding.me](https://bdznh.coding.me)
    - [https://bdznh.github.io](https://bdznh.github.io)
6. 2017.07.31 [网易云跟帖](https://manage.gentie.163.com)官方停止服务，停用评论系统；
7. 2017.10.02 新增[Minecraft](../Minecraft)页面；
8. 2018.03.30 [增加文章阅读量功能](https://leaferx.online/2018/02/11/lc-security/);
9. 2019.01.17 移除站点[https://bdznh.coding.me](https://bdznh.coding.me)
]]></content>
  </entry>
  <entry>
    <title>一些小工具和项目</title>
    <url>/app/index.html</url>
    <content><![CDATA[
## GacLib
轮子哥的GUI库——[http://www.gaclib.net](http://www.gaclib.net)

## 树莓派温控风扇
[https://github.com/BDZNH/AutoControlRaspberryFan](https://github.com/BDZNH/AutoControlRaspberryFan)

## 看云
国内的GitBook托管平台——[https://www.kancloud.cn/](https://www.kancloud.cn/)

## Clappr
一个html5播放器——[https://github.com/clappr/clappr](https://github.com/clappr/clappr)

## Listary
Windows上的高速搜索软件——[http://www.listary.com/](http://www.listary.com/)

## HMCL
一个Minecraft的第三方启动器——[https://github.com/huanghongxun/HMCL](https://github.com/huanghongxun/HMCL)

## h5ai
依赖于PHP的优秀文件服务器——[https://larsjung.de/h5ai/](https://larsjung.de/h5ai/)

## aria2c
下载器，用处多多——[https://github.com/aria2/aria2](https://github.com/aria2/aria2)

## EasyX
一个很简单的GUI库——[http://www.easyx.cn/](http://www.easyx.cn/)
优点：很简单
缺点：很简单

## PuTTY
Windows上的ssh客户端——[https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)
中文版PuTTY——[https://github.com/larryli/PuTTY](https://github.com/larryli/PuTTY)
如果你想用VS2017去编译或者查看代码，可以前往[https://github.com/larryli/PuTTY](https://github.com/larryli/PuTTY)

## Fluter 教程
翻译和制作中的 Flutter 教程(书): [https://github.com/flutterchina/flutter-in-action](https://github.com/flutterchina/flutter-in-action)
]]></content>
  </entry>
  <entry>
    <title>tags</title>
    <url>/tags/index.html</url>
    <content><![CDATA[]]></content>
  </entry>
</search>