internal/cgohandler: Separate from xpc package

Signed-off-by: Norio Nomura <norio.nomura@gmail.com>

Author: norio-nomura

internal/cgohandler/cgohandler.go

@@ -0,0 +1,44 @@
+package cgohandler
+
+/*
+# include <stdint.h>
+*/
+import "C"
+import (
+	"runtime"
+	"runtime/cgo"
+)
+
+// Handler holds a cgo.Handle for an Object.
+// It provides methods to hold and release the handle.
+// handle will released when Handler is cleaned up.
+type Handler struct {
+	handle cgo.Handle
+}
+
+// releaseOnCleanup registers a cleanup function to delete the cgo.Handle when cleaned up.
+func (h *Handler) releaseOnCleanup() {
+	runtime.AddCleanup(h, func(h cgo.Handle) {
+		h.Delete()
+	}, h.handle)
+}
+
+// New creates a new [Handler] and holds the given value.
+func New(v any) (*Handler, uintptr) {
+	if v == nil {
+		return nil, 0
+	}
+	h := &Handler{cgo.NewHandle(v)}
+	h.releaseOnCleanup()
+	return h, uintptr(h.handle)
+}
+
+// Unwrap unwraps the cgo.Handle from the given uintptr and returns the associated value.
+// It does NOT delete the handle; it expects the handle to be managed by [Handler] or caller.
+func Unwrap[T any](handle uintptr) T {
+	if handle == 0 {
+		var zero T
+		return zero
+	}
+	return cgo.Handle(handle).Value().(T)
+}

xpc/array.go

@@ -11,6 +11,7 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/Code-Hex/vz/v3/internal/cgohandler"
 	"github.com/Code-Hex/vz/v3/internal/objc"
 )
 
@@ -74,7 +75,7 @@ type ArrayApplier func(uint64, Object) bool
 //
 //export callArrayApplier
 func callArrayApplier(cgoApplier uintptr, index C.size_t, cgoValue uintptr) C.bool {
-	applier := unwrapHandler[ArrayApplier](cgoApplier)
+	applier := cgohandler.Unwrap[ArrayApplier](cgoApplier)
 	value := unwrapObject[Object](cgoValue)
 	result := applier(uint64(index), value)
 	return C.bool(result)

xpc/cgo_handle.go

@@ -12,6 +12,7 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/Code-Hex/vz/v3/internal/cgohandler"
 	"github.com/Code-Hex/vz/v3/internal/objc"
 )
 
@@ -103,7 +104,7 @@ type DictionaryApplier func(string, Object) bool
 //
 //export callDictionaryApplier
 func callDictionaryApplier(cgoApplier uintptr, cKey *C.char, cgoValue uintptr) C.bool {
-	applier := unwrapHandler[DictionaryApplier](cgoApplier)
+	applier := cgohandler.Unwrap[DictionaryApplier](cgoApplier)
 	return C.bool(applier(C.GoString(cKey), unwrapObject[Object](cgoValue)))
 }
 

xpc/dictionary.go

@@ -9,14 +9,15 @@ import "C"
 import (
 	"unsafe"
 
+	"github.com/Code-Hex/vz/v3/internal/cgohandler"
 	"github.com/Code-Hex/vz/v3/internal/objc"
 )
 
 // Listener represents an XPC listener. (macOS 14.0+)
 //   - https://developer.apple.com/documentation/xpc/xpc_listener_t?language=objc
 type Listener struct {
 	*xpcObject
-	sessionHandler *cgoHandler
+	sessionHandler *cgohandler.Handler
 }
 
 // SessionHandler is a function that handles incoming sessions.
