~audio-recorder/audio-recorder/trunk

/*

 * Copyright (c) Linux community.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "dbus-player.h"

#include "dbus-mpris.h"

#include "dbus-banshee.h"

#include "dbus-marshal.h"

#include "log.h"

#include "support.h"

#include "utility.h"

// Thanks to:

// http://code.google.com/p/pidgin-musictracker/source/browse/trunk/src/banshee.c?r=446

//

// Read also dev-info/banshee_readme.txt

void marshal_VOID__STRING_STRING_DOUBLE (GClosure *closure, GValue *return_value G_GNUC_UNUSED, guint n_param_values,

        const GValue *param_values, gpointer invocation_hint G_GNUC_UNUSED,gpointer marshal_data);

void banshee_player_track_start(MediaPlayerRec *player) {

    // Called when Banshee player starts a new track

    // Re-read all player data

    banshee_get_info(player);

    // Set track changed signal

    TrackInfo *tr = &player->track;

    tr->status = PLAYER_STATUS_PLAYING;

    // Print debug info

    dbus_player_debug_print(player);

    // Process data

    dbus_player_process_data(player);

}

void banshee_player_track_stop(MediaPlayerRec *player) {

    // Called when Banshee player ends a track

    // Re-read all player data

    banshee_get_info(player);

    // Set track changed signal

    TrackInfo *tr = &player->track;

    tr->status = PLAYER_STATUS_STOPPED;

    // Print debug info

    dbus_player_debug_print(player);

    // Process data

    dbus_player_process_data(player);

}

/*

void banshee_player_track_changed(MediaPlayerRec *player) {

    // Called when track changes

    // Re-read all player data

    banshee_get_info(player);

    // Set track changed signal

    TrackInfo *tr = &player->track;

    tr->status = PLAYER_STATUS_TRACK_CHANGE;

    // Print debug info

    dbus_player_debug_print(player);

    // Process data

    dbus_player_process_data(player);

}

*/

void banshee_player_status_changed(MediaPlayerRec *player) {

    // Called when player's status or track changes

    // Re-read all player data

    banshee_get_info(player);

    // Print debug info

    // dbus_player_debug_print(player);

    // Process data

    dbus_player_process_data(player);

}

void banshee_get_app_name(MediaPlayerRec *player) {

    // Name of the Banshee media player.

    player->app_name = g_strdup(_("Banshee Media Player"));

}

void banshee_state_signal_cb(DBusGProxy *player_proxy, gchar *state, MediaPlayerRec *player) {

    // State signal from Banshee

    // state:

    // "idle"  (quit player)

    // "loading"

    // "loaded"

    // "playing"  (play)

    // "paused"   (pause)

    // LOG_PLAYER("banshee_state_signal_cb: %s (%s) got state:<%s>\n", player->app_name, player->service_name, state);

    if ((!g_strcmp0(state, "idle")) || // Quit player

            (!g_strcmp0(state, "playing")) || // Play

            (!g_strcmp0(state, "paused"))) {

        // We do not utilize these state-events at the moment. See the banshee_event_signal_cb() function below.

        // Re-read all data and inform GUI

        // banshee_player_status_changed(player);

    }

}

void banshee_event_signal_cb(DBusGProxy *player_proxy, gchar *event, gchar *message, gdouble buffering_percentage, MediaPlayerRec *player) {

    // Event signal from Banshee

    // event:

    // "volume"

    // "seek"

    // "statechange"

    // "requestnexttrack"

    // "startofstream"

    // "endofstream"

    LOG_PLAYER("banshee_event_signal_cb: %s (%s) got event:<%s>\n", player->app_name, player->service_name, event);

    if (!g_strcmp0(event, "volume")) {

        // Do nothing

    } else if (!g_strcmp0(event, "seek")) {

        // Do nothing

    } else if (!g_strcmp0(event, "requestnexttrack")) {

        // Do nothing

    } else if (!g_strcmp0(event, "statechange")) {

        // Re-read all data and inform the recorder

        banshee_player_status_changed(player);

    } else if (!g_strcmp0(event, "startofstream")) {

        // Stop and start of a new stream/track. Inform the recorder

        banshee_player_track_stop(player);

        banshee_player_track_start(player);

    } else if (!g_strcmp0(event, "endofstream")) {

        // End of track/stream. Inform the recorder

        banshee_player_track_stop(player);

    }

}

