Android Display/Graphics相关模块绘制的自绘UML图整合（部分流程图参考非最新AOSP）

绘制序列图

文章：Android HWUI绘制流程-绘制序列图

Android 图形显示框架

显示框架概述

文章：Android 图形显示框架-显示框架概述）

窗口移除序列图

文章：Android 图形显示框架-窗口移除序列图（Activity destroy）

Surface Destroy（Activity pause或者stop状态）

文章：Android 图形显示框架-Surface Destroy（Activity pause或者stop状态）

surface创建序列图

文章：Android 图形显示框架-surface创建序列图

BufferQueue序列图

dequeuebuffer & queuebuffer

文章：Android 图形显示框架-dequeuebuffer & queuebuffer

acquire & release

文章：Android 图形显示框架-acquire & release

SurfaceFlinger进程启动

SurfaceFlinger工作流程

SurfaceFlinger onFrameAvailble类关系图

Angle流程图

Angle是一款专为Android平台设计的，敏捷且适合快速开发的2D游戏引擎，基于OpenGL ES技术开发。具体流程后续文章整理。

C++11/14/17/20部分新的特性语法

C++11被弃用的主要特性

char修饰符

不再允许字符串字面值常量赋值给一个char *。如果需要用字符串字面值常量赋值和初始化一个char *,应该使用const char * 或者auto

char *str = "hello world!"; // 将出现弃用警告

• • auto，不指定变量类型，编译器将把变量的类型设置成和初始值相同
• • const，限定符

PS：另一个限定符Volatile关键词，易变的。所谓的易变性，在汇编层面反映出来，就是两条语句，下一条语句不会直接使用上一条语句对应的volatile变量的寄存器内容，而是重新从内存中读取。

智能指针之unique_ptr

auto_ptr被弃用,应使用unique_ptr

C++11提供了3种智能指针类型，它们分别由unique_ptr类、shared_ptr类和weak_ptr 类定义，所以又分别称它们为独占指针、共享指针和弱指针（均定义在头文件#include <memory>）

智能指针是一个可以像指针一样工作的对象，但是当它不再被使用时，可以自动删除动态分配的内存。智能指针背后的核心概念是动态分配内存的所有权。

智能指针背后的核心概念是动态分配内存的所有权。智能指针被称为可以拥有或管理它所指向的对象。当需要让单个指针拥有动态分配的对象时，可以使用独占指针。对象的所有权可以从一个独占指针转移到另一个指针，其转移方式为：对象始终只能有一个指针作为其所有者。当独占指针离开其作用域或将要拥有不同的对象时，它会自动释放自己所管理的对象。

共享指针将记录有多少个指针共同享有某个对象的所有权。当有更多指针被设置为指向该对象时，引用计数随之增加；当指针和对象分离时，则引用计数也相应减少。当引用计数降低至0时，该对象被删除。

智能指针实际上是一个对象，在对象的外面包围了一个拥有该对象的普通指针。这个包围的常规指针称为裸指针。

move()函数

C++ 提供了一个move()库函数，可用于将对象的所有权从一个独占指针转移到另外一个独占指针：

1
2
3
4
5

unique_ptr<int> uptr1(new int); //定义并初始化
*uptr1 = 15;  //赋值
unique_ptr<int> uptr3; // 正确
uptr3 = move (uptr1) ; // 将所有权从 uptr1 转移到 uptr3
cout << *uptr3 << endl; // 打印 15

函数传参

不能直接通过值给函数传递一个智能指针，因为通过值传递将导致复制真正的形参。如果要让函数通过值接收一个独占指针，则在调用函数时，必须对真正的形参使用move()函数：

结果将打印来自于函数fun()中的10

1
2
3
4
5
6
7
8
9
10
11

//函数使用通过值传递的形参
void fun(unique_ptr<int> uptrParam)
{
    cout << *uptrParam << endl;
}
int main()
{
    unique_ptr<int> uptr(new int);
    *uptr = 10;
    fun (move (uptr)); // 在调用中使用 move
}

如果通过引用传递的方式，那就不必对真正的形参使用move()函数了。示例代码如下：

结果将打印数字15：

1
2
3
4
5
6
7
8
9
10
11

//函数使用通过引用传递的值
void fun(unique_ptr<int>& uptrParam)
{
    cout << *uptrParam << endl;
}
int main()
{
    unique_ptr<int> uptr(new int);
    *uptr1 = 15;
    fun (uptr1) ; //在调用中无须使用move
}

make_unique()函数创建对象

从C++14开始，有一个库函数make_unique<T>()可用于创建unique_ptr对象。该函数分配一个类型为T的对象，然后返回一个拥有该对象的独占指针。例如：

unique_ptr<int> uptr(new int);

现在可以替换成：

unique_ptr<int> uptr = make_unique<int>();

unique_ptr 类的成员函数

register关键字弃用

register关键字被弃用,可以使用但不再具备任何实际含义

bool类型的++操作弃用

bool类型的++操作被弃用

noexcept

C++98异常说明、unexpected_handler、set_unexpected() 等相关特性被弃用,应该使用noexcept

C++11新标准引入的noexcept运算符，可以用于指定某个函数不抛出异常。预先知道函数不会抛出异常有助于简化调用该函数的代码，而且编译器确认函数不会抛出异常，它就能执行某些特殊的优化操作。

1
2

void func(int x) noexcept;  //不抛出异常
void func1(int x);  //抛出异常

noexcept可以接受一个可选的实参，该参数必须能转换为bool类型:

1
2

void func(int x) noexcept(true);  //不抛出异常
void func(int x) noexcept(false); //抛出异常

C语言风格的类型转换被弃用

即在变量前使用(convert_type),应该使用static_cast、reinterpret_cast、const_cast、dynamic_cast来进行类型转换

为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C++对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

这四个关键字的语法格式都是一样的：

xxx_cast<newType>(data)

老式的C语言转换类型（已弃用）：

1
2

double scores = 95.5;
int n = (int)scores;

C++新风格：

1
2

double scores = 95.5;
int n = static_cast<int>(scores);

static_cast关键字

static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

static_cast（静态转换）只能用于良性转换，转换风险较低，例如：

• 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型等；
• void指针和具体类型指针之间的转换，例如void *转int *、char *转void *等；
• 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如double转Complex（调用转换构造函数）、Complex转double（调用类型转换函数）

static_cast不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

1. 两个具体类型指针之间的转换，例如int *转double *、Student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用A类型的指针指向B类型的数据后，会按照A类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。
2. int和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件
3. static_cast也不能用来去掉表达式的const修饰和volatile修饰。换句话说，不能将const/volatile类型转换为非const/volatile类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

    #include <iostream>
    #include <cstdlib>
    using namespace std;
    class Complex{
    public:
        Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
    public:
        operator double() const { return m_real; }  //类型转换函数
    private:
        double m_real;
        double m_imag;
    };
    int main(){
        //下面是正确的用法
        int m = 100;
        Complex c(12.5, 23.8);
        long n = static_cast<long>(m);  //宽转换，没有信息丢失
        char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
        int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
        void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
        double real= static_cast<double>(c);  //调用类型转换函数
       
        //下面的用法是错误的
-        float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
-        p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型
        return 0;
    }

const_cast关键字

const_cast用来去掉表达式的const修饰或volatile修饰。换句话说，const_cast就是用来将const/volatile 类型转换为非const/volatile类型。

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>
using namespace std;
int main(){
    const int n = 100;
    //&n用来获取n的地址，它的类型为const int *，必须使用const_cast转换为int *类型后才能赋值给 p
    //由于p指向了n，并且n占用的是栈内存，有写入权限，所以可以通过p修改n的值
    int *p = const_cast<int*>(&n);
    *p = 234;
    cout<<"n = "<<n<<endl;
    cout<<"*p = "<<*p<<endl;
    return 0;
}

reinterpret_cast关键字

reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高

不建议使用

dynamic_cast关键字

dynamic_cast用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助RTTI进行检测，所有只有一部分能成功。

dynamic_cast与static_cast是相对的，dynamic_cast是“动态转换”的意思，static_cast是“静态转换”的意思。dynamic_cast会在程序运行期间借助 RTTI进行类型转换，这就要求基类必须包含虚函数；static_cast在编译期间完成类型转换，能够更加及时地发现错误。

dynamic_cast的语法格式为：

dynamic_cast <newType> (expression)

常量nullptr

nullptr出现的目的是为了替代NULL。在某种意义上来说,传统C++会把NULL、0视为同一种东西,这取决于编译器如何定义NULL,有些编译器会将NULL定义为((void*)0),有些则会直接将其定义为0

C++不允许直接将void *隐式转换到其他类型。但如果编译器尝试把NULL定义为((void*)0)

例如：

1
2
3
4
5
6
7
8

void foo(char*);
void foo(int);

//无法通过编译，将会去调用 foo(int),从而导致代码违反直觉
foo(NULL);

//调用foo(char*)
foo(nullptr);

为了解决这个问题，C++11引入了nullptr关键字,专门用来区分空指针、0。

而nullptr的类型为nullptr_t，能够隐式的转换为任何指针或成员指针的类型,也能和他们进行相等或者不等的比较。

因此NULL不同于0与nullptr。所以,请养成直接使用nullptr的习惯

常量constexpr

C++本身已经具备了常量表达式的概念,比如1+2,3*4这种表达式总是会产生相同的结果并且没有任何副作用。如果编译器能够在编译时就把这些表达式直接优化并植入到程序运行时,将能增加程序的性能

C++11 提供了 constexpr 让用户显式的声明函数或对象构造函数在编译期会成为常量表达式

**

if/switch变量声明强化

在传统C++中,变量的声明虽然能够位于任何位置,甚至于for语句内能够声明一个临时变量int,但始终没有办法在if和switch语句中声明一个临时的变量。

C++17消除了这一限制,使得我们可以在if(或switch)中完成这一操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
std::vector<int> vec = {1, 2, 3, 4};

//在c++17之前
const std::vector<int>::iterator itr = std::find(vec.begin(), vec.end(), 2);
if (itr != vec.end()) {
*itr = 3;
}
// 需要重新定义一个新的变量
const std::vector<int>::iterator itr2 = std::find(vec.begin(), vec.end(), 3);
if (itr2 != vec.end()) {
*itr2 = 4;
}

//*****************
//C++17
// 将临时变量放到 if 语句内
if (const std::vector<int>::iterator itr = std::find(vec.begin(), vec.end(), 3);
itr != vec.end()) {
*itr = 4;
}
.....
}

decltype

decltype关键字是为了解决auto关键字只能对变量进行类型推导的缺陷而出现的。它的用法和typeof很相似:

