app, cmd/gogio: add android foreground permission and service

This adds the permission android.permission.FOREGROUND_SERVICE and adds
GioForegroundService which creates the tray Notification necessary to
implement the Foreground Service. The package foreground includes the method
Start, which on android, notifies the system that the program
will perform background work and that it shouldn't be killed. It returns
a channel that should be closed when the background work is complete.

See https://developer.android.com/guide/components/foreground-services
and https://developer.android.com/training/notify-user/build-notification

Signed-off-by: Masala <[email protected]>

Author: mixmasala

app/GioForegroundService.java

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package org.gioui;
+import android.app.Notification;
+import android.app.Service;
+import android.app.Notification;
+import android.app.Notification.Builder;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+
+// GioForegroundService implements a Service required to use the FOREGROUND_SERVICE
+// permission on Android, in order to run an application in the background.
+// See https://developer.android.com/guide/components/foreground-services for
+// more details. To add this permission to your application, import
+// gioui.org/app/permission/foreground and use the Start method from that
+// package to control this service.
+public class GioForegroundService extends Service {
+	private String channelID;
+	private String channelName;
+	private String channelDesc;
+	private int notificationID = 0x42424242;
+
+	@Override public int onStartCommand (Intent intent, int flags, int startId) {
+		// get the channel parameters from intent extras
+		channelID   = intent.getStringExtra("channelID");
+		channelName = intent.getStringExtra("channelName");
+		channelDesc = intent.getStringExtra("channelDesc");
+		notificationID = intent.getIntExtra("notificationID", notificationID);
+		this.createNotificationChannel();
+
+		// create the Intent that will bring GioActivity to foreground
+		Context ctx = getApplicationContext();
+		Intent resultIntent = new Intent(ctx, GioActivity.class);
+		PendingIntent pending = PendingIntent.getActivity(ctx, notificationID, resultIntent, Intent.FLAG_ACTIVITY_CLEAR_TASK);
+		// create the Notification that Android will display on the tray for this service
+		Notification.Builder builder = new Notification.Builder(ctx, channelID)
+			.setContentTitle(channelName)
+			.setSmallIcon(getResources().getIdentifier("@mipmap/ic_launcher_adaptive", "drawable", getPackageName()))
+			.setContentText(channelDesc)
+			.setContentIntent(pending)
+			.setPriority(Notification.PRIORITY_MIN);
+		startForeground(notificationID, builder.build());
+		return START_NOT_STICKY;
+	}
+
+	@Override public IBinder onBind(Intent intent) {
+		return null;
+	}
+
+	@Override public void onCreate() {
+		super.onCreate();
+	}
+
+	@Override
+	public void onTaskRemoved(Intent rootIntent) {
+		super.onTaskRemoved(rootIntent);
+		this.deleteNotificationChannel();
+		stopForeground(true);
+		this.stopSelf();
+	}
+
+	@Override public void onDestroy() {
+		this.deleteNotificationChannel();
+	}
+
+	private void deleteNotificationChannel() {
+		NotificationManager notificationManager = getSystemService(NotificationManager.class);
+		notificationManager.deleteNotificationChannel(channelName);
+	}
+
+	private void createNotificationChannel() {
+		// https://developer.android.com/training/notify-user/build-notification#java
+		NotificationChannel channel = new NotificationChannel(channelID, channelName, NotificationManager.IMPORTANCE_LOW);
+		channel.setDescription(channelDesc);
+		NotificationManager notificationManager = getSystemService(NotificationManager.class);
+		notificationManager.createNotificationChannel(channel);
+	}
+}

app/os_android.go

@@ -40,6 +40,14 @@ static jclass jni_GetObjectClass(JNIEnv *env, jobject obj) {
 	return (*env)->GetObjectClass(env, obj);
 }
 
+static jclass jni_FindClass(JNIEnv *env, const char *name) {
+	return (*env)->FindClass(env, name);
+}
+
+static jobject jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID) {
+	return (*env)->NewObject(env, clazz, methodID);
+}
+
 static jmethodID jni_GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig) {
 	return (*env)->GetMethodID(env, clazz, name, sig);
 }
@@ -131,6 +139,8 @@ import (
 	"gioui.org/unit"
 )
 
