diff --git a/packages/android_alarm_manager/CHANGELOG.md b/packages/android_alarm_manager/CHANGELOG.md
index 1494506..055086d 100644
--- a/packages/android_alarm_manager/CHANGELOG.md
+++ b/packages/android_alarm_manager/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.4.5
+
+* Add support for Flutter Android embedding V2
+
 ## 0.4.4+3
 
 * Add unit tests and DartDocs.
diff --git a/packages/android_alarm_manager/android/build.gradle b/packages/android_alarm_manager/android/build.gradle
index d711772..52da124 100644
--- a/packages/android_alarm_manager/android/build.gradle
+++ b/packages/android_alarm_manager/android/build.gradle
@@ -23,7 +23,10 @@
 
 android {
     compileSdkVersion 28
-
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
     defaultConfig {
         minSdkVersion 16
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -37,3 +40,29 @@
     implementation 'androidx.appcompat:appcompat:1.0.0'
     api 'androidx.core:core:1.0.1'
 }
+
+// TODO(bkonyi): Remove this hack once androidx.lifecycle is included on stable. https://github.com/flutter/flutter/issues/42348
+afterEvaluate {
+    def containsEmbeddingDependencies = false
+    for (def configuration : configurations.all) {
+        for (def dependency : configuration.dependencies) {
+            if (dependency.group == 'io.flutter' &&
+                dependency.name.startsWith('flutter_embedding') &&
+                dependency.isTransitive())
+            {
+                containsEmbeddingDependencies = true
+                break
+            }
+        }
+    }
+    if (!containsEmbeddingDependencies) {
+        android {
+            dependencies {
+                def lifecycle_version = "1.1.1"
+                api 'android.arch.lifecycle:runtime:$lifecycle_version'
+                api 'android.arch.lifecycle:common:$lifecycle_version'
+                api 'android.arch.lifecycle:common-java8:$lifecycle_version'
+            }
+        }
+    }
+}
diff --git a/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AlarmService.java b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AlarmService.java
index bb3d0c8..fb6e7f8 100644
--- a/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AlarmService.java
+++ b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AlarmService.java
@@ -13,12 +13,7 @@
 import android.util.Log;
 import androidx.core.app.AlarmManagerCompat;
 import androidx.core.app.JobIntentService;
-import io.flutter.plugin.common.MethodChannel;
 import io.flutter.plugin.common.PluginRegistry.PluginRegistrantCallback;
-import io.flutter.view.FlutterCallbackInformation;
-import io.flutter.view.FlutterMain;
-import io.flutter.view.FlutterNativeView;
-import io.flutter.view.FlutterRunArguments;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -27,192 +22,88 @@
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicBoolean;
 import org.json.JSONException;
 import org.json.JSONObject;
 
 public class AlarmService extends JobIntentService {
-  // TODO(mattcarroll): tags should be private. Make private if no public usage.
-  public static final String TAG = "AlarmService";
-  private static final String CALLBACK_HANDLE_KEY = "callback_handle";
+  private static final String TAG = "AlarmService";
   private static final String PERSISTENT_ALARMS_SET_KEY = "persistent_alarm_ids";
-  private static final String SHARED_PREFERENCES_KEY = "io.flutter.android_alarm_manager_plugin";
+  protected static final String SHARED_PREFERENCES_KEY = "io.flutter.android_alarm_manager_plugin";
   private static final int JOB_ID = 1984; // Random job ID.
-  private static final Object sPersistentAlarmsLock = new Object();
+  private static final Object persistentAlarmsLock = new Object();
 
-  // TODO(mattcarroll): make sIsIsolateRunning per-instance, not static.
-  private static AtomicBoolean sIsIsolateRunning = new AtomicBoolean(false);
-
-  // TODO(mattcarroll): make sAlarmQueue per-instance, not static.
-  private static List<Intent> sAlarmQueue = Collections.synchronizedList(new LinkedList<Intent>());
+  // TODO(mattcarroll): make alarmQueue per-instance, not static.
+  private static List<Intent> alarmQueue = Collections.synchronizedList(new LinkedList<Intent>());
 
   /** Background Dart execution context. */
-  private static FlutterNativeView sBackgroundFlutterView;
+  private static FlutterBackgroundExecutor flutterBackgroundExecutor;
 
-  /**
-   * The {@link MethodChannel} that connects the Android side of this plugin with the background
-   * Dart isolate that was created by this plugin.
-   */
-  private static MethodChannel sBackgroundChannel;
-
-  private static PluginRegistrantCallback sPluginRegistrantCallback;
-
-  // Schedule the alarm to be handled by the AlarmService.
+  /** Schedule the alarm to be handled by the {@link AlarmService}. */
   public static void enqueueAlarmProcessing(Context context, Intent alarmContext) {
     enqueueWork(context, AlarmService.class, JOB_ID, alarmContext);
   }
 
   /**
-   * Starts running a background Dart isolate within a new {@link FlutterNativeView}.
-   *
-   * <p>The isolate is configured as follows:
-   *
-   * <ul>
-   *   <li>Bundle Path: {@code FlutterMain.findAppBundlePath(context)}.
-   *   <li>Entrypoint: The Dart method represented by {@code callbackHandle}.
-   *   <li>Run args: none.
-   * </ul>
+   * Starts the background isolate for the {@link AlarmService}.
    *
    * <p>Preconditions:
    *
    * <ul>
    *   <li>The given {@code callbackHandle} must correspond to a registered Dart callback. If the
    *       handle does not resolve to a Dart callback then this method does nothing.
-   *   <li>A static {@link #sPluginRegistrantCallback} must exist, otherwise a {@link
+   *   <li>A static {@link #pluginRegistrantCallback} must exist, otherwise a {@link
    *       PluginRegistrantException} will be thrown.
    * </ul>
    */
   public static void startBackgroundIsolate(Context context, long callbackHandle) {
-    // TODO(mattcarroll): re-arrange order of operations. The order is strange - there are 3
-    // conditions that must be met for this method to do anything but they're split up for no
-    // apparent reason. Do the qualification checks first, then execute the method's logic.
-    FlutterMain.ensureInitializationComplete(context, null);
-    String mAppBundlePath = FlutterMain.findAppBundlePath(context);
-    FlutterCallbackInformation flutterCallback =
-        FlutterCallbackInformation.lookupCallbackInformation(callbackHandle);
-    if (flutterCallback == null) {
-      Log.e(TAG, "Fatal: failed to find callback");
+    if (flutterBackgroundExecutor != null) {
+      Log.w(TAG, "Attempted to start a duplicate background isolate. Returning...");
       return;
     }
-
-    // Note that we're passing `true` as the second argument to our
-    // FlutterNativeView constructor. This specifies the FlutterNativeView
-    // as a background view and does not create a drawing surface.
-    sBackgroundFlutterView = new FlutterNativeView(context, true);
-    if (mAppBundlePath != null && !sIsIsolateRunning.get()) {
-      if (sPluginRegistrantCallback == null) {
-        throw new PluginRegistrantException();
-      }
-      Log.i(TAG, "Starting AlarmService...");
-      FlutterRunArguments args = new FlutterRunArguments();
-      args.bundlePath = mAppBundlePath;
-      args.entrypoint = flutterCallback.callbackName;
-      args.libraryPath = flutterCallback.callbackLibraryPath;
-      sBackgroundFlutterView.runFromBundle(args);
-      sPluginRegistrantCallback.registerWith(sBackgroundFlutterView.getPluginRegistry());
-    }
+    flutterBackgroundExecutor = new FlutterBackgroundExecutor();
+    flutterBackgroundExecutor.startBackgroundIsolate(context, callbackHandle);
   }
 
   /**
-   * Called once the Dart isolate ({@code sBackgroundFlutterView}) has finished initializing.
+   * Called once the Dart isolate ({@code flutterBackgroundExecutor}) has finished initializing.
    *
    * <p>Invoked by {@link AndroidAlarmManagerPlugin} when it receives the {@code
    * AlarmService.initialized} message. Processes all alarm events that came in while the isolate
    * was starting.
    */
-  // TODO(mattcarroll): consider making this method package private
-  public static void onInitialized() {
+  /* package */ static void onInitialized() {
     Log.i(TAG, "AlarmService started!");
-    sIsIsolateRunning.set(true);
-    synchronized (sAlarmQueue) {
+    synchronized (alarmQueue) {
       // Handle all the alarm events received before the Dart isolate was
       // initialized, then clear the queue.
-      Iterator<Intent> i = sAlarmQueue.iterator();
+      Iterator<Intent> i = alarmQueue.iterator();
       while (i.hasNext()) {
-        executeDartCallbackInBackgroundIsolate(i.next(), null);
+        flutterBackgroundExecutor.executeDartCallbackInBackgroundIsolate(i.next(), null);
       }
-      sAlarmQueue.clear();
+      alarmQueue.clear();
     }
   }
 
   /**
-   * Sets the {@link MethodChannel} that is used to communicate with Dart callbacks that are invoked
-   * in the background by the android_alarm_manager plugin.
-   */
-  public static void setBackgroundChannel(MethodChannel channel) {
-    sBackgroundChannel = channel;
-  }
-
-  /**
    * Sets the Dart callback handle for the Dart method that is responsible for initializing the
    * background Dart isolate, preparing it to receive Dart callback tasks requests.
    */
   public static void setCallbackDispatcher(Context context, long callbackHandle) {
-    SharedPreferences prefs = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
-    prefs.edit().putLong(CALLBACK_HANDLE_KEY, callbackHandle).apply();
-  }
-
-  public static boolean setBackgroundFlutterView(FlutterNativeView view) {
-    if (sBackgroundFlutterView != null && sBackgroundFlutterView != view) {
-      Log.i(TAG, "setBackgroundFlutterView tried to overwrite an existing FlutterNativeView");
-      return false;
-    }
-    sBackgroundFlutterView = view;
-    return true;
-  }
-
-  public static void setPluginRegistrant(PluginRegistrantCallback callback) {
-    sPluginRegistrantCallback = callback;
+    FlutterBackgroundExecutor.setCallbackDispatcher(context, callbackHandle);
   }
 
   /**
-   * Executes the desired Dart callback in a background Dart isolate.
+   * Sets the {@link PluginRegistrantCallback} used to register the plugins used by an application
+   * with the newly spawned background isolate.
    *
-   * <p>The given {@code intent} should contain a {@code long} extra called "callbackHandle", which
-   * corresponds to a callback registered with the Dart VM.
+   * <p>This should be invoked in {@link Application.onCreate} with {@link
+   * GeneratedPluginRegistrant} in applications using the V1 embedding API in order to use other
+   * plugins in the background isolate. For applications using the V2 embedding API, it is not
+   * necessary to set a {@link PluginRegistrantCallback} as plugins are registered automatically.
    */
-  private static void executeDartCallbackInBackgroundIsolate(
-      Intent intent, final CountDownLatch latch) {
-    // Grab the handle for the callback associated with this alarm. Pay close
-    // attention to the type of the callback handle as storing this value in a
-    // variable of the wrong size will cause the callback lookup to fail.
-    long callbackHandle = intent.getLongExtra("callbackHandle", 0);
-    if (sBackgroundChannel == null) {
-      Log.e(
-          TAG,
-          "setBackgroundChannel was not called before alarms were scheduled." + " Bailing out.");
-      return;
-    }
-
-    // If another thread is waiting, then wake that thread when the callback returns a result.
-    MethodChannel.Result result = null;
-    if (latch != null) {
-      result =
-          new MethodChannel.Result() {
-            @Override
-            public void success(Object result) {
-              latch.countDown();
-            }
-
-            @Override
-            public void error(String errorCode, String errorMessage, Object errorDetails) {
-              latch.countDown();
-            }
-
-            @Override
-            public void notImplemented() {
-              latch.countDown();
-            }
-          };
-    }
-
-    // Handle the alarm event in Dart. Note that for this plugin, we don't
-    // care about the method name as we simply lookup and invoke the callback
-    // provided.
-    // TODO(mattcarroll): consider giving a method name anyway for the purpose of developer discoverability
-    //                    when reading the source code. Especially on the Dart side.
-    sBackgroundChannel.invokeMethod(
-        "", new Object[] {callbackHandle, intent.getIntExtra("id", -1)}, result);
+  public static void setPluginRegistrant(PluginRegistrantCallback callback) {
+    // Indirectly set in FlutterBackgroundExecutor for backwards compatibility.
+    FlutterBackgroundExecutor.setPluginRegistrant(callback);
   }
 
   private static void scheduleAlarm(
@@ -285,6 +176,7 @@
     }
   }
 
+  /** Schedules a one-shot alarm to be executed once in the future. */
   public static void setOneShot(Context context, AndroidAlarmManagerPlugin.OneShotRequest request) {
     final boolean repeating = false;
     scheduleAlarm(
@@ -301,6 +193,7 @@
         request.callbackHandle);
   }
 
+  /** Schedules a periodic alarm to be executed repeatedly in the future. */
   public static void setPeriodic(
       Context context, AndroidAlarmManagerPlugin.PeriodicRequest request) {
     final boolean repeating = true;
@@ -320,6 +213,7 @@
         request.callbackHandle);
   }
 
+  /** Cancels an alarm with ID {@code requestCode}. */
   public static void cancel(Context context, int requestCode) {
     // Clear the alarm if it was set to be rescheduled after reboots.
     clearPersistentAlarm(context, requestCode);
@@ -364,7 +258,7 @@
     String key = getPersistentAlarmKey(requestCode);
     SharedPreferences prefs = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
 
-    synchronized (sPersistentAlarmsLock) {
+    synchronized (persistentAlarmsLock) {
       Set<String> persistentAlarms = prefs.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
       if (persistentAlarms == null) {
         persistentAlarms = new HashSet<>();
@@ -383,7 +277,7 @@
 
   private static void clearPersistentAlarm(Context context, int requestCode) {
     SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
-    synchronized (sPersistentAlarmsLock) {
+    synchronized (persistentAlarmsLock) {
       Set<String> persistentAlarms = p.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
       if ((persistentAlarms == null) || !persistentAlarms.contains(requestCode)) {
         return;
@@ -399,7 +293,7 @@
   }
 
   public static void reschedulePersistentAlarms(Context context) {
-    synchronized (sPersistentAlarmsLock) {
+    synchronized (persistentAlarmsLock) {
       SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
       Set<String> persistentAlarms = p.getStringSet(PERSISTENT_ALARMS_SET_KEY, null);
       // No alarms to reschedule.
@@ -449,15 +343,11 @@
   @Override
   public void onCreate() {
     super.onCreate();
-
-    Context context = getApplicationContext();
-    FlutterMain.ensureInitializationComplete(context, null);
-
-    if (!sIsIsolateRunning.get()) {
-      SharedPreferences p = context.getSharedPreferences(SHARED_PREFERENCES_KEY, 0);
-      long callbackHandle = p.getLong(CALLBACK_HANDLE_KEY, 0);
-      startBackgroundIsolate(context, callbackHandle);
+    if (flutterBackgroundExecutor == null) {
+      flutterBackgroundExecutor = new FlutterBackgroundExecutor();
     }
+    Context context = getApplicationContext();
+    flutterBackgroundExecutor.startBackgroundIsolate(context);
   }
 
   /**
@@ -470,17 +360,17 @@
    * intent}, then the desired Dart callback is invoked immediately.
    *
    * <p>If there are any pre-existing callback requests that have yet to be executed, the incoming
-   * {@code intent} is added to the {@link #sAlarmQueue} to invoked later, after all pre-existing
+   * {@code intent} is added to the {@link #alarmQueue} to invoked later, after all pre-existing
    * callbacks have been executed.
    */
   @Override
   protected void onHandleWork(final Intent intent) {
     // If we're in the middle of processing queued alarms, add the incoming
     // intent to the queue and return.
-    synchronized (sAlarmQueue) {
-      if (!sIsIsolateRunning.get()) {
+    synchronized (alarmQueue) {
+      if (!flutterBackgroundExecutor.isRunning()) {
         Log.i(TAG, "AlarmService has not yet started.");
-        sAlarmQueue.add(intent);
+        alarmQueue.add(intent);
         return;
       }
     }
@@ -493,7 +383,7 @@
             new Runnable() {
               @Override
               public void run() {
-                executeDartCallbackInBackgroundIsolate(intent, latch);
+                flutterBackgroundExecutor.executeDartCallbackInBackgroundIsolate(intent, latch);
               }
             });
 
diff --git a/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AndroidAlarmManagerPlugin.java b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AndroidAlarmManagerPlugin.java
index 5cc7741..9db6270 100644
--- a/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AndroidAlarmManagerPlugin.java
+++ b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/AndroidAlarmManagerPlugin.java
@@ -5,13 +5,15 @@
 package io.flutter.plugins.androidalarmmanager;
 
 import android.content.Context;
+import android.util.Log;
+import io.flutter.embedding.engine.plugins.FlutterPlugin;
+import io.flutter.plugin.common.BinaryMessenger;
 import io.flutter.plugin.common.JSONMethodCodec;
 import io.flutter.plugin.common.MethodCall;
 import io.flutter.plugin.common.MethodChannel;
 import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
 import io.flutter.plugin.common.MethodChannel.Result;
 import io.flutter.plugin.common.PluginRegistry.Registrar;
-import io.flutter.plugin.common.PluginRegistry.ViewDestroyListener;
 import io.flutter.view.FlutterNativeView;
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -38,7 +40,13 @@
  *       Dart is ready to execute tasks.
  * </ol>
  */
-public class AndroidAlarmManagerPlugin implements MethodCallHandler, ViewDestroyListener {
+public class AndroidAlarmManagerPlugin implements FlutterPlugin, MethodCallHandler {
+  private static AndroidAlarmManagerPlugin instance;
+  private final String TAG = "AndroidAlarmManagerPlugin";
+  private Context context;
+  private Object initializationLock = new Object();
+  private MethodChannel alarmManagerPluginChannel;
+
   /**
    * Registers this plugin with an associated Flutter execution context, represented by the given
    * {@link Registrar}.
@@ -47,54 +55,53 @@
    * connected to, and running against, the associated Flutter execution context.
    */
   public static void registerWith(Registrar registrar) {
-    // alarmManagerPluginChannel is the channel responsible for receiving the following messages
-    // from the main Flutter app:
-    // - "AlarmService.start"
-    // - "Alarm.oneShotAt"
-    // - "Alarm.periodic"
-    // - "Alarm.cancel"
-    final MethodChannel alarmManagerPluginChannel =
-        new MethodChannel(
-            registrar.messenger(),
-            "plugins.flutter.io/android_alarm_manager",
-            JSONMethodCodec.INSTANCE);
-
-    // backgroundCallbackChannel is the channel responsible for receiving the following messages
-    // from the background isolate that was setup by this plugin:
-    // - "AlarmService.initialized"
-    //
-    // This channel is also responsible for sending requests from Android to Dart to execute Dart
-    // callbacks in the background isolate. Those messages are sent with an empty method name because
-    // they are the only messages that this channel sends to Dart.
-    final MethodChannel backgroundCallbackChannel =
-        new MethodChannel(
-            registrar.messenger(),
-            "plugins.flutter.io/android_alarm_manager_background",
-            JSONMethodCodec.INSTANCE);
-
-    // Instantiate a new AndroidAlarmManagerPlugin, connect the primary and background
-    // method channels for Android/Flutter communication, and listen for FlutterView
-    // destruction so that this plugin can move itself to background mode.
-    AndroidAlarmManagerPlugin plugin = new AndroidAlarmManagerPlugin(registrar.context());
-    alarmManagerPluginChannel.setMethodCallHandler(plugin);
-    backgroundCallbackChannel.setMethodCallHandler(plugin);
-    registrar.addViewDestroyListener(plugin);
-
-    // The AlarmService expects to hold a static reference to the plugin's background
-    // method channel.
-    // TODO(mattcarroll): this static reference implies that only one instance of this plugin
-    //                    can exist at a time. Moreover, calling registerWith() a 2nd time would
-    //                    seem to overwrite the previously registered background channel without
-    //                    notice.
-    AlarmService.setBackgroundChannel(backgroundCallbackChannel);
+    if (instance == null) {
+      instance = new AndroidAlarmManagerPlugin();
+    }
+    instance.onAttachedToEngine(registrar.context(), registrar.messenger());
   }
 
-  private Context mContext;
-
-  private AndroidAlarmManagerPlugin(Context context) {
-    this.mContext = context;
+  @Override
+  public void onAttachedToEngine(FlutterPluginBinding binding) {
+    onAttachedToEngine(
+        binding.getApplicationContext(), binding.getFlutterEngine().getDartExecutor());
   }
 
+  public void onAttachedToEngine(Context applicationContext, BinaryMessenger messenger) {
+    synchronized (initializationLock) {
+      if (alarmManagerPluginChannel != null) {
+        return;
+      }
+
+      Log.i(TAG, "onAttachedToEngine");
+      this.context = applicationContext;
+
+      // alarmManagerPluginChannel is the channel responsible for receiving the following messages
+      // from the main Flutter app:
+      // - "AlarmService.start"
+      // - "Alarm.oneShotAt"
+      // - "Alarm.periodic"
+      // - "Alarm.cancel"
+      alarmManagerPluginChannel =
+          new MethodChannel(
+              messenger, "plugins.flutter.io/android_alarm_manager", JSONMethodCodec.INSTANCE);
+
+      // Instantiate a new AndroidAlarmManagerPlugin and connect the primary method channel for
+      // Android/Flutter communication.
+      alarmManagerPluginChannel.setMethodCallHandler(this);
+    }
+  }
+
+  @Override
+  public void onDetachedFromEngine(FlutterPluginBinding binding) {
+    Log.i(TAG, "onDetachedFromEngine");
+    context = null;
+    alarmManagerPluginChannel.setMethodCallHandler(null);
+    alarmManagerPluginChannel = null;
+  }
+
+  public AndroidAlarmManagerPlugin() {}
+
   /** Invoked when the Flutter side of this plugin sends a message to the Android side. */
   @Override
   public void onMethodCall(MethodCall call, Result result) {
@@ -109,33 +116,26 @@
         // method channel to communicate with the new background isolate. Once completed,
         // this onMethodCall() method will receive messages from both the primary and background
         // method channels.
-        AlarmService.setCallbackDispatcher(mContext, callbackHandle);
-        AlarmService.startBackgroundIsolate(mContext, callbackHandle);
-        result.success(true);
-      } else if (method.equals("AlarmService.initialized")) {
-        // This message is sent by the background method channel as soon as the background isolate
-        // is running. From this point forward, the Android side of this plugin can send
-        // callback handles through the background method channel, and the Dart side will execute
-        // the Dart methods corresponding to those callback handles.
-        AlarmService.onInitialized();
+        AlarmService.setCallbackDispatcher(context, callbackHandle);
+        AlarmService.startBackgroundIsolate(context, callbackHandle);
         result.success(true);
       } else if (method.equals("Alarm.periodic")) {
         // This message indicates that the Flutter app would like to schedule a periodic
         // task.
         PeriodicRequest periodicRequest = PeriodicRequest.fromJson((JSONArray) arguments);
-        AlarmService.setPeriodic(mContext, periodicRequest);
+        AlarmService.setPeriodic(context, periodicRequest);
         result.success(true);
       } else if (method.equals("Alarm.oneShotAt")) {
         // This message indicates that the Flutter app would like to schedule a one-time
         // task.
         OneShotRequest oneShotRequest = OneShotRequest.fromJson((JSONArray) arguments);
-        AlarmService.setOneShot(mContext, oneShotRequest);
+        AlarmService.setOneShot(context, oneShotRequest);
         result.success(true);
       } else if (method.equals("Alarm.cancel")) {
         // This message indicates that the Flutter app would like to cancel a previously
         // scheduled task.
         int requestCode = ((JSONArray) arguments).getInt(0);
-        AlarmService.cancel(mContext, requestCode);
+        AlarmService.cancel(context, requestCode);
         result.success(true);
       } else {
         result.notImplemented();
@@ -147,21 +147,6 @@
     }
   }
 
-  /**
-   * Transitions the Flutter execution context that owns this plugin from foreground execution to
-   * background execution.
-   *
-   * <p>Invoked when the {@link FlutterView} connected to the given {@link FlutterNativeView} is
-   * destroyed.
-   *
-   * <p>Returns true if the given {@code nativeView} was successfully stored by this plugin, or
-   * false if a different {@link FlutterNativeView} was already registered with this plugin.
-   */
-  @Override
-  public boolean onViewDestroy(FlutterNativeView nativeView) {
-    return AlarmService.setBackgroundFlutterView(nativeView);
-  }
-
   /** A request to schedule a one-shot Dart task. */
   static final class OneShotRequest {
     static OneShotRequest fromJson(JSONArray json) throws JSONException {
diff --git a/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/FlutterBackgroundExecutor.java b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/FlutterBackgroundExecutor.java
new file mode 100644
index 0000000..c7eebc2
--- /dev/null
+++ b/packages/android_alarm_manager/android/src/main/java/io/flutter/plugins/androidalarmmanager/FlutterBackgroundExecutor.java
@@ -0,0 +1,236 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.androidalarmmanager;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.AssetManager;
+import android.util.Log;
+import io.flutter.embedding.engine.FlutterEngine;
+import io.flutter.embedding.engine.dart.DartExecutor;
+import io.flutter.embedding.engine.dart.DartExecutor.DartCallback;
+import io.flutter.embedding.engine.plugins.shim.ShimPluginRegistry;
+import io.flutter.plugin.common.BinaryMessenger;
+import io.flutter.plugin.common.JSONMethodCodec;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
+import io.flutter.plugin.common.MethodChannel.Result;
+import io.flutter.plugin.common.PluginRegistry.PluginRegistrantCallback;
+import io.flutter.view.FlutterCallbackInformation;
+import io.flutter.view.FlutterMain;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * An background execution abstraction which handles initializing a background isolate running a
+ * callback dispatcher, used to invoke Dart callbacks while backgrounded.
+ */
+public class FlutterBackgroundExecutor implements MethodCallHandler {
+  private static final String TAG = "FlutterBackgroundExecutor";
+  private static final String CALLBACK_HANDLE_KEY = "callback_handle";
+  private static PluginRegistrantCallback pluginRegistrantCallback;
+
+  /**
+   * The {@link MethodChannel} that connects the Android side of this plugin with the background
+   * Dart isolate that was created by this plugin.
+   */
+  private MethodChannel backgroundChannel;
+
+  private FlutterEngine backgroundFlutterEngine;
+
+  private AtomicBoolean isCallbackDispatcherReady = new AtomicBoolean(false);
+
+  /**
+   * Sets the {@code PluginRegistrantCallback} used to register plugins with the newly spawned
+   * isolate.
+   *
+   * <p>Note: this is only necessary for applications using the V1 engine embedding API as plugins
+   * are automatically registered via reflection in the V2 engine embedding API. If not set, alarm
+   * callbacks will not be able to utilize functionality from other plugins.
+   */
+  public static void setPluginRegistrant(PluginRegistrantCallback callback) {
+    pluginRegistrantCallback = callback;
+  }
+
+  /**
+   * Sets the Dart callback handle for the Dart method that is responsible for initializing the
+   * background Dart isolate, preparing it to receive Dart callback tasks requests.
+   */
+  public static void setCallbackDispatcher(Context context, long callbackHandle) {
+    SharedPreferences prefs = context.getSharedPreferences(AlarmService.SHARED_PREFERENCES_KEY, 0);
+    prefs.edit().putLong(CALLBACK_HANDLE_KEY, callbackHandle).apply();
+  }
+
+  /** Returns true when the background isolate has started and is ready to handle alarms. */
+  public boolean isRunning() {
+    return isCallbackDispatcherReady.get();
+  }
+
+  private void onInitialized() {
+    isCallbackDispatcherReady.set(true);
+    AlarmService.onInitialized();
+  }
+
+  @Override
+  public void onMethodCall(MethodCall call, Result result) {
+    String method = call.method;
+    Object arguments = call.arguments;
+    try {
+      if (method.equals("AlarmService.initialized")) {
+        // This message is sent by the background method channel as soon as the background isolate
+        // is running. From this point forward, the Android side of this plugin can send
+        // callback handles through the background method channel, and the Dart side will execute
+        // the Dart methods corresponding to those callback handles.
+        onInitialized();
+        result.success(true);
+      } else {
+        result.notImplemented();
+      }
+    } catch (PluginRegistrantException e) {
+      result.error("error", "AlarmManager error: " + e.getMessage(), null);
+    }
+  }
+
+  /**
+   * Starts running a background Dart isolate within a new {@link FlutterEngine} using a previously
+   * used entrypoint.
+   *
+   * <p>The isolate is configured as follows:
+   *
+   * <ul>
+   *   <li>Bundle Path: {@code FlutterMain.findAppBundlePath(context)}.
+   *   <li>Entrypoint: The Dart method used the last time this plugin was initialized in the
+   *       foreground.
+   *   <li>Run args: none.
+   * </ul>
+   *
+   * <p>Preconditions:
+   *
+   * <ul>
+   *   <li>The given callback must correspond to a registered Dart callback. If the handle does not
+   *       resolve to a Dart callback then this method does nothing.
+   *   <li>A static {@link #pluginRegistrantCallback} must exist, otherwise a {@link
+   *       PluginRegistrantException} will be thrown.
+   * </ul>
+   */
+  public void startBackgroundIsolate(Context context) {
+    if (!isRunning()) {
+      SharedPreferences p = context.getSharedPreferences(AlarmService.SHARED_PREFERENCES_KEY, 0);
+      long callbackHandle = p.getLong(CALLBACK_HANDLE_KEY, 0);
+      startBackgroundIsolate(context, callbackHandle);
+    }
+  }
+
+  /**
+   * Starts running a background Dart isolate within a new {@link FlutterEngine}.
+   *
+   * <p>The isolate is configured as follows:
+   *
+   * <ul>
+   *   <li>Bundle Path: {@code FlutterMain.findAppBundlePath(context)}.
+   *   <li>Entrypoint: The Dart method represented by {@code callbackHandle}.
+   *   <li>Run args: none.
+   * </ul>
+   *
+   * <p>Preconditions:
+   *
+   * <ul>
+   *   <li>The given {@code callbackHandle} must correspond to a registered Dart callback. If the
+   *       handle does not resolve to a Dart callback then this method does nothing.
+   *   <li>A static {@link #pluginRegistrantCallback} must exist, otherwise a {@link
+   *       PluginRegistrantException} will be thrown.
+   * </ul>
+   */
+  public void startBackgroundIsolate(Context context, long callbackHandle) {
+    if (backgroundFlutterEngine != null) {
+      Log.e(TAG, "Background isolate already started");
+      return;
+    }
+
+    FlutterCallbackInformation flutterCallback =
+        FlutterCallbackInformation.lookupCallbackInformation(callbackHandle);
+    if (flutterCallback == null) {
+      Log.e(TAG, "Fatal: failed to find callback");
+      return;
+    }
+    Log.i(TAG, "Starting AlarmService...");
+    String appBundlePath = FlutterMain.findAppBundlePath(context);
+    AssetManager assets = context.getAssets();
+    if (appBundlePath != null && !isRunning()) {
+      backgroundFlutterEngine = new FlutterEngine(context);
+      DartExecutor executor = backgroundFlutterEngine.getDartExecutor();
+      initializeMethodChannel(executor);
+      DartCallback dartCallback = new DartCallback(assets, appBundlePath, flutterCallback);
+
+      executor.executeDartCallback(dartCallback);
+
+      // The pluginRegistrantCallback should only be set in the V1 embedding as
+      // plugin registration is done via reflection in the V2 embedding.
+      if (pluginRegistrantCallback != null) {
+        pluginRegistrantCallback.registerWith(new ShimPluginRegistry(backgroundFlutterEngine));
+      }
+    }
+  }
+
+  /**
+   * Executes the desired Dart callback in a background Dart isolate.
+   *
+   * <p>The given {@code intent} should contain a {@code long} extra called "callbackHandle", which
+   * corresponds to a callback registered with the Dart VM.
+   */
+  public void executeDartCallbackInBackgroundIsolate(Intent intent, final CountDownLatch latch) {
+    // Grab the handle for the callback associated with this alarm. Pay close
+    // attention to the type of the callback handle as storing this value in a
+    // variable of the wrong size will cause the callback lookup to fail.
+    long callbackHandle = intent.getLongExtra("callbackHandle", 0);
+
+    // If another thread is waiting, then wake that thread when the callback returns a result.
+    MethodChannel.Result result = null;
+    if (latch != null) {
+      result =
+          new MethodChannel.Result() {
+            @Override
+            public void success(Object result) {
+              latch.countDown();
+            }
+
+            @Override
+            public void error(String errorCode, String errorMessage, Object errorDetails) {
+              latch.countDown();
+            }
+
+            @Override
+            public void notImplemented() {
+              latch.countDown();
+            }
+          };
+    }
+
+    // Handle the alarm event in Dart. Note that for this plugin, we don't
+    // care about the method name as we simply lookup and invoke the callback
+    // provided.
+    backgroundChannel.invokeMethod(
+        "invokeAlarmManagerCallback",
+        new Object[] {callbackHandle, intent.getIntExtra("id", -1)},
+        result);
+  }
+
+  private void initializeMethodChannel(BinaryMessenger isolate) {
+    // backgroundChannel is the channel responsible for receiving the following messages from
+    // the background isolate that was setup by this plugin:
+    // - "AlarmService.initialized"
+    //
+    // This channel is also responsible for sending requests from Android to Dart to execute Dart
+    // callbacks in the background isolate.
+    backgroundChannel =
+        new MethodChannel(
+            isolate,
+            "plugins.flutter.io/android_alarm_manager_background",
+            JSONMethodCodec.INSTANCE);
+    backgroundChannel.setMethodCallHandler(this);
+  }
+}
diff --git a/packages/android_alarm_manager/example/android/app/src/androidTest/java/io/plugins/androidalarmmanager/MainActivityTest.java b/packages/android_alarm_manager/example/android/app/src/androidTest/java/io/plugins/androidalarmmanager/MainActivityTest.java
new file mode 100644
index 0000000..6b69d39
--- /dev/null
+++ b/packages/android_alarm_manager/example/android/app/src/androidTest/java/io/plugins/androidalarmmanager/MainActivityTest.java
@@ -0,0 +1,15 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.androidalarmmanagerexample;
+
+import androidx.test.rule.ActivityTestRule;
+import dev.flutter.plugins.e2e.FlutterRunner;
+import org.junit.Rule;
+import org.junit.runner.RunWith;
+
+@RunWith(FlutterRunner.class)
+public class MainActivityTest {
+  @Rule public ActivityTestRule<MainActivity> rule = new ActivityTestRule<>(MainActivity.class);
+}
diff --git a/packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml b/packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml
index 7d87c6e..c67a8dd 100644
--- a/packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml
+++ b/packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml
@@ -10,15 +10,21 @@
         android:label="android_alarm_manager_example"
         android:icon="@mipmap/ic_launcher">
         <activity
+          android:name="io.flutter.plugins.androidalarmmanagerexample.EmbeddingV1Activity"
+          android:launchMode="singleTop"
+          android:theme="@style/LaunchTheme"
+          android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection"
+          android:hardwareAccelerated="true"
+          android:windowSoftInputMode="adjustResize"
+          android:exported="true">
+        </activity>
+        <activity
             android:name=".MainActivity"
             android:launchMode="singleTop"
             android:theme="@style/LaunchTheme"
             android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale"
             android:hardwareAccelerated="true"
             android:windowSoftInputMode="adjustResize">
-            <meta-data
-                android:name="io.flutter.app.android.SplashScreenUntilFirstFrame"
-                android:value="true" />
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
diff --git a/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/EmbeddingV1Activity.java b/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/EmbeddingV1Activity.java
new file mode 100644
index 0000000..17a37b8
--- /dev/null
+++ b/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/EmbeddingV1Activity.java
@@ -0,0 +1,19 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.androidalarmmanagerexample;
+
+import android.os.Bundle;
+import io.flutter.app.FlutterActivity;
+import io.flutter.plugins.GeneratedPluginRegistrant;
+
+public class EmbeddingV1Activity extends FlutterActivity {
+  public static final String TAG = "AlarmExampleMainActivity";
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    GeneratedPluginRegistrant.registerWith(this);
+  }
+}
diff --git a/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/MainActivity.java b/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/MainActivity.java
index 3d9afa5..2c80708 100644
--- a/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/MainActivity.java
+++ b/packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/MainActivity.java
@@ -1,15 +1,24 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
 package io.flutter.plugins.androidalarmmanagerexample;
 
-import android.os.Bundle;
-import io.flutter.app.FlutterActivity;
-import io.flutter.plugins.GeneratedPluginRegistrant;
+import dev.flutter.plugins.e2e.E2EPlugin;
+import io.flutter.embedding.android.FlutterActivity;
+import io.flutter.embedding.engine.FlutterEngine;
+import io.flutter.embedding.engine.plugins.shim.ShimPluginRegistry;
+import io.flutter.plugins.androidalarmmanager.AndroidAlarmManagerPlugin;
+import io.flutter.plugins.pathprovider.PathProviderPlugin;
 
 public class MainActivity extends FlutterActivity {
-  public static final String TAG = "AlarmExampleMainActivity";
-
+  // TODO(bkonyi): Remove this once v2 of GeneratedPluginRegistrant rolls to stable. https://github.com/flutter/flutter/issues/42694
   @Override
-  protected void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-    GeneratedPluginRegistrant.registerWith(this);
+  public void configureFlutterEngine(FlutterEngine flutterEngine) {
+    ShimPluginRegistry shimPluginRegistry = new ShimPluginRegistry(flutterEngine);
+    flutterEngine.getPlugins().add(new AndroidAlarmManagerPlugin());
+    flutterEngine.getPlugins().add(new E2EPlugin());
+    PathProviderPlugin.registerWith(
+        shimPluginRegistry.registrarFor("io.flutter.plugins.pathprovider.PathProviderPlugin"));
   }
 }
diff --git a/packages/android_alarm_manager/example/android/gradle.properties b/packages/android_alarm_manager/example/android/gradle.properties
index 53ae0ae..b6e61b6 100644
--- a/packages/android_alarm_manager/example/android/gradle.properties
+++ b/packages/android_alarm_manager/example/android/gradle.properties
@@ -1,3 +1,4 @@
 android.enableJetifier=true
 android.useAndroidX=true
 org.gradle.jvmargs=-Xmx1536M
+android.enableR8=true
diff --git a/packages/android_alarm_manager/example/android/settings_aar.gradle b/packages/android_alarm_manager/example/android/settings_aar.gradle
new file mode 100644
index 0000000..e7b4def
--- /dev/null
+++ b/packages/android_alarm_manager/example/android/settings_aar.gradle
@@ -0,0 +1 @@
+include ':app'
diff --git a/packages/android_alarm_manager/example/lib/main.dart b/packages/android_alarm_manager/example/lib/main.dart
index 5e20364..12aad9b 100644
--- a/packages/android_alarm_manager/example/lib/main.dart
+++ b/packages/android_alarm_manager/example/lib/main.dart
@@ -18,6 +18,8 @@
   final int periodicID = 0;
   final int oneShotID = 1;
 
+  WidgetsFlutterBinding.ensureInitialized();
+
   // Start the AlarmManager service.
   await AndroidAlarmManager.initialize();
 
@@ -27,7 +29,7 @@
           Text('See device log for output', textDirection: TextDirection.ltr)));
   await AndroidAlarmManager.periodic(
       const Duration(seconds: 5), periodicID, printPeriodic,
-      wakeup: true);
+      wakeup: true, exact: true);
   await AndroidAlarmManager.oneShot(
       const Duration(seconds: 5), oneShotID, printOneShot);
 }
diff --git a/packages/android_alarm_manager/example/pubspec.yaml b/packages/android_alarm_manager/example/pubspec.yaml
index 392c03d..3046f16 100644
--- a/packages/android_alarm_manager/example/pubspec.yaml
+++ b/packages/android_alarm_manager/example/pubspec.yaml
@@ -6,8 +6,13 @@
     sdk: flutter
   android_alarm_manager:
     path: ../
+  e2e: ^0.2.1
+  path_provider: ^1.3.1
+
 
 dev_dependencies:
+  flutter_driver:
+    sdk: flutter
   flutter_test:
     sdk: flutter
 
diff --git a/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e.dart b/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e.dart
new file mode 100644
index 0000000..8359bfd
--- /dev/null
+++ b/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e.dart
@@ -0,0 +1,101 @@
+// Copyright 2019, the Chromium project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+import 'package:android_alarm_manager/android_alarm_manager.dart';
+import 'package:e2e/e2e.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path_provider/path_provider.dart';
+
+// From https://flutter.dev/docs/cookbook/persistence/reading-writing-files
+Future<String> get _localPath async {
+  final Directory directory = await getTemporaryDirectory();
+  return directory.path;
+}
+
+Future<File> get _localFile async {
+  final String path = await _localPath;
+  return File('$path/counter.txt');
+}
+
+Future<File> writeCounter(int counter) async {
+  final File file = await _localFile;
+
+  // Write the file.
+  return file.writeAsString('$counter');
+}
+
+Future<int> readCounter() async {
+  try {
+    final File file = await _localFile;
+
+    // Read the file.
+    final String contents = await file.readAsString();
+
+    return int.parse(contents);
+    // ignore: unused_catch_clause
+  } on FileSystemException catch (e) {
+    // If encountering an error, return 0.
+    return 0;
+  }
+}
+
+Future<void> incrementCounter() async {
+  final int value = await readCounter();
+  print('incrementCounter to: ${value + 1}');
+  await writeCounter(value + 1);
+}
+
+void main() {
+  E2EWidgetsFlutterBinding.ensureInitialized();
+
+  print('main');
+  setUp(() async {
+    await AndroidAlarmManager.initialize();
+  });
+
+  group('oneshot', () {
+    testWidgets('cancelled before it fires', (WidgetTester tester) async {
+      final int alarmId = 0;
+      final int startingValue = await readCounter();
+      await AndroidAlarmManager.oneShot(
+          const Duration(seconds: 1), alarmId, incrementCounter);
+      expect(await AndroidAlarmManager.cancel(alarmId), isTrue);
+      await Future<void>.delayed(const Duration(seconds: 4));
+      expect(await readCounter(), startingValue);
+    });
+
+    testWidgets('cancelled after it fires', (WidgetTester tester) async {
+      final int alarmId = 1;
+      final int startingValue = await readCounter();
+      await AndroidAlarmManager.oneShot(
+          const Duration(seconds: 1), alarmId, incrementCounter,
+          exact: true, wakeup: true);
+      await Future<void>.delayed(const Duration(seconds: 2));
+      // poll until file is updated
+      while (await readCounter() == startingValue) {
+        await Future<void>.delayed(const Duration(seconds: 1));
+      }
+      expect(await readCounter(), startingValue + 1);
+      expect(await AndroidAlarmManager.cancel(alarmId), isTrue);
+    });
+  });
+
+  testWidgets('periodic', (WidgetTester tester) async {
+    final int alarmId = 2;
+    final int startingValue = await readCounter();
+    await AndroidAlarmManager.periodic(
+        const Duration(seconds: 1), alarmId, incrementCounter,
+        wakeup: true, exact: true);
+    // poll until file is updated
+    while (await readCounter() < startingValue + 2) {
+      await Future<void>.delayed(const Duration(seconds: 1));
+    }
+    expect(await readCounter(), startingValue + 2);
+    expect(await AndroidAlarmManager.cancel(alarmId), isTrue);
+    await Future<void>.delayed(const Duration(seconds: 3));
+    expect(await readCounter(), startingValue + 2);
+  });
+}
diff --git a/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e_test.dart b/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e_test.dart
new file mode 100644
index 0000000..eea5e8a
--- /dev/null
+++ b/packages/android_alarm_manager/example/test_driver/android_alarm_manager_e2e_test.dart
@@ -0,0 +1,41 @@
+// Copyright 2019, the Chromium project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter_driver/flutter_driver.dart';
+import 'package:vm_service_client/vm_service_client.dart';
+
+Future<StreamSubscription<VMIsolateRef>> resumeIsolatesOnPause(
+    FlutterDriver driver) async {
+  final VM vm = await driver.serviceClient.getVM();
+  for (VMIsolateRef isolateRef in vm.isolates) {
+    final VMIsolate isolate = await isolateRef.load();
+    if (isolate.isPaused) {
+      await isolate.resume();
+    }
+  }
+  return driver.serviceClient.onIsolateRunnable
+      .asBroadcastStream()
+      .listen((VMIsolateRef isolateRef) async {
+    final VMIsolate isolate = await isolateRef.load();
+    if (isolate.isPaused) {
+      await isolate.resume();
+    }
+  });
+}
+
+Future<void> main() async {
+  final FlutterDriver driver = await FlutterDriver.connect();
+  // flutter drive causes isolates to be paused on spawn. The background isolate
+  // for this plugin will need to be resumed for the test to pass.
+  final StreamSubscription<VMIsolateRef> subscription =
+      await resumeIsolatesOnPause(driver);
+  final String result =
+      await driver.requestData(null, timeout: const Duration(minutes: 5));
+  await driver.close();
+  await subscription.cancel();
+  exit(result == 'pass' ? 0 : 1);
+}
diff --git a/packages/android_alarm_manager/lib/android_alarm_manager.dart b/packages/android_alarm_manager/lib/android_alarm_manager.dart
index f31b4bc..b8afa13 100644
--- a/packages/android_alarm_manager/lib/android_alarm_manager.dart
+++ b/packages/android_alarm_manager/lib/android_alarm_manager.dart
@@ -13,17 +13,16 @@
     'plugins.flutter.io/android_alarm_manager_background';
 
 // This is the entrypoint for the background isolate. Since we can only enter
-// an isolate once, we setup a MethodChannel to listen for method invokations
+// an isolate once, we setup a MethodChannel to listen for method invocations
 // from the native portion of the plugin. This allows for the plugin to perform
 // any necessary processing in Dart (e.g., populating a custom object) before
 // invoking the provided callback.
 void _alarmManagerCallbackDispatcher() {
-  const MethodChannel _channel =
-      MethodChannel(_backgroundName, JSONMethodCodec());
-
-  // Setup Flutter state needed for MethodChannels.
+  // Initialize state necessary for MethodChannels.
   WidgetsFlutterBinding.ensureInitialized();
 
+  const MethodChannel _channel =
+      MethodChannel(_backgroundName, JSONMethodCodec());
   // This is where the magic happens and we handle background events from the
   // native portion of the plugin.
   _channel.setMethodCallHandler((MethodCall call) async {
diff --git a/packages/android_alarm_manager/pubspec.yaml b/packages/android_alarm_manager/pubspec.yaml
index 29a9961..9239fa4 100644
--- a/packages/android_alarm_manager/pubspec.yaml
+++ b/packages/android_alarm_manager/pubspec.yaml
@@ -1,7 +1,7 @@
 name: android_alarm_manager
 description: Flutter plugin for accessing the Android AlarmManager service, and
   running Dart code in the background when alarms fire.
-version: 0.4.4+3
+version: 0.4.5
 author: Flutter Team <flutter-dev@googlegroups.com>
 homepage: https://github.com/flutter/plugins/tree/master/packages/android_alarm_manager
 
@@ -15,10 +15,12 @@
 
 flutter:
   plugin:
-    androidPackage: io.flutter.plugins.androidalarmmanager
-    pluginClass: AndroidAlarmManagerPlugin
-    iosPrefix: FLT
+    platforms:
+      android:
+        package: io.flutter.plugins.androidalarmmanager
+        pluginClass: AndroidAlarmManagerPlugin
 
 environment:
   sdk: ">=2.0.0-dev.28.0 <3.0.0"
+  # TODO(bkonyi): set minimum Flutter version to next stable release
   flutter: ">=1.2.0 <2.0.0"