forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
gamepad_service.h
178 lines (138 loc) · 6.09 KB
/
gamepad_service.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_
#define DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_
#include <memory>
#include <set>
#include <unordered_map>
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/memory/read_only_shared_memory_region.h"
#include "base/memory/singleton.h"
#include "device/gamepad/gamepad_export.h"
#include "device/gamepad/gamepad_provider.h"
#include "device/gamepad/public/mojom/gamepad.mojom.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace service_manager {
class Connector;
} // namespace service_manager
namespace device {
class GamepadConsumer;
class GamepadDataFetcher;
class GamepadProvider;
// Owns the GamepadProvider (the background polling thread) and keeps track of
// the number of consumers currently using the data (and pausing the provider
// when not in use).
class DEVICE_GAMEPAD_EXPORT GamepadService
: public device::GamepadConnectionChangeClient {
public:
// Returns the GamepadService singleton.
static GamepadService* GetInstance();
// Sets the GamepadService instance. Exposed for tests.
static void SetInstance(GamepadService*);
// Initializes the GamepadService. |service_manager_connector| will be
// passed to the GamepadProvider once it is created, to allow data fetchers
// to access the device service from the polling thread.
void StartUp(
std::unique_ptr<service_manager::Connector> service_manager_connector);
// Increments the number of users of the provider. The Provider is running
// when there's > 0 users, and is paused when the count drops to 0.
// |consumer| is registered to listen for gamepad connections. If this is the
// first time it is added to the set of consumers it will be treated
// specially: it will not be informed about connections before a new user
// gesture is observed at which point it will be notified for every connected
// gamepads.
//
// Returns true on success. If |consumer| is already active, returns false and
// exits without modifying the consumer set.
//
// Must be called on the I/O thread.
bool ConsumerBecameActive(GamepadConsumer* consumer);
// Decrements the number of users of the provider. |consumer| will not be
// informed about connections until it's added back via ConsumerBecameActive.
//
// Returns true on success. If |consumer| is not in the consumer set or is
// already inactive, returns false and exits without modifying the consumer
// set.
//
// Must be called on the I/O thread.
bool ConsumerBecameInactive(GamepadConsumer* consumer);
// Decrements the number of users of the provider and removes |consumer| from
// the set of consumers. Should be matched with a a ConsumerBecameActive
// call.
//
// Returns true on success, or false if |consumer| was not in the consumer
// set.
//
// Must be called on the I/O thread.
bool RemoveConsumer(GamepadConsumer* consumer);
// Registers the given closure for calling when the user has interacted with
// the device. This callback will only be issued once. Should only be called
// while a consumer is active.
void RegisterForUserGesture(base::OnceClosure closure);
// Returns a duplicate of the shared memory region of the gamepad data.
base::ReadOnlySharedMemoryRegion DuplicateSharedMemoryRegion();
// Stop/join with the background thread in GamepadProvider |provider_|.
void Terminate();
// Called on IO thread when a gamepad is connected.
void OnGamepadConnected(uint32_t index, const Gamepad& pad);
// Called on IO thread when a gamepad is disconnected.
void OnGamepadDisconnected(uint32_t index, const Gamepad& pad);
// Request playback of a haptic effect on the specified gamepad. Once effect
// playback is complete or is preempted by a different effect, the callback
// will be called.
void PlayVibrationEffectOnce(
uint32_t pad_index,
mojom::GamepadHapticEffectType,
mojom::GamepadEffectParametersPtr,
mojom::GamepadHapticsManager::PlayVibrationEffectOnceCallback);
// Resets the state of the vibration actuator on the specified gamepad. If any
// effects are currently being played, they are preempted and vibration is
// stopped.
void ResetVibrationActuator(
uint32_t pad_index,
mojom::GamepadHapticsManager::ResetVibrationActuatorCallback);
// Constructor for testing. This specifies the data fetcher to use for a
// provider, bypassing the default platform one.
GamepadService(std::unique_ptr<GamepadDataFetcher> fetcher);
virtual ~GamepadService();
private:
friend struct base::DefaultSingletonTraits<GamepadService>;
friend class GamepadServiceTest;
GamepadService();
void OnUserGesture();
void OnGamepadConnectionChange(bool connected,
uint32_t index,
const Gamepad& pad) override;
void SetSanitizationEnabled(bool sanitize);
struct ConsumerInfo {
ConsumerInfo(GamepadConsumer* consumer) : consumer(consumer) {}
bool operator<(const ConsumerInfo& other) const {
return consumer < other.consumer;
}
device::GamepadConsumer* consumer;
mutable bool is_active = false;
mutable bool did_observe_user_gesture = false;
};
std::unique_ptr<GamepadProvider> provider_;
scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
typedef std::set<ConsumerInfo> ConsumerSet;
ConsumerSet consumers_;
typedef std::unordered_map<device::GamepadConsumer*, std::vector<bool>>
ConsumerConnectedStateMap;
ConsumerConnectedStateMap inactive_consumer_state_;
// The number of active consumers in |consumers_|.
int num_active_consumers_ = 0;
bool gesture_callback_pending_ = false;
// Service manager connector. Must be used only on the main thread.
std::unique_ptr<service_manager::Connector> service_manager_connector_;
DISALLOW_COPY_AND_ASSIGN(GamepadService);
};
} // namespace device
#endif // DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_