Home | History | Annotate | Download | only in android 
      1 #ifndef _TCUANDROIDRENDERACTIVITY_HPP
      2 #define _TCUANDROIDRENDERACTIVITY_HPP
      3 /*-------------------------------------------------------------------------
      4  * drawElements Quality Program Tester Core
      5  * ----------------------------------------
      6  *
      7  * Copyright 2014 The Android Open Source Project
      8  *
      9  * Licensed under the Apache License, Version 2.0 (the "License");
     10  * you may not use this file except in compliance with the License.
     11  * You may obtain a copy of the License at
     12  *
     13  *      http://www.apache.org/licenses/LICENSE-2.0
     14  *
     15  * Unless required by applicable law or agreed to in writing, software
     16  * distributed under the License is distributed on an "AS IS" BASIS,
     17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     18  * See the License for the specific language governing permissions and
     19  * limitations under the License.
     20  *
     21  *//*!
     22  * \file
     23  * \brief RenderActivity base class.
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "tcuDefs.hpp"
     27 #include "tcuAndroidNativeActivity.hpp"
     28 #include "deThread.hpp"
     29 #include "deThreadSafeRingBuffer.hpp"
     30 
     31 namespace tcu
     32 {
     33 namespace Android
     34 {
     35 
     36 enum MessageType
     37 {
     38 	// Execution control messages. No data argument.
     39 	MESSAGE_RESUME = 0,
     40 	MESSAGE_PAUSE,
     41 	MESSAGE_FINISH,
     42 
     43 	// Window messages. Argument is ANativeWindow pointer.
     44 	MESSAGE_WINDOW_CREATED,
     45 	MESSAGE_WINDOW_RESIZED,
     46 	MESSAGE_WINDOW_DESTROYED,
     47 
     48 	// Input queue messages. Argument is AInputQueue pointer.
     49 	MESSAGE_INPUT_QUEUE_CREATED,
     50 	MESSAGE_INPUT_QUEUE_DESTROYED,
     51 
     52 	MESSAGE_SYNC,					//!< Main thread requests sync. Data argument is de::Semaphore* that needs to be incremented.
     53 
     54 	MESSAGETYPE_LAST
     55 };
     56 
     57 struct Message
     58 {
     59 	MessageType			type;			//!< Message type.
     60 	union
     61 	{
     62 		ANativeWindow*	window;
     63 		AInputQueue*	inputQueue;
     64 		de::Semaphore*	semaphore;
     65 	} payload;							//!< Optional data argument.
     66 
     67 	Message (void)
     68 		: type(MESSAGETYPE_LAST)
     69 	{
     70 	}
     71 
     72 	explicit Message (MessageType type_)
     73 		: type(type_)
     74 	{
     75 		DE_ASSERT(type_ == MESSAGE_RESUME	||
     76 				  type_ == MESSAGE_PAUSE	||
     77 				  type_ == MESSAGE_FINISH);
     78 	}
     79 
     80 	Message (MessageType type_, ANativeWindow* window)
     81 		: type(type_)
     82 	{
     83 		DE_ASSERT(type_ == MESSAGE_WINDOW_CREATED	||
     84 				  type_ == MESSAGE_WINDOW_DESTROYED	||
     85 				  type_ == MESSAGE_WINDOW_RESIZED);
     86 		DE_ASSERT(window);
     87 		payload.window = window;
     88 	}
     89 
     90 	Message (MessageType type_, AInputQueue* inputQueue)
     91 		: type(type_)
     92 	{
     93 		DE_ASSERT(type_ == MESSAGE_INPUT_QUEUE_CREATED	||
     94 				  type_ == MESSAGE_INPUT_QUEUE_DESTROYED);
     95 		DE_ASSERT(inputQueue);
     96 		payload.inputQueue = inputQueue;
     97 	}
     98 
     99 	Message (MessageType type_, de::Semaphore* semaphore)
    100 		: type(type_)
    101 	{
    102 		DE_ASSERT(type_ == MESSAGE_SYNC);
    103 		DE_ASSERT(semaphore);
    104 		payload.semaphore = semaphore;
    105 	}
    106 };
    107 
    108 enum WindowState
    109 {
    110 	WINDOWSTATE_NOT_CREATED = 0,	//!< Framework hasn't signaled window creation.
    111 	WINDOWSTATE_NOT_INITIALIZED,	//!< Framework hasn't signaled first resize after creation and thus size is not final.
    112 	WINDOWSTATE_READY,				//!< Window is ready for use.
    113 	WINDOWSTATE_DESTROYED,			//!< Window has been destroyed.
    114 
    115 	WINDOWSTATE_LAST
    116 };
    117 
    118 typedef de::ThreadSafeRingBuffer<Message> MessageQueue;
    119 
    120 class RenderThread : private de::Thread
    121 {
    122 public:
    123 							RenderThread				(NativeActivity& activity);
    124 							~RenderThread				(void);
    125 
    126 	void					start						(void);
    127 	void					resume						(void);
    128 	void					pause						(void);
    129 	void					stop						(void);
    130 
    131 	void					enqueue						(const Message& message);
    132 	void					sync						(void);
    133 
    134 	void					run							(void);
    135 
    136 protected:
    137 	virtual void			onInputEvent				(AInputEvent* event) { DE_UNREF(event); }
    138 	virtual void			onWindowCreated				(ANativeWindow* window) = 0;
    139 	virtual void			onWindowResized				(ANativeWindow* window) = 0;
    140 	virtual void			onWindowDestroyed			(ANativeWindow* window) = 0;
    141 	virtual bool			render						(void) = 0;
    142 
    143 	NativeActivity&			getNativeActivity			(void) { return m_activity; }
    144 
    145 private:
    146 	void					processMessage				(const Message& message);
    147 
    148 	// Shared state.
    149 	NativeActivity&			m_activity;
    150 	MessageQueue			m_msgQueue;
    151 
    152 	// Parent thread state.
    153 	bool					m_threadRunning;
    154 
    155 	// Thread state.
    156 	AInputQueue*			m_inputQueue;
    157 	WindowState				m_windowState;
    158 	ANativeWindow*			m_window;
    159 	bool					m_paused;					//!< Is rendering paused?
    160 	bool					m_finish;					//!< Has thread received FINISH message?
    161 	bool					m_receivedFirstResize;				//!< Has the first onWindowResized been processed?
    162 };
    163 
    164 class RenderActivity : public NativeActivity
    165 {
    166 public:
    167 							RenderActivity				(ANativeActivity* activity);
    168 	virtual					~RenderActivity				(void);
    169 
    170 	virtual void			onStart						(void);
    171 	virtual void			onResume					(void);
    172 	virtual void			onPause						(void);
    173 	virtual void			onStop						(void);
    174 	virtual void			onDestroy					(void);
    175 
    176 	virtual void			onNativeWindowCreated		(ANativeWindow* window);
    177 	virtual void			onNativeWindowResized		(ANativeWindow* window);
    178 	virtual void			onNativeWindowRedrawNeeded	(ANativeWindow* window);
    179 	virtual void			onNativeWindowDestroyed		(ANativeWindow* window);
    180 
    181 	virtual void			onInputQueueCreated			(AInputQueue* queue);
    182 	virtual void			onInputQueueDestroyed		(AInputQueue* queue);
    183 
    184 protected:
    185 	//! Set rendering thread. Must be called at construction time.
    186 	void					setThread					(RenderThread* thread);
    187 
    188 private:
    189 							RenderActivity				(const RenderActivity& other);
    190 	RenderActivity&			operator=					(const RenderActivity& other);
    191 
    192 	RenderThread*			m_thread;
    193 };
    194 
    195 } // Android
    196 } // tcu
    197 
    198 #endif // _TCUANDROIDRENDERACTIVITY_HPP
    199