Android CLI 快速开发指南：从 0 到 1 的脚本化开发流程

💻 开发效率 | 实战教程 | 关键词：Android 命令行、自动化、脚本化开发

开篇：为什么开发者还在用 Android Studio

2026 年，Android 开发还没有完全"云原生化"。

但越来越多的开发者发现了一个秘密：

你根本不需要 Android Studio 的 GUI。

用命令行工具，你可以：

⚡ 更快 - 不用等 IDE 加载，秒级编译
🔧 更灵活 - 用脚本自动化重复工作
💾 更轻量 - 10GB IDE vs 1GB CLI 工具
🚀 远程开发 - SSH 到任何机器开发
📦 CI/CD 友好 - 完全可以集成到 Jenkins/GitHub Actions

这篇指南教你如何用命令行工具链完成 Android 开发的 80% 工作。

第一部分：环境搭建

1. 安装 Java Development Kit (JDK)

Android 开发的第一步：装 JDK。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# macOS
brew install java@17
export JAVA_HOME=$(brew --prefix java@17)
echo $JAVA_HOME  # 验证

# Linux (Ubuntu/Debian)
sudo apt-get install openjdk-17-jdk
java -version  # 验证

# Windows
# 下载: https://www.oracle.com/java/technologies/downloads/
# 或用 Windows Package Manager
winget install Oracle.JDK.17

为什么是 JDK 17？

Android 14+ 需要 JDK 17+
兼容性最好
LTS 版本，稳定性强

验证安装：

1
2
java -version
# openjdk version "17.0.x"

2. 安装 Android SDK

这是核心工具集。

方法 A：独立安装（推荐，最小化）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# 下载 SDK Command-line Tools
# https://developer.android.com/studio/command-line-tools

# macOS
cd ~/Library/Android
mkdir -p sdk/cmdline-tools/latest
# 解压下载的 zip 到 latest/

# Linux
mkdir -p ~/Android/sdk/cmdline-tools/latest
# 解压下载的 zip 到 latest/

# 添加到环境变量
export ANDROID_SDK_ROOT=~/Android/sdk
export PATH=$PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools
export PATH=$PATH:$ANDROID_SDK_ROOT/tools

方法 B：用 Android Studio（包含 SDK）

1
2
3
4
# 如果已经装了 Android Studio，SDK 自动在这里
export ANDROID_SDK_ROOT=$HOME/Library/Android/sdk  # macOS
# 或
export ANDROID_SDK_ROOT=$HOME/Android/Sdk  # Linux

3. 安装必要的 SDK 组件

用 sdkmanager 工具安装：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 列出所有可用的组件
sdkmanager --list

# 安装常用组件
sdkmanager "platforms;android-35"  # Android 15
sdkmanager "platforms;android-34"  # Android 14
sdkmanager "build-tools;35.0.0"    # 构建工具
sdkmanager "platform-tools"        # ADB、Fastboot
sdkmanager "emulator"              # 模拟器

# 一次性安装所有推荐组件
sdkmanager "platforms;android-35" "build-tools;35.0.0" \
  "platform-tools" "emulator"

验证安装：

1
2
adb --version      # ADB 版本
emulator -version  # 模拟器版本

4. 完整的环境变量设置

加到 ~/.bashrc 或 ~/.zshrc：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# Android SDK 环境变量
export ANDROID_SDK_ROOT=$HOME/Android/sdk
export ANDROID_HOME=$ANDROID_SDK_ROOT  # 兼容性
export PATH=$PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools
export PATH=$PATH:$ANDROID_SDK_ROOT/tools
export PATH=$PATH:$ANDROID_SDK_ROOT/emulator

# Java 环境变量
export JAVA_HOME=$(which java | xargs readlink -f | sed "s:/bin/java::")
export PATH=$JAVA_HOME/bin:$PATH

# Gradle（可选，很多项目自带 Gradle）
export GRADLE_USER_HOME=$HOME/.gradle

重载配置：

1
source ~/.bashrc  # 或 source ~/.zshrc

