minimal get_next_event api

deltachat-ffi/deltachat.h

@@ -19,6 +19,7 @@ typedef struct _dc_msg      dc_msg_t;
 typedef struct _dc_contact  dc_contact_t;
 typedef struct _dc_lot      dc_lot_t;
 typedef struct _dc_provider dc_provider_t;
+typedef struct _dc_event    dc_event_t;
 
 
 /**
@@ -189,6 +190,26 @@ typedef struct _dc_provider dc_provider_t;
  */
 
 
+
+/**
+ * TODO: document
+ */  
+int           dc_has_next_event(dc_context_t* context);
+  
+/**
+ * TODO: document
+ */  
+dc_event_t*   dc_get_next_event(dc_context_t* context);
+
+int          dc_event_get_id   (dc_event_t* event);
+uintptr_t    dc_event_get_data1(dc_event_t* event);
+uintptr_t    dc_event_get_data2(dc_event_t* event);
+
+/**
+ * TODO: document
+ */
+void          dc_event_unref   (dc_event_t* event);
+
 /**
  * @class dc_context_t
  *
@@ -199,20 +220,6 @@ typedef struct _dc_provider dc_provider_t;
  * settings.
  */
 
-
-/**
- * Callback function that should be given to dc_context_new().
- *
- * @memberof dc_context_t
- * @param context The context object as returned by dc_context_new().
- * @param event one of the @ref DC_EVENT constants
- * @param data1 depends on the event parameter
- * @param data2 depends on the event parameter
- * @return return 0 unless stated otherwise in the event parameter documentation
- */
-typedef uintptr_t (*dc_callback_t) (dc_context_t* context, int event, uintptr_t data1, uintptr_t data2);
-
-
 // create/open/config/information
 
 /**

deltachat-ffi/src/lib.rs

@@ -464,10 +464,7 @@ pub unsafe extern "C" fn dc_is_configured(context: *mut dc_context_t) -> libc::c
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_context_run(context: *mut dc_context_t) {
-    eprintln!("dc_context_run");
-
     if context.is_null() {
-        eprintln!("ignoring careless call to dc_run()");
         return;
     }
     let ffi_context = &*context;
@@ -475,81 +472,168 @@ pub unsafe extern "C" fn dc_context_run(context: *mut dc_context_t) {
     with_inner_async!(ffi_context, ctx, { ctx.run() }).unwrap_or(())
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_has_next_event(context: *mut dc_context_t) -> libc::c_int {
+    if context.is_null() {
+        return 0;
+    }
+    let ffi_context = &*context;
+
+    ffi_context
+        .with_inner(|ctx| ctx.has_next_event())
+        .unwrap_or_default() as libc::c_int
+}
+
+pub struct EventWrapper {
+    pub event_id: libc::c_int,
+    pub data1: uintptr_t,
+    pub data2: uintptr_t,
+}
+
+#[no_mangle]
+pub type dc_event_t = EventWrapper;
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_event_unref(a: *mut dc_event_t) {
+    if a.is_null() {
+        eprintln!("ignoring careless call to dc_event_unref()");
+        return;
+    }
+
+    Box::from_raw(a);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_event_get_id(event: *mut dc_event_t) -> libc::c_int {
+    if event.is_null() {
+        eprintln!("ignoring careless call to dc_event_get_id()");
+        return 0;
+    }
+
+    let event = &*event;
+    event.event_id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_event_get_data1(event: *mut dc_event_t) -> uintptr_t {
+    if event.is_null() {
+        eprintln!("ignoring careless call to dc_event_get_data1()");
+        return 0;
+    }
+
+    let event = &*event;
+    event.data1
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_event_get_data2(event: *mut dc_event_t) -> uintptr_t {
+    if event.is_null() {
+        eprintln!("ignoring careless call to dc_event_get_data2()");
+        return 0;
+    }
+
+    let event = &*event;
+    event.data2
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_get_next_event(context: *mut dc_context_t) -> *mut dc_event_t {
+    if context.is_null() {
+        return ptr::null_mut();
+    }
+    let ffi_context = &*context;
+
+    ffi_context
+        .with_inner(|ctx| match ctx.get_next_event() {
+            Ok(ev) => translate_event(ev),
+            Err(_) => ptr::null_mut(),
+        })
+        .unwrap_or_else(|_| ptr::null_mut())
+}
+
 /// Translates the callback from the rust style to the C-style version.
-unsafe fn translate_cb(ctx: &ContextWrapper, ffi_cb: Option<dc_callback_t>, event: Event) {
+unsafe fn translate_event(event: Event) -> *mut dc_event_t {
-    if let Some(ffi_cb) = ffi_cb {
+    let event_id = event.as_id();
-        let event_id = event.as_id();
+    let wrapper = match event {
-        match event {
+        Event::Info(msg)
-            Event::Info(msg)
+        | Event::SmtpConnected(msg)
-            | Event::SmtpConnected(msg)
+        | Event::ImapConnected(msg)
-            | Event::ImapConnected(msg)
+        | Event::SmtpMessageSent(msg)
-            | Event::SmtpMessageSent(msg)
+        | Event::ImapMessageDeleted(msg)
-            | Event::ImapMessageDeleted(msg)
+        | Event::ImapMessageMoved(msg)
-            | Event::ImapMessageMoved(msg)
+        | Event::ImapFolderEmptied(msg)
-            | Event::ImapFolderEmptied(msg)
+        | Event::NewBlobFile(msg)
-            | Event::NewBlobFile(msg)
+        | Event::DeletedBlobFile(msg)
-            | Event::DeletedBlobFile(msg)
+        | Event::Warning(msg)
-            | Event::Warning(msg)
+        | Event::Error(msg)
-            | Event::Error(msg)
+        | Event::ErrorNetwork(msg)
-            | Event::ErrorNetwork(msg)
+        | Event::ErrorSelfNotInGroup(msg) => {
-            | Event::ErrorSelfNotInGroup(msg) => {
+            let data2 = CString::new(msg).unwrap_or_default();
-                let data2 = CString::new(msg).unwrap_or_default();
+
-                ffi_cb(ctx, event_id, 0, data2.as_ptr() as uintptr_t);
+            EventWrapper {
-            }
+                event_id,
-            Event::MsgsChanged { chat_id, msg_id }
+                data1: 0,
-            | Event::IncomingMsg { chat_id, msg_id }
+                data2: data2.into_raw() as uintptr_t,
-            | Event::MsgDelivered { chat_id, msg_id }
-            | Event::MsgFailed { chat_id, msg_id }
-            | Event::MsgRead { chat_id, msg_id } => {
-                ffi_cb(
-                    ctx,
-                    event_id,
-                    chat_id.to_u32() as uintptr_t,
-                    msg_id.to_u32() as uintptr_t,
-                );
-            }
-            Event::ChatModified(chat_id) => {
-                ffi_cb(ctx, event_id, chat_id.to_u32() as uintptr_t, 0);
-            }
-            Event::ContactsChanged(id) | Event::LocationChanged(id) => {
-                let id = id.unwrap_or_default();
-                ffi_cb(ctx, event_id, id as uintptr_t, 0);
-            }
-            Event::ConfigureProgress(progress) | Event::ImexProgress(progress) => {
-                ffi_cb(ctx, event_id, progress as uintptr_t, 0);
-            }
-            Event::ImexFileWritten(file) => {
-                let data1 = file.to_c_string().unwrap_or_default();
-                ffi_cb(ctx, event_id, data1.as_ptr() as uintptr_t, 0);
-            }
-            Event::SecurejoinInviterProgress {
-                contact_id,
-                progress,
-            }
-            | Event::SecurejoinJoinerProgress {
-                contact_id,
-                progress,
-            } => {
-                ffi_cb(
-                    ctx,
-                    event_id,
-                    contact_id as uintptr_t,
-                    progress as uintptr_t,
-                );
-            }
-            Event::SecurejoinMemberAdded {
-                chat_id,
-                contact_id,
-            } => {
-                ffi_cb(
-                    ctx,
-                    event_id,
-                    chat_id.to_u32() as uintptr_t,
-                    contact_id as uintptr_t,
-                );
             }
         }
-    }
+        Event::MsgsChanged { chat_id, msg_id }
+        | Event::IncomingMsg { chat_id, msg_id }
+        | Event::MsgDelivered { chat_id, msg_id }
+        | Event::MsgFailed { chat_id, msg_id }
+        | Event::MsgRead { chat_id, msg_id } => EventWrapper {
+            event_id,
+            data1: chat_id.to_u32() as uintptr_t,
+            data2: msg_id.to_u32() as uintptr_t,
+        },
+        Event::ChatModified(chat_id) => EventWrapper {
+            event_id,
+            data1: chat_id.to_u32() as uintptr_t,
+            data2: 0,
+        },
+        Event::ContactsChanged(id) | Event::LocationChanged(id) => {
+            let id = id.unwrap_or_default();
+            EventWrapper {
+                event_id,
+                data1: id as uintptr_t,
+                data2: 0,
+            }
+        }
+        Event::ConfigureProgress(progress) | Event::ImexProgress(progress) => EventWrapper {
+            event_id,
+            data1: progress as uintptr_t,
+            data2: 0,
+        },
+        Event::ImexFileWritten(file) => {
+            let data1 = file.to_c_string().unwrap_or_default();
+            EventWrapper {
+                event_id,
+                data1: data1.into_raw() as uintptr_t,
+                data2: 0,
+            }
+        }
+        Event::SecurejoinInviterProgress {
+            contact_id,
+            progress,
+        }
+        | Event::SecurejoinJoinerProgress {
+            contact_id,
+            progress,
+        } => EventWrapper {
+            event_id,
+            data1: contact_id as uintptr_t,
+            data2: progress as uintptr_t,
+        },
+        Event::SecurejoinMemberAdded {
+            chat_id,
+            contact_id,
+        } => EventWrapper {
+            event_id,
+            data1: chat_id.to_u32() as uintptr_t,
+            data2: contact_id as uintptr_t,
+        },
+    };
+
+    Box::into_raw(Box::new(wrapper))
 }
 
 #[no_mangle]

python/src/deltachat/__init__.py

@@ -13,7 +13,6 @@ except DistributionNotFound:
 _DC_CALLBACK_MAP = {}
 
 
-@capi.ffi.def_extern()
 def py_dc_callback(ctx, evt, data1, data2):
     """The global event handler.
 
@@ -32,9 +31,9 @@ def py_dc_callback(ctx, evt, data1, data2):
     evt_name = get_dc_event_name(evt)
     event_sig_types = capi.lib.dc_get_event_signature_types(evt)
     if data1 and event_sig_types & 1:
-        data1 = ffi.string(ffi.cast('char*', data1)).decode("utf8")
+        data1 = ffi.string(ffi.gc(ffi.cast('char*', data1), capi.lib.dc_str_unref)).decode("utf8")
     if data2 and event_sig_types & 2:
-        data2 = ffi.string(ffi.cast('char*', data2)).decode("utf8")
+        data2 = ffi.string(ffi.gc(ffi.cast('char*', data2), capi.lib.dc_str_unref)).decode("utf8")
         try:
             if isinstance(data2, bytes):
                 data2 = data2.decode("utf8")
@@ -43,18 +42,9 @@ def py_dc_callback(ctx, evt, data1, data2):
             # i don't want to hunt down encoding problems in the c lib
             pass
     try:
-        ret = callback(ctx, evt_name, data1, data2)
+        callback(ctx, evt_name, data1, data2)
-        if ret is None:
-            ret = 0
-        assert isinstance(ret, int), repr(ret)
-        if event_sig_types & 4:
-            return ffi.cast('uintptr_t', ret)
-        elif event_sig_types & 8:
-            return ffi.cast('int', ret)
     except:  # noqa
         raise
-        ret = 0
-    return ret
 
 
 def set_context_callback(dc_context, func):

python/src/deltachat/_build.py

@@ -92,13 +92,6 @@ def ffibuilder():
     finally:
         shutil.rmtree(tmpdir)
 
-    builder.cdef("""
-        extern "Python" uintptr_t py_dc_callback(
-            dc_context_t* context,
-            int event,
-            uintptr_t data1,
-            uintptr_t data2);
-    """)
     return builder
 
 

python/src/deltachat/account.py

@@ -565,12 +565,14 @@ class IOThreads:
         self._thread_quitflag = False
         self._name2thread = {}
         self._log_event = log_event
+        self._running = False
 
     def is_started(self):
-        return len(self._name2thread) > 0
+        return self._running
 
     def start(self, imap=True, smtp=True, mvbox=False, sentbox=False):
         assert not self.is_started()
+        self._running = True
         self._start_one_thread("deltachat", self.dc_thread_run)
 
     def _start_one_thread(self, name, func):
@@ -583,11 +585,25 @@ class IOThreads:
         if wait:
             for name, thread in self._name2thread.items():
                 thread.join()
+        self._running = False
 
     def dc_thread_run(self):
         self._log_event("py-bindings-info", 0, "DC THREAD START")
 
-        lib.dc_context_run(self._dc_context, lib.py_dc_callback)
+        lib.dc_context_run(self._dc_context)
+        while self._running:
+            if lib.dc_has_next_event(self._dc_context):
+                event = lib.dc_get_next_event(self._dc_context)
+                if event != ffi.NULL:
+                    deltachat.py_dc_callback(
+                        self._dc_context,
+                        lib.dc_event_get_id(event),
+                        lib.dc_event_get_data1(event),
+                        lib.dc_event_get_data2(event)
+                    )
+                    lib.dc_event_unref(event)
+                else:
+                    time.sleep(0.05)
 
         self._log_event("py-bindings-info", 0, "DC THREAD FINISHED")
 

python/tests/test_lowlevel.py

@@ -1,5 +1,6 @@
 from __future__ import print_function
 import threading
+import time
 from deltachat import capi, cutil, const, set_context_callback, clear_context_callback
 from deltachat.capi import ffi
 from deltachat.capi import lib
@@ -11,12 +12,27 @@ class EventThread(threading.Thread):
         self.dc_context = dc_context
         super(EventThread, self).__init__()
         self.setDaemon(1)
+        self._running = True
 
     def run(self):
-        lib.dc_context_run(self.dc_context)#, lib.py_dc_callback)
+        lib.dc_context_run(self.dc_context)
+        while self._running: 
+            if lib.dc_has_next_event(self.dc_context):
+                event = lib.dc_get_next_event(self.dc_context)
+                if event != ffi.NULL:
+                    deltachat.py_dc_callback(
+                        self._dc_context,
+                        lib.dc_event_get_id(event),
+                        lib.dc_event_get_data1(event),
+                        lib.dc_event_get_data2(event)
+                    )
+                    lib.dc_event_unref(event)
+                else:
+                    time.sleep(0.05)
 
     def stop(self):
         lib.dc_context_shutdown(self.dc_context)
+        self._running = False
 
 
 def test_empty_context():
@@ -40,39 +56,41 @@ def test_start_stop_event_thread_basic():
     print("4 -- stopping event thread")
     ev_thread.stop()
 
-def test_dc_close_events(tmpdir):
-    ctx = ffi.gc(
-        capi.lib.dc_context_new(ffi.NULL, ffi.NULL),
-        lib.dc_context_unref,
-    )
-    evlog = EventLogger(ctx)
-    evlog.set_timeout(5)
-    set_context_callback(
-        ctx,
-        lambda ctx, evt_name, data1, data2: evlog(evt_name, data1, data2)
-    )
-    ev_thread = EventThread(ctx)
-    ev_thread.start()
 
-    p = tmpdir.join("hello.db")
+# FIXME: EventLogger doesn't work without an account anymore
-    lib.dc_open(ctx, p.strpath.encode("ascii"), ffi.NULL)
+# def test_dc_close_events(tmpdir):
-    capi.lib.dc_close(ctx)
+#     ctx = ffi.gc(
+#         capi.lib.dc_context_new(ffi.NULL, ffi.NULL),
+#         lib.dc_context_unref,
+#     )
+#     evlog = EventLogger(ctx)
+#     evlog.set_timeout(5)
+#     set_context_callback(
+#         ctx,
+#         lambda ctx, evt_name, data1, data2: evlog(evt_name, data1, data2)
+#     )
+#     ev_thread = EventThread(ctx)
+#     ev_thread.start()
 
-    def find(info_string):
+#     p = tmpdir.join("hello.db")
-        while 1:
+#     lib.dc_open(ctx, p.strpath.encode("ascii"), ffi.NULL)
-            ev = evlog.get_matching("DC_EVENT_INFO", check_error=False)
+#     capi.lib.dc_close(ctx)
-            data2 = ev[2]
-            if info_string in data2:
-                return
-            else:
-                print("skipping event", *ev)
 
-    find("disconnecting inbox-thread")
+#     def find(info_string):
-    find("disconnecting sentbox-thread")
+#         while 1:
-    find("disconnecting mvbox-thread")
+#             ev = evlog.get_matching("DC_EVENT_INFO", check_error=False)
-    find("disconnecting SMTP")
+#             data2 = ev[2]
-    find("Database closed")
+#             if info_string in data2:
-    ev_thread.stop()
+#                 return
+#             else:
+#                 print("skipping event", *ev)
+
+#     find("disconnecting inbox-thread")
+#     find("disconnecting sentbox-thread")
+#     find("disconnecting mvbox-thread")
+#     find("disconnecting SMTP")
+#     find("Database closed")
+#     ev_thread.stop()
 
 
 def test_wrong_db(tmpdir):
@@ -113,6 +131,8 @@ def test_sig():
 
 def test_markseen_invalid_message_ids(acfactory):
     ac1 = acfactory.get_configured_offline_account()
+    
+    ac1.start_threads()
     contact1 = ac1.create_contact(email="some1@example.com", name="some1")
     chat = ac1.create_chat_by_contact(contact1)
     chat.send_text("one messae")
@@ -120,6 +140,7 @@ def test_markseen_invalid_message_ids(acfactory):
     msg_ids = [9]
     lib.dc_markseen_msgs(ac1._dc_context, msg_ids, len(msg_ids))
     ac1._evlogger.ensure_event_not_queued("DC_EVENT_WARNING|DC_EVENT_ERROR")
+    ac1.stop_threads()
 
 
 def test_get_special_message_id_returns_empty_message(acfactory):