mtpfws/mtpfw/src/cmtpdataprovidercontroller.cpp
changeset 17 aabe5387f5ce
parent 0 d0791faffa3f
child 18 1b39655331a3
equal deleted inserted replaced
0:d0791faffa3f 17:aabe5387f5ce
   234         __ASSERT_DEBUG(aParams, User::Invariant());
   234         __ASSERT_DEBUG(aParams, User::Invariant());
   235         const TMTPNotificationParamsStorageChange* params(static_cast<const TMTPNotificationParamsStorageChange*>(aParams));
   235         const TMTPNotificationParamsStorageChange* params(static_cast<const TMTPNotificationParamsStorageChange*>(aParams));
   236         iEnumeratingStorages.AppendL(params->iStorageId);
   236         iEnumeratingStorages.AppendL(params->iStorageId);
   237         
   237         
   238         // Only schedule the operation start if there is not one currently underway.
   238         // Only schedule the operation start if there is not one currently underway.
   239         if (iEnumerationState == EEnumerated)
   239         if (iEnumerationState == EEnumeratedFulllyCompleted) 
   240             {
   240             {
   241             iNextDpId           = iDpIdDeviceDp;
   241             iNextDpId           = iDpIdDeviceDp;
   242             iEnumerationState   = EEnumeratingFrameworkObjects;
   242             iEnumerationState   = EEnumeratingFrameworkObjects;
   243             Schedule();
   243             Schedule();
   244             }
   244             }
   383 /**
   383 /**
   384 Wait for the enumeration complete.
   384 Wait for the enumeration complete.
   385 */ 
   385 */ 
   386 EXPORT_C void CMTPDataProviderController::WaitForEnumerationComplete()
   386 EXPORT_C void CMTPDataProviderController::WaitForEnumerationComplete()
   387 {
   387 {
   388 	if(EnumerateState() != CMTPDataProviderController::EEnumerated)
   388 	if((EnumerateState() < CMTPDataProviderController::EEnumeratingPhaseOneDone) && ( !iOpenSessionWaiter->IsStarted()))
   389 		{
   389 		{
   390 		iOpenSessionWaiter->Start();
   390 		iOpenSessionWaiter->Start();
   391 		}
   391 		}
   392 }
   392 }
   393 TBool CMTPDataProviderController::FreeEnumerationWaiter()
   393 TBool CMTPDataProviderController::FreeEnumerationWaiter()
   404 @param aDp The notifying data provider.
   404 @param aDp The notifying data provider.
   405 */    
   405 */    
   406 void CMTPDataProviderController::EnumerationStateChangedL(const CMTPDataProvider& aDp)
   406 void CMTPDataProviderController::EnumerationStateChangedL(const CMTPDataProvider& aDp)
   407     {
   407     {
   408     __FLOG(_L8("EnumerationStateChangedL - Entry"));
   408     __FLOG(_L8("EnumerationStateChangedL - Entry"));
       
   409     __FLOG_VA((_L8("Entry iEnumerationState: 0x%x iNextDpId: %d"), iEnumerationState, iNextDpId));
   409     switch (iEnumerationState)
   410     switch (iEnumerationState)
   410         {        
   411         {        
   411     case EEnumeratingFrameworkStorages:
   412     case EEnumeratingFrameworkStorages:
   412     	switch (aDp.ImplementationUid().iUid)
   413     	switch (aDp.ImplementationUid().iUid)
   413             {
   414             {
   461                 }
   462                 }
   462             Schedule();
   463             Schedule();
   463             break;
   464             break;
   464             
   465             
   465         case KMTPImplementationUidFileDp:
   466         case KMTPImplementationUidFileDp:
   466             iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());
   467 			// No other data providers
   467             // No other data providers
   468 			if(NeedEnumeratingPhase2())
   468             iNextDpId = 0;
   469 				{
   469             iEnumeratingStorages.Remove(0);
   470 				iEnumerationState = EEnumeratingSubDirFiles;
   470             if (iEnumeratingStorages.Count() == 0)
   471 				if(iOpenSessionWaiter->IsStarted())
   471                 {
   472 					{
   472                 // No queued enumerations.
   473 					iOpenSessionWaiter->AsyncStop();
   473                 iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL();
   474 					}
   474                 iEnumerationState   = EEnumerated;
   475 				//Schedule FildDP to enumerate the files in sub-dir
   475                 Cancel();
   476 				iNextDpId           = iDpIdFileDp;
   476                 if(iOpenSessionWaiter->IsStarted())
   477 				Schedule();
   477                     {
   478 				}
   478                     iOpenSessionWaiter->AsyncStop();
   479 			else
   479                     }
   480 				{
   480                 }
   481 				iNextDpId = 0;
   481             else
   482 				iEnumeratingStorages.Remove(0);
   482                 {
   483 				if (iEnumeratingStorages.Count() == 0)
   483                 // Queued enumerations.
   484 					{
   484                 iNextDpId           = iDpIdDeviceDp;
   485 					iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());
   485                 Schedule();
   486 					iEnumerationState   = EEnumeratedFulllyCompleted;
   486                 }
   487 					iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL();
       
   488 						
       
   489 					Cancel();
       
   490 					if(iOpenSessionWaiter->IsStarted())
       
   491 						{
       
   492 						iOpenSessionWaiter->AsyncStop();
       
   493 						}
       
   494 					}
       
   495 				else
       
   496 					{
       
   497 					// Queued enumerations.
       
   498 					iNextDpId           = iDpIdDeviceDp;
       
   499 					Schedule();
       
   500 					}
       
   501 				}
       
   502         		
   487             }
   503             }
   488         break;
   504         break;
   489         
   505         
   490     case EEnumeratingDataProviderObjects:
   506     case EEnumeratingDataProviderObjects:
   491         // Enumerate non-framework data providers concurrently.
   507         // Enumerate non-framework data providers concurrently.
   494         iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());
   510         iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());
   495 
   511 
   496         if ((iEnumeratingDps.Count() == 0) && iDpIdArrayIndex >= iDataProviderIds.Count())
   512         if ((iEnumeratingDps.Count() == 0) && iDpIdArrayIndex >= iDataProviderIds.Count())
   497             {
   513             {
   498             // Enumeration complete.
   514             // Enumeration complete.
   499             iNextDpId = 0;
       
   500             iNextDpId           = iDpIdFileDp;
   515             iNextDpId           = iDpIdFileDp;
   501             iEnumerationState   = EEnumeratingFrameworkObjects;
   516             iEnumerationState   = EEnumeratingFrameworkObjects;
       
   517             			
       
   518 			if ( ( iEnumeratingStorages.Count() > 1 ) &&(KErrNotFound != iEnumeratingStorages.Find(KMTPStorageAll)) )
       
   519 				{
       
   520 				const TUint storageid = iEnumeratingStorages[0];
       
   521 				iEnumeratingStorages.Remove(0);
       
   522 				if(KMTPStorageAll == storageid)
       
   523 					{
       
   524 					iEnumeratingStorages.Append(KMTPStorageAll);
       
   525 					}
       
   526 				
       
   527 				if(iEnumeratingStorages[0] != KMTPStorageAll)
       
   528 					{
       
   529 					iNextDpId = iDpIdDeviceDp;
       
   530 					}
       
   531 				}
   502             }
   532             }
   503         else
   533         else
   504             {
   534             {
   505             if ((iEnumeratingDps.Count() == 0) && (iEnumerationPhase != DataProviderL(iDataProviderIds[iDpIdArrayIndex]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase)))
   535             if ((iEnumeratingDps.Count() == 0) && (iEnumerationPhase != DataProviderL(iDataProviderIds[iDpIdArrayIndex]).DataProviderConfig().UintValue(MMTPDataProviderConfig::EEnumerationPhase)))
   506                 {
   536                 {
   509                 }
   539                 }
   510             }
   540             }
   511         Schedule();        
   541         Schedule();        
   512         break;
   542         break;
   513         
   543         
       
   544     case EEnumeratingSubDirFiles:
       
   545     	{
       
   546     	if(aDp.ImplementationUid().iUid == KMTPImplementationUidFileDp)
       
   547     		{
       
   548 			iSingletons.ObjectMgr().RemoveNonPersistentObjectsL(aDp.DataProviderId());
       
   549 			iNextDpId = 0;
       
   550 			iEnumeratingStorages.Remove(0);
       
   551 			if(iEnumeratingStorages.Count() == 0)
       
   552 				{
       
   553 				iSingletons.DpController().SetNeedEnumeratingPhase2(EFalse);
       
   554 				iEnumerationState   = EEnumeratedFulllyCompleted;
       
   555 				iSingletons.ObjectMgr().ObjectStore().CleanDBSnapshotL();
       
   556 				}
       
   557 			else //removable card plug in
       
   558 				{
       
   559 				iNextDpId           = iDpIdDeviceDp;
       
   560 				iEnumerationState   = EEnumeratingFrameworkObjects;
       
   561 				Schedule();
       
   562 				}
       
   563     		}
       
   564     	}
       
   565     	break;
       
   566     	
       
   567     case EEnumeratedFulllyCompleted:
   514     case EUnenumerated:
   568     case EUnenumerated:
   515     case EEnumerationStarting:
   569     case EEnumerationStarting:
   516     case EEnumerated:
   570     case EEnumeratingPhaseOneDone:
   517     default:
   571     default:
   518         __DEBUG_ONLY(User::Invariant());
   572         __DEBUG_ONLY(User::Invariant());
   519         break;
   573         break;
   520         }
   574         }
       
   575     
       
   576     __FLOG_VA((_L8("Exit iEnumerationState: 0x%x, iNextDpId: %d, UID=0x%x"), iEnumerationState, iNextDpId, aDp.ImplementationUid().iUid));
   521     __FLOG(_L8("EnumerationStateChangedL - Exit"));
   577     __FLOG(_L8("EnumerationStateChangedL - Exit"));
   522     }
   578     }
   523 
   579 
   524 void CMTPDataProviderController::DoCancel()
   580 void CMTPDataProviderController::DoCancel()
   525     {
   581     {
   554         else
   610         else
   555             {
   611             {
   556             iNextDpId           = iDpIdDeviceDp;
   612             iNextDpId           = iDpIdDeviceDp;
   557             iEnumerationState   = EEnumeratingFrameworkObjects;
   613             iEnumerationState   = EEnumeratingFrameworkObjects;
   558 	
   614 	
   559             
       
   560         
       
   561             Schedule();
   615             Schedule();
   562             }
   616             }
   563         break;
   617         break;
   564         
   618         
   565     case EEnumeratingFrameworkObjects:
   619     case EEnumeratingFrameworkObjects:
   571             //Specified storage not existed, not necessary to start enumeration on this stroage.
   625             //Specified storage not existed, not necessary to start enumeration on this stroage.
   572             //Do this check will save enumeration time, i.e. avoid unnecessary enumeration, since memory card removed before enumeration starts.
   626             //Do this check will save enumeration time, i.e. avoid unnecessary enumeration, since memory card removed before enumeration starts.
   573             iEnumeratingStorages.Remove(0);
   627             iEnumeratingStorages.Remove(0);
   574             if (iEnumeratingStorages.Count() == 0)
   628             if (iEnumeratingStorages.Count() == 0)
   575                 {
   629                 {
   576                 iEnumerationState = EEnumerated;
   630                 iEnumerationState = EEnumeratedFulllyCompleted;
   577                 }
   631                 }
   578             else
   632             else
   579                 {
   633                 {
   580                 //deal next storage
   634                 //deal next storage
   581                 iNextDpId = iDpIdDeviceDp;
   635                 iNextDpId = iDpIdDeviceDp;
   589                 {
   643                 {
   590                 if(KMTPStorageAll == storageId)
   644                 if(KMTPStorageAll == storageId)
   591                     {
   645                     {
   592                     iSingletons.ObjectMgr().ObjectStore().EstablishDBSnapshotL(storageId);
   646                     iSingletons.ObjectMgr().ObjectStore().EstablishDBSnapshotL(storageId);
   593                     }
   647                     }
   594                 else
   648                 else 
   595                     {
   649                     {
   596                     const CMTPStorageMetaData& storage(iSingletons.StorageMgr().StorageL(storageId));
   650 					const CMTPStorageMetaData& storage(iSingletons.StorageMgr().StorageL(storageId));
   597                     if(storage.Uint(CMTPStorageMetaData::EStorageSystemType) == CMTPStorageMetaData::ESystemTypeDefaultFileSystem)
   651                 	if(storage.Uint(CMTPStorageMetaData::EStorageSystemType) == CMTPStorageMetaData::ESystemTypeDefaultFileSystem)
   598                         {
   652                 		{
   599                         const RArray<TUint>& logicalIds(storage.UintArray(CMTPStorageMetaData::EStorageLogicalIds));
   653 						const RArray<TUint>& logicalIds(storage.UintArray(CMTPStorageMetaData::EStorageLogicalIds));
   600                         const TUint KCountLogicalIds(logicalIds.Count());
   654 						const TUint KCountLogicalIds(logicalIds.Count());
   601                         for (TUint i(0); (i < KCountLogicalIds); i++)
   655 						for (TUint i(0); (i < KCountLogicalIds); i++)
   602                             {
   656 							{
   603                             __FLOG_VA((_L8("Establish snapshot for storage: 0x%x"), storageId));
   657 							__FLOG_VA((_L8("Establish snapshot for storage: 0x%x"), logicalIds[i]));
   604                             iSingletons.ObjectMgr().ObjectStore().EstablishDBSnapshotL(storageId);
   658 							iSingletons.ObjectMgr().ObjectStore().EstablishDBSnapshotL(logicalIds[i]);
   605                             }
   659 							}	
   606                         }
   660                 		}
   607                     }
   661                     }
   608                 }
   662                 }
       
   663             	
   609             EnumerateDataProviderObjectsL(iNextDpId);          
   664             EnumerateDataProviderObjectsL(iNextDpId);          
   610             }
   665             }
   611         	}
   666         	}
   612         break;
   667         break;
   613         
   668         
   622             {
   677             {
   623             currentDp = iDataProviderIds[iDpIdArrayIndex++];
   678             currentDp = iDataProviderIds[iDpIdArrayIndex++];
   624             iEnumeratingDps.InsertInOrderL(currentDp);
   679             iEnumeratingDps.InsertInOrderL(currentDp);
   625             EnumerateDataProviderObjectsL(currentDp);
   680             EnumerateDataProviderObjectsL(currentDp);
   626             }
   681             }
   627         }
   682         
   628         break;
   683         __FLOG_VA((_L8("iDpIdArrayIndex = %d, KLoadedDps = %d"), iDpIdArrayIndex, KLoadedDps));
   629         
   684         }
       
   685         break;
       
   686         
       
   687     case EEnumeratingSubDirFiles:
       
   688     	{
       
   689     	EnumerateDataProviderObjectsL(iNextDpId); 
       
   690     	}
       
   691     	break;
       
   692     case EEnumeratedFulllyCompleted:
   630     case EUnenumerated:
   693     case EUnenumerated:
   631     case EEnumerated:
   694     case EEnumeratingPhaseOneDone:
   632     default:
   695     default:
   633         __DEBUG_ONLY(User::Invariant());
   696         __DEBUG_ONLY(User::Invariant());
   634         break;
   697         break;
   635         }
   698         }
   636     __FLOG(_L8("RunL - Exit"));
   699     __FLOG(_L8("RunL - Exit"));
   664     case EEnumeratingDataProviderObjects:
   727     case EEnumeratingDataProviderObjects:
   665         Panic(EMTPPanicDataProviderEnumeration);
   728         Panic(EMTPPanicDataProviderEnumeration);
   666         break;
   729         break;
   667         
   730         
   668     case EUnenumerated:
   731     case EUnenumerated:
   669     case EEnumerated:
   732     case EEnumeratingPhaseOneDone:
   670     default:
   733     default:
   671         User::Invariant();
   734         User::Invariant();
   672         break;
   735         break;
   673         }
   736         }
   674 
   737 
   707 		tMTPMode = KMTPModeMTP;
   770 		tMTPMode = KMTPModeMTP;
   708 		}
   771 		}
   709 	iMode = (TMTPOperationalMode)tMTPMode;
   772 	iMode = (TMTPOperationalMode)tMTPMode;
   710 	CreateRegistrySessionAndEntryL();
   773 	CreateRegistrySessionAndEntryL();
   711     
   774     
   712 	iFlagDb = 0;
   775 	SetNeedEnumeratingPhase2(EFalse);
   713 	
   776 	
   714     iOpenSessionWaiter = new(ELeave) CActiveSchedulerWait();
   777     iOpenSessionWaiter = new(ELeave) CActiveSchedulerWait();
   715     __FLOG(_L8("ConstructL - Exit"));
   778     __FLOG(_L8("ConstructL - Exit"));
   716     }
   779     }
   717     
   780     
  1146 		iSisEntry.Close();	
  1209 		iSisEntry.Close();	
  1147 		}
  1210 		}
  1148 	iSisSession.Close();
  1211 	iSisSession.Close();
  1149 	}
  1212 	}
  1150 
  1213 
       
  1214 EXPORT_C void CMTPDataProviderController::SetNeedEnumeratingPhase2(TBool aNeed)
       
  1215 	{
       
  1216 	__FLOG(_L8("SetNeedEnumeratingPhase2 - Entry"));
       
  1217 	__FLOG_VA((_L8("Need = %d"), aNeed)); 
       
  1218 	
       
  1219 	iNeedEnumeratingPhase2 = aNeed;
       
  1220 	
       
  1221 	__FLOG(_L8("SetNeedEnumeratingPhase2 - Exit"));
       
  1222 	}
       
  1223 
       
  1224 EXPORT_C TBool CMTPDataProviderController::NeedEnumeratingPhase2() const
       
  1225 	{
       
  1226 	return iNeedEnumeratingPhase2;
       
  1227 	}
       
  1228