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