static DBusMessage *cv_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_call_volume *cv = data;
DBusMessage *reply;
DBusMessageIter iter, dict;
dbus_bool_t muted;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "SpeakerVolume", DBUS_TYPE_BYTE,
&cv->speaker_volume);
ofono_dbus_dict_append(&dict, "MicrophoneVolume",
DBUS_TYPE_BYTE, &cv->microphone_volume);
muted = cv->muted;
ofono_dbus_dict_append(&dict, "Muted", DBUS_TYPE_BOOLEAN, &muted);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void cm_get_properties_reply(struct ofono_call_meter *cm)
{
DBusMessage *reply;
DBusMessageIter iter, dict;
const char *currency = cm->currency;
reply = dbus_message_new_method_return(cm->pending);
if (reply == NULL)
return;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "CallMeter", DBUS_TYPE_UINT32,
&cm->call_meter);
ofono_dbus_dict_append(&dict, "AccumulatedCallMeter", DBUS_TYPE_UINT32,
&cm->acm);
ofono_dbus_dict_append(&dict, "AccumulatedCallMeterMaximum",
DBUS_TYPE_UINT32, &cm->acm_max);
ofono_dbus_dict_append(&dict, "PricePerUnit", DBUS_TYPE_DOUBLE,
&cm->ppu);
ofono_dbus_dict_append(&dict, "Currency", DBUS_TYPE_STRING, ¤cy);
dbus_message_iter_close_container(&iter, &dict);
__ofono_dbus_pending_reply(&cm->pending, reply);
}
static DBusMessage *location_reporting_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_location_reporting *lr = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *type;
int value;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
value = lr->enabled;
ofono_dbus_dict_append(&dict, "Enabled", DBUS_TYPE_BOOLEAN, &value);
type = location_reporting_type_to_string(lr->driver->type);
ofono_dbus_dict_append(&dict, "Type", DBUS_TYPE_STRING, &type);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *audio_get_properties_reply(DBusMessage *msg,
struct ofono_audio_settings *as)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "Active", DBUS_TYPE_BOOLEAN, &as->active);
if (as->mode)
ofono_dbus_dict_append(&dict, "Mode",
DBUS_TYPE_STRING, &as->mode);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *generate_get_properties_reply(struct ofono_sms *sms,
DBusMessage *msg)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *sca;
const char *bearer;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
sca = phone_number_to_string(&sms->sca);
ofono_dbus_dict_append(&dict, "ServiceCenterAddress", DBUS_TYPE_STRING,
&sca);
ofono_dbus_dict_append(&dict, "UseDeliveryReports", DBUS_TYPE_BOOLEAN,
&sms->use_delivery_reports);
bearer = sms_bearer_to_string(sms->bearer);
ofono_dbus_dict_append(&dict, "Bearer", DBUS_TYPE_STRING, &bearer);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *radio_get_properties_reply(DBusMessage *msg,
struct ofono_radio_settings *rs)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *mode = radio_access_mode_to_string(rs->mode);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "TechnologyPreference",
DBUS_TYPE_STRING, &mode);
if (rs->driver->query_band) {
const char *band = radio_band_gsm_to_string(rs->band_gsm);
ofono_dbus_dict_append(&dict, "GsmBand",
DBUS_TYPE_STRING, &band);
band = radio_band_umts_to_string(rs->band_umts);
ofono_dbus_dict_append(&dict, "UmtsBand",
DBUS_TYPE_STRING, &band);
}
if (rs->driver->query_fast_dormancy) {
dbus_bool_t value = rs->fast_dormancy;
ofono_dbus_dict_append(&dict, "FastDormancy",
DBUS_TYPE_BOOLEAN, &value);
}
if (rs->driver->query_modem_rats) {
const char *rats_strs[OFONO_RADIO_ACCESS_MODE_LAST + 1];
const char *(*strs)[] = &rats_strs;
int i, str_i;
for (i = 0, str_i = 0; i < OFONO_RADIO_ACCESS_MODE_LAST; ++i)
if (rs->modem_rats[i])
rats_strs[str_i++] =
radio_access_mode_to_string(i);
rats_strs[str_i] = NULL;
ofono_dbus_dict_append_array(&dict, "ModemTechnologies",
DBUS_TYPE_STRING, &strs);
}
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
void __dundee_device_append_properties(struct dundee_device *device,
DBusMessageIter *dict)
{
settings_append_dict(device, dict);
ofono_dbus_dict_append(dict, "Name", DBUS_TYPE_STRING,
&device->name);
ofono_dbus_dict_append(dict, "Active", DBUS_TYPE_BOOLEAN,
&device->active);
}
static DBusMessage *network_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_cdma_netreg *cdma_netreg = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *status = cdma_netreg_status_to_string(cdma_netreg->status);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "Status", DBUS_TYPE_STRING, &status);
if (cdma_netreg->strength != -1) {
unsigned char strength = cdma_netreg->strength;
ofono_dbus_dict_append(&dict, "Strength", DBUS_TYPE_BYTE,
&strength);
}
if (cdma_netreg->hdr_strength != -1) {
unsigned char strength = cdma_netreg->hdr_strength;
ofono_dbus_dict_append(&dict, "DataStrength", DBUS_TYPE_BYTE,
&strength);
}
if (cdma_netreg->sid)
ofono_dbus_dict_append(&dict, "SystemIdentifier",
DBUS_TYPE_STRING,
&cdma_netreg->sid);
if (cdma_netreg->provider_name)
ofono_dbus_dict_append(&dict, "Name", DBUS_TYPE_STRING,
&cdma_netreg->provider_name);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void card_append_properties(struct ofono_handsfree_card *card,
DBusMessageIter *dict)
{
const char *type;
type = card_type_to_string(card->type);
ofono_dbus_dict_append(dict, "Type",
DBUS_TYPE_STRING, &type);
ofono_dbus_dict_append(dict, "RemoteAddress",
DBUS_TYPE_STRING, &card->remote);
ofono_dbus_dict_append(dict, "LocalAddress",
DBUS_TYPE_STRING, &card->local);
}
static DBusMessage *ussd_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_ussd *ussd = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *value;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
value = ussd_get_state_string(ussd);
ofono_dbus_dict_append(&dict, "State", DBUS_TYPE_STRING, &value);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *thermal_management_get_properties(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
struct ril_thermal_management *tm = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
DBG("");
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "TransmitPowerThrottling",
DBUS_TYPE_BOOLEAN,
&tm->throttling);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *stk_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_stk *stk = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *idle_mode_text;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
idle_mode_text = stk->idle_mode_text ? stk->idle_mode_text : "";
ofono_dbus_dict_append(&dict, "IdleModeText",
DBUS_TYPE_STRING, &idle_mode_text);
if (stk->main_menu)
dict_append_menu(&dict, stk->main_menu);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *generate_get_properties_reply(struct ofono_handsfree *hf,
DBusMessage *msg)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
dbus_bool_t inband_ringing;
dbus_bool_t voice_recognition;
const char **features;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
inband_ringing = hf->inband_ringing;
ofono_dbus_dict_append(&dict, "InbandRinging", DBUS_TYPE_BOOLEAN,
&inband_ringing);
if (hf->ag_features & HFP_AG_FEATURE_ECNR)
ofono_dbus_dict_append(&dict, "EchoCancelingNoiseReduction",
DBUS_TYPE_BOOLEAN, &hf->nrec);
voice_recognition = hf->voice_recognition;
ofono_dbus_dict_append(&dict, "VoiceRecognition", DBUS_TYPE_BOOLEAN,
&voice_recognition);
features = ag_features_list(hf->ag_features, hf->ag_chld_features);
ofono_dbus_dict_append_array(&dict, "Features", DBUS_TYPE_STRING,
&features);
ofono_dbus_dict_append(&dict, "BatteryChargeLevel", DBUS_TYPE_BYTE,
&hf->battchg);
if (hf->subscriber_numbers)
append_subscriber_numbers(hf->subscriber_numbers, &dict);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static DBusMessage *radio_get_properties_reply(DBusMessage *msg,
struct ofono_radio_settings *rs)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *mode = radio_access_mode_to_string(rs->mode);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "TechnologyPreference",
DBUS_TYPE_STRING, &mode);
if (rs->driver->query_band) {
const char *band = radio_band_gsm_to_string(rs->band_gsm);
ofono_dbus_dict_append(&dict, "GsmBand",
DBUS_TYPE_STRING, &band);
band = radio_band_umts_to_string(rs->band_umts);
ofono_dbus_dict_append(&dict, "UmtsBand",
DBUS_TYPE_STRING, &band);
}
if (rs->driver->query_fast_dormancy) {
dbus_bool_t value = rs->fast_dormancy;
ofono_dbus_dict_append(&dict, "FastDormancy",
DBUS_TYPE_BOOLEAN, &value);
}
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void emit_menu_changed(struct ofono_stk *stk)
{
static struct stk_menu_item end_item = {};
static struct stk_menu no_menu = {
.title = "",
.items = &end_item,
.has_help = FALSE,
.default_item = -1,
};
static char *name = "MainMenu";
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(stk->atom);
struct stk_menu *menu = stk->main_menu ? stk->main_menu : &no_menu;
DBusMessage *signal;
DBusMessageIter iter;
ofono_dbus_signal_property_changed(conn, path,
OFONO_STK_INTERFACE,
"MainMenuTitle",
DBUS_TYPE_STRING, &menu->title);
signal = dbus_message_new_signal(path, OFONO_STK_INTERFACE,
"PropertyChanged");
if (!signal) {
ofono_error("Unable to allocate new %s.PropertyChanged signal",
OFONO_SIM_APP_INTERFACE);
return;
}
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
append_menu_items_variant(&iter, menu->items);
g_dbus_send_message(conn, signal);
}
static void dict_append_menu(DBusMessageIter *dict, struct stk_menu *menu)
{
DBusMessageIter entry;
const char *key = "MainMenu";
ofono_dbus_dict_append(dict, "MainMenuTitle",
DBUS_TYPE_STRING, &menu->title);
dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
NULL, &entry);
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
append_menu_items_variant(&entry, menu->items);
dbus_message_iter_close_container(dict, &entry);
}
static void settings_append(struct dundee_device *device,
DBusMessageIter *iter)
{
DBusMessageIter variant;
DBusMessageIter array;
char typesig[5];
char arraysig[6];
arraysig[0] = DBUS_TYPE_ARRAY;
arraysig[1] = typesig[0] = DBUS_DICT_ENTRY_BEGIN_CHAR;
arraysig[2] = typesig[1] = DBUS_TYPE_STRING;
arraysig[3] = typesig[2] = DBUS_TYPE_VARIANT;
arraysig[4] = typesig[3] = DBUS_DICT_ENTRY_END_CHAR;
arraysig[5] = typesig[4] = '\0';
dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
arraysig, &variant);
dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
typesig, &array);
if (device->active == FALSE)
goto out;
if (device->settings.interface)
ofono_dbus_dict_append(&array, "Interface",
DBUS_TYPE_STRING, &device->settings.interface);
if (device->settings.ip)
ofono_dbus_dict_append(&array, "Address", DBUS_TYPE_STRING,
&device->settings.ip);
if (device->settings.nameservers)
ofono_dbus_dict_append_array(&array, "DomainNameServers",
DBUS_TYPE_STRING,
&device->settings.nameservers);
out:
dbus_message_iter_close_container(&variant, &array);
dbus_message_iter_close_container(iter, &variant);
}
static inline void property_append_cf_condition(DBusMessageIter *dict, int cls,
const char *postfix,
const char *value,
dbus_uint16_t timeout)
{
char attr[64];
char tattr[64];
int addt = !strcmp(postfix, "NoReply");
snprintf(attr, sizeof(attr), "%s%s",
bearer_class_to_string(cls), postfix);
if (addt)
snprintf(tattr, sizeof(tattr), "%s%sTimeout",
bearer_class_to_string(cls), postfix);
ofono_dbus_dict_append(dict, attr, DBUS_TYPE_STRING, &value);
if (addt)
ofono_dbus_dict_append(dict, tattr, DBUS_TYPE_UINT16, &timeout);
}
static DBusMessage *handsfree_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_handsfree *hf = data;
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
dbus_bool_t inband_ringing;
dbus_bool_t voice_recognition;
const char **features;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
inband_ringing = hf->inband_ringing;
ofono_dbus_dict_append(&dict, "InbandRinging", DBUS_TYPE_BOOLEAN,
&inband_ringing);
voice_recognition = hf->voice_recognition;
ofono_dbus_dict_append(&dict, "VoiceRecognition", DBUS_TYPE_BOOLEAN,
&voice_recognition);
features = ag_features_list(hf->ag_features);
ofono_dbus_dict_append_array(&dict, "Features", DBUS_TYPE_STRING,
&features);
ofono_dbus_dict_append(&dict, "BatteryChargeLevel", DBUS_TYPE_BYTE,
&hf->battchg);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void cb_ss_property_append(struct ofono_call_barring *cb,
DBusMessageIter *dict, int lock,
int mask)
{
int i;
char property_name[64];
const char *strvalue;
for (i = 1; i <= BEARER_CLASS_PAD; i = i << 1) {
if (!(mask & i))
continue;
strvalue = (cb->new_locks[lock] & i) ? "enabled" : "disabled";
snprintf(property_name, sizeof(property_name), "%s%s",
bearer_class_to_string(i),
cb_locks[lock].name);
ofono_dbus_dict_append(dict, property_name, DBUS_TYPE_STRING,
&strvalue);
}
}
static void cdma_dispatch_text_message(struct ofono_cdma_sms *cdma_sms,
const char *message,
const char *oaddr)
{
const char *path = __ofono_atom_get_path(cdma_sms->atom);
DBusConnection *conn = ofono_dbus_get_connection();
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
const char *signal_name;
/* TODO: Support ImmediateMessage */
signal_name = "IncomingMessage";
signal = dbus_message_new_signal(path,
OFONO_CDMA_MESSAGE_MANAGER_INTERFACE,
signal_name);
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &message);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "Sender", DBUS_TYPE_STRING, &oaddr);
/* TODO: Other properties not supported yet */
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
/*TODO: Add the message to history*/
}
static DBusMessage *cf_get_properties_reply(DBusMessage *msg,
struct ofono_call_forwarding *cf)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
int i;
dbus_bool_t status;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
for (i = 0; i < 4; i++)
property_append_cf_conditions(&dict, cf->cf_conditions[i],
BEARER_CLASS_VOICE,
cf_type_lut[i]);
if ((cf->flags & CALL_FORWARDING_FLAG_CPHS_CFF) ||
cf->cfis_record_id > 0)
status = is_cfu_enabled(cf, NULL);
else
status = FALSE;
ofono_dbus_dict_append(&dict, "ForwardingFlagOnSim", DBUS_TYPE_BOOLEAN,
&status);
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
static void dispatch_text_message(struct ofono_sms *sms,
const struct ofono_uuid *uuid,
const char *message,
enum sms_class cls,
const struct sms_address *addr,
const struct sms_scts *scts)
{
struct ofono_modem *modem = __ofono_atom_get_modem(sms->atom);
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(sms->atom);
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
char buf[128];
const char *signal_name;
time_t ts;
struct tm remote;
struct tm local;
const char *str = buf;
ofono_sms_text_notify_cb_t notify;
struct sms_handler *h;
GSList *l;
if (message == NULL)
return;
if (cls == SMS_CLASS_0)
signal_name = "ImmediateMessage";
else
signal_name = "IncomingMessage";
signal = dbus_message_new_signal(path, OFONO_MESSAGE_MANAGER_INTERFACE,
signal_name);
if (signal == NULL)
return;
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &message);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ts = sms_scts_to_time(scts, &remote);
localtime_r(&ts, &local);
strftime(buf, 127, "%Y-%m-%dT%H:%M:%S%z", &local);
buf[127] = '\0';
ofono_dbus_dict_append(&dict, "LocalSentTime", DBUS_TYPE_STRING, &str);
strftime(buf, 127, "%Y-%m-%dT%H:%M:%S%z", &remote);
buf[127] = '\0';
ofono_dbus_dict_append(&dict, "SentTime", DBUS_TYPE_STRING, &str);
str = sms_address_to_string(addr);
ofono_dbus_dict_append(&dict, "Sender", DBUS_TYPE_STRING, &str);
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
if (cls == SMS_CLASS_0)
return;
for (l = sms->text_handlers->items; l; l = l->next) {
h = l->data;
notify = h->item.notify;
notify(str, &remote, &local, message, h->item.notify_data);
}
__ofono_history_sms_received(modem, uuid, str, &remote, &local,
message);
}
void __ofono_modem_append_properties(struct ofono_modem *modem,
DBusMessageIter *dict)
{
char **interfaces;
char **features;
int i;
GSList *l;
struct ofono_devinfo *info;
dbus_bool_t emergency = ofono_modem_get_emergency_mode(modem);
const char *strtype;
ofono_dbus_dict_append(dict, "Online", DBUS_TYPE_BOOLEAN,
&modem->online);
ofono_dbus_dict_append(dict, "Powered", DBUS_TYPE_BOOLEAN,
&modem->powered);
ofono_dbus_dict_append(dict, "Lockdown", DBUS_TYPE_BOOLEAN,
&modem->lockdown);
ofono_dbus_dict_append(dict, "Emergency", DBUS_TYPE_BOOLEAN,
&emergency);
info = __ofono_atom_find(OFONO_ATOM_TYPE_DEVINFO, modem);
if (info) {
if (info->manufacturer)
ofono_dbus_dict_append(dict, "Manufacturer",
DBUS_TYPE_STRING,
&info->manufacturer);
if (info->model)
ofono_dbus_dict_append(dict, "Model", DBUS_TYPE_STRING,
&info->model);
if (info->revision)
ofono_dbus_dict_append(dict, "Revision",
DBUS_TYPE_STRING,
&info->revision);
if (info->serial)
ofono_dbus_dict_append(dict, "Serial",
DBUS_TYPE_STRING,
&info->serial);
}
interfaces = g_new0(char *, g_slist_length(modem->interface_list) + 1);
for (i = 0, l = modem->interface_list; l; l = l->next, i++)
interfaces[i] = l->data;
ofono_dbus_dict_append_array(dict, "Interfaces", DBUS_TYPE_STRING,
&interfaces);
g_free(interfaces);
features = g_new0(char *, g_slist_length(modem->feature_list) + 1);
for (i = 0, l = modem->feature_list; l; l = l->next, i++)
features[i] = l->data;
ofono_dbus_dict_append_array(dict, "Features", DBUS_TYPE_STRING,
&features);
g_free(features);
if (modem->name)
ofono_dbus_dict_append(dict, "Name", DBUS_TYPE_STRING,
&modem->name);
strtype = modem_type_to_string(modem->driver->modem_type);
ofono_dbus_dict_append(dict, "Type", DBUS_TYPE_STRING, &strtype);
}
static void sms_history_sms_send_status(
struct ofono_history_context *context,
const struct ofono_uuid *uuid,
time_t when,
enum ofono_history_sms_status s)
{
if ((s == OFONO_HISTORY_SMS_STATUS_DELIVERED)
|| (s == OFONO_HISTORY_SMS_STATUS_DELIVER_FAILED)) {
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
const char *uuid_str;
char *msg_uuid_str;
size_t msg_len;
struct ofono_atom *atom;
const char *path;
DBusConnection *conn;
int delivered;
atom = __ofono_modem_find_atom(context->modem,
OFONO_ATOM_TYPE_SMS);
if (atom == NULL)
return;
path = __ofono_atom_get_path(atom);
if (path == NULL)
return;
conn = ofono_dbus_get_connection();
if (conn == NULL)
return;
delivered = (s == OFONO_HISTORY_SMS_STATUS_DELIVERED);
uuid_str = ofono_uuid_to_str(uuid);
/* sizeof adds extra space for one '\0' */
msg_len = strlen(path) + sizeof(msg_prefix)
+ strlen(uuid_str);
msg_uuid_str = g_try_malloc(msg_len);
if (msg_uuid_str == NULL)
return;
/* modem path + msg_prefix + UUID as string */
snprintf(msg_uuid_str, msg_len, "%s%s%s", path,
msg_prefix, uuid_str);
DBG("SMS %s delivery success: %d", msg_uuid_str, delivered);
signal = dbus_message_new_signal(path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"StatusReport");
if (signal != NULL) {
dbus_message_iter_init_append(signal, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
&msg_uuid_str);
dbus_message_iter_open_container(
&iter,
DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "Delivered",
DBUS_TYPE_BOOLEAN,
&delivered);
dbus_message_iter_close_container(&iter, &dict);
g_dbus_send_message(conn, signal);
}
g_free(msg_uuid_str);
}
}
static DBusMessage *radio_get_properties_reply(DBusMessage *msg,
struct ofono_radio_settings *rs)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter dict;
const char *mode = radio_access_mode_to_string(rs->mode);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
OFONO_PROPERTIES_ARRAY_SIGNATURE,
&dict);
ofono_dbus_dict_append(&dict, "TechnologyPreference",
DBUS_TYPE_STRING, &mode);
if (rs->driver->query_band) {
const char *band = radio_band_gsm_to_string(rs->band_gsm);
ofono_dbus_dict_append(&dict, "GsmBand",
DBUS_TYPE_STRING, &band);
band = radio_band_umts_to_string(rs->band_umts);
ofono_dbus_dict_append(&dict, "UmtsBand",
DBUS_TYPE_STRING, &band);
}
if (rs->driver->query_fast_dormancy) {
dbus_bool_t value = rs->fast_dormancy;
ofono_dbus_dict_append(&dict, "FastDormancy",
DBUS_TYPE_BOOLEAN, &value);
}
if (rs->available_rats) {
const char *rats[sizeof(uint32_t) * CHAR_BIT + 1];
const char **dbus_rats = rats;
int n = 0;
unsigned int i;
for (i = 0; i < sizeof(uint32_t) * CHAR_BIT; i++) {
int tech = 1 << i;
if (!(rs->available_rats & tech))
continue;
rats[n++] = radio_access_mode_to_string(tech);
}
rats[n] = NULL;
ofono_dbus_dict_append_array(&dict, "AvailableTechnologies",
DBUS_TYPE_STRING, &dbus_rats);
}
dbus_message_iter_close_container(&iter, &dict);
return reply;
}
void message_append_properties(struct message *m, DBusMessageIter *dict)
{
const char *state = message_state_to_string(m->state);
ofono_dbus_dict_append(dict, "State", DBUS_TYPE_STRING, &state);
}