/*

* 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:  PEC client plugin.

*

*/

// INCLUDE FILES

#include <E32std.h>

#include "MIMPSSharedData.h"

#include "CIMPSSharedDataFactory.h"

#include "IMPSUIDDefs.h"

//PEC attributes

#include <CPEngAttributeTransaction2.h>

#include <CPEngAttributeStore2.h>

#include <MPEngPresenceAttrModel2.h>

#include <MPEngPresenceAttrTypeProperties2.h>

//PEC attribute lists

#include <CPEngAttributeListStore2.h>

#include <CPEngAttributeListTransaction2.h>

#include <MPEngAttributeList2.h>

//PEC contact lists

#include <CPEngContactListStore2.h>

#include <CPEngContactListTransaction2.h>

#include <MPEngContactList2.h>

// PEC

#include <CPEngNWSessionSlotID2.h>

#include <PEngWVServices2.h>

#include <ImpsServices.h>

#include <PEngWVPresenceErrors2.h>

#include <PEngWVPresenceAttributes2.h>

#include <WVSettingsSharedDataNG.h>

#include "CCnUiClientPluginPEC.h"

#include "IMPSPublishLevelPolicy.h"

#include "impspresenceconnectionuiconstsng.h"

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

// Two-phased constructor.

CCnUiClientPluginPEC* CCnUiClientPluginPEC::NewL( CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aNWSessionSlotID );

    CleanupStack::Pop( self ); //self

    return self;

    }

// Destructor

CCnUiClientPluginPEC::~CCnUiClientPluginPEC()

    {

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

CCnUiClientPluginPEC::CCnUiClientPluginPEC()

        : CCnUiClientPluginBase( EIMPSConnClientPEC )

    {

    }

// Symbian OS default constructor can leave.

void CCnUiClientPluginPEC::ConstructL( CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    CCnUiClientPluginBase::ConstructL( aNWSessionSlotID );

    }

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

// CCnUiClientPluginPEC::CurrentConnectionModeSettingL()

// From MCnUiClientPlugin

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

//

TCnUiConnectionMode CCnUiClientPluginPEC::CurrentConnectionModeSettingL()

    {

    // dummy implementation

    TCnUiConnectionMode cMode( ECnUiCMAutomatic );

    return cMode;

    }

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

// CCnUiClientPluginPEC::ReWakeAutomaticConnectionModeL()

// From MCnUiClientPlugin

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

//

void CCnUiClientPluginPEC::ReWakeAutomaticConnectionModeL()

    {

    // this is no longer needed

    }

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

// CCnUiClientPluginPEC::ConnectionOpenInitL()

// From MCnUiClientPlugin - connection open related methods

// Overloaded from CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::ConnectionOpenInitL( TBool aSapConnectionOpen,

                                                const CIMPSSAPSettings& aSap )

    {

    //let first the base class to do its things like disable synchronization

    //of unknown lists

    CCnUiClientPluginBase::ConnectionOpenInitL( aSapConnectionOpen, aSap );

    //if opening real NW connection, initialize the local

    //attribute lists and attributes here as needed

    //==>they will get synchronized with PEC engine login & synchronization

    if ( !aSapConnectionOpen )

        {

        IMPSPublishLevelPolicy::InitializePublishLevelL( *iNWSessionSlotID );

        }

    }

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

// CCnUiClientPluginPEC::DoPostLoginProsessingL()

// From MCnUiClientPlugin - connection open related methods

// Overloaded from CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoPostLoginProsessingL( TRequestStatus& aStatus )

    {

    //do first the client specific things (enable profiles presence updates)

    MIMPSSharedData* sharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(

                                      NULL,

                                      KIMPSProfileEngineKeyUid );

    //From SharedDataKeys.h

    //1 == allowed to update Presence attributes

    //ignore possible settings errors, all this is done with best effort way...

    sharedData->SetIntKey( EIMPSSharedKeysProEngAllowUpdatePresence, 1 );

    delete sharedData;

    //and the let the base class take the charge...

    //NOTE!! Order must be this becase the base might start something

    //asynhronous & and after that leaving isn't allowd...

    CCnUiClientPluginBase::DoPostLoginProsessingL( aStatus );

    }

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

// CCnUiClientPluginPEC::DoPreLogoutProsessingL()

// From MCnUiClientPlugin - connection close related methods

