Refactor connection closing logic and removing unnecessary codes
Ryan Lee
parent
acad86321d
commit
70cc9f6bd6
234
src/control.cc
234
src/control.cc
|
|
@ -83,7 +83,6 @@ void Control::DeleteControl() {
|
|||
}
|
||||
|
||||
|
||||
|
||||
void Control::SignIn(const std::string& user_id, const std::string& user_password, const std::string& open_id) {
|
||||
// 1. Connect to signal server
|
||||
// 2. Send signin command to signal server
|
||||
|
|
@ -115,7 +114,7 @@ void Control::SignOut() {
|
|||
}
|
||||
|
||||
signal_->SignOut();
|
||||
DisconnectAll();
|
||||
Close();
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
|
@ -124,7 +123,7 @@ void Control::Connect(const std::string id) {
|
|||
// 1. Join channel on signal server
|
||||
// 2. Server(remote) peer createoffer
|
||||
// 3. Client(local) peer answeroffer
|
||||
// 4. Conect datachannel
|
||||
// 4. Connect datachannel
|
||||
|
||||
if (signal_.get() == NULL) {
|
||||
LOGP_F(LERROR) << "Join failed, no signal server";
|
||||
|
|
@ -135,33 +134,58 @@ void Control::Connect(const std::string id) {
|
|||
JoinChannel(id);
|
||||
}
|
||||
|
||||
void Control::Disconnect(const std::string id) {
|
||||
// 1. Leave channel on signal server
|
||||
// 2. Close remote data channel
|
||||
// 3. Close local data channel
|
||||
// 4. Close ice connection
|
||||
// 5. Erase peer
|
||||
void Control::Close(const std::string id, bool force_queuing) {
|
||||
|
||||
LOGP_F( INFO ) << "Queue peer disconnect " << id;
|
||||
QueuePeerDisconnect(id);
|
||||
//
|
||||
// Called by
|
||||
// PeerConnect 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(id, ref_);
|
||||
webrtc_thread_->Post(this, MSG_CLOSE_PEER, data);
|
||||
return;
|
||||
}
|
||||
|
||||
// 1. Leave channel on signal server
|
||||
// 2. Erase peer
|
||||
// 3. Close peer
|
||||
|
||||
LeaveChannel(id);
|
||||
|
||||
auto peer_found = peers_.find(id);
|
||||
if ( peer_found == peers_.end() ) {
|
||||
LOGP_F( WARNING ) << "peer not found, " << id;
|
||||
return;
|
||||
}
|
||||
|
||||
Peer peer = peer_found->second;
|
||||
peers_.erase( peer_found );
|
||||
peer->Close();
|
||||
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
}
|
||||
|
||||
void Control::DisconnectAll() {
|
||||
void Control::Close( const std::string id ) {
|
||||
Close( id, QUEUEING_ON );
|
||||
}
|
||||
|
||||
void Control::Close() {
|
||||
std::vector<std::string> peer_ids;
|
||||
|
||||
for (auto peer : peers_) {
|
||||
peer_ids.push_back(peer.second->remote_id());
|
||||
}
|
||||
|
||||
LOGP_F(INFO) << "DisconnectAll(): peer count is " << peer_ids.size();
|
||||
LOGP_F(INFO) << "Close(): peer count is " << peer_ids.size();
|
||||
|
||||
for (auto id : peer_ids) {
|
||||
LOGP_F( INFO ) << "Try to disconnect peer having id " << id;
|
||||
Disconnect(id);
|
||||
LOGP_F( INFO ) << "Try to close peer having id " << id;
|
||||
Close(id, QUEUEING_ON);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Send data to peer
|
||||
//
|
||||
|
|
@ -197,32 +221,7 @@ void Control::SendCommand(const std::string& id, const std::string& command, con
|
|||
}
|
||||
|
||||
|
||||
|
||||
void Control::QueuePeerDisconnect(const std::string id) {
|
||||
|
||||
ControlMessageData *data = new ControlMessageData(id, ref_);
|
||||
|
||||
// 1. Leave channel on signal server
|
||||
LeaveChannel(id);
|
||||
|
||||
// 2. Close remote data channel
|
||||
// 3. Close local data channel
|
||||
// 4. Close ice connection
|
||||
// 5. Erase peer
|
||||
webrtc_thread_->Post(this, MSG_DISCONNECT_PEER, data);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Both peer local and remote data channel has been opened.
|
||||
// It means that ice connection had been opened already and
|
||||
// now we can send and receive data from/to data channel.
|
||||
//
|
||||
// Implements PeerObserver::OnPeerConnected()
|
||||
//
|
||||
|
||||
void Control::OnPeerConnected(const std::string id) {
|
||||
void Control::OnConnected(const std::string id) {
|
||||
if ( observer_ == nullptr ) {
|
||||
LOGP_F( WARNING ) << "observer_ is null, id is " << id;
|
||||
return;
|
||||
|
|
@ -239,73 +238,36 @@ void Control::OnPeerConnected(const std::string id) {
|
|||
// Implements PeerObserver::OnDisconnected()
|
||||
//
|
||||
|
||||
void Control::OnPeerDisconnected(const std::string id) {
|
||||
void Control::OnClosed(const std::string id, const bool force_queuing) {
|
||||
|
||||
if (force_queuing || webrtc_thread_ != rtc::Thread::Current()) {
|
||||
ControlMessageData *data = new ControlMessageData(id, ref_);
|
||||
|
||||
// Call Control::OnPeerDisconnected()
|
||||
webrtc_thread_->Post(this, MSG_ON_PEER_CLOSED, data);
|
||||
LOGP_F( INFO ) << "Queued, id is " << id;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if ( observer_ == nullptr ) {
|
||||
LOGP_F( WARNING ) << "observer_ is null, id is " << id;
|
||||
return;
|
||||
}
|
||||
|
||||
bool erased;
|
||||
std::map<std::string, Peer>::iterator it;
|
||||
LOGP_F( INFO ) << "Calling OnPeerDisconnected, id is " << id;
|
||||
observer_->OnPeerDisconnected(id);
|
||||
|
||||
for (it = peers_.begin(); it != peers_.end(); ) {
|
||||
if (it->second->remote_id() == id) {
|
||||
erased = true;
|
||||
peers_.erase(it++);
|
||||
}
|
||||
else {
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
if (erased) {
|
||||
LOGP_F( INFO ) << "Calling OnPeerDisconnected, id is " << id;
|
||||
observer_->OnPeerDisconnected(id);
|
||||
if (peers_.size() == 0) {
|
||||
LOGP_F( INFO ) << "peers_ has been empty. id is " << id;
|
||||
OnSignedOut(open_id_);
|
||||
}
|
||||
if (peers_.size() == 0) {
|
||||
LOGP_F( INFO ) << "peers_ has been empty. id is " << id;
|
||||
OnSignedOut(open_id_);
|
||||
}
|
||||
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
}
|
||||
|
||||
void Control::QueueOnPeerDisconnected(const std::string id) {
|
||||
ControlMessageData *data = new ControlMessageData(id, ref_);
|
||||
|
||||
// Call Control::OnPeerDisconnected()
|
||||
webrtc_thread_->Post(this, MSG_ON_PEER_DISCONNECTED, data);
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
|
||||
}
|
||||
|
||||
|
||||
void Control::OnPeerChannelClosed(const std::string id) {
|
||||
auto peer = peers_.find(id);
|
||||
if ( peer == peers_.end() ) {
|
||||
LOGP_F( WARNING ) << "Peer not found, id is " << id;
|
||||
return;
|
||||
}
|
||||
|
||||
peer->second->ClosePeerConnection();
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
}
|
||||
|
||||
void Control::QueueOnPeerChannelClosed(const std::string id, int delay) {
|
||||
|
||||
LOGP_F( INFO ) << "id is " << id << " and delay is " << delay;
|
||||
|
||||
// close_peerconnection
|
||||
ControlMessageData *data = new ControlMessageData(id, ref_);
|
||||
|
||||
// Call Control::OnPeerDisconnected()
|
||||
if (delay==0)
|
||||
webrtc_thread_->Post(this, MSG_ON_PEER_CHANNEL_CLOSED, data);
|
||||
else
|
||||
webrtc_thread_->PostDelayed(delay, this, MSG_ON_PEER_CHANNEL_CLOSED, data);
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
void Control::OnClosed(const std::string id) {
|
||||
OnClosed( id, QUEUEING_ON );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -313,7 +275,7 @@ void Control::QueueOnPeerChannelClosed(const std::string id, int delay) {
|
|||
// Signal receiving data
|
||||
//
|
||||
|
||||
void Control::OnPeerMessage(const std::string& id, const char* buffer, const size_t size) {
|
||||
void Control::OnMessage(const std::string& id, const char* buffer, const size_t size) {
|
||||
if ( observer_ == nullptr ) {
|
||||
LOGP_F( WARNING ) << "observer_ is null, id is " << id;
|
||||
return;
|
||||
|
|
@ -321,7 +283,7 @@ void Control::OnPeerMessage(const std::string& id, const char* buffer, const siz
|
|||
observer_->OnPeerMessage(id, buffer, size);
|
||||
}
|
||||
|
||||
void Control::OnPeerWritable(const std::string& id) {
|
||||
void Control::OnWritable(const std::string& id) {
|
||||
if ( observer_ == nullptr ) {
|
||||
LOGP_F( WARNING ) << "observer_ is null, id is " << id;
|
||||
return;
|
||||
|
|
@ -329,6 +291,14 @@ void Control::OnPeerWritable(const std::string& id) {
|
|||
observer_->OnPeerWritable(id);
|
||||
}
|
||||
|
||||
void Control::OnError( const std::string id, const std::string& reason ) {
|
||||
if ( observer_ == nullptr ) {
|
||||
LOGP_F( WARNING ) << "observer_ is null, id is " << id;
|
||||
return;
|
||||
}
|
||||
observer_->OnError( id, reason );
|
||||
}
|
||||
|
||||
|
||||
void Control::RegisterObserver(ControlObserver* observer, std::shared_ptr<Control> ref) {
|
||||
ref_ = ref;
|
||||
|
|
@ -355,21 +325,13 @@ void Control::OnMessage(rtc::Message* msg) {
|
|||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
OnCommandReceived(param->data_json_);
|
||||
break;
|
||||
case MSG_DISCONNECT:
|
||||
case MSG_CLOSE_PEER:
|
||||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
Disconnect(param->data_string_);
|
||||
Close(param->data_string_, QUEUEING_OFF);
|
||||
break;
|
||||
case MSG_DISCONNECT_PEER:
|
||||
case MSG_ON_PEER_CLOSED:
|
||||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
DisconnectPeer(param->data_string_);
|
||||
break;
|
||||
case MSG_ON_PEER_DISCONNECTED:
|
||||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
OnPeerDisconnected(param->data_string_);
|
||||
break;
|
||||
case MSG_ON_PEER_CHANNEL_CLOSED:
|
||||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
OnPeerChannelClosed(param->data_string_);
|
||||
OnClosed(param->data_string_, QUEUEING_OFF);
|
||||
break;
|
||||
case MSG_SIGNOUT:
|
||||
param = static_cast<ControlMessageData*>(msg->pdata);
|
||||
|
|
@ -432,9 +394,6 @@ void Control::OnCommandReceived(const Json::Value& message) {
|
|||
else if (command == "ice_candidate") {
|
||||
AddIceCandidate(peer_id, data);
|
||||
}
|
||||
else if (command == "close_peerconnection") {
|
||||
ClosePeerConnection(peer_id, data);
|
||||
}
|
||||
}
|
||||
|
||||
void Control::OnSignalCommandReceived(const Json::Value& message) {
|
||||
|
|
@ -685,8 +644,13 @@ void Control::CreateOffer(const Json::Value& data) {
|
|||
}
|
||||
|
||||
Peer peer = new rtc::RefCountedObject<PeerControl>(open_id_, remote_id, this, peer_connection_factory_);
|
||||
peers_.insert(std::pair<std::string, Peer>(remote_id, peer));
|
||||
if ( !peer->Initialize() ) {
|
||||
LOGP_F( LERROR ) << "Peer initialization failed";
|
||||
OnClosed( remote_id );
|
||||
return;
|
||||
}
|
||||
|
||||
peers_.insert(std::pair<std::string, Peer>(remote_id, peer));
|
||||
peer->CreateOffer(NULL);
|
||||
}
|
||||
|
||||
|
|
@ -707,9 +671,15 @@ void Control::ReceiveOfferSdp(const std::string& peer_id, const Json::Value& dat
|
|||
}
|
||||
|
||||
Peer peer = new rtc::RefCountedObject<PeerControl>(open_id_, peer_id, this, peer_connection_factory_);
|
||||
peers_.insert(std::pair<std::string, Peer>(peer_id, peer));
|
||||
if ( !peer->Initialize() ) {
|
||||
LOGP_F( LERROR ) << "Peer initialization failed";
|
||||
OnClosed( peer_id );
|
||||
return;
|
||||
}
|
||||
|
||||
peers_.insert(std::pair<std::string, Peer>(peer_id, peer));
|
||||
peer->ReceiveOfferSdp(sdp);
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
|
@ -738,36 +708,4 @@ void Control::ReceiveAnswerSdp(const std::string& peer_id, const Json::Value& da
|
|||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void Control::ClosePeerConnection(const std::string& peer_id, const Json::Value& data) {
|
||||
auto peer = peers_.find(peer_id);
|
||||
if ( peer == peers_.end() ) {
|
||||
LOGP_F( LERROR ) << "peer_id not found, peer_id is " << peer_id << " and " <<
|
||||
"data is " << data.toStyledString();
|
||||
return;
|
||||
}
|
||||
|
||||
peers_[peer_id]->ClosePeerConnection();
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
||||
|
||||
void Control::DisconnectPeer(const std::string id) {
|
||||
// 1. Close remote data channel (remote_data_channel_)
|
||||
// 2. Close local data channel (local_data_channel_)
|
||||
// 3. Close ice connection (peer_connection_)
|
||||
// 4. Erase peer
|
||||
|
||||
auto peer = peers_.find(id);
|
||||
if ( peer == peers_.end() ) {
|
||||
LOGP_F( WARNING ) << "peer not found, " << id;
|
||||
return;
|
||||
}
|
||||
|
||||
peer->second->Close();
|
||||
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
}
|
||||
|
||||
|
||||
} // namespace pc
|
||||
|
|
|
|||
|
|
@ -48,8 +48,7 @@ public:
|
|||
void SignIn(const std::string& user_id, const std::string& user_password, const std::string& open_id);
|
||||
void SignOut();
|
||||
void Connect(const std::string id);
|
||||
void Disconnect(const std::string id);
|
||||
void DisconnectAll();
|
||||
void Close();
|
||||
bool IsWritable(const std::string id);
|
||||
|
||||
void OnCommandReceived(const Json::Value& message);
|
||||
|
|
@ -62,14 +61,13 @@ public:
|
|||
//
|
||||
|
||||
virtual void SendCommand(const std::string& id, const std::string& command, const Json::Value& data);
|
||||
virtual void OnPeerConnected(const std::string id);
|
||||
virtual void QueuePeerDisconnect(const std::string id);
|
||||
virtual void QueueOnPeerDisconnected(const std::string id);
|
||||
virtual void OnPeerDisconnected(const std::string id);
|
||||
virtual void QueueOnPeerChannelClosed(const std::string id, int delay);
|
||||
virtual void OnPeerChannelClosed(const std::string id);
|
||||
virtual void OnPeerMessage(const std::string& id, const char* buffer, const size_t size);
|
||||
virtual void OnPeerWritable(const std::string& id);
|
||||
virtual void Close(const std::string id);
|
||||
virtual void OnConnected(const std::string id);
|
||||
virtual void OnClosed(const std::string id);
|
||||
virtual void OnMessage(const std::string& id, const char* buffer, const size_t size);
|
||||
virtual void OnWritable(const std::string& id);
|
||||
virtual void OnError( const std::string id, const std::string& reason );
|
||||
|
||||
|
||||
// Register/Unregister observer
|
||||
void RegisterObserver(ControlObserver* observer, std::shared_ptr<Control> ref);
|
||||
|
|
@ -87,14 +85,16 @@ protected:
|
|||
void AddIceCandidate(const std::string& peer_id, const Json::Value& data);
|
||||
void ReceiveOfferSdp(const std::string& peer_id, const Json::Value& data);
|
||||
void ReceiveAnswerSdp(const std::string& peer_id, const Json::Value& data);
|
||||
void ClosePeerConnection(const std::string& peer_id, const Json::Value& data);
|
||||
void DisconnectPeer(const std::string id);
|
||||
|
||||
void OnSignedIn(const Json::Value& data);
|
||||
void OnChannelCreated(const Json::Value& data);
|
||||
void OnChannelJoined(const Json::Value& data);
|
||||
void OnChannelLeaved(const Json::Value& data);
|
||||
|
||||
void Close( const std::string id, const bool force_queuing);
|
||||
void OnClosed(const std::string id, const bool force_queuing);
|
||||
|
||||
|
||||
// open_id_: other peers can find this peer by open_id_ and it is user_id or alias
|
||||
// user_id_: A user id to sign in signal server (could be 'anonymous' for guest user)
|
||||
// session_id_: A unique id for signal server connection
|
||||
|
|
@ -113,12 +113,14 @@ protected:
|
|||
|
||||
private:
|
||||
|
||||
const bool QUEUEING_ON = true;
|
||||
const bool QUEUEING_OFF = false;
|
||||
|
||||
|
||||
enum {
|
||||
MSG_COMMAND_RECEIVED, // Command has been received from signal server
|
||||
MSG_DISCONNECT, // Queue disconnection request (+subsequent peer disconnection)
|
||||
MSG_DISCONNECT_PEER, // Queue peer disconnection request
|
||||
MSG_ON_PEER_DISCONNECTED, // Queue onpeerdisconnected event
|
||||
MSG_ON_PEER_CHANNEL_CLOSED, // Queue onchanneldisconnected event
|
||||
MSG_CLOSE_PEER, // Close peer
|
||||
MSG_ON_PEER_CLOSED, // Peer has been closed
|
||||
MSG_SIGNOUT, // Queue signout request
|
||||
MSG_SIGNAL_SERVER_CLOSED // Connection to signal server has been closed
|
||||
};
|
||||
|
|
|
|||
191
src/peer.cc
191
src/peer.cc
|
|
@ -24,24 +24,10 @@ PeerControl::PeerControl(const std::string local_id,
|
|||
peer_connection_factory)
|
||||
: local_id_(local_id),
|
||||
remote_id_(remote_id),
|
||||
observer_(observer),
|
||||
control_(observer),
|
||||
peer_connection_factory_(peer_connection_factory),
|
||||
state_(pClosed)
|
||||
{
|
||||
state_(pClosed) {
|
||||
|
||||
if (!CreatePeerConnection()) {
|
||||
LOGP_F(LS_ERROR) << "CreatePeerConnection failed";
|
||||
DeletePeerConnection();
|
||||
}
|
||||
|
||||
webrtc::DataChannelInit init;
|
||||
const std::string data_channel_name = std::string("pc_data_") + remote_id_;
|
||||
if (!CreateDataChannel(data_channel_name, init)) {
|
||||
LOGP_F(LS_ERROR) << "CreateDataChannel failed";
|
||||
DeletePeerConnection();
|
||||
}
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
PeerControl::~PeerControl() {
|
||||
|
|
@ -51,36 +37,84 @@ PeerControl::~PeerControl() {
|
|||
}
|
||||
|
||||
|
||||
bool PeerControl::Initialize() {
|
||||
|
||||
if (!CreatePeerConnection()) {
|
||||
LOGP_F(LS_ERROR) << "CreatePeerConnection failed";
|
||||
DeletePeerConnection();
|
||||
return false;
|
||||
}
|
||||
|
||||
webrtc::DataChannelInit init;
|
||||
const std::string data_channel_name = std::string("pc_data_") + remote_id_;
|
||||
if (!CreateDataChannel(data_channel_name, init)) {
|
||||
LOGP_F(LS_ERROR) << "CreateDataChannel failed";
|
||||
DeletePeerConnection();
|
||||
return false;
|
||||
}
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
return true;
|
||||
}
|
||||
|
||||
bool PeerControl::Send(const char* buffer, const size_t size) {
|
||||
ASSERT( state_ == pOpened );
|
||||
ASSERT( state_ == pOpen );
|
||||
|
||||
if ( state_ != pOpen ) {
|
||||
LOGP_F( WARNING ) << "Send data when a peer state is not opened";
|
||||
return false;
|
||||
}
|
||||
|
||||
return local_data_channel_->Send(buffer, size);
|
||||
}
|
||||
|
||||
bool PeerControl::SyncSend(const char* buffer, const size_t size) {
|
||||
ASSERT( state_ == pOpened );
|
||||
ASSERT( state_ == pOpen );
|
||||
|
||||
if ( state_ != pOpen ) {
|
||||
LOGP_F( WARNING ) << "Send data when a peer state is not opened";
|
||||
return false;
|
||||
}
|
||||
|
||||
return local_data_channel_->SyncSend(buffer, size);
|
||||
}
|
||||
|
||||
bool PeerControl::IsWritable() {
|
||||
|
||||
if ( state_ != pOpen ) {
|
||||
LOGP_F( WARNING ) << "A function was called when a peer state is not opened";
|
||||
return false;
|
||||
}
|
||||
|
||||
return local_data_channel_->IsWritable();
|
||||
}
|
||||
|
||||
void PeerControl::Close() {
|
||||
LOGP_F_IF(state_ != pOpened, WARNING) << "Closing peer when it is not opened";
|
||||
LOGP_F_IF(state_ != pOpen, WARNING) << "Closing peer when it is not opened";
|
||||
|
||||
if ( state_ == pClosing || state_ == pClosed ) {
|
||||
LOGP_F( WARNING ) << "Close peer when is closing or already closed";
|
||||
return;
|
||||
}
|
||||
|
||||
state_ = pClosing;
|
||||
|
||||
LOGP_F( INFO ) << "Closing data-channel of remote_id_ " << remote_id_;
|
||||
LOGP_F( INFO ) << "Close data-channel of remote_id_ " << remote_id_;
|
||||
|
||||
if (local_data_channel_) local_data_channel_->Close();
|
||||
if (remote_data_channel_) remote_data_channel_->Close();
|
||||
if ( peer_connection_ ) {
|
||||
peer_connection_->Close();
|
||||
}
|
||||
else {
|
||||
LOGP_F( WARNING ) << "peer_connection_ is nullptr ";
|
||||
state_ = pClosed;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void PeerControl::CreateOffer(const webrtc::MediaConstraintsInterface* constraints) {
|
||||
ASSERT( state_ == pClosed );
|
||||
|
||||
state_ = pOpening;
|
||||
state_ = pConnecting;
|
||||
peer_connection_->CreateOffer(this, constraints);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
|
@ -89,7 +123,7 @@ void PeerControl::CreateOffer(const webrtc::MediaConstraintsInterface* constrain
|
|||
void PeerControl::CreateAnswer(const webrtc::MediaConstraintsInterface* constraints) {
|
||||
ASSERT( state_ == pClosed );
|
||||
|
||||
state_ = pOpening;
|
||||
state_ = pConnecting;
|
||||
peer_connection_->CreateAnswer(this, constraints);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
|
@ -104,21 +138,11 @@ void PeerControl::ReceiveOfferSdp(const std::string& sdp) {
|
|||
|
||||
|
||||
void PeerControl::ReceiveAnswerSdp(const std::string& sdp) {
|
||||
ASSERT( state_ == pOpening );
|
||||
ASSERT( state_ == pConnecting );
|
||||
SetRemoteDescription(webrtc::SessionDescriptionInterface::kAnswer, sdp);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerControl::ClosePeerConnection() {
|
||||
LOGP_F( INFO ) << "Closing peer-connection of remote_id_ " << remote_id_;
|
||||
|
||||
ASSERT( state_ == pClosing );
|
||||
peer_connection_->Close();
|
||||
|
||||
state_ = pClosed;
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
void PeerControl::OnDataChannel(webrtc::DataChannelInterface* data_channel) {
|
||||
LOGP_F( INFO ) << "remote_id_ is " << remote_id_;
|
||||
|
||||
|
|
@ -140,16 +164,31 @@ void PeerControl::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConn
|
|||
// Ice connection has been closed.
|
||||
// Notify it to Control so the Control will remove peer in peers_
|
||||
//
|
||||
observer_->QueueOnPeerDisconnected(remote_id_);
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionClosed";
|
||||
OnPeerClosed();
|
||||
break;
|
||||
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionDisconnected:
|
||||
//
|
||||
// Peer disconnected unexpectedly before close()
|
||||
// Queue disconnection requeue to Control.
|
||||
// - Leave channel in signal server
|
||||
// - Close peer data channel and ice connecition
|
||||
// Peer disconnected and notify it to control that makes control trigger closing
|
||||
//
|
||||
observer_->QueuePeerDisconnect(remote_id_);
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionDisconnected";
|
||||
OnPeerDisconnected();
|
||||
break;
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionNew:
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionNew";
|
||||
break;
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionChecking:
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionChecking";
|
||||
break;
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionConnected:
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionConnected";
|
||||
break;
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionCompleted:
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionCompleted";
|
||||
break;
|
||||
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionFailed:
|
||||
LOGP_F( INFO ) << "new_state is " << "kIceConnectionFailed";
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -157,7 +196,6 @@ void PeerControl::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConn
|
|||
}
|
||||
|
||||
|
||||
|
||||
void PeerControl::OnIceCandidate(const webrtc::IceCandidateInterface* candidate) {
|
||||
std::string sdp;
|
||||
if (!candidate->ToString(&sdp)) return;
|
||||
|
|
@ -168,7 +206,7 @@ void PeerControl::OnIceCandidate(const webrtc::IceCandidateInterface* candidate)
|
|||
data["sdp_mline_index"] = candidate->sdp_mline_index();
|
||||
data["candidate"] = sdp;
|
||||
|
||||
observer_->SendCommand(remote_id_, "ice_candidate", data);
|
||||
control_->SendCommand(remote_id_, "ice_candidate", data);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
||||
|
|
@ -189,11 +227,11 @@ void PeerControl::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
|
|||
|
||||
if (desc->type() == webrtc::SessionDescriptionInterface::kOffer) {
|
||||
data["sdp"] = sdp;
|
||||
observer_->SendCommand(remote_id_, "offersdp", data);
|
||||
control_->SendCommand(remote_id_, "offersdp", data);
|
||||
}
|
||||
else if (desc->type() == webrtc::SessionDescriptionInterface::kAnswer) {
|
||||
data["sdp"] = sdp;
|
||||
observer_->SendCommand(remote_id_, "answersdp", data);
|
||||
control_->SendCommand(remote_id_, "answersdp", data);
|
||||
}
|
||||
LOGP_F( INFO ) << "Done";
|
||||
}
|
||||
|
|
@ -206,10 +244,12 @@ void PeerControl::OnPeerOpened() {
|
|||
remote_data_channel_->state() == webrtc::DataChannelInterface::DataState::kOpen
|
||||
) {
|
||||
LOG_F( INFO ) << "Peers are connected, " << remote_id_ << " and " << local_id_;
|
||||
ASSERT( state_ == pOpening );
|
||||
state_ = pOpened;
|
||||
observer_->OnPeerConnected(remote_id_);
|
||||
observer_->OnPeerWritable(local_id_);
|
||||
ASSERT( state_ == pConnecting );
|
||||
|
||||
// Fianlly, data-channel has been opened.
|
||||
state_ = pOpen;
|
||||
control_->OnConnected(remote_id_);
|
||||
control_->OnWritable(local_id_);
|
||||
}
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
|
|
@ -217,36 +257,31 @@ void PeerControl::OnPeerOpened() {
|
|||
|
||||
void PeerControl::OnPeerClosed() {
|
||||
|
||||
if ( local_data_channel_.get() == nullptr ) {
|
||||
LOGP_F( WARNING ) << "local_data_channel_ is null";
|
||||
ASSERT( state_ == pClosing );
|
||||
|
||||
state_ = pClosed;
|
||||
control_->OnClosed(remote_id_);
|
||||
|
||||
}
|
||||
|
||||
void PeerControl::OnPeerDisconnected() {
|
||||
|
||||
if ( state_ == pClosed ) {
|
||||
LOGP_F( WARNING ) << "Already closed";
|
||||
return;
|
||||
}
|
||||
else if ( state_ == pClosing ) {
|
||||
LOGP_F( INFO ) << "Already closing";
|
||||
return;
|
||||
}
|
||||
|
||||
if ( remote_data_channel_.get() == nullptr ) {
|
||||
LOGP_F( WARNING ) << "remote_data_channel_ is null";
|
||||
return;
|
||||
}
|
||||
|
||||
// Both local_data_channel_ and remote_data_channel_ has been closed
|
||||
if ((local_data_channel_ == nullptr ||
|
||||
local_data_channel_->state() == webrtc::DataChannelInterface::DataState::kClosed) &&
|
||||
(remote_data_channel_ == nullptr ||
|
||||
remote_data_channel_->state() == webrtc::DataChannelInterface::DataState::kClosed)) {
|
||||
|
||||
// Close local peerconnection
|
||||
LOGP_F( INFO ) << "Data channels are closed. "
|
||||
"remote_id_ is " << remote_id_ << " and "
|
||||
"local_id_ is " << local_id_;
|
||||
observer_->QueueOnPeerChannelClosed(remote_id_, 1000);
|
||||
}
|
||||
|
||||
LOGP_F( INFO ) << "Done";
|
||||
control_->Close( remote_id_ );
|
||||
}
|
||||
|
||||
|
||||
void PeerControl::OnPeerMessage(const webrtc::DataBuffer& buffer) {
|
||||
std::string data;
|
||||
observer_->OnPeerMessage(remote_id_, buffer.data.data<char>(), buffer.data.size());
|
||||
control_->OnMessage(remote_id_, buffer.data.data<char>(), buffer.data.size());
|
||||
}
|
||||
|
||||
void PeerControl::OnBufferedAmountChange(const uint64_t previous_amount) {
|
||||
|
|
@ -254,7 +289,7 @@ void PeerControl::OnBufferedAmountChange(const uint64_t previous_amount) {
|
|||
LOGP_F( LERROR ) << "local_data_channel_ is not writable";
|
||||
return;
|
||||
}
|
||||
observer_->OnPeerWritable( remote_id_ );
|
||||
control_->OnWritable( remote_id_ );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -314,6 +349,7 @@ bool PeerControl::CreatePeerConnection() {
|
|||
LOGP_F( LERROR ) << "peer_connection is null";
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -332,6 +368,11 @@ void PeerControl::DeletePeerConnection() {
|
|||
void PeerControl::SetLocalDescription(const std::string& type,
|
||||
const std::string& sdp) {
|
||||
|
||||
if ( peer_connection_ == nullptr ) {
|
||||
LOGP_F( LERROR ) << "peer_connection_ is nullptr";
|
||||
return;
|
||||
}
|
||||
|
||||
rtc::scoped_refptr<webrtc::MockSetSessionDescriptionObserver>
|
||||
observer(new rtc::RefCountedObject<
|
||||
webrtc::MockSetSessionDescriptionObserver>());
|
||||
|
|
@ -360,7 +401,7 @@ void PeerControl::Attach(PeerDataChannelObserver* datachannel) {
|
|||
}
|
||||
|
||||
datachannel->SignalOnOpen_.connect(this, &PeerControl::OnPeerOpened);
|
||||
datachannel->SignalOnClosed_.connect(this, &PeerControl::OnPeerClosed);
|
||||
datachannel->SignalOnDisconnected_.connect(this, &PeerControl::OnPeerDisconnected);
|
||||
datachannel->SignalOnMessage_.connect(this, &PeerControl::OnPeerMessage);
|
||||
datachannel->SignalOnBufferedAmountChange_.connect(this, &PeerControl::OnBufferedAmountChange);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
|
|
@ -373,7 +414,7 @@ void PeerControl::Detach(PeerDataChannelObserver* datachannel) {
|
|||
}
|
||||
|
||||
datachannel->SignalOnOpen_.disconnect(this);
|
||||
datachannel->SignalOnClosed_.disconnect(this);
|
||||
datachannel->SignalOnDisconnected_.disconnect(this);
|
||||
datachannel->SignalOnMessage_.disconnect(this);
|
||||
datachannel->SignalOnBufferedAmountChange_.disconnect(this);
|
||||
LOGP_F( INFO ) << "Done";
|
||||
|
|
@ -418,7 +459,7 @@ void PeerDataChannelObserver::OnStateChange() {
|
|||
}
|
||||
else if (state_ == webrtc::DataChannelInterface::DataState::kClosed) {
|
||||
LOGP_F( INFO ) << "Data channel internal state is kClosed";
|
||||
SignalOnClosed_();
|
||||
SignalOnDisconnected_();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
33
src/peer.h
33
src/peer.h
|
|
@ -25,14 +25,13 @@ namespace pc {
|
|||
class PeerObserver {
|
||||
public:
|
||||
virtual void SendCommand(const std::string& id, const std::string& command, const Json::Value& data) = 0;
|
||||
virtual void OnPeerConnected(const std::string id) = 0;
|
||||
virtual void QueuePeerDisconnect(const std::string id) = 0;
|
||||
virtual void QueueOnPeerDisconnected(const std::string id) = 0;
|
||||
virtual void OnPeerDisconnected(const std::string id) = 0;
|
||||
virtual void QueueOnPeerChannelClosed(const std::string id, int delay) = 0;
|
||||
virtual void OnPeerChannelClosed(const std::string id) = 0;
|
||||
virtual void OnPeerMessage(const std::string& id, const char* buffer, const size_t size) = 0;
|
||||
virtual void OnPeerWritable(const std::string& id) = 0;
|
||||
virtual void Close(const std::string id) = 0;
|
||||
virtual void OnConnected(const std::string id) = 0;
|
||||
virtual void OnClosed(const std::string id) = 0;
|
||||
virtual void OnMessage(const std::string& id, const char* buffer, const size_t size) = 0;
|
||||
virtual void OnWritable(const std::string& id) = 0;
|
||||
virtual void OnError( const std::string id, const std::string& reason ) = 0;
|
||||
|
||||
};
|
||||
|
||||
class PeerDataChannelObserver;
|
||||
|
|
@ -58,15 +57,21 @@ public:
|
|||
~PeerControl();
|
||||
|
||||
enum PeerState {
|
||||
pOpening,
|
||||
pOpened,
|
||||
pConnecting,
|
||||
pOpen,
|
||||
pClosing,
|
||||
pClosed
|
||||
};
|
||||
|
||||
const std::string& local_id() const { return local_id_; }
|
||||
const std::string& remote_id() const { return remote_id_; }
|
||||
const PeerState state() const { return state_ ; }
|
||||
|
||||
//
|
||||
// APIs
|
||||
//
|
||||
|
||||
bool Initialize();
|
||||
bool Send(const char* buffer, const size_t size);
|
||||
bool SyncSend(const char* buffer, const size_t size);
|
||||
bool IsWritable();
|
||||
|
|
@ -78,14 +83,11 @@ public:
|
|||
|
||||
void CreateOffer(const webrtc::MediaConstraintsInterface* constraints);
|
||||
void CreateAnswer(const webrtc::MediaConstraintsInterface* constraints);
|
||||
|
||||
void AddIceCandidate(const std::string& sdp_mid, int sdp_mline_index,
|
||||
const std::string& candidate);
|
||||
void ReceiveOfferSdp(const std::string& sdp);
|
||||
void ReceiveAnswerSdp(const std::string& sdp);
|
||||
|
||||
void ClosePeerConnection();
|
||||
|
||||
//
|
||||
// PeerConnectionObserver implementation.
|
||||
//
|
||||
|
|
@ -113,6 +115,7 @@ public:
|
|||
|
||||
void OnPeerOpened();
|
||||
void OnPeerClosed();
|
||||
void OnPeerDisconnected();
|
||||
void OnPeerMessage(const webrtc::DataBuffer& buffer);
|
||||
void OnBufferedAmountChange(const uint64_t previous_amount);
|
||||
|
||||
|
|
@ -137,7 +140,7 @@ protected:
|
|||
|
||||
PeerState state_;
|
||||
|
||||
PeerObserver* observer_;
|
||||
PeerObserver* control_;
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -165,7 +168,7 @@ public:
|
|||
|
||||
// sigslots
|
||||
sigslot::signal0<> SignalOnOpen_;
|
||||
sigslot::signal0<> SignalOnClosed_;
|
||||
sigslot::signal0<> SignalOnDisconnected_;
|
||||
sigslot::signal1<const webrtc::DataBuffer&> SignalOnMessage_;
|
||||
sigslot::signal1<const uint64_t> SignalOnBufferedAmountChange_;
|
||||
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@ PeerConnect::PeerConnect()
|
|||
PeerConnect::PeerConnect(const std::string setting) {
|
||||
// Log level
|
||||
#if DEBUG || _DEBUG
|
||||
rtc::LogMessage::LogToDebug(rtc::WARNING);
|
||||
pc::LogMessage::LogToDebug(pc::WARNING);
|
||||
rtc::LogMessage::LogToDebug(rtc::LS_NONE);
|
||||
pc::LogMessage::LogToDebug(pc::LS_VERBOSE);
|
||||
#else
|
||||
rtc::LogMessage::LogToDebug(rtc::LS_NONE);
|
||||
pc::LogMessage::LogToDebug(pc::LS_NONE);
|
||||
|
|
@ -127,7 +127,7 @@ void PeerConnect::Connect(const std::string id) {
|
|||
}
|
||||
|
||||
void PeerConnect::Disconnect(const std::string id) {
|
||||
control_->Disconnect(id);
|
||||
control_->Close(id);
|
||||
LOGP_F( INFO ) << "Done, id is " << id;
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue