/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tests.applaunch;

import static org.junit.Assert.assertNotNull;

import android.accounts.Account;
import android.accounts.AccountManager;
import android.app.ActivityManager;
import android.app.ActivityManager.ProcessErrorStateInfo;
import android.app.IActivityManager;
import android.app.UiAutomation;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.UserHandle;
import android.support.test.uiautomator.UiDevice;
import android.test.InstrumentationTestCase;
import android.test.InstrumentationTestRunner;
import android.util.Log;

import androidx.test.rule.logging.AtraceLogger;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.file.Paths;
import java.time.format.DateTimeFormatter;
import java.time.ZonedDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * This test is intended to measure the time it takes for the apps to start.
 * Names of the applications are passed in command line, and the
 * test starts each application, and reports the start up time in milliseconds.
 * The instrumentation expects the following key to be passed on the command line:
 * apps - A list of applications to start and their corresponding result keys
 * in the following format:
 * -e apps <app name>^<result key>|<app name>^<result key>
 */
@Deprecated
public class AppLaunch extends InstrumentationTestCase {

    private static final int JOIN_TIMEOUT = 10000;
    private static final String TAG = AppLaunch.class.getSimpleName();

    // optional parameter: comma separated list of required account types before proceeding
    // with the app launch
    private static final String KEY_REQUIRED_ACCOUNTS = "required_accounts";
    private static final String KEY_APPS = "apps";
    private static final String KEY_IORAP_TRIAL_LAUNCH = "iorap_trial_launch";
    private static final String KEY_IORAP_COMPILER_FILTERS = "iorap_compiler_filters";
    private static final String KEY_TRIAL_LAUNCH = "trial_launch";
    private static final String KEY_LAUNCH_ITERATIONS = "launch_iterations";
    private static final String KEY_LAUNCH_ORDER = "launch_order";
    private static final String KEY_DROP_CACHE = "drop_cache";
    private static final String KEY_SIMPLEPERF_CMD = "simpleperf_cmd";
    private static final String KEY_SIMPLEPERF_APP = "simpleperf_app";
    private static final String KEY_CYCLE_CLEAN = "cycle_clean";
    private static final String KEY_TRACE_ALL = "trace_all";
    private static final String KEY_TRACE_ITERATIONS = "trace_iterations";
    private static final String KEY_LAUNCH_DIRECTORY = "launch_directory";
    private static final String KEY_TRACE_DIRECTORY = "trace_directory";
    private static final String KEY_TRACE_CATEGORY = "trace_categories";
    private static final String KEY_TRACE_BUFFERSIZE = "trace_bufferSize";
    private static final String KEY_TRACE_DUMPINTERVAL = "tracedump_interval";
    private static final String KEY_COMPILER_FILTERS = "compiler_filters";
    private static final String KEY_FORCE_STOP_APP = "force_stop_app";
    private static final String ENABLE_SCREEN_RECORDING = "enable_screen_recording";
    private static final int MAX_RECORDING_PARTS = 5;
    private static final long VIDEO_TAIL_BUFFER = 500;

    private static final String SIMPLEPERF_APP_CMD =
            "simpleperf --log fatal stat --csv -e cpu-cycles,major-faults --app %s & %s";
    private static final String WEARABLE_ACTION_GOOGLE =
            "com.google.android.wearable.action.GOOGLE";
    private static final int INITIAL_LAUNCH_IDLE_TIMEOUT = 5000; // 5s to allow app to idle
    private static final int POST_LAUNCH_IDLE_TIMEOUT = 750; // 750ms idle for non initial launches
    private static final int BEFORE_FORCE_STOP_SLEEP_TIMEOUT = 1000; // 1s before force stopping
    private static final int BEFORE_KILL_APP_SLEEP_TIMEOUT = 1000; // 1s before killing
    private static final int BETWEEN_LAUNCH_SLEEP_TIMEOUT = 3000; // 3s between launching apps
    private static final int PROFILE_SAVE_SLEEP_TIMEOUT = 1000; // Allow 1s for the profile to save
    private static final int IORAP_TRACE_DURATION_TIMEOUT = 7000; // Allow 7s for trace to complete.
    private static final int IORAP_TRIAL_LAUNCH_ITERATIONS = 5;  // min 5 launches to merge traces.
    private static final int IORAP_COMPILE_CMD_TIMEOUT = 60;  // in seconds: 1 minutes
    private static final int IORAP_COMPILE_MIN_TRACES = 1;  // configure iorapd to need 1 trace.
    private static final int IORAP_COMPILE_RETRIES = 3;  // retry compiler 3 times if it fails.
    private static final String LAUNCH_SUB_DIRECTORY = "launch_logs";
    private static final String LAUNCH_FILE = "applaunch.txt";
    private static final String TRACE_SUB_DIRECTORY = "atrace_logs";
    private static final String DEFAULT_TRACE_CATEGORIES =
            "sched,freq,gfx,view,dalvik,webview,input,wm,disk,am,wm,binder_driver,hal,ss";
    private static final String DEFAULT_TRACE_BUFFER_SIZE = "20000";
    private static final String DEFAULT_TRACE_DUMP_INTERVAL = "10";
    private static final String TRIAL_LAUNCH = "TRIAL_LAUNCH";
    private static final String IORAP_TRIAL_LAUNCH = "IORAP_TRIAL_LAUNCH";
    private static final String IORAP_TRIAL_LAUNCH_FIRST = "IORAP_TRIAL_LAUNCH_FIRST";
    private static final String IORAP_TRIAL_LAUNCH_LAST = "IORAP_TRIAL_LAUNCH_LAST";
    private static final String DELIMITER = ",";
    private static final String DROP_CACHE_SCRIPT = "/data/local/tmp/dropCache.sh";
    private static final String APP_LAUNCH_CMD = "am start -W -n";
    private static final String SUCCESS_MESSAGE = "Status: ok";
    private static final String TOTAL_TIME_MESSAGE = "TotalTime:";
    private static final String COMPILE_SUCCESS = "Success";
    private static final String LAUNCH_ITERATION = "LAUNCH_ITERATION-%d";
    private static final String TRACE_ITERATION = "TRACE_ITERATION-%d";
    private static final String LAUNCH_ITERATION_PREFIX = "LAUNCH_ITERATION";
    private static final String TRACE_ITERATION_PREFIX = "TRACE_ITERATION";
    private static final String LAUNCH_ORDER_CYCLIC = "cyclic";
    private static final String LAUNCH_ORDER_SEQUENTIAL = "sequential";
    private static final String COMPILE_CMD = "cmd package compile -f -m %s %s";
    private static final String IORAP_COMPILE_CMD = "dumpsys iorapd --compile-package %s";
    private static final String IORAP_MAINTENANCE_CMD =
            "dumpsys iorapd --purge-package %s";
    private static final String IORAP_DUMPSYS_CMD = "dumpsys iorapd";
    private static final String SPEED_PROFILE_FILTER = "speed-profile";
    private static final String VERIFY_FILTER = "verify";
    private static final String LAUNCH_SCRIPT_NAME = "appLaunch";

