/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <dbus/dbus.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include "audio_thread.h"
#include "cras_dbus.h"
#include "cras_dbus_control.h"
#include "cras_dbus_util.h"
#include "cras_iodev_list.h"
#include "cras_observer.h"
#include "cras_system_state.h"
#include "cras_util.h"
#include "utlist.h"
#define CRAS_CONTROL_INTERFACE "org.chromium.cras.Control"
#define CRAS_ROOT_OBJECT_PATH "/org/chromium/cras"
#define CONTROL_INTROSPECT_XML \
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
"<node>\n" \
" <interface name=\""CRAS_CONTROL_INTERFACE"\">\n" \
" <method name=\"SetOutputVolume\">\n" \
" <arg name=\"volume\" type=\"i\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetOutputNodeVolume\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" <arg name=\"volume\" type=\"i\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SwapLeftRight\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" <arg name=\"swap\" type=\"b\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetOutputMute\">\n" \
" <arg name=\"mute_on\" type=\"b\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetOutputUserMute\">\n" \
" <arg name=\"mute_on\" type=\"b\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetSuspendAudio\">\n" \
" <arg name=\"suspend\" type=\"b\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetInputGain\">\n" \
" <arg name=\"gain\" type=\"i\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetInputNodeGain\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" <arg name=\"gain\" type=\"i\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetInputMute\">\n" \
" <arg name=\"mute_on\" type=\"b\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"GetVolumeState\">\n" \
" <arg name=\"output_volume\" type=\"i\" direction=\"out\"/>\n"\
" <arg name=\"output_mute\" type=\"b\" direction=\"out\"/>\n" \
" <arg name=\"input_gain\" type=\"i\" direction=\"out\"/>\n" \
" <arg name=\"input_mute\" type=\"b\" direction=\"out\"/>\n" \
" <arg name=\"output_user_mute\" type=\"b\" direction=\"out\"/>\n"\
" </method>\n" \
" <method name=\"GetNodes\">\n" \
" <arg name=\"nodes\" type=\"a{sv}\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"SetActiveOutputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetActiveInputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"AddActiveInputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"AddActiveOutputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"RemoveActiveInputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"RemoveActiveOutputNode\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"GetNumberOfActiveStreams\">\n" \
" <arg name=\"num\" type=\"i\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"GetNumberOfActiveOutputStreams\">\n" \
" <arg name=\"num\" type=\"i\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"GetNumberOfActiveInputStreams\">\n" \
" <arg name=\"num\" type=\"i\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"SetGlobalOutputChannelRemix\">\n" \
" <arg name=\"num_channels\" type=\"i\" direction=\"in\"/>\n" \
" <arg name=\"coefficient\" type=\"ad\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"SetHotwordModel\">\n" \
" <arg name=\"node_id\" type=\"t\" direction=\"in\"/>\n" \
" <arg name=\"model_name\" type=\"s\" direction=\"in\"/>\n" \
" </method>\n" \
" </interface>\n" \
" <interface name=\"" DBUS_INTERFACE_INTROSPECTABLE "\">\n" \
" <method name=\"Introspect\">\n" \
" <arg name=\"data\" type=\"s\" direction=\"out\"/>\n" \
" </method>\n" \
" </interface>\n" \
"</node>\n"
struct cras_dbus_control {
DBusConnection *conn;
struct cras_observer_client *observer;
};
static struct cras_dbus_control dbus_control;
/* helper to extract a single argument from a DBus message. */
static int get_single_arg(DBusMessage *message, int dbus_type, void *arg)
{
DBusError dbus_error;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
dbus_type, arg,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING,
"Bad method received: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return 0;
}
/* Helper to send an empty reply. */
static void send_empty_reply(DBusConnection *conn, DBusMessage *message)
{
DBusMessage *reply;
dbus_uint32_t serial = 0;
reply = dbus_message_new_method_return(message);
if (!reply)
return;
dbus_connection_send(conn, reply, &serial);
dbus_message_unref(reply);
}
/* Helper to send an int32 reply. */
static void send_int32_reply(DBusConnection *conn,
DBusMessage *message,
dbus_int32_t value)
{
DBusMessage *reply;
dbus_uint32_t serial = 0;
reply = dbus_message_new_method_return(message);
if (!reply)
return;
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &value,
DBUS_TYPE_INVALID);
dbus_connection_send(conn, reply, &serial);
dbus_message_unref(reply);
}
/* Handlers for exported DBus method calls. */
static DBusHandlerResult handle_set_output_volume(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_int32_t new_vol;
rc = get_single_arg(message, DBUS_TYPE_INT32, &new_vol);
if (rc)
return rc;
cras_system_set_volume(new_vol);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_output_node_volume(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
dbus_int32_t new_vol;
cras_node_id_t id;
DBusError dbus_error;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
DBUS_TYPE_UINT64, &id,
DBUS_TYPE_INT32, &new_vol,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING,
"Bad method received: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
cras_iodev_list_set_node_attr(id, IONODE_ATTR_VOLUME, new_vol);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_swap_left_right(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
cras_node_id_t id;
dbus_bool_t swap;
DBusError dbus_error;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
DBUS_TYPE_UINT64, &id,
DBUS_TYPE_BOOLEAN, &swap,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING,
"Bad method received: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
cras_iodev_list_set_node_attr(id, IONODE_ATTR_SWAP_LEFT_RIGHT,
swap);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_output_mute(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_bool_t new_mute;
rc = get_single_arg(message, DBUS_TYPE_BOOLEAN, &new_mute);
if (rc)
return rc;
cras_system_set_mute(new_mute);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_output_user_mute(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_bool_t new_mute;
rc = get_single_arg(message, DBUS_TYPE_BOOLEAN, &new_mute);
if (rc)
return rc;
cras_system_set_user_mute(new_mute);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_suspend_audio(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_bool_t suspend;
rc = get_single_arg(message, DBUS_TYPE_BOOLEAN, &suspend);
if (rc)
return rc;
cras_system_set_suspended(suspend);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_input_gain(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_int32_t new_gain;
rc = get_single_arg(message, DBUS_TYPE_INT32, &new_gain);
if (rc)
return rc;
cras_system_set_capture_gain(new_gain);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_input_node_gain(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
dbus_int32_t new_gain;
cras_node_id_t id;
DBusError dbus_error;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
DBUS_TYPE_UINT64, &id,
DBUS_TYPE_INT32, &new_gain,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING,
"Bad method received: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
cras_iodev_list_set_node_attr(id, IONODE_ATTR_CAPTURE_GAIN, new_gain);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_input_mute(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
int rc;
dbus_bool_t new_mute;
rc = get_single_arg(message, DBUS_TYPE_BOOLEAN, &new_mute);
if (rc)
return rc;
cras_system_set_capture_mute(new_mute);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_get_volume_state(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
DBusMessage *reply;
dbus_uint32_t serial = 0;
dbus_int32_t volume;
dbus_bool_t system_muted;
dbus_bool_t user_muted;
dbus_int32_t capture_gain;
dbus_bool_t capture_muted;
reply = dbus_message_new_method_return(message);
volume = cras_system_get_volume();
system_muted = cras_system_get_system_mute();
user_muted = cras_system_get_user_mute();
capture_gain = cras_system_get_capture_gain();
capture_muted = cras_system_get_capture_mute();
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &volume,
DBUS_TYPE_BOOLEAN, &system_muted,
DBUS_TYPE_INT32, &capture_gain,
DBUS_TYPE_BOOLEAN, &capture_muted,
DBUS_TYPE_BOOLEAN, &user_muted,
DBUS_TYPE_INVALID);
dbus_connection_send(conn, reply, &serial);
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* Appends the information about a node to the dbus message. Returns
* false if not enough memory. */
static dbus_bool_t append_node_dict(DBusMessageIter *iter,
const struct cras_iodev_info *dev,
const struct cras_ionode_info *node,
enum CRAS_STREAM_DIRECTION direction)
{
DBusMessageIter dict;
dbus_bool_t is_input;
dbus_uint64_t id;
const char *dev_name = dev->name;
dbus_uint64_t stable_dev_id = node->stable_id;
dbus_uint64_t stable_dev_id_new = node->stable_id_new;
const char *node_type = node->type;
const char *node_name = node->name;
const char *mic_positions = node->mic_positions;
dbus_bool_t active;
dbus_uint64_t plugged_time = node->plugged_time.tv_sec * 1000000ULL +
node->plugged_time.tv_usec;
dbus_uint64_t node_volume = node->volume;
dbus_int64_t node_capture_gain = node->capture_gain;
char *models, *empty_models = "";
is_input = (direction == CRAS_STREAM_INPUT);
id = node->iodev_idx;
id = (id << 32) | node->ionode_idx;
active = !!node->active;
if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}",
&dict))
return FALSE;
if (!append_key_value(&dict, "IsInput", DBUS_TYPE_BOOLEAN,
DBUS_TYPE_BOOLEAN_AS_STRING, &is_input))
return FALSE;
if (!append_key_value(&dict, "Id", DBUS_TYPE_UINT64,
DBUS_TYPE_UINT64_AS_STRING, &id))
return FALSE;
if (!append_key_value(&dict, "DeviceName", DBUS_TYPE_STRING,
DBUS_TYPE_STRING_AS_STRING, &dev_name))
return FALSE;
if (!append_key_value(&dict, "StableDeviceId", DBUS_TYPE_UINT64,
DBUS_TYPE_UINT64_AS_STRING, &stable_dev_id))
return FALSE;
if (!append_key_value(&dict, "StableDeviceIdNew", DBUS_TYPE_UINT64,
DBUS_TYPE_UINT64_AS_STRING, &stable_dev_id_new))
return FALSE;
if (!append_key_value(&dict, "Type", DBUS_TYPE_STRING,
DBUS_TYPE_STRING_AS_STRING, &node_type))
return FALSE;
if (!append_key_value(&dict, "Name", DBUS_TYPE_STRING,
DBUS_TYPE_STRING_AS_STRING, &node_name))
return FALSE;
if (!append_key_value(&dict, "MicPositions", DBUS_TYPE_STRING,
DBUS_TYPE_STRING_AS_STRING, &mic_positions))
return FALSE;
if (!append_key_value(&dict, "Active", DBUS_TYPE_BOOLEAN,
DBUS_TYPE_BOOLEAN_AS_STRING, &active))
return FALSE;
if (!append_key_value(&dict, "PluggedTime", DBUS_TYPE_UINT64,
DBUS_TYPE_UINT64_AS_STRING, &plugged_time))
return FALSE;
if (!append_key_value(&dict, "NodeVolume", DBUS_TYPE_UINT64,
DBUS_TYPE_UINT64_AS_STRING, &node_volume))
return FALSE;
if (!append_key_value(&dict, "NodeCaptureGain", DBUS_TYPE_INT64,
DBUS_TYPE_INT64_AS_STRING, &node_capture_gain))
return FALSE;
models = cras_iodev_list_get_hotword_models(id);
if (!append_key_value(&dict, "HotwordModels", DBUS_TYPE_STRING,
DBUS_TYPE_STRING_AS_STRING,
models ? &models : &empty_models)) {
free(models);
return FALSE;
}
free(models);
if (!dbus_message_iter_close_container(iter, &dict))
return FALSE;
return TRUE;
}
/* Appends the information about all nodes in a given direction. Returns false
* if not enough memory. */
static dbus_bool_t append_nodes(enum CRAS_STREAM_DIRECTION direction,
DBusMessageIter *array)
{
const struct cras_iodev_info *devs;
const struct cras_ionode_info *nodes;
int ndevs, nnodes;
int i, j;
if (direction == CRAS_STREAM_OUTPUT) {
ndevs = cras_system_state_get_output_devs(&devs);
nnodes = cras_system_state_get_output_nodes(&nodes);
} else {
ndevs = cras_system_state_get_input_devs(&devs);
nnodes = cras_system_state_get_input_nodes(&nodes);
}
for (i = 0; i < nnodes; i++) {
/* Don't reply unplugged nodes. */
if (!nodes[i].plugged)
continue;
/* Find the device for this node. */
for (j = 0; j < ndevs; j++)
if (devs[j].idx == nodes[i].iodev_idx)
break;
if (j == ndevs)
continue;
/* Send information about this node. */
if (!append_node_dict(array, &devs[j], &nodes[i], direction))
return FALSE;
}
return TRUE;
}
static DBusHandlerResult handle_get_nodes(DBusConnection *conn,
DBusMessage *message,
void *arg)
{
DBusMessage *reply;
DBusMessageIter array;
dbus_uint32_t serial = 0;
reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(reply, &array);
if (!append_nodes(CRAS_STREAM_OUTPUT, &array))
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (!append_nodes(CRAS_STREAM_INPUT, &array))
return DBUS_HANDLER_RESULT_NEED_MEMORY;
dbus_connection_send(conn, reply, &serial);
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
handle_set_active_node(DBusConnection *conn,
DBusMessage *message,
void *arg,
enum CRAS_STREAM_DIRECTION direction)
{
int rc;
cras_node_id_t id;
rc = get_single_arg(message, DBUS_TYPE_UINT64, &id);
if (rc)
return rc;
cras_iodev_list_select_node(direction, id);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
handle_add_active_node(DBusConnection *conn,
DBusMessage *message,
void *arg,
enum CRAS_STREAM_DIRECTION direction)
{
int rc;
cras_node_id_t id;
rc = get_single_arg(message, DBUS_TYPE_UINT64, &id);
if (rc)
return rc;
cras_iodev_list_add_active_node(direction, id);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
handle_rm_active_node(DBusConnection *conn,
DBusMessage *message,
void *arg,
enum CRAS_STREAM_DIRECTION direction)
{
int rc;
cras_node_id_t id;
rc = get_single_arg(message, DBUS_TYPE_UINT64, &id);
if (rc)
return rc;
cras_iodev_list_rm_active_node(direction, id);
send_empty_reply(conn, message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_get_num_active_streams(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
send_int32_reply(conn, message, cras_system_state_get_active_streams());
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_get_num_active_streams_use_input_hw(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
dbus_int32_t num = 0;
unsigned i;
for (i = 0; i < CRAS_NUM_DIRECTIONS; i++) {
if (cras_stream_uses_input_hw(i))
num += cras_system_state_get_active_streams_by_direction(i);
}
send_int32_reply(conn, message, num);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_get_num_active_streams_use_output_hw(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
dbus_int32_t num = 0;
unsigned i;
for (i = 0; i < CRAS_NUM_DIRECTIONS; i++) {
if (cras_stream_uses_output_hw(i))
num += cras_system_state_get_active_streams_by_direction(i);
}
send_int32_reply(conn, message, num);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_global_output_channel_remix(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
dbus_int32_t num_channels;
double *coeff_array;
dbus_int32_t count;
DBusError dbus_error;
float *coefficient;
int i;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
DBUS_TYPE_INT32, &num_channels,
DBUS_TYPE_ARRAY,
DBUS_TYPE_DOUBLE, &coeff_array, &count,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING, "Set global output channel remix error: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
coefficient = (float *)calloc(count, sizeof(*coefficient));
if (!coefficient)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
for (i = 0; i < count; i++)
coefficient[i] = coeff_array[i];
audio_thread_config_global_remix(
cras_iodev_list_get_audio_thread(),
num_channels,
coefficient);
send_empty_reply(conn, message);
free(coefficient);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult handle_set_hotword_model(
DBusConnection *conn,
DBusMessage *message,
void *arg)
{
cras_node_id_t id;
const char *model_name;
DBusError dbus_error;
dbus_int32_t ret;
dbus_error_init(&dbus_error);
if (!dbus_message_get_args(message, &dbus_error,
DBUS_TYPE_UINT64, &id,
DBUS_TYPE_STRING, &model_name,
DBUS_TYPE_INVALID)) {
syslog(LOG_WARNING,
"Bad method received: %s",
dbus_error.message);
dbus_error_free(&dbus_error);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
ret = cras_iodev_list_set_hotword_model(id, model_name);
send_int32_reply(conn, message, ret);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* Handle incoming messages. */
static DBusHandlerResult handle_control_message(DBusConnection *conn,
DBusMessage *message,
void *arg)
{
syslog(LOG_DEBUG, "Control message: %s %s %s",
dbus_message_get_path(message),
dbus_message_get_interface(message),
dbus_message_get_member(message));
if (dbus_message_is_method_call(message,
DBUS_INTERFACE_INTROSPECTABLE,
"Introspect")) {
DBusMessage *reply;
const char *xml = CONTROL_INTROSPECT_XML;
reply = dbus_message_new_method_return(message);
if (!reply)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (!dbus_message_append_args(reply,
DBUS_TYPE_STRING, &xml,
DBUS_TYPE_INVALID))
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (!dbus_connection_send(conn, reply, NULL))
return DBUS_HANDLER_RESULT_NEED_MEMORY;
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetOutputVolume")) {
return handle_set_output_volume(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetOutputNodeVolume")) {
return handle_set_output_node_volume(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SwapLeftRight")) {
return handle_swap_left_right(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetOutputMute")) {
return handle_set_output_mute(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetOutputUserMute")) {
return handle_set_output_user_mute(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetSuspendAudio")) {
return handle_set_suspend_audio(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetInputGain")) {
return handle_set_input_gain(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetInputNodeGain")) {
return handle_set_input_node_gain(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetInputMute")) {
return handle_set_input_mute(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"GetVolumeState")) {
return handle_get_volume_state(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"GetNodes")) {
return handle_get_nodes(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetActiveOutputNode")) {
return handle_set_active_node(conn, message, arg,
CRAS_STREAM_OUTPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetActiveInputNode")) {
return handle_set_active_node(conn, message, arg,
CRAS_STREAM_INPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"AddActiveInputNode")) {
return handle_add_active_node(conn, message, arg,
CRAS_STREAM_INPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"AddActiveOutputNode")) {
return handle_add_active_node(conn, message, arg,
CRAS_STREAM_OUTPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"RemoveActiveInputNode")) {
return handle_rm_active_node(conn, message, arg,
CRAS_STREAM_INPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"RemoveActiveOutputNode")) {
return handle_rm_active_node(conn, message, arg,
CRAS_STREAM_OUTPUT);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"GetNumberOfActiveStreams")) {
return handle_get_num_active_streams(conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"GetNumberOfActiveInputStreams")) {
return handle_get_num_active_streams_use_input_hw(
conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"GetNumberOfActiveOutputStreams")) {
return handle_get_num_active_streams_use_output_hw(
conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetGlobalOutputChannelRemix")) {
return handle_set_global_output_channel_remix(
conn, message, arg);
} else if (dbus_message_is_method_call(message,
CRAS_CONTROL_INTERFACE,
"SetHotwordModel")) {
return handle_set_hotword_model(conn, message, arg);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/* Creates a new DBus message, must be freed with dbus_message_unref. */
static DBusMessage *create_dbus_message(const char *name)
{
DBusMessage *msg;
msg = dbus_message_new_signal(CRAS_ROOT_OBJECT_PATH,
CRAS_CONTROL_INTERFACE,
name);
if (!msg)
syslog(LOG_ERR, "Failed to create signal");
return msg;
}
/* Handlers for system updates that generate DBus signals. */
static void signal_output_volume(void *context, int32_t volume)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("OutputVolumeChanged");
if (!msg)
return;
volume = cras_system_get_volume();
dbus_message_append_args(msg,
DBUS_TYPE_INT32, &volume,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_output_mute(void *context, int muted, int user_muted,
int mute_locked)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("OutputMuteChanged");
if (!msg)
return;
muted = cras_system_get_system_mute();
user_muted = cras_system_get_user_mute();
dbus_message_append_args(msg,
DBUS_TYPE_BOOLEAN, &muted,
DBUS_TYPE_BOOLEAN, &user_muted,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_capture_gain(void *context, int32_t gain)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("InputGainChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_INT32, &gain,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_capture_mute(void *context, int muted, int mute_locked)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("InputMuteChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_BOOLEAN, &muted,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_nodes_changed(void *context)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("NodesChanged");
if (!msg)
return;
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_active_node_changed(void *context,
enum CRAS_STREAM_DIRECTION dir,
cras_node_id_t node_id)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
DBusMessage *msg;
dbus_uint32_t serial = 0;
msg = create_dbus_message((dir == CRAS_STREAM_OUTPUT)
? "ActiveOutputNodeChanged"
: "ActiveInputNodeChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_UINT64, &node_id,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
/* Called by iodev_list when a node volume changes. */
static void signal_node_volume_changed(void *context,
cras_node_id_t node_id,
int32_t volume)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("OutputNodeVolumeChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_UINT64, &node_id,
DBUS_TYPE_INT32, &volume,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_node_capture_gain_changed(void *context,
cras_node_id_t node_id,
int capture_gain)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("InputNodeGainChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_UINT64, &node_id,
DBUS_TYPE_INT32, &capture_gain,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_node_left_right_swapped_changed(void *context,
cras_node_id_t node_id,
int swapped)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
msg = create_dbus_message("NodeLeftRightSwappedChanged");
if (!msg)
return;
dbus_message_append_args(msg,
DBUS_TYPE_UINT64, &node_id,
DBUS_TYPE_BOOLEAN, &swapped,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
static void signal_num_active_streams_changed(void *context,
enum CRAS_STREAM_DIRECTION dir,
uint32_t num_active_streams)
{
struct cras_dbus_control *control = (struct cras_dbus_control *)context;
dbus_uint32_t serial = 0;
DBusMessage *msg;
dbus_int32_t num;
msg = create_dbus_message("NumberOfActiveStreamsChanged");
if (!msg)
return;
num = cras_system_state_get_active_streams();
dbus_message_append_args(msg,
DBUS_TYPE_INT32, &num,
DBUS_TYPE_INVALID);
dbus_connection_send(control->conn, msg, &serial);
dbus_message_unref(msg);
}
/* Exported Interface */
void cras_dbus_control_start(DBusConnection *conn)
{
static const DBusObjectPathVTable control_vtable = {
.message_function = handle_control_message,
};
DBusError dbus_error;
struct cras_observer_ops observer_ops;
dbus_control.conn = conn;
dbus_connection_ref(dbus_control.conn);
if (!dbus_connection_register_object_path(conn,
CRAS_ROOT_OBJECT_PATH,
&control_vtable,
&dbus_error)) {
syslog(LOG_WARNING,
"Couldn't register CRAS control: %s: %s",
CRAS_ROOT_OBJECT_PATH, dbus_error.message);
dbus_error_free(&dbus_error);
return;
}
memset(&observer_ops, 0, sizeof(observer_ops));
observer_ops.output_volume_changed = signal_output_volume;
observer_ops.output_mute_changed = signal_output_mute;
observer_ops.capture_gain_changed = signal_capture_gain;
observer_ops.capture_mute_changed = signal_capture_mute;
observer_ops.num_active_streams_changed =
signal_num_active_streams_changed;
observer_ops.nodes_changed = signal_nodes_changed;
observer_ops.active_node_changed = signal_active_node_changed;
observer_ops.input_node_gain_changed = signal_node_capture_gain_changed;
observer_ops.output_node_volume_changed = signal_node_volume_changed;
observer_ops.node_left_right_swapped_changed =
signal_node_left_right_swapped_changed;
dbus_control.observer = cras_observer_add(&observer_ops, &dbus_control);
}
void cras_dbus_control_stop()
{
if (!dbus_control.conn)
return;
dbus_connection_unregister_object_path(dbus_control.conn,
CRAS_ROOT_OBJECT_PATH);
dbus_connection_unref(dbus_control.conn);
dbus_control.conn = NULL;
cras_observer_remove(dbus_control.observer);
dbus_control.observer = NULL;
}