code refactor

Author: paulocoutinhox

include/bitchat/core/bitchat_manager.h

@@ -67,25 +67,6 @@ class BitchatManager
     std::shared_ptr<CryptoService> getCryptoService() const;
     std::shared_ptr<NoiseService> getNoiseService() const;
 
-    // Set callbacks for UI updates
-    using MessageCallback = std::function<void(const BitchatMessage &)>;
-    using PeerJoinedCallback = std::function<void(const std::string &, const std::string &)>;
-    using PeerLeftCallback = std::function<void(const std::string &, const std::string &)>;
-    using PeerConnectedCallback = std::function<void(const std::string &)>;
-    using PeerDisconnectedCallback = std::function<void(const std::string &)>;
-    using StatusCallback = std::function<void(const std::string &)>;
-    using ChannelJoinedCallback = std::function<void(const std::string &)>;
-    using ChannelLeftCallback = std::function<void(const std::string &)>;
-
-    void setMessageCallback(MessageCallback callback);
-    void setPeerJoinedCallback(PeerJoinedCallback callback);
-    void setPeerLeftCallback(PeerLeftCallback callback);
-    void setPeerConnectedCallback(PeerConnectedCallback callback);
-    void setPeerDisconnectedCallback(PeerDisconnectedCallback callback);
-    void setStatusCallback(StatusCallback callback);
-    void setChannelJoinedCallback(ChannelJoinedCallback callback);
-    void setChannelLeftCallback(ChannelLeftCallback callback);
-
 private:
     // Static instance
     static std::shared_ptr<BitchatManager> instance;
@@ -103,27 +84,6 @@ class BitchatManager
     // Runners
     std::shared_ptr<BluetoothAnnounceRunner> announceRunner;
     std::shared_ptr<CleanupRunner> cleanupRunner;
-
-    // Callbacks
-    MessageCallback messageCallback;
-    PeerJoinedCallback peerJoinedCallback;
-    PeerLeftCallback peerLeftCallback;
-    PeerConnectedCallback peerConnectedCallback;
-    PeerDisconnectedCallback peerDisconnectedCallback;
-    StatusCallback statusCallback;
-    ChannelJoinedCallback channelJoinedCallback;
-    ChannelLeftCallback channelLeftCallback;
-
-    // Internal methods
-    void setupCallbacks();
-    void onMessageReceived(const BitchatMessage &message);
-    void onPeerJoined(const std::string &peerID, const std::string &nickname);
-    void onPeerLeft(const std::string &peerID, const std::string &nickname);
-    void onPeerConnected(const std::string &peripheralID);
-    void onPeerDisconnected(const std::string &peripheralID);
-    void onStatusUpdate(const std::string &status);
-    void onChannelJoined(const std::string &channel);
-    void onChannelLeft(const std::string &channel);
 };
 
 } // namespace bitchat

include/bitchat/services/message_service.h

@@ -2,6 +2,7 @@
 
 #include "bitchat/core/bitchat_data.h"
 #include "bitchat/protocol/packet.h"
+#include "bitchat/ui/ui_interface.h"
 #include <functional>
 #include <map>
 #include <memory>
@@ -43,24 +44,37 @@ class MessageService
     // Start identity announce
     void startIdentityAnnounce();
 
+    // Peer joined
+    void peerJoined(const std::string &peerID, const std::string &nickname);
+
+    // Peer left
+    void peerLeft(const std::string &peerID, const std::string &nickname);
+
+    // Peer connected
+    void peerConnected(const std::string &peripheralID);
+
+    // Peer disconnected
+    void peerDisconnected(const std::string &peripheralID);
+
+    // Centralized packet processing - main entry point for all packets
+    void processPacket(const BitchatPacket &packet, const std::string &peripheralID);
+
     // Set callbacks for message events
     using MessageReceivedCallback = std::function<void(const BitchatMessage &)>;
     using ChannelJoinedCallback = std::function<void(const std::string &)>;
     using ChannelLeftCallback = std::function<void(const std::string &)>;
     using PeerJoinedCallback = std::function<void(const std::string &, const std::string &)>;
     using PeerLeftCallback = std::function<void(const std::string &, const std::string &)>;
