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); }
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); }
gboolean g_dbus_detach_object_manager(DBusConnection *connection) { if (!g_dbus_unregister_interface(connection, "/", DBUS_INTERFACE_OBJECT_MANAGER)) return FALSE; root = NULL; return TRUE; }
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); }
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); }
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; }
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); }
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); }
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); }
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); }
void telephony_exit(void) { DBG(""); g_dbus_unregister_interface(connection, TELEPHONY_DUMMY_PATH, TELEPHONY_DUMMY_IFACE); dbus_connection_unref(connection); connection = NULL; telephony_deinit(); }
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); }
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; }
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); }
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); }
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; }
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); }
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); }
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); }
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); }
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(); }
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; }
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); }
static void nmcompat_exit(void) { DBG(""); connman_notifier_unregister(¬ifier); if (connection == NULL) return; g_dbus_unregister_interface(connection, NM_PATH, NM_INTERFACE); dbus_connection_unref(connection); }
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); } }
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); }
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); }
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); }
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); }
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); }