decltype(表达式)

有时候,我们可能需要计算某个表达式的类型,例如:

1
2
3

auto x = 1;
auto y = 2;
decltype(x+y) z;

if constexpr

C++11引入了constexpr关键字,它将表达式或函数编译为常量结果。

如果我们把这一特性引入到条件判断中去,让代码在编译时就完成分支判断,岂不是能让程序效率更高?

C++17将constexpr这个关键字引入到if语句中,允许在代码中声明常量表达式的判断条件

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include <iostream>
//函数模板
template<typename T>
auto print_type_info(const T& t) {
if constexpr (std::is_integral<T>::value) {
    return t + 1;
} else {
    return t + 0.001;
}
}

int main() {
std::cout << print_type_info(5) << std::endl;
std::cout << print_type_info(3.14) << std::endl;
}

在编译时，实际代码会表现为：

1
2
3
4
5
6
7
8
9
10
11
12

int print_type_info(const int& t) {
return t + 1;
}

double print_type_info(const double& t) {
return t + 0.001;
}

int main() {
    std::cout << print_type_info(5) << std::endl;
    std::cout << print_type_info(3.14) << std::endl;
}

区间for迭代

C++11引入了基于范围的迭代写法,我们能够写出像Python一样简洁的循环语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    //std::find可用于查找容器中是否存在某个特定值
    if (auto itr = std::find(vec.begin(), vec.end(), 3); itr != vec.end()) *itr = 4;

    for (auto element : vec)
        std::cout << element << std::endl; // read only
    for (auto &element : vec) {
        element += 1;       // writeable
}

for (auto element : vec)
    std::cout << element << std::endl; // read only
}

外部模板

C++模板的哲学在于将一切能够在编译期处理的问题丢到编译期进行处理,仅在运行时处理那些最核心的动态服务,进而大幅优化运行期的性能。

传统C++中,模板只有在使用时才会被编译器实例化。换句话说,只要在每个编译单元(文件)中编译的代码中遇到了被完整定义的模板,都会实例化。这就产生了重复实例化而导致的编译时间的增加。并且,我们没有办法通知编译器不要触发模板的实例化。

为此,C++11引入了外部模板,扩充了原来的强制编译器在特定位置实例化模板的语法,使我们能够显式的通知编译器何时进行模板的实例化:

1
2
3

template class std::vector<bool>;
// 强行实例化
extern template class std::vector<double>; // 不在该当前编译文件中实例化模板

参考

• 书籍：《现代C++教程：高速上手 C++11/14/17/20》
• C++智能指针unique_ptr详解
• C++函数传参三种形式（包含形参与实参）
• C++11：noexcept关键字
• C++四种类型转换运算符：static_cast、dynamic_cast、const_cast和reinterpret_cast
• C/C++ Volatile关键词深度剖析

android display/graphics相关的调试方法和优化工作效率技巧整理

RenderThread渲染绘制（结合systrace）

参考：Android Systrace 基础知识(7) - Vsync 解读
参考：BufferQueue 学习总结（内附动态图）
参考：android 判断list里有这条数据_Android图形渲染原理（中）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

----
frameworks/base/libs/hwui/renderthread   -- DrawFrameTask::drawFrame()   ----->
DrawFrameTask::postAndWait()   ---->
DrawFrameTask::run()    ----->
(1) DrawFrameTask::syncFrameState  同步Frame的State  ---->
CanvasContext::prepareTree
(2) context->draw()   绘制    ------>
frameworks/base/libs/hwui/renderthread  -- CanvasContext::draw()   ---->
----
(1) frameworks/base/libs/hwui/pipeline/skia  -- SkiaOpenGLPipeline::getFrame()  ---->
frameworks/base/libs/hwui/renderthread/EglManager.cpp - EglManager::beginFrame ---->
(1.1)EglManager::makeCurrent  ----->
frameworks/native/opengl/libs/EGL/eglApi.cpp -- eglMakeCurrent --->
frameworks/native/libs/nativewindow/ANativeWindow.cpp -- ANativeWindow_dequeueBuffer ---->
frameworks/native/libs/gui/Surface.cpp -- Surface::dequeueBuffer (`systrace: HWC release`)

(1.2)EglManager::queryBufferAge
----
(2) SkiaOpenGLPipeline::draw()   ---->
(2.1) EglManager::damageFrame
(2.2) SkiaPipeline::renderFrame (`systrace:flush commands` 后调用，systrace显示在后)[--->SkiaPipeline::renderOverdraw]  --->
SkiaPipeline::renderFrameImpl (先调用，systrace显示在前)  --->
RenderNodeDrawable::onDraw  ---->
RenderNodeDrawable::forceDraw  [------>RenderNodeDrawable::drawBackwardsProjectedNodes] ----> 
RenderNodeDrawable::drawContent   ---->
RenderNodeDrawable::setViewProperties (`systrace:alpha caused saveLayer`)
----
(3) SkiaOpenGLPipeline::swapBuffers   ----->
frameworks/native/opengl/libs/EGL/eglApi.cpp -- eglSwapBuffersWithDamageKHR   ---->
frameworks/native/libs/nativewindow/ANativeWindow.cpp -- ANativeWindow_queueBuffer  --->
frameworks/native/libs/gui/Surface.cpp -- Surface::queueBuffer  (`systrace: gpu completion`绘制完成)

合成送显流程

Android Q，非最新AOSP流程，有变动

SurfaceFlinger模块

1
2
3
4
5
6
7
8
9
10

SurfaceFlinger::handleMessageRefresh();
  preComposition();
  rebuildLayerStacks();
  calculateWorkingSet();
  doComposition();
    doDisplayComposition();
    postFramebuffer();
      HWComposer::presentAndGetReleaseFences();
        HWC2::Display::present();
          Composer::presentDisplay();

HWC模块

1
2
3
4
5
6
7
8
9
10
11

HWCSession::PresentDisplay();
  HWCDisplayBuiltIn::Present();
    HWCDisplayBuiltIn::CommitLayerStack();
      HWCDisplay::CommitLayerStack();
        DisplayBuiltIn::Commit();
          DisplayBase::Commit();
            HWPeripheralDRM::Commit();
               HWDeviceDRM::Commit();
                 HWDeviceDRM::AtomicCommit();
                   DRMAtomicReq::Commit();
                     drmModeAtomicCommit();

DRM模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

msm_atomic_commit();
  msm_atomic_commit_dispatch();
    kthread_queue_work(commit->commit_work);
 
_msm_drm_commit_work_cb();
  complete_commit();
    drm_atomic_helper_commit_planes();
      sde_crtc_atomic_begin();
        _sde_crtc_setup_mixers();
        _sde_crtc_blend_setup();
          _sde_crtc_blend_setup_mixer();
            _sde_crtc_setup_blend_cfg(); // blend_op
        _sde_crtc_dest_scaler_setup();
      sde_plane_atomic_update();
        sde_plane_sspp_atomic_update();
      sde_crtc_atomic_flush();
        sde_plane_flush();
    msm_atomic_helper_commit_modeset_enables();
      sde_crtc_enable();
      sde_encoder_virt_enable();
        sde_encoder_resource_control(SDE_ENC_RC_EVENT_KICKOFF);
        _sde_encoder_virt_enable_helper();
          hw_mdptop->ops.reset_ubwc();
          hw_ctl->ops.setup_intf_cfg_v1();
          _sde_encoder_update_vsync_source();
            sde_encoder_phys_cmd_setup_vsync_source();
              sde_hw_intf_vsync_sel();
          sde_encoder_control_te();
            sde_encoder_phys_cmd_connect_te();
              sde_hw_intf_connect_external_te();
      sde_kms_commit();
        sde_crtc_commit_kickoff();
          sde_encoder_prepare_for_kickoff();
      drm_bridge_enable();
        dsi_bridge_enable();
    msm_atomic_wait_for_commit_done();
      sde_kms_wait_for_commit_done();
        sde_encoder_wait_for_event(MSM_ENC_COMMIT_DONE);
        sde_crtc_complete_flip();
          drm_crtc_send_vblank_event();

Fence同步机制

DummySwSyncTimeline CreateDummyFence()创建软件模拟fence

核心只有两件事情：

1. sw_sync_fence_create 创建一个软件模拟的fence
2. sw_sync_timeline_inc sync_timeline 时间轴向后推一个时间同步点

BufferSlot对应的BufferItem中的mFence对象就是Fence类，最后会在setUpHwcComposer中prepareFrame设置到Hal中

在Android Framework中有一个用于操作fence同步栅的类（libsync中sync_wait类）

Google平台帧率切换

参考：Android UI架构四、五
参考：Android UI架构十、十一

关键函数：

• setFrameRate

• getRefreshRate

• app: 用于接收vsync信号并且上报给App进程，App开始画图 属性名：VSYNC_EVENT_PHASE_OFFSET_NS

• sf: 用于SurfaceFlinger接收vsync信号用于渲染 属性名：SF_VSYNC_EVENT_PHASE_OFFSET_NS

磁盘空间占满100%

1. 使用命令 sudo du -sh * 查看各个目录的占内存情况，使用du -h -x --max-depth=1查看哪个深度1的目录占用过高
2. 如果发现/usr/local/tomcat的目录占用的磁盘空间特别大,则进入该目录，发现logs的目录特别大,Tomcat的日志太大,可以将其删除。比如本地电脑发现~/.cache/vmware目录下的drag_and_drop文件很大，这是因为虚拟机和主系统之间每次拖拉文件，都会生成一个复制文件，造成该文件越来越大，可以删除。
3. 再使用df -h发现磁盘空间

Android设备分辨率、密度以及dp的理解

参考：Android设备分辨率、密度以及dp的理解
参考：UI设计师不可不知的安卓屏幕知识

• dpi计算方法：

1. 分辨率的平方和开方（勾股定理） adb shell wm size
2. 然后除以屏幕的物理英寸，即是dpi

adb shell wm density可以查看当前的dpi（一般有的手机会在计算的结果上调整）

• dp计算方法（开发者选项最小宽度dp）

1.在安卓中，系统密度为160dpi的中密度手机屏幕为基准屏幕，即320×480的手机屏幕。在这个屏幕中，1dp=1px
2.分辨率的宽高分别除以dpi，获取到sw320dp,h533dp值

可通过adb shell dumpsys window查看到

低内存分析方向和技巧

参考：Android ANR基本Log分析

参考：Android 系统内存耗用：VSS/RSS/PSS/USS 的介绍

dumpsys meminfo:

1
2
3
4
5
6
7
8
9

