Fire TV的应用性能脚本

public String get_device_type() {
  String deviceType = null;
  try (BufferedReader read = new BufferedReader(new InputStreamReader
                    (Runtime.getRuntime().exec
                    ("adb -s "+ DSN +" shell getprop ro.build.configuration")
                    .getInputStream()))) 
  {
            String outputLines = read.readLine();
            switch (outputLines) {
                case "tv":
                    deviceType = "FTV";
                    break;
                case "tablet":
                    deviceType = "Tablet";
                    break;
            }
  }
  catch (Exception e) {
     System.out.println("获取设备类型信息时出现异常：" + e);
  }
  return deviceType;
}

try (BufferedReader read = new BufferedReader(new InputStreamReader
                    (Runtime.getRuntime().exec("adb -s "+ DSN +" shell pm dump "+ appPackage +" | grep -A 1 MAIN").getInputStream()))) {
            String outputLine = null;
            String line;
            while ((line = read.readLine()) != null) {
                if (line.contains(appPackage + "/")) {
                    outputLine = line;
                    break;
                }
            }
            
            outputLine = outputLine.split("/")[1];
            String mainActivity = outputLine.split(" ")[0];
            String componentName = appPackage + "/" + mainActivity;
            return componentName;
}
catch (Exception e) {
        System.out.println("检索应用主活动时出现异常" + e);
}

try (BufferedReader read = new BufferedReader(new InputStreamReader
                    (Runtime.getRuntime().exec("adb -s "+ DSN +" shell am start -n " + componentName).getInputStream()))) {
            String deviceName = getDeviceName(DSN);
            String line;
            while ((line = read.readLine()) != null) {
                if (line.startsWith("Starting: Intent")) {
                    System.out.println("应用启动成功，使用的是 - " + componentName);
                    break;
                } else if (line.contains("Error")) {
                    System.out.println("应用启动错误");
                }
            }
        } catch (Exception e) {
            System.out.println("启动应用时出现异常：" + e);
        }

try {
     String monkeyCommand = null;
     if (DEVICE_TYPE.equals(FTV)) {
          monkeyCommand = " shell monkey --pct-syskeys 0 -p "
     }
     else {
          monkeyCommand = " shell monkey -p "
     }
     
     BufferedReader launchRead = new BufferedReader(new InputStreamReader
            (Runtime.getRuntime().exec("adb -s "+ DSN + monkeyCommand + appPackage +" -c android.intent.category.LAUNCHER 1").getInputStream()));
      
     String line;
     while ((line = launchRead.readLine()) != null) {
         if (line.contains("Events injected")) {
             System.out.println("使用Monkey工具成功启动应用 - " + appPackage);
             launchRead.close();
             return true;
         } 
         else if (line.contains("Error") || line.contains("No activities found")) {
             System.out.println("通过Monkey工具使用意图启动应用时出现错误”);
             launchRead.close();
             return false;
         }
     }
}
catch (Exception e) {
     System.out.println("使用Monkey启动应用时出现异常" + e);
     return false;
}  

try {
       Runtime.getRuntime().exec("adb -s "+ DSN +" shell am force-stop " + appPackage);
       System.out.println("已强制停止应用 - " + appPackage);
} 
catch (Exception e) {
       System.out.println("强制停止应用时出现异常" + e);
}

public void startAtrace(String dsn) {
    log.info("启动Atrace收集");

    try {
        String command = String.format(
            "adb -s %s shell atrace -t 15 -b 32000 am wm gfx view input > /sdcard/atrace.log 2>&1 & echo $! > /sdcard/atrace.pid",
            dsn
        );

        Process process = Runtime.getRuntime().exec(new String[]{"bash", "-c", command});

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            log.debug("Atrace输出：{}", line);
        }
        reader.close();

        log.info("Atrace在后台启动");

    } catch (Exception e) {
        log.error("启动Atrace时出错：", e);
        throw new RuntimeException("启动Atrace失败", e);
    }
}

public void clearTrace() throws IOException, InterruptedException {
    log.info("清除现有跟踪数据");

    try {
        String deleteLogCmd = String.format("adb -s %s shell rm -rf /sdcard/atrace.log", dsn);
        String deletePidCmd = String.format("adb -s %s shell rm -rf /sdcard/atrace.pid", dsn);
        String clearTraceBuffer = String.format("adb -s %s shell 'echo 0 > /sys/kernel/debug/tracing/trace'", dsn);
        String disableTracing = String.format("adb -s %s shell 'echo 0 > /sys/kernel/debug/tracing/tracing_on'", dsn);

        Process logProcess = Runtime.getRuntime().exec(new String[]{"bash", "-c", deleteLogCmd});
        Process pidProcess = Runtime.getRuntime().exec(new String[]{"bash", "-c", deletePidCmd});
        Process clearTraceBufferProcess = Runtime.getRuntime().exec(new String[]{"bash", "-c", clearTraceBuffer});
        Process disableTracingProcess = Runtime.getRuntime().exec(new String[]{"bash", "-c", disableTracing});

        int logExitCode = logProcess.waitFor();
        int pidExitCode = pidProcess.waitFor();
        int clearTraceBufferExitCode = clearTraceBufferProcess.waitFor();
        int disableTracingExitCode = disableTracingProcess.waitFor();
        

        if (logExitCode != 0 || pidExitCode != 0 || clearTraceBufferExitCode!=0 || disableTracingExitCode!=0) {
            throw new IOException("清除一个或多个跟踪文件失败。Exit codes: log=" + logExitCode + ", pid=" + pidExitCode);
        }

        log.info("跟踪数据已成功清除");
    } catch (Exception e) {
        log.error("清除跟踪时出错：", e);
        throw e;
    }
}