// Overloaded from CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoPreLogoutProsessingL( TRequestStatus& aStatus )

    {

    //do first the client specific things (disable profiles presence updates)

    MIMPSSharedData* sharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(

                                      NULL,

                                      KIMPSProfileEngineKeyUid );

    //From SharedDataKeys.h

    //0 == not allowed to update Presence attributes, default

    //ignore possible settings errors, all this is done with best effort way...

    sharedData->SetIntKey( EIMPSSharedKeysProEngAllowUpdatePresence, 0 );

    delete sharedData;

    //and the let the base class take the charge...

    //NOTE!! Order must be this becase the base might start something

    //asynhronous & and after that leaving isn't allowd...

    CCnUiClientPluginBase::DoPreLogoutProsessingL( aStatus );

    }

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

// CCnUiClientPluginPEC::DoVerifySapCapabilities()

// From CCnUiClientPluginBase

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

//

TBool CCnUiClientPluginPEC::DoVerifySapCapabilities( TPEngWVCspServicesTree2 aCurrentNwServices )

    {

    // For PEC WV server must support all of these main features

    // Logical and is used

    //==> if any of these is EFalse, result will be EFalse

    TBool capabOK = aCurrentNwServices.iFundamentalFeat.FeatureSupported();

    capabOK &= aCurrentNwServices.iFundamentalFeat.SubFunctionSupported( KPEngFFSubFuncSRCH );

    capabOK &= aCurrentNwServices.iFundamentalFeat.SubFunctionSupported( KPEngFFSubFuncSTSRC );

    capabOK &= aCurrentNwServices.iPresenceFeat.FeatureSupported();

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncGCLI );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncCCLI );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncDCLI );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncMCLS );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncGETWL );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncGETPR );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncUPDPR );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncCALI );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncDALI );

    capabOK &= aCurrentNwServices.iPresenceFeat.SubFunctionSupported( KPEngWVSubFuncGALS );

    return capabOK;

    }

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

// CCnUiClientPluginPEC::DoClientKnownCntListsLC()

// Template method from CCnUiClientPluginBase

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

//

CDesCArray* CCnUiClientPluginPEC::DoClientKnownCntListsLC()

    {

    CDesCArrayFlat* lists = new ( ELeave ) CDesCArrayFlat( 4 ); //4 known lists

    CleanupStack::PushL( lists );

    //enumerate here those lists that are used by PEC & needs to be

    //synchronized when PEC is doing login

    CPEngContactListStore2* contactListStore = CPEngContactListStore2::NewLC( *iNWSessionSlotID );

    const MDesCArray& array = contactListStore->AllContactListsL();

    for ( TInt i = 1; i < array.MdcaCount(); i++ )

        {

        TPtrC list = array.MdcaPoint( i );

        if ( list.FindF( KIMPSPECContactListIdentifier() ) != KErrNotFound  )

            {

            // this seems to be PECUi's list

            lists->AppendL( list );

            }

        }

    CleanupStack::PopAndDestroy( contactListStore );

    return lists;

    }

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

// CCnUiClientPluginPEC::DoStartExplicitPostLoginSyncL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoStartExplicitPostLoginSyncL()

    {

    // first do the base synchronization

    User::LeaveIfError( iPEngCntListPublisher->BaseSynchronizeContactLists( *this ) );

    SetStepProcessingActive();

    iStepId = EBaseCntListSynch;

    }

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

// CCnUiClientPluginPEC::DoHandleExplicitPostLoginSyncStepCompleteL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoHandleExplicitPostLoginSyncStepCompleteL( TStepId aStepId,

                                                                       TInt& aStepStatus )

    {

    switch ( aStepId )

        {

        case EBaseCntListSynch:

            {

            if ( aStepStatus == KErrNone )

                {

                //initialize the local attribute lists as needed

                IMPSPublishLevelPolicy::InitializePublishLevelL( *iNWSessionSlotID );

                //and synchronize known PEC list explicitly with network server

                MDesCArray* knownLists = DoClientKnownCntListsLC();

                User::LeaveIfError( iPEngCntListPublisher->SynchronizeContactLists(

                                        *knownLists,

                                        *this ) );

                CleanupStack::PopAndDestroy();  //knownLists

                SetStepProcessingActive();

                iStepId = ECntListPublish;

                }

            break;

            }

        case ECntListPublish:

            {

            if ( ( aStepStatus == KErrNone ) ||

                 ( aStepStatus == KPEngNwErrPartiallySuccessful ) )

                {

                //Contact lists are now successfully synchronized

                aStepStatus = KErrNone;

                User::LeaveIfError( iPEngAttributeListPublisher->PublishAttributeLists( *this ) );

                SetStepProcessingActive();

                iStepId = EAttribListPublish;

                }

            break;

            }

        case EAttribListPublish:

            {

            if ( ( aStepStatus == KErrNone ) ||

                 ( aStepStatus == KPEngNwErrPartiallySuccessful ) )

                {

                //Attribute lists are now successfully synchronized

                aStepStatus = KErrNone;

                UpdateAttributesL();

                SetStepProcessingActive();

                iStepId = EAttributePublish;

                }

            break;

            }

        case EAttributePublish:

            {

            //ignore possibly from attribute publish propagating errors

            aStepStatus = KErrNone;

            break;

            }

        default:

            {

            //nothing to do

            break;

            }

        }

    }

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

