1 /*
2 * This file is part of Wireless Display Software for Linux OS
3 *
4 * Copyright (C) 2014 Intel Corporation.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
19 * 02110-1301 USA
20 */
21
22 #ifndef LIBWDS_COMMON_MESSAGE_HANDLER_H_
23 #define LIBWDS_COMMON_MESSAGE_HANDLER_H_
24
25 #include <cassert>
26 #include <list>
27 #include <vector>
28 #include <memory>
29 #include <utility>
30
31 #include "libwds/rtsp/message.h"
32 #include "libwds/rtsp/reply.h"
33 #include "libwds/public/logging.h"
34 #include "libwds/public/peer.h"
35
36 namespace wds {
37
38 // Default keep-alive timer is 60 seconds
39 const int kDefaultKeepAliveTimeout = 60;
40 // Default timeout for RTSP message exchange
41 const int kDefaultTimeoutValue = 5;
42
43 class MediaManager;
44
45 class MessageHandler;
46 using MessageHandlerPtr = std::shared_ptr<MessageHandler>;
47
make_ptr(MessageHandler * handler)48 inline MessageHandlerPtr make_ptr(MessageHandler* handler) {
49 return MessageHandlerPtr(handler);
50 }
51
52 class MessageHandler : public std::enable_shared_from_this<MessageHandler> {
53 public:
54 class Observer {
55 public:
OnCompleted(MessageHandlerPtr handler)56 virtual void OnCompleted(MessageHandlerPtr handler) {}
OnError(MessageHandlerPtr handler)57 virtual void OnError(MessageHandlerPtr handler) {}
58
59 protected:
~Observer()60 virtual ~Observer() {}
61 };
62
63 struct InitParams {
64 Peer::Delegate* sender;
65 MediaManager* manager;
66 Observer* observer;
67 };
68
69 virtual ~MessageHandler();
70
71 virtual void Start() = 0;
72 virtual void Reset() = 0;
73
74 virtual bool CanSend(rtsp::Message* message) const = 0;
75 virtual void Send(std::unique_ptr<rtsp::Message> message) = 0;
76
77 virtual bool CanHandle(rtsp::Message* message) const = 0;
78 virtual void Handle(std::unique_ptr<rtsp::Message> message) = 0;
79
80 // For handlers that require timeout
81 virtual bool HandleTimeoutEvent(unsigned timer_id) const;
82
set_observer(Observer * observer)83 void set_observer(Observer* observer) {
84 assert(observer);
85 observer_ = observer;
86 }
87
88 protected:
MessageHandler(const InitParams & init_params)89 explicit MessageHandler(const InitParams& init_params)
90 : sender_(init_params.sender),
91 manager_(init_params.manager),
92 observer_(init_params.observer) {
93 assert(sender_);
94 assert(manager_);
95 assert(observer_);
96 }
97
98 Peer::Delegate* sender_;
99 MediaManager* manager_;
100 Observer* observer_;
101 };
102
103 class MessageSequenceHandler : public MessageHandler,
104 public MessageHandler::Observer {
105 public:
106 explicit MessageSequenceHandler(const InitParams& init_params);
107 ~MessageSequenceHandler() override;
108 void Start() override;
109 void Reset() override;
110
111 bool CanSend(rtsp::Message* message) const override;
112 void Send(std::unique_ptr<rtsp::Message> message) override;
113
114 bool CanHandle(rtsp::Message* message) const override;
115 void Handle(std::unique_ptr<rtsp::Message> message) override;
116
117 bool HandleTimeoutEvent(unsigned timer_id) const override;
118
119 protected:
120 void AddSequencedHandler(MessageHandlerPtr handler);
121 // MessageHandler::Observer implementation.
122 void OnCompleted(MessageHandlerPtr handler) override;
123 void OnError(MessageHandlerPtr handler) override;
124
125 std::vector<MessageHandlerPtr> handlers_;
126 MessageHandlerPtr current_handler_;
127 };
128
129 class MessageSequenceWithOptionalSetHandler : public MessageSequenceHandler {
130 public:
131 explicit MessageSequenceWithOptionalSetHandler(const InitParams& init_params);
132 ~MessageSequenceWithOptionalSetHandler() override;
133 void Start() override;
134 void Reset() override;
135 bool CanSend(rtsp::Message* message) const override;
136 void Send(std::unique_ptr<rtsp::Message> message) override;
137 bool CanHandle(rtsp::Message* message) const override;
138 void Handle(std::unique_ptr<rtsp::Message> message) override;
139
140 bool HandleTimeoutEvent(unsigned timer_id) const override;
141
142 protected:
143 void AddOptionalHandler(MessageHandlerPtr handler);
144 // MessageHandler::Observer implementation.
145 void OnCompleted(MessageHandlerPtr handler) override;
146 void OnError(MessageHandlerPtr handler) override;
147
148 std::vector<MessageHandlerPtr> optional_handlers_;
149 };
150
151 // This is aux classes to handle single message.
152 // There are two common scenarious:
153 // 1. We send a message and wait for reply
154 // class Handler : public MessageSender
155 //
156 // 2. We wait for the message and reply ourselves.
157 // class Handler : public MessageReceiver<type of the message
158 // we're waiting for>
159 class MessageReceiverBase : public MessageHandler {
160 public:
161 explicit MessageReceiverBase(const InitParams& init_params);
162 ~MessageReceiverBase() override;
163
164 protected:
165 virtual std::unique_ptr<wds::rtsp::Reply> HandleMessage(rtsp::Message* message) = 0;
166 bool CanHandle(rtsp::Message* message) const override;
167 void Handle(std::unique_ptr<rtsp::Message> message) override;
168
169 private:
170 void Start() override;
171 void Reset() override;
172 bool CanSend(rtsp::Message* message) const override;
173 void Send(std::unique_ptr<rtsp::Message> message) override;
174
175 bool wait_for_message_;
176 };
177
178 template <rtsp::Request::ID id>
179 class MessageReceiver : public MessageReceiverBase {
180 public:
181 using MessageReceiverBase::MessageReceiverBase;
182
183 protected:
CanHandle(rtsp::Message * message)184 bool CanHandle(rtsp::Message* message) const override {
185 return MessageReceiverBase::CanHandle(message) && message->is_request() &&
186 id == ToRequest(message)->id();
187 }
188 };
189
190 class MessageSenderBase : public MessageHandler {
191 public:
192 explicit MessageSenderBase(const InitParams& init_params);
193 ~MessageSenderBase() override;
194
195 protected:
196 virtual bool HandleReply(rtsp::Reply* reply) = 0;
197 void Send(std::unique_ptr<rtsp::Message> message) override;
198 void Reset() override;
199 bool HandleTimeoutEvent(unsigned timer_id) const override;
200
201
202 private:
203 bool CanHandle(rtsp::Message* message) const override;
204 void Handle(std::unique_ptr<rtsp::Message> message) override;
205
206 virtual int GetResponseTimeout() const;
207
208 struct ParcelData {
209 int cseq;
210 unsigned timer_id;
211 };
212 std::list<ParcelData> parcel_queue_;
213 };
214
215 // To be used for optional senders.
216 template <rtsp::Request::ID id>
217 class OptionalMessageSender : public MessageSenderBase {
218 public:
219 using MessageSenderBase::MessageSenderBase;
220
221 protected:
CanSend(rtsp::Message * message)222 bool CanSend(rtsp::Message* message) const override {
223 assert(message);
224 return message->is_request() && ToRequest(message)->id() == id;
225 }
226
227 private:
Start()228 void Start() override {}
229 };
230
231 // To be used for sequensed senders.
232 class SequencedMessageSender : public MessageSenderBase {
233 public:
234 explicit SequencedMessageSender(const InitParams& init_params);
235 ~SequencedMessageSender() override;
236
237 protected:
238 virtual std::unique_ptr<rtsp::Message> CreateMessage() = 0;
239
240 private:
241 void Start() override;
242 void Reset() override;
243 bool CanSend(rtsp::Message* message) const override;
244
245 rtsp::Message* to_be_send_;
246 };
247
248 } // namespace wds
249 #endif // LIBWDS_COMMON_MESSAGE_HANDLER_H_
250