/*

* 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 Startup Adapter

*

*/

/*

./Customization -+--> Startup -+--> WelcomeData

  */

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

// Use this flag to activate mime type checking in adapter

// Data with unsupported mime types will be rejected

//  

// #define SUPADAPTER_CHECK_MIME_TYPES

#ifdef	SUPADAPTER_CHECK_MIME_TYPES

#define SUPADAPTER_CHECK_TEXT_MIME_TYPE

#define SUPADAPTER_CHECK_IMAGE_MIME_TYPE

#endif

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

#include "supadapter.h"

// symbian

#ifndef __WINS_DEBUG_TESTING__

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

#endif

#include <fbs.h>

#include <f32file.h>

#include <imcvcodc.h>

// s60

#include <AknUtils.h>

#include <sysutil.h>

#include <startupdomaincrkeys.h>

// tarm

//#ifdef __SAP_POLICY_MANAGEMENT

#include <DMCert.h>

#include <SettingEnforcementInfo.h>

#include <PolicyEngineXACML.h>

//#endif

#include "nsmldmuri.h"

#include "TPtrC8I.h"

#include "TARMCharConv.h"

#include "FileCoderB64.h"

#include "debug.h"

#include <featmgr.h>

#include <utf.h> 

/**

*

* Supported MIME types of this adapter

*

**/

_LIT8(KText,              "text/");

_LIT8(KMimeTypeTextPlain, "text/plain");

#ifdef SUPADAPTER_CHECK_TEXT_MIME_TYPE

_LIT8(KMimeTypeTextAny,   "text/*");

#endif

_LIT8(KImage,			  "image/");

_LIT8(KMimeTypeImageMbm,  "image/x-epoc-mbm");

#ifdef SUPADAPTER_CHECK_IMAGE_MIME_TYPE

_LIT8(KMimeTypeImageGif,  "image/gif");

_LIT8(KMimeTypeImagePng,  "image/png");

_LIT8(KMimeTypeImageJpg,  "image/jpeg");

_LIT8(KMimeTypeImageAny,  "image/*");

#endif

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

/**

* Folder for temporary files

**/

_LIT(KTempFilePath, "c:\\system\\temp\\");

// This length value is copied from S60/Startup/StartupUserWelcomeNote.h

const TInt KStartupTBufMaxLength( 100 );

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

// CSupAdapter* CSupAdapter::NewL( )

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

CSupAdapter* CSupAdapter::NewL(MSmlDmCallback* aDmCallback )

	{

	RDEBUG( "CSupAdapter::NewL()" );

	CSupAdapter* self = NewLC( aDmCallback );

	CleanupStack::Pop();

	return self;

	}

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

// CSupAdapter* CSupAdapter::NewLC( )

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

CSupAdapter* CSupAdapter::NewLC(MSmlDmCallback* aDmCallback )

	{

	RDEBUG( "CSupAdapter::NewLC()" );

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

	CleanupStack::PushL(self);

	self->ConstructL(aDmCallback);

	return self;

	}

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

// CSupAdapter::CSupAdapter()

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

CSupAdapter::CSupAdapter(TAny* aEcomArguments)

: CTARMDmStreamAdapter((MSmlDmCallback*)aEcomArguments)

, iUndoImage(0)

, iUndoText(0)

, iUndoNoteType(-1)

	{

	}

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

// CSupAdapter::~CSupAdapter()

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

CSupAdapter::~CSupAdapter()

	{

	RDEBUG( "CSupAdapter::~CSupAdapter()" );

    delete iUndoImage; iUndoImage = 0;

    delete iUndoText;  iUndoText  = 0;

    if( iTemporaryImageFile.Length() > 0 )

        {

        RFs fs;

        if (fs.Connect())

        	{

        fs.Delete( iTemporaryImageFile );

        fs.Close();

      		}

        iTemporaryImageFile.Zero();

        }

//#ifdef __SAP_POLICY_MANAGEMENT

if(FeatureManager::FeatureSupported(KFeatureIdSapStartupAdapter))

{

	if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement ))

	{

	iPR.Close();

	iPE.Close();

	}

}

//#endif

FeatureManager::UnInitializeLib();

	}

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

// CSupAdapter::ConstructL

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

void CSupAdapter::ConstructL(MSmlDmCallback *aDmCallback)

	{

	RDEBUG( "CSupAdapter::ConstructL()" );

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

		if( errf != KErrNone )

		{

			User::Leave(errf);

		}

			if(FeatureManager::FeatureSupported(KFeatureIdSapStartupAdapter))

			{

	iCallBack = aDmCallback;

			//#ifdef __SAP_POLICY_MANAGEMENT

			if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement ))

			{

    User::LeaveIfError( iPE.Connect() );

    User::LeaveIfError( iPR.Open( iPE ) );

			}

			//#endif

    iTemporaryImageFile.Zero();

#ifdef __WINS_DEBUG_TEST__

    DebugTestsL();

