xref: /external/deqp/framework/platform/android/tcuAndroidExecService.cpp

/*-------------------------------------------------------------------------
 * 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