framework/platform/android/tcuAndroidWindow.cpp

   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         {
  76                 // Reset buffer size and format back to initial state
  77                 ANativeWindow_setBuffersGeometry(m_window, 0, 0, 0);
  78
  79                 m_state = STATE_AVAILABLE;
  80         }
  81         else if (m_state == STATE_PENDING_DESTROY)
  82                 m_state = STATE_READY_FOR_DESTROY;
  83         else
  84                 DE_FATAL("Invalid window state");
  85 }
  86
  87 void Window::markForDestroy (void)
  88 {
  89         de::ScopedLock lock(m_stateLock);
  90
  91         if (m_state == STATE_AVAILABLE)
  92                 m_state = STATE_READY_FOR_DESTROY;
  93         else if (m_state == STATE_IN_USE)
  94                 m_state = STATE_PENDING_DESTROY;
  95         else
  96                 DE_FATAL("Invalid window state");
  97 }
  98
  99 bool Window::isPendingDestroy (void) const
 100 {
 101         de::ScopedLock lock(m_stateLock);
 102         return m_state == STATE_PENDING_DESTROY;
 103 }
 104
 105 bool Window::tryAcquireForDestroy (bool onlyMarked)
 106 {
 107         de::ScopedLock lock(m_stateLock);
 108
 109         if (m_state == STATE_READY_FOR_DESTROY ||
 110                 (!onlyMarked && m_state == STATE_AVAILABLE))
 111         {
 112                 m_state = STATE_ACQUIRED_FOR_DESTROY;
 113                 return true;
 114         }
 115         else
 116                 return false;
 117 }
 118
 119 // WindowRegistry
 120
 121 WindowRegistry::WindowRegistry (void)
 122 {
 123 }
 124
 125 WindowRegistry::~WindowRegistry (void)
 126 {
 127         for (vector<Window*>::const_iterator winIter = m_windows.begin(); winIter != m_windows.end(); winIter++)
 128         {
 129                 Window* const window = *winIter;
 130
 131                 if (window->tryAcquireForDestroy(false))
 132                         delete window;
 133                 else
 134                 {
 135                         print("ERROR: Window was not available for deletion, leaked tcu::Android::Window!\n");
 136                         DE_FATAL("Window leaked");
 137                 }
 138         }
 139 }
 140
 141 void WindowRegistry::addWindow (ANativeWindow* window)
 142 {
 143         m_windows.reserve(m_windows.size()+1);
 144         m_windows.push_back(new Window(window));
 145 }
 146
 147 void WindowRegistry::destroyWindow (ANativeWindow* rawHandle)
 148 {
 149         for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
 150         {
 151                 Window* const window = m_windows[ndx];
 152
 153                 if (window->getNativeWindow() == rawHandle)
 154                 {
 155                         if (window->tryAcquireForDestroy(false))
 156                         {
 157                                 delete window;
 158                                 m_windows[ndx] = m_windows.back();
 159                                 m_windows.pop_back();
 160                         }
 161                         else
 162                                 window->markForDestroy();
 163
 164                         return;
 165                 }
 166         }
 167
 168         throw tcu::InternalError("Window not registered", DE_NULL, __FILE__, __LINE__);
 169 }
 170
 171 Window* WindowRegistry::tryAcquireWindow (void)
 172 {
 173         for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
 174         {
 175                 Window* const window = m_windows[ndx];
 176
 177                 if (window->tryAcquire())
 178                         return window;
 179         }
 180
 181         return DE_NULL;
 182 }
 183
 184 void WindowRegistry::garbageCollect (void)
 185 {
 186         for (int ndx = 0; ndx < (int)m_windows.size(); ++ndx)
 187         {
 188                 Window* const window = m_windows[ndx];
 189
 190                 if (window->tryAcquireForDestroy(true))
 191                 {
 192                         delete window;
 193                         m_windows[ndx] = m_windows.back();
 194                         m_windows.pop_back();
 195                         ndx -= 1;
 196                 }
 197         }
 198 }
 199
 200 } // Android
 201 } // tcu