/*

* Copyright (c) 2008 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:  Class that capsulates single service data members

*

*/

//  INCLUDES

#include "cvimpstengine.h"

#include "cvimpstengineservicetablefetcher.h"

#include <e32std.h>

#include <barsc.h>

#include <gulutil.h>

#include <coemain.h>

#include <e32base.h>

#include "tvimpstconsts.h"

#include "cvimpstenginevoipsubservice.h"

#include "cvimpstengineimsubservice.h"

#include "cvimpstenginepresencesubservice.h"

#include "cvimpstenginecchhandler.h"

//storage

#include "cvimpststoragemanagerfactory.h"

#include "cvimpstenginesessioncntxtobserver.h"

#include "mvimpststorageserviceview.h"

#include "mvimpststoragevpbkstorehandler.h"

#include "tvimpstenums.h" 

#include "mvimpstengineextentionfeatures.h"

#include "mvimpstengineservicestateeventobserver.h"

//extention features

#include "cvimpstenginesearchmgrextention.h"

#include "cvimpstenginecontactmgmtextention.h"

#include "cvimpstblockedlistmanager.h"

#include "mvimpststoragecontactlist.h"

#include <cvimpstsettingsstore.h>

#include "vimpstdebugtrace.h"

// Constants

_LIT( KListNameAllBuddy ,"buddylist" );

// ================= MEMBER FUNCTIONS =======================

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

// CVIMPSTEngine::NewL

// 

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

CVIMPSTEngine* CVIMPSTEngine::NewL(

								TUint32 aServiceId,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher )

    {

    TRACE( T_LIT("CVIMPSTEngine::NewL start") );

    TRACE( T_LIT("NewL() ServiceId: %d"), aServiceId );

    CVIMPSTEngine* self = CVIMPSTEngine::NewLC(	aServiceId,

    											aTableFetcher );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CVIMPSTEngine::NewLC

// 

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

CVIMPSTEngine* CVIMPSTEngine::NewLC(

								TUint32 aServiceId,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher )

	{

    TRACE( T_LIT("CVIMPSTEngine::NewLC start") );

    TRACE( T_LIT("NewLC() ServiceId: %d"), aServiceId );

    CVIMPSTEngine* self = new (ELeave) CVIMPSTEngine(

    												aServiceId, 

    												aTableFetcher );

    CleanupStack::PushL( self );

    self->ConstructL( aServiceId );

    TRACE( T_LIT("CVIMPSTEngine::NewLC end") );

    return self;

	}

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

// CVIMPSTEngine::~CVIMPSTEngine

// 

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

CVIMPSTEngine::~CVIMPSTEngine()

	{

	TRACE( T_LIT("CVIMPSTEngine::~CVIMPSTEngine start") );

	iObserverArray.Reset();

    iObserverArray.Close();

	iSubService.ResetAndDestroy();	

	iSubService.Close();

	// Delete this after sub services, those might use it in destructor!

	delete iSessionCntxtObserver;

    delete iServiceName;

	iExtentionFeatures.ResetAndDestroy();

	iExtentionFeatures.Close();

	delete iCchHandler;

    iCchHandler = NULL;       

    TRACE( T_LIT("CVIMPSTEngine::~CVIMPSTEngine end") );

 	}

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

// CVIMPSTEngine::ConstructL

// 

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

void CVIMPSTEngine::ConstructL( TUint32 aServiceId )

	{

	TRACE( T_LIT("CVIMPSTEngine::ConstructL  start") );

    TRACE( T_LIT("ConstructL() - ServiceId: %d"), aServiceId );

	iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength );

	// construct the service state by passing the array of subservices.

	iCchHandler = CVIMPSTEngineCchHandler::NewL(iServiceId,*this);

	//construct eventobserver only if there are any adaptations.

	TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(aServiceId);

	TBool requireXimp = EFalse;		

	TBool presenceSupported = IsSubServiceSupportedInternal(TVIMPSTEnums::EPresence);

	TBool imSupported = IsSubServiceSupportedInternal(TVIMPSTEnums::EIM);

	requireXimp |= presenceSupported;

	//if either of Presence/IM Subservice supported then we need

	//to bind to XIMP context. 

	if ( KErrNotFound != ximpAdapterUid && requireXimp )

	    {

	    }

	// iterate the service array

    for ( TInt index = TVIMPSTEnums::EVoip; index < TVIMPSTEnums::ELast ; index++ )        

        {

	    //create the subservice

	    switch(index)

	        {

	        case TVIMPSTEnums::EVoip:

	            {

	            if(IsSubServiceSupportedInternal(TVIMPSTEnums::EVoip))

	                {

	                CVIMPSTEngineVOIPSubService* item = 

	                CVIMPSTEngineVOIPSubService::NewL(aServiceId, *iCchHandler,

	                        iTableFetcher, *this);

	                iSubService.Append(item);

	                }

	            break;				

	            }

	        case TVIMPSTEnums::EPresence:

	            {

	            if(presenceSupported)

	                {

	                if (iSessionCntxtObserver)

	                    {

	                    CVIMPSTEnginePresenceSubService* item = CVIMPSTEnginePresenceSubService::NewL(

	                            aServiceId,*iCchHandler,iTableFetcher,

	                            *iSessionCntxtObserver,*this

	                    );

	                    iSubService.Append(item);

	                    iSessionCntxtObserver->RegisterObserver(item);					

	                    }

	                }

	            break;

	            }

	        case TVIMPSTEnums::EIM:

	            {

	            if(imSupported)

	                {

	                CVIMPSTEngineIMSubService* item = 

	                CVIMPSTEngineIMSubService::NewL(aServiceId, *iCchHandler, 

	                        iTableFetcher,*this);

	                iSubService.Append(item);

	                }

	            break;

	            }

	        default:		

	            {

	            break;

	            }

	        }				

	    }

    //Create the required extention mgrs

    CreateExtentionFeaturesL(); 		

    iState = ParseGetServiceState();

    //if cch is already logged in, and the callback's servicestatuschanged() stopped

    RetriveContextIfCChEnabledL();

    TRACE( T_LIT("CVIMPSTEngine::ConstructL  end") );

    }

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

