src/DbusConnection.cpp

Go to the documentation of this file.

/*

Traplas visualisation.

Copyright (C) 2006 Herbert de Vos & Willem Drost

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

(For full Licence see ../GPL-Licence.txt)

*/

#define ASYNCHRONOUS 0
#define SYNCHRONOUS 1

#ifndef DBUSCONNECTION_H
#include "DbusConnection.h"
#endif

#ifndef MESSAGECONTROLLER_H
#include "MessageController.h"
#endif

GType some_object_get_type (void);
G_DEFINE_TYPE(SomeObject, some_object, G_TYPE_OBJECT)
gboolean _send_message(SomeObject* obj, char** messgArray, GError** wrong);

#include "DbusConnection-glue.h"

static void
some_object_init (SomeObject *)
{
}

static void
some_object_class_init (SomeObjectClass *)
{
}

static void
lose (const char *str, ...)
{
  va_list args;

  va_start (args, str);

  vfprintf (stderr, str, args);
  fputc ('\n', stderr);

  va_end (args);

  exit (1);
}

static void
lose_gerror (const char *prefix, GError *error)
{
  lose ("%s: %s", prefix, error->message);
}

/*
 * Our sendMessage function: Used to process messages.
 */
gboolean _send_message(SomeObject* obj, char** messgArray, GError** ) {
        MessageController* myc = obj->mc;

        //      Construct the message.
        shared_ptr< vector< shared_ptr< string > > > message( new vector< shared_ptr< string > >() );
        for ( int i = 0 ; messgArray[i] != NULL ; i++) {
                shared_ptr< string > newword( new string( messgArray[i] ) );
                message->push_back(newword);
        }

        //      Now send the message to the MessageController.
        myc-> processMessageFromComm( message );

        return TRUE;
}

/*
 *      The receive-thread contains the glib_main_loop for receiving messages.
 */
void* receiveThread(void* mainloop) {

        g_main_loop_run((GMainLoop*)mainloop);

        return 0;
}

/*
 *      The send-thread. It looks at the outqueue for messages to be send.
 */
void* sendThread(void* att) {

        GError *error = NULL;

        DbusConnection* myconnection = (DbusConnection*) att;
        bool message_ready;

        while ( myconnection->sendthread_run ) {
                if ( pthread_mutex_trylock( &(myconnection->mutex) ) != 0 )
                        pthread_cond_wait( &(myconnection->cond), &(myconnection->mutex) );

                char **sendArray = NULL;

                if (!myconnection->outqueue->empty()) {
                        //      Construct the message to be sent over Dbus and clean up.
                        ostringstream msg;

                        vector< shared_ptr< string > >::iterator iter;
                        iter = myconnection->outqueue->front()->begin();
                        while ( iter != myconnection->outqueue->front()->end() ) {
                                msg << **iter << " ";
                                iter++;
                        }

                        sendArray = g_strsplit(msg.str().c_str(), " ", 0);

                        myconnection->outqueue->pop();
                        message_ready = true;
                } else message_ready = false;
                pthread_mutex_unlock( &(myconnection->mutex) );
                pthread_cond_signal( &(myconnection->cond) );

                if ( message_ready ) {
                        #if SYNCHRONOUS

                        if(!dbus_g_proxy_call(  myconnection->remote_object,
                                                                        "SendMessage",
                                                                        &error,
                                                                        G_TYPE_STRV,
                                                                        sendArray,
                                                                        G_TYPE_INVALID,
                                                                        G_TYPE_INVALID)) {
                                lose_gerror ("failed to send message", error);
                        } 
                        #endif

                        #if ASYNCHRONOUS
                        DBusGProxyCall* callID;

                        callID = dbus_g_proxy_begin_call(       myconnection->remote_object,
                                                                                                "SendMessage",
                                                                                                NULL ,
                                                                                                NULL,
                                                                                                NULL ,
                                                                                                G_TYPE_STRV,
                                                                                                sendArray,
                                                                                                G_TYPE_INVALID);


                        if(!dbus_g_proxy_end_call(      myconnection->remote_object,
                                                                                callID,
                                                                                &error,
                                                                                G_TYPE_INVALID)) {
                                lose_gerror("failed to send message",error);
                        } 
                        #endif

                        g_strfreev(sendArray);
                } else
                        usleep(50);     //No messages left in the queue, check again later.             
        }
        int status = 0;
        pthread_exit(&status);
}

