void UpnpControlPointService::serviceProxyRemoved (GUPnPControlPoint *cp, GUPnPServiceProxy *proxy, gpointer data)
{
UpnpControlPointService* pThis = static_cast<UpnpControlPointService*>(data);
const char* type = gupnp_service_info_get_service_type(GUPNP_SERVICE_INFO(proxy));
const char* location = gupnp_service_info_get_location(GUPNP_SERVICE_INFO(proxy));
g_print("Service removed: \n");
g_print("\ttype: %s\n", type);
g_print("\tlocation: %s\n", location);
}
static void
service_proxy_unavailable_cb (G_GNUC_UNUSED GUPnPControlPoint *cp,
GUPnPServiceProxy *proxy)
{
const char *type, *location;
type = gupnp_service_info_get_service_type (GUPNP_SERVICE_INFO (proxy));
location = gupnp_service_info_get_location (GUPNP_SERVICE_INFO (proxy));
g_print ("Service unavailable:\n");
g_print ("\ttype: %s\n", type);
g_print ("\tlocation: %s\n", location);
}
static GUPnPServiceInfo *
gupnp_device_proxy_get_service (GUPnPDeviceInfo *info,
xmlNode *element)
{
GUPnPResourceFactory *factory;
GUPnPServiceProxy *service;
GUPnPContext *context;
GUPnPXMLDoc *doc;
const char *location, *udn;
const SoupURI *url_base;
factory = gupnp_device_info_get_resource_factory (info);
context = gupnp_device_info_get_context (info);
doc = _gupnp_device_info_get_document (info);
udn = gupnp_device_info_get_udn (info);
location = gupnp_device_info_get_location (info);
url_base = gupnp_device_info_get_url_base (info);
service = gupnp_resource_factory_create_service_proxy (factory,
context,
doc,
element,
udn,
NULL,
location,
url_base);
return GUPNP_SERVICE_INFO (service);
}
static void
gupnp_service_info_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GUPnPServiceInfo *info;
GUPnPServiceInfoPrivate *priv;
info = GUPNP_SERVICE_INFO (object);
priv = gupnp_service_info_get_instance_private (info);
switch (property_id) {
case PROP_CONTEXT:
g_value_set_object (value, priv->context);
break;
case PROP_LOCATION:
g_value_set_string (value, priv->location);
break;
case PROP_UDN:
g_value_set_string (value, priv->udn);
break;
case PROP_SERVICE_TYPE:
g_value_set_string (value,
gupnp_service_info_get_service_type (info));
break;
case PROP_URL_BASE:
g_value_set_boxed (value, priv->url_base);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
service_proxy_unavailable_cb (G_GNUC_UNUSED GUPnPControlPoint *cp,
GUPnPServiceProxy *proxy)
{
const char *location;
location = gupnp_service_info_get_location (GUPNP_SERVICE_INFO (proxy));
g_print ("ContentDirectory unavailable:\n");
g_print ("\tlocation: %s\n", location);
}
static void
_cp_service_unavail (GUPnPControlPoint *cp,
GUPnPServiceProxy *proxy,
GUPnPSimpleIgd *self)
{
guint i;
for (i=0; i < self->priv->service_proxies->len; i++)
{
struct Proxy *prox = g_ptr_array_index (self->priv->service_proxies, i);
if (prox->cp == cp &&
!strcmp (gupnp_service_info_get_udn (GUPNP_SERVICE_INFO (proxy)),
gupnp_service_info_get_udn (GUPNP_SERVICE_INFO (prox->proxy))))
{
free_proxy (prox);
g_ptr_array_remove_index_fast (self->priv->service_proxies, i);
break;
}
}
}
static void
service_proxy_available_cb (G_GNUC_UNUSED GUPnPControlPoint *cp,
GUPnPServiceProxy *proxy)
{
GUPnPServiceInfo *info;
info = GUPNP_SERVICE_INFO (proxy);
gupnp_service_info_get_introspection_async_full (info,
got_introspection,
cancellable,
NULL);
}
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);
}
static void
on_state_variable_changed (GUPnPServiceProxy *proxy,
const char *variable_name,
GValue *value,
gpointer user_data)
{
GUPnPServiceInfo *info = GUPNP_SERVICE_INFO (proxy);
GUPnPDeviceInfo *device_info;
GValue str_value;
char *id;
char *friendly_name;
char *notified_at;
struct tm *tm;
time_t current_time;
/* Get the parent device */
device_info = get_service_device (info);
g_return_if_fail (device_info != NULL);
friendly_name = gupnp_device_info_get_friendly_name (device_info);
g_object_unref (device_info);
id = gupnp_service_info_get_id (info);
/* We neither keep devices without friendlyname
* nor services without an id
*/
g_assert (friendly_name != NULL);
g_assert (id != NULL);
memset (&str_value, 0, sizeof (GValue));
g_value_init (&str_value, G_TYPE_STRING);
g_value_transform (value, &str_value);
current_time = time (NULL);
tm = localtime (¤t_time);
notified_at = g_strdup_printf ("%02d:%02d",
tm->tm_hour,
tm->tm_min);
display_event (notified_at,
friendly_name,
id,
variable_name,
g_value_get_string (&str_value));
g_free (notified_at);
g_free (friendly_name);
g_free (id);
g_value_unset (&str_value);
}
static void
gupnp_service_info_finalize (GObject *object)
{
GUPnPServiceInfo *info;
info = GUPNP_SERVICE_INFO (object);
g_free (info->priv->location);
g_free (info->priv->udn);
g_free (info->priv->service_type);
soup_uri_free (info->priv->url_base);
G_OBJECT_CLASS (gupnp_service_info_parent_class)->finalize (object);
}
static void
gupnp_service_info_dispose (GObject *object)
{
GUPnPServiceInfo *info;
GUPnPServiceInfoPrivate *priv;
info = GUPNP_SERVICE_INFO (object);
priv = gupnp_service_info_get_instance_private (info);
/* Cancel any pending SCPD GETs */
if (priv->context) {
SoupSession *session;
session = gupnp_context_get_session (priv->context);
while (priv->pending_gets) {
GetSCPDURLData *data;
data = priv->pending_gets->data;
if (data->cancellable)
g_cancellable_disconnect (data->cancellable,
data->cancelled_id);
soup_session_cancel_message (session,
data->message,
SOUP_STATUS_CANCELLED);
get_scpd_url_data_free (data);
priv->pending_gets =
g_list_delete_link (priv->pending_gets,
priv->pending_gets);
}
/* Unref context */
g_object_unref (priv->context);
priv->context = NULL;
}
if (priv->doc) {
g_object_unref (priv->doc);
priv->doc = NULL;
}
G_OBJECT_CLASS (gupnp_service_info_parent_class)->dispose (object);
}
static void
append_device_tree (GUPnPDeviceInfo *info,
GtkTreeModel *model,
GtkTreeIter *parent_iter)
{
char *friendly_name;
friendly_name = gupnp_device_info_get_friendly_name (info);
if (friendly_name) {
GtkTreeIter device_iter;
GList *child;
gtk_tree_store_insert_with_values
(GTK_TREE_STORE (model),
&device_iter, parent_iter, -1,
0, get_icon_by_id (ICON_DEVICE),
1, friendly_name,
2, info,
5, ICON_DEVICE,
-1);
g_free (friendly_name);
schedule_icon_update (info, on_device_icon_available);
/* Append the embedded devices */
child = gupnp_device_info_list_devices (info);
while (child) {
append_device_tree (GUPNP_DEVICE_INFO (child->data),
model,
&device_iter);
g_object_unref (child->data);
child = g_list_delete_link (child, child);
}
/* Append the services */
child = gupnp_device_info_list_services (info);
while (child) {
append_service_tree (GUPNP_SERVICE_INFO (child->data),
GTK_TREE_STORE (model),
&device_iter);
g_object_unref (child->data);
child = g_list_delete_link (child, child);
}
}
}
static void
gupnp_service_info_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GUPnPServiceInfo *info;
info = GUPNP_SERVICE_INFO (object);
switch (property_id) {
case PROP_CONTEXT:
info->priv->context = g_object_ref (g_value_get_object (value));
break;
case PROP_LOCATION:
info->priv->location = g_value_dup_string (value);
break;
case PROP_UDN:
info->priv->udn = g_value_dup_string (value);
break;
case PROP_SERVICE_TYPE:
info->priv->service_type = g_value_dup_string (value);
break;
case PROP_URL_BASE:
info->priv->url_base = g_value_get_pointer (value);
if (info->priv->url_base)
info->priv->url_base =
soup_uri_copy (info->priv->url_base);
break;
case PROP_DOCUMENT:
info->priv->doc = g_value_dup_object (value);
break;
case PROP_ELEMENT:
info->priv->element = g_value_get_pointer (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static GUPnPServiceInfo *
gupnp_device_get_service (GUPnPDeviceInfo *info,
xmlNode *element)
{
GUPnPDevice *device;
GUPnPService *service;
GUPnPResourceFactory *factory;
GUPnPContext *context;
GUPnPDevice *root_device;
const char *location, *udn;
const SoupURI *url_base;
device = GUPNP_DEVICE (info);
root_device = GUPNP_IS_ROOT_DEVICE (device) ? device :
GUPNP_DEVICE (device->priv->root_device);
if (root_device == NULL) {
g_warning ("Root device not found.");
return NULL;
}
factory = gupnp_device_info_get_resource_factory (info);
context = gupnp_device_info_get_context (info);
udn = gupnp_device_info_get_udn (info);
location = gupnp_device_info_get_location (info);
url_base = gupnp_device_info_get_url_base (info);
service = gupnp_resource_factory_create_service (factory,
context,
root_device,
element,
udn,
location,
url_base);
return GUPNP_SERVICE_INFO (service);
}
static void on_service_proxy_action_ret (GUPnPServiceProxy *proxy,
GUPnPServiceProxyAction *action,
gpointer user_data)
{
GError *error = NULL;
gupnp_service_proxy_end_action (proxy,
action,
&error,
NULL);
if (error) {
GUPnPServiceInfo *info = GUPNP_SERVICE_INFO (proxy);
g_warning ("Failed to call action \"%s\" on \"%s\": %s",
(char *) user_data,
gupnp_service_info_get_location (info),
error->message);
g_error_free (error);
}
g_free (user_data);
}
void
run_action_dialog (GUPnPServiceActionInfo *action_info,
GUPnPServiceProxy *proxy,
GUPnPServiceIntrospection *introspection)
{
GList *in_arguments;
GList *out_arguments;
setup_action_dialog_labels (GUPNP_SERVICE_INFO (proxy), action_info);
in_arguments = find_arguments_by_direction (
action_info->arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN);
populate_action_arguments_grid (
in_args_grid,
in_arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN,
introspection);
out_arguments = find_arguments_by_direction (
action_info->arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_OUT);
populate_action_arguments_grid (
out_args_grid,
out_arguments,
GUPNP_SERVICE_ACTION_ARG_DIRECTION_OUT,
introspection);
/* If the action only has out arguments, open the out expander */
if (!in_arguments)
gtk_expander_set_expanded (GTK_EXPANDER (out_args_expander), TRUE);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_hide (dialog);
}
static GList *
find_service_node (GUPnPControlPoint *control_point,
const char *udn,
const char *service_type)
{
GList *l;
l = control_point->priv->services;
while (l) {
GUPnPServiceInfo *info;
info = GUPNP_SERVICE_INFO (l->data);
if ((strcmp (gupnp_service_info_get_udn (info), udn) == 0) &&
(strcmp (gupnp_service_info_get_service_type (info),
service_type) == 0))
break;
l = l->next;
}
return l;
}
static void
service_proxy_available_cb (G_GNUC_UNUSED GUPnPControlPoint *cp,
GUPnPServiceProxy *proxy)
{
const char *location;
char *result = NULL;
guint count, total;
GError *error = NULL;
location = gupnp_service_info_get_location (GUPNP_SERVICE_INFO (proxy));
g_print ("ContentDirectory available:\n");
g_print ("\tlocation: %s\n", location);
/* We want to be notified whenever SystemUpdateID (of type uint)
* changes */
gupnp_service_proxy_add_notify (proxy,
"SystemUpdateID",
G_TYPE_UINT,
notify_cb,
(gpointer) "Test");
/* Subscribe */
g_signal_connect (proxy,
"subscription-lost",
G_CALLBACK (subscription_lost_cb),
NULL);
gupnp_service_proxy_set_subscribed (proxy, TRUE);
/* And test action IO */
gupnp_service_proxy_send_action (proxy,
"Browse",
&error,
/* IN args */
"ObjectID",
G_TYPE_STRING,
"0",
"BrowseFlag",
G_TYPE_STRING,
"BrowseDirectChildren",
"Filter",
G_TYPE_STRING,
"*",
"StartingIndex",
G_TYPE_UINT,
0,
"RequestedCount",
G_TYPE_UINT,
0,
"SortCriteria",
G_TYPE_STRING,
"",
NULL,
/* OUT args */
"Result",
G_TYPE_STRING,
&result,
"NumberReturned",
G_TYPE_UINT,
&count,
"TotalMatches",
G_TYPE_UINT,
&total,
NULL);
if (error) {
g_printerr ("Error: %s\n", error->message);
g_error_free (error);
return;
}
g_print ("Browse returned:\n");
g_print ("\tResult: %s\n", result);
g_print ("\tNumberReturned: %u\n", count);
g_print ("\tTotalMatches: %u\n", total);
g_free (result);
}