[edit] Hypothetical gRPC handshake

.gitignore

@@ -29,6 +29,10 @@
 # Executables
 *.o
 
+# Protobuffer builds
+*.pb.cc
+*.pb.h
+
 # Directories
 build/
 .vscode/

src/main.cpp

@@ -21,16 +21,15 @@
 //
 //
 
-
-#include "rtcPeerHandler.hpp" //HAndle peer connection requests
+#include "rtcPeerHandler.hpp" //Handle peer connection requests
 #include "rpcStub.hpp"		  //Handle gRPC communications between the different fosscord elements
 
-int main (int argc, char** argv){
+int main(int argc, char **argv){
 
 	auto commsHandler = std::make_shared<rtcPeerHandler>();
-    auto rpcHandler = std::unique_ptr<rpcStub>();
+	auto rpcHandler = std::unique_ptr<rpcStub>(new rpcStub(commsHandler, 8057));
 
-	std::cout << "Server created" <<std::endl;
+	std::cout << "Server created" << std::endl;
 
 	//rpcHandler->server->Wait(); //blocking, this will need to be threaded
 	return 0;

src/protodefs/protos.proto

@@ -3,13 +3,13 @@ syntax = "proto3";
 package fosscordMedia;
 
 service fosscordInternals{
-	rpc requestProtocol(voiceRequest) returns (voiceAnswer) {}
+	rpc vRequest(voiceRequest) returns (voiceAnswer) {}
 }
 
 message voiceRequest{ //OP1 from gw
 	uint64 userid = 1;
 	uint64 guildid = 2;
-	string IP=3;
+	string ip=3;
 	uint32 port=4;
 	string protocol=5;
 	string rtcConnectionId=6;

src/rpcStub.cpp

@@ -1,24 +1,32 @@
 #include "rpcStub.hpp"
 
-class fossCordInternalsImpl final : public fosscordMedia::fosscordInternals::Service{
-	grpc::Status sendRequest(
-		grpc::ServerContext* ctx,
-		const fosscordMedia::rpcRequest* req,
-		fosscordMedia::rpcResponse* resp
-	) override{
-		resp->set_b(333);
+class fossCordInternalsImpl final : public fosscordMedia::fosscordInternals::Service {
+	std::shared_ptr<rtcPeerHandler> ph;
+	fossCordInternalsImpl(std::shared_ptr<rtcPeerHandler> handler){
+		this->ph= handler;
+	}
+    grpc::Status vRequest(grpc::ServerContext* ctx,
+                             const fosscordMedia::voiceRequest* req,
+                             fosscordMedia::voiceAnswer* resp) override {
+
+        this->ph->initiateConnection(req->ip(), req->port());
         return grpc::Status::OK;
     }
-
 };
 
-rpcStub::rpcStub(int port){
-	grpc::ServerBuilder builder;
+rpcStub::rpcStub(std::shared_ptr<rtcPeerHandler> handler, int port) {
+    if (not port) {
+        port = 8057;
+    }
+    this->ph = handler;
 
     fossCordInternalsImpl* service;
-	builder.AddListeningPort("0.0.0.0:8057", grpc::InsecureServerCredentials() );
+    grpc::ServerBuilder builder;
+    builder.AddListeningPort("0.0.0.0:" + std::to_string(port),
+                             grpc::InsecureServerCredentials());
     builder.RegisterService(service);
 
-	std::unique_ptr<grpc::Server> server(builder.BuildAndStart());
-	std::cout << "Server listening on port 8057 " << std::endl;
+    this->server = builder.BuildAndStart();
+
+    std::cout << "RPC stub listening on port " << port << std::endl;
 }

src/rpcStub.hpp

@@ -1,11 +1,12 @@
 #include <grpc++/grpc++.h>
 #include "protodefs/include/protos.grpc.pb.h"
+#include "rtcPeerHandler.hpp"
 
 class rpcStub{
 	public:
-		rpcStub(int port);
+		rpcStub(std::shared_ptr<rtcPeerHandler> peerHandler, int port);
 		std::unique_ptr<grpc::Server> server;
+		
 	private:
-		
-
+		std::shared_ptr<rtcPeerHandler> ph;
 };

src/rtcPeerHandler.cpp

@@ -1,12 +1,11 @@
 #include "rtcPeerHandler.hpp"
-rtcPeerHandler::rtcPeerHandler()
-{
+
+rtcPeerHandler::rtcPeerHandler() {
     rtc::InitLogger(rtc::LogLevel::Verbose, NULL);
 }
 
-void rtcPeerHandler::initiateConnection(std::string peerIP, int peerPort)
-{
-	//Socket connection between client and server
+void rtcPeerHandler::initiateConnection(std::string peerIP, int peerPort) {
+    // Socket connection between client and server
     SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
     sockaddr_in addr;
     addr.sin_addr.s_addr = inet_addr(peerIP.c_str());
@@ -19,16 +18,16 @@ void rtcPeerHandler::initiateConnection(std::string peerIP, int peerPort)
 
     auto pc = std::make_shared<rtc::PeerConnection>(conf);
 
-	rtc::Description::Audio media("audio", rtc::Description::Direction::SendRecv);
+    rtc::Description::Audio media("audio",
+                                  rtc::Description::Direction::SendRecv);
     media.addOpusCodec(96);
     media.setBitrate(64);
 
-
     auto track = pc->addTrack(media);
 
-	//auto session = std::make_shared<rtc::MediaHandler>();
+    // auto session = std::make_shared<rtc::MediaHandler>();
 
-	//track->setMediaHandler(session);
+    // track->setMediaHandler(session);
 
     rtc::Reliability rtcRel;
     rtcRel.unordered = true;
@@ -48,10 +47,37 @@ void rtcPeerHandler::initiateConnection(std::string peerIP, int peerPort)
         }
     });
 
-	pc->onGatheringStateChange(
-		[](rtc::PeerConnection::GatheringState state) { std::cout << "Gathering State: " << state << std::endl; });
+    pc->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
+        std::cout << "Gathering State: " << state << std::endl;
+    });
 
+    /*std::tuple<rtc::Track*, rtc::RtcpSrReporter*> addAudio(
+		
+        const std::shared_ptr<rtc::PeerConnection> pc,
+        const uint8_t payloadType, const uint32_t ssrc, const std::string cname,
+        const std::string msid, const std::function<void(void)> onOpen) {
+        auto audio = Description::Audio(cname);
+        audio.addOpusCodec(payloadType);
+        audio.addSSRC(ssrc, cname, msid, cname);
+        auto track = pc->addTrack(audio);
+        // create RTP configuration
+        auto rtpConfig = make_shared<RtpPacketizationConfig>(
+            ssrc, cname, payloadType, OpusRtpPacketizer::defaultClockRate);
+        // create packetizer
+        auto packetizer = make_shared<OpusRtpPacketizer>(rtpConfig);
+        // create opus handler
+        auto opusHandler = make_shared<OpusPacketizationHandler>(packetizer);
+
+        // add RTCP SR handler
+        auto srReporter = make_shared<RtcpSrReporter>(rtpConfig);
+        opusHandler->addToChain(srReporter);
+
+        // set handler
+        track->setMediaHandler(opusHandler);
+        track->onOpen(onOpen);
+        auto trackData = make_shared<ClientTrackData>(track, srReporter);
+        return trackData;
+    }*/
 
     pc->createDataChannel("Fosscord voice connection", rtcConf);
 }
-   

src/rtcPeerHandler.hpp

@@ -13,6 +13,8 @@ typedef int SOCKET;
 
 using json = nlohmann::json;
 
+#ifndef RTCPEERHANDLER
+#define RTCPEERHANDLER
 class rtcPeerHandler{
 public:
 	rtcPeerHandler();
@@ -27,3 +29,4 @@ public:
 private:
 	std::map<SOCKET, client> clients;
 };
+#endif