Total RAM: 2,697,524K (status normal)
 Free RAM: 1,063,563K (  252,355K cached pss +   717,200K cached kernel +         0K cached ion +    94,008K free)
      ION:   189,688K (    7,624K mapped +   182,064K unmapped +         0K pools)
 totalSwapPss:   775,324K kernelCached:   272,476K
 Used RAM: 2,677,904K (2,090,100K used pss +   587,804K kernel)
 Lost RAM:   -23,995K
     ZRAM:   200,100K physical used for   669,848K in swap (1,572,860K total swap)
   Tuning: 128 (large 512), oom   322,560K, restore limit   107,520K (high-end-gfx)
--------- 14.816s was the duration of dumpsys meminfo, ending at: 2021-01-05 16:09:23

查看进程占用内存情况

adb shell procrank

1
2
3
4

  PID       Vss      Rss      Pss      Uss     Swap    PSwap    USwap    ZSwap  cmdline
 1195  9776476K  509716K  228733K  166648K    3748K     405K     352K      78K  system_server
 5466  7005964K  351036K  139327K  123836K    3404K      53K       0K      10K  com.android.systemui
.....

• VSS： 一个进程总共可访问的地址空间。其大小还包括了可能不在RAM中的内存（比如虽然malloc分配了空间，但尚未写入）。 VSS 很少被用于判断一个进程的真实内存使用量
• RSS： 一个进程在RAM中真实存储的总内存。仅仅表示该进程所使用的所有共享库的大小，而不管有多少个进程使用该共享库，该共享库仅被加载到内存一次。所以RSS并不能准确反映单进程的内存占用情况
• PSS： 按比例表示使用的共享库。系统中所有进程的PSS都相加的话，就刚好反映了系统中的总共占用的内存。而当一个进程被销毁之后， 其占用的共享库那部分比例的PSS，将会再次按比例分配给余下使用该库的进程
• USS： 进程所占用的私有内存（内存泄漏的最佳观察数据）。不包含so库占用内存的

ubuntu查看公网ip

三种方法：

1. curl www.icanhazip.com
2. curl ifconfig.me
3. curl -4sSkL https://myip.ipip.net

查看视频解码的分辨率及对应的帧率支持

日志关键词MediaCodec

配置文件：/vendor/etc/media_codecs.xml

linux和windows书签同步

about:config网址搜索sync：

• identity.sync.tokenserver.uri：

修改：

• linux：https://sync.firefox.com.cn/token/1.0/sync/1.5

• windows：https://token.services.mozilla.com/1.0/sync/1.5

getService配置权限

首先getService获取服务，紧接着就是getTransport的接口调用。如果在配置文件里面没找到我们所要求的服务，就会报错并结束服务的获取

• 首先会去system/etc/vintf/manifest.xml文件去找我们调用者的服务名，如果找到就返回。
• 如果没找到就会去vendor/etc/vintf/manifest.xml文件去找，如果找到就返回。如果没找到则返回NULLPRT。同时打印Cannot find entry xxx in either framework or device manifest.

所以，如果碰到这样的log，首先要去检测这两个文件里面有没有配置我们调用的服务，没有就要自己配置。

一般是没有配置引起的，当然也有可能是xml增加的语法有问题，比如格式对齐等。

HIDL编写/升级流程

参考：VINTF
参考：VINTF简介
参考：供应商接口对象

总体流程:

1. 创建HIDL接口文件XXX.hal：HIDL为每个HAL模块设计了不同接口定义hal文件，以.hal结尾，在hidl-gen工具的帮助下即可自动编译生成对应接口C++实现或者Java实现
2. hidl-gen生成interface hash, 添加至current.txt
3. hidl-gen生成接口,更新接口, XXX.bp, XXX.mk等
4. 更新vendor manifest文件：对于TA开发来说, 底层TA是服务提供者(需求提供者), 因此提供的是manifest(vendor), 将vintf/manifests.xmlpush到设备端:adb push manifest.xml /vendor/etc/vintf；system(framwork是发起需求者,需要设什么样的需求), 这部分内容在新平台上也在vintf/manifests.xml，push到设备端:adb push compatibity.device.xml /system/etc/vintf
5. 更新fcm(matrix)，即compatibility matrix XML编写：manifest文件描述了提供给对方的feature, Matrix描述了需要对方提供什么样的feature. Manifest和Matrix在OTA升级之前会进行匹配检查, 确保framework和device是兼容的, 总的来说,manifest是feature提供端, matrix是feature需求端

• 关于compatibility Matrices：
• • framework compatibility matrix：描述了framwork对device的需求, 这个matrix文件是和system.img关联的, 这些需求需要被device manifest支持
• • device compatibility matrix：描述了device对framework的需求

1
2
3
4
5
6
7
8
9
10
11
12

//xml manifest语法
<manifest version="1.0" type="device">   //version: 必选, manifest的主版本号；type: 必选, manifest的类型,属于vendor,值为device; 属于system,值为framework
    <hal format="hidl">    //hal:可选,可以存在多个,代表HAL(HIDL或者native); format:可选, 值为hidl(默认),或者native,分别代表HIDL和native HALS
        <name>vendor.android.hardware.test</name>  // name 必选, 代表HAL的合规包名
        <transport>hwbinder</transport>  // 和format有关,format的值是hidl时，就是必选的，否则不必存在.申明了当这个包的接口被service manager查询时将使用何种transport方式
                                         // 可以是hwbinder,代表绑定式hidl, 也可以是passthrough: 代表直通式hide
        <version>1.1</version>  //必选, 代表当前hidl的版本号
        <interface>             // 必选的,可以多个但是不能重复,声明了一个含有实例的接口
            <name>ITestService</name> //必选  接口实例的名字
            <instance>default</instance> //必选,不可重复
        </interface>
        .....

结构层级:

1
2
3
4
5
6
7
8
9
10

manifest:version  type //这一层级申明当前manifest
|--hal format 第二层级
    |--name
    |--transtport
    |--version
    |-- interface
      |-- name
      |-- instance
|--sepolicy
  |--version

6. 启动服务:首先需要将生成的库文件和服务守护进程分别push到设备端, 其次, 使用lshal查看对应的服务是否启动,如果为启动,需要查看对应的rc文件是否存在, 若不存在,则push(vendor/etc/xxx.rc), 手动启服务

• 概念：hidl接口哈希,是一种旨在防止意外更改接口,并确保接口更改经过全面审查的机制.因为HIDL接口带有版本号, 因此,接口一旦发布就bade在更改

• 布局：每个软件包根目录,都必须包含一个列出所有已经发布的HIDL接口的current.txt文件

• 使用hidl-gen添加哈希：hidl-gen生成的每个接口定义库都包含哈希，通过调用IBase::getHashChain可检索这些哈希。hidl-gen 编译接口时，会检查HAL软件包根目录中的current.txt 文件，以查看HAL是否已被更改

• • 如果没有找到HAL的哈希，则接口会被视为未发布（处于开发阶段），并且编译会继续进行
• • 如果找到了相应哈希，则会对照当前接口对其进行检查

如果接口与哈希匹配，则编译会继续进行

如果接口与哈希不匹配，则编译会暂停，因为这意味着之前发布的接口会被更改

如要进行保留ABI的更改（ABI稳定性），必须先修改current.txt文件，然后编译才能继续进行

所有其他更改都应在接口的minor或major版本升级中进行

Tips：

• 查看HIDL编写的hal服务是否启动：adb shell lshal

7. 重启

ssk-key生成current.txt hash值

1
2
3
4

$ hidl-gen -L hash -r vendor.....Testservice（service名称）:/vendor/.../interfaces/Testservice（路径） -r android.hidl:system/libhidl/transport vendor...Testservice@1.0

e147fb59c6ffd19c8ea7345423e6b99d8d450e6078ff40367122a9c4ee005da5 vendor...Testservice@1.0::types
8f202376e0d66fa4c9448d71415993994de99150b7326e32ac5a04b4b94aec09 vendor....Testservice@1.0::ITestQservice

修改git remote -v的orign源

1. git remote -v查看远程提交信息
2. git remote rm origin删除
3. 添加：git remote add origin (正确的信息)ssh://..../platform/frameworks/native
4. git remote -v查看，如果push未修改成功没有关系
5. 提交代码，记得加上-u选项：git push -u orign master

git报错无法push（不建议使用）

报错信息：

1
2

fatal: Unpack error, check server log
error: remote unpack failed: error Missing tree 7d3329b06421654faca962eab6cb6f9da6b47b9f

使用：git push --no-thin origin dev

git commit修改作者名称

git commit --amend --author="wizzie <wizzie@test.com>"

gerrit拉取Andorid指定模块代码

1. repo init
2. gerrit提交代码的界面projects里面搜索要拉取的指定模块
3. 复制git clone然后本地执行
4. git branch -a查看所有分支，然后git checkout 分支名（不包含orign/master）
5. git pull

ubuntu命令查看dns

nm-tool

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

- Device: eth0  [Auto Ethernet] ------------------------------------------------
  Type:              Wired
  Driver:            e1000e
  State:             connected
  Default:           yes
  HW Address:        ...:5D

  Capabilities:
    Carrier Detect:  yes
    Speed:           1000 Mb/s

  Wired Properties
    Carrier:         on

  IPv4 Settings:
    Address:         ....241
    Prefix:          24 (255.255.255.0)
    Gateway:         ....1

    DNS:             ....74
    DNS:             ....75
    DNS:             ....73

markdown数学公式语法

参考：Markdown数学公式语法

• 行内公式：将公式插入到本行内，符号：$公式内容$，如：$xyz$

• 独行公式：将公式插入到新的一行内，并且居中，符号：$$公式内容$$，如：$$xyz$$

• 上标符号，符号：^，如：$x^4$

• 下标符号，符号：_，如：$x_1$

• 组合符号，符号：{}，如：${16}{8}O{2+}{2}$

安装adb和fastboot

sudo apt-get install android-tools-adb

sudo apt-get install android-tools-fastboot

或者使用Android SDK/platform-tools

针对image编译

1. 编译所有image

1
2
3

source build/envsetup.sh
lunch XX-userdebug
./build.sh dist -j4

2. 编译system.img，生成在qssi目录下

1
2
3

source build/envsetup.sh
lunch xx-userdebug
./build.sh dist qssi_only -j4

3. 编译super.img

1
2
3

source build/envsetup.sh
lunch xx-userdebug
./build.sh dist merge_only -j4

4. 编译其它img，例如vendorimage（如果不指定会编译其它所有img）

1
2
3

source build/envsetup.sh
lunch xx-userdebug
./build.sh vendorimage dist target_only -j4

安装APK报错

