static void voicecall_watch(struct ofono_atom *atom, enum ofono_atom_watch_condition cond, void *data) { struct ofono_atom *sim_atom; struct ofono_sim *sim; struct ofono_modem *modem; DBusConnection *conn = ofono_dbus_get_connection(); if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) return; /* * This logic is only intended to handle voicecall atoms * registered in post_sim state or later */ modem = __ofono_atom_get_modem(atom); sim_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_SIM); if (sim_atom == NULL) return; sim = __ofono_atom_get_data(sim_atom); if (ofono_sim_get_state(sim) != OFONO_SIM_STATE_READY) return; modems = g_list_append(modems, modem); if (modems->next != NULL) return; bt_register_profile(conn, HFP_AG_UUID, HFP_VERSION_1_5, "hfp_ag", HFP_AG_EXT_PROFILE_PATH, NULL, 0); }
static gboolean handle_command_send_sms(const struct stk_command *cmd, struct stk_response *rsp, struct ofono_stk *stk) { struct ofono_modem *modem = __ofono_atom_get_modem(stk->atom); struct ofono_atom *sms_atom; struct ofono_sms *sms; GSList msg_list; sms_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_SMS); if (!sms_atom || !__ofono_atom_get_registered(sms_atom)) { rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE; return TRUE; } sms = __ofono_atom_get_data(sms_atom); stk->sms_submit_req = g_new0(struct sms_submit_req, 1); stk->sms_submit_req->stk = stk; msg_list.data = (void *) &cmd->send_sms.gsm_sms; msg_list.next = NULL; __ofono_sms_txq_submit(sms, &msg_list, 0, send_sms_submit_cb, stk->sms_submit_req, g_free); stk->cancel_cmd = send_sms_cancel; if (cmd->send_sms.alpha_id && cmd->send_sms.alpha_id[0]) stk_alpha_id_set(stk, cmd->send_sms.alpha_id); return FALSE; }
static void sms_watch(struct ofono_atom *atom, enum ofono_atom_watch_condition cond, void *data) { struct push_notification *pn = data; DBusConnection *conn = ofono_dbus_get_connection(); if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) { g_dbus_unregister_interface(conn, ofono_modem_get_path(pn->modem), PUSH_NOTIFICATION_INTERFACE); return; } DBG("registered"); pn->sms = __ofono_atom_get_data(atom); if (!g_dbus_register_interface(conn, ofono_modem_get_path(pn->modem), PUSH_NOTIFICATION_INTERFACE, push_notification_methods, NULL, NULL, pn, push_notification_cleanup)) { ofono_error("Could not create %s interface", PUSH_NOTIFICATION_INTERFACE); return; } ofono_modem_add_interface(pn->modem, PUSH_NOTIFICATION_INTERFACE); }
static void get_rs_with_mode(struct ofono_modem *modem, void *data) { struct switch_data *sd = data; struct radio_data *rd_ref = sd->rd_1; struct ofono_atom *atom; struct ofono_radio_settings *rs; struct radio_data *rd; const char *standby_group, *modem_group; atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_RADIO_SETTINGS); if (atom == NULL) return; rs = __ofono_atom_get_data(atom); rd = ofono_radio_settings_get_data(rs); if (rd == rd_ref) return; standby_group = ofono_modem_get_string(rd_ref->modem, "StandbyGroup"); if (standby_group == NULL) return; modem_group = ofono_modem_get_string(modem, "StandbyGroup"); if (g_strcmp0(standby_group, modem_group) != 0) return; if ((rd->available_rats & sd->mode_to_switch) == 0) return; sd->rd_2 = rd; }
static DBusMessage *message_cancel(DBusConnection *conn, DBusMessage *msg, void *data) { struct message *m = data; int res; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_INVALID) == FALSE) return __ofono_error_invalid_args(msg); if (m->state != MESSAGE_STATE_PENDING) return __ofono_error_not_available(msg); res = __ofono_sms_txq_cancel(__ofono_atom_get_data(m->atom), &m->uuid); switch (res) { case -ENOENT: return __ofono_error_not_found(msg); case -EPERM: return __ofono_error_access_denied(msg); case 0: return dbus_message_new_method_return(msg); default: return __ofono_error_failed(msg); } }
static void context_remove(struct ofono_atom *atom) { struct ofono_nettime_context *context = __ofono_atom_get_data(atom); if (context->driver->remove) context->driver->remove(context); g_free(context); }
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); }
static void emulator_battery_cb(struct ofono_atom *atom, void *data) { struct ofono_emulator *em = __ofono_atom_get_data(atom); int val = 0; if (GPOINTER_TO_INT(data) > 0) val = (GPOINTER_TO_INT(data) - 1) / 20 + 1; ofono_emulator_set_indicator(em, OFONO_EMULATOR_IND_BATTERY, val); }
static void nettime_info_received(struct ofono_atom *atom, void *data) { struct ofono_nettime_context *context = __ofono_atom_get_data(atom); struct ofono_network_time *info = data; if (context->driver->info_received == NULL) return; context->driver->info_received(context, info); }
static void audio_settings_unregister(struct ofono_atom *atom) { struct ofono_audio_settings *as = __ofono_atom_get_data(atom); const char *path = __ofono_atom_get_path(as->atom); DBusConnection *conn = ofono_dbus_get_connection(); struct ofono_modem *modem = __ofono_atom_get_modem(as->atom); ofono_modem_remove_interface(modem, OFONO_AUDIO_SETTINGS_INTERFACE); g_dbus_unregister_interface(conn, path, OFONO_AUDIO_SETTINGS_INTERFACE); }
static void check_pin2_state(struct ofono_call_meter *cm) { struct ofono_atom *sim_atom; sim_atom = __ofono_modem_find_atom(__ofono_atom_get_modem(cm->atom), OFONO_ATOM_TYPE_SIM); if (sim_atom == NULL) return; __ofono_sim_recheck_pin(__ofono_atom_get_data(sim_atom)); }
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 mw_watch(struct ofono_atom *atom, enum ofono_atom_watch_condition cond, void *data) { struct ofono_sms *sms = data; if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) { sms->mw = NULL; return; } sms->mw = __ofono_atom_get_data(atom); }
static void sms_remove(struct ofono_atom *atom) { struct ofono_sms *sms = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (sms == NULL) return; if (sms->driver && sms->driver->remove) sms->driver->remove(sms); if (sms->tx_source) { g_source_remove(sms->tx_source); sms->tx_source = 0; } if (sms->assembly) { sms_assembly_free(sms->assembly); sms->assembly = NULL; } if (sms->txq) { g_queue_foreach(sms->txq, tx_queue_entry_destroy_foreach, NULL); g_queue_free(sms->txq); sms->txq = NULL; } if (sms->settings) { g_key_file_set_integer(sms->settings, SETTINGS_GROUP, "NextReference", sms->ref); g_key_file_set_boolean(sms->settings, SETTINGS_GROUP, "UseDeliveryReports", sms->use_delivery_reports); g_key_file_set_integer(sms->settings, SETTINGS_GROUP, "Bearer", sms->bearer); g_key_file_set_integer(sms->settings, SETTINGS_GROUP, "Alphabet", sms->alphabet); storage_close(sms->imsi, SETTINGS_STORE, sms->settings, TRUE); g_free(sms->imsi); sms->imsi = NULL; sms->settings = NULL; } if (sms->sr_assembly) { status_report_assembly_free(sms->sr_assembly); sms->sr_assembly = NULL; } g_free(sms); }
static void oem_raw_remove(struct ofono_atom *atom) { struct ofono_oem_raw *oemraw = __ofono_atom_get_data(atom); if (oemraw == NULL) return; if (oemraw->driver && oemraw->driver->remove) oemraw->driver->remove(oemraw); g_free(oemraw); }
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 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); }
static void dun_watch(struct ofono_atom *atom, enum ofono_atom_watch_condition cond, void *data) { struct ofono_emulator *em = __ofono_atom_get_data(atom); if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) return; ofono_emulator_add_handler(em, "+GMI", gmi_cb, data, NULL); ofono_emulator_add_handler(em, "+GMM", gmm_cb, data, NULL); ofono_emulator_add_handler(em, "+GMR", gmr_cb, data, NULL); ofono_emulator_add_handler(em, "+GCAP", gcap_cb, data, NULL); }
static void ussd_remove(struct ofono_atom *atom) { struct ofono_ussd *ussd = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (ussd == NULL) return; if (ussd->driver && ussd->driver->remove) ussd->driver->remove(ussd); g_free(ussd); }
static void stk_remove(struct ofono_atom *atom) { struct ofono_stk *stk = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (stk == NULL) return; if (stk->driver && stk->driver->remove) stk->driver->remove(stk); g_free(stk); }
static void call_volume_remove(struct ofono_atom *atom) { struct ofono_call_volume *cv = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (cv == NULL) return; if (cv->driver != NULL && cv->driver->remove != NULL) cv->driver->remove(cv); g_free(cv); }
static void handsfree_remove(struct ofono_atom *atom) { struct ofono_handsfree *hf = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (hf == NULL) return; if (hf->driver != NULL && hf->driver->remove != NULL) hf->driver->remove(hf); g_free(hf); }
static void oem_raw_dbus_unregister(struct ofono_atom *atom) { DBG(""); struct ofono_oem_raw *oemraw = __ofono_atom_get_data(atom); const char *path = __ofono_atom_get_path(oemraw->atom); DBusConnection *conn = ofono_dbus_get_connection(); struct ofono_modem *modem = __ofono_atom_get_modem(oemraw->atom); ofono_modem_remove_interface(modem, OFONO_OEM_RAW_INTERFACE); if (!g_dbus_unregister_interface(conn, path, OFONO_OEM_RAW_INTERFACE)) ofono_error("Failed to unregister interface %s", OFONO_OEM_RAW_INTERFACE); }
static void gnss_remove(struct ofono_atom *atom) { struct ofono_gnss *gnss = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (gnss == NULL) return; if (gnss->driver && gnss->driver->remove) gnss->driver->remove(gnss); g_free(gnss); }
static void location_reporting_remove(struct ofono_atom *atom) { struct ofono_location_reporting *lr = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (lr == NULL) return; if (lr->driver && lr->driver->remove) lr->driver->remove(lr); g_free(lr); }
static void radio_settings_remove(struct ofono_atom *atom) { struct ofono_radio_settings *rs = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (rs == NULL) return; if (rs->driver && rs->driver->remove) rs->driver->remove(rs); g_free(rs); }
static void call_meter_remove(struct ofono_atom *atom) { struct ofono_call_meter *cm = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (cm == NULL) return; if (cm->driver && cm->driver->remove) cm->driver->remove(cm); g_free(cm); }
static void audio_settings_remove(struct ofono_atom *atom) { struct ofono_audio_settings *as = __ofono_atom_get_data(atom); DBG("atom: %p", atom); if (as == NULL) return; if (as->driver && as->driver->remove) as->driver->remove(as); g_free(as->mode); g_free(as); }
static void sim_watch(struct ofono_atom *atom, enum ofono_atom_watch_condition cond, void *data) { struct ofono_modem *modem = data; if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) { modem->sim_ready_watch = 0; return; } modem->sim = __ofono_atom_get_data(atom); modem->sim_ready_watch = ofono_sim_add_state_watch(modem->sim, sim_state_watch, modem, NULL); }
static void devinfo_unregister(struct ofono_atom *atom) { struct ofono_devinfo *info = __ofono_atom_get_data(atom); g_free(info->manufacturer); info->manufacturer = NULL; g_free(info->model); info->model = NULL; g_free(info->revision); info->revision = NULL; g_free(info->serial); info->serial = NULL; }