@dittolive/ditto 4.12.0 → 5.0.0-experimental.js-cocoapods-publishing.3

package/react-native/android/dittoffi/src/dittoffi_java.h

@@ -350,21 +350,15 @@ public:
     virtual ~SwigDirector_PresenceRust();
     virtual void java_retain();
     virtual void java_release();
-    virtual void v1Callback(char const *const json);
-    virtual void v2Callback(char const *const json);
     virtual void v3Callback(char const *const json);
-    virtual void register_v1();
-    virtual void register_v2();
     virtual void register_v3();
-    virtual void requestV1Update();
-    virtual void requestV2Update();
     virtual void requestV3Update();
 public:
     bool swig_overrides(int n) {
-      return (n < 11 ? swig_override[n] : false);
+      return (n < 5 ? swig_override[n] : false);
     }
 protected:
-    Swig::BoolArray<11> swig_override;
+    Swig::BoolArray<5> swig_override;
 };
 
 class SwigDirector_StoreObserverHandlerRust : public StoreObserverHandlerRust, public Swig::Director {

package/react-native/android/dittoffi/src/dittoffi_java.i

@@ -25,6 +25,7 @@
 %include "ditto_transaction.h"
 %include "dittomesh_java.i"
 %include "dittostore_java.i"
+%include "ditto_c_string.i"
 extern "C" {
   %include "dittoffi.h"
 }

package/react-native/android/dittoffi/src/dittomesh_java.i

@@ -17,15 +17,6 @@ typedef int int32_t;
 %include "cpointer.i"
 %include <stdint.i>
 
-%typemap(newfree) char * {
-  if ($1 != NULL) {
-    ditto_c_string_free($1);
-  }
-}
-%newobject ditto_auth_client_user_id;
-%newobject dittoffi_authentication_status_user_id;
-%newobject ditto_set_device_name;
-
 %typemap(in, numinputs=0) EnvMarker {
   // This code runs inside the JNI wrapper, where 'jenv' is available.
   current_env = jenv;

package/react-native/android/dittoffi/src/dittostore_java.i

@@ -454,21 +454,20 @@
     ) {
       return unsigned_long_ints[index];
     }
-  }
-%}
 
-// Here we use a typemap to say that for functions that return `char *` and are
-// marked with the `%newobject` directive we have custom behaviour for freeing
-// the returned value. This ensures all strings get cleaned up.
-%typemap(newfree) char * {
-  if ($1 != NULL) {
-    ditto_c_string_free($1);
+    // This makes working with sync subscriptions easier
+    dittoffi_sync_subscription_t const * dittoffi_sync_subscription_at_index(
+      dittoffi_sync_subscription_t const * * subscriptions,
+      unsigned long int index
+    ) {
+      if (subscriptions == nullptr) {
+        throw std::invalid_argument("subscriptions pointer is null");
+      }
+
+      return subscriptions[index];
+    }
   }
-}
-%newobject ditto_error_message;
-%newobject ditto_get_complete_attachment_path;
-%newobject ditto_get_sdk_version;
-%newobject ditto_document_id_query_compatible;
+%}
 
 // To make it possible (or at least a lot easier) to work with pointers to some
 // of the Ditto_* types we use the `%pointer_functions` directive to provide a

package/react-native/android/dittoffi/src/presence.h

@@ -17,55 +17,19 @@ public:
     explicit PresenceRust(CDitto_t *ditto) : ditto(ditto) {}
     ~PresenceRust() override = default;
 
-    virtual void v1Callback(const char *const json) = 0;
-    virtual void v2Callback(const char *const json) = 0;
     virtual void v3Callback(const char *const json) = 0;
 
-    static void invokeV1Callback(void *const ctx, const char *json) {
-        const auto inst = static_cast<PresenceRust *>(ctx);
-        return inst->v1Callback(json);
-    }
-
-    static void invokeV2Callback(void *const ctx, const char *const json) {
-        const auto inst = static_cast<PresenceRust *>(ctx);
-        return inst->v2Callback(json);
-    }
-
     static void invokeV3Callback(void *const ctx, const char *const json) {
         const auto inst = static_cast<PresenceRust *>(ctx);
         return inst->v3Callback(json);
     }
 
-    virtual void register_v1() {
-        ditto_register_presence_v1_callback(ditto, this, PresenceRust::invokeRetain,
-                                            PresenceRust::invokeRelease,
-                                            PresenceRust::invokeV1Callback);
-    }
-
-    virtual void register_v2() {
-        ditto_register_presence_v2_callback(ditto, this, PresenceRust::invokeRetain,
-                                            PresenceRust::invokeRelease,
-                                            PresenceRust::invokeV2Callback);
-    }
-
     virtual void register_v3() {
         ditto_register_presence_callback_v3(ditto, this, PresenceRust::invokeRetain,
                                             PresenceRust::invokeRelease,
                                             PresenceRust::invokeV3Callback);
     }
 