@@ -47,9 +48,9 @@ func NewListener(service string, handler SessionHandler, options ...ListenerOpti
 	// For example, vmnet_network_create fails when using a concurrent queue.
 	q := C.dispatchQueueCreateSerial(cname)
 	defer C.dispatchRelease(q)
-	cgoHandler, p := newCgoHandler(handler)
+	cgoHandler, p := cgohandler.New(handler)
 	var err_out unsafe.Pointer
-	ptr := C.xpcListenerCreate(cname, q, C.XPC_LISTENER_CREATE_INACTIVE, p, &err_out)
+	ptr := C.xpcListenerCreate(cname, q, C.XPC_LISTENER_CREATE_INACTIVE, C.uintptr_t(p), &err_out)
 	if err_out != nil {
 		return nil, newRichError(err_out)
 	}
@@ -67,7 +68,7 @@ func NewListener(service string, handler SessionHandler, options ...ListenerOpti
 //
 //export callSessionHandler
 func callSessionHandler(cgoSessionHandler, cgoSession uintptr) {
-	handler := unwrapHandler[SessionHandler](cgoSessionHandler)
+	handler := cgohandler.Unwrap[SessionHandler](cgoSessionHandler)
 	session := unwrapObject[*Session](cgoSession)
 	handler(session)
 }

xpc/listener.go

@@ -11,6 +11,7 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
+	"github.com/Code-Hex/vz/v3/internal/cgohandler"
 	"github.com/Code-Hex/vz/v3/internal/objc"
 )
 
@@ -20,8 +21,8 @@ import (
 type Session struct {
 	// Exported for use in other packages since unimplemented XPC API may require direct access to xpc_session_t.
 	*xpcObject
-	cancellationHandler    *cgoHandler
-	incomingMessageHandler *cgoHandler
+	cancellationHandler    *cgohandler.Handler
+	incomingMessageHandler *cgohandler.Handler
 }
 
 var _ Object = &Session{}
@@ -128,16 +129,16 @@ func (s *Session) activate() error {
 //
 //export callMessageHandler
 func callMessageHandler(cgoMessageHandler, cgoMessage uintptr) (reply unsafe.Pointer) {
-	handler := unwrapHandler[MessageHandler](cgoMessageHandler)
+	handler := cgohandler.Unwrap[MessageHandler](cgoMessageHandler)
 	message := unwrapObject[*Dictionary](cgoMessage)
 	return objc.Ptr(handler(message))
 }
 
 // setIncomingMessageHandler sets the [MessageHandler] for the inactive [Session]. (macOS 13.0+)
 //   - https://developer.apple.com/documentation/xpc/xpc_session_set_incoming_message_handler
 func (s *Session) setIncomingMessageHandler(handler MessageHandler) {
-	cgoHandler, p := newCgoHandler(handler)
-	C.xpcSessionSetIncomingMessageHandler(objc.Ptr(s), p)
+	cgoHandler, p := cgohandler.New(handler)
+	C.xpcSessionSetIncomingMessageHandler(objc.Ptr(s), C.uintptr_t(p))
 	// Store the handler after setting it to avoid premature garbage collection of the previous handler.
 	s.incomingMessageHandler = cgoHandler
 }
@@ -152,7 +153,7 @@ func (s *Session) Cancel() {
 //
 //export callCancelHandler
 func callCancelHandler(cgoCancelHandler, cgoErr uintptr) {
-	handler := unwrapHandler[CancellationHandler](cgoCancelHandler)
+	handler := cgohandler.Unwrap[CancellationHandler](cgoCancelHandler)
 	err := unwrapObject[*RichError](cgoErr)
 	handler(err)
 }
@@ -161,13 +162,13 @@ func callCancelHandler(cgoCancelHandler, cgoErr uintptr) {
 // The handler will call [Session.handleCancellation] after executing the provided handler.
 //   - https://developer.apple.com/documentation/xpc/xpc_session_set_cancel_handler
 func (s *Session) setCancellationHandler(handler CancellationHandler) {
-	cgoHandler, p := newCgoHandler((CancellationHandler)(func(err *RichError) {
+	cgoHandler, p := cgohandler.New((CancellationHandler)(func(err *RichError) {
 		if handler != nil {
 			handler(err)
 		}
 		s.handleCancellation(err)
 	}))
-	C.xpcSessionSetCancelHandler(objc.Ptr(s), p)
+	C.xpcSessionSetCancelHandler(objc.Ptr(s), C.uintptr_t(p))
 	// Store the handler after setting it to avoid premature garbage collection of the previous handler.
 	s.cancellationHandler = cgoHandler
 }
@@ -182,7 +183,7 @@ type ReplyHandler func(*Dictionary, *RichError)
 //
 //export callReplyHandler
 func callReplyHandler(cgoReplyHandler uintptr, cgoReply, cgoError uintptr) {
-	handler := unwrapHandler[ReplyHandler](cgoReplyHandler)
+	handler := cgohandler.Unwrap[ReplyHandler](cgoReplyHandler)
 	reply := unwrapObject[*Dictionary](uintptr(cgoReply))
 	err := unwrapObject[*RichError](cgoError)
 	handler(reply, err)