tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

CocoaBattery.cpp (9799B)

      1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim set: sw=2 ts=2 et lcs=trail\:.,tab\:>~ : */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #import <CoreFoundation/CoreFoundation.h>
      8 #import <IOKit/ps/IOPowerSources.h>
      9 #import <IOKit/ps/IOPSKeys.h>
     10 
     11 #include <mozilla/Hal.h>
     12 #include <mozilla/dom/battery/Constants.h>
     13 #include <mozilla/Services.h>
     14 
     15 #include <nsIObserverService.h>
     16 #include <nsIObserver.h>
     17 
     18 #include <dlfcn.h>
     19 
     20 #define IOKIT_FRAMEWORK_PATH "/System/Library/Frameworks/IOKit.framework/IOKit"
     21 
     22 #ifndef kIOPSTimeRemainingUnknown
     23 #  define kIOPSTimeRemainingUnknown ((CFTimeInterval) - 1.0)
     24 #endif
     25 #ifndef kIOPSTimeRemainingUnlimited
     26 #  define kIOPSTimeRemainingUnlimited ((CFTimeInterval) - 2.0)
     27 #endif
     28 
     29 using namespace mozilla::dom::battery;
     30 
     31 namespace mozilla {
     32 namespace hal_impl {
     33 
     34 typedef CFTimeInterval (*IOPSGetTimeRemainingEstimateFunc)(void);
     35 
     36 class MacPowerInformationService {
     37 public:
     38  static MacPowerInformationService* GetInstance();
     39  static void Shutdown();
     40  static bool IsShuttingDown();
     41 
     42  void BeginListening();
     43  void StopListening();
     44 
     45  static void HandleChange(void* aContext);
     46 
     47  ~MacPowerInformationService();
     48 
     49 private:
     50  MacPowerInformationService();
     51 
     52  // The reference to the runloop that is notified of power changes.
     53  CFRunLoopSourceRef mRunLoopSource;
     54 
     55  double mLevel;
     56  bool mCharging;
     57  double mRemainingTime;
     58  bool mShouldNotify;
     59 
     60  friend void GetCurrentBatteryInformation(
     61      hal::BatteryInformation* aBatteryInfo);
     62 
     63  static MacPowerInformationService* sInstance;
     64  static bool sShuttingDown;
     65 
     66  static void* sIOKitFramework;
     67  static IOPSGetTimeRemainingEstimateFunc sIOPSGetTimeRemainingEstimate;
     68 };
     69 
     70 void* MacPowerInformationService::sIOKitFramework;
     71 IOPSGetTimeRemainingEstimateFunc
     72    MacPowerInformationService::sIOPSGetTimeRemainingEstimate;
     73 
     74 /*
     75 * Implementation of mozilla::hal_impl::EnableBatteryNotifications,
     76 *                   mozilla::hal_impl::DisableBatteryNotifications,
     77 *               and mozilla::hal_impl::GetCurrentBatteryInformation.
     78 */
     79 
     80 void EnableBatteryNotifications() {
     81  if (!MacPowerInformationService::IsShuttingDown()) {
     82    MacPowerInformationService::GetInstance()->BeginListening();
     83  }
     84 }
     85 
     86 void DisableBatteryNotifications() {
     87  if (!MacPowerInformationService::IsShuttingDown()) {
     88    MacPowerInformationService::GetInstance()->StopListening();
     89  }
     90 }
     91 
     92 void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo) {
     93  MacPowerInformationService* powerService =
     94      MacPowerInformationService::GetInstance();
     95 
     96  aBatteryInfo->level() = powerService->mLevel;
     97  aBatteryInfo->charging() = powerService->mCharging;
     98  aBatteryInfo->remainingTime() = powerService->mRemainingTime;
     99 }
    100 
    101 bool MacPowerInformationService::sShuttingDown = false;
    102 
    103 /*
    104 * Following is the implementation of MacPowerInformationService.
    105 */
    106 
    107 MacPowerInformationService* MacPowerInformationService::sInstance = nullptr;
    108 
    109 namespace {
    110 struct SingletonDestroyer final : public nsIObserver {
    111  NS_DECL_ISUPPORTS
    112  NS_DECL_NSIOBSERVER
    113 
    114 private:
    115  ~SingletonDestroyer() {}
    116 };
    117 
    118 NS_IMPL_ISUPPORTS(SingletonDestroyer, nsIObserver)
    119 
    120 NS_IMETHODIMP
    121 SingletonDestroyer::Observe(nsISupports*, const char* aTopic, const char16_t*) {
    122  MOZ_ASSERT(!strcmp(aTopic, "xpcom-shutdown"));
    123  MacPowerInformationService::Shutdown();
    124  return NS_OK;
    125 }
    126 }  // namespace
    127 
    128 /* static */
    129 MacPowerInformationService* MacPowerInformationService::GetInstance() {
    130  if (sInstance) {
    131    return sInstance;
    132  }
    133 
    134  sInstance = new MacPowerInformationService();
    135 
    136  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
    137  if (obs) {
    138    obs->AddObserver(new SingletonDestroyer(), "xpcom-shutdown", false);
    139  }
    140 
    141  return sInstance;
    142 }
    143 
    144 bool MacPowerInformationService::IsShuttingDown() { return sShuttingDown; }
    145 
    146 void MacPowerInformationService::Shutdown() {
    147  sShuttingDown = true;
    148  delete sInstance;
    149  sInstance = nullptr;
    150 }
    151 
    152 MacPowerInformationService::MacPowerInformationService()
    153    : mRunLoopSource(nullptr),
    154      mLevel(kDefaultLevel),
    155      mCharging(kDefaultCharging),
    156      mRemainingTime(kDefaultRemainingTime),
    157      mShouldNotify(false) {
    158  // IOPSGetTimeRemainingEstimate (and the related constants) are only available
    159  // on 10.7, so we test for their presence at runtime.
    160  sIOKitFramework = dlopen(IOKIT_FRAMEWORK_PATH, RTLD_LAZY | RTLD_LOCAL);
    161  if (sIOKitFramework) {
    162    sIOPSGetTimeRemainingEstimate = (IOPSGetTimeRemainingEstimateFunc)dlsym(
    163        sIOKitFramework, "IOPSGetTimeRemainingEstimate");
    164  } else {
    165    sIOPSGetTimeRemainingEstimate = nullptr;
    166  }
    167 }
    168 
    169 MacPowerInformationService::~MacPowerInformationService() {
    170  MOZ_ASSERT(!mRunLoopSource,
    171             "The observers have not been correctly removed! "
    172             "(StopListening should have been called)");
    173 
    174  if (sIOKitFramework) {
    175    dlclose(sIOKitFramework);
    176  }
    177 }
    178 
    179 void MacPowerInformationService::BeginListening() {
    180  // Set ourselves up to be notified about changes.
    181  MOZ_ASSERT(!mRunLoopSource,
    182             "IOPS Notification Loop Source already set up. "
    183             "(StopListening should have been called)");
    184 
    185  mRunLoopSource = ::IOPSNotificationCreateRunLoopSource(HandleChange, this);
    186  if (mRunLoopSource) {
    187    ::CFRunLoopAddSource(::CFRunLoopGetCurrent(), mRunLoopSource,
    188                         kCFRunLoopDefaultMode);
    189 
    190    // Invoke our callback now so we have data if GetCurrentBatteryInformation
    191    // is called before a change happens.
    192    HandleChange(this);
    193    mShouldNotify = true;
    194  }
    195 }
    196 
    197 void MacPowerInformationService::StopListening() {
    198  if (mRunLoopSource) {
    199    ::CFRunLoopRemoveSource(::CFRunLoopGetCurrent(), mRunLoopSource,
    200                            kCFRunLoopDefaultMode);
    201    mRunLoopSource = nullptr;
    202  }
    203 }
    204 
    205 void MacPowerInformationService::HandleChange(void* aContext) {
    206  MacPowerInformationService* power =
    207      static_cast<MacPowerInformationService*>(aContext);
    208 
    209  CFTypeRef data = ::IOPSCopyPowerSourcesInfo();
    210  if (!data) {
    211    ::CFRelease(data);
    212    return;
    213  }
    214 
    215  // Get the list of power sources.
    216  CFArrayRef list = ::IOPSCopyPowerSourcesList(data);
    217  if (!list) {
    218    ::CFRelease(list);
    219    return;
    220  }
    221 
    222  // Default values. These will be used if there are 0 sources or we can't find
    223  // better information.
    224  double level = kDefaultLevel;
    225  double charging = kDefaultCharging;
    226  double remainingTime = kDefaultRemainingTime;
    227 
    228  // Look for the first battery power source to give us the information we need.
    229  // Usually there's only 1 available, depending on current power source.
    230  for (CFIndex i = 0; i < ::CFArrayGetCount(list); ++i) {
    231    CFTypeRef source = ::CFArrayGetValueAtIndex(list, i);
    232    CFDictionaryRef currPowerSourceDesc =
    233        ::IOPSGetPowerSourceDescription(data, source);
    234    if (!currPowerSourceDesc) {
    235      continue;
    236    }
    237 
    238    // Get a battery level estimate. This key is required but does not always
    239    // exist.
    240    int currentCapacity = 0;
    241    const void* cfRef = ::CFDictionaryGetValue(currPowerSourceDesc,
    242                                               CFSTR(kIOPSCurrentCapacityKey));
    243    if (!cfRef) {
    244      continue;
    245    }
    246    ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberSInt32Type,
    247                       &currentCapacity);
    248 
    249    // This key is also required.
    250    int maxCapacity = 0;
    251    cfRef =
    252        ::CFDictionaryGetValue(currPowerSourceDesc, CFSTR(kIOPSMaxCapacityKey));
    253    ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberSInt32Type, &maxCapacity);
    254 
    255    if (maxCapacity > 0) {
    256      level = static_cast<double>(currentCapacity) /
    257              static_cast<double>(maxCapacity);
    258    }
    259 
    260    // Find out if we're charging.
    261    // This key is optional, we fallback to kDefaultCharging if the current
    262    // power source doesn't have that info.
    263    if (::CFDictionaryGetValueIfPresent(currPowerSourceDesc,
    264                                        CFSTR(kIOPSIsChargingKey), &cfRef)) {
    265      charging = ::CFBooleanGetValue((CFBooleanRef)cfRef);
    266 
    267      // Get an estimate of how long it's going to take until we're fully
    268      // charged. This key is optional.
    269      if (charging) {
    270        // Default value that will be changed if we happen to find the actual
    271        // remaining time.
    272        remainingTime =
    273            level == 1.0 ? kDefaultRemainingTime : kUnknownRemainingTime;
    274 
    275        if (::CFDictionaryGetValueIfPresent(
    276                currPowerSourceDesc, CFSTR(kIOPSTimeToFullChargeKey), &cfRef)) {
    277          int timeToCharge;
    278          ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType,
    279                             &timeToCharge);
    280          if (timeToCharge != kIOPSTimeRemainingUnknown) {
    281            remainingTime = timeToCharge * 60;
    282          }
    283        }
    284      } else if (sIOPSGetTimeRemainingEstimate) {  // not charging
    285        // See if we can get a time estimate.
    286        CFTimeInterval estimate = sIOPSGetTimeRemainingEstimate();
    287        if (estimate == kIOPSTimeRemainingUnlimited ||
    288            estimate == kIOPSTimeRemainingUnknown) {
    289          remainingTime = kUnknownRemainingTime;
    290        } else {
    291          remainingTime = estimate;
    292        }
    293      }
    294    }
    295 
    296    break;
    297  }
    298 
    299  bool isNewData = level != power->mLevel || charging != power->mCharging ||
    300                   remainingTime != power->mRemainingTime;
    301 
    302  power->mRemainingTime = remainingTime;
    303  power->mCharging = charging;
    304  power->mLevel = level;
    305 
    306  // Notify the observers if stuff changed.
    307  if (power->mShouldNotify && isNewData) {
    308    hal::NotifyBatteryChange(hal::BatteryInformation(
    309        power->mLevel, power->mCharging, power->mRemainingTime));
    310  }
    311 
    312  ::CFRelease(data);
    313  ::CFRelease(list);
    314 }
    315 
    316 }  // namespace hal_impl
    317 }  // namespace mozilla