公共字符串 p   ullaTraceLog（整数迭代，la    unchType  launchType）抛出 IOException，In   ter  racetdException  {
    字符串时间戳   = DateTimeFormatt   er 。OfPattern    (“yyymmdd_hhmmss”)  
            。格式    (localDateTime)。现在   ()); 

    String fileName = String.format("systrace_%s_launch_iter%d_%s_%s.txt",
            launchType.toString().toLowerCase(),
            iteration,
            dsn,
            timestamp
    );

    Path currentPath = Paths.get(System.getProperty("user.dir"));
    Path baseDir = currentPath.resolve("configuration/output/logs/systrace");
    Path outputDir = baseDir.resolve(launchType.toString().toLowerCase());
    路径    outputPath  =  output  Dir。 解析 （文件名 ）；

    log.info("工作目录：{}", currentPath);
    log.info("基本目录：{}", baseDir);
    log.info("Systrace文件路径：{}", outputPath);

    线程。睡觉   (5000 ); 

    try {
        Files.createDirectories(outputDir);

        String pullCommand = String.format("adb -s %s pull /sdcard/atrace.log %s", dsn, outputPath);
        log.info("执行拉取命令：{}", pullCommand);

        Process process = Runtime.getRuntime().exec(new String[]{"bash", "-c", pullCommand});

        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            log.debug("拉取输出：{}", line);
        }
        reader.close();

        int exitCode = process.waitFor();
        if (exitCode != 0) {
            throw new IOException("ADB拉取失败，退出代码：" + exitCode);
        }

        log.info("已将设备{}的{}启动跟踪日志拉取至：{}", launchType, dsn, outputPath);

        // 等待命令缓冲区刷新（模拟拉取后的等待）
        线程。睡觉 （30000 ）; 
        log.info("等待拉取日志30秒");

        // 清理设备跟踪文件
        clearTrace();

        return outputPath.toString();

    } catch (Exception e) {
        log.error("在设备{}上保存{}启动的跟踪文件时出错：", launchType, dsn, e);
        throw new IOException("保存跟踪文件失败", e);
    }
}

private double calculateLatency(MarkerInfo startMarker, MarkerInfo endMarker, String launchType) {
    if (startMarker == null || endMarker == null) {
        log.error("缺少{}标记 - 开始：{}，结束：{}",
                launchType,
                startMarker != null ? "found" : "missing",
                endMarker != null ? "found" : "missing");
        return -1;
    }

    double latencyMs = (endMarker.timestamp - startMarker.timestamp) * 1000;
    return Double.parseDouble(formatTime(latencyMs / 1000.0));
}

private double parseTTFFLaunch(List<String> fileContent, String packageName, String launchType) throws IOException {
    final String START_MARKER = "AMS.startActivityAsUser";
    final String END_MARKER = "eglSwapBuffersWithDamageKHR";
    final Pattern TIMESTAMP_PATTERN =
        Pattern.compile("\\[\\d+]\\s+\\.{3}1\\s+(\\d+\\.\\d+):\\s+tracing_mark_write:\\s+B\\|(\\d+)\\|(.*)");

    String appPid = findAppPid(fileContent, packageName);
    if (appPid == null) {
        log.error("找不到程序包的PID：{}", packageName);
        return -1;
    }

    MarkerInfo startMarker = null;
    MarkerInfo endMarker = null;
    int lineCount = 0;

    for (String line : fileContent) {
        lineCount++;
        Matcher matcher = TIMESTAMP_PATTERN.matcher(line);
        if (!matcher.find()) continue;

        double timestamp = Double.parseDouble(matcher.group(1));
        String processId = matcher.group(2);
        String marker = matcher.group(3);

        if (startMarker == null && marker.equals(START_MARKER)) {
            startMarker = new MarkerInfo(timestamp, line, lineCount, processId);
            log.info("在{}行找到{} TTFF起始标记|行：{}", launchType, lineCount, line);
            continue;
        }

        if (endMarker == null && processId.equals(appPid) &&
            (marker.contains("eglSwapBuffers") || marker.contains(END_MARKER))) {
            endMarker = new MarkerInfo(timestamp, line, lineCount, processId);
            log.info("Found {} TTFF end marker at line {} | Line: {}", launchType, lineCount, line);
            break;
        }
    }

    return calculateLatency(startMarker, endMarker, launchType + " TTFF");
}