第二部分：创建和构建 Android 项目

1. 快速创建项目结构

方法 A：手动创建（理解项目结构）

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

# 创建项目级配置
cat > settings.gradle << 'EOF'
include ':app'
EOF

# 创建应用级配置
cat > app/build.gradle << 'EOF'
plugins {
    id 'com.android.application'
}

android {
    namespace 'com.example.myapp'
    compileSdk 35

    defaultConfig {
        applicationId 'com.example.myapp'
        minSdk 24
        targetSdk 35
        versionCode 1
        versionName "1.0"
    }

    buildTypes {
        release {
            minifyEnabled false
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.2.0'
}
EOF

# 创建源代码目录
mkdir -p app/src/main/java/com/example/myapp
mkdir -p app/src/main/res/layout
mkdir -p app/src/main/res/values
mkdir -p app/src/main/AndroidManifest.xml

# 创建主 Activity
cat > app/src/main/java/com/example/myapp/MainActivity.java << 'EOF'
package com.example.myapp;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}
EOF

# 创建布局文件
cat > app/src/main/res/layout/activity_main.xml << 'EOF'
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</LinearLayout>
EOF

方法 B：用 Android Gradle 模板（推荐，快速）

1
2
3
4
# 用 Gradle 生成完整项目
gradle init --type android-application \
  --dsl groovy \
  --project-name "my-app"

2. 用 Gradle 构建项目

编译 APK：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
# 进入项目根目录
cd my-app

# 编译调试版本 APK
./gradlew assembleDebug
# 输出: app/build/outputs/apk/debug/app-debug.apk

# 编译发布版本 APK（需要签名配置）
./gradlew assembleRelease

# 编译并运行单元测试
./gradlew testDebugUnitTest

# 一次性做所有事：编译 + 测试 + lint
./gradlew build

快速构建脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/bash
# build.sh - 快速构建脚本

echo "🔨 开始构建..."
./gradlew clean  # 清理旧构建

if [ "$1" == "release" ]; then
    echo "📦 构建发布版本..."
    ./gradlew assembleRelease
    APK_PATH="app/build/outputs/apk/release/app-release.apk"
else
    echo "📱 构建调试版本..."
    ./gradlew assembleDebug
    APK_PATH="app/build/outputs/apk/debug/app-debug.apk"
fi

if [ -f "$APK_PATH" ]; then
    echo "✅ 构建成功！"
    echo "📍 APK 位置: $APK_PATH"
    ls -lh "$APK_PATH"
else
    echo "❌ 构建失败"
    exit 1
fi

使用：

1
2
3
chmod +x build.sh
./build.sh         # 构建调试版
./build.sh release # 构建发布版

第三部分：设备管理和部署

1. 连接和检测设备

检测已连接的设备：

1
2
3
4
5
6
7
8
# 列出所有连接的设备和模拟器
adb devices

# 输出示例：
# List of attached devices
# emulator-5554          device
# 192.168.1.100:5555     device (无线连接)
# FA7Y215E0E             device (真机)

连接到真机设备：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 开启 USB 调试（设备设置 → 开发者选项 → USB 调试）

# 有线连接
adb connect /dev/ttyUSB0  # Linux
# 或直接通过 USB 检测

# 无线连接（前提：设备和电脑在同一 WiFi）
adb connect 192.168.1.100:5555  # 设备 IP

# 断开连接
adb disconnect 192.168.1.100:5555

获取设备信息：

1
2
3
4
5
6
7
8
# 获取设备属性
adb shell getprop ro.product.model    # 设备型号
adb shell getprop ro.build.version.release  # Android 版本
adb shell getprop ro.serialno         # 序列号

# 获取设备状态
adb shell dumpsys deviceidle          # 电池优化状态
adb shell wm size                     # 屏幕分辨率

2. 安装和运行 APK

安装 APK：

1
2
3
4
5
6
7
8
# 安装到设备
adb install app/build/outputs/apk/debug/app-debug.apk

# 安装并覆盖现有应用
adb install -r app/build/outputs/apk/debug/app-debug.apk

# 卸载应用
adb uninstall com.example.myapp

启动应用：

1
2
3
4
5
# 启动指定应用
adb shell am start -n com.example.myapp/.MainActivity

# 启动并显示日志
adb logcat | grep MyApp

快速部署脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/bin/bash
# deploy.sh - 构建 + 安装 + 启动

APP_PACKAGE="com.example.myapp"
ACTIVITY="MainActivity"
APK="app/build/outputs/apk/debug/app-debug.apk"

echo "🔨 构建..."
./gradlew assembleDebug || exit 1

echo "📲 安装到设备..."
adb install -r "$APK" || exit 1

echo "🚀 启动应用..."
adb shell am start -n "$APP_PACKAGE/.$ACTIVITY"

echo "📋 显示日志..."
adb logcat -s MyApp:V

使用：

1
2
chmod +x deploy.sh
./deploy.sh

第四部分：调试和监控

1. Logcat - 实时日志查看

基础用法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# 显示实时日志
adb logcat

# 清空日志缓冲
adb logcat -c

# 仅显示应用的日志
adb logcat | grep MyApp

# 显示带时间戳的日志
adb logcat -v time

# 显示带进程 ID 的日志
adb logcat -v process

# 过滤特定级别（V, D, I, W, E）
adb logcat "*:E"  # 仅显示错误和更严重的日志

保存日志到文件：

1
2
3
4
5
6
# 实时保存日志
adb logcat > app_log_$(date +%Y%m%d_%H%M%S).log &

# 后台保存，然后查看
adb logcat > log.txt 2>&1 &
tail -f log.txt

高级日志过滤：

1
2
3
4
5
6
7
8
#!/bin/bash
# logcat-filter.sh - 智能日志过滤

TAG=${1:-"MyApp"}
LEVEL=${2:-"D"}  # D=Debug, I=Info, W=Warn, E=Error

# 过滤格式: tag:level
adb logcat "$TAG:$LEVEL" "*:S"

使用：

1
2
./logcat-filter.sh MyApp D  # 查看 MyApp 的 Debug 日志
./logcat-filter.sh MyApp E  # 查看 MyApp 的 Error 日志

2. 代码级调试

在代码中添加日志：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import android.util.Log;

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate called");
        setContentView(R.layout.activity_main);
    }

    private void debugMethod() {
        Log.i(TAG, "Info message");
        Log.w(TAG, "Warning message");
        Log.e(TAG, "Error message", new Exception("Stack trace"));
    }
}

