DEV Community: larson

Android Gpio use cases by controlling LED

larson — Thu, 14 Jan 2021 09:53:02 +0000

This experiment uses the GPIO port to pull up and down to control the on and off of the small lights. As a soldier who has just switched from the application layer to the framework, writing this article hopes to help you learn.

What is GPIO

GPIO, the full English name is General-Purpose IO ports, that is, general-purpose IO ports. Embedded systems often have a large number of external devices/circuits with relatively simple structures. Some of these devices/circuits require the CPU to provide control means, and some need to be used by the CPU as an input signal. Moreover, many of these devices/circuits only require one bit, that is, as long as there are two states of on/off, such as light on and off. For the control of these devices/circuits, it is not appropriate to use traditional serial ports or parallel ports.

Therefore, a "universal programmable IO interface" is generally provided on the microcontroller chip, that is, GPIO.
In layman's terms, some pins can be used to output high and low levels or read the state of the pins through them-whether they are high or low.

Generate devices in the kernel

principle

Regarding GPIO port character device driver, we have to do the following steps:
1 Find the GPIO port corresponding to the schematic and configure it as an output pin
GPIO port configuration (different platform configuration is different) but the purpose is the same. Set the GPIO port output, and the default low level, we are connected to 57 pins
<&range 56 1 0x1500>
<&range 57 1 0x1500> means 57 pins are used as gpio ports, and default low level
This io port register address: 0xe46002e4

But during the debugging process

#define gpio_lp 57
gpio_request(gpio_lp,"pos_pwr");
gpio_set_value(gpio_lp,1);

The GPIO call request reports an error, which causes the GPIO to be unusable, but after changing the GPIO port, changing the gpio port will not report the error.
This reason is due to the particularity of intel: gpio is called in the place of vmm, and it cannot be operated under the kernel (the general platform is no problem with this operation)

Later, I thought of another method

void __iomem *ldo_mmio_base = ioremap(0xe46002e4, 4);
iowrite32(0x1700, ldo_mmio_base); //1700 represents the setting register (0xe46002e4) is GPIO port, and the output is high
iowrite32(0x1500, ldo_mmio_base);//1500 represents the setting register (0xe46002e4) is GPIO port, the output is low

Realize the control of IO port

achieve

I put the source code under kenel-3.10/drivers/char to let the system generate a device node: /dev/mtgpio, which needs to be modified in two places.
First enter the kernel-3.10/drivers/char directory, add a new file, I named it lp6735_switch.c here, the specific code is as follows:
kernel-3.10/drivers/char$ vim lp6735_switch.c

#include <linux/module.h> /* For module specific items */
#include <linux/moduleparam.h> /* For new moduleparam's */
#include <linux/types.h> /* For standard types (like size_t) */
#include <linux/errno.h> /* For the -ENODEV/... values */
#include <linux/kernel.h> /* For printk/panic/... */
#include <linux/fs.h> /* For file operations */^M
#include <linux/ioport.h> /* For io-port access */
#include <linux/platform_device.h> /* For platform_driver framework */
#include <linux/init.h> /* For __init/__exit/... */
#include <linux/uaccess.h> /* For copy_to_user/put_user/... */
#include <linux/io.h> /* For inb/outb/... */
#include <linux/gpio.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h> /*kamlloc */
//#include <asm-generic/ioctl.h>

 //ioctl
#define CMD_FLAG'i'
#define led_PWR_ON _IOR(CMD_FLAG,0x00000001,__u32)
#define led_PWR_OFF _IOR(CMD_FLAG,0x00000000,__u32)
#define gpio_lp 57

static int major =0;
static struct classclass *led_class;
struct cdev_led {
    struct cdev cdev;
};
struct cdev_led *led_dev;

static int led_ioctl(struct file* filp,unsigned int cmd,unsigned long argv)
{
    printk(KERN_INFO "entry kernel.... \n");
    printk(KERN_INFO "%d\n", led_PWR_ON);
    void __iomem *ldo_mmio_base = ioremap(0xe46002e4, 4);

    switch(cmd)
    {
        case led_PWR_ON:
        {
#if 0
            gpio_set_value(gpio_lp,1); //
            printk(KERN_INFO "led on\n");
#endif
            iowrite32(0x1700, ldo_mmio_base)
            break;
        }
        case led_PWR_OFF:
        {
#if 0
            gpio_set_value(gpio_lp,0);
            printk(KERN_INFO "led off \n");
#endif
            iowrite32(0x1500, ldo_mmio_base);
            break;
        }
        default:
            return -EINVAL;
    }
    return 0;
}


//open
static int led_open(struct inode* i_node,struct file* filp)
{
    printk(KERN_INFO "larsonzhong open init.... \n");
    int err;
// larsonzhong Content between #if 0 #endif would comment, because there is no actual device
 #if 0
    err = gpio_request(gpio_lp,"led_pwr");
    if(err<0)
    {
        printk(KERN_INFO "gpio request faile \n");
        return err;
    }
    gpio_direction_output(gpio_lp,1);
 #endif
    return 0;
}

//close
static void led_close(struct inode* i_node,struct file* filp)
{
printk(KERN_INFO "larsonzhong close init \n");
// larsonzhong Content between #if 0 #endif would comment, because there is no actual device
#if 0
    gpio_free(gpio_lp);
#endif
    return;
}

/* file operations */
struct file_operations fops={
    .owner = THIS_MODULE,
    .open = led_open,
    .unlocked_ioctl = led_ioctl,
    .release = led_close,
};

static int __init led_init(void)
{
    printk(KERN_INFO "init .... \n");
    dev_t dev_no;
    int result,err;
    err = alloc_chrdev_region(&dev_no,0,1,"my_led"); //dynamic request device number
    if(err<0)
    {
        printk(KERN_INFO "ERROR\n");
        return err;
    }
    major = MAJOR(dev_no);
    led_dev = kmalloc(sizeof(struct cdev_led),GFP_KERNEL);
    if(!led_dev)
    {
        result = -ENOMEM;
        goto fail_malloc;
    }
    memset(led_dev,0,sizeof(led_dev));

    cdev_init(&led_dev->cdev,&fops);
    led_dev->cdev.owner = THIS_MODULE;
    result = cdev_add(&led_dev->cdev,dev_no,1);
    if(result <0)
    {printk(KERN_INFO "error\n");
        goto fail_add;
    }
    led_class = class_create(THIS_MODULE,"mtgpio"); //in sys/class create sysfs file
    device_create(led_class,NULL,MKDEV(major,0),NULL,"mtgpio"); //dynamic create device file /dev/myled
    return 0;
fail_add:
    kfree(led_dev);
fail_malloc:
    unregister_chrdev_region(dev_no,1);
    return result;

}

static void __exit led_exit(void)
{
    dev_t dev_no=MKDEV(major,0);

    unregister_chrdev_region(dev_no,1);
    cdev_del(&led_dev->cdev);
    kfree(led_dev);
    device_destroy(led_class,dev_no);
    class_destroy(led_class);
    printk(KERN_INFO "exit........ \n");
}
module_init(led_init);
module_exit(led_exit);
MODULE_AUTHOR("larsonzhong@gmail.com");
MODULE_DESCRIPTION("control_led_power");
MODULE_LICENSE("GPL");

Save and exit, and then we need to modify a file, which is the makefile in the same directory.
Add a paragraph in kernel-3.10/drivers/char$ vim Makefile:
+obj-y += lp6735_switch.o
Specific code, because csd has processed some special symbols, only pictures can be uploaded:

After adding lp6735_switch.c and modifying the Makefile, the firmware generation will generate a node under /dev/ /dev/mtgpio
To make this node readable and writable by others, you must also modify the system owner of the node and his permissions. This step is carried out in init.rc.

My code is system/core/rootdir/init.rc

   ...
   # added by larsonzhong@163.com change my devices mqgpio
   chown system system /dev/mtgpio
   chmod 0766 /dev/mtgpio
   ...

Start experiment

We assume that the device of the small lamp we want to use is dev/mtgpio##Jni header file
Create a new Android project, and then create a new class, here is GpioLED.java.
To

public class GpioLED {
To
//Control LED power on
public native static void ledPowerOn();
// Control the LED to power off
public native static void ledPowerOff();
}

To
Generate header file

Method 1: Simple and rude
Use javah to generate, please note that the java environment has been set up (including environment configuration classpath configuration).
Go to the classes directory under the bin directory under the source code, and use the javah -jni package name. Class name, here is javah -jni com.coban.ledsimple.LEDGpio
We can see the header file in the directory and open the header file. Copy the statement inside.

Method 2: More convenient
Click the small triangle next to the compile button with toolbox next to the compile button, a drop-down list pops up, click External Tools Configurations, a dialog box pops up,
We select Program and click the new button above. Then fill in as follows:

Main card:
Name: javah
Location: Select the directory where javah is located. Mine is C:\Program Files\Java\jdk1.8.0_102\bin\javah.exe
Working Diractory: Click the variables button to pop up the list, select project_loc to confirm, and then add \src at the end, my result is ${project_loc}\src
Arguments: -classpath ${project_loc}\bin\classes -d ${project_loc}\jni -jni ${java_type_name}
Refresh card:
Check refresh Resource upon completion
Common card:
Check External Tools and click apply

jni implementation

Create a new c file and mk file. If you are using eclipse and ndk is configured (note that ndk must be configured not only in eclipse, but also in environment variables) otherwise there may be Unable to launch cygpath. Is Cygwin on the path?] error.
Right click Project->Android Tools->Add Native Support
Then you will see an additional folder and two files in the project directory, we paste the header file declaration just copied.

My code implementation here is like this: ledcontrol.c

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<errno.h>
#include<unistd.h>
#include<sys/ioctl.h>
#include<jni.h> // Must include this file
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include <android/log.h>
//Command code in the driver.
#define CMD_FLAG'i'
#define LED_ON _IOR(CMD_FLAG,0x00000001,__u32)
#define LED_OFF _IOR(CMD_FLAG,0x00000000,__u32)

#define DEVICE_NAME "/dev/mtgpio"
int fd;


static const char *TAG="012";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

/* * Class: Linuxc
* Method: openled
* Signature: ()I
*/

JNIEXPORT void JNICALL Java_com_coban_ledsimple_LEDGpio_ledPowerOn(JNIEnv* env, jclass mc)
{
  LOGI("POWER ON BY LARSON");
  LOGI("LED_ON:%d LED_OFF:%d",LED_ON,LED_OFF);
  fd=open(DEVICE_NAME,O_RDWR);
  if(fd<0)
      {
            LOGI("don't open dev");
        }
        else
            {
            ioctl(fd,LED_ON,NULL);
            LOGI("open success");
            }


}

