/*
* Copyright (c) 2006 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: MNcdProtocolDefaultObserverImpl implementation
*
*/
#include <s32mem.h>
#include <e32property.h>
#include "catalogsdebug.h"
#include "catalogsconstants.h"
#include "catalogscontext.h"
#include "ncd_cp_actionrequest.h"
#include "ncd_cp_clientconfiguration.h"
#include "ncd_cp_detail.h"
#include "ncd_cp_query.h"
#include "ncd_cp_serverdetails.h"
#include "ncd_pp_error.h"
#include "ncd_pp_datablock.h"
#include "ncd_pp_information.h"
#include "ncd_pp_subscription.h"
#include "ncdprotocoldefaultobserverimpl.h"
#include "ncdconfigurationmanager.h"
#include "ncd_cp_cookie.h"
#include "ncdserverdetails.h"
#include "ncdproviderdefines.h"
#include "ncdsubscriptionmanagerimpl.h"
// Action targets
_LIT( KNcdActionTargetMasterServerUri, "masterServerUri" );
_LIT( KNcdActionTargetSkin, "skin" );
_LIT( KNcdActionTargetClient, "client" );
CNcdProtocolDefaultObserver* CNcdProtocolDefaultObserver::NewL(
MCatalogsContext& aContext,
MNcdConfigurationManager& aConfigurationManager,
CNcdSubscriptionManager& aSubscriptionManager,
const TDesC& aServerUri )
{
CNcdProtocolDefaultObserver* self = new(ELeave)
CNcdProtocolDefaultObserver( aContext,
aConfigurationManager, aSubscriptionManager );
CleanupStack::PushL( self );
self->ConstructL( aServerUri );
CleanupStack::Pop( self );
return self;
}
CNcdProtocolDefaultObserver::CNcdProtocolDefaultObserver(
MCatalogsContext& aContext,
MNcdConfigurationManager& aConfigurationManager,
CNcdSubscriptionManager& aSubscriptionManager )
: iContext( aContext ),
iConfigurationManager( aConfigurationManager ),
iSubscriptionManager( aSubscriptionManager )
{
}
CNcdProtocolDefaultObserver::~CNcdProtocolDefaultObserver()
{
delete iServerUri;
}
void CNcdProtocolDefaultObserver::ConstructL( const TDesC& aServerUri )
{
iServerUri = aServerUri.AllocL();
}
//*****************************************************************************
// MNcdParserConfigurationProtocolObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::ConfigurationBeginL( const TDesC& /*aVersion*/,
TInt /*aExpirationDelta*/ )
{
DLTRACEIN((""));
}
void CNcdProtocolDefaultObserver::ConfigurationQueryL(
MNcdConfigurationProtocolQuery* aQuery )
{
DLTRACEIN((""));
// The queries by now should be handled by other interested parties.
// Do nothing.
delete aQuery;
}
void CNcdProtocolDefaultObserver::ClientConfigurationL(
MNcdConfigurationProtocolClientConfiguration* aConfiguration )
{
DLTRACEIN((""));
CleanupDeletePushL( aConfiguration );
// Should interpret details to grab master server validity information,
// for example
// pass cookies to cookie handler
TInt cookieCount = aConfiguration->CookieCount();
DLINFO(("cookie count=%d",cookieCount));
// Get SSID
const TDesC8& ssid( iConfigurationManager.SsidL( iContext ) );
MNcdServerDetails& details(
iConfigurationManager.ServerDetailsL( iContext,
*iServerUri,
NcdProviderDefines::KConfigNamespace ));
for ( TInt i = 0; i < cookieCount; ++i )
{
const MNcdConfigurationProtocolCookie& cookie(
aConfiguration->CookieL( i ) );
details.AddCookieL( cookie, ssid );
}
CleanupStack::PopAndDestroy( aConfiguration );
DLTRACEOUT((""));
}
void CNcdProtocolDefaultObserver::ConfigurationDetailsL(
CArrayPtr<MNcdConfigurationProtocolDetail>* aDetails )
{
DLTRACEIN((""));
aDetails->ResetAndDestroy();
delete aDetails;
}
void CNcdProtocolDefaultObserver::ConfigurationActionRequestL(
MNcdConfigurationProtocolActionRequest* aActionRequest )
{
DLTRACEIN((""));
CleanupDeletePushL( aActionRequest );
if( aActionRequest->Type() == MNcdConfigurationProtocolActionRequest::ETypeUpdate &&
aActionRequest->UpdateDetails() )
{
DLTRACE(( "Update" ));
DLINFO(( _L("Target: %S"), &aActionRequest->Target() ));
DLINFO(( _L("Id: %S"), &aActionRequest->UpdateDetails()->Id() ));
DLINFO(( _L("Version: %S"), &aActionRequest->UpdateDetails()->Version() ));
DLINFO(( _L("Uri: %S"), &aActionRequest->UpdateDetails()->Uri() ));
DLINFO(( "Forced: %d", aActionRequest->Force() ));
DLINFO(( "Client SID %08x", iContext.SecureId().iId ));
if ( aActionRequest->Target() == KNcdActionTargetMasterServerUri &&
aActionRequest->UpdateDetails()->Uri().Length() )
{
const TDesC& currentMaster( iConfigurationManager.MasterServerAddressL(
iContext ) );
// Ensure that request was received from the master server
if ( *iServerUri == currentMaster )
{
/**
* @ Improve this check to notice missing '/' at the end of the URIs
*/
if ( aActionRequest->UpdateDetails()->Uri() != currentMaster )
{
DLINFO(("Updating MasterServerUri"));
iConfigurationManager.SetMasterServerAddressL( iContext,
aActionRequest->UpdateDetails()->Uri(), 0 );
}
else
{
DLINFO(("MasterServerUri didn't change"));
}
}
else
{
DLERROR(( _L("Invalid update request source! Request source: %S"),
iServerUri ));
}
}
else if( aActionRequest->Target() == KNcdActionTargetSkin ||
aActionRequest->Target() == KNcdActionTargetClient )
{
HBufC* msgQueueName = HBufC::NewLC( KCatalogsUpdateQueueNameFormat().Length() + 8 );
msgQueueName->Des().Format( KCatalogsUpdateQueueNameFormat, iContext.SecureId().iId );
DLINFO(( _L("Opening client's update message queue: %S"), msgQueueName ));
RMsgQueueBase queue;
TInt err = queue.OpenGlobal( *msgQueueName );
if( err == KErrNone )
{
CleanupClosePushL( queue );
TInt msgSize = queue.MessageSize();
// Prepare a buffer to write to update information P&S variable.
CBufFlat* buffer = CBufFlat::NewL( KCatalogsUpdateInformationMaxSize + msgSize );
CleanupStack::PushL( buffer );
// Externalize the info to the buffer.
RBufWriteStream stream( *buffer );
CleanupClosePushL( stream );
stream << (TInt32)(aActionRequest->Target().Size() +
aActionRequest->UpdateDetails()->Id().Size() +
aActionRequest->UpdateDetails()->Version().Size() +
aActionRequest->UpdateDetails()->Uri().Size() +
sizeof( TInt32 ));
stream << aActionRequest->Target();
stream << aActionRequest->UpdateDetails()->Id();
stream << aActionRequest->UpdateDetails()->Version();
stream << aActionRequest->UpdateDetails()->Uri();
stream << (TInt32)aActionRequest->Force();
// Write the update information to the client's update message queue.
TInt bytesToSend = buffer->Size();
for( TInt sendPos = 0; sendPos < bytesToSend; sendPos += msgSize )
{
const TUint8* sendPtr = buffer->Ptr( sendPos ).Ptr();
queue.SendBlocking( sendPtr, msgSize );
}
DLINFO(( "Update information sent to message queue" ));
CleanupStack::PopAndDestroy( 3, &queue ); // stream-close, buffer, queue
}
// Clean up the local info buffer.
CleanupStack::PopAndDestroy( msgQueueName );
}
else
{
DLINFO(("Unknown Action target"));
}
}
// Action request no longer needed, delete it.
CleanupStack::PopAndDestroy( aActionRequest );
}
void CNcdProtocolDefaultObserver::ConfigurationServerDetailsL(
MNcdConfigurationProtocolServerDetails* aServerDetails )
{
DLTRACEIN((""));
DASSERT( aServerDetails );
DASSERT( iServerUri );
DLINFO(("Server supports %d capabilities",
aServerDetails->CapabilityCount() ));
CleanupDeletePushL( aServerDetails );
if ( aServerDetails->CapabilityCount() )
{
DLTRACE(("Adding capabilities to server details"));
MNcdServerDetails& details(
iConfigurationManager.ServerDetailsL( iContext,
*iServerUri,
NcdProviderDefines::KConfigNamespace ));
// Clear old caps so that we don't just keep on adding them.
// AddCapabilityL does NOT check for duplicates
details.ClearCapabilitiesL();
for ( TInt i = 0; i < aServerDetails->CapabilityCount(); ++i )
{
details.AddCapabilityL( aServerDetails->CapabilityL( i ) );
}
iConfigurationManager.SaveConfigurationToDbL( iContext );
}
CleanupStack::PopAndDestroy( aServerDetails );
}
void CNcdProtocolDefaultObserver::ConfigurationErrorL(
MNcdConfigurationProtocolError* aError )
{
DLTRACEIN((""));
delete aError;
}
void CNcdProtocolDefaultObserver::ConfigurationEndL()
{
DLTRACEIN((""));
}
//*****************************************************************************
// MNcdParserInformationObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::InformationL(
MNcdPreminetProtocolInformation* aData )
{
DLTRACEIN(( _L("Namespace: %S"), &aData->Namespace() ));
CleanupDeletePushL( aData );
TInt cookieCount = aData->CookieCount();
DLINFO(("cookie count=%d",cookieCount));
MNcdServerDetails& details(
iConfigurationManager.ServerDetailsL( iContext, *iServerUri,
aData->Namespace() ));
// Get SSID
const TDesC8& ssid( iConfigurationManager.SsidL( iContext ) );
for ( TInt i = 0; i < cookieCount; ++i )
{
const MNcdConfigurationProtocolCookie& cookie( aData->CookieL( i ) );
details.AddCookieL( cookie, ssid );
}
// Handle server capabilities
DLTRACE(("Handle server capabilities"));
const MNcdConfigurationProtocolServerDetails* serverDetails =
aData->ServerDetails();
DLTRACE(("ServerDetails-ptr: %x", serverDetails ));
if ( serverDetails && serverDetails->CapabilityCount() )
{
// Clear old caps so that we don't just keep on adding them.
// AddCapabilityL does NOT check for duplicates
details.ClearCapabilitiesL();
DLINFO(("Capabilities: %d", serverDetails->CapabilityCount() ));
DLTRACE(("Adding capabilities to server details"));
for ( TInt i = 0; i < serverDetails->CapabilityCount(); ++i )
{
details.AddCapabilityL( serverDetails->CapabilityL( i ) );
}
}
iConfigurationManager.SaveConfigurationToDbL( iContext );
CleanupStack::PopAndDestroy( aData );
DLTRACEOUT(("Protocol information handled"));
}
//*****************************************************************************
// MNcdParserDataBlocksObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::DataBlocksL(
CArrayPtr<MNcdPreminetProtocolDataBlock>* aData )
{
DLTRACEIN((""));
aData->ResetAndDestroy();
delete aData;
}
//*****************************************************************************
// MNcdParserErrorObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::ErrorL( MNcdPreminetProtocolError* aData )
{
DLTRACEIN((""));
delete aData;
}
//*****************************************************************************
// MNcdParserQueryObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::QueryL( MNcdConfigurationProtocolQuery* aData )
{
DLTRACEIN((""));
delete aData;
}
//*****************************************************************************
// MNcdParserSubscriptionObserver
//*****************************************************************************
void CNcdProtocolDefaultObserver::ValidSubscriptionL(
MNcdPreminetProtocolSubscription* aData )
{
DLTRACEIN((""));
iSubscriptionManager.InternalizeSubscriptionL(
iContext.FamilyId(), *iServerUri, *aData, &iContext, NULL );
delete aData;
}
void CNcdProtocolDefaultObserver::OldSubscriptionL(
MNcdPreminetProtocolSubscription* aData )
{
DLTRACEIN((""));
iSubscriptionManager.InternalizeSubscriptionL(
iContext.FamilyId(), *iServerUri, *aData, &iContext, NULL );
delete aData;
}