From: Luc Yriarte Date: Tue, 30 Jul 2013 07:28:38 +0000 (+0200) Subject: Merge branch 'tizen' into mediaserver X-Git-Tag: submit/tizen/20130807.192244~6^2~2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=aebaf66a7497d8d6749ef3fe41ed7345a2c74ea9;hp=4018d4648695d59b1bcd5114b342e098a50b0967;p=profile%2Fivi%2Fwrt-plugins-ivi.git Merge branch 'tizen' into mediaserver --- diff --git a/packaging/wrt-plugins-ivi.spec b/packaging/wrt-plugins-ivi.spec index 1616140..1a56c93 100644 --- a/packaging/wrt-plugins-ivi.spec +++ b/packaging/wrt-plugins-ivi.spec @@ -19,6 +19,7 @@ BuildRequires: pkgconfig(wrt-plugins-commons-javascript) BuildRequires: wrt-plugins-tizen-devel BuildRequires: pkgconfig(wrt-plugins-plugin-manager) BuildRequires: pkgconfig(security-server) +BuildRequires: dleyna BuildRequires: expat-devel BuildRequires: cmake BuildRequires: gettext-devel diff --git a/pkgconfigs/wrt-plugins-tizen-mediaserver.pc.in b/pkgconfigs/wrt-plugins-tizen-mediaserver.pc.in new file mode 100644 index 0000000..9bf5d3b --- /dev/null +++ b/pkgconfigs/wrt-plugins-tizen-mediaserver.pc.in @@ -0,0 +1,13 @@ +prefix=/usr +project_name=@CMAKE_PROJECT_NAME@ +module_name=mediaserver +exec_prefix=${prefix} +libdir=${prefix}/lib/wrt-plugins/tizen-${module_name} +includedir=${prefix}/include/${project_name} + +Name: wrt-plugins-tizen-${module_name} +Description: wrt-plugins-tizen-${module_name} +Version: @CMAKE_PROJECT_VERSION@ +Requires: icu-i18n icu-io icu-le icu-lx icu-uc +Libs: -L${libdir} -lwrt-plugins-tizen-${module_name}-impl +Cflags: -I${includedir}/${module_name} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b7f1ca4..ba21fae 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -19,5 +19,6 @@ SET(LIBS_TEST add_plugin( Vehicle + MediaServer ) diff --git a/src/MediaServer/CMakeLists.txt b/src/MediaServer/CMakeLists.txt new file mode 100755 index 0000000..1aa5596 --- /dev/null +++ b/src/MediaServer/CMakeLists.txt @@ -0,0 +1,76 @@ +SET(TARGET_NAME ${mediaserver_target}) +SET(DESTINATION_NAME ${mediaserver_dest}) +SET(TARGET_IMPL_NAME ${mediaserver_impl}) + +cmake_minimum_required(VERSION 2.8) + +add_definitions(-std=c++11) + +include(FindPkgConfig) + +PKG_CHECK_MODULES(amb REQUIRED gio-2.0 wrt-plugins-tizen-common) + +find_library(uuid_LIBRARY uuid DOC "Uuid libraries") +find_path(uuid_INCLUDE_DIR uuid/uuid.h DOC "Libtool headers") + +if(uuid_LIBRARY) + message(STATUS "uuid found") +else(uuid_LIBRARY) + message(FATAL_ERROR "uuid missing. please install uuid-dev") +endif(uuid_LIBRARY) + + + +INCLUDE_DIRECTORIES( + ${INCLUDE_COMMON} + ${amb_INCLUDE_DIRS} + ${uuid_INCLUDE_DIR} +) + +SET(CMAKE_INSTALL_RPATH + ${CMAKE_INSTALL_RPATH} + ${CMAKE_INSTALL_PREFIX}/${DESTINATION_LIB_PREFIX}/${tizen_dest} + ${CMAKE_INSTALL_PREFIX}/${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME} +) + +SET(SRCS_IMPL + JSMediaServerManager.cpp + MediaServerManager.cpp + JSMediaServer.cpp + MediaServer.cpp +) + +SET(SRCS_PROXY + dleynaserver-manager-proxy.c + dleynaserver-mediadevice-proxy.c + upnp-mediacontainer2-proxy.c + upnp-mediaobject2-proxy.c +) + +ADD_LIBRARY(${TARGET_IMPL_NAME} SHARED ${SRCS_IMPL} ${SRCS_PROXY}) + +TARGET_LINK_LIBRARIES(${TARGET_IMPL_NAME} + ${LIBS_COMMON} + ${amb_LIBRARIES} + ${uuid_LIBRARY} + -L/usr/lib/wrt-plugins/tizen-tizen/ +) + +SET(SRCS + plugin_initializer.cpp +) + +ADD_LIBRARY(${TARGET_NAME} SHARED ${SRCS}) + +TARGET_LINK_LIBRARIES(${TARGET_NAME} + ${TARGET_IMPL_NAME} +) + +INSTALL(TARGETS ${TARGET_NAME} ${TARGET_IMPL_NAME} LIBRARY DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME}) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.xml DESTINATION ${DESTINATION_LIB_PREFIX}/${DESTINATION_NAME}) +INSTALL( + DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${DESTINATION_HEADER_PREFIX}/mediaserver + FILES_MATCHING PATTERN "*.h" PATTERN "CMakeFiles" EXCLUDE +) + + diff --git a/src/MediaServer/CMakeLists.txt.user b/src/MediaServer/CMakeLists.txt.user new file mode 100644 index 0000000..42cf274 --- /dev/null +++ b/src/MediaServer/CMakeLists.txt.user @@ -0,0 +1,178 @@ + + + + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + true + 1 + true + 1 + true + 1 + 8 + true + 1 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop + {0ed07035-58b9-4556-86c7-eaa33ca4d732} + 0 + 0 + 0 + + /home/tripzero/src/wrt-plugins-tizen/src/MediaServerManager-build + false + + + + + false + false + true + Make + + CMakeProjectManager.MakeStep + + 1 + Build + + ProjectExplorer.BuildSteps.Build + + + + clean + + true + false + true + Make + + CMakeProjectManager.MakeStep + + 1 + Clean + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + all + + CMakeProjectManager.CMakeBuildConfiguration + + 1 + + + 0 + Deploy + + ProjectExplorer.BuildSteps.Deploy + + 1 + Deploy locally + + ProjectExplorer.DefaultDeployConfiguration + + 1 + + true + + false + false + false + false + true + 0.01 + 10 + true + 25 + + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + + 2 + + false + + %{buildDir} + Custom Executable + + ProjectExplorer.CustomExecutableRunConfiguration + 3768 + true + false + false + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.EnvironmentId + {a45d451d-b7c5-4849-8e78-a87fad4889b9} + + + ProjectExplorer.Project.Updater.FileVersion + 12 + + diff --git a/src/MediaServer/EventMediaServerManagerPropertyChanged.h b/src/MediaServer/EventMediaServerManagerPropertyChanged.h new file mode 100644 index 0000000..8871f70 --- /dev/null +++ b/src/MediaServer/EventMediaServerManagerPropertyChanged.h @@ -0,0 +1,37 @@ +#ifndef TIZENAPIS_API_MEDIASERVERMANAGER_EVENT_PROPERTY_CHANGED_H_ +#define TIZENAPIS_API_MEDIASERVERMANAGER_EVENT_PROPERTY_CHANGED_H_ + +#include +#include + +namespace DeviceAPI { +namespace MediaServer { + +class EventMediaServerManagerPropertyChanged : public WrtDeviceApis::Commons::IEvent +{ +private: + /* parameter */ + std::string m_contextId; + +public: + void setContextId(std::string contextId) + { + m_contextId = contextId; + } + + std::string getContextId() const + { + return m_contextId; + } + + EventMediaServerManagerPropertyChanged() + { + } +}; + +typedef DPL::SharedPtr EventMediaServerManagerPropertyChangedPtr; + +} // Application +} // DeviceAPI + +#endif diff --git a/src/MediaServer/EventMediaServerPropertyChanged.h b/src/MediaServer/EventMediaServerPropertyChanged.h new file mode 100644 index 0000000..fb5c0d1 --- /dev/null +++ b/src/MediaServer/EventMediaServerPropertyChanged.h @@ -0,0 +1,37 @@ +#ifndef TIZENAPIS_API_MEDIASERVER_EVENT_PROPERTY_CHANGED_H_ +#define TIZENAPIS_API_MEDIASERVER_EVENT_PROPERTY_CHANGED_H_ + +#include +#include + +namespace DeviceAPI { +namespace MediaServer { + +class EventMediaServerPropertyChanged : public WrtDeviceApis::Commons::IEvent +{ +private: + /* parameter */ + std::string m_contextId; + +public: + void setContextId(std::string contextId) + { + m_contextId = contextId; + } + + std::string getContextId() const + { + return m_contextId; + } + + EventMediaServerPropertyChanged() + { + } +}; + +typedef DPL::SharedPtr EventMediaServerPropertyChangedPtr; + +} // Application +} // DeviceAPI + +#endif diff --git a/src/MediaServer/JSMediaServer.cpp b/src/MediaServer/JSMediaServer.cpp new file mode 100644 index 0000000..e7cfc01 --- /dev/null +++ b/src/MediaServer/JSMediaServer.cpp @@ -0,0 +1,239 @@ +#include "JSMediaServer.h" +#include "MediaServer.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace DeviceAPI { +namespace MediaServer { + +using namespace DPL; +using namespace DeviceAPI::Common; +using namespace WrtDeviceApis::Commons; +using namespace WrtDeviceApis::CommonsJavaScript; + +JSClassDefinition JSMediaServer::m_classInfo = { + 0, + kJSClassAttributeNone, + "MediaServer", + 0, + m_property, + m_function, + initialize, + finalize, + NULL, //HasProperty, + NULL, //GetProperty, + NULL, //SetProperty, + NULL, //DeleteProperty, + NULL, //GetPropertyNames, + NULL, //CallAsFunction, + NULL, //CallAsConstructor, + hasInstance, + NULL, //ConvertToType +}; + +JSStaticValue JSMediaServer::m_property[] = +{ + {"id", getProperty, NULL, kJSPropertyAttributeReadOnly}, + {"friendlyName", getProperty, NULL, kJSPropertyAttributeReadOnly}, + {"root", getProperty, NULL, kJSPropertyAttributeReadOnly}, + { 0, 0, 0, 0 } +}; + +JSStaticFunction JSMediaServer::m_function[] = { + {"browse", JSMediaServer::browse, kJSPropertyAttributeNone}, + {"find", JSMediaServer::find, kJSPropertyAttributeNone}, + { 0, 0, 0 } +}; + +const JSClassRef JSMediaServer::getClassRef() +{ + if (!m_jsClassRef) + { + m_jsClassRef = JSClassCreate(&m_classInfo); + } + return m_jsClassRef; +} + +const JSClassDefinition* JSMediaServer::getClassInfo() +{ + return &m_classInfo; +} + +JSClassRef JSMediaServer::m_jsClassRef = JSClassCreate(JSMediaServer::getClassInfo()); + +JSObjectRef JSMediaServer::createJSObject(JSContextRef context) { + LoggerD("Entered JSMediaServer::createJSObject"); + MediaServerPtr mediaserver(new MediaServer()); + MediaServerPrivObject* priv = new MediaServerPrivObject(context, mediaserver); + return JSObjectMake(context, getClassRef(), priv); +} + +JSObjectRef JSMediaServer::createJSObject(JSContextRef context, std::string path) { + LoggerD("Entered JSMediaServer::createJSObject : " << path.c_str()); + MediaServer *ms = new MediaServer(); + ms->setProxyPath(path); + MediaServerPtr mediaserver(ms); + MediaServerPrivObject* priv = new MediaServerPrivObject(context, mediaserver); + return JSObjectMake(context, getClassRef(), priv); +} + +void JSMediaServer::initialize(JSContextRef context, JSObjectRef object) +{ + LoggerD("Entered JSMediaServer::initialize"); + MediaServerPrivObject* priv = static_cast(JSObjectGetPrivate(object)); + if (!priv) + { + LoggerD("Create private object"); + MediaServerPtr mediaserver(new MediaServer()); + priv = new MediaServerPrivObject(context, mediaserver); + if(!JSObjectSetPrivate(object, static_cast(priv))) + { + LoggerE("Object can't store private data."); + delete priv; + } + } + + LoggerD("JSMediaServer::initialize done"); +} + +void JSMediaServer::finalize(JSObjectRef object) +{ + MediaServerPrivObject* priv = static_cast(JSObjectGetPrivate(object)); + JSObjectSetPrivate(object, NULL); + LoggerD("JSMediaServer::finalize"); + delete priv; +} + +bool JSMediaServer::hasInstance(JSContextRef context, + JSObjectRef constructor, + JSValueRef possibleInstance, + JSValueRef* exception) +{ + return JSValueIsObjectOfClass(context, possibleInstance, getClassRef()); +} + + +JSValueRef JSMediaServer::getProperty(JSContextRef context, + JSObjectRef object, + JSStringRef propertyName, + JSValueRef* exception) +{ + LoggerD("Entered JSMediaServer::getProperty"); + // TODO try/catch block + MediaServerPrivObject* privateObject = static_cast(JSObjectGetPrivate(object)); + if (NULL == privateObject) + { + LoggerE("private object is null"); + // TODO post exception + } + MediaServerPtr server(privateObject->getObject()); + + Converter converter(context); + std::string name = converter.toString(propertyName); + LoggerD("JSMediaServer::getProperty : " << name.c_str()); + JSStringRef jsStr = converter.toJSStringRef(server->getPropertyStringValue(name)); + + if (JSStringIsEqualToUTF8CString(propertyName, "id")) + return JSValueMakeString(context, jsStr); + else if (JSStringIsEqualToUTF8CString(propertyName, "friendlyName")) + return JSValueMakeString(context, jsStr); + else if (JSStringIsEqualToUTF8CString(propertyName, "root")) + return JSValueMakeFromJSONString(context, jsStr); + + return JSValueMakeUndefined(context); +} + + + +JSValueRef JSMediaServer::browse(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception) +{ + LoggerD("Entered JSMediaServer::browse"); + // TODO try/catch block + MediaServerPrivObject* privateObject = static_cast(JSObjectGetPrivate(object)); + if (NULL == privateObject) + { + LoggerE("private object is null"); + // TODO post exception + } + + LoggerD("Validating arguments: " << argumentCount); + + ArgumentValidator validator(context, argumentCount, arguments); + std::string containerId = validator.toString(0); + std::string sortMode = validator.toString(1); + unsigned long count = validator.toULong(2); + unsigned long offset = validator.toULong(3); + + BrowseFindCB *cbP = new BrowseFindCB(); + cbP->context = context; + cbP->object = object; + cbP->thisObject = thisObject; + cbP->successCB = validator.toFunction(4, true); + if (argumentCount > 5) + cbP->errorCB = validator.toFunction(5, true); + + MediaServerPtr server(privateObject->getObject()); + server->browse(containerId, sortMode, count, offset, cbP); + + return JSValueMakeUndefined(context); +} + + +JSValueRef JSMediaServer::find(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception) +{ + LoggerD("Entered JSMediaServer::find"); + // TODO try/catch block + MediaServerPrivObject* privateObject = static_cast(JSObjectGetPrivate(object)); + if (NULL == privateObject) + { + LoggerE("private object is null"); + // TODO post exception + } + + LoggerD("Validating arguments: " << argumentCount); + + ArgumentValidator validator(context, argumentCount, arguments); + std::string containerId = validator.toString(0); + std::string searchFilter = validator.toString(1); + std::string sortMode = validator.toString(2); + unsigned long count = validator.toULong(3); + unsigned long offset = validator.toULong(4); + + BrowseFindCB *cbP = new BrowseFindCB(); + cbP->context = context; + cbP->object = object; + cbP->thisObject = thisObject; + cbP->successCB = validator.toFunction(5, true); + if (argumentCount > 6) + cbP->errorCB = validator.toFunction(6, true); + + MediaServerPtr server(privateObject->getObject()); + server->find(containerId, searchFilter, sortMode, count, offset, cbP); + + return JSValueMakeUndefined(context); +} + + +} +} diff --git a/src/MediaServer/JSMediaServer.h b/src/MediaServer/JSMediaServer.h new file mode 100644 index 0000000..e2de424 --- /dev/null +++ b/src/MediaServer/JSMediaServer.h @@ -0,0 +1,98 @@ +#ifndef JSMEDIASERVER_H +#define JSMEDIASERVER_H + +#include "MediaServer.h" +#include +#include +#include +#include + +namespace DeviceAPI { +namespace MediaServer { + +typedef WrtDeviceApis::CommonsJavaScript::PrivateObject MediaServerPrivObject; + +class JSMediaServer +{ +public: + static const JSClassDefinition* getClassInfo(); + + static const JSClassRef getClassRef(); + + static JSObjectRef createJSObject(JSContextRef context); + static JSObjectRef createJSObject(JSContextRef context, std::string path); +private: + /** + * The callback invoked when an object is first created. + */ + static void initialize(JSContextRef context, + JSObjectRef object); + + /** + * The callback invoked when an object is finalized. + */ + static void finalize(JSObjectRef object); + + /** + * The callback invoked when an object is used as the target of an 'instanceof' expression. + */ + static bool hasInstance(JSContextRef context, + JSObjectRef constructor, + JSValueRef possibleInstance, + JSValueRef* exception); + + /** + * Getters for properties + */ + static JSValueRef getProperty(JSContextRef context, + JSObjectRef object, + JSStringRef propertyName, + JSValueRef* exception); + + + /** + * Browses for media item under a given MediaContainer. + */ + static JSValueRef browse(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception); + + + /** + * Searches for media item under a given MediaContainer. + */ + static JSValueRef find(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception); + + + /** + * This structure contains properties and callbacks that define a type of object. + */ + static JSClassDefinition m_classInfo; + + /** + * This structure describes a statically declared function. + */ + static JSStaticFunction m_function[]; + + /** + * This member variable contains the initialization values for the + * properties of this class. The values are given according to the + * data structure JSPropertySpec. + */ + static JSStaticValue m_property[]; + + static JSClassRef m_jsClassRef; +}; + +} +} + +#endif // JSMEDIASERVER_H diff --git a/src/MediaServer/JSMediaServerManager.cpp b/src/MediaServer/JSMediaServerManager.cpp new file mode 100644 index 0000000..78df7b7 --- /dev/null +++ b/src/MediaServer/JSMediaServerManager.cpp @@ -0,0 +1,140 @@ +#include "JSMediaServerManager.h" +#include "MediaServerManager.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace DeviceAPI { +namespace MediaServer { + +using namespace DPL; +using namespace DeviceAPI::Common; +using namespace WrtDeviceApis::Commons; +using namespace WrtDeviceApis::CommonsJavaScript; + +JSClassDefinition JSMediaServerManager::m_classInfo = { + 0, + kJSClassAttributeNone, + "MediaServerManager", + 0, + NULL, + m_function, + initialize, + finalize, + NULL, //HasProperty, + NULL, //GetProperty, + NULL, //SetProperty, + NULL, //DeleteProperty, + NULL, //GetPropertyNames, + NULL, //CallAsFunction, + NULL, //CallAsConstructor, + hasInstance, + NULL, //ConvertToType +}; + +JSStaticFunction JSMediaServerManager::m_function[] = { + {"scanNetwork", JSMediaServerManager::scanNetwork, kJSPropertyAttributeNone}, + { 0, 0, 0 } +}; + +const JSClassRef JSMediaServerManager::getClassRef() +{ + if (!m_jsClassRef) + { + m_jsClassRef = JSClassCreate(&m_classInfo); + } + return m_jsClassRef; +} + +const JSClassDefinition* JSMediaServerManager::getClassInfo() +{ + return &m_classInfo; +} + +JSClassRef JSMediaServerManager::m_jsClassRef = JSClassCreate(JSMediaServerManager::getClassInfo()); + +void JSMediaServerManager::initialize(JSContextRef context, JSObjectRef object) +{ + LoggerD("Entered JSMediaServerManager::initialize"); + MediaServerManagerPrivObject* priv = static_cast(JSObjectGetPrivate(object)); + if (!priv) + { + LoggerD("Create private object"); + MediaServerManagerPtr mediaservermanager(new MediaServerManager()); + priv = new MediaServerManagerPrivObject( context, mediaservermanager); + if(!JSObjectSetPrivate(object, static_cast(priv))) + { + LoggerE("Object can't store private data."); + delete priv; + } + } + + LoggerD("JSMediaServerManager::initialize done"); +} + +void JSMediaServerManager::finalize(JSObjectRef object) +{ + MediaServerManagerPrivObject* priv = static_cast(JSObjectGetPrivate(object)); + JSObjectSetPrivate(object, NULL); + LoggerD("JSMediaServerManager::finalize"); + delete priv; +} + +bool JSMediaServerManager::hasInstance(JSContextRef context, + JSObjectRef constructor, + JSValueRef possibleInstance, + JSValueRef* exception) +{ + return JSValueIsObjectOfClass(context, possibleInstance, getClassRef()); +} + + +JSValueRef JSMediaServerManager::scanNetwork(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception) +{ + LoggerD("Entered JSMediaServerManager::scanNetwork"); + + // TODO try/catch block + MediaServerManagerPrivObject* privateObject = static_cast(JSObjectGetPrivate(object)); + if (NULL == privateObject) + { + LoggerE("private object is null"); + // FIXME re-doing intialization ? several instances ? + MediaServerManagerPtr mediaservermanager(new MediaServerManager()); + privateObject = new MediaServerManagerPrivObject( context, mediaservermanager); + } + + // FIXME use event handlers instead of callbacks + + LoggerD("Validating arguments: " << argumentCount); + ArgumentValidator validator(context, argumentCount, arguments); + + ScanNetworkCB *cbP = new ScanNetworkCB(); + cbP->context = context; + cbP->object = object; + cbP->thisObject = thisObject; + cbP->successCB = validator.toFunction(1, true); + if (argumentCount > 2) + cbP->errorCB = validator.toFunction(2, true); + + MediaServerManagerPtr manager(privateObject->getObject()); + manager->scanNetwork(cbP); + + return JSValueMakeUndefined(context); +} + + +} +} diff --git a/src/MediaServer/JSMediaServerManager.h b/src/MediaServer/JSMediaServerManager.h new file mode 100644 index 0000000..312c636 --- /dev/null +++ b/src/MediaServer/JSMediaServerManager.h @@ -0,0 +1,69 @@ +#ifndef JSMEDIASERVERMANAGER_H +#define JSMEDIASERVERMANAGER_H + +#include "MediaServerManager.h" +#include +#include +#include +#include + +namespace DeviceAPI { +namespace MediaServer { + +typedef WrtDeviceApis::CommonsJavaScript::PrivateObject MediaServerManagerPrivObject; + +class JSMediaServerManager +{ +public: + static const JSClassDefinition* getClassInfo(); + + static const JSClassRef getClassRef(); + +private: + /** + * The callback invoked when an object is first created. + */ + static void initialize(JSContextRef context, + JSObjectRef object); + + /** + * The callback invoked when an object is finalized. + */ + static void finalize(JSObjectRef object); + + /** + * The callback invoked when an object is used as the target of an 'instanceof' expression. + */ + static bool hasInstance(JSContextRef context, + JSObjectRef constructor, + JSValueRef possibleInstance, + JSValueRef* exception); + + + /** + * Scans local network for MediaServers. + */ + static JSValueRef scanNetwork(JSContextRef context, + JSObjectRef object, + JSObjectRef thisObject, + size_t argumentCount, + const JSValueRef arguments[], + JSValueRef* exception); + + /** + * This structure contains properties and callbacks that define a type of object. + */ + static JSClassDefinition m_classInfo; + + /** + * This structure describes a statically declared function. + */ + static JSStaticFunction m_function[]; + + static JSClassRef m_jsClassRef; +}; + +} +} + +#endif // JSMEDIASERVERMANAGER_H diff --git a/src/MediaServer/MediaServer.cpp b/src/MediaServer/MediaServer.cpp new file mode 100644 index 0000000..00b3029 --- /dev/null +++ b/src/MediaServer/MediaServer.cpp @@ -0,0 +1,239 @@ +#include "MediaServer.h" +#include +#include +#include +#include + +#include +#include +#include + + + +/* + * MediaServer class implementation + */ + +namespace DeviceAPI +{ +namespace MediaServer +{ + +using namespace WrtDeviceApis::Commons; + + +/* + * Attribute filter for browse / find on UPnPContainer2 proxy + */ +static const gchar *const arg_Filter[] = { + "Path", /* MediaObject id */ + "Type", /* MediaObject type */ + "DisplayName", /* MediaObject title */ + "URLs", /* MediaItem content.uri */ + "MIMEType", /* MediaItem MIMEType */ + "Date", /* MediaItem createdDate */ + "Size", /* MediaItem fileSize */ + "Width", /* MediaItem resolution.Width */ + "Height", /* MediaItem resolution.Height */ + "Duration", /* MediaItem duration */ + "Bitrate", /* MediaItem samplingRate */ + "Album", /* MediaItem collection */ + "Artist", /* MediaItem author */ + "Genre", /* MediaItem category */ + "TrackNumber", /* MediaItem TrackNumber */ + NULL}; + + +/* + * Callback for browse / find on UPnPContainer2 proxy + */ +static void browseFindCallback(GObject *source_object, GAsyncResult *res, gpointer user_data) { + + GError* gerror = NULL; + BrowseFindCB * callback = (BrowseFindCB *) user_data; + LoggerD("Entered browseFindCallback"); + + /* finish list children on UPnPContainer2 proxy */ + GVariant * out_Children; + if (upn_pcontainer2__call_list_children_finish ( + callback->cntProxy, /* proxy */ + &out_Children, + res, + &gerror /* error */ + )) { + LoggerD("browseFindCallback success"); + } else { + LoggerD(gerror->message); + g_error_free(gerror); + return; + } + + /* convert children to Javascript array */ + gsize size; + gchar * gStr = json_gvariant_serialize_data(out_Children,&size); + JSStringRef jsStr = JSStringCreateWithUTF8CString(gStr); + JSValueRef jsArray = JSValueMakeFromJSONString(callback->context, jsStr); + /* Trigger callback */ + JSValueRef arguments[1]; + arguments[0] = jsArray; + JSObjectCallAsFunction(callback->context, + callback->successCB, + callback->thisObject, + 1, + arguments, + NULL); + /* free upn_pcontainer2 proxy */ + g_object_unref(callback->cntProxy); +} + + + + +/** + * MediaServer implementation + */ + +MediaServer::MediaServer() +:EventRequestReceiver(ThreadEnum::APPLICATION_THREAD) +{ + LoggerD("Entered MediaServer::MediaServer"); + proxy = NULL; +} + + +void MediaServer::addEventListener(std::string property, EventMediaServerPropertyChangedPtr& event) +{ +} + + +/** + * Set UPnPDevice proxy using DBus path + */ +void MediaServer::setProxyPath(std::string path) +{ + LoggerD("Entered MediaServer::setProxyPath " << path); + if (proxy) + /* free upn_pdevice proxy */ + g_object_unref(proxy); + + GError* gerror = NULL; + proxy = upn_pdevice__proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "com.intel.dleyna-server", + path.c_str(), + NULL, /* GCancellable */ + &gerror); + + if (gerror) { + LoggerD(gerror->message); + g_error_free(gerror); + return; + } + + // set MediaServer properties + id = path; + friendlyName = upn_pdevice__get_friendly_name(proxy); + root = "{ type: 'container', title: 'root', id: '"; + root += id + "' }"; +} + + +/** + * Gets a property string value + */ +std::string MediaServer::getPropertyStringValue(std::string property) +{ + LoggerD("Entered MediaServer::getPropertyStringValue : " << property); + + if (property == "id") + return id; + else if (property == "friendlyName") + return friendlyName; + else if (property == "root") + return root; + + return ""; +} + + + +/** + * Browses for media item under a given MediaContainer. + */ +void MediaServer::browse(std::string containerId, + std::string sortMode, + unsigned long count, + unsigned long offset, + BrowseFindCB *callback) +{ + LoggerD("Entered MediaServer::browse"); + + GError* gerror = NULL; + callback->cntProxy = upn_pcontainer2__proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "com.intel.dleyna-server", + containerId.c_str(), + NULL, /* GCancellable */ + &gerror); + + if (gerror) { + LoggerD(gerror->message); + g_error_free(gerror); + return; + } + + upn_pcontainer2__call_list_children_ex ( + callback->cntProxy, /* proxy */ + offset, /* arg_Offset */ + count, /* arg_Max */ + arg_Filter, /* arg_Filter */ + sortMode.c_str(), /* arg_SortBy */ + NULL, /* cancellable */ + browseFindCallback, /* callback */ + callback /* user_data */ + ); +} + + +/** + * Searches for media item under a given MediaContainer. + */ +void MediaServer::find(std::string containerId, + std::string searchFilter, + std::string sortMode, + unsigned long count, + unsigned long offset, + BrowseFindCB *callback) + +{ + LoggerD("Entered MediaServer::find"); + + GError* gerror = NULL; + callback->cntProxy = upn_pcontainer2__proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "com.intel.dleyna-server", + containerId.c_str(), + NULL, /* GCancellable */ + &gerror); + + if (gerror) { + LoggerD(gerror->message); + g_error_free(gerror); + return; + } + + upn_pcontainer2__call_search_objects_ex ( + callback->cntProxy, /* proxy */ + searchFilter.c_str(), /* arg_Query */ + offset, /* arg_Offset */ + count, /* arg_Max */ + arg_Filter, /* arg_Filter */ + sortMode.c_str(), /* arg_SortBy */ + NULL, /* cancellable */ + browseFindCallback, /* callback */ + callback /* user_data */ + ); +} + +} +} diff --git a/src/MediaServer/MediaServer.h b/src/MediaServer/MediaServer.h new file mode 100644 index 0000000..34b6b5d --- /dev/null +++ b/src/MediaServer/MediaServer.h @@ -0,0 +1,75 @@ +#ifndef MEDIASERVER_H +#define MEDIASERVER_H + +#include +#include +#include +#include + +#include + +#include "EventMediaServerPropertyChanged.h" + +#include "dleynaserver-mediadevice-proxy.h" +#include "upnp-mediacontainer2-proxy.h" + + + +namespace DeviceAPI { +namespace MediaServer { + +class BrowseFindCB { +public: + UPnPContainer2 *cntProxy; + JSContextRef context; + JSObjectRef object; + JSObjectRef thisObject; + JSObjectRef successCB; + JSObjectRef errorCB; +}; + + +class MediaServer: public WrtDeviceApis::Commons::EventRequestReceiver +{ +public: + + MediaServer(); + + void addEventListener(std::string property, EventMediaServerPropertyChangedPtr& event); + + void setProxyPath(std::string path); + + std::string getPropertyStringValue(std::string property); + + void browse(std::string containerId, + std::string sortMode, + unsigned long count, + unsigned long offset, + BrowseFindCB *callback); + + void find(std::string containerId, + std::string searchFilter, + std::string sortMode, + unsigned long count, + unsigned long offset, + BrowseFindCB *callback); + + void OnRequestReceived(const EventMediaServerPropertyChangedPtr &event) + { + } + +private: + UPnPDevice *proxy; + // properties + std::string id; + std::string friendlyName; + std::string root; // JSON MediaObject with type 'container' +}; + +typedef DPL::SharedPtr MediaServerPtr; + + +} +} + +#endif // MEDIASERVER_H diff --git a/src/MediaServer/MediaServerManager.cpp b/src/MediaServer/MediaServerManager.cpp new file mode 100644 index 0000000..18b410d --- /dev/null +++ b/src/MediaServer/MediaServerManager.cpp @@ -0,0 +1,92 @@ +#include "MediaServerManager.h" +#include "JSMediaServer.h" +#include +#include +#include +#include + +#include + + +namespace DeviceAPI +{ +namespace MediaServer +{ + +using namespace WrtDeviceApis::Commons; + + +/** + * MediaServerManager implementation + */ + +MediaServerManager::MediaServerManager() +:EventRequestReceiver(ThreadEnum::APPLICATION_THREAD) +{ + LoggerD("Entered MediaServerManager::MediaServerManager"); + proxy = NULL; +} + + +void MediaServerManager::addEventListener(std::string property, EventMediaServerManagerPropertyChangedPtr& event) +{ +} + + +/** + * Scans local network for MediaServers. + */ +void MediaServerManager::scanNetwork(ScanNetworkCB *callback) +{ + LoggerD("Entered MediaServerManager::scanNetwork"); + + GError* gerror = NULL; + if (!proxy) + proxy = upn_pmanager__proxy_new_for_bus_sync(G_BUS_TYPE_SESSION, + G_DBUS_PROXY_FLAGS_NONE, + "com.intel.dleyna-server", + "/com/intel/dLeynaServer", + NULL, /* GCancellable */ + &gerror); + + if (gerror) { + LoggerD(gerror->message); + g_error_free(gerror); + return; + } + + char ** strTab; + if (upn_pmanager__call_get_servers_sync( + proxy, /* proxy */ + &strTab, /* out_Servers */ + NULL, /* cancellable */ + &gerror /* error */ + )) { + LoggerD("get servers success"); + while (*strTab) { + LoggerD("mediaserver dbus path " << *strTab); + // Create MediaServer object with proxy path + std::string path = *strTab; + JSValueRef arguments[1]; + arguments[0] = JSMediaServer::createJSObject(callback->context, path); + // Trigger callback + JSObjectCallAsFunction(callback->context, + callback->successCB, + callback->thisObject, + 1, + arguments, + NULL); + LoggerD(*strTab); + strTab++; + } + } else { + LoggerD("get servers error"); + } + +} + + + + +} +} diff --git a/src/MediaServer/MediaServerManager.h b/src/MediaServer/MediaServerManager.h new file mode 100644 index 0000000..6b69de9 --- /dev/null +++ b/src/MediaServer/MediaServerManager.h @@ -0,0 +1,53 @@ +#ifndef MEDIASERVERMANAGER_H +#define MEDIASERVERMANAGER_H + +#include +#include +#include +#include + +#include + +#include "EventMediaServerManagerPropertyChanged.h" + +#include "dleynaserver-manager-proxy.h" + + + +namespace DeviceAPI { +namespace MediaServer { + +class ScanNetworkCB { +public: + JSContextRef context; + JSObjectRef object; + JSObjectRef thisObject; + JSObjectRef successCB; + JSObjectRef errorCB; +}; + + +class MediaServerManager: public WrtDeviceApis::Commons::EventRequestReceiver +{ +public: + + MediaServerManager(); + + void addEventListener(std::string property, EventMediaServerManagerPropertyChangedPtr& event); + + void scanNetwork(ScanNetworkCB *callback); + + void OnRequestReceived(const EventMediaServerManagerPropertyChangedPtr &event) + { + } + +private: + UPnPManager *proxy; +}; + +typedef DPL::SharedPtr MediaServerManagerPtr; + + +} +} +#endif // MEDIASERVERMANAGER_H diff --git a/config.xml b/src/MediaServer/config.xml old mode 100644 new mode 100755 similarity index 71% rename from config.xml rename to src/MediaServer/config.xml index 912f8cd..42eca7d --- a/config.xml +++ b/src/MediaServer/config.xml @@ -1,15 +1,15 @@ - libwrt-plugins-tizen-vehicle.so + libwrt-plugins-tizen-mediaserver.so time.install.uri INTEL plugin group INTEL certificate authority AAAABBBBCCCCDDDEEEE0000 - http://tizen.org/privilege/vehicle - vehicle + http://tizen.org/privilege/mediaserver + mediaserver diff --git a/src/MediaServer/dleynaserver-manager-proxy.c b/src/MediaServer/dleynaserver-manager-proxy.c new file mode 100644 index 0000000..4ccb12f --- /dev/null +++ b/src/MediaServer/dleynaserver-manager-proxy.c @@ -0,0 +1,2009 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "dleynaserver-manager-proxy.h" + +#include + +#ifdef G_OS_UNIX +#undef G_OS_UNIX +#endif + +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface com.intel.dLeynaServer.Manager + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:UPnPManager + * @title: UPnPManager + * @short_description: Generated C code for the com.intel.dLeynaServer.Manager D-Bus interface + * + * This section contains code for working with the com.intel.dLeynaServer.Manager D-Bus interface in C. + */ + +/* ---- Introspection data for com.intel.dLeynaServer.Manager ---- */ + +static const _ExtendedGDBusArgInfo _upn_pmanager__method_info_get_version_OUT_ARG_Version = +{ + { + -1, + (gchar *) "Version", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__method_info_get_version_OUT_ARG_pointers[] = +{ + &_upn_pmanager__method_info_get_version_OUT_ARG_Version, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_get_version = +{ + { + -1, + (gchar *) "GetVersion", + NULL, + (GDBusArgInfo **) &_upn_pmanager__method_info_get_version_OUT_ARG_pointers, + NULL + }, + "handle-get-version", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_release = +{ + { + -1, + (gchar *) "Release", + NULL, + NULL, + NULL + }, + "handle-release", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pmanager__method_info_get_servers_OUT_ARG_Servers = +{ + { + -1, + (gchar *) "Servers", + (gchar *) "ao", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__method_info_get_servers_OUT_ARG_pointers[] = +{ + &_upn_pmanager__method_info_get_servers_OUT_ARG_Servers, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_get_servers = +{ + { + -1, + (gchar *) "GetServers", + NULL, + (GDBusArgInfo **) &_upn_pmanager__method_info_get_servers_OUT_ARG_pointers, + NULL + }, + "handle-get-servers", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_rescan = +{ + { + -1, + (gchar *) "Rescan", + NULL, + NULL, + NULL + }, + "handle-rescan", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pmanager__method_info_set_protocol_info_IN_ARG_ProtocolInfo = +{ + { + -1, + (gchar *) "ProtocolInfo", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__method_info_set_protocol_info_IN_ARG_pointers[] = +{ + &_upn_pmanager__method_info_set_protocol_info_IN_ARG_ProtocolInfo, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_set_protocol_info = +{ + { + -1, + (gchar *) "SetProtocolInfo", + (GDBusArgInfo **) &_upn_pmanager__method_info_set_protocol_info_IN_ARG_pointers, + NULL, + NULL + }, + "handle-set-protocol-info", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pmanager__method_info_prefer_local_addresses_IN_ARG_Prefer = +{ + { + -1, + (gchar *) "Prefer", + (gchar *) "b", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__method_info_prefer_local_addresses_IN_ARG_pointers[] = +{ + &_upn_pmanager__method_info_prefer_local_addresses_IN_ARG_Prefer, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pmanager__method_info_prefer_local_addresses = +{ + { + -1, + (gchar *) "PreferLocalAddresses", + (GDBusArgInfo **) &_upn_pmanager__method_info_prefer_local_addresses_IN_ARG_pointers, + NULL, + NULL + }, + "handle-prefer-local-addresses", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _upn_pmanager__method_info_pointers[] = +{ + &_upn_pmanager__method_info_get_version, + &_upn_pmanager__method_info_release, + &_upn_pmanager__method_info_get_servers, + &_upn_pmanager__method_info_rescan, + &_upn_pmanager__method_info_set_protocol_info, + &_upn_pmanager__method_info_prefer_local_addresses, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pmanager__signal_info_found_server_ARG_Path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "o", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__signal_info_found_server_ARG_pointers[] = +{ + &_upn_pmanager__signal_info_found_server_ARG_Path, + NULL +}; + +static const _ExtendedGDBusSignalInfo _upn_pmanager__signal_info_found_server = +{ + { + -1, + (gchar *) "FoundServer", + (GDBusArgInfo **) &_upn_pmanager__signal_info_found_server_ARG_pointers, + NULL + }, + "found-server" +}; + +static const _ExtendedGDBusArgInfo _upn_pmanager__signal_info_lost_server_ARG_Path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "o", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pmanager__signal_info_lost_server_ARG_pointers[] = +{ + &_upn_pmanager__signal_info_lost_server_ARG_Path, + NULL +}; + +static const _ExtendedGDBusSignalInfo _upn_pmanager__signal_info_lost_server = +{ + { + -1, + (gchar *) "LostServer", + (GDBusArgInfo **) &_upn_pmanager__signal_info_lost_server_ARG_pointers, + NULL + }, + "lost-server" +}; + +static const _ExtendedGDBusSignalInfo * const _upn_pmanager__signal_info_pointers[] = +{ + &_upn_pmanager__signal_info_found_server, + &_upn_pmanager__signal_info_lost_server, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _upn_pmanager__interface_info = +{ + { + -1, + (gchar *) "com.intel.dLeynaServer.Manager", + (GDBusMethodInfo **) &_upn_pmanager__method_info_pointers, + (GDBusSignalInfo **) &_upn_pmanager__signal_info_pointers, + NULL, + NULL + }, + "", +}; + + +/** + * upn_pmanager__interface_info: + * + * Gets a machine-readable description of the com.intel.dLeynaServer.Manager D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +upn_pmanager__interface_info (void) +{ + return (GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct; +} + +/** + * upn_pmanager__override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #UPnPManager interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +upn_pmanager__override_properties (GObjectClass *klass, guint property_id_begin) +{ + return property_id_begin - 1; +} + + + +/** + * UPnPManager: + * + * Abstract interface type for the D-Bus interface com.intel.dLeynaServer.Manager. + */ + +/** + * UPnPManagerIface: + * @parent_iface: The parent interface. + * @handle_get_servers: Handler for the #UPnPManager::handle-get-servers signal. + * @handle_get_version: Handler for the #UPnPManager::handle-get-version signal. + * @handle_prefer_local_addresses: Handler for the #UPnPManager::handle-prefer-local-addresses signal. + * @handle_release: Handler for the #UPnPManager::handle-release signal. + * @handle_rescan: Handler for the #UPnPManager::handle-rescan signal. + * @handle_set_protocol_info: Handler for the #UPnPManager::handle-set-protocol-info signal. + * @found_server: Handler for the #UPnPManager::found-server signal. + * @lost_server: Handler for the #UPnPManager::lost-server signal. + * + * Virtual table for the D-Bus interface com.intel.dLeynaServer.Manager. + */ + +static void +upn_pmanager__default_init (UPnPManagerIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * UPnPManager::handle-get-version: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetVersion() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_get_version() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-version", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_get_version), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * UPnPManager::handle-release: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Release() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_release() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-release", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_release), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * UPnPManager::handle-get-servers: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetServers() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_get_servers() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-servers", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_get_servers), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * UPnPManager::handle-rescan: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Rescan() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_rescan() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-rescan", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_rescan), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * UPnPManager::handle-set-protocol-info: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * @arg_ProtocolInfo: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the SetProtocolInfo() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_set_protocol_info() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-set-protocol-info", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_set_protocol_info), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING); + + /** + * UPnPManager::handle-prefer-local-addresses: + * @object: A #UPnPManager. + * @invocation: A #GDBusMethodInvocation. + * @arg_Prefer: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the PreferLocalAddresses() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pmanager__complete_prefer_local_addresses() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-prefer-local-addresses", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, handle_prefer_local_addresses), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN); + + /* GObject signals for received D-Bus signals: */ + /** + * UPnPManager::found-server: + * @object: A #UPnPManager. + * @arg_Path: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "FoundServer" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("found-server", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, found_server), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_STRING); + + /** + * UPnPManager::lost-server: + * @object: A #UPnPManager. + * @arg_Path: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "LostServer" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("lost-server", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPManagerIface, lost_server), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_STRING); + +} + +typedef UPnPManagerIface UPnPManagerInterface; +G_DEFINE_INTERFACE (UPnPManager, upn_pmanager_, G_TYPE_OBJECT); + +/** + * upn_pmanager__emit_found_server: + * @object: A #UPnPManager. + * @arg_Path: Argument to pass with the signal. + * + * Emits the "FoundServer" D-Bus signal. + */ +void +upn_pmanager__emit_found_server ( + UPnPManager *object, + const gchar *arg_Path) +{ + g_signal_emit_by_name (object, "found-server", arg_Path); +} + +/** + * upn_pmanager__emit_lost_server: + * @object: A #UPnPManager. + * @arg_Path: Argument to pass with the signal. + * + * Emits the "LostServer" D-Bus signal. + */ +void +upn_pmanager__emit_lost_server ( + UPnPManager *object, + const gchar *arg_Path) +{ + g_signal_emit_by_name (object, "lost-server", arg_Path); +} + +/** + * upn_pmanager__call_get_version: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetVersion() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_get_version_finish() to get the result of the operation. + * + * See upn_pmanager__call_get_version_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_get_version ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetVersion", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_get_version_finish: + * @proxy: A #UPnPManagerProxy. + * @out_Version: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_get_version(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_get_version(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_get_version_finish ( + UPnPManager *proxy, + gchar **out_Version, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_Version); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_get_version_sync: + * @proxy: A #UPnPManagerProxy. + * @out_Version: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetVersion() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_get_version() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_get_version_sync ( + UPnPManager *proxy, + gchar **out_Version, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetVersion", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(s)", + out_Version); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_release: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Release() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_release_finish() to get the result of the operation. + * + * See upn_pmanager__call_release_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_release ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Release", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_release_finish: + * @proxy: A #UPnPManagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_release(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_release(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_release_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_release_sync: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Release() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_release() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_release_sync ( + UPnPManager *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Release", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_get_servers: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetServers() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_get_servers_finish() to get the result of the operation. + * + * See upn_pmanager__call_get_servers_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_get_servers ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetServers", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_get_servers_finish: + * @proxy: A #UPnPManagerProxy. + * @out_Servers: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_get_servers(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_get_servers(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_get_servers_finish ( + UPnPManager *proxy, + gchar ***out_Servers, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(^ao)", + out_Servers); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_get_servers_sync: + * @proxy: A #UPnPManagerProxy. + * @out_Servers: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetServers() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_get_servers() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_get_servers_sync ( + UPnPManager *proxy, + gchar ***out_Servers, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetServers", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(^ao)", + out_Servers); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_rescan: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Rescan() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_rescan_finish() to get the result of the operation. + * + * See upn_pmanager__call_rescan_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_rescan ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Rescan", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_rescan_finish: + * @proxy: A #UPnPManagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_rescan(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_rescan(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_rescan_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_rescan_sync: + * @proxy: A #UPnPManagerProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Rescan() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_rescan() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_rescan_sync ( + UPnPManager *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Rescan", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_set_protocol_info: + * @proxy: A #UPnPManagerProxy. + * @arg_ProtocolInfo: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the SetProtocolInfo() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_set_protocol_info_finish() to get the result of the operation. + * + * See upn_pmanager__call_set_protocol_info_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_set_protocol_info ( + UPnPManager *proxy, + const gchar *arg_ProtocolInfo, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "SetProtocolInfo", + g_variant_new ("(s)", + arg_ProtocolInfo), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_set_protocol_info_finish: + * @proxy: A #UPnPManagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_set_protocol_info(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_set_protocol_info(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_set_protocol_info_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_set_protocol_info_sync: + * @proxy: A #UPnPManagerProxy. + * @arg_ProtocolInfo: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the SetProtocolInfo() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_set_protocol_info() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_set_protocol_info_sync ( + UPnPManager *proxy, + const gchar *arg_ProtocolInfo, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "SetProtocolInfo", + g_variant_new ("(s)", + arg_ProtocolInfo), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_prefer_local_addresses: + * @proxy: A #UPnPManagerProxy. + * @arg_Prefer: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the PreferLocalAddresses() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__call_prefer_local_addresses_finish() to get the result of the operation. + * + * See upn_pmanager__call_prefer_local_addresses_sync() for the synchronous, blocking version of this method. + */ +void +upn_pmanager__call_prefer_local_addresses ( + UPnPManager *proxy, + gboolean arg_Prefer, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "PreferLocalAddresses", + g_variant_new ("(b)", + arg_Prefer), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pmanager__call_prefer_local_addresses_finish: + * @proxy: A #UPnPManagerProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__call_prefer_local_addresses(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pmanager__call_prefer_local_addresses(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_prefer_local_addresses_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__call_prefer_local_addresses_sync: + * @proxy: A #UPnPManagerProxy. + * @arg_Prefer: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the PreferLocalAddresses() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pmanager__call_prefer_local_addresses() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pmanager__call_prefer_local_addresses_sync ( + UPnPManager *proxy, + gboolean arg_Prefer, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "PreferLocalAddresses", + g_variant_new ("(b)", + arg_Prefer), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pmanager__complete_get_version: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Version: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetVersion() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_get_version ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + const gchar *Version) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(s)", + Version)); +} + +/** + * upn_pmanager__complete_release: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Release() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_release ( + UPnPManager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * upn_pmanager__complete_get_servers: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Servers: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetServers() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_get_servers ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + const gchar *const *Servers) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(^ao)", + Servers)); +} + +/** + * upn_pmanager__complete_rescan: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Rescan() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_rescan ( + UPnPManager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * upn_pmanager__complete_set_protocol_info: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the SetProtocolInfo() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_set_protocol_info ( + UPnPManager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * upn_pmanager__complete_prefer_local_addresses: + * @object: A #UPnPManager. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the PreferLocalAddresses() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pmanager__complete_prefer_local_addresses ( + UPnPManager *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPManagerProxy: + * + * The #UPnPManagerProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPManagerProxyClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPManagerProxy. + */ + +struct _UPnPManagerProxyPrivate +{ + GData *qdata; +}; + +static void upn_pmanager__proxy_iface_init (UPnPManagerIface *iface); + +G_DEFINE_TYPE_WITH_CODE (UPnPManagerProxy, upn_pmanager__proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (UPN_PMANAGER_TYPE_, upn_pmanager__proxy_iface_init)); + +static void +upn_pmanager__proxy_finalize (GObject *object) +{ + UPnPManagerProxy *proxy = UPN_PMANAGER__PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (upn_pmanager__proxy_parent_class)->finalize (object); +} + +static void +upn_pmanager__proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ +} + +static void +upn_pmanager__proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ +} + +static void +upn_pmanager__proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], UPN_PMANAGER_TYPE_); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PMANAGER_TYPE_); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +upn_pmanager__proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + UPnPManagerProxy *proxy = UPN_PMANAGER__PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static void +upn_pmanager__proxy_init (UPnPManagerProxy *proxy) +{ + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UPN_PMANAGER_TYPE__PROXY, UPnPManagerProxyPrivate); + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), upn_pmanager__interface_info ()); +} + +static void +upn_pmanager__proxy_class_init (UPnPManagerProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + g_type_class_add_private (klass, sizeof (UPnPManagerProxyPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pmanager__proxy_finalize; + gobject_class->get_property = upn_pmanager__proxy_get_property; + gobject_class->set_property = upn_pmanager__proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = upn_pmanager__proxy_g_signal; + proxy_class->g_properties_changed = upn_pmanager__proxy_g_properties_changed; + +} + +static void +upn_pmanager__proxy_iface_init (UPnPManagerIface *iface) +{ +} + +/** + * upn_pmanager__proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface com.intel.dLeynaServer.Manager. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__proxy_new_finish() to get the result of the operation. + * + * See upn_pmanager__proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pmanager__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PMANAGER_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.Manager", NULL); +} + +/** + * upn_pmanager__proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pmanager__proxy_new(). + * + * Returns: (transfer full) (type UPnPManagerProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPManager * +upn_pmanager__proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PMANAGER_ (ret); + else + return NULL; +} + +/** + * upn_pmanager__proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface com.intel.dLeynaServer.Manager. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pmanager__proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPManagerProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPManager * +upn_pmanager__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PMANAGER_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.Manager", NULL); + if (ret != NULL) + return UPN_PMANAGER_ (ret); + else + return NULL; +} + + +/** + * upn_pmanager__proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like upn_pmanager__proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pmanager__proxy_new_for_bus_finish() to get the result of the operation. + * + * See upn_pmanager__proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pmanager__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PMANAGER_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.Manager", NULL); +} + +/** + * upn_pmanager__proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pmanager__proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pmanager__proxy_new_for_bus(). + * + * Returns: (transfer full) (type UPnPManagerProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPManager * +upn_pmanager__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PMANAGER_ (ret); + else + return NULL; +} + +/** + * upn_pmanager__proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like upn_pmanager__proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pmanager__proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPManagerProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPManager * +upn_pmanager__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PMANAGER_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.Manager", NULL); + if (ret != NULL) + return UPN_PMANAGER_ (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPManagerSkeleton: + * + * The #UPnPManagerSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPManagerSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPManagerSkeleton. + */ + +struct _UPnPManagerSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_upn_pmanager__skeleton_handle_method_call ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], UPN_PMANAGER_TYPE_); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PMANAGER_TYPE_); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_upn_pmanager__skeleton_handle_get_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_upn_pmanager__skeleton_handle_set_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pmanager__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _upn_pmanager__skeleton_vtable = +{ + _upn_pmanager__skeleton_handle_method_call, + _upn_pmanager__skeleton_handle_get_property, + _upn_pmanager__skeleton_handle_set_property +}; + +static GDBusInterfaceInfo * +upn_pmanager__skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton) +{ + return upn_pmanager__interface_info (); +} + +static GDBusInterfaceVTable * +upn_pmanager__skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton) +{ + return (GDBusInterfaceVTable *) &_upn_pmanager__skeleton_vtable; +} + +static GVariant * +upn_pmanager__skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_upn_pmanager__interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _upn_pmanager__interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _upn_pmanager__interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _upn_pmanager__skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.Manager", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static void +upn_pmanager__skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ +} + +static void +_upn_pmanager__on_signal_found_server ( + UPnPManager *object, + const gchar *arg_Path) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(o)", + arg_Path)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.Manager", "FoundServer", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_upn_pmanager__on_signal_lost_server ( + UPnPManager *object, + const gchar *arg_Path) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(o)", + arg_Path)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.Manager", "LostServer", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void upn_pmanager__skeleton_iface_init (UPnPManagerIface *iface); +G_DEFINE_TYPE_WITH_CODE (UPnPManagerSkeleton, upn_pmanager__skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (UPN_PMANAGER_TYPE_, upn_pmanager__skeleton_iface_init)); + +static void +upn_pmanager__skeleton_finalize (GObject *object) +{ + UPnPManagerSkeleton *skeleton = UPN_PMANAGER__SKELETON (object); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (upn_pmanager__skeleton_parent_class)->finalize (object); +} + +static void +upn_pmanager__skeleton_init (UPnPManagerSkeleton *skeleton) +{ + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UPN_PMANAGER_TYPE__SKELETON, UPnPManagerSkeletonPrivate); + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); +} + +static void +upn_pmanager__skeleton_class_init (UPnPManagerSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + g_type_class_add_private (klass, sizeof (UPnPManagerSkeletonPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pmanager__skeleton_finalize; + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = upn_pmanager__skeleton_dbus_interface_get_info; + skeleton_class->get_properties = upn_pmanager__skeleton_dbus_interface_get_properties; + skeleton_class->flush = upn_pmanager__skeleton_dbus_interface_flush; + skeleton_class->get_vtable = upn_pmanager__skeleton_dbus_interface_get_vtable; +} + +static void +upn_pmanager__skeleton_iface_init (UPnPManagerIface *iface) +{ + iface->found_server = _upn_pmanager__on_signal_found_server; + iface->lost_server = _upn_pmanager__on_signal_lost_server; +} + +/** + * upn_pmanager__skeleton_new: + * + * Creates a skeleton object for the D-Bus interface com.intel.dLeynaServer.Manager. + * + * Returns: (transfer full) (type UPnPManagerSkeleton): The skeleton object. + */ +UPnPManager * +upn_pmanager__skeleton_new (void) +{ + return UPN_PMANAGER_ (g_object_new (UPN_PMANAGER_TYPE__SKELETON, NULL)); +} + diff --git a/src/MediaServer/dleynaserver-manager-proxy.h b/src/MediaServer/dleynaserver-manager-proxy.h new file mode 100644 index 0000000..346ef15 --- /dev/null +++ b/src/MediaServer/dleynaserver-manager-proxy.h @@ -0,0 +1,319 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __DLEYNASERVER_MANAGER_PROXY_H__ +#define __DLEYNASERVER_MANAGER_PROXY_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for com.intel.dLeynaServer.Manager */ + +#define UPN_PMANAGER_TYPE_ (upn_pmanager__get_type ()) +#define UPN_PMANAGER_(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PMANAGER_TYPE_, UPnPManager)) +#define UPN_PMANAGER_IS_(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PMANAGER_TYPE_)) +#define UPN_PMANAGER__GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UPN_PMANAGER_TYPE_, UPnPManagerIface)) + +struct _UPnPManager; +typedef struct _UPnPManager UPnPManager; +typedef struct _UPnPManagerIface UPnPManagerIface; + +struct _UPnPManagerIface +{ + GTypeInterface parent_iface; + + + gboolean (*handle_get_servers) ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_get_version) ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_prefer_local_addresses) ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + gboolean arg_Prefer); + + gboolean (*handle_release) ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_rescan) ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_set_protocol_info) ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + const gchar *arg_ProtocolInfo); + + void (*found_server) ( + UPnPManager *object, + const gchar *arg_Path); + + void (*lost_server) ( + UPnPManager *object, + const gchar *arg_Path); + +}; + +GType upn_pmanager__get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *upn_pmanager__interface_info (void); +guint upn_pmanager__override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void upn_pmanager__complete_get_version ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + const gchar *Version); + +void upn_pmanager__complete_release ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + +void upn_pmanager__complete_get_servers ( + UPnPManager *object, + GDBusMethodInvocation *invocation, + const gchar *const *Servers); + +void upn_pmanager__complete_rescan ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + +void upn_pmanager__complete_set_protocol_info ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + +void upn_pmanager__complete_prefer_local_addresses ( + UPnPManager *object, + GDBusMethodInvocation *invocation); + + + +/* D-Bus signal emissions functions: */ +void upn_pmanager__emit_found_server ( + UPnPManager *object, + const gchar *arg_Path); + +void upn_pmanager__emit_lost_server ( + UPnPManager *object, + const gchar *arg_Path); + + + +/* D-Bus method calls: */ +void upn_pmanager__call_get_version ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_get_version_finish ( + UPnPManager *proxy, + gchar **out_Version, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_get_version_sync ( + UPnPManager *proxy, + gchar **out_Version, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__call_release ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_release_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_release_sync ( + UPnPManager *proxy, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__call_get_servers ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_get_servers_finish ( + UPnPManager *proxy, + gchar ***out_Servers, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_get_servers_sync ( + UPnPManager *proxy, + gchar ***out_Servers, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__call_rescan ( + UPnPManager *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_rescan_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_rescan_sync ( + UPnPManager *proxy, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__call_set_protocol_info ( + UPnPManager *proxy, + const gchar *arg_ProtocolInfo, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_set_protocol_info_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_set_protocol_info_sync ( + UPnPManager *proxy, + const gchar *arg_ProtocolInfo, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__call_prefer_local_addresses ( + UPnPManager *proxy, + gboolean arg_Prefer, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pmanager__call_prefer_local_addresses_finish ( + UPnPManager *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pmanager__call_prefer_local_addresses_sync ( + UPnPManager *proxy, + gboolean arg_Prefer, + GCancellable *cancellable, + GError **error); + + + +/* ---- */ + +#define UPN_PMANAGER_TYPE__PROXY (upn_pmanager__proxy_get_type ()) +#define UPN_PMANAGER__PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PMANAGER_TYPE__PROXY, UPnPManagerProxy)) +#define UPN_PMANAGER__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PMANAGER_TYPE__PROXY, UPnPManagerProxyClass)) +#define UPN_PMANAGER__PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PMANAGER_TYPE__PROXY, UPnPManagerProxyClass)) +#define UPN_PMANAGER_IS__PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PMANAGER_TYPE__PROXY)) +#define UPN_PMANAGER_IS__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PMANAGER_TYPE__PROXY)) + +typedef struct _UPnPManagerProxy UPnPManagerProxy; +typedef struct _UPnPManagerProxyClass UPnPManagerProxyClass; +typedef struct _UPnPManagerProxyPrivate UPnPManagerProxyPrivate; + +struct _UPnPManagerProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + UPnPManagerProxyPrivate *priv; +}; + +struct _UPnPManagerProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType upn_pmanager__proxy_get_type (void) G_GNUC_CONST; + +void upn_pmanager__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPManager *upn_pmanager__proxy_new_finish ( + GAsyncResult *res, + GError **error); +UPnPManager *upn_pmanager__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void upn_pmanager__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPManager *upn_pmanager__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +UPnPManager *upn_pmanager__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define UPN_PMANAGER_TYPE__SKELETON (upn_pmanager__skeleton_get_type ()) +#define UPN_PMANAGER__SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PMANAGER_TYPE__SKELETON, UPnPManagerSkeleton)) +#define UPN_PMANAGER__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PMANAGER_TYPE__SKELETON, UPnPManagerSkeletonClass)) +#define UPN_PMANAGER__SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PMANAGER_TYPE__SKELETON, UPnPManagerSkeletonClass)) +#define UPN_PMANAGER_IS__SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PMANAGER_TYPE__SKELETON)) +#define UPN_PMANAGER_IS__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PMANAGER_TYPE__SKELETON)) + +typedef struct _UPnPManagerSkeleton UPnPManagerSkeleton; +typedef struct _UPnPManagerSkeletonClass UPnPManagerSkeletonClass; +typedef struct _UPnPManagerSkeletonPrivate UPnPManagerSkeletonPrivate; + +struct _UPnPManagerSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + UPnPManagerSkeletonPrivate *priv; +}; + +struct _UPnPManagerSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType upn_pmanager__skeleton_get_type (void) G_GNUC_CONST; + +UPnPManager *upn_pmanager__skeleton_new (void); + + +G_END_DECLS + +#endif /* __DLEYNASERVER_MANAGER_PROXY_H__ */ diff --git a/src/MediaServer/dleynaserver-mediadevice-proxy.c b/src/MediaServer/dleynaserver-mediadevice-proxy.c new file mode 100644 index 0000000..4fbe73f --- /dev/null +++ b/src/MediaServer/dleynaserver-mediadevice-proxy.c @@ -0,0 +1,4675 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "dleynaserver-mediadevice-proxy.h" + +#include + +#ifdef G_OS_UNIX +#undef G_OS_UNIX +#endif + +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface com.intel.dLeynaServer.MediaDevice + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:UPnPDevice + * @title: UPnPDevice + * @short_description: Generated C code for the com.intel.dLeynaServer.MediaDevice D-Bus interface + * + * This section contains code for working with the com.intel.dLeynaServer.MediaDevice D-Bus interface in C. + */ + +/* ---- Introspection data for com.intel.dLeynaServer.MediaDevice ---- */ + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_upload_to_any_container_IN_ARG_DisplayName = +{ + { + -1, + (gchar *) "DisplayName", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_upload_to_any_container_IN_ARG_FilePath = +{ + { + -1, + (gchar *) "FilePath", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_upload_to_any_container_IN_ARG_pointers[] = +{ + &_upn_pdevice__method_info_upload_to_any_container_IN_ARG_DisplayName, + &_upn_pdevice__method_info_upload_to_any_container_IN_ARG_FilePath, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_upload_to_any_container_OUT_ARG_UploadId = +{ + { + -1, + (gchar *) "UploadId", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_upload_to_any_container_OUT_ARG_Path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "o", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_upload_to_any_container_OUT_ARG_pointers[] = +{ + &_upn_pdevice__method_info_upload_to_any_container_OUT_ARG_UploadId, + &_upn_pdevice__method_info_upload_to_any_container_OUT_ARG_Path, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_upload_to_any_container = +{ + { + -1, + (gchar *) "UploadToAnyContainer", + (GDBusArgInfo **) &_upn_pdevice__method_info_upload_to_any_container_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pdevice__method_info_upload_to_any_container_OUT_ARG_pointers, + NULL + }, + "handle-upload-to-any-container", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_get_upload_status_IN_ARG_UploadId = +{ + { + -1, + (gchar *) "UploadId", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_get_upload_status_IN_ARG_pointers[] = +{ + &_upn_pdevice__method_info_get_upload_status_IN_ARG_UploadId, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_get_upload_status_OUT_ARG_UploadStatus = +{ + { + -1, + (gchar *) "UploadStatus", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_get_upload_status_OUT_ARG_Length = +{ + { + -1, + (gchar *) "Length", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_get_upload_status_OUT_ARG_Total = +{ + { + -1, + (gchar *) "Total", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_get_upload_status_OUT_ARG_pointers[] = +{ + &_upn_pdevice__method_info_get_upload_status_OUT_ARG_UploadStatus, + &_upn_pdevice__method_info_get_upload_status_OUT_ARG_Length, + &_upn_pdevice__method_info_get_upload_status_OUT_ARG_Total, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_get_upload_status = +{ + { + -1, + (gchar *) "GetUploadStatus", + (GDBusArgInfo **) &_upn_pdevice__method_info_get_upload_status_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pdevice__method_info_get_upload_status_OUT_ARG_pointers, + NULL + }, + "handle-get-upload-status", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_get_upload_ids_OUT_ARG_Total = +{ + { + -1, + (gchar *) "Total", + (gchar *) "au", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_get_upload_ids_OUT_ARG_pointers[] = +{ + &_upn_pdevice__method_info_get_upload_ids_OUT_ARG_Total, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_get_upload_ids = +{ + { + -1, + (gchar *) "GetUploadIDs", + NULL, + (GDBusArgInfo **) &_upn_pdevice__method_info_get_upload_ids_OUT_ARG_pointers, + NULL + }, + "handle-get-upload-ids", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_cancel_upload_IN_ARG_UploadId = +{ + { + -1, + (gchar *) "UploadId", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_cancel_upload_IN_ARG_pointers[] = +{ + &_upn_pdevice__method_info_cancel_upload_IN_ARG_UploadId, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_cancel_upload = +{ + { + -1, + (gchar *) "CancelUpload", + (GDBusArgInfo **) &_upn_pdevice__method_info_cancel_upload_IN_ARG_pointers, + NULL, + NULL + }, + "handle-cancel-upload", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_create_container_in_any_container_IN_ARG_DisplayName = +{ + { + -1, + (gchar *) "DisplayName", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_create_container_in_any_container_IN_ARG_Type = +{ + { + -1, + (gchar *) "Type", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_create_container_in_any_container_IN_ARG_ChildTypes = +{ + { + -1, + (gchar *) "ChildTypes", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_create_container_in_any_container_IN_ARG_pointers[] = +{ + &_upn_pdevice__method_info_create_container_in_any_container_IN_ARG_DisplayName, + &_upn_pdevice__method_info_create_container_in_any_container_IN_ARG_Type, + &_upn_pdevice__method_info_create_container_in_any_container_IN_ARG_ChildTypes, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__method_info_create_container_in_any_container_OUT_ARG_Path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "o", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__method_info_create_container_in_any_container_OUT_ARG_pointers[] = +{ + &_upn_pdevice__method_info_create_container_in_any_container_OUT_ARG_Path, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_create_container_in_any_container = +{ + { + -1, + (gchar *) "CreateContainerInAnyContainer", + (GDBusArgInfo **) &_upn_pdevice__method_info_create_container_in_any_container_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pdevice__method_info_create_container_in_any_container_OUT_ARG_pointers, + NULL + }, + "handle-create-container-in-any-container", + FALSE +}; + +static const _ExtendedGDBusMethodInfo _upn_pdevice__method_info_cancel = +{ + { + -1, + (gchar *) "Cancel", + NULL, + NULL, + NULL + }, + "handle-cancel", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _upn_pdevice__method_info_pointers[] = +{ + &_upn_pdevice__method_info_upload_to_any_container, + &_upn_pdevice__method_info_get_upload_status, + &_upn_pdevice__method_info_get_upload_ids, + &_upn_pdevice__method_info_cancel_upload, + &_upn_pdevice__method_info_create_container_in_any_container, + &_upn_pdevice__method_info_cancel, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_container_update_ids_ARG_ContainerPathsIDs = +{ + { + -1, + (gchar *) "ContainerPathsIDs", + (gchar *) "a(ou)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__signal_info_container_update_ids_ARG_pointers[] = +{ + &_upn_pdevice__signal_info_container_update_ids_ARG_ContainerPathsIDs, + NULL +}; + +static const _ExtendedGDBusSignalInfo _upn_pdevice__signal_info_container_update_ids = +{ + { + -1, + (gchar *) "ContainerUpdateIDs", + (GDBusArgInfo **) &_upn_pdevice__signal_info_container_update_ids_ARG_pointers, + NULL + }, + "container-update-ids" +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_last_change_ARG_StateEvent = +{ + { + -1, + (gchar *) "StateEvent", + (gchar *) "a(sv)", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__signal_info_last_change_ARG_pointers[] = +{ + &_upn_pdevice__signal_info_last_change_ARG_StateEvent, + NULL +}; + +static const _ExtendedGDBusSignalInfo _upn_pdevice__signal_info_last_change = +{ + { + -1, + (gchar *) "LastChange", + (GDBusArgInfo **) &_upn_pdevice__signal_info_last_change_ARG_pointers, + NULL + }, + "last-change" +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_upload_update_ARG_UploadId = +{ + { + -1, + (gchar *) "UploadId", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_upload_update_ARG_UploadStatus = +{ + { + -1, + (gchar *) "UploadStatus", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_upload_update_ARG_Length = +{ + { + -1, + (gchar *) "Length", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pdevice__signal_info_upload_update_ARG_Total = +{ + { + -1, + (gchar *) "Total", + (gchar *) "t", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pdevice__signal_info_upload_update_ARG_pointers[] = +{ + &_upn_pdevice__signal_info_upload_update_ARG_UploadId, + &_upn_pdevice__signal_info_upload_update_ARG_UploadStatus, + &_upn_pdevice__signal_info_upload_update_ARG_Length, + &_upn_pdevice__signal_info_upload_update_ARG_Total, + NULL +}; + +static const _ExtendedGDBusSignalInfo _upn_pdevice__signal_info_upload_update = +{ + { + -1, + (gchar *) "UploadUpdate", + (GDBusArgInfo **) &_upn_pdevice__signal_info_upload_update_ARG_pointers, + NULL + }, + "upload-update" +}; + +static const _ExtendedGDBusSignalInfo * const _upn_pdevice__signal_info_pointers[] = +{ + &_upn_pdevice__signal_info_container_update_ids, + &_upn_pdevice__signal_info_last_change, + &_upn_pdevice__signal_info_upload_update, + NULL +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_location = +{ + { + -1, + (gchar *) "Location", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "location", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_udn = +{ + { + -1, + (gchar *) "UDN", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "udn", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_device_type = +{ + { + -1, + (gchar *) "DeviceType", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "device-type", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_friendly_name = +{ + { + -1, + (gchar *) "FriendlyName", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "friendly-name", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_manufacturer = +{ + { + -1, + (gchar *) "Manufacturer", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "manufacturer", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_manufacturer_url = +{ + { + -1, + (gchar *) "ManufacturerUrl", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "manufacturer-url", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_model_description = +{ + { + -1, + (gchar *) "ModelDescription", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "model-description", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_model_name = +{ + { + -1, + (gchar *) "ModelName", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "model-name", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_model_number = +{ + { + -1, + (gchar *) "ModelNumber", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "model-number", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_model_url = +{ + { + -1, + (gchar *) "ModelURL", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "model-url", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_serial_number = +{ + { + -1, + (gchar *) "SerialNumber", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "serial-number", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_presentation_url = +{ + { + -1, + (gchar *) "PresentationURL", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "presentation-url", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_icon_url = +{ + { + -1, + (gchar *) "IconURL", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "icon-url", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_dlnacaps = +{ + { + -1, + (gchar *) "DLNACaps", + (gchar *) "a{sv}", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "dlnacaps", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_search_caps = +{ + { + -1, + (gchar *) "SearchCaps", + (gchar *) "as", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "search-caps", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_sort_caps = +{ + { + -1, + (gchar *) "SortCaps", + (gchar *) "as", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "sort-caps", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_sort_ext_caps = +{ + { + -1, + (gchar *) "SortExtCaps", + (gchar *) "as", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "sort-ext-caps", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_feature_list = +{ + { + -1, + (gchar *) "FeatureList", + (gchar *) "a(ssao)", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "feature-list", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_system_update_id = +{ + { + -1, + (gchar *) "SystemUpdateID", + (gchar *) "u", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "system-update-id", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pdevice__property_info_service_reset_token = +{ + { + -1, + (gchar *) "ServiceResetToken", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "service-reset-token", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo * const _upn_pdevice__property_info_pointers[] = +{ + &_upn_pdevice__property_info_location, + &_upn_pdevice__property_info_udn, + &_upn_pdevice__property_info_device_type, + &_upn_pdevice__property_info_friendly_name, + &_upn_pdevice__property_info_manufacturer, + &_upn_pdevice__property_info_manufacturer_url, + &_upn_pdevice__property_info_model_description, + &_upn_pdevice__property_info_model_name, + &_upn_pdevice__property_info_model_number, + &_upn_pdevice__property_info_model_url, + &_upn_pdevice__property_info_serial_number, + &_upn_pdevice__property_info_presentation_url, + &_upn_pdevice__property_info_icon_url, + &_upn_pdevice__property_info_dlnacaps, + &_upn_pdevice__property_info_search_caps, + &_upn_pdevice__property_info_sort_caps, + &_upn_pdevice__property_info_sort_ext_caps, + &_upn_pdevice__property_info_feature_list, + &_upn_pdevice__property_info_system_update_id, + &_upn_pdevice__property_info_service_reset_token, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _upn_pdevice__interface_info = +{ + { + -1, + (gchar *) "com.intel.dLeynaServer.MediaDevice", + (GDBusMethodInfo **) &_upn_pdevice__method_info_pointers, + (GDBusSignalInfo **) &_upn_pdevice__signal_info_pointers, + (GDBusPropertyInfo **) &_upn_pdevice__property_info_pointers, + NULL + }, + "", +}; + + +/** + * upn_pdevice__interface_info: + * + * Gets a machine-readable description of the com.intel.dLeynaServer.MediaDevice D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +upn_pdevice__interface_info (void) +{ + return (GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct; +} + +/** + * upn_pdevice__override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #UPnPDevice interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +upn_pdevice__override_properties (GObjectClass *klass, guint property_id_begin) +{ + g_object_class_override_property (klass, property_id_begin++, "location"); + g_object_class_override_property (klass, property_id_begin++, "udn"); + g_object_class_override_property (klass, property_id_begin++, "device-type"); + g_object_class_override_property (klass, property_id_begin++, "friendly-name"); + g_object_class_override_property (klass, property_id_begin++, "manufacturer"); + g_object_class_override_property (klass, property_id_begin++, "manufacturer-url"); + g_object_class_override_property (klass, property_id_begin++, "model-description"); + g_object_class_override_property (klass, property_id_begin++, "model-name"); + g_object_class_override_property (klass, property_id_begin++, "model-number"); + g_object_class_override_property (klass, property_id_begin++, "model-url"); + g_object_class_override_property (klass, property_id_begin++, "serial-number"); + g_object_class_override_property (klass, property_id_begin++, "presentation-url"); + g_object_class_override_property (klass, property_id_begin++, "icon-url"); + g_object_class_override_property (klass, property_id_begin++, "dlnacaps"); + g_object_class_override_property (klass, property_id_begin++, "search-caps"); + g_object_class_override_property (klass, property_id_begin++, "sort-caps"); + g_object_class_override_property (klass, property_id_begin++, "sort-ext-caps"); + g_object_class_override_property (klass, property_id_begin++, "feature-list"); + g_object_class_override_property (klass, property_id_begin++, "system-update-id"); + g_object_class_override_property (klass, property_id_begin++, "service-reset-token"); + return property_id_begin - 1; +} + + + +/** + * UPnPDevice: + * + * Abstract interface type for the D-Bus interface com.intel.dLeynaServer.MediaDevice. + */ + +/** + * UPnPDeviceIface: + * @parent_iface: The parent interface. + * @handle_cancel: Handler for the #UPnPDevice::handle-cancel signal. + * @handle_cancel_upload: Handler for the #UPnPDevice::handle-cancel-upload signal. + * @handle_create_container_in_any_container: Handler for the #UPnPDevice::handle-create-container-in-any-container signal. + * @handle_get_upload_ids: Handler for the #UPnPDevice::handle-get-upload-ids signal. + * @handle_get_upload_status: Handler for the #UPnPDevice::handle-get-upload-status signal. + * @handle_upload_to_any_container: Handler for the #UPnPDevice::handle-upload-to-any-container signal. + * @get_device_type: Getter for the #UPnPDevice:device-type property. + * @get_dlnacaps: Getter for the #UPnPDevice:dlnacaps property. + * @get_feature_list: Getter for the #UPnPDevice:feature-list property. + * @get_friendly_name: Getter for the #UPnPDevice:friendly-name property. + * @get_icon_url: Getter for the #UPnPDevice:icon-url property. + * @get_location: Getter for the #UPnPDevice:location property. + * @get_manufacturer: Getter for the #UPnPDevice:manufacturer property. + * @get_manufacturer_url: Getter for the #UPnPDevice:manufacturer-url property. + * @get_model_description: Getter for the #UPnPDevice:model-description property. + * @get_model_name: Getter for the #UPnPDevice:model-name property. + * @get_model_number: Getter for the #UPnPDevice:model-number property. + * @get_model_url: Getter for the #UPnPDevice:model-url property. + * @get_presentation_url: Getter for the #UPnPDevice:presentation-url property. + * @get_search_caps: Getter for the #UPnPDevice:search-caps property. + * @get_serial_number: Getter for the #UPnPDevice:serial-number property. + * @get_service_reset_token: Getter for the #UPnPDevice:service-reset-token property. + * @get_sort_caps: Getter for the #UPnPDevice:sort-caps property. + * @get_sort_ext_caps: Getter for the #UPnPDevice:sort-ext-caps property. + * @get_system_update_id: Getter for the #UPnPDevice:system-update-id property. + * @get_udn: Getter for the #UPnPDevice:udn property. + * @container_update_ids: Handler for the #UPnPDevice::container-update-ids signal. + * @last_change: Handler for the #UPnPDevice::last-change signal. + * @upload_update: Handler for the #UPnPDevice::upload-update signal. + * + * Virtual table for the D-Bus interface com.intel.dLeynaServer.MediaDevice. + */ + +static void +upn_pdevice__default_init (UPnPDeviceIface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * UPnPDevice::handle-upload-to-any-container: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * @arg_DisplayName: Argument passed by remote caller. + * @arg_FilePath: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the UploadToAnyContainer() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_upload_to_any_container() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-upload-to-any-container", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_upload_to_any_container), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 3, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING); + + /** + * UPnPDevice::handle-get-upload-status: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * @arg_UploadId: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the GetUploadStatus() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_get_upload_status() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-upload-status", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_get_upload_status), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * UPnPDevice::handle-get-upload-ids: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the GetUploadIDs() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_get_upload_ids() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-get-upload-ids", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_get_upload_ids), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /** + * UPnPDevice::handle-cancel-upload: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * @arg_UploadId: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the CancelUpload() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_cancel_upload() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-cancel-upload", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_cancel_upload), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 2, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT); + + /** + * UPnPDevice::handle-create-container-in-any-container: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * @arg_DisplayName: Argument passed by remote caller. + * @arg_Type: Argument passed by remote caller. + * @arg_ChildTypes: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the CreateContainerInAnyContainer() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_create_container_in_any_container() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-create-container-in-any-container", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_create_container_in_any_container), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV); + + /** + * UPnPDevice::handle-cancel: + * @object: A #UPnPDevice. + * @invocation: A #GDBusMethodInvocation. + * + * Signal emitted when a remote caller is invoking the Cancel() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pdevice__complete_cancel() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-cancel", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, handle_cancel), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 1, + G_TYPE_DBUS_METHOD_INVOCATION); + + /* GObject signals for received D-Bus signals: */ + /** + * UPnPDevice::container-update-ids: + * @object: A #UPnPDevice. + * @arg_ContainerPathsIDs: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "ContainerUpdateIDs" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("container-update-ids", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, container_update_ids), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_VARIANT); + + /** + * UPnPDevice::last-change: + * @object: A #UPnPDevice. + * @arg_StateEvent: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "LastChange" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("last-change", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, last_change), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 1, G_TYPE_VARIANT); + + /** + * UPnPDevice::upload-update: + * @object: A #UPnPDevice. + * @arg_UploadId: Argument. + * @arg_UploadStatus: Argument. + * @arg_Length: Argument. + * @arg_Total: Argument. + * + * On the client-side, this signal is emitted whenever the D-Bus signal "UploadUpdate" is received. + * + * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal. + */ + g_signal_new ("upload-update", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPDeviceIface, upload_update), + NULL, + NULL, + g_cclosure_marshal_generic, + G_TYPE_NONE, + 4, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64); + + /* GObject properties for D-Bus properties: */ + /** + * UPnPDevice:location: + * + * Represents the D-Bus property "Location". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("location", "Location", "Location", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:udn: + * + * Represents the D-Bus property "UDN". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("udn", "UDN", "UDN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:device-type: + * + * Represents the D-Bus property "DeviceType". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("device-type", "DeviceType", "DeviceType", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:friendly-name: + * + * Represents the D-Bus property "FriendlyName". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("friendly-name", "FriendlyName", "FriendlyName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:manufacturer: + * + * Represents the D-Bus property "Manufacturer". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("manufacturer", "Manufacturer", "Manufacturer", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:manufacturer-url: + * + * Represents the D-Bus property "ManufacturerUrl". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("manufacturer-url", "ManufacturerUrl", "ManufacturerUrl", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:model-description: + * + * Represents the D-Bus property "ModelDescription". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("model-description", "ModelDescription", "ModelDescription", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:model-name: + * + * Represents the D-Bus property "ModelName". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("model-name", "ModelName", "ModelName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:model-number: + * + * Represents the D-Bus property "ModelNumber". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("model-number", "ModelNumber", "ModelNumber", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:model-url: + * + * Represents the D-Bus property "ModelURL". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("model-url", "ModelURL", "ModelURL", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:serial-number: + * + * Represents the D-Bus property "SerialNumber". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("serial-number", "SerialNumber", "SerialNumber", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:presentation-url: + * + * Represents the D-Bus property "PresentationURL". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("presentation-url", "PresentationURL", "PresentationURL", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:icon-url: + * + * Represents the D-Bus property "IconURL". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("icon-url", "IconURL", "IconURL", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:dlnacaps: + * + * Represents the D-Bus property "DLNACaps". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_variant ("dlnacaps", "DLNACaps", "DLNACaps", G_VARIANT_TYPE ("a{sv}"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:search-caps: + * + * Represents the D-Bus property "SearchCaps". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boxed ("search-caps", "SearchCaps", "SearchCaps", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:sort-caps: + * + * Represents the D-Bus property "SortCaps". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boxed ("sort-caps", "SortCaps", "SortCaps", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:sort-ext-caps: + * + * Represents the D-Bus property "SortExtCaps". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boxed ("sort-ext-caps", "SortExtCaps", "SortExtCaps", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:feature-list: + * + * Represents the D-Bus property "FeatureList". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_variant ("feature-list", "FeatureList", "FeatureList", G_VARIANT_TYPE ("a(ssao)"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:system-update-id: + * + * Represents the D-Bus property "SystemUpdateID". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_uint ("system-update-id", "SystemUpdateID", "SystemUpdateID", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPDevice:service-reset-token: + * + * Represents the D-Bus property "ServiceResetToken". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("service-reset-token", "ServiceResetToken", "ServiceResetToken", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +typedef UPnPDeviceIface UPnPDeviceInterface; +G_DEFINE_INTERFACE (UPnPDevice, upn_pdevice_, G_TYPE_OBJECT); + +/** + * upn_pdevice__get_location: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "Location" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_location() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_location (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_location (object); +} + +/** + * upn_pdevice__dup_location: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "Location" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_location (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "location", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_location: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "Location" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_location (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "location", value, NULL); +} + +/** + * upn_pdevice__get_udn: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "UDN" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_udn() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_udn (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_udn (object); +} + +/** + * upn_pdevice__dup_udn: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "UDN" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_udn (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "udn", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_udn: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "UDN" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_udn (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "udn", value, NULL); +} + +/** + * upn_pdevice__get_device_type: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "DeviceType" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_device_type() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_device_type (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_device_type (object); +} + +/** + * upn_pdevice__dup_device_type: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "DeviceType" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_device_type (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "device-type", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_device_type: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "DeviceType" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_device_type (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "device-type", value, NULL); +} + +/** + * upn_pdevice__get_friendly_name: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "FriendlyName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_friendly_name() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_friendly_name (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_friendly_name (object); +} + +/** + * upn_pdevice__dup_friendly_name: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "FriendlyName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_friendly_name (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "friendly-name", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_friendly_name: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "FriendlyName" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_friendly_name (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "friendly-name", value, NULL); +} + +/** + * upn_pdevice__get_manufacturer: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "Manufacturer" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_manufacturer() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_manufacturer (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_manufacturer (object); +} + +/** + * upn_pdevice__dup_manufacturer: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "Manufacturer" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_manufacturer (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "manufacturer", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_manufacturer: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "Manufacturer" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_manufacturer (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "manufacturer", value, NULL); +} + +/** + * upn_pdevice__get_manufacturer_url: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ManufacturerUrl" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_manufacturer_url() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_manufacturer_url (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_manufacturer_url (object); +} + +/** + * upn_pdevice__dup_manufacturer_url: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ManufacturerUrl" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_manufacturer_url (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "manufacturer-url", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_manufacturer_url: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ManufacturerUrl" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_manufacturer_url (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "manufacturer-url", value, NULL); +} + +/** + * upn_pdevice__get_model_description: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ModelDescription" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_model_description() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_model_description (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_model_description (object); +} + +/** + * upn_pdevice__dup_model_description: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ModelDescription" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_model_description (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "model-description", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_model_description: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ModelDescription" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_model_description (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "model-description", value, NULL); +} + +/** + * upn_pdevice__get_model_name: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ModelName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_model_name() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_model_name (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_model_name (object); +} + +/** + * upn_pdevice__dup_model_name: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ModelName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_model_name (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "model-name", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_model_name: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ModelName" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_model_name (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "model-name", value, NULL); +} + +/** + * upn_pdevice__get_model_number: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ModelNumber" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_model_number() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_model_number (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_model_number (object); +} + +/** + * upn_pdevice__dup_model_number: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ModelNumber" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_model_number (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "model-number", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_model_number: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ModelNumber" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_model_number (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "model-number", value, NULL); +} + +/** + * upn_pdevice__get_model_url: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ModelURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_model_url() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_model_url (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_model_url (object); +} + +/** + * upn_pdevice__dup_model_url: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ModelURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_model_url (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "model-url", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_model_url: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ModelURL" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_model_url (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "model-url", value, NULL); +} + +/** + * upn_pdevice__get_serial_number: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "SerialNumber" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_serial_number() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_serial_number (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_serial_number (object); +} + +/** + * upn_pdevice__dup_serial_number: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "SerialNumber" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_serial_number (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "serial-number", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_serial_number: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "SerialNumber" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_serial_number (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "serial-number", value, NULL); +} + +/** + * upn_pdevice__get_presentation_url: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "PresentationURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_presentation_url() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_presentation_url (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_presentation_url (object); +} + +/** + * upn_pdevice__dup_presentation_url: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "PresentationURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_presentation_url (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "presentation-url", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_presentation_url: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "PresentationURL" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_presentation_url (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "presentation-url", value, NULL); +} + +/** + * upn_pdevice__get_icon_url: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "IconURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_icon_url() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_icon_url (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_icon_url (object); +} + +/** + * upn_pdevice__dup_icon_url: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "IconURL" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_icon_url (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "icon-url", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_icon_url: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "IconURL" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_icon_url (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "icon-url", value, NULL); +} + +/** + * upn_pdevice__get_dlnacaps: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "DLNACaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_dlnacaps() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +GVariant * +upn_pdevice__get_dlnacaps (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_dlnacaps (object); +} + +/** + * upn_pdevice__dup_dlnacaps: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "DLNACaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref(). + */ +GVariant * +upn_pdevice__dup_dlnacaps (UPnPDevice *object) +{ + GVariant *value; + g_object_get (G_OBJECT (object), "dlnacaps", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_dlnacaps: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "DLNACaps" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_dlnacaps (UPnPDevice *object, GVariant *value) +{ + g_object_set (G_OBJECT (object), "dlnacaps", value, NULL); +} + +/** + * upn_pdevice__get_search_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "SearchCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_search_caps() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar *const * +upn_pdevice__get_search_caps (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_search_caps (object); +} + +/** + * upn_pdevice__dup_search_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "SearchCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev(). + */ +gchar ** +upn_pdevice__dup_search_caps (UPnPDevice *object) +{ + gchar **value; + g_object_get (G_OBJECT (object), "search-caps", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_search_caps: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "SearchCaps" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_search_caps (UPnPDevice *object, const gchar *const *value) +{ + g_object_set (G_OBJECT (object), "search-caps", value, NULL); +} + +/** + * upn_pdevice__get_sort_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "SortCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_sort_caps() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar *const * +upn_pdevice__get_sort_caps (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_sort_caps (object); +} + +/** + * upn_pdevice__dup_sort_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "SortCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev(). + */ +gchar ** +upn_pdevice__dup_sort_caps (UPnPDevice *object) +{ + gchar **value; + g_object_get (G_OBJECT (object), "sort-caps", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_sort_caps: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "SortCaps" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_sort_caps (UPnPDevice *object, const gchar *const *value) +{ + g_object_set (G_OBJECT (object), "sort-caps", value, NULL); +} + +/** + * upn_pdevice__get_sort_ext_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "SortExtCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_sort_ext_caps() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar *const * +upn_pdevice__get_sort_ext_caps (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_sort_ext_caps (object); +} + +/** + * upn_pdevice__dup_sort_ext_caps: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "SortExtCaps" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev(). + */ +gchar ** +upn_pdevice__dup_sort_ext_caps (UPnPDevice *object) +{ + gchar **value; + g_object_get (G_OBJECT (object), "sort-ext-caps", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_sort_ext_caps: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "SortExtCaps" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_sort_ext_caps (UPnPDevice *object, const gchar *const *value) +{ + g_object_set (G_OBJECT (object), "sort-ext-caps", value, NULL); +} + +/** + * upn_pdevice__get_feature_list: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "FeatureList" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_feature_list() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +GVariant * +upn_pdevice__get_feature_list (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_feature_list (object); +} + +/** + * upn_pdevice__dup_feature_list: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "FeatureList" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref(). + */ +GVariant * +upn_pdevice__dup_feature_list (UPnPDevice *object) +{ + GVariant *value; + g_object_get (G_OBJECT (object), "feature-list", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_feature_list: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "FeatureList" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_feature_list (UPnPDevice *object, GVariant *value) +{ + g_object_set (G_OBJECT (object), "feature-list", value, NULL); +} + +/** + * upn_pdevice__get_system_update_id: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "SystemUpdateID" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +guint +upn_pdevice__get_system_update_id (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_system_update_id (object); +} + +/** + * upn_pdevice__set_system_update_id: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "SystemUpdateID" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_system_update_id (UPnPDevice *object, guint value) +{ + g_object_set (G_OBJECT (object), "system-update-id", value, NULL); +} + +/** + * upn_pdevice__get_service_reset_token: (skip) + * @object: A #UPnPDevice. + * + * Gets the value of the "ServiceResetToken" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pdevice__dup_service_reset_token() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pdevice__get_service_reset_token (UPnPDevice *object) +{ + return UPN_PDEVICE__GET_IFACE (object)->get_service_reset_token (object); +} + +/** + * upn_pdevice__dup_service_reset_token: (skip) + * @object: A #UPnPDevice. + * + * Gets a copy of the "ServiceResetToken" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pdevice__dup_service_reset_token (UPnPDevice *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "service-reset-token", &value, NULL); + return value; +} + +/** + * upn_pdevice__set_service_reset_token: (skip) + * @object: A #UPnPDevice. + * @value: The value to set. + * + * Sets the "ServiceResetToken" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pdevice__set_service_reset_token (UPnPDevice *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "service-reset-token", value, NULL); +} + +/** + * upn_pdevice__emit_container_update_ids: + * @object: A #UPnPDevice. + * @arg_ContainerPathsIDs: Argument to pass with the signal. + * + * Emits the "ContainerUpdateIDs" D-Bus signal. + */ +void +upn_pdevice__emit_container_update_ids ( + UPnPDevice *object, + GVariant *arg_ContainerPathsIDs) +{ + g_signal_emit_by_name (object, "container-update-ids", arg_ContainerPathsIDs); +} + +/** + * upn_pdevice__emit_last_change: + * @object: A #UPnPDevice. + * @arg_StateEvent: Argument to pass with the signal. + * + * Emits the "LastChange" D-Bus signal. + */ +void +upn_pdevice__emit_last_change ( + UPnPDevice *object, + GVariant *arg_StateEvent) +{ + g_signal_emit_by_name (object, "last-change", arg_StateEvent); +} + +/** + * upn_pdevice__emit_upload_update: + * @object: A #UPnPDevice. + * @arg_UploadId: Argument to pass with the signal. + * @arg_UploadStatus: Argument to pass with the signal. + * @arg_Length: Argument to pass with the signal. + * @arg_Total: Argument to pass with the signal. + * + * Emits the "UploadUpdate" D-Bus signal. + */ +void +upn_pdevice__emit_upload_update ( + UPnPDevice *object, + guint arg_UploadId, + const gchar *arg_UploadStatus, + guint64 arg_Length, + guint64 arg_Total) +{ + g_signal_emit_by_name (object, "upload-update", arg_UploadId, arg_UploadStatus, arg_Length, arg_Total); +} + +/** + * upn_pdevice__call_upload_to_any_container: + * @proxy: A #UPnPDeviceProxy. + * @arg_DisplayName: Argument to pass with the method invocation. + * @arg_FilePath: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the UploadToAnyContainer() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_upload_to_any_container_finish() to get the result of the operation. + * + * See upn_pdevice__call_upload_to_any_container_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_upload_to_any_container ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_FilePath, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "UploadToAnyContainer", + g_variant_new ("(ss)", + arg_DisplayName, + arg_FilePath), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_upload_to_any_container_finish: + * @proxy: A #UPnPDeviceProxy. + * @out_UploadId: (out): Return location for return parameter or %NULL to ignore. + * @out_Path: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_upload_to_any_container(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_upload_to_any_container(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_upload_to_any_container_finish ( + UPnPDevice *proxy, + guint *out_UploadId, + gchar **out_Path, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(uo)", + out_UploadId, + out_Path); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_upload_to_any_container_sync: + * @proxy: A #UPnPDeviceProxy. + * @arg_DisplayName: Argument to pass with the method invocation. + * @arg_FilePath: Argument to pass with the method invocation. + * @out_UploadId: (out): Return location for return parameter or %NULL to ignore. + * @out_Path: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the UploadToAnyContainer() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_upload_to_any_container() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_upload_to_any_container_sync ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_FilePath, + guint *out_UploadId, + gchar **out_Path, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "UploadToAnyContainer", + g_variant_new ("(ss)", + arg_DisplayName, + arg_FilePath), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(uo)", + out_UploadId, + out_Path); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_get_upload_status: + * @proxy: A #UPnPDeviceProxy. + * @arg_UploadId: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetUploadStatus() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_get_upload_status_finish() to get the result of the operation. + * + * See upn_pdevice__call_get_upload_status_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_get_upload_status ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetUploadStatus", + g_variant_new ("(u)", + arg_UploadId), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_get_upload_status_finish: + * @proxy: A #UPnPDeviceProxy. + * @out_UploadStatus: (out): Return location for return parameter or %NULL to ignore. + * @out_Length: (out): Return location for return parameter or %NULL to ignore. + * @out_Total: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_get_upload_status(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_get_upload_status(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_get_upload_status_finish ( + UPnPDevice *proxy, + gchar **out_UploadStatus, + guint64 *out_Length, + guint64 *out_Total, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(stt)", + out_UploadStatus, + out_Length, + out_Total); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_get_upload_status_sync: + * @proxy: A #UPnPDeviceProxy. + * @arg_UploadId: Argument to pass with the method invocation. + * @out_UploadStatus: (out): Return location for return parameter or %NULL to ignore. + * @out_Length: (out): Return location for return parameter or %NULL to ignore. + * @out_Total: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetUploadStatus() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_get_upload_status() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_get_upload_status_sync ( + UPnPDevice *proxy, + guint arg_UploadId, + gchar **out_UploadStatus, + guint64 *out_Length, + guint64 *out_Total, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetUploadStatus", + g_variant_new ("(u)", + arg_UploadId), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(stt)", + out_UploadStatus, + out_Length, + out_Total); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_get_upload_ids: + * @proxy: A #UPnPDeviceProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the GetUploadIDs() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_get_upload_ids_finish() to get the result of the operation. + * + * See upn_pdevice__call_get_upload_ids_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_get_upload_ids ( + UPnPDevice *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "GetUploadIDs", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_get_upload_ids_finish: + * @proxy: A #UPnPDeviceProxy. + * @out_Total: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_get_upload_ids(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_get_upload_ids(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_get_upload_ids_finish ( + UPnPDevice *proxy, + GVariant **out_Total, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@au)", + out_Total); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_get_upload_ids_sync: + * @proxy: A #UPnPDeviceProxy. + * @out_Total: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the GetUploadIDs() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_get_upload_ids() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_get_upload_ids_sync ( + UPnPDevice *proxy, + GVariant **out_Total, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "GetUploadIDs", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@au)", + out_Total); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_cancel_upload: + * @proxy: A #UPnPDeviceProxy. + * @arg_UploadId: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the CancelUpload() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_cancel_upload_finish() to get the result of the operation. + * + * See upn_pdevice__call_cancel_upload_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_cancel_upload ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "CancelUpload", + g_variant_new ("(u)", + arg_UploadId), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_cancel_upload_finish: + * @proxy: A #UPnPDeviceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_cancel_upload(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_cancel_upload(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_cancel_upload_finish ( + UPnPDevice *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_cancel_upload_sync: + * @proxy: A #UPnPDeviceProxy. + * @arg_UploadId: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the CancelUpload() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_cancel_upload() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_cancel_upload_sync ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "CancelUpload", + g_variant_new ("(u)", + arg_UploadId), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_create_container_in_any_container: + * @proxy: A #UPnPDeviceProxy. + * @arg_DisplayName: Argument to pass with the method invocation. + * @arg_Type: Argument to pass with the method invocation. + * @arg_ChildTypes: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the CreateContainerInAnyContainer() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_create_container_in_any_container_finish() to get the result of the operation. + * + * See upn_pdevice__call_create_container_in_any_container_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_create_container_in_any_container ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_Type, + const gchar *const *arg_ChildTypes, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "CreateContainerInAnyContainer", + g_variant_new ("(ss^as)", + arg_DisplayName, + arg_Type, + arg_ChildTypes), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_create_container_in_any_container_finish: + * @proxy: A #UPnPDeviceProxy. + * @out_Path: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_create_container_in_any_container(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_create_container_in_any_container(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_create_container_in_any_container_finish ( + UPnPDevice *proxy, + gchar **out_Path, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(o)", + out_Path); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_create_container_in_any_container_sync: + * @proxy: A #UPnPDeviceProxy. + * @arg_DisplayName: Argument to pass with the method invocation. + * @arg_Type: Argument to pass with the method invocation. + * @arg_ChildTypes: Argument to pass with the method invocation. + * @out_Path: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the CreateContainerInAnyContainer() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_create_container_in_any_container() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_create_container_in_any_container_sync ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_Type, + const gchar *const *arg_ChildTypes, + gchar **out_Path, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "CreateContainerInAnyContainer", + g_variant_new ("(ss^as)", + arg_DisplayName, + arg_Type, + arg_ChildTypes), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(o)", + out_Path); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_cancel: + * @proxy: A #UPnPDeviceProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the Cancel() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__call_cancel_finish() to get the result of the operation. + * + * See upn_pdevice__call_cancel_sync() for the synchronous, blocking version of this method. + */ +void +upn_pdevice__call_cancel ( + UPnPDevice *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "Cancel", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pdevice__call_cancel_finish: + * @proxy: A #UPnPDeviceProxy. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__call_cancel(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pdevice__call_cancel(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_cancel_finish ( + UPnPDevice *proxy, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__call_cancel_sync: + * @proxy: A #UPnPDeviceProxy. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the Cancel() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pdevice__call_cancel() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pdevice__call_cancel_sync ( + UPnPDevice *proxy, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "Cancel", + g_variant_new ("()"), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "()"); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pdevice__complete_upload_to_any_container: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @UploadId: Parameter to return. + * @Path: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the UploadToAnyContainer() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_upload_to_any_container ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + guint UploadId, + const gchar *Path) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(uo)", + UploadId, + Path)); +} + +/** + * upn_pdevice__complete_get_upload_status: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @UploadStatus: Parameter to return. + * @Length: Parameter to return. + * @Total: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetUploadStatus() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_get_upload_status ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *UploadStatus, + guint64 Length, + guint64 Total) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(stt)", + UploadStatus, + Length, + Total)); +} + +/** + * upn_pdevice__complete_get_upload_ids: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Total: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the GetUploadIDs() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_get_upload_ids ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + GVariant *Total) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@au)", + Total)); +} + +/** + * upn_pdevice__complete_cancel_upload: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the CancelUpload() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_cancel_upload ( + UPnPDevice *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/** + * upn_pdevice__complete_create_container_in_any_container: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Path: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the CreateContainerInAnyContainer() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_create_container_in_any_container ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *Path) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(o)", + Path)); +} + +/** + * upn_pdevice__complete_cancel: + * @object: A #UPnPDevice. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * + * Helper function used in service implementations to finish handling invocations of the Cancel() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pdevice__complete_cancel ( + UPnPDevice *object, + GDBusMethodInvocation *invocation) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("()")); +} + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPDeviceProxy: + * + * The #UPnPDeviceProxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPDeviceProxyClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPDeviceProxy. + */ + +struct _UPnPDeviceProxyPrivate +{ + GData *qdata; +}; + +static void upn_pdevice__proxy_iface_init (UPnPDeviceIface *iface); + +G_DEFINE_TYPE_WITH_CODE (UPnPDeviceProxy, upn_pdevice__proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (UPN_PDEVICE_TYPE_, upn_pdevice__proxy_iface_init)); + +static void +upn_pdevice__proxy_finalize (GObject *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (upn_pdevice__proxy_parent_class)->finalize (object); +} + +static void +upn_pdevice__proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 20); + info = _upn_pdevice__property_info_pointers[prop_id - 1]; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name); + if (info->use_gvariant) + { + g_value_set_variant (value, variant); + } + else + { + if (variant != NULL) + g_dbus_gvariant_to_gvalue (variant, value); + } + if (variant != NULL) + g_variant_unref (variant); +} + +static void +upn_pdevice__proxy_set_property_cb (GDBusProxy *proxy, + GAsyncResult *res, + gpointer user_data) +{ + const _ExtendedGDBusPropertyInfo *info = user_data; + GError *error; + error = NULL; + if (!g_dbus_proxy_call_finish (proxy, res, &error)) + { + g_warning ("Error setting property `%s' on interface com.intel.dLeynaServer.MediaDevice: %s (%s, %d)", + info->parent_struct.name, + error->message, g_quark_to_string (error->domain), error->code); + g_error_free (error); + } +} + +static void +upn_pdevice__proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 20); + info = _upn_pdevice__property_info_pointers[prop_id - 1]; + variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_dbus_proxy_call (G_DBUS_PROXY (object), + "org.freedesktop.DBus.Properties.Set", + g_variant_new ("(ssv)", "com.intel.dLeynaServer.MediaDevice", info->parent_struct.name, variant), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, (GAsyncReadyCallback) upn_pdevice__proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct); + g_variant_unref (variant); +} + +static void +upn_pdevice__proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], UPN_PDEVICE_TYPE_); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PDEVICE_TYPE_); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +upn_pdevice__proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static const gchar * +upn_pdevice__proxy_get_location (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Location"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_udn (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UDN"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_device_type (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DeviceType"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_friendly_name (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FriendlyName"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_manufacturer (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Manufacturer"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_manufacturer_url (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ManufacturerUrl"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_model_description (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ModelDescription"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_model_name (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ModelName"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_model_number (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ModelNumber"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_model_url (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ModelURL"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_serial_number (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SerialNumber"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_presentation_url (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "PresentationURL"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_icon_url (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IconURL"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static GVariant * +upn_pdevice__proxy_get_dlnacaps (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + GVariant *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DLNACaps"); + value = variant; + if (variant != NULL) + g_variant_unref (variant); + return value; +} + +static const gchar *const * +upn_pdevice__proxy_get_search_caps (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *const *value = NULL; + value = g_datalist_get_data (&proxy->priv->qdata, "SearchCaps"); + if (value != NULL) + return value; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SearchCaps"); + if (variant != NULL) + { + value = g_variant_get_strv (variant, NULL); + g_datalist_set_data_full (&proxy->priv->qdata, "SearchCaps", (gpointer) value, g_free); + g_variant_unref (variant); + } + return value; +} + +static const gchar *const * +upn_pdevice__proxy_get_sort_caps (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *const *value = NULL; + value = g_datalist_get_data (&proxy->priv->qdata, "SortCaps"); + if (value != NULL) + return value; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SortCaps"); + if (variant != NULL) + { + value = g_variant_get_strv (variant, NULL); + g_datalist_set_data_full (&proxy->priv->qdata, "SortCaps", (gpointer) value, g_free); + g_variant_unref (variant); + } + return value; +} + +static const gchar *const * +upn_pdevice__proxy_get_sort_ext_caps (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *const *value = NULL; + value = g_datalist_get_data (&proxy->priv->qdata, "SortExtCaps"); + if (value != NULL) + return value; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SortExtCaps"); + if (variant != NULL) + { + value = g_variant_get_strv (variant, NULL); + g_datalist_set_data_full (&proxy->priv->qdata, "SortExtCaps", (gpointer) value, g_free); + g_variant_unref (variant); + } + return value; +} + +static GVariant * +upn_pdevice__proxy_get_feature_list (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + GVariant *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FeatureList"); + value = variant; + if (variant != NULL) + g_variant_unref (variant); + return value; +} + +static guint +upn_pdevice__proxy_get_system_update_id (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + guint value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SystemUpdateID"); + if (variant != NULL) + { + value = g_variant_get_uint32 (variant); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pdevice__proxy_get_service_reset_token (UPnPDevice *object) +{ + UPnPDeviceProxy *proxy = UPN_PDEVICE__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ServiceResetToken"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static void +upn_pdevice__proxy_init (UPnPDeviceProxy *proxy) +{ + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UPN_PDEVICE_TYPE__PROXY, UPnPDeviceProxyPrivate); + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), upn_pdevice__interface_info ()); +} + +static void +upn_pdevice__proxy_class_init (UPnPDeviceProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + g_type_class_add_private (klass, sizeof (UPnPDeviceProxyPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pdevice__proxy_finalize; + gobject_class->get_property = upn_pdevice__proxy_get_property; + gobject_class->set_property = upn_pdevice__proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = upn_pdevice__proxy_g_signal; + proxy_class->g_properties_changed = upn_pdevice__proxy_g_properties_changed; + + + upn_pdevice__override_properties (gobject_class, 1); +} + +static void +upn_pdevice__proxy_iface_init (UPnPDeviceIface *iface) +{ + iface->get_location = upn_pdevice__proxy_get_location; + iface->get_udn = upn_pdevice__proxy_get_udn; + iface->get_device_type = upn_pdevice__proxy_get_device_type; + iface->get_friendly_name = upn_pdevice__proxy_get_friendly_name; + iface->get_manufacturer = upn_pdevice__proxy_get_manufacturer; + iface->get_manufacturer_url = upn_pdevice__proxy_get_manufacturer_url; + iface->get_model_description = upn_pdevice__proxy_get_model_description; + iface->get_model_name = upn_pdevice__proxy_get_model_name; + iface->get_model_number = upn_pdevice__proxy_get_model_number; + iface->get_model_url = upn_pdevice__proxy_get_model_url; + iface->get_serial_number = upn_pdevice__proxy_get_serial_number; + iface->get_presentation_url = upn_pdevice__proxy_get_presentation_url; + iface->get_icon_url = upn_pdevice__proxy_get_icon_url; + iface->get_dlnacaps = upn_pdevice__proxy_get_dlnacaps; + iface->get_search_caps = upn_pdevice__proxy_get_search_caps; + iface->get_sort_caps = upn_pdevice__proxy_get_sort_caps; + iface->get_sort_ext_caps = upn_pdevice__proxy_get_sort_ext_caps; + iface->get_feature_list = upn_pdevice__proxy_get_feature_list; + iface->get_system_update_id = upn_pdevice__proxy_get_system_update_id; + iface->get_service_reset_token = upn_pdevice__proxy_get_service_reset_token; +} + +/** + * upn_pdevice__proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface com.intel.dLeynaServer.MediaDevice. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__proxy_new_finish() to get the result of the operation. + * + * See upn_pdevice__proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pdevice__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PDEVICE_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.MediaDevice", NULL); +} + +/** + * upn_pdevice__proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pdevice__proxy_new(). + * + * Returns: (transfer full) (type UPnPDeviceProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPDevice * +upn_pdevice__proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PDEVICE_ (ret); + else + return NULL; +} + +/** + * upn_pdevice__proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface com.intel.dLeynaServer.MediaDevice. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pdevice__proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPDeviceProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPDevice * +upn_pdevice__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PDEVICE_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.MediaDevice", NULL); + if (ret != NULL) + return UPN_PDEVICE_ (ret); + else + return NULL; +} + + +/** + * upn_pdevice__proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like upn_pdevice__proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pdevice__proxy_new_for_bus_finish() to get the result of the operation. + * + * See upn_pdevice__proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pdevice__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PDEVICE_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.MediaDevice", NULL); +} + +/** + * upn_pdevice__proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pdevice__proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pdevice__proxy_new_for_bus(). + * + * Returns: (transfer full) (type UPnPDeviceProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPDevice * +upn_pdevice__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PDEVICE_ (ret); + else + return NULL; +} + +/** + * upn_pdevice__proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like upn_pdevice__proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pdevice__proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPDeviceProxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPDevice * +upn_pdevice__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PDEVICE_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "com.intel.dLeynaServer.MediaDevice", NULL); + if (ret != NULL) + return UPN_PDEVICE_ (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPDeviceSkeleton: + * + * The #UPnPDeviceSkeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPDeviceSkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPDeviceSkeleton. + */ + +struct _UPnPDeviceSkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_upn_pdevice__skeleton_handle_method_call ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], UPN_PDEVICE_TYPE_); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PDEVICE_TYPE_); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_upn_pdevice__skeleton_handle_get_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_upn_pdevice__skeleton_handle_set_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pdevice__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _upn_pdevice__skeleton_vtable = +{ + _upn_pdevice__skeleton_handle_method_call, + _upn_pdevice__skeleton_handle_get_property, + _upn_pdevice__skeleton_handle_set_property +}; + +static GDBusInterfaceInfo * +upn_pdevice__skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton) +{ + return upn_pdevice__interface_info (); +} + +static GDBusInterfaceVTable * +upn_pdevice__skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton) +{ + return (GDBusInterfaceVTable *) &_upn_pdevice__skeleton_vtable; +} + +static GVariant * +upn_pdevice__skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_upn_pdevice__interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _upn_pdevice__interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _upn_pdevice__interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _upn_pdevice__skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.MediaDevice", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static gboolean _upn_pdevice__emit_changed (gpointer user_data); + +static void +upn_pdevice__skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (_skeleton); + gboolean emit_changed = FALSE; + + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties_idle_source != NULL) + { + g_source_destroy (skeleton->priv->changed_properties_idle_source); + skeleton->priv->changed_properties_idle_source = NULL; + emit_changed = TRUE; + } + g_mutex_unlock (&skeleton->priv->lock); + + if (emit_changed) + _upn_pdevice__emit_changed (skeleton); +} + +static void +_upn_pdevice__on_signal_container_update_ids ( + UPnPDevice *object, + GVariant *arg_ContainerPathsIDs) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(@a(ou))", + arg_ContainerPathsIDs)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.MediaDevice", "ContainerUpdateIDs", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_upn_pdevice__on_signal_last_change ( + UPnPDevice *object, + GVariant *arg_StateEvent) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(@a(sv))", + arg_StateEvent)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.MediaDevice", "LastChange", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void +_upn_pdevice__on_signal_upload_update ( + UPnPDevice *object, + guint arg_UploadId, + const gchar *arg_UploadStatus, + guint64 arg_Length, + guint64 arg_Total) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + + GList *connections, *l; + GVariant *signal_variant; + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + + signal_variant = g_variant_ref_sink (g_variant_new ("(ustt)", + arg_UploadId, + arg_UploadStatus, + arg_Length, + arg_Total)); + for (l = connections; l != NULL; l = l->next) + { + GDBusConnection *connection = l->data; + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "com.intel.dLeynaServer.MediaDevice", "UploadUpdate", + signal_variant, NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); +} + +static void upn_pdevice__skeleton_iface_init (UPnPDeviceIface *iface); +G_DEFINE_TYPE_WITH_CODE (UPnPDeviceSkeleton, upn_pdevice__skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (UPN_PDEVICE_TYPE_, upn_pdevice__skeleton_iface_init)); + +static void +upn_pdevice__skeleton_finalize (GObject *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + guint n; + for (n = 0; n < 20; n++) + g_value_unset (&skeleton->priv->properties[n]); + g_free (skeleton->priv->properties); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (upn_pdevice__skeleton_parent_class)->finalize (object); +} + +static void +upn_pdevice__skeleton_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 20); + g_mutex_lock (&skeleton->priv->lock); + g_value_copy (&skeleton->priv->properties[prop_id - 1], value); + g_mutex_unlock (&skeleton->priv->lock); +} + +static gboolean +_upn_pdevice__emit_changed (gpointer user_data) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (user_data); + GList *l; + GVariantBuilder builder; + GVariantBuilder invalidated_builder; + guint num_changes; + + g_mutex_lock (&skeleton->priv->lock); + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as")); + for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next) + { + ChangedProperty *cp = l->data; + GVariant *variant; + const GValue *cur_value; + + cur_value = &skeleton->priv->properties[cp->prop_id - 1]; + if (!_g_value_equal (cur_value, &cp->orig_value)) + { + variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature)); + g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant); + g_variant_unref (variant); + num_changes++; + } + } + if (num_changes > 0) + { + GList *connections, *ll; + GVariant *signal_variant; + signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "com.intel.dLeynaServer.MediaDevice", + &builder, &invalidated_builder)); + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + for (ll = connections; ll != NULL; ll = ll->next) + { + GDBusConnection *connection = ll->data; + + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), + "org.freedesktop.DBus.Properties", + "PropertiesChanged", + signal_variant, + NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); + } + else + { + g_variant_builder_clear (&builder); + g_variant_builder_clear (&invalidated_builder); + } + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + skeleton->priv->changed_properties = NULL; + skeleton->priv->changed_properties_idle_source = NULL; + g_mutex_unlock (&skeleton->priv->lock); + return FALSE; +} + +static void +_upn_pdevice__schedule_emit_changed (UPnPDeviceSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value) +{ + ChangedProperty *cp; + GList *l; + cp = NULL; + for (l = skeleton->priv->changed_properties; l != NULL; l = l->next) + { + ChangedProperty *i_cp = l->data; + if (i_cp->info == info) + { + cp = i_cp; + break; + } + } + if (cp == NULL) + { + cp = g_new0 (ChangedProperty, 1); + cp->prop_id = prop_id; + cp->info = info; + skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp); + g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value)); + g_value_copy (orig_value, &cp->orig_value); + } +} + +static void +upn_pdevice__skeleton_notify (GObject *object, + GParamSpec *pspec) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties != NULL && + skeleton->priv->changed_properties_idle_source == NULL) + { + skeleton->priv->changed_properties_idle_source = g_idle_source_new (); + g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT); + g_source_set_callback (skeleton->priv->changed_properties_idle_source, _upn_pdevice__emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref); + g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context); + g_source_unref (skeleton->priv->changed_properties_idle_source); + } + g_mutex_unlock (&skeleton->priv->lock); +} + +static void +upn_pdevice__skeleton_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 20); + g_mutex_lock (&skeleton->priv->lock); + g_object_freeze_notify (object); + if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1])) + { + if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL) + _upn_pdevice__schedule_emit_changed (skeleton, _upn_pdevice__property_info_pointers[prop_id - 1], prop_id, &skeleton->priv->properties[prop_id - 1]); + g_value_copy (value, &skeleton->priv->properties[prop_id - 1]); + g_object_notify_by_pspec (object, pspec); + } + g_mutex_unlock (&skeleton->priv->lock); + g_object_thaw_notify (object); +} + +static void +upn_pdevice__skeleton_init (UPnPDeviceSkeleton *skeleton) +{ + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UPN_PDEVICE_TYPE__SKELETON, UPnPDeviceSkeletonPrivate); + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); + skeleton->priv->properties = g_new0 (GValue, 20); + g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[4], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[5], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[6], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[7], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[8], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[9], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[10], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[11], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[12], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[13], G_TYPE_VARIANT); + g_value_init (&skeleton->priv->properties[14], G_TYPE_STRV); + g_value_init (&skeleton->priv->properties[15], G_TYPE_STRV); + g_value_init (&skeleton->priv->properties[16], G_TYPE_STRV); + g_value_init (&skeleton->priv->properties[17], G_TYPE_VARIANT); + g_value_init (&skeleton->priv->properties[18], G_TYPE_UINT); + g_value_init (&skeleton->priv->properties[19], G_TYPE_STRING); +} + +static const gchar * +upn_pdevice__skeleton_get_location (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[0])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_udn (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[1])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_device_type (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[2])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_friendly_name (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[3])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_manufacturer (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[4])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_manufacturer_url (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[5])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_model_description (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[6])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_model_name (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[7])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_model_number (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[8])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_model_url (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[9])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_serial_number (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[10])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_presentation_url (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[11])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_icon_url (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[12])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static GVariant * +upn_pdevice__skeleton_get_dlnacaps (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + GVariant *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_variant (&(skeleton->priv->properties[13])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar *const * +upn_pdevice__skeleton_get_search_caps (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *const *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boxed (&(skeleton->priv->properties[14])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar *const * +upn_pdevice__skeleton_get_sort_caps (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *const *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boxed (&(skeleton->priv->properties[15])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar *const * +upn_pdevice__skeleton_get_sort_ext_caps (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *const *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boxed (&(skeleton->priv->properties[16])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static GVariant * +upn_pdevice__skeleton_get_feature_list (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + GVariant *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_variant (&(skeleton->priv->properties[17])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static guint +upn_pdevice__skeleton_get_system_update_id (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + guint value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_uint (&(skeleton->priv->properties[18])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pdevice__skeleton_get_service_reset_token (UPnPDevice *object) +{ + UPnPDeviceSkeleton *skeleton = UPN_PDEVICE__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[19])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static void +upn_pdevice__skeleton_class_init (UPnPDeviceSkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + g_type_class_add_private (klass, sizeof (UPnPDeviceSkeletonPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pdevice__skeleton_finalize; + gobject_class->get_property = upn_pdevice__skeleton_get_property; + gobject_class->set_property = upn_pdevice__skeleton_set_property; + gobject_class->notify = upn_pdevice__skeleton_notify; + + + upn_pdevice__override_properties (gobject_class, 1); + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = upn_pdevice__skeleton_dbus_interface_get_info; + skeleton_class->get_properties = upn_pdevice__skeleton_dbus_interface_get_properties; + skeleton_class->flush = upn_pdevice__skeleton_dbus_interface_flush; + skeleton_class->get_vtable = upn_pdevice__skeleton_dbus_interface_get_vtable; +} + +static void +upn_pdevice__skeleton_iface_init (UPnPDeviceIface *iface) +{ + iface->container_update_ids = _upn_pdevice__on_signal_container_update_ids; + iface->last_change = _upn_pdevice__on_signal_last_change; + iface->upload_update = _upn_pdevice__on_signal_upload_update; + iface->get_location = upn_pdevice__skeleton_get_location; + iface->get_udn = upn_pdevice__skeleton_get_udn; + iface->get_device_type = upn_pdevice__skeleton_get_device_type; + iface->get_friendly_name = upn_pdevice__skeleton_get_friendly_name; + iface->get_manufacturer = upn_pdevice__skeleton_get_manufacturer; + iface->get_manufacturer_url = upn_pdevice__skeleton_get_manufacturer_url; + iface->get_model_description = upn_pdevice__skeleton_get_model_description; + iface->get_model_name = upn_pdevice__skeleton_get_model_name; + iface->get_model_number = upn_pdevice__skeleton_get_model_number; + iface->get_model_url = upn_pdevice__skeleton_get_model_url; + iface->get_serial_number = upn_pdevice__skeleton_get_serial_number; + iface->get_presentation_url = upn_pdevice__skeleton_get_presentation_url; + iface->get_icon_url = upn_pdevice__skeleton_get_icon_url; + iface->get_dlnacaps = upn_pdevice__skeleton_get_dlnacaps; + iface->get_search_caps = upn_pdevice__skeleton_get_search_caps; + iface->get_sort_caps = upn_pdevice__skeleton_get_sort_caps; + iface->get_sort_ext_caps = upn_pdevice__skeleton_get_sort_ext_caps; + iface->get_feature_list = upn_pdevice__skeleton_get_feature_list; + iface->get_system_update_id = upn_pdevice__skeleton_get_system_update_id; + iface->get_service_reset_token = upn_pdevice__skeleton_get_service_reset_token; +} + +/** + * upn_pdevice__skeleton_new: + * + * Creates a skeleton object for the D-Bus interface com.intel.dLeynaServer.MediaDevice. + * + * Returns: (transfer full) (type UPnPDeviceSkeleton): The skeleton object. + */ +UPnPDevice * +upn_pdevice__skeleton_new (void) +{ + return UPN_PDEVICE_ (g_object_new (UPN_PDEVICE_TYPE__SKELETON, NULL)); +} + diff --git a/src/MediaServer/dleynaserver-mediadevice-proxy.h b/src/MediaServer/dleynaserver-mediadevice-proxy.h new file mode 100644 index 0000000..b494ff9 --- /dev/null +++ b/src/MediaServer/dleynaserver-mediadevice-proxy.h @@ -0,0 +1,485 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __DLEYNASERVER_MEDIADEVICE_PROXY_H__ +#define __DLEYNASERVER_MEDIADEVICE_PROXY_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for com.intel.dLeynaServer.MediaDevice */ + +#define UPN_PDEVICE_TYPE_ (upn_pdevice__get_type ()) +#define UPN_PDEVICE_(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PDEVICE_TYPE_, UPnPDevice)) +#define UPN_PDEVICE_IS_(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PDEVICE_TYPE_)) +#define UPN_PDEVICE__GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UPN_PDEVICE_TYPE_, UPnPDeviceIface)) + +struct _UPnPDevice; +typedef struct _UPnPDevice UPnPDevice; +typedef struct _UPnPDeviceIface UPnPDeviceIface; + +struct _UPnPDeviceIface +{ + GTypeInterface parent_iface; + + + + gboolean (*handle_cancel) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_cancel_upload) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + guint arg_UploadId); + + gboolean (*handle_create_container_in_any_container) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *arg_DisplayName, + const gchar *arg_Type, + const gchar *const *arg_ChildTypes); + + gboolean (*handle_get_upload_ids) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation); + + gboolean (*handle_get_upload_status) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + guint arg_UploadId); + + gboolean (*handle_upload_to_any_container) ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *arg_DisplayName, + const gchar *arg_FilePath); + + const gchar * (*get_device_type) (UPnPDevice *object); + + GVariant * (*get_dlnacaps) (UPnPDevice *object); + + GVariant * (*get_feature_list) (UPnPDevice *object); + + const gchar * (*get_friendly_name) (UPnPDevice *object); + + const gchar * (*get_icon_url) (UPnPDevice *object); + + const gchar * (*get_location) (UPnPDevice *object); + + const gchar * (*get_manufacturer) (UPnPDevice *object); + + const gchar * (*get_manufacturer_url) (UPnPDevice *object); + + const gchar * (*get_model_description) (UPnPDevice *object); + + const gchar * (*get_model_name) (UPnPDevice *object); + + const gchar * (*get_model_number) (UPnPDevice *object); + + const gchar * (*get_model_url) (UPnPDevice *object); + + const gchar * (*get_presentation_url) (UPnPDevice *object); + + const gchar *const * (*get_search_caps) (UPnPDevice *object); + + const gchar * (*get_serial_number) (UPnPDevice *object); + + const gchar * (*get_service_reset_token) (UPnPDevice *object); + + const gchar *const * (*get_sort_caps) (UPnPDevice *object); + + const gchar *const * (*get_sort_ext_caps) (UPnPDevice *object); + + guint (*get_system_update_id) (UPnPDevice *object); + + const gchar * (*get_udn) (UPnPDevice *object); + + void (*container_update_ids) ( + UPnPDevice *object, + GVariant *arg_ContainerPathsIDs); + + void (*last_change) ( + UPnPDevice *object, + GVariant *arg_StateEvent); + + void (*upload_update) ( + UPnPDevice *object, + guint arg_UploadId, + const gchar *arg_UploadStatus, + guint64 arg_Length, + guint64 arg_Total); + +}; + +GType upn_pdevice__get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *upn_pdevice__interface_info (void); +guint upn_pdevice__override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void upn_pdevice__complete_upload_to_any_container ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + guint UploadId, + const gchar *Path); + +void upn_pdevice__complete_get_upload_status ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *UploadStatus, + guint64 Length, + guint64 Total); + +void upn_pdevice__complete_get_upload_ids ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + GVariant *Total); + +void upn_pdevice__complete_cancel_upload ( + UPnPDevice *object, + GDBusMethodInvocation *invocation); + +void upn_pdevice__complete_create_container_in_any_container ( + UPnPDevice *object, + GDBusMethodInvocation *invocation, + const gchar *Path); + +void upn_pdevice__complete_cancel ( + UPnPDevice *object, + GDBusMethodInvocation *invocation); + + + +/* D-Bus signal emissions functions: */ +void upn_pdevice__emit_container_update_ids ( + UPnPDevice *object, + GVariant *arg_ContainerPathsIDs); + +void upn_pdevice__emit_last_change ( + UPnPDevice *object, + GVariant *arg_StateEvent); + +void upn_pdevice__emit_upload_update ( + UPnPDevice *object, + guint arg_UploadId, + const gchar *arg_UploadStatus, + guint64 arg_Length, + guint64 arg_Total); + + + +/* D-Bus method calls: */ +void upn_pdevice__call_upload_to_any_container ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_FilePath, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_upload_to_any_container_finish ( + UPnPDevice *proxy, + guint *out_UploadId, + gchar **out_Path, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_upload_to_any_container_sync ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_FilePath, + guint *out_UploadId, + gchar **out_Path, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__call_get_upload_status ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_get_upload_status_finish ( + UPnPDevice *proxy, + gchar **out_UploadStatus, + guint64 *out_Length, + guint64 *out_Total, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_get_upload_status_sync ( + UPnPDevice *proxy, + guint arg_UploadId, + gchar **out_UploadStatus, + guint64 *out_Length, + guint64 *out_Total, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__call_get_upload_ids ( + UPnPDevice *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_get_upload_ids_finish ( + UPnPDevice *proxy, + GVariant **out_Total, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_get_upload_ids_sync ( + UPnPDevice *proxy, + GVariant **out_Total, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__call_cancel_upload ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_cancel_upload_finish ( + UPnPDevice *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_cancel_upload_sync ( + UPnPDevice *proxy, + guint arg_UploadId, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__call_create_container_in_any_container ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_Type, + const gchar *const *arg_ChildTypes, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_create_container_in_any_container_finish ( + UPnPDevice *proxy, + gchar **out_Path, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_create_container_in_any_container_sync ( + UPnPDevice *proxy, + const gchar *arg_DisplayName, + const gchar *arg_Type, + const gchar *const *arg_ChildTypes, + gchar **out_Path, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__call_cancel ( + UPnPDevice *proxy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pdevice__call_cancel_finish ( + UPnPDevice *proxy, + GAsyncResult *res, + GError **error); + +gboolean upn_pdevice__call_cancel_sync ( + UPnPDevice *proxy, + GCancellable *cancellable, + GError **error); + + + +/* D-Bus property accessors: */ +const gchar *upn_pdevice__get_location (UPnPDevice *object); +gchar *upn_pdevice__dup_location (UPnPDevice *object); +void upn_pdevice__set_location (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_udn (UPnPDevice *object); +gchar *upn_pdevice__dup_udn (UPnPDevice *object); +void upn_pdevice__set_udn (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_device_type (UPnPDevice *object); +gchar *upn_pdevice__dup_device_type (UPnPDevice *object); +void upn_pdevice__set_device_type (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_friendly_name (UPnPDevice *object); +gchar *upn_pdevice__dup_friendly_name (UPnPDevice *object); +void upn_pdevice__set_friendly_name (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_manufacturer (UPnPDevice *object); +gchar *upn_pdevice__dup_manufacturer (UPnPDevice *object); +void upn_pdevice__set_manufacturer (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_manufacturer_url (UPnPDevice *object); +gchar *upn_pdevice__dup_manufacturer_url (UPnPDevice *object); +void upn_pdevice__set_manufacturer_url (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_model_description (UPnPDevice *object); +gchar *upn_pdevice__dup_model_description (UPnPDevice *object); +void upn_pdevice__set_model_description (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_model_name (UPnPDevice *object); +gchar *upn_pdevice__dup_model_name (UPnPDevice *object); +void upn_pdevice__set_model_name (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_model_number (UPnPDevice *object); +gchar *upn_pdevice__dup_model_number (UPnPDevice *object); +void upn_pdevice__set_model_number (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_model_url (UPnPDevice *object); +gchar *upn_pdevice__dup_model_url (UPnPDevice *object); +void upn_pdevice__set_model_url (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_serial_number (UPnPDevice *object); +gchar *upn_pdevice__dup_serial_number (UPnPDevice *object); +void upn_pdevice__set_serial_number (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_presentation_url (UPnPDevice *object); +gchar *upn_pdevice__dup_presentation_url (UPnPDevice *object); +void upn_pdevice__set_presentation_url (UPnPDevice *object, const gchar *value); + +const gchar *upn_pdevice__get_icon_url (UPnPDevice *object); +gchar *upn_pdevice__dup_icon_url (UPnPDevice *object); +void upn_pdevice__set_icon_url (UPnPDevice *object, const gchar *value); + +GVariant *upn_pdevice__get_dlnacaps (UPnPDevice *object); +GVariant *upn_pdevice__dup_dlnacaps (UPnPDevice *object); +void upn_pdevice__set_dlnacaps (UPnPDevice *object, GVariant *value); + +const gchar *const *upn_pdevice__get_search_caps (UPnPDevice *object); +gchar **upn_pdevice__dup_search_caps (UPnPDevice *object); +void upn_pdevice__set_search_caps (UPnPDevice *object, const gchar *const *value); + +const gchar *const *upn_pdevice__get_sort_caps (UPnPDevice *object); +gchar **upn_pdevice__dup_sort_caps (UPnPDevice *object); +void upn_pdevice__set_sort_caps (UPnPDevice *object, const gchar *const *value); + +const gchar *const *upn_pdevice__get_sort_ext_caps (UPnPDevice *object); +gchar **upn_pdevice__dup_sort_ext_caps (UPnPDevice *object); +void upn_pdevice__set_sort_ext_caps (UPnPDevice *object, const gchar *const *value); + +GVariant *upn_pdevice__get_feature_list (UPnPDevice *object); +GVariant *upn_pdevice__dup_feature_list (UPnPDevice *object); +void upn_pdevice__set_feature_list (UPnPDevice *object, GVariant *value); + +guint upn_pdevice__get_system_update_id (UPnPDevice *object); +void upn_pdevice__set_system_update_id (UPnPDevice *object, guint value); + +const gchar *upn_pdevice__get_service_reset_token (UPnPDevice *object); +gchar *upn_pdevice__dup_service_reset_token (UPnPDevice *object); +void upn_pdevice__set_service_reset_token (UPnPDevice *object, const gchar *value); + + +/* ---- */ + +#define UPN_PDEVICE_TYPE__PROXY (upn_pdevice__proxy_get_type ()) +#define UPN_PDEVICE__PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PDEVICE_TYPE__PROXY, UPnPDeviceProxy)) +#define UPN_PDEVICE__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PDEVICE_TYPE__PROXY, UPnPDeviceProxyClass)) +#define UPN_PDEVICE__PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PDEVICE_TYPE__PROXY, UPnPDeviceProxyClass)) +#define UPN_PDEVICE_IS__PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PDEVICE_TYPE__PROXY)) +#define UPN_PDEVICE_IS__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PDEVICE_TYPE__PROXY)) + +typedef struct _UPnPDeviceProxy UPnPDeviceProxy; +typedef struct _UPnPDeviceProxyClass UPnPDeviceProxyClass; +typedef struct _UPnPDeviceProxyPrivate UPnPDeviceProxyPrivate; + +struct _UPnPDeviceProxy +{ + /*< private >*/ + GDBusProxy parent_instance; + UPnPDeviceProxyPrivate *priv; +}; + +struct _UPnPDeviceProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType upn_pdevice__proxy_get_type (void) G_GNUC_CONST; + +void upn_pdevice__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPDevice *upn_pdevice__proxy_new_finish ( + GAsyncResult *res, + GError **error); +UPnPDevice *upn_pdevice__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void upn_pdevice__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPDevice *upn_pdevice__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +UPnPDevice *upn_pdevice__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define UPN_PDEVICE_TYPE__SKELETON (upn_pdevice__skeleton_get_type ()) +#define UPN_PDEVICE__SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PDEVICE_TYPE__SKELETON, UPnPDeviceSkeleton)) +#define UPN_PDEVICE__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PDEVICE_TYPE__SKELETON, UPnPDeviceSkeletonClass)) +#define UPN_PDEVICE__SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PDEVICE_TYPE__SKELETON, UPnPDeviceSkeletonClass)) +#define UPN_PDEVICE_IS__SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PDEVICE_TYPE__SKELETON)) +#define UPN_PDEVICE_IS__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PDEVICE_TYPE__SKELETON)) + +typedef struct _UPnPDeviceSkeleton UPnPDeviceSkeleton; +typedef struct _UPnPDeviceSkeletonClass UPnPDeviceSkeletonClass; +typedef struct _UPnPDeviceSkeletonPrivate UPnPDeviceSkeletonPrivate; + +struct _UPnPDeviceSkeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + UPnPDeviceSkeletonPrivate *priv; +}; + +struct _UPnPDeviceSkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType upn_pdevice__skeleton_get_type (void) G_GNUC_CONST; + +UPnPDevice *upn_pdevice__skeleton_new (void); + + +G_END_DECLS + +#endif /* __DLEYNASERVER_MEDIADEVICE_PROXY_H__ */ diff --git a/src/MediaServer/plugin_config.cpp b/src/MediaServer/plugin_config.cpp new file mode 100755 index 0000000..e69de29 diff --git a/src/MediaServer/plugin_initializer.cpp b/src/MediaServer/plugin_initializer.cpp new file mode 100644 index 0000000..d0fba07 --- /dev/null +++ b/src/MediaServer/plugin_initializer.cpp @@ -0,0 +1,76 @@ +// +// Tizen Web Device API +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#include +#include +#include "JSMediaServerManager.h" +#include + +namespace DeviceAPI { +namespace MediaServer { + +using namespace WrtDeviceApis; +using namespace WrtDeviceApis::Commons; + +class_definition_options_t ConstructorClassOptions = +{ + JS_INTERFACE, + CREATE_INSTANCE, + NONE_NOTICE, + USE_OVERLAYED, //ignored + NULL, + NULL, + NULL +}; + +void on_widget_start_callback(int widgetId) { + LoggerD("[TIZEN\\MediaServerManager] on_widget_start_callback ("< + +#ifdef G_OS_UNIX +#undef G_OS_UNIX +#endif + +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface org.gnome.UPnP.MediaContainer2 + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:UPnPContainer2 + * @title: UPnPContainer2 + * @short_description: Generated C code for the org.gnome.UPnP.MediaContainer2 D-Bus interface + * + * This section contains code for working with the org.gnome.UPnP.MediaContainer2 D-Bus interface in C. + */ + +/* ---- Introspection data for org.gnome.UPnP.MediaContainer2 ---- */ + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_children_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_children_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_children_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_children_IN_ARG_Filter, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_children_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_children_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_children = +{ + { + -1, + (gchar *) "ListChildren", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_children_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_children_OUT_ARG_pointers, + NULL + }, + "handle-list-children", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_ex_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_ex_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_ex_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_ex_IN_ARG_SortBy = +{ + { + -1, + (gchar *) "SortBy", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_children_ex_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_children_ex_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_children_ex_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_children_ex_IN_ARG_Filter, + &_upn_pcontainer2__method_info_list_children_ex_IN_ARG_SortBy, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_children_ex_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_children_ex_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_children_ex_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_children_ex = +{ + { + -1, + (gchar *) "ListChildrenEx", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_children_ex_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_children_ex_OUT_ARG_pointers, + NULL + }, + "handle-list-children-ex", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_containers_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_containers_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_containers_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_containers_IN_ARG_Filter, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_containers_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_containers_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_containers = +{ + { + -1, + (gchar *) "ListContainers", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_containers_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_containers_OUT_ARG_pointers, + NULL + }, + "handle-list-containers", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_ex_IN_ARG_SortBy = +{ + { + -1, + (gchar *) "SortBy", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_containers_ex_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_containers_ex_IN_ARG_Filter, + &_upn_pcontainer2__method_info_list_containers_ex_IN_ARG_SortBy, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_containers_ex_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_containers_ex_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_containers_ex_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_containers_ex = +{ + { + -1, + (gchar *) "ListContainersEx", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_containers_ex_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_containers_ex_OUT_ARG_pointers, + NULL + }, + "handle-list-containers-ex", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_items_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_items_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_items_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_items_IN_ARG_Filter, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_items_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_items_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_items = +{ + { + -1, + (gchar *) "ListItems", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_items_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_items_OUT_ARG_pointers, + NULL + }, + "handle-list-items", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_ex_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_ex_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_ex_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_ex_IN_ARG_SortBy = +{ + { + -1, + (gchar *) "SortBy", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_items_ex_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_items_ex_IN_ARG_Offset, + &_upn_pcontainer2__method_info_list_items_ex_IN_ARG_Max, + &_upn_pcontainer2__method_info_list_items_ex_IN_ARG_Filter, + &_upn_pcontainer2__method_info_list_items_ex_IN_ARG_SortBy, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_list_items_ex_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_list_items_ex_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_list_items_ex_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_list_items_ex = +{ + { + -1, + (gchar *) "ListItemsEx", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_items_ex_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_list_items_ex_OUT_ARG_pointers, + NULL + }, + "handle-list-items-ex", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_IN_ARG_Query = +{ + { + -1, + (gchar *) "Query", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_search_objects_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_search_objects_IN_ARG_Query, + &_upn_pcontainer2__method_info_search_objects_IN_ARG_Offset, + &_upn_pcontainer2__method_info_search_objects_IN_ARG_Max, + &_upn_pcontainer2__method_info_search_objects_IN_ARG_Filter, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_search_objects_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_search_objects_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_search_objects = +{ + { + -1, + (gchar *) "SearchObjects", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_search_objects_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_search_objects_OUT_ARG_pointers, + NULL + }, + "handle-search-objects", + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Query = +{ + { + -1, + (gchar *) "Query", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Offset = +{ + { + -1, + (gchar *) "Offset", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Max = +{ + { + -1, + (gchar *) "Max", + (gchar *) "u", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Filter = +{ + { + -1, + (gchar *) "Filter", + (gchar *) "as", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_SortBy = +{ + { + -1, + (gchar *) "SortBy", + (gchar *) "s", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_search_objects_ex_IN_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Query, + &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Offset, + &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Max, + &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_Filter, + &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_SortBy, + NULL +}; + +static const _ExtendedGDBusArgInfo _upn_pcontainer2__method_info_search_objects_ex_OUT_ARG_Children = +{ + { + -1, + (gchar *) "Children", + (gchar *) "aa{sv}", + NULL + }, + FALSE +}; + +static const _ExtendedGDBusArgInfo * const _upn_pcontainer2__method_info_search_objects_ex_OUT_ARG_pointers[] = +{ + &_upn_pcontainer2__method_info_search_objects_ex_OUT_ARG_Children, + NULL +}; + +static const _ExtendedGDBusMethodInfo _upn_pcontainer2__method_info_search_objects_ex = +{ + { + -1, + (gchar *) "SearchObjectsEx", + (GDBusArgInfo **) &_upn_pcontainer2__method_info_search_objects_ex_IN_ARG_pointers, + (GDBusArgInfo **) &_upn_pcontainer2__method_info_search_objects_ex_OUT_ARG_pointers, + NULL + }, + "handle-search-objects-ex", + FALSE +}; + +static const _ExtendedGDBusMethodInfo * const _upn_pcontainer2__method_info_pointers[] = +{ + &_upn_pcontainer2__method_info_list_children, + &_upn_pcontainer2__method_info_list_children_ex, + &_upn_pcontainer2__method_info_list_containers, + &_upn_pcontainer2__method_info_list_containers_ex, + &_upn_pcontainer2__method_info_list_items, + &_upn_pcontainer2__method_info_list_items_ex, + &_upn_pcontainer2__method_info_search_objects, + &_upn_pcontainer2__method_info_search_objects_ex, + NULL +}; + +static const _ExtendedGDBusPropertyInfo _upn_pcontainer2__property_info_child_count = +{ + { + -1, + (gchar *) "ChildCount", + (gchar *) "u", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "child-count", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pcontainer2__property_info_searchable = +{ + { + -1, + (gchar *) "Searchable", + (gchar *) "b", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "searchable", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo * const _upn_pcontainer2__property_info_pointers[] = +{ + &_upn_pcontainer2__property_info_child_count, + &_upn_pcontainer2__property_info_searchable, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _upn_pcontainer2__interface_info = +{ + { + -1, + (gchar *) "org.gnome.UPnP.MediaContainer2", + (GDBusMethodInfo **) &_upn_pcontainer2__method_info_pointers, + NULL, + (GDBusPropertyInfo **) &_upn_pcontainer2__property_info_pointers, + NULL + }, + "", +}; + + +/** + * upn_pcontainer2__interface_info: + * + * Gets a machine-readable description of the org.gnome.UPnP.MediaContainer2 D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +upn_pcontainer2__interface_info (void) +{ + return (GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct; +} + +/** + * upn_pcontainer2__override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #UPnPContainer2 interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +upn_pcontainer2__override_properties (GObjectClass *klass, guint property_id_begin) +{ + g_object_class_override_property (klass, property_id_begin++, "child-count"); + g_object_class_override_property (klass, property_id_begin++, "searchable"); + return property_id_begin - 1; +} + + + +/** + * UPnPContainer2: + * + * Abstract interface type for the D-Bus interface org.gnome.UPnP.MediaContainer2. + */ + +/** + * UPnPContainer2Iface: + * @parent_iface: The parent interface. + * @handle_list_children: Handler for the #UPnPContainer2::handle-list-children signal. + * @handle_list_children_ex: Handler for the #UPnPContainer2::handle-list-children-ex signal. + * @handle_list_containers: Handler for the #UPnPContainer2::handle-list-containers signal. + * @handle_list_containers_ex: Handler for the #UPnPContainer2::handle-list-containers-ex signal. + * @handle_list_items: Handler for the #UPnPContainer2::handle-list-items signal. + * @handle_list_items_ex: Handler for the #UPnPContainer2::handle-list-items-ex signal. + * @handle_search_objects: Handler for the #UPnPContainer2::handle-search-objects signal. + * @handle_search_objects_ex: Handler for the #UPnPContainer2::handle-search-objects-ex signal. + * @get_child_count: Getter for the #UPnPContainer2:child-count property. + * @get_searchable: Getter for the #UPnPContainer2:searchable property. + * + * Virtual table for the D-Bus interface org.gnome.UPnP.MediaContainer2. + */ + +static void +upn_pcontainer2__default_init (UPnPContainer2Iface *iface) +{ + /* GObject signals for incoming D-Bus method calls: */ + /** + * UPnPContainer2::handle-list-children: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListChildren() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_children() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-children", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_children), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV); + + /** + * UPnPContainer2::handle-list-children-ex: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * @arg_SortBy: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListChildrenEx() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_children_ex() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-children-ex", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_children_ex), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 5, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV, G_TYPE_STRING); + + /** + * UPnPContainer2::handle-list-containers: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListContainers() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_containers() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-containers", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_containers), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV); + + /** + * UPnPContainer2::handle-list-containers-ex: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * @arg_SortBy: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListContainersEx() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_containers_ex() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-containers-ex", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_containers_ex), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 5, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV, G_TYPE_STRING); + + /** + * UPnPContainer2::handle-list-items: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListItems() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_items() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-items", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_items), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 4, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV); + + /** + * UPnPContainer2::handle-list-items-ex: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * @arg_SortBy: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the ListItemsEx() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_list_items_ex() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-list-items-ex", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_list_items_ex), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 5, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV, G_TYPE_STRING); + + /** + * UPnPContainer2::handle-search-objects: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Query: Argument passed by remote caller. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the SearchObjects() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_search_objects() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-search-objects", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_search_objects), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 5, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV); + + /** + * UPnPContainer2::handle-search-objects-ex: + * @object: A #UPnPContainer2. + * @invocation: A #GDBusMethodInvocation. + * @arg_Query: Argument passed by remote caller. + * @arg_Offset: Argument passed by remote caller. + * @arg_Max: Argument passed by remote caller. + * @arg_Filter: Argument passed by remote caller. + * @arg_SortBy: Argument passed by remote caller. + * + * Signal emitted when a remote caller is invoking the SearchObjectsEx() D-Bus method. + * + * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call upn_pcontainer2__complete_search_objects_ex() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned. + * + * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run. + */ + g_signal_new ("handle-search-objects-ex", + G_TYPE_FROM_INTERFACE (iface), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (UPnPContainer2Iface, handle_search_objects_ex), + g_signal_accumulator_true_handled, + NULL, + g_cclosure_marshal_generic, + G_TYPE_BOOLEAN, + 6, + G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRV, G_TYPE_STRING); + + /* GObject properties for D-Bus properties: */ + /** + * UPnPContainer2:child-count: + * + * Represents the D-Bus property "ChildCount". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_uint ("child-count", "ChildCount", "ChildCount", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPContainer2:searchable: + * + * Represents the D-Bus property "Searchable". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_boolean ("searchable", "Searchable", "Searchable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +typedef UPnPContainer2Iface UPnPContainer2Interface; +G_DEFINE_INTERFACE (UPnPContainer2, upn_pcontainer2_, G_TYPE_OBJECT); + +/** + * upn_pcontainer2__get_child_count: (skip) + * @object: A #UPnPContainer2. + * + * Gets the value of the "ChildCount" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +guint +upn_pcontainer2__get_child_count (UPnPContainer2 *object) +{ + return UPN_PCONTAINER2__GET_IFACE (object)->get_child_count (object); +} + +/** + * upn_pcontainer2__set_child_count: (skip) + * @object: A #UPnPContainer2. + * @value: The value to set. + * + * Sets the "ChildCount" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pcontainer2__set_child_count (UPnPContainer2 *object, guint value) +{ + g_object_set (G_OBJECT (object), "child-count", value, NULL); +} + +/** + * upn_pcontainer2__get_searchable: (skip) + * @object: A #UPnPContainer2. + * + * Gets the value of the "Searchable" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: The property value. + */ +gboolean +upn_pcontainer2__get_searchable (UPnPContainer2 *object) +{ + return UPN_PCONTAINER2__GET_IFACE (object)->get_searchable (object); +} + +/** + * upn_pcontainer2__set_searchable: (skip) + * @object: A #UPnPContainer2. + * @value: The value to set. + * + * Sets the "Searchable" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pcontainer2__set_searchable (UPnPContainer2 *object, gboolean value) +{ + g_object_set (G_OBJECT (object), "searchable", value, NULL); +} + +/** + * upn_pcontainer2__call_list_children: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListChildren() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_children_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_children_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_children ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListChildren", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_children_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_children(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_children(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_children_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_children_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListChildren() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_children() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_children_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListChildren", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_children_ex: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListChildrenEx() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_children_ex_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_children_ex_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_children_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListChildrenEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_children_ex_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_children_ex(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_children_ex(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_children_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_children_ex_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListChildrenEx() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_children_ex() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_children_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListChildrenEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_containers: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListContainers() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_containers_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_containers_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_containers ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListContainers", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_containers_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_containers(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_containers(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_containers_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_containers_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListContainers() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_containers() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_containers_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListContainers", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_containers_ex: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListContainersEx() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_containers_ex_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_containers_ex_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_containers_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListContainersEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_containers_ex_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_containers_ex(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_containers_ex(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_containers_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_containers_ex_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListContainersEx() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_containers_ex() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_containers_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListContainersEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_items: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListItems() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_items_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_items_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_items ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListItems", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_items_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_items(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_items(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_items_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_items_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListItems() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_items() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_items_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListItems", + g_variant_new ("(uu^as)", + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_items_ex: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the ListItemsEx() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_list_items_ex_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_list_items_ex_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_list_items_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "ListItemsEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_list_items_ex_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_list_items_ex(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_list_items_ex(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_items_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_list_items_ex_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the ListItemsEx() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_list_items_ex() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_list_items_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "ListItemsEx", + g_variant_new ("(uu^ass)", + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_search_objects: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Query: Argument to pass with the method invocation. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the SearchObjects() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_search_objects_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_search_objects_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_search_objects ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "SearchObjects", + g_variant_new ("(suu^as)", + arg_Query, + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_search_objects_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_search_objects(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_search_objects(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_search_objects_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_search_objects_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Query: Argument to pass with the method invocation. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the SearchObjects() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_search_objects() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_search_objects_sync ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "SearchObjects", + g_variant_new ("(suu^as)", + arg_Query, + arg_Offset, + arg_Max, + arg_Filter), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_search_objects_ex: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Query: Argument to pass with the method invocation. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL. + * @user_data: User data to pass to @callback. + * + * Asynchronously invokes the SearchObjectsEx() D-Bus method on @proxy. + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__call_search_objects_ex_finish() to get the result of the operation. + * + * See upn_pcontainer2__call_search_objects_ex_sync() for the synchronous, blocking version of this method. + */ +void +upn_pcontainer2__call_search_objects_ex ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_dbus_proxy_call (G_DBUS_PROXY (proxy), + "SearchObjectsEx", + g_variant_new ("(suu^ass)", + arg_Query, + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + callback, + user_data); +} + +/** + * upn_pcontainer2__call_search_objects_ex_finish: + * @proxy: A #UPnPContainer2Proxy. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__call_search_objects_ex(). + * @error: Return location for error or %NULL. + * + * Finishes an operation started with upn_pcontainer2__call_search_objects_ex(). + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_search_objects_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__call_search_objects_ex_sync: + * @proxy: A #UPnPContainer2Proxy. + * @arg_Query: Argument to pass with the method invocation. + * @arg_Offset: Argument to pass with the method invocation. + * @arg_Max: Argument to pass with the method invocation. + * @arg_Filter: Argument to pass with the method invocation. + * @arg_SortBy: Argument to pass with the method invocation. + * @out_Children: (out): Return location for return parameter or %NULL to ignore. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL. + * + * Synchronously invokes the SearchObjectsEx() D-Bus method on @proxy. The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__call_search_objects_ex() for the asynchronous version of this method. + * + * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set. + */ +gboolean +upn_pcontainer2__call_search_objects_ex_sync ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error) +{ + GVariant *_ret; + _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy), + "SearchObjectsEx", + g_variant_new ("(suu^ass)", + arg_Query, + arg_Offset, + arg_Max, + arg_Filter, + arg_SortBy), + G_DBUS_CALL_FLAGS_NONE, + -1, + cancellable, + error); + if (_ret == NULL) + goto _out; + g_variant_get (_ret, + "(@aa{sv})", + out_Children); + g_variant_unref (_ret); +_out: + return _ret != NULL; +} + +/** + * upn_pcontainer2__complete_list_children: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListChildren() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_children ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_list_children_ex: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListChildrenEx() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_children_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_list_containers: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListContainers() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_containers ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_list_containers_ex: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListContainersEx() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_containers_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_list_items: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListItems() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_items ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_list_items_ex: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the ListItemsEx() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_list_items_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_search_objects: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the SearchObjects() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_search_objects ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/** + * upn_pcontainer2__complete_search_objects_ex: + * @object: A #UPnPContainer2. + * @invocation: (transfer full): A #GDBusMethodInvocation. + * @Children: Parameter to return. + * + * Helper function used in service implementations to finish handling invocations of the SearchObjectsEx() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar. + * + * This method will free @invocation, you cannot use it afterwards. + */ +void +upn_pcontainer2__complete_search_objects_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children) +{ + g_dbus_method_invocation_return_value (invocation, + g_variant_new ("(@aa{sv})", + Children)); +} + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPContainer2Proxy: + * + * The #UPnPContainer2Proxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPContainer2ProxyClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPContainer2Proxy. + */ + +struct _UPnPContainer2ProxyPrivate +{ + GData *qdata; +}; + +static void upn_pcontainer2__proxy_iface_init (UPnPContainer2Iface *iface); + +G_DEFINE_TYPE_WITH_CODE (UPnPContainer2Proxy, upn_pcontainer2__proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (UPN_PCONTAINER2_TYPE_, upn_pcontainer2__proxy_iface_init)); + +static void +upn_pcontainer2__proxy_finalize (GObject *object) +{ + UPnPContainer2Proxy *proxy = UPN_PCONTAINER2__PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (upn_pcontainer2__proxy_parent_class)->finalize (object); +} + +static void +upn_pcontainer2__proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 2); + info = _upn_pcontainer2__property_info_pointers[prop_id - 1]; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name); + if (info->use_gvariant) + { + g_value_set_variant (value, variant); + } + else + { + if (variant != NULL) + g_dbus_gvariant_to_gvalue (variant, value); + } + if (variant != NULL) + g_variant_unref (variant); +} + +static void +upn_pcontainer2__proxy_set_property_cb (GDBusProxy *proxy, + GAsyncResult *res, + gpointer user_data) +{ + const _ExtendedGDBusPropertyInfo *info = user_data; + GError *error; + error = NULL; + if (!g_dbus_proxy_call_finish (proxy, res, &error)) + { + g_warning ("Error setting property `%s' on interface org.gnome.UPnP.MediaContainer2: %s (%s, %d)", + info->parent_struct.name, + error->message, g_quark_to_string (error->domain), error->code); + g_error_free (error); + } +} + +static void +upn_pcontainer2__proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 2); + info = _upn_pcontainer2__property_info_pointers[prop_id - 1]; + variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_dbus_proxy_call (G_DBUS_PROXY (object), + "org.freedesktop.DBus.Properties.Set", + g_variant_new ("(ssv)", "org.gnome.UPnP.MediaContainer2", info->parent_struct.name, variant), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, (GAsyncReadyCallback) upn_pcontainer2__proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct); + g_variant_unref (variant); +} + +static void +upn_pcontainer2__proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], UPN_PCONTAINER2_TYPE_); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PCONTAINER2_TYPE_); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +upn_pcontainer2__proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + UPnPContainer2Proxy *proxy = UPN_PCONTAINER2__PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static guint +upn_pcontainer2__proxy_get_child_count (UPnPContainer2 *object) +{ + UPnPContainer2Proxy *proxy = UPN_PCONTAINER2__PROXY (object); + GVariant *variant; + guint value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ChildCount"); + if (variant != NULL) + { + value = g_variant_get_uint32 (variant); + g_variant_unref (variant); + } + return value; +} + +static gboolean +upn_pcontainer2__proxy_get_searchable (UPnPContainer2 *object) +{ + UPnPContainer2Proxy *proxy = UPN_PCONTAINER2__PROXY (object); + GVariant *variant; + gboolean value = 0; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Searchable"); + if (variant != NULL) + { + value = g_variant_get_boolean (variant); + g_variant_unref (variant); + } + return value; +} + +static void +upn_pcontainer2__proxy_init (UPnPContainer2Proxy *proxy) +{ + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UPN_PCONTAINER2_TYPE__PROXY, UPnPContainer2ProxyPrivate); + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), upn_pcontainer2__interface_info ()); +} + +static void +upn_pcontainer2__proxy_class_init (UPnPContainer2ProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + g_type_class_add_private (klass, sizeof (UPnPContainer2ProxyPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pcontainer2__proxy_finalize; + gobject_class->get_property = upn_pcontainer2__proxy_get_property; + gobject_class->set_property = upn_pcontainer2__proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = upn_pcontainer2__proxy_g_signal; + proxy_class->g_properties_changed = upn_pcontainer2__proxy_g_properties_changed; + + + upn_pcontainer2__override_properties (gobject_class, 1); +} + +static void +upn_pcontainer2__proxy_iface_init (UPnPContainer2Iface *iface) +{ + iface->get_child_count = upn_pcontainer2__proxy_get_child_count; + iface->get_searchable = upn_pcontainer2__proxy_get_searchable; +} + +/** + * upn_pcontainer2__proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.gnome.UPnP.MediaContainer2. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__proxy_new_finish() to get the result of the operation. + * + * See upn_pcontainer2__proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pcontainer2__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PCONTAINER2_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaContainer2", NULL); +} + +/** + * upn_pcontainer2__proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pcontainer2__proxy_new(). + * + * Returns: (transfer full) (type UPnPContainer2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPContainer2 * +upn_pcontainer2__proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PCONTAINER2_ (ret); + else + return NULL; +} + +/** + * upn_pcontainer2__proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.gnome.UPnP.MediaContainer2. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPContainer2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPContainer2 * +upn_pcontainer2__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PCONTAINER2_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaContainer2", NULL); + if (ret != NULL) + return UPN_PCONTAINER2_ (ret); + else + return NULL; +} + + +/** + * upn_pcontainer2__proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like upn_pcontainer2__proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pcontainer2__proxy_new_for_bus_finish() to get the result of the operation. + * + * See upn_pcontainer2__proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pcontainer2__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_PCONTAINER2_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaContainer2", NULL); +} + +/** + * upn_pcontainer2__proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pcontainer2__proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pcontainer2__proxy_new_for_bus(). + * + * Returns: (transfer full) (type UPnPContainer2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPContainer2 * +upn_pcontainer2__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_PCONTAINER2_ (ret); + else + return NULL; +} + +/** + * upn_pcontainer2__proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like upn_pcontainer2__proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pcontainer2__proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPContainer2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPContainer2 * +upn_pcontainer2__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_PCONTAINER2_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaContainer2", NULL); + if (ret != NULL) + return UPN_PCONTAINER2_ (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPContainer2Skeleton: + * + * The #UPnPContainer2Skeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPContainer2SkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPContainer2Skeleton. + */ + +struct _UPnPContainer2SkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_upn_pcontainer2__skeleton_handle_method_call ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], UPN_PCONTAINER2_TYPE_); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_PCONTAINER2_TYPE_); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_upn_pcontainer2__skeleton_handle_get_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_upn_pcontainer2__skeleton_handle_set_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pcontainer2__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _upn_pcontainer2__skeleton_vtable = +{ + _upn_pcontainer2__skeleton_handle_method_call, + _upn_pcontainer2__skeleton_handle_get_property, + _upn_pcontainer2__skeleton_handle_set_property +}; + +static GDBusInterfaceInfo * +upn_pcontainer2__skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton) +{ + return upn_pcontainer2__interface_info (); +} + +static GDBusInterfaceVTable * +upn_pcontainer2__skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton) +{ + return (GDBusInterfaceVTable *) &_upn_pcontainer2__skeleton_vtable; +} + +static GVariant * +upn_pcontainer2__skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_upn_pcontainer2__interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _upn_pcontainer2__interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _upn_pcontainer2__interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _upn_pcontainer2__skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.gnome.UPnP.MediaContainer2", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static gboolean _upn_pcontainer2__emit_changed (gpointer user_data); + +static void +upn_pcontainer2__skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (_skeleton); + gboolean emit_changed = FALSE; + + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties_idle_source != NULL) + { + g_source_destroy (skeleton->priv->changed_properties_idle_source); + skeleton->priv->changed_properties_idle_source = NULL; + emit_changed = TRUE; + } + g_mutex_unlock (&skeleton->priv->lock); + + if (emit_changed) + _upn_pcontainer2__emit_changed (skeleton); +} + +static void upn_pcontainer2__skeleton_iface_init (UPnPContainer2Iface *iface); +G_DEFINE_TYPE_WITH_CODE (UPnPContainer2Skeleton, upn_pcontainer2__skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (UPN_PCONTAINER2_TYPE_, upn_pcontainer2__skeleton_iface_init)); + +static void +upn_pcontainer2__skeleton_finalize (GObject *object) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + guint n; + for (n = 0; n < 2; n++) + g_value_unset (&skeleton->priv->properties[n]); + g_free (skeleton->priv->properties); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (upn_pcontainer2__skeleton_parent_class)->finalize (object); +} + +static void +upn_pcontainer2__skeleton_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 2); + g_mutex_lock (&skeleton->priv->lock); + g_value_copy (&skeleton->priv->properties[prop_id - 1], value); + g_mutex_unlock (&skeleton->priv->lock); +} + +static gboolean +_upn_pcontainer2__emit_changed (gpointer user_data) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (user_data); + GList *l; + GVariantBuilder builder; + GVariantBuilder invalidated_builder; + guint num_changes; + + g_mutex_lock (&skeleton->priv->lock); + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as")); + for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next) + { + ChangedProperty *cp = l->data; + GVariant *variant; + const GValue *cur_value; + + cur_value = &skeleton->priv->properties[cp->prop_id - 1]; + if (!_g_value_equal (cur_value, &cp->orig_value)) + { + variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature)); + g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant); + g_variant_unref (variant); + num_changes++; + } + } + if (num_changes > 0) + { + GList *connections, *ll; + GVariant *signal_variant; + signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.gnome.UPnP.MediaContainer2", + &builder, &invalidated_builder)); + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + for (ll = connections; ll != NULL; ll = ll->next) + { + GDBusConnection *connection = ll->data; + + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), + "org.freedesktop.DBus.Properties", + "PropertiesChanged", + signal_variant, + NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); + } + else + { + g_variant_builder_clear (&builder); + g_variant_builder_clear (&invalidated_builder); + } + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + skeleton->priv->changed_properties = NULL; + skeleton->priv->changed_properties_idle_source = NULL; + g_mutex_unlock (&skeleton->priv->lock); + return FALSE; +} + +static void +_upn_pcontainer2__schedule_emit_changed (UPnPContainer2Skeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value) +{ + ChangedProperty *cp; + GList *l; + cp = NULL; + for (l = skeleton->priv->changed_properties; l != NULL; l = l->next) + { + ChangedProperty *i_cp = l->data; + if (i_cp->info == info) + { + cp = i_cp; + break; + } + } + if (cp == NULL) + { + cp = g_new0 (ChangedProperty, 1); + cp->prop_id = prop_id; + cp->info = info; + skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp); + g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value)); + g_value_copy (orig_value, &cp->orig_value); + } +} + +static void +upn_pcontainer2__skeleton_notify (GObject *object, + GParamSpec *pspec) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties != NULL && + skeleton->priv->changed_properties_idle_source == NULL) + { + skeleton->priv->changed_properties_idle_source = g_idle_source_new (); + g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT); + g_source_set_callback (skeleton->priv->changed_properties_idle_source, _upn_pcontainer2__emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref); + g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context); + g_source_unref (skeleton->priv->changed_properties_idle_source); + } + g_mutex_unlock (&skeleton->priv->lock); +} + +static void +upn_pcontainer2__skeleton_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 2); + g_mutex_lock (&skeleton->priv->lock); + g_object_freeze_notify (object); + if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1])) + { + if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL) + _upn_pcontainer2__schedule_emit_changed (skeleton, _upn_pcontainer2__property_info_pointers[prop_id - 1], prop_id, &skeleton->priv->properties[prop_id - 1]); + g_value_copy (value, &skeleton->priv->properties[prop_id - 1]); + g_object_notify_by_pspec (object, pspec); + } + g_mutex_unlock (&skeleton->priv->lock); + g_object_thaw_notify (object); +} + +static void +upn_pcontainer2__skeleton_init (UPnPContainer2Skeleton *skeleton) +{ + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UPN_PCONTAINER2_TYPE__SKELETON, UPnPContainer2SkeletonPrivate); + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); + skeleton->priv->properties = g_new0 (GValue, 2); + g_value_init (&skeleton->priv->properties[0], G_TYPE_UINT); + g_value_init (&skeleton->priv->properties[1], G_TYPE_BOOLEAN); +} + +static guint +upn_pcontainer2__skeleton_get_child_count (UPnPContainer2 *object) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + guint value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_uint (&(skeleton->priv->properties[0])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static gboolean +upn_pcontainer2__skeleton_get_searchable (UPnPContainer2 *object) +{ + UPnPContainer2Skeleton *skeleton = UPN_PCONTAINER2__SKELETON (object); + gboolean value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_boolean (&(skeleton->priv->properties[1])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static void +upn_pcontainer2__skeleton_class_init (UPnPContainer2SkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + g_type_class_add_private (klass, sizeof (UPnPContainer2SkeletonPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pcontainer2__skeleton_finalize; + gobject_class->get_property = upn_pcontainer2__skeleton_get_property; + gobject_class->set_property = upn_pcontainer2__skeleton_set_property; + gobject_class->notify = upn_pcontainer2__skeleton_notify; + + + upn_pcontainer2__override_properties (gobject_class, 1); + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = upn_pcontainer2__skeleton_dbus_interface_get_info; + skeleton_class->get_properties = upn_pcontainer2__skeleton_dbus_interface_get_properties; + skeleton_class->flush = upn_pcontainer2__skeleton_dbus_interface_flush; + skeleton_class->get_vtable = upn_pcontainer2__skeleton_dbus_interface_get_vtable; +} + +static void +upn_pcontainer2__skeleton_iface_init (UPnPContainer2Iface *iface) +{ + iface->get_child_count = upn_pcontainer2__skeleton_get_child_count; + iface->get_searchable = upn_pcontainer2__skeleton_get_searchable; +} + +/** + * upn_pcontainer2__skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.gnome.UPnP.MediaContainer2. + * + * Returns: (transfer full) (type UPnPContainer2Skeleton): The skeleton object. + */ +UPnPContainer2 * +upn_pcontainer2__skeleton_new (void) +{ + return UPN_PCONTAINER2_ (g_object_new (UPN_PCONTAINER2_TYPE__SKELETON, NULL)); +} + diff --git a/src/MediaServer/upnp-mediacontainer2-proxy.h b/src/MediaServer/upnp-mediacontainer2-proxy.h new file mode 100644 index 0000000..68c6046 --- /dev/null +++ b/src/MediaServer/upnp-mediacontainer2-proxy.h @@ -0,0 +1,462 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __UPNP_MEDIACONTAINER2_PROXY_H__ +#define __UPNP_MEDIACONTAINER2_PROXY_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.gnome.UPnP.MediaContainer2 */ + +#define UPN_PCONTAINER2_TYPE_ (upn_pcontainer2__get_type ()) +#define UPN_PCONTAINER2_(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PCONTAINER2_TYPE_, UPnPContainer2)) +#define UPN_PCONTAINER2_IS_(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PCONTAINER2_TYPE_)) +#define UPN_PCONTAINER2__GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UPN_PCONTAINER2_TYPE_, UPnPContainer2Iface)) + +struct _UPnPContainer2; +typedef struct _UPnPContainer2 UPnPContainer2; +typedef struct _UPnPContainer2Iface UPnPContainer2Iface; + +struct _UPnPContainer2Iface +{ + GTypeInterface parent_iface; + + + gboolean (*handle_list_children) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter); + + gboolean (*handle_list_children_ex) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy); + + gboolean (*handle_list_containers) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter); + + gboolean (*handle_list_containers_ex) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy); + + gboolean (*handle_list_items) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter); + + gboolean (*handle_list_items_ex) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy); + + gboolean (*handle_search_objects) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter); + + gboolean (*handle_search_objects_ex) ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy); + + guint (*get_child_count) (UPnPContainer2 *object); + + gboolean (*get_searchable) (UPnPContainer2 *object); + +}; + +GType upn_pcontainer2__get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *upn_pcontainer2__interface_info (void); +guint upn_pcontainer2__override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus method call completion functions: */ +void upn_pcontainer2__complete_list_children ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_list_children_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_list_containers ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_list_containers_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_list_items ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_list_items_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_search_objects ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + +void upn_pcontainer2__complete_search_objects_ex ( + UPnPContainer2 *object, + GDBusMethodInvocation *invocation, + GVariant *Children); + + + +/* D-Bus method calls: */ +void upn_pcontainer2__call_list_children ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_children_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_children_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_list_children_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_children_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_children_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_list_containers ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_containers_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_containers_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_list_containers_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_containers_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_containers_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_list_items ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_items_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_items_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_list_items_ex ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_list_items_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_list_items_ex_sync ( + UPnPContainer2 *proxy, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_search_objects ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_search_objects_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_search_objects_sync ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__call_search_objects_ex ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gboolean upn_pcontainer2__call_search_objects_ex_finish ( + UPnPContainer2 *proxy, + GVariant **out_Children, + GAsyncResult *res, + GError **error); + +gboolean upn_pcontainer2__call_search_objects_ex_sync ( + UPnPContainer2 *proxy, + const gchar *arg_Query, + guint arg_Offset, + guint arg_Max, + const gchar *const *arg_Filter, + const gchar *arg_SortBy, + GVariant **out_Children, + GCancellable *cancellable, + GError **error); + + + +/* D-Bus property accessors: */ +guint upn_pcontainer2__get_child_count (UPnPContainer2 *object); +void upn_pcontainer2__set_child_count (UPnPContainer2 *object, guint value); + +gboolean upn_pcontainer2__get_searchable (UPnPContainer2 *object); +void upn_pcontainer2__set_searchable (UPnPContainer2 *object, gboolean value); + + +/* ---- */ + +#define UPN_PCONTAINER2_TYPE__PROXY (upn_pcontainer2__proxy_get_type ()) +#define UPN_PCONTAINER2__PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PCONTAINER2_TYPE__PROXY, UPnPContainer2Proxy)) +#define UPN_PCONTAINER2__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PCONTAINER2_TYPE__PROXY, UPnPContainer2ProxyClass)) +#define UPN_PCONTAINER2__PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PCONTAINER2_TYPE__PROXY, UPnPContainer2ProxyClass)) +#define UPN_PCONTAINER2_IS__PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PCONTAINER2_TYPE__PROXY)) +#define UPN_PCONTAINER2_IS__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PCONTAINER2_TYPE__PROXY)) + +typedef struct _UPnPContainer2Proxy UPnPContainer2Proxy; +typedef struct _UPnPContainer2ProxyClass UPnPContainer2ProxyClass; +typedef struct _UPnPContainer2ProxyPrivate UPnPContainer2ProxyPrivate; + +struct _UPnPContainer2Proxy +{ + /*< private >*/ + GDBusProxy parent_instance; + UPnPContainer2ProxyPrivate *priv; +}; + +struct _UPnPContainer2ProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType upn_pcontainer2__proxy_get_type (void) G_GNUC_CONST; + +void upn_pcontainer2__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPContainer2 *upn_pcontainer2__proxy_new_finish ( + GAsyncResult *res, + GError **error); +UPnPContainer2 *upn_pcontainer2__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void upn_pcontainer2__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPContainer2 *upn_pcontainer2__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +UPnPContainer2 *upn_pcontainer2__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define UPN_PCONTAINER2_TYPE__SKELETON (upn_pcontainer2__skeleton_get_type ()) +#define UPN_PCONTAINER2__SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_PCONTAINER2_TYPE__SKELETON, UPnPContainer2Skeleton)) +#define UPN_PCONTAINER2__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_PCONTAINER2_TYPE__SKELETON, UPnPContainer2SkeletonClass)) +#define UPN_PCONTAINER2__SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_PCONTAINER2_TYPE__SKELETON, UPnPContainer2SkeletonClass)) +#define UPN_PCONTAINER2_IS__SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_PCONTAINER2_TYPE__SKELETON)) +#define UPN_PCONTAINER2_IS__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_PCONTAINER2_TYPE__SKELETON)) + +typedef struct _UPnPContainer2Skeleton UPnPContainer2Skeleton; +typedef struct _UPnPContainer2SkeletonClass UPnPContainer2SkeletonClass; +typedef struct _UPnPContainer2SkeletonPrivate UPnPContainer2SkeletonPrivate; + +struct _UPnPContainer2Skeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + UPnPContainer2SkeletonPrivate *priv; +}; + +struct _UPnPContainer2SkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType upn_pcontainer2__skeleton_get_type (void) G_GNUC_CONST; + +UPnPContainer2 *upn_pcontainer2__skeleton_new (void); + + +G_END_DECLS + +#endif /* __UPNP_MEDIACONTAINER2_PROXY_H__ */ diff --git a/src/MediaServer/upnp-mediaobject2-proxy.c b/src/MediaServer/upnp-mediaobject2-proxy.c new file mode 100644 index 0000000..3356b08 --- /dev/null +++ b/src/MediaServer/upnp-mediaobject2-proxy.c @@ -0,0 +1,1475 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "upnp-mediaobject2-proxy.h" + +#include + +#ifdef G_OS_UNIX +#undef G_OS_UNIX +#endif + +#ifdef G_OS_UNIX +# include +#endif + +typedef struct +{ + GDBusArgInfo parent_struct; + gboolean use_gvariant; +} _ExtendedGDBusArgInfo; + +typedef struct +{ + GDBusMethodInfo parent_struct; + const gchar *signal_name; + gboolean pass_fdlist; +} _ExtendedGDBusMethodInfo; + +typedef struct +{ + GDBusSignalInfo parent_struct; + const gchar *signal_name; +} _ExtendedGDBusSignalInfo; + +typedef struct +{ + GDBusPropertyInfo parent_struct; + const gchar *hyphen_name; + gboolean use_gvariant; +} _ExtendedGDBusPropertyInfo; + +typedef struct +{ + GDBusInterfaceInfo parent_struct; + const gchar *hyphen_name; +} _ExtendedGDBusInterfaceInfo; + +typedef struct +{ + const _ExtendedGDBusPropertyInfo *info; + guint prop_id; + GValue orig_value; /* the value before the change */ +} ChangedProperty; + +static void +_changed_property_free (ChangedProperty *data) +{ + g_value_unset (&data->orig_value); + g_free (data); +} + +static gboolean +_g_strv_equal0 (gchar **a, gchar **b) +{ + gboolean ret = FALSE; + guint n; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + if (g_strv_length (a) != g_strv_length (b)) + goto out; + for (n = 0; a[n] != NULL; n++) + if (g_strcmp0 (a[n], b[n]) != 0) + goto out; + ret = TRUE; +out: + return ret; +} + +static gboolean +_g_variant_equal0 (GVariant *a, GVariant *b) +{ + gboolean ret = FALSE; + if (a == NULL && b == NULL) + { + ret = TRUE; + goto out; + } + if (a == NULL || b == NULL) + goto out; + ret = g_variant_equal (a, b); +out: + return ret; +} + +G_GNUC_UNUSED static gboolean +_g_value_equal (const GValue *a, const GValue *b) +{ + gboolean ret = FALSE; + g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b)); + switch (G_VALUE_TYPE (a)) + { + case G_TYPE_BOOLEAN: + ret = (g_value_get_boolean (a) == g_value_get_boolean (b)); + break; + case G_TYPE_UCHAR: + ret = (g_value_get_uchar (a) == g_value_get_uchar (b)); + break; + case G_TYPE_INT: + ret = (g_value_get_int (a) == g_value_get_int (b)); + break; + case G_TYPE_UINT: + ret = (g_value_get_uint (a) == g_value_get_uint (b)); + break; + case G_TYPE_INT64: + ret = (g_value_get_int64 (a) == g_value_get_int64 (b)); + break; + case G_TYPE_UINT64: + ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b)); + break; + case G_TYPE_DOUBLE: + { + /* Avoid -Wfloat-equal warnings by doing a direct bit compare */ + gdouble da = g_value_get_double (a); + gdouble db = g_value_get_double (b); + ret = memcmp (&da, &db, sizeof (gdouble)) == 0; + } + break; + case G_TYPE_STRING: + ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0); + break; + case G_TYPE_VARIANT: + ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b)); + break; + default: + if (G_VALUE_TYPE (a) == G_TYPE_STRV) + ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b)); + else + g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a))); + break; + } + return ret; +} + +/* ------------------------------------------------------------------------ + * Code for interface org.gnome.UPnP.MediaObject2 + * ------------------------------------------------------------------------ + */ + +/** + * SECTION:UPnPObject2 + * @title: UPnPObject2 + * @short_description: Generated C code for the org.gnome.UPnP.MediaObject2 D-Bus interface + * + * This section contains code for working with the org.gnome.UPnP.MediaObject2 D-Bus interface in C. + */ + +/* ---- Introspection data for org.gnome.UPnP.MediaObject2 ---- */ + +static const _ExtendedGDBusPropertyInfo _upn_pobject2__property_info_parent = +{ + { + -1, + (gchar *) "Parent", + (gchar *) "o", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "parent", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pobject2__property_info_type_ = +{ + { + -1, + (gchar *) "Type", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "type", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pobject2__property_info_path = +{ + { + -1, + (gchar *) "Path", + (gchar *) "o", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "path", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo _upn_pobject2__property_info_display_name = +{ + { + -1, + (gchar *) "DisplayName", + (gchar *) "s", + G_DBUS_PROPERTY_INFO_FLAGS_READABLE, + NULL + }, + "display-name", + FALSE +}; + +static const _ExtendedGDBusPropertyInfo * const _upn_pobject2__property_info_pointers[] = +{ + &_upn_pobject2__property_info_parent, + &_upn_pobject2__property_info_type_, + &_upn_pobject2__property_info_path, + &_upn_pobject2__property_info_display_name, + NULL +}; + +static const _ExtendedGDBusInterfaceInfo _upn_pobject2__interface_info = +{ + { + -1, + (gchar *) "org.gnome.UPnP.MediaObject2", + NULL, + NULL, + (GDBusPropertyInfo **) &_upn_pobject2__property_info_pointers, + NULL + }, + "", +}; + + +/** + * upn_pobject2__interface_info: + * + * Gets a machine-readable description of the org.gnome.UPnP.MediaObject2 D-Bus interface. + * + * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free. + */ +GDBusInterfaceInfo * +upn_pobject2__interface_info (void) +{ + return (GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct; +} + +/** + * upn_pobject2__override_properties: + * @klass: The class structure for a #GObject-derived class. + * @property_id_begin: The property id to assign to the first overridden property. + * + * Overrides all #GObject properties in the #UPnPObject2 interface for a concrete class. + * The properties are overridden in the order they are defined. + * + * Returns: The last property id. + */ +guint +upn_pobject2__override_properties (GObjectClass *klass, guint property_id_begin) +{ + g_object_class_override_property (klass, property_id_begin++, "parent"); + g_object_class_override_property (klass, property_id_begin++, "type"); + g_object_class_override_property (klass, property_id_begin++, "path"); + g_object_class_override_property (klass, property_id_begin++, "display-name"); + return property_id_begin - 1; +} + + + +/** + * UPnPObject2: + * + * Abstract interface type for the D-Bus interface org.gnome.UPnP.MediaObject2. + */ + +/** + * UPnPObject2Iface: + * @parent_iface: The parent interface. + * @get_display_name: Getter for the #UPnPObject2:display-name property. + * @get_parent: Getter for the #UPnPObject2:parent property. + * @get_path: Getter for the #UPnPObject2:path property. + * @get_type_: Getter for the #UPnPObject2:type property. + * + * Virtual table for the D-Bus interface org.gnome.UPnP.MediaObject2. + */ + +static void +upn_pobject2__default_init (UPnPObject2Iface *iface) +{ + /* GObject properties for D-Bus properties: */ + /** + * UPnPObject2:parent: + * + * Represents the D-Bus property "Parent". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("parent", "Parent", "Parent", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPObject2:type: + * + * Represents the D-Bus property "Type". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("type", "Type", "Type", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPObject2:path: + * + * Represents the D-Bus property "Path". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("path", "Path", "Path", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + /** + * UPnPObject2:display-name: + * + * Represents the D-Bus property "DisplayName". + * + * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side. + */ + g_object_interface_install_property (iface, + g_param_spec_string ("display-name", "DisplayName", "DisplayName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +typedef UPnPObject2Iface UPnPObject2Interface; +G_DEFINE_INTERFACE (UPnPObject2, upn_pobject2_, G_TYPE_OBJECT); + +/** + * upn_pobject2__get_parent: (skip) + * @object: A #UPnPObject2. + * + * Gets the value of the "Parent" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pobject2__dup_parent() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pobject2__get_parent (UPnPObject2 *object) +{ + return UPN_POBJECT2__GET_IFACE (object)->get_parent (object); +} + +/** + * upn_pobject2__dup_parent: (skip) + * @object: A #UPnPObject2. + * + * Gets a copy of the "Parent" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pobject2__dup_parent (UPnPObject2 *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "parent", &value, NULL); + return value; +} + +/** + * upn_pobject2__set_parent: (skip) + * @object: A #UPnPObject2. + * @value: The value to set. + * + * Sets the "Parent" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pobject2__set_parent (UPnPObject2 *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "parent", value, NULL); +} + +/** + * upn_pobject2__get_type_: (skip) + * @object: A #UPnPObject2. + * + * Gets the value of the "Type" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pobject2__dup_type_() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pobject2__get_type_ (UPnPObject2 *object) +{ + return UPN_POBJECT2__GET_IFACE (object)->get_type_ (object); +} + +/** + * upn_pobject2__dup_type_: (skip) + * @object: A #UPnPObject2. + * + * Gets a copy of the "Type" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pobject2__dup_type_ (UPnPObject2 *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "type", &value, NULL); + return value; +} + +/** + * upn_pobject2__set_type_: (skip) + * @object: A #UPnPObject2. + * @value: The value to set. + * + * Sets the "Type" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pobject2__set_type_ (UPnPObject2 *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "type", value, NULL); +} + +/** + * upn_pobject2__get_path: (skip) + * @object: A #UPnPObject2. + * + * Gets the value of the "Path" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pobject2__dup_path() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pobject2__get_path (UPnPObject2 *object) +{ + return UPN_POBJECT2__GET_IFACE (object)->get_path (object); +} + +/** + * upn_pobject2__dup_path: (skip) + * @object: A #UPnPObject2. + * + * Gets a copy of the "Path" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pobject2__dup_path (UPnPObject2 *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "path", &value, NULL); + return value; +} + +/** + * upn_pobject2__set_path: (skip) + * @object: A #UPnPObject2. + * @value: The value to set. + * + * Sets the "Path" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pobject2__set_path (UPnPObject2 *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "path", value, NULL); +} + +/** + * upn_pobject2__get_display_name: (skip) + * @object: A #UPnPObject2. + * + * Gets the value of the "DisplayName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use upn_pobject2__dup_display_name() if on another thread. + * + * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object. + */ +const gchar * +upn_pobject2__get_display_name (UPnPObject2 *object) +{ + return UPN_POBJECT2__GET_IFACE (object)->get_display_name (object); +} + +/** + * upn_pobject2__dup_display_name: (skip) + * @object: A #UPnPObject2. + * + * Gets a copy of the "DisplayName" D-Bus property. + * + * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side. + * + * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free(). + */ +gchar * +upn_pobject2__dup_display_name (UPnPObject2 *object) +{ + gchar *value; + g_object_get (G_OBJECT (object), "display-name", &value, NULL); + return value; +} + +/** + * upn_pobject2__set_display_name: (skip) + * @object: A #UPnPObject2. + * @value: The value to set. + * + * Sets the "DisplayName" D-Bus property to @value. + * + * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side. + */ +void +upn_pobject2__set_display_name (UPnPObject2 *object, const gchar *value) +{ + g_object_set (G_OBJECT (object), "display-name", value, NULL); +} + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPObject2Proxy: + * + * The #UPnPObject2Proxy structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPObject2ProxyClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPObject2Proxy. + */ + +struct _UPnPObject2ProxyPrivate +{ + GData *qdata; +}; + +static void upn_pobject2__proxy_iface_init (UPnPObject2Iface *iface); + +G_DEFINE_TYPE_WITH_CODE (UPnPObject2Proxy, upn_pobject2__proxy, G_TYPE_DBUS_PROXY, + G_IMPLEMENT_INTERFACE (UPN_POBJECT2_TYPE_, upn_pobject2__proxy_iface_init)); + +static void +upn_pobject2__proxy_finalize (GObject *object) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (object); + g_datalist_clear (&proxy->priv->qdata); + G_OBJECT_CLASS (upn_pobject2__proxy_parent_class)->finalize (object); +} + +static void +upn_pobject2__proxy_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 4); + info = _upn_pobject2__property_info_pointers[prop_id - 1]; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name); + if (info->use_gvariant) + { + g_value_set_variant (value, variant); + } + else + { + if (variant != NULL) + g_dbus_gvariant_to_gvalue (variant, value); + } + if (variant != NULL) + g_variant_unref (variant); +} + +static void +upn_pobject2__proxy_set_property_cb (GDBusProxy *proxy, + GAsyncResult *res, + gpointer user_data) +{ + const _ExtendedGDBusPropertyInfo *info = user_data; + GError *error; + error = NULL; + if (!g_dbus_proxy_call_finish (proxy, res, &error)) + { + g_warning ("Error setting property `%s' on interface org.gnome.UPnP.MediaObject2: %s (%s, %d)", + info->parent_struct.name, + error->message, g_quark_to_string (error->domain), error->code); + g_error_free (error); + } +} + +static void +upn_pobject2__proxy_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + const _ExtendedGDBusPropertyInfo *info; + GVariant *variant; + g_assert (prop_id != 0 && prop_id - 1 < 4); + info = _upn_pobject2__property_info_pointers[prop_id - 1]; + variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_dbus_proxy_call (G_DBUS_PROXY (object), + "org.freedesktop.DBus.Properties.Set", + g_variant_new ("(ssv)", "org.gnome.UPnP.MediaObject2", info->parent_struct.name, variant), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, (GAsyncReadyCallback) upn_pobject2__proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct); + g_variant_unref (variant); +} + +static void +upn_pobject2__proxy_g_signal (GDBusProxy *proxy, + const gchar *sender_name, + const gchar *signal_name, + GVariant *parameters) +{ + _ExtendedGDBusSignalInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint n; + guint signal_id; + info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct, signal_name); + if (info == NULL) + return; + num_params = g_variant_n_children (parameters); + paramv = g_new0 (GValue, num_params + 1); + g_value_init (¶mv[0], UPN_POBJECT2_TYPE_); + g_value_set_object (¶mv[0], proxy); + g_variant_iter_init (&iter, parameters); + n = 1; + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_POBJECT2_TYPE_); + g_signal_emitv (paramv, signal_id, 0, NULL); + for (n = 0; n < num_params + 1; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static void +upn_pobject2__proxy_g_properties_changed (GDBusProxy *_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (_proxy); + guint n; + const gchar *key; + GVariantIter *iter; + _ExtendedGDBusPropertyInfo *info; + g_variant_get (changed_properties, "a{sv}", &iter); + while (g_variant_iter_next (iter, "{&sv}", &key, NULL)) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct, key); + g_datalist_remove_data (&proxy->priv->qdata, key); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } + g_variant_iter_free (iter); + for (n = 0; invalidated_properties[n] != NULL; n++) + { + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct, invalidated_properties[n]); + g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]); + if (info != NULL) + g_object_notify (G_OBJECT (proxy), info->hyphen_name); + } +} + +static const gchar * +upn_pobject2__proxy_get_parent (UPnPObject2 *object) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Parent"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pobject2__proxy_get_type_ (UPnPObject2 *object) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Type"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pobject2__proxy_get_path (UPnPObject2 *object) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Path"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static const gchar * +upn_pobject2__proxy_get_display_name (UPnPObject2 *object) +{ + UPnPObject2Proxy *proxy = UPN_POBJECT2__PROXY (object); + GVariant *variant; + const gchar *value = NULL; + variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DisplayName"); + if (variant != NULL) + { + value = g_variant_get_string (variant, NULL); + g_variant_unref (variant); + } + return value; +} + +static void +upn_pobject2__proxy_init (UPnPObject2Proxy *proxy) +{ + proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UPN_POBJECT2_TYPE__PROXY, UPnPObject2ProxyPrivate); + g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), upn_pobject2__interface_info ()); +} + +static void +upn_pobject2__proxy_class_init (UPnPObject2ProxyClass *klass) +{ + GObjectClass *gobject_class; + GDBusProxyClass *proxy_class; + + g_type_class_add_private (klass, sizeof (UPnPObject2ProxyPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pobject2__proxy_finalize; + gobject_class->get_property = upn_pobject2__proxy_get_property; + gobject_class->set_property = upn_pobject2__proxy_set_property; + + proxy_class = G_DBUS_PROXY_CLASS (klass); + proxy_class->g_signal = upn_pobject2__proxy_g_signal; + proxy_class->g_properties_changed = upn_pobject2__proxy_g_properties_changed; + + + upn_pobject2__override_properties (gobject_class, 1); +} + +static void +upn_pobject2__proxy_iface_init (UPnPObject2Iface *iface) +{ + iface->get_parent = upn_pobject2__proxy_get_parent; + iface->get_type_ = upn_pobject2__proxy_get_type_; + iface->get_path = upn_pobject2__proxy_get_path; + iface->get_display_name = upn_pobject2__proxy_get_display_name; +} + +/** + * upn_pobject2__proxy_new: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Asynchronously creates a proxy for the D-Bus interface org.gnome.UPnP.MediaObject2. See g_dbus_proxy_new() for more details. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pobject2__proxy_new_finish() to get the result of the operation. + * + * See upn_pobject2__proxy_new_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pobject2__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_POBJECT2_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaObject2", NULL); +} + +/** + * upn_pobject2__proxy_new_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pobject2__proxy_new(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pobject2__proxy_new(). + * + * Returns: (transfer full) (type UPnPObject2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPObject2 * +upn_pobject2__proxy_new_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_POBJECT2_ (ret); + else + return NULL; +} + +/** + * upn_pobject2__proxy_new_sync: + * @connection: A #GDBusConnection. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection. + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Synchronously creates a proxy for the D-Bus interface org.gnome.UPnP.MediaObject2. See g_dbus_proxy_new_sync() for more details. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pobject2__proxy_new() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPObject2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPObject2 * +upn_pobject2__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_POBJECT2_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaObject2", NULL); + if (ret != NULL) + return UPN_POBJECT2_ (ret); + else + return NULL; +} + + +/** + * upn_pobject2__proxy_new_for_bus: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @callback: A #GAsyncReadyCallback to call when the request is satisfied. + * @user_data: User data to pass to @callback. + * + * Like upn_pobject2__proxy_new() but takes a #GBusType instead of a #GDBusConnection. + * + * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from. + * You can then call upn_pobject2__proxy_new_for_bus_finish() to get the result of the operation. + * + * See upn_pobject2__proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor. + */ +void +upn_pobject2__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_async_initable_new_async (UPN_POBJECT2_TYPE__PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaObject2", NULL); +} + +/** + * upn_pobject2__proxy_new_for_bus_finish: + * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to upn_pobject2__proxy_new_for_bus(). + * @error: Return location for error or %NULL + * + * Finishes an operation started with upn_pobject2__proxy_new_for_bus(). + * + * Returns: (transfer full) (type UPnPObject2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPObject2 * +upn_pobject2__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error) +{ + GObject *ret; + GObject *source_object; + source_object = g_async_result_get_source_object (res); + ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error); + g_object_unref (source_object); + if (ret != NULL) + return UPN_POBJECT2_ (ret); + else + return NULL; +} + +/** + * upn_pobject2__proxy_new_for_bus_sync: + * @bus_type: A #GBusType. + * @flags: Flags from the #GDBusProxyFlags enumeration. + * @name: A bus name (well-known or unique). + * @object_path: An object path. + * @cancellable: (allow-none): A #GCancellable or %NULL. + * @error: Return location for error or %NULL + * + * Like upn_pobject2__proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection. + * + * The calling thread is blocked until a reply is received. + * + * See upn_pobject2__proxy_new_for_bus() for the asynchronous version of this constructor. + * + * Returns: (transfer full) (type UPnPObject2Proxy): The constructed proxy object or %NULL if @error is set. + */ +UPnPObject2 * +upn_pobject2__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error) +{ + GInitable *ret; + ret = g_initable_new (UPN_POBJECT2_TYPE__PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.gnome.UPnP.MediaObject2", NULL); + if (ret != NULL) + return UPN_POBJECT2_ (ret); + else + return NULL; +} + + +/* ------------------------------------------------------------------------ */ + +/** + * UPnPObject2Skeleton: + * + * The #UPnPObject2Skeleton structure contains only private data and should only be accessed using the provided API. + */ + +/** + * UPnPObject2SkeletonClass: + * @parent_class: The parent class. + * + * Class structure for #UPnPObject2Skeleton. + */ + +struct _UPnPObject2SkeletonPrivate +{ + GValue *properties; + GList *changed_properties; + GSource *changed_properties_idle_source; + GMainContext *context; + GMutex lock; +}; + +static void +_upn_pobject2__skeleton_handle_method_call ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *method_name, + GVariant *parameters, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (user_data); + _ExtendedGDBusMethodInfo *info; + GVariantIter iter; + GVariant *child; + GValue *paramv; + guint num_params; + guint num_extra; + guint n; + guint signal_id; + GValue return_value = G_VALUE_INIT; + info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation); + g_assert (info != NULL); + num_params = g_variant_n_children (parameters); + num_extra = info->pass_fdlist ? 3 : 2; paramv = g_new0 (GValue, num_params + num_extra); + n = 0; + g_value_init (¶mv[n], UPN_POBJECT2_TYPE_); + g_value_set_object (¶mv[n++], skeleton); + g_value_init (¶mv[n], G_TYPE_DBUS_METHOD_INVOCATION); + g_value_set_object (¶mv[n++], invocation); + if (info->pass_fdlist) + { +#ifdef G_OS_UNIX + g_value_init (¶mv[n], G_TYPE_UNIX_FD_LIST); + g_value_set_object (¶mv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation))); +#else + g_assert_not_reached (); +#endif + } + g_variant_iter_init (&iter, parameters); + while ((child = g_variant_iter_next_value (&iter)) != NULL) + { + _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra]; + if (arg_info->use_gvariant) + { + g_value_init (¶mv[n], G_TYPE_VARIANT); + g_value_set_variant (¶mv[n], child); + n++; + } + else + g_dbus_gvariant_to_gvalue (child, ¶mv[n++]); + g_variant_unref (child); + } + signal_id = g_signal_lookup (info->signal_name, UPN_POBJECT2_TYPE_); + g_value_init (&return_value, G_TYPE_BOOLEAN); + g_signal_emitv (paramv, signal_id, 0, &return_value); + if (!g_value_get_boolean (&return_value)) + g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name); + g_value_unset (&return_value); + for (n = 0; n < num_params + num_extra; n++) + g_value_unset (¶mv[n]); + g_free (paramv); +} + +static GVariant * +_upn_pobject2__skeleton_handle_get_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GError **error, + gpointer user_data) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + GVariant *ret; + ret = NULL; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + g_value_init (&value, pspec->value_type); + g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value); + ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature)); + g_value_unset (&value); + } + return ret; +} + +static gboolean +_upn_pobject2__skeleton_handle_set_property ( + GDBusConnection *connection, + const gchar *sender, + const gchar *object_path, + const gchar *interface_name, + const gchar *property_name, + GVariant *variant, + GError **error, + gpointer user_data) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (user_data); + GValue value = G_VALUE_INIT; + GParamSpec *pspec; + _ExtendedGDBusPropertyInfo *info; + gboolean ret; + ret = FALSE; + info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_upn_pobject2__interface_info.parent_struct, property_name); + g_assert (info != NULL); + pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name); + if (pspec == NULL) + { + g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name); + } + else + { + if (info->use_gvariant) + g_value_set_variant (&value, variant); + else + g_dbus_gvariant_to_gvalue (variant, &value); + g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value); + g_value_unset (&value); + ret = TRUE; + } + return ret; +} + +static const GDBusInterfaceVTable _upn_pobject2__skeleton_vtable = +{ + _upn_pobject2__skeleton_handle_method_call, + _upn_pobject2__skeleton_handle_get_property, + _upn_pobject2__skeleton_handle_set_property +}; + +static GDBusInterfaceInfo * +upn_pobject2__skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton) +{ + return upn_pobject2__interface_info (); +} + +static GDBusInterfaceVTable * +upn_pobject2__skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton) +{ + return (GDBusInterfaceVTable *) &_upn_pobject2__skeleton_vtable; +} + +static GVariant * +upn_pobject2__skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (_skeleton); + + GVariantBuilder builder; + guint n; + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + if (_upn_pobject2__interface_info.parent_struct.properties == NULL) + goto out; + for (n = 0; _upn_pobject2__interface_info.parent_struct.properties[n] != NULL; n++) + { + GDBusPropertyInfo *info = _upn_pobject2__interface_info.parent_struct.properties[n]; + if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) + { + GVariant *value; + value = _upn_pobject2__skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.gnome.UPnP.MediaObject2", info->name, NULL, skeleton); + if (value != NULL) + { + g_variant_take_ref (value); + g_variant_builder_add (&builder, "{sv}", info->name, value); + g_variant_unref (value); + } + } + } +out: + return g_variant_builder_end (&builder); +} + +static gboolean _upn_pobject2__emit_changed (gpointer user_data); + +static void +upn_pobject2__skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (_skeleton); + gboolean emit_changed = FALSE; + + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties_idle_source != NULL) + { + g_source_destroy (skeleton->priv->changed_properties_idle_source); + skeleton->priv->changed_properties_idle_source = NULL; + emit_changed = TRUE; + } + g_mutex_unlock (&skeleton->priv->lock); + + if (emit_changed) + _upn_pobject2__emit_changed (skeleton); +} + +static void upn_pobject2__skeleton_iface_init (UPnPObject2Iface *iface); +G_DEFINE_TYPE_WITH_CODE (UPnPObject2Skeleton, upn_pobject2__skeleton, G_TYPE_DBUS_INTERFACE_SKELETON, + G_IMPLEMENT_INTERFACE (UPN_POBJECT2_TYPE_, upn_pobject2__skeleton_iface_init)); + +static void +upn_pobject2__skeleton_finalize (GObject *object) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + guint n; + for (n = 0; n < 4; n++) + g_value_unset (&skeleton->priv->properties[n]); + g_free (skeleton->priv->properties); + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + if (skeleton->priv->changed_properties_idle_source != NULL) + g_source_destroy (skeleton->priv->changed_properties_idle_source); + g_main_context_unref (skeleton->priv->context); + g_mutex_clear (&skeleton->priv->lock); + G_OBJECT_CLASS (upn_pobject2__skeleton_parent_class)->finalize (object); +} + +static void +upn_pobject2__skeleton_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 4); + g_mutex_lock (&skeleton->priv->lock); + g_value_copy (&skeleton->priv->properties[prop_id - 1], value); + g_mutex_unlock (&skeleton->priv->lock); +} + +static gboolean +_upn_pobject2__emit_changed (gpointer user_data) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (user_data); + GList *l; + GVariantBuilder builder; + GVariantBuilder invalidated_builder; + guint num_changes; + + g_mutex_lock (&skeleton->priv->lock); + g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as")); + for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next) + { + ChangedProperty *cp = l->data; + GVariant *variant; + const GValue *cur_value; + + cur_value = &skeleton->priv->properties[cp->prop_id - 1]; + if (!_g_value_equal (cur_value, &cp->orig_value)) + { + variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature)); + g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant); + g_variant_unref (variant); + num_changes++; + } + } + if (num_changes > 0) + { + GList *connections, *ll; + GVariant *signal_variant; + signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.gnome.UPnP.MediaObject2", + &builder, &invalidated_builder)); + connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton)); + for (ll = connections; ll != NULL; ll = ll->next) + { + GDBusConnection *connection = ll->data; + + g_dbus_connection_emit_signal (connection, + NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), + "org.freedesktop.DBus.Properties", + "PropertiesChanged", + signal_variant, + NULL); + } + g_variant_unref (signal_variant); + g_list_free_full (connections, g_object_unref); + } + else + { + g_variant_builder_clear (&builder); + g_variant_builder_clear (&invalidated_builder); + } + g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free); + skeleton->priv->changed_properties = NULL; + skeleton->priv->changed_properties_idle_source = NULL; + g_mutex_unlock (&skeleton->priv->lock); + return FALSE; +} + +static void +_upn_pobject2__schedule_emit_changed (UPnPObject2Skeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value) +{ + ChangedProperty *cp; + GList *l; + cp = NULL; + for (l = skeleton->priv->changed_properties; l != NULL; l = l->next) + { + ChangedProperty *i_cp = l->data; + if (i_cp->info == info) + { + cp = i_cp; + break; + } + } + if (cp == NULL) + { + cp = g_new0 (ChangedProperty, 1); + cp->prop_id = prop_id; + cp->info = info; + skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp); + g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value)); + g_value_copy (orig_value, &cp->orig_value); + } +} + +static void +upn_pobject2__skeleton_notify (GObject *object, + GParamSpec *pspec) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + g_mutex_lock (&skeleton->priv->lock); + if (skeleton->priv->changed_properties != NULL && + skeleton->priv->changed_properties_idle_source == NULL) + { + skeleton->priv->changed_properties_idle_source = g_idle_source_new (); + g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT); + g_source_set_callback (skeleton->priv->changed_properties_idle_source, _upn_pobject2__emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref); + g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context); + g_source_unref (skeleton->priv->changed_properties_idle_source); + } + g_mutex_unlock (&skeleton->priv->lock); +} + +static void +upn_pobject2__skeleton_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + g_assert (prop_id != 0 && prop_id - 1 < 4); + g_mutex_lock (&skeleton->priv->lock); + g_object_freeze_notify (object); + if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1])) + { + if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL) + _upn_pobject2__schedule_emit_changed (skeleton, _upn_pobject2__property_info_pointers[prop_id - 1], prop_id, &skeleton->priv->properties[prop_id - 1]); + g_value_copy (value, &skeleton->priv->properties[prop_id - 1]); + g_object_notify_by_pspec (object, pspec); + } + g_mutex_unlock (&skeleton->priv->lock); + g_object_thaw_notify (object); +} + +static void +upn_pobject2__skeleton_init (UPnPObject2Skeleton *skeleton) +{ + skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UPN_POBJECT2_TYPE__SKELETON, UPnPObject2SkeletonPrivate); + g_mutex_init (&skeleton->priv->lock); + skeleton->priv->context = g_main_context_ref_thread_default (); + skeleton->priv->properties = g_new0 (GValue, 4); + g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING); + g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING); +} + +static const gchar * +upn_pobject2__skeleton_get_parent (UPnPObject2 *object) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[0])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pobject2__skeleton_get_type_ (UPnPObject2 *object) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[1])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pobject2__skeleton_get_path (UPnPObject2 *object) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[2])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static const gchar * +upn_pobject2__skeleton_get_display_name (UPnPObject2 *object) +{ + UPnPObject2Skeleton *skeleton = UPN_POBJECT2__SKELETON (object); + const gchar *value; + g_mutex_lock (&skeleton->priv->lock); + value = g_value_get_string (&(skeleton->priv->properties[3])); + g_mutex_unlock (&skeleton->priv->lock); + return value; +} + +static void +upn_pobject2__skeleton_class_init (UPnPObject2SkeletonClass *klass) +{ + GObjectClass *gobject_class; + GDBusInterfaceSkeletonClass *skeleton_class; + + g_type_class_add_private (klass, sizeof (UPnPObject2SkeletonPrivate)); + + gobject_class = G_OBJECT_CLASS (klass); + gobject_class->finalize = upn_pobject2__skeleton_finalize; + gobject_class->get_property = upn_pobject2__skeleton_get_property; + gobject_class->set_property = upn_pobject2__skeleton_set_property; + gobject_class->notify = upn_pobject2__skeleton_notify; + + + upn_pobject2__override_properties (gobject_class, 1); + + skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass); + skeleton_class->get_info = upn_pobject2__skeleton_dbus_interface_get_info; + skeleton_class->get_properties = upn_pobject2__skeleton_dbus_interface_get_properties; + skeleton_class->flush = upn_pobject2__skeleton_dbus_interface_flush; + skeleton_class->get_vtable = upn_pobject2__skeleton_dbus_interface_get_vtable; +} + +static void +upn_pobject2__skeleton_iface_init (UPnPObject2Iface *iface) +{ + iface->get_parent = upn_pobject2__skeleton_get_parent; + iface->get_type_ = upn_pobject2__skeleton_get_type_; + iface->get_path = upn_pobject2__skeleton_get_path; + iface->get_display_name = upn_pobject2__skeleton_get_display_name; +} + +/** + * upn_pobject2__skeleton_new: + * + * Creates a skeleton object for the D-Bus interface org.gnome.UPnP.MediaObject2. + * + * Returns: (transfer full) (type UPnPObject2Skeleton): The skeleton object. + */ +UPnPObject2 * +upn_pobject2__skeleton_new (void) +{ + return UPN_POBJECT2_ (g_object_new (UPN_POBJECT2_TYPE__SKELETON, NULL)); +} + diff --git a/src/MediaServer/upnp-mediaobject2-proxy.h b/src/MediaServer/upnp-mediaobject2-proxy.h new file mode 100644 index 0000000..ca10798 --- /dev/null +++ b/src/MediaServer/upnp-mediaobject2-proxy.h @@ -0,0 +1,163 @@ +/* + * Generated by gdbus-codegen 2.34.1. DO NOT EDIT. + * + * The license of this code is the same as for the source it was derived from. + */ + +#ifndef __UPNP_MEDIAOBJECT2_PROXY_H__ +#define __UPNP_MEDIAOBJECT2_PROXY_H__ + +#include + +G_BEGIN_DECLS + + +/* ------------------------------------------------------------------------ */ +/* Declarations for org.gnome.UPnP.MediaObject2 */ + +#define UPN_POBJECT2_TYPE_ (upn_pobject2__get_type ()) +#define UPN_POBJECT2_(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_POBJECT2_TYPE_, UPnPObject2)) +#define UPN_POBJECT2_IS_(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_POBJECT2_TYPE_)) +#define UPN_POBJECT2__GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UPN_POBJECT2_TYPE_, UPnPObject2Iface)) + +struct _UPnPObject2; +typedef struct _UPnPObject2 UPnPObject2; +typedef struct _UPnPObject2Iface UPnPObject2Iface; + +struct _UPnPObject2Iface +{ + GTypeInterface parent_iface; + + const gchar * (*get_display_name) (UPnPObject2 *object); + + const gchar * (*get_parent) (UPnPObject2 *object); + + const gchar * (*get_path) (UPnPObject2 *object); + + const gchar * (*get_type_) (UPnPObject2 *object); + +}; + +GType upn_pobject2__get_type (void) G_GNUC_CONST; + +GDBusInterfaceInfo *upn_pobject2__interface_info (void); +guint upn_pobject2__override_properties (GObjectClass *klass, guint property_id_begin); + + +/* D-Bus property accessors: */ +const gchar *upn_pobject2__get_parent (UPnPObject2 *object); +gchar *upn_pobject2__dup_parent (UPnPObject2 *object); +void upn_pobject2__set_parent (UPnPObject2 *object, const gchar *value); + +const gchar *upn_pobject2__get_type_ (UPnPObject2 *object); +gchar *upn_pobject2__dup_type_ (UPnPObject2 *object); +void upn_pobject2__set_type_ (UPnPObject2 *object, const gchar *value); + +const gchar *upn_pobject2__get_path (UPnPObject2 *object); +gchar *upn_pobject2__dup_path (UPnPObject2 *object); +void upn_pobject2__set_path (UPnPObject2 *object, const gchar *value); + +const gchar *upn_pobject2__get_display_name (UPnPObject2 *object); +gchar *upn_pobject2__dup_display_name (UPnPObject2 *object); +void upn_pobject2__set_display_name (UPnPObject2 *object, const gchar *value); + + +/* ---- */ + +#define UPN_POBJECT2_TYPE__PROXY (upn_pobject2__proxy_get_type ()) +#define UPN_POBJECT2__PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_POBJECT2_TYPE__PROXY, UPnPObject2Proxy)) +#define UPN_POBJECT2__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_POBJECT2_TYPE__PROXY, UPnPObject2ProxyClass)) +#define UPN_POBJECT2__PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_POBJECT2_TYPE__PROXY, UPnPObject2ProxyClass)) +#define UPN_POBJECT2_IS__PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_POBJECT2_TYPE__PROXY)) +#define UPN_POBJECT2_IS__PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_POBJECT2_TYPE__PROXY)) + +typedef struct _UPnPObject2Proxy UPnPObject2Proxy; +typedef struct _UPnPObject2ProxyClass UPnPObject2ProxyClass; +typedef struct _UPnPObject2ProxyPrivate UPnPObject2ProxyPrivate; + +struct _UPnPObject2Proxy +{ + /*< private >*/ + GDBusProxy parent_instance; + UPnPObject2ProxyPrivate *priv; +}; + +struct _UPnPObject2ProxyClass +{ + GDBusProxyClass parent_class; +}; + +GType upn_pobject2__proxy_get_type (void) G_GNUC_CONST; + +void upn_pobject2__proxy_new ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPObject2 *upn_pobject2__proxy_new_finish ( + GAsyncResult *res, + GError **error); +UPnPObject2 *upn_pobject2__proxy_new_sync ( + GDBusConnection *connection, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + +void upn_pobject2__proxy_new_for_bus ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +UPnPObject2 *upn_pobject2__proxy_new_for_bus_finish ( + GAsyncResult *res, + GError **error); +UPnPObject2 *upn_pobject2__proxy_new_for_bus_sync ( + GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *object_path, + GCancellable *cancellable, + GError **error); + + +/* ---- */ + +#define UPN_POBJECT2_TYPE__SKELETON (upn_pobject2__skeleton_get_type ()) +#define UPN_POBJECT2__SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UPN_POBJECT2_TYPE__SKELETON, UPnPObject2Skeleton)) +#define UPN_POBJECT2__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UPN_POBJECT2_TYPE__SKELETON, UPnPObject2SkeletonClass)) +#define UPN_POBJECT2__SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UPN_POBJECT2_TYPE__SKELETON, UPnPObject2SkeletonClass)) +#define UPN_POBJECT2_IS__SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UPN_POBJECT2_TYPE__SKELETON)) +#define UPN_POBJECT2_IS__SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UPN_POBJECT2_TYPE__SKELETON)) + +typedef struct _UPnPObject2Skeleton UPnPObject2Skeleton; +typedef struct _UPnPObject2SkeletonClass UPnPObject2SkeletonClass; +typedef struct _UPnPObject2SkeletonPrivate UPnPObject2SkeletonPrivate; + +struct _UPnPObject2Skeleton +{ + /*< private >*/ + GDBusInterfaceSkeleton parent_instance; + UPnPObject2SkeletonPrivate *priv; +}; + +struct _UPnPObject2SkeletonClass +{ + GDBusInterfaceSkeletonClass parent_class; +}; + +GType upn_pobject2__skeleton_get_type (void) G_GNUC_CONST; + +UPnPObject2 *upn_pobject2__skeleton_new (void); + + +G_END_DECLS + +#endif /* __UPNP_MEDIAOBJECT2_PROXY_H__ */