# 自定义调试工具开发

## 概述

在Android开发中，有时需要开发自定义的调试工具来满足特定需求。本文档介绍如何设计和开发自定义调试工具。

## 工具设计原则

### 1. 明确需求

在开发工具前，需要明确：
- **解决什么问题**: 工具要解决的具体问题
- **目标用户**: 谁将使用这个工具
- **使用场景**: 在什么情况下使用
- **性能要求**: 对性能的影响要求

### 2. 设计原则

- **易用性**: 界面简洁，操作简单
- **可靠性**: 稳定可靠，不影响应用运行
- **可扩展性**: 便于后续扩展功能
- **性能**: 对应用性能影响最小

### 3. 技术选型

- **语言**: Java/Kotlin/C++
- **框架**: 根据需求选择
- **UI**: 命令行/图形界面/Web界面
- **部署**: 独立应用/集成到应用/插件

## 工具类型

### 1. 性能监控工具

#### 功能需求
- CPU使用率监控
- 内存使用监控
- 帧率监控
- 网络请求监控

#### 实现示例

```java
public class PerformanceMonitor {
    private static PerformanceMonitor sInstance;
    private Handler mHandler;
    private boolean mMonitoring = false;
    
    public static PerformanceMonitor getInstance() {
        if (sInstance == null) {
            sInstance = new PerformanceMonitor();
        }
        return sInstance;
    }
    
    public void startMonitoring() {
        if (mMonitoring) {
            return;
        }
        mMonitoring = true;
        mHandler = new Handler(Looper.getMainLooper());
        mHandler.post(mMonitorRunnable);
    }
    
    public void stopMonitoring() {
        mMonitoring = false;
        if (mHandler != null) {
            mHandler.removeCallbacks(mMonitorRunnable);
        }
    }
    
    private Runnable mMonitorRunnable = new Runnable() {
        @Override
        public void run() {
            if (!mMonitoring) {
                return;
            }
            
            // 收集性能数据
            collectPerformanceData();
            
            // 1秒后再次执行
            mHandler.postDelayed(this, 1000);
        }
    };
    
    private void collectPerformanceData() {
        // CPU使用率
        float cpuUsage = getCpuUsage();
        
        // 内存使用
        long memoryUsage = getMemoryUsage();
        
        // 帧率
        float fps = getFPS();
        
        // 记录数据
        Log.d("Performance", String.format(
            "CPU: %.2f%%, Memory: %dMB, FPS: %.2f",
            cpuUsage, memoryUsage / 1024 / 1024, fps
        ));
    }
    
    private float getCpuUsage() {
        // 实现CPU使用率计算
        // 通过/proc/stat计算
        return 0.0f;
    }
    
    private long getMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        return runtime.totalMemory() - runtime.freeMemory();
    }
    
    private float getFPS() {
        // 使用Choreographer计算FPS
        return 0.0f;
    }
}
```

### 2. 日志收集工具

#### 功能需求
- 自动收集日志
- 日志分类存储
- 日志上传
- 日志分析

#### 实现示例

```java
public class LogCollector {
    private static final String LOG_DIR = "logs";
    private File mLogDir;
    private File mCurrentLogFile;
    
    public LogCollector(Context context) {
        mLogDir = new File(context.getFilesDir(), LOG_DIR);
        if (!mLogDir.exists()) {
            mLogDir.mkdirs();
        }
    }
    
    public void startCollecting() {
        // 创建新的日志文件
        String fileName = "log_" + System.currentTimeMillis() + ".txt";
        mCurrentLogFile = new File(mLogDir, fileName);
        
        // 启动日志收集线程
        new Thread(() -> {
            collectLogs();
        }).start();
    }
    
    private void collectLogs() {
        try {
            Process process = Runtime.getRuntime().exec("logcat");
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream())
            );
            
            FileWriter writer = new FileWriter(mCurrentLogFile);
            String line;
            while ((line = reader.readLine()) != null) {
                // 过滤和格式化日志
                if (shouldCollect(line)) {
                    writer.write(line + "\n");
                    writer.flush();
                }
            }
            
            writer.close();
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private boolean shouldCollect(String line) {
        // 实现日志过滤逻辑
        return line.contains("MyApp");
    }
    
    public void uploadLogs(String url) {
        // 实现日志上传逻辑
        // 可以使用OkHttp等网络库
    }
}
```

### 3. 内存分析工具

#### 功能需求
- 内存快照
- 内存泄漏检测
- 内存使用分析
- 内存报告生成

#### 实现示例

```java
public class MemoryAnalyzer {
    private ActivityManager mActivityManager;
    
    public MemoryAnalyzer(Context context) {
        mActivityManager = (ActivityManager) 
            context.getSystemService(Context.ACTIVITY_SERVICE);
    }
    
    public MemoryInfo getMemoryInfo() {
        ActivityManager.MemoryInfo memInfo = 
            new ActivityManager.MemoryInfo();
        mActivityManager.getMemoryInfo(memInfo);
        
        return new MemoryInfo(
            memInfo.totalMem,
            memInfo.availMem,
            memInfo.threshold,
            memInfo.lowMemory
        );
    }
    
    public void dumpHeap(String fileName) {
        try {
            Debug.dumpHprofData(fileName);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void analyzeMemoryLeak() {
        // 实现内存泄漏检测逻辑
        // 可以集成LeakCanary
    }
    
    public static class MemoryInfo {
        public long totalMem;
        public long availMem;
        public long threshold;
        public boolean lowMemory;
        
        public MemoryInfo(long total, long avail, 
                         long threshold, boolean low) {
            this.totalMem = total;
            this.availMem = avail;
            this.threshold = threshold;
            this.lowMemory = low;
        }
    }
}
```