-    virtual void requestV1Update() {
-        auto json = ditto_presence_v1(ditto);
-        v1Callback(json);
-        ditto_c_string_free(json);
-    }
-
-    virtual void requestV2Update() {
-        auto json = ditto_presence_v2(ditto);
-        v2Callback(json);
-        ditto_c_string_free(json);
-    }
-
     // Handler for a single update. Called immediately after register_v3 is invoked to deliver a
     // fresh value to the observer.
     virtual void requestV3Update() {

package/react-native/cpp/include/DQL.h

@@ -7,8 +7,6 @@ using namespace facebook::jsi;
 
 namespace sharedjsi {
 Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime &runtime);
-Function dittoffi_try_add_sync_subscription(Runtime &runtime);
-Function dittoffi_try_remove_sync_subscription(Runtime &runtime);
 Function dittoffi_try_exec_statement(Runtime &runtime);
 Function dittoffi_query_result_item_count(Runtime &runtime);
 Function dittoffi_query_result_item_at(Runtime &runtime);

package/react-native/cpp/include/Presence.h

@@ -13,8 +13,6 @@ Function ditto_clear_presence_v3_callback(Runtime &runtime);
 Function dittoffi_presence_peer_metadata_json(Runtime &runtime);
 Function dittoffi_presence_try_set_peer_metadata_json(Runtime &runtime);
 Function dittoffi_presence_set_connection_request_handler(Runtime &runtime);
-Function ditto_presence_v1(Runtime &runtime);
-Function ditto_register_presence_v1_callback(Runtime &runtime);
 Function ditto_clear_presence_callback(Runtime &runtime);
 }
 #endif /* Presence_H */

package/react-native/cpp/include/SyncSubscription.h

@@ -0,0 +1,20 @@
+#ifndef SyncSubscription_H
+#define SyncSubscription_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi {
+Function dittoffi_sync_register_subscription_throws(Runtime &runtime);
+Function dittoffi_sync_subscriptions(Runtime &runtime);
+Function dittoffi_sync_subscription_id(Runtime &runtime);
+Function dittoffi_sync_subscription_query_string(Runtime &runtime);
+Function dittoffi_sync_subscription_query_arguments_cbor(Runtime &runtime);
+Function dittoffi_sync_subscription_query_arguments_json(Runtime &runtime);
+Function dittoffi_sync_subscription_cancel(Runtime &runtime);
+Function dittoffi_sync_subscription_is_cancelled(Runtime &runtime);
+Function dittoffi_sync_subscription_free(Runtime &runtime);
+}
+
+#endif /* SyncSubscription_H */

package/react-native/cpp/src/DQL.cpp

@@ -26,65 +26,6 @@ void v_change_handler_with_query_result(void *ctx, ChangeHandlerWithQueryResult_
 }
 }
 
-Function dittoffi_try_add_sync_subscription(Runtime &runtime)
-{
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    std::string query_str = jsTypedArrayToCString(runtime, arguments[1]);
-    const char *query = query_str.c_str();
-
-    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
-    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
-
-    dittoffi_result_void_t res = ::dittoffi_try_add_sync_subscription(ditto, query, query_args_cbor);
-
-    Object obj(runtime);
-    if (res.error != nullptr) {
-      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
-    } else {
-      obj.setProperty(runtime, "error", Value::null());
-    }
-    return obj;
-  });
-}
-
-Function dittoffi_try_remove_sync_subscription(Runtime &runtime)
-{
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    std::string query_str = jsTypedArrayToCString(runtime, arguments[1]);
-    const char *query = query_str.c_str();
-
-    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
-    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
-    dittoffi_result_void_t res = ::dittoffi_try_remove_sync_subscription(ditto, query, query_args_cbor);
-
-    Object obj(runtime);
-    if (res.error != nullptr) {
-      obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
-    } else {
-      obj.setProperty(runtime, "error", Value::null());
-    }
-    return obj;
-  });
-}
-
 Function dittoffi_try_exec_statement(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,

package/react-native/cpp/src/Lifecycle.cpp

@@ -57,11 +57,6 @@ Function dittoffi_ditto_try_new_blocking(Runtime &runtime)
     std::string experimental_passphrase = jsTypedArrayToCString(runtime, arguments[3]);
     std::string transport_config_mode_str = arguments[4].toString(runtime).utf8(runtime);
 
-    Function createDirFunc = runtime.global().getPropertyAsFunction(runtime, "createDirectory");
-    Value pathArg = String::createFromUtf8(runtime, path);
-    Value resolvedPathValue = createDirFunc.call(runtime, pathArg);
-    std::string finalPath = resolvedPathValue.asString(runtime).utf8(runtime);
-
     HistoryTracking_t history_tracking;
     if (history_tracking_str == "Disabled") {
       history_tracking = HISTORY_TRACKING_DISABLED;
@@ -81,7 +76,7 @@ Function dittoffi_ditto_try_new_blocking(Runtime &runtime)
     }
 
     dittoffi_result_CDitto_ptr_t res = ::dittoffi_ditto_try_new_blocking(
-        finalPath.c_str(),
+        path.c_str(),
         identity_config,
         history_tracking,
         experimental_passphrase.empty() ? nullptr: experimental_passphrase.c_str(),

package/react-native/cpp/src/Presence.cpp

@@ -165,46 +165,6 @@ Function dittoffi_presence_set_connection_request_handler(Runtime &runtime)
   });
 }
 
