mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-06 00:55:37 +00:00
331 lines
8.8 KiB
C++
331 lines
8.8 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=40: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "TelephonyCall.h"
|
|
#include "mozilla/dom/CallEvent.h"
|
|
#include "mozilla/dom/TelephonyCallBinding.h"
|
|
|
|
#include "mozilla/dom/DOMError.h"
|
|
|
|
#include "Telephony.h"
|
|
#include "TelephonyCallGroup.h"
|
|
|
|
using namespace mozilla::dom;
|
|
using mozilla::ErrorResult;
|
|
|
|
// static
|
|
already_AddRefed<TelephonyCall>
|
|
TelephonyCall::Create(Telephony* aTelephony, uint32_t aServiceId,
|
|
const nsAString& aNumber, uint16_t aNumberPresentation,
|
|
const nsAString& aName, uint16_t aNamePresentation,
|
|
uint16_t aCallState, uint32_t aCallIndex, bool aEmergency,
|
|
bool aIsConference, bool aSwitchable, bool aMergeable)
|
|
{
|
|
NS_ASSERTION(aTelephony, "Null pointer!");
|
|
NS_ASSERTION(!aNumber.IsEmpty(), "Empty number!");
|
|
NS_ASSERTION(aCallIndex >= 1, "Invalid call index!");
|
|
|
|
nsRefPtr<TelephonyCall> call = new TelephonyCall(aTelephony->GetOwner());
|
|
nsRefPtr<TelephonyCallId> id = new TelephonyCallId(aTelephony->GetOwner(),
|
|
aNumber, aNumberPresentation,
|
|
aName, aNamePresentation);
|
|
|
|
call->mTelephony = aTelephony;
|
|
call->mServiceId = aServiceId;
|
|
call->mCallIndex = aCallIndex;
|
|
call->mError = nullptr;
|
|
call->mEmergency = aEmergency;
|
|
call->mGroup = aIsConference ? aTelephony->ConferenceGroup() : nullptr;
|
|
call->mSwitchable = aSwitchable;
|
|
call->mMergeable = aMergeable;
|
|
call->mId = id;
|
|
|
|
call->ChangeStateInternal(aCallState, false);
|
|
|
|
return call.forget();
|
|
}
|
|
|
|
TelephonyCall::TelephonyCall(nsPIDOMWindow* aOwner)
|
|
: DOMEventTargetHelper(aOwner),
|
|
mCallState(nsITelephonyService::CALL_STATE_UNKNOWN),
|
|
mLive(false)
|
|
{
|
|
}
|
|
|
|
TelephonyCall::~TelephonyCall()
|
|
{
|
|
}
|
|
|
|
JSObject*
|
|
TelephonyCall::WrapObject(JSContext* aCx)
|
|
{
|
|
return TelephonyCallBinding::Wrap(aCx, this);
|
|
}
|
|
|
|
void
|
|
TelephonyCall::ChangeStateInternal(uint16_t aCallState, bool aFireEvents)
|
|
{
|
|
nsRefPtr<TelephonyCall> kungFuDeathGrip(this);
|
|
|
|
nsString stateString;
|
|
switch (aCallState) {
|
|
case nsITelephonyService::CALL_STATE_DIALING:
|
|
stateString.AssignLiteral("dialing");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_ALERTING:
|
|
stateString.AssignLiteral("alerting");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_CONNECTING:
|
|
stateString.AssignLiteral("connecting");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_CONNECTED:
|
|
stateString.AssignLiteral("connected");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_HOLDING:
|
|
stateString.AssignLiteral("holding");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_HELD:
|
|
stateString.AssignLiteral("held");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_RESUMING:
|
|
stateString.AssignLiteral("resuming");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_DISCONNECTING:
|
|
stateString.AssignLiteral("disconnecting");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_DISCONNECTED:
|
|
stateString.AssignLiteral("disconnected");
|
|
break;
|
|
case nsITelephonyService::CALL_STATE_INCOMING:
|
|
stateString.AssignLiteral("incoming");
|
|
break;
|
|
default:
|
|
NS_NOTREACHED("Unknown state!");
|
|
}
|
|
|
|
mState = stateString;
|
|
mCallState = aCallState;
|
|
|
|
if (aCallState == nsITelephonyService::CALL_STATE_DISCONNECTED) {
|
|
NS_ASSERTION(mLive, "Should be live!");
|
|
mLive = false;
|
|
if (mGroup) {
|
|
mGroup->RemoveCall(this);
|
|
} else {
|
|
mTelephony->RemoveCall(this);
|
|
}
|
|
} else if (!mLive) {
|
|
mLive = true;
|
|
if (mGroup) {
|
|
mGroup->AddCall(this);
|
|
} else {
|
|
mTelephony->AddCall(this);
|
|
}
|
|
}
|
|
|
|
if (aFireEvents) {
|
|
nsresult rv = DispatchCallEvent(NS_LITERAL_STRING("statechange"), this);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to dispatch specific event!");
|
|
}
|
|
|
|
// This can change if the statechange handler called back here... Need to
|
|
// figure out something smarter.
|
|
if (mCallState == aCallState) {
|
|
rv = DispatchCallEvent(stateString, this);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to dispatch specific event!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
TelephonyCall::DispatchCallEvent(const nsAString& aType,
|
|
TelephonyCall* aCall)
|
|
{
|
|
MOZ_ASSERT(aCall);
|
|
|
|
CallEventInit init;
|
|
init.mBubbles = false;
|
|
init.mCancelable = false;
|
|
init.mCall = aCall;
|
|
|
|
nsRefPtr<CallEvent> event = CallEvent::Constructor(this, aType, init);
|
|
|
|
return DispatchTrustedEvent(event);
|
|
}
|
|
|
|
void
|
|
TelephonyCall::NotifyError(const nsAString& aError)
|
|
{
|
|
// Set the error string
|
|
NS_ASSERTION(!mError, "Already have an error?");
|
|
|
|
mError = new DOMError(GetOwner(), aError);
|
|
|
|
// Do the state transitions
|
|
ChangeStateInternal(nsITelephonyService::CALL_STATE_DISCONNECTED, true);
|
|
|
|
nsresult rv = DispatchCallEvent(NS_LITERAL_STRING("error"), this);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to dispatch error event!");
|
|
}
|
|
}
|
|
|
|
void
|
|
TelephonyCall::ChangeGroup(TelephonyCallGroup* aGroup)
|
|
{
|
|
mGroup = aGroup;
|
|
|
|
nsresult rv = DispatchCallEvent(NS_LITERAL_STRING("groupchange"), this);
|
|
if (NS_FAILED(rv)) {
|
|
NS_WARNING("Failed to dispatch error event!");
|
|
}
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(TelephonyCall,
|
|
DOMEventTargetHelper,
|
|
mTelephony,
|
|
mError,
|
|
mGroup,
|
|
mId,
|
|
mSecondId);
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(TelephonyCall)
|
|
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(TelephonyCall, DOMEventTargetHelper)
|
|
NS_IMPL_RELEASE_INHERITED(TelephonyCall, DOMEventTargetHelper)
|
|
|
|
// TelephonyCall WebIDL
|
|
|
|
already_AddRefed<TelephonyCallId>
|
|
TelephonyCall::Id() const
|
|
{
|
|
nsRefPtr<TelephonyCallId> id = mId;
|
|
return id.forget();
|
|
}
|
|
|
|
already_AddRefed<TelephonyCallId>
|
|
TelephonyCall::GetSecondId() const
|
|
{
|
|
nsRefPtr<TelephonyCallId> id = mSecondId;
|
|
return id.forget();
|
|
}
|
|
|
|
already_AddRefed<DOMError>
|
|
TelephonyCall::GetError() const
|
|
{
|
|
nsRefPtr<DOMError> error = mError;
|
|
return error.forget();
|
|
}
|
|
|
|
already_AddRefed<TelephonyCallGroup>
|
|
TelephonyCall::GetGroup() const
|
|
{
|
|
nsRefPtr<TelephonyCallGroup> group = mGroup;
|
|
return group.forget();
|
|
}
|
|
|
|
void
|
|
TelephonyCall::Answer(ErrorResult& aRv)
|
|
{
|
|
if (mCallState != nsITelephonyService::CALL_STATE_INCOMING) {
|
|
NS_WARNING("Answer on non-incoming call ignored!");
|
|
return;
|
|
}
|
|
|
|
nsresult rv = mTelephony->Service()->AnswerCall(mServiceId, mCallIndex);
|
|
if (NS_FAILED(rv)) {
|
|
aRv.Throw(rv);
|
|
return;
|
|
}
|
|
|
|
ChangeStateInternal(nsITelephonyService::CALL_STATE_CONNECTING, true);
|
|
}
|
|
|
|
void
|
|
TelephonyCall::HangUp(ErrorResult& aRv)
|
|
{
|
|
if (mCallState == nsITelephonyService::CALL_STATE_DISCONNECTING ||
|
|
mCallState == nsITelephonyService::CALL_STATE_DISCONNECTED) {
|
|
NS_WARNING("HangUp on previously disconnected call ignored!");
|
|
return;
|
|
}
|
|
|
|
nsresult rv = mCallState == nsITelephonyService::CALL_STATE_INCOMING ?
|
|
mTelephony->Service()->RejectCall(mServiceId, mCallIndex) :
|
|
mTelephony->Service()->HangUp(mServiceId, mCallIndex);
|
|
if (NS_FAILED(rv)) {
|
|
aRv.Throw(rv);
|
|
return;
|
|
}
|
|
|
|
ChangeStateInternal(nsITelephonyService::CALL_STATE_DISCONNECTING, true);
|
|
}
|
|
|
|
void
|
|
TelephonyCall::Hold(ErrorResult& aRv)
|
|
{
|
|
if (mCallState != nsITelephonyService::CALL_STATE_CONNECTED) {
|
|
NS_WARNING("Hold non-connected call ignored!");
|
|
return;
|
|
}
|
|
|
|
if (mGroup) {
|
|
NS_WARNING("Hold a call in conference ignored!");
|
|
return;
|
|
}
|
|
|
|
if (!mSwitchable) {
|
|
NS_WARNING("Hold a non-switchable call ignored!");
|
|
return;
|
|
}
|
|
|
|
nsresult rv = mTelephony->Service()->HoldCall(mServiceId, mCallIndex);
|
|
if (NS_FAILED(rv)) {
|
|
aRv.Throw(rv);
|
|
return;
|
|
}
|
|
|
|
if (mSecondId) {
|
|
// No state transition when we switch two numbers within one TelephonyCall
|
|
// object. Otherwise, the state here will be inconsistent with the backend
|
|
// RIL and will never be right.
|
|
return;
|
|
}
|
|
|
|
ChangeStateInternal(nsITelephonyService::CALL_STATE_HOLDING, true);
|
|
}
|
|
|
|
void
|
|
TelephonyCall::Resume(ErrorResult& aRv)
|
|
{
|
|
if (mCallState != nsITelephonyService::CALL_STATE_HELD) {
|
|
NS_WARNING("Resume non-held call ignored!");
|
|
return;
|
|
}
|
|
|
|
if (mGroup) {
|
|
NS_WARNING("Resume a call in conference ignored!");
|
|
return;
|
|
}
|
|
|
|
if (!mSwitchable) {
|
|
NS_WARNING("Resume a non-switchable call ignored!");
|
|
return;
|
|
}
|
|
|
|
nsresult rv = mTelephony->Service()->ResumeCall(mServiceId, mCallIndex);
|
|
if (NS_FAILED(rv)) {
|
|
aRv.Throw(rv);
|
|
return;
|
|
}
|
|
|
|
ChangeStateInternal(nsITelephonyService::CALL_STATE_RESUMING, true);
|
|
}
|