Connecting to Bluetooth Device using bluetooth_client_connect_service() - gnome-bluetooth 3.8.2.1

Question

I would be glad if I can be pointed in the right direction the community concerning my above topic.

I am interested in connecting to bluetooth devices using the gnome-bluetooth api in ubuntu 14.04 using the bluetooth_client_connect_service() function.

I have tried searching but could not find good results on how to use it so I decided to read the gnome-bluetooth's source code but due to insufficient commenting I am unable to understand.

Below is what I have done so far but I do not get any errors when I try running my application yet when I double-click on a device it does nothing.

#define AGENT_PATH "/org/bluez/agent/wizard"
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <signal.h>
#include <math.h>
#include <glib.h>
//#include <dbus/dbus.h>
#include <glib/gi18n.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <bluetooth-chooser.h>
#include <bluetooth-client.h>
#include <bluetooth-utils.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <bluetooth/hci_lib.h>

#define CONNECT_TIMEOUT 3.0
#define AGENT_PATH "/org/bluez/agent/wizard"

typedef struct {
    char *path;
    GTimer *timer;
} ConnectData;

BluetoothClient *client;
GtkWidget *selector;
GtkWidget *vboxMainLayout;

GValue value = { 0, };

int find_conn(int s, int dev_id, long arg)
{
    struct hci_conn_list_req *cl;
    struct hci_conn_info *ci;
    int i;

    if (!(cl = malloc(10 * sizeof(*ci) + sizeof(*cl)))) {
        perror("Can't allocate memory");
        exit(1);
    }
    cl->dev_id = dev_id;
    cl->conn_num = 10;
    ci = cl->conn_info;

    if (ioctl(s, HCIGETCONNLIST, (void *) cl)) {
        perror("Can't get connection list");
        exit(1);
    }

    for (i = 0; i < cl->conn_num; i++, ci++)
        if (!bacmp((bdaddr_t *) arg, &ci->bdaddr)) {
            free(cl);
            return 1;
        }

    free(cl);
    return 0;
}

void cmd_rssi(const char *bt_address)
{
    struct hci_conn_info_req *cr;
    bdaddr_t bdaddr;
    int8_t rssi;
    int dd, dev_id;

    str2ba(bt_address, &bdaddr);

        dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
        if (dev_id < 0) {
            g_print("\tNot connected.\n");
            return;
        }

    dd = hci_open_dev(dev_id);
    if (dd < 0) {
        perror("HCI device open failed");
        exit(1);
    }

    cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
    if (!cr) {
        perror("Can't allocate memory");
        exit(1);
    }

    bacpy(&cr->bdaddr, &bdaddr);
    cr->type = ACL_LINK;
    if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
        perror("Get connection info failed");
        exit(1);
    }

    if (hci_read_rssi(dd, htobs(cr->conn_info->handle), &rssi, 1000) < 0) {
        perror("Read RSSI failed");
        exit(1);
    }

    g_print("\tRSSI return value: %d\n", rssi);

    free(cr);

    hci_close_dev(dd);
}

void connect_callback (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
    ConnectData *data = (ConnectData *) user_data;
    gboolean success;

    success = bluetooth_client_connect_service_finish (client, res, NULL);

    if (success == FALSE && g_timer_elapsed (data->timer, NULL) < CONNECT_TIMEOUT) {
        bluetooth_client_connect_service (client, data->path, TRUE, NULL, connect_callback, data);
        return;
    }

    if (success == FALSE)
        g_print ("\tFailed to connect to device %s", data->path);
    else
        g_print("\n\tConnection successfully.. ha.. I'm tired\n");

    g_timer_destroy (data->timer);
    g_free (data->path);
    g_free (data);
}

void create_callback (BluetoothClient *_client, const char *path, const GError *error, gpointer user_data)
{
    ConnectData *data;
    //compiler throws "implicit declaration" warning here
    //bluetooth_client_set_trusted(client, path, TRUE);

    data = g_new0 (ConnectData, 1);
    data->path = g_strdup (path);
    data->timer = g_timer_new ();

    bluetooth_client_connect_service (client, path, TRUE, NULL, connect_callback, data);
}

