/*

* 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 the License "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:  CBSSession.cpp

*

*/

//  INCLUDE FILES

#include <e32base.h>

#include <apgcli.h>

#include "cbssession.h"

#include "cbsserver.h"

#include "DebugTrace.h"

#include "cbsbrandhandler.h"

#include "cbsstoragemanager.h"

#include "cbsstorage.h"

#include "cbsbitmap.h"

//#include "cbselement.h"

#include "rbsobjowningptrarray.h"

#include "bselementfactory.h"

#include "bsimportconstants.h"

#include <badesca.h>

#include <s32buf.h>

#include <s32mem.h>

#include <utf.h>

#include <e32property.h>

// ==============================================================

// ======================== SESSION =============================

// ==============================================================

// Two-phased constructor.

CBSSession* CBSSession::NewL()

    {

    TRACE( T_LIT("CBSSession::NewL begin") );

    CBSSession* self = new( ELeave ) CBSSession();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE( T_LIT("CBSSession::NewL end") );

    return self;

    }

// Symbian OS default constructor can leave.

void CBSSession::ConstructL()

	{

	}

// destructor

CBSSession::~CBSSession()

    {

    TRACE( T_LIT("CBSSession[%d]::~CBSSession()"), this );

    if( Server() )

        {

        Server()->SessionDied( this );

        }

	delete iText;

	delete iBuffer;

	delete iBranding;

	delete iSeveralData;

#ifdef __WINSCW__

	if( iStorageManager )

		{

		iStorageManager->WriteIbyFiles();

		}

#endif

	delete iStorageManager;

    delete iSessionInfo;

    }

// C++ default constructor can NOT contain any code, that

// might leave.

//

CBSSession::CBSSession()

    {

    }

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

// CBSSession::CreateL

//

// (other items were commented in a header).

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

//

void CBSSession::CreateL()

    {

    TRACE( T_LIT("CBSSession[%d]::CreateL()"), this );

    Server()->SessionCreatedL( this );

    }

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

// CBSSession::ServiceL

//

// (other items were commented in a header).

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

//

void CBSSession::ServiceL( const RMessage2 &aMessage )

    {

    /*if( !iSessionInfo )

        {

        TRAPD( err, ExtractInfoL( aMessage ) );

        TRACE( T_LIT("CBSSession::ServiceL() ExtractInfoL returned with [%d]"), err );

        }

	*/

    if( DispatchMessageL( aMessage ) )

        {

        if( !iMessageCompleted )

        	{

        	aMessage.Complete( KErrNone );

        	}

        }

    }

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

// CBSSession::ServiceError

//

// (other items were commented in a header).

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

//

void CBSSession::ServiceError( const RMessage2& aMessage,

                                      TInt aError )

    {

    aMessage.Complete( aError );

    }

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

// CBSSession::HandleBackupStateL

//

// (other items were commented in a header).

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

//

void CBSSession::HandleBackupStateL( TBackupState aState )

    {

	iIsBackup = ETrue ;	

    switch( aState )

        {

        case EBackupNotActive: // backup is complete

            {

            // release session lock

            iBackupActive = EFalse;

            if( iStorageManager )

                {

                iStorageManager->ReleaseLockL();

                }

			// Sending backup active state change event after unlocking it

			if( iObserverActive )

				{

				iObserverMessage.Complete( KErrNone );

				iObserverActive = EFalse;

				}

            break;

            }

        case EBackupActive: // backup activated

            {

            // Lock session. Branding data is not available until

            // backup is completed.

            iBackupActive = ETrue;

			// Sending backup active state change event before locking it

			if( iObserverActive )

				{

				iObserverMessage.Complete( KErrNone );

				iObserverActive = EFalse;

				}

            if( iStorageManager )

                {

                iStorageManager->LockStorage();

                }

            break;

            }

        default:

            {

            // unknown state

            }

        }

    }

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

// CBSSession::DispatchMessageL

//

// (other items were commented in a header).

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

//

