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 ExecServer. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuAndroidExecService.hpp" 25 #include "deFile.h" 26 #include "deClock.h" 27 28 #if 0 29 # define DBG_PRINT(ARGS) print ARGS 30 #else 31 # define DBG_PRINT(ARGS) 32 #endif 33 34 namespace tcu 35 { 36 namespace Android 37 { 38 39 static const char* LOG_FILE_NAME = "/sdcard/dEQP-log.qpa"; 40 41 enum 42 { 43 PROCESS_START_TIMEOUT = 5000*1000, //!< Timeout in usec. 44 PROCESS_QUERY_INTERVAL = 1000*1000 //!< Running query interval limit in usec. 45 }; 46 47 static void checkJniException (JNIEnv* env, const char* file, int line) 48 { 49 if (env->ExceptionOccurred()) 50 { 51 env->ExceptionDescribe(); 52 env->ExceptionClear(); 53 throw InternalError("JNI Exception", DE_NULL, file, line); 54 } 55 } 56 57 #define JNI_CHECK(EXPR) do { checkJniException(env, __FILE__, __LINE__); TCU_CHECK_INTERNAL(EXPR); } while (deGetFalse()) 58 59 // TestProcess 60 61 TestProcess::TestProcess (JavaVM* vm, jobject context) 62 : m_vm (vm) 63 , m_remoteCls (0) 64 , m_remote (0) 65 , m_start (0) 66 , m_kill (0) 67 , m_isRunning (0) 68 , m_launchTime (0) 69 , m_lastQueryTime (0) 70 , m_lastRunningStatus (false) 71 , m_logReader (xs::LOG_BUFFER_BLOCK_SIZE, xs::LOG_BUFFER_NUM_BLOCKS) 72 { 73 DBG_PRINT(("TestProcess::TestProcess(%p, %p)", vm, context)); 74 75 JNIEnv* env = getCurrentThreadEnv(); 76 jobject remote = 0; 77 jstring logFileName = 0; 78 79 try 80 { 81 jclass remoteCls = 0; 82 jmethodID ctorId = 0; 83 84 remoteCls = env->FindClass("com/drawelements/deqp/testercore/RemoteAPI"); 85 JNI_CHECK(remoteCls); 86 87 // Acquire global reference to RemoteAPI class. 88 m_remoteCls = reinterpret_cast<jclass>(env->NewGlobalRef(remoteCls)); 89 JNI_CHECK(m_remoteCls); 90 env->DeleteLocalRef(remoteCls); 91 remoteCls = 0; 92 93 ctorId = env->GetMethodID(m_remoteCls, "<init>", "(Landroid/content/Context;Ljava/lang/String;)V"); 94 JNI_CHECK(ctorId); 95 96 logFileName = env->NewStringUTF(LOG_FILE_NAME); 97 JNI_CHECK(logFileName); 98 99 // Create RemoteAPI instance. 100 remote = env->NewObject(m_remoteCls, ctorId, context, logFileName); 101 JNI_CHECK(remote); 102 103 env->DeleteLocalRef(logFileName); 104 logFileName = 0; 105 106 // Acquire global reference to remote. 107 m_remote = env->NewGlobalRef(remote); 108 JNI_CHECK(m_remote); 109 env->DeleteLocalRef(remote); 110 remote = 0; 111 112 m_start = env->GetMethodID(m_remoteCls, "start", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z"); 113 JNI_CHECK(m_start); 114 115 m_kill = env->GetMethodID(m_remoteCls, "kill", "()Z"); 116 JNI_CHECK(m_kill); 117 118 m_isRunning = env->GetMethodID(m_remoteCls, "isRunning", "()Z"); 119 JNI_CHECK(m_isRunning); 120 } 121 catch (...) 122 { 123 if (logFileName) 124 env->DeleteLocalRef(logFileName); 125 if (remote) 126 env->DeleteLocalRef(remote); 127 if (m_remoteCls) 128 env->DeleteGlobalRef(reinterpret_cast<jobject>(m_remoteCls)); 129 if (m_remote) 130 env->DeleteGlobalRef(m_remote); 131 throw; 132 } 133 } 134 135 TestProcess::~TestProcess (void) 136 { 137 DBG_PRINT(("TestProcess::~TestProcess()")); 138 139 try 140 { 141 JNIEnv* env = getCurrentThreadEnv(); 142 env->DeleteGlobalRef(m_remote); 143 env->DeleteGlobalRef(m_remoteCls); 144 } 145 catch (...) 146 { 147 } 148 } 149 150 void TestProcess::start (const char* name, const char* params, const char* workingDir, const char* caseList) 151 { 152 DBG_PRINT(("TestProcess::start(%s, %s, %s, ...)", name, params, workingDir)); 153 154 JNIEnv* env = getCurrentThreadEnv(); 155 jstring nameStr = 0; 156 jstring paramsStr = 0; 157 jstring caseListStr = 0; 158 159 DE_UNREF(workingDir); 160 161 // Remove old log file if such exists. 162 if (deFileExists(LOG_FILE_NAME)) 163 { 164 if (!deDeleteFile(LOG_FILE_NAME) || deFileExists(LOG_FILE_NAME)) 165 throw xs::TestProcessException(std::string("Failed to remove '") + LOG_FILE_NAME + "'"); 166 } 167 168 try 169 { 170 nameStr = env->NewStringUTF(name); 171 JNI_CHECK(nameStr); 172 173 paramsStr = env->NewStringUTF(params); 174 JNI_CHECK(paramsStr); 175 176 caseListStr = env->NewStringUTF(caseList); 177 JNI_CHECK(caseListStr); 178 179 jboolean res = env->CallBooleanMethod(m_remote, m_start, nameStr, paramsStr, caseListStr); 180 checkJniException(env, __FILE__, __LINE__); 181 182 if (res == JNI_FALSE) 183 throw xs::TestProcessException("Failed to launch activity"); 184 185 m_launchTime = deGetMicroseconds(); 186 m_lastQueryTime = m_launchTime; 187 m_lastRunningStatus = true; 188 } 189 catch (...) 190 { 191 if (nameStr) 192 env->DeleteLocalRef(nameStr); 193 if (paramsStr) 194 env->DeleteLocalRef(paramsStr); 195 if (caseListStr) 196 env->DeleteLocalRef(caseListStr); 197 throw; 198 } 199 200 env->DeleteLocalRef(nameStr); 201 env->DeleteLocalRef(paramsStr); 202 env->DeleteLocalRef(caseListStr); 203 } 204 205 void TestProcess::terminate (void) 206 { 207 DBG_PRINT(("TestProcess::terminate()")); 208 209 JNIEnv* env = getCurrentThreadEnv(); 210 jboolean res = env->CallBooleanMethod(m_remote, m_kill); 211 checkJniException(env, __FILE__, __LINE__); 212 DE_UNREF(res); // Failure to kill process is ignored. 213 } 214 215 void TestProcess::cleanup (void) 216 { 217 DBG_PRINT(("TestProcess::cleanup()")); 218 219 terminate(); 220 m_logReader.stop(); 221 } 222 223 bool TestProcess::isRunning (void) 224 { 225 deUint64 curTime = deGetMicroseconds(); 226 227 // On Android process launch is asynchronous so we don't want to poll for process until after some time. 228 if (curTime-m_launchTime < PROCESS_START_TIMEOUT || 229 curTime-m_lastQueryTime < PROCESS_QUERY_INTERVAL) 230 return m_lastRunningStatus; 231 232 JNIEnv* env = getCurrentThreadEnv(); 233 jboolean res = env->CallBooleanMethod(m_remote, m_isRunning); 234 checkJniException(env, __FILE__, __LINE__); 235 236 DBG_PRINT(("TestProcess::isRunning(): %s", res == JNI_TRUE ? "true" : "false")); 237 m_lastQueryTime = curTime; 238 m_lastRunningStatus = res == JNI_TRUE; 239 240 return m_lastRunningStatus; 241 } 242 243 JNIEnv* TestProcess::getCurrentThreadEnv (void) 244 { 245 JNIEnv* env = DE_NULL; 246 jint ret = m_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6); 247 248 if (ret == JNI_OK) 249 return env; 250 else 251 throw InternalError("GetEnv() failed"); 252 } 253 254 int TestProcess::readTestLog (deUint8* dst, int numBytes) 255 { 256 if (!m_logReader.isRunning()) 257 { 258 if (deGetMicroseconds() - m_launchTime > xs::LOG_FILE_TIMEOUT*1000) 259 { 260 // Timeout, kill process. 261 terminate(); 262 DBG_PRINT(("TestProcess:readTestLog(): Log file timeout occurred!")); 263 return 0; // \todo [2013-08-13 pyry] Throw exception? 264 } 265 266 if (!deFileExists(LOG_FILE_NAME)) 267 return 0; 268 269 // Start reader. 270 m_logReader.start(LOG_FILE_NAME); 271 } 272 273 DE_ASSERT(m_logReader.isRunning()); 274 return m_logReader.read(dst, numBytes); 275 } 276 277 int TestProcess::getExitCode (void) const 278 { 279 return 0; 280 } 281 282 int TestProcess::readInfoLog (deUint8* dst, int numBytes) 283 { 284 // \todo [2012-11-12 pyry] Read device log. 285 DE_UNREF(dst && numBytes); 286 return 0; 287 } 288 289 // ExecutionServer 290 291 ExecutionServer::ExecutionServer (JavaVM* vm, xs::TestProcess* testProcess, deSocketFamily family, int port, RunMode runMode) 292 : xs::ExecutionServer (testProcess, family, port, runMode) 293 , m_vm (vm) 294 { 295 } 296 297 xs::ConnectionHandler* ExecutionServer::createHandler (de::Socket* socket, const de::SocketAddress& clientAddress) 298 { 299 DE_UNREF(clientAddress); 300 return new ConnectionHandler(m_vm, this, socket); 301 } 302 303 // ConnectionHandler 304 305 ConnectionHandler::ConnectionHandler (JavaVM* vm, xs::ExecutionServer* server, de::Socket* socket) 306 : xs::ExecutionRequestHandler (server, socket) 307 , m_vm (vm) 308 { 309 } 310 311 void ConnectionHandler::run (void) 312 { 313 JNIEnv* env = DE_NULL; 314 if (m_vm->AttachCurrentThread(&env, DE_NULL) != 0) 315 { 316 print("AttachCurrentThread() failed"); 317 return; 318 } 319 320 xs::ExecutionRequestHandler::run(); 321 322 if (m_vm->DetachCurrentThread() != 0) 323 print("DetachCurrentThread() failed"); 324 } 325 326 // ServerThread 327 328 ServerThread::ServerThread (JavaVM* vm, xs::TestProcess* process, deSocketFamily family, int port) 329 : m_server(vm, process, family, port, xs::ExecutionServer::RUNMODE_FOREVER) 330 { 331 } 332 333 void ServerThread::run (void) 334 { 335 try 336 { 337 m_server.runServer(); 338 } 339 catch (const std::exception& e) 340 { 341 die("ServerThread::run(): %s", e.what()); 342 } 343 } 344 345 void ServerThread::stop (void) 346 { 347 m_server.stopServer(); 348 join(); 349 } 350 351 // ExecService 352 353 ExecService::ExecService (JavaVM* vm, jobject context, int port, deSocketFamily family) 354 : m_process (vm, context) 355 , m_thread (vm, &m_process, family, port) 356 { 357 } 358 359 ExecService::~ExecService (void) 360 { 361 } 362 363 void ExecService::start (void) 364 { 365 m_thread.start(); 366 } 367 368 void ExecService::stop (void) 369 { 370 m_thread.stop(); 371 } 372 373 } // Android 374 } // tcu 375
