dom/telephony/TelephonyDialCallback.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 "TelephonyDialCallback.h"
   6
   7 #include "mozilla/dom/MozMobileConnectionBinding.h"
   8 #include "nsIMobileCallForwardingOptions.h"
   9 #include "nsIMobileConnectionService.h"
  10
  11 using namespace mozilla::dom;
  12 using namespace mozilla::dom::telephony;
  13
  14 NS_IMPL_ISUPPORTS_INHERITED(TelephonyDialCallback, TelephonyCallback,
  15                             nsITelephonyDialCallback)
  16
  17 TelephonyDialCallback::TelephonyDialCallback(nsPIDOMWindow* aWindow,
  18                                              Telephony* aTelephony,
  19                                              Promise* aPromise)
  20   : TelephonyCallback(aPromise), mWindow(aWindow), mTelephony(aTelephony)
  21 {
  22   MOZ_ASSERT(mTelephony);
  23 }
  24
  25 nsresult
  26 TelephonyDialCallback::NotifyDialMMISuccess(JSContext* aCx,
  27                                             const MozMMIResult& aResult)
  28 {
  29   JS::Rooted<JS::Value> jsResult(aCx);
  30
  31   if (!ToJSValue(aCx, aResult, &jsResult)) {
  32     JS_ClearPendingException(aCx);
  33     return NS_ERROR_TYPE_ERR;
  34   }
  35
  36   mMMICall->NotifyResult(jsResult);
  37   return NS_OK;
  38 }
  39
  40 // nsITelephonyDialCallback
  41
  42 NS_IMETHODIMP
  43 TelephonyDialCallback::NotifyDialMMI(const nsAString& aServiceCode)
  44 {
  45   mServiceCode.Assign(aServiceCode);
  46
  47   mMMICall = new MMICall(mWindow, aServiceCode);
  48   mPromise->MaybeResolve(mMMICall);
  49   return NS_OK;
  50 }
  51
  52 NS_IMETHODIMP
  53 TelephonyDialCallback::NotifyDialCallSuccess(uint32_t aClientId,
  54                                              uint32_t aCallIndex,
  55                                              const nsAString& aNumber)
  56 {
  57   nsRefPtr<TelephonyCallId> id = mTelephony->CreateCallId(aNumber);
  58   nsRefPtr<TelephonyCall> call =
  59       mTelephony->CreateCall(id, aClientId, aCallIndex,
  60                              nsITelephonyService::CALL_STATE_DIALING);
  61
  62   mPromise->MaybeResolve(call);
  63   return NS_OK;
  64 }
  65
  66 NS_IMETHODIMP
  67 TelephonyDialCallback::NotifyDialMMISuccess(const nsAString& aStatusMessage)
  68 {
  69   AutoJSAPI jsapi;
  70   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
  71     return NS_ERROR_FAILURE;
  72   }
  73
  74   JSContext* cx = jsapi.cx();
  75
  76   MozMMIResult result;
  77   result.mSuccess = true;
  78   result.mServiceCode.Assign(mServiceCode);
  79   result.mStatusMessage.Assign(aStatusMessage);
  80
  81   return NotifyDialMMISuccess(cx, result);
  82 }
  83
  84 NS_IMETHODIMP
  85 TelephonyDialCallback::NotifyDialMMISuccessWithInteger(const nsAString& aStatusMessage,
  86                                                        uint16_t aAdditionalInformation)
  87 {
  88   AutoJSAPI jsapi;
  89   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
  90     return NS_ERROR_FAILURE;
  91   }
  92
  93   JSContext* cx = jsapi.cx();
  94
  95   MozMMIResult result;
  96   result.mSuccess = true;
  97   result.mServiceCode.Assign(mServiceCode);
  98   result.mStatusMessage.Assign(aStatusMessage);
  99   result.mAdditionalInformation.Construct().SetAsUnsignedShort() = aAdditionalInformation;
 100
 101   return NotifyDialMMISuccess(cx, result);
 102 }
 103
 104 NS_IMETHODIMP
 105 TelephonyDialCallback::NotifyDialMMISuccessWithStrings(const nsAString& aStatusMessage,
 106                                                        uint32_t aCount,
 107                                                        const char16_t** aAdditionalInformation)
 108 {
 109   AutoJSAPI jsapi;
 110   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
 111     return NS_ERROR_FAILURE;
 112   }
 113
 114   JSContext* cx = jsapi.cx();
 115
 116   RootedDictionary<MozMMIResult> result(cx);
 117   result.mSuccess = true;
 118   result.mServiceCode.Assign(mServiceCode);
 119   result.mStatusMessage.Assign(aStatusMessage);
 120
 121   nsTArray<nsString> additionalInformation;
 122   for (uint32_t i = 0; i < aCount; i++) {
 123     additionalInformation.AppendElement(nsDependentString(aAdditionalInformation[i]));
 124   }
 125
 126   JS::Rooted<JS::Value> jsAdditionalInformation(cx);
 127   if (!ToJSValue(cx, additionalInformation, &jsAdditionalInformation)) {
 128     JS_ClearPendingException(cx);
 129     return NS_ERROR_TYPE_ERR;
 130   }
 131
 132   result.mAdditionalInformation.Construct().SetAsObject() =
 133     &jsAdditionalInformation.toObject();
 134
 135   return NotifyDialMMISuccess(cx, result);
 136 }
 137
 138 NS_IMETHODIMP
 139 TelephonyDialCallback::NotifyDialMMISuccessWithCallForwardingOptions(const nsAString& aStatusMessage,
 140                                                                      uint32_t aCount,
 141                                                                      nsIMobileCallForwardingOptions** aResults)
 142 {
 143   AutoJSAPI jsapi;
 144   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
 145     return NS_ERROR_FAILURE;
 146   }
 147
 148   JSContext* cx = jsapi.cx();
 149
 150   RootedDictionary<MozMMIResult> result(cx);
 151   result.mSuccess = true;
 152   result.mServiceCode.Assign(mServiceCode);
 153   result.mStatusMessage.Assign(aStatusMessage);
 154
 155   nsTArray<MozCallForwardingOptions> additionalInformation;
 156   for (uint32_t i = 0; i < aCount; i++) {
 157     MozCallForwardingOptions options;
 158
 159     bool active = false;
 160     aResults[i]->GetActive(&active);
 161     options.mActive.Construct(active);
 162
 163     int16_t action = nsIMobileConnection::CALL_FORWARD_ACTION_UNKNOWN;
 164     aResults[i]->GetAction(&action);
 165     if (action != nsIMobileConnection::CALL_FORWARD_ACTION_UNKNOWN) {
 166       options.mAction.Construct(action);
 167     }
 168
 169     int16_t reason = nsIMobileConnection::CALL_FORWARD_REASON_UNKNOWN;
 170     aResults[i]->GetReason(&reason);
 171     if (reason != nsIMobileConnection::CALL_FORWARD_REASON_UNKNOWN) {
 172       options.mReason.Construct(reason);
 173     }
 174
 175     nsAutoString number;
 176     aResults[i]->GetNumber(number);
 177     options.mNumber.Construct(number.get());
 178
 179     int16_t timeSeconds = -1;
 180     aResults[i]->GetTimeSeconds(&timeSeconds);
 181     if (timeSeconds >= 0) {
 182       options.mTimeSeconds.Construct(timeSeconds);
 183     }
 184
 185     int16_t serviceClass = nsIMobileConnection::ICC_SERVICE_CLASS_NONE;
 186     aResults[i]->GetServiceClass(&serviceClass);
 187     if (serviceClass != nsIMobileConnection::ICC_SERVICE_CLASS_NONE) {
 188       options.mServiceClass.Construct(serviceClass);
 189     }
 190
 191     additionalInformation.AppendElement(options);
 192   }
 193
 194   JS::Rooted<JS::Value> jsAdditionalInformation(cx);
 195   if (!ToJSValue(cx, additionalInformation, &jsAdditionalInformation)) {
 196     JS_ClearPendingException(cx);
 197     return NS_ERROR_TYPE_ERR;
 198   }
 199
 200   result.mAdditionalInformation.Construct().SetAsObject() =
 201     &jsAdditionalInformation.toObject();
 202
 203   return NotifyDialMMISuccess(cx, result);
 204 }
 205
 206 NS_IMETHODIMP
 207 TelephonyDialCallback::NotifyDialMMIError(const nsAString& aError)
 208 {
 209   AutoJSAPI jsapi;
 210   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
 211     return NS_ERROR_FAILURE;
 212   }
 213
 214   JSContext* cx = jsapi.cx();
 215
 216   MozMMIResult result;
 217   result.mSuccess = false;
 218   result.mServiceCode.Assign(mServiceCode);
 219   result.mStatusMessage.Assign(aError);
 220
 221   return NotifyDialMMISuccess(cx, result);
 222 }
 223
 224 NS_IMETHODIMP
 225 TelephonyDialCallback::NotifyDialMMIErrorWithInfo(const nsAString& aError,
 226                                                   uint16_t aInfo)
 227 {
 228   AutoJSAPI jsapi;
 229   if (NS_WARN_IF(!jsapi.Init(mWindow))) {
 230     return NS_ERROR_FAILURE;
 231   }
 232
 233   JSContext* cx = jsapi.cx();
 234
 235   MozMMIResult result;
 236   result.mSuccess = false;
 237   result.mServiceCode.Assign(mServiceCode);
 238   result.mStatusMessage.Assign(aError);
 239   result.mAdditionalInformation.Construct().SetAsUnsignedShort() = aInfo;
 240
 241   return NotifyDialMMISuccess(cx, result);
 242 }