peerborough
/
peerapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Supports WebRTC branch head 60

master
Ryan Lee 2017-10-23 00:39:33 +09:00
parent 137fe1cfbc
commit ea11b4baa2
15 changed files with 697 additions and 736 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
CMakeLists.txt
View File

@ -4,12 +4,7 @@
#
# ============================================================================
if (APPLE)
cmake_minimum_required(VERSION 3.2)
else (APPLE)
cmake_minimum_required(VERSION 2.8)
endif (APPLE)
cmake_minimum_required(VERSION 3.2)
project(peerconnect)
@ -149,14 +144,14 @@ if (PC_WITH_STATIC)
if (_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
add_custom_command(TARGET peerconnect PRE_LINK
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" gn gen ${WEBRTC_OUT_DIR_DEBUG} --args=\"is_debug=true is_component_build=false\"
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" ninja -C ${WEBRTC_OUT_DIR_DEBUG} peerconnection_unittests
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" ninja -C ${WEBRTC_OUT_DIR_DEBUG}
WORKING_DIRECTORY "${WEBRTC_ROOT_DIR}"
COMMENT "Building WebRTC library (Once)"
)
else()
add_custom_command(TARGET peerconnect PRE_LINK
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" gn gen ${WEBRTC_OUT_DIR} --args=\"is_debug=false is_component_build=false\"
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" ninja -C ${WEBRTC_OUT_DIR} peerconnection_unittests
COMMAND ${CMAKE_COMMAND} -E env \"PATH=${DEPOT_TOOLS_DIR}:$ENV{PATH}\" ninja -C ${WEBRTC_OUT_DIR}
WORKING_DIRECTORY "${WEBRTC_ROOT_DIR}"
COMMENT "Building WebRTC library (Once)"
)
@ -251,7 +246,6 @@ if (PC_WITH_SHARED)
CACHE STRING "PeerConnect shared library")
endif()
# ============================================================================
# Test
# ============================================================================
@ -259,7 +253,6 @@ endif()
if (PC_BUILD_TEST)
add_executable(test_main src/test/test_main.cc)
add_dependencies(test_main peerconnect)
target_include_directories(test_main PRIVATE ${PEERCONNECT_INCLUDE_DIR})
target_link_libraries(test_main ${PEERCONNECT_LIBRARIES_STATIC})
set_target_properties (test_main PROPERTIES FOLDER test)

4
README.md
View File

@ -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/55 so run
Currently PeerConnect supports WebRTC branch-heads/60 so run
```
$ git checkout -b peers55 refs/remotes/branch-heads/55
$ git checkout -b peers60 refs/remotes/branch-heads/60
```
To update build toolchain and dependencies of WebRTC, run:

94
cmake/FindWebRTC.cmake
View File

File diff suppressed because one or more lines are too long

10
cmake/Mergestaticlibs.cmake
View File

