/*
* 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: Active object for wiping messages, called by lawmomessagingplugin.
*
*/

#include <msvids.h>
#include <f32file.h>
#include <e32base.h>
#include "lawmomessagingasyncwipe.h"
#include "fdebug.h"

// ----------------------------------------------------------------------------- 
// CActiveWipeObject::CActiveWipeObject
// Description: CActiveWipeObject constructer . Initializes datamember of MLawmoPluginWipeObserver 
// ----------------------------------------------------------------------------- 
//
CActiveWipeObject::CActiveWipeObject(MLawmoPluginWipeObserver* aObserver) :
    CActive(EPriorityStandard), iObserver(aObserver), iSession(NULL)
    {
    FLOG(
            _L(" Messaging: CActiveWipeObject::CActiveWipeObject(MLawmoPluginWipeObserver* aObserver) >>"));
    // See ConstructL() for initialisation completion.
    FLOG(
            _L(" Messaging: CActiveWipeObject::CActiveWipeObject(MLawmoPluginWipeObserver* aObserver) <<"));
    }

// ----------------------------------------------------------------------------- 
// CActiveWipeObject::NewL
// Description: CActiveWipeObject constructer 
// ----------------------------------------------------------------------------- 
//
CActiveWipeObject* CActiveWipeObject::NewL(MLawmoPluginWipeObserver* aObserver)
    {
    FLOG(_L(" Messaging: CActiveWipeObject* CActiveWipeObject::NewL(MLawmoPluginWipeObserver* aObserver) >>"));
    CActiveWipeObject* self=new(ELeave) CActiveWipeObject(aObserver);  
    CleanupStack::PushL(self);
    self->ConstructL(); 
    CleanupStack::Pop();
    FLOG(_L(" Messaging: CActiveWipeObject* CActiveWipeObject::NewL(MLawmoPluginWipeObserver* aObserver) <<"));
    return self;
    }

// ----------------------------------------------------------------------------------------
// CActiveWipeObject::ConstructL
// ----------------------------------------------------------------------------------------
void CActiveWipeObject::ConstructL()
    {
    FLOG(_L(" Messaging: CActiveWipeObject::ConstructL() >>"));

    iTimer.CreateLocal();
    User::LeaveIfError(iWs.Connect());
    CActiveScheduler::Add(this); // Add to scheduler
    iDummyObserver = new CDummyObserver();
    FLOG(_L(" Messaging: CActiveWipeObject::ConstructL() <<"));
    }

