diff -r 000000000000 -r 522cd55cc3d7 locationcentre/lcserver/src/lcregistry.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/locationcentre/lcserver/src/lcregistry.cpp Tue Feb 02 00:16:03 2010 +0200 @@ -0,0 +1,987 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Location Centre Server object. +* +*/ + + +// SYSTEM INCLUDES +#include +#include +#include // CDocumentHandler +#include + +// USER INCLUDES +#include "lcregistry.h" +#include "lcregistrationparser.h" +#include "lcregistryupdate.h" +#include "lcregistrationupdatenotifier.h" +#include "lcregapporder.h" +#include "lcregistryobserver.h" +#include "lcregappinfo.h" +#include "lcregappstore.h" +#include "lcdebug.h" + +// CONSTANT DEFINTIONS +//Forward declaration. Function for sorted ordering of appinfo array +static TInt PositionDescOrdering( const CLcRegAppInfo& aAppInfo1, + const CLcRegAppInfo& aAppInfo2 ); + + + +// ----- Member funtions for CLcRegistry --------------------------------- + +// --------------------------------------------------------------------------- +// CLcRegistry::CLcRegistry +// --------------------------------------------------------------------------- +// +CLcRegistry::CLcRegistry( MLcRegistryObserver& aRegistryObserver ) + :CActive(EPriorityStandard), + iRegistryObserver( aRegistryObserver ) + { + // C++ Default constructor. No allocations or functions which can Leave + // should be called from here.Initiallize all the variable here + } + +// --------------------------------------------------------------------------- +// CLcRegistry::~CLcRegistry +// --------------------------------------------------------------------------- +// +CLcRegistry::~CLcRegistry() + { + Cancel(); + + // C++ Destructor. Free all resources associated with this class. + delete iLcRegUpdate; + delete iRegAppStore; + delete iLcRegAppOrder; + + //close the file server session. + iFs.Close(); + // free filename array memory + iFileNameArry.Reset(); + iFileNameArry.Close(); + + //delete all items from the appinfo array. + iAppInfoArray.ResetAndDestroy(); + iAppInfoArray.Close(); + + iAppInfoNewArray.ResetAndDestroy(); + iAppInfoNewArray.Close(); + } + +// --------------------------------------------------------------------------- +// CLcRegistry* CLcRegistry::NewL +// --------------------------------------------------------------------------- +// +CLcRegistry* CLcRegistry::NewL( MLcRegistryObserver& aRegistryObserver ) + { + CLcRegistry* self = NewLC( aRegistryObserver ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CLcRegistry* CLcRegistry::NewLC +// --------------------------------------------------------------------------- +// +CLcRegistry* CLcRegistry::NewLC( MLcRegistryObserver& aRegistryObserver ) + { + // Symbian Two phased constructor. Leaves the object on the Clean-up + // stack. + CLcRegistry* self = new ( ELeave )CLcRegistry( aRegistryObserver ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// void CLcRegistry::ConstructL +// --------------------------------------------------------------------------- +// +void CLcRegistry::ConstructL() + { + // connect to file server + // and pass this session to all the class required. + User::LeaveIfError(iFs.Connect()); + + // creation of dynamic registration notifier object + iLcRegUpdate = CLcRegistryUpdate::NewL( *this, iFs); + + // creation of private info object + iRegAppStore = CLcRegAppStore::NewL(iFs); + + // creation of application order settings object + iLcRegAppOrder = CLcRegAppOrder::NewL( *iRegAppStore ); + + // reset the new applist array count here + iAppInfoNewArray.Reset(); + /* Now Check if any update needed to that list. + * To do that start all the system drive scan and collect + * all the registered file names + */ + iRegistryHasToUpdate = EFalse; + + // registered for notification in private directory from file server + iLcRegUpdate->StartFileNotifation(); + // Add it to Active scheduler + CActiveScheduler::Add( this ); + // issue the request to active scheduker + CheckForUpdationL(); + } + +// --------------------------------------------------------------------------- +// void CLcRegistry::CheckForUpdationL() +// --------------------------------------------------------------------------- +// +void CLcRegistry::CheckForUpdationL() + { + // inform registry engine that registration process is under updation + iRegistryObserver.RegistryUnderUpdation(); + // set the file count to zero + iregFileCount = 0; + + // Scan all the drives and get all the registered file names + ScanDrivesAndGetFileNameL(); + + DEBUG3("Updated File list : %d", iFileNameArry.Count(), 0, 0 ); + + // issue a request to active scheduler + IssueRequest(); + } + + +// --------------------------------------------------------------------------- +// void CLcRegistry::IssueRequest +// --------------------------------------------------------------------------- +// +void CLcRegistry::IssueRequest() + { + if(!IsActive()) + { + SetActive(); + TRequestStatus *status = &iStatus; + User::RequestComplete(status,KErrNone); + } + } + +// --------------------------------------------------------------------------- +// TInt CLcRegistry::GetAllRegisteredAppsList +// --------------------------------------------------------------------------- +// +TInt CLcRegistry::GetAllRegisteredAppsList( RPointerArray& appInfoArray ) + { + //DEBUG( "+ CLcRegistry::GetAllRegisteredAppsList"); + + TInt error = KErrNone; + if( iAppInfoArray.Count() <= 0 ) + { + error = KErrNotFound; + } + else + { + for(TInt i = 0; i < iAppInfoArray.Count(); i++) + { + // check wheather application is present + // append only present application + if( iAppInfoArray[i]->IsAppPresent() ) + { + error = appInfoArray.Append( iAppInfoArray[i] ); + if ( error ) + { + break; + } + } + } + } + DEBUG3("Get Registered Apps : %d", appInfoArray.Count(), 0, 0 ); + //DEBUG( "- CLcRegistry::GetAllRegisteredAppsList"); + return error; + } + +// --------------------------------------------------------------------------- +// TInt CLcRegistry::GetApplicationInfo +// --------------------------------------------------------------------------- +// +TInt CLcRegistry::GetApplicationInfo( const TDesC& aAppUid, + CLcBasicAppInfo*& aLcRegAppInfo ) + { + //DEBUG( "+ CLcRegistry::GetApplicationInfo"); + + for(TInt i = 0; i< iAppInfoArray.Count(); i++) + { + if( !aAppUid.Compare( iAppInfoArray[i]->Id()) && + iAppInfoArray[i]->IsAppPresent()) + { + aLcRegAppInfo = iAppInfoArray[i]; + return KErrNone; + } + } + + //DEBUG( "- CLcRegistry::GetApplicationInfo"); + + return KErrNotFound; + } + +// --------------------------------------------------------------------------- +// void CLcRegistry::HandleDynamicRegistrationL +// --------------------------------------------------------------------------- +// +void CLcRegistry::HandleDynamicRegistrationL() + { + DEBUG("+CLcRegistry::HandleDynamicRegistrationL"); + iRegistryHasToUpdate = ETrue; + CheckForUpdationL(); + } + +// --------------------------------------------------------------------------- +// void CLcService::ScanDrivesAndGetFileNameL +// --------------------------------------------------------------------------- +// +void CLcRegistry::ScanDrivesAndGetFileNameL() + { + DEBUG( "+ CLcRegistry::ScanDrivesAndGetFileNameL"); + + iFileNameArry.Reset(); + //declare the directory to be scan through + _LIT(KPriDirName, ":\\private\\10283138\\import\\" ); + TFileName srcDirName( KPriDirName ); + TDriveList dirList; + + if(iFs.DriveList( dirList ) != KErrNone) + { + return; + } + + TBuf rootDir; + //creating the CDirscan object + CDirScan* scanner = CDirScan::NewLC(iFs); + TChar driveLetter = '?'; + TDriveInfo info; + TInt error; + + //Scan for all drives in the system + TInt driveListSize = dirList.Length(); + for(TInt dir(0); dir < driveListSize; dir++) + { + error = iFs.Drive(info, dir); + if ((error == KErrNone) && + (dirList[dir] && info.iType != EMediaNotPresent)) + { + RFs::DriveToChar(dir, driveLetter); + rootDir.Zero();//Clear the previous contents + rootDir.Append(driveLetter); + rootDir.Append( srcDirName ); + + CDir *currentDir = NULL; + // Go through the files only + scanner->SetScanDataL( rootDir, KEntryAttNormal, ESortNone ); + + TRAP( error, scanner->NextL( currentDir )); + if( error ) + { + continue; + } + TInt entryCount = currentDir->Count(); + while(entryCount--) + { + TBuf lookup; + TEntry entry=( *currentDir )[entryCount]; + //Clear the previous values + lookup.Zero(); + //Append next one + lookup.Append(scanner->FullPath()); + lookup.Append(entry.iName); + //Store it in for future reference + iFileNameArry.Append(lookup); + } + delete currentDir; + } + } + CleanupStack::PopAndDestroy( scanner ); + + DEBUG( "- CLcRegistry::ScanDrivesAndGetFileNameL"); + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::RunL +// ---------------------------------------------------------------------------- +// +void CLcRegistry::RunL() + { + TUint mmcId = 0; + // This check is for if some update events come + // during registration updation going on. + if( iRegistryHasToUpdate ) + { + DEBUG( "Dynamic notification recived"); + // Add all the appinfo to current list from new created list + for( TInt i = 0; i < iAppInfoNewArray.Count(); i++ ) + { + User::LeaveIfError( iAppInfoArray.Append( iAppInfoNewArray[i] )); + } + iAppInfoNewArray.Reset(); + // end of loop set the flag as EFalse + iRegistryHasToUpdate = EFalse; + DEBUG( "Notify execute"); + IssueRequest(); + } + else + { + CLcRegAppInfo* regAppInfo = NULL; + if( iregFileCount < iFileNameArry.Count() ) + { + // Check wheather registration file name is present in the + // old registered list.If not then add as a new registration service + TBool lResult = DoesApplicationExists( iFileNameArry[ iregFileCount ], + regAppInfo ); + if ( lResult ) + { + // Check if the Application suffered an Upgrade. If its an upgrade + // then its equivalent to a new installation. + if ( IsAppUpgraded( regAppInfo->FileName())) + { + // Remove the element from the Old array + TInt index = iAppInfoArray.Find( regAppInfo ); + CLcRegAppInfo* info = iAppInfoArray[index]; + iAppInfoArray.Remove( index ); + delete info; + + // Parse new registration info validate and append it to list + TRAPD( err, regAppInfo = + CreateAppRegInfoL(iFileNameArry[ iregFileCount ])); + if( !err ) + { + CleanupStack::PushL( regAppInfo ); + InsertAppRegInfoL( regAppInfo ); + CleanupStack::Pop( regAppInfo ); + } + iregFileCount++; + IssueRequest(); + } + else + { + // Check and Set the Present status of the Application + if( !regAppInfo->IsAppPresent() && + !GetMmcId( mmcId ) && + !mmcId == regAppInfo->MmcId()) + { + // This condition is only when the Application was registered + // prior to this and was on an MMC which was not mounted + regAppInfo->SetFilePresenceStatus(ETrue); + } + + // Remove the element from the Old array + TInt index = iAppInfoArray.Find( regAppInfo ); + iAppInfoArray.Remove( index ); + // push the object to cleanup stack before calling + // InsertAppRegInfoL. + CleanupStack::PushL( regAppInfo ); + InsertAppRegInfoL( regAppInfo ); + CleanupStack::Pop( regAppInfo ); + + iregFileCount++; + IssueRequest(); + } + } + else + { + // Parse new registration info validate and append it to list + TRAPD( err, regAppInfo = + CreateAppRegInfoL( iFileNameArry[ iregFileCount ] )); + if( !err ) + { + CleanupStack::PushL( regAppInfo ); + InsertAppRegInfoL( regAppInfo ); + CleanupStack::Pop( regAppInfo ); + } + iregFileCount++; + IssueRequest(); + } + } + else + { + // After completing if part if there is any application present + // in the old array then check those application for absent or removal case. + if( iAppInfoArray.Count() > 0 ) + { + //Get current MMC id. + if( GetMmcId( mmcId ) ) + { + // Check for all Absent applications + while( iAppInfoArray.Count()) + { + regAppInfo = iAppInfoArray[0]; + iAppInfoArray.Remove( 0 ); + + if( regAppInfo->MmcId() != mmcId ) + { + regAppInfo->SetFilePresenceStatus(EFalse); + CleanupStack::PushL( regAppInfo ); + InsertAppRegInfoL( regAppInfo ); + CleanupStack::Pop( regAppInfo ); + } + else + { + iLcRegAppOrder->RemoveArrayL( regAppInfo->Id() ); + delete regAppInfo; + } + } + } + + // Check for all de-registered applications + while( iAppInfoArray.Count()) + { + regAppInfo = iAppInfoArray[0]; + iAppInfoArray.Remove( 0 ); + iLcRegAppOrder->RemoveArrayL( regAppInfo->Id() ); + delete regAppInfo; + } + } + iAppInfoArray.ResetAndDestroy(); + FinalRegistrationUpdateL(); + } + } + } + +// --------------------------------------------------------------------------- +// CLcServerShutDownTimer::RunError +// --------------------------------------------------------------------------- +// +TInt CLcRegistry::RunError( TInt aError ) + { + // Dont leave. Continue with the next operation + return aError; + } + + +// --------------------------------------------------------------------------- +// void CLcRegistry::FinalRegistrationUpdateL +// --------------------------------------------------------------------------- +// +void CLcRegistry::FinalRegistrationUpdateL() + { + // Resync all the existing applications. Their order could have been + // changed because of the possible changes in the index ordering + + // Temporary array to assist copying of all content from one place + // to another + RPointerArray tempArray; + while ( iAppInfoArray.Count()) + { + CLcRegAppInfo* info = iAppInfoArray[0]; + iAppInfoArray.Remove( 0 ); + tempArray.Append( info ); + } + + // Insert back all temporary elements back into the Info Array + TInt appcount = tempArray.Count(); + for( TInt i = 0; i < appcount; i++ ) + { + User::LeaveIfError( iAppInfoArray.Append( tempArray[i] )); + } + + // Now destroy all the elements back in the temporary array. + tempArray.ResetAndDestroy(); + tempArray.Close(); + + // Add all the appinfo to current list from new created list + appcount = iAppInfoNewArray.Count(); + for( TInt i = 0; i < appcount; i++ ) + { + User::LeaveIfError(iAppInfoArray.Append( iAppInfoNewArray[i] )); + } + iAppInfoNewArray.Reset(); + + DEBUG1("New List Count : %d", iAppInfoArray.Count()) + + // Send a notification to registry engine that updation completed + iRegistryObserver.RegistryUpdated(); + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::IsInMMc +// ---------------------------------------------------------------------------- +// +TBool CLcRegistry::IsInMMc( TFileName aFileName ) + { + TBool lResult = EFalse; + TParse parse; + parse.Set(aFileName,NULL,NULL); + TPtrC lDrive = parse.Drive(); + TInt err,mmcDrive,fileDrive; + err = RFs::CharToDrive( PathInfo::MemoryCardRootPath()[0], mmcDrive ); + if (err == KErrNone) + { + err = RFs::CharToDrive( lDrive[0], fileDrive ); + if( err == KErrNone ) + { + if( mmcDrive == fileDrive ) + { + lResult = ETrue; + } + } + } + return lResult; + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::DoesApplicationExists +// ---------------------------------------------------------------------------- +// +TBool CLcRegistry::DoesApplicationExists( TFileName aFileName, + CLcRegAppInfo*& alcRegAppInfoPtr ) + { + // This function checks wheather registration info with same file name + // is present in the old list. If present then return ETrue or else EFalse. + TInt count = iAppInfoArray.Count(); + for( TInt i = 0; i < count; i++ ) + { + alcRegAppInfoPtr = iAppInfoArray[i]; + if( alcRegAppInfoPtr ) + { + if( aFileName.Compare( alcRegAppInfoPtr->FileName()) == 0 ) + { + return ETrue; + } + } + } + return EFalse; + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::CreateAppRegInfoL +// ---------------------------------------------------------------------------- +// +CLcRegAppInfo* CLcRegistry::CreateAppRegInfoL( TFileName aFileName ) + { + DEBUG( "+ CLcRegistry::CreateAppRegInfoL" ); + + CLcRegistrationParser* regParser = CLcRegistrationParser::NewL( iFs ); + CleanupStack::PushL( regParser ); + + //Parse the file content and get all the registration info. + CLcRegAppInfo* info = regParser->ParseFileL( aFileName ); + + CleanupStack::PopAndDestroy( regParser ); + + CleanupStack::PushL( info ); + + //Check that same UUID based appinfo is already registered or not. + if( DoesSameUuidPresent( info )) + { + User::Leave( KErrAlreadyExists ); + } + + //validate the application or document + if ( info->ApplicationType() == ELcNativeApplication || + info->ApplicationType() == ELcDocument ) + { + //DEBUG("+ Validate") + ValidateRegisteredServiceL( *info ); + //DEBUG("- Validate") + } + + // Set the language specific name for the service + if( info->IsAppNamePresent()) + { + info->SetAppLangSpecificNameL(iFs); + } + else + { + SetAbsentAppNameL( info ); + } + + + // Set the file name for future reference. + info->SetFileNameL( aFileName ); + + TUint mmcId; + + //Get current MMC id. + if( !GetMmcId( mmcId ) && IsInMMc( aFileName )) + { + info->SetMmcId(mmcId); + } + + CleanupStack::Pop( info ); + + DEBUG( "- CLcRegistry::CreateAppRegInfoL" ); + return info; + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::InsertAppRegInfoL +// ---------------------------------------------------------------------------- +// +void CLcRegistry::InsertAppRegInfoL( CLcRegAppInfo* aAppInfo ) + { + TInt index = 0; + + // Get the required order of the + // service from the central repository + //Add the appinfo to array + if( iLcRegAppOrder->GetRegisteredAppOrder( aAppInfo->Id(), + index )) + { + + // this is for new regapp info addition + // to db and get the final order + index = iLcRegAppOrder->AppendArrayL( aAppInfo->Id()); + + for ( TInt i = 0; i < iAppInfoArray.Count(); i++ ) + { + // Get the new order for the respective elements and set the correct values. + CLcRegAppInfo* info = iAppInfoArray[i]; + TInt currentIndex = 0; + iLcRegAppOrder->GetRegisteredAppOrder( info->Id(), + currentIndex ); + // Set the new Index + info->SetArrayIndex( currentIndex ); + } + + // Set the index of all elements in the new array + for ( TInt i = 0; i < iAppInfoNewArray.Count(); i++ ) + { + // Get the new order for the respective elements and set the correct values. + CLcRegAppInfo* info = iAppInfoNewArray[i]; + TInt currentIndex = 0; + iLcRegAppOrder->GetRegisteredAppOrder( info->Id(), + currentIndex ); + // Set the new Index + info->SetArrayIndex( currentIndex ); + } + } + + // Set the array index + aAppInfo->SetArrayIndex( index ); + + User::LeaveIfError( + iAppInfoNewArray.InsertInOrder( aAppInfo, + PositionDescOrdering )); + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::DoesSameUuidPresent +// ---------------------------------------------------------------------------- +// +TBool CLcRegistry::DoesSameUuidPresent( CLcRegAppInfo* aLcRegAppInfo ) + { + // Check in the Old array + for( TInt i = 0; i < iAppInfoArray.Count(); i++ ) + { + CLcRegAppInfo* lcRegAppInfoPtr = iAppInfoArray[i]; + if( lcRegAppInfoPtr ) + { + if( !aLcRegAppInfo->Id().Compare( lcRegAppInfoPtr->Id())) + { + return ETrue; + } + } + } + + // Now check in the new array + for( TInt i = 0; i < iAppInfoNewArray.Count(); i++ ) + { + CLcRegAppInfo* lcRegAppInfoPtr = iAppInfoNewArray[i]; + if( lcRegAppInfoPtr ) + { + if( !aLcRegAppInfo->Id().Compare( lcRegAppInfoPtr->Id())) + { + return ETrue; + } + } + } + + // No match found + return EFalse; + } + +// ---------------------------------------------------------------------------- +// CLcRegistry::DoCancel +// ---------------------------------------------------------------------------- +// +void CLcRegistry::DoCancel() + { + Cancel(); + } + +// --------------------------------------------------------------------------- +// void CLcService::ValidateRegisteredAppL +// --------------------------------------------------------------------------- +// +void CLcRegistry::ValidateRegisteredServiceL( CLcRegAppInfo& aApplicationInfo ) + { + DEBUG( "+ CLcRegistry::ValidateRegisteredServiceL" ) + + RApaLsSession lsSession; + User::LeaveIfError( lsSession.Connect() ); + CleanupClosePushL( lsSession ); + + //Check the application type.If Application then validate it + if( aApplicationInfo.ApplicationType() == ELcNativeApplication ) + { + DEBUG("+ App Validation") + TLex lexer(aApplicationInfo.ApplicationData()); + TUint32 lAppSid = 0; + TUint limit = 0xFFFFFFFF; + User::LeaveIfError( lexer.BoundedVal(lAppSid, EHex, limit) ); + TApaAppInfo appInfo; + User::LeaveIfError( lsSession.GetAppInfo( appInfo, TUid::Uid( lAppSid ))); + DEBUG("- App Validation") + } + else if( aApplicationInfo.ApplicationType() == ELcDocument ) + { + DEBUG("+ Document Validation") + //Validate document + CDocumentHandler* documentHandler = CDocumentHandler::NewL(); + CleanupStack::PushL( documentHandler ); + // empty datatype for automatic recognization + TUint8* contentTypeString = NULL; + FindContentTypeFromFileL( lsSession, + contentTypeString, + &aApplicationInfo ); + User::LeaveIfNull( contentTypeString ); + + CleanupStack::PushL( contentTypeString ); + documentHandler->CanOpenL( TDataType( TPtrC8( contentTypeString ))); + CleanupStack::PopAndDestroy( 2, documentHandler ); + DEBUG("- Document Validation") + } + + // Now set the system characteristics for application / document / weburl + SetAppSysCharacteristicsL( lsSession, aApplicationInfo ); + + CleanupStack::PopAndDestroy(); //lsSession + + DEBUG( "- CLcRegistry::ValidateRegisteredServiceL" ) + } + + +// --------------------------------------------------------------------------- +// void CLcRegistry::FindContentTypeFromFileL +// --------------------------------------------------------------------------- +// +void CLcRegistry::FindContentTypeFromFileL( RApaLsSession apaSession, + TUint8*& aContentTypeString, + CLcRegAppInfo* aApplicationInfo ) + { + TDataRecognitionResult dataType; + TInt ret; + + // Create a buffer to hold data from the file + TInt bufferSize = 0; + TInt seekPosition = 0; + apaSession.GetMaxDataBufSize(bufferSize); + HBufC8* buffer = HBufC8::NewLC(bufferSize); + TPtr8 buf = buffer->Des(); + + RFile file; + HBufC* fileName = HBufC::NewLC( KMaxPath ); + fileName->Des().Copy(aApplicationInfo->ApplicationData()); + + ret = file.Open( iFs, + *fileName, + EFileShareAny | EFileRead ); + if( !ret ) + { + // Find current file pointer position + file.Seek(ESeekStart, seekPosition); + // Read from file + file.Read(buf); + // return file pointer to original position + file.Seek(ESeekStart, seekPosition); + // Ask the application architecture to find the file type + ret = apaSession.RecognizeData(*fileName, buf, dataType); + + if (ret == KErrNone && + (dataType.iConfidence == CApaDataRecognizerType::ECertain) || + (dataType.iConfidence == CApaDataRecognizerType::EProbable)) + { + // If the file type was found, try to match it to a known file type + TPtrC8 mimeTypePtr = dataType.iDataType.Des8(); + TInt len = mimeTypePtr.Length() + 1; + aContentTypeString = new(ELeave) TUint8 [len]; + + TPtr8 contentTypeStringPtr(aContentTypeString, len); + contentTypeStringPtr.Copy(mimeTypePtr); + contentTypeStringPtr.ZeroTerminate(); + } + file.Close(); + } + CleanupStack::PopAndDestroy(fileName); //fileName + CleanupStack::PopAndDestroy(buffer); //buffer + } + +// ----------------------------------------------------------------------------- +// CLcRegistry::MmcIdL +// Get the id of the MMC card. +// ----------------------------------------------------------------------------- +// +TInt CLcRegistry::GetMmcId( TUint& aUid ) + { + TDriveInfo info; + info.iType = EMediaNotPresent; + TInt mmcDrive; + TInt err; + TChar cha = '?'; + err = RFs::CharToDrive( PathInfo::MemoryCardRootPath()[0], mmcDrive ); + if (err == KErrNone) + { + err = iFs.Drive( info, mmcDrive ); + } + if( err != KErrNone || + info.iType == EMediaNotPresent ) + { + // MMC locked or not installed + err = KErrNotFound; + } + else + { + TVolumeInfo volumeInfo; + err = iFs.Volume( volumeInfo, mmcDrive ); + if( err == KErrNone ) + { + aUid = volumeInfo.iUniqueID; + } + } + return err; + } + + +// ---------------------------------------------------------------------------- +// CLcRegistry::SetAppSysCharacteristicsL +// ---------------------------------------------------------------------------- +// +void CLcRegistry::SetAppSysCharacteristicsL( RApaLsSession& alsSession, + CLcRegAppInfo& aRegAppInfo ) + { + TFileName fileName; + if( aRegAppInfo.ApplicationType() == ELcNativeApplication ) + { + // for application we should check + // where the binary is present + TLex lexer(aRegAppInfo.ApplicationData()); + TUint32 lAppSid = 0; + TUint limit = 0xFFFFFFFF; + User::LeaveIfError( lexer.BoundedVal(lAppSid, EHex, limit) ); + TApaAppInfo appInfo; + User::LeaveIfError( alsSession.GetAppInfo( appInfo, TUid::Uid( lAppSid ))); + // check if the dll file is in ROM or not + fileName.Copy( appInfo.iFullName ); + } + else if( aRegAppInfo.ApplicationType() == ELcDocument ) + { + // for document we should check for the document file name + fileName.Copy( aRegAppInfo.ApplicationData() ); + } + else if( aRegAppInfo.ApplicationType() == ELcWebUrl ) + { + // for web url it will be registration filename + fileName.Copy( iFileNameArry[ iregFileCount ] ); + } + + if( fileName.Length() > 0 ) + { + // parse the file name and check the drive letter + TParse parse; + parse.Set( fileName, NULL, NULL ); + TPtrC drive = parse.Drive(); + if( drive[0] == PathInfo::RomRootPath()[0] ) + { + aRegAppInfo.SetSystemCharacteristics( CLcLocationAppInfo::ESysCharRomBased); + } + else + { + aRegAppInfo.SetSystemCharacteristics( CLcLocationAppInfo::ESysCharNone); + } + } + } + +// ----------------------------------------------------------------------------- +// CLcRegistry::IsAppUpgraded +// ----------------------------------------------------------------------------- +// +TBool CLcRegistry::IsAppUpgraded( TFileName aFileName ) + { + DEBUG( "+ CLcRegistry::CheckforAppUpgrade("); + + // If filename is already there in the old list and presence + // flag also true then check the time stamp between current file and old file + TEntry oldEntry,newEntry; + TFileName newFileName = iFileNameArry[ iregFileCount ]; + iFs.Entry( aFileName, oldEntry ); + iFs.Entry( newFileName, newEntry ); + + if( oldEntry.iModified == newEntry.iModified ) + { + return EFalse; + } + else + { + return ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CLcRegistry::SetAbsentAppNameL +// ----------------------------------------------------------------------------- +// +void CLcRegistry::SetAbsentAppNameL( CLcRegAppInfo* aAppInfo ) + { + RApaLsSession lsSession; + User::LeaveIfError( lsSession.Connect() ); + CleanupClosePushL( lsSession ); + //Check the application type.If Application then validate it + if( aAppInfo->ApplicationType() == ELcNativeApplication ) + { + TLex lexer(aAppInfo->ApplicationData()); + TUint32 lAppSid = 0; + TUint limit = 0xFFFFFFFF; + User::LeaveIfError( lexer.BoundedVal(lAppSid, EHex, limit) ); + TApaAppInfo appNameInfo; + User::LeaveIfError( lsSession.GetAppInfo( appNameInfo, TUid::Uid( lAppSid ))); + aAppInfo->SetNameL(appNameInfo.iCaption); + } + else + { + aAppInfo->SetNameL( aAppInfo->ApplicationData() ); + } + CleanupStack::PopAndDestroy(); //lsSession + } + + +// --------------------------------------------------------------------------- +// static TInt PositionDescOrdering +// Ordering function for inserting the elements into the applist array. +// The ordering is done first based on the previous index. +// +// @param CLcRegAppInfo& First appinfo Element +// @param CLcRegAppInfo& Second appinfo Element +// @return 1. zero, if the two objects are equal. +// +// 2. a negative value, if the first object is less than the second. +// +// 3. a positive value, if the first object is greater than the second. +// +// --------------------------------------------------------------------------- +TInt PositionDescOrdering( const CLcRegAppInfo& aAppInfo1, + const CLcRegAppInfo& aAppInfo2 ) + { + CLcRegAppInfo* appInfo1 = const_cast< CLcRegAppInfo*>(&aAppInfo1); + CLcRegAppInfo* appInfo2 = const_cast< CLcRegAppInfo*>(&aAppInfo2); + return ( appInfo1->Index() - appInfo2->Index()); + } +//End of file +