dom/icc/Icc.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "Icc.h"
   6
   7 #include "mozilla/dom/MozIccBinding.h"
   8 #include "mozilla/dom/MozStkCommandEvent.h"
   9 #include "mozilla/dom/DOMRequest.h"
  10 #include "mozilla/dom/ScriptSettings.h"
  11 #include "nsIDOMIccInfo.h"
  12 #include "nsJSON.h"
  13 #include "nsRadioInterfaceLayer.h"
  14 #include "nsServiceManagerUtils.h"
  15
  16 using namespace mozilla::dom;
  17
  18 Icc::Icc(nsPIDOMWindow* aWindow, long aClientId, const nsAString& aIccId)
  19   : mLive(true)
  20   , mClientId(aClientId)
  21   , mIccId(aIccId)
  22 {
  23   SetIsDOMBinding();
  24   BindToOwner(aWindow);
  25
  26   mProvider = do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
  27
  28   // Not being able to acquire the provider isn't fatal since we check
  29   // for it explicitly below.
  30   if (!mProvider) {
  31     NS_WARNING("Could not acquire nsIIccProvider!");
  32   }
  33 }
  34
  35 void
  36 Icc::Shutdown()
  37 {
  38   mProvider = nullptr;
  39   mLive = false;
  40 }
  41
  42 nsresult
  43 Icc::NotifyEvent(const nsAString& aName)
  44 {
  45   return DispatchTrustedEvent(aName);
  46 }
  47
  48 nsresult
  49 Icc::NotifyStkEvent(const nsAString& aName, const nsAString& aMessage)
  50 {
  51   AutoJSAPI jsapi;
  52   if (NS_WARN_IF(!jsapi.InitWithLegacyErrorReporting(GetOwner()))) {
  53     return NS_ERROR_UNEXPECTED;
  54   }
  55   JSContext* cx = jsapi.cx();
  56   JS::Rooted<JS::Value> value(cx);
  57
  58   if (!aMessage.IsEmpty()) {
  59     nsCOMPtr<nsIJSON> json(new nsJSON());
  60     nsresult rv = json->DecodeToJSVal(aMessage, cx, &value);
  61     NS_ENSURE_SUCCESS(rv, rv);
  62   } else {
  63     value = JS::NullValue();
  64   }
  65
  66   MozStkCommandEventInit init;
  67   init.mBubbles = false;
  68   init.mCancelable = false;
  69   init.mCommand = value;
  70
  71   nsRefPtr<MozStkCommandEvent> event =
  72     MozStkCommandEvent::Constructor(this, aName, init);
  73
  74   return DispatchTrustedEvent(event);
  75 }
  76
  77 // WrapperCache
  78
  79 JSObject*
  80 Icc::WrapObject(JSContext* aCx)
  81 {
  82   return MozIccBinding::Wrap(aCx, this);
  83 }
  84
  85 // MozIcc WebIDL
  86
  87 already_AddRefed<nsIDOMMozIccInfo>
  88 Icc::GetIccInfo() const
  89 {
  90   if (!mProvider) {
  91     return nullptr;
  92   }
  93
  94   nsCOMPtr<nsIDOMMozIccInfo> iccInfo;
  95   nsresult rv = mProvider->GetIccInfo(mClientId, getter_AddRefs(iccInfo));
  96   if (NS_FAILED(rv)) {
  97     return nullptr;
  98   }
  99
 100   return iccInfo.forget();
 101 }
 102
 103 void
 104 Icc::GetCardState(nsString& aCardState) const
 105 {
 106   aCardState.SetIsVoid(true);
 107
 108   if (!mProvider) {
 109     return;
 110   }
 111
 112   nsresult rv = mProvider->GetCardState(mClientId, aCardState);
 113   if (NS_FAILED(rv)) {
 114     aCardState.SetIsVoid(true);
 115   }
 116 }
 117
 118 void
 119 Icc::SendStkResponse(const JSContext* aCx, JS::Handle<JS::Value> aCommand,
 120                      JS::Handle<JS::Value> aResponse, ErrorResult& aRv)
 121 {
 122   if (!mProvider) {
 123     aRv.Throw(NS_ERROR_FAILURE);
 124     return;
 125   }
 126
 127   nsresult rv = mProvider->SendStkResponse(mClientId, GetOwner(), aCommand,
 128                                            aResponse);
 129   if (NS_FAILED(rv)) {
 130     aRv.Throw(rv);
 131   }
 132 }
 133
 134 void
 135 Icc::SendStkMenuSelection(uint16_t aItemIdentifier, bool aHelpRequested,
 136                           ErrorResult& aRv)
 137 {
 138   if (!mProvider) {
 139     aRv.Throw(NS_ERROR_FAILURE);
 140     return;
 141   }
 142
 143   nsresult rv = mProvider->SendStkMenuSelection(mClientId,
 144                                                 GetOwner(),
 145                                                 aItemIdentifier,
 146                                                 aHelpRequested);
 147   if (NS_FAILED(rv)) {
 148     aRv.Throw(rv);
 149   }
 150 }
 151
 152 void
 153 Icc::SendStkTimerExpiration(const JSContext* aCx, JS::Handle<JS::Value> aTimer,
 154                             ErrorResult& aRv)
 155 {
 156   if (!mProvider) {
 157     aRv.Throw(NS_ERROR_FAILURE);
 158     return;
 159   }
 160
 161   nsresult rv = mProvider->SendStkTimerExpiration(mClientId, GetOwner(),
 162                                                   aTimer);
 163   if (NS_FAILED(rv)) {
 164     aRv.Throw(rv);
 165   }
 166 }
 167
 168 void
 169 Icc::SendStkEventDownload(const JSContext* aCx, JS::Handle<JS::Value> aEvent,
 170                           ErrorResult& aRv)
 171 {
 172   if (!mProvider) {
 173     aRv.Throw(NS_ERROR_FAILURE);
 174     return;
 175   }
 176
 177   nsresult rv = mProvider->SendStkEventDownload(mClientId, GetOwner(), aEvent);
 178   if (NS_FAILED(rv)) {
 179     aRv.Throw(rv);
 180   }
 181 }
 182
 183 already_AddRefed<DOMRequest>
 184 Icc::GetCardLock(const nsAString& aLockType, ErrorResult& aRv)
 185 {
 186   if (!mProvider) {
 187     aRv.Throw(NS_ERROR_FAILURE);
 188     return nullptr;
 189   }
 190
 191   nsRefPtr<nsIDOMDOMRequest> request;
 192   nsresult rv = mProvider->GetCardLockState(mClientId, GetOwner(), aLockType,
 193                                             getter_AddRefs(request));
 194   if (NS_FAILED(rv)) {
 195     aRv.Throw(rv);
 196     return nullptr;
 197   }
 198
 199   return request.forget().downcast<DOMRequest>();
 200 }
 201
 202 already_AddRefed<DOMRequest>
 203 Icc::UnlockCardLock(const JSContext* aCx, JS::Handle<JS::Value> aInfo,
 204                     ErrorResult& aRv)
 205 {
 206   if (!mProvider) {
 207     aRv.Throw(NS_ERROR_FAILURE);
 208     return nullptr;
 209   }
 210
 211   nsRefPtr<nsIDOMDOMRequest> request;
 212   nsresult rv = mProvider->UnlockCardLock(mClientId, GetOwner(), aInfo,
 213                                           getter_AddRefs(request));
 214   if (NS_FAILED(rv)) {
 215     aRv.Throw(rv);
 216     return nullptr;
 217   }
 218
 219   return request.forget().downcast<DOMRequest>();
 220 }
 221
 222 already_AddRefed<DOMRequest>
 223 Icc::SetCardLock(const JSContext* aCx, JS::Handle<JS::Value> aInfo,
 224                  ErrorResult& aRv)
 225 {
 226   if (!mProvider) {
 227     aRv.Throw(NS_ERROR_FAILURE);
 228     return nullptr;
 229   }
 230
 231   nsRefPtr<nsIDOMDOMRequest> request;
 232   nsresult rv = mProvider->SetCardLock(mClientId, GetOwner(), aInfo,
 233                                        getter_AddRefs(request));
 234   if (NS_FAILED(rv)) {
 235     aRv.Throw(rv);
 236     return nullptr;
 237   }
 238
 239   return request.forget().downcast<DOMRequest>();
 240 }
 241
 242 already_AddRefed<DOMRequest>
 243 Icc::GetCardLockRetryCount(const nsAString& aLockType, ErrorResult& aRv)
 244 {
 245   if (!mProvider) {
 246     aRv.Throw(NS_ERROR_FAILURE);
 247     return nullptr;
 248   }
 249
 250   nsRefPtr<nsIDOMDOMRequest> request;
 251   nsresult rv = mProvider->GetCardLockRetryCount(mClientId,
 252                                                  GetOwner(),
 253                                                  aLockType,
 254                                                  getter_AddRefs(request));
 255   if (NS_FAILED(rv)) {
 256     aRv.Throw(rv);
 257     return nullptr;
 258   }
 259
 260   return request.forget().downcast<DOMRequest>();
 261 }
 262
 263 already_AddRefed<DOMRequest>
 264 Icc::ReadContacts(const nsAString& aContactType, ErrorResult& aRv)
 265 {
 266   if (!mProvider) {
 267     aRv.Throw(NS_ERROR_FAILURE);
 268     return nullptr;
 269   }
 270
 271   nsRefPtr<nsIDOMDOMRequest> request;
 272   nsresult rv = mProvider->ReadContacts(mClientId, GetOwner(), aContactType,
 273                                         getter_AddRefs(request));
 274   if (NS_FAILED(rv)) {
 275     aRv.Throw(rv);
 276     return nullptr;
 277   }
 278
 279   return request.forget().downcast<DOMRequest>();
 280 }
 281
 282 already_AddRefed<DOMRequest>
 283 Icc::UpdateContact(const JSContext* aCx, const nsAString& aContactType,
 284                    JS::Handle<JS::Value> aContact, const nsAString& aPin2,
 285                    ErrorResult& aRv)
 286 {
 287   if (!mProvider) {
 288     aRv.Throw(NS_ERROR_FAILURE);
 289     return nullptr;
 290   }
 291
 292   nsRefPtr<nsIDOMDOMRequest> request;
 293   nsresult rv = mProvider->UpdateContact(mClientId, GetOwner(), aContactType,
 294                                          aContact, aPin2,
 295                                          getter_AddRefs(request));
 296   if (NS_FAILED(rv)) {
 297     aRv.Throw(rv);
 298     return nullptr;
 299   }
 300
 301   return request.forget().downcast<DOMRequest>();
 302 }
 303
 304 already_AddRefed<DOMRequest>
 305 Icc::IccOpenChannel(const nsAString& aAid, ErrorResult& aRv)
 306 {
 307   if (!mProvider) {
 308     aRv.Throw(NS_ERROR_FAILURE);
 309     return nullptr;
 310   }
 311
 312   nsRefPtr<nsIDOMDOMRequest> request;
 313   nsresult rv = mProvider->IccOpenChannel(mClientId, GetOwner(), aAid,
 314                                           getter_AddRefs(request));
 315   if (NS_FAILED(rv)) {
 316     aRv.Throw(rv);
 317     return nullptr;
 318   }
 319
 320   return request.forget().downcast<DOMRequest>();
 321 }
 322
 323 already_AddRefed<DOMRequest>
 324 Icc::IccExchangeAPDU(const JSContext* aCx, int32_t aChannel,
 325                      JS::Handle<JS::Value> aApdu, ErrorResult& aRv)
 326 {
 327   if (!mProvider) {
 328     aRv.Throw(NS_ERROR_FAILURE);
 329     return nullptr;
 330   }
 331
 332   nsRefPtr<nsIDOMDOMRequest> request;
 333   nsresult rv = mProvider->IccExchangeAPDU(mClientId, GetOwner(), aChannel,
 334                                            aApdu, getter_AddRefs(request));
 335   if (NS_FAILED(rv)) {
 336     aRv.Throw(rv);
 337     return nullptr;
 338   }
 339
 340   return request.forget().downcast<DOMRequest>();
 341 }
 342
 343 already_AddRefed<DOMRequest>
 344 Icc::IccCloseChannel(int32_t aChannel, ErrorResult& aRv)
 345 {
 346   if (!mProvider) {
 347     aRv.Throw(NS_ERROR_FAILURE);
 348     return nullptr;
 349   }
 350
 351   nsRefPtr<nsIDOMDOMRequest> request;
 352   nsresult rv = mProvider->IccCloseChannel(mClientId, GetOwner(), aChannel,
 353                                            getter_AddRefs(request));
 354   if (NS_FAILED(rv)) {
 355     aRv.Throw(rv);
 356     return nullptr;
 357   }
 358
 359   return request.forget().downcast<DOMRequest>();
 360 }
 361
 362 already_AddRefed<DOMRequest>
 363 Icc::MatchMvno(const nsAString& aMvnoType,
 364                const nsAString& aMvnoData,
 365                ErrorResult& aRv)
 366 {
 367   if (!mProvider) {
 368     aRv.Throw(NS_ERROR_FAILURE);
 369     return nullptr;
 370   }
 371
 372   nsRefPtr<nsIDOMDOMRequest> request;
 373   nsresult rv = mProvider->MatchMvno(mClientId, GetOwner(),
 374                                      aMvnoType, aMvnoData,
 375                                      getter_AddRefs(request));
 376   if (NS_FAILED(rv)) {
 377     aRv.Throw(rv);
 378     return nullptr;
 379   }
 380
 381   return request.forget().downcast<DOMRequest>();
 382 }