static void
on_message (FridaScript * script,
const gchar * message,
GBytes * data,
gpointer user_data)
{
JsonParser * parser;
JsonObject * root;
const gchar * type;
parser = json_parser_new ();
json_parser_load_from_data (parser, message, -1, NULL);
root = json_node_get_object (json_parser_get_root (parser));
type = json_object_get_string_member (root, "type");
if (strcmp (type, "log") == 0)
{
const gchar * log_message;
log_message = json_object_get_string_member (root, "payload");
g_print ("%s\n", log_message);
}
else
{
g_print ("on_message: %s\n", message);
}
g_object_unref (parser);
}
static gboolean _piwigo_api_create_new_album(dt_storage_piwigo_params_t *p)
{
GList *args = NULL;
args = _piwigo_query_add_arguments(args, "method", "pwg.categories.add");
args = _piwigo_query_add_arguments(args, "name", p->album);
if(p->parent_album_id != 0)
{
char pid[100];
snprintf(pid, sizeof(pid), "%"PRId64, p->parent_album_id);
args = _piwigo_query_add_arguments(args, "parent", pid);
}
args = _piwigo_query_add_arguments(args, "status", p->privacy==0?"public":"private");
_piwigo_api_post(p->api, args, NULL, FALSE);
g_list_free(args);
if (!p->api->response || p->api->error_occured)
{
return FALSE;
}
else
{
JsonObject *result = json_node_get_object(json_object_get_member(p->api->response, "result"));
// set new album id in paremeter
p->album_id = json_object_get_int_member(result, "id");
}
return TRUE;
}
static gboolean
parse_review (AsReview *review, const gchar *our_username, JsonNode *node)
{
JsonObject *object;
gint64 star_rating;
g_autofree gchar *id_string = NULL;
if (!JSON_NODE_HOLDS_OBJECT (node))
return FALSE;
object = json_node_get_object (node);
if (g_strcmp0 (our_username, json_object_get_string_member (object, "reviewer_username")) == 0)
as_review_add_flags (review, AS_REVIEW_FLAG_SELF);
as_review_set_reviewer_name (review, json_object_get_string_member (object, "reviewer_displayname"));
as_review_set_summary (review, json_object_get_string_member (object, "summary"));
as_review_set_description (review, json_object_get_string_member (object, "review_text"));
as_review_set_version (review, json_object_get_string_member (object, "version"));
star_rating = json_object_get_int_member (object, "rating");
if (star_rating > 0)
as_review_set_rating (review, (gint) (star_rating * 20 - 10));
as_review_set_date (review, parse_date_time (json_object_get_string_member (object, "date_created")));
id_string = g_strdup_printf ("%" G_GINT64_FORMAT, json_object_get_int_member (object, "id"));
as_review_add_metadata (review, "ubuntu-id", id_string);
return TRUE;
}
gboolean torrent_has_tracker(JsonObject * t, GRegex * rx, gchar * search)
{
GList *trackers;
GList *li;
gboolean ret = FALSE;
trackers = json_array_get_elements(torrent_get_tracker_stats(t));
for (li = trackers; li; li = g_list_next(li)) {
JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
const gchar *trackerAnnounce = tracker_stats_get_announce(tracker);
gchar *trackerAnnounceHost =
trg_gregex_get_first(rx, trackerAnnounce);
int cmpResult = g_strcmp0(trackerAnnounceHost, search);
g_free(trackerAnnounceHost);
if (!cmpResult) {
ret = TRUE;
break;
}
}
g_list_free(trackers);
return ret;
}
static JsonObject *gphoto_parse_response(dt_gphoto_context_t *ctx, GString *response)
{
GError *error = NULL;
gboolean ret = json_parser_load_from_data(ctx->json_parser, response->str, response->len, &error);
if(ret)
{
JsonNode *root = json_parser_get_root(ctx->json_parser);
// we should always have a dict
g_return_val_if_fail((json_node_get_node_type(root) == JSON_NODE_OBJECT), NULL);
JsonObject *rootdict = json_node_get_object(root);
if(json_object_has_member(rootdict, "error"))
{
JsonObject *errorstruct = json_object_get_object_member(rootdict, "error");
g_return_val_if_fail((errorstruct != NULL), NULL);
const gchar *errormessage = json_object_get_string_member(errorstruct, "message");
g_return_val_if_fail((errormessage != NULL), NULL);
g_string_assign(ctx->errmsg, errormessage);
return NULL;
}
return rootdict;
}
else // not a json response, can be the upload-token
{
ctx->response = g_string_new(response->str);
return NULL;
}
}
static void
progress_cb (JsonObject *result, gpointer user_data)
{
GsApp *app = user_data;
JsonArray *tasks;
GList *task_list, *l;
gint64 done = 0, total = 0;
tasks = json_object_get_array_member (result, "tasks");
task_list = json_array_get_elements (tasks);
for (l = task_list; l != NULL; l = l->next) {
JsonObject *task, *progress;
gint64 task_done, task_total;
task = json_node_get_object (l->data);
progress = json_object_get_object_member (task, "progress");
task_done = json_object_get_int_member (progress, "done");
task_total = json_object_get_int_member (progress, "total");
done += task_done;
total += task_total;
}
gs_app_set_progress (app, (guint) (100 * done / total));
g_list_free (task_list);
}
static void
skypeweb_got_self_details(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonObject *userobj;
const gchar *old_alias;
const gchar *displayname = NULL;
const gchar *username;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT)
return;
userobj = json_node_get_object(node);
username = json_object_get_string_member(userobj, "username");
g_free(sa->username); sa->username = g_strdup(username);
old_alias = purple_account_get_private_alias(sa->account);
if (!old_alias || !*old_alias) {
if (json_object_has_member(userobj, "displayname"))
displayname = json_object_get_string_member(userobj, "displayname");
if (!displayname || g_str_equal(displayname, username))
displayname = json_object_get_string_member(userobj, "firstname");
if (displayname)
purple_account_set_private_alias(sa->account, displayname);
}
if (!PURPLE_CONNECTION_IS_CONNECTED(sa->pc)) {
skypeweb_do_all_the_things(sa);
}
}
END_TEST
START_TEST (test_cometd_new_publish_message)
{
cometd_conn_set_client_id(g_instance->conn, "testid");
const char* expected_channel = "/baz/bar";
JsonNode* node = cometd_json_str2node("{ \"hey\": \"now\" }");
JsonNode* message = cometd_new_publish_message(g_instance,
expected_channel,
node);
JsonObject* obj = json_node_get_object(message);
const gchar* actual_channel = json_object_get_string_member(obj,
COMETD_MSG_CHANNEL_FIELD);
ck_assert_str_eq(expected_channel, actual_channel);
JsonObject* data = json_object_get_object_member(obj,
COMETD_MSG_DATA_FIELD);
const char* value = json_object_get_string_member(data, "hey");
ck_assert_str_eq("now", value);
json_node_free(message);
json_node_free(node);
}
END_TEST
static void add_foo(const cometd* h, JsonNode* n)
{
JsonObject* obj = json_node_get_object(n);
json_object_set_int_member(obj, "foo", 1);
}
static void
process_results (RBPodcastSearchITunes *search, JsonParser *parser)
{
JsonObject *container;
JsonArray *results;
guint i;
container = json_node_get_object (json_parser_get_root (parser));
results = json_node_get_array (json_object_get_member (container, "results"));
for (i = 0; i < json_array_get_length (results); i++) {
JsonObject *feed;
RBPodcastChannel *channel;
feed = json_array_get_object_element (results, i);
/* check wrapperType==track, kind==podcast ? */
channel = g_new0 (RBPodcastChannel, 1);
channel->url = g_strdup (json_object_get_string_member (feed, "collectionViewUrl"));
channel->title = g_strdup (json_object_get_string_member (feed, "collectionName"));
channel->author = g_strdup (json_object_get_string_member (feed, "artistName"));
channel->img = g_strdup (json_object_get_string_member (feed, "artworkUrl100")); /* 100? */
channel->is_opml = FALSE;
channel->num_posts = json_object_get_int_member (feed, "trackCount");
rb_debug ("got result %s (%s)", channel->title, channel->url);
rb_podcast_search_result (RB_PODCAST_SEARCH (search), channel);
rb_podcast_parse_channel_free (channel);
}
}
static gboolean
ipcam_event_input_msg_handler_get_action_impl(IpcamMessageHandler *handler, JsonNode *request, JsonNode **response)
{
JsonBuilder *builder = json_builder_new();
JsonArray *req_array;
int i;
req_array = json_object_get_array_member(json_node_get_object(request), "items");
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_object(builder);
for (i = 0; i < json_array_get_length(req_array); i++)
{
const gchar *name = json_array_get_string_element(req_array, i);
if (g_str_equal(name, "input1") ||
g_str_equal(name, "input2"))
{
json_builder_set_member_name(builder, name);
json_builder_begin_object(builder);
ipcam_event_input_msg_handler_read_param(IPCAM_EVENT_INPUT_MSG_HANDLER(handler), builder, name);
json_builder_end_object(builder);
}
}
json_builder_end_object(builder);
json_builder_end_object(builder);
*response = json_builder_get_root(builder);
g_object_unref(builder);
return TRUE;
}
static GType
object_peek_type (JsonNode *node)
{
JsonObject *obj;
const gchar *type_str;
if (!node ||
!JSON_NODE_HOLDS_OBJECT(node) ||
!(obj = json_node_get_object(node)) ||
!json_object_has_member(obj, "type") ||
!JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "type")) ||
!(type_str = json_object_get_string_member(obj, "type"))) {
return FALSE;
}
if (!g_strcmp0(type_str, "note")) {
return CATCH_TYPE_NOTE;
} else if (!g_strcmp0(type_str, "image")) {
return CATCH_TYPE_IMAGE;
} else if (!g_strcmp0(type_str, "audio")) {
return CATCH_TYPE_AUDIO;
} else if (!g_strcmp0(type_str, "comment")) {
return CATCH_TYPE_COMMENT;
} else if (!g_strcmp0(type_str, "attachment")) {
return CATCH_TYPE_ATTACHMENT;
} else if (!g_strcmp0(type_str, "checkitem")) {
return CATCH_TYPE_CHECK_ITEM;
}
return G_TYPE_NONE;
}
static void
trg_torrent_model_count_peers(TrgTorrentModel * model,
GtkTreeIter * iter, JsonObject * t)
{
GList *trackersList =
json_array_get_elements(torrent_get_tracker_stats(t));
gint64 seeders = 0;
gint64 leechers = 0;
gint64 downloads = 0;
GList *li;
for (li = trackersList; li; li = g_list_next(li)) {
JsonObject *tracker = json_node_get_object((JsonNode *) li->data);
seeders += tracker_stats_get_seeder_count(tracker);
leechers += tracker_stats_get_leecher_count(tracker);
downloads += tracker_stats_get_download_count(tracker);
}
g_list_free(trackersList);
gtk_list_store_set(GTK_LIST_STORE(model), iter, TORRENT_COLUMN_SEEDS,
seeders, TORRENT_COLUMN_LEECHERS, leechers,
TORRENT_COLUMN_DOWNLOADS, downloads, -1);
}
JsonNode* cometd_ping_ls(cometd* h, char *target)
{
JsonObject *adviceObject = json_object_new();
JsonNode *adviceNode = json_node_new(JSON_NODE_OBJECT);
JsonNode *adviceRoot = json_node_init_object(adviceNode, adviceObject);
adviceObject = json_node_get_object(adviceRoot);
json_object_set_string_member(adviceObject, "folder", "/");
JsonNode* root = json_node_new(JSON_NODE_OBJECT);
JsonObject* obj = json_object_new();
gint64 seed = ++(h->conn->msg_id_seed);
char* connection_type = cometd_current_transport(h)->name;
json_object_set_int_member (obj, COMETD_MSG_ID_FIELD, seed);
json_object_set_string_member(obj, COMETD_MSG_CHANNEL_FIELD, target);
json_object_set_string_member(obj, "connectionType", connection_type);
json_object_set_member(obj, "data", adviceRoot);
json_object_set_string_member(obj, "clientId", cometd_conn_client_id(h->conn));
json_node_take_object(root, obj);
return(root);
}
/**
* json_reader_count_members:
* @reader: a #JsonReader
*
* Counts the members of the current position, if @reader is
* positioned on an object
*
* Return value: the number of members, or -1. In case of failure
* the #JsonReader is set in an error state
*
* Since: 0.12
*/
gint
json_reader_count_members (JsonReader *reader)
{
JsonReaderPrivate *priv;
g_return_val_if_fail (JSON_IS_READER (reader), -1);
priv = reader->priv;
if (priv->current_node == NULL)
{
json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE,
_("No node available at the current position"));
return -1;
}
if (!JSON_NODE_HOLDS_OBJECT (priv->current_node))
{
json_reader_set_error (reader, JSON_READER_ERROR_NO_OBJECT,
_("The current position holds a '%s' and not an object"),
json_node_type_get_name (JSON_NODE_TYPE (priv->current_node)));
return -1;
}
return json_object_get_size (json_node_get_object (priv->current_node));
}
void
snarf_alert_add_tags(snarf_alert_t *alert, char *tags)
{
gchar **taglist = NULL;
char **p = NULL;
int tagcount = 0;
char *tag = NULL;
JsonObject * rootobj = json_node_get_object (alert->msg);
JsonObject * envelopeobj = json_object_get_object_member(rootobj,"envelope");
JsonArray *analysis_tags=json_array_new();
taglist = g_strsplit_set(tags, ", \t\n\v\f\r", 0);
for (p = taglist, tagcount = 0; p && *p; p++)
{
tag=*p;
if (!strlen(tag))
{
continue;
}
json_array_add_string_element(analysis_tags,tag);
}
json_object_set_array_member(envelopeobj,"analysis_tags",analysis_tags);
}
static GHashTable* toHashTable(std::string msg)
{
g_print("toHashTable\n");
JsonParser *parser;
GError *error = NULL;
parser = json_parser_new ();
GHashTable *map = g_hash_table_new(g_str_hash, g_str_equal);
if (json_parser_load_from_data (parser, msg.c_str(), -1, &error))
{
JsonNode *root;
JsonObject *object;
g_assert (NULL != json_parser_get_root (parser));
root = json_parser_get_root (parser);
if (JSON_NODE_TYPE (root) == JSON_NODE_OBJECT)
{
object = json_node_get_object (root);
g_assert (object != NULL);
json_object_foreach_member(object, parseMembers, map);
}
}
else
{
g_error_free (error);
}
g_object_unref (parser);
return map;
}
static GlideActor *
glide_window_construct_copy_buffer (GlideWindow *w)
{
JsonObject *obj = json_node_get_object (w->priv->copy_buffer);
return glide_actor_construct_from_json (obj);
}
JsonNode *
builder_source_to_json (BuilderSource *self)
{
JsonNode *node;
JsonObject *object;
const gchar *type = NULL;
node = json_gobject_serialize (G_OBJECT (self));
object = json_node_get_object (node);
if (BUILDER_IS_SOURCE_ARCHIVE (self))
type = "archive";
else if (BUILDER_IS_SOURCE_FILE (self))
type = "file";
else if (BUILDER_IS_SOURCE_SCRIPT (self))
type = "script";
else if (BUILDER_IS_SOURCE_SHELL (self))
type = "shell";
else if (BUILDER_IS_SOURCE_PATCH (self))
type = "patch";
else if (BUILDER_IS_SOURCE_GIT (self))
type = "git";
else if (BUILDER_IS_SOURCE_BZR (self))
type = "bzr";
else
g_warning ("Unknown source type");
if (type)
json_object_set_string_member (object, "type", type);
return node;
}
/**
* @brief get_spotify_artist_albums Get the number of artist albums on Spotify
* @param spotify_uri Spotify uri for the artist
* @return Number of number of artist albums on Spotify
*/
guint get_spotify_artist_albums(const gchar *spotify_uri){
GString *url = g_string_new(ARTIST_LOOKUP_URI);
url = g_string_insert(url, 41, spotify_uri);
GError *error = NULL;
JsonParser *parser = json_parser_new();
GFile * file = g_file_new_for_uri(url->str);
g_print("Opening %s for reading\n", url->str);
GInputStream * fis = (GInputStream*)g_file_read (file, NULL, &error);
g_print("Opened!\n");
if (error){
g_debug("** ERROR **: %s (domain: %s, code: %d) at %d (in get_spotify_artist_albums)\n", \
error->message, g_quark_to_string (error->domain), error->code, \
__LINE__);
g_object_unref(file);
g_object_unref(fis);
g_object_unref (parser);
g_string_free(url, TRUE);
return 0;
}
json_parser_load_from_stream(parser, fis, NULL, &error);
if (error){
g_debug("Unable to parse `%s': %s\n", url->str, error->message);
g_object_unref(file);
g_object_unref(fis);
g_object_unref (parser);
g_string_free(url, TRUE);
return 0;
}
JsonNode *root = json_parser_get_root(parser);
JsonObject * content = json_node_get_object(root);
JsonNode * node = json_object_get_member(content, "artist");
content = json_node_get_object(node);
node = json_object_get_member(content, "albums");
JsonArray * AlbumsArray = json_node_get_array(node);
guint AlbumsArrayLength = json_array_get_length(AlbumsArray);
g_object_unref(file);
g_object_unref(fis);
g_object_unref (parser);
g_string_free(url, TRUE);
return AlbumsArrayLength;
}
static void i3ipc_con_initialize_floating_nodes(JsonArray *array, guint index_, JsonNode *element_node, gpointer user_data) {
i3ipcCon *parent = I3IPC_CON(user_data);
JsonObject *data = json_node_get_object(element_node);
i3ipcCon *con = i3ipc_con_new(parent, data, parent->priv->conn);
parent->priv->floating_nodes = g_list_append(parent->priv->floating_nodes, con);
}
static GVariant *
parse_json_variant (JsonNode *node,
GError **error)
{
if (check_type (node, JSON_NODE_OBJECT, 0, error))
return parse_json_with_sig (json_node_get_object (node), error);
return NULL;
}
static void
got_token_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
/* parses the authentication token from the response
*/
RBAudioscrobblerAccount *account;
JsonParser *parser;
account = RB_AUDIOSCROBBLER_ACCOUNT (user_data);
parser = json_parser_new ();
if (msg->response_body->data != NULL &&
json_parser_load_from_data (parser, msg->response_body->data, msg->response_body->length, NULL)) {
JsonObject *root_object;
root_object = json_node_get_object (json_parser_get_root (parser));
if (json_object_has_member (root_object, "token")) {
char *url;
account->priv->auth_token = g_strdup (json_object_get_string_member (root_object, "token"));
rb_debug ("granted auth token \"%s\"", account->priv->auth_token);
/* send the user to the web page using the token */
url = g_strdup_printf ("%s?api_key=%s&token=%s",
rb_audioscrobbler_service_get_auth_url (account->priv->service),
rb_audioscrobbler_service_get_api_key (account->priv->service),
account->priv->auth_token);
rb_debug ("sending user to %s", url);
gtk_show_uri (NULL, url, GDK_CURRENT_TIME, NULL);
/* add timeout which will ask for session key */
account->priv->session_key_timeout_id =
g_timeout_add_seconds (SESSION_KEY_REQUEST_TIMEOUT,
request_session_key_timeout_cb,
account);
g_free (url);
} else {
rb_debug ("error retrieving auth token: %s",
json_object_get_string_member (root_object, "message"));
/* go back to being logged out */
rb_audioscrobbler_account_logout (account);
}
} else {
/* treat as connection error */
rb_debug ("empty or invalid response retrieving auth token. treating as connection error");
cancel_session (account);
account->priv->login_status = RB_AUDIOSCROBBLER_ACCOUNT_LOGIN_STATUS_CONNECTION_ERROR;
g_signal_emit (account, rb_audioscrobbler_account_signals[LOGIN_STATUS_CHANGED],
0, account->priv->login_status);
}
g_object_unref (parser);
}
/*!
* Recursive function that handles converging \c JsonNode's to \c
* GNode's.
*
* \param root \c Root JsonNode to convert.
* \param node \c GNode.
* \param parsing_array \c true if handling an array, else \c false.
*/
static void
clr_oci_json_parse_aux(JsonNode* root, GNode* node, bool parsing_array) {
guint i;
g_assert (root);
g_assert (node);
if (JSON_NODE_TYPE(root) == JSON_NODE_OBJECT) {
JsonObject *object = json_node_get_object(root);
if (object) {
guint j;
guint size;
GList* keys, *key = NULL;
GList* values, *value = NULL;
size = json_object_get_size(object);
keys = json_object_get_members(object);
values = json_object_get_values(object);
node = g_node_append(node, g_node_new(NULL));
for (j = 0, key = keys, value = values; j < size; j++) {
if (key) {
node = g_node_append(node->parent, g_node_new(g_strdup(key->data)));
}
if (value) {
clr_oci_json_parse_aux(value->data, node, false);
}
key = g_list_next(key);
value = g_list_next(value);
}
if (keys) {
g_list_free(keys);
}
if (values) {
g_list_free(values);
}
}
} else if (JSON_NODE_TYPE(root) == JSON_NODE_ARRAY) {
JsonArray* array = json_node_get_array(root);
guint array_size = json_array_get_length (array);
JsonNode *array_element;
for (i = 0; i < array_size; i++) {
array_element = json_array_get_element(array, i);
clr_oci_json_parse_aux(array_element, node, true);
}
} else if (JSON_NODE_TYPE(root) == JSON_NODE_VALUE) {
node = g_node_append(node, g_node_new(clr_oci_json_string(root)));
if (parsing_array) {
node = g_node_append(node, g_node_new(NULL));
}
}
}
/**
* json_gobject_deserialize:
* @gtype: the type of the #GObject to create
* @node: a #JsonNode of type %JSON_NODE_OBJECT describing the
* instance of type @gtype
*
* Creates a new #GObject of type @gtype, and constructs it
* using the members of the passed #JsonObject
*
* Return value: (transfer full): The newly created #GObject
* instance. Use g_object_unref() to free the resources
* allocated by this function
*
* Since: 0.10
*/
GObject *
json_gobject_deserialize (GType gtype,
JsonNode *node)
{
g_return_val_if_fail (g_type_is_a (gtype, G_TYPE_OBJECT), NULL);
g_return_val_if_fail (JSON_NODE_TYPE (node) == JSON_NODE_OBJECT, NULL);
return json_gobject_new (gtype, json_node_get_object (node));
}
void ggp_edisc_xfer_ticket_changed(PurpleConnection *gc, const char *data)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleXfer *xfer;
JsonParser *parser;
JsonObject *ticket;
const gchar *ticket_id, *send_status;
ggp_edisc_xfer_ack_status ack_status;
gboolean is_completed;
g_return_if_fail(sdata != NULL);
parser = ggp_json_parse(data);
ticket = json_node_get_object(json_parser_get_root(parser));
ticket_id = json_object_get_string_member(ticket, "id");
ack_status = ggp_edisc_xfer_parse_ack_status(
json_object_get_string_member(ticket, "ack_status"));
send_status = json_object_get_string_member(ticket, "send_status");
if (ticket_id == NULL)
ticket_id = "";
xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id);
if (xfer == NULL) {
purple_debug_misc("gg", "ggp_edisc_event_ticket_changed: "
"ticket %s not found, updating it...\n",
purple_debug_is_unsafe() ? ticket_id : "");
ggp_edisc_xfer_recv_ticket_got(gc, ticket_id);
g_object_unref(parser);
return;
}
is_completed = FALSE;
if (g_strcmp0("in_progress", send_status) == 0) {
/* do nothing */
} else if (g_strcmp0("completed", send_status) == 0) {
is_completed = TRUE;
} else if (g_strcmp0("expired", send_status) == 0)
ggp_edisc_xfer_error(xfer, _("File transfer expired."));
else {
purple_debug_warning("gg", "ggp_edisc_event_ticket_changed: "
"unknown send_status=%s\n", send_status);
g_object_unref(parser);
return;
}
g_object_unref(parser);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
if (is_completed)
ggp_edisc_xfer_recv_ticket_completed(xfer);
} else {
if (ack_status != GGP_EDISC_XFER_ACK_STATUS_UNKNOWN)
ggp_edisc_xfer_send_ticket_changed(gc, xfer, ack_status
== GGP_EDISC_XFER_ACK_STATUS_ALLOWED);
}
}
void trg_prefs_load(TrgPrefs * p)
{
TrgPrefsPrivate *priv = p->priv;
JsonParser *parser = json_parser_new();
JsonNode *root;
guint n_profiles;
JsonArray *profiles;
gboolean parsed = json_parser_load_from_file(parser, priv->file, NULL);
if (!parsed) {
trg_prefs_empty_init(p);
g_object_unref(parser);
return;
}
root = json_parser_get_root(parser);
if (root) {
priv->user = json_node_copy(root);
priv->userObj = json_node_get_object(priv->user);
}
g_object_unref(parser);
if (!root) {
trg_prefs_empty_init(p);
return;
}
if (!json_object_has_member(priv->userObj, TRG_PREFS_KEY_PROFILES)) {
profiles = json_array_new();
json_object_set_array_member(priv->userObj, TRG_PREFS_KEY_PROFILES,
profiles);
} else {
profiles = json_object_get_array_member(priv->userObj,
TRG_PREFS_KEY_PROFILES);
}
n_profiles = json_array_get_length(profiles);
if (n_profiles < 1) {
priv->profile = trg_prefs_new_profile_object();
json_array_add_object_element(profiles, priv->profile);
trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, 0,
TRG_PREFS_GLOBAL);
} else {
gint profile_id = trg_prefs_get_int(p, TRG_PREFS_KEY_PROFILE_ID,
TRG_PREFS_GLOBAL);
if (profile_id >= n_profiles)
trg_prefs_set_int(p, TRG_PREFS_KEY_PROFILE_ID, profile_id = 0,
TRG_PREFS_GLOBAL);
priv->profile =
json_array_get_object_element(profiles, profile_id);
}
}
static void
list_command_completed (gpointer data)
{
FrCommandUnarchiver *unar_comm = FR_COMMAND_UNARCHIVER (data);
JsonParser *parser;
GError *error = NULL;
parser = json_parser_new ();
if (json_parser_load_from_stream (parser, unar_comm->stream, NULL, &error)) {
JsonObject *root;
root = json_node_get_object (json_parser_get_root (parser));
if (json_object_get_int_member (root, "lsarFormatVersion") == LSAR_SUPPORTED_FORMAT) {
JsonArray *content;
int i;
content = json_object_get_array_member (root, "lsarContents");
for (i = 0; i < json_array_get_length (content); i++) {
JsonObject *entry;
FileData *fdata;
const char *filename;
entry = json_array_get_object_element (content, i);
fdata = file_data_new ();
fdata->size = json_object_get_int_member (entry, "XADFileSize");
fdata->modified = mktime_from_string (json_object_get_string_member (entry, "XADLastModificationDate"));
if (json_object_has_member (entry, "XADIsEncrypted"))
fdata->encrypted = json_object_get_int_member (entry, "XADIsEncrypted") == 1;
filename = json_object_get_string_member (entry, "XADFileName");
if (*filename == '/') {
fdata->full_path = g_strdup (filename);
fdata->original_path = fdata->full_path;
}
else {
fdata->full_path = g_strconcat ("/", filename, NULL);
fdata->original_path = fdata->full_path + 1;
}
fdata->link = NULL;
if (json_object_has_member (entry, "XADIsDirectory"))
fdata->dir = json_object_get_int_member (entry, "XADIsDirectory") == 1;
if (fdata->dir)
fdata->name = _g_path_get_dir_name (fdata->full_path);
else
fdata->name = g_strdup (_g_path_get_basename (fdata->full_path));
fdata->path = _g_path_remove_level (fdata->full_path);
fr_archive_add_file (FR_ARCHIVE (unar_comm), fdata);
}
}
}
g_object_unref (parser);
}
static void onTaskReadyCallback(GObject * source, GAsyncResult * res,
gpointer userData)
{
GError *err = NULL;
//WlDictQuery *query=WL_DICT_QUERY(source);
TaskData *td = g_task_get_task_data(G_TASK(res));
gchar *responseBody = g_task_propagate_pointer(G_TASK(res), &err);
if (err) { /* Error */
if (td->cb)
td->cb(td->from, td->to, td->src, NULL, td->cbData, err);
return;
}
JsonParser *parser = json_parser_new();
if (!json_parser_load_from_data(parser, responseBody, -1, &err)) {
if (td->cb)
td->cb(td->from, td->to, td->src, NULL, td->cbData, err);
g_message("%s", responseBody);
return;
}
JsonNode *rootNode = json_parser_get_root(parser);
JsonObject *rootObj = json_node_get_object(rootNode);
const gchar *from = json_object_get_string_member(rootObj, "from");
const gchar *to = json_object_get_string_member(rootObj, "to");
if (json_object_has_member(rootObj, "error_code")) {
/* 查询出错 */
const gchar *error_msg =
json_object_get_string_member(rootObj, "error_msg");
const gchar *error_code =
json_object_get_string_member(rootObj, "error_code");
if (td->cb) {
GError *error =
g_error_new(G_IO_ERROR, atoi(error_code), "%s", error_msg);
td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to),
json_object_get_string_member(rootObj, "query"), NULL,
td->cbData, error);
g_error_free(error);
}
g_object_unref(parser);
return;
}
JsonArray *results =
json_object_get_array_member(rootObj, "trans_result");
gint i, len = json_array_get_length(results);
for (i = 0; i < len; i++) {
JsonObject *resEle = json_array_get_object_element(results, i);
const gchar *src = json_object_get_string_member(resEle, "src");
const gchar *dst = json_object_get_string_member(resEle, "dst");
if (td->cb)
td->cb(wl_dict_lang_get_enum(from),
wl_dict_lang_get_enum(to), src, dst, td->cbData, NULL);
}
g_object_unref(parser);
}
/**
* @brief get_spotify_thumbnail Get the Spotify artist thumbnail url
* @param spotify_uri Spotify uri for the artist
* @return Pointer to the string containing the Spotify artist thumbnail url
*/
char * get_spotify_thumbnail(const char *spotify_uri){
GString *url = g_string_new(ARTIST_ICON_BASE_URI);
g_string_append(url, spotify_uri);
GError *error = NULL;
JsonParser *parser = json_parser_new();
GFile * file = g_file_new_for_uri(url->str);
g_print("Opening %s for reading\n", url->str);
GInputStream * fis = (GInputStream* ) g_file_read(file, NULL, &error);
g_print("Opened!\n");
if (error){
g_debug("** ERROR **: %s (domain: %s, code: %d) at %d (in get_spotify_thumbnail)\n",\
error->message, g_quark_to_string (error->domain), error->code, \
__LINE__);
g_object_unref(file);
g_object_unref(fis);
g_object_unref (parser);
g_string_free(url, TRUE);
return NULL;
}
json_parser_load_from_stream(parser, fis, NULL, &error);
if (error){
g_debug("Unable to parse `%s': %s\n", url->str, error->message);
g_object_unref(file);
g_object_unref(fis);
g_object_unref (parser);
g_string_free(url, TRUE);
return NULL;
}
JsonNode *root = json_parser_get_root(parser);
JsonObject * content = json_node_get_object(root);
const gchar * thumbnail_url = \
json_object_get_string_member(content, "thumbnail_url");
gchar * pointer = (gchar *) malloc( strlen(thumbnail_url) + 1 );
char ** tokens = g_strsplit(thumbnail_url, "cover", 0);
if ( *(tokens + 1) ){
gchar * new_thumbnail_url = g_strconcat(*tokens, "640", \
*(tokens+1), '\0', NULL);
g_strfreev(tokens);
strcpy(pointer, new_thumbnail_url);
g_free(new_thumbnail_url);
}
else{
strcpy(pointer, thumbnail_url);
}
g_object_unref(file);
g_object_unref(fis);
g_object_unref(parser);
g_string_free(url, TRUE);
return pointer;
}
