services/core/java/com/android/server/testharness/TestHarnessModeService.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2019 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.server.testharness;

 import android.annotation.Nullable;
 import android.app.KeyguardManager;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.UserInfo;
 import android.os.BatteryManager;
 import android.os.Binder;
 import android.os.IBinder;
 import android.os.ResultReceiver;
 import android.os.ShellCallback;
 import android.os.ShellCommand;
 import android.os.SystemProperties;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.provider.Settings;
 import android.util.Slog;

 import com.android.server.LocalServices;
 import com.android.server.PersistentDataBlockManagerInternal;
 import com.android.server.SystemService;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.attribute.PosixFilePermission;
 import java.util.Set;

 /**
  * Manages the Test Harness Mode service for setting up test harness mode on the device.
  *
  * <p>Test Harness Mode is a feature that allows the user to clean their device, retain ADB keys,
  * and provision the device for Instrumentation testing. This means that all parts of the device
  * that would otherwise interfere with testing (auto-syncing accounts, package verification,
  * automatic updates, etc.) are all disabled by default but may be re-enabled by the user.
  */
 public class TestHarnessModeService extends SystemService {
     private static final String TAG = TestHarnessModeService.class.getSimpleName();
     private static final String TEST_HARNESS_MODE_PROPERTY = "persist.sys.test_harness";

     private PersistentDataBlockManagerInternal mPersistentDataBlockManagerInternal;
     private boolean mShouldSetUpTestHarnessMode;

     public TestHarnessModeService(Context context) {
         super(context);
     }

     @Override
     public void onStart() {
         publishBinderService("testharness", mService);
     }

     @Override
     public void onBootPhase(int phase) {
         switch (phase) {
             case PHASE_SYSTEM_SERVICES_READY:
                 setUpTestHarnessMode();
                 break;
             case PHASE_BOOT_COMPLETED:
                 disableAutoSync();
                 break;
         }
         super.onBootPhase(phase);
     }

     private void setUpTestHarnessMode() {
         Slog.d(TAG, "Setting up test harness mode");
         byte[] testHarnessModeData = getPersistentDataBlock().getTestHarnessModeData();
         if (testHarnessModeData == null || testHarnessModeData.length == 0) {
             // There's no data to apply, so leave it as-is.
             return;
         }
         mShouldSetUpTestHarnessMode = true;
         PersistentData persistentData = PersistentData.fromBytes(testHarnessModeData);

         SystemProperties.set(TEST_HARNESS_MODE_PROPERTY, persistentData.mEnabled ? "1" : "0");
         writeAdbKeysFile(persistentData);
         // Clear out the data block so that we don't revert the ADB keys on every boot.
         getPersistentDataBlock().clearTestHarnessModeData();

         ContentResolver cr = getContext().getContentResolver();
         if (Settings.Global.getInt(cr, Settings.Global.ADB_ENABLED, 0) == 0) {
             // Enable ADB
             Settings.Global.putInt(cr, Settings.Global.ADB_ENABLED, 1);
         } else {
             // ADB is already enabled, we should restart the service so it picks up the new keys
             android.os.SystemService.restart("adbd");
         }

         Settings.Global.putInt(cr, Settings.Global.PACKAGE_VERIFIER_ENABLE, 0);
         Settings.Global.putInt(
                 cr,
                 Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
                 BatteryManager.BATTERY_PLUGGED_ANY);
         Settings.Global.putInt(cr, Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE, 1);
         Settings.Global.putInt(cr, Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1);

         setDeviceProvisioned();
     }

     private void disableAutoSync() {
         if (!mShouldSetUpTestHarnessMode) {
             return;
         }
         UserInfo primaryUser = UserManager.get(getContext()).getPrimaryUser();
         ContentResolver
             .setMasterSyncAutomaticallyAsUser(false, primaryUser.getUserHandle().getIdentifier());
     }

     private void writeAdbKeysFile(PersistentData persistentData) {
         Path adbKeys = Paths.get("/data/misc/adb/adb_keys");
         try {
             OutputStream fileOutputStream = Files.newOutputStream(adbKeys);
             fileOutputStream.write(persistentData.mAdbKeys);
             fileOutputStream.close();

             Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(adbKeys);
             permissions.add(PosixFilePermission.GROUP_READ);
             Files.setPosixFilePermissions(adbKeys, permissions);
         } catch (IOException e) {
             Slog.e(TAG, "Failed to set up adb keys", e);
             // Note: if a device enters this block, it will remain UNAUTHORIZED in ADB, but all
             // other settings will be set up.
         }
     }

     // Setting the device as provisioned skips the setup wizard.
     private void setDeviceProvisioned() {
         ContentResolver cr = getContext().getContentResolver();
         Settings.Global.putInt(cr, Settings.Global.DEVICE_PROVISIONED, 1);
         Settings.Secure.putIntForUser(
                 cr,
                 Settings.Secure.USER_SETUP_COMPLETE,
                 1,
                 UserHandle.USER_CURRENT);
     }

     @Nullable
     private PersistentDataBlockManagerInternal getPersistentDataBlock() {
         if (mPersistentDataBlockManagerInternal == null) {
             Slog.d(TAG, "Getting PersistentDataBlockManagerInternal from LocalServices");
             mPersistentDataBlockManagerInternal =
                     LocalServices.getService(PersistentDataBlockManagerInternal.class);
         }
         return mPersistentDataBlockManagerInternal;
     }

     private final IBinder mService = new Binder() {
         @Override
         public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
                 String[] args, ShellCallback callback, ResultReceiver resultReceiver) {
             (new TestHarnessModeShellCommand())
                 .exec(this, in, out, err, args, callback, resultReceiver);
         }
     };

     private class TestHarnessModeShellCommand extends ShellCommand {
         @Override
         public int onCommand(String cmd) {
             switch (cmd) {
                 case "enable":
                 case "restore":
                     checkPermissions();
                     final long originalId = Binder.clearCallingIdentity();
                     try {
                         if (isDeviceSecure()) {
                             getErrPrintWriter().println(
                                     "Test Harness Mode cannot be enabled if there is a lock "
                                             + "screen");
                             return 2;
                         }
                         return handleEnable();
                     } finally {
                         Binder.restoreCallingIdentity(originalId);
                     }
                 default:
                     return handleDefaultCommands(cmd);
             }
         }

         private void checkPermissions() {
             getContext().enforceCallingPermission(
                     android.Manifest.permission.ENABLE_TEST_HARNESS_MODE,
                     "You must hold android.permission.ENABLE_TEST_HARNESS_MODE "
                             + "to enable Test Harness Mode");
         }

         private boolean isDeviceSecure() {
             UserInfo primaryUser = UserManager.get(getContext()).getPrimaryUser();
             KeyguardManager keyguardManager = getContext().getSystemService(KeyguardManager.class);
             return keyguardManager.isDeviceSecure(primaryUser.id);
         }

         private int handleEnable() {
             Path adbKeys = Paths.get("/data/misc/adb/adb_keys");
             if (!Files.exists(adbKeys)) {
                 // This should only be accessible on eng builds that haven't yet set up ADB keys
                 getErrPrintWriter()
                     .println("No ADB keys stored; not enabling test harness mode");
                 return 1;
             }

             try (InputStream inputStream = Files.newInputStream(adbKeys)) {
                 long size = Files.size(adbKeys);
                 byte[] adbKeysBytes = new byte[(int) size];
                 int numBytes = inputStream.read(adbKeysBytes);
                 if (numBytes != size) {
                     getErrPrintWriter().println("Failed to read all bytes of adb_keys");
                     return 1;
                 }
                 PersistentData persistentData = new PersistentData(true, adbKeysBytes);
                 getPersistentDataBlock().setTestHarnessModeData(persistentData.toBytes());
             } catch (IOException e) {
                 Slog.e(TAG, "Failed to store ADB keys.", e);
                 getErrPrintWriter().println("Failed to enable Test Harness Mode");
                 return 1;
             }

             Intent i = new Intent(Intent.ACTION_FACTORY_RESET);
             i.setPackage("android");
             i.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
             i.putExtra(Intent.EXTRA_REASON, TAG);
             i.putExtra(Intent.EXTRA_WIPE_EXTERNAL_STORAGE, true);
             getContext().sendBroadcastAsUser(i, UserHandle.SYSTEM);
             return 0;
         }

         @Override
         public void onHelp() {
             PrintWriter pw = getOutPrintWriter();
             pw.println("About:");
             pw.println("  Test Harness Mode is a mode that the device can be placed in to prepare");
             pw.println("  the device for running UI tests. The device is placed into this mode by");
             pw.println("  first wiping all data from the device, preserving ADB keys.");
             pw.println();
             pw.println("  By default, the following settings are configured:");
             pw.println("    * Package Verifier is disabled");
             pw.println("    * Stay Awake While Charging is enabled");
             pw.println("    * OTA Updates are disabled");
             pw.println("    * Auto-Sync for accounts is disabled");
             pw.println();
             pw.println("  Other apps may configure themselves differently in Test Harness Mode by");
             pw.println("  checking ActivityManager.isRunningInUserTestHarness()");
             pw.println();
             pw.println("Test Harness Mode commands:");
             pw.println("  help");
             pw.println("    Print this help text.");
             pw.println();
             pw.println("  enable|restore");
             pw.println("    Erase all data from this device and enable Test Harness Mode,");
             pw.println("    preserving the stored ADB keys currently on the device and toggling");
             pw.println("    settings in a way that are conducive to Instrumentation testing.");
         }
     }

     /**
      * The object that will serialize/deserialize the Test Harness Mode data to and from the
      * persistent data block.
      */
     public static class PersistentData {
         static final byte VERSION_1 = 1;

         final int mVersion;
         final boolean mEnabled;
         final byte[] mAdbKeys;

         PersistentData(boolean enabled, byte[] adbKeys) {
             this(VERSION_1, enabled, adbKeys);
         }

         PersistentData(int version, boolean enabled, byte[] adbKeys) {
             this.mVersion = version;
             this.mEnabled = enabled;
             this.mAdbKeys = adbKeys;
         }

         static PersistentData fromBytes(byte[] bytes) {
             try {
                 DataInputStream is = new DataInputStream(new ByteArrayInputStream(bytes));
                 int version = is.readInt();
                 boolean enabled = is.readBoolean();
                 int adbKeysLength = is.readInt();
                 byte[] adbKeys = new byte[adbKeysLength];
                 is.readFully(adbKeys);
                 return new PersistentData(version, enabled, adbKeys);
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         }

         byte[] toBytes() {
             try {
                 ByteArrayOutputStream os = new ByteArrayOutputStream();
                 DataOutputStream dos = new DataOutputStream(os);
                 dos.writeInt(VERSION_1);
                 dos.writeBoolean(mEnabled);
                 dos.writeInt(mAdbKeys.length);
                 dos.write(mAdbKeys);
                 dos.close();
                 return os.toByteArray();
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         }
     }
 }
	/*
	* Copyright (C) 2019 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.server.testharness;

	import android.annotation.Nullable;
	import android.app.KeyguardManager;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.UserInfo;
	import android.os.BatteryManager;
	import android.os.Binder;
	import android.os.IBinder;
	import android.os.ResultReceiver;
	import android.os.ShellCallback;
	import android.os.ShellCommand;
	import android.os.SystemProperties;
	import android.os.UserHandle;
	import android.os.UserManager;
	import android.provider.Settings;
	import android.util.Slog;

	import com.android.server.LocalServices;
	import com.android.server.PersistentDataBlockManagerInternal;
	import com.android.server.SystemService;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.FileDescriptor;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.PrintWriter;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.attribute.PosixFilePermission;
	import java.util.Set;

	/**
	* Manages the Test Harness Mode service for setting up test harness mode on the device.
	*
	* <p>Test Harness Mode is a feature that allows the user to clean their device, retain ADB keys,
	* and provision the device for Instrumentation testing. This means that all parts of the device
	* that would otherwise interfere with testing (auto-syncing accounts, package verification,
	* automatic updates, etc.) are all disabled by default but may be re-enabled by the user.
	*/
	public class TestHarnessModeService extends SystemService {
	private static final String TAG = TestHarnessModeService.class.getSimpleName();
	private static final String TEST_HARNESS_MODE_PROPERTY = "persist.sys.test_harness";

	private PersistentDataBlockManagerInternal mPersistentDataBlockManagerInternal;
	private boolean mShouldSetUpTestHarnessMode;

	public TestHarnessModeService(Context context) {
	super(context);
	}

	@Override
	public void onStart() {
	publishBinderService("testharness", mService);
	}

	@Override
	public void onBootPhase(int phase) {
	switch (phase) {
	case PHASE_SYSTEM_SERVICES_READY:
	setUpTestHarnessMode();
	break;
	case PHASE_BOOT_COMPLETED:
	disableAutoSync();
	break;
	}
	super.onBootPhase(phase);
	}

	private void setUpTestHarnessMode() {
	Slog.d(TAG, "Setting up test harness mode");
	byte[] testHarnessModeData = getPersistentDataBlock().getTestHarnessModeData();
	if (testHarnessModeData == null \|\| testHarnessModeData.length == 0) {
	// There's no data to apply, so leave it as-is.
	return;
	}
	mShouldSetUpTestHarnessMode = true;
	PersistentData persistentData = PersistentData.fromBytes(testHarnessModeData);

	SystemProperties.set(TEST_HARNESS_MODE_PROPERTY, persistentData.mEnabled ? "1" : "0");
	writeAdbKeysFile(persistentData);
	// Clear out the data block so that we don't revert the ADB keys on every boot.
	getPersistentDataBlock().clearTestHarnessModeData();

	ContentResolver cr = getContext().getContentResolver();
	if (Settings.Global.getInt(cr, Settings.Global.ADB_ENABLED, 0) == 0) {
	// Enable ADB
	Settings.Global.putInt(cr, Settings.Global.ADB_ENABLED, 1);
	} else {
	// ADB is already enabled, we should restart the service so it picks up the new keys
	android.os.SystemService.restart("adbd");
	}

	Settings.Global.putInt(cr, Settings.Global.PACKAGE_VERIFIER_ENABLE, 0);
	Settings.Global.putInt(
	cr,
	Settings.Global.STAY_ON_WHILE_PLUGGED_IN,
	BatteryManager.BATTERY_PLUGGED_ANY);
	Settings.Global.putInt(cr, Settings.Global.OTA_DISABLE_AUTOMATIC_UPDATE, 1);
	Settings.Global.putInt(cr, Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 1);

	setDeviceProvisioned();
	}

	private void disableAutoSync() {
	if (!mShouldSetUpTestHarnessMode) {
	return;
	}
	UserInfo primaryUser = UserManager.get(getContext()).getPrimaryUser();
	ContentResolver
	.setMasterSyncAutomaticallyAsUser(false, primaryUser.getUserHandle().getIdentifier());
	}

	private void writeAdbKeysFile(PersistentData persistentData) {
	Path adbKeys = Paths.get("/data/misc/adb/adb_keys");
	try {
	OutputStream fileOutputStream = Files.newOutputStream(adbKeys);
	fileOutputStream.write(persistentData.mAdbKeys);
	fileOutputStream.close();

	Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(adbKeys);
	permissions.add(PosixFilePermission.GROUP_READ);
	Files.setPosixFilePermissions(adbKeys, permissions);
	} catch (IOException e) {
	Slog.e(TAG, "Failed to set up adb keys", e);
	// Note: if a device enters this block, it will remain UNAUTHORIZED in ADB, but all
	// other settings will be set up.
	}
	}

	// Setting the device as provisioned skips the setup wizard.
	private void setDeviceProvisioned() {
	ContentResolver cr = getContext().getContentResolver();
	Settings.Global.putInt(cr, Settings.Global.DEVICE_PROVISIONED, 1);
	Settings.Secure.putIntForUser(
	cr,
	Settings.Secure.USER_SETUP_COMPLETE,
	1,
	UserHandle.USER_CURRENT);
	}

	@Nullable
	private PersistentDataBlockManagerInternal getPersistentDataBlock() {
	if (mPersistentDataBlockManagerInternal == null) {
	Slog.d(TAG, "Getting PersistentDataBlockManagerInternal from LocalServices");
	mPersistentDataBlockManagerInternal =
	LocalServices.getService(PersistentDataBlockManagerInternal.class);
	}
	return mPersistentDataBlockManagerInternal;
	}

	private final IBinder mService = new Binder() {
	@Override
	public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
	String[] args, ShellCallback callback, ResultReceiver resultReceiver) {
	(new TestHarnessModeShellCommand())
	.exec(this, in, out, err, args, callback, resultReceiver);
	}
	};

	private class TestHarnessModeShellCommand extends ShellCommand {
	@Override
	public int onCommand(String cmd) {
	switch (cmd) {
	case "enable":
	case "restore":
	checkPermissions();
	final long originalId = Binder.clearCallingIdentity();
	try {
	if (isDeviceSecure()) {
	getErrPrintWriter().println(
	"Test Harness Mode cannot be enabled if there is a lock "
	+ "screen");
	return 2;
	}
	return handleEnable();
	} finally {
	Binder.restoreCallingIdentity(originalId);
	}
	default:
	return handleDefaultCommands(cmd);
	}
	}

	private void checkPermissions() {
	getContext().enforceCallingPermission(
	android.Manifest.permission.ENABLE_TEST_HARNESS_MODE,
	"You must hold android.permission.ENABLE_TEST_HARNESS_MODE "
	+ "to enable Test Harness Mode");
	}

	private boolean isDeviceSecure() {
	UserInfo primaryUser = UserManager.get(getContext()).getPrimaryUser();
	KeyguardManager keyguardManager = getContext().getSystemService(KeyguardManager.class);
	return keyguardManager.isDeviceSecure(primaryUser.id);
	}

	private int handleEnable() {
	Path adbKeys = Paths.get("/data/misc/adb/adb_keys");
	if (!Files.exists(adbKeys)) {
	// This should only be accessible on eng builds that haven't yet set up ADB keys
	getErrPrintWriter()
	.println("No ADB keys stored; not enabling test harness mode");
	return 1;
	}

	try (InputStream inputStream = Files.newInputStream(adbKeys)) {
	long size = Files.size(adbKeys);
	byte[] adbKeysBytes = new byte[(int) size];
	int numBytes = inputStream.read(adbKeysBytes);
	if (numBytes != size) {
	getErrPrintWriter().println("Failed to read all bytes of adb_keys");
	return 1;
	}
	PersistentData persistentData = new PersistentData(true, adbKeysBytes);
	getPersistentDataBlock().setTestHarnessModeData(persistentData.toBytes());
	} catch (IOException e) {
	Slog.e(TAG, "Failed to store ADB keys.", e);
	getErrPrintWriter().println("Failed to enable Test Harness Mode");
	return 1;
	}

	Intent i = new Intent(Intent.ACTION_FACTORY_RESET);
	i.setPackage("android");
	i.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
	i.putExtra(Intent.EXTRA_REASON, TAG);
	i.putExtra(Intent.EXTRA_WIPE_EXTERNAL_STORAGE, true);
	getContext().sendBroadcastAsUser(i, UserHandle.SYSTEM);
	return 0;
	}

	@Override
	public void onHelp() {
	PrintWriter pw = getOutPrintWriter();
	pw.println("About:");
	pw.println(" Test Harness Mode is a mode that the device can be placed in to prepare");
	pw.println(" the device for running UI tests. The device is placed into this mode by");
	pw.println(" first wiping all data from the device, preserving ADB keys.");
	pw.println();
	pw.println(" By default, the following settings are configured:");
	pw.println(" * Package Verifier is disabled");
	pw.println(" * Stay Awake While Charging is enabled");
	pw.println(" * OTA Updates are disabled");
	pw.println(" * Auto-Sync for accounts is disabled");
	pw.println();
	pw.println(" Other apps may configure themselves differently in Test Harness Mode by");
	pw.println(" checking ActivityManager.isRunningInUserTestHarness()");
	pw.println();
	pw.println("Test Harness Mode commands:");
	pw.println(" help");
	pw.println(" Print this help text.");
	pw.println();
	pw.println(" enable\|restore");
	pw.println(" Erase all data from this device and enable Test Harness Mode,");
	pw.println(" preserving the stored ADB keys currently on the device and toggling");
	pw.println(" settings in a way that are conducive to Instrumentation testing.");
	}
	}

	/**
	* The object that will serialize/deserialize the Test Harness Mode data to and from the
	* persistent data block.
	*/
	public static class PersistentData {
	static final byte VERSION_1 = 1;

	final int mVersion;
	final boolean mEnabled;
	final byte[] mAdbKeys;

	PersistentData(boolean enabled, byte[] adbKeys) {
	this(VERSION_1, enabled, adbKeys);
	}

	PersistentData(int version, boolean enabled, byte[] adbKeys) {
	this.mVersion = version;
	this.mEnabled = enabled;
	this.mAdbKeys = adbKeys;
	}

	static PersistentData fromBytes(byte[] bytes) {
	try {
	DataInputStream is = new DataInputStream(new ByteArrayInputStream(bytes));
	int version = is.readInt();
	boolean enabled = is.readBoolean();
	int adbKeysLength = is.readInt();
	byte[] adbKeys = new byte[adbKeysLength];
	is.readFully(adbKeys);
	return new PersistentData(version, enabled, adbKeys);
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	}

	byte[] toBytes() {
	try {
	ByteArrayOutputStream os = new ByteArrayOutputStream();
	DataOutputStream dos = new DataOutputStream(os);
	dos.writeInt(VERSION_1);
	dos.writeBoolean(mEnabled);
	dos.writeInt(mAdbKeys.length);
	dos.write(mAdbKeys);
	dos.close();
	return os.toByteArray();
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	}
	}
	}