1 #ifndef __DALI_INTERNAL_ECORE_INDICATOR_H__
2 #define __DALI_INTERNAL_ECORE_INDICATOR_H__
5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
22 #include <dali/public-api/animation/animation.h>
23 #include <dali/public-api/actors/image-actor.h>
24 #include <dali/public-api/events/pan-gesture.h>
25 #include <dali/public-api/events/pan-gesture-detector.h>
26 #include <dali/devel-api/rendering/renderer.h>
29 #include <base/interfaces/indicator-interface.h>
30 #include <indicator-buffer.h>
31 #include <ecore-server-connection.h>
32 #include <shared-file.h>
49 typedef unsigned int PixmapId;
52 * The Indicator class connects to the indicator server, and gets and draws the indicator
53 * for the given orientation.
55 class Indicator : public ConnectionTracker, public ServerConnection::Observer, public IndicatorInterface
68 * Class to encapsulate lock file
74 * Constructor. open lock file
76 LockFile(const std::string filename);
84 * Grab an exclusive lock on this file
85 * @return true if the lock succeeded, false if it failed
95 * Test if there is an error with the lock file, and clears
97 * @return true if an error was thrown
99 bool RetrieveAndClearErrorStatus();
102 std::string mFilename;
108 * Class to ensure lock/unlock through object destruction
114 * Constructor - creates a lock on the lockfile
115 * @param[in] lockFile The lockfile to use
117 ScopedLock( LockFile* lockFile );
120 * Destructor - removes the lock (if any) on the lockfile
125 * Method to test if the locking succeeded
126 * @return TRUE if locked
131 LockFile* mLockFile; ///< The lock file to use
132 bool mLocked; ///< Whether the lock succeeded
136 public: // Dali::Internal::Adaptor::IndicicatorInterface
138 * @copydoc Dali::Internal::IndicatorInterface::IndicatorInterface
140 Indicator( Adaptor* adaptor,
141 Dali::Window::WindowOrientation orientation,
142 IndicatorInterface::Observer* observer );
145 * @copydoc Dali::Internal::IndicatorInterface::~IndicatorInterface
147 virtual ~Indicator();
150 virtual void SetAdaptor(Adaptor* adaptor);
153 * @copydoc Dali::Internal::IndicatorInterface::GetActor
155 virtual Dali::Actor GetActor();
158 * @copydoc Dali::Internal::IndicatorInterface::Open
160 virtual void Open( Dali::Window::WindowOrientation orientation );
163 * @copydoc Dali::Internal::IndicatorInterface::Close
165 virtual void Close();
168 * @copydoc Dali::Internal::IndicatorInterface::SetOpacityMode
170 virtual void SetOpacityMode( Dali::Window::IndicatorBgOpacity mode );
173 * @copydoc Dali::Internal::IndicatorInterface::SetVisible
175 virtual void SetVisible( Dali::Window::IndicatorVisibleMode visibleMode, bool forceUpdate = false );
178 * @copydoc Dali::Internal::IndicatorInterface::IsConnected
180 virtual bool IsConnected();
183 * @copydoc Dali::Internal::IndicatorInterface::SendMessage
185 virtual bool SendMessage( int messageDomain, int messageId, const void *data, int size );
189 * Initialize the indicator actors
194 * Constructs the renderers used for the background
196 Dali::Geometry CreateBackgroundGeometry();
199 * Touch event callback.
200 * It should pass the valid touch event to indicator server
202 * @param[in] indicator The indicator actor that was touched
203 * @param[in] touchEvent The touch event
205 bool OnTouched(Dali::Actor indicator, const TouchEvent& touchEvent);
208 * Pan gesture callback.
209 * It finds flick down gesture to show hidden indicator image
211 * @param[in] actor The actor for gesture
212 * @param[in] gesture The gesture event
214 void OnPan( Dali::Actor actor, const Dali::PanGesture& gesture );
217 * Touch event callback on stage.
218 * If stage is touched, hide showing indicator image
220 * @param[in] touchEvent The touch event
222 void OnStageTouched(const Dali::TouchEvent& touchEvent);
225 * Connect to the indicator service
230 * Start the reconnection timer. This will run every second until we reconnect to
231 * the indicator service.
233 void StartReconnectionTimer();
236 * If connection failed, attempt to re-connect every second
238 bool OnReconnectTimer();
241 * Disconnect from the indicator service
246 * Handle Resize event
247 * @param[in] width The new width
248 * @param[in] height The new height
250 void Resize( int width, int height );
253 * Set the lock file info.
254 * @param[in] epcEvent Current ecore event.
256 void SetLockFileInfo( Ecore_Ipc_Event_Server_Data *epcEvent );
259 * Set the shared indicator image info
260 * @param[in] epcEvent The event containing the image data
262 void SetSharedImageInfo( Ecore_Ipc_Event_Server_Data *epcEvent );
265 * Load the shared indicator image
266 * @param[in] epcEvent The event containing the image data
268 void LoadSharedImage( Ecore_Ipc_Event_Server_Data *epcEvent );
271 * Load the pixmap indicator image
272 * @param[in] epcEvent The event containing the image data
274 void LoadPixmapImage( Ecore_Ipc_Event_Server_Data *epcEvent );
277 * Inform dali that the indicator data has been updated.
278 * @param[in] bufferNumber The shared file number
280 void UpdateImageData( int bufferNumber );
283 * Lock the temporary file, Copy the shared image into IndicatorBuffer
284 * and then unlock the temporary file.
285 * Caller should ensure we are not writing image to gl texture.
286 * @param[in] bufferNumber The shared file number
288 bool CopyToBuffer( int bufferNumber );
291 * Create a new image for the indicator, and set up signal handling for it.
292 * @param[in] bufferNumber The shared file number
294 void CreateNewImage( int bufferNumber );
297 * Create a new pixmap image for the indicator, and set up signal handling for it.
299 void CreateNewPixmapImage();
302 * Indicator type has changed.
304 * @param[in] type The new indicator type
306 void OnIndicatorTypeChanged( Type type );
309 * Check whether the indicator could be visible or invisible
310 * @return true if indicator should be shown
312 bool CheckVisibleState();
315 * Show/Hide indicator actor with effect
316 * @param[in] duration how long need to show the indicator,
317 * if it equal to 0, hide the indicator
318 * if it less than 0, show always
320 void ShowIndicator( float duration );
323 * Showing timer callback
328 * Showing animation finished callback
329 * @param[in] animation
331 void OnAnimationFinished( Dali::Animation& animation );
333 private: // Implementation of ServerConnection::Observer
335 * @copydoc Dali::Internal::Adaptor::ServerConnection::Observer::DataReceived()
337 virtual void DataReceived( void* event );
340 * @copydoc Dali::Internal::Adaptor::ServerConnection::Observer::DataReceived()
342 virtual void ConnectionClosed();
347 * Clear shared file info
349 void ClearSharedFileInfo();
353 struct SharedFileInfo
363 mSharedFileNumber( 0 )
367 LockFile* mLock; ///< File lock for the shared file
368 SharedFile* mSharedFile; ///< Shared file
370 int mImageWidth; ///< Shared image width
371 int mImageHeight; ///< Shared image height
373 std::string mLockFileName; ///< Lock file name
374 std::string mSharedFileName; ///< Shared file name
375 int mSharedFileID; ///< Shared file ID
376 int mSharedFileNumber; ///< Shared file number
379 static const int SHARED_FILE_NUMBER = 2; ///< Shared file number
381 Dali::Geometry mTranslucentGeometry; ///< Geometry used for rendering the translucent background
382 Dali::Geometry mSolidGeometry; ///< Geometry used for rendering the opaque background
383 Dali::Material mBackgroundMaterial; ///< Material used for rendering the background
385 IndicatorBufferPtr mIndicatorBuffer; ///< class which handles indicator rendering
386 PixmapId mPixmap; ///< Pixmap including indicator content
387 Dali::Image mImage; ///< Image created from mIndicatorBuffer
388 Dali::ImageActor mIndicatorImageActor; ///< Actor created from mImage
390 Dali::Actor mIndicatorImageContainerActor; ///< Actor container for image and background
391 Dali::Actor mBackgroundActor; ///< Actor for background
392 Dali::Actor mIndicatorActor; ///< Handle to topmost indicator actor
393 Dali::Actor mEventActor; ///< Handle to event
394 Dali::PanGestureDetector mPanDetector; ///< Pan detector to find flick gesture for hidden indicator
395 float mGestureDeltaY; ///< Checking how much panning moved
396 bool mGestureDetected; ///< Whether find the flick gesture
398 Dali::Timer mReconnectTimer; ///< Reconnection timer
399 SlotDelegate< Indicator > mConnection;
401 Dali::Window::IndicatorBgOpacity mOpacityMode; ///< Opacity enum for background
402 Indicator::State mState; ///< The connection state
405 ServerConnection* mServerConnection;
406 IndicatorInterface::Observer* mObserver; ///< Upload observer
408 Dali::Window::WindowOrientation mOrientation;
411 Dali::Window::IndicatorVisibleMode mVisible; ///< Whether the indicator is visible
413 Dali::Timer mShowTimer; ///< Timer to show indicator
414 bool mIsShowing; ///< Whether the indicator is showing on the screen
415 Dali::Animation mIndicatorAnimation; ///< Animation to show/hide indicator image
417 bool mIsAnimationPlaying; ///< Whether the animation is playing
419 int mCurrentSharedFile; ///< Current shared file number
420 SharedFileInfo mSharedFileInfo[SHARED_FILE_NUMBER]; ///< Table to store shared file info