mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
576 lines
15 KiB
C++
576 lines
15 KiB
C++
/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* 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 "base/basictypes.h"
|
|
|
|
#include "BluetoothService.h"
|
|
#include "BluetoothManager.h"
|
|
#include "BluetoothTypes.h"
|
|
#include "BluetoothReplyRunnable.h"
|
|
|
|
#include "jsapi.h"
|
|
#include "mozilla/Services.h"
|
|
#include "mozilla/Util.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIDOMDOMRequest.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsISettingsService.h"
|
|
#include "nsThreadUtils.h"
|
|
#include "nsXPCOM.h"
|
|
#include "nsXPCOMCIDInternal.h"
|
|
#include "nsISystemMessagesInternal.h"
|
|
|
|
#define MOZSETTINGS_CHANGED_ID "mozsettings-changed"
|
|
#define BLUETOOTH_ENABLED_SETTING "bluetooth.enabled"
|
|
|
|
using namespace mozilla;
|
|
|
|
USING_BLUETOOTH_NAMESPACE
|
|
|
|
static nsRefPtr<BluetoothService> gBluetoothService;
|
|
static bool gInShutdown = false;
|
|
|
|
NS_IMPL_ISUPPORTS1(BluetoothService, nsIObserver)
|
|
|
|
class BluetoothService::ToggleBtAck : public nsRunnable
|
|
{
|
|
public:
|
|
ToggleBtAck(bool aEnabled)
|
|
: mEnabled(aEnabled)
|
|
{
|
|
MOZ_ASSERT(!NS_IsMainThread());
|
|
}
|
|
|
|
NS_IMETHOD Run()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!gBluetoothService) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!gInShutdown) {
|
|
// Notify all the managers about the state change.
|
|
gBluetoothService->SetEnabled(mEnabled);
|
|
}
|
|
|
|
if (!mEnabled || gInShutdown) {
|
|
// Shut down the command thread if it still exists.
|
|
if (gBluetoothService->mBluetoothCommandThread) {
|
|
nsCOMPtr<nsIThread> thread;
|
|
gBluetoothService->mBluetoothCommandThread.swap(thread);
|
|
if (NS_FAILED(thread->Shutdown())) {
|
|
NS_WARNING("Failed to shut down the bluetooth command thread!");
|
|
}
|
|
}
|
|
|
|
if (gInShutdown) {
|
|
gBluetoothService = nullptr;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
bool mEnabled;
|
|
};
|
|
|
|
class BluetoothService::ToggleBtTask : public nsRunnable
|
|
{
|
|
public:
|
|
ToggleBtTask(bool aEnabled)
|
|
: mEnabled(aEnabled)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
}
|
|
|
|
NS_IMETHOD Run()
|
|
{
|
|
MOZ_ASSERT(!NS_IsMainThread());
|
|
|
|
if (mEnabled) {
|
|
if (NS_FAILED(gBluetoothService->StartInternal())) {
|
|
NS_WARNING("Bluetooth service failed to start!");
|
|
mEnabled = !mEnabled;
|
|
}
|
|
}
|
|
else if (NS_FAILED(gBluetoothService->StopInternal())) {
|
|
NS_WARNING("Bluetooth service failed to stop!");
|
|
mEnabled = !mEnabled;
|
|
}
|
|
|
|
nsCOMPtr<nsIRunnable> ackTask = new BluetoothService::ToggleBtAck(mEnabled);
|
|
if (NS_FAILED(NS_DispatchToMainThread(ackTask))) {
|
|
NS_WARNING("Failed to dispatch to main thread!");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
private:
|
|
bool mEnabled;
|
|
};
|
|
|
|
class BluetoothService::StartupTask : public nsISettingsServiceCallback
|
|
{
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
NS_IMETHOD Handle(const nsAString& aName, const jsval& aResult, JSContext* aCx)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(gBluetoothService);
|
|
|
|
if (!aResult.isBoolean()) {
|
|
NS_WARNING("Setting for '" BLUETOOTH_ENABLED_SETTING "' is not a boolean!");
|
|
return NS_OK;
|
|
}
|
|
|
|
return aResult.toBoolean() ? gBluetoothService->Start() : NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD HandleError(const nsAString& aName, JSContext* aCx)
|
|
{
|
|
NS_WARNING("Unable to get value for '" BLUETOOTH_ENABLED_SETTING "'");
|
|
return NS_OK;
|
|
}
|
|
};
|
|
|
|
NS_IMPL_ISUPPORTS1(BluetoothService::StartupTask, nsISettingsServiceCallback);
|
|
|
|
BluetoothService::~BluetoothService()
|
|
{
|
|
if (!gBluetoothService) {
|
|
return;
|
|
}
|
|
|
|
if (NS_FAILED(gBluetoothService->UnregisterBluetoothSignalHandler(
|
|
NS_LITERAL_STRING(LOCAL_AGENT_PATH), gBluetoothService))) {
|
|
NS_WARNING("Unresgister observer to register local agent failed!");
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::RegisterBluetoothSignalHandler(const nsAString& aNodeName,
|
|
BluetoothSignalObserver* aHandler)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
BluetoothSignalObserverList* ol;
|
|
if (!mBluetoothSignalObserverTable.Get(aNodeName, &ol)) {
|
|
ol = new BluetoothSignalObserverList();
|
|
mBluetoothSignalObserverTable.Put(aNodeName, ol);
|
|
}
|
|
ol->AddObserver(aHandler);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::UnregisterBluetoothSignalHandler(const nsAString& aNodeName,
|
|
BluetoothSignalObserver* aHandler)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
BluetoothSignalObserverList* ol;
|
|
if (!mBluetoothSignalObserverTable.Get(aNodeName, &ol)) {
|
|
NS_WARNING("Node does not exist to remove BluetoothSignalListener from!");
|
|
return NS_OK;
|
|
}
|
|
ol->RemoveObserver(aHandler);
|
|
if (ol->Length() == 0) {
|
|
mBluetoothSignalObserverTable.Remove(aNodeName);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::DistributeSignal(const BluetoothSignal& signal)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
// Notify observers that a message has been sent
|
|
BluetoothSignalObserverList* ol;
|
|
if (!mBluetoothSignalObserverTable.Get(signal.path(), &ol)) {
|
|
#if DEBUG
|
|
nsString msg;
|
|
msg.AssignLiteral("No observer registered for path");
|
|
msg.Append(signal.path());
|
|
NS_WARNING(NS_ConvertUTF16toUTF8(msg).get());
|
|
#endif
|
|
return NS_OK;
|
|
}
|
|
#if DEBUG
|
|
if (ol->Length() == 0) {
|
|
NS_WARNING("Distributing to observer list of 0");
|
|
}
|
|
#endif
|
|
ol->Broadcast(signal);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::StartStopBluetooth(bool aStart)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
#ifdef DEBUG
|
|
if (aStart && mLastRequestedEnable) {
|
|
MOZ_ASSERT(false, "Calling Start twice in a row!");
|
|
}
|
|
else if (!aStart && !mLastRequestedEnable) {
|
|
MOZ_ASSERT(false, "Calling Stop twice in a row!");
|
|
}
|
|
mLastRequestedEnable = aStart;
|
|
#endif
|
|
|
|
if (gInShutdown) {
|
|
if (aStart) {
|
|
// Don't try to start if we're already shutting down.
|
|
MOZ_ASSERT(false, "Start called while in shutdown!");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (!mBluetoothCommandThread) {
|
|
// Don't create a new thread after we've begun shutdown since bluetooth
|
|
// can't be running.
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
if (!mBluetoothCommandThread) {
|
|
MOZ_ASSERT(!gInShutdown);
|
|
|
|
rv = NS_NewNamedThread("BluetoothCmd",
|
|
getter_AddRefs(mBluetoothCommandThread));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
nsCOMPtr<nsIRunnable> runnable = new ToggleBtTask(aStart);
|
|
rv = mBluetoothCommandThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
BluetoothService::SetEnabled(bool aEnabled)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (aEnabled == mEnabled) {
|
|
// Nothing to do, maybe something failed.
|
|
return;
|
|
}
|
|
|
|
mEnabled = aEnabled;
|
|
|
|
BluetoothManagerList::ForwardIterator iter(mLiveManagers);
|
|
while (iter.HasMore()) {
|
|
if (NS_FAILED(iter.GetNext()->FireEnabledDisabledEvent(mEnabled))) {
|
|
NS_WARNING("FireEnabledDisabledEvent failed!");
|
|
}
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::Start()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return StartStopBluetooth(true);
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::Stop()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return StartStopBluetooth(false);
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::HandleStartup()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
nsCOMPtr<nsISettingsService> settings =
|
|
do_GetService("@mozilla.org/settingsService;1");
|
|
NS_ENSURE_TRUE(settings, NS_ERROR_UNEXPECTED);
|
|
|
|
nsCOMPtr<nsISettingsServiceLock> settingsLock;
|
|
nsresult rv = settings->CreateLock(getter_AddRefs(settingsLock));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsRefPtr<StartupTask> callback = new StartupTask();
|
|
rv = settingsLock->Get(BLUETOOTH_ENABLED_SETTING, callback);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::HandleSettingsChanged(const nsAString& aData)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
// The string that we're interested in will be a JSON string that looks like:
|
|
// {"key":"bluetooth.enabled","value":true}
|
|
|
|
JSContext* cx = nsContentUtils::GetSafeJSContext();
|
|
if (!cx) {
|
|
return NS_OK;
|
|
}
|
|
|
|
JS::Value val;
|
|
if (!JS_ParseJSON(cx, aData.BeginReading(), aData.Length(), &val)) {
|
|
return JS_ReportPendingException(cx) ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (!val.isObject()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
JSObject& obj(val.toObject());
|
|
|
|
JS::Value key;
|
|
if (!JS_GetProperty(cx, &obj, "key", &key)) {
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (!key.isString()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
JSBool match;
|
|
if (!JS_StringEqualsAscii(cx, key.toString(), BLUETOOTH_ENABLED_SETTING,
|
|
&match)) {
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (!match) {
|
|
return NS_OK;
|
|
}
|
|
|
|
JS::Value value;
|
|
if (!JS_GetProperty(cx, &obj, "value", &value)) {
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
if (!value.isBoolean()) {
|
|
MOZ_ASSERT(false, "Expecting a boolean for 'bluetooth.enabled'!");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
if (value.toBoolean() == IsEnabled()) {
|
|
// Nothing to do here.
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv;
|
|
|
|
if (IsEnabled()) {
|
|
rv = Stop();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
rv = Start();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::HandleShutdown()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
gInShutdown = true;
|
|
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
if (obs &&
|
|
(NS_FAILED(obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) ||
|
|
NS_FAILED(obs->RemoveObserver(this, MOZSETTINGS_CHANGED_ID)))) {
|
|
NS_WARNING("Can't unregister observers!");
|
|
}
|
|
|
|
return Stop();
|
|
}
|
|
|
|
void
|
|
BluetoothService::RegisterManager(BluetoothManager* aManager)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aManager);
|
|
MOZ_ASSERT(!mLiveManagers.Contains(aManager));
|
|
|
|
mLiveManagers.AppendElement(aManager);
|
|
RegisterBluetoothSignalHandler(aManager->GetPath(), aManager);
|
|
}
|
|
|
|
void
|
|
BluetoothService::UnregisterManager(BluetoothManager* aManager)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aManager);
|
|
MOZ_ASSERT(mLiveManagers.Contains(aManager));
|
|
|
|
UnregisterBluetoothSignalHandler(aManager->GetPath(), aManager);
|
|
mLiveManagers.RemoveElement(aManager);
|
|
}
|
|
|
|
// static
|
|
BluetoothService*
|
|
BluetoothService::Get()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
// If we already exist, exit early
|
|
if (gBluetoothService) {
|
|
return gBluetoothService;
|
|
}
|
|
|
|
// If we're in shutdown, don't create a new instance
|
|
if (gInShutdown) {
|
|
NS_WARNING("BluetoothService can't be created during shutdown");
|
|
return nullptr;
|
|
}
|
|
|
|
// Create new instance, register, return
|
|
nsRefPtr<BluetoothService> service = BluetoothService::Create();
|
|
NS_ENSURE_TRUE(service, nullptr);
|
|
|
|
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
|
|
NS_ENSURE_TRUE(obs, nullptr);
|
|
|
|
if (NS_FAILED(obs->AddObserver(service, NS_XPCOM_SHUTDOWN_OBSERVER_ID,
|
|
false)) ||
|
|
NS_FAILED(obs->AddObserver(service, MOZSETTINGS_CHANGED_ID, false))) {
|
|
NS_WARNING("AddObserver failed!");
|
|
return nullptr;
|
|
}
|
|
|
|
gBluetoothService.swap(service);
|
|
|
|
if (NS_FAILED(gBluetoothService->RegisterBluetoothSignalHandler(
|
|
NS_LITERAL_STRING(LOCAL_AGENT_PATH), gBluetoothService))) {
|
|
NS_WARNING("Resgister observer to register local agent failed!");
|
|
return nullptr;
|
|
}
|
|
|
|
return gBluetoothService;
|
|
}
|
|
|
|
nsresult
|
|
BluetoothService::Observe(nsISupports* aSubject, const char* aTopic,
|
|
const PRUnichar* aData)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
if (!strcmp(aTopic, "profile-after-change")) {
|
|
return HandleStartup();
|
|
}
|
|
|
|
if (!strcmp(aTopic, MOZSETTINGS_CHANGED_ID)) {
|
|
return HandleSettingsChanged(nsDependentString(aData));
|
|
}
|
|
|
|
if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
|
|
return HandleShutdown();
|
|
}
|
|
|
|
MOZ_ASSERT(false, "BluetoothService got unexpected topic!");
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
bool
|
|
SetJsObject(JSContext* aContext,
|
|
JSObject* aObj,
|
|
const InfallibleTArray<BluetoothNamedValue>& aData)
|
|
{
|
|
for (int i = 0; i < aData.Length(); i++) {
|
|
jsval v;
|
|
if (aData[i].value().type() == BluetoothValue::TnsString) {
|
|
nsString data = aData[i].value().get_nsString();
|
|
JSString* JsData = JS_NewStringCopyN(aContext,
|
|
NS_ConvertUTF16toUTF8(data).get(),
|
|
data.Length());
|
|
NS_ENSURE_TRUE(JsData, NS_ERROR_OUT_OF_MEMORY);
|
|
v = STRING_TO_JSVAL(JsData);
|
|
} else if (aData[i].value().type() == BluetoothValue::Tuint32_t) {
|
|
int data = aData[i].value().get_uint32_t();
|
|
v = INT_TO_JSVAL(data);
|
|
} else {
|
|
NS_WARNING("SetJsObject: Parameter is not handled");
|
|
}
|
|
|
|
if (!JS_SetProperty(aContext, aObj,
|
|
NS_ConvertUTF16toUTF8(aData[i].name()).get(),
|
|
&v)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
BluetoothService::Notify(const BluetoothSignal& aData)
|
|
{
|
|
InfallibleTArray<BluetoothNamedValue> arr = aData.value().get_ArrayOfBluetoothNamedValue();
|
|
nsString type;
|
|
|
|
JSContext* cx = nsContentUtils::GetSafeJSContext();
|
|
NS_ASSERTION(!::JS_IsExceptionPending(cx),
|
|
"Shouldn't get here when an exception is pending!");
|
|
|
|
JSObject* obj = JS_NewObject(cx, NULL, NULL, NULL);
|
|
if (!obj) {
|
|
NS_WARNING("Failed to new JSObject for system message!");
|
|
return;
|
|
}
|
|
|
|
bool ok = SetJsObject(cx, obj, arr);
|
|
if (!ok) {
|
|
NS_WARNING("Failed to set properties of system message!");
|
|
return;
|
|
}
|
|
|
|
if (aData.name().EqualsLiteral("RequestConfirmation")) {
|
|
NS_ASSERTION(arr.Length() == 3, "RequestConfirmation: Wrong length of parameters");
|
|
type.AssignLiteral("bluetooth-requestconfirmation");
|
|
} else if (aData.name().EqualsLiteral("RequestPinCode")) {
|
|
NS_ASSERTION(arr.Length() == 2, "RequestPinCode: Wrong length of parameters");
|
|
type.AssignLiteral("bluetooth-requestpincode");
|
|
} else if (aData.name().EqualsLiteral("RequestPasskey")) {
|
|
NS_ASSERTION(arr.Length() == 2, "RequestPinCode: Wrong length of parameters");
|
|
type.AssignLiteral("bluetooth-requestpasskey");
|
|
} else if (aData.name().EqualsLiteral("Authorize")) {
|
|
NS_ASSERTION(arr.Length() == 2, "Authorize: Wrong length of parameters");
|
|
type.AssignLiteral("bluetooth-authorize");
|
|
} else if (aData.name().EqualsLiteral("Cancel")) {
|
|
NS_ASSERTION(arr.Length() == 0, "Cancel: Wrong length of parameters");
|
|
type.AssignLiteral("bluetooth-cancel");
|
|
} else {
|
|
#ifdef DEBUG
|
|
nsCString warningMsg;
|
|
warningMsg.AssignLiteral("Not handling service signal: ");
|
|
warningMsg.Append(NS_ConvertUTF16toUTF8(aData.name()));
|
|
NS_WARNING(warningMsg.get());
|
|
#endif
|
|
}
|
|
|
|
nsCOMPtr<nsISystemMessagesInternal> systemMessenger =
|
|
do_GetService("@mozilla.org/system-message-internal;1");
|
|
|
|
if (!systemMessenger) {
|
|
NS_WARNING("Failed to get SystemMessenger service!");
|
|
return;
|
|
}
|
|
systemMessenger->BroadcastMessage(type, OBJECT_TO_JSVAL(obj));
|
|
}
|