1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Metadata engine Harverster Server client session

    15 *

    16 */

    17 

    18 #include "mdeharvestersession.h"

    19 #include "mdesessionimpl.h"

    20 #include "mdcserializationbuffer.h"

    21 #include "harvesterlog.h"

    22 

    23 EXPORT_C CMdEHarvesterSession* CMdEHarvesterSession::NewL(CMdESession& aSession)

    24 	{

    25 	CMdEHarvesterSession* self = CMdEHarvesterSession::NewLC( aSession );

    26 	CleanupStack::Pop(self);

    27 	return self;

    28 	}

    29 

    30 EXPORT_C CMdEHarvesterSession* CMdEHarvesterSession::NewLC(CMdESession& aSession)

    31 	{

    32 	CMdEHarvesterSession* self = new (ELeave) CMdEHarvesterSession( aSession );

    33 	CleanupStack::PushL(self);

    34 	self->ConstructL();

    35 	return self;

    36 	}

    37 

    38 CMdEHarvesterSession::CMdEHarvesterSession(CMdESession& aSession) : 

    39 	iSession( STATIC_CAST( CMdESessionImpl*, &aSession ) ),

    40 	iHarvestingPrioritizationSerializationBuffer( NULL )

    41 	{

    42 	}

    43 

    44 CMdEHarvesterSession::~CMdEHarvesterSession()

    45 	{

    46 	iHarvestingPrioritizationChunk.Close();

    47 	delete iHarvestingPrioritizationSerializationBuffer;

    48 	}

    49 

    50 void CMdEHarvesterSession::ConstructL()

    51 	{

    52 	}

    53 

    54 EXPORT_C void CMdEHarvesterSession::SetSession(CMdESession& aSession)

    55 {

    56 	iSession = STATIC_CAST( CMdESessionImpl*, &aSession );

    57 }

    58 

    59 EXPORT_C CMdESession& CMdEHarvesterSession::SessionRef()

    60 	{

    61 	return *iSession;

    62 	}

    63 

    64 EXPORT_C CMdESession* CMdEHarvesterSession::Session()

    65 	{

    66 	return iSession;

    67 	}

    68 

    69 EXPORT_C void CMdEHarvesterSession::AddMemoryCard(TUint32 aMediaId)

    70 	{

    71 	iSession->EngineSession().DoAddMemoryCard( aMediaId );

    72 	}

    73 

    74 EXPORT_C TBool CMdEHarvesterSession::GetMemoryCard(TUint32& aMediaId)

    75 	{

    76 	return iSession->EngineSession().DoGetMemoryCard( aMediaId );

    77 	}

    78 

    79 EXPORT_C TBool CMdEHarvesterSession::CheckMemoryCard(TUint32 aMediaId, 

    80 		TBool& aExist)

    81 	{

    82 	return iSession->EngineSession().DoCheckMemoryCard( aMediaId, aExist );

    83 	}

    84 

    85 EXPORT_C void CMdEHarvesterSession::SetMediaL(TUint32 aMediaId, TChar aDrive, 

    86 		TBool aPresentState)

    87 	{

    88 	iSession->EngineSession().DoSetMediaL( aMediaId, aDrive, aPresentState );

    89 	}

    90 

    91 EXPORT_C TBool CMdEHarvesterSession::GetMediaL(TUint32 aMediaId, TChar& aDrive, 

    92 		TBool& aPresentState)

    93 	{

    94 	return iSession->EngineSession().DoGetMediaL( aMediaId, aDrive, 

    95 			aPresentState );

    96 	}

    97 

    98 EXPORT_C void CMdEHarvesterSession::GetPresentMediasL(

    99 		RArray<TMdEMediaInfo>& aMedias)

   100 	{

   101 	iSession->EngineSession().DoGetPresentMediasL( aMedias );

   102 	}

   103 

   104 EXPORT_C TBool CMdEHarvesterSession::SetFileToPresent(TUint32 aMediaId, 

   105 		const TDesC& aUri, TMdSFileInfo& aFileInfo)

   106 	{

   107 	HBufC* uri = NULL;

   108 	uri = HBufC::New( aUri.Length() );

   109 	if( !uri )

   110 		{

   111 		return EFalse;

   112 		}

   113 

   114 	// Note: CopyLC doesn't push anything to cleanup stack

   115 	uri->Des().CopyLC( aUri );

   116 

   117 	const TBool ret = iSession->EngineSession().DoSetFileToPresent( 

   118 			aMediaId, *uri, aFileInfo );

   119 	

   120 	delete uri;

   121 

   122 	return ret;

   123 	}

   124 

   125 EXPORT_C void CMdEHarvesterSession::SetFilesToPresentL(TUint32 aMediaId, 

   126 		const RArray<TPtrC>& aUris, const RArray<TMdSFileInfo>& aFileInfos, 

   127 		RArray<TFilePresentStates>& aResults)

   128 	{

   129 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- Start" );

   130 	if( aUris.Count() != aFileInfos.Count() )

   131 		{

   132 		WRITELOG2( "CMdEHarvesterSession::SetFilesToPresentL -- Leave (%d, %d)", 

   133 				aUris.Count(), aFileInfos.Count() );

   134 		User::Leave( KErrArgument );

   135 		}

   136 

   137 	const TInt fileCount = aUris.Count();

   138 	

   139 	TInt urisSize = CMdCSerializationBuffer::KRequiredSizeForTUint32;

   140 

   141 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- Loop urisSize" );

   142 	for( TInt i = 0; i < fileCount; i++ )

   143 		{

   144 		urisSize += CMdCSerializationBuffer::RequiredSize( aUris[i] );

   145 		}

   146 

   147 	const TInt fileInfosSize = ( CMdCSerializationBuffer::KRequiredSizeForTUint32 +  

   148 					CMdCSerializationBuffer::KRequiredSizeForTInt64 ) * fileCount;

   149 	const TInt resultsSize = CMdCSerializationBuffer::KRequiredSizeForTUint8 * fileCount;

   150 

   151 	CMdCSerializationBuffer* uriBuffer = CMdCSerializationBuffer::NewLC( urisSize );

   152 	CMdCSerializationBuffer* fileInfosBuffer = CMdCSerializationBuffer::NewLC( fileInfosSize );

   153 	CMdCSerializationBuffer* resultsBuffer = CMdCSerializationBuffer::NewLC( resultsSize );

   154 

   155 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- Loop fileinfos" );

   156 	for( TInt i = 0; i < fileCount; i++ )

   157 		{

   158 		const TDesC& uri = aUris[i];

   159 		uriBuffer->InsertL( CONST_CAST(TDesC&, uri) );

   160 

   161 		fileInfosBuffer->InsertL( aFileInfos[i].iModifiedTime );

   162 		fileInfosBuffer->InsertL( aFileInfos[i].iSize );

   163 		}

   164 	

   165 	TMdSMediaIdAndCount mediaIdAndCount = {aMediaId, (TUint32)fileCount};

   166 	

   167 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- DoSetFilesToPresent start" );

   168 	TInt error = iSession->EngineSession().DoSetFilesToPresent( mediaIdAndCount, 

   169 			*uriBuffer->BufferConstPtr(), *fileInfosBuffer->BufferConstPtr(), 

   170 			*resultsBuffer->BufferPtr() );

   171 	WRITELOG1( "CMdEHarvesterSession::SetFilesToPresentL -- DoSetFilesToPresent end(%d)", error );

   172 	

   173 	User::LeaveIfError( error );

   174 

   175 	resultsBuffer->PositionL( KNoOffset );

   176 

   177 	aResults.ReserveL( fileCount );

   178 

   179 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- loop results" );

   180 	for( TInt i = 0; i < fileCount; i++ )

   181 		{

   182 		TUint8 result;

   183 		resultsBuffer->ReceiveL( result );

   184 		aResults.Append( (TFilePresentStates)result );

   185 		}

   186 

   187 	WRITELOG( "CMdEHarvesterSession::SetFilesToPresentL -- End" );

   188 	CleanupStack::PopAndDestroy( resultsBuffer );

   189 	CleanupStack::PopAndDestroy( fileInfosBuffer );

   190 	CleanupStack::PopAndDestroy( uriBuffer );

   191 	}

   192 

   193 EXPORT_C void CMdEHarvesterSession::SetFilesToNotPresent(TUint32 aMediaId)

   194 	{

   195 	// only accept correct media IDs, other are silently ignored

   196 	if( aMediaId != 0 )

   197 		{

   198 		iSession->EngineSession().DoSetFilesToNotPresent( aMediaId, EFalse );

   199 		}

   200 	}

   201 

   202 EXPORT_C void CMdEHarvesterSession::RemoveFilesNotPresent(TUint32 aMediaId)

   203 	{

   204 	iSession->EngineSession().DoRemoveFilesNotPresent( aMediaId, EFalse );

   205 	}

   206 

   207 EXPORT_C void CMdEHarvesterSession::SetFilesToNotPresent(TUint32 aMediaId, 

   208 		TBool aStartUp)

   209 	{

   210 	iSession->EngineSession().DoSetFilesToNotPresent( aMediaId, aStartUp );

   211 	}

   212 

   213 EXPORT_C void CMdEHarvesterSession::RemoveFilesNotPresent(TUint32 aMediaId, 

   214 		TBool aStartUp)

   215 	{

   216 	iSession->EngineSession().DoRemoveFilesNotPresent( aMediaId, aStartUp );

   217 	}

   218 

   219 EXPORT_C void CMdEHarvesterSession::ResetDBL()

   220 	{

   221 	#ifdef _DEBUG

   222 	iSession->EngineSession().DoResetDBL();

   223 	iSession->LoadSchemaL();

   224 	#else

   225 	User::Leave( KErrNotSupported );

   226 	#endif

   227 	}

   228 

   229 EXPORT_C void CMdEHarvesterSession::SetHarvestingPrioritizationChunkL( 

   230 		TInt aSize )

   231 	{

   232 	const TInt error = 

   233 		iHarvestingPrioritizationChunk.CreateGlobal( KNullDesC, aSize, aSize );

   234 

   235 	User::LeaveIfError( error );

   236 

   237 	iSession->EngineSession().DoSetHarvestingPrioritizationChunkL( 

   238 		iHarvestingPrioritizationChunk );

   239 

   240 	iHarvestingPrioritizationSerializationBuffer = 

   241 		CMdCSerializationBuffer::NewL( 

   242 			iHarvestingPrioritizationChunk.Base(), 

   243 			iHarvestingPrioritizationChunk.Size() );

   244 	

   245 	iHarvestingPrioritizationSerializationBuffer->PositionL( 0 );

   246 	const TInt32 initialUriCount = 0;

   247 	iHarvestingPrioritizationSerializationBuffer->InsertL( initialUriCount );

   248 	}

   249 

   250 EXPORT_C void CMdEHarvesterSession::AddHarvestingPrioritizationObserver( 

   251 		TRequestStatus& aStatus )

   252 	{

   253 	iSession->EngineSession().DoAddHarvestingPrioritizationObserver( aStatus );

   254 	}

   255 

   256 EXPORT_C TInt CMdEHarvesterSession::CancelHarvestingPrioritizationObserver()

   257 	{

   258 	return iSession->EngineSession().DoCancelHarvestingPrioritizationObserver();

   259 	}

   260 

   261 EXPORT_C TInt CMdEHarvesterSession::HarvestingPrioritizationUriCountL()

   262 	{

   263 	if( !iHarvestingPrioritizationSerializationBuffer )

   264 		{

   265 		User::Leave( KErrNotFound );

   266 		}

   267 

   268 	iHarvestingPrioritizationSerializationBuffer->PositionL( 0 );

   269 

   270 	TInt32 count = 0;

   271 	iHarvestingPrioritizationSerializationBuffer->ReceiveL( count );

   272 

   273 	return count;

   274 	}

   275 

   276 EXPORT_C HBufC* CMdEHarvesterSession::HarvestingPrioritizationUriL( 

   277 		TInt aIndex )

   278 	{

   279 	if( !iHarvestingPrioritizationSerializationBuffer )

   280 		{

   281 		User::Leave( KErrNotFound );

   282 		}

   283 

   284 	const TUint32 offsetPosition = 

   285 		CMdCSerializationBuffer::KRequiredSizeForTInt32 + 

   286 		CMdCSerializationBuffer::KRequiredSizeForTUint32 * aIndex;

   287 

   288 	iHarvestingPrioritizationSerializationBuffer->PositionL( offsetPosition );

   289 

   290 	TUint32 uriOffset = 0;

   291 	iHarvestingPrioritizationSerializationBuffer->ReceiveL( uriOffset );

   292 

   293 	iHarvestingPrioritizationSerializationBuffer->PositionL( uriOffset );

   294 

   295 	return iHarvestingPrioritizationSerializationBuffer->ReceiveDes16L();

   296 	}

   297 

   298 EXPORT_C void CMdEHarvesterSession::AutoLockL( 

   299 		RPointerArray<CMdEObject>& aObjects )

   300 	{

   301 	const TInt objectCount = aObjects.Count();

   302 	

   303 	for( TInt i = 0; i < objectCount; i++ )

   304 		{

   305 		aObjects[i]->AutoLockL();

   306 		}

   307 	}

   308 

   309 EXPORT_C void CMdEHarvesterSession::ChangePath( 

   310 		const TDesC& aOldPath, const TDesC& aNewPath, TRequestStatus& aStatus )

   311 	{

   312 	iSession->EngineSession().DoChangePath( aOldPath, aNewPath, aStatus );

   313 	}

   314 

   315 EXPORT_C void CMdEHarvesterSession::ChangeCDriveMediaId()

   316 	{

   317 	iSession->EngineSession().DoChangeCDriveMediaId();

   318 	}

   319 

   320 EXPORT_C void CMdEHarvesterSession::SetPendingL( 

   321 		const RArray<TItemId>& aObjectIds )

   322 	{

   323 	iSession->EngineSession().DoSetPendingL( aObjectIds );

   324 	}

   325 

   326 EXPORT_C void CMdEHarvesterSession::ResetPendingL( 

   327 		const RArray<TItemId>& aObjectIds )

   328 	{

   329 	iSession->EngineSession().DoResetPendingL( aObjectIds );

   330 	}

   331 

   332 EXPORT_C TInt CMdEHarvesterSession::GetPendingCount( const CMdEObjectDef* aObjectDef )

   333 	{

   334 	return iSession->EngineSession().DoGetPendingCount( aObjectDef );

   335 	}

   336 	

   337 EXPORT_C TInt CMdEHarvesterSession::GetPending( 

   338 		const CMdEObjectDef* aObjectDef, TInt& aObjectIdCount, 

   339 		CMdCSerializationBuffer& aObjectIdBuffer )

   340 	{

   341 	return iSession->EngineSession().DoGetPending( aObjectDef, aObjectIdCount, 

   342 			aObjectIdBuffer );

   343 	}

   344