Mercurial Mercurial > oss > FCL > sf > mw > mmappfw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmappcomponents/mmmtpdataprovider/mmmtpdpplugins/mediamtpdataprovider/src/cmediamtpdataprovidercopyobject.cpp
changeset 25 d881023c13eb
parent 0 a2952bb97e68
child 50 762d760dcfdf
equal deleted inserted replaced
21:a05c44bc3c61 25:d881023c13eb 
    14 * Description:  Implement the operation: Copy Object
 
    14 * Description:  Implement the operation: Copy Object
 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 
    18 
    19 #include <mtp/mmtpdataproviderframework.h>
 
       
    20 #include <mtp/cmtptypeobjectproplist.h>
 
    19 #include <mtp/cmtptypeobjectproplist.h>
 
    21 #include <mtp/cmtptypestring.h>
 
    20 #include <mtp/cmtptypestring.h>
 
    22 #include <mtp/cmtptypearray.h>
 
    21 #include <mtp/cmtptypearray.h>
 
    23 
    22 
    24 #include "cmediamtpdataprovidercopyobject.h"
 
    23 #include "cmediamtpdataprovidercopyobject.h"
 
    63 // Destructor
 
    62 // Destructor
 
    64 // -----------------------------------------------------------------------------
 
    63 // -----------------------------------------------------------------------------
 
    65 //
 
    64 //
 
    66 CMediaMtpDataProviderCopyObject::~CMediaMtpDataProviderCopyObject()
 
    65 CMediaMtpDataProviderCopyObject::~CMediaMtpDataProviderCopyObject()
 
    67     {
 
    66     {
 
    68 
    67     // Do nothing
 
    69     }
 
    68     }
 
    70 
    69 
    71 // -----------------------------------------------------------------------------
 
    70 // -----------------------------------------------------------------------------
 
    72 // CMediaMtpDataProviderCopyObject::CMediaMtpDataProviderCopyObject
 
    71 // CMediaMtpDataProviderCopyObject::CMediaMtpDataProviderCopyObject
 
    73 // Standard c++ constructor
 
    72 // Standard c++ constructor
 
    76 CMediaMtpDataProviderCopyObject::CMediaMtpDataProviderCopyObject( MMTPDataProviderFramework& aFramework,
 
    75 CMediaMtpDataProviderCopyObject::CMediaMtpDataProviderCopyObject( MMTPDataProviderFramework& aFramework,
 
    77     MMTPConnection& aConnection,
 
    76     MMTPConnection& aConnection,
 
    78     MMmMtpDpConfig& aDpConfig ) :
 
    77     MMmMtpDpConfig& aDpConfig ) :
 
    79     CCopyObject( aFramework, aConnection, aDpConfig )
 
    78     CCopyObject( aFramework, aConnection, aDpConfig )
 
    80     {
 
    79     {
 
    81 
    80     // Do nothing
 
    82     }
 
    81     }
 
    83 
    82 
    84 // -----------------------------------------------------------------------------
 
    83 // -----------------------------------------------------------------------------
 
    85 // CMediaMtpDataProviderCopyObject::ServiceSpecificObjectPropertyL
 
    84 // CMediaMtpDataProviderCopyObject::ServiceSpecificObjectPropertyL
 
    86 //
 
    85 //
 
   122 
   121 
   123             if ( err == KErrNone )
 
   122             if ( err == KErrNone )
 
   124                 {
 
   123                 {
 
   125                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   124                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   126                 iPropertyElement->SetStringL( CMTPTypeObjectPropListElement::EValue, textData->StringChars());
 
   125                 iPropertyElement->SetStringL( CMTPTypeObjectPropListElement::EValue, textData->StringChars());
 
   127                 
       
   128 //                iPropertyElement = CMTPTypeObjectPropListElement::NewL( aHandle,
 
       
   129 //                    aPropCode,
 
       
   130 //                    *textData );
 
       
   131                 }
 
   126                 }
 
   132 
   127 
   133             CleanupStack::PopAndDestroy( textData );  // - textData
 
   128             CleanupStack::PopAndDestroy( textData );  // - textData
 
   134             }
 
   129             }
 
   135             break;
 
   130             break;
 
   146 
   141 
   147             if ( err == KErrNone )
 
   142             if ( err == KErrNone )
 
   148                 {
 
   143                 {
 
   149                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   144                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   150                 iPropertyElement->SetArrayL( CMTPTypeObjectPropListElement::EValue, *desData);
 
   145                 iPropertyElement->SetArrayL( CMTPTypeObjectPropListElement::EValue, *desData);
 
   151                 
       
   152 //                iPropertyElement = CMTPTypeObjectPropListElement::NewL( aHandle,
 
       
   153 //                    aPropCode,
 
       
   154 //                    *desData );
 
       
   155                 }
 
   146                 }
 
   156 
   147 
   157             CleanupStack::PopAndDestroy( desData );  // - desData
 
   148             CleanupStack::PopAndDestroy( desData );  // - desData
 
   158             }
 
   149             }
 
   159             break;
 
   150             break;
 
   171 
   162 
   172             if ( err == KErrNone )
 
   163             if ( err == KErrNone )
 
   173                 {
 
   164                 {
 
   174                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   165                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   175                 iPropertyElement->SetUint16L( CMTPTypeObjectPropListElement::EValue, uint16.Value());
 
   166                 iPropertyElement->SetUint16L( CMTPTypeObjectPropListElement::EValue, uint16.Value());
 
   176                 
   167                 }
 
   177 //                iPropertyElement = CMTPTypeObjectPropListElement::NewL( aHandle,
 
       
   178 //                    aPropCode,
 
       
   179 //                    uint16 );
 
       
   180                 }
 
       
   181 
       
   182             }
 
   168             }
 
   183             break;
 
   169             break;
 
   184 
   170 
   185         case EMTPObjectPropCodeWidth:
 
   171         case EMTPObjectPropCodeWidth:
 
   186         case EMTPObjectPropCodeHeight:
 
   172         case EMTPObjectPropCodeHeight:
 
   187         case EMTPObjectPropCodeDuration:
 
   173         case EMTPObjectPropCodeDuration:
 
   188         case EMTPObjectPropCodeUseCount:
 
       
   189         case EMTPObjectPropCodeSampleRate:
 
   174         case EMTPObjectPropCodeSampleRate:
 
   190         case EMTPObjectPropCodeAudioWAVECodec:
 
   175         case EMTPObjectPropCodeAudioWAVECodec:
 
   191         case EMTPObjectPropCodeAudioBitRate:
 
   176         case EMTPObjectPropCodeAudioBitRate:
 
   192         case EMTPObjectPropCodeVideoFourCCCodec:
 
   177         case EMTPObjectPropCodeVideoFourCCCodec:
 
   193         case EMTPObjectPropCodeVideoBitRate:
 
   178         case EMTPObjectPropCodeVideoBitRate:
 
   202 
   187 
   203             if ( err == KErrNone )
 
   188             if ( err == KErrNone )
 
   204                 {
 
   189                 {
 
   205                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   190                 iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   206                 iPropertyElement->SetUint32L( CMTPTypeObjectPropListElement::EValue, uint32.Value());
 
   191                 iPropertyElement->SetUint32L( CMTPTypeObjectPropListElement::EValue, uint32.Value());
 
   207 //                iPropertyElement = CMTPTypeObjectPropListElement::NewL( aHandle,
 
       
   208 //                    aPropCode,
 
       
   209 //                    uint32 );
 
       
   210                 }
 
   192                 }
 
   211             }
 
   193             }
 
   212             break;
 
   194             break;
 
   213 
   195 
   214         case EMTPExtObjectPropCodeOmaDrmStatus:
 
   196         case EMTPExtObjectPropCodeOmaDrmStatus:
 
   218             result.Set( 0 );
 
   200             result.Set( 0 );
 
   219 
   201 
   220             if ( drmStatus == EMTPDrmStatusProtected )
 
   202             if ( drmStatus == EMTPDrmStatusProtected )
 
   221                 result.Set( 1 );
 
   203                 result.Set( 1 );
 
   222 
   204 
   223             iPropertyElement = &(iPropertyList->ReservePropElemL(aHandle, aPropCode));
 
   205             iPropertyElement = &( iPropertyList->ReservePropElemL( aHandle, aPropCode ) );
 
   224             iPropertyElement->SetUint16L( CMTPTypeObjectPropListElement::EDatatype, EMTPTypeUINT8);
 
   206             iPropertyElement->SetUint16L( CMTPTypeObjectPropListElement::EDatatype, EMTPTypeUINT8 );
 
   225             iPropertyElement->SetUint8L( CMTPTypeObjectPropListElement::EValue, result.Value());
 
   207             iPropertyElement->SetUint8L( CMTPTypeObjectPropListElement::EValue, result.Value());
 
   226             
       
   227 //            iPropertyElement = CMTPTypeObjectPropListElement::NewL( aHandle,
 
       
   228 //                aPropCode,
 
       
   229 //                EMTPTypeUINT8,
 
       
   230 //                result );
 
       
   231             }
 
   208             }
 
   232             break;
 
   209             break;
 
   233 
   210 
   234         default:
 
   211         default:
 
   235             {
 
   212             {
 
   237             }
 
   214             }
 
   238             break;
 
   215             break;
 
   239         }
 
   216         }
 
   240 
   217 
   241     // centralize logic to handle error, doing so, that's on need to trap the
 
   218     // centralize logic to handle error, doing so, that's on need to trap the
 
   242     // leave for KErrNotSupported in base class like previous version.
 
   219     // Ignore all errors came from mpx db.
 
   243     if ( ( err == KErrNotFound )
 
   220     // It's enough that only file copied successfully no matter metadata got whatever failure.
 
   244         || ( ( err == KErrNotSupported )
 
   221     if ( err != KErrNone )
 
   245         && ( ( aObject.Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCodeASF )
 
       
   246         || ( aObject.Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCodeMP4Container )
 
       
   247         || ( aObject.Uint( CMTPObjectMetaData::EFormatCode ) == EMTPFormatCode3GPContainer ) ) ) )
 
       
   248         {
 
   222         {
 
   249         iPropertyElement = NULL;
 
   223         iPropertyElement = NULL;
 
   250         }
 
   224         }
 
   251     else
 
   225     else
 
   252         {
 
   226         {
 
   253         User::LeaveIfError( err );
 
   227         User::LeaveIfError( err );
 
   254         }
 
   228         }
 
   255     PRINT( _L( "MM MTP <= CMediaMtpDataProviderCopyObject::ServiceSpecificObjectPropertyL" ) );
 
   229     PRINT( _L( "MM MTP <= CMediaMtpDataProviderCopyObject::ServiceSpecificObjectPropertyL" ) );
 
   256     }
 
   230     }
 
   257 
   231 
   258 // -----------------------------------------------------------------------------
 
       
   259 // CMediaMtpDataProviderCopyObject::ServiceSetSpecificObjectPropertyL
 
       
   260 //
 
       
   261 // -----------------------------------------------------------------------------
 
       
   262 //
 
       
   263 TMTPResponseCode CMediaMtpDataProviderCopyObject::ServiceSetSpecificObjectPropertyL( TUint16 aPropCode, const CMTPObjectMetaData& aObject,
 
       
   264     const CMTPTypeObjectPropListElement& aElement )
 
       
   265     {
 
       
   266     PRINT( _L( "MM MTP => CMediaMtpDataProviderCopyObject::ServiceSetSpecificObjectPropertyL" ) );
 
       
   267     TMTPResponseCode responseCode( EMTPRespCodeOK );
 
       
   268 
       
   269     switch ( aPropCode )
 
       
   270         {
 
       
   271         case EMTPObjectPropCodeArtist:
 
       
   272         case EMTPObjectPropCodeGenre:
 
       
   273         case EMTPObjectPropCodeComposer:
 
       
   274         case EMTPObjectPropCodeOriginalReleaseDate:
 
       
   275         case EMTPObjectPropCodeAlbumName:
 
       
   276         case EMTPObjectPropCodeParentalRating:
 
       
   277         case EMTPObjectPropCodeEncodingProfile:
 
       
   278             {
 
       
   279             CMTPTypeString* stringData =
 
       
   280                 CMTPTypeString::NewLC( aElement.StringL( CMTPTypeObjectPropListElement::EValue ) );// + stringData
 
       
   281 
       
   282             responseCode = ServiceMetaDataToWrapper( aPropCode,
 
       
   283                 *stringData,
 
       
   284                 aObject );
 
       
   285 
       
   286             CleanupStack::PopAndDestroy( stringData ); // - stringData
 
       
   287             }
 
       
   288             break;
 
       
   289 
       
   290         case EMTPObjectPropCodeVideoBitRate:
 
       
   291             {
 
       
   292             responseCode = EMTPRespCodeAccessDenied;
 
       
   293             }
 
       
   294             break;
 
       
   295 
       
   296         case EMTPObjectPropCodeDescription:
 
       
   297             {
 
       
   298             CMTPTypeArray*  desData = CMTPTypeArray::NewLC( EMTPTypeAUINT16 ); // + desData
 
       
   299 //            aElement.GetL( CMTPTypeObjectPropListElement::EValue, *desData );
 
       
   300             desData->SetByDesL(aElement.ArrayL(CMTPTypeObjectPropListElement::EValue));
 
       
   301             //desData(aElement.ArrayL(CMTPTypeObjectPropListElement::EValue));
 
       
   302             
       
   303             responseCode = ServiceMetaDataToWrapper( aPropCode,
 
       
   304                     *desData,
 
       
   305                     aObject );
 
       
   306             CleanupStack::PopAndDestroy( desData ); // - desData
 
       
   307             }
 
       
   308             break;
 
       
   309 
       
   310         case EMTPObjectPropCodeWidth:
 
       
   311         case EMTPObjectPropCodeHeight:
 
       
   312         case EMTPObjectPropCodeDuration:
 
       
   313         case EMTPObjectPropCodeUseCount:
 
       
   314         case EMTPObjectPropCodeSampleRate:
 
       
   315         case EMTPObjectPropCodeAudioWAVECodec:
 
       
   316         case EMTPObjectPropCodeAudioBitRate:
 
       
   317         case EMTPObjectPropCodeVideoFourCCCodec:
 
       
   318         case EMTPObjectPropCodeFramesPerThousandSeconds:
 
       
   319         case EMTPObjectPropCodeKeyFrameDistance:
 
       
   320             {
 
       
   321             TMTPTypeUint32 uint32( aElement.Uint32L( CMTPTypeObjectPropListElement::EValue ) );
 
       
   322             responseCode = ServiceMetaDataToWrapper( aPropCode,
 
       
   323                 uint32,
 
       
   324                 aObject );
 
       
   325             }
 
       
   326             break;
 
       
   327 
       
   328         case EMTPObjectPropCodeTrack:
 
       
   329         case EMTPObjectPropCodeNumberOfChannels:
 
       
   330         case EMTPObjectPropCodeScanType:
 
       
   331         case EMTPObjectPropCodeDRMStatus:
 
       
   332             {
 
       
   333             TMTPTypeUint16 uint16( aElement.Uint16L( CMTPTypeObjectPropListElement::EValue ));
 
       
   334             responseCode = ServiceMetaDataToWrapper( aPropCode,
 
       
   335                 uint16,
 
       
   336                 aObject );
 
       
   337             }
 
       
   338             break;
 
       
   339 
       
   340         case EMTPExtObjectPropCodeOmaDrmStatus:
 
       
   341             {
 
       
   342             TInt drmStatus = MmMtpDpUtility::GetDrmStatus( aObject.DesC( CMTPObjectMetaData::ESuid ) );
 
       
   343 
       
   344             if (drmStatus == EMTPDrmStatusUnknown)
 
       
   345                 {
 
       
   346                 responseCode = EMTPRespCodeAccessDenied;
 
       
   347                 }
 
       
   348             else
 
       
   349                 {
 
       
   350                 TMTPTypeUint8 newValue( aElement.Uint8L( CMTPTypeObjectPropListElement::EValue ) );
 
       
   351 
       
   352                 // there's no DB field to remember the value, so return an error
 
       
   353                 // if there's a mismatch to CAF protection status
 
       
   354                 if ( ( ( drmStatus == EMTPDrmStatusProtected) && ( newValue.Value() == 0 ) ) ||
 
       
   355                     ( ( drmStatus == EMTPDrmStatusNotProtected ) && ( newValue.Value() == 1 ) ) )
 
       
   356                     {
 
       
   357                     responseCode = EMTPRespCodeAccessDenied;
 
       
   358                     }
 
       
   359                 }
 
       
   360             }
 
       
   361             break;
 
       
   362 
       
   363         default:
 
       
   364             {
 
       
   365             User::Leave( KErrNotSupported );
 
       
   366             }
 
       
   367             break;
 
       
   368         }
 
       
   369 
       
   370     PRINT( _L( "MM MTP <= CMediaMtpDataProviderCopyObject::ServiceSetSpecificObjectPropertyL" ) );
 
       
   371 
       
   372     return responseCode;
 
       
   373     }
 
       
   374 
       
   375 // end of file
 
   232 // end of file
FCL/sf/mw/mmappfw