void CActiveWipeObject::Close()
    {
    FLOG(_L(" Messaging: void CActiveWipeObject::Close() >>"));
    if (iSession)
        {
        FLOG(_L("  delete iSession;"));
        delete iSession;
        iSession = NULL;
        }
    FLOG(_L(" Messaging: void CActiveWipeObject::Close() <<"));
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject:: CActiveWipeObject
// Description: CActiveWipeObject Destructer
// ----------------------------------------------------------------------------- 
// 
CActiveWipeObject::~CActiveWipeObject()
    {
    FLOG(_L(" Messaging: CActiveWipeObject::~CActiveWipeObject() >>"));
    Close();
    if (iDummyObserver)
        delete iDummyObserver;
    iWs.Close();
    iTimer.Close();
    FLOG(_L(" Messaging: CActiveWipeObject::~CActiveWipeObject() <<"));
    }

//
// Description: Deletes message entries one by one. If used by message application, force deletes.
//
void CActiveWipeObject::DoJobL(CMsvEntry* aContext)
    {
    FLOG(_L(" Messaging: void CLAWMOMessagingplugin::doJobL() >>"));

    TMsvId entryID;
    CMsvEntrySelection* entries;

    entries = aContext->ChildrenL();
    CleanupStack::PushL(entries);

    TInt msgCount= entries->Count();
    FLOG(_L("  msgCount= %d "), msgCount );
    
    for (TInt i=msgCount-1; i>=0; i--)
    { 
         entryID = entries->At(i);
         CMsvEntry* entry = iSession->GetEntryL(entryID);
         CleanupStack::PushL(entry);
         TRAPD(err, entry->DeleteL(entryID));                                                                            
         CleanupStack::PopAndDestroy(entry);
         if(err)
         {
             FLOG(_L("  Deleteing entry failed with err= %d "), err);
             // Force removal of the entry. If no any other way only.  
             iSession->RemoveEntry(entryID);             
         }
    }                

    CleanupStack::PopAndDestroy(entries);
    FLOG(_L(" Messaging: void CLAWMOMessagingplugin::doJobL() <<"));
    }

void CActiveWipeObject::InitializeL()
    {
    FLOG(_L(" Messaging: void CActiveWipeObject::InitializeL() >>"));
    iSession = CMsvSession::OpenSyncL(*iDummyObserver);
    FLOG(_L(" Messaging: void CActiveWipeObject::InitializeL() <<"));
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::WipeAsyncL
// Description: Wipes the logs 
// ---------------------------------------------------------------------------- 
//

void CActiveWipeObject::WipeAsyncL()
    {
    FLOG(_L(" Messaging: void CActiveWipeObject::WipeAsyncL () >>"));
        
    if ( !WaitTillMessageAppKilled()) //Application is closed already
        {
        TRequestStatus* status = &iStatus;
        FLOG(_L("  SetActive()"));
        SetActive();
        User::RequestComplete(status, KErrNone);
        }
    FLOG(_L(" Messaging: void CActiveWipeObject::WipeAsyncL () <<"));
    }

//
// Description: Wipes Inbox, Sent Items, Drafts, Outbox messages.
//
//
void CActiveWipeObject::WipeAllL()
    {
    FLOG(_L(" Messaging: void  CActiveWipeObject::wipeAll() >>"));

    CMsvEntry* context = NULL;
    TMsvSelectionOrdering sort;

    sort.SetShowInvisibleEntries(ETrue); // we want to handle also the invisible entries
    context = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, sort); // Reading Messages from Inbox Folder
    DoJobL(context);
    delete context;

    context = CMsvEntry::NewL(*iSession, KMsvGlobalOutBoxIndexEntryId, sort); // Reading Messages from Outbox Folderif(KErrNone)
    DoJobL(context);
    delete context;

    context = CMsvEntry::NewL(*iSession, KMsvSentEntryId, sort); // Reading Messages from Sent Folder
    DoJobL(context);
    delete context;

    context = CMsvEntry::NewL(*iSession, KMsvDraftEntryId, sort); // Reading Messages from Draft Folder
    DoJobL(context);
    delete context;
    FLOG(_L(" Messaging: void  CActiveWipeObject::wipeAll() <<"));
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::RunError
// Description: This returns error 
//----------------------------------------------------------------------------- 
//

TInt CActiveWipeObject::RunError(TInt aError)
    {
    FLOG(_L(" Messaging: TInt CActiveWipeObject::RunError(TInt aError) >>"));

    FLOG(_L(" Messaging: RunError error %d"), aError);
    iObserver->HandleWipeCompleted(aError);

    FLOG(_L(" Messaging: TInt CActiveWipeObject::RunError(TInt aError) <<"));
    return KErrNone;
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::DoCancel
// Description: This calls CActive's Cancel 
//----------------------------------------------------------------------------- 
//
void CActiveWipeObject::DoCancel()
    {
    FLOG(_L(" Messaging: void CActiveWipeObject::DoCancel() >>"));
    iTimer.Cancel();
    FLOG(_L(" Messaging: void CActiveWipeObject::DoCancel() <<"));
    }

//
//-----------------------------------------------------------------------------
// CActiveWipeObject::WaitTillMessageAppKilled
// Description: This function checks for the Messaging applicaiton being run. If running then kill it.
//-----------------------------------------------------------------------------

TBool CActiveWipeObject::WaitTillMessageAppKilled()
    {
    FLOG(_L(" void CTTPAPITestAppUi::WaitTillMessageAppKilled() >>"));
    TBool ret(EFalse);
    TBool flag(ETrue);

    TApaTaskList list(iWs);
    TUid uid =
        {
        KMessagingAppUid
        };

    while (flag)
        {
        TApaTask task( list.FindApp( uid ) );
        if (task.Exists())
            {
            FLOG(_L("Killing one instance..."));
            task.EndTask();
            User::After(500000);
            ret = ETrue;
            }
        else
            {
            flag = EFalse;
            }
        }
    
    if (ret)
        {
        FLOG(_L(" WaitTillMessageAppKilled: iTimer.After(iStatus,2000); "));  
        iTimer.After(iStatus,2000); // 0.002 sec
        SetActive();
        }
    
     FLOG(_L(" void CTTPAPITestAppUi::WaitTillMessageAppKilled(), ret = %d <<"), ret);
     return ret;
    }



//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::RunL 
// Description: CActive::RunL implementation which will either stop the
// Scheduler or increment the count
//----------------------------------------------------------------------------- 
//
void CActiveWipeObject::RunL()
    {
    FLOG(_L(" Messaging: void CActiveWipeObject::RunL() >>"));
    
    FLOG(_L("void CActiveWipeObject::RunL(): iStatus= %d "), iStatus.Int());
    InitializeL();    
    WipeAllL();
    iObserver->HandleWipeCompleted(KErrNone);
    FLOG(_L(" Messaging: void CActiveWipeObject::RunL() <<"));
    }