testing/monkey/monkey_main.c - nuttx-apps - Git at Google

 /****************************************************************************
  * 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, &param);

   monkey = monkey_init(&param);

   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;
 }
	/****************************************************************************
	* 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, &param);

	monkey = monkey_init(&param);

	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;
	}