/*

* 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: 

*     Messaging progress watching classes

*

*

*/

// INCLUDE FILES

#include "emailtrace.h"

#include "ipsplgheaders.h"

// CONSTANTS

const TInt KSingleOpWatcherPriority = KMaxTInt;

#ifdef _DEBUG

_LIT( KPanicIpsPlgSingleOpWatcher, "CIpsPlgSingleOpWatcher");

#endif

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

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

// CIpsPlgSingleOpWatcher::NewLC

//

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

//

EXPORT_C CIpsPlgSingleOpWatcher* CIpsPlgSingleOpWatcher::NewLC( 

    MIpsPlgSingleOpWatcher& aObserver )

    {

    FUNC_LOG;

    CIpsPlgSingleOpWatcher* self = new( ELeave ) CIpsPlgSingleOpWatcher( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIpsPlgSingleOpWatcher::NewL

//

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

//

EXPORT_C CIpsPlgSingleOpWatcher* CIpsPlgSingleOpWatcher::NewL( 

    MIpsPlgSingleOpWatcher& aObserver )

    {

    FUNC_LOG;

    CIpsPlgSingleOpWatcher* self = CIpsPlgSingleOpWatcher::NewLC( aObserver );

    CleanupStack::Pop( self ); // self

    return self;

    }

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

// CIpsPlgSingleOpWatcher::CIpsPlgSingleOpWatcher

//

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

//

CIpsPlgSingleOpWatcher::CIpsPlgSingleOpWatcher( 

    MIpsPlgSingleOpWatcher& aObserver )

    : CActive( KSingleOpWatcherPriority ), iObserver( aObserver )

    {

    FUNC_LOG;

    CActiveScheduler::Add( this );

    }

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

// CIpsPlgSingleOpWatcher::ConstructL

//

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

//

void CIpsPlgSingleOpWatcher::ConstructL()

    {

    FUNC_LOG;

    // Nothing to do, reserved for future use...

    }

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

// CIpsPlgSingleOpWatcher::~CIpsPlgSingleOpWatcher

//

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

//

EXPORT_C CIpsPlgSingleOpWatcher::~CIpsPlgSingleOpWatcher()

    {

    FUNC_LOG;

    Cancel();

    delete iOperation;

    }

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

// CIpsPlgSingleOpWatcher::SetOperation

// --- Setter ---

// Must only be called once during the lifetime 

//of a CIpsPlgSingleOpWatcher object.

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

//

EXPORT_C void CIpsPlgSingleOpWatcher::SetOperation(CMsvOperation* aOperation)

    {

    FUNC_LOG;

    __ASSERT_DEBUG( !IsActive(), 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrInUse ) );

    __ASSERT_DEBUG( !iOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrAlreadyExists ) );

    __ASSERT_DEBUG( aOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrNotFound ) );

    __ASSERT_DEBUG( !iBaseOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrAlreadyExists ) );

    //

    // Take ownership of operation and set our active status so we're handled 

    // by the active scheduler.

    iOperation = aOperation;

    iStatus = KRequestPending;

    SetActive();

    }

void CIpsPlgSingleOpWatcher::SetOperation( CIpsPlgBaseOperation* aBaseOperation )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( !IsActive(), 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrInUse ) );

    __ASSERT_DEBUG( !iOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrAlreadyExists ) );

    __ASSERT_DEBUG( aBaseOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrNotFound ) );

    __ASSERT_DEBUG( !iBaseOperation, 

        User::Panic( KPanicIpsPlgSingleOpWatcher, KErrAlreadyExists ) );

    iBaseOperation = aBaseOperation;

    iStatus = KRequestPending;

    SetActive();

    }

const CIpsPlgBaseOperation* CIpsPlgSingleOpWatcher::BaseOperation( ) const

    {

    FUNC_LOG;

    CIpsPlgBaseOperation* op = NULL;

    if ( !iOperation )

        {

        __ASSERT_DEBUG( iBaseOperation, 

            User::Panic( KPanicIpsPlgSingleOpWatcher, KErrNotFound  )  );

        op =  iBaseOperation;

        }

    return op;

    }

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

// CIpsPlgSingleOpWatcher::Operation

// --- Accessor ---

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

//

EXPORT_C CMsvOperation& CIpsPlgSingleOpWatcher::Operation() const

    {

    FUNC_LOG;

    CMsvOperation* op = NULL;

    if ( !iOperation )

        {

        __ASSERT_DEBUG( iBaseOperation, 

            User::Panic( KPanicIpsPlgSingleOpWatcher, KErrNotFound  )  );

        op = static_cast<CMsvOperation*>( iBaseOperation );

        }

    else if ( !iBaseOperation )

        {

        __ASSERT_DEBUG( iOperation, 

            User::Panic( KPanicIpsPlgSingleOpWatcher, KErrNotFound  )  );

        op = iOperation;

        }

    return *op;

    }

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

// CIpsPlgSingleOpWatcher::DoCancel

// --- From CActive ---

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

//

void CIpsPlgSingleOpWatcher::DoCancel()        

    {

    FUNC_LOG;

    // Pass on cancel

    if ( iOperation && iOperation->IsActive() )

        {

        iOperation->Cancel();

        }

    else if ( iBaseOperation && iBaseOperation->IsActive() )

        {

        iBaseOperation->Cancel();

        }

    else

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete(status, KErrNone);

        }

    }

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

// CIpsPlgSingleOpWatcher::RunL

// --- From CActive ---

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

//

void CIpsPlgSingleOpWatcher::RunL()

    {

    FUNC_LOG;

    //

    // Inform client of watcher that the operation has completed

    iObserver.OpCompleted( *this, iStatus.Int() );

    }

// End of file