dom/tv/FakeTVService.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/TVServiceRunnables.h"
   8 #include "mozilla/dom/TVTypes.h"
   9 #include "nsCOMPtr.h"
  10 #include "nsIMutableArray.h"
  11 #include "nsITimer.h"
  12 #include "nsServiceManagerUtils.h"
  13 #include "prtime.h"
  14 #include "FakeTVService.h"
  15
  16 namespace mozilla {
  17 namespace dom {
  18
  19 NS_IMPL_CYCLE_COLLECTION_CLASS(FakeTVService)
  20
  21 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(FakeTVService)
  22   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourceListener)
  23   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTuners)
  24   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChannels)
  25   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPrograms)
  26   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEITBroadcastedTimer)
  27   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScanCompleteTimer)
  28 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  29
  30 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(FakeTVService)
  31   tmp->Shutdown();
  32   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSourceListener)
  33   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTuners)
  34   NS_IMPL_CYCLE_COLLECTION_UNLINK(mChannels)
  35   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPrograms)
  36   NS_IMPL_CYCLE_COLLECTION_UNLINK(mEITBroadcastedTimer)
  37   NS_IMPL_CYCLE_COLLECTION_UNLINK(mScanCompleteTimer)
  38 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  39
  40 NS_IMPL_CYCLE_COLLECTING_ADDREF(FakeTVService)
  41 NS_IMPL_CYCLE_COLLECTING_RELEASE(FakeTVService)
  42
  43 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FakeTVService)
  44   NS_INTERFACE_MAP_ENTRY(nsITVService)
  45   NS_INTERFACE_MAP_ENTRY(nsISupports)
  46 NS_INTERFACE_MAP_END
  47
  48 FakeTVService::FakeTVService()
  49 {
  50   Init();
  51 }
  52
  53 FakeTVService::~FakeTVService()
  54 {
  55   Shutdown();
  56 }
  57
  58 void
  59 FakeTVService::Init()
  60 {
  61   const char* sourceTypes1[2] = {"dvb-t", "dvb-c"};
  62   nsCOMPtr<nsITVTunerData> tunerData1 = MockTuner(NS_LITERAL_STRING("1"), 2, sourceTypes1);
  63   mTuners.AppendElement(tunerData1);
  64   const char* sourceTypes2[1] = {"dvb-s"};
  65   nsCOMPtr<nsITVTunerData> tunerData2 = MockTuner(NS_LITERAL_STRING("2"), 1, sourceTypes2);
  66   mTuners.AppendElement(tunerData2);
  67
  68   nsCOMPtr<nsITVChannelData> channelData1 =
  69     MockChannel(NS_LITERAL_STRING("networkId1"), NS_LITERAL_STRING("transportStreamId1"),
  70                 NS_LITERAL_STRING("serviceId1"), NS_LITERAL_STRING("tv"),
  71                 NS_LITERAL_STRING("1"), NS_LITERAL_STRING("name1"), true, true);
  72   mChannels.AppendElement(channelData1);
  73   nsCOMPtr<nsITVChannelData> channelData2 =
  74     MockChannel(NS_LITERAL_STRING("networkId2"), NS_LITERAL_STRING("transportStreamId2"),
  75                 NS_LITERAL_STRING("serviceId2"), NS_LITERAL_STRING("radio"),
  76                 NS_LITERAL_STRING("2"), NS_LITERAL_STRING("name2"), true, true);
  77   mChannels.AppendElement(channelData2);
  78
  79   uint64_t now = PR_Now();
  80   const char* audioLanguages1[2] = {"eng", "jpn"};
  81   const char* subtitleLanguages1[2] = {"fre", "spa"};
  82   nsCOMPtr<nsITVProgramData> programData1 =
  83     MockProgram(NS_LITERAL_STRING("eventId1"), NS_LITERAL_STRING("title1"),
  84                 now - 1, 3600000,
  85                 NS_LITERAL_STRING("description1"), NS_LITERAL_STRING("rating1"),
  86                 2, audioLanguages1, 2, subtitleLanguages1);
  87   mPrograms.AppendElement(programData1);
  88   nsCOMPtr<nsITVProgramData> programData2 =
  89       MockProgram(NS_LITERAL_STRING("eventId2"), NS_LITERAL_STRING("title2"),
  90                   now + 3600000 , 3600000,
  91                   NS_LITERAL_STRING(""), NS_LITERAL_STRING(""),
  92                   0, nullptr, 0, nullptr);
  93   mPrograms.AppendElement(programData2);
  94 }
  95
  96 void
  97 FakeTVService::Shutdown()
  98 {
  99   if (mEITBroadcastedTimer) {
 100     mEITBroadcastedTimer->Cancel();
 101   }
 102   if (mScanCompleteTimer) {
 103     mScanCompleteTimer->Cancel();
 104   }
 105 }
 106
 107 /* virtual */ NS_IMETHODIMP
 108 FakeTVService::GetSourceListener(nsITVSourceListener** aSourceListener)
 109 {
 110   if (!mSourceListener) {
 111     *aSourceListener = nullptr;
 112     return NS_OK;
 113   }
 114
 115   *aSourceListener = mSourceListener;
 116   NS_ADDREF(*aSourceListener);
 117   return NS_OK;
 118 }
 119
 120 /* virtual */ NS_IMETHODIMP
 121 FakeTVService::SetSourceListener(nsITVSourceListener* aSourceListener)
 122 {
 123   mSourceListener = aSourceListener;
 124   return NS_OK;
 125 }
 126
 127 /* virtual */ NS_IMETHODIMP
 128 FakeTVService::GetTuners(nsITVServiceCallback* aCallback)
 129 {
 130   if (!aCallback) {
 131     return NS_ERROR_INVALID_ARG;
 132   }
 133
 134   nsCOMPtr<nsIMutableArray> tunerDataList = do_CreateInstance(NS_ARRAY_CONTRACTID);
 135   if (!tunerDataList) {
 136     return NS_ERROR_OUT_OF_MEMORY;
 137   }
 138
 139   for (uint32_t i = 0; i < mTuners.Length(); i++) {
 140     tunerDataList->AppendElement(mTuners[i], false);
 141   }
 142
 143   nsCOMPtr<nsIRunnable> runnable =
 144     new TVServiceNotifyRunnable(aCallback, tunerDataList);
 145   return NS_DispatchToCurrentThread(runnable);
 146 }
 147
 148 /* virtual */ NS_IMETHODIMP
 149 FakeTVService::SetSource(const nsAString& aTunerId,
 150                          const nsAString& aSourceType,
 151                          nsITVServiceCallback* aCallback)
 152 {
 153   if (!aCallback) {
 154     return NS_ERROR_INVALID_ARG;
 155   }
 156
 157   for (uint32_t i = 0; i < mTuners.Length(); i++) {
 158     nsString tunerId;
 159     mTuners[i]->GetId(tunerId);
 160     if (aTunerId.Equals(tunerId)) {
 161       uint32_t sourceTypeCount;
 162       char** sourceTypes;
 163       mTuners[i]->GetSupportedSourceTypes(&sourceTypeCount, &sourceTypes);
 164       for (uint32_t j = 0; j < sourceTypeCount; j++) {
 165         nsString sourceType;
 166         sourceType.AssignASCII(sourceTypes[j]);
 167         if (aSourceType.Equals(sourceType)) {
 168           NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(sourceTypeCount, sourceTypes);
 169           nsCOMPtr<nsIRunnable> runnable =
 170             new TVServiceNotifyRunnable(aCallback, nullptr);
 171           return NS_DispatchToCurrentThread(runnable);
 172         }
 173       }
 174       NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(sourceTypeCount, sourceTypes);
 175     }
 176   }
 177
 178   nsCOMPtr<nsIRunnable> runnable =
 179     new TVServiceNotifyRunnable(aCallback, nullptr, nsITVServiceCallback::TV_ERROR_FAILURE);
 180   return NS_DispatchToCurrentThread(runnable);
 181 }
 182
 183 class EITBroadcastedCallback MOZ_FINAL : public nsITimerCallback
 184 {
 185 public:
 186   NS_DECL_ISUPPORTS
 187
 188   EITBroadcastedCallback(const nsAString& aTunerId,
 189                          const nsAString& aSourceType,
 190                          nsITVSourceListener* aSourceListener,
 191                          nsITVChannelData* aChannelData)
 192     : mTunerId(aTunerId)
 193     , mSourceType(aSourceType)
 194     , mSourceListener(aSourceListener)
 195     , mChannelData(aChannelData)
 196   {}
 197
 198   NS_IMETHODIMP
 199   Notify(nsITimer* aTimer) MOZ_OVERRIDE
 200   {
 201     // Notify mock EIT broadcasting.
 202     nsITVProgramData** programDataList =
 203       static_cast<nsITVProgramData **>(NS_Alloc(1 * sizeof(nsITVProgramData*)));
 204     programDataList[0] = new TVProgramData();
 205     programDataList[0]->SetEventId(NS_LITERAL_STRING("eventId"));
 206     programDataList[0]->SetTitle(NS_LITERAL_STRING("title"));
 207     programDataList[0]->SetStartTime(PR_Now() + 3600000);
 208     programDataList[0]->SetDuration(3600000);
 209     programDataList[0]->SetDescription(NS_LITERAL_STRING("description"));
 210     programDataList[0]->SetRating(NS_LITERAL_STRING("rating"));
 211     programDataList[0]->SetAudioLanguages(0, nullptr);
 212     programDataList[0]->SetSubtitleLanguages(0, nullptr);
 213     nsresult rv = mSourceListener->NotifyEITBroadcasted(mTunerId, mSourceType,
 214                                                         mChannelData,
 215                                                         programDataList, 1);
 216     NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(1, programDataList);
 217     return rv;
 218   }
 219
 220 private:
 221   ~EITBroadcastedCallback() {}
 222
 223   nsString mTunerId;
 224   nsString mSourceType;
 225   nsCOMPtr<nsITVSourceListener> mSourceListener;
 226   nsCOMPtr<nsITVChannelData> mChannelData;
 227 };
 228
 229 NS_IMPL_ISUPPORTS(EITBroadcastedCallback, nsITimerCallback)
 230
 231 class ScanCompleteCallback MOZ_FINAL : public nsITimerCallback
 232 {
 233 public:
 234   NS_DECL_ISUPPORTS
 235
 236   ScanCompleteCallback(const nsAString& aTunerId,
 237                        const nsAString& aSourceType,
 238                        nsITVSourceListener* aSourceListener)
 239     : mTunerId(aTunerId)
 240     , mSourceType(aSourceType)
 241     , mSourceListener(aSourceListener)
 242   {}
 243
 244   NS_IMETHODIMP
 245   Notify(nsITimer* aTimer) MOZ_OVERRIDE
 246   {
 247     return mSourceListener->NotifyChannelScanComplete(mTunerId, mSourceType);
 248   }
 249
 250 private:
 251   ~ScanCompleteCallback() {}
 252
 253   nsString mTunerId;
 254   nsString mSourceType;
 255   nsCOMPtr<nsITVSourceListener> mSourceListener;
 256 };
 257
 258 NS_IMPL_ISUPPORTS(ScanCompleteCallback, nsITimerCallback)
 259
 260 /* virtual */ NS_IMETHODIMP
 261 FakeTVService::StartScanningChannels(const nsAString& aTunerId,
 262                                      const nsAString& aSourceType,
 263                                      nsITVServiceCallback* aCallback)
 264 {
 265   if (!aCallback) {
 266     return NS_ERROR_INVALID_ARG;
 267   }
 268
 269   nsCOMPtr<nsIRunnable> runnable =
 270     new TVServiceNotifyRunnable(aCallback, nullptr);
 271   nsresult rv = NS_DispatchToCurrentThread(runnable);
 272   NS_ENSURE_SUCCESS(rv, rv);
 273
 274   if (IsAllowed(aTunerId, aSourceType)) {
 275     rv = mSourceListener->NotifyChannelScanned(aTunerId, aSourceType, mChannels[0]);
 276     NS_ENSURE_SUCCESS(rv, rv);
 277
 278     // Set a timer. |notifyEITBroadcasted| will be called after the timer
 279     // fires (10ms). (The timer could be canceled if |StopScanningChannels| gets
 280     // called before firing.)
 281     mEITBroadcastedTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
 282     NS_ENSURE_TRUE(mEITBroadcastedTimer, NS_ERROR_OUT_OF_MEMORY);
 283     nsRefPtr<EITBroadcastedCallback> eitBroadcastedCb =
 284       new EITBroadcastedCallback(aTunerId, aSourceType, mSourceListener, mChannels[0]);
 285     rv = mEITBroadcastedTimer->InitWithCallback(eitBroadcastedCb, 10,
 286                                                 nsITimer::TYPE_ONE_SHOT);
 287     NS_ENSURE_SUCCESS(rv, rv);
 288
 289     // Set a timer. |notifyChannelScanComplete| will be called after the timer
 290     // fires (20ms). (The timer could be canceled if |StopScanningChannels| gets
 291     // called before firing.)
 292     mScanCompleteTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
 293     NS_ENSURE_TRUE(mScanCompleteTimer, NS_ERROR_OUT_OF_MEMORY);
 294     nsRefPtr<ScanCompleteCallback> scanCompleteCb =
 295       new ScanCompleteCallback(aTunerId, aSourceType, mSourceListener);
 296     rv = mScanCompleteTimer->InitWithCallback(scanCompleteCb, 20,
 297                                               nsITimer::TYPE_ONE_SHOT);
 298     NS_ENSURE_SUCCESS(rv, rv);
 299   }
 300
 301   return NS_OK;
 302 }
 303
 304 /* virtual */ NS_IMETHODIMP
 305 FakeTVService::StopScanningChannels(const nsAString& aTunerId,
 306                                     const nsAString& aSourceType,
 307                                     nsITVServiceCallback* aCallback)
 308 {
 309   if (!aCallback) {
 310     return NS_ERROR_INVALID_ARG;
 311   }
 312
 313   if (mEITBroadcastedTimer) {
 314     mEITBroadcastedTimer->Cancel();
 315     mEITBroadcastedTimer = nullptr;
 316   }
 317   if (mScanCompleteTimer) {
 318     mScanCompleteTimer->Cancel();
 319     mScanCompleteTimer = nullptr;
 320   }
 321   nsresult rv = mSourceListener->NotifyChannelScanStopped(aTunerId, aSourceType);
 322   NS_ENSURE_SUCCESS(rv, rv);
 323
 324   nsCOMPtr<nsIRunnable> runnable =
 325     new TVServiceNotifyRunnable(aCallback, nullptr);
 326   return NS_DispatchToCurrentThread(runnable);
 327 }
 328
 329 /* virtual */ NS_IMETHODIMP
 330 FakeTVService::ClearScannedChannelsCache()
 331 {
 332   // Fake service doesn't support channel cache, so there's nothing to do here.
 333   return NS_OK;
 334 }
 335
 336 /* virtual */ NS_IMETHODIMP
 337 FakeTVService::SetChannel(const nsAString& aTunerId,
 338                           const nsAString& aSourceType,
 339                           const nsAString& aChannelNumber,
 340                           nsITVServiceCallback* aCallback)
 341 {
 342   if (!aCallback) {
 343     return NS_ERROR_INVALID_ARG;
 344   }
 345
 346   nsCOMPtr<nsIMutableArray> channelDataList = do_CreateInstance(NS_ARRAY_CONTRACTID);
 347   if (!channelDataList) {
 348     return NS_ERROR_OUT_OF_MEMORY;
 349   }
 350
 351   if (IsAllowed(aTunerId, aSourceType)) {
 352     for (uint32_t i = 0; i < mChannels.Length(); i++) {
 353       nsString channelNumber;
 354       mChannels[i]->GetNumber(channelNumber);
 355       if (aChannelNumber.Equals(channelNumber)) {
 356         channelDataList->AppendElement(mChannels[i], false);
 357         break;
 358       }
 359     }
 360   }
 361
 362   uint32_t length;
 363   nsresult rv = channelDataList->GetLength(&length);
 364   NS_ENSURE_SUCCESS(rv, rv);
 365
 366   nsCOMPtr<nsIRunnable> runnable = new TVServiceNotifyRunnable(
 367     aCallback,
 368     (length == 1) ? channelDataList : nullptr,
 369     (length == 1) ? nsITVServiceCallback::TV_ERROR_OK : nsITVServiceCallback::TV_ERROR_FAILURE
 370   );
 371   return NS_DispatchToCurrentThread(runnable);
 372 }
 373
 374 /* virtual */ NS_IMETHODIMP
 375 FakeTVService::GetChannels(const nsAString& aTunerId,
 376                            const nsAString& aSourceType,
 377                            nsITVServiceCallback* aCallback)
 378 {
 379   if (!aCallback) {
 380     return NS_ERROR_INVALID_ARG;
 381   }
 382
 383   nsCOMPtr<nsIMutableArray> channelDataList = do_CreateInstance(NS_ARRAY_CONTRACTID);
 384   if (!channelDataList) {
 385     return NS_ERROR_OUT_OF_MEMORY;
 386   }
 387
 388   if (IsAllowed(aTunerId, aSourceType)) {
 389     for (uint32_t i = 0; i < mChannels.Length(); i++) {
 390       channelDataList->AppendElement(mChannels[i], false);
 391     }
 392   }
 393
 394   nsCOMPtr<nsIRunnable> runnable =
 395     new TVServiceNotifyRunnable(aCallback, channelDataList);
 396   return NS_DispatchToCurrentThread(runnable);
 397 }
 398
 399 /* virtual */ NS_IMETHODIMP
 400 FakeTVService::GetPrograms(const nsAString& aTunerId,
 401                            const nsAString& aSourceType,
 402                            const nsAString& aChannelNumber,
 403                            uint64_t startTime,
 404                            uint64_t endTime,
 405                            nsITVServiceCallback* aCallback)
 406 {
 407   if (!aCallback) {
 408     return NS_ERROR_INVALID_ARG;
 409   }
 410
 411   nsCOMPtr<nsIMutableArray> programDataList = do_CreateInstance(NS_ARRAY_CONTRACTID);
 412   if (!programDataList) {
 413     return NS_ERROR_OUT_OF_MEMORY;
 414   }
 415
 416   // Only return mock programs for the first channel.
 417   nsString channelNumber;
 418   mChannels[0]->GetNumber(channelNumber);
 419   if (IsAllowed(aTunerId, aSourceType) && aChannelNumber.Equals(channelNumber)) {
 420     for (uint32_t i = 0; i < mPrograms.Length(); i++) {
 421       programDataList->AppendElement(mPrograms[i], false);
 422     }
 423   }
 424
 425   nsCOMPtr<nsIRunnable> runnable =
 426     new TVServiceNotifyRunnable(aCallback, programDataList);
 427   return NS_DispatchToCurrentThread(runnable);
 428 }
 429
 430 /* virtual */ NS_IMETHODIMP
 431 FakeTVService::GetOverlayId(const nsAString& aTunerId,
 432                             nsITVServiceCallback* aCallback)
 433 {
 434   if (!aCallback) {
 435     return NS_ERROR_INVALID_ARG;
 436   }
 437
 438   nsCOMPtr<nsIMutableArray> overlayIds = do_CreateInstance(NS_ARRAY_CONTRACTID);
 439   if (!overlayIds) {
 440     return NS_ERROR_OUT_OF_MEMORY;
 441   }
 442
 443   // TODO Implement in follow-up patches.
 444
 445   nsCOMPtr<nsIRunnable> runnable =
 446     new TVServiceNotifyRunnable(aCallback, overlayIds);
 447   return NS_DispatchToCurrentThread(runnable);
 448 }
 449
 450 bool
 451 FakeTVService::IsAllowed(const nsAString& aTunerId,
 452                          const nsAString& aSourceType)
 453 {
 454   // Only allow for the first source of the first tuner.
 455   nsString tunerId;
 456   mTuners[0]->GetId(tunerId);
 457   if (!aTunerId.Equals(tunerId)) {
 458     return false;
 459   }
 460
 461   uint32_t sourceTypeCount;
 462   char** sourceTypes;
 463   mTuners[0]->GetSupportedSourceTypes(&sourceTypeCount, &sourceTypes);
 464   nsString sourceType;
 465   sourceType.AssignASCII(sourceTypes[0]);
 466   NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(sourceTypeCount, sourceTypes);
 467   if (!aSourceType.Equals(sourceType)) {
 468     return false;
 469   }
 470
 471   return true;
 472 }
 473
 474 already_AddRefed<nsITVTunerData>
 475 FakeTVService::MockTuner(const nsAString& aId,
 476                          uint32_t aSupportedSourceTypeCount,
 477                          const char** aSupportedSourceTypes)
 478 {
 479   nsCOMPtr<nsITVTunerData> tunerData = new TVTunerData();
 480   tunerData->SetId(aId);
 481   tunerData->SetSupportedSourceTypes(aSupportedSourceTypeCount, aSupportedSourceTypes);
 482   return tunerData.forget();
 483 }
 484
 485 already_AddRefed<nsITVChannelData>
 486 FakeTVService::MockChannel(const nsAString& aNetworkId,
 487                            const nsAString& aTransportStreamId,
 488                            const nsAString& aServiceId,
 489                            const nsAString& aType,
 490                            const nsAString& aNumber,
 491                            const nsAString& aName,
 492                            bool aIsEmergency,
 493                            bool aIsFree)
 494 {
 495   nsCOMPtr<nsITVChannelData> channelData = new TVChannelData();
 496   channelData->SetNetworkId(aNetworkId);
 497   channelData->SetTransportStreamId(aTransportStreamId);
 498   channelData->SetServiceId(aServiceId);
 499   channelData->SetType(aType);
 500   channelData->SetNumber(aNumber);
 501   channelData->SetName(aName);
 502   channelData->SetIsEmergency(aIsEmergency);
 503   channelData->SetIsFree(aIsFree);
 504   return channelData.forget();
 505 }
 506
 507 already_AddRefed<nsITVProgramData>
 508 FakeTVService::MockProgram(const nsAString& aEventId,
 509                            const nsAString& aTitle,
 510                            uint64_t aStartTime,
 511                            uint64_t aDuration,
 512                            const nsAString& aDescription,
 513                            const nsAString& aRating,
 514                            uint32_t aAudioLanguageCount,
 515                            const char** aAudioLanguages,
 516                            uint32_t aSubtitleLanguageCount,
 517                            const char** aSubtitleLanguages)
 518 {
 519   nsCOMPtr<nsITVProgramData> programData = new TVProgramData();
 520   programData->SetEventId(aEventId);
 521   programData->SetTitle(aTitle);
 522   programData->SetStartTime(aStartTime);
 523   programData->SetDuration(aDuration);
 524   programData->SetDescription(aDescription);
 525   programData->SetRating(aRating);
 526   programData->SetAudioLanguages(aAudioLanguageCount, aAudioLanguages);
 527   programData->SetSubtitleLanguages(aSubtitleLanguageCount, aSubtitleLanguages);
 528   return programData.forget();
 529 }
 530
 531 } // namespace dom
 532 } // namespace mozilla