niotify/android/notify_android.go

186 lines
6.8 KiB
Go
Raw Normal View History

2020-06-19 17:40:18 -04:00
package android
import (
"fmt"
"sync"
2020-06-19 17:40:18 -04:00
"gioui.org/app"
"git.wow.st/gmp/jni"
2020-06-19 17:40:18 -04:00
)
2020-06-20 12:20:38 -04:00
// Importance represents the priority of notifications sent over a particular NotificationChannel.
// You MUST use one of the constants defined here when specifying an importance for a channel.
// These constants map to different values within the JVM.
type Importance int
const (
ImportanceDefault Importance = iota
ImportanceHigh
ImportanceLow
ImportanceMax
ImportanceMin
ImportanceNone
ImportanceUnspecified
importanceEnd // compile-time hack to track the number of importance constants and size the
// array holding their values correctly. If new constants need to be added, add them above
// this.
)
// value returns the JVM value for this importance constant. It must not be invoked before the
// importances have been resolved.
func (i Importance) value() int32 {
return importances[i]
}
const (
helperClass = "ht/sr/git/whereswaldon/niotify/NotificationHelper"
importanceDefaultName = "IMPORTANCE_DEFAULT"
importanceHighName = "IMPORTANCE_HIGH"
importanceLowName = "IMPORTANCE_LOW"
importanceMaxName = "IMPORTANCE_MAX"
importanceMinName = "IMPORTANCE_MIN"
importanceNoneName = "IMPORTANCE_NONE"
importanceUnspecifiedName = "IMPORTANCE_UNSPECIFIED"
)
var (
// idlock protects the nextNotificationID to ensure that no notification is ever
// sent with a duplicate id.
//
2020-06-20 12:20:38 -04:00
// BUG(whereswaldon): Notification ID generation does not handle 32 bit integer
// overflow. Sending more than 2 billion notifications results in undefined
// behavior.
idlock sync.Mutex
nextNotificationID int32
// jvmConstLock protects the mapping of JVM constants that must be resolved at runtime
jvmConstLock sync.Once
// importances tracks the IMPORTANCE_* constants from the JVM's values. Since they must
// be resolved at runtime, this array tracks their actual runtime values and the exported
// constants are simply indicies into this array.
importances [importanceEnd]int32
// map the JVM constant name to the index in the array
importancesMap = map[string]Importance{
importanceDefaultName: ImportanceDefault,
importanceHighName: ImportanceHigh,
importanceLowName: ImportanceLow,
importanceMaxName: ImportanceMax,
importanceMinName: ImportanceMin,
importanceNoneName: ImportanceNone,
importanceUnspecifiedName: ImportanceUnspecified,
}
)
// nextID safely returns the next unused notification id number. This function should
// always be used to get a notificationID.
func nextID() int32 {
idlock.Lock()
defer idlock.Unlock()
id := nextNotificationID
nextNotificationID++
return id
}
// NotificationChannel represents a stream of notifications that an application
// provisions on android. Such streams can be selectively enabled and disabled
// by the user, and should be used for different purposes.
2020-06-19 17:40:18 -04:00
type NotificationChannel struct {
id string
2020-06-19 17:40:18 -04:00
}
// NewChannel creates a new notification channel identified by the provided id
2020-06-20 12:20:38 -04:00
// and with the given user-visible name and description. The importance field
// specifies how the android system should prioritize notifications sent over this
// channel, and the value provided MUST be one of the constants declared by this
// package. The actual value of the importance constant is translated into the
// java value at runtime.
func NewChannel(importance Importance, id, name, description string) (*NotificationChannel, error) {
if err := jni.Do(jni.JVMFor(app.JavaVM()), func(env jni.Env) error {
appCtx := jni.Object(app.AppContext())
classLoader := jni.ClassLoaderFor(env, appCtx)
notifyClass, err := jni.LoadClass(env, classLoader, helperClass)
2020-06-19 17:40:18 -04:00
if err != nil {
return err
}
jvmConstLock.Do(func() {
var managerClass jni.Class
managerClass, err = jni.LoadClass(env, classLoader, "android/app/NotificationManager")
if err != nil {
return
}
for name, index := range importancesMap {
fieldID := jni.GetStaticFieldID(env, managerClass, name, "I")
importances[index] = jni.GetStaticIntField(env, managerClass, fieldID)
}
})
newChannelMethod := jni.GetStaticMethodID(env, notifyClass, "newChannel", "(Landroid/content/Context;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;)V")
jname := jni.Value(jni.JavaString(env, name))
jdescription := jni.Value(jni.JavaString(env, description))
jID := jni.Value(jni.JavaString(env, id))
jimportance := jni.Value(importance.value())
err = jni.CallStaticVoidMethod(env, notifyClass, newChannelMethod, jni.Value(app.AppContext()), jimportance, jID, jname, jdescription)
if err != nil {
return err
}
return nil
2020-06-19 17:40:18 -04:00
}); err != nil {
return nil, fmt.Errorf("failed creating notification channel: %w", err)
}
nc := &NotificationChannel{
id: id,
}
return nc, nil
2020-06-19 17:40:18 -04:00
}
// Notification represents a notification that has been requested to be shown to the user.
// This type provides methods to cancel or update the contents of the notification.
type Notification struct {
id int32
}
// Send creates a new Notification and requests that it be displayed on this channel.
func (nc *NotificationChannel) Send(title, text string) (*Notification, error) {
notificationID := nextID()
if err := jni.Do(jni.JVMFor(app.JavaVM()), func(env jni.Env) error {
appCtx := jni.Object(app.AppContext())
classLoader := jni.ClassLoaderFor(env, appCtx)
notifyClass, err := jni.LoadClass(env, classLoader, helperClass)
if err != nil {
return err
}
newChannelMethod := jni.GetStaticMethodID(env, notifyClass, "sendNotification", "(Landroid/content/Context;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V")
jtitle := jni.Value(jni.JavaString(env, title))
jtext := jni.Value(jni.JavaString(env, text))
jID := jni.Value(jni.JavaString(env, nc.id))
err = jni.CallStaticVoidMethod(env, notifyClass, newChannelMethod, jni.Value(app.AppContext()), jID, jni.Value(notificationID), jtitle, jtext)
if err != nil {
return err
}
return nil
}); err != nil {
return nil, fmt.Errorf("failed sending notification: %w", err)
}
return &Notification{
id: notificationID,
}, nil
}
// Cancel removes a previously created notification from display.
func (n *Notification) Cancel() error {
notificationID := n.id
if err := jni.Do(jni.JVMFor(app.JavaVM()), func(env jni.Env) error {
appCtx := jni.Object(app.AppContext())
classLoader := jni.ClassLoaderFor(env, appCtx)
notifyClass, err := jni.LoadClass(env, classLoader, helperClass)
if err != nil {
return err
}
newChannelMethod := jni.GetStaticMethodID(env, notifyClass, "cancelNotification", "(Landroid/content/Context;I)V")
return jni.CallStaticVoidMethod(env, notifyClass, newChannelMethod, jni.Value(app.AppContext()), jni.Value(notificationID))
}); err != nil {
return fmt.Errorf("failed cancelling notification: %w", err)
}
return nil
}