private double parseRTULaunch(List < String > fileContent, String packageName, String launchType) throws IOException {
    final String START_MARKER = "AMS.startActivityAsUser";
    final String END_MARKER = "eglSwapBuffersWithDamageKHR";
    final Pattern TIMESTAMP_PATTERN =
        Pattern.compile("\\[\\d+]\\s+\\.{3}1\\s+(\\d+\\.\\d+):\\s+tracing_mark_write:\\s+B\\|(\\d+)\\|(.*)");

    String appPid = findAppPid(fileContent, packageName);
    if (appPid == null) {
        log.error("找不到程序包的PID：{}", packageName);
        return -1;
    }

    MarkerInfo startMarker = null;
    MarkerInfo lastChoreographer = null;
    MarkerInfo endMarker = null;
    MarkerInfo reportFullyDrawnMarker = null;
    int lineCount = 0;

    // 第一遍：找到起始标记、最后Choreographer和reportFullyDrawn
    for (String line : fileContent) {
        lineCount++;
        if (line.contains("ExoPlayer")) continue; // 跳过ExoPlayer行

        Matcher matcher = TIMESTAMP_PATTERN.matcher(line);
        if (!matcher.find()) continue;

        double timestamp = Double.parseDouble(matcher.group(1));
        String processId = matcher.group(2);
        String marker = matcher.group(3);

        if (startMarker == null && marker.equals(START_MARKER)) {
            startMarker = new MarkerInfo(timestamp, line, lineCount, processId);
            log.info("在{}行找到{}起始标记|行：{}", launchType, lineCount, line);
            continue;
        }

        if (processId.equals(appPid)) {
            // 跟踪Choreographer帧数（不包括ExoPlayer）
            if (marker.contains(GFX_MARKER) && !line.contains("ExoPlayer")) {
                lastChoreographer = new MarkerInfo(timestamp, line, lineCount, processId);
            }
            // 跟踪reportFullyDrawn（如果存在）
            else if (marker.contains("Activity.reportFullyDrawn")) {
                reportFullyDrawnMarker = new MarkerInfo(timestamp, line, lineCount, processId);
                log.info("在行{}找到reportFullyDrawn|行：{}", lineCount, line);
            }
        }
    }
    
    if(reportFullyDrawnMarker == null) {
        // 第二遍：找到最后一个Choreographer之后的第一个结束标记
        if (lastChoreographer != null) {
            lineCount = 0;
            for (String line : fileContent) {
                lineCount++;
                if (line.contains("ExoPlayer")) continue; // 跳过ExoPlayer行
    
                Matcher matcher = TIMESTAMP_PATTERN.matcher(line);
                if (!matcher.find()) continue;
    
                double timestamp = Double.parseDouble(matcher.group(1));
                String processId = matcher.group(2);
                String marker = matcher.group(3);
    
                if (processId.equals(appPid) &&
                        timestamp > lastChoreographer.timestamp &&
                        marker.contains(END_MARKER)) {
    
                    endMarker = new MarkerInfo(timestamp, line, lineCount, processId);
                    log.info("在行{}的Choreographer后找到第一个{}eglSwapBuffers|行：{}",
                            launchType, lineCount, line);
                    break;
                }
            }
        }
    
        // 获取最后eglSwapBuffers的回退方法：
        if (endMarker == null) {
            lineCount = 0;
            double timestamp = 0;
            int finalLineCount =0;
            String finalLine = null;
            for (String line : fileContent) {
                lineCount++;
                if (line.contains("ExoPlayer")) continue; // 跳过ExoPlayer行
    
                Matcher matcher = TIMESTAMP_PATTERN.matcher(line);
                if (!matcher.find()) continue;
    
                String processId = matcher.group(2);
    
                String marker = matcher.group(3);
    
                if (processId.equals(appPid) && marker.contains(END_MARKER)) {
                    timestamp = Double.parseDouble(matcher.group(1));
                    finalLine = line;
                    finalLineCount = lineCount;
                }
            }
            if (finalLineCount > 0) {
                endMarker = new MarkerInfo(timestamp, finalLine, finalLineCount, appPid);
                log.info("回退方法： 在行{}找到最后{} eglSwapBuffers|行：{}", launchType,
                         finalLineCount, endMarker.line);
            } else {
                log.info("用任何方法都无法找到egl swapBuffers标记！！");
            }
        }
    } else {
        endMarker = reportFullyDrawnMarker;
    }

    return calculateLatency(startMarker, endMarker, launchType + " RTU");
}

public void log_file_writer(BufferedReader bf_read) {
 File adb_log_file = new File(kpi_log_file_path + "/KPI_Log.txt");
 FileWriter fileWriter = new FileWriter(adb_log_file);
 try {
    String reader = null;
     while ((reader = bf_read.readLine()) != null) {
            fileWriter.write(reader.trim() + "\n");
     }
  }
  catch (Exception e) {
     System.out.println(e);
  } 
  finally {
     fileWriter.flush();
     fileWriter.close();
     bf_read.close();
  }   
}