refactor(api): 统一回调为 CoreSetEventCallback，新增日志推送，移除 QueryLogs

- 3 个独立回调 (URLTest/ModeUpdate/ConnEvent) 合并为单一 CoreSetEventCallback
- 事件类型: 0=Log, 1=URLTest, 2=ModeUpdate, 3=ConnEvent
- 日志通过回调实时推送，移除内存环形缓冲和 QueryLogs 查询方法
- 修复 FFI 回调内存管理: ownership transfer 替代 defer C.free (dart-lang/sdk#54554)
- Mobile SDK: 3 个 Listener 接口合并为 EventListener.OnEvent

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: mapleafgo

cmd/lib/exports.go

@@ -3,13 +3,8 @@ package main
 /*
 #include <stdlib.h>
 
-typedef void (*VoidCallback)();
-typedef void (*StringCallback)(const char*);
-typedef void (*IntStringCallback)(int, const char*);
-
-static void invokeVoidCB(VoidCallback cb) { cb(); }
-static void invokeStringCB(StringCallback cb, const char* s) { cb(s); }
-static void invokeIntStringCB(IntStringCallback cb, int i, const char* s) { cb(i, s); }
+typedef void (*EventCallback)(int, const char*);
+static void invokeEventCB(EventCallback cb, int t, const char* s) { cb(t, s); }
 */
 import "C"
 
@@ -22,34 +17,17 @@ import (
 
 var api = ffi.Create()
 
-var (
-	cURLTestCB   unsafe.Pointer
-	cModeUpdateCB unsafe.Pointer
-	cConnEventCB  unsafe.Pointer
-)
+var cEventCB unsafe.Pointer
 
 func init() {
-	api.SetCallbackFuncs(
-		func() {
-			if cURLTestCB != nil {
-				C.invokeVoidCB(C.VoidCallback(cURLTestCB))
-			}
-		},
-		func(mode string) {
-			if cModeUpdateCB != nil {
-				cs := C.CString(mode)
-				defer C.free(unsafe.Pointer(cs))
-				C.invokeStringCB(C.StringCallback(cModeUpdateCB), cs)
-			}
-		},
-		func(eventType int32, connJSON string) {
-			if cConnEventCB != nil {
-				cs := C.CString(connJSON)
-				defer C.free(unsafe.Pointer(cs))
-				C.invokeIntStringCB(C.IntStringCallback(cConnEventCB), C.int(eventType), cs)
-			}
-		},
-	)
+	api.SetCallbackFuncs(func(eventType int32, json string) {
+		if cEventCB != nil {
+			// Ownership transfer: Dart side must call CoreFreeString after copying.
+			// Do NOT free here — NativeCallable.listener is async (dart-lang/sdk#54554).
+			cs := C.CString(json)
+			C.invokeEventCB(C.EventCallback(cEventCB), C.int(eventType), cs)
+		}
+	})
 }
 
 func resultJSON(err error) *C.char {
@@ -136,9 +114,6 @@ func CoreQueryProxies() *C.char { return cString(api.QueryProxies()) }
 //export CoreQueryStats
 func CoreQueryStats() *C.char { return cString(api.QueryStats()) }
 
-//export CoreQueryLogs
-func CoreQueryLogs() *C.char { return cString(api.QueryLogs()) }
-
 //export CoreQueryConnections
 func CoreQueryConnections() *C.char { return cString(api.QueryConnections()) }
 
@@ -196,13 +171,7 @@ func CoreSetMemoryLimit(bytes C.longlong) { api.SetMemoryLimit(int64(bytes)) }
 //export CoreGetVersion
 func CoreGetVersion() *C.char { return cString(api.Version()) }
 
-// --- Event Callbacks ---
-
-//export CoreSetURLTestCallback
-func CoreSetURLTestCallback(cb unsafe.Pointer) { cURLTestCB = cb }
-
-//export CoreSetModeUpdateCallback
-func CoreSetModeUpdateCallback(cb unsafe.Pointer) { cModeUpdateCB = cb }
+// --- Event Callback ---
 
-//export CoreSetConnEventCallback
-func CoreSetConnEventCallback(cb unsafe.Pointer) { cConnEventCB = cb }
+//export CoreSetEventCallback
+func CoreSetEventCallback(cb unsafe.Pointer) { cEventCB = cb }

core/logging.go

@@ -7,12 +7,9 @@ import (
 	"log/slog"
 	"os"
 	"strings"
-	"sync"
 	"sync/atomic"
 )
 
-const maxCoreLogEntries = 500
-
 // Log level constants. Lower number = higher severity.
 const (
 	LogLevelError int32 = 2
@@ -23,18 +20,18 @@ const (
 )
 
 var (
-	coreLogMu sync.Mutex
-
-	// Fixed-size ring buffer avoids slice-shift memory waste.
-	coreLogRing [maxCoreLogEntries]LogEntry
-	coreLogPos  int // next write position
-	coreLogLen  int // current length (0..maxCoreLogEntries)
-
 	// Runtime log level filter. Lower number = higher severity.
 	// Error=2, Warn=3, Info=4, Debug=5, Trace=6.
 	coreLogLevel atomic.Int32
+
+	// Global log event callback, set via SetOnLogEvent.
+	onLogEvent func(int32, string)
 )
 
+// SetOnLogEvent registers a callback invoked for each new log entry.
+// The callback receives (EventLog, json) where json is a serialized LogEntry.
+func SetOnLogEvent(fn func(int32, string)) { onLogEvent = fn }
+
 func init() {
 	coreLogLevel.Store(LogLevelInfo)
 	slog.SetDefault(slog.New(&coreLogHandler{}))
@@ -46,9 +43,9 @@ func SetLogLevel(level int32) { coreLogLevel.Store(level) }
 // GetLogLevel returns the current minimum log level.
 func GetLogLevel() int32 { return coreLogLevel.Load() }
 
-// coreLogHandler implements slog.Handler, routing log entries to an in-memory
-// ring buffer and the event callback. No file I/O is performed; the frontend
-// handles all log persistence.
+// coreLogHandler implements slog.Handler, routing log entries to stderr
+// and the event callback. No in-memory retention — the frontend handles
+// log persistence via the callback.
 type coreLogHandler struct {
 	extra string // accumulated key=value pairs from WithAttrs
 }
@@ -71,19 +68,15 @@ func (h *coreLogHandler) Handle(_ context.Context, r slog.Record) error {
 	// Always mirror to stderr for debugging (gomobile forwards to Android logcat).
 	fmt.Fprintln(os.Stderr, b.String())
 
-	entry := LogEntry{
-		Level:     slogToCoreLevel(r.Level),
-		Message:   b.String(),
-		Timestamp: r.Time.UnixMilli(),
+	if onLogEvent != nil {
+		data, _ := json.Marshal(LogEntry{
+			Level:     slogToCoreLevel(r.Level),
+			Message:   b.String(),
+			Timestamp: r.Time.UnixMilli(),
+		})
+		onLogEvent(EventLog, string(data))
 	}
 
-	coreLogMu.Lock()
-	coreLogRing[coreLogPos] = entry
-	coreLogPos = (coreLogPos + 1) % maxCoreLogEntries
-	if coreLogLen < maxCoreLogEntries {
-		coreLogLen++
-	}
-	coreLogMu.Unlock()
 	return nil
 }
 
@@ -152,26 +145,3 @@ func syncLogLevelFromConfig(jsonContent string) {
 	slog.Info("[syncLogLevel] syncing log level", "configLevel", cfg.Log.Level, "oldLevel", oldLevel, "newLevel", newLevel)
 	SetLogLevel(newLevel)
 }
-
-func queryCoreLogs() string {
-	entries := queryCoreLogEntries()
-	if len(entries) == 0 {
-		return "[]"
-	}
-	data, _ := json.Marshal(entries)
-	return string(data)
-}
-
-func queryCoreLogEntries() []LogEntry {
-	coreLogMu.Lock()
-	defer coreLogMu.Unlock()
-	if coreLogLen == 0 {
-		return nil
-	}
-	entries := make([]LogEntry, 0, coreLogLen)
-	start := (coreLogPos - coreLogLen + maxCoreLogEntries) % maxCoreLogEntries
-	for i := range coreLogLen {
-		entries = append(entries, coreLogRing[(start+i)%maxCoreLogEntries])
-	}
-	return entries
-}

core/logging_test.go

@@ -4,100 +4,65 @@ import (
 	"encoding/json"
 	"log/slog"
 	"strings"
+	"sync"
 	"testing"
 )
 
-func TestLogging_RingBufferOrder(t *testing.T) {
-	coreLogMu.Lock()
-	coreLogPos = 0
-	coreLogLen = 0
-	coreLogMu.Unlock()
+func TestLogging_Callback(t *testing.T) {
+	var mu sync.Mutex
+	var gotEntries []LogEntry
 
-	for i := 0; i < 5; i++ {
-		slog.Info("test message", "index", i)
-	}
-
-	got := queryCoreLogs()
-	var entries []LogEntry
-	if err := json.Unmarshal([]byte(got), &entries); err != nil {
-		t.Fatalf("unmarshal: %v", err)
-	}
-	if len(entries) != 5 {
-		t.Fatalf("expected 5 entries, got %d", len(entries))
-	}
-	for i, e := range entries {
-		if !strings.Contains(e.Message, "test message") {
-			t.Errorf("entry[%d] = %q, should contain 'test message'", i, e.Message)
+	SetOnLogEvent(func(eventType int32, jsonStr string) {
+		if eventType != EventLog {
+			t.Errorf("eventType = %d, want %d", eventType, EventLog)
 		}
-	}
-}
-
-func TestLogging_RingBufferOverflow(t *testing.T) {
-	coreLogMu.Lock()
-	coreLogPos = 0
-	coreLogLen = 0
-	coreLogMu.Unlock()
-
-	prevLevel := GetLogLevel()
-	SetLogLevel(6) // Trace
-	defer SetLogLevel(prevLevel)
-
-	for i := 0; i < maxCoreLogEntries+100; i++ {
-		slog.Debug("overflow-test", "i", i)
-	}
+		var entry LogEntry
+		if err := json.Unmarshal([]byte(jsonStr), &entry); err != nil {
+			t.Errorf("unmarshal: %v", err)
+		}
+		mu.Lock()
+		gotEntries = append(gotEntries, entry)
+		mu.Unlock()
+	})
+	defer SetOnLogEvent(nil)
 
-	coreLogMu.Lock()
-	if coreLogLen != maxCoreLogEntries {
-		t.Errorf("coreLogLen = %d, want %d", coreLogLen, maxCoreLogEntries)
-	}
-	coreLogMu.Unlock()
+	slog.Info("callback-test", "key", "val")
 
-	got := queryCoreLogs()
-	var entries []LogEntry
-	if err := json.Unmarshal([]byte(got), &entries); err != nil {
-		t.Fatalf("unmarshal: %v", err)
-	}
-	if len(entries) != maxCoreLogEntries {
-		t.Errorf("queryCoreLogs returned %d entries, want %d", len(entries), maxCoreLogEntries)
+	mu.Lock()
+	defer mu.Unlock()
+	if len(gotEntries) == 0 {
+		t.Fatal("expected at least one log entry via callback")
 	}
-	if !strings.Contains(entries[0].Message, "overflow-test") {
-		t.Errorf("oldest entry = %q, should contain overflow-test", entries[0].Message)
-	}
-}
-
-func TestLogging_QueryEmpty(t *testing.T) {
-	coreLogMu.Lock()
-	coreLogPos = 0
-	coreLogLen = 0
-	coreLogMu.Unlock()
-
-	got := queryCoreLogs()
-	if got != "[]" {
-		t.Errorf("empty ring = %q, want []", got)
+	if !strings.Contains(gotEntries[len(gotEntries)-1].Message, "callback-test") {
+		t.Errorf("entry = %q, should contain callback-test", gotEntries[len(gotEntries)-1].Message)
 	}
 }
 
 func TestLogging_HandleAttrs(t *testing.T) {
-	coreLogMu.Lock()
-	coreLogPos = 0
-	coreLogLen = 0
-	coreLogMu.Unlock()
+	var mu sync.Mutex
+	var messages []string
+
+	SetOnLogEvent(func(_ int32, jsonStr string) {
+		var entry LogEntry
+		json.Unmarshal([]byte(jsonStr), &entry)
+		mu.Lock()
+		messages = append(messages, entry.Message)
+		mu.Unlock()
+	})
+	defer SetOnLogEvent(nil)
 
 	slog.Info("with-attrs", "key1", "val1", "key2", 42)
 
-	got := queryCoreLogs()
-	var entries []LogEntry
-	if err := json.Unmarshal([]byte(got), &entries); err != nil {
-		t.Fatalf("unmarshal: %v", err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected 1 entry, got %d", len(entries))
+	mu.Lock()
+	defer mu.Unlock()
+	if len(messages) == 0 {
+		t.Fatal("expected at least one entry")
 	}
-	if !strings.Contains(entries[0].Message, "key1=val1") {
-		t.Errorf("entry should contain attrs: %q", entries[0].Message)
+	if !strings.Contains(messages[len(messages)-1], "key1=val1") {
+		t.Errorf("entry should contain key1=val1: %q", messages[len(messages)-1])
 	}
-	if !strings.Contains(entries[0].Message, "key2=42") {
-		t.Errorf("entry should contain attrs: %q", entries[0].Message)
+	if !strings.Contains(messages[len(messages)-1], "key2=42") {
+		t.Errorf("entry should contain key2=42: %q", messages[len(messages)-1])
 	}
 }