/*

* Copyright (c) 2006, 2007 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:  s_enginecontmgtextfeatures.cpp

*

*/

#include "s_vimpstengin.h"

//#include "s_enginecontmgtextfeatures.h"

#include "s_enginesearchextention.h"

#include "s_vimpstenginepresencesubservice.h"

#include "s_imsubservice.h"

#include "tvimpstenums.h"

#include "s_engineextentionfeatures.h"

/*

*/

/*MVIMPSTEngine& vimpstengine_stub::NewL()

{

	return new vimpstengine_stub;

}*/

/**

* Gets the Brand Information for the current service

* @param aBrandLanguage - Holds the BrandLanguage

* @param aBrandVersion - Holds the Version to be used

* @param aBrandId - Holds the brandId 

* caller should allocate memory for all params and send the same to this API

* The result will be available in the InParams otself.

* @return TInt Error code

*/

TInt vimpstengine_stub::GetBrandInfoL(TLanguage& /*aBrandLanguage*/, 

		TInt& /*aBrandVersion*/, TDes8& /*aBrandId*/) const 

	{

	return 1;			

	}

/**

* Returns the Service State - Cumulative Service State of the SubServices

* @return TVIMPSTRegistrationState, current service state.

*/

TVIMPSTEnums::TVIMPSTRegistrationState vimpstengine_stub::ServiceState() const 

	{

	TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCERegistered;

	return state;

	}

/**

* Gets the Service Id

* @return TUint32 Service Id

*/

TUint32 vimpstengine_stub::ServiceId() const

{

return 1;	

}

/**

* Returns a SubService is Supported or not

* Components intertested in knowing whether a SubService is Supported or not can use this API

* @param aType - Type of the SubService TVIMPSTEnums::SubServiceType - Defined in tvimpstenums.h

* @return TBool, ETrue if the SubService is Supported in this Service, else returns EFalse

*/			

TBool vimpstengine_stub::IsSubServiceSupportedL(TVIMPSTEnums::SubServiceType /*aType*/) const 

	{

	return ETrue;

	}

/**

* Returns TBool whether a SubService is Enabled or not

* Components intertested in knowing whether a SubService is Enabled or not can use this API

* @param aType - Type of the SubService TVIMPSTEnums::SubServiceType - Defined in tvimpstenums.h

* @return TBool, ETrue if the SubService is Enabled in this Service, else returns EFalse

*/

TBool vimpstengine_stub::IsSubServiceEnabled(TVIMPSTEnums::SubServiceType /*aType*/) const 

{

	return ETrue;

}

/**

* Gets the StoreName for given service

* @param aContactStoreId, Virtual store id. 

* The caller of the this function has to assign required memory for aContactStoreId

* aContactStoreId will be filled with the Virtual Store Id by this API

*/

void vimpstengine_stub::ContactStoreIdL( 

		TDes& /*aContactStoreId*/ ) const 

{

}

/**

* returns the Service Name	

* @return TDesC&, reference to service name. Ownership is not transferred.

*/

const TDesC& vimpstengine_stub::ServiceName() const 

{

	return KNullDesC;

}

/**

* Register Session Observer.

* @aObserver, observer ot be registered.

*/

void vimpstengine_stub::RegisterServiceSessionObserverL

				(MVIMPSTEngineServiceStateEventObserver* /*aObserver*/) 

{

}

/**

* UnRegisters Session Observer

* @aObserver, observer ot be Unregistered.   

*/

void vimpstengine_stub::UnRegisterServiceSessionObserver

				(MVIMPSTEngineServiceStateEventObserver* /*aObserver*/) 

{

}

/**

* intialize storage 

*/	

void vimpstengine_stub::IntializeStorageL() 

{

}

/**

* unintialize storage

*/	

void vimpstengine_stub::UnIntializeStorage() 

{

}

/**

* Get the Ptr to the SubService given the Type of the SubService

* This API returns a Generalised SubService Class MVIMPSTEngineSubService

* Ownership of the SubService is not Transferred to the Caller

* The Caller can use this (MVIMPSTEngineSubService*) ptr to typecast to appropriate SubService Interface

* Usage	 : 			MVIMPSTEngineIMSubService* imSubService = 

*			   	   			dynamic_cast<MVIMPSTEngineIMSubService*> 

*			   	   			(iEngine.SubService(TVIMPSTEnums::EIM));

*			    

*				    if(imSubService)

*				        {

*				        imSubService->CloseConversationL( iContactId );

*				        }

* @param aType - SubService Type (TVIMPSTEnums::SubServiceType) defined in tvimpstenums.h

* @return - Ptr to the SubService - Value can even be NULL

*/ 

MVIMPSTEngineSubService* vimpstengine_stub::SubService(TVIMPSTEnums::SubServiceType aType) const

