/*

* Copyright (c) 2004 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:  API which handles OMA Provisioning related operations

*

*/

//INCLUDE FILES

#include "WimCertMgmt.h"

#include "WimMgmt.h"

#include "ProvSC.h"

#include "WimTrace.h"

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

// CWimOMAProv::CWimOMAProv()

// Default constructor

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

//

CWimOMAProv::CWimOMAProv(): CActive( EPriorityStandard )

    {

    }

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

// CWimOMAProv* CWimOMAProv::NewL()

// Symbian 2 phase construction

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

//

EXPORT_C CWimOMAProv* CWimOMAProv::NewL()

    {

    CWimOMAProv* self = new( ELeave ) CWimOMAProv();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWimOMAProv::ConstructL()

// Second phase

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

//

void CWimOMAProv::ConstructL()

    {

    _WIMTRACE ( _L( "CWimOMAProv::ConstructL" ) );

    CActiveScheduler::Add( this );

    }

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

// CWimOMAProv::~CWimOMAProv()

// Destructor. All allocated memory is released.

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

//

EXPORT_C CWimOMAProv::~CWimOMAProv()

    {

    _WIMTRACE ( _L( "CWimOMAProv::~CWimOMAProv" ) );

    Cancel();

    DeallocMemoryFromOmaProvStruct();

    if( iConnectionHandle )

        {

        iConnectionHandle->Close();

        delete iConnectionHandle;

        }

    if ( iClientSession )

        {

        iClientSession->Close();

        delete iClientSession;

        }

    }

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

// CWimOMAProv::Initialize()

// Initializes the WIM server cache.

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

//

EXPORT_C void CWimOMAProv::Initialize( TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimOMAProv::Initialize" ) );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    iPhase = EInitialize;

    SignalOwnStatusAndComplete();

    }

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

// CWimOMAProv::CancelInitialize()

// Cancels outgoing Initialize operation.

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

//

EXPORT_C void CWimOMAProv::CancelInitialize()

    {

    _WIMTRACE ( _L( "CWimOMAProv::CancelInitialize" ) );

    Cancel();

    }

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

// CWimOMAProv::GetSize()

// Fetches the size of provisioning information string. This information can

// be used as a notification, does provisioning information exist.

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

//

EXPORT_C void CWimOMAProv::GetSize( TInt& aSize, 

                                    const TOMAType& aOMAType, 

                                    TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimOMAProv::GetSize" ) );

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    if ( !iClientSession || !iConnectionHandle )

        {

        User::RequestComplete( iClientStatus, KErrGeneral );

        }

    else

        {

        iSize = &aSize;

        iOMAType = aOMAType;

        iPhase = EGetSize;

        SignalOwnStatusAndComplete();

        }

    }

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

// CWimOMAProv::CancelGetSize()

// Cancels ongoing GetSize operation

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

//

EXPORT_C void CWimOMAProv::CancelGetSize()

    {

    _WIMTRACE ( _L( "CWimOMAProv::CancelGetSize" ) );

    Cancel();

    }

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

// CWimOMAProv::Retrieve()

// Fetches the whole data of provisioning information string.

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

//

EXPORT_C void CWimOMAProv::Retrieve( const TOMAType& aOMAType, 

                                     TDes8& aOMAData, 

                                     TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimOMAProv::Retrieve" ) );    

    aStatus = KRequestPending;

    iClientStatus = &aStatus;

    if ( !iClientSession || !iConnectionHandle )

        {

        User::RequestComplete( iClientStatus, KErrGeneral );

        return;

        }

    if ( aOMAData.MaxLength() )

        {

        iOMAType = aOMAType;

        iData = &aOMAData;

        iPhase = ERetrieve;

        SignalOwnStatusAndComplete();

        }

    else

        {

        User::RequestComplete( iClientStatus, KErrGeneral );

        }

    }

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

// CWimOMAProv::CancelRetrieve()

// Cancels ongoing retrieve operation

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

//

EXPORT_C void CWimOMAProv::CancelRetrieve()

    {

    _WIMTRACE ( _L( "CWimOMAProv::CancelRetrieve" ) );

    Cancel();

    }

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

// CWimOMAProv::RunL()

// Different phases are handled here

// iPhase = EInitialize: Gets ClientSession handle. Tries to connect

//          to existing session. If there is no existing session, a new session 

//          is created.

// iPhase = EConnectClientSession: If new session was needed to be created, 

//          new connecting request is needed.

// iPhase = EInitializeWim: Sends initialize request to server and waits

//          asyncronously.

// iPhase = EInitializeDone: Initialization is ready.

// iPhase = EGetSize: Gets OMA data type and data size from WIM Server

// iPhase = EGetSizeDone: WIM server has sent data to client and client copies

//                        data forward to caller.

// iPhase = ERetrieve: Retrieves OMA binary data from WIM Server according to

//                     type

// iPhase = ERetrieveDone: WIM Server has sent data and client copies data 

//                         forward to caller.

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

//

void CWimOMAProv::RunL()

    {

    switch ( iPhase ) 

        {

        case EInitialize:

            {    

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EInitialize" ) );

             //get ClientSession handle

            iClientSession = RWimMgmt::ClientSessionL();

            iPhase = EConnectClientSession;

            TInt retval = 0;

            iWimStartErr = iClientSession->Connect();

            if ( iWimStartErr == KErrNotFound ) 

                {

                retval = iClientSession->StartWim();

                if( retval != KErrNone )

                    {

                    User::RequestComplete( iClientStatus, retval ); 

                    }

                else

                    {

                    SignalOwnStatusAndComplete();

                    }

                }

            else

                {

                 SignalOwnStatusAndComplete(); 

                }

            break;

            }

        case EConnectClientSession:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EConnectClientSession" ) );

            //Raise iPhase

            iPhase = EInitializeWim; 

            if ( iWimStartErr )

                {

                //New session was needed to be created. Try to reconnect.

                iWimStartErr = iClientSession->Connect();

                if ( iWimStartErr )

                    {

                    //Failed to connect. No reason to continue.

                    User::RequestComplete( iClientStatus, iWimStartErr );

                    }

                else

                    {

                    SignalOwnStatusAndComplete();

                    }

                }

            else

                {

                SignalOwnStatusAndComplete();

                }

            break;

            }

        case EInitializeWim:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EInitializeWim" ) );

            //Initialize WIM

            SetActive();

            iClientSession->Initialize( iStatus );

            iPhase = EInitializeDone;

            break;   

            }

        case EInitializeDone:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EInitializeDone" ) );

            if ( iStatus.Int() == KErrNone )

                {

                 //Get connection handle to WIM Server.

                iConnectionHandle = RWimCertMgmt::ClientSessionL(); 

                }

            User::RequestComplete( iClientStatus, iStatus.Int() );

            break;

            }

        case EGetSize:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EGetSize" ) );

            TOmaProv omaProv;

            omaProv.iOmaType = iOMAType;

            iConnectionHandle->RetrieveOmaDataL( omaProv, 

                                                 iStatus, 

                                                 EGetOMAFileSize );

            iPhase = EGetSizeDone;

            SetActive();

            break;

            }

        case EGetSizeDone:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: EGetSizeDone" ) );

            if ( iStatus.Int() == KErrNone )

                {

                TPckgBuf<TOmaProv> omaProvPckgBuf;

                omaProvPckgBuf.operator = 

                    ( *iConnectionHandle->TOmaProvPckgBuf()->PckgBuf() );

                *iSize = omaProvPckgBuf().iSize;

                }

            iConnectionHandle->DeallocOmaDataPckgBuf();

            User::RequestComplete( iClientStatus, iStatus.Int() );

            break;

            }

        case ERetrieve:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: ERetrieve" ) );

            AllocMemoryForOmaProvStructL( iData->MaxLength() );

            TOmaProv omaProv;

            omaProv.iOmaData = iOmaProvBufPtr;

            omaProv.iOmaType = iOMAType;

            iConnectionHandle->RetrieveOmaDataL( omaProv, 

                                                 iStatus,

                                                 EGetOMAFile );

            iPhase = ERetrieveDone;

            SetActive();

            break;

            }

        case ERetrieveDone:

            {

            _WIMTRACE ( _L( "CWimOMAProv::RunL case: ERetrieveDone" ) );

            if ( iStatus.Int() == KErrNone )

                {

                TPtr8 ptr = iOmaProvBuf->Des();

                iData->Copy( ptr );

                }

            DeallocMemoryFromOmaProvStruct();

            iConnectionHandle->DeallocOmaDataPckgBuf();

            User::RequestComplete( iClientStatus, iStatus.Int() );

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CWimOMAProv::AllocMemoryForOmaProvStructL()

// Allocates memory for OMA binary data

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

void CWimOMAProv::AllocMemoryForOmaProvStructL( const TInt aDataLength )

    {

    _WIMTRACE ( _L( "CWimOMAProv::AllocMemoryForOmaProvStructL" ) );

    if ( aDataLength )

        {

        iOmaProvBuf = HBufC8::NewL( aDataLength );

        iOmaProvBufPtr = new( ELeave ) TPtr8( iOmaProvBuf->Des() );

        }

    }

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

// CWimOMAProv::DeallocMemoryFromOmaProvStruct()

// Deallocates memory from member variables

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

void CWimOMAProv::DeallocMemoryFromOmaProvStruct()

    {

    _WIMTRACE ( _L( "CWimOMAProv::DeallocMemoryFromOmaProvStruct" ) );

    delete iOmaProvBuf;

    delete iOmaProvBufPtr;

    iOmaProvBuf = NULL;

    iOmaProvBufPtr = NULL;

    }

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

// CWimOMAProv::DoCancel()

// Deallocates member variables and completes client status with

// KErrCancel error code.

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

//

void CWimOMAProv::DoCancel()

    {

    _WIMTRACE ( _L( "CWimOMAProv::DoCancel" ) );

    if ( iConnectionHandle && 

         ( iPhase == EGetSizeDone || iPhase == ERetrieveDone ) )

        {

        iConnectionHandle->DeallocOmaDataPckgBuf();

        }

    DeallocMemoryFromOmaProvStruct();

    User::RequestComplete( iClientStatus, KErrCancel );

    }

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

// CWimOMAProv::RunError()

// The active scheduler calls this function if this active object's RunL() 

// function leaves. This gives this active object the opportunity to perform 

// any necessary cleanup.

// After cleanup, complete request with received error code.

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

//

TInt CWimOMAProv::RunError( TInt aError )

    {

    _WIMTRACE ( _L( "CWimOMAProv::RunError Error = %d" ) );

    if ( iConnectionHandle && 

         ( iPhase == EGetSizeDone || iPhase == ERetrieveDone ) )

        {

        iConnectionHandle->DeallocOmaDataPckgBuf();

        }

    DeallocMemoryFromOmaProvStruct();

    User::RequestComplete( iClientStatus, aError );

    return KErrNone;

    }

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

// CWimOMAProv::SignalOwnStatusAndComplete()       

// Sets own iStatus to KRequestPending, and signals it 

// with User::RequestComplete() -request. This gives chance 

// active scheduler to run other active objects. After a quick

// visit in actives cheduler, signal returns to RunL() and starts next

// phase of operation. 

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

//

void CWimOMAProv::SignalOwnStatusAndComplete()

    {

    _WIMTRACE ( _L( "CWimOMAProv::SignalOwnStatusAndComplete" ) );

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

// End of File