From ca7a1abe785ec3a6529c79218ccec2cc44a48228 Mon Sep 17 00:00:00 2001
From: jummp01 <jumana.mp@arm.com>
Date: Tue, 31 Jan 2017 17:50:04 +0000
Subject: [PATCH] Add new applaunch workload.

The workload supports launch time measurement of other uxperf workloads that
implement the ApplicationlaunchInterface. It takes a uxperf workload as a parameter
and helps to instrument the application launch time in two modes.

a)launch_from_background
b)launch_from_long_idle

The workload executes in two major phases.
1- Setup phase: clears initial dialogues on the first launch of an application.
2- Run phase: Runs multiple iterations of the application launch and measures
the time taken for launch. Iteration number can be specified as parameter applaunch_iterations.

Applaunch measurements are captured in the logcat file.
---
 wlauto/workloads/applaunch/__init__.py        | 169 ++++++++++++++
 .../com.arm.wlauto.uiauto.applaunch.jar       | Bin 0 -> 14149 bytes
 wlauto/workloads/applaunch/uiauto/build.sh    |  39 ++++
 wlauto/workloads/applaunch/uiauto/build.xml   |  92 ++++++++
 .../applaunch/uiauto/project.properties       |  14 ++
 .../com/arm/wlauto/uiauto/UiAutomation.java   | 220 ++++++++++++++++++
 6 files changed, 534 insertions(+)
 create mode 100644 wlauto/workloads/applaunch/__init__.py
 create mode 100644 wlauto/workloads/applaunch/com.arm.wlauto.uiauto.applaunch.jar
 create mode 100755 wlauto/workloads/applaunch/uiauto/build.sh
 create mode 100644 wlauto/workloads/applaunch/uiauto/build.xml
 create mode 100644 wlauto/workloads/applaunch/uiauto/project.properties
 create mode 100755 wlauto/workloads/applaunch/uiauto/src/com/arm/wlauto/uiauto/UiAutomation.java