// CVIMPSTEngine::CVIMPSTEngine

// 

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

CVIMPSTEngine::CVIMPSTEngine( TUint32 aServiceId,

								CVIMPSTEngineServiceTableFetcher& aTableFetcher ) :

iServiceId(aServiceId),

iTableFetcher(aTableFetcher)								

	{

	}

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

// CVIMPSTEngine::RetriveContextIfCChEnabledL

// 

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

void CVIMPSTEngine::RetriveContextIfCChEnabledL()

	{

    TRACE( T_LIT("CVIMPSTEngine::RetriveContextIfCChEnabledL  start") );

    if ( (iSessionCntxtObserver) && 

         (TVIMPSTEnums::ESVCEUpdatingContacts == iState || TVIMPSTEnums::ESVCERegistered == iState ) 

   		 && ( TVIMPSTEnums::EVIMPSTBindNotDone == iSessionCntxtObserver->ContextBindStatus()  ) )

		{

		TInt ximpAdapterUid = iTableFetcher.XimpAdapterUidL(iServiceId);

		TInt err = iSessionCntxtObserver->ServerBindL(TUid::Uid( ximpAdapterUid ));	      

        if(KErrNone != err)

            {

            //should never reache here;

            iCchHandler->DisableService();

            User::LeaveIfError(err);

            }

        SetExtentionFeaturesSupportedL();

		}

	TRACE( T_LIT("CVIMPSTEngine::RetriveContextIfCChEnabledL end"));

	}

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

// CVIMPSTEngine::LoginL

// 

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

TInt CVIMPSTEngine::Login()

	{

    TRACE( T_LIT("CVIMPSTEngine::ConstructL  start") );

    TRACE( T_LIT("Login() - ServiceId: %d"), iServiceId );

	TInt error = KErrNotFound;

	if(iCchHandler)

		{

		TRACE( T_LIT("Login() - EnableService Called"));

		error =  iCchHandler->EnableService(); 		

		}

	TRACE( T_LIT("Login - error: %d"), error );

	TRACE( T_LIT("CVIMPSTEngine::Login"));

	return error;

	}

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

// CVIMPSTEngine::Logout

// 

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

