← Back to branch summary

~ubuntu-branches/ubuntu/trusty/digikam/trusty

« back to all changes in this revision

Viewing changes to extra/kipi-plugins/dlnaexport/extra/hupnp_av/src/cds_model/model_mgmt/hcds_dlite_serializer.cpp

  • Committer: Package Import Robot
  • Author(s): Rohan Garg
  • Date: 2012-11-26 18:24:20 UTC
  • mfrom: (1.9.1) (3.1.23 experimental)
  • Revision ID: package-import@ubuntu.com-20121126182420-qoy6z0nx4ai0wzcl
Tags: 4:3.0.0~beta3-0ubuntu1
https://launchpad.net/bugs/890059
https://launchpad.net/bugs/1011211
https://launchpad.net/bugs/658047
* New upstream release
  - Add build-deps :  libhupnp-dev, libqtgstreamer-dev, libmagickcore-dev
* Merge from debian, remaining changes:
  - Make sure libqt4-opengl-dev, libgl1-mesa-dev and libglu1-mesa-dev only
    install on i386,amd64 and powerpc
  - Depend on libtiff-dev instead of libtiff4-dev
  - Drop digikam breaks/replaces kipi-plugins-common since we're past the
    LTS release now
  - digikam to recommend mplayerthumbs | ffmpegthumbs. We currently only
    have latter in the archives, even though former is also supposed to
    be part of kdemultimedia. (LP: #890059)
  - kipi-plugins to recommend www-browser rather than konqueror directly
    since 2.8 no direct usage of konqueror is present in the flickr
    plugin anymore (LP: #1011211)
  - Keep kubuntu_mysqld_executable_name.diff
  - Don't install libkipi translations
  - Keep deps on libcv-dev, libcvaux-dev
  - Keep split packaging of libraries
  - Replace icons from KDE 3 time in debian/xpm.d/*.xpm with the new
    versions (LP: #658047)
* Update debian/not-installed

Show diffs side-by-side

added added

removed removed

Lines of Context:
extra/kipi-plugins/dlnaexport/extra/hupnp_av/src/cds_model/model_mgmt/hcds_dlite_serializer.cpp
 
1
/*
 
2
 *  Copyright (C) 2011 Tuomo Penttinen, all rights reserved.
 
3
 *
 
4
 *  Author: Tuomo Penttinen <tp@herqq.org>
 
5
 *
 
6
 *  This file is part of Herqq UPnP Av (HUPnPAv) library.
 
7
 *
 
8
 *  Herqq UPnP Av is free software: you can redistribute it and/or modify
 
9
 *  it under the terms of the GNU General Public License as published by
 
10
 *  the Free Software Foundation, either version 3 of the License, or
 
11
 *  (at your option) any later version.
 
12
 *
 
13
 *  Herqq UPnP Av is distributed in the hope that it will be useful,
 
14
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
16
 *  GNU General Public License for more details.
 
17
 *
 
18
 *  You should have received a copy of the GNU General Public License
 
19
 *  along with Herqq UPnP Av. If not, see <http://www.gnu.org/licenses/>.
 
20
 */
 
21
 
 
22
#include "hcds_dlite_serializer.h"
 
23
#include "hcds_dlite_serializer_p.h"
 
24
#include "hcdsproperty_db.h"
 
25
#include "hcdsproperty.h"
 
26
 
 
27
#include "../cds_objects/hitem.h"
 
28
#include "../cds_objects/halbum.h"
 
29
#include "../cds_objects/hmovie.h"
 
30
#include "../cds_objects/hphoto.h"
 
31
#include "../cds_objects/hperson.h"
 
32
#include "../cds_objects/htextitem.h"
 
33
#include "../cds_objects/haudioitem.h"
 
34
#include "../cds_objects/haudiobook.h"
 
35
#include "../cds_objects/hcontainer.h"
 
36
#include "../cds_objects/haudiobook.h"
 
37
#include "../cds_objects/hvideoitem.h"
 
38
#include "../cds_objects/hmusicgenre.h"
 
39
#include "../cds_objects/hmoviegenre.h"
 
40
#include "../cds_objects/hmusictrack.h"
 
41
#include "../cds_objects/hmusicalbum.h"
 
42
#include "../cds_objects/hphotoalbum.h"
 
43
#include "../cds_objects/hmusicartist.h"
 
44
#include "../cds_objects/hphotoalbum.h"
 
45
#include "../cds_objects/hepgcontainer.h"
 
46
#include "../cds_objects/hchannelgroup.h"
 
47
#include "../cds_objects/hbookmarkitem.h"
 
48
#include "../cds_objects/hplaylistitem.h"
 
49
#include "../cds_objects/haudioprogram.h"
 
50
#include "../cds_objects/hvideoprogram.h"
 
51
#include "../cds_objects/hstoragesystem.h"
 
52
#include "../cds_objects/hstoragevolume.h"
 
53
#include "../cds_objects/hstoragefolder.h"
 
54
#include "../cds_objects/hgenrecontainer.h"
 
55
#include "../cds_objects/hvideobroadcast.h"
 
56
#include "../cds_objects/haudiobroadcast.h"
 
57
#include "../cds_objects/hmusicvideoclip.h"
 
58
#include "../cds_objects/hbookmarkfolder.h"
 
59
#include "../cds_objects/haudiochannelgroup.h"
 
60
#include "../cds_objects/hvideochannelgroup.h"
 
61
#include "../cds_objects/hplaylistcontainer.h"
 
62
 
 
63
#include <HUpnpCore/private/hlogger_p.h>
 
64
 
 
65
#include <QtCore/QSet>
 
66
#include <QtCore/QVariant>
 
67
#include <QtCore/QStringList>
 
68
#include <QtCore/QXmlStreamReader>
 
69
#include <QtCore/QXmlStreamWriter>
 
70
 
 
71
/*!
 
72
 * \defgroup hupnp_av_cds_om_mgmt Object Model Management
 
73
 * \ingroup hupnp_av_cds
 
74
 *
 
75
 */
 
76
 
 
77
namespace Herqq
 
78
{
 
79
 
 
80
namespace Upnp
 
81
{
 
82
 
 
83
namespace Av
 
84
{
 
85
 
 
86
namespace
 
87
{
 
88
void addNamespaces(QXmlStreamReader& reader)
 
89
{
 
90
    QXmlStreamNamespaceDeclaration didl(
 
91
        "DIDL-Lite", "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/");
 
92
    QXmlStreamNamespaceDeclaration dc(
 
93
        "dc", "http://purl.org/dc/elements/1.1/");
 
94
    QXmlStreamNamespaceDeclaration upnp(
 
95
        "upnp", "urn:schemas-upnp-org:metadata-1-0/upnp/");
 
96
    QXmlStreamNamespaceDeclaration xsi(
 
97
        "xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
98
 
 
99
    reader.addExtraNamespaceDeclaration(didl);
 
100
    reader.addExtraNamespaceDeclaration(dc);
 
101
    reader.addExtraNamespaceDeclaration(upnp);
 
102
    reader.addExtraNamespaceDeclaration(xsi);
 
103
}
 
104
 
 
105
QString saveItemToXml(QXmlStreamReader& reader)
 
106
{
 
107
    Q_ASSERT(reader.name() == "item" || reader.name() == "container");
 
108
 
 
109
    QString retVal;
 
110
    QXmlStreamWriter writer(&retVal);
 
111
 
 
112
    writer.writeStartElement(reader.name().toString());
 
113
 
 
114
    while(!reader.atEnd() && reader.readNext())
 
115
    {
 
116
        switch(reader.tokenType())
 
117
        {
 
118
        case QXmlStreamReader::StartElement:
 
119
            if (reader.name() == "item" || reader.name() == "container")
 
120
            {
 
121
                goto end;
 
122
            }
 
123
 
 
124
            writer.writeStartElement(reader.qualifiedName().toString());
 
125
            writer.writeAttributes(reader.attributes());
 
126
            break;
 
127
 
 
128
        case QXmlStreamReader::EndElement:
 
129
            if (reader.name() == "item" || reader.name() == "container")
 
130
            {
 
131
                goto end;
 
132
            }
 
133
 
 
134
            writer.writeEndElement();
 
135
            break;
 
136
 
 
137
        case QXmlStreamReader::Characters:
 
138
            writer.writeCharacters(reader.text().toString());
 
139
            break;
 
140
 
 
141
        default:
 
142
            continue;
 
143
        }
 
144
    }
 
145
 
 
146
end:
 
147
    writer.writeEndElement();
 
148
 
 
149
    return retVal;
 
150
}
 
151
}
 
152
 
 
153
/*******************************************************************************
 
154
 * HCdsDidlLiteSerializerPrivate
 
155
 ******************************************************************************/
 
156
namespace
 
157
{
 
158
inline HObject* createItem          () { return HItem::create(); }
 
159
inline HObject* createImageItem     () { return HImageItem::create(); }
 
160
inline HObject* createPhoto         () { return HPhoto::create(); }
 
161
inline HObject* createAudioItem     () { return HAudioItem::create(); }
 
162
inline HObject* createMusicTrack    () { return HMusicTrack::create(); }
 
163
inline HObject* createAudioBroadcast() { return HAudioBroadcast::create(); }
 
164
inline HObject* createAudioBook     () { return HAudioBook::create(); }
 
165
inline HObject* createVideoItem     () { return HVideoItem::create(); }
 
166
inline HObject* createMovie         () { return HMovie::create(); }
 
167
inline HObject* createVideoBroadcast() { return HVideoBroadcast::create(); }
 
168
inline HObject* createMusicVideoClip() { return HMusicVideoClip::create(); }
 
169
inline HObject* createPlaylistItem  () { return HPlaylistItem::create(); }
 
170
inline HObject* createTextItem      () { return HTextItem::create(); }
 
171
inline HObject* createBookmarkItem  () { return HBookmarkItem::create(); }
 
172
inline HObject* createEpgItem       () { return HEpgItem::create(); }
 
173
inline HObject* createAudioProgram  () { return HAudioProgram::create(); }
 
174
inline HObject* createVideoProgram  () { return HVideoProgram::create(); }
 
175
inline HObject* createContainer     () { return HContainer::create(); }
 
176
inline HObject* createPerson        () { return HPerson::create(); }
 
177
inline HObject* createMusicArtist   () { return HMusicArtist::create(); }
 
178
inline HObject* createPlaylistContainer() { return HPlaylistContainer::create(); }
 
179
inline HObject* createAlbum         () { return HAlbum::create(); }
 
180
inline HObject* createMusicAlbum    () { return HMusicAlbum::create(); }
 
181
inline HObject* createPhotoAlbum    () { return HPhotoAlbum::create(); }
 
182
inline HObject* createGenreContainer() { return HGenreContainer::create(); }
 
183
inline HObject* createMusicGenre    () { return HMusicGenre::create(); }
 
184
inline HObject* createMovieGenre    () { return HMovieGenre::create(); }
 
185
inline HObject* createChannelGroup  () { return HChannelGroup::create(); }
 
186
inline HObject* createAudioChannelGroup() { return HAudioChannelGroup::create(); }
 
187
inline HObject* createVideoChannelGroup() { return HVideoChannelGroup::create(); }
 
188
inline HObject* createEpgContainer  () { return HEpgContainer::create(); }
 
189
inline HObject* createStorageSystem () { return HStorageSystem::create(); }
 
190
inline HObject* createStorageVolume () { return HStorageVolume::create(); }
 
191
inline HObject* createStorageFolder () { return HStorageFolder::create(); }
 
192
inline HObject* createBookmarkFolder() { return HBookmarkFolder::create(); }
 
193
}
 
194
 
 
195
HCdsDidlLiteSerializerPrivate::HCdsDidlLiteSerializerPrivate() :
 
196
    m_creatorFunctions(), m_lastErrorDescription()
 
197
{
 
198
    m_creatorFunctions.insert(HItem::sClass(), createItem);
 
199
    m_creatorFunctions.insert(HImageItem::sClass(), createImageItem);
 
200
    m_creatorFunctions.insert(HPhoto::sClass(), createPhoto);
 
201
    m_creatorFunctions.insert(HAudioItem::sClass(), createAudioItem);
 
202
    m_creatorFunctions.insert(HMusicTrack::sClass(), createMusicTrack);
 
203
    m_creatorFunctions.insert(HAudioBroadcast::sClass(), createAudioBroadcast);
 
204
    m_creatorFunctions.insert(HAudioBook::sClass(), createAudioBook);
 
205
    m_creatorFunctions.insert(HVideoItem::sClass(), createVideoItem);
 
206
    m_creatorFunctions.insert(HMovie::sClass(), createMovie);
 
207
    m_creatorFunctions.insert(HVideoBroadcast::sClass(), createVideoBroadcast);
 
208
    m_creatorFunctions.insert(HMusicVideoClip::sClass(), createMusicVideoClip);
 
209
    m_creatorFunctions.insert(HPlaylistItem::sClass(), createPlaylistItem);
 
210
    m_creatorFunctions.insert(HTextItem::sClass(), createTextItem);
 
211
    m_creatorFunctions.insert(HBookmarkItem::sClass(), createBookmarkItem);
 
212
    m_creatorFunctions.insert(HEpgItem::sClass(), createEpgItem);
 
213
    m_creatorFunctions.insert(HAudioProgram::sClass(), createAudioProgram);
 
214
    m_creatorFunctions.insert(HVideoProgram::sClass(), createVideoProgram);
 
215
 
 
216
    m_creatorFunctions.insert(HContainer::sClass(), createContainer);
 
217
    m_creatorFunctions.insert(HPerson::sClass(), createPerson);
 
218
    m_creatorFunctions.insert(HMusicArtist::sClass(), createMusicArtist);
 
219
    m_creatorFunctions.insert(HPlaylistContainer::sClass(), createPlaylistContainer);
 
220
    m_creatorFunctions.insert(HAlbum::sClass(), createAlbum);
 
221
    m_creatorFunctions.insert(HMusicAlbum::sClass(), createMusicAlbum);
 
222
    m_creatorFunctions.insert(HPhotoAlbum::sClass(), createPhotoAlbum);
 
223
    m_creatorFunctions.insert(HGenreContainer::sClass(), createGenreContainer);
 
224
    m_creatorFunctions.insert(HMusicGenre::sClass(), createMusicGenre);
 
225
    m_creatorFunctions.insert(HMovieGenre::sClass(), createMovieGenre);
 
226
    m_creatorFunctions.insert(HChannelGroup::sClass(), createChannelGroup);
 
227
    m_creatorFunctions.insert(HAudioChannelGroup::sClass(), createAudioChannelGroup);
 
228
    m_creatorFunctions.insert(HVideoChannelGroup::sClass(), createVideoChannelGroup);
 
229
    m_creatorFunctions.insert(HEpgContainer::sClass(), createEpgContainer);
 
230
    m_creatorFunctions.insert(HStorageSystem::sClass(), createStorageSystem);
 
231
    m_creatorFunctions.insert(HStorageVolume::sClass(), createStorageVolume);
 
232
    m_creatorFunctions.insert(HStorageFolder::sClass(), createStorageFolder);
 
233
    m_creatorFunctions.insert(HBookmarkFolder::sClass(), createBookmarkFolder);
 
234
}
 
235
 
 
236
HCdsDidlLiteSerializerPrivate::~HCdsDidlLiteSerializerPrivate()
 
237
{
 
238
}
 
239
 
 
240
bool HCdsDidlLiteSerializerPrivate::serializePropertyFromAttribute(
 
241
    HObject* object, const QString& xmlTokenName, const QString& attributeValue)
 
242
{
 
243
    HLOG(H_AT, H_FUN);
 
244
 
 
245
    QString cdsName = QString("@%1").arg(xmlTokenName);
 
246
    if (!object->hasCdsProperty(cdsName))
 
247
    {
 
248
        return false;
 
249
    }
 
250
 
 
251
    HCdsProperty prop = HCdsPropertyDb::instance().property(cdsName);
 
252
    if (!prop.isValid())
 
253
    {
 
254
        return false;
 
255
    }
 
256
 
 
257
    HCdsPropertyHandler hnd = prop.handler();
 
258
 
 
259
    QVariant value(attributeValue);
 
260
    value.convert(prop.info().defaultValue().type());
 
261
    /*if (!hnd.inSerializer()(xmlTokenName, &value, 0))
 
262
    {
 
263
        return false;
 
264
    }*/
 
265
 
 
266
    HValidator validator = hnd.validator();
 
267
    if (validator && !validator(value))
 
268
    {
 
269
        return false;
 
270
    }
 
271
 
 
272
    if (!object->setCdsProperty(cdsName, value))
 
273
    {
 
274
        return false;
 
275
    }
 
276
 
 
277
    return true;
 
278
}
 
279
 
 
280
bool HCdsDidlLiteSerializerPrivate::serializePropertyFromElement(
 
281
    HObject* object, const QString& propertyName, QXmlStreamReader& reader)
 
282
{
 
283
    HLOG(H_AT, H_FUN);
 
284
 
 
285
    if (!object->hasCdsProperty(propertyName))
 
286
    {
 
287
        return false;
 
288
    }
 
289
 
 
290
    HCdsProperty prop = HCdsPropertyDb::instance().property(propertyName);
 
291
 
 
292
    if (!prop.isValid())
 
293
    {
 
294
        return object->serialize(propertyName, 0, &reader);
 
295
    }
 
296
 
 
297
    QVariant value;
 
298
    HCdsPropertyHandler hnd = prop.handler();
 
299
    if (hnd.inSerializer()(propertyName, &value, &reader) == false)
 
300
    {
 
301
        return false;
 
302
    }
 
303
 
 
304
    HValidator validator = hnd.validator();
 
305
    if (validator && !validator(value))
 
306
    {
 
307
        return false;
 
308
    }
 
309
 
 
310
    if (prop.info().propertyFlags() & HCdsPropertyInfo::MultiValued)
 
311
    {
 
312
        QVariant tmp;
 
313
        object->getCdsProperty(propertyName, &tmp);
 
314
        QVariantList values = tmp.toList();
 
315
        values.append(value);
 
316
        return object->setCdsProperty(propertyName, values);
 
317
    }
 
318
 
 
319
    return object->setCdsProperty(propertyName, value);
 
320
}
 
321
 
 
322
bool HCdsDidlLiteSerializerPrivate::serializeProperty(
 
323
    const HObject& object, const QString& propName, const QVariant& value,
 
324
    const QSet<QString>& filter, QXmlStreamWriter& writer)
 
325
{
 
326
    HLOG(H_AT, H_FUN);
 
327
 
 
328
    if (!object.isCdsPropertySet(propName) ||
 
329
        !object.isCdsPropertyActive(propName))
 
330
    {
 
331
        return false;
 
332
    }
 
333
 
 
334
    bool filterOk = filter.contains("*") || filter.contains(propName);
 
335
 
 
336
    HCdsProperty prop = HCdsPropertyDb::instance().property(propName);
 
337
 
 
338
    if (!prop.isValid())
 
339
    {
 
340
        if (filterOk)
 
341
        {
 
342
            if (!object.serialize(propName, value, writer))
 
343
            {
 
344
                HLOG_DBG(QString("Failed to serialize property: [%1]").arg(propName));
 
345
            }
 
346
        }
 
347
        else
 
348
        {
 
349
            HLOG_DBG(QString("Failed to serialize property: [%1]").arg(propName));
 
350
        }
 
351
        return false;
 
352
    }
 
353
 
 
354
    HCdsPropertyInfo::PropertyFlags pflags = prop.info().propertyFlags();
 
355
    if (!filterOk && (!(pflags & HCdsPropertyInfo::Mandatory)))
 
356
    {
 
357
        return false;
 
358
    }
 
359
    else if (pflags & HCdsPropertyInfo::MultiValued)
 
360
    {
 
361
        foreach(const QVariant& var, value.toList())
 
362
        {
 
363
            if (prop.handler().outSerializer()(propName, var, writer) == false)
 
364
            {
 
365
                HLOG_DBG(QString("Failed to serialize property: [%1]").arg(propName));
 
366
            }
 
367
        }
 
368
    }
 
369
    else
 
370
    {
 
371
        if (prop.handler().outSerializer()(propName, value, writer) == false)
 
372
        {
 
373
            HLOG_DBG(QString("Failed to serialize property: [%1]").arg(propName));
 
374
        }
 
375
    }
 
376
 
 
377
    return true;
 
378
}
 
379
 
 
380
bool HCdsDidlLiteSerializerPrivate::serializeObject(
 
381
    const HObject& object, const QSet<QString>& filter,
 
382
    QXmlStreamWriter& writer)
 
383
{
 
384
    HLOG(H_AT, H_FUN);
 
385
 
 
386
    writer.writeStartElement(HObject::isItem(object.type()) ? "item" : "container");
 
387
 
 
388
    QHash<QString, QVariant> cdsProps = object.cdsProperties();
 
389
 
 
390
    QSet<QString> didlLiteDepProps =
 
391
        HCdsPropertyDb::instance().didlLiteDependentProperties();
 
392
 
 
393
    foreach(const QString& arg, didlLiteDepProps)
 
394
    {
 
395
        if (cdsProps.contains(arg))
 
396
        {
 
397
            serializeProperty(object, arg, cdsProps.value(arg), filter, writer);
 
398
            cdsProps.remove(arg);
 
399
        }
 
400
    }
 
401
 
 
402
    QHash<QString, QVariant>::const_iterator ci = cdsProps.constBegin();
 
403
    for(; ci != cdsProps.constEnd(); ++ci)
 
404
    {
 
405
        serializeProperty(object, ci.key(), ci.value(), filter, writer);
 
406
    }
 
407
 
 
408
    writer.writeEndElement();
 
409
 
 
410
    return true;
 
411
}
 
412
 
 
413
HObject* HCdsDidlLiteSerializerPrivate::parseObject(
 
414
    QXmlStreamReader& reader, HCdsDidlLiteSerializer::XmlType xtype)
 
415
{
 
416
    HLOG(H_AT, H_FUN);
 
417
 
 
418
    QXmlStreamAttributes attrs = reader.attributes();
 
419
 
 
420
    QString itemData = saveItemToXml(reader);
 
421
 
 
422
    QXmlStreamReader itemReader(itemData);
 
423
 
 
424
    if (xtype == HCdsDidlLiteSerializer::Document)
 
425
    {
 
426
        addNamespaces(itemReader);
 
427
    }
 
428
    else
 
429
    {
 
430
        itemReader.setNamespaceProcessing(false);
 
431
    }
 
432
 
 
433
    while(!itemReader.atEnd() && itemReader.readNext())
 
434
    {
 
435
        if (itemReader.tokenType() == QXmlStreamReader::StartElement)
 
436
        {
 
437
            if (itemReader.qualifiedName() != "upnp:class")
 
438
            {
 
439
                continue;
 
440
            }
 
441
        }
 
442
        else
 
443
        {
 
444
            continue;
 
445
        }
 
446
 
 
447
        QString clazz = itemReader.readElementText();
 
448
        HObjectCreator creator = m_creatorFunctions.value(clazz);
 
449
        if (!creator)
 
450
        {
 
451
            m_lastErrorDescription =  QString("Unknown class: [%1]").arg(clazz);
 
452
            return 0;
 
453
        }
 
454
 
 
455
        QScopedPointer<HObject> object(creator());
 
456
 
 
457
        foreach(const QXmlStreamAttribute& attr, attrs)
 
458
        {
 
459
            serializePropertyFromAttribute(
 
460
                object.data(), attr.name().toString(), attr.value().toString());
 
461
        }
 
462
 
 
463
        bool tcoEnabled = false;
 
464
 
 
465
        itemReader.clear();
 
466
        if (xtype == HCdsDidlLiteSerializer::Document)
 
467
        {
 
468
            addNamespaces(itemReader);
 
469
        }
 
470
        else
 
471
        {
 
472
            itemReader.setNamespaceProcessing(false);
 
473
        }
 
474
        itemReader.addData(itemData);
 
475
 
 
476
        while(!itemReader.atEnd() && itemReader.readNext())
 
477
        {
 
478
            if (itemReader.tokenType() == QXmlStreamReader::StartElement)
 
479
            {
 
480
                QString name = itemReader.qualifiedName().toString();
 
481
 
 
482
                if (name == "upnp:class")
 
483
                {
 
484
                    continue;
 
485
                }
 
486
                else if (!serializePropertyFromElement(object.data(), name, itemReader))
 
487
                {
 
488
                    if (name == "item" || name == "container")
 
489
                    {
 
490
                        continue;
 
491
                    }
 
492
                    else
 
493
                    {
 
494
                        HLOG_DBG(QString("Couldn't serialize property: %1").arg(name));
 
495
                    }
 
496
                }
 
497
                else if (!tcoEnabled)
 
498
                {
 
499
                    const HCdsPropertyInfo& info = HCdsProperties::instance().get(name);
 
500
                    if (info.isValid() && (
 
501
                            info.type() == HCdsProperties::upnp_objectUpdateID ||
 
502
                            info.type() == HCdsProperties::upnp_containerUpdateID ||
 
503
                            info.type() == HCdsProperties::upnp_totalDeletedChildCount)
 
504
                        )
 
505
                    {
 
506
                        tcoEnabled = true;
 
507
                    }
 
508
                }
 
509
            }
 
510
        }
 
511
 
 
512
        if (tcoEnabled)
 
513
        {
 
514
            object->setTrackChangesOption(true);
 
515
        }
 
516
 
 
517
        return object->validate() ? object.take() : 0;
 
518
    }
 
519
 
 
520
    return 0;
 
521
}
 
522
 
 
523
void HCdsDidlLiteSerializerPrivate::writeDidlLiteDocumentInfo(
 
524
    QXmlStreamWriter& writer)
 
525
{
 
526
    writer.setCodec("UTF-8");
 
527
    writer.writeStartDocument();
 
528
    writer.writeStartElement("DIDL-Lite");
 
529
    writer.writeDefaultNamespace("urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/");
 
530
    writer.writeAttribute("xmlns:dc", "http://purl.org/dc/elements/1.1/");
 
531
    writer.writeAttribute("xmlns:upnp", "urn:schemas-upnp-org:metadata-1-0/upnp/");
 
532
    writer.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
533
    writer.writeAttribute("xsi:schemaLocation",
 
534
                      "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/ " \
 
535
                      "http://www.upnp.org/schemas/av/didl-lite.xsd " \
 
536
                      "urn:schemas-upnp-org:metadata-1-0/upnp/ " \
 
537
                      "http://www.upnp.org/schemas/av/upnp.xsd");
 
538
}
 
539
 
 
540
/*******************************************************************************
 
541
 * HCdsDidlLiteSerializer
 
542
 ******************************************************************************/
 
543
HCdsDidlLiteSerializer::HCdsDidlLiteSerializer() :
 
544
    h_ptr(new HCdsDidlLiteSerializerPrivate())
 
545
{
 
546
}
 
547
 
 
548
HCdsDidlLiteSerializer::~HCdsDidlLiteSerializer()
 
549
{
 
550
    delete h_ptr;
 
551
}
 
552
 
 
553
QString HCdsDidlLiteSerializer::lastErrorDescription() const
 
554
{
 
555
    return h_ptr->m_lastErrorDescription;
 
556
}
 
557
 
 
558
bool HCdsDidlLiteSerializer::serializeFromXml(
 
559
    const QString& didlLiteDoc, HObjects* retVal, XmlType inputType)
 
560
{
 
561
    HLOG(H_AT, H_FUN);
 
562
    Q_ASSERT(retVal);
 
563
 
 
564
    QXmlStreamReader reader(didlLiteDoc);
 
565
 
 
566
    if (inputType == Document)
 
567
    {
 
568
        addNamespaces(reader);
 
569
        if (reader.readNextStartElement())
 
570
        {
 
571
            if (reader.name().compare("DIDL-Lite", Qt::CaseInsensitive) != 0)
 
572
            {
 
573
                h_ptr->m_lastErrorDescription = "Missing mandatory DIDL-Lite element";
 
574
                return false;
 
575
            }
 
576
        }
 
577
    }
 
578
    else
 
579
    {
 
580
        reader.setNamespaceProcessing(false);
 
581
    }
 
582
 
 
583
    HObjects tmp;
 
584
    while(!reader.atEnd() && reader.readNext())
 
585
    {
 
586
        switch(reader.tokenType())
 
587
        {
 
588
        case QXmlStreamReader::StartElement:
 
589
            {
 
590
                QStringRef name = reader.name();
 
591
                if (name == "item" || name == "container")
 
592
                {
 
593
                     HObject* obj = h_ptr->parseObject(reader, inputType);
 
594
                     if (!obj)
 
595
                     {
 
596
                         return false;
 
597
                     }
 
598
                     tmp.append(obj);
 
599
                }
 
600
            }
 
601
            break;
 
602
        default:
 
603
            break;
 
604
        }
 
605
    }
 
606
 
 
607
    if (reader.error() != QXmlStreamReader::NoError)
 
608
    {
 
609
        h_ptr->m_lastErrorDescription =
 
610
            QString("Parse failed: [%1]").arg(reader.errorString());
 
611
 
 
612
        return false;
 
613
    }
 
614
 
 
615
    *retVal = tmp;
 
616
    return true;
 
617
}
 
618
 
 
619
QString HCdsDidlLiteSerializer::serializeToXml(
 
620
    const HObject& object, XmlType xmlType)
 
621
{
 
622
    QSet<QString> filter; filter.insert("*");
 
623
    return serializeToXml(object, filter, xmlType);
 
624
}
 
625
 
 
626
QString HCdsDidlLiteSerializer::serializeToXml(
 
627
    const HObject& object, const QSet<QString>& filter, XmlType xmlType)
 
628
{
 
629
    QString retVal;
 
630
    QXmlStreamWriter writer(&retVal);
 
631
 
 
632
    if (xmlType == Document)
 
633
    {
 
634
        h_ptr->writeDidlLiteDocumentInfo(writer);
 
635
    }
 
636
 
 
637
    if (!h_ptr->serializeObject(object, filter, writer))
 
638
    {
 
639
        return "";
 
640
    }
 
641
 
 
642
    if (xmlType == Document)
 
643
    {
 
644
        writer.writeEndDocument();
 
645
    }
 
646
 
 
647
    return retVal;
 
648
}
 
649
 
 
650
QString HCdsDidlLiteSerializer::serializeToXml(const HObjects& objects)
 
651
{
 
652
    QSet<QString> filter; filter.insert("*");
 
653
    return serializeToXml(objects, filter);
 
654
}
 
655
 
 
656
QString HCdsDidlLiteSerializer::serializeToXml(
 
657
    const HObjects& objects, const QSet<QString>& filter)
 
658
{
 
659
    QString retVal;
 
660
    QXmlStreamWriter writer(&retVal);
 
661
 
 
662
    h_ptr->writeDidlLiteDocumentInfo(writer);
 
663
 
 
664
    foreach(const HObject* obj, objects)
 
665
    {
 
666
        if (!h_ptr->serializeObject(*obj, filter, writer))
 
667
        {
 
668
            return "";
 
669
        }
 
670
    }
 
671
 
 
672
    writer.writeEndDocument();
 
673
 
 
674
    return retVal;
 
675
}
 
676
 
 
677
}
 
678
}
 
679
}