Merge pull request #208 from hanseuljun/capi-callback-add-id

Add id as a parameter to C API callbacks.

examples/copy-paste-capi/answerer.c

@@ -41,13 +41,13 @@ typedef struct {
         bool connected;
 } Peer;
 
-static void dataChannelCallback(int dc, void *ptr);
-static void descriptionCallback(const char *sdp, const char *type, void *ptr);
-static void candidateCallback(const char *cand, const char *mid, void *ptr);
-static void stateChangeCallback(rtcState state, void *ptr);
-static void gatheringStateCallback(rtcGatheringState state, void *ptr);
-static void closedCallback(void *ptr);
-static void messageCallback(const char *message, int size, void *ptr);
+static void dataChannelCallback(int pc, int dc, void *ptr);
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr);
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr);
+static void stateChangeCallback(int pc, rtcState state, void *ptr);
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr);
+static void closedCallback(int id, void *ptr);
+static void messageCallback(int id, const char *message, int size, void *ptr);
 static void deletePeer(Peer *peer);
 
 char* state_print(rtcState state);
@@ -194,35 +194,35 @@ int main(int argc, char **argv) {
         return 0;
 }
 
-static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr) {
         // Peer *peer = (Peer *)ptr;
         printf("Description %s:\n%s\n", "answerer", sdp);
 }
 
-static void candidateCallback(const char *cand, const char *mid, void *ptr) {
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr) {
         // Peer *peer = (Peer *)ptr;
         printf("Candidate %s: %s\n", "answerer", cand);
 
 }
 
