--- /dev/null
+/*
+ * Devious: UPNP Control Point for Maemo 5
+ *
+ * Copyright (C) 2009 Kyle Cronan
+ *
+ * Author: Kyle Cronan <kyle@pbx.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this library; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <hildon/hildon.h>
+#include <libgupnp/gupnp-control-point.h>
+#include <libgupnp-av/gupnp-av.h>
+
+#include "devious.h"
+
+
+void add_content(GUPnPDIDLLiteParser *didl_parser, xmlNode *object_node,
+ gpointer user_data)
+{
+ struct browse_data *data = (struct browse_data *)user_data;
+
+ char *title = gupnp_didl_lite_object_get_title(object_node);
+ char *id = gupnp_didl_lite_object_get_id(object_node);
+ gboolean container = gupnp_didl_lite_object_is_container(object_node);
+ GError *error = NULL;
+ GdkPixbuf *icon = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),
+ (container ? "general_folder"
+ : "general_audio_file"),
+ HILDON_ICON_PIXEL_SIZE_FINGER,
+ 0, &error);
+ GtkTreeIter iter;
+ gtk_list_store_append(data->list, &iter);
+ gtk_list_store_set(data->list, &iter,
+ COL_ICON, icon, COL_LABEL, title,
+ COL_ID, id, COL_CONTENT, data->content_dir,
+ COL_CONTAINER, container, -1);
+}
+
+struct browse_data *browse_data_new(GUPnPServiceProxy *content_dir,
+ const char *id, guint32 starting_index,
+ GtkListStore *list)
+{
+ struct browse_data *data;
+
+ data = g_slice_new(struct browse_data);
+ data->content_dir = g_object_ref(content_dir);
+ data->id = g_strdup(id);
+ data->starting_index = starting_index;
+ data->list = list;
+
+ return data;
+}
+
+void browse_data_free(struct browse_data *data)
+{
+ g_free(data->id);
+ g_object_unref(data->content_dir);
+ g_slice_free(struct browse_data, data);
+}
+
+void browse_cb(GUPnPServiceProxy *content_dir,
+ GUPnPServiceProxyAction *action, gpointer user_data)
+{
+ struct browse_data *data;
+ char *didl_xml;
+ guint32 number_returned;
+ guint32 total_matches;
+ GError *error;
+
+ data = (struct browse_data *)user_data;
+ didl_xml = NULL;
+ error = NULL;
+
+ gupnp_service_proxy_end_action(content_dir, action, &error,
+ "Result", G_TYPE_STRING, &didl_xml,
+ "NumberReturned", G_TYPE_UINT,
+ &number_returned,
+ "TotalMatches", G_TYPE_UINT, &total_matches,
+ NULL);
+ if (didl_xml) {
+ guint32 remaining;
+ GError *error = NULL;
+
+ if (!gupnp_didl_lite_parser_parse_didl(data->didl_parser, didl_xml,
+ add_content, data, &error)) {
+ g_warning("%s\n", error->message);
+ g_error_free(error);
+ }
+ g_free(didl_xml);
+
+ data->starting_index += number_returned;
+
+ /* See if we have more objects to get */
+ remaining = total_matches - data->starting_index;
+ /* Keep browsing till we get each and every object */
+ if (remaining != 0) browse(content_dir, data->id, data->starting_index,
+ MIN(remaining, MAX_BROWSE),
+ data->list, data->didl_parser);
+ } else if (error) {
+ GUPnPServiceInfo *info;
+
+ info = GUPNP_SERVICE_INFO(content_dir);
+ g_warning("Failed to browse '%s': %s\n",
+ gupnp_service_info_get_location(info),
+ error->message);
+
+ g_error_free(error);
+ }
+
+ browse_data_free(data);
+}
+
+void browse(GUPnPServiceProxy *content_dir, const char *container_id,
+ guint32 starting_index, guint32 requested_count,
+ GtkListStore *list, GUPnPDIDLLiteParser *didl_parser)
+{
+ struct browse_data *data;
+ data = browse_data_new(content_dir, container_id, starting_index, list);
+
+ gupnp_service_proxy_begin_action(content_dir, "Browse", browse_cb, data,
+ "ObjectID", G_TYPE_STRING, container_id,
+ "BrowseFlag", G_TYPE_STRING,
+ "BrowseDirectChildren",
+ "Filter", G_TYPE_STRING, "*",
+ "StartingIndex", G_TYPE_UINT,
+ starting_index,
+ "RequestedCount", G_TYPE_UINT,
+ requested_count,
+ "SortCriteria", G_TYPE_STRING, "",
+ NULL);
+}
+
+void update_container(GUPnPServiceProxy *content_dir,
+ const char *container_id)
+{
+// TODO
+// GtkTreeModel *model;
+// GtkTreeIter container_iter;
+}
+
+void on_container_update_ids(GUPnPServiceProxy *content_dir,
+ const char *variable, GValue *value,
+ gpointer user_data)
+{
+ char **tokens = g_strsplit(g_value_get_string(value), ",", 0);
+ guint i;
+ for (i=0; tokens[i] != NULL && tokens[i+1] != NULL; i+=2) {
+ update_container(content_dir, tokens[i]);
+ }
+ g_strfreev(tokens);
+}
+
+void set_panarea_padding(GtkWidget *child, gpointer data)
+{
+ void set_child_padding(GtkWidget *child, gpointer user_data)
+ {
+ GtkBox *box = GTK_BOX(user_data);
+ gboolean expand, fill;
+ guint pad;
+ GtkPackType pack;
+
+ gtk_box_query_child_packing(box, child, &expand, &fill, &pad, &pack);
+ gtk_box_set_child_packing(box, child, expand, fill, 0, pack);
+ }
+
+ if (GTK_IS_CONTAINER(child))
+ gtk_container_forall(GTK_CONTAINER(child), set_child_padding, child);
+}
+
+GtkWidget *new_selector(GtkListStore *list)
+{
+ GtkWidget *selector = hildon_touch_selector_new();
+
+ HildonTouchSelectorColumn *column =
+ hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR(selector),
+ GTK_TREE_MODEL(list), NULL, NULL);
+ g_object_unref(list);
+ hildon_touch_selector_column_set_text_column(column, 1);
+
+ hildon_touch_selector_set_hildon_ui_mode(HILDON_TOUCH_SELECTOR(selector),
+ HILDON_UI_MODE_NORMAL);
+ GtkCellRenderer *renderer;
+ renderer = gtk_cell_renderer_pixbuf_new();
+ g_object_set(renderer, "xalign", ICON_XALIGN, NULL);
+ gtk_cell_renderer_set_fixed_size(renderer, ICON_WIDTH, ROW_HEIGHT);
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, FALSE);
+ gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer,
+ "pixbuf", 0, NULL);
+
+ renderer = gtk_cell_renderer_text_new();
+ g_object_set(renderer, "xalign", 0.0, NULL);
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
+ gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer,
+ "text", 1, NULL);
+
+ gtk_container_forall(GTK_CONTAINER(selector), set_panarea_padding, NULL);
+
+ gtk_widget_show_all(selector);
+ return selector;
+}
+
+void transport_uri(GUPnPServiceProxy *av_transport,
+ GUPnPServiceProxyAction *action, gpointer user_data)
+{
+ GError *error = NULL;
+ if (gupnp_service_proxy_end_action(av_transport, action, &error, NULL)) {
+ /* TODO: do something with duration? */
+ } else {
+ g_warning("Failed to set URI");
+ g_error_free(error);
+ }
+}
+
+gboolean mime_type_is_a(const char *mime_type1, const char *mime_type2)
+{
+ gboolean ret;
+
+ char *content_type1 = g_content_type_from_mime_type(mime_type1);
+ char *content_type2 = g_content_type_from_mime_type(mime_type2);
+ if (content_type1 == NULL || content_type2 == NULL) {
+ /* Uknown content type, just do a simple comarison */
+ ret = g_ascii_strcasecmp(mime_type1, mime_type2) == 0;
+ } else {
+ ret = g_content_type_is_a(content_type1, content_type2);
+ }
+
+ g_free(content_type1);
+ g_free(content_type2);
+
+ return ret;
+}
+
+gboolean is_transport_compat(const gchar *renderer_protocol,
+ const gchar *renderer_host,
+ const gchar *item_protocol,
+ const gchar *item_host)
+{
+ if (g_ascii_strcasecmp(renderer_protocol, item_protocol) != 0 &&
+ g_ascii_strcasecmp(renderer_protocol, "*") != 0) {
+ return FALSE;
+ } else if (g_ascii_strcasecmp("INTERNAL", renderer_protocol) == 0 &&
+ g_ascii_strcasecmp(renderer_host, item_host) != 0) {
+ /* Host must be the same in case of INTERNAL protocol */
+ return FALSE;
+ } else {
+ return TRUE;
+ }
+}
+
+gboolean is_content_format_compat(const gchar *renderer_content_format,
+ const gchar *item_content_format)
+{
+ if(g_ascii_strcasecmp(renderer_content_format, "*") != 0 &&
+ !mime_type_is_a(item_content_format, renderer_content_format)) {
+ return FALSE;
+ } else {
+ return TRUE;
+ }
+}
+
+gchar *get_dlna_pn(gchar **additional_info_fields)
+{
+ gchar *pn = NULL;
+ gint i;
+ for (i = 0; additional_info_fields[i]; i++) {
+ pn = g_strstr_len(additional_info_fields[i],
+ strlen(additional_info_fields[i]), "DLNA.ORG_PN=");
+ if (pn) {
+ pn += 12; /* end of "DLNA.ORG_PN=" */
+ break;
+ }
+ }
+
+ return pn;
+}
+
+gboolean is_additional_info_compat(const gchar *renderer_additional_info,
+ const gchar *item_additional_info)
+{
+ gboolean ret = FALSE;
+
+ if (g_ascii_strcasecmp(renderer_additional_info, "*") == 0) {
+ return TRUE;
+ }
+
+ char **renderer_tokens = g_strsplit(renderer_additional_info, ";", -1);
+ if (renderer_tokens == NULL) {
+ return FALSE;
+ }
+
+ char **item_tokens = g_strsplit(item_additional_info, ";", -1);
+ if (item_tokens == NULL) {
+ goto no_item_tokens;
+ }
+
+ char *renderer_pn = get_dlna_pn(renderer_tokens);
+ char *item_pn = get_dlna_pn(item_tokens);
+ if (renderer_pn == NULL || item_pn == NULL) {
+ goto no_renderer_pn;
+ }
+
+ if (g_ascii_strcasecmp(renderer_pn, item_pn) == 0) {
+ ret = TRUE;
+ }
+
+no_renderer_pn:
+ g_strfreev(item_tokens);
+no_item_tokens:
+ g_strfreev(renderer_tokens);
+
+ return ret;
+}
+
+gboolean is_protocol_info_compat(xmlNode *res_node,
+ const gchar *renderer_protocol)
+{
+ gchar *item_protocol;
+ gchar **item_proto_tokens;
+ gchar **renderer_proto_tokens;
+ gboolean ret = FALSE;
+
+ item_protocol = gupnp_didl_lite_property_get_attribute(res_node,
+ "protocolInfo");
+ if (!item_protocol) return FALSE;
+
+ item_proto_tokens = g_strsplit(item_protocol, ":", 4);
+ renderer_proto_tokens = g_strsplit(renderer_protocol, ":", 4);
+
+ if (!item_proto_tokens[0] || !item_proto_tokens[1] ||
+ !item_proto_tokens[2] || !item_proto_tokens[3] ||
+ !renderer_proto_tokens[0] || !renderer_proto_tokens[1] ||
+ !renderer_proto_tokens[2] || !renderer_proto_tokens[3])
+ goto return_point;
+
+ if (is_transport_compat(renderer_proto_tokens[0], renderer_proto_tokens[2],
+ item_proto_tokens[0], item_proto_tokens[1]) &&
+ is_content_format_compat(renderer_proto_tokens[2],
+ item_proto_tokens[2]) &&
+ is_additional_info_compat(renderer_proto_tokens[3],
+ item_proto_tokens[3]))
+ ret = TRUE;
+
+return_point:
+ g_free(item_protocol);
+ g_strfreev(renderer_proto_tokens);
+ g_strfreev(item_proto_tokens);
+
+ return ret;
+}
+
+char *find_compat_uri_from_metadata(const char *metadata, char **duration,
+ struct proxy *renderer)
+{
+ char *uri = NULL;
+ void on_didl_item_available(GUPnPDIDLLiteParser *didl_parser,
+ xmlNode *item_node, gpointer user_data)
+ {
+ GList *resources =
+ gupnp_didl_lite_object_get_property(item_node, "res");
+ if (!resources) return;
+
+ int i;
+ for (i=0; renderer->protocols[i] && uri == NULL; i++) {
+ GList *res, *compat_res = NULL;
+ xmlNode *res_node;
+ for (res = resources; res != NULL; res = res->next) {
+ res_node = (xmlNode *)res->data;
+
+ int j;
+ for (j=0; renderer->protocols[j]; j++) {
+ if (is_protocol_info_compat(res_node,
+ renderer->protocols[j])) {
+ compat_res = res;
+ break;
+ }
+ }
+ }
+ if (!compat_res) continue;
+
+ res_node = (xmlNode *)compat_res->data;
+ uri = gupnp_didl_lite_property_get_value(res_node);
+ *duration = gupnp_didl_lite_property_get_attribute(res_node,
+ "duration");
+ }
+ g_list_free(resources);
+ }
+
+ GError *error = NULL;
+ /* Assumption: metadata only contains a single didl object */
+ gupnp_didl_lite_parser_parse_didl(renderer->set->didl_parser, metadata,
+ on_didl_item_available, NULL, &error);
+ if (error) {
+ g_warning("%s\n", error->message);
+ g_error_free(error);
+ }
+
+ return uri;
+}
+
+struct proxy *current_renderer(struct proxy_set *proxy_set)
+{
+ int i = hildon_picker_button_get_active(proxy_set->renderer_picker);
+ GtkTreeIter iter;
+ gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(proxy_set->renderer_list),
+ &iter, NULL, i);
+ char *udn;
+ gtk_tree_model_get(GTK_TREE_MODEL(proxy_set->renderer_list), &iter,
+ 1, &udn, -1);
+
+ return g_hash_table_lookup(proxy_set->renderers, udn);
+}
+
+void set_av_transport_uri(GUPnPServiceProxy *content_dir,
+ GUPnPServiceProxyAction *action, gpointer user_data)
+{
+ GError *error = NULL;
+ char *metadata;
+ gupnp_service_proxy_end_action(content_dir, action, &error,
+ "Result", G_TYPE_STRING, &metadata, NULL);
+ if (!metadata) return;
+ if (error) {
+ g_warning("Failed to get metadata for content");
+ g_error_free(error);
+ }
+
+ struct proxy_set *proxy_set = (struct proxy_set *)user_data;
+ struct proxy *renderer = current_renderer(proxy_set);
+
+ char *duration;
+ char *uri = find_compat_uri_from_metadata(metadata, &duration, renderer);
+ if (!uri) {
+ g_warning("no compatible URI found.");
+ return;
+ }
+
+ GUPnPServiceProxy *av_transport = GUPNP_SERVICE_PROXY(
+ gupnp_device_info_get_service(GUPNP_DEVICE_INFO(renderer->proxy),
+ AV_TRANSPORT));
+
+ gupnp_service_proxy_begin_action(av_transport, "SetAVTransportURI",
+ transport_uri, NULL,
+ "InstanceID", G_TYPE_UINT, 0,
+ "CurrentURI", G_TYPE_STRING, uri,
+ "CurrentURIMetaData", G_TYPE_STRING,
+ metadata,
+ NULL);
+}
+
+void av_transport_action_cb(GUPnPServiceProxy *av_transport,
+ GUPnPServiceProxyAction *action, gpointer data)
+{
+ const char *action_name = (const char *)data;
+ GError *error = NULL;
+
+ if (!gupnp_service_proxy_end_action(av_transport, action, &error, NULL)) {
+ g_warning("Failed to send action '%s': %s",
+ action_name, error->message);
+ g_error_free(error);
+ }
+}
+
+void g_value_free(gpointer data)
+{
+ g_value_unset((GValue *)data);
+ g_slice_free(GValue, data);
+}
+
+GHashTable *create_av_transport_args_hash(char **additional_args)
+{
+ GHashTable *args = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, g_value_free);
+
+ GValue *instance_id = g_slice_alloc0(sizeof(GValue));
+ g_value_init(instance_id, G_TYPE_UINT);
+ g_value_set_uint(instance_id, 0);
+
+ g_hash_table_insert(args, "InstanceID", instance_id);
+
+ if (additional_args) {
+ int i;
+ for (i=0; additional_args[i]; i += 2) {
+ GValue *value = g_slice_alloc0(sizeof(GValue));
+ g_value_init(value, G_TYPE_STRING);
+ g_value_set_string(value, additional_args[i + 1]);
+ g_hash_table_insert(args, additional_args[i], value);
+ }
+ }
+ return args;
+}
+
+void av_transport_send_action(GUPnPServiceProxy *av_transport, char *action,
+ char *additional_args[])
+{
+ GHashTable *args = create_av_transport_args_hash(additional_args);
+
+ gupnp_service_proxy_begin_action_hash(av_transport, action,
+ av_transport_action_cb,
+ (char *)action,
+ args);
+ g_hash_table_unref(args);
+}
+
+void transport_selection(struct proxy *server, GtkTreeRowReference *row)
+{
+ server->current_selection = row;
+
+ GtkTreeModel *model = gtk_tree_row_reference_get_model(row);
+ GtkTreePath *path = gtk_tree_row_reference_get_path(row);
+
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(model, &iter, path);
+
+ char *label;
+ char *id;
+ GUPnPServiceProxy *content;
+ gtk_tree_model_get(model, &iter, COL_LABEL, &label,
+ COL_CONTENT, &content, COL_ID, &id, -1);
+
+ gupnp_service_proxy_begin_action(content, "Browse",
+ set_av_transport_uri, server->set,
+ "ObjectID", G_TYPE_STRING, id,
+ "BrowseFlag", G_TYPE_STRING,
+ "BrowseMetadata",
+ "Filter", G_TYPE_STRING, "*",
+ "StartingIndex", G_TYPE_UINT, 0,
+ "RequestedCount", G_TYPE_UINT, 0,
+ "SortCriteria", G_TYPE_STRING, "",
+ NULL);
+}
+
+void play_button(GtkWidget *button, gpointer data)
+{
+ struct proxy_set *proxy_set = (struct proxy_set *)data;
+ struct proxy *renderer = current_renderer(proxy_set);
+ GUPnPServiceProxy *av_transport = GUPNP_SERVICE_PROXY(
+ gupnp_device_info_get_service(GUPNP_DEVICE_INFO(renderer->proxy),
+ AV_TRANSPORT));
+ char *args[] = {"Speed", "1", NULL};
+ av_transport_send_action(av_transport, "Play", args);
+}
+
+GtkWidget *play_window(struct proxy *server, GtkTreeRowReference *row)
+{
+ GtkWidget *window = hildon_stackable_window_new();
+ gtk_window_set_title(GTK_WINDOW(window), PLAY_WINDOW_TITLE);
+
+ GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(window), vbox);
+
+ GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 6);
+
+ GtkWidget *image = gtk_image_new();
+ gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 6);
+
+ GtkWidget *inner_box = gtk_vbox_new(FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(hbox), inner_box, TRUE, TRUE, 6);
+
+ GtkWidget *button_box = gtk_hbutton_box_new();
+ gtk_box_pack_start(GTK_BOX(vbox), button_box, FALSE, FALSE, 6);
+
+ GtkWidget *button =
+ hildon_button_new_with_text(HILDON_SIZE_FINGER_HEIGHT,
+ HILDON_BUTTON_ARRANGEMENT_VERTICAL,
+ "Play", "");
+
+ g_signal_connect(button, "clicked", G_CALLBACK(play_button), server->set);
+
+ gtk_box_pack_start(GTK_BOX(button_box), button, FALSE, FALSE, 0);
+ gtk_widget_show_all(GTK_WIDGET(vbox));
+
+ return window;
+}
+
+void content_select(HildonTouchSelector *selector, gint column, gpointer data)
+{
+ GtkTreePath *path;
+ path = hildon_touch_selector_get_last_activated_row(selector, column);
+ if (!path) return;
+
+ GtkTreeModel *model = hildon_touch_selector_get_model(selector, column);
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(model, &iter, path);
+
+ GUPnPServiceProxy *content;
+ char *id, *label;
+ gboolean container;
+ gtk_tree_model_get(model, &iter, COL_CONTENT, &content, COL_ID, &id,
+ COL_CONTAINER, &container,
+ COL_LABEL, &label, -1);
+
+ struct proxy *server = (struct proxy *)data;
+ GtkWidget *window;
+
+ if (container) {
+ GtkListStore *view_list;
+ window = content_window(server, label, &view_list);
+ browse(content, id, 0, MAX_BROWSE, view_list, server->set->didl_parser);
+ gupnp_service_proxy_add_notify(content, "ContainerUpdateIDs",
+ G_TYPE_STRING, on_container_update_ids,
+ NULL);
+ gupnp_service_proxy_set_subscribed(content, TRUE);
+ } else {
+ GtkTreeRowReference *row = gtk_tree_row_reference_new(model, path);
+ transport_selection(server, row);
+ window = play_window(server, row);
+ }
+
+ HildonWindowStack *stack = hildon_window_stack_get_default();
+ hildon_window_stack_push_1(stack, HILDON_STACKABLE_WINDOW(window));
+}
+
+GtkWidget *content_window(struct proxy *server, char *title,
+ GtkListStore **view_list)
+{
+ GtkWidget *window = hildon_stackable_window_new();
+ gtk_window_set_title(GTK_WINDOW(window), title);
+
+ GtkListStore *list = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF,
+ G_TYPE_STRING, G_TYPE_STRING,
+ G_TYPE_POINTER, G_TYPE_BOOLEAN);
+
+ GtkWidget *selector = new_selector(list);
+
+ g_signal_connect(G_OBJECT(selector), "changed",
+ G_CALLBACK(content_select), server);
+
+ gtk_container_add(GTK_CONTAINER(window), selector);
+
+ *view_list = list;
+ return window;
+}
+
+void server_select(HildonTouchSelector *selector, gint column, gpointer data)
+{
+ GtkTreePath *path;
+ path = hildon_touch_selector_get_last_activated_row(selector, column);
+ if (!path) return;
+
+ GtkTreeModel *model = hildon_touch_selector_get_model(selector, column);
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(model, &iter, path);
+
+ char *udn;
+ gtk_tree_model_get(model, &iter, COL_ID, &udn, -1);
+
+ GHashTable *servers = (GHashTable *)data;
+ struct proxy *server = g_hash_table_lookup(servers, udn);
+
+ GUPnPServiceProxy *content_dir = GUPNP_SERVICE_PROXY(
+ gupnp_device_info_get_service(GUPNP_DEVICE_INFO(server->proxy),
+ CONTENT_DIR));
+
+ GtkListStore *view_list;
+ GtkWidget *window = content_window(server, server->name, &view_list);
+
+ browse(content_dir, "0", 0, MAX_BROWSE, view_list,
+ server->set->didl_parser);
+
+ gupnp_service_proxy_add_notify(content_dir, "ContainerUpdateIDs",
+ G_TYPE_STRING, on_container_update_ids,
+ NULL);
+ gupnp_service_proxy_set_subscribed(content_dir, TRUE);
+
+ /* TODO: GList *child_devices = gupnp_device_info_list_devices(GUPNP_DEVICE_INFO(server->proxy)); */
+
+ HildonWindowStack *stack = hildon_window_stack_get_default();
+ hildon_window_stack_push_1(stack, HILDON_STACKABLE_WINDOW(window));
+}
+
+GtkWidget *target_selector(struct proxy_set *proxy_set)
+{
+ GtkWidget *selector;
+ selector = hildon_touch_selector_new();
+
+ HildonTouchSelectorColumn *column =
+ hildon_touch_selector_append_column(HILDON_TOUCH_SELECTOR(selector),
+ GTK_TREE_MODEL(proxy_set->renderer_list), NULL, NULL);
+ g_object_unref(proxy_set->renderer_list);
+ hildon_touch_selector_column_set_text_column(column, 0);
+
+ GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
+ g_object_set(renderer, "xalign", 0.0, NULL);
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
+ gtk_cell_renderer_set_fixed_size(renderer, -1, ROW_HEIGHT);
+ gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer,
+ "text", 0, NULL);
+
+ gtk_widget_show_all(selector);
+ return selector;
+}
+
+GtkWidget *main_menu(struct proxy_set *proxy_set)
+{
+ GtkWidget *menu = hildon_app_menu_new();
+ GtkWidget *button;
+ button = hildon_picker_button_new(HILDON_SIZE_AUTO,
+ HILDON_BUTTON_ARRANGEMENT_VERTICAL);
+ hildon_button_set_title(HILDON_BUTTON(button), CHOOSE_TARGET);
+
+ GtkWidget *selector = target_selector(proxy_set);
+ hildon_picker_button_set_selector(HILDON_PICKER_BUTTON(button),
+ HILDON_TOUCH_SELECTOR(selector));
+ proxy_set->renderer_picker = HILDON_PICKER_BUTTON(button);
+
+ hildon_app_menu_append(HILDON_APP_MENU(menu), GTK_BUTTON(button));
+
+ gtk_widget_show_all(menu);
+ return menu;
+}
+
+GtkWidget *main_window(HildonProgram *program, struct proxy_set *proxy_set)
+{
+ GtkWidget *window = hildon_stackable_window_new();
+ hildon_program_add_window(program, HILDON_WINDOW(window));
+
+ gtk_window_set_title(GTK_WINDOW(window), APPLICATION_NAME);
+
+ GError *error = NULL;
+ proxy_set->icon = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),
+ "control_bluetooth_lan",
+ HILDON_ICON_PIXEL_SIZE_FINGER,
+ 0, &error);
+ proxy_set->server_list = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF,
+ G_TYPE_STRING, G_TYPE_STRING,
+ G_TYPE_POINTER, G_TYPE_BOOLEAN);
+
+ GtkWidget *selector = new_selector(proxy_set->server_list);
+
+ g_signal_connect(G_OBJECT(selector), "changed",
+ G_CALLBACK(server_select), proxy_set->servers);
+
+ gtk_container_add(GTK_CONTAINER(window), selector);
+
+ GtkWidget *menu = main_menu(proxy_set);
+ hildon_window_set_app_menu(HILDON_WINDOW(window), HILDON_APP_MENU(menu));
+
+ return window;
+}
+
+void protocol_info(GUPnPServiceProxy *cm, GUPnPServiceProxyAction *action,
+ gpointer user_data)
+{
+ gchar *sink_protocols;
+ GError *error = NULL;
+ const gchar *udn = gupnp_service_info_get_udn(GUPNP_SERVICE_INFO(cm));
+
+ if (!gupnp_service_proxy_end_action(cm, action, &error, "Sink",
+ G_TYPE_STRING, &sink_protocols,
+ NULL)) {
+ g_warning("Failed to get sink protocol info from "
+ "media renderer '%s':%s\n",
+ udn, error->message);
+ g_error_free(error);
+ return;
+ }
+
+ struct proxy *server = (struct proxy *)user_data;
+ server->protocols = g_strsplit(sink_protocols, ",", 0);
+}
+
+void add_renderer(GUPnPDeviceProxy *proxy, struct proxy_set *proxy_set)
+{
+ const char *udn = gupnp_device_info_get_udn(GUPNP_DEVICE_INFO(proxy));
+ if (!udn) return;
+
+ struct proxy *server = g_hash_table_lookup(proxy_set->renderers, udn);
+ if (server) return;
+
+ char *name = gupnp_device_info_get_friendly_name(GUPNP_DEVICE_INFO(proxy));
+ if (!name) return;
+
+ server = (struct proxy *)g_malloc(sizeof(struct proxy));
+ server->proxy = proxy;
+ server->name = name;
+ server->set = proxy_set;
+
+ GtkTreeIter iter;
+ gtk_list_store_append(proxy_set->renderer_list, &iter);
+ gtk_list_store_set(proxy_set->renderer_list, &iter,
+ 0, server->name, 1, udn, -1);
+
+ /* TODO: default to saved value */
+ hildon_picker_button_set_active(proxy_set->renderer_picker, 0);
+
+ GtkTreeModel *model = GTK_TREE_MODEL(proxy_set->renderer_list);
+ GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
+ server->row = gtk_tree_row_reference_new(model, path);
+
+ g_hash_table_replace(proxy_set->renderers, (char *)udn, server);
+
+ GUPnPServiceProxy *cm = GUPNP_SERVICE_PROXY(
+ gupnp_device_info_get_service(GUPNP_DEVICE_INFO(proxy),
+ CONNECTION_MANAGER));
+ gupnp_service_proxy_begin_action(cm, "GetProtocolInfo", protocol_info,
+ server, NULL);
+}
+
+void add_server(GUPnPDeviceProxy *proxy, struct proxy_set *proxy_set)
+{
+ const char *udn = gupnp_device_info_get_udn(GUPNP_DEVICE_INFO(proxy));
+ if (!udn) return;
+
+ struct proxy *server = g_hash_table_lookup(proxy_set->servers, udn);
+ if (server) return;
+
+ char *name = gupnp_device_info_get_friendly_name(GUPNP_DEVICE_INFO(proxy));
+ GUPnPServiceInfo *content_dir =
+ gupnp_device_info_get_service(GUPNP_DEVICE_INFO(proxy), CONTENT_DIR);
+
+ if (!name || !content_dir) return;
+
+ server = (struct proxy *)g_malloc(sizeof(struct proxy));
+ server->proxy = proxy;
+ server->name = name;
+ server->set = proxy_set;
+
+ GtkTreeIter iter;
+ gtk_list_store_append(proxy_set->server_list, &iter);
+ gtk_list_store_set(proxy_set->server_list, &iter,
+ COL_ICON, proxy_set->icon, COL_LABEL, server->name, COL_ID, udn,
+ COL_CONTENT, NULL, COL_CONTAINER, TRUE, -1);
+
+ GtkTreeModel *model = GTK_TREE_MODEL(proxy_set->server_list);
+ GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
+ server->row = gtk_tree_row_reference_new(model, path);
+
+ g_hash_table_replace(proxy_set->servers, (char *)udn, server);
+}
+
+void remove_renderer(GUPnPDeviceProxy *proxy, struct proxy_set *proxy_set)
+{
+ const char *udn = gupnp_device_info_get_udn(GUPNP_DEVICE_INFO(proxy));
+ struct proxy *server = g_hash_table_lookup(proxy_set->renderers, udn);
+ if (!server) return;
+
+ GtkTreeModel *model = GTK_TREE_MODEL(proxy_set->renderer_list);
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(model, &iter,
+ gtk_tree_row_reference_get_path(server->row));
+ gtk_list_store_remove(proxy_set->renderer_list, &iter);
+ g_hash_table_remove(proxy_set->renderers, udn);
+ free(server);
+
+ /* TODO: change current selection if necessary */
+}
+
+void remove_server(GUPnPDeviceProxy *proxy, struct proxy_set *proxy_set)
+{
+ const char *udn = gupnp_device_info_get_udn(GUPNP_DEVICE_INFO(proxy));
+ struct proxy *server = g_hash_table_lookup(proxy_set->servers, udn);
+ if (!server) return;
+
+ GtkTreeModel *model = GTK_TREE_MODEL(proxy_set->server_list);
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(model, &iter,
+ gtk_tree_row_reference_get_path(server->row));
+ gtk_list_store_remove(proxy_set->server_list, &iter);
+ g_hash_table_remove(proxy_set->servers, udn);
+ free(server);
+
+ /* TODO: bring user back to server menu if necessary */
+}
+
+void device_proxy_available(GUPnPControlPoint *cp,
+ GUPnPDeviceProxy *proxy, gpointer user_data)
+{
+ struct proxy_set *proxy_set = (struct proxy_set *)user_data;
+ const char *type;
+ type = gupnp_device_info_get_device_type(GUPNP_DEVICE_INFO(proxy));
+
+ if (g_pattern_match_simple(MEDIA_RENDERER, type)) {
+ add_renderer(proxy, proxy_set);
+ } else if (g_pattern_match_simple(MEDIA_SERVER, type)) {
+ add_server(proxy, proxy_set);
+ }
+}
+
+void device_proxy_unavailable(GUPnPControlPoint *cp,
+ GUPnPDeviceProxy *proxy, gpointer user_data)
+{
+ struct proxy_set *proxy_set = (struct proxy_set *)user_data;
+ const char *type;
+ type = gupnp_device_info_get_device_type(GUPNP_DEVICE_INFO(proxy));
+
+ if (g_pattern_match_simple(MEDIA_RENDERER, type)) {
+ remove_renderer(proxy, proxy_set);
+ } else if (g_pattern_match_simple(MEDIA_SERVER, type)) {
+ remove_server(proxy, proxy_set);
+ }
+}
+
+void init_upnp(struct proxy_set *proxy_set)
+{
+ GError *error = NULL;
+
+ g_type_init();
+
+ GUPnPContext *context = gupnp_context_new(NULL, NULL, 0, &error);
+ if (error) {
+ g_printerr("Error creating the GUPnP context: %s\n", error->message);
+ g_error_free(error);
+ exit(1);
+ }
+
+ GUPnPControlPoint *cp = gupnp_control_point_new(context, "ssdp:all");
+
+ g_signal_connect(cp, "device-proxy-available",
+ G_CALLBACK(device_proxy_available), proxy_set);
+ g_signal_connect(cp, "device-proxy-unavailable",
+ G_CALLBACK(device_proxy_unavailable), proxy_set);
+
+ gssdp_resource_browser_set_active(GSSDP_RESOURCE_BROWSER(cp), TRUE);
+}
+
+int main(int argc, char *argv[])
+{
+ g_thread_init(NULL);
+
+ hildon_gtk_init(&argc, &argv);
+
+ HildonProgram *program = hildon_program_get_instance();
+ g_set_application_name(APPLICATION_NAME);
+
+ struct proxy_set proxy_set;
+ proxy_set.renderers = g_hash_table_new(g_str_hash, g_str_equal);
+ proxy_set.servers = g_hash_table_new(g_str_hash, g_str_equal);
+
+ proxy_set.renderer_list = gtk_list_store_new(2, G_TYPE_STRING,
+ G_TYPE_STRING);
+ proxy_set.didl_parser = gupnp_didl_lite_parser_new();
+ GtkWidget *window = main_window(program, &proxy_set);
+ g_signal_connect(G_OBJECT(window), "destroy",
+ G_CALLBACK(gtk_main_quit), NULL);
+
+ init_upnp(&proxy_set);
+
+ gtk_widget_show(window);
+ gtk_main();
+
+ return 0;
+}
projects / devious / commitdiff