2011-10-05 15:15:45 -07:00
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2011-10-20 14:38:39 -07:00
|
|
|
/* vim: set sw=2 ts=8 et ft=cpp : */
|
2012-02-10 02:04:44 -08:00
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
2012-02-01 22:09:00 -08:00
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
2012-02-10 02:04:44 -08:00
|
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
2011-10-05 15:15:45 -07:00
|
|
|
|
|
|
|
#include "Hal.h"
|
|
|
|
#include "mozilla/dom/ContentChild.h"
|
|
|
|
#include "mozilla/hal_sandbox/PHalChild.h"
|
|
|
|
#include "mozilla/hal_sandbox/PHalParent.h"
|
2011-09-30 00:00:48 -07:00
|
|
|
#include "mozilla/dom/TabParent.h"
|
|
|
|
#include "mozilla/dom/TabChild.h"
|
2011-11-02 08:14:01 -07:00
|
|
|
#include "mozilla/dom/battery/Types.h"
|
2012-01-16 05:39:57 -08:00
|
|
|
#include "mozilla/dom/network/Types.h"
|
2012-03-13 09:42:46 -07:00
|
|
|
#include "mozilla/dom/ScreenOrientation.h"
|
2011-11-02 08:14:01 -07:00
|
|
|
#include "mozilla/Observer.h"
|
|
|
|
#include "mozilla/unused.h"
|
2011-12-17 13:04:26 -08:00
|
|
|
#include "WindowIdentifier.h"
|
2011-10-05 15:15:45 -07:00
|
|
|
|
|
|
|
using namespace mozilla;
|
|
|
|
using namespace mozilla::dom;
|
|
|
|
using namespace mozilla::hal;
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
namespace hal_sandbox {
|
|
|
|
|
|
|
|
static PHalChild* sHal;
|
|
|
|
static PHalChild*
|
|
|
|
Hal()
|
|
|
|
{
|
|
|
|
if (!sHal) {
|
|
|
|
sHal = ContentChild::GetSingleton()->SendPHalConstructor();
|
|
|
|
}
|
|
|
|
return sHal;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2011-09-30 00:00:48 -07:00
|
|
|
Vibrate(const nsTArray<uint32>& pattern, const WindowIdentifier &id)
|
2011-10-05 15:15:45 -07:00
|
|
|
{
|
2011-09-30 00:00:48 -07:00
|
|
|
HAL_LOG(("Vibrate: Sending to parent process."));
|
|
|
|
|
2011-10-05 15:15:45 -07:00
|
|
|
AutoInfallibleTArray<uint32, 8> p(pattern);
|
2011-09-30 00:00:48 -07:00
|
|
|
|
|
|
|
WindowIdentifier newID(id);
|
|
|
|
newID.AppendProcessID();
|
|
|
|
Hal()->SendVibrate(p, newID.AsArray(), GetTabChildFrom(newID.GetWindow()));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
CancelVibrate(const WindowIdentifier &id)
|
|
|
|
{
|
|
|
|
HAL_LOG(("CancelVibrate: Sending to parent process."));
|
|
|
|
|
|
|
|
WindowIdentifier newID(id);
|
|
|
|
newID.AppendProcessID();
|
|
|
|
Hal()->SendCancelVibrate(newID.AsArray(), GetTabChildFrom(newID.GetWindow()));
|
2011-10-05 15:15:45 -07:00
|
|
|
}
|
|
|
|
|
2011-11-02 08:14:01 -07:00
|
|
|
void
|
|
|
|
EnableBatteryNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendEnableBatteryNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableBatteryNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendDisableBatteryNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetCurrentBatteryInformation(BatteryInformation* aBatteryInfo)
|
|
|
|
{
|
|
|
|
Hal()->SendGetCurrentBatteryInformation(aBatteryInfo);
|
|
|
|
}
|
|
|
|
|
2012-01-16 05:39:57 -08:00
|
|
|
void
|
|
|
|
EnableNetworkNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendEnableNetworkNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableNetworkNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendDisableNetworkNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetCurrentNetworkInformation(NetworkInformation* aNetworkInfo)
|
|
|
|
{
|
|
|
|
Hal()->SendGetCurrentNetworkInformation(aNetworkInfo);
|
|
|
|
}
|
|
|
|
|
2012-03-13 09:42:46 -07:00
|
|
|
void
|
|
|
|
EnableScreenOrientationNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendEnableScreenOrientationNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableScreenOrientationNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendDisableScreenOrientationNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetCurrentScreenOrientation(ScreenOrientation* aScreenOrientation)
|
|
|
|
{
|
|
|
|
Hal()->SendGetCurrentScreenOrientation(aScreenOrientation);
|
|
|
|
}
|
|
|
|
|
2012-03-29 12:43:16 -07:00
|
|
|
bool
|
|
|
|
LockScreenOrientation(const dom::ScreenOrientation& aOrientation)
|
|
|
|
{
|
|
|
|
bool allowed;
|
|
|
|
Hal()->SendLockScreenOrientation(aOrientation, &allowed);
|
|
|
|
return allowed;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
UnlockScreenOrientation()
|
|
|
|
{
|
|
|
|
Hal()->SendUnlockScreenOrientation();
|
|
|
|
}
|
|
|
|
|
2011-12-04 09:07:00 -08:00
|
|
|
bool
|
|
|
|
GetScreenEnabled()
|
|
|
|
{
|
|
|
|
bool enabled = false;
|
|
|
|
Hal()->SendGetScreenEnabled(&enabled);
|
|
|
|
return enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetScreenEnabled(bool enabled)
|
|
|
|
{
|
|
|
|
Hal()->SendSetScreenEnabled(enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
GetScreenBrightness()
|
|
|
|
{
|
|
|
|
double brightness = 0;
|
|
|
|
Hal()->SendGetScreenBrightness(&brightness);
|
|
|
|
return brightness;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetScreenBrightness(double brightness)
|
|
|
|
{
|
|
|
|
Hal()->SendSetScreenBrightness(brightness);
|
|
|
|
}
|
|
|
|
|
2012-02-01 22:09:00 -08:00
|
|
|
bool
|
|
|
|
SetLight(hal::LightType light, const hal::LightConfiguration& aConfig)
|
|
|
|
{
|
|
|
|
bool status;
|
|
|
|
Hal()->SendSetLight(light, aConfig, &status);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
GetLight(hal::LightType light, hal::LightConfiguration* aConfig)
|
|
|
|
{
|
|
|
|
bool status;
|
|
|
|
Hal()->SendGetLight(light, aConfig, &status);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-02-17 02:44:00 -08:00
|
|
|
void
|
|
|
|
AdjustSystemClock(int32_t aDeltaMilliseconds)
|
|
|
|
{
|
|
|
|
Hal()->SendAdjustSystemClock(aDeltaMilliseconds);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
SetTimezone(const nsCString& aTimezoneSpec)
|
|
|
|
{
|
|
|
|
Hal()->SendSetTimezone(nsCString(aTimezoneSpec));
|
|
|
|
}
|
|
|
|
|
2012-01-30 22:08:00 -08:00
|
|
|
void
|
|
|
|
Reboot()
|
|
|
|
{
|
|
|
|
Hal()->SendReboot();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
PowerOff()
|
|
|
|
{
|
|
|
|
Hal()->SendPowerOff();
|
|
|
|
}
|
|
|
|
|
2012-02-05 11:51:06 -08:00
|
|
|
void
|
|
|
|
EnableSensorNotifications(SensorType aSensor) {
|
|
|
|
Hal()->SendEnableSensorNotifications(aSensor);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableSensorNotifications(SensorType aSensor) {
|
|
|
|
Hal()->SendDisableSensorNotifications(aSensor);
|
|
|
|
}
|
|
|
|
|
2012-03-07 03:03:25 -08:00
|
|
|
void
|
|
|
|
EnableWakeLockNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendEnableWakeLockNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
DisableWakeLockNotifications()
|
|
|
|
{
|
|
|
|
Hal()->SendDisableWakeLockNotifications();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ModifyWakeLock(const nsAString &aTopic, WakeLockControl aLockAdjust, WakeLockControl aHiddenAdjust)
|
|
|
|
{
|
|
|
|
Hal()->SendModifyWakeLock(nsString(aTopic), aLockAdjust, aHiddenAdjust);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
GetWakeLockInfo(const nsAString &aTopic, WakeLockInformation *aWakeLockInfo)
|
|
|
|
{
|
|
|
|
Hal()->SendGetWakeLockInfo(nsString(aTopic), aWakeLockInfo);
|
|
|
|
}
|
|
|
|
|
2011-11-02 08:14:01 -07:00
|
|
|
class HalParent : public PHalParent
|
2012-01-16 05:39:57 -08:00
|
|
|
, public BatteryObserver
|
|
|
|
, public NetworkObserver
|
2012-02-05 11:51:06 -08:00
|
|
|
, public ISensorObserver
|
2012-03-07 03:03:25 -08:00
|
|
|
, public WakeLockObserver
|
2012-03-13 09:42:46 -07:00
|
|
|
, public ScreenOrientationObserver
|
2012-01-16 05:39:57 -08:00
|
|
|
{
|
2011-10-05 15:15:45 -07:00
|
|
|
public:
|
|
|
|
NS_OVERRIDE virtual bool
|
2011-09-30 00:00:48 -07:00
|
|
|
RecvVibrate(const InfallibleTArray<unsigned int>& pattern,
|
|
|
|
const InfallibleTArray<uint64> &id,
|
|
|
|
PBrowserParent *browserParent)
|
|
|
|
{
|
|
|
|
// Check whether browserParent is active. We should have already
|
|
|
|
// checked that the corresponding window is active, but this check
|
|
|
|
// isn't redundant. A window may be inactive in an active
|
|
|
|
// browser. And a window is not notified synchronously when it's
|
|
|
|
// deactivated, so the window may think it's active when the tab
|
|
|
|
// is actually inactive.
|
|
|
|
TabParent *tabParent = static_cast<TabParent*>(browserParent);
|
|
|
|
if (!tabParent->Active()) {
|
|
|
|
HAL_LOG(("RecvVibrate: Tab is not active. Cancelling."));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-05 15:15:45 -07:00
|
|
|
// Forward to hal::, not hal_impl::, because we might be a
|
|
|
|
// subprocess of another sandboxed process. The hal:: entry point
|
|
|
|
// will do the right thing.
|
2011-09-30 00:00:48 -07:00
|
|
|
nsCOMPtr<nsIDOMWindow> window =
|
|
|
|
do_QueryInterface(tabParent->GetBrowserDOMWindow());
|
|
|
|
WindowIdentifier newID(id, window);
|
|
|
|
hal::Vibrate(pattern, newID);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvCancelVibrate(const InfallibleTArray<uint64> &id,
|
|
|
|
PBrowserParent *browserParent)
|
|
|
|
{
|
|
|
|
TabParent *tabParent = static_cast<TabParent*>(browserParent);
|
|
|
|
nsCOMPtr<nsIDOMWindow> window =
|
|
|
|
do_QueryInterface(tabParent->GetBrowserDOMWindow());
|
|
|
|
WindowIdentifier newID(id, window);
|
|
|
|
hal::CancelVibrate(newID);
|
2011-10-05 15:15:45 -07:00
|
|
|
return true;
|
|
|
|
}
|
2011-11-02 08:14:01 -07:00
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvEnableBatteryNotifications() {
|
|
|
|
hal::RegisterBatteryObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvDisableBatteryNotifications() {
|
|
|
|
hal::UnregisterBatteryObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetCurrentBatteryInformation(BatteryInformation* aBatteryInfo) {
|
|
|
|
hal::GetCurrentBatteryInformation(aBatteryInfo);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Notify(const BatteryInformation& aBatteryInfo) {
|
|
|
|
unused << SendNotifyBatteryChange(aBatteryInfo);
|
|
|
|
}
|
2011-12-04 09:07:00 -08:00
|
|
|
|
2012-01-16 05:39:57 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvEnableNetworkNotifications() {
|
|
|
|
hal::RegisterNetworkObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvDisableNetworkNotifications() {
|
|
|
|
hal::UnregisterNetworkObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetCurrentNetworkInformation(NetworkInformation* aNetworkInfo) {
|
|
|
|
hal::GetCurrentNetworkInformation(aNetworkInfo);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Notify(const NetworkInformation& aNetworkInfo) {
|
|
|
|
unused << SendNotifyNetworkChange(aNetworkInfo);
|
|
|
|
}
|
|
|
|
|
2012-03-13 09:42:46 -07:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvEnableScreenOrientationNotifications() {
|
|
|
|
hal::RegisterScreenOrientationObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvDisableScreenOrientationNotifications() {
|
|
|
|
hal::UnregisterScreenOrientationObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetCurrentScreenOrientation(ScreenOrientation* aScreenOrientation) {
|
|
|
|
hal::GetCurrentScreenOrientation(aScreenOrientation);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-29 12:43:16 -07:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvLockScreenOrientation(const dom::ScreenOrientation& aOrientation, bool* aAllowed)
|
|
|
|
{
|
|
|
|
*aAllowed = hal::LockScreenOrientation(aOrientation);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvUnlockScreenOrientation()
|
|
|
|
{
|
|
|
|
hal::UnlockScreenOrientation();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-03-13 09:42:46 -07:00
|
|
|
void Notify(const ScreenOrientationWrapper& aScreenOrientation) {
|
|
|
|
unused << SendNotifyScreenOrientationChange(aScreenOrientation.orientation);
|
|
|
|
}
|
|
|
|
|
2011-12-04 09:07:00 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetScreenEnabled(bool *enabled)
|
|
|
|
{
|
|
|
|
*enabled = hal::GetScreenEnabled();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvSetScreenEnabled(const bool &enabled)
|
|
|
|
{
|
|
|
|
hal::SetScreenEnabled(enabled);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetScreenBrightness(double *brightness)
|
|
|
|
{
|
|
|
|
*brightness = hal::GetScreenBrightness();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvSetScreenBrightness(const double &brightness)
|
|
|
|
{
|
|
|
|
hal::SetScreenBrightness(brightness);
|
|
|
|
return true;
|
|
|
|
}
|
2012-01-30 22:08:00 -08:00
|
|
|
|
2012-02-01 22:09:00 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvSetLight(const LightType& aLight, const hal::LightConfiguration& aConfig, bool *status)
|
|
|
|
{
|
|
|
|
*status = hal::SetLight(aLight, aConfig);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetLight(const LightType& aLight, LightConfiguration* aConfig, bool* status)
|
|
|
|
{
|
|
|
|
*status = hal::GetLight(aLight, aConfig);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-02-17 02:44:00 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvAdjustSystemClock(const int32_t &aDeltaMilliseconds)
|
|
|
|
{
|
|
|
|
hal::AdjustSystemClock(aDeltaMilliseconds);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvSetTimezone(const nsCString& aTimezoneSpec)
|
|
|
|
{
|
|
|
|
hal::SetTimezone(aTimezoneSpec);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-01-30 22:08:00 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvReboot()
|
|
|
|
{
|
|
|
|
hal::Reboot();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvPowerOff()
|
|
|
|
{
|
|
|
|
hal::PowerOff();
|
|
|
|
return true;
|
|
|
|
}
|
2012-02-05 11:51:06 -08:00
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvEnableSensorNotifications(const SensorType &aSensor) {
|
|
|
|
hal::RegisterSensorObserver(aSensor, this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvDisableSensorNotifications(const SensorType &aSensor) {
|
|
|
|
hal::UnregisterSensorObserver(aSensor, this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Notify(const SensorData& aSensorData) {
|
|
|
|
unused << SendNotifySensorChange(aSensorData);
|
|
|
|
}
|
2012-03-07 03:03:25 -08:00
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvModifyWakeLock(const nsString &aTopic,
|
|
|
|
const WakeLockControl &aLockAdjust,
|
|
|
|
const WakeLockControl &aHiddenAdjust)
|
|
|
|
{
|
|
|
|
hal::ModifyWakeLock(aTopic, aLockAdjust, aHiddenAdjust);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvEnableWakeLockNotifications()
|
|
|
|
{
|
|
|
|
hal::RegisterWakeLockObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvDisableWakeLockNotifications()
|
|
|
|
{
|
|
|
|
hal::UnregisterWakeLockObserver(this);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvGetWakeLockInfo(const nsString &aTopic, WakeLockInformation *aWakeLockInfo)
|
|
|
|
{
|
|
|
|
hal::GetWakeLockInfo(aTopic, aWakeLockInfo);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Notify(const WakeLockInformation& aWakeLockInfo)
|
|
|
|
{
|
|
|
|
unused << SendNotifyWakeLockChange(aWakeLockInfo);
|
|
|
|
}
|
2011-10-05 15:15:45 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
class HalChild : public PHalChild {
|
|
|
|
public:
|
2011-11-02 08:14:01 -07:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvNotifyBatteryChange(const BatteryInformation& aBatteryInfo) {
|
|
|
|
hal::NotifyBatteryChange(aBatteryInfo);
|
|
|
|
return true;
|
|
|
|
}
|
2012-01-16 05:39:57 -08:00
|
|
|
|
2012-02-05 11:51:06 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvNotifySensorChange(const hal::SensorData &aSensorData);
|
|
|
|
|
2012-01-16 05:39:57 -08:00
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvNotifyNetworkChange(const NetworkInformation& aNetworkInfo) {
|
|
|
|
hal::NotifyNetworkChange(aNetworkInfo);
|
|
|
|
return true;
|
|
|
|
}
|
2012-03-07 03:03:25 -08:00
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvNotifyWakeLockChange(const WakeLockInformation& aWakeLockInfo) {
|
|
|
|
hal::NotifyWakeLockChange(aWakeLockInfo);
|
|
|
|
return true;
|
|
|
|
}
|
2012-03-13 09:42:46 -07:00
|
|
|
|
|
|
|
NS_OVERRIDE virtual bool
|
|
|
|
RecvNotifyScreenOrientationChange(const ScreenOrientation& aScreenOrientation) {
|
|
|
|
hal::NotifyScreenOrientationChange(aScreenOrientation);
|
|
|
|
return true;
|
|
|
|
}
|
2011-10-05 15:15:45 -07:00
|
|
|
};
|
|
|
|
|
2012-02-05 11:51:06 -08:00
|
|
|
bool
|
|
|
|
HalChild::RecvNotifySensorChange(const hal::SensorData &aSensorData) {
|
|
|
|
hal::NotifySensorChange(aSensorData);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-05 15:15:45 -07:00
|
|
|
PHalChild* CreateHalChild() {
|
|
|
|
return new HalChild();
|
|
|
|
}
|
|
|
|
|
|
|
|
PHalParent* CreateHalParent() {
|
|
|
|
return new HalParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace hal_sandbox
|
|
|
|
} // namespace mozilla
|