/****************************************************************************
* apps/testing/monkey/monkey_main.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you 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.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <errno.h>
#include <inttypes.h>
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include "monkey.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define MONKEY_PREFIX "monkey"
#define OPTARG_TO_VALUE(value, type, base) \
do \
{ \
FAR char *ptr; \
(value) = (type)strtoul(optarg, &ptr, (base)); \
if (*ptr != '\0') \
{ \
printf(MONKEY_PREFIX "Parameter error: -%c %s\n", ch, optarg); \
show_usage(argv[0], EXIT_FAILURE); \
} \
} while (0)
/****************************************************************************
* Private Type Declarations
****************************************************************************/
struct monkey_param_s
{
int dev_type_mask;
FAR const char *file_path;
int hor_res;
int ver_res;
int period_min;
int period_max;
};
enum monkey_wait_res_e
{
MONKEY_WAIT_RES_AGAIN,
MONKEY_WAIT_RES_PAUSE,
MONKEY_WAIT_RES_STOP,
MONKEY_WAIT_RES_ERROR,
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: show_usage
****************************************************************************/
static void show_usage(FAR const char *progname, int exitcode)
{
printf("\nUsage: %s"
" -t <hex-value> -f <string> -p <string> -s <string>\n",
progname);
printf("\nWhere:\n");
printf(" -t <hex-value> Device type mask: uinput = 0x%02X;"
" touch = 0x%02X; button = 0x%02X.\n",
MONKEY_UINPUT_TYPE_MASK,
MONKEY_DEV_TYPE_TOUCH,
MONKEY_DEV_TYPE_BUTTON);
printf(" -f <string> Recorder playback file path.\n");
printf(" -p <string> Period(ms) range: "
"<decimal-value min>-<decimal-value max>\n");
printf(" -s <string> Screen resolution: "
"<decimal-value hor_res>x<decimal-value ver_res>\n");
exit(exitcode);
}
/****************************************************************************
* Name: monkey_init
****************************************************************************/
static FAR struct monkey_s *monkey_init(
FAR const struct monkey_param_s *param)
{
FAR struct monkey_s *monkey;
struct monkey_config_s config;
if (!param->dev_type_mask)
{
show_usage(MONKEY_PREFIX, EXIT_FAILURE);
}
monkey = monkey_create(param->dev_type_mask);
if (!monkey)
{
goto failed;
}
monkey_config_default_init(&config);
#ifdef CONFIG_TESTING_MONKEY_SCREEN_IS_ROUND
config.screen.type = MONKEY_SCREEN_TYPE_ROUND;
#endif
config.screen.hor_res = param->hor_res;
config.screen.ver_res = param->ver_res;
config.period.min = param->period_min;
config.period.max = param->period_max;
monkey_set_config(monkey, &config);
printf(MONKEY_PREFIX ": Screen: %dx%d %s\n",
config.screen.hor_res,
config.screen.ver_res,
(config.screen.type == MONKEY_SCREEN_TYPE_ROUND)
? "ROUND" : "RECT");
printf(MONKEY_PREFIX ": Period: %" PRIu32 " ~ %" PRIu32 "ms\n",
config.period.min,
config.period.max);
if (MONKEY_IS_UINPUT_TYPE(param->dev_type_mask))
{
if (param->file_path)
{
monkey_set_mode(monkey, MONKEY_MODE_PLAYBACK);
if (!monkey_set_recorder_path(monkey, param->file_path))
{
goto failed;
}
}
else
{
monkey_set_mode(monkey, MONKEY_MODE_RANDOM);
}
}
else
{
monkey_set_mode(monkey, MONKEY_MODE_RECORD);
if (!monkey_set_recorder_path(monkey,
CONFIG_TESTING_MONKEY_REC_DIR_PATH))
{
goto failed;
}
monkey_set_period(monkey, config.period.min);
}
return monkey;
failed:
if (monkey)
{
monkey_delete(monkey);
}
return NULL;
}
/****************************************************************************
* Name: parse_commandline
****************************************************************************/
static void parse_commandline(int argc, FAR char **argv,
FAR struct monkey_param_s *param)
{
int ch;
int hor_res = -1;
int ver_res = -1;
int period_min = -1;
int period_max = -1;
int converted;
memset(param, 0, sizeof(struct monkey_param_s));
param->hor_res = CONFIG_TESTING_MONKEY_SCREEN_HOR_RES;
param->ver_res = CONFIG_TESTING_MONKEY_SCREEN_VER_RES;
param->period_min = CONFIG_TESTING_MONKEY_PERIOD_MIN_DEFAULT;
param->period_max = CONFIG_TESTING_MONKEY_PERIOD_MAX_DEFAULT;
while ((ch = getopt(argc, argv, "t:f:p:s:")) != ERROR)
{
switch (ch)
{
case 't':
OPTARG_TO_VALUE(param->dev_type_mask, int, 16);
break;
case 'f':
param->file_path = optarg;
break;
case 'p':
converted = sscanf(optarg, "%d-%d", &period_min, &period_max);
if (converted == 2 && period_min >= 0 && period_max >= 0)
{
param->period_min = period_min;
param->period_max = period_max;
}
else
{
printf(MONKEY_PREFIX ": Error period range: %s\n", optarg);
show_usage(argv[0], EXIT_FAILURE);
}
break;
case 's':
converted = sscanf(optarg, "%dx%d", &hor_res, &ver_res);
if (converted == 2 && hor_res > 0 && ver_res > 0)
{
param->hor_res = hor_res;
param->ver_res = ver_res;
}
else
{
printf(MONKEY_PREFIX ": Error screen resolution: %s\n",
optarg);
show_usage(argv[0], EXIT_FAILURE);
}
break;
case '?':
printf(MONKEY_PREFIX ": Unknown option: %c\n", optopt);
show_usage(argv[0], EXIT_FAILURE);
break;
}
}
}
/****************************************************************************
* Name: monkey_pause
****************************************************************************/
static int monkey_pause(void)
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGCONT);
return sigwaitinfo(&set, NULL);
}
/****************************************************************************
* Name: monkey_wait
****************************************************************************/
static enum monkey_wait_res_e monkey_wait(uint32_t ms)
{
sigset_t set;
struct timespec timeout;
int ret;
enum monkey_wait_res_e res = MONKEY_WAIT_RES_ERROR;
if (ms == 0)
{
return MONKEY_WAIT_RES_AGAIN;
}
timeout.tv_sec = ms / 1000;
timeout.tv_nsec = (ms % 1000) * 1000000;
sigemptyset(&set);
sigaddset(&set, SIGTSTP);
ret = sigtimedwait(&set, NULL, &timeout);
if (ret < 0)
{
int errcode = errno;
if (errcode == EINTR)
{
res = MONKEY_WAIT_RES_STOP;
}
else if(errcode == EAGAIN)
{
res = MONKEY_WAIT_RES_AGAIN;
}
else
{
printf(MONKEY_PREFIX ": Unknow error: %d\n", errcode);
}
}
else if (ret == SIGTSTP)
{
res = MONKEY_WAIT_RES_PAUSE;
}
return res;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: main or monkey_main
*
* Description:
*
* Input Parameters:
* Standard argc and argv
*
* Returned Value:
* Zero on success; a positive, non-zero value on failure.
*
****************************************************************************/
int main(int argc, FAR char *argv[])
{
struct monkey_param_s param;
FAR struct monkey_s *monkey;
parse_commandline(argc, argv, ¶m);
monkey = monkey_init(¶m);
if (!monkey)
{
return ERROR;
}
while (1)
{
enum monkey_wait_res_e res;
int sleep_ms;
sleep_ms = monkey_update(monkey);
if (sleep_ms < 0)
{
break;
}
res = monkey_wait(sleep_ms);
if (res == MONKEY_WAIT_RES_AGAIN)
{
continue;
}
else if (res == MONKEY_WAIT_RES_PAUSE)
{
printf(MONKEY_PREFIX ": pause\n");
if (monkey_pause() < 0)
{
break;
}
printf(MONKEY_PREFIX ": continue...\n");
}
else
{
/* STOP or ERROR */
break;
}
}
monkey_delete(monkey);
return OK;
}