Handle cancellable disconnect callback handler

Author: dvd-bnc

lib/backend/fs.dart

@@ -22,15 +22,20 @@ enum OperationStatus {
 }
 
 class Cancellable extends ChangeNotifier {
-  Cancellable([VoidCallback? onCancel]) {
-    _cancelCallable = onCancel != null
-        ? NativeCallable<Void Function()>.isolateLocal(notifyListeners)
-        : null;
-    _handle = cancellable_new(_cancelCallable?.nativeFunction ?? nullptr);
+  Cancellable() {
+    _cancelCallable = NativeCallable<Void Function()>.isolateLocal(
+      notifyListeners,
+    );
+    _handle = cancellable_new();
+    _cancelCallbackHandlerId = cancellable_connect(
+      _handle,
+      _cancelCallable.nativeFunction,
+    );
   }
 
   late final Pointer<GCancellable> _handle;
-  late final NativeCallable<Void Function()>? _cancelCallable;
+  late final NativeCallable<Void Function()> _cancelCallable;
+  late final int _cancelCallbackHandlerId;
 
   bool get isCancelled => cancellable_is_cancelled(_handle);
 
@@ -39,8 +44,8 @@ class Cancellable extends ChangeNotifier {
   }
 
   void destroy() {
-    cancellable_destroy(_handle);
-    _cancelCallable?.close();
+    cancellable_destroy(_handle, _cancelCallbackHandlerId);
+    _cancelCallable.close();
   }
 }
 
@@ -359,11 +364,7 @@ extension type FileInfo._(Pointer<GFileInfo> _handle) {
     final name = fileinfo_get_name(_handle);
     if (name == nullptr) return null;
 
-    try {
-      return name.cast<Utf8>().toDartString();
-    } finally {
-      calloc.free(name);
-    }
+    return name.cast<Utf8>().toDartString();
   }
 
   int getFileType() => fileinfo_get_file_type(_handle);

lib/backend/fs_native.dart

@@ -33,10 +33,17 @@ final class GList extends Struct {
   external final Pointer<GList> previous;
 }
 
+@Native<Pointer<GCancellable> Function()>()
+external Pointer<GCancellable> cancellable_new();
+
 @Native<
-  Pointer<GCancellable> Function(Pointer<NativeFunction<Void Function()>>)
+  UnsignedLong Function(
+    Pointer<GCancellable>,
+    Pointer<NativeFunction<Void Function()>>,
+  )
 >()
-external Pointer<GCancellable> cancellable_new(
+external int cancellable_connect(
+  Pointer<GCancellable> cancellable,
   Pointer<NativeFunction<Void Function()>> onCancel,
 );
 
@@ -46,8 +53,11 @@ external void cancellable_cancel(Pointer<GCancellable> cancellable);
 @Native<Bool Function(Pointer<GCancellable>)>()
 external bool cancellable_is_cancelled(Pointer<GCancellable> cancellable);
 
-@Native<Void Function(Pointer<GCancellable>)>()
-external void cancellable_destroy(Pointer<GCancellable> cancellable);
+@Native<Void Function(Pointer<GCancellable>, UnsignedLong)>()
+external void cancellable_destroy(
+  Pointer<GCancellable> cancellable,
+  int cancelCallbackHandlerId,
+);
 
 @Native<Pointer<Pointer<GError>> Function()>()
 external Pointer<Pointer<GError>> error_new();

src/src/lib.zig

@@ -434,31 +434,33 @@ fn onCancel(_: [*c]c.GCancellable, user_data: ?*anyopaque) callconv(.c) void {
     callback();
 }
 
-pub export fn cancellable_new(
-    on_cancel: ?*fn () void,
-) *c.GCancellable {
-    const cancellable = c.g_cancellable_new();
-    if (on_cancel) |callback| {
-        _ = c.g_cancellable_connect(
-            cancellable,
-            c.G_CALLBACK(onCancel),
-            @ptrCast(callback),
-            null,
-        );
-    }
-    return cancellable;
+pub export fn cancellable_new() ?*c.GCancellable {
+    return c.g_cancellable_new();
+}
+
+pub export fn cancellable_connect(
+    cancellable: *c.GCancellable,
+    on_cancel: *const fn () callconv(.c) void,
+) c.ulong {
+    return c.g_cancellable_connect(
+        cancellable,
+        c.G_CALLBACK(onCancel),
+        @ptrCast(@constCast(on_cancel)),
+        null,
+    );
 }
 
-pub export fn cancellable_cancel(cancellable: *c.GCancellable) void {
-    c.g_cancellable_cancel(cancellable);
+pub export fn cancellable_cancel(fs_cancellable: *c.GCancellable) void {
+    c.g_cancellable_cancel(fs_cancellable);
 }
 
-pub export fn cancellable_is_cancelled(cancellable: *c.GCancellable) bool {
-    return c.g_cancellable_is_cancelled(cancellable) == 1;
+pub export fn cancellable_is_cancelled(fs_cancellable: *c.GCancellable) bool {
+    return c.g_cancellable_is_cancelled(fs_cancellable) == 1;
 }
 
-pub export fn cancellable_destroy(cancellable: *c.GCancellable) void {
-    c.g_object_unref(cancellable);
+pub export fn cancellable_destroy(fs_cancellable: *c.GCancellable, cancel_callback_handler_id: c.ulong) void {
+    c.g_cancellable_disconnect(fs_cancellable, cancel_callback_handler_id);
+    c.g_object_unref(fs_cancellable);
 }
 
 // -------- ERROR -------- //