/* -*- 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/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/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 { class WindowIdentifier; typedef Observer SystemClockChangeObserver; typedef Observer 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& pattern, nsPIDOMWindowInner* aWindow); void Vibrate(const nsTArray& 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); /** * 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); /** * 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); /** * 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(); /** * Return true if the current platform supports the setting of process * priority. */ bool SetProcessPrioritySupported(); /** * 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); /** * 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 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(); } // 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