tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/RollbackTestUtils.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2018 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.rollback;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.fail;

 import android.app.ActivityManager;
 import android.app.AlarmManager;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageInstaller;
 import android.content.pm.PackageManager;
 import android.content.pm.VersionedPackage;
 import android.content.rollback.PackageRollbackInfo;
 import android.content.rollback.RollbackInfo;
 import android.content.rollback.RollbackManager;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.util.Log;

 import androidx.test.InstrumentationRegistry;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.SynchronousQueue;

 /**
  * Utilities to facilitate testing rollbacks.
  */
 class RollbackTestUtils {

     private static final String TAG = "RollbackTest";

     static RollbackManager getRollbackManager() {
         Context context = InstrumentationRegistry.getContext();
         RollbackManager rm = (RollbackManager) context.getSystemService(Context.ROLLBACK_SERVICE);
         if (rm == null) {
             throw new AssertionError("Failed to get RollbackManager");
         }
         return rm;
     }

     private static void setTime(long millis) {
         Context context = InstrumentationRegistry.getContext();
         AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
         am.setTime(millis);
     }

     static void forwardTimeBy(long offsetMillis) {
         setTime(System.currentTimeMillis() + offsetMillis);
         Log.i(TAG, "Forwarded time on device by " + offsetMillis + " millis");
     }

     /**
      * Returns the version of the given package installed on device.
      * Returns -1 if the package is not currently installed.
      */
     static long getInstalledVersion(String packageName) {
         PackageInfo pi = getPackageInfo(packageName);
         if (pi == null) {
             return -1;
         } else {
             return pi.getLongVersionCode();
         }
     }

     private static boolean isSystemAppWithoutUpdate(String packageName) {
         PackageInfo pi = getPackageInfo(packageName);
         if (pi == null) {
             return false;
         } else {
             return ((pi.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)
                     && ((pi.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 0);
         }
     }

     private static PackageInfo getPackageInfo(String packageName) {
         Context context = InstrumentationRegistry.getContext();
         PackageManager pm = context.getPackageManager();
         try {
             return pm.getPackageInfo(packageName, PackageManager.MATCH_APEX);
         } catch (PackageManager.NameNotFoundException e) {
             return null;
         }
     }

     private static void assertStatusSuccess(Intent result) {
         int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
                 PackageInstaller.STATUS_FAILURE);
         if (status == -1) {
             throw new AssertionError("PENDING USER ACTION");
         } else if (status > 0) {
             String message = result.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE);
             throw new AssertionError(message == null ? "UNKNOWN FAILURE" : message);
         }
     }

     /**
      * Uninstalls the given package.
      * Does nothing if the package is not installed.
      * @throws AssertionError if package can't be uninstalled.
      */
     static void uninstall(String packageName) throws InterruptedException, IOException {
         // No need to uninstall if the package isn't installed or is installed on /system.
         if (getInstalledVersion(packageName) == -1 || isSystemAppWithoutUpdate(packageName)) {
             return;
         }

         Context context = InstrumentationRegistry.getContext();
         PackageManager packageManager = context.getPackageManager();
         PackageInstaller packageInstaller = packageManager.getPackageInstaller();
         packageInstaller.uninstall(packageName, LocalIntentSender.getIntentSender());
         assertStatusSuccess(LocalIntentSender.getIntentSenderResult());
     }

     /**
      * Commit the given rollback.
      * @throws AssertionError if the rollback fails.
      */
     static void rollback(int rollbackId, VersionedPackage... causePackages)
             throws InterruptedException {
         RollbackManager rm = getRollbackManager();
         rm.commitRollback(rollbackId, Arrays.asList(causePackages),
                 LocalIntentSender.getIntentSender());
         Intent result = LocalIntentSender.getIntentSenderResult();
         int status = result.getIntExtra(RollbackManager.EXTRA_STATUS,
                 RollbackManager.STATUS_FAILURE);
         if (status != RollbackManager.STATUS_SUCCESS) {
             String message = result.getStringExtra(RollbackManager.EXTRA_STATUS_MESSAGE);
             throw new AssertionError(message);
         }
     }

     /**
      * Installs the apk with the given name.
      *
      * @param resourceName name of class loader resource for the apk to
      *        install.
      * @param enableRollback if rollback should be enabled.
      * @throws AssertionError if the installation fails.
      */
     static void install(String resourceName, boolean enableRollback)
             throws InterruptedException, IOException {
         installSplit(enableRollback, resourceName);
     }

     /**
      * Installs the apk with the given name and its splits.
      *
      * @param enableRollback if rollback should be enabled.
      * @param resourceNames names of class loader resources for the apk and
      *        its splits to install.
      * @throws AssertionError if the installation fails.
      */
     static void installSplit(boolean enableRollback, String... resourceNames)
             throws InterruptedException, IOException {
         Context context = InstrumentationRegistry.getContext();
         PackageInstaller.Session session = null;
         PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();
         PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
                 PackageInstaller.SessionParams.MODE_FULL_INSTALL);
         params.setEnableRollback(enableRollback);
         int sessionId = packageInstaller.createSession(params);
         session = packageInstaller.openSession(sessionId);

         ClassLoader loader = RollbackTest.class.getClassLoader();
         for (String resourceName : resourceNames) {
             try (OutputStream packageInSession = session.openWrite(resourceName, 0, -1);
                     InputStream is = loader.getResourceAsStream(resourceName);) {
                 byte[] buffer = new byte[4096];
                 int n;
                 while ((n = is.read(buffer)) >= 0) {
                     packageInSession.write(buffer, 0, n);
                 }
             }
         }

         // Commit the session (this will start the installation workflow).
         session.commit(LocalIntentSender.getIntentSender());
         assertStatusSuccess(LocalIntentSender.getIntentSenderResult());
     }

     /** Launches {@code packageName} with {@link Intent#ACTION_MAIN}. */
     private static void launchPackage(String packageName)
             throws InterruptedException, IOException {
         Context context = InstrumentationRegistry.getContext();
         Intent intent = new Intent(Intent.ACTION_MAIN);
         intent.setPackage(packageName);
         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         intent.addCategory(Intent.CATEGORY_LAUNCHER);
         context.startActivity(intent);
     }

     /**
      * Installs the APKs or APEXs with the given resource names as an atomic
      * set. A resource is assumed to be an APEX if it has the .apex extension.
      * <p>
      * In case of staged installs, this function will return succesfully after
      * the staged install has been committed and is ready for the device to
      * reboot.
      *
      * @param staged if the rollback should be staged.
      * @param enableRollback if rollback should be enabled.
      * @param resourceNames names of the class loader resource for the apks to
      *        install.
      * @throws AssertionError if the installation fails.
      */
     private static void install(boolean staged, boolean enableRollback,
             String... resourceNames) throws InterruptedException, IOException {
         Context context = InstrumentationRegistry.getContext();
         PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();

         PackageInstaller.SessionParams multiPackageParams = new PackageInstaller.SessionParams(
                 PackageInstaller.SessionParams.MODE_FULL_INSTALL);
         multiPackageParams.setMultiPackage();
         if (staged) {
             multiPackageParams.setStaged();
         }
         // TODO: Do we set this on the parent params, the child params, or
         // both?
         multiPackageParams.setEnableRollback(enableRollback);
         int multiPackageId = packageInstaller.createSession(multiPackageParams);
         PackageInstaller.Session multiPackage = packageInstaller.openSession(multiPackageId);

         for (String resourceName : resourceNames) {
             PackageInstaller.Session session = null;
             PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
                     PackageInstaller.SessionParams.MODE_FULL_INSTALL);
             if (staged) {
                 params.setStaged();
             }
             if (resourceName.endsWith(".apex")) {
                 params.setInstallAsApex();
             }
             params.setEnableRollback(enableRollback);
             int sessionId = packageInstaller.createSession(params);
             session = packageInstaller.openSession(sessionId);

             ClassLoader loader = RollbackTest.class.getClassLoader();
             try (OutputStream packageInSession = session.openWrite(resourceName, 0, -1);
                  InputStream is = loader.getResourceAsStream(resourceName);) {
                 byte[] buffer = new byte[4096];
                 int n;
                 while ((n = is.read(buffer)) >= 0) {
                     packageInSession.write(buffer, 0, n);
                 }
             }
             multiPackage.addChildSessionId(sessionId);
         }

         // Commit the session (this will start the installation workflow).
         multiPackage.commit(LocalIntentSender.getIntentSender());
         assertStatusSuccess(LocalIntentSender.getIntentSenderResult());

         if (staged) {
             waitForSessionReady(multiPackageId);
         }
     }

     /**
      * Installs the apks with the given resource names as an atomic set.
      *
      * @param enableRollback if rollback should be enabled.
      * @param resourceNames names of the class loader resource for the apks to
      *        install.
      * @throws AssertionError if the installation fails.
      */
     static void installMultiPackage(boolean enableRollback, String... resourceNames)
             throws InterruptedException, IOException {
         install(false, enableRollback, resourceNames);
     }

     /**
      * Installs the APKs or APEXs with the given resource names as a staged
      * atomic set. A resource is assumed to be an APEX if it has the .apex
      * extension.
      *
      * @param enableRollback if rollback should be enabled.
      * @param resourceNames names of the class loader resource for the apks to
      *        install.
      * @throws AssertionError if the installation fails.
      */
     static void installStaged(boolean enableRollback, String... resourceNames)
             throws InterruptedException, IOException {
         install(true, enableRollback, resourceNames);
     }

     static void adoptShellPermissionIdentity(String... permissions) {
         InstrumentationRegistry
             .getInstrumentation()
             .getUiAutomation()
             .adoptShellPermissionIdentity(permissions);
     }

     static void dropShellPermissionIdentity() {
         InstrumentationRegistry
             .getInstrumentation()
             .getUiAutomation()
             .dropShellPermissionIdentity();
     }

     /**
      * Returns the RollbackInfo with a given package in the list of rollbacks.
      * Throws an assertion failure if there is more than one such rollback
      * info. Returns null if there are no such rollback infos.
      */
     static RollbackInfo getUniqueRollbackInfoForPackage(List<RollbackInfo> rollbacks,
             String packageName) {
         RollbackInfo found = null;
         for (RollbackInfo rollback : rollbacks) {
             for (PackageRollbackInfo info : rollback.getPackages()) {
                 if (packageName.equals(info.getPackageName())) {
                     assertNull(found);
                     found = rollback;
                     break;
                 }
             }
         }
         return found;
     }

     /**
      * Asserts that the given PackageRollbackInfo has the expected package
      * name and versions.
      */
     static void assertPackageRollbackInfoEquals(String packageName,
             long versionRolledBackFrom, long versionRolledBackTo,
             PackageRollbackInfo info) {
         assertEquals(packageName, info.getPackageName());
         assertEquals(packageName, info.getVersionRolledBackFrom().getPackageName());
         assertEquals(versionRolledBackFrom, info.getVersionRolledBackFrom().getLongVersionCode());
         assertEquals(packageName, info.getVersionRolledBackTo().getPackageName());
         assertEquals(versionRolledBackTo, info.getVersionRolledBackTo().getLongVersionCode());
     }

     /**
      * Asserts that the given RollbackInfo has the given packages with expected
      * package names and all are rolled to and from the same given versions.
      */
     static void assertRollbackInfoEquals(String[] packageNames,
             long versionRolledBackFrom, long versionRolledBackTo,
             RollbackInfo info, VersionedPackage... causePackages) {
         assertNotNull(info);
         assertEquals(packageNames.length, info.getPackages().size());
         int foundPackages = 0;
         for (String packageName : packageNames) {
             for (PackageRollbackInfo pkgRollbackInfo : info.getPackages()) {
                 if (packageName.equals(pkgRollbackInfo.getPackageName())) {
                     foundPackages++;
                     assertPackageRollbackInfoEquals(packageName, versionRolledBackFrom,
                             versionRolledBackTo, pkgRollbackInfo);
                     break;
                 }
             }
         }
         assertEquals(packageNames.length, foundPackages);
         assertEquals(causePackages.length, info.getCausePackages().size());
         for (int i = 0; i < causePackages.length; ++i) {
             assertEquals(causePackages[i].getPackageName(),
                     info.getCausePackages().get(i).getPackageName());
             assertEquals(causePackages[i].getLongVersionCode(),
                     info.getCausePackages().get(i).getLongVersionCode());
         }
     }

     /**
      * Asserts that the given RollbackInfo has a single package with expected
      * package name and versions.
      */
     static void assertRollbackInfoEquals(String packageName,
             long versionRolledBackFrom, long versionRolledBackTo,
             RollbackInfo info, VersionedPackage... causePackages) {
         String[] packageNames = {packageName};
         assertRollbackInfoEquals(packageNames, versionRolledBackFrom, versionRolledBackTo, info,
                 causePackages);
     }

     /**
      * Waits for the given session to be marked as ready.
      * Throws an assertion if the session fails.
      */
     static void waitForSessionReady(int sessionId) {
         BlockingQueue<PackageInstaller.SessionInfo> sessionStatus = new LinkedBlockingQueue<>();
         BroadcastReceiver sessionUpdatedReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 PackageInstaller.SessionInfo info =
                         intent.getParcelableExtra(PackageInstaller.EXTRA_SESSION);
                 if (info != null && info.getSessionId() == sessionId) {
                     if (info.isStagedSessionReady() || info.isStagedSessionFailed()) {
                         try {
                             sessionStatus.put(info);
                         } catch (InterruptedException e) {
                             Log.e(TAG, "Failed to put session info.", e);
                         }
                     }
                 }
             }
         };
         IntentFilter sessionUpdatedFilter =
                 new IntentFilter(PackageInstaller.ACTION_SESSION_UPDATED);

         Context context = InstrumentationRegistry.getContext();
         context.registerReceiver(sessionUpdatedReceiver, sessionUpdatedFilter);

         PackageInstaller installer = context.getPackageManager().getPackageInstaller();
         PackageInstaller.SessionInfo info = installer.getSessionInfo(sessionId);

         try {
             if (info.isStagedSessionReady() || info.isStagedSessionFailed()) {
                 sessionStatus.put(info);
             }

             info = sessionStatus.take();
             context.unregisterReceiver(sessionUpdatedReceiver);
             if (info.isStagedSessionFailed()) {
                 throw new AssertionError(info.getStagedSessionErrorMessage());
             }
         } catch (InterruptedException e) {
             throw new AssertionError(e);
         }
     }

     private static final String NO_RESPONSE = "NO RESPONSE";

     /**
      * Calls into the test app to process user data.
      * Asserts if the user data could not be processed or was version
      * incompatible with the previously processed user data.
      */
     static void processUserData(String packageName) {
         Intent intent = new Intent();
         intent.setComponent(new ComponentName(packageName,
                     "com.android.tests.rollback.testapp.ProcessUserData"));
         Context context = InstrumentationRegistry.getContext();

         HandlerThread handlerThread = new HandlerThread("RollbackTestHandlerThread");
         handlerThread.start();

         // It can sometimes take a while after rollback before the app will
         // receive this broadcast, so try a few times in a loop.
         String result = NO_RESPONSE;
         for (int i = 0; result.equals(NO_RESPONSE) && i < 5; ++i) {
             BlockingQueue<String> resultQueue = new LinkedBlockingQueue<>();
             context.sendOrderedBroadcast(intent, null, new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     if (getResultCode() == 1) {
                         resultQueue.add("OK");
                     } else {
                         // If the test app doesn't receive the broadcast or
                         // fails to set the result data, then getResultData
                         // here returns the initial NO_RESPONSE data passed to
                         // the sendOrderedBroadcast call.
                         resultQueue.add(getResultData());
                     }
                 }
             }, new Handler(handlerThread.getLooper()), 0, NO_RESPONSE, null);

             try {
                 result = resultQueue.take();
             } catch (InterruptedException e) {
                 throw new AssertionError(e);
             }
         }

         handlerThread.quit();
         if (!"OK".equals(result)) {
             fail(result);
         }
     }

     /**
      * Return the rollback info for a recently committed rollback, by matching the rollback id, or
      * return null if no matching rollback is found.
      */
     static RollbackInfo getRecentlyCommittedRollbackInfoById(int getRollbackId) {
         for (RollbackInfo info : getRollbackManager().getRecentlyCommittedRollbacks()) {
             if (info.getRollbackId() == getRollbackId) {
                 return info;
             }
         }
         return null;
     }

     /**
      * Send broadcast to crash {@code packageName} {@code count} times. If {@code count} is at least
      * {@link PackageWatchdog#TRIGGER_FAILURE_COUNT}, watchdog crash detection will be triggered.
      */
     static BroadcastReceiver sendCrashBroadcast(Context context, String packageName, int count)
             throws InterruptedException, IOException {
         BlockingQueue<Integer> crashQueue = new SynchronousQueue<>();
         IntentFilter crashCountFilter = new IntentFilter();
         crashCountFilter.addAction("com.android.tests.rollback.CRASH");
         crashCountFilter.addCategory(Intent.CATEGORY_DEFAULT);

         BroadcastReceiver crashCountReceiver = new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     try {
                         // Sleep long enough for packagewatchdog to be notified of crash
                         Thread.sleep(1000);
                         // Kill app and close AppErrorDialog
                         ActivityManager am = context.getSystemService(ActivityManager.class);
                         am.killBackgroundProcesses(packageName);
                         // Allow another package launch
                         crashQueue.put(intent.getIntExtra("count", 0));
                     } catch (InterruptedException e) {
                         fail("Failed to communicate with test app");
                     }
                 }
             };
         context.registerReceiver(crashCountReceiver, crashCountFilter);

         do {
             launchPackage(packageName);
         } while(crashQueue.take() < count);
         return crashCountReceiver;
     }
 }
	/*
	* Copyright (C) 2018 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.rollback;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.fail;

	import android.app.ActivityManager;
	import android.app.AlarmManager;
	import android.content.BroadcastReceiver;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.pm.ApplicationInfo;
	import android.content.pm.PackageInfo;
	import android.content.pm.PackageInstaller;
	import android.content.pm.PackageManager;
	import android.content.pm.VersionedPackage;
	import android.content.rollback.PackageRollbackInfo;
	import android.content.rollback.RollbackInfo;
	import android.content.rollback.RollbackManager;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.util.Log;

	import androidx.test.InstrumentationRegistry;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.Arrays;
	import java.util.List;
	import java.util.concurrent.BlockingQueue;
	import java.util.concurrent.LinkedBlockingQueue;
	import java.util.concurrent.SynchronousQueue;

	/**
	* Utilities to facilitate testing rollbacks.
	*/
	class RollbackTestUtils {

	private static final String TAG = "RollbackTest";

	static RollbackManager getRollbackManager() {
	Context context = InstrumentationRegistry.getContext();
	RollbackManager rm = (RollbackManager) context.getSystemService(Context.ROLLBACK_SERVICE);
	if (rm == null) {
	throw new AssertionError("Failed to get RollbackManager");
	}
	return rm;
	}

	private static void setTime(long millis) {
	Context context = InstrumentationRegistry.getContext();
	AlarmManager am = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
	am.setTime(millis);
	}

	static void forwardTimeBy(long offsetMillis) {
	setTime(System.currentTimeMillis() + offsetMillis);
	Log.i(TAG, "Forwarded time on device by " + offsetMillis + " millis");
	}

	/**
	* Returns the version of the given package installed on device.
	* Returns -1 if the package is not currently installed.
	*/
	static long getInstalledVersion(String packageName) {
	PackageInfo pi = getPackageInfo(packageName);
	if (pi == null) {
	return -1;
	} else {
	return pi.getLongVersionCode();
	}
	}

	private static boolean isSystemAppWithoutUpdate(String packageName) {
	PackageInfo pi = getPackageInfo(packageName);
	if (pi == null) {
	return false;
	} else {
	return ((pi.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)
	&& ((pi.applicationInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) == 0);
	}
	}

	private static PackageInfo getPackageInfo(String packageName) {
	Context context = InstrumentationRegistry.getContext();
	PackageManager pm = context.getPackageManager();
	try {
	return pm.getPackageInfo(packageName, PackageManager.MATCH_APEX);
	} catch (PackageManager.NameNotFoundException e) {
	return null;
	}
	}

	private static void assertStatusSuccess(Intent result) {
	int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
	PackageInstaller.STATUS_FAILURE);
	if (status == -1) {
	throw new AssertionError("PENDING USER ACTION");
	} else if (status > 0) {
	String message = result.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE);
	throw new AssertionError(message == null ? "UNKNOWN FAILURE" : message);
	}
	}

	/**
	* Uninstalls the given package.
	* Does nothing if the package is not installed.
	* @throws AssertionError if package can't be uninstalled.
	*/
	static void uninstall(String packageName) throws InterruptedException, IOException {
	// No need to uninstall if the package isn't installed or is installed on /system.
	if (getInstalledVersion(packageName) == -1 \|\| isSystemAppWithoutUpdate(packageName)) {
	return;
	}

	Context context = InstrumentationRegistry.getContext();
	PackageManager packageManager = context.getPackageManager();
	PackageInstaller packageInstaller = packageManager.getPackageInstaller();
	packageInstaller.uninstall(packageName, LocalIntentSender.getIntentSender());
	assertStatusSuccess(LocalIntentSender.getIntentSenderResult());
	}

	/**
	* Commit the given rollback.
	* @throws AssertionError if the rollback fails.
	*/
	static void rollback(int rollbackId, VersionedPackage... causePackages)
	throws InterruptedException {
	RollbackManager rm = getRollbackManager();
	rm.commitRollback(rollbackId, Arrays.asList(causePackages),
	LocalIntentSender.getIntentSender());
	Intent result = LocalIntentSender.getIntentSenderResult();
	int status = result.getIntExtra(RollbackManager.EXTRA_STATUS,
	RollbackManager.STATUS_FAILURE);
	if (status != RollbackManager.STATUS_SUCCESS) {
	String message = result.getStringExtra(RollbackManager.EXTRA_STATUS_MESSAGE);
	throw new AssertionError(message);
	}
	}

	/**
	* Installs the apk with the given name.
	*
	* @param resourceName name of class loader resource for the apk to
	* install.
	* @param enableRollback if rollback should be enabled.
	* @throws AssertionError if the installation fails.
	*/
	static void install(String resourceName, boolean enableRollback)
	throws InterruptedException, IOException {
	installSplit(enableRollback, resourceName);
	}

	/**
	* Installs the apk with the given name and its splits.
	*
	* @param enableRollback if rollback should be enabled.
	* @param resourceNames names of class loader resources for the apk and
	* its splits to install.
	* @throws AssertionError if the installation fails.
	*/
	static void installSplit(boolean enableRollback, String... resourceNames)
	throws InterruptedException, IOException {
	Context context = InstrumentationRegistry.getContext();
	PackageInstaller.Session session = null;
	PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();
	PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
	PackageInstaller.SessionParams.MODE_FULL_INSTALL);
	params.setEnableRollback(enableRollback);
	int sessionId = packageInstaller.createSession(params);
	session = packageInstaller.openSession(sessionId);

	ClassLoader loader = RollbackTest.class.getClassLoader();
	for (String resourceName : resourceNames) {
	try (OutputStream packageInSession = session.openWrite(resourceName, 0, -1);
	InputStream is = loader.getResourceAsStream(resourceName);) {
	byte[] buffer = new byte[4096];
	int n;
	while ((n = is.read(buffer)) >= 0) {
	packageInSession.write(buffer, 0, n);
	}
	}
	}

	// Commit the session (this will start the installation workflow).
	session.commit(LocalIntentSender.getIntentSender());
	assertStatusSuccess(LocalIntentSender.getIntentSenderResult());
	}

	/** Launches {@code packageName} with {@link Intent#ACTION_MAIN}. */
	private static void launchPackage(String packageName)
	throws InterruptedException, IOException {
	Context context = InstrumentationRegistry.getContext();
	Intent intent = new Intent(Intent.ACTION_MAIN);
	intent.setPackage(packageName);
	intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
	intent.addCategory(Intent.CATEGORY_LAUNCHER);
	context.startActivity(intent);
	}

	/**
	* Installs the APKs or APEXs with the given resource names as an atomic
	* set. A resource is assumed to be an APEX if it has the .apex extension.
	* <p>
	* In case of staged installs, this function will return succesfully after
	* the staged install has been committed and is ready for the device to
	* reboot.
	*
	* @param staged if the rollback should be staged.
	* @param enableRollback if rollback should be enabled.
	* @param resourceNames names of the class loader resource for the apks to
	* install.
	* @throws AssertionError if the installation fails.
	*/
	private static void install(boolean staged, boolean enableRollback,
	String... resourceNames) throws InterruptedException, IOException {
	Context context = InstrumentationRegistry.getContext();
	PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();

	PackageInstaller.SessionParams multiPackageParams = new PackageInstaller.SessionParams(
	PackageInstaller.SessionParams.MODE_FULL_INSTALL);
	multiPackageParams.setMultiPackage();
	if (staged) {
	multiPackageParams.setStaged();
	}
	// TODO: Do we set this on the parent params, the child params, or
	// both?
	multiPackageParams.setEnableRollback(enableRollback);
	int multiPackageId = packageInstaller.createSession(multiPackageParams);
	PackageInstaller.Session multiPackage = packageInstaller.openSession(multiPackageId);

	for (String resourceName : resourceNames) {
	PackageInstaller.Session session = null;
	PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
	PackageInstaller.SessionParams.MODE_FULL_INSTALL);
	if (staged) {
	params.setStaged();
	}
	if (resourceName.endsWith(".apex")) {
	params.setInstallAsApex();
	}
	params.setEnableRollback(enableRollback);
	int sessionId = packageInstaller.createSession(params);
	session = packageInstaller.openSession(sessionId);

	ClassLoader loader = RollbackTest.class.getClassLoader();
	try (OutputStream packageInSession = session.openWrite(resourceName, 0, -1);
	InputStream is = loader.getResourceAsStream(resourceName);) {
	byte[] buffer = new byte[4096];
	int n;
	while ((n = is.read(buffer)) >= 0) {
	packageInSession.write(buffer, 0, n);
	}
	}
	multiPackage.addChildSessionId(sessionId);
	}

	// Commit the session (this will start the installation workflow).
	multiPackage.commit(LocalIntentSender.getIntentSender());
	assertStatusSuccess(LocalIntentSender.getIntentSenderResult());

	if (staged) {
	waitForSessionReady(multiPackageId);
	}
	}

	/**
	* Installs the apks with the given resource names as an atomic set.
	*
	* @param enableRollback if rollback should be enabled.
	* @param resourceNames names of the class loader resource for the apks to
	* install.
	* @throws AssertionError if the installation fails.
	*/
	static void installMultiPackage(boolean enableRollback, String... resourceNames)
	throws InterruptedException, IOException {
	install(false, enableRollback, resourceNames);
	}

	/**
	* Installs the APKs or APEXs with the given resource names as a staged
	* atomic set. A resource is assumed to be an APEX if it has the .apex
	* extension.
	*
	* @param enableRollback if rollback should be enabled.
	* @param resourceNames names of the class loader resource for the apks to
	* install.
	* @throws AssertionError if the installation fails.
	*/
	static void installStaged(boolean enableRollback, String... resourceNames)
	throws InterruptedException, IOException {
	install(true, enableRollback, resourceNames);
	}

	static void adoptShellPermissionIdentity(String... permissions) {
	InstrumentationRegistry
	.getInstrumentation()
	.getUiAutomation()
	.adoptShellPermissionIdentity(permissions);
	}

	static void dropShellPermissionIdentity() {
	InstrumentationRegistry
	.getInstrumentation()
	.getUiAutomation()
	.dropShellPermissionIdentity();
	}

	/**
	* Returns the RollbackInfo with a given package in the list of rollbacks.
	* Throws an assertion failure if there is more than one such rollback
	* info. Returns null if there are no such rollback infos.
	*/
	static RollbackInfo getUniqueRollbackInfoForPackage(List<RollbackInfo> rollbacks,
	String packageName) {
	RollbackInfo found = null;
	for (RollbackInfo rollback : rollbacks) {
	for (PackageRollbackInfo info : rollback.getPackages()) {
	if (packageName.equals(info.getPackageName())) {
	assertNull(found);
	found = rollback;
	break;
	}
	}
	}
	return found;
	}

	/**
	* Asserts that the given PackageRollbackInfo has the expected package
	* name and versions.
	*/
	static void assertPackageRollbackInfoEquals(String packageName,
	long versionRolledBackFrom, long versionRolledBackTo,
	PackageRollbackInfo info) {
	assertEquals(packageName, info.getPackageName());
	assertEquals(packageName, info.getVersionRolledBackFrom().getPackageName());
	assertEquals(versionRolledBackFrom, info.getVersionRolledBackFrom().getLongVersionCode());
	assertEquals(packageName, info.getVersionRolledBackTo().getPackageName());
	assertEquals(versionRolledBackTo, info.getVersionRolledBackTo().getLongVersionCode());
	}

	/**
	* Asserts that the given RollbackInfo has the given packages with expected
	* package names and all are rolled to and from the same given versions.
	*/
	static void assertRollbackInfoEquals(String[] packageNames,
	long versionRolledBackFrom, long versionRolledBackTo,
	RollbackInfo info, VersionedPackage... causePackages) {
	assertNotNull(info);
	assertEquals(packageNames.length, info.getPackages().size());
	int foundPackages = 0;
	for (String packageName : packageNames) {
	for (PackageRollbackInfo pkgRollbackInfo : info.getPackages()) {
	if (packageName.equals(pkgRollbackInfo.getPackageName())) {
	foundPackages++;
	assertPackageRollbackInfoEquals(packageName, versionRolledBackFrom,
	versionRolledBackTo, pkgRollbackInfo);
	break;
	}
	}
	}
	assertEquals(packageNames.length, foundPackages);
	assertEquals(causePackages.length, info.getCausePackages().size());
	for (int i = 0; i < causePackages.length; ++i) {
	assertEquals(causePackages[i].getPackageName(),
	info.getCausePackages().get(i).getPackageName());
	assertEquals(causePackages[i].getLongVersionCode(),
	info.getCausePackages().get(i).getLongVersionCode());
	}
	}

	/**
	* Asserts that the given RollbackInfo has a single package with expected
	* package name and versions.
	*/
	static void assertRollbackInfoEquals(String packageName,
	long versionRolledBackFrom, long versionRolledBackTo,
	RollbackInfo info, VersionedPackage... causePackages) {
	String[] packageNames = {packageName};
	assertRollbackInfoEquals(packageNames, versionRolledBackFrom, versionRolledBackTo, info,
	causePackages);
	}

	/**
	* Waits for the given session to be marked as ready.
	* Throws an assertion if the session fails.
	*/
	static void waitForSessionReady(int sessionId) {
	BlockingQueue<PackageInstaller.SessionInfo> sessionStatus = new LinkedBlockingQueue<>();
	BroadcastReceiver sessionUpdatedReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	PackageInstaller.SessionInfo info =
	intent.getParcelableExtra(PackageInstaller.EXTRA_SESSION);
	if (info != null && info.getSessionId() == sessionId) {
	if (info.isStagedSessionReady() \|\| info.isStagedSessionFailed()) {
	try {
	sessionStatus.put(info);
	} catch (InterruptedException e) {
	Log.e(TAG, "Failed to put session info.", e);
	}
	}
	}
	}
	};
	IntentFilter sessionUpdatedFilter =
	new IntentFilter(PackageInstaller.ACTION_SESSION_UPDATED);

	Context context = InstrumentationRegistry.getContext();
	context.registerReceiver(sessionUpdatedReceiver, sessionUpdatedFilter);

	PackageInstaller installer = context.getPackageManager().getPackageInstaller();
	PackageInstaller.SessionInfo info = installer.getSessionInfo(sessionId);

	try {
	if (info.isStagedSessionReady() \|\| info.isStagedSessionFailed()) {
	sessionStatus.put(info);
	}

	info = sessionStatus.take();
	context.unregisterReceiver(sessionUpdatedReceiver);
	if (info.isStagedSessionFailed()) {
	throw new AssertionError(info.getStagedSessionErrorMessage());
	}
	} catch (InterruptedException e) {
	throw new AssertionError(e);
	}
	}

	private static final String NO_RESPONSE = "NO RESPONSE";

	/**
	* Calls into the test app to process user data.
	* Asserts if the user data could not be processed or was version
	* incompatible with the previously processed user data.
	*/
	static void processUserData(String packageName) {
	Intent intent = new Intent();
	intent.setComponent(new ComponentName(packageName,
	"com.android.tests.rollback.testapp.ProcessUserData"));
	Context context = InstrumentationRegistry.getContext();

	HandlerThread handlerThread = new HandlerThread("RollbackTestHandlerThread");
	handlerThread.start();

	// It can sometimes take a while after rollback before the app will
	// receive this broadcast, so try a few times in a loop.
	String result = NO_RESPONSE;
	for (int i = 0; result.equals(NO_RESPONSE) && i < 5; ++i) {
	BlockingQueue<String> resultQueue = new LinkedBlockingQueue<>();
	context.sendOrderedBroadcast(intent, null, new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	if (getResultCode() == 1) {
	resultQueue.add("OK");
	} else {
	// If the test app doesn't receive the broadcast or
	// fails to set the result data, then getResultData
	// here returns the initial NO_RESPONSE data passed to
	// the sendOrderedBroadcast call.
	resultQueue.add(getResultData());
	}
	}
	}, new Handler(handlerThread.getLooper()), 0, NO_RESPONSE, null);

	try {
	result = resultQueue.take();
	} catch (InterruptedException e) {
	throw new AssertionError(e);
	}
	}

	handlerThread.quit();
	if (!"OK".equals(result)) {
	fail(result);
	}
	}

	/**
	* Return the rollback info for a recently committed rollback, by matching the rollback id, or
	* return null if no matching rollback is found.
	*/
	static RollbackInfo getRecentlyCommittedRollbackInfoById(int getRollbackId) {
	for (RollbackInfo info : getRollbackManager().getRecentlyCommittedRollbacks()) {
	if (info.getRollbackId() == getRollbackId) {
	return info;
	}
	}
	return null;
	}

	/**
	* Send broadcast to crash {@code packageName} {@code count} times. If {@code count} is at least
	* {@link PackageWatchdog#TRIGGER_FAILURE_COUNT}, watchdog crash detection will be triggered.
	*/
	static BroadcastReceiver sendCrashBroadcast(Context context, String packageName, int count)
	throws InterruptedException, IOException {
	BlockingQueue<Integer> crashQueue = new SynchronousQueue<>();
	IntentFilter crashCountFilter = new IntentFilter();
	crashCountFilter.addAction("com.android.tests.rollback.CRASH");
	crashCountFilter.addCategory(Intent.CATEGORY_DEFAULT);

	BroadcastReceiver crashCountReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	try {
	// Sleep long enough for packagewatchdog to be notified of crash
	Thread.sleep(1000);
	// Kill app and close AppErrorDialog
	ActivityManager am = context.getSystemService(ActivityManager.class);
	am.killBackgroundProcesses(packageName);
	// Allow another package launch
	crashQueue.put(intent.getIntExtra("count", 0));
	} catch (InterruptedException e) {
	fail("Failed to communicate with test app");
	}
	}
	};
	context.registerReceiver(crashCountReceiver, crashCountFilter);

	do {
	launchPackage(packageName);
	} while(crashQueue.take() < count);
	return crashCountReceiver;
	}
	}