Add managed gsm client

Author: sebromero

src/ArduinoCellular.cpp

@@ -1,6 +1,7 @@
 
 
 #include "ArduinoCellular.h"
+
 #if defined(ARDUINO_ARCH_MBED)
   #include "Watchdog.h"
 #endif
@@ -165,12 +166,19 @@ int ArduinoCellular::getSignalQuality(){
     return modem.getSignalQuality();
 }
 
-TinyGsmClient ArduinoCellular::getNetworkClient(){
-    return TinyGsmClient(modem, 0);
+ManagedTinyGsmClient ArduinoCellular::getNetworkClient(){
+    return ManagedTinyGsmClient(modem);
 }
 
 HttpClient ArduinoCellular::getHTTPClient(const char * server, const int port){
-    TinyGsmClient client = getNetworkClient();
+    ManagedTinyGsmClient client = getNetworkClient();
+    if (!client.isValid()) {
+        // Handle error: no available sockets
+        // Option 1: Return an invalid HttpClient (if supported)
+        // Option 2: Use a default/shared client (not recommended)
+        // Option 3: Wait and retry (could add a delay/retry mechanism)
+        // For now, we'll proceed but the connection will likely fail
+    }
     return HttpClient(client, server, port);
 }
 
@@ -181,7 +189,7 @@ HttpClient ArduinoCellular::getHTTPSClient(const char * server, const int port){
 }
 
 BearSSLClient ArduinoCellular::getSecureNetworkClient(){
-    TinyGsmClient client = getNetworkClient();
+    ManagedTinyGsmClient client = getNetworkClient();
     return BearSSLClient(client);
 }
 #endif

src/ArduinoCellular.h

@@ -16,6 +16,7 @@
 
 #include <Arduino.h>
 #include <vector>
+#include "ManagedTinyGsmClient.h"
 
 #if defined __has_include
   #if !__has_include (<ArduinoIoTCloud.h>)
@@ -221,7 +222,7 @@ class ArduinoCellular {
          * @brief Gets the Network client. (OSI Layer 3)
          * @return The GSM client.
          */
-        TinyGsmClient getNetworkClient();
+        ManagedTinyGsmClient getNetworkClient();
 
         /**
          * @brief Gets the Transport Layer Security (TLS) client. (OSI Layer 4)

src/ManagedTinyGsmClient.cpp

@@ -0,0 +1,82 @@
+#include "ManagedTinyGsmClient.h"
+
+// Static member definitions
+uint32_t ManagedTinyGsmClient::usedSockets = 0;
+bool ManagedTinyGsmClient::socketMutex = false;
+
+void ManagedTinyGsmClient::lockSockets() {
+    // Simple spinlock - not ideal but works for basic protection
+    while (socketMutex) {
+        delay(1); // Small delay to prevent busy waiting
+    }
+    socketMutex = true;
+}
+
+void ManagedTinyGsmClient::unlockSockets() {
+    socketMutex = false;
+}
+
+int ManagedTinyGsmClient::allocateSocket() {
+    lockSockets();
+    
+    for (int i = 0; i < TINY_GSM_MUX_COUNT; i++) {
+        uint32_t mask = 1UL << i;
+        if (!(usedSockets & mask)) {
+            usedSockets |= mask;  // Set bit i
+            unlockSockets();
+            return i;
+        }
+    }
+    
+    unlockSockets();
+    return -1; // No available sockets
+}
+
+void ManagedTinyGsmClient::releaseSocket(int socketId) {
+    if (socketId >= 0 && socketId < TINY_GSM_MUX_COUNT) {
+        lockSockets();
+        uint32_t mask = 1UL << socketId;
+        usedSockets &= ~mask;  // Clear bit socketId
+        unlockSockets();
+    }
+}
+
+ManagedTinyGsmClient::ManagedTinyGsmClient(TinyGsm& modem) 
+    : socketId(allocateSocket()), TinyGsmClient(modem, socketId) {
+    // Note: If socketId is -1, the client is invalid
+}
+
+ManagedTinyGsmClient::ManagedTinyGsmClient(const ManagedTinyGsmClient& other)
+    : socketId(allocateSocket()), TinyGsmClient(other) {
+    // Copy constructor allocates a new socket
+    // Note: If socketId is -1, the client is invalid
+}
+
+ManagedTinyGsmClient& ManagedTinyGsmClient::operator=(const ManagedTinyGsmClient& other) {
+    if (this != &other) {
+        TinyGsmClient::operator=(other);
+        // Keep our own socket - don't change it
+    }
+    return *this;
+}
+
+ManagedTinyGsmClient::ManagedTinyGsmClient(ManagedTinyGsmClient&& other)
+    : socketId(other.socketId), TinyGsmClient(other) {
+    other.socketId = -1; // Mark other as moved-from
+}
+
+ManagedTinyGsmClient& ManagedTinyGsmClient::operator=(ManagedTinyGsmClient&& other) {
+    if (this != &other) {
+        // Release our current socket
+        releaseSocket(socketId);
+        
+        TinyGsmClient::operator=(other);
+        socketId = other.socketId;
+        other.socketId = -1; // Mark other as moved-from
+    }
+    return *this;
+}
+
+ManagedTinyGsmClient::~ManagedTinyGsmClient() {
+    releaseSocket(socketId);
+}

src/ManagedTinyGsmClient.h

@@ -0,0 +1,29 @@
+#ifndef MANAGED_TINY_GSM_CLIENT_H
+#define MANAGED_TINY_GSM_CLIENT_H
+
+#include "ModemInterface.h"
+
+class ManagedTinyGsmClient : public TinyGsmClient {
+private:
+    int socketId;
+    static uint32_t usedSockets;        // Bit field to track sockets 0-(TINY_GSM_MUX_COUNT-1)
+    static bool socketMutex;            // Simple mutex flag
+    
+    static int allocateSocket();
+    static void releaseSocket(int socketId);
+    static void lockSockets();
+    static void unlockSockets();
+
+public:
+    ManagedTinyGsmClient(TinyGsm& modem);
+    ManagedTinyGsmClient(const ManagedTinyGsmClient& other);
+    ManagedTinyGsmClient& operator=(const ManagedTinyGsmClient& other);
+    ManagedTinyGsmClient(ManagedTinyGsmClient&& other);
+    ManagedTinyGsmClient& operator=(ManagedTinyGsmClient&& other);
+    ~ManagedTinyGsmClient();
+    
+    int getSocketId() const { return socketId; }
+    bool isValid() const { return socketId >= 0; }
+};
+
+#endif // MANAGED_TINY_GSM_CLIENT_H