如果安装APK报错，控制台输出如下：

1
2
3

$ adb install test.apk
5451 KB/s (635477 bytes in 0.113s)
Failure [INSTALL_FAILED_UPDATE_INCOMPATIBLE: Package com.debug.test signatures do not match previously installed version; ignoring!]

需要先删除原先的APK，并且清楚缓存，重启：

1
2
3
4
5
6
7
8
9
10
11
12

adb shell dumpsys activity top|grep ACTIVITY
adb shell pm path com.debug.test

//删除卸载原APK
adb shell rm -rf ***

//清楚缓存
adb shell pm clear com.debug.test
adb reboot

//再次安装新的APK
adb install test.apk

查看当前前台app包名（实时）

adb shell dumpsys window | grep mCurrentFocus

监控设备实时获取当前的包名

adb shell am monitor

APP增加多国语言

参考：让App支持不同的语言
参考：语言代码
参考：Android多语言支持以及各国语言Values文件夹命名规则

1. 目录在：res/values-***
2. 将各个语言区域的字符串值添加到相应文件中。在运行时，Android 系统会根据当前为用户设备设置的语言区域使用相应的字符串资源集的
3. 如需添加对更多语言的支持，在res/目录下创建名称末尾不同的values，其中目录末尾ISO语言代码则对应着相应语言，譬如：values-fr则代表着手机系统语言为法语时读取的目录

例如：

• 英语（默认语言区域），/values/strings.xml
• 中文，/values-zh/strings.xml
• 法语，values-fr/strings.xml

native crash分析

使用addr2line命令定位堆栈地址：

1
2

/out/target/product/product/symbols/system/lib64$ addr2line -f -e libgui.so 00000000000c39a0
_ZNK7android12SortedVectorINS_12DisplayStateEE16do_move_backwardEPvPKvm

解释：-e后加上.so的文件名；-f可同时输出函数名称

分析工具：

• addr2line：addr2line –e obj/local/armeabi/libhello-jni.so 00004de8, 用来分析单个pc地址对应的源码行数
• objdump：objdump –S obj/local/armeabi/libhello-jni.so > hello.asm,或者symbols/out/target/product/merlin/symbols$ objdump -tT system/lib64/libdisplayfeature.so 用来把相应的so变成汇编语言的asm文件，然后根据地址信息（比如00000000000c39a0）就可以找到更加详细的相关函数信息；
• ndk-stack：用来把log信息全部翻译成更加详细的带源码行数信息的log，相当于是在整个crash堆栈信息都执行addr2line命令。

addr2line -Cef .so address

或者：

1. 可以使用readelf -a [.so/.bin]解析库地址
2. 根据解析结果查询函数，C++在linux系统编译后会变成类似_ZNK...的修饰名。使用c++filt获取函数的原始名称：

c++filt [_ZNK...函数修饰名]

YUV数据查看

1. 从ffmpeg官网：http://ffmpeg.org/download.html下载最新的ffmpeg安装包，然后通过如下命令解压：
   tar jxf ffmpeg-2.5.3.tar.bz2
2. 查看YUV：
   ffplay -f rawvideo -video_size 1280x800 raw_1280x800_1878.yuv

或者使用YUVPlayer工具，执行：

wine yuvplayer.exe

YUV Player工具获取：

• https://github.com/Yonsm/RawPlayer RawPlayer
• https://github.com/latelee/YUVPlayer YUVPlayer
• https://github.com/figgis/yuv-viewer yuv-viewer
• https://github.com/Luomingbear/YuvPlayer android yuv播放器 SDL

关闭硬件加速

三种不同针对对象的方法：

1. 在AndroidManifest.xml中设置android:hardwareAccelerated="false"，注意关闭整个app的硬件加速，慎用
2. View有个方法支持单独的View关闭硬件加速，可以设置mView.setLaterType(View.LAYER_TYPE_SOFTWARE);
3. 关闭某一个控件的硬件加速功能：findViewById(R.id.btn).setLayerType(View.LAYER_TYPE_SOFTWARE,null);

linux绘图UML/序列图工具dia

1. 安装：sudo apt-get install dia
2. 使用，终端执行：dia

屏幕旋转/转向切换命令

1
2
3
4
5
6
7

adb root
#turn off the automatic rotation
adb shell settings put system accelerometer_rotation 0
# rotate landscape
adb shell settings put system user_rotation 1
# rotate portrait
adb shell settings put system user_rotation 0

Surface两种合成方式（dump sf）

• Client合成：Client合成方式是相对于硬件合成来说的，其合成方式是，将各个Layer的内容用GPU渲染到暂存缓冲区中，最后将暂存缓冲区传送到显示硬件。这个暂存缓冲区，我们称为FBTarget，每个Display设备有各自的FBTarget。Client合成，之前称为GLES合成，我们也可以称之为GPU合成。Client合成，采用RenderEngine进行合成

• Device合成：就是用专门的硬件合成器进行合成HWComposer，所以硬件合成的能力就取决于硬件的实现。其合成方式是将各个Layer的数据全部传给显示硬件，并告知它从不同的缓冲区读取屏幕不同部分的数据。HWComposer是Devicehec的抽象。

getprop查看当前版本是user/userdebug

adb shell getprop ro.system.build.type

getprop查看设备信息

adb shell getprop ro.build.product

滑动到边缘Pixel值调试

AOSP源码位置：/frameworks/base/core/java/com/android/internal/widget/PointerLocationView.java的onDraw函数中有ps.mCoords.x和ps.mCoords.y（float类型），可以将其打印出来，如果有问题可以修改此处转换逻辑

Input调试（PointerLocation）

systrace查看

systrace可以查看到touch点击的事件

点击input事件(up/down)

adb shell getevent -lrt

查看帮助：
adb shell getevent -h

1
2
3
4
5
6
7
8
9
10
11
12

[    1423.973137] /dev/input/event2: EV_ABS       ABS_MT_TRACKING_ID   0000003b            
[    1423.973137] /dev/input/event2: EV_ABS       ABS_MT_POSITION_X    0000017e            //十六进制转成十进制 1*16*16+7*16+14*1=382   横坐标X
[    1423.973137] /dev/input/event2: EV_ABS       ABS_MT_POSITION_Y    0000032d            //3*16*16+2*16+13*1=813  纵坐标Y
[    1423.973137] /dev/input/event2: EV_ABS       ABS_MT_TOUCH_MAJOR   0000000a            
[    1423.973137] /dev/input/event2: EV_ABS       ABS_MT_PRESSURE      000003e8            
[    1423.973137] /dev/input/event2: EV_KEY       BTN_TOUCH            DOWN                
[    1423.973137] /dev/input/event2: EV_SYN       SYN_REPORT           00000000            
[    1436.084174] /dev/input/event2: EV_ABS       ABS_MT_TOUCH_MAJOR   00000000            
[    1436.084174] /dev/input/event2: EV_ABS       ABS_MT_PRESSURE      00000000            
[    1436.084174] /dev/input/event2: EV_ABS       ABS_MT_TRACKING_ID   ffffffff            
[    1436.084174] /dev/input/event2: EV_KEY       BTN_TOUCH            UP                  
[    1436.084174] /dev/input/event2: EV_SYN       SYN_REPORT           00000000             rate 0

input和wms的debug log开关打开

1
2
3
4
5
6
7
8
9
10
11

adb root
//wns debug
adb shell dumpsys window -d enable DEBUG_FOCUS
adb shell dumpsys window -d enable DEBUG_INPUT
//或者
adb shell dumpsys window -d enable a
//input debug
adb shell setprop sys.inputlog.enabled true
adb shell setprop sys.input.TouchFilterEnable true
adb shell setprop sys.input.TouchFilterLogEnable true
adb shell dumpsys input

FPS帧率测试

查看设备的帧率：while true;do adb shell dumpsys SurfaceFlinger | grep "refresh-rate";done

获取实时帧率（主要用于获取游戏/视频应用的fps数据）

参考前面的文章：Android 两种实时获取FPS的方法

1. 查询当前的layer（直接dump sf）：adb shell dumpsys SurfaceFlinger --list
2. adb shell dumpsys SurfaceFlinger --latency SurfaceView

dump gfxinfo信息

adb shell dumpsys gfxinfo <package_name>

查看每一帧的信息：adb shell dumpsys gfxinfo <package_name> framestats

结果：

• Graphics info for pid 31148 [com.android.settings]: 表明当前dump的为设置界面的帧信息，pid为31148
• Total frames rendered: 105 本次dump搜集了105帧的信息
• Janky frames: 2 (1.90%) 105帧中有2帧的耗时超过了16ms，卡顿概率为1.9%
• Number Missed Vsync: 0 垂直同步失败的帧
• Number High input latency: 0 处理input时间超时的帧数
• Number Slow UI thread: 2 因UI线程上的工作导致超时的帧数
• Number Slow bitmap uploads: 0 因bitmap的加载耗时的帧数
• Number Slow issue draw commands: 1 因绘制导致耗时的帧数
• HISTOGRAM: 5ms=78 6ms=16 7ms=4 … 直方图数据

例如：while true;do adb shell dumpsys gfxinfo com.android.home framestat;sleep 1;done|tee swipeHome_dumpgfx.log

然后通过一秒抓一次，递减总帧数，确认每秒绘制的帧数:

• 重置：adb shell dumpsys gfxinfo com.android.home reset

• 抓取：adb shell dumpsys gfxinfo com.android.home framestats

查看帧率以及如何在systrace分析帧率

1
2
3
4
5

adb root
adb shell setprop debug.gr.calcfps 1
adb shell setprop debug.gr.calcfps.period 5
adb shell stop
adb shell start

之后可以在logcat中通过fps关键字查看帧率

Tips:

1. 该帧率为实时帧率，一个动画的首帧和尾帧存在误差，可以忽略
2. debug.gr.calcfps.period n:后面的数字n控制统计的帧数
3. 重启手机后将不再统计帧率

systrace中的Frame

在每个app进程，都有一个Frames行，正常情况以绿色的圆点表示。当圆点颜色为黄色或者红色时，意味着这一帧超过16.6ms（即发现丢帧），点击黄色或红色的Frames圆点便会有相关的提示信息；

另外，在systrace的最右侧，有一个Alerts tab可以展开，这里记录着所有的的警告提示信息；

也可以通过放大那一帧进一步分析问题。

对于Android 5.0(API level 21)或者更高的设备，该问题主要聚焦在UI Thread和Render Thread这两个线程当中

屏幕录制视频（限定时间长）

• adb shell screenrecord --time-limit 10 --verbose /sdcard/record.mp4

录屏带--bugreport调试参数：

