1 /* 2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef WEBRTC_VOICE_ENGINE_CHANNEL_MANAGER_H 12 #define WEBRTC_VOICE_ENGINE_CHANNEL_MANAGER_H 13 14 #include <vector> 15 16 #include "webrtc/base/constructormagic.h" 17 #include "webrtc/base/scoped_ptr.h" 18 #include "webrtc/call/rtc_event_log.h" 19 #include "webrtc/system_wrappers/include/atomic32.h" 20 #include "webrtc/system_wrappers/include/critical_section_wrapper.h" 21 #include "webrtc/typedefs.h" 22 23 namespace webrtc { 24 25 class Config; 26 27 namespace voe { 28 29 class Channel; 30 31 // Shared-pointer implementation for keeping track of Channels. The underlying 32 // shared instance will be dropped when no more ChannelOwners point to it. 33 // 34 // One common source of ChannelOwner instances are 35 // ChannelManager::CreateChannel() and ChannelManager::GetChannel(...). 36 // It has a similar use case to shared_ptr in C++11. Should this move to C++11 37 // in the future, this class should be replaced by exactly that. 38 // 39 // To access the underlying Channel, use .channel(). 40 // IsValid() implements a convenience method as an alternative for checking 41 // whether the underlying pointer is NULL or not. 42 // 43 // Channel channel_owner = channel_manager.GetChannel(channel_id); 44 // if (channel_owner.IsValid()) 45 // channel_owner.channel()->...; 46 // 47 class ChannelOwner { 48 public: 49 explicit ChannelOwner(Channel* channel); 50 ChannelOwner(const ChannelOwner& channel_owner); 51 52 ~ChannelOwner(); 53 54 ChannelOwner& operator=(const ChannelOwner& other); 55 channel()56 Channel* channel() const { return channel_ref_->channel.get(); } IsValid()57 bool IsValid() { return channel_ref_->channel.get() != NULL; } use_count()58 int use_count() const { return channel_ref_->ref_count.Value(); } 59 private: 60 // Shared instance of a Channel. Copying ChannelOwners increase the reference 61 // count and destroying ChannelOwners decrease references. Channels are 62 // deleted when no references to them are held. 63 struct ChannelRef { 64 ChannelRef(Channel* channel); 65 const rtc::scoped_ptr<Channel> channel; 66 Atomic32 ref_count; 67 }; 68 69 ChannelRef* channel_ref_; 70 }; 71 72 class ChannelManager { 73 public: 74 ChannelManager(uint32_t instance_id, const Config& config); 75 76 // Upon construction of an Iterator it will grab a copy of the channel list of 77 // the ChannelManager. The iteration will then occur over this state, not the 78 // current one of the ChannelManager. As the Iterator holds its own references 79 // to the Channels, they will remain valid even if they are removed from the 80 // ChannelManager. 81 class Iterator { 82 public: 83 explicit Iterator(ChannelManager* channel_manager); 84 85 Channel* GetChannel(); 86 bool IsValid(); 87 88 void Increment(); 89 90 private: 91 size_t iterator_pos_; 92 std::vector<ChannelOwner> channels_; 93 94 RTC_DISALLOW_COPY_AND_ASSIGN(Iterator); 95 }; 96 97 // CreateChannel will always return a valid ChannelOwner instance. The channel 98 // is created either based on internal configuration, i.e. |config_|, by 99 // calling CreateChannel(), or using and external configuration 100 // |external_config| if the overloaded method 101 // CreateChannel(const Config& external_config) is called. 102 ChannelOwner CreateChannel(); 103 ChannelOwner CreateChannel(const Config& external_config); 104 105 // ChannelOwner.channel() will be NULL if channel_id is invalid or no longer 106 // exists. This should be checked with ChannelOwner::IsValid(). 107 ChannelOwner GetChannel(int32_t channel_id); 108 void GetAllChannels(std::vector<ChannelOwner>* channels); 109 110 void DestroyChannel(int32_t channel_id); 111 void DestroyAllChannels(); 112 113 size_t NumOfChannels() const; 114 115 // Returns a pointer to the event log object stored within the ChannelManager. 116 RtcEventLog* GetEventLog() const; 117 118 private: 119 // Create a channel given a configuration, |config|. 120 ChannelOwner CreateChannelInternal(const Config& config); 121 122 uint32_t instance_id_; 123 124 Atomic32 last_channel_id_; 125 126 rtc::scoped_ptr<CriticalSectionWrapper> lock_; 127 std::vector<ChannelOwner> channels_; 128 129 const Config& config_; 130 rtc::scoped_ptr<RtcEventLog> event_log_; 131 132 RTC_DISALLOW_COPY_AND_ASSIGN(ChannelManager); 133 }; 134 } // namespace voe 135 } // namespace webrtc 136 137 #endif // WEBRTC_VOICE_ENGINE_CHANNEL_MANAGER_H 138