/*

* 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 for cch service handling

 *                

 *

*/

#include "cservicewidgetcchhandler.h"

#include "cservicewidgetcontentpublisher.h"

#include "mservicewidgetobservers.h"

#include "servicewidgetcpglobals.h"

#include "swpdebugtrace.h"

#include <spsettings.h> 

#include <spentry.h>

#include <spproperty.h>

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

// CServiceWidgetCchHandler::CServiceWidgetCchHandler

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

// 

CServiceWidgetCchHandler::CServiceWidgetCchHandler(TUint32 aServiceId, 

												   MServiceWidgetServiceStateObserver& aStateObserver ):

   iServiceId(aServiceId),

   iStateObserver( aStateObserver ),

   iServiceState( ESWSNotRegistered )

   {

   TRACE_SWP(TXT("CServiceWidgetCchHandler::CServiceWidgetCchHandler iServiceId %d"),iServiceId );

   }

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

// CServiceWidgetCchHandler::NewL

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

// 

CServiceWidgetCchHandler* CServiceWidgetCchHandler::NewL(TUint32 aServiceId, 

														 MServiceWidgetServiceStateObserver& aStateObserver  )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::NewL() start") );

    CServiceWidgetCchHandler* self = NewLC(aServiceId, aStateObserver);

    CleanupStack::Pop(self);

    TRACE_SWP(TXT("CServiceWidgetCchHandler::NewL() end") );

    return self;

    }

// ---------------------------------------------------------------------------aOwnStatusKey

// CServiceWidgetCchHandler::NewLC

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

// 

CServiceWidgetCchHandler* CServiceWidgetCchHandler::NewLC(TUint32 aServiceId,

														 MServiceWidgetServiceStateObserver& aStateObserver )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::NewLC() start") );

    CServiceWidgetCchHandler* self =

        new (ELeave) CServiceWidgetCchHandler(aServiceId, aStateObserver);

    CleanupStack::PushL(self);

    self->ConstructL( );

    TRACE_SWP(TXT("CServiceWidgetCchHandler::NewLC() end") );

    return self;

    }

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

// CServiceWidgetCchHandler::ConstructL

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

// 

void CServiceWidgetCchHandler::ConstructL()

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() start") );

	iCchClient = CCch::NewL();

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() iCchClient created") );

	CCchService* service = iCchClient->GetService( iServiceId );    

	if( service )

		{

		service->AddObserver( *this );      

		}

	//Configure CCHUI notes

	MCchUi& cchui = iCchClient->CchUiApi();

	// Configure CCHUI API to show all notes/dialogs except connecting note.

	// Also configure that only VoIP and IM subservices are allowed (notes are

	// shown only for those).

	RArray<MCchUiObserver::TCchUiDialogType> allowedNotes;

	RArray<TCCHSubserviceType> allowedSubServices;

	CleanupClosePushL( allowedNotes );

	CleanupClosePushL( allowedSubServices );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeUsernamePasswordFailed );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeAuthenticationFailed );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeNoConnectionDefined );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeNoConnectionAvailable );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeConfirmChangeConnection );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeChangeConnection );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeDefectiveSettings );

	allowedNotes.AppendL( MCchUiObserver::ECchUiDialogTypeErrorInConnection );  

	allowedSubServices.AppendL( ECCHVoIPSub );

	allowedSubServices.AppendL( ECCHIMSub );

	allowedSubServices.AppendL( ECCHPresenceSub );

	cchui.ConfigureVisualizationL( 

			allowedNotes, allowedSubServices );

	CleanupStack::PopAndDestroy( &allowedSubServices );

	CleanupStack::PopAndDestroy( &allowedNotes );

	ReadSupportedSubServices();

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ConstructL() end") );

	}

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

// CServiceWidgetCchHandler::~CServiceWidgetCchHandler

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

// 

CServiceWidgetCchHandler::~CServiceWidgetCchHandler()

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::~CServiceWidgetCchHandler() start") );

	if(iCchClient)

		{

		CCchService* service = iCchClient->GetService( iServiceId );

		if( service )

		    {

		    service->RemoveObserver(*this);

		    }

		delete iCchClient; 

		}

	iSupportedSubServices.Reset();

	delete iServiceName;

	delete iOwnData;

	TRACE_SWP(TXT("CServiceWidgetCchHandler::~CServiceWidgetCchHandler() end") );

	}

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