/* * Class: Linuxc
* Method: clsoeled
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_coban_ledsimple_LEDGpio_ledPowerOff(JNIEnv* env, jclass mc)
{
    LOGI("POWER Off BY LARSON");
    ioctl(fd,LED_OFF,NULL);
    close(fd);

}

Please note that I used the log and some other header files here, we need to include the relevant libraries. Modify Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_LDLIBS := -lm -llog
LOCAL_MODULE := ledcontrol
LOCAL_SRC_FILES := ledcontrol.c

include $(BUILD_SHARED_LIBRARY)

It should be noted that LOCAL_LDLIBS := -lm -llog should not be added in front of include $(CLEAR_VARS), otherwise it will be cleared and invalidated.

Application.mk
APP_ABI := all

The meaning here is to compile the so files of all platforms, if you want to specify a compilation
APP_ABI := armeabi armeabi-v7a x86
Separated by a space

Generate so file

We directly push or build the software to the device. You will see an extra obj folder in the project directory,
And there are several more folders under libs, these folders correspond to different platforms.

APP Implementation

I will post the code directly here
HelloJniLED.java

package com.example.hellojni;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class HelloJniLED extends Activity {
private Button power_on;
private Button power_off;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
power_on = (Button) findViewById(R.id.power_on);
power_off = (Button) findViewById(R.id.power_off);

To
power_on.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d("012", "power_on by android\n");
LEDGpio.ledPowerOn();

}
});
power_off.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d("012", "power_off by android\n");
LEDGpio.ledPowerOff();

}
});

}
To
}

LEDGpio.java

package com.coban.ledsimple;

import android.util.Log;

public class LEDGpio {
static {
try {
Log.i("012", "try to load ledcontrol.so");
System.loadLibrary("ledcontrol");
} catch (UnsatisfiedLinkError ule) {
Log.e("012", "WARNING: Could not load ledcontrol.so");
}
}

public native static void ledPowerOn();

public native static void ledPowerOff();
}

Layout file activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/position"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text=" power control "
        android:textColor="#ff0000"
        android:textSize="25sp" />

    <Button
        android:id="@+id/power_on"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignTop="@+id/position"
        android:layout_centerHorizontal="true"
        android:layout_toLeftOf="@+id/position"
        android:text="power_on"
        android:textSize="18sp" />

    <Button
        android:id="@+id/power_off"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignTop="@+id/position"
        android:layout_toRightOf="@+id/position"
        android:text="power_off"
        android:textSize="18sp" />

</RelativeLayout>

Essential software on a new computer

larson — Thu, 14 Jan 2021 07:12:21 +0000

From the beginning to the present, I don’t know how many times I have installed the system, and every time I don’t remember what kind of software I need to use. Later, I started to use a network disk to download this software to a directory, but due to the software version update, I was unwilling to use the software in this directory when I installed the system next time, so this article was published.
This article has been collected by many people, so I realized that this matter is very meaningful, so I have kept it up to date;

1. Office Drawing

Markdown Generate Directory

If you get some other websites to write blogs on GitHub, it is a painful thing to ask you to organize the catalog yourself. Of course, the best way is to use tools to generate it;

GH-MD-TOC

The artifact is to run under Linux;

$ gh-md-toc file.md | (tail -n +2 && echo "" && cat file.md) | sponge file.md

You will be surprised to find that this command completes everything and generates a table of file.MD
contents are automatically added to the head of file.MD, and blank lines are handled perfectly.

Markdown All in One

This is a VS plug-in. After installation, click on the md file, then the shortcut key CTRL(CMD)+SHIFT+P, enter Markdown All in One: Create Table of Contents and press Enter, as follows:

1.1 Online drawing

ProcessOn

ProcessOn is an online collaborative drawing platform that supports the online creation of flowcharts, mind maps, organizational charts, network topology diagrams, BPMN, UML diagrams, UI interface prototype design, etc., and the interface is also very simple.

MindMaster mind map

MindMaster has a very good interface and interaction, and its functions will be much richer than the above software. It is a very professional online mind mapping tool. It can not only create topics, but also teamwork, but also customize the filling, style, effect, etc. of each topic.

Typora

I was not used to it when I first started using it, because I used the Markdown Pad to write markdown files at the beginning, and there is a real-time preview function in it that I can't get rid of; Typora The advertisement says yes The most concise and most beautiful editor is aimed at this conciseness, I went to understand it. It's really not bad;

Other editors

In addition to Typora, there are many good editors, like Markdown Pad, like Cmd Markdown, like Atom (yes, this is a code IDE), like VS Code (this is also a code editor); but Github's syntax and Typora is consistent, so I still like Typora;

1.3 Take notes

Good memory is not as good as bad writing. An efficient note-taking software can help us save a lot of time. The best note-taking application I have used is Evernote, followed by Youdao Cloud Note.

Evernote

Everyone recommends note-taking applications, both in the cloud and on the desktop. The layout is also beautiful and rich in functions. It is the first choice for writing articles, taking notes, attending classes, and other recording scenarios. If you use it, you need to go to Evernote official website Registration;

2. System Ease of Use

2.1 Clipboard

Have you ever encountered a scene where you want to copy two paragraphs of text at the same time, but the clipboard that comes with Windows only supports one paragraph of text at the same time, Ctrl+C and then Ctrl+V;

ditto

Ditto is a standard Windows cut and paste tool. Support network synchronization, record grouping, name paste, and other functions. Small but powerful and easy to use. You can paste text, pictures, HTML, and custom formats in the clipboard.

2.2 Window Management

Window’s file browser can’t intuitively switch the directories we open. When there are too many open directories, I will turn off a few of them for obsessive-compulsive disorder, but then I found that I need to re-use Ie Explorer to open that directory. There is no software that can switch the browsing window on a View like a browser manages the tab page. After all, it now supports multiple windows whether it is text editing or page browsing.

clover

The Chinese name "Four Leaf Clover", I believe many people have heard of it. It is a lightweight file management artifact and my favorite multi-tab file manager (lightweight).

Total Commander

This is another awesome file management artifact. It is an advanced version of Clover. It has a large number of loyal users and is powerful. It is highly recommended by Geek;

2.3 Desktop organization

Seeing the dense collection of desktop icons, it is painful to see if they are all left in a temporary folder and afraid of not being found. The screen is full and it affects beauty. At this time, I hope to have a partition software, so that you can quickly manage desktop affairs;

I have used Tencent’s and 360’s desktop finishing software, but in the end, I still used Fence;

Fence

This is a lightweight desktop organization software, I like lightweight things;

Bing Wallpapers

Bing Wallpaper contains exquisite pictures from all over the world selected on the Bing homepage. Not only will you see a new image on your desktop every day, but you can also browse the image and learn its source.

2.4 File Search & Organize

The computer has been used for a long time, it may be troublesome to find files. If you use the file browser that comes with windows, you may not find it, and the efficiency is low. Here are several tools that can quickly locate the file;

Everything

Everything is a file search tool developed by void tools. The official website describes it as "Locate files and folders by name instantly".

listary

Listary is smarter than Everything and more powerful to use, but because it needs to be in the background, it may conflict with other software shortcuts. In order to avoid this conflict, I finally use Everything;

spacesniffer

Is your C drive running out of disk space? Try spacesniffer, he can quickly scan the file composition in the C drive, and quickly find large files that can free up space.

3. Windows/linux tools

3.1 Mirror write

Including Linux mirroring and Windows mirroring writing. Generally speaking, we don't write much Windows mirroring. Generally, we need to write a windows image when it is used for system disks.

Soft Disk Link

Soft Disk Link, UltraISO Floppy is a tool for making/editing/converting CD image files. It can edit ISO files, extract files and directories from ISO, make CD images from CD-ROM or make files on the hard disk into ISO files, and make bootable CDs.

Win32 Disk Imager

I often use it to write Linux systems, such as writing systems to the Raspberry Pi and writing systems to the router. It is very versatile, lightweight, and convenient. I like it very much.

3.2 Software uninstall

In the past, I only knew that 360 can be uninstalled in batches, so every time I want to uninstall in batches, I need to install 360 Security Guard, so I was forced to install the whole family bucket. Later I found that other tools can also achieve the effect, such as Revo Uninstaller Pro;

Revo Uninstaller

Lightweight, efficient, and perfect for batch software uninstallation.

3.3 Remote login

FinalShell

It is highly recommended. I have been using this software since Xshell could not be cracked. The focus is on open source and easy to use. It comes with Ftp tools, which is great.

remote Desktop connection

The software that comes with Windows is focused on being lightweight and efficient. Congratulations on the system that comes with it, it's much cleaner than other software.

3.4 Remote Assistance

Splashtop

The software developed by foreigners is lightweight and efficient and supports Win, Mac, Linux, and other systems across platforms, and even mobile systems such as iOS and Android. Great!

Sunflower

TeamViewer

It can be used for remote control in the background of any firewall and NAT proxy. It can be used to easily connect to any PC or server in the world. There are currently about 200 million users using Teamviewer. Teamviewer is free for personal use, but annoying ads will pop up.

3.6 Audio and video playback

Shark007

This is a program package that enables the media player that comes with Windows to support a full range of audio and video encodings. Blessed are friends who are fed up with domestic software ads pointing to experience the pure version of local playback. Shark007 supports many encoding formats. Basically, support all mainstream formats. Official download address is easy to be walled, you can download it at Domestic Software Download Station download.

PotPlayer

PotPlay is an independent player, but like shark007, it supports opening with the media player that comes with windows. The encoding is also very comprehensive because it is a foreign software, so Official website download is slow, you can use Baidu's Domestic software download station download;

3.7 Browser

There are many domestic browsers, such as 360, Tencent, Do you, etc., but in the end, I think the best to use is the foreign three giants Ie, Google Chrome, Firefox, Ie have basically heard and used it, Firefox and chrome if you are Geek, you will love it;

Firefox browser

Since Firefox official website is not walled, you can click the link to download the latest version. Windows, Linux, and macOS are all supported; you may think she is not good-looking, but her Memory optimization is great;

Chrome browser

The browser developed by Google is ranked first in the world and the browser with the best feedback. It is supported by the whole system like Firefox, but the download address of Chrome official website is sometimes downloaded Very slow, you can consider using domestic download sites as appropriate;

4. Development assistance

4.1 Source Code View

Usually, we can view the code of some small projects and use the IDE to import the project source code directly, but when dealing with the source code of some large projects, using the IDE will cause the computer to freeze and seriously affect the user experience. I do Android development by myself, usually in Android Studio, I can view it directly like the project source code, but the source code below the framework layer needs another tool;

sourceInSight

This is an excellent source code viewing tool. Whether it is a few G or dozens of G or even hundreds of G, you can use this tool to quickly and efficiently read the code. Of course, there are some skills you can go to the tutorial for details. ；

Linux Daniel likes to use Vim to view the source code. I'm not a Daniel, so I don't recommend it.

4.2 FTP file transfer

In the past, I used the XFTP that comes with XShell to do file transfers, but later found that I couldn’t use it for free, so I used the Ftp tool with FinalShell to transfer files, and later I found a more independent transfer tool;

File Zilla File Zilla, This is a very easy-to-use and user-friendly Ftp transfer tool. I and my company use this software;

FireFTP FireFTP,If you do not want to install the software, you can use the Firefox plug-in, provided that you have to install Firefox;

4.3 Download software

There are many download tools, but many of them are bloated;

Motrix

The download speed of the official website address is very slow, I will help you download it in advance. You can go to my resource page to download the corresponding version.

Violent Monkey/Greasy Monkey

A browser script software that runs on major browsers. After installation, various scripts can be installed to achieve the desired functions. So you may think that's it. What I want to say is that it can crack Vip, compare prices across the entire network, realize direct download from the network disk, and realize that major video websites are free of advertisements. Have you tried it?

Whether it is a greasy monkey or a violent monkey, you need to install plug-ins to complete these functions. There is a place to search for plug-ins greasyfork;

Bit Wizard

Sometimes it is not easy to use, I still recommend Motrix;

7Zip

7Zip supports extreme compression, and it does not require cracking like rar. The compression efficiency is just right. For example, I used to zip to compress a directory that was originally 500m after compressed with rar, and the final size was only more than 100M;

5. Screen recording and image processing

5.1 Screen Recording

I sometimes do live broadcasts. I have also been a lecturer before, and I need to record and broadcast. I have used several recording software, and finally only selected two.

FSCapture Pro

This is my favorite screen recording software. It is small in size, simple in interface, and powerful. Many domestic software sites have green versions, and I have uploaded them to the csdn download page.

Bandicam

This is more versatile than the first one. It’s great for game recording. I generally don’t do game recording, so I prefer to use the first one;

5.2 Gif recording

ScreenToGif

My favorite tool for screen recording Gif. Sometimes we can’t share videos with others, so we can only share pictures. This is a lightweight and memory-saving tool for screen recording Gif. You must not miss it;

LICEcap

This is another tool for recording Gif. It is also lightweight and has a simple interface. I use less but it doesn’t mean it’s bad;

5.3 Image compression

A processed 3000w pixel picture has dozens of megabytes. In fact, we don’t need such high details. Many times we want to spread on social media, so we hope that the resolution is as large as possible instead of as many details as possible. In fact, when there are too many details, human eyes can't see it at all. This is why the graphics compression algorithm was invented;

Voralent Antelope

This is a pretty good image compression software, it can compress dozens of megabytes of photos to 2 megabytes and it is difficult for you to distinguish the difference between the two with your naked eyes;

PS image batch processing

There are many awesome uses of PS, batch processing is a built-in script; you can find it in Ps File -> Script -> Image Batch;

6. Format conversion and text recognition

6.1 Convert Word to PDF

Word to PDF

Method 1: After Word2016, it comes with the function of saving as PDF. How to use: Open Word document→File→Save as→Save as the type and select PDF;

Method 2: Word to print PDF, the computer system needs win7 or higher, operation: open Word document → file → print → click the print button;

PDF to Word

Many people don't know that Word comes with the function of converting PDF to Word. In fact, with the improvement of the Word version, it is completely possible to reverse the PDF that was originally converted from Word.

All you have to do is to select the PDF document you want to convert, right-click the mouse, and choose to open it with Word2013 or 2016.

这个时候 Word 友情地提示你，它正在努力地转 Word，但转换之后可能会和 PDF 有点差异，没事，点确认就行；

At that time, Word kindly reminds you that it is working hard to convert to Word, but it may be a little different from PDF after conversion. It's okay, just click confirm;

6.2 Word to Markdown

For example, I read a great article on the Internet, but because Csdn needs MD format files, although I can copy and paste the content to Word by selecting all, I need to convert it to MD. At that time, you need to use the artifact of Writage:

Writage

Writage,This is an artifact that can be converted to markdown by directly saving as in word.

6.3 Image to text

Image-to-text is also called OCR. There is open source code on GitHub, but many people don't know how to compile, or if they are in a hurry, they need to use molded things. For example, this online conversion is easy to use:

XPdf

xpdf, Convert pictures to text online for free, unlimited pages. The product also provides PDF to word;

- ABBYY FineReader

ABBYY FineReader

The awesome thing about this thing is that you can directly recognize the content on the picture and save it to Word. After opening the software, click [Graph or PDF file to Microsoft Word], select the document to be converted and then start the conversion.

You can download ABBYY FineReader on the official website. After opening the software, click [Graph or PDF file to Microsoft Word], select the document to be converted and start the conversion. The effect is excellent.

Android system init process startup and init.rc full analysis

larson — Thu, 14 Jan 2021 01:44:07 +0000

This is a blog written with heart, and I hope everyone can read it carefully and help find the improvement of the article, thank you;

Service startup mechanism

parse_config_file (init.rc) in the main function of the system/core/init/init.c file reads and parses the contents of the init.rc file. Place the service information in the service_list of system/core/init/init_parser.cpp
The main function of the system/core/init/init.c file continues to execute restart_servie_if_needed(...) -> service_start(...) -> Execve(...) to establish the service process;

In order to let everyone see more clearly, the last picture first "Overall Startup Framework":

init.rc Introduction

At present, Linux has many communication mechanisms that can interact between user space and kernel space, such as device driver files (located in the /dev directory), memory files (/proc, /sys directories, etc.). Students who know Linux should know that one of the important features of Linux is that everything exists in the form of files. For example, a device usually corresponds to one or more device files. These files that interact with the kernel space are in the user space, so after loading in the Linux kernel, you need to first create the directory where these files are located. The program to complete these tasks is the init described in this article. Init is a command line program. One of its main tasks is to create a directory where these files that interact with the kernel space are located. When the Linux kernel is loaded, the first thing to do is to call the init program, that is, init is the first program executed in user space.

Although the work done by init is not much, the code is still very complicated. Init program is not composed of one source code file, but is formed by linking a set of object files of source code files. These files are located in the following directories.

It should be understood that these init.rc are just grammar files, not programs. The real entry point is the system/core/init/init.c mentioned above.
Because the init.c file is relatively large, in the second part of the article I will briefly analyze the init startup process through the main function;

There are two init.rc, located in:
./system/core/rootdir/init.rc
./bootable/recovery/etc/init.rc
It can be guessed from the catalog that the two init.rc usage scenarios are different. One is used for flashing, that is, to enter the recorvery mode, and the other is used for normal startup; our focus here is the above one, which is also init The one associated with .c;

init.rc grammatical structure analysis

To understand how init.rc is parsed, we need to look at the documentation first. The documentation is there. Of course, you can also look at the Chinese version ；
init.rc is located in /bootable/recovery/etc/init.rc

The Android initialization language contains four types of declarations:
Actions (behavior), Commands (command), Services (service) and Options (options)

All of these are in units of lines, and various signs are separated by spaces.
C-style backslashes can be used to insert spaces between tokens.
Double quotes can also be used to prevent a string from being split into multiple tokens by spaces.
The backslash at the end of the line is used to wrap the line, and the comment line starts with a pound sign (#) (a space is allowed).

It should be noted that this is only a grammar file, just like an xml file, without execution order, the parser obtains the desired data by reading this file, including service, action, etc.

Actions and Services declare a new grouping Section. All commands or options belong to the most recently declared group. Commands or options before the first group will be ignored.
Actions and Services have unique names. If there is a duplicate name, the second statement will be ignored as an error.

Actions

Actions are the start of a series of commands
Actions represent some Actions. Actions represent a set of commands (Commands), and Actions have a trigger (trigger) that determines when to execute this Action, that is, under what circumstances can the defined command in the Action be executed. When some conditions meet the conditions of the trigger, the command defined in the Action will be added to the end of the command queue to be executed (if this group of commands is already in the queue, it will not be added again).

Each action in the queue is extracted in turn, and each command in this action is executed in turn when an Action is removed from the queue.

The format of Action is as follows:



on <trgger> [&& <trigger>]*
   <command1>
   <command2>
   <command3>
   ...

On is followed by a trigger. When the trigger is triggered, command1, command2, and command3 will be executed in sequence until the next Action or the next Service.

To put it simply, Actions is a startup script defined by Android at startup. When the conditions are met, the script will be executed. There are some commands in the script, and different scripts are distinguished by on.

Triggers (Triggers)

Trigger is the trigger we mentioned above, which is essentially a string that can match a certain event containing the string.
Triggers are subdivided into event triggers and property triggers.
Triggers (triggers) is a string used to match specific event types to make Actions happen.

Event triggers can be triggered by the "trigger" command or via QueueEventTrigger() during the initialization process, usually some simple strings defined in advance, such as: boot, late-init
Property trigger is triggered when the variable value of the specified property becomes the specified value, and its format is property:=*

An Action can have multiple attribute triggers, but there is at most one event trigger. Let's look at two examples below:



on boot && property:a=b

This Action will only be triggered when the boot event occurs and the attributes a and b are equal.



on property:a=b && property:c=d

The Action will be triggered in the following three situations:

-At startup, if the value of attribute a is equal to b and the value of attribute c is equal to d
-When the value of attribute c is already d, the value of attribute a is updated to b
-When the value of attribute a is already b, the value of attribute c is updated to d

The following event triggers are commonly used in AIL:



Type Description
-------------------------------------------------
Triggered after boot init.rc is loaded
device-added-<path> triggers when the specified device is added
device-removed-<path> triggers when the specified device is removed
service-exited-<name> is triggered when a specific service (service) exits
Triggered before early-init initialization
Triggered after late-init initialization
Triggered when init is initialized (after /init.conf (startup configuration file) is loaded)

The trigger of Init is determined by the function action_for_each_trigger in init.c (called in the main function).

Services

A service is a program that starts with service and is started by the init process. Generally, it runs in another child process of init. Therefore, it is necessary to determine whether the corresponding executable file exists before starting the service. The sub-processes generated by init are defined in the rc file, and each service in it will generate sub-processes through the fork method at startup. The form of Services is as follows:



service <name> <pathname> [<argument> ]*
    <option>
    <option>
    ...

among them:

-name: service name
-pathname: the program location corresponding to the current service
-option: the option set by the current service
-argument optional parameter

init.rc file detailed

In order to facilitate understanding, I put the whole init.rc analysis aside, so that everyone can understand the whole process; if you want to understand the init syntax analysis under recovery, refer to this article "Init.rc syntax analysis under recovery"
The amount of code is relatively large, if you think it looks laborious, you can pick the green part to see;



# Copyright (C) 2012 The Android Open Source Project
#
# IMPORTANT: Do not create world writable files or directories.
# This is a common source of Android security bugs.
#

"[Import <filename> an init configuration file to extend the current configuration.]"
import /init.environ.rc
import /init.usb.rc
import /init.${ro.hardware}.rc
import /init.${ro.zygote}.rc
import /init.trace.rc

"[Trigger condition early-init, call the following line in the early-init phase]"
on early-init
    # Set init and its forked children's oom_adj.
    write /proc/1/oom_score_adj -1000
"[Open a file with path <path> and write one or more strings]"
    # Apply strict SELinux checking of PROT_EXEC on mmap/mprotect calls.
    write /sys/fs/selinux/checkreqprot 0

    # Set the security context for the init process.
    # This should occur before anything else (e.g. ueventd) is started.
    "[This script means that the function setcon is called immediately after the init process is started to set its security context to "u:r:init:s0", that is, the domain of the init process is designated as init.]"
    setcon u:r:init:s0

    # Set the security context of /adb_keys if present.
    "[Restore the specified file to the safe online text environment specified in the file_contexts configuration]"
    restorecon /adb_keys

"[Execute the start ueventd command. ueventd is a service with a definition behind it]"
    start ueventd

"[Mkdir <path> [mode] [owner] [group] //Create a directory <path>, you can optionally specify the mode, owner, and group. If not specified, the default permission is 755, and belongs to the root user and root group.]"
    # create mountpoints
    mkdir /mnt 0775 root system

on init
"[Set the reference of the system clock, such as 0 for GMT, which is based on Greenwich Mean Time]"
    sysclktz 0

"[Set Kernel Log Level]"
loglevel 6 ####
    write /proc/bootprof "INIT: on init start" ####
To
"[Symlink <target> <path> //Create a soft link <target> pointing to <path>.]"
    # Backward compatibility
    symlink /system/etc /etc
    symlink /sys/kernel/debug /d

    # Right now vendor lives on the same filesystem as system,
    # but someday that may change.
    symlink /system/vendor /vendor

"[Create a directory <path>, you can optionally specify mode, owner and group.]"
    # Create cgroup mount point for cpu accounting
    mkdir /acct
    mount cgroup none /acct cpuacct
    mkdir /acct/uid

"[Mount <type> <device> <dir> [<mountoption>] //Mount the specified device in the directory <dir>. <device> can specify an mtd block device in the form of mtd@name. <mountoption> Including ro, rw, remount, noatime, ...]"
    # Create cgroup mount point for memory
    mount tmpfs none /sys/fs/cgroup mode=0750,uid=0,gid=1000
    mkdir /sys/fs/cgroup/memory 0750 root system
    mount cgroup none /sys/fs/cgroup/memory memory
    write /sys/fs/cgroup/memory/memory.move_charge_at_immigrate 1
    "[Chown <owner> <group> <path> //Change the owner and group of the file.]"

    "[Some of the following lines are omitted because they are similar]"
    .....

# Healthd can trigger a full boot from charger mode by signaling this
# property when the power button is held.
on property:sys.boot_from_charger_mode=1
"[Stop all running services under the specified service category]"
    class_stop charger
    "[Trigger an event, arrange the action after a certain action (for Action queuing)]"
    trigger late-init

# Load properties from /system/ + /factory after fs mount.
on load_all_props_action
"[Load attributes from /system, /vendor. It is included in init.rc by default]"
    load_all_props

# Indicate to fw loaders that the relevant mounts are up.
on firmware_mounts_complete
"[Delete the file under the specified path]"
    rm /dev/.booting

# Mount filesystems and start core system services.
on late-init
"[Trigger an event. Used to arrange an action with another action.]"
    trigger early-fs
    trigger fs
    trigger post-fs
    trigger post-fs-data

    # Load properties from /system/ + /factory after fs mount. Place
    # this in another action so that the load will be scheduled after the prior
    # issued fs triggers have completed.
    trigger load_all_props_action

    # Remove a file to wake up anything waiting for firmware.
    trigger firmware_mounts_complete

    trigger early-boot
    trigger boot


on post-fs
...
    "[Some operations for creating directories, establishing links, and changing permissions are omitted here]"

on post-fs-data
...
"[Some operations for creating directories, establishing links, and changing permissions are omitted here]"

"[Restore the specified file to the safe online text environment specified in the file_contexts configuration]"
    restorecon /data/mediaserver

"[Set the value of the system property <name> to <value>, that is, set the system property in the form of key-value pairs]"
    # Reload policy from /data/security if present.
    setprop selinux.reload_policy 1

"[Recursively restore the specified directory to the security context specified in the file_contexts configuration]"
    # Set SELinux security contexts on upgrade or policy update.
    restorecon_recursive /data

    # If there is no fs-post-data action in the init.<device>.rc file, you
    # must uncomment this line, otherwise encrypted filesystems
    # won't work.
    # Set indication (checked by vold) that we have finished this action
    #setprop vold.post_fs_data_done 1

on boot
"[Initialize Network]"
    # basic network init
    ifup lo
    "[Set the host name to localhost]"
    hostname localhost
    "[Set the domain name localdomain]"
    domainname localdomain

"[Set Resource Limit]"
    # set RLIMIT_NICE to allow priorities from 19 to -20
    setrlimit 13 40 40

"[Some chmod, chown, and other operations are omitted here, no more explanation]"
   ...


    # Define default initial receive window size in segments.
    setprop net.tcp.default_init_rwnd 60
To
"[Restart core service]"
    class_start core

on nonencrypted
    class_start main
    class_start late_start

on property:vold.decrypt=trigger_default_encryption
    start defaultcrypto

on property:vold.decrypt=trigger_encryption
    start surfaceflinger
    start encrypt

on property:sys.init_log_level=*
    loglevel ${sys.init_log_level}

on charger
    class_start charger

on property:vold.decrypt=trigger_reset_main
    class_reset main

on property:vold.decrypt=trigger_load_persist_props
    load_persist_props

on property:vold.decrypt=trigger_post_fs_data
    trigger post-fs-data

on property:vold.decrypt=trigger_restart_min_framework
    class_start main

on property:vold.decrypt=trigger_restart_framework
    class_start main
    class_start late_start

on property:vold.decrypt=trigger_shutdown_framework
    class_reset late_start
    class_reset main

on property:sys.powerctl=*
    powerctl ${sys.powerctl}

# system server cannot write to /proc/sys files,
# and chown/chmod does not work for /proc/sys/ entries.
# So proxy writes through init.
on property:sys.sysctl.extra_free_kbytes=*
    write /proc/sys/vm/extra_free_kbytes ${sys.sysctl.extra_free_kbytes}

# "tcp_default_init_rwnd" Is too long!
on property:sys.sysctl.tcp_def_init_rwnd=*
    write /proc/sys/net/ipv4/tcp_default_init_rwnd ${sys.sysctl.tcp_def_init_rwnd}

"[Daemon Process]"
## Daemon processes to be run by init.
##
service ueventd /sbin/ueventd
    class core
    critical
    seclabel u:r:ueventd:s0

"[Log Service Process]"
service logd /system/bin/logd
    class core
    socket logd stream 0666 logd logd
    socket logdr seqpacket 0666 logd logd
    socket logdw dgram 0222 logd logd
    seclabel u:r:logd:s0

"[Healthd is an intermediary model proposed after android4.4. This model listens to battery events from the bottom layer and transmits battery data information upward to the BatteryService of the Framework layer to calculate battery power related status information]"
service healthd /sbin/healthd
    class core
    critical
    seclabel u:r:healthd:s0

"[Console Process]"
service console /system/bin/sh
"[Set a category for the current service. Services of the same category will be started or stopped at the same time, the default class name is default]"
    class core
    "[Service requires a console]"
    console
    "[The service will not start automatically, it must be explicitly started by the service name]"
    disabled
    "[Switch the user name before executing this service, the current default is root. Since Android M, even if it requires linux capabilities, this option should be used. Obviously, in order to get this function, the process needs to be run as root]"
    user shell
    seclabel u:r:shell:s0

on property:ro.debuggable=1
    start console

# adbd is controlled via property triggers in init.<platform>.usb.rc
service adbd /sbin/adbd --root_seclabel=u:r:su:s0
    class core
    "[Create a socket under the unix domain, which is named /dev/socket/<name>. And returns its file descriptor fd to the service process. Among them, the type must be dgram, stream or seqpacke, and the default for user and group is 0.seclabel is the security context of the SELLinux of the socket, the default is the context of the current service, specified by seclabel]"
    socket adbd stream 660 system system
    disabled
    seclabel u:r:adbd:s0

# adbd on at boot in emulator
on property:ro.kernel.qemu=1
    start adbd

"[Memory management service, memory is insufficient to release memory]"
service lmkd /system/bin/lmkd
    class core
    critical
    socket lmkd seqpacket 0660 system system

"[ServiceManager is a daemon process that maintains the binder communication between system services and clients.
The most used communication mechanism in the Android system is Binder, which is mainly composed of Client, Server, ServiceManager and Binder drivers. Among them, Client, Service, and ServiceManager run in user space, while Binder driver runs in kernel space. The core component is the Binder driver, and ServiceManager provides auxiliary management functions, whether it is Client or Service before communicating with ServiceManager. The ServiceManager is a daemon process that is responsible for managing the Server and providing the client with the function of querying the Server. 】"
service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    "[Zygote service will be restarted when the servicemanager service starts]"
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

"[Vold is the abbreviation of Volume Daemon, it is the control center of the external storage system in the Android platform, and is the background process for managing and controlling the external storage device of the Android platform]"
service vold /system/bin/vold
    class core
    socket vold stream 0660 root mount
    ioprio be 2

"[Netd is a background daemon program specifically responsible for network management and control in the Android system]"
service netd /system/bin/netd
    class main
    socket netd stream 0660 root system
    socket dnsproxyd stream 0660 root inet
    socket mdns stream 0660 root system
    socket fwmarkd stream 0660 root inet

"[Debuggerd is a daemon process, which starts with the init process when the system starts. It is mainly responsible for dumping the information of the process running to a file or console]"
service debuggerd /system/bin/debuggerd
    class main

service debuggerd64 /system/bin/debuggerd64
    class main

"[Android RIL (Radio Interface Layer) provides an abstraction layer between Telephony services and Radio hardware]"
# for using TK init.modem.rc rild-daemon setting
#service ril-daemon /system/bin/rild
# class main
# socket rild stream 660 root radio
# socket rild-debug stream 660 radio system
# user root
# group radio cache inet misc audio log

"[Provides a system-wide surface composer function, which can combine 2D and 3D surfaces of various applications.]"
service surfaceflinger /system/bin/surfaceflinger
    class core
    user system
    group graphics drmrpc
    onrestart restart zygote

"[DRM can directly access the hardware of DRM clients. The DRM driver is used to handle DMA, memory management, resource locks, and secure hardware access. In order to support multiple 3D applications at the same time, the 3D graphics card hardware must be used as a shared resource, so a lock is required Provide mutually exclusive access. DMA transfer and AGP interface are used to send buffers for graphics operations to the graphics hardware, so it is necessary to prevent the client from unauthorized access to the graphics hardware.]"
#make sure drm server has rights to read and write sdcard ####
service drm /system/bin/drmserver
    class main
    user drm
    # group drm system inet drmrpc ####
    group drm system inet drmrpc sdcard_r ####

"[Media Services, no need to say more]"
service media /system/bin/mediaserver
    class main
    user root ####
# google default ####
# user media ####
    group audio camera inet net_bt net_bt_admin net_bw_acct drmrpc mediadrm media sdcard_r system net_bt_stack ####
# google default ####
# group audio camera inet net_bt net_bt_admin net_bw_acct drmrpc mediadrm ####

    ioprio rt 4

"[Device Encryption Related Services]"
# One shot invocation to deal with encrypted volume.
service defaultcrypto /system/bin/vdc --wait cryptfs mountdefaultencrypted
    disabled
    "[When the service exits, do not restart the service]"
    oneshot
    # vold will set vold.decrypt to trigger_restart_framework (default
    # encryption) or trigger_restart_min_framework (other encryption)

# One shot invocation to encrypt unencrypted volumes
service encrypt /system/bin/vdc --wait cryptfs enablecrypto inplace default
    disabled
    oneshot
    # vold will set vold.decrypt to trigger_restart_framework (default
    # encryption)

"[Startup Animation Service]"
service bootanim /system/bin/bootanimation
    class core
    user graphics
# group graphics audio ####
    group graphics media audio ####
    disabled
    oneshot

"[In the Android system, PackageManagerService is used to manage all the installation package information in the system and the installation and uninstallation of applications, but the installation and uninstallation of applications is not completed by PackageManagerService, but through PackageManagerService to access the installd service to execute the package Installed and uninstalled.]"
service installd /system/bin/installd
    class main
    socket installd stream 600 system system

service flash_recovery /system/bin/install-recovery.sh
    class main
    seclabel u:r:install_recovery:s0
    oneshot

"[Vpn related services]"
service racoon /system/bin/racoon
    class main
    socket racoon stream 600 system system
    # IKE uses UDP port 500. Racoon will setuid to vpn after binding the port.
    group vpn net_admin inet
    disabled
    oneshot

"[There are mtpd commands in android to connect to vpn]"
service mtpd /system/bin/mtpd
    class main
    socket mtpd stream 600 system system
    user vpn
    group vpn net_admin inet net_raw
    disabled
    oneshot

service keystore /system/bin/keystore /data/misc/keystore
    class main
    user keystore
    group keystore drmrpc

"[You can use dumpstate to obtain various information about the device]"
service dumpstate /system/bin/dumpstate -s
    class main
    socket dumpstate stream 0660 shell log
    disabled
    oneshot

"[Mdnsd is a daemon for multicast DNS and DNS service discovery.]"
service mdnsd /system/bin/mdnsd
    class main
    user mdnsr
    group inet net_raw
    socket mdnsd stream 0660 mdnsr inet
    disabled
    oneshot

"[Trigger shutdown process to continue down]"
service pre-recovery /system/bin/uncrypt
    class main
    disabled
    "[When the service exits, do not restart the service]"
    oneshot

init.c full analysis

Next, we analyze the execution process of the following main function in detail; it may be relatively long, so please take a look:




int main( int argc, char **argv)
{
#Create some directories in the linux root file system
mkdir( "/dev", 0755 );
mkdir( "/proc", 0755 );
mkdir( "/sys", 0755 );

mount( "tmpfs", "/dev", "tmpfs", 0, "mode=0755" );
mkdir( "/dev/pts", 0755 );
mkdir( "/dev/socket", 0755 );
mount( "devpts", "/dev/pts", "devpts", 0, NULL );
mount( "proc", "/proc", "proc", 0, NULL );
mount( "sysfs", "/sys", "sysfs", 0, NULL );
#init's standard input, standard output, and standard error file descriptors are directed to __null__, which means that there is no input and output, and all its input and output are written to Log
open_devnull_stdio();
#Initial log Write init information
log_init();
#Read and parse the init.rc file (this file is in the root directory)
parse_config_file( "/init.rc" );
#Get hardware To print our device name fs100
get_hardware_name();
snprintf( tmp, sizeof(tmp), "/init.%s.rc", hardware );
    #Read and parse hardware-related init script files,
parse_config_file( tmp );
# Trigger the action named early-init in the init script file and execute its commands, which is actually: on early-init
action_for_each_trigger( "early-init", action_add_queue_tail );
drain_action_queue();
#Initialize dynamic device management, react to the kernel when the device file changes, which will be explained later
device_fd = device_init(); # Initialize device management
#Load the startup animation. If the animation fails to open, print on the screen: A N D R O I D.
if (load_565rle_image( INIT_IMAGE_FILE))
{
fd = open( "/dev/tty0", O_WRONLY );
if (fd >= 0)
{
const char *msg;
msg = "\n"
"\n"
"\n"
879 "\n"
"\n"
"\n"
"\n" /* console is 40 cols x 30 lines */
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
/* "A N D R O I D "; boot animation */
write( fd, msg, strlen( msg) );
close( fd );
}
}