adb shell screenrecord --bugreport /sdcard/test.mp4

截图命令

adb shell screencap /sdcard/screencap.png

dump sf查看buffer/layer列表

adb shell dumpsys SurfaceFlinger --list

dump windows/inpu/sf

1
2
3
4

adb root
adb shell dumpsys input
adb shell dumpsys window -a
adb shell dumpsys SurfaceFlinger

源码打开input debug日志开关

• frameworks/native/services/inputflinger/InputDispatcher.cpp：bool gInputLogEnabled = false;改为true
• frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.java：static final boolean DEBUG_INPUT = false;

adb打印kernel log，即内核调试信息dmsg和kmsg

Android的log信息分为内核空间和用户空间中LOG，查看用户空间（也就是app等上层的log）的log直接用adb logcat就可以

如果想过滤一些信息就用adb logcat | grep -E "log_xxx|log_aaa”命令，这样log只会显示含有log_aaa和log_xxx的log信息了。上层的log信息另行查看。

1. 执行dmesg命令，可以查看全部消息。如果想把log信息保存到文件，可以用adb shell dmesg > E:/Kernel.log (输出内核信息)

2. adb shell cat /proc/kmsg：程序里面用printk函数打印的信息会显示出来。

用cat /proc/kmsg命令打印出来的信息跟与dmesg不同。第一次执行/proc/kmsg打印到当前时间的所有内核信息，再次执行cat /proc/kmsg，不会再打印已经打印的信息，只打印上一次执行之后打印出来的新的信息。

Tips:查看kernel log时间，前面是秒，然后隔一段时间会打印android time标记日志

合并kmsg log

adb shell logcat -v time -f /dev/kmsg | adb shell cat /proc/kmsg | tee kernel_logcat.txt

• “-f”选项 : 该选向后面跟着输入日志的文件, 使用adb logcat -f /sdcard/log.txt命令, 注意这个log文件是输出到手机上，需要指定合适的路径

例如触屏inpu事件log抓取：

adb shell logcat -v threadtime -f /dev/kmsg | adb shell cat /proc/kmsg | grep -Ei "InputDispatcher|DOWN\!|Up\!|ViewRootImpl|onTouchEvent"

查看设备的白名单

• adb shell cat vendor/etc/power_whitelist_cfg.xml

代码添加示例：

1
2
3
4
5
6
7
8

//vendor/PLATFORM/proprietary/hardware/power/config/平台型号/power_whitelist_cfg.xml
        <Package name="com.android.gallery">
            <Activity name="Common">
                <PERF_RES_SCHED_BOOST_VALUE_TA Param1="10"/>
                <PERF_RES_THERMAL_POLICY Param1="8"/>
                <PERF_RES_DRAM_CM_MGR Param1="1"/>
            </Activity>
        </Package>

Android.mk和Android.bp转换语法

