/*
* Copyright (c) 2002 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: Root of Provisioning document
*
*/
// INCLUDE FILES
#include <s32file.h>
#include <badesca.h>
#include "CWPRoot.h"
#include "CWPCharacteristic.h"
#include "CWPParameter.h"
#include "WPElementFactory.h"
#include "ProvisioningDebug.h"
// CONSTANTS
const TInt KElementsGranularity = 5;
const TInt KIDArrayGranularity = 6;
_LIT( KInternet, "INTERNET" );
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CWPRoot::CWPRoot
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CWPRoot::CWPRoot()
{
}
// -----------------------------------------------------------------------------
// CWPRoot::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CWPRoot::ConstructL()
{
iContents = new(ELeave)
CArrayPtrFlat<CWPCharacteristic>( KElementsGranularity );
}
// -----------------------------------------------------------------------------
// CWPRoot::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWPRoot* CWPRoot::NewL()
{
CWPRoot* self = NewLC();
CleanupStack::Pop();
return self;
}
// -----------------------------------------------------------------------------
// CWPRoot::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWPRoot* CWPRoot::NewLC()
{
CWPRoot* self = new( ELeave ) CWPRoot;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
CWPRoot::~CWPRoot()
{
if( iContents )
{
iContents->ResetAndDestroy();
delete iContents;
}
iNeeders.Close();
iProviders.Close();
delete iNeededIDs;
delete iProviderIDs;
iStack.Close();
}
// -----------------------------------------------------------------------------
// CWPRoot::AcceptL
// -----------------------------------------------------------------------------
//
void CWPRoot::AcceptL( MWPVisitor& aVisitor )
{
FLOG( _L( "[Provisioning] CWPRoot::AcceptL:" ) );
for( TInt i( 0 ); i < iContents->Count(); i++ )
{
iContents->At( i )->CallVisitorL( aVisitor );
}
FLOG( _L( "[Provisioning] CWPRoot::AcceptL: Done" ) );
}
// -----------------------------------------------------------------------------
// CWPRoot::InternalizeL
// -----------------------------------------------------------------------------
//
void CWPRoot::InternalizeL(RReadStream& aStream)
{
TInt count( aStream.ReadInt32L() );
iContents->ResetAndDestroy();
for( TInt i( 0 ); i < count; i++ )
{
TInt type( aStream.ReadInt32L() );
CWPCharacteristic* current =
WPElementFactory::CreateCharacteristicLC( type );
current->InternalizeL( aStream );
iContents->AppendL( current );
CleanupStack::Pop(); // current
}
}
// -----------------------------------------------------------------------------
// CWPRoot::ExternalizeL
// -----------------------------------------------------------------------------
//
void CWPRoot::ExternalizeL(RWriteStream& aStream) const
{
aStream.WriteInt32L( iContents->Count() );
for( TInt i( 0 ); i < iContents->Count(); i++ )
{
CWPCharacteristic* current = iContents->At( i );
aStream.WriteInt32L( current->Type() );
current->ExternalizeL( aStream );
}
}
// -----------------------------------------------------------------------------
// CWPRoot::InsertL
// -----------------------------------------------------------------------------
//
void CWPRoot::InsertL( CWPCharacteristic* aCharacteristic )
{
iContents->AppendL( aCharacteristic );
}
// -----------------------------------------------------------------------------
// CWPRoot::StartCharacteristicL
// -----------------------------------------------------------------------------
//
void CWPRoot::StartCharacteristicL( TInt aType )
{
FTRACE(RDebug::Print(_L("[Provisioning] CWPRoot::StartCharacteristicL: aType (%d)"), aType));
CWPCharacteristic* newChar =
WPElementFactory::CreateCharacteristicLC( aType );
if( iStack.Count() == 0 )
{
// Assumes ownership if doesn't leave
InsertL( newChar );
}
else
{
CWPCharacteristic* latest = iStack[ iStack.Count()-1 ];
// Assumes ownership if doesn't leave
latest->InsertL( newChar );
}
CleanupStack::Pop(); // newChar
User::LeaveIfError( iStack.Append( newChar ) );
}
// -----------------------------------------------------------------------------
// CWPRoot::StartCharacteristicL
// -----------------------------------------------------------------------------
//
void CWPRoot::StartCharacteristicL( const TDesC& aName )
{
FLOG( _L( "[Provisioning] CWPRoot::StartCharacteristicL:" ) );
CWPCharacteristic* newChar =
WPElementFactory::CreateCharacteristicLC( aName );
if( iStack.Count() == 0 )
{
// Assumes ownership if doesn't leave
InsertL( newChar );
}
else
{
CWPCharacteristic* latest = iStack[ iStack.Count()-1 ];
// Assumes ownership if doesn't leave
latest->InsertL( newChar );
}
CleanupStack::Pop(); // newChar
User::LeaveIfError( iStack.Append( newChar ) );
}
// -----------------------------------------------------------------------------
// CWPRoot::EndCharacteristicL
// -----------------------------------------------------------------------------
//
void CWPRoot::EndCharacteristicL()
{
FLOG( _L( "[Provisioning] CWPRoot::EndCharacteristicL:" ) );
if( iStack.Count() > 0 )
{
iStack.Remove( iStack.Count()-1 );
}
else
{
User::Leave( KErrCorrupt );
}
}
// -----------------------------------------------------------------------------
// CWPRoot::ParameterL
// -----------------------------------------------------------------------------
//
void CWPRoot::ParameterL( TInt aID, const TDesC& aValue )
{
TPtrC ptr( aValue );
FTRACE(RDebug::Print(_L("[Provisioning] CWPRoot::ParameterL: id: %d: value: %S"), aID, &ptr));
if( iStack.Count() > 0 )
{
CWPParameter* param = WPElementFactory::CreateParameterLC( aID, ptr );
iStack[ iStack.Count()-1 ]->InsertL( param );
CleanupStack::Pop(); // param
}
}
// -----------------------------------------------------------------------------
// CWPRoot::ParameterL
// -----------------------------------------------------------------------------
//
void CWPRoot::ParameterL( const TDesC& aName, const TDesC& aValue )
{
TPtrC name( aName );
TPtrC value( aValue );
FTRACE(RDebug::Print(_L("[Provisioning] CWPRoot::ParameterL: %S: %S"), &name, &value));
if( iStack.Count() > 0 )
{
CWPParameter* param =
WPElementFactory::CreateParameterLC( name, value );
iStack[ iStack.Count()-1 ]->InsertL( param );
CleanupStack::Pop(); // param
}
}
// -----------------------------------------------------------------------------
// CWPRoot::CreateLinksL
// -----------------------------------------------------------------------------
//
void CWPRoot::CreateLinksL()
{
FLOG( _L( "[Provisioning] CWPRoot::ParameterL2:" ) );
iNeeders.Reset();
delete iNeededIDs;
iNeededIDs = NULL;
iNeededIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity );
delete iProviderIDs;
iProviderIDs = NULL;
iProviderIDs = new(ELeave) CDesCArrayFlat( KIDArrayGranularity );
AcceptL( *this );
// We now have arrays of links and targets of links. Put them together.
for( TInt i( 0 ); i < iNeeders.Count(); i++ )
{
CWPCharacteristic* needer = iNeeders[i];
TPtrC neededID( iNeededIDs->MdcaPoint( i ) );
TBool foundProvider( EFalse );
for( TInt j( 0 ); j < iProviders.Count() && !foundProvider; j++ )
{
CWPCharacteristic* needed = iProviders[j];
TPtrC providerID( iProviderIDs->MdcaPoint( j ) );
if( providerID == neededID )
{
if ( needer->Type() == KWPPxPhysical && needed->Type() != KWPNapDef)
{
// incorrect link found. do nothing.
}
else
{
#ifndef __SYNCML_DM_OTA
FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL*********** __SYNCML_DM_OTA ***********" ) );
if (KWPApplication == needer->Type())
{
_LIT( KNSmlDMProvisioningDMAppIdVal, "w7" );
FLOG (_L( "[Provisioning] CWPRoot::CreateLinksL:Needer is Application" ) );
CArrayFix<TPtrC>* name = new(ELeave) CArrayFixFlat<TPtrC>(1);
CleanupStack::PushL(name);
needer->ParameterL(EWPParameterAppID, name);
if ((name->Count() > 0)
&&
0 == name->At(0).Compare(KNSmlDMProvisioningDMAppIdVal) )
{
CleanupStack::PopAndDestroy(); // name
continue;
}
CleanupStack::PopAndDestroy(); // name
}
FLOG ( _L( "[Provisioning] CWPRoot::CreateLinksL:*********** __SYNCML_DM_OTA ***********" ) );
#endif
needer->InsertLinkL( *needed );
foundProvider = ETrue;
}
}
}
}
// Free the temporary memory
iNeeders.Reset();
iProviders.Reset();
delete iNeededIDs;
iNeededIDs = NULL;
delete iProviderIDs;
iProviderIDs = NULL;
}
// -----------------------------------------------------------------------------
// CWPRoot::Visit
// -----------------------------------------------------------------------------
//
void CWPRoot::VisitL( CWPParameter& aParameter )
{
FLOG( _L( "[Provisioning] CWPRoot::VisitL Parameter:" ) );
if( iCharStack )
{
TInt charType( iCharStack->Type() );
TInt paramID( aParameter.ID() );
// If the current characteristic is a logical proxy or access point,
// add it to the list of potential targets of a link
if( (charType == KWPPxLogical && paramID == EWPParameterProxyID )
|| (charType == KWPNapDef && paramID == EWPParameterNapID) )
{
iProviderIDs->AppendL( aParameter.Value() );
}
// Handle internet-capable NAPDEF here
else if( charType == KWPNapDef && paramID == EWPParameterInternet )
{
User::LeaveIfError( iProviders.Append( iCharStack ) );
iProviderIDs->AppendL( KInternet );
}
// If the parameter can link, append to the list of sources of links
else if( paramID == EWPParameterToNapID
|| paramID == EWPParameterToProxy
|| (charType == KWPBootstrap && paramID == EWPParameterProxyID) )
{
iNeededIDs->AppendL( aParameter.Value() );
User::LeaveIfError( iNeeders.Append( iCharStack ) );
}
}
}
// -----------------------------------------------------------------------------
// CWPRoot::Visit
// -----------------------------------------------------------------------------
//
void CWPRoot::VisitL( CWPCharacteristic& aCharacteristic )
{
FLOG( _L( "[Provisioning] CWPRoot::VisitL Char:" ) );
TInt charType( aCharacteristic.Type() );
// Add the characteristic to the stack as current
CWPCharacteristic* charStack = iCharStack;
iCharStack = &aCharacteristic;
// Logical proxy and access points as treated as potential targets of links
if( charType == KWPPxLogical || charType == KWPNapDef )
{
// First get the characteristic and then use a visitor to find out the
// id
aCharacteristic.AcceptL( *this );
// If no id was found, there's something wrong with the document
if( iProviders.Count() == iProviderIDs->Count()-1 )
{
User::LeaveIfError( iProviders.Append( &aCharacteristic ) );
}
}
else
{
// Just enter other characteristics
aCharacteristic.AcceptL( *this );
}
// Remove the current from stack
iCharStack = charStack;
}
// -----------------------------------------------------------------------------
// CWPRoot::VisitLink
// -----------------------------------------------------------------------------
//
void CWPRoot::VisitLinkL( CWPCharacteristic& /*aLink*/ )
{
// Links have not yet been created
}
// End of File