    private Map<String, Intent> mNameToIntent;
    private List<LaunchOrder> mLaunchOrderList = new ArrayList<LaunchOrder>();
    private RecordingThread mCurrentThread;
    private Map<String, String> mNameToResultKey;
    private Map<String, Map<String, List<AppLaunchResult>>> mNameToLaunchTime;
    private IActivityManager mAm;
    private File launchSubDir = null;
    private String mSimplePerfCmd = null;
    private String mLaunchOrder = null;
    private boolean mDropCache = false;
    private int mLaunchIterations = 10;
    private boolean mForceStopApp = true;
    private boolean mEnableRecording = false;
    private int mTraceLaunchCount = 0;
    private String mTraceDirectoryStr = null;
    private Bundle mResult = new Bundle();
    private Set<String> mRequiredAccounts;
    private boolean mTrialLaunch = false;
    private boolean mIorapTrialLaunch = false;
    private BufferedWriter mBufferedWriter = null;
    private boolean mSimplePerfAppOnly = false;
    private String[] mCompilerFilters = null;
    private List<String> mIorapCompilerFilters = null;
    private String mLastAppName = "";
    private boolean mCycleCleanUp = false;
    private boolean mTraceAll = false;
    private boolean mIterationCycle = false;
    private UiDevice mDevice;

