fix: extract closure-wrapped mutex patterns into named functions

Author: xaionaro@dx.center

examples/alarm/main.go

@@ -127,24 +127,12 @@ func run(vm *jni.VM, output *bytes.Buffer) error {
 	go func() {
 		time.Sleep(delay)
 		if err := postNotification(vm, appCtxObj); err != nil {
-			func() {
-				ui.OutputMu.Lock()
-				defer ui.OutputMu.Unlock()
-				fmt.Fprintf(output, "notification error: %v\n", err)
-			}()
+			ui.FormatToOutputBuf("notification error: %v\n", err)
 		}
 		if err := playAlarmRingtone(vm, appCtxObj); err != nil {
-			func() {
-				ui.OutputMu.Lock()
-				defer ui.OutputMu.Unlock()
-				fmt.Fprintf(output, "ringtone error: %v\n", err)
-			}()
+			ui.FormatToOutputBuf("ringtone error: %v\n", err)
 		}
-		func() {
-			ui.OutputMu.Lock()
-			defer ui.OutputMu.Unlock()
-			fmt.Fprintf(output, "alarm fired!\n")
-		}()
+		ui.FormatToOutputBuf("alarm fired!\n")
 		ui.RenderOutput()
 	}()
 

examples/common/ui/ui.go

@@ -83,18 +83,54 @@ func Register(fn RunFunc) {
 	runFunc = fn
 }
 
+// resetOutputBuf clears the shared output buffer.
+func resetOutputBuf() {
+	OutputMu.Lock()
+	defer OutputMu.Unlock()
+	outputBuf.Reset()
+}
+
+// appendToOutputBuf writes data into the shared output buffer.
+func appendToOutputBuf(data []byte) {
+	OutputMu.Lock()
+	defer OutputMu.Unlock()
+	outputBuf.Write(data)
+}
+
+// FormatToOutputBuf formats and writes a message into the shared output buffer.
+func FormatToOutputBuf(format string, args ...any) {
+	OutputMu.Lock()
+	defer OutputMu.Unlock()
+	fmt.Fprintf(&outputBuf, format, args...)
+}
+
+// snapshotOutputBuf returns a copy of the current output buffer contents.
+func snapshotOutputBuf() string {
+	OutputMu.Lock()
+	defer OutputMu.Unlock()
+	return outputBuf.String()
+}
+
+// snapshotOutputBufIfNonEmpty returns the buffer contents and whether the
+// buffer was non-empty, under a single lock acquisition.
+func snapshotOutputBufIfNonEmpty() (text string, nonEmpty bool) {
+	OutputMu.Lock()
+	defer OutputMu.Unlock()
+	nonEmpty = outputBuf.Len() > 0
+	if nonEmpty {
+		text = outputBuf.String()
+	}
+	return text, nonEmpty
+}
+
 // OnCreate is called when the NativeActivity is created.
 func OnCreate(
 	cvm *jni.VM,
 	activity *jni.Object,
 ) {
 	vm = cvm
 	activityRef = activity
-	func() {
-		OutputMu.Lock()
-		defer OutputMu.Unlock()
-		outputBuf.Reset()
-	}()
+	resetOutputBuf()
 	exampleStarted = false
 }
 
@@ -117,11 +153,7 @@ func OnNativeWindowCreated(windowPtr unsafe.Pointer) {
 			var err error
 			needed, err = getUngrantedPermissions(env, activityRef)
 			if err != nil {
-				func() {
-					OutputMu.Lock()
-					defer OutputMu.Unlock()
-					fmt.Fprintf(&outputBuf, "permissions check: %v\n", err)
-				}()
+				FormatToOutputBuf("permissions check: %v\n", err)
 			}
 			return nil
 		})
@@ -151,11 +183,7 @@ func startExample() {
 			if err := runFunc(vm, &localBuf); err != nil {
 				fmt.Fprintf(&localBuf, "ERROR: %v\n", err)
 			}
-			func() {
-				OutputMu.Lock()
-				defer OutputMu.Unlock()
-				outputBuf.Write(localBuf.Bytes())
-			}()
+			appendToOutputBuf(localBuf.Bytes())
 		}
 		RenderOutput()
 	}()