diff --git a/wlauto/workloads/applaunch/__init__.py b/wlauto/workloads/applaunch/__init__.py
new file mode 100644
index 00000000..19fcac96
--- /dev/null
+++ b/wlauto/workloads/applaunch/__init__.py
@@ -0,0 +1,169 @@
+#    Copyright 2015 ARM Limited
+#
+# 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.
+#
+# pylint: disable=attribute-defined-outside-init
+import os
+
+from time import sleep
+
+from wlauto import Workload, AndroidBenchmark, AndroidUxPerfWorkload, UiAutomatorWorkload
+from wlauto import Parameter
+from wlauto import ExtensionLoader
+from wlauto import File
+from wlauto import settings
+from wlauto.exceptions import ConfigError
+from wlauto.exceptions import ResourceError
+from wlauto.utils.android import ApkInfo
+from wlauto.utils.uxperf import UxPerfParser
+
+import wlauto.common.android.resources
+
+
+class Applaunch(AndroidUxPerfWorkload):
+
+    name = 'applaunch'
+    description = '''
+    This workload launches and measures the launch time of applications for supporting workloads.
+    
+    Currently supported workloads are the ones that implement ``ApplaunchInterface``. For any
+    workload to support this workload, it should implement the ``ApplaunchInterface``.
+    The corresponding java file of the workload associated with the application being measured
+    is executed during the run. The application that needs to be
+    measured is passed as a parametre ``workload_name``. The parameters required for that workload
+    have to be passed as a dictionary which is captured by the parametre ``workload_params``.
+    This information can be obtained by inspecting the workload details of the specific workload.
+
+    The workload allows to run multiple iterations of an application
+    launch in two modes:
+
+    1. Launch from background
+    2. Launch from long-idle
+
+    These modes are captured as a parameter applaunch_type.
+
+    ``launch_from_background``
+        Launches an application after the application is sent to background by
+        pressing Home button.
+
+    ``launch_from_long-idle``
+        Launches an application after killing an application process and
+        clearing all the caches.
+
+    **Test Description:**
+
+    -   During the initialization and setup, the application being launched is launched 
+        for the first time. The jar file of the workload of the application
+        is moved to device at the location ``workdir`` which further implements the methods
+        needed to measure the application launch time.
+
+    -   Run phase calls the UiAutomator of the applaunch which runs in two subphases.
+            A.  Applaunch Setup Run:
+                    During this phase, welcome screens and dialogues during the first launch
+                    of the instrumented application are cleared.
+            B.  Applaunch Metric Run:
+                    During this phase, the application is launched multiple times determined by
+                    the iteration number specified by the parametre ``applaunch_iterations``.
+                    Each of these iterations are instrumented to capture the launch time taken
+                    and the values are recorded as UXPERF marker values in logfile.
+    '''
+    supported_platforms = ['android']
+
+    parameters = [
+        Parameter('workload_name', kind=str,
+                  description='Name of the uxperf workload to launch',
+                  default='gmail'),
+        Parameter('workload_params', kind=dict, default={},
+                  description="""
+                  parameters of the uxperf workload whose application launch
+                  time is measured
+                  """),
+        Parameter('applaunch_type', kind=str, default='launch_from_background',
+                  allowed_values=['launch_from_background', 'launch_from_long-idle'],
+                  description="""
+                  Choose launch_from_long-idle for measuring launch time
+                  from long-idle. These two types are described in the class
+                  description.
+                  """),
+        Parameter('applaunch_iterations', kind=int, default=1,
+                  description="""
+                  Number of iterations of the application launch
+                  """),
+        Parameter('report_results', kind=bool, default=True,
+                  description="""
+                  Choose to report results of the application launch time.
+                  """),
+    ]
+
+    def __init__(self, device, **kwargs):
+        super(Applaunch, self).__init__(device, **kwargs)
+
+    def init_resources(self, context):
+        super(Applaunch, self).init_resources(context)
+        loader = ExtensionLoader(packages=settings.extension_packages, paths=settings.extension_paths)
+        self.workload_params['markers_enabled'] = True
+        self.workload = loader.get_workload(self.workload_name, self.device,
+                                            **self.workload_params)
+        self.init_workload_resources(context)
+
+    def init_workload_resources(self, context):
+        self.workload.uiauto_file = context.resolver.get(wlauto.common.android.resources.JarFile(self.workload))
+        if not self.workload.uiauto_file:
+            raise ResourceError('No UI automation JAR file found for workload {}.'.format(self.workload.name))
+        self.workload.device_uiauto_file = self.device.path.join(self.device.working_directory, os.path.basename(self.workload.uiauto_file))
+        if not self.workload.uiauto_package:
+            self.workload.uiauto_package = os.path.splitext(os.path.basename(self.workload.uiauto_file))[0]
+
+    def validate(self):
+        super(Applaunch, self).validate()
+        self.workload.validate()
+        self.pass_parameters()
+
+    def pass_parameters(self):
+        self.uiauto_params['workload'] = self.workload.name
+        self.uiauto_params['package'] = self.workload.package
+        self.uiauto_params['binaries_directory'] = self.device.binaries_directory
+        self.uiauto_params.update(self.workload.uiauto_params)
+        if self.workload.activity:
+            self.uiauto_params['launch_activity'] = self.workload.activity
+        else:
+            self.uiauto_params['launch_activity'] = "None"
+        self.uiauto_params['applaunch_type'] = self.applaunch_type
+        self.uiauto_params['applaunch_iterations'] = self.applaunch_iterations
+
+    def setup(self, context):
+        AndroidBenchmark.setup(self.workload, context)
+        if not self.workload.launch_main:
+            self.workload.launch_app()
+        UiAutomatorWorkload.setup(self, context)
+        self.workload.device.push_file(self.workload.uiauto_file, self.workload.device_uiauto_file)
+
+    def run(self, context):
+        UiAutomatorWorkload.run(self, context)
+
+    def update_result(self, context):
+        super(Applaunch, self).update_result(context)
+        if self.report_results:
+            parser = UxPerfParser(context, prefix='applaunch_')
+            logfile = os.path.join(context.output_directory, 'logcat.log')
+            parser.parse(logfile)
+            parser.add_action_timings()
+
+    def teardown(self, context):
+        super(Applaunch, self).teardown(context)
+        AndroidBenchmark.teardown(self.workload, context)
+        UiAutomatorWorkload.teardown(self.workload, context)
+        #Workload uses Dexclass loader while loading the jar file of the instrumented workload.
+        #Dexclassloader unzips and generates .dex file in the .jar directory during the run.
+        device_uiauto_dex_file = self.workload.device_uiauto_file.replace(".jar", ".dex")
+        self.workload.device.delete_file(self.device.path.join(self.device.binaries_directory, device_uiauto_dex_file))
diff --git a/wlauto/workloads/applaunch/com.arm.wlauto.uiauto.applaunch.jar b/wlauto/workloads/applaunch/com.arm.wlauto.uiauto.applaunch.jar
new file mode 100644
index 0000000000000000000000000000000000000000..c10edd6fd0b011f3b0e0a105fa6a2e52a5747d09
GIT binary patch
literal 14149
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
Y;Y_Bf@&@%koyf0G%WE0H|DW3b0#m0TY5)KL

