/*

* 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:  connection service manager for im

*

*/

#include "cicpservicemanager.h"	   	// service manager

#include <e32std.h>

#include <ximpclient.h>

#include <ximpcontext.h>

#include <ximprequestcompleteevent.h>

#include <ximpcontextstateevent.h>

#include <ximpidentity.h>

#include <ximpstatus.h>

#include <ximpcontextstateevent.h>

#include <ximpcontextstate.h>

#include <ximperrors.hrh>

#include <imconversationevent.h> // recieve message

#include <imconversationinfo.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spdefinitions.h>

#include "icplogger.h"

#include "cicpservicerequest.h"

// imcache related includes

#include    <cimcachefactory.h>

#include	<mimcacheupdater.h>

//xmppsettings

#include "xmppparams.h"

#include "xmppservicesettingsapi.h"

/************** Consts ***************/

const TInt KPropertyMaxLength = 512;

const TInt KPasswordMaxLength = 50;

//Received message maximum length is 400 character if received message is longer than 400 character

//Truncate it to 400 character

//This must always be in sync with imcvuiapp KReceiveMsgMaxLength

const TInt KReceiveMsgMaxLength = 400;  

 _LIT(KAt, "@");

 _LIT(KPercentage, "%");

/***********End of Consts**********************/

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

// CIcpServiceManager::CIcpServiceManager()

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

//

CIcpServiceManager::CIcpServiceManager( MCchServiceObserver& aServiceObserver ) :

    iServiceObserver( aServiceObserver ),

    iOngoingState( ECCHUninitialized )

	{

    ICPLOGSTRING( "CIcpServiceManager::CIcpServiceManager");

	}

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

// CIcpServiceManager::NewL

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

//

CIcpServiceManager* CIcpServiceManager::NewL( MCchServiceObserver& aServiceObserver )

	{

    ICPLOGSTRING( "CIcpServiceManager::NewL");

    CIcpServiceManager* self = new ( ELeave ) CIcpServiceManager( aServiceObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

	}

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

// CIcpServiceManager::ConstructL

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

//

void CIcpServiceManager::ConstructL()

    {

    ICPLOGSTRING( "CIcpServiceManager::ConstructL");

    iCSPSetting = CSPSettings::NewL();

    iXmppParameters = CXmppSettingsApi::NewL();

	iOwnUserId = HBufC::NewL(MAX_LENGTH);

    if ( iPresClient )

        {

        delete iPresClient;

        iPresClient = NULL;

        }

    //XIMP Context creation    

    iPresClient = MXIMPClient::NewClientL();

    MXIMPContext* tmp = iPresClient->NewPresenceContextLC();

    iPresenceCtx = tmp;

    CleanupStack::Pop( ); // iPresenceCtx

	iAcceptedEventTypes.Reset();

    iAcceptedEventTypes.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );

    iAcceptedEventTypes.AppendL( MXIMPContextStateEvent::KInterfaceId );       

    iAcceptedEventTypes.AppendL( MImConversationEvent::KInterfaceId );

	TArray< TInt32 > eventFilterArray = iAcceptedEventTypes.Array();

   	// register this to prsence context   

    iPresenceCtx->RegisterObserverL( *this, &eventFilterArray );       

    tmp = NULL;                                                                      

    ICPLOGSTRING( "CIcpServiceManager::ConstructL Done");  

    }

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

// CIcpServiceManager::~CIcpServiceManager

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

//

CIcpServiceManager::~CIcpServiceManager()

	{	

    ICPLOGSTRING( "CIcpServiceManager::~CIcpServiceManager"); 

    delete iXmppParameters;

    delete iOwnUserId; 

    delete iCSPSetting;

    iAcceptedEventTypes.Reset();

	iAcceptedEventTypes.Close();

    iReqIDArray.ResetAndDestroy();

    delete iPresenceCtx;

    delete iPresClient;

    if(iIMCacheFactory)

	    {

	    CIMCacheFactory::Release();	

	    }

	if (iServiceName)

		{

		delete iServiceName;

		iServiceName = NULL;	

		}

	}

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

// CIcpServiceManager::EnableServiceL

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

//

