PointerController.h revision 33c5903e7759b0594b1e0a062b066945a2c86989 
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    virtual int32_t getCustomPointerIconId() = 0;
71};
72
73
74/*
75 * Tracks pointer movements and draws the pointer sprite to a surface.
76 *
77 * Handles pointer acceleration and animation.
78 */
79class PointerController : public PointerControllerInterface, public MessageHandler,
80                          public LooperCallback {
81protected:
82    virtual ~PointerController();
83
84public:
85    enum InactivityTimeout {
86        INACTIVITY_TIMEOUT_NORMAL = 0,
87        INACTIVITY_TIMEOUT_SHORT = 1,
88    };
89
90    PointerController(const sp<PointerControllerPolicyInterface>& policy,
91            const sp<Looper>& looper, const sp<SpriteController>& spriteController);
92
93    virtual bool getBounds(float* outMinX, float* outMinY,
94            float* outMaxX, float* outMaxY) const;
95    virtual void move(float deltaX, float deltaY);
96    virtual void setButtonState(int32_t buttonState);
97    virtual int32_t getButtonState() const;
98    virtual void setPosition(float x, float y);
99    virtual void getPosition(float* outX, float* outY) const;
100    virtual void fade(Transition transition);
101    virtual void unfade(Transition transition);
102
103    virtual void setPresentation(Presentation presentation);
104    virtual void setSpots(const PointerCoords* spotCoords,
105            const uint32_t* spotIdToIndex, BitSet32 spotIdBits);
106    virtual void clearSpots();
107
108    void updatePointerIcon(int32_t iconId);
109    void setCustomPointerIcon(const SpriteIcon& icon);
110    void setDisplayViewport(int32_t width, int32_t height, int32_t orientation);
111    void setInactivityTimeout(InactivityTimeout inactivityTimeout);
112    void reloadPointerResources();
113
114private:
115    static const size_t MAX_RECYCLED_SPRITES = 12;
116    static const size_t MAX_SPOTS = 12;
117
118    enum {
119        MSG_INACTIVITY_TIMEOUT,
120    };
121
122    struct Spot {
123        static const uint32_t INVALID_ID = 0xffffffff;
124
125        uint32_t id;
126        sp<Sprite> sprite;
127        float alpha;
128        float scale;
129        float x, y;
130
131        inline Spot(uint32_t id, const sp<Sprite>& sprite)
132                : id(id), sprite(sprite), alpha(1.0f), scale(1.0f),
133                  x(0.0f), y(0.0f), lastIcon(NULL) { }
134
135        void updateSprite(const SpriteIcon* icon, float x, float y);
136
137    private:
138        const SpriteIcon* lastIcon;
139    };
140
141    mutable Mutex mLock;
142
143    sp<PointerControllerPolicyInterface> mPolicy;
144    sp<Looper> mLooper;
145    sp<SpriteController> mSpriteController;
146    sp<WeakMessageHandler> mHandler;
147    sp<LooperCallback> mCallback;
148
149    DisplayEventReceiver mDisplayEventReceiver;
150
151    PointerResources mResources;
152
153    struct Locked {
154        bool animationPending;
155        nsecs_t animationTime;
156
157        size_t animationFrameIndex;
158        nsecs_t lastFrameUpdatedTime;
159
160        int32_t displayWidth;
161        int32_t displayHeight;
162        int32_t displayOrientation;
163
164        InactivityTimeout inactivityTimeout;
165
166        Presentation presentation;
167        bool presentationChanged;
168
169        int32_t pointerFadeDirection;
170        float pointerX;
171        float pointerY;
172        float pointerAlpha;
173        sp<Sprite> pointerSprite;
174        SpriteIcon pointerIcon;
175        bool pointerIconChanged;
176
177        std::map<int32_t, SpriteIcon> additionalMouseResources;
178        std::map<int32_t, PointerAnimation> animationResources;
179
180        int32_t requestedPointerType;
181
182        int32_t buttonState;
183
184        Vector<Spot*> spots;
185        Vector<sp<Sprite> > recycledSprites;
186    } mLocked;
187
188    bool getBoundsLocked(float* outMinX, float* outMinY, float* outMaxX, float* outMaxY) const;
189    void setPositionLocked(float x, float y);
190
191    void handleMessage(const Message& message);
192    int handleEvent(int fd, int events, void* data);
193    void doAnimate(nsecs_t timestamp);
194    bool doFadingAnimationLocked(nsecs_t timestamp);
195    bool doBitmapAnimationLocked(nsecs_t timestamp);
196    void doInactivityTimeout();
197
198    void startAnimationLocked();
199
200    void resetInactivityTimeoutLocked();
201    void removeInactivityTimeoutLocked();
202    void updatePointerLocked();
203
204    Spot* getSpotLocked(uint32_t id);
205    Spot* createAndAddSpotLocked(uint32_t id);
206    Spot* removeFirstFadingSpotLocked();
207    void releaseSpotLocked(Spot* spot);
208    void fadeOutAndReleaseSpotLocked(Spot* spot);
209    void fadeOutAndReleaseAllSpotsLocked();
210
211    void loadResources();
212};
213
214} // namespace android
215
216#endif // _UI_POINTER_CONTROLLER_H
217