void get_device_info(BluetoothChooser *self)
{

        const gchar* result;

        g_print ("Info dumped:\n");
        if (bluetooth_chooser_get_selected_device_info (self, "name", &value)) {
            g_print ("\tName: '%s'\n", g_value_get_string (&value));
            g_value_unset (&value);
        }
        if (bluetooth_chooser_get_selected_device_info (self, "address", &value)) {
            g_print ("\tAddress: '%s'\n", g_value_get_string (&value));
            g_value_unset (&value);
        }
        if (bluetooth_chooser_get_selected_device_info (self, "paired", &value)) {
            result = g_value_get_boolean (&value)? "Paired":"Unpaired";
            g_print ("\tPaired: '%s'\n", result);
            g_value_unset (&value);
        }
        guint type = bluetooth_chooser_get_selected_device_type (self);
        const gchar *device_type = bluetooth_type_to_string(type);
        if(type)
        {
            g_print("\tType: '%s'\n", device_type);
        }
        if (bluetooth_chooser_get_selected_device_info (self, "connected", &value)) {
                result = g_value_get_boolean (&value)? "Connected":"Not Connected";
                g_print ("\tConnected: '%s'\n", result);
                g_value_unset (&value);
        }
}

/* My problem lies here.. how to connect to the detected device 
 * no error message is displayed when a device is double-clicked
 */
void connect_button_clicked(GtkWidget *widget, gpointer user_data)
{
    const char *path = AGENT_PATH;
    ConnectData *data = (ConnectData *) user_data;
    GValue value = { 0, };

    bluetooth_chooser_get_selected_device_info (widget, "address", &value);
    bluetooth_client_connect_service (client, path, TRUE, NULL, connect_callback, data);

    //function to get the rssi value of the remote device
    cmd_rssi(g_value_get_string (&value));
}

void create_interface(GtkApplication *app, gpointer user_data)
{
    GtkWidget *frmTopWindow;
    frmTopWindow = gtk_application_window_new(app);
    gtk_window_set_title(GTK_WINDOW(frmTopWindow), "Test");
    gtk_window_set_position(GTK_WINDOW(frmTopWindow),GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(frmTopWindow),200,400);

    selector = bluetooth_chooser_new();
    g_object_set(selector,
                  "show-searching", TRUE,
                  "show-device-type", FALSE,
                  "show-pairing" , TRUE,
                  "show-device-category", FALSE,
                     NULL);
        client = bluetooth_client_new();
        vboxMainLayout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
        g_object_set(vboxMainLayout,
                "width-request", 190,
                "height-request", 300, NULL);

        gtk_container_add(GTK_CONTAINER(frmTopWindow),selector);

        /*Events and Signals*/
        /*------------------*/

        // When user double-clicks on a detected device, try and connect to that device
        // and display it's RSSI
        g_signal_connect(G_OBJECT(selector),"notify::selected-device-activated",G_CALLBACK(connect_button_clicked),client);

        //When user clicks on a detected device, display information about that device in the
        // standard output
        g_signal_connect(G_OBJECT(selector),"notify::device-selected",G_CALLBACK(get_device_info),vboxMainLayout);

        gtk_widget_show_all(frmTopWindow);
}

int main(int argc, char** argv)
{
    GtkApplication *app;
    int status;
    app = gtk_application_new ("rucst.project.test", G_APPLICATION_FLAGS_NONE);
    g_signal_connect (app, "activate", G_CALLBACK (create_interface), NULL);
    status = g_application_run (G_APPLICATION (app), argc, argv);
    g_object_unref (app);
    return status;
}

In my implementation code, I have a g_signal_connect function that calls it as shown below:

g_signal_connect(G_OBJECT(selector),"notify::selected-device-activated",G_CALLBACK(connect_button_clicked),client);

This code I expect to connect to the selected detected device when it receives a double-click signal but at the moment nothing happens when I double-click on it.

I would be very grateful to receive guidance from the experts.

Thank you in advance

Answer 1

g_signal_connect(G_OBJECT(selector),"notify::selected-device-activated",
                 G_CALLBACK(connect_button_clicked),client);

This signal signature would be used if there was a property "selected-device-activated" and you wanted to know when the property value changes. But in this case "selected-device-activated" is an actual signal so you should just do:

g_signal_connect(G_OBJECT(selector),"selected-device-activated",
                 G_CALLBACK(callback), client);

The single click version just happens to work because you've found a property that does what you want, so connecting to "notify::device-selected" works (I'd still connect to the "selected-device-changed" signal for consistency instead).

---

After that in connect_button_clicked() your connect call uses what seems like a an unrelated path as the device object path... Something like this might work instead (although I'm not 100% sure about the "proxy" field name, I've not used this API myself):

GValue value = { 0, };
if (bluetooth_chooser_get_selected_device_info (BLUETOOTH_CHOOSER (widget),
                                                "proxy", &value)) {
    GDBusProxy *proxy = g_value_get_object (&value);
    g_print ("Connecting to %s\n", g_dbus_proxy_get_object_path(proxy));
    bluetooth_client_connect_service (client, g_dbus_proxy_get_object_path(proxy),
                                      TRUE, NULL, connect_callback, data);
}

Note also that the userdata pointers you give to the callbacks are wrong: e.g. connect_button_clicked() expects a ConnectData* but gets a BluetoothClient*.