2011-10-06 02:15:45 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2011-09-30 11:00:48 +04:00
|
|
|
/* vim: set sw=2 ts=8 et ft=cpp : */
|
2012-02-10 14:04:44 +04:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
2012-02-02 10:09:00 +04:00
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
2012-02-10 14:04:44 +04:00
|
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2011-10-06 02:15:45 +04:00
|
|
|
|
|
|
|
#include "Hal.h"
|
2011-12-18 01:04:51 +04:00
|
|
|
#include "HalImpl.h"
|
|
|
|
#include "HalSandbox.h"
|
2011-10-06 02:15:45 +04:00
|
|
|
#include "mozilla/Util.h"
|
|
|
|
#include "nsThreadUtils.h"
|
|
|
|
#include "nsXULAppAPI.h"
|
2011-11-02 19:14:01 +04:00
|
|
|
#include "mozilla/Observer.h"
|
2011-09-30 11:00:48 +04:00
|
|
|
#include "nsIDOMDocument.h"
|
|
|
|
#include "nsIDOMWindow.h"
|
|
|
|
#include "mozilla/Services.h"
|
|
|
|
#include "nsIWebNavigation.h"
|
|
|
|
#include "nsITabChild.h"
|
|
|
|
#include "nsIDocShell.h"
|
2011-12-15 19:51:11 +04:00
|
|
|
#include "mozilla/ClearOnShutdown.h"
|
2011-12-18 01:04:26 +04:00
|
|
|
#include "WindowIdentifier.h"
|
2012-03-13 20:42:46 +04:00
|
|
|
#include "mozilla/dom/ScreenOrientation.h"
|
2011-09-30 11:00:48 +04:00
|
|
|
|
|
|
|
using namespace mozilla::services;
|
2011-10-06 02:15:45 +04:00
|
|
|
|
|
|
|
#define PROXY_IF_SANDBOXED(_call) \
|
|
|
|
do { \
|
|
|
|
if (InSandbox()) { \
|
|
|
|
hal_sandbox::_call; \
|
|
|
|
} else { \
|
|
|
|
hal_impl::_call; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2011-12-04 21:07:00 +04:00
|
|
|
#define RETURN_PROXY_IF_SANDBOXED(_call) \
|
|
|
|
do { \
|
|
|
|
if (InSandbox()) { \
|
|
|
|
return hal_sandbox::_call; \
|
|
|
|
} else { \
|
|
|
|
return hal_impl::_call; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2011-10-06 02:15:45 +04:00
|
|
|
namespace mozilla {
|
|
|
|
namespace hal {
|
|
|
|
|
2011-09-30 11:00:48 +04:00
|
|
|
PRLogModuleInfo *sHalLog = PR_LOG_DEFINE("hal");
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
void
|
2011-10-06 02:15:45 +04:00
|
|
|
AssertMainThread()
|
|
|
|
{
|
|
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
}
|
|
|
|
|
2011-09-30 11:00:48 +04:00
|
|
|
bool
|
2011-10-06 02:15:45 +04:00
|
|
|
InSandbox()
|
|
|
|
{
|
|
|
|
return GeckoProcessType_Content == XRE_GetProcessType();
|
|
|
|
}
|
|
|
|
|
2011-09-30 11:00:48 +04:00
|
|
|
bool
|
|
|
|
WindowIsActive(nsIDOMWindow *window)
|
|
|
|
{
|
|
|
|
NS_ENSURE_TRUE(window, false);
|
|
|
|
|
|
|
|
nsCOMPtr<nsIDOMDocument> doc;
|
|
|
|
window->GetDocument(getter_AddRefs(doc));
|
|
|
|
NS_ENSURE_TRUE(doc, false);
|
|
|
|
|
|
|
|
bool hidden = true;
|
|
|
|
doc->GetMozHidden(&hidden);
|
|
|
|
return !hidden;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoPtr<WindowIdentifier::IDArrayType> gLastIDToVibrate;
|
|
|
|
|
|
|
|
void InitLastIDToVibrate()
|
|
|
|
{
|
|
|
|
gLastIDToVibrate = new WindowIdentifier::IDArrayType();
|
2011-12-15 19:51:11 +04:00
|
|
|
ClearOnShutdown(&gLastIDToVibrate);
|
2011-09-30 11:00:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
2011-10-06 02:15:45 +04:00
|
|
|
void
|
2011-12-18 01:04:26 +04:00
|
|
|
Vibrate(const nsTArray<uint32>& pattern, nsIDOMWindow* window)
|
2011-09-30 11:00:48 +04:00
|
|
|
{
|
2011-12-18 01:04:26 +04:00
|
|
|
Vibrate(pattern, WindowIdentifier(window));
|
2011-09-30 11:00:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
Vibrate(const nsTArray<uint32>& pattern, const WindowIdentifier &id)
|
2011-10-06 02:15:45 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2011-09-30 11:00:48 +04:00
|
|
|
|
|
|
|
// Only active windows may start vibrations. If |id| hasn't gone
|
|
|
|
// through the IPC layer -- that is, if our caller is the outside
|
|
|
|
// world, not hal_proxy -- check whether the window is active. If
|
|
|
|
// |id| has gone through IPC, don't check the window's visibility;
|
|
|
|
// only the window corresponding to the bottommost process has its
|
|
|
|
// visibility state set correctly.
|
|
|
|
if (!id.HasTraveledThroughIPC() && !WindowIsActive(id.GetWindow())) {
|
|
|
|
HAL_LOG(("Vibrate: Window is inactive, dropping vibrate."));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (InSandbox()) {
|
|
|
|
hal_sandbox::Vibrate(pattern, id);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!gLastIDToVibrate)
|
|
|
|
InitLastIDToVibrate();
|
|
|
|
*gLastIDToVibrate = id.AsArray();
|
|
|
|
|
|
|
|
HAL_LOG(("Vibrate: Forwarding to hal_impl."));
|
|
|
|
|
|
|
|
// hal_impl doesn't need |id|. Send it an empty id, which will
|
|
|
|
// assert if it's used.
|
|
|
|
hal_impl::Vibrate(pattern, WindowIdentifier());
|
|
|
|
}
|
2011-10-06 02:15:45 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:04:26 +04:00
|
|
|
void
|
|
|
|
CancelVibrate(nsIDOMWindow* window)
|
|
|
|
{
|
|
|
|
CancelVibrate(WindowIdentifier(window));
|
|
|
|
}
|
|
|
|
|
2011-09-30 11:00:48 +04:00
|
|
|
void
|
|
|
|
CancelVibrate(const WindowIdentifier &id)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
|
|
|
|
// Although only active windows may start vibrations, a window may
|
|
|
|
// cancel its own vibration even if it's no longer active.
|
|
|
|
//
|
|
|
|
// After a window is marked as inactive, it sends a CancelVibrate
|
|
|
|
// request. We want this request to cancel a playing vibration
|
|
|
|
// started by that window, so we certainly don't want to reject the
|
|
|
|
// cancellation request because the window is now inactive.
|
|
|
|
//
|
|
|
|
// But it could be the case that, after this window became inactive,
|
|
|
|
// some other window came along and started a vibration. We don't
|
|
|
|
// want this window's cancellation request to cancel that window's
|
|
|
|
// actively-playing vibration!
|
|
|
|
//
|
|
|
|
// To solve this problem, we keep track of the id of the last window
|
|
|
|
// to start a vibration, and only accepts cancellation requests from
|
|
|
|
// the same window. All other cancellation requests are ignored.
|
|
|
|
|
|
|
|
if (InSandbox()) {
|
|
|
|
hal_sandbox::CancelVibrate(id);
|
|
|
|
}
|
|
|
|
else if (*gLastIDToVibrate == id.AsArray()) {
|
|
|
|
// Don't forward our ID to hal_impl. It doesn't need it, and we
|
|
|
|
// don't want it to be tempted to read it. The empty identifier
|
|
|
|
// will assert if it's used.
|
|
|
|
HAL_LOG(("CancelVibrate: Forwarding to hal_impl."));
|
|
|
|
hal_impl::CancelVibrate(WindowIdentifier());
|
|
|
|
}
|
|
|
|
}
|
2011-12-04 21:07:00 +04:00
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
template <class InfoType>
|
|
|
|
class ObserversManager
|
2011-11-02 19:14:01 +04:00
|
|
|
{
|
|
|
|
public:
|
2011-12-18 01:51:44 +04:00
|
|
|
void AddObserver(Observer<InfoType>* aObserver) {
|
2011-11-02 19:14:01 +04:00
|
|
|
if (!mObservers) {
|
2012-02-05 23:51:06 +04:00
|
|
|
mObservers = new mozilla::ObserverList<InfoType>();
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
mObservers->AddObserver(aObserver);
|
|
|
|
|
|
|
|
if (mObservers->Length() == 1) {
|
2011-12-18 01:51:44 +04:00
|
|
|
EnableNotifications();
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
void RemoveObserver(Observer<InfoType>* aObserver) {
|
2012-03-19 19:49:39 +04:00
|
|
|
// If mObservers is null, that means there are no observers.
|
|
|
|
// In addition, if RemoveObserver() returns false, that means we didn't
|
|
|
|
// find the observer.
|
|
|
|
// In both cases, that is a logical error we want to make sure the developer
|
|
|
|
// notices.
|
|
|
|
|
|
|
|
MOZ_ASSERT(mObservers);
|
|
|
|
|
|
|
|
#ifndef DEBUG
|
2012-03-14 22:18:26 +04:00
|
|
|
if (!mObservers) {
|
|
|
|
return;
|
|
|
|
}
|
2012-03-19 19:49:39 +04:00
|
|
|
#endif
|
2012-03-14 22:18:26 +04:00
|
|
|
|
2012-03-19 19:49:39 +04:00
|
|
|
DebugOnly<bool> removed = mObservers->RemoveObserver(aObserver);
|
|
|
|
MOZ_ASSERT(removed);
|
2011-11-02 19:14:01 +04:00
|
|
|
|
|
|
|
if (mObservers->Length() == 0) {
|
2011-12-18 01:51:44 +04:00
|
|
|
DisableNotifications();
|
2011-11-02 19:14:01 +04:00
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
OnNotificationsDisabled();
|
|
|
|
|
2011-11-02 19:14:01 +04:00
|
|
|
delete mObservers;
|
|
|
|
mObservers = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
void BroadcastInformation(const InfoType& aInfo) {
|
|
|
|
MOZ_ASSERT(mObservers);
|
|
|
|
mObservers->Broadcast(aInfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
virtual void EnableNotifications() = 0;
|
|
|
|
virtual void DisableNotifications() = 0;
|
|
|
|
virtual void OnNotificationsDisabled() {}
|
|
|
|
|
|
|
|
private:
|
|
|
|
mozilla::ObserverList<InfoType>* mObservers;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class InfoType>
|
|
|
|
class CachingObserversManager : public ObserversManager<InfoType>
|
|
|
|
{
|
|
|
|
public:
|
2011-12-18 01:51:44 +04:00
|
|
|
InfoType GetCurrentInformation() {
|
|
|
|
if (mHasValidCache) {
|
|
|
|
return mInfo;
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
GetCurrentInformationInternal(&mInfo);
|
|
|
|
return mInfo;
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
void CacheInformation(const InfoType& aInfo) {
|
|
|
|
mHasValidCache = true;
|
|
|
|
mInfo = aInfo;
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
void BroadcastCachedInformation() {
|
2012-03-07 19:44:05 +04:00
|
|
|
this->BroadcastInformation(mInfo);
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
protected:
|
|
|
|
virtual void GetCurrentInformationInternal(InfoType*) = 0;
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
virtual void OnNotificationsDisabled() {
|
|
|
|
mHasValidCache = false;
|
|
|
|
}
|
|
|
|
|
2011-11-02 19:14:01 +04:00
|
|
|
private:
|
2011-12-18 01:51:44 +04:00
|
|
|
InfoType mInfo;
|
|
|
|
bool mHasValidCache;
|
|
|
|
};
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
class BatteryObserversManager : public CachingObserversManager<BatteryInformation>
|
2011-12-18 01:51:44 +04:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
void EnableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(EnableBatteryNotifications());
|
|
|
|
}
|
|
|
|
|
|
|
|
void DisableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(DisableBatteryNotifications());
|
|
|
|
}
|
|
|
|
|
|
|
|
void GetCurrentInformationInternal(BatteryInformation* aInfo) {
|
|
|
|
PROXY_IF_SANDBOXED(GetCurrentBatteryInformation(aInfo));
|
|
|
|
}
|
2011-11-02 19:14:01 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
static BatteryObserversManager sBatteryObservers;
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
class NetworkObserversManager : public CachingObserversManager<NetworkInformation>
|
2012-01-16 17:39:57 +04:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
void EnableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(EnableNetworkNotifications());
|
|
|
|
}
|
|
|
|
|
|
|
|
void DisableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(DisableNetworkNotifications());
|
|
|
|
}
|
|
|
|
|
|
|
|
void GetCurrentInformationInternal(NetworkInformation* aInfo) {
|
|
|
|
PROXY_IF_SANDBOXED(GetCurrentNetworkInformation(aInfo));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static NetworkObserversManager sNetworkObservers;
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
class WakeLockObserversManager : public ObserversManager<WakeLockInformation>
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
void EnableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(EnableWakeLockNotifications());
|
|
|
|
}
|
|
|
|
|
|
|
|
void DisableNotifications() {
|
|
|
|
PROXY_IF_SANDBOXED(DisableWakeLockNotifications());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static WakeLockObserversManager sWakeLockObservers;
|
|
|
|
|
2012-05-09 01:36:07 +04:00
|
|
|
class ScreenConfigurationObserversManager : public CachingObserversManager<ScreenConfiguration>
|
2012-03-13 20:42:46 +04:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
void EnableNotifications() {
|
2012-05-09 01:36:07 +04:00
|
|
|
PROXY_IF_SANDBOXED(EnableScreenConfigurationNotifications());
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void DisableNotifications() {
|
2012-05-09 01:36:07 +04:00
|
|
|
PROXY_IF_SANDBOXED(DisableScreenConfigurationNotifications());
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
2012-05-09 01:36:07 +04:00
|
|
|
void GetCurrentInformationInternal(ScreenConfiguration* aInfo) {
|
|
|
|
PROXY_IF_SANDBOXED(GetCurrentScreenConfiguration(aInfo));
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-05-09 01:36:07 +04:00
|
|
|
static ScreenConfigurationObserversManager sScreenConfigurationObservers;
|
2012-03-13 20:42:46 +04:00
|
|
|
|
2011-11-02 19:14:01 +04:00
|
|
|
void
|
2011-12-18 01:51:44 +04:00
|
|
|
RegisterBatteryObserver(BatteryObserver* aObserver)
|
2011-11-02 19:14:01 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2011-12-18 01:51:44 +04:00
|
|
|
sBatteryObservers.AddObserver(aObserver);
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-12-18 01:51:44 +04:00
|
|
|
UnregisterBatteryObserver(BatteryObserver* aObserver)
|
2011-11-02 19:14:01 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2011-12-18 01:51:44 +04:00
|
|
|
sBatteryObservers.RemoveObserver(aObserver);
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-12-18 01:51:44 +04:00
|
|
|
GetCurrentBatteryInformation(BatteryInformation* aInfo)
|
2011-11-02 19:14:01 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2011-12-18 01:51:44 +04:00
|
|
|
*aInfo = sBatteryObservers.GetCurrentInformation();
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-18 01:51:44 +04:00
|
|
|
void
|
|
|
|
NotifyBatteryChange(const BatteryInformation& aInfo)
|
2011-11-02 19:14:01 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2011-12-18 01:51:44 +04:00
|
|
|
sBatteryObservers.CacheInformation(aInfo);
|
|
|
|
sBatteryObservers.BroadcastCachedInformation();
|
2011-11-02 19:14:01 +04:00
|
|
|
}
|
|
|
|
|
2011-12-04 21:07:00 +04:00
|
|
|
bool GetScreenEnabled()
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(GetScreenEnabled());
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetScreenEnabled(bool enabled)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(SetScreenEnabled(enabled));
|
|
|
|
}
|
|
|
|
|
2012-04-17 02:35:33 +04:00
|
|
|
bool GetCpuSleepAllowed()
|
|
|
|
{
|
|
|
|
// Generally for interfaces that are accessible by normal web content
|
|
|
|
// we should cache the result and be notified on state changes, like
|
|
|
|
// what the battery API does. But since this is only used by
|
|
|
|
// privileged interface, the synchronous getter is OK here.
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(GetCpuSleepAllowed());
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetCpuSleepAllowed(bool allowed)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(SetCpuSleepAllowed(allowed));
|
|
|
|
}
|
|
|
|
|
2011-12-04 21:07:00 +04:00
|
|
|
double GetScreenBrightness()
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(GetScreenBrightness());
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetScreenBrightness(double brightness)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(SetScreenBrightness(clamped(brightness, 0.0, 1.0)));
|
|
|
|
}
|
|
|
|
|
2012-02-02 10:09:00 +04:00
|
|
|
bool SetLight(LightType light, const hal::LightConfiguration& aConfig)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(SetLight(light, aConfig));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GetLight(LightType light, hal::LightConfiguration* aConfig)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(GetLight(light, aConfig));
|
|
|
|
}
|
|
|
|
|
2012-02-17 14:44:00 +04:00
|
|
|
|
|
|
|
void
|
|
|
|
AdjustSystemClock(int32_t aDeltaMilliseconds)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(AdjustSystemClock(aDeltaMilliseconds));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetTimezone(const nsCString& aTimezoneSpec)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(SetTimezone(aTimezoneSpec));
|
|
|
|
}
|
|
|
|
|
2012-02-05 23:51:06 +04:00
|
|
|
void
|
|
|
|
EnableSensorNotifications(SensorType aSensor) {
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(EnableSensorNotifications(aSensor));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableSensorNotifications(SensorType aSensor) {
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(DisableSensorNotifications(aSensor));
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef mozilla::ObserverList<SensorData> SensorObserverList;
|
2012-03-21 10:36:17 +04:00
|
|
|
static SensorObserverList* gSensorObservers = NULL;
|
2012-02-05 23:51:06 +04:00
|
|
|
|
|
|
|
static SensorObserverList &
|
|
|
|
GetSensorObservers(SensorType sensor_type) {
|
|
|
|
MOZ_ASSERT(sensor_type < NUM_SENSOR_TYPE);
|
|
|
|
|
|
|
|
if(gSensorObservers == NULL)
|
|
|
|
gSensorObservers = new SensorObserverList[NUM_SENSOR_TYPE];
|
|
|
|
return gSensorObservers[sensor_type];
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RegisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
|
|
|
|
SensorObserverList &observers = GetSensorObservers(aSensor);
|
|
|
|
|
|
|
|
AssertMainThread();
|
|
|
|
|
|
|
|
observers.AddObserver(aObserver);
|
|
|
|
if(observers.Length() == 1) {
|
|
|
|
EnableSensorNotifications(aSensor);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnregisterSensorObserver(SensorType aSensor, ISensorObserver *aObserver) {
|
|
|
|
SensorObserverList &observers = GetSensorObservers(aSensor);
|
|
|
|
|
|
|
|
AssertMainThread();
|
|
|
|
|
|
|
|
observers.RemoveObserver(aObserver);
|
|
|
|
if(observers.Length() == 0) {
|
|
|
|
DisableSensorNotifications(aSensor);
|
2012-03-21 10:36:17 +04:00
|
|
|
delete [] gSensorObservers;
|
|
|
|
gSensorObservers = nsnull;
|
2012-02-05 23:51:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NotifySensorChange(const SensorData &aSensorData) {
|
|
|
|
SensorObserverList &observers = GetSensorObservers(aSensorData.sensor());
|
|
|
|
|
|
|
|
AssertMainThread();
|
|
|
|
|
|
|
|
observers.Broadcast(aSensorData);
|
|
|
|
}
|
|
|
|
|
2012-01-16 17:39:57 +04:00
|
|
|
void
|
|
|
|
RegisterNetworkObserver(NetworkObserver* aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
sNetworkObservers.AddObserver(aObserver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnregisterNetworkObserver(NetworkObserver* aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
sNetworkObservers.RemoveObserver(aObserver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetCurrentNetworkInformation(NetworkInformation* aInfo)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
*aInfo = sNetworkObservers.GetCurrentInformation();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NotifyNetworkChange(const NetworkInformation& aInfo)
|
|
|
|
{
|
|
|
|
sNetworkObservers.CacheInformation(aInfo);
|
|
|
|
sNetworkObservers.BroadcastCachedInformation();
|
|
|
|
}
|
|
|
|
|
2012-01-31 10:08:00 +04:00
|
|
|
void Reboot()
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(Reboot());
|
|
|
|
}
|
|
|
|
|
|
|
|
void PowerOff()
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(PowerOff());
|
|
|
|
}
|
|
|
|
|
2012-03-07 15:03:25 +04:00
|
|
|
void
|
|
|
|
RegisterWakeLockObserver(WakeLockObserver* aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
sWakeLockObservers.AddObserver(aObserver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnregisterWakeLockObserver(WakeLockObserver* aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
sWakeLockObservers.RemoveObserver(aObserver);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ModifyWakeLock(const nsAString &aTopic,
|
|
|
|
hal::WakeLockControl aLockAdjust,
|
|
|
|
hal::WakeLockControl aHiddenAdjust)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetWakeLockInfo(const nsAString &aTopic, WakeLockInformation *aWakeLockInfo)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(GetWakeLockInfo(aTopic, aWakeLockInfo));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NotifyWakeLockChange(const WakeLockInformation& aInfo)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
sWakeLockObservers.BroadcastInformation(aInfo);
|
|
|
|
}
|
|
|
|
|
2012-03-13 20:42:46 +04:00
|
|
|
void
|
2012-05-09 01:36:07 +04:00
|
|
|
RegisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
|
2012-03-13 20:42:46 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2012-05-09 01:36:07 +04:00
|
|
|
sScreenConfigurationObservers.AddObserver(aObserver);
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-05-09 01:36:07 +04:00
|
|
|
UnregisterScreenConfigurationObserver(ScreenConfigurationObserver* aObserver)
|
2012-03-13 20:42:46 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2012-05-09 01:36:07 +04:00
|
|
|
sScreenConfigurationObservers.RemoveObserver(aObserver);
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-05-09 01:36:07 +04:00
|
|
|
GetCurrentScreenConfiguration(ScreenConfiguration* aScreenConfiguration)
|
2012-03-13 20:42:46 +04:00
|
|
|
{
|
|
|
|
AssertMainThread();
|
2012-05-09 01:36:07 +04:00
|
|
|
*aScreenConfiguration = sScreenConfigurationObservers.GetCurrentInformation();
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2012-05-09 01:36:07 +04:00
|
|
|
NotifyScreenConfigurationChange(const ScreenConfiguration& aScreenConfiguration)
|
2012-03-13 20:42:46 +04:00
|
|
|
{
|
2012-05-09 01:36:07 +04:00
|
|
|
sScreenConfigurationObservers.CacheInformation(aScreenConfiguration);
|
|
|
|
sScreenConfigurationObservers.BroadcastCachedInformation();
|
2012-03-13 20:42:46 +04:00
|
|
|
}
|
|
|
|
|
2012-03-29 23:43:16 +04:00
|
|
|
bool
|
|
|
|
LockScreenOrientation(const dom::ScreenOrientation& aOrientation)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(LockScreenOrientation(aOrientation));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnlockScreenOrientation()
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(UnlockScreenOrientation());
|
|
|
|
}
|
|
|
|
|
2012-04-22 22:09:22 +04:00
|
|
|
void
|
|
|
|
EnableSwitchNotifications(hal::SwitchDevice aDevice) {
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(EnableSwitchNotifications(aDevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableSwitchNotifications(hal::SwitchDevice aDevice) {
|
|
|
|
AssertMainThread();
|
|
|
|
PROXY_IF_SANDBOXED(DisableSwitchNotifications(aDevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
hal::SwitchState GetCurrentSwitchState(hal::SwitchDevice aDevice)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
RETURN_PROXY_IF_SANDBOXED(GetCurrentSwitchState(aDevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef mozilla::ObserverList<SwitchEvent> SwitchObserverList;
|
|
|
|
|
|
|
|
static SwitchObserverList *sSwitchObserverLists = NULL;
|
|
|
|
|
|
|
|
static SwitchObserverList&
|
|
|
|
GetSwitchObserverList(hal::SwitchDevice aDevice) {
|
|
|
|
MOZ_ASSERT(0 <= aDevice && aDevice < NUM_SWITCH_DEVICE);
|
|
|
|
if (sSwitchObserverLists == NULL) {
|
|
|
|
sSwitchObserverLists = new SwitchObserverList[NUM_SWITCH_DEVICE];
|
|
|
|
}
|
|
|
|
return sSwitchObserverLists[aDevice];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ReleaseObserversIfNeeded() {
|
|
|
|
for (int i = 0; i < NUM_SWITCH_DEVICE; i++) {
|
|
|
|
if (sSwitchObserverLists[i].Length() != 0)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
//The length of every list is 0, no observer in the list.
|
|
|
|
delete [] sSwitchObserverLists;
|
|
|
|
sSwitchObserverLists = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
RegisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
SwitchObserverList& observer = GetSwitchObserverList(aDevice);
|
|
|
|
observer.AddObserver(aObserver);
|
|
|
|
if (observer.Length() == 1) {
|
|
|
|
EnableSwitchNotifications(aDevice);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnregisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aObserver)
|
|
|
|
{
|
|
|
|
AssertMainThread();
|
|
|
|
SwitchObserverList& observer = GetSwitchObserverList(aDevice);
|
|
|
|
observer.RemoveObserver(aObserver);
|
|
|
|
if (observer.Length() == 0) {
|
|
|
|
DisableSwitchNotifications(aDevice);
|
|
|
|
ReleaseObserversIfNeeded();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
NotifySwitchChange(const hal::SwitchEvent& aEvent)
|
|
|
|
{
|
|
|
|
// When callback this notification, main thread may call unregister function
|
|
|
|
// first. We should check if this pointer is valid.
|
|
|
|
if (!sSwitchObserverLists)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SwitchObserverList& observer = GetSwitchObserverList(aEvent.device());
|
|
|
|
observer.Broadcast(aEvent);
|
|
|
|
}
|
|
|
|
|
2011-10-06 02:15:45 +04:00
|
|
|
} // namespace hal
|
|
|
|
} // namespace mozilla
|