-SUBDIRS = joystick_gtforce touch_egalax tests
+SUBDIRS = gtforce tests
-DIST_SUBDIRS = joystick_gtforce touch_egalax tests
+DIST_SUBDIRS = gtforce tests
DISTCHECK_CONFIGURE_FLAGS = --disable-setuid-install
AC_PREREQ([2.68])
AC_INIT([ico-uxf-device-input-controller],
- [0.4.91],
+ [0.9.01],
[https://BUG-REPORT-ADDRESS])
AC_CONFIG_HEADERS([config.h])
WAYLAND_SCANNER_RULES(['$(top_srcdir)/protocol'])
AC_CONFIG_FILES([Makefile
- joystick_gtforce/Makefile
- touch_egalax/Makefile
+ gtforce/Makefile
tests/Makefile])
AC_OUTPUT
+++ /dev/null
-DWIDTH=1920
-DHEIGHT=1080
-POSITION1=1958*114
-POSITION2=77*125
-POSITION3=1924*1879
-POSITION4=99*1852
wayland_ivi_client_lib = -lico-uxf-weston-plugin
wayland_ivi_client_inc = -I/usr/include/ico-uxf-weston-plugin
-AM_CFLAGS = $(GCC_CFLAGS)
+AM_CFLAGS = $(GCC_CFLAGS) -I/usr/include/ico-util
AM_CPPFLAGS = -I$(top_srcdir)/src $(wayland_ivi_client_inc) $(GLIB_CFLAGS) $(COMPOSITOR_CFLAGS)
bin_PROGRAMS = \
- ico_ictl-joystick_gtforce
+ ico_dic-gtforce
check_LTLIBRARIES = $(TESTS)
-check_PROGRAMS = ico_ictl-joystick
+check_PROGRAMS = ico_dic-gtforce
-AM_LDFLAGS = -module -avoid-version -rpath $(libdir) $(GLIB_LIBS)
+AM_LDFLAGS = -module -avoid-version -rpath $(libdir) $(GLIB_LIBS) -lico-util
-ico_ictl_joystick_gtforce_SOURCES = \
- ico_ictl-joystick.c \
- ico_ictl-wayland.c \
- dbg_curtime.c
-ico_ictl_joystick_gtforce_LDADD = $(SIMPLE_CLIENT_LIBS) $(wayland_ivi_client_lib) $(wayland_client_lib)
+ico_dic_gtforce_SOURCES = \
+ ico_dic-gtforce.c \
+ ico_dic-wayland.c
+ico_dic_gtforce_LDADD = $(SIMPLE_CLIENT_LIBS) $(wayland_ivi_client_lib) $(wayland_client_lib)
*/
/**
* @brief Device Input Controller(GtForce joystick)
- * @brief joystick input event to Input Manager
+ * @brief GtForce input event to Input Manager
*
- * @date Feb-08-2013
+ * @date Sep-08-2013
*/
#include <stdio.h>
#include <linux/joystick.h>
#include <glib.h>
-#include "ico_ictl-local.h"
+#include "ico_dic-gtforce.h"
/* type definition */
-typedef struct _Ico_ICtl_JS {
+typedef struct _Ico_Dic_JS {
int fd; /* device file fd */
char device[32]; /* device name */
- char ictl[32]; /* input controller name */
+ char dic_name[32]; /* input controller name */
int type; /* device type */
int hostid; /* host Id(currently unused) */
-} Ico_ICtl_JS;
+} Ico_Dic_JS;
-typedef struct _Ico_Ictl_Code {
+typedef struct _Ico_Dic_Code {
unsigned short code; /* code value */
char name[20]; /* code name */
-} Ico_Ictl_Code;
+ char appid[ICO_DIC_MAX_APPID_LEN];
+ /* application id or script path */
+ short keycode; /* keycode or -1 for script */
+} Ico_Dic_Code;
-typedef struct _Ico_ICtl_JS_Input {
+typedef struct _Ico_Dic_JS_Input {
char name[20]; /* input switch name */
int input; /* input number */
int type; /* input event type */
int number; /* input event number */
- Ico_Ictl_Code code[20]; /* key code */
+ Ico_Dic_Code code[ICO_DIC_MAX_CODES];
+ /* key code */
int last; /* last input code */
-} Ico_ICtl_JS_Input;
+} Ico_Dic_JS_Input;
/* prototype of static function */
static void PrintUsage(const char *pName);
int gRunning = 1; /* run state(1:run, 0:finish) */
/* Input Contorller Table */
-Ico_ICtl_Mng gIco_ICtrl_Mng = { 0 };
-Ico_ICtl_JS gIco_ICtrl_JS = { 0 };
-int nIco_ICtrl_JS_Input = 0;
-Ico_ICtl_JS_Input *gIco_ICtrl_JS_Input = NULL;
+Ico_Dic_Mng gIco_Dic_Mng = { 0 };
+Ico_Dic_JS gIco_Dic_JS = { 0 };
+int nIco_Dic_JS_Input = 0;
+Ico_Dic_JS_Input *gIco_Dic_JS_Input = NULL;
/* static functions */
/*--------------------------------------------------------------------------*/
/**
- * @brief ico_ictl_find_input_by_name: find Input Table by input switch name
+ * @brief ico_dic_find_input_by_name: find Input Table by input switch name
*
* @param[in] name input switch name
- * @return result
- * @retval !=NULL success(Input Table address)
- * @retval ==NULL failed
+ * @return result
+ * @retval !=NULL success(Input Table address)
+ * @retval ==NULL failed
*/
/*--------------------------------------------------------------------------*/
-static Ico_ICtl_JS_Input *
-ico_ictl_find_input_by_name(const char *name)
+static Ico_Dic_JS_Input *
+ico_dic_find_input_by_name(const char *name)
{
- Ico_ICtl_JS_Input *iMng = NULL;
+ Ico_Dic_JS_Input *iMng = NULL;
int ii;
- for (ii = 0; ii < nIco_ICtrl_JS_Input; ii++) {
- if (strncasecmp(name, gIco_ICtrl_JS_Input[ii].name, 16) == 0) {
- iMng = &gIco_ICtrl_JS_Input[ii];
+ for (ii = 0; ii < nIco_Dic_JS_Input; ii++) {
+ if (strncasecmp(name, gIco_Dic_JS_Input[ii].name, 16) == 0) {
+ iMng = &gIco_Dic_JS_Input[ii];
break;
}
}
/*--------------------------------------------------------------------------*/
/**
- * @brief ico_ictl_find_input_by_param: find Input Table by input switch type and number
+ * @brief ico_dic_find_input_by_param: find Input Table by input switch type and number
*
* @param[in] type input event type (of Linux Input subsystem)
* @param[in] number input event number (of Linux Input subsystem)
- * @return result
- * @retval !=NULL success(Input Table address)
- * @retval ==NULL failed
+ * @return result
+ * @retval !=NULL success(Input Table address)
+ * @retval ==NULL failed
*/
/*--------------------------------------------------------------------------*/
-static Ico_ICtl_JS_Input *
-ico_ictl_find_input_by_param(int type, int number)
+static Ico_Dic_JS_Input *
+ico_dic_find_input_by_param(int type, int number)
{
- Ico_ICtl_JS_Input *iMng = NULL;
+ Ico_Dic_JS_Input *iMng = NULL;
int ii;
- for (ii = 0; ii < nIco_ICtrl_JS_Input; ii++) {
- if ((gIco_ICtrl_JS_Input[ii].type == type)
- && (gIco_ICtrl_JS_Input[ii].number == number)) {
- iMng = &gIco_ICtrl_JS_Input[ii];
+ for (ii = 0; ii < nIco_Dic_JS_Input; ii++) {
+ if ((gIco_Dic_JS_Input[ii].type == type)
+ && (gIco_Dic_JS_Input[ii].number == number)) {
+ iMng = &gIco_Dic_JS_Input[ii];
break;
}
}
* @brief conf_getUint: convert integer string to value
*
* @param[in] str integer string
- * @return result
- * @retval >=0 success(converted vaule)
- * @retval -1 failed
+ * @return result
+ * @retval >=0 success(converted vaule)
+ * @retval -1 failed
*/
/*--------------------------------------------------------------------------*/
static int
*
* @param[in] keyfile configuration file
* @param[in] group configuration key group name
- * @return result
- * @retval !=NULL success(configuration list)
- * @retval ==NULL failed
+ * @return result
+ * @retval !=NULL success(configuration list)
+ * @retval ==NULL failed
*/
/*--------------------------------------------------------------------------*/
static GList *
*
* @param[in] str1 string 1
* @param[in] str2 string 2
- * @return connected string
+ * @return connected string
*/
/*--------------------------------------------------------------------------*/
static char *
/*--------------------------------------------------------------------------*/
/**
- * @brief ico_ictl_read_conf: read configuration file
+ * @brief ico_dic_read_conf: read configuration file
*
- * @param[in] file configuration file path name
- * @return result
- * @retval ICO_ICTL_OK sccess
- * @retval ICO_ICTL_ERR failed
+ * @param[in] file configuration file path name
+ * @return result
+ * @retval ICO_DIC_OK sccess
+ * @retval ICO_DIC_ERR failed
*/
/*--------------------------------------------------------------------------*/
static int
-ico_ictl_read_conf(const char *file)
+ico_dic_read_conf(const char *file)
{
- DEBUG_PRINT("ico_ictl_read_conf: Enter(file=%s)", file);
+ ICO_TRA("ico_dic_read_conf: Enter(file=%s)", file);
GKeyFile *keyfile;
GKeyFileFlags flags;
GString *filepath;
GList *idlist;
GError *error = NULL;
- Ico_ICtl_JS_Input *iMng;
+ Ico_Dic_JS_Input *iMng;
char *name;
gsize length;
- int ii, jj;
+ int ii, jj, kk, ll;
keyfile = g_key_file_new();
flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS;
filepath = g_string_new(file);
if (! g_key_file_load_from_file(keyfile, filepath->str, flags, &error)) {
- ERROR_PRINT("ico_ictl_read_conf: Leave(can not open conf file)");
+ ICO_ERR("ico_dic_read_conf: Leave(can not open conf file)");
g_string_free(filepath, TRUE);
- return ICO_ICTL_ERR;
+ return ICO_DIC_ERR;
}
g_string_free(filepath, TRUE);
/* count number of key in [device] section */
- memset((char *)&gIco_ICtrl_JS, 0, sizeof(gIco_ICtrl_JS));
+ memset((char *)&gIco_Dic_JS, 0, sizeof(gIco_Dic_JS));
name = g_key_file_get_string(keyfile, "device", "name", &error);
if (name) {
- strncpy(gIco_ICtrl_JS.device, name, sizeof(gIco_ICtrl_JS.device)-1);
+ strncpy(gIco_Dic_JS.device, name, sizeof(gIco_Dic_JS.device)-1);
}
- name = g_key_file_get_string(keyfile, "device", "ictl", &error);
+ name = g_key_file_get_string(keyfile, "device", "dic", &error);
if (name) {
- strncpy(gIco_ICtrl_JS.ictl, name, sizeof(gIco_ICtrl_JS.ictl)-1);
+ strncpy(gIco_Dic_JS.dic_name, name, sizeof(gIco_Dic_JS.dic_name)-1);
}
- gIco_ICtrl_JS.type = g_key_file_get_integer(keyfile, "device", "type", &error);
- gIco_ICtrl_JS.hostid = g_key_file_get_integer(keyfile, "device", "ecu", &error);
+ gIco_Dic_JS.type = g_key_file_get_integer(keyfile, "device", "type", &error);
+ gIco_Dic_JS.hostid = g_key_file_get_integer(keyfile, "device", "ecu", &error);
/* count number of key in [input] section */
idlist = conf_countNumericalKey(keyfile, "input");
if (length <= 0) {
length = 1;
}
- nIco_ICtrl_JS_Input = 0;
- gIco_ICtrl_JS_Input = (Ico_ICtl_JS_Input *)malloc(sizeof(Ico_ICtl_JS_Input) * length);
- if (! gIco_ICtrl_JS_Input) {
- ERROR_PRINT("joystick_gtforce: No Memory");
+ nIco_Dic_JS_Input = 0;
+ gIco_Dic_JS_Input = (Ico_Dic_JS_Input *)malloc(sizeof(Ico_Dic_JS_Input) * length);
+ if (! gIco_Dic_JS_Input) {
+ ICO_ERR("joystick_gtforce: No Memory");
exit(1);
}
- memset((char *)gIco_ICtrl_JS_Input, 0, sizeof(Ico_ICtl_JS_Input) * length);
+ memset((char *)gIco_Dic_JS_Input, 0, sizeof(Ico_Dic_JS_Input) * length);
for (ii = 0; ii < (int)length; ii++) {
const char *g = "input";
char *key = (char *)g_list_nth_data(idlist, ii);
gsize listsize;
+ gsize listsize2;
gint *attr;
gchar **code;
+ char *p;
+ int codeval;
name = g_key_file_get_string(keyfile, g, key, &error);
if (name == NULL) continue;
- iMng = ico_ictl_find_input_by_name(name);
+ iMng = ico_dic_find_input_by_name(name);
if (iMng != NULL) {
/* multiple define */
- ERROR_PRINT("ico_ictl_read_conf: switch name(%s) re-define", name);
+ ICO_ERR("ico_dic_read_conf: switch name(%s) re-define", name);
continue;
}
- iMng = &gIco_ICtrl_JS_Input[nIco_ICtrl_JS_Input];
+ iMng = &gIco_Dic_JS_Input[nIco_Dic_JS_Input];
iMng->input = conf_getUint(key);
strncpy(iMng->name, name, sizeof(iMng->name)-1);
/* event */
attr = g_key_file_get_integer_list(keyfile, g, conf_appendStr(key, ".event"),
&listsize, &error);
- if (listsize < 2) continue;
+ if ((int)listsize < 2) continue;
iMng->type = attr[0];
iMng->number = attr[1];
/* code */
code = g_key_file_get_string_list(keyfile, g, conf_appendStr(key, ".code"),
&listsize, &error);
- if ((code == NULL) || (listsize <= 0)) {
+ if ((code == NULL) || ((int)listsize <= 0)) {
strcpy(iMng->code[0].name, iMng->name);
}
else {
- if ((int)listsize > 20) listsize = 20;
+ if ((int)listsize > ICO_DIC_MAX_CODES) listsize = ICO_DIC_MAX_CODES;
for (jj = 0; jj < (int)listsize; jj++) {
- char *p = (char *)code[jj];
+ p = (char *)code[jj];
while ((*p != 0) && (*p != ':')) {
iMng->code[jj].code = iMng->code[jj].code * 10 + *p - '0';
p ++;
}
if (code) g_strfreev(code);
- nIco_ICtrl_JS_Input ++;
+ /* fixed */
+ code = g_key_file_get_string_list(keyfile, g, conf_appendStr(key, ".fixed"),
+ &listsize2, &error);
+ error = NULL;
+ if ((code != NULL) && ((int)listsize2 > 0)) {
+ for (jj = 0; jj < (int)listsize2; jj++) {
+ p = (char *)code[jj];
+ codeval = -1;
+ while ((*p >= '0') && (*p <= '9')) {
+ if (codeval < 0) codeval = 0;
+ codeval = codeval * 10 + *p - '0';
+ p ++;
+ }
+ if ((codeval >= 0) && (*p == ':')) {
+ p++;
+ for (kk = 0; kk < (int)listsize; kk++) {
+ if (iMng->code[kk].code == codeval) break;
+ }
+ memset(iMng->code[kk].appid, 0, ICO_DIC_MAX_APPID_LEN);
+ if (strncasecmp(p, "shell=", 6) == 0) {
+ iMng->code[kk].keycode = -1;
+ strncpy(iMng->code[kk].appid, p + 6, ICO_DIC_MAX_APPID_LEN-1);
+ }
+ else {
+ if (strncasecmp(p, "appid=", 6) == 0) {
+ p += 6;
+ }
+ for (ll = 0; ll < (ICO_DIC_MAX_APPID_LEN-1); ll++) {
+ if ((*p == 0) || (*p == ':')) break;
+ iMng->code[kk].appid[ll] = *p;
+ p++;
+ }
+ if (*p) {
+ p ++;
+ if (strncasecmp(p, "key=", 4) == 0) p += 4;
+ iMng->code[kk].keycode = strtol(p, (char **)0, 0);
+ }
+ }
+ }
+ else {
+ for (kk = 0; kk < (int)listsize; kk++) {
+ if (kk == 0) {
+ memset(iMng->code[0].appid, 0, ICO_DIC_MAX_APPID_LEN);
+ if (strncasecmp(p, "shell=", 6) == 0) {
+ iMng->code[0].keycode = -1;
+ strncpy(iMng->code[0].appid, p + 6, ICO_DIC_MAX_APPID_LEN-1);
+ }
+ else {
+ if (strncasecmp(p, "appid=", 6) == 0) {
+ p += 6;
+ }
+ for (ll = 0; ll < (ICO_DIC_MAX_APPID_LEN-1); ll++) {
+ if ((*p == 0) || (*p == ':')) break;
+ iMng->code[0].appid[ll] = *p;
+ p++;
+ }
+ if (*p) {
+ p ++;
+ if (strncasecmp(p, "key=", 4) == 0) p += 4;
+ iMng->code[0].keycode = strtol(p, (char **)0, 0);
+ }
+ }
+ }
+ else {
+ memcpy(iMng->code[kk].appid,
+ iMng->code[0].appid, ICO_DIC_MAX_APPID_LEN);
+ iMng->code[kk].keycode = iMng->code[0].keycode;
+ }
+ }
+ }
+ }
+ }
+ if (code) g_strfreev(code);
+
+ nIco_Dic_JS_Input ++;
- DEBUG_PRINT("%s input:%d(type=%d,number=%d,code=%d[%s],%d[%s])",
+ if (iMng->code[1].code == 0) {
+ ICO_DBG("%s input:%d type=%d,number=%d,code=%d[%s,%s,%d]",
iMng->name, iMng->input, iMng->type, iMng->number,
iMng->code[0].code, iMng->code[0].name,
- iMng->code[1].code, iMng->code[1].name);
+ iMng->code[0].appid, iMng->code[0].keycode);
+ }
+ else {
+ ICO_DBG("%s input:%d type=%d,number=%d,code=%d[%s,%s,%d],code=%d[%s,%s,%d]",
+ iMng->name, iMng->input, iMng->type, iMng->number,
+ iMng->code[0].code, iMng->code[0].name,
+ iMng->code[0].appid, iMng->code[0].keycode,
+ iMng->code[1].code, iMng->code[1].name,
+ iMng->code[1].appid, iMng->code[1].keycode);
+ }
}
- DEBUG_PRINT("ico_ictl_read_conf: Leave");
+ ICO_TRA("ico_dic_read_conf: Leave");
- return ICO_ICTL_OK;
+ return ICO_DIC_OK;
}
/*--------------------------------------------------------------------------*/
/**
- * @brief ico_ictl_js_open: open input jyostick input device
+ * @brief ico_dic_js_open: open input jyostick input device
*
- * @param[in] ictlDevName device name
- * @return result
- * @retval >= 0 sccess(device file descriptor)
- * @retval ICO_ICTL_ERR failed
+ * @param[in] dicDevName device name
+ * @param[in/out] confpath configuration file path
+ * @return result
+ * @retval >= 0 sccess(device file descriptor)
+ * @retval ICO_DIC_ERR failed
*/
/*--------------------------------------------------------------------------*/
static int
-ico_ictl_js_open(const char *ictlDevName)
+ico_dic_js_open(const char *dicDevName, char **confpath)
{
- DEBUG_PRINT("ico_ictl_js_open: Enter(device=%s)", ictlDevName)
-
int fd = -1;
+ int conf_fd;
+ static char fixconfpath[128];
char devFile[64];
char devName[64];
int ii, jj, kk;
- if (ictlDevName == NULL) {
- ERROR_PRINT("ico_ictl_js_open: Leave(failed devname NULL)");
- return ICO_ICTL_ERR;
- }
+ ICO_TRA("ico_dic_js_open: Enter(device=%s, conf=%s)", dicDevName,
+ *confpath ? *confpath : "(null)");
- char *pdev = getenv(ICO_ICTL_INPUT_DEV);
+ char *pdev = getenv(ICO_DIC_INPUT_DEV);
if ((pdev != NULL) && (*pdev != 0)) {
- DEBUG_PRINT("ico_ictl_js_open: Pseudo input device(%s)", pdev);
+ ICO_DBG("ico_dic_js_open: Pseudo input device(%s)", pdev);
mPseudo = 1;
}
else {
- pdev = (char *)ictlDevName;
+ pdev = (char *)dicDevName;
}
for (ii = 0; ii < 16; ii++) {
if (mPseudo) {
kk = 0;
for (jj = 0; devName[jj]; jj++) {
if (devName[jj] != ' ') {
- devName[kk++] = devName[jj];
+ if ((devName[jj] >= 'A') && (devName[jj] <= 'Z')) {
+ devName[kk++] = devName[jj] - 'A' + 'a';
+ }
+ else {
+ devName[kk++] = devName[jj];
+ }
}
}
devName[kk] = 0;
- DEBUG_PRINT("ico_ictl_js_open: %d.%s", ii+1, devName);
+ ICO_DBG("ico_dic_js_open: %d.%s", ii+1, devName);
- if (strncasecmp(devName, pdev, sizeof(devName)) == 0) break;
+ if (pdev) {
+ /* fixed (or debug) device */
+ if (strcasecmp(pdev, devName) == 0) {
+ if (*confpath == NULL) {
+ snprintf(fixconfpath, sizeof(fixconfpath), ICO_DIC_CONF_FILE, devName);
+ }
+ break;
+ }
+ }
+ else {
+ /* search configuration file */
+ if (*confpath == NULL) {
+ snprintf(fixconfpath, sizeof(fixconfpath), ICO_DIC_CONF_FILE, devName);
+ conf_fd = open(fixconfpath, O_RDONLY);
+ if (conf_fd < 0) continue;
+ close(conf_fd);
+ }
+ break;
+ }
/* not match, close */
close(fd);
fd = -1;
}
if (fd < 0) {
- ERROR_PRINT("ico_ictl_js_open: Leave(not find device file)");
- return ICO_ICTL_ERR;
+ ICO_ERR("ico_dic_js_open: Leave(not find device file)");
+ return ICO_DIC_ERR;
+ }
+ ICO_TRA("ico_dic_js_open: Leave(found %s)", fixconfpath);
+
+ if (*confpath == NULL) {
+ *confpath = &fixconfpath[0];
}
- DEBUG_PRINT("ico_ictl_js_open: Leave(found %s[%s] as %s)", pdev, devFile, ictlDevName);
return fd;
}
/*--------------------------------------------------------------------------*/
/**
- * @brief ico_ictl_js_read: read input jyostick input device
+ * @brief ico_dic_js_read: read jyostick input device
*
* @param[in] fd file descriptor
* @return nothing
*/
/*--------------------------------------------------------------------------*/
static void
-ico_ictl_js_read(int fd)
+ico_dic_js_read(int fd)
{
- DEBUG_PRINT("ico_ictl_js_read: Enter(fd=%d)", fd)
-
struct js_event events[8];
struct input_event pevents[8];
int rSize;
int ii, jj;
int number, value, type, code, state;
+ int icode;
if (mPseudo) {
/* Pseudo event input for Debug */
else if ((events[ii].type == 1) && (events[ii].number == 9)) {
events[ii].number = 0;
}
- DEBUG_PRINT("ico_ictl_js_read: pseude event.%d %d.%d.%d",
- ii, events[ii].type, events[ii].number, events[ii].value);
+ ICO_DBG("ico_dic_js_read: pseude event.%d %d.%d.%d",
+ ii, events[ii].type, events[ii].number, events[ii].value);
}
rSize = ii * sizeof(struct js_event);
}
if ((ii == EINTR) || (ii == EAGAIN)) {
return;
}
- DEBUG_PRINT("ico_ictl_js_read: Leave(read error[%d])", ii)
+ ICO_ERR("ico_dic_js_read: read error[%d]", ii)
exit(9);
}
for (ii = 0; ii < (rSize / (int)sizeof(struct js_event)); ii++) {
- Ico_ICtl_JS_Input *iMng = NULL;
+ Ico_Dic_JS_Input *iMng = NULL;
type = events[ii].type;
number = events[ii].number;
value = events[ii].value;
- DEBUG_PRINT("ico_ictl_js_read: Read(type=%d, number=%d, value=%d",
- type, number, value);
-
- iMng = ico_ictl_find_input_by_param(type, number);
+ iMng = ico_dic_find_input_by_param(type, number);
if (iMng == NULL) {
+ if (mDebug >= 2) {
+ ICO_DBG("ico_dic_js_read: Not Assigned(type=%d, number=%d, value=%d)",
+ type, number, value);
+ }
continue;
}
+ ICO_DBG("ico_dic_js_read: Read(type=%d, number=%d, value=%d)",
+ type, number, value);
if (mEventLog) {
struct timeval curtime;
lastEvent.tv_usec = curtime.tv_usec;
}
for (jj = 0;
- jj < (int)(sizeof(gIco_ICtrl_JS_Input)/sizeof(Ico_ICtl_JS_Input)); jj++) {
- if ((type == gIco_ICtrl_JS_Input[jj].type) &&
- (number == gIco_ICtrl_JS_Input[jj].number)) {
+ jj < (int)(sizeof(gIco_Dic_JS_Input)/sizeof(Ico_Dic_JS_Input)); jj++) {
+ if ((type == gIco_Dic_JS_Input[jj].type) &&
+ (number == gIco_Dic_JS_Input[jj].number)) {
break;
}
}
}
+ icode = 0;
if (iMng->code[1].code != 0) {
if (value < 0) {
code = iMng->code[0].code;
iMng->last = code;
}
else if (value > 0) {
+ icode = 1;
code = iMng->code[1].code;
state = WL_KEYBOARD_KEY_STATE_PRESSED;
iMng->last = code;
continue;
}
code = iMng->last;
+ if (code == iMng->code[1].code) {
+ icode = 1;
+ }
state = WL_KEYBOARD_KEY_STATE_RELEASED;
iMng->last = -1;
}
continue;
}
}
- ico_input_mgr_device_input_event(gIco_ICtrl_Mng.Wayland_InputMgr, events[ii].time,
- gIco_ICtrl_JS.device, iMng->input, code, state);
+ if (iMng->code[icode].appid[0]) {
+ /* fixed event */
+ if (iMng->code[icode].keycode < 0) {
+ /* start program if pressed */
+ if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
+ ICO_DBG("ico_dic_js_read: start script(%s)", iMng->code[icode].appid);
+ if (system(iMng->code[icode].appid) == -1) {
+ ICO_WRN("ico_dic_js_read: script(%s) Error",
+ iMng->code[icode].appid);
+ }
+ }
+ }
+ else {
+ /* send keyboard event to application */
+ if (state == WL_KEYBOARD_KEY_STATE_PRESSED) state = 1;
+ else state = 0;
+
+ ICO_DBG("ico_dic_js_read: send event to %s(%d.%d)",
+ iMng->code[icode].appid, iMng->code[icode].keycode, state);
+ ico_input_mgr_control_send_input_event(gIco_Dic_Mng.Wayland_InputCtl,
+ iMng->code[icode].appid, 0,
+ ICO_INPUT_MGR_DEVICE_TYPE_KEYBOARD,
+ 0, iMng->code[icode].keycode, state);
+ }
+ }
+ else {
+ /* general switch event, send to multi input manager */
+ ICO_DBG("ico_dic_js_read: send general input event(%s.%d.%d.%d)",
+ gIco_Dic_JS.device, iMng->input, code, state);
+ ico_input_mgr_device_input_event(gIco_Dic_Mng.Wayland_InputMgr, events[ii].time,
+ gIco_Dic_JS.device, iMng->input, code, state);
+ }
}
}
/*--------------------------------------------------------------------------*/
/**
- * @brief Device Input Controllers: For Joy Stick
+ * @brief Device Input Controllers: For GtForce
* main routine
*
- * @param main() finction's standard parameter (argc,argv)
- * @return result
- * @retval 0 success
- * @retval 1 failed
+ * @param main() finction's standard parameter (argc,argv)
+ * @return result
+ * @retval 0 success
+ * @retval 1 failed
*/
/*--------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
struct epoll_event ev_ret[16];
- char *ictlDevName = "DrivingForceGT";
+ char *dicDevName = NULL;
+ char *confpath;
int JSfd;
int ii, jj;
int ret;
PrintUsage(argv[0]);
exit( 0 );
}
- else if (strcasecmp( argv[ii], "-d") == 0) {
+ else if (strcmp( argv[ii], "-d") == 0) {
/* debug */
mDebug = 1;
}
+ else if (strcmp( argv[ii], "-D") == 0) {
+ /* debug */
+ mDebug = 2;
+ }
else if (strcasecmp( argv[ii], "-l") == 0) {
/* event input log */
mEventLog = 1;
}
else {
- ictlDevName = argv[ii];
+ dicDevName = argv[ii];
}
}
}
}
+ /* set log name */
+ ico_log_open("ico_dic-gtforce");
+
+ /* read conf file */
+ confpath = getenv(ICO_DIC_CONF_ENV);
+
/* open joystick */
- JSfd = ico_ictl_js_open(ictlDevName);
+ JSfd = ico_dic_js_open(dicDevName, &confpath);
if (JSfd < 0) {
- ERROR_PRINT("main: Leave(Error device open)");
+ ICO_ERR("main: Leave(Error device open)");
exit(1);
}
- gIco_ICtrl_JS.fd = JSfd;
+ gIco_Dic_JS.fd = JSfd;
/* read conf file */
- char *confpath = getenv(ICO_ICTL_CONF_ENV);
- if (!confpath) {
- confpath = ICO_ICTL_CONF_FILE;
+ if (ico_dic_read_conf(confpath) == ICO_DIC_ERR) {
+ ICO_ERR("main: Leave(Error can not read configfile(%s))", confpath);
+ exit(1);
}
- ico_ictl_read_conf(confpath);
/* initialize wayland */
- ico_ictl_wayland_init(NULL, NULL);
- ico_ictl_add_fd(JSfd);
+ if (ico_dic_wayland_init(NULL, NULL) == ICO_DIC_ERR) {
+ ICO_ERR("main: Leave(Error can not connect to wayland)");
+ exit(1);
+ }
+ ico_dic_add_fd(JSfd);
/* send configuration informations to Multi Input Manager */
- for (ii = 0; ii < nIco_ICtrl_JS_Input; ii++) {
+ for (ii = 0; ii < nIco_Dic_JS_Input; ii++) {
+ if (gIco_Dic_JS_Input[ii].code[0].appid[0] != 0) continue;
ico_input_mgr_device_configure_input(
- gIco_ICtrl_Mng.Wayland_InputMgr, gIco_ICtrl_JS.device, gIco_ICtrl_JS.type,
- gIco_ICtrl_JS_Input[ii].name, gIco_ICtrl_JS_Input[ii].input,
- gIco_ICtrl_JS_Input[ii].code[0].name, gIco_ICtrl_JS_Input[ii].code[0].code);
- for (jj = 1; jj < 20; jj++) {
- if (gIco_ICtrl_JS_Input[ii].code[jj].code == 0) break;
+ gIco_Dic_Mng.Wayland_InputMgr, gIco_Dic_JS.device, gIco_Dic_JS.type,
+ gIco_Dic_JS_Input[ii].name, gIco_Dic_JS_Input[ii].input,
+ gIco_Dic_JS_Input[ii].code[0].name, gIco_Dic_JS_Input[ii].code[0].code);
+ for (jj = 1; jj < ICO_DIC_MAX_CODES; jj++) {
+ if (gIco_Dic_JS_Input[ii].code[jj].code == 0) break;
ico_input_mgr_device_configure_code(
- gIco_ICtrl_Mng.Wayland_InputMgr, gIco_ICtrl_JS.device,
- gIco_ICtrl_JS_Input[ii].input, gIco_ICtrl_JS_Input[ii].code[jj].name,
- gIco_ICtrl_JS_Input[ii].code[jj].code);
+ gIco_Dic_Mng.Wayland_InputMgr, gIco_Dic_JS.device,
+ gIco_Dic_JS_Input[ii].input, gIco_Dic_JS_Input[ii].code[jj].name,
+ gIco_Dic_JS_Input[ii].code[jj].code);
}
}
/* signal init */
+ signal(SIGCHLD, SIG_IGN);
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
+ sigaction(SIGTERM, &sigint, NULL);
/* main loop */
while (gRunning) {
- ret = ico_ictl_wayland_iterate(ev_ret, 200);
+ ret = ico_dic_wayland_iterate(ev_ret, 200);
for (ii = 0; ii < ret; ii++) {
if (ev_ret[ii].data.fd == JSfd) {
- ico_ictl_js_read(JSfd);
+ ico_dic_js_read(JSfd);
}
}
}
- ico_ictl_wayland_finish();
+ ico_dic_wayland_finish();
+ ico_log_close();
exit(0);
}
static void PrintUsage(const char *pName)
{
- fprintf( stderr, "Usage: %s [-h] [-d] DeviceName\n", pName );
+ fprintf( stderr, "Usage: %s [-h] [-d] [DeviceName]\n", pName );
fprintf( stderr, " ex)\n");
fprintf( stderr, " %s \"Driving Force GT\"\n", pName);
}
--- /dev/null
+/*
+ * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ *
+ * This program is licensed under the terms and conditions of the
+ * Apache License, version 2.0. The full text of the Apache License is at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ */
+/**
+ * @brief header file of Device Input Controllers for GtForce
+ *
+ * @date Sep-08-2013
+ */
+
+#ifndef _ICO_DIC_GTFORCE_H_
+#define _ICO_DIC_GTFORCE_H_
+
+#include <wayland-client-protocol.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+#include <wayland-util.h>
+#include <sys/ioctl.h>
+#include <sys/epoll.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <ico_window_mgr-client-protocol.h>
+#include <ico_input_mgr-client-protocol.h>
+#include <ico_log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* call back function */
+typedef void (*Ico_Dic_Wayland_Cb)( void );
+
+/* Deafult config file */
+#define ICO_DIC_CONF_FILE \
+ "/opt/etc/ico/device-input-controller/%s.conf"
+/* Environment valible name for config file */
+#define ICO_DIC_CONF_ENV "DIC_GTFORCE_CONF"
+/* Environment valible name for input device*/
+#define ICO_DIC_INPUT_DEV "DIC_GTFORCE_DEV"
+
+/* maximum value */
+#define ICO_DIC_MAX_APPID_LEN 80 /* application id name length */
+#define ICO_DIC_MAX_CODES 2 /* maximum codes in same switch */
+
+/* event code */
+#define ICO_DIC_TOUCH_NONE 0 /* not exist touch event */
+#define ICO_DIC_TOUCH_KEYIN 1 /* touch event is reserved */
+#define ICO_DIC_TOUCH_PASSED 2 /* touch event is passed */
+#define ICO_DIC_EVENT_NUM (16)
+
+/* return val */
+#define ICO_DIC_OK 0 /* success */
+#define ICO_DIC_ERR (-1) /* failedi */
+
+/* management table */
+typedef struct _Ico_Dic_Mng {
+ /* Multi Input Controller */
+ int Dic_id; /* multi input controller ID */
+ Ico_Dic_Wayland_Cb Dic_CallBack; /* call back function */
+
+ /* wayland interfaces */
+ struct wl_display *Wayland_Display; /* Wayland Display */
+ struct wl_registry *Wayland_Registry; /* Wayland Registory */
+ struct ico_window_mgr *Wayland_WindowMgr; /* Wayland multi window manager */
+ struct ico_input_mgr_control *Wayland_InputCtl; /* Wayland multi input manager */
+ struct ico_input_mgr_device *Wayland_InputMgr; /* Wayland multi input manager */
+
+ int WaylandFd; /* file descriptor of Wayland */
+ int Dic_efd; /* descriptor of epoll */
+
+} Ico_Dic_Mng;
+
+/* function prototype */
+ /* initialization to wayland */
+int ico_dic_wayland_init(const char *display ,Ico_Dic_Wayland_Cb callback);
+void ico_dic_wayland_finish(void); /* finish wayland connection */
+ /* iterate wayland connection */
+int ico_dic_wayland_iterate(struct epoll_event *ev_ret, int timeout);
+int ico_dic_add_fd(int fd); /* add file descriptor */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* _ICO_DIC_GTFORCE_H_ */
+
--- /dev/null
+/*
+ * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ *
+ * This program is licensed under the terms and conditions of the
+ * Apache License, version 2.0. The full text of the Apache License is at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ */
+/**
+ * @brief Device Input Controllers(wayland processing)
+ * processing related wayland
+ *
+ * @date Sep-08-2013
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <strings.h>
+#include <errno.h>
+#include <pthread.h>
+#include "ico_dic-gtforce.h"
+
+/* prototype of static function */
+/* callback function from wayland global */
+static void ico_dic_wayland_globalcb(void *data, struct wl_registry *registry,
+ uint32_t wldispid, const char *event,
+ uint32_t version);
+
+/* table/variable */
+extern Ico_Dic_Mng gIco_Dic_Mng;
+
+static const struct wl_registry_listener registry_listener = {
+ ico_dic_wayland_globalcb
+};
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief ico_dic_wayland_init
+ * connect to wayland of specified Display. specified NULL to
+ * connected Display, connect to the default Display.
+ *
+ * @param[in] display display to connect
+ * @param[in] callback callback function
+ * @return result
+ * @retval ICO_DIC_EOK Success
+ * @retval ICO_DIC_ERR Failed
+ */
+/*--------------------------------------------------------------------------*/
+int
+ico_dic_wayland_init(const char *display, Ico_Dic_Wayland_Cb callback)
+{
+ ICO_TRA("ico_dic_wayland_init: Enter");
+
+ int ret;
+
+ /* regist callback funtion */
+ gIco_Dic_Mng.Dic_CallBack = callback;
+
+ /* connect to wayland(retry max 5 sec) */
+ for (ret = 0; ret < (5000/20); ret++) {
+ gIco_Dic_Mng.Wayland_Display = wl_display_connect(display);
+ if (gIco_Dic_Mng.Wayland_Display) {
+ break;
+ }
+ usleep(20*1000);
+ }
+ if (! gIco_Dic_Mng.Wayland_Display) {
+ ICO_ERR("ico_dic_wayland_init: Leave(ERR), Wayland Connect Error");
+ return ICO_DIC_ERR;
+ }
+
+ /* add listener of wayland registry */
+ gIco_Dic_Mng.Wayland_Registry =
+ wl_display_get_registry(gIco_Dic_Mng.Wayland_Display);
+ wl_registry_add_listener(gIco_Dic_Mng.Wayland_Registry,
+ ®istry_listener, &gIco_Dic_Mng);
+
+ /* display dispatch to wait */
+ do {
+ wl_display_dispatch(gIco_Dic_Mng.Wayland_Display);
+ } while ((gIco_Dic_Mng.Wayland_WindowMgr == NULL) ||
+ (gIco_Dic_Mng.Wayland_InputCtl == NULL) ||
+ (gIco_Dic_Mng.Wayland_InputMgr == NULL));
+
+ /* get the Wayland descriptor */
+ gIco_Dic_Mng.WaylandFd = wl_display_get_fd(gIco_Dic_Mng.Wayland_Display);
+ ICO_DBG("ico_dic_wayland_init: Wayland FD = %d", gIco_Dic_Mng.WaylandFd);
+
+ /* create epoll file descriptor */
+ gIco_Dic_Mng.Dic_efd = epoll_create1(EPOLL_CLOEXEC);
+ if (gIco_Dic_Mng.Dic_efd < 0) {
+ ICO_ERR("ico_dic_wayland_init: Leave(ERR), Epoll Create Error");
+ return ICO_DIC_ERR;
+ }
+ struct epoll_event ev;
+ memset(&ev, 0, sizeof(ev));
+ ev.events = EPOLLIN;
+ ev.data.fd = gIco_Dic_Mng.WaylandFd;
+ if (epoll_ctl(gIco_Dic_Mng.Dic_efd, EPOLL_CTL_ADD,
+ gIco_Dic_Mng.WaylandFd, &ev) != 0) {
+ ICO_ERR("ico_dic_wayland_init: Leave(ERR), Epoll ctl Error");
+ return ICO_DIC_ERR;
+ }
+ ICO_TRA("ico_dic_wayland_init: Leave(EOK)");
+ return ICO_DIC_OK;
+}
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief ico_dic_wayland_globalcb
+ *
+ * @param[in] data the information that appointed at the time of
+ * callback registration
+ * @param[in] registry wayland registry
+ * @param[in] wldispid wayland displya id
+ * @param[in] event event name
+ * @param[in] version version of Wayland
+ * @return nothing
+ */
+/*--------------------------------------------------------------------------*/
+static void
+ico_dic_wayland_globalcb(void *data, struct wl_registry *registry, uint32_t wldispid,
+ const char *event, uint32_t version)
+{
+ ICO_DBG("ico_dic_wayland_globalcb: Event=%s DispId=%08x", event, wldispid);
+
+ if (strcmp(event, "ico_window_mgr") == 0) {
+ gIco_Dic_Mng.Wayland_WindowMgr = wl_registry_bind(gIco_Dic_Mng.Wayland_Registry,
+ wldispid,
+ &ico_window_mgr_interface, 1);
+ ICO_DBG("ico_dic_wayland_globalcb: wl_registry_bind(ico_window_mgr)");
+ }
+ else if (strcmp(event, "ico_input_mgr_control") == 0) {
+ /* conect to multi input manager control interface */
+ gIco_Dic_Mng.Wayland_InputCtl = wl_registry_bind(gIco_Dic_Mng.Wayland_Registry,
+ wldispid,
+ &ico_input_mgr_control_interface, 1);
+ ICO_DBG("ico_dic_wayland_globalcb: wl_registry_bind(ico_input_mgr_control)");
+ }
+ else if (strcmp(event, "ico_input_mgr_device") == 0) {
+ /* conect to multi input manager device interface */
+ gIco_Dic_Mng.Wayland_InputMgr = wl_registry_bind(gIco_Dic_Mng.Wayland_Registry,
+ wldispid,
+ &ico_input_mgr_device_interface, 1);
+ ICO_DBG("ico_dic_wayland_globalcb: wl_registry_bind(ico_input_mgr_device)");
+ }
+}
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief ico_dic_wayland_iterate
+ * iterate processing of wayland
+ *
+ * @param[in] timeout wait time miri-sec
+ * @return nothing
+ */
+/*--------------------------------------------------------------------------*/
+int
+ico_dic_wayland_iterate(struct epoll_event *ev_ret, int timeout)
+{
+ int nfds;
+ int ii;
+ static int errcount = 0;
+
+ memset(ev_ret, 0, sizeof(struct epoll_event) * ICO_DIC_EVENT_NUM);
+ wl_display_flush(gIco_Dic_Mng.Wayland_Display);
+
+ while (1) {
+ if ((nfds = epoll_wait(gIco_Dic_Mng.Dic_efd, ev_ret,
+ ICO_DIC_EVENT_NUM, timeout)) > 0) {
+ for (ii = 0; ii < nfds; ii++) {
+ if (ev_ret[ii].data.fd == gIco_Dic_Mng.WaylandFd) {
+ wl_display_dispatch(gIco_Dic_Mng.Wayland_Display);
+ ICO_DBG("ico_dic_wayland_iterate: Event wayland fd");
+ errcount ++;
+ if (errcount > 50) {
+ ICO_ERR("ico_dic_wayland_iterate: Error wayland disconnect");
+ exit(9);
+ }
+ if ((errcount % 5) == 0) {
+ usleep(50*1000);
+ }
+ }
+ else {
+ errcount = 0;
+ }
+ }
+ return nfds;
+ }
+ else if (nfds == 0) {
+ return 0;
+ }
+ }
+}
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief ico_dic_add_fd
+ * Add file descriptor to watch in pool.
+ *
+ * @param[in] fd File descriptor
+ * @return result
+ * @retval ICO_DIC_EOK Success
+ * @retval ICO_DIC_ERR Failed
+ */
+/*--------------------------------------------------------------------------*/
+int
+ico_dic_add_fd(int fd)
+{
+ ICO_DBG("ico_dic_add_fd: Enter(fd=%d)", fd);
+
+ struct epoll_event ev;
+
+ if (gIco_Dic_Mng.Dic_efd <= 0) {
+ ICO_ERR("ico_dic_add_fd: Leave(ERR), Epoll Never Created");
+ return ICO_DIC_ERR;
+ }
+
+ memset(&ev, 0, sizeof(ev));
+ ev.events = EPOLLIN;
+ ev.data.fd = fd;
+ if (epoll_ctl(gIco_Dic_Mng.Dic_efd, EPOLL_CTL_ADD, fd, &ev) != 0) {
+ ICO_ERR("ico_dic_add_fd: Leave(ERR), Epoll ctl Error");
+ return ICO_DIC_ERR;
+ }
+ ICO_DBG("ico_dic_add_fd: Leave(EOK)");
+
+ return ICO_DIC_OK;
+}
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief ico_dic_wayland_finish
+ * Finish wayland connection
+ *
+ * @param nothing
+ * @return nothing
+ */
+/*--------------------------------------------------------------------------*/
+void
+ico_dic_wayland_finish(void)
+{
+ ICO_DBG("ico_dic_wayland_finish: Enter");
+
+ wl_display_flush(gIco_Dic_Mng.Wayland_Display);
+ wl_display_disconnect(gIco_Dic_Mng.Wayland_Display);
+
+ ICO_DBG("ico_dic_wayland_finish: Leave");
+}
+
+++ /dev/null
-## Multi Input Controller Configurations for joystick_gtforce
-## /opt/etc/ico-uxf-device-input-controller/joystick_gtforce.conf
-## Feb-08-2013
-
-## Device
-[device]
-# Device Name
-name=DrivingForceGT
-# Device Input Controller
-ictl=ico_ictl-joystick
-# Device type('8' is input switch)
-type=8
-# ECU Id
-ecu=0
-
-## Input Switch
-[input]
-## UpDown key input
-0=JS_UPDOWN
-# input event from device(type;number)
-0.event=2;3
-# event code to Multi Input Manager(Up;Down)
-0.code=10:Up;11:Down
-
-## LeftRight key input
-1=JS_LR
-# input event from device(type;number)
-1.event=2;2
-# event code to Multi Input Manager(Left;Right)
-1.code=20:Left;21:Right
-
-## CROSS Button input
-2=JS_CROSS
-# input event from device(type;number)
-2.event=1;0
-# event code to Multi Input Manager
-2.code=30
-
-## SQUARE Button input
-3=JS_SQUARE
-# input event from device(type;number)
-3.event=1;1
-# event code to Multi Input Manager
-3.code=40
-
-## CIRCLE Button input
-4=JS_CIRCLE
-# input event from device(type;number)
-4.event=1;2
-# event code to Multi Input Manager
-4.code=50
-
-## TRIANGLE Button input
-5=JS_TRIANGLE
-# input event from device(type;number)
-5.event=1;3
-# event code to Multi Input Manager
-5.code=60
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief Current date & time string for log output
- *
- * @date Feb-08-2013
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <math.h>
-#include <sys/time.h>
-#include <time.h>
-
-const char *dbg_curtime(void);
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief dbg_curtime: Current time for Debug Write
- *
- * @param None
- * @return String pointer for current time
- */
-/*--------------------------------------------------------------------------*/
-const char *
-dbg_curtime(void)
-{
- struct timeval NowTime; /* Current date & time */
- static int NowZone = (99*60*60);/* Local time */
- extern long timezone; /* System time zone */
- static char sBuf[28];
-
- if (NowZone > (24*60*60)) {
- tzset();
- NowZone = timezone;
- }
- gettimeofday(&NowTime, (struct timezone *)0);
- NowTime.tv_sec -= NowZone;
-
- sprintf(sBuf, "[%02d:%02d:%02d.%03d]",
- (int)((NowTime.tv_sec/3600) % 24),
- (int)((NowTime.tv_sec/60) % 60),
- (int)(NowTime.tv_sec % 60),
- (int)NowTime.tv_usec/1000);
-
- return(sBuf);
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief header file of Input Controllers
- *
- * @date Feb-20-2013
- */
-
-#ifndef _ICO_ICTL_LOCAL_H_
-#define _ICO_ICTL_LOCAL_H_
-
-#include <wayland-client-protocol.h>
-#include <wayland-client.h>
-#include <wayland-egl.h>
-#include <wayland-util.h>
-#include <sys/ioctl.h>
-#include <sys/epoll.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#include <ico_input_mgr-client-protocol.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* call back function */
-typedef void (*Ico_ICtl_Wayland_Cb)( void );
-
-/* Deafult config file */
-#define ICO_ICTL_CONF_FILE \
- "/opt/etc/ico-uxf-device-input-controller/joystick_gtforce.conf"
-/* Environment valible name for config file */
-#define ICO_ICTL_CONF_ENV "ICTL_GTFORCE_CONF"
-/* Environment valible name for input device*/
-#define ICO_ICTL_INPUT_DEV "ICTL_GTFORCE_DEV"
-
-#define ICO_ICTL_TOUCH_NONE 0 /* not exist touch event */
-#define ICO_ICTL_TOUCH_KEYIN 1 /* touch event is reserved */
-#define ICO_ICTL_TOUCH_PASSED 2 /* touch event is passed */
-
-#define ICO_ICTL_EVENT_NUM (16)
-/* return val */
-#define ICO_ICTL_OK 0 /* success */
-#define ICO_ICTL_ERR (-1) /* failedi */
-
-/* management table */
-typedef struct _Ico_ICtl_Mng {
- /* Multi Input Controller */
- int ICTL_ID; /* multi input controller ID */
- Ico_ICtl_Wayland_Cb ICtl_CallBack; /* call back function */
-
- /* wayland interfaces */
- struct wl_display *Wayland_Display; /* Wayland Display */
- struct wl_registry *Wayland_Registry; /* Wayland Registory */
- struct ico_input_mgr_device *Wayland_InputMgr; /* Wayland multi input manager */
-
- int WaylandFd; /* file descriptor of Wayland */
- int ICTL_EFD; /* descriptor of epoll */
-
-} Ico_ICtl_Mng;
-
-/* function prototype */
- /* initialization to wayland */
-int ico_ictl_wayland_init(const char *display ,Ico_ICtl_Wayland_Cb callback);
-void ico_ictl_wayland_finish(void); /* finish wayland connection */
- /* iterate wayland connection */
-int ico_ictl_wayland_iterate(struct epoll_event *ev_ret, int timeout);
-int ico_ictl_add_fd(int fd); /* add file descriptor */
-
-/* macro for debug */
-extern const char *dbg_curtime(void);
-extern int mDebug;
-#define DEBUG_PRINT(fmt, ...) \
- {if (mDebug) {fprintf(stderr, "%sDBG> "fmt" (%s:%d)\n",dbg_curtime(),##__VA_ARGS__,__FILE__,__LINE__); fflush(stderr);}}
-#define ERROR_PRINT(fmt, ...) \
- {fprintf(stderr, "%sERR> "fmt" (%s:%d)\n",dbg_curtime(),##__VA_ARGS__,__FILE__,__LINE__); fflush(stderr);}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* _ICO_ICTL_LOCAL_H_ */
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief Device Input Controllers(wayland processing)
- * processing related wayland
- *
- * @date Feb-08-2013
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <strings.h>
-#include <errno.h>
-#include <pthread.h>
-
-#include "ico_ictl-local.h"
-
-/* prototype of static function */
-/* callback function from wayland global */
-static void ico_ictl_wayland_globalcb(void *data, struct wl_registry *registry,
- uint32_t wldispid, const char *event,
- uint32_t version);
-
-/* table/variable */
-extern Ico_ICtl_Mng gIco_ICtrl_Mng;
-
-static const struct wl_registry_listener registry_listener = {
- ico_ictl_wayland_globalcb
-};
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief ico_ictl_wayland_init
- * connect to wayland of specified Display. specified NULL to
- * connected Display, connect to the default Display.
- *
- * @param[in] display display to connect
- * @param[in] callback callback function
- * @return result
- * @retval ICO_ICTL_EOK Success
- * @retval ICO_ICTL_ERR Failed
- */
-/*--------------------------------------------------------------------------*/
-int
-ico_ictl_wayland_init(const char *display, Ico_ICtl_Wayland_Cb callback)
-{
- DEBUG_PRINT("ico_ictl_wayland_init: Enter");
-
- int ret;
-
- /* regist callback funtion */
- gIco_ICtrl_Mng.ICtl_CallBack = callback;
-
- /* connect to wayland(retry max 3 sec) */
- for (ret = 0; ret < (3000/20); ret++) {
- gIco_ICtrl_Mng.Wayland_Display = wl_display_connect(display);
- if (gIco_ICtrl_Mng.Wayland_Display) {
- break;
- }
- usleep(20*1000);
- }
- if (! gIco_ICtrl_Mng.Wayland_Display) {
- ERROR_PRINT("ico_ictl_wayland_init: Leave(ERR), Wayland Connect Error");
- return ICO_ICTL_ERR;
- }
-
- /* add listener of wayland registry */
- gIco_ICtrl_Mng.Wayland_Registry =
- wl_display_get_registry(gIco_ICtrl_Mng.Wayland_Display);
- wl_registry_add_listener(gIco_ICtrl_Mng.Wayland_Registry,
- ®istry_listener, &gIco_ICtrl_Mng);
-
- /* display dispatch to wait */
- do {
- wl_display_dispatch(gIco_ICtrl_Mng.Wayland_Display);
- } while (gIco_ICtrl_Mng.Wayland_InputMgr == NULL);
-
- /* get the Wayland descriptor */
- gIco_ICtrl_Mng.WaylandFd =
- wl_display_get_fd(gIco_ICtrl_Mng.Wayland_Display);
- DEBUG_PRINT("ico_ictl_wayland_init: WFD = %d", gIco_ICtrl_Mng.WaylandFd);
-
- /* create epoll file descriptor */
- gIco_ICtrl_Mng.ICTL_EFD = epoll_create1(EPOLL_CLOEXEC);
- if (gIco_ICtrl_Mng.ICTL_EFD < 0) {
- ERROR_PRINT("ico_ictl_wayland_init: Leave(ERR), Epoll Create Error");
- return ICO_ICTL_ERR;
- }
- struct epoll_event ev;
- memset(&ev, 0, sizeof(ev));
- ev.events = EPOLLIN;
- ev.data.fd = gIco_ICtrl_Mng.WaylandFd;
- if (epoll_ctl(gIco_ICtrl_Mng.ICTL_EFD, EPOLL_CTL_ADD,
- gIco_ICtrl_Mng.WaylandFd, &ev) != 0) {
- ERROR_PRINT("ico_ictl_wayland_init: Leave(ERR), Epoll ctl Error");
- return ICO_ICTL_ERR;
- }
- DEBUG_PRINT("ico_ictl_wayland_init: Leave(EOK)");
- return ICO_ICTL_OK;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief ico_ictl_wayland_globalcb
- *
- * @param[in] data the information that appointed at the time of
- * callback registration
- * @param[in] registry wayland registry
- * @param[in] wldispid wayland displya id
- * @param[in] event event name
- * @param[in] version version of Wayland
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-ico_ictl_wayland_globalcb(void *data, struct wl_registry *registry, uint32_t wldispid,
- const char *event, uint32_t version)
-{
- DEBUG_PRINT("ico_ictl_wayland_globalcb: Event=%s DispId=%08x", event, wldispid);
-
- if (strcmp(event, "ico_input_mgr_device") == 0) {
- /* connect ictl_master in multi input manager */
- gIco_ICtrl_Mng.Wayland_InputMgr = (struct ico_input_mgr_device *)
- wl_registry_bind(gIco_ICtrl_Mng.Wayland_Registry,
- wldispid, &ico_input_mgr_device_interface, 1);
-
- DEBUG_PRINT("ico_ictl_wayland_globalcb: wl_registry_bind(ico_input_mgr_device)");
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief ico_ictl_wayland_iterate
- * iterate processing of wayland
- *
- * @param[in] timeout wait time miri-sec
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-int
-ico_ictl_wayland_iterate(struct epoll_event *ev_ret, int timeout)
-{
- int nfds;
- int ii = 0;
-
- memset(ev_ret, 0, sizeof(struct epoll_event) * ICO_ICTL_EVENT_NUM);
- wl_display_flush(gIco_ICtrl_Mng.Wayland_Display);
-
- while (1) {
- if ((nfds = epoll_wait( gIco_ICtrl_Mng.ICTL_EFD, ev_ret,
- ICO_ICTL_EVENT_NUM, timeout)) > 0) {
- for (ii = 0; ii < nfds; ii++) {
- if (ev_ret[ii].data.fd == gIco_ICtrl_Mng.WaylandFd) {
- wl_display_dispatch(gIco_ICtrl_Mng.Wayland_Display);
- DEBUG_PRINT( "ico_ictl_wayland_iterate: Exit wayland fd");
- }
- }
- return nfds;
- }
- else if (nfds == 0) {
- return nfds;
- }
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief ico_ictl_add_fd
- * Add file descriptor to watch in pool.
- *
- * @param[in] fd File descriptor
- * @return result
- * @retval ICO_ICTL_EOK Success
- * @retval ICO_ICTL_ERR Failed
- */
-/*--------------------------------------------------------------------------*/
-int
-ico_ictl_add_fd(int fd)
-{
- DEBUG_PRINT("ico_ictl_add_fd: Enter(fd=%d)", fd);
-
- struct epoll_event ev;
-
- if (gIco_ICtrl_Mng.ICTL_EFD <= 0) {
- ERROR_PRINT("ico_ictl_add_fd: Leave(ERR), Epoll Never Created");
- return ICO_ICTL_ERR;
- }
-
- memset(&ev, 0, sizeof(ev));
- ev.events = EPOLLIN;
- ev.data.fd = fd;
- if (epoll_ctl(gIco_ICtrl_Mng.ICTL_EFD, EPOLL_CTL_ADD, fd, &ev) != 0) {
- ERROR_PRINT("ico_ictl_add_fd: Leave(ERR), Epoll ctl Error");
- return ICO_ICTL_ERR;
- }
- DEBUG_PRINT("ico_ictl_add_fd: Leave(EOK)");
-
- return ICO_ICTL_OK;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief ico_ictl_wayland_finish
- * Finish wayland connection
- *
- * @param nothing
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-void
-ico_ictl_wayland_finish(void)
-{
- DEBUG_PRINT("ico_ictl_wayland_finish: Enter");
-
- wl_display_flush(gIco_ICtrl_Mng.Wayland_Display);
- wl_display_disconnect(gIco_ICtrl_Mng.Wayland_Display);
-
- DEBUG_PRINT("ico_ictl_wayland_finish: Leave");
-}
-
+* Thu Sep 19 2013 Shibata Makoto <shibata@mac.tec.toyota.co.jp> submit/tizen/20130919.104803@2537721
+- 0.9.01 release.
+-- The initial release for TizenIVI 3.0.
+-- Support GTForce (G25 and G27).
+-- Abolished the touch panel (including the calibration) support, because it became the standard support of Weston.
+
* Wed Jun 12 2013 Shibata Makoto <shibata@mac.tec.toyota.co.jp> accepted/2.0alpha-wayland/20130606.173259@3f487a2
- 0.5.05 release
- The change of the package test program with the interface change of ico-uxf-weston-plugin.
Name: ico-uxf-device-input-controller
Summary: Device Input Controller
-Version: 0.5.05
+Version: 0.9.01
Release: 1.1
Group: System/GUI
License: Apache License, Version 2.0
URL: ""
Source0: %{name}-%{version}.tar.bz2
-BuildRequires: pkgconfig(wayland-client) >= 1.0
-BuildRequires: pkgconfig(wayland-egl)
+BuildRequires: pkgconfig(wayland-client) >= 1.2.0
+BuildRequires: mesa-devel
BuildRequires: pkgconfig(egl)
BuildRequires: pkgconfig(glesv2)
BuildRequires: pkgconfig(glib-2.0)
-BuildRequires: ico-uxf-weston-plugin-devel >= 0.5.05
-Requires: weston >= 1.0
-Requires: ico-uxf-weston-plugin >= 0.5.05
+BuildRequires: ico-uxf-weston-plugin-devel >= 0.9.04
+BuildRequires: ico-uxf-utilities-devel >= 0.2.04
+Requires: weston >= 1.2.1
+Requires: ico-uxf-weston-plugin >= 0.9.04
+Requires: ico-uxf-utilities >= 0.2.04
%description
Device Input Controller for ico-uxf-weston-plugin(Multi Input Manager)
%setup -q -n %{name}-%{version}
%build
-autoreconf --install
-
-%autogen --prefix=/usr
+%autogen
%configure
make %{?_smp_mflags}
%make_install
# configurations
-%define ictl_conf /opt/etc/ico-uxf-device-input-controller
+%define ictl_conf /opt/etc/ico/device-input-controller
mkdir -p %{buildroot}%{ictl_conf}
-install -m 0644 joystick_gtforce.conf %{buildroot}%{ictl_conf}
-install -m 0644 egalax_calibration.conf %{buildroot}%{ictl_conf}
+install -m 0644 settings/drivingforcegt.conf %{buildroot}%{ictl_conf}
+install -m 0644 settings/g27racingwheel.conf %{buildroot}%{ictl_conf}
+install -m 0755 settings/set_daynight.sh %{buildroot}%{ictl_conf}
+install -m 0755 settings/set_navi_busguide.sh %{buildroot}%{ictl_conf}
+install -m 0755 settings/set_navi_destination.sh %{buildroot}%{ictl_conf}
+install -d %{buildroot}/%{_unitdir_user}/weston.target.wants
+install -m 644 settings/ico-device-input-controller.service %{buildroot}%{_unitdir_user}/ico-device-input-controller.service
+install -m 644 settings/ico-dic-wait-weston-ready.path %{buildroot}%{_unitdir_user}/ico-dic-wait-weston-ready.path
+ln -sf ../ico-dic-wait-weston-ready.path %{buildroot}/%{_unitdir_user}/weston.target.wants/
%files
%defattr(-,root,root,-)
-%{_bindir}/ico_ictl-joystick_gtforce
-%{_bindir}/ico_ictl-touch_egalax
-%{_bindir}/ico_ictl-egalax_calibration
-%{ictl_conf}/joystick_gtforce.conf
-%{ictl_conf}/egalax_calibration.conf
-
+%{_bindir}/ico_dic-gtforce
+%{ictl_conf}/drivingforcegt.conf
+%{ictl_conf}/g27racingwheel.conf
+%{ictl_conf}/set_daynight.sh
+%{ictl_conf}/set_navi_busguide.sh
+%{ictl_conf}/set_navi_destination.sh
+/usr/lib/systemd/user/ico-device-input-controller.service
+/usr/lib/systemd/user/ico-dic-wait-weston-ready.path
+/usr/lib/systemd/user/weston.target.wants/ico-dic-wait-weston-ready.path
--- /dev/null
+## Multi Input Controller Configurations for GtForce
+## /opt/etc/ico/device-input-controller/gtforce_g25.conf
+## Sep-08-2013
+
+## Device
+[device]
+# Device Name
+name=Driving Force GT
+# Device Input Controller
+dic=ico_uxf_dic-gtforce
+# Device type('8' is input switch)
+type=8
+# ECU Id
+ecu=0
+
+## Input Switch
+[input]
+## UpDown key input
+0=JS_UPDOWN
+# input event from device(type;number)
+0.event=2;4
+# event code to Multi Input Manager(Up;Down)
+0.code=10:Up;11:Down
+# fixed send appid (if fixed switch) ... send key event(Up='U',Down='D') to HapticDaemon
+0.fixed=10:appid=ico_uxf_dic-haptic:key=22;11:appid=ico_uxf_dic-haptic:key=32
+
+## LeftRight key input
+1=JS_LR
+# input event from device(type;number)
+1.event=2;3
+# event code to Multi Input Manager(Left;Right)
+1.code=20:Left;21:Right
+# fixed send appid (if fixed switch) ... send key event(Left='L',Right='R') to HapticDaemon
+1.fixed=20:appid=ico_uxf_dic-haptic:key=38;21:appid=ico_uxf_dic-haptic:key=19
+
+## CROSS Button input
+2=JS_CROSS
+# input event from device(type;number)
+2.event=1;0
+# event code to Multi Input Manager
+2.code=30
+2.fixed=appid=org.tizen.ico.homescreen:key=50
+
+## SQUARE Button input
+3=JS_SQUARE
+# input event from device(type;number)
+3.event=1;1
+# event code to Multi Input Manager
+3.code=40
+3.fixed=shell=/opt/etc/ico/device-input-controller/set_navi_busguide.sh
+
+## CIRCLE Button input
+4=JS_CIRCLE
+# input event from device(type;number)
+4.event=1;2
+# event code to Multi Input Manager
+4.code=50
+4.fixed=appid=ico_uxf_dic-haptic:key=24
+
+## TRIANGLE Button input
+5=JS_TRIANGLE
+# input event from device(type;number)
+5.event=1;3
+# event code to Multi Input Manager
+5.code=60
+# fixed start shell script
+5.fixed=shell=/opt/etc/ico/device-input-controller/set_daynight.sh
+
+## PS Button
+6=JS_PS
+6.event=1;20
+6.code=101
+6.fixed=shell=/opt/etc/ico/device-input-controller/set_navi_destination.sh
+
+## Home Button
+#7=JS_HOME
+#7.event=1;19
+#7.code=102
+
+## Enter Button
+#8=JS_ENTER
+#8.event=1;14
+#8.code=103
+
+## Start Button
+#9=JS_START
+#9.event=1;9
+#9.code=104
+
+## Select Button
+#10=JS_SELECT
+#10.event=1;8
+#10.code=105
+
+## + Button
+#11=JS_PLUS
+#11.event=1;15
+#11.code=111
+
+## - Button
+#12=JS_MINUS
+#12.event=1;18
+#12.code=112
+
--- /dev/null
+## Multi Input Controller Configurations for GtForce
+## /opt/etc/ico/device-input-controller/gtforce_g27.conf
+## Sep-08-2013
+
+## Device
+[device]
+# Device Name
+name=G27 Racing Wheel
+# Device Input Controller
+dic=ico_uxf_dic-gtforce
+# Device type('8' is input switch)
+type=8
+# ECU Id
+ecu=0
+
+## Input Switch
+[input]
+## UpDown key input
+0=JS_UPDOWN
+# input event from device(type;number)
+0.event=2;5
+# event code to Multi Input Manager(Up;Down)
+0.code=10:Up;11:Down
+# fixed send appid (if fixed switch) ... send key event(Up='U',Down='D') to HapticDaemon
+0.fixed=10:appid=ico_uxf_dic-haptic:key=22;11:appid=ico_uxf_dic-haptic:key=32
+
+## LeftRight key input
+1=JS_LR
+# input event from device(type;number)
+1.event=2;4
+# event code to Multi Input Manager(Left;Right)
+1.code=20:Left;21:Right
+# fixed send appid (if fixed switch) ... send key event(Left='L',Right='R') to HapticDaemon
+1.fixed=20:appid=ico_uxf_dic-haptic:key=38;21:appid=ico_uxf_dic-haptic:key=19
+
+## CROSS Button(Black action button buttom) input
+2=JS_CROSS
+# input event from device(type;number)
+2.event=1;0
+# event code to Multi Input Manager
+2.code=30
+2.fixed=appid=org.tizen.ico.homescreen:key=50
+
+## SQUARE Button(Black action button left) input
+3=JS_SQUARE
+# input event from device(type;number)
+3.event=1;1
+# event code to Multi Input Manager
+3.code=40
+3.fixed=shell=/opt/etc/ico/device-input-controller/set_navi_busguide.sh
+
+## CIRCLE Button(Black action button right) input
+4=JS_CIRCLE
+# input event from device(type;number)
+4.event=1;2
+# event code to Multi Input Manager
+4.code=50
+4.fixed=appid=ico_uxf_dic-haptic:key=24
+
+## TRIANGLE Button(Black action button top) input
+5=JS_TRIANGLE
+# input event from device(type;number)
+5.event=1;3
+# event code to Multi Input Manager
+5.code=60
+# fixed start shell script
+5.fixed=shell=/opt/etc/ico/device-input-controller/set_daynight.sh
+
+## Shift Red Button
+6=RED_1
+6.event=1;11
+6.code=101
+6.fixed=shell=/opt/etc/ico/device-input-controller/set_navi_destination.sh
+#7=RED_2
+#7.event=1;8
+#7.code=102
+#8=RED_3
+#8.event=1;9
+#8.code=103
+#9=RED_4
+#9.event=1;10
+#9.code=104
+
+## Handle Left Red Buttons
+#10=LEFT_UPPER
+#10.event=1;7
+#10.code=71
+#11=LEFT_MIDDLE
+#11.event=1;20
+#11.code=72
+#12=LEFT_LOWER
+#12.event=1;21
+#12.code=73
+
+## Handle Right Red Button
+#13=RIGHT_UPPER
+#13.event=1;6
+#13.code=81
+#14=RIGHT_MIDDLE
+#14.event=1;18
+#14.code=82
+#15=RIGHT_LOWER
+#15.event=1;19
+#15.code=83
+
+## Handle Under Switch
+#16=HANDLE_LEFT
+#16.event=1;5
+#16.code=91
+#17=HANDLE_RIGHT
+#17.event=1;4
+#17.code=92
--- /dev/null
+[Unit]
+Description=ico device input controller
+Requires=weston.service
+After=weston.service
+
+[Service]
+#Environment=XDG_RUNTIME_DIR=/run/user/5000
+Type=oneshot
+ExecStart=/usr/bin/ico_dic-gtforce -d
+
--- /dev/null
+Description=Path activation for ico-device-input-controller
+
+[Path]
+PathExists=/run/user/5000/wayland-0.lock
+#PathExists=/tmp/amd_ready
+Unit=ico-device-input-controller.service
+
+[Install]
+WantedBy=weston.target
--- /dev/null
+#!/bin/sh
+#
+# set day/night mode
+
+if [ -e /tmp/daynight_sw.day ] ; then
+ rm -fr /tmp/daynight_sw.day
+ /usr/local/bin/ico_set_vehicleinfo EXTERIOR=0
+else
+ touch /tmp/daynight_sw.day
+ /usr/local/bin/ico_set_vehicleinfo EXTERIOR=1000
+fi
--- /dev/null
+#!/bin/sh
+#
+# sample navi bus guide control
+
+if [ -e /tmp/busguide_sw.off ] ; then
+ rm -fr /tmp/busguide_sw.off
+ /usr/local/bin/set_navi_info genr ON &
+else
+ touch /tmp/busguide_sw.off
+ /usr/local/bin/set_navi_info genr OFF &
+fi
--- /dev/null
+#!/bin/sh
+#
+# set sample navi destination
+
+/usr/local/bin/set_navi_info dest 35.497467 139.405041 &
# Remark: This examination premises that Weston does not run.
# 1 Delete log file
-rm -fr ../tests/testlog
-mkdir ../tests/testlog
+mkdir ../tests/testlog 2> /dev/null
+rm -fr ../tests/testlog/* 2> /dev/null
-# 2 Start Pseudo event device (for Touch Panel and Jyostick)
-../tests/test-send_event -device=ico_test_touch -d -mq=55551 2> ../tests/testlog/event_log_touch.log &
-../tests/test-send_event -device=ico_test_joystick -d -J -mq=55552 2> ../tests/testlog/event_log_joystic.log &
-sleep 1
+# 2 set weston environment
+export XDG_RUNTIME_DIR=/run/user/5000
# 3 Start Device Input Controllers
-export CALIBRATOIN_CONF="../egalax_calibration.conf"
-export ICTL_TOUCH_DEV="ico_test_touch"
-#../touch_egalax/ico_ictl-touch_egalax -d -L ico_test_touch 2> ../tests/testlog/touch_egalax.log &
-../touch_egalax/ico_ictl-touch_egalax -d -L > ../tests/testlog/touch_egalax.log 2>&1 &
+export DIC_GTFORCE_CONF="../settings/g27racingwheel.conf"
+../gtforce/ico_uxf_dic-gtforce -d -L 2> ../tests/testlog/gtforce.log &
sleep 0.5
-export ICTL_GTFORCE_CONF="../joystick_gtforce.conf"
-export ICTL_GTFORCE_DEV="ico_test_joystick"
-#../joystick_gtforce/ico_ictl-joystick_gtforce -d -l ico_test_joystick 2> ../tests/testlog/joystick_gtforce.log &
-../joystick_gtforce/ico_ictl-joystick_gtforce -d -l > ../tests/testlog/joystick_gtforce.log 2>&1 &
-sleep 1
-
-# 4 Weston/Wayland Envionment
-export XDG_RUNTIME_DIR=/tmp/run-root
-export QT_QPA_PLATFORM=wayland
-export ELM_ENGINE=wayland_egl
-export ECORE_EVAS_ENGINE=wayland_egl
-#export ELM_ENGINE=wayland_shm
-#export ECORE_EVAS_ENGINE=wayland_shm
-export EVAS_FONT_DPI=72
-export ECORE_IMF_MODULE=isf
-export ELM_MODULES="ctxpopup_copypasteUI>entry/api:datetime_input_ctxpopup>datetime/api"
-export ELM_SCALE="0.7"
-export ELM_PROFILE=mobile
-
-# 5 Start Weston
-export XDG_CONFIG_HOME="../tests"
-/usr/bin/weston --backend=drm-backend.so --idle-time=0 --log=../tests/testlog/weston.log &
-sleep 1
-# 5 Start test-homescreen
-../tests/test-homescreen < ../tests/testdata/hs_alltest.dat 2> ../tests/testlog/test-homescreen.log
+# 4 Start Weston
+/usr/bin/weston --idle-time=0 $WESTON_BACKEND --log=../tests/testlog/weston.log &
+sleep 600
-# 6 End of Test
+# 5 End of Test
sleep 1
/usr/bin/killall weston
-/usr/bin/killall test-send_event
-/usr/bin/killall test-send_event
-/usr/bin/killall ico_ictl-touch_egalax
-/usr/bin/killall ico_ictl-joystick_gtforce
+/usr/bin/killall ico_uxf_dic-gtforce
sleep 1
# 9 Check Error
if [ "$?" != "1" ] ; then
FOUND_ERR=1
fi
-/bin/grep "error" testlog/* | /bin/grep -v "error_but_no_problem_for_test"
+/bin/grep "error" testlog/*
if [ "$?" != "1" ] ; then
FOUND_ERR=1
fi
-/bin/grep "Fail" testlog/* | /bin/grep -v "error_but_no_problem_for_test"
+/bin/grep "Fail" testlog/*
if [ "$?" != "1" ] ; then
FOUND_ERR=1
fi
/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2013 TOYOTA MOTOR CORPORATION
*
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
*
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
*/
/**
- * @brief Wayland Application for uint test of Weston(Wayland) IVI plugins
+ * @brief Wayland Application for unit test of Weston(Wayland) IVI plugins
*
* @date Feb-08-2013
*/
#include <poll.h>
#include <wayland-client.h>
#include <linux/input.h>
-#include "ico_ivi_shell-client-protocol.h"
#include "ico_window_mgr-client-protocol.h"
#include "ico_input_mgr-client-protocol.h"
#include "test-common.h"
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_shell *shell;
- struct ico_ivi_shell *ico_ivi_shell;
struct ico_window_mgr *ico_window_mgr;
struct ico_exinput *ico_exinput;
struct input *input;
struct wl_seat *seat;
struct wl_pointer *pointer;
struct wl_keyboard *keyboard;
+ struct wl_touch *touch;
float x, y;
uint32_t button_mask;
struct surface *pointer_focus;
input->pointer_focus = wl_surface_get_user_data(surface);
input->x = wl_fixed_to_double(x);
input->y = wl_fixed_to_double(y);
- print_log("CLIENT: got pointer enter (%d,%d), surface %p",
- (int)input->x, (int)input->y, surface);
+ print_log("CLIENT: got pointer enter (%d,%d)=(%d,%d), surface %p",
+ x, y, (int)input->x, (int)input->y, surface);
}
static void
input->x = wl_fixed_to_double(x);
input->y = wl_fixed_to_double(y);
- print_log("CLIENT: got pointer motion (%d,%d)", (int)input->x, (int)input->y);
+ print_log("CLIENT: got pointer motion (%d,%d)=(%d,%d)",
+ x, y, (int)input->x, (int)input->y);
}
static void
print_log("CLIENT: got keyboard modifier");
}
+static void
+touch_handle_down(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
+ struct wl_surface *surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+ print_log("CLIENT: got touch down %d (%d,%d)", id, x/256, y/256);
+}
+
+static void
+touch_handle_up(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
+ int32_t id)
+{
+ print_log("CLIENT: got touch up %d", id);
+}
+
+static void
+touch_handle_motion(void *data, struct wl_touch *wl_touch, uint32_t time,
+ int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+ print_log("CLIENT: got touch motion %d (%d,%d)", id, x/256, y/256);
+}
+
+static void
+touch_handle_frame(void *data, struct wl_touch *wl_touch)
+{
+ print_log("CLIENT: got touch frame");
+}
+
+static void
+touch_handle_cancel(void *data, struct wl_touch *wl_touch)
+{
+ print_log("CLIENT: got touch cancel");
+}
+
static const struct wl_pointer_listener pointer_listener = {
pointer_handle_enter,
pointer_handle_leave,
keyboard_handle_modifiers,
};
+static const struct wl_touch_listener touch_listener = {
+ touch_handle_down,
+ touch_handle_up,
+ touch_handle_motion,
+ touch_handle_frame,
+ touch_handle_cancel
+};
+
static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
enum wl_seat_capability caps)
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
input->pointer = wl_seat_get_pointer(seat);
wl_pointer_set_user_data(input->pointer, input);
- wl_pointer_add_listener(input->pointer, &pointer_listener,
- input);
+ wl_pointer_add_listener(input->pointer, &pointer_listener, input);
}
else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
wl_pointer_destroy(input->pointer);
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
input->keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_set_user_data(input->keyboard, input);
- wl_keyboard_add_listener(input->keyboard, &keyboard_listener,
- input);
+ wl_keyboard_add_listener(input->keyboard, &keyboard_listener, input);
}
else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
wl_keyboard_destroy(input->keyboard);
input->keyboard = NULL;
}
+
+ if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->touch) {
+ input->touch = wl_seat_get_touch(seat);
+ wl_touch_set_user_data(input->touch, input);
+ wl_touch_add_listener(input->touch, &touch_listener, input);
+ }
+ else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->touch) {
+ wl_touch_destroy(input->touch);
+ input->touch = NULL;
+ }
}
static const struct wl_seat_listener seat_listener = {
{
struct output *output = data;
+ print_log("CLIENT: Event[handle_geometry] x/y=%d/%d p.w/h=%d/%d trans=%d",
+ x, y, physical_width, physical_height, transform);
+
output->x = x;
output->y = y;
-
- print_log("CLIENT: Output[geometry] x/y=%d/%d,trans=%d", x, y, transform);
}
static void
{
struct output *output = data;
+ print_log("CLIENT: Event[handle_mode] %08x x/y=%d/%d flags=%08x refresh=%d",
+ (int)wl_output, width, height, flags, refresh);
+
if (flags & WL_OUTPUT_MODE_CURRENT) {
output->width = width;
output->height = height;
- print_log("CLIENT: Output[mode] w/h=%d/%d", width, height);
}
}
print_log("CLIENT: handle_global: interface=<%s> id=%d", interface, (int)id);
if (strcmp(interface, "wl_compositor") == 0) {
- display->compositor =
- wl_registry_bind(display->registry,
- id, &wl_compositor_interface, 1);
+ display->compositor = wl_registry_bind(display->registry, id,
+ &wl_compositor_interface, 1);
}
else if (strcmp(interface, "wl_seat") == 0) {
input = calloc(1, sizeof *input);
input->display = display;
- input->seat = wl_registry_bind(display->registry, id,
- &wl_seat_interface, 1);
+ input->seat = wl_registry_bind(display->registry, id, &wl_seat_interface, 1);
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
else if (strcmp(interface, "wl_output") == 0) {
output = malloc(sizeof *output);
output->display = display;
- output->output = wl_registry_bind(display->registry,
- id, &wl_output_interface, 1);
+ output->output = wl_registry_bind(display->registry, id, &wl_output_interface, 1);
wl_output_add_listener(output->output,
&output_listener, output);
display->output = output;
print_log("CLIENT: created output global %p", display->output);
}
else if (strcmp(interface, "wl_shell") == 0) {
- display->shell =
- wl_registry_bind(display->registry,
- id, &wl_shell_interface, 1);
- }
- else if (strcmp(interface, "ico_ivi_shell") == 0) {
- display->ico_ivi_shell =
- wl_registry_bind(display->registry,
- id, &ico_ivi_shell_interface, 1);
+ display->shell = wl_registry_bind(display->registry, id, &wl_shell_interface, 1);
}
else if (strcmp(interface, "ico_window_mgr") == 0) {
- display->ico_window_mgr =
- wl_registry_bind(display->registry,
- id, &ico_window_mgr_interface, 1);
+ display->ico_window_mgr = wl_registry_bind(display->registry, id,
+ &ico_window_mgr_interface, 1);
print_log("CLIENT: created window_mgr global %p", display->ico_window_mgr);
}
else if (strcmp(interface, "ico_exinput") == 0) {
- display->ico_exinput =
- wl_registry_bind(display->registry,
- id, &ico_exinput_interface, 1);
- ico_exinput_add_listener(display->ico_exinput,
- &exinput_listener, display);
+ display->ico_exinput = wl_registry_bind(display->registry, id,
+ &ico_exinput_interface, 1);
+ ico_exinput_add_listener(display->ico_exinput, &exinput_listener, display);
print_log("CLIENT: created exinput global %p", display->ico_exinput);
}
}
}
static void
-create_surface(struct display *display)
+create_surface(struct display *display, const char *title)
{
struct surface *surface;
wl_shell_surface_add_listener(surface->shell_surface,
&shell_surface_listener, display);
wl_shell_surface_set_toplevel(surface->shell_surface);
+ wl_shell_surface_set_title(surface->shell_surface, title);
}
}
wl_display_flush(display->display);
surface->egl_surface = opengl_create_window(display->display, surface->surface,
surface->dpy, surface->conf,
surface->ctx, display->init_width,
- display->init_height, display->init_color);
+ display->init_height,
+ display->init_color);
clear_surface(display);
print_log("CLIENT: created egl_surface %08x", (int)surface->egl_surface);
}
clear_surface(struct display *display)
{
if (! display->surface) {
- create_surface(display);
+ create_surface(display, "test-client");
}
else {
opengl_clear_window(display->init_color);
}
}
+static void
+set_region(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int x, y, width, height;
+ int hot_x, hot_y;
+ int c_x, c_y, c_width, c_height;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 5) {
+ x = strtol(args[1], (char **)0, 0);
+ y = strtol(args[2], (char **)0, 0);
+ width = strtol(args[3], (char **)0, 0);
+ height = strtol(args[4], (char **)0, 0);
+ hot_x = x + (width / 2);
+ hot_y = y + (height / 2);
+ c_x = x + 5;
+ c_y = y + 5;
+ c_width = width - 10;
+ if (c_width <= 0) c_width = 2;
+ c_height = height - 10;
+ if (c_height <= 0) c_height = 2;
+ print_log("CLIENT: ico_exinput_set_input_region(%s,%d,%d-%d,%d,"
+ "hot=%d,%d,cur=%d,%d-%d,%d,attr=0)",
+ args[0] ? args[0] : "(null)", x, y, width, height,
+ hot_x, hot_y, c_x, c_y, c_width, c_height);
+ if (strcasecmp(args[0], "NULL") == 0) {
+ ico_exinput_set_input_region(display->ico_exinput, "", x, y,
+ width, height, hot_x, hot_y, c_x, c_y,
+ c_width, c_height, 0);
+ }
+ else {
+ ico_exinput_set_input_region(display->ico_exinput, args[0], x, y,
+ width, height, hot_x, hot_y, c_x, c_y,
+ c_width, c_height, 0);
+ }
+ }
+ else {
+ print_log("CLIENT: set_region command[set_region winname@appid x y "
+ "width height] has no argument");
+ }
+}
+
+static void
+unset_region(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int x, y, width, height;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 1) {
+ if (narg >= 5) {
+ x = strtol(args[1], (char **)0, 0);
+ y = strtol(args[2], (char **)0, 0);
+ width = strtol(args[3], (char **)0, 0);
+ height = strtol(args[4], (char **)0, 0);
+ }
+ else {
+ x = 0;
+ y = 0;
+ width = 0;
+ height = 0;
+ }
+ print_log("CLIENT: ico_exinput_unset_input_region(%s,08x,%d,%d-%d,%d)",
+ args[0] ? args[0] : "(null)", x, y, width, height);
+ if (strcasecmp(args[0], "NULL") == 0) {
+ ico_exinput_unset_input_region(display->ico_exinput, "", x, y,
+ width, height);
+ }
+ else {
+ ico_exinput_unset_input_region(display->ico_exinput, args[0],
+ x, y, width, height);
+ }
+ }
+ else {
+ print_log("CLIENT: unset_region command[unset_region winname@appid x y "
+ "width height] has no argument");
+ }
+}
+
int main(int argc, char *argv[])
{
struct display *display;
wl_registry_add_listener(display->registry,
®istry_listener, display);
wl_display_dispatch(display->display);
+ sleep_with_wayland(display->display, 1000);
fd = 0;
while (1) {
sleep_with_wayland(display->display, 20);
if (display->prompt) {
- printf("CLIENT: "); fflush(stdout);
+ printf("CLIENT> "); fflush(stdout);
}
- ret = getdata(display->ico_window_mgr, "CLIENT: ", fd, buf, sizeof(buf));
+ ret = getdata(display->ico_window_mgr, "CLIENT> ", fd, buf, sizeof(buf));
if (ret < 0) {
fprintf(stderr, "CLIENT: read error: fd %d, %m\n",
fd);
break;
}
else if (strncasecmp(buf, "create-surface", ret) == 0) {
- create_surface(display);
+ create_surface(display, "test-client");
}
else if (strncasecmp(buf, "clear-surface", 13) == 0) {
display->init_color = strtoul(&buf[14], (char **)0, 0);
clear_surface(display);
}
+ else if (strncasecmp(buf, "set_region", 10) == 0) {
+ /* set input region */
+ set_region(display, &buf[10]);
+ }
+ else if (strncasecmp(buf, "unset_region", 12) == 0) {
+ /* unset input region */
+ unset_region(display, &buf[12]);
+ }
else if (strncasecmp(buf, "send-state", ret) == 0) {
send_state(display);
}
}
else {
print_log("CLIENT: unknown command[%s]", buf);
- return(-1);
+ return -1;
}
}
if (postsec > 0) {
/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ * Copyright © 2013 TOYOTA MOTOR CORPORATION
*
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
*
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
*/
/**
* @brief Uint test common routines
#include <time.h>
#include <errno.h>
#include <wayland-client.h>
-#include <ico_window_mgr-client-protocol.h>
+#include "ico_window_mgr-client-protocol.h"
#include "test-common.h"
/*--------------------------------------------------------------------------*/
ret = read(fd, &buf[i], 1);
if (ret < 0) {
- return(ret);
+ return ret;
}
if ((buf[i] == '\n') || (buf[i] == '\r')) break;
strcpy( buf, &buf[j] );
i -= j;
}
- return(i);
+ return i;
}
/*--------------------------------------------------------------------------*/
sTimeZone = timezone;
}
NowTime.tv_sec -= sTimeZone;
- fprintf(stderr, "[%02d:%02d:%02d.%03d@%d] %s\n",
- (int)((NowTime.tv_sec/3600) % 24),
- (int)((NowTime.tv_sec/60) % 60),
- (int)(NowTime.tv_sec % 60),
+ fprintf(stderr, "[%02d:%02d:%02d.%03d@%d] %s\n", (int)((NowTime.tv_sec/3600) % 24),
+ (int)((NowTime.tv_sec/60) % 60), (int)(NowTime.tv_sec % 60),
(int)NowTime.tv_usec/1000, getpid(), log);
}
/*--------------------------------------------------------------------------*/
/**
+ * @brief skip_spaces: skip spaces in command input
+ *
+ * @param[in] buf input command string
+ * @return character pointer of not space character
+ */
+/*--------------------------------------------------------------------------*/
+char *
+skip_spaces(char *buf)
+{
+ while ((*buf == ' ') || (*buf == '\t')) {
+ buf++;
+ }
+ return buf;
+}
+
+/*--------------------------------------------------------------------------*/
+/**
+ * @brief pars_command: The word division of the command line
+ *
+ * @param[in] buf input command string
+ * @param[in] pt word pointers (maximum len words)
+ * @param[in] len maximum number of words
+ * @return number of words
+ */
+/*--------------------------------------------------------------------------*/
+int
+pars_command(char *buf, char *pt[], const int len)
+{
+ char *p;
+ int narg;
+
+ memset(pt, 0, sizeof(int *)*10);
+ p = buf;
+ for (narg = 0; narg < len; narg++) {
+ p = skip_spaces(p);
+ if (*p == 0) break;
+ pt[narg] = p;
+ for (; *p; p++) {
+ if ((*p == ' ') || (*p == '\t') ||
+ (*p == '=') || (*p == ',')) break;
+ }
+ if (*p == 0) {
+ narg++;
+ break;
+ }
+ *p = 0;
+ p++;
+ }
+ return narg;
+}
+
+/*--------------------------------------------------------------------------*/
+/**
* @brief wayland_dispatch_nonblock: Read from wayland if receive data exist
*
* @param[in] display Wayland connection
fd = wl_display_get_fd(display);
do {
- /* Flush send data */
- wl_display_flush(display);
-
/* Check wayland input */
- nread = 0;
- if (ioctl(fd, FIONREAD, &nread) < 0) {
+ while(1) {
+ /* Flush send data */
+ wl_display_flush(display);
+
nread = 0;
- }
- if (nread >= 8) {
+ if (ioctl(fd, FIONREAD, &nread) < 0) {
+ nread = 0;
+ }
+ if (nread < 8) break;
/* Read event from wayland */
wl_display_dispatch(display);
}
if (n == 2) msec *= 10;
sec += msec;
}
- return(sec);
+ return sec;
}
/*--------------------------------------------------------------------------*/
wayland_dispatch_nonblock(display);
- return(dpy);
+ return dpy;
}
/*--------------------------------------------------------------------------*/
opengl_swap_buffer(display, dpy, egl_surface);
- return(egl_surface);
+ return egl_surface;
}
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/**
- * @brief opengl_create_window: Create OpenGL/EGL window
+ * @brief opengl_swap_buffer: Swap OpenGL/EGL buffer
*
* @param[in] display Wayland connection
* @param[in] dpy EGL display
wayland_dispatch_nonblock(display);
}
+
/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ * Copyright © 2013 TOYOTA MOTOR CORPORATION
*
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
*
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
*/
/**
* @brief Header file for uint test common routines
/* Function prototype */
int getdata(void *window_mgr, const char *prompt, int fd, char *buf, const int size);
void print_log(const char *fmt, ...);
+char *skip_spaces(char *buf);
+int pars_command(char *buf, char *pt[], const int len);
void wayland_dispatch_nonblock(struct wl_display *display);
void sleep_with_wayland(struct wl_display *display, int msec);
void wait_with_wayland(struct wl_display *display, int msec, int *endflag);
const int width, const int height, const int color);
void opengl_clear_window(const unsigned int color);
void opengl_swap_buffer(struct wl_display *display, EGLDisplay dpy, EGLSurface egl_surface);
+void opengl_thumbnail(struct wl_display *display, uint32_t surfaceid, EGLDisplay dpy,
+ EGLConfig conf, EGLSurface egl_surface, EGLContext ctx, uint32_t name,
+ int width, int height, int stride, uint32_t format);
#endif /*_TEST_COMMON_H_*/
+
/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ * Copyright © 2012 Intel Corporation
+ * Copyright © 2013 TOYOTA MOTOR CORPORATION
*
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
*
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
*/
/**
- * @brief HomeScreen for uint test of Weston(Wayland) IVI plugins
+ * @brief HomeScreen for unit test of Weston(Wayland) IVI plugins
*
* @date Feb-08-2013
*/
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
+#include <sys/mman.h>
#include <signal.h>
+#include <fcntl.h>
#include <linux/input.h>
#include <wayland-client.h>
-#include "ico_ivi_shell-client-protocol.h"
#include "ico_window_mgr-client-protocol.h"
#include "ico_input_mgr-client-protocol.h"
+#include "ico_input_mgr.h"
#include "test-common.h"
#define MAX_APPID 128
-#define ICO_IVI_MAX_COORDINATE 16383
+#define SHM_SIZE (16*1024*1024)
+#define MAX_CON_NAME 127
+#define MAX_OUTPUT 8
struct surface_name {
struct surface_name *next;
int surfaceid;
int pid;
char appid[MAX_APPID];
+ int node;
int x;
int y;
int width;
int visible;
};
-#define MAX_CON_NAME 127
-
struct display {
struct wl_display *display;
struct wl_registry *registry;
struct wl_compositor *compositor;
struct wl_shell *shell;
- struct ico_ivi_shell *ico_ivi_shell;
struct ico_window_mgr *ico_window_mgr;
struct ico_input_mgr_control *ico_input_mgr;
struct ico_input_mgr_device *ico_input_device;
struct ico_exinput *ico_exinput;
struct input *input;
- struct output *output;
+ int num_output;
+ struct output *output[MAX_OUTPUT];
struct surface *surface;
struct surface_name *surface_name;
struct surface_name *bgsurface_name;
struct wl_seat *seat;
struct wl_pointer *pointer;
struct wl_keyboard *keyboard;
+ struct wl_touch *touch;
float x, y;
uint32_t button_mask;
struct surface *pointer_focus;
print_log("HOMESCREEN: got keyboard modifier");
}
+static void
+touch_handle_down(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
+ struct wl_surface *surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+ print_log("HOMESCREEN: got touch down %d (%d,%d)", id, x/256, y/256);
+}
+
+static void
+touch_handle_up(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
+ int32_t id)
+{
+ print_log("HOMESCREEN: got touch up %d", id);
+}
+
+static void
+touch_handle_motion(void *data, struct wl_touch *wl_touch, uint32_t time,
+ int32_t id, wl_fixed_t x, wl_fixed_t y)
+{
+ print_log("HOMESCREEN: got touch motion %d (%d,%d)", id, x/256, y/256);
+}
+
+static void
+touch_handle_frame(void *data, struct wl_touch *wl_touch)
+{
+ print_log("HOMESCREEN: got touch frame");
+}
+
+static void
+touch_handle_cancel(void *data, struct wl_touch *wl_touch)
+{
+ print_log("HOMESCREEN: got touch cancel");
+}
+
static const struct wl_pointer_listener pointer_listener = {
pointer_handle_enter,
pointer_handle_leave,
keyboard_handle_modifiers,
};
+static const struct wl_touch_listener touch_listener = {
+ touch_handle_down,
+ touch_handle_up,
+ touch_handle_motion,
+ touch_handle_frame,
+ touch_handle_cancel
+};
+
static void
seat_handle_capabilities(void *data, struct wl_seat *seat,
enum wl_seat_capability caps)
{
struct input *input = data;
+ print_log("HOMESCREEN: seat_handle_capabilities caps=%x", caps);
+
if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
input->pointer = wl_seat_get_pointer(seat);
+ print_log("HOMESCREEN: seat_handle_capabilities add pointer=%x", (int)input->pointer);
wl_pointer_set_user_data(input->pointer, input);
- wl_pointer_add_listener(input->pointer, &pointer_listener,
- input);
+ wl_pointer_add_listener(input->pointer, &pointer_listener, input);
}
else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
+ print_log("HOMESCREEN: seat_handle_capabilities delete pointer");
wl_pointer_destroy(input->pointer);
input->pointer = NULL;
}
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
input->keyboard = wl_seat_get_keyboard(seat);
+ print_log("HOMESCREEN: seat_handle_capabilities add keyboard=%x", (int)input->keyboard);
wl_keyboard_set_user_data(input->keyboard, input);
- wl_keyboard_add_listener(input->keyboard, &keyboard_listener,
- input);
+ wl_keyboard_add_listener(input->keyboard, &keyboard_listener, input);
}
else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
+ print_log("HOMESCREEN: seat_handle_capabilities delete keyboard");
wl_keyboard_destroy(input->keyboard);
input->keyboard = NULL;
}
+
+ if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->touch) {
+ input->touch = wl_seat_get_touch(seat);
+ print_log("HOMESCREEN: seat_handle_capabilities add touch=%x", (int)input->touch);
+ wl_touch_set_user_data(input->touch, input);
+ wl_touch_add_listener(input->touch, &touch_listener, input);
+ }
+ else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->touch) {
+ print_log("HOMESCREEN: seat_handle_capabilities delete touch");
+ wl_touch_destroy(input->touch);
+ input->touch = NULL;
+ }
}
static const struct wl_seat_listener seat_listener = {
};
static void
-create_surface(struct display *display)
+create_surface(struct display *display, const char *title)
{
struct surface *surface;
int id;
wl_shell_get_shell_surface(display->shell, surface->surface);
if (surface->shell_surface) {
wl_shell_surface_set_toplevel(surface->shell_surface);
+ wl_shell_surface_set_title(surface->shell_surface, title);
}
}
wl_display_flush(display->display);
surface->egl_surface = opengl_create_window(display->display, surface->surface,
surface->dpy, surface->conf,
surface->ctx, display->init_width,
- display->init_height, display->init_color);
+ display->init_height,
+ display->init_color);
clear_surface(display);
print_log("HOMESCREEN: created egl_surface %08x", (int)surface->egl_surface);
}
clear_surface(struct display *display)
{
if (! display->surface) {
- create_surface(display);
+ create_surface(display, "HomeScreen-BG");
}
else {
opengl_clear_window(display->init_color);
{
struct output *output = data;
+ print_log("HOMESCREEN: Event[handle_geometry] %08x x/y=%d/%d p.w/h=%d/%d trans=%d",
+ (int)wl_output, x, y, physical_width, physical_height, transform);
+
output->x = x;
output->y = y;
}
{
struct output *output = data;
+ print_log("HOMESCREEN: Event[handle_mode] %08x x/y=%d/%d flags=%08x refresh=%d",
+ (int)wl_output, width, height, flags, refresh);
+
if (flags & WL_OUTPUT_MODE_CURRENT) {
struct display *display = output->display;
output->width = width;
output->height = height;
- print_log("HOMESCREEN: Event[handle_mode] x/y=%d/%d bgsurf=%08x",
- width, height, (int)display->bgsurface_name);
-
display->init_width = width;
display->init_height = height;
if (display->bgsurface_name) {
ico_window_mgr_set_positionsize(display->ico_window_mgr,
display->bgsurface_name->surfaceid,
- 0, 0, width, height);
+ 0, 0, 0, 0, width, height);
}
else if (display->bg_created == 0) {
display->bg_created = 9;
- create_surface(output->display);
+ create_surface(display, "HomeScreen-BG");
}
}
}
}
if (p) {
- return(p->surfaceid);
+ return p->surfaceid;
}
else {
- return(-1);
+ if ((strcasecmp(surfname, "all") == 0) ||
+ (strcasecmp(surfname, "main") == 0)) {
+ return ICO_WINDOW_MGR_V_MAINSURFACE;
+ }
+ return -1;
}
}
if (strcmp(p->appid, surfname) == 0) break;
p = p->next;
}
- return(p);
+ if (! p) {
+ print_log("HOMESCREEN: app(%s) dose not exist", surfname);
+ }
+ return p;
}
static struct surface_name *
p = display->surface_name;
while (p) {
if (p->surfaceid == surfaceid) {
- return(p);
+ return p;
}
p = p->next;
}
- return(NULL);
+ return NULL;
}
static void
window_created(void *data, struct ico_window_mgr *ico_window_mgr,
- uint32_t surfaceid, int32_t pid, const char *appid)
+ uint32_t surfaceid, const char *winname, int32_t pid, const char *appid)
{
struct display *display = data;
struct surface_name *p;
p = p->next;
}
if (p) {
- print_log("HOMESCREEN: Event[window_created] surface=%08x(app=%s) exist",
- (int)surfaceid, appid);
+ print_log("HOMESCREEN: Event[window_created] surface=%08x(app=%s,name=%s) exist",
+ (int)surfaceid, appid, winname);
}
else {
- print_log("HOMESCREEN: Event[window_created] new surface=%08x(app=%s)",
- (int)surfaceid, appid);
+ print_log("HOMESCREEN: Event[window_created] new surface=%08x(app=%s) winname=%s",
+ (int)surfaceid, appid, winname);
p = malloc(sizeof(struct surface_name));
if (! p) {
return;
/* Set default size and show */
if (p->width > 0) {
ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
- p->x, p->y, p->width, p->height);
+ 0, p->x, p->y, p->width, p->height, 0);
}
print_log("HOMESCREEN: Created window[%08x] (app=%s)", (int)surfaceid, appid);
if (display->bg_created == 1) {
display->bg_created = 9;
ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
- 0, 0, display->init_width, display->init_height);
+ 0, 0, 0,
+ display->init_width, display->init_height, 0);
}
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 1, 0);
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 1, 0, 0);
print_log("HOMESCREEN: Created window[%08x] (app=%s) Visible",
(int)surfaceid, appid);
p->visible = 1;
}
static void
+window_name(void *data, struct ico_window_mgr *ico_window_mgr,
+ uint32_t surfaceid, const char *winname)
+{
+ print_log("HOMESCREEN: Window Name[%08x] (name=%s)", (int)surfaceid, winname);
+}
+
+static void
window_destroyed(void *data, struct ico_window_mgr *ico_window_mgr, uint32_t surfaceid)
{
struct display *display = data;
}
else {
print_log("HOMESCREEN: Event[window_visible] surface=%08x "
- "visible=%d raise=%d hint=%d",
- (int)surfaceid, visible, raise, hint);
+ "visible=%d raise=%d hint=%d", (int)surfaceid, visible, raise, hint);
p->visible = visible;
- if (hint == 0) {
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, visible, 9);
+ if (hint == 1) {
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
+ visible, ICO_WINDOW_MGR_V_NOCHANGE, 0);
}
}
}
static void
window_configure(void *data, struct ico_window_mgr *ico_window_mgr,
- uint32_t surfaceid, const char *appid, int32_t layer,
+ uint32_t surfaceid, uint32_t node, uint32_t layer,
int32_t x, int32_t y, int32_t width, int32_t height, int32_t hint)
{
struct display *display = data;
struct surface_name *p;
print_log("HOMESCREEN: Event[window_configure] surface=%08x "
- "app=%s x/y=%d/%d w/h=%d/%d hint=%d",
- (int)surfaceid, appid, x, y, width, height, hint);
+ "node=%x x/y=%d/%d w/h=%d/%d hint=%d",
+ (int)surfaceid, node, x, y, width, height, hint);
p = search_surfaceid(display, (int)surfaceid);
if (! p) {
- print_log("HOMESCREEN: Event[window_configure] surface=%08x(app=%s) new create",
- (int)surfaceid, appid);
- window_created(data, ico_window_mgr, surfaceid, 0, appid);
- p = search_surfaceid(display, (int)surfaceid);
- if (! p) {
- print_log("HOMESCREEN: Event[window_configure] can not make table");
- return;
- }
+ print_log("HOMESCREEN: Event[window_configure] surface=%08x dose not exist",
+ (int)surfaceid);
+ }
+ else {
+ p->node = node;
}
}
static void
+window_layer_visible(void *data, struct ico_window_mgr *ico_window_mgr,
+ uint32_t layer, int32_t visible)
+{
+ print_log("HOMESCREEN: Event[layer_visible]layer=%x visible=%d",
+ (int)layer, visible);
+}
+
+static void
window_active(void *data, struct ico_window_mgr *ico_window_mgr,
- uint32_t surfaceid, const uint32_t active)
+ uint32_t surfaceid, const int32_t active)
{
print_log("HOMESCREEN: Event[window_active] surface=%08x acive=%d",
(int)surfaceid, (int)active);
+ if ((surfaceid & 0x0000ffff) == 0x0001) {
+ ico_window_mgr_set_visible(ico_window_mgr, surfaceid,
+ ICO_WINDOW_MGR_V_NOCHANGE, 0, 0);
+ }
+}
+
+static void
+window_surfaces(void *data, struct ico_window_mgr *ico_window_mgr,
+ const char *appid, struct wl_array *surfaces)
+{
+ print_log("HOMESCREEN: Event[app_surfaces] app=%s", appid);
+}
+
+static void
+window_map(void *data, struct ico_window_mgr *ico_window_mgr,
+ int32_t event, uint32_t surfaceid, uint32_t type, uint32_t target,
+ int32_t width, int32_t height, int32_t stride, uint32_t format)
+{
+#if 0
+ struct display *display = data;
+#endif
+ char sevt[16];
+
+ switch (event) {
+ case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_CONTENTS:
+ strcpy(sevt, "Contents"); break;
+ case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_RESIZE:
+ strcpy(sevt, "Resize"); break;
+ case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_MAP:
+ strcpy(sevt, "Map"); break;
+ case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_UNMAP:
+ strcpy(sevt, "Unmap"); break;
+ case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_ERROR:
+ sprintf(sevt, "Error %d", type); break;
+ default:
+ sprintf(sevt, "??%d??", event); break;
+ }
+ print_log("HOMESCREEN: Event[map_surface] ev=%s(%d) surf=%08x type=%d target=%x "
+ "w/h/s/f=%d/%d/%d/%x",
+ sevt, event, (int)surfaceid, type, target, width, height, stride, format);
+#if 0
+ if ((event == ICO_WINDOW_MGR_MAP_SURFACE_EVENT_MAP) ||
+ (event == ICO_WINDOW_MGR_MAP_SURFACE_EVENT_CONTENTS)) {
+ opengl_thumbnail(display->display, surfaceid, display->surface->dpy,
+ display->surface->conf, display->surface->egl_surface,
+ display->surface->ctx, target, width, height, stride, format);
+ }
+#endif
}
static const struct ico_window_mgr_listener window_mgr_listener = {
window_created,
+ window_name,
window_destroyed,
window_visible,
window_configure,
- window_active
+ window_active,
+ window_layer_visible,
+ window_surfaces,
+ window_map
};
static void
};
static void
+cb_input_regions(void *data, struct ico_input_mgr_device *ico_input_mgr_device,
+ struct wl_array *regions)
+{
+ struct ico_uifw_input_region *region;
+ int n;
+ char schange[16];
+
+ n = 0;
+ if (regions) {
+ wl_array_for_each(region, regions) {
+ n ++;
+ print_log("HOMESCREEN: Event[input_regions] number of regions=%d", n);
+ }
+ n = 0;
+ wl_array_for_each(region, regions) {
+ n ++;
+ switch (region->change) {
+ case ICO_INPUT_MGR_DEVICE_REGION_ADD:
+ strcpy(schange, "Add");
+ break;
+ case ICO_INPUT_MGR_DEVICE_REGION_REMOVE:
+ strcpy(schange, "Remove");
+ break;
+ case ICO_INPUT_MGR_DEVICE_REGION_REMOVEALL:
+ strcpy(schange, "RemoveAll");
+ break;
+ default:
+ sprintf(schange, "?%d?", region->change);
+ break;
+ }
+ print_log("HOMESCREEN:%2d. %s %d.%08(%d/%d) &d/%d-%d/%d "
+ "hot=%d/%d cur=%d/%d-%d/%d attr=%x",
+ n, schange, region->node, region->surfaceid, region->surface_x,
+ region->surface_y, region->x, region->y, region->width,
+ region->height, region->hotspot_x, region->hotspot_y,
+ region->cursor_x, region->cursor_y, region->cursor_width,
+ region->cursor_height, region->attr);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: Event[input_regions] no region");
+ }
+}
+
+static const struct ico_input_mgr_device_listener device_listener = {
+ cb_input_regions
+};
+
+
+static void
handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0) {
display->compositor =
- wl_registry_bind(display->registry,
- id, &wl_compositor_interface, 1);
+ wl_registry_bind(display->registry, id, &wl_compositor_interface, 1);
}
else if (strcmp(interface, "wl_seat") == 0) {
input = calloc(1, sizeof *input);
input->display = display;
- input->seat = wl_registry_bind(display->registry, id,
- &wl_seat_interface, 1);
+ input->seat = wl_registry_bind(display->registry, id, &wl_seat_interface, 1);
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
display->input = input;
}
else if (strcmp(interface, "wl_output") == 0) {
- output = malloc(sizeof *output);
- output->display = display;
- output->output = wl_registry_bind(display->registry,
- id, &wl_output_interface, 1);
- wl_output_add_listener(output->output,
- &output_listener, output);
- display->output = output;
+ if (display->num_output < MAX_OUTPUT) {
+ output = malloc(sizeof *output);
+ output->display = display;
+ output->output = wl_registry_bind(display->registry, id, &wl_output_interface, 1);
+ wl_output_add_listener(output->output, &output_listener, output);
+ display->output[display->num_output] = output;
- print_log("HOMESCREEN: created output global %p", display->output);
+ print_log("HOMESCREEN: created output[%d] global %p",
+ display->num_output, display->output[display->num_output]);
+ display->num_output ++;
+ }
}
else if (strcmp(interface, "wl_shell") == 0) {
display->shell =
- wl_registry_bind(display->registry,
- id, &wl_shell_interface, 1);
- }
- else if (strcmp(interface, "ico_ivi_shell") == 0) {
- display->ico_ivi_shell =
- wl_registry_bind(display->registry,
- id, &ico_ivi_shell_interface, 1);
+ wl_registry_bind(display->registry, id, &wl_shell_interface, 1);
}
else if (strcmp(interface, "ico_window_mgr") == 0) {
display->ico_window_mgr =
- wl_registry_bind(display->registry,
- id, &ico_window_mgr_interface, 1);
- ico_window_mgr_add_listener(display->ico_window_mgr,
- &window_mgr_listener, display);
+ wl_registry_bind(display->registry, id, &ico_window_mgr_interface, 1);
+ ico_window_mgr_add_listener(display->ico_window_mgr, &window_mgr_listener, display);
print_log("HOMESCREEN: created window_mgr global %p", display->ico_window_mgr);
- ico_window_mgr_set_eventcb(display->ico_window_mgr, 1);
+ ico_window_mgr_declare_manager(display->ico_window_mgr, 1);
}
else if (strcmp(interface, "ico_input_mgr_control") == 0) {
- display->ico_input_mgr =
- wl_registry_bind(display->registry,
- id, &ico_input_mgr_control_interface, 1);
+ display->ico_input_mgr = wl_registry_bind(display->registry, id,
+ &ico_input_mgr_control_interface, 1);
print_log("HOMESCREEN: created input_mgr global %p", display->ico_input_mgr);
}
else if (strcmp(interface, "ico_input_mgr_device") == 0) {
- display->ico_input_device =
- wl_registry_bind(display->registry,
- id, &ico_input_mgr_device_interface, 1);
+ display->ico_input_device = wl_registry_bind(display->registry, id,
+ &ico_input_mgr_device_interface, 1);
+ ico_input_mgr_device_add_listener(display->ico_input_device,
+ &device_listener, display);
print_log("HOMESCREEN: created input_device global %p", display->ico_input_device);
}
else if (strcmp(interface, "ico_exinput") == 0) {
display->ico_exinput =
- wl_registry_bind(display->registry,
- id, &ico_exinput_interface, 1);
- ico_exinput_add_listener(display->ico_exinput,
- &exinput_listener, display);
+ wl_registry_bind(display->registry, id, &ico_exinput_interface, 1);
+ ico_exinput_add_listener(display->ico_exinput, &exinput_listener, display);
print_log("HOMESCREEN: created exinput global %p", display->ico_exinput);
- ico_window_mgr_set_eventcb(display->ico_window_mgr, 1);
+ ico_window_mgr_declare_manager(display->ico_window_mgr, 1);
display->bg_created = 1;
- create_surface(display);
+ create_surface(display, "HomeScreen-BG");
}
}
handle_global
};
-static char *
-skip_spaces(char *buf)
-{
- while ((*buf == ' ') || (*buf == '\t')) {
- buf++;
- }
- return(buf);
-}
-
-static int
-pars_command(char *buf, char *pt[], const int len)
-{
- char *p;
- int narg;
-
- memset(pt, 0, sizeof(int *)*10);
- p = buf;
- for (narg = 0; narg < len; narg++) {
- p = skip_spaces(p);
- if (*p == 0) break;
- pt[narg] = p;
- for (; *p; p++) {
- if ((*p == ' ') || (*p == '\t') ||
- (*p == '=') || (*p == ',')) break;
- }
- if (*p == 0) {
- narg++;
- break;
- }
- *p = 0;
- p++;
- }
- return (narg);
-}
-
static void
launch_app(struct display *display, char *buf)
{
narg = pars_command(buf, args, 10);
if (narg >= 1) {
p = search_surfacename(display, args[0]);
- if (kill(p->pid, SIGINT) < 0) {
+ if (! p) {
+ print_log("HOMESCREEN: kill[%s] Application dose not exist", args[0]);
+ }
+ else if (kill(p->pid, SIGINT) < 0) {
print_log("HOMESCREEN: kill[%s.%d] Application dose not exist",
p->appid, p->pid);
}
positionsize_surface(struct display *display, char *buf)
{
char *args[10];
+ struct surface_name *p;
int narg;
int surfaceid;
int x, y, width, height;
+ int anima = 0;
+ int node = 0;
narg = pars_command(buf, args, 10);
if (narg >= 5) {
surfaceid = search_surface(display, args[0]);
+ p = search_surfacename(display, args[0]);
x = strtol(args[1], (char **)0, 0);
y = strtol(args[2], (char **)0, 0);
width = strtol(args[3], (char **)0, 0);
height = strtol(args[4], (char **)0, 0);
+ if (narg >= 6) {
+ node = strtol(args[5], (char **)0, 0);
+ if (p) {
+ p->node = node;
+ }
+ }
+ else if (p) {
+ node = p->node;
+ }
+ if (narg >= 7) {
+ anima = strtol(args[6], (char **)0, 0);
+ }
if ((surfaceid >= 0) && (x >= 0) && (y >=0) && (width >= 0) && (height >=0)) {
- print_log("HOMESCREEN: set_positionsize(%s,%08x,%d,%d,%d,%d)",
- args[0], surfaceid, x, y, width, height);
+ print_log("HOMESCREEN: set_positionsize(%s,%08x,%d,%d,%d,%d,%d)",
+ args[0], surfaceid, node, x, y, width, height);
ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
- x, y, width, height);
+ node, x, y, width, height, anima);
}
else {
- print_log("HOMESCREEN: Unknown surface(%s) at positionsize command",
- args[0]);
+ print_log("HOMESCREEN: Unknown surface(%s) at positionsize command", args[0]);
}
}
else {
print_log("HOMESCREEN: positionsize command"
- "[positionsize appid x y width heigh] has no argument");
+ "[positionsize appid x y width heigh node anima] has no argument");
}
}
move_surface(struct display *display, char *buf)
{
char *args[10];
+ struct surface_name *p;
int narg;
int surfaceid;
int x, y;
+ int anima = 0;
+ int node = 0;
narg = pars_command(buf, args, 10);
if (narg >= 3) {
surfaceid = search_surface(display, args[0]);
+ p = search_surfacename(display, args[0]);
x = strtol(args[1], (char **)0, 0);
y = strtol(args[2], (char **)0, 0);
+ if (narg >= 4) {
+ node = strtol(args[3], (char **)0, 0);
+ if (node < 0) {
+ if (p) node = p->node;
+ else node = 0;
+ }
+ if (p) p->node = node;
+ }
+ else if (p) {
+ node = p->node;
+ }
+ if (narg >= 5) {
+ anima = strtol(args[4], (char **)0, 0);
+ }
+
if ((surfaceid >= 0) && (x >= 0) && (y >=0)) {
- print_log("HOMESCREEN: move(%s,%08x,%d,%d)", args[0], surfaceid, x, y);
+ print_log("HOMESCREEN: move(%s,%08x,%d.%d,%d anima=%d)", args[0], surfaceid,
+ node, x, y, anima);
ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
- x, y,
- ICO_IVI_MAX_COORDINATE+1, ICO_IVI_MAX_COORDINATE+1);
+ node, x, y,
+ ICO_WINDOW_MGR_V_NOCHANGE,
+ ICO_WINDOW_MGR_V_NOCHANGE, anima);
}
else {
print_log("HOMESCREEN: Unknown surface(%s) at move command", args[0]);
}
}
else {
- print_log("HOMESCREEN: move command[positionsize appid x y] has no argument");
+ print_log("HOMESCREEN: move command[positionsize appid x y node anima] has no argument");
}
}
resize_surface(struct display *display, char *buf)
{
char *args[10];
+ struct surface_name *p;
int narg;
int surfaceid;
int width, height;
+ int anima = 0;
+ int node = 0;
narg = pars_command(buf, args, 10);
if (narg >= 3) {
surfaceid = search_surface(display, args[0]);
+ p = search_surfacename(display, args[0]);
+ if (p) {
+ node = p->node;
+ }
width = strtol(args[1], (char **)0, 0);
height = strtol(args[2], (char **)0, 0);
+ if (narg >= 4) {
+ anima = strtol(args[3], (char **)0, 0);
+ }
+
if ((surfaceid >= 0) && (width >= 0) && (height >=0)) {
- print_log("HOMESCREEN: resize(%s,%08x,%d,%d)", args[0], surfaceid, width, height);
+ print_log("HOMESCREEN: resize(%s,%08x,%d.%d,%d,anima=%d)",
+ args[0], surfaceid, node, width, height, anima);
ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
- ICO_IVI_MAX_COORDINATE+1, ICO_IVI_MAX_COORDINATE+1,
- width, height);
+ node, ICO_WINDOW_MGR_V_NOCHANGE,
+ ICO_WINDOW_MGR_V_NOCHANGE, width, height, anima);
}
else {
print_log("HOMESCREEN: Unknown surface(%s) at resize command", args[0]);
}
else {
print_log("HOMESCREEN: positionsize command"
- "[resize appid width heigh] has no argument");
+ "[resize appid width heigh anima] has no argument");
}
}
int surfaceid;
int visible;
int raise;
+ int anima = 0;
narg = pars_command(buf, args, 10);
if (narg >= 3) {
surfaceid = search_surface(display, args[0]);
visible = strtol(args[1], (char **)0, 0);
raise = strtol(args[2], (char **)0, 0);
+ if (narg >= 4) {
+ anima = strtol(args[3], (char **)0, 0);
+ }
if ((surfaceid >= 0) && (visible >= 0) && (raise >=0)) {
- print_log("HOMESCREEN: visible(%s,%08x,%d,%d)",
- args[0], surfaceid, visible, raise);
+ print_log("HOMESCREEN: visible(%s,%08x,%d,%d,%d)",
+ args[0], surfaceid, visible, raise, anima);
ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
- visible, raise);
+ visible, raise, anima);
}
else {
print_log("HOMESCREEN: Unknown surface(%s) at visible command", args[0]);
}
}
else {
- print_log("HOMESCREEN: visible command[visible appid visible raise] has no argument");
+ print_log("HOMESCREEN: visible command[visible appid visible raise] "
+ "has no argument");
}
}
char *args[10];
int narg;
int surfaceid;
+ int anima = 0;
+ int ax = 0;
+ int ay = 0;
+ int awidth = 1;
+ int aheight = 1;
narg = pars_command(buf, args, 10);
if (narg >= 1) {
surfaceid = search_surface(display, args[0]);
+ if (narg >= 2) {
+ anima = strtol(args[1], (char **)0, 0);
+ if (anima >= 2) {
+ ax = 0;
+ ay = 0;
+ awidth = 1;
+ aheight = 1;
+ if (narg >= 3) ax = strtol(args[2], (char **)0, 0);
+ if (narg >= 4) ay = strtol(args[3], (char **)0, 0);
+ if (narg >= 5) awidth = strtol(args[4], (char **)0, 0);
+ if (narg >= 6) aheight = strtol(args[5], (char **)0, 0);
+ }
+ }
if (surfaceid >= 0) {
if (show) {
- print_log("HOMESCREEN: show(%s,%08x)", args[0], surfaceid);
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 1, 9);
+ if (anima >= 2) {
+ print_log("HOMESCREEN: show anima(%s,%08x,x/y=%d/%d,w/h=%d/%d)",
+ args[0], surfaceid, ax, ay, awidth, aheight);
+ ico_window_mgr_visible_animation(display->ico_window_mgr, surfaceid,
+ 1, ax, ay, awidth, aheight);
+ }
+ else {
+ print_log("HOMESCREEN: show(%s,%08x,anima=%d)",
+ args[0], surfaceid, anima);
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
+ 1, ICO_WINDOW_MGR_V_NOCHANGE, anima);
+ }
}
else {
- print_log("HOMESCREEN: hide(%s,%08x)", args[0], surfaceid);
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 0, 9);
+ if (anima >= 2) {
+ print_log("HOMESCREEN: hide anima(%s,%08x,x/y=%d/%d,w/h=%d/%d)",
+ args[0], surfaceid, ax, ay, awidth, aheight);
+ ico_window_mgr_visible_animation(display->ico_window_mgr, surfaceid,
+ 0, ax, ay, awidth, aheight);
+ }
+ else {
+ print_log("HOMESCREEN: hide(%s,%08x,anima=%d)",
+ args[0], surfaceid, anima);
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
+ 0, ICO_WINDOW_MGR_V_NOCHANGE, anima);
+ }
}
}
else {
}
}
else {
- print_log("HOMESCREEN: show command[show/hide appid] has no argument");
+ print_log("HOMESCREEN: show command[show/hide appid anima x y width height]"
+ " has no argument");
}
}
char *args[10];
int narg;
int surfaceid;
+ int anima = 0;
narg = pars_command(buf, args, 10);
if (narg >= 1) {
surfaceid = search_surface(display, args[0]);
+ if (narg >= 2) {
+ anima = strtol(args[1], (char **)0, 0);
+ }
if (surfaceid >= 0) {
if (raise) {
- print_log("HOMESCREEN: raise(%s,%08x)", args[0], surfaceid);
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 9, 1);
+ print_log("HOMESCREEN: raise(%s,%08x,anima=%d)", args[0], surfaceid, anima);
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
+ ICO_WINDOW_MGR_V_NOCHANGE, 1, anima);
}
else {
- print_log("HOMESCREEN: lower(%s,%08x)", args[0], surfaceid);
- ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 9, 0);
+ print_log("HOMESCREEN: lower(%s,%08x,anima=%d)", args[0], surfaceid, anima);
+ ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
+ ICO_WINDOW_MGR_V_NOCHANGE, 0, anima);
}
}
else {
}
}
else {
- print_log("HOMESCREEN: show command[raise/lower appid] has no argument");
+ print_log("HOMESCREEN: show command[raise/lower appid anima] has no argument");
+ }
+}
+
+static void
+active_window(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int surfaceid;
+ int target;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 1) {
+ surfaceid = search_surface(display, args[0]);
+ if (narg >= 2) {
+ target = strtol(args[1], (char **)0, 0);
+ }
+ else {
+ target = ICO_WINDOW_MGR_ACTIVE_POINTER | ICO_WINDOW_MGR_ACTIVE_KEYBOARD;
+ }
+ if (surfaceid >= 0) {
+ print_log("HOMESCREEN: active(%s,%08x,target=%x)", args[0], surfaceid, target);
+ ico_window_mgr_set_active(display->ico_window_mgr, surfaceid, target);
+ }
+ else {
+ print_log("HOMESCREEN: Unknown surface(%s) at active command", args[0]);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: active command[active appid[target]] has no argument");
+ }
+}
+
+
+static void
+animation_surface(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int surfaceid;
+ int time;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 2) {
+ surfaceid = search_surface(display, args[0]);
+ if (surfaceid >= 0) {
+ if (narg >= 3) {
+ time = strtol(args[2], (char **)0, 0);
+ }
+ else {
+ time = 0;
+ }
+ print_log("HOMESCREEN: animation(%s,%08x,%s,%d)",
+ args[0], surfaceid, args[1], time);
+ ico_window_mgr_set_animation(display->ico_window_mgr, surfaceid, 0x7fffffff,
+ args[1], time);
+ }
+ else {
+ print_log("HOMESCREEN: Unknown surface(%s) at animation command", args[0]);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: animation command"
+ "[animation appid animation time] has no argument");
+ }
+}
+
+static void
+map_surface(struct display *display, char *buf, int map)
+{
+ char *args[10];
+ int narg;
+ int surfaceid;
+ int fps;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 1) {
+ surfaceid = search_surface(display, args[0]);
+ if (surfaceid >= 0) {
+ if (narg >= 2) {
+ fps = strtol(args[1], (char **)0, 0);
+ }
+ else {
+ fps = 0;
+ }
+ if (map) {
+ print_log("HOMESCREEN: map surface(%s,%08x,%d)",
+ args[0], surfaceid, fps);
+ ico_window_mgr_map_surface(display->ico_window_mgr, surfaceid, fps);
+ }
+ else {
+ print_log("HOMESCREEN: unmap surface(%s,%08x)", args[0], surfaceid);
+ ico_window_mgr_unmap_surface(display->ico_window_mgr, surfaceid);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: Unknown surface(%s) at %s command", args[0],
+ map ? "map" : "unmap");
+ }
+ }
+ else {
+ if (map) {
+ print_log("HOMESCREEN: map surface command"
+ "[map surface framerate] has no argument");
+ }
+ else {
+ print_log("HOMESCREEN: unmap surface command"
+ "[unmap surface] has no argument");
+ }
}
}
fix = 0;
}
if ((input >= 0) && (fix >=0)) {
- print_log("HOMESCREEN: input_add(%s.%d to %s[%d])", args[0], input, args[2], fix);
+ print_log("HOMESCREEN: input_add(%s.%d to %s[%d])",
+ args[0], input, args[2], fix);
ico_input_mgr_control_add_input_app(display->ico_input_mgr,
- args[2], args[0], input, fix);
+ args[2], args[0], input, fix, 0);
}
else {
print_log("HOMESCREEN: Unknown input(%s) at input_add command", args[1]);
}
static void
+input_send(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int surfaceid;
+ int type;
+ int no;
+ int code;
+ int value;
+ char appid[64];
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 5) {
+ memset(appid, 0, sizeof(appid));
+ if (args[0][0] == '@') {
+ strncpy(appid, &args[0][1], sizeof(appid)-1);
+ surfaceid = 0;
+ }
+ else {
+ surfaceid = search_surface(display, args[0]);
+ }
+ if (strcasecmp(args[1], "POINTER") == 0) {
+ type = ICO_INPUT_MGR_DEVICE_TYPE_POINTER;
+ }
+ else if (strcasecmp(args[1], "KEYBOARD") == 0) {
+ type = ICO_INPUT_MGR_DEVICE_TYPE_KEYBOARD;
+ }
+ else if (strcasecmp(args[1], "TOUCH") == 0) {
+ type = ICO_INPUT_MGR_DEVICE_TYPE_TOUCH;
+ }
+ else if (strcasecmp(args[1], "SWITCH") == 0) {
+ type = ICO_INPUT_MGR_DEVICE_TYPE_SWITCH;
+ }
+ else if (strcasecmp(args[1], "HAPTIC") == 0) {
+ type = ICO_INPUT_MGR_DEVICE_TYPE_HAPTIC;
+ }
+ else {
+ type = strtol(args[1], (char **)0, 0);
+ }
+ no = strtol(args[2], (char **)0, 0);
+ if (strcasecmp(args[3], "ABS_X") == 0) {
+ code = ABS_X;
+ }
+ else if (strcasecmp(args[3], "ABS_Y") == 0) {
+ code = ABS_Y;
+ }
+ else if (strcasecmp(args[3], "ABS_Z") == 0) {
+ code = ABS_Z;
+ }
+ else if (strcasecmp(args[3], "REL_X") == 0) {
+ code = REL_X | (EV_REL << 16);
+ }
+ else if (strcasecmp(args[3], "REL_Y") == 0) {
+ code = REL_Y | (EV_REL << 16);
+ }
+ else if (strcasecmp(args[3], "REL_Z") == 0) {
+ code = REL_Z | (EV_REL << 16);
+ }
+ else if (strcasecmp(args[3], "BTN_TOUCH") == 0) {
+ code = BTN_TOUCH;
+ }
+ else if (strcasecmp(args[3], "BTN_LEFT") == 0) {
+ code = BTN_LEFT;
+ }
+ else if (strcasecmp(args[3], "BTN_RIGHT") == 0) {
+ code = BTN_RIGHT;
+ }
+ else if (strcasecmp(args[3], "BTN_MIDDLE") == 0) {
+ code = BTN_MIDDLE;
+ }
+ else if (strcasecmp(args[3], "BTN_RIGHT") == 0) {
+ code = BTN_RIGHT;
+ }
+ else {
+ code = strtol(args[3], (char **)0, 0);
+ }
+ value = strtol(args[4], (char **)0, 0);
+ if (narg >= 6) {
+ value = (value << 16) + strtol(args[5], (char **)0, 0);
+ }
+ print_log("HOMESCREEN: input_send(%s.%x,%d,%d,%x,%d)",
+ appid, surfaceid, type, no, code, value);
+ ico_input_mgr_control_send_input_event(display->ico_input_mgr,
+ appid, surfaceid, type, no, code, value);
+ }
+ else {
+ print_log("HOMESCREEN: input_send command[input_send {@app/serface} type no code "
+ "value [value2]] has no argument");
+ }
+}
+
+static void
input_conf(struct display *display, char *buf)
{
char *args[10];
if (msgsnd(mqid, &mqbuf, sizeof(mqbuf)-sizeof(long), 0) < 0) {
fprintf(stderr, "HOMESCREEN: message queue(%d(0x%x)) send error[%d]\n",
- mqkey, mqkey, errno);
+ mqkey, mqkey, errno);
return;
}
}
+static void
+set_region(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int x, y, width, height;
+ int hot_x, hot_y;
+ int c_x, c_y, c_width, c_height;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 5) {
+ x = strtol(args[1], (char **)0, 0);
+ y = strtol(args[2], (char **)0, 0);
+ width = strtol(args[3], (char **)0, 0);
+ height = strtol(args[4], (char **)0, 0);
+ hot_x = x + (width / 2);
+ hot_y = y + (height / 2);
+ c_x = x + 5;
+ c_y = y + 5;
+ c_width = width - 10;
+ if (c_width <= 0) c_width = 2;
+ c_height = height - 10;
+ if (c_height <= 0) c_height = 2;
+ print_log("HOMESCREEN: ico_exinput_set_input_region(%s,%d,%d-%d,%d,"
+ "hot=%d,%d,cur=%d,%d-%d,%d,attr=0)",
+ args[0] ? args[0] : "(null)", x, y, width, height,
+ hot_x, hot_y, c_x, c_y, c_width, c_height);
+ if (strcasecmp(args[0], "NULL") == 0) {
+ ico_exinput_set_input_region(display->ico_exinput, "", x, y,
+ width, height, hot_x, hot_y, c_x, c_y,
+ c_width, c_height, 0);
+ }
+ else {
+ ico_exinput_set_input_region(display->ico_exinput, args[0], x, y,
+ width, height, hot_x, hot_y, c_x, c_y,
+ c_width, c_height, 0);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: set_region command[set_region winname@appid x y "
+ "width height] has no argument");
+ }
+}
+
+static void
+unset_region(struct display *display, char *buf)
+{
+ char *args[10];
+ int narg;
+ int x, y, width, height;
+
+ narg = pars_command(buf, args, 10);
+ if (narg >= 1) {
+ if (narg >= 5) {
+ x = strtol(args[1], (char **)0, 0);
+ y = strtol(args[2], (char **)0, 0);
+ width = strtol(args[3], (char **)0, 0);
+ height = strtol(args[4], (char **)0, 0);
+ }
+ else {
+ x = 0;
+ y = 0;
+ width = 0;
+ height = 0;
+ }
+ print_log("HOMESCREEN: ico_exinput_unset_input_region(%s,08x,%d,%d-%d,%d)",
+ args[0] ? args[0] : "(null)", x, y, width, height);
+ if (strcasecmp(args[0], "NULL") == 0) {
+ ico_exinput_unset_input_region(display->ico_exinput, "", x, y,
+ width, height);
+ }
+ else {
+ ico_exinput_unset_input_region(display->ico_exinput, args[0],
+ x, y, width, height);
+ }
+ }
+ else {
+ print_log("HOMESCREEN: unset_region command[unset_region winname@appid x y "
+ "width height] has no argument");
+ }
+}
+
/*
* Main Program
*
char buf[256];
int ret, fd;
int msec;
+#if 1 /* use mkostemp */
+ extern int mkostemp(char *template, int flags);
+#else /* use mkostemp */
+ long flags;
+#endif /* use mkostemp */
display = malloc(sizeof *display);
assert(display);
assert(display->display);
display->registry = wl_display_get_registry(display->display);
- wl_registry_add_listener(display->registry,
- ®istry_listener, display);
+ wl_registry_add_listener(display->registry, ®istry_listener, display);
wl_display_dispatch(display->display);
fd = 0;
while (1) {
sleep_with_wayland(display->display, 20);
if (display->prompt) {
- printf("HOMESCREEN: "); fflush(stdout);
+ printf("HOMESCREEN> "); fflush(stdout);
}
- ret = getdata(display->ico_window_mgr, "HOMESCREEN: ", fd, buf, sizeof(buf));
+ ret = getdata(display->ico_window_mgr, "HOMESCREEN> ", fd, buf, sizeof(buf));
if (ret < 0) {
- fprintf(stderr, "HOMESCREEN: read error: fd %d, %m\n",
- fd);
+ fprintf(stderr, "HOMESCREEN: read error: fd %d, %m\n", fd);
return -1;
}
if (ret == 0) continue;
/* Raise/Lower surface window */
raise_surface(display, &buf[5], 0);
}
+ else if (strncasecmp(buf, "active", 6) == 0) {
+ /* Active surface window */
+ active_window(display, &buf[6]);
+ }
+ else if (strncasecmp(buf, "animation", 9) == 0) {
+ /* Set animation surface window */
+ animation_surface(display, &buf[9]);
+ }
+ else if (strncasecmp(buf, "map", 3) == 0) {
+ /* map surface */
+ map_surface(display, &buf[3], 1);
+ }
+ else if (strncasecmp(buf, "unmap", 5) == 0) {
+ /* unmap surface */
+ map_surface(display, &buf[5], 0);
+ }
else if (strncasecmp(buf, "input_add", 9) == 0) {
/* Set input switch to application */
input_add(display, &buf[9]);
/* Reset input switch to application*/
input_del(display, &buf[9]);
}
+ else if (strncasecmp(buf, "input_send", 10) == 0) {
+ /* Input event send to application*/
+ input_send(display, &buf[10]);
+ }
else if (strncasecmp(buf, "input_conf", 10) == 0) {
/* input switch configuration */
input_conf(display, &buf[10]);
/* input switch event */
input_sw(display, &buf[8]);
}
+ else if (strncasecmp(buf, "set_region", 10) == 0) {
+ /* set input region */
+ set_region(display, &buf[10]);
+ }
+ else if (strncasecmp(buf, "unset_region", 12) == 0) {
+ /* unset input region */
+ unset_region(display, &buf[12]);
+ }
+ else if (strncasecmp(buf, "input_sw", 8) == 0) {
+ /* input switch event */
+ input_sw(display, &buf[8]);
+ }
else if (strncasecmp(buf, "sleep", 5) == 0) {
/* Sleep */
msec = sec_str_2_value(&buf[6]);
send_event(NULL);
- return(0);
+ return 0;
}
/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
+ * Copyright © 2013 TOYOTA MOTOR CORPORATION.
*
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
+ * Permission to use, copy, modify, distribute, and sell this software and
+ * its documentation for any purpose is hereby granted without fee, provided
+ * that the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of the copyright holders not be used in
+ * advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission. The copyright holders make
+ * no representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
*
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+ * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+ * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @brief System Test Tool for send device input event
print_log("Send Event Y=%d\t %d.%03d", event.value,
(int)event.time.tv_sec, (int)(event.time.tv_usec/1000));
}
- else if ((event.type == EV_KEY) && (event.code == BTN_LEFT) && (event.value == 1)) {
+ else if ((event.type == EV_KEY) &&
+ (event.code == BTN_LEFT) && (event.value == 1)) {
print_log("Send Event BTN_LEFT=Down\t# %d.%03d",
(int)event.time.tv_sec, (int)(event.time.tv_usec/1000));
}
- else if ((event.type == EV_KEY) && (event.code == BTN_LEFT) && (event.value == 0)) {
+ else if ((event.type == EV_KEY) &&
+ (event.code == BTN_LEFT) && (event.value == 0)) {
print_log("Send Event BTN_LEFT=Up\t# %d.%03d",
(int)event.time.tv_sec, (int)(event.time.tv_usec/1000));
}
static void
usage(const char *prog)
{
- fprintf(stderr, "Usage: %s [-device=device] [{-m/-t/-j}] [-mq[=key]] [-d] [event=value] [event=value] ...\n", prog);
+ fprintf(stderr, "Usage: %s [-device=device] [{-m/-t/-j}] [-mq[=key]] "
+ "[-d] [event=value] [event=value] ...\n", prog);
exit(0);
}
+++ /dev/null
-[core]
-modules=ico_plugin_loader.so
-
-#[output]
-#name=HDMI3
-#mode=1680x945
-#mode=1920x1080
-#mode=173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync
-#transform=90
-
-#[output]
-#name=LVDS1
-#mode=1680x1050
-#transform=90
-
-#[output]
-#name=VGA1
-#mode=173.00 1920 2048 2248 2576 1080 1083 1088 1120 -hsync +vsync
-#transform=90
-
-#[output]
-#name=X1
-#mode=1024x768
-#transform=flipped-270
+++ /dev/null
-[plugin]
-modules=ico_ivi_common.so,ico_ivi_shell.so,ico_window_mgr.so,ico_input_mgr.so
-
-[shell]
-animation=none
-#animation=zoom
-# 0=hide on surface create(for with HomeScreen)/1=show on surface create(for Debug)
-visible_on_create=0
-
-[debug]
-# option flag
-# 0x00000001 : =1, At the time of unvisible of surface, it travels surface outside a screen.
-# : =0, Exclude surface of the unvisible from a list of surface of Westons.
-option_flag=1
-
-# 0=no debug write(1=err/2=warn/3=info/4=debug)
-ivi_debug=4
-
+++ /dev/null
-export abs_builddir
-
-AM_CFLAGS = $(GCC_CFLAGS)
-AM_CPPFLAGS = -I$(top_srcdir)/src $(COMPOSITOR_CFLAGS)
-
-bin_PROGRAMS = \
- ico_ictl-touch_egalax \
- ico_ictl-egalax_calibration
-
-check_LTLIBRARIES = $(TESTS)
-check_PROGRAMS = \
- ico_ictl-touch_egalax \
- ico_ictl-egalax_calibration
-
-AM_LDFLAGS = -module -avoid-version -rpath $(libdir)
-
-ico_ictl_touch_egalax_SOURCES = \
- ico_ictl-touch_egalax.c
-ico_ictl_touch_egalax_LDADD = $(SIMPLE_CLIENT_LIBS)
-
-ico_ictl_egalax_calibration_SOURCES = \
- ico_ictl-egalax_calibration.c
-ico_ictl_egalax_calibration_LDADD = $(SIMPLE_CLIENT_LIBS)
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief Touchpanel(eGalax) Calibration Tool
- *
- * @date Feb-20-2013
- */
-
-#include "ico_ictl-touch_egalax.h"
-
-/* Number of times to repeat a touch about each point */
-#define CALIBCONF_READ_NUM (5)
-#define XY_COORDNATE_DELTA (50)
-
-/* Macro for adjust coordinate */
-#define delta_add(x) \
- (x) > 256 ? (x) + XY_COORDNATE_DELTA : ((x) > XY_COORDNATE_DELTA ? (x) - XY_COORDNATE_DELTA : 0);
-
-static void print_usage(const char *pName);
-static char *find_event_device(void);
-static FILE *open_conffile(void);
-static void get_coordinates(int evfd);
-static void read_event(int evfd, int *x, int *y);
-static void sort_data(int buff[], int left, int right);
-
-int mDispWidth = CALIBRATION_DISP_WIDTH;
-int mDispHeight = CALIBRATION_DISP_HEIGHT;
-int mPosX[4];
-int mPosY[4];
-
-int mDebug = 0;
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief Touchpanel(eGalax) Calibration Tool main routine
- *
- * @param arguments of standard main routeins(argc, argv)
- * @return result
- * @retval 0 sucess
- * @retval 8 configuration file Error
- * @retval 9 can not open event device(touchpanel)
- */
-/*--------------------------------------------------------------------------*/
-int
-main(int argc, char *argv[])
-{
- int ii, cnt;
- int evfd; /* event device fd */
- char *eventDeviceName = NULL; /* event device name to hook */
- FILE *fp;
- char buff[128];
-
- /* Get options */
- for (ii = 1; ii < argc; ii++) {
- if (strcasecmp(argv[ii], "-h") == 0) {
- /* Help */
- print_usage(argv[0]);
- exit(0);
- }
- else if (strcasecmp(argv[ii], "-width") == 0) {
- /* Screen width */
- ii++;
- if (ii >= argc) {
- print_usage(argv[0]);
- exit(0);
- }
- mDispWidth = strtol(argv[ii], (char **)0, 0);
- if ((mDispWidth <= 0) || (mDispWidth > 8192)) {
- print_usage(argv[0]);
- exit(0);
- }
- }
- else if (strcasecmp(argv[ii], "-height") == 0) {
- /* Screen height */
- ii++;
- if (ii >= argc) {
- print_usage(argv[0]);
- exit(0);
- }
- mDispHeight = strtol(argv[ii], (char **)0, 0);
- if ((mDispHeight <= 0) || (mDispHeight > 8192)) {
- print_usage(argv[0]);
- exit(0);
- }
- }
- else {
- /* Input event device name */
- eventDeviceName = argv[ii];
- }
- }
-
- if (eventDeviceName == NULL) {
- /* If event device not present, get default device */
- eventDeviceName = find_event_device();
- if (eventDeviceName == NULL) {
- /* System has no touchpanel, Error */
- exit(9);
- }
- }
-
- evfd = open(eventDeviceName, O_RDONLY);
- if (evfd < 0) {
- perror("Open event device");
- exit(9);
- }
-
- /* Open configuration file for output */
- fp = open_conffile();
- if (fp == NULL) {
- fprintf(stderr, "%s: Can not open config file\n", argv[0]);
- close(evfd);
- exit(8);
- }
-
- CALIBRATION_PRINT("\n");
- CALIBRATION_PRINT("+================================================+\n");
- CALIBRATION_PRINT("| Configration Tool for Calibration Touch ver0.1 |\n");
- CALIBRATION_PRINT("+------------------------------------------------+\n");
- CALIBRATION_PRINT("| use display width = %d\n", CALIBRATION_DISP_WIDTH);
- CALIBRATION_PRINT("| use display height = %d\n", CALIBRATION_DISP_HEIGHT);
- CALIBRATION_PRINT("+------------------------------------------------+\n");
-
- get_coordinates(evfd);
-
- CALIBRATION_PRINT("+------------------------------------------------+\n");
- CALIBRATION_PRINT("| save config |\n");
- CALIBRATION_PRINT("+------------------------------------------------+\n");
-
- cnt = sprintf(buff, "%s=%d\n", CALIBRATOIN_STR_DISP_W, mDispWidth);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- cnt = sprintf(buff, "%s=%d\n", CALIBRATOIN_STR_DISP_H, mDispHeight);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- cnt = sprintf(buff, "%s=%d*%d\n", CALIBRATOIN_STR_POS1, mPosX[0], mPosY[0]);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- cnt = sprintf(buff, "%s=%d*%d\n", CALIBRATOIN_STR_POS2, mPosX[1], mPosY[1]);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- cnt = sprintf(buff, "%s=%d*%d\n", CALIBRATOIN_STR_POS3, mPosX[2], mPosY[2]);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- cnt = sprintf(buff, "%s=%d*%d\n", CALIBRATOIN_STR_POS4, mPosX[3], mPosY[3]);
- fwrite(buff, sizeof(char), cnt, fp);
- CALIBRATION_PRINT("| %s", buff);
-
- if (evfd >= 0) {
- close(evfd);
- }
-
- /* Close outputed configuration file */
- fclose(fp);
-
- CALIBRATION_PRINT("| |\n");
- CALIBRATION_PRINT("| finish Tools |\n");
-
- exit(0);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief find_event_device: Find eGalax touchpanel device
- *
- * @param nothing
- * @return device name
- * @retval != NULL device name string
- * @retvel == NULL system has no eGalax touchpanel
- */
-/*--------------------------------------------------------------------------*/
-static char *
-find_event_device(void)
-{
- FILE *fp;
- int eGalax = 0;
- int i, j, k;
- char buf[240];
- static char edevice[64];
-
- /* Search input device */
- fp = fopen("/proc/bus/input/devices", "r");
- if (!fp) {
- CALIBRATION_INFO("find_event_device: /proc/bus/input/devices Open Error\n");
- return(NULL);
- }
-
- while (fgets(buf, sizeof(buf), fp)) {
- if (eGalax == 0) {
- for (i = 0; buf[i]; i++) {
- if (strncmp(&buf[i], "eGalax", 6) == 0) {
- /* Find eGalax touchpanel device */
- eGalax = 1;
- break;
- }
- }
- }
- else {
- for (i = 0; buf[i]; i++) {
- if (strncmp(&buf[i], "Handlers", 8) == 0) {
- /* Find eGalax device and Handlers */
- for (j = i+8; buf[j]; j++) {
- if (buf[j] != ' ') continue;
- strcpy(edevice, "/dev/input/");
- for (k = strlen(edevice); k < (int)sizeof(edevice); k++) {
- j++;
- if ((buf[j] == 0) || (buf[j] == ' ') ||
- (buf[j] == '\t') || (buf[j] == '\n') ||
- (buf[j] == '\r')) break;
- edevice[k] = buf[j];
- }
- edevice[k] = 0;
- CALIBRATION_INFO("Event device of eGalax=<%s>\n", edevice);
- fclose(fp);
- return(edevice);
- }
- break;
- }
- }
- }
- }
- fclose(fp);
-
- CALIBRATION_PRINT("System has no eGalax Touchpanel\n");
- return(NULL);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief read coordinates form touchpanel
- *
- * @param[in] evfd touchpanel event device
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-get_coordinates(int evfd)
-{
- int bufX[CALIBCONF_READ_NUM];
- int bufY[CALIBCONF_READ_NUM];
- int x, y;
- int ii;
-
- CALIBRATION_PRINT("| Touch the Top-Left corner of the screen %d times\n",
- CALIBCONF_READ_NUM);
- for (ii = 0; ii < CALIBCONF_READ_NUM; ii++) {
- read_event(evfd, &x, &y);
- bufX[ii] = x;
- bufY[ii] = y;
- CALIBRATION_PRINT("| # %d: %dx%d \n", ii, x, y);
- }
- sort_data(bufX, 0, CALIBCONF_READ_NUM - 1);
- sort_data(bufY, 0, CALIBCONF_READ_NUM - 1);
- mPosX[0] = delta_add(bufX[CALIBCONF_READ_NUM / 2]);
- mPosY[0] = delta_add(bufY[CALIBCONF_READ_NUM / 2]);
-
- CALIBRATION_PRINT("+------------------------------------------------+\n");
- CALIBRATION_PRINT("| Touch the Top-Right corner of the screen %d times\n",
- CALIBCONF_READ_NUM);
- for (ii = 0; ii < CALIBCONF_READ_NUM; ii++) {
- read_event(evfd, &x, &y);
- bufX[ii] = x;
- bufY[ii] = y;
- CALIBRATION_PRINT("| # %d: %dx%d \n", ii, x, y);
- }
- sort_data(bufX, 0, CALIBCONF_READ_NUM - 1);
- sort_data(bufY, 0, CALIBCONF_READ_NUM - 1);
- mPosX[1] = delta_add(bufX[CALIBCONF_READ_NUM / 2]);
- mPosY[1] = delta_add(bufY[CALIBCONF_READ_NUM / 2]);
-
- CALIBRATION_PRINT("+------------------------------------------------+\n");
- CALIBRATION_PRINT("| Touch the Bottom-Left corner of the screen %d times\n",
- CALIBCONF_READ_NUM);
- for (ii = 0; ii < CALIBCONF_READ_NUM; ii++) {
- read_event(evfd, &x, &y);
- bufX[ii] = x;
- bufY[ii] = y;
- CALIBRATION_PRINT("| # %d: %dx%d \n", ii, x, y);
- }
- sort_data(bufX, 0, CALIBCONF_READ_NUM - 1);
- sort_data(bufY, 0, CALIBCONF_READ_NUM - 1);
- mPosX[2] = delta_add(bufX[CALIBCONF_READ_NUM / 2]);
- mPosY[2] = delta_add(bufY[CALIBCONF_READ_NUM / 2]);
-
- CALIBRATION_PRINT("+------------------------------------------------+\n");
- CALIBRATION_PRINT("| Touch the Bottom-Right corner of the screen %d times\n",
- CALIBCONF_READ_NUM);
- for (ii = 0; ii < CALIBCONF_READ_NUM; ii++) {
- read_event(evfd, &x, &y);
- bufX[ii] = x;
- bufY[ii] = y;
- CALIBRATION_PRINT("| # %d: %dx%d \n", ii, x, y);
- }
- sort_data(bufX, 0, CALIBCONF_READ_NUM - 1);
- sort_data(bufY, 0, CALIBCONF_READ_NUM - 1);
- mPosX[3] = delta_add(bufX[CALIBCONF_READ_NUM / 2]);
- mPosY[3] = delta_add(bufY[CALIBCONF_READ_NUM / 2]);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief sort integer dates
- *
- * @param[in] buff array of integer datas
- * @param[in] left array start index
- * @param[in] right array end index
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-sort_data(int buff[], int left, int right)
-{
- int ii, jj, pivot;
- int tmp;
-
- ii = left;
- jj = right;
-
- pivot = buff[(left + right) / 2];
- while (1) {
- while (buff[ii] < pivot) {
- ii++;
- }
- while (pivot < buff[jj]) {
- jj--;
- }
- if (ii >= jj) {
- break;
- }
- tmp = buff[ii];
- buff[ii] = buff[jj];
- buff[jj] = tmp;
- ii++;
- jj--;
- }
-
- if (left < (ii - 1)) {
- sort_data(buff, left, ii - 1);
- }
- if ((jj + 1) < right) {
- sort_data(buff, jj + 1, right);
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief event read from touchpanel
- *
- * @param[in] evfd touchpanel event device
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-read_event(int evfd, int *x, int *y)
-{
- fd_set fds;
- int ret;
- int rsize;
- int ii;
- int flagX = 0;
- int flagY = 0;
- struct timeval delay;
- struct input_event events[64];
-
- while (1) {
- /* select timeoutt value */
- delay.tv_sec = 0;
- delay.tv_usec = 100*1000;
- /* fs_set */
- FD_ZERO(&fds);
- FD_SET(evfd, &fds);
-
- /* wait for event read or timedout */
- ret = select(evfd + 1, &fds, NULL, NULL, &delay);
- if (ret <= 0) {
- continue;
- }
- if (FD_ISSET(evfd, &fds)) {
- /* event read */
- rsize = read(evfd, events, sizeof(events) );
- for (ii = 0; ii < (int)(rsize/sizeof(struct input_event)); ii++) {
- if ((events[ii].type == EV_ABS) && (events[ii].code == ABS_X)) {
- /* X */
- flagX++;
- *x = events[ii].value;
- }
- else if ((events[ii].type == EV_ABS) && (events[ii].code == ABS_Y)) {
- /* Y */
- flagY++;
- *y = events[ii].value;
- }
- }
- }
- /* Input 2 times (Touch On and Off) */
- if ((flagX >= 2) && (flagY >= 2)) {
- break;
- }
- }
-
- while (1) {
- delay.tv_sec = 0;
- delay.tv_usec = 200*1000;
- FD_ZERO(&fds);
- FD_SET(evfd, &fds);
-
- /* wait for input (or timedout) */
- ret = select(evfd + 1, &fds, NULL, NULL, &delay);
- if (ret == 0) {
- break;
- }
- else if (ret < 0) {
- continue;
- }
- rsize = read(evfd, events, sizeof(events));
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief open configuration file
- *
- * @param nothing
- * @return file descriptor
- * @retval != NULL file descriptor
- * @retval NULL open error
- */
-/*--------------------------------------------------------------------------*/
-static FILE *
-open_conffile(void)
-{
- char *confp;
- FILE *fp;
-
- /* Get configuration file path */
- confp = getenv(CALIBRATOIN_CONF_ENV);
- if (! confp) {
- confp = CALIBRATOIN_CONF_FILE;
- }
-
- /* Open configuration file */
- fp = fopen(confp, "w");
- if (fp == NULL) {
- perror(confp);
- return fp;
- }
- return fp;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief print help
- *
- * @param[in] pName program name
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-print_usage(const char *pName)
-{
- fprintf(stderr, "Usage: %s [-h][-width width][-height height] [device]\n", pName);
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief Device Input Controller(eGalax Touchpanel)
- * Send touchpanel input enevt to Weston
- *
- * @date Feb-20-2013
- */
-
-#include "ico_ictl-touch_egalax.h"
-
-/* Change touch event */
-#define REPLACE_TOUCH_EVENT 1 /* Change touch event to mouse left button event*/
-
-/* Program name */
-#define CALIBDAE_DEV_NAME "ico_ictl-touch_egalax"
-
-static void print_usage(const char *pName);
-static char *find_event_device(void);
-static int setup_uinput(char *uinputDeviceName);
-static void set_eventbit(int uifd);
-static int open_uinput(char *uinputDeviceName);
-static void close_uinput(int uifd);
-static void event_iterate(int uifd, int evfd);
-static void setup_sighandler(void);
-static void terminate_program(const int signal);
-static int setup_program(void);
-static int calibration_event(struct input_event *in, struct input_event *out);
-static void push_event(struct input_event *ev);
-static void push_eventlog(const char *cmd, const int value, struct timeval *tp);
-
-int mRunning = -1; /* Running flag */
-int mDebug = 0; /* Debug flag */
-int mEventLog = 0; /* event input log */
-struct timeval lastEvent = { 0, 0 }; /* last input event time */
-
-/* Configurations */
-int mDispWidth = CALIBRATION_DISP_WIDTH;
-int mDispHeight = CALIBRATION_DISP_HEIGHT;
-int mPosX[4] = { 0, 0, 0, 0 };
-int mPosY[4] = { 0, 0, 0, 0 };
-int mXlow = 0;
-int mXheigh = 0;
-int mYlow = 0;
-int mYheigh = 0;
-
-/* Optiones */
-int mTrans = 0; /* Rotate(0,90,180 or 270) */
-int mRevX = 0; /* Reverse X coordinate */
-int mRevY = 0; /* Reverse Y coordinate */
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief Device Input Controller: For eGalax TouchPanel
- * main routine
- *
- * @param main() finction's standard parameter (argc,argv)
- * @return result
- * @retval 0 success
- * @retval 8 failed(configuration error)
- * @retval 9 failed(event device error)
- */
-/*--------------------------------------------------------------------------*/
-int
-main(int argc, char *argv[])
-{
- int ii;
- int err;
- int uifd; /* uinput fd */
- int evfd; /* event device fd */
- char *eventDeviceName = NULL; /* event device name to hook */
- char *uinputDeviceName = "/dev/uinput"; /* User Input module */
-
- for (ii = 1; ii < argc; ii++) {
- if (strcmp(argv[ii], "-h") == 0) {
- print_usage(argv[0]);
- exit(0);
- }
- else if (strcmp(argv[ii], "-d") == 0) {
- mDebug = 1;
- }
- else if (strcmp(argv[ii], "-t") == 0) {
- if ((ii < (argc-1)) && (argv[ii+1][0] != '-')) {
- ii++;
- mTrans = strtol(argv[ii], (char **)0, 0);
- }
- else {
- mTrans = 90;
- }
- }
- else if (strcmp(argv[ii], "-l") == 0) {
- mEventLog = 1; /* Input Log for System Test */
- }
- else if (strcmp(argv[ii], "-L") == 0) {
- mEventLog = 2; /* Output Log for Unit Test */
- }
- else {
- eventDeviceName = argv[ii];
- }
- }
-
- if (eventDeviceName == NULL) {
- /* If event device not present, get default device */
- eventDeviceName = find_event_device();
- if (eventDeviceName == NULL) {
- /* System has no touchpanel, Error */
- exit(9);
- }
- }
-
- err = setup_program();
- if (err < 0) {
- if (err == -2) {
- fprintf(stderr, "%s: Illegal config value\n", argv[0]);
- }
- else {
- fprintf(stderr, "%s: Can not read config file\n", argv[0]);
- }
- exit(8);
- }
-
- if (! mDebug) {
- if (daemon(0, 1) < 0) {
- fprintf(stderr, "%s: Can not Create Daemon\n", argv[0]);
- exit(1);
- }
- }
-
- /* setup uinput device */
- uifd = setup_uinput(uinputDeviceName);
- if (uifd < 0) {
- fprintf(stderr, "uinput(%s) initialize failed. Continue anyway\n", uinputDeviceName);
- exit(9);
- }
-
- evfd = open(eventDeviceName, O_RDONLY);
- if (evfd < 0) {
- fprintf(stderr, "event device(%s) Open Error[%d]\n", eventDeviceName, errno);
- close_uinput(uifd);
- exit(9);
- }
- CALIBRATION_DEBUG("main: input device(%s) = %d\n", eventDeviceName, evfd);
-
- setup_sighandler();
-
- /* event read */
- mRunning = 1;
- event_iterate(uifd, evfd);
-
- if (evfd >= 0) {
- close(evfd);
- }
-
- close_uinput(uifd);
-
- exit(0);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief initialize with get configurations
- *
- * @param nothing
- * @return result
- * @retval 0 sucess
- * @retval -1 config file read error
- * @retval -2 illegal config value
- */
-/*--------------------------------------------------------------------------*/
-static int
-setup_program(void)
-{
- char *confp;
- char buff[128];
- FILE *fp;
- int work;
-
- /* Get configuration file path */
- confp = getenv(CALIBRATOIN_CONF_ENV);
- if (! confp) {
- confp = CALIBRATOIN_CONF_FILE;
- }
-
- /* Open configuration file */
- fp = fopen(confp, "r");
- if (fp == NULL) {
- perror(confp);
- return -1;
- }
-
- while (fgets(buff, sizeof(buff), fp)) {
- if (buff[0] == '#') {
- /* comment line, skip */
- continue;
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_DISP_W,
- sizeof(CALIBRATOIN_STR_DISP_W) - 1) == 0) {
- /* screen width */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mDispWidth = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("mDispWidth = %d\n", mDispWidth);
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_DISP_H,
- sizeof(CALIBRATOIN_STR_DISP_H) - 1) == 0) {
- /* screen height */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mDispHeight = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("mDispHeight = %d\n", mDispHeight);
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_POS1,
- sizeof(CALIBRATOIN_STR_POS1) - 1) == 0) {
- /* position1 : Top-Left */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mPosX[0] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- mPosY[0] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("POS1 = %dx%d\n", mPosX[0], mPosY[0]);
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_POS2,
- sizeof(CALIBRATOIN_STR_POS2) - 1) == 0) {
- /* position2 : Top-Right */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mPosX[1] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- mPosY[1] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("POS2 = %dx%d\n", mPosX[1], mPosY[1]);
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_POS3,
- sizeof(CALIBRATOIN_STR_POS3) - 1) == 0) {
- /* position3 : Bottom-Left */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mPosX[2] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- mPosY[2] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("POS3 = %dx%d\n", mPosX[2], mPosY[2]);
- }
- else if (strncmp(buff,
- CALIBRATOIN_STR_POS4,
- sizeof(CALIBRATOIN_STR_POS4) - 1) == 0) {
- /* position4 : Bottom-Right */
- strtok(buff, CALIBRATOIN_STR_SEPAR);
- mPosX[3] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- mPosY[3] = atoi(strtok(NULL, CALIBRATOIN_STR_SEPAR));
- CALIBRATION_INFO("POS4 = %dx%d\n", mPosX[3], mPosY[3]);
- }
- }
- fclose(fp);
-
- /* Reverse X coordinate, if need */
- if (mPosX[0] > mPosX[1]) {
- int work;
- work = mPosX[0];
- mPosX[0] = mPosX[1];
- mPosX[1] = work;
- work = mPosX[2];
- mPosX[2] = mPosX[3];
- mPosX[3] = work;
- mRevX = 1;
- CALIBRATION_INFO("Reverse X\n");
- }
-
- /* Reverse Y coordinate, if need */
- if (mPosY[0] > mPosY[2]) {
- work = mPosY[0];
- mPosY[0] = mPosY[2];
- mPosY[2] = work;
- work = mPosY[1];
- mPosY[1] = mPosY[3];
- mPosY[3] = work;
- mRevY = 1;
- CALIBRATION_INFO("Reverse Y\n");
- }
-
- if ((mRevX != 0) || (mRevY != 0)) {
- CALIBRATION_INFO("Changed POS1 = %dx%d\n", mPosX[0], mPosY[0]);
- CALIBRATION_INFO("Changed POS2 = %dx%d\n", mPosX[1], mPosY[1]);
- CALIBRATION_INFO("Changed POS3 = %dx%d\n", mPosX[2], mPosY[2]);
- CALIBRATION_INFO("Changed POS4 = %dx%d\n", mPosX[3], mPosY[3]);
- }
-
- mXlow = (mPosX[0] + mPosX[2]) / 2;
- mXheigh = (mPosX[1] + mPosX[3]) / 2;
- if (mXheigh <= mXlow) {
- return -2;
- }
-
- mYlow = (mPosY[0] + mPosY[1]) / 2;
- mYheigh = (mPosY[2] + mPosY[3]) / 2;
- if (mYheigh <= mYlow) {
- return -2;
- }
- return 1;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief signal handler
- *
- *
- * @param[in] signal signal numnber
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-terminate_program(const int signal)
-{
- mRunning = -signal;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief setup signal handler
- *
- * @param nothing
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-setup_sighandler(void)
-{
- sigset_t mask;
-
- sigemptyset(&mask);
-
- signal(SIGTERM, terminate_program);
-
- sigaddset(&mask, SIGTERM);
- sigprocmask(SIG_UNBLOCK, &mask, NULL);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief find_event_device: Find eGalax touchpanel device
- *
- *
- * @param nothing
- * @return device name
- * @retval != NULL device name string
- * @retvel == NULL system has no eGalax touchpanel
- */
-/*--------------------------------------------------------------------------*/
-static char *
-find_event_device(void)
-{
- FILE *fp;
- int eGalax = 0;
- int i, j, k;
- char buf[240];
- static char edevice[64];
-
- char *pdev = getenv(CALIBRATOIN_INPUT_DEV);
-
- if ((pdev != NULL) && (*pdev != 0)) {
- /* Search pseudo input device for Debug */
- int fd;
- for (i = 0; i < 16; i++) {
- snprintf(edevice, 64, "/dev/input/event%d", i);
- fd = open(edevice, O_RDONLY | O_NONBLOCK);
- if (fd < 0) continue;
-
- memset(buf, 0, sizeof(buf));
- ioctl(fd, EVIOCGNAME(sizeof(buf)), buf);
- close(fd);
- k = 0;
- for (j = 0; buf[j]; j++) {
- if (buf[j] != ' ') {
- buf[k++] = buf[j];
- }
- }
- buf[k] = 0;
-
- if (strncasecmp(buf, pdev, sizeof(buf)) == 0) {
- CALIBRATION_INFO("Event device of eGalax=<%s>\n", edevice);
- return edevice;
- }
- }
- }
- else {
- /* Search input device */
- fp = fopen("/proc/bus/input/devices", "r");
- if (!fp) {
- CALIBRATION_PRINT("find_event_device: /proc/bus/input/devices Open Error\n");
- return NULL;
- }
-
- while (fgets(buf, sizeof(buf), fp)) {
- if (eGalax == 0) {
- for (i = 0; buf[i]; i++) {
- if (strncmp(&buf[i], "eGalax", 6) == 0) {
- /* Find eGalax touchpanel device */
- eGalax = 1;
- break;
- }
- }
- }
- else {
- for (i = 0; buf[i]; i++) {
- if (strncmp(&buf[i], "Handlers", 8) == 0) {
- /* Find eGalax device and Handlers */
- for (j = i+8; buf[j]; j++) {
- if (buf[j] != ' ') continue;
- strcpy(edevice, "/dev/input/");
- for (k = strlen(edevice); k < (int)sizeof(edevice); k++) {
- j++;
- if ((buf[j] == 0) || (buf[j] == ' ') ||
- (buf[j] == '\t') || (buf[j] == '\n') ||
- (buf[j] == '\r')) break;
- edevice[k] = buf[j];
- }
- edevice[k] = 0;
- CALIBRATION_INFO("Event device of eGalax=<%s>\n", edevice);
- fclose(fp);
- return edevice;
- }
- break;
- }
- }
- }
- }
- fclose(fp);
- }
- CALIBRATION_PRINT("%s: System has no eGalax Touchpanel\n", CALIBDAE_DEV_NAME);
- return NULL;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief event input and convert (main loop)
- *
- *
- * @param[in] uifd event output file descriptor
- * @param[in] evfd event input file descriptor
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-event_iterate(int uifd, int evfd)
-{
- fd_set fds;
- int ret;
- int rsize;
- int ii;
- int retry;
- struct timeval delay;
- struct input_event events[128];
- struct input_event event;
-
- ioctl(evfd, EVIOCGRAB, 1);
-
- retry = 0;
-
- while (mRunning > 0) {
- delay.tv_sec = 1;
- delay.tv_usec = 0;
-
- FD_ZERO(&fds);
- FD_SET(evfd, &fds);
-
- ret = select(evfd + 1, &fds, NULL, NULL, &delay);
- if (ret <= 0) {
- continue;
- }
- if (FD_ISSET(evfd, &fds)) {
- rsize = read(evfd, events, sizeof(events));
- if (rsize <= 0) {
- if (rsize < 0) {
- CALIBRATION_PRINT("event_iterate: input device(%d) end<%d>\n", evfd, errno);
- retry ++;
- if (retry > CALIBRATOIN_RETRY_COUNT) {
- return;
- }
- }
- usleep(CALIBRATOIN_RETRY_WAIT * 1000);
- continue;
- }
- retry = 0;
- for (ii = 0; ii < (int)(rsize/sizeof(struct input_event)); ii++) {
- ret = calibration_event(&events[ii], &event);
-#ifdef REPLACE_TOUCH_EVENT
- if (ret >= 0) {
- if (write(uifd, &event, sizeof(struct input_event)) < 0) {
- CALIBRATION_PRINT("%s: Event write error %d[%d]\n",
- CALIBDAE_DEV_NAME, uifd, errno);
- }
- if (mEventLog == 2) {
- push_event(&event);
- }
- if (ret > 0) {
- event.type = EV_SYN;
- event.code = SYN_REPORT;
- event.value = 0;
- write(uifd, &event, sizeof(struct input_event));
-
- event.type = EV_KEY;
- event.code = BTN_LEFT;
- event.value = 1;
- if (write(uifd, &event, sizeof(struct input_event)) < 0) {
- CALIBRATION_PRINT("%s: Event write error %d[%d]\n",
- CALIBDAE_DEV_NAME, uifd, errno);
- }
- else {
- CALIBRATION_DEBUG("EV_KEY=BTN_LEFT\n");
- }
- if (mEventLog == 2) {
- push_event(&event);
- }
- }
- }
-#else /*REPLACE_TOUCH_EVENT*/
- ret = write(uifd, &event, sizeof(struct input_event));
- if (mEventLog == 2) {
- push_event(&event);
- }
-#endif /*REPLACE_TOUCH_EVENT*/
- }
- }
- }
- ioctl(evfd, EVIOCGRAB, 0);
-}
-
-static void
-push_eventlog(const char *event, const int value, struct timeval *tp)
-{
- struct timeval curtime;
-
- gettimeofday(&curtime, NULL);
-
- if (lastEvent.tv_sec) {
- int sec, usec;
-
- sec = curtime.tv_sec - lastEvent.tv_sec;
- usec = curtime.tv_usec - lastEvent.tv_usec;
-
- if (usec < 0) {
- sec -= 1;
- usec += 1000000;
- }
- usec += 500;
- if( usec >= 1000000 ) {
- usec -= 1000000;
- sec += 1;
- }
- if ((sec > 0) || ((sec == 0) && (usec >= 10000))) {
- printf("sleep %d.%03d\n", sec, usec / 1000);
- lastEvent.tv_sec = curtime.tv_sec;
- lastEvent.tv_usec = curtime.tv_usec;
- }
- }
- else {
- lastEvent.tv_sec = curtime.tv_sec;
- lastEvent.tv_usec = curtime.tv_usec;
- }
- printf("%s=%d\t# %d.%03d\n", event, value, (int)tp->tv_sec, (int)(tp->tv_usec/1000));
- fflush(stdout);
-}
-
-static void
-push_event(struct input_event *ev)
-{
- switch(ev->type) {
- case EV_ABS:
- switch(ev->code) {
- case ABS_X:
- push_eventlog("X", ev->value, &(ev->time));
- break;
- case ABS_Y:
- push_eventlog("Y", ev->value, &(ev->time));
- break;
- default:
- break;
- }
- break;
- case EV_KEY:
- switch(ev->code) {
- case BTN_TOUCH:
- push_eventlog("Touch", ev->value, &(ev->time));
- break;
- case BTN_LEFT:
- push_eventlog("Button", ev->value, &(ev->time));
- break;
- default:
- break;
- }
- break;
- default:
- break;
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief convert x/y coordinates
- *
- * @param[in] in input event
- * @param[in] out output converted event
- * @return result
- * @retval -1 input event queued(no output)
- * @retval 0 no input event
- * @retval 1 event converted
- */
-/*--------------------------------------------------------------------------*/
-static int
-calibration_event(struct input_event *in, struct input_event *out)
-{
- int ret = 0;
-#ifdef REPLACE_TOUCH_EVENT
- static int queue_touch = 0;
-#endif /*REPLACE_TOUCH_EVENT*/
-
- memcpy(out, in, sizeof(struct input_event) );
-
- switch (in->type) {
- case EV_ABS:
- /* absolute coordinate */
- switch (in->code) {
- /* X/Y coordinate */
- case ABS_X:
- out->value = mDispWidth * (in->value - mXlow) / (mXheigh - mXlow);
- if (mRevX) {
- out->value = mDispWidth - out->value;
- }
- if (out->value < 0) out->value = 0;
- if (out->value >= mDispWidth) out->value = mDispWidth - 1;
-
- if (mTrans == 90) {
- out->code = ABS_Y;
- out->value = mDispWidth - out->value - 1;
- }
- else if (mTrans == 180) {
- out->value = mDispWidth - out->value - 1;
- }
- else if (mTrans == 270) {
- out->code = ABS_Y;
- }
- if (mEventLog == 1) {
- push_eventlog("X", in->value, &(in->time));
- }
-#ifdef REPLACE_TOUCH_EVENT
- if (queue_touch & 1) {
- queue_touch &= ~1;
- if (queue_touch == 0) {
- ret = 1;
- }
- }
-#endif /*REPLACE_TOUCH_EVENT*/
- CALIBRATION_DEBUG("ABS_X=%s %d=>%d\n",
- (out->code == ABS_X) ? "X" : "Y",
- in->value, out->value);
- break;
-
- case ABS_Y:
- out->value = mDispHeight * (in->value - mYlow) / (mYheigh - mYlow);
- if (mRevY) {
- out->value = mDispHeight - out->value;
- }
- if (out->value < 0) out->value = 0;
- if (out->value >= mDispHeight) out->value = mDispHeight - 1;
-
- if (mTrans == 90) {
- out->code = ABS_X;
- }
- else if (mTrans == 180) {
- out->value = mDispHeight - out->value - 1;
- }
- else if (mTrans == 270) {
- out->code = ABS_X;
- out->value = mDispHeight - out->value - 1;
- }
- if (mEventLog == 1) {
- push_eventlog("Y", in->value, &(in->time));
- }
-#ifdef REPLACE_TOUCH_EVENT
- if (queue_touch & 2) {
- queue_touch &= ~2;
- if (queue_touch == 0) {
- ret = 1;
- }
- }
-#endif /*REPLACE_TOUCH_EVENT*/
- CALIBRATION_DEBUG("ABS_Y=%s %d=>%d\n",
- (out->code == ABS_X) ? "X" : "Y",
- in->value, out->value);
- break;
-
- default:
- CALIBRATION_DEBUG("calibration_event: Unknown code(0x%x)\n", (int)in->code);
- break;
- }
- break;
-
-#ifdef REPLACE_TOUCH_EVENT
- case EV_KEY:
- if (in->code == BTN_TOUCH) {
- if (mEventLog == 1) {
- push_eventlog("Touch", in->value, &(in->time));
- }
- /* Touch event change to mouse left button event */
- out->code = BTN_LEFT;
- if (out->value != 0) {
- queue_touch = 3;
- ret = -1;
- CALIBRATION_DEBUG("BTN_TOUCH=LEFT, queue(%d)\n", out->value);
- }
- else {
- ret = 0;
- CALIBRATION_DEBUG("BTN_TOUCH=LEFT(%d)\n", out->value);
- }
- }
- break;
-#endif /*REPLACE_TOUCH_EVENT*/
-
- case EV_SYN:
- CALIBRATION_DEBUG("calibration_event: SYN\n");
- break;
-
- default:
- CALIBRATION_DEBUG("calibration_event: Unknown type(0x%x)\n", (int)in->type);
- break;
- }
- if (out->value < 0) {
- out->value = 0;
- }
-
- return ret;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief setup uinput device for event output
- *
- * @param[in] uinputDeviceName uinput device node name
- * @return uinput file descriptor
- * @retval >= 0 file descriptor
- * @retval < 0 error
- */
-/*--------------------------------------------------------------------------*/
-static int
-setup_uinput(char *uinputDeviceName)
-{
- int uifd;
- struct uinput_user_dev uinputDevice;
-
- uifd = open_uinput(uinputDeviceName);
- if (uifd < 0) {
- perror("Open uinput");
- return -1;
- }
-
- memset(&uinputDevice, 0, sizeof(uinputDevice));
- strcpy(uinputDevice.name, CALIBDAE_DEV_NAME);
- uinputDevice.absmax[ABS_X] = mDispWidth;
- uinputDevice.absmax[ABS_Y] = mDispHeight;
-
- /* uinput device configuration */
- if (write(uifd, &uinputDevice, sizeof(uinputDevice)) < (int)sizeof(uinputDevice)) {
- perror("Regist uinput");
- CALIBRATION_PRINT("setup_uinput: write(%d) Error[%d]\n", uifd, errno);
- close(uifd);
- return -1;
- }
-
- /* uinput set event bits */
- set_eventbit(uifd);
-
- if (ioctl(uifd, UI_DEV_CREATE, NULL) < 0) {
- CALIBRATION_PRINT("setup_uinput: ioclt(%d,UI_DEV_CREATE,) Error[%d]\n", uifd, errno);
- }
- return uifd;
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief event bit set
- *
- * @param[in] uifd uinput file descriptor
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-set_eventbit(int uifd)
-{
- ioctl(uifd, UI_SET_EVBIT, EV_SYN);
-
- ioctl(uifd, UI_SET_EVBIT, EV_ABS);
- ioctl(uifd, UI_SET_ABSBIT, ABS_X);
- ioctl(uifd, UI_SET_ABSBIT, ABS_Y);
-
- ioctl(uifd, UI_SET_EVBIT, EV_KEY);
-#ifdef REPLACE_TOUCH_EVENT
- ioctl(uifd, UI_SET_KEYBIT, BTN_LEFT);
-#else /*REPLACE_TOUCH_EVENT*/
- ioctl(uifd, UI_SET_KEYBIT, BTN_TOUCH);
- ioctl(uifd, UI_SET_KEYBIT, BTN_TOOL_PEN);
-#endif /*REPLACE_TOUCH_EVENT*/
-
- ioctl(uifd, UI_SET_EVBIT, EV_MSC);
- ioctl(uifd, UI_SET_MSCBIT, MSC_SCAN);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief open uinput device
- *
- * @param[in] uinputDeviceName uinput device name
- * @return uinput file descriptor
- * @retval >= 0 file descriptor
- * @retval < 0 error
- */
-/*--------------------------------------------------------------------------*/
-static int
-open_uinput(char *uinputDeviceName)
-{
- return open(uinputDeviceName, O_RDWR);
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief close uinput device
- *
- * @param[in] uifd uinput file descriptor
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-close_uinput(int uifd)
-{
- if (uifd >= 0) {
- ioctl(uifd, UI_DEV_DESTROY, NULL);
- close(uifd);
- uifd = -1;
- }
-}
-
-/*--------------------------------------------------------------------------*/
-/**
- * @brief print help message
- *
- * @param[in] pName program name
- * @return nothing
- */
-/*--------------------------------------------------------------------------*/
-static void
-print_usage(const char *pName)
-{
- fprintf(stderr, "Usage: %s [-h][-d][-t [rotate]] [device]\n", pName );
-}
-
+++ /dev/null
-/*
- * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
- *
- * This program is licensed under the terms and conditions of the
- * Apache License, version 2.0. The full text of the Apache License is at
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- */
-/**
- * @brief Device Input Controller(cartouch Touchpanel)
- * Program common include file
- *
- * @date Feb-20-2013
- */
-
-#ifndef _ICO_ICTL_TOUCH_EGALAX_H_
-#define _ICO_ICTL_TOUCH_EGALAX_H_
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <time.h>
-#include <unistd.h>
-#include <sys/time.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/ioctl.h>
-#include <linux/input.h>
-#include <linux/uinput.h>
-
-/* Default screen size */
-#define CALIBRATION_DISP_WIDTH 1920
-#define CALIBRATION_DISP_HEIGHT 1080
-
-/* Configuration file */
-#define CALIBRATOIN_CONF_LEN_MAX 128
-#define CALIBRATOIN_CONF_ENV "CALIBRATOIN_CONF"
-#define CALIBRATOIN_INPUT_DEV "ICTL_TOUCH_DEV"
-#define CALIBRATOIN_CONF_FILE \
- "/opt/etc/ico-uxf-device-input-controller/egalax_calibration.conf"
-
-/* Configuration items */
-#define CALIBRATOIN_STR_SEPAR "=*" /* Delimitor */
-#define CALIBRATOIN_STR_DISP_W "DWIDTH" /* Screen width */
-#define CALIBRATOIN_STR_DISP_H "DHEIGHT" /* Scneen height */
-#define CALIBRATOIN_STR_POS1 "POSITION1" /* Top-Left position */
-#define CALIBRATOIN_STR_POS2 "POSITION2" /* Top-Right position */
-#define CALIBRATOIN_STR_POS3 "POSITION3" /* Bottom-Left position */
-#define CALIBRATOIN_STR_POS4 "POSITION4" /* Bottom-Right position */
-
-/* Error retry */
-#define CALIBRATOIN_RETRY_COUNT 10 /* number of error retry */
-#define CALIBRATOIN_RETRY_WAIT 10 /* wait time(ms) for retry */
-
-/* Debug macros */
-#define CALIBRATION_DEBUG(fmt, ...) {if (mDebug) {fprintf(stdout, "%s:%d "fmt, __func__, __LINE__, ##__VA_ARGS__); fflush(stdout);}}
-#define CALIBRATION_INFO(fmt, ...) {if (mDebug) {fprintf(stdout, "%s:%d "fmt, __func__, __LINE__, ##__VA_ARGS__); fflush(stdout);}}
-#define CALIBRATION_PRINT(...) {fprintf(stdout, ##__VA_ARGS__); fflush(stdout);}
-
-#endif /*_ICO_ICTL_TOUCH_EGALAX_H_*/
-
projects / profile / ivi / ico-uxf-device-input-controller.git / commitdiff