void *
xmmsc_mainloop_gmain_init (xmmsc_connection_t *c)
{
xmmsc_glib_watch_t *watch;
gint fd;
g_return_val_if_fail (c, NULL);
fd = xmmsc_io_fd_get (c);
watch = g_new0 (xmmsc_glib_watch_t, 1);
watch->conn = xmmsc_ref (c);
watch->iochan = g_io_channel_unix_new (fd);
xmmsc_io_need_out_callback_set (c, xmmsc_mainloop_need_out_cb, watch);
watch->source_id = g_io_add_watch (watch->iochan,
G_IO_IN | G_IO_ERR | G_IO_HUP,
xmmsc_glib_read_cb,
watch);
g_io_channel_unref (watch->iochan);
if (xmmsc_io_want_out (c)) {
xmmsc_mainloop_need_out_cb (TRUE, watch);
}
return watch;
}
/*
* call-seq:
* xc.io_fd -> integer
*
* Returns the file descriptor of the Xmms::Client IPC socket.
*/
static VALUE
c_io_fd (VALUE self)
{
RbXmmsClient *xmms = NULL;
Data_Get_Struct (self, RbXmmsClient, xmms);
CHECK_DELETED (xmms);
return INT2NUM (xmmsc_io_fd_get (xmms->real));
}
void *
xmmsc_mainloop_ecore_init (xmmsc_connection_t *c)
{
Ecore_Fd_Handler *fdh;
int flags = ECORE_FD_READ | ECORE_FD_ERROR;
if (xmmsc_io_want_out (c))
flags |= ECORE_FD_WRITE;
fdh = ecore_main_fd_handler_add (xmmsc_io_fd_get (c), flags,
on_fd_data, c, NULL, NULL);
ecore_main_fd_handler_prepare_callback_set (fdh, on_prepare, c);
return fdh;
}
XmmsQT4::XmmsQT4 (xmmsc_connection_t *xmmsc) :
QObject (), Xmms::MainloopInterface (xmmsc),
m_fd (0), m_rsock (0), m_wsock (0), m_xmmsc (xmmsc)
{
m_fd = xmmsc_io_fd_get (xmmsc);
xmmsc_io_need_out_callback_set (xmmsc, CheckWrite, this);
m_rsock = new QSocketNotifier (m_fd, QSocketNotifier::Read, this);
connect (m_rsock, SIGNAL (activated (int)), SLOT (OnRead ()));
m_rsock->setEnabled (true);
m_wsock = new QSocketNotifier (m_fd, QSocketNotifier::Write, this);
connect (m_wsock, SIGNAL (activated (int)), SLOT (OnWrite ()));
m_wsock->setEnabled (false);
running_ = true;
}
unsigned int
xmmsc_mainloop_cf_init (xmmsc_connection_t *c, CFRunLoopSourceRef *source)
{
CFRunLoopRef runLoopRef = CFRunLoopGetCurrent ();
CFRunLoopSourceRef runLoopSourceRef;
CFSocketContext context;
CFSocketRef sockRef;
CFOptionFlags flags;
context.version = 0;
context.info = c;
context.retain = NULL;
context.release = NULL;
context.copyDescription = NULL;
flags = kCFSocketReadCallBack;
if (xmmsc_io_want_out (c))
flags |= kCFSocketWriteCallBack;
sockRef = CFSocketCreateWithNative (kCFAllocatorDefault,
xmmsc_io_fd_get (c),
flags,
&xmmsc_io_cf_event_callback,
&context);
if (!sockRef)
return 0;
runLoopSourceRef = CFSocketCreateRunLoopSource (kCFAllocatorDefault,
sockRef, XMMSC_CF_SOURCE_PRIORITY);
CFRunLoopAddSource (runLoopRef, runLoopSourceRef, kCFRunLoopDefaultMode);
xmmsc_io_need_out_callback_set (c, xmmsc_io_cf_toggle_socket_flags, sockRef);
*source = runLoopSourceRef;
return 1;
}
static void
cli_context_event_loop_select (cli_context_t *ctx)
{
xmmsc_connection_t *conn = cli_context_xmms_async (ctx);
fd_set rfds, wfds;
gint modfds;
gint xmms2fd;
gint maxfds = 0;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
/* Listen to xmms2 if connected */
if (conn) {
xmms2fd = xmmsc_io_fd_get (conn);
if (xmms2fd == -1) {
g_printf (_("Error: failed to retrieve XMMS2 file descriptor!"));
return;
}
FD_SET(xmms2fd, &rfds);
if (xmmsc_io_want_out (conn)) {
FD_SET(xmms2fd, &wfds);
}
if (maxfds < xmms2fd) {
maxfds = xmms2fd;
}
}
/* Listen to readline in shell mode or status mode */
if ((cli_context_in_mode (ctx, CLI_EXECUTION_MODE_SHELL) &&
cli_context_in_status (ctx, CLI_ACTION_STATUS_READY)) ||
cli_context_in_status (ctx, CLI_ACTION_STATUS_REFRESH)) {
FD_SET(STDIN_FILENO, &rfds);
if (maxfds < STDIN_FILENO) {
maxfds = STDIN_FILENO;
}
}
if (cli_context_in_status (ctx, CLI_ACTION_STATUS_REFRESH)) {
struct timeval refresh;
refresh.tv_sec = cli_context_refresh_interval (ctx);
refresh.tv_usec = 0;
modfds = select (maxfds + 1, &rfds, &wfds, NULL, &refresh);
} else {
modfds = select (maxfds + 1, &rfds, &wfds, NULL, NULL);
}
if (modfds < 0 && errno != EINTR) {
g_printf (_("Error: invalid I/O result!"));
return;
} else if (modfds != 0) {
/* Get/send data to xmms2 */
if (conn) {
if (FD_ISSET(xmms2fd, &rfds) &&
!xmmsc_io_in_handle (conn)) {
return;
}
if (FD_ISSET(xmms2fd, &wfds) &&
!xmmsc_io_out_handle (conn)) {
return;
}
}
/* User input found, read it */
if ((cli_context_in_mode (ctx, CLI_EXECUTION_MODE_SHELL) ||
cli_context_in_status (ctx, CLI_ACTION_STATUS_REFRESH)) &&
FD_ISSET(STDIN_FILENO, &rfds)) {
rl_callback_read_char ();
}
}
/* Status -refresh
Ask theefer: use callbacks for update and -refresh only for print?
Nesciens: Yes, please!
*/
if (cli_context_in_status (ctx, CLI_ACTION_STATUS_REFRESH)) {
cli_context_refresh_status (ctx);
}
}
static void
loop_select (cli_infos_t *infos)
{
fd_set rfds, wfds;
gint modfds;
gint xmms2fd;
gint maxfds = 0;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
/* Listen to xmms2 if connected */
if (infos->conn) {
xmms2fd = xmmsc_io_fd_get (infos->conn);
if (xmms2fd == -1) {
g_printf (_("Error: failed to retrieve XMMS2 file descriptor!"));
return;
}
FD_SET(xmms2fd, &rfds);
if (xmmsc_io_want_out (infos->conn)) {
FD_SET(xmms2fd, &wfds);
}
if (maxfds < xmms2fd) {
maxfds = xmms2fd;
}
}
/* Listen to readline in shell mode or status mode */
if ((infos->mode == CLI_EXECUTION_MODE_SHELL &&
infos->status == CLI_ACTION_STATUS_READY) ||
infos->status == CLI_ACTION_STATUS_REFRESH) {
FD_SET(STDINFD, &rfds);
if (maxfds < STDINFD) {
maxfds = STDINFD;
}
}
if (infos->status == CLI_ACTION_STATUS_REFRESH) {
struct timeval refresh;
refresh.tv_sec = infos->status_entry->refresh;
refresh.tv_usec = 0;
modfds = select (maxfds + 1, &rfds, &wfds, NULL, &refresh);
} else {
modfds = select (maxfds + 1, &rfds, &wfds, NULL, NULL);
}
if (modfds < 0) {
g_printf (_("Error: invalid I/O result!"));
return;
} else if (modfds != 0) {
/* Get/send data to xmms2 */
if (infos->conn) {
if (FD_ISSET(xmms2fd, &rfds)) {
xmmsc_io_in_handle (infos->conn);
}
if (FD_ISSET(xmms2fd, &wfds)) {
xmmsc_io_out_handle (infos->conn);
}
}
/* User input found, read it */
if ((infos->mode == CLI_EXECUTION_MODE_SHELL ||
infos->status == CLI_ACTION_STATUS_REFRESH) &&
FD_ISSET(STDINFD, &rfds)) {
rl_callback_read_char ();
}
}
/* Status -refresh
Ask theefer: use callbacks for update and -refresh only for print? */
if (infos->status == CLI_ACTION_STATUS_REFRESH) {
status_update_all (infos, infos->status_entry);
g_printf ("\r");
status_print_entry (infos->status_entry);
}
}
int32_t
Listener::getFileDescriptor() const
{
return xmmsc_io_fd_get( conn_ );
}
