/**
* @brief Cancel an ongoing query for a list of available networks.
*
* JSON format:
* request:
* { }
* response:
* {
* "returnValue": <boolean>,
* "errorCode": <integer>,
* "errorString" <string>,
* }
**/
bool _service_network_list_query_cancel_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->network_list_query_cancel) {
g_warning("No implementation available for service networkListQueryCancel API method");
luna_service_message_reply_error_not_implemented(handle, message);
return true;
}
if (!service->network_status_query_pending) {
luna_service_message_reply_custom_error(handle, message, "No network list query pending");
return true;
}
req_data = luna_service_req_data_new(handle, message);
req_data->user_data = service;
service->driver->network_list_query_cancel(service, _service_network_list_query_cancel_finish, req_data);
return true;
}
static bool set_mic_mute_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct audio_service *service = user_data;
const char *payload;
jvalue_ref parsed_obj = NULL;
struct luna_service_req_data *req;
pa_operation *op;
if (!service->context_initialized) {
luna_service_message_reply_custom_error(handle, message, "Not yet initialized");
return true;
}
payload = LSMessageGetPayload(message);
parsed_obj = luna_service_message_parse_and_validate(payload);
if (jis_null(parsed_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
service->mic_mute = luna_service_message_get_boolean(parsed_obj, "micMute", service->mic_mute);
req = luna_service_req_data_new(handle, message);
req->user_data = service;
op = pa_context_get_source_info_list(service->context, mm_sourceinfo_cb, req);
pa_operation_unref(op);
cleanup:
if (!jis_null(parsed_obj))
j_release(&parsed_obj);
return true;
}
static bool volume_down_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct audio_service *service = user_data;
struct luna_service_req_data *req;
int normalized_volume;
if (!service->context_initialized) {
luna_service_message_reply_custom_error(handle, message, "Not yet initialized");
return true;
}
normalized_volume = (service->volume / 10) * 10;
if (normalized_volume == 0)
goto done;
req = luna_service_req_data_new(handle, message);
req->user_data = service;
set_volume(service, normalized_volume - VOLUME_STEP, req);
return true;
done:
luna_service_message_reply_success(handle, message);
return true;
}
/**
* @brief Set the network the modem should connect to.
*
* JSON format:
* request:
* {
* "automatic": <boolean>,
* "id": <string>,
* }
* response:
* {
* "returnValue": <boolean>,
* "errorCode": <integer>,
* "errorString": <string>,
* }
**/
bool _service_network_set_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
jvalue_ref parsed_obj = NULL;
jvalue_ref automatic_obj = NULL;
jvalue_ref id_obj = NULL;
const char *payload;
raw_buffer id_buf;
const char *id = NULL;
bool automatic = false;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->network_set) {
g_warning("No implementation available for service networkSet API method");
luna_service_message_reply_error_not_implemented(handle, message);
goto cleanup;
}
payload = LSMessageGetPayload(message);
parsed_obj = luna_service_message_parse_and_validate(payload);
if (jis_null(parsed_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (!jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("automatic"), &automatic_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
jboolean_get(automatic_obj, &automatic);
if (!automatic) {
if (!jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("id"), &id_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
id_buf = jstring_get(id_obj);
id = id_buf.m_str;
}
req_data = luna_service_req_data_new(handle, message);
service->driver->network_set(service, automatic, id, telephonyservice_common_finish, req_data);
cleanup:
if (!jis_null(parsed_obj))
j_release(&parsed_obj);
return true;
}
/**
* @brief Set the radio access technology mode
*
* JSON format:
* request:
* {
* "mode": <string>,
* }
* response:
* {
* "returnValue": <boolean>,
* "errorCode": <integer>,
* "errorString": <string>,
* }
**/
bool _service_rat_set_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
jvalue_ref parsed_obj = NULL;
jvalue_ref mode_obj = NULL;
const char *payload;
raw_buffer mode_buf;
enum telephony_radio_access_mode mode;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->rat_set) {
g_warning("No implementation available for service ratSet API method");
luna_service_message_reply_error_not_implemented(handle, message);
goto cleanup;
}
payload = LSMessageGetPayload(message);
parsed_obj = luna_service_message_parse_and_validate(payload);
if (jis_null(parsed_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (!jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("mode"), &mode_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
mode_buf = jstring_get(mode_obj);
mode = telephony_radio_access_mode_from_string(mode_buf.m_str);
if (mode < 0) {
luna_service_message_reply_error_invalid_params(handle, message);
goto cleanup;
}
req_data = luna_service_req_data_new(handle, message);
service->driver->rat_set(service, mode, telephonyservice_common_finish, req_data);
cleanup:
if (!jis_null(parsed_obj))
j_release(&parsed_obj);
return true;
}
static bool set_volume_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct audio_service *service = user_data;
const char *payload;
jvalue_ref parsed_obj = NULL;
jvalue_ref volume_obj = NULL;
struct luna_service_req_data *req;
int new_volume = 0;
if (!service->context_initialized) {
luna_service_message_reply_custom_error(handle, message, "Not yet initialized");
return true;
}
payload = LSMessageGetPayload(message);
parsed_obj = luna_service_message_parse_and_validate(payload);
if (jis_null(parsed_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (!jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("volume"), &volume_obj) ||
!jis_number(volume_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
jnumber_get_i32(volume_obj, &new_volume);
if (new_volume < 0 || new_volume > 100) {
luna_service_message_reply_custom_error(handle, message, "Volume out of range. Must be in [0;100]");
goto cleanup;
}
if (service->new_volume == service->volume) {
luna_service_message_reply_custom_error(handle, message,
"Provided volume doesn't differ from current one");
goto cleanup;
}
req = luna_service_req_data_new(handle, message);
req->user_data = service;
set_volume(service, service->new_volume, req);
cleanup:
if (!jis_null(parsed_obj))
j_release(&parsed_obj);
return true;
}
bool service_run_upgrade_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct luna_service_req_data *req_data;
jvalue_ref reply_obj;
bool upgrade_succeeded = true;
g_message("User requested starting a complete system upgrade ...");
if (opkg_new()) {
luna_service_message_reply_error_internal(handle, message);
return true;
}
req_data = luna_service_req_data_new(handle, message);
if (opkg_upgrade_all(system_upgrade_progress_cb, req_data) != 0) {
g_warning("Failed to upgrade the system");
upgrade_succeeded = false;
}
reply_obj = jobject_create();
jobject_put(reply_obj, J_CSTR_TO_JVAL("returnValue"), jboolean_create(upgrade_succeeded));
jobject_put(reply_obj, J_CSTR_TO_JVAL("state"), jstring_create(upgrade_succeeded ? "finished" : "failed"));
if (!luna_service_message_validate_and_send(req_data->handle, req_data->message, reply_obj)) {
luna_service_message_reply_error_internal(req_data->handle, req_data->message);
goto cleanup;
}
if (upgrade_succeeded)
g_message("Successfully finished system upgrade!");
cleanup:
if (req_data)
luna_service_req_data_free(req_data);
opkg_free();
return true;
}
/**
* @brief Query the current radio access technology mode
*
* JSON format:
* request:
* { }
* response:
* {
* "returnValue": <boolean>,
* "errorCode": <integer>,
* "errorString": <string>,
* "extended": {
* "mode": <string>,
* }
* }
**/
bool _service_rat_query_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->rat_query) {
g_warning("No implementation available for service ratQuery API method");
luna_service_message_reply_error_not_implemented(handle, message);
return true;
}
req_data = luna_service_req_data_new(handle, message);
service->driver->rat_query(service, _service_rat_query_finish, req_data);
return true;
}
/**
* @brief Query the id of the network we're connected.
*
* JSON format:
* request:
* { }
* response:
* {
* "returnValue": <boolean>,
* "errorCode": <integer>,
* "errorString": <string>,
* "subscribed": <boolean>,
* "extended": {
* "mccmnc": <string>,
* },
* }
**/
bool _service_network_id_query_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->network_id_query) {
g_warning("No implementation available for service networkIdQuery API method");
luna_service_message_reply_error_not_implemented(handle, message);
return true;
}
req_data = luna_service_req_data_new(handle, message);
req_data->subscribed = luna_service_check_for_subscription_and_process(req_data->handle, req_data->message);
service->driver->network_id_query(service, _service_network_id_query_finish, req_data);
return true;
}
bool _service_power_set_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
struct telephony_service *service = user_data;
struct luna_service_req_data *req_data = NULL;
bool power = false;
jvalue_ref parsed_obj = NULL;
jvalue_ref state_obj = NULL;
jvalue_ref save_obj = NULL;
const char *payload;
bool should_save = false;
if (!service->initialized) {
luna_service_message_reply_custom_error(handle, message, "Backend not initialized");
return true;
}
if (!service->driver || !service->driver->power_set) {
g_warning("No implementation available for service powerSet API method");
luna_service_message_reply_error_not_implemented(handle, message);
goto cleanup;
}
payload = LSMessageGetPayload(message);
parsed_obj = luna_service_message_parse_and_validate(payload);
if (jis_null(parsed_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (!jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("state"), &state_obj)) {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (jstring_equal2(state_obj, J_CSTR_TO_BUF("on")))
power = true;
else if (jstring_equal2(state_obj, J_CSTR_TO_BUF("off")))
power = false;
else if (jstring_equal2(state_obj, J_CSTR_TO_BUF("default"))) {
power = true;
}
else {
luna_service_message_reply_error_bad_json(handle, message);
goto cleanup;
}
if (jobject_get_exists(parsed_obj, J_CSTR_TO_BUF("save"), &save_obj)) {
jboolean_get(save_obj, &should_save);
if (should_save)
telephony_settings_store(TELEPHONY_SETTINGS_TYPE_POWER_STATE,
power ? "{\"state\":true}" : "{\"state\":false}");
}
service->power_off_pending = !power;
req_data = luna_service_req_data_new(handle, message);
req_data->user_data = service;
service->driver->power_set(service, power, _service_power_set_finish, req_data);
cleanup:
if (!jis_null(parsed_obj))
j_release(&parsed_obj);
return true;
}
