dom/telephony/Telephony.cpp

   1 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
   2 /* vim: set ts=2 et sw=2 tw=40: */
   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 "Telephony.h"
   8
   9 #include "nsIURI.h"
  10 #include "nsIURL.h"
  11 #include "nsPIDOMWindow.h"
  12
  13 #include "jsapi.h"
  14 #include "nsIPermissionManager.h"
  15 #include "nsCharSeparatedTokenizer.h"
  16 #include "nsContentUtils.h"
  17 #include "nsDOMClassInfo.h"
  18 #include "nsIInterfaceRequestorUtils.h"
  19 #include "nsNetUtil.h"
  20 #include "nsServiceManagerUtils.h"
  21 #include "SystemWorkerManager.h"
  22 #include "nsRadioInterfaceLayer.h"
  23 #include "nsTArrayHelpers.h"
  24
  25 #include "CallEvent.h"
  26 #include "TelephonyCall.h"
  27
  28 USING_TELEPHONY_NAMESPACE
  29 using namespace mozilla::dom::gonk;
  30
  31 namespace {
  32
  33 typedef nsAutoTArray<Telephony*, 2> TelephonyList;
  34
  35 TelephonyList* gTelephonyList;
  36
  37 } // anonymous namespace
  38
  39 Telephony::Telephony()
  40 : mActiveCall(nullptr), mCallsArray(nullptr), mRooted(false)
  41 {
  42   if (!gTelephonyList) {
  43     gTelephonyList = new TelephonyList();
  44   }
  45
  46   gTelephonyList->AppendElement(this);
  47 }
  48
  49 Telephony::~Telephony()
  50 {
  51   if (mRIL && mRILTelephonyCallback) {
  52     mRIL->UnregisterTelephonyCallback(mRILTelephonyCallback);
  53   }
  54
  55   if (mRooted) {
  56     mCallsArray = nullptr;
  57     NS_DROP_JS_OBJECTS(this, Telephony);
  58   }
  59
  60   NS_ASSERTION(gTelephonyList, "This should never be null!");
  61   NS_ASSERTION(gTelephonyList->Contains(this), "Should be in the list!");
  62
  63   if (gTelephonyList->Length() == 1) {
  64     delete gTelephonyList;
  65     gTelephonyList = nullptr;
  66   }
  67   else {
  68     gTelephonyList->RemoveElement(this);
  69   }
  70 }
  71
  72 // static
  73 already_AddRefed<Telephony>
  74 Telephony::Create(nsPIDOMWindow* aOwner, nsIRILContentHelper* aRIL)
  75 {
  76   NS_ASSERTION(aOwner, "Null owner!");
  77   NS_ASSERTION(aRIL, "Null RIL!");
  78
  79   nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aOwner);
  80   NS_ENSURE_TRUE(sgo, nullptr);
  81
  82   nsCOMPtr<nsIScriptContext> scriptContext = sgo->GetContext();
  83   NS_ENSURE_TRUE(scriptContext, nullptr);
  84
  85   nsRefPtr<Telephony> telephony = new Telephony();
  86
  87   telephony->BindToOwner(aOwner);
  88
  89   telephony->mRIL = aRIL;
  90   telephony->mRILTelephonyCallback = new RILTelephonyCallback(telephony);
  91
  92   nsresult rv = aRIL->EnumerateCalls(telephony->mRILTelephonyCallback);
  93   NS_ENSURE_SUCCESS(rv, nullptr);
  94
  95   rv = aRIL->RegisterTelephonyCallback(telephony->mRILTelephonyCallback);
  96   NS_ENSURE_SUCCESS(rv, nullptr);
  97
  98   rv = aRIL->RegisterTelephonyMsg();
  99   NS_ENSURE_SUCCESS(rv, nullptr);
 100
 101   return telephony.forget();
 102 }
 103
 104 already_AddRefed<TelephonyCall>
 105 Telephony::CreateNewDialingCall(const nsAString& aNumber)
 106 {
 107   nsRefPtr<TelephonyCall> call =
 108     TelephonyCall::Create(this, aNumber,
 109                           nsIRadioInterfaceLayer::CALL_STATE_DIALING);
 110   NS_ASSERTION(call, "This should never fail!");
 111
 112   NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
 113
 114   return call.forget();
 115 }
 116
 117 void
 118 Telephony::NoteDialedCallFromOtherInstance(const nsAString& aNumber)
 119 {
 120   // We don't need to hang on to this call object, it is held alive by mCalls.
 121   nsRefPtr<TelephonyCall> call = CreateNewDialingCall(aNumber);
 122 }
 123
 124 nsresult
 125 Telephony::NotifyCallsChanged(TelephonyCall* aCall)
 126 {
 127   nsRefPtr<CallEvent> event = CallEvent::Create(aCall);
 128   NS_ASSERTION(event, "This should never fail!");
 129
 130   if (aCall->CallState() == nsIRadioInterfaceLayer::CALL_STATE_DIALING ||
 131       aCall->CallState() == nsIRadioInterfaceLayer::CALL_STATE_ALERTING ||
 132       aCall->CallState() == nsIRadioInterfaceLayer::CALL_STATE_CONNECTED) {
 133     NS_ASSERTION(!mActiveCall, "Already have an active call!");
 134     mActiveCall = aCall;
 135   } else if (mActiveCall && mActiveCall->CallIndex() == aCall->CallIndex()) {
 136     mActiveCall = nullptr;
 137   }
 138
 139   nsresult rv =
 140     event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("callschanged"));
 141   NS_ENSURE_SUCCESS(rv, rv);
 142
 143   return NS_OK;
 144 }
 145
 146 nsresult
 147 Telephony::DialInternal(bool isEmergency,
 148                         const nsAString& aNumber,
 149                         nsIDOMTelephonyCall** aResult)
 150 {
 151   NS_ENSURE_ARG(!aNumber.IsEmpty());
 152
 153   for (uint32_t index = 0; index < mCalls.Length(); index++) {
 154     const nsRefPtr<TelephonyCall>& tempCall = mCalls[index];
 155     if (tempCall->IsOutgoing() &&
 156         tempCall->CallState() < nsIRadioInterfaceLayer::CALL_STATE_CONNECTED) {
 157       // One call has been dialed already and we only support one outgoing call
 158       // at a time.
 159       NS_WARNING("Only permitted to dial one call at a time!");
 160       return NS_ERROR_NOT_AVAILABLE;
 161     }
 162   }
 163
 164   nsresult rv;
 165   if (isEmergency) {
 166     rv = mRIL->DialEmergency(aNumber);
 167   } else {
 168     rv = mRIL->Dial(aNumber);
 169   }
 170   NS_ENSURE_SUCCESS(rv, rv);
 171
 172   nsRefPtr<TelephonyCall> call = CreateNewDialingCall(aNumber);
 173
 174   // Notify other telephony objects that we just dialed.
 175   for (uint32_t index = 0; index < gTelephonyList->Length(); index++) {
 176     Telephony*& telephony = gTelephonyList->ElementAt(index);
 177     if (telephony != this) {
 178       nsRefPtr<Telephony> kungFuDeathGrip = telephony;
 179       telephony->NoteDialedCallFromOtherInstance(aNumber);
 180     }
 181   }
 182
 183   call.forget(aResult);
 184   return NS_OK;
 185 }
 186
 187 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(Telephony,
 188                                                   nsDOMEventTargetHelper)
 189   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 190   for (uint32_t index = 0; index < tmp->mCalls.Length(); index++) {
 191     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mCalls[i]");
 192     cb.NoteXPCOMChild(tmp->mCalls[index]->ToISupports());
 193   }
 194 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 195
 196 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(Telephony,
 197                                                nsDOMEventTargetHelper)
 198   NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mCallsArray)
 199 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 200
 201 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(Telephony,
 202                                                 nsDOMEventTargetHelper)
 203   tmp->mCalls.Clear();
 204   tmp->mActiveCall = nullptr;
 205   tmp->mCallsArray = nullptr;
 206 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 207
 208 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(Telephony)
 209   NS_INTERFACE_MAP_ENTRY(nsIDOMTelephony)
 210   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Telephony)
 211 NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
 212
 213 NS_IMPL_ADDREF_INHERITED(Telephony, nsDOMEventTargetHelper)
 214 NS_IMPL_RELEASE_INHERITED(Telephony, nsDOMEventTargetHelper)
 215
 216 DOMCI_DATA(Telephony, Telephony)
 217
 218 NS_IMPL_ISUPPORTS1(Telephony::RILTelephonyCallback, nsIRILTelephonyCallback)
 219
 220 NS_IMETHODIMP
 221 Telephony::Dial(const nsAString& aNumber, nsIDOMTelephonyCall** aResult)
 222 {
 223   DialInternal(false, aNumber, aResult);
 224
 225   return NS_OK;
 226 }
 227
 228 NS_IMETHODIMP
 229 Telephony::DialEmergency(const nsAString& aNumber, nsIDOMTelephonyCall** aResult)
 230 {
 231   DialInternal(true, aNumber, aResult);
 232
 233   return NS_OK;
 234 }
 235
 236 NS_IMETHODIMP
 237 Telephony::GetMuted(bool* aMuted)
 238 {
 239   nsresult rv = mRIL->GetMicrophoneMuted(aMuted);
 240   NS_ENSURE_SUCCESS(rv, rv);
 241
 242   return NS_OK;
 243 }
 244
 245 NS_IMETHODIMP
 246 Telephony::SetMuted(bool aMuted)
 247 {
 248   nsresult rv = mRIL->SetMicrophoneMuted(aMuted);
 249   NS_ENSURE_SUCCESS(rv, rv);
 250
 251   return NS_OK;
 252 }
 253
 254 NS_IMETHODIMP
 255 Telephony::GetSpeakerEnabled(bool* aSpeakerEnabled)
 256 {
 257   nsresult rv = mRIL->GetSpeakerEnabled(aSpeakerEnabled);
 258   NS_ENSURE_SUCCESS(rv, rv);
 259
 260   return NS_OK;
 261 }
 262
 263 NS_IMETHODIMP
 264 Telephony::SetSpeakerEnabled(bool aSpeakerEnabled)
 265 {
 266   nsresult rv = mRIL->SetSpeakerEnabled(aSpeakerEnabled);
 267   NS_ENSURE_SUCCESS(rv, rv);
 268
 269   return NS_OK;
 270 }
 271
 272 NS_IMETHODIMP
 273 Telephony::GetActive(jsval* aActive)
 274 {
 275   if (!mActiveCall) {
 276     aActive->setNull();
 277     return NS_OK;
 278   }
 279
 280   nsresult rv;
 281   nsIScriptContext* sc = GetContextForEventHandlers(&rv);
 282   NS_ENSURE_SUCCESS(rv, rv);
 283   if (sc) {
 284     rv =
 285       nsContentUtils::WrapNative(sc->GetNativeContext(),
 286                                  sc->GetNativeGlobal(),
 287                                  mActiveCall->ToISupports(), aActive);
 288     NS_ENSURE_SUCCESS(rv, rv);
 289   }
 290   return NS_OK;
 291 }
 292
 293 NS_IMETHODIMP
 294 Telephony::GetCalls(jsval* aCalls)
 295 {
 296   JSObject* calls = mCallsArray;
 297   if (!calls) {
 298     nsresult rv;
 299     nsIScriptContext* sc = GetContextForEventHandlers(&rv);
 300     NS_ENSURE_SUCCESS(rv, rv);
 301     if (sc) {
 302       rv = nsTArrayToJSArray(sc->GetNativeContext(), mCalls, &calls);
 303       NS_ENSURE_SUCCESS(rv, rv);
 304
 305       if (!mRooted) {
 306         NS_HOLD_JS_OBJECTS(this, Telephony);
 307         mRooted = true;
 308       }
 309
 310       mCallsArray = calls;
 311     } else {
 312       NS_ENSURE_SUCCESS(rv, rv);
 313     }
 314   }
 315
 316   aCalls->setObject(*calls);
 317   return NS_OK;
 318 }
 319
 320 NS_IMETHODIMP
 321 Telephony::StartTone(const nsAString& aDTMFChar)
 322 {
 323   if (aDTMFChar.IsEmpty()) {
 324     NS_WARNING("Empty tone string will be ignored");
 325     return NS_OK;
 326   }
 327
 328   if (aDTMFChar.Length() > 1) {
 329     return NS_ERROR_INVALID_ARG;
 330   }
 331
 332   nsresult rv = mRIL->StartTone(aDTMFChar);
 333   NS_ENSURE_SUCCESS(rv, rv);
 334
 335   return NS_OK;
 336 }
 337
 338 NS_IMETHODIMP
 339 Telephony::StopTone()
 340 {
 341   nsresult rv = mRIL->StopTone();
 342   NS_ENSURE_SUCCESS(rv, rv);
 343
 344   return NS_OK;
 345 }
 346
 347 NS_IMPL_EVENT_HANDLER(Telephony, incoming)
 348 NS_IMPL_EVENT_HANDLER(Telephony, callschanged)
 349
 350 NS_IMETHODIMP
 351 Telephony::CallStateChanged(uint32_t aCallIndex, uint16_t aCallState,
 352                             const nsAString& aNumber, bool aIsActive)
 353 {
 354   NS_ASSERTION(aCallIndex != kOutgoingPlaceholderCallIndex,
 355                "This should never happen!");
 356
 357   nsRefPtr<TelephonyCall> modifiedCall;
 358   nsRefPtr<TelephonyCall> outgoingCall;
 359
 360   for (uint32_t index = 0; index < mCalls.Length(); index++) {
 361     nsRefPtr<TelephonyCall>& tempCall = mCalls[index];
 362     if (tempCall->CallIndex() == kOutgoingPlaceholderCallIndex) {
 363       NS_ASSERTION(!outgoingCall, "More than one outgoing call not supported!");
 364       NS_ASSERTION(tempCall->CallState() ==
 365                    nsIRadioInterfaceLayer::CALL_STATE_DIALING,
 366                    "Something really wrong here!");
 367       // Stash this for later, we may need it if aCallIndex doesn't match one of
 368       // our other calls.
 369       outgoingCall = tempCall;
 370     } else if (tempCall->CallIndex() == aCallIndex) {
 371       // We already know about this call so just update its state.
 372       modifiedCall = tempCall;
 373       outgoingCall = nullptr;
 374       break;
 375     }
 376   }
 377
 378   // If nothing matched above and the call state isn't incoming but we do have
 379   // an outgoing call then we must be seeing a status update for our outgoing
 380   // call.
 381   if (!modifiedCall &&
 382       aCallState != nsIRadioInterfaceLayer::CALL_STATE_INCOMING &&
 383       outgoingCall) {
 384     outgoingCall->UpdateCallIndex(aCallIndex);
 385     modifiedCall.swap(outgoingCall);
 386   }
 387
 388   if (modifiedCall) {
 389     // See if this should replace our current active call.
 390     if (aIsActive) {
 391         mActiveCall = modifiedCall;
 392     } else if (mActiveCall && mActiveCall->CallIndex() == aCallIndex) {
 393       mActiveCall = nullptr;
 394     }
 395
 396     // Change state.
 397     modifiedCall->ChangeState(aCallState);
 398
 399     return NS_OK;
 400   }
 401
 402   // Didn't know anything about this call before now.
 403
 404   if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_DISCONNECTED) {
 405     // Do nothing since we didn't know anything about it before now and it's
 406     // been ended already.
 407     return NS_OK;
 408   }
 409
 410   nsRefPtr<TelephonyCall> call =
 411     TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
 412   NS_ASSERTION(call, "This should never fail!");
 413
 414   NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
 415
 416   if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_INCOMING) {
 417     // Dispatch incoming event.
 418     nsRefPtr<CallEvent> event = CallEvent::Create(call);
 419     NS_ASSERTION(event, "This should never fail!");
 420
 421     nsresult rv =
 422       event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("incoming"));
 423     NS_ENSURE_SUCCESS(rv, rv);
 424   }
 425
 426   return NS_OK;
 427 }
 428
 429 NS_IMETHODIMP
 430 Telephony::EnumerateCallState(uint32_t aCallIndex, uint16_t aCallState,
 431                               const nsAString& aNumber, bool aIsActive,
 432                               bool* aContinue)
 433 {
 434   // Make sure we don't somehow add duplicates.
 435   for (uint32_t index = 0; index < mCalls.Length(); index++) {
 436     nsRefPtr<TelephonyCall>& tempCall = mCalls[index];
 437     if (tempCall->CallIndex() == aCallIndex) {
 438       // We have the call already. Skip it.
 439       *aContinue = true;
 440       return NS_OK;
 441     }
 442   }
 443
 444   nsRefPtr<TelephonyCall> call =
 445     TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
 446   NS_ASSERTION(call, "This should never fail!");
 447
 448   NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
 449
 450   *aContinue = true;
 451   return NS_OK;
 452 }
 453
 454 NS_IMETHODIMP
 455 Telephony::NotifyError(int32_t aCallIndex,
 456                        const nsAString& aError)
 457 {
 458   nsRefPtr<TelephonyCall> callToNotify;
 459   if (!mCalls.IsEmpty()) {
 460     // The connection is not established yet. Get the latest call object.
 461     if (aCallIndex == -1) {
 462       callToNotify = mCalls[mCalls.Length() - 1];
 463     } else {
 464       // The connection has been established. Get the failed call.
 465       for (uint32_t index = 0; index < mCalls.Length(); index++) {
 466         nsRefPtr<TelephonyCall>& call = mCalls[index];
 467         if (call->CallIndex() == aCallIndex) {
 468           callToNotify = call;
 469           break;
 470         }
 471       }
 472     }
 473   }
 474
 475   if (!callToNotify) {
 476     NS_ERROR("Don't call me with a bad call index!");
 477     return NS_ERROR_UNEXPECTED;
 478   }
 479
 480   if (mActiveCall && mActiveCall->CallIndex() == callToNotify->CallIndex()) {
 481     mActiveCall = nullptr;
 482   }
 483
 484   // Set the call state to 'disconnected' and remove it from the calls list.
 485   callToNotify->NotifyError(aError);
 486
 487   return NS_OK;
 488 }
 489
 490 nsresult
 491 NS_NewTelephony(nsPIDOMWindow* aWindow, nsIDOMTelephony** aTelephony)
 492 {
 493   NS_ASSERTION(aWindow, "Null pointer!");
 494
 495   nsPIDOMWindow* innerWindow = aWindow->IsInnerWindow() ?
 496     aWindow :
 497     aWindow->GetCurrentInnerWindow();
 498
 499   nsCOMPtr<nsIPermissionManager> permMgr =
 500     do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
 501   NS_ENSURE_TRUE(permMgr, NS_ERROR_UNEXPECTED);
 502
 503   uint32_t permission;
 504   nsresult rv =
 505     permMgr->TestPermissionFromWindow(aWindow, "telephony", &permission);
 506   NS_ENSURE_SUCCESS(rv, rv);
 507
 508   if (permission != nsIPermissionManager::ALLOW_ACTION) {
 509     *aTelephony = nullptr;
 510     return NS_OK;
 511   }
 512
 513   nsCOMPtr<nsIRILContentHelper> ril =
 514     do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
 515   NS_ENSURE_TRUE(ril, NS_ERROR_UNEXPECTED);
 516
 517   nsRefPtr<Telephony> telephony = Telephony::Create(innerWindow, ril);
 518   NS_ENSURE_TRUE(telephony, NS_ERROR_UNEXPECTED);
 519
 520   telephony.forget(aTelephony);
 521   return NS_OK;
 522 }