#Trigger The action named init in the init script file and execute its commands is actually: on init
action_for_each_trigger( "init", action_add_queue_tail );
drain_action_queue();
#Start the system property service: system property service
property_set_fd = start_property_service();
#Create socket to handle orphan process signals
if (socketpair( AF_UNIX, SOCK_STREAM, 0, s) == 0)
{
signal_fd = s[0];
signal_recv_fd = s[1];
fcntl( s[0], F_SETFD, FD_CLOEXEC );
fcntl( s[0], F_SETFL, O_NONBLOCK );
fcntl( s[1], F_SETFD, FD_CLOEXEC );
fcntl( s[1], F_SETFL, O_NONBLOCK );
}
#Trigger The actions named early-boot and boot in the init script file and execute their commands are actually: on early-boot and on boot
action_for_each_trigger( "early-boot", action_add_queue_tail );
action_for_each_trigger( "boot", action_add_queue_tail );
drain_action_queue();
#Start all property change trigger commands, which is actually: on property:ro.xx.xx=xx
queue_all_property_triggers();
drain_action_queue();
#Enter the infinite loop ()
for (;;)
{
#Start all services declared in the init script,
#如：266 service servicemanager /system/bin/servicemanager
#user system
#critical
#onrestart restart zygote
#onrestart restart media
restart_processes();
#Multi-channel monitoring equipment management, child process running status, attribute service
nr = poll( ufds, fd_count, timeout );
if (nr <= 0)
continue;
if (ufds[2].revents == POLLIN)
{
read( signal_recv_fd, tmp, sizeof(tmp) );
while (!wait_for_one_process( 0))
;
continue;
}

if (ufds[0].revents == POLLIN)
handle_device_fd( device_fd );

if (ufds[1].revents == POLLIN)
handle_property_set_fd( property_set_fd );
if (ufds[3].revents == POLLIN)
handle_keychord( keychord_fd );
}

