/*

* 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:  DM Operator Logo Adapter

*

*/

/*

./Customization -+--> OperatorLogo -+--> LogoData

*/

#include "OperatorLogoAdapter.h"

#include <implementationproxy.h> // For TImplementationProxy definition

#include <coemain.h>

#include <imageconversion.h>

#include <bitmaptransforms.h>

#include <RPhCltServer.h>

#include <CPhCltImageHandler.h>

#include <CPhCltBaseImageParams.h>

//#ifdef __SAP_POLICY_MANAGEMENT

#include <PolicyEngineXACML.h>

//#endif

#include "nsmldmuri.h"

#include "FileCoderB64.h"

#include "debug.h"

#include <featmgr.h>

const TInt KLogoMaxWidthPixels      = 97;

const TInt KLogoMaxHeightPixels     = 25;

_LIT( KOperatorLogoAdapterTmpFilePath, "c:\\system\\temp\\DM_OPLogo.bin" );

class CWaitScheduler : public CActive

	{

	// Functions

	public:

		static CWaitScheduler* NewL( TInt aPriority = EPriorityStandard );

		TInt WaitForRequest();

	private:

		CWaitScheduler( TInt aPriority );

		void ConstructL();

		virtual ~CWaitScheduler();

		void RunL();

		void DoCancel();

	// Data

	private:

		CActiveSchedulerWait iScheduler;

	};

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

CWaitScheduler* CWaitScheduler::NewL( TInt aPriority )

	{

	CWaitScheduler* self = new( ELeave ) CWaitScheduler( aPriority );

	CleanupStack::PushL( self );

	self->ConstructL( );

	CleanupStack::Pop( self );

	return self;

	}

CWaitScheduler::CWaitScheduler( TInt aPriority )

	: CActive( aPriority )

	{

	CActiveScheduler::Add( this );

	}

void CWaitScheduler::ConstructL()

	{

	}

CWaitScheduler::~CWaitScheduler()

	{

	if ( IsActive() )

		{

		User::Panic( _L("CSyncWait"), 1 );

		}

	}

TInt CWaitScheduler::WaitForRequest()

	{

	SetActive();

	iScheduler.Start();

	return iStatus.Int();

	}

void CWaitScheduler::RunL()

	{

	iScheduler.AsyncStop();

	}

void CWaitScheduler::DoCancel()

	{

	User::Panic( _L("CSyncWait"), 2 );

	}

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

// COperatorLogoAdapter* COperatorLogoAdapter::NewL( )

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

COperatorLogoAdapter* COperatorLogoAdapter::NewL( MSmlDmCallback* aDmCallback )

	{

	RDEBUG("COperatorLogoAdapter::NewL(): begin");

	COperatorLogoAdapter* self = NewLC( aDmCallback );

	CleanupStack::Pop();

	return self;

	}

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

// COperatorLogoAdapter* COperatorLogoAdapter::NewLC( )

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

COperatorLogoAdapter* COperatorLogoAdapter::NewLC( MSmlDmCallback* aDmCallback )

	{

	COperatorLogoAdapter* self = new( ELeave ) COperatorLogoAdapter( aDmCallback );

	CleanupStack::PushL( self );

	self->ConstructL( );

	return self;

	}

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

// COperatorLogoAdapter::COperatorLogoAdapter()

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

COperatorLogoAdapter::COperatorLogoAdapter( MSmlDmCallback* aDmCallback )

	: CTARMDmAdapter( aDmCallback )

	, iCallBack( aDmCallback )

	{

	}

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

//

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

void COperatorLogoAdapter::ConstructL( )

	{

		TRAPD( errf, FeatureManager::InitializeLibL() );

		if( errf != KErrNone )

		{

			User::Leave(errf);

		}

	    if(FeatureManager::FeatureSupported(KFeatureIdSapOperatorLogoAdapter))

		{

	    User::LeaveIfError( RFbsSession::Connect() );

		}

		else

		{

			FeatureManager::UnInitializeLib();

	   		User::Leave( KErrNotSupported );

		}

	}

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

// COperatorLogoAdapter::~COperatorLogoAdapter()

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

COperatorLogoAdapter::~COperatorLogoAdapter()

	{

	FeatureManager::UnInitializeLib();

	RFbsSession::Disconnect();

	}

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

//  COperatorLogoAdapter::DDFVersionL()

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

void COperatorLogoAdapter::DDFVersionL( CBufBase& aDDFVersion )

	{

	aDDFVersion.InsertL( 0, KOperatorLogoDDFVersion );

	}

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

//  COperatorLogoAdapter::DDFStructureL()

//

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

void COperatorLogoAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

	{

	RDEBUG( "COperatorLogoAdapter::DDFStructureL(): begin" );

	TSmlDmAccessTypes accessTypesGet;

	accessTypesGet.SetGet();

	TSmlDmAccessTypes accessTypesGetReplace;

	accessTypesGetReplace.SetGet();

	accessTypesGetReplace.SetReplace();

	/*

	Node: ./Customzation

	This interior node is the common parent to all customization..

	Status: Required

	Occurs: One

	Format: Node

	Access Types: Get

	Values: N/A

	*/

	MSmlDmDDFObject& customization = aDDF.AddChildObjectL( KOperatorLogoCustomization );

	FillNodeInfoL(customization, accessTypesGet, MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent,

		MSmlDmDDFObject::ENode, KOperatorLogoCustomizationD, ETrue );

	/*

	Node: ./Customization/OperatorLogo

	This interior node acts as a placeholder for one or more update packages within a same content provider group.

	Status: Required

	Occurs: One

	Format: Node

	Access Types: Get

	Values: N/A

	*/

	MSmlDmDDFObject& operatorLogo = customization.AddChildObjectL( KOperatorLogoOperatorLogo );

	FillNodeInfoL( operatorLogo, accessTypesGet, MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent,

		MSmlDmDDFObject::ENode, KOperatorLogoOperatorLogoD, ETrue );

	/*

	Node: ./Customization/OperatorLogo/Data

	Status: Optional

	Occurs: One

	Format: bin

	Access Types: Get, Replace

	Values: N/A

	*/

	MSmlDmDDFObject& logoData = operatorLogo.AddChildObjectL(KOperatorLogoLogoData);

	FillNodeInfoL( logoData, accessTypesGetReplace, MSmlDmDDFObject::EOne, MSmlDmDDFObject::EPermanent,

		MSmlDmDDFObject::EBin, KOperatorLogoLogoDataD, EFalse);

	logoData.AddDFTypeMimeTypeL( KNSmlDMTextPlain );

	logoData.AddDFTypeMimeTypeL( KNSmlDMImageAny );

	}

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

//  COperatorLogoAdapter::UpdateLeafObjectL()

//  

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

void COperatorLogoAdapter::_UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const TDesC8& aObject, const TDesC8& aType, const TInt aStatusRef )

	{

	RDEBUG( "COperatorLogoAdapter::UpdateLeafObjectL(): begin" );

	TError ret = EOk ;

#ifdef __TARM_SYMBIAN_CONVERGENCY

	TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

	TNodeId nodeId = NodeId( uriPtrc );

#else

	TNodeId nodeId = NodeId( aURI );

#endif	

	switch( nodeId )

		{

	case ENodeLogoData:

		ret = SetOperatorLogoL( aObject, aType );

		break;

	case ENodeUnknown:

		ret = ENotFound;

		break;

	default:

		ret = EError;

		break;

		}

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//

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

void COperatorLogoAdapter::_UpdateLeafObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, TInt aStatusRef )

	{

	RDEBUG( "COperatorLogoAdapter::UpdateLeafObjectL(...RWriteStream...): begin" );

	// Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

// COperatorLogoAdapter::DeleteObjectL( const TDesC& aURI, const TDesC& aLUID )

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

void COperatorLogoAdapter::_DeleteObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, const TInt aStatusRef )

	{

	RDEBUG( "COperatorLogoAdapter::DeleteObjectL(): begin" );

	// Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//  COperatorLogoAdapter::FetchLeafObjectL( const TDesC& aURI, const TDesC& aLUID, const TDesC& aType, CBufBase& aObject )

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

void COperatorLogoAdapter::_FetchLeafObjectL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const TDesC8& /*aType*/, const TInt /*aResultsRef*/, const TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::FetchLeafObjectL(): begin");

	TError ret = EOk ;

#ifdef __TARM_SYMBIAN_CONVERGENCY

	TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

	TNodeId nodeId = NodeId( uriPtrc );

#else

	TNodeId nodeId = NodeId( aURI );

#endif	

	switch( nodeId )

		{

	case ENodeLogoData:

		// Get not supported for operator logo

		ret = EError;

		break;

	case ENodeUnknown:

		ret = ENotFound;

		break;

	default:

		ret = EError;

		break;

		}

	iCallBack->SetStatusL( aStatusRef, ret );

}

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

//

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

void COperatorLogoAdapter::_FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const TDesC8& /*aType*/, TInt /*aResultsRef*/, TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::FetchLeafObjectSizeL(): begin");

	TError ret = EOk ;

#ifdef __TARM_SYMBIAN_CONVERGENCY

	TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

	TNodeId nodeId = NodeId( uriPtrc );