+const foregroundService = "org/gioui/GioForegroundService"
+
 type window struct {
 	callbacks *callbacks
 
@@ -774,6 +784,59 @@ func getObjectClass(env *C.JNIEnv, obj C.jobject) C.jclass {
 	return cls
 }
 
+// getIntent loads class and returns an android.content.Intent or error
+func getIntent(env *C.JNIEnv, obj C.jobject, class string) (C.jobject, error) {
+	cls := getObjectClass(env, obj) // android.app.Application
+	getClassLoader := getMethodID(env, cls, "getClassLoader", "()Ljava/lang/ClassLoader;")
+	ldr, err := callObjectMethod(env, obj, getClassLoader)
+	if err != nil {
+		return 0, err
+	}
+	loadClassMethod := getMethodID(env, getObjectClass(env, ldr), "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;")
+	loaded, err := callObjectMethod(env, ldr, loadClassMethod, jvalue(javaString(env, class)))
+	if err != nil {
+		return 0, err
+	}
+	c := C.CString("android/content/Intent")
+	defer C.free(unsafe.Pointer(c))
+	intentClass := C.jni_FindClass(env, c)
+	if err := exception(env); err != nil {
+		return 0, err
+	}
+	intentInit := getMethodID(env, intentClass, "<init>", "()V")
+	intent := C.jni_NewObject(env, intentClass, intentInit)
+	setClassMethod := getMethodID(env, intentClass, "setClass", "(Landroid/content/Context;Ljava/lang/Class;)Landroid/content/Intent;")
+	_, err = callObjectMethod(env, intent, setClassMethod, jvalue(obj), jvalue(C.jclass(loaded)))
+	if err != nil {
+		return 0, err
+	}
+
+	return intent, nil
+}
+
+// setforegroundIntentExtras adds the notification text to the intent.
+func setforegroundIntentExtras(env *C.JNIEnv, intent C.jobject, id int, name, desc string) {
+	cls := getObjectClass(env, intent)
+	putExtraStringMethod := getMethodID(env, cls, "putExtra", "(Ljava/lang/String;Ljava/lang/String;)Landroid/content/Intent;")
+	putExtraIntMethod := getMethodID(env, cls, "putExtra", "(Ljava/lang/String;I)Landroid/content/Intent;")
+	_, err := callObjectMethod(env, intent, putExtraStringMethod, jvalue(javaString(env, "channelID")), jvalue(javaString(env, name)))
+	if err != nil {
+		panic(err)
+	}
+	_, err = callObjectMethod(env, intent, putExtraStringMethod, jvalue(javaString(env, "channelName")), jvalue(javaString(env, name)))
+	if err != nil {
+		panic(err)
+	}
+	_, err = callObjectMethod(env, intent, putExtraStringMethod, jvalue(javaString(env, "channelDesc")), jvalue(javaString(env, desc)))
+	if err != nil {
+		panic(err)
+	}
+	_, err = callObjectMethod(env, intent, putExtraIntMethod, jvalue(javaString(env, "notificationID")), jvalue(id))
+	if err != nil {
+		panic(err)
+	}
+}
+
 // goString converts the JVM jstring to a Go string.
 func goString(env *C.JNIEnv, str C.jstring) string {
 	if str == 0 {
@@ -951,3 +1014,45 @@ func Java_org_gioui_Gio_scheduleMainFuncs(env *C.JNIEnv, cls C.jclass) {
 }
 
 func (_ ViewEvent) ImplementsEvent() {}
+
+// start a foreground service
+func Java_org_gioui_StartForeground(id int, title, text string) (chan struct{}, error) {
+	closeChan := make(chan struct{})
+	errChan := make(chan error)
+
+	// get a handle on the startService, stopService methods of GioForegroundService
+	// run everything in a goroutine so that start/stop calls are from the same thread
+	go func() {
+		runInJVM(javaVM(), func(env *C.JNIEnv) {
+			// create an intent and set it to the foregroundService
+			intent, err := getIntent(env, android.appCtx, foregroundService)
+			if err != nil {
+				errChan <- err
+				return
+			}
+
+			// set the notification text
+			setforegroundIntentExtras(env, intent, id, title, text)
+
+			// locate the methods to start and stop our service
+			cls := getObjectClass(env, android.appCtx)
+			startServiceMethod := getMethodID(env, cls, "startService", "(Landroid/content/Intent;)Landroid/content/ComponentName;")
+			stopServiceMethod := getMethodID(env, cls, "stopService", "(Landroid/content/Intent;)Z")
+
+			// Call startService with the above intent
+			_, err = callObjectMethod(env, android.appCtx, startServiceMethod, jvalue(intent))
+			if err != nil {
+				errChan <- err
+				return
+			}
+
+			// wait for the channel to close, and then halt the foreground service
+			// create an intent and set it to the foregroundService
+			errChan <- nil
+			<-closeChan
+			callVoidMethod(env, android.appCtx, stopServiceMethod, jvalue(intent))
+		})
+	}()
+
+	return closeChan, <-errChan
+}

app/permission/foreground/android.go

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+//+build android
+
+/*
+Package foreground implements permissions to run a foreground service.
+See https://developer.android.com/guide/components/foreground-services.
+
+The following entries will be added to AndroidManifest.xml:
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+
+*/
+
+package foreground
+
+import (
+	"gioui.org/app"
+)
+
+func start(id int, title, text string) (chan struct{}, error) {
+	return app.Java_org_gioui_StartForeground(id, title, text)
+}

app/permission/foreground/main.go

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+/*
+Package foreground implements permissions to run a foreground service.
+See https://developer.android.com/guide/components/foreground-services.
+
+The following entries will be added to AndroidManifest.xml:
+
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+
+*/
+
+package foreground
+
+// Start notifies the system that the program will perform
+// background work and that it shouldn't be killed. It returns a channel
+// that should be closed when the background work is complete.
+
+// Start is a no-op on Linux, Windows, macOS; Android will
+// display a notification during background work; iOS isn't supported.
+func Start(id int, title, text string) (chan struct{}, error) {
+	return start(id, title, text)
+}

app/permission/foreground/other.go

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+//+build !android
+
+package foreground
+
+func start(id int, title, text string) (chan struct{}, error) {
+	return nil, nil
+}

cmd/gogio/androidbuild.go

@@ -49,6 +49,7 @@ type manifestData struct {
 	Features    []string
 	IconSnip    string
 	AppName     string
+	HasService  bool
 }
 
 const (
@@ -68,6 +69,7 @@ const (
 		<item name="android:statusBarColor">#40000000</item>
 	</style>
 </resources>`
+	foregroundPermission = "android.permission.FOREGROUND_SERVICE"
 )
 
 func init() {
@@ -446,6 +448,7 @@ func exeAndroid(tmpDir string, tools *androidTools, bi *buildInfo, extraJars, pe
 		Features:    features,
 		IconSnip:    iconSnip,
 		AppName:     appName,
+		HasService:  hasForegroundPermission(permissions),
 	}
 	tmpl, err := template.New("test").Parse(
 		`<?xml version="1.0" encoding="utf-8"?>
@@ -467,6 +470,11 @@ func exeAndroid(tmpDir string, tools *androidTools, bi *buildInfo, extraJars, pe
 				<category android:name="android.intent.category.LAUNCHER" />
 			</intent-filter>
 		</activity>
+		{{if .HasService}}
+		<service android:name="org.gioui.GioForegroundService"
+			android:stopWithTask="true">
+		</service>
+		{{end}}
 	</application>
 </manifest>`)
 	var manifestBuffer bytes.Buffer
@@ -867,6 +875,15 @@ func getPermissions(ps []string) ([]string, []string) {
 	return permissions, features
 }
 
+func hasForegroundPermission(permissions []string) bool {
+	for _, p := range permissions {
+		if p == foregroundPermission {
+			return true
+		}
+	}
+	return false
+}
+
 func latestPlatform(sdk string) (string, error) {
 	allPlats, err := filepath.Glob(filepath.Join(sdk, "platforms", "android-*"))
 	if err != nil {

cmd/gogio/permission.go

@@ -19,6 +19,9 @@ var AndroidPermissions = map[string][]string{
 		"android.permission.READ_EXTERNAL_STORAGE",
 		"android.permission.WRITE_EXTERNAL_STORAGE",
 	},
+	"foreground": {
+		"android.permission.FOREGROUND_SERVICE",
+	},
 }
 
 var AndroidFeatures = map[string][]string{