FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/src/cmtpobjectstore.cpp

equal deleted inserted replaced

-:1b39655331a3
+:6e82ae192c3a
 __FLOG_STMT(_LIT8(KComponent,"MTPObjectStore");)
 const TInt KMaxLimitCommitInEnumeration = 1024;
 const TInt KMaxLimitCommitAfterEnumeration = 256;
 const TInt KMaxLimitCompactInEnumeration = 2048;
 const TInt KMaxLimitCompactAfterEnumeration = 1024;
+const TInt KSnapshotGranularity = 128;
+CMTPObjectStore::CSnapshotWorker* CMTPObjectStore::CSnapshotWorker::NewL(CMTPObjectStore* aObjectStore, TBool aOnlyRoot)
+{
+CSnapshotWorker* self = new (ELeave) CMTPObjectStore::CSnapshotWorker(aObjectStore, aOnlyRoot);
+CleanupStack::PushL(self);
+self->ConstructL();
+CleanupStack::Pop(self);
+return self;
+}
+void CMTPObjectStore::CSnapshotWorker::RunL()
+{
+iObjectStore->CleanDBSnapshotL(iOnlyRoot);
+}
+void CMTPObjectStore::CSnapshotWorker::DoCancel()
+{
+//nothing to do
+}
+TInt CMTPObjectStore::CSnapshotWorker::RunErr()
+{
+return KErrNone;
+}
+void CMTPObjectStore::CSnapshotWorker::ActiveSelf()
+{
+TRequestStatus *status = &iStatus;
+iStatus = KRequestPending;
+User::RequestComplete(status, KErrNone);
+SetActive();
+}
+CMTPObjectStore::CSnapshotWorker::CSnapshotWorker(CMTPObjectStore* aObjectStore, TBool aOnlyRoot):
+CActive(EPriorityLow), iObjectStore(aObjectStore), iOnlyRoot(aOnlyRoot)
+{
+}
+void CMTPObjectStore::CSnapshotWorker::ConstructL()
+{
+CActiveScheduler::Add(this);
+}
 /**
 MTP object meta data store factory method.
 @return A pointer to a new CMTPObjectStore instance, ownership IS transferred.
 @leave One of the system wide error codes, if a processing failure occurs.
 */
 	delete iHandleAllocator;
 	delete iMtpDeltaDataMgr;
 	delete iDPIDStore;
 	delete iPkgIDStore;
 	delete iSentinal;
+	delete iSnapshotWorker;
 	TRAP_IGNORE(CommitTransactionL());
 	iDatabase.Compact();
 	iBatched.Close();
 	iBatched_SuidHashID.Close();
 	CloseDb();
 	reinterpret_cast<RDbTable*> (aTable)->Cancel();
 	}
 void CMTPObjectStore::InsertObjectL(CMTPObjectMetaData& aObject)
 	{
-	//_LIT(KInsert, "CMTPObjectStore::InsertObjectL");
-	//volatile TTimer t(KInsert);
 	__FLOG(_L8("InsertObjectL - Entry"));
 	iCachedHandle = 0;
 	iCachedSuidHash = 0;
 	TBool needToInsert = EFalse;
 	TBool needUpdateOwner = EFalse;
 					needUpdateOwner = ETrue;
 					}
 				delete iEnumeratingCacheObjList[found];
 				iEnumeratingCacheObjList.Remove(found);
 				}
+			__FLOG_VA(_L8("Found in Snapshot"));
 			}
 		else
 			{//This is a totally new object. insert it after check the db to prevent user wrong operation
 			handle = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));
 			if (handle == KMTPHandleNone)
 				{
 				needToInsert = ETrue;
 				}
 			else
 				{
+				aObject.SetUint(CMTPObjectMetaData::EHandle, handle);
+				needUpdateOwner = ETrue;
 				//while enumerating, we ignore the repeatedly INSERT operations.
 				//User::Leave(KErrAlreadyExists);
 				}
