RDK Documentation (Open Sourced RDK Components)
JanssonParser.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 common
25 * @{
26 **/
27 
28 
29 #include <stdint.h>
30 #include <stdlib.h>
31 #include <vector>
32 #include <memory>
33 #include <limits>
34 
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <unistd.h>
38 #include <string.h>
39 
40 #include "jansson.h"
41 
42 #include "trm/TRM.h"
43 #include "trm/Klass.h"
44 #include "trm/Messages.h"
45 
46 #include "ReservationCustomAttributes.h"
47 #include "Util.h"
48 #include "safec_lib.h"
49 
50 #define DEVICEID_SCRIPT_PATH "/lib/rdk/getDeviceId.sh"
51 #define SCRIPT_OUTPUT_BUFFER_SIZE 512
52 
53 TRM_BEGIN_NAMESPACE
54 
55 static void json_dump_error(const std::string & title, const json_error_t &error);
56 static int vector_dump_callback(const char *buffer, size_t size, void *data);
57 static int vector_load_callback(const char *buffer, size_t size, void *data);
58 
59 static void JsonEncode(const Activity &r, json_t *parent);
60 static void JsonDecode(json_t * parent, Activity& r);
61 
62 static void JsonEncode(const TunerReservation &r, json_t *parent);
63 static void JsonDecode(json_t * parent, TunerReservation & reservation);
64 
65 static void JsonEncode(const DetailedTunerState &r, json_t *parent);
66 static void JsonDecode(json_t * parent, DetailedTunerState & reservation);
67 
68 
69 static void JsonEncode(const NotifyClientConnectionEvent &r, json_t *parent);
70 static void JsonDecode(json_t * parent, NotifyClientConnectionEvent & notification);
71 
72 
73 /*
74  * Classes MsgT that are identical to SimpleTRMRequest will invoke
75  * JsonEncode(MsgT&r, out) -- > JsonEncode(r,out, int=0) --> JsonEncode(r, parent);
76  * JsonDecode(handle, MsgT&r) -- > JsonEncode(handle, r, int=0);
77  */
78 static void JsonEncode(const SimpleTRMRequest & r, std::vector<uint8_t> &out, int);
79 static void JsonEncode(const SimpleTRMRequest &r, json_t *parent);
80 
81 static void JsonDecode(int handle, SimpleTRMRequest & message, int);
82 static void JsonDecode(json_t *parent, SimpleTRMRequest & message);
83 
84 static void JsonEncode(const SimpleTRMResponse &r, json_t *parent);
85 static void JsonDecode(json_t *parent, SimpleTRMResponse & message);
86 
87 static void json_dump_error(const std::string & title, const json_error_t &error)
88 {
89  std::cout << title << "============================" << std::endl;
90  std::cout << "Line : " << error.line << "Column : " << error.column << "Position : " << error.position << std::endl;
91  std::cout << "Source : " << error.source << std::endl;
92  std::cout << "Text : " << error.text << std::endl;
93 }
94 
95 
96 static int vector_dump_callback(const char *buffer, size_t size, void *data)
97 {
98  std::vector<uint8_t> *out = (std::vector<uint8_t> *)data;
99  out->insert(out->end(), buffer, (buffer+size));
100  return 0;
101 }
102 
103 static int vector_load_callback(const char *buffer, size_t size, void *data)
104 {
105  std::vector<uint8_t> *in = (std::vector<uint8_t> *)data;
106  in->insert(in->end(), buffer, (buffer+size));
107  return 0;
108 }
109 
110 /*
111  *
112  * Activity :=
113  * {
114  * "name" : [String] name,
115  * "details" : <Details>,
116  * }
117  *
118  * Details :=
119  * {
120  * "recordingId" : [long] recordingId,
121  * }
122  *
123  */
124 
125 static void JsonEncode(const Activity &r, json_t *parent)
126 {
127  json_t *JT_activity = parent;
128 
129  //Add Parent
130  {
131  json_object_set_new(JT_activity, "name", json_string(r.getActivity()));
132  if (r.hasDetails()) {
133  json_object_set_new(JT_activity, "details", json_object());
134 
135  json_t *JT_details = json_object_get(JT_activity, "details");
136  //Encode Child
137  {
138 #if 1
139  /* Iterate through details and echo back the (key, value) pair */
140  const std::map<Activity::KeyT,Activity::ValT> details = r.getDetails();
141  std::map<Activity::KeyT,Activity::ValT>::const_iterator it = details.begin();
142  while(it != details.end()) {
143  std::cout << "[ENC]Adding Activity(" << it->first << ", " << it->second << ") " << std::endl;
144  json_object_set_new(JT_details, (it->first).c_str(), json_string((it->second).c_str()));
145  it++;
146  }
147 #else
148  if (r == Activity::kRecord) {
149  //uint32_t recordingId = atol(r.getDetail("recordingId").c_str());
150  json_object_set_new(JT_details, "recordingId", json_string(r.getDetail("recordingId").c_str()));
151  }
152  else if (r == Activity::kLive) {
153 
154  }
155  else if (r == Activity::kEAS) {
156 
157  }
158 #endif
159  }
160  }
161  }
162 }
163 
164 static void JsonDecode(json_t * parent, Activity& r)
165 {
166  //Decode parent
167  {
168  json_t *JT_activity = parent;
169  {
170  json_t *JT_name = json_object_get(JT_activity, "name");
171  const char * name = json_string_value(JT_name);
172  std::cout << "[DEC][Activity] name = "<< name << std::endl;
173 
174  r = Activity(name);
175 
176  json_t *JT_details = json_object_get(JT_activity, "details");
177  //Decode child.
178  {
179  const char *key;
180  json_t *value;
181  json_object_foreach(JT_details, key, value) {
182  r.addDetail(key, json_string_value(value));
183  std::cout << "[DEC][Details]"<< key << " = " << json_string_value(value) << std::endl;
184  }
185  }
186 #if 1
187  /* Enable to test EAS feature */
188  struct stat buf;
189  errno_t safec_rc = -1;
190  int ind = -1;
191  if (stat("/tmp/testTRMEAS", &buf) == 0) {
192  safec_rc = strcmp_s("Live", strlen("Live"), name, &ind);
193  ERR_CHK(safec_rc);
194  if((safec_rc == EOK) && (ind == 0)) {
195  std::cout << "Test Live Tune with EAS flag" << std::endl;
196  r.addDetail("eas", "true");
197  }
198  }
199 #endif
200 
201  }
202  }
203 }
204 
205 /*
206  * TunerReservation :=
207  * {
208  * "reservationToken" : [String] reservationToken,
209  * "device" : [String] device,
210  * "serviceLocator" : [String] sourceLocator,
211  * "startTime" (optional) : [long long] startTime,
212  * "duration" (optional) : [long long] duration
213  * "activity" : <Activity>
214  * "customAttributes(optional): <CustomAttributes>
215  * }
216  */
217 static void JsonEncode(const TunerReservation &r, json_t *parent)
218 {
219  json_t *JT_tunerReservation = parent;
220 
221  //Add child
222  {
223  if (!r.getReservationToken().empty())
224  json_object_set_new(JT_tunerReservation, "reservationToken", json_string(r.getReservationToken().c_str()));
225  json_object_set_new(JT_tunerReservation, "device", json_string(r.getDevice().c_str()));
226  json_object_set_new(JT_tunerReservation, "serviceLocator", json_string(r.getServiceLocator().c_str()));
227  json_object_set_new(JT_tunerReservation, "startTime", json_integer(r.getStartTime()));
228  json_object_set_new(JT_tunerReservation, "duration", json_integer(r.getDuration()));
229  json_object_set_new(JT_tunerReservation, "activity", json_object());
230  if (r.getCustomAttributes()) {
231  json_object_set(JT_tunerReservation, "customAttributes", r.getCustomAttributes()->getObject());
232  }
233  else {
234  /* Setting to json null if customAttributes is NULL*/
235  json_object_set(JT_tunerReservation, "customAttributes", json_null());
236  }
237  //@TODO: Asser sizeof(json_int_t) == sizeof(uint64_t)
238 
239  //Encode grandchild
240  {
241  json_t *JT_activity = json_object_get(JT_tunerReservation, "activity");
242  JsonEncode(r.getActivity(), JT_activity);
243  }
244  }
245 }
246 
247 static void JsonDecode(json_t * parent, TunerReservation & reservation)
248 {
249  //Decode parent
250  {
251  json_t *JT_reservation = parent;
252  {
253  json_t *JT_reservationToken = json_object_get(JT_reservation, "reservationToken");
254  json_t *JT_device = json_object_get(JT_reservation, "device");
255  json_t *JT_serviceLocator = json_object_get(JT_reservation, "serviceLocator");
256  json_t *JT_startTime = json_object_get(JT_reservation, "startTime");
257  json_t *JT_duration = json_object_get(JT_reservation, "duration");
258  json_t *JT_activity = json_object_get(JT_reservation, "activity");
259  json_t *JT_customAttributes = json_object_get(JT_reservation, "customAttributes");
260 
261  const char* reservationToken = json_string_value (JT_reservationToken);
262  const char* device = json_string_value (JT_device);
263  const char* serviceLocator = json_string_value (JT_serviceLocator);
264  uint64_t startTime = (JT_startTime ? json_integer_value(JT_startTime) : GetCurrentEpoch());
265  uint64_t duration = (JT_duration ? json_integer_value(JT_duration ) : std::numeric_limits<uint32_t>::min());
266 
267  ReservationCustomAttributes *
268  customAttributes = (JT_customAttributes ? ((!json_is_null(JT_customAttributes)) ? (new ReservationCustomAttributes(JT_customAttributes)) : 0) : 0);
269 
270  if (reservationToken)
271  std::cout << "[DEC][TunerReservation] reservationToken = " << reservationToken << std::endl;
272  std::cout << "[DEC][TunerReservation] device = " << device << std::endl;
273  std::cout << "[DEC][TunerReservation] serviceLocator = " << serviceLocator << std::endl;
274  std::cout << "[DEC][TunerReservation] startTime = " << startTime << std::endl;
275  if (JT_duration)
276  std::cout << "[DEC][TunerReservation] duration = " << duration << std::endl;
277  else
278  std::cout << "[DEC][TunerReservation] duration = " << "[To be Adjusted]" << std::endl;
279  std::cout << "[DEC][TunerReservation] customAttriburtes = " << (customAttributes ? "Present" : "Not Present") << std::endl;
280 
281  //Decode child.
282  {
283  Activity activity;
284  JsonDecode(JT_activity, activity);
285 
286  if (JT_duration == NULL && GetSpecVersion() > SpecVersion(2, 1)) {
287  /* duration is optional for Live */
288  if (activity == Activity::kLive) {
289  /* Leave enough room to avoid overflow handling */
290  Assert(std::numeric_limits<int64_t>::max() > 2 * GetCurrentEpoch());
291  duration = std::numeric_limits<int64_t>::max() - 2 * GetCurrentEpoch();
292  }
293  }
294 
295  std::cout << "[DEC][TunerReservation] duration [Adjusted] = " << duration << std::endl;
296 
297  reservation = TunerReservation(device ? device : "",
298  serviceLocator,
299  startTime,
300  duration,
301  activity,
302  reservationToken ? reservationToken : "",
303  customAttributes);
304  }
305 
306  }
307  }
308 }
309 
310 /*
311  * DetailedTunerState := {
312  * "state" : <State>
313  * “serviceLocator" : [String] sourceLocator
314  * "owners" : {
315  * <Activity> : {
316  * "device" : [String] device
317  * }
318  * ...
319  * }
320  * }
321  */
322 static void JsonEncode(const DetailedTunerState &r, json_t *parent)
323 {
324  json_t *JT_detailedTunerState = parent;
325 
326  //Add child
327  {
328  json_object_set_new(JT_detailedTunerState, "state", json_string(r.getState().c_str()));
329  if (!r.getServiceLocator().empty()) {
330  json_object_set_new(JT_detailedTunerState, "serviceLocator", json_string(r.getServiceLocator().c_str()));
331  json_object_set_new(JT_detailedTunerState, "owners", json_object());
332  {
333  json_t *JT_owners = json_object_get(JT_detailedTunerState, "owners");
334  const std::map<std::string, std::string> & owners = r.getOwners();
335  std::map<std::string, std::string>::const_iterator ito;
336  for (ito = owners.begin(); ito != owners.end(); ito++) {
337  json_object_set_new(JT_owners, ito->first.c_str(), json_object());
338  {
339  json_t *JT_ownersActivity = json_object_get(JT_owners, ito->first.c_str());
340  json_object_set_new(JT_ownersActivity, "device", json_string(ito->second.c_str()));
341  }
342  }
343  }
344  }
345  if (!r.getReservedDeviceId().empty()) {
346  json_object_set_new(JT_detailedTunerState, "reservedDeviceId", json_string(r.getReservedDeviceId().c_str()));
347  }
348  else {
349  }
350  }
351 }
352 
353 static void JsonDecode(json_t * parent, DetailedTunerState & detailedState)
354 {
355  //Decode parent
356  json_t *JT_reservation = parent;
357  json_t *JT_state = json_object_get(JT_reservation, "state");
358  json_t *JT_serviceLocator = json_object_get(JT_reservation, "serviceLocator");
359  json_t *JT_owners = json_object_get(JT_reservation, "owners");
360  json_t *JT_reservedDeviceId = json_object_get(JT_reservation, "reservedDeviceId");
361 
362  const char* state = json_string_value (JT_state);
363  const char* serviceLocator = JT_serviceLocator ? json_string_value (JT_serviceLocator) : "";
364 
365  std::cout << "[DEC][DetailedTunerState] state = " << state << std::endl;
366  if (JT_serviceLocator) {
367  std::cout << "[DEC][DetailedTunerState] serviceLocator = " << serviceLocator << std::endl;
368  }
369  detailedState.setState(state, serviceLocator);
370 
371  //Decode child.
372  if (JT_owners)
373  {
374  //Assert(json_object_size(JT_owners) >= 1);
375  const char *key;
376  json_t *value;
377  json_object_foreach(JT_owners, key, value){
378  const char *activity = key;
379  json_t *JT_ownersActivity = value;
380  json_t *JT_ownerActivityDevice = json_object_get(JT_ownersActivity, "device");
381  const char *device = json_string_value(JT_ownerActivityDevice);
382  if(device == 0) {
383  std::cout << "[ERROR][JsonDecode : ReserveTuner] NULL Device "<< std::endl; //CID:18250 - Forward null issue
384  return;
385  }
386  std::cout << "[DEC][DetailedTunerState][owners][" << activity << "]"
387  "[device] = " << device << std::endl;
388  detailedState.addTunerOwner(activity, device);
389  }
390  }
391 
392  if (JT_reservedDeviceId) {
393  const char* reservedDeviceId = json_string_value (JT_reservedDeviceId);
394  detailedState.setReservedDeviceId(reservedDeviceId);
395  std::cout << "[DEC][DetailedTunerState] reservedDeviceId = " << reservedDeviceId << std::endl;
396  }
397  else {
398  std::cout << "[DEC][DetailedTunerState] reservedDeviceId = " << "NONE" << std::endl;
399  }
400 }
401 
402 int JsonDecode(const std::vector<uint8_t> &in, Enum<Klass> &klass)
403 {
404 
405  json_error_t error;
406  json_t * parent = json_loadb((const char *)&in[0], in.size(), JSON_DISABLE_EOF_CHECK, &error);
407 
408  if (parent == 0) {
409  json_dump_error("Load Error", error);
410  }
411  else
412  //Decode parent
413  {
414  const char *key;
415  json_t *value;
416  json_object_foreach(parent, key, value){
417  //First key is "className", first value is json object.
418  Assert(json_object_size(parent) == 1);
419  klass = Klass(key).getClass();
420  }
421  }
422 
423  return (int)parent;
424 }
425 
426 /*
427  * "reserveTuner" =:
428  * {
429  * "requestId" : [String] requestId,
430  * "device" : [String] device,
431  * "tunerReservation" : <TunerReservation>
432  * }
433  */
434 void JsonEncode(const ReserveTuner &r, std::vector<uint8_t> &out)
435 {
436  json_t * parent = json_object();
437 
438  //Add parent
439  {
440  json_object_set_new(parent, r.getClassName().c_str(), json_object());
441 
442  //Add child
443  {
444  json_t *JT_reserveTuner = json_object_get(parent, r.getClassName().c_str());
445 
446  json_object_set_new(JT_reserveTuner, "requestId", json_string(r.getUUID().c_str()));
447  json_object_set_new(JT_reserveTuner, "device", json_string(r.getDevice().c_str()));
448  json_object_set_new(JT_reserveTuner, "tunerReservation", json_object());
449  json_object_set_new(JT_reserveTuner, "resurrect", json_string(r.getResurrect().c_str()));
450 
451  //Encode grandchild
452  {
453  JsonEncode(r.getTunerReservation(), json_object_get(JT_reserveTuner, "tunerReservation"));
454  }
455  }
456  }
457 
458  //@TODO: only enable JSON_PRESERVE_ORDER for debug builds.
459  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
460  json_decref(parent);
461 }
462 
463 void JsonDecode(int handle, ReserveTuner & message)
464 {
465  json_t * parent = (json_t *)handle;
466 
467  if (parent == 0) {
468  std::cout << "[ERROR][JsonDecode : ReserveTuner] NULL Handle "<< std::endl;
469  }
470  else
471  //Decode parent
472  {
473  const char *key;
474  json_t *value;
475  json_object_foreach(parent, key, value){
476  Assert(json_object_size(parent) == 1);
477  json_t *JT_reserveTuner = value;
478  {
479  json_t *JT_requestId = json_object_get(JT_reserveTuner, "requestId");
480  json_t *JT_device = json_object_get(JT_reserveTuner, "device");
481  json_t *JT_tunerReservation = json_object_get(JT_reserveTuner, "tunerReservation");
482  json_t *JT_resurrect = json_object_get(JT_reserveTuner, "resurrect");
483 
484  const char *requestId = json_string_value(JT_requestId);
485  const char *device = json_string_value(JT_device);
486  const char *resurrect = (JT_resurrect ? json_string_value(JT_resurrect) : "false");
487 
488  Assert(resurrect != 0);
489  if(device == 0) {
490  std::cout << "[ERROR][JsonDecode : ReserveTuner] NULL Device "<< std::endl; //CID:18576 - Forward null issue
491  return;
492  }
493  std::cout << "[DEC][ReserveTuner] requestId = "<< requestId << std::endl;
494  std::cout << "[DEC][ReserveTuner] device = " << device << std::endl;
495  std::cout << "[DEC][ReserveTuner] resurrect = "<< resurrect << std::endl;
496 
497  {
498  TunerReservation tunerReservation;
499  JsonDecode(JT_tunerReservation, tunerReservation);
500  message = ReserveTuner(requestId, device, tunerReservation,resurrect);
501  }
502  }
503  }
504  json_decref(parent);
505  }
506 }
507 
508 /*
509  * "reserveTunerResponse" =:
510  * {
511  * "requestId" : [String] requestId,
512  * "status" : [String] status,
513  * "statusMessage" (optional) : [String] statusMessage
514  * "tunerReservation" : <TunerReservation>
515  * "conflicts" : [ [<TunerReservation>, ...], ...]
516  * }
517  */
518 void JsonEncode(const ReserveTunerResponse &r, std::vector<uint8_t> &out)
519 {
520  json_t * parent = json_object();
521 
522  //Add parent
523  {
524  json_object_set_new(parent, r.getClassName().c_str(), json_object());
525 
526  //Add child
527  {
528  json_t *JT_reserveTunerResponse = json_object_get(parent, r.getClassName().c_str());
529 
530  json_object_set_new(JT_reserveTunerResponse, "requestId", json_string(r.getUUID().c_str()));
531  json_object_set_new(JT_reserveTunerResponse, "status", json_string(r.getStatus().getStatusCode()));
532  json_object_set_new(JT_reserveTunerResponse, "statusMessage", json_string(r.getStatus().getDetails().c_str()));
533  if(!r.getTunerReservation().getReservationToken().empty())
534  json_object_set_new(JT_reserveTunerResponse, "tunerReservation",json_object());
535  if(r.getConflicts().size())
536  json_object_set_new(JT_reserveTunerResponse, "conflicts",json_array());
537 
538  //Encode grandchild
539  {
540  json_t *JT_tunerReservation = json_object_get(JT_reserveTunerResponse, "tunerReservation");
541  if (JT_tunerReservation) {
542  JsonEncode(r.getTunerReservation(), JT_tunerReservation);
543  }
544 
545  //Conflicts is a List of List of Reservations.
546  //Each sublist represents all reservations from a same tuner.
547 
548  json_t *JT_conflicts = json_object_get(JT_reserveTunerResponse, "conflicts");
549  if (JT_conflicts)
550  { //
551  typedef ReserveTunerResponse::ConflictCT ConflictsCT;
552  typedef ReserveTunerResponse::ReservationCT ReservationCT;
553 
554  const ConflictsCT & conflicts = r.getConflicts();
555  ConflictsCT::const_iterator itc;
556  for (itc = conflicts.begin(); itc != conflicts.end(); itc++) {
557  json_t *JT_singleReservation = json_object();
558  JsonEncode(*itc, JT_singleReservation);
559  json_array_append_new(JT_conflicts, JT_singleReservation);
560  }
561  }
562  }
563  }
564  }
565 
566  //@TODO: only enable JSON_PRESERVE_ORDER for debug builds.
567  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
568  json_decref(parent);
569 }
570 
571 void JsonDecode(int handle, ReserveTunerResponse & message)
572 {
573  json_t * parent = (json_t *)handle;
574 
575  if (parent == 0) {
576  std::cout << "[ERROR][JsonDecode : ReserveTunerResponse] NULL Handle "<< std::endl;
577  }
578  else
579  //Decode parent
580  {
581  const char *key;
582  json_t *value;
583  json_object_foreach(parent, key, value){
584  //first key is "className", first value is json object.
585  Assert(json_object_size(parent) == 1);
586  json_t *JT_reserveTunerResponse = value;
587  {
588  json_t *JT_requestId = json_object_get(JT_reserveTunerResponse, "requestId");
589  json_t *JT_status = json_object_get(JT_reserveTunerResponse, "status");
590  json_t *JT_statusMessage = json_object_get(JT_reserveTunerResponse, "statusMessage");
591  json_t *JT_tunerReservation = json_object_get(JT_reserveTunerResponse, "tunerReservation");
592  json_t *JT_conflicts = json_object_get(JT_reserveTunerResponse, "conflicts");
593 
594  const char *requestId = json_string_value(JT_requestId);
595  const char *status = json_string_value(JT_status);
596  const char *statusMessage = json_string_value(JT_statusMessage);
597 
598  if (/***/JT_requestId) {
599  std::cout << "[DEC][ReserveTunerResponse] requestId = " << requestId << std::endl;
600  }
601  if (/***/JT_status) {
602  std::cout << "[DEC][ReserveTunerResponse] status = " << status << std::endl;
603  }
604  if (/***/JT_statusMessage) {
605  std::cout << "[DEC][ReserveTunerResponse] statusMessage = " << statusMessage<< std::endl;
606  }
607  if (/***/JT_tunerReservation){
608  TunerReservation tunerReservation;
609  JsonDecode(JT_tunerReservation, tunerReservation);
610  //TODO: message is reinit'd by assignment here, what happens if JT_tunerReservation is 0 but JT_conflicts
611  message = ReserveTunerResponse(requestId, ResponseStatus(status, statusMessage), tunerReservation);
612  }
613  else {
614  message = ReserveTunerResponse(requestId, ResponseStatus(status, statusMessage), TunerReservation());
615  }
616  if (/***/JT_conflicts) {
617  //conflicts is a list of list.
618  int numOfConflicts = json_array_size(JT_conflicts);
619 
620  for (int i = 0; i < numOfConflicts; i++) {
621  json_t *JT_singleReservation = json_array_get(JT_conflicts, i);
622  if (/***/JT_singleReservation) {
623  TunerReservation tunerReservation;
624  JsonDecode(JT_singleReservation, tunerReservation);
625  message.addConflict(tunerReservation);
626  }
627  }
628  }
629  }
630  }
631  json_decref(parent);
632  }
633 }
634 /*
635  * Messages with the following format are Simple TRM Requests.
636  *
637  * <Message Name> =:
638  * {
639  * "requestId" : [String] requestId,
640  * "device" (optional) : [String] device,
641  * "reservationToken" : [String] reservationToken,
642  * }
643  *
644  * Known TRM Requests:
645  *
646  * - releaseTunerReservation
647  * - validateTunerReservation
648  * - cancelRecording
649  *
650  */
651 static void JsonEncode(const SimpleTRMRequest &r, json_t *parent)
652 {
653  json_t *JT_simpleRequest = parent;
654 
655  //Add parent
656  {
657  json_object_set_new(JT_simpleRequest, "requestId", json_string(r.getUUID().c_str()));
658  if (!r.getDevice().empty())
659  json_object_set_new(JT_simpleRequest, "device", json_string(r.getDevice().c_str()));
660  if (!r.getReservationToken().empty())
661  json_object_set_new(JT_simpleRequest, "reservationToken", json_string(r.getReservationToken().c_str()));
662  }
663 }
664 
665 static void JsonEncode(const SimpleTRMRequest & r, std::vector<uint8_t> &out, int)
666 {
667  json_t * parent = json_object();
668 
669  if (parent != 0)
670  {//Add parent
671  json_object_set_new(parent, r.getClassName().c_str(), json_object());
672  json_t *JT_request = json_object_get(parent, r.getClassName().c_str());
673 
674  //Add child
675  {
676  JsonEncode(r, JT_request);
677  }
678 
679  //@TODO: only enable JSON_PRESERVE_ORDER for debug builds.
680  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
681  json_decref(parent);
682  }
683 }
684 
685 static void JsonDecode(json_t *parent, SimpleTRMRequest & message)
686 {
687  if (parent == 0) {
688  }
689  else
690  //Decode parent
691  {
692  {
693  json_t *JT_simpleRequest = parent;
694 
695  json_t *JT_requestId = json_object_get(JT_simpleRequest, "requestId");
696  json_t *JT_device = json_object_get(JT_simpleRequest, "device");
697  json_t *JT_reservationToken = json_object_get(JT_simpleRequest, "reservationToken");
698 
699  const char *requestId = json_string_value(JT_requestId);
700  const char *device = json_string_value(JT_device);
701  const char *reservationToken = json_string_value(JT_reservationToken);
702  std::cout << "[DEC][" << SimpleTRMRequest::klassName() << "]requestId = " << requestId << std::endl;
703  std::cout << "[DEC][" << SimpleTRMRequest::klassName() << "]device : " << (device != 0 ? device : "") << std::endl;
704  if (reservationToken != 0)
705  std::cout << "[DEC][" << SimpleTRMRequest::klassName() << "]reservationToken = " << reservationToken << std::endl;
706 
707  message = SimpleTRMRequest(message.getClassName(), requestId, (device != 0 ? device : ""), (reservationToken != 0 ? reservationToken : ""));
708  }
709  }
710 }
711 
712 static void JsonDecode(int handle, SimpleTRMRequest & message, int)
713 {
714  json_t * parent = (json_t *)handle;
715  if (parent == 0) {
716 
717  }
718  else {
719  const char *key;
720  json_t *value;
721 
722  json_object_foreach(parent, key, value) {
723  //First key is "className", first value is json object.
724  Assert(json_object_size(parent) == 1);
725  json_t *JT_simpleRequest = value;
726  {
727  JsonDecode(JT_simpleRequest, message);
728  }
729  }
730  json_decref(parent);
731  }
732 }
733 
734 void JsonEncode(const ReleaseTunerReservation & r, std::vector<uint8_t> &out)
735 {
736  JsonEncode(r, out, 0/*Dummy*/);
737 }
738 
739 void JsonDecode(int handle, ReleaseTunerReservation & message)
740 {
741  JsonDecode(handle, message, 0/*Dummy*/);
742 }
743 
744 void JsonEncode(const ValidateTunerReservation & r, std::vector<uint8_t> &out)
745 {
746  JsonEncode(r, out, 0/*Dummy*/);
747 }
748 
749 void JsonDecode(int handle, ValidateTunerReservation & message)
750 {
751  JsonDecode(handle, message, 0/*Dummy*/);
752 }
753 
754 void JsonEncode(const CancelRecording & r, std::vector<uint8_t> &out)
755 {
756  JsonEncode(r, out, 0/*Dummy*/);
757 }
758 
759 void JsonDecode(int handle, CancelRecording & message)
760 {
761  JsonDecode(handle, message, 0/*Dummy*/);
762 }
763 
764 /*
765  * Messages with the following format are Simple TRM Responses.
766  *
767  * <Message Name> =:
768  * {
769  * "requestId" : [String] requestId,
770  "status" : [String] status,
771  "statusMessage" (optional): [String] statusMessage
772  * "reservationToken" : [String] reservationToken,
773  * }
774  *
775  * Known TRM Responses:
776  *
777  * - releaseTunerReservationResponse
778  * - validateTunerReservationResponse
779  * - cancelRecordingResponse
780  *
781  */
782 static void JsonEncode(const SimpleTRMResponse &r, json_t *parent)
783 {
784  json_t *JT_simpleResponse = parent;
785  //Add parent
786  {
787  json_object_set_new(JT_simpleResponse, "requestId", json_string(r.getUUID().c_str()));
788  json_object_set_new(JT_simpleResponse, "status", json_string(r.getStatus().getStatusCode()));
789  if (!r.getStatus().getDetails().empty())
790  json_object_set_new(JT_simpleResponse, "statusMessage", json_string(r.getStatus().getDetails().c_str()));
791  if (!r.getReservationToken().empty())
792  json_object_set_new(JT_simpleResponse, "reservationToken",json_string(r.getReservationToken().c_str()));
793  }
794 }
795 
796 static void JsonDecode(json_t *parent, SimpleTRMResponse & message)
797 {
798  if (parent == 0) {
799  }
800  else
801  //Decode parent
802  {
803  json_t *JT_simpleResponse = parent;
804  {
805  json_t *JT_requestId = json_object_get(JT_simpleResponse, "requestId");
806  json_t *JT_status = json_object_get(JT_simpleResponse, "status");
807  json_t *JT_statusMessage = json_object_get(JT_simpleResponse, "statusMessage");
808  json_t *JT_reservationToken = json_object_get(JT_simpleResponse, "reservationToken");
809 
810 
811  const char *requestId = json_string_value(JT_requestId);
812  const char *status = json_string_value(JT_status);
813  const char *statusMessage = json_string_value(JT_statusMessage);
814  const char *reservationToken = json_string_value(JT_reservationToken);
815 
816  std::cout << "[DEC][" << SimpleTRMResponse::klassName() << "]requestId = " << requestId << std::endl;
817  std::cout << "[DEC][" << SimpleTRMResponse::klassName() << "]status = " << status << std::endl;
818  if (statusMessage)
819  std::cout << "[DEC][" << SimpleTRMResponse::klassName() << "]statusMessage = " << statusMessage << std::endl;
820  if (reservationToken)
821  std::cout << "[DEC][" << SimpleTRMResponse::klassName() << "]reservationToken = " << reservationToken << std::endl;
822 
823  message = SimpleTRMResponse(message.getClassName(), requestId, ResponseStatus(status, statusMessage == 0 ? "" : statusMessage), reservationToken != 0 ? reservationToken : "");
824  }
825  }
826 }
827 
828 void JsonEncode(const ReleaseTunerReservationResponse &r, std::vector<uint8_t> &out)
829 {
830  json_t * parent = json_object();
831  //Add parent
832  if (parent == 0) {
833 
834  }
835  else
836  {//Add parent
837  json_object_set_new(parent, r.getClassName().c_str(), json_object());
838  //Add child
839  {
840  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
841  JsonEncode(r, JT_response);
842  json_object_set_new(JT_response, "released",json_string(r.isReleased() ? "true" : "false"));
843  }
844 
845  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
846  json_decref(parent);
847  }
848 
849 }
850 
851 void JsonDecode(int handle, ReleaseTunerReservationResponse & message)
852 {
853  json_t * parent = (json_t *)handle;
854  if (parent == 0) {
855  }
856  else
857  //Decode parent
858  {
859  const char *key;
860  json_t *value;
861  json_object_foreach(parent, key, value){
862  //first key is "className", first value is json object.'
863  Assert(json_object_size(parent) == 1);
864  json_t *JT_simpleResponse = value;
865  {
866  JsonDecode(JT_simpleResponse, message);
867  json_t *JT_released = json_object_get(JT_simpleResponse, "released");
868  const char *released = json_string_value(JT_released);
869  bool isReleased = (std::string(released).compare("true") == 0);
870  message.setReleased(isReleased);
871  }
872  }
873  json_decref(parent);
874  }
875 }
876 
877 void JsonEncode(const ValidateTunerReservationResponse &r, std::vector<uint8_t> &out)
878 {
879  json_t * parent = json_object();
880  //Add parent
881  if (parent == 0) {
882 
883  }
884  else
885  {//Add parent
886  json_object_set_new(parent, r.getClassName().c_str(), json_object());
887  //Add child
888  {
889  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
890  JsonEncode(r, JT_response);
891  json_object_set_new(JT_response, "valid",json_string(r.isValid() ? "true" : "false"));
892  }
893 
894  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
895  json_decref(parent);
896  }
897 
898 }
899 
900 void JsonDecode(int handle, ValidateTunerReservationResponse & message)
901 {
902  json_t * parent = (json_t *)handle;
903  if (parent == 0) {
904  }
905  else
906  //Decode parent
907  {
908  const char *key;
909  json_t *value;
910  json_object_foreach(parent, key, value){
911  //first key is "className", first value is json object.
912  Assert(json_object_size(parent) == 1);
913  json_t *JT_simpleResponse = value;
914  {
915  JsonDecode(JT_simpleResponse, message);
916  json_t *JT_valid = json_object_get(JT_simpleResponse, "valid");
917  const char *valid = json_string_value(JT_valid);
918  bool isValid = (std::string(valid).compare("true") == 0);
919  message.setValid(isValid);
920  }
921  }
922  json_decref(parent);
923  }
924 }
925 
926 
927 void JsonEncode(const CancelRecordingResponse &r, std::vector<uint8_t> &out)
928 {
929  json_t * parent = json_object();
930  //Add parent
931  if (parent == 0) {
932 
933  }
934  else
935  {//Add parent
936  json_object_set_new(parent, r.getClassName().c_str(), json_object());
937  //Add child
938  {
939  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
940  JsonEncode(r, JT_response);
941  json_object_set_new(JT_response, "cancelled",json_string(r.isCanceled() ? "true" : "false"));
942  }
943 
944  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
945  json_decref(parent);
946  }
947 
948 }
949 
950 void JsonDecode(int handle, CancelRecordingResponse & message)
951 {
952  json_t * parent = (json_t *)handle;
953  if (parent == 0) {
954  }
955  else
956  //Decode parent
957  {
958  const char *key;
959  json_t *value;
960  json_object_foreach(parent, key, value){
961  //first key is "className", first value is json object.
962  Assert(json_object_size(parent) == 1);
963  json_t *JT_simpleResponse = value;
964  {
965  JsonDecode(JT_simpleResponse, message);
966  json_t *JT_canceled = json_object_get(JT_simpleResponse, "cancelled");
967  const char *canceled = JT_canceled ? json_string_value(JT_canceled) : "";
968  bool isCanceled = (std::string(canceled).compare("true") == 0);
969  message.setCanceled(isCanceled);
970  }
971  }
972  json_decref(parent);
973  }
974 }
975 
976 /*
977  * "getAllTunerIds" =:
978  * {
979  * "requestId" : [String] requestId,
980  * "device" : [String] device,
981  * }
982  */
983 void JsonEncode(const GetAllTunerIds &r, std::vector<uint8_t> &out)
984 {
985  JsonEncode(r, out, 0/*Dummy*/);
986 }
987 
988 void JsonDecode(int handle, GetAllTunerIds & message)
989 {
990  JsonDecode(handle, message, 0/*Dummy*/);
991 }
992 
993 /*
994  * "getAllTunerIdsResponse" =:
995  * {
996  * "requestId" : [String] requestId,
997  * "status" : [String] status,
998  * "statusMessage" (optional): [String] statusMessage
999  * "tunerIds" ; [<TunerId>, ... ]
1000  * }
1001  */
1002 void JsonEncode(const GetAllTunerIdsResponse &r, std::vector<uint8_t> &out)
1003 {
1004  json_t * parent = json_object();
1005  //Add parent
1006  if (parent == 0) {
1007 
1008  }
1009  else
1010  {//Add parent
1011  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1012 
1013  {//Add child
1014  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
1015  JsonEncode(r, JT_response);
1016  json_object_set_new(JT_response, "tunerIds", json_array());
1017 
1018  {//Add Array Elements
1019  json_t *JT_tunerIds = json_object_get(JT_response, "tunerIds");
1020  const std::list<std::string> & tunerIds = r.getTunerIds();
1021  std::list<std::string>::const_iterator it;
1022  for (it = tunerIds.begin(); it != tunerIds.end(); it++) {
1023  json_array_append_new(JT_tunerIds, json_string(it->c_str()));
1024  }
1025  }
1026  }
1027 
1028  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1029  json_decref(parent);
1030  }
1031 
1032 }
1033 
1034 void JsonDecode(int handle, GetAllTunerIdsResponse & message)
1035 {
1036  json_t * parent = (json_t *)handle;
1037  if (parent == 0) {
1038  }
1039  else
1040  //Decode parent
1041  {
1042  const char *key;
1043  json_t *value;
1044  json_object_foreach(parent, key, value){
1045  //first key is "className", first value is json object.
1046  Assert(json_object_size(parent) == 1);
1047  json_t *JT_simpleResponse = value;
1048  {
1049  JsonDecode(JT_simpleResponse, message);
1050  json_t *JT_tunerIds = json_object_get(JT_simpleResponse, "tunerIds");
1051  int numOfTuners = json_array_size(JT_tunerIds);
1052  for (int i = 0; i < numOfTuners; i++) {
1053  json_t *JT_id = json_array_get(JT_tunerIds, i);
1054  message.addTunerId(json_string_value(JT_id));
1055  }
1056  }
1057  }
1058  json_decref(parent);
1059  }
1060 }
1061 
1062 void JsonEncode(const GetAllTunerStates &r, std::vector<uint8_t> &out)
1063 {
1064  JsonEncode(r, out, 0/*Dummy*/);
1065 }
1066 
1067 void JsonDecode(int handle, GetAllTunerStates & message)
1068 {
1069  JsonDecode(handle, message, 0/*Dummy*/);
1070 }
1071 
1072 /*
1073  * "TunerState" =:
1074  * {
1075  * <tunerId> : <State>
1076  * ...
1077  * }
1078  *
1079  * "getAllTunerStatesResponse" =:
1080  * {
1081  * "requestId" : [String] requestId,
1082  * "status" : [String] status,
1083  * "statusMessage" (optional): [String] statusMessage
1084  * "allStates" : <TunerState>
1085  * }
1086  */
1087 void JsonEncode(const GetAllTunerStatesResponse &r, std::vector<uint8_t> &out)
1088 {
1089  json_t * parent = json_object();
1090  //Add parent
1091  if (parent == 0) {
1092 
1093  }
1094  else
1095  {//Add parent
1096  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1097 
1098  {//Add child
1099  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
1100  JsonEncode(r, JT_response);
1101  json_object_set_new(JT_response, "allStates", json_object());
1102 
1103  {//Add one <tunerId>: <state> tuple for each tuner
1104  json_t *JT_states = json_object_get(JT_response, "allStates");
1105  const std::map<std::string, std::string> & tunerStates = r.getTunerStates();
1106  std::map<std::string, std::string>::const_iterator it;
1107  for (it = tunerStates.begin(); it != tunerStates.end(); it++) {
1108  json_object_set_new(JT_states, it->first.c_str(), json_string(it->second.c_str()));
1109  }
1110  }
1111 
1112  json_object_set_new(JT_response, "detailedStates", json_object());
1113  {
1114  json_t *JT_detailedStates = json_object_get(JT_response, "detailedStates");
1115  const std::map<std::string, DetailedTunerState> & tunerDetailedStates = r.getTunerDetailedStates();
1116  std::map<std::string, DetailedTunerState>::const_iterator it;
1117  for (it = tunerDetailedStates.begin(); it != tunerDetailedStates.end(); it++) {
1118 
1119  json_object_set_new(JT_detailedStates, it->first.c_str(), json_object());
1120  {
1121  json_t *JT_detailedTunerState = json_object_get(JT_detailedStates, it->first.c_str());
1122  {
1123  JsonEncode(it->second, JT_detailedTunerState);
1124  }
1125  }
1126  }
1127  }
1128  }
1129 
1130  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1131  json_decref(parent);
1132  }
1133 
1134 }
1135 
1136 void JsonDecode(int handle, GetAllTunerStatesResponse & message)
1137 {
1138  json_t * parent = (json_t *)handle;
1139  if (parent == 0) {
1140  }
1141  else
1142  //Decode parent
1143  {
1144  const char *key;
1145  json_t *value;
1146  json_object_foreach(parent, key, value){
1147  //first key is "className", first value is json object.
1148  Assert(json_object_size(parent) == 1);
1149  json_t *JT_simpleResponse = value;
1150  {
1151  JsonDecode(JT_simpleResponse, message);
1152  json_t *JT_states = json_object_get(JT_simpleResponse, "allStates");
1153  //size_t numOfTuners = json_object_size(JT_states);
1154  {//Iterate through all elements of the "states" object
1155  const char *stateKey;
1156  json_t *stateValue;
1157  json_object_foreach(JT_states, stateKey, stateValue){
1158  message.addTunerState(stateKey, json_string_value(stateValue));
1159  }
1160  }
1161  json_t *JT_detailedStates = json_object_get(JT_simpleResponse, "detailedStates");
1162  {//Iterate through all elements of the "detailedStates" object
1163  const char *key;
1164  json_t *value;
1165  json_object_foreach(JT_detailedStates, key, value){
1166  //first key is "className", first value is json object.
1167  const char *&tunerId = key;
1168  json_t *&JT_detailedState = value;
1169  {
1170  DetailedTunerState detailedState;
1171  JsonDecode(JT_detailedState, detailedState);
1172  message.addTunerState(tunerId, detailedState.getState(), detailedState.getServiceLocator(), detailedState.getReservedDeviceId());
1173  std::map<std::string, std::string>::const_iterator owners_it = detailedState.getOwners().begin();
1174  for (owners_it = detailedState.getOwners().begin(); owners_it != detailedState.getOwners().end(); owners_it++)
1175  {
1176  message.addTunerOwner(tunerId, owners_it->first, owners_it->second);
1177  }
1178  }
1179  }
1180  }
1181  }
1182  }
1183  json_decref(parent);
1184  }
1185 }
1186 
1187 /*
1188  *
1189  * Filter :=
1190  * {
1191  * "device" (optional) : [String] device,
1192  * "activity" (optional) : <Activity>,
1193  * "tunerState" (optional) : <State>,
1194  * }
1195  *
1196  * "getAllReservations" =:
1197  * {
1198  * "requestId" : [String] requestId,
1199  * "filters" : [<Filter>,...],
1200  * }
1201  */
1202 
1203 void JsonEncode(const GetAllReservations &r, std::vector<uint8_t> &out)
1204 {
1205  json_t * parent = json_object();
1206  //Add parent
1207  if (parent == 0) {
1208 
1209  }
1210  else
1211  {//Add parent
1212  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1213 
1214  {//Add child
1215  json_t *JT_request = json_object_get(parent, r.getClassName().c_str());
1216  JsonEncode(r, JT_request);
1217  json_object_set_new(JT_request, "filters", json_array());
1218  {
1219  json_t *JT_filters = json_object_get(JT_request, "filters");
1220  {
1221  const std::map<std::string, std::string> filters = r.getFilters();
1222  std::map<std::string, std::string>::const_iterator it = filters.begin();
1223  for (it = filters.begin(); it != filters.end(); it++) {
1224  json_t *JT_singleFilter = json_object();
1225  json_object_set_new(JT_singleFilter, it->first.c_str(), json_string(it->second.c_str()));
1226  json_array_append_new(JT_filters, JT_singleFilter);
1227  }
1228  }
1229  }
1230  }
1231 
1232  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1233  json_decref(parent);
1234  }
1235 }
1236 
1237 void JsonDecode(int handle, GetAllReservations & message)
1238 {
1239  json_t * parent = (json_t *)handle;
1240  if (parent == 0) {
1241  }
1242  else
1243  //Decode parent
1244  {
1245  const char *key;
1246  json_t *value;
1247  json_object_foreach(parent, key, value){
1248  //first key is "className", first value is json object.
1249  Assert(json_object_size(parent) == 1);
1250  json_t *JT_simpleRequest = value;
1251  {
1252  JsonDecode(JT_simpleRequest, message);
1253  json_t *JT_filters = json_object_get(JT_simpleRequest, "filters");
1254  {//Iterate through all elements of the "filters" array
1255  size_t numOfFilters = json_array_size(JT_filters);
1256  for (int i = 0; i < (int)numOfFilters; i++) {
1257  json_t *JT_singleFilter = json_array_get(JT_filters, i);
1258  json_t *JT_deviceFilter = json_object_get(JT_singleFilter, "device");
1259  json_t *JT_activityFilter = json_object_get(JT_singleFilter, "activity");
1260  json_t *JT_stateFilter = json_object_get(JT_singleFilter, "state");
1261 
1262  if (JT_deviceFilter) {
1263  const char * device = json_string_value(JT_deviceFilter);
1264  message.addFilter("device", device);
1265  }
1266  if (JT_activityFilter) {
1267  json_t *JT_activityFilter_name = json_object_get(JT_activityFilter, "name");
1268  if (JT_activityFilter_name) {
1269  const char * activity = json_string_value(JT_activityFilter_name);
1270  message.addFilter("activity", activity);
1271  }
1272  }
1273  if (JT_stateFilter) {
1274  const char * state = json_string_value(JT_stateFilter);
1275  message.addFilter("state", state);
1276  }
1277 
1278  }
1279  }
1280  }
1281  }
1282  json_decref(parent);
1283  }
1284 }
1285 
1286 /*
1287  * "AllReservations" =:
1288  * {
1289  * <tunerId> : [<TunerReservation>,...]
1290  * ...
1291  * }
1292  *
1293  * "GetAllReservationsResponse" =:
1294  * {
1295  * "requestId" : [String] requestId,
1296  * "status" : [String] status,
1297  * "statusMessage" (optional): [String] statusMessage
1298  * "allReservations" : <AllReservations>
1299  * }
1300  */
1301 void JsonEncode(const GetAllReservationsResponse &r, std::vector<uint8_t> &out)
1302 {
1303  json_t * parent = json_object();
1304  //Add parent
1305  if (parent == 0) {
1306 
1307  }
1308  else
1309  {//Add parent
1310  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1311 
1312  {//Add child
1313  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
1314  JsonEncode(r, JT_response);
1315  json_object_set_new(JT_response, "allReservations", json_object());
1316 
1317  {//Add one <tunerId>: [<TunerReservation>,...] tuple for each tuner
1318  json_t *JT_allReservations = json_object_get(JT_response, "allReservations");
1319  const std::map<std::string, std::list<TunerReservation> > & allReservations = r.getAllReservations();
1320  std::map<std::string, std::list<TunerReservation> >::const_iterator itm;
1321  for (itm = allReservations.begin(); itm != allReservations.end(); itm++) {
1322  json_object_set_new(JT_allReservations, itm->first.c_str(), json_array());
1323  {// Add each reservation to the array
1324  json_t *JT_reservations = json_object_get(JT_allReservations, itm->first.c_str());
1325  const std::list<TunerReservation> &reservations = itm->second;
1326  std::list<TunerReservation>::const_iterator itl;
1327  for (itl = reservations.begin(); itl != reservations.end(); itl++) {
1328  json_t *JT_singleReservation = json_object();
1329  JsonEncode(*itl, JT_singleReservation);
1330  json_array_append_new(JT_reservations, JT_singleReservation);
1331  }
1332  }
1333  }
1334  }
1335  }
1336 
1337  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1338  json_decref(parent);
1339  }
1340 
1341 }
1342 
1343 void JsonDecode(int handle, GetAllReservationsResponse & message)
1344 {
1345  json_t * parent = (json_t *)handle;
1346  if (parent == 0) {
1347  }
1348  else
1349  //Decode parent
1350  {
1351  const char *key;
1352  json_t *value;
1353  json_object_foreach(parent, key, value){
1354  //first key is "className", first value is json object.
1355  Assert(json_object_size(parent) == 1);
1356  json_t *JT_simpleResponse = value;
1357  {
1358  JsonDecode(JT_simpleResponse, message);
1359  json_t *JT_allReservations = json_object_get(JT_simpleResponse, "allReservations");
1360  //size_t numOfTuners = json_object_size(JT_allReservations);
1361  {//Iterate through all elements of the "allReservations" object
1362  const char *tunerId;
1363  json_t *JT_reservations;
1364  json_object_foreach(JT_allReservations, tunerId, JT_reservations){
1365  int numOfReservations = json_array_size(JT_reservations);
1366  for (int i = 0; i < numOfReservations; i++) {
1367  json_t *JT_singleReservation = json_array_get(JT_reservations, i);
1368  TunerReservation singleReservation;
1369  JsonDecode(JT_singleReservation, singleReservation);
1370  message.addTunerReservation(tunerId, singleReservation);
1371  }
1372  }
1373  }
1374  }
1375  }
1376  json_decref(parent);
1377  }
1378 }
1379 
1380 void JsonEncode(const GetVersion &r, std::vector<uint8_t> &out)
1381 {
1382  JsonEncode(r, out, 0/*Dummy*/);
1383 }
1384 
1385 void JsonDecode(int handle, GetVersion & message)
1386 {
1387  JsonDecode(handle, message, 0/*Dummy*/);
1388 }
1389 
1390 void JsonEncode(const GetVersionResponse &r, std::vector<uint8_t> &out)
1391 {
1392  json_t * parent = json_object();
1393  //Add parent
1394  if (parent == 0) {
1395 
1396  }
1397  else
1398  {//Add parent
1399  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1400  //Add child
1401  {
1402  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
1403  JsonEncode(r, JT_response);
1404  json_object_set_new(JT_response, "version",json_string(r.getVersion().c_str()));
1405  }
1406 
1407  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1408  json_decref(parent);
1409  }
1410 }
1411 
1412 void JsonDecode(int handle, GetVersionResponse & message)
1413 {
1414  json_t * parent = (json_t *)handle;
1415  if (parent == 0) {
1416  }
1417  else
1418  //Decode parent
1419  {
1420  const char *key;
1421  json_t *value;
1422  json_object_foreach(parent, key, value){
1423  //first key is "className", first value is json object.
1424  Assert(json_object_size(parent) == 1);
1425  json_t *JT_simpleResponse = value;
1426  {
1427  JsonDecode(JT_simpleResponse, message);
1428  json_t *JT_version = json_object_get(JT_simpleResponse, "version");
1429  const char *version = json_string_value(JT_version);
1430  message.setVersion(version);
1431  }
1432  }
1433  json_decref(parent);
1434  }
1435 }
1436 
1437 void JsonEncode(const UpdateTunerActivityStatusResponse &r, std::vector<uint8_t> &out)
1438 {
1439  json_t * parent = json_object();
1440  //Add parent
1441  if (parent == 0) {
1442 
1443  }
1444  else
1445  {//Add parent
1446 
1447  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1448 
1449  {//Add child
1450  json_t *JT_UpdateTunerActivityResponse = json_object_get(parent, r.getClassName().c_str());
1451  json_object_set_new(JT_UpdateTunerActivityResponse, "requestId", json_string(r.getUUID().c_str()));
1452  json_object_set_new(JT_UpdateTunerActivityResponse, "status", json_string(r.getStatus().getStatusCode()));
1453  if (!r.getStatus().getDetails().empty())
1454  json_object_set_new(JT_UpdateTunerActivityResponse, "statusMessage", json_string(r.getStatus().getDetails().c_str()));
1455  }
1456 
1457  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1458  json_decref(parent);
1459  }
1460 }
1461 
1462 void JsonEncode(const UpdateTunerActivityStatus &r, std::vector<uint8_t> &out)
1463 {
1464  json_t * parent = json_object();
1465  //Add parent
1466  if (parent == 0) {
1467 
1468  }
1469  else
1470  {//Add parent
1471 
1472  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1473 
1474  {//Add child
1475  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1476  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1477  json_object_set_new(JT_notification, "device", json_string(r.getDevice().c_str()));
1478  json_object_set_new(JT_notification, "tunerActivityStatus", json_string(r.getTunerActivityStatus().c_str()));
1479  json_object_set_new(JT_notification, "lastActivityTimeStamp", json_string(r.getLastActivityTimeStamp().c_str()));
1480  json_object_set_new(JT_notification, "lastActivityAction", json_string(r.getLastActivityAction().c_str()));
1481  }
1482 
1483  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1484  json_decref(parent);
1485  }
1486 }
1487 
1488 void JsonDecode(int handle, UpdateTunerActivityStatus & message)
1489 {
1490  json_t * parent = (json_t *)handle;
1491  if (parent == 0) {
1492  }
1493  else
1494  //Decode parent
1495  {
1496  const char *key;
1497  json_t *value;
1498  json_object_foreach(parent, key, value){
1499  //first key is "className", first value is json object.
1500  Assert(json_object_size(parent) == 1);
1501  json_t *JT_notification = value;
1502  {
1503  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1504  json_t *JT_device = json_object_get(JT_notification, "device");
1505  json_t *JT_activity = json_object_get(JT_notification, "tunerActivityStatus");
1506  json_t *JT_lastActivityTS = json_object_get(JT_notification, "lastActivityTimeStamp");
1507  json_t *JT_lastActivityAction = json_object_get(JT_notification, "lastActivityAction");
1508 
1509 
1510  const char *requestId = json_string_value(JT_requestId);
1511  const char *device = json_string_value(JT_device);
1512  const char *activity = json_string_value(JT_activity);
1513  const char *lastActivityTS = json_string_value(JT_lastActivityTS);
1514  const char *lastActivityAction = json_string_value(JT_lastActivityAction);
1515 
1516  Assert(requestId != 0);
1517  Assert(device != 0);
1518  Assert(activity != 0);
1519  if(lastActivityTS == NULL ) lastActivityTS = "";
1520  if(lastActivityAction == NULL ) lastActivityAction = "";
1521 
1522  std::cout << "[DEC][" << UpdateTunerActivityStatus::klassName() << "]requestId = " << requestId << std::endl;
1523  std::cout << "[DEC][" << UpdateTunerActivityStatus::klassName() << "]device = " << device << std::endl;
1524 
1525  std::cout << "[DEC][" << UpdateTunerActivityStatus::klassName() << "]tunerActivityStatus = " << activity << std::endl;
1526  std::cout << "[DEC][" << UpdateTunerActivityStatus::klassName() << "]lastActivityTimeStamp = " << lastActivityTS << std::endl;
1527  std::cout << "[DEC][" << UpdateTunerActivityStatus::klassName() << "]lastActivityAction = " << lastActivityAction << std::endl;
1528 
1529  message = UpdateTunerActivityStatus(requestId,device,activity,lastActivityTS,lastActivityAction);
1530  message.print();
1531  }
1532  }
1533  json_decref(parent);
1534  }
1535 
1536 }
1537 
1538 
1539 /*
1540  * notifyTunerReservationRelease" =:
1541  * {
1542  * "requestId" : [String] requestId,
1543  * "reservationToken" : [String] reservationToken
1544  * "reason" : [String] reason
1545  * }
1546  */
1547 void JsonEncode(const NotifyTunerReservationRelease &r, std::vector<uint8_t> &out)
1548 {
1549  json_t * parent = json_object();
1550  //Add parent
1551  if (parent == 0) {
1552 
1553  }
1554  else
1555  {//Add parent
1556  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1557 
1558  {//Add child
1559  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1560  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1561  json_object_set_new(JT_notification, "reservationToken", json_string(r.getReservationToken().c_str()));
1562  json_object_set_new(JT_notification, "reason", json_string(r.getReason().c_str()));
1563  }
1564 
1565  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1566  json_decref(parent);
1567  }
1568 }
1569 
1570 void JsonDecode(int handle, NotifyTunerReservationRelease & message)
1571 {
1572  json_t * parent = (json_t *)handle;
1573  if (parent == 0) {
1574  }
1575  else
1576  //Decode parent
1577  {
1578  const char *key;
1579  json_t *value;
1580  json_object_foreach(parent, key, value){
1581  //first key is "className", first value is json object.
1582  Assert(json_object_size(parent) == 1);
1583  json_t *JT_notification = value;
1584  {
1585  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1586  json_t *JT_reservationToken = json_object_get(JT_notification, "reservationToken");
1587  json_t *JT_reason = json_object_get(JT_notification, "reason");
1588 
1589 
1590  const char *requestId = json_string_value(JT_requestId);
1591  const char *reservationToken = json_string_value(JT_reservationToken);
1592  const char *reason = json_string_value(JT_reason);
1593 
1594  Assert(requestId != 0);
1595  Assert(reservationToken != 0);
1596  Assert(reason != 0);
1597 
1598  std::cout << "[DEC][" << NotifyTunerReservationRelease::klassName() << "]requestId = " << requestId << std::endl;
1599  std::cout << "[DEC][" << NotifyTunerReservationRelease::klassName() << "]reservationToken = " << reservationToken << std::endl;
1600  std::cout << "[DEC][" << NotifyTunerReservationRelease::klassName() << "]reason = " << reason << std::endl;
1601 
1602  message = NotifyTunerReservationRelease(requestId, reservationToken, reason);
1603  }
1604  }
1605  json_decref(parent);
1606  }
1607 }
1608 
1609 /*
1610  * notifyTunerReservationUpdate" =:
1611  * {
1612  * "requestId" : [String] requestId,
1613  * "tunerReservation" : <TunerReservation>
1614  * }
1615  */
1616 void JsonEncode(const NotifyTunerReservationUpdate &r, std::vector<uint8_t> &out)
1617 {
1618  json_t * parent = json_object();
1619  //Add parent
1620  if (parent == 0) {
1621 
1622  }
1623  else
1624  {//Add parent
1625  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1626 
1627  {//Add child
1628  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1629  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1630  json_object_set_new(JT_notification, "tunerReservation", json_object());
1631 
1632  //Encode grandchild
1633  {
1634  JsonEncode(r.getTunerReservation(), json_object_get(JT_notification, "tunerReservation"));
1635  }
1636  }
1637 
1638  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1639  json_decref(parent);
1640  }
1641 }
1642 
1643 void JsonDecode(int handle, NotifyTunerReservationUpdate & message)
1644 {
1645  json_t * parent = (json_t *)handle;
1646  if (parent == 0) {
1647  }
1648  else
1649  //Decode parent
1650  {
1651  const char *key;
1652  json_t *value;
1653  json_object_foreach(parent, key, value){
1654  //first key is "className", first value is json object.
1655  Assert(json_object_size(parent) == 1);
1656  json_t *JT_notification = value;
1657  {
1658  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1659  json_t *JT_tunerReservation = json_object_get(JT_notification, "tunerReservation");
1660 
1661  const char *requestId = json_string_value(JT_requestId);
1662  Assert(requestId != 0);
1663 
1664  if (/***/JT_requestId) {
1665  std::cout << "[DEC][" << NotifyTunerReservationUpdate::klassName() << "]requestId = " << requestId << std::endl;
1666  }
1667 
1668  if (/***/JT_tunerReservation){
1669  TunerReservation tunerReservation;
1670  JsonDecode(JT_tunerReservation, tunerReservation);
1671  message = NotifyTunerReservationUpdate(requestId, tunerReservation);
1672  }
1673  }
1674  }
1675  json_decref(parent);
1676  }
1677 }
1678 
1679 /*
1680  * notifyTunerReservationConflict" =:
1681  * {
1682  * "requestId" : [String] requestId,
1683  * "tunerReservation" : <TunerReservation>
1684  * "conflicts" : [<TunerReservation>]
1685  * }
1686  */
1687 void JsonEncode(const NotifyTunerReservationConflicts &r, std::vector<uint8_t> &out)
1688 {
1689  json_t * parent = json_object();
1690  //Add parent
1691  if (parent == 0) {
1692 
1693  }
1694  else
1695  {//Add parent
1696  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1697 
1698  {//Add child
1699  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1700  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1701  json_object_set_new(JT_notification, "tunerReservation", json_object());
1702  if(r.getConflicts().size())
1703  json_object_set_new(JT_notification, "conflicts", json_array());
1704 
1705  //Encode grandchild
1706  {
1707  JsonEncode(r.getTunerReservation(), json_object_get(JT_notification, "tunerReservation"));
1708 
1709  json_t *JT_conflicts = json_object_get(JT_notification, "conflicts");
1710  if (JT_conflicts)
1711  { //
1712  typedef NotifyTunerReservationConflicts::ConflictCT ConflictsCT;
1713 
1714  const ConflictsCT & conflicts = r.getConflicts();
1715  ConflictsCT::const_iterator itc;
1716  for (itc = conflicts.begin(); itc != conflicts.end(); itc++) {
1717  json_t *JT_singleReservation = json_object();
1718  JsonEncode(*itc, JT_singleReservation);
1719  json_array_append_new(JT_conflicts, JT_singleReservation);
1720  }
1721  }
1722  }
1723  }
1724 
1725  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1726  json_decref(parent);
1727  }
1728 }
1729 
1730 void JsonDecode(int handle, NotifyTunerReservationConflicts & message)
1731 {
1732  json_t * parent = (json_t *)handle;
1733  if (parent == 0) {
1734  }
1735  else
1736  //Decode parent
1737  {
1738  const char *key;
1739  json_t *value;
1740  json_object_foreach(parent, key, value){
1741  //first key is "className", first value is json object.
1742 
1743  Assert(json_object_size(parent) == 1);
1744  json_t *JT_notification = value;
1745  {
1746  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1747  json_t *JT_tunerReservation = json_object_get(JT_notification, "tunerReservation");
1748  json_t *JT_conflicts = json_object_get(JT_notification, "conflicts");
1749 
1750  const char *requestId = json_string_value(JT_requestId);
1751 
1752  if (/***/JT_requestId) {
1753  std::cout << "[DEC][NotifyTunerReservationConflicts] requestId = " << requestId << std::endl;
1754  }
1755 
1756  if (/***/JT_tunerReservation){
1757  TunerReservation tunerReservation;
1758  JsonDecode(JT_tunerReservation, tunerReservation);
1759  message = NotifyTunerReservationConflicts(requestId, tunerReservation);
1760  }
1761 
1762  if (/***/JT_conflicts) {
1763  //conflicts is a list of list.
1764  int numOfConflicts = json_array_size(JT_conflicts);
1765 
1766  for (int i = 0; i < numOfConflicts; i++) {
1767  json_t *JT_singleReservation = json_array_get(JT_conflicts, i);
1768  if (/***/JT_singleReservation) {
1769  TunerReservation tunerReservation;
1770  JsonDecode(JT_singleReservation, tunerReservation);
1771  message.addConflict(tunerReservation);
1772  }
1773  }
1774  }
1775  }
1776  }
1777  json_decref(parent);
1778  }
1779 }
1780 
1781 /*
1782  * NotifyTunerStatesUpdate" =:
1783  * {
1784  * "requestId" : string
1785  * "detailedStates" : <AllTunerDetailedStates>,
1786  * }
1787  */
1788 void JsonEncode(const NotifyTunerStatesUpdate &r, std::vector<uint8_t> &out)
1789 {
1790  json_t * parent = json_object();
1791  //Add parent
1792  if (parent == 0) {
1793 
1794  }
1795  else
1796  {//Add parent
1797  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1798 
1799  {//Add child
1800  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1801  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1802  json_object_set_new(JT_notification, "detailedStates", json_object());
1803  //Encode grandchild
1804  {
1805  json_t *JT_detailedStates = json_object_get(JT_notification, "detailedStates");
1806  const std::map<std::string, DetailedTunerState> & tunerDetailedStates = r.getTunerDetailedStates();
1807  std::map<std::string, DetailedTunerState>::const_iterator it;
1808  for (it = tunerDetailedStates.begin(); it != tunerDetailedStates.end(); it++) {
1809 
1810  json_object_set_new(JT_detailedStates, it->first.c_str(), json_object());
1811  {
1812  json_t *JT_detailedTunerState = json_object_get(JT_detailedStates, it->first.c_str());
1813  {
1814  JsonEncode(it->second, JT_detailedTunerState);
1815  }
1816  }
1817  }
1818 
1819  }
1820  }
1821 
1822  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1823  json_decref(parent);
1824  }
1825 }
1826 
1827 void JsonDecode(int handle, NotifyTunerStatesUpdate & message)
1828 {
1829  json_t * parent = (json_t *)handle;
1830  if (parent == 0) {
1831  }
1832  else
1833  //Decode parent
1834  {
1835  const char *key;
1836  json_t *value;
1837  json_object_foreach(parent, key, value){
1838  //first key is "className", first value is json object.
1839  Assert(json_object_size(parent) == 1);
1840  json_t *JT_notification = value;
1841  {
1842  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1843  if (/***/JT_requestId) {
1844  const char *requestId = json_string_value(JT_requestId);
1845  std::cout << "[DEC][NotifyTunerStatesUpdate] requestId = " << requestId << std::endl;
1846  }
1847 
1848  json_t *JT_detailedStates = json_object_get(JT_notification, "detailedStates");
1849  const char *tunerId;
1850  json_t *JT_detailedState;
1851  json_object_foreach(JT_detailedStates, tunerId, JT_detailedState){
1852  DetailedTunerState detailedState;
1853  JsonDecode(JT_detailedState, detailedState);
1854  message.addTunerDetailedState(tunerId, detailedState);
1855  }
1856  }
1857  }
1858  json_decref(parent);
1859  }
1860 }
1861 
1862 /*
1863  * notifyTunerPretune" =:
1864  * {
1865  * "requestId" : [String] requestId,
1866  * "serviceLocator" : [String] serviceLocator
1867  * }
1868  */
1869 void JsonEncode(const NotifyTunerPretune &r, std::vector<uint8_t> &out)
1870 {
1871  json_t * parent = json_object();
1872  //Add parent
1873  if (parent == 0) {
1874 
1875  }
1876  else
1877  {//Add parent
1878  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1879 
1880  {//Add child
1881  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
1882  json_object_set_new(JT_notification, "requestId", json_string(r.getUUID().c_str()));
1883  json_object_set_new(JT_notification, "serviceLocator", json_string(r.getServiceLocator().c_str()));
1884  }
1885 
1886  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1887  json_decref(parent);
1888  }
1889 }
1890 
1891 void JsonDecode(int handle, NotifyTunerPretune & message)
1892 {
1893  json_t * parent = (json_t *)handle;
1894  if (parent == 0) {
1895  }
1896  else
1897  //Decode parent
1898  {
1899  const char *key;
1900  json_t *value;
1901  json_object_foreach(parent, key, value){
1902  //first key is "className", first value is json object.
1903  Assert(json_object_size(parent) == 1);
1904  json_t *JT_notification = value;
1905  {
1906  json_t *JT_requestId = json_object_get(JT_notification, "requestId");
1907  json_t *JT_serviceLocator = json_object_get(JT_notification, "serviceLocator");
1908  json_t *JT_reason = json_object_get(JT_notification, "reason");
1909 
1910 
1911  const char *requestId = json_string_value(JT_requestId);
1912  const char *serviceLocator = json_string_value(JT_serviceLocator);
1913 
1914  Assert(requestId != 0);
1915  Assert(serviceLocator != 0);
1916 
1917  std::cout << "[DEC][" << NotifyTunerPretune::klassName() << "]requestId = " << requestId << std::endl;
1918  std::cout << "[DEC][" << NotifyTunerPretune::klassName() << "]serviceLocator = " << serviceLocator << std::endl;
1919 
1920  message = NotifyTunerPretune(requestId, serviceLocator);
1921  }
1922  }
1923  json_decref(parent);
1924  }
1925 }
1926 
1927 void JsonEncode(const CancelLiveResponse &r, std::vector<uint8_t> &out)
1928 {
1929  json_t * parent = json_object();
1930  //Add parent
1931  if (parent == 0) {
1932 
1933  }
1934  else
1935  {//Add parent
1936  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1937  //Add child
1938  {
1939  json_t *JT_cancelLiveResponse = json_object_get(parent, r.getClassName().c_str());
1940  JsonEncode(r, JT_cancelLiveResponse);
1941  json_object_set_new(JT_cancelLiveResponse, "cancelled",json_string(r.isCanceled() ? "true" : "false"));
1942  }
1943 
1944  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
1945  json_decref(parent);
1946  }
1947 
1948 }
1949 
1950 void JsonDecode(int handle, CancelLiveResponse & message)
1951 {
1952  json_t * parent = (json_t *)handle;
1953  if (parent == 0) {
1954  }
1955  else
1956  //Decode parent
1957  {
1958  const char *key;
1959  json_t *value;
1960  json_object_foreach(parent, key, value){
1961  //first key is "className", first value is json object.
1962  Assert(json_object_size(parent) == 1);
1963  json_t *JT_cancelLiveResponse = value;
1964  {
1965  JsonDecode(JT_cancelLiveResponse, message);
1966  json_t *JT_canceled = json_object_get(JT_cancelLiveResponse, "cancelled");
1967  const char *canceled = JT_canceled ? json_string_value(JT_canceled) : "";
1968  bool isCanceled = (std::string(canceled).compare("true") == 0);
1969  message.setCanceled(isCanceled);
1970  }
1971  }
1972  json_decref(parent);
1973  }
1974 }
1975 
1976 /*
1977  * "cancelLive" =:
1978  * {
1979  * "requestId" : [String] requestId,
1980  * "device" : [String] device,
1981  * "reservationToken" : <reservationToken>
1982  * "serviceLocator" : [String] serviceLocator
1983  * }
1984  */
1985 void JsonEncode(const CancelLive &r, std::vector<uint8_t> &out)
1986 {
1987  json_t * parent = json_object();
1988 
1989  //Add parent
1990  {
1991  json_object_set_new(parent, r.getClassName().c_str(), json_object());
1992 
1993  //Add child
1994  {
1995  json_t *JT_cancelLive = json_object_get(parent, r.getClassName().c_str());
1996  JsonEncode(r, JT_cancelLive);
1997  json_object_set_new(JT_cancelLive, "serviceLocator", json_string(r.getServiceLocator().c_str()));
1998  }
1999  }
2000 
2001  //@TODO: only enable JSON_PRESERVE_ORDER for debug builds.
2002  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
2003  json_decref(parent);
2004 }
2005 
2006 void JsonDecode(int handle, CancelLive & message)
2007 {
2008  json_t * parent = (json_t *)handle;
2009 
2010 
2011  if (parent == 0) {
2012  std::cout << "[ERROR][JsonDecode : CancelLive] NULL Handle "<< std::endl;
2013  }
2014  else
2015  //Decode parent
2016  {
2017  const char *key;
2018  json_t *value;
2019  json_object_foreach(parent, key, value){
2020  Assert(json_object_size(parent) == 1);
2021  json_t *JT_cancelLive = value;
2022  {
2023  JsonDecode(JT_cancelLive, message);
2024  json_t *JT_serviceLocator = json_object_get(JT_cancelLive, "serviceLocator");
2025 
2026  const char *serviceLocator = json_string_value(JT_serviceLocator);
2027  std::cout << "[DEC][CanceLive] serviceLocator = "<< serviceLocator << std::endl;
2028  message.setServiceLocator(serviceLocator);
2029  }
2030  }
2031  json_decref(parent);
2032  }
2033 }
2034 
2035 /*
2036  * {"result": "OK", "data": {"deviceId": "P1234567890", "authToken":"abCDefGhijK"}}
2037  */
2038 int JsonDecode(const std::vector<uint8_t> &in, GenerateAuthTokenResponse &response)
2039 {
2040  json_error_t error;
2041 
2042  if (in.size() == 0) {
2043  std::cout <<"[DEC][GenerateAuthTokenResponse]: Parsing Error, size 0" << std::endl;
2044  return 0;
2045  }
2046 
2047  json_t * parent = json_loadb((const char *)&in[0], in.size(), JSON_DISABLE_EOF_CHECK, &error);
2048 
2049  if (parent == 0) {
2050  json_dump_error("Load Error", error);
2051  }
2052  else
2053  {
2054  json_t *JT_result = json_object_get(parent, "result");
2055  json_t *JT_data = json_object_get(parent, "data");
2056  if (JT_result) {
2057  const char* result = json_string_value (JT_result);
2058  }
2059 
2060  if (JT_data) {
2061  json_t *JT_data_deviceId = json_object_get(JT_data, "deviceId");
2062  json_t *JT_data_authToken = json_object_get(JT_data, "authToken");
2063 
2064  if (JT_data_deviceId) {
2065  response.deviceId = (json_string_value (JT_data_deviceId));
2066  }
2067  if (JT_data_authToken) {
2068  response.authToken = (json_string_value (JT_data_authToken));
2069  }
2070  }
2071  }
2072 
2073  json_decref(parent);
2074  return 0;
2075 }
2076 
2077 int JsonDecode(const std::vector<uint8_t> &in, GenerateAuthTokenResponseFromAuthService &response)
2078 {
2079  json_error_t error;
2080 
2081  if (in.size() == 0) {
2082  std::cout <<"[DEC][GenerateAuthTokenResponseFromAuthService]: Parsing Error, size 0" << std::endl;
2083  return 0;
2084  }
2085 
2086  json_t * parent = json_loadb((const char *)&in[0], in.size(), JSON_DISABLE_EOF_CHECK, &error);
2087 
2088  if (parent == 0) {
2089  json_dump_error("Load Error", error);
2090  }
2091  else
2092  {
2093  json_t *JT_deviceId = json_object_get(parent, "deviceId");
2094  json_t *JT_partnerId = json_object_get(parent, "partnerId");
2095 
2096 
2097  if (JT_deviceId) {
2098  response.deviceId = (json_string_value (JT_deviceId));
2099  }
2100  if (JT_partnerId) {
2101  response.partnerId = (json_string_value (JT_partnerId));
2102  }
2103  }
2104 
2105  json_decref(parent);
2106  return 0;
2107 }
2108 
2109 std::string GetDeviceId()
2110 {
2111  static std::string deviceId;
2112  //DELIA-39464 - Getting the device ID from /lib/rdk/getDeviceId.sh
2113  FILE *deviceIdScript = NULL;
2114  char scriptoutput[SCRIPT_OUTPUT_BUFFER_SIZE] = {0};
2115  if (!deviceId.empty()) return deviceId;
2116  deviceIdScript = popen(DEVICEID_SCRIPT_PATH, "r"); // pipe open the script
2117  if( (NULL != deviceIdScript) && deviceId.empty() ){ //Read the output from script
2118  if(fgets(scriptoutput,SCRIPT_OUTPUT_BUFFER_SIZE,deviceIdScript)!=NULL){
2119  std::string jsonResponse_(scriptoutput); //convert the output to sting object.
2120  std::vector<uint8_t> jsonResponse(jsonResponse_.begin(), jsonResponse_.end());
2121  GenerateAuthTokenResponseFromAuthService response;
2122  JsonDecode(jsonResponse, response); //parse the jason format string to object
2123 
2124  Log() << "AuthService::DeviceId = [" << response.deviceId << "]" << std::endl;
2125  deviceId = response.deviceId;
2126  }
2127  }
2128  if (deviceId.empty()) {
2129  static char generateTokenRequest[] = "GET /device/generateAuthToken HTTP/1.0\r\n\r\n";
2130  std::string jsonResponse_ = GetAuthToken(generateTokenRequest);
2131  std::vector<uint8_t> jsonResponse(jsonResponse_.begin(), jsonResponse_.end());
2132  GenerateAuthTokenResponse response;
2133  JsonDecode(jsonResponse, response);
2134 
2135  Log() << "WhiteBox::DeviceId = [" << response.deviceId << "]" << std::endl;
2136  deviceId = response.deviceId;
2137  }
2138  if(NULL != deviceIdScript)
2139  pclose(deviceIdScript);
2140 
2141  return deviceId;
2142 }
2143 
2144 
2145 
2146 /*
2147  * NotifyClientConnectionEvent =:
2148  * {
2149  * "eventName" : [String] Event Type,
2150  * "clientIP" : [String] Client IP Address
2151  * "timeStamp" : [int] Event Time Stamp
2152  * }
2153  */
2154 
2155 void JsonEncode(const NotifyClientConnectionEvent &r, std::vector<uint8_t> &out)
2156 {
2157  json_t * parent = json_object();
2158  //Add parent
2159  if (parent == 0) {
2160 
2161  }
2162  else
2163  {//Add parent
2164  json_object_set_new(parent, r.getClassName().c_str(), json_object());
2165 
2166  {//Add child
2167  json_t *JT_notification = json_object_get(parent, r.getClassName().c_str());
2168  json_object_set_new(JT_notification, "eventName", json_string(r.getEventName().c_str()));
2169  json_object_set_new(JT_notification, "clientIP", json_string(r.getClientIP().c_str()));
2170  json_object_set_new(JT_notification, "timeStamp", json_integer(r.getEventTimeStamp()));
2171  }
2172 
2173  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
2174  json_decref(parent);
2175  }
2176 }
2177 
2178 void JsonDecode(int handle, NotifyClientConnectionEvent & message)
2179 {
2180  json_t * parent = (json_t *)handle;
2181  if (parent == 0) {
2182  }
2183  else
2184  //Decode parent
2185  {
2186  const char *key;
2187  json_t *value;
2188  json_object_foreach(parent, key, value){
2189  //first key is "className", first value is json object.
2190  Assert(json_object_size(parent) == 1);
2191  json_t *JT_notification = value;
2192  {
2193 
2194  json_t *JT_eventName = json_object_get(JT_notification, "eventName");
2195  json_t *JT_clientIP = json_object_get(JT_notification, "clientIP");
2196  json_t *JT_timeStamp = json_object_get(JT_notification, "timeStamp");
2197 
2198 
2199  const char *requestID = "";
2200  const char *eventName = json_string_value(JT_eventName);
2201  const char *clientIP = json_string_value(JT_clientIP);
2202  uint64_t timeStamp = json_integer_value(JT_timeStamp);
2203 
2204 
2205  std::cout << "[DEC][" << NotifyClientConnectionEvent::klassName() << "]eventName = " << eventName << std::endl;
2206  std::cout << "[DEC][" << NotifyClientConnectionEvent::klassName() << "]clientIP = " << clientIP << std::endl;
2207  std::cout << "[DEC][" << NotifyClientConnectionEvent::klassName() << "]timeStamp = " << timeStamp << std::endl;
2208 
2209  message = NotifyClientConnectionEvent(requestID,eventName,clientIP,timeStamp);
2210  }
2211  }
2212  json_decref(parent);
2213  }
2214 }
2215 
2216 
2217 static void JsonEncode(const NotifyClientConnectionEvent &r, json_t *parent)
2218 {
2219  json_t *JT_notification = parent;
2220  json_object_set_new(JT_notification, "eventName",json_string(r.getEventName().c_str()));
2221  json_object_set_new(JT_notification, "clientIP",json_string(r.getClientIP().c_str()));
2222  json_object_set_new(JT_notification, "timeStamp",json_integer(r.getEventTimeStamp()));
2223 }
2224 
2225 static void JsonDecode(json_t * parent, NotifyClientConnectionEvent & notification)
2226 {
2227  json_t *JT_notification = parent;
2228 
2229  json_t *JT_eventName = json_object_get(JT_notification, "eventName");
2230  json_t *JT_clientIP = json_object_get(JT_notification, "clientIP");
2231  json_t *JT_timeStamp = json_object_get(JT_notification, "timeStamp");
2232 
2233  const char *requestID = "";
2234  const char *eventName = json_string_value(JT_eventName);
2235  const char *clientIP = json_string_value(JT_clientIP);
2236  uint64_t timeStamp = json_integer_value(JT_timeStamp);
2237 
2238  std::cout << "[DEC][NotifyClientConnectionEvent] eventName = " << eventName << std::endl;
2239  std::cout << "[DEC][NotifyClientConnectionEvent] clientIP = " << clientIP << std::endl;
2240  std::cout << "[DEC][NotifyClientConnectionEvent] timeStamp = " << timeStamp << std::endl;
2241 }
2242 
2243 /*
2244  * "GetTRMConnectionEvents" =:
2245  * {
2246  * "requestId" : [String] requestId,
2247  * "status" : [String] status,
2248  * "conEventList" ; [<NotifyClientConnectionEvent>.. ]
2249  * }
2250  */
2251 void JsonEncode(const GetTRMConnectionEvents &r, std::vector<uint8_t> &out)
2252 {
2253  json_t * parent = json_object();
2254  //Add parent
2255  if (parent == 0) {
2256 
2257  }
2258  else
2259  {//Add parent
2260  json_object_set_new(parent, r.getClassName().c_str(), json_object());
2261 
2262  {//Add child
2263  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
2264  JsonEncode(r, JT_response);
2265  json_object_set_new(JT_response, "connectionEvents", json_array());
2266 
2267  {//Add Array Elements
2268  typedef GetTRMConnectionEvents::ConnectionEventList conEventLists;
2269 
2270  json_t *JT_eventlist = json_object_get(JT_response, "connectionEvents");
2271  if (JT_eventlist)
2272  { //
2273  const conEventLists & eventList = r.getConEvents();
2274  conEventLists::const_iterator it;
2275  for (it = eventList.begin(); it != eventList.end(); it++) {
2276  json_t *JT_notification = json_object();
2277  JsonEncode(*it, JT_notification);
2278  json_array_append_new(JT_eventlist, JT_notification);
2279  }
2280  }
2281  }
2282  }
2283  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
2284  json_decref(parent);
2285  }
2286 }
2287 
2288 void JsonDecode(int handle, GetTRMConnectionEvents & message)
2289 {
2290  json_t * parent = (json_t *)handle;
2291  if (parent == 0) {
2292  }
2293  else
2294  //Decode parent
2295  {
2296  const char *key;
2297  json_t *value;
2298  json_object_foreach(parent, key, value) {
2299  //first key is "className", first value is json object.
2300  Assert(json_object_size(parent) == 1);
2301  json_t *JT_simpleResponse = value;
2302  {
2303  JsonDecode(JT_simpleResponse, message);
2304  json_t *JT_eventlist = json_object_get(JT_simpleResponse, "connectionEvents");
2305  if (JT_eventlist) {
2306  int numOfEvents = json_array_size(JT_eventlist);
2307 
2308  std::cout << "[DEC][GetTRMConnectionEvents] numOfEvents = " << numOfEvents << std::endl;
2309 
2310  for (int i = 0; i < numOfEvents; i++) {
2311  json_t *JT_singleNotifictaion = json_array_get(JT_eventlist, i);
2312  if (JT_singleNotifictaion) {
2313  NotifyClientConnectionEvent::ConnectionEvent event;
2314  JsonDecode(JT_singleNotifictaion,event);
2315  message.addConEvents(event);
2316  }
2317  }
2318  }
2319 
2320  }
2321  }
2322  json_decref(parent);
2323  }
2324 }
2325 
2326 
2327 /*
2328  * "GetAllConnectedDeviceIdsResponse" =:
2329  * {
2330  * "requestId" : [String] requestId,
2331  * "status" : [String] status,
2332  * "DeviceIds" ; [<DeviceIds>, ... ]
2333  * }
2334  */
2335 void JsonEncode(const GetAllConnectedDeviceIdsResponse &r, std::vector<uint8_t> &out)
2336 {
2337  json_t * parent = json_object();
2338  //Add parent
2339  if (parent == 0) {
2340 
2341  }
2342  else
2343  {//Add parent
2344  json_object_set_new(parent, r.getClassName().c_str(), json_object());
2345 
2346  {//Add child
2347  json_t *JT_response = json_object_get(parent, r.getClassName().c_str());
2348  JsonEncode(r, JT_response);
2349  json_object_set_new(JT_response, "DeviceIds", json_array());
2350 
2351  {//Add Array Elements
2352  json_t *JT_DeviceIds = json_object_get(JT_response, "DeviceIds");
2353  const std::list<std::string> & DeviceIds = r.getDeviceIds();
2354  std::list<std::string>::const_iterator it;
2355  for (it = DeviceIds.begin(); it != DeviceIds.end(); it++) {
2356  json_array_append_new(JT_DeviceIds, json_string(it->c_str()));
2357  }
2358  }
2359  }
2360 
2361  json_dump_callback(parent, vector_dump_callback, &out, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
2362  json_decref(parent);
2363  }
2364 
2365 }
2366 
2367 void JsonDecode(int handle, GetAllConnectedDeviceIdsResponse & message)
2368 {
2369  json_t * parent = (json_t *)handle;
2370  if (parent == 0) {
2371  }
2372  else
2373  //Decode parent
2374  {
2375  const char *key;
2376  json_t *value;
2377  json_object_foreach(parent, key, value){
2378  //first key is "className", first value is json object.
2379  Assert(json_object_size(parent) == 1);
2380  json_t *JT_simpleResponse = value;
2381  {
2382  JsonDecode(JT_simpleResponse, message);
2383  json_t *JT_DeviceIds = json_object_get(JT_simpleResponse, "DeviceIds");
2384  int numOfDevices = json_array_size(JT_DeviceIds);
2385  for (int i = 0; i < numOfDevices; i++) {
2386  json_t *JT_id = json_array_get(JT_DeviceIds, i);
2387  message.addDeviceId(json_string_value(JT_id));
2388  }
2389  }
2390  }
2391  json_decref(parent);
2392  }
2393 }
2394 
2395 void delete_ReservationCustomAttributes(void *p)
2396 {
2397  if (p != NULL) delete ((ReservationCustomAttributes *)p);
2398 }
2399 
2400 
2401 TRM_END_NAMESPACE
2402 
2403 
2404 /** @} */
2405 /** @} */
ReservationCustomAttributes
Definition: ReservationCustomAttributes.h:38
SpecVersion
Definition: Util.h:41
Messages.h