TBool CBSSession::DispatchMessageL( const RMessage2& aMessage )

    {

    TRACE( T_LIT("CBrandingSession[%d]::DispatchMessageL() %d"),

                  this, aMessage.Function() );

	iMessageCompleted = EFalse;

    TBool msgNeedsToBeCompleted = ETrue;

    if( iBackupActive )

        {

        // if backup is active, we don't take requests.

        // We could take some requests which do not require disk

        // operations. This is not a good solution and a better one should be

        // investigated. I'm running out of time.

        TInt msg = aMessage.Function() ; 

        if( msg == EBSObserveGetChange ||

        	msg == EBSObserveGetBackupState ||

        	msg == EBSObserveBrand)

        	{

        	//allow to do the operation	

        	}

        else

    	    {

	       	User::Leave( KErrNotReady );	

        	}

        }

    switch( aMessage.Function() )

        {

        case EBSInitInstall:

        	{

        	InitUpdateL( aMessage, EBSTxInstall );

        	break;

        	}

        case EBSInitUninstall:

        	{

        	InitUpdateL( aMessage, EBSTxUninstall );

        	break;

        	}

        case EBSInitAppend:

        	{

        	InitUpdateL( aMessage, EBSTxAppend );

        	break;

        	}

        case EBSInitReplace:

        	{

        	InitUpdateL( aMessage, EBSTxReplace );

        	break;

        	}

        case EBSInitAccess:

        	{

        	InitAccessL( aMessage );

        	break;

        	}

        case EBSPrepareText:

            {

			GetTextL( aMessage );

            break;

            }

        case EBSGetText:

            {

            if( iText )

            	{

            	aMessage.WriteL( 2, *iText );	

            	}

			else

				{

				aMessage.WriteL( 2, KNullDesC() );

				}

            break;

            }

		case EBSIsBrandUpdateRequired:

			isBrandUpdateRequiredL (aMessage);

			break;

        case EBSGetInt:

            {

			GetIntL( aMessage );

            break;

            }

        case EBSPrepareBuffer:

            {

			GetBufferL( aMessage );

            break;

            }

        case EBSGetBuffer:

            {

            if( iBuffer )

            	{

            	aMessage.WriteL( 2, *iBuffer );	

            	}

			else

				{

				aMessage.WriteL( 2, KNullDesC8() );

				}

            break;

            }

        case EBSGetFile:

            {

 			GetFileL( aMessage );

            break;

            }

        case EBSPrepareSeveral:

        	{

			PrepareSeveralL( aMessage );

        	break;

        	}

        case EBSGetSeveral:

        	{

			GetSeveralL( aMessage );

        	break;

        	}

        case EBSPrepareStructure:

        	{

			PrepareStructureL( aMessage );

        	break;

        	}

        case EBSGetStructure:

    		{

			GetStructureL( aMessage );

    		break;

    		}

        case EBSStartTransaction:

        	{

			StartTransactionL( aMessage );

        	break;

        	}

        case EBSStopTransaction:

        	{

        	StopTransactionL( aMessage );

        	break;

        	}

        case EBSCancelTransaction:

        	{

        	CancelTransactionL( aMessage );

        	break;

        	}

        case EBSInstall:

        	{

        	InstallL( aMessage );

        	break;

        	}

        case EBSReplace:

        	{

        	ReplaceL( aMessage );

        	break;

        	}

        case EBSAppend:

        	{

        	AppendL( aMessage );

        	break;

        	}

        case EBSRemoveBrand:

        	{

        	RemoveBrandL( aMessage );

        	break;

        	}

        case EBSRemoveApplication:

        	{

        	RemoveApplicationL( aMessage );

        	break;

        	}

        case EBSObserveBrand:

        	{

        	if( iObserverActive )

        		{

        		// complete the old observer request with KErrCancel

        		iObserverMessage.Complete( KErrCancel );

        		}

        	iObserverMessage = aMessage;

        	iObserverActive = ETrue;

        	msgNeedsToBeCompleted = EFalse;

        	break;

        	}

        case EBSObserveGetNewVersion:

        	{

        	TInt newVersion = GetNewVersionL();

			TPckgC<TInt> pack( newVersion );

			aMessage.WriteL( 0, pack );

        	break;

        	}

		// Get what change happen        	

        case EBSObserveGetChange:

        	{

			TPckgC<TInt> pack( iIsBackup );

			aMessage.WriteL( 0, pack );

        	break ;

        	}

        // Get the backup state

        case EBSObserveGetBackupState:

        	{

			TPckgC<TInt> pack( iBackupActive );

			aMessage.WriteL( 0, pack );

        	break ;	

        	}

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    return msgNeedsToBeCompleted;

    }

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

// CBSSession::InitUpdateL

//

// (other items were commented in a header).

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

//

void CBSSession::InitUpdateL( const RMessage2 &aMessage, TTransactionType aType)

	{

    TRACE( T_LIT("CBSSession::InitUpdateL: begin TTransactionType[%d] "),aType );

	// get the application id

	TInt bufferSize( aMessage.GetDesLength( 0 ) );

    HBufC8* appId = HBufC8::NewLC( bufferSize );

	TPtr8 appPtr = appId->Des();

	aMessage.ReadL( 0, appPtr );

	HBufC* tmpAppId = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *appId );

	CleanupStack::PopAndDestroy( appId );

	delete iApplicationId;

	iApplicationId = tmpAppId;

	// get the brand id

	bufferSize = aMessage.GetDesLength( 1 );

    HBufC8* streamBuf = HBufC8::NewLC( bufferSize );

	TPtr8 streamPtr = streamBuf->Des();

	aMessage.ReadL( 1, streamPtr );

	RDesReadStream stream;

	CleanupClosePushL( stream );

	stream.Open( streamPtr );

	TInt descriptorLength = stream.ReadInt16L();

	HBufC8* brandId = HBufC8::NewLC( descriptorLength );

	TPtr8 brandPtr = brandId->Des();

	stream.ReadL( brandPtr, descriptorLength );

	HBufC* tmpBrandId = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *brandId );

	CleanupStack::PopAndDestroy( brandId );

	delete iBrandId;

	iBrandId = tmpBrandId;

	descriptorLength = stream.ReadInt16L();

	HBufC8* defaultBrandId = HBufC8::NewLC( descriptorLength );

	TPtr8 defaultPtr = defaultBrandId->Des();

	stream.ReadL( defaultPtr, descriptorLength );

	HBufC* tmpDefaultBrandId = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *defaultBrandId );

	CleanupStack::PopAndDestroy( defaultBrandId );

	delete iDefaultBrandId;

	iDefaultBrandId = tmpDefaultBrandId;

	CleanupStack::PopAndDestroy( 2, streamBuf ); // stream, streamBuf

	// get the language id

	iLanguageId = (TLanguage)aMessage.Int2();

	// get the version

	iReserved = aMessage.Int3();

	// Check if brand is discarded and client is trying to access/append/replace on that

	// give error message saying brand not found so that client will not use that brand

	if(aType == EBSTxAccess || aType == EBSTxAppend || aType == EBSTxReplace )

	{

		if(!iStorageManager)

		{

			iStorageManager = CBSStorageManager::NewL( this, *iApplicationId );	

		}

		TBool brandDiscarded = EFalse ;

		brandDiscarded = iStorageManager->CheckBrandDiscarded(*iApplicationId, *iBrandId) ;

		if(brandDiscarded)

		{

			TRACE( T_LIT("CBSSession::InitUpdateL: Brand discarded!->LeaveWith KErrNotFound") );

			///Server()->DisplaySessionInfoL( this, KErrNotFound );

			User::Leave( KErrNotFound );	

		}

	}

	if( aType == EBSTxAppend )

		{

		PrepareAppendL();

		}

	else if( aType == EBSTxReplace )

		{

		PrepareReplaceL();

		}

	else if(aType == EBSTxUninstall)

		{

		if( !iStorageManager )

			{

			iStorageManager = CBSStorageManager::NewL( this, *iApplicationId );

			}

		// if any client is accessing same brand leave with KErrInUse.