gboolean banshee_check_proxy(MediaPlayerRec *player) {

    // Check/set proxy

    if (!player) return FALSE;

    if (!player->proxy) {

        DBusGConnection *dbus_conn = dbus_player_connect_to_dbus();

        player->proxy = dbus_g_proxy_new_for_name(dbus_conn,

                        player->service_name,

                        "/org/bansheeproject/Banshee/PlayerEngine",

                        "org.bansheeproject.Banshee.PlayerEngine");

    }

    if (!player->proxy) {

        LOG_ERROR("banshee_check_proxy: Cannot create DBus proxy for Banshee.\n");

    }

    return (player->proxy != NULL);

}

void banshee_set_signals(gpointer player_rec, gboolean connect) {

    // Connect/disconnect signals

    MediaPlayerRec *player = (MediaPlayerRec*)player_rec;

    if (!player) return;

    if (!player->proxy) {

        if (!banshee_check_proxy(player)) return;

        // Register arguments.

        dbus_g_object_register_marshaller(marshal_VOID__STRING_STRING_DOUBLE, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_INVALID);

        dbus_g_proxy_add_signal(player->proxy, "StateChanged", G_TYPE_STRING, G_TYPE_INVALID);

        dbus_g_proxy_add_signal(player->proxy, "EventChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_INVALID);

    }

    if (!banshee_check_proxy(player)) return;

    if (connect) {

        // Connect signals

        dbus_g_proxy_connect_signal(player->proxy, "StateChanged", G_CALLBACK(banshee_state_signal_cb), (gpointer)player, NULL);

        dbus_g_proxy_connect_signal(player->proxy, "EventChanged", G_CALLBACK(banshee_event_signal_cb), (gpointer)player, NULL);

    } else  {

        // Disconnect signals

        dbus_g_proxy_disconnect_signal(player->proxy, "StateChanged", G_CALLBACK(banshee_state_signal_cb), (gpointer)player);

        dbus_g_proxy_disconnect_signal(player->proxy, "EventChanged", G_CALLBACK(banshee_event_signal_cb), (gpointer)player);

    }

}

void banshee_hash_str(GHashTable *table, gchar *key, gchar *dest) {

    dest[0] = '\0';

    GValue* value = (GValue*) g_hash_table_lookup(table, key);

    if (G_VALUE_HOLDS_STRING(value)) {

        str_copy(dest, (gchar*)g_value_get_string(value), MPRIS_STRLEN-1);

    }

}

gboolean banshee_dbus_string(DBusGProxy *proxy, gchar *method, gchar* dest) {

    dest[0] = '\0';

    gchar *str = NULL;

    GError *error = 0;

    if (!dbus_g_proxy_call_with_timeout (proxy, method, DBUS_MPRIS_TIMEOUT, &error,

                                         G_TYPE_INVALID,

                                         G_TYPE_STRING, &str,

                                         G_TYPE_INVALID)) {

        LOG_ERROR("banshee_dbus_string: Failed to make DBus call %s: %s", method, error ? error->message : "");

        g_free(str);

        str = NULL;

        if (error)

            g_error_free(error);

        return FALSE;

    }

    str_copy(dest, str, MPRIS_STRLEN-1);

    dest[MPRIS_STRLEN-1] = '\0';

    g_free(str);

    return TRUE;

}

gint banshee_dbus_int(DBusGProxy *proxy, const char *method) {

    gint ret = 0;

    GError *error = NULL;

    if (!dbus_g_proxy_call_with_timeout (proxy, method, DBUS_MPRIS_TIMEOUT, &error,

                                         G_TYPE_INVALID,

                                         G_TYPE_INT, &ret,

                                         G_TYPE_INVALID)) {

        LOG_ERROR("banshee_dbus_int: Failed to make DBus call %s: %s", method, error ? error->message : "");

        if (error)

            g_error_free(error);

        return 0;

    }

    return ret;

}

guint banshee_dbus_uint(DBusGProxy *proxy, const char *method) {

    guint ret = 0;

    GError *error = NULL;

    if (!dbus_g_proxy_call_with_timeout (proxy, method, DBUS_MPRIS_TIMEOUT, &error,

                                         G_TYPE_INVALID,

                                         G_TYPE_UINT, &ret,

                                         G_TYPE_INVALID)) {

        LOG_ERROR("banshee_dbus_uint: Failed to make DBus call %s: %s", method, error ? error->message : "");

        if (error)

            g_error_free(error);

        return 0;

    }

    return ret;

}

void banshee_get_info(gpointer player_rec) {

    MediaPlayerRec *player = (MediaPlayerRec*)player_rec;

    TrackInfo *tr = &player->track;

    // Is this player running/active?

    player->active = mpris_service_is_running_by_name(player->service_name);

    if (!player->active) {

        tr->status = PLAYER_STATUS_CLOSED;

        goto LBL_1;

    }

    // Check proxy

    if (!banshee_check_proxy(player)) return;

    char str[MPRIS_STRLEN];

    if (!banshee_dbus_string(player->proxy, "GetCurrentState", str)) {

        // Application has exited/shutdown

        player->active = FALSE;

        tr->status = PLAYER_STATUS_STOPPED;

        goto LBL_1;

    }

    if (!g_strcmp0(str, "idle")) {

        tr->status = PLAYER_STATUS_STOPPED;

        goto LBL_1;

    } else if (!g_strcmp0(str, "playing")) {

        tr->status = PLAYER_STATUS_PLAYING;

    } else {

        tr->status = PLAYER_STATUS_PAUSED;

    }

    GError *error = NULL;

    GHashTable* table = NULL;

    if (!dbus_g_proxy_call_with_timeout(player->proxy, "GetCurrentTrack", DBUS_MPRIS_TIMEOUT, &error, G_TYPE_INVALID,

                                        dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &table,G_TYPE_INVALID)) {

        LOG_ERROR("banshee_get_info: Failed to make DBus call: %s", error ? error->message : "");

        if (error)

            g_error_free(error);

        goto LBL_1;

    }

    banshee_hash_str(table, "album", tr->album);

    banshee_hash_str(table, "artist", tr->artist);

    banshee_hash_str(table, "name", tr->track);

    g_hash_table_destroy(table);

    tr->total_secs = banshee_dbus_uint(player->proxy, "GetLength") / 1000;

    tr->current_secs = banshee_dbus_uint(player->proxy, "GetPosition") / 1000;

LBL_1:

    ;

}

void banshee_start_app(gpointer player_rec) {

    // Start Banshee

    MediaPlayerRec *player = (MediaPlayerRec*)player_rec;

    // Check/set proxy

    if (!banshee_check_proxy(player)) return;

    dbus_g_proxy_call_no_reply(player->proxy, "Start", G_TYPE_INVALID);

}

/*

 VOID:STRING,STRING,DOUBLE (marshal.list:1)

 Ref: http://web.archive.org/web/20080501043040/http://wiki.bluez.org/wiki/HOWTO/DiscoveringDevices

 An example:

 $ echo "VOID:STRING,STRING,DOUBLE" > marshal.list

 $ glib-genmarshal --prefix=marshal marshal.list --header > sample1.h

 $ glib-genmarshal --prefix=marshal marshal.list --body > sample1.c

 See dbus_marshal.c

*/

void marshal_VOID__STRING_STRING_DOUBLE (GClosure     *closure,

        GValue       *return_value G_GNUC_UNUSED,

        guint         n_param_values,

        const GValue *param_values,

        gpointer      invocation_hint G_GNUC_UNUSED,

        gpointer      marshal_data) {

    typedef void (*GMarshalFunc_VOID__STRING_STRING_DOUBLE) (gpointer     data1,

            gpointer     arg_1,

            gpointer     arg_2,

            gdouble      arg_3,

            gpointer     data2);

    register GMarshalFunc_VOID__STRING_STRING_DOUBLE callback;

    register GCClosure *cc = (GCClosure*) closure;

    register gpointer data1, data2;

    g_return_if_fail (n_param_values == 4);

    if (G_CCLOSURE_SWAP_DATA (closure)) {

        data1 = closure->data;

        data2 = g_value_peek_pointer (param_values + 0);

    } else {

        data1 = g_value_peek_pointer (param_values + 0);

        data2 = closure->data;

    }

    callback = (GMarshalFunc_VOID__STRING_STRING_DOUBLE) (marshal_data ? marshal_data : cc->callback);

    callback (data1,

              g_marshal_value_peek_string (param_values + 1),

              g_marshal_value_peek_string (param_values + 2),

              g_marshal_value_peek_double (param_values + 3),

              data2);

}