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