~osmoma/audio-recorder/trunk

/*
 * Copyright (c) 2011- Osmo Antero.
 *
 * 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 3 of the License (GPL3), or 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 3 for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License 3 along with this program; if not, see /usr/share/common-licenses/GPL file
 * or <http://www.gnu.org/licenses/>.
*/
#include "log.h"
#include "support.h"
#include "about.h"
#include "rec-manager.h"
#include <gst/gst.h>

// This module creates a DBus-server for this program.
// Other programs can control the recorder by calling methods via this DBus interface.
//
// Audio-recorder itself can send messages to the running instance of this program.
// See audio-recorder --help for more information.
//
//  Exported DBus methods are:
//  get_state(), returns current recording state: "not running" | "on" | off" | "paused".
//
//  set_state(state), set new state. The state can be one of: "start"|"stop"|"pause"|"hide"|"show"|"quit".
//                    returns "OK" if success. NULL if error.
//
// Ref: https://developer.gnome.org/gio/stable/GDBusServer.html
//
// Notice: This module has nothing to do with dbus-player.[ch], dbus-mpris2.[ch] modules.
//

#define R_DBUS_SERVER_ADDRESS "unix:abstract=audiorecorder"

#define R_DBUS_OBJECT_PATH "/org/gnome/API/AudioRecorder"
#define R_DBUS_INTERFACE_NAME "org.gnome.API.AudioRecorderInterface"

static GDBusServer *g_dbus_server = NULL;
static GDBusNodeInfo *g_introspection_data = NULL;

// Signatures for the methods we are exporting.
// DBus clients can get information or control the recorder by calling these functions.
static const gchar g_introspection_xml[] =
    "<node>"
    "  <interface name='org.gnome.API.AudioRecorderInterface'>"
    "    <method name='get_state'>"
    "      <arg type='s' name='response' direction='out'/>"  // Returns current recording state: "not running"|"on"|off"|"paused"
    "    </method>"
    "    <method name='set_state'>"
    "      <arg type='s' name='state' direction='in'/>"      // Set new state. Input argument:"start"|"stop"|"pause"|"hide"|"show"|"quit".
    "      <arg type='s' name='response' direction='out'/>"  // Returns "OK" or NULL if error.
    "    </method>"
    "  </interface>"
    "</node>";

static gboolean dbus_service_start();
static void dbus_service_set_state(gchar *new_state);

// -----------------------------------------------------------------------------------

void dbus_service_module_init() {
    LOG_DEBUG("Init dbus_service.c\n");

    g_dbus_server = NULL;

    // Start service
    dbus_service_start();
}

void dbus_service_module_exit() {
    LOG_DEBUG("Clean up dbus_service.c.\n");

    if (g_introspection_data) {
        g_dbus_node_info_unref(g_introspection_data);
    }
    g_introspection_data = NULL;

    if (g_dbus_server) {
        g_dbus_server_stop(g_dbus_server);
        g_object_unref(g_dbus_server);
    }
    g_dbus_server = NULL;
}

static void handle_method_call(GDBusConnection *connection,
                               const gchar           *sender,
                               const gchar           *object_path,
                               const gchar           *interface_name,
                               const gchar           *method_name,
                               GVariant              *parameters,
                               GDBusMethodInvocation *invocation,
                               gpointer               user_data) {

    // DBus method call: get_state.
    // Returns "not running" | "on" | "off" | "paused"
    if (g_strcmp0(method_name, "get_state") == 0) {

        // Get recording state
        gint state = -1;
        gint pending = -1;
        rec_manager_get_state(&state, &pending);

        const gchar *state_str = NULL;

        switch (state) {
        case GST_STATE_PAUSED:
            state_str = "paused";
            break;

        case GST_STATE_PLAYING:
            state_str = "on";
            break;

        default:
            state_str = "off";
        }

        g_dbus_method_invocation_return_value(invocation, g_variant_new ("(s)", state_str));
        LOG_DEBUG("Audio recorder (DBus-server) executed method get_state().\n");
    }

    // DBus method call: set_state(new_state).
    // new_state can be: "start" | "stop" | "pause" | "show"  | "hide" | "quit".
    // Returns "OK" | NULL
    else if (g_strcmp0 (method_name, "set_state") == 0) {
        gchar *response = g_strdup("OK");

        gchar *new_state = NULL;
        g_variant_get(parameters, "(&s)", &new_state);

        g_dbus_method_invocation_return_value(invocation, g_variant_new ("(s)", response));
        g_free(response);
        LOG_DEBUG("Audio recorder (Dbus-server) executed method set_state(%s).\n", new_state);

        // Set recorder to new_state
        dbus_service_set_state(new_state);
    }
}

