/*

* 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:  IM client plug-in.

*

*/

// INCLUDE FILES

#include "CCnUiClientPluginIM.h"

#include "CIMPSSharedDataFactory.h"

#include "IMPSSharedDataDefs.h"

#include "IMPSUIDDefs.h"

#include "impscommonuibuilddefinitions.h"

//PEC attributes

#include <CPEngAttributeTransaction2.h>

#include <CPEngAttributeStore2.h>

#include <MPEngPresenceAttrModel2.h>

#include <MPEngPresenceAttrTypeProperties2.h>

#include <PEngWVPresenceAttributes2.h>

//PEC attribute lists

#include <CPEngAttributeListStore2.h>

#include <CPEngAttributeListTransaction2.h>

#include <MPEngAttributeList2.h>

//PEC contact lists

#include <CPEngContactListTransaction2.h>

#include <CPEngContactListStore2.h>

#include <MPEngContactList2.h>

#include <PEngWVServices2.h>

// built-in resource reader

#include "CnUiResourceFileName.h"

#include "PAppVariationNG.hrh"

#include <IMPSConnectionUiNG.rsg>

#include <eikenv.h>

#include <StringLoader.h>

#include <barsread.h>

#include <ImpsServices.h>

#include <PEngWVPresenceErrors2.h>

#include <WVSettingsSharedDataNG.h>

#include <E32std.h>

#include <e32property.h>

#include <CIMPSSAPSettings.h>

#include 	"VariantKeys.h"

#include 	<centralrepository.h>

#include "CIMPSSharedDataFactory.h"

#include "MIMPSSharedData.h"

// CONSTANTS

_LIT( KPanicAttribute, "IMPSCommonUi Attribute" );

enum TIMAuthValues

    {

    EIMAuthValueAll = 0,

    EIMAuthValueFriends,

    EIMAuthValueNobody

    };

// Authorize IM presence

_LIT( KIMPresenceAuth,  "IMAuthIMPr" );

// Table of userId specific Aliases

_LIT( KIMOwnAlias,      "IMOwnAlias" );

// Separators for Alias table, to separate items from each other

// e.g [userid][itemsep][alias][tablesep][userid][itemsep][alias] etc...

//

const TUint KAliasItemSeparator  = 0x10;

const TUint KAliasTableSeparator = 0x11;

const TInt  KSeparatorSize       = 2; // bytes

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

// Two-phased constructor.

CCnUiClientPluginIM* CCnUiClientPluginIM::NewL( CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aNWSessionSlotID );

    CleanupStack::Pop( self ); //self

    return self;

    }

// Destructor

CCnUiClientPluginIM::~CCnUiClientPluginIM()

    {

    delete iSharedData;

    iRFs.Close();

    delete iAlias;

    }

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

// might leave.

//

CCnUiClientPluginIM::CCnUiClientPluginIM()

        : CCnUiClientPluginBase( EIMPSConnClientIM )

    {

    }

// Symbian OS default constructor can leave.

void CCnUiClientPluginIM::ConstructL( CPEngNWSessionSlotID2& aNWSessionSlotID )

    {

    CCnUiClientPluginBase::ConstructL( aNWSessionSlotID );

    iSharedData = CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL( NULL, KBrandingUid );

    iRAUsed = 1 == ReadResourceIntValueL( RSC_CHAT_VARIATION_IMPSCU_REACTIVE_AUTHORIZATION );

    iAliasUsed = 1 == ReadResourceIntValueL( RSC_CHAT_VARIATION_USE_ALIAS_ATTRIBUTE );

    }

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

// CCnUiClientPluginIM::CurrentConnectionModeSettingL()

// From MCnUiClientPlugin

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

//

TCnUiConnectionMode CCnUiClientPluginIM::CurrentConnectionModeSettingL()

    {

    MIMPSSharedData* sharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(

                                      NULL,

                                      KIMPSServSettUid );

    TInt loginTypeSetting( EWVSettingsChatLoginManual );

    // ignore return value since loginTypeSettings is unchanged from default if error occurs

    sharedData->GetIntKey( EIMPSSharedKeysIMLogin, loginTypeSetting );

    delete sharedData;

    TCnUiConnectionMode cMode( ECnUiCMAutomatic );

    if ( ( loginTypeSetting == EWVSettingsChatLoginManual ) ||

         ( loginTypeSetting == EWVSettingsChatLoginApplicationLaunch ) )

        {

        cMode = ECnUiCMManual;

        }

    return cMode;

    }

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

// CCnUiClientPluginIM::ReWakeAutomaticConnectionModeL()

// From MCnUiClientPlugin

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

//

