2012-01-09 22:28:47 +00:00
|
|
|
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
|
|
/* vim: set ts=2 et sw=2 tw=40: */
|
2012-05-21 11:12:37 +00:00
|
|
|
/* 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/. */
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
#include "Telephony.h"
|
|
|
|
|
|
|
|
#include "nsIURI.h"
|
2012-02-24 13:14:37 +00:00
|
|
|
#include "nsIURL.h"
|
2012-01-09 22:28:47 +00:00
|
|
|
#include "nsPIDOMWindow.h"
|
|
|
|
|
|
|
|
#include "jsapi.h"
|
2012-08-06 07:33:37 +00:00
|
|
|
#include "nsIPermissionManager.h"
|
2012-02-24 13:14:37 +00:00
|
|
|
#include "nsCharSeparatedTokenizer.h"
|
2012-01-09 22:28:47 +00:00
|
|
|
#include "nsContentUtils.h"
|
|
|
|
#include "nsDOMClassInfo.h"
|
2012-01-09 23:18:23 +00:00
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
2012-02-24 13:14:37 +00:00
|
|
|
#include "nsNetUtil.h"
|
2012-01-09 22:28:47 +00:00
|
|
|
#include "nsServiceManagerUtils.h"
|
2012-01-09 23:18:23 +00:00
|
|
|
#include "SystemWorkerManager.h"
|
2012-04-24 15:44:42 +00:00
|
|
|
#include "nsRadioInterfaceLayer.h"
|
2012-09-28 17:43:49 +00:00
|
|
|
#include "nsTArrayHelpers.h"
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
#include "CallEvent.h"
|
|
|
|
#include "TelephonyCall.h"
|
|
|
|
|
|
|
|
USING_TELEPHONY_NAMESPACE
|
2012-03-14 22:43:26 +00:00
|
|
|
using namespace mozilla::dom::gonk;
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-02-23 15:09:11 +00:00
|
|
|
namespace {
|
|
|
|
|
2012-02-24 13:14:37 +00:00
|
|
|
typedef nsAutoTArray<Telephony*, 2> TelephonyList;
|
|
|
|
|
|
|
|
TelephonyList* gTelephonyList;
|
|
|
|
|
2012-02-23 15:09:11 +00:00
|
|
|
} // anonymous namespace
|
|
|
|
|
2012-02-24 13:14:37 +00:00
|
|
|
Telephony::Telephony()
|
2012-07-30 14:20:58 +00:00
|
|
|
: mActiveCall(nullptr), mCallsArray(nullptr), mRooted(false)
|
2012-02-24 13:14:37 +00:00
|
|
|
{
|
|
|
|
if (!gTelephonyList) {
|
|
|
|
gTelephonyList = new TelephonyList();
|
|
|
|
}
|
|
|
|
|
|
|
|
gTelephonyList->AppendElement(this);
|
|
|
|
}
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
Telephony::~Telephony()
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
if (mRIL && mRILTelephonyCallback) {
|
2012-04-24 15:44:42 +00:00
|
|
|
mRIL->UnregisterTelephonyCallback(mRILTelephonyCallback);
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
2012-02-23 15:09:11 +00:00
|
|
|
|
|
|
|
if (mRooted) {
|
|
|
|
NS_DROP_JS_OBJECTS(this, Telephony);
|
|
|
|
}
|
2012-02-24 13:14:37 +00:00
|
|
|
|
|
|
|
NS_ASSERTION(gTelephonyList, "This should never be null!");
|
|
|
|
NS_ASSERTION(gTelephonyList->Contains(this), "Should be in the list!");
|
|
|
|
|
|
|
|
if (gTelephonyList->Length() == 1) {
|
|
|
|
delete gTelephonyList;
|
2012-07-30 14:20:58 +00:00
|
|
|
gTelephonyList = nullptr;
|
2012-02-24 13:14:37 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
gTelephonyList->RemoveElement(this);
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// static
|
|
|
|
already_AddRefed<Telephony>
|
2012-04-24 15:44:42 +00:00
|
|
|
Telephony::Create(nsPIDOMWindow* aOwner, nsIRILContentHelper* aRIL)
|
2012-01-09 22:28:47 +00:00
|
|
|
{
|
|
|
|
NS_ASSERTION(aOwner, "Null owner!");
|
2012-01-19 20:53:32 +00:00
|
|
|
NS_ASSERTION(aRIL, "Null RIL!");
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aOwner);
|
2012-07-30 14:20:58 +00:00
|
|
|
NS_ENSURE_TRUE(sgo, nullptr);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
nsCOMPtr<nsIScriptContext> scriptContext = sgo->GetContext();
|
2012-07-30 14:20:58 +00:00
|
|
|
NS_ENSURE_TRUE(scriptContext, nullptr);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
nsRefPtr<Telephony> telephony = new Telephony();
|
|
|
|
|
2012-03-13 22:11:16 +00:00
|
|
|
telephony->BindToOwner(aOwner);
|
|
|
|
|
2012-01-19 20:53:32 +00:00
|
|
|
telephony->mRIL = aRIL;
|
|
|
|
telephony->mRILTelephonyCallback = new RILTelephonyCallback(telephony);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = aRIL->EnumerateCalls(telephony->mRILTelephonyCallback);
|
2012-07-30 14:20:58 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, nullptr);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-04-24 15:44:42 +00:00
|
|
|
rv = aRIL->RegisterTelephonyCallback(telephony->mRILTelephonyCallback);
|
2012-07-30 14:20:58 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, nullptr);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-10-09 10:07:11 +00:00
|
|
|
rv = aRIL->RegisterTelephonyMsg();
|
|
|
|
NS_ENSURE_SUCCESS(rv, nullptr);
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
return telephony.forget();
|
|
|
|
}
|
|
|
|
|
2012-02-24 13:14:37 +00:00
|
|
|
already_AddRefed<TelephonyCall>
|
|
|
|
Telephony::CreateNewDialingCall(const nsAString& aNumber)
|
|
|
|
{
|
|
|
|
nsRefPtr<TelephonyCall> call =
|
|
|
|
TelephonyCall::Create(this, aNumber,
|
|
|
|
nsIRadioInterfaceLayer::CALL_STATE_DIALING);
|
|
|
|
NS_ASSERTION(call, "This should never fail!");
|
|
|
|
|
|
|
|
NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
|
|
|
|
|
|
|
|
return call.forget();
|
|
|
|
}
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
void
|
2012-02-24 13:14:37 +00:00
|
|
|
Telephony::NoteDialedCallFromOtherInstance(const nsAString& aNumber)
|
2012-01-09 22:28:47 +00:00
|
|
|
{
|
2012-02-24 13:14:37 +00:00
|
|
|
// We don't need to hang on to this call object, it is held alive by mCalls.
|
|
|
|
nsRefPtr<TelephonyCall> call = CreateNewDialingCall(aNumber);
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult
|
|
|
|
Telephony::NotifyCallsChanged(TelephonyCall* aCall)
|
|
|
|
{
|
|
|
|
nsRefPtr<CallEvent> event = CallEvent::Create(aCall);
|
|
|
|
NS_ASSERTION(event, "This should never fail!");
|
|
|
|
|
2012-06-08 07:09:15 +00:00
|
|
|
if (aCall->CallState() == nsIRadioInterfaceLayer::CALL_STATE_DIALING) {
|
|
|
|
mActiveCall = aCall;
|
|
|
|
}
|
|
|
|
|
2012-02-24 13:14:37 +00:00
|
|
|
nsresult rv =
|
|
|
|
event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("callschanged"));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
|
|
|
|
2012-07-20 12:08:24 +00:00
|
|
|
nsresult
|
|
|
|
Telephony::DialInternal(bool isEmergency,
|
|
|
|
const nsAString& aNumber,
|
|
|
|
nsIDOMTelephonyCall** aResult)
|
|
|
|
{
|
|
|
|
NS_ENSURE_ARG(!aNumber.IsEmpty());
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < mCalls.Length(); index++) {
|
2012-07-20 12:08:24 +00:00
|
|
|
const nsRefPtr<TelephonyCall>& tempCall = mCalls[index];
|
|
|
|
if (tempCall->IsOutgoing() &&
|
|
|
|
tempCall->CallState() < nsIRadioInterfaceLayer::CALL_STATE_CONNECTED) {
|
|
|
|
// One call has been dialed already and we only support one outgoing call
|
|
|
|
// at a time.
|
|
|
|
NS_WARNING("Only permitted to dial one call at a time!");
|
|
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult rv;
|
|
|
|
if (isEmergency) {
|
|
|
|
rv = mRIL->DialEmergency(aNumber);
|
|
|
|
} else {
|
|
|
|
rv = mRIL->Dial(aNumber);
|
|
|
|
}
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
nsRefPtr<TelephonyCall> call = CreateNewDialingCall(aNumber);
|
|
|
|
|
|
|
|
// Notify other telephony objects that we just dialed.
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < gTelephonyList->Length(); index++) {
|
2012-07-20 12:08:24 +00:00
|
|
|
Telephony*& telephony = gTelephonyList->ElementAt(index);
|
|
|
|
if (telephony != this) {
|
|
|
|
nsRefPtr<Telephony> kungFuDeathGrip = telephony;
|
|
|
|
telephony->NoteDialedCallFromOtherInstance(aNumber);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
call.forget(aResult);
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(Telephony)
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(Telephony,
|
2012-02-08 19:22:01 +00:00
|
|
|
nsDOMEventTargetHelper)
|
2012-02-23 15:09:11 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < tmp->mCalls.Length(); index++) {
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mCalls[i]");
|
|
|
|
cb.NoteXPCOMChild(tmp->mCalls[index]->ToISupports());
|
|
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
2012-02-23 15:09:11 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(Telephony,
|
|
|
|
nsDOMEventTargetHelper)
|
2012-05-15 16:56:39 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mCallsArray)
|
2012-02-23 15:09:11 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(Telephony,
|
2012-02-08 19:22:01 +00:00
|
|
|
nsDOMEventTargetHelper)
|
2012-01-09 22:28:47 +00:00
|
|
|
tmp->mCalls.Clear();
|
2012-07-30 14:20:58 +00:00
|
|
|
tmp->mActiveCall = nullptr;
|
|
|
|
tmp->mCallsArray = nullptr;
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(Telephony)
|
|
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMTelephony)
|
|
|
|
NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(Telephony)
|
2012-02-08 19:22:01 +00:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-02-08 19:22:01 +00:00
|
|
|
NS_IMPL_ADDREF_INHERITED(Telephony, nsDOMEventTargetHelper)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(Telephony, nsDOMEventTargetHelper)
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
DOMCI_DATA(Telephony, Telephony)
|
|
|
|
|
2012-01-19 20:53:32 +00:00
|
|
|
NS_IMPL_ISUPPORTS1(Telephony::RILTelephonyCallback, nsIRILTelephonyCallback)
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::Dial(const nsAString& aNumber, nsIDOMTelephonyCall** aResult)
|
|
|
|
{
|
2012-07-20 12:08:24 +00:00
|
|
|
DialInternal(false, aNumber, aResult);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-07-20 12:08:24 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-07-20 12:08:24 +00:00
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::DialEmergency(const nsAString& aNumber, nsIDOMTelephonyCall** aResult)
|
|
|
|
{
|
|
|
|
DialInternal(true, aNumber, aResult);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::GetMuted(bool* aMuted)
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->GetMicrophoneMuted(aMuted);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::SetMuted(bool aMuted)
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->SetMicrophoneMuted(aMuted);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::GetSpeakerEnabled(bool* aSpeakerEnabled)
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->GetSpeakerEnabled(aSpeakerEnabled);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::SetSpeakerEnabled(bool aSpeakerEnabled)
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->SetSpeakerEnabled(aSpeakerEnabled);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::GetActive(jsval* aActive)
|
|
|
|
{
|
|
|
|
if (!mActiveCall) {
|
|
|
|
aActive->setNull();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-03-13 22:11:16 +00:00
|
|
|
nsresult rv;
|
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2012-03-13 22:11:16 +00:00
|
|
|
if (sc) {
|
|
|
|
rv =
|
|
|
|
nsContentUtils::WrapNative(sc->GetNativeContext(),
|
|
|
|
sc->GetNativeGlobal(),
|
|
|
|
mActiveCall->ToISupports(), aActive);
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-02-23 15:09:11 +00:00
|
|
|
Telephony::GetCalls(jsval* aCalls)
|
2012-01-09 22:28:47 +00:00
|
|
|
{
|
2012-02-23 15:09:11 +00:00
|
|
|
JSObject* calls = mCallsArray;
|
2012-01-09 22:28:47 +00:00
|
|
|
if (!calls) {
|
2012-03-13 22:11:16 +00:00
|
|
|
nsresult rv;
|
|
|
|
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
|
2012-02-23 15:09:11 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2012-03-13 22:11:16 +00:00
|
|
|
if (sc) {
|
2012-09-28 17:43:49 +00:00
|
|
|
rv = nsTArrayToJSArray(sc->GetNativeContext(), mCalls, &calls);
|
2012-03-13 22:11:16 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2012-02-23 15:09:11 +00:00
|
|
|
|
2012-03-13 22:11:16 +00:00
|
|
|
if (!mRooted) {
|
|
|
|
NS_HOLD_JS_OBJECTS(this, Telephony);
|
|
|
|
mRooted = true;
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-03-13 22:11:16 +00:00
|
|
|
mCallsArray = calls;
|
|
|
|
} else {
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
|
|
|
|
2012-02-23 15:09:11 +00:00
|
|
|
aCalls->setObject(*calls);
|
2012-01-09 22:28:47 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::StartTone(const nsAString& aDTMFChar)
|
|
|
|
{
|
|
|
|
if (aDTMFChar.IsEmpty()) {
|
|
|
|
NS_WARNING("Empty tone string will be ignored");
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (aDTMFChar.Length() > 1) {
|
|
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
}
|
|
|
|
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->StartTone(aDTMFChar);
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
Telephony::StopTone()
|
|
|
|
{
|
2012-01-19 20:53:32 +00:00
|
|
|
nsresult rv = mRIL->StopTone();
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMPL_EVENT_HANDLER(Telephony, incoming)
|
2012-02-24 13:14:37 +00:00
|
|
|
NS_IMPL_EVENT_HANDLER(Telephony, callschanged)
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
Telephony::CallStateChanged(uint32_t aCallIndex, uint16_t aCallState,
|
2012-05-15 04:13:06 +00:00
|
|
|
const nsAString& aNumber, bool aIsActive)
|
2012-01-09 22:28:47 +00:00
|
|
|
{
|
2012-01-12 02:17:26 +00:00
|
|
|
NS_ASSERTION(aCallIndex != kOutgoingPlaceholderCallIndex,
|
|
|
|
"This should never happen!");
|
|
|
|
|
|
|
|
nsRefPtr<TelephonyCall> modifiedCall;
|
|
|
|
nsRefPtr<TelephonyCall> outgoingCall;
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < mCalls.Length(); index++) {
|
2012-01-09 22:28:47 +00:00
|
|
|
nsRefPtr<TelephonyCall>& tempCall = mCalls[index];
|
2012-01-12 02:17:26 +00:00
|
|
|
if (tempCall->CallIndex() == kOutgoingPlaceholderCallIndex) {
|
|
|
|
NS_ASSERTION(!outgoingCall, "More than one outgoing call not supported!");
|
2012-02-24 13:14:37 +00:00
|
|
|
NS_ASSERTION(tempCall->CallState() ==
|
|
|
|
nsIRadioInterfaceLayer::CALL_STATE_DIALING,
|
2012-01-12 02:17:26 +00:00
|
|
|
"Something really wrong here!");
|
|
|
|
// Stash this for later, we may need it if aCallIndex doesn't match one of
|
|
|
|
// our other calls.
|
|
|
|
outgoingCall = tempCall;
|
|
|
|
} else if (tempCall->CallIndex() == aCallIndex) {
|
|
|
|
// We already know about this call so just update its state.
|
|
|
|
modifiedCall = tempCall;
|
2012-07-30 14:20:58 +00:00
|
|
|
outgoingCall = nullptr;
|
2012-01-12 02:17:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-01-12 02:17:26 +00:00
|
|
|
// If nothing matched above and the call state isn't incoming but we do have
|
|
|
|
// an outgoing call then we must be seeing a status update for our outgoing
|
|
|
|
// call.
|
|
|
|
if (!modifiedCall &&
|
2012-01-19 20:53:32 +00:00
|
|
|
aCallState != nsIRadioInterfaceLayer::CALL_STATE_INCOMING &&
|
2012-01-12 02:17:26 +00:00
|
|
|
outgoingCall) {
|
|
|
|
outgoingCall->UpdateCallIndex(aCallIndex);
|
|
|
|
modifiedCall.swap(outgoingCall);
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-01-12 02:17:26 +00:00
|
|
|
if (modifiedCall) {
|
|
|
|
|
|
|
|
// See if this should replace our current active call.
|
2012-05-15 04:13:06 +00:00
|
|
|
if (aIsActive) {
|
2012-06-08 07:09:15 +00:00
|
|
|
if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_DISCONNECTED) {
|
2012-07-30 14:20:58 +00:00
|
|
|
mActiveCall = nullptr;
|
2012-06-08 07:09:15 +00:00
|
|
|
} else {
|
|
|
|
mActiveCall = modifiedCall;
|
|
|
|
}
|
2012-07-04 05:46:11 +00:00
|
|
|
} else {
|
|
|
|
if (mActiveCall && mActiveCall->CallIndex() == aCallIndex) {
|
2012-07-30 14:20:58 +00:00
|
|
|
mActiveCall = nullptr;
|
2012-07-04 05:46:11 +00:00
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
2012-01-12 02:17:26 +00:00
|
|
|
|
2012-06-08 07:09:15 +00:00
|
|
|
// Change state.
|
|
|
|
modifiedCall->ChangeState(aCallState);
|
|
|
|
|
2012-01-12 02:17:26 +00:00
|
|
|
return NS_OK;
|
2012-01-09 22:28:47 +00:00
|
|
|
}
|
|
|
|
|
2012-10-25 10:31:37 +00:00
|
|
|
// Didn't know anything about this call before now, could be 'incoming' or
|
|
|
|
// 'dialing' that was placed by others.
|
|
|
|
NS_ASSERTION(aCallState == nsIRadioInterfaceLayer::CALL_STATE_INCOMING ||
|
|
|
|
aCallState == nsIRadioInterfaceLayer::CALL_STATE_DIALING,
|
2012-01-09 22:28:47 +00:00
|
|
|
"Serious logic problem here!");
|
|
|
|
|
|
|
|
nsRefPtr<TelephonyCall> call =
|
|
|
|
TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
|
|
|
|
NS_ASSERTION(call, "This should never fail!");
|
|
|
|
|
|
|
|
NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
|
|
|
|
|
2012-10-25 10:31:37 +00:00
|
|
|
if (aCallState == nsIRadioInterfaceLayer::CALL_STATE_INCOMING) {
|
|
|
|
// Dispatch incoming event.
|
|
|
|
nsRefPtr<CallEvent> event = CallEvent::Create(call);
|
|
|
|
NS_ASSERTION(event, "This should never fail!");
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-10-25 10:31:37 +00:00
|
|
|
nsresult rv =
|
|
|
|
event->Dispatch(ToIDOMEventTarget(), NS_LITERAL_STRING("incoming"));
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
Telephony::EnumerateCallState(uint32_t aCallIndex, uint16_t aCallState,
|
2012-01-09 22:28:47 +00:00
|
|
|
const nsAString& aNumber, bool aIsActive,
|
|
|
|
bool* aContinue)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG
|
|
|
|
// Make sure we don't somehow add duplicates.
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < mCalls.Length(); index++) {
|
2012-01-09 22:28:47 +00:00
|
|
|
NS_ASSERTION(mCalls[index]->CallIndex() != aCallIndex,
|
|
|
|
"Something is really wrong here!");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
nsRefPtr<TelephonyCall> call =
|
|
|
|
TelephonyCall::Create(this, aNumber, aCallState, aCallIndex);
|
|
|
|
NS_ASSERTION(call, "This should never fail!");
|
|
|
|
|
|
|
|
NS_ASSERTION(mCalls.Contains(call), "Should have auto-added new call!");
|
|
|
|
|
|
|
|
if (aIsActive) {
|
|
|
|
NS_ASSERTION(!mActiveCall, "Already have an active call!");
|
|
|
|
mActiveCall = call;
|
|
|
|
}
|
|
|
|
|
|
|
|
*aContinue = true;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-05-15 04:13:06 +00:00
|
|
|
NS_IMETHODIMP
|
2012-08-22 15:56:38 +00:00
|
|
|
Telephony::NotifyError(int32_t aCallIndex,
|
2012-06-21 03:00:52 +00:00
|
|
|
const nsAString& aError)
|
2012-05-15 04:13:06 +00:00
|
|
|
{
|
2012-06-21 03:00:52 +00:00
|
|
|
nsRefPtr<TelephonyCall> callToNotify;
|
|
|
|
if (!mCalls.IsEmpty()) {
|
|
|
|
// The connection is not established yet. Get the latest call object.
|
|
|
|
if (aCallIndex == -1) {
|
|
|
|
callToNotify = mCalls[mCalls.Length() - 1];
|
|
|
|
} else {
|
|
|
|
// The connection has been established. Get the failed call.
|
2012-08-22 15:56:38 +00:00
|
|
|
for (uint32_t index = 0; index < mCalls.Length(); index++) {
|
2012-06-21 03:00:52 +00:00
|
|
|
nsRefPtr<TelephonyCall>& call = mCalls[index];
|
|
|
|
if (call->CallIndex() == aCallIndex) {
|
|
|
|
callToNotify = call;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-06-22 02:23:55 +00:00
|
|
|
}
|
2012-05-15 04:13:06 +00:00
|
|
|
}
|
2012-06-21 03:00:52 +00:00
|
|
|
|
|
|
|
if (!callToNotify) {
|
|
|
|
NS_ERROR("Don't call me with a bad call index!");
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
2012-05-15 04:13:06 +00:00
|
|
|
}
|
|
|
|
|
2012-07-20 12:08:24 +00:00
|
|
|
if (mActiveCall && mActiveCall->CallIndex() == callToNotify->CallIndex()) {
|
2012-07-30 14:20:58 +00:00
|
|
|
mActiveCall = nullptr;
|
2012-07-20 12:08:24 +00:00
|
|
|
}
|
|
|
|
|
2012-06-21 03:00:52 +00:00
|
|
|
// Set the call state to 'disconnected' and remove it from the calls list.
|
|
|
|
callToNotify->NotifyError(aError);
|
|
|
|
|
2012-05-15 04:13:06 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2012-01-09 22:28:47 +00:00
|
|
|
nsresult
|
|
|
|
NS_NewTelephony(nsPIDOMWindow* aWindow, nsIDOMTelephony** aTelephony)
|
|
|
|
{
|
|
|
|
NS_ASSERTION(aWindow, "Null pointer!");
|
|
|
|
|
|
|
|
nsPIDOMWindow* innerWindow = aWindow->IsInnerWindow() ?
|
2012-05-24 04:02:23 +00:00
|
|
|
aWindow :
|
|
|
|
aWindow->GetCurrentInnerWindow();
|
2012-05-24 01:27:53 +00:00
|
|
|
|
2012-08-06 07:33:37 +00:00
|
|
|
nsCOMPtr<nsIPermissionManager> permMgr =
|
|
|
|
do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
|
|
|
|
NS_ENSURE_TRUE(permMgr, NS_ERROR_UNEXPECTED);
|
|
|
|
|
2012-08-22 15:56:38 +00:00
|
|
|
uint32_t permission;
|
2012-05-24 04:02:23 +00:00
|
|
|
nsresult rv =
|
2012-09-21 10:32:18 +00:00
|
|
|
permMgr->TestPermissionFromWindow(aWindow, "telephony", &permission);
|
2012-05-24 04:02:23 +00:00
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2012-08-06 07:33:37 +00:00
|
|
|
|
|
|
|
if (permission != nsIPermissionManager::ALLOW_ACTION) {
|
2012-07-30 14:20:58 +00:00
|
|
|
*aTelephony = nullptr;
|
2012-05-24 04:02:23 +00:00
|
|
|
return NS_OK;
|
2012-01-12 02:19:53 +00:00
|
|
|
}
|
2012-01-09 22:28:47 +00:00
|
|
|
|
2012-04-24 15:44:42 +00:00
|
|
|
nsCOMPtr<nsIRILContentHelper> ril =
|
|
|
|
do_GetService(NS_RILCONTENTHELPER_CONTRACTID);
|
2012-01-19 20:53:32 +00:00
|
|
|
NS_ENSURE_TRUE(ril, NS_ERROR_UNEXPECTED);
|
2012-01-12 02:19:53 +00:00
|
|
|
|
2012-01-19 20:53:32 +00:00
|
|
|
nsRefPtr<Telephony> telephony = Telephony::Create(innerWindow, ril);
|
2012-01-12 02:19:53 +00:00
|
|
|
NS_ENSURE_TRUE(telephony, NS_ERROR_UNEXPECTED);
|
2012-01-09 22:28:47 +00:00
|
|
|
|
|
|
|
telephony.forget(aTelephony);
|
|
|
|
return NS_OK;
|
|
|
|
}
|