clients = QTAILQ_HEAD_INITIALIZER(clients);
static ECS_State *current_ecs;
+static int port;
static pthread_mutex_t mutex_clilist = PTHREAD_MUTEX_INITIALIZER;
return -1;
}
+int get_ecs_port(void) {
+ return port;
+}
+
static void* ecs_initialize(void* args) {
int ret = 1;
ECS_State *cs = NULL;
QemuOpts *opts = NULL;
Error *local_err = NULL;
Monitor* mon = NULL;
- int port;
char host_port[16];
start_logging();
goto fail;
msgproc_monitor_req(cli, msg);
}
+ else if (master->type == ECS__MASTER__TYPE__DEVICE_REQ)
+ {
+ ECS__DeviceReq* msg = master->device_req;
+ if (!msg)
+ goto fail;
+ msgproc_device_req(cli, msg);
+ }
else if (master->type == ECS__MASTER__TYPE__SCREEN_DUMP_REQ)
{
ECS__ScreenDumpReq* msg = master->screen_dump_req;
void ecs_vprintf(const char *type, const char *fmt, va_list ap);
void ecs_printf(const char *type, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
+int get_ecs_port(void);
bool handle_protobuf_msg(ECS_Client* cli, char* data, const int len);
bool send_injector_ntf(const char* data, const int len);
bool send_control_ntf(const char* data, const int len);
bool send_monitor_ntf(const char* data, const int len);
+bool send_device_ntf(const char* data, const int len);
bool send_to_all_client(const char* data, const int len);
void send_to_client(int fd, const char* data, const int len) ;
bool msgproc_injector_req(ECS_Client* ccli, ECS__InjectorReq* msg);
bool msgproc_control_req(ECS_Client *ccli, ECS__ControlReq* msg);
bool msgproc_monitor_req(ECS_Client *ccli, ECS__MonitorReq* msg);
+bool msgproc_device_req(ECS_Client* ccli, ECS__DeviceReq* msg);
bool msgproc_screen_dump_req(ECS_Client *ccli, ECS__ScreenDumpReq* msg);
\r
#include "ecs.h"\r
#include "hw/maru_virtio_evdi.h"\r
+#include "hw/maru_virtio_sensor.h"\r
#include "skin/maruskin_operation.h"\r
\r
// utility functions\r
return true;\r
}\r
\r
+bool msgproc_device_req(ECS_Client* ccli, ECS__DeviceReq* msg)\r
+{\r
+ char cmd[10];\r
+ char* data;\r
+ memset(cmd, 0, 10);\r
+ strcpy(cmd, msg->category);\r
+ type_length length = (type_length) msg->length;\r
+ type_group group = (type_group) (msg->group & 0xff);\r
+ type_action action = (type_action) (msg->action & 0xff);\r
+\r
+ if (msg->has_data && msg->data.len > 0)\r
+ {\r
+ data = msg->data.data;\r
+ }\r
+\r
+ LOG(">> header = cmd = %s, length = %d, action=%d, group=%d", cmd, length,\r
+ action, group);\r
+ \r
+ if (!strncmp(cmd, MSG_TYPE_SENSOR, 6)) {\r
+ if (group == MSG_GROUP_STATUS) {\r
+ if (action ==MSG_ACTION_ACCEL) {\r
+ get_sensor_accel();\r
+ } else if (action == MSG_ACTION_GYRO) {\r
+ get_sensor_gyro();\r
+ } else if (action == MSG_ACTION_MAG) {\r
+ get_sensor_mag();\r
+ } else if (action == MSG_ACTION_LIGHT) {\r
+ get_sensor_light();\r
+ } else if (action == MSG_ACTION_PROXI) {\r
+ get_sensor_proxi();\r
+ }\r
+ } else {\r
+ set_sensor_data(length, data);\r
+ }\r
+ }\r
+ else if (!strncmp(cmd, MSG_TYPE_NFC, 3)) {\r
+ if (group == MSG_GROUP_STATUS) {\r
+ send_to_nfc(request_get, data, length);\r
+ } \r
+ else \r
+ {\r
+ send_to_nfc(request_set, data, length);\r
+ }\r
+ }\r
+\r
+ return true;\r
+}\r
+\r
bool msgproc_screen_dump_req(ECS_Client *ccli, ECS__ScreenDumpReq* msg)\r
{\r
\r
\r
return true;\r
}\r
+\r
+\r
+bool send_device_ntf(const char* data, const int len)\r
+{\r
+ return send_injector_ntf(data, len);\r
+}\r
+\r
\r
INFO("ntf_to_injector- bufnum: %s, group: %s, action: %s, data: %s\n", data_len, group, action, msg->buf);\r
\r
- ntf_to_injector(ecs_message, message_len);\r
+ //ntf_to_injector(ecs_message, message_len);\r
+ send_device_ntf(ecs_message, message_len);\r
\r
if (ecs_message)\r
free(ecs_message);\r
INFO("ntf_to_injector- bufnum: %s, group: %s, action: %s, data: %s\n", data_len, group, action, msg->buf);
- ntf_to_injector(ecs_message, message_len);
+ //ntf_to_injector(ecs_message, message_len);
+ send_device_ntf(ecs_message, message_len);
if (ecs_message)
free(ecs_message);
import org.tizen.emulator.skin.comm.ICommunicator.Scale;
import org.tizen.emulator.skin.comm.ICommunicator.SendCommand;
import org.tizen.emulator.skin.comm.sock.SocketCommunicator;
+import org.tizen.emulator.skin.comm.sock.SocketCommunicator.DataTranfer;
import org.tizen.emulator.skin.comm.sock.data.BooleanData;
import org.tizen.emulator.skin.comm.sock.data.DisplayStateData;
import org.tizen.emulator.skin.comm.sock.data.KeyEventData;
return listener;
}
+ public SelectionAdapter createEcpMenu() {
+ SelectionAdapter listener = new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+
+ String emulName = SkinUtil.getVmName(config);
+ int portSdb = config.getArgInt(ArgsConstants.NET_BASE_PORT);
+ int portEcp = 0;
+
+ DataTranfer dataTranfer = communicator.sendDataToQEMU(
+ SendCommand.ECP_PORT_REQ, null, true);
+ byte[] receivedData = communicator.getReceivedData(dataTranfer);
+ portEcp = receivedData[0] << 24;
+ portEcp |= receivedData[1] << 16;
+ portEcp |= receivedData[2] << 8;
+ portEcp |= receivedData[3];
+
+ ProcessBuilder procEcp = new ProcessBuilder();
+
+ // FIXME: appropriate running binary setting is necessary.
+ if (SwtUtil.isLinuxPlatform()) {
+ procEcp.command("/usr/bin/java", "-jar",
+ "./emulator-control-panel.jar", "vmname="
+ + emulName, "sdb.port=" + portSdb,
+ "svr.port=" + portEcp);
+ } else if (SwtUtil.isWindowsPlatform()) {
+ procEcp.command("java.exe", "-jar",
+ "emulator-control-panel.jar", "vmname=" + emulName,
+ "sdb.port=" + portSdb, "svr.port=" + portEcp);
+ } else if (SwtUtil.isMacPlatform()) {
+ // procSdb.command("./sdbscript", "emulator-" + portSdb);
+ /*
+ * procSdb.command( "/usr/X11/bin/uxterm", "-T", "emulator-"
+ * + portSdb, "-e", sdbPath,"shell");
+ */
+ }
+
+ logger.log(Level.INFO, procEcp.command().toString());
+
+ try {
+ procEcp.start(); /* open ECP */
+ } catch (Exception ee) {
+ logger.log(Level.SEVERE, ee.getMessage(), ee);
+ SkinUtil.openMessage(shell, null,
+ "Fail to open control panel: \n" + ee.getMessage(),
+ SWT.ICON_ERROR, config);
+ }
+ }
+ };
+
+ return listener;
+ }
+
public SelectionAdapter createTopMostMenu() {
SelectionAdapter listener = new SelectionAdapter() {
@Override
DETAIL_INFO((short) 17),
RAM_DUMP((short) 18),
GUEST_DUMP((short) 19),
-
+ ECP_PORT_REQ((short) 20),
+
RESPONSE_HEART_BEAT((short) 900),
RESPONSE_DRAW_FRAMEBUFFER((short) 901),
CLOSE((short) 998),
RAMDUMP_COMPLETE((short) 4),
BOOTING_PROGRESS((short) 5),
BRIGHTNESS_VALUE((short) 6),
+ ECP_PORT((short) 7),
SENSOR_DAEMON_START((short) 800),
SDB_DAEMON_START((short) 801),
DRAW_FRAME((short) 900),
private DataTranfer detailInfoTransfer;
private DataTranfer progressDataTransfer;
private DataTranfer brightnessDataTransfer;
-
+ private DataTranfer ecpTransfer;
+
private Thread sendThread;
private LinkedList<SkinSendData> sendQueue;
this.brightnessDataTransfer.sleep = SCREENSHOT_WAIT_INTERVAL;
this.brightnessDataTransfer.maxWaitTime = SCREENSHOT_WAIT_LIMIT;
+ this.ecpTransfer = new DataTranfer();
+ this.ecpTransfer.sleep = SCREENSHOT_WAIT_INTERVAL;
+ this.ecpTransfer.maxWaitTime = SCREENSHOT_WAIT_LIMIT;
+
this.heartbeatCount = new AtomicInteger(0);
//this.heartbeatExecutor = Executors.newSingleThreadScheduledExecutor();
this.heartbeatTimer = new Timer();
break;
}
+ case ECP_PORT: {
+ logger.info("received ECP_PORT from QEMU.");
+ resetDataTransfer(ecpTransfer);
+ receiveData( ecpTransfer, length );
+
+ break;
+ }
case SENSOR_DAEMON_START: {
logger.info("received SENSOR_DAEMON_START from QEMU.");
dataTranfer = resetDataTransfer(screenShotDataTransfer);
} else if (SendCommand.DETAIL_INFO.equals(command)) {
dataTranfer = resetDataTransfer(detailInfoTransfer);
+ } else if (SendCommand.ECP_PORT_REQ.equals(command)) {
+ dataTranfer = resetDataTransfer(ecpTransfer);
}
}
import org.tizen.emulator.skin.util.SwtUtil;
public class PopupMenu {
+ public static final String ECP_NAME = "Control &Panel";
public static final String TOPMOST_MENUITEM_NAME = "&Always On Top";
public static final String ROTATE_MENUITEM_NAME = "&Rotate";
public static final String SCALE_MENUITEM_NAME = "&Scale";
/* default menu items */
public MenuItem detailInfoItem;
+ public MenuItem ecpItem;
public MenuItem onTopItem;
public MenuItem rotateItem;
public MenuItem scaleItem;
SelectionAdapter detailInfoListener = skin.createDetailInfoMenu();
detailInfoItem.addSelectionListener(detailInfoListener);
-
+
new MenuItem(menu, SWT.SEPARATOR);
/* Always on top menu */
new MenuItem(menu, SWT.SEPARATOR);
+ ecpItem = new MenuItem(menu, SWT.PUSH);
+ {
+ ecpItem.setText(ECP_NAME);
+
+ SelectionAdapter ecpListener = skin.createEcpMenu();
+ ecpItem.addSelectionListener(ecpListener);
+ }
+
+ new MenuItem(menu, SWT.SEPARATOR);
+
/* Close menu */
closeItem = new MenuItem(menu, SWT.PUSH);
closeItem.setText(CLOSE_MENUITEM_NAME);
#include "emulator.h"
#include "debug_ch.h"
#include "sdb.h"
+#include "ecs.h"
#include "mloop_event.h"
#include "emul_state.h"
#include "maruskin_keymap.h"
}
}
+int get_ecs_port_req(void)
+{
+ return get_ecs_port();
+}
+
void do_open_shell(void)
{
INFO("open shell\n");
mloop_evcmd_ramdump();
}
+
void do_guestmemory_dump(void)
{
INFO("dump guest memory!\n");
QemuSurfaceInfo *get_screenshot_info(void);
DetailInfo *get_detail_info(int qemu_argc, char **qemu_argv);
+int get_ecs_port_req(void);
void free_detail_info(DetailInfo *detail_info);
void free_screenshot_info(QemuSurfaceInfo *);
RECV_DETAIL_INFO = 17,
RECV_RAM_DUMP = 18,
RECV_GUESTMEMORY_DUMP = 19,
+ RECV_ECP_PORT_REQ = 20,
RECV_RESPONSE_HEART_BEAT = 900,
RECV_RESPONSE_DRAW_FRAME = 901,
RECV_CLOSE = 998,
SEND_RAMDUMP_COMPLETE = 4,
SEND_BOOTING_PROGRESS = 5,
SEND_BRIGHTNESS_VALUE = 6,
+ SEND_ECP_PORT = 7,
SEND_SENSOR_DAEMON_START = 800,
SEND_SDB_DAEMON_START = 801,
SEND_DRAW_FRAME = 900,
do_ram_dump();
break;
}
+ case RECV_ECP_PORT_REQ: {
+ log_cnt += sprintf(log_buf + log_cnt, "RECV_ECP_PORT_REQ ==\n");
+ TRACE(log_buf);
+
+ int port = get_ecs_port_req();
+ unsigned char port_buf[5];
+ memset(port_buf, 0, 5);
+ port_buf[0] = (port & 0xFF000000) >> 24;
+ port_buf[1] = (port & 0x00FF0000) >> 16;
+ port_buf[2] = (port & 0x0000FF00) >> 8;
+ port_buf[3] = (port & 0x000000FF);
+
+ send_skin_data( client_sock, SEND_ECP_PORT, port_buf, 4, 0);
+ break;
+ }
case RECV_GUESTMEMORY_DUMP: {
log_cnt += sprintf(log_buf + log_cnt, "RECV_GUESTMEMORY_DUMP ==\n");
TRACE(log_buf);
projects / sdk / emulator / qemu.git / commitdiff