// CServiceWidgetCchHandler::ReadSupportedSubServices

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

//

 void CServiceWidgetCchHandler::ReadSupportedSubServices()

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ReadSupportedSubServices() start") );

	iSupportedSubServices.Reset();

	TSubServiceState subService;

	TBool supported = IsServiceSupported( ECCHIMSub );

	if( supported )

		{

		// im sub service supported

		subService.iSubServiceType = ECCHIMSub;

		subService.iSubServiceState = GetServiceState( ECCHIMSub );

		iSupportedSubServices.Append( subService );	

		}

	supported = IsServiceSupported( ECCHPresenceSub );

	if( supported )

		{

		// presence sub service supported

		subService.iSubServiceType = ECCHPresenceSub;

		subService.iSubServiceState = GetServiceState( ECCHPresenceSub );

		iSupportedSubServices.Append( subService );	

		}

	supported = IsServiceSupported( ECCHVoIPSub );

	if( supported )

		{

		// voip sub service supported

		subService.iSubServiceType = ECCHVoIPSub;

		subService.iSubServiceState = GetServiceState( ECCHVoIPSub );

		iSupportedSubServices.Append( subService );	

		}

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ReadSupportedSubServices() end") );

	}

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

// CServiceWidgetCchHandler::ServiceStatusChanged

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

//

void CServiceWidgetCchHandler::ServiceStatusChanged(

                TInt  aServiceId,

                const TCCHSubserviceType aType,

                const TCchServiceStatus& aServiceStatus )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() start") );

    if( aServiceId != iServiceId )

	    {

	    return;

	    }

	TCCHSubserviceState state = aServiceStatus.State();

    TInt subServiceCount = iSupportedSubServices.Count();

    TInt error = aServiceStatus.Error();

    for(TInt i=0; i< subServiceCount; i++)

	    {

	    TSubServiceState subService = iSupportedSubServices[ i ]; 

	    if( subService.iSubServiceType == aType )

			{

			// sub service is matched ,supported

			// check for ALR state if supported ,service may go to waiting state

			if( error && (error != KCCHErrorInvalidSettings )  && 

				( ECCHConnecting == state ) )

				{

				// waiting state

				iSupportedSubServices[ i ].iSubServiceState = ESWSWaitingForNetwork;	

				}

			else

				{

				TSWSTRegistrationState swState = GetLocalServiceState( state );

				if( swState == ESWSRegistered && aType == ECCHPresenceSub )

					{

					// in case of presence subservice ,need to fetch the contact ,so

					// move to updating state

					iSupportedSubServices[ i ].iSubServiceState = ESWSUpdatingContacts;	

					}

				else

					{

					// store the subservice state

					iSupportedSubServices[ i ].iSubServiceState = swState;		

					}

				}

			break; // break the loop if subservice matched	

			}

		}

	TSWSTRegistrationState previousState = iServiceState;

	// get best match state

	iServiceState  = ParseGetServiceState();

    if( iServiceState != previousState )

		{

		// inform the observer only if state changed

		TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() state changed") );

		// some times give the same state call back more than one

		TRAP_IGNORE( iStateObserver.HandleServiceStatusChangedL( iServiceState  ) );	

		}

    TRACE_SWP(TXT("CServiceWidgetCchHandler::ServiceStatusChanged() end") );

    }

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

// CServiceWidgetCchHandler::ParseGetServiceState

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

//

