omadrm/drmplugins/drmrecognizer/src/RecDRM.cpp
branchRCL_3
changeset 71 1221b68b8a5f
parent 32 457cd4423b8c
child 72 1481bf457703
equal deleted inserted replaced
67:50c53e893c3f 71:1221b68b8a5f
    19 // INCLUDE FILES
    19 // INCLUDE FILES
    20 #include <apmrec.h>
    20 #include <apmrec.h>
    21 #include <apmstd.h>
    21 #include <apmstd.h>
    22 #include <ecom/ecom.h>
    22 #include <ecom/ecom.h>
    23 #include <ecom/implementationproxy.h>
    23 #include <ecom/implementationproxy.h>
    24 #include <featmgr.h>
       
    25 
    24 
    26 #include "RecDRM.h"
    25 #include "RecDRM.h"
    27 
    26 
    28 #define RECOGNIZE_KEY_CHAIN
    27 #define RECOGNIZE_KEY_CHAIN
    29 
    28 
    38 
    37 
    39 // maximum amount of buffer space we will ever use
    38 // maximum amount of buffer space we will ever use
    40 const TInt KMaxBufferLength=256;
    39 const TInt KMaxBufferLength=256;
    41 
    40 
    42 const TInt KDCFHeaderLength=3;
    41 const TInt KDCFHeaderLength=3;
    43 
       
    44 #ifdef DRM_OMA2_ENABLED
       
    45 const TInt KLengthBoxSize = 4;
    42 const TInt KLengthBoxSize = 4;
    46 const TInt KLengthBoxType = 4;
    43 const TInt KLengthBoxType = 4;
    47 const TInt KLengthBoxSize64 = 8;
    44 const TInt KLengthBoxSize64 = 8;
    48 const TInt KLengthVersion = 1;
    45 const TInt KLengthVersion = 1;
    49 const TInt KLengthFlags = 3;
    46 const TInt KLengthFlags = 3;
    51 _LIT8(KFTypPrefix, "ftyp");
    48 _LIT8(KFTypPrefix, "ftyp");
    52 _LIT8(KODFPrefix, "odcf");
    49 _LIT8(KODFPrefix, "odcf");
    53 _LIT8(KRoapTriggerElement, "roap-trigger:roapTrigger"); // before OMA spec CR, ROAP Trigger namespace prefix was roap-trigger
    50 _LIT8(KRoapTriggerElement, "roap-trigger:roapTrigger"); // before OMA spec CR, ROAP Trigger namespace prefix was roap-trigger
    54 _LIT8(KRoapTriggerElement2, "roap:roapTrigger");
    51 _LIT8(KRoapTriggerElement2, "roap:roapTrigger");
    55 _LIT8(KRoapTriggerType, "application/vnd.oma.drm.roap-trigger+xml");
    52 _LIT8(KRoapTriggerType, "application/vnd.oma.drm.roap-trigger+xml");
    56 #endif
       
    57 
    53 
    58 const TImplementationProxy ImplementationTable[] =
    54 const TImplementationProxy ImplementationTable[] =
    59         {
    55         {
    60         IMPLEMENTATION_PROXY_ENTRY(0x101F6DB8, CApaDRMRecognizer::CreateRecognizerL)
    56         IMPLEMENTATION_PROXY_ENTRY(0x101F6DB8, CApaDRMRecognizer::CreateRecognizerL)
    61         };
    57         };
    91     return;
    87     return;
    92 }
    88 }
    93 
    89 
    94 CApaDRMRecognizer::~CApaDRMRecognizer()
    90 CApaDRMRecognizer::~CApaDRMRecognizer()
    95 {
    91 {
    96     FeatureManager::UnInitializeLib();
       
    97 }
    92 }
    98 
    93 
    99 
    94 
   100 CApaDataRecognizerType* CApaDRMRecognizer::CreateRecognizerL()
    95 CApaDataRecognizerType* CApaDRMRecognizer::CreateRecognizerL()
   101 {
    96 {
   102     FeatureManager::InitializeLibL();
    97     return new (ELeave) CApaDRMRecognizer ();
   103 	return new (ELeave) CApaDRMRecognizer ();
       
   104 }
    98 }
   105 
    99 
   106 
   100 
   107 TUint CApaDRMRecognizer::PreferredBufSize()
   101 TUint CApaDRMRecognizer::PreferredBufSize()
   108 {
   102 {
   135         return;
   129         return;
   136         }
   130         }
   137 #endif
   131 #endif
   138 
   132 
   139 #ifdef DRM_OMA2_ENABLED
   133 #ifdef DRM_OMA2_ENABLED
   140 	if( FeatureManager::FeatureSupported( KFeatureIdFfOmadrm2Support ) )
   134     // Recognize ROAP Trigger
   141 	    {    
   135     if ( RecognizeRoapTrigger( aBuffer ) )
   142         // Recognize ROAP Trigger
   136         {
   143         if ( RecognizeRoapTrigger( aBuffer ) )
   137         return;
   144             {
   138         }
   145             return;
   139 
   146             }
   140     // Recognize DCFv2
   147 	
   141     if ( RecognizeODF( aBuffer ) )
   148         // Recognize DCFv2    
   142         {
   149         if ( RecognizeODF( aBuffer ) )
   143         return;
   150             {
   144         }
   151             return;
   145 #endif
   152             }
   146     // Recognize DCFv1
   153 	    }
   147     TUint8 version = aBuffer[0];
   154 #endif	
   148     TUint8 contentTypeLen = aBuffer[1];
   155 	// Recognize DCFv1
   149     TUint8 contentURILen = aBuffer[2];
   156 	TUint8 version = aBuffer[0];
       
   157 	TUint8 contentTypeLen = aBuffer[1];
       
   158 	TUint8 contentURILen = aBuffer[2];
       
   159 
   150 
   160     if ( contentTypeLen < KMinContentTypeLen || contentURILen == 0 )
   151     if ( contentTypeLen < KMinContentTypeLen || contentURILen == 0 )
   161     {
   152     {
   162         return;
   153         return;
   163     }
   154     }
   184 }
   175 }
   185 
   176 
   186 #ifdef DRM_OMA2_ENABLED
   177 #ifdef DRM_OMA2_ENABLED
   187 TBool CApaDRMRecognizer::RecognizeRoapTrigger( const TDesC8& aBuffer )
   178 TBool CApaDRMRecognizer::RecognizeRoapTrigger( const TDesC8& aBuffer )
   188 {
   179 {
   189         if( ! ( FeatureManager::FeatureSupported( 
       
   190                 KFeatureIdFfOmadrm2Support ) ) )
       
   191             {
       
   192             return EFalse;
       
   193             }
       
   194         
       
   195         if ( aBuffer.FindF( KRoapTriggerElement() ) != KErrNotFound
   180         if ( aBuffer.FindF( KRoapTriggerElement() ) != KErrNotFound
   196              || aBuffer.FindF( KRoapTriggerElement2() ) != KErrNotFound )
   181              || aBuffer.FindF( KRoapTriggerElement2() ) != KErrNotFound )
   197         {
   182         {
   198             iConfidence = ECertain;
   183             iConfidence = ECertain;
   199             iDataType=TDataType( KRoapTriggerType() );
   184             iDataType=TDataType( KRoapTriggerType() );
   202     return EFalse;
   187     return EFalse;
   203 }
   188 }
   204 
   189 
   205 TBool CApaDRMRecognizer::RecognizeODF( const TDesC8& aBuffer )
   190 TBool CApaDRMRecognizer::RecognizeODF( const TDesC8& aBuffer )
   206 {
   191 {
   207     
   192     if ( aBuffer.Size() < 24 ) return EFalse;
   208     if( ! ( FeatureManager::FeatureSupported(
   193     TPtrC8 ftypPrefix = aBuffer.Mid( 4, KFTypPrefix().Length() );
   209             KFeatureIdFfOmadrm2Support ) ) )
   194     if ( KFTypPrefix().CompareF( ftypPrefix ) == KErrNone )
   210         {
   195     {
   211         return EFalse;
   196         TPtrC8 odfPrefix = aBuffer.Mid( 8, KODFPrefix().Length() );
   212         }
   197         if ( KODFPrefix().CompareF( odfPrefix ) == KErrNone )
   213     
   198         {
   214 	if ( aBuffer.Size() < 24 ) return EFalse;
   199             TBuf8<4> buffer;
   215 	TPtrC8 ftypPrefix = aBuffer.Mid( 4, KFTypPrefix().Length() );
   200             TUint32 size;
   216 	if ( KFTypPrefix().CompareF( ftypPrefix ) == KErrNone )
   201             TPtr8 ptr(NULL, 0);
   217 	{
   202             TUint32 offset(20);
   218 		TPtrC8 odfPrefix = aBuffer.Mid( 8, KODFPrefix().Length() );
   203 
   219 		if ( KODFPrefix().CompareF( odfPrefix ) == KErrNone )
   204             // ODRM box header
   220 		{
   205             buffer.Zero();
   221 			TBuf8<4> buffer;
   206             buffer.Copy( aBuffer.Mid( offset, 4 ));
   222     		TUint32 size;
   207             size = ReadUint32FromBlock( buffer, 0 );
   223     		TPtr8 ptr(NULL, 0);
   208             offset += KLengthBoxSize + KLengthBoxType + KLengthVersion + KLengthFlags;
   224     		TUint32 offset(20);
   209 
   225     
   210             if (size == 1)
   226     		// ODRM box header
   211             {
   227     		buffer.Zero();
   212                 offset += KLengthBoxSize64;
   228     		buffer.Copy( aBuffer.Mid( offset, 4 ));
   213             }
   229     		size = ReadUint32FromBlock( buffer, 0 );
   214             if ( aBuffer.Size() < offset+4 ) return EFalse;
   230     		offset += KLengthBoxSize + KLengthBoxType + KLengthVersion + KLengthFlags;
   215 
   231     		
   216             // Discrete headers box header
   232     		if (size == 1)
   217             buffer.Zero();
   233         	{
   218             buffer.Copy( aBuffer.Mid( offset, 4 ));
   234         		offset += KLengthBoxSize64;
   219             size = ReadUint32FromBlock( buffer, 0 );
   235         	}
   220             offset += KLengthBoxSize + KLengthBoxType + KLengthVersion + KLengthFlags;
   236     		if ( aBuffer.Size() < offset+4 ) return EFalse;
   221             if ( size == 1 )
   237     		
   222             {
   238     		// Discrete headers box header
   223                 offset += KLengthBoxSize64;
   239     		buffer.Zero();
   224             }
   240     		buffer.Copy( aBuffer.Mid( offset, 4 ));
   225             if ( aBuffer.Size() < offset+1 ) return EFalse;
   241     		size = ReadUint32FromBlock( buffer, 0 );
   226 
   242     		offset += KLengthBoxSize + KLengthBoxType + KLengthVersion + KLengthFlags;
   227             // Content type
   243     		if ( size == 1 )
   228             buffer.Zero();
   244         	{
   229             buffer.Copy( aBuffer.Mid( offset, 1 ));
   245         		offset += KLengthBoxSize64;
   230             if ( aBuffer.Size() < offset + 1 + buffer[0] ) return EFalse;
   246         	}
   231             TPtrC8 mimeType = aBuffer.Mid( offset+1, buffer[0] );
   247     		if ( aBuffer.Size() < offset+1 ) return EFalse;
   232 
   248     		
   233             iConfidence = ECertain;
   249     		// Content type
   234             iDataType=TDataType( mimeType );
   250     		buffer.Zero();
   235             return ETrue;
   251     		buffer.Copy( aBuffer.Mid( offset, 1 ));
   236         }
   252     		if ( aBuffer.Size() < offset + 1 + buffer[0] ) return EFalse;
   237 
   253     		TPtrC8 mimeType = aBuffer.Mid( offset+1, buffer[0] );
   238     }
   254    			
   239     return EFalse;
   255    			iConfidence = ECertain;
       
   256 			iDataType=TDataType( mimeType );
       
   257 			return ETrue;
       
   258 		}
       
   259 		
       
   260 	}
       
   261 	return EFalse;
       
   262 }
   240 }
   263 #endif
   241 #endif
   264 
   242 
   265 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
   243 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
   266     {
   244     {