自学教程：C++ GDBUS_METHOD函数代码示例

}static gboolean control_property_get_connected(					const GDBusPropertyTable *property,					DBusMessageIter *iter, void *data){	struct control *control = data;	dbus_bool_t value = (control->session != NULL);	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &value);	return TRUE;}static const GDBusMethodTable control_methods[] = {	{ GDBUS_METHOD("Play", NULL, NULL, control_play) },	{ GDBUS_METHOD("Pause", NULL, NULL, control_pause) },	{ GDBUS_METHOD("Stop", NULL, NULL, control_stop) },	{ GDBUS_METHOD("Next", NULL, NULL, control_next) },	{ GDBUS_METHOD("Previous", NULL, NULL, control_previous) },	{ GDBUS_METHOD("VolumeUp", NULL, NULL, control_volume_up) },	{ GDBUS_METHOD("VolumeDown", NULL, NULL, control_volume_down) },	{ GDBUS_METHOD("FastForward", NULL, NULL, control_fast_forward) },	{ GDBUS_METHOD("Rewind", NULL, NULL, control_rewind) },	{ }};static const GDBusPropertyTable control_properties[] = {	{ "Connected", "b", control_property_get_connected },	{ }};

			set_online(modem, FALSE);			modem_change_state(modem, MODEM_STATE_POWER_OFF);		}		return NULL;	}	if (g_str_equal(name, "Lockdown"))		return set_property_lockdown(modem, msg, &var);	return __ofono_error_invalid_args(msg);}static const GDBusMethodTable modem_methods[] = {	{ GDBUS_METHOD("GetProperties",			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),			modem_get_properties) },	{ GDBUS_ASYNC_METHOD("SetProperty",			GDBUS_ARGS({ "property", "s" }, { "value", "v" }),			NULL, modem_set_property) },	{ }};static const GDBusSignalTable modem_signals[] = {	{ GDBUS_SIGNAL("PropertyChanged",			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },	{ }};void ofono_modem_set_powered(struct ofono_modem *modem, ofono_bool_t powered){

		return btd_error_does_not_exist(msg);	hradapter->watchers = g_slist_remove(hradapter->watchers, watcher);	g_dbus_remove_watch(conn, watcher->id);	if (g_slist_length(hradapter->watchers) == 0)		g_slist_foreach(hradapter->devices, disable_measurement, 0);	DBG("heartrate watcher [%s] unregistered", path);	return dbus_message_new_method_return(msg);}static const GDBusMethodTable heartrate_manager_methods[] = {	{ GDBUS_METHOD("RegisterWatcher",			GDBUS_ARGS({ "agent", "o" }), NULL,			register_watcher) },	{ GDBUS_METHOD("UnregisterWatcher",			GDBUS_ARGS({ "agent", "o" }), NULL,			unregister_watcher) },	{ }};static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg,								void *data){	struct heartrate *hr = data;	DBusMessageIter iter;	DBusMessageIter dict;	DBusMessage *reply;	gboolean has_reset;

	g_dbus_unregister_interface(conn, AD_PATH, AD_IFACE);}static DBusMessage *release_advertising(DBusConnection *conn,					DBusMessage *msg, void *user_data){	rl_printf("Advertising released/n");	ad_release(conn);	return dbus_message_new_method_return(msg);}static const GDBusMethodTable ad_methods[] = {	{ GDBUS_METHOD("Release", NULL, NULL, release_advertising) },	{ }};static void register_setup(DBusMessageIter *iter, void *user_data){	DBusMessageIter dict;	const char *path = AD_PATH;	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);	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);	dbus_message_iter_close_container(iter, &dict);

	return dbus_message_new_method_return(msg);error:	return g_dbus_create_error(msg,			BLUEZ_ERROR_INTERFACE ".Rejected",			"Invalid arguments in method call");}static const GDBusMethodTable profile_methods[] = {	{ GDBUS_ASYNC_METHOD("NewConnection",				GDBUS_ARGS({ "device", "o"}, { "fd", "h"},						{ "fd_properties", "a{sv}" }),				NULL, profile_new_connection) },	{ GDBUS_NOREPLY_METHOD("Release", NULL, NULL, profile_release) },	{ GDBUS_METHOD("RequestDisconnection",				GDBUS_ARGS({"device", "o"}), NULL,				profile_disconnection) },	{ }};static void connect_handler(DBusConnection *conn, void *user_data){	uint16_t features = HFP_SDP_HF_FEATURE_ECNR |				HFP_SDP_HF_FEATURE_3WAY |				HFP_SDP_HF_FEATURE_CLIP |				HFP_SDP_HF_FEATURE_REMOTE_VOLUME_CONTROL;	/*	 * Assuming that if defer_setup is supported, then SCO transparent	 * mode is also supported	*/

	if (err < 0)		return __connman_error_failed(msg, -err);	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable manager_methods[] = {	{ GDBUS_ASYNC_METHOD("Create",			GDBUS_ARGS({ "properties", "a{sv}" }),			GDBUS_ARGS({ "path", "o" }),			create) },	{ GDBUS_ASYNC_METHOD("Remove",			GDBUS_ARGS({ "identifier", "o" }), NULL,			remove) },	{ GDBUS_METHOD("GetConnections", NULL,			GDBUS_ARGS({ "connections", "a(oa{sv})" }),			get_connections) },	{ GDBUS_METHOD("RegisterAgent",			GDBUS_ARGS({ "path", "o" }), NULL,			register_agent) },	{ GDBUS_METHOD("UnregisterAgent",			GDBUS_ARGS({ "path", "o" }), NULL,			unregister_agent) },	{ },};static const GDBusSignalTable manager_signals[] = {	{ GDBUS_SIGNAL("ConnectionAdded",			GDBUS_ARGS({ "identifier", "o" },				{ "properties", "a{sv}" })) },	{ GDBUS_SIGNAL("ConnectionRemoved",

	dbus_message_ref(message);	return NULL;fail:	reply = g_dbus_create_error(message,					"org.openobex.Error.Failed",					"%s", gerr->message);	g_error_free(gerr);	return reply;}static const GDBusMethodTable session_methods[] = {	{ GDBUS_METHOD("GetProperties",				NULL, GDBUS_ARGS({ "properties", "a{sv}" }),				session_get_properties) },	{ GDBUS_ASYNC_METHOD("GetCapabilities",				NULL, GDBUS_ARGS({ "capabilities", "s" }),				get_capabilities) },	{ }};static gboolean session_queue_complete(gpointer data){	struct obc_session *session = data;	session_process_queue(session);	session->queue_complete_id = 0;

	if (hf->pending)		return __ofono_error_busy(msg);	if (!hf->driver->request_phone_number)		return __ofono_error_not_supported(msg);	hf->pending = dbus_message_ref(msg);	hf->driver->request_phone_number(hf, request_phone_number_cb, hf);	return NULL;}static const GDBusMethodTable handsfree_methods[] = {	{ GDBUS_METHOD("GetProperties",			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),			handsfree_get_properties) },	{ GDBUS_ASYNC_METHOD("SetProperty",			GDBUS_ARGS({ "property", "s" }, { "value", "v" }),			NULL, handsfree_set_property) },	{ GDBUS_ASYNC_METHOD("RequestPhoneNumber",			NULL, GDBUS_ARGS({ "number", "s" }),			handsfree_request_phone_number) },	{ }};static const GDBusSignalTable handsfree_signals[] = {	{ GDBUS_SIGNAL("PropertyChanged",			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },	{ }};

}static gboolean transfer_get_transferred(const GDBusPropertyTable *property,					DBusMessageIter *iter, void *data){	struct obex_transfer *transfer = data;	struct obex_session *session = transfer->session;	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64,							&session->offset);	return TRUE;}static const GDBusMethodTable manager_methods[] = {	{ GDBUS_METHOD("RegisterAgent",			GDBUS_ARGS({ "agent", "o" }), NULL, register_agent) },	{ GDBUS_METHOD("UnregisterAgent",			GDBUS_ARGS({ "agent", "o" }), NULL, unregister_agent) },	{ }};static const GDBusMethodTable transfer_methods[] = {	{ GDBUS_METHOD("Cancel", NULL, NULL, transfer_cancel) },	{ }};static const GDBusPropertyTable transfer_properties[] = {	{ "Status", "s", transfer_get_status },	{ "Session", "o", transfer_get_session },	{ "Name", "s", transfer_get_name, NULL, transfer_name_exists },	{ "Type", "s", transfer_get_type, NULL, transfer_type_exists },

	info->chat = NULL;	return dbus_message_new_method_return(msg);error:	return g_dbus_create_error(msg,			BLUEZ_ERROR_INTERFACE ".Rejected",			"Invalid arguments in method call");}static const GDBusMethodTable profile_methods[] = {	{ GDBUS_ASYNC_METHOD("NewConnection",				GDBUS_ARGS({ "device", "o"}, { "fd", "h"},						{ "fd_properties", "a{sv}" }),				NULL, profile_new_connection) },	{ GDBUS_METHOD("Release", NULL, NULL, profile_release) },	{ GDBUS_METHOD("Cancel", NULL, NULL, profile_cancel) },	{ GDBUS_METHOD("RequestDisconnection",				GDBUS_ARGS({"device", "o"}), NULL,				profile_disconnection) },	{ }};static void connect_handler(DBusConnection *conn, void *user_data){	DBG("Registering External Profile handler ...");	bt_register_profile(conn, HFP_HS_UUID, HFP_VERSION_1_6, "hfp_hf",						HFP_EXT_PROFILE_PATH);}

					"Invalid signature for '%s'", name);	propdata = g_new(struct property_data, 1);	propdata->id = next_pending_property++;	propdata->message = dbus_message_ref(message);	propdata->conn = connection;	pending_property_set = g_slist_prepend(pending_property_set, propdata);	property->set(property, &sub, propdata->id, iface->user_data);	return NULL;}static const GDBusMethodTable properties_methods[] = {	{ GDBUS_METHOD("Get",			GDBUS_ARGS({ "interface", "s" }, { "name", "s" }),			GDBUS_ARGS({ "value", "v" }),			properties_get) },	{ GDBUS_ASYNC_METHOD("Set",			GDBUS_ARGS({ "interface", "s" }, { "name", "s" },							{ "value", "v" }),			NULL,			properties_set) },	{ GDBUS_METHOD("GetAll",			GDBUS_ARGS({ "interface", "s" }),			GDBUS_ARGS({ "properties", "a{sv}" }),			properties_get_all) },	{ }};static const GDBusSignalTable properties_signals[] = {	{ GDBUS_SIGNAL("PropertiesChanged",

			void *data){	set_status(property, iter, id, STATUS_READ, data);}static void set_deleted(const GDBusPropertyTable *property,			DBusMessageIter *iter, GDBusPendingPropertySet id,			void *data){	set_status(property, iter, id, STATUS_DELETE, data);}static const GDBusMethodTable map_msg_methods[] = {	{ GDBUS_METHOD("Get",			GDBUS_ARGS({ "targetfile", "s" },						{ "attachment", "b" }),			GDBUS_ARGS({ "transfer", "o" },						{ "properties", "a{sv}" }),			map_msg_get) },	{ }};static const GDBusPropertyTable map_msg_properties[] = {	{ "Subject", "s", get_subject, NULL, subject_exists },	{ "Timestamp", "s", get_timestamp, NULL, timestamp_exists },	{ "Sender", "s", get_sender, NULL, sender_exists },	{ "SenderAddress", "s", get_sender_address, NULL,						sender_address_exists },	{ "ReplyTo", "s", get_replyto, NULL, replyto_exists },	{ "Recipient", "s", get_recipient, NULL, recipient_exists },	{ "RecipientAddress", "s", get_recipient_address, NULL,						recipient_address_exists },

	DBG("%s", mgr->sender);	if (strncmp(sender, mgr->sender, strlen(mgr->sender)))		return error_permission_denied(msg);	/* remove it */	near_p2p_unregister(mgr->p2p_driver);	g_hash_table_remove(mgr_list, mgr->p2p_driver->service_name);	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable phdc_methods[] = {	{ GDBUS_METHOD("RegisterAgent",			GDBUS_ARGS({"", "a{sv}"}),			NULL, dbus_register_phdc_agent) },{ GDBUS_METHOD("UnregisterAgent",			GDBUS_ARGS({ "path", "o" }, { "type", "s"}),			NULL, dbus_unregister_phdc_agent) },	{ },};/* Initialize the PHDC plugin - Expose our dbus entry points */int phdc_init(void){	gboolean err;	DBG("");

			break;		default:			g_assert(FALSE);			return __connman_error_invalid_arguments(msg);		}		dbus_message_iter_next(&array);	}	if (session->notify != NULL)		session->notify(session);	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable notify_methods[] = {	{ GDBUS_METHOD("Release", NULL, NULL, notify_release) },	{ GDBUS_METHOD("Update",			GDBUS_ARGS({ "settings", "a{sv}" }), NULL,			notify_update) },	{ },};int session_notify_register(struct test_session *session,				const char *notify_path){	if (g_dbus_register_interface(session->connection, notify_path,			CONNMAN_NOTIFICATION_INTERFACE,			notify_methods, NULL, NULL,			session, NULL) == FALSE) {		return -EINVAL;	}

}static DBusMessage *cancel_request(DBusConnection *conn,					DBusMessage *msg, void *user_data){	bt_shell_printf("Request canceled/n");	agent_release_prompt();	dbus_message_unref(pending_message);	pending_message = NULL;	return dbus_message_new_method_return(msg);}static const GDBusMethodTable methods[] = {	{ GDBUS_METHOD("Release", NULL, NULL, release_agent) },	{ GDBUS_ASYNC_METHOD("RequestPinCode",			GDBUS_ARGS({ "device", "o" }),			GDBUS_ARGS({ "pincode", "s" }), request_pincode) },	{ GDBUS_METHOD("DisplayPinCode",			GDBUS_ARGS({ "device", "o" }, { "pincode", "s" }),			NULL, display_pincode) },	{ GDBUS_ASYNC_METHOD("RequestPasskey",			GDBUS_ARGS({ "device", "o" }),			GDBUS_ARGS({ "passkey", "u" }), request_passkey) },	{ GDBUS_METHOD("DisplayPasskey",			GDBUS_ARGS({ "device", "o" }, { "passkey", "u" },							{ "entered", "q" }),			NULL, display_passkey) },	{ GDBUS_ASYNC_METHOD("RequestConfirmation",			GDBUS_ARGS({ "device", "o" }, { "passkey", "u" }),

		return __ofono_error_invalid_args(msg);	if (pn->agent == NULL)		return __ofono_error_failed(msg);	if (sms_agent_matches(pn->agent, agent_bus, agent_path) == FALSE)		return __ofono_error_failed(msg);	sms_agent_free(pn->agent);	pn->agent = NULL;	return dbus_message_new_method_return(msg);}static const GDBusMethodTable push_notification_methods[] = {	{ GDBUS_METHOD("RegisterAgent",	GDBUS_ARGS({ "path", "o" }), NULL,			push_notification_register_agent) },	{ GDBUS_METHOD("UnregisterAgent", GDBUS_ARGS({ "path", "o" }), NULL,			push_notification_unregister_agent) },	{ }};static void push_notification_cleanup(gpointer user){	struct push_notification *pn = user;	DBG("%p", pn);	/* The push watch was already cleaned up */	pn->push_watch[0] = 0;	pn->push_watch[1] = 0;	pn->sms = NULL;

	return NULL;fallback:	/* There's no driver, fallback to direct SCO connection */	err = ofono_handsfree_card_connect_sco(card);	if (err < 0)		return __ofono_error_failed(msg);	card->msg = dbus_message_ref(msg);	return NULL;}static const GDBusMethodTable card_methods[] = {	{ GDBUS_METHOD("GetProperties",			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),			card_get_properties) },	{ GDBUS_ASYNC_METHOD("Connect", NULL, NULL, card_connect) },	{ }};static const GDBusSignalTable card_signals[] = {	{ GDBUS_SIGNAL("PropertyChanged",			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },	{ }};struct ofono_handsfree_card *ofono_handsfree_card_create(unsigned int vendor,					enum ofono_handsfree_card_type type,					const char *driver,					void *data)

			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);	connected = (conn->state == SAP_STATE_CONNECTED ||				conn->state == SAP_STATE_GRACEFUL_DISCONNECT);	dict_append_entry(&dict, "Connected", DBUS_TYPE_BOOLEAN, &connected);	dbus_message_iter_close_container(&iter, &dict);	return reply;}static const GDBusMethodTable server_methods[] = {	{ GDBUS_METHOD("GetProperties",			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),			get_properties) },	{ GDBUS_METHOD("Disconnect", NULL, NULL, disconnect) },	{ }};static const GDBusSignalTable server_signals[] = {	{ GDBUS_SIGNAL("PropertyChanged",			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },	{ }};static void server_free(struct sap_server *server){	if (!server)		return;

                                    DBusMessage *msg, void *user_data){    struct connman_session *session = user_data;    DBG("session %p", session);    if (ecall_session && ecall_session != session)        return __connman_error_failed(msg, EBUSY);    session_disconnect(session);    return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable session_methods[] = {    { GDBUS_METHOD("Destroy", NULL, NULL, destroy_session) },    { GDBUS_METHOD("Connect", NULL, NULL, connect_session) },    {   GDBUS_METHOD("Disconnect", NULL, NULL,        disconnect_session )    },    {   GDBUS_METHOD("Change",        GDBUS_ARGS({ "name", "s" }, { "value", "v" }),        NULL, change_session)    },    { },};static int session_policy_config_cb(struct connman_session *session,                                    struct connman_session_config *config,                                    void *user_data, int err){

static void path_unregister(void *data){	struct network_adapter *na = data;	DBG("Unregistered interface %s on path %s",		NETWORK_SERVER_INTERFACE, adapter_get_path(na->adapter));	g_slist_free_full(na->servers, server_free);	adapters = g_slist_remove(adapters, na);	adapter_free(na);}static const GDBusMethodTable server_methods[] = {	{ GDBUS_METHOD("Register",			GDBUS_ARGS({ "uuid", "s" }, { "bridge", "s" }), NULL,			register_server) },	{ GDBUS_METHOD("Unregister",			GDBUS_ARGS({ "uuid", "s" }), NULL,			unregister_server) },	{ }};static struct network_adapter *create_adapter(struct btd_adapter *adapter){	struct network_adapter *na;	GError *err = NULL;	na = g_new0(struct network_adapter, 1);	na->adapter = btd_adapter_ref(adapter);

static DBusMessage *profile_request_disconnection(DBusConnection *conn,						DBusMessage *msg, void *data){	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static DBusMessage *profile_cancel(DBusConnection *conn,						DBusMessage *msg, void *data){	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable profile_methods[] = {	{ GDBUS_METHOD("Release",			NULL, NULL,			profile_release) },	{ GDBUS_METHOD("NewConnection",			GDBUS_ARGS({ "device", "o" }, { "fd", "h" },			{ "options", "a{sv}" }), NULL,			profile_new_connection) },	{ GDBUS_METHOD("RequestDisconnection",			GDBUS_ARGS({ "device", "o" }), NULL,			profile_request_disconnection) },	{ GDBUS_METHOD("Cancel",			NULL, NULL,			profile_cancel) },	{ }};static void register_profile_reply(DBusPendingCall *call, void *user_data)

						&query, &query_len, &version);	if (ret)		goto error;	ret = __connman_peer_service_unregister(owner, spec, spec_len,						query, query_len, version);	if (!ret)		return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);error:	return __connman_error_failed(msg, -ret);}static const GDBusMethodTable manager_methods[] = {	{ GDBUS_METHOD("GetProperties",			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),			get_properties) },	{ GDBUS_ASYNC_METHOD("SetProperty",			GDBUS_ARGS({ "name", "s" }, { "value", "v" }),			NULL, set_property) },	{ GDBUS_METHOD("GetTechnologies",			NULL, GDBUS_ARGS({ "technologies", "a(oa{sv})" }),			get_technologies) },	{ GDBUS_DEPRECATED_METHOD("RemoveProvider",			GDBUS_ARGS({ "provider", "o" }), NULL,			remove_provider) },	{ GDBUS_METHOD("GetServices",			NULL, GDBUS_ARGS({ "services", "a(oa{sv})" }),			get_services) },	{ GDBUS_METHOD("GetPeers",			NULL, GDBUS_ARGS({ "peers", "a(oa{sv})" }),

	alert_adapters = g_slist_remove(alert_adapters, al_adapter);	btd_adapter_unref(al_adapter->adapter);	g_free(al_adapter);}static struct btd_profile alert_profile = {	.name = "gatt-alert-server",	.adapter_probe = alert_server_probe,	.adapter_remove = alert_server_remove,};static const GDBusMethodTable alert_methods[] = {	{ GDBUS_METHOD("RegisterAlert",			GDBUS_ARGS({ "category", "s" },				   { "agent", "o" }), NULL,			register_alert) },	{ GDBUS_METHOD("NewAlert",			GDBUS_ARGS({ "category", "s" },				   { "count", "q" },				   { "description", "s" }), NULL,			new_alert) },	{ GDBUS_METHOD("UnreadAlert",			GDBUS_ARGS({ "category", "s" }, { "count", "q" }), NULL,			unread_alert) },	{ }};int alert_server_init(void){	if (!g_dbus_register_interface(btd_get_dbus_connection(),

	return dbus_message_new_method_return(msg);}static DBusMessage *control_reset(DBusConnection *conn,					DBusMessage *msg, void *data){	release_modems();	parse_config();	return dbus_message_new_method_return(msg);}static const GDBusMethodTable control_methods[] = {	{ GDBUS_METHOD("Add",		GDBUS_ARGS({ "name", "s" }, {"address", "s"}, {"port", "s"}),		NULL,		control_add) },	{ GDBUS_METHOD("RemoveAll",		GDBUS_ARGS({ }),		NULL,		control_remove_all) },	{ GDBUS_METHOD("Reset",		GDBUS_ARGS({ }),		NULL,		control_reset) },	{}};static int setup_control_channel(void){	int err = 0;

		return btd_error_does_not_exist(msg);	hradapter->watchers = g_slist_remove(hradapter->watchers, watcher);	g_dbus_remove_watch(conn, watcher->id);	if (g_slist_length(hradapter->watchers) == 0)		g_slist_foreach(hradapter->devices, disable_measurement, 0);	DBG("heartrate watcher [%s] unregistered", path);	return dbus_message_new_method_return(msg);}static const GDBusMethodTable heartrate_manager_methods[] = {	{ GDBUS_METHOD("RegisterWatcher",			GDBUS_ARGS({ "agent", "o" }), NULL,			register_watcher) },	{ GDBUS_METHOD("UnregisterWatcher",			GDBUS_ARGS({ "agent", "o" }), NULL,			unregister_watcher) },	{ }};static gboolean property_get_location(const GDBusPropertyTable *property,					DBusMessageIter *iter, void *data){	struct heartrate *hr = data;	char *loc;	if (!hr->has_location)		return FALSE;

	sender = dbus_message_get_sender(msg);	dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,							DBUS_TYPE_INVALID);	DBG("sender %s path %s", sender, path);	g_hash_table_remove(config_list, path);	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);}static const GDBusMethodTable manager_methods[] = {	{ GDBUS_METHOD("CreateProxyConfiguration",			GDBUS_ARGS({ "settings", "a{sv}" }),			GDBUS_ARGS({ "path", "o" }),			create_proxy_config) },	{ GDBUS_METHOD("DestroyProxyConfiguration",			GDBUS_ARGS({ "configuration" , "o" }), NULL,			destroy_proxy_config) },	{ },};static DBusConnection *connection;int __pacrunner_manager_init(DBusConnection *conn){	DBG("");	connection = dbus_connection_ref(conn);

	return 0;}static const GDBusMethodTable sms_manager_methods[] = {	{ GDBUS_ASYNC_METHOD("GetProperties",				NULL, GDBUS_ARGS({ "properties", "a{sv}" }),				sms_get_properties) },	{ GDBUS_ASYNC_METHOD("SetProperty",			GDBUS_ARGS({ "property", "s" }, { "value", "v" }),			NULL, sms_set_property) },	{ GDBUS_ASYNC_METHOD("SendMessage",			GDBUS_ARGS({ "to", "s" }, { "text", "s" }),			GDBUS_ARGS({ "path", "o" }),			sms_send_message) },	{ GDBUS_METHOD("GetMessages",			NULL, GDBUS_ARGS({ "messages", "a(oa{sv})" }),			sms_get_messages) },	{ }};static const GDBusSignalTable sms_manager_signals[] = {	{ GDBUS_SIGNAL("PropertyChanged",			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },	{ GDBUS_SIGNAL("IncomingMessage",			GDBUS_ARGS({ "message", "s" }, { "info", "a{sv}" })) },	{ GDBUS_SIGNAL("ImmediateMessage",			GDBUS_ARGS({ "message", "s" }, { "info", "a{sv}" })) },	{ GDBUS_SIGNAL("MessageAdded",			GDBUS_ARGS({ "path", "o" },						{ "properties", "a{sv}" })) },	{ GDBUS_SIGNAL("MessageRemoved",

	}	invalidate_parent_data(conn, parent_path);	if (data == NULL)		goto done;	g_free(data->introspect);	data->introspect = NULL;done:	g_free(parent_path);}static const GDBusMethodTable introspect_methods[] = {	{ GDBUS_METHOD("Introspect", NULL,			GDBUS_ARGS({ "xml", "s" }), introspect) },	{ }};static void add_interface(struct generic_data *data, const char *name,				const GDBusMethodTable *methods,				const GDBusSignalTable *signals,				const GDBusPropertyTable *properties,				void *user_data,				GDBusDestroyFunction destroy){	struct interface_data *iface;	iface = g_new0(struct interface_data, 1);	iface->name = g_strdup(name);	iface->methods = methods;

    dbus_message_iter_next(&iter);    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)        return __dundee_error_invalid_args(msg);    dbus_message_iter_recurse(&iter, &var);    if (g_str_equal(name, "Active"))        return set_property_active(device, msg, &var);    return __dundee_error_invalid_args(msg);}static const GDBusMethodTable device_methods[] = {    {   GDBUS_METHOD("GetProperties",        NULL, GDBUS_ARGS({ "properties", "a{sv}" }),        device_get_properties)    },    {   GDBUS_ASYNC_METHOD("SetProperty",        GDBUS_ARGS({ "property", "s" }, { "value", "v" }),        NULL, device_set_property)    },    { }};static const GDBusSignalTable device_signals[] = {    {   GDBUS_SIGNAL("PropertyChanged",        GDBUS_ARGS({ "name", "s" }, { "value", "v" }))    },    { }};

	const char *obj_path = ofono_modem_get_path(modem);	g_dbus_unregister_interface(connection, obj_path, HFP_AGENT_INTERFACE);	hfp_data->agent_registered = FALSE;	g_hash_table_remove(modem_hash, hfp_data->handsfree_path);	ofono_modem_remove(modem);	return dbus_message_new_method_return(msg);}static const GDBusMethodTable agent_methods[] = {	{ GDBUS_ASYNC_METHOD("NewConnection",				GDBUS_ARGS({ "fd", "h" }, { "version", "q" }),				NULL, hfp_agent_new_connection) },	{ GDBUS_METHOD("Release", NULL, NULL, hfp_agent_release) },	{ }};static int hfp_hf_probe(const char *device, const char *dev_addr,				const char *adapter_addr, const char *alias){	struct ofono_modem *modem;	struct hfp_data *data;	char buf[256];	/* We already have this device in our hash, ignore */	if (g_hash_table_lookup(modem_hash, device) != NULL)		return -EALREADY;	ofono_info("Using device: %s, devaddr: %s, adapter: %s",