summaryrefslogtreecommitdiffstats
path: root/hal/windows
diff options
context:
space:
mode:
Diffstat (limited to 'hal/windows')
-rw-r--r--hal/windows/WindowsBattery.cpp115
-rw-r--r--hal/windows/WindowsProcessPriority.cpp45
-rw-r--r--hal/windows/WindowsSensor.cpp170
3 files changed, 330 insertions, 0 deletions
diff --git a/hal/windows/WindowsBattery.cpp b/hal/windows/WindowsBattery.cpp
new file mode 100644
index 0000000000..fba786c8a2
--- /dev/null
+++ b/hal/windows/WindowsBattery.cpp
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "Hal.h"
+#include "HalImpl.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/battery/Constants.h"
+
+#include <windows.h>
+
+using namespace mozilla::dom::battery;
+
+namespace mozilla {
+namespace hal_impl {
+
+static HPOWERNOTIFY sPowerHandle = nullptr;
+static HPOWERNOTIFY sCapacityHandle = nullptr;
+static HWND sHWnd = nullptr;
+
+static LRESULT CALLBACK BatteryWindowProc(HWND hwnd, UINT msg, WPARAM wParam,
+ LPARAM lParam) {
+ if (msg != WM_POWERBROADCAST || wParam != PBT_POWERSETTINGCHANGE) {
+ return DefWindowProc(hwnd, msg, wParam, lParam);
+ }
+
+ hal::BatteryInformation currentInfo;
+
+ // Since we need update remainingTime, we cannot use LPARAM.
+ hal_impl::GetCurrentBatteryInformation(&currentInfo);
+
+ hal::NotifyBatteryChange(currentInfo);
+ return TRUE;
+}
+
+void EnableBatteryNotifications() {
+ // Create custom window to watch battery event
+ // If we can get Gecko's window handle, this is unnecessary.
+
+ if (sHWnd == nullptr) {
+ WNDCLASSW wc;
+ HMODULE hSelf = GetModuleHandle(nullptr);
+
+ if (!GetClassInfoW(hSelf, L"MozillaBatteryClass", &wc)) {
+ ZeroMemory(&wc, sizeof(WNDCLASSW));
+ wc.hInstance = hSelf;
+ wc.lpfnWndProc = BatteryWindowProc;
+ wc.lpszClassName = L"MozillaBatteryClass";
+ RegisterClassW(&wc);
+ }
+
+ sHWnd = CreateWindowW(L"MozillaBatteryClass", L"Battery Watcher", 0, 0, 0,
+ 0, 0, nullptr, nullptr, hSelf, nullptr);
+ }
+
+ if (sHWnd == nullptr) {
+ return;
+ }
+
+ sPowerHandle = RegisterPowerSettingNotification(
+ sHWnd, &GUID_ACDC_POWER_SOURCE, DEVICE_NOTIFY_WINDOW_HANDLE);
+ sCapacityHandle = RegisterPowerSettingNotification(
+ sHWnd, &GUID_BATTERY_PERCENTAGE_REMAINING, DEVICE_NOTIFY_WINDOW_HANDLE);
+}
+
+void DisableBatteryNotifications() {
+ if (sPowerHandle) {
+ UnregisterPowerSettingNotification(sPowerHandle);
+ sPowerHandle = nullptr;
+ }
+
+ if (sCapacityHandle) {
+ UnregisterPowerSettingNotification(sCapacityHandle);
+ sCapacityHandle = nullptr;
+ }
+
+ if (sHWnd) {
+ DestroyWindow(sHWnd);
+ sHWnd = nullptr;
+ }
+}
+
+void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo) {
+ SYSTEM_POWER_STATUS status;
+ if (!GetSystemPowerStatus(&status)) {
+ aBatteryInfo->level() = kDefaultLevel;
+ aBatteryInfo->charging() = kDefaultCharging;
+ aBatteryInfo->remainingTime() = kDefaultRemainingTime;
+ return;
+ }
+
+ aBatteryInfo->level() = status.BatteryLifePercent == 255
+ ? kDefaultLevel
+ : ((double)status.BatteryLifePercent) / 100.0;
+ aBatteryInfo->charging() = (status.ACLineStatus != 0);
+ if (status.ACLineStatus != 0) {
+ if (aBatteryInfo->level() == 1.0) {
+ // GetSystemPowerStatus API may returns -1 for BatteryFullLifeTime.
+ // So, if battery is 100%, set kDefaultRemainingTime at force.
+ aBatteryInfo->remainingTime() = kDefaultRemainingTime;
+ } else {
+ aBatteryInfo->remainingTime() = status.BatteryFullLifeTime == (DWORD)-1
+ ? kUnknownRemainingTime
+ : status.BatteryFullLifeTime;
+ }
+ } else {
+ aBatteryInfo->remainingTime() = status.BatteryLifeTime == (DWORD)-1
+ ? kUnknownRemainingTime
+ : status.BatteryLifeTime;
+ }
+}
+
+} // namespace hal_impl
+} // namespace mozilla
diff --git a/hal/windows/WindowsProcessPriority.cpp b/hal/windows/WindowsProcessPriority.cpp
new file mode 100644
index 0000000000..c660991278
--- /dev/null
+++ b/hal/windows/WindowsProcessPriority.cpp
@@ -0,0 +1,45 @@
+/* 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/. */
+
+#include "Hal.h"
+#include "HalLog.h"
+
+#include <windows.h>
+
+using namespace mozilla::hal;
+
+namespace mozilla {
+namespace hal_impl {
+
+bool SetProcessPrioritySupported() { return true; }
+
+void SetProcessPriority(int aPid, ProcessPriority aPriority) {
+ HAL_LOG("WindowsProcessPriority - SetProcessPriority(%d, %s)\n", aPid,
+ ProcessPriorityToString(aPriority));
+
+ nsAutoHandle processHandle(
+ ::OpenProcess(PROCESS_SET_INFORMATION, FALSE, aPid));
+#ifdef DEBUG
+ if (!processHandle) {
+ printf_stderr("::OpenProcess() failed with error %#08x\n",
+ ::GetLastError());
+ }
+#endif // DEBUG
+ MOZ_ASSERT(processHandle);
+ if (processHandle) {
+ DWORD priority = NORMAL_PRIORITY_CLASS;
+ if (aPriority == PROCESS_PRIORITY_BACKGROUND) {
+ priority = IDLE_PRIORITY_CLASS;
+ } else if (aPriority == PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) {
+ priority = BELOW_NORMAL_PRIORITY_CLASS;
+ }
+ ::SetPriorityClass(processHandle, priority);
+ }
+
+ HAL_LOG("WindowsProcessPriority - priority set to %d for pid %d\n", aPriority,
+ aPid);
+}
+
+} // namespace hal_impl
+} // namespace mozilla
diff --git a/hal/windows/WindowsSensor.cpp b/hal/windows/WindowsSensor.cpp
new file mode 100644
index 0000000000..73bd8bc57c
--- /dev/null
+++ b/hal/windows/WindowsSensor.cpp
@@ -0,0 +1,170 @@
+/* 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/. */
+
+#include "Hal.h"
+
+#include <sensorsapi.h>
+#include <sensors.h>
+#include <portabledevicetypes.h>
+
+#define MEAN_GRAVITY 9.80665
+#define DEFAULT_SENSOR_POLL 100
+
+using namespace mozilla::hal;
+
+namespace mozilla {
+namespace hal_impl {
+
+static RefPtr<ISensor> sAccelerometer;
+
+class SensorEvent final : public ISensorEvents {
+ public:
+ SensorEvent() : mCount(0) {}
+
+ // IUnknown interface
+
+ STDMETHODIMP_(ULONG) AddRef() { return InterlockedIncrement(&mCount); }
+
+ STDMETHODIMP_(ULONG) Release() {
+ ULONG count = InterlockedDecrement(&mCount);
+ if (!count) {
+ delete this;
+ return 0;
+ }
+ return count;
+ }
+
+ STDMETHODIMP QueryInterface(REFIID iid, void** ppv) {
+ if (iid == IID_IUnknown) {
+ *ppv = static_cast<IUnknown*>(this);
+ } else if (iid == IID_ISensorEvents) {
+ *ppv = static_cast<ISensorEvents*>(this);
+ } else {
+ return E_NOINTERFACE;
+ }
+ AddRef();
+ return S_OK;
+ }
+
+ // ISensorEvents interface
+
+ STDMETHODIMP OnEvent(ISensor* aSensor, REFGUID aId,
+ IPortableDeviceValues* aData) {
+ return S_OK;
+ }
+
+ STDMETHODIMP OnLeave(REFSENSOR_ID aId) { return S_OK; }
+
+ STDMETHODIMP OnStateChanged(ISensor* aSensor, SensorState state) {
+ return S_OK;
+ }
+
+ STDMETHODIMP OnDataUpdated(ISensor* aSensor, ISensorDataReport* aReport) {
+ PROPVARIANT v;
+ HRESULT hr;
+ nsTArray<float> values;
+
+ // X-axis acceleration in g's
+ hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_X_G, &v);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
+
+ // Y-axis acceleration in g's
+ hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, &v);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
+
+ // Z-axis acceleration in g's
+ hr = aReport->GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, &v);
+ if (FAILED(hr)) {
+ return hr;
+ }
+ values.AppendElement(float(-v.dblVal * MEAN_GRAVITY));
+
+ hal::SensorData sdata(hal::SENSOR_ACCELERATION, PR_Now(), values);
+ hal::NotifySensorChange(sdata);
+
+ return S_OK;
+ }
+
+ private:
+ ULONG mCount;
+};
+
+void EnableSensorNotifications(SensorType aSensor) {
+ if (aSensor != SENSOR_ACCELERATION) {
+ return;
+ }
+
+ if (sAccelerometer) {
+ return;
+ }
+
+ RefPtr<ISensorManager> manager;
+ if (FAILED(CoCreateInstance(CLSID_SensorManager, nullptr,
+ CLSCTX_INPROC_SERVER, IID_ISensorManager,
+ getter_AddRefs(manager)))) {
+ return;
+ }
+
+ // accelerometer event
+
+ RefPtr<ISensorCollection> collection;
+ if (FAILED(manager->GetSensorsByType(SENSOR_TYPE_ACCELEROMETER_3D,
+ getter_AddRefs(collection)))) {
+ return;
+ }
+
+ ULONG count = 0;
+ collection->GetCount(&count);
+ if (!count) {
+ return;
+ }
+
+ RefPtr<ISensor> sensor;
+ collection->GetAt(0, getter_AddRefs(sensor));
+ if (!sensor) {
+ return;
+ }
+
+ // Set report interval to 100ms if possible.
+ // Default value depends on drivers.
+ RefPtr<IPortableDeviceValues> values;
+ if (SUCCEEDED(CoCreateInstance(
+ CLSID_PortableDeviceValues, nullptr, CLSCTX_INPROC_SERVER,
+ IID_IPortableDeviceValues, getter_AddRefs(values)))) {
+ if (SUCCEEDED(values->SetUnsignedIntegerValue(
+ SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, DEFAULT_SENSOR_POLL))) {
+ RefPtr<IPortableDeviceValues> returns;
+ sensor->SetProperties(values, getter_AddRefs(returns));
+ }
+ }
+
+ RefPtr<SensorEvent> event = new SensorEvent();
+ RefPtr<ISensorEvents> sensorEvents;
+ if (FAILED(event->QueryInterface(IID_ISensorEvents,
+ getter_AddRefs(sensorEvents)))) {
+ return;
+ }
+
+ if (FAILED(sensor->SetEventSink(sensorEvents))) {
+ return;
+ }
+
+ sAccelerometer = sensor;
+}
+
+void DisableSensorNotifications(SensorType aSensor) {
+ if (aSensor == SENSOR_ACCELERATION && sAccelerometer) {
+ sAccelerometer->SetEventSink(nullptr);
+ sAccelerometer = nullptr;
+ }
+}
+
+} // namespace hal_impl
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 14:27:59 +0000