#endif

			}

			else

			{

		   		User::Leave( KErrNotSupported );

			}

	}

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

//  CSupAdapter::DDFVersionL()

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

void CSupAdapter::DDFVersionL(CBufBase& aDDFVersion)

	{

	RDEBUG( "CSupAdapter::DDFVersionL()" );

	aDDFVersion.InsertL(0,KNSmlSUPDDFVersion);

	}

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

//  CSupAdapter::DDFStructureL()

//

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

void CSupAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

	{

	RDEBUG( "CSupAdapter::DDFStructureL()" );

	TSmlDmAccessTypes accessTypesGet;

	accessTypesGet.SetGet();

	/*

	Node: ./Customization

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

	Status: Required

	Occurs: One

	Format: Node

	Access Types: Get

	Values: N/A

	*/

	MSmlDmDDFObject& apps = aDDF.AddChildObjectL(KNSmlCustomizationNodeName);

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

	    MSmlDmDDFObject::ENode, KNSmlSUPDescription,KNullDesC8());

	/*

	Node: ./Customization/Startup

	Startup is a common parent node to nodes customizing startup functionality

	Status: Required

	Occurs: One

	Format: Node

	Access Types: Get

	Values: N/A

	*/

	MSmlDmDDFObject& groupNode = apps.AddChildObjectL(KNSmlSUPStartupNodeName);

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

		MSmlDmDDFObject::ENode,KNSmlSUPStartupNodeDescription,KNullDesC8());

	/*

	Node: ./Customization/Startup/Data

	Image node stores the Startup image as binary data, and its runtime Type determines the interpretation.

·	Status: Optional

·	Occurs: One

·	Format: bin

·	Access Types: Replace

·	Values: N/A

	*/

	TSmlDmAccessTypes accessTypesReplace;

	accessTypesReplace.SetReplace();

	MSmlDmDDFObject& imageNode = groupNode.AddChildObjectL(KNSmlSUPWelcomeDataNodeName);

	FillNodeInfoL(imageNode,accessTypesReplace,MSmlDmDDFObject::EZeroOrOne,MSmlDmDDFObject::EPermanent,

		MSmlDmDDFObject::EBin,KNSmlSUPWelcomeDataNodeDescription,KNSmlSUPTextPlain());

	imageNode.AddDFTypeMimeTypeL(KMimeTypeImageMbm);

	/*

	Node: ./Customization/Startup/Text

	Text node stores the Startup text as text, and its runtime Type determines the interpretation.

·	Status: Optional

·	Occurs: One

·	Format: Chr

·	Access Types: Get, Replace

·	Values: N/A

	*/

	TSmlDmAccessTypes accessTypesGetReplace;

	accessTypesGetReplace.SetGet();

	accessTypesGetReplace.SetReplace();

	MSmlDmDDFObject& textNode = groupNode.AddChildObjectL(KNSmlSUPWelcomeTextNodeName);

	FillNodeInfoL(textNode,accessTypesGetReplace,MSmlDmDDFObject::EZeroOrOne,MSmlDmDDFObject::EPermanent,

		MSmlDmDDFObject::EChr,KNSmlSUPWelcomeTextNodeDescription,KNSmlSUPTextPlain());

	}

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

//  CSupAdapter::UpdateLeafObjectL()

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

void CSupAdapter::UpdateLeafObjectL( CSmlDmAdapter::TError& aStatus, const TDesC8& aURI,

                                     const TDesC8& /*aLUID*/, const TDesC8& aObject, const TDesC8& aType )

	{

	RDEBUG( "CSupAdapter::UpdateLeafObjectL()" );

#ifdef __TARM_SYMBIAN_CONVERGENCY

	TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

	CSupAdapter::TSupNodeIdentifier identifier = GetNodeIdentifier( uriPtrc );

#else

	CSupAdapter::TSupNodeIdentifier identifier = GetNodeIdentifier( aURI );

#endif

	TStartupAdapterLeafType type;

    switch( identifier )

        {

            case ESupNodeWelcomeText:

            	{

                HBufC16* source = CTARMCharConv::ConvertFromUtf8LC( aObject );

                TInt sourceLength = source->Length();

                TInt destLength = KStartupTBufMaxLength<sourceLength?KStartupTBufMaxLength:sourceLength;

                TPtrC16 sourcePtr( source->Ptr(), destLength );

				aStatus = CSmlDmAdapter::EOk;

				SetStartupTextL(aStatus, sourcePtr);

				CleanupStack::PopAndDestroy( source );

            	}

            	break;

            case ESupNodeWelcomeData:

				type = GetObjectType( aType );

				switch(type)

					{

					case CSupAdapter::EImage:

					    aStatus = CSmlDmAdapter::EOk;

					    SetStartupImageL(aStatus, aObject, aType);

						break;

					case CSupAdapter::EUnknown:

					    aStatus = CSmlDmAdapter::EInvalidObject;

						break;

					}

            	break;

            default:

            aStatus = CSmlDmAdapter::EError;

        }

	}

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

