diff options
Diffstat (limited to 'hal/Hal.h')
| -rw-r--r-- | hal/Hal.h | 560 |
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 |