/*
* Copyright (c) 2005-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:  Phonebook 2 UI Service server application connection.
*
*/


#include "CPbk2ServerAppConnection.h"

// Phonebook 2
#include "MPbk2ConnectionObserver.h"
#include "CPbk2ExitServiceMonitor.h"
#include "CPbk2AcceptServiceMonitor.h"
#include <Pbk2InternalUID.h>

// System includes
#include <coemain.h>

// Debugging headers
#include <Pbk2Debug.h>

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::CPbk2ServerAppConnection
// --------------------------------------------------------------------------
//
CPbk2ServerAppConnection::CPbk2ServerAppConnection
        ( MPbk2ConnectionObserver& aObserver ) :
            CActive( EPriorityStandard ),
            iObserver( aObserver )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::CPbk2ServerAppConnection()") );
    CActiveScheduler::Add( this );
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::~CPbk2ServerAppConnection
// --------------------------------------------------------------------------
//
CPbk2ServerAppConnection::~CPbk2ServerAppConnection()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::~CPbk2ServerAppConnection()") );
    Cancel();
    delete iArrayResults;
    delete iFieldResults;
    DisconnectMonitors();
    DisconnectServerApplication();
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::NewL
// --------------------------------------------------------------------------
//
CPbk2ServerAppConnection* CPbk2ServerAppConnection::NewL
        ( MPbk2ConnectionObserver& aObserver )
    {
    CPbk2ServerAppConnection* self =
        new ( ELeave ) CPbk2ServerAppConnection( aObserver );
    return self;
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::LaunchAssignL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::LaunchAssignL
        ( HBufC8* aConfigurationPackage, HBufC8* aDataPackage,
          HBufC8* aAssignInstructions )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::LaunchAssignL()") );
    // Need to trap, because consumer freezes if ConnectL function leaves.
    // Reason for the freeze is that connection stays open.
    TRAPD( error, ConnectL() );
    if ( error == KErrNone )
        {
        iPbk2AppService.LaunchAssignL(
            iStatus,  aConfigurationPackage, aDataPackage,
            aAssignInstructions, iCanceled );
        SetActive();
        }
    else
        {
        DisconnectMonitors();
        DisconnectServerApplication();
        User::Leave( error );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::LaunchAttributeAssignL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::LaunchAttributeAssignL
    ( HBufC8* aConfigurationPackage,
      TPbk2AttributeAssignData& aAttributePackage,
      HBufC8* aAssignInstructions )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::LaunchAttributeAssignL()") );
    ConnectL();
    iPbk2AppService.LaunchAttributeAssignL
        ( iStatus,  aConfigurationPackage, aAttributePackage,
          aAssignInstructions, iCanceled );
    SetActive();
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::LaunchAttributeUnassignL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::LaunchAttributeUnassignL
    ( HBufC8* aConfigurationPackage,
      TPbk2AttributeAssignData aAttributePackage,
      HBufC8* aAssignInstructions )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::LaunchAttributeUnassignL()") );
    ConnectL();
    iPbk2AppService.LaunchAttributeUnassignL
        ( iStatus,  aConfigurationPackage, aAttributePackage,
          aAssignInstructions, iCanceled );
    SetActive();
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::CancelAssign
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::CancelAssign()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::CancelAssign()") );
    if ( iPbk2AppService.Handle() != KNullHandle )
        {
        iPbk2AppService.CancelAssign( iCanceled );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::LaunchFetchL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::LaunchFetchL
        ( HBufC8* aConfigurationPackage, HBufC8* aFetchInstructions )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::LaunchFetchL()") );
    //AIW Cancel command uses CancelFetch and leaves AO active,
    //call here Cancel() to avoid using active AO (E32User-CBase 42)
    Cancel();
    // Need to trap, because consumer freezes if ConnectL function leaves.
    // Reason for the freeze is that connection stays open.
    TRAPD( error, ConnectL() );

    if ( error == KErrNone )
        {
        iPbk2AppService.LaunchFetchL
            ( iStatus, aConfigurationPackage,
              aFetchInstructions, iCanceled );
        SetActive();
        }
    else
        {
        DisconnectMonitors();
        DisconnectServerApplication();
        User::Leave( error );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::CancelFetch
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::CancelFetch()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::CancelFetch()") );
    if ( iPbk2AppService.Handle() != KNullHandle )
        {
        iPbk2AppService.CancelFetch( iCanceled );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::RunL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::RunL()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::RunL(%d)"), iStatus.Int() );
    switch( iStatus.Int() )
        {
        case KErrNone:
            {
            GetResultsL();
            iObserver.OperationCompleteL( *iArrayResults, iExtraResultData,
                *iFieldResults );
            DisconnectMonitors();
            DisconnectServerApplication();
            break;
            }
        case KErrCancel:            // FALLTHROUGH
        case KErrServerTerminated:
            {
            iObserver.OperationCanceledL();
            DisconnectMonitors();
            DisconnectServerApplication();
            break;
            }
        case KErrAbort:
            {
            // Abort is like completion with KErrCancel,
            // expect that we leave the server application alive
            // and wait for it to close itself down and send
            // HandleServerAppExit notification
            iObserver.OperationCanceledL();
            DisconnectMonitors();
            break;
            }
        default:
            {
            // Delegate to RunError
            User::Leave( iStatus.Int() );
            break;
            }
        };
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::RunError
// --------------------------------------------------------------------------
//
TInt CPbk2ServerAppConnection::RunError( TInt aError )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::RunError(%d)"), aError );
    TRAPD( err,  iObserver.OperationErrorL( aError ) );
    DisconnectMonitors();
    DisconnectServerApplication();
    return err;
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::DoCancel
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::DoCancel()
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::DoCancel()") );
    // Cancels outstanding notification monitors
    if ( iExitServiceMonitor )
        {
        iExitServiceMonitor->Cancel();
        }
    if ( iAcceptServiceMonitor )
        {
        iAcceptServiceMonitor->Cancel();
        }

    // Cancels outstanding operations
    CancelAssign();
    CancelFetch();
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::HandleServerAppExit
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::HandleServerAppExit( TInt aReason )
    {
    PBK2_DEBUG_PRINT( PBK2_DEBUG_STRING(
        "CPbk2ServerAppConnection::HandleServerAppExit(%d)"), aReason );
    TBool okToExit = EFalse;

    // Query the observer whether it is ok to exit application
    // (the consumer process)
    TRAPD( err,
        okToExit = iObserver.OkToExitL( aReason, EPbk2ExitApplication ) );

    if ( err != KErrNone )
        {
        CCoeEnv::Static()->HandleError( err );
        }

    if (okToExit)
        {
        MAknServerAppExitObserver::HandleServerAppExit( aReason );
        }
    else
        {
        DisconnectServerApplication();
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::ConnectL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::ConnectL()
    {
    if ( iPbk2AppService.Handle() == KNullHandle )
        {
        iPbk2AppService.ConnectChainedAppL
            ( TUid::Uid( KPbk2ServerAppUID3 ) );

        delete iExitAppServerMonitor;
        iExitAppServerMonitor = NULL;
        iExitAppServerMonitor = CApaServerAppExitMonitor::NewL
            ( iPbk2AppService, *this, CActive::EPriorityStandard );

        delete iExitServiceMonitor;
        iExitServiceMonitor = NULL;
        iExitServiceMonitor = CPbk2ExitServiceMonitor::NewL
            ( iPbk2AppService, iObserver );

        delete iAcceptServiceMonitor;
        iAcceptServiceMonitor = NULL;
        iAcceptServiceMonitor = CPbk2AcceptServiceMonitor::NewL
            ( iPbk2AppService, iObserver );
        }
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::GetResultsL
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::GetResultsL()
    {
    // Important to delete old results
    delete iArrayResults;
    iArrayResults = NULL;
    delete iFieldResults;
    iFieldResults = NULL;

    iExtraResultData = KErrNotSupported;

    // First get the result size
    TInt arraySize = 0;
    TInt fieldSize = 0;
    iPbk2AppService.GetResultSizeL( arraySize, fieldSize );
    iArrayResults = HBufC8::NewL( arraySize );
    iFieldResults = HBufC::NewL( fieldSize );

    // Then get the results
    iPbk2AppService.GetResultsL( *iArrayResults, iExtraResultData,
        *iFieldResults );
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::DisconnectMonitors
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::DisconnectMonitors()
    {
    delete iExitServiceMonitor;
    iExitServiceMonitor = NULL;
    delete iAcceptServiceMonitor;
    iAcceptServiceMonitor = NULL;
    }

// --------------------------------------------------------------------------
// CPbk2ServerAppConnection::DisconnectServerApplication
// --------------------------------------------------------------------------
//
void CPbk2ServerAppConnection::DisconnectServerApplication()
    {
    delete iExitAppServerMonitor;
    iExitAppServerMonitor = NULL;
    iPbk2AppService.Close();
    }

// End of File