| /* |
| * Copyright (C) 2016 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #import "config.h" |
| #import "GameControllerGamepadProvider.h" |
| |
| #if ENABLE(GAMEPAD) |
| |
| #import "GameControllerGamepad.h" |
| #import "GamepadProviderClient.h" |
| #import "KnownGamepads.h" |
| #import "Logging.h" |
| #import <GameController/GameController.h> |
| #import <pal/spi/mac/IOKitSPIMac.h> |
| #import <wtf/NeverDestroyed.h> |
| |
| #import "GameControllerSoftLink.h" |
| |
| namespace WebCore { |
| |
| #if !HAVE(GCCONTROLLER_HID_DEVICE_CHECK) |
| |
| bool GameControllerGamepadProvider::willHandleVendorAndProduct(uint16_t vendorID, uint16_t productID) |
| { |
| // Check the vendor/product ID pair against a hard coded list of controllers we expect to work |
| // well with GameController.framework on macOS 10.15. |
| switch ((static_cast<uint32_t>(vendorID) << 16) | productID) { |
| case Dualshock4_1: |
| case Dualshock4_2: |
| case GamesirM2: |
| case HoripadUltimate: |
| case Nimbus1: |
| case Nimbus2: |
| case StratusXL1: |
| case StratusXL2: |
| case StratusXL3: |
| case StratusXL4: |
| case XboxOne1: |
| case XboxOne2: |
| case XboxOne3: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| #endif // !HAVE(GCCONTROLLER_HID_DEVICE_CHECK) |
| |
| static const Seconds inputNotificationDelay { 1_ms }; |
| |
| GameControllerGamepadProvider& GameControllerGamepadProvider::singleton() |
| { |
| static NeverDestroyed<GameControllerGamepadProvider> sharedProvider; |
| return sharedProvider; |
| } |
| |
| GameControllerGamepadProvider::GameControllerGamepadProvider() |
| : m_inputNotificationTimer(RunLoop::current(), this, &GameControllerGamepadProvider::inputNotificationTimerFired) |
| { |
| } |
| |
| void GameControllerGamepadProvider::controllerDidConnect(GCController *controller, ConnectionVisibility visibility) |
| { |
| LOG(Gamepad, "GameControllerGamepadProvider controller %p added", controller); |
| |
| #if HAVE(MULTIGAMEPADPROVIDER_SUPPORT) && !HAVE(GCCONTROLLER_HID_DEVICE_CHECK) |
| // On macOS 10.15, we use GameController framework for some controllers, but it's much too aggressive in handling devices it shouldn't. |
| // So we check Vendor/Product against an explicit allow-list to determine if we should let GCF handle the device. |
| // (We have the opposite check in HIDGamepadProvider, as well) |
| for (_GCCControllerHIDServiceInfo *serviceInfo in controller.hidServices) { |
| if (!serviceInfo.service) |
| continue; |
| |
| auto cfVendorID = adoptCF((CFNumberRef)IOHIDServiceClientCopyProperty(serviceInfo.service, (__bridge CFStringRef)@(kIOHIDVendorIDKey))); |
| auto cfProductID = adoptCF((CFNumberRef)IOHIDServiceClientCopyProperty(serviceInfo.service, (__bridge CFStringRef)@(kIOHIDProductIDKey))); |
| |
| int vendorID, productID; |
| CFNumberGetValue(cfVendorID.get(), kCFNumberIntType, &vendorID); |
| CFNumberGetValue(cfProductID.get(), kCFNumberIntType, &productID); |
| |
| if (!willHandleVendorAndProduct(vendorID, productID)) { |
| LOG(Gamepad, "GameControllerGamepadProvider::controllerDidConnect - GCController service does not match known VID/PID. Letting the HID provider handle it."); |
| return; |
| } |
| } |
| #endif // HAVE(MULTIGAMEPADPROVIDER_SUPPORT) && !HAVE(GCCONTROLLER_HID_DEVICE_CHECK) |
| |
| |
| // When initially starting up the GameController framework machinery, |
| // we might get the connection notification for an already-connected controller. |
| if (m_gamepadMap.contains(controller)) |
| return; |
| |
| unsigned index = indexForNewlyConnectedDevice(); |
| auto gamepad = makeUnique<GameControllerGamepad>(controller, index); |
| |
| if (m_gamepadVector.size() <= index) |
| m_gamepadVector.grow(index + 1); |
| |
| m_gamepadVector[index] = gamepad.get(); |
| m_gamepadMap.set((__bridge CFTypeRef)controller, WTFMove(gamepad)); |
| |
| |
| if (visibility == ConnectionVisibility::Invisible) { |
| m_invisibleGamepads.add(m_gamepadVector[index]); |
| return; |
| } |
| |
| makeInvisibleGamepadsVisible(); |
| |
| for (auto& client : m_clients) |
| client->platformGamepadConnected(*m_gamepadVector[index], EventMakesGamepadsVisible::Yes); |
| } |
| |
| void GameControllerGamepadProvider::controllerDidDisconnect(GCController *controller) |
| { |
| LOG(Gamepad, "GameControllerGamepadProvider controller %p removed", controller); |
| |
| auto removedGamepad = m_gamepadMap.take((__bridge CFTypeRef)controller); |
| ASSERT(removedGamepad); |
| |
| auto i = m_gamepadVector.find(removedGamepad.get()); |
| if (i != notFound) |
| m_gamepadVector[i] = nullptr; |
| |
| m_invisibleGamepads.remove(removedGamepad.get()); |
| |
| for (auto& client : m_clients) |
| client->platformGamepadDisconnected(*removedGamepad); |
| } |
| |
| void GameControllerGamepadProvider::prewarmGameControllerDevicesIfNecessary() |
| { |
| static bool prewarmed; |
| if (prewarmed) |
| return; |
| |
| LOG(Gamepad, "GameControllerGamepadProvider explicitly starting GameController framework monitoring"); |
| [getGCControllerClass() __openXPC_and_CBApplicationDidBecomeActive__]; |
| prewarmed = true; |
| } |
| |
| void GameControllerGamepadProvider::startMonitoringGamepads(GamepadProviderClient& client) |
| { |
| ASSERT(!m_clients.contains(&client)); |
| m_clients.add(&client); |
| |
| if (m_connectObserver) |
| return; |
| |
| prewarmGameControllerDevicesIfNecessary(); |
| |
| if (canLoad_GameController_GCControllerDidConnectNotification()) { |
| m_connectObserver = [[NSNotificationCenter defaultCenter] addObserverForName:get_GameController_GCControllerDidConnectNotification() object:nil queue:nil usingBlock:^(NSNotification *notification) { |
| LOG(Gamepad, "GameControllerGamepadProvider notified of new GCController %p", notification.object); |
| GameControllerGamepadProvider::singleton().controllerDidConnect(notification.object, ConnectionVisibility::Visible); |
| }]; |
| } |
| |
| if (canLoad_GameController_GCControllerDidDisconnectNotification()) { |
| m_disconnectObserver = [[NSNotificationCenter defaultCenter] addObserverForName:get_GameController_GCControllerDidDisconnectNotification() object:nil queue:nil usingBlock:^(NSNotification *notification) { |
| LOG(Gamepad, "GameControllerGamepadProvider notified of disconnected GCController %p", notification.object); |
| GameControllerGamepadProvider::singleton().controllerDidDisconnect(notification.object); |
| }]; |
| } |
| |
| auto *controllers = [getGCControllerClass() controllers]; |
| if (!controllers || !controllers.count) |
| LOG(Gamepad, "GameControllerGamepadProvider has no initial GCControllers attached"); |
| |
| for (GCController *controller in controllers) { |
| LOG(Gamepad, "GameControllerGamepadProvider has initial GCController %p", controller); |
| controllerDidConnect(controller, ConnectionVisibility::Invisible); |
| } |
| } |
| |
| void GameControllerGamepadProvider::stopMonitoringGamepads(GamepadProviderClient& client) |
| { |
| ASSERT(m_clients.contains(&client)); |
| m_clients.remove(&client); |
| |
| if (!m_connectObserver || !m_clients.isEmpty()) |
| return; |
| |
| [[NSNotificationCenter defaultCenter] removeObserver:m_connectObserver.get()]; |
| [[NSNotificationCenter defaultCenter] removeObserver:m_disconnectObserver.get()]; |
| } |
| |
| unsigned GameControllerGamepadProvider::indexForNewlyConnectedDevice() |
| { |
| unsigned index = 0; |
| while (index < m_gamepadVector.size() && m_gamepadVector[index]) |
| ++index; |
| |
| return index; |
| } |
| |
| void GameControllerGamepadProvider::gamepadHadInput(GameControllerGamepad&, bool hadButtonPresses) |
| { |
| if (!m_inputNotificationTimer.isActive()) |
| m_inputNotificationTimer.startOneShot(inputNotificationDelay); |
| |
| if (hadButtonPresses) |
| m_shouldMakeInvisibleGamepadsVisible = true; |
| } |
| |
| void GameControllerGamepadProvider::makeInvisibleGamepadsVisible() |
| { |
| for (auto* gamepad : m_invisibleGamepads) { |
| for (auto& client : m_clients) |
| client->platformGamepadConnected(*gamepad, EventMakesGamepadsVisible::Yes); |
| } |
| |
| m_invisibleGamepads.clear(); |
| } |
| |
| void GameControllerGamepadProvider::inputNotificationTimerFired() |
| { |
| if (m_shouldMakeInvisibleGamepadsVisible) { |
| setShouldMakeGamepadsVisibile(); |
| makeInvisibleGamepadsVisible(); |
| } |
| |
| m_shouldMakeInvisibleGamepadsVisible = false; |
| |
| dispatchPlatformGamepadInputActivity(); |
| } |
| |
| } // namespace WebCore |
| |
| #endif // ENABLE(GAMEPAD) |