void CVIMPSTEngine::LogoutL()

	{

	TRACE( T_LIT("CVIMPSTEngine::Logout"));

	TRACE( T_LIT("Logout() - ServiceId: %d"), iServiceId );

	if(iCchHandler)

		{

		MVIMPSTEngineSubService* subService = SubService(TVIMPSTEnums::EPresence);

		if (subService)

		    {

		    //Get Presence SubService     

		    MVIMPSTEnginePresenceSubService& presenceSubService = 

		                    MVIMPSTEnginePresenceSubService::Cast(*subService);

		    if (TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() ||

		            TVIMPSTEnums::ESVCEUpdatingContacts == subService->SubServiceState() ) 

		        {

		        // Unsubscribe all lists here to get whole list contents when doing a new bind.

                // Trap here to avoid unbind not being done if list operations should leave

                TRAP_IGNORE( presenceSubService.UnsubscribeListsL() ); 

		        }		    

		    }

 			//if either of Presence/IM Subservice supported then we need

      //to unbind to XIMP context. 

      if( iSessionCntxtObserver )

          {

          TRACE( T_LIT("Logout() - ServerUnBindL Called"));

          iSessionCntxtObserver->ServerUnBindL(ETrue);    

          }		

		TRACE( T_LIT("Logout() - DisableService Called"));

		iCchHandler->DisableService();  

		}	

	TRACE( T_LIT("CVIMPSTEngine::Logout"));

	}

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

// CVIMPSTEngine::ServiceId

// 

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

TUint32 CVIMPSTEngine::ServiceId() const

	{

	TRACE( T_LIT("ServiceId() - ServiceId: %d"), iServiceId );

	return iServiceId;	

	}

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

// CVIMPSTEngine::ServiceName

// 

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

const TDesC& CVIMPSTEngine::ServiceName() const

	{

	TPtr serviceNamePtr = iServiceName->Des();

	TRACE( T_LIT("ServiceName() - ServiceName: '%S'"), &serviceNamePtr );

	return *iServiceName;	

	}

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

// CVIMPSTEngine::ServiceState

// 

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

TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEngine::ServiceState() const

	{

	TRACE( T_LIT("ServiceState() - ServiceState: %d"), iState  );

	return iState;

	}

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

// CVIMPSTEngine::GetBrandInfo

// 

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

TInt CVIMPSTEngine::GetBrandInfoL(TLanguage& aBrandLanguage, 

				TInt &aBrandVersion, TDes8& aBrandId) const

	{

	TRACE( T_LIT("CVIMPSTEngine::GetBrandInfoL start"));

	TRACE( T_LIT("GetBrandInfoL() - ServiceId: %d"), iServiceId );

	iTableFetcher.GetBrandIdL(iServiceId, aBrandId);

	aBrandLanguage = iTableFetcher.PropertyBrandLanguageL(iServiceId);

	aBrandVersion = iTableFetcher.PropertyBrandVersionL(iServiceId);

	TRACE( T_LIT("CVIMPSTEngine::GetBrandInfoL end"));

	return KErrNone;

	}

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

// CVIMPSTEngine::IsSubServiceSupportedL

// 

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

TBool CVIMPSTEngine::IsSubServiceSupportedL(TVIMPSTEnums::SubServiceType aType) const 

	{

	TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL start"));

	TRACE( T_LIT ("IsSubServiceSupportedL() - ServiceId: %d"), iServiceId);

	TRACE( T_LIT ("IsSubServiceSupportedL() - SubServiceType: %d"), aType);

	TBool support = EFalse;

	MVIMPSTEngineSubService* subService = SubService(aType);

	if (subService)

		{

		support = ETrue;

		}

	TRACE( T_LIT("IsSubServiceSupportedL() - support: %d"), support );	

	TRACE( T_LIT("CVIMPSTEngine::IsSubServiceSupportedL end"));

	return support;

	}

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

// CVIMPSTEngine::IsSubServiceEnabled

// 

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

