go-notify-darwin

noti.go (5621B)

---

 //go:build darwin && cgo
 
 package notify
 
 /*
 #cgo LDFLAGS: -framework Foundation -framework UserNotifications
 #cgo CFLAGS: -x objective-c -fobjc-arc -fmodules -O3 -Wall -Wextra
 #pragma clang diagnostic ignored "-Wformat-security"
 #pragma clang diagnostic ignored "-Wunused-variable"
 #include <stdlib.h>
 #include <stdint.h>
 #include "noti.h"
 */
 import "C"
 
 import (
 	"bytes"
 	"context"
 	"encoding/json"
 	"log/slog"
 	"runtime"
 	"sync/atomic"
 	"unsafe"
 )
 
 func init() {
 	runtime.LockOSThread()
 	C.noti_setup()
 }
 
 var (
 	// logger is the package logger to use.
 	logger atomic.Pointer[slog.Logger]
 
 	// callback is the pure Go hook that the application registers in order to receive user
 	// interactions from notifications.
 	callback atomic.Pointer[CallbackFunc]
 )
 
 // SetCallback sets the application callback to be invoked upon user interaction
 // with a notification.
 func SetCallback(cb CallbackFunc) {
 	callback.Store(&cb)
 }
 
 // SetLogger sets the package logger to use.
 func SetLogger(l *slog.Logger) {
 	logger.Swap(l)
 }
 
 // Init declares the set of notification categories for the application.
 func Init(categories ...Category) {
 	for _, category := range categories {
 		C.noti_category_register(category.toCType())
 	}
 }
 
 // Notify pushes the notification to the system.
 // Set a logger to view errors.
 func Notify(n Notification) {
 	C.noti_notify(n.toCType())
 }
 
 // Cancel notifications for the package.
 func Cancel() {
 	C.noti_cancel()
 }
 
 /*
 	To keep things simple (dealing with nested objects), we tie the C memory
 	to the lifetime of the various Go objects by doing the frees in a runtime
 	finalizer.
 */
 
 func (cc *Category) toCType() (c C.Category) {
 	var p runtime.Pinner
 
 	c.id = C.CString(cc.ID)
 	c.summary = C.CString(cc.Summary)
 	c.preview = C.CString(cc.Preview)
 
 	cActions := make([]C.Action, len(cc.Actions))
 	cTextInputActions := make([]C.TextInputAction, len(cc.TextInputActions))
 
 	for ii, action := range cc.Actions {
 		cActions[ii] = action.toCType()
 	}
 
 	for ii, action := range cc.TextInputActions {
 		cTextInputActions[ii] = action.toCType()
 	}
 
 	c.actions = unsafe.SliceData(cActions)
 	c.actions_len = C.uintptr_t(len(cActions))
 	c.text_input_actions = unsafe.SliceData(cTextInputActions)
 	c.text_input_actions_len = C.uintptr_t(len(cTextInputActions))
 
 	runtime.SetFinalizer(cc, func(_ *Category) {
 		C.free(unsafe.Pointer(c.id))
 		C.free(unsafe.Pointer(c.summary))
 		C.free(unsafe.Pointer(c.preview))
 		p.Unpin()
 	})
 
 	p.Pin(unsafe.SliceData(cActions))
 	p.Pin(unsafe.SliceData(cTextInputActions))
 
 	return c
 }
 
 func (n *Notification) toCType() (c C.Notification) {
 	var p runtime.Pinner
 
 	c.title = C.CString(n.Title)
 	c.sub_title = C.CString(n.Subtitle)
 	c.body = C.CString(n.Body)
 	c.category_id = C.CString(n.Category)
 
 	userDataBytes, err := json.Marshal(n.UserData)
 	if len(userDataBytes) == 0 || bytes.Equal(userDataBytes, []byte("null")) || err != nil {
 		c.user_data = C.CString(`"{}"`)
 	} else {
 		c.user_data = C.CString(string(userDataBytes))
 	}
 
 	cAttachments := make([]*C.char, len(n.Attachments))
 	cActions := make([]C.Action, len(n.Actions))
 	cTextInputActions := make([]C.TextInputAction, len(n.TextInputActions))
 
 	for ii, a := range n.Attachments {
 		cAttachments[ii] = C.CString(a)
 	}
 
 	for ii, action := range n.Actions {
 		cActions[ii] = action.toCType()
 	}
 
 	for ii, action := range n.TextInputActions {
 		cTextInputActions[ii] = action.toCType()
 	}
 
 	c.attachments = unsafe.SliceData(cAttachments)
 	c.attachments_len = C.uintptr_t(len(cAttachments))
 	c.actions = unsafe.SliceData(cActions)
 	c.actions_len = C.uintptr_t(len(cActions))
 	c.text_input_actions = unsafe.SliceData(cTextInputActions)
 	c.text_input_actions_len = C.uintptr_t(len(cTextInputActions))
 
 	runtime.SetFinalizer(n, func(_ *Notification) {
 		C.free(unsafe.Pointer(c.title))
 		C.free(unsafe.Pointer(c.sub_title))
 		C.free(unsafe.Pointer(c.body))
 		C.free(unsafe.Pointer(c.category_id))
 		C.free(unsafe.Pointer(c.user_data))
 		for ii := range cAttachments {
 			C.free(unsafe.Pointer(cAttachments[ii]))
 		}
 		p.Unpin()
 	})
 
 	p.Pin(unsafe.SliceData(userDataBytes))
 	p.Pin(unsafe.SliceData(cAttachments))
 	p.Pin(unsafe.SliceData(cActions))
 	p.Pin(unsafe.SliceData(cTextInputActions))
 
 	return c
 }
 
 func (a *Action) toCType() (c C.Action) {
 	c.id = C.CString(a.ID)
 	c.icon = C.CString(a.Icon)
 	c.title = C.CString(a.Title)
 
 	runtime.SetFinalizer(a, func(_ *Action) {
 		C.free(unsafe.Pointer(c.id))
 		C.free(unsafe.Pointer(c.title))
 		C.free(unsafe.Pointer(c.icon))
 	})
 
 	return c
 }
 
 func (a *TextInputAction) toCType() (c C.TextInputAction) {
 	c.id = C.CString(a.ID)
 	c.icon = C.CString(a.Icon)
 	c.title = C.CString(a.Title)
 	c.button_title = C.CString(a.ButtonTitle)
 	c.placeholder = C.CString(a.Placeholder)
 
 	runtime.SetFinalizer(a, func(_ *TextInputAction) {
 		C.free(unsafe.Pointer(c.id))
 		C.free(unsafe.Pointer(c.title))
 		C.free(unsafe.Pointer(c.icon))
 		C.free(unsafe.Pointer(c.button_title))
 		C.free(unsafe.Pointer(c.placeholder))
 	})
 
 	return c
 }
 
 //export gocallback
 func gocallback(
 	categoryID *C.cchar_t,
 	actionID *C.cchar_t,
 	userText *C.cchar_t,
 	userData *C.cchar_t,
 ) {
 	cb := callback.Load()
 
 	if cb == nil {
 		return
 	}
 
 	category := C.GoString(categoryID)
 	action := C.GoString(actionID)
 	text := C.GoString(userText)
 	data := C.GoString(userData)
 
 	var v map[string]string
 	err := json.Unmarshal([]byte(data), &v)
 
 	(*cb)(CallbackArgs{
 		Category: CategoryID(category),
 		Action:   ActionID(action),
 		UserText: text,
 		UserData: v,
 		Err:      err,
 	})
 }
 
 //export golog
 func golog(level C.int, msg *C.cchar_t) {
 	slog.Log(context.Background(), slog.Level(level), C.GoString(msg))
 }