The Tor Browser: comparison hal/gonk/GonkSwitch.cpp

--1:000000000000
+:2cfb839e4da8
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* Copyright 2012 Mozilla Foundation and Mozilla contributors
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include <android/log.h>
+#include <fcntl.h>
+#include <sysutils/NetlinkEvent.h>
+#include <cutils/properties.h>
+#include "base/message_loop.h"
+#include "Hal.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Monitor.h"
+#include "nsPrintfCString.h"
+#include "nsXULAppAPI.h"
+#include "nsThreadUtils.h"
+#include "UeventPoller.h"
+using namespace mozilla::hal;
+#define LOG(args...)  __android_log_print(ANDROID_LOG_INFO, "GonkSwitch" , ## args)
+#define SWITCH_HEADSET_DEVPATH "/devices/virtual/switch/h2w"
+#define SWITCH_USB_DEVPATH_GB  "/devices/virtual/switch/usb_configuration"
+#define SWITCH_USB_DEVPATH_ICS "/devices/virtual/android_usb/android0"
+namespace mozilla {
+namespace hal_impl {
+/**
+* The uevent for a usb on GB insertion looks like:
+*
+*  change@/devices/virtual/switch/usb_configuration
+*    ACTION=change
+*    DEVPATH=/devices/virtual/switch/usb_configuration
+*    SUBSYSTEM=switch
+*    SWITCH_NAME=usb_configuration
+*    SWITCH_STATE=0
+*    SEQNUM=5038
+*/
+class SwitchHandler
+{
+public:
+NS_INLINE_DECL_REFCOUNTING(SwitchHandler)
+SwitchHandler(const char* aDevPath, SwitchDevice aDevice)
+: mDevPath(aDevPath),
+mState(SWITCH_STATE_UNKNOWN),
+mDevice(aDevice)
+{
+GetInitialState();
+}
+virtual ~SwitchHandler()
+{
+}
+bool CheckEvent(NetlinkEvent* aEvent)
+{
+if (strcmp(GetSubsystem(), aEvent->getSubsystem()) ||
+strcmp(mDevPath, aEvent->findParam("DEVPATH"))) {
+return false;
+}
+mState = ConvertState(GetStateString(aEvent));
+return mState != SWITCH_STATE_UNKNOWN;
+}
+SwitchState GetState()
+{
+return mState;
+}
+SwitchDevice GetType()
+{
+return mDevice;
+}
+protected:
+virtual const char* GetSubsystem()
+{
+return "switch";
+}
+virtual const char* GetStateString(NetlinkEvent* aEvent)
+{
+return aEvent->findParam("SWITCH_STATE");
+}
+void GetInitialState()
+{
+nsPrintfCString statePath("/sys%s/state", mDevPath);
+int fd = open(statePath.get(), O_RDONLY);
+if (fd <= 0) {
+return;
+}
+ScopedClose autoClose(fd);
+char state[16];
+ssize_t bytesRead = read(fd, state, sizeof(state));
+if (bytesRead < 0) {
+LOG("Read data from %s fails", statePath.get());
+return;
+}
+if (state[bytesRead - 1] == '\n') {
+bytesRead--;
+}
+state[bytesRead] = '\0';
+mState = ConvertState(state);
+}
+virtual SwitchState ConvertState(const char* aState)
+{
+MOZ_ASSERT(aState);
+return aState[0] == '0' ? SWITCH_STATE_OFF : SWITCH_STATE_ON;
+}
+const char* mDevPath;
+SwitchState mState;
+SwitchDevice mDevice;
+};
+/**
+* The uevent delivered for the USB configuration under ICS looks like,
+*
+*  change@/devices/virtual/android_usb/android0
+*    ACTION=change
+*    DEVPATH=/devices/virtual/android_usb/android0
+*    SUBSYSTEM=android_usb
+*    USB_STATE=CONFIGURED
+*    SEQNUM=1802
+*/
+class SwitchHandlerUsbIcs: public SwitchHandler
+{
+public:
+SwitchHandlerUsbIcs(const char* aDevPath) : SwitchHandler(aDevPath, SWITCH_USB)
+{
+SwitchHandler::GetInitialState();
+}
+virtual ~SwitchHandlerUsbIcs() { }
+protected:
+virtual const char* GetSubsystem()
+{
+return "android_usb";
+}
+virtual const char* GetStateString(NetlinkEvent* aEvent)
+{
+return aEvent->findParam("USB_STATE");
+}
+SwitchState ConvertState(const char* aState)
+{
+MOZ_ASSERT(aState);
+return strcmp(aState, "CONFIGURED") == 0 ? SWITCH_STATE_ON : SWITCH_STATE_OFF;
+}
+};
+/**
+* The uevent delivered for the headset under ICS looks like,
+*
+* change@/devices/virtual/switch/h2w
+*   ACTION=change
+*   DEVPATH=/devices/virtual/switch/h2w
+*   SUBSYSTEM=switch
+*   SWITCH_NAME=h2w
+*   SWITCH_STATE=2 // Headset with no mic
+*   SEQNUM=2581
+* On Otoro, SWITCH_NAME could be Headset/No Device when plug/unplug.
+* change@/devices/virtual/switch/h2w
+*   ACTION=change
+*   DEVPATH=/devices/virtual/switch/h2w
+*   SUBSYSTEM=switch
+*   SWITCH_NAME=Headset
+*   SWITCH_STATE=1 // Headset with mic
+*   SEQNUM=1602
+*/
+class SwitchHandlerHeadphone: public SwitchHandler
+{
+public:
+SwitchHandlerHeadphone(const char* aDevPath) :
+SwitchHandler(aDevPath, SWITCH_HEADPHONES)
+{
+SwitchHandler::GetInitialState();
+}
+virtual ~SwitchHandlerHeadphone() { }
+protected:
+SwitchState ConvertState(const char* aState)
+{
+MOZ_ASSERT(aState);
+return aState[0] == '0' ? SWITCH_STATE_OFF :
+(aState[0] == '1' ? SWITCH_STATE_HEADSET : SWITCH_STATE_HEADPHONE);
+}
+};
+typedef nsTArray<RefPtr<SwitchHandler> > SwitchHandlerArray;
+class SwitchEventRunnable : public nsRunnable
+{
+public:
+SwitchEventRunnable(SwitchEvent& aEvent) : mEvent(aEvent)
+{
+}
+NS_IMETHOD Run()
+{
+NotifySwitchChange(mEvent);
+return NS_OK;
+}
+private:
+SwitchEvent mEvent;
+};
+class SwitchEventObserver MOZ_FINAL : public IUeventObserver
+{
+~SwitchEventObserver()
+{
+mHandler.Clear();
+}
+public:
+NS_INLINE_DECL_REFCOUNTING(SwitchEventObserver)
+SwitchEventObserver() : mEnableCount(0)
+{
+Init();
+}
+int GetEnableCount()
+{
+return mEnableCount;
+}
+void EnableSwitch(SwitchDevice aDevice)
+{
+mEventInfo[aDevice].mEnabled = true;
+mEnableCount++;
+}
+void DisableSwitch(SwitchDevice aDevice)
+{
+mEventInfo[aDevice].mEnabled = false;
+mEnableCount--;
+}
+void Notify(const NetlinkEvent& aEvent)
+{
+SwitchState currState;
+SwitchDevice device = GetEventInfo(aEvent, currState);
+if (device == SWITCH_DEVICE_UNKNOWN) {
+return;
+}
+EventInfo& info = mEventInfo[device];
+if (currState == info.mEvent.status()) {
+return;
+}
+info.mEvent.status() = currState;
+if (info.mEnabled) {
+NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
+}
+}
+void Notify(SwitchDevice aDevice, SwitchState aState)
+{
+EventInfo& info = mEventInfo[aDevice];
+if (aState == info.mEvent.status()) {
+return;
+}
+info.mEvent.status() = aState;
+if (info.mEnabled) {
+NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
+}
+}
+SwitchState GetCurrentInformation(SwitchDevice aDevice)
+{
+return mEventInfo[aDevice].mEvent.status();
+}
+void NotifyAnEvent(SwitchDevice aDevice)
+{
+EventInfo& info = mEventInfo[aDevice];
+if (info.mEvent.status() != SWITCH_STATE_UNKNOWN) {
+NS_DispatchToMainThread(new SwitchEventRunnable(info.mEvent));
+}
+}
+private:
+class EventInfo
+{
+public:
+EventInfo() : mEnabled(false)
+{
+mEvent.status() = SWITCH_STATE_UNKNOWN;
+mEvent.device() = SWITCH_DEVICE_UNKNOWN;
+}
+SwitchEvent mEvent;
+bool mEnabled;
+};
+EventInfo mEventInfo[NUM_SWITCH_DEVICE];
+size_t mEnableCount;
+SwitchHandlerArray mHandler;
+void Init()
+{
+char value[PROPERTY_VALUE_MAX];
+property_get("ro.moz.devinputjack", value, "0");
+bool headphonesFromInputDev = !strcmp(value, "1");
+if (!headphonesFromInputDev) {
+mHandler.AppendElement(new SwitchHandlerHeadphone(SWITCH_HEADSET_DEVPATH));
+} else {
+// If headphone status will be notified from input dev then initialize
+// status to "off" and wait for event notification.
+mEventInfo[SWITCH_HEADPHONES].mEvent.device() = SWITCH_HEADPHONES;
+mEventInfo[SWITCH_HEADPHONES].mEvent.status() = SWITCH_STATE_OFF;
+}
+mHandler.AppendElement(new SwitchHandler(SWITCH_USB_DEVPATH_GB, SWITCH_USB));
+mHandler.AppendElement(new SwitchHandlerUsbIcs(SWITCH_USB_DEVPATH_ICS));
+SwitchHandlerArray::index_type handlerIndex;
+SwitchHandlerArray::size_type numHandlers = mHandler.Length();
+for (handlerIndex = 0; handlerIndex < numHandlers; handlerIndex++) {
+SwitchState state = mHandler[handlerIndex]->GetState();
+if (state == SWITCH_STATE_UNKNOWN) {
+continue;
+}
+SwitchDevice device = mHandler[handlerIndex]->GetType();
+mEventInfo[device].mEvent.device() = device;
+mEventInfo[device].mEvent.status() = state;
+}
+}
+SwitchDevice GetEventInfo(const NetlinkEvent& aEvent, SwitchState& aState)
+{
+//working around the android code not being const-correct
+NetlinkEvent *e = const_cast<NetlinkEvent*>(&aEvent);
+for (size_t i = 0; i < mHandler.Length(); i++) {
+if (mHandler[i]->CheckEvent(e)) {
+aState = mHandler[i]->GetState();
+return mHandler[i]->GetType();
+}
+}
+return SWITCH_DEVICE_UNKNOWN;
+}
+};
+static RefPtr<SwitchEventObserver> sSwitchObserver;
+static void
+InitializeResourceIfNeed()
+{
+if (!sSwitchObserver) {
+sSwitchObserver = new SwitchEventObserver();
+RegisterUeventListener(sSwitchObserver);
+}
+}
+static void
+ReleaseResourceIfNeed()
+{
+if (sSwitchObserver->GetEnableCount() == 0) {
+UnregisterUeventListener(sSwitchObserver);
+sSwitchObserver = nullptr;
+}
+}
+static void
+EnableSwitchNotificationsIOThread(SwitchDevice aDevice, Monitor *aMonitor)
+{
+InitializeResourceIfNeed();
+sSwitchObserver->EnableSwitch(aDevice);
+{
+MonitorAutoLock lock(*aMonitor);
+lock.Notify();
+}
+// Notify the latest state if IO thread has the information.
+if (sSwitchObserver->GetEnableCount() > 1) {
+sSwitchObserver->NotifyAnEvent(aDevice);
+}
+}
+void
+EnableSwitchNotifications(SwitchDevice aDevice)
+{
+Monitor monitor("EnableSwitch.monitor");
+{
+MonitorAutoLock lock(monitor);
+XRE_GetIOMessageLoop()->PostTask(
+FROM_HERE,
+NewRunnableFunction(EnableSwitchNotificationsIOThread, aDevice, &monitor));
+lock.Wait();
+}
+}
+static void
+DisableSwitchNotificationsIOThread(SwitchDevice aDevice)
+{
+MOZ_ASSERT(sSwitchObserver->GetEnableCount());
+sSwitchObserver->DisableSwitch(aDevice);
+ReleaseResourceIfNeed();
+}
+void
+DisableSwitchNotifications(SwitchDevice aDevice)
+{
+XRE_GetIOMessageLoop()->PostTask(
+FROM_HERE,
+NewRunnableFunction(DisableSwitchNotificationsIOThread, aDevice));
+}
+SwitchState
+GetCurrentSwitchState(SwitchDevice aDevice)
+{
+MOZ_ASSERT(sSwitchObserver && sSwitchObserver->GetEnableCount());
+return sSwitchObserver->GetCurrentInformation(aDevice);
+}
+static void
+NotifySwitchStateIOThread(SwitchDevice aDevice, SwitchState aState)
+{
+sSwitchObserver->Notify(aDevice, aState);
+}
+void NotifySwitchStateFromInputDevice(SwitchDevice aDevice, SwitchState aState)
+{
+InitializeResourceIfNeed();
+XRE_GetIOMessageLoop()->PostTask(
+FROM_HERE,
+NewRunnableFunction(NotifySwitchStateIOThread, aDevice, aState));
+}
+} // hal_impl
+} //mozilla

The Tor Browser / file comparison

comparison: hal/gonk/GonkSwitch.cpp

hal/gonk/GonkSwitch.cpp