{

MVIMPSTEngineSubService* subservice = NULL;

switch(aType)

        {

        case TVIMPSTEnums::EPresence:

            {

            TRAP_IGNORE(subservice = CVIMPSTEnginePresenceSubService_Stub::NewL());

            return subservice ;

            break;

            }

     /*   case TVIMPSTEnums::EIM:

                    {

                    TRAP_IGNORE(subservice = CVIMPSTEngineImSubService_Stub::NewL());

                    return subservice ;

                    break;

                    }*/

        default:

            break;

        }

	return subservice;

}

/**

*/

MVIMPSTEngineExtentionFeatures* vimpstengine_stub::ExtentionFeatures(TVIMPSTEnums::ExtentionType aType) const 

{

	MVIMPSTEngineExtentionFeatures* extFeature = NULL;

	switch(aType)

		{

		case TVIMPSTEnums::EContactManagement:

			{

			TRAP_IGNORE(extFeature = extentionfeatures_stub::NewL());

			return extFeature ;

			break;

			}

		case TVIMPSTEnums::ESearch:

			{

			TRAP_IGNORE(extFeature = searchextention_stub::NewL());

			return extFeature ;

			break;

			}

		}

		return extFeature;

}

/**

* Sets the User Name for the Service 

* Stores the username to CCH Plugin

*

void vimpstengine_stub::SetUserNameL(const TDesC& /*aUserid) 

{

}

*/

/**

* Sets the Password for the Service 

* Stores the Password to CCH Plugin

* @param Password, Password to be stored.

*

void vimpstengine_stub::SetPassword(const TDesC& /*aPassword) 

{

}

/**

* gets the UserName for the Service          

* @return HBufC* - Ownership is transferred to the caller

* This API allocates memory for the UserName and transfers the Ownership to the Caller

*

HBufC* vimpstengine_stub::UserNameL() const 

{

_LIT(KText,"Nutan@presence");

   HBufC* buf = HBufC::NewL(20);

   *buf = KText; 

	return buf;

}

/**

* gets the Password for the Service          

* @return HBufC* - Ownership is transferred to the caller

* This API allocates memory for the Password and transfers the Ownership to the Caller

*

HBufC* vimpstengine_stub::PasswordL() const 

{

	return NULL;

}

*/

/**

* API used to login to the Service                  

*/

TInt vimpstengine_stub::Login() 

{

	return 1;

}

/**

* API used to Logout to the Service                  

*/

void vimpstengine_stub::LogoutL() 

{

}

/**

* Gets the default domain name for given service

* @param aDefaultDomainName, Domain Name. 

* The caller of the this function has to assign required memory for aDefaultDomainName

* aDefaultDomainName will be filled with the deafault domain name by this API

*/			

void vimpstengine_stub::DefaultDomainNameL( TDes& /*aDefaultDomainName */) const 

{

}

/**

 * IsBlockSupportedL

 * @returns ETrue if block/unblock is supported 

 * else EFalse

 */

TBool vimpstengine_stub::IsBlockSupportedL()

{

	return ETrue;

}

TInt vimpstengine_stub::ChangeConnectionL()

{

	return 1;

}

/**

* See MVIMPSTEngine

* 

* @return True if password is present in the settings else returns false

*

*/

TBool vimpstengine_stub::IsPasswordAvailableL()

{

return ETrue;

}

/**

          * Inform storage that data base need to be deleted.

          */

 void  vimpstengine_stub::DeleteDataBaseL()

    {

    }

 /*----------------------------------------------------------

  * vimpstengine_stub::GetPreseceSubService

  *-----------------------------------------------------------*/

 MVIMPSTEnginePresenceSubService* vimpstengine_stub::GetPreseceSubService()

     {

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

     if (subService)

         {

         //Get Presence SubService     

         MVIMPSTEnginePresenceSubService& presenceSubService = 

         MVIMPSTEnginePresenceSubService::Cast(*subService);

         return &presenceSubService ;

         }

     return NULL;

     }

 /*----------------------------------------------------------

  * vimpstengine_stub::FetchBlockedListL

  *-----------------------------------------------------------*/

 void vimpstengine_stub::FetchBlockedListL()

     {

     }

 /*----------------------------------------------------------

  * vimpstengine_stub::RegisterBlockedListObserver

  *-----------------------------------------------------------*/

 void vimpstengine_stub::RegisterBlockedListObserver(

                     MVIMPSTEngineBlockedListFetchEventObserver* aOb)

     {

     }

 HBufC* vimpstengine_stub::GetOwnUserIdFromCChOrStorageL() const

 {

 HBufC* temp = NULL;

 return temp;

 }

 void vimpstengine_stub::RetriveContextIfCChEnabledL() 

     {

     }

 void vimpstengine_stub::SetOwnUserIdIfChangedL(const TDesC& aUserId ) 

     {

     }

 TBool vimpstengine_stub::IsUnInstalled()

     {

     return EFalse;

     }

//end of file