TSWSTRegistrationState CServiceWidgetCchHandler::ParseGetServiceState()

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ParseGetServiceState() start") );

	TInt serviceState = 0;

	TInt subServiceCount = iSupportedSubServices.Count();

	//Find the cumulative of the ServiceStates of all subservices

	// iterate the service array

	for ( TInt index = 0; index < subServiceCount ; index++ )        

		{	

		serviceState |= iSupportedSubServices[index].iSubServiceState;

		}

	TSWSTRegistrationState swState = ESWSNotRegistered;

	//The logic below is that, if any one subservice not enabled for us the service is not enabled

	//So to do this we assign priority for each service state

	//Connecting gets the High Priority, when copmared to Waiting for Connection,

	//Disconnecting, Registered, UnRegistered.

	//By this way the Sevice Tab will be more usable and atleast we can perform operations

	//related to the the logged in subservice

	//its upto the connection handlers to do the job properly, whether to provide connectivity to all

	//sub services or not.. 

	//Start parsing and decide the state of the ServiceTab   

	if ( serviceState & ESWSNetworkConnecting )

		{

		//Connecting	

		swState = ESWSNetworkConnecting;

		}

	else if ( serviceState & ESWSWaitingForNetwork )

		{

		//Waiting for Connection	

		swState = ESWSWaitingForNetwork;

		}

	else if ( serviceState & ESWSUpdatingContacts )

		{

		//Waiting for Connection	

		swState = ESWSUpdatingContacts;

		}	    	    

	else if ( serviceState & ESWSNetworkDisConnecting )

		{

		//disconnecting	

		swState = ESWSNetworkDisConnecting;

		}   

	else if ( serviceState & ESWSRegistered ) 

		{

		//Enabled	

		swState = ESWSRegistered;

		}

	TRACE_SWP(TXT("CServiceWidgetCchHandler::ParseGetServiceState() end") );

	return swState;   	

	}

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

// CServiceWidgetCchHandler::GetServiceState

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

// 

TSWSTRegistrationState CServiceWidgetCchHandler::GetServiceState( TCCHSubserviceType aServiceType )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::GetServiceState() start") );

    CCchService* service = iCchClient->GetService( iServiceId );

   	TCchServiceStatus status;

	status.SetState(ECCHUninitialized);

	if( service )

		{

		// Get status from the client

	    service->GetStatus(  aServiceType , status );

		}		

	TRACE_SWP(TXT("CServiceWidgetCchHandler::GetServiceState() end") );

    return GetLocalServiceState( status.State() );

    }

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

// CServiceWidgetCchHandler::GetLocalServiceState

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

// 

TSWSTRegistrationState CServiceWidgetCchHandler::GetLocalServiceState(TCCHSubserviceState aState )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::GetLocalServiceState() start") );

    TSWSTRegistrationState mappedState = ESWSNotRegistered;

	if( ECCHConnecting == aState )

		{

		mappedState = ESWSNetworkConnecting;	

		}

	else if( ECCHDisconnecting == aState )

		{

		mappedState = ESWSNetworkDisConnecting;	

		}

	else if( ECCHDisabled == aState )

		{

		mappedState = ESWSNotRegistered;	

		}

	else if( ECCHEnabled == aState )

		{

		mappedState = ESWSRegistered;	

		}

	TRACE_SWP(TXT("CServiceWidgetCchHandler::GetLocalServiceState() end") );

   	return mappedState;

    }

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

// CServiceWidgetCchHandler::OwnUserIdL

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

// 

const TDesC& CServiceWidgetCchHandler::OwnUserIdL()

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() start") );	

    if( iOwnData )

		{

		delete iOwnData;

		iOwnData = NULL;	

		}

   // call back can not be modified ignore the error

	iOwnData = GetConParametersL( ECchUsername );

	if( iOwnData )

	    {

	    TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() valid") );

	    TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() end") );	

	   	return *iOwnData;	

	    }

	TRACE_SWP(TXT("CServiceWidgetCchHandler::OwnUserIdL() end") );	

    return KNullDesC ;

    }  

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

// CServiceWidgetCchHandler::XimpAdaptationUidL()

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

//

TInt CServiceWidgetCchHandler::XimpAdaptationUidL()

    {

	TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() start") );

    TInt ret = KErrNotFound;

    CSPSettings* settings = CSPSettings::NewLC(); 

    CSPProperty* property = CSPProperty::NewLC();

    TInt err = settings->FindPropertyL( iServiceId,

                                EPropertyPCSPluginId,

                                *property );    

    if (KErrNone == err)

	    {

	    TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() uid read") );

	    property->GetValue( ret );

	    }

    CleanupStack::PopAndDestroy(2);// property ,settings

    TRACE_SWP(TXT("CServiceWidgetCchHandler::XimpAdaptationUidL() end") );

    return ret;

    }        

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

// CServiceWidgetCchHandler::GetConParametersL

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

// 

