hal/android/AndroidHal.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "Hal.h"
   7 #include "HalImpl.h"
   8 #include "WindowIdentifier.h"
   9 #include "AndroidBridge.h"
  10 #include "mozilla/dom/network/Constants.h"
  11 #include "mozilla/java/GeckoAppShellWrappers.h"
  12 #include "mozilla/java/GeckoRuntimeWrappers.h"
  13 #include "mozilla/widget/ScreenManager.h"
  14 #include "nsPIDOMWindow.h"
  15
  16 using namespace mozilla::dom;
  17 using namespace mozilla::hal;
  18
  19 namespace mozilla::hal_impl {
  20
  21 void Vibrate(const nsTArray<uint32_t>& pattern, WindowIdentifier&&) {
  22   // Ignore the WindowIdentifier parameter; it's here only because hal::Vibrate,
  23   // hal_sandbox::Vibrate, and hal_impl::Vibrate all must have the same
  24   // signature.
  25
  26   // Strangely enough, the Android Java API seems to treat vibrate([0]) as a
  27   // nop.  But we want to treat vibrate([0]) like CancelVibrate!  (Note that we
  28   // also need to treat vibrate([]) as a call to CancelVibrate.)
  29   bool allZero = true;
  30   for (uint32_t i = 0; i < pattern.Length(); i++) {
  31     if (pattern[i] != 0) {
  32       allZero = false;
  33       break;
  34     }
  35   }
  36
  37   if (allZero) {
  38     hal_impl::CancelVibrate(WindowIdentifier());
  39     return;
  40   }
  41
  42   AndroidBridge* b = AndroidBridge::Bridge();
  43   if (!b) {
  44     return;
  45   }
  46
  47   b->Vibrate(pattern);
  48 }
  49
  50 void CancelVibrate(WindowIdentifier&&) {
  51   // Ignore WindowIdentifier parameter.
  52
  53   java::GeckoAppShell::CancelVibrate();
  54 }
  55
  56 void EnableBatteryNotifications() {
  57   java::GeckoAppShell::EnableBatteryNotifications();
  58 }
  59
  60 void DisableBatteryNotifications() {
  61   java::GeckoAppShell::DisableBatteryNotifications();
  62 }
  63
  64 void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo) {
  65   AndroidBridge::Bridge()->GetCurrentBatteryInformation(aBatteryInfo);
  66 }
  67
  68 void EnableNetworkNotifications() {
  69   java::GeckoAppShell::EnableNetworkNotifications();
  70 }
  71
  72 void DisableNetworkNotifications() {
  73   java::GeckoAppShell::DisableNetworkNotifications();
  74 }
  75
  76 void GetCurrentNetworkInformation(hal::NetworkInformation* aNetworkInfo) {
  77   AndroidBridge::Bridge()->GetCurrentNetworkInformation(aNetworkInfo);
  78 }
  79
  80 static bool IsSupportedScreenOrientation(hal::ScreenOrientation aOrientation) {
  81   // The Android backend only supports these orientations.
  82   static constexpr ScreenOrientation kSupportedOrientations[] = {
  83       ScreenOrientation::PortraitPrimary,
  84       ScreenOrientation::PortraitSecondary,
  85       ScreenOrientation::PortraitPrimary | ScreenOrientation::PortraitSecondary,
  86       ScreenOrientation::LandscapePrimary,
  87       ScreenOrientation::LandscapeSecondary,
  88       ScreenOrientation::LandscapePrimary |
  89           ScreenOrientation::LandscapeSecondary,
  90       ScreenOrientation::PortraitPrimary |
  91           ScreenOrientation::PortraitSecondary |
  92           ScreenOrientation::LandscapePrimary |
  93           ScreenOrientation::LandscapeSecondary,
  94       ScreenOrientation::Default,
  95   };
  96   for (auto supportedOrientation : kSupportedOrientations) {
  97     if (aOrientation == supportedOrientation) {
  98       return true;
  99     }
 100   }
 101   return false;
 102 }
 103
 104 RefPtr<GenericNonExclusivePromise> LockScreenOrientation(
 105     const hal::ScreenOrientation& aOrientation) {
 106   if (!IsSupportedScreenOrientation(aOrientation)) {
 107     NS_WARNING("Unsupported screen orientation type");
 108     return GenericNonExclusivePromise::CreateAndReject(
 109         NS_ERROR_DOM_NOT_SUPPORTED_ERR, __func__);
 110   }
 111
 112   java::GeckoRuntime::LocalRef runtime = java::GeckoRuntime::GetInstance();
 113   if (!runtime) {
 114     return GenericNonExclusivePromise::CreateAndReject(NS_ERROR_DOM_ABORT_ERR,
 115                                                        __func__);
 116   }
 117   auto result = runtime->LockScreenOrientation(uint32_t(aOrientation));
 118   auto geckoResult = java::GeckoResult::LocalRef(std::move(result));
 119   return GenericNonExclusivePromise::FromGeckoResult(geckoResult)
 120       ->Then(
 121           GetCurrentSerialEventTarget(), __func__,
 122           [](const GenericNonExclusivePromise::ResolveOrRejectValue& aValue) {
 123             if (aValue.IsResolve()) {
 124               if (aValue.ResolveValue()) {
 125                 return GenericNonExclusivePromise::CreateAndResolve(true,
 126                                                                     __func__);
 127               }
 128               // Delegated orientation controller returns failure for
 129               // lock.
 130               return GenericNonExclusivePromise::CreateAndReject(
 131                   NS_ERROR_DOM_ABORT_ERR, __func__);
 132             }
 133             // Browser side doesn't implement orientation delegate.
 134             return GenericNonExclusivePromise::CreateAndReject(
 135                 NS_ERROR_DOM_NOT_SUPPORTED_ERR, __func__);
 136           });
 137 }
 138
 139 void UnlockScreenOrientation() {
 140   java::GeckoRuntime::LocalRef runtime = java::GeckoRuntime::GetInstance();
 141   if (runtime) {
 142     runtime->UnlockScreenOrientation();
 143   }
 144 }
 145
 146 }  // namespace mozilla::hal_impl