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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_dom_GamepadPlatformService_h_
#define mozilla_dom_GamepadPlatformService_h_
#include "mozilla/dom/GamepadBinding.h"
#include "mozilla/dom/GamepadHandle.h"
#include <map>
#include "mozilla/Mutex.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Vector.h"
#include "mozilla/WeakPtr.h"
namespace mozilla {
namespace dom {
class GamepadAdded;
class GamepadEventChannelParent;
enum class GamepadLightIndicatorType : uint8_t;
struct GamepadPoseState;
class GamepadTestChannelParent;
struct GamepadTouchState;
class GamepadPlatformService;
class GamepadMonitoringState {
public:
static GamepadMonitoringState& GetSingleton();
void AddObserver(GamepadTestChannelParent* aParent);
void RemoveObserver(GamepadTestChannelParent* aParent);
bool IsMonitoring() const;
GamepadMonitoringState(const GamepadMonitoringState&) = delete;
GamepadMonitoringState(GamepadMonitoringState&&) = delete;
GamepadMonitoringState& operator=(const GamepadMonitoringState) = delete;
GamepadMonitoringState& operator=(GamepadMonitoringState&&) = delete;
private:
GamepadMonitoringState() = default;
~GamepadMonitoringState() = default;
void Set(bool aIsMonitoring);
bool mIsMonitoring{false};
Vector<WeakPtr<GamepadTestChannelParent>> mObservers;
friend class mozilla::dom::GamepadPlatformService;
};
// Platform Service for building and transmitting IPDL messages
// through the HAL sandbox. Used by platform specific
// Gamepad implementations
//
// This class can be accessed by the following 2 threads :
// 1. Background thread:
// This thread takes charge of IPDL communications
// between here and DOM side
//
// 2. Monitor Thread:
// This thread is populated in platform-dependent backends, which
// is in charge of processing gamepad hardware events from OS
class GamepadPlatformService final {
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GamepadPlatformService)
public:
// Get the singleton service
static already_AddRefed<GamepadPlatformService> GetParentService();
// Add a gamepad to the list of known gamepads, and return its handle.
GamepadHandle AddGamepad(const char* aID, GamepadMappingType aMapping,
GamepadHand aHand, uint32_t aNumButtons,
uint32_t aNumAxes, uint32_t aNumHaptics,
uint32_t aNumLightIndicator,
uint32_t aNumTouchEvents);
// Remove the gamepad at |aHandle| from the list of known gamepads.
void RemoveGamepad(GamepadHandle aHandle);
// Update the state of |aButton| for the gamepad at |aHandle| for all
// windows that are listening and visible, and fire one of
// a gamepadbutton{up,down} event at them as well.
// aPressed is used for digital buttons, aTouched is for detecting touched
// events, aValue is for analog buttons.
void NewButtonEvent(GamepadHandle aHandle, uint32_t aButton, bool aPressed,
bool aTouched, double aValue);
// When only a digital button is available the value will be synthesized.
void NewButtonEvent(GamepadHandle aHandle, uint32_t aButton, bool aPressed);
// When only a digital button are available the value will be synthesized.
void NewButtonEvent(GamepadHandle aHandle, uint32_t aButton, bool aPressed,
bool aTouched);
// When only a digital button are available the value will be synthesized.
void NewButtonEvent(GamepadHandle aHandle, uint32_t aButton, bool aPressed,
double aValue);
// Update the state of |aAxis| for the gamepad at |aHandle| for all
// windows that are listening and visible, and fire a gamepadaxismove
// event at them as well.
void NewAxisMoveEvent(GamepadHandle aHandle, uint32_t aAxis, double aValue);
// Update the state of |aState| for the gamepad at |aHandle| for all
// windows that are listening and visible.
void NewPoseEvent(GamepadHandle aHandle, const GamepadPoseState& aState);
// Update the type of |aType| for the gamepad at |aHandle| for all
// windows that are listening and visible.
void NewLightIndicatorTypeEvent(GamepadHandle aHandle, uint32_t aLight,
GamepadLightIndicatorType aType);
// Update the state of |aState| for the gamepad at |aHandle| with
// |aTouchArrayIndex| for all windows that are listening and visible.
void NewMultiTouchEvent(GamepadHandle aHandle, uint32_t aTouchArrayIndex,
const GamepadTouchState& aState);
// When shutting down the platform communications for gamepad, also reset the
// indexes.
void ResetGamepadIndexes();
// Add IPDL parent instance
void AddChannelParent(GamepadEventChannelParent* aParent);
// Remove IPDL parent instance
void RemoveChannelParent(GamepadEventChannelParent* aParent);
void MaybeShutdown();
private:
GamepadPlatformService();
~GamepadPlatformService();
template <class T>
void NotifyGamepadChange(GamepadHandle aHandle, const T& aInfo);
void Cleanup();
// mNextGamepadHandleValue can only be accessed by monitor thread
uint32_t mNextGamepadHandleValue;
// mChannelParents stores all the GamepadEventChannelParent instances
// which may be accessed by both background thread and monitor thread
// simultaneously, so we have a mutex to prevent race condition
nsTArray<RefPtr<GamepadEventChannelParent>> mChannelParents;
// This mutex protects mChannelParents from race condition
// between background and monitor thread
Mutex mMutex;
std::map<GamepadHandle, GamepadAdded> mGamepadAdded;
};
} // namespace dom
} // namespace mozilla
#endif
|
