C++ DLEYNA_LOG_DEBUG函数代码示例

void dls_upnp_create_container(dls_upnp_t *upnp, dls_client_t *client,
			       dls_task_t *task,
			       dls_upnp_task_complete_t cb)
{
	dls_async_task_t *cb_data = (dls_async_task_t *)task;

	DLEYNA_LOG_DEBUG("Enter");

	cb_data->cb = cb;

	DLEYNA_LOG_DEBUG("Root Path %s Id %s", task->target.root_path,
			 task->target.id);

	dls_device_create_container(client, task, task->target.id);

	DLEYNA_LOG_DEBUG("Exit");
}

static void prv_free_cb(gpointer data)
{
	dleyna_task_queue_t *task_queue = data;

	DLEYNA_LOG_DEBUG("Enter");

	g_ptr_array_foreach(task_queue->tasks, prv_task_free_cb, task_queue);
	g_ptr_array_unref(task_queue->tasks);

	if (task_queue->task_queue_finally_cb)
		task_queue->task_queue_finally_cb(task_queue->cancelled,
						  task_queue->user_data);

	g_free(task_queue);

	DLEYNA_LOG_DEBUG("Exit");
}

void dld_upnp_get_prop(dld_upnp_t *upnp, dld_task_t *task,
		       dld_upnp_task_complete_t cb)
{
	dld_device_t *device;

	DLEYNA_LOG_DEBUG("Enter");

	DLEYNA_LOG_DEBUG("Path: %s", task->path);
	DLEYNA_LOG_DEBUG("Interface %s", task->ut.get_prop.interface_name);
	DLEYNA_LOG_DEBUG("Prop.%s", task->ut.get_prop.prop_name);

	device = prv_get_and_check_device(upnp, task, cb);
	if (device != NULL)
		dld_device_get_prop(device, task, cb);

	DLEYNA_LOG_DEBUG("Exit");
}

static GUPnPServiceInfo *prv_remove_bm_service_sub_devices(
						GUPnPDeviceInfo *device_info,
						dld_upnp_t *upnp,
						const gchar *ip_address)
{
	GList *child_devices;
	GList *next;
	GUPnPDeviceInfo *child_info = NULL;
	GUPnPServiceInfo *service_info = NULL;

	DLEYNA_LOG_DEBUG("Enter");

	child_devices = gupnp_device_info_list_devices(device_info);

	next = child_devices;
	while (next != NULL) {
		child_info = (GUPnPDeviceInfo *)next->data;

		service_info = gupnp_device_info_get_service(child_info,
					  DLD_BASIC_MANAGEMENT_SERVICE_TYPE);

		if (service_info != NULL)
			prv_remove_sub_device(upnp,
					      (GUPnPDeviceProxy *)child_info,
					      (GUPnPServiceProxy *)service_info,
					      ip_address);

		service_info = prv_remove_bm_service_sub_devices(child_info,
								 upnp,
								 ip_address);

		if (service_info != NULL)
			prv_remove_sub_device(upnp,
					      (GUPnPDeviceProxy *)child_info,
					      (GUPnPServiceProxy *)service_info,
					      ip_address);

		next = g_list_next(next);
	}

	g_list_free_full(child_devices, g_object_unref);

	DLEYNA_LOG_DEBUG("Exit");

	return service_info;
}

static void prv_connector_connect(
			const gchar *server_name,
			dleyna_connector_connected_cb_t connected_cb,
			dleyna_connector_disconnected_cb_t disconnected_cb)
{
	DLEYNA_LOG_DEBUG("Enter");

	g_context.connected_cb = connected_cb;
	g_context.disconnected_cb = disconnected_cb;

	g_context.owner_id = g_bus_own_name(G_BUS_TYPE_SESSION,
					    server_name,
					    G_BUS_NAME_OWNER_FLAGS_NONE,
					    prv_bus_acquired, NULL,
					    prv_name_lost, NULL, NULL);

	DLEYNA_LOG_DEBUG("Exit");
}

static void prv_cancel(const dleyna_task_queue_key_t *queue_id,
		       dleyna_task_queue_t *task_queue)
{
	if (prv_cancel_only(queue_id, task_queue)) {
		DLEYNA_LOG_DEBUG("Removing queue <%s,%s>",
				 queue_id->source, queue_id->sink);
		g_hash_table_remove(queue_id->processor->task_queues, queue_id);
	}
}

void dleyna_white_list_enable(dleyna_white_list_t *wl,
			      gboolean enabled)
{
	if (wl->gupnp_wl != NULL) {
		gupnp_white_list_set_enabled(wl->gupnp_wl, enabled);

		DLEYNA_LOG_DEBUG("White List enabled: %d", enabled);
	}
}

static guint prv_connector_publish_subtree(
				dleyna_connector_id_t connection,
				const gchar *object_path,
				const dleyna_connector_dispatch_cb_t *cb_table,
				guint cb_table_size,
				dleyna_connector_interface_filter_cb_t cb)
{
	guint flags;
	guint object_id;
	dleyna_dbus_object_t *object;
	guint *object_key;

	DLEYNA_LOG_DEBUG("Enter, path = <%s>", object_path);

	object = g_new0(dleyna_dbus_object_t, 1);

	flags = G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES;
	object_id = g_dbus_connection_register_subtree(
						(GDBusConnection *)connection,
						object_path,
						&g_subtree_vtable,
						flags,
						object,
						NULL, NULL);

	if (object_id) {
		object->id = object_id;
		object->root_path = g_strdup(object_path);
		object->dispatch_table = cb_table;
		object->dispatch_table_size = cb_table_size;
		object->filter_cb = cb;

		object_key = g_new(guint, 1);
		*object_key = object_id;
		g_hash_table_insert(g_context.objects, object_key, object);
	} else {
		g_free(object);
	}

	DLEYNA_LOG_DEBUG("Exit, object_id = %u", object_id);

	return object_id;
}

