sms_get_properties) },
{ GDBUS_ASYNC_METHOD("SetProperty",
GDBUS_ARGS({ "property", "s" }, { "value", "v" }),
NULL, sms_set_property) },
{ GDBUS_ASYNC_METHOD("SendMessage",
GDBUS_ARGS({ "to", "s" }, { "text", "s" }),
GDBUS_ARGS({ "path", "o" }),
sms_send_message) },
{ GDBUS_METHOD("GetMessages",
NULL, GDBUS_ARGS({ "messages", "a(oa{sv})" }),
sms_get_messages) },
{ }
};
static const GDBusSignalTable sms_manager_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
{ GDBUS_SIGNAL("IncomingMessage",
GDBUS_ARGS({ "message", "s" }, { "info", "a{sv}" })) },
{ GDBUS_SIGNAL("ImmediateMessage",
GDBUS_ARGS({ "message", "s" }, { "info", "a{sv}" })) },
{ GDBUS_SIGNAL("MessageAdded",
GDBUS_ARGS({ "path", "o" },
{ "properties", "a{sv}" })) },
{ GDBUS_SIGNAL("MessageRemoved",
GDBUS_ARGS({ "path", "o" })) },
{ }
};
static gboolean compute_incoming_msgid(GSList *sms_list,
struct ofono_uuid *uuid)
{
}
static const GDBusMethodTable device_methods[] = {
{ GDBUS_METHOD("GetProperties",
NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
device_get_properties)
},
{ GDBUS_ASYNC_METHOD("SetProperty",
GDBUS_ARGS({ "property", "s" }, { "value", "v" }),
NULL, device_set_property)
},
{ }
};
static const GDBusSignalTable device_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" }))
},
{ }
};
static int register_device(struct dundee_device *device)
{
DBusConnection *conn = ofono_dbus_get_connection();
DBusMessage *signal;
DBusMessageIter iter;
DBusMessageIter dict;
DBG("%p path %s", device, device->path);
if (!g_dbus_register_interface(conn, device->path,
DUNDEE_DEVICE_INTERFACE,
card->msg = dbus_message_ref(msg);
return NULL;
}
static const GDBusMethodTable card_methods[] = {
{ GDBUS_METHOD("GetProperties",
NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
card_get_properties) },
{ GDBUS_ASYNC_METHOD("Connect", NULL, NULL, card_connect) },
{ }
};
static const GDBusSignalTable card_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
{ }
};
struct ofono_handsfree_card *ofono_handsfree_card_create(unsigned int vendor,
enum ofono_handsfree_card_type type,
const char *driver,
void *data)
{
struct ofono_handsfree_card *card;
GSList *l;
card = g_new0(struct ofono_handsfree_card, 1);
card->type = type;
card->selected_codec = HFP_CODEC_CVSD;
remove) },
{ GDBUS_METHOD("GetConnections", NULL,
GDBUS_ARGS({ "connections", "a(oa{sv})" }),
get_connections) },
{ GDBUS_METHOD("RegisterAgent",
GDBUS_ARGS({ "path", "o" }), NULL,
register_agent) },
{ GDBUS_METHOD("UnregisterAgent",
GDBUS_ARGS({ "path", "o" }), NULL,
unregister_agent) },
{ },
};
static const GDBusSignalTable manager_signals[] = {
{ GDBUS_SIGNAL("ConnectionAdded",
GDBUS_ARGS({ "identifier", "o" },
{ "properties", "a{sv}" })) },
{ GDBUS_SIGNAL("ConnectionRemoved",
GDBUS_ARGS({ "identifier", "o" })) },
{ },
};
int __vpn_manager_init(void)
{
DBG("");
connection = connman_dbus_get_connection();
if (connection == NULL)
return -1;
g_dbus_register_interface(connection, VPN_MANAGER_PATH,
properties_get) },
{ GDBUS_ASYNC_METHOD("Set",
GDBUS_ARGS({ "interface", "s" }, { "name", "s" },
{ "value", "v" }),
NULL,
properties_set) },
{ GDBUS_METHOD("GetAll",
GDBUS_ARGS({ "interface", "s" }),
GDBUS_ARGS({ "properties", "a{sv}" }),
properties_get_all) },
{ }
};
static const GDBusSignalTable properties_signals[] = {
{ GDBUS_SIGNAL("PropertiesChanged",
GDBUS_ARGS({ "interface", "s" },
{ "changed_properties", "a{sv}" },
{ "invalidated_properties", "as"})) },
{ }
};
static void append_name(gpointer data, gpointer user_data)
{
char *name = data;
DBusMessageIter *iter = user_data;
dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &name);
}
static void emit_interfaces_removed(struct generic_data *data)
{
DBusMessage *signal;
request_private_network) },
{ GDBUS_METHOD("ReleasePrivateNetwork",
GDBUS_ARGS({ "path", "o" }), NULL,
release_private_network) },
{ GDBUS_ASYNC_METHOD("RegisterPeerService",
GDBUS_ARGS({ "specification", "a{sv}" },
{ "master", "b" }), NULL,
register_peer_service) },
{ GDBUS_METHOD("UnregisterPeerService",
GDBUS_ARGS({ "specification", "a{sv}" }), NULL,
unregister_peer_service) },
{ },
};
static const GDBusSignalTable manager_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
{ GDBUS_SIGNAL("TechnologyAdded",
GDBUS_ARGS({ "path", "o" },
{ "properties", "a{sv}" })) },
{ GDBUS_SIGNAL("TechnologyRemoved",
GDBUS_ARGS({ "path", "o" })) },
{ GDBUS_SIGNAL("ServicesChanged",
GDBUS_ARGS({ "changed", "a(oa{sv})" },
{ "removed", "ao" })) },
{ GDBUS_SIGNAL("PeersChanged",
GDBUS_ARGS({ "changed", "a(oa{sv})" },
{ "removed", "ao" })) },
{ },
};
int __connman_manager_init(void)
os->aborted = TRUE;
return dbus_message_new_method_return(msg);
}
static const GDBusMethodTable manager_methods[] = {
{ GDBUS_METHOD("RegisterAgent",
GDBUS_ARGS({ "agent", "o" }), NULL, register_agent) },
{ GDBUS_METHOD("UnregisterAgent",
GDBUS_ARGS({ "agent", "o" }), NULL, unregister_agent) },
{ }
};
static const GDBusSignalTable manager_signals[] = {
{ GDBUS_SIGNAL("TransferStarted", GDBUS_ARGS({ "transfer", "o"})) },
{ GDBUS_SIGNAL("TransferCompleted", GDBUS_ARGS({ "transfer", "o" },
{ "success", "b" })) },
{ GDBUS_SIGNAL("SessionCreated", GDBUS_ARGS({ "session", "o" })) },
{ GDBUS_SIGNAL("SessionRemoved", GDBUS_ARGS({ "session", "o" })) },
{ }
};
static const GDBusMethodTable transfer_methods[] = {
{ GDBUS_METHOD("Cancel", NULL, NULL, transfer_cancel) },
{ }
};
static const GDBusSignalTable transfer_signals[] = {
{ GDBUS_SIGNAL("Progress", GDBUS_ARGS({ "total", "i" },
{ "transferred", "i" })) },
static const GDBusMethodTable cm_methods[] = {
{ GDBUS_ASYNC_METHOD("GetProperties",
NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
cm_get_properties) },
{ GDBUS_ASYNC_METHOD("SetProperty",
GDBUS_ARGS({ "property", "s" }, { "value", "v" },
{ "password", "s" }),
NULL, cm_set_property) },
{ GDBUS_ASYNC_METHOD("Reset",
GDBUS_ARGS({ "passoword", "s" }), NULL,
cm_acm_reset) },
{ }
};
static const GDBusSignalTable cm_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "property", "s" }, { "value", "v" })) },
{ GDBUS_SIGNAL("NearMaximumWarning", NULL) },
{ }
};
void ofono_call_meter_changed_notify(struct ofono_call_meter *cm, int new_value)
{
set_call_meter(cm, new_value);
}
void ofono_call_meter_maximum_notify(struct ofono_call_meter *cm)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cm->atom);
g_dbus_emit_signal(conn, path, OFONO_CALL_METER_INTERFACE,
get_properties) },
{ GDBUS_METHOD("DefaultAdapter",
NULL, GDBUS_ARGS({ "adapter", "o" }),
default_adapter) },
{ GDBUS_METHOD("FindAdapter",
GDBUS_ARGS({ "pattern", "s" }),
GDBUS_ARGS({ "adapter", "o" }),
find_adapter) },
{ GDBUS_DEPRECATED_METHOD("ListAdapters",
NULL, GDBUS_ARGS({ "adapters", "ao" }),
list_adapters) },
{ }
};
static const GDBusSignalTable manager_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
{ GDBUS_SIGNAL("AdapterAdded",
GDBUS_ARGS({ "adapter", "o" })) },
{ GDBUS_SIGNAL("AdapterRemoved",
GDBUS_ARGS({ "adapter", "o" })) },
{ GDBUS_SIGNAL("DefaultAdapterChanged",
GDBUS_ARGS({ "adapter", "o" })) },
{ }
};
dbus_bool_t manager_init(DBusConnection *conn, const char *path)
{
connection = conn;
snprintf(base_path, sizeof(base_path), "/org/bluez/%d", getpid());
GDBUS_ARGS({ "command", "s" }),
GDBUS_ARGS({ "result_name", "s" }, { "value", "v" }),
ussd_initiate) },
{ GDBUS_ASYNC_METHOD("Respond",
GDBUS_ARGS({ "reply", "s" }),
GDBUS_ARGS({ "result", "s" }),
ussd_respond) },
{ GDBUS_ASYNC_METHOD("Cancel", NULL, NULL, ussd_cancel) },
{ GDBUS_METHOD("GetProperties",
NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
ussd_get_properties) },
{ }
};
static const GDBusSignalTable ussd_signals[] = {
{ GDBUS_SIGNAL("NotificationReceived",
GDBUS_ARGS({ "message", "s" })) },
{ GDBUS_SIGNAL("RequestReceived",
GDBUS_ARGS({ "message", "s" })) },
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
{ }
};
int ofono_ussd_driver_register(const struct ofono_ussd_driver *d)
{
DBG("driver: %p, name: %s", d, d->name);
if (d->probe == NULL)
return -EINVAL;
g_drivers = g_slist_prepend(g_drivers, (void *) d);
static GSList *g_drivers;
struct ofono_cdma_sms {
const struct ofono_cdma_sms_driver *driver;
void *driver_data;
struct ofono_atom *atom;
};
static const GDBusMethodTable cdma_sms_manager_methods[] = {
/* TODO */
{ }
};
static const GDBusSignalTable cdma_sms_manager_signals[] = {
{ GDBUS_SIGNAL("IncomingMessage",
GDBUS_ARGS({ "message", "s"}, { "info", "a{sv}" })) },
/* TODO */
{ }
};
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;
return reply;
}
return dbus_message_new_error(msg, DBUS_ERROR_FAILED,
"Unsupported property");
}
static const GDBusMethodTable methods[] = {
{ GDBUS_METHOD("Get",
GDBUS_ARGS({ "interface", "s" }, { "key", "s" }),
GDBUS_ARGS({ "property", "v" }), property_get) },
{ },
};
static const GDBusSignalTable signals[] = {
{ GDBUS_SIGNAL("PropertiesChanged",
GDBUS_ARGS({ "properties", "a{sv}" })) },
{ GDBUS_SIGNAL("StateChanged",
GDBUS_ARGS({ "state", "u" })) },
{ },
};
static int nmcompat_init(void)
{
DBG("");
connection = connman_dbus_get_connection();
if (!connection)
return -1;
if (!g_dbus_request_name(connection, NM_SERVICE, NULL)) {
connman_error("nmcompat: failed to register service");
GDBUS_ARGS({ "level", "u" }), NULL,
battery_level) },
{ GDBUS_METHOD("RoamingStatus",
GDBUS_ARGS({ "roaming", "b" }), NULL,
roaming_status) },
{ GDBUS_METHOD("RegistrationStatus",
GDBUS_ARGS({ "registration", "b" }), NULL,
registration_status) },
{ GDBUS_METHOD("SetSubscriberNumber",
GDBUS_ARGS({ "number", "s" }), NULL,
set_subscriber_number) },
{ }
};
static const GDBusSignalTable dummy_signals[] = {
{ GDBUS_SIGNAL("VoiceDial", NULL) },
{ }
};
int telephony_init(uint32_t disabled_features, uint32_t disabled_supp_features,
enum batt_info_source batt, void *batt_param,
gchar *last_number_path)
{
uint32_t features = AG_FEATURE_REJECT_A_CALL |
AG_FEATURE_ENHANCED_CALL_STATUS |
AG_FEATURE_EXTENDED_ERROR_RESULT_CODES;
DBG("");
features &= ~disabled_features;