return(0);
}

Most complete ADB command manual

larson — Tue, 12 Jan 2021 09:58:19 +0000

What is ADB
ADB Architecture
ADB port is occupied
Basic usage
- Command syntax
- Specify the target device for the command
- start stop
- View adb version
- Run adbd as root
- Specify the network port of adb server
Device connection management
- Query connected devices/emulators
- USB connection
- Wireless connection (USB cable required)
- Wireless connection (no need to use USB cable)
Application Management
- View application list
- All applications
- system applications
- third-party usage
- Install APK
- Adb install internal principle introduction
- Uninstall the app
- Clear application data and cache
- View foreground activity
- View running Services
- View application details
Interact with the application
- Activating Activity
- Transfer Service
- Send broadcast
- Forcibly stop the application
- Disable apps and start
- Revoke the permissions of the application
File Management
- Copy the files in the device to the computer
- Copy files from computer to device
Simulation key/input
- Power button
- menu
- HOME key
- return key
- volume control
- Media Control
- Turn on/off the screen
- Slide to unlock
- Enter text
View log
- Android log
- Kernel log
View device information
- Model
- Battery status
- Screen Resolution
- Screen density
- Display parameters
- android_id
- IMEI
- Android system version
- IP address
- Mac address
- CPU information
- Memory information
- More hardware and system properties
Modify settings
- Resolution
- Screen density
- Display area
- Turn off USB debugging mode
- Display and hide status bar and navigation bar
- Return to normal mode
Useful functions
- Screenshots
- Record screen
- Remount.
- View connected WiFi passwords
- Set the system date and time
- restart cellphone
- Check if the device is rooted
- Use Monkey for stress testing
- Turn on/off WiFi
- Turn on/off data traffic
Flashing related commands
- Restart to Recovery mode
- Restart from Recovery to Android
- Restart to Fastboot mode
- Update the system via sideload
- More adb shell commands
- View process
- View real-time resource usage
- View process UID
- Other
Security related
- Enable SELinux
- Disable SELinux
- Enable dm_verity
- Disable dm_verity
common problem
- Failed to start adb server

*The content of this article is integrated from the Internet, welcome to reprint. *

I believe that friends who do Android development have used ADB commands, but they are only limited to installing application push files and device restarting. I don’t know the deeper ones. In fact, we can understand a little more. There are some uncommon scenarios we should at least Knowing that it can be done, for example, we know adb install but not adb shell am start. The former is used to install software, and the latter is used to open the software. A usage scenario of the latter makes me pay attention to him: the company customizes the Android system. When debugging the screen, it depends on whether the screen is full to verify that the driver is normal. This is a troublesome approach. It is to be installed and opened in the hands of Android developers with eclipse or other ide. Obviously, it is much more complicated than the driver who connects the data line and uses the adb command. Therefore, it is necessary to know more.

The following may be more cumbersome, I will try to be simple, please be patient and finish reading.

What is ADB

The full name of Adb is Android Debug Bridge: Android Debug Bridge. The picture below shows the official introduction of Adb by Android:

It can be seen that the original intention of Android is to use a tool such as adb to assist developers in debugging apk faster and better in the process of developing android applications, so adb has the ability to install and uninstall apk, copy and push files, view device hardware information, and view Functions such as applications occupying resources and executing shell commands on the device;

We can find the adb tool in the platform-tools directory of the android sdk installation directory;

The permission mechanism of the existing Android system is becoming more and more perfect. Many operations that hope to bypass the permission management mechanism are no longer available, but Adb can achieve it. In fact, Adb has a lot of authority to some extent, even on the latest version of the Android system. Because Adb is designed to facilitate debugging by developers, it is necessary to expose some interfaces outside of permissions. So many companies can use this feature to bypass the permission mechanism to do some operations on non-Root non-customized machines (the specific usage is mentioned below), of course, there are also various ways, such as connecting via mobile phone OTG, which will not be repeated here.

ADB Architecture

In order to facilitate understanding, we start with three instructions, we often use adb start-server, adb devices, adb kill-server.
Then we often see this output interface:



C:\Users\dell>adb devices
List of devices attached
* daemon not running. starting it now at tcp:5037 *
* daemon started successfully *

So there are three questions here, why is the server, the server corresponds to the server or the server? If the mobile phone is the client, does the server refer to the service opened on the computer. And what is this daemon?

ADB is a C/S architecture application, composed of three parts:

Adb client running on the PC side: The command line program "adb" is used to run adb commands from a shell or script. First, the "adb" program tries to locate the ADB server on the host. If the ADB server cannot be found, the "adb" program automatically starts an ADB server. Next, when the adbd of the device and the adb server on the pc side establish a connection, the adb client can send a service request to the ADB servcer;
Adb server running on the PC side: ADB Server is a background process running on the host. Its function is to detect the connection and removal of the USB port sensing device, and the start or stop of the emulator instance. ADB Server also needs to send the request of the adb client to the corresponding adbd via usb or tcp;
The resident process adb demon (adbd) running on the device side: The program "adbd" runs as a background process in the Android device or emulator system. Its function is to connect to the ADB server and provide some services for the client running on the host;

ADB port is occupied

A small partner said that he hoped that I would put the Adb startup problem at the top, because he often encountered the problem of adb unable to find the device, then I will put it in front, I think it is definitely not only she will encounter this situation .

5037 is the default port of adb. If port 5037 is occupied, we will be troubled by not finding the device when using the Adb command. This problem is often encountered for those who are not very familiar with Adb, so I will This usage is placed at the beginning of the article so that friends can find it easily;
The idea of solving this kind of port occupation problem is the same, three steps:

Find the Pid of the process using the port;



C:\Windows\system32>netstat -aon|findstr 5037
TCP 127.0.0.1:5037 0.0.0.0:0 LISTENING 3172

Find the corresponding process name through PID (easy to locate, you can skip);



C:\Windows\system32>tasklist /fi "PID eq 3172"

Image name PID session name session# memory usage
========================= ======== ================ = ========== ============
360MobileLink.exe 3172 Console 4 40,208 K

Use the command to terminate the operation of the command;



C:\Users\wwx229495>taskkill /pid 3172 /f
Success: The process with PID 3172 has been terminated.

Sometimes, some rogue programs will copy a copy of Adb.exe to the windows environment variable, such as C://Windows/system32, at this time we can use Where
The Adb command finds out the path where adb is located and deletes it.

Basic usage

What can adb do? The answer is that all operations that can be performed on mobile phones can be implemented with adb. That is to say, if you play 6, your touch screen is completely broken, and the display is completely broken, just give you a motherboard, and you can still complete the actions you want to do. Of course, this is not recommended in general scenarios, efficiency is the priority.

The following content is transferred from the blog of a big cow on github. If there is any infringement, please inform and delete it immediately;
Late

Command syntax

The basic syntax of the adb command is as follows:

adb [-d|-e|-s ]

If there is only one device/emulator connected, you can omit the part [-d|-e|-s ] and use adb directly.

Specify the target device for the command

If there are multiple devices/emulators connected, you need to specify the target device for the command.

Parameters	Meaning
-d	Specify the only Android device currently connected via USB as the command target
-e	Specify the only simulator currently running as the command target
`-s <serialNumber>`	Specify the device/emulator with the corresponding serialNumber number as the command target

When multiple devices/emulators are connected, the -s parameter is commonly used. The serialNumber can be obtained through the adb devices command. Such as:



$ adb devices

List of devices attached
cf264b8f device
emulator-5554 device
10.129.164.6:5555 device

Cf264b8f, emulator-5554 and 10.129.164.6:5555 in the output are serialNumber.