-Function ditto_presence_v1(Runtime &runtime)
-{
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    char *res = ::ditto_presence_v1(jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]));
-    return cPointerToJSPointerObject<char>(runtime, res);
-  });
-}
-
-Function ditto_register_presence_v1_callback(Runtime &runtime)
-{
-  return Function::createFromHostFunction(runtime,
-                                          PropNameID::forAscii(runtime,
-                                                               STRINGIFIED_FUNC_NAME()),
-                                          0,
-                                          [](Runtime &runtime,
-                                             const Value &thisValue,
-                                             const Value *arguments,
-                                             size_t count) -> Value
-                                          {
-    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
-    Function presence_callback = arguments[1].getObject(runtime).getFunction(runtime);
-    Arc<Function> wrappedStateFfiWrapper /* = */ (std::move(presence_callback));
-
-    ::ditto_register_presence_v1_callback(ditto,
-                                          Arc<Function>::as_raw(wrappedStateFfiWrapper),
-                                          v_retain,
-                                          v_release,
-                                          v_presence_callback);
-    return {};
-  });
-}
-
 Function ditto_clear_presence_callback(Runtime &runtime)
 {
   return Function::createFromHostFunction(runtime,

package/react-native/cpp/src/SyncSubscription.cpp

@@ -0,0 +1,180 @@
+#include <SyncSubscription.h>
+
+#include "Utils.h"
+
+namespace sharedjsi
+{
+
+Function dittoffi_sync_register_subscription_throws(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    std::string query_str = jsTypedArrayToCString(runtime, arguments[1]);
+    const char *query = query_str.c_str();
+
+    std::vector<uint8_t> query_args_cbor_vec = jsTypedArrayToCVector(runtime, arguments[2]);
+    slice_ref_uint8_t query_args_cbor = borrowVecAsOptRefSlice(query_args_cbor_vec);
+
+    dittoffi_result_dittoffi_sync_subscription_ptr_t res = ::dittoffi_sync_register_subscription_throws(ditto, query, query_args_cbor);
+
+    Object obj(runtime);
+    obj.setProperty(runtime, "success", cPointerToJSPointerObject(runtime, res.success));
+    obj.setProperty(runtime, "error", cPointerToJSPointerObject(runtime, res.error));
+    return obj;
+  });
+}
+
+Function dittoffi_sync_subscriptions(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ditto = jsPointerObjectToCPointer<CDitto_t>(runtime, arguments[0]);
+    Vec_dittoffi_sync_subscription_ptr_t res = ::dittoffi_sync_subscriptions(ditto);
+
+    jsi::Array jsArray(runtime, res.len);
+
+    for (size_t i = 0; i < res.len; ++i) {
+      dittoffi_sync_subscription_t *ffi_subscription = res.ptr[i];
+      auto jsObj = cPointerToJSPointerObject<dittoffi_sync_subscription_t>(runtime, ffi_subscription);
+      jsArray.setValueAtIndex(runtime, i, jsObj);
+    }
+
+    ::dittoffi_sync_subscriptions_free_sparse(res);
+
+    return jsArray;
+  });
+}
+
+Function dittoffi_sync_subscription_id(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    slice_boxed_uint8_t id_cbor = ::dittoffi_sync_subscription_id(ffi_sync_subscription);
+    return cSlicedBoxToJSSlicedBox(runtime, id_cbor);
+  });
+}
+
+Function dittoffi_sync_subscription_query_string(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    char *res = ::dittoffi_sync_subscription_query_string(ffi_sync_subscription);
+    return cPointerToJSPointerObject<char>(runtime, res);
+  });
+}
+
+Function dittoffi_sync_subscription_query_arguments_cbor(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    slice_boxed_uint8_t id_cbor = ::dittoffi_sync_subscription_query_arguments_cbor(ffi_sync_subscription);
+    return cSlicedBoxToJSSlicedBox(runtime, id_cbor);
+  });
+}
+
+Function dittoffi_sync_subscription_query_arguments_json(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    slice_boxed_uint8_t id_json_bytes = ::dittoffi_sync_subscription_query_arguments_json(ffi_sync_subscription);
+    return cSlicedBoxToJSSlicedBox(runtime, id_json_bytes);
+  });
+}
+
+Function dittoffi_sync_subscription_cancel(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    ::dittoffi_sync_subscription_cancel(ffi_sync_subscription);
+    return {};
+  });
+}
+
+Function dittoffi_sync_subscription_is_cancelled(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    return ::dittoffi_sync_subscription_is_cancelled(ffi_sync_subscription);
+  });
+}
+
+Function dittoffi_sync_subscription_free(Runtime &runtime)
+{
+  return Function::createFromHostFunction(runtime,
+                                          PropNameID::forAscii(runtime,
+                                                               STRINGIFIED_FUNC_NAME()),
+                                          0,
+                                          [](Runtime &runtime,
+                                             const Value &thisValue,
+                                             const Value *arguments,
+                                             size_t count) -> Value
+                                          {
+    auto *ffi_sync_subscription = jsPointerObjectToCPointer<dittoffi_sync_subscription_t>(runtime, arguments[0]);
+    ::dittoffi_sync_subscription_free(ffi_sync_subscription);
+    return {};
+  });
+}
+}

