RDK Documentation (Open Sourced RDK Components)
TRMMonitor.cpp
1 /*
2  * If not stated otherwise in this file or this component's Licenses.txt file the
3  * following copyright and licenses apply:
4  *
5  * Copyright 2016 RDK Management
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18 */
19 
20 
21 /**
22 * @defgroup trm
23 * @{
24 * @defgroup qtapp
25 * @{
26 **/
27 
28 
29 #include <QApplication>
30 #include <QtGlobal>
31 #include <QtCore>
32 #include <QObject>
33 #include <QTcpSocket>
34 #include <QHostAddress>
35 
36 
37 #include <QList>
38 
39 #include "trm/JsonEncoder.h"
40 #include "trm/Messages.h"
41 
42 
43 #include "trm/TunerReservation.h"
44 #include "TRMMonitor.h"
45 
46 using namespace TRM;
47 
48 TRMMonitor::TRMMonitor(const QHostAddress &address, quint16 port, uint32_t clientId) : Client (address, port),
49  hostAddress(address), portNumber(port), clientId(clientId)
50 {
51 }
52 
53 TRMMonitor::~TRMMonitor()
54 {
55 }
56 
57 const std::list<std::string> & TRMMonitor::getTunerIds(void) const
58 {
59  return tunerIds;
60 }
61 
62 #if 1
63 
64 void TRMMonitor::sendTunerReserve(const QString &device, qint64 startTime, qint64 duration, const QString &locator, const QString &activity, const QString &token)
65 {
66 
67  qDebug() << ("Sending out ReserveTuner");
68 
69  std::vector<uint8_t> out;
70  Activity activityObject(activity.toUtf8().constData());
71  activityObject.addDetail("recordingId", QDateTime(QDate::currentDate(), QTime::currentTime()).toString().toUtf8().constData());
72  activityObject.addDetail("hot", "false");
73 
74  ReserveTuner requestObject(QUuid::createUuid ().toString().toUtf8().constData(),
75  device.toUtf8().constData(),
76  TunerReservation(device.toUtf8().constData(),
77  locator.toUtf8().constData(),
78  startTime,
79  duration,
80  activityObject,
81  token.toUtf8().constData())
82  );
83 
84  send(requestObject, out);
85  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
86  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
87 }
88 
89 void TRMMonitor::sendGetAllTunerIds(void)
90 {
91  qDebug() << ("Sending out GetAllTunerIds");
92 
93  std::vector<uint8_t> out;
94  GetAllTunerIds requestObject(QUuid::createUuid ().toString().toUtf8().constData());
95 
96  send(requestObject, out);
97  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
98  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
99 }
100 
101 void TRMMonitor::sendGetAllTunerStates(void)
102 {
103  qDebug() << ("Sending out GetAllTunerStates");
104  std::vector<uint8_t> out;
105  GetAllTunerStates requestObject(QUuid::createUuid ().toString().toUtf8().constData(), "");
106 
107  send(requestObject, out);
108  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
109  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
110 }
111 
112 void TRMMonitor::sendGetAllReservations(void)
113 {
114  qDebug() << ("Sending out GetAllReservations");
115  std::vector<uint8_t> out;
116  GetAllReservations requestObject(QUuid::createUuid ().toString().toUtf8().constData(), "");
117 
118  send(requestObject, out);
119  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
120  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
121 }
122 
123 void TRMMonitor::sendReleaseTunerReservation(const QString &reservationToken)
124 {
125  qDebug() << ("Sending out ReleaseTunerReservation");
126  std::vector<uint8_t> out;
127  ReleaseTunerReservation requestObject(QUuid::createUuid ().toString().toUtf8().constData(), "Device::TestApp", reservationToken.toUtf8().constData());
128 
129  send(requestObject, out);
130  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
131  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
132 }
133 
134 void TRMMonitor::sendValidateTunerReservation(const QString &device, const QString &reservationToken)
135 {
136  qDebug() << ("Sending out ValidateTunerReservation");
137  std::vector<uint8_t> out;
138  ValidateTunerReservation requestObject(QUuid::createUuid ().toString().toUtf8().constData(), device.toUtf8().constData(), reservationToken.toUtf8().constData());
139 
140  send(requestObject, out);
141  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
142  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
143 
144 }
145 
146 void TRMMonitor::sendCancelRecording(const QString &, const QString &reservationToken)
147 {
148  qDebug() << ("Sending out ValidateTunerReservation");
149  std::vector<uint8_t> out;
150  CancelRecording requestObject(QUuid::createUuid ().toString().toUtf8().constData(), reservationToken.toUtf8().constData());
151 
152  send(requestObject, out);
153  pendingRequestIds.enqueue(QString(requestObject.getUUID().c_str()));
154  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
155 
156 }
157 
158 void TRMMonitor::sendCancelRecordingResponse(const QString &uuid, const QString &, const QString &reservationToken, uint32_t outClientId)
159 {
160  qDebug() << ("Sending out ValidateTunerReservation");
161  std::vector<uint8_t> out;
162  ResponseStatus responseStatus(ResponseStatus::kOk, "Recording Canceled sSuccessfully");
163  CancelRecordingResponse requestObject(uuid.toUtf8().constData(), responseStatus, reservationToken.toUtf8().constData(), true);
164 
165  send(requestObject, out, outClientId);
166  if (connection) connection->sendMessage(QByteArray((const char *)&out[0], out.size()));
167 
168 }
169 
170 void TRMMonitor::operator() (const ReserveTunerResponse &msg)
171 {
172  process(msg);
173  std::cout << "handleReserveTunerResponse =======================================" << std::endl;
174 
175  QString requestId = pendingRequestIds.dequeue();
176  if(requestId != QString(msg.getUUID().c_str()))
177  {
178  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
179  Q_ASSERT(false);
180  }
181  else {
182  }
183 
184  sendGetAllReservations();
185  sendGetAllTunerStates();
186  if (msg.getStatus().getDetails() != "") {
187 
188  emit statusMessageReceived(msg.getStatus().getDetails());
189  }
190  const ReserveTunerResponse::ConflictCT &conflicts = msg.getConflicts();
191 
192  if (conflicts.size() != 0) {
193  std::cout << "handleReserveTunerResponse FOUND CONFLICTS=======================================" << std::endl;
194  emit conflictsReceived(conflicts);
195  }
196  else {
197  std::cout << "handleReserveTunerResponse NO CONFLICTS=======================================" << std::endl;
198  }
199 
200  sendGetAllReservations();
201  sendGetAllTunerStates();
202 }
203 
204 void TRMMonitor::operator() (const ReleaseTunerReservationResponse &msg)
205 {
206  process(msg);
207  qDebug() << "handleReleaseTunerReservationResponse";
208  QString requestId = pendingRequestIds.dequeue();
209  if(requestId != QString(msg.getUUID().c_str()))
210  {
211  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
212  Q_ASSERT(false);
213  }
214  else {
215  }
216 
217 
218  UNUSED_VARIABLE(connection);
219  sendGetAllReservations();
220  sendGetAllTunerStates();
221 }
222 
223 void TRMMonitor::operator() (const ValidateTunerReservationResponse &msg)
224 {
225  process(msg);
226  qDebug() << "handleValidateTunerReservationResponse";
227 
228  QString requestId = pendingRequestIds.dequeue();
229  if(requestId != QString(msg.getUUID().c_str()))
230  {
231  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
232  Q_ASSERT(false);
233  }
234  else {
235  qDebug() << "Validation Result is " << msg.isValid();
236  }
237 
238 
239  UNUSED_VARIABLE(connection);
240  sendGetAllReservations();
241  sendGetAllTunerStates();
242 
243 }
244 
245 void TRMMonitor::operator() (const CancelRecording &msg)
246 {
247  process(msg);
248  qDebug() << "handleCancelRecording";
249  sendCancelRecordingResponse(msg.getUUID().c_str(), msg.getDevice().c_str(), msg.getReservationToken().c_str(), inClientId);
250 
251 }
252 
253 void TRMMonitor::operator() (const CancelRecordingResponse &msg)
254 {
255  process(msg);
256  qDebug() << "handleCancelRecordingResponse";
257 
258  QString requestId = pendingRequestIds.dequeue();
259  if(requestId != QString(msg.getUUID().c_str()))
260  {
261  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
262  Q_ASSERT(false);
263  }
264  else {
265  }
266 
267  UNUSED_VARIABLE(connection);
268  sendGetAllReservations();
269  sendGetAllTunerStates();
270 }
271 
272 void TRMMonitor::operator() (const GetAllTunerStatesResponse &msg)
273 {
274  process(msg);
275 
276  qDebug() << "handleGetAllTunerStatesResponse";
277  QString requestId = pendingRequestIds.dequeue();
278 
279  const std::map<std::string, std::string> &states = msg.getTunerStates();
280  emit tunerStatesUpdated(states);
281 }
282 
283 void TRMMonitor::operator() (const GetAllTunerIdsResponse &msg)
284 {
285  process(msg);
286  qDebug() << "handleGetAllTunerIdsResponse";
287 
288  QString requestId = pendingRequestIds.dequeue();
289  if(requestId != QString(msg.getUUID().c_str()))
290  {
291  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
292  Q_ASSERT(false);
293  }
294  else {
295  }
296 
297  tunerIds = msg.getTunerIds();
298  /* save a copy of tuner Ids */
299  std::list<std::string>::iterator it = tunerIds.begin();
300  for (it = tunerIds.begin(); it != tunerIds.end(); it++) {
301  qDebug() << "TunerID: " << (*it).c_str();
302  }
303 
304  emit tunerIdsUpdated(tunerIds);
305 }
306 
307 void TRMMonitor::operator() (const GetAllReservationsResponse &msg)
308 {
309  process(msg);
310  qDebug() << "handleGetAllReservationsResponse";
311 
312  QString requestId = pendingRequestIds.dequeue();
313  if(requestId != QString(msg.getUUID().c_str()))
314  {
315  qDebug() << "RequestId: [" << requestId << "] vs Response Id: [" << msg.getUUID().c_str() << "]";
316  Q_ASSERT(false);
317  }
318  else {
319  }
320 
321  const std::map<std::string, std::list<TunerReservation> > & reservations = msg.getAllReservations();
322  emit tunerReservationsUpdated(reservations);
323 }
324 
325 void TRMMonitor::operator() (const NotifyTunerReservationUpdate &msg)
326 {
327  process(msg);
328  qDebug() << "NotifyTunerReservationUpdate";
329 
330  sendGetAllReservations();
331  sendGetAllTunerStates();
332 }
333 
334 void TRMMonitor::operator() (const NotifyTunerReservationRelease &msg)
335 {
336  process(msg);
337  qDebug() << "NotifyTunerReservationRelease";
338 
339  sendGetAllReservations();
340  sendGetAllTunerStates();
341 }
342 
343 void TRMMonitor::operator() (const NotifyTunerReservationConflicts &msg)
344 {
345  process(msg);
346  std::cout << "NotifyTunerReservationConflicts =======================================" << std::endl;
347 
348  const ReserveTunerResponse::ConflictCT &conflicts = msg.getConflicts();
349 
350  if (conflicts.size() != 0) {
351  std::cout << "handleReserveTunerResponse FOUND CONFLICTS=======================================" << std::endl;
352  emit conflictsReceived(conflicts);
353  }
354  else {
355  std::cout << "handleReserveTunerResponse NO CONFLICTS=======================================" << std::endl;
356  }
357 
358  sendGetAllReservations();
359  sendGetAllTunerStates();
360 }
361 
362 void TRMMonitor::operator() (const NotifyTunerStatesUpdate &msg)
363 {
364  process(msg);
365  qDebug() << "NotifyTunerStatesUpdate";
366 }
367 
368 void TRMMonitor::operator() (const NotifyTunerPretune &msg)
369 {
370  process(msg);
371  std::cout << "NotifyTunerPretune" << msg.getServiceLocator().c_str() << std::endl;
372 }
373 
374 #endif
375 
376 
377 /** @} */
378 /** @} */
TRM::ValidateTunerReservation
Implements the message format for client to validate an existing tuner reservation.
Definition: Messages.h:1168
TRM::ValidateTunerReservationResponse
Implements the response message payload for Tuner reservation validation requests.
Definition: Messages.h:1118
TRM::ResponseStatus
This class is responsible for handling response message for tuner reservation. All response messages ...
Definition: ResponseStatus.h:62
TRM::CancelRecording
Implements a message to cancel the recording.
Definition: Messages.h:1241
TRM::ReserveTunerResponse::getConflicts
const ConflictCT & getConflicts(void) const
This function returns an array of existing tuner reservations that is in conflict with the requested ...
Definition: Messages.h:914
TRM::NotifyTunerReservationConflicts::getConflicts
const ConflictCT & getConflicts(void) const
This function will return the array of tuner reservation conflicts.
Definition: Messages.h:2001
TRM::Activity
The Activity class represents the request or granted usage of a tuner. The activity field in the clas...
Definition: Activity.h:92
TRM::ReleaseTunerReservation
Implements the message payload for releasing tuner reservation.
Definition: Messages.h:1094
TRM::ReserveTuner
Class implementing a Tuner reservation request, the client uses this message to request,...
Definition: Messages.h:972
TRM::Client
Definition: Client.h:42
TRM::CancelRecordingResponse
Implements payload for a response message against cancel recording request.
Definition: Messages.h:1194
TRM::ValidateTunerReservationResponse::isValid
bool isValid(void) const
This function returns whether the token requested is valid or not.
Definition: Messages.h:1143
TRM::NotifyTunerPretune
Implements a Notification message when a pre tune has performed.
Definition: Messages.h:2076
TRM::GetAllTunerStatesResponse::getTunerStates
const std::map< std::string, std::string > & getTunerStates(void) const
This function will return the tuner states which is an enumeration of detailed tuner states at time o...
Definition: Messages.h:1585
TRM::ReleaseTunerReservationResponse
Class implementing the response message payload for releasing Tuner reservation.
Definition: Messages.h:1046
TRM::GetAllTunerStates
Implements a request message for getting the state of all tuners in the system.
Definition: Messages.h:1668
TRM::NotifyTunerReservationConflicts
Class for implementing asynchronous notification from TRM to the owner of a token that a tuner reserv...
Definition: Messages.h:1945
TRM::ReserveTunerResponse
Class implementing the response message to a ReserveTuner request.
Definition: Messages.h:858
TRM::GetAllTunerIdsResponse::getTunerIds
const std::list< std::string > & getTunerIds(void) const
This function will return an array of tuner id.
Definition: Messages.h:1399
Messages.h
TRM::GetAllTunerIdsResponse
Implements the response message payload against a Tuner Id request.
Definition: Messages.h:1378
TRM::GetAllTunerStatesResponse
Implements the response payload against a Get tuner state request.
Definition: Messages.h:1563
TRM::GetAllReservationsResponse
Implements the response message for the request to get All tuner reservation details.
Definition: Messages.h:1692
TRM::NotifyTunerStatesUpdate
Class for implementing an asynchronous Notification from TRM whenever a tuner has changed it state.
Definition: Messages.h:2037
TRM::GetAllTunerIds
Implements the message payload format for requesting the system allocated Unique Id of tuner....
Definition: Messages.h:1439
TRM::GetAllReservations
Implements a request message to get reservation detail of all the tuners that are valid at that time.
Definition: Messages.h:1727
TRM::TunerReservationBase
The TunerReservation class is used to set the requested or granted tuner reservation from client....
Definition: TunerReservation.h:139
TRM::NotifyTunerReservationUpdate
Implements the asynchronous Notification from TRM whenever a reservation has changed its usage by its...
Definition: Messages.h:1892
TRM::NotifyTunerReservationRelease
Class to implement asynchronous Notification from TRM to the owner of a token that its tuner reservat...
Definition: Messages.h:1845