fix: ensure all mutex Unlock calls use defer

Author: xaionaro@dx.center

examples/alarm/main.go

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

examples/common/ui/ui.go

@@ -90,9 +90,11 @@ func OnCreate(
 ) {
 	vm = cvm
 	activityRef = activity
-	OutputMu.Lock()
-	outputBuf.Reset()
-	OutputMu.Unlock()
+	func() {
+		OutputMu.Lock()
+		defer OutputMu.Unlock()
+		outputBuf.Reset()
+	}()
 	exampleStarted = false
 }
 
@@ -115,9 +117,11 @@ func OnNativeWindowCreated(windowPtr unsafe.Pointer) {
 			var err error
 			needed, err = getUngrantedPermissions(env, activityRef)
 			if err != nil {
-				OutputMu.Lock()
-				fmt.Fprintf(&outputBuf, "permissions check: %v\n", err)
-				OutputMu.Unlock()
+				func() {
+					OutputMu.Lock()
+					defer OutputMu.Unlock()
+					fmt.Fprintf(&outputBuf, "permissions check: %v\n", err)
+				}()
 			}
 			return nil
 		})
@@ -147,9 +151,11 @@ func startExample() {
 			if err := runFunc(vm, &localBuf); err != nil {
 				fmt.Fprintf(&localBuf, "ERROR: %v\n", err)
 			}
-			OutputMu.Lock()
-			outputBuf.Write(localBuf.Bytes())
-			OutputMu.Unlock()
+			func() {
+				OutputMu.Lock()
+				defer OutputMu.Unlock()
+				outputBuf.Write(localBuf.Bytes())
+			}()
 		}
 		RenderOutput()
 	}()
@@ -158,9 +164,11 @@ func startExample() {
 // RenderOutput re-renders the current output buffer to the screen.
 // Call from background goroutines after appending to the shared buffer.
 func RenderOutput() {
-	OutputMu.Lock()
-	text := outputBuf.String()
-	OutputMu.Unlock()
+	text := func() string {
+		OutputMu.Lock()
+		defer OutputMu.Unlock()
+		return outputBuf.String()
+	}()
 	if text == "" {
 		text = "(no output)"
 	}
@@ -169,13 +177,16 @@ func RenderOutput() {
 
 // OnResume is called when the activity resumes (e.g. after permission dialog).
 func OnResume(activity *jni.Object) {
-	OutputMu.Lock()
-	hasOutput := outputBuf.Len() > 0
-	var text string
-	if hasOutput {
-		text = outputBuf.String()
-	}
-	OutputMu.Unlock()
+	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
+	}()
 	if nativeWindow != nil && hasOutput {
 		renderText(text)
 	}

examples/location/main.go

@@ -230,12 +230,14 @@ func requestFreshLocation(vm *jni.VM, mgr *location.Manager) (*location.Extracte
 
 					loc, err := location.ExtractLocation(env, locObj)
 					if err == nil && loc != nil {
-						mu.Lock()
-						if result == nil {
-							result = loc
-							close(done)
-						}
-						mu.Unlock()
+						func() {
+							mu.Lock()
+							defer mu.Unlock()
+							if result == nil {
+								result = loc
+								close(done)
+							}
+						}()
 					}
 				}
 				return nil, nil

proxy.go

@@ -26,27 +26,31 @@ var (
 // registerProxy stores a handler and returns a unique ID.
 func registerProxy(h ProxyHandler) int64 {
 	id := proxyNextID.Add(1)
-	proxyMu.Lock()
-	proxyHandlers[id] = h
-	proxyMu.Unlock()
+	func() {
+		proxyMu.Lock()
+		defer proxyMu.Unlock()
+		proxyHandlers[id] = h
+	}()
 	return id
 }
 
 // registerProxyFull stores a full handler and returns a unique ID.
 func registerProxyFull(h ProxyHandlerFull) int64 {
 	id := proxyNextID.Add(1)
-	proxyMu.Lock()
-	proxyFullHandlers[id] = h
-	proxyMu.Unlock()
+	func() {
+		proxyMu.Lock()
+		defer proxyMu.Unlock()
+		proxyFullHandlers[id] = h
+	}()
 	return id
 }
 
 // unregisterProxy removes a handler by ID from both registries.
 func unregisterProxy(id int64) {
 	proxyMu.Lock()
+	defer proxyMu.Unlock()
 	delete(proxyHandlers, id)
 	delete(proxyFullHandlers, id)
-	proxyMu.Unlock()
 }
 
 // RegisterProxyHandler stores a basic ProxyHandler in the global registry
@@ -66,16 +70,16 @@ func UnregisterProxyHandler(id int64) {
 // lookupProxy retrieves a handler by ID.
 func lookupProxy(id int64) (ProxyHandler, bool) {
 	proxyMu.Lock()
+	defer proxyMu.Unlock()
 	h, ok := proxyHandlers[id]
-	proxyMu.Unlock()
 	return h, ok
 }
 
 // lookupProxyFull retrieves a full handler by ID.
 func lookupProxyFull(id int64) (ProxyHandlerFull, bool) {
 	proxyMu.Lock()
+	defer proxyMu.Unlock()
 	h, ok := proxyFullHandlers[id]
-	proxyMu.Unlock()
 	return h, ok
 }
 
@@ -158,9 +162,11 @@ func findClassWithFallback(
 	}
 	capi.ExceptionClear(env)
 
-	proxyMu.Lock()
-	cl := proxyClassLoader
-	proxyMu.Unlock()
+	cl := func() capi.Object {
+		proxyMu.Lock()
+		defer proxyMu.Unlock()
+		return proxyClassLoader
+	}()
 	if cl == 0 {
 		return 0
 	}