1 /*
2  * Copyright (C) 2010 The Android Open Source Project
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 #ifndef _UI_POINTER_CONTROLLER_H
18 #define _UI_POINTER_CONTROLLER_H
19 
20 #include "SpriteController.h"
21 
22 #include <ui/DisplayInfo.h>
23 #include <input/Input.h>
24 #include <inputflinger/PointerControllerInterface.h>
25 #include <utils/BitSet.h>
26 #include <utils/RefBase.h>
27 #include <utils/Looper.h>
28 #include <utils/String8.h>
29 
30 #include <SkBitmap.h>
31 
32 namespace android {
33 
34 /*
35  * Pointer resources.
36  */
37 struct PointerResources {
38     SpriteIcon spotHover;
39     SpriteIcon spotTouch;
40     SpriteIcon spotAnchor;
41 };
42 
43 
44 /*
45  * Pointer controller policy interface.
46  *
47  * The pointer controller policy is used by the pointer controller to interact with
48  * the Window Manager and other system components.
49  *
50  * The actual implementation is partially supported by callbacks into the DVM
51  * via JNI.  This interface is also mocked in the unit tests.
52  */
53 class PointerControllerPolicyInterface : public virtual RefBase {
54 protected:
PointerControllerPolicyInterface()55     PointerControllerPolicyInterface() { }
~PointerControllerPolicyInterface()56     virtual ~PointerControllerPolicyInterface() { }
57 
58 public:
59     virtual void loadPointerResources(PointerResources* outResources) = 0;
60 };
61 
62 
63 /*
64  * Tracks pointer movements and draws the pointer sprite to a surface.
65  *
66  * Handles pointer acceleration and animation.
67  */
68 class PointerController : public PointerControllerInterface, public MessageHandler {
69 protected:
70     virtual ~PointerController();
71 
72 public:
73     enum InactivityTimeout {
74         INACTIVITY_TIMEOUT_NORMAL = 0,
75         INACTIVITY_TIMEOUT_SHORT = 1,
76     };
77 
78     PointerController(const sp<PointerControllerPolicyInterface>& policy,
79             const sp<Looper>& looper, const sp<SpriteController>& spriteController);
80 
81     virtual bool getBounds(float* outMinX, float* outMinY,
82             float* outMaxX, float* outMaxY) const;
83     virtual void move(float deltaX, float deltaY);
84     virtual void setButtonState(int32_t buttonState);
85     virtual int32_t getButtonState() const;
86     virtual void setPosition(float x, float y);
87     virtual void getPosition(float* outX, float* outY) const;
88     virtual void fade(Transition transition);
89     virtual void unfade(Transition transition);
90 
91     virtual void setPresentation(Presentation presentation);
92     virtual void setSpots(const PointerCoords* spotCoords,
93             const uint32_t* spotIdToIndex, BitSet32 spotIdBits);
94     virtual void clearSpots();
95 
96     void setDisplayViewport(int32_t width, int32_t height, int32_t orientation);
97     void setPointerIcon(const SpriteIcon& icon);
98     void setInactivityTimeout(InactivityTimeout inactivityTimeout);
99 
100 private:
101     static const size_t MAX_RECYCLED_SPRITES = 12;
102     static const size_t MAX_SPOTS = 12;
103 
104     enum {
105         MSG_ANIMATE,
106         MSG_INACTIVITY_TIMEOUT,
107     };
108 
109     struct Spot {
110         static const uint32_t INVALID_ID = 0xffffffff;
111 
112         uint32_t id;
113         sp<Sprite> sprite;
114         float alpha;
115         float scale;
116         float x, y;
117 
SpotSpot118         inline Spot(uint32_t id, const sp<Sprite>& sprite)
119                 : id(id), sprite(sprite), alpha(1.0f), scale(1.0f),
120                   x(0.0f), y(0.0f), lastIcon(NULL) { }
121 
122         void updateSprite(const SpriteIcon* icon, float x, float y);
123 
124     private:
125         const SpriteIcon* lastIcon;
126     };
127 
128     mutable Mutex mLock;
129 
130     sp<PointerControllerPolicyInterface> mPolicy;
131     sp<Looper> mLooper;
132     sp<SpriteController> mSpriteController;
133     sp<WeakMessageHandler> mHandler;
134 
135     PointerResources mResources;
136 
137     struct Locked {
138         bool animationPending;
139         nsecs_t animationTime;
140 
141         int32_t displayWidth;
142         int32_t displayHeight;
143         int32_t displayOrientation;
144 
145         InactivityTimeout inactivityTimeout;
146 
147         Presentation presentation;
148         bool presentationChanged;
149 
150         int32_t pointerFadeDirection;
151         float pointerX;
152         float pointerY;
153         float pointerAlpha;
154         sp<Sprite> pointerSprite;
155         SpriteIcon pointerIcon;
156         bool pointerIconChanged;
157 
158         int32_t buttonState;
159 
160         Vector<Spot*> spots;
161         Vector<sp<Sprite> > recycledSprites;
162     } mLocked;
163 
164     bool getBoundsLocked(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const;
165     void setPositionLocked(float x, float y);
166 
167     void handleMessage(const Message& message);
168     void doAnimate();
169     void doInactivityTimeout();
170 
171     void startAnimationLocked();
172 
173     void resetInactivityTimeoutLocked();
174     void removeInactivityTimeoutLocked();
175     void updatePointerLocked();
176 
177     Spot* getSpotLocked(uint32_t id);
178     Spot* createAndAddSpotLocked(uint32_t id);
179     Spot* removeFirstFadingSpotLocked();
180     void releaseSpotLocked(Spot* spot);
181     void fadeOutAndReleaseSpotLocked(Spot* spot);
182     void fadeOutAndReleaseAllSpotsLocked();
183 
184     void loadResources();
185 };
186 
187 } // namespace android
188 
189 #endif // _UI_POINTER_CONTROLLER_H
190