/*
* Note __ofono_modem_get_list() will abort if it cannot allocate
* memory; so no error path or cleanup is needed.
*/
static DBusMessage *manager_get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessageIter iter;
DBusMessageIter dict;
DBusMessage *reply;
const char **modems;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
modems = __ofono_modem_get_list();
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_array(&dict, "Modems", DBUS_TYPE_OBJECT_PATH,
&modems);
g_free(modems);
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;
}
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 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 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;
}
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 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;
}