相互转换的定义在：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//该代码Android Q AOSP，在R之后该文件有变化
func init() {
addStandardProperties(bpparser.StringType,
map[string]string{
"LOCAL_MODULE":                  "name",
"LOCAL_CXX_STL":                 "stl",
"LOCAL_STRIP_MODULE":            "strip",
"LOCAL_MULTILIB":                "compile_multilib",
"LOCAL_ARM_MODE_HACK":           "instruction_set",
"LOCAL_SDK_VERSION":             "sdk_version",
"LOCAL_NDK_STL_VARIANT":         "stl",
"LOCAL_JAR_MANIFEST":            "manifest",
"LOCAL_JARJAR_RULES":            "jarjar_rules",
"LOCAL_CERTIFICATE":             "certificate",
"LOCAL_PACKAGE_NAME":            "name",
"LOCAL_MODULE_RELATIVE_PATH":    "relative_install_path",
"LOCAL_PROTOC_OPTIMIZE_TYPE":    "proto.type",
"LOCAL_MODULE_OWNER":            "owner",
"LOCAL_RENDERSCRIPT_TARGET_API": "renderscript.target_api",
"LOCAL_NOTICE_FILE":             "notice",
"LOCAL_JAVA_LANGUAGE_VERSION":   "java_version",
"LOCAL_INSTRUMENTATION_FOR":     "instrumentation_for",
"LOCAL_MANIFEST_FILE":           "manifest",
 
"LOCAL_DEX_PREOPT_PROFILE_CLASS_LISTING": "dex_preopt.profile",

将HIDL接口服务从设备system移到vendor

1. 修改Android.bp中添加vendor:true（或者vendor_avaiable：ture）；如果是Android.mk，则添加如下：

1
2

LOCAL_MODULE_PATH_64 = $(TARGET_OUT_VENDOR)/lib64
LOCAL_MODULE_PATH_32 = $(TARGET_OUT_VENDOR)/lib32

2. 如果有.rc文件，则需要修改其中的目录；其中class hal是不会自动启动的，所以需要将其修改成class main ；并且onrestart restart后面添加的是service名称。

可以在adb shell；cd /vendor/bin/里面手动执行bin文件，然后查看进程是否启动。

3. 在seploicy添加权限：device/PLATFORM/sepolicy/basic/non_plat/file_contexts

Android.bp（可参考）

VNDK 构建系统支持

系统将通过以下规则确定cc_library或cc_library_shared的默认安装路径：

将核心变体安装到/system/lib[64]中

供应商变体安装路径可能会有所不同：

• 如果vndk.enabled为false，则将供应商变体将安装到/vendor/lib[64]中

• 如果vndk.enabled为true，则vndk.support_system_process可以是true或false。如果：

• • 为false，则供应商变体将安装到/system/lib[64]/vndk-${VER}中
• • 为true，则供应商变体将安装到/system/lib[64]/vndk-sp-${VER}中

C函数memset(…)

函数解释：将s中当前位置后面的n个字节（typedef unsigned int size_t ）用ch替换并返回s

• memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法
• memset()函数原型：是extern void *memset(void *buffer, int c, int count)，buffer为指针或是数组，c是赋给buffer的值，count是buffer的长度

domain.te错误类型

错误日志：The following types on /vendor/ must be associated with the "vendor_file_type" attribute: ×××_exec

• 如果是system/则type ***_exec, exec_type, system_file_type, file_type;
• 如果是svendor/则type ***_exec, exec_type, vendor_file_type, file_type;

查看手机硬件设备（包含屏幕信息）

• adb shell cat proc/cmdline

ubuntu的ll命令不能使用

将ll作为一个别名：

1
2

...
+ alias ll='ls -alF''

然后执行source .bash_profile生效

ubuntu挂载硬盘

1. 查看硬盘：sudo fdisk -l

比如打印：Disk /dev/sdb: 3000.6 GB, 3000592982016 bytes

2. 编辑添加到文件：sudo vim /etc/fstab

比如打印：/dev/sdb /sunwg/ ext4 defaults 0 0 (后面的目录是挂载的目录)

3. 重启电脑，然后df -h查看系统分区

find命令

find ./ -iname "*gpuinfo*"

##　查看CPU/GPU硬件频率

• 查看CPU: adb shell "cat /proc/cpufreq/*/cpufreq_freq"
• 查看DDR: adb shell "cat /sys/devices/platform/10012000.dvfsrc/helio-dvfsrc/dvfsrc_dump | grep -e uv -e khz -e CONTROL -e VCORE_OPP -e DDR_OPP -e LEVEL -e RSV_9"
• 查看GPU频率： adb shell cat /proc/gpufreq/gpufreq_var_dump或者adb shell cat /proc/gpufreq/gpufreq_opp_dump

设置GPU频率

1
2

adb root;
adb shell "echo 1000000 > /proc/gpufreq/gpufreq_opp_freq"

☆CPU/GPU信息文件路径

CPU信息是在：/sys/devices/system/cpu
GPU的信息在如下目录查看：/sys/class/kgsl/kgsl-3d0

加大dequeuebuffer数目

有时候从systrace中看到dequeuebuffer耗时长，如果可能和gpu/cpu相关，则可以参照上面的方式对gpu/cpu进行提频；

也可以尝试修改文件：/frameworks/native/services/surfaceflinger/BufferQueueLayer.cpp

mProducer->setMaxDequeuedBufferCount(1); //增加这里值

比如修改为3，看是否有改善

windows cmd过滤log

adb logcat |find "***"

vscode插件

gitlens：可以查看提交

抓取perfetto-trace（替代systrace）

1. 打开开发者选项->系统跟踪->显示‘快捷设置’图块
   或者命令方式打开：adb shell am start com.android.traceur/com.android.traceur.MainActivity
2. 然后点击“录制跟踪记录”开始抓取
3. 点击停止后分享生成文件，或者命令导出：adb pull data/local/traces
4. 使用chrome登录perfetto-trace网站：https://ui.perfetto.dev/#!/

或者转换成html格式：

1
2
3
4
5
6

// 仅支持python 2.7 且需要GLIBC_2.28版本
curl https://get.perfetto.dev/traceconv -o traceconv

chmod +x traceconv

./traceconv [text|json|systrace|profile] [input proto file] [output file]

systrace打开空白或者打不开

在chrome地址栏中输入”chrome:tracing”，然后点击load按钮load你的trace.html文件

atrace转换到html

./systrace.py --from-file 2-1.atrace

结果文件生成2-1.html

systrace的类别和选项（直接添加）

systrace脚本来源：Android\Sdk\platform-tools\systrace

示例命令：./systrace.py -b 8000 -t 5 –list-categories="Screen turning on" hal app sched gfx view wm power binder_driver -o systrace.html

几个比较常用的模块：

• sched：CPU调度的信息，非常重要；你能看到CPU在每个时间段在运行什么线程；线程调度情况，比如锁信息
• gfx：Graphic系统的相关信息，包括SurfaceFlinger，VSYNC消息，Texture，RenderThread等；分析卡顿非常依赖这个
• view：View绘制系统的相关信息，比如onMeasure，onLayout等；对分析卡顿比较有帮助
• am：ActivityManager调用的相关信息；用来分析Activity的启动过程比较有效
• dalvik： 虚拟机相关信息，比如GC停顿等
• binder_driver：Binder驱动的相关信息，如果你怀疑是Binder IPC的问题，不妨打开这个
• core_services：SystemServer中系统核心Service的相关信息，分析特定问题用

SElinux权限相关

参考网站程序员大本营selinux

• scontext表示进程的SContext，u:r:bluetooth:s0，属于bluetooth域；
• tcontext表示目标的SContext，u:r:system_data_file:s0，属于system_data_file类型;
• tclass表示进程要操作的ObjectClass，dir表示目录；

自动生成selinux权限代码

1. 过滤avc关键词代码，导入到新文件log.txt

2. 需要安装：policycoreutils

3. 执行命令或区域权限的代码：
   cat log.txt | grep avc | audit2al

4. 命令执行后生成权限相关代码，然后进行修改，例如下面：

1
2
3
4
5

#============= mcd ==============
allow mcd sysfs_battery_supply:dir search;
allow mcd sysfs_battery_supply:file { read open };
allow mcd sysfs_batteryinfo:dir search;
...

开启/关闭Selinux权限

1
2

adb shell setenforce 0 //设置成permissive模式，临时关闭selinux
adb shell setenforce 1 //设置成enforce模式

重启后失效

使用adb shell getenforce查看当前权限状态。

可能返回结果有三种：

• Disabled代表SELinux被禁用
• Permissive代表仅记录安全警告但不阻止可疑行
• Enforcing代表记录警告且阻止可疑行为

进入fastboot

adb reboot fastboot

或者

adb reboot bootloader

LCD屏幕低温残影现象

LCD屏幕里的像素发光是由液晶偏转来控制的，而液晶这种材料对温度十分敏感，温度越低，液晶翻转的速度也就越慢，屏幕的响应速度也就会越慢。当画面已经刷新到了下一帧时，液晶还未翻转完成，新生成的画面与未消失的画面错位存在，看上去就像重影一样。

而OLED屏幕的像素点是由一个个单独控制的发光二级管所组成的，低温对其响应速度影响不大，所以单独发光的OLED的响应速度要远高于LCD屏幕。所以OLED屏幕的手机在低温下几乎不会出现拖影的问题。

此外，录屏是录取不到拖影的现象，需要拍视频才能看的到。

makefile

makefile中-D*表示：#define *

如：-DPOSGP730 等价于 #define POSGP730

亮度单位nit

nit(尼特),1nit=1坎德拉/平方米[cd/m2]

亮度(L)指物体明暗的程度,定义是单位面积的发光强度,是表示眼睛从某一方向所看到物体反射光的强度。

光学单位lux

0.1Lux是指摄像机的照度

Lux是一个光学单位，指的是每平方米的光照亮，可以理解成对光线强度的反应，在同等光线条件下，LUX越小的摄像机感光度越好。

启动activity/关闭activity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//使用Action方式打开系统设置-输入法设置
adb shell am start -a android.settings.INPUT_METHOD_SETTINGS
 
//使用组件名方式启动照相机功能
adb shell am start -n com.android.camera/.Camera
 
//打开拨号界面，并传递一个DATA_URI数据给拨号界面
am start -a android.intent.action.CALL -d tel:10086

//使用ComponentName方式启动一个Service
adb shell am startservice com.some.package.name/.YourServiceSubClassName

//关闭指定包名的应用程序 
adb shell am force-stop com.some.package

//杀死进程
adb shell am kill com.some.package

Git命令

查看代码提交历史（具体到某一行）

git blame SurfaceFlinger.cpp（文件名）

提交代码

git push origin HEAD:refs/for/×××Branch

提交草稿代码

git push origin HEAD:refs/drafts/×××Branch

提交代码、sync代码报错Agent admitted failure to sign using the key

执行：ssh-add ~/.ssh/id_rsa

apt-get报错不能进行正常更新

提示错误信息The package lists or status file could not be parsed or opened

解决方法：

1
2

sudo rm -vf /var/lib/apt/lists/*
sudo apt-get update

ubuntu自带截图快捷键

1
2
3
4
5
6
7
8
9

Alt + Print Screen #截取选中的窗口

Shift + Print Screen #自由选区

Ctrl + Print Screen  #整个桌面

Ctrl + Alt + Print Screen #选中的窗口

Shift + Ctrl + Print Screen #自由选区

gedit乱码

执行：gconftool-2 --set --type=list --list-type=string /apps/gedit-2/preferences/encodings/auto_detected "[UTF-8,CURRENT,GB18030,BIG5-HKSCS,UTF-16]"

跳过开机向导

1
2

adb shell settings put secure user_setup_complete 1
adb shell settings put global device_provisioned 1

ubuntu快速下载命令

axel -n 20 下载链接

谷歌GMS服务

GMS（Google Mobile Service），即谷歌移动服务，是Google提供的移动设备上的一系列应用服务，比如包含Play Sotre，Gmail，YouTube，Chrome，Google Maps等。
如果需要预置GMS应用，需要通过Google认证，比如CTS、GTS等跑测。

GMS测试注意事项

1. 如果升级应用到最新版本不再复现，则是应用本身的问题，Google在升级过程中已进行修补
2. 如果仍旧复现，则使用对比机器进行对比验证

常见问题

开机向导设置密码后关机再开机黑屏

修改方式：

1. 找到frameworks/base/packages/SystemUI/src/com/android/systemui/Keyguard/KeyguardViewMediator.java
2. 找到函数private void doKeyguardLocked(Bundle options)
3. 修改if (!lockedOrMissing && !provisioned && !antiTheftLocked) —> if(!lockedOrMissing && shouldWaitForProvisioning() && !antiTheftLocked)

Play Store无法正常连接

无法登陆Google账户，提示与Google服务器通信时出现问题

如果可以登录Google账户（设置添加Google账户），而不能进入Google Play，可以抓取一份log，搜索关键字CheckinTask，如果出现如下log：

E CheckinTask: Checkin failed: https://android.clients.google.com/checkin (request #0): java.io.IOException: Bad Content-Type: text/html; charset=UTF-8

就先检查系统以下属性值的设定是否存在“非法”字符：

1
2
3
4

ro.product.model
ro.product.name
ro.product.device
ro.product.board

Play Store下载应用失败

从服务器检索信息时出错 (Error retrieving information from server)

可以参考：Google Play商店的各种报错解释以及修复方法

GMS应用首次登陆闪退，第二次正常

闪退问题先Check log中是否收到PACKAGE_CHANGED的广播

查看system log，Google Maps如果有发生package changed，这是厂商的Maps版本比较旧，开机后联网情况下会自动从server升级造成process kill，属于正常的行为。关键log如下：

1
2
3

V ActivityManager: Broadcast: Intent { act=android.intent.action.PACKAGE_CHANGED dat=package:com.google.android.apps.maps flg=0x4000010 (has extras) } ordered=false userid=0 callerApp=null
I ActivityManager: Force stopping com.google.android.apps.maps appid=10060 user=0: pkg changed
I ActivityManager: Killing 6004:com.google.android.apps.maps/u0a60 (adj 0): stop com.google.android.apps.maps

GMS应用缺少部分菜单

如果系统分区太小，会拿掉一些feature，你可以尝试更大的RAM size，比如1GB或更大。

GMS部分应用联网后消失

GMS中部分应用有地域使用限制，Play Books, Play Magazine, Play Movies等应用目前不支持在中国大陆这边使用，所以联网后应用会自己屏蔽掉，此为正常现象。

包含树、二叉树、哈希表、二分查找的定义和实现

树

定义

树（Tree）是 n（n≥0）个结点的有限集 T，当 T 为空时称为空树，否则它满足以下两个条件：

1. 有且仅有一个特定的数据元素称为根（root）的结点，根结点没有前驱结点
2. 其余的结点可分为m（m＞0）个互不相交的子集Tl, T2,…, Tm，其中每个集合Ti（1≤i≤m）本身又是一棵树，并称其为根的子树（subtree）

树的递归定义刻画了树的固有特性：一棵非空树是由若干棵子树构成的，而子树又可由若干棵更小的子树构成。因此，树结构的很多算法都使用了递归方法

基本术语

1. 结点的度（degree）：结点拥有的子树数
2. 叶子（终端结点）：度为0的结点
3. 非终端结点：度不为0的结点
4. 结点的层次：树中根结点的层次为1，其子树的根为第2层，其余类推
5. 树的度：树中所有结点的最大度数
6. 树的深度：树中所有结点层次的最大值
7. 有序树、无序树：如果树中每棵子树从左向右的排列拥有一定的顺序，不得互换，则称为有序树；否则称为无序树
8. 森林：m（m≥0）棵互不相交的树的集合

在树结构中，结点之间的关系又可用家族关系描述，定义如下：

• 孩子、双亲：结点子树的根称为这个结点的孩子，而这个结点又被称为孩子的双亲（父结点、子结点）
• 子孙：以某结点为根的子树中的所有结点都被称为是该结点的子孙
• 祖先：从根结点到该结点路径上的所有结点
• 兄弟：同一个双亲的孩子之间互为兄弟
• 堂兄弟：双亲在同一层的结点互为堂兄弟

树的遍历

之所以叫前序、中序、后序遍历，是因为根节点在前、中、后

前序：根左右；中序：左根右；后序：左右根；

中序常用来在二叉搜索数中得到递增的有序序列；

后序可用于数学中的后缀表示法，结合栈处理表达式，每遇到一个操作符，就可以从栈中弹出栈顶的两个元素，计算并将结果返回到栈中；

先序遍历

首先访问根节点，然后遍历左子树，最后遍历右子树

中序遍历

先遍历左子树，然后访问根节点，然后遍历右子树。

后序遍历

先遍历左子树，然后遍历右子树，最后访问树的根节点

森林遍历

根据森林和树相互递归的定义，可推出森林的两种遍历方法：

先序遍历森林：

1. 访问森林中第一棵树的根结点；
2. 先序遍历第一棵树中根结点的子树森林；
3. 先序遍历除去第一棵树之后剩余的树构成的森林

后序遍历森林：

1. 后序遍历森林中第一棵树的根结点的子树森林；
2. 访问第一棵树的根结点；
3. 后序遍历除去第一棵树之后剩余的树构成的森林。

上面的森林进行先序遍历和后序遍历，分别得到森林的先序序列为1 23 4 5 6 7 8 9 10 11 12，后序序列为5 2 3 4 1 8 9 7 6 12 11 10

二叉树

定义

一棵二叉树（binary tree）是结点的一个有限集合，该集合或者为空，或者由一个根结点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。

五种基本形态：

性质

1. 在二叉树的第i层上至多有$2^{i-1}$个结点（i≥1）
2. 深度为k的二叉树至多有$2^{k-1}$个结点（k≥1）
3. 对任意一棵非空二叉树T，若其叶结点数为$n_0$，度为2的结点数为$n_2$，则$n_0=n_2+1$（根节点加上其他度为2的结点树）
4. 具有n个结点的完全二叉树的深度为$[log_2n]+1$

证明：设完全二叉树的深度为k，由它的定义和性质可知2k-1-1＜n≤2k-1 或2k-l≤n＜2k，取对数后有k-1≤log2n＜k，因为k是整数，所以k = log2n || +1（或者）

5. 如果将一棵有 n个结点的完全二叉树（其深度为log n||2+）自顶向下、同一1层自左向右编号为1, 2, 3,…, n，则对任意一个结点i（1≤i≤n）有：① 如果i = 1，则此结点为二叉树的根，无双亲；如果 i＞1，则其双亲结点是floor(i/2)。② 如果2i＞n，则结点 i无左孩子（结点 i 为叶子结点）；否则其左孩子是结点2i。③ 如果2i+1＞n，则结点 i 无右孩子；否则其右孩子是结点2i+1

满二叉树和完全二叉树

• 满二叉树（full binarytree）是指深度为k，且有2k-1个结点的二叉树。特点是，每一层上结点数都是最大结点数，即不存在度为1的结点

• 完全二叉树（completed binary tree）是指深度为k，有n个结点的二叉树，除最后一层外，其余层均是满的，且最下面一层的结点都集中在最左边的位置上

层序遍历

层序遍历就是逐层遍历树结构。

广度优先搜索是一种广泛运用在树或图这类数据结构中，遍历或搜索的算法。

该算法从一个根节点开始，首先访问节点本身。 然后遍历它的相邻节点，其次遍历它的二级邻节点、三级邻节点，以此类推。

当我们在树中进行广度优先搜索时，我们访问的节点的顺序是按照层序遍历顺序的。

二叉树的层序遍历实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //创建返回数组
        vector<vector<int>> ans;
        //创建队列
        queue<TreeNode*> que;
        //若空
        if(root == nullptr) return ans;
        //根节点压入队列
        que.push(root);
        //若队列不为空，循环
        while(!que.empty()){
            //当前队列长度
            int queLen = que.size();
            ans.push_back(vector<int>());
            //循环遍历当前层所有节点
            for(int i = 0; i < queLen; ++i){
                //选择节点
                auto node = que.front();
                //选择的当前节点弹出队列
                que.pop();
                //将选择的当前节点的值压入数组
                ans.back().push_back(node->val);
                //寻找当前节点的下一层节点压入队列
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return ans;
    }
};

二叉搜索树

二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性：

• 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值
• 每个节点中的值必须小于（或等于）存储在其右子树中的任何值

哈希表

哈希表是一种数据结构，它使用哈希函数组织数据，以支持快速插入和搜索

• 哈希函数：将结点的关键字与它的存储位置之间建立一种对应关系的函数称为哈希函数。
• 哈希表：根据设定的哈希函数h(key)和处理冲突的方法将一组关键字映射到一个有限的连续地址区间上，这样的表称为哈希表，这一映射过程称为哈希造表或散列，所得的存储位置称为哈希地址或散列地址
• 冲突（collision）：不同的关键字映射到同一哈希地址的现象称为冲突
• 同义词（synonym）：在一个哈希函数中，具有相同函数值的关键字，互称为同义词。

有两种不同类型的哈希表：哈希集合和哈希映射。

• 哈希集合是集合数据结构的实现之一，用于存储非重复值。
• 哈希映射是映射 数据结构的实现之一，用于存储(key, value)键值对。

在标准模板库的帮助下，哈希表是易于使用的

原理

哈希表的关键思想是使用哈希函数将键映射到存储桶。更确切地说，

• 当我们插入一个新的键时，哈希函数将决定该键应该分配到哪个桶中，并将该键存储在相应的桶中；
• 当我们想要搜索一个键时，哈希表将使用相同的哈希函数来查找对应的桶，并只在特定的桶中进行搜索。

例如我们使用$y = x ％ 5$作为哈希函数，然后完成插入和搜索策略：

• 插入：我们通过哈希函数解析键，将它们映射到相应的桶中。例如，1987分配给桶2，而24分配给桶4
• 搜索：我们通过相同的哈希函数解析键，并仅在特定存储桶中搜索。如果我们搜索 1987，我们将使用相同的哈希函数将1987 映射到 2。因此我们在桶 2 中搜索，我们在那个桶中成功找到了 1987。例如，如果我们搜索23，将映射23到3，并在桶3中搜索。我们发现23不在桶3中，这意味着23不在哈希表中。

哈希集用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <unordered_set>                // 0. include the library

int main() {
    // 1. initialize a hash set
    unordered_set<int> hashset;   
    // 2. insert a new key
    hashset.insert(3);
    hashset.insert(2);
    hashset.insert(1);
    // 3. delete a key
    hashset.erase(2);
    // 4. check if the key is in the hash set
    if (hashset.count(2) <= 0) {
        cout << "Key 2 is not in the hash set." << endl;
    }
    // 5. get the size of the hash set
    cout << "The size of hash set is: " << hashset.size() << endl; 
    // 6. iterate the hash set
    for (auto it = hashset.begin(); it != hashset.end(); ++it) {
        cout << (*it) << " ";
    }
    cout << "are in the hash set." << endl;
    // 7. clear the hash set
    hashset.clear();
    // 8. check if the hash set is empty
    if (hashset.empty()) {
        cout << "hash set is empty now!" << endl;
    }
}

使用哈希集查重

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/*
 * Template for using hash set to find duplicates.
 */
bool findDuplicates(vector<Type>& keys) {
    // Replace Type with actual type of your key
    unordered_set<Type> hashset;
    for (Type key : keys) {
        if (hashset.count(key) > 0) {
            return true;
        }
        hashset.insert(key);
    }
    return false;
}

哈希映射用法

哈希集合只能存储值。另一方面，哈希映射是映射的一种实现，它能够存储 (key,value) 键值对

由于能够存储更多信息，哈希映射可以帮助我们解决更复杂的问题。 例如，我们可以使用哈希映射按键聚合所有信息，并在平均为常量的时间内查找与特定键相关的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <unordered_map>                // 0. include the library

int main() {
    // 1. initialize a hash map
    unordered_map<int, int> hashmap;
    // 2. insert a new (key, value) pair
    hashmap.insert(make_pair(0, 0));  //make_pair无需标明类型即可生成一个pair对象
    hashmap.insert(make_pair(2, 3));
    // 3. insert a new (key, value) pair or update the value of existed key
    hashmap[1] = 1;
    hashmap[1] = 2;
    // 4. get the value of a specific key
    cout << "The value of key 1 is: " << hashmap[1] << endl;
    // 5. delete a key
    hashmap.erase(2);
    // 6. check if a key is in the hash map
    if (hashmap.count(2) <= 0) {
        cout << "Key 2 is not in the hash map." << endl;
    }
    // 7. get the size of the hash map
    cout << "the size of hash map is: " << hashmap.size() << endl; 
    // 8. iterate the hash map
    for (auto it = hashmap.begin(); it != hashmap.end(); ++it) {
        cout << "(" << it->first << "," << it->second << ") ";
    }
    cout << "are in the hash map." << endl;
    // 9. clear the hash map
    hashmap.clear();
    // 10. check if the hash map is empty
    if (hashmap.empty()) {
        cout << "hash map is empty now!" << endl;
    }
}

二分查找

它描述了在有序集合中搜索特定值的过程。

二分查找中使用的术语：

• 目标 Target —— 你要查找的值
• 索引 Index —— 你要查找的当前位置
• 左、右指示符 Left，Right —— 我们用来维持查找空间的指标
• 中间指示符 Mid —— 我们用来应用条件来确定我们应该向左查找还是向右查找的索引

三步骤

二分查找一般由三个主要部分组成：

1. 预处理 —— 如果集合未排序，则进行排序
2. 二分查找 —— 使用循环或递归在每次比较后将查找空间划分为两半
3. 后处理 —— 在剩余空间中确定可行的候选者

二分查找代码模板

查找单个索引

二分查找的最基础和最基本的形式

用于查找可以通过访问数组中的单个索引来确定的元素或条件

二分查找的最基础和最基本的形式。

查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。

不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

int binarySearch(vector<int>& nums, int target){
  if(nums.size() == 0)
    return -1;

  int left = 0, right = nums.size() - 1;
  while(left <= right){
    // Prevent (left + right) overflow
    int mid = left + (right - left) / 2;
    if(nums[mid] == target){ return mid; }
    else if(nums[mid] < target) { left = mid + 1; }
    else { right = mid - 1; }
  }

  // End Condition: left > right
  return -1;
}

查找索引及其右邻居索引

用于查找需要访问数组中当前索引及其直接右邻居索引的元素或条件

一种实现二分查找的高级方法。

查找条件需要访问元素的直接右邻居。

使用元素的右邻居来确定是否满足条件，并决定是向左还是向右。

保证查找空间在每一步中至少有2个元素。

需要进行后处理。当你剩下1个元素时，循环/递归结束。需要评估剩余元素是否符合条件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

int binarySearch(vector<int>& nums, int target){
  if(nums.size() == 0)
    return -1;

  int left = 0, right = nums.size();
  while(left < right){
    // Prevent (left + right) overflow
    int mid = left + (right - left) / 2;
    if(nums[mid] == target){ return mid; }
    else if(nums[mid] < target) { left = mid + 1; }
    else { right = mid; }  //右邻居
  }

  // Post-processing:
  // End Condition: left == right
  if(left != nums.size() && nums[left] == target) return left;
  return -1;
}

查找索引及其左右邻居索引

用于搜索需要访问当前索引及其在数组中的直接左右邻居索引的元素或条件。

实现二分查找的另一种方法。

搜索条件需要访问元素的直接左右邻居。

使用元素的邻居来确定它是向右还是向左。

保证查找空间在每个步骤中至少有 3 个元素。

需要进行后处理。当剩下2个元素时，循环/递归结束。需要评估其余元素是否符合条件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int binarySearch(vector<int>& nums, int target){
    if (nums.size() == 0)
        return -1;

    int left = 0, right = nums.size() - 1;
    while (left + 1 < right){
        // Prevent (left + right) overflow
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid;
        } else {
            right = mid;
        }
    }

    // Post-processing:
    // End Condition: left + 1 == right
    if(nums[left] == target) return left;
    if(nums[right] == target) return right;
    return -1;
}

例子

给定一个n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.empty()) return -1;
        int left=0;
        int right=nums.size()-1;
        while(left<=right){
            int mid = left + (right-left)/2; //中间值
            if(nums[mid]>target){
                right=mid-1;  //右边界重新赋值
            } else if(nums[mid]<target){
                left=mid+1;
            } else{
                return mid;
            }
        }
        return -1;
    }
};

