C++ (Cpp) g_dbus_unregister_interfaceの例

コード例 #1

ファイル: call-volume.c プロジェクト: Conjuror/ofono

static void call_volume_unregister(struct ofono_atom *atom)
{
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(atom);
	const char *path = __ofono_atom_get_path(atom);

	ofono_modem_remove_interface(modem, OFONO_CALL_VOLUME_INTERFACE);
	g_dbus_unregister_interface(conn, path,
					OFONO_CALL_VOLUME_INTERFACE);
}

コード例 #2

ファイル: manager.c プロジェクト: ghent360/bluez

void manager_unregister_session(struct obex_session *os)
{
	char *path;

	path = g_strdup_printf("%s/session%u", SESSION_BASE_PATH, os->id);

	g_dbus_unregister_interface(connection, path, SESSION_INTERFACE);

	g_free(path);
}

コード例 #3

ファイル: object.c プロジェクト: dmp0x7c5/gobexfuse

gboolean g_dbus_detach_object_manager(DBusConnection *connection)
{
	if (!g_dbus_unregister_interface(connection, "/",
					DBUS_INTERFACE_OBJECT_MANAGER))
		return FALSE;

	root = NULL;

	return TRUE;
}

コード例 #4

ファイル: transport.c プロジェクト: BloodLiker/bluez

void media_transport_destroy(struct media_transport *transport)
{
	char *path;

	path = g_strdup(transport->path);
	g_dbus_unregister_interface(transport->conn, path,
						MEDIA_TRANSPORT_INTERFACE);

	g_free(path);
}

コード例 #5

ファイル: call-meter.c プロジェクト: AndriusA/ofono

static void call_meter_unregister(struct ofono_atom *atom)
{
	struct ofono_call_meter *cm = __ofono_atom_get_data(atom);
	const char *path = __ofono_atom_get_path(cm->atom);
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(cm->atom);

	ofono_modem_remove_interface(modem, OFONO_CALL_METER_INTERFACE);
	g_dbus_unregister_interface(conn, path, OFONO_CALL_METER_INTERFACE);
}

コード例 #6

ファイル: session-api.c プロジェクト: aldebaran/connman-stable

int session_notify_unregister(struct test_session *session,
				const char *notify_path)
{
	if (g_dbus_unregister_interface(session->connection, notify_path,
				CONNMAN_NOTIFICATION_INTERFACE) == FALSE) {
		return -EINVAL;
	}

	return 0;
}

コード例 #7

ファイル: radio-settings.c プロジェクト: stskeeps/ofono

static void radio_settings_unregister(struct ofono_atom *atom)
{
	struct ofono_radio_settings *rs = __ofono_atom_get_data(atom);
	const char *path = __ofono_atom_get_path(rs->atom);
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(rs->atom);

	ofono_modem_remove_interface(modem, OFONO_RADIO_SETTINGS_INTERFACE);
	g_dbus_unregister_interface(conn, path, OFONO_RADIO_SETTINGS_INTERFACE);
}

コード例 #8

ファイル: player.c プロジェクト: AwxiVYTHUIiMOol/bluez

static void media_item_destroy(void *data)
{
	struct media_item *item = data;

	DBG("%s", item->path);

	g_dbus_unregister_interface(btd_get_dbus_connection(), item->path,
						MEDIA_ITEM_INTERFACE);

	media_item_free(item);
}

コード例 #9

ファイル: neard.c プロジェクト: Jubei-Mitsuyoshi/aaa-connman

static DBusMessage *release_method(DBusConnection *dbus_conn,
					DBusMessage *message, void *user_data)
{
	DBG("");

	agent_registered = FALSE;
	g_dbus_unregister_interface(connection,
					AGENT_PATH, NEARD_AGENT_INTERFACE);

	return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
}

コード例 #10

ファイル: advertising.c プロジェクト: AlanApter/steamlink-sdk

void btd_advertising_manager_destroy(struct btd_advertising *manager)
{
	if (!manager)
		return;

	g_dbus_unregister_interface(btd_get_dbus_connection(),
					adapter_get_path(manager->adapter),
					LE_ADVERTISING_MGR_IFACE);

	advertising_manager_destroy(manager);
}

コード例 #11

ファイル: telephony-dummy.c プロジェクト: blammit/bluez

void telephony_exit(void)
{
	DBG("");

	g_dbus_unregister_interface(connection, TELEPHONY_DUMMY_PATH,
						TELEPHONY_DUMMY_IFACE);
	dbus_connection_unref(connection);
	connection = NULL;

	telephony_deinit();
}

コード例 #12

ファイル: manager.c プロジェクト: tmarcu/PACrunner-jsengine

void __pacrunner_manager_cleanup(void)
{
	DBG("");

	g_hash_table_destroy(config_list);

	g_dbus_unregister_interface(connection, PACRUNNER_MANAGER_PATH,
						PACRUNNER_MANAGER_INTERFACE);

	dbus_connection_unref(connection);
}