void CIcpServiceManager::EnableServiceL( TUint aServiceId,

                                         TCCHSubserviceType aSubServiceType )

    {

    ICPLOGSTRING3( "CIcpServiceManager::EnableServiceL service:%i Type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

	if ( (iOngoingState != ECCHEnabled) && 

				(iOngoingState != ECCHConnecting) )

		{

		//Get the service

		iServiceId = aServiceId;

		if (iServiceName)

			{

			delete iServiceName;

			iServiceName = NULL;	

			}

		iServiceName = HBufC::NewL(KPropertyMaxLength);

		TPtr serviceIdPtr( iServiceName->Des() );    

		GetServiceNameL(iServiceId, serviceIdPtr);

	    TInt settingsId = GetSPSettingsIntPropertyL(aServiceId, ESubPropertyIMSettingsId);

	    //reset owndata

	    delete iOwnUserId;    

	    iOwnUserId = NULL;

	    iOwnUserId = HBufC::NewL(MAX_LENGTH);

		TPtr owndataPtr = iOwnUserId->Des();

	    //get the owndata from settingsapi

	    CXmppSettingsApi* xmppParameters = CXmppSettingsApi::NewLC();    	

		xmppParameters->GetParamL(settingsId, XmppParams::KXmppParamUsername(), owndataPtr );	

		CleanupStack::PopAndDestroy(); // xmppParameters

		TInt passwordSet = KErrNotFound;

		GetConnectionParameter(aServiceId,aSubServiceType,ECchPasswordSet,passwordSet);

		if(0 ==  iOwnUserId->Length() || !passwordSet)

		    {

		    // check the user name if its empty or leave with the KCCHErrorAuthenticationFailed

            // for the cch ui to show the user name and password query dialog.

            User::Leave(KCCHErrorAuthenticationFailed);

		    }

		//bind to presence context

		BindL(iServiceId);	

		iOngoingState = ECCHConnecting; 

		}

    ICPLOGSTRING( "CIcpServiceManager::EnableServiceL out" );

    }

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

// CIcpServiceManager::EnableServiceL

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

//

void CIcpServiceManager::EnableServiceL( TUint aServiceId,

                                         TCCHSubserviceType aSubServiceType,

                                         TUint /*aIapId*/ )

    {

    ICPLOGSTRING3( "CIcpServiceManager::EnableServiceL service:%i Type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    EnableServiceL( aServiceId, aSubServiceType );

    }

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

// CIcpServiceManager::DisableServiceL

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

//

void CIcpServiceManager::DisableServiceL( TUint aServiceId,

                                          TCCHSubserviceType aSubServiceType  )

    {

    ICPLOGSTRING3( "CIcpServiceManager::DisableService service:%i Type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

	// just unbind the context from the oss protocol adaptation plugin

	if (iOngoingState == ECCHEnabled)	

		{

		UnBindL();   

		iOngoingState = ECCHDisconnecting;  

		}

    }

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

// CIcpServiceManager::IsAvailableL

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

//

TBool CIcpServiceManager::IsAvailableL( TUint /*aServiceId*/,

                                        TCCHSubserviceType /*a*/,

                                        const RArray<TUint32>& /*aIapIdArray*/ ) const

    {

    ICPLOGSTRING( "CIcpServiceManager::IsAvailableL" );

    return ETrue;

    }

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

// CIcpServiceManager::GetServiceState

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

//

TInt CIcpServiceManager::GetServiceState( TUint aServiceId,

                                          TCCHSubserviceType aSubServiceType , 

                                          TCCHSubserviceState& aState ) const

    {

    ICPLOGSTRING3( "CIcpServiceManager::GetServiceState service:%i type:%i", aServiceId, aSubServiceType );

	__ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    TInt result( KErrNone );

    aState = iOngoingState;        

    result = iLastReportedError;

    return result;

    }

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

// CIcpServiceManager::GetServiceNetworkInfo

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

//

TInt CIcpServiceManager::GetServiceNetworkInfoL( TUint aServiceId,

                                                TCCHSubserviceType aSubServiceType,

                                                TUint32& aSnapId, 

                                                TUint32& aIapId,

                                                TBool& aSnapLocked,

                                                TBool& aPasswordSet) const

    {

    ICPLOGSTRING3( "CIcpServiceManager::GetServiceNetworkInfo service:%i type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

	//Please dont remove the below line

    //otheriwse enable service will not be called

    //assuming service is down. Hack

    aSnapId = 0;

    aIapId = 5;

    aSnapLocked = ETrue;    

    // read from setting see, if it is availabe set 1 else 0

    TInt settingsId = GetSPSettingsIntPropertyL(aServiceId, ESubPropertyIMSettingsId);            

    //get the owndata from settingsapi

    HBufC* password = HBufC::NewLC( KPasswordMaxLength );

    TPtr  passwordPtr( password->Des() );

    iXmppParameters->GetParamL((TUint32)settingsId, XmppParams::KXmppParamPassword(), passwordPtr );

    if( passwordPtr.Length() > 0 )

        {

        aPasswordSet = ETrue;

        }

    else

        {

        aPasswordSet = EFalse;

        }  

    CleanupStack::PopAndDestroy();// password 

    return KErrNone;

    }

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

// CIcpServiceManager::SetSnapId

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

//

TInt CIcpServiceManager::SetSnapId( TUint /*aServiceId*/,

                                    TCCHSubserviceType /*aSubServiceType*/,

                                    const TUint /*aSnapId*/ )

    {    

    return KErrNotSupported;

    }

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

// CIcpServiceManager::SetIapId

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

//

TInt CIcpServiceManager::SetIapId( TUint /*aServiceId*/,

                                   TCCHSubserviceType /*aSubServiceType*/,

                                   TUint /*aIapId*/ )

    {

    return KErrNotSupported;

    }

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

// CIcpServiceManager::GetServiceInfoL

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

//

void CIcpServiceManager::GetServiceInfoL( TUint /*aServiceId*/,

                                          TCCHSubserviceType /*aSubServiceType*/,

                                          RBuf& /*aBuffer*/ ) const

    {    

    }

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

// CIcpServiceManager::ReserveService

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

//

TInt CIcpServiceManager::SetServiceReserved( TBool /*aReserved*/,

                                             TUint /*aServiceId*/,

                                             TCCHSubserviceType /*aSubServiceType*/ )

    {

    return KErrNotSupported;

    }

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

// CIcpServiceManager::GetConnectionParameter

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

//

TInt CIcpServiceManager::GetConnectionParameter(TUint aServiceId,

                         TCCHSubserviceType aSubServiceType, 

                         TCchConnectionParameter aParameter,

                         TInt& aValue ) const

    {

    ICPLOGSTRING3( "CIcpServiceManager::GetConnectionParameter service:%i type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    TInt error = KErrBadHandle;

    switch( aParameter )

	    {

	    case ECchIapId:

		    {

		    aValue = iIapId;

		    error = KErrNone;

		    break;	

		    }

		case ECchSnapId:

		    {

		    aValue = iSnapId;

		    error = KErrNone;

		    break;	

		    }

		case ECchSnapLocked:

		    {

		    aValue = ETrue;

		    error = KErrNone;

		    break;	

		    } 

		case ECchPasswordSet:

		    {

		    // dont return ETrue simply, check if password length is greater than 0,

		    // only then return ETrue, else return EFalse.

		    TBuf<MAX_LENGTH> password;

		    TInt settingsId = KErrNotFound;

		    TRAPD(err,settingsId = GetSPSettingsIntPropertyL(aServiceId, ESubPropertyIMSettingsId));               

           //get the owndata from settingsapi

		   if(KErrNone == err)

		       {

	           TRAP_IGNORE(iXmppParameters->GetParamL((TUint32)settingsId, 

	                                               XmppParams::KXmppParamPassword(), password ));

		       }

           if( 0 == password.Length())

               {

               aValue = EFalse;

               }

           else 

               {

               aValue = ETrue;

               }

		    break;	

		    } 

		default :

			{

			break;	

			}  

	    }

   	return error;

    }

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

// CIcpServiceManager::GetConnectionParameter

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

//

void CIcpServiceManager::GetConnectionParameterL(TUint aServiceId,

                         				TCCHSubserviceType aSubServiceType,  

                                        TCchConnectionParameter aParameter,

                                        RBuf& aValue  ) const

    {

    ICPLOGSTRING3( "CIcpServiceManager::GetConnectionParameterL service:%i type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    TInt error = KErrBadHandle;

     switch( aParameter )

	    {

	   	case ECchUsername:

		    {

    	    TInt settingsId = GetSPSettingsIntPropertyL(aServiceId, ESubPropertyIMSettingsId);

       		TRAP(error,iXmppParameters->GetParamL((TUint32)settingsId, 

       											XmppParams::KXmppParamUsername(), aValue ));

		    break;	

		    }

	   	case ECchPassword:

            {

            TInt settingsId = GetSPSettingsIntPropertyL(aServiceId, ESubPropertyIMSettingsId);       		

            //get the owndata from settingsapi

            TRAP(error,iXmppParameters->GetParamL((TUint32)settingsId, 

            									XmppParams::KXmppParamPassword(), aValue ));

            break;  

            }

		default :

			{

			break;	

			}  

	    }

    }

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

// CIcpPlugin::SetConnectionParameter

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

//

TInt CIcpServiceManager::SetConnectionParameter( TUint aServiceId,

                        					TCCHSubserviceType aSubServiceType,  

                                            TCchConnectionParameter aParameter,

                                            TInt aValue )

    {

    ICPLOGSTRING3( "CIcpServiceManager::SetConnectionParameter service:%i type:%i", aServiceId, aSubServiceType );

    __ASSERT_DEBUG( ValidateSubService(aSubServiceType), User::Panic( KNullDesC, KErrNotFound ) );    

    __ASSERT_DEBUG( aServiceId > 0, User::Panic( KNullDesC, KErrNotFound ) );

    TInt error = KErrBadHandle;

	 switch( aParameter )

	    {

	  	case ECchIapId:

		    {

		    iIapId = aValue ;

		    error = KErrNone;

		    break;	

		    }

		case ECchSnapId:

		    {

		    iSnapId = aValue ;

		    error = KErrNone;

		    break;	

		    }

	   default :

			{

			break;