Home | History | Annotate | Download | only in android 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program Tester Core
      3  * ----------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      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
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     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.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Android window.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "tcuAndroidWindow.hpp"
     25 
     26 namespace tcu
     27 {
     28 namespace Android
     29 {
     30 
     31 using std::vector;
     32 
     33 // Window
     34 
     35 Window::Window (ANativeWindow* window)
     36 	: m_window	(window)
     37 	, m_state	(STATE_AVAILABLE)
     38 {
     39 }
     40 
     41 Window::~Window (void)
     42 {
     43 }
     44 
     45 void Window::setBuffersGeometry (int width, int height, int32_t format)
     46 {
     47 	ANativeWindow_setBuffersGeometry(m_window, width, height, format);
     48 }
     49 
     50 IVec2 Window::getSize (void) const
     51 {
     52 	const int32_t	width	= ANativeWindow_getWidth(m_window);
     53 	const int32_t	height	= ANativeWindow_getHeight(m_window);
     54 	return IVec2(width, height);
     55 }
     56 
     57 bool Window::tryAcquire (void)
     58 {
     59 	de::ScopedLock lock(m_stateLock);
     60 
     61 	if (m_state == STATE_AVAILABLE)
     62 	{
     63 		m_state = STATE_IN_USE;
     64 		return true;
     65 	}
     66 	else
     67 		return false;
     68 }
     69 
     70 void Window::release (void)
     71 {
     72 	de::ScopedLock lock(m_stateLock);
     73 
     74 	if (m_state == STATE_IN_USE)
     75 		m_state = STATE_AVAILABLE;
     76 	else if (m_state == STATE_PENDING_DESTROY)
     77 		m_state = STATE_READY_FOR_DESTROY;
     78 	else
     79 		DE_ASSERT(!"Invalid window state");
     80 }
     81 
     82 void Window::markForDestroy (void)
     83 {
     84 	de::ScopedLock lock(m_stateLock);
     85 
     86 	if (m_state == STATE_AVAILABLE)
     87 		m_state = STATE_READY_FOR_DESTROY;
     88 	else if (m_state == STATE_IN_USE)
     89 		m_state = STATE_PENDING_DESTROY;
     90 	else
     91 		DE_ASSERT(!"Invalid window state");
     92 }
     93 
     94 bool Window::isPendingDestroy (void) const
     95 {
     96 	de::ScopedLock lock(m_stateLock);
     97 	return m_state == STATE_PENDING_DESTROY;
     98 }
     99 
    100 bool Window::tryAcquireForDestroy (bool onlyMarked)
    101 {
    102 	de::ScopedLock lock(m_stateLock);
    103 
    104 	if (m_state == STATE_READY_FOR_DESTROY ||
    105 		(!onlyMarked && m_state == STATE_AVAILABLE))
    106 	{
    107 		m_state = STATE_ACQUIRED_FOR_DESTROY;
    108 		return true;
    109 	}
    110 	else
    111 		return false;
    112 }
    113 
    114 // WindowRegistry
    115 
    116 WindowRegistry::WindowRegistry (void)
    117 {
    118 }
    119 
    120 WindowRegistry::~WindowRegistry (void)
    121 {
    122 	for (vector<Window*>::const_iterator winIter = m_windows.begin(); winIter != m_windows.end(); winIter++)
    123 	{
    124 		Window* const window = *winIter;
    125 
    126 		if (window->tryAcquireForDestroy(false))
    127 			delete window;
    128 		else
    129 		{
    130 			print("ERROR: Window was not available for deletion, leaked tcu::Android::Window!\n");
    131 			DE_ASSERT(!"Window leaked");
    132 		}
    133 	}
    134 }
    135 
    136 void WindowRegistry::addWindow (ANativeWindow* window)
    137 {
    138 	m_windows.reserve(m_windows.size()+1);
    139 	m_windows.push_back(new Window(window));
    140 }
    141 
    142 void WindowRegistry::destroyWindow (ANativeWindow* rawHandle)
    143 {
    144 	for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
    145 	{
    146 		Window* const window = m_windows[ndx];
    147 
    148 		if (window->getNativeWindow() == rawHandle)
    149 		{
    150 			if (window->tryAcquireForDestroy(false))
    151 			{
    152 				delete window;
    153 				m_windows[ndx] = m_windows.back();
    154 				m_windows.pop_back();
    155 			}
    156 			else
    157 				window->markForDestroy();
    158 
    159 			return;
    160 		}
    161 	}
    162 
    163 	throw tcu::InternalError("Window not registered", DE_NULL, __FILE__, __LINE__);
    164 }
    165 
    166 Window* WindowRegistry::tryAcquireWindow (void)
    167 {
    168 	for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
    169 	{
    170 		Window* const window = m_windows[ndx];
    171 
    172 		if (window->tryAcquire())
    173 			return window;
    174 	}
    175 
    176 	return DE_NULL;
    177 }
    178 
    179 void WindowRegistry::garbageCollect (void)
    180 {
    181 	for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
    182 	{
    183 		Window* const window = m_windows[ndx];
    184 
    185 		if (window->tryAcquireForDestroy(true))
    186 		{
    187 			delete window;
    188 			m_windows[ndx] = m_windows.back();
    189 			m_windows.pop_back();
    190 			ndx -= 1;
    191 		}
    192 	}
    193 }
    194 
    195 } // Android
    196 } // tcu
    197