static void ussd_change_state(struct ofono_ussd *ussd, int state)
{
const char *value;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(ussd->atom);
if (state == ussd->state)
return;
ussd->state = state;
value = ussd_get_state_string(ussd);
ofono_dbus_signal_property_changed(conn, path,
OFONO_SUPPLEMENTARY_SERVICES_INTERFACE,
"State", DBUS_TYPE_STRING, &value);
}
void ofono_call_volume_set_microphone_volume(struct ofono_call_volume *cv,
unsigned char percent)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cv->atom);
cv->microphone_volume = percent;
if (__ofono_atom_get_registered(cv->atom) == FALSE)
return;
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_VOLUME_INTERFACE,
"MicrophoneVolume",
DBUS_TYPE_BYTE, &percent);
}
void ofono_call_volume_set_muted(struct ofono_call_volume *cv, int muted)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cv->atom);
dbus_bool_t m;
cv->muted = muted;
if (__ofono_atom_get_registered(cv->atom) == FALSE)
return;
m = muted;
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_VOLUME_INTERFACE,
"Muted", DBUS_TYPE_BOOLEAN, &m);
}
void ofono_modem_set_name(struct ofono_modem *modem, const char *name)
{
if (modem->name)
g_free(modem->name);
modem->name = g_strdup(name);
if (modem->driver) {
DBusConnection *conn = ofono_dbus_get_connection();
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Name", DBUS_TYPE_STRING,
&modem->name);
}
}
static void set_online(struct ofono_modem *modem, ofono_bool_t new_online)
{
DBusConnection *conn = ofono_dbus_get_connection();
if (new_online == modem->online)
return;
modem->online = new_online;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Online", DBUS_TYPE_BOOLEAN,
&modem->online);
notify_online_watches(modem);
}
static void radio_set_fast_dormancy(struct ofono_radio_settings *rs,
ofono_bool_t enable)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(rs->atom);
dbus_bool_t value = enable;
if (rs->fast_dormancy == enable)
return;
ofono_dbus_signal_property_changed(conn, path,
OFONO_RADIO_SETTINGS_INTERFACE,
"FastDormancy",
DBUS_TYPE_BOOLEAN, &value);
rs->fast_dormancy = enable;
}
static void query_serial_cb(const struct ofono_error *error,
const char *serial, void *user)
{
struct ofono_devinfo *info = user;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(info->atom);
if (error->type != OFONO_ERROR_TYPE_NO_ERROR)
return;
info->serial = g_strdup(serial);
ofono_dbus_signal_property_changed(conn, path,
OFONO_MODEM_INTERFACE,
"Serial", DBUS_TYPE_STRING,
&info->serial);
}
void ofono_handsfree_voice_recognition_notify(struct ofono_handsfree *hf,
ofono_bool_t enabled)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(hf->atom);
dbus_bool_t dbus_enabled = enabled;
if (hf->voice_recognition == enabled)
return;
hf->voice_recognition = enabled;
ofono_dbus_signal_property_changed(conn, path,
OFONO_HANDSFREE_INTERFACE,
"VoiceRecognition", DBUS_TYPE_BOOLEAN,
&dbus_enabled);
}
static void set_acm_max(struct ofono_call_meter *cm, int value)
{
DBusConnection *conn;
const char *path;
if (cm->acm_max == value)
return;
cm->acm_max = value;
conn = ofono_dbus_get_connection();
path = __ofono_atom_get_path(cm->atom);
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_METER_INTERFACE,
"AccumulatedCallMeterMaximum",
DBUS_TYPE_UINT32, &cm->acm_max);
}
static void set_ppu(struct ofono_call_meter *cm, double value)
{
DBusConnection *conn;
const char *path;
if (cm->ppu == value)
return;
cm->ppu = value;
conn = ofono_dbus_get_connection();
path = __ofono_atom_get_path(cm->atom);
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_METER_INTERFACE,
"PricePerUnit",
DBUS_TYPE_DOUBLE, &cm->ppu);
}
int dundee_device_set_name(struct dundee_device *device, const char *name)
{
DBusConnection *conn = ofono_dbus_get_connection();
DBG("%p name %s", device, name);
g_free(device->name);
device->name = g_strdup(name);
if (device->registered == FALSE)
return 0;
ofono_dbus_signal_property_changed(conn, device->path,
DUNDEE_DEVICE_INTERFACE, "Name",
DBUS_TYPE_STRING, &device->name);
return 0;
}
static void set_bearer(struct ofono_sms *sms, int bearer)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(sms->atom);
const char *value;
if (sms->bearer == bearer)
return;
sms->bearer = bearer;
value = sms_bearer_to_string(sms->bearer);
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"Bearer",
DBUS_TYPE_STRING, &value);
}
void ofono_audio_settings_active_notify(struct ofono_audio_settings *as,
ofono_bool_t active)
{
const char *path = __ofono_atom_get_path(as->atom);
DBusConnection *conn = ofono_dbus_get_connection();
if (as->active == active)
return;
DBG("active %d", active);
as->active = active;
ofono_dbus_signal_property_changed(conn, path,
OFONO_AUDIO_SETTINGS_INTERFACE,
"Active", DBUS_TYPE_BOOLEAN, &as->active);
}
void ofono_audio_settings_mode_notify(struct ofono_audio_settings *as,
const char *mode)
{
const char *path = __ofono_atom_get_path(as->atom);
DBusConnection *conn = ofono_dbus_get_connection();
DBG("mode %s", mode);
g_free(as->mode);
as->mode = g_strdup(mode);
if (as->mode == NULL)
return;
ofono_dbus_signal_property_changed(conn, path,
OFONO_AUDIO_SETTINGS_INTERFACE,
"Mode", DBUS_TYPE_STRING, &as->mode);
}
static void set_alphabet(struct ofono_sms *sms, enum sms_alphabet alphabet)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(sms->atom);
const char *value;
if (sms->alphabet == alphabet)
return;
sms->alphabet = alphabet;
value = sms_alphabet_to_string(sms->alphabet);
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"Alphabet",
DBUS_TYPE_STRING, &value);
}
void message_set_state(struct message *m, enum message_state new_state)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path;
const char *state;
if (m->state == new_state)
return;
path = message_path_from_uuid(m->atom, &m->uuid);
m->state = new_state;
state = message_state_to_string(m->state);
ofono_dbus_signal_property_changed(conn, path, OFONO_MESSAGE_INTERFACE,
"State",
DBUS_TYPE_STRING,
&state);
}
void ofono_handsfree_set_inband_ringing(struct ofono_handsfree *hf,
ofono_bool_t enabled)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(hf->atom);
dbus_bool_t dbus_enabled = enabled;
if (hf->inband_ringing == enabled)
return;
hf->inband_ringing = enabled;
if (__ofono_atom_get_registered(hf->atom) == FALSE)
return;
ofono_dbus_signal_property_changed(conn, path,
OFONO_HANDSFREE_INTERFACE,
"InbandRinging", DBUS_TYPE_BOOLEAN,
&dbus_enabled);
}
static void query_model_cb(const struct ofono_error *error,
const char *model, void *user)
{
struct ofono_devinfo *info = user;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(info->atom);
if (error->type != OFONO_ERROR_TYPE_NO_ERROR)
goto out;
info->model = g_strdup(model);
ofono_dbus_signal_property_changed(conn, path,
OFONO_MODEM_INTERFACE,
"Model", DBUS_TYPE_STRING,
&info->model);
out:
query_revision(info);
}
static void radio_set_rat_mode(struct ofono_radio_settings *rs,
enum ofono_radio_access_mode mode)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path;
const char *str_mode;
if (rs->mode == mode)
return;
rs->mode = mode;
path = __ofono_atom_get_path(rs->atom);
str_mode = radio_access_mode_to_string(rs->mode);
ofono_dbus_signal_property_changed(conn, path,
OFONO_RADIO_SETTINGS_INTERFACE,
"TechnologyPreference",
DBUS_TYPE_STRING, &str_mode);
}
static void set_registration_status(struct ofono_cdma_netreg *cdma_netreg,
enum cdma_netreg_status status)
{
const char *str_status = cdma_netreg_status_to_string(status);
const char *path = __ofono_atom_get_path(cdma_netreg->atom);
DBusConnection *conn = ofono_dbus_get_connection();
cdma_netreg->status = status;
ofono_dbus_signal_property_changed(conn, path,
OFONO_CDMA_NETWORK_REGISTRATION_INTERFACE,
"Status", DBUS_TYPE_STRING,
&str_status);
if (cdma_netreg->status == CDMA_NETWORK_REGISTRATION_STATUS_REGISTERED
|| cdma_netreg->status ==
CDMA_NETWORK_REGISTRATION_STATUS_ROAMING)
if (cdma_netreg->driver->serving_system != NULL)
cdma_netreg->driver->serving_system(cdma_netreg,
serving_system_callback, cdma_netreg);
}
void __ofono_modem_dec_emergency_mode(struct ofono_modem *modem)
{
DBusConnection *conn = ofono_dbus_get_connection();
dbus_bool_t emergency = FALSE;
if (modem->emergency == 0) {
ofono_error("emergency mode is already deactivated!!!");
return;
}
if (modem->emergency > 1)
goto out;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Emergency", DBUS_TYPE_BOOLEAN,
&emergency);
out:
modem->emergency--;
}
static void mv_set_callback(const struct ofono_error *error, void *data)
{
struct ofono_call_volume *cv = data;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cv->atom);
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
__ofono_dbus_pending_reply(&cv->pending,
__ofono_error_failed(cv->pending));
return;
}
cv->microphone_volume = cv->pending_volume;
__ofono_dbus_pending_reply(&cv->pending,
dbus_message_new_method_return(cv->pending));
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_VOLUME_INTERFACE,
"MicrophoneVolume",
DBUS_TYPE_BYTE, &cv->microphone_volume);
}
static void set_sca(struct ofono_sms *sms,
const struct ofono_phone_number *sca)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(sms->atom);
const char *value;
if (sms->sca.type == sca->type &&
!strcmp(sms->sca.number, sca->number))
return;
sms->sca.type = sca->type;
strncpy(sms->sca.number, sca->number, OFONO_MAX_PHONE_NUMBER_LENGTH);
sms->sca.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
value = phone_number_to_string(&sms->sca);
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"ServiceCenterAddress",
DBUS_TYPE_STRING, &value);
}
void ofono_handsfree_battchg_notify(struct ofono_handsfree *hf,
unsigned char level)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(hf->atom);
if (hf == NULL)
return;
if (hf->battchg == level)
return;
hf->battchg = level;
if (__ofono_atom_get_registered(hf->atom) == FALSE)
return;
ofono_dbus_signal_property_changed(conn, path,
OFONO_HANDSFREE_INTERFACE,
"BatteryChargeLevel", DBUS_TYPE_BYTE,
&level);
}
static void voicerec_set_cb(const struct ofono_error *error, void *data)
{
struct ofono_handsfree *hf = data;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(hf->atom);
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
__ofono_dbus_pending_reply(&hf->pending,
__ofono_error_failed(hf->pending));
return;
}
hf->voice_recognition = hf->voice_recognition_pending;
__ofono_dbus_pending_reply(&hf->pending,
dbus_message_new_method_return(hf->pending));
ofono_dbus_signal_property_changed(conn, path,
OFONO_HANDSFREE_INTERFACE,
"VoiceRecognition",
DBUS_TYPE_BOOLEAN,
&hf->voice_recognition);
}
static gboolean set_powered_timeout(gpointer user)
{
struct ofono_modem *modem = user;
DBG("modem: %p", modem);
modem->timeout = 0;
if (modem->powered_pending == FALSE) {
DBusConnection *conn = ofono_dbus_get_connection();
dbus_bool_t powered = FALSE;
set_online(modem, FALSE);
modem->powered = FALSE;
notify_powered_watches(modem);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
} else {
modem->powered_pending = modem->powered;
}
if (modem->pending != NULL) {
DBusMessage *reply;
reply = __ofono_error_timed_out(modem->pending);
__ofono_dbus_pending_reply(&modem->pending, reply);
if (modem->lockdown)
lockdown_remove(modem);
}
return FALSE;
}
static void muted_set_callback(const struct ofono_error *error, void *data)
{
struct ofono_call_volume *cv = data;
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cv->atom);
dbus_bool_t m;
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
cv->muted_pending = cv->muted;
__ofono_dbus_pending_reply(&cv->pending,
__ofono_error_failed(cv->pending));
return;
}
cv->muted = cv->muted_pending;
m = cv->muted;
__ofono_dbus_pending_reply(&cv->pending,
dbus_message_new_method_return(cv->pending));
ofono_dbus_signal_property_changed(conn, path,
OFONO_CALL_VOLUME_INTERFACE,
"Muted", DBUS_TYPE_BOOLEAN, &m);
}
static gboolean handle_command_set_idle_text(const struct stk_command *cmd,
struct stk_response *rsp,
struct ofono_stk *stk)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(stk->atom);
const char *idle_mode_text;
if (stk->idle_mode_text) {
g_free(stk->idle_mode_text);
stk->idle_mode_text = NULL;
}
if (cmd->setup_idle_mode_text.text)
stk->idle_mode_text = g_strdup(cmd->setup_idle_mode_text.text);
idle_mode_text = stk->idle_mode_text ? stk->idle_mode_text : "";
ofono_dbus_signal_property_changed(conn, path, OFONO_STK_INTERFACE,
"IdleModeText",
DBUS_TYPE_STRING,
&idle_mode_text);
return TRUE;
}
static DBusMessage *sms_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_sms *sms = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (sms->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (!strcmp(property, "ServiceCenterAddress")) {
const char *value;
struct ofono_phone_number sca;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (strlen(value) == 0 || !valid_phone_number_format(value))
return __ofono_error_invalid_format(msg);
if (sms->driver->sca_set == NULL ||
sms->driver->sca_query == NULL)
return __ofono_error_not_implemented(msg);
string_to_phone_number(value, &sca);
sms->pending = dbus_message_ref(msg);
sms->driver->sca_set(sms, &sca, sca_set_callback, sms);
return NULL;
}
if (!strcmp(property, "Bearer")) {
const char *value;
int bearer;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (sms_bearer_from_string(value, &bearer) != TRUE)
return __ofono_error_invalid_format(msg);
if (sms->driver->bearer_set == NULL ||
sms->driver->bearer_query == NULL)
return __ofono_error_not_implemented(msg);
sms->pending = dbus_message_ref(msg);
sms->driver->bearer_set(sms, bearer, bearer_set_callback, sms);
return NULL;
}
if (!strcmp(property, "UseDeliveryReports")) {
const char *path = __ofono_atom_get_path(sms->atom);
dbus_bool_t value;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
if (sms->use_delivery_reports != (ofono_bool_t) value) {
sms->use_delivery_reports = value;
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"UseDeliveryReports",
DBUS_TYPE_BOOLEAN, &value);
}
return NULL;
}
if (!strcmp(property, "Alphabet")) {
const char *value;
enum sms_alphabet alphabet;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (!sms_alphabet_from_string(value, &alphabet))
return __ofono_error_invalid_format(msg);
set_alphabet(sms, alphabet);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *set_property_lockdown(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
DBusConnection *conn = ofono_dbus_get_connection();
ofono_bool_t lockdown;
dbus_bool_t powered;
const char *caller;
int err;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &lockdown);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
caller = dbus_message_get_sender(msg);
if (modem->lockdown && g_strcmp0(caller, modem->lock_owner))
return __ofono_error_access_denied(msg);
if (modem->lockdown == lockdown)
return dbus_message_new_method_return(msg);
if (lockdown == FALSE) {
lockdown_remove(modem);
goto done;
}
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
modem->lock_owner = g_strdup(caller);
modem->lock_watch = g_dbus_add_disconnect_watch(conn,
modem->lock_owner, lockdown_disconnect,
modem, NULL);
if (modem->lock_watch == 0) {
g_free(modem->lock_owner);
modem->lock_owner = NULL;
return __ofono_error_failed(msg);
}
modem->lockdown = lockdown;
if (modem->powered == FALSE)
goto done;
err = set_powered(modem, FALSE);
if (err < 0) {
if (err != -EINPROGRESS) {
lockdown_remove(modem);
return __ofono_error_failed(msg);
}
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
set_online(modem, FALSE);
powered = FALSE;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
done:
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&lockdown);
return NULL;
}
