/***************************************************************************
* Function handle_rc_connect
*
* - Argument: tBTA_AV_RC_OPEN RC open data structure
*
* - Description: RC connection event handler
*
***************************************************************************/
void handle_rc_connect (tBTA_AV_RC_OPEN *p_rc_open)
{
BTIF_TRACE_DEBUG2("%s: rc_handle: %d", __FUNCTION__, p_rc_open->rc_handle);
bt_status_t result = BT_STATUS_SUCCESS;
int i;
char bd_str[18];
if(p_rc_open->status == BTA_AV_SUCCESS)
{
memcpy(btif_rc_cb.rc_addr, p_rc_open->peer_addr, sizeof(BD_ADDR));
btif_rc_cb.rc_features = p_rc_open->peer_features;
btif_rc_cb.rc_connected = TRUE;
btif_rc_cb.rc_handle = p_rc_open->rc_handle;
result = uinput_driver_check();
if(result == BT_STATUS_SUCCESS)
{
init_uinput();
}
}
else
{
BTIF_TRACE_ERROR2("%s Connect failed with error code: %d",
__FUNCTION__, p_rc_open->status);
btif_rc_cb.rc_connected = FALSE;
}
}
static void avctp_connect_cb(GIOChannel *chan, GError *err, gpointer data)
{
struct avctp *session = data;
char address[18];
uint16_t imtu, omtu;
GError *gerr = NULL;
if (err) {
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
error("%s", err->message);
return;
}
bt_io_get(chan, &gerr,
BT_IO_OPT_DEST, &address,
BT_IO_OPT_IMTU, &imtu,
BT_IO_OPT_IMTU, &omtu,
BT_IO_OPT_INVALID);
if (gerr) {
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
error("%s", gerr->message);
g_error_free(gerr);
return;
}
DBG("AVCTP: connected to %s", address);
if (session->control == NULL)
session->control = avctp_channel_create(session, chan, NULL);
session->control->imtu = imtu;
session->control->omtu = omtu;
session->control->buffer = g_malloc0(MAX(imtu, omtu));
session->control->watch = g_io_add_watch(session->control->io,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) session_cb, session);
session->passthrough_id = avctp_register_pdu_handler(session,
AVC_OP_PASSTHROUGH,
handle_panel_passthrough,
NULL);
session->unit_id = avctp_register_pdu_handler(session,
AVC_OP_UNITINFO,
handle_unit_info,
NULL);
session->subunit_id = avctp_register_pdu_handler(session,
AVC_OP_SUBUNITINFO,
handle_subunit_info,
NULL);
init_uinput(session);
avctp_set_state(session, AVCTP_STATE_CONNECTED);
}
static void avctp_connect_cb(GIOChannel *chan, int err, const bdaddr_t *src,
const bdaddr_t *dst, gpointer data)
{
struct avctp *session = data;
struct l2cap_options l2o;
socklen_t len;
int sk;
char address[18];
if (!g_slist_find(sessions, session)) {
error("avctp_connect_cb: session no longer exists");
return;
}
if (err < 0) {
avctp_unref(session);
error("AVCTP connect(%s): %s (%d)", address, strerror(-err),
-err);
return;
}
ba2str(&session->dst, address);
debug("AVCTP: connected to %s", address);
g_io_channel_set_close_on_unref(chan, FALSE);
sk = g_io_channel_unix_get_fd(chan);
session->sock = sk;
memset(&l2o, 0, sizeof(l2o));
len = sizeof(l2o);
if (getsockopt(sk, SOL_L2CAP, L2CAP_OPTIONS, &l2o, &len) < 0) {
err = errno;
avctp_unref(session);
error("getsockopt(L2CAP_OPTIONS): %s (%d)", strerror(err),
err);
return;
}
init_uinput(session);
g_dbus_emit_signal(session->dev->conn, session->dev->path,
AUDIO_CONTROL_INTERFACE, "Connected",
DBUS_TYPE_INVALID);
session->state = AVCTP_STATE_CONNECTED;
session->mtu = l2o.imtu;
if (session->io)
g_source_remove(session->io);
session->io = g_io_add_watch(chan,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) session_cb, session);
}
int main(int argc, char **argv)
{
char keys[1024]={0};
if(init_uinput()<0)
{
perror("init_uinput failed");
return -1;
}
int src=server(12345);
int data;
while(1)
{
if(!read(src, &data, 4)){
exit(1);
}
if(data<1024)
{
printf("Got Keycode: %i\n", data);
keys[data]^=1;
if(keys[data])
{
press_key(data);
}
else
{
release_key(data);
}
}
else
{
int i;
for(i=0;i<1024;i++)
{
release_key(i);
}
memset(keys, 0, 1024);
}
}
destroy_uinput();
return 0;
}
static void avctp_connect_cb(GIOChannel *chan, GError *err, gpointer data)
{
struct avctp *session = data;
char address[18];
uint16_t imtu;
GError *gerr = NULL;
if (err) {
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
error("%s", err->message);
return;
}
bt_io_get(chan, BT_IO_L2CAP, &gerr,
BT_IO_OPT_DEST, &address,
BT_IO_OPT_IMTU, &imtu,
BT_IO_OPT_INVALID);
if (gerr) {
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
error("%s", gerr->message);
g_error_free(gerr);
return;
}
DBG("AVCTP: connected to %s", address);
if (!session->io)
session->io = g_io_channel_ref(chan);
init_uinput(session);
avctp_set_state(session, AVCTP_STATE_CONNECTED);
session->mtu = imtu;
session->io_id = g_io_add_watch(chan,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) session_cb, session);
}
static void avctp_connect_session(struct avctp *session)
{
GIOChannel *io;
session->state = AVCTP_STATE_CONNECTED;
session->dev = manager_device_connected(&session->dst,
AVRCP_TARGET_UUID);
session->dev->control->session = session;
init_uinput(session);
g_dbus_emit_signal(session->dev->conn, session->dev->path,
AUDIO_CONTROL_INTERFACE, "Connected",
DBUS_TYPE_INVALID);
if (session->io)
g_source_remove(session->io);
io = g_io_channel_unix_new(session->sock);
session->io = g_io_add_watch(io,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) session_cb, session);
g_io_channel_unref(io);
}
void
XboxdrvDaemon::run()
{
try
{
create_pid_file();
init_uinput();
USBSubsystem usb_subsystem;
UdevSubsystem udev_subsystem;
udev_subsystem.set_device_callback(boost::bind(&XboxdrvDaemon::process_match, this, _1));
boost::scoped_ptr<DBusSubsystem> dbus_subsystem;
if (m_opts.dbus != Options::kDBusDisabled)
{
DBusBusType dbus_bus_type;
switch(m_opts.dbus)
{
case Options::kDBusAuto:
if (getuid() == 0)
{
dbus_bus_type = DBUS_BUS_SYSTEM;
}
else
{
dbus_bus_type = DBUS_BUS_SESSION;
}
break;
case Options::kDBusSession:
dbus_bus_type = DBUS_BUS_SESSION;
break;
case Options::kDBusSystem:
dbus_bus_type = DBUS_BUS_SYSTEM;
break;
case Options::kDBusDisabled:
default:
assert(!"should never happen");
break;
}
dbus_subsystem.reset(new DBusSubsystem("org.seul.Xboxdrv", dbus_bus_type));
dbus_subsystem->register_xboxdrv_daemon(this);
dbus_subsystem->register_controller_slots(m_controller_slots);
}
log_debug("launching into main loop");
g_main_loop_run(m_gmain);
log_debug("main loop exited");
// get rid of active ControllerThreads before the subsystems shutdown
m_inactive_controllers.clear();
m_controller_slots.clear();
}
catch(const std::exception& err)
{
log_error("fatal exception: " << err.what());
}
}
int main(int argc, char **argv)
{
int i;
int res;
int one = 1;
int option_index = 0;
int c;
char *main_script = NULL;
// adding default include paths
add_include_path(".");
// TODO: once ordinary installation is available, add /usr/share/kbd-mangler/js or something
while (1) {
c = getopt_long(argc, argv, "r:w:I:", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'r': {
// preparing input device
int input_fd = open(optarg, O_RDONLY);
if (input_fd < 0)
{
fprintf(stderr, "could not open input device %s: %s\n", optarg, strerror(errno));
exit(2);
}
if (ioctl(input_fd, EVIOCGRAB, (void *)1) < 0)
{
fprintf (stderr, "unable to grab device '%s' : %s\n", optarg, strerror(errno));
}
if (ioctl(input_fd, FIONBIO, (void *)&one) < 0)
{
fprintf (stderr, "unable to set device '%s' to non-blocking mode : %s\n", optarg, strerror(errno));
}
if (input_count < MAX_INPUTS) {
input_fds[input_count++] = input_fd;
} else {
fprintf (stderr, "Maximum number of input devices exceeded (%d)\n", MAX_INPUTS);
exit(1);
}
break;
}
case 'w':
if (uinput_fd >= 0) {
fprintf(stderr, "multiple -w options are not allowed\n");
usage();
exit(1);
}
init_uinput(optarg);
break;
case 'I':
add_include_path(optarg);
break;
case '?':
break;
default:
fprintf(stderr, "getopt returned unexpectd char code: 0%o\n", c);
exit(1);
}
}
if (uinput_fd == -1) {
usage();
}
// script name left
if (argc - optind != 1)
usage();
res = InitScripting(argv[optind]); // custom main script
if (res) {
main_loop();
} else {
fprintf(stderr, "Error initializing scripting\n");
}
DestroyScripting();
for (i = 0; i < input_count; i++)
close(input_fds[i]);
close(uinput_fd);
}
/*
Chatpad Interface:
==================
bInterfaceNumber 2
bInterfaceClass 255 Vendor Specific Class
bInterfaceSubClass 93
bInterfaceProtocol 2
*/
Chatpad::Chatpad(libusb_device_handle* handle, uint16_t bcdDevice,
bool no_init, bool debug) :
m_init_state(kStateInit1),
m_handle(handle),
m_bcdDevice(bcdDevice),
m_no_init(no_init),
m_debug(debug),
m_quit_thread(false),
m_uinput(),
m_keymap(),
m_state(),
m_led_state(0),
m_read_transfer(0)
{
if (m_bcdDevice != 0x0110 && m_bcdDevice != 0x0114)
{
throw std::runtime_error("unknown bcdDevice version number, please report this issue "
"to <*****@*****.**> and include the output of 'lsusb -v'");
}
std::fill(m_keymap.begin(), m_keymap.end(), 0);
std::fill(m_state.begin(), m_state.end(), 0);
m_keymap[CHATPAD_KEY_1] = KEY_1;
m_keymap[CHATPAD_KEY_2] = KEY_2;
m_keymap[CHATPAD_KEY_3] = KEY_3;
m_keymap[CHATPAD_KEY_4] = KEY_4;
m_keymap[CHATPAD_KEY_5] = KEY_5;
m_keymap[CHATPAD_KEY_6] = KEY_6;
m_keymap[CHATPAD_KEY_7] = KEY_7;
m_keymap[CHATPAD_KEY_8] = KEY_8;
m_keymap[CHATPAD_KEY_9] = KEY_9;
m_keymap[CHATPAD_KEY_0] = KEY_0;
m_keymap[CHATPAD_KEY_Q] = KEY_Q;
m_keymap[CHATPAD_KEY_W] = KEY_W;
m_keymap[CHATPAD_KEY_E] = KEY_E;
m_keymap[CHATPAD_KEY_R] = KEY_R;
m_keymap[CHATPAD_KEY_T] = KEY_T;
m_keymap[CHATPAD_KEY_Y] = KEY_Y;
m_keymap[CHATPAD_KEY_U] = KEY_U;
m_keymap[CHATPAD_KEY_I] = KEY_I;
m_keymap[CHATPAD_KEY_O] = KEY_O;
m_keymap[CHATPAD_KEY_P] = KEY_P;
m_keymap[CHATPAD_KEY_A] = KEY_A;
m_keymap[CHATPAD_KEY_S] = KEY_S;
m_keymap[CHATPAD_KEY_D] = KEY_D;
m_keymap[CHATPAD_KEY_F] = KEY_F;
m_keymap[CHATPAD_KEY_G] = KEY_G;
m_keymap[CHATPAD_KEY_H] = KEY_H;
m_keymap[CHATPAD_KEY_J] = KEY_J;
m_keymap[CHATPAD_KEY_K] = KEY_K;
m_keymap[CHATPAD_KEY_L] = KEY_L;
m_keymap[CHATPAD_KEY_COMMA] = KEY_COMMA;
m_keymap[CHATPAD_KEY_Z] = KEY_Z;
m_keymap[CHATPAD_KEY_X] = KEY_X;
m_keymap[CHATPAD_KEY_C] = KEY_C;
m_keymap[CHATPAD_KEY_V] = KEY_V;
m_keymap[CHATPAD_KEY_B] = KEY_B;
m_keymap[CHATPAD_KEY_N] = KEY_N;
m_keymap[CHATPAD_KEY_M] = KEY_M;
m_keymap[CHATPAD_KEY_PERIOD] = KEY_DOT;
m_keymap[CHATPAD_KEY_ENTER] = KEY_ENTER;
m_keymap[CHATPAD_KEY_BACKSPACE] = KEY_BACKSPACE;
m_keymap[CHATPAD_KEY_LEFT] = KEY_LEFT;
m_keymap[CHATPAD_KEY_SPACEBAR] = KEY_SPACE;
m_keymap[CHATPAD_KEY_RIGHT] = KEY_RIGHT;
m_keymap[CHATPAD_MOD_SHIFT] = KEY_LEFTSHIFT;
m_keymap[CHATPAD_MOD_GREEN] = KEY_LEFTALT;
m_keymap[CHATPAD_MOD_ORANGE] = KEY_LEFTCTRL;
m_keymap[CHATPAD_MOD_PEOPLE] = KEY_LEFTMETA;
init_uinput();
if (no_init)
{
m_init_state = kStateKeepAlive_1e;
}
send_command();
if (m_bcdDevice == 0x0110)
{
usb_submit_read(6, 32);
}
else if (m_bcdDevice == 0x0114)
{
usb_submit_read(4, 32);
}
}
int main(int argc, char *argv[])
{
int en_daemonize = 0;
int i;
for(i=1; i<argc; i++){
if(!strcmp(argv[i], "-d")){
en_daemonize = 1;
//daemonize("/tmp", "/tmp/pikeyd.pid");
}
if(!strcmp(argv[i], "-k")){
daemonKill("/tmp/pikeyd.pid");
exit(0);
}
if(!strcmp(argv[i], "-r")){
joy_enable_repeat();
}
if(!strcmp(argv[i], "-v")){
showVersion();
exit(0);
}
if(!strcmp(argv[i], "-h")){
showHelp();
exit(0);
}
}
if(en_daemonize){
daemonize("/tmp", "/tmp/pikeyd.pid");
}
init_iic();
init_config();
//test_config(); exit(0);
//test_iic(0x20); close_iic(); exit(0);
//printf("init uinput\n");
if(init_uinput() == 0){
sleep(1);
//test_uinput();
if(joy_RPi_init()>=0){
if(!en_daemonize){
printf("Press ^C to exit.\n");
}
for(;;){
joy_RPi_poll();
usleep(4000);
}
joy_RPi_exit();
}
close_uinput();
}
return 0;
}
