hal/cocoa/CocoaBattery.cpp

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