A project name changed
Ryan Lee
parent
c7b59c0010
commit
7a21a34e04
94
API.md
94
API.md
|
|
@ -1,8 +1,8 @@
|
|||
# PeerConnect
|
||||
# Peer
|
||||
|
||||
### Table of Contents
|
||||
* Constructor
|
||||
* [PeerConnect()](#classpeerconnect)
|
||||
* [Peer()](#classpeer)
|
||||
* Methods
|
||||
* [Open()](#open)
|
||||
* [Close()](#close)
|
||||
|
|
@ -15,8 +15,8 @@
|
|||
* [On("message")](#onmessage)
|
||||
* [On("writable")](#onwritable)
|
||||
* Static Methods
|
||||
* [PeerConnect::Run()](#run)
|
||||
* [PeerConnect::Stop()](#stop)
|
||||
* [Peer::Run()](#run)
|
||||
* [Peer::Stop()](#stop)
|
||||
* Example
|
||||
* [echo_server](#echoserver)
|
||||
* [echo_client](#echoclient)
|
||||
|
|
@ -30,20 +30,20 @@ Include following at the top of your code
|
|||
#include "peerconnect.h"
|
||||
```
|
||||
|
||||
## Class: PeerConnect
|
||||
## Class: Peer
|
||||
|
||||
This class is a PeerConnect server and client.
|
||||
This class is a PeerApi server and client.
|
||||
|
||||
## Constructor
|
||||
|
||||
<a name="classpeerconnect"/>
|
||||
### PeerConnect()
|
||||
<a name="classpeer"/>
|
||||
### Peer()
|
||||
|
||||
Construct a new PeerConnect object. A `peer` is local name of peer and remote peer may connect to local peer with `peer` name.
|
||||
Construct a new Peer object. A `peer` is local name of peer and remote peer may connect to local peer with `peer` name.
|
||||
|
||||
```c++
|
||||
PeerConnect(
|
||||
const std::string peer = ""
|
||||
Peer(
|
||||
const std::string peer_id = ""
|
||||
)
|
||||
```
|
||||
|
||||
|
|
@ -55,9 +55,9 @@ Parameters
|
|||
Examples
|
||||
|
||||
```c++
|
||||
PeerConnect pc1;
|
||||
PeerConnect pc2("PEER_NAME");
|
||||
PeerConnect pc3("Your@email.com");
|
||||
Peer peer1;
|
||||
Peer peer2("PEER_NAME");
|
||||
Peer peer3("Your@email.com");
|
||||
```
|
||||
|
||||
## Methods
|
||||
|
|
@ -78,7 +78,7 @@ Close the remote peer connection or connection attempt, if any. If the connectio
|
|||
|
||||
```c++
|
||||
void Close(
|
||||
const std::string peer = ""
|
||||
const std::string peer_id = ""
|
||||
)
|
||||
```
|
||||
|
||||
|
|
@ -94,7 +94,7 @@ Connect to remote peer.
|
|||
|
||||
```c++
|
||||
void Connect(
|
||||
const std::string peer
|
||||
const std::string peer_id
|
||||
)
|
||||
```
|
||||
|
||||
|
|
@ -110,14 +110,14 @@ Transmits data to the peer over p2p connection.
|
|||
|
||||
```c++
|
||||
bool Send(
|
||||
const std::string& peer,
|
||||
const std::string& peer_id,
|
||||
const char* data,
|
||||
const size_t size,
|
||||
const bool wait = SYNC_OFF
|
||||
)
|
||||
|
||||
bool Send(
|
||||
const string& peer,
|
||||
const string& peer_id,
|
||||
const string& data,
|
||||
const bool wait = SYNC_OFF
|
||||
)
|
||||
|
|
@ -139,10 +139,10 @@ Constants
|
|||
<a name="onopen"/>
|
||||
### On("open")
|
||||
|
||||
Attaches "open" event handler. A "open" event is emitted when PeerConnect is ready by `Open()` method.
|
||||
Attaches "open" event handler. A "open" event is emitted when Peer is ready by `Open()` method.
|
||||
|
||||
```c++
|
||||
pc.On("open", function_pc( std::string peer ) {
|
||||
peer.On("open", function_peer( std::string peer_id ) {
|
||||
// ...
|
||||
})
|
||||
```
|
||||
|
|
@ -157,7 +157,7 @@ Parameters
|
|||
Attaches "close" event handler. A "close" event is emitted when connection is closed.
|
||||
|
||||
```c++
|
||||
pc.On("close", function_pc( std::string peer, CloseCode code, std::string desc ) {
|
||||
peer.On("close", function_peer( std::string peer_id, CloseCode code, std::string desc ) {
|
||||
// ...
|
||||
})
|
||||
```
|
||||
|
|
@ -165,7 +165,7 @@ pc.On("close", function_pc( std::string peer, CloseCode code, std::string desc )
|
|||
Parameters
|
||||
|
||||
> * peer : A name of closed peer. Note that peer is one of local peer or remote peer.
|
||||
> * code : A close code defined in the PeerConnect.
|
||||
> * code : A close code defined in the Peer.
|
||||
> * desc : A description of close reason.
|
||||
|
||||
Constants
|
||||
|
|
@ -189,7 +189,7 @@ enum CloseCode {
|
|||
Attaches "connect" event handler. A "connect" event is emitted when connection is established.
|
||||
|
||||
```c++
|
||||
pc.On("connect", function_pc( std::string peer ) {
|
||||
peer.On("connect", function_peer( std::string peer_id ) {
|
||||
// ...
|
||||
})
|
||||
```
|
||||
|
|
@ -204,7 +204,7 @@ Parameters
|
|||
Attaches "message" event handler. A "message" event is emitted when data is received.
|
||||
|
||||
```c++
|
||||
pc.On("message", function_pc( std::string peer, char* data, std::size_t size ) {
|
||||
peer.On("message", function_peer( std::string peer_id, char* data, std::size_t size ) {
|
||||
// ...
|
||||
})
|
||||
```
|
||||
|
|
@ -222,7 +222,7 @@ Parameters
|
|||
Attaches "writable" event handler. A "writable" event is emitted when read to send data. It is useful when asynchronously (SYNC_OFF) sending a data.
|
||||
|
||||
```c++
|
||||
pc.On("writable", function_pc( std::string peer ){
|
||||
peer.On("writable", function_peer( std::string peer_id ){
|
||||
// ...
|
||||
});
|
||||
```
|
||||
|
|
@ -233,21 +233,21 @@ Parameter
|
|||
## Static methods
|
||||
|
||||
<a name="run"/>
|
||||
### PeerConnect::Run()
|
||||
### Peer::Run()
|
||||
|
||||
Run PeerConnect object's event processing loop. Note that the thread quit a loop if other thread calls PeerConnect::Stop() method.
|
||||
Run Peer object's event processing loop. Note that the thread quit a loop if other thread calls Peer::Stop() method.
|
||||
|
||||
```c++
|
||||
void PeerConnect::Run()
|
||||
void Peer::Run()
|
||||
```
|
||||
|
||||
<a name="stop"/>
|
||||
### PeerConnect::Stop()
|
||||
### Peer::Stop()
|
||||
|
||||
Stop PeerConnect object's event processing loop.
|
||||
Stop Peer object's event processing loop.
|
||||
|
||||
```c++
|
||||
void PeerConnect::Stop()
|
||||
void Peer::Stop()
|
||||
```
|
||||
|
||||
## Example
|
||||
|
|
@ -256,39 +256,39 @@ void PeerConnect::Stop()
|
|||
* echo server
|
||||
|
||||
```c++
|
||||
PeerConnect pc("SERVER_PEER");
|
||||
Peer peer("SERVER_PEER");
|
||||
|
||||
pc.On("message", function_pc(std::string peer, char* data, std::size_t size) {
|
||||
peer.On("message", function_peer(std::string peer_id, char* data, std::size_t size) {
|
||||
// Echo message
|
||||
pc.Send(peer, data, size);
|
||||
peer.Send(peer, data, size);
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
PeerConnect::Run();
|
||||
peer.Open();
|
||||
Peer::Run();
|
||||
```
|
||||
|
||||
<a name="echoclient"/>
|
||||
* echo client
|
||||
```c++
|
||||
|
||||
PeerConnect pc;
|
||||
Peer peer;
|
||||
|
||||
pc.On("open", function_pc(std::string peer) {
|
||||
pc.Connect("SERVER_PEER");
|
||||
peer.On("open", function_peer(std::string peer_id) {
|
||||
peer.Connect("SERVER_PEER");
|
||||
});
|
||||
|
||||
pc.On("connect", function_pc(std::string peer) {
|
||||
pc.Send(peer, "Hello world");
|
||||
peer.On("connect", function_peer(std::string peer_id) {
|
||||
peer.Send(peer, "Hello world");
|
||||
});
|
||||
|
||||
pc.On("close", function_pc(std::string peer, CloseCode code, std::string desc) {
|
||||
PeerConnect::Stop();
|
||||
peer.On("close", function_peer(std::string peer_id, CloseCode code, std::string desc) {
|
||||
Peer::Stop();
|
||||
});
|
||||
|
||||
pc.On("message", function_pc(std::string peer, char* data, std::size_t size) {
|
||||
pc.Close();
|
||||
peer.On("message", function_peer(std::string peer_id, char* data, std::size_t size) {
|
||||
peer.Close();
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
PeerConnect::Run();
|
||||
peer.Open();
|
||||
Peer::Run();
|
||||
```
|
||||
|
|
|
|||
30
README.md
30
README.md
|
|
@ -1,4 +1,4 @@
|
|||
# PeerConnect
|
||||
# PeerApi
|
||||
|
||||
A peer-to-peer C++ library for network.
|
||||
|
||||
|
|
@ -10,28 +10,28 @@ A peer-to-peer C++ library for network.
|
|||
# Quick start
|
||||
Peer A (listen)
|
||||
```c++
|
||||
PeerConnect pc("PEER_A");
|
||||
Peer peer("PEER_A");
|
||||
|
||||
pc.On("message", function_pc(string peer, char* data, size_t size) {
|
||||
peer.On("message", function_peer(string peer_id, char* data, size_t size) {
|
||||
std::cout << "A message has been received." << std::endl;
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
peer.Open();
|
||||
```
|
||||
|
||||
Peer B (connect)
|
||||
```c++
|
||||
PeerConnect pc("PEER_B");
|
||||
Peer peer("PEER_B");
|
||||
|
||||
pc.On("open", function_pc(string peer) {
|
||||
pc.>Connect("PEER_A");
|
||||
peer.On("open", function_peer(string peer_id) {
|
||||
peer.>Connect("PEER_A");
|
||||
});
|
||||
|
||||
pc.On("connect", function_pc(string peer) {
|
||||
pc.Send("PEER_A", "Hello");
|
||||
peer.On("connect", function_peer(string peer_id) {
|
||||
peer.Send("PEER_A", "Hello");
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
peer.Open();
|
||||
```
|
||||
|
||||
# API
|
||||
|
|
@ -42,7 +42,7 @@ See the [API.md](API.md) document.
|
|||
|
||||
See the **examples** directory.
|
||||
|
||||
* [p2p netcat](https://github.com/peersio/peerconnect/tree/master/examples/p2p_netcat): netcat on peer-to-peer way
|
||||
* [p2p netcat](https://github.com/peerborough/peerapi/tree/master/examples/p2p_netcat): netcat on peer-to-peer way
|
||||
|
||||
|
||||
# Build
|
||||
|
|
@ -63,10 +63,10 @@ In the [WebRTC development](https://webrtc.org/native-code/development/) instruc
|
|||
* Follow 'Before You Start' step
|
||||
* Follow 'Getting the code' step
|
||||
|
||||
Currently PeerConnect supports WebRTC branch-heads/60 so run
|
||||
Currently PeerApi supports WebRTC branch-heads/60 so run
|
||||
|
||||
```
|
||||
$ git checkout -b peers60 refs/remotes/branch-heads/60
|
||||
$ git checkout -b peerapi60 refs/remotes/branch-heads/60
|
||||
```
|
||||
|
||||
To update build toolchain and dependencies of WebRTC, run:
|
||||
|
|
@ -74,10 +74,10 @@ To update build toolchain and dependencies of WebRTC, run:
|
|||
$ gclient sync
|
||||
```
|
||||
|
||||
Note that you don't have to follow 'Generating Ninja project files' or 'Compiling' step. PeerConnect will do that internally.
|
||||
Note that you don't have to follow 'Generating Ninja project files' or 'Compiling' step. PeerApi will do that internally.
|
||||
|
||||
|
||||
## Build PeerConnect
|
||||
## Build PeerApi
|
||||
|
||||
Generate the build files
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -24,30 +24,30 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
string server = argv[1];
|
||||
|
||||
PeerConnect pc;
|
||||
Peer peer;
|
||||
|
||||
pc.On("open", function_pc(string peer) {
|
||||
pc.Connect(server);
|
||||
peer.On("open", function_peer(string peer_id) {
|
||||
peer.Connect(server);
|
||||
});
|
||||
|
||||
pc.On("connect", function_pc(string peer) {
|
||||
pc.Send(peer, "Hello world");
|
||||
std::cout << "Sent 'Hello world' message to " << peer << "." << std::endl;
|
||||
peer.On("connect", function_peer(string peer_id) {
|
||||
peer.Send(peer_id, "Hello world");
|
||||
std::cout << "Sent 'Hello world' message to " << peer_id << "." << std::endl;
|
||||
});
|
||||
|
||||
pc.On("close", function_pc(string peer, CloseCode code, string desc) {
|
||||
std::cout << "Peer " << peer << " has been closed" << std::endl;
|
||||
PeerConnect::Stop();
|
||||
peer.On("close", function_peer(string peer_id, CloseCode code, string desc) {
|
||||
std::cout << "Peer " << peer_id << " has been closed" << std::endl;
|
||||
Peer::Stop();
|
||||
});
|
||||
|
||||
pc.On("message", function_pc(string peer, char* data, size_t size) {
|
||||
peer.On("message", function_peer(string peer_id, char* data, size_t size) {
|
||||
std::cout << "Message '" << std::string(data, size) <<
|
||||
"' has been received." << std::endl;
|
||||
pc.Close();
|
||||
peer.Close();
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
PeerConnect::Run();
|
||||
peer.Open();
|
||||
Peer::Run();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -21,24 +21,24 @@ int main(int argc, char *argv[]) {
|
|||
}
|
||||
string server = argv[1];
|
||||
|
||||
PeerConnect pc(server);
|
||||
Peer peer(server);
|
||||
|
||||
pc.On("connect", function_pc(string peer) {
|
||||
std::cout << "Peer " << peer << " has been connected." << std::endl;
|
||||
peer.On("connect", function_peer(string peer_id) {
|
||||
std::cout << "Peer " << peer_id << " has been connected." << std::endl;
|
||||
});
|
||||
|
||||
pc.On("close", function_pc(string peer, CloseCode code, string desc) {
|
||||
std::cout << "Peer " << peer << " has been closed." << std::endl;
|
||||
peer.On("close", function_peer(string peer_id, CloseCode code, string desc) {
|
||||
std::cout << "Peer " << peer_id << " has been closed." << std::endl;
|
||||
});
|
||||
|
||||
pc.On("message", function_pc(string peer, char* data, size_t size) {
|
||||
peer.On("message", function_peer(string peer_id, char* data, size_t size) {
|
||||
std::cout << "Message " << std::string(data, size) <<
|
||||
" has been received." << std::endl;
|
||||
pc.Send(peer,data, size);
|
||||
peer.Send(peer_id,data, size);
|
||||
});
|
||||
|
||||
pc.Open();
|
||||
PeerConnect::Run();
|
||||
peer.Open();
|
||||
Peer::Run();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# Netcat over p2p network
|
||||
This is PeerConnect library example.
|
||||
This is PeerApi library example.
|
||||
|
||||
# Usage
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -27,27 +27,27 @@
|
|||
using namespace std;
|
||||
|
||||
|
||||
bool parse_args(int argc, char* argv[], string& local_peer, string& remote_peer, bool& server_mode);
|
||||
bool parse_args(int argc, char* argv[], string& local_peer_id, string& remote_peer_id, bool& server_mode);
|
||||
void usage(const char* prg);
|
||||
void read_stdin(PeerConnect* pc, std::string peer);
|
||||
void read_stdin(Peer* peer, std::string peer_id);
|
||||
bool write_stdout(const char* buf, int len);
|
||||
void set_mode(PeerConnect* pc);
|
||||
void set_mode(Peer* peer);
|
||||
void ctrlc_handler(int s);
|
||||
|
||||
static PeerConnect *pc_;
|
||||
static Peer *peer_;
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
|
||||
string local_peer;
|
||||
string remote_peer;
|
||||
string local_peer_id;
|
||||
string remote_peer_id;
|
||||
bool server_mode;
|
||||
|
||||
//
|
||||
// Parse arguments
|
||||
//
|
||||
|
||||
if (!parse_args(argc, argv, local_peer, remote_peer, server_mode)) {
|
||||
if (!parse_args(argc, argv, local_peer_id, remote_peer_id, server_mode)) {
|
||||
usage(argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -56,32 +56,32 @@ int main(int argc, char *argv[]) {
|
|||
// Set event handlers
|
||||
//
|
||||
|
||||
PeerConnect pc(local_peer);
|
||||
Peer peer(local_peer_id);
|
||||
|
||||
set_mode(&pc);
|
||||
set_mode(&peer);
|
||||
|
||||
pc.On("open", function_pc( string peer ) {
|
||||
peer.On("open", function_peer( string peer_id ) {
|
||||
if (server_mode) {
|
||||
std::cerr << "Listening " << peer << std::endl;
|
||||
std::cerr << "Listening " << peer_id << std::endl;
|
||||
}
|
||||
else {
|
||||
std::cerr << "Connecting to " << remote_peer << std::endl;
|
||||
pc.Connect(remote_peer);
|
||||
std::cerr << "Connecting to " << remote_peer_id << std::endl;
|
||||
peer.Connect(remote_peer_id);
|
||||
}
|
||||
});
|
||||
|
||||
pc.On("connect", function_pc( string peer ) {
|
||||
peer.On("connect", function_peer( string peer_id ) {
|
||||
std::cerr << "Connected" << std::endl;
|
||||
std::thread(read_stdin, &pc, peer).detach();
|
||||
std::thread(read_stdin, &peer, peer_id).detach();
|
||||
});
|
||||
|
||||
pc.On("close", function_pc( string peer, CloseCode code, string desc ) {
|
||||
peer.On("close", function_peer( string peer_id, CloseCode code, string desc ) {
|
||||
|
||||
if ( peer == local_peer ) {
|
||||
PeerConnect::Stop();
|
||||
if ( peer_id == local_peer_id ) {
|
||||
Peer::Stop();
|
||||
}
|
||||
else {
|
||||
pc.Close();
|
||||
peer.Close();
|
||||
}
|
||||
|
||||
if ( !desc.empty() ) {
|
||||
|
|
@ -89,9 +89,9 @@ int main(int argc, char *argv[]) {
|
|||
}
|
||||
});
|
||||
|
||||
pc.On("message", function_pc(string peer, char *data, size_t size) {
|
||||
peer.On("message", function_peer(string peer_id, char *data, size_t size) {
|
||||
if (!write_stdout(data, size)) {
|
||||
pc.Close(peer);
|
||||
peer.Close(peer_id);
|
||||
}
|
||||
});
|
||||
|
||||
|
|
@ -99,9 +99,9 @@ int main(int argc, char *argv[]) {
|
|||
// Sign in as anonymous user
|
||||
//
|
||||
|
||||
pc.Open();
|
||||
peer.Open();
|
||||
|
||||
PeerConnect::Run();
|
||||
Peer::Run();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -119,7 +119,7 @@ int main(int argc, char *argv[]) {
|
|||
#define STDERR_FILENO 2
|
||||
#endif
|
||||
|
||||
void read_stdin(PeerConnect* pc, std::string peer)
|
||||
void read_stdin(Peer* peer, std::string peer_id)
|
||||
{
|
||||
int nbytes;
|
||||
char buf[32*1024];
|
||||
|
|
@ -127,11 +127,11 @@ void read_stdin(PeerConnect* pc, std::string peer)
|
|||
for (;;) {
|
||||
nbytes = read(STDIN_FILENO, buf, sizeof(buf));
|
||||
if (nbytes <= 0) {
|
||||
pc->Close( peer );
|
||||
peer->Close( peer_id );
|
||||
return;
|
||||
}
|
||||
|
||||
if (!pc->Send(peer, buf, nbytes, SYNC_ON)) {
|
||||
if (!peer->Send(peer_id, buf, nbytes, SYNC_ON)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -156,12 +156,12 @@ bool write_stdout(const char* buf, int len)
|
|||
|
||||
void ctrlc_handler(int s) {
|
||||
std::cerr << "Terminating..." << std::endl;
|
||||
pc_->Close();
|
||||
peer_->Close();
|
||||
}
|
||||
|
||||
void set_mode(PeerConnect* pc)
|
||||
void set_mode(Peer* peer)
|
||||
{
|
||||
pc_ = pc;
|
||||
peer_ = peer;
|
||||
signal(SIGINT, ctrlc_handler);
|
||||
|
||||
#ifdef WIN32
|
||||
|
|
@ -171,15 +171,15 @@ void set_mode(PeerConnect* pc)
|
|||
#endif
|
||||
}
|
||||
|
||||
bool parse_args(int argc, char* argv[], string& local_peer, string& remote_peer, bool& server_mode) {
|
||||
bool parse_args(int argc, char* argv[], string& local_peer_id, string& remote_peer_id, bool& server_mode) {
|
||||
if (argc == 2) {
|
||||
remote_peer = argv[1];
|
||||
local_peer = PeerConnect::CreateRandomUuid();
|
||||
remote_peer_id = argv[1];
|
||||
local_peer_id = Peer::CreateRandomUuid();
|
||||
server_mode = false;
|
||||
return true;
|
||||
}
|
||||
else if (argc == 3 && std::string(argv[1]) == "-l") {
|
||||
local_peer = argv[2];
|
||||
local_peer_id = argv[2];
|
||||
server_mode = true;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -187,7 +187,7 @@ bool parse_args(int argc, char* argv[], string& local_peer, string& remote_peer,
|
|||
}
|
||||
|
||||
void usage(const char* prg) {
|
||||
std::cerr << "P2P netcat demo (http://github.com/peersio/peerconnect)" << std::endl << std::endl;
|
||||
std::cerr << "P2P netcat demo (http://github.com/peerborough/peerapi)" << std::endl << std::endl;
|
||||
std::cerr << "Usage: " << prg << " [-l] name" << std::endl << std::endl;
|
||||
std::cerr << " Options:" << std::endl;
|
||||
std::cerr << " -l Listen mode, for inbound connections" << std::endl << std::endl;
|
||||
|
|
|
|||
14
src/common.h
14
src/common.h
|
|
@ -1,16 +1,16 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
||||
|
||||
#ifndef __PEERCONNECT_COMMON_H__
|
||||
#define __PEERCONNECT_COMMON_H__
|
||||
#ifndef __PEERAPI_COMMON_H__
|
||||
#define __PEERAPI_COMMON_H__
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
#define function_pc [&]
|
||||
#define function_peer [&]
|
||||
|
||||
enum CloseCode {
|
||||
// Success
|
||||
|
|
@ -30,6 +30,6 @@ const bool SYNC_ON = true;
|
|||
const bool FORCE_QUEUING_OFF = false;
|
||||
const bool FORCE_QUEUING_ON = true;
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_COMMON_H__
|
||||
#endif // __PEERAPI_COMMON_H__
|
||||
108
src/control.cc
108
src/control.cc
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -27,7 +27,7 @@ namespace rtc {
|
|||
|
||||
#endif // WEBRTC_POSIX
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
Control::Control()
|
||||
: Control(nullptr){
|
||||
|
|
@ -85,21 +85,21 @@ void Control::DeleteControl() {
|
|||
}
|
||||
|
||||
|
||||
void Control::Open(const string& user_id, const string& user_password, const string& peer) {
|
||||
void Control::Open(const string& user_id, const string& user_password, const string& peer_id) {
|
||||
|
||||
// 1. Connect to signal server
|
||||
// 2. Send open command to signal server
|
||||
// 3. Send createchannel command to signal server.
|
||||
// A peer name is user-supplied string to listen or random string.
|
||||
// Other peers connect to this peer by peer name.
|
||||
// 4. Generate 'open' event to PeerConnect
|
||||
// 4. Generate 'open' event to Peer
|
||||
|
||||
if (signal_.get() == NULL) {
|
||||
LOG_F( LERROR ) << "Open failed, no signal server";
|
||||
return;
|
||||
}
|
||||
|
||||
peer_name_ = peer;
|
||||
peer_name_ = peer_id;
|
||||
user_id_ = user_id;
|
||||
|
||||
// Connect to signal server
|
||||
|
|
@ -109,7 +109,7 @@ void Control::Open(const string& user_id, const string& user_password, const str
|
|||
return;
|
||||
}
|
||||
|
||||
void Control::Connect(const string peer) {
|
||||
void Control::Connect(const string peer_id) {
|
||||
|
||||
// 1. Join channel on signal server
|
||||
// 2. Server(remote) peer createoffer
|
||||
|
|
@ -121,8 +121,8 @@ void Control::Connect(const string peer) {
|
|||
return;
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Joining channel " << peer;
|
||||
JoinChannel(peer);
|
||||
LOG_F( INFO ) << "Joining channel " << peer_id;
|
||||
JoinChannel(peer_id);
|
||||
}
|
||||
|
||||
void Control::Close(const CloseCode code, bool force_queuing) {
|
||||
|
|
@ -161,23 +161,23 @@ void Control::Close(const CloseCode code, bool force_queuing) {
|
|||
// Close signal server
|
||||
//
|
||||
|
||||
if ( pc_ ) {
|
||||
pc_->OnClose( peer_name_ ,code );
|
||||
if ( peer_ ) {
|
||||
peer_->OnClose( peer_name_ ,code );
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void Control::ClosePeer( const string peer, const CloseCode code, bool force_queuing ) {
|
||||
void Control::ClosePeer( const string peer_id, const CloseCode code, bool force_queuing ) {
|
||||
|
||||
//
|
||||
// Called by
|
||||
// PeerConnect if user closes the connection.
|
||||
// Peer if user closes the connection.
|
||||
// PeerControl if remote peer closes a ice connection or data channel
|
||||
//
|
||||
|
||||
if (force_queuing || webrtc_thread_ != rtc::Thread::Current()) {
|
||||
ControlMessageData *data = new ControlMessageData(peer, ref_);
|
||||
ControlMessageData *data = new ControlMessageData(peer_id, ref_);
|
||||
data->data_int32_ = code;
|
||||
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_CLOSE_PEER, data);
|
||||
return;
|
||||
|
|
@ -186,9 +186,9 @@ void Control::ClosePeer( const string peer, const CloseCode code, bool force_que
|
|||
// 1. Erase peer
|
||||
// 2. Close peer
|
||||
|
||||
auto peer_found = peers_.find(peer);
|
||||
auto peer_found = peers_.find(peer_id);
|
||||
if ( peer_found == peers_.end() ) {
|
||||
LOG_F( WARNING ) << "peer not found, " << peer;
|
||||
LOG_F( WARNING ) << "peer not found, " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -197,9 +197,9 @@ void Control::ClosePeer( const string peer, const CloseCode code, bool force_que
|
|||
item->Close(code);
|
||||
|
||||
// 3. Leave channel on signal server
|
||||
LeaveChannel(peer);
|
||||
LeaveChannel(peer_id);
|
||||
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
//
|
||||
|
|
@ -232,73 +232,73 @@ bool Control::SyncSend(const string to, const char* data, const size_t size) {
|
|||
// Send command to other peer by signal server
|
||||
//
|
||||
|
||||
void Control::SendCommand(const string& peer, const string& command, const Json::Value& data) {
|
||||
signal_->SendCommand(peer, command, data);
|
||||
void Control::SendCommand(const string& peer_id, const string& command, const Json::Value& data) {
|
||||
signal_->SendCommand(peer_id, command, data);
|
||||
}
|
||||
|
||||
|
||||
void Control::OnPeerConnect(const string peer) {
|
||||
if ( pc_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
|
||||
void Control::OnPeerConnect(const string peer_id) {
|
||||
if ( peer_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "peer_ is null, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
pc_->OnConnect(peer);
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
peer_->OnConnect(peer_id);
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
void Control::OnPeerClose(const string peer, CloseCode code) {
|
||||
void Control::OnPeerClose(const string peer_id, CloseCode code) {
|
||||
|
||||
if (webrtc_thread_ != rtc::Thread::Current()) {
|
||||
ControlMessageData *data = new ControlMessageData(peer, ref_);
|
||||
ControlMessageData *data = new ControlMessageData(peer_id, ref_);
|
||||
|
||||
// Call Control::OnPeerDisconnected()
|
||||
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_ON_PEER_CLOSE, data);
|
||||
LOG_F( INFO ) << "Queued, peer is " << peer;
|
||||
LOG_F( INFO ) << "Queued, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Enter, peer is " << peer;
|
||||
LOG_F( INFO ) << "Enter, peer is " << peer_id;
|
||||
|
||||
if ( pc_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
|
||||
if ( peer_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "peer_ is null, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
pc_->OnClose( peer, code );
|
||||
peer_->OnClose( peer_id, code );
|
||||
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
//
|
||||
// Signal receiving data
|
||||
//
|
||||
|
||||
void Control::OnPeerMessage(const string& peer, const char* data, const size_t size) {
|
||||
if ( pc_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
|
||||
void Control::OnPeerMessage(const string& peer_id, const char* data, const size_t size) {
|
||||
if ( peer_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "peer_ is null, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
pc_->OnMessage(peer, data, size);
|
||||
peer_->OnMessage(peer_id, data, size);
|
||||
}
|
||||
|
||||
void Control::OnPeerWritable(const string& peer) {
|
||||
if ( pc_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
|
||||
void Control::OnPeerWritable(const string& peer_id) {
|
||||
if ( peer_ == nullptr ) {
|
||||
LOG_F( WARNING ) << "peer_ is null, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
pc_->OnWritable(peer);
|
||||
peer_->OnWritable(peer_id);
|
||||
}
|
||||
|
||||
void Control::RegisterObserver(ControlObserver* observer, std::shared_ptr<Control> ref) {
|
||||
ref_ = ref;
|
||||
pc_ = observer;
|
||||
peer_ = observer;
|
||||
|
||||
LOG_F( INFO ) << "Registered";
|
||||
}
|
||||
|
||||
void Control::UnregisterObserver() {
|
||||
pc_ = nullptr;
|
||||
peer_ = nullptr;
|
||||
ref_.reset();
|
||||
|
||||
LOG_F( INFO ) << "Unregistered";
|
||||
|
|
@ -535,13 +535,13 @@ void Control::OnChannelCreate(const Json::Value& data) {
|
|||
bool result;
|
||||
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
|
||||
LOG_F(WARNING) << "Unknown open response";
|
||||
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
|
||||
peer_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
|
||||
return;
|
||||
}
|
||||
|
||||
string peer;
|
||||
if (!rtc::GetStringFromJsonObject(data, "name", &peer)) {
|
||||
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
|
||||
string peer_id;
|
||||
if (!rtc::GetStringFromJsonObject(data, "name", &peer_id)) {
|
||||
peer_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
|
||||
LOG_F(LERROR) << "Create channel failed - no channel name";
|
||||
return;
|
||||
}
|
||||
|
|
@ -553,11 +553,11 @@ void Control::OnChannelCreate(const Json::Value& data) {
|
|||
desc = "Unknown reason";
|
||||
}
|
||||
|
||||
pc_->OnClose(peer, CLOSE_SIGNAL_ERROR, desc);
|
||||
peer_->OnClose(peer_id, CLOSE_SIGNAL_ERROR, desc);
|
||||
return;
|
||||
}
|
||||
|
||||
pc_->OnOpen(peer);
|
||||
peer_->OnOpen(peer_id);
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
|
@ -567,14 +567,14 @@ void Control::OnChannelJoin(const Json::Value& data) {
|
|||
LOG_F(INFO) << "OnChannelJoined(" << data.toStyledString() << ")";
|
||||
|
||||
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
|
||||
pc_->OnClose( "", CLOSE_SIGNAL_ERROR );
|
||||
peer_->OnClose( "", CLOSE_SIGNAL_ERROR );
|
||||
LOG_F(LERROR) << "Unknown channel join response";
|
||||
return;
|
||||
}
|
||||
|
||||
string peer;
|
||||
if (!rtc::GetStringFromJsonObject(data, "name", &peer)) {
|
||||
pc_->OnClose( "", CLOSE_SIGNAL_ERROR );
|
||||
string peer_id;
|
||||
if (!rtc::GetStringFromJsonObject(data, "name", &peer_id)) {
|
||||
peer_->OnClose( "", CLOSE_SIGNAL_ERROR );
|
||||
LOG_F(LERROR) << "Join channel failed - no channel name";
|
||||
return;
|
||||
}
|
||||
|
|
@ -586,7 +586,7 @@ void Control::OnChannelJoin(const Json::Value& data) {
|
|||
desc = "Unknown reason";
|
||||
}
|
||||
|
||||
pc_->OnClose( peer, CLOSE_SIGNAL_ERROR, desc );
|
||||
peer_->OnClose( peer_id, CLOSE_SIGNAL_ERROR, desc );
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -691,4 +691,4 @@ void Control::ReceiveAnswerSdp(const string& peer_id, const Json::Value& data) {
|
|||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
||||
#ifndef __PEERCONNECT_CONTROL_H__
|
||||
#define __PEERCONNECT_CONTROL_H__
|
||||
#ifndef __PEERAPI_CONTROL_H__
|
||||
#define __PEERAPI_CONTROL_H__
|
||||
|
||||
#include <memory>
|
||||
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
#include "fakeaudiocapturemodule.h"
|
||||
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
class Control
|
||||
: public PeerObserver,
|
||||
|
|
@ -46,10 +46,10 @@ public:
|
|||
void Send(const string to, const char* data, const size_t size);
|
||||
bool SyncSend(const string to, const char* data, const size_t size);
|
||||
|
||||
void Open(const string& user_id, const string& user_password, const string& peer);
|
||||
void Open(const string& user_id, const string& user_password, const string& peer_id);
|
||||
void Close(const CloseCode code, bool force_queueing = FORCE_QUEUING_OFF);
|
||||
void Connect(const string peer);
|
||||
bool IsWritable(const string peer);
|
||||
void Connect(const string peer_id);
|
||||
bool IsWritable(const string peer_id);
|
||||
|
||||
void OnCommandReceived(const Json::Value& message);
|
||||
void OnSignalCommandReceived(const Json::Value& message);
|
||||
|
|
@ -59,12 +59,12 @@ public:
|
|||
// PeerObserver implementation
|
||||
//
|
||||
|
||||
virtual void SendCommand(const string& peer, const string& command, const Json::Value& data);
|
||||
virtual void ClosePeer( const string peer, const CloseCode code, bool force_queueing = FORCE_QUEUING_OFF );
|
||||
virtual void OnPeerConnect(const string peer);
|
||||
virtual void OnPeerClose(const string peer, const CloseCode code);
|
||||
virtual void OnPeerMessage(const string& peer, const char* data, const size_t size);
|
||||
virtual void OnPeerWritable(const string& peer);
|
||||
virtual void SendCommand(const string& peer_id, const string& command, const Json::Value& data);
|
||||
virtual void ClosePeer( const string peer_id, const CloseCode code, bool force_queueing = FORCE_QUEUING_OFF );
|
||||
virtual void OnPeerConnect(const string peer_id);
|
||||
virtual void OnPeerClose(const string peer_id, const CloseCode code);
|
||||
virtual void OnPeerMessage(const string& peer_id, const char* data, const size_t size);
|
||||
virtual void OnPeerWritable(const string& peer_id);
|
||||
|
||||
|
||||
// Register/Unregister observer
|
||||
|
|
@ -130,10 +130,10 @@ private:
|
|||
};
|
||||
|
||||
rtc::Thread* webrtc_thread_;
|
||||
ControlObserver* pc_;
|
||||
ControlObserver* peer_;
|
||||
std::shared_ptr<Control> ref_;
|
||||
};
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_CONTROL_H__
|
||||
#endif // __PEERAPI_CONTROL_H__
|
||||
|
|
|
|||
|
|
@ -1,25 +1,25 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
||||
#ifndef __PEERCONNECT_CONTROLOBSERVER_H__
|
||||
#define __PEERCONNECT_CONTROLOBSERVER_H__
|
||||
#ifndef __PEERAPI_CONTROLOBSERVER_H__
|
||||
#define __PEERAPI_CONTROLOBSERVER_H__
|
||||
|
||||
#include "common.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
class ControlObserver {
|
||||
public:
|
||||
virtual void OnOpen(const std::string peer) = 0;
|
||||
virtual void OnClose(const std::string peer, const pc::CloseCode code, const std::string desc = "") = 0;
|
||||
virtual void OnConnect(const std::string peer) = 0;
|
||||
virtual void OnMessage(const std::string peer, const char* data, const size_t size) = 0;
|
||||
virtual void OnWritable(const std::string peer) = 0;
|
||||
virtual void OnOpen(const std::string peer_id) = 0;
|
||||
virtual void OnClose(const std::string peer_id, const peerapi::CloseCode code, const std::string desc = "") = 0;
|
||||
virtual void OnConnect(const std::string peer_id) = 0;
|
||||
virtual void OnMessage(const std::string peer_id, const char* data, const size_t size) = 0;
|
||||
virtual void OnWritable(const std::string peer_id) = 0;
|
||||
};
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_CONTROLOBSERVER_H__
|
||||
#endif // __PEERAPI_CONTROLOBSERVER_H__
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
// Note P postfix of a function indicates that it should only be called by the
|
||||
// processing thread.
|
||||
|
||||
#ifndef _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
#define _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
#ifndef _PEERAPI_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
#define _PEERAPI_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
|
||||
#include <memory>
|
||||
|
||||
|
|
@ -278,4 +278,4 @@ class FakeAudioCaptureModule
|
|||
rtc::CriticalSection crit_callback_;
|
||||
};
|
||||
|
||||
#endif // _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
#endif // _PEERAPI_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -55,7 +55,7 @@ static const char kLibjingle[] = "libjingle";
|
|||
|
||||
using namespace rtc;
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
namespace {
|
||||
|
||||
// Return the filename portion of the string (that following the last slash).
|
||||
|
|
@ -567,4 +567,4 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
|
|||
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -49,8 +49,8 @@
|
|||
// to output logging data at the desired level.
|
||||
// Lastly, PLOG(sev, err) is an alias for LOG_ERR_EX.
|
||||
|
||||
#ifndef __PEERCONNECT_LOGGING_H__
|
||||
#define __PEERCONNECT_LOGGING_H__
|
||||
#ifndef __PEERAPI_LOGGING_H__
|
||||
#define __PEERAPI_LOGGING_H__
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
|
|
@ -67,7 +67,7 @@
|
|||
#include "webrtc/base/constructormagic.h"
|
||||
#include "webrtc/base/thread_annotations.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// ConstantLabel can be used to easily generate string names from constant
|
||||
|
|
@ -286,19 +286,19 @@ class LogMessageVoidify {
|
|||
};
|
||||
|
||||
#define LOG_SEVERITY_PRECONDITION(sev) \
|
||||
!(pc::LogMessage::Loggable(sev)) \
|
||||
!(peerapi::LogMessage::Loggable(sev)) \
|
||||
? (void) 0 \
|
||||
: pc::LogMessageVoidify() &
|
||||
: peerapi::LogMessageVoidify() &
|
||||
|
||||
#define LOG(sev) \
|
||||
LOG_SEVERITY_PRECONDITION(pc::sev) \
|
||||
pc::LogMessage(__FILE__, __LINE__, pc::sev).stream()
|
||||
LOG_SEVERITY_PRECONDITION(peerapi::sev) \
|
||||
peerapi::LogMessage(__FILE__, __LINE__, peerapi::sev).stream()
|
||||
|
||||
// The _V version is for when a variable is passed in. It doesn't do the
|
||||
// namespace concatination.
|
||||
#define LOG_V(sev) \
|
||||
LOG_SEVERITY_PRECONDITION(sev) \
|
||||
pc::LogMessage(__FILE__, __LINE__, sev).stream()
|
||||
peerapi::LogMessage(__FILE__, __LINE__, sev).stream()
|
||||
|
||||
// The _F version prefixes the message with the current function name.
|
||||
#if (defined(__GNUC__) && !defined(NDEBUG)) || defined(WANT_PRETTY_LOG_F)
|
||||
|
|
@ -310,18 +310,18 @@ class LogMessageVoidify {
|
|||
#endif
|
||||
|
||||
#define LOG_CHECK_LEVEL(sev) \
|
||||
pc::LogCheckLevel(pc::sev)
|
||||
peerapi::LogCheckLevel(peerapi::sev)
|
||||
#define LOG_CHECK_LEVEL_V(sev) \
|
||||
pc::LogCheckLevel(sev)
|
||||
peerapi::LogCheckLevel(sev)
|
||||
|
||||
inline bool LogCheckLevel(LoggingSeverity sev) {
|
||||
return (LogMessage::GetMinLogSeverity() <= sev);
|
||||
}
|
||||
|
||||
#define LOG_E(sev, ctx, err, ...) \
|
||||
LOG_SEVERITY_PRECONDITION(pc::sev) \
|
||||
pc::LogMessage(__FILE__, __LINE__, pc::sev, \
|
||||
pc::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \
|
||||
LOG_SEVERITY_PRECONDITION(peerapi::sev) \
|
||||
peerapi::LogMessage(__FILE__, __LINE__, peerapi::sev, \
|
||||
peerapi::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \
|
||||
.stream()
|
||||
|
||||
#define LOG_T(sev) LOG(sev) << this << ": "
|
||||
|
|
@ -362,7 +362,7 @@ inline bool LogCheckLevel(LoggingSeverity sev) {
|
|||
|
||||
#define LOG_TAG(sev, tag) \
|
||||
LOG_SEVERITY_PRECONDITION(sev) \
|
||||
pc::LogMessage(nullptr, 0, sev, tag).stream()
|
||||
peerapi::LogMessage(nullptr, 0, sev, tag).stream()
|
||||
|
||||
#define PLOG(sev, err) \
|
||||
LOG_ERR_EX(sev, err)
|
||||
|
|
@ -371,6 +371,6 @@ inline bool LogCheckLevel(LoggingSeverity sev) {
|
|||
|
||||
#endif // LOG
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_LOGGING_H__
|
||||
#endif // __PEERAPI_LOGGING_H__
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
#include "logging.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
//
|
||||
// class PeerControl
|
||||
|
|
@ -46,7 +46,7 @@ bool PeerControl::Initialize() {
|
|||
}
|
||||
|
||||
webrtc::DataChannelInit init;
|
||||
const string data_channel_name = string("pc_data_") + remote_id_;
|
||||
const string data_channel_name = string("peer_data_") + remote_id_;
|
||||
if (!CreateDataChannel(data_channel_name, init)) {
|
||||
LOG_F(LS_ERROR) << "CreateDataChannel failed";
|
||||
DeletePeerConnection();
|
||||
|
|
@ -553,4 +553,4 @@ PeerDataChannelObserver::state() const {
|
|||
}
|
||||
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
24
src/peer.h
24
src/peer.h
|
|
@ -1,11 +1,11 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
||||
#ifndef __PEERCONNECT_PEER_H__
|
||||
#define __PEERCONNECT_PEER_H__
|
||||
#ifndef __PEERAPI_PEER_H__
|
||||
#define __PEERAPI_PEER_H__
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
#include "webrtc/base/json.h"
|
||||
#include "common.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
//
|
||||
// class PeerObserver
|
||||
|
|
@ -25,12 +25,12 @@ namespace pc {
|
|||
|
||||
class PeerObserver {
|
||||
public:
|
||||
virtual void SendCommand(const std::string& peer, const std::string& command, const Json::Value& data) = 0;
|
||||
virtual void ClosePeer(const std::string peer, const pc::CloseCode code, bool force_queuing = FORCE_QUEUING_OFF ) = 0;
|
||||
virtual void OnPeerConnect(const std::string peer) = 0;
|
||||
virtual void OnPeerClose(const std::string peer, const pc::CloseCode code) = 0;
|
||||
virtual void OnPeerMessage(const std::string& peer, const char* buffer, const size_t size) = 0;
|
||||
virtual void OnPeerWritable(const std::string& peer) = 0;
|
||||
virtual void SendCommand(const std::string& peer_id, const std::string& command, const Json::Value& data) = 0;
|
||||
virtual void ClosePeer(const std::string peer_id, const peerapi::CloseCode code, bool force_queuing = FORCE_QUEUING_OFF ) = 0;
|
||||
virtual void OnPeerConnect(const std::string peer_id) = 0;
|
||||
virtual void OnPeerClose(const std::string peer_id, const peerapi::CloseCode code) = 0;
|
||||
virtual void OnPeerMessage(const std::string& peer_id, const char* buffer, const size_t size) = 0;
|
||||
virtual void OnPeerWritable(const std::string& peer_id) = 0;
|
||||
};
|
||||
|
||||
class PeerDataChannelObserver;
|
||||
|
|
@ -184,6 +184,6 @@ private:
|
|||
std::mutex send_lock_;
|
||||
};
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_PEER_H__
|
||||
#endif // __PEERAPI_PEER_H__
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -11,49 +11,49 @@
|
|||
#include "control.h"
|
||||
#include "logging.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
PeerConnect::PeerConnect( const string peer ) {
|
||||
Peer::Peer( const string peer_id ) {
|
||||
// Log level
|
||||
#if DEBUG || _DEBUG
|
||||
rtc::LogMessage::LogToDebug( rtc::LS_NONE );
|
||||
pc::LogMessage::LogToDebug( pc::WARNING );
|
||||
peerapi::LogMessage::LogToDebug( peerapi::WARNING );
|
||||
#else
|
||||
rtc::LogMessage::LogToDebug( rtc::LS_NONE );
|
||||
pc::LogMessage::LogToDebug( pc::LS_NONE );
|
||||
peerapi::LogMessage::LogToDebug( peerapi::LS_NONE );
|
||||
#endif
|
||||
|
||||
string local_peer;
|
||||
string local_peer_id;
|
||||
|
||||
if ( peer.empty() ) {
|
||||
local_peer = rtc::CreateRandomUuid();
|
||||
if ( peer_id.empty() ) {
|
||||
local_peer_id = rtc::CreateRandomUuid();
|
||||
}
|
||||
else {
|
||||
local_peer = peer;
|
||||
local_peer_id = peer_id;
|
||||
}
|
||||
|
||||
peer_ = local_peer;
|
||||
peer_id_ = local_peer_id;
|
||||
close_once_ = false;
|
||||
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
PeerConnect::~PeerConnect() {
|
||||
Peer::~Peer() {
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerConnect::Run() {
|
||||
void Peer::Run() {
|
||||
rtc::ThreadManager::Instance()->CurrentThread()->Run();
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerConnect::Stop() {
|
||||
void Peer::Stop() {
|
||||
rtc::ThreadManager::Instance()->CurrentThread()->Quit();
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
||||
void PeerConnect::Open() {
|
||||
void Peer::Open() {
|
||||
|
||||
if ( control_.get() != nullptr ) {
|
||||
LOG_F( WARNING ) << "Already open.";
|
||||
|
|
@ -65,14 +65,14 @@ void PeerConnect::Open() {
|
|||
//
|
||||
|
||||
if ( signal_ == nullptr ) {
|
||||
signal_ = std::make_shared<pc::Signal>( setting_.signal_uri_ );
|
||||
signal_ = std::make_shared<peerapi::Signal>( setting_.signal_uri_ );
|
||||
}
|
||||
|
||||
//
|
||||
// Initialize control
|
||||
//
|
||||
|
||||
control_ = std::make_shared<pc::Control>( signal_ );
|
||||
control_ = std::make_shared<peerapi::Control>( signal_ );
|
||||
control_->RegisterObserver( this, control_ );
|
||||
|
||||
if ( control_.get() == NULL ) {
|
||||
|
|
@ -94,26 +94,26 @@ void PeerConnect::Open() {
|
|||
// Connect to signal server
|
||||
//
|
||||
|
||||
control_->Open( setting_.signal_id_, setting_.signal_password_, peer_ );
|
||||
control_->Open( setting_.signal_id_, setting_.signal_password_, peer_id_ );
|
||||
LOG_F( INFO ) << "Done";
|
||||
return;
|
||||
}
|
||||
|
||||
void PeerConnect::Close( const string peer ) {
|
||||
void Peer::Close( const string peer_id ) {
|
||||
|
||||
if ( peer.empty() || peer == peer_ ) {
|
||||
if ( peer_id.empty() || peer_id == peer_id_ ) {
|
||||
control_->Close( CLOSE_NORMAL, FORCE_QUEUING_ON );
|
||||
signal_->SyncClose();
|
||||
}
|
||||
else {
|
||||
control_->ClosePeer( peer, CLOSE_NORMAL, FORCE_QUEUING_ON );
|
||||
control_->ClosePeer( peer_id, CLOSE_NORMAL, FORCE_QUEUING_ON );
|
||||
}
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerConnect::Connect( const string peer ) {
|
||||
control_->Connect( peer );
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
void Peer::Connect( const string peer_id ) {
|
||||
control_->Connect( peer_id );
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ void PeerConnect::Connect( const string peer ) {
|
|||
// Send message to destination peer session id
|
||||
//
|
||||
|
||||
bool PeerConnect::Send( const string& peer, const char* data, const size_t size, const bool wait ) {
|
||||
bool Peer::Send( const string& peer_id, const char* data, const size_t size, const bool wait ) {
|
||||
if ( wait ) {
|
||||
|
||||
//
|
||||
|
|
@ -129,10 +129,10 @@ bool PeerConnect::Send( const string& peer, const char* data, const size_t size,
|
|||
// and a timeout is 60*1000 ms by default.
|
||||
//
|
||||
|
||||
return control_->SyncSend( peer, data, size );
|
||||
return control_->SyncSend( peer_id, data, size );
|
||||
}
|
||||
else {
|
||||
control_->Send( peer, data, size );
|
||||
control_->Send( peer_id, data, size );
|
||||
|
||||
//
|
||||
// Asyncronous send always returns true and
|
||||
|
|
@ -143,11 +143,11 @@ bool PeerConnect::Send( const string& peer, const char* data, const size_t size,
|
|||
}
|
||||
}
|
||||
|
||||
bool PeerConnect::Send( const string& peer, const string& message, const bool wait ) {
|
||||
return Send( peer, message.c_str(), message.size(), wait );
|
||||
bool Peer::Send( const string& peer_id, const string& message, const bool wait ) {
|
||||
return Send( peer_id, message.c_str(), message.size(), wait );
|
||||
}
|
||||
|
||||
bool PeerConnect::SetOptions( const string options ) {
|
||||
bool Peer::SetOptions( const string options ) {
|
||||
|
||||
// parse settings
|
||||
if ( !options.empty() ) {
|
||||
|
|
@ -157,14 +157,14 @@ bool PeerConnect::SetOptions( const string options ) {
|
|||
}
|
||||
|
||||
|
||||
std::string PeerConnect::CreateRandomUuid() {
|
||||
std::string Peer::CreateRandomUuid() {
|
||||
return rtc::CreateRandomUuid();
|
||||
}
|
||||
|
||||
//
|
||||
// Register Event handler
|
||||
//
|
||||
PeerConnect& PeerConnect::On( string event_id, std::function<void( string )> handler ) {
|
||||
Peer& Peer::On( string event_id, std::function<void( string )> handler ) {
|
||||
|
||||
if ( event_id.empty() ) return *this;
|
||||
|
||||
|
|
@ -179,7 +179,7 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string )> han
|
|||
return *this;
|
||||
}
|
||||
|
||||
PeerConnect& PeerConnect::On( string event_id, std::function<void( string, string )> handler ) {
|
||||
Peer& Peer::On( string event_id, std::function<void( string, string )> handler ) {
|
||||
|
||||
if ( event_id.empty() ) return *this;
|
||||
|
||||
|
|
@ -187,7 +187,7 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, strin
|
|||
return *this;
|
||||
}
|
||||
|
||||
PeerConnect& PeerConnect::On( string event_id, std::function<void( string, pc::CloseCode, string )> handler ) {
|
||||
Peer& Peer::On( string event_id, std::function<void( string, peerapi::CloseCode, string )> handler ) {
|
||||
if ( event_id.empty() ) return *this;
|
||||
|
||||
if ( event_id == "close" ) {
|
||||
|
|
@ -203,7 +203,7 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, pc::C
|
|||
return *this;
|
||||
}
|
||||
|
||||
PeerConnect& PeerConnect::On( string event_id, std::function<void( string, char*, std::size_t )> handler ) {
|
||||
Peer& Peer::On( string event_id, std::function<void( string, char*, std::size_t )> handler ) {
|
||||
if ( event_id.empty() ) return *this;
|
||||
|
||||
if ( event_id == "message" ) {
|
||||
|
|
@ -223,29 +223,29 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, char*
|
|||
// Signal event handler
|
||||
//
|
||||
|
||||
void PeerConnect::OnOpen( const string peer ) {
|
||||
void Peer::OnOpen( const string peer_id ) {
|
||||
close_once_ = false;
|
||||
|
||||
if ( event_handler_.find( "open" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "open", peer );
|
||||
CallEventHandler( "open", peer_id );
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerConnect::OnClose( const string peer, const CloseCode code, const string desc ) {
|
||||
void Peer::OnClose( const string peer_id, const CloseCode code, const string desc ) {
|
||||
|
||||
// This instance of PeerConnect and local peer is going to be closed
|
||||
if ( peer == peer_ ) {
|
||||
// This instance of Peer and local peer is going to be closed
|
||||
if ( peer_id == peer_id_ ) {
|
||||
if ( close_once_ ) {
|
||||
LOG_F( WARNING ) << "close_ is false, peer is " << peer;
|
||||
LOG_F( WARNING ) << "close_ is false, peer is " << peer_id;
|
||||
return;
|
||||
}
|
||||
|
||||
close_once_ = true;
|
||||
|
||||
if ( event_handler_.find( "close" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "close", peer, code, desc );
|
||||
CallEventHandler( "close", peer_id, code, desc );
|
||||
}
|
||||
|
||||
control_->UnregisterObserver();
|
||||
|
|
@ -254,38 +254,38 @@ void PeerConnect::OnClose( const string peer, const CloseCode code, const string
|
|||
// Remote peer has been closed
|
||||
else {
|
||||
if ( event_handler_.find( "close" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "close", peer, code, desc );
|
||||
CallEventHandler( "close", peer_id, code, desc );
|
||||
}
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
void PeerConnect::OnConnect( const string peer ) {
|
||||
void Peer::OnConnect( const string peer_id ) {
|
||||
if ( event_handler_.find( "connect" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "connect", peer );
|
||||
CallEventHandler( "connect", peer_id );
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
void PeerConnect::OnMessage( const string peer, const char* data, const size_t size ) {
|
||||
void Peer::OnMessage( const string peer_id, const char* data, const size_t size ) {
|
||||
if ( event_handler_.find( "message" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "message", peer, data, size );
|
||||
CallEventHandler( "message", peer_id, data, size );
|
||||
}
|
||||
}
|
||||
|
||||
void PeerConnect::OnWritable( const string peer ) {
|
||||
void Peer::OnWritable( const string peer_id ) {
|
||||
if ( event_handler_.find( "writable" ) != event_handler_.end() ) {
|
||||
CallEventHandler( "writable", peer );
|
||||
CallEventHandler( "writable", peer_id );
|
||||
}
|
||||
|
||||
LOG_F( INFO ) << "Done, peer is " << peer;
|
||||
LOG_F( INFO ) << "Done, peer is " << peer_id;
|
||||
}
|
||||
|
||||
|
||||
template<typename ...A>
|
||||
void PeerConnect::CallEventHandler( string msg_id, A&& ... args )
|
||||
void Peer::CallEventHandler( string msg_id, A&& ... args )
|
||||
{
|
||||
using eventhandler_t = EventHandler_t<A...>;
|
||||
using cb_t = std::function<void( A... )>;
|
||||
|
|
@ -295,7 +295,7 @@ void PeerConnect::CallEventHandler( string msg_id, A&& ... args )
|
|||
}
|
||||
|
||||
|
||||
bool PeerConnect::ParseOptions( const string& options ) {
|
||||
bool Peer::ParseOptions( const string& options ) {
|
||||
Json::Reader reader;
|
||||
Json::Value joptions;
|
||||
|
||||
|
|
@ -321,4 +321,4 @@ bool PeerConnect::ParseOptions( const string& options ) {
|
|||
return true;
|
||||
}
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
|
@ -1,11 +1,11 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
||||
#ifndef __PEERCONNECT_PEERCONNECT_H__
|
||||
#define __PEERCONNECT_PEERCONNECT_H__
|
||||
#ifndef __PEERAPI_PEERCONNECT_H__
|
||||
#define __PEERAPI_PEERCONNECT_H__
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
|
|
@ -15,17 +15,17 @@
|
|||
#include "common.h"
|
||||
#include "controlobserver.h"
|
||||
|
||||
#ifndef USE_PEERCONNECT_STRICT_NAMESPACE
|
||||
using namespace pc;
|
||||
#endif // USE_PEERCONNECT_STRICT_NAMESPACE
|
||||
#ifndef USE_PEERAPI_STRICT_NAMESPACE
|
||||
using namespace peerapi;
|
||||
#endif // USE_PEERAPI_STRICT_NAMESPACE
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
class Control;
|
||||
class Signal;
|
||||
|
||||
|
||||
class PeerConnect
|
||||
class Peer
|
||||
: public ControlObserver {
|
||||
public:
|
||||
|
||||
|
|
@ -46,23 +46,23 @@ public:
|
|||
static void Stop();
|
||||
|
||||
void Open();
|
||||
void Close( const string peer = "" );
|
||||
void Connect( const string peer );
|
||||
bool Send( const string& peer, const char* data, const std::size_t size, const bool wait = SYNC_OFF );
|
||||
bool Send( const string& peer, const string& data, const bool wait = SYNC_OFF );
|
||||
void Close( const string peer_id = "" );
|
||||
void Connect( const string peer_id );
|
||||
bool Send( const string& peer_id, const char* data, const std::size_t size, const bool wait = SYNC_OFF );
|
||||
bool Send( const string& peer_id, const string& data, const bool wait = SYNC_OFF );
|
||||
bool SetOptions( const string options );
|
||||
|
||||
PeerConnect& On( string event_id, std::function<void( string )> );
|
||||
PeerConnect& On( string event_id, std::function<void( string, string )> );
|
||||
PeerConnect& On( string event_id, std::function<void( string, pc::CloseCode, string )> );
|
||||
PeerConnect& On( string event_id, std::function<void( string, char*, std::size_t )> );
|
||||
Peer& On( string event_id, std::function<void( string )> );
|
||||
Peer& On( string event_id, std::function<void( string, string )> );
|
||||
Peer& On( string event_id, std::function<void( string, peerapi::CloseCode, string )> );
|
||||
Peer& On( string event_id, std::function<void( string, char*, std::size_t )> );
|
||||
|
||||
//
|
||||
// Member functions
|
||||
//
|
||||
|
||||
explicit PeerConnect( const string peer = "" );
|
||||
~PeerConnect();
|
||||
explicit Peer( const string peer_id = "" );
|
||||
~Peer();
|
||||
|
||||
static std::string CreateRandomUuid();
|
||||
|
||||
|
|
@ -87,7 +87,7 @@ protected:
|
|||
using EventHandler_1 = EventHandler_t<>;
|
||||
using EventHandler_2 = EventHandler_t<string>;
|
||||
using EventHandler_3 = EventHandler_t<string, Data&>;
|
||||
using EventHandler_Close = EventHandler_t<string, pc::CloseCode, string>;
|
||||
using EventHandler_Close = EventHandler_t<string, peerapi::CloseCode, string>;
|
||||
using EventHandler_Message = EventHandler_t<string, char*, std::size_t>;
|
||||
using Events = std::map<string, std::unique_ptr<Handler_t>>;
|
||||
|
||||
|
|
@ -95,11 +95,11 @@ protected:
|
|||
// ControlObserver implementation
|
||||
//
|
||||
|
||||
void OnOpen( const string peer );
|
||||
void OnClose( const string peer, const pc::CloseCode code, const string desc = "" );
|
||||
void OnConnect( const string peer );
|
||||
void OnMessage( const string peer, const char* data, const size_t size );
|
||||
void OnWritable( const string peer );
|
||||
void OnOpen( const string peer_id );
|
||||
void OnClose( const string peer_id, const peerapi::CloseCode code, const string desc = "" );
|
||||
void OnConnect( const string peer_id );
|
||||
void OnMessage( const string peer_id, const char* data, const size_t size );
|
||||
void OnWritable( const string peer_id );
|
||||
|
||||
bool ParseOptions( const string& options );
|
||||
|
||||
|
|
@ -110,10 +110,10 @@ protected:
|
|||
std::shared_ptr<Control> control_;
|
||||
std::shared_ptr<Signal> signal_;
|
||||
|
||||
string peer_;
|
||||
string peer_id_;
|
||||
};
|
||||
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_PEERCONNECT_H__
|
||||
#endif // __PEERAPI_PEERCONNECT_H__
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -13,7 +13,7 @@
|
|||
#include "signalconnection.h"
|
||||
#include "logging.h"
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
Signal::Signal(const string url) :
|
||||
con_state_(con_closed),
|
||||
|
|
@ -417,4 +417,4 @@ Signal::context_ptr Signal::OnTlsInit(websocketpp::connection_hdl conn)
|
|||
}
|
||||
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -30,8 +30,8 @@
|
|||
*/
|
||||
|
||||
|
||||
#ifndef __PEERCONNECT_SIGNAL_H__
|
||||
#define __PEERCONNECT_SIGNAL_H__
|
||||
#ifndef __PEERAPI_SIGNAL_H__
|
||||
#define __PEERAPI_SIGNAL_H__
|
||||
|
||||
#include <string>
|
||||
|
||||
|
|
@ -48,7 +48,7 @@
|
|||
#include "webrtc/base/json.h"
|
||||
|
||||
|
||||
namespace pc {
|
||||
namespace peerapi {
|
||||
|
||||
class SignalInterface {
|
||||
public:
|
||||
|
|
@ -158,6 +158,6 @@ private:
|
|||
}; // class Signal
|
||||
|
||||
|
||||
} // namespace pc
|
||||
} // namespace peerapi
|
||||
|
||||
#endif // __PEERCONNECT_SIGNAL_H__
|
||||
#endif // __PEERAPI_SIGNAL_H__
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
|
||||
* Copyright 2016 The PeerApi Project Authors. All rights reserved.
|
||||
*
|
||||
* Ryan Lee
|
||||
*/
|
||||
|
|
@ -30,159 +30,159 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
void test_normal() {
|
||||
|
||||
std::string server = PeerConnect::CreateRandomUuid();
|
||||
std::string client = PeerConnect::CreateRandomUuid();
|
||||
std::string server_id = Peer::CreateRandomUuid();
|
||||
std::string client_id = Peer::CreateRandomUuid();
|
||||
|
||||
PeerConnect pc1(server);
|
||||
PeerConnect pc2(client);
|
||||
Peer peer1(server_id);
|
||||
Peer peer2(client_id);
|
||||
|
||||
pc1.On("open", function_pc( string peer ) {
|
||||
assert(peer == server);
|
||||
std::cout << "pc1: open" << std::endl;
|
||||
pc2.Open();
|
||||
peer1.On("open", function_peer( string peer_id ) {
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer1: open" << std::endl;
|
||||
peer2.Open();
|
||||
});
|
||||
|
||||
pc1.On("connect", function_pc( string peer ) {
|
||||
assert(peer == client);
|
||||
std::cout << "pc1: pc2(" << peer << ") connected" << std::endl;
|
||||
peer1.On("connect", function_peer( string peer_id ) {
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer1: peer2(" <<peer_id << ") connected" << std::endl;
|
||||
});
|
||||
|
||||
pc1.On("close", function_pc( string peer, CloseCode code, string desc ) {
|
||||
assert(peer == client || peer == server);
|
||||
if ( peer == client ) {
|
||||
std::cout << "pc1: pc2 disconnected" << std::endl;
|
||||
peer1.On("close", function_peer( string peer_id, CloseCode code, string desc ) {
|
||||
assert(peer_id == client_id || peer_id == server_id);
|
||||
if ( peer_id == client_id ) {
|
||||
std::cout << "peer1: peer2 disconnected" << std::endl;
|
||||
}
|
||||
else if ( peer == server ) {
|
||||
std::cout << "pc1: close out" << std::endl;
|
||||
pc2.Close();
|
||||
else if ( peer_id == server_id ) {
|
||||
std::cout << "peer1: close out" << std::endl;
|
||||
peer2.Close();
|
||||
}
|
||||
});
|
||||
|
||||
pc1.On("message", function_pc( string peer, char* data, size_t size ) {
|
||||
peer1.On("message", function_peer( string peer_id, char* data, size_t size ) {
|
||||
assert(std::string(data, size) == "Ping");
|
||||
assert(peer == client);
|
||||
std::cout << "pc1: a message has been received" << std::endl;
|
||||
pc1.Send(client, "Pong");
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer1: a message has been received" << std::endl;
|
||||
peer1.Send(client_id, "Pong");
|
||||
});
|
||||
|
||||
|
||||
pc2.On("open", function_pc( string peer ) {
|
||||
assert(peer == client);
|
||||
std::cout << "pc2: open" << std::endl;
|
||||
pc2.Connect(server);
|
||||
peer2.On("open", function_peer( string peer_id ) {
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer2: open" << std::endl;
|
||||
peer2.Connect(server_id);
|
||||
});
|
||||
|
||||
pc2.On("connect", function_pc( string peer ) {
|
||||
assert(peer == server);
|
||||
std::cout << "pc2: pc1(" << peer << ") connected" << std::endl;
|
||||
pc2.Send(server, "Ping");
|
||||
peer2.On("connect", function_peer( string peer_id ) {
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer2: peer1(" << peer_id << ") connected" << std::endl;
|
||||
peer2.Send(server_id, "Ping");
|
||||
});
|
||||
|
||||
pc2.On("close", function_pc( string peer, CloseCode code, string desc ) {
|
||||
assert( peer == server || peer == client );
|
||||
if ( peer == server ) {
|
||||
std::cout << "pc2: pc1 disconnected" << std::endl;
|
||||
pc1.Close();
|
||||
peer2.On("close", function_peer( string peer_id, CloseCode code, string desc ) {
|
||||
assert( peer_id == server_id || peer_id == client_id );
|
||||
if ( peer_id == server_id ) {
|
||||
std::cout << "peer2: peer1 disconnected" << std::endl;
|
||||
peer1.Close();
|
||||
}
|
||||
else if ( peer == client ) {
|
||||
std::cout << "pc2: close out" << std::endl;
|
||||
PeerConnect::Stop();
|
||||
else if ( peer_id == client_id ) {
|
||||
std::cout << "peer2: close out" << std::endl;
|
||||
Peer::Stop();
|
||||
}
|
||||
});
|
||||
|
||||
pc2.On("message", function_pc( string peer, char* data, size_t size ) {
|
||||
peer2.On("message", function_peer( string peer_id, char* data, size_t size ) {
|
||||
assert(std::string(data, size) == "Pong");
|
||||
assert(peer == server);
|
||||
std::cout << "pc2 has received message" << std::endl;
|
||||
pc2.Close(server);
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer2 has received message" << std::endl;
|
||||
peer2.Close(server_id);
|
||||
});
|
||||
|
||||
pc1.Open();
|
||||
PeerConnect::Run();
|
||||
peer1.Open();
|
||||
Peer::Run();
|
||||
}
|
||||
|
||||
|
||||
void test_writable() {
|
||||
|
||||
std::string server = PeerConnect::CreateRandomUuid();
|
||||
std::string client = PeerConnect::CreateRandomUuid();
|
||||
std::string server_id = Peer::CreateRandomUuid();
|
||||
std::string client_id = Peer::CreateRandomUuid();
|
||||
|
||||
PeerConnect pc1(server);
|
||||
PeerConnect pc2(client);
|
||||
Peer peer1(server_id);
|
||||
Peer peer2(client_id);
|
||||
|
||||
pc1.On("open", function_pc( string peer ) {
|
||||
assert(peer == server);
|
||||
std::cout << "pc1: open" << std::endl;
|
||||
pc2.Open();
|
||||
peer1.On("open", function_peer( string peer_id ) {
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer1: open" << std::endl;
|
||||
peer2.Open();
|
||||
});
|
||||
|
||||
pc1.On("connect", function_pc( string peer ) {
|
||||
assert(peer == client);
|
||||
std::cout << "pc1: pc2(" << peer << ") connected" << std::endl;
|
||||
peer1.On("connect", function_peer( string peer_id ) {
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer1: peer2(" << peer_id << ") connected" << std::endl;
|
||||
});
|
||||
|
||||
pc1.On("close", function_pc( string peer, CloseCode code, string desc ) {
|
||||
assert( peer == client || peer == server );
|
||||
if ( peer == client ) {
|
||||
std::cout << "pc1: pc2 disconnected" << std::endl;
|
||||
peer1.On("close", function_peer( string peer_id, CloseCode code, string desc ) {
|
||||
assert( peer_id == client_id || peer_id == server_id );
|
||||
if ( peer_id == client_id ) {
|
||||
std::cout << "peer1: peer2 disconnected" << std::endl;
|
||||
}
|
||||
else if ( peer == server ) {
|
||||
std::cout << "pc1: close" << std::endl;
|
||||
pc2.Close();
|
||||
else if ( peer_id == server_id ) {
|
||||
std::cout << "peer1: close" << std::endl;
|
||||
peer2.Close();
|
||||
}
|
||||
});
|
||||
|
||||
pc1.On("writable", function_pc( string peer ){
|
||||
assert(peer == server);
|
||||
std::cout << "pc1: writable" << std::endl;
|
||||
peer1.On("writable", function_peer( string peer_id ){
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer1: writable" << std::endl;
|
||||
});
|
||||
|
||||
pc1.On("message", function_pc( string peer, char* data, size_t size ) {
|
||||
peer1.On("message", function_peer( string peer_id, char* data, size_t size ) {
|
||||
assert(std::string(data, size) == "Ping");
|
||||
assert(peer == client);
|
||||
std::cout << "pc1: a message has been received" << std::endl;
|
||||
pc1.Send(client, "Pong");
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer1: a message has been received" << std::endl;
|
||||
peer1.Send(client_id, "Pong");
|
||||
});
|
||||
|
||||
|
||||
pc2.On("open", function_pc( string peer ) {
|
||||
assert(peer == client);
|
||||
std::cout << "pc2: open" << std::endl;
|
||||
pc2.Connect(server);
|
||||
peer2.On("open", function_peer( string peer_id ) {
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer2: open" << std::endl;
|
||||
peer2.Connect(server_id);
|
||||
});
|
||||
|
||||
pc2.On("connect", function_pc( string peer ) {
|
||||
assert( peer == server );
|
||||
std::cout << "pc2: pc1(" << peer << ") connected" << std::endl;
|
||||
peer2.On("connect", function_peer( string peer_id ) {
|
||||
assert( peer_id == server_id );
|
||||
std::cout << "peer2: peer1(" << peer_id << ") connected" << std::endl;
|
||||
});
|
||||
|
||||
pc2.On("close", function_pc( string peer, CloseCode code, string desc ) {
|
||||
assert( peer == server || peer == client);
|
||||
if ( peer == server ) {
|
||||
std::cout << "pc2: pc1 disconnected" << std::endl;
|
||||
pc1.Close();
|
||||
peer2.On("close", function_peer( string peer_id, CloseCode code, string desc ) {
|
||||
assert( peer_id == server_id || peer_id == client_id);
|
||||
if ( peer_id == server_id ) {
|
||||
std::cout << "peer2: peer1 disconnected" << std::endl;
|
||||
peer1.Close();
|
||||
}
|
||||
else if ( peer == client ) {
|
||||
std::cout << "pc2: close" << std::endl;
|
||||
PeerConnect::Stop();
|
||||
else if ( peer_id == client_id ) {
|
||||
std::cout << "peer2: close" << std::endl;
|
||||
Peer::Stop();
|
||||
}
|
||||
});
|
||||
|
||||
pc2.On("writable", function_pc( string peer ){
|
||||
assert(peer == client);
|
||||
std::cout << "pc2: writable" << std::endl;
|
||||
pc2.Send(server, "Ping");
|
||||
peer2.On("writable", function_peer( string peer_id ){
|
||||
assert(peer_id == client_id);
|
||||
std::cout << "peer2: writable" << std::endl;
|
||||
peer2.Send(server_id, "Ping");
|
||||
});
|
||||
|
||||
pc2.On("message", function_pc( string peer, char* data, size_t size ) {
|
||||
peer2.On("message", function_peer( string peer_id, char* data, size_t size ) {
|
||||
assert(std::string(data, size) == "Pong");
|
||||
assert(peer == server);
|
||||
std::cout << "pc2 has received message" << std::endl;
|
||||
pc2.Close(server);
|
||||
assert(peer_id == server_id);
|
||||
std::cout << "peer2 has received message" << std::endl;
|
||||
peer2.Close(server_id);
|
||||
});
|
||||
|
||||
pc1.Open();
|
||||
PeerConnect::Run();
|
||||
peer1.Open();
|
||||
Peer::Run();
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue