dom/tv/TVChannel.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/Promise.h"
   8 #include "mozilla/dom/TVServiceCallbacks.h"
   9 #include "mozilla/dom/TVServiceFactory.h"
  10 #include "mozilla/dom/TVSource.h"
  11 #include "mozilla/dom/TVTuner.h"
  12 #include "mozilla/dom/TVUtils.h"
  13 #include "nsITVService.h"
  14 #include "nsServiceManagerUtils.h"
  15 #include "TVChannel.h"
  16
  17 namespace mozilla {
  18 namespace dom {
  19
  20 NS_IMPL_CYCLE_COLLECTION_INHERITED(TVChannel, DOMEventTargetHelper,
  21                                    mTVService, mSource)
  22
  23 NS_IMPL_ADDREF_INHERITED(TVChannel, DOMEventTargetHelper)
  24 NS_IMPL_RELEASE_INHERITED(TVChannel, DOMEventTargetHelper)
  25
  26 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(TVChannel)
  27 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
  28
  29 TVChannel::TVChannel(nsPIDOMWindow* aWindow,
  30                      TVSource* aSource)
  31   : DOMEventTargetHelper(aWindow)
  32   , mSource(aSource)
  33 {
  34   MOZ_ASSERT(mSource);
  35 }
  36
  37 TVChannel::~TVChannel()
  38 {
  39 }
  40
  41 /* static */ already_AddRefed<TVChannel>
  42 TVChannel::Create(nsPIDOMWindow* aWindow,
  43                   TVSource* aSource,
  44                   nsITVChannelData* aData)
  45 {
  46   nsRefPtr<TVChannel> channel = new TVChannel(aWindow, aSource);
  47   return (channel->Init(aData)) ? channel.forget() : nullptr;
  48 }
  49
  50 bool
  51 TVChannel::Init(nsITVChannelData* aData)
  52 {
  53   NS_ENSURE_TRUE(aData, false);
  54
  55   nsString channelType;
  56   aData->GetType(channelType);
  57   mType = ToTVChannelType(channelType);
  58   if (NS_WARN_IF(mType == TVChannelType::EndGuard_)) {
  59     return false;
  60   }
  61
  62   aData->GetNetworkId(mNetworkId);
  63   aData->GetTransportStreamId(mTransportStreamId);
  64   aData->GetServiceId(mServiceId);
  65   aData->GetName(mName);
  66   aData->GetNumber(mNumber);
  67   aData->GetIsEmergency(&mIsEmergency);
  68   aData->GetIsFree(&mIsFree);
  69
  70   mTVService = TVServiceFactory::AutoCreateTVService();
  71   NS_ENSURE_TRUE(mTVService, false);
  72
  73   return true;
  74 }
  75
  76 /* virtual */ JSObject*
  77 TVChannel::WrapObject(JSContext* aCx)
  78 {
  79   return TVChannelBinding::Wrap(aCx, this);
  80 }
  81
  82 nsresult
  83 TVChannel::DispatchTVEvent(nsIDOMEvent* aEvent)
  84 {
  85   return DispatchTrustedEvent(aEvent);
  86 }
  87
  88 already_AddRefed<Promise>
  89 TVChannel::GetPrograms(const TVGetProgramsOptions& aOptions, ErrorResult& aRv)
  90 {
  91   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
  92   MOZ_ASSERT(global);
  93
  94   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
  95   if (NS_WARN_IF(aRv.Failed())) {
  96     return nullptr;
  97   }
  98
  99   nsRefPtr<TVTuner> tuner = mSource->Tuner();
 100   nsString tunerId;
 101   tuner->GetId(tunerId);
 102
 103   uint64_t startTime = aOptions.mStartTime.WasPassed() ?
 104                        aOptions.mStartTime.Value() :
 105                        PR_Now();
 106   uint64_t endTime = aOptions.mDuration.WasPassed() ?
 107                      (startTime + aOptions.mDuration.Value()) :
 108                      std::numeric_limits<uint64_t>::max();
 109   nsCOMPtr<nsITVServiceCallback> callback =
 110     new TVServiceProgramGetterCallback(this, promise, false);
 111   nsresult rv =
 112     mTVService->GetPrograms(tunerId,
 113                             ToTVSourceTypeStr(mSource->Type()),
 114                             mNumber,
 115                             startTime,
 116                             endTime,
 117                             callback);
 118   if (NS_WARN_IF(NS_FAILED(rv))) {
 119     promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
 120   }
 121
 122   return promise.forget();
 123 }
 124
 125 void
 126 TVChannel::GetNetworkId(nsAString& aNetworkId) const
 127 {
 128   aNetworkId = mNetworkId;
 129 }
 130
 131 void
 132 TVChannel::GetTransportStreamId(nsAString& aTransportStreamId) const
 133 {
 134   aTransportStreamId = mTransportStreamId;
 135 }
 136
 137 void
 138 TVChannel::GetServiceId(nsAString& aServiceId) const
 139 {
 140   aServiceId = mServiceId;
 141 }
 142
 143 already_AddRefed<TVSource>
 144 TVChannel::Source() const
 145 {
 146   nsRefPtr<TVSource> source = mSource;
 147   return source.forget();
 148 }
 149
 150 TVChannelType
 151 TVChannel::Type() const
 152 {
 153   return mType;
 154 }
 155
 156 void
 157 TVChannel::GetName(nsAString& aName) const
 158 {
 159   aName = mName;
 160 }
 161
 162 void
 163 TVChannel::GetNumber(nsAString& aNumber) const
 164 {
 165   aNumber = mNumber;
 166 }
 167
 168 bool
 169 TVChannel::IsEmergency() const
 170 {
 171   return mIsEmergency;
 172 }
 173
 174 bool
 175 TVChannel::IsFree() const
 176 {
 177   return mIsFree;
 178 }
 179
 180 already_AddRefed<Promise>
 181 TVChannel::GetCurrentProgram(ErrorResult& aRv)
 182 {
 183   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
 184   MOZ_ASSERT(global);
 185
 186   nsRefPtr<Promise> promise = Promise::Create(global, aRv);
 187   if (aRv.Failed()) {
 188     return nullptr;
 189   }
 190
 191   nsRefPtr<TVTuner> tuner = mSource->Tuner();
 192   nsString tunerId;
 193   tuner->GetId(tunerId);
 194
 195   // Get only one program from now on.
 196   nsCOMPtr<nsITVServiceCallback> callback =
 197     new TVServiceProgramGetterCallback(this, promise, true);
 198   nsresult rv =
 199     mTVService->GetPrograms(tunerId,
 200                             ToTVSourceTypeStr(mSource->Type()),
 201                             mNumber,
 202                             PR_Now(),
 203                             std::numeric_limits<uint64_t>::max(),
 204                             callback);
 205   if (NS_WARN_IF(NS_FAILED(rv))) {
 206     promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR);
 207   }
 208
 209   return promise.forget();
 210 }
 211
 212 } // namespace dom
 213 } // namespace mozilla