@@ -164,11 +192,7 @@ func startExample() {
 // RenderOutput re-renders the current output buffer to the screen.
 // Call from background goroutines after appending to the shared buffer.
 func RenderOutput() {
-	text := func() string {
-		OutputMu.Lock()
-		defer OutputMu.Unlock()
-		return outputBuf.String()
-	}()
+	text := snapshotOutputBuf()
 	if text == "" {
 		text = "(no output)"
 	}
@@ -177,16 +201,7 @@ func RenderOutput() {
 
 // OnResume is called when the activity resumes (e.g. after permission dialog).
 func OnResume(activity *jni.Object) {
-	hasOutput, text := func() (bool, string) {
-		OutputMu.Lock()
-		defer OutputMu.Unlock()
-		has := outputBuf.Len() > 0
-		var t string
-		if has {
-			t = outputBuf.String()
-		}
-		return has, t
-	}()
+	text, hasOutput := snapshotOutputBufIfNonEmpty()
 	if nativeWindow != nil && hasOutput {
 		renderText(text)
 	}

examples/location/main.go

@@ -142,6 +142,22 @@ func printLocation(vm *jni.VM, provider string, locObj *jni.Object, output *byte
 		loc.Provider, loc.Latitude, loc.Longitude)
 }
 
+// deliverFirstLocation stores the first received location and signals
+// completion. Subsequent calls are no-ops (the channel is already closed).
+func deliverFirstLocation(
+	mu *sync.Mutex,
+	result **location.ExtractedLocation,
+	done chan struct{},
+	loc *location.ExtractedLocation,
+) {
+	mu.Lock()
+	defer mu.Unlock()
+	if *result == nil {
+		*result = loc
+		close(done)
+	}
+}
+
 // requestFreshLocation uses requestLocationUpdates with a JNI proxy
 // LocationListener to obtain a fresh GPS fix. It creates a HandlerThread
 // with its own Looper so callbacks can be delivered while the main thread
@@ -230,14 +246,7 @@ func requestFreshLocation(vm *jni.VM, mgr *location.Manager) (*location.Extracte
 
 					loc, err := location.ExtractLocation(env, locObj)
 					if err == nil && loc != nil {
-						func() {
-							mu.Lock()
-							defer mu.Unlock()
-							if result == nil {
-								result = loc
-								close(done)
-							}
-						}()
+						deliverFirstLocation(&mu, &result, done, loc)
 					}
 				}
 				return nil, nil

proxy.go

@@ -23,25 +23,38 @@ var (
 	proxyNextID       atomic.Int64
 )
 
+// storeProxyHandler adds a handler to the global registry under the given ID.
+func storeProxyHandler(id int64, h ProxyHandler) {
+	proxyMu.Lock()
+	defer proxyMu.Unlock()
+	proxyHandlers[id] = h
+}
+
+// storeProxyHandlerFull adds a full handler to the global registry under the given ID.
+func storeProxyHandlerFull(id int64, h ProxyHandlerFull) {
+	proxyMu.Lock()
+	defer proxyMu.Unlock()
+	proxyFullHandlers[id] = h
+}
+
+// loadProxyClassLoader returns the current fallback ClassLoader reference.
+func loadProxyClassLoader() capi.Object {
+	proxyMu.Lock()
+	defer proxyMu.Unlock()
+	return proxyClassLoader
+}
+
 // registerProxy stores a handler and returns a unique ID.
 func registerProxy(h ProxyHandler) int64 {
 	id := proxyNextID.Add(1)
-	func() {
-		proxyMu.Lock()
-		defer proxyMu.Unlock()
-		proxyHandlers[id] = h
-	}()
+	storeProxyHandler(id, h)
 	return id
 }
 
 // registerProxyFull stores a full handler and returns a unique ID.
 func registerProxyFull(h ProxyHandlerFull) int64 {
 	id := proxyNextID.Add(1)
-	func() {
-		proxyMu.Lock()
-		defer proxyMu.Unlock()
-		proxyFullHandlers[id] = h
-	}()
+	storeProxyHandlerFull(id, h)
 	return id
 }
 
@@ -162,11 +175,7 @@ func findClassWithFallback(
 	}
 	capi.ExceptionClear(env)
 
-	cl := func() capi.Object {
-		proxyMu.Lock()
-		defer proxyMu.Unlock()
-		return proxyClassLoader
-	}()
+	cl := loadProxyClassLoader()
 	if cl == 0 {
 		return 0
 	}