参考

• leetcode-二叉树
• 数据结构：图（Graph）
• leetcode-哈希表
• leetcode-二分查找
• leetcode-二叉搜索树
• 《数据结构（C++语言版）》

栈和队列以及相关代码实现（阅读《数据结构（C++语言版）》及leetcode课题）

FIFO（先入先出数据结构）

FIFO数据结构中，将首先处理添加到队列中的第一个元素。

队列是典型的FIFO数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。删除（delete）操作也被称为出队（dequeue)。你只能移除第一个元素。

队列实现

为了实现队列，可以使用动态数组和指向队列头部的索引。

队列应支持两种操作：入队和出队。入队会向队列追加一个新元素，而出队会删除第一个元素。 所以我们需要一个索引来指出起点

以下是简单的代码实现，但是某些场景效率会很低。随着起始指针的移动，会造成更多的空间浪费。

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <iostream>

class MyQueue {
    private:
        // store elements
        vector<int> data;       
        // a pointer to indicate the start position
        int p_start;            
    public:
        MyQueue() {p_start = 0;}
        /** Insert an element into the queue. Return true if the operation is successful. */
        //入队增加元素
        bool enQueue(int x) {
            data.push_back(x);
            return true;
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        //出队删除一个元素
        bool deQueue() {
            if (isEmpty()) {
                return false;
            }
            p_start++;  //队列头部索引后移
            return true;
        };
        /** Get the front item from the queue. */
        //队列第一个元素
        int Front() {
            return data[p_start];
        };
        /** Checks whether the queue is empty or not. */
        //判断是否为空
        bool isEmpty()  {
            return p_start >= data.size();
        }
};

int main() {
    MyQueue q;
    q.enQueue(5);
    q.enQueue(3);
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
    q.deQueue();
    if (!q.isEmpty()) {
        cout << q.Front() << endl;
    }
}

java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// "static void main" must be defined in a public class.

class MyQueue {
    // store elements
    private List<Integer> data;         
    // a pointer to indicate the start position
    private int p_start;            
    public MyQueue() {
        data = new ArrayList<Integer>();
        p_start = 0;
    }
    /** Insert an element into the queue. Return true if the operation is successful. */
    public boolean enQueue(int x) {
        data.add(x);
        return true;
    };    
    /** Delete an element from the queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if (isEmpty() == true) {
            return false;
        }
        p_start++;
        return true;
    }
    /** Get the front item from the queue. */
    public int Front() {
        return data.get(p_start);
    }
    /** Checks whether the queue is empty or not. */
    public boolean isEmpty() {
        return p_start >= data.size();
    }     
};

public class Main {
    public static void main(String[] args) {
        MyQueue q = new MyQueue();
        q.enQueue(5);
        q.enQueue(3);
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
        q.deQueue();
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
        q.deQueue();
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
    }
}

循环队列

上面的方式简单但是低效。

更有效的方法是使用循环队列。具体来说，就是使用固定大小的数组和两个指针来指示起始位置和结束位置

目的是重用我们之前提到的被浪费的存储。

定义和接口

循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

• MyCircularQueue(k): 构造器，设置队列长度为 k
• Front: 从队首获取元素。如果队列为空，返回 -1
• Rear: 获取队尾元素。如果队列为空，返回 -1
• enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真
• deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真
• isEmpty(): 检查循环队列是否为空
• isFull(): 检查循环队列是否已满

cpp实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

class MyCircularQueue {
private:
    int queue[1000] = {0};  //假设值范围在0-1000内
    int k = 0;      //队列长度
    int head = 0;   //头指针
    int end = -1;   //尾指针
    int count = 0;
    
public:
    MyCircularQueue(int k) {
        this->k = k;
    }
    