void CCnUiClientPluginIM::ReWakeAutomaticConnectionModeL()

    {

    MIMPSSharedData* sharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(

                                      NULL,

                                      KIMPSServSettUid );

    TInt loginTypeSetting( EWVSettingsChatLoginManual );

    // ignore return value since loginTypeSettings is unchanged from default if error occurs

    sharedData->GetIntKey( EIMPSSharedKeysIMLogin, loginTypeSetting );

    delete sharedData;

    if ( ( loginTypeSetting == EWVSettingsChatLoginAutoAlways ) ||

         ( loginTypeSetting == EWVSettingsChatLoginAutoInHomeNW ) )

        {

        //current mode setting is automatic

        //==> re-wake with same mode

        MIMPSSharedData* loginTypeNotifier = CIMPSSharedDataFactory::CreateTemporaryKeyHandlerL(

                                                 NULL,

                                                 KIMPSServSettNotifyUid );

        // just set the key

        TInt err = loginTypeNotifier->SetIntKey( EIMPSSharedKeysServSettLoginTypeChangedIM, 0 );

        delete loginTypeNotifier;

        if ( err )

            {

            User::Leave( err );

            }

        }

    }

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

// CCnUiClientPluginIM::ConnectionOpenInitL()

// From MCnUiClientPlugin - connection open related methods

// Overloaded from CCnUiClientPluginBase

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

//

void CCnUiClientPluginIM::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 );

    // Get presence authorization level value

    iPresenceAuth = 0;  // use 0 as default value

    aSap.GetOpaqueInt( KIMPresenceAuth, iPresenceAuth );

    // Get and cache alias

    TPtrC aliasPtr( KNullDesC );

    if ( aSap.GetOpaqueDesC16( KIMOwnAlias, aliasPtr ) == KErrNone )

        {

        HBufC* userId = GetSharedDataL( EIMPSSharedKeysIMUserId );

        CleanupStack::PushL( userId );

        if ( userId->Length() != 0 )

            {

            TInt index = KErrNotFound;

            TInt length = 0;

            LocateAliasL( aliasPtr, *userId, index, length );

            if ( index != KErrNotFound )

                {

                // found correct alias

                iAlias = aliasPtr.Mid( index, length ).AllocL();

                }

            }

        CleanupStack::PopAndDestroy( userId );

        }

    // default value

    if ( !iAlias )

        {

        iAlias = KNullDesC().AllocL();

        }

    }

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

// CCnUiClientPluginIM::DoVerifySapCapabilities()

// From CCnUiClientPluginBase

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

//

TBool CCnUiClientPluginIM::DoVerifySapCapabilities( TPEngWVCspServicesTree2 aCurrentNwServices )

    {

    // For IM + Presence use WV server must support all of

    // PEC engine needed main features + IM Specific ones...

    // Logical and is used

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

    TBool capabOK = ETrue;

    capabOK = aCurrentNwServices.iPresenceFeat.FeatureSupported();

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

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

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

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

    capabOK &= aCurrentNwServices.iPresenceFeat.FunctionSupported( KPEngWVPresDelivFunction );

    // IM feature capability check

    capabOK &= aCurrentNwServices.iIMFeat.FeatureSupported();

    capabOK &= aCurrentNwServices.iIMFeat.SubFunctionSupported( KPEngIMSubFuncNEWM );

    iAttribListsSupported = aCurrentNwServices.iPresenceFeat.FeatureSupported();

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

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

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

    return capabOK;

    }

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

// CCnUiClientPluginIM::DoClientKnownCntListsLC()

// Template method from CCnUiClientPluginBase

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

//

CDesCArray* CCnUiClientPluginIM::DoClientKnownCntListsLC()

    {

    //no way to know the number of lists so putting 1 as granularity

    CDesCArrayFlat* lists = new ( ELeave ) CDesCArrayFlat( 1 );

    CleanupStack::PushL( lists );

    CPEngContactListStore2* contactListStore =

        CPEngContactListStore2::NewLC( *iNWSessionSlotID );

    // get all contact lists

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

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

        {

        TPtrC list = array.MdcaPoint( i );

        // now adding all list, except watcher list

        // (also other old PEC UI -lists)

        if ( 0 != list.CompareF( KPEngWatcherList ) )

            {

            // this seems to be IM's list

            lists->AppendL( list );

            }

        }

    CleanupStack::PopAndDestroy( contactListStore );

    return lists;

    }

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

// CCnUiClientPluginIM::DoStartExplicitPostLoginSyncL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginIM::DoStartExplicitPostLoginSyncL()

    {

    // first do the base synchronization

    if ( CurrentConnectionModeSettingL() == ECnUiCMAutomatic )

        {

        // When AO is active we need to basesync lists so that we can

        // update our attribute lists.

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

        SetStepProcessingActive();

        iStepId = ECntListPublish;

        }

    else // Manual login mode

        {

        // we can directly publish our attributes.

        iStepId = EAttribListPublish;

        IssueIMAttributeUpdateAndPublishIfNeededL( iPresenceAuth );

        }

    }

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

