diff -r 000000000000 -r 72b543305e3a messagingappbase/msgeditor/modelsrc/MsgEditorModel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/msgeditor/modelsrc/MsgEditorModel.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,538 @@ +/* +* Copyright (c) 2002 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: MsgEditorModel implementation +* +*/ + + + +// ========== INCLUDE FILES ================================ + +#include // MTM UI registery +#include // MTM UI base +#include // MTM UI data registry +#include // MTM UI data base +#include // NullEntryId + +#include "MsgEditorCommon.h" +#include "MsgEditorModel.h" // Module Header +#include "MsgEditorModelPanic.h" // panic codes for model +#include "MsgEditorModelObserver.h" // MMsgEditorModelObserver + +#include "MsgEditorLogging.h" + + +//#define ASYNC_CONST + + +// ========== EXTERNAL DATA STRUCTURES ===================== + +// ========== EXTERNAL FUNCTION PROTOTYPES ================= + +// ========== CONSTANTS ==================================== + +const TInt KThingsToWaitBeforeLaunch = 2; + +// ========== MACROS ======================================= + +// ========== LOCAL CONSTANTS AND MACROS =================== + +// ========== MODULE DATA STRUCTURES ======================= + +// ========== LOCAL FUNCTION PROTOTYPES ==================== + +// ========== LOCAL FUNCTIONS ============================== + +// ========== MEMBER FUNCTIONS ============================= + +// --------------------------------------------------------- +// CMsgEditorModel::CMsgEditorModel +// +// Constructor. +// --------------------------------------------------------- +// +CMsgEditorModel::CMsgEditorModel() : iLaunchWait(KThingsToWaitBeforeLaunch) +{ +} + +// --------------------------------------------------------- +// CMsgEditorModel::ConstructL +// +// 2nd phase constructor. +// --------------------------------------------------------- +// +void CMsgEditorModel::ConstructL() +{ + MEBLOGGER_ENTERFN("CMsgEditorModel::ConstructL"); + +#ifdef ASYNC_CONST + + MEBLOGGER_WRITE("OpenAsyncL"); + MEBLOGGER_WRITE_TIMESTAMP(""); + + iSession = CMsvSession::OpenAsyncL(*this); + +#else + + MEBLOGGER_WRITE("OpenSyncL"); + MEBLOGGER_WRITE_TIMESTAMP(""); + + TRAPD(err, iSession = CMsvSession::OpenSyncL(*this)); + + if (err != KErrNone) + { + iMediaAvailable = EFalse; + if (iModelObserver) + { + // exits. + iModelObserver->HandleServerFailedToStartL(); + } + else + { + User::Leave(err); + } + } + + __ASSERT_DEBUG(iSession, Panic(ENoSession)); + + iMediaAvailable = ETrue; + + CompleteConstructL(); + +#endif + + MEBLOGGER_LEAVEFN("CMsgEditorModel::ConstructL"); +} + +// --------------------------------------------------------- +// CMsgEditorModel::Wait +// +// Starts active scheduler to complete construction, if necessary. +// --------------------------------------------------------- +// +void CMsgEditorModel::Wait() +{ +#ifdef ASYNC_CONST + + MEBLOGGER_ENTERFN("CMsgEditorModel::Wait"); + + if (!iMediaAvailable) + { + iWait = ETrue; + CActiveScheduler::Start(); + } + iWait = EFalse; + + MEBLOGGER_LEAVEFN("CMsgEditorModel::Wait"); + +#endif +} + +// --------------------------------------------------------- +// CMsgEditorModel::CompleteConstructL +// +// Creates client MTM registry and MTM UI registry when session is ready +// for use. This completes model construction and is called after 'server +// ready' event is received after async opening of CMsvSession. +// --------------------------------------------------------- +// +void CMsgEditorModel::CompleteConstructL() +{ + MEBLOGGER_ENTERFN("CMsgEditorModel::CompleteConstructL"); + MEBLOGGER_WRITE_TIMESTAMP(""); + + __ASSERT_DEBUG(iMtmUiReg == NULL, Panic(ENullPointer)); + + iMtmReg = CClientMtmRegistry::NewL(*iSession); + //delay the construction of iMtmUiReg and iMtmUiDataReg until needed + + __ASSERT_DEBUG(iMtmReg, Panic(ENullPointer)); + + + MEBLOGGER_LEAVEFN("CMsgEditorModel::CompleteConstructL"); +} + +// --------------------------------------------------------- +// CMsgEditorModel::~CMsgEditorModel +// +// Destructor. +// --------------------------------------------------------- +// +CMsgEditorModel::~CMsgEditorModel() +{ + // note that iMtmReg can be deleted only after iMtm is deleted first + delete iMtmUiData; + delete iMtmUiDataReg; + + delete iMtmUi; + delete iMtmUiReg; + + delete iMtm; + delete iMtmReg; + + delete iSession; + iModelObserver = NULL; // not owned +} + +// --------------------------------------------------------- +// CMsgEditorModel::SetEntryL +// +// Set up current message entry, creates a real connection between current +// editor/viewer session and an message entryy to be displayed or edited. +// --------------------------------------------------------- +// +void CMsgEditorModel::SetEntryL(TMsvId aEntryId) + { + MEBLOGGER_ENTERFN( "CMsgEditorModel::SetEntryL" ); + MEBLOGGER_WRITE_TIMESTAMP(""); + + TMsvId service; + TMsvEntry entry; + User::LeaveIfError( Session().GetEntry( aEntryId, service, entry ) ); + + if ( iMtm == NULL || iMtm->Type() != entry.iMtm ) + { + delete iMtm; + delete iMtmUi; + delete iMtmUiData; + + iMtm = NULL; + iMtmUi = NULL; + iMtmUiData = NULL; + + iMtm = iMtmReg->NewMtmL( entry.iMtm ); + // delay the construction of iMtmUi and iMtmUiData until needed + } + + if ( !iMtm->HasContext() || iMtm->Entry().EntryId() != aEntryId ) + { + iMtm->SwitchCurrentEntryL( aEntryId ); + } + + MEBLOGGER_LEAVEFN( "CMsgEditorModel::SetEntryL" ); + } + +// --------------------------------------------------------- +// CMsgEditorModel::PrepareMtmL +// +// Loads client and ui mtm's according to given message type. +// clientmtm context is set also (this prepares +// --------------------------------------------------------- +// +void CMsgEditorModel::PrepareMtmL(const TUid aMtmType) +{ + if (iMtm == NULL) + { + //delete iMtm; + delete iMtmUi; + delete iMtmUiData; + + //iMtm = NULL; + iMtmUi = NULL; + iMtmUiData = NULL; + + iMtm = iMtmReg->NewMtmL(aMtmType); + //delay the construction of iMtmUi and iMtmUiData until needed + + // ClientMtm needs some context before CreateMessageL can be called. + CMsvEntry* entry = Session().GetEntryL(KMsvRootIndexEntryId); + + CleanupStack::PushL(entry); + + // Note: Switch... makes copy of the given entry. + // Don't use SetCurrentEntry, because it does ownership transfer + // delete moves out of model. + iMtm->SwitchCurrentEntryL(entry->EntryId()); + + CleanupStack::PopAndDestroy(); // entry + } +} + +// --------------------------------------------------------- +// CMsgEditorModel::MtmUiL +// --------------------------------------------------------- +// +CBaseMtmUi& CMsgEditorModel::MtmUiL() + { + __ASSERT_DEBUG(iMtm, Panic(ENullPointer)); + if ( !iMtmUiReg ) + { + iMtmUiReg = CMtmUiRegistry::NewL(*iSession); + } + if ( !iMtmUi ) + { + iMtmUi = iMtmUiReg->NewMtmUiL(*iMtm); + } + return *iMtmUi; + } + +// --------------------------------------------------------- +// CMsgEditorModel::MtmUiDataL +// --------------------------------------------------------- +// +CBaseMtmUiData& CMsgEditorModel::MtmUiDataL() + { + __ASSERT_DEBUG(iMtm, Panic(ENullPointer)); + if ( !iMtmUiDataReg ) + { + iMtmUiDataReg = CMtmUiDataRegistry::NewL(*iSession); + } + if ( !iMtmUi )//incase MtmUi was not initialized + { + MtmUiL(); + } + if ( !iMtmUiData ) + { + iMtmUiData = iMtmUiDataReg->NewMtmUiDataLayerL(iMtmUi->Type()); + } + return *iMtmUiData; + } + +// --------------------------------------------------------- +// CMsgEditorModel::HandleSessionEventL +// +// Handles session event observer, and call event handling functions in observer. +// --------------------------------------------------------- +// +void CMsgEditorModel::HandleSessionEventL( + TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3) +{ + MEBLOGGER_ENTERFN("CMsgEditorModel::HandleSessionEventL"); + MEBLOGGER_WRITE_TIMESTAMP(""); + + switch (aEvent) + { + case EMsvEntriesCreated: + MEBLOGGER_WRITE("EMsvEntriesCreated"); + // no action + break; + + case EMsvEntriesChanged: + { + MEBLOGGER_WRITE("EMsvEntriesChanged"); + + if (iMtm == NULL || !(iMtm->HasContext())) + break; // no entry => ignore event + + // check if the current entry has been changed + const CMsvEntrySelection* sel = static_cast(aArg1); + + __ASSERT_DEBUG(sel, Panic(ENullPointer)); + + const TInt index = sel->Find(Entry().Id()); + + // if it has (and if there is model observer defined) ... + if ((index != KErrNotFound) && iModelObserver) + { + iModelObserver->HandleEntryChangeL(); + } + } + break; + + case EMsvEntriesDeleted: + { + MEBLOGGER_WRITE("EMsvEntriesDeleted"); + + if (iMtm == NULL || !(iMtm->HasContext())) + break; // no entry => ignore event + + // check if the current entry has been deleted + const CMsvEntrySelection* sel = static_cast(aArg1); + + __ASSERT_DEBUG(sel, Panic(ENullPointer)); + + const TInt index = sel->Find(Entry().Id()); + + // notify the application, if necessary + if ((index != KErrNotFound) && iModelObserver) + { + iModelObserver->HandleEntryDeletedL(); + } + } + break; + + case EMsvEntriesMoved: + { + MEBLOGGER_WRITE("EMsvEntriesMoved"); + + if (iMtm == NULL || !(iMtm->HasContext())) + break; // no entry => ignore event + + // check if the current entry has been moved + const CMsvEntrySelection* sel = static_cast(aArg1); + const TMsvId newParent = reinterpret_cast(aArg2); + const TMsvId oldParent = reinterpret_cast(aArg3); + + __ASSERT_DEBUG(sel, Panic(ENullPointer)); + __ASSERT_DEBUG(newParent, Panic(ENullPointer)); + __ASSERT_DEBUG(oldParent, Panic(ENullPointer)); + + const TInt index = sel->Find(Entry().Id()); + + // notify the application, if necessary + if ((index != KErrNotFound) && iModelObserver) + { + iModelObserver->HandleEntryMovedL(oldParent, newParent); + } + } + break; + + case EMsvMtmGroupInstalled: + MEBLOGGER_WRITE("EMsvMtmGroupInstalled"); + // no action + break; + + case EMsvMtmGroupDeInstalled: + { + MEBLOGGER_WRITE("EMsvMtmGroupDeInstalled"); + + if (iMtm == NULL || !(iMtm->HasContext())) + break; // no entry => ignore event + + const TUid mtmId = TUid::Uid(reinterpret_cast(aArg2)); + + if (mtmId == Mtm().Type() && iModelObserver) + { + iModelObserver->HandleMtmGroupDeinstalledL(); + } + } + break; + + case EMsvGeneralError: + { + MEBLOGGER_WRITE("EMsvGeneralError"); + + const TInt errorCode = reinterpret_cast(aArg1); + + if (iModelObserver) + { + iModelObserver->HandleGeneralErrorL(errorCode); + } + } + break; + + case EMsvCloseSession: + MEBLOGGER_WRITE("EMsvCloseSession"); + + if (iModelObserver) + { + iModelObserver->HandleCloseSessionL(); + } + break; + + case EMsvServerReady: + MEBLOGGER_WRITE("EMsvServerReady"); + + iMediaAvailable = ETrue; +#ifdef ASYNC_CONST + CompleteConstructL(); + if (iWait) + { + CActiveScheduler::Stop(); + } +#endif + break; + + case EMsvServerFailedToStart: + MEBLOGGER_WRITE("EMsvServerFailedToStart"); + + iMediaAvailable = EFalse; + if (iModelObserver) + { + iModelObserver->HandleServerFailedToStartL(); + } + break; + + case EMsvServerTerminated: + MEBLOGGER_WRITE("EMsvServerTerminated"); + + iMediaAvailable = EFalse; + if (iModelObserver) + { + iModelObserver->HandleServerTerminatedL(); + } + break; + + case EMsvMediaChanged: + MEBLOGGER_WRITE("EMsvMediaChanged"); + + // media is available, although it may not be the same one any more + iMediaAvailable = ETrue; + if (iModelObserver) + { + iModelObserver->HandleMediaChangedL(); + } + break; + + case EMsvMediaUnavailable: + MEBLOGGER_WRITE("EMsvMediaUnavailable"); + + iMediaAvailable = EFalse; + if (iModelObserver) + { + iModelObserver->HandleMediaUnavailableL(); + } + break; + + case EMsvMediaAvailable: + MEBLOGGER_WRITE("EMsvMediaAvailable"); + + iMediaAvailable = ETrue; + if (iModelObserver) + { + iModelObserver->HandleMediaAvailableL(); + } + break; + + case EMsvMediaIncorrect: + MEBLOGGER_WRITE("EMsvMediaIncorrect"); + + iMediaAvailable = EFalse; + if (iModelObserver) + { + iModelObserver->HandleMediaIncorrectL(); + } + break; + + case EMsvCorruptedIndexRebuilding: + MEBLOGGER_WRITE("EMsvCorruptedIndexRebuilding"); + + iMediaAvailable = EFalse; + if (iModelObserver) + { + iModelObserver->HandleCorruptedIndexRebuildingL(); + } + break; + + case EMsvCorruptedIndexRebuilt: + MEBLOGGER_WRITE("EMsvCorruptedIndexRebuilt"); + + // iMediaAvailable will be updated by EMsvServerReady event + if (iModelObserver) + { + iModelObserver->HandleCorruptedIndexRebuiltL(); + } + break; + + default: + __ASSERT_DEBUG(EFalse, Panic(EUnknownSessionEvent)); + break; + } + + MEBLOGGER_LEAVEFN("CMsgEditorModel::HandleSessionEventL"); +} + +// ========== OTHER EXPORTED FUNCTIONS ===================== + +// End of File