hal/gonk/GonkSwitch.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* Copyright 2012 Mozilla Foundation and Mozilla contributors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <fcntl.h>
  18 #include <sysutils/NetlinkEvent.h>
  19
  20 #include "base/message_loop.h"
  21
  22 #include "Hal.h"
  23 #include "HalLog.h"
  24 #include "mozilla/FileUtils.h"
  25 #include "mozilla/RefPtr.h"
  26 #include "mozilla/Monitor.h"
  27 #include "nsPrintfCString.h"
  28 #include "nsXULAppAPI.h"
  29 #include "nsThreadUtils.h"
  30 #include "UeventPoller.h"
  31
  32 using namespace mozilla::hal;
  33
  34 #define SWITCH_HEADSET_DEVPATH "/devices/virtual/switch/h2w"
  35 #define SWITCH_USB_DEVPATH_GB  "/devices/virtual/switch/usb_configuration"
  36 #define SWITCH_USB_DEVPATH_ICS "/devices/virtual/android_usb/android0"
  37
  38 namespace mozilla {
  39 namespace hal_impl {
  40 /**
  41  * The uevent for a usb on GB insertion looks like:
  42  *
  43  *  change@/devices/virtual/switch/usb_configuration
  44  *    ACTION=change
  45  *    DEVPATH=/devices/virtual/switch/usb_configuration
  46  *    SUBSYSTEM=switch
  47  *    SWITCH_NAME=usb_configuration
  48  *    SWITCH_STATE=0
  49  *    SEQNUM=5038
  50  */
  51 class SwitchHandler
  52 {
  53 public:
  54   NS_INLINE_DECL_REFCOUNTING(SwitchHandler)
  55
  56   SwitchHandler(const char* aDevPath, SwitchDevice aDevice)
  57     : mDevPath(aDevPath),
  58       mState(SWITCH_STATE_UNKNOWN),
  59       mDevice(aDevice)
  60   {
  61     GetInitialState();
  62   }
  63
  64   virtual ~SwitchHandler()
  65   {
  66   }
  67
  68   bool CheckEvent(NetlinkEvent* aEvent)
  69   {
  70     if (strcmp(GetSubsystem(), aEvent->getSubsystem()) ||
  71         strcmp(mDevPath, aEvent->findParam("DEVPATH"))) {
  72         return false;
  73     }
  74
  75     mState = ConvertState(GetStateString(aEvent));
  76     return mState != SWITCH_STATE_UNKNOWN;
  77   }
  78
  79   SwitchState GetState()
  80   {
  81     return mState;
  82   }
  83
  84   SwitchDevice GetType()
  85   {
  86     return mDevice;
  87   }
  88 protected:
  89   virtual const char* GetSubsystem()
  90   {
  91     return "switch";
  92   }
  93
  94   virtual const char* GetStateString(NetlinkEvent* aEvent)
  95   {
  96     return aEvent->findParam("SWITCH_STATE");
  97   }
  98
  99   void GetInitialState()
 100   {
 101     nsPrintfCString statePath("/sys%s/state", mDevPath);
 102     int fd = open(statePath.get(), O_RDONLY);
 103     if (fd <= 0) {
 104       return;
 105     }
 106
 107     ScopedClose autoClose(fd);
 108     char state[16];
 109     ssize_t bytesRead = read(fd, state, sizeof(state));
 110     if (bytesRead < 0) {
 111       HAL_ERR("Read data from %s fails", statePath.get());
 112       return;
 113     }
 114
 115     if (state[bytesRead - 1] == '\n') {
 116       bytesRead--;
 117     }
 118
 119     state[bytesRead] = '\0';
 120     mState = ConvertState(state);
 121   }
 122
 123   virtual SwitchState ConvertState(const char* aState)
 124   {
 125     MOZ_ASSERT(aState);
 126     return aState[0] == '0' ? SWITCH_STATE_OFF : SWITCH_STATE_ON;
 127   }
 128
 129   const char* mDevPath;
 130   SwitchState mState;
 131   SwitchDevice mDevice;
 132 };
 133
 134 /**
 135  * The uevent delivered for the USB configuration under ICS looks like,
 136  *
 137  *  change@/devices/virtual/android_usb/android0
 138  *    ACTION=change
 139  *    DEVPATH=/devices/virtual/android_usb/android0
 140  *    SUBSYSTEM=android_usb
 141  *    USB_STATE=CONFIGURED
 142  *    SEQNUM=1802
 143  */
 144 class SwitchHandlerUsbIcs: public SwitchHandler
 145 {
 146 public:
 147   SwitchHandlerUsbIcs(const char* aDevPath) : SwitchHandler(aDevPath, SWITCH_USB)
 148   {
 149     SwitchHandler::GetInitialState();
 150   }
 151
 152   virtual ~SwitchHandlerUsbIcs() { }
 153
 154 protected:
 155   virtual const char* GetSubsystem()
 156   {
 157     return "android_usb";
 158   }
 159
 160   virtual const char* GetStateString(NetlinkEvent* aEvent)
 161   {
 162     return aEvent->findParam("USB_STATE");
 163   }
 164
 165   SwitchState ConvertState(const char* aState)
 166   {
 167     MOZ_ASSERT(aState);
 168     return strcmp(aState, "CONFIGURED") == 0 ? SWITCH_STATE_ON : SWITCH_STATE_OFF;
 169   }
 170 };
 171
 172 /**
 173  * The uevent delivered for the headset under ICS looks like,
 174  *
 175  * change@/devices/virtual/switch/h2w
 176  *   ACTION=change
 177  *   DEVPATH=/devices/virtual/switch/h2w
 178  *   SUBSYSTEM=switch
 179  *   SWITCH_NAME=h2w
 180  *   SWITCH_STATE=2 // Headset with no mic
 181  *   SEQNUM=2581
 182  * On Otoro, SWITCH_NAME could be Headset/No Device when plug/unplug.
 183  * change@/devices/virtual/switch/h2w
 184  *   ACTION=change
 185  *   DEVPATH=/devices/virtual/switch/h2w
 186  *   SUBSYSTEM=switch
 187  *   SWITCH_NAME=Headset
 188  *   SWITCH_STATE=1 // Headset with mic
 189  *   SEQNUM=1602
 190  */
 191 class SwitchHandlerHeadphone: public SwitchHandler
 192 {
 193 public:
 194   SwitchHandlerHeadphone(const char* aDevPath) :
 195     SwitchHandler(aDevPath, SWITCH_HEADPHONES)
 196   {
 197     SwitchHandler::GetInitialState();
 198   }
 199
 200   virtual ~SwitchHandlerHeadphone() { }
 201
 202 protected:
 203   SwitchState ConvertState(const char* aState)
 204   {
 205     MOZ_ASSERT(aState);
 206
 207     return aState[0] == '0' ? SWITCH_STATE_OFF :
 208       (aState[0] == '1' ? SWITCH_STATE_HEADSET : SWITCH_STATE_HEADPHONE);
 209   }
 210 };
 211
 212
 213 typedef nsTArray<RefPtr<SwitchHandler> > SwitchHandlerArray;
 214
 215 class SwitchEventRunnable : public nsRunnable
 216 {
 217 public:
 218   SwitchEventRunnable(SwitchEvent& aEvent) : mEvent(aEvent)
 219   {
 220   }
 221
 222   NS_IMETHOD Run()
 223   {
 224     NotifySwitchChange(mEvent);
 225     return NS_OK;
 226   }
 227 private:
 228   SwitchEvent mEvent;
 229 };
 230
 231 class SwitchEventObserver MOZ_FINAL : public IUeventObserver
 232 {
 233   ~SwitchEventObserver()
 234   {
 235     mHandler.Clear();
 236   }
 237
 238 public:
 239   NS_INLINE_DECL_REFCOUNTING(SwitchEventObserver)
 240   SwitchEventObserver()
 241     : mEnableCount(0),
 242     mHeadphonesFromInputDev(false)
 243   {
 244     Init();
 245   }
 246
 247   int GetEnableCount()
 248   {
 249     return mEnableCount;
 250   }
 251
 252   void EnableSwitch(SwitchDevice aDevice)
 253   {
 254     mEventInfo[aDevice].mEnabled = true;
 255     mEnableCount++;
 256   }
 257
 258   void DisableSwitch(SwitchDevice aDevice)
 259   {
 260     mEventInfo[aDevice].mEnabled = false;
 261     mEnableCount--;
 262   }
 263
 264   void Notify(const NetlinkEvent& aEvent)
 265   {
 266     SwitchState currState;
 267
 268     SwitchDevice device = GetEventInfo(aEvent, currState);
 269     if (device == SWITCH_DEVICE_UNKNOWN) {
 270       return;
 271     }
 272
 273     EventInfo& info = mEventInfo[device];
 274     if (currState == info.mEvent.status()) {
 275       return;
 276     }
 277
 278     info.mEvent.status() = currState;
 279
 280     if (info.mEnabled) {
 281       NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
 282     }
 283   }
 284
 285   void Notify(SwitchDevice aDevice, SwitchState aState)
 286   {
 287     EventInfo& info = mEventInfo[aDevice];
 288     if (aState == info.mEvent.status()) {
 289       return;
 290     }
 291
 292     info.mEvent.status() = aState;
 293
 294     if (info.mEnabled) {
 295       NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
 296     }
 297   }
 298
 299   SwitchState GetCurrentInformation(SwitchDevice aDevice)
 300   {
 301     return mEventInfo[aDevice].mEvent.status();
 302   }
 303
 304   void NotifyAnEvent(SwitchDevice aDevice)
 305   {
 306     EventInfo& info = mEventInfo[aDevice];
 307     if (info.mEvent.status() != SWITCH_STATE_UNKNOWN) {
 308       NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
 309     }
 310   }
 311
 312   bool GetHeadphonesFromInputDev()
 313   {
 314     return mHeadphonesFromInputDev;
 315   }
 316
 317 private:
 318   class EventInfo
 319   {
 320   public:
 321     EventInfo() : mEnabled(false)
 322     {
 323       mEvent.status() = SWITCH_STATE_UNKNOWN;
 324       mEvent.device() = SWITCH_DEVICE_UNKNOWN;
 325     }
 326     SwitchEvent mEvent;
 327     bool mEnabled;
 328   };
 329
 330   EventInfo mEventInfo[NUM_SWITCH_DEVICE];
 331   size_t mEnableCount;
 332   SwitchHandlerArray mHandler;
 333   bool mHeadphonesFromInputDev;
 334
 335   // This function might also get called on the main thread
 336   // (from IsHeadphoneEventFromInputDev)
 337   void Init()
 338   {
 339     RefPtr<SwitchHandlerHeadphone> switchHeadPhone =
 340       new SwitchHandlerHeadphone(SWITCH_HEADSET_DEVPATH);
 341
 342     // If the initial state is unknown, it means the headphone event is from input dev
 343     mHeadphonesFromInputDev = switchHeadPhone->GetState() == SWITCH_STATE_UNKNOWN ? true : false;
 344
 345     if (!mHeadphonesFromInputDev) {
 346       mHandler.AppendElement(switchHeadPhone);
 347     } else {
 348       // If headphone status will be notified from input dev then initialize
 349       // status to "off" and wait for event notification.
 350       mEventInfo[SWITCH_HEADPHONES].mEvent.device() = SWITCH_HEADPHONES;
 351       mEventInfo[SWITCH_HEADPHONES].mEvent.status() = SWITCH_STATE_OFF;
 352     }
 353     mHandler.AppendElement(new SwitchHandler(SWITCH_USB_DEVPATH_GB, SWITCH_USB));
 354     mHandler.AppendElement(new SwitchHandlerUsbIcs(SWITCH_USB_DEVPATH_ICS));
 355
 356     SwitchHandlerArray::index_type handlerIndex;
 357     SwitchHandlerArray::size_type numHandlers = mHandler.Length();
 358
 359     for (handlerIndex = 0; handlerIndex < numHandlers; handlerIndex++) {
 360       SwitchState state = mHandler[handlerIndex]->GetState();
 361       if (state == SWITCH_STATE_UNKNOWN) {
 362         continue;
 363       }
 364
 365       SwitchDevice device = mHandler[handlerIndex]->GetType();
 366       mEventInfo[device].mEvent.device() = device;
 367       mEventInfo[device].mEvent.status() = state;
 368     }
 369   }
 370
 371   SwitchDevice GetEventInfo(const NetlinkEvent& aEvent, SwitchState& aState)
 372   {
 373     //working around the android code not being const-correct
 374     NetlinkEvent *e = const_cast<NetlinkEvent*>(&aEvent);
 375
 376     for (size_t i = 0; i < mHandler.Length(); i++) {
 377       if (mHandler[i]->CheckEvent(e)) {
 378         aState = mHandler[i]->GetState();
 379         return mHandler[i]->GetType();
 380       }
 381     }
 382     return SWITCH_DEVICE_UNKNOWN;
 383   }
 384 };
 385
 386 static RefPtr<SwitchEventObserver> sSwitchObserver;
 387
 388 static void
 389 InitializeResourceIfNeed()
 390 {
 391   if (!sSwitchObserver) {
 392     sSwitchObserver = new SwitchEventObserver();
 393     RegisterUeventListener(sSwitchObserver);
 394   }
 395 }
 396
 397 static void
 398 ReleaseResourceIfNeed()
 399 {
 400   if (sSwitchObserver->GetEnableCount() == 0) {
 401     UnregisterUeventListener(sSwitchObserver);
 402     sSwitchObserver = nullptr;
 403   }
 404 }
 405
 406 static void
 407 EnableSwitchNotificationsIOThread(SwitchDevice aDevice, Monitor *aMonitor)
 408 {
 409   InitializeResourceIfNeed();
 410   sSwitchObserver->EnableSwitch(aDevice);
 411   {
 412     MonitorAutoLock lock(*aMonitor);
 413     lock.Notify();
 414   }
 415
 416   // Notify the latest state if IO thread has the information.
 417   if (sSwitchObserver->GetEnableCount() > 1) {
 418     sSwitchObserver->NotifyAnEvent(aDevice);
 419   }
 420 }
 421
 422 void
 423 EnableSwitchNotifications(SwitchDevice aDevice)
 424 {
 425   Monitor monitor("EnableSwitch.monitor");
 426   {
 427     MonitorAutoLock lock(monitor);
 428     XRE_GetIOMessageLoop()->PostTask(
 429         FROM_HERE,
 430         NewRunnableFunction(EnableSwitchNotificationsIOThread, aDevice, &monitor));
 431     lock.Wait();
 432   }
 433 }
 434
 435 static void
 436 DisableSwitchNotificationsIOThread(SwitchDevice aDevice)
 437 {
 438   MOZ_ASSERT(sSwitchObserver->GetEnableCount());
 439   sSwitchObserver->DisableSwitch(aDevice);
 440   ReleaseResourceIfNeed();
 441 }
 442
 443 void
 444 DisableSwitchNotifications(SwitchDevice aDevice)
 445 {
 446   XRE_GetIOMessageLoop()->PostTask(
 447       FROM_HERE,
 448       NewRunnableFunction(DisableSwitchNotificationsIOThread, aDevice));
 449 }
 450
 451 SwitchState
 452 GetCurrentSwitchState(SwitchDevice aDevice)
 453 {
 454   MOZ_ASSERT(sSwitchObserver && sSwitchObserver->GetEnableCount());
 455   return sSwitchObserver->GetCurrentInformation(aDevice);
 456 }
 457
 458 static void
 459 NotifySwitchStateIOThread(SwitchDevice aDevice, SwitchState aState)
 460 {
 461   InitializeResourceIfNeed();
 462   sSwitchObserver->Notify(aDevice, aState);
 463 }
 464
 465 void NotifySwitchStateFromInputDevice(SwitchDevice aDevice, SwitchState aState)
 466 {
 467   XRE_GetIOMessageLoop()->PostTask(
 468       FROM_HERE,
 469       NewRunnableFunction(NotifySwitchStateIOThread, aDevice, aState));
 470 }
 471
 472 bool IsHeadphoneEventFromInputDev()
 473 {
 474   // Instead of calling InitializeResourceIfNeed, create new SwitchEventObserver
 475   // to prevent calling RegisterUeventListener in main thread.
 476   RefPtr<SwitchEventObserver> switchObserver = new SwitchEventObserver();
 477   return switchObserver->GetHeadphonesFromInputDev();
 478 }
 479
 480 } // hal_impl
 481 } //mozilla