Add Connection Status Listener. Add functions to Reconnect and Disconnect all subscriptions.

CMakeLists.txt

@@ -84,7 +84,7 @@ endif()
 FetchContent_Declare(
   pubnub
   GIT_REPOSITORY https://github.com/pubnub/c-core.git
-  GIT_TAG v5.0.0
+  GIT_TAG v5.0.2
   GIT_SHALLOW TRUE
   GIT_PROGRESS ON
   SYSTEM
@@ -107,9 +107,9 @@ endif()
 
 # TODO: this flag is okay until we release the Cpp-Chat as an independent library
 if(${ENABLE_C_ABI})
-    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unity/0.4.4\")
+    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unity/0.5.0\")
 else()
-    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unreal/0.4.0\")
+    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unreal/0.4.1\")
 endif()
 
 set(CCORE_COMPILE_OPTIONS -DPUBNUB_NTF_RUNTIME_SELECTION -DPUBNUB_USE_SUBSCRIBE_EVENT_ENGINE=1 -DPUBNUB_USE_SUBSCRIBE_V2=1 -DPUBNUB_CALLBACK_API=1 -DPUBNUB_SET_DNS_SERVERS=1 -DPUBNUB_USE_IPV6=1 -DPUBNUB_USE_LOG_CALLBACK=1)

c_abi/include/c_chat.hpp

@@ -227,4 +227,8 @@ PN_CHAT_EXTERN PN_CHAT_EXPORT PnCResult pn_pam_set_auth_token(Pubnub::Chat* chat
 
 PN_CHAT_EXTERN PN_CHAT_EXPORT PnCResult pn_pam_set_pubnub_origin(Pubnub::Chat* chat, const char* origin);
 
+PN_CHAT_EXTERN PN_CHAT_EXPORT PnCTribool pn_chat_reconnect_subscriptions(Pubnub::Chat* chat);
+
+PN_CHAT_EXTERN PN_CHAT_EXPORT PnCTribool pn_chat_disconnect_subscriptions(Pubnub::Chat* chat);
+
 #endif // PN_CHAT_C_CHAT_HPP

c_abi/src/c_chat.cpp

@@ -965,3 +965,27 @@ PnCResult pn_pam_set_pubnub_origin(Pubnub::Chat* chat, const char* origin) {
     return PN_C_OK;
 }
 
+
+PnCTribool pn_chat_reconnect_subscriptions(Pubnub::Chat* chat)
+{
+    try {
+        return chat->reconnect_subscriptions();
+    }
+    catch (std::exception& e) {
+        pn_c_set_error_message(e.what());
+
+        return PN_C_ERROR;
+    }
+}
+
+PnCTribool pn_chat_disconnect_subscriptions(Pubnub::Chat* chat)
+{
+    try {
+        return chat->disconnect_subscriptions();
+    }
+    catch (std::exception& e) {
+        pn_c_set_error_message(e.what());
+
+        return PN_C_ERROR;
+    }
+}

include/pubnub_chat/chat.hpp

@@ -110,6 +110,12 @@ namespace Pubnub {
         bool is_more;
     };
 
+    struct ConnectionStatusData
+    {
+        /**Error details in case of ConnectionError.*/
+        Pubnub::String reason = "";
+    };
+
 
 
     class Chat {
@@ -170,11 +176,20 @@ namespace Pubnub {
             PN_CHAT_EXPORT void remove_thread_channel(const Pubnub::Message& message) const;
 
             /* PAM */
+
             PN_CHAT_EXPORT Pubnub::AccessManager access_manager() const;
 
             /* LOG */
+
             PN_CHAT_EXPORT void register_logger_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback);
 
+            /* CONNECTION STATUS */
+
+            PN_CHAT_EXPORT void add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> connection_status_callback) const;
+            PN_CHAT_EXPORT void remove_connection_status_listener() const;
+            PN_CHAT_EXPORT bool reconnect_subscriptions() const;
+            PN_CHAT_EXPORT bool disconnect_subscriptions() const;
+
         private:
             Chat(const Pubnub::String& publish_key, const Pubnub::String& subscribe_key, const Pubnub::String& user_id, const ChatConfig& config);
             void store_user_activity_timestamp() const;

include/pubnub_chat/enums.hpp

@@ -47,6 +47,12 @@ enum pn_log_level {
     Trace
 };
 
+enum pn_connection_status {
+    PCS_CONNECTION_ONLINE,
+    PCS_CONNECTION_OFFLINE,
+    PCS_CONNECTION_ERROR
+};
+
 }
 
 #endif // PN_ENUMS_HPP

src/application/callback_service.cpp

@@ -9,11 +9,14 @@
 #include "nlohmann/json.hpp"
 #include "domain/parsers.hpp"
 #include "message.hpp"
+#include "enum_converters.hpp"
 #include <algorithm>
 #include <cstring>
 #include <list>
 #include <pubnub_helper.h>
 #include <pubnub_subscribe_event_listener_types.h>
+#include <pubnub_subscribe_event_listener.h>
+
 
 using json = nlohmann::json;
 
@@ -738,3 +741,54 @@ CCoreCallbackData CallbackService::to_c_thread_messages_updates_callback(const s
         this->callback_contexts.emplace_back(CallbackCtx{messages, message_service, message_update_callback})
     };
 }