literal 0
HcmV?d00001

diff --git a/wlauto/workloads/applaunch/uiauto/build.sh b/wlauto/workloads/applaunch/uiauto/build.sh
new file mode 100755
index 00000000..1c5233c5
--- /dev/null
+++ b/wlauto/workloads/applaunch/uiauto/build.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+
+# CD into build dir if possible - allows building from any directory
+script_path='.'
+if `readlink -f $0 &>/dev/null`; then
+    script_path=`readlink -f $0 2>/dev/null`
+fi
+script_dir=`dirname $script_path`
+cd $script_dir
+
+# Ensure build.xml exists before starting
+if [[ ! -f build.xml ]]; then
+    echo 'Ant build.xml file not found! Check that you are in the right directory.'
+    exit 9
+fi
+
+# Copy base classes from wlauto dist
+class_dir=bin/classes/com/arm/wlauto/uiauto
+base_classes=`python -c "import os, wlauto; print os.path.join(os.path.dirname(wlauto.__file__), 'common', 'android', '*.class')"`
+mkdir -p $class_dir
+cp $base_classes $class_dir
+
+# Build and return appropriate exit code if failed
+ant build
+exit_code=$?
+if [[ $exit_code -ne 0 ]]; then
+    echo "ERROR: 'ant build' exited with code $exit_code"
+    exit $exit_code
+fi
+
+# If successful move JAR file to workload folder (overwrite previous)
+package=com.arm.wlauto.uiauto.applaunch.jar
+rm -f ../$package
+if [[ -f bin/$package ]]; then
+    cp bin/$package ..
+else
+    echo 'ERROR: UiAutomator JAR could not be found!'
+    exit 9
+fi
diff --git a/wlauto/workloads/applaunch/uiauto/build.xml b/wlauto/workloads/applaunch/uiauto/build.xml
new file mode 100644
index 00000000..b4e76972
--- /dev/null
+++ b/wlauto/workloads/applaunch/uiauto/build.xml
@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="com.arm.wlauto.uiauto.applaunch" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contains the path to the SDK. It should *NOT* be checked into
+         Version Control Systems. -->
+    <property file="local.properties" />
+
+    <!-- The ant.properties file can be created by you. It is only edited by the
+         'android' tool to add properties to it.
+         This is the place to change some Ant specific build properties.
+         Here are some properties you may want to change/update:
+
+         source.dir
+             The name of the source directory. Default is 'src'.
+         out.dir
+             The name of the output directory. Default is 'bin'.
+
+         For other overridable properties, look at the beginning of the rules
+         files in the SDK, at tools/ant/build.xml
+
+         Properties related to the SDK location or the project target should
+         be updated using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems.
+
+         -->
+    <property file="ant.properties" />
+
+    <!-- if sdk.dir was not set from one of the property file, then
+         get it from the ANDROID_HOME env var.
+         This must be done before we load project.properties since
+         the proguard config can use sdk.dir -->
+    <property environment="env" />
+    <condition property="sdk.dir" value="${env.ANDROID_HOME}">
+        <isset property="env.ANDROID_HOME" />
+    </condition>
+
+    <!-- The project.properties file is created and updated by the 'android'
+         tool, as well as ADT.
+
+         This contains project specific properties such as project target, and library
+         dependencies. Lower level build properties are stored in ant.properties
+         (or in .classpath for Eclipse projects).
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems. -->
+    <loadproperties srcFile="project.properties" />
+
+    <!-- quick check on sdk.dir -->
+    <fail
+            message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable."
+            unless="sdk.dir"
+    />
+
+    <!--
+        Import per project custom build rules if present at the root of the project.
+        This is the place to put custom intermediary targets such as:
+            -pre-build
+            -pre-compile
+            -post-compile (This is typically used for code obfuscation.
+                           Compiled code location: ${out.classes.absolute.dir}
+                           If this is not done in place, override ${out.dex.input.absolute.dir})
+            -post-package
+            -post-build
+            -pre-clean
+    -->
+    <import file="custom_rules.xml" optional="true" />
+
+    <!-- Import the actual build file.
+
+         To customize existing targets, there are two options:
+         - Customize only one target:
+             - copy/paste the target into this file, *before* the
+               <import> task.
+             - customize it to your needs.
+         - Customize the whole content of build.xml
+             - copy/paste the content of the rules files (minus the top node)
+               into this file, replacing the <import> task.
+             - customize to your needs.
+
+         ***********************
+         ****** IMPORTANT ******
+         ***********************
+         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+         in order to avoid having your file be overridden by tools such as "android update project"
+    -->
+    <!-- version-tag: VERSION_TAG -->
+    <import file="${sdk.dir}/tools/ant/uibuild.xml" />
+
+</project>
diff --git a/wlauto/workloads/applaunch/uiauto/project.properties b/wlauto/workloads/applaunch/uiauto/project.properties
new file mode 100644
index 00000000..ce39f2d0
--- /dev/null
+++ b/wlauto/workloads/applaunch/uiauto/project.properties
@@ -0,0 +1,14 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+# Project target.
+target=android-18
diff --git a/wlauto/workloads/applaunch/uiauto/src/com/arm/wlauto/uiauto/UiAutomation.java b/wlauto/workloads/applaunch/uiauto/src/com/arm/wlauto/uiauto/UiAutomation.java
new file mode 100755
index 00000000..b0e9f80f
--- /dev/null
+++ b/wlauto/workloads/applaunch/uiauto/src/com/arm/wlauto/uiauto/UiAutomation.java
@@ -0,0 +1,220 @@
+/*    Copyright 2014-2016 ARM Limited
+ *
+ * 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.arm.wlauto.uiauto.applaunch;
+
+import android.os.Bundle;
+import android.util.Log;
+
+// Import the uiautomator libraries
+import com.android.uiautomator.core.UiObject;
+import com.android.uiautomator.core.UiObjectNotFoundException;
+import com.android.uiautomator.core.UiSelector;
+
+import com.arm.wlauto.uiauto.ApplaunchInterface;
+import com.arm.wlauto.uiauto.UxPerfUiAutomation;
+
+import static com.arm.wlauto.uiauto.BaseUiAutomation.FindByCriteria.BY_ID;
+import static com.arm.wlauto.uiauto.BaseUiAutomation.FindByCriteria.BY_TEXT;
+import static com.arm.wlauto.uiauto.BaseUiAutomation.FindByCriteria.BY_DESC;
+
+import java.util.concurrent.TimeUnit;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Map.Entry;
+import dalvik.system.DexClassLoader;
+import java.lang.reflect.Method;
+
+
+public class UiAutomation extends UxPerfUiAutomation {
+
+    /** 
+     * Uiobject that marks the end of launch of an application, which is workload
+     * specific and added in the workload Java file by a method called getLaunchEndObject().
+     */
+    public UiObject launchEndObject;
+    /** Timeout to wait for application launch to finish. */
+    private Integer launch_timeout = 10;
+    public String applaunchType;
+    public String applaunchIterations;
+    public String activityName;
+    public ApplaunchInterface launch_workload;
+
+    /** Uiautomator function called by the applaunch workload. */
+    public void runUiAutomation() throws Exception{
+        parameters = getParams();
+
+        // Get workload jar file parameters
+        String workload = parameters.getString("workload");
+        String binariesDirectory = parameters.getString("binaries_directory");
+        String workloadJarPath = parameters.getString("workdir");
+        String workloadJarName = String.format("com.arm.wlauto.uiauto.%1s.jar",workload);
+        String workloadJarFile = String.format("%1s/%2s",workloadJarPath, workloadJarName);
+
+        // Load the jar file
+        File jarFile = new File(workloadJarFile);
+        if(!jarFile.exists()) {
+            throw new Exception(String.format("Jar file not found: %s", workloadJarFile));
+        }
+        DexClassLoader classloader = new DexClassLoader(jarFile.toURI().toURL().toString(),
+                                     binariesDirectory, null, ClassLoader.getSystemClassLoader());
+        Class uiautomation = null;
+        Object uiautomation_interface = null;
+        String workloadClass = String.format("com.arm.wlauto.uiauto.%1s.UiAutomation",workload);
+        try {
+            uiautomation = classloader.loadClass(workloadClass);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        Log.d("Class loaded:", uiautomation.getCanonicalName());
+        uiautomation_interface = uiautomation.newInstance();
+
+        // Create an Application Interface object from the workload
+        launch_workload = ((ApplaunchInterface)uiautomation_interface);
+
+        // Get parameters for application launch
+        getPackageParameters();
+        applaunchType = parameters.getString("applaunch_type");
+        applaunchIterations = parameters.getString("applaunch_iterations");
+        activityName = parameters.getString("launch_activity");
+
+        // Run the workload for application launch initialization
+        runApplaunchSetup();
+
+        // Run the workload for application launch measurement
+        for (int iteration = 0; iteration < Integer.parseInt(applaunchIterations); iteration++) {
+            Log.d("Applaunch iteration number: ", applaunchIterations);
+            sleep(20);//sleep for a while before next iteration
+            killBackground();
+            runApplaunchIteration(iteration);
+            closeApplication();
+        }
+    }
+
+    /**
+     * Setup run for applaunch workload that clears the initial
+     * run dialogues on launching an application package.
+     */
+    public void runApplaunchSetup() throws Exception{
+        setScreenOrientation(ScreenOrientation.NATURAL);
+        launch_workload.setWorkloadParameters(parameters);
+        launch_workload.runApplicationInitialization();
+        launchEndObject = launch_workload.getLaunchEndObject();
+        unsetScreenOrientation();
+        closeApplication();
+    }
+
+    /**
+     * This method performs multiple iterations of application launch and
+     * records the time taken for each iteration.
+     */
+    public void runApplaunchIteration(Integer iteration_count) throws Exception{
+        String testTag = "applaunch" + iteration_count;
+        String launchCommand = launch_workload.getLaunchCommand();
+        AppLaunch applaunch = new AppLaunch(testTag, launchCommand);
+        applaunch.startLaunch();//Launch the application and start timer
+        applaunch.endLaunch();//marks the end of launch and stops timer
+    }
+
+    /*
+     * AppLaunch class implements methods that facilitates launching applications
+     * from the uiautomator. It has methods that are used for one complete iteration of application
+     * launch instrumentation.
+     * ActionLogger class is instantiated within the class for measuring applaunch time.
+     * startLaunch(): Marks the beginning of the application launch, starts Timer
+     * endLaunch(): Marks the end of application, ends Timer
+     * launchMain(): Starts the application launch process and validates the finish of launch.
+    */
+    private class AppLaunch {
+
+        private String testTag;
+        private String launchCommand;
+        private ActionLogger logger;
+        Process launch_p;
+
+        public AppLaunch(String testTag, String launchCommand) {
+            this.testTag = testTag;
+            this.launchCommand = launchCommand;
+            this.logger = new ActionLogger(testTag, parameters);
+        }
+
+        // Called by launchMain() to check if app launch is successful
+        public void launchValidate(Process launch_p) throws Exception {
+            launch_p.waitFor();
+            Integer exit_val = launch_p.exitValue();
+            if (exit_val != 0) {
+                throw new Exception("Application could not be launched");
+            }
+        }
+
+        // Marks the end of application launch of the workload.
+        public void endLaunch() throws Exception{
+            waitObject(launchEndObject, launch_timeout);
+            logger.stop();
+            launch_p.destroy();
+        }
+
+        // Launches the application.
+        public void launchMain() throws Exception{
+            launch_p = Runtime.getRuntime().exec(launchCommand);
+
+            launchValidate(launch_p);
+        }
+
+        // Beginning of application launch
+        public void startLaunch() throws Exception{
+            logger.start();
+            launchMain();
+        }
+    }
+
+    // Exits the application according to application launch type.
+    public void closeApplication() throws Exception{
+        if(applaunchType.equals("launch_from_background")) {
+            pressHome();
+        }
+        else if(applaunchType.equals("launch_from_long-idle")) {
+            killApplication();
+            dropCaches();
+        }
+    }
+
+    // Kills the application process
+    public void killApplication() throws Exception{
+        Process kill_p;
+        kill_p = Runtime.getRuntime().exec(String.format("am force-stop %s", packageName));
+        kill_p.waitFor();
+        kill_p.destroy();
+    }
+
+    // Kills the background processes
+    public void killBackground() throws Exception{
+        Process kill_p;
+        kill_p = Runtime.getRuntime().exec("am kill-all");
+        kill_p.waitFor();
+        kill_p.destroy();
+    }
+
+    // Drop the caches
+    public void dropCaches() throws Exception{
+        Process drop_cache;
+        drop_cache = Runtime.getRuntime().exec("su sync; su echo 3 > /proc/sys/vm/drop_caches");
+        drop_cache.waitFor();
+        drop_cache.destroy();
+    }
+}