void T_CntImageRescaler::testRescaleImageSuccefully()
{
test.Next(_L("Rescale image"));
TPath dest;
dest.Append(KDestDir());
dest.Append(_L("test.jpg"));
TTime time;
time.UniversalTime();
TRAPD(err, iRescaler->ResizeImageL(KSrcImage(), dest));
TTime time2;
time2.UniversalTime();
TInt seconds = time2.MicroSecondsFrom( time ).Int64() / 1000000;
test.Printf(_L("rescaled in %d seconds\n"), seconds);
test(err == KErrNone);
test(BaflUtils::FileExists(iFs, dest));
TEntry file;
if (iFs.Entry(dest, file) == KErrNone)
{
test(file.iSize <= KMaxImageSize);
}
}
// ---------------------------------------------------------------------------
// CAknMemorySelectionDialogMultiDrive::AddDrivePathsL
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CAknMemorySelectionDialogMultiDrive::AddDrivePathsL(
const TDesC& aRootPath,
const TDesC& aDefaultFolder
)
{
// TODO: Verify paramters if they are valid.
TInt rootPathCount=iRootPathArray.Count();
TInt result = KErrNone;
TPath path;
for ( TInt i=0;i<rootPathCount;i++ )
{
path.Copy( iRootPathArray[i] );
path.Append( aRootPath );
AknCFDUtility::AddTrailingBackslash( path );
iRootPathArray.Delete(i);
iRootPathArray.Compress();
iRootPathArray.InsertL( i, path );
path.Copy( aDefaultFolder );
AknCFDUtility::AddTrailingBackslash( path );
iDefaultFolderArray.Delete(i);
iDefaultFolderArray.Compress();
iDefaultFolderArray.InsertL( i, path );
}
return result;
}
/**
Copy or resize if need be a source image to the internal folder
@return A file path of the new destination of the rescaled image
@param aSourceFile Source image path to be resized
@param aItem Contact item to help naming the new image
*/
TPath CImageRescaler::ResizeAndCopyImage(const TDesC& aSourceFile, const CContactItem& aItem)
{
TPtrC guid = const_cast<CContactItem&>(aItem).Guid();
// Remove the old file. An empty guid means that this contact is new and
// does not have any image associated with it in the images dir
if (guid.Length())
{
TPath oldFile;
oldFile.Append(iImagesDirPath);
oldFile.Append(guid);
oldFile.Append(_L("*"));
// Remove previous file(s)
BaflUtils::DeleteFile(iFs, oldFile); // Error value not necessary
}
TPath destFile = GenerateDestPath(aSourceFile);
// Check the size of the image
if (IsImageTooLarge(aSourceFile))
{
// Resize image
TRAPD(err, ResizeImageL(aSourceFile, destFile));
if (err != KErrNone && err != KErrArgument)
{
// Copy original image to the images directory to ensure
// the contact keeps a copy of the image
if (BaflUtils::CopyFile(iFs, aSourceFile, destFile) != KErrNone)
{
destFile.Zero();
}
}
}
else
{
// Copy image to the images directory if the image is not to big
if (BaflUtils::CopyFile(iFs, aSourceFile, destFile) != KErrNone)
{
destFile.Zero();
}
}
return destFile;
}
TPath CImageRescaler::GenerateDestPath(const TDesC& aSrcPath)
{
// Image file type
TParse p;
TInt err = p.Set(aSrcPath, NULL, NULL);
TPath destFile;
if (err == KErrNone)
{
// Generate the image path
// Format <path>_timestamp_filename.ext
destFile.Append(iImagesDirPath);
destFile.Append(_L("_"));
TTime time;
time.UniversalTime();
destFile.AppendNum(time.Int64());
destFile.Append(_L("_"));
destFile.Append(p.NameAndExt());
}
return destFile;
}
// ---------------------------------------------------------------------------
// CAknMemorySelectionModelMultiDrive::UpdateDataArraysL
// ---------------------------------------------------------------------------
//
void CAknMemorySelectionModelMultiDrive::UpdateDataArraysL()
{
TDriveList driveList;
TInt driveCount;
User::LeaveIfError( DriveInfo::GetUserVisibleDrives(
iCoeEnv->FsSession(), driveList, driveCount, KDriveAttAll ) );
TPath rootPath;
TDriveNumber driveNumber;
AknCommonDialogsDynMem::TMemoryTypes memoryType;
CDesCArrayFlat* driveArray = STATIC_CAST( CDesCArrayFlat*, iDriveArray );
CDesCArrayFlat* defaultFolderArray =
STATIC_CAST( CDesCArrayFlat*, iDefaultFolderArray );
driveArray->Reset();
defaultFolderArray->Reset();
if ( iDefDriveArray != NULL && iDefDefaultFolderArray != NULL )
{
for ( TInt i = 0; i < KMaxDrives; i++ )
{
TInt driveExist = driveList[i];
if ( driveExist )
{
driveNumber = TDriveNumber( i );
rootPath.Zero();
memoryType = AknCFDUtility::DriveMemoryTypeL( driveNumber );
if( memoryType & iIncludedMedias )
{
User::LeaveIfError(
PathInfo::GetRootPath( rootPath, driveNumber ) );
}
else
{
continue;
}
TBool isUserDefined = EFalse;
// add right location even user's location with wrong sequence
for ( TInt j = 0; j < iDefDriveArray->MdcaCount(); j++ )
{
// same drive info and user's root path must under c:\data\.
// try to get the location
if ( ( *iDefDriveArray )[j].FindC( rootPath ) == 0 )
{
// Use user's root path, part of user definiens
// (lowercase) may be replaced by system rootPath
rootPath.Append( ( *iDefDriveArray )[j].Right(
( *iDefDriveArray )[j].Length() - rootPath.Length() ) );
driveArray->AppendL( rootPath );
defaultFolderArray->AppendL( ( *iDefDefaultFolderArray )[j] );
isUserDefined = ETrue;
break;
}
}
if ( !isUserDefined )
{
// user does not define location for this drive
// use the default
driveArray->AppendL( rootPath );
defaultFolderArray->AppendL( KNullDesC );
}
}
}
}
else
{
for ( TInt i=0; i<KMaxDrives; i++ )
{
TInt drive = driveList[i];
driveNumber = TDriveNumber( i );
if (drive)
{
memoryType = AknCFDUtility::DriveMemoryTypeL( driveNumber );
if( memoryType & iIncludedMedias )
{
User::LeaveIfError(
PathInfo::GetRootPath( rootPath, driveNumber ) );
driveArray->AppendL( rootPath );
defaultFolderArray->AppendL( KNullDesC );
}
}
}
}
}
LOCAL_C void TestCreateContactWithoutImagesFoldeL()
{
test.Next(_L("TestCreateContactWithoutImagesFoldeL"));
SETUP;
// Delete the images folder and all contents
TInt drive;
#ifdef __WINS__
TInt err = DriveInfo::GetDefaultDrive(DriveInfo::EDefaultPhoneMemory, drive);
#else
TInt err = DriveInfo::GetDefaultDrive(DriveInfo::EDefaultMassStorage, drive);
#endif
// Do not leave with this error. The phone does not have to have this support
if (err == KErrNone)
{
// Get the root path in this drive to create
// to create the images directory
TPath dir;
User::LeaveIfError(PathInfo::GetRootPath(dir, drive));
dir.Append(KImagesFolder);
CFileMan* fileMan = CFileMan::NewL(fs);
err = fileMan->RmDir(dir); // err not used
delete fileMan;
}
else
{
test.Printf(_L("Could not remove the images folder\n"));
return;
}
// Create an image and store an image without the images dir available
CContactItem *contact = CContactItem::NewLC(KUidContactCard);
CContactItemField *newField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCodImage);
newField->SetMapping(KUidContactFieldVCardMapUnknown);
newField->TextStorage()->SetTextL(KSrcImage());
contact->AddFieldL(*newField); // Takes ownership
CleanupStack::Pop(newField);
TContactItemId id = cntClient.CreateContactL(*contact);
CleanupStack::PopAndDestroy(contact);
// View definition to read image field
CContactItemViewDef *imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldCodImage);
contact = cntClient.ReadContactL(imageViewDef ,id);
CleanupStack::PopAndDestroy(imageViewDef); // imageViewDef
TInt index = contact->CardFields().Find(KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown);
// Test image field found
test(index != KErrNotFound);
CContactItemField& field = contact->CardFields()[index];
TPtrC imagePtr = field.TextStorage()->Text();
// Image path should not change
test(imagePtr.Compare(KSrcImage()) == 0);
cntClient.CloseContact(id);
delete contact;
TEAR_DOWN;
}
void T_CntImageRescaler::testRescaleUtility()
{
// delete the possible image directory, it must not leave
// even if the folder was not found.
TRAPD( err, TCntImageRescaleUtility::DeleteImageDirectoryL() );
test( err == KErrNone );
// path for image directory, existense of the directory is not
// checked
TPath path = TCntImageRescaleUtility::ImageDirectoryL();
test( path.Length() > 0 );
test( path.Find(KImagesFolder) != KErrNotFound );
TPath dir = TCntImageRescaleUtility::CreateImageDirectoryL();
test( dir.Length() > 0 );
test( dir.Find( KImagesFolder) != KErrNotFound );
// make a test image file (empty file)
RFs fs;
CleanupClosePushL( fs );
User::LeaveIfError( fs.Connect() );
TPath imagePath;
imagePath.Append( dir );
imagePath.Append( KImageName );
RFile file;
CleanupClosePushL(file);
User::LeaveIfError(file.Create( fs, imagePath, EFileWrite ));
CleanupStack::PopAndDestroy();
CContactItem* item = CContactItem::NewLC(KUidContactCard);
CContactItemField* field = CContactItemField::NewL( KStorageTypeText, KUidContactFieldCodImage );
field->SetMapping( KUidContactFieldVCardMapUnknown );
item->AddFieldL( *field );
// add image without GUID
TRAPD( err2, TCntImageRescaleUtility::StoreImageFieldL( *item, imagePath ) );
test( err2 == KErrNone );
// then update with GUID value
_LIT(KGuid, "guid");
TBufC<4> buffer ( KGuid );
item->SetUidStringL( buffer );
TRAPD( err3, TCntImageRescaleUtility::UpdateImageNameL( *item ) );
test( err3 == KErrNone );
CContactItemFieldSet& fields = item->CardFields();
TInt privateImageIndex = fields.Find( KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown );
test( privateImageIndex != KErrNotFound );
TPtrC fieldText = fields[privateImageIndex].TextStorage()->Text();
// how it should look like
TPath newPath;
newPath.Append( TCntImageRescaleUtility::ImageDirectoryL() );
newPath.Append( buffer );
newPath.Append( KImageName );
RDebug::Print( _L("%S"), &newPath );
RDebug::Print( _L("%S"), &fieldText );
test( newPath.Compare(fieldText) == 0 );
BaflUtils::DeleteFile( fs, newPath );
CleanupStack::PopAndDestroy(2); // item, RFs
}