コード例 #13

ファイル: handsfree-audio.c プロジェクト: alfonsosanchezbeato/ofono

static void card_unregister(struct ofono_handsfree_card *card)
{
	DBusConnection *conn = ofono_dbus_get_connection();

	g_dbus_unregister_interface(conn, card->path, HFP_AUDIO_CARD_INTERFACE);

	emit_card_removed(card);

	g_free(card->path);
	card->path = NULL;
}

コード例 #14

ファイル: transfer.c プロジェクト: Sork007/obexd

void obc_transfer_unregister(struct obc_transfer *transfer)
{
	if (transfer->path) {
		g_dbus_unregister_interface(transfer->conn,
			transfer->path, TRANSFER_INTERFACE);
	}

	DBG("%p unregistered %s", transfer, transfer->path);

	obc_transfer_free(transfer);
}

コード例 #15

ファイル: location-reporting.c プロジェクト: Conjuror/ofono

static void location_reporting_unregister(struct ofono_atom *atom)
{
	struct ofono_location_reporting *lr = __ofono_atom_get_data(atom);
	const char *path = __ofono_atom_get_path(lr->atom);
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(lr->atom);

	ofono_modem_remove_interface(modem, OFONO_LOCATION_REPORTING_INTERFACE);
	g_dbus_unregister_interface(conn, path,
					OFONO_LOCATION_REPORTING_INTERFACE);
}

コード例 #16

ファイル: technology.c プロジェクト: leinomii/connman

static void technology_dbus_unregister(struct connman_technology *technology)
{
	if (technology->dbus_registered == FALSE)
		return;

	technology_removed_signal(technology);
	g_dbus_unregister_interface(connection, technology->path,
		CONNMAN_TECHNOLOGY_INTERFACE);

	technology->dbus_registered = FALSE;
}

コード例 #17

ファイル: vpn-manager.c プロジェクト: cshnick/rpmFromGit

void __vpn_manager_cleanup(void)
{
	DBG("");

	if (connection == NULL)
		return;

	g_dbus_unregister_interface(connection, VPN_MANAGER_PATH,
						VPN_MANAGER_INTERFACE);

	dbus_connection_unref(connection);
}

コード例 #18

ファイル: proxy.c プロジェクト: writefaruq/bluez-oob

void proxy_unregister(struct btd_adapter *btd_adapter)
{
    struct serial_adapter *adapter;

    adapter = find_adapter(adapters, btd_adapter);
    if (!adapter)
        return;

    g_dbus_unregister_interface(adapter->conn,
                                adapter_get_path(btd_adapter),
                                SERIAL_MANAGER_INTERFACE);
}

コード例 #19

ファイル: cdma-netreg.c プロジェクト: AndriusA/ofono

static void cdma_netreg_unregister(struct ofono_atom *atom)
{
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(atom);
	const char *path = __ofono_atom_get_path(atom);

	g_dbus_unregister_interface(conn, path,
				OFONO_CDMA_NETWORK_REGISTRATION_INTERFACE);

	ofono_modem_remove_interface(modem,
				OFONO_CDMA_NETWORK_REGISTRATION_INTERFACE);
}

コード例 #20

ファイル: session.c プロジェクト: Commers/obexd

static void session_unregistered(struct session_data *session)
{
	switch (session->uuid.value.uuid16) {
	case OBEX_FILETRANS_SVCLASS_ID:
		g_dbus_unregister_interface(session->conn, session->path,
						FTP_INTERFACE);
		break;
	case PBAP_PSE_SVCLASS_ID:
		pbap_unregister_interface(session->conn, session->path,
						session);
		break;
	case IRMC_SYNC_SVCLASS_ID:
		sync_unregister_interface(session->conn, session->path,
						session);
	}

	g_dbus_unregister_interface(session->conn, session->path,
					SESSION_INTERFACE);

	DBG("Session(%p) unregistered %s", session, session->path);
}

コード例 #21

ファイル: neard.c プロジェクト: Jubei-Mitsuyoshi/aaa-connman

static void neard_is_out(DBusConnection *conn, void *user_data)
{
	DBG("");

	if (agent_registered == TRUE) {
		g_dbus_unregister_interface(connection,
					AGENT_PATH, NEARD_AGENT_INTERFACE);
		agent_registered = FALSE;
	}

	cleanup_register_call();
}

コード例 #22

ファイル: sms.c プロジェクト: AndriusA/ofono

