Fire OSでアプリの起動時間を測定し改善する方法

ActivityManager: Displayed {package}/{activity}: +1s534ms

ActivityManager: Fully drawn {package}/{activity}: +4s54ms

ActivityManager: Displayed {package}/{activity}: +1s534ms

ActivityManager: Fully drawn {package}/{activity}: +4s54ms

// MainActivity.java
public class MainActivity extends Activity {

    ...
    private static final Uri mBaseUri = Uri.parse("https://mysampleapp.com");

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                .replace(R.id.main_browse_fragment, new MainFragment())
                .commitNow();
        }

        WebView mWebView = findViewById(R.id.web_layout);
        mWebView.getSettings().setJavaScriptEnabled(true);
        mWebView.loadUrl(mBaseUri.toString());
        mWebView.setWebViewClient(new WebViewClient() {
            @Override
            public void onPageFinished(WebView view, String url) {
                super.onPageFinished(view, url);

                reportFullyDrawn();
            }
        });
    }
    
    ...
}

public void serialize(Context context, String filename, Serializable object) throws Exception {
    FileOutputStream fOut = context.openFileOutput(filename, Context.MODE_PRIVATE);
    ObjectOutputStream oOut = new ObjectOutputStream(fOut);
    oOut.writeObject(object);
    oOut.close();
}

public Object deserialize(Context context, String filename) throws Exception {
    FileInputStream fIn = context.openFileInput(filename);
    ObjectInputStream oIn = new ObjectInputStream(fIn);
    Object result = oIn.readObject();
    oIn.close();

    return result;
}

// app_start_times.kts
import java.util.Scanner

private val CMD_LOGCAT = "adb logcat"
private val CMD_HOME = "adb shell input keyevent 3"
private val COOLDOWN_MILIS: Long = 1 * 1000

//APP PARAMETERS
private val PACKAGE_NAME = "com.example.myapplication"
private val ACTIVITY_NAME = "MainActivity"

//SCRIPT PARAMETERS
private var MEASURE_TIMES = 10
private var MEASURE_COLD_START = true
private var MEASURE_WARM_START = false

val logcatScanner = startAdbLogcat()

prepareApp(MEASURE_COLD_START, logcatScanner)
runMeasureLoop(MEASURE_COLD_START, MEASURE_TIMES, logcatScanner)

prepareApp(MEASURE_WARM_START, logcatScanner)
runMeasureLoop(MEASURE_WARM_START, MEASURE_TIMES, logcatScanner)

fun startAdbLogcat(): Scanner{
    val logcatProcess = Runtime.getRuntime().exec(CMD_LOGCAT)
    println("ADB Logcat Started")
    Thread.sleep(COOLDOWN_MILIS)
    val stream = logcatProcess.inputStream
    val scanner = Scanner(stream)
    scanner.useDelimiter("\n")
    return scanner
}

fun prepareApp(isWarmStart: Boolean, scanner: Scanner) {
    println("Step 1 - PREPARATION")
    val appStart = generateAppStartAdbCommand()
    val appStop = generateAppStopAdbCommand()
    val fullyDrawm = generateFullyDrawnLog()

    if(isWarmStart) {
        println("  - Opening app once and putting to background (for WARM START measure)")

        // To have proper WARM START benchmarks, open the app once,
        // wait until it is fully drawn and put it in the background
        Runtime.getRuntime().exec(appStart)
        waitForLog(fullyDrawm, scanner)
        Thread.sleep(COOLDOWN_MILIS)
        Runtime.getRuntime().exec(CMD_HOME)
    } else {
        println("  - Making sure that the app is closed (for COLD START measure)")
        Runtime.getRuntime().exec(appStop)
    }
}

fun runMeasureLoop(isWarmStart: Boolean, benchmarkTimes: Int, scanner: Scanner) {
    var totalMillis: Long = 0

    println("Step 2 - BENCHMARKING $benchmarkTimes TIMES")
    for(i in 1..benchmarkTimes) {
        println("  - Run $i")
        val benchmark = benchmarkApp(isWarmStart, scanner)
        totalMillis = totalMillis + benchmark
        Thread.sleep(COOLDOWN_MILIS)
    }

    println("Step 3 - RESULTS")
    println("  - Start type: ${if(isWarmStart) "WARM START" else "COLD START"}")
    println("  - Times benchmarked: $benchmarkTimes")
    println("  - Average start time: ${totalMillis/benchmarkTimes} milliseconds")
}

fun waitForLog(logToSearch: String, scanner: Scanner): String {
    while (scanner.hasNext()) {
        val str = scanner.next().trim()
        if(str.contains(logToSearch)) {
            return str
        }
    }

    return ""
}

fun benchmarkApp(isWarmStart: Boolean, scanner: Scanner): Long {
    val appStart = generateAppStartAdbCommand()
    val appStop = generateAppStopAdbCommand()
    val logToSearch = if(isWarmStart) generateFullyDrawnLog() else generateTimeToDisplayLog()

    Runtime.getRuntime().exec(appStart)
    val log = waitForLog(logToSearch, scanner)
    val millis = extractMiliseconds(log)

    Thread.sleep(COOLDOWN_MILIS)
    if(isWarmStart) {
        println("    * WARM START at $millis milliseconds")
        Runtime.getRuntime().exec(CMD_HOME)
    } else {
        println("    * COLD START at $millis milliseconds")
        Runtime.getRuntime().exec(appStop)
    }

    return millis
}

fun extractMiliseconds(logcat: String): Long {
    //1s234ms -> 1234 millis
    //345ms -> 345 millis
    var milis = logcat.split(" ").last().filter { it.isDigit() }
    return milis.toLong()
}

fun generateAppStartAdbCommand(): String {
    return "adb shell am start -n ${PACKAGE_NAME}/.${ACTIVITY_NAME}"
}

fun generateAppStopAdbCommand(): String {
    return "adb shell am force-stop ${PACKAGE_NAME}"
}

fun generateTimeToDisplayLog(): String {
    return "Displayed ${PACKAGE_NAME}/.${ACTIVITY_NAME}"
}

fun generateFullyDrawnLog(): String {
    return "Fully drawn ${PACKAGE_NAME}/.${ACTIVITY_NAME}"
}