/*

* Copyright (c) 2002 - 2007 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:  

*     Message centre's settings session observer

*

*/

// INCLUDE FILES

#include <ErrorUI.h> // CErrorUI

#include <aknappui.h> // iAvkonAppUi

#include <avkon.mbg>

#include <mtudreg.h>

#include <MTMStore.h>

#include <MsgArrays.h> // CUidNameArray

#include <msvids.h>

#include <msvuids.h>

#include <MuiuMsvUiServiceUtilities.h> // MsvUiServiceUtilities

#include <MuiuMsvProgressReporterOperation.h>

#include <akninputblock.h> // CAknInputBlock

#include <SenduiMtmUids.h>

#include "MceSettingsSessionObserver.h"

// CONSTANTS

const TInt KMceArrayGranularity = 4;

const TInt KMceVisibleTextLength = KHumanReadableNameLength;

// ================= MEMBER FUNCTIONS =======================

// ----------------------------------------------------

// CMceSettingsSessionObserver::Constructor

// ----------------------------------------------------

CMceSettingsSessionObserver::CMceSettingsSessionObserver( CMsvSession* aSession )

    :

    iSession( aSession ),

    iDeleteSession( EFalse )

    {

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::Constructor

// ----------------------------------------------------

void CMceSettingsSessionObserver::ConstructL()

    {

    if ( !iSession )

        {

        iSession = CMsvSession::OpenSyncL( *this );

        iDeleteSession = ETrue;

        }

    iUiRegistry = CMtmUiDataRegistry::NewL( *iSession );

    iMtmStore = CMtmStore::NewL( *iSession );

    iRootEntry=CMsvEntry::NewL(

        *iSession,

        KMsvRootIndexEntryId,

        TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::Constructor

// ----------------------------------------------------

EXPORT_C CMceSettingsSessionObserver* CMceSettingsSessionObserver::NewL( CMsvSession* aSession )

    {

    CMceSettingsSessionObserver* self = new ( ELeave ) CMceSettingsSessionObserver( aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::Destructor

// ----------------------------------------------------

EXPORT_C CMceSettingsSessionObserver::~CMceSettingsSessionObserver()

    {

    delete iRunningOperation;

    delete iUiRegistry;

    delete iMtmStore;

    delete iRootEntry;

    if ( iDeleteSession )

        {

        delete iSession;

        }

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::Session

// ----------------------------------------------------

EXPORT_C CMsvSession& CMceSettingsSessionObserver::Session()

    {

    return *iSession;

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::UiRegistry

// ----------------------------------------------------

EXPORT_C CMtmUiDataRegistry* CMceSettingsSessionObserver::UiRegistry() const

    {

    return iUiRegistry;

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::MtmStore

// ----------------------------------------------------

EXPORT_C CMtmStore* CMceSettingsSessionObserver::MtmStore() const

    {

    return iMtmStore;

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::HandleSessionEventL

// ----------------------------------------------------

void CMceSettingsSessionObserver::HandleSessionEventL( TMsvSessionEvent /*aEvent*/, 

                                                                                          TAny* /*aArg1*/, 

                                                                                          TAny* /*aArg2*/, 

                                                                                          TAny* /*aArg3*/ )

    {

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::OpCompleted

// ----------------------------------------------------

void CMceSettingsSessionObserver::OpCompleted( CMsvSingleOpWatcher& aOpWatcher, 

                                                                            TInt aCompletionCode )

    {

    CMsvOperation* op=&aOpWatcher.Operation();

    TRAP_IGNORE( DoOperationCompletedL( op, aCompletionCode ) );  

    if ( iRunningOperation->Operation().Id() == op->Id() )

        {

        delete iRunningOperation;

        iRunningOperation = NULL;

        }

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::DoOperationCompletedL

// ----------------------------------------------------

void CMceSettingsSessionObserver::DoOperationCompletedL(

    CMsvOperation* aOperation, 

    TInt aCompletionCode )

    {

    if ( !aOperation )

        {

        return;

        }

    if ( aCompletionCode == EEikCmdExit )

        {

        iAvkonAppUi->ProcessCommandL( EAknCmdExit );

        return;

        }

    const TDesC8& progress = aOperation->ProgressL();

    if ( progress.Length() == 0 )

        {

        return;

        }

    if ( aOperation->Mtm() != KUidMsvLocalServiceMtm )

        {

        CAknInputBlock::NewLC();

        iMtmStore->GetMtmUiLC( aOperation->Mtm() ).DisplayProgressSummary( progress );            

        CleanupStack::PopAndDestroy( 2 );  // CAknInputBlock, release mtmUi      

        return;

        }

    TMsvLocalOperationProgress localprogress = 

        McliUtils::GetLocalProgressL( *aOperation );     

    if ( ( aCompletionCode==KErrNone || aCompletionCode==KErrCancel) &&

        ( localprogress.iError==KErrNone || localprogress.iError==KErrCancel ) )

        {

        return;

        }

    CErrorUI* errorUi = CErrorUI::NewL( *CCoeEnv::Static() );

    CleanupStack::PushL( errorUi );

    errorUi->ShowGlobalErrorNoteL( localprogress.iError?localprogress.iError:aCompletionCode );

    CleanupStack::PopAndDestroy( errorUi );

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::CanCreateNewAccountL

// ----------------------------------------------------

EXPORT_C TBool CMceSettingsSessionObserver::CanCreateNewAccountL( TUid aMtm )

    {

    TMsvEntry serviceEntry;

    serviceEntry.iType=KUidMsvServiceEntry;

    serviceEntry.iMtm=aMtm;

    TInt rid;

    CBaseMtmUiData& uiData = iMtmStore->MtmUiDataL( aMtm );

    return uiData.CanCreateEntryL( iRootEntry->Entry(), serviceEntry, rid );

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::DeleteAccountL

// ----------------------------------------------------

EXPORT_C void CMceSettingsSessionObserver::DeleteAccountL( TMsvId aId )

    {

    User::LeaveIfError( iRunningOperation ? KErrInUse : KErrNone );

    TMsvEntry entry;

    TMsvId serviceId;

    User::LeaveIfError( iSession->GetEntry( aId, serviceId, entry ) );

    const TUid mtm = entry.iMtm;

    CBaseMtmUi* ui = &iMtmStore->ClaimMtmUiL( mtm );

    if ( ui )

        {

        CMtmStoreMtmReleaser::CleanupReleaseMtmUiLC( *iMtmStore, mtm );

        }

    CMsvOperation* op = NULL;    

// Request free disk space to be implemented

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );

    CleanupStack::PushL( singleOpWatcher );

    if ( ui )

        {

        ui->BaseMtm().SetCurrentEntryL( iSession->GetEntryL( KMsvRootIndexEntryId ) );

        CAknInputBlock::NewLC();

        op = ui->DeleteServiceL( entry, singleOpWatcher->iStatus );

        CleanupStack::PopAndDestroy(); //CAknInputBlock

        CleanupStack::PushL( op );

        }

    else

        {

        // could not load mtm, so delete as normal local entry

        CMsvProgressReporterOperation* progOp = CMsvProgressReporterOperation::NewL(

            *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased );

        CleanupStack::PushL( progOp );

        CMsvEntrySelection* selection = new( ELeave ) CMsvEntrySelection();

        CleanupStack::PushL( selection );

        selection->AppendL( entry.Id() );

        CMsvOperation* subOp = iRootEntry->DeleteL( *selection, progOp->RequestStatus() );

        CleanupStack::PopAndDestroy( selection );

        progOp->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.

        op = progOp;

        CleanupStack::PushL( op );

        }

    CleanupStack::Pop( op );

    CleanupStack::Pop( singleOpWatcher );

    singleOpWatcher->SetOperation( op );

    iRunningOperation = singleOpWatcher;    

// Cancel the free disk space request to be implemented

    if ( ui )

        {

        CleanupStack::PopAndDestroy();// release mtmUi

        }

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::CreateNewAccountL

// ----------------------------------------------------

EXPORT_C TBool CMceSettingsSessionObserver::CreateNewAccountL( TUid aMessageType, 

                                                                           TMsvId aOldServiceId /* = KMsvNullIndexEntryId */)

    {

    LeaveIfDiskSpaceUnderCriticalLevelL();

    User::LeaveIfError ( ( iRunningOperation ? KErrInUse : KErrNone ) );

    TMsvEntry nentry;

    nentry.iMtm = aMessageType;

    nentry.iType.iUid = KUidMsvServiceEntryValue;

    nentry.iDate.HomeTime();

    nentry.iServiceId = aOldServiceId;

    // --- Get the MTM UI relevant to the message type ---

    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( nentry.iMtm );

    CMsvEntry* centry = iSession->GetEntryL( KMsvRootIndexEntryId );

    CleanupStack::PushL( centry );

    CAknInputBlock::NewLC();

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );

    CleanupStack::PushL( singleOpWatcher );

    CMsvOperation* op=mtmUi.CreateL(

        nentry,

        *centry,

        singleOpWatcher->iStatus );

    CleanupStack::PushL( op );

    singleOpWatcher->SetOperation( op );

    iRunningOperation = singleOpWatcher;

    CleanupStack::Pop( op );

    CleanupStack::Pop( singleOpWatcher );

    TBool accountCreated = ( op->iStatus != KErrCancel );

    // if not created, imum returns completed operation with KErrCancel

    CleanupStack::PopAndDestroy(); // command absorb

    CleanupStack::PopAndDestroy( centry );

    CleanupStack::PopAndDestroy(); // mtm ui release

    return accountCreated;

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::EditAccountL

// ----------------------------------------------------

EXPORT_C void CMceSettingsSessionObserver::EditAccountL( TMsvId aId )

    {

    LeaveIfDiskSpaceUnderCriticalLevelL();

    User::LeaveIfError ( ( iRunningOperation ? KErrInUse : KErrNone ) );

    TMsvEntry entry;

    TMsvId serviceId;

    User::LeaveIfError( iSession->GetEntry( aId, serviceId, entry ) );

    if ( entry.iType == KUidMsvServiceEntry )

        {

        CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( entry );

        CAknInputBlock::NewLC();

        CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );

        CleanupStack::PushL( singleOpWatcher );

        CMsvOperation* op=mtmUi.EditL( singleOpWatcher->iStatus );

        CleanupStack::PushL( op );

        singleOpWatcher->SetOperation( op );

        iRunningOperation = singleOpWatcher;

        CleanupStack::Pop( op ); 

        CleanupStack::Pop( singleOpWatcher );

        CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmUi

        }

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::MtmAccountsL

// ----------------------------------------------------

EXPORT_C CUidNameArray* CMceSettingsSessionObserver::MtmAccountsL( TUid aType )

    {

    CUidNameArray* accounts = new (ELeave) CUidNameArray(

        KMceArrayGranularity );

    CleanupStack::PushL( accounts );

    CMsvEntrySelection* sel = NULL;

    if ( aType == KSenduiMtmSmtpUid )

        {

        sel = MsvUiServiceUtilities::GetListOfAccountsL(

            *iSession,

            ETrue );

        }

    else

        {

        sel = MsvUiServiceUtilities::GetListOfAccountsWithMTML(

            *iSession,

            aType,

            ETrue );

        }

    CleanupStack::PushL( sel );

    CMsvEntry* rootEntry=CMsvEntry::NewL(

        *iSession,

        KMsvRootIndexEntryId,

        TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    delete iRootEntry;

    iRootEntry = rootEntry;

    TUid uid;

    TUid techType=iUiRegistry->TechnologyTypeUid( aType );

    const TInt numAccounts=sel->Count();

    for (TInt cc=0; cc<numAccounts; cc++)

        {

        uid.iUid=sel->At(cc);

        TMsvEntry tentry;

        TRAPD( err, ( tentry = iRootEntry->ChildDataL( uid.iUid ) ) );

        if ( err == KErrNone &&

            iUiRegistry->IsPresent( tentry.iMtm ) && 

            iUiRegistry->TechnologyTypeUid( tentry.iMtm ) == techType )

            {

            const TInt count = accounts->Count();

            TBool foundService = EFalse;

            //check that related service is not already added to array

            for ( TInt loop = 0; loop < count; loop ++ )

                {

                if ( tentry.iRelatedId == ( *accounts )[loop].iUid.iUid )

                    {

                    foundService = ETrue;

                    break;

                    }

                }

            if ( !foundService )

                {

                TUidNameInfo info( uid, tentry.iDetails.Left( KMceVisibleTextLength ) );

                accounts->AppendL( info );

                }

            }

        }

    CleanupStack::PopAndDestroy( sel );

    CleanupStack::Pop( accounts );

    return accounts;

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::IsPresent

// ----------------------------------------------------

EXPORT_C TBool CMceSettingsSessionObserver::IsPresent( TUid aMtm ) const

    {

    return iUiRegistry->IsPresent( aMtm );

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::LeaveIfDiskSpaceUnderCriticalLevelL

// ----------------------------------------------------

void CMceSettingsSessionObserver::LeaveIfDiskSpaceUnderCriticalLevelL( TInt aBytesToWrite ) const

    {

    if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL( *iSession, aBytesToWrite) )

        {

        User::Leave( KErrDiskFull );

        }

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::CancelFreeDiskSpaceRequest

// Static function.

// ----------------------------------------------------

void CMceSettingsSessionObserver::CancelFreeDiskSpaceRequest(TAny* /*aAny*/)

    {

    // Cancel free disk space request to be implemented

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::MtmName

//

// ----------------------------------------------------

EXPORT_C THumanReadableName CMceSettingsSessionObserver::MtmName( TUid aMtm ) const

    {

    return iUiRegistry->RegisteredMtmDllInfo( aMtm ).HumanReadableName();

    }

// ----------------------------------------------------

// CMceSettingsSessionObserver::SetChangeMessageStore

//

// ----------------------------------------------------

EXPORT_C void CMceSettingsSessionObserver::SetChangeMessageStore( TBool /*aChangeEnded*/ )

    {

    // do nothing...

    }