static void sms_unregister(struct ofono_atom *atom)
{
	struct ofono_sms *sms = __ofono_atom_get_data(atom);
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(atom);
	const char *path = __ofono_atom_get_path(atom);

	g_dbus_unregister_interface(conn, path,
					OFONO_MESSAGE_MANAGER_INTERFACE);
	ofono_modem_remove_interface(modem, OFONO_MESSAGE_MANAGER_INTERFACE);

	if (sms->mw_watch) {
		__ofono_modem_remove_atom_watch(modem, sms->mw_watch);
		sms->mw_watch = 0;
		sms->mw = NULL;
	}

	if (sms->status_watch) {
		__ofono_netreg_remove_status_watch(sms->netreg,
							sms->status_watch);
		sms->status_watch = 0;
	}

	if (sms->netreg_watch) {
		__ofono_modem_remove_atom_watch(modem, sms->netreg_watch);
		sms->netreg_watch = 0;
	}

	sms->netreg = NULL;

	if (sms->messages) {
		GHashTableIter iter;
		struct message *m;
		gpointer key, value;

		g_hash_table_iter_init(&iter, sms->messages);

		while (g_hash_table_iter_next(&iter, &key, &value)) {
			m = value;
			message_dbus_unregister(m);
		}

		g_hash_table_destroy(sms->messages);
		sms->messages = NULL;
	}

	__ofono_watchlist_free(sms->text_handlers);
	sms->text_handlers = NULL;

	__ofono_watchlist_free(sms->datagram_handlers);
	sms->datagram_handlers = NULL;
}

コード例 #23

ファイル: network.c プロジェクト: wenhann/chromiumos

static void unregister_interface(struct connman_element *element)
{
	struct connman_network * network = element->network;

	_DBG_NETWORK("element %p name %s", element, element->name);

	network->registered = FALSE;

	emit_networks_signal(network->device);

	g_dbus_unregister_interface(connection, element->path,
						CONNMAN_NETWORK_INTERFACE);
}

コード例 #24

ファイル: nmcompat.c プロジェクト: sanyaade-research-hub/connman-stable

static void nmcompat_exit(void)
{
    DBG("");

    connman_notifier_unregister(&notifier);

    if (connection == NULL)
        return;

    g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE);

    dbus_connection_unref(connection);
}

コード例 #25

ファイル: sync.c プロジェクト: Commers/obexd

void sync_unregister_interface(DBusConnection *connection, const char *path,
							void *user_data)
{
	struct session_data *session = user_data;
	struct sync_data *syncdata = session_get_data(session);

	g_dbus_unregister_interface(connection, path, SYNC_INTERFACE);

	if (syncdata) {
		g_free(syncdata->phonebook_path);
		g_free(syncdata);
	}
}

コード例 #26

ファイル: gnss.c プロジェクト: AndriusA/ofono

static void gnss_unregister(struct ofono_atom *atom)
{
	struct ofono_gnss *gnss = __ofono_atom_get_data(atom);
	DBusConnection *conn = ofono_dbus_get_connection();
	struct ofono_modem *modem = __ofono_atom_get_modem(atom);
	const char *path = __ofono_atom_get_path(atom);

	if (gnss->posr_agent)
		gnss_agent_free(gnss->posr_agent);

	ofono_modem_remove_interface(modem, OFONO_GNSS_INTERFACE);
	g_dbus_unregister_interface(conn, path, OFONO_GNSS_INTERFACE);
}

コード例 #27

ファイル: device.c プロジェクト: padelt/bluez

void input_device_unregister(struct btd_service *service)
{
    struct btd_device *device = btd_service_get_device(service);
    const char *path = device_get_path(device);
    struct input_device *idev = btd_service_get_user_data(service);

    DBG("%s", path);

    g_dbus_unregister_interface(btd_get_dbus_connection(),
                                idev->path, INPUT_INTERFACE);

    input_device_free(idev);
}

コード例 #28

ファイル: manager.c プロジェクト: Fiend90/obex

void manager_unregister_transfer(struct obex_session *os)
{
	char *path = g_strdup_printf("/transfer%u", os->id);

	/* Got an error during a transfer. */
	if (os->object)
		emit_transfer_completed(os, os->offset == os->size);

	g_dbus_unregister_interface(connection, path,
				TRANSFER_INTERFACE);

	g_free(path);
}

コード例 #29

ファイル: heartrate.c プロジェクト: intgr/bluez

void heartrate_adapter_unregister(struct btd_adapter *adapter)
{
	struct heartrate_adapter *hradapter;

	hradapter = find_heartrate_adapter(adapter);
	if (hradapter == NULL)
		return;

	heartrate_adapters = g_slist_remove(heartrate_adapters, hradapter);

	g_dbus_unregister_interface(btd_get_dbus_connection(),
					adapter_get_path(hradapter->adapter),
					HEART_RATE_MANAGER_INTERFACE);
}

コード例 #30

ファイル: gatt-client.c プロジェクト: LGSInnovations/edison-debian-image

static void unregister_service(void *data)
{
	struct service *service = data;

	DBG("Removing GATT service: %s", service->path);

	if (service->idle_id)
		g_source_remove(service->idle_id);

	queue_remove_all(service->chrcs, NULL, NULL, unregister_characteristic);

	g_dbus_unregister_interface(btd_get_dbus_connection(), service->path,
							GATT_SERVICE_IFACE);
}