summaryrefslogtreecommitdiffstats
path: root/hal/Hal.h
diff options
context:
space:
mode:
Diffstat (limited to 'hal/Hal.h')
-rw-r--r--hal/Hal.h560
1 files changed, 560 insertions, 0 deletions
diff --git a/hal/Hal.h b/hal/Hal.h
new file mode 100644
index 000000000..e45bbcde2
--- /dev/null
+++ b/hal/Hal.h
@@ -0,0 +1,560 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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/. */
+
+#ifndef mozilla_Hal_h
+#define mozilla_Hal_h
+
+#include "base/basictypes.h"
+#include "base/platform_thread.h"
+#include "nsTArray.h"
+#include "mozilla/dom/battery/Types.h"
+#include "mozilla/dom/MozPowerManagerBinding.h"
+#include "mozilla/dom/network/Types.h"
+#include "mozilla/dom/power/Types.h"
+#include "mozilla/dom/ScreenOrientation.h"
+#include "mozilla/hal_sandbox/PHal.h"
+#include "mozilla/HalScreenConfiguration.h"
+#include "mozilla/HalTypes.h"
+#include "mozilla/Observer.h"
+#include "mozilla/Types.h"
+
+/*
+ * Hal.h contains the public Hal API.
+ *
+ * By default, this file defines its functions in the hal namespace, but if
+ * MOZ_HAL_NAMESPACE is defined, we'll define our functions in that namespace.
+ *
+ * This is used by HalImpl.h and HalSandbox.h, which define copies of all the
+ * functions here in the hal_impl and hal_sandbox namespaces.
+ */
+
+class nsPIDOMWindowInner;
+
+#ifndef MOZ_HAL_NAMESPACE
+# define MOZ_HAL_NAMESPACE hal
+# define MOZ_DEFINED_HAL_NAMESPACE 1
+#endif
+
+namespace mozilla {
+
+namespace hal {
+
+typedef Observer<void_t> AlarmObserver;
+
+class WindowIdentifier;
+
+typedef Observer<int64_t> SystemClockChangeObserver;
+typedef Observer<SystemTimezoneChangeInformation> SystemTimezoneChangeObserver;
+
+} // namespace hal
+
+namespace MOZ_HAL_NAMESPACE {
+
+/**
+ * Turn the default vibrator device on/off per the pattern specified
+ * by |pattern|. Each element in the pattern is the number of
+ * milliseconds to turn the vibrator on or off. The first element in
+ * |pattern| is an "on" element, the next is "off", and so on.
+ *
+ * If |pattern| is empty, any in-progress vibration is canceled.
+ *
+ * Only an active window within an active tab may call Vibrate; calls
+ * from inactive windows and windows on inactive tabs do nothing.
+ *
+ * If you're calling hal::Vibrate from the outside world, pass an
+ * nsIDOMWindow* in place of the WindowIdentifier parameter.
+ * The method with WindowIdentifier will be called automatically.
+ */
+void Vibrate(const nsTArray<uint32_t>& pattern,
+ nsPIDOMWindowInner* aWindow);
+void Vibrate(const nsTArray<uint32_t>& pattern,
+ const hal::WindowIdentifier &id);
+
+/**
+ * Cancel a vibration started by the content window identified by
+ * WindowIdentifier.
+ *
+ * If the window was the last window to start a vibration, the
+ * cancellation request will go through even if the window is not
+ * active.
+ *
+ * As with hal::Vibrate(), if you're calling hal::CancelVibrate from the outside
+ * world, pass an nsIDOMWindow*. The method with WindowIdentifier will be called
+ * automatically.
+ */
+void CancelVibrate(nsPIDOMWindowInner* aWindow);
+void CancelVibrate(const hal::WindowIdentifier &id);
+
+/**
+ * Inform the battery backend there is a new battery observer.
+ * @param aBatteryObserver The observer that should be added.
+ */
+void RegisterBatteryObserver(BatteryObserver* aBatteryObserver);
+
+/**
+ * Inform the battery backend a battery observer unregistered.
+ * @param aBatteryObserver The observer that should be removed.
+ */
+void UnregisterBatteryObserver(BatteryObserver* aBatteryObserver);
+
+/**
+ * Returns the current battery information.
+ */
+void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo);
+
+/**
+ * Notify of a change in the battery state.
+ * @param aBatteryInfo The new battery information.
+ */
+void NotifyBatteryChange(const hal::BatteryInformation& aBatteryInfo);
+
+/**
+ * Determine whether the device's screen is currently enabled.
+ */
+bool GetScreenEnabled();
+
+/**
+ * Enable or disable the device's screen.
+ *
+ * Note that it may take a few seconds for the screen to turn on or off.
+ */
+void SetScreenEnabled(bool aEnabled);
+
+/**
+ * Determine whether the device's keypad/button backlight is currently enabled.
+ */
+bool GetKeyLightEnabled();
+
+/**
+ * Enable or disable the device's keypad/button backlight.
+ */
+void SetKeyLightEnabled(bool aEnabled);
+
+/**
+ * Get the brightness of the device's screen's backlight, on a scale from 0
+ * (very dim) to 1 (full blast).
+ *
+ * If the display is currently disabled, this returns the brightness the
+ * backlight will have when the display is re-enabled.
+ */
+double GetScreenBrightness();
+
+/**
+ * Set the brightness of the device's screen's backlight, on a scale from 0
+ * (very dimm) to 1 (full blast). Values larger than 1 are treated like 1, and
+ * values smaller than 0 are treated like 0.
+ *
+ * Note that we may reduce the resolution of the given brightness value before
+ * sending it to the screen. Therefore if you call SetScreenBrightness(x)
+ * followed by GetScreenBrightness(), the value returned by
+ * GetScreenBrightness() may not be exactly x.
+ */
+void SetScreenBrightness(double aBrightness);
+
+/**
+ * Determine whether the device is allowed to sleep.
+ */
+bool GetCpuSleepAllowed();
+
+/**
+ * Set whether the device is allowed to suspend automatically after
+ * the screen is disabled.
+ */
+void SetCpuSleepAllowed(bool aAllowed);
+
+/**
+ * Register an observer for the sensor of given type.
+ *
+ * The observer will receive data whenever the data generated by the
+ * sensor is avaiable.
+ */
+void RegisterSensorObserver(hal::SensorType aSensor,
+ hal::ISensorObserver *aObserver);
+
+/**
+ * Unregister an observer for the sensor of given type.
+ */
+void UnregisterSensorObserver(hal::SensorType aSensor,
+ hal::ISensorObserver *aObserver);
+
+/**
+ * Post a value generated by a sensor.
+ *
+ * This API is internal to hal; clients shouldn't call it directly.
+ */
+void NotifySensorChange(const hal::SensorData &aSensorData);
+
+/**
+ * Enable sensor notifications from the backend
+ *
+ * This method is only visible from implementation of sensor manager.
+ * Rest of the system should not try this.
+ */
+void EnableSensorNotifications(hal::SensorType aSensor);
+
+/**
+ * Disable sensor notifications from the backend
+ *
+ * This method is only visible from implementation of sensor manager.
+ * Rest of the system should not try this.
+ */
+void DisableSensorNotifications(hal::SensorType aSensor);
+
+
+/**
+ * Inform the network backend there is a new network observer.
+ * @param aNetworkObserver The observer that should be added.
+ */
+void RegisterNetworkObserver(NetworkObserver* aNetworkObserver);
+
+/**
+ * Inform the network backend a network observer unregistered.
+ * @param aNetworkObserver The observer that should be removed.
+ */
+void UnregisterNetworkObserver(NetworkObserver* aNetworkObserver);
+
+/**
+ * Returns the current network information.
+ */
+void GetCurrentNetworkInformation(hal::NetworkInformation* aNetworkInfo);
+
+/**
+ * Notify of a change in the network state.
+ * @param aNetworkInfo The new network information.
+ */
+void NotifyNetworkChange(const hal::NetworkInformation& aNetworkInfo);
+
+/**
+ * Adjusting system clock.
+ * @param aDeltaMilliseconds The difference compared with current system clock.
+ */
+void AdjustSystemClock(int64_t aDeltaMilliseconds);
+
+/**
+ * Set timezone
+ * @param aTimezoneSpec The definition can be found in
+ * http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+ */
+void SetTimezone(const nsCString& aTimezoneSpec);
+
+/**
+ * Get timezone
+ * http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+ */
+nsCString GetTimezone();
+
+/**
+ * Get timezone offset
+ * returns the timezone offset relative to UTC in minutes (DST effect included)
+ */
+int32_t GetTimezoneOffset();
+
+/**
+ * Register observer for system clock changed notification.
+ * @param aObserver The observer that should be added.
+ */
+void RegisterSystemClockChangeObserver(
+ hal::SystemClockChangeObserver* aObserver);
+
+/**
+ * Unregister the observer for system clock changed.
+ * @param aObserver The observer that should be removed.
+ */
+void UnregisterSystemClockChangeObserver(
+ hal::SystemClockChangeObserver* aObserver);
+
+/**
+ * Notify of a change in the system clock.
+ * @param aClockDeltaMS
+ */
+void NotifySystemClockChange(const int64_t& aClockDeltaMS);
+
+/**
+ * Register observer for system timezone changed notification.
+ * @param aObserver The observer that should be added.
+ */
+void RegisterSystemTimezoneChangeObserver(
+ hal::SystemTimezoneChangeObserver* aObserver);
+
+/**
+ * Unregister the observer for system timezone changed.
+ * @param aObserver The observer that should be removed.
+ */
+void UnregisterSystemTimezoneChangeObserver(
+ hal::SystemTimezoneChangeObserver* aObserver);
+
+/**
+ * Notify of a change in the system timezone.
+ * @param aSystemTimezoneChangeInfo
+ */
+void NotifySystemTimezoneChange(
+ const hal::SystemTimezoneChangeInformation& aSystemTimezoneChangeInfo);
+
+/**
+ * Reboot the device.
+ *
+ * This API is currently only allowed to be used from the main process.
+ */
+void Reboot();
+
+/**
+ * Power off the device.
+ *
+ * This API is currently only allowed to be used from the main process.
+ */
+void PowerOff();
+
+/**
+ * Enable wake lock notifications from the backend.
+ *
+ * This method is only used by WakeLockObserversManager.
+ */
+void EnableWakeLockNotifications();
+
+/**
+ * Disable wake lock notifications from the backend.
+ *
+ * This method is only used by WakeLockObserversManager.
+ */
+void DisableWakeLockNotifications();
+
+/**
+ * Inform the wake lock backend there is a new wake lock observer.
+ * @param aWakeLockObserver The observer that should be added.
+ */
+void RegisterWakeLockObserver(WakeLockObserver* aObserver);
+
+/**
+ * Inform the wake lock backend a wake lock observer unregistered.
+ * @param aWakeLockObserver The observer that should be removed.
+ */
+void UnregisterWakeLockObserver(WakeLockObserver* aObserver);
+
+/**
+ * Adjust a wake lock's counts on behalf of a given process.
+ *
+ * In most cases, you shouldn't need to pass the aProcessID argument; the
+ * default of CONTENT_PROCESS_ID_UNKNOWN is probably what you want.
+ *
+ * @param aTopic lock topic
+ * @param aLockAdjust to increase or decrease active locks
+ * @param aHiddenAdjust to increase or decrease hidden locks
+ * @param aProcessID indicates which process we're modifying the wake lock
+ * on behalf of. It is interpreted as
+ *
+ * CONTENT_PROCESS_ID_UNKNOWN: The current process
+ * CONTENT_PROCESS_ID_MAIN: The root process
+ * X: The process with ContentChild::GetID() == X
+ */
+void ModifyWakeLock(const nsAString &aTopic,
+ hal::WakeLockControl aLockAdjust,
+ hal::WakeLockControl aHiddenAdjust,
+ uint64_t aProcessID = hal::CONTENT_PROCESS_ID_UNKNOWN);
+
+/**
+ * Query the wake lock numbers of aTopic.
+ * @param aTopic lock topic
+ * @param aWakeLockInfo wake lock numbers
+ */
+void GetWakeLockInfo(const nsAString &aTopic, hal::WakeLockInformation *aWakeLockInfo);
+
+/**
+ * Notify of a change in the wake lock state.
+ * @param aWakeLockInfo The new wake lock information.
+ */
+void NotifyWakeLockChange(const hal::WakeLockInformation& aWakeLockInfo);
+
+/**
+ * Inform the backend there is a new screen configuration observer.
+ * @param aScreenConfigurationObserver The observer that should be added.
+ */
+void RegisterScreenConfigurationObserver(hal::ScreenConfigurationObserver* aScreenConfigurationObserver);
+
+/**
+ * Inform the backend a screen configuration observer unregistered.
+ * @param aScreenConfigurationObserver The observer that should be removed.
+ */
+void UnregisterScreenConfigurationObserver(hal::ScreenConfigurationObserver* aScreenConfigurationObserver);
+
+/**
+ * Returns the current screen configuration.
+ */
+void GetCurrentScreenConfiguration(hal::ScreenConfiguration* aScreenConfiguration);
+
+/**
+ * Notify of a change in the screen configuration.
+ * @param aScreenConfiguration The new screen orientation.
+ */
+void NotifyScreenConfigurationChange(const hal::ScreenConfiguration& aScreenConfiguration);
+
+/**
+ * Lock the screen orientation to the specific orientation.
+ * @return Whether the lock has been accepted.
+ */
+MOZ_MUST_USE bool LockScreenOrientation(const dom::ScreenOrientationInternal& aOrientation);
+
+/**
+ * Unlock the screen orientation.
+ */
+void UnlockScreenOrientation();
+
+/**
+ * Register an observer for the switch of given SwitchDevice.
+ *
+ * The observer will receive data whenever the data generated by the
+ * given switch.
+ */
+void RegisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aSwitchObserver);
+
+/**
+ * Unregister an observer for the switch of given SwitchDevice.
+ */
+void UnregisterSwitchObserver(hal::SwitchDevice aDevice, hal::SwitchObserver *aSwitchObserver);
+
+/**
+ * Notify the state of the switch.
+ *
+ * This API is internal to hal; clients shouldn't call it directly.
+ */
+void NotifySwitchChange(const hal::SwitchEvent& aEvent);
+
+/**
+ * Get current switch information.
+ */
+hal::SwitchState GetCurrentSwitchState(hal::SwitchDevice aDevice);
+
+/**
+ * Notify switch status change from input device.
+ */
+void NotifySwitchStateFromInputDevice(hal::SwitchDevice aDevice,
+ hal::SwitchState aState);
+
+/**
+ * Register an observer that is notified when a programmed alarm
+ * expires.
+ *
+ * Currently, there can only be 0 or 1 alarm observers.
+ */
+MOZ_MUST_USE bool RegisterTheOneAlarmObserver(hal::AlarmObserver* aObserver);
+
+/**
+ * Unregister the alarm observer. Doing so will implicitly cancel any
+ * programmed alarm.
+ */
+void UnregisterTheOneAlarmObserver();
+
+/**
+ * Notify that the programmed alarm has expired.
+ *
+ * This API is internal to hal; clients shouldn't call it directly.
+ */
+void NotifyAlarmFired();
+
+/**
+ * Program the real-time clock to expire at the time |aSeconds|,
+ * |aNanoseconds|. These specify a point in real time relative to the
+ * UNIX epoch. The alarm will fire at this time point even if the
+ * real-time clock is changed; that is, this alarm respects changes to
+ * the real-time clock. Return true iff the alarm was programmed.
+ *
+ * The alarm can be reprogrammed at any time.
+ *
+ * This API is currently only allowed to be used from non-sandboxed
+ * contexts.
+ */
+MOZ_MUST_USE bool SetAlarm(int32_t aSeconds, int32_t aNanoseconds);
+
+/**
+ * Set the priority of the given process.
+ *
+ * Exactly what this does will vary between platforms. On *nix we might give
+ * background processes higher nice values. On other platforms, we might
+ * ignore this call entirely.
+ */
+void SetProcessPriority(int aPid,
+ hal::ProcessPriority aPriority,
+ uint32_t aLRU = 0);
+
+
+/**
+ * Set the current thread's priority to appropriate platform-specific value for
+ * given functionality. Instead of providing arbitrary priority numbers you
+ * must specify a type of function like THREAD_PRIORITY_COMPOSITOR.
+ */
+void SetCurrentThreadPriority(hal::ThreadPriority aThreadPriority);
+
+/**
+ * Set a thread priority to appropriate platform-specific value for
+ * given functionality. Instead of providing arbitrary priority numbers you
+ * must specify a type of function like THREAD_PRIORITY_COMPOSITOR.
+ */
+void SetThreadPriority(PlatformThreadId aThreadId,
+ hal::ThreadPriority aThreadPriority);
+
+/**
+ * Start a watchdog to compulsively shutdown the system if it hangs.
+ * @param aMode Specify how to shutdown the system.
+ * @param aTimeoutSecs Specify the delayed seconds to shutdown the system.
+ *
+ * This API is currently only allowed to be used from the main process.
+ */
+void StartForceQuitWatchdog(hal::ShutdownMode aMode, int32_t aTimeoutSecs);
+
+/**
+ * Perform Factory Reset to wipe out all user data.
+ */
+void FactoryReset(mozilla::dom::FactoryResetReason& aReason);
+
+/**
+ * Start monitoring disk space for low space situations.
+ *
+ * This API is currently only allowed to be used from the main process.
+ */
+void StartDiskSpaceWatcher();
+
+/**
+ * Stop monitoring disk space for low space situations.
+ *
+ * This API is currently only allowed to be used from the main process.
+ */
+void StopDiskSpaceWatcher();
+
+/**
+ * Get total system memory of device being run on in bytes.
+ *
+ * Returns 0 if we are unable to determine this information from /proc/meminfo.
+ */
+uint32_t GetTotalSystemMemory();
+
+/**
+ * Determine whether the headphone switch event is from input device
+ */
+bool IsHeadphoneEventFromInputDev();
+
+/**
+ * Start the system service with the specified name and arguments.
+ */
+nsresult StartSystemService(const char* aSvcName, const char* aArgs);
+
+/**
+ * Stop the system service with the specified name.
+ */
+void StopSystemService(const char* aSvcName);
+
+/**
+ * Determine whether the system service with the specified name is running.
+ */
+bool SystemServiceIsRunning(const char* aSvcName);
+
+} // namespace MOZ_HAL_NAMESPACE
+} // namespace mozilla
+
+#ifdef MOZ_DEFINED_HAL_NAMESPACE
+# undef MOZ_DEFINED_HAL_NAMESPACE
+# undef MOZ_HAL_NAMESPACE
+#endif
+
+#endif // mozilla_Hal_h