//  CSupAdapter::_UpdateLeafObjectL()

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

void CSupAdapter::_UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType, TInt aStatusRef )

	{

	RDEBUG8_3( "CSupAdapter::_UpdateLeafObjectL() (%S) (%S)", &aURI, &aType );

	TBuf8<KStartupTBufMaxLength> mimeType;

	CopyAndTrimMimeType(mimeType, aType);

//#ifdef __SAP_POLICY_MANAGEMENT

if(FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement ))

{

	User::LeaveIfError( CheckPolicyL() );	

}

//#endif

	CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TRAPD(

        reason,

        // NOTE! UpdateLeafObjectL removes the "./" from the beginning

        UpdateLeafObjectL( status, aURI, aLUID, aObject, mimeType ) );

    if( KErrNone != reason )

        {

        status = CSmlDmAdapter::EError;

        }

    iCallBack->SetStatusL(aStatusRef, status);

	}

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

//  CSupAdapter::_UpdateLeafObjectL()

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

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

    {       

	RDEBUG( "CSupAdapter::_UpdateLeafObjectL() (stream)" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    iCallBack->SetStatusL(aStatusRef, status);

    }

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

// CSupAdapter::_DeleteObjectL

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

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

	{

	RDEBUG( "CSupAdapter::_DeleteObjectL()" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    iCallBack->SetStatusL(aStatusRef, status);

	}

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

// CSupAdapter::_ExecuteCommandL

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

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

    {

	RDEBUG( "CSupAdapter::_ExecuteCommandL()" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    iCallBack->SetStatusL(aStatusRef, status);        

    }

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

// CSupAdapter::_ExecuteCommandL

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

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

    {

	RDEBUG( "CSupAdapter::_ExecuteCommandL() (stream)" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    iCallBack->SetStatusL(aStatusRef, status);        

    }

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

// CSupAdapter::_CopyCommandL

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

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

    {

	RDEBUG( "CSupAdapter::_CopyCommandL()" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    iCallBack->SetStatusL(aStatusRef, status);        

    }

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

// CSupAdapter::StartAtomicL

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

void CSupAdapter::StartAtomicL()

    {

	RDEBUG( "CSupAdapter::StartAtomicL()" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    delete iUndoImage; iUndoImage = 0;

    delete iUndoText;  iUndoText  = 0;

    iUndoNoteType = -1;

    // Copy startup image & text

    TInt imageSize;

    iUndoImage = GetStartupImageL(status, KMimeTypeImageMbm, imageSize);

    iUndoText  = GetStartupTextL(status, KMimeTypeTextPlain);

    }

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

// CSupAdapter::CommitAtomicL

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

void CSupAdapter::CommitAtomicL()

    {

	RDEBUG( "CSupAdapter::CommitAtomicL()" );

    delete iUndoImage; iUndoImage = 0;

    delete iUndoText;  iUndoText  = 0;        

    iUndoNoteType = -1;

    }

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

// CSupAdapter::RollbackAtomicL

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

void CSupAdapter::RollbackAtomicL()

    {

	RDEBUG( "CSupAdapter::RollbackAtomicL()" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    if(iUndoImage != 0)        

        {

            SetStartupImageL(status, iUndoImage->Ptr(0), KMimeTypeImageMbm);

            if(status != CSmlDmAdapter::EOk)

                {

                    status = CSmlDmAdapter::ERollbackFailed;

                }

            delete iUndoImage; iUndoImage = 0;

        }

    if(iUndoText != 0)

        {

            HBufC16* source   = CTARMCharConv::ConvertFromUtf8LC( iUndoText->Ptr( 0 ) );

            TInt sourceLength = source->Length();

            TInt destLength   = KStartupTBufMaxLength<sourceLength?KStartupTBufMaxLength:sourceLength;

            TPtrC16 sourcePtr( source->Ptr(), destLength );

            SetStartupTextL(status, sourcePtr);

            CleanupStack::PopAndDestroy( source );

            if(status != CSmlDmAdapter::EOk)

                {

                status = CSmlDmAdapter::ERollbackFailed;

                }

            delete iUndoText; iUndoText = 0;

        }

    if(iUndoNoteType != -1)

        {

            RUISettingsSrv uiSrv;

            User::LeaveIfError( uiSrv.Connect() );

            CleanupClosePushL( uiSrv );

            User::LeaveIfError( uiSrv.SetStartupNoteType( iUndoNoteType ) );

            CleanupStack::PopAndDestroy( &uiSrv );

            iUndoNoteType = -1;

        }

    iCallBack->SetStatusL(0, status);

    }

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

// CSupAdapter::StreamType

// 

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

//

CTARMDmStreamAdapter::TAdapterStreamType CSupAdapter::StreamType( const TDesC8& aURI )

    {

#ifdef __TARM_SYMBIAN_CONVERGENCY