package/react-native/cpp/src/main.cpp

@@ -1,27 +1,29 @@
 #include <jsi/jsi.h>
 
 #include "main.h"
-#include "Utils.h"
-#include "DQL.h"
+
+#include "Authentication.h"
+#include "Attachment.h"
+#include "Collection.h"
+#include "ConnectionRequest.h"
 #include "Differ.h"
 #include "Document.h"
-#include "Authentication.h"
-#include "Sync.h"
-#include "Lifecycle.h"
-#include "Misc.h"
+#include "DQL.h"
+#include "FFIUtils.h"
+#include "GlobalCallInvoker.h"
 #include "Identity.h"
-#include "Presence.h"
-#include "Attachment.h"
+#include "IO.h"
+#include "Lifecycle.h"
 #include "LiveQuery.h"
-#include "Collection.h"
 #include "Logger.h"
+#include "Misc.h"
+#include "Presence.h"
 #include "SmallPeerInfo.h"
-#include "Transports.h"
-#include "IO.h"
-#include "FFIUtils.h"
-#include "ConnectionRequest.h"
-#include "GlobalCallInvoker.h"
+#include "Sync.h"
+#include "SyncSubscription.h"
 #include "Transaction.h"
+#include "Transports.h"
+#include "Utils.h"
 
 // Note: `runtime` variable must exist in scope.
 #define REGISTER_JS_FUNCTION(fname) runtime.global().setProperty(runtime, STRINGIFY(fname), fname(runtime));
@@ -95,8 +97,6 @@ namespace sharedjsi
 
     // DQL
     REGISTER_JS_FUNCTION(dittoffi_try_experimental_register_change_observer_str_detached);
-    REGISTER_JS_FUNCTION(dittoffi_try_add_sync_subscription);
-    REGISTER_JS_FUNCTION(dittoffi_try_remove_sync_subscription);
     REGISTER_JS_FUNCTION(dittoffi_try_exec_statement);
     REGISTER_JS_FUNCTION(dittoffi_query_result_item_count);
     REGISTER_JS_FUNCTION(dittoffi_query_result_item_at);
@@ -115,6 +115,17 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(dittoffi_differ_diff);
     REGISTER_JS_FUNCTION(dittoffi_differ_free);
 
+    // SyncSubscription
+    REGISTER_JS_FUNCTION(dittoffi_sync_register_subscription_throws);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscriptions);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_id);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_query_string);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_query_arguments_cbor);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_query_arguments_json);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_cancel);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_is_cancelled);
+    REGISTER_JS_FUNCTION(dittoffi_sync_subscription_free);
+
     // Documents
     REGISTER_JS_FUNCTION(ditto_document_id_query_compatible);
     REGISTER_JS_FUNCTION(ditto_document_id);
@@ -123,9 +134,6 @@ namespace sharedjsi
     REGISTER_JS_FUNCTION(ditto_validate_document_id);
 
     // Presence
-    REGISTER_JS_FUNCTION(ditto_presence_v1);
-    REGISTER_JS_FUNCTION(ditto_register_presence_v1_callback);
-    REGISTER_JS_FUNCTION(ditto_clear_presence_callback);
     REGISTER_JS_FUNCTION(ditto_presence_v3);
     REGISTER_JS_FUNCTION(ditto_register_presence_v3_callback);
     REGISTER_JS_FUNCTION(ditto_clear_presence_v3_callback);