-			}
+			__FLOG_VA(_L8("Not Found in Snapshot"));
+			}
+		__FLOG_VA((_L8("InsertObjectL Under enmueration, needUpdateOwner %d needToInsert %d"), needUpdateOwner, needToInsert));
 		}
 	else
 		{
 		handle = HandleL(aObject.DesC(CMTPObjectMetaData::ESuid));
 		if (handle != KMTPHandleNone)
 				//Leaves if id already exists in suid map table
 			User::Leave(KErrAlreadyExists);
 			}
 		// dp is not enumerating, do a plain insert
 		needToInsert = ETrue;
+		__FLOG_VA((_L8("InsertObjectL After enmueration, needUpdateOwner %d needToInsert %d"), needUpdateOwner, needToInsert));
 		}
 	if (needToInsert)//needToInsert and needUpdateOwner can't be true at same time
 		{
 		TUint32 parentHandle(aObject.Uint(CMTPObjectMetaData::EParentHandle));
 		handle = iHandleAllocator->NextIdL(dpId);
 		}
 	}
 void CMTPObjectStore::CommitTransactionL()
 	{
+	__FLOG(_L8("CommitTransactionL Entry"));
 	if (iDatabase.InTransaction())
 		{
 		User::LeaveIfError(iDatabase.Commit());
 		}
+	__FLOG(_L8("CommitTransactionL Exit"));
 	}
 void CMTPObjectStore::InsertObjectsL(RPointerArray<CMTPObjectMetaData>& aObjects)
 	{
 	TInt count = aObjects.Count();
 	result.Set(1, highHalfPOUID);	//for the ONB
 	return result;
 	}
 void CMTPObjectStore::RemoveObjectL(const TMTPTypeUint32& aHandle)
-	{
+{
-	if (LocateByHandleL(aHandle.Value()))
+__FLOG_VA((_L8("RemoveObjectL Entry Handle = 0x%x"), aHandle.Value()));
-		{
+if (LocateByHandleL(aHandle.Value()))
-		if (iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted &&
+{
-			IsMediaFormat(iBatched.ColUint16(EObjectStoreFormatCode)))
+if (iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted &&
-			{
+IsMediaFormat(iBatched.ColUint16(EObjectStoreFormatCode)))
-			iMtpDeltaDataMgr->UpdateDeltaDataTableL(iBatched.ColInt64(EObjectStorePOUID), CMtpDeltaDataMgr::EDeleted);
+{
-			}
-		iCachedSuidHash = 0;
+iMtpDeltaDataMgr->UpdateDeltaDataTableL(iBatched.ColInt64(EObjectStorePOUID), CMtpDeltaDataMgr::EDeleted);
-		iCachedHandle = 0;
+}
-		iBatched.DeleteL();
+iCachedSuidHash = 0;
-		IncTranOpsNumL();
+iCachedHandle = 0;
-		}
-	}
+iBatched.DeleteL();
+__FLOG(_L8("RemoveObjectL From iBacthed"));
+IncTranOpsNumL();
+}
+__FLOG(_L8("RemoveObjectL Exit"));
+}
 void CMTPObjectStore::RemoveObjectL(const TDesC& aSuid)
 	{
 	if(LocateBySuidL(aSuid))
 		{
 	iCompactor = CDbCompactor::NewL(&iDatabase);
 	iMtpDeltaDataMgr = CMtpDeltaDataMgr::NewL(iDatabase);
 	iReferenceMgr = CMTPReferenceMgr::NewL(*this);
 	iDPIDStore = CMTPDPIDStore::NewL(iDatabase);
 	iPkgIDStore = CMTPPkgIDStore::NewL(iDatabase);
-	iBatched.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable);
+	User::LeaveIfError(iBatched.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
-	iBatched.SetIndex(KSQLHandleId);
+	User::LeaveIfError(iBatched.SetIndex(KSQLHandleId));
-	iBatched_SuidHashID.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable);
+	User::LeaveIfError(iBatched_SuidHashID.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
-	iBatched_SuidHashID.SetIndex(KSQLSuidHash);
+	User::LeaveIfError(iBatched_SuidHashID.SetIndex(KSQLSuidHash));
 	iHandleAllocator = CMTPHandleAllocator::NewL(*this);
-	iSentinal = CEnumertingCacheItem::NewL(0, 0, 0, 0, 0);
+	iSentinal = CEnumertingCacheItem::NewL(0, 0, 0, 0, 0, 0);
 	BeginTransactionL();
 	}
 /**
 Initialises the database, it creates the table and index if the database does not exist, otherwise,
 	User::LeaveIfError(iDatabase.Replace(iSingletons.Fs(), aFileName, KMTPFormat));
 	// Create table and index
 	CreateHandleTableL();
 	CreateHandleIndexL();
-	//This is the very very 1st time of MTP server running, therefore, all of the objects in the HandleStore should be added items
+	iUpdateDeltaDataTable = ETrue;
-	//roundtrip table will fetch the added items directly from the handlestore, do not popluate the added items to round-trip table
-	//until the enumeration is finished.
-	iUpdateDeltaDataTable = EFalse;
 	}
 /**
 Open the database with the specified database name
 @param aFileName    The name of the database to open
 	}
 TBool CMTPObjectStore::LocateByHandleL(const TUint aHandle, const TBool aReadTable /*default = ETrue*/) const
 	{
+	__FLOG_VA((_L8("LocateByHandleL - Entry aHandle 0x%x"), aHandle));
 	TBool result = EFalse;
 	if(IsInvalidHandle(aHandle))
 		{
+		__FLOG_VA((_L8("LocateByHandleL - Exit result 0x%x"), result));
 		return result;
 		}
 	if (iCachedHandle == aHandle)
 		{
+		__FLOG(_L8("CacheHit"));
 		result = ETrue;
 		}
 	else
 		{
 		if (iBatched.SeekL(aHandle))
 		}
 	if (result && aReadTable)
 		{
 		iBatched.GetL();
 		}
+	__FLOG_VA((_L8("LocateByHandleL - Exit result 0x%x"), result));
 	return result;
 	}
 TBool CMTPObjectStore::LocateBySuidL(const TDesC& aSuid) const
 	{
 				}
 			}
 		}
 	}
 void CMTPObjectStore::EstablishDBSnapshotL(TUint32 aStorageId)