static void dbus_service_set_state(gchar *new_state) {
    // Set recorder to new_state

    // $ audio-recorder --command start
    if (!g_strcmp0(new_state, "start")) {
        rec_manager_start_recording();
    }

    // $ audio-recorder --command stop
    else if (!g_strcmp0(new_state, "stop")) {
        rec_manager_stop_recording();
    }

    // $ audio-recorder --command pause
    else if (!g_strcmp0(new_state, "pause")) {
        rec_manager_pause_recording();
    }

    // $ audio-recorder --command show
    else if (!g_strcmp0(new_state, "show")) {
        rec_manager_show_window(TRUE);
    }

    // $ audio-recorder --command hide
    else if (!g_strcmp0(new_state, "hide")) {
        rec_manager_show_window(FALSE);
    }

    // $ audio-recorder --command quit
    else if (!g_strcmp0(new_state, "quit")) {
        rec_manager_quit_application();
    }
}

static const GDBusInterfaceVTable interface_vtable = {
    handle_method_call,
    NULL,
    NULL,
};

// ---------------------------------------------------------------------------------

static gboolean on_new_connection(GDBusServer *server, GDBusConnection *connection, gpointer user_data) {
    /*
    GCredentials *credentials = NULL;
    credentials = g_dbus_connection_get_peer_credentials(connection);

    gchar *s = NULL;
    if (credentials == NULL)
        s = g_strdup ("(no credentials received)");
    else
        s = g_credentials_to_string(credentials);


    LOG_DEBUG("Client connected.\n"
           "Peer credentials: %s\n"
           "Negotiated capabilities: unix-fd-passing=%d\n",
           s,
           g_dbus_connection_get_capabilities(connection) & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
    */

    g_object_ref(connection);

    gint registration_id = g_dbus_connection_register_object(connection,
                           R_DBUS_OBJECT_PATH,
                           g_introspection_data->interfaces[0],
                           &interface_vtable,
                           NULL,  /* user_data */
                           NULL,  /* user_data_free_func */
                           NULL); /* GError */

    return (registration_id > 0);
}


static gboolean dbus_service_start() {
    // Start DBus-server for this application.
    // This will receive method calls from external programs.

    // Build introspection data from XML
    g_introspection_data = g_dbus_node_info_new_for_xml(g_introspection_xml, NULL);

    // Server flags
    GDBusServerFlags server_flags = G_DBUS_SERVER_FLAGS_NONE;
    server_flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;

    gchar *guid = g_dbus_generate_guid();

    // Create a new D-Bus server that listens on R_DBUS_SERVER_ADDRESS
    GError *error = NULL;
    g_dbus_server = g_dbus_server_new_sync(R_DBUS_SERVER_ADDRESS,
                                           server_flags,
                                           guid,
                                           NULL, /* GDBusAuthObserver */
                                           NULL, /* GCancellable */
                                           &error);

    g_dbus_server_start(g_dbus_server);
    g_free(guid);

    if (g_dbus_server == NULL) {
        LOG_ERROR("Cannot create server address %s for DBus. %s\n", R_DBUS_SERVER_ADDRESS, error->message);
        g_error_free(error);
        return FALSE;
    }

    LOG_DEBUG("This Audio Recorder is listening on DBus at: %s\n", g_dbus_server_get_client_address(g_dbus_server));

    // Set up callback method (for client calls)
    g_signal_connect(g_dbus_server, "new-connection", G_CALLBACK (on_new_connection), NULL);

    return (g_dbus_server != NULL);
}

gchar *dbus_service_client_request(gchar *method_name, gchar *arg) {
    // Execute method call on the server.
    // Audio-recorder itself can call methods on the server.
    // DBus-server will most likely return a value. We will pass it to the calling function.

    GError *error = NULL;

    GDBusConnection *connection = g_dbus_connection_new_for_address_sync(R_DBUS_SERVER_ADDRESS,
                                  G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
                                  NULL, // GDBusAuthObserver
                                  NULL, // GCancellable
                                  &error);

    if (!connection) {
        LOG_DEBUG("Cannot connect to DBus address %s. %s\n", R_DBUS_SERVER_ADDRESS, error->message);
        g_error_free(error);
        return NULL;
    }

    // Optional argument
    GVariant *argument = NULL;
    if (arg) {
        argument = g_variant_new("(s)", arg);
    }

    GVariant *value = NULL;
    value = g_dbus_connection_call_sync(connection,
                                        NULL, // bus_name
                                        R_DBUS_OBJECT_PATH,
                                        R_DBUS_INTERFACE_NAME,
                                        method_name, // method_name
                                        argument, // input parm
                                        G_VARIANT_TYPE ("(s)"), // return value (one string)
                                        G_DBUS_CALL_FLAGS_NONE,
                                        -1,
                                        NULL,
                                        &error);

    if (!value) {
        LOG_ERROR("Error invoking %s(%s). %s\n", method_name, arg, error->message);
        g_error_free(error);
        g_object_unref(connection);
        return NULL;
    }

    gchar *server_response = NULL;
    g_variant_get(value, "(&s)", &server_response);

    // Take copy of the value
    gchar *ret = g_strdup(server_response);

    if (value) {
        g_variant_unref(value);
    }

    //Notice: "argument" is floating and consumed by g_dbus_connection_call_sync().
    //if (argument)
    //  g_variant_unref(argument);
    //}

    g_object_unref(connection);

    // Return ret
    return ret;
}