+    using PeerConnectedCallback = std::function<void(const std::string &)>;
+    using PeerDisconnectedCallback = std::function<void(const std::string &)>;
 
     void setMessageReceivedCallback(MessageReceivedCallback callback);
     void setChannelJoinedCallback(ChannelJoinedCallback callback);
     void setChannelLeftCallback(ChannelLeftCallback callback);
     void setPeerJoinedCallback(PeerJoinedCallback callback);
     void setPeerLeftCallback(PeerLeftCallback callback);
-
-    // Centralized packet processing - main entry point for all packets
-    void processPacket(const BitchatPacket &packet, const std::string &peripheralID);
-
-    // Check if service is ready
-    bool isReady() const;
+    void setPeerConnectedCallback(PeerConnectedCallback callback);
+    void setPeerDisconnectedCallback(PeerDisconnectedCallback callback);
 
 private:
     // Dependencies
@@ -74,6 +88,8 @@ class MessageService
     ChannelLeftCallback channelLeftCallback;
     PeerJoinedCallback peerJoinedCallback;
     PeerLeftCallback peerLeftCallback;
+    PeerConnectedCallback peerConnectedCallback;
+    PeerDisconnectedCallback peerDisconnectedCallback;
 
     // Message-related packet processing
     void processMessagePacket(const BitchatPacket &packet);

include/bitchat/services/network_service.h

@@ -54,9 +54,6 @@ class NetworkService
     void setPeerConnectedCallback(PeerConnectedCallback callback);
     void setPeerDisconnectedCallback(PeerDisconnectedCallback callback);
 
-    // Check if network is ready
-    bool isReady() const;
-
 private:
     // Bluetooth interface
     std::shared_ptr<IBluetoothNetwork> bluetoothNetworkInterface;

src/bitchat/core/bitchat_manager.cpp

@@ -80,10 +80,10 @@ bool BitchatManager::initialize(
         return false;
     }
 
-    // Generate or load key pair
-    if (!cryptoService->generateOrLoadKeyPair("bitchat-pk.pem"))
+    // Initialize UI with message service
+    if (!userInterface->initialize(messageService))
     {
-        spdlog::error("Failed to generate or load key pair");
+        spdlog::error("Failed to initialize UserInterface");
         return false;
     }
 
@@ -93,16 +93,6 @@ bool BitchatManager::initialize(
         return false;
     }
 
-    // Initialize UI with message service
-    if (!userInterface->initialize(messageService))
-    {
-        spdlog::error("Failed to initialize UserInterface");
-        return false;
-    }
-
-    // Set up callbacks
-    setupCallbacks();
-
     spdlog::info("BitchatManager initialized successfully");
 
     return true;