### 4. 网络监控工具

#### 功能需求
- 网络请求拦截
- 请求响应记录
- 网络性能分析
- 请求重放

#### 实现示例

```java
public class NetworkMonitor {
    private List<NetworkRequest> mRequests = new ArrayList<>();
    private boolean mMonitoring = false;
    
    public void startMonitoring() {
        mMonitoring = true;
        // 使用OkHttp Interceptor拦截请求
    }
    
    public void stopMonitoring() {
        mMonitoring = false;
    }
    
    public void addRequest(NetworkRequest request) {
        if (mMonitoring) {
            mRequests.add(request);
        }
    }
    
    public List<NetworkRequest> getRequests() {
        return new ArrayList<>(mRequests);
    }
    
    public void exportRequests(String fileName) {
        // 导出请求记录
        try {
            FileWriter writer = new FileWriter(fileName);
            for (NetworkRequest request : mRequests) {
                writer.write(request.toString() + "\n");
            }
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static class NetworkRequest {
        public String url;
        public String method;
        public Map<String, String> headers;
        public String requestBody;
        public String responseBody;
        public long duration;
        public int statusCode;
    }
}
```

## 工具集成方式

### 1. 独立应用

```java
// 作为独立的调试应用
public class DebugApp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // 初始化调试工具
        DebugTools.init(this);
    }
}
```

**优点**:
- 不影响主应用
- 可以独立更新
- 便于分发

**缺点**:
- 需要单独安装
- 可能无法访问主应用数据

### 2. 集成到应用

```java
// 在主应用中集成
public class MainApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        
        if (BuildConfig.DEBUG) {
            // 只在Debug版本启用
            DebugTools.init(this);
        }
    }
}
```

**优点**:
- 直接访问应用数据
- 无需单独安装
- 集成度高

**缺点**:
- 可能影响应用性能
- 需要控制发布版本

### 3. 插件化

```java
// 使用插件机制
public class DebugPlugin {
    public void load(Context context) {
        // 动态加载调试功能
    }
    
    public void unload() {
        // 卸载调试功能
    }
}
```

**优点**:
- 灵活加载/卸载
- 不影响主应用
- 便于扩展

**缺点**:
- 实现复杂
- 需要插件框架支持

## UI设计

### 1. 命令行界面

```java
public class DebugCLI {
    public void start() {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("Debug> ");
            String command = scanner.nextLine();
            executeCommand(command);
        }
    }
    
    private void executeCommand(String command) {
        String[] parts = command.split(" ");
        String cmd = parts[0];
        
        switch (cmd) {
            case "memory":
                showMemoryInfo();
                break;
            case "cpu":
                showCpuInfo();
                break;
            case "fps":
                showFPS();
                break;
            case "help":
                showHelp();
                break;
            default:
                System.out.println("Unknown command: " + cmd);
        }
    }
}
```

### 2. 图形界面

```java
// 使用Android原生UI
public class DebugActivity extends AppCompatActivity {
    private TextView mMemoryText;
    private TextView mCpuText;
    private TextView mFpsText;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_debug);
        
        mMemoryText = findViewById(R.id.memory_text);
        mCpuText = findViewById(R.id.cpu_text);
        mFpsText = findViewById(R.id.fps_text);
        
        startMonitoring();
    }
    
    private void startMonitoring() {
        Handler handler = new Handler();
        handler.post(new Runnable() {
            @Override
            public void run() {
                updateUI();
                handler.postDelayed(this, 1000);
            }
        });
    }
    
    private void updateUI() {
        // 更新UI显示
        mMemoryText.setText(getMemoryInfo());
        mCpuText.setText(getCpuInfo());
        mFpsText.setText(getFpsInfo());
    }
}
```

### 3. Web界面

```java
// 使用WebView或HTTP服务器
public class DebugWebServer {
    private HttpServer mServer;
    
    public void start(int port) {
        try {
            mServer = HttpServer.create(new InetSocketAddress(port), 0);
            mServer.createContext("/", new DebugHandler());
            mServer.setExecutor(null);
            mServer.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    private class DebugHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange exchange) throws IOException {
            String response = generateResponse();
            exchange.sendResponseHeaders(200, response.length());
            OutputStream os = exchange.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}
```

## 工具发布

### 1. 版本管理

```gradle
// build.gradle
android {
    defaultConfig {
        versionCode 1
        versionName "1.0.0"
    }
}
```

### 2. 文档编写

- **使用说明**: 如何安装和使用
- **功能说明**: 功能介绍
- **常见问题**: FAQ
- **更新日志**: 版本更新记录

### 3. 分发方式

- **内部使用**: 通过内部渠道分发
- **GitHub**: 开源发布
- **应用商店**: 发布到应用商店

## 最佳实践

1. **性能优先**: 确保工具不影响应用性能
2. **易于使用**: 界面简洁，操作直观
3. **稳定可靠**: 充分测试，确保稳定
4. **文档完善**: 提供详细的使用文档
5. **持续维护**: 根据反馈持续改进

## 相关链接

- [[README]]
- [[ADB高级命令]]
- [[06-性能优化体系]]