Merge "Rename payload metadata partition"
diff --git a/demo/Android.bp b/demo/Android.bp
new file mode 100644
index 0000000..77049de
--- /dev/null
+++ b/demo/Android.bp
@@ -0,0 +1,21 @@
+package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_app {
+ name: "MicrodroidDemoApp",
+ srcs: ["java/**/*.java"],
+ resource_dirs: ["res"],
+ static_libs: [
+ "androidx-constraintlayout_constraintlayout",
+ "androidx.appcompat_appcompat",
+ "com.google.android.material_material",
+ ],
+ libs: [
+ "android.system.virtualmachine",
+ ],
+ jni_libs: ["MicrodroidTestNativeLib"],
+ platform_apis: true,
+ use_embedded_native_libs: true,
+ v4_signature: true,
+}
diff --git a/demo/AndroidManifest.xml b/demo/AndroidManifest.xml
new file mode 100644
index 0000000..ae4f734
--- /dev/null
+++ b/demo/AndroidManifest.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.microdroid.demo">
+
+ <application
+ android:label="MicrodroidDemo"
+ android:theme="@style/Theme.MicrodroidDemo">
+ <uses-library android:name="android.system.virtualmachine" android:required="true" />
+ <activity android:name=".MainActivity" android:exported="true">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+
+</manifest>
diff --git a/demo/assets/vm_config.json b/demo/assets/vm_config.json
new file mode 100644
index 0000000..b814394
--- /dev/null
+++ b/demo/assets/vm_config.json
@@ -0,0 +1,13 @@
+{
+ "os": {
+ "name": "microdroid"
+ },
+ "task": {
+ "type": "microdroid_launcher",
+ "command": "MicrodroidTestNativeLib.so",
+ "args": [
+ "hello",
+ "microdroid"
+ ]
+ }
+}
diff --git a/demo/java/com/android/microdroid/demo/MainActivity.java b/demo/java/com/android/microdroid/demo/MainActivity.java
new file mode 100644
index 0000000..976e37e
--- /dev/null
+++ b/demo/java/com/android/microdroid/demo/MainActivity.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2021 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.microdroid.demo;
+
+import android.app.Application;
+import android.os.Bundle;
+import android.system.virtualmachine.VirtualMachine;
+import android.system.virtualmachine.VirtualMachineConfig;
+import android.system.virtualmachine.VirtualMachineException;
+import android.system.virtualmachine.VirtualMachineManager;
+import android.widget.TextView;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.Observer;
+import androidx.lifecycle.ViewModelProvider;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * This app is to demonstrate the use of APIs in the android.system.virtualmachine library.
+ * Currently, this app starts a virtual machine running Microdroid and shows the console output from
+ * the virtual machine to the UI.
+ */
+public class MainActivity extends AppCompatActivity {
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // Whenthe console model is updated, append the new line to the text view.
+ TextView view = (TextView) findViewById(R.id.textview);
+ VirtualMachineModel model = new ViewModelProvider(this).get(VirtualMachineModel.class);
+ model.getConsoleOutput()
+ .observeForever(
+ new Observer<String>() {
+ @Override
+ public void onChanged(String line) {
+ view.append(line + "\n");
+ }
+ });
+ }
+
+ /** Models a virtual machine and console output from it. */
+ public static class VirtualMachineModel extends AndroidViewModel {
+ private final VirtualMachine mVirtualMachine;
+ private final MutableLiveData<String> mConsoleOutput = new MutableLiveData<>();
+
+ public VirtualMachineModel(Application app) {
+ super(app);
+
+ // Create a VM and run it.
+ // TODO(jiyong): remove the call to idsigPath
+ try {
+ VirtualMachineConfig config =
+ new VirtualMachineConfig.Builder(getApplication(), "assets/vm_config.json")
+ .idsigPath("/data/local/tmp/virt/MicrodroidDemoApp.apk.idsig")
+ .build();
+ VirtualMachineManager vmm = VirtualMachineManager.getInstance(getApplication());
+ mVirtualMachine = vmm.create("demo_vm", config);
+ mVirtualMachine.run();
+ } catch (VirtualMachineException e) {
+ throw new RuntimeException(e);
+ }
+
+ // Read console output from the VM in the background
+ ExecutorService executorService = Executors.newFixedThreadPool(1);
+ executorService.execute(
+ new Runnable() {
+ @Override
+ public void run() {
+ try {
+ BufferedReader reader =
+ new BufferedReader(
+ new InputStreamReader(
+ mVirtualMachine.getConsoleOutputStream()));
+ while (true) {
+ String line = reader.readLine();
+ mConsoleOutput.postValue(line);
+ }
+ } catch (IOException | VirtualMachineException e) {
+ // Consume
+ }
+ }
+ });
+ }
+
+ public LiveData<String> getConsoleOutput() {
+ return mConsoleOutput;
+ }
+ }
+}
diff --git a/demo/res/layout/activity_main.xml b/demo/res/layout/activity_main.xml
new file mode 100644
index 0000000..026382f
--- /dev/null
+++ b/demo/res/layout/activity_main.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:app="http://schemas.android.com/apk/res-auto"
+ xmlns:tools="http://schemas.android.com/tools"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ android:background="#FFC107"
+ android:scrollbars="horizontal|vertical"
+ android:textAlignment="textStart"
+ tools:context=".MainActivity">
+
+ <ScrollView
+ android:id="@+id/scrollview"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+ <TextView
+ android:id="@+id/textview"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:background="#FFEB3B"
+ android:fontFamily="monospace"
+ android:textColor="#000000" />
+ </ScrollView>
+
+</androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/demo/res/values/colors.xml b/demo/res/values/colors.xml
new file mode 100644
index 0000000..f8c6127
--- /dev/null
+++ b/demo/res/values/colors.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+ <color name="purple_200">#FFBB86FC</color>
+ <color name="purple_500">#FF6200EE</color>
+ <color name="purple_700">#FF3700B3</color>
+ <color name="teal_200">#FF03DAC5</color>
+ <color name="teal_700">#FF018786</color>
+ <color name="black">#FF000000</color>
+ <color name="white">#FFFFFFFF</color>
+</resources>
\ No newline at end of file
diff --git a/demo/res/values/themes.xml b/demo/res/values/themes.xml
new file mode 100644
index 0000000..16b8ab3
--- /dev/null
+++ b/demo/res/values/themes.xml
@@ -0,0 +1,16 @@
+<resources xmlns:tools="http://schemas.android.com/tools">
+ <!-- Base application theme. -->
+ <style name="Theme.MicrodroidDemo" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
+ <!-- Primary brand color. -->
+ <item name="colorPrimary">@color/purple_500</item>
+ <item name="colorPrimaryVariant">@color/purple_700</item>
+ <item name="colorOnPrimary">@color/white</item>
+ <!-- Secondary brand color. -->
+ <item name="colorSecondary">@color/teal_200</item>
+ <item name="colorSecondaryVariant">@color/teal_700</item>
+ <item name="colorOnSecondary">@color/black</item>
+ <!-- Status bar color. -->
+ <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
+ <!-- Customize your theme here. -->
+ </style>
+</resources>
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachine.java b/javalib/src/android/system/virtualmachine/VirtualMachine.java
index 504bc03..8089d85 100644
--- a/javalib/src/android/system/virtualmachine/VirtualMachine.java
+++ b/javalib/src/android/system/virtualmachine/VirtualMachine.java
@@ -16,5 +16,267 @@
package android.system.virtualmachine;
-/** @hide */
-public class VirtualMachine {}
+import android.content.Context;
+import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.system.virtualizationservice.IVirtualMachine;
+import android.system.virtualizationservice.IVirtualizationService;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.Optional;
+
+/**
+ * A handle to the virtual machine. The virtual machine is local to the app which created the
+ * virtual machine.
+ *
+ * @hide
+ */
+public class VirtualMachine {
+ /** Name of the directory under the files directory where all VMs created for the app exist. */
+ private static final String VM_DIR = "vm";
+
+ /** Name of the persisted config file for a VM. */
+ private static final String CONFIG_FILE = "config.xml";
+
+ /** Name of the instance image file for a VM. (Not implemented) */
+ private static final String INSTANCE_IMAGE_FILE = "instance.img";
+
+ /** Name of the virtualization service. */
+ private static final String SERVICE_NAME = "android.system.virtualizationservice";
+
+ /** Status of a virtual machine */
+ public enum Status {
+ /** The virtual machine has just been created, or {@link #stop()} was called on it. */
+ STOPPED,
+ /** The virtual machine is running. */
+ RUNNING,
+ /**
+ * The virtual machine is deleted. This is a irreversable state. Once a virtual machine is
+ * deleted, it can never be undone, which means all its secrets are permanently lost.
+ */
+ DELETED,
+ }
+
+ /** The package which owns this VM. */
+ private final String mPackageName;
+
+ /** Name of this VM within the package. The name should be unique in the package. */
+ private final String mName;
+
+ /**
+ * Path to the config file for this VM. The config file is where the configuration is persisted.
+ */
+ private final File mConfigFilePath;
+
+ /** Path to the instance image file for this VM. (Not implemented) */
+ private final File mInstanceFilePath;
+
+ /** The configuration that is currently associated with this VM. */
+ private VirtualMachineConfig mConfig;
+
+ /** Handle to the "running" VM. */
+ private IVirtualMachine mVirtualMachine;
+
+ private ParcelFileDescriptor mConsoleReader;
+ private ParcelFileDescriptor mConsoleWriter;
+
+ private VirtualMachine(Context context, String name, VirtualMachineConfig config) {
+ mPackageName = context.getPackageName();
+ mName = name;
+ mConfig = config;
+
+ final File vmRoot = new File(context.getFilesDir(), VM_DIR);
+ final File thisVmDir = new File(vmRoot, mName);
+ mConfigFilePath = new File(thisVmDir, CONFIG_FILE);
+ mInstanceFilePath = new File(thisVmDir, INSTANCE_IMAGE_FILE);
+ }
+
+ /**
+ * Creates a virtual machine with the given name and config. Once a virtual machine is created
+ * it is persisted until it is deleted by calling {@link #delete()}. The created virtual machine
+ * is in {@link #STOPPED} state. To run the VM, call {@link #run()}.
+ */
+ /* package */ static VirtualMachine create(
+ Context context, String name, VirtualMachineConfig config)
+ throws VirtualMachineException {
+ // TODO(jiyong): trigger an error if the VM having 'name' already exists.
+ VirtualMachine vm = new VirtualMachine(context, name, config);
+
+ try {
+ final File vmRoot = vm.mConfigFilePath.getParentFile();
+ Files.createDirectories(vmRoot.toPath());
+
+ FileOutputStream output = new FileOutputStream(vm.mConfigFilePath);
+ vm.mConfig.serialize(output);
+ output.close();
+ } catch (IOException e) {
+ throw new VirtualMachineException(e);
+ }
+
+ // TODO(jiyong): create the instance image file
+ return vm;
+ }
+
+ /** Loads a virtual machine that is already created before. */
+ /* package */ static VirtualMachine load(Context context, String name)
+ throws VirtualMachineException {
+ // TODO(jiyong): return null if the VM having the 'name' doesn't exist.
+ VirtualMachine vm = new VirtualMachine(context, name, /* config */ null);
+
+ try {
+ FileInputStream input = new FileInputStream(vm.mConfigFilePath);
+ VirtualMachineConfig config = VirtualMachineConfig.from(input);
+ input.close();
+ vm.mConfig = config;
+ } catch (IOException e) {
+ throw new VirtualMachineException(e);
+ }
+
+ return vm;
+ }
+
+ /**
+ * Returns the name of this virtual machine. The name is unique in the package and can't be
+ * changed.
+ */
+ public String getName() {
+ return mName;
+ }
+
+ /**
+ * Returns the currently selected config of this virtual machine. There can be multiple virtual
+ * machines sharing the same config. Even in that case, the virtual machines are completely
+ * isolated from each other; one cannot share its secret to another virtual machine even if they
+ * share the same config. It is also possible that a virtual machine can switch its config,
+ * which can be done by calling {@link #setConfig(VirtualMachineCOnfig)}.
+ */
+ public VirtualMachineConfig getConfig() {
+ return mConfig;
+ }
+
+ /** Returns the current status of this virtual machine. */
+ public Status getStatus() throws VirtualMachineException {
+ try {
+ if (mVirtualMachine != null && mVirtualMachine.isRunning()) {
+ return Status.RUNNING;
+ }
+ } catch (RemoteException e) {
+ throw new VirtualMachineException(e);
+ }
+ if (!mConfigFilePath.exists()) {
+ return Status.DELETED;
+ }
+ return Status.STOPPED;
+ }
+
+ /**
+ * Runs this virtual machine. The returning of this method however doesn't mean that the VM has
+ * actually started running or the OS has booted there. Such events can be notified by
+ * registering a callback object (not implemented currently).
+ */
+ public void run() throws VirtualMachineException {
+ if (getStatus() != Status.STOPPED) {
+ throw new VirtualMachineException(this + " is not in stopped state");
+ }
+ IVirtualizationService service =
+ IVirtualizationService.Stub.asInterface(ServiceManager.getService(SERVICE_NAME));
+
+ try {
+ if (mConsoleReader == null && mConsoleWriter == null) {
+ ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
+ mConsoleReader = pipe[0];
+ mConsoleWriter = pipe[1];
+ }
+ mVirtualMachine =
+ service.startVm(
+ android.system.virtualizationservice.VirtualMachineConfig.appConfig(
+ getConfig().toParcel()),
+ mConsoleWriter);
+ } catch (IOException e) {
+ throw new VirtualMachineException(e);
+ } catch (RemoteException e) {
+ throw new VirtualMachineException(e);
+ }
+ }
+
+ /** Returns the stream object representing the console output from the virtual machine. */
+ public InputStream getConsoleOutputStream() throws VirtualMachineException {
+ if (mConsoleReader == null) {
+ throw new VirtualMachineException("Console output not available");
+ }
+ return new FileInputStream(mConsoleReader.getFileDescriptor());
+ }
+
+ /**
+ * Stops this virtual machine. Stopping a virtual machine is like pulling the plug on a real
+ * computer; the machine halts immediately. Software running on the virtual machine is not
+ * notified with the event. A stopped virtual machine can be re-started by calling {@link
+ * #run()}.
+ */
+ public void stop() throws VirtualMachineException {
+ // Dropping the IVirtualMachine handle stops the VM
+ mVirtualMachine = null;
+ }
+
+ /**
+ * Deletes this virtual machine. Deleting a virtual machine means deleting any persisted data
+ * associated with it including the per-VM secret. This is an irreversable action. A virtual
+ * machine once deleted can never be restored. A new virtual machine created with the same name
+ * and the same config is different from an already deleted virtual machine.
+ */
+ public void delete() throws VirtualMachineException {
+ if (getStatus() != Status.STOPPED) {
+ throw new VirtualMachineException("Virtual machine is not stopped");
+ }
+ final File vmRootDir = mConfigFilePath.getParentFile();
+ mConfigFilePath.delete();
+ mInstanceFilePath.delete();
+ vmRootDir.delete();
+ }
+
+ /** Returns the CID of this virtual machine, if it is running. */
+ public Optional<Integer> getCid() throws VirtualMachineException {
+ if (getStatus() != Status.RUNNING) {
+ return Optional.empty();
+ }
+ try {
+ return Optional.of(mVirtualMachine.getCid());
+ } catch (RemoteException e) {
+ throw new VirtualMachineException(e);
+ }
+ }
+
+ /**
+ * Changes the config of this virtual machine to a new one. This can be used to adjust things
+ * like the number of CPU and size of the RAM, depending on the situation (e.g. the size of the
+ * application to run on the virtual machine, etc.) However, changing a config might make the
+ * virtual machine un-bootable if the new config is not compatible with the existing one. For
+ * example, if the signer of the app payload in the new config is different from that of the old
+ * config, the virtual machine won't boot. To prevent such cases, this method returns exception
+ * when an incompatible config is attempted.
+ *
+ * @return the old config
+ */
+ public VirtualMachineConfig setConfig(VirtualMachineConfig newConfig)
+ throws VirtualMachineException {
+ // TODO(jiyong): implement this
+ throw new VirtualMachineException("Not implemented");
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("VirtualMachine(");
+ sb.append("name:" + getName() + ", ");
+ sb.append("config:" + getConfig().getPayloadConfigPath() + ", ");
+ sb.append("package: " + mPackageName);
+ sb.append(")");
+ return sb.toString();
+ }
+}
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java b/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java
new file mode 100644
index 0000000..062cd04
--- /dev/null
+++ b/javalib/src/android/system/virtualmachine/VirtualMachineConfig.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2021 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 android.system.virtualmachine;
+
+import static android.os.ParcelFileDescriptor.MODE_READ_ONLY;
+
+import android.content.Context;
+import android.os.ParcelFileDescriptor;
+import android.os.PersistableBundle;
+import android.system.virtualizationservice.VirtualMachineAppConfig;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/**
+ * Represents a configuration of a virtual machine. A configuration consists of hardware
+ * configurations like the number of CPUs and the size of RAM, and software configurations like the
+ * OS and application to run on the virtual machine.
+ *
+ * @hide
+ */
+public final class VirtualMachineConfig {
+ // These defines the schema of the config file persisted on disk.
+ private static final int VERSION = 1;
+ private static final String KEY_VERSION = "version";
+ private static final String KEY_APKPATH = "apkPath";
+ private static final String KEY_IDSIGPATH = "idsigPath";
+ private static final String KEY_PAYLOADCONFIGPATH = "payloadConfigPath";
+
+ // Paths to the APK and its idsig file of this application.
+ private final String mApkPath;
+ private final String mIdsigPath;
+
+ /**
+ * Path within the APK to the payload config file that defines software aspects of this config.
+ */
+ private final String mPayloadConfigPath;
+
+ // TODO(jiyong): add more items like # of cpu, size of ram, debuggability, etc.
+
+ private VirtualMachineConfig(String apkPath, String idsigPath, String payloadConfigPath) {
+ mApkPath = apkPath;
+ mIdsigPath = idsigPath;
+ mPayloadConfigPath = payloadConfigPath;
+ }
+
+ /** Loads a config from a stream, for example a file. */
+ /* package */ static VirtualMachineConfig from(InputStream input)
+ throws IOException, VirtualMachineException {
+ PersistableBundle b = PersistableBundle.readFromStream(input);
+ final int version = b.getInt(KEY_VERSION);
+ if (version > VERSION) {
+ throw new VirtualMachineException("Version too high");
+ }
+ final String apkPath = b.getString(KEY_APKPATH);
+ if (apkPath == null) {
+ throw new VirtualMachineException("No apkPath");
+ }
+ final String idsigPath = b.getString(KEY_IDSIGPATH);
+ if (idsigPath == null) {
+ throw new VirtualMachineException("No idsigPath");
+ }
+ final String payloadConfigPath = b.getString(KEY_PAYLOADCONFIGPATH);
+ if (payloadConfigPath == null) {
+ throw new VirtualMachineException("No payloadConfigPath");
+ }
+ return new VirtualMachineConfig(apkPath, idsigPath, payloadConfigPath);
+ }
+
+ /** Persists this config to a stream, for example a file. */
+ /* package */ void serialize(OutputStream output) throws IOException {
+ PersistableBundle b = new PersistableBundle();
+ b.putInt(KEY_VERSION, VERSION);
+ b.putString(KEY_APKPATH, mApkPath);
+ b.putString(KEY_IDSIGPATH, mIdsigPath);
+ b.putString(KEY_PAYLOADCONFIGPATH, mPayloadConfigPath);
+ b.writeToStream(output);
+ }
+
+ /** Returns the path to the payload config within the owning application. */
+ public String getPayloadConfigPath() {
+ return mPayloadConfigPath;
+ }
+
+ /**
+ * Converts this config object into a parcel. Used when creating a VM via the virtualization
+ * service. Notice that the files are not passed as paths, but as file descriptors because the
+ * service doesn't accept paths as it might not have permission to open app-owned files and that
+ * could be abused to run a VM with software that the calling application doesn't own.
+ */
+ /* package */ VirtualMachineAppConfig toParcel() throws FileNotFoundException {
+ VirtualMachineAppConfig parcel = new VirtualMachineAppConfig();
+ parcel.apk = ParcelFileDescriptor.open(new File(mApkPath), MODE_READ_ONLY);
+ parcel.idsig = ParcelFileDescriptor.open(new File(mIdsigPath), MODE_READ_ONLY);
+ parcel.configPath = mPayloadConfigPath;
+ return parcel;
+ }
+
+ /** A builder used to create a {@link VirtualMachineConfig}. */
+ public static class Builder {
+ private Context mContext;
+ private String mPayloadConfigPath;
+ private String mIdsigPath; // TODO(jiyong): remove this
+ // TODO(jiyong): add more items like # of cpu, size of ram, debuggability, etc.
+
+ /** Creates a builder for the given context (APK), and the payload config file in APK. */
+ public Builder(Context context, String payloadConfigPath) {
+ mContext = context;
+ mPayloadConfigPath = payloadConfigPath;
+ }
+
+ // TODO(jiyong): remove this. Apps shouldn't need to set the path to the idsig file. It
+ // should be automatically found or created on demand.
+ /** Set the path to the idsig file for the current application. */
+ public Builder idsigPath(String idsigPath) {
+ mIdsigPath = idsigPath;
+ return this;
+ }
+
+ /** Builds an immutable {@link VirtualMachineConfig} */
+ public VirtualMachineConfig build() {
+ final String apkPath = mContext.getPackageCodePath();
+ return new VirtualMachineConfig(apkPath, mIdsigPath, mPayloadConfigPath);
+ }
+ }
+}
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachineException.java b/javalib/src/android/system/virtualmachine/VirtualMachineException.java
new file mode 100644
index 0000000..d6aeab3
--- /dev/null
+++ b/javalib/src/android/system/virtualmachine/VirtualMachineException.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2021 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 android.system.virtualmachine;
+
+/** @hide */
+public class VirtualMachineException extends Exception {
+ public VirtualMachineException() {
+ super();
+ }
+
+ public VirtualMachineException(String message) {
+ super(message);
+ }
+
+ public VirtualMachineException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public VirtualMachineException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/javalib/src/android/system/virtualmachine/VirtualMachineManager.java b/javalib/src/android/system/virtualmachine/VirtualMachineManager.java
new file mode 100644
index 0000000..dfa4f0b
--- /dev/null
+++ b/javalib/src/android/system/virtualmachine/VirtualMachineManager.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2021 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 android.system.virtualmachine;
+
+import android.content.Context;
+
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * Manages {@link VirtualMachine} objects created for an application.
+ *
+ * @hide
+ */
+public class VirtualMachineManager {
+ private final Context mContext;
+
+ private VirtualMachineManager(Context context) {
+ mContext = context;
+ }
+
+ static Map<Context, WeakReference<VirtualMachineManager>> sInstances = new WeakHashMap<>();
+
+ /** Returns the per-context instance. */
+ public static VirtualMachineManager getInstance(Context context) {
+ synchronized (sInstances) {
+ VirtualMachineManager vmm =
+ sInstances.containsKey(context) ? sInstances.get(context).get() : null;
+ if (vmm == null) {
+ vmm = new VirtualMachineManager(context);
+ sInstances.put(context, new WeakReference(vmm));
+ }
+ return vmm;
+ }
+ }
+
+ /** A lock used to synchronize the creation of virtual machines */
+ private static final Object sCreateLock = new Object();
+
+ /**
+ * Creates a new {@link VirtualMachine} with the given name and config. Creating a virtual
+ * machine with the same name as an existing virtual machine is an error. The existing virtual
+ * machine has to be deleted before its name can be reused. Every call to this methods creates a
+ * new (and different) virtual machine even if the name and the config are the same as the
+ * deleted one.
+ */
+ public VirtualMachine create(String name, VirtualMachineConfig config)
+ throws VirtualMachineException {
+ synchronized (sCreateLock) {
+ return VirtualMachine.create(mContext, name, config);
+ }
+ }
+
+ /**
+ * Returns an existing {@link VirtualMachine} with the given name. Returns null if there is no
+ * such virtual machine.
+ */
+ public VirtualMachine get(String name) throws VirtualMachineException {
+ return VirtualMachine.load(mContext, name);
+ }
+
+ /** Returns an existing {@link VirtualMachine} if it exists, or create a new one. */
+ public VirtualMachine getOrCreate(String name, VirtualMachineConfig config)
+ throws VirtualMachineException {
+ VirtualMachine vm;
+ synchronized (sCreateLock) {
+ vm = get(name);
+ if (vm == null) {
+ return create(name, config);
+ }
+ }
+
+ if (vm.getConfig().equals(config)) {
+ return vm;
+ } else {
+ throw new VirtualMachineException("Incompatible config");
+ }
+ }
+}
diff --git a/tests/testapk/src/java/com/android/microdroid/test/TestActivity.java b/tests/testapk/src/java/com/android/microdroid/test/TestActivity.java
index b25869b..f73772e 100644
--- a/tests/testapk/src/java/com/android/microdroid/test/TestActivity.java
+++ b/tests/testapk/src/java/com/android/microdroid/test/TestActivity.java
@@ -17,8 +17,35 @@
import android.app.Activity;
import android.os.Bundle;
+import android.system.virtualmachine.VirtualMachine;
+import android.system.virtualmachine.VirtualMachineConfig;
+import android.system.virtualmachine.VirtualMachineException;
+import android.system.virtualmachine.VirtualMachineManager;
public class TestActivity extends Activity {
+
@Override
- public void onCreate(Bundle savedInstanceState) {}
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ VirtualMachine vm1 = createAndRunVirtualMachine("vm1");
+ VirtualMachine vm2 = createAndRunVirtualMachine("vm2");
+ }
+
+ private VirtualMachine createAndRunVirtualMachine(String name) {
+ VirtualMachine vm;
+ try {
+ VirtualMachineConfig config =
+ new VirtualMachineConfig.Builder(this, "assets/vm_config.json")
+ .idsigPath("/data/local/tmp/virt/MicrodroidTestApp.apk.idsig")
+ .build();
+
+ VirtualMachineManager vmm = VirtualMachineManager.getInstance(this);
+ vm = vmm.create(name, config);
+ vm.run();
+ } catch (VirtualMachineException e) {
+ throw new RuntimeException(e);
+ }
+ return vm;
+ }
}
diff --git a/virtualizationservice/aidl/Android.bp b/virtualizationservice/aidl/Android.bp
index a3311f2..f7cb339 100644
--- a/virtualizationservice/aidl/Android.bp
+++ b/virtualizationservice/aidl/Android.bp
@@ -5,8 +5,8 @@
aidl_interface {
name: "android.system.virtualizationservice",
srcs: ["**/*.aidl"],
- // This is never accessed directly. Apps are expected to use this indirectly via the java wrapper
- // android.system.virtualmachine.
+ // This is never accessed directly. Apps are expected to use this indirectly via the Java
+ // wrapper android.system.virtualmachine.
unstable: true,
backend: {
java: {