RTSPPlatform.h

#pragma once
 
#include <Arduino.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
namespace audio_tools {
 
template <typename TcpServer, typename TcpClient, typename UdpSocket>
class RTSPPlatform {
 public:
  // Type aliases for template parameters
  using TcpServerType = TcpServer;
  using TcpClientType = TcpClient;
  using UdpSocketType = UdpSocket;
  static TcpServerType* createServer(uint16_t port){
    TcpServerType *srv = new TcpServerType(port);
    srv->begin();
    return srv;
  }
 
  static TcpClientType getAvailableClient(TcpServerType *srv){
    return srv->accept();
  }
  
  static constexpr TcpClient* NULL_TCP_SOCKET = nullptr;
  static constexpr UdpSocket* NULL_UDP_SOCKET = nullptr;
 
  static void closeSocket(TcpClient* s) {
    if (s) {
      s->stop();
      // delete s; // TCP clients are typically not heap-allocated in Arduino
    }
  }
 
  static void getSocketPeerAddr(TcpClient* s, IPAddress *addr,
                             uint16_t *port) {
    // For WiFiClient and compatible types, assume remoteIP/remotePort are
    // available
    if (s) {
      *addr = s->remoteIP();
      *port = s->remotePort();
    } else {
      *addr = IPAddress();
      *port = 0;
    }
  }
 
  static void closeUdpSocket(UdpSocket* s) {
    if (s) {
      s->stop();
      delete s;
    }
  }
 
  static UdpSocket* createUdpSocket(unsigned short portNum) {
    UdpSocket* s = new UdpSocket();
 
    if (!s->begin(portNum)) {
      printf("Can't bind port %d\n", portNum);
      delete s;
      return nullptr;
    }
 
    return s;
  }
 
  static ssize_t sendSocket(TcpClient* sockfd, const void *buf, size_t len) {
    return sockfd->write((uint8_t *)buf, len);
  }
 
  static ssize_t sendUdpSocket(UdpSocket* sockfd, const void *buf, size_t len,
                               IPAddress destaddr, uint16_t destport) {
    sockfd->beginPacket(destaddr, destport);
    sockfd->write((const uint8_t *)buf, len);
    if (!sockfd->endPacket()) printf("error sending udp packet\n");
 
    return len;
  }
 
  static int readSocket(TcpClient* sock, char *buf, size_t buflen,
                        int timeoutmsec) {
    if (!sock->connected()) {
      printf("client has closed the socket\n");
      return 0;
    }
 
    int numAvail = sock->available();
    if (numAvail == 0 && timeoutmsec != 0) {
      // sleep and hope for more
      delay(timeoutmsec);
      numAvail = sock->available();
    }
 
    if (numAvail == 0) {
      // printf("timeout on read\n");
      return -1;
    } else {
      // int numRead = sock->readBytesUntil('\n', buf, buflen);
      int numRead = sock->readBytes(buf, buflen);
      // printf("bytes avail %d, read %d: %s", numAvail, numRead, buf);
      return numRead;
    }
  }
};
 
 
}  // namespace audio_tools