For example, you want to specify the device cf264b8f to run the adb command to obtain the screen resolution:



adb -s cf264b8f shell wm size

Another example is to install an application on the device 10.129.164.6:5555 (the format of serialNumber in this form is :, which is generally a wirelessly connected device or a third-party Android emulator such as Genymotion):



adb -s 10.129.164.6:5555 install test.apk

*In the case of multiple devices/simulators, these parameters are used to specify the target device for the command. The following is a simplified description and will not be repeated. *

start stop

Start the adb server command:



adb start-server

(Generally, there is no need to manually execute this command. If you find that the adb server is not started when running the adb command, it will be automatically activated.)

Stop the adb server command:



adb kill-server

View adb version



adb version

Sample output



Android Debug Bridge version 1.0.36
Revision 8f855a3d9b35-android

Run adbd as root

The operating principle of adb is that the adb server on the PC side establishes a connection with the daemon adbd on the mobile phone side, and then the adb client on the PC side forwards the command through the adb server, and adbd parses and runs after receiving the command.

So if adbd is executed with normal permissions, some commands that require root permissions to execute cannot be directly executed with adb xxx. At this time, you can execute commands after adb shell and then su, or you can let adbd execute with root privileges, which can execute high-privileged commands at will.

command:



adb root

Normal output:



restarting adbd as root

Now run adb shell again and see if the command line prompt becomes #?

Some mobile phones cannot be executed with root privileges through the adb root command after rooting. For example, some Samsung models will prompt adbd cannot run as root in production builds. You can install adbd Insecure first, and then adb root Try it.

Correspondingly, if you want to restore adbd to non-root privileges, you can use the adb unroot command.

Specify the network port of adb server



adb -P <port> start-server

The default port is 5037.

Device connection management

Query connected devices/emulators

command:



adb devices

Sample output:



List of devices attached
cf264b8f device
emulator-5554 device
10.129.164.6:5555 device

The output format is [serialNumber] [state], serialNumber is what we often call SN, and the state is as follows:

offline —— Indicates that the device is not successfully connected or has no response.

device-The device is connected. Note that this state does not indicate that the Android system has been fully started and operable. The device instance can be connected to adb during the device startup process, but the system will be in an operable state after startup.

no device —— No device/emulator connection.

The above output shows that three devices/emulators are currently connected, and cf264b8f, emulator-5554 and 10.129.164.6:5555 are their SNs respectively. It can be seen from the name emulator-5554 that it is an Android emulator, and 10.129.164.6:5555, which is the serialNumber of the form :, is generally a wirelessly connected device or a third-party Android emulator such as Genymotion.

Common abnormal output:

No device/emulator is successfully connected.

List of devices attached
The device/emulator is not connected to adb or not responding.

List of devices attached
cf264b8f offline

USB connection

To use adb normally through USB connection, you need to ensure several points:

The hardware status is normal.

Including the Android device is in the normal boot state, the USB cable and various interfaces are intact.

Developer options and USB debugging mode for Android devices are turned on.

You can go to "Settings"-"Developer Options"-"Android Debugging" to view.

If you can't find the developer option in the settings, you need to use an easter egg to show it: click the "version number" 7 times in "Settings"-"About Phone".

The device drive status is normal.

It seems that you don’t need to worry about this under Linux and Mac OS X. Under Windows, you may encounter a situation where you need to install a driver. To confirm this, you can right-click "Computer"-"Properties" and go to the "Device Manager" to view related devices Whether there is a yellow exclamation mark or question mark, if not, it means the drive status is good. Otherwise, you can download a mobile assistant program to install the driver first.

Confirm the status after connecting the computer and the device via the USB cable.



adb devices

If you can see
xxxxxx device
The connection is successful.

Wireless connection (USB cable required)

In addition to connecting the device and the computer via USB to use adb, you can also use a wireless connection-although there are steps to use USB during the connection process, your device can get rid of the limitation of the USB cable within a certain range after the connection is successful. !

Steps:
Connect the Android device and the computer to run adb to the same local area network, for example to the same WiFi.
Connect the device to the computer via a USB cable.
Make sure that the connection is successful (you can run adb devices to see if the device can be listed).
Let the device monitor TCP/IP connections on port 5555:



adb tcpip 5555

Disconnect the USB connection.
Find the IP address of the device.
Generally, it can be found in "Settings"-"About Phone"-"Status Information"-"IP Address", or you can use the adb command to view it using the method in the section View Device Information-IP Address below.

Connect the device by IP address.



adb connect <device-ip-address>

Here is the device IP address found in the previous step.

Confirm the connection status.



adb devices

If you can see



<device-ip-address>:5555 device

The connection is successful.
If you can't connect, please confirm that the Android device and the computer are connected to the same WiFi, and then execute the step of adb connect <device-ip-address> again;
If it still does not work, restart adb via adb kill-server and try again from the beginning.

Disconnect wireless connection
command:



adb disconnect <device-ip-address>

Wireless connection (no need to use USB cable)

Note: root permission is required.

The previous section "Wireless connection (requires USB cable)" is the method introduced in the official document, which requires the help of USB data cable to achieve wireless connection.
Since we want to achieve wireless connection, can all steps be wireless? The answer is yes.
Install a terminal emulator on the Android device.
Devices that have already been installed can skip this step. The download address of the terminal emulator I use is: Terminal Emulator for Android Downloads
Connect the Android device and the computer to run adb to the same local area network, for example to the same WiFi.
Open the terminal emulator on the Android device and run the commands in sequence:



su
setprop service.adb.tcp.port 5555

Find the IP address of the Android device.

Generally, it can be found in "Settings"-"About Phone"-"Status Information"-"IP Address", or you can use the adb command to view it using the method in the section View Device Information-IP Address below.

Connect the Android device via adb and IP address on the computer.



adb connect <device-ip-address>

Here is the device IP address found in the previous step.

If you can see the output connected to :5555, it means the connection is successful.

Section Note 1:

Some devices, such as Xiaomi 5S + MIUI 8.0 + Android 6.0.1 MXB48T, may need to restart the adbd service before step 5, and run on the device's terminal emulator:



restart adbd

If restart does not work, try the following command:



stop adbd
start adbd

Application Management

View application list

The basic command format for viewing the application list is



adb shell pm list packages [-f] [-d] [-e] [-s] [-3] [-i] [-u] [--user USER_ID] [FILTER]

That is, on the basis of adb shell pm list packages, you can add some parameters to filter and view different lists. The supported filter parameters are as follows:

Parameters	Display list
None	All applications
-f	Display the apk file associated with the application
-d	Only display disabled apps
-e	Only show enabled apps
-s	Only show system apps
-3	Only display third-party applications
-i	Display the installer of the application
-u	Include uninstalled apps
`<FILTER>`	Package name contains `<FILTER>` string

All applications

command:



adb shell pm list packages

Sample output:



package:com.android.smoketest
package:com.example.android.livecubes
package:com.android.providers.telephony
package:com.google.android.googlequicksearchbox
package:com.android.providers.calendar
package:com.android.providers.media
package:com.android.protips
package:com.android.documentsui
package:com.android.gallery
package:com.android.externalstorage
...
// other packages here
...

system applications

command:



adb shell pm list packages -s

third-party usage

command:



adb shell pm list packages -3

Applications whose package name contains a certain string
For example, to view the list of applications whose package name contains the string mazhuang, command:



adb shell pm list packages mazhuang

Of course, you can also use grep to filter:



adb shell pm list packages | grep mazhuang

Install APK

Command format:



adb install [-lrtsdg] <path_to_apk>

parameter:

Adb install can be followed by some optional parameters to control the behavior of installing APK. The available parameters and their meanings are as follows:

Parameters	Meaning
-l	Install the application to the protected directory /mnt/asec
-r	Allow overwrite installation
-t	Allow to install the application specified by application `android:testOnly="true"` in AndroidManifest.xml
-s	Install the application to the sdcard
-d	Allow downgrade to overwrite installation
-g	Grant all runtime permissions

After running the command, if you see output similar to the following (the status is Success), the installation is successful:



[100%] /data/local/tmp/1.apk
pkg: /data/local/tmp/1.apk
Success

The above is the output of the latest version of adb of v1.0.36, which will show the progress percentage of pushing the apk file to the phone.

Using the old version of adb, the output is like this:



12040 KB/s (22205609 bytes in 1.801s)
        pkg: /data/local/tmp/SogouInput_android_v8.3_sweb.apk
Success

And if the status is Failure, the installation failed, for example:



[100%] /data/local/tmp/map-20160831.apk
        pkg: /data/local/tmp/map-20160831.apk
Failure [INSTALL_FAILED_ALREADY_EXISTS]

Common installation failure output codes, meanings and possible solutions are as follows:

when parsing APK file

Output	Meaning	Solution
INSTALL_FAILED_ALREADY_EXISTS	The application already exists, or uninstalled but not uninstalled cleanly	`adb install`, use the `-r` parameter, or first `adb uninstall <packagename>` and then install
INSTALL_FAILED_INVALID_APK	Invalid APK file
INSTALL_FAILED_INVALID_URI	Invalid APK file name	Make sure there is no Chinese in the APK file name
INSTALL_FAILED_INSUFFICIENT_STORAGE	Not enough space	Clean up space
INSTALL_FAILED_DUPLICATE_PACKAGE	A program with the same name already exists
INSTALL_FAILED_NO_SHARED_USER	The requested shared user does not exist
INSTALL_FAILED_UPDATE_INCOMPATIBLE	The application with the same name has been installed before, but the data is not removed when uninstalling; or the application has been installed, but the signature is inconsistent	First `adb uninstall <packagename>` then install
INSTALL_FAILED_SHARED_USER_INCOMPATIBLE	The requested shared user exists but the signature is inconsistent
INSTALL_FAILED_MISSING_SHARED_LIBRARY	The installation package uses a shared library that is not available on the device
INSTALL_FAILED_REPLACE_COULDNT_DELETE	Cannot be deleted when replacing
INSTALL_FAILED_DEXOPT	dex optimization verification failed or insufficient space
INSTALL_FAILED_OLDER_SDK	The device system version is lower than the application requirements
INSTALL_FAILED_CONFLICTING_PROVIDER	A content provider with the same name as the app already exists in the device
INSTALL_FAILED_NEWER_SDK	The device system version is higher than the application requirements
INSTALL_FAILED_TEST_ONLY	The application is test-only, but the `-t` parameter is not specified during installation
INSTALL_FAILED_CPU_ABI_INCOMPATIBLE	Contains native code of incompatible device CPU application binary interface
INSTALL_FAILED_MISSING_FEATURE	The application uses a feature that is not available on the device
INSTALL_FAILED_CONTAINER_ERROR	1. sdcard access failed; 2. The application signature is consistent with the ROM signature and is regarded as a built-in application.	1. Confirm that the sdcard is available, or install it to the built-in storage; 2. Do not use the same signature as the ROM when packaging.
INSTALL_FAILED_INVALID_INSTALL_LOCATION	1. Cannot be installed to the specified location; 2. The application signature is consistent with the ROM signature and is regarded as a built-in application.	1. Switch the installation location, add or delete the `-s` parameter; 2. Do not use the same signature as the ROM when packaging.
INSTALL_FAILED_MEDIA_UNAVAILABLE	The installation location is not available	Usually sdcard, confirm that the sdcard is available or install to the built-in storage
INSTALL_FAILED_VERIFICATION_TIMEOUT	Verify installation package timeout
INSTALL_FAILED_VERIFICATION_FAILURE	Failed to verify the installation package
INSTALL_FAILED_PACKAGE_CHANGED	The application does not match the expectations of the calling program
INSTALL_FAILED_UID_CHANGED	The application has been installed before, and it is not consistent with the UID assigned this time	Clean up residual files from previous installations
INSTALL_FAILED_VERSION_DOWNGRADE	A newer version of this app has been installed	Use the `-d` parameter
INSTALL_FAILED_PERMISSION_MODEL_DOWNGRADE	The installed target SDK supports the application of the same name with runtime permissions, and the version to be installed does not support runtime permissions
INSTALL_PARSE_FAILED_NOT_APK	The specified path is not a file or does not end with `.apk`
INSTALL_PARSE_FAILED_BAD_MANIFEST	Unable to parse AndroidManifest.xml file
INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION	The parser encountered an exception
INSTALL_PARSE_FAILED_NO_CERTIFICATES	The installation package is not signed
INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES	The app has been installed, and the signature is inconsistent with the APK file	Uninstall the app on the device first, then install it
INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING	`CertificateEncodingException`
INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME	There is no or invalid package name in the manifest file
INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID	An invalid shared user ID is specified in the manifest file
INSTALL_PARSE_FAILED_MANIFEST_MALFORMED	A structural error was encountered while parsing the manifest file
INSTALL_PARSE_FAILED_MANIFEST_EMPTY	The operable tag (instrumentation or application) could not be found in the manifest file
INSTALL_FAILED_INTERNAL_ERROR	Installation failed due to system problems
INSTALL_FAILED_USER_RESTRICTED	Users are restricted from installing apps
INSTALL_FAILED_DUPLICATE_PERMISSION	The application tries to define an existing permission name
INSTALL_FAILED_NO_MATCHING_ABIS	The application contains native code not supported by the application binary interface of the device
INSTALL_CANCELED_BY_USER	App installation needs to be confirmed on the device, but the device is not operated or canceled	Agree to install on the device
INSTALL_FAILED_ACWF_INCOMPATIBLE	The application is not compatible with the device
does not contain AndroidManifest.xml	Invalid APK file
is not a valid zip file	Invalid APK file
Offline	The device is not connected successfully	First connect the device to adb successfully
unauthorized	The device is not authorized to allow debugging
error: device not found	There is no successfully connected device	First connect the device to adb successfully
protocol failure	The device has been disconnected	First connect the device to adb successfully
Unknown option: -s	Installation to sdcard is not supported under Android 2.2	Do not use the `-s` parameter
No space left on device	Not enough space	Clean up space
Permission denied ... sdcard ...	sdcard is not available
signatures do not match the previously installed version; ignoring!	The app has been installed and the signatures are inconsistent	Uninstall the app on the device first, then install it

Reference: [PackageManager.java]

Adb install internal principle introduction

adb install is actually completed in three steps:

Push the apk file to /data/local/tmp.
Call pm install to install.
Delete the corresponding apk file under /data/local/tmp.