-static void stateChangeCallback(rtcState state, void *ptr) {
+static void stateChangeCallback(int pc, rtcState state, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->state = state;
         printf("State %s: %s\n", "answerer", state_print(state));
 }
 
-static void gatheringStateCallback(rtcGatheringState state, void *ptr) {
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->gatheringState = state;
         printf("Gathering state %s: %s\n", "answerer", rtcGatheringState_print(state));
 }
 
-static void closedCallback(void *ptr) {
+static void closedCallback(int id, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->connected = false;
 }
 
-static void messageCallback(const char *message, int size, void *ptr) {
+static void messageCallback(int id, const char *message, int size, void *ptr) {
         if (size < 0) { // negative size indicates a null-terminated string
                 printf("Message %s: %s\n", "answerer", message);
         } else {
@@ -240,7 +240,7 @@ static void deletePeer(Peer *peer) {
         }
 }
 
-static void dataChannelCallback(int dc, void *ptr) {
+static void dataChannelCallback(int pc, int dc, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->dc = dc;
         peer->connected = true;

examples/copy-paste-capi/offerer.c

@@ -41,13 +41,13 @@ typedef struct {
         bool connected;
 } Peer;
 
-static void descriptionCallback(const char *sdp, const char *type, void *ptr);
-static void candidateCallback(const char *cand, const char *mid, void *ptr);
-static void stateChangeCallback(rtcState state, void *ptr);
-static void gatheringStateCallback(rtcGatheringState state, void *ptr);
-static void openCallback(void *ptr);
-static void closedCallback(void *ptr);
-static void messageCallback(const char *message, int size, void *ptr);
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr);
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr);
+static void stateChangeCallback(int pc, rtcState state, void *ptr);
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr);
+static void openCallback(int id, void *ptr);
+static void closedCallback(int id, void *ptr);
+static void messageCallback(int id, const char *message, int size, void *ptr);
 static void deletePeer(Peer *peer);
 
 char *state_print(rtcState state);
@@ -199,30 +199,30 @@ int main(int argc, char **argv){
         return 0;
 }
 
-static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr) {
         // Peer *peer = (Peer *)ptr;
         printf("Description %s:\n%s\n", "offerer", sdp);
 }
 
-static void candidateCallback(const char *cand, const char *mid, void *ptr) {
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr) {
         // Peer *peer = (Peer *)ptr;
         printf("Candidate %s: %s\n", "offerer", cand);
 
 }
 
-static void stateChangeCallback(rtcState state, void *ptr) {
+static void stateChangeCallback(int pc, rtcState state, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->state = state;
         printf("State %s: %s\n", "offerer", state_print(state));
 }
 
-static void gatheringStateCallback(rtcGatheringState state, void *ptr) {
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->gatheringState = state;
         printf("Gathering state %s: %s\n", "offerer", rtcGatheringState_print(state));
 }
 
-static void openCallback(void *ptr) {
+static void openCallback(int id, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->connected = true;
         char buffer[256];
@@ -230,12 +230,12 @@ static void openCallback(void *ptr) {
                 printf("DataChannel %s: Received with label \"%s\"\n","offerer", buffer);
 }
 
-static void closedCallback(void *ptr) {
+static void closedCallback(int id, void *ptr) {
         Peer *peer = (Peer *)ptr;
         peer->connected = false;
 }
 
-static void messageCallback(const char *message, int size, void *ptr) {
+static void messageCallback(int id, const char *message, int size, void *ptr) {
         // Peer *peer = (Peer *)ptr;
         if (size < 0) { // negative size indicates a null-terminated string
                 printf("Message %s: %s\n", "offerer", message);

include/rtc/rtc.h

@@ -88,18 +88,18 @@ typedef struct {
 } rtcReliability;
 
 typedef void (RTC_API *rtcLogCallbackFunc)(rtcLogLevel level, const char *message);
-typedef void (RTC_API *rtcDescriptionCallbackFunc)(const char *sdp, const char *type, void *ptr);
-typedef void (RTC_API *rtcCandidateCallbackFunc)(const char *cand, const char *mid, void *ptr);
-typedef void (RTC_API *rtcStateChangeCallbackFunc)(rtcState state, void *ptr);
-typedef void (RTC_API *rtcGatheringStateCallbackFunc)(rtcGatheringState state, void *ptr);
-typedef void (RTC_API *rtcDataChannelCallbackFunc)(int dc, void *ptr);
-typedef void (RTC_API *rtcTrackCallbackFunc)(int tr, void *ptr);
-typedef void (RTC_API *rtcOpenCallbackFunc)(void *ptr);
-typedef void (RTC_API *rtcClosedCallbackFunc)(void *ptr);
-typedef void (RTC_API *rtcErrorCallbackFunc)(const char *error, void *ptr);
-typedef void (RTC_API *rtcMessageCallbackFunc)(const char *message, int size, void *ptr);
-typedef void (RTC_API *rtcBufferedAmountLowCallbackFunc)(void *ptr);
-typedef void (RTC_API *rtcAvailableCallbackFunc)(void *ptr);
+typedef void (RTC_API *rtcDescriptionCallbackFunc)(int pc, const char *sdp, const char *type, void *ptr);
+typedef void (RTC_API *rtcCandidateCallbackFunc)(int pc, const char *cand, const char *mid, void *ptr);
+typedef void (RTC_API *rtcStateChangeCallbackFunc)(int pc, rtcState state, void *ptr);
+typedef void (RTC_API *rtcGatheringStateCallbackFunc)(int pc, rtcGatheringState state, void *ptr);
+typedef void (RTC_API *rtcDataChannelCallbackFunc)(int pc, int dc, void *ptr);
+typedef void (RTC_API *rtcTrackCallbackFunc)(int pc, int tr, void *ptr);
+typedef void (RTC_API *rtcOpenCallbackFunc)(int id, void *ptr);
+typedef void (RTC_API *rtcClosedCallbackFunc)(int id, void *ptr);
+typedef void (RTC_API *rtcErrorCallbackFunc)(int id, const char *error, void *ptr);
+typedef void (RTC_API *rtcMessageCallbackFunc)(int id, const char *message, int size, void *ptr);
+typedef void (RTC_API *rtcBufferedAmountLowCallbackFunc)(int id, void *ptr);
+typedef void (RTC_API *rtcAvailableCallbackFunc)(int id, void *ptr);
 
 // Log
 // NULL cb on the first call will log to stdout

src/capi.cpp

@@ -422,7 +422,7 @@ int rtcSetLocalDescriptionCallback(int pc, rtcDescriptionCallbackFunc cb) {
 		if (cb)
 			peerConnection->onLocalDescription([pc, cb](Description desc) {
 				if (auto ptr = getUserPointer(pc))
-					cb(string(desc).c_str(), desc.typeString().c_str(), *ptr);
+					cb(pc, string(desc).c_str(), desc.typeString().c_str(), *ptr);
 			});
 		else
 			peerConnection->onLocalDescription(nullptr);
@@ -435,7 +435,7 @@ int rtcSetLocalCandidateCallback(int pc, rtcCandidateCallbackFunc cb) {
 		if (cb)
 			peerConnection->onLocalCandidate([pc, cb](Candidate cand) {
 				if (auto ptr = getUserPointer(pc))
-					cb(cand.candidate().c_str(), cand.mid().c_str(), *ptr);
+					cb(pc, cand.candidate().c_str(), cand.mid().c_str(), *ptr);
 			});
 		else
 			peerConnection->onLocalCandidate(nullptr);
@@ -448,7 +448,7 @@ int rtcSetStateChangeCallback(int pc, rtcStateChangeCallbackFunc cb) {
 		if (cb)
 			peerConnection->onStateChange([pc, cb](PeerConnection::State state) {
 				if (auto ptr = getUserPointer(pc))
-					cb(static_cast<rtcState>(state), *ptr);
+					cb(pc, static_cast<rtcState>(state), *ptr);
 			});
 		else
 			peerConnection->onStateChange(nullptr);
@@ -461,7 +461,7 @@ int rtcSetGatheringStateChangeCallback(int pc, rtcGatheringStateCallbackFunc cb)
 		if (cb)
 			peerConnection->onGatheringStateChange([pc, cb](PeerConnection::GatheringState state) {
 				if (auto ptr = getUserPointer(pc))
-					cb(static_cast<rtcGatheringState>(state), *ptr);
+					cb(pc, static_cast<rtcGatheringState>(state), *ptr);
 			});
 		else
 			peerConnection->onGatheringStateChange(nullptr);
@@ -476,7 +476,7 @@ int rtcSetDataChannelCallback(int pc, rtcDataChannelCallbackFunc cb) {
 				int dc = emplaceDataChannel(dataChannel);
 				if (auto ptr = getUserPointer(pc)) {
 					rtcSetUserPointer(dc, *ptr);
-					cb(dc, *ptr);
+					cb(pc, dc, *ptr);
 				}
 			});
 		else
@@ -492,7 +492,7 @@ int rtcSetTrackCallback(int pc, rtcTrackCallbackFunc cb) {
 				int tr = emplaceTrack(track);
 				if (auto ptr = getUserPointer(pc)) {
 					rtcSetUserPointer(tr, *ptr);
-					cb(tr, *ptr);
+					cb(pc, tr, *ptr);
 				}
 			});
 		else
@@ -686,7 +686,7 @@ int rtcSetOpenCallback(int id, rtcOpenCallbackFunc cb) {
 		if (cb)
 			channel->onOpen([id, cb]() {
 				if (auto ptr = getUserPointer(id))
-					cb(*ptr);
+					cb(id, *ptr);
 			});
 		else
 			channel->onOpen(nullptr);
@@ -699,7 +699,7 @@ int rtcSetClosedCallback(int id, rtcClosedCallbackFunc cb) {
 		if (cb)
 			channel->onClosed([id, cb]() {
 				if (auto ptr = getUserPointer(id))
-					cb(*ptr);
+					cb(id, *ptr);
 			});
 		else
 			channel->onClosed(nullptr);
@@ -712,7 +712,7 @@ int rtcSetErrorCallback(int id, rtcErrorCallbackFunc cb) {
 		if (cb)
 			channel->onError([id, cb](string error) {
 				if (auto ptr = getUserPointer(id))
-					cb(error.c_str(), *ptr);
+					cb(id, error.c_str(), *ptr);
 			});
 		else
 			channel->onError(nullptr);
@@ -726,11 +726,11 @@ int rtcSetMessageCallback(int id, rtcMessageCallbackFunc cb) {
 			channel->onMessage(
 			    [id, cb](binary b) {
 				    if (auto ptr = getUserPointer(id))
-					    cb(reinterpret_cast<const char *>(b.data()), int(b.size()), *ptr);
+					    cb(id, reinterpret_cast<const char *>(b.data()), int(b.size()), *ptr);
 			    },
 			    [id, cb](string s) {
 				    if (auto ptr = getUserPointer(id))
-					    cb(s.c_str(), -int(s.size() + 1), *ptr);
+					    cb(id, s.c_str(), -int(s.size() + 1), *ptr);
 			    });
 		else
 			channel->onMessage(nullptr);
@@ -777,7 +777,7 @@ int rtcSetBufferedAmountLowCallback(int id, rtcBufferedAmountLowCallbackFunc cb)
 		if (cb)
 			channel->onBufferedAmountLow([id, cb]() {
 				if (auto ptr = getUserPointer(id))
-					cb(*ptr);
+					cb(id, *ptr);
 			});
 		else
 			channel->onBufferedAmountLow(nullptr);
@@ -794,7 +794,7 @@ int rtcSetAvailableCallback(int id, rtcAvailableCallbackFunc cb) {
 		if (cb)
 			channel->onOpen([id, cb]() {
 				if (auto ptr = getUserPointer(id))
-					cb(*ptr);
+					cb(id, *ptr);
 			});
 		else
 			channel->onOpen(nullptr);

test/capi_connectivity.cpp

@@ -42,33 +42,33 @@ typedef struct {
 static Peer *peer1 = NULL;
 static Peer *peer2 = NULL;
 
-static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	printf("Description %d:\n%s\n", peer == peer1 ? 1 : 2, sdp);
 	Peer *other = peer == peer1 ? peer2 : peer1;
 	rtcSetRemoteDescription(other->pc, sdp, type);
 }
 
-static void candidateCallback(const char *cand, const char *mid, void *ptr) {
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	printf("Candidate %d: %s\n", peer == peer1 ? 1 : 2, cand);
 	Peer *other = peer == peer1 ? peer2 : peer1;
 	rtcAddRemoteCandidate(other->pc, cand, mid);
 }
 
-static void stateChangeCallback(rtcState state, void *ptr) {
+static void stateChangeCallback(int pc, rtcState state, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->state = state;
 	printf("State %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
 }
 
-static void gatheringStateCallback(rtcGatheringState state, void *ptr) {
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->gatheringState = state;
 	printf("Gathering state %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
 }
 
-static void openCallback(void *ptr) {
+static void openCallback(int id, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->connected = true;
 	printf("DataChannel %d: Open\n", peer == peer1 ? 1 : 2);
@@ -77,12 +77,12 @@ static void openCallback(void *ptr) {
 	rtcSendMessage(peer->dc, message, -1); // negative size indicates a null-terminated string
 }
 
-static void closedCallback(void *ptr) {
+static void closedCallback(int id, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->connected = false;
 }
 
-static void messageCallback(const char *message, int size, void *ptr) {
+static void messageCallback(int id, const char *message, int size, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	if (size < 0) { // negative size indicates a null-terminated string
 		printf("Message %d: %s\n", peer == peer1 ? 1 : 2, message);
@@ -91,7 +91,7 @@ static void messageCallback(const char *message, int size, void *ptr) {
 	}
 }
 
-static void dataChannelCallback(int dc, void *ptr) {
+static void dataChannelCallback(int pc, int dc, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->dc = dc;
 	peer->connected = true;

test/capi_track.cpp

@@ -43,44 +43,44 @@ static Peer *peer2 = NULL;
 static const char *mediaDescription = "video 9 UDP/TLS/RTP/SAVPF\r\n"
                                       "a=mid:video\r\n";
 
-static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
+static void descriptionCallback(int pc, const char *sdp, const char *type, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	printf("Description %d:\n%s\n", peer == peer1 ? 1 : 2, sdp);
 	Peer *other = peer == peer1 ? peer2 : peer1;
 	rtcSetRemoteDescription(other->pc, sdp, type);
 }
 
-static void candidateCallback(const char *cand, const char *mid, void *ptr) {
+static void candidateCallback(int pc, const char *cand, const char *mid, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	printf("Candidate %d: %s\n", peer == peer1 ? 1 : 2, cand);
 	Peer *other = peer == peer1 ? peer2 : peer1;
 	rtcAddRemoteCandidate(other->pc, cand, mid);
 }
 
-static void stateChangeCallback(rtcState state, void *ptr) {
+static void stateChangeCallback(int pc, rtcState state, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->state = state;
 	printf("State %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
 }
 
-static void gatheringStateCallback(rtcGatheringState state, void *ptr) {
+static void gatheringStateCallback(int pc, rtcGatheringState state, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->gatheringState = state;
 	printf("Gathering state %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
 }
 
-static void openCallback(void *ptr) {
+static void openCallback(int id, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->connected = true;
 	printf("Track %d: Open\n", peer == peer1 ? 1 : 2);
 }
 
-static void closedCallback(void *ptr) {
+static void closedCallback(int id, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->connected = false;
 }
 
-static void trackCallback(int tr, void *ptr) {
+static void trackCallback(int pc, int tr, void *ptr) {
 	Peer *peer = (Peer *)ptr;
 	peer->tr = tr;
 	peer->connected = true;