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;
}