@@ -140,18 +130,26 @@ void BitchatManager::stop()
 
 bool BitchatManager::sendMessage(const std::string &content)
 {
+    if (!messageService)
+    {
+        return false;
+    }
+
     return messageService->sendMessage(content);
 }
 
 bool BitchatManager::sendPrivateMessage(const std::string &content, const std::string &recipientNickname)
 {
+    if (!messageService)
+    {
+        return false;
+    }
+
     return messageService->sendPrivateMessage(content, recipientNickname);
 }
 
 void BitchatManager::joinChannel(const std::string &channel)
 {
-    BitchatData::shared()->setCurrentChannel(channel);
-
     if (messageService)
     {
         messageService->joinChannel(channel);
@@ -160,8 +158,6 @@ void BitchatManager::joinChannel(const std::string &channel)
 
 void BitchatManager::leaveChannel()
 {
-    BitchatData::shared()->setCurrentChannel("");
-
     if (messageService)
     {
         messageService->leaveChannel();
@@ -173,177 +169,6 @@ void BitchatManager::changeNickname(const std::string &nickname)
     BitchatData::shared()->setNickname(nickname);
 }
 
-void BitchatManager::setMessageCallback(MessageCallback callback)
-{
-    messageCallback = callback;
-}
-
-void BitchatManager::setPeerJoinedCallback(PeerJoinedCallback callback)
-{
-    peerJoinedCallback = callback;
-}
-
-void BitchatManager::setPeerLeftCallback(PeerLeftCallback callback)
-{
-    peerLeftCallback = callback;
-}
-
-void BitchatManager::setPeerConnectedCallback(PeerConnectedCallback callback)
-{
-    peerConnectedCallback = callback;
-}
-
-void BitchatManager::setPeerDisconnectedCallback(PeerDisconnectedCallback callback)
-{
-    peerDisconnectedCallback = callback;
-}
-
-void BitchatManager::setStatusCallback(StatusCallback callback)
-{
-    statusCallback = callback;
-}
-
-void BitchatManager::setChannelJoinedCallback(ChannelJoinedCallback callback)
-{
-    channelJoinedCallback = callback;
-}
-
-void BitchatManager::setChannelLeftCallback(ChannelLeftCallback callback)
-{
-    channelLeftCallback = callback;
-}
-
-void BitchatManager::setupCallbacks()
-{
-    // Set up network manager callbacks
-
-    // clang-format off
-    networkService->setPeerConnectedCallback([this](const std::string &peripheralID) {
-        onPeerConnected(peripheralID);
-    });
-    // clang-format on
-
-    // clang-format off
-    networkService->setPeerDisconnectedCallback([this](const std::string &peripheralID) {
-        onPeerDisconnected(peripheralID);
-    });
-    // clang-format on
-
-    // Set up message manager callbacks
-
-    // clang-format off
-    messageService->setMessageReceivedCallback([this](const BitchatMessage &message) {
-        onMessageReceived(message);
-    });
-    // clang-format on
-
-    // clang-format off
-    messageService->setChannelJoinedCallback([this](const std::string &channel) {
-        onChannelJoined(channel);
-    });
-    // clang-format on
-
-    // clang-format off
-    messageService->setChannelLeftCallback([this](const std::string &channel) {
-        onChannelLeft(channel);
-    });
-    // clang-format on
-
-    // clang-format off
-    messageService->setPeerJoinedCallback([this](const std::string &peerID, const std::string &nickname) {
-        onPeerJoined(peerID, nickname);
-    });
-    // clang-format on
-
-    // clang-format off
-    messageService->setPeerLeftCallback([this](const std::string &peerID, const std::string &nickname) {
-        onPeerLeft(peerID, nickname);
-    });
-    // clang-format on
-}
-
-void BitchatManager::onMessageReceived(const BitchatMessage &message)
-{
-    if (messageCallback)
-    {
-        messageCallback(message);
-    }
-}
-
-void BitchatManager::onPeerJoined(const std::string &peerID, const std::string &nickname)
-{
-    if (peerJoinedCallback)
-    {
-        peerJoinedCallback(peerID, nickname);
-    }
-}
-
-void BitchatManager::onPeerLeft(const std::string &peerID, const std::string &nickname)
-{
-    if (peerLeftCallback)
-    {
-        peerLeftCallback(peerID, nickname);
-    }
-}
-
-void BitchatManager::onPeerConnected(const std::string &peripheralID)
-{
-    if (peerConnectedCallback)
-    {
-        peerConnectedCallback(peripheralID);
-    }
-}
-
-void BitchatManager::onPeerDisconnected(const std::string &peripheralID)
-{
-    // Remove peer from data store
-    auto peers = BitchatData::shared()->getPeers();
-
-    for (const auto &peer : peers)
-    {
-        if (peer.getPeripheralID() == peripheralID)
-        {
-            std::string peerID = peer.getPeerID();
-            std::string nickname = peer.getNickname();
-            BitchatData::shared()->removePeer(peerID);
-
-            onPeerLeft(peerID, nickname);
-
-            break;
-        }
-    }
-
-    // Notify callback
-    if (peerDisconnectedCallback)
-    {
-        peerDisconnectedCallback(peripheralID);
-    }
-}
-
-void BitchatManager::onStatusUpdate(const std::string &status)
-{
-    if (statusCallback)
-    {
-        statusCallback(status);
-    }
-}
-
-void BitchatManager::onChannelJoined(const std::string &channel)
-{
-    if (channelJoinedCallback)
-    {
-        channelJoinedCallback(channel);
-    }
-}
-
-void BitchatManager::onChannelLeft(const std::string &channel)
-{
-    if (channelLeftCallback)
-    {
-        channelLeftCallback(channel);
-    }
-}
-
 std::shared_ptr<IUserInterface> BitchatManager::getUserInterface() const
 {
     return userInterface;

src/bitchat/services/crypto_service.cpp

@@ -23,6 +23,14 @@ CryptoService::~CryptoService()
 
 bool CryptoService::initialize()
 {
+    // Generate or load key pair
+    if (!generateOrLoadKeyPair("bitchat-pk.pem"))
+    {
+        spdlog::error("Failed to generate or load key pair");
+        return false;
+    }
+
+    // Initialize OpenSSL
     OpenSSL_add_all_algorithms();
     ERR_load_crypto_strings();