Add login, connection and error listeners

Author: Shubham

objectbox/c.py

@@ -299,18 +299,6 @@ class SyncState(IntEnum):
     STOPPED = 6
     DEAD = 7
 
-
-class SyncCode(IntEnum):
-    OK = 20
-    REQ_REJECTED = 40
-    CREDENTIALS_REJECTED = 43
-    UNKNOWN = 50
-    AUTH_UNREACHABLE = 53
-    BAD_VERSION = 55
-    CLIENT_ID_TAKEN = 61
-    TX_VIOLATED_UNIQUE = 71
-
-
 class OBXSyncError(IntEnum):
     REJECT_TX_NO_PERMISSION = 1  # Sync client received rejection of transaction writes due to missing permissions
 
@@ -1222,4 +1210,12 @@ def c_array_pointer(py_list: Union[List[Any], np.ndarray], c_type):
 obx_sync_protocol_version = c_fn('obx_sync_protocol_version', ctypes.c_uint32, [])
 obx_sync_protocol_version_server = c_fn('obx_sync_protocol_version_server', ctypes.c_uint32, [OBX_sync_p])
 
-obx_sync_close = c_fn_rc('obx_sync_close', [OBX_sync_p])
+obx_sync_close = c_fn_rc('obx_sync_close', [OBX_sync_p])
+
+obx_sync_listener_connect = c_fn('obx_sync_listener_connect', None, [OBX_sync_p, OBX_sync_listener_connect, ctypes.c_void_p])
+obx_sync_listener_disconnect = c_fn('obx_sync_listener_disconnect', None, [OBX_sync_p, OBX_sync_listener_disconnect, ctypes.c_void_p])
+obx_sync_listener_login = c_fn('obx_sync_listener_login', None, [OBX_sync_p, OBX_sync_listener_login, ctypes.c_void_p])
+obx_sync_listener_login_failure = c_fn('obx_sync_listener_login_failure', None, [OBX_sync_p, OBX_sync_listener_login_failure, ctypes.c_void_p])
+obx_sync_listener_error = c_fn('obx_sync_listener_error', None, [OBX_sync_p, OBX_sync_listener_error, ctypes.c_void_p])
+
+obx_sync_wait_for_logged_in_state = c_fn_rc('obx_sync_wait_for_logged_in_state', [OBX_sync_p, ctypes.c_uint64])

objectbox/sync.py

@@ -1,7 +1,13 @@
 import ctypes
+from collections.abc import Callable
+from ctypes import c_void_p
+
 import objectbox.c as c
 from objectbox import Store
-from enum import Enum, auto
+from enum import Enum, auto, IntEnum
+
+from objectbox.c import OBX_sync_listener_login
+
 
 class SyncCredentials:
 
@@ -86,6 +92,15 @@ class SyncLoginEvent:
     CREDENTIALS_REJECTED = 'credentials_rejected'
     UNKNOWN_ERROR = 'unknown_error'
 
+class SyncCode(IntEnum):
+    OK = 20
+    REQ_REJECTED = 40
+    CREDENTIALS_REJECTED = 43
+    UNKNOWN = 50
+    AUTH_UNREACHABLE = 53
+    BAD_VERSION = 55
+    CLIENT_ID_TAKEN = 61
+    TX_VIOLATED_UNIQUE = 71
 
 class SyncChange:
     def __init__(self, entity_id: int, entity: type, puts: list[int], removals: list[int]):