使用 debugger：

1
2
3
4
5
# 设置断点并调试（需要 Android Studio 或调试器）
adb forward tcp:5037 tcp:5037

# 查看应用的调试信息
adb shell am dump-hprof --user 10 com.example.myapp /data/anr/dump.hprof

3. 性能监控

CPU 使用率：

1
2
3
4
5
# 查看进程的 CPU 使用
adb shell top -n 1 | grep com.example.myapp

# 持续监控
watch -n 1 'adb shell top -n 1 | grep com.example.myapp'

内存使用：

1
2
3
4
5
# 查看内存详情
adb shell dumpsys meminfo com.example.myapp

# 获取最大内存
adb shell dumpsys meminfo com.example.myapp | grep TOTAL

帧率（FPS）：

1
2
3
4
5
# 启用 FPS 计数
adb shell dumpsys SurfaceFlinger | grep "FramebufferSurface"

# 实时监控（需要性能监控工具）
adb shell service call SurfaceFlinger 1013  # 获取 FPS

快速性能监控脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#!/bin/bash
# perf-monitor.sh - 实时性能监控

APP_PACKAGE="com.example.myapp"

echo "📊 性能监控 (按 Ctrl+C 停止)"
while true; do
    clear
    echo "=== 性能实时数据 ==="
    echo "时间: $(date)"
    
    echo -e "\n📱 CPU 使用率:"
    adb shell top -n 1 | grep "$APP_PACKAGE" | awk '{print $2, $3}'
    
    echo -e "\n💾 内存使用:"
    adb shell dumpsys meminfo "$APP_PACKAGE" | grep -E "^  TOTAL|Pss"
    
    sleep 2