    //入队
    bool enQueue(int value) {
        if (count < k) {
            count++;    //当前入队元素数量，判断队列是否已满
            end = (end + 1) % k; //取余，注意end初始化是-1
            queue[end] = value;
            return true;
        }
        return false;
    }

    //出队
    bool deQueue() {
        if (count == 0) {
            return false;
        }
        count--;  //队列元素减一
        head = (head + 1) % k;  //队列元素后移，即第一次更新是1（移除了下标为0的元素）
        return true;
    }
    
    int Front() {
        if (count == 0) {
            return -1;
        }
        return queue[head]; //队首元素
    }
    
    int Rear() {
        if (count == 0) {
            return -1;
        }
        return queue[end]; //获取队尾元素
    }
    
    bool isEmpty() {
        if (count == 0) {  //队列元素是0，即空队列
            return true;
        }
        return false;
    }
    
    bool isFull() {
        if (count == k) { //队列已满
            return true;
        }
        return false;
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue* obj = new MyCircularQueue(k);
 * bool param_1 = obj->enQueue(value);
 * bool param_2 = obj->deQueue();
 * int param_3 = obj->Front();
 * int param_4 = obj->Rear();
 * bool param_5 = obj->isEmpty();
 * bool param_6 = obj->isFull();
 */

int main() {
    MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
    circularQueue.enQueue(1);  // 返回 true
    circularQueue.enQueue(2);  // 返回 true
    circularQueue.enQueue(3);  // 返回 true
    circularQueue.enQueue(4);  // 返回 false，队列已满
    circularQueue.Rear();  // 返回 3
    circularQueue.isFull();  // 返回 true
    circularQueue.deQueue();  // 返回 true
    circularQueue.enQueue(4);  // 返回 true
    circularQueue.Rear();  // 返回 4
    return 0;
}

Leetcode实现方式-C++

在循环队列中，我们使用一个数组和两个指针（head 和 tail）。 head 表示队列的起始位置，tail 表示队列的结束位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

class MyCircularQueue {
private:
    vector<int> data;
    int head;
    int tail;
    int size;
public:
    /** Initialize your data structure here. Set the size of the queue to be k. */
    MyCircularQueue(int k) {
        data.resize(k);  //重置size
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    bool enQueue(int value) {
        if (isFull()) {
            return false;
        }
        if (isEmpty()) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    bool deQueue() {
        if (isEmpty()) {
            return false;
        }
        if (head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    int Front() {
        if (isEmpty()) {
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    bool isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    bool isFull() {
        return ((tail + 1) % size) == head;
    }
};

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * bool param_1 = obj.enQueue(value);
 * bool param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * bool param_5 = obj.isEmpty();
 * bool param_6 = obj.isFull();
 */

Leetcode实现方式-Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

class MyCircularQueue {
    
    private int[] data;
    private int head;
    private int tail;
    private int size;

    /** Initialize your data structure here. Set the size of the queue to be k. */
    public MyCircularQueue(int k) {
        data = new int[k];
        head = -1;
        tail = -1;
        size = k;
    }
    
    /** Insert an element into the circular queue. Return true if the operation is successful. */
    public boolean enQueue(int value) {
        if (isFull() == true) {
            return false;
        }
        if (isEmpty() == true) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /** Delete an element from the circular queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if (isEmpty() == true) {
            return false;
        }
        if (head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** Get the front item from the queue. */
    public int Front() {
        if (isEmpty() == true) {
            return -1;
        }
        return data[head];
    }
    
    /** Get the last item from the queue. */
    public int Rear() {
        if (isEmpty() == true) {
            return -1;
        }
        return data[tail];
    }
    
    /** Checks whether the circular queue is empty or not. */
    public boolean isEmpty() {
        return head == -1;
    }
    
    /** Checks whether the circular queue is full or not. */
    public boolean isFull() {
        return ((tail + 1) % size) == head;
    }
}

/**
 * Your MyCircularQueue object will be instantiated and called as such:
 * MyCircularQueue obj = new MyCircularQueue(k);
 * boolean param_1 = obj.enQueue(value);
 * boolean param_2 = obj.deQueue();
 * int param_3 = obj.Front();
 * int param_4 = obj.Rear();
 * boolean param_5 = obj.isEmpty();
 * boolean param_6 = obj.isFull();
 */

☆内置队列库

大多数流行语言都提供内置的队列库，因此您无需重新发明轮子。

队列有两个重要的操作，入队 enqueue 和出队 dequeue。 此外，我们应该能够获得队列中的第一个元素，因为应该首先处理它。

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <iostream>

int main() {
    // 1. Initialize a queue.
    queue<int> q;
    // 2. Push new element.
    q.push(5);
    q.push(13);
    q.push(8);
    q.push(6);
    // 3. Check if queue is empty.
    if (q.empty()) {
        cout << "Queue is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.移除一个元素
    q.pop();
    // 5. Get the first element.获取第一个元素
    cout << "The first element is: " << q.front() << endl;
    // 6. Get the last element.获取最后一个元素
    cout << "The last element is: " << q.back() << endl;
    // 7. Get the size of the queue.长度
    cout << "The size is: " << q.size() << endl;
}

java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        // 1. Initialize a queue.
        Queue<Integer> q = new LinkedList();
        // 2. Get the first element - return null if queue is empty.
        System.out.println("The first element is: " + q.peek());
        // 3. Push new element.
        q.offer(5);
        q.offer(13);
        q.offer(8);
        q.offer(6);
        // 4. Pop an element.
        q.poll();
        // 5. Get the first element.
        System.out.println("The first element is: " + q.peek());
        // 7. Get the size of the queue.
        System.out.println("The size is: " + q.size());
    }
}

LIFO（后入先出数据结构）

参考：leetcode-后入先出的数据结构

在LIFO数据结构中，将首先处理添加到队列中的最新元素。

与队列不同，栈是一个LIFO数据结构。通常，插入操作在栈中被称作入栈push。与队列类似，总是在堆栈的末尾添加一个新元素。但是，删除操作，退栈pop，将始终删除队列中相对于它的最后一个元素

栈定义和实现

栈是限制在表的一端进行插入和删除的线性表。表中允许插入、删除的这一端称为栈顶，栈顶的当前位置是动态变化的；不允许插入和删除的另一端称为栈底，栈底是固定不变的。当表中没有元素时称为空栈。栈的插入运算称为进栈、压栈或入栈，栈的删除运算称为退栈或出栈。

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>

class MyStack {
    private:
        vector<int> data;               // store elements
    public:
        /** Insert an element into the stack. */
        void push(int x) {
            data.push_back(x);
        }
        /** Checks whether the queue is empty or not. */
        bool isEmpty() {
            return data.empty();
        }
        /** Get the top item from the queue. */
        int top() {
            return data.back();
        }
        /** Delete an element from the queue. Return true if the operation is successful. */
        bool pop() {
            if (isEmpty()) {
                return false;
            }
            data.pop_back();
            return true;
        }
};

int main() {
    MyStack s;
    s.push(1);
    s.push(2);
    s.push(3);
    for (int i = 0; i < 4; ++i) {
        if (!s.isEmpty()) {
            cout << s.top() << endl;
        }
        cout << (s.pop() ? "true" : "false") << endl;
    }
}