@@ -94,11 +109,36 @@ def __init__(self, entity_id: int, entity: type, puts: list[int], removals: list
         self.puts = puts
         self.removals = removals
 
+class SyncLoginListener:
+
+    def on_logged_in(self):
+        pass
+
+    def on_login_failed(self, sync_login_code: SyncCode):
+        pass
+
+class SyncConnectionListener:
+
+    def on_connected(self):
+        pass
+
+    def on_disconnected(self):
+        pass
+
+class SyncErrorListener:
+
+    def on_error(self, sync_error_code: int):
+        pass
 
 class SyncClient:
 
-    def __init__(self, store: Store, server_urls: list[str], credentials: list[SyncCredentials],
+    def __init__(self, store: Store, server_urls: list[str],
                  filter_variables: dict[str, str] | None = None):
+        self.__c_login_listener = None
+        self.__c_login_failure_listener = None
+        self.__c_connect_listener = None
+        self.__c_disconnect_listener = None
+        self.__c_error_listener = None
         if not server_urls:
             raise ValueError("Provide at least one server URL")
 
@@ -109,14 +149,13 @@ def __init__(self, store: Store, server_urls: list[str], credentials: list[SyncC
         #         'Please visit https://objectbox.io/sync/ for options.')
 
         self.__store = store
-        self.__server_urls = server_urls
-        self.__credentials = credentials
+        self.__server_urls = [url.encode('utf-8') for url in server_urls]
 
-        server_urls = [url.encode('utf-8') for url in server_urls]
-        self.__c_sync_client_ptr = c.obx_sync_urls(store.c_store(), c.c_array_pointer(server_urls, ctypes.c_char_p),
-                                                   len(server_urls))
+        self.__c_sync_client_ptr = c.obx_sync_urls(store.c_store(), c.c_array_pointer(self.__server_urls, ctypes.c_char_p),
+                                                   len(self.__server_urls))
 
     def set_credentials(self, credentials: SyncCredentials):
+        self.__credentials = credentials
         if isinstance(credentials, SyncCredentialsNone):
             c.obx_sync_credentials(self.__c_sync_client_ptr, credentials.type, None, 0)
         elif isinstance(credentials, SyncCredentialsUserPassword):
@@ -181,3 +220,42 @@ def close(self):
 
     def is_closed(self) -> bool:
         return self.__c_sync_client_ptr is None
+
+    def set_login_listener(self, login_listener: SyncLoginListener):
+        self.__c_login_listener = c.OBX_sync_listener_login(lambda arg: login_listener.on_logged_in())
+        self.__c_login_failure_listener = c.OBX_sync_listener_login_failure(lambda arg, sync_login_code: login_listener.on_login_failed(sync_login_code))
+        c.obx_sync_listener_login(
+            self.__c_sync_client_ptr,
+            self.__c_login_listener,
+            None
+        )
+        c.obx_sync_listener_login_failure(
+            self.__c_sync_client_ptr,
+            self.__c_login_failure_listener,
+            None
+        )
+
+    def set_connection_listener(self, connection_listener: SyncConnectionListener):
+        self.__c_connect_listener = c.OBX_sync_listener_connect(lambda arg: connection_listener.on_connected())
+        self.__c_disconnect_listener = c.OBX_sync_listener_disconnect(lambda arg: connection_listener.on_disconnected())
+        c.obx_sync_listener_connect(
+            self.__c_sync_client_ptr,
+            self.__c_connect_listener,
+            None
+        )
+        c.obx_sync_listener_disconnect(
+            self.__c_sync_client_ptr,
+            self.__c_disconnect_listener,
+            None
+        )
+
+    def set_error_listener(self, error_listener: SyncErrorListener):
+        self.__c_error_listener = c.OBX_sync_listener_error(lambda arg, sync_error_code: error_listener.on_error(sync_error_code))
+        c.obx_sync_listener_error(
+            self.__c_sync_client_ptr,
+            self.__c_error_listener,
+            None
+        )
+
+    def wait_for_logged_in_state(self, timeout_millis: int):
+        c.obx_sync_wait_for_logged_in_state(self.__c_sync_client_ptr, timeout_millis)

tests/conftest.py

@@ -1,5 +1,6 @@
 import pytest
 from objectbox.logger import logger
+from objectbox.sync import SyncLoginListener, SyncConnectionListener, SyncErrorListener
 from common import *
 
 
@@ -19,3 +20,54 @@ def test_store():
     store = create_test_store()
     yield store
     store.close()
+
+class TestLoginListener(SyncLoginListener):
+    def __init__(self):
+        self.logged_in_called = False
+        self.login_failure_code = None
+
+    def on_logged_in(self):
+        self.logged_in_called = True
+
+    def on_login_failed(self, sync_login_code: int):
+        self.login_failure_code = sync_login_code
+
+
+class TestConnectionListener(SyncConnectionListener):
+    def __init__(self):
+        self.connected_called = False
+        self.disconnected_called = False
+
+    def on_connected(self):
+        self.connected_called = True
+
+    def on_disconnected(self):
+        self.disconnected_called = True
+
+
+class TestErrorListener(SyncErrorListener):
+    def __init__(self):
+        self.sync_error_code = None
+
+    def on_error(self, sync_error_code: int):
+        self.sync_error_code = sync_error_code
+
+@pytest.fixture
+def connection_listener():
+    listener = TestConnectionListener()
+    yield listener
+    listener.connected_called = False
+    listener.disconnected_called = False
+
+@pytest.fixture
+def login_listener():
+    listener = TestLoginListener()
+    yield listener
+    listener.logged_in_called = False
+    listener.login_failure_code = None
+
+@pytest.fixture
+def error_listener():
+    listener = TestErrorListener()
+    yield listener
+    listener.sync_error_code = None

tests/test_sync.py

@@ -1,11 +1,10 @@
+from time import sleep
 from objectbox.sync import *
 
-
 def test_sync_protocol_version():
     version = SyncClient.protocol_version()
     assert version >= 1
 
-
 def test_sync_client_states(test_store):
     server_urls = ["ws://localhost:9999"]
     credentials = [SyncCredentials.none()]
@@ -16,3 +15,20 @@ def test_sync_client_states(test_store):
     client.stop()
     assert client.get_sync_state() == SyncState.STOPPED
     client.close()
+
+def test_sync_listener(test_store, login_listener, connection_listener):
+    server_urls = ["ws://127.0.0.1:9999"]
+    client = SyncClient(test_store, server_urls)
+    client.set_credentials(SyncCredentials.shared_secret_string("shared_secret"))
+    client.set_login_listener(login_listener)
+    client.set_connection_listener(connection_listener)
+
+    client.start()
+    sleep(1)
+    client.stop()
+    client.close()
+
+    assert login_listener.login_failure_code is not None
+    assert login_listener.login_failure_code == SyncCode.CREDENTIALS_REJECTED
+    assert connection_listener.connected_called
+    assert connection_listener.disconnected_called