+
+
+void CallbackService::add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> listener)
+{
+    if(nullptr == listener)
+    {
+        return;
+    }
+
+    this->status_listener = listener;
+
+    //If subscription status listener was already added, we just replace status_listener variable, no need to add it again to C-Core
+    if(status_listener_added)
+    {
+        return;
+    }
+
+    pubnub_subscribe_status_callback_t callback = +[](const pubnub_t *pb, const pubnub_subscription_status status, const pubnub_subscription_status_data_t status_data, void* _data)
+    {
+        CallbackService* CallbackServicebject = static_cast<CallbackService*>(_data);
+        if(!CallbackServicebject || !CallbackServicebject->status_listener)
+        {
+            return;
+        }
+
+        //Don't call the listener if the subscription status is changed - this type is not supported in Chat SDK
+        if(status == PNSS_SUBSCRIPTION_STATUS_SUBSCRIPTION_CHANGED)
+        {
+            return;
+        }
+        else
+        {
+            Pubnub::ConnectionStatusData data;
+            data.reason = pubnub_res_2_string(status_data.reason);
+            CallbackServicebject->status_listener(Pubnub::pn_subscription_status_to_connection_status(status), data);
+        }
+    };
+    this->status_listener_callback = callback;
+    auto guard = this->pubnub->lock();
+    guard->add_subscription_status_listener(status_listener_callback, this);
+    this->status_listener_added = true;
+}
+
+void CallbackService::remove_connection_status_listener()
+{
+    auto guard = this->pubnub->lock();
+    guard->remove_subscription_status_listener(status_listener_callback, this);
+    this->status_listener_added = false;
+    this->status_listener = nullptr;
+    this->status_listener_callback = nullptr;
+}

src/application/callback_service.hpp

@@ -86,6 +86,9 @@ class CallbackService {
 
         void broadcast_messages(std::vector<pubnub_v2_message> messages);
 
+        void add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> listener);
+        void remove_connection_status_listener();
+
         CCoreCallbackData to_c_message_callback(std::weak_ptr<const ChatService> chat_service, std::function<void(Pubnub::Message)> message_callback);
         CCoreCallbackData to_c_channel_update_callback(Pubnub::Channel channel, std::shared_ptr<const ChannelService> chat_service, std::function<void(Pubnub::Channel)> channel_update_callback);
         CCoreCallbackData to_c_channels_updates_callback(const std::vector<Pubnub::Channel>& channels, std::shared_ptr<const ChannelService> chat_service, std::function<void(std::vector<Pubnub::Channel>)> channel_update_callback);
@@ -115,6 +118,10 @@ class CallbackService {
         std::thread callback_thread;
         std::atomic<bool> thread_run_flag;
         std::list<std::any> callback_contexts;
+
+        std::function<void(Pubnub::pn_connection_status, Pubnub::ConnectionStatusData)> status_listener;
+        pubnub_subscribe_status_callback_t status_listener_callback;
+        bool status_listener_added = false;
 };
 
 #endif // PN_CHAT_CALLBACK_SERVICE_HPP

src/application/chat_service.cpp

@@ -234,4 +234,24 @@ std::shared_ptr<Subscription> ChatService::listen_for_events(const Pubnub::Strin
 void ChatService::register_logger_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback) const
 {
     logger.register_logging_callback(callback);
-}
+}
+
+void ChatService::add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> connection_status_callback) const
+{
+    this->callback_service->add_connection_status_listener(connection_status_callback);
+}
+
+void ChatService::remove_connection_status_listener() const
+{
+    this->callback_service->remove_connection_status_listener();
+}
+
+bool ChatService::reconnect_subscriptions() const
+{
+    return this->pubnub->lock()->reconnect_subscriptions();
+}
+
+bool ChatService::disconnect_subscriptions() const
+{
+    return this->pubnub->lock()->disconnect_subscriptions();
+}

src/application/chat_service.hpp

@@ -60,6 +60,11 @@ class ChatService : public std::enable_shared_from_this<ChatService>
 
         std::shared_ptr<CallbackService> callback_service;
 
+        void add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> connection_status_callback) const;
+        void remove_connection_status_listener() const;
+        bool reconnect_subscriptions() const;
+        bool disconnect_subscriptions() const;
+
 
     private:
         ThreadSafePtr<PubNub> pubnub;

src/application/enum_converters.hpp

@@ -5,6 +5,10 @@
 #include "enums.hpp"
 #include <cstdint>
 
