/*

* 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 handling the use of Cch - All CCH Events go thro this class

*

*/

// INCLUDE FILES

#include <e32def.h>

#include <cchserver.h>

#include <cchclient.h>

#include "cvimpstenginecchhandler.h"

#include "tvimpstconsts.h"

#include "f32file.h"

// CONSTANTS

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

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

// CVIMPSTEngineCchHandler::CVIMPSTEngineCchHandler

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

// 

CVIMPSTEngineCchHandler::CVIMPSTEngineCchHandler(TUint aServiceId, MVIMPSTEngineCchUiEventObserver& aCchUiEventObserver)

: iServiceId(aServiceId),iCchUiEventObserver(aCchUiEventObserver)

    {        

    }

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

// CVIMPSTEngineCchHandler::ConstructL

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

// 

void CVIMPSTEngineCchHandler::ConstructL(  )

    {

     // Create service selection here

	 iCchClient = CCch::NewL();

	 iSettingsStore = CVIMPSTSettingsStore::NewL();

	if (iCchClient)

		{		

		if( service )

			{

			}

		}

	//Configure CCHUI notes

	MCchUi& cchUiApi = iCchClient->CchUiApi();

	// Set observer to listen cchui events for change connection.

    cchUiApi.AddObserverL( *this );  // parameter is MCchUiObserver

	// 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 );

	allowedSubServices.AppendL( ECCHUnknown );

	allowedSubServices.AppendL( ECCHVoIPSub );

	allowedSubServices.AppendL( ECCHIMSub );

	allowedSubServices.AppendL( ECCHPresenceSub );

	cchUiApi.ConfigureVisualizationL( 

				allowedNotes, allowedSubServices );

	CleanupStack::PopAndDestroy( &allowedSubServices );

	CleanupStack::PopAndDestroy( &allowedNotes );

    }

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

// CVIMPSTEngineCchHandler::NewL

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

// 

CVIMPSTEngineCchHandler* CVIMPSTEngineCchHandler::NewL(TUint aServiceId,

        MVIMPSTEngineCchUiEventObserver& aCchUiEventObserver )

        {

    CVIMPSTEngineCchHandler* self = NewLC(aServiceId, aCchUiEventObserver );

    CleanupStack::Pop(self);

    return self;

    }

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

// CVIMPSTEngineCchHandler::NewLC

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

// 

CVIMPSTEngineCchHandler* CVIMPSTEngineCchHandler::NewLC(TUint aServiceId ,MVIMPSTEngineCchUiEventObserver& aCchUiEventObserver)

    {

    CVIMPSTEngineCchHandler* self =

        new (ELeave) CVIMPSTEngineCchHandler(aServiceId, aCchUiEventObserver);

    CleanupStack::PushL(self);

    self->ConstructL( );

    return self;

    }

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

// CVIMPSTEngineCchHandler::~CVIMPSTEngineCchHandler

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

// 

CVIMPSTEngineCchHandler::~CVIMPSTEngineCchHandler()

    {

    if(iCchClient)

    	{

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

    	if( service )

			{

			service->RemoveObserver();

			}

    	}

    delete iCchClient; 

    delete iSettingsStore;

    iObserverStructure.Reset();

    iObserverStructure.Close();

    }

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

// CVIMPSTEngineCchHandler::ShutdownCch

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

//

//TODO: not used any where.. need to be removed.

void CVIMPSTEngineCchHandler::ShutdownCch()

    {

    if ( iCchClient )

        {        

        delete iCchClient;

        iCchClient = NULL;

        }

    }    

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

// CVIMPSTEngineCchHandler::GetServiceState

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

// 

TInt CVIMPSTEngineCchHandler::GetServiceState(TUint aServiceId,

									TInt aSubServiceType, 

									TCCHSubserviceState& aCCHState

									)

    {

   	TInt err = KErrNotFound;

   	if ( iCchClient )

	   	{

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

	   	TCchServiceStatus status;

		status.SetState(ECCHUninitialized);

		if( service )

			{

			// Get status from the client

			err = service->GetStatus( TCCHSubserviceType(aSubServiceType), status );

			if (KErrNone == err)

				{

				aCCHState = status.State();	

				}

			}		

	   	}

    return err;   	

    }

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

// CVIMPSTEngineCchHandler::EnableService

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

// 

TInt CVIMPSTEngineCchHandler::EnableService()

    {

    TInt error = KErrNotFound;

    if ( iCchClient )

	    {

	    iCchClient->SetConnectivityDialogsAllowed( ETrue );

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

		if( service )

			{

			error = service->Enable( ECCHUnknown );		

			}

	    }

	return error;

    }

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

// CVIMPSTEngineCchHandler::DisableService

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

// 

TInt CVIMPSTEngineCchHandler::DisableService()

    {

	TInt error = KErrNotFound;

	if(iCchClient)

		{

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

	    if( service )

			{

			error = service->Disable( ECCHUnknown );

			}		

		}

    return error;

    }

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

// CVIMPSTEngineCchHandler::ServiceStatusChanged

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

//

