dom/telephony/ipc/TelephonyParent.cpp

   1 /* -*- Mode: C++ tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/telephony/TelephonyParent.h"
   7 #include "nsServiceManagerUtils.h"
   8
   9 USING_TELEPHONY_NAMESPACE
  10
  11 /*******************************************************************************
  12  * TelephonyParent
  13  ******************************************************************************/
  14
  15 NS_IMPL_ISUPPORTS(TelephonyParent, nsITelephonyListener)
  16
  17 TelephonyParent::TelephonyParent()
  18   : mActorDestroyed(false)
  19   , mRegistered(false)
  20 {
  21 }
  22
  23 void
  24 TelephonyParent::ActorDestroy(ActorDestroyReason why)
  25 {
  26   // The child process could die before this asynchronous notification, in which
  27   // case ActorDestroy() was called and mActorDestroyed is set to true. Return
  28   // an error here to avoid sending a message to the dead process.
  29   mActorDestroyed = true;
  30
  31   // Try to unregister listener if we're still registered.
  32   RecvUnregisterListener();
  33 }
  34
  35 bool
  36 TelephonyParent::RecvPTelephonyRequestConstructor(PTelephonyRequestParent* aActor,
  37                                                   const IPCTelephonyRequest& aRequest)
  38 {
  39   TelephonyRequestParent* actor = static_cast<TelephonyRequestParent*>(aActor);
  40
  41   switch (aRequest.type()) {
  42     case IPCTelephonyRequest::TEnumerateCallsRequest:
  43       return actor->DoRequest(aRequest.get_EnumerateCallsRequest());
  44     case IPCTelephonyRequest::TDialRequest:
  45       return actor->DoRequest(aRequest.get_DialRequest());
  46     case IPCTelephonyRequest::THangUpConferenceRequest:
  47       return actor->DoRequest(aRequest.get_HangUpConferenceRequest());
  48     default:
  49       MOZ_CRASH("Unknown type!");
  50   }
  51
  52   return false;
  53 }
  54
  55 PTelephonyRequestParent*
  56 TelephonyParent::AllocPTelephonyRequestParent(const IPCTelephonyRequest& aRequest)
  57 {
  58   TelephonyRequestParent* actor = new TelephonyRequestParent();
  59   // Add an extra ref for IPDL. Will be released in
  60   // TelephonyParent::DeallocPTelephonyRequestParent().
  61   NS_ADDREF(actor);
  62
  63   return actor;
  64 }
  65
  66 bool
  67 TelephonyParent::DeallocPTelephonyRequestParent(PTelephonyRequestParent* aActor)
  68 {
  69   // TelephonyRequestParent is refcounted, must not be freed manually.
  70   static_cast<TelephonyRequestParent*>(aActor)->Release();
  71   return true;
  72 }
  73
  74 bool
  75 TelephonyParent::Recv__delete__()
  76 {
  77   return true; // Unregister listener in TelephonyParent::ActorDestroy().
  78 }
  79
  80 bool
  81 TelephonyParent::RecvRegisterListener()
  82 {
  83   NS_ENSURE_TRUE(!mRegistered, true);
  84
  85   nsCOMPtr<nsITelephonyService> service =
  86     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
  87   NS_ENSURE_TRUE(service, true);
  88
  89   mRegistered = NS_SUCCEEDED(service->RegisterListener(this));
  90   return true;
  91 }
  92
  93 bool
  94 TelephonyParent::RecvUnregisterListener()
  95 {
  96   NS_ENSURE_TRUE(mRegistered, true);
  97
  98   nsCOMPtr<nsITelephonyService> service =
  99     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 100   NS_ENSURE_TRUE(service, true);
 101
 102   mRegistered = !NS_SUCCEEDED(service->UnregisterListener(this));
 103   return true;
 104 }
 105
 106 bool
 107 TelephonyParent::RecvHangUpCall(const uint32_t& aClientId,
 108                                 const uint32_t& aCallIndex)
 109 {
 110   nsCOMPtr<nsITelephonyService> service =
 111     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 112   NS_ENSURE_TRUE(service, true);
 113
 114   service->HangUp(aClientId, aCallIndex);
 115   return true;
 116 }
 117
 118 bool
 119 TelephonyParent::RecvAnswerCall(const uint32_t& aClientId,
 120                                 const uint32_t& aCallIndex)
 121 {
 122   nsCOMPtr<nsITelephonyService> service =
 123     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 124   NS_ENSURE_TRUE(service, true);
 125
 126   service->AnswerCall(aClientId, aCallIndex);
 127   return true;
 128 }
 129
 130 bool
 131 TelephonyParent::RecvRejectCall(const uint32_t& aClientId,
 132                                 const uint32_t& aCallIndex)
 133 {
 134   nsCOMPtr<nsITelephonyService> service =
 135     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 136   NS_ENSURE_TRUE(service, true);
 137
 138   service->RejectCall(aClientId, aCallIndex);
 139   return true;
 140 }
 141
 142 bool
 143 TelephonyParent::RecvHoldCall(const uint32_t& aClientId,
 144                               const uint32_t& aCallIndex)
 145 {
 146   nsCOMPtr<nsITelephonyService> service =
 147     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 148   NS_ENSURE_TRUE(service, true);
 149
 150   service->HoldCall(aClientId, aCallIndex);
 151   return true;
 152 }
 153
 154 bool
 155 TelephonyParent::RecvResumeCall(const uint32_t& aClientId,
 156                                 const uint32_t& aCallIndex)
 157 {
 158   nsCOMPtr<nsITelephonyService> service =
 159     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 160   NS_ENSURE_TRUE(service, true);
 161
 162   service->ResumeCall(aClientId, aCallIndex);
 163   return true;
 164 }
 165
 166 bool
 167 TelephonyParent::RecvConferenceCall(const uint32_t& aClientId)
 168 {
 169   nsCOMPtr<nsITelephonyService> service =
 170     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 171   NS_ENSURE_TRUE(service, true);
 172
 173   service->ConferenceCall(aClientId);
 174   return true;
 175 }
 176
 177 bool
 178 TelephonyParent::RecvSeparateCall(const uint32_t& aClientId,
 179                                   const uint32_t& aCallIndex)
 180 {
 181   nsCOMPtr<nsITelephonyService> service =
 182     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 183   NS_ENSURE_TRUE(service, true);
 184
 185   service->SeparateCall(aClientId, aCallIndex);
 186   return true;
 187 }
 188
 189 bool
 190 TelephonyParent::RecvHoldConference(const uint32_t& aClientId)
 191 {
 192   nsCOMPtr<nsITelephonyService> service =
 193     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 194   NS_ENSURE_TRUE(service, true);
 195
 196   service->HoldConference(aClientId);
 197   return true;
 198 }
 199
 200 bool
 201 TelephonyParent::RecvResumeConference(const uint32_t& aClientId)
 202 {
 203   nsCOMPtr<nsITelephonyService> service =
 204     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 205   NS_ENSURE_TRUE(service, true);
 206
 207   service->ResumeConference(aClientId);
 208   return true;
 209 }
 210
 211 bool
 212 TelephonyParent::RecvStartTone(const uint32_t& aClientId, const nsString& aTone)
 213 {
 214   nsCOMPtr<nsITelephonyService> service =
 215     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 216   NS_ENSURE_TRUE(service, true);
 217
 218   service->StartTone(aClientId, aTone);
 219   return true;
 220 }
 221
 222 bool
 223 TelephonyParent::RecvStopTone(const uint32_t& aClientId)
 224 {
 225   nsCOMPtr<nsITelephonyService> service =
 226     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 227   NS_ENSURE_TRUE(service, true);
 228
 229   service->StopTone(aClientId);
 230   return true;
 231 }
 232
 233 bool
 234 TelephonyParent::RecvGetMicrophoneMuted(bool* aMuted)
 235 {
 236   *aMuted = false;
 237
 238   nsCOMPtr<nsITelephonyService> service =
 239     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 240   NS_ENSURE_TRUE(service, true);
 241
 242   service->GetMicrophoneMuted(aMuted);
 243   return true;
 244 }
 245
 246 bool
 247 TelephonyParent::RecvSetMicrophoneMuted(const bool& aMuted)
 248 {
 249   nsCOMPtr<nsITelephonyService> service =
 250     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 251   NS_ENSURE_TRUE(service, true);
 252
 253   service->SetMicrophoneMuted(aMuted);
 254   return true;
 255 }
 256
 257 bool
 258 TelephonyParent::RecvGetSpeakerEnabled(bool* aEnabled)
 259 {
 260   *aEnabled = false;
 261
 262   nsCOMPtr<nsITelephonyService> service =
 263     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 264   NS_ENSURE_TRUE(service, true);
 265
 266   service->GetSpeakerEnabled(aEnabled);
 267   return true;
 268 }
 269
 270 bool
 271 TelephonyParent::RecvSetSpeakerEnabled(const bool& aEnabled)
 272 {
 273   nsCOMPtr<nsITelephonyService> service =
 274     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 275   NS_ENSURE_TRUE(service, true);
 276
 277   service->SetSpeakerEnabled(aEnabled);
 278   return true;
 279 }
 280
 281 // nsITelephonyListener
 282
 283 NS_IMETHODIMP
 284 TelephonyParent::CallStateChanged(uint32_t aClientId,
 285                                   uint32_t aCallIndex,
 286                                   uint16_t aCallState,
 287                                   const nsAString& aNumber,
 288                                   uint16_t aNumberPresentation,
 289                                   const nsAString& aName,
 290                                   uint16_t aNamePresentation,
 291                                   bool aIsOutgoing,
 292                                   bool aIsEmergency,
 293                                   bool aIsConference,
 294                                   bool aIsSwitchable,
 295                                   bool aIsMergeable)
 296 {
 297   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 298
 299   IPCCallStateData data(aCallIndex, aCallState, nsString(aNumber),
 300                         aNumberPresentation, nsString(aName), aNamePresentation,
 301                         aIsOutgoing, aIsEmergency, aIsConference,
 302                         aIsSwitchable, aIsMergeable);
 303   return SendNotifyCallStateChanged(aClientId, data) ? NS_OK : NS_ERROR_FAILURE;
 304 }
 305
 306 NS_IMETHODIMP
 307 TelephonyParent::ConferenceCallStateChanged(uint16_t aCallState)
 308 {
 309   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 310
 311   return SendNotifyConferenceCallStateChanged(aCallState) ? NS_OK
 312                                                           : NS_ERROR_FAILURE;
 313 }
 314
 315 NS_IMETHODIMP
 316 TelephonyParent::EnumerateCallStateComplete()
 317 {
 318   MOZ_CRASH("Not a EnumerateCalls request!");
 319 }
 320
 321 NS_IMETHODIMP
 322 TelephonyParent::EnumerateCallState(uint32_t aClientId,
 323                                     uint32_t aCallIndex,
 324                                     uint16_t aCallState,
 325                                     const nsAString& aNumber,
 326                                     uint16_t aNumberPresentation,
 327                                     const nsAString& aName,
 328                                     uint16_t aNamePresentation,
 329                                     bool aIsOutgoing,
 330                                     bool aIsEmergency,
 331                                     bool aIsConference,
 332                                     bool aIsSwitchable,
 333                                     bool aIsMergeable)
 334 {
 335   MOZ_CRASH("Not a EnumerateCalls request!");
 336 }
 337
 338 NS_IMETHODIMP
 339 TelephonyParent::NotifyCdmaCallWaiting(uint32_t aClientId,
 340                                        const nsAString& aNumber,
 341                                        uint16_t aNumberPresentation,
 342                                        const nsAString& aName,
 343                                        uint16_t aNamePresentation)
 344 {
 345   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 346
 347   IPCCdmaWaitingCallData data(nsString(aNumber), aNumberPresentation,
 348                               nsString(aName), aNamePresentation);
 349   return SendNotifyCdmaCallWaiting(aClientId, data) ? NS_OK : NS_ERROR_FAILURE;
 350 }
 351
 352 NS_IMETHODIMP
 353 TelephonyParent::NotifyConferenceError(const nsAString& aName,
 354                                        const nsAString& aMessage)
 355 {
 356   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 357
 358   return SendNotifyConferenceError(nsString(aName), nsString(aMessage)) ? NS_OK
 359                                                                         : NS_ERROR_FAILURE;
 360 }
 361
 362 NS_IMETHODIMP
 363 TelephonyParent::NotifyError(uint32_t aClientId,
 364                              int32_t aCallIndex,
 365                              const nsAString& aError)
 366 {
 367   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 368
 369   return SendNotifyCallError(aClientId, aCallIndex, nsString(aError))
 370       ? NS_OK : NS_ERROR_FAILURE;
 371 }
 372
 373 NS_IMETHODIMP
 374 TelephonyParent::SupplementaryServiceNotification(uint32_t aClientId,
 375                                                   int32_t aCallIndex,
 376                                                   uint16_t aNotification)
 377 {
 378   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 379
 380   return SendNotifySupplementaryService(aClientId, aCallIndex, aNotification)
 381       ? NS_OK : NS_ERROR_FAILURE;
 382 }
 383
 384 /*******************************************************************************
 385  * TelephonyRequestParent
 386  ******************************************************************************/
 387
 388 NS_IMPL_ISUPPORTS(TelephonyRequestParent,
 389                   nsITelephonyListener,
 390                   nsITelephonyCallback,
 391                   nsITelephonyDialCallback)
 392
 393 TelephonyRequestParent::TelephonyRequestParent()
 394   : mActorDestroyed(false)
 395 {
 396 }
 397
 398 void
 399 TelephonyRequestParent::ActorDestroy(ActorDestroyReason why)
 400 {
 401   // The child process could die before this asynchronous notification, in which
 402   // case ActorDestroy() was called and mActorDestroyed is set to true. Return
 403   // an error here to avoid sending a message to the dead process.
 404   mActorDestroyed = true;
 405 }
 406
 407 bool
 408 TelephonyRequestParent::DoRequest(const EnumerateCallsRequest& aRequest)
 409 {
 410   nsresult rv = NS_ERROR_FAILURE;
 411
 412   nsCOMPtr<nsITelephonyService> service =
 413     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 414   if (service) {
 415     rv = service->EnumerateCalls(this);
 416   }
 417
 418   if (NS_FAILED(rv)) {
 419     return NS_SUCCEEDED(EnumerateCallStateComplete());
 420   }
 421
 422   return true;
 423 }
 424
 425 bool
 426 TelephonyRequestParent::DoRequest(const DialRequest& aRequest)
 427 {
 428   nsCOMPtr<nsITelephonyService> service =
 429     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 430   if (service) {
 431     service->Dial(aRequest.clientId(), aRequest.number(),
 432                   aRequest.isEmergency(), this);
 433   } else {
 434     return NS_SUCCEEDED(NotifyError(NS_LITERAL_STRING("InvalidStateError")));
 435   }
 436
 437   return true;
 438 }
 439
 440 bool
 441 TelephonyRequestParent::DoRequest(const HangUpConferenceRequest& aRequest)
 442 {
 443   nsCOMPtr<nsITelephonyService> service =
 444     do_GetService(TELEPHONY_SERVICE_CONTRACTID);
 445   if (service) {
 446     service->HangUpConference(aRequest.clientId(), this);
 447   } else {
 448     return NS_SUCCEEDED(NotifyError(NS_LITERAL_STRING("InvalidStateError")));
 449   }
 450
 451   return true;
 452 }
 453
 454 nsresult
 455 TelephonyRequestParent::SendResponse(const IPCTelephonyResponse& aResponse)
 456 {
 457   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 458
 459   return Send__delete__(this, aResponse) ? NS_OK : NS_ERROR_FAILURE;
 460 }
 461
 462 // nsITelephonyListener
 463
 464 NS_IMETHODIMP
 465 TelephonyRequestParent::CallStateChanged(uint32_t aClientId,
 466                                          uint32_t aCallIndex,
 467                                          uint16_t aCallState,
 468                                          const nsAString& aNumber,
 469                                          uint16_t aNumberPresentation,
 470                                          const nsAString& aName,
 471                                          uint16_t aNamePresentation,
 472                                          bool aIsOutgoing,
 473                                          bool aIsEmergency,
 474                                          bool aIsConference,
 475                                          bool aIsSwitchable,
 476                                          bool aIsMergeable)
 477 {
 478   MOZ_CRASH("Not a TelephonyParent!");
 479 }
 480
 481 NS_IMETHODIMP
 482 TelephonyRequestParent::ConferenceCallStateChanged(uint16_t aCallState)
 483 {
 484   MOZ_CRASH("Not a TelephonyParent!");
 485 }
 486
 487 NS_IMETHODIMP
 488 TelephonyRequestParent::EnumerateCallStateComplete()
 489 {
 490   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 491
 492   return Send__delete__(this, EnumerateCallsResponse()) ? NS_OK : NS_ERROR_FAILURE;
 493 }
 494
 495 NS_IMETHODIMP
 496 TelephonyRequestParent::EnumerateCallState(uint32_t aClientId,
 497                                            uint32_t aCallIndex,
 498                                            uint16_t aCallState,
 499                                            const nsAString& aNumber,
 500                                            uint16_t aNumberPresentation,
 501                                            const nsAString& aName,
 502                                            uint16_t aNamePresentation,
 503                                            bool aIsOutgoing,
 504                                            bool aIsEmergency,
 505                                            bool aIsConference,
 506                                            bool aIsSwitchable,
 507                                            bool aIsMergeable)
 508 {
 509   NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
 510
 511   IPCCallStateData data(aCallIndex, aCallState, nsString(aNumber),
 512                         aNumberPresentation, nsString(aName), aNamePresentation,
 513                         aIsOutgoing, aIsEmergency, aIsConference,
 514                         aIsSwitchable, aIsMergeable);
 515   return SendNotifyEnumerateCallState(aClientId, data) ? NS_OK
 516                                                        : NS_ERROR_FAILURE;
 517 }
 518
 519 NS_IMETHODIMP
 520 TelephonyRequestParent::NotifyCdmaCallWaiting(uint32_t aClientId,
 521                                               const nsAString& aNumber,
 522                                               uint16_t aNumberPresentation,
 523                                               const nsAString& aName,
 524                                               uint16_t aNamePresentation)
 525 {
 526   MOZ_CRASH("Not a TelephonyParent!");
 527 }
 528
 529 NS_IMETHODIMP
 530 TelephonyRequestParent::NotifyConferenceError(const nsAString& aName,
 531                                               const nsAString& aMessage)
 532 {
 533   MOZ_CRASH("Not a TelephonyParent!");
 534 }
 535
 536 NS_IMETHODIMP
 537 TelephonyRequestParent::NotifyError(uint32_t aClientId,
 538                                     int32_t aCallIndex,
 539                                     const nsAString& aError)
 540 {
 541   MOZ_CRASH("Not a TelephonyParent!");
 542 }
 543
 544 NS_IMETHODIMP
 545 TelephonyRequestParent::SupplementaryServiceNotification(uint32_t aClientId,
 546                                                          int32_t aCallIndex,
 547                                                          uint16_t aNotification)
 548 {
 549   MOZ_CRASH("Not a TelephonyParent!");
 550 }
 551
 552 // nsITelephonyDialCallback
 553
 554 NS_IMETHODIMP
 555 TelephonyRequestParent::NotifySuccess()
 556 {
 557   return SendResponse(SuccessResponse());
 558 }
 559
 560 NS_IMETHODIMP
 561 TelephonyRequestParent::NotifyError(const nsAString& aError)
 562 {
 563   return SendResponse(ErrorResponse(nsAutoString(aError)));
 564 }
 565
 566 NS_IMETHODIMP
 567 TelephonyRequestParent::NotifyDialCallSuccess(uint32_t aClientId,
 568                                               uint32_t aCallIndex,
 569                                               const nsAString& aNumber)
 570 {
 571   return SendResponse(DialResponseCallSuccess(aClientId, aCallIndex,
 572                                               nsAutoString(aNumber)));
 573 }