Therefore, when necessary, you can also follow this step to manually perform the installation process step by step.

Uninstall the app

command:



adb uninstall [-k] <packagename>

<packagename> represents the package name of the application, and the -k parameter is optional, meaning that the application is uninstalled but the data and cache directory are retained.
Command example:



adb uninstall com.qihoo360.mobilesafe

Means to uninstall 360 Mobile Guard.

Clear application data and cache

command:



adb shell pm clear <packagename>

<packagename> represents the application name package. The effect of this command is equivalent to clicking "Clear Cache" and "Clear Data" on the application information interface in the settings.

Command example:



adb shell pm clear com.qihoo360.mobilesafe

Means to clear the data and cache of 360 Mobile Guard.

View foreground activity

command:



adb shell dumpsys activity activities | grep mFocusedActivity

Sample output:



mFocusedActivity: ActivityRecord{8079d7e u0 com.cyanogenmod.trebuchet/com.android.launcher3.Launcher t42}

Among them, com.cyanogenmod.trebuchet/com.android.launcher3.Launcher is the Activity currently in the foreground.

View running Services

command:



adb shell dumpsys activity services [<packagename>]

The <packagename> parameter is not necessary. Specifying <packagename> means viewing the Services related to a certain package name, and not specifying it means viewing all Services.

<packagename> does not have to give a complete package name. For example, if you run adb shell dumpsys activity services org.mazhuang, then the package name org.mazhuang.demo1, org.mazhuang.demo2, org.mazhuang123 and other related Services will be listed come out.

View application details

command:



adb shell dumpsys package <packagename>

The output contains a lot of information, including Activity Resolver Table, Registered ContentProviders, package name, userId, path to file resource code after installation, version information, permission information and grant status, signature version information, etc.

<packagename> represents the application package name.

Sample output:



Activity Resolver Table:
  Non-Data Actions:
      android.intent.action.MAIN:
        5b4cba8 org.mazhuang.guanggoo/.SplashActivity filter 5ec9dcc
          Action: "android.intent.action.MAIN"
          Category: "android.intent.category.LAUNCHER"
          AutoVerify=false

Registered ContentProviders:
  org.mazhuang.guanggoo/com.tencent.bugly.beta.utils.BuglyFileProvider:
    Provider{7a3c394 org.mazhuang.guanggoo/com.tencent.bugly.beta.utils.BuglyFileProvider}

ContentProvider Authorities:
  [org.mazhuang.guanggoo.fileProvider]:
    Provider{7a3c394 org.mazhuang.guanggoo/com.tencent.bugly.beta.utils.BuglyFileProvider}
      applicationInfo=ApplicationInfo{7754242 org.mazhuang.guanggoo}

Key Set Manager:
  [org.mazhuang.guanggoo]
      Signing KeySets: 501

Packages:
  Package [org.mazhuang.guanggoo] (c1d7f):
    userId=10394
    pkg=Package{55f714c org.mazhuang.guanggoo}
    codePath=/data/app/org.mazhuang.guanggoo-2
    resourcePath=/data/app/org.mazhuang.guanggoo-2
    legacyNativeLibraryDir=/data/app/org.mazhuang.guanggoo-2/lib
    primaryCpuAbi=null
    secondaryCpuAbi=null
    versionCode=74 minSdk=15 targetSdk=25
    versionName=1.1.74
    splits=[base]
    apkSigningVersion=2
    applicationInfo=ApplicationInfo{7754242 org.mazhuang.guanggoo}
    flags=[ HAS_CODE ALLOW_CLEAR_USER_DATA ALLOW_BACKUP]
    privateFlags=[ RESIZEABLE_ACTIVITIES]
    dataDir=/data/user/0/org.mazhuang.guanggoo
    supportsScreens=[small, medium, large, xlarge, resizeable, anyDensity]
    timeStamp=2017-10-22 23:50:53
    firstInstallTime=2017-10-22 23:50:25
    lastUpdateTime=2017-10-22 23:50:55
    installerPackageName=com.miui.packageinstaller
    signatures=PackageSignatures{af09595 [53c7caa2]}
    installPermissionsFixed=true installStatus=1
    pkgFlags=[ HAS_CODE ALLOW_CLEAR_USER_DATA ALLOW_BACKUP]
    requested permissions:
      android.permission.READ_PHONE_STATE
      android.permission.INTERNET
      android.permission.ACCESS_NETWORK_STATE
      android.permission.ACCESS_WIFI_STATE
      android.permission.READ_LOGS
      android.permission.WRITE_EXTERNAL_STORAGE
      android.permission.READ_EXTERNAL_STORAGE
    install permissions:
      android.permission.INTERNET: granted=true
      android.permission.ACCESS_NETWORK_STATE: granted=true
      android.permission.ACCESS_WIFI_STATE: granted=true
    User 0: ceDataInode=1155675 installed=true hidden=false suspended=false stopped=true notLaunched=false enabled=0
      gids=[3003]
      runtime permissions:
        android.permission.READ_EXTERNAL_STORAGE: granted=true
        android.permission.READ_PHONE_STATE: granted=true
        android.permission.WRITE_EXTERNAL_STORAGE: granted=true
    User 999: ceDataInode=0 installed=false hidden=false suspended=false stopped=true notLaunched=true enabled=0
      gids=[3003]
      runtime permissions:


Dexopt state:
  [org.mazhuang.guanggoo]
    Instruction Set: arm64
      path: /data/app/org.mazhuang.guanggoo-2/base.apk
      status: /data/app/org.mazhuang.guanggoo-2/oat/arm64/base.odex [compilation_filter=speed-profile, status=kOatUpToDa
      te]

Interact with the application

Mainly use the am <command> command, the commonly used <command> are as follows:

command	Use
`start [options] <INTENT>`	Start the activity specified by `<INTENT>`
`startservice [options] <INTENT>`	Start the service specified by `<INTENT>`
`broadcast [options] <INTENT>`	Send the broadcast specified by `<INTENT>`
`force-stop <packagename>`	Stop `<packagename>` related processes

<INTENT> The parameters are very flexible, and correspond to the Intent in the code when writing Android programs.

The options used to determine the intent object are as follows:

Parameters	Meaning
`-a <ACTION>`	Specify the action, such as `android.intent.action.VIEW`
`-c <CATEGORY>`	Specify category, such as `android.intent.category.APP_CONTACTS`
`-n <COMPONENT>`	Specify the complete component name, which is used to clearly specify which Activity to start, such as `com.example.app/.ExampleActivity`

<INTENT> can also carry data, just like Bundle when writing code:

Parameters	Meaning
`--esn <EXTRA_KEY>`	null value (only key name)
`-e	--es <EXTRA_KEY> <EXTRA_STRING_VALUE>`
`--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE>`	boolean value
`--ei <EXTRA_KEY> <EXTRA_INT_VALUE>`	integer value
`--el <EXTRA_KEY> <EXTRA_LONG_VALUE>`	long value
`--ef <EXTRA_KEY> <EXTRA_FLOAT_VALUE>`	float 值
`--eu <EXTRA_KEY> <EXTRA_URI_VALUE>`	URI
`--ecn <EXTRA_KEY> <EXTRA_COMPONENT_NAME_VALUE>`	component name
`--eia <EXTRA_KEY> <EXTRA_INT_VALUE>[,<EXTRA_INT_VALUE...]`	integer 数组
`--ela <EXTRA_KEY> <EXTRA_LONG_VALUE>[,<EXTRA_LONG_VALUE...]`	long 数组

Activating Activity

Command format:



adb shell am start [options] <INTENT>

E.g:



adb shell am start -n com.tencent.mm/.ui.LauncherUI

Indicates that the main interface of WeChat is activated.



adb shell am start -n org.mazhuang.boottimemeasure/.MainActivity --es "toast" "hello, world"

It means to call up org.mazhuang.boottimemeasure/.MainActivity and pass it the string data key-value pair toast-hello, world.

Transfer Service

Command format:



adb shell am startservice [options] <INTENT>

E.g:



adb shell am startservice -n com.tencent.mm/.plugin.accountsync.model.AccountAuthenticatorService

Indicates that a certain service of WeChat has been activated.

Send broadcast

Command format:



adb shell am broadcast [options] <INTENT>

It can be broadcast to all components or only to specified components.

For example, to broadcast BOOT_COMPLETED to all components:



adb shell am broadcast -a android.intent.action.BOOT_COMPLETED

For another example, only broadcast BOOT_COMPLETED to org.mazhuang.boottimemeasure/.BootCompletedReceiver:



adb shell am broadcast -a android.intent.action.BOOT_COMPLETED -n org.mazhuang.boottimemeasure/.BootCompletedReceiver

This type of usage is very practical when testing. For example, a broadcast scene is difficult to create. You can consider sending broadcasts in this way.
It can send the pre-defined broadcast of the system and also send the self-defined broadcast. The following is part of the system predefined broadcast and normal trigger timing:

action	Trigger timing
android.net.conn.CONNECTIVITY_CHANGE	Network connection has changed
android.intent.action.SCREEN_ON	The screen lights up
android.intent.action.SCREEN_OFF	The screen goes off
android.intent.action.BATTERY_LOW	If the battery is low, a low battery prompt box will pop up
android.intent.action.BATTERY_OKAY	The battery is restored
android.intent.action.BOOT_COMPLETED	The device has started up
android.intent.action.DEVICE_STORAGE_LOW	Storage space is too low
android.intent.action.DEVICE_STORAGE_OK	Storage space recovery
android.intent.action.PACKAGE_ADDED	A new application is installed
android.net.wifi.STATE_CHANGE	The WiFi connection status has changed
android.net.wifi.WIFI_STATE_CHANGED	WiFi status changes to enable/disable/starting/disabling/unknown
android.intent.action.BATTERY_CHANGED	The battery level has changed
android.intent.action.INPUT_METHOD_CHANGED	The system input method has changed
android.intent.action.ACTION_POWER_CONNECTED	External power connection
android.intent.action.ACTION_POWER_DISCONNECTED	External power supply disconnected
android.intent.action.DREAMING_STARTED	The system started to sleep
android.intent.action.DREAMING_STOPPED	The system stops sleeping
android.intent.action.WALLPAPER_CHANGED	The wallpaper has changed
android.intent.action.HEADSET_PLUG	Plug in headphones
android.intent.action.MEDIA_UNMOUNTED	Unload external media
android.intent.action.MEDIA_MOUNTED	Mount external media
android.os.action.POWER_SAVE_MODE_CHANGED	Enable power saving mode

(The above broadcasts can all be triggered by adb)

Forcibly stop the application

command:



adb shell am force-stop <packagename>

Command example:



adb shell am force-stop com.qihoo360.mobilesafe

Means to stop all the processes and services of 360 Security Guard.

Disable apps and start

Command example:



adb shell pm disable-user <packagename>
adb shell pm disable <packagename>



adb shell pm disable-user [options] <packagename>

Command example:



adb shell pm enable <packagename>

Revoke the permissions of the application

Grant permissions to the app. Only optional permissions declared by the application can be granted



adb shell pm grant <packagename> <PACKAGE_PERMISSION>

For example: adb -d shell pm grant packageName android.permission.BATTERY_STATS

Cancel app authorization



adb shell pm revoke <packagename> <PACKAGE_PERMISSION>

Option --user user_id: the user to be disabled For example, grant permissions to the application. On devices running Android 6.0 (API level 23) and higher, the permission can be any permission declared in the application manifest. On devices running Android 5.1 (API level 22) and lower, it must be an optional permission defined by the application.

Disclaimer: The above order is an unconventional order. I am not responsible for any damage to your equipment, forcible stop, etc. You are performing this operation on your device, and you are responsible for it.

File Management

Copy the files in the device to the computer

command:



adb pull <file path in device> [directory on computer]

Among them, the directory parameter on the computer can be omitted, and the default is copied to the current directory.

example:



adb pull /sdcard/sr.mp4 ~/tmp/

*Tips: *The file path on the device may require root privileges to access. If your device has been rooted, you can use the adb shell and su commands to obtain root privileges in the adb shell, then cp /path/on/device /sdcard/filename Copy the file to sdcard, then adb pull /sdcard/filename /path/on/pc.

Copy files from computer to device

command:



adb push <file path on computer> <directory in device>

example:



adb push ~/sr.mp4 /sdcard/

*Tips: *The file path on the device may not be directly written by ordinary permissions. If your device has been rooted, you can first adb push /path/on/pc /sdcard/filename, and then adb shell and su in adb shell After obtaining root permissions, cp /sdcard/filename /path/on/device.

Simulation key/input

There is a very useful command called input in adb shell, through which you can do some interesting things.
The complete help information of the input command is as follows:



Usage: input [<source>] <command> [<arg>...]

The sources are:
      mouse
      keyboard
      joystick
      touchnavigation
      touchpad
      trackball
      stylus
      dpad
      gesture
      touchscreen
      gamepad

The commands and default sources are:
      text <string> (Default: touchscreen)
      keyevent [--longpress] <key code number or name> ... (Default: keyboard)
      tap <x> <y> (Default: touchscreen)
      swipe <x1> <y1> <x2> <y2> [duration(ms)] (Default: touchscreen)
      press (Default: trackball)
      roll <dx> <dy> (Default: trackball)

For example, to simulate a click: //Click the position of the coordinate point x=50 y=250 on the screen.

adb shell input tap 50 250

For example, using the adb shell input keyevent command, different keycodes can achieve different functions. For the complete keycode list, see KeyEvent. The excerpts are as follows:

keycode	Meaning
3	HOME key
4	Back key
5	Open the dial-up application
6	Hang up the call
24	Increase volume
25	Reduce the volume
26	Power button
27	Taking photos (need to be in the camera application)
64	Open the browser
82	Menu key
85	Play/Pause
86	Stop playing
87	Play the next song
88	Play the previous song
122	Move the cursor to the beginning of the line or the top of the list
123	Move the cursor to the end of the line or the bottom of the list
126	Resume playback
127	Pause playback
164	Mute
176	Open system settings
187	Switch application
207	Open contacts
208	Open the calendar
209	Open music
210	Open the calculator
220	Reduce screen brightness
221	Increase screen brightness
223	System hibernation
224	Light up the screen
231	Open the voice assistant
276	If there is no wakelock, let the system hibernate

The following are some usage examples of input command.

Power button



db shell input keyevent 26

The effect is equivalent to pressing the power button.

HOME key

command:



