mtpfws/mtpfw/dataproviders/dputility/src/rmtputility.cpp
branchRCL_3
changeset 6 ef55b168cedb
parent 2 4843bb5893b6
child 17 dbd1c5e08735
equal deleted inserted replaced
5:3673b591050c 6:ef55b168cedb
    29 
    29 
    30 #include "rmtputility.h"
    30 #include "rmtputility.h"
    31 #include "cmtpdataprovidercontroller.h"
    31 #include "cmtpdataprovidercontroller.h"
    32 #include "cmtpextensionmapping.h"
    32 #include "cmtpextensionmapping.h"
    33 #include "cmtpdataprovider.h"
    33 #include "cmtpdataprovider.h"
       
    34 #include "mtpframeworkconst.h"
    34 
    35 
    35 using namespace ContentAccess;
    36 using namespace ContentAccess;
    36 // Class constants.
    37 // Class constants.
    37 const TInt KMTPDateStringLength = 15;
    38 const TInt KMTPDateStringLength = 15;
    38 const TInt KMTPDateStringTIndex = 8;
    39 const TInt KMTPDateStringTIndex = 8;
    39 const TInt KMimeTypeMaxLength = 76;
    40 const TInt KMimeTypeMaxLength = 76;
    40 const TInt KMAXPackageIDStringLen = 32;
    41 //const TInt KMAXPackageIDStringLen = 32;
    41 
    42 
    42 _LIT( KTxtBackSlash, "\\" );
    43 _LIT( KTxtBackSlash, "\\" );
    43     
    44     
    44 _LIT( KTxtExtensionODF, ".odf" );
    45 _LIT( KTxtExtensionODF, ".odf" );
    45     
    46     
   371     TInt err = KErrNone;
   372     TInt err = KErrNone;
   372     
   373     
   373     if ( file.Ext().CompareF( KTxtExtensionODF ) == 0 )
   374     if ( file.Ext().CompareF( KTxtExtensionODF ) == 0 )
   374         {
   375         {
   375         TRAP( err, mime = OdfMimeTypeL( aFullPath ) );
   376         TRAP( err, mime = OdfMimeTypeL( aFullPath ) );
   376         }
   377         __FLOG_VA((_L("ContainerMimeType err %d mime %S"), err, mime));
   377 
   378         }
   378     return mime;
   379     return mime;
   379     }
   380     }
   380 
   381 
   381 EXPORT_C void RMTPUtility::FormatExtensionMapping()
   382 EXPORT_C void RMTPUtility::FormatExtensionMapping()
   382     {
   383     {
   384     
   385     
   385     while(count--)
   386     while(count--)
   386         {
   387         {
   387         CDesCArraySeg* FormatExtensionMapping = new (ELeave) CDesCArraySeg(4);
   388         CDesCArraySeg* FormatExtensionMapping = new (ELeave) CDesCArraySeg(4);
   388         CleanupStack::PushL(FormatExtensionMapping);
   389         CleanupStack::PushL(FormatExtensionMapping);
   389         TRAP_IGNORE(iSingleton.DpController().DataProviderByIndexL(count).Plugin().SupportedL(EFormatExtensionSets,*FormatExtensionMapping));
   390         TRAP_IGNORE(
   390         AppendFormatExtensionMapping(*FormatExtensionMapping,iSingleton.DpController().DataProviderByIndexL(count).DataProviderId());
   391         iSingleton.DpController().DataProviderByIndexL(count).Plugin().SupportedL(EFormatExtensionSets,*FormatExtensionMapping);
       
   392         AppendFormatExtensionMappingL(*FormatExtensionMapping,iSingleton.DpController().DataProviderByIndexL(count).DataProviderId());
       
   393         );
   391         CleanupStack::PopAndDestroy(FormatExtensionMapping);
   394         CleanupStack::PopAndDestroy(FormatExtensionMapping);
   392         }
   395         }
   393     }
   396     }
   394 
   397 
   395 EXPORT_C TMTPFormatCode RMTPUtility::GetFormatByExtension(const TDesC& aExtension)
   398 EXPORT_C TMTPFormatCode RMTPUtility::GetFormatByExtension(const TDesC& aExtension)
   404         }
   407         }
   405     CleanupStack::PopAndDestroy(extensionMapping);
   408     CleanupStack::PopAndDestroy(extensionMapping);
   406     return EMTPFormatCodeUndefined;
   409     return EMTPFormatCodeUndefined;
   407     }
   410     }
   408 
   411 
   409 EXPORT_C TUint32 RMTPUtility::GetDpId(const TDesC& aExtension,const TDesC& aMIMEType)
   412 EXPORT_C TUint32 RMTPUtility::GetDpIdL(const TDesC& aExtension,const TDesC& aMIMEType)
       
   413     {
       
   414     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined,aMIMEType);
       
   415     CleanupStack::PushL(extensionMapping);
       
   416     TInt  found = KErrNotFound;
       
   417     if(aMIMEType == KNullDesC)
       
   418         {
       
   419         found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::Compare));
       
   420         }
       
   421     else
       
   422         {
       
   423         found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
       
   424         }
       
   425     if ( KErrNotFound != found)
       
   426         {
       
   427         CleanupStack::PopAndDestroy(extensionMapping);
       
   428         return iFormatMappings[found]->DpId();
       
   429         }
       
   430     CleanupStack::PopAndDestroy(extensionMapping);
       
   431     return KMTPFileDPID;
       
   432     }
       
   433 
       
   434 EXPORT_C TUint16 RMTPUtility::GetSubFormatCodeL(const TDesC& aExtension,const TDesC& aMIMEType)
   410     {
   435     {
   411     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined,aMIMEType);
   436     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined,aMIMEType);
   412     CleanupStack::PushL(extensionMapping);
   437     CleanupStack::PushL(extensionMapping);
   413     TInt  found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
   438     TInt  found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
   414     if ( KErrNotFound != found)
   439     if ( KErrNotFound != found)
   415         {
   440         {
   416         CleanupStack::PopAndDestroy(extensionMapping);
   441         CleanupStack::PopAndDestroy(extensionMapping);
   417         return iFormatMappings[found]->DpId();
   442         return iFormatMappings[found]->SubFormatCode();
   418         }
   443         }
   419     CleanupStack::PopAndDestroy(extensionMapping);
   444     CleanupStack::PopAndDestroy(extensionMapping);
   420     return 255;
   445     return 0;
   421     }
   446     }
       
   447 
       
   448 EXPORT_C TMTPFormatCode RMTPUtility::GetFormatCodeByMimeTypeL(const TDesC& aExtension,const TDesC& aMIMEType)
       
   449     {
       
   450     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined,aMIMEType);
       
   451     CleanupStack::PushL(extensionMapping);
       
   452     TInt  found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
       
   453     if ( KErrNotFound != found)
       
   454         {
       
   455         CleanupStack::PopAndDestroy(extensionMapping);
       
   456         return iFormatMappings[found]->FormatCode();
       
   457         }
       
   458     CleanupStack::PopAndDestroy(extensionMapping);
       
   459     return EMTPFormatCodeUndefined;
       
   460     }
       
   461 
   422 
   462 
   423 EXPORT_C TUint RMTPUtility::GetEnumerationFlag(const TDesC& aExtension)
   463 EXPORT_C TUint RMTPUtility::GetEnumerationFlag(const TDesC& aExtension)
   424     {
   464     {
   425     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined);
   465     CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(aExtension, EMTPFormatCodeUndefined);
   426     CleanupStack::PushL(extensionMapping);
   466     CleanupStack::PushL(extensionMapping);
   556     
   596     
   557     TParsePtrC file( aFullPath );
   597     TParsePtrC file( aFullPath );
   558         
   598         
   559     if ( file.Ext().CompareF( KTxtExtensionODF ) == 0 )
   599     if ( file.Ext().CompareF( KTxtExtensionODF ) == 0 )
   560         {
   600         {
   561         RFs tempFsSession; 
   601         CContent* content = CContent::NewL( aFullPath );
   562         User::LeaveIfError(tempFsSession.Connect());     
       
   563         CleanupClosePushL(tempFsSession);
       
   564         User::LeaveIfError(tempFsSession.ShareProtected());  
       
   565         
       
   566         RFile tempFile; 
       
   567         User::LeaveIfError(tempFile.Open(tempFsSession, aFullPath, EFileRead|EFileShareAny)); 
       
   568         CleanupClosePushL(tempFile); 
       
   569         
       
   570         //CContent* content = CContent::NewL( aFullPath );
       
   571         CContent* content = CContent::NewL( tempFile );
       
   572         CleanupStack::PushL( content ); // + content
   602         CleanupStack::PushL( content ); // + content
   573         
   603         
   574         HBufC* buffer = HBufC::NewL( KMimeTypeMaxLength );
   604         HBufC* buffer = HBufC::NewL( KMimeTypeMaxLength );
   575         CleanupStack::PushL( buffer ); // + buffer
   605         CleanupStack::PushL( buffer ); // + buffer
   576         
   606         
   577         TPtr data = buffer->Des();
   607         TPtr data = buffer->Des();
   578         TInt err = content->GetStringAttribute( EMimeType, data );
   608         TInt err = content->GetStringAttribute( ContentAccess::EMimeType, data );
   579                 
       
   580         if ( err == KErrNone )
   609         if ( err == KErrNone )
   581             {
   610             {
   582             mimebuf = HBufC::New( buffer->Length() );
   611             mimebuf = HBufC::New( buffer->Length() );
   583     
   612     
   584             if (mimebuf == NULL)
   613             if (mimebuf == NULL)
   585                 {
   614                 {
   586                 User::LeaveIfError( KErrNotFound );
   615                 User::LeaveIfError( KErrNotFound );
   587                 }
   616                 }
       
   617             mimebuf->Des().Copy( *buffer );
   588             
   618             
   589             mimebuf->Des().Copy( *buffer );
       
   590             }
   619             }
   591         
   620         
   592         // leave if NULL
   621         // leave if NULL
   593         if ( mimebuf == NULL )
   622         if ( mimebuf == NULL )
   594             {
   623             {
   595             User::Leave( KErrNotFound );
   624             User::Leave( KErrNotFound );
   596             }
   625             }
   597         
   626         
   598         CleanupStack::PopAndDestroy( buffer ); // - buffer
   627         CleanupStack::PopAndDestroy( buffer ); // - buffer
   599         CleanupStack::PopAndDestroy( content ); // - content
   628         CleanupStack::PopAndDestroy( content ); // - content
   600         CleanupStack::PopAndDestroy(&tempFile); // close 
       
   601         CleanupStack::PopAndDestroy(&tempFsSession);    // close 
       
   602         }
   629         }
   603     else
   630     else
   604         {
   631         {
   605         User::Leave( KErrNotSupported );
   632         User::Leave( KErrNotSupported );
   606         }
   633         }
   607     
   634     
   608     return mimebuf;
   635     return mimebuf;
   609     }
   636     }
   610 
   637 void RMTPUtility::ParseFormatCode(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
   611 void  RMTPUtility::AppendFormatExtensionMapping(const CDesCArray& aFormatExtensionMapping,TUint32 aDpId)
   638     {
       
   639     
       
   640     TLex lex(aString.Mid(2)); //skip 0x
       
   641     TUint formatCode = EMTPFormatCodeUndefined;
       
   642     lex.Val(formatCode, EHex);
       
   643     aMapping.SetFormatCode(static_cast<TMTPFormatCode>(formatCode));
       
   644     aState = Extension;
       
   645     __FLOG_VA((_L("ParseFormatCode %S, 0x%x"), &aString, formatCode));
       
   646     }
       
   647 void RMTPUtility::ParseExtension(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
       
   648     {
       
   649     aMapping.SetExtensionL(aString);
       
   650     aState = EMimeType;
       
   651     __FLOG_VA((_L("ParseExtension %S"), &aString));
       
   652     }
       
   653 void RMTPUtility::ParseMimeType(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
       
   654     {
       
   655     aMapping.SetMIMETypeL(aString);
       
   656     aState = ESubFormatCode;
       
   657     __FLOG_VA((_L("ParseMimeType %S"), &aString));
       
   658     }
       
   659 void RMTPUtility::ParseSubFormatCode(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
       
   660     {
       
   661     iEnumFlag = 1;
       
   662     TUint32 subFormatCode = 0;
       
   663     if(aString != KNullDesC)
       
   664         {
       
   665         if(aString.Length() > 2) //temp code will remove after the correct their format string
       
   666             {
       
   667             TLex lex(aString.Mid(2)); //skip 0x
       
   668             lex.Val(subFormatCode, EHex);
       
   669             }
       
   670         else//temp code will remove after the correct their format string
       
   671             {
       
   672             TLex lex(aString);
       
   673             lex.Val(iEnumFlag, EDecimal);
       
   674             }
       
   675         }
       
   676     aMapping.SetSubFormatCode(subFormatCode);
       
   677     aState = EnumerationFlag;
       
   678     __FLOG_VA((_L("ParseSubFormatCode %S, 0x%x"), &aString, subFormatCode));
       
   679     }
       
   680 void RMTPUtility::ParseEnumerationFlag(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
       
   681     {
       
   682     TUint enumFlag = iEnumFlag;           //default is delegate to file DP
       
   683     //temp code(iEnumFlag is temp the value should be 1) will remove after the correct their format string
       
   684     if(aString != KNullDesC)
       
   685         {
       
   686         TLex lex(aString);
       
   687         lex.Val(enumFlag, EDecimal);
       
   688         }
       
   689     aMapping.SetEnumerationFlag(enumFlag);
       
   690     
       
   691     __FLOG_VA((_L8("ParseEnumerationFlag %S, %d"), &aString, enumFlag));
       
   692     aState = EParseStateEnd;
       
   693     }
       
   694 void RMTPUtility::Parse(const TDesC& aString, CMTPExtensionMapping& aMapping, TParseState& aState)
       
   695     {
       
   696     switch(aState)
       
   697         {
       
   698         case EFormatCode:
       
   699             ParseFormatCode(aString, aMapping, aState);
       
   700             break;
       
   701         case Extension:
       
   702             ParseExtension(aString, aMapping, aState);
       
   703             break;
       
   704         case EMimeType:
       
   705             ParseMimeType(aString, aMapping, aState);
       
   706             break;
       
   707         case ESubFormatCode:
       
   708             ParseSubFormatCode(aString, aMapping, aState);
       
   709             break;
       
   710         case EnumerationFlag:
       
   711             ParseEnumerationFlag(aString, aMapping, aState);
       
   712             break;
       
   713         default:
       
   714             //do nothing;
       
   715             break;
       
   716         }
       
   717     }
       
   718 
       
   719 void  RMTPUtility::AppendFormatExtensionMappingL(const CDesCArray& aFormatExtensionMapping,TUint32 aDpId)
   612     {
   720     {
   613     //Parse the descriptor formatcode,fileextension, e.g. 0x3009:mp3
   721     //Parse the descriptor formatcode,fileextension, e.g. 0x3009:mp3
   614      TBuf<KMAXPackageIDStringLen> stringSeg;
   722     //FromatCode:extension:MimeType:SubFormatCode:EnumerationFlag
   615      TInt  splitter1(0);
   723 
   616      TInt  splitter2(0);
   724     TChar spliter(':');
   617      TInt  found(0);
   725     for(TInt i=0; i < aFormatExtensionMapping.Count(); ++i)
   618      TUint formatCode = 0;
   726         {
   619      TUint isNeedFileDp = 1;
   727         CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(KNullDesC, EMTPFormatCodeUndefined);
   620      
   728       
   621      for(TInt i=0; i < aFormatExtensionMapping.Count(); ++i)
   729         TParseState state = EFormatCode;
   622          {
   730         TLex lex(aFormatExtensionMapping[i]);
   623          CMTPExtensionMapping* extensionMapping = CMTPExtensionMapping::NewL(KNullDesC, EMTPFormatCodeUndefined);
   731         lex.Mark();
   624          CleanupStack::PushL(extensionMapping);
   732         while(!lex.Eos())
   625          _LIT(KSPLITTER,":");
   733             {
   626          splitter1 = aFormatExtensionMapping[i].FindF(KSPLITTER);
   734             if(lex.Peek() == spliter)
   627          //Skip "0x", 2 is the length of "0x"
   735                 {
   628          stringSeg = aFormatExtensionMapping[i].Mid(2, 4);
   736                 Parse(lex.MarkedToken(), *extensionMapping, state);
   629          TLex lex(stringSeg);
   737                 lex.Inc(); //skip :
   630          User::LeaveIfError(lex.Val(formatCode, EHex));
   738                 lex.Mark();
   631          //Skip ":"
   739                 }
   632          stringSeg = aFormatExtensionMapping[i].Mid(splitter1 + 1);
   740             else
   633          splitter2 = stringSeg.FindF(KSPLITTER);
   741                 {
   634          if ( splitter2 == KErrNotFound )
   742                 lex.Inc(); //move to next char
   635              {
   743                 }
   636              extensionMapping->SetExtensionL(stringSeg);
   744             }
   637              }
   745         while(state < EParseStateEnd)
   638          else
   746             {
   639              {
   747             Parse(lex.MarkedToken(), *extensionMapping, state);
   640              extensionMapping->SetExtensionL(aFormatExtensionMapping[i].Mid(splitter1+1,splitter2));
   748             lex.Mark();
   641              stringSeg = stringSeg.Mid(splitter2+1);
   749             }
   642              splitter1 = stringSeg.FindF(KSPLITTER);
   750         extensionMapping->SetDpId(aDpId);
   643              if ( splitter1==KErrNotFound )
   751         if(iFormatMappings.InsertInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME)) != KErrNone)
   644                  {
   752             {
   645                  extensionMapping->SetMIMETypeL(stringSeg);
   753             delete extensionMapping;
   646                  }
   754             }
   647              else if ( splitter1==0 )
   755         }
   648                  {
   756     }
   649                  TLex lex1(stringSeg.Mid(splitter1+1));
   757 
   650                  User::LeaveIfError(lex1.Val(isNeedFileDp, EDecimal));                 
   758 
   651                  }
   759 
   652              else
       
   653                  {
       
   654                  extensionMapping->SetMIMETypeL(stringSeg.Mid(0,splitter1));
       
   655                  TLex lex2(stringSeg.Mid(splitter1+1));
       
   656                  User::LeaveIfError(lex2.Val(isNeedFileDp, EDecimal));
       
   657                  }
       
   658              
       
   659              }
       
   660 
       
   661          found = iFormatMappings.FindInOrder(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
       
   662          if (KErrNotFound == found)
       
   663              {
       
   664              extensionMapping->SetFormatCode((TMTPFormatCode)formatCode);
       
   665              extensionMapping->SetDpId(aDpId);
       
   666              extensionMapping->SetEnumerationFlag(isNeedFileDp);
       
   667              iFormatMappings.InsertInOrderL(extensionMapping, TLinearOrder<CMTPExtensionMapping>(CMTPExtensionMapping::ComparewithMIME));
       
   668              }
       
   669          CleanupStack::Pop(extensionMapping);
       
   670          }    
       
   671     }