@ -39,7 +39,7 @@ macro (MERGE_STATIC_LIBRARIES TARGET_LIB LIBRARIES LIBRARIES_DEBUG OBJECTS OBJEC
endif()
set(outfile $<TARGET_FILE:${TARGET_LIB}>)
set(target_temp_file "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${TARGET_LIB}_temp.a")
set(target_temp_file "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_LIB}_temp.a")
string(TOUPPER "${CMAKE_BUILD_TYPE}" _CMAKE_BUILD_TYPE)
if (_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
@ -74,8 +74,8 @@ macro (MERGE_STATIC_LIBRARIES TARGET_LIB LIBRARIES LIBRARIES_DEBUG OBJECTS OBJEC
set(_OBJECTS ${OBJECTS})
endif()
get_target_property (outfile ${TARGET_LIB} LOCATION)
set(target_temp_file "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${TARGET_LIB}_temp.a")
set(outfile "libpeerconnect.a")
set(target_temp_file "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_LIB}_temp.a")
set(MRI_SCRIPT "create ${outfile}\n")
foreach(lib ${_LIBRARIES})
@ -89,13 +89,13 @@ macro (MERGE_STATIC_LIBRARIES TARGET_LIB LIBRARIES LIBRARIES_DEBUG OBJECTS OBJEC
set(MRI_SCRIPT "${MRI_SCRIPT}save\n")
set(MRI_SCRIPT "${MRI_SCRIPT}end\n")
file(WRITE "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/peerconnect.mri" "${MRI_SCRIPT}")
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/peerconnect.mri" "${MRI_SCRIPT}")
add_custom_command(TARGET ${TARGET_LIB} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy "${outfile}"
"${target_temp_file}"
COMMAND rm "${outfile}"
COMMAND ${CMAKE_AR} -M < "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/peerconnect.mri"
COMMAND ${CMAKE_AR} -M < "${CMAKE_CURRENT_BINARY_DIR}/peerconnect.mri"
COMMAND rm "${target_temp_file}"
)
endif (WIN32)

322
src/control.cc
View File

@ -38,18 +38,18 @@ Control::Control(std::shared_ptr<Signal> signal)
signal_->SignalOnCommandReceived_.connect(this, &Control::OnSignalCommandReceived);
signal_->SignalOnClosed_.connect(this, &Control::OnSignalConnectionClosed);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
Control::~Control() {
LOGP_F( INFO ) << "Starting";
LOG_F( INFO ) << "Starting";
peers_.clear();
DeleteControl();
signal_->SignalOnCommandReceived_.disconnect(this);
signal_->SignalOnClosed_.disconnect(this);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
@ -59,29 +59,29 @@ Control::~Control() {
bool Control::InitializeControl() {
ASSERT(peer_connection_factory_.get() == NULL);
RTC_DCHECK(peer_connection_factory_.get() == NULL);
webrtc::MediaConstraintsInterface* constraints = NULL;
if ( !CreatePeerFactory(constraints) ) {
LOGP_F(LERROR) << "CreatePeerFactory failed";
LOG_F(LERROR) << "CreatePeerFactory failed";
DeleteControl();
return false;
}
webrtc_thread_ = rtc::Thread::Current();
ASSERT( webrtc_thread_ != nullptr );
RTC_DCHECK( webrtc_thread_ != nullptr );
return true;
}
void Control::DeleteControl() {
LOGP_F( INFO ) << "Starting";
LOG_F( INFO ) << "Starting";
peer_connection_factory_ = NULL;
fake_audio_capture_module_ = NULL;
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
@ -95,7 +95,7 @@ void Control::Open(const string& user_id, const string& user_password, const str
// 4. Generate 'open' event to PeerConnect
if (signal_.get() == NULL) {
LOGP_F( LERROR ) << "Open failed, no signal server";
LOG_F( LERROR ) << "Open failed, no signal server";
return;
}
@ -105,7 +105,7 @@ void Control::Open(const string& user_id, const string& user_password, const str
// Connect to signal server
signal_->Open(user_id, user_password);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
return;
}
@ -117,18 +117,18 @@ void Control::Connect(const string peer) {
// 4. Connect datachannel
if (signal_.get() == NULL) {
LOGP_F(LERROR) << "Join failed, no signal server";
LOG_F(LERROR) << "Join failed, no signal server";
return;
}
LOGP_F( INFO ) << "Joining channel " << peer;
LOG_F( INFO ) << "Joining channel " << peer;
JoinChannel(peer);
}
void Control::Close(const CloseCode code, bool force_queuing) {
LOGP_F( INFO ) << "Call";
LOG_F( INFO ) << "Call";
//
// Verify current thread
//
@ -136,7 +136,7 @@ void Control::Close(const CloseCode code, bool force_queuing) {
if (force_queuing || webrtc_thread_ != rtc::Thread::Current()) {
ControlMessageData *data = new ControlMessageData(code, ref_);
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_CLOSE, data);
LOGP_F( INFO ) << "Queued";
LOG_F( INFO ) << "Queued";
return;
}
@ -150,10 +150,10 @@ void Control::Close(const CloseCode code, bool force_queuing) {
peer_ids.push_back(peer.second->remote_id());
}
LOGP_F(INFO) << "Close(): peer count is " << peer_ids.size();
LOG_F(INFO) << "Close(): peer count is " << peer_ids.size();
for (auto id : peer_ids) {
LOGP_F( INFO ) << "Try to close peer having id " << id;
LOG_F( INFO ) << "Try to close peer having id " << id;
ClosePeer(id, code);
}
@ -165,7 +165,7 @@ void Control::Close(const CloseCode code, bool force_queuing) {
pc_->OnClose( peer_name_ ,code );
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void Control::ClosePeer( const string peer, const CloseCode code, bool force_queuing ) {
@ -188,7 +188,7 @@ void Control::ClosePeer( const string peer, const CloseCode code, bool force_que
auto peer_found = peers_.find(peer);
if ( peer_found == peers_.end() ) {
LOGP_F( WARNING ) << "peer not found, " << peer;
LOG_F( WARNING ) << "peer not found, " << peer;
return;
}
@ -199,7 +199,7 @@ void Control::ClosePeer( const string peer, const CloseCode code, bool force_que
// 3. Leave channel on signal server
LeaveChannel(peer);
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
//
@ -239,12 +239,12 @@ void Control::SendCommand(const string& peer, const string& command, const Json:
void Control::OnPeerConnect(const string peer) {
if ( pc_ == nullptr ) {
LOGP_F( WARNING ) << "pc_ is null, peer is " << peer;
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
return;
}
pc_->OnConnect(peer);
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
void Control::OnPeerClose(const string peer, CloseCode code) {
@ -254,20 +254,20 @@ void Control::OnPeerClose(const string peer, CloseCode code) {
// Call Control::OnPeerDisconnected()
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_ON_PEER_CLOSE, data);
LOGP_F( INFO ) << "Queued, peer is " << peer;
LOG_F( INFO ) << "Queued, peer is " << peer;
return;
}
LOGP_F( INFO ) << "Enter, peer is " << peer;
LOG_F( INFO ) << "Enter, peer is " << peer;
if ( pc_ == nullptr ) {
LOGP_F( WARNING ) << "pc_ is null, peer is " << peer;
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
return;
}
pc_->OnClose( peer, code );
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
//
@ -276,7 +276,7 @@ void Control::OnPeerClose(const string peer, CloseCode code) {
void Control::OnPeerMessage(const string& peer, const char* data, const size_t size) {
if ( pc_ == nullptr ) {
LOGP_F( WARNING ) << "pc_ is null, peer is " << peer;
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
return;
}
pc_->OnMessage(peer, data, size);
@ -284,7 +284,7 @@ void Control::OnPeerMessage(const string& peer, const char* data, const size_t s
void Control::OnPeerWritable(const string& peer) {
if ( pc_ == nullptr ) {
LOGP_F( WARNING ) << "pc_ is null, peer is " << peer;
LOG_F( WARNING ) << "pc_ is null, peer is " << peer;
return;
}
pc_->OnWritable(peer);
@ -294,14 +294,14 @@ void Control::RegisterObserver(ControlObserver* observer, std::shared_ptr<Contro
ref_ = ref;
pc_ = observer;
LOGP_F( INFO ) << "Registered";
LOG_F( INFO ) << "Registered";
}
void Control::UnregisterObserver() {
pc_ = nullptr;
ref_.reset();
LOGP_F( INFO ) << "Unregistered";
LOG_F( INFO ) << "Unregistered";
}
//
@ -309,11 +309,11 @@ void Control::UnregisterObserver() {
//
void Control::OnMessage(rtc::Message* msg) {
ControlMessageData* param = nullptr;
ControlMessageData* param = nullptr;
switch (msg->message_id) {
case MSG_COMMAND_RECEIVED:
param = static_cast<ControlMessageData*>(msg->pdata);
OnCommandReceived(param->data_json_);
param = static_cast<ControlMessageData*>(msg->pdata);
OnCommandReceived(param->data_json_);
break;
case MSG_CLOSE:
param = static_cast<ControlMessageData*>(msg->pdata);
@ -332,7 +332,7 @@ void Control::OnMessage(rtc::Message* msg) {
Close((CloseCode)param->data_int32_);
break;
default:
LOGP_F( WARNING ) << "Unknown message";
LOG_F( WARNING ) << "Unknown message";
break;
}
@ -353,7 +353,7 @@ void Control::OnCommandReceived(const Json::Value& message) {
if (!rtc::GetStringFromJsonObject(message, "command", &command) ||
!rtc::GetValueFromJsonObject(message, "data", &data)) {
LOGP_F(LERROR) << "Invalid message:" << message;
LOG_F(LERROR) << "Invalid message:" << message;
return;
}
@ -393,16 +393,16 @@ void Control::OnCommandReceived(const Json::Value& message) {
void Control::OnSignalCommandReceived(const Json::Value& message) {
ControlMessageData *data = new ControlMessageData(message, ref_);
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_COMMAND_RECEIVED, data);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void Control::OnSignalConnectionClosed(websocketpp::close::status::value code) {
LOGP_F(INFO) << "Enter, code is " << code;
LOG_F(INFO) << "Enter, code is " << code;
if (code != websocketpp::close::status::normal) {
ControlMessageData *data = new ControlMessageData(CLOSE_SIGNAL_ERROR, ref_);
webrtc_thread_->Post(RTC_FROM_HERE, this, MSG_ON_SIGLAL_CONNECTION_CLOSE, data);
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
//
@ -410,26 +410,26 @@ void Control::OnSignalConnectionClosed(websocketpp::close::status::value code) {
//
void Control::CreateChannel(const string name) {
LOGP_F( INFO ) << "channel is " << name;
Json::Value data;
data["name"] = name;
SendCommand(name, "createchannel", data);
LOG_F( INFO ) << "channel is " << name;
Json::Value data;
data["name"] = name;
SendCommand(name, "createchannel", data);
}
void Control::JoinChannel(const string name) {
LOGP_F( INFO ) << "channel is " << name;
LOG_F( INFO ) << "channel is " << name;
Json::Value data;
data["name"] = name;
Json::Value data;
data["name"] = name;
SendCommand(name, "joinchannel", data);
}
void Control::LeaveChannel(const string name) {
LOGP_F( INFO ) << "channel is " << name;
LOG_F( INFO ) << "channel is " << name;
Json::Value data;
data["name"] = name;
Json::Value data;
data["name"] = name;
SendCommand(name, "leavechannel", data);
}
@ -443,7 +443,7 @@ bool Control::CreatePeerFactory(
fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
if (fake_audio_capture_module_ == NULL) {
LOGP_F( LERROR ) << "Failed to create FakeAudioCaptureModule";
LOG_F( LERROR ) << "Failed to create FakeAudioCaptureModule";
return false;
}
@ -452,11 +452,11 @@ bool Control::CreatePeerFactory(
fake_audio_capture_module_, NULL, NULL);
if (!peer_connection_factory_.get()) {
LOGP_F( LERROR ) << "Failed to create CreatePeerConnectionFactory";
LOG_F( LERROR ) << "Failed to create CreatePeerConnectionFactory";
return false;
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
return true;
}
@ -472,28 +472,28 @@ void Control::AddIceCandidate(const string& peer_id, const Json::Value& data) {
string candidate;
if ( !rtc::GetStringFromJsonObject( data, "sdp_mid", &sdp_mid ) ) {
LOGP_F( LERROR ) << "sdp_mid not found, " << data.toStyledString();
LOG_F( LERROR ) << "sdp_mid not found, " << data.toStyledString();
return;
}
if ( !rtc::GetIntFromJsonObject( data, "sdp_mline_index", &sdp_mline_index ) ) {
LOGP_F( LERROR ) << "sdp_mline_index not found, " << data.toStyledString();
LOG_F( LERROR ) << "sdp_mline_index not found, " << data.toStyledString();
return;
}
if ( !rtc::GetStringFromJsonObject( data, "candidate", &candidate ) ) {
LOGP_F( LERROR ) << "candidate not found, " << data.toStyledString();
LOG_F( LERROR ) << "candidate not found, " << data.toStyledString();
return;
}
if ( peers_.find( peer_id ) == peers_.end() ) {
LOGP_F( WARNING ) << "peer_id not found, peer_id is " << peer_id << " and " <<
LOG_F( WARNING ) << "peer_id not found, peer_id is " << peer_id << " and " <<
"data is " << data.toStyledString();
return;
}
peers_[peer_id]->AddIceCandidate(sdp_mid, sdp_mline_index, candidate);
LOGP_F( INFO ) << "Done, peer_id is " << peer_id;
LOG_F( INFO ) << "Done, peer_id is " << peer_id;
}
@ -503,94 +503,94 @@ void Control::AddIceCandidate(const string& peer_id, const Json::Value& data) {
//
void Control::OnOpen(const Json::Value& data) {
bool result;
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
LOGP_F(WARNING) << "Unknown open response";
return;
}
if (!result) {
LOGP_F(LERROR) << "Open failed";
return;
}
string session_id;
if (!rtc::GetStringFromJsonObject(data, "session_id", &session_id)) {
LOGP_F(LERROR) << "Open failed - no session_id";
return;
}
session_id_ = session_id;
//
// Create channel
//
CreateChannel(peer_name_);
LOGP_F( INFO ) << "Done";
bool result;
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
LOG_F(WARNING) << "Unknown open response";
return;
}
if (!result) {
LOG_F(LERROR) << "Open failed";
return;
}
string session_id;
if (!rtc::GetStringFromJsonObject(data, "session_id", &session_id)) {
LOG_F(LERROR) << "Open failed - no session_id";
return;
}
session_id_ = session_id;
//
// Create channel
//
CreateChannel(peer_name_);
LOG_F( INFO ) << "Done";
}
void Control::OnChannelCreate(const Json::Value& data) {
bool result;
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
LOGP_F(WARNING) << "Unknown open response";
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
return;
}
string peer;
if (!rtc::GetStringFromJsonObject(data, "name", &peer)) {
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
LOGP_F(LERROR) << "Create channel failed - no channel name";
return;
}
if (!result) {
LOGP_F(LERROR) << "Create channel failed";
string desc;
if (!rtc::GetStringFromJsonObject(data, "desc", &desc)) {
desc = "Unknown reason";
}
pc_->OnClose(peer, CLOSE_SIGNAL_ERROR, desc);
return;
}
bool result;
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
LOG_F(WARNING) << "Unknown open response";
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
return;
}
string peer;
if (!rtc::GetStringFromJsonObject(data, "name", &peer)) {
pc_->OnClose(peer_name_, CLOSE_SIGNAL_ERROR);
LOG_F(LERROR) << "Create channel failed - no channel name";
return;
}
if (!result) {
LOG_F(LERROR) << "Create channel failed";
string desc;
if (!rtc::GetStringFromJsonObject(data, "desc", &desc)) {
desc = "Unknown reason";
}
pc_->OnClose(peer, CLOSE_SIGNAL_ERROR, desc);
return;
}
pc_->OnOpen(peer);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void Control::OnChannelJoin(const Json::Value& data) {
bool result;
LOGP_F(INFO) << "OnChannelJoined(" << data.toStyledString() << ")";
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
pc_->OnClose( "", CLOSE_SIGNAL_ERROR );
LOGP_F(LERROR) << "Unknown channel join response";
return;
}
string peer;
if (!rtc::GetStringFromJsonObject(data, "name", &peer)) {
pc_->OnClose( "", CLOSE_SIGNAL_ERROR );
LOGP_F(LERROR) << "Join channel failed - no channel name";
return;
}
if (!result) {
LOGP_F(LERROR) << "Join channel failed";
string desc;
if (!rtc::GetStringFromJsonObject(data, "desc", &desc)) {
desc = "Unknown reason";
}
pc_->OnClose( peer, CLOSE_SIGNAL_ERROR, desc );
return;
}
LOGP_F( INFO ) << "Done";
bool result;
LOG_F(INFO) << "OnChannelJoined(" << data.toStyledString() << ")";
if (!rtc::GetBoolFromJsonObject(data, "result", &result)) {
pc_->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 );
LOG_F(LERROR) << "Join channel failed - no channel name";
return;
}
if (!result) {
LOG_F(LERROR) << "Join channel failed";
string desc;
if (!rtc::GetStringFromJsonObject(data, "desc", &desc)) {
desc = "Unknown reason";
}
pc_->OnClose( peer, CLOSE_SIGNAL_ERROR, desc );
return;
}
LOG_F( INFO ) << "Done";
}
@ -604,7 +604,7 @@ void Control::OnChannelLeave(const Json::Value& data) {
void Control::OnRemotePeerClose(const string& peer_id, const Json::Value& data) {
ClosePeer( peer_id, CLOSE_NORMAL );
ClosePeer( peer_id, CLOSE_NORMAL );
}
//
@ -612,32 +612,32 @@ void Control::OnRemotePeerClose(const string& peer_id, const Json::Value& data)
//
void Control::CreateOffer(const Json::Value& data) {
Json::Value peers;
if (!rtc::GetValueFromJsonObject(data, "peers", &peers)) {
LOGP_F(LERROR) << "createoffer failed - no peers value";
return;
}
for (size_t i = 0; i < peers.size(); ++i) {
string remote_id;
if (!rtc::GetStringFromJsonArray(peers, i, &remote_id)) {
LOGP_F(LERROR) << "Peer handshake failed - invalid peer id";
return;
}
Json::Value peers;
if (!rtc::GetValueFromJsonObject(data, "peers", &peers)) {
LOG_F(LERROR) << "createoffer failed - no peers value";
return;
}
for (size_t i = 0; i < peers.size(); ++i) {
string remote_id;
if (!rtc::GetStringFromJsonArray(peers, i, &remote_id)) {
LOG_F(LERROR) << "Peer handshake failed - invalid peer id";
return;
}
Peer peer = new rtc::RefCountedObject<PeerControl>(peer_name_, remote_id, this, peer_connection_factory_);
if ( !peer->Initialize() ) {
LOGP_F( LERROR ) << "Peer initialization failed";
LOG_F( LERROR ) << "Peer initialization failed";
OnPeerClose( remote_id, CLOSE_ABNORMAL );
return;
}
peers_.insert(std::pair<string, Peer>(remote_id, peer));
peer->CreateOffer(NULL);
}
LOGP_F( INFO ) << "Done";
}
LOG_F( INFO ) << "Done";
}
//
@ -648,14 +648,14 @@ void Control::ReceiveOfferSdp(const string& peer_id, const Json::Value& data) {
string sdp;
if ( !rtc::GetStringFromJsonObject( data, "sdp", &sdp ) ) {
LOGP_F( LERROR ) << "sdp not found, peer_id is " << peer_id << " and " <<
LOG_F( LERROR ) << "sdp not found, peer_id is " << peer_id << " and " <<
"data is " << data.toStyledString();
return;
}
Peer peer = new rtc::RefCountedObject<PeerControl>(peer_name_, peer_id, this, peer_connection_factory_);
if ( !peer->Initialize() ) {
LOGP_F( LERROR ) << "Peer initialization failed";
LOG_F( LERROR ) << "Peer initialization failed";
OnPeerClose( peer_id, CLOSE_ABNORMAL );
return;
}
@ -663,7 +663,7 @@ void Control::ReceiveOfferSdp(const string& peer_id, const Json::Value& data) {
peers_.insert(std::pair<string, Peer>(peer_id, peer));
peer->ReceiveOfferSdp(sdp);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
@ -675,20 +675,20 @@ void Control::ReceiveAnswerSdp(const string& peer_id, const Json::Value& data) {
string sdp;
if ( !rtc::GetStringFromJsonObject( data, "sdp", &sdp ) ) {
LOGP_F( LERROR ) << "sdp not found, peer_id is " << peer_id << " and " <<
LOG_F( LERROR ) << "sdp not found, peer_id is " << peer_id << " and " <<
"data is " << data.toStyledString();
return;
}
auto peer = peers_.find(peer_id);
if ( peer == peers_.end() ) {
LOGP_F( LERROR ) << "peer_id not found, peer_id is " << peer_id << " and " <<
LOG_F( LERROR ) << "peer_id not found, peer_id is " << peer_id << " and " <<
"data is " << data.toStyledString();
return;
}
peer->second->ReceiveAnswerSdp(sdp);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
} // namespace pc

140
src/fakeaudiocapturemodule.cc
View File

@ -8,9 +8,9 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/api/test/fakeaudiocapturemodule.h"
#include "webrtc/pc/test/fakeaudiocapturemodule.h"
#include "webrtc/base/common.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/refcount.h"
#include "webrtc/base/thread.h"
#include "webrtc/base/timeutils.h"
@ -23,7 +23,7 @@ static const int kHighSampleValue = 10000;
// Same value as src/modules/audio_device/main/source/audio_device_config.h in
// https://code.google.com/p/webrtc/
static const uint32_t kAdmMaxIdleTimeProcess = 1000;
static const int kAdmMaxIdleTimeProcess = 1000;
// Constants here are derived by running VoE using a real ADM.
// The constants correspond to 10ms of mono audio at 44kHz.
@ -73,12 +73,12 @@ int FakeAudioCaptureModule::frames_received() const {
}
int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
const uint32_t current_time = rtc::Time();
const int64_t current_time = rtc::TimeMillis();
if (current_time < last_process_time_ms_) {
// TODO: wraparound could be handled more gracefully.
return 0;
}
const uint32_t elapsed_time = current_time - last_process_time_ms_;
const int64_t elapsed_time = current_time - last_process_time_ms_;
if (kAdmMaxIdleTimeProcess < elapsed_time) {
return 0;
}
@ -86,17 +86,17 @@ int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
}
void FakeAudioCaptureModule::Process() {
last_process_time_ms_ = rtc::Time();
last_process_time_ms_ = rtc::TimeMillis();
}
int32_t FakeAudioCaptureModule::ActiveAudioLayer(
AudioLayer* /*audio_layer*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
webrtc::AudioDeviceModule::ErrorCode FakeAudioCaptureModule::LastError() const {
ASSERT(false);
RTC_NOTREACHED();
return webrtc::AudioDeviceModule::kAdmErrNone;
}
@ -125,17 +125,17 @@ int32_t FakeAudioCaptureModule::Terminate() {
}
bool FakeAudioCaptureModule::Initialized() const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int16_t FakeAudioCaptureModule::PlayoutDevices() {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int16_t FakeAudioCaptureModule::RecordingDevices() {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -143,7 +143,7 @@ int32_t FakeAudioCaptureModule::PlayoutDeviceName(
uint16_t /*index*/,
char /*name*/[webrtc::kAdmMaxDeviceNameSize],
char /*guid*/[webrtc::kAdmMaxGuidSize]) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -151,7 +151,7 @@ int32_t FakeAudioCaptureModule::RecordingDeviceName(
uint16_t /*index*/,
char /*name*/[webrtc::kAdmMaxDeviceNameSize],
char /*guid*/[webrtc::kAdmMaxGuidSize]) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -181,7 +181,7 @@ int32_t FakeAudioCaptureModule::SetRecordingDevice(
}
int32_t FakeAudioCaptureModule::PlayoutIsAvailable(bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -195,7 +195,7 @@ bool FakeAudioCaptureModule::PlayoutIsInitialized() const {
}
int32_t FakeAudioCaptureModule::RecordingIsAvailable(bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -205,8 +205,7 @@ int32_t FakeAudioCaptureModule::InitRecording() {
}
bool FakeAudioCaptureModule::RecordingIsInitialized() const {
ASSERT(false);
return 0;
return rec_is_initialized_;
}
int32_t FakeAudioCaptureModule::StartPlayout() {
@ -273,20 +272,20 @@ int32_t FakeAudioCaptureModule::SetAGC(bool /*enable*/) {
}
bool FakeAudioCaptureModule::AGC() const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetWaveOutVolume(uint16_t /*volume_left*/,
uint16_t /*volume_right*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::WaveOutVolume(
uint16_t* /*volume_left*/,
uint16_t* /*volume_right*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -296,7 +295,7 @@ int32_t FakeAudioCaptureModule::InitSpeaker() {
}
bool FakeAudioCaptureModule::SpeakerIsInitialized() const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -306,46 +305,46 @@ int32_t FakeAudioCaptureModule::InitMicrophone() {
}
bool FakeAudioCaptureModule::MicrophoneIsInitialized() const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerVolumeIsAvailable(bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetSpeakerVolume(uint32_t /*volume*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerVolume(uint32_t* /*volume*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MaxSpeakerVolume(
uint32_t* /*max_volume*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MinSpeakerVolume(
uint32_t* /*min_volume*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerVolumeStepSize(
uint16_t* /*step_size*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneVolumeIsAvailable(
bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -369,59 +368,59 @@ int32_t FakeAudioCaptureModule::MaxMicrophoneVolume(
int32_t FakeAudioCaptureModule::MinMicrophoneVolume(
uint32_t* /*min_volume*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneVolumeStepSize(
uint16_t* /*step_size*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerMuteIsAvailable(bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetSpeakerMute(bool /*enable*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerMute(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneMuteIsAvailable(bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetMicrophoneMute(bool /*enable*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneMute(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneBoostIsAvailable(
bool* /*available*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetMicrophoneBoost(bool /*enable*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneBoost(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -440,7 +439,7 @@ int32_t FakeAudioCaptureModule::SetStereoPlayout(bool /*enable*/) {
}
int32_t FakeAudioCaptureModule::StereoPlayout(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -459,7 +458,7 @@ int32_t FakeAudioCaptureModule::SetStereoRecording(bool enable) {
}
int32_t FakeAudioCaptureModule::StereoRecording(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -468,7 +467,7 @@ int32_t FakeAudioCaptureModule::SetRecordingChannel(
if (channel != AudioDeviceModule::kChannelBoth) {
// There is no right or left in mono. I.e. kChannelBoth should be used for
// mono.
ASSERT(false);
RTC_NOTREACHED();
return -1;
}
return 0;
@ -483,13 +482,13 @@ int32_t FakeAudioCaptureModule::RecordingChannel(ChannelType* channel) const {
int32_t FakeAudioCaptureModule::SetPlayoutBuffer(const BufferType /*type*/,
uint16_t /*size_ms*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::PlayoutBuffer(BufferType* /*type*/,
uint16_t* /*size_ms*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -500,73 +499,73 @@ int32_t FakeAudioCaptureModule::PlayoutDelay(uint16_t* delay_ms) const {
}
int32_t FakeAudioCaptureModule::RecordingDelay(uint16_t* /*delay_ms*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::CPULoad(uint16_t* /*load*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::StartRawOutputFileRecording(
const char /*pcm_file_name_utf8*/[webrtc::kAdmMaxFileNameSize]) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::StopRawOutputFileRecording() {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::StartRawInputFileRecording(
const char /*pcm_file_name_utf8*/[webrtc::kAdmMaxFileNameSize]) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::StopRawInputFileRecording() {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetRecordingSampleRate(
const uint32_t /*samples_per_sec*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::RecordingSampleRate(
uint32_t* /*samples_per_sec*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetPlayoutSampleRate(
const uint32_t /*samples_per_sec*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::PlayoutSampleRate(
uint32_t* /*samples_per_sec*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::ResetAudioDevice() {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::SetLoudspeakerStatus(bool /*enable*/) {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
int32_t FakeAudioCaptureModule::GetLoudspeakerStatus(bool* /*enabled*/) const {
ASSERT(false);
RTC_NOTREACHED();
return 0;
}
@ -581,7 +580,7 @@ void FakeAudioCaptureModule::OnMessage(rtc::Message* msg) {
default:
// All existing messages should be caught. Getting here should never
// happen.
ASSERT(false);
RTC_NOTREACHED();
}
}
@ -591,7 +590,7 @@ bool FakeAudioCaptureModule::Initialize() {
// sent to it. Note that the audio processing pipeline will likely distort the
// original signal.
SetSendBuffer(kHighSampleValue);
last_process_time_ms_ = rtc::Time();
last_process_time_ms_ = rtc::TimeMillis();
return true;
}
@ -639,7 +638,7 @@ void FakeAudioCaptureModule::UpdateProcessing(bool start) {
}
void FakeAudioCaptureModule::StartProcessP() {
ASSERT(process_thread_->IsCurrent());
RTC_CHECK(process_thread_->IsCurrent());
if (started_) {
// Already started.
return;
@ -648,9 +647,9 @@ void FakeAudioCaptureModule::StartProcessP() {
}
void FakeAudioCaptureModule::ProcessFrameP() {
ASSERT(process_thread_->IsCurrent());
RTC_CHECK(process_thread_->IsCurrent());
if (!started_) {
next_frame_time_ = rtc::Time();
next_frame_time_ = rtc::TimeMillis();
started_ = true;
}
@ -666,14 +665,14 @@ void FakeAudioCaptureModule::ProcessFrameP() {
}
next_frame_time_ += kTimePerFrameMs;
const uint32_t current_time = rtc::Time();
const uint32_t wait_time =
const int64_t current_time = rtc::TimeMillis();
const int64_t wait_time =
(next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
process_thread_->PostDelayed(RTC_FROM_HERE, wait_time, this, MSG_RUN_PROCESS);
}
void FakeAudioCaptureModule::ReceiveFrameP() {
ASSERT(process_thread_->IsCurrent());
RTC_CHECK(process_thread_->IsCurrent());
{
rtc::CritScope cs(&crit_callback_);
if (!audio_callback_) {
@ -687,9 +686,9 @@ void FakeAudioCaptureModule::ReceiveFrameP() {
kNumberOfChannels, kSamplesPerSecond,
rec_buffer_, nSamplesOut,
&elapsed_time_ms, &ntp_time_ms) != 0) {
ASSERT(false);
RTC_NOTREACHED();
}
ASSERT(nSamplesOut == kNumberSamples);
RTC_CHECK(nSamplesOut == kNumberSamples);
}
// The SetBuffer() function ensures that after decoding, the audio buffer
// should contain samples of similar magnitude (there is likely to be some
@ -704,7 +703,7 @@ void FakeAudioCaptureModule::ReceiveFrameP() {
}
void FakeAudioCaptureModule::SendFrameP() {
ASSERT(process_thread_->IsCurrent());
RTC_CHECK(process_thread_->IsCurrent());
rtc::CritScope cs(&crit_callback_);
if (!audio_callback_) {
return;
@ -719,8 +718,7 @@ void FakeAudioCaptureModule::SendFrameP() {
kClockDriftMs, current_mic_level,
key_pressed,
current_mic_level) != 0) {
ASSERT(false);
RTC_NOTREACHED();
}
SetMicrophoneVolume(current_mic_level);
}

33
src/fakeaudiocapturemodule.h
View File

@ -17,10 +17,11 @@
// Note P postfix of a function indicates that it should only be called by the
// processing thread.
#ifndef WEBRTC_API_TEST_FAKEAUDIOCAPTUREMODULE_H_
#define WEBRTC_API_TEST_FAKEAUDIOCAPTUREMODULE_H_
#ifndef _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
#define _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_
#include <memory>
#include "webrtc/base/basictypes.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/messagehandler.h"
@ -172,12 +173,22 @@ class FakeAudioCaptureModule
int32_t ResetAudioDevice() override;
int32_t SetLoudspeakerStatus(bool enable) override;
int32_t GetLoudspeakerStatus(bool* enabled) const override;
virtual bool BuiltInAECIsAvailable() const override { return false; }
virtual int32_t EnableBuiltInAEC(bool enable) override { return -1; }
virtual bool BuiltInAGCIsAvailable() const override { return false; }
virtual int32_t EnableBuiltInAGC(bool enable) override { return -1; }
virtual bool BuiltInNSIsAvailable() const override { return false; }
virtual int32_t EnableBuiltInNS(bool enable) override { return -1; }
bool BuiltInAECIsAvailable() const override { return false; }
int32_t EnableBuiltInAEC(bool enable) override { return -1; }
bool BuiltInAGCIsAvailable() const override { return false; }
int32_t EnableBuiltInAGC(bool enable) override { return -1; }
bool BuiltInNSIsAvailable() const override { return false; }
int32_t EnableBuiltInNS(bool enable) override { return -1; }
#if defined(WEBRTC_IOS)
int GetPlayoutAudioParameters(
webrtc::AudioParameters* params) const override {
return -1;
}
int GetRecordAudioParameters(webrtc::AudioParameters* params) const override {
return -1;
}
#endif // WEBRTC_IOS
// End of functions inherited from webrtc::AudioDeviceModule.
// The following function is inherited from rtc::MessageHandler.
@ -225,7 +236,7 @@ class FakeAudioCaptureModule
// The time in milliseconds when Process() was last called or 0 if no call
// has been made.
uint32_t last_process_time_ms_;
int64_t last_process_time_ms_;
// Callback for playout and recording.
webrtc::AudioTransport* audio_callback_;
@ -245,7 +256,7 @@ class FakeAudioCaptureModule
// wall clock time the next frame should be generated and received. started_
// ensures that next_frame_time_ can be initialized properly on first call.
bool started_;
uint32_t next_frame_time_;
int64_t next_frame_time_;
std::unique_ptr<rtc::Thread> process_thread_;
@ -267,4 +278,4 @@ class FakeAudioCaptureModule
rtc::CriticalSection crit_callback_;
};
#endif // WEBRTC_API_TEST_FAKEAUDIOCAPTUREMODULE_H_
#endif // _PEERCONNECT_PC_TEST_FAKEAUDIOCAPTUREMODULE_H_

49
src/logging.cc
View File

@ -119,7 +119,7 @@ CriticalSection g_log_crit;
// The list of logging streams currently configured.
// Note: we explicitly do not clean this up, because of the uncertain ordering
// of destructors at program exit. Let the person who sets the stream trigger
// cleanup by setting to NULL, or let it leak (safe at program exit).
// cleanup by setting to null, or let it leak (safe at program exit).
LogMessage::StreamList LogMessage::streams_ GUARDED_BY(g_log_crit);
// Boolean options default to false (0)
@ -133,7 +133,9 @@ LogMessage::LogMessage(const char* file,
const char* module)
: severity_(sev), tag_(kLibjingle) {
if (timestamp_) {
int64_t time = TimeSince(LogStartTime());
// Use SystemTimeMillis so that even if tests use fake clocks, the timestamp
// in log messages represents the real system time.
int64_t time = TimeDiff(SystemTimeMillis(), LogStartTime());
// Also ensure WallClockStartTime is initialized, so that it matches
// LogStartTime.
WallClockStartTime();
@ -147,7 +149,7 @@ LogMessage::LogMessage(const char* file,
print_stream_ << "[" << std::dec << id << "] ";
}
if (file != NULL)
if (file != nullptr)
print_stream_ << "(" << FilenameFromPath(file) << ":" << line << "): ";
if (err_ctx != ERRCTX_NONE) {
@ -157,7 +159,7 @@ LogMessage::LogMessage(const char* file,
case ERRCTX_ERRNO:
tmp << " " << strerror(err);
break;
#if WEBRTC_WIN
#ifdef WEBRTC_WIN
case ERRCTX_HRESULT: {
char msgbuf[256];
DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM;
@ -165,9 +167,8 @@ LogMessage::LogMessage(const char* file,
if (hmod)
flags |= FORMAT_MESSAGE_FROM_HMODULE;
if (DWORD len = FormatMessageA(
flags, hmod, err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), NULL)) {
flags, hmod, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) {
while ((len > 0) &&
isspace(static_cast<unsigned char>(msgbuf[len-1]))) {
msgbuf[--len] = 0;
@ -179,9 +180,8 @@ LogMessage::LogMessage(const char* file,
#endif // WEBRTC_WIN
#if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS)
case ERRCTX_OSSTATUS: {
// PeerConnect don't need this.
// std::string desc(DescriptionFromOSStatus(err));
// tmp << " " << (desc.empty() ? "Unknown error" : desc.c_str());
// std::string desc(DescriptionFromOSStatus(err));
// tmp << " " << (desc.empty() ? "Unknown error" : desc.c_str());
break;
}
#endif // WEBRTC_MAC && !defined(WEBRTC_IOS)
@ -196,7 +196,12 @@ LogMessage::LogMessage(const char* file,
int line,
LoggingSeverity sev,
const std::string& tag)
: LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */, NULL /* module */) {
: LogMessage(file,
line,
sev,
ERRCTX_NONE,
0 /* err */,
nullptr /* module */) {
tag_ = tag;
print_stream_ << tag << ": ";
}
@ -220,12 +225,12 @@ LogMessage::~LogMessage() {
}
int64_t LogMessage::LogStartTime() {
static const int64_t g_start = TimeMillis();
static const int64_t g_start = SystemTimeMillis();
return g_start;
}
uint32_t LogMessage::WallClockStartTime() {
static const uint32_t g_start_wallclock = time(NULL);
static const uint32_t g_start_wallclock = time(nullptr);
return g_start_wallclock;
}
@ -357,7 +362,7 @@ void LogMessage::OutputToDebug(const std::string& str,
"logToStdErr",
kCFStringEncodingUTF8);
CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
if (key != NULL && domain != NULL) {
if (key != nullptr && domain != nullptr) {
Boolean exists_and_is_valid;
Boolean should_log =
CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid);
@ -365,7 +370,7 @@ void LogMessage::OutputToDebug(const std::string& str,
// stderr.
log_to_stderr = exists_and_is_valid && should_log;
}
if (key != NULL) {
if (key != nullptr) {
CFRelease(key);
}
#endif
@ -446,15 +451,15 @@ void LogMessage::OutputToDebug(const std::string& str,
void LogMultiline(LoggingSeverity level, const char* label, bool input,
const void* data, size_t len, bool hex_mode,
LogMultilineState* state) {
if (!LOGP_CHECK_LEVEL_V(level))
if (!LOG_CHECK_LEVEL_V(level))
return;
const char * direction = (input ? " << " : " >> ");
// NULL data means to flush our count of unprintable characters.
// null data means to flush our count of unprintable characters.
if (!data) {
if (state && state->unprintable_count_[input]) {
LOGP_V(level) << label << direction << "## "
LOG_V(level) << label << direction << "## "
<< state->unprintable_count_[input]
<< " consecutive unprintable ##";
state->unprintable_count_[input] = 0;
@ -480,7 +485,7 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
}
asc_line[sizeof(asc_line)-1] = 0;
hex_line[sizeof(hex_line)-1] = 0;
LOGP_V(level) << label << direction
LOG_V(level) << label << direction
<< asc_line << " " << hex_line << " ";
udata += line_len;
len -= line_len;
@ -534,7 +539,7 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
// Print out the current line, but prefix with a count of prior unprintable
// characters.
if (consecutive_unprintable) {
LOGP_V(level) << label << direction << "## " << consecutive_unprintable
LOG_V(level) << label << direction << "## " << consecutive_unprintable
<< " consecutive unprintable ##";
consecutive_unprintable = 0;
}
@ -549,9 +554,9 @@ void LogMultiline(LoggingSeverity level, const char* label, bool input,
pos_private = substr.find("Passwd");
}
if (pos_private == std::string::npos) {
LOGP_V(level) << label << direction << substr;
LOG_V(level) << label << direction << substr;
} else {
LOGP_V(level) << label << direction << "## omitted for privacy ##";
LOG_V(level) << label << direction << "## omitted for privacy ##";
}
}

140
src/logging.h
View File

@ -14,7 +14,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// LOGP(...) an ostream target that can be used to send formatted
// LOG(...) an ostream target that can be used to send formatted
// output to a variety of logging targets, such as debugger console, stderr,
// or any LogSink.
// The severity level passed as the first argument to the LOGging
@ -24,30 +24,30 @@
// There are several variations on the LOG macro which facilitate logging
// of common error conditions, detailed below.
// LOGP(sev) logs the given stream at severity "sev", which must be a
// LOG(sev) logs the given stream at severity "sev", which must be a
// compile-time constant of the LoggingSeverity type, without the namespace
// prefix.
// LOGP_V(sev) Like LOGP(), but sev is a run-time variable of the LoggingSeverity
// LOG_V(sev) Like LOG(), but sev is a run-time variable of the LoggingSeverity
// type (basically, it just doesn't prepend the namespace).
// LOGP_F(sev) Like LOGP(), but includes the name of the current function.
// LOGP_T(sev) Like LOGP(), but includes the this pointer.
// LOGP_T_F(sev) Like LOGP_F(), but includes the this pointer.
// LOGP_GLE(M)(sev [, mod]) attempt to add a string description of the
// LOG_F(sev) Like LOG(), but includes the name of the current function.
// LOG_T(sev) Like LOG(), but includes the this pointer.
// LOG_T_F(sev) Like LOG_F(), but includes the this pointer.
// LOG_GLE(M)(sev [, mod]) attempt to add a string description of the
// HRESULT returned by GetLastError. The "M" variant allows searching of a
// DLL's string table for the error description.
// LOGP_ERRNO(sev) attempts to add a string description of an errno-derived
// LOG_ERRNO(sev) attempts to add a string description of an errno-derived
// error. errno and associated facilities exist on both Windows and POSIX,
// but on Windows they only apply to the C/C++ runtime.
// LOGP_ERR(sev) is an alias for the platform's normal error system, i.e. _GLE on
// LOG_ERR(sev) is an alias for the platform's normal error system, i.e. _GLE on
// Windows and _ERRNO on POSIX.
// (The above three also all have _EX versions that let you specify the error
// code, rather than using the last one.)
// LOGP_E(sev, ctx, err, ...) logs a detailed error interpreted using the
// LOG_E(sev, ctx, err, ...) logs a detailed error interpreted using the
// specified context.
// LOGP_CHECK_LEVEL(sev) (and LOGP_CHECK_LEVEL_V(sev)) can be used as a test
// LOG_CHECK_LEVEL(sev) (and LOG_CHECK_LEVEL_V(sev)) can be used as a test
// before performing expensive or sensitive operations whose sole purpose is
// to output logging data at the desired level.
// Lastly, PLOGP(sev, err) is an alias for LOGP_ERR_EX.
// Lastly, PLOG(sev, err) is an alias for LOG_ERR_EX.
#ifndef __PEERCONNECT_LOGGING_H__
#define __PEERCONNECT_LOGGING_H__
@ -81,16 +81,13 @@ namespace pc {
// }
//
// int err = LibraryFunc();
// LOGP(LS_ERROR) << "LibraryFunc returned: "
// LOG(LS_ERROR) << "LibraryFunc returned: "
// << ErrorName(err, LIBRARY_ERRORS);
struct ConstantLabel { int value; const char * label; };
#ifndef KLABEL
#define KLABEL(x) { x, #x }
#define TLABEL(x, y) { x, y }
#define LASTLABEL { 0, 0 }
#endif
const char* FindLabel(int value, const ConstantLabel entries[]);
std::string ErrorName(int err, const ConstantLabel* err_table);
@ -148,9 +145,12 @@ class LogSink {
class LogMessage {
public:
LogMessage(const char* file, int line, LoggingSeverity sev,
LogErrorContext err_ctx = ERRCTX_NONE, int err = 0,
const char* module = NULL);
LogMessage(const char* file,
int line,
LoggingSeverity sev,
LogErrorContext err_ctx = ERRCTX_NONE,
int err = 0,
const char* module = nullptr);
LogMessage(const char* file,
int line,
@ -194,7 +194,7 @@ class LogMessage {
// GetLogToStream gets the severity for the specified stream, of if none
// is specified, the minimum stream severity.
// RemoveLogToStream removes the specified stream, without destroying it.
static int GetLogToStream(LogSink* stream = NULL);
static int GetLogToStream(LogSink* stream = nullptr);
static void AddLogToStream(LogSink* stream, LoggingSeverity min_sev);
static void RemoveLogToStream(LogSink* stream);
@ -263,12 +263,12 @@ class LogMultilineState {
};
// When possible, pass optional state variable to track various data across
// multiple calls to LogMultiline. Otherwise, pass NULL.
// multiple calls to LogMultiline. Otherwise, pass null.
void LogMultiline(LoggingSeverity level, const char* label, bool input,
const void* data, size_t len, bool hex_mode,
LogMultilineState* state);
#ifndef LOGP
#ifndef LOG
// The following non-obvious technique for implementation of a
// conditional log stream was stolen from google3/base/logging.h.
@ -285,101 +285,91 @@ class LogMessageVoidify {
void operator&(std::ostream&) { }
};
#define LOGP_SEVERITY_PRECONDITION(sev) \
#define LOG_SEVERITY_PRECONDITION(sev) \
!(pc::LogMessage::Loggable(sev)) \
? (void) 0 \
: pc::LogMessageVoidify() &
#define LOGP(sev) \
LOGP_SEVERITY_PRECONDITION(pc::sev) \
#define LOG(sev) \
LOG_SEVERITY_PRECONDITION(pc::sev) \
pc::LogMessage(__FILE__, __LINE__, pc::sev).stream()
#define LOGP_IF(cond, sev) \
!(cond) \
? (void) 0 \
: LOGP(sev)
#define LOGP_F_IF(cond, sev) \
!(cond) \
? (void) 0 \
: LOGP_F(sev)
// The _V version is for when a variable is passed in. It doesn't do the
// namespace concatination.
#define LOGP_V(sev) \
LOGP_SEVERITY_PRECONDITION(sev) \
#define LOG_V(sev) \
LOG_SEVERITY_PRECONDITION(sev) \
pc::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)
#define LOGP_F(sev) LOGP(sev) << __PRETTY_FUNCTION__ << ": "
#define LOGP_T_F(sev) LOGP(sev) << this << ": " << __PRETTY_FUNCTION__ << ": "
#define LOG_F(sev) LOG(sev) << __PRETTY_FUNCTION__ << ": "
#define LOG_T_F(sev) LOG(sev) << this << ": " << __PRETTY_FUNCTION__ << ": "
#else
#define LOGP_F(sev) LOGP(sev) << __FUNCTION__ << ": "
#define LOGP_T_F(sev) LOGP(sev) << this << ": " << __FUNCTION__ << ": "
#define LOG_F(sev) LOG(sev) << __FUNCTION__ << ": "
#define LOG_T_F(sev) LOG(sev) << this << ": " << __FUNCTION__ << ": "
#endif
#define LOGP_CHECK_LEVEL(sev) \
#define LOG_CHECK_LEVEL(sev) \
pc::LogCheckLevel(pc::sev)
#define LOGP_CHECK_LEVEL_V(sev) \
#define LOG_CHECK_LEVEL_V(sev) \
pc::LogCheckLevel(sev)
inline bool LogCheckLevel(LoggingSeverity sev) {
return (LogMessage::GetMinLogSeverity() <= sev);
}
#define LOGP_E(sev, ctx, err, ...) \
LOGP_SEVERITY_PRECONDITION(pc::sev) \
#define LOG_E(sev, ctx, err, ...) \
LOG_SEVERITY_PRECONDITION(pc::sev) \
pc::LogMessage(__FILE__, __LINE__, pc::sev, \
pc::ERRCTX_ ## ctx, err , ##__VA_ARGS__) \
.stream()
#define LOGP_T(sev) LOGP(sev) << this << ": "
#define LOG_T(sev) LOG(sev) << this << ": "
#define LOGP_ERRNO_EX(sev, err) \
LOGP_E(sev, ERRNO, err)
#define LOGP_ERRNO(sev) \
LOGP_ERRNO_EX(sev, errno)
#define LOG_ERRNO_EX(sev, err) \
LOG_E(sev, ERRNO, err)
#define LOG_ERRNO(sev) \
LOG_ERRNO_EX(sev, errno)
#if defined(WEBRTC_WIN)
#define LOGP_GLE_EX(sev, err) \
LOGP_E(sev, HRESULT, err)
#define LOGP_GLE(sev) \
LOGP_GLE_EX(sev, GetLastError())
#define LOGP_GLEM(sev, mod) \
LOGP_E(sev, HRESULT, GetLastError(), mod)
#define LOGP_ERR_EX(sev, err) \
LOGP_GLE_EX(sev, err)
#define LOGP_ERR(sev) \
LOGP_GLE(sev)
#define LOG_GLE_EX(sev, err) \
LOG_E(sev, HRESULT, err)
#define LOG_GLE(sev) \
LOG_GLE_EX(sev, GetLastError())
#define LOG_GLEM(sev, mod) \
LOG_E(sev, HRESULT, GetLastError(), mod)
#define LOG_ERR_EX(sev, err) \
LOG_GLE_EX(sev, err)
#define LOG_ERR(sev) \
LOG_GLE(sev)
#define LAST_SYSTEM_ERROR \
(::GetLastError())
#elif __native_client__
#define LOGP_ERR_EX(sev, err) \
LOGP(sev)
#define LOGP_ERR(sev) \
LOGP(sev)
#elif defined(__native_client__) && __native_client__
#define LOG_ERR_EX(sev, err) \
LOG(sev)
#define LOG_ERR(sev) \
LOG(sev)
#define LAST_SYSTEM_ERROR \
(0)
#elif defined(WEBRTC_POSIX)
#define LOGP_ERR_EX(sev, err) \
LOGP_ERRNO_EX(sev, err)
#define LOGP_ERR(sev) \
LOGP_ERRNO(sev)
#define LOG_ERR_EX(sev, err) \
LOG_ERRNO_EX(sev, err)
#define LOG_ERR(sev) \
LOG_ERRNO(sev)
#define LAST_SYSTEM_ERROR \
(errno)
#endif // WEBRTC_WIN
#define LOGP_TAG(sev, tag) \
LOGP_SEVERITY_PRECONDITION(sev) \
pc::LogMessage(NULL, 0, sev, tag).stream()
#define LOG_TAG(sev, tag) \
LOG_SEVERITY_PRECONDITION(sev) \
pc::LogMessage(nullptr, 0, sev, tag).stream()
#define PLOGP(sev, err) \
LOGP_ERR_EX(sev, err)
#define PLOG(sev, err) \
LOG_ERR_EX(sev, err)
// TODO(?): Add an "assert" wrapper that logs in the same manner.
#endif // LOGP
#endif // LOG
} // namespace pc

132
src/peer.cc
View File

@ -7,7 +7,7 @@
#include "control.h"
#include "peer.h"
#include "webrtc/api/test/fakeconstraints.h"
#include "webrtc/api/test/mockpeerconnectionobservers.h"
#include "webrtc/pc/test/mockpeerconnectionobservers.h"
#include "logging.h"
@ -31,16 +31,16 @@ PeerControl::PeerControl(const string local_id,
}
PeerControl::~PeerControl() {
ASSERT(state_ == pClosed);
RTC_DCHECK(state_ == pClosed);
DeletePeerConnection();
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
bool PeerControl::Initialize() {
if (!CreatePeerConnection()) {
LOGP_F(LS_ERROR) << "CreatePeerConnection failed";
LOG_F(LS_ERROR) << "CreatePeerConnection failed";
DeletePeerConnection();
return false;
}
@ -48,20 +48,20 @@ bool PeerControl::Initialize() {
webrtc::DataChannelInit init;
const string data_channel_name = string("pc_data_") + remote_id_;
if (!CreateDataChannel(data_channel_name, init)) {
LOGP_F(LS_ERROR) << "CreateDataChannel failed";
LOG_F(LS_ERROR) << "CreateDataChannel failed";
DeletePeerConnection();
return false;
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
return true;
}
bool PeerControl::Send(const char* buffer, const size_t size) {
ASSERT( state_ == pOpen );
RTC_DCHECK( state_ == pOpen );
if ( state_ != pOpen ) {
LOGP_F( WARNING ) << "Send data when a peer state is not opened";
LOG_F( WARNING ) << "Send data when a peer state is not opened";
return false;
}
@ -69,10 +69,10 @@ bool PeerControl::Send(const char* buffer, const size_t size) {
}
bool PeerControl::SyncSend(const char* buffer, const size_t size) {
ASSERT( state_ == pOpen );
RTC_DCHECK( state_ == pOpen );
if ( state_ != pOpen ) {
LOGP_F( WARNING ) << "Send data when a peer state is not opened";
LOG_F( WARNING ) << "Send data when a peer state is not opened";
return false;
}
@ -82,7 +82,7 @@ bool PeerControl::SyncSend(const char* buffer, const size_t size) {
bool PeerControl::IsWritable() {
if ( state_ != pOpen ) {
LOGP_F( WARNING ) << "A function was called when a peer state is not opened";
LOG_F( WARNING ) << "A function was called when a peer state is not opened";
return false;
}
@ -90,16 +90,16 @@ bool PeerControl::IsWritable() {
}
void PeerControl::Close(const CloseCode code) {
LOGP_F_IF(state_ != pOpen, WARNING) << "Closing peer when it is not opened";
// LOG_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";
LOG_F( WARNING ) << "Close peer when is closing or already closed";
return;
}
state_ = pClosing;
LOGP_F( INFO ) << "Close data-channel of remote_id_ " << remote_id_;
LOG_F( INFO ) << "Close data-channel of remote_id_ " << remote_id_;
if ( peer_connection_ ) {
@ -120,45 +120,45 @@ void PeerControl::Close(const CloseCode code) {
void PeerControl::CreateOffer(const webrtc::MediaConstraintsInterface* constraints) {
ASSERT( state_ == pClosed );
RTC_DCHECK( state_ == pClosed );
state_ = pConnecting;
peer_connection_->CreateOffer(this, constraints);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::CreateAnswer(const webrtc::MediaConstraintsInterface* constraints) {
ASSERT( state_ == pClosed );
RTC_DCHECK( state_ == pClosed );
state_ = pConnecting;
peer_connection_->CreateAnswer(this, constraints);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::ReceiveOfferSdp(const string& sdp) {
ASSERT( state_ == pClosed);
RTC_DCHECK( state_ == pClosed);
SetRemoteDescription(webrtc::SessionDescriptionInterface::kOffer, sdp);
CreateAnswer(NULL);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::ReceiveAnswerSdp(const string& sdp) {
ASSERT( state_ == pConnecting );
RTC_DCHECK( state_ == pConnecting );
SetRemoteDescription(webrtc::SessionDescriptionInterface::kAnswer, sdp);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::OnDataChannel(webrtc::DataChannelInterface* data_channel) {
LOGP_F( INFO ) << "remote_id_ is " << remote_id_;
void PeerControl::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
LOG_F( INFO ) << "remote_id_ is " << remote_id_;
PeerDataChannelObserver* Observer = new PeerDataChannelObserver(data_channel);
PeerDataChannelObserver* Observer = new PeerDataChannelObserver(channel);
remote_data_channel_ = std::unique_ptr<PeerDataChannelObserver>(Observer);
Attach(remote_data_channel_.get());
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
@ -178,7 +178,7 @@ void PeerControl::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConn
// Ice connection has been closed.
// Notify it to Control so the Control will remove peer in peers_
//
LOGP_F( INFO ) << "new_state is " << "kIceConnectionClosed";
LOG_F( INFO ) << "new_state is " << "kIceConnectionClosed";
OnPeerDisconnected();
break;
@ -186,23 +186,23 @@ void PeerControl::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConn
//
// Peer disconnected and notify it to control that makes control trigger closing
//
LOGP_F( INFO ) << "new_state is " << "kIceConnectionDisconnected";
LOG_F( INFO ) << "new_state is " << "kIceConnectionDisconnected";
OnPeerDisconnected();
break;
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionNew:
LOGP_F( INFO ) << "new_state is " << "kIceConnectionNew";
LOG_F( INFO ) << "new_state is " << "kIceConnectionNew";
break;
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionChecking:
LOGP_F( INFO ) << "new_state is " << "kIceConnectionChecking";
LOG_F( INFO ) << "new_state is " << "kIceConnectionChecking";
break;
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionConnected:
LOGP_F( INFO ) << "new_state is " << "kIceConnectionConnected";
LOG_F( INFO ) << "new_state is " << "kIceConnectionConnected";
break;
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionCompleted:
LOGP_F( INFO ) << "new_state is " << "kIceConnectionCompleted";
LOG_F( INFO ) << "new_state is " << "kIceConnectionCompleted";
break;
case webrtc::PeerConnectionInterface::IceConnectionState::kIceConnectionFailed:
LOGP_F( INFO ) << "new_state is " << "kIceConnectionFailed";
LOG_F( INFO ) << "new_state is " << "kIceConnectionFailed";
break;
default:
break;
@ -221,7 +221,7 @@ void PeerControl::OnIceCandidate(const webrtc::IceCandidateInterface* candidate)
data["candidate"] = sdp;
control_->SendCommand(remote_id_, "ice_candidate", data);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
@ -233,7 +233,7 @@ void PeerControl::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
if (!desc->ToString(&sdp)) return;
if ( state_ != pConnecting ) {
LOGP_F( WARNING ) << "Invalid state";
LOG_F( WARNING ) << "Invalid state";
return;
}
@ -252,7 +252,7 @@ void PeerControl::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
data["sdp"] = sdp;
control_->SendCommand(remote_id_, "answersdp", data);
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::OnPeerOpened() {
@ -263,7 +263,7 @@ void PeerControl::OnPeerOpened() {
remote_data_channel_->state() == webrtc::DataChannelInterface::DataState::kOpen
) {
LOG_F( INFO ) << "Peers are connected, " << remote_id_ << " and " << local_id_;
ASSERT( state_ == pConnecting );
RTC_DCHECK( state_ == pConnecting );
// Fianlly, data-channel has been opened.
state_ = pOpen;
@ -271,17 +271,17 @@ void PeerControl::OnPeerOpened() {
control_->OnPeerWritable(local_id_);
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::OnPeerDisconnected() {
if ( state_ == pClosed ) {
LOGP_F( WARNING ) << "Already closed";
LOG_F( WARNING ) << "Already closed";
return;
}
else if ( state_ == pClosing ) {
LOGP_F( INFO ) << "Already closing";
LOG_F( INFO ) << "Already closing";
return;
}
@ -302,7 +302,7 @@ void PeerControl::OnPeerMessage(const webrtc::DataBuffer& buffer) {
void PeerControl::OnBufferedAmountChange(const uint64_t previous_amount) {
if ( !local_data_channel_->IsWritable() ) {
LOGP_F( LERROR ) << "local_data_channel_ is not writable";
LOG_F( LERROR ) << "local_data_channel_ is not writable";
return;
}
control_->OnPeerWritable( remote_id_ );
@ -317,19 +317,19 @@ bool PeerControl::CreateDataChannel(
data_channel = peer_connection_->CreateDataChannel(label, &init);
if (data_channel.get() == nullptr) {
LOGP_F( LERROR ) << "data_channel is null";
LOG_F( LERROR ) << "data_channel is null";
return false;
}
local_data_channel_.reset(new PeerDataChannelObserver(data_channel));
if (local_data_channel_.get() == NULL) {
LOGP_F( LERROR ) << "local_data_channel_ is null";
LOG_F( LERROR ) << "local_data_channel_ is null";
return false;
}
Attach(local_data_channel_.get());
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
return true;
}
@ -340,13 +340,13 @@ void PeerControl::AddIceCandidate(const string& sdp_mid, int sdp_mline_index,
webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, candidate, NULL));
peer_connection_->AddIceCandidate(owned_candidate.get());
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
bool PeerControl::CreatePeerConnection() {
ASSERT(peer_connection_factory_.get() != NULL);
ASSERT(peer_connection_.get() == NULL);
RTC_DCHECK(peer_connection_factory_.get() != NULL);
RTC_DCHECK(peer_connection_.get() == NULL);
// Enable DTLS
webrtc::FakeConstraints constraints;
@ -362,7 +362,7 @@ bool PeerControl::CreatePeerConnection() {
config, &constraints, NULL, NULL, this);
if ( peer_connection_.get() == nullptr ) {
LOGP_F( LERROR ) << "peer_connection is null";
LOG_F( LERROR ) << "peer_connection is null";
return false;
}
@ -378,14 +378,14 @@ void PeerControl::DeletePeerConnection() {
peer_connection_ = NULL;
peer_connection_factory_ = NULL;
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::SetLocalDescription(const string& type,
const string& sdp) {
if ( peer_connection_ == nullptr ) {
LOGP_F( LERROR ) << "peer_connection_ is nullptr";
LOG_F( LERROR ) << "peer_connection_ is nullptr";
return;
}
@ -395,7 +395,7 @@ void PeerControl::SetLocalDescription(const string& type,
peer_connection_->SetLocalDescription(
observer, webrtc::CreateSessionDescription(type, sdp, NULL));
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::SetRemoteDescription(const string& type,
@ -407,12 +407,12 @@ void PeerControl::SetRemoteDescription(const string& type,
peer_connection_->SetRemoteDescription(
observer, webrtc::CreateSessionDescription(type, sdp, NULL));
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::Attach(PeerDataChannelObserver* datachannel) {
if (datachannel == nullptr) {
LOGP_F(WARNING) << "Attach to nullptr";
LOG_F(WARNING) << "Attach to nullptr";
return;
}
@ -420,12 +420,12 @@ void PeerControl::Attach(PeerDataChannelObserver* datachannel) {
datachannel->SignalOnDisconnected_.connect(this, &PeerControl::OnPeerDisconnected);
datachannel->SignalOnMessage_.connect(this, &PeerControl::OnPeerMessage);
datachannel->SignalOnBufferedAmountChange_.connect(this, &PeerControl::OnBufferedAmountChange);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerControl::Detach(PeerDataChannelObserver* datachannel) {
if (datachannel == nullptr) {
LOGP_F(WARNING) << "Detach from nullptr";
LOG_F(WARNING) << "Detach from nullptr";
return;
}
@ -433,7 +433,7 @@ void PeerControl::Detach(PeerDataChannelObserver* datachannel) {
datachannel->SignalOnDisconnected_.disconnect(this);
datachannel->SignalOnMessage_.disconnect(this);
datachannel->SignalOnBufferedAmountChange_.disconnect(this);
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
@ -446,14 +446,14 @@ PeerDataChannelObserver::PeerDataChannelObserver(webrtc::DataChannelInterface* c
: channel_(channel) {
channel_->RegisterObserver(this);
state_ = channel_->state();
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
PeerDataChannelObserver::~PeerDataChannelObserver() {
channel_->Close();
state_ = channel_->state();
channel_->UnregisterObserver();
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerDataChannelObserver::OnBufferedAmountChange(uint64_t previous_amount) {
@ -470,11 +470,11 @@ void PeerDataChannelObserver::OnBufferedAmountChange(uint64_t previous_amount) {
void PeerDataChannelObserver::OnStateChange() {
state_ = channel_->state();
if (state_ == webrtc::DataChannelInterface::DataState::kOpen) {
LOGP_F( INFO ) << "Data channel internal state is kOpen";
LOG_F( INFO ) << "Data channel internal state is kOpen";
SignalOnOpen_();
}
else if (state_ == webrtc::DataChannelInterface::DataState::kClosed) {
LOGP_F( INFO ) << "Data channel internal state is kClosed";
LOG_F( INFO ) << "Data channel internal state is kClosed";
SignalOnDisconnected_();
}
}
@ -488,7 +488,7 @@ bool PeerDataChannelObserver::Send(const char* buffer, const size_t size) {
webrtc::DataBuffer databuffer(rtcbuffer, true);
if ( channel_->buffered_amount() >= max_buffer_size_ ) {
LOGP_F( LERROR ) << "Buffer is full";
LOG_F( LERROR ) << "Buffer is full";
return false;
}
@ -504,7 +504,7 @@ bool PeerDataChannelObserver::SyncSend(const char* buffer, const size_t size) {
if (!send_cv_.wait_for(lock, std::chrono::milliseconds(60*1000),
[this] () { return channel_->buffered_amount() == 0; })) {
LOGP_F( LERROR ) << "Buffer is full";
LOG_F( LERROR ) << "Buffer is full";
return false;
}
@ -512,7 +512,7 @@ bool PeerDataChannelObserver::SyncSend(const char* buffer, const size_t size) {
}
void PeerDataChannelObserver::Close() {
LOGP_F(LS_INFO) << "Closing data channel";
LOG_F(LS_INFO) << "Closing data channel";
if (channel_->state() != webrtc::DataChannelInterface::kClosing) {
channel_->Close();
}
@ -529,17 +529,17 @@ uint64_t PeerDataChannelObserver::BufferedAmount() {
bool PeerDataChannelObserver::IsWritable() {
if ( channel_ == nullptr ) {
LOGP_F( LERROR ) << "channel_ is null";
LOG_F( LERROR ) << "channel_ is null";
return false;
}
if ( !IsOpen() ) {
LOGP_F( LERROR ) << "data channel is not opened";
LOG_F( LERROR ) << "data channel is not opened";
return false;
}
if ( channel_->buffered_amount() > 0 ) {
LOGP_F( LERROR ) << "buffer is full";
LOG_F( LERROR ) << "buffer is full";
return false;
}

6
src/peer.h
View File

@ -94,9 +94,9 @@ public:
//
void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) override;
void OnAddStream(webrtc::MediaStreamInterface* stream) override {};
void OnRemoveStream(webrtc::MediaStreamInterface* stream) override {}
void OnDataChannel(webrtc::DataChannelInterface* channel) override;
void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override {};
void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> channel) override;
void OnRenegotiationNeeded() override {}
void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) override {}

46
src/peerconnect.cc
View File

@ -35,28 +35,28 @@ PeerConnect::PeerConnect( const string peer ) {
peer_ = local_peer;
close_once_ = false;
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
PeerConnect::~PeerConnect() {
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerConnect::Run() {
rtc::ThreadManager::Instance()->CurrentThread()->Run();
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerConnect::Stop() {
rtc::ThreadManager::Instance()->CurrentThread()->Quit();
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerConnect::Open() {
if ( control_.get() != nullptr ) {
LOGP_F( WARNING ) << "Already open.";
LOG_F( WARNING ) << "Already open.";
return;
}
@ -76,7 +76,7 @@ void PeerConnect::Open() {
control_->RegisterObserver( this, control_ );
if ( control_.get() == NULL ) {
LOGP_F( LERROR ) << "Failed to create class Control.";
LOG_F( LERROR ) << "Failed to create class Control.";
return;
}
@ -85,7 +85,7 @@ void PeerConnect::Open() {
//
if ( !control_->InitializeControl() ) {
LOGP_F( LERROR ) << "Failed to initialize Control.";
LOG_F( LERROR ) << "Failed to initialize Control.";
control_.reset();
return;
}
@ -95,7 +95,7 @@ void PeerConnect::Open() {
//
control_->Open( setting_.signal_id_, setting_.signal_password_, peer_ );
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
return;
}
@ -108,12 +108,12 @@ void PeerConnect::Close( const string peer ) {
else {
control_->ClosePeer( peer, CLOSE_NORMAL, FORCE_QUEUING_ON );
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerConnect::Connect( const string peer ) {
control_->Connect( peer );
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
return;
}
@ -171,10 +171,10 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string )> han
if ( event_id == "open" || event_id == "connect" || event_id == "writable" ) {
std::unique_ptr<EventHandler_2> f( new EventHandler_2( handler ) );
event_handler_.insert( Events::value_type( event_id, std::move( f ) ) );
LOGP_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
LOG_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
}
else {
LOGP_F( LERROR ) << "Unsupported event type: " << event_id;
LOG_F( LERROR ) << "Unsupported event type: " << event_id;
}
return *this;
}
@ -183,7 +183,7 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, strin
if ( event_id.empty() ) return *this;
LOGP_F( LERROR ) << "Unsupported event type: " << event_id;
LOG_F( LERROR ) << "Unsupported event type: " << event_id;
return *this;
}
@ -194,10 +194,10 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, pc::C
std::unique_ptr<EventHandler_Close> f( new EventHandler_Close( handler ) );
event_handler_.insert( Events::value_type( event_id, std::move( f ) ) );
LOGP_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
LOG_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
}
else {
LOGP_F( LERROR ) << "Unsupported event type: " << event_id;
LOG_F( LERROR ) << "Unsupported event type: " << event_id;
}
return *this;
@ -210,10 +210,10 @@ PeerConnect& PeerConnect::On( string event_id, std::function<void( string, char*
std::unique_ptr<EventHandler_Message> f( new EventHandler_Message( handler ) );
event_handler_.insert( Events::value_type( event_id, std::move( f ) ) );
LOGP_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
LOG_F( INFO ) << "An event handler '" << event_id << "' has been inserted";
}
else {
LOGP_F( LERROR ) << "Unsupported event type: " << event_id;
LOG_F( LERROR ) << "Unsupported event type: " << event_id;
}
return *this;
@ -230,7 +230,7 @@ void PeerConnect::OnOpen( const string peer ) {
CallEventHandler( "open", peer );
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
void PeerConnect::OnClose( const string peer, const CloseCode code, const string desc ) {
@ -238,7 +238,7 @@ void PeerConnect::OnClose( const string peer, const CloseCode code, const string
// This instance of PeerConnect and local peer is going to be closed
if ( peer == peer_ ) {
if ( close_once_ ) {
LOGP_F( WARNING ) << "close_ is false, peer is " << peer;
LOG_F( WARNING ) << "close_ is false, peer is " << peer;
return;
}
@ -258,7 +258,7 @@ void PeerConnect::OnClose( const string peer, const CloseCode code, const string
}
}
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
void PeerConnect::OnConnect( const string peer ) {
@ -266,7 +266,7 @@ void PeerConnect::OnConnect( const string peer ) {
CallEventHandler( "connect", peer );
}
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
void PeerConnect::OnMessage( const string peer, const char* data, const size_t size ) {
@ -280,7 +280,7 @@ void PeerConnect::OnWritable( const string peer ) {
CallEventHandler( "writable", peer );
}
LOGP_F( INFO ) << "Done, peer is " << peer;
LOG_F( INFO ) << "Done, peer is " << peer;
}
@ -302,7 +302,7 @@ bool PeerConnect::ParseOptions( const string& options ) {
string value;
if ( !reader.parse( options, joptions ) ) {
LOGP_F( WARNING ) << "Invalid setting: " << options;
LOG_F( WARNING ) << "Invalid setting: " << options;
return false;
}

282
src/signalconnection.cc
View File

@ -1,28 +1,28 @@
/*
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
*
* Ryan Lee
*/
#if defined(WEBRTC_WIN)
#pragma warning(disable:4503)
#endif
#include <map>
#include <list>
#include "signalconnection.h"
#include "logging.h"
namespace pc {
Signal::Signal(const string url) :
/*
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
*
* Ryan Lee
*/
#if defined(WEBRTC_WIN)
#pragma warning(disable:4503)
#endif
#include <map>
#include <list>
#include "signalconnection.h"
#include "logging.h"
namespace pc {
Signal::Signal(const string url) :
con_state_(con_closed),
network_thread_(),
reconn_attempts_(3),
reconn_made_(0),
reconn_delay_(5000),
reconn_delay_max_(25000),
url_(url) {
reconn_delay_max_(25000),
url_(url) {
#if _DEBUG || DEBUG
client_.clear_access_channels(websocketpp::log::alevel::all);
@ -32,10 +32,10 @@ Signal::Signal(const string url) :
client_.clear_error_channels(websocketpp::log::alevel::all);
#endif
// Default settings
if (url_.empty()) {
url_ = "wss://signal.peers.io/hello";
}
// Default settings
if (url_.empty()) {
url_ = "wss://signal.peers.io/hello";
}
// Initialize ASIO
client_.init_asio();
@ -51,27 +51,27 @@ Signal::Signal(const string url) :
client_.set_message_handler(bind(&Signal::OnMessage, this, _1, _2));
client_.set_tls_init_handler(bind(&Signal::OnTlsInit, this, _1));
LOGP_F( INFO ) << "Done";
}
Signal::~Signal() {
Teardown();
LOGP_F( INFO ) << "Done";
}
void Signal::Open(const string& id, const string& password) {
user_id_ = id;
user_password_ = password;
Connect();
LOG_F( INFO ) << "Done";
}
LOGP_F( INFO ) << "Done";
}
void Signal::Close() {
if ( !opened() ) {
LOGP_F( WARNING ) << "It is not opened";
return;
Signal::~Signal() {
Teardown();
LOG_F( INFO ) << "Done";
}
void Signal::Open(const string& id, const string& password) {
user_id_ = id;
user_password_ = password;
Connect();
LOG_F( INFO ) << "Done";
}
void Signal::Close() {
if ( !opened() ) {
LOG_F( WARNING ) << "It is not opened";
return;
}
con_state_ = con_closing;
@ -79,14 +79,14 @@ void Signal::Close() {
this,
websocketpp::close::status::normal,
"End by user"));
LOGP_F( INFO ) << "Done";
}
LOG_F( INFO ) << "Done";
}
void Signal::SyncClose()
{
if ( !opened() ) {
LOGP_F( WARNING ) << "It is not opened";
LOG_F( WARNING ) << "It is not opened";
return;
}
@ -102,53 +102,53 @@ void Signal::SyncClose()
network_thread_.reset();
}
LOGP_F( INFO ) << "Done";
}
void Signal::SendCommand(const string channel,
const string commandname,
const Json::Value& data) {
if (commandname.empty()) {
LOGP_F(WARNING) << "SendCommand with empty commandname";
return;
}
if (!opened()) {
LOGP_F(WARNING) << "Signal server is not opened";
return;
}
Json::Value message;
Json::FastWriter writer;
message["command"] = commandname;
message["data"] = data;
if (!channel.empty()) message["channel"] = channel;
LOGP_F( LS_VERBOSE ) << "message is " << message.toStyledString();
try {
client_.send(con_hdl_, writer.write(message), websocketpp::frame::opcode::text);
}
catch (websocketpp::lib::error_code& ec) {
LOGP_F(LERROR) << "SendCommand Error: " << ec;
}
catch (std::exception& e) {
LOGP_F(LERROR) << "SendCommand Error: " << e.what();
}
catch (...) {
LOGP_F(LERROR) << "SendCommand Error: ";
}
LOGP_F( INFO ) << "Done";
}
void Signal::SendGlobalCommand(const string commandname,
const Json::Value& data) {
SendCommand("", commandname, data);
}
LOG_F( INFO ) << "Done";
}
void Signal::SendCommand(const string channel,
const string commandname,
const Json::Value& data) {
if (commandname.empty()) {
LOG_F(WARNING) << "SendCommand with empty commandname";
return;
}
if (!opened()) {
LOG_F(WARNING) << "Signal server is not opened";
return;
}
Json::Value message;
Json::FastWriter writer;
message["command"] = commandname;
message["data"] = data;
if (!channel.empty()) message["channel"] = channel;
LOG_F( LS_VERBOSE ) << "message is " << message.toStyledString();
try {
client_.send(con_hdl_, writer.write(message), websocketpp::frame::opcode::text);
}
catch (websocketpp::lib::error_code& ec) {
LOG_F(LERROR) << "SendCommand Error: " << ec;
}
catch (std::exception& e) {
LOG_F(LERROR) << "SendCommand Error: " << e.what();
}
catch (...) {
LOG_F(LERROR) << "SendCommand Error: ";
}
LOG_F( INFO ) << "Done";
}
void Signal::SendGlobalCommand(const string commandname,
const Json::Value& data) {
SendCommand("", commandname, data);
}
void Signal::Connect()
{
if (reconn_timer_)
@ -180,9 +180,9 @@ void Signal::Connect()
this->ResetState();
client_.get_io_service().dispatch(websocketpp::lib::bind(&Signal::ConnectInternal, this));
network_thread_.reset(new websocketpp::lib::thread(websocketpp::lib::bind(&Signal::RunLoop, this)));
LOGP_F( INFO ) << "Done";
}
LOG_F( INFO ) << "Done";
}
void Signal::Teardown()
{
@ -190,17 +190,17 @@ void Signal::Teardown()
network_thread_->detach();
network_thread_.reset();
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
asio::io_service& Signal::GetIoService()
{
return client_.get_io_service();
}
}
void Signal::SendOpenCommand() {
Json::Value data;
@ -209,19 +209,19 @@ void Signal::SendOpenCommand() {
SendGlobalCommand("open", data);
}
void Signal::OnCommandReceived(Json::Value& message) {
SignalOnCommandReceived_(message);
return;
}
void Signal::RunLoop()
{
client_.run();
client_.reset();
client_.get_alog().write(websocketpp::log::alevel::devel,
"run loop end");
}
}
void Signal::ConnectInternal()
{
@ -235,13 +235,13 @@ void Signal::ConnectInternal()
client_.connect(con);
return;
}
}
void Signal::CloseInternal(websocketpp::close::status::value const& code, string const& desc)
{
LOGP_F(WARNING) << "Close by reason:" << desc;
LOG_F(WARNING) << "Close by reason:" << desc;
if (reconn_timer_)
{
@ -250,7 +250,7 @@ void Signal::CloseInternal(websocketpp::close::status::value const& code, string
}
if (con_hdl_.expired())
{
LOGP_F(LERROR) << "Error: No active session";
LOG_F(LERROR) << "Error: No active session";
}
else
{
@ -258,7 +258,7 @@ void Signal::CloseInternal(websocketpp::close::status::value const& code, string
client_.close(con_hdl_, code, desc, ec);
}
}
void Signal::TimeoutReconnect(websocketpp::lib::asio::error_code const& ec)
{
if (ec)
@ -271,29 +271,29 @@ void Signal::TimeoutReconnect(websocketpp::lib::asio::error_code const& ec)
con_state_ = con_opening;
reconn_made_++;
this->ResetState();
LOGP_F(WARNING) << "Reconnecting..";
LOG_F(WARNING) << "Reconnecting..";
client_.get_io_service().dispatch(websocketpp::lib::bind(&Signal::ConnectInternal, this));
}
}
unsigned Signal::NextDelay() const
{
//no jitter, fixed power root.
unsigned reconn_made = std::min<unsigned>(reconn_made_, 32);//protect the pow result to be too big.
return static_cast<unsigned>(std::min<double>(reconn_delay_ * pow(1.5, reconn_made), reconn_delay_max_));
}
}
void Signal::OnOpen(websocketpp::connection_hdl con)
{
LOGP_F(WARNING) << "Connected.";
LOG_F(WARNING) << "Connected.";
con_state_ = con_opened;
con_hdl_ = con;
reconn_made_ = 0;
SendOpenCommand();
}
}
void Signal::OnClose(websocketpp::connection_hdl con)
{
@ -307,7 +307,7 @@ void Signal::OnClose(websocketpp::connection_hdl con)
websocketpp::close::status::value code = websocketpp::close::status::normal;
client_type::connection_ptr conn_ptr = client_.get_con_from_hdl(con, ec);
if (ec) {
LOGP_F(LERROR) << "get conn failed" << ec;
LOG_F(LERROR) << "get conn failed" << ec;
}
else {
code = conn_ptr->get_local_close_code();
@ -328,7 +328,7 @@ void Signal::OnClose(websocketpp::connection_hdl con)
//if (reconn_made_<reconn_attempts_)
//{
// LOGP_F(LS_WARNING) << "Reconnect for attempt:" << reconn_made_;
// LOG_F(LS_WARNING) << "Reconnect for attempt:" << reconn_made_;
// unsigned delay = this->NextDelay();
// reconn_timer_.reset(new websocketpp::lib::asio::steady_timer(client_.get_io_service()));
// websocketpp::lib::asio::error_code ec;
@ -340,10 +340,10 @@ void Signal::OnClose(websocketpp::connection_hdl con)
SignalOnClosed_(code);
}
LOGP_F( INFO ) << "Done";
LOG_F( INFO ) << "Done";
}
}
void Signal::OnFail(websocketpp::connection_hdl con)
{
//
@ -355,7 +355,7 @@ void Signal::OnFail(websocketpp::connection_hdl con)
websocketpp::close::status::value code = websocketpp::close::status::abnormal_close;
client_type::connection_ptr conn_ptr = client_.get_con_from_hdl(con, ec);
if (ec) {
LOGP_F(LERROR) << "get conn failed" << ec;
LOG_F(LERROR) << "get conn failed" << ec;
}
else {
code = conn_ptr->get_local_close_code();
@ -364,11 +364,11 @@ void Signal::OnFail(websocketpp::connection_hdl con)
con_hdl_.reset();
con_state_ = con_closed;
LOGP_F(LERROR) << "Connection failed.";
LOG_F(LERROR) << "Connection failed.";
if (reconn_made_<reconn_attempts_)
{
LOGP_F(WARNING) << "Reconnect for attempt:" << reconn_made_;
LOG_F(WARNING) << "Reconnect for attempt:" << reconn_made_;
unsigned delay = this->NextDelay();
reconn_timer_.reset(new asio::steady_timer(client_.get_io_service()));
websocketpp::lib::asio::error_code ec;
@ -379,19 +379,19 @@ void Signal::OnFail(websocketpp::connection_hdl con)
SignalOnClosed_(code);
}
}
void Signal::OnMessage(websocketpp::connection_hdl con, client_type::message_ptr msg)
{
Json::Reader reader;
Json::Value jmessage;
if (!reader.parse(msg->get_payload(), jmessage)) {
LOGP_F(WARNING) << "Received unknown message: " << msg->get_payload();
return;
Json::Reader reader;
Json::Value jmessage;
if (!reader.parse(msg->get_payload(), jmessage)) {
LOG_F(WARNING) << "Received unknown message: " << msg->get_payload();
return;
}
LOGP_F( LS_VERBOSE ) << jmessage.toStyledString();
LOG_F( LS_VERBOSE ) << jmessage.toStyledString();
OnCommandReceived(jmessage);
}
@ -410,11 +410,11 @@ Signal::context_ptr Signal::OnTlsInit(websocketpp::connection_hdl conn)
asio::ssl::context::single_dh_use, ec);
if (ec)
{
LOGP_F(LERROR) << "Init tls failed,reason:" << ec.message();
LOG_F(LERROR) << "Init tls failed,reason:" << ec.message();
}
return ctx;
}
} // namespace pc

160
src/signalconnection.h
View File

@ -1,12 +1,12 @@
/*
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
*
* Ryan Lee
*/
/*
Reference: socket.io-client-cpp
/*
* Copyright 2016 The PeerConnect Project Authors. All rights reserved.
*
* Ryan Lee
*/
/*
Reference: socket.io-client-cpp
Copyright (c) 2015, Melo Yao
All rights reserved.
@ -26,62 +26,62 @@
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef __PEERCONNECT_SIGNAL_H__
#define __PEERCONNECT_SIGNAL_H__
#include <string>
SOFTWARE.
*/
#ifndef __PEERCONNECT_SIGNAL_H__
#define __PEERCONNECT_SIGNAL_H__
#include <string>
#if _DEBUG || DEBUG
#include <websocketpp/config/debug_asio.hpp>
#else
#include <websocketpp/config/asio_client.hpp>
#endif //DEBUG
#include "websocketpp/client.hpp"
#include "websocketpp/common/thread.hpp"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/json.h"
namespace pc {
class SignalInterface {
public:
virtual void Open(const std::string& id, const std::string& password) = 0;
virtual void Close() = 0;
virtual void SendCommand(const std::string id,
const std::string commandname,
const Json::Value& data) = 0;
virtual void SendGlobalCommand(const std::string commandname,
const Json::Value& data) = 0;
std::string session_id() { return session_id_; }
// sigslots
sigslot::signal1<const Json::Value&> SignalOnCommandReceived_;
sigslot::signal1<const websocketpp::close::status::value> SignalOnClosed_;
protected:
std::string session_id_;
};
class Signal
: public SignalInterface {
public:
#endif //DEBUG
#include "websocketpp/client.hpp"
#include "websocketpp/common/thread.hpp"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/json.h"
namespace pc {
class SignalInterface {
public:
virtual void Open(const std::string& id, const std::string& password) = 0;
virtual void Close() = 0;
virtual void SendCommand(const std::string id,
const std::string commandname,
const Json::Value& data) = 0;
virtual void SendGlobalCommand(const std::string commandname,
const Json::Value& data) = 0;
std::string session_id() { return session_id_; }
// sigslots
sigslot::signal1<const Json::Value&> SignalOnCommandReceived_;
sigslot::signal1<const websocketpp::close::status::value> SignalOnClosed_;
protected:
std::string session_id_;
};
class Signal
: public SignalInterface {
public:
enum con_state
{
con_opening,
con_opened,
con_closing,
con_closed
};
};
using string = std::string;
@ -89,22 +89,22 @@ public:
typedef websocketpp::config::debug_asio_tls client_config;
#else
typedef websocketpp::config::asio_tls_client client_config;
#endif //DEBUG
typedef websocketpp::client<client_config> client_type;
#endif //DEBUG
typedef websocketpp::client<client_config> client_type;
Signal(const string url);
~Signal();
void Open(const string& id, const string& password);
void Close();
Signal(const string url);
~Signal();
void Open(const string& id, const string& password);
void Close();
void SyncClose();
void SendCommand(const string channel,
const string commandname,
const Json::Value& data);
void SendGlobalCommand(const string commandname,
const Json::Value& data);
void SendCommand(const string channel,
const string commandname,
const Json::Value& data);
void SendGlobalCommand(const string commandname,
const Json::Value& data);
void Teardown();
bool opened() const { return con_state_ == con_opened;}
@ -149,15 +149,15 @@ private:
unsigned reconn_delay_;
unsigned reconn_delay_max_;
unsigned reconn_attempts_;
unsigned reconn_made_;
// Signal server
string url_;
string user_id_;
string user_password_;
}; // class Signal
} // namespace pc
unsigned reconn_made_;
// Signal server
string url_;
string user_id_;
string user_password_;
}; // class Signal
} // namespace pc
#endif // __PEERCONNECT_SIGNAL_H__

2
webrtcbranch
View File

@ -1 +1 @@
branch-heads/55
branch-heads/60