-	{
+{
-	//Currently, i only do this for File DP since it is non-persistent, later, if we take the proposal that
+//Currently, i only do this for File DP since it is non-persistent, later, if we take the proposal that
-	//1. FileDP is the last DP to be enumerated.
+//1. FileDP is the last DP to be enumerated.
-	//2. FileDP will san the whole file system, and will try to enumerate all of the objects(might on behalf of another DP) if the objects is still not
+//2. FileDP will san the whole file system, and will try to enumerate all of the objects(might on behalf of another DP) if the objects is still not
-	// in the object store after all other DP finish its enumeration.
+// in the object store after all other DP finish its enumeration.
-	//3. Then notify the related DP about the newly added objects by notification API;
+//3. Then notify the related DP about the newly added objects by notification API;
-	//_LIT(KInsert, "CMTPObjectStore::EstablishDBSnapshotL");
+__FLOG(_L8("EstablishDBSnapshotL - Entry"));
-	//volatile TTimer t(KInsert);
+RDbTable temp;
-	RDbTable temp;
+CleanupClosePushL(temp);
-	CleanupClosePushL(temp);
+User::LeaveIfError(temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable));
-	temp.Open(iDatabase, KSQLHandleTableName, RDbRowSet::EUpdatable);
 if(!iCacheExist)
 {
-	TInt32 count = temp.CountL(RDbRowSet::EQuick);
+TInt32 count = temp.CountL(RDbRowSet::EQuick);
 iEnumeratingCacheObjList.ReserveL(count);
 }
-	temp.FirstL();
+temp.FirstL();
-	while (!temp.AtEnd())
-		{
+while (!temp.AtEnd())
-		temp.GetL();
+{
-if (temp.ColUint8(EObjectStoreDPFlag) == 1 && (KMTPStorageAll == aStorageId || temp.ColUint32(EObjectStoreStorageId) == aStorageId))
+temp.GetL();
-			{
+if (temp.ColUint8(EObjectStoreDPFlag) == 1
-			TUint32 handleID = temp.ColUint32(EObjectStoreHandleId);
+&& (KMTPStorageAll == aStorageId || temp.ColUint32(EObjectStoreStorageId) == aStorageId))
-			TInt64 pUID = temp.ColInt64(EObjectStorePOUID);
+{
-			iHandleAllocator->SetIdL(handleID, pUID);
+TUint32 handleID = temp.ColUint32(EObjectStoreHandleId);
-			CEnumertingCacheItem* item = CEnumertingCacheItem::NewLC(
+TUint32 parentID = temp.ColUint32(EObjectStoreParentHandle);
-					temp.ColUint32(EObjectStoreSUIDHash), handleID,
+TInt64 pUID = temp.ColInt64(EObjectStorePOUID);
-					temp.ColUint16(EObjectStoreFormatCode), pUID, temp.ColUint8(EObjectStoreDataProviderId));
+iHandleAllocator->SetIdL(handleID, pUID);
-			TInt result = iEnumeratingCacheObjList.InsertInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
+CEnumertingCacheItem* item = CEnumertingCacheItem::NewLC(
-			if (KErrAlreadyExists == result) //hash collision
+temp.ColUint32(EObjectStoreSUIDHash), handleID, parentID,
-				{
+temp.ColUint16(EObjectStoreFormatCode), pUID, temp.ColUint8(EObjectStoreDataProviderId));
-				TInt found = iEnumeratingCacheObjList.FindInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
+TInt result = iEnumeratingCacheObjList.InsertInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
-				CEnumertingCacheItem* colliItem = iEnumeratingCacheObjList[found];
+if (KErrAlreadyExists == result) //hash collision
+{
+TInt found = iEnumeratingCacheObjList.FindInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
+CEnumertingCacheItem* colliItem = iEnumeratingCacheObjList[found];
 TFileName suid;
-				if (colliItem->iSuid == NULL)
+if (colliItem->iSuid == NULL)
-					{
+{
-					if (LocateByHandleL(colliItem->iObjHandleId))
+if (LocateByHandleL(colliItem->iObjHandleId))
-					    {
+{
-					    DbColReadStreamL(iBatched, EObjectStoreSUID, suid);
+DbColReadStreamL(iBatched, EObjectStoreSUID, suid);
+colliItem->iSuid = suid.AllocL();
-					    colliItem->iSuid = suid.AllocL();
+colliItem->iSuidPtr.Set(*colliItem->iSuid);
+}
-					    colliItem->iSuidPtr.Set(*colliItem->iSuid);
+}
-					    }
-					}
 DbColReadStreamL(temp, EObjectStoreSUID, suid);
 item->iSuid = suid.AllocL();
-				item->iSuidPtr.Set(*item->iSuid);
+item->iSuidPtr.Set(*item->iSuid);
 result = iEnumeratingCacheObjList.InsertInOrder(item, TLinearOrder<CEnumertingCacheItem>(CEnumertingCacheItem::Compare));
-				}
+}
 if(result != KErrAlreadyExists)
-				{
+{
-				User::LeaveIfError(result);
+User::LeaveIfError(result);
-				}
+CleanupStack::Pop(item);
-			CleanupStack::Pop(item);
+}
-			}
+else
-		temp.NextL();
+{
-		}
+CleanupStack::PopAndDestroy(item);
-	CleanupStack::PopAndDestroy(&temp);
+}
-	iCacheExist = ETrue;
-	}
+}
+temp.NextL();
-void CMTPObjectStore::CleanDBSnapshotL()
+}
-	{
-	//For those items left in the iEnumeratingCacheObjList, remove the object entry if the DPID of the handle is not persistent. and populate the
+CleanupStack::PopAndDestroy(&temp);
-	//roundtrip table if needed.
+iCacheExist = ETrue;
-	//and then close the iEnumeratingCacheObjList to release the memory.
+__FLOG_VA((_L8("EstablishDBSnapshotL - Exit build %d items"), iEnumeratingCacheObjList.Count()));
-	//_LIT(KInsert, "CMTPObjectStore::CleanDBSnapshot");
+}
-	//volatile TTimer t(KInsert);
+/*
-	if(iCacheExist)
+* All Objects enumeration complete
-	    {
+*/
-	        iCacheExist = EFalse;
+void CMTPObjectStore::ObjectsEnumComplete()
-	    }
+{
-	else
+if(iCacheExist)
-	    return;
+{
+iCacheExist = EFalse;
-	for (TInt i = iEnumeratingCacheObjList.Count() - 1; i >= 0; i--)
+}
-		{
+iNonPersistentDPList.Close();
-		TInt rc = iNonPersistentDPList.FindInOrder(iEnumeratingCacheObjList[i]->iDpID);
+iEnumeratingCacheObjList.ResetAndDestroy();
-		if (rc != KErrNotFound)
+iUpdateDeltaDataTable = ETrue;
-			{//This is a non persistent DP.
+iMaxCommitLimit = KMaxLimitCommitAfterEnumeration;
-			RemoveObjectL(iEnumeratingCacheObjList[i]->iObjHandleId);
+iMaxCompactLimit = KMaxLimitCompactAfterEnumeration;
-			}
-		}
-	iNonPersistentDPList.Close();
-	iEnumeratingCacheObjList.ResetAndDestroy();
-	iUpdateDeltaDataTable = ETrue;
-	iMaxCommitLimit = KMaxLimitCommitAfterEnumeration;
-	iMaxCompactLimit = KMaxLimitCompactAfterEnumeration;
 CommitTransactionL();
 User::LeaveIfError(iDatabase.Compact());
 BeginTransactionL();
-	}
+}
-CMTPObjectStore::CEnumertingCacheItem::CEnumertingCacheItem(TUint32 aSuidHash, TUint32 aHandle, TUint32 aFormat, TUint64 aId, TUint8 aDpID)
+void CMTPObjectStore::CleanDBSnapshotL(TBool aOnlyRoot/* = EFalse*/)
+{
+//For those items left in the iEnumeratingCacheObjList, remove the object entry if the DPID of the handle is not persistent. and populate the
+//roundtrip table if needed.
+//and then close the iEnumeratingCacheObjList to release the memory.
+//_LIT(KInsert, "CMTPObjectStore::CleanDBSnapshot");
+//volatile TTimer t(KInsert);
+__FLOG(_L8("CleanDBSnapshotL Entry"));
+if (iSnapshotWorker == NULL)
+{
+iSnapshotCleanPos = iEnumeratingCacheObjList.Count() - 1;
+iSnapshotWorker = CSnapshotWorker::NewL(this, aOnlyRoot);
+}
+//for (TInt i = iEnumeratingCacheObjList.Count() - 1; i >= 0; i--)
+for (TInt i = 0; iSnapshotCleanPos >= 0 && i <= KSnapshotGranularity; --iSnapshotCleanPos, ++i)
+{
+if((aOnlyRoot && iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjParentId == KMTPHandleNoParent) //only root
+||(!aOnlyRoot)) //everything
+{
+TInt rc = iNonPersistentDPList.FindInOrder(iEnumeratingCacheObjList[iSnapshotCleanPos]->iDpID);
+if (rc != KErrNotFound)
+{//This is a non persistent DP.
+__FLOG_VA((_L8("Remove Object 0x%x"), iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjHandleId));
+RemoveObjectL(iEnumeratingCacheObjList[iSnapshotCleanPos]->iObjHandleId);
+}
+}
+}
+if (iSnapshotCleanPos >= 0)
+{
+iSnapshotWorker->ActiveSelf();
+}
+else
+{
+//TRequestStatus *status = &aStatus;
+//User::RequestComplete(status, KErrNone);
+iSingletons.DpController().Schedule();
+iSnapshotCleanPos = 0;
+delete iSnapshotWorker;
+iSnapshotWorker = NULL;
+}
+__FLOG(_L8("CleanDBSnapshotL Exit"));
+}
+CMTPObjectStore::CEnumertingCacheItem::CEnumertingCacheItem(TUint32 aSuidHash, TUint32 aHandle, TUint32 aParent, TUint32 aFormat, TUint64 aId, TUint8 aDpID)
 	{
 	iObjSuiIdHash = aSuidHash;
 	iObjHandleId = aHandle;
+	iObjParentId = aParent;
 	iFormatcode = aFormat;
 	iPOUID = aId;
 	iDpID = aDpID;
 	}

changeset 20	6e82ae192c3a
parent 18	1b39655331a3
child 25	48a2e0d8a4ce
child 29	3ae5cb0b4c02