// CCnUiClientPluginIM::DoHandleExplicitPostLoginSyncStepCompleteL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginIM::DoHandleExplicitPostLoginSyncStepCompleteL( TStepId aStepId,

                                                                      TInt& aStepStatus )

    {

    if ( aStepId == EBaseCntListSynch )

        {

        // We end up here only if AO and BG handling are both active.

        // We don't want to synchronize lists here so we skip that step.

        aStepId = ECntListPublish;

        }

    if ( ( aStepId == ECntListPublish ) && !iAttribListsSupported )

        {

        // if attribute lists are not suppored we can skip the next

        // step so we put EAttribListPublish as stepid

        aStepId = EAttribListPublish;

        }

    switch ( aStepId )

        {

        case EBaseCntListSynch:

            {

            if ( aStepStatus == KErrNone )

                {

                //doing explicit synchronization

                MDesCArray* knownLists = DoClientKnownCntListsLC();

                //and synchronize known IM lists explicitly with network server

                //If list synchronization is actually done, then also attribute

                //lists & attributes are synchronized. However, in some cases

                //list synchronization isn't done and in those cases IM attributes

                //must be pushed explicitly

                User::LeaveIfError( iPEngCntListPublisher->SynchronizeContactLists(

                                        *knownLists,

                                        *this ) );

                CleanupStack::PopAndDestroy();  //knownLists

                SetStepProcessingActive();

                iStepId = ECntListPublish;

                }

            break;

            }

        case ECntListPublish:

            {

            //initialize the local attribute lists & attributes as needed

            MDesCArray* knownLists = DoClientKnownCntListsLC();

            if ( iRAUsed )

                {

                // reactive authorization,

                // delete all the attribute lists

                // including default attribute list

                SetAuthorizationToNoneL( *knownLists );

                //initialize the local attribute lists & attributes as needed

                iPEngAttributeListStore->DeleteDefaultAttributeListL();

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

                SetStepProcessingActive();

                iStepId = EAttribListPublish;

                }

            else if ( ( aStepStatus == KErrNone ) ||

                      ( aStepStatus == KPEngNwErrPartiallySuccessful ) )

                {

                UpdateIMAttributeListsL( iPresenceAuth, *knownLists );

                //Contact lists are now successfully synchronized

                aStepStatus = KErrNone;

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

                SetStepProcessingActive();

                iStepId = EAttribListPublish;

                }

            CleanupStack::PopAndDestroy();  //knownLists

            break;

            }

        case EAttribListPublish:

            {

            if ( ( aStepStatus == KErrNone ) ||

                 ( aStepStatus == KPEngNwErrPartiallySuccessful ) )

                {

                //Attribute lists are now successfully synchronized

                aStepStatus = KErrNone;

                IssueIMAttributeUpdateAndPublishIfNeededL( iPresenceAuth );

                }

            break;

            }

        case EAttributePublish:

            {

            //ignore possibly from attribute publish propagating errors

            aStepStatus = KErrNone;

            break;

            }

        default:

            {

            //nothing to do

            break;

            }

        }

    }

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

// CCnUiClientPluginIM::DoStartPreLogoutPublishL()

// From CCnUiClientPluginBase

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

//

void CCnUiClientPluginIM::DoStartPreLogoutPublishL()

    {

    // nothing to do here as server takes care of OnlineStatus updating

    }

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

// CCnUiClientPluginIM::DoHandlePreLogoutPublishStepCompleteL()

// From CCnUiClientPluginBase

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

//

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

                                                                 TInt& aStepStatus )

    {

    //only attribute publish step is issued

    //ignore errors coming from it

    aStepStatus = KErrNone;

    }

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

// CCnUiClientPluginIM::IMAttributePublishLevelL()

// Private helper

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

//

TInt CCnUiClientPluginIM::IMAttributePublishLevelL()

    {

    MIMPSSharedData* sharedData = CIMPSSharedDataFactory::CreatePermanentKeyHandlerL(

                                      NULL,

                                      KIMPSChatClientKeyUid );

    TInt value( 0 );

    TInt err = sharedData->GetIntKey( EIMPSSharedKeysIMPresenceAuthSettingKey, value );

    if ( err == KErrNotFound )

        {

        // we can ignore not finding the key, since then the correct value is 0

        err = KErrNone;

        }

    delete sharedData;

    // leave on other errors

    User::LeaveIfError( err );

    return value;

    }

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

// CCnUiClientPluginIM::UpdateIMAttributeListsL()

// Private helper

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

//

void CCnUiClientPluginIM::UpdateIMAttributeListsL( TInt aPublishLevel, MDesCArray& aContactLists )

    {

    if ( aPublishLevel == EIMAuthValueAll )

        {

        SetAuthorizationToAllL( aContactLists );

        }

    else if ( aPublishLevel == EIMAuthValueFriends )

        {

        SetAuthorizationToFriendsL( aContactLists );

        }

    else

        {

        SetAuthorizationToNoneL( aContactLists );

        }

    }