+extern "C" {
+#include <pubnub_subscribe_event_engine_types.h>
+}
+
 
 namespace Pubnub
 {
@@ -136,6 +140,22 @@ static inline pubnub_chat_event_type chat_event_type_from_string(Pubnub::String
 	throw std::invalid_argument("can't convert chat_event_type_string to pubnub_chat_event_type");
 }
 
+static inline Pubnub::pn_connection_status pn_subscription_status_to_connection_status(const pubnub_subscription_status subscription_status)
+{
+    switch(subscription_status)
+    {
+        case PNSS_SUBSCRIPTION_STATUS_CONNECTED:
+            return Pubnub::pn_connection_status::PCS_CONNECTION_ONLINE;
+        case PNSS_SUBSCRIPTION_STATUS_DISCONNECTED:
+            return Pubnub::pn_connection_status::PCS_CONNECTION_OFFLINE;
+        case PNSS_SUBSCRIPTION_STATUS_CONNECTION_ERROR:
+            return Pubnub::pn_connection_status::PCS_CONNECTION_ERROR;
+        case PNSS_SUBSCRIPTION_STATUS_DISCONNECTED_UNEXPECTEDLY:
+            return Pubnub::pn_connection_status::PCS_CONNECTION_ERROR;
+        default:
+            return Pubnub::pn_connection_status::PCS_CONNECTION_ERROR;
+    }       
+}
 }
 
 #endif // PN_ENUM_CONVERTERS_HPP

src/domain/message_entity.cpp

@@ -98,7 +98,6 @@ std::vector<std::pair<MessageEntity::MessageTimetoken, MessageEntity>> MessageEn
 
 MessageEntity MessageEntity::edit_text(const Pubnub::String& text, const Pubnub::String& timetoken) const {
     MessageEntity new_message_entity = *this;
-    new_message_entity.text = text;
 
     Pubnub::MessageAction message_action;
     message_action.type = Pubnub::pubnub_message_action_type::PMAT_Edited;

src/infra/pubnub.cpp

@@ -846,4 +846,27 @@ int PubNub::set_pubnub_origin(const Pubnub::String origin)
 void PubNub::set_logging_callback(void (*callback)(enum pubnub_log_level log_level, const char* message)) 
 {
     pubnub_set_log_callback(callback);
-}
+}
+
+void PubNub::add_subscription_status_listener(pubnub_subscribe_status_callback_t callback, void* user_data)
+{
+    pubnub_subscribe_add_status_listener(this->long_poll_context.get(), callback, user_data);
+}
+
+void PubNub::remove_subscription_status_listener(pubnub_subscribe_status_callback_t callback, void* user_data)
+{
+    pubnub_subscribe_remove_status_listener(this->long_poll_context.get(), callback, user_data);
+}
+
+bool PubNub::reconnect_subscriptions()
+{
+    auto result = pubnub_reconnect(this->long_poll_context.get(), nullptr);
+    return result == PNR_OK;
+}
+
+bool PubNub::disconnect_subscriptions()
+{
+    auto result = pubnub_disconnect(this->long_poll_context.get());
+    return result == PNR_OK;
+}
+

src/infra/pubnub.hpp

@@ -23,11 +23,8 @@ extern "C" {
 
 namespace Pubnub
 {
-    // class Message;
-    // class User;
-    // class Channel;
     class Chat;
-    // class Membership;
+    struct ConnectionStatusData;
 }
 // TODO: format file
 class PubNub {
@@ -79,6 +76,11 @@ class PubNub {
 
     void set_logging_callback(void (*callback)(enum pubnub_log_level log_level, const char* message));
 
+    void add_subscription_status_listener(pubnub_subscribe_status_callback_t callback, void* user_data);
+    void remove_subscription_status_listener(pubnub_subscribe_status_callback_t callback, void* user_data);
+    bool reconnect_subscriptions();
+    bool disconnect_subscriptions();
+
 private:
     void await_and_handle_error(pubnub_res result);
     bool is_subscribed_to_channel(const Pubnub::String channel);

src/presentation/chat.cpp

@@ -268,6 +268,26 @@ Pubnub::User Chat::create_user_for_init_chat(const Pubnub::String& user_id, cons
     return this->user_service->create_user(user_id, user_data, true);
 }
 
+void Chat::add_connection_status_listener(std::function<void(Pubnub::pn_connection_status status, Pubnub::ConnectionStatusData status_data)> connection_status_callback) const
+{
+    this->chat_service->add_connection_status_listener(connection_status_callback);
+}
+
+bool Chat::reconnect_subscriptions() const
+{
+    return this->chat_service->reconnect_subscriptions();
+}
+
+void Chat::remove_connection_status_listener() const
+{
+    this->chat_service->remove_connection_status_listener();
+}
+
+bool Chat::disconnect_subscriptions() const
+{
+    return this->chat_service->disconnect_subscriptions();
+}
+
 #ifdef PN_CHAT_C_ABI
 
 const ChatService* Chat::get_chat_service() const {