[android_alarm_manager] Added Espresso test for background execution

packages/android_alarm_manager/example/android/app/build.gradle

@@ -55,6 +55,8 @@ flutter {
 
 dependencies {
     testImplementation 'junit:junit:4.12'
+    testImplementation "com.google.truth:truth:1.0"
     androidTestImplementation 'androidx.test:runner:1.1.1'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+    api 'androidx.test:core:1.2.0'
 }

packages/android_alarm_manager/example/android/app/src/androidTest/java/io/plugins/androidalarmmanager/BackgroundExecutionTest.java

@@ -0,0 +1,62 @@
+// Copyright 2020 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 static androidx.test.espresso.Espresso.pressBackUnconditionally;
+import static androidx.test.espresso.flutter.EspressoFlutter.onFlutterWidget;
+import static androidx.test.espresso.flutter.action.FlutterActions.click;
+import static androidx.test.espresso.flutter.matcher.FlutterMatchers.withValueKey;
+import static org.junit.Assert.assertEquals;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.test.InstrumentationRegistry;
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.ActivityTestRule;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class BackgroundExecutionTest {
+  private SharedPreferences prefs;
+
+  @Rule
+  public ActivityTestRule<MainActivity> myActivityTestRule =
+      new ActivityTestRule<>(MainActivity.class, true, false);
+
+  @Before
+  public void setUp() throws Exception {
+    Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+    prefs = context.getSharedPreferences("FlutterSharedPreferences", Context.MODE_PRIVATE);
+    ActivityScenario.launch(MainActivity.class);
+  }
+
+  @Test
+  public void startBackgroundIsolate() throws Exception {
+    final String countKey = "flutter.count";
+
+    // Register a one shot alarm which will go off in ~5 seconds.
+    onFlutterWidget(withValueKey("RegisterOneShotAlarm")).perform(click());
+
+    // The alarm count should be 0 after installation.
+    assertEquals(prefs.getLong(countKey, -1), 0);
+
+    // Close the application to background it.
+    pressBackUnconditionally();
+
+    // The alarm should eventually fire, wake up the application, create a
+    // background isolate, and then increment the counter in the shared
+    // preferences. Timeout after 20s, just to be safe.
+    int tries = 0;
+    while ((prefs.getLong(countKey, -1) == 0) && (tries < 200)) {
+      Thread.sleep(100);
+      ++tries;
+    }
+    assertEquals(prefs.getLong(countKey, -1), 1);
+  }
+}

packages/android_alarm_manager/example/android/app/src/main/AndroidManifest.xml

@@ -8,7 +8,8 @@
     <application
         android:name=".Application"
         android:label="android_alarm_manager_example"
-        android:icon="@mipmap/ic_launcher">
+        android:icon="@mipmap/ic_launcher"
+        android:usesCleartextTraffic="true">
         <activity
           android:name="io.flutter.plugins.androidalarmmanagerexample.EmbeddingV1Activity"
           android:launchMode="singleTop"

packages/android_alarm_manager/example/android/app/src/main/java/io/flutter/plugins/androidalarmmanagerexample/MainActivity.java

@@ -10,6 +10,7 @@
 import io.flutter.embedding.engine.plugins.shim.ShimPluginRegistry;
 import io.flutter.plugins.androidalarmmanager.AndroidAlarmManagerPlugin;
 import io.flutter.plugins.pathprovider.PathProviderPlugin;
+import io.flutter.plugins.sharedpreferences.SharedPreferencesPlugin;
 
 public class MainActivity extends FlutterActivity {
   // TODO(bkonyi): Remove this once v2 of GeneratedPluginRegistrant rolls to stable. https://github.com/flutter/flutter/issues/42694
@@ -18,6 +19,7 @@ public void configureFlutterEngine(FlutterEngine flutterEngine) {
     ShimPluginRegistry shimPluginRegistry = new ShimPluginRegistry(flutterEngine);
     flutterEngine.getPlugins().add(new AndroidAlarmManagerPlugin());
     flutterEngine.getPlugins().add(new E2EPlugin());
+    flutterEngine.getPlugins().add(new SharedPreferencesPlugin());
     PathProviderPlugin.registerWith(
         shimPluginRegistry.registrarFor("io.flutter.plugins.pathprovider.PathProviderPlugin"));
   }

packages/android_alarm_manager/example/lib/main.dart

@@ -4,32 +4,154 @@
 
 // ignore_for_file: public_member_api_docs
 
-import 'dart:async';
+import 'dart:isolate';
+import 'dart:math';
+import 'dart:ui';
 
 import 'package:android_alarm_manager/android_alarm_manager.dart';
-import 'package:flutter/widgets.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:flutter/material.dart';
 
-void printMessage(String msg) => print('[${DateTime.now()}] $msg');
+/// The [SharedPreferences] key to access the alarm fire count.
+const String countKey = 'count';
 
-void printPeriodic() => printMessage("Periodic!");
-void printOneShot() => printMessage("One shot!");
+/// The name associated with the UI isolate's [SendPort].
+const String isolateName = 'isolate';
 
-Future<void> main() async {
-  final int periodicID = 0;
-  final int oneShotID = 1;
+/// A port used to communicate from a background isolate to the UI isolate.
+final ReceivePort port = ReceivePort();
+
+/// Global [SharedPreferences] object.
+SharedPreferences prefs;
 
+Future<void> main() async {
+  // TODO(bkonyi): uncomment
   WidgetsFlutterBinding.ensureInitialized();
 
-  // Start the AlarmManager service.
-  await AndroidAlarmManager.initialize();
-
-  printMessage("main run");
-  runApp(const Center(
-      child:
-          Text('See device log for output', textDirection: TextDirection.ltr)));
-  await AndroidAlarmManager.periodic(
-      const Duration(seconds: 5), periodicID, printPeriodic,
-      wakeup: true, exact: true);
-  await AndroidAlarmManager.oneShot(
-      const Duration(seconds: 5), oneShotID, printOneShot);
+  // Register the UI isolate's SendPort to allow for communication from the
+  // background isolate.
+  IsolateNameServer.registerPortWithName(
+    port.sendPort,
+    isolateName,
+  );
+  prefs = await SharedPreferences.getInstance();
+  if (!prefs.containsKey(countKey)) {
+    await prefs.setInt(countKey, 0);
+  }
+  runApp(AlarmManagerExampleApp());
+  print("hello world!");
+}
+
+/// Example app for Espresso plugin.
+class AlarmManagerExampleApp extends StatelessWidget {
+  // This widget is the root of your application.
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'Flutter Demo',
+      home: _AlarmHomePage(title: 'Flutter Demo Home Page'),
+    );
+  }
+}
+
+class _AlarmHomePage extends StatefulWidget {
+  _AlarmHomePage({Key key, this.title}) : super(key: key);
+  final String title;
+
+  @override
+  _AlarmHomePageState createState() => _AlarmHomePageState();
+}
+
+class _AlarmHomePageState extends State<_AlarmHomePage> {
+  int _counter = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    AndroidAlarmManager.initialize();
+
+    // Register for events from the background isolate. These messages will
+    // always coincide with an alarm firing.
+    port.listen((_) async => await _incrementCounter());
+  }
+
+  Future<void> _incrementCounter() async {
+    print('Increment counter!');
+
+    // Ensure we've loaded the updated count from the background isolate.
+    await prefs.reload();
+
+    setState(() {
+      _counter++;
+    });
+  }
+
+  // The background
+  static SendPort uiSendPort;
+
+  // The callback for our alarm
+  static Future<void> callback() async {
+    print('Alarm fired!');
+
+    // Get the previous cached count and increment it.
+    final prefs = await SharedPreferences.getInstance();
+    int currentCount = prefs.getInt(countKey);
+    await prefs.setInt(countKey, currentCount + 1);
+
+    // This will be null if we're running in the background.
+    uiSendPort ??= IsolateNameServer.lookupPortByName(isolateName);
+    uiSendPort?.send(null);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final textStyle = Theme.of(context).textTheme.display1;
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(widget.title),
+      ),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: <Widget>[
+            Text(
+              'Alarm fired $_counter times',
+              style: textStyle,
+            ),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.center,
+              children: <Widget>[
+                Text(
+                  'Total alarms fired: ',
+                  style: textStyle,
+                ),
+                Text(
+                  prefs.getInt(countKey).toString(),
+                  key: ValueKey('BackgroundCountText'),
+                  style: textStyle,
+                ),
+              ],
+            ),
+            RaisedButton(
+              child: Text(
+                'Schedule OneShot Alarm',
+              ),
+              key: ValueKey('RegisterOneShotAlarm'),
+              onPressed: () async {
+                print('Scheduling!');
+                await AndroidAlarmManager.oneShot(
+                  const Duration(seconds: 5),
+                  // Ensure we have a unique alarm ID.
+                  Random().nextInt(pow(2, 31)),
+                  callback,
+                  exact: true,
+                  wakeup: true,
+                );
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
 }

packages/android_alarm_manager/example/pubspec.yaml

@@ -6,11 +6,13 @@ dependencies:
     sdk: flutter
   android_alarm_manager:
     path: ../
+  shared_preferences: ^0.5.6
   e2e: ^0.2.1
   path_provider: ^1.3.1
 
 
 dev_dependencies:
+  espresso: ^0.0.1+1
   flutter_driver:
     sdk: flutter
   flutter_test:

packages/android_alarm_manager/example/test_driver/alarm_manager_test.dart

@@ -0,0 +1,8 @@
+import 'package:flutter_driver/driver_extension.dart';
+// ignore: avoid_relative_lib_import
+import '../lib/main.dart' as app;
+
+Future<void> main() async {
+  enableFlutterDriverExtension();
+  await app.main();
+}