qtmobility/src/multimedia/qmediaobject.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
child 15 1f895d8a5b2b
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4
    41 
    41 
    42 #include <QtCore/qmetaobject.h>
    42 #include <QtCore/qmetaobject.h>
    43 
    43 
    44 #include "qmediaobject_p.h"
    44 #include "qmediaobject_p.h"
    45 
    45 
    46 #include "qmediaservice.h"
    46 #include <qmediaservice.h>
    47 #include "qmetadatacontrol.h"
    47 #include <qmetadatareadercontrol.h>
       
    48 #include <qmediabindableinterface.h>
    48 
    49 
    49 
    50 
    50 QT_BEGIN_NAMESPACE
    51 QT_BEGIN_NAMESPACE
    51 
    52 
    52 void QMediaObjectPrivate::_q_notify()
    53 void QMediaObjectPrivate::_q_notify()
    94 
    95 
    95 /*!
    96 /*!
    96     Returns the service availability error state.
    97     Returns the service availability error state.
    97 */
    98 */
    98 
    99 
    99 QtMediaServices::AvailabilityError QMediaObject::availabilityError() const
   100 QtMultimedia::AvailabilityError QMediaObject::availabilityError() const
   100 {
   101 {
   101     return QtMediaServices::ServiceMissingError;
   102     return QtMultimedia::ServiceMissingError;
   102 }
   103 }
   103 
   104 
   104 /*!
   105 /*!
   105     Returns true if the service is available for use.
   106     Returns true if the service is available for use.
   106 */
   107 */
   134         emit notifyIntervalChanged(milliSeconds);
   135         emit notifyIntervalChanged(milliSeconds);
   135     }
   136     }
   136 }
   137 }
   137 
   138 
   138 /*!
   139 /*!
   139   \internal
   140 */
   140 */
   141 bool QMediaObject::bind(QObject *object)
   141 void QMediaObject::bind(QObject*)
   142 {
   142 {
   143     QMediaBindableInterface *helper = qobject_cast<QMediaBindableInterface*>(object);
   143 }
   144     if (!helper)
   144 
   145         return false;
   145 /*!
   146 
   146   \internal
   147     QMediaObject *currentObject = helper->mediaObject();
   147 */
   148 
   148 void QMediaObject::unbind(QObject*)
   149     if (currentObject == this)
   149 {
   150         return true;
       
   151 
       
   152     if (currentObject)
       
   153         currentObject->unbind(object);
       
   154 
       
   155     return helper->setMediaObject(this);
       
   156 }
       
   157 
       
   158 /*!
       
   159 */
       
   160 void QMediaObject::unbind(QObject *object)
       
   161 {
       
   162     QMediaBindableInterface *helper = qobject_cast<QMediaBindableInterface*>(object);
       
   163 
       
   164     Q_ASSERT(helper);
       
   165     Q_ASSERT(helper->mediaObject() == this);
       
   166 
       
   167     if (helper && helper->mediaObject() == this)
       
   168         helper->setMediaObject(0);
   150 }
   169 }
   151 
   170 
   152 
   171 
   153 /*!
   172 /*!
   154     Constructs a media object which uses the functionality provided by a media \a service.
   173     Constructs a media object which uses the functionality provided by a media \a service.
   279 
   298 
   280     Signals that the \a available state of a media object's meta-data has changed.
   299     Signals that the \a available state of a media object's meta-data has changed.
   281 */
   300 */
   282 
   301 
   283 /*!
   302 /*!
   284     \property QMediaObject::metaDataWritable
       
   285     \brief whether a media object's meta-data is writable.
       
   286 
       
   287     If this is true the meta-data is writable, otherwise the meta-data is read-only.
       
   288 */
       
   289 
       
   290 bool QMediaObject::isMetaDataWritable() const
       
   291 {
       
   292     Q_D(const QMediaObject);
       
   293 
       
   294     return d->metaDataControl
       
   295             ? d->metaDataControl->isWritable()
       
   296             : false;
       
   297 }
       
   298 
       
   299 /*!
       
   300     \fn QMediaObject::metaDataWritableChanged(bool writable)
       
   301 
       
   302     Signals that the \a writable state of a media object's meta-data has changed.
       
   303 */
       
   304 
       
   305 /*!
       
   306     Returns the value associated with a meta-data \a key.
   303     Returns the value associated with a meta-data \a key.
   307 */
   304 */
   308 QVariant QMediaObject::metaData(QtMediaServices::MetaData key) const
   305 QVariant QMediaObject::metaData(QtMultimedia::MetaData key) const
   309 {
   306 {
   310     Q_D(const QMediaObject);
   307     Q_D(const QMediaObject);
   311 
   308 
   312     return d->metaDataControl
   309     return d->metaDataControl
   313             ? d->metaDataControl->metaData(key)
   310             ? d->metaDataControl->metaData(key)
   314             : QVariant();
   311             : QVariant();
   315 }
   312 }
   316 
   313 
   317 /*!
   314 /*!
   318     Sets a \a value for a meta-data \a key.
       
   319 */
       
   320 void QMediaObject::setMetaData(QtMediaServices::MetaData key, const QVariant &value)
       
   321 {
       
   322     Q_D(QMediaObject);
       
   323 
       
   324     if (d->metaDataControl)
       
   325         d->metaDataControl->setMetaData(key, value);
       
   326 }
       
   327 
       
   328 /*!
       
   329     Returns a list of keys there is meta-data available for.
   315     Returns a list of keys there is meta-data available for.
   330 */
   316 */
   331 QList<QtMediaServices::MetaData> QMediaObject::availableMetaData() const
   317 QList<QtMultimedia::MetaData> QMediaObject::availableMetaData() const
   332 {
   318 {
   333     Q_D(const QMediaObject);
   319     Q_D(const QMediaObject);
   334 
   320 
   335     return d->metaDataControl
   321     return d->metaDataControl
   336             ? d->metaDataControl->availableMetaData()
   322             ? d->metaDataControl->availableMetaData()
   337             : QList<QtMediaServices::MetaData>();
   323             : QList<QtMultimedia::MetaData>();
   338 }
   324 }
   339 
   325 
   340 /*!
   326 /*!
   341     \fn QMediaObject::metaDataChanged()
   327     \fn QMediaObject::metaDataChanged()
   342 
   328 
   357             ? d->metaDataControl->extendedMetaData(key)
   343             ? d->metaDataControl->extendedMetaData(key)
   358             : QVariant();
   344             : QVariant();
   359 }
   345 }
   360 
   346 
   361 /*!
   347 /*!
   362     Sets a \a value for a meta-data \a key.
       
   363 
       
   364     The naming and type of extended meta-data is not standardized, so the values and meaning
       
   365     of keys may vary between backends.
       
   366 */
       
   367 void QMediaObject::setExtendedMetaData(const QString &key, const QVariant &value)
       
   368 {
       
   369     Q_D(QMediaObject);
       
   370 
       
   371     if (d->metaDataControl)
       
   372         d->metaDataControl->setExtendedMetaData(key, value);
       
   373 }
       
   374 
       
   375 /*!
       
   376     Returns a list of keys there is extended meta-data available for.
   348     Returns a list of keys there is extended meta-data available for.
   377 */
   349 */
   378 QStringList QMediaObject::availableExtendedMetaData() const
   350 QStringList QMediaObject::availableExtendedMetaData() const
   379 {
   351 {
   380     Q_D(const QMediaObject);
   352     Q_D(const QMediaObject);
   388 void QMediaObject::setupMetaData()
   360 void QMediaObject::setupMetaData()
   389 {
   361 {
   390     Q_D(QMediaObject);
   362     Q_D(QMediaObject);
   391 
   363 
   392     if (d->service != 0) {
   364     if (d->service != 0) {
   393         d->metaDataControl =
   365         d->metaDataControl = qobject_cast<QMetaDataReaderControl*>(
   394             qobject_cast<QMetaDataControl*>(d->service->control(QMetaDataControl_iid));
   366                 d->service->requestControl(QMetaDataReaderControl_iid));
   395 
   367 
   396         if (d->metaDataControl) {
   368         if (d->metaDataControl) {
   397             connect(d->metaDataControl, SIGNAL(metaDataChanged()), SIGNAL(metaDataChanged()));
   369             connect(d->metaDataControl, SIGNAL(metaDataChanged()), SIGNAL(metaDataChanged()));
   398             connect(d->metaDataControl,
   370             connect(d->metaDataControl,
   399                     SIGNAL(metaDataAvailableChanged(bool)),
   371                     SIGNAL(metaDataAvailableChanged(bool)),
   400                     SIGNAL(metaDataAvailableChanged(bool)));
   372                     SIGNAL(metaDataAvailableChanged(bool)));
   401             connect(d->metaDataControl,
       
   402                     SIGNAL(writableChanged(bool)),
       
   403                     SIGNAL(metaDataWritableChanged(bool)));
       
   404         }
   373         }
   405     }
   374     }
   406 }
   375 }
   407 
   376 
   408 /*!
   377 /*!