done

第五部分：自动化工作流

1. 快速构建 + 测试 + 部署

完整工作流脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#!/bin/bash
# full-pipeline.sh - 完整的 CI/CD 流程

set -e  # 任何错误立即退出

PROJECT_DIR=$(pwd)
BUILD_DIR="build_output"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

echo "🚀 开始完整工作流..."

# 1. 清理
echo "🧹 清理旧构建..."
rm -rf "$BUILD_DIR" && mkdir -p "$BUILD_DIR"

# 2. 编译
echo "🔨 编译项目..."
./gradlew clean assembleDebug assembleRelease

# 3. 运行单元测试
echo "🧪 运行测试..."
./gradlew testDebugUnitTest || echo "⚠️ 某些测试失败"

# 4. 代码检查（lint）
echo "🔍 代码检查..."
./gradlew lint

# 5. 复制输出
echo "📦 收集输出..."
cp app/build/outputs/apk/debug/*.apk "$BUILD_DIR/app-debug-$TIMESTAMP.apk"
cp app/build/outputs/apk/release/*.apk "$BUILD_DIR/app-release-$TIMESTAMP.apk"

# 6. 统计
echo "📊 构建统计:"
ls -lh "$BUILD_DIR"

# 7. 如果有设备，自动部署
if adb devices | grep -q "device"; then
    echo "📲 发现设备，开始部署..."
    adb install -r "$BUILD_DIR/app-debug-$TIMESTAMP.apk"
    adb shell am start -n com.example.myapp/.MainActivity
fi

echo "✅ 工作流完成！"

2. 批量测试在多个设备上

多设备测试脚本：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#!/bin/bash
# test-all-devices.sh - 在所有连接的设备上运行测试

APP_PACKAGE="com.example.myapp"
APK_PATH="app/build/outputs/apk/debug/app-debug.apk"

echo "📱 获取连接的设备..."
DEVICES=$(adb devices | grep -E 'device$' | awk '{print $1}')

if [ -z "$DEVICES" ]; then
    echo "❌ 没有找到连接的设备"
    exit 1
fi

echo "🔨 开始构建..."
./gradlew assembleDebug

DEVICE_COUNT=0
for DEVICE in $DEVICES; do
    DEVICE_COUNT=$((DEVICE_COUNT + 1))
    echo "
━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo "📲 设备 $DEVICE_COUNT: $DEVICE"
    
    adb -s "$DEVICE" install -r "$APK_PATH"
    adb -s "$DEVICE" shell am start -n "$APP_PACKAGE/.MainActivity"
    adb -s "$DEVICE" shell am instrument -w "$APP_PACKAGE.test/androidx.test.runner.AndroidJUnitRunner"
    
    echo "✅ 设备 $DEVICE 测试完成"
done

echo "
━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "✅ 所有 $DEVICE_COUNT 个设备的测试完成"

3. 生成签名的 APK（发布版本）

签名和发布：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/bin/bash
# release.sh - 生成签名 APK

# 1. 生成密钥库（只需一次）
if [ ! -f "keystore.jks" ]; then
    echo "🔑 生成签名密钥..."
    keytool -genkey -v -keystore keystore.jks \
        -keyalg RSA -keysize 2048 -validity 10000 \
        -alias my-release-key
fi

# 2. 更新 build.gradle
cat >> app/build.gradle << 'EOF'

android {
    signingConfigs {
        release {
            storeFile file("../keystore.jks")
            storePassword System.getenv("KEYSTORE_PASSWORD")
            keyAlias System.getenv("KEY_ALIAS")
            keyPassword System.getenv("KEY_PASSWORD")
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            shrinkResources true
        }
    }
}
EOF

# 3. 构建签名 APK
echo "🔨 构建发布版本..."
export KEYSTORE_PASSWORD="your_password"
export KEY_ALIAS="my-release-key"
export KEY_PASSWORD="your_password"

./gradlew assembleRelease

echo "✅ 发布 APK: app/build/outputs/apk/release/app-release.apk"

第六部分：高级技巧

1. 远程调试（通过 SSH）

在远程服务器开发：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# 在远程服务器上安装和构建
ssh dev@dev-server << 'EOF'
cd ~/android-projects/my-app
./gradlew assembleDebug
EOF

# 下载编译好的 APK
scp dev@dev-server:~/android-projects/my-app/app/build/outputs/apk/debug/app-debug.apk .

# 本地部署
adb install -r app-debug.apk

2. 持续集成（GitHub Actions）

自动化构建和测试：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# .github/workflows/android.yml

name: Android Build

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          java-version: '17'
      
      - name: Build APK
        run: ./gradlew assembleDebug
      
      - name: Run Tests
        run: ./gradlew testDebugUnitTest
      
      - name: Upload APK
        uses: actions/upload-artifact@v3
        with:
          name: debug-apk
          path: app/build/outputs/apk/debug/

3. 性能优化

减小 APK 大小：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// build.gradle

android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

启用 R8 编译器：

1
2
3
4
// gradle.properties

android.enableR8=true
android.enableR8.libraries=true

常见问题解决

问题	解决方案
`ANDROID_SDK_ROOT not found`	设置环境变量：`export ANDROID_SDK_ROOT=~/Android/sdk`
`adb: command not found`	添加 `platform-tools` 到 PATH：`export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools`
`Gradle build fails`	清理并重试：`./gradlew clean build`
设备无法连接	检查 USB 调试是否启用，或用 `adb connect <IP>` 无线连接
APK 无法安装	卸载旧版本：`adb uninstall com.example.myapp`

效率对比

任务	Android Studio	CLI 命令行	效率提升
编译 APK	60-120 秒	20-40 秒	3 倍
安装到设备	通过 UI（30s）	`adb install` （5s）	6 倍
查看日志	Logcat panel	`adb logcat`	相同
多设备测试	一个一个	脚本自动化	N 倍
完整工作流	5-10 分钟	1-2 分钟	5 倍

总结：命令行开发的优势

✅ 极速开发 - 不用等 IDE，秒级反馈 ✅ 完全自动化 - 用脚本编排整个工作流 ✅ 远程友好 - SSH 连接到任何地方开发 ✅ CI/CD 集成 - GitHub Actions、Jenkins 无缝协作 ✅ 资源轻量 - 1GB vs 10GB，旧电脑也能用 ✅ 学习价值 - 理解 Android 构建的真实原理

下一步学习

深入 Gradle - 理解 build.gradle 的每个配置
自动化脚本 - 用 Bash/Python 构建个人工具链
持续集成 - 在 GitHub/GitLab 上自动化测试和部署
性能优化 - 用 CLI 工具进行 APK 优化和分析

参考资源

现在你可以用 Vim + CLI 工具高效开发 Android 应用了！ 🚀✨

Android CLI 快速开发指南：从 0 到 1 的脚本化开发流程#

开篇：为什么开发者还在用 Android Studio#

第一部分：环境搭建#

1. 安装 Java Development Kit (JDK)#

2. 安装 Android SDK#

3. 安装必要的 SDK 组件#

4. 完整的环境变量设置#

第二部分：创建和构建 Android 项目#

1. 快速创建项目结构#

2. 用 Gradle 构建项目#

第三部分：设备管理和部署#

1. 连接和检测设备#

2. 安装和运行 APK#

第四部分：调试和监控#

1. Logcat - 实时日志查看#

2. 代码级调试#

3. 性能监控#

第五部分：自动化工作流#

1. 快速构建 + 测试 + 部署#

2. 批量测试在多个设备上#

3. 生成签名的 APK（发布版本）#

第六部分：高级技巧#

1. 远程调试（通过 SSH）#

2. 持续集成（GitHub Actions）#

3. 性能优化#

常见问题解决#

效率对比#

总结：命令行开发的优势#

下一步学习#

参考资源#