#else

	TNodeId nodeId = NodeId( aURI );

#endif	

	switch( nodeId )

		{

	case ENodeLogoData:

		// Get not supported for operator logo

		ret = EError;

		break;

	case ENodeUnknown:

		ret = ENotFound;

		break;

	default:

		ret = EError;

		break;

		}

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//  COperatorLogoAdapter::ChildURIListL( const TDesC& aURI, const TDesC& aParentLUID, const CArrayFix<TNSmlDmMappingInfo>& aPreviousURISegmentList, CArrayFix<TPtrC>& aCurrentURISegmentList )

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

void COperatorLogoAdapter::_ChildURIListL( const TDesC8& aURI, const TDesC8& /*aParentLUID*/, const CArrayFix<TSmlDmMappingInfo>& /*aPreviousURISegmentList*/, TInt aResultsRef, TInt aStatusRef  )

	{

	RDEBUG("COperatorLogoAdapter::ChildURIListL(): begin");

	TError ret = EOk ;

#ifdef __TARM_SYMBIAN_CONVERGENCY

	TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

	TNodeId nodeId = NodeId( uriPtrc );

#else

	TNodeId nodeId = NodeId( aURI );

#endif	

	CBufBase *currentList = CBufFlat::NewL( 128 );

	CleanupStack::PushL( currentList );

	switch( nodeId )

		{

	case ENodeCustomization:

		currentList->InsertL( currentList->Size(), KOperatorLogoOperatorLogo() );

		break;

	case ENodeOperatorLogo:

		currentList->InsertL( currentList->Size(), KOperatorLogoLogoData );

		break;

	case ENodeLogoData:

		// No children, leave list empty

		break;

	case ENodeUnknown:

		ret = ENotFound;

		break;

	default:

		ret = EError;

		break;

		}

	if( ret == EOk )

		{

		iCallBack->SetResultsL( aResultsRef, *currentList, KNullDesC8 );

		}

	iCallBack->SetStatusL( aStatusRef, ret );

	CleanupStack::PopAndDestroy(currentList); //currentList

	}

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

// COperatorLogoAdapter::AddNodeObjectL( const TDesC& aURI, const TDesC& aParentLUID )

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

void COperatorLogoAdapter::_AddNodeObjectL( const TDesC8& /*aURI*/, const TDesC8& /*aParentLUID*/, const TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::AddNodeObjectL(): begin");

	// Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//

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

void COperatorLogoAdapter::_ExecuteCommandL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, const TDesC8& /*aArgument*/, const TDesC8& /*aType*/, TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::ExecuteCommandL(): begin");

	// Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//

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

void COperatorLogoAdapter::_ExecuteCommandL( const TDesC8& /*aURI*/, const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/, const TDesC8& /*aType*/, TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::ExecuteCommandL(...RWriteStream...): begin");

	//Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//

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

void COperatorLogoAdapter::_CopyCommandL( const TDesC8& /*aTargetURI*/, const TDesC8& /*aTargetLUID*/, const TDesC8& /*aSourceURI*/, const TDesC8& /*aSourceLUID*/, const TDesC8& /*aType*/, TInt aStatusRef )

	{

	RDEBUG("COperatorLogoAdapter::CopyCommandL(): begin");

	//Not supported

	TError ret = EError;

	iCallBack->SetStatusL( aStatusRef, ret );

	}

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

//

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

void COperatorLogoAdapter::StartAtomicL()

	{

	RDEBUG("COperatorLogoAdapter::StartAtomicL(): begin");

	//Not supported

	}

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

//

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

void COperatorLogoAdapter::CommitAtomicL()

	{

	RDEBUG("COperatorLogoAdapter::CommitAtomicL(): begin");

	//Not supported

	}

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

//

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

void COperatorLogoAdapter::RollbackAtomicL()

	{

	RDEBUG("COperatorLogoAdapter::RollbackAtomicL(): begin");

	//Not supported

	}

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

//

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

TBool COperatorLogoAdapter::StreamingSupport( TInt& /*aItemSize*/ )

	{

	RDEBUG("COperatorLogoAdapter::StreamingSupport(): begin");

	return EFalse;

	}

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

//

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

#ifdef __TARM_SYMBIAN_CONVERGENCY	

void COperatorLogoAdapter::StreamCommittedL( RWriteStream& /*aStream*/ )

#else

void COperatorLogoAdapter::StreamCommittedL()

#endif	

	{	

	RDEBUG("COperatorLogoAdapter::StreamCommittedL(): begin");

	RDEBUG("COperatorLogoAdapter::StreamCommittedL(): end");

	}