| /* |
| * libjingle |
| * Copyright 2004--2011, Google Inc. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "talk/app/webrtc/peerconnectionproxy.h" |
| |
| #include "talk/app/webrtc/peerconnectionimpl.h" |
| #include "talk/base/logging.h" |
| |
| namespace webrtc { |
| |
| enum { |
| MSG_WEBRTC_ADDSTREAM = 1, |
| MSG_WEBRTC_CLOSE, |
| MSG_WEBRTC_CONNECT, |
| MSG_WEBRTC_INIT, |
| MSG_WEBRTC_REGISTEROBSERVER, |
| MSG_WEBRTC_RELEASE, |
| MSG_WEBRTC_REMOVESTREAM, |
| MSG_WEBRTC_SETAUDIODEVICE, |
| MSG_WEBRTC_SETLOCALRENDERER, |
| MSG_WEBRTC_SETVIDEOCAPTURE, |
| MSG_WEBRTC_SETVIDEORENDERER, |
| MSG_WEBRTC_SIGNALINGMESSAGE, |
| MSG_WEBRTC_GETREADYSTATE, |
| }; |
| |
| struct AddStreamParams : public talk_base::MessageData { |
| AddStreamParams(const std::string& stream_id, bool video) |
| : stream_id(stream_id), |
| video(video), |
| result(false) {} |
| |
| std::string stream_id; |
| bool video; |
| bool result; |
| }; |
| |
| struct RemoveStreamParams : public talk_base::MessageData { |
| explicit RemoveStreamParams(const std::string& stream_id) |
| : stream_id(stream_id), |
| result(false) {} |
| |
| std::string stream_id; |
| bool result; |
| }; |
| |
| struct SignalingMsgParams : public talk_base::MessageData { |
| explicit SignalingMsgParams(const std::string& signaling_message) |
| : signaling_message(signaling_message), |
| result(false) {} |
| |
| std::string signaling_message; |
| bool result; |
| }; |
| |
| struct SetAudioDeviceParams : public talk_base::MessageData { |
| SetAudioDeviceParams(const std::string& wave_in_device, |
| const std::string& wave_out_device, |
| int opts) |
| : wave_in_device(wave_in_device), wave_out_device(wave_out_device), |
| opts(opts), result(false) {} |
| |
| std::string wave_in_device; |
| std::string wave_out_device; |
| int opts; |
| bool result; |
| }; |
| |
| struct SetLocalRendererParams : public talk_base::MessageData { |
| explicit SetLocalRendererParams(cricket::VideoRenderer* renderer) |
| : renderer(renderer), result(false) {} |
| |
| cricket::VideoRenderer* renderer; |
| bool result; |
| }; |
| |
| struct SetVideoRendererParams : public talk_base::MessageData { |
| SetVideoRendererParams(const std::string& stream_id, |
| cricket::VideoRenderer* renderer) |
| : stream_id(stream_id), renderer(renderer), result(false) {} |
| |
| std::string stream_id; |
| cricket::VideoRenderer* renderer; |
| bool result; |
| }; |
| |
| struct SetVideoCaptureParams : public talk_base::MessageData { |
| explicit SetVideoCaptureParams(const std::string& cam_device) |
| : cam_device(cam_device), result(false) {} |
| |
| std::string cam_device; |
| bool result; |
| }; |
| |
| struct RegisterObserverParams : public talk_base::MessageData { |
| explicit RegisterObserverParams(PeerConnectionObserver* observer) |
| : observer(observer), result(false) {} |
| |
| PeerConnectionObserver* observer; |
| bool result; |
| }; |
| |
| struct ResultParams : public talk_base::MessageData { |
| ResultParams() |
| : result(false) {} |
| |
| bool result; |
| }; |
| |
| PeerConnectionProxy::PeerConnectionProxy( |
| cricket::PortAllocator* port_allocator, |
| cricket::ChannelManager* channel_manager, |
| talk_base::Thread* signaling_thread) |
| : peerconnection_impl_(new PeerConnectionImpl(port_allocator, |
| channel_manager, signaling_thread)), |
| signaling_thread_(signaling_thread) { |
| } |
| |
| PeerConnectionProxy::~PeerConnectionProxy() { |
| ResultParams params; |
| Send(MSG_WEBRTC_RELEASE, ¶ms); |
| } |
| |
| bool PeerConnectionProxy::Init() { |
| ResultParams params; |
| return (Send(MSG_WEBRTC_INIT, ¶ms) && params.result); |
| } |
| |
| void PeerConnectionProxy::RegisterObserver(PeerConnectionObserver* observer) { |
| RegisterObserverParams params(observer); |
| Send(MSG_WEBRTC_REGISTEROBSERVER, ¶ms); |
| } |
| |
| bool PeerConnectionProxy::SignalingMessage( |
| const std::string& signaling_message) { |
| SignalingMsgParams params(signaling_message); |
| return (Send(MSG_WEBRTC_SIGNALINGMESSAGE, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::AddStream(const std::string& stream_id, bool video) { |
| AddStreamParams params(stream_id, video); |
| return (Send(MSG_WEBRTC_ADDSTREAM, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::RemoveStream(const std::string& stream_id) { |
| RemoveStreamParams params(stream_id); |
| return (Send(MSG_WEBRTC_REMOVESTREAM, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::SetAudioDevice(const std::string& wave_in_device, |
| const std::string& wave_out_device, |
| int opts) { |
| SetAudioDeviceParams params(wave_in_device, wave_out_device, opts); |
| return (Send(MSG_WEBRTC_SETAUDIODEVICE, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::SetLocalVideoRenderer( |
| cricket::VideoRenderer* renderer) { |
| SetLocalRendererParams params(renderer); |
| return (Send(MSG_WEBRTC_SETLOCALRENDERER, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::SetVideoRenderer(const std::string& stream_id, |
| cricket::VideoRenderer* renderer) { |
| SetVideoRendererParams params(stream_id, renderer); |
| return (Send(MSG_WEBRTC_SETVIDEORENDERER, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::SetVideoCapture(const std::string& cam_device) { |
| SetVideoCaptureParams params(cam_device); |
| return (Send(MSG_WEBRTC_SETVIDEOCAPTURE, ¶ms) && params.result); |
| } |
| |
| PeerConnection::ReadyState PeerConnectionProxy::GetReadyState() { |
| PeerConnection::ReadyState ready_state = NEW; |
| Send(MSG_WEBRTC_GETREADYSTATE, |
| reinterpret_cast<talk_base::MessageData*>(&ready_state)); |
| return ready_state; |
| } |
| |
| bool PeerConnectionProxy::Connect() { |
| ResultParams params; |
| return (Send(MSG_WEBRTC_CONNECT, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::Close() { |
| ResultParams params; |
| return (Send(MSG_WEBRTC_CLOSE, ¶ms) && params.result); |
| } |
| |
| bool PeerConnectionProxy::Send(uint32 id, talk_base::MessageData* data) { |
| if (!signaling_thread_) |
| return false; |
| signaling_thread_->Send(this, id, data); |
| return true; |
| } |
| |
| void PeerConnectionProxy::OnMessage(talk_base::Message* message) { |
| talk_base::MessageData* data = message->pdata; |
| switch (message->message_id) { |
| case MSG_WEBRTC_ADDSTREAM: { |
| AddStreamParams* params = reinterpret_cast<AddStreamParams*>(data); |
| params->result = peerconnection_impl_->AddStream( |
| params->stream_id, params->video); |
| break; |
| } |
| case MSG_WEBRTC_SIGNALINGMESSAGE: { |
| SignalingMsgParams* params = |
| reinterpret_cast<SignalingMsgParams*>(data); |
| params->result = peerconnection_impl_->SignalingMessage( |
| params->signaling_message); |
| break; |
| } |
| case MSG_WEBRTC_REMOVESTREAM: { |
| RemoveStreamParams* params = reinterpret_cast<RemoveStreamParams*>(data); |
| params->result = peerconnection_impl_->RemoveStream( |
| params->stream_id); |
| break; |
| } |
| case MSG_WEBRTC_SETAUDIODEVICE: { |
| SetAudioDeviceParams* params = |
| reinterpret_cast<SetAudioDeviceParams*>(data); |
| params->result = peerconnection_impl_->SetAudioDevice( |
| params->wave_in_device, params->wave_out_device, params->opts); |
| break; |
| } |
| case MSG_WEBRTC_SETLOCALRENDERER: { |
| SetLocalRendererParams* params = |
| reinterpret_cast<SetLocalRendererParams*>(data); |
| params->result = peerconnection_impl_->SetLocalVideoRenderer( |
| params->renderer); |
| break; |
| } |
| case MSG_WEBRTC_SETVIDEOCAPTURE: { |
| SetVideoCaptureParams* params = |
| reinterpret_cast<SetVideoCaptureParams*>(data); |
| params->result = peerconnection_impl_->SetVideoCapture( |
| params->cam_device); |
| break; |
| } |
| case MSG_WEBRTC_GETREADYSTATE: { |
| PeerConnection::ReadyState* ready_state = |
| reinterpret_cast<PeerConnection::ReadyState*>(data); |
| *ready_state = peerconnection_impl_->GetReadyState(); |
| break; |
| } |
| case MSG_WEBRTC_SETVIDEORENDERER: { |
| SetVideoRendererParams* params = |
| reinterpret_cast<SetVideoRendererParams*>(data); |
| params->result = peerconnection_impl_->SetVideoRenderer( |
| params->stream_id, params->renderer); |
| break; |
| } |
| case MSG_WEBRTC_CONNECT: { |
| ResultParams* params = |
| reinterpret_cast<ResultParams*>(data); |
| params->result = peerconnection_impl_->Connect(); |
| break; |
| } |
| case MSG_WEBRTC_CLOSE: { |
| ResultParams* params = |
| reinterpret_cast<ResultParams*>(data); |
| params->result = peerconnection_impl_->Close(); |
| break; |
| } |
| case MSG_WEBRTC_INIT: { |
| ResultParams* params = |
| reinterpret_cast<ResultParams*>(data); |
| params->result = peerconnection_impl_->Init(); |
| break; |
| } |
| case MSG_WEBRTC_REGISTEROBSERVER: { |
| RegisterObserverParams* params = |
| reinterpret_cast<RegisterObserverParams*>(data); |
| peerconnection_impl_->RegisterObserver(params->observer); |
| break; |
| } |
| case MSG_WEBRTC_RELEASE: { |
| peerconnection_impl_.reset(); |
| break; |
| } |
| default: { |
| ASSERT(false); |
| break; |
| } |
| } |
| } |
| |
| } // namespace webrtc |