//      ---------------------------------------------------------------------------------------------
//      DbusConnection code.

void DbusConnection::dbus_init() {
        //      Initialise Dbus

        g_type_init ();

        DBusGConnection *bus;
        DBusGProxy *bus_proxy;
        GError *error = NULL;

        bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
        if (!bus)
                lose_gerror ("Couldn't connect to session bus.", error);

        SomeObject *obj;
        guint request_name_result;

        mainloop = g_main_loop_new (NULL, FALSE);

        dbus_g_object_type_install_info (SOME_TYPE_OBJECT, &dbus_glib__object_info);

        char otherName[512]="some.";
        strcat(otherName, thatapp.c_str());
        remote_object = dbus_g_proxy_new_for_name (     bus,
                                                                                                otherName,
                                                                                                "/SomeObject",
                                                                                                "some.SampleInterface");

        bus_proxy = dbus_g_proxy_new_for_name (bus, "org.freedesktop.DBus",
                                "/org/freedesktop/DBus",
                                "org.freedesktop.DBus");

        char registerName[512]="some.";
        strcat(registerName, thisapp.c_str());
        if (!dbus_g_proxy_call (bus_proxy, "RequestName", &error,
                                G_TYPE_STRING, registerName,
                                G_TYPE_UINT, 0,
                                G_TYPE_INVALID,
                                G_TYPE_UINT, &request_name_result,
                                G_TYPE_INVALID))
                lose_gerror ("Failed to acquire that name.\n", error);

        obj = (SomeObject*)g_object_new (SOME_TYPE_OBJECT, NULL);
        obj->mc = msgcontroller;

        dbus_g_connection_register_g_object (bus, "/SomeObject", G_OBJECT (obj));
}

DbusConnection::DbusConnection(string nthisapp, string nthatapp, MessageController* ptr) {

        thisapp = nthisapp;
        thatapp = nthatapp;
        msgcontroller = ptr;

        sendthread_run = true;

        //      Construct the queue and mutex&condition variables and init them.
        outqueue = shared_ptr< queue< shared_ptr< vector< shared_ptr<string> > > > >( new queue< shared_ptr< vector< shared_ptr<string> > > >() );
        pthread_mutex_init(&mutex, NULL);       
        pthread_cond_init(&cond, NULL); 

        //      Initialise Dbus
        dbus_init();

        //      Starting receiving thread.
        pthread_create(&receivethread, NULL, receiveThread, (void*) mainloop);

        //      Starting sending thread. This thread processes the outqueue.
        pthread_create(&sendthread, NULL, sendThread, (void*)this);
}

DbusConnection::~DbusConnection() {
        //TODO  Destructor not tested.

        //      Signal the senthread to quit
        sendthread_run = false;

        //      Kill the glib_mainloop
        g_main_destroy(mainloop);
        
        g_object_unref (G_OBJECT (remote_object));
        
        //      Wait for the threads to finish.
        pthread_join( sendthread, NULL);
        pthread_join( receivethread, NULL);             
}

bool DbusConnection::sendMessage(shared_ptr< vector< shared_ptr< string > > > messagebody) {
        //      Put a message in the outgoing queue.

        if ( pthread_mutex_trylock(&mutex) != 0 )
                pthread_cond_wait(&cond, &mutex);

        outqueue->push(messagebody);

        pthread_mutex_unlock(&mutex);
        pthread_cond_signal(&cond);
        
        return true;
}

---