HBufC* CServiceWidgetCchHandler::GetConParametersL( TCchConnectionParameter aConnParam )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() start") );

    HBufC* temp = NULL;

    TInt error = KErrNotFound;

    if(iCchClient)  

	    {

		CCchService* service = iCchClient->GetService( iServiceId );    

		if( service )

		   {              

		   RBuf buffer;

	       CleanupClosePushL( buffer );

		   buffer.CreateL(KIMW_MAX_LENGTH);

		   error = service->GetConnectionParameter(ECCHUnknown,aConnParam,buffer);

		   User::LeaveIfError( error);

		   if( buffer.Length() > 0)

		      {

		      TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() buffer valid") );

              //extract only the user id in case

		      // Check for prefix and remove if found

              TInt prefixLocation = buffer.Locate( ':' );

              if ( KErrNotFound != prefixLocation  && ECchUsername == aConnParam )

                  {

                  temp = buffer.Mid(prefixLocation+1 ).AllocL(); // ownership transferred  

                  }

              else

                  {

                  temp = buffer.AllocL(); // ownership transferred  

                  }

		      }

		   CleanupStack::PopAndDestroy( &buffer );

		   }

	    }

	TRACE_SWP(TXT("CServiceWidgetCchHandler::GetConParametersL() end") );

    return temp;

    }

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

// CServiceWidgetCchHandler::IsServiceSupported

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

// 

TBool CServiceWidgetCchHandler::IsServiceSupported(TCCHSubserviceType aSubServiceType )

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::IsServiceSupported() start") );

	TBool ret = EFalse;

   	if ( iCchClient )

	   	{

	   	CCchService* service = iCchClient->GetService( iServiceId );

		if( service )

			{

			service->IsSupported(aSubServiceType, ret );

			}		

	   	}

	TRACE_SWP(TXT("CServiceWidgetCchHandler::IsServiceSupported() end") );

 	return ret;   	

 	}

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

// CServiceWidgetCchHandler::IsSubServiceSupported

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

// 

TBool CServiceWidgetCchHandler::IsSubServiceSupported(TCCHSubserviceType aSubServiceType )

	{

	TRACE_SWP(TXT("CServiceWidgetCchHandler::IsSubServiceSupported() start") );

	TBool ret = EFalse;

   	TInt subServiceCount = iSupportedSubServices.Count();

	//Find the cumulative of the ServiceStates of all subservices

	// iterate the service array

	for ( TInt index = 0; index < subServiceCount ; index++ )        

		{	

		if( iSupportedSubServices[index].iSubServiceType == aSubServiceType )

			{

			ret = ETrue;

			break;	

			}

		}

	TRACE_SWP(TXT("CServiceWidgetCchHandler::IsSubServiceSupported() end") );

 	return ret;   	

 	}   

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

// CServiceWidgetCchHandler::GetServiceViewIdL

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

// 

TInt CServiceWidgetCchHandler::GetServiceViewIdL( TInt& aTabUid )

    {

    TInt serviceviewId = 0 ;

    if( iServiceId != KErrNotFound)

        {

        CSPSettings* spSettings = CSPSettings::NewL();

        CleanupStack::PushL(spSettings);

        //get the tabview id from settings

        CSPProperty* property = CSPProperty::NewLC();

        spSettings->FindPropertyL( iServiceId,

                EPropertyContactViewId,

                *property );    

        property->GetValue(serviceviewId);

        //get the tab uid from settings

        spSettings->FindPropertyL( iServiceId,

                EPropertyContactViewPluginId,

                *property );    

        property->GetValue(aTabUid);

        CleanupStack::PopAndDestroy( property );  

        CleanupStack::PopAndDestroy( spSettings );

        }

    return serviceviewId;

    }

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

// CServiceWidgetCchHandler::EnableServiceL

// 

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

//

TInt CServiceWidgetCchHandler::EnableServiceL( )

    {

    TRACE_SWP(TXT("CServiceWidgetCchHandler::EnableServiceL() start") );

    TInt error = KErrNotFound;

    if( iCchClient  )

        {

		iCchClient->SetConnectivityDialogsAllowed( ETrue );

        CCchService* service = iCchClient->GetService( iServiceId );

        if( service )

            {

            error = service->Enable( ECCHUnknown );

            }

        }

    return error;

    }

 // end of file