TBool CVIMPSTEngine::IsSubServiceEnabled(TVIMPSTEnums::SubServiceType aType) const 

	{

	TRACE( T_LIT("CVIMPSTEngine::IsSubServiceEnabled start"));

    TRACE( T_LIT("IsSubServiceEnabled() - ServiceId: %d"), iServiceId );

    TRACE( T_LIT("IsSubServiceEnabled() - SubServiceType: %d"), aType );

	MVIMPSTEngineSubService* subService = SubService(aType);

	TBool enabled = EFalse;

	if (subService)

		{			

		if ( TVIMPSTEnums::ESVCERegistered == subService->SubServiceState() )

			{			

			enabled = ETrue;

			}

		}	

	TRACE( T_LIT("IsSubServiceEnabled() - enabled: %d"), enabled );

	TRACE( T_LIT("CVIMPSTEngine::IsSubServiceEnabled end") );

	return enabled;	

	}

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

// CVIMPSTEngine::GetContactStoreIdL

// 

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

void CVIMPSTEngine::ContactStoreIdL (TDes& aContactStoreId ) const

	{

	TRACE( T_LIT("CVIMPSTEngine::ContactStoreIdL start"));

	TRACE( T_LIT("ContactStoreIdL() - ServiceId: %d"), iServiceId );	

	iTableFetcher.GetContactStoreIdL(iServiceId, aContactStoreId);	

	TRACE( T_LIT("CVIMPSTEngine::ContactStoreIdL end"));

	}

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

// CVIMPSTEngine::RegisterServiceSessionObserver()

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

// 

void CVIMPSTEngine::RegisterServiceSessionObserverL

							(MVIMPSTEngineServiceStateEventObserver* aObserver)

	{

	__ASSERT_ALWAYS(aObserver,User::Leave(KErrArgument));

	TRACE( T_LIT("CVIMPSTEngine::RegisterServiceSessionObserverL start"));

	TInt index = iObserverArray.Find(aObserver);

	        if( index == KErrNotFound )

	            {

	            iObserverArray.Append( aObserver );   

	            } 

	TRACE( T_LIT("CVIMPSTEngine::RegisterServiceSessionObserverL end"));

	}

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

// CVIMPSTEngine::UnRegisterServiceSessionObserver()

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

//     

void CVIMPSTEngine::UnRegisterServiceSessionObserver

							(MVIMPSTEngineServiceStateEventObserver* aObserver)

	{

	TRACE( T_LIT("CVIMPSTEngine::UnRegisterServiceSessionObserverL start"));

    if(aObserver)

        {

        TInt index = iObserverArray.Find(aObserver);

        if( index >=0 )

            {

            iObserverArray.Remove( index );

            iObserverArray.Compress();

            }

        }

	TRACE( T_LIT("CVIMPSTEngine::UnRegisterServiceSessionObserverL end"));

	}

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

// CVIMPSTEngine::IntializeStorage

// 

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

void CVIMPSTEngine::IntializeStorageL()

	{

    TRACE( T_LIT("CVIMPSTEngine::IntializeStorageL"));

    TRACE( T_LIT("IntializeStorageL() - ServiceId: %d"), iServiceId );	

 	iContactInterface = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);

 	if(iContactInterface)

		{

		iContactInterface->AddObserverL( this );   

		MVIMPSTSettingsStore* store = CVIMPSTSettingsStore::NewLC(); 

		RBuf lastUserName;

		lastUserName.CreateL( KPropertyMaxLength );

		CleanupClosePushL( lastUserName );

		store->GetL( iServiceId, EServiceLastUserName, lastUserName );

		if( lastUserName.Length() == 0 )

			{

			HBufC* userId = GetOwnUserIdFromCChOrStorageL();

			CleanupStack::PushL( userId );

			store->SetL(iServiceId, EServiceLastUserName,*userId);

			iContactInterface->SetOwnUserIdL(*userId );  

			CleanupStack::PopAndDestroy(); //userId   

			}

		else

			{

			iContactInterface->SetOwnUserIdL(lastUserName );	

			}

		CleanupStack::PopAndDestroy(&lastUserName); //lastUserName  

		CleanupStack::PopAndDestroy(); //store     

		}

 	TRACE( T_LIT("CVIMPSTEngine::IntializeStorageL") );

	}

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

// CVIMPSTEngine::UnIntializeStorage

// 

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

void CVIMPSTEngine::UnIntializeStorage()

	{

	TRACE( T_LIT("CVIMPSTEngine::UnIntializeStorage start"));

	TRACE( T_LIT("UnIntializeStorage() - ServiceId: %d"), iServiceId );