262 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType ); |
267 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType ); |
263 HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() ); |
268 HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() ); |
264 mimeType8->Des().Append( mimeType ); |
269 mimeType8->Des().Append( mimeType ); |
265 |
270 |
266 // Continue to extract metadata even if fail. |
271 // Continue to extract metadata even if fail. |
267 TRAPD( metadataerror, iMetadataUtility->OpenFileL( iFile, *mimeType8 ) ); |
272 MPX_TRAPD( metadataerror, iMetadataUtility->OpenFileL( iFile, *mimeType8 ) ); |
268 MPX_DEBUG2("CMPXMetadataExtractor::CreateMediaL, error %d parsing metadata", |
|
269 metadataerror ); |
|
270 CleanupStack::PopAndDestroy( mimeType8 ); |
273 CleanupStack::PopAndDestroy( mimeType8 ); |
271 |
274 |
|
275 // Get MetadataUtility Container |
272 const CMetaDataFieldContainer& metaCont = iMetadataUtility->MetaDataFieldsL(); |
276 const CMetaDataFieldContainer& metaCont = iMetadataUtility->MetaDataFieldsL(); |
|
277 |
|
278 // Get DRM data |
|
279 // Need the protected flag from metadataUtility Container |
|
280 MPX_TRAPD( drmerror, SetDrmMediaPropertiesL( metaCont ) ); |
|
281 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL, result=%d getting drm data", |
|
282 drmerror ); |
|
283 |
|
284 // Get metadata fields |
273 TInt count( metaCont.Count() ); |
285 TInt count( metaCont.Count() ); |
274 for( TInt i=0; i<count; ++i ) |
286 for( TInt i=0; i<count; ++i ) |
275 { |
287 { |
276 TMetaDataFieldId fieldType; |
288 TMetaDataFieldId fieldType; |
277 |
289 |
279 metaCont.FieldIdAt( i, fieldType ); // get the field type |
291 metaCont.FieldIdAt( i, fieldType ); // get the field type |
280 |
292 |
281 // get the value, except for album art |
293 // get the value, except for album art |
282 if ( fieldType != EMetaDataJpeg ) |
294 if ( fieldType != EMetaDataJpeg ) |
283 { |
295 { |
284 TRAPD( err, value = metaCont.At( i, fieldType ).AllocL() ); |
296 MPX_TRAPD( err, value = metaCont.At( i, fieldType ).AllocL() ); |
285 if ( KErrNone != err ) |
297 if ( KErrNone != err ) |
286 { |
298 { |
287 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL - error = %i", err); |
299 MPX_DEBUG2("CMPXMetadataExtractor::SetMediaPropertiesL - error = %i", err); |
288 continue; |
300 continue; |
289 } |
301 } |
448 // |
460 // |
449 void CMPXMetadataExtractor::SetExtMediaPropertiesL() |
461 void CMPXMetadataExtractor::SetExtMediaPropertiesL() |
450 { |
462 { |
451 MPX_FUNC("CMPXMetadataExtractor::SetExtMediaPropertiesL()"); |
463 MPX_FUNC("CMPXMetadataExtractor::SetExtMediaPropertiesL()"); |
452 |
464 |
453 // DB Flags to set |
|
454 // |
|
455 TUint dbFlags(KMPXMediaGeneralFlagsSetOrUnsetBit); |
|
456 |
|
457 // File Path |
|
458 // |
|
459 TParsePtrC parse( iFileName ); |
|
460 iMedia->SetTextValueL( KMPXMediaGeneralUri, iFileName ); |
|
461 iMedia->SetTextValueL( KMPXMediaGeneralDrive, parse.Drive() ); |
|
462 |
|
463 // DRM Rights |
|
464 // |
|
465 CMPXMedia* drm = NULL; |
|
466 TRAPD( drmError, iDrmMediaUtility->InitL( iFileName ); |
|
467 drm = CMPXMedia::NewL( *iDrmMediaUtility->GetMediaL( KMPXMediaDrmProtected.iAttributeId | |
|
468 KMPXMediaDrmRightsStatus.iAttributeId ) ); |
|
469 ); |
|
470 |
|
471 TBool prot(EFalse); |
|
472 if( drm ) |
|
473 { |
|
474 CleanupStack::PushL( drm ); |
|
475 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL -- is a drm file"); |
|
476 if( drm->IsSupported( KMPXMediaDrmProtected ) ) |
|
477 { |
|
478 prot = drm->ValueTObjectL<TBool>( KMPXMediaDrmProtected ); |
|
479 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL protected %i", prot); |
|
480 } |
|
481 |
|
482 TMPXMediaDrmRightsStatus status(EMPXDrmRightsFull); |
|
483 if( drm->IsSupported( KMPXMediaDrmRightsStatus ) ) |
|
484 { |
|
485 status = drm->ValueTObjectL<TMPXMediaDrmRightsStatus>(KMPXMediaDrmRightsStatus); |
|
486 iMedia->SetTObjectValueL<TInt>(KMPXMediaDrmRightsStatus, status ); |
|
487 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL -- status %i", status); |
|
488 } |
|
489 |
|
490 // Set DB flags |
|
491 dbFlags |= KMPXMediaGeneralFlagsIsDrmProtected; |
|
492 if( status != EMPXDrmRightsFull && status != EMPXDrmRightsRestricted && status != EMPXDrmRightsPreview ) |
|
493 { |
|
494 dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid; |
|
495 } |
|
496 CleanupStack::PopAndDestroy( drm ); |
|
497 } |
|
498 |
|
499 // Trapped PV DRM error. If -46, we know the file has no rights |
|
500 // |
|
501 if( drmError == KErrPermissionDenied ) |
|
502 { |
|
503 dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid; |
|
504 } |
|
505 else |
|
506 { |
|
507 User::LeaveIfError( drmError ); |
|
508 } |
|
509 |
|
510 iMedia->SetTObjectValueL<TBool>( KMPXMediaDrmProtected, prot ); |
|
511 iMedia->SetTObjectValueL<TUint16>( KMPXMediaMTPDrmStatus, (TUint16)prot ); |
|
512 |
|
513 iDrmMediaUtility->Close(); |
|
514 |
|
515 // |
465 // |
516 // File Size --- The following needs MMF support |
466 // File Size --- The following needs MMF support |
517 // |
467 // |
518 TInt size( 0 ); |
468 TInt size( 0 ); |
519 if( iFileOpenError == KErrNone ) |
469 if( iFileOpenError == KErrNone ) |
520 { |
470 { |
521 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType ); |
471 const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType ); |
522 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, mimeType = %S", &mimeType); |
472 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, mimeType = %S", &mimeType); |
|
473 iFile.Size( size ); |
|
474 iMedia->SetTObjectValueL<TInt>( KMPXMediaGeneralSize, size ); |
523 |
475 |
524 // Verify if WMA, skip getting info from MMF |
476 // Verify if WMA, skip getting info from MMF |
525 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 ) |
477 if( mimeType.Compare(KWmaMimeType) == 0 || mimeType.Compare(KWmaCafMimeType) == 0 ) |
526 { |
478 { |
527 // No need to get MMF support |
479 // No need to get MMF support |
528 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, skip MMF "); |
480 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, skip MMF "); |
529 } |
481 } |
530 else |
482 else |
531 { |
483 { |
532 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, get MMF controller"); |
484 MPX_DEBUG1("CMPXMetadataExtractor::SetExtMediaPropertiesL, get MMF controller"); |
533 iFile.Size( size ); |
|
534 iMedia->SetTObjectValueL<TInt>( KMPXMediaGeneralSize, size ); |
|
535 |
|
536 // Duration, bitrate, samplerate, etc |
485 // Duration, bitrate, samplerate, etc |
537 // |
486 // |
538 if( !iMetadataOnly ) |
487 if( !iMetadataOnly ) |
539 { |
488 { |
540 TRAPD(err2, iFileInfoUtil->OpenFileL( |
489 MPX_TRAPD(err2, iFileInfoUtil->OpenFileL( |
541 iFile, |
490 iFile, |
542 iMedia->ValueText(KMPXMediaGeneralMimeType))); |
491 iMedia->ValueText(KMPXMediaGeneralMimeType))); |
543 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, file info util error %i", err2); |
492 MPX_DEBUG2("CMPXMetadataExtractor::SetExtMediaPropertiesL, file info util error %i", err2); |
544 if( KErrNone == err2 ) |
493 if( KErrNone == err2 ) |
545 { |
494 { |
742 { |
683 { |
743 const TDesC& mimeType = aMedia->ValueText( KMPXMediaGeneralMimeType ); |
684 const TDesC& mimeType = aMedia->ValueText( KMPXMediaGeneralMimeType ); |
744 MPX_DEBUG2("CMPXMetadataExtractor::ExtractAlbumArtL MimeType:%S ", &mimeType ); |
685 MPX_DEBUG2("CMPXMetadataExtractor::ExtractAlbumArtL MimeType:%S ", &mimeType ); |
745 HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() ); |
686 HBufC8* mimeType8 = HBufC8::NewLC( mimeType.Length() ); |
746 mimeType8->Des().Append( mimeType ); |
687 mimeType8->Des().Append( mimeType ); |
747 TRAP( err, iMetadataUtility->OpenFileL( path, wantedFields, *mimeType8 ) ); |
688 MPX_TRAP( err, iMetadataUtility->OpenFileL( path, wantedFields, *mimeType8 ) ); |
748 CleanupStack::PopAndDestroy( mimeType8 ); |
689 CleanupStack::PopAndDestroy( mimeType8 ); |
749 } |
690 } |
750 else |
691 else |
751 { |
692 { |
752 TRAP( err, iMetadataUtility->OpenFileL( path, wantedFields ) ); |
693 MPX_TRAP( err, iMetadataUtility->OpenFileL( path, wantedFields ) ); |
753 } |
694 } |
754 CleanupStack::PopAndDestroy( &wantedFields ); |
695 CleanupStack::PopAndDestroy( &wantedFields ); |
755 |
696 |
756 if ( !err ) |
697 if ( !err ) |
757 { |
698 { |
758 //check if can send TN request, If thumbnail creation is ongoing, wait til it is done |
699 //check if can send TN request, If thumbnail creation is ongoing, wait til it is done |
759 CheckBeforeSendRequest(); |
700 CheckBeforeSendRequest(); |
760 TRAP( err, AddMediaAlbumArtL( *aMedia, path )); |
701 MPX_TRAP( err, AddMediaAlbumArtL( *aMedia, path )); |
761 } |
702 } |
762 |
703 |
763 // Reset the utility |
704 // Reset the utility |
764 iMetadataUtility->ResetL(); |
705 iMetadataUtility->ResetL(); |
765 #ifdef ABSTRACTAUDIOALBUM_INCLUDED |
706 #ifdef ABSTRACTAUDIOALBUM_INCLUDED |
798 CThumbnailObjectSource* source = CThumbnailObjectSource::NewL( |
739 CThumbnailObjectSource* source = CThumbnailObjectSource::NewL( |
799 value8, mimeType, aFile ); |
740 value8, mimeType, aFile ); |
800 TThumbnailRequestId tnId = iTNManager->CreateThumbnails( *source ); |
741 TThumbnailRequestId tnId = iTNManager->CreateThumbnails( *source ); |
801 iArrayTNRequestId.Append( tnId ); // add thumbnail id to array |
742 iArrayTNRequestId.Append( tnId ); // add thumbnail id to array |
802 CleanupStack::Pop( value8 ); |
743 CleanupStack::Pop( value8 ); |
|
744 delete source; |
|
745 |
803 aMedia.SetTextValueL( KMPXMediaMusicOriginalAlbumArtFileName, aFile ); |
746 aMedia.SetTextValueL( KMPXMediaMusicOriginalAlbumArtFileName, aFile ); |
804 #endif // RD_MPX_TNM_INTEGRATION |
747 #endif // RD_MPX_TNM_INTEGRATION |
805 aMedia.SetTextValueL( KMPXMediaMusicAlbumArtFileName, aFile ); |
748 aMedia.SetTextValueL( KMPXMediaMusicAlbumArtFileName, aFile ); |
806 } |
749 } |
807 } |
750 } |
873 // Create media and set default data and mimetype. |
816 // Create media and set default data and mimetype. |
874 // ---------------------------------------------------------------------------- |
817 // ---------------------------------------------------------------------------- |
875 void CMPXMetadataExtractor::DoCreateMediaL() |
818 void CMPXMetadataExtractor::DoCreateMediaL() |
876 { |
819 { |
877 MPX_FUNC("CMPXMetadataExtractor::DoCreateMediaL()"); |
820 MPX_FUNC("CMPXMetadataExtractor::DoCreateMediaL()"); |
|
821 MPX_ASSERT( iMedia == NULL ); |
878 RArray<TInt> contentIDs; |
822 RArray<TInt> contentIDs; |
|
823 CleanupClosePushL( contentIDs ); |
879 contentIDs.AppendL( KMPXMediaIdGeneral ); |
824 contentIDs.AppendL( KMPXMediaIdGeneral ); |
880 contentIDs.AppendL( KMPXMediaIdAudio ); |
825 contentIDs.AppendL( KMPXMediaIdAudio ); |
881 contentIDs.AppendL( KMPXMediaIdMusic ); |
826 contentIDs.AppendL( KMPXMediaIdMusic ); |
882 contentIDs.AppendL( KMPXMediaIdDrm ); |
827 contentIDs.AppendL( KMPXMediaIdDrm ); |
883 contentIDs.AppendL( KMPXMediaIdMTP ); |
828 contentIDs.AppendL( KMPXMediaIdMTP ); |
884 iMedia = CMPXMedia::NewL( contentIDs.Array() ); |
829 iMedia = CMPXMedia::NewL( contentIDs.Array() ); |
885 contentIDs.Close(); |
830 CleanupStack::PopAndDestroy( &contentIDs ); |
886 |
831 |
887 // CMPXMedia default types |
832 // CMPXMedia default types |
888 iMedia->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, |
833 iMedia->SetTObjectValueL<TMPXGeneralType>( KMPXMediaGeneralType, |
889 EMPXItem ); |
834 EMPXItem ); |
890 iMedia->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, |
835 iMedia->SetTObjectValueL<TMPXGeneralCategory>( KMPXMediaGeneralCategory, |
1039 |
984 |
1040 // Do not change the order of the task below. |
985 // Do not change the order of the task below. |
1041 iArrayTasks.Reset(); |
986 iArrayTasks.Reset(); |
1042 if ( iFileOpenError == KErrNone ) |
987 if ( iFileOpenError == KErrNone ) |
1043 { |
988 { |
|
989 // to avoid resources contention (i.e. accessing sql, file system, etc) |
|
990 // Ordering the tasks - so no multiple tasks run at the same time |
|
991 // put the longest running task at the last (i.e. thumbnailing) |
1044 iArrayTasks.AppendL(ETaskCreateMedia); |
992 iArrayTasks.AppendL(ETaskCreateMedia); |
1045 iArrayTasks.AppendL(ETaskAddMetadata); |
993 iArrayTasks.AppendL(ETaskAddExtMetadata); // Get the MMF first |
|
994 iArrayTasks.AppendL(ETaskAddMetadata); // Get metadata & maybe drm data |
1046 iArrayTasks.AppendL(ETaskCheckBeforeSend); |
995 iArrayTasks.AppendL(ETaskCheckBeforeSend); |
1047 iArrayTasks.AppendL(ETaskAddAlbumArt); |
996 iArrayTasks.AppendL(ETaskAddAlbumArt); // Get album art / thumbnail last |
1048 iArrayTasks.AppendL(ETaskAddExtMetadata); |
|
1049 } |
997 } |
1050 else |
998 else |
1051 { |
999 { |
1052 iArrayTasks.AppendL(ETaskCreateMedia); |
1000 iArrayTasks.AppendL(ETaskCreateMedia); |
1053 iArrayTasks.AppendL(ETaskAddExtMetadata); |
1001 iArrayTasks.AppendL(ETaskAddExtMetadata); |
1073 // ---------------------------------------------------------------------------- |
1021 // ---------------------------------------------------------------------------- |
1074 void CMPXMetadataExtractor::HandleTaskTimerExpired() |
1022 void CMPXMetadataExtractor::HandleTaskTimerExpired() |
1075 { |
1023 { |
1076 MPX_FUNC("CMPXMetadataExtractor::HandleTaskTimerExpired()"); |
1024 MPX_FUNC("CMPXMetadataExtractor::HandleTaskTimerExpired()"); |
1077 |
1025 |
1078 iTaskTimer->Cancel(); |
1026 if ( iTaskTimer && iTaskTimer->IsActive() ) |
|
1027 { |
|
1028 iTaskTimer->Cancel(); |
|
1029 } |
1079 // execute task at index 0 |
1030 // execute task at index 0 |
1080 TRAPD( error, ExecuteTaskL() ); |
1031 MPX_TRAPD( error, ExecuteTaskL() ); |
1081 if ( error || iCancelled ) |
1032 if ( error || iCancelled ) |
1082 { |
1033 { |
1083 // cleanup |
1034 // cleanup |
1084 if ( iMedia != NULL ) |
1035 if ( iMedia != NULL ) |
1085 { |
1036 { |
1122 // Reset the utility |
1074 // Reset the utility |
1123 TRAP_IGNORE( iMetadataUtility->ResetL() ); |
1075 TRAP_IGNORE( iMetadataUtility->ResetL() ); |
1124 iFile.Close(); |
1076 iFile.Close(); |
1125 } |
1077 } |
1126 |
1078 |
|
1079 |
|
1080 // --------------------------------------------------------------------------- |
|
1081 // Sets DRRM media properties not returned by metadata utilities |
|
1082 // --------------------------------------------------------------------------- |
|
1083 // |
|
1084 void CMPXMetadataExtractor::SetDrmMediaPropertiesL(const CMetaDataFieldContainer& aMetaCont) |
|
1085 { |
|
1086 MPX_FUNC("CMPXMetadataExtractor::SetDrmMediaPropertiesL()"); |
|
1087 |
|
1088 TBool prot(EFalse); |
|
1089 // DB Flags to set |
|
1090 TUint dbFlags(KMPXMediaGeneralFlagsSetOrUnsetBit); |
|
1091 // Validate the objects to be used |
|
1092 MPX_ASSERT(iMedia); |
|
1093 MPX_ASSERT(iDrmMediaUtility); |
|
1094 |
|
1095 // File Path |
|
1096 TParsePtrC parse( iFileName ); |
|
1097 iMedia->SetTextValueL( KMPXMediaGeneralUri, iFileName ); |
|
1098 iMedia->SetTextValueL( KMPXMediaGeneralDrive, parse.Drive() ); |
|
1099 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL - Filename=%S", &iFileName); |
|
1100 |
|
1101 // get the protected flag from MetadataUtility Container |
|
1102 TPtrC ptr = aMetaCont.Field( EMetaDataProtected ); |
|
1103 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL -- status=%S", &ptr); |
|
1104 _LIT( KNonProtected, "0" ); |
|
1105 if ( ptr.Compare( KNonProtected ) == 0 ) |
|
1106 { |
|
1107 // this is non-protected file |
|
1108 // prot = EFalse |
|
1109 MPX_DEBUG1("CMPXMetadataExtractor::SetDrmMediaPropertiesL - non protected"); |
|
1110 iMedia->SetTObjectValueL<TBool>( KMPXMediaDrmProtected, prot ); |
|
1111 iMedia->SetTObjectValueL<TUint16>( KMPXMediaMTPDrmStatus, (TUint16)prot ); |
|
1112 } |
|
1113 else |
|
1114 { // DRM file |
|
1115 |
|
1116 // DRM Rights |
|
1117 // |
|
1118 CMPXMedia* drm = NULL; |
|
1119 MPX_TRAPD( drmError, iDrmMediaUtility->InitL( iFileName ); |
|
1120 drm = CMPXMedia::NewL( *iDrmMediaUtility->GetMediaL( KMPXMediaDrmProtected.iAttributeId | |
|
1121 KMPXMediaDrmRightsStatus.iAttributeId ) ); |
|
1122 ); |
|
1123 |
|
1124 TBool prot(EFalse); |
|
1125 if( drm ) |
|
1126 { |
|
1127 CleanupStack::PushL( drm ); |
|
1128 MPX_DEBUG1("CMPXMetadataExtractor::SetDrmMediaPropertiesL -- is a drm file"); |
|
1129 if( drm->IsSupported( KMPXMediaDrmProtected ) ) |
|
1130 { |
|
1131 prot = drm->ValueTObjectL<TBool>( KMPXMediaDrmProtected ); |
|
1132 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL protected %i", prot); |
|
1133 } |
|
1134 |
|
1135 TMPXMediaDrmRightsStatus status(EMPXDrmRightsFull); |
|
1136 if( drm->IsSupported( KMPXMediaDrmRightsStatus ) ) |
|
1137 { |
|
1138 status = drm->ValueTObjectL<TMPXMediaDrmRightsStatus>(KMPXMediaDrmRightsStatus); |
|
1139 iMedia->SetTObjectValueL<TInt>(KMPXMediaDrmRightsStatus, status ); |
|
1140 MPX_DEBUG2("CMPXMetadataExtractor::SetDrmMediaPropertiesL -- status %i", status); |
|
1141 } |
|
1142 |
|
1143 // Set DB flags |
|
1144 dbFlags |= KMPXMediaGeneralFlagsIsDrmProtected; |
|
1145 if( status != EMPXDrmRightsFull && status != EMPXDrmRightsRestricted && status != EMPXDrmRightsPreview ) |
|
1146 { |
|
1147 dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid; |
|
1148 } |
|
1149 CleanupStack::PopAndDestroy( drm ); |
|
1150 } |
|
1151 |
|
1152 // Trapped PV DRM error. If -46, we know the file has no rights |
|
1153 // |
|
1154 if( drmError == KErrPermissionDenied ) |
|
1155 { |
|
1156 dbFlags |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid; |
|
1157 } |
|
1158 else |
|
1159 { |
|
1160 User::LeaveIfError( drmError ); |
|
1161 } |
|
1162 |
|
1163 iMedia->SetTObjectValueL<TBool>( KMPXMediaDrmProtected, prot ); |
|
1164 iMedia->SetTObjectValueL<TUint16>( KMPXMediaMTPDrmStatus, (TUint16)prot ); |
|
1165 |
|
1166 iDrmMediaUtility->Close(); |
|
1167 |
|
1168 } // DRM file |
|
1169 |
|
1170 |
|
1171 // verify the file open status |
|
1172 if( iFileOpenError == KErrNotFound || iFileOpenError == KErrPathNotFound ) |
|
1173 { |
|
1174 dbFlags |= KMPXMediaGeneralFlagsIsInvalid; |
|
1175 } |
|
1176 |
|
1177 // Finally set the db flag |
|
1178 // |
|
1179 iMedia->SetTObjectValueL( KMPXMediaGeneralFlags, dbFlags ); |
|
1180 |
|
1181 } |