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 34 namespace android { 35 36 /* 37 * Pointer resources. 38 */ 39 struct PointerResources { 40 SpriteIcon spotHover; 41 SpriteIcon spotTouch; 42 SpriteIcon spotAnchor; 43 }; 44 45 struct 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 */ 59 class PointerControllerPolicyInterface : public virtual RefBase { 60 protected: PointerControllerPolicyInterface()61 PointerControllerPolicyInterface() { } ~PointerControllerPolicyInterface()62 virtual ~PointerControllerPolicyInterface() { } 63 64 public: 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 */ 79 class PointerController : public PointerControllerInterface, public MessageHandler, 80 public LooperCallback { 81 protected: 82 virtual ~PointerController(); 83 84 public: 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 114 private: 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 SpotSpot131 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