/*-------------------------------------------------------------------------
|
* 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 Android ExecServer.
|
*//*--------------------------------------------------------------------*/
|
|
#include "tcuAndroidExecService.hpp"
|
#include "deFile.h"
|
#include "deClock.h"
|
|
#if 0
|
# define DBG_PRINT(ARGS) print ARGS
|
#else
|
# define DBG_PRINT(ARGS)
|
#endif
|
|
namespace tcu
|
{
|
namespace Android
|
{
|
|
static const char* LOG_FILE_NAME = "/sdcard/dEQP-log.qpa";
|
|
enum
|
{
|
PROCESS_START_TIMEOUT = 5000*1000, //!< Timeout in usec.
|
PROCESS_QUERY_INTERVAL = 1000*1000 //!< Running query interval limit in usec.
|
};
|
|
static void checkJniException (JNIEnv* env, const char* file, int line)
|
{
|
if (env->ExceptionOccurred())
|
{
|
env->ExceptionDescribe();
|
env->ExceptionClear();
|
throw InternalError("JNI Exception", DE_NULL, file, line);
|
}
|
}
|
|
#define JNI_CHECK(EXPR) do { checkJniException(env, __FILE__, __LINE__); TCU_CHECK_INTERNAL(EXPR); } while (deGetFalse())
|
|
// TestProcess
|
|
TestProcess::TestProcess (JavaVM* vm, jobject context)
|
: m_vm (vm)
|
, m_remoteCls (0)
|
, m_remote (0)
|
, m_start (0)
|
, m_kill (0)
|
, m_isRunning (0)
|
, m_launchTime (0)
|
, m_lastQueryTime (0)
|
, m_lastRunningStatus (false)
|
, m_logReader (xs::LOG_BUFFER_BLOCK_SIZE, xs::LOG_BUFFER_NUM_BLOCKS)
|
{
|
DBG_PRINT(("TestProcess::TestProcess(%p, %p)", vm, context));
|
|
JNIEnv* env = getCurrentThreadEnv();
|
jobject remote = 0;
|
jstring logFileName = 0;
|
|
try
|
{
|
jclass remoteCls = 0;
|
jmethodID ctorId = 0;
|
|
remoteCls = env->FindClass("com/drawelements/deqp/testercore/RemoteAPI");
|
JNI_CHECK(remoteCls);
|
|
// Acquire global reference to RemoteAPI class.
|
m_remoteCls = reinterpret_cast<jclass>(env->NewGlobalRef(remoteCls));
|
JNI_CHECK(m_remoteCls);
|
env->DeleteLocalRef(remoteCls);
|
remoteCls = 0;
|
|
ctorId = env->GetMethodID(m_remoteCls, "<init>", "(Landroid/content/Context;Ljava/lang/String;)V");
|
JNI_CHECK(ctorId);
|
|
logFileName = env->NewStringUTF(LOG_FILE_NAME);
|
JNI_CHECK(logFileName);
|
|
// Create RemoteAPI instance.
|
remote = env->NewObject(m_remoteCls, ctorId, context, logFileName);
|
JNI_CHECK(remote);
|
|
env->DeleteLocalRef(logFileName);
|
logFileName = 0;
|
|
// Acquire global reference to remote.
|
m_remote = env->NewGlobalRef(remote);
|
JNI_CHECK(m_remote);
|
env->DeleteLocalRef(remote);
|
remote = 0;
|
|
m_start = env->GetMethodID(m_remoteCls, "start", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z");
|
JNI_CHECK(m_start);
|
|
m_kill = env->GetMethodID(m_remoteCls, "kill", "()Z");
|
JNI_CHECK(m_kill);
|
|
m_isRunning = env->GetMethodID(m_remoteCls, "isRunning", "()Z");
|
JNI_CHECK(m_isRunning);
|
}
|
catch (...)
|
{
|
if (logFileName)
|
env->DeleteLocalRef(logFileName);
|
if (remote)
|
env->DeleteLocalRef(remote);
|
if (m_remoteCls)
|
env->DeleteGlobalRef(reinterpret_cast<jobject>(m_remoteCls));
|
if (m_remote)
|
env->DeleteGlobalRef(m_remote);
|
throw;
|
}
|
}
|
|
TestProcess::~TestProcess (void)
|
{
|
DBG_PRINT(("TestProcess::~TestProcess()"));
|
|
try
|
{
|
JNIEnv* env = getCurrentThreadEnv();
|
env->DeleteGlobalRef(m_remote);
|
env->DeleteGlobalRef(m_remoteCls);
|
}
|
catch (...)
|
{
|
}
|
}
|
|
void TestProcess::start (const char* name, const char* params, const char* workingDir, const char* caseList)
|
{
|
DBG_PRINT(("TestProcess::start(%s, %s, %s, ...)", name, params, workingDir));
|
|
JNIEnv* env = getCurrentThreadEnv();
|
jstring nameStr = 0;
|
jstring paramsStr = 0;
|
jstring caseListStr = 0;
|
|
DE_UNREF(workingDir);
|
|
// Remove old log file if such exists.
|
if (deFileExists(LOG_FILE_NAME))
|
{
|
if (!deDeleteFile(LOG_FILE_NAME) || deFileExists(LOG_FILE_NAME))
|
throw xs::TestProcessException(std::string("Failed to remove '") + LOG_FILE_NAME + "'");
|
}
|
|
try
|
{
|
nameStr = env->NewStringUTF(name);
|
JNI_CHECK(nameStr);
|
|
paramsStr = env->NewStringUTF(params);
|
JNI_CHECK(paramsStr);
|
|
caseListStr = env->NewStringUTF(caseList);
|
JNI_CHECK(caseListStr);
|
|
jboolean res = env->CallBooleanMethod(m_remote, m_start, nameStr, paramsStr, caseListStr);
|
checkJniException(env, __FILE__, __LINE__);
|
|
if (res == JNI_FALSE)
|
throw xs::TestProcessException("Failed to launch activity");
|
|
m_launchTime = deGetMicroseconds();
|
m_lastQueryTime = m_launchTime;
|
m_lastRunningStatus = true;
|
}
|
catch (...)
|
{
|
if (nameStr)
|
env->DeleteLocalRef(nameStr);
|
if (paramsStr)
|
env->DeleteLocalRef(paramsStr);
|
if (caseListStr)
|
env->DeleteLocalRef(caseListStr);
|
throw;
|
}
|
|
env->DeleteLocalRef(nameStr);
|
env->DeleteLocalRef(paramsStr);
|
env->DeleteLocalRef(caseListStr);
|
}
|
|
void TestProcess::terminate (void)
|
{
|
DBG_PRINT(("TestProcess::terminate()"));
|
|
JNIEnv* env = getCurrentThreadEnv();
|
jboolean res = env->CallBooleanMethod(m_remote, m_kill);
|
checkJniException(env, __FILE__, __LINE__);
|
DE_UNREF(res); // Failure to kill process is ignored.
|
}
|
|
void TestProcess::cleanup (void)
|
{
|
DBG_PRINT(("TestProcess::cleanup()"));
|
|
terminate();
|
m_logReader.stop();
|
}
|
|
bool TestProcess::isRunning (void)
|
{
|
deUint64 curTime = deGetMicroseconds();
|
|
// On Android process launch is asynchronous so we don't want to poll for process until after some time.
|
if (curTime-m_launchTime < PROCESS_START_TIMEOUT ||
|
curTime-m_lastQueryTime < PROCESS_QUERY_INTERVAL)
|
return m_lastRunningStatus;
|
|
JNIEnv* env = getCurrentThreadEnv();
|
jboolean res = env->CallBooleanMethod(m_remote, m_isRunning);
|
checkJniException(env, __FILE__, __LINE__);
|
|
DBG_PRINT(("TestProcess::isRunning(): %s", res == JNI_TRUE ? "true" : "false"));
|
m_lastQueryTime = curTime;
|
m_lastRunningStatus = res == JNI_TRUE;
|
|
return m_lastRunningStatus;
|
}
|
|
JNIEnv* TestProcess::getCurrentThreadEnv (void)
|
{
|
JNIEnv* env = DE_NULL;
|
jint ret = m_vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
|
|
if (ret == JNI_OK)
|
return env;
|
else
|
throw InternalError("GetEnv() failed");
|
}
|
|
int TestProcess::readTestLog (deUint8* dst, int numBytes)
|
{
|
if (!m_logReader.isRunning())
|
{
|
if (deGetMicroseconds() - m_launchTime > xs::LOG_FILE_TIMEOUT*1000)
|
{
|
// Timeout, kill process.
|
terminate();
|
DBG_PRINT(("TestProcess:readTestLog(): Log file timeout occurred!"));
|
return 0; // \todo [2013-08-13 pyry] Throw exception?
|
}
|
|
if (!deFileExists(LOG_FILE_NAME))
|
return 0;
|
|
// Start reader.
|
m_logReader.start(LOG_FILE_NAME);
|
}
|
|
DE_ASSERT(m_logReader.isRunning());
|
return m_logReader.read(dst, numBytes);
|
}
|
|
int TestProcess::getExitCode (void) const
|
{
|
return 0;
|
}
|
|
int TestProcess::readInfoLog (deUint8* dst, int numBytes)
|
{
|
// \todo [2012-11-12 pyry] Read device log.
|
DE_UNREF(dst && numBytes);
|
return 0;
|
}
|
|
// ExecutionServer
|
|
ExecutionServer::ExecutionServer (JavaVM* vm, xs::TestProcess* testProcess, deSocketFamily family, int port, RunMode runMode)
|
: xs::ExecutionServer (testProcess, family, port, runMode)
|
, m_vm (vm)
|
{
|
}
|
|
xs::ConnectionHandler* ExecutionServer::createHandler (de::Socket* socket, const de::SocketAddress& clientAddress)
|
{
|
DE_UNREF(clientAddress);
|
return new ConnectionHandler(m_vm, this, socket);
|
}
|
|
// ConnectionHandler
|
|
ConnectionHandler::ConnectionHandler (JavaVM* vm, xs::ExecutionServer* server, de::Socket* socket)
|
: xs::ExecutionRequestHandler (server, socket)
|
, m_vm (vm)
|
{
|
}
|
|
void ConnectionHandler::run (void)
|
{
|
JNIEnv* env = DE_NULL;
|
if (m_vm->AttachCurrentThread(&env, DE_NULL) != 0)
|
{
|
print("AttachCurrentThread() failed");
|
return;
|
}
|
|
xs::ExecutionRequestHandler::run();
|
|
if (m_vm->DetachCurrentThread() != 0)
|
print("DetachCurrentThread() failed");
|
}
|
|
// ServerThread
|
|
ServerThread::ServerThread (JavaVM* vm, xs::TestProcess* process, deSocketFamily family, int port)
|
: m_server(vm, process, family, port, xs::ExecutionServer::RUNMODE_FOREVER)
|
{
|
}
|
|
void ServerThread::run (void)
|
{
|
try
|
{
|
m_server.runServer();
|
}
|
catch (const std::exception& e)
|
{
|
die("ServerThread::run(): %s", e.what());
|
}
|
}
|
|
void ServerThread::stop (void)
|
{
|
m_server.stopServer();
|
join();
|
}
|
|
// ExecService
|
|
ExecService::ExecService (JavaVM* vm, jobject context, int port, deSocketFamily family)
|
: m_process (vm, context)
|
, m_thread (vm, &m_process, family, port)
|
{
|
}
|
|
ExecService::~ExecService (void)
|
{
|
}
|
|
void ExecService::start (void)
|
{
|
m_thread.start();
|
}
|
|
void ExecService::stop (void)
|
{
|
m_thread.stop();
|
}
|
|
} // Android
|
} // tcu
|
