// Copyright (c) 2007-2009 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:
// Name        : sipprofileitcreceiver
// Part of     : SIP Profile Client
// implementation
// Version     : 1.0
// INCLUDE FILES
//



#include <s32mem.h>
#include <eikenv.h>

#include "SIPProfileITCReceiver.h"
#include "SIPRemoteProfile.h"
#include "sipconcreteprofile.h"
#include "sipconcreteprofileobserver.h"
#include "sipprofileslots.h"
#include "sipprofilealrobserver.h"

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

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSIPProfileITCReceiver* CSIPProfileITCReceiver::NewL(
	RSIPProfile& aSipProfile, MSIPConcreteProfileObserver& aObserver)
	{
    CSIPProfileITCReceiver* self = 
		CSIPProfileITCReceiver::NewLC(aSipProfile, aObserver);
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSIPProfileITCReceiver* CSIPProfileITCReceiver::NewLC(
	RSIPProfile& aSipProfile, MSIPConcreteProfileObserver& aObserver)
	{
	CSIPProfileITCReceiver* self = new (ELeave)
		CSIPProfileITCReceiver(aSipProfile, aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::CSIPProfileITCReceiver
// -----------------------------------------------------------------------------
//
CSIPProfileITCReceiver::CSIPProfileITCReceiver(
	RSIPProfile& aSipProfile, MSIPConcreteProfileObserver& aObserver) 
	: CActive(EPriorityStandard),
	iSip(aSipProfile),
	iObserver(aObserver)
	{
    CActiveScheduler::Add(this);
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::ConstructL()
	{
    iITCMsgArgs.Set(ESipProfileItcArgSlots, &iIdsPckg);
	Receive();
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::~CSIPProfileITCReceiver
// -----------------------------------------------------------------------------
//
CSIPProfileITCReceiver::~CSIPProfileITCReceiver() 
	{
	CActive::Cancel();
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::Receive
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::Receive()
	{
	if (!IsActive())
		{
    	iSip.Receive(iITCMsgArgs, iStatus);
		SetActive();
		}
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::RunL
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::RunL()
	{
	TInt err = iStatus.Int();
	TSIPProfileSlots ids = iIdsPckg();
	
	if (err == KErrServerTerminated)
		{
		User::LeaveIfError(iSip.Connect());
		}

	Receive();

	if (err == KErrNone)
		{
		IncomingEventL(ids);
		}
	else
		{
		ErrorOccuredL(err,ids);
		}
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::RunError
// -----------------------------------------------------------------------------
//
TInt CSIPProfileITCReceiver::RunError(TInt aError)
	{
	if (aError == KErrServerTerminated)
		{
		// to avoid infinite loop
		return aError;
		}
	Receive();
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::DoCancel
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::DoCancel()
	{
    iSip.CancelReceive();
	}
	
// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::IncomingEventL
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::IncomingEventL(TSIPProfileSlots& aIds)
    {
	switch (aIds.iEventId)
		{
		case ESipProfileItcOpRegistered:
			iObserver.RegistrationStatusChangedL(
				aIds.iProfileId, 
				CSIPConcreteProfile::ERegistered, 
				aIds.iSlot1);
			break;
		case ESipProfileItcOpRegistrationError:
			iObserver.ErrorOccurredL(
				aIds.iProfileId,
				CSIPConcreteProfile::ERegistrationInProgress, 
				aIds.iSlot1);
			break;
		case ESipProfileItcOpUnregistrationError:
			iObserver.ErrorOccurredL(
				aIds.iProfileId, 
				CSIPConcreteProfile::EUnregistrationInProgress, 
				aIds.iSlot1);
			break;
		case ESipProfileItcOpDeregistered:
			iObserver.RegistrationStatusChangedL(
				aIds.iProfileId, 
				CSIPConcreteProfile::EUnregistered, 
				0);
			break;
		case ESipProfileItcOpProfileAdded:
		case ESipProfileItcOpProfileAddedDefault:
			iObserver.AddedL(aIds.iProfileId);
			break;
		case ESipProfileItcOpProfileUpdated:
			iObserver.UpdatedL(aIds.iProfileId, aIds.iSlot1);
			break;
		case ESipProfileItcOpProfileRemoved:
			iObserver.RemovedL(aIds.iProfileId);
			break;
		case ESipProfileItcOpIapAvailable:
			if (iALRObserver)
				{
				iALRObserver->AlrEvent(
					MSipProfileAlrObserver::EIapAvailable, 
					aIds.iProfileId,
					aIds.iSlot1, 
					aIds.iSlot2);
				}
			break;
		case ESipProfileItcOpMigrationStarted:
			if (iALRObserver)
				{
				iALRObserver->AlrEvent(
					MSipProfileAlrObserver::EMigrationStarted, 
					aIds.iProfileId,
					aIds.iSlot1, 
					aIds.iSlot2);
				}
			break; 
		case ESipProfileItcOpMigrationCompleted:
			if (iALRObserver)
				{
				iALRObserver->AlrEvent(
					MSipProfileAlrObserver::EMigrationCompleted, 
					aIds.iProfileId,
					aIds.iSlot1, 
					aIds.iSlot2);
				}
			break;
		case ESipProfileItcOpALRError:
			if (iALRObserver)
				{
				iALRObserver->AlrError(
					aIds.iError, 
					aIds.iProfileId,
					aIds.iSlot1,
					aIds.iSlot2);
				}
			break;
		case ESipProfileItcOpProfileForciblyDisabled:
			{
			iObserver.RegistrationStatusChangedL(
				aIds.iProfileId, 
				CSIPConcreteProfile::EUnregistered, 
				aIds.iEventId);
			break;
			}
		default:
			User::Leave(KErrNotSupported);
		}
	}

// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::ErrorOccuredL
// -----------------------------------------------------------------------------
//
void CSIPProfileITCReceiver::ErrorOccuredL(TInt aError, TSIPProfileSlots& aIds)
	{
	iObserver.ErrorOccurredL(aIds.iProfileId, 
							 CSIPConcreteProfile::ERegistrationInProgress, 
							 aError);
	}
	
// -----------------------------------------------------------------------------
// CSIPProfileITCReceiver::SetALRObserver
// -----------------------------------------------------------------------------
//
TInt
CSIPProfileITCReceiver::SetALRObserver(MSipProfileAlrObserver* aALRObserver)
	{
	if (aALRObserver && iALRObserver)
		{
		return KErrAlreadyExists;
		}
	iALRObserver = aALRObserver;
	return KErrNone;
	}