/*
* 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 Call-logs, called by lawmocalllogsplugin.
*
*/
#include <logcli.h>
#include <f32file.h>
#include <logwrap.h>
#include <logview.h>
#include <e32base.h>
#include <logwraplimits.h>
#include <logwrapconst.h>
#include "lawmocalllogsasyncwipe.h"
#include "fdebug.h"

// Application Closing
#include <apgtask.h>
#include <w32std.h>
#include <APGTASK.H>

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

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

// ----------------------------------------------------------------------------------------
// CActiveWipeObject::ConstructL
// ----------------------------------------------------------------------------------------
void CActiveWipeObject::ConstructL()
    {
    FLOG(_L( " CAllLogs: CActiveWipeObject::ConstructL >> "));
    iTimer.CreateLocal();
    User::LeaveIfError(iWsSession.Connect());
    CActiveScheduler::Add(this); // Add to scheduler    
    FLOG(_L( " CAllLogs: CActiveWipeObject::ConstructL << "));
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject:: CActiveWipeObject
// Description: CActiveWipeObject Destructer
// ----------------------------------------------------------------------------- 
// 
CActiveWipeObject::~CActiveWipeObject()
    {
    FLOG(_L( " CAllLogs: CActiveWipeObject::~CActiveWipeObject() >> "));
    Cancel();
    if (ilogClient)
    	{
        delete ilogClient;
      }
      
    if (ifs.Handle())
      	{
      		ifs.Close();
      	}

    iTimer.Close();
    
    iWsSession.Close();
        
    FLOG(_L( " CAllLogs: CActiveWipeObject::~CActiveWipeObject() << "));
    }

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

void CActiveWipeObject::WipeAsyncL()
    {
    FLOG(_L(" CAllLogs: void CActiveWipeObject::WipeAsyncL () >>"));
    if (!WaitTillLogsAppKilled()) //Application is closed already
        {
        ClearLogsL();
        }

    FLOG(_L(" CAllLogs: void CActiveWipeObject::WipeAsyncL () <<"));
    }

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

TInt CActiveWipeObject::RunError(TInt aError)
    {
    FLOG(_L(" CAllLogs: TInt CActiveWipeObject::RunError(TInt aError) >>"));
    FLOG(_L(" CAllLogs: RunError error %d"), aError);
    iObserver->HandleWipeCompleted(aError);
    FLOG(_L(" CAllLogs: TInt CActiveWipeObject::RunError(TInt aError) <<"));
    return KErrNone;
    }

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

TBool CActiveWipeObject::WaitTillLogsAppKilled()
    {
    FLOG(_L(" WaitTillLogsAppKilled() >>"));

    TBool ret(EFalse);
    TBool flag(ETrue);

    TApaTaskList list(iWsSession);
    TUid uid =
        {
        KCallLogsAppUid
        };

    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(" WaitTillPhonebookKilled: iTimer.After(iStatus,1000); "));
        iTimerStarted = ETrue; // If time is started, this is true
        iTimer.After(iStatus, 2000); // 0.002 sec
        SetActive();
        }

    FLOG(_L(" WaitTillLogsAppKilled(), ret = %d <<"), ret);
    return ret;
    }


//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::RunL 
// Description: Clears the logs
//----------------------------------------------------------------------------- 
//
void CActiveWipeObject::ClearLogsL()
    {
    FLOG(_L("void CActiveWipeObject::ClearLogs() >> "));
    TTime time(KMaxTime);
    User::LeaveIfError(ifs.Connect());
    ilogClient = CLogClient::NewL(ifs);
    FLOG(_L("iStatus.Int() = %d "), iStatus.Int());
    ilogClient->ClearLog(time, iStatus);
    SetActive();

    FLOG(_L("void CActiveWipeObject::ClearLogs() << "));
    }

//
//----------------------------------------------------------------------------- 
// CActiveWipeObject::RunL 
// Description: Called when either timer expires of logs are cleared
//----------------------------------------------------------------------------- 
//
void CActiveWipeObject::RunL()
    {
    FLOG(_L(" CAllLogs: void CActiveWipeObject::RunL() >>"));
    FLOG(_L("void CActiveWipeObject::RunL(): iStatus= %d "), iStatus.Int());

    if (iTimerStarted)
        {
        iTimerStarted = EFalse;
        ClearLogsL();
        }
    else
        iObserver->HandleWipeCompleted(iStatus.Int());
    FLOG(_L(" CAllLogs: void CActiveWipeObject::RunL() <<"));
    }