Add logger that prints c-core logs.

CMakeLists.txt

@@ -54,6 +54,7 @@ set(USE_CALLBACK_API ON)
 set(USE_SET_DNS_SERVERS ON)
 set(USE_IPV6 ON)
 set(USE_SUBSCRIBE_EVENT_ENGINE ON)
+set(USE_LOG_CALLBACK ON)
 set(USE_NTF_RUNTIME_SELECTION ON)
 
 if(WIN32 OR WIN64 OR MSVC)
@@ -63,7 +64,7 @@ endif()
 FetchContent_Declare(
   pubnub
   GIT_REPOSITORY https://github.com/pubnub/c-core.git
-  GIT_TAG feat/runtime-api-enforcement
+  GIT_TAG v5.0.0
   GIT_SHALLOW TRUE
   GIT_PROGRESS ON
   SYSTEM
@@ -88,9 +89,11 @@ endif()
 if(${ENABLE_C_ABI})
     target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unity/0.4.3\")
 else()
-    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unreal/0.3.0\")
+    target_compile_options(pubnub PUBLIC -DPUBNUB_SDK_VERSION_SUFFIX=\"/CA-Unreal/0.3.3\")
 endif()
-target_compile_options(pubnub PUBLIC -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)
+
+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)
+target_compile_options(pubnub PUBLIC ${CCORE_COMPILE_OPTIONS})
 
 FetchContent_Declare(
   json
@@ -133,7 +136,8 @@ set(INFRA_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/timer.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/pubnub.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/interval_task.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/rate_limiter.cpp)
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/rate_limiter.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/infra/logger.cpp)
 
 set(DOMAIN_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/domain/chat_entity.cpp 
@@ -181,8 +185,7 @@ set(SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/src/presentation/access_manager.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/presentation/callback_handle.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/chat_helpers.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/src/string.cpp
-)
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/string.cpp)
 
 if(${ENABLE_C_ABI})
     add_compile_definitions(PN_CHAT_C_ABI)
@@ -212,19 +215,19 @@ set(SOURCES
 
 add_library(pubnub-chat SHARED ${SOURCES})
 
-target_compile_options(pubnub-chat PRIVATE -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)
+target_compile_options(pubnub-chat PRIVATE ${CCORE_COMPILE_OPTIONS})
 
 target_link_libraries(pubnub-chat PRIVATE -lpthread pubnub)
 
 # TODO: kept for debugging purposes - should be deleted before release
 add_executable(pubnub-chat-example example/main.cpp)
-target_compile_options(pubnub-chat-example PRIVATE -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)
+target_compile_options(pubnub-chat-example PRIVATE ${CCORE_COMPILE_OPTIONS})
 target_link_libraries(pubnub-chat-example PUBLIC -lpthread pubnub-chat)
 
 if(${COMPILE_EXAMPLES})
     function(example name)
         add_executable(pubnub_${name} example/${name}.cpp)
-        target_compile_options(pubnub_${name} PRIVATE -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)
+        target_compile_options(pubnub_${name} PRIVATE ${CCORE_COMPILE_OPTIONS})
         target_link_libraries(pubnub_${name} PRIVATE pubnub-chat)
     endfunction()
 

include/pubnub_chat/chat.hpp

@@ -170,9 +170,13 @@ namespace Pubnub {
             /* 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);
+
         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;
+            Pubnub::User create_user_for_init_chat(const Pubnub::String& user_id, const Pubnub::ChatUserData& user_data) const;
 
             std::shared_ptr<const ChatService> chat_service;
             std::shared_ptr<const UserService> user_service;

include/pubnub_chat/enums.hpp

@@ -38,6 +38,15 @@ enum EventMethod {
     Signal
 };
 
+enum pn_log_level {
+    None,
+    Error,
+    Warning,
+    Info,
+    Debug,
+    Trace
+};
+
 }
 
 #endif // PN_ENUMS_HPP

include/pubnub_chat/string.hpp

@@ -5,6 +5,7 @@
 #include <cstddef>
 #include <ostream>
 #include <string>
+#include <cstring>
 
 namespace Pubnub {
     /**

src/application/chat_service.cpp

@@ -57,6 +57,8 @@ void ChatService::init_services(const ChatConfig& config) {
         presence_service,
         pubnub
     );
+
+    this->pubnub->lock()->set_logging_callback(Logger::log_ccore_message);
 }
 
 ThreadSafePtr<PubNub> ChatService::create_pubnub(const String& publish_key, const String& subscribe_key, const String& user_id, const String& auth_key) {
@@ -228,3 +230,8 @@ std::shared_ptr<Subscription> ChatService::listen_for_events(const Pubnub::Strin
 
     return subscription;
 }
+
+void ChatService::register_logger_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback) const
+{
+    logger.register_logging_callback(callback);
+}

src/application/chat_service.hpp

@@ -9,6 +9,7 @@
 #include "mentions.hpp"
 #include "string.hpp"
 #include "enums.hpp"
+#include "infra/logger.hpp"
 #include <functional>
 #include <memory>
 #include <vector>
@@ -45,6 +46,8 @@ class ChatService : public std::enable_shared_from_this<ChatService>
         std::tuple<std::vector<Pubnub::UserMentionData>, bool> get_current_user_mentions(const Pubnub::String& start_timetoken, const Pubnub::String& end_timetoken, int count) const;
         std::shared_ptr<Subscription> listen_for_events(const Pubnub::String& channel_id, Pubnub::pubnub_chat_event_type chat_event_type, std::function<void(const Pubnub::Event&)> event_callback) const;
 
+        void register_logger_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback) const;
+
         std::shared_ptr<const UserService> user_service;
         std::shared_ptr<const MessageService> message_service;
         std::shared_ptr<const MembershipService> membership_service;
@@ -53,6 +56,7 @@ class ChatService : public std::enable_shared_from_this<ChatService>
         std::shared_ptr<const AccessManagerService> access_manager_service;
         std::shared_ptr<const ChannelService> channel_service;
         Pubnub::ChatConfig chat_config;
+        mutable Logger logger;
 
         std::shared_ptr<CallbackService> callback_service;
 

src/application/user_service.cpp

@@ -31,28 +31,31 @@ User UserService::get_current_user() const
     return this->get_user(user_id);
 }
 
-User UserService::create_user(const String& user_id, const UserDAO& user_data) const
+User UserService::create_user(const String& user_id, const UserDAO& user_data, bool skip_get_user) const
 {
     if(user_id.empty())
     {
         throw std::invalid_argument("Failed to create user, user_id is empty");
     }
 
-    bool user_exists = true;
-
-    try
-    {
-        get_user(user_id);
-
-    }
-    catch(...)
+    if(!skip_get_user)
     {
-        user_exists = false;
-    }
+        bool user_exists = true;
 
-    if(user_exists)
-    {
-        throw std::invalid_argument("User with this ID already exists");
+        try
+        {
+            get_user(user_id);
+
+        }
+        catch(...)
+        {
+            user_exists = false;
+        }
+
+        if(user_exists)
+        {
+            throw std::invalid_argument("User with this ID already exists");
+        }
     }
 
     auto new_user_entity = user_data.to_entity();

src/application/user_service.hpp

@@ -26,7 +26,7 @@ class UserService : public std::enable_shared_from_this<UserService>
 
         Pubnub::User get_current_user() const;
 
-        Pubnub::User create_user(const Pubnub::String& user_id, const UserDAO& user_data) const;
+        Pubnub::User create_user(const Pubnub::String& user_id, const UserDAO& user_data, bool skip_get_user = false) const;
         Pubnub::User get_user(const Pubnub::String& user_id) const;
         std::tuple<std::vector<Pubnub::User>, Pubnub::Page, int> get_users(const Pubnub::String& filter = "", const Pubnub::String& sort = "", int limit = 0, const Pubnub::Page& page = Pubnub::Page()) const;
         Pubnub::User update_user(const Pubnub::String& user_id, const UserDAO& user_data) const;

src/chat_helpers.cpp

@@ -16,21 +16,21 @@ namespace Pubnub
 String create_set_memberships_object(String channel_id, String custom_params_json)
 {
     String custom_parameter_string;
-    custom_params_json.empty() ? custom_parameter_string="{}" : custom_parameter_string = custom_params_json;
-    return String("[{\"channel\": {\"id\": \"") + channel_id +  String("\"}, \"custom\": ") + custom_parameter_string + String("}]");
+    custom_params_json.empty() ? custom_parameter_string = "" : custom_parameter_string = String(", \"custom\": ") + custom_params_json;
+    return String("[{\"channel\": {\"id\": \"") + channel_id +  String("\"}") + custom_parameter_string + String("}]");
 }
 
 String create_set_members_object(String user_id, String custom_params_json)
 {
     String custom_parameter_string;
-    custom_params_json.empty() ? custom_parameter_string="{}" : custom_parameter_string = custom_params_json;
-    return String("[{\"uuid\": {\"id\": \"") + user_id + String("\"}, \"custom\": ") + custom_parameter_string + String("}]");
+    custom_params_json.empty() ? custom_parameter_string="" : custom_parameter_string = String(", \"custom\": ") + custom_params_json;
+    return String("[{\"uuid\": {\"id\": \"") + user_id + String("\"}") + custom_parameter_string + String("}]");
 }
 
 String create_set_members_object(std::vector<String> users_ids, String custom_params_json)
 {
     String custom_parameter_string;
-    custom_params_json.empty() ? custom_parameter_string="{}" : custom_parameter_string = custom_params_json;
+    custom_params_json.empty() ? custom_parameter_string = "" : custom_parameter_string = String(", \"custom\": ") + custom_params_json;
 
     //Start json array
     String final_object = "["; 
@@ -39,7 +39,7 @@ String create_set_members_object(std::vector<String> users_ids, String custom_pa
     for(auto &user_id : users_ids)
     {
         if(user_id.empty()) {continue;}
-        String user_object = String("{\"uuid\": {\"id\": \"") + user_id + String("\"}, \"custom\": ") + custom_parameter_string + String("},");
+        String user_object = String("{\"uuid\": {\"id\": \"") + user_id + String("\"}") + custom_parameter_string + String("},");
         final_object += user_object;
     }
 

src/infra/logger.cpp

@@ -0,0 +1,29 @@
+#include "logger.hpp"
+#include <iostream>
+
+std::function<void(Pubnub::pn_log_level, const char*)> Logger::cpp_log_callback = nullptr;
+
+void Logger::log_message(Pubnub::pn_log_level log_level, Pubnub::String message)
+{
+    if(cpp_log_callback)
+    {
+        cpp_log_callback(log_level, message);
+    }
+    else
+    {
+        std::cout << message << std::endl;
+    }
+}
+
+void Logger::register_logging_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback)
+{
+    cpp_log_callback = callback;
+}
+
+void Logger::log_ccore_message(enum pubnub_log_level log_level, const char* message)
+{
+    if(cpp_log_callback)
+    {
+        cpp_log_callback((Pubnub::pn_log_level)log_level, message);
+    }
+}

src/infra/logger.hpp

@@ -0,0 +1,31 @@
+#ifndef PN_CHAT_LOG_HPP
+#define PN_CHAT_LOG_HPP
+
+#include "enums.hpp"
+#include "string.hpp"
+#include <functional>
+#include <sstream>
+
+extern "C" {
+#include <pubnub_log.h>
+}
+
+
+class Logger
+{
+    public:
+
+    void log_message(Pubnub::pn_log_level log_level, Pubnub::String message);
+
+
+    void register_logging_callback(std::function<void(Pubnub::pn_log_level, const char*)> callback);
+
+    static void log_ccore_message(enum pubnub_log_level log_level, const char* message);
+
+    private:
+
+    static std::function<void(Pubnub::pn_log_level, const char*)> cpp_log_callback;
+
+};
+
+#endif // PN_CHAT_LOG_HPP

src/infra/pubnub.cpp

@@ -30,6 +30,7 @@ extern "C" {
 #include <pubnub_ntf_enforcement.h>
 #include <pubnub_entities.h>
 #include <pubnub_subscribe_event_listener.h>
+#include <pubnub_log.h>
 }
 
 using json = nlohmann::json;
@@ -840,4 +841,9 @@ int PubNub::set_pubnub_origin(const Pubnub::String origin)
     custom_origin = origin;
     return pubnub_origin_set(this->main_context.get(), custom_origin.c_str());
     return pubnub_origin_set(this->long_poll_context.get(), custom_origin.c_str());
+}
+
+void PubNub::set_logging_callback(void (*callback)(enum pubnub_log_level log_level, const char* message)) 
+{
+    pubnub_set_log_callback(callback);
 }

src/infra/pubnub.hpp

@@ -4,6 +4,7 @@
 #include "application/subscription.hpp"
 #include "string.hpp"
 #include "enums.hpp"
+#include "logger.hpp"
 #include <memory>
 #include <thread>
 #include <vector>
@@ -76,6 +77,8 @@ class PubNub {
     void set_auth_token(const Pubnub::String token);
     int set_pubnub_origin(const Pubnub::String origin);
 
+    void set_logging_callback(void (*callback)(enum pubnub_log_level log_level, const char* message));
+
 private:
     void await_and_handle_error(pubnub_res result);
     bool is_subscribed_to_channel(const Pubnub::String channel);

src/infra/rate_limiter.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <chrono>
 #include <memory>
+#include <cmath>
 
 #define THREADS_MAX_SPEEL_MS 1000
 #define NO_SLEEP_REQUIRED -1

src/infra/rate_limiter.hpp

@@ -12,6 +12,7 @@
 #include <map>
 #include <memory>
 #include <vector>
+#include <thread>
 
 struct RateLimiterElement {
     std::function<Pubnub::String()> task;

src/infra/timer.hpp

@@ -5,6 +5,7 @@
 #include <chrono>
 #include <future>
 #include <functional>
+#include <thread>
 
 class Timer
 {