/*
* Copyright (c) 2009 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:
*
*/
#include <s32mem.h>
#include "afstorageasynctask.h"
#include "activitycmd.h"
_LIT(KUnsupportedStorageAsyncTask, "Unsupported async storage task");
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
LOCAL_C void ReadEntryL(CAfEntry& entry, const RMessage2& msg)
{
RBuf8 serializedEntry;
CleanupClosePushL(serializedEntry);
serializedEntry.CreateL(msg.GetDesLengthL(0));
msg.ReadL(0, serializedEntry);
RDesReadStream reader(serializedEntry);
CleanupClosePushL(reader);
reader >> entry;
CleanupStack::PopAndDestroy(&reader);
CleanupStack::PopAndDestroy(&serializedEntry);
}
// -----------------------------------------------------------------------------
/**
* Constructor for performing 1st stage construction
*/
CAfStorageAsyncTask::CAfStorageAsyncTask()
{
// No implementation required
}
// -----------------------------------------------------------------------------
/**
* Destructor.
*/
CAfStorageAsyncTask::~CAfStorageAsyncTask()
{
mExternalizedData.Close();
mInternalizedData.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
/**
* Handle asynchronous data storage requests
* @param taskStorage - data tasks storage
* @param dataStorage - data storage
* @param msg - request message
*/
void CAfStorageAsyncTask::ExecuteLD(MAfTaskStorage& taskStorage,
CAfStorage& dataStorage,
const RMessage2& msg)
{
CAfStorageAsyncTask* self = new (ELeave) CAfStorageAsyncTask();
CleanupStack::PushL(self);
self->ExecuteL(dataStorage, msg);
taskStorage.PushL(self);
CleanupStack::Pop(self);
if (EFalse == msg.IsNull()) {
msg.Complete(KErrNone);
}
}
// -----------------------------------------------------------------------------
/**
* Interface implementation
* @see CActivityTask::Data()
*/
const TDesC8& CAfStorageAsyncTask::CAfStorageAsyncTask::Data() const
{
return mExternalizedData;
}
// -----------------------------------------------------------------------------
/**
* Interface implementation
* @see CActivityTask::BroadcastReceivedL(const RMessage2 &)
*/
void CAfStorageAsyncTask::BroadcastReceivedL(const RMessage2& )
{
// No implementation required
}
// -----------------------------------------------------------------------------
/**
* Handle asynchronous data storage requests
* @param dataStorage - data storage
* @param msg - request message
*/
void CAfStorageAsyncTask::ExecuteL(CAfStorage& dataStorage,
const RMessage2& msg)
{
switch (msg.Function()) {
case Activities:
AllActivitiesL(dataStorage, msg);
break;
case ApplicationActivities:
ApplicationActivitiesL(dataStorage, msg);
break;
case ApplicationActivity:
ApplicationActivityL(dataStorage, msg);
break;
default:
//this code shouldn't be called. fatal error: means wrong session implementation
User::Panic(KUnsupportedStorageAsyncTask, KErrGeneral);
};
}
// -----------------------------------------------------------------------------
/**
* Handle getting all activities request
* @param dataStorage - data storage
* @param msg - requested message
*/
void CAfStorageAsyncTask::AllActivitiesL(CAfStorage& dataStorage,
const RMessage2& msg)
{
dataStorage.ActivitiesL(mInternalizedData);
ExternalizeL();
WriteResponseL(msg);
}
// -----------------------------------------------------------------------------
/**
* Handle getting application activities request
* @param dataStorage - data storage
* @param msg - requested message
*/
void CAfStorageAsyncTask::ApplicationActivitiesL(CAfStorage& dataStorage,
const RMessage2& msg)
{
CAfEntry *entry = CAfEntry::NewLC();
ReadEntryL(*entry, msg);
dataStorage.ActivitiesL(mInternalizedData, entry->ApplicationId());
CleanupStack::PopAndDestroy(entry);
ExternalizeL();
WriteResponseL(msg);
}
// -----------------------------------------------------------------------------
/**
* Handle getting application activity request
* @param dataStorage - data storage
* @param msg - requested message
*/
void CAfStorageAsyncTask::ApplicationActivityL(CAfStorage& dataStorage,
const RMessage2& msg)
{
CAfEntry *src(CAfEntry::NewLC()) , *dst(0);
ReadEntryL(*src, msg);
dataStorage.ActivityL(dst, *src);
CleanupStack::PushL(dst);
ExternalizeL(*dst);
CleanupStack::PopAndDestroy(dst);
CleanupStack::PopAndDestroy(src);
WriteResponseL(msg);
}
// -----------------------------------------------------------------------------
void CAfStorageAsyncTask::ExternalizeL()
{
mExternalizedData << mInternalizedData;
mInternalizedData.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
/**
* Externalzie entry into output buffer
* @param entry - source entry
*/
void CAfStorageAsyncTask::ExternalizeL(const CAfEntry &entry)
{
CAfEntry::ReallocL(mExternalizedData, entry.Size());
RDesWriteStream writer(mExternalizedData);
CleanupClosePushL(writer);
writer << entry;
CleanupStack::PopAndDestroy(&writer);
}
// -----------------------------------------------------------------------------
/**
* Write response data into request message
* @param msg - destination message
*/
void CAfStorageAsyncTask::WriteResponseL(const RMessage2& msg)
{
if (EFalse == msg.IsNull()) {
msg.WriteL(1,
TPckgBuf<TInt>(mExternalizedData.Length()));//write data size
msg.WriteL(2,
TPckgBuf<CBase*>(this));//task identyfier
}
}
// -----------------------------------------------------------------------------
/**
* Returns ETrue if task is related with session argument
*/
TBool CAfStorageAsyncTask::IsSessionTask(const CSession2* /*session*/)
{
return EFalse;
}