// CCnUiClientPluginPEC::DoStartPreLogoutPublishL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoStartPreLogoutPublishL()

    {

    }

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

// CCnUiClientPluginPEC::DoHandlePreLogoutPublishStepCompleteL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginPEC::DoHandlePreLogoutPublishStepCompleteL( TStepId /*aStepId*/,

                                                                  TInt& /*aStepStatus*/ )

    {

    }

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

// CCnUiClientPluginPEC::DoHandlePreLogoutPublishStepCompleteL()

//

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

//

void CCnUiClientPluginPEC::UpdateAttributesL()

    {

    RPointerArray<MPEngPresenceAttrModel2> models;

    CleanupStack::PushL( TCleanupItem( DestroyCloseModelArray, &models ) );

    MPEngPresenceAttrModel2* userAvail = NULL;

    TInt err = iPEngAttributeStore->GetAndLockOwnAttribute( KUidPrAttrUserAvailability,

                                                            userAvail );

    // if the model was locked, the pointer is still null, but we want to continue with

    // the other attributes

    if ( ( err != KErrNone ) && ( err != KErrLocked  ) )

        {

        User::Leave( err );

        }

    else

        {

        CleanupClosePushL( *userAvail );

        models.AppendL( userAvail );

        CleanupStack::Pop(); // userAvail

        }

    MPEngPresenceAttrModel2* onlineStatus = NULL;

    err = iPEngAttributeStore->GetAndLockOwnAttribute( KUidPrAttrOnlineStatus, onlineStatus );

    // if the model was locked, the pointer is still null, but we want to continue with

    // the other attributes

    if ( ( err != KErrNone ) && ( err != KErrLocked  ) )

        {

        User::Leave( err );

        }

    else

        {

        CleanupClosePushL( *onlineStatus );

        onlineStatus->SetQualifier( ETrue );

        models.AppendL( onlineStatus );

        CleanupStack::Pop(); // onlineStatus

        }

    MPEngPresenceAttrModel2* clientInfo = NULL;

    err = iPEngAttributeStore->GetAndLockOwnAttribute( KUidPrAttrClientInfo, clientInfo );

    // if the model was locked, the pointer is still null, but we want to continue with

    // the other attributes

    if ( ( err != KErrNone ) && ( err != KErrLocked  ) )

        {

        User::Leave( err );

        }

    else

        {

        CleanupClosePushL( *clientInfo );

        models.AppendL( clientInfo );

        CleanupStack::Pop(); // clientInfo

        }

    MPEngPresenceAttrModel2* statusText = NULL;

    err = iPEngAttributeStore->GetAndLockOwnAttribute( KUidPrAttrStatusText, statusText );

    // if the model was locked, the pointer is still null, but we want to continue with

    // the other attributes

    if ( ( err != KErrNone ) && ( err != KErrLocked  ) )

        {

        User::Leave( err );

        }

    else

        {

        CleanupClosePushL( *statusText );

        models.AppendL( statusText );

        CleanupStack::Pop(); // statusText

        }

    MPEngPresenceAttrModel2* statusContent = NULL;

    err = iPEngAttributeStore->GetAndLockOwnAttribute( KUidPrAttrStatusContent, statusContent );

    // if the model was locked, the pointer is still null, but we want to continue with

    // the other attributes

    if ( ( err != KErrNone ) && ( err != KErrLocked  ) )

        {

        User::Leave( err );

        }

    else

        {

        CleanupClosePushL( *statusContent );

        models.AppendL( statusContent );

        CleanupStack::Pop(); // statusContent

        }

    User::LeaveIfError( iPEngAttributePublisher->PublishAndUnLockOwnAttributes( models, *this ) );

    CleanupStack::Pop(); // models

    }

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

// CCnUiClientPluginPEC::DestroyCloseModelArray()

//

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

//

void CCnUiClientPluginPEC::DestroyCloseModelArray( TAny* aObject )

    {

    reinterpret_cast<RPointerArray<MPEngPresenceAttrModel2>*>( aObject )->ResetAndDestroy();

    }

//  End of File