void dleyna_connector_mgr_release(const dleyna_connector_t *connector)
{
	GModule *module;

	DLEYNA_LOG_DEBUG("Enter");

	module = g_hash_table_lookup(g_connectors, connector);
	if (module) {
		g_module_close(module);

		g_hash_table_remove(g_connectors, connector);
		if (g_hash_table_size(g_connectors) == 0) {
			g_hash_table_unref(g_connectors);
			g_connectors = NULL;
		}
	}

	DLEYNA_LOG_DEBUG("Exit");
}

void dls_upnp_create_reference(dls_upnp_t *upnp, dls_client_t *client,
			       dls_task_t *task,
			       dls_upnp_task_complete_t cb)
{
	dls_async_task_t *cb_data = (dls_async_task_t *)task;

	DLEYNA_LOG_DEBUG("Enter");

	cb_data->cb = cb;

	DLEYNA_LOG_DEBUG("Root Path: %s - Id: %s", task->target.root_path,
			 task->target.id);

	dls_device_create_reference(client, task);

	DLEYNA_LOG_DEBUG("Exit");

	return;
}

dleyna_task_processor_t *dleyna_task_processor_new(GSourceFunc on_quit_cb)
{
	dleyna_task_processor_t *processor;

	DLEYNA_LOG_DEBUG("Enter");

	processor = g_malloc(sizeof(*processor));

	processor->task_queues = g_hash_table_new_full(prv_key_hash_cb,
						       prv_key_equal_cb,
						       prv_key_free_cb,
						       prv_free_cb);
	processor->running_tasks = 0;
	processor->quitting = FALSE;
	processor->on_quit_cb = on_quit_cb;

	DLEYNA_LOG_DEBUG("Exit");

	return processor;
}

static void prv_dump_wl_entries(GUPnPWhiteList *wl)
{
	GList *l;

	l = gupnp_white_list_get_entries(wl);

	DLEYNA_LOG_DEBUG_NL();
	DLEYNA_LOG_DEBUG("White List entries:");

	if (l != NULL) {
		while (l != NULL) {
			DLEYNA_LOG_DEBUG("     Entry: [%s].", (char *)l->data);
			l = l->next;
		}
	} else {
		DLEYNA_LOG_DEBUG("     White List Empty.");
	}

	DLEYNA_LOG_DEBUG_NL();
}

void dleyna_white_list_clear(dleyna_white_list_t *wl)
{
	if (wl->gupnp_wl != NULL) {
		DLEYNA_LOG_DEBUG("Clear white list");
		gupnp_white_list_clear(wl->gupnp_wl);

#if DLEYNA_LOG_LEVEL & DLEYNA_LOG_LEVEL_DEBUG
		prv_dump_wl_entries(wl->gupnp_wl);
#endif
	}
}

const dleyna_connector_t *dleyna_connector_mgr_load(const gchar *name)
{
	GModule *module;
	const dleyna_connector_t *connector;
	dleyna_connector_get_interface_t get_interface;
	gchar *path;

	DLEYNA_LOG_DEBUG("Enter");

	path = g_strdup_printf("%s/%s%s.so", CONNECTOR_DIR,
			       DLEYNA_CONNECTOR_LIB_PATTERN, name);
	module = g_module_open(path, G_MODULE_BIND_LAZY);
	g_free(path);

	if (module) {
		if (!g_connectors)
			g_connectors = g_hash_table_new(g_direct_hash,
							g_direct_equal);

		if (g_module_symbol(module, "dleyna_connector_get_interface",
				    (gpointer *)&get_interface)) {
			connector = get_interface();
			g_hash_table_insert(g_connectors, (gpointer)connector,
					    module);
		} else {
			connector = NULL;
			g_module_close(module);
			DLEYNA_LOG_CRITICAL(
					"Connector '%s' entry point not found",
					name);
		}

	} else {
		connector = NULL;
		DLEYNA_LOG_CRITICAL("Connector '%s' not found", name);
	}

	DLEYNA_LOG_DEBUG("Exit");

	return connector;
}

static void prv_device_available_cb(GUPnPControlPoint *cp,
				    GUPnPDeviceProxy *proxy,
				    gpointer user_data)
{
	dld_upnp_t *upnp = user_data;
	const char *udn;
	const gchar *ip_address;
	GUPnPServiceProxy *bms_proxy;

	DLEYNA_LOG_DEBUG("Enter");

	udn = gupnp_device_info_get_udn((GUPnPDeviceInfo *)proxy);

	ip_address = gupnp_context_get_host_ip(
					gupnp_control_point_get_context(cp));

	if (!udn || !ip_address)
		goto on_error;

	DLEYNA_LOG_DEBUG("UDN %s", udn);
	DLEYNA_LOG_DEBUG("IP Address %s", ip_address);

	bms_proxy = (GUPnPServiceProxy *)
			gupnp_device_info_get_service(
					(GUPnPDeviceInfo *)proxy,
					DLD_BASIC_MANAGEMENT_SERVICE_TYPE);

	if (bms_proxy != NULL)
		prv_add_device(upnp, proxy, bms_proxy, ip_address, udn);

	(void) prv_add_bm_service_sub_devices((GUPnPDeviceInfo *)proxy,
					      upnp,
					      ip_address);

on_error:

	DLEYNA_LOG_DEBUG("Exit");
	DLEYNA_LOG_DEBUG_NL();

	return;
}