adb shell input keyevent 3

return key

command:



adb shell input keyevent 4

volume control

Increase volume:



adb shell input keyevent 24

lower the volume:



adb shell input keyevent 25

Mute:



adb shell input keyevent 164

Media Control

play / Pause:



adb shell input keyevent 85

Stop play:



adb shell input keyevent 86

Play the next song:



adb shell input keyevent 87

Play the previous song:



adb shell input keyevent 88

Resume playback:



adb shell input keyevent 126

Pause playback:



adb shell input keyevent 127

Turn on/off the screen

The analog power button described above can be used to switch the screen on and off, but if you clearly want to turn on or off the screen, you can use the following method.

Light up the screen:



adb shell input keyevent 224

Turn off the screen:



adb shell input keyevent 223

Slide to unlock

If the lock screen does not have a password and is unlocked by swiping gestures, you can unlock it by input swipe.

Command (parameters are based on model Nexus 5, for example, swipe up gesture to unlock):



adb shell input swipe 300 1000 300 500

The parameters 300 1000 300 500 respectively represent the start point x coordinate, the start point y coordinate, the end point x coordinate, and the end point y coordinate.

Enter text

When the focus is on a text box, you can use the input command to enter text.

command:



adb shell input text hello

Now hello appears in the text box.

View log

The Android system log is divided into two parts, the underlying Linux kernel log is output to /proc/kmsg, and the Android log is output to /dev/log.

Android log

Command format:



[adb] logcat [<option>] ... [<filter-spec>] ...

Common usages are listed as follows:

Filter logs by level

Android logs are divided into the following priority (priority):

-V —— Verbose (lowest, most output)
-D —— Debug I —— Info
-W —— Warning
-E —— Error
-F—— Fatal
-S —— Silent (the highest, nothing is output)

Filtering logs by a certain level will output logs of that level and above.

For example, the command:



adb logcat *:W

Warning, Error, Fatal and Silent logs will be output.

(Note: Under macOS, you need to add double quotation marks to :W so that * as the tag parameter, such as adb logcat ":W", otherwise an error will be reported no matches found: *:W.)

Filter logs by tag and level

<filter-spec> can be composed of multiple <tag>[:priority].

For example, the command:



adb logcat ActivityManager:I MyApp:D *:S

It means to output the log above Info of tag ActivityManager, output the log above Debug of tag MyApp, and the Silent log of other tags (that is, to block other tag logs).

Log Format

You can use the adb logcat -v <format> option to specify the log output format.

The log supports the following types of <format>:

-brief

The default format. The format is:

/():
Example:

D/HeadsetStateMachine( 1785): Disconnected process message: 10, size: 0

-process

The format is:

()
Example:

D( 1785) Disconnected process message: 10, size: 0 (HeadsetStateMachine)

-tag

The format is:

/:
Example:

D/HeadsetStateMachine: Disconnected process message: 10, size: 0
To
-raw

The format is:

Example:

Disconnected process message: 10, size: 0

-time

The format is:

/():
Example:

08-28 22:39:39.974 D/HeadsetStateMachine( 1785): Disconnected process message: 10, size: 0

-threadtime

The format is:

:
Example:

08-28 22:39:39.974 1785 1832 D HeadsetStateMachine: Disconnected process message: 10, size: 0

-long

The format is:

[ : /]
Example:

[08-28 22:39:39.974 1785: 1832 D/HeadsetStateMachine] Disconnected process message: 10, size: 0

The specified format can be used simultaneously with the above filtering. such as:



adb logcat -v long ActivityManager:I *:S

Clear log



adb logcat -c

Kernel log

command:



adb shell dmesg

Sample output:



<6>[14201.684016] PM: noirq resume of devices complete after 0.982 msecs
<6>[14201.685525] PM: early resume of devices complete after 0.838 msecs
<6>[14201.753642] PM: resume of devices complete after 68.106 msecs
<4>[14201.755954] Restarting tasks ... done.
<6>[14201.771229] PM: suspend exit 2016-08-28 13:31:32.679217193 UTC
<6>[14201.872373] PM: suspend entry 2016-08-28 13:31:32.780363596 UTC
<6>[14201.872498] PM: Syncing filesystems ... done.

The [14201.684016] in the brackets represents the time since the kernel started, in seconds.

Through the kernel log we can do some things, such as measuring the kernel startup time, find the time before the Freeing init memory line in the kernel log after the system is started.

View device information

Model

command:



adb shell getprop ro.product.model

Sample output:

Nexus 5

Battery status

command:



adb shell dumpsys battery

Input example:



  Current Battery Service state:
  AC powered: false
  USB powered: true
  Wireless powered: false
  status: 2
  health: 2
  present: true
  level: 44
  scale: 100
  voltage: 3872
  temperature: 280
  technology: Li-poly

Among them, scale represents the maximum power, and level represents the current power. The output above indicates that 44% of the battery is left.

Screen Resolution

command:



adb shell wm size

Sample output:



Physical size: 1080x1920

The device screen resolution is 1080px * 1920px.

If it is modified using the command, the output may be:



Physical size: 1080x1920
Override size: 480x1024

Indicates that the screen resolution of the device was originally 1080px * 1920px, but is currently modified to 480px * 1024px.

Screen density

command:

adb shell wm density
Sample output:

Physical density: 420
The device screen density is 420dpi.

If it is modified using the command, the output may be:

Physical density: 480
Override density: 160
Indicates that the screen density of the device was originally 480dpi, but is currently modified to 160dpi.

Display parameters

command:



adb shell dumpsys window displays

Sample output:



WINDOW MANAGER DISPLAY CONTENTS (dumpsys window displays)
  Display: mDisplayId=0
    init=1080x1920 420dpi cur=1080x1920 app=1080x1794 rng=1080x1017-1810x1731
    deferred=false layoutNeeded=false

Among them, mDisplayId is the display number, init is the initial resolution and screen density. The height of the app is smaller than that in init, which means that there are virtual buttons at the bottom of the screen. The height is 1920-1794 = 126px and 42dp.

android_id

command:



adb shell settings get secure android_id

Sample output:



51b6be48bac8c569

IMEI

In Android 4.4 and below versions, IMEI can be obtained by the following command:



adb shell dumpsys iphonesubinfo

Sample output:



Phone Subscriber Info:
  Phone Type = GSM
  Device ID = 860955027785041
The Device ID is IMEI.

In Android 5.0 and above, the output of this command is empty, and it must be obtained by other means (root permission is required):



adb shell
su
service call iphonesubinfo 1

Sample output:



Result: Parcel(
  0x00000000: 00000000 0000000f 00360038 00390030'........8.6.0.9.'
  0x00000010: 00350035 00320030 00370037 00350038 '5.5.0.2.7.7.8.5.'
  0x00000020: 00340030 00000031 '0.4.1...')

Extracting the effective content inside is the IMEI, for example, here is 860955027785041.

Reference: adb shell dumpsys iphonesubinfo not working since Android 5.0 Lollipop

Android system version

command:



adb shell getprop ro.build.version.release

Sample output:

5.0.2

IP address

Every time you want to know the IP address of the device, you have to "Settings"-"About Phone"-"Status Information"-"IP Address", which is annoying, right? It can be easily viewed through adb.

command:



adb shell ifconfig "| grep Mask"

Sample output:



inet addr:10.130.245.230 Mask:255.255.255.252
inet addr: 127.0.0.1 Mask: 255.0.0.0

Then 10.130.245.230 is the device IP address.

This command has no output on some devices. If the device is connected to WiFi, you can use the following command to view the local area network adb shell ifconfig wlan0 Example:



wlan0: ip 10.129.160.99 mask 255.255.240.0 flags [up broadcast running multicast]



wlan0 Link encap:UNSPEC
          inet addr:10.129.168.57 Bcast:10.129.175.255 Mask:255.255.240.0
          inet6 addr: fe80::66cc:2eff:fe68:b6b6/64 Scope: Link
          UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
          RX packets:496520 errors:0 dropped:0 overruns:0 frame:0
          TX packets: 68215 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:3000
          RX bytes: 116266821 TX bytes: 8311736

If the above command still does not get the expected information, you can try the following command (available in some system versions):



adb shell netcfg

Sample output:



wlan0 UP 10.129.160.99/20 0x00001043 f8:a9:d0:17:42:4d
lo UP 127.0.0.1/8 0x00000049 00:00:00:00:00:00
p2p0 UP 0.0.0.0/0 0x00001003 fa:a9:d0:17:42:4d
sit0 DOWN 0.0.0.0/0 0x00000080 00:00:00:00:00:00
rmnet0 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet1 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet3 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet2 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet4 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet6 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet5 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rmnet7 DOWN 0.0.0.0/0 0x00000000 00:00:00:00:00:00
rev_rmnet3 DOWN 0.0.0.0/0 0x00001002 4e:b7:e4:2e:17:58
rev_rmnet2 DOWN 0.0.0.0/0 0x00001002 4e:f0:c8:bf:7a:cf
rev_rmnet4 DOWN 0.0.0.0/0 0x00001002 a6:c0:3b:6b:c4:1f
rev_rmnet6 DOWN 0.0.0.0/0 0x00001002 66:bb:5d:64:2e:e9
rev_rmnet5 DOWN 0.0.0.0/0 0x00001002 0e:1b:eb:b9:23:a0
rev_rmnet7 DOWN 0.0.0.0/0 0x00001002 7a:d9:f6:81:40:5a
rev_rmnet8 DOWN 0.0.0.0/0 0x00001002 4e:e2:a9:bb:d0:1b
rev_rmnet0 DOWN 0.0.0.0/0 0x00001002 fe:65:d0:ca:82:a9
rev_rmnet1 DOWN 0.0.0.0/0 0x00001002 da:d8:e8:4f:2e:fe

You can see information such as the network connection name, activation status, IP address, and Mac address.

Mac address

command:



adb shell cat /sys/class/net/wlan0/address

Sample output:



f8:a9:d0:17:42:4d

This is the local area network Mac address, mobile network or other connection information can be viewed through the adb shell netcfg command mentioned in the previous section "IP address".

CPU information

command:



adb shell cat /proc/cpuinfo

Sample output:



Processor: ARMv7 Processor rev 0 (v7l)
processor: 0
BogoMIPS: 38.40

processor: 1
BogoMIPS: 38.40

processor: 2
BogoMIPS: 38.40

processor: 3
BogoMIPS: 38.40

Features: swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4 idiva idivt
CPU implementer: 0x51
CPU architecture: 7
CPU variant: 0x2
CPU part: 0x06f
CPU revision: 0

Hardware: Qualcomm MSM 8974 HAMMERHEAD (Flattened Device Tree)
Revision: 000b
Serial: 0000000000000000

This is the CPU information of Nexus 5. We can see from the output that the hardware used is Qualcomm MSM 8974, and the processor number is 0 to 3, so it is quad-core and the architecture used is ARMv7 Processor rev 0 (v71).

Memory information

command:



adb shell cat /proc/meminfo

Sample output:



MemTotal: 1027424 kB
MemFree: 486564 kB
Buffers: 15224 kB
Cached: 72464 kB
SwapCached: 24152 kB
Active: 110572 kB
Inactive: 259060 kB
Active(anon): 79176 kB
Inactive(anon): 207736 kB
Active(file): 31396 kB
Inactive(file): 51324 kB
Unevictable: 3948 kB
Mlocked: 0 kB
HighTotal: 409600 kB
HighFree: 132612 kB
LowTotal: 617824 kB
LowFree: 353952 kB
SwapTotal: 262140 kB
SwapFree: 207572 kB
Dirty: 0 kB
Writeback: 0 kB
AnonPages: 265324 kB
Mapped: 47072 kB
Shmem: 1020 kB
Slab: 57372 kB
SReclaimable: 7692 kB
SUnreclaim: 49680 kB
KernelStack: 4512 kB
PageTables: 5912 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 775852 kB
Committed_AS: 13520632 kB
VmallocTotal: 385024 kB
VmallocUsed: 61004 kB
VmallocChunk: 209668 kB

Among them, MemTotal is the total memory of the device, and MemFree is the current free memory.

More hardware and system properties

More hardware and system properties of the device can be viewed through the following commands:



adb shell cat /system/build.prop

This will output a lot of information, including the "model" and "Android system version" mentioned in the previous sections.

The output also includes some other useful information, which can also be viewed separately through the adb shell getprop command. Some properties are listed as follows:

Attribute name	Meaning
ro.build.version.sdk	SDK version
ro.build.version.release	Android system version
ro.build.version.security_patch	Android security patch level
ro.product.model	Model
ro.product.brand	Brand
ro.product.name	Device name
ro.product.board	Processor model
ro.product.cpu.abilist	Abi list supported by CPU [Section 1]
persist.sys.isUsbOtgEnabled	Whether to support OTG
dalvik.vm.heapsize	Maximum memory limit for each application
ro.sf.lcd_density	Screen density

Section Note 1:

Some ROMs customized by small factories may have modified the attribute name of the abi list supported by the CPU. If you can’t find it with the ro.product.cpu.abilist attribute name, you can try:



adb shell cat /system/build.prop | grep ro.product.cpu.abi

Sample output:



ro.product.cpu.abi=armeabi-v7a
ro.product.cpu.abi2=armeabi

Modify settings

*Note: After modifying the settings, running the recovery command may still display abnormalities. You can run adb reboot to restart the device, or manually restart. *

The principle of modifying settings is mainly to modify the setting values stored in /data/data/com.android.providers.settings/databases/settings.db through the settings command.

Resolution

command:



adb shell wm size 480x1024

Means to modify the resolution to 480px * 1024px.

Restore the original resolution command:



adb shell wm size reset

Screen density

command:



adb shell wm density 160

Means to modify the screen density to 160dpi.

Restore the original screen density command:



adb shell wm density reset

Display area

command:



adb shell wm overscan 0,0,0,200

The four numbers respectively indicate the margin pixels from the left, top, right, and bottom edges. The above command means to leave the bottom of the screen 200px blank.

Restore the original display area command:



adb shell wm overscan reset

Turn off USB debugging mode

command:

adb shell settings put global adb_enabled 0
restore:

It can't be restored with commands, after all, if USB debugging is turned off, adb cannot connect to the Android device.

Go to the device to manually restore it: "Settings"-"Developer Options"-"Android Debugging".

Display and hide status bar and navigation bar

The related settings mentioned in this section correspond to "Extended Desktop" in Cyanogenmod.

