cras/src/server/cras_bt_player.c - platform/external/adhd - Git at Google

 /* Copyright 2016 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 <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <syslog.h>

 #include "cras_bt_adapter.h"
 #include "cras_bt_constants.h"
 #include "cras_bt_player.h"
 #include "cras_dbus_util.h"
 #include "cras_utf8.h"
 #include "utlist.h"

 static void cras_bt_on_player_registered(DBusPendingCall *pending_call,
 					 void *data)
 {
 	DBusMessage *reply;

 	reply = dbus_pending_call_steal_reply(pending_call);
 	dbus_pending_call_unref(pending_call);

 	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
 		syslog(LOG_ERR, "RegisterPlayer returned error: %s",
 		       dbus_message_get_error_name(reply));
 		dbus_message_unref(reply);
 		return;
 	}

 	dbus_message_unref(reply);
 }

 static int cras_bt_add_player(DBusConnection *conn,
 			      const struct cras_bt_adapter *adapter,
 			      struct cras_bt_player *player)
 {
 	const char *adapter_path;
 	DBusMessage *method_call;
 	DBusMessageIter message_iter, dict;
 	DBusPendingCall *pending_call;

 	adapter_path = cras_bt_adapter_object_path(adapter);
 	method_call = dbus_message_new_method_call(BLUEZ_SERVICE, adapter_path,
 						   BLUEZ_INTERFACE_MEDIA,
 						   "RegisterPlayer");
 	if (!method_call)
 		return -ENOMEM;

 	dbus_message_iter_init_append(method_call, &message_iter);
 	dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_OBJECT_PATH,
 				       &player->object_path);

 	dbus_message_iter_open_container(
 		&message_iter, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&dict);

 	append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &player->playback_status);
 	append_key_value(&dict, "Identity", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &player->identity);
 	append_key_value(&dict, "LoopStatus", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &player->loop_status);
 	append_key_value(&dict, "Position", DBUS_TYPE_INT64,
 			 DBUS_TYPE_INT64_AS_STRING, &player->position);
 	append_key_value(&dict, "Shuffle", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->shuffle);
 	append_key_value(&dict, "CanGoNext", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_go_next);
 	append_key_value(&dict, "CanGoPrevious", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_go_prev);
 	append_key_value(&dict, "CanPlay", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_play);
 	append_key_value(&dict, "CanPause", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_pause);
 	append_key_value(&dict, "CanControl", DBUS_TYPE_BOOLEAN,
 			 DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_control);

 	dbus_message_iter_close_container(&message_iter, &dict);

 	if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,
 					     DBUS_TIMEOUT_USE_DEFAULT)) {
 		dbus_message_unref(method_call);
 		return -ENOMEM;
 	}

 	dbus_message_unref(method_call);
 	if (!pending_call)
 		return -EIO;

 	if (!dbus_pending_call_set_notify(
 		    pending_call, cras_bt_on_player_registered, player, NULL)) {
 		dbus_pending_call_cancel(pending_call);
 		dbus_pending_call_unref(pending_call);
 		return -ENOMEM;
 	}
 	return 0;
 }

 /* Note that player properties will be used mostly for AVRCP qualification and
  * not for normal use cases. The corresponding media events won't be routed by
  * CRAS until we have a plan to provide general system API to handle media
  * control.
  */
 static struct cras_bt_player player = {
 	.object_path = CRAS_DEFAULT_PLAYER,
 	.playback_status = NULL,
 	.identity = NULL,
 	.loop_status = "None",
 	.shuffle = 0,
 	.metadata = NULL,
 	.position = 0,
 	.can_go_next = 0,
 	.can_go_prev = 0,
 	.can_play = 0,
 	.can_pause = 0,
 	.can_control = 0,
 	.message_cb = NULL,
 };

 static DBusHandlerResult cras_bt_player_handle_message(DBusConnection *conn,
 						       DBusMessage *message,
 						       void *arg)
 {
 	const char *msg = dbus_message_get_member(message);

 	if (player.message_cb)
 		player.message_cb(msg);

 	return DBUS_HANDLER_RESULT_HANDLED;
 }

 static struct cras_bt_player_metadata *cras_bt_player_metadata_init()
 {
 	struct cras_bt_player_metadata *metadata =
 		malloc(sizeof(struct cras_bt_player_metadata));
 	metadata->title = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
 	metadata->album = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
 	metadata->artist = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
 	metadata->length = 0;

 	return metadata;
 }

 static void cras_bt_player_init()
 {
 	player.playback_status = malloc(CRAS_PLAYER_PLAYBACK_STATUS_SIZE_MAX);
 	player.identity = malloc(CRAS_PLAYER_IDENTITY_SIZE_MAX);

 	strcpy(player.playback_status, CRAS_PLAYER_PLAYBACK_STATUS_DEFAULT);
 	strcpy(player.identity, CRAS_PLAYER_IDENTITY_DEFAULT);
 	player.position = 0;

 	player.metadata = cras_bt_player_metadata_init();
 }

 static void cras_bt_player_append_metadata_artist(DBusMessageIter *iter,
 						  const char *artist)
 {
 	DBusMessageIter dict, varient, array;
 	const char *artist_key = "xesam:artist";

 	dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL,
 					 &dict);
 	dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &artist_key);
 	dbus_message_iter_open_container(
 		&dict, DBUS_TYPE_VARIANT,
 		DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &varient);
 	dbus_message_iter_open_container(&varient, DBUS_TYPE_ARRAY,
 					 DBUS_TYPE_STRING_AS_STRING, &array);
 	dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &artist);
 	dbus_message_iter_close_container(&varient, &array);
 	dbus_message_iter_close_container(&dict, &varient);
 	dbus_message_iter_close_container(iter, &dict);
 }

 static void cras_bt_player_append_metadata(DBusMessageIter *iter,
 					   const char *title,
 					   const char *artist,
 					   const char *album,
 					   dbus_int64_t length)
 {
 	DBusMessageIter varient, array;
 	dbus_message_iter_open_container(
 		iter, DBUS_TYPE_VARIANT,
 		DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&varient);
 	dbus_message_iter_open_container(
 		&varient, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&array);
 	if (!is_utf8_string(title)) {
 		syslog(LOG_INFO, "Non-utf8 title: %s", title);
 		title = "";
 	}
 	if (!is_utf8_string(album)) {
 		syslog(LOG_INFO, "Non-utf8 album: %s", album);
 		album = "";
 	}
 	if (!is_utf8_string(artist)) {
 		syslog(LOG_INFO, "Non-utf8 artist: %s", artist);
 		artist = "";
 	}

 	append_key_value(&array, "xesam:title", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &title);
 	append_key_value(&array, "xesam:album", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &album);
 	append_key_value(&array, "mpris:length", DBUS_TYPE_INT64,
 			 DBUS_TYPE_INT64_AS_STRING, &length);
 	cras_bt_player_append_metadata_artist(&array, artist);

 	dbus_message_iter_close_container(&varient, &array);
 	dbus_message_iter_close_container(iter, &varient);
 }

 static bool cras_bt_player_parse_metadata(const char *title, const char *album,
 					  const char *artist,
 					  const dbus_int64_t length)
 {
 	bool require_update = false;

 	if (title && strcmp(player.metadata->title, title)) {
 		snprintf(player.metadata->title, CRAS_PLAYER_METADATA_SIZE_MAX,
 			 "%s", title);
 		require_update = true;
 	}
 	if (artist && strcmp(player.metadata->artist, artist)) {
 		snprintf(player.metadata->artist, CRAS_PLAYER_METADATA_SIZE_MAX,
 			 "%s", artist);
 		require_update = true;
 	}
 	if (album && strcmp(player.metadata->album, album)) {
 		snprintf(player.metadata->album, CRAS_PLAYER_METADATA_SIZE_MAX,
 			 "%s", album);
 		require_update = true;
 	}
 	if (length && player.metadata->length != length) {
 		player.metadata->length = length;
 		require_update = true;
 	}

 	return require_update;
 }

 int cras_bt_player_create(DBusConnection *conn)
 {
 	static const DBusObjectPathVTable player_vtable = {
 		.message_function = cras_bt_player_handle_message
 	};

 	DBusError dbus_error;
 	struct cras_bt_adapter **adapters;
 	size_t num_adapters, i;

 	dbus_error_init(&dbus_error);

 	cras_bt_player_init();
 	if (!dbus_connection_register_object_path(
 		    conn, player.object_path, &player_vtable, &dbus_error)) {
 		syslog(LOG_ERR, "Cannot register player %s",
 		       player.object_path);
 		dbus_error_free(&dbus_error);
 		return -ENOMEM;
 	}

 	num_adapters = cras_bt_adapter_get_list(&adapters);
 	for (i = 0; i < num_adapters; ++i)
 		cras_bt_add_player(conn, adapters[i], &player);
 	free(adapters);
 	return 0;
 }

 int cras_bt_register_player(DBusConnection *conn,
 			    const struct cras_bt_adapter *adapter)
 {
 	return cras_bt_add_player(conn, adapter, &player);
 }

 int cras_bt_player_update_playback_status(DBusConnection *conn,
 					  const char *status)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter, dict;
 	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

 	if (!player.playback_status)
 		return -ENXIO;

 	/* Verify the string value matches one of the possible status defined in
 	 * bluez/profiles/audio/avrcp.c
 	 */
 	if (strcasecmp(status, "stopped") != 0 &&
 	    strcasecmp(status, "playing") != 0 &&
 	    strcasecmp(status, "paused") != 0 &&
 	    strcasecmp(status, "forward-seek") != 0 &&
 	    strcasecmp(status, "reverse-seek") != 0 &&
 	    strcasecmp(status, "error") != 0)
 		return -EINVAL;

 	if (!strcasecmp(player.playback_status, status))
 		return 0;

 	strcpy(player.playback_status, status);

 	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
 				      DBUS_INTERFACE_PROPERTIES,
 				      "PropertiesChanged");
 	if (!msg)
 		return -ENOMEM;

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 				       &playerInterface);
 	dbus_message_iter_open_container(
 		&iter, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&dict);
 	append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &status);
 	dbus_message_iter_close_container(&iter, &dict);

 	if (!dbus_connection_send(conn, msg, NULL)) {
 		dbus_message_unref(msg);
 		return -ENOMEM;
 	}

 	dbus_message_unref(msg);
 	return 0;
 }

 int cras_bt_player_update_identity(DBusConnection *conn, const char *identity)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter, dict;
 	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

 	if (!player.identity)
 		return -ENXIO;

 	if (!identity)
 		return -EINVAL;

 	if (!is_utf8_string(identity)) {
 		syslog(LOG_INFO, "Non-utf8 identity: %s", identity);
 		identity = "";
 	}

 	if (!strcasecmp(player.identity, identity))
 		return 0;

 	strcpy(player.identity, identity);

 	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
 				      DBUS_INTERFACE_PROPERTIES,
 				      "PropertiesChanged");
 	if (!msg)
 		return -ENOMEM;

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 				       &playerInterface);
 	dbus_message_iter_open_container(
 		&iter, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&dict);
 	append_key_value(&dict, "Identity", DBUS_TYPE_STRING,
 			 DBUS_TYPE_STRING_AS_STRING, &identity);
 	dbus_message_iter_close_container(&iter, &dict);

 	if (!dbus_connection_send(conn, msg, NULL)) {
 		dbus_message_unref(msg);
 		return -ENOMEM;
 	}

 	dbus_message_unref(msg);
 	return 0;
 }

 int cras_bt_player_update_position(DBusConnection *conn,
 				   const dbus_int64_t position)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter, dict;
 	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

 	if (position < 0)
 		return -EINVAL;

 	player.position = position;

 	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
 				      DBUS_INTERFACE_PROPERTIES,
 				      "PropertiesChanged");
 	if (!msg)
 		return -ENOMEM;

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 				       &playerInterface);
 	dbus_message_iter_open_container(
 		&iter, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&dict);
 	append_key_value(&dict, "Position", DBUS_TYPE_INT64,
 			 DBUS_TYPE_INT64_AS_STRING, &player.position);
 	dbus_message_iter_close_container(&iter, &dict);

 	if (!dbus_connection_send(conn, msg, NULL)) {
 		dbus_message_unref(msg);
 		return -ENOMEM;
 	}

 	dbus_message_unref(msg);
 	return 0;
 }

 int cras_bt_player_update_metadata(DBusConnection *conn, const char *title,
 				   const char *artist, const char *album,
 				   const dbus_int64_t length)
 {
 	DBusMessage *msg;
 	DBusMessageIter iter, array, dict;
 	const char *property = "Metadata";
 	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

 	if (!player.metadata)
 		return -ENXIO;

 	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
 				      DBUS_INTERFACE_PROPERTIES,
 				      "PropertiesChanged");
 	if (!msg)
 		return -ENOMEM;

 	dbus_message_iter_init_append(msg, &iter);
 	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
 				       &playerInterface);
 	dbus_message_iter_open_container(
 		&iter, DBUS_TYPE_ARRAY,
 		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
 			DBUS_TYPE_VARIANT_AS_STRING
 				DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
 		&array);
 	dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL,
 					 &dict);
 	dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &property);

 	if (!cras_bt_player_parse_metadata(title, album, artist, length)) {
 		/* Nothing to update. */
 		dbus_message_unref(msg);
 		return 0;
 	}

 	cras_bt_player_append_metadata(&dict, player.metadata->title,
 				       player.metadata->artist,
 				       player.metadata->album,
 				       player.metadata->length);

 	dbus_message_iter_close_container(&array, &dict);
 	dbus_message_iter_close_container(&iter, &array);

 	if (!dbus_connection_send(conn, msg, NULL)) {
 		dbus_message_unref(msg);
 		return -ENOMEM;
 	}

 	dbus_message_unref(msg);
 	return 0;
 }
	/* Copyright 2016 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 <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <syslog.h>

	#include "cras_bt_adapter.h"
	#include "cras_bt_constants.h"
	#include "cras_bt_player.h"
	#include "cras_dbus_util.h"
	#include "cras_utf8.h"
	#include "utlist.h"

	static void cras_bt_on_player_registered(DBusPendingCall *pending_call,
	void *data)
	{
	DBusMessage *reply;

	reply = dbus_pending_call_steal_reply(pending_call);
	dbus_pending_call_unref(pending_call);

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
	syslog(LOG_ERR, "RegisterPlayer returned error: %s",
	dbus_message_get_error_name(reply));
	dbus_message_unref(reply);
	return;
	}

	dbus_message_unref(reply);
	}

	static int cras_bt_add_player(DBusConnection *conn,
	const struct cras_bt_adapter *adapter,
	struct cras_bt_player *player)
	{
	const char *adapter_path;
	DBusMessage *method_call;
	DBusMessageIter message_iter, dict;
	DBusPendingCall *pending_call;

	adapter_path = cras_bt_adapter_object_path(adapter);
	method_call = dbus_message_new_method_call(BLUEZ_SERVICE, adapter_path,
	BLUEZ_INTERFACE_MEDIA,
	"RegisterPlayer");
	if (!method_call)
	return -ENOMEM;

	dbus_message_iter_init_append(method_call, &message_iter);
	dbus_message_iter_append_basic(&message_iter, DBUS_TYPE_OBJECT_PATH,
	&player->object_path);

	dbus_message_iter_open_container(
	&message_iter, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&dict);

	append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &player->playback_status);
	append_key_value(&dict, "Identity", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &player->identity);
	append_key_value(&dict, "LoopStatus", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &player->loop_status);
	append_key_value(&dict, "Position", DBUS_TYPE_INT64,
	DBUS_TYPE_INT64_AS_STRING, &player->position);
	append_key_value(&dict, "Shuffle", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->shuffle);
	append_key_value(&dict, "CanGoNext", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_go_next);
	append_key_value(&dict, "CanGoPrevious", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_go_prev);
	append_key_value(&dict, "CanPlay", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_play);
	append_key_value(&dict, "CanPause", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_pause);
	append_key_value(&dict, "CanControl", DBUS_TYPE_BOOLEAN,
	DBUS_TYPE_BOOLEAN_AS_STRING, &player->can_control);

	dbus_message_iter_close_container(&message_iter, &dict);

	if (!dbus_connection_send_with_reply(conn, method_call, &pending_call,
	DBUS_TIMEOUT_USE_DEFAULT)) {
	dbus_message_unref(method_call);
	return -ENOMEM;
	}

	dbus_message_unref(method_call);
	if (!pending_call)
	return -EIO;

	if (!dbus_pending_call_set_notify(
	pending_call, cras_bt_on_player_registered, player, NULL)) {
	dbus_pending_call_cancel(pending_call);
	dbus_pending_call_unref(pending_call);
	return -ENOMEM;
	}
	return 0;
	}

	/* Note that player properties will be used mostly for AVRCP qualification and
	* not for normal use cases. The corresponding media events won't be routed by
	* CRAS until we have a plan to provide general system API to handle media
	* control.
	*/
	static struct cras_bt_player player = {
	.object_path = CRAS_DEFAULT_PLAYER,
	.playback_status = NULL,
	.identity = NULL,
	.loop_status = "None",
	.shuffle = 0,
	.metadata = NULL,
	.position = 0,
	.can_go_next = 0,
	.can_go_prev = 0,
	.can_play = 0,
	.can_pause = 0,
	.can_control = 0,
	.message_cb = NULL,
	};

	static DBusHandlerResult cras_bt_player_handle_message(DBusConnection *conn,
	DBusMessage *message,
	void *arg)
	{
	const char *msg = dbus_message_get_member(message);

	if (player.message_cb)
	player.message_cb(msg);

	return DBUS_HANDLER_RESULT_HANDLED;
	}

	static struct cras_bt_player_metadata *cras_bt_player_metadata_init()
	{
	struct cras_bt_player_metadata *metadata =
	malloc(sizeof(struct cras_bt_player_metadata));
	metadata->title = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
	metadata->album = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
	metadata->artist = calloc(1, CRAS_PLAYER_METADATA_SIZE_MAX);
	metadata->length = 0;

	return metadata;
	}

	static void cras_bt_player_init()
	{
	player.playback_status = malloc(CRAS_PLAYER_PLAYBACK_STATUS_SIZE_MAX);
	player.identity = malloc(CRAS_PLAYER_IDENTITY_SIZE_MAX);

	strcpy(player.playback_status, CRAS_PLAYER_PLAYBACK_STATUS_DEFAULT);
	strcpy(player.identity, CRAS_PLAYER_IDENTITY_DEFAULT);
	player.position = 0;

	player.metadata = cras_bt_player_metadata_init();
	}

	static void cras_bt_player_append_metadata_artist(DBusMessageIter *iter,
	const char *artist)
	{
	DBusMessageIter dict, varient, array;
	const char *artist_key = "xesam:artist";

	dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL,
	&dict);
	dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &artist_key);
	dbus_message_iter_open_container(
	&dict, DBUS_TYPE_VARIANT,
	DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING, &varient);
	dbus_message_iter_open_container(&varient, DBUS_TYPE_ARRAY,
	DBUS_TYPE_STRING_AS_STRING, &array);
	dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &artist);
	dbus_message_iter_close_container(&varient, &array);
	dbus_message_iter_close_container(&dict, &varient);
	dbus_message_iter_close_container(iter, &dict);
	}

	static void cras_bt_player_append_metadata(DBusMessageIter *iter,
	const char *title,
	const char *artist,
	const char *album,
	dbus_int64_t length)
	{
	DBusMessageIter varient, array;
	dbus_message_iter_open_container(
	iter, DBUS_TYPE_VARIANT,
	DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
	DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&varient);
	dbus_message_iter_open_container(
	&varient, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&array);
	if (!is_utf8_string(title)) {
	syslog(LOG_INFO, "Non-utf8 title: %s", title);
	title = "";
	}
	if (!is_utf8_string(album)) {
	syslog(LOG_INFO, "Non-utf8 album: %s", album);
	album = "";
	}
	if (!is_utf8_string(artist)) {
	syslog(LOG_INFO, "Non-utf8 artist: %s", artist);
	artist = "";
	}

	append_key_value(&array, "xesam:title", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &title);
	append_key_value(&array, "xesam:album", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &album);
	append_key_value(&array, "mpris:length", DBUS_TYPE_INT64,
	DBUS_TYPE_INT64_AS_STRING, &length);
	cras_bt_player_append_metadata_artist(&array, artist);

	dbus_message_iter_close_container(&varient, &array);
	dbus_message_iter_close_container(iter, &varient);
	}

	static bool cras_bt_player_parse_metadata(const char title, const char album,
	const char *artist,
	const dbus_int64_t length)
	{
	bool require_update = false;

	if (title && strcmp(player.metadata->title, title)) {
	snprintf(player.metadata->title, CRAS_PLAYER_METADATA_SIZE_MAX,
	"%s", title);
	require_update = true;
	}
	if (artist && strcmp(player.metadata->artist, artist)) {
	snprintf(player.metadata->artist, CRAS_PLAYER_METADATA_SIZE_MAX,
	"%s", artist);
	require_update = true;
	}
	if (album && strcmp(player.metadata->album, album)) {
	snprintf(player.metadata->album, CRAS_PLAYER_METADATA_SIZE_MAX,
	"%s", album);
	require_update = true;
	}
	if (length && player.metadata->length != length) {
	player.metadata->length = length;
	require_update = true;
	}

	return require_update;
	}

	int cras_bt_player_create(DBusConnection *conn)
	{
	static const DBusObjectPathVTable player_vtable = {
	.message_function = cras_bt_player_handle_message
	};

	DBusError dbus_error;
	struct cras_bt_adapter **adapters;
	size_t num_adapters, i;

	dbus_error_init(&dbus_error);

	cras_bt_player_init();
	if (!dbus_connection_register_object_path(
	conn, player.object_path, &player_vtable, &dbus_error)) {
	syslog(LOG_ERR, "Cannot register player %s",
	player.object_path);
	dbus_error_free(&dbus_error);
	return -ENOMEM;
	}

	num_adapters = cras_bt_adapter_get_list(&adapters);
	for (i = 0; i < num_adapters; ++i)
	cras_bt_add_player(conn, adapters[i], &player);
	free(adapters);
	return 0;
	}

	int cras_bt_register_player(DBusConnection *conn,
	const struct cras_bt_adapter *adapter)
	{
	return cras_bt_add_player(conn, adapter, &player);
	}

	int cras_bt_player_update_playback_status(DBusConnection *conn,
	const char *status)
	{
	DBusMessage *msg;
	DBusMessageIter iter, dict;
	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

	if (!player.playback_status)
	return -ENXIO;

	/* Verify the string value matches one of the possible status defined in
	* bluez/profiles/audio/avrcp.c
	*/
	if (strcasecmp(status, "stopped") != 0 &&
	strcasecmp(status, "playing") != 0 &&
	strcasecmp(status, "paused") != 0 &&
	strcasecmp(status, "forward-seek") != 0 &&
	strcasecmp(status, "reverse-seek") != 0 &&
	strcasecmp(status, "error") != 0)
	return -EINVAL;

	if (!strcasecmp(player.playback_status, status))
	return 0;

	strcpy(player.playback_status, status);

	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
	DBUS_INTERFACE_PROPERTIES,
	"PropertiesChanged");
	if (!msg)
	return -ENOMEM;

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
	&playerInterface);
	dbus_message_iter_open_container(
	&iter, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&dict);
	append_key_value(&dict, "PlaybackStatus", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &status);
	dbus_message_iter_close_container(&iter, &dict);

	if (!dbus_connection_send(conn, msg, NULL)) {
	dbus_message_unref(msg);
	return -ENOMEM;
	}

	dbus_message_unref(msg);
	return 0;
	}

	int cras_bt_player_update_identity(DBusConnection conn, const char identity)
	{
	DBusMessage *msg;
	DBusMessageIter iter, dict;
	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

	if (!player.identity)
	return -ENXIO;

	if (!identity)
	return -EINVAL;

	if (!is_utf8_string(identity)) {
	syslog(LOG_INFO, "Non-utf8 identity: %s", identity);
	identity = "";
	}

	if (!strcasecmp(player.identity, identity))
	return 0;

	strcpy(player.identity, identity);

	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
	DBUS_INTERFACE_PROPERTIES,
	"PropertiesChanged");
	if (!msg)
	return -ENOMEM;

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
	&playerInterface);
	dbus_message_iter_open_container(
	&iter, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&dict);
	append_key_value(&dict, "Identity", DBUS_TYPE_STRING,
	DBUS_TYPE_STRING_AS_STRING, &identity);
	dbus_message_iter_close_container(&iter, &dict);

	if (!dbus_connection_send(conn, msg, NULL)) {
	dbus_message_unref(msg);
	return -ENOMEM;
	}

	dbus_message_unref(msg);
	return 0;
	}

	int cras_bt_player_update_position(DBusConnection *conn,
	const dbus_int64_t position)
	{
	DBusMessage *msg;
	DBusMessageIter iter, dict;
	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

	if (position < 0)
	return -EINVAL;

	player.position = position;

	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
	DBUS_INTERFACE_PROPERTIES,
	"PropertiesChanged");
	if (!msg)
	return -ENOMEM;

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
	&playerInterface);
	dbus_message_iter_open_container(
	&iter, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&dict);
	append_key_value(&dict, "Position", DBUS_TYPE_INT64,
	DBUS_TYPE_INT64_AS_STRING, &player.position);
	dbus_message_iter_close_container(&iter, &dict);

	if (!dbus_connection_send(conn, msg, NULL)) {
	dbus_message_unref(msg);
	return -ENOMEM;
	}

	dbus_message_unref(msg);
	return 0;
	}

	int cras_bt_player_update_metadata(DBusConnection conn, const char title,
	const char artist, const char album,
	const dbus_int64_t length)
	{
	DBusMessage *msg;
	DBusMessageIter iter, array, dict;
	const char *property = "Metadata";
	const char *playerInterface = BLUEZ_INTERFACE_MEDIA_PLAYER;

	if (!player.metadata)
	return -ENXIO;

	msg = dbus_message_new_signal(CRAS_DEFAULT_PLAYER,
	DBUS_INTERFACE_PROPERTIES,
	"PropertiesChanged");
	if (!msg)
	return -ENOMEM;

	dbus_message_iter_init_append(msg, &iter);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
	&playerInterface);
	dbus_message_iter_open_container(
	&iter, DBUS_TYPE_ARRAY,
	DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING
	DBUS_TYPE_VARIANT_AS_STRING
	DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
	&array);
	dbus_message_iter_open_container(&array, DBUS_TYPE_DICT_ENTRY, NULL,
	&dict);
	dbus_message_iter_append_basic(&dict, DBUS_TYPE_STRING, &property);

	if (!cras_bt_player_parse_metadata(title, album, artist, length)) {
	/* Nothing to update. */
	dbus_message_unref(msg);
	return 0;
	}

	cras_bt_player_append_metadata(&dict, player.metadata->title,
	player.metadata->artist,
	player.metadata->album,
	player.metadata->length);

	dbus_message_iter_close_container(&array, &dict);
	dbus_message_iter_close_container(&iter, &array);

	if (!dbus_connection_send(conn, msg, NULL)) {
	dbus_message_unref(msg);
	return -ENOMEM;
	}

	dbus_message_unref(msg);
	return 0;
	}