dom/tv/TVTypes.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/TVUtils.h"
   8 #include "nsCRTGlue.h"
   9 #include "TVTypes.h"
  10
  11 namespace mozilla {
  12 namespace dom {
  13
  14 /*
  15  * Implementation of TVTunerData
  16  */
  17
  18 NS_IMPL_ISUPPORTS(TVTunerData, nsITVTunerData)
  19
  20 TVTunerData::TVTunerData()
  21   : mSupportedSourceTypes(nullptr)
  22   , mCount(0)
  23 {
  24 }
  25
  26 TVTunerData::~TVTunerData()
  27 {
  28   if (mSupportedSourceTypes) {
  29     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCount, mSupportedSourceTypes);
  30   }
  31 }
  32
  33 /* virtual */ NS_IMETHODIMP
  34 TVTunerData::GetId(nsAString& aId)
  35 {
  36   aId = mId;
  37   return NS_OK;
  38 }
  39
  40 /* virtual */ NS_IMETHODIMP
  41 TVTunerData::SetId(const nsAString& aId)
  42 {
  43   if (aId.IsEmpty()) {
  44     return NS_ERROR_INVALID_ARG;
  45   }
  46
  47   mId = aId;
  48   return NS_OK;
  49 }
  50
  51 /* virtual */ NS_IMETHODIMP
  52 TVTunerData::GetSupportedSourceTypes(uint32_t* aCount,
  53                                      char*** aSourceTypes)
  54 {
  55   *aCount = mCount;
  56
  57   char** sourceTypes = (mCount > 0) ?
  58                        static_cast<char **>(NS_Alloc(mCount * sizeof(char*))) :
  59                        nullptr;
  60   for (uint32_t i = 0; i < mCount; i++) {
  61     sourceTypes[i] = NS_strdup(mSupportedSourceTypes[i]);
  62   }
  63
  64   *aSourceTypes = sourceTypes;
  65   return NS_OK;
  66 }
  67
  68 /* virtual */ NS_IMETHODIMP
  69 TVTunerData::SetSupportedSourceTypes(uint32_t aCount,
  70                                      const char** aSourceTypes)
  71 {
  72   if (aCount == 0) {
  73     return NS_ERROR_INVALID_ARG;
  74   }
  75   NS_ENSURE_ARG_POINTER(aSourceTypes);
  76
  77   for (uint32_t i = 0; i < aCount; i++) {
  78     if (TVSourceType::EndGuard_ == ToTVSourceType(aSourceTypes[i])) {
  79       return NS_ERROR_INVALID_ARG;
  80     }
  81   }
  82
  83   if (mSupportedSourceTypes) {
  84     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCount, mSupportedSourceTypes);
  85   }
  86
  87   mCount = aCount;
  88
  89   mSupportedSourceTypes = (mCount > 0) ?
  90                           static_cast<char **>(NS_Alloc(mCount * sizeof(char*))) :
  91                           nullptr;
  92   for (uint32_t i = 0; i < mCount; i++) {
  93     mSupportedSourceTypes[i] = NS_strdup(aSourceTypes[i]);
  94   }
  95
  96   return NS_OK;
  97 }
  98
  99
 100 /*
 101  * Implementation of TVChannelData
 102  */
 103
 104 NS_IMPL_ISUPPORTS(TVChannelData, nsITVChannelData)
 105
 106 TVChannelData::TVChannelData()
 107   : mIsEmergency(false)
 108   , mIsFree(false)
 109 {
 110 }
 111
 112 TVChannelData::~TVChannelData()
 113 {
 114 }
 115
 116 /* virtual */ NS_IMETHODIMP
 117 TVChannelData::GetNetworkId(nsAString& aNetworkId)
 118 {
 119   aNetworkId = mNetworkId;
 120   return NS_OK;
 121 }
 122
 123 /* virtual */ NS_IMETHODIMP
 124 TVChannelData::SetNetworkId(const nsAString& aNetworkId)
 125 {
 126   if (aNetworkId.IsEmpty()) {
 127     return NS_ERROR_INVALID_ARG;
 128   }
 129
 130   mNetworkId = aNetworkId;
 131   return NS_OK;
 132 }
 133
 134 /* virtual */ NS_IMETHODIMP
 135 TVChannelData::GetTransportStreamId(nsAString& aTransportStreamId)
 136 {
 137   aTransportStreamId = mTransportStreamId;
 138   return NS_OK;
 139 }
 140
 141 /* virtual */ NS_IMETHODIMP
 142 TVChannelData::SetTransportStreamId(const nsAString& aTransportStreamId)
 143 {
 144   if (aTransportStreamId.IsEmpty()) {
 145     return NS_ERROR_INVALID_ARG;
 146   }
 147
 148   mTransportStreamId = aTransportStreamId;
 149   return NS_OK;
 150 }
 151
 152 /* virtual */ NS_IMETHODIMP
 153 TVChannelData::GetServiceId(nsAString& aServiceId)
 154 {
 155   aServiceId = mServiceId;
 156   return NS_OK;
 157 }
 158
 159 /* virtual */ NS_IMETHODIMP
 160 TVChannelData::SetServiceId(const nsAString& aServiceId)
 161 {
 162   if (aServiceId.IsEmpty()) {
 163     return NS_ERROR_INVALID_ARG;
 164   }
 165
 166   mServiceId = aServiceId;
 167   return NS_OK;
 168 }
 169
 170 /* virtual */ NS_IMETHODIMP
 171 TVChannelData::GetType(nsAString& aType)
 172 {
 173   aType = mType;
 174   return NS_OK;
 175 }
 176
 177 /* virtual */ NS_IMETHODIMP
 178 TVChannelData::SetType(const nsAString& aType)
 179 {
 180   if (aType.IsEmpty()) {
 181     return NS_ERROR_INVALID_ARG;
 182   }
 183
 184   if (TVChannelType::EndGuard_ == ToTVChannelType(aType)) {
 185     return NS_ERROR_INVALID_ARG;
 186   }
 187
 188   mType = aType;
 189   return NS_OK;
 190 }
 191
 192 /* virtual */ NS_IMETHODIMP
 193 TVChannelData::GetNumber(nsAString& aNumber)
 194 {
 195   aNumber = mNumber;
 196   return NS_OK;
 197 }
 198
 199 /* virtual */ NS_IMETHODIMP
 200 TVChannelData::SetNumber(const nsAString& aNumber)
 201 {
 202   if (aNumber.IsEmpty()) {
 203     return NS_ERROR_INVALID_ARG;
 204   }
 205
 206   mNumber = aNumber;
 207   return NS_OK;
 208 }
 209
 210 /* virtual */ NS_IMETHODIMP
 211 TVChannelData::GetName(nsAString& aName)
 212 {
 213   aName = mName;
 214   return NS_OK;
 215 }
 216
 217 /* virtual */ NS_IMETHODIMP
 218 TVChannelData::SetName(const nsAString& aName)
 219 {
 220   if (aName.IsEmpty()) {
 221     return NS_ERROR_INVALID_ARG;
 222   }
 223
 224   mName = aName;
 225   return NS_OK;
 226 }
 227
 228 /* virtual */ NS_IMETHODIMP
 229 TVChannelData::GetIsEmergency(bool *aIsEmergency)
 230 {
 231   *aIsEmergency = mIsEmergency;
 232   return NS_OK;
 233 }
 234
 235 /* virtual */ NS_IMETHODIMP
 236 TVChannelData::SetIsEmergency(bool aIsEmergency)
 237 {
 238   mIsEmergency = aIsEmergency;
 239   return NS_OK;
 240 }
 241
 242 /* virtual */ NS_IMETHODIMP
 243 TVChannelData::GetIsFree(bool *aIsFree)
 244 {
 245   *aIsFree = mIsFree;
 246   return NS_OK;
 247 }
 248
 249 /* virtual */ NS_IMETHODIMP
 250 TVChannelData::SetIsFree(bool aIsFree)
 251 {
 252   mIsFree = aIsFree;
 253   return NS_OK;
 254 }
 255
 256
 257 /*
 258  * Implementation of TVProgramData
 259  */
 260
 261 NS_IMPL_ISUPPORTS(TVProgramData, nsITVProgramData)
 262
 263 TVProgramData::TVProgramData()
 264   : mAudioLanguages(nullptr)
 265   , mAudioLanguageCount(0)
 266   , mSubtitleLanguages(nullptr)
 267   , mSubtitleLanguageCount(0)
 268 {
 269 }
 270
 271 TVProgramData::~TVProgramData()
 272 {
 273   if (mAudioLanguages) {
 274     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mAudioLanguageCount, mAudioLanguages);
 275   }
 276   if (mSubtitleLanguages) {
 277     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mSubtitleLanguageCount, mSubtitleLanguages);
 278   }
 279 }
 280
 281 /* virtual */ NS_IMETHODIMP
 282 TVProgramData::GetEventId(nsAString& aEventId)
 283 {
 284   aEventId = mEventId;
 285   return NS_OK;
 286 }
 287
 288 /* virtual */ NS_IMETHODIMP
 289 TVProgramData::SetEventId(const nsAString& aEventId)
 290 {
 291   if (aEventId.IsEmpty()) {
 292     return NS_ERROR_INVALID_ARG;
 293   }
 294
 295   mEventId = aEventId;
 296   return NS_OK;
 297 }
 298
 299 /* virtual */ NS_IMETHODIMP
 300 TVProgramData::GetTitle(nsAString& aTitle)
 301 {
 302   aTitle = mTitle;
 303   return NS_OK;
 304 }
 305
 306 /* virtual */ NS_IMETHODIMP
 307 TVProgramData::SetTitle(const nsAString& aTitle)
 308 {
 309   if (aTitle.IsEmpty()) {
 310     return NS_ERROR_INVALID_ARG;
 311   }
 312
 313   mTitle = aTitle;
 314   return NS_OK;
 315 }
 316
 317 /* virtual */ NS_IMETHODIMP
 318 TVProgramData::GetStartTime(uint64_t *aStartTime)
 319 {
 320   *aStartTime = mStartTime;
 321   return NS_OK;
 322 }
 323
 324 /* virtual */ NS_IMETHODIMP
 325 TVProgramData::SetStartTime(uint64_t aStartTime)
 326 {
 327   mStartTime = aStartTime;
 328   return NS_OK;
 329 }
 330
 331 /* virtual */ NS_IMETHODIMP
 332 TVProgramData::GetDuration(uint64_t *aDuration)
 333 {
 334   *aDuration = mDuration;
 335   return NS_OK;
 336 }
 337
 338 /* virtual */ NS_IMETHODIMP
 339 TVProgramData::SetDuration(uint64_t aDuration)
 340 {
 341   mDuration = aDuration;
 342   return NS_OK;
 343 }
 344
 345 /* virtual */ NS_IMETHODIMP
 346 TVProgramData::GetDescription(nsAString& aDescription)
 347 {
 348   aDescription = mDescription;
 349   return NS_OK;
 350 }
 351
 352 /* virtual */ NS_IMETHODIMP
 353 TVProgramData::SetDescription(const nsAString& aDescription)
 354 {
 355   mDescription = aDescription;
 356   return NS_OK;
 357 }
 358
 359 /* virtual */ NS_IMETHODIMP
 360 TVProgramData::GetRating(nsAString& aRating)
 361 {
 362   aRating = mRating;
 363   return NS_OK;
 364 }
 365
 366 /* virtual */ NS_IMETHODIMP
 367 TVProgramData::SetRating(const nsAString& aRating)
 368 {
 369   mRating = aRating;
 370   return NS_OK;
 371 }
 372
 373 /* virtual */ NS_IMETHODIMP
 374 TVProgramData::GetAudioLanguages(uint32_t* aCount,
 375                                  char*** aLanguages)
 376 {
 377   *aCount = mAudioLanguageCount;
 378
 379   char** languages = (mAudioLanguageCount > 0) ?
 380                      static_cast<char **>(NS_Alloc(mAudioLanguageCount * sizeof(char*))) :
 381                      nullptr;
 382   for (uint32_t i = 0; i < mAudioLanguageCount; i++) {
 383     languages[i] = NS_strdup(mAudioLanguages[i]);
 384   }
 385
 386   *aLanguages = languages;
 387   return NS_OK;
 388 }
 389
 390 /* virtual */ NS_IMETHODIMP
 391 TVProgramData::SetAudioLanguages(uint32_t aCount,
 392                                  const char** aLanguages)
 393 {
 394   if (aCount > 0) {
 395     NS_ENSURE_ARG_POINTER(aLanguages);
 396   }
 397
 398   if (mAudioLanguages) {
 399     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mAudioLanguageCount, mAudioLanguages);
 400   }
 401
 402   mAudioLanguageCount = aCount;
 403
 404   mAudioLanguages = (mAudioLanguageCount > 0) ?
 405                     static_cast<char **>(NS_Alloc(mAudioLanguageCount * sizeof(char*))) :
 406                     nullptr;
 407   for (uint32_t i = 0; i < mAudioLanguageCount; i++) {
 408     mAudioLanguages[i] = NS_strdup(aLanguages[i]);
 409   }
 410
 411   return NS_OK;
 412 }
 413
 414 /* virtual */ NS_IMETHODIMP
 415 TVProgramData::GetSubtitleLanguages(uint32_t* aCount,
 416                                     char*** aLanguages)
 417 {
 418   *aCount = mSubtitleLanguageCount;
 419
 420   char** languages = (mSubtitleLanguageCount > 0) ?
 421                      static_cast<char **>(NS_Alloc(mSubtitleLanguageCount * sizeof(char*))) :
 422                      nullptr;
 423   for (uint32_t i = 0; i < mSubtitleLanguageCount; i++) {
 424     languages[i] = NS_strdup(mSubtitleLanguages[i]);
 425   }
 426
 427   *aLanguages = languages;
 428   return NS_OK;
 429 }
 430
 431 /* virtual */ NS_IMETHODIMP
 432 TVProgramData::SetSubtitleLanguages(uint32_t aCount,
 433                                     const char** aLanguages)
 434 {
 435   if (aCount > 0) {
 436     NS_ENSURE_ARG_POINTER(aLanguages);
 437   }
 438
 439   if (mSubtitleLanguages) {
 440     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mSubtitleLanguageCount, mSubtitleLanguages);
 441   }
 442
 443   mSubtitleLanguageCount = aCount;
 444
 445   mSubtitleLanguages = (mSubtitleLanguageCount > 0) ?
 446                        static_cast<char **>(NS_Alloc(mSubtitleLanguageCount * sizeof(char*))) :
 447                        nullptr;
 448   for (uint32_t i = 0; i < mSubtitleLanguageCount; i++) {
 449     mSubtitleLanguages[i] = NS_strdup(aLanguages[i]);
 450   }
 451
 452   return NS_OK;
 453 }
 454
 455 } // namespace dom
 456 } // namespace mozilla