void CVIMPSTEngineCchHandler::ServiceStatusChanged(

				TInt aServiceId,

				const TCCHSubserviceType aType,

				const TCchServiceStatus& aServiceStatus )

    {

    // Disable the service only if the login to one of the subservices fails

    // 1.ECCHVoIPSub

    // 2.ECCHPresenceSub

    // 3.ECCHIMSub

    if( aServiceStatus.Error() == KCCHErrorLoginFailed &&

            (ECCHVoIPSub == aType ||

             ECCHPresenceSub == aType ||

             ECCHIMSub == aType))

        {

        DisableService();

        }

    if((aServiceStatus.Error() == KCCHErrorAuthenticationFailed )||(aServiceStatus.Error() == KCCHErrorLoginFailed))

        {

        TInt loginfailed = 0;

        TRAP_IGNORE( iSettingsStore->SetL(iServiceId ,EServiceSuccessfullLogin ,loginfailed) );  

        }

    TInt count  = iObserverStructure.Count();

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

        {

        if(aType == iObserverStructure[i].iSubserviceType )

            {

            TRAP_IGNORE(iObserverStructure[i].iObserver->CchEventOccuredL( 

                    aServiceId, 

                    aServiceStatus.State(),

                    aServiceStatus.Error() ));

            }

        }

    }

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

// CVIMPSTEngineCchHandler::RegisterCchObserverL

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

// 

void CVIMPSTEngineCchHandler::RegisterCchObserverL(MVIMPSTEngineCchHandlerObserver* aObserver,

                                                   TCCHSubserviceType aSubServiceType )

    {

    if(aObserver)

    	{

    	 TObserverStructure obsstruct;

	     obsstruct.iObserver = aObserver;

	     obsstruct.iSubserviceType = aSubServiceType;

	     iObserverStructure.Append(obsstruct);

    	}

    }    

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

// CVIMPSTEngineCchHandler::UnRegisterCchObserver

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

// 

void CVIMPSTEngineCchHandler::UnRegisterCchObserver(TCCHSubserviceType aSubServiceType )

    {

    TInt count  = iObserverStructure.Count();

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

    	{

    	if(aSubServiceType == iObserverStructure[i].iSubserviceType)

    		{

    		iObserverStructure[i].iObserver = NULL;

    		iObserverStructure.Remove(i);

    		iObserverStructure.Compress();

    		break;

    		}

    	}

    }    

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

// CVIMPSTEngineCchHandler::GetConParametersL

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

// 

HBufC* CVIMPSTEngineCchHandler::GetConParametersL(			

		    TCchConnectionParameter aConnParam )

    {

    HBufC* temp = NULL;

    TInt error = KErrNotFound;

    if(iCchClient)  

	    {

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

		if( service )

		   {              

		   RBuf buffer;

	       CleanupClosePushL( buffer );

		   buffer.CreateL(KVIMPSTUISPSMaxPropertyLength);

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

		   User::LeaveIfError( error);

		   //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 );

		   }

	    }

    return temp;

    }

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

// Set cch connection parameter.

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

//

TInt CVIMPSTEngineCchHandler::SetConnectionParameter(     

    TCchConnectionParameter aConnParam,

    const TDesC& aConnParamValue )

    {

    TInt error = KErrNotFound;

    if(iCchClient)

        {

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

        if (service)

	        {

	        error =  service->SetConnectionParameter( 

	                  ECCHUnknown, aConnParam, aConnParamValue );

	        }

        }    

    return error;

    }

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

// CVIMPSTEngineCchHandler::ChangeConnectionL

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

//

TInt CVIMPSTEngineCchHandler::ChangeConnectionL()

    {

    TInt err = KErrNone;

    if (iCchClient)

	    {

	    MCchUi& cchUiApi = iCchClient->CchUiApi();

		TRAP(err, cchUiApi.ShowDialogL(iServiceId, 

						MCchUiObserver::ECchUiDialogTypeChangeConnection););

	    }

    return err;    

    } 

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

// CchUiApi

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

//

MCchUi& CVIMPSTEngineCchHandler::CchUiApi() const

	{

	return iCchClient->CchUiApi();	

	}

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

// CVIMPSTEngineCchHandler::IsPasswordAvailableL

//  To check whether password available in settings or not

//  Returns true if password is present in the settings else returns false    

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

//

TBool CVIMPSTEngineCchHandler::IsPasswordAvailable(TCchConnectionParameter aConnParam )

    {

    TInt passwordSet = EFalse;

    if(iCchClient)  

        {

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

        if( service )

            {              

            service->GetConnectionParameter( ECCHUnknown,aConnParam,passwordSet );

            }

        }

    return passwordSet;

    }

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

// CVIMPSTEngineCchHandler::ConnectivityDialogsCompletedL

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

//

void CVIMPSTEngineCchHandler::ConnectivityDialogsCompletedL(

        TInt aServiceId, MCchUiObserver::TCchUiOperationResult aOperationResult )

    { 

    if((iServiceId == aServiceId)&&(aOperationResult == ECchUiClientOperationResultConnectionChanged))

        {

        iCchUiEventObserver.HandleChangeConnectionEventL();

        }

    }

// End of file