#ifndef _TCUANDROIDRENDERACTIVITY_HPP
|
#define _TCUANDROIDRENDERACTIVITY_HPP
|
/*-------------------------------------------------------------------------
|
* drawElements Quality Program Tester Core
|
* ----------------------------------------
|
*
|
* Copyright 2014 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
*//*!
|
* \file
|
* \brief RenderActivity base class.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuDefs.hpp"
|
#include "tcuAndroidNativeActivity.hpp"
|
#include "deThread.hpp"
|
#include "deThreadSafeRingBuffer.hpp"
|
|
namespace tcu
|
{
|
namespace Android
|
{
|
|
enum MessageType
|
{
|
// Execution control messages. No data argument.
|
MESSAGE_RESUME = 0,
|
MESSAGE_PAUSE,
|
MESSAGE_FINISH,
|
|
// Window messages. Argument is ANativeWindow pointer.
|
MESSAGE_WINDOW_CREATED,
|
MESSAGE_WINDOW_RESIZED,
|
MESSAGE_WINDOW_DESTROYED,
|
|
// Input queue messages. Argument is AInputQueue pointer.
|
MESSAGE_INPUT_QUEUE_CREATED,
|
MESSAGE_INPUT_QUEUE_DESTROYED,
|
|
MESSAGE_SYNC, //!< Main thread requests sync. Data argument is de::Semaphore* that needs to be incremented.
|
|
MESSAGETYPE_LAST
|
};
|
|
struct Message
|
{
|
MessageType type; //!< Message type.
|
union
|
{
|
ANativeWindow* window;
|
AInputQueue* inputQueue;
|
de::Semaphore* semaphore;
|
} payload; //!< Optional data argument.
|
|
Message (void)
|
: type(MESSAGETYPE_LAST)
|
{
|
}
|
|
explicit Message (MessageType type_)
|
: type(type_)
|
{
|
DE_ASSERT(type_ == MESSAGE_RESUME ||
|
type_ == MESSAGE_PAUSE ||
|
type_ == MESSAGE_FINISH);
|
}
|
|
Message (MessageType type_, ANativeWindow* window)
|
: type(type_)
|
{
|
DE_ASSERT(type_ == MESSAGE_WINDOW_CREATED ||
|
type_ == MESSAGE_WINDOW_DESTROYED ||
|
type_ == MESSAGE_WINDOW_RESIZED);
|
DE_ASSERT(window);
|
payload.window = window;
|
}
|
|
Message (MessageType type_, AInputQueue* inputQueue)
|
: type(type_)
|
{
|
DE_ASSERT(type_ == MESSAGE_INPUT_QUEUE_CREATED ||
|
type_ == MESSAGE_INPUT_QUEUE_DESTROYED);
|
DE_ASSERT(inputQueue);
|
payload.inputQueue = inputQueue;
|
}
|
|
Message (MessageType type_, de::Semaphore* semaphore)
|
: type(type_)
|
{
|
DE_ASSERT(type_ == MESSAGE_SYNC);
|
DE_ASSERT(semaphore);
|
payload.semaphore = semaphore;
|
}
|
};
|
|
enum WindowState
|
{
|
WINDOWSTATE_NOT_CREATED = 0, //!< Framework hasn't signaled window creation.
|
WINDOWSTATE_NOT_INITIALIZED, //!< Framework hasn't signaled first resize after creation and thus size is not final.
|
WINDOWSTATE_READY, //!< Window is ready for use.
|
WINDOWSTATE_DESTROYED, //!< Window has been destroyed.
|
|
WINDOWSTATE_LAST
|
};
|
|
typedef de::ThreadSafeRingBuffer<Message> MessageQueue;
|
|
class RenderThread : private de::Thread
|
{
|
public:
|
RenderThread (NativeActivity& activity);
|
~RenderThread (void);
|
|
void start (void);
|
void resume (void);
|
void pause (void);
|
void stop (void);
|
|
void enqueue (const Message& message);
|
void sync (void);
|
|
void run (void);
|
|
protected:
|
virtual void onInputEvent (AInputEvent* event) { DE_UNREF(event); }
|
virtual void onWindowCreated (ANativeWindow* window) = 0;
|
virtual void onWindowResized (ANativeWindow* window) = 0;
|
virtual void onWindowDestroyed (ANativeWindow* window) = 0;
|
virtual bool render (void) = 0;
|
|
NativeActivity& getNativeActivity (void) { return m_activity; }
|
|
private:
|
void processMessage (const Message& message);
|
|
// Shared state.
|
NativeActivity& m_activity;
|
MessageQueue m_msgQueue;
|
|
// Parent thread state.
|
bool m_threadRunning;
|
|
// Thread state.
|
AInputQueue* m_inputQueue;
|
WindowState m_windowState;
|
ANativeWindow* m_window;
|
bool m_paused; //!< Is rendering paused?
|
bool m_finish; //!< Has thread received FINISH message?
|
bool m_receivedFirstResize; //!< Has the first onWindowResized been processed?
|
};
|
|
class RenderActivity : public NativeActivity
|
{
|
public:
|
RenderActivity (ANativeActivity* activity);
|
virtual ~RenderActivity (void);
|
|
virtual void onStart (void);
|
virtual void onResume (void);
|
virtual void onPause (void);
|
virtual void onStop (void);
|
virtual void onDestroy (void);
|
|
virtual void onNativeWindowCreated (ANativeWindow* window);
|
virtual void onNativeWindowResized (ANativeWindow* window);
|
virtual void onNativeWindowRedrawNeeded (ANativeWindow* window);
|
virtual void onNativeWindowDestroyed (ANativeWindow* window);
|
|
virtual void onInputQueueCreated (AInputQueue* queue);
|
virtual void onInputQueueDestroyed (AInputQueue* queue);
|
|
protected:
|
//! Set rendering thread. Must be called at construction time.
|
void setThread (RenderThread* thread);
|
|
private:
|
RenderActivity (const RenderActivity& other);
|
RenderActivity& operator= (const RenderActivity& other);
|
|
RenderThread* m_thread;
|
};
|
|
} // Android
|
} // tcu
|
|
#endif // _TCUANDROIDRENDERACTIVITY_HPP
|
