bool ShellCommandService::executeService(TasCommandModel& model, TasResponse& response)
{
if(model.service() == serviceName() ){
TasCommand* command = getCommandParameters(model, "shellCommand");
if(command && !command->text().isEmpty()){
if (command->parameter("detached") == "true"){
detachedShellCommand(command->text(), response);
}
else if (command->parameter("threaded") == "true") {
shellTask(command->text(), response);
}
else if (command->parameter("status") == "true") {
TasCommand* command = getCommandParameters(model, "shellCommand");
if(command && !command->text().isEmpty()){
qint64 pid = command->text().toInt();
if (command->parameter("kill") == "true") {
killTask(pid, response);
} else {
shellStatus(pid, response);
}
}
}
else{
shellCommand(command->text(), response);
}
}
else{
response.setErrorMessage(NO_COMMAND_TO_EXECUTE);
}
return true;
}
else{
return false;
}
}
bool RegisterService::executeService(TasCommandModel& model, TasResponse& response)
{
if(model.service() == serviceName() ){
TasCommand* command = getCommandParameters(model, COMMAND_REGISTER);
if(command){
ClientDetails client;
bool ok;
//this should not really ever fail (app pid used to generate in client side)
quint64 clientPid = command->parameter(PLUGIN_ID).toULongLong(&ok);
client.processId = clientPid;
client.processName = command->parameter(PLUGIN_NAME);
#ifdef Q_OS_SYMBIAN
client.applicationUid = command->parameter(APP_UID);
#endif
client.pluginType = command->parameter(PLUGIN_TYPE);
client.socket = response.requester();
registerPlugin(client);
}
else{
command = getCommandParameters(model, COMMAND_UNREGISTER);
if(command){
unRegisterPlugin(*command);
}
}
return true;
}
else{
return false;
}
}
void ViewItemHandler::setCheckState(QTreeWidget* treeWidget, TasCommand& command)
{
Qt::CheckState newState = static_cast<Qt::CheckState>(command.parameter("state").toInt());
int column = command.parameter("column").toInt();
//look for the item
QTreeWidgetItem* item = findTreeItem(treeWidget, command.parameter("item"));
if(item){
item->setCheckState(column, newState);
}
}
void RegisterService::unRegisterPlugin(TasCommand& command)
{
bool ok;
//this should not really ever fail (app pid used to generate in client side)
quint64 clientPid = command.parameter("processId").toULongLong(&ok);
TasLogger::logger()->info("TasServer::serviceRequest: unregister plugin: " + QString::number(clientPid));
TasClientManager::instance()->removeClient(clientPid);
}
void ScreenshotService::getScreenshot(TasCommandModel& model, TasResponse& response)
{
QListIterator<TasTarget*> i(model.targetList());
QString errorMsg = PARSE_ERROR;
QImage screenshot;
QString pictureFormat = "PNG";
while (i.hasNext()) {
TasTarget* commandTarget = i.next();
QString targetId = commandTarget->id();
QString targetType = commandTarget->type();
TasCommand* command = commandTarget->findCommand("Screenshot");
// are required for command completion
if (targetId.isEmpty() || targetType.isEmpty() || !command) {
continue;
}
if (!command->parameter("format").isEmpty()) {
pictureFormat = command->parameter("format");
}
if (!isFormatSupported(pictureFormat)) {
errorMsg = "Given format " + pictureFormat + "is not supported. Supported formats are: PNG, JPEG and BMP.";
break;
}
bool draw = (command->parameter("draw") == "true");
QWidget* widget = 0;
QQuickWindow* qtQuickWindow = 0;
WId winId = 0;
QRect rect(0,0,-1,-1);
errorMsg = "Taking screenshot failed!";
if (targetType == TYPE_GRAPHICS_VIEW) {
//TasLogger::logger()->debug("TYPE_GRAPHICS_VIEW Target id:" + targetId);
QGraphicsItem* item = findGraphicsItem(targetId);
if (item) {
QGraphicsView* view = getViewForItem(item);
if(view) {
ItemLocationDetails locationDetails = TestabilityUtils::getItemLocationDetails(item);
rect = QRect(locationDetails.windowPoint.x(),
locationDetails.windowPoint.y(),
locationDetails.width,
locationDetails.height);
if (draw) {
widget = view->window();
} else {
winId = view->window()->winId();
}
} else {
errorMsg = "Could not find a GraphicsView for the GraphicsItem!";
}
} else {
errorMsg = "Could not find the GraphicsItem!";
}
} else if (targetType == TYPE_STANDARD_VIEW) {
//TasLogger::logger()->debug("TYPE_STANDARD_VIEW about to find widget Target id:" + targetId);
widget = findWidget(targetId);
if (widget) {
if ((widget->isWindow() && !draw) || widget->inherits("QDesktopWidget")) {
winId = widget->winId();
widget = 0;
} else if (!draw) {
QPoint point = widget->mapToGlobal(QPoint(0,0));
QPoint windowPoint = widget->window()->mapFromGlobal(point);
rect = QRect(windowPoint.x(),
windowPoint.y(),
widget->rect().width(),
widget->rect().width());
winId = widget->window()->winId();
widget = 0;
}
} else {
TasLogger::logger()->debug("ScreenshotService::executeService application has no visible ui!");
errorMsg = "Application has no visible ui!";
}
} else if (targetType == TYPE_QSCENEGRAPH) {
QQuickItem* item = TestabilityUtils::findQuickItem(targetId);
if (item) {
QPointF offset = item->mapToScene(QPointF(0,0));
rect = QRect(-offset.x(), -offset.y(), item->width(), item->height());
qtQuickWindow = item->window();
}
} else {
//TasLogger::logger()->debug("TYPE_APPLICATION_VIEW about to find application window Target id:" + targetId);
widget = getApplicationWidget();
if (!widget) {
QWindow *window = getApplicationWindow();
//in case no window false, return the desktop
qtQuickWindow = qobject_cast<QQuickWindow *>(window);
if (!window) {
widget = qApp->desktop();
}
}
}
if (widget) {
screenshot = widget->grab(rect).toImage();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", objectId(widget));
}
} else if (qtQuickWindow) {
screenshot = qtQuickWindow->grabWindow();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", objectId(qtQuickWindow));
}
} else if (winId) {
screenshot = QPixmap::grabWindow(winId, rect.x(), rect.y(), rect.width(), rect.height()).toImage();
if (!screenshot.isNull()) {
screenshot.setText("tas_id", QString::number(winId));
}
}
break;
}
if (!screenshot.isNull()) {
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
screenshot.save(&buffer, pictureFormat.toLatin1());
response.setData(bytes);
buffer.close();
} else {
response.setErrorMessage(errorMsg);
}
}
/*!
Passes service directed to plugins on to the correct plugin.
*/
void InfoLogger::performLogService(TasCommandModel& model, TasResponse& response)
{
TasTarget* target = model.findTarget(APPLICATION_TARGET);
if(!mTimer.isActive() && model.interval() > 100){
mTimer.setInterval(model.interval());
}
if(target){
TasCommand* command = target->findCommand(CPU);
if(command){
if(command->parameter(ACTION) == "start"){
QString fileName;
if(!makeFileName(command, CPU, fileName)){
response.setErrorMessage("File path must be defined for cpu logging!");
}
else{
mLastCpuTime = mDeviceUtils->currentProcessCpuTime();
mInterval.start();
mState |= CpuLogging;
if(mCpu){
delete mCpu;
mCpu = 0;
}
mCpu = openFile(fileName, command);
}
}
else if(command->parameter(ACTION) == "stop" || command->parameter(ACTION) == "load"){
loadCpuData(response, command);
}
}
command = target->findCommand(MEM);
if(command){
if(command->parameter(ACTION) == "start"){
QString fileName;
if(!makeFileName(command, MEM, fileName)){
response.setErrorMessage("File path must be defined for mem logging!");
}
else{
mState |= MemLogging;
if(mMem){
delete mMem;
mMem = 0;
}
mMem = openFile(fileName, command);
}
}
else if(command->parameter(ACTION) == "stop" || command->parameter(ACTION) == "load"){
loadMemData(response, command);
}
}
command = target->findCommand(GPU);
if(command){
if(command->parameter(ACTION) == "start"){
QString fileName;
if(!makeFileName(command, GPU, fileName)){
response.setErrorMessage("File path must be defined for mem logging!");
}
else{
mState |= GpuLogging;
if(mGpu){
delete mGpu;
mGpu = 0;
}
mGpu = openFile(fileName, command);
}
}
else if(command->parameter(ACTION) == "stop" || command->parameter(ACTION) == "load"){
loadGpuData(response, command);
}
}
command = target->findCommand(PWR);
if(command){
if(command->parameter(ACTION) == "start"){
QString fileName;
if(!makeFileName(command, PWR, fileName)){
response.setErrorMessage("File path must be defined for pwr logging!");
}
else{
mState |= PwrLogging;
if(mPwr){
delete mPwr;
mPwr = 0;
}
mPwr = openFile(fileName, command);
}
//to launch measuring if not running
mDeviceUtils->pwrDetails();
}
else if(command->parameter(ACTION) == "stop" || command->parameter(ACTION) == "load"){
loadPwrData(response, command);
if(command->parameter(ACTION) == "stop" ){
mDeviceUtils->stopPwrData();
}
}
}
//determines that does the interval need to be started or stopped
checkLoggerState();
}
}