command:



adb shell settings put global policy_control <key-values>

<key-values> can be composed of the following keys and their corresponding values, in the format of <key1>=<value1>:<key2>=<value2>.

key	Meaning
immersive.full	Hide at the same time
immersive.status	Hide the status bar
immersive.navigation	Hide the navigation bar
immersive.preconfirms	?

The values corresponding to these keys can be combined with commas as the following values:

value	Meaning
`apps`	All applications
`*`	All interfaces
`packagename`	Specify application
`-packagename`	Exclude specific applications

E.g:



adb shell settings put global policy_control immersive.full=*

Indicates that the status bar and navigation bar are hidden at the same time in all interfaces.



adb shell settings put global policy_control immersive.status=com.package1,com.package2:immersive.navigation=apps,-com.package3

It means setting to hide the status bar in applications with package names com.package1 and com.package2, and hide the navigation bar in all applications except package names com.package3.

Return to normal mode

What if I don't want to be full screen?



adb shell settings put global policy_control null

Useful functions

Screenshots

Save screenshot to computer:



adb exec-out screencap -p> sc.png

If the adb version is older and the exec-out command cannot be used, it is recommended to update the adb version at this time. If you cannot update, you can use the following troublesome methods:

First save the screenshot to the device:



adb shell screencap -p /sdcard/sc.png

Then export the png file to the computer:



adb pull /sdcard/sc.png

You can use adb shell screencap -h to view the help information of the screencap command. The following are two meaningful parameters and their meanings:

Parameters	Meaning
-p	Specify the save file as png format
-d display-id	Specify the screen number of the screenshot (if there are multiple screens)

Actually, if the specified file name ends with .png, you can omit the -p parameter; otherwise, you need to use the -p parameter. If you do not specify the file name, the content of the screenshot file will be directly output to stdout.

Another way to take a screenshot of a one-line command and save it to the computer:

Linux and Windows



adb shell screencap -p | sed "s/\r$//"> sc.png

Mac OS X



adb shell screencap -p | gsed "s/\r$//"> sc.png

This method needs to use the gnu sed command, which is available directly under Linux, and under the bin folder of the Git installation directory under Windows. If you really cannot find the command, you can download sed for Windows and add the folder where sed.exe is located to the PATH environment variable.

However, using the sed command that comes with the system under Mac will report an error:



sed: RE error: illegal byte sequence

Need to install gnu-sed, and then use the gsed command:



brew install gnu-sed

Record screen

The recorded screen is saved to /sdcard in mp4 format:



adb shell screenrecord /sdcard/filename.mp4

Press Ctrl-C when you need to stop, the default recording time and maximum recording time are both 180 seconds.

If you need to export to a computer:



adb pull /sdcard/filename.mp4

You can use adb shell screenrecord --help to view the help information of the screenrecord command. The following are common parameters and their meanings:

Parameters	Meaning
--size WIDTHxHEIGHT	The size of the video, such as `1280x720`, the default is the screen resolution.
--bit-rate RATE	The bit rate of the video, the default is 4Mbps.
--time-limit TIME	Recording duration, in seconds.
--verbose	Output more information.

Remount the system partition as writable

*Note: root permission is required. *

The /system partition is mounted as read-only by default, but some operations such as adding commands to the Android system, deleting its own applications, etc. require writing to /system, so you need to remount it as read-write.

step:

Enter the shell and switch to root user authority.

command:



adb shell
su

View the current partition mounting status.

command:



mount

Sample output:



rootfs / rootfs ro, relatime 0 0
tmpfs /dev tmpfs rw,seclabel,nosuid,relatime,mode=755 0 0
devpts /dev/pts devpts rw,seclabel,relatime,mode=600 0 0
proc /proc proc rw,relatime 0 0
sysfs /sys sysfs rw,seclabel,relatime 0 0
selinuxfs /sys/fs/selinux selinuxfs rw,relatime 0 0
debugfs /sys/kernel/debug debugfs rw,relatime 0 0
none /var tmpfs rw,seclabel,relatime,mode=770,gid=1000 0 0
none /acct cgroup rw,relatime,cpuacct 0 0
none /sys/fs/cgroup tmpfs rw,seclabel,relatime,mode=750,gid=1000 0 0
none /sys/fs/cgroup/memory cgroup rw,relatime,memory 0 0
tmpfs /mnt/asec tmpfs rw,seclabel,relatime,mode=755,gid=1000 0 0
tmpfs /mnt/obb tmpfs rw,seclabel,relatime,mode=755,gid=1000 0 0
none /dev/memcg cgroup rw,relatime,memory 0 0
none /dev/cpuctl cgroup rw,relatime,cpu 0 0
none /sys/fs/cgroup tmpfs rw,seclabel,relatime,mode=750,gid=1000 0 0
none /sys/fs/cgroup/memory cgroup rw,relatime,memory 0 0
none /sys/fs/cgroup/freezer cgroup rw,relatime,freezer 0 0
/dev/block/platform/msm_sdcc.1/by-name/system /system ext4 ro,seclabel,relatime,data=ordered 0 0
/dev/block/platform/msm_sdcc.1/by-name/userdata /data ext4 rw,seclabel,nosuid,nodev,relatime,noauto_da_alloc,data=ordered 0 0
/dev/block/platform/msm_sdcc.1/by-name/cache /cache ext4 rw,seclabel,nosuid,nodev,relatime,data=ordered 0 0
/dev/block/platform/msm_sdcc.1/by-name/persist /persist ext4 rw,seclabel,nosuid,nodev,relatime,data=ordered 0 0
/dev/block/platform/msm_sdcc.1/by-name/modem /firmware vfat ro,context=u:object_r:firmware_file:s0,relatime,uid=1000,gid=1000,fmask=0337,dmask=0227,codepage =cp437,iocharset=iso8859-1,shortname=lower,errors=remount-ro 0 0
/dev/fuse /mnt/shell/emulated fuse rw,nosuid,nodev,relatime,user_id=1023,group_id=1023,default_permissions,allow_other 0 0
/dev/fuse /mnt/shell/emulated/0 fuse rw,nosuid,nodev,relatime,user_id=1023,group_id=1023,default_permissions,allow_other 0 0

Find the line with /system that we are concerned about:



/dev/block/platform/msm_sdcc.1/by-name/system /system ext4 ro,seclabel,relatime,data=ordered 0 0

Remount.

command:



mount -o remount,rw -t yaffs2 /dev/block/platform/msm_sdcc.1/by-name/system /system

Here /dev/block/platform/msm_sdcc.1/by-name/system is the file path we got from the output of the previous step.

If the output does not prompt an error, the operation is successful, and you can do whatever you want with the files under /system.

View connected WiFi passwords

*Note: root permission is required. *

command:



adb shell
su
cat /data/misc/wifi/*.conf

Sample output:



network={
ssid="TP-LINK_9DFC"
scan_ssid=1
psk="123456789"
key_mgmt=WPA-PSK
group=CCMP TKIP
auth_alg=OPEN
sim_num=1
priority=13893
}

network={
ssid="TP-LINK_F11E"
psk="987654321"
key_mgmt=WPA-PSK
sim_num=1
priority=17293
}

ssid is the name we see in the WLAN settings, psk is the password, and key_mgmt is the security encryption method.

Set the system date and time

*Note: root permission is required. *

command:



adb shell
su
date -s 20160823.131500

Means to change the system date and time to 13:15:00 on August 23, 2016.

restart cellphone

command:



adb reboot

Check if the device is rooted

command:



adb shell
su

At this time, the command line prompt is $, which means that there is no root authority, and # means that it is rooted.

Use Monkey for stress testing

Monkey can generate pseudo-random user events to simulate clicks, touches, gestures and other operations, and can perform random stress tests on programs under development.

Simple usage:



adb shell monkey -p <packagename> -v 500

It means to send 500 pseudo-random events to the application specified by <packagename>.

For detailed usage of Monkey, refer to the official documentation.

Turn on/off WiFi

Note: root permission is required.

Sometimes you need to control the WiFi status of the device, you can use the following commands to complete.

Turn on WiFi:



adb root
adb shell svc wifi enable

Turn off WiFi:



adb root
adb shell svc wifi disable

Set wifi priority, use wifi first when there is network and wifi



adb shell svc wifi prefer

If the execution is successful, the output will be empty; if the command is executed without root permission, the execution will fail and the output will be Killed.

Turn on/off data traffic



svc data disable

This command can close the data connection, that is, the Internet traffic. Everyone knows that there are many switches to control the Internet, but most of them are realized by adding a suffix to the access point on the apn, but this command will not change any settings of the apn. The bottom layer closes the data connection. It should be the most thorough, and does not affect the apn settings. What is the difference between this and apndroid? When apndroid closes the Internet data, the downloading connection may not be forcibly closed (this is also mentioned in apndroid's own instructions). For example, if you are downloading a 10M movie, if you download 1M, the download will not sound. Use apndroid to close the connection, maybe the download will continue, not immediately. But with this command, it clicked away without mercy.



adb shell svc data enable

This is to open the Internet data connection, which is the opposite of the previous command.



adb shell svc data prefer

This command is to control the data connection prior to wifi. We all know that under normal circumstances, when there is wifi, the data network connection will not be used. But this command is the opposite. If there is a data network, use data network traffic first, and use wifi when there is no data network.

Flashing related commands

Restart to Recovery mode

command:



adb reboot recovery

Restart from Recovery to Android

command:



adb reboot

Restart to Fastboot mode

command:



adb reboot bootloader

Update the system via sideload

If we download the system update package corresponding to the Android device to the computer, we can also complete the update through adb.

Take the update in Recovery mode as an example:

Restart to Recovery mode.

command:



adb reboot recovery

Operate on the Recovery interface of the device to enter Apply update-Apply from ADB.

*Note: Different Recovery menus may be different from this. Some first-level menus have Apply update from ADB. *

*Upload and update the system via adb. *

command:



adb sideload <path-to-update.zip>

More adb shell commands

The Android system is based on the Linux kernel, so many commands in Linux have the same or similar implementations in Android and can be called in adb shell. The adb shell command has been used in the previous part of this document.

View process



adb shell ps

example:



USER PID PPID VSIZE RSS WCHAN PC NAME
root 1 0 8904 788 ffffffff 00000000 S /init
root 2 0 0 0 ffffffff 00000000 S kthreadd
...
u0_a71 7779 5926 1538748 48896 ffffffff 00000000 S com.sohu.inputmethod.sogou:classic
u0_a58 7963 5926 1561916 59568 ffffffff 00000000 S org.mazhuang.boottimemeasure
...
shell 8750 217 10640 740 00000000 b6f28340 R ps

Meaning of each column:

Column name	Meaning
USER	Owned user
PID	Process ID
PPID	Parent process ID
NAME	Process name

View real-time resource usage



adb shell top

example:



User 0%, System 6%, IOW 0%, IRQ 0%
User 3 + Nice 0 + Sys 21 + Idle 280 + IOW 0 + IRQ 0 + SIRQ 3 = 307

  PID PR CPU% S #THR VSS RSS PCY UID Name
 8763 0 3% R 1 10640K 1064K fg shell top
  131 0 3% S 1 0K 0K fg root dhd_dpc
 6144 0 0% S 115 1682004K 115916K fg system system_server
  132 0 0% S 1 0K 0K fg root dhd_rxf
 1731 0 0% S 6 20288K 788K fg root /system/bin/mpdecision
  217 0 0% S 6 18008K 356K fg shell /sbin/adbd
 ...
 7779 2 0% S 19 1538748K 48896K bg u0_a71 com.sohu.inputmethod.sogou:classic
 7963 0 0% S 18 1561916K 59568K fg u0_a58 org.mazhuang.boottimemeasure
 ...

Meaning of each column:

Column name	Meaning
PID	Process ID
PR	Priority
CPU%	The percentage of CPU occupied at the current instant
S	Process status (R=run, S=sleep, T=track/stop, Z=zombie process)
#THR	Number of threads
VSS	Virtual Set Size virtual memory consumption (including memory occupied by shared libraries)
RSS	Resident Set Size actually uses physical memory (including memory occupied by shared libraries)
PCY	Scheduling strategy priority, SP_BACKGROUND/SPFOREGROUND
UID	User ID of the process owner
NAME	Process name

The top command also supports some command line parameters, the detailed usage is as follows:



Usage: top [-m max_procs] [-n iterations] [-d delay] [-s sort_column] [-t] [-h]
    -m num shows how many processes at most
    -n num exit after refreshing how many times
    -d num refresh interval (unit: second, default value 5)
    -s col Sort by a column (available col values: cpu, vss, rss, thr)
    -t display thread information
    -h show help document

View process UID

There are two options:



adb shell dumpsys package <packagename> | grep userId=

Such as:



$ adb shell dumpsys package org.mazhuang.guanggoo | grep userId=
   userId=10394

After finding the pid of the corresponding process through the ps command, adb shell cat /proc/<pid>/status | grep Uid

Such as:



$ adb shell
gemini:/ $ ps | grep org.mazhuang.guanggoo
u0_a394 28635 770 1795812 78736 SyS_epoll_ 0000000000 S org.mazhuang.guanggoo
gemini:/$ cat /proc/28635/status | grep Uid
Uid: 10394 10394 10394 10394
gemini:/$

Other

The following is a brief description of other commonly used commands. The commands that have been specifically mentioned above will not be explained separately:

Command	Features
cat	Display file content
cd	Change directory
chmod	Change file access mode/access permissions
df	Check disk space usage
grep	Filter output
kill	Kill the process of the specified PID
ls	List the contents of the directory
mount	View and manage mount directories
mv	Move or rename files
ps	View the running process
rm	Delete files
top	Check the resource usage of the process

Security related

Enable SELinux



adb root
adb shell setenforce 1

Disable SELinux



adb root
adb shell setenforce 0

Enable dm_verity



adb root
adb enable-verity

Disable dm_verity



adb root
adb disable-verity

common problem

Failed to start adb server

Error message



error: protocol fault (couldn't read status): No error

possible reason

The 5037 port that the adb server process wants to use is occupied.

solution

Find the process occupying port 5037, and then terminate it. Take Windows as an example:



netstat -ano | findstr LISTENING

...
TCP 0.0.0.0:5037 0.0.0.0:0 LISTENING 1548
...

Here 1548 is the process ID, end the process with the command:



taskkill /PID 1548

Then start adb and there is no problem.