    enum IorapStatus {
        UNDEFINED,
        ENABLED,
        DISABLED
    }
    private IorapStatus mIorapStatus = IorapStatus.UNDEFINED;
    private long mCycleTime = 0;
    private StringBuilder mCycleTimes = new StringBuilder();

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        getInstrumentation().getUiAutomation().setRotation(UiAutomation.ROTATION_FREEZE_0);
    }

    @Override
    protected void tearDown() throws Exception {
        getInstrumentation().getUiAutomation().setRotation(UiAutomation.ROTATION_UNFREEZE);
        super.tearDown();
    }

    private void addLaunchResult(LaunchOrder launch, AppLaunchResult result) {
        mNameToLaunchTime.get(launch.getApp()).get(launch.getCompilerFilter()).add(result);
    }

    private boolean hasFailureOnFirstLaunch(LaunchOrder launch) {
        List<AppLaunchResult> results =
            mNameToLaunchTime.get(launch.getApp()).get(launch.getCompilerFilter());
        return (results.size() > 0) && (results.get(0).mLaunchTime < 0);
    }

    public void testMeasureStartUpTime() throws RemoteException, NameNotFoundException,
            IOException, InterruptedException {
        InstrumentationTestRunner instrumentation =
                (InstrumentationTestRunner)getInstrumentation();
        Bundle args = instrumentation.getArguments();
        mAm = ActivityManager.getService();
        String launchDirectory = args.getString(KEY_LAUNCH_DIRECTORY);

        createMappings();
        parseArgs(args);
        checkAccountSignIn();

        // Root directory for applaunch file to log the app launch output
        // Will be useful in case of simpleperf command is used
        File launchRootDir = null;
        if (null != launchDirectory && !launchDirectory.isEmpty()) {
            launchRootDir = new File(launchDirectory);
            if (!launchRootDir.exists() && !launchRootDir.mkdirs()) {
                throw new IOException("Unable to create the destination directory "
                    + launchRootDir + ". Try disabling selinux.");
            }
        }

        try {
            launchSubDir = new File(launchRootDir, LAUNCH_SUB_DIRECTORY);

            if (!launchSubDir.exists() && !launchSubDir.mkdirs()) {
                throw new IOException("Unable to create the lauch file sub directory "
                    + launchSubDir + ". Try disabling selinux.");
            }
            File file = new File(launchSubDir, LAUNCH_FILE);
            FileOutputStream outputStream = new FileOutputStream(file);
            mBufferedWriter = new BufferedWriter(new OutputStreamWriter(
                    outputStream));

            // Root directory for trace file during the launches
            File rootTrace = null;
            File rootTraceSubDir = null;
            int traceBufferSize = 0;
            int traceDumpInterval = 0;
            Set<String> traceCategoriesSet = null;
            if (null != mTraceDirectoryStr && !mTraceDirectoryStr.isEmpty()) {
                rootTrace = new File(mTraceDirectoryStr);
                if (!rootTrace.exists() && !rootTrace.mkdirs()) {
                    throw new IOException("Unable to create the trace directory");
                }
                rootTraceSubDir = new File(rootTrace, TRACE_SUB_DIRECTORY);
                if (!rootTraceSubDir.exists() && !rootTraceSubDir.mkdirs()) {
                    throw new IOException("Unable to create the trace sub directory");
                }
                assertNotNull("Trace iteration parameter is mandatory",
                        args.getString(KEY_TRACE_ITERATIONS));
                mTraceLaunchCount = Integer.parseInt(args.getString(KEY_TRACE_ITERATIONS));
                String traceCategoriesStr = args
                        .getString(KEY_TRACE_CATEGORY, DEFAULT_TRACE_CATEGORIES);
                traceBufferSize = Integer.parseInt(args.getString(KEY_TRACE_BUFFERSIZE,
                        DEFAULT_TRACE_BUFFER_SIZE));
                traceDumpInterval = Integer.parseInt(args.getString(KEY_TRACE_DUMPINTERVAL,
                        DEFAULT_TRACE_DUMP_INTERVAL));
                traceCategoriesSet = new HashSet<String>();
                if (!traceCategoriesStr.isEmpty()) {
                    String[] traceCategoriesSplit = traceCategoriesStr.split(DELIMITER);
                    for (int i = 0; i < traceCategoriesSplit.length; i++) {
                        traceCategoriesSet.add(traceCategoriesSplit[i]);
                    }
                }
            }

            // Get the app launch order based on launch order, trial launch,
            // launch iterations and trace iterations
            setLaunchOrder();

            for (LaunchOrder launch : mLaunchOrderList) {
                toggleIorapStatus(launch.getIorapEnabled());
                dropCache(/*override*/false);

                Log.v(TAG, "Launch reason: " + launch.getLaunchReason());

                // App launch times for trial launch will not be used for final
                // launch time calculations.
                if (launch.getLaunchReason().equals(TRIAL_LAUNCH)) {
                    mIterationCycle = false;
                    // In the "applaunch.txt" file, trail launches is referenced using
                    // "TRIAL_LAUNCH"
                    Intent startIntent = mNameToIntent.get(launch.getApp());
                    if (startIntent == null) {
                        Log.w(TAG, "App does not exist: " + launch.getApp());
                        mResult.putString(mNameToResultKey.get(launch.getApp()),
                            "App does not exist");
                        continue;
                    }
                    String appPkgName = startIntent.getComponent().getPackageName();
                    if (SPEED_PROFILE_FILTER.equals(launch.getCompilerFilter())) {
                        assertTrue(String.format("Not able to compile the app : %s", appPkgName),
                              compileApp(VERIFY_FILTER, appPkgName));
                    } else if (launch.getCompilerFilter() != null) {
                        assertTrue(String.format("Not able to compile the app : %s", appPkgName),
                              compileApp(launch.getCompilerFilter(), appPkgName));
                    }
                    // We only need to run a trial for the speed-profile filter, but we always
                    // run one for "applaunch.txt" consistency.
                    AppLaunchResult launchResult =
                        startApp(launch.getApp(), launch.getLaunchReason());
                    if (launchResult.mLaunchTime < 0) {
                        addLaunchResult(launch, new AppLaunchResult());
                        // simply pass the app if launch isn't successful
                        // error should have already been logged by startApp
                        continue;
                    }
                    sleep(INITIAL_LAUNCH_IDLE_TIMEOUT);
                    if (SPEED_PROFILE_FILTER.equals(launch.getCompilerFilter())) {
                        // Send SIGUSR1 to force dumping a profile.
                        String sendSignalCommand =
                            String.format("killall -s SIGUSR1 %s", appPkgName);
                        getInstrumentation().getUiAutomation().executeShellCommand(
                            sendSignalCommand);
                        // killall is async, wait one second to let the app save the profile.
                        sleep(PROFILE_SAVE_SLEEP_TIMEOUT);
                        assertTrue(String.format("Not able to compile the app : %s", appPkgName),
                              compileApp(launch.getCompilerFilter(), appPkgName));
                    }
                }
                else if (launch.getLaunchReason().startsWith(IORAP_TRIAL_LAUNCH)) {
                    mIterationCycle = false;

                    // In the "applaunch.txt" file, iorap-trial launches is referenced using
                    // "IORAP_TRIAL_LAUNCH" or "IORAP_TRIAL_LAUNCH_LAST"
                    Intent startIntent = mNameToIntent.get(launch.getApp());
                    if (startIntent == null) {
                        Log.w(TAG, "App does not exist: " + launch.getApp());
                        mResult.putString(mNameToResultKey.get(launch.getApp()),
                            "App does not exist");
                        continue;
                    }
                    String appPkgName = startIntent.getComponent().getPackageName();

                    if (launch.getLaunchReason().equals(IORAP_TRIAL_LAUNCH_FIRST)) {
                        // delete any iorap-traces associated with this package.
                        purgeIorapPackage(appPkgName);
                    }
                    dropCache(/*override*/true);  // iorap-trial runs must have drop cache.

                    AppLaunchResult launchResult =
                        startApp(launch.getApp(), launch.getLaunchReason());
                    if (launchResult.mLaunchTime < 0) {
                        addLaunchResult(launch, new AppLaunchResult());
                        // simply pass the app if launch isn't successful
                        // error should have already been logged by startApp
                        continue;
                    }
                    // wait for slightly more than 5s (iorapd.perfetto.trace_duration_ms) for the trace buffers to complete.
                    sleep(IORAP_TRACE_DURATION_TIMEOUT);

                    if (launch.getLaunchReason().equals(IORAP_TRIAL_LAUNCH_LAST)) {
                        // run the iorap compiler and wait for iorap to compile fully.
                        // this throws an exception if it fails.
                        compileAppForIorapWithRetries(appPkgName, IORAP_COMPILE_RETRIES);
                    }
                }

                // App launch times used for final calculation
                else if (launch.getLaunchReason().contains(LAUNCH_ITERATION_PREFIX)) {
                    mIterationCycle = true;
                    AppLaunchResult launchResults = null;
                    if (hasFailureOnFirstLaunch(launch)) {
                        // skip if the app has failures while launched first
                        Log.w(TAG, "Has failures on first launch: " + launch.getApp());
                        forceStopApp(launch.getApp());
                        continue;
                    }
                    AtraceLogger atraceLogger = null;
                    if (mTraceAll) {
                        Log.i(TAG, "Started tracing " + launch.getApp());
                        atraceLogger = AtraceLogger
                                .getAtraceLoggerInstance(getInstrumentation());
                    }
                    try {
                        // Start the trace
                        if (atraceLogger != null) {
                            atraceLogger.atraceStart(traceCategoriesSet, traceBufferSize,
                                    traceDumpInterval, rootTraceSubDir,
                                    String.format("%s-%s-%s", launch.getApp(),
                                            launch.getCompilerFilter(), launch.getLaunchReason()));
                        }
                        // In the "applaunch.txt" file app launches are referenced using
                        // "LAUNCH_ITERATION - ITERATION NUM"
                        launchResults = startApp(launch.getApp(), launch.getLaunchReason());
                        if (launchResults.mLaunchTime < 0) {
                            addLaunchResult(launch, new AppLaunchResult());
                            // if it fails once, skip the rest of the launches
                            continue;
                        } else {
                            mCycleTime += launchResults.mLaunchTime;
                            addLaunchResult(launch, launchResults);
                        }
                        sleep(POST_LAUNCH_IDLE_TIMEOUT);
                    } finally {
                        // Stop the trace
                        if (atraceLogger != null) {
                            Log.i(TAG, "Stopped tracing " + launch.getApp());
                            atraceLogger.atraceStop();
                        }
                    }

                }

                // App launch times for trace launch will not be used for final
                // launch time calculations.
                else if (launch.getLaunchReason().contains(TRACE_ITERATION_PREFIX)) {
                    mIterationCycle = false;
                    AtraceLogger atraceLogger = AtraceLogger
                            .getAtraceLoggerInstance(getInstrumentation());
                    // Start the trace
                    try {
                        atraceLogger.atraceStart(traceCategoriesSet, traceBufferSize,
                                traceDumpInterval, rootTraceSubDir,
                                String.format("%s-%s-%s", launch.getApp(),
                                        launch.getCompilerFilter(), launch.getLaunchReason()));
                        startApp(launch.getApp(), launch.getLaunchReason());
                        sleep(POST_LAUNCH_IDLE_TIMEOUT);
                    } finally {
                        // Stop the trace
                        atraceLogger.atraceStop();
                    }
                }
                if(mForceStopApp) {
                    sleep(BEFORE_FORCE_STOP_SLEEP_TIMEOUT);
                    forceStopApp(launch.getApp());
                    sleep(BEFORE_KILL_APP_SLEEP_TIMEOUT);
                    // Close again for good measure (just in case).
                    forceStopApp(launch.getApp());
                    // Kill the backgrounded process in the case forceStopApp only sent it to
                    // background.
                    killBackgroundApp(launch.getApp());
                } else {
                    startHomeIntent();
                }
                sleep(BETWEEN_LAUNCH_SLEEP_TIMEOUT);

                // If cycle clean up is enabled and last app launched is
                // current app then the cycle is completed and eligible for
                // cleanup.
                if (LAUNCH_ORDER_CYCLIC.equalsIgnoreCase(mLaunchOrder) && mCycleCleanUp
                        && launch.getApp().equalsIgnoreCase(mLastAppName)) {
                    // Kill all the apps and drop all the cache
                    cleanUpAfterCycle();
                    if (mIterationCycle) {
                        // Save the previous cycle time and reset the cycle time to 0
                        mCycleTimes.append(String.format("%d,", mCycleTime));
                        mCycleTime = 0;
                    }
                }
            }
        } finally {
            if (null != mBufferedWriter) {
                mBufferedWriter.close();
            }
        }

        if (mCycleTimes.length() != 0) {
                mResult.putString("Cycle_Times", mCycleTimes.toString());
        }
        for (String app : mNameToResultKey.keySet()) {
            for (String compilerFilter : mCompilerFilters) {
                StringBuilder launchTimes = new StringBuilder();
                StringBuilder cpuCycles = new StringBuilder();
                StringBuilder majorFaults = new StringBuilder();
                for (AppLaunchResult result : mNameToLaunchTime.get(app).get(compilerFilter)) {
                    launchTimes.append(result.mLaunchTime);
                    launchTimes.append(",");
                    if (mSimplePerfAppOnly) {
                        cpuCycles.append(result.mCpuCycles);
                        cpuCycles.append(",");
                        majorFaults.append(result.mMajorFaults);
                        majorFaults.append(",");
                    }
                }
                String filterName = (compilerFilter == null) ? "" : ("-" + compilerFilter);
                mResult.putString(mNameToResultKey.get(app) + filterName, launchTimes.toString());
                if (mSimplePerfAppOnly) {
                    mResult.putString(mNameToResultKey.get(app) + filterName + "-cpuCycles",
                        cpuCycles.toString());
                    mResult.putString(mNameToResultKey.get(app) + filterName + "-majorFaults",
                        majorFaults.toString());
                }
            }
        }
        instrumentation.sendStatus(0, mResult);
    }

    /**
     * Compile the app package using compilerFilter and return true or false
     * based on status of the compilation command.
     */
    private boolean compileApp(String compilerFilter, String appPkgName) throws IOException {
        try (ParcelFileDescriptor result = getInstrumentation().getUiAutomation().
                executeShellCommand(String.format(COMPILE_CMD, compilerFilter, appPkgName));
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                        new FileInputStream(result.getFileDescriptor())))) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                if (line.contains(COMPILE_SUCCESS)) {
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * Compile the app package using compilerFilter,
     * retrying if the compilation command fails in between.
     */
    private void compileAppForIorapWithRetries(String appPkgName, int retries) throws IOException {
        for (int i = 0; i < retries; ++i) {
            if (compileAppForIorap(appPkgName)) {
                return;
            }
            sleep(1000);
        }

        throw new IllegalStateException("compileAppForIorapWithRetries: timed out after "
                + retries + " retries");
    }

    /**
     * Compile the app package using compilerFilter and return true or false
     * based on status of the compilation command.
     */
    private boolean compileAppForIorap(String appPkgName) throws IOException {
        String logcatTimestamp = getTimeNowForLogcat();

        getInstrumentation().getUiAutomation().
                executeShellCommand(String.format(IORAP_COMPILE_CMD, appPkgName));

        int i = 0;
        for (i = 0; i < IORAP_COMPILE_CMD_TIMEOUT; ++i) {
            IorapCompilationStatus status = waitForIorapCompiled(appPkgName);
            if (status == IorapCompilationStatus.COMPLETE) {
                Log.v(TAG, "compileAppForIorap: success");
                logDumpsysIorapd(appPkgName);
                break;
            } else if (status == IorapCompilationStatus.INSUFFICIENT_TRACES) {
                Log.e(TAG, "compileAppForIorap: failed due to insufficient traces");
                logDumpsysIorapd(appPkgName);
                throw new IllegalStateException(
                        "compileAppForIorap: failed due to insufficient traces");
            } // else INCOMPLETE. keep asking iorapd if it's done yet.
            sleep(1000);
        }

        if (i == IORAP_COMPILE_CMD_TIMEOUT) {
            Log.e(TAG, "compileAppForIorap: failed due to timeout");
            logDumpsysIorapd(appPkgName);
            return false;
        }

        return true;
    }

    /** Save the contents of $(adb shell dumpsys iorapd) to the launch_logs directory. */
    private void logDumpsysIorapd(String packageName) throws IOException {
        InstrumentationTestRunner instrumentation =
                (InstrumentationTestRunner)getInstrumentation();
        Bundle args = instrumentation.getArguments();

        String launchDirectory = args.getString(KEY_LAUNCH_DIRECTORY);

        // Root directory for applaunch file to log the app launch output
        // Will be useful in case of simpleperf command is used
        File launchRootDir = null;
        if (null != launchDirectory && !launchDirectory.isEmpty()) {
            launchRootDir = new File(launchDirectory);
            if (!launchRootDir.exists() && !launchRootDir.mkdirs()) {
                throw new IOException("Unable to create the destination directory "
                    + launchRootDir + ". Try disabling selinux.");
            }
        } else {
            Log.w(TAG, "logDumpsysIorapd: Missing launch-directory arg");
            return;
        }

        File launchSubDir = new File(launchRootDir, LAUNCH_SUB_DIRECTORY);

        if (!launchSubDir.exists() && !launchSubDir.mkdirs()) {
            throw new IOException("Unable to create the lauch file sub directory "
                + launchSubDir + ". Try disabling selinux.");
        }
        String path = "iorapd_dumpsys_" + packageName + "_" + System.nanoTime() + ".txt";
        File file = new File(launchSubDir, path);
        try (FileOutputStream outputStream = new FileOutputStream(file);
                BufferedWriter writer = new BufferedWriter(
                        new OutputStreamWriter(outputStream));
                ParcelFileDescriptor result = getInstrumentation().getUiAutomation().
                        executeShellCommand(IORAP_DUMPSYS_CMD);
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                        new FileInputStream(result.getFileDescriptor())))) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                writer.write(line + "\n");
            }
        }

        Log.v(TAG, "logDumpsysIorapd: Saved to file: " + path);
    }

    enum IorapCompilationStatus {
        INCOMPLETE,
        COMPLETE,
        INSUFFICIENT_TRACES,
    }
    private IorapCompilationStatus waitForIorapCompiled(String appPkgName) throws IOException {
        try (ParcelFileDescriptor result = getInstrumentation().getUiAutomation().
                executeShellCommand(IORAP_DUMPSYS_CMD);
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                        new FileInputStream(result.getFileDescriptor())))) {
            String line;
            String prevLine = "";
            while ((line = bufferedReader.readLine()) != null) {
                // Match the indented VersionedComponentName string.
                // "  com.google.android.deskclock/com.android.deskclock.DeskClock@62000712"
                // Note: spaces are meaningful here.
                if (prevLine.contains("  " + appPkgName) && prevLine.contains("@")) {
                    // pre-requisite:
                    // Compiled Status: Raw traces pending compilation (3)
                    if (line.contains("Compiled Status: Usable compiled trace")) {
                        return IorapCompilationStatus.COMPLETE;
                    } else if (line.contains("Compiled Status: ") &&
                            line.contains("more traces for compilation")) {
                        //      Compiled Status: Need 1 more traces for compilation
                        // No amount of waiting will help here because there were
                        // insufficient traces made.
                        return IorapCompilationStatus.INSUFFICIENT_TRACES;
                    }
                }

                prevLine = line;
            }
            return IorapCompilationStatus.INCOMPLETE;
        }
    }

    private String makeReasonForIorapTrialLaunch(int launchCount) {
        String reason = IORAP_TRIAL_LAUNCH;
        if (launchCount == 0) {
            reason = IORAP_TRIAL_LAUNCH_FIRST;
        }
        if (launchCount == IORAP_TRIAL_LAUNCH_ITERATIONS - 1) {
            reason = IORAP_TRIAL_LAUNCH_LAST;
        }
        return reason;
    }

    private boolean shouldIncludeIorap(String compilerFilter) {
        if (!mIorapTrialLaunch) {
            return false;
        }

        // No iorap compiler filters specified: treat all compiler filters as ok.
        if (mIorapCompilerFilters == null) {
            return true;
        }

        // iorap compiler filters specified: the compilerFilter must be in the whitelist.
        if (mIorapCompilerFilters.indexOf(compilerFilter) != -1) {
            return true;
        }

        return false;
    }

    /**
     * If launch order is "cyclic" then apps will be launched one after the
     * other for each iteration count.
     * If launch order is "sequential" then each app will be launched for given number
     * iterations at once before launching the other apps.
     */
    private void setLaunchOrder() {
        if (LAUNCH_ORDER_CYCLIC.equalsIgnoreCase(mLaunchOrder)) {
            for (String compilerFilter : mCompilerFilters) {
                if (mTrialLaunch) {
                    for (String app : mNameToResultKey.keySet()) {
                        mLaunchOrderList.add(new LaunchOrder(app, compilerFilter, TRIAL_LAUNCH, /*iorapEnabled*/false));
                    }
                }
                if (shouldIncludeIorap(compilerFilter)) {
                    for (int launchCount = 0; launchCount < IORAP_TRIAL_LAUNCH_ITERATIONS; ++launchCount) {
                        for (String app : mNameToResultKey.keySet()) {
                            String reason = makeReasonForIorapTrialLaunch(launchCount);
                            mLaunchOrderList.add(
                                    new LaunchOrder(app, compilerFilter,
                                            reason,
                                            /*iorapEnabled*/true));
                        }
                    }
                }
                for (int launchCount = 0; launchCount < mLaunchIterations; launchCount++) {
                    for (String app : mNameToResultKey.keySet()) {
                        mLaunchOrderList.add(new LaunchOrder(app, compilerFilter,
                                  String.format(LAUNCH_ITERATION, launchCount),
                                        shouldIncludeIorap(compilerFilter)));
                    }
                }
                if (mTraceDirectoryStr != null && !mTraceDirectoryStr.isEmpty()) {
                    for (int traceCount = 0; traceCount < mTraceLaunchCount; traceCount++) {
                        for (String app : mNameToResultKey.keySet()) {
                            mLaunchOrderList.add(new LaunchOrder(app, compilerFilter,
                                      String.format(TRACE_ITERATION, traceCount),
                                            shouldIncludeIorap(compilerFilter)));
                        }
                    }
                }
            }
        } else if (LAUNCH_ORDER_SEQUENTIAL.equalsIgnoreCase(mLaunchOrder)) {
            for (String compilerFilter : mCompilerFilters) {
                for (String app : mNameToResultKey.keySet()) {
                    if (mTrialLaunch) {
                        mLaunchOrderList.add(new LaunchOrder(app, compilerFilter, TRIAL_LAUNCH, /*iorapEnabled*/false));
                    }
                    if (shouldIncludeIorap(compilerFilter)) {
                        for (int launchCount = 0; launchCount < IORAP_TRIAL_LAUNCH_ITERATIONS; ++launchCount) {
                            String reason = makeReasonForIorapTrialLaunch(launchCount);
                            mLaunchOrderList.add(
                                    new LaunchOrder(app, compilerFilter,
                                            reason,
                                            /*iorapEnabled*/true));
                        }
                    }
                    for (int launchCount = 0; launchCount < mLaunchIterations; launchCount++) {
                        mLaunchOrderList.add(new LaunchOrder(app, compilerFilter,
                                String.format(LAUNCH_ITERATION, launchCount),
                                        shouldIncludeIorap(compilerFilter)));
                    }
                    if (mTraceDirectoryStr != null && !mTraceDirectoryStr.isEmpty()) {
                        for (int traceCount = 0; traceCount < mTraceLaunchCount; traceCount++) {
                            mLaunchOrderList.add(new LaunchOrder(app, compilerFilter,
                                    String.format(TRACE_ITERATION, traceCount),
                                            shouldIncludeIorap(compilerFilter)));
                        }
                    }
                }
            }
        } else {
            assertTrue("Launch order is not valid parameter", false);
        }
    }

    private void dropCache(boolean override) {
        if (mDropCache || override) {
            assertNotNull("Issue in dropping the cache",
                    getInstrumentation().getUiAutomation()
                            .executeShellCommand(DROP_CACHE_SCRIPT));
        }
    }

    // [[ $(adb shell whoami) == "root" ]]
    private boolean checkIfRoot() throws IOException {
        String total = "";
        try (ParcelFileDescriptor result = getInstrumentation().getUiAutomation().
                executeShellCommand("whoami");
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                        new FileInputStream(result.getFileDescriptor())))) {
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                total = total + line;
            }
        }
        return total.contains("root");
    }

    private void stopIorapd() {
        getInstrumentation().getUiAutomation()
                .executeShellCommand("stop iorapd");
        sleep(100);  // give it extra time to fully stop.
    }

    private void startIorapd() {
        String logcatTimeNow = getTimeNowForLogcat();
        Log.v(TAG, "startIorapd, logcat time: " + logcatTimeNow);

        getInstrumentation().getUiAutomation()
                .executeShellCommand("start iorapd");

        int maxAttempts = 100;
        int attempt = 0;
        do {
            // Ensure that IorapForwardingService fully reconnects to iorapd before proceeding.
            String needle = "Connected to iorapd native service";
            String logcatLines = getLogcatSinceTime(logcatTimeNow);

            if (logcatLines.contains(needle)) {
                break;
            }

            sleep(1000);
            attempt++;
        } while (attempt < maxAttempts);

        if (attempt == maxAttempts) {
            Log.e(TAG, "Timed out after waiting for iorapd to start");
        }
        // Wait a little bit longer for iorapd to settle.
        sleep(1000);
    }

    // Delete all db rows and files associated with a package in iorapd.
    // Effectively deletes any raw or compiled trace files, unoptimizing the package in iorap.
    private void purgeIorapPackage(String packageName) {
        try {
            if (!checkIfRoot()) {
                throw new AssertionError("must be root to toggle iorapd; try adb root?");
            }
        } catch (IOException e) {
            throw new AssertionError(e);
        }

        Log.v(TAG, "Purge iorap package: " + packageName);
        getInstrumentation().getUiAutomation()
                .executeShellCommand(String.format(IORAP_MAINTENANCE_CMD, packageName));
        Log.v(TAG, "Executed: " + String.format(IORAP_MAINTENANCE_CMD, packageName));
    }

    String executeShellCommandWithTempFile(String cmd) {
        Log.v(TAG, "executeShellCommandWithTempFile, cmd: " + cmd);
        try {
            //File outputDir =
            //       InstrumentationRegistry.getInstrumentation().getContext().getCacheDir();
            File outputFile = File.createTempFile("exec_shell_command", ".sh");

            try {
                outputFile.setWritable(true);
                outputFile.setExecutable(true, /*ownersOnly*/false);

                String scriptPath = outputFile.toString();

                // If this works correctly, the next log-line will print 'Success'.
                try (BufferedWriter writer = new BufferedWriter(new FileWriter(scriptPath))) {
                    writer.write(cmd);
                }

                String resultString = "";
                try (ParcelFileDescriptor result = getInstrumentation().getUiAutomation().
                        executeShellCommand(scriptPath);
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                                new FileInputStream(result.getFileDescriptor())))) {
                    String line;
                    while ((line = bufferedReader.readLine()) != null) {
                        resultString += line + "\n";
                    }
                }

                return resultString;
            } finally {
                outputFile.delete();
            }
        } catch (IOException e) {
            throw new AssertionError("Failed to execute shell command: " + cmd, e);
        }
    }

    // Get the 'now' timestamp usable with $(adb logcat -v utc -T "time string")
    String getTimeNowForLogcat() {
        ZonedDateTime utc = ZonedDateTime.now(ZoneOffset.UTC);

        // YYYY-MM-DD hh:mm:ss.mmm
        return utc.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"));
    }

    String getLogcatSinceTime(String logcatTime) {
        // The time has spaces in it but must be passed as a single arg.
        // Therefore use a temp script file.
        return executeShellCommandWithTempFile(
                String.format("logcat -d -v threadtime -v utc -T '%s'", logcatTime));
    }

    /**
     * Toggle iorapd-based readahead and trace-collection.
     * If iorapd is already enabled and enable is true, does nothing.
     * If iorapd is already disabled and enable is false, does nothing.
     */
    private void toggleIorapStatus(boolean enable) {
        boolean currentlyEnabled = false;
        Log.v(TAG, "toggleIorapStatus " + Boolean.toString(enable));

        // Do nothing if we are already enabled or disabled.
        if (mIorapStatus == IorapStatus.ENABLED && enable) {
            return;
        } else if (mIorapStatus == IorapStatus.DISABLED && !enable) {
            return;
        }

        try {
            if (!checkIfRoot()) {
                throw new AssertionError("must be root to toggle iorapd; try adb root?");
            }
        } catch (IOException e) {
            throw new AssertionError(e);
        }

        getInstrumentation().getUiAutomation()
                .executeShellCommand(String.format("setprop iorapd.perfetto.enable %b", enable));
        getInstrumentation().getUiAutomation()
                .executeShellCommand(String.format("setprop iorapd.readahead.enable %b", enable));
        getInstrumentation().getUiAutomation()
                .executeShellCommand(String.format(
                        "setprop iorapd.maintenance.min_traces %d", IORAP_COMPILE_MIN_TRACES));
        // this last command blocks until iorapd refreshes its system properties
        getInstrumentation().getUiAutomation()
                .executeShellCommand(String.format("dumpsys iorapd --refresh-properties"));

        if (enable) {
            mIorapStatus = IorapStatus.ENABLED;
        } else {
            mIorapStatus = IorapStatus.DISABLED;
        }
    }

    private void parseArgs(Bundle args) {
        mNameToResultKey = new LinkedHashMap<String, String>();
        mNameToLaunchTime = new HashMap<>();
        String launchIterations = args.getString(KEY_LAUNCH_ITERATIONS);
        if (launchIterations != null) {
            mLaunchIterations = Integer.parseInt(launchIterations);
        }
        String forceStopApp = args.getString(KEY_FORCE_STOP_APP);

        if (forceStopApp != null) {
            mForceStopApp = Boolean.parseBoolean(forceStopApp);
        }

        String enableRecording = args.getString(ENABLE_SCREEN_RECORDING);

        if (enableRecording != null) {
            mEnableRecording = Boolean.parseBoolean(enableRecording);
        }
        String appList = args.getString(KEY_APPS);
        if (appList == null)
            return;

        String appNames[] = appList.split("\\|");
        for (String pair : appNames) {
            String[] parts = pair.split("\\^");
            if (parts.length != 2) {
                Log.e(TAG, "The apps key is incorrectly formatted");
                fail();
            }

            mNameToResultKey.put(parts[0], parts[1]);
            mNameToLaunchTime.put(parts[0], null);
            mLastAppName = parts[0];
        }
        String requiredAccounts = args.getString(KEY_REQUIRED_ACCOUNTS);
        if (requiredAccounts != null) {
            mRequiredAccounts = new HashSet<String>();
            for (String accountType : requiredAccounts.split(",")) {
                mRequiredAccounts.add(accountType);
            }
        }

        String compilerFilterList = args.getString(KEY_COMPILER_FILTERS);
        if (compilerFilterList != null) {
            // If a compiler filter is passed, we make a trial launch to force compilation
            // of the apps.
            mTrialLaunch = true;
            mCompilerFilters = compilerFilterList.split("\\|");
        } else {
            // Just pass a null compiler filter to use the current state of the app.
            mCompilerFilters = new String[1];
        }

        String iorapCompilerFilterList = args.getString(KEY_IORAP_COMPILER_FILTERS);
        if (iorapCompilerFilterList != null) {
            // Passing in iorap compiler filters implies an iorap trial launch.
            mIorapTrialLaunch = true;
            mIorapCompilerFilters = Arrays.asList(iorapCompilerFilterList.split("\\|"));
        }

        // Pre-populate the results map to avoid null checks.
        for (String app : mNameToLaunchTime.keySet()) {
            HashMap<String, List<AppLaunchResult>> map = new HashMap<>();
            mNameToLaunchTime.put(app, map);
            for (String compilerFilter : mCompilerFilters) {
                map.put(compilerFilter, new ArrayList<>());
            }
        }

        mTraceDirectoryStr = args.getString(KEY_TRACE_DIRECTORY);
        mDropCache = Boolean.parseBoolean(args.getString(KEY_DROP_CACHE));
        mSimplePerfCmd = args.getString(KEY_SIMPLEPERF_CMD);
        mLaunchOrder = args.getString(KEY_LAUNCH_ORDER, LAUNCH_ORDER_CYCLIC);
        mSimplePerfAppOnly = Boolean.parseBoolean(args.getString(KEY_SIMPLEPERF_APP));
        mCycleCleanUp = Boolean.parseBoolean(args.getString(KEY_CYCLE_CLEAN));
        mTraceAll = Boolean.parseBoolean(args.getString(KEY_TRACE_ALL));
        mTrialLaunch = mTrialLaunch || Boolean.parseBoolean(args.getString(KEY_TRIAL_LAUNCH));
        mIorapTrialLaunch = mIorapTrialLaunch ||
                Boolean.parseBoolean(args.getString(KEY_IORAP_TRIAL_LAUNCH));

        if (mSimplePerfCmd != null && mSimplePerfAppOnly) {
            Log.w(TAG, String.format("Passing both %s and %s is not supported, ignoring %s",
                KEY_SIMPLEPERF_CMD, KEY_SIMPLEPERF_APP, KEY_SIMPLEPERF_CMD));
        }
    }

    private boolean hasLeanback(Context context) {
        return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LEANBACK);
    }

    private void createMappings() {
        mNameToIntent = new LinkedHashMap<String, Intent>();

        PackageManager pm = getInstrumentation().getContext()
                .getPackageManager();
        Intent intentToResolve = new Intent(Intent.ACTION_MAIN);
        intentToResolve.addCategory(hasLeanback(getInstrumentation().getContext()) ?
                Intent.CATEGORY_LEANBACK_LAUNCHER :
                Intent.CATEGORY_LAUNCHER);
        List<ResolveInfo> ris = pm.queryIntentActivities(intentToResolve, 0);
        resolveLoop(ris, intentToResolve, pm);
        // For Wear
        intentToResolve = new Intent(WEARABLE_ACTION_GOOGLE);
        ris = pm.queryIntentActivities(intentToResolve, 0);
        resolveLoop(ris, intentToResolve, pm);
    }

    private void resolveLoop(List<ResolveInfo> ris, Intent intentToResolve, PackageManager pm) {
        if (ris == null || ris.isEmpty()) {
            Log.i(TAG, "Could not find any apps");
        } else {
            for (ResolveInfo ri : ris) {
                Intent startIntent = new Intent(intentToResolve);
                startIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                        | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
                startIntent.setClassName(ri.activityInfo.packageName,
                        ri.activityInfo.name);
                String appName = ri.loadLabel(pm).toString();
                if (appName != null) {
                    // Support launching intent using package name or app name
                    mNameToIntent.put(ri.activityInfo.packageName, startIntent);
                    mNameToIntent.put(appName, startIntent);
                }
            }
        }
    }

    private AppLaunchResult startApp(String appName, String launchReason)
            throws NameNotFoundException, RemoteException {
        Log.i(TAG, "Starting " + appName);
        if(mEnableRecording) {
            startRecording(appName, launchReason);
        }

        Intent startIntent = mNameToIntent.get(appName);
        if (startIntent == null) {
            Log.w(TAG, "App does not exist: " + appName);
            mResult.putString(mNameToResultKey.get(appName), "App does not exist");
            return new AppLaunchResult();
        }
        AppLaunchRunnable runnable = new AppLaunchRunnable(startIntent, launchReason);
        Thread t = new Thread(runnable);
        t.start();
        try {
            t.join(JOIN_TIMEOUT);
        } catch (InterruptedException e) {
            // ignore
        }

        if(mEnableRecording) {
            stopRecording();
        }
        return runnable.getResult();
    }

    private void checkAccountSignIn() {
        // ensure that the device has the required account types before starting test
        // e.g. device must have a valid Google account sign in to measure a meaningful launch time
        // for Gmail
        if (mRequiredAccounts == null || mRequiredAccounts.isEmpty()) {
            return;
        }
        final AccountManager am =
                (AccountManager) getInstrumentation().getTargetContext().getSystemService(
                        Context.ACCOUNT_SERVICE);
        Account[] accounts = am.getAccounts();
        // use set here in case device has multiple accounts of the same type
        Set<String> foundAccounts = new HashSet<String>();
        for (Account account : accounts) {
            if (mRequiredAccounts.contains(account.type)) {
                foundAccounts.add(account.type);
            }
        }
        // check if account type matches, if not, fail test with message on what account types
        // are missing
        if (mRequiredAccounts.size() != foundAccounts.size()) {
            mRequiredAccounts.removeAll(foundAccounts);
            StringBuilder sb = new StringBuilder("Device missing these accounts:");
            for (String account : mRequiredAccounts) {
                sb.append(' ');
                sb.append(account);
            }
            fail(sb.toString());
        }
    }

    private void startHomeIntent() {
        Intent homeIntent = new Intent(Intent.ACTION_MAIN);
        homeIntent.addCategory(Intent.CATEGORY_HOME);
        homeIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
        getInstrumentation().getContext().startActivity(homeIntent);
        sleep(POST_LAUNCH_IDLE_TIMEOUT);
    }

    private void cleanUpAfterCycle() {
        // Kill all the apps
        for (String appName : mNameToIntent.keySet()) {
            Log.w(TAG, String.format("killing %s", appName));
            forceStopApp(appName);
        }
        // Drop all the cache.
        assertNotNull("Issue in dropping the cache",
                getInstrumentation().getUiAutomation()
                        .executeShellCommand(DROP_CACHE_SCRIPT));
    }

    private void forceStopApp(String appName) {
        Intent startIntent = mNameToIntent.get(appName);
        if (startIntent != null) {
            String packageName = startIntent.getComponent().getPackageName();
            try {
                mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
            } catch (RemoteException e) {
                Log.w(TAG, "Error closing app", e);
            }
        }
    }

    private void killBackgroundApp(String appName) {
        Intent startIntent = mNameToIntent.get(appName);
        if (startIntent != null) {
            String packageName = startIntent.getComponent().getPackageName();
            try {
                mAm.killBackgroundProcesses(packageName, UserHandle.USER_CURRENT);
            } catch (RemoteException e) {
                Log.w(TAG, "Error closing app", e);
            }
        }
    }

    private void sleep(int time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            // ignore
        }
    }

    private void reportError(String appName, String processName) {
        ActivityManager am = (ActivityManager) getInstrumentation()
                .getContext().getSystemService(Context.ACTIVITY_SERVICE);
        List<ProcessErrorStateInfo> crashes = am.getProcessesInErrorState();
        if (crashes != null) {
            for (ProcessErrorStateInfo crash : crashes) {
                if (!crash.processName.equals(processName))
                    continue;

                Log.w(TAG, appName + " crashed: " + crash.shortMsg);
                mResult.putString(mNameToResultKey.get(appName), crash.shortMsg);
                return;
            }
        }

        mResult.putString(mNameToResultKey.get(appName),
                "Crashed for unknown reason");
        Log.w(TAG, appName
                + " not found in process list, most likely it is crashed");
    }

    private class LaunchOrder {
        private String mApp;
        private String mCompilerFilter;
        private String mLaunchReason;
        private boolean mIorapEnabled;

        LaunchOrder(String app, String compilerFilter, String launchReason, boolean iorapEnabled) {
            mApp = app;
            mCompilerFilter = compilerFilter;
            mLaunchReason = launchReason;
            mIorapEnabled = iorapEnabled;
        }

        public String getApp() {
            return mApp;
        }

        public void setApp(String app) {
            mApp = app;
        }

        public String getCompilerFilter() {
            return mCompilerFilter;
        }

        public String getLaunchReason() {
            return mLaunchReason;
        }

        public void setLaunchReason(String launchReason) {
            mLaunchReason = launchReason;
        }

        public void setIorapEnabled(boolean iorapEnabled) {
            mIorapEnabled = iorapEnabled;
        }

        public boolean getIorapEnabled() {
            return mIorapEnabled;
        }
    }

    private class AppLaunchResult {
        long mLaunchTime;
        long mCpuCycles;
        long mMajorFaults;

        AppLaunchResult() {
            mLaunchTime = -1L;
            mCpuCycles = -1L;
            mMajorFaults = -1L;
        }

        AppLaunchResult(String launchTime, String cpuCycles, String majorFaults) {
            try {
                mLaunchTime = Long.parseLong(launchTime, 10);
                mCpuCycles = Long.parseLong(cpuCycles, 10);
                mMajorFaults = Long.parseLong(majorFaults, 10);
            } catch (NumberFormatException e) {
                Log.e(TAG, "Error parsing result", e);
            }
        }
    }

    private class AppLaunchRunnable implements Runnable {
        private Intent mLaunchIntent;
        private AppLaunchResult mLaunchResult;
        private String mLaunchReason;

        public AppLaunchRunnable(Intent intent, String launchReason) {
            mLaunchIntent = intent;
            mLaunchReason = launchReason;
            mLaunchResult = new AppLaunchResult();
        }

        public AppLaunchResult getResult() {
            return mLaunchResult;
        }

        public void run() {
            File launchFile = null;
            try {
                String packageName = mLaunchIntent.getComponent().getPackageName();
                String componentName = mLaunchIntent.getComponent().flattenToShortString();
                if (mForceStopApp) {
                    mAm.forceStopPackage(packageName, UserHandle.USER_CURRENT);
                }
                String launchCmd = String.format("%s %s", APP_LAUNCH_CMD, componentName);
                if (mSimplePerfAppOnly) {
                    try {
                        // executeShellCommand cannot handle shell specific actions, like '&'.
                        // Therefore, we create a file containing the command and make that
                        // the command to launch.
                        launchFile = File.createTempFile(LAUNCH_SCRIPT_NAME, ".sh");
                        launchFile.setExecutable(true);
                        try (FileOutputStream stream = new FileOutputStream(launchFile);
                             BufferedWriter writer =
                                new BufferedWriter(new OutputStreamWriter(stream))) {
                            String cmd = String.format(SIMPLEPERF_APP_CMD, packageName, launchCmd);
                            // In the file, we need to escape any "$".
                            cmd = cmd.replace("$", "\\$");
                            writer.write(cmd);
                        }
                        launchCmd = launchFile.getAbsolutePath();
                    } catch (IOException e) {
                        Log.w(TAG, "Error writing the launch command", e);
                        return;
                    }
                } else if (null != mSimplePerfCmd) {
                    launchCmd = String.format("%s %s", mSimplePerfCmd, launchCmd);
                }
                Log.v(TAG, "Final launch cmd:" + launchCmd);
                ParcelFileDescriptor parcelDesc = getInstrumentation().getUiAutomation()
                        .executeShellCommand(launchCmd);
                mLaunchResult = parseLaunchTimeAndWrite(parcelDesc, String.format
                        ("App Launch :%s %s", componentName, mLaunchReason));
            } catch (RemoteException e) {
                Log.w(TAG, "Error launching app", e);
            } finally {
                if (launchFile != null) {
                    launchFile.delete();
                }
            }
        }

        /**
         * Method to parse the launch time info and write the result to file
         *
         * @param parcelDesc
         * @return
         */
        private AppLaunchResult parseLaunchTimeAndWrite(ParcelFileDescriptor parcelDesc,
                String headerInfo) {
            String launchTime = "-1";
            String cpuCycles = "-1";
            String majorFaults = "-1";
            boolean launchSuccess = false;
            try {
                InputStream inputStream = new FileInputStream(parcelDesc.getFileDescriptor());
                /* SAMPLE OUTPUT : Cold launch
                Starting: Intent { cmp=com.google.android.calculator/com.android.calculator2.Calculator }
                Status: ok
                LaunchState: COLD
                Activity: com.google.android.calculator/com.android.calculator2.Calculator
                TotalTime: 357
                WaitTime: 377
                Complete*/
                /* SAMPLE OUTPUT : Hot launch
                Starting: Intent { cmp=com.google.android.calculator/com.android.calculator2.Calculator }
                Warning: Activity not started, its current task has been brought to the front
                Status: ok
                LaunchState: HOT
                Activity: com.google.android.calculator/com.android.calculator2.CalculatorGoogle
                TotalTime: 60
                WaitTime: 67
                Complete*/
                /* WITH SIMPLEPERF :
                Performance counter statistics,
                6595722690,cpu-cycles,4.511040,GHz,(100%),
                0,major-faults,0.000,/sec,(100%),
                Total test time,1.462129,seconds,*/
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(
                        inputStream));
                String line;
                mBufferedWriter.newLine();
                mBufferedWriter.write(headerInfo);
                mBufferedWriter.newLine();
                while ((line = bufferedReader.readLine()) != null) {
                    mBufferedWriter.write(line);
                    mBufferedWriter.newLine();
                    if (line.startsWith(SUCCESS_MESSAGE)) {
                        launchSuccess = true;
                    }
                    if (!launchSuccess) {
                        continue;
                    }
                    // Parse TotalTime which is the launch time
                    if (line.startsWith(TOTAL_TIME_MESSAGE)) {
                        String launchSplit[] = line.split(":");
                        launchTime = launchSplit[1].trim();
                    }

                    if (mSimplePerfAppOnly) {
                        if (line.contains(",cpu-cycles,")) {
                            cpuCycles = line.split(",")[0].trim();
                        } else if (line.contains(",major-faults,")) {
                            majorFaults = line.split(",")[0].trim();
                        }
                    }
                }
                mBufferedWriter.flush();
                inputStream.close();
            } catch (IOException e) {
                Log.w(TAG, "Error parsing launch time and writing to file", e);
            }
            return new AppLaunchResult(launchTime, cpuCycles, majorFaults);
        }

    }

    /**
     * Start the screen recording while launching the app.
     *
     * @param appName
     * @param launchReason
     */
    private void startRecording(String appName, String launchReason) {
        Log.v(TAG, "Started Recording");
        mCurrentThread = new RecordingThread("test-screen-record",
                String.format("%s_%s", appName, launchReason));
        mCurrentThread.start();
    }

    /**
     * Stop already started screen recording.
     */
    private void stopRecording() {
        // Skip if not directory.
        if (launchSubDir == null) {
            return;
        }

        // Add some extra time to the video end.
        SystemClock.sleep(VIDEO_TAIL_BUFFER);
        // Ctrl + C all screen record processes.
        mCurrentThread.cancel();
        // Wait for the thread to completely die.
        try {
            mCurrentThread.join();
        } catch (InterruptedException ex) {
            Log.e(TAG, "Interrupted when joining the recording thread.", ex);
        }
        Log.v(TAG, "Stopped Recording");
    }

    /** Returns the recording's name for part {@code part} of launch description. */
    private File getOutputFile(String description, int part) {
        // Omit the iteration number for the first iteration.
        final String fileName =
                String.format(
                        "%s-video%s.mp4", description, part == 1 ? "" : part);
        return Paths.get(launchSubDir.getAbsolutePath(), description).toFile();
    }


    /**
     * Encapsulates the start and stop screen recording logic.
     * Copied from ScreenRecordCollector.
     */
    private class RecordingThread extends Thread {
        private final String mDescription;
        private final List<File> mRecordings;

        private boolean mContinue;

        public RecordingThread(String name, String description) {
            super(name);

            mContinue = true;
            mRecordings = new ArrayList<>();

            assertNotNull("No test description provided for recording.", description);
            mDescription = description;
        }

        @Override
        public void run() {
            try {
                // Start at i = 1 to encode parts as X.mp4, X2.mp4, X3.mp4, etc.
                for (int i = 1; i <= MAX_RECORDING_PARTS && mContinue; i++) {
                    File output = getOutputFile(mDescription, i);
                    Log.d(
                            TAG,
                            String.format("Recording screen to %s", output.getAbsolutePath()));
                    mRecordings.add(output);
                    // Make sure not to block on this background command in the main thread so
                    // that the test continues to run, but block in this thread so it does not
                    // trigger a new screen recording session before the prior one completes.
                    getDevice().executeShellCommand(
                                    String.format("screenrecord %s", output.getAbsolutePath()));
                }
            } catch (IOException e) {
                throw new RuntimeException("Caught exception while screen recording.");
            }
        }

        public void cancel() {
            mContinue = false;

            // Identify the screenrecord PIDs and send SIGINT 2 (Ctrl + C) to each.
            try {
                String[] pids = getDevice().executeShellCommand(
                        "pidof screenrecord").split(" ");
                for (String pid : pids) {
                    // Avoid empty process ids, because of weird splitting behavior.
                    if (pid.isEmpty()) {
                        continue;
                    }

                    getDevice().executeShellCommand(
                            String.format("kill -2 %s", pid));
                    Log.d(
                            TAG,
                            String.format("Sent SIGINT 2 to screenrecord process (%s)", pid));
                }
            } catch (IOException e) {
                throw new RuntimeException("Failed to kill screen recording process.");
            }
        }

        public List<File> getRecordings() {
            return mRecordings;
        }
    }

    public UiDevice getDevice() {
        if (mDevice == null) {
            mDevice = UiDevice.getInstance(getInstrumentation());
        }
        return mDevice;
    }
}