Add managed gsm client

Author: sebromero

src/ArduinoCellular.cpp

@@ -1,6 +1,8 @@
 
 
 #include "ArduinoCellular.h"
+#include "ManagedTinyGsmClient.h"
+
 #if defined(ARDUINO_ARCH_MBED)
   #include "Watchdog.h"
 #endif
@@ -166,7 +168,7 @@ int ArduinoCellular::getSignalQuality(){
 }
 
 TinyGsmClient ArduinoCellular::getNetworkClient(){
-    return TinyGsmClient(modem, 0);
+    return ManagedTinyGsmClient(modem);
 }
 
 HttpClient ArduinoCellular::getHTTPClient(const char * server, const int port){

src/ArduinoCellular.h

@@ -218,8 +218,12 @@ class ArduinoCellular {
 
 
         /**
-         * @brief Gets the Network client. (OSI Layer 3)
-         * @return The GSM client.
+         * @brief Gets a new Network client. (OSI Layer 3)
+         * The library automatically manages the sockets, so you can create multiple clients 
+         * without worrying about socket management. You should ensure that you release the client when you are done with it.
+         * It's possible that the client is invalid if no sockets are available.
+         * This is indicated by the isValid() method and the socketId will be -1.
+         * @return A GSM client object that can be used to connect to a server.
          */
         TinyGsmClient getNetworkClient();
 

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