/*

* Copyright (c) 2002-2005 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:  Symbian OS Server source.

*

*/

#include <s32mem.h>

#include <ecom.h>

#include <implementationinformation.h>

//#include <syncmlnotifier.h>

#include <e32property.h>

#include <DevManInternalCRKeys.h>

#include <centralrepository.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldsconstants.h>

#include "nsmlsosserver.h"

#include "nsmltransport.h"

#include "nsmlsosthread.h"

#include "nsmlprivatepskeys.h"

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

// CNSmlSOSHandler* CNSmlSOSHandler::NewL()

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

//

CNSmlSOSHandler* CNSmlSOSHandler::NewL()

    {

	CNSmlSOSHandler* self= new (ELeave) CNSmlSOSHandler();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;    

    }

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

// void CNSmlSOSHandler::ConstructL()

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

//

void CNSmlSOSHandler::ConstructL()

    {

    iMsgQueue = CNSmlMessageQueue::NewL(this);

    iContactSuiteObserverProfileId = 0;

    }

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

// CNSmlSOSHandler::CNSmlSOSHandler()

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

//

CNSmlSOSHandler::CNSmlSOSHandler() : CActive(EPriorityStandard), iSessionCount(0)

    {     

    CActiveScheduler::Add(this);

    }

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

// CNSmlSOSHandler::~CNSmlSOSHandler()

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

//

CNSmlSOSHandler::~CNSmlSOSHandler()

    {

    Cancel();

    delete iMsgQueue;

    delete iParams;

    delete iThreadObserver;

    iProfileLocks.Close();

    iSessionLib.Close();

    iEventMsgs.Close();

    iProgressMsgs.Close();

	iContactSuiteProgressMsgs.Close();

    iWrtStream.Close();

    }

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

// void CNSmlSOSHandler::LockProfile( const TInt aProfId )

// Adds profile to the array of locked profiles.

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

//

void CNSmlSOSHandler::LockProfile( const TInt aProfId )

    {

    iProfileLocks.Append( aProfId );

    }

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

// void CNSmlSOSHandler::RemoveLock( const TInt aProfId )

// Removes lock from profile.

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

//

void CNSmlSOSHandler::RemoveLock( const TInt aProfId )

    {

    TInt index = iProfileLocks.Find( aProfId );

    if ( index != KErrNotFound )

        {

        iProfileLocks.Remove(index);

        }

    }

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

// TBool CNSmlSOSHandler::IsLocked( const TInt aProfId )

// Checks whether profile is locked or not.

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

//

TBool CNSmlSOSHandler::IsLocked( const TInt aProfId )

    {

    if ( iProfileLocks.Find( aProfId ) != KErrNotFound )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// TInt CNSmlSOSHandler::AddJobL( CNSmlJob* aJob, TInt& aJobId )

// Adds a created job to the job queue.

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

//

TInt CNSmlSOSHandler::AddJobL( CNSmlJob* aJob, TInt& aJobId )

    {

    aJobId = CreateJobId();

    aJob->SetJobId( aJobId );

    if ( !iCurrentJob )

        {

        iCurrentJob = aJob;

        if ( iCurrentJob->UsageType() == ESmlDataSync )

            {

            StartDSSyncL();

            }

        else

            {

            StartDMSyncL();

            }

        }

    else

        {

        if ( SearchSimilarJobs( aJob ) )

            {

            delete aJob;

            aJob = NULL;

            return KErrAlreadyExists;

            }

        CNSmlJob* tempJob = iCurrentJob;

        while ( tempJob->iNext )

            {            

            tempJob = tempJob->iNext;

            }

        tempJob->iNext = aJob;    

        }

    return KErrNone;

    }

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

// CNSmlJob* CNSmlSOSHandler::FindJob( TInt aJobId )

// Finds job from queue.

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

//

CNSmlJob* CNSmlSOSHandler::FindJob( TInt aJobId )

    {

    if ( iCurrentJob )

        {

        CNSmlJob* job = iCurrentJob;

        if ( job->JobId() == aJobId )

            {

            return iCurrentJob; 

            }

        while ( job->iNext )

            {

            job = job->iNext;

            if ( job->JobId() == aJobId )

                {

                return job;

                }

            }

        }

    return NULL;   

    }

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

// TInt CNSmlSOSHandler::CreateJobId()

// Creates an id to the new job.

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

//

TInt CNSmlSOSHandler::CreateJobId()

    {

    return iJobIndex++;

    }

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

// TInt CNSmlSOSHandler::StopJob( const TInt aJobId, const TInt aCreatorId )

// Removes job from queue or cancels the job if currently running.

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

//

TInt CNSmlSOSHandler::StopJob( const TInt aJobId, const TInt aCreatorId )

    {

    if ( !iCurrentJob )

        {

        return KErrNotFound;

        }

    if ( iCurrentJob->JobId() == aJobId )

        {

        if ( iCurrentJob->CreatorId() != aCreatorId )

            {

            return KErrPermissionDenied;

            }

        else

            {

            if ( iCurrentJob->UsageType() == ESmlDataSync )

                {

                CancelDSSync();

                }

            else

                {

                CancelDMSync();

                }           

            return KErrNone;

            }

        }

    else

        {

        CNSmlJob* tempJob = iCurrentJob;

        CNSmlJob* prevJob = iCurrentJob;

        while ( tempJob->iNext )

            {

            prevJob = tempJob;

            tempJob = tempJob->iNext;

            if ( tempJob->JobId() == aJobId )

                {

 				if ( tempJob->CreatorId() != aCreatorId )

                    {

                    return KErrPermissionDenied;

                    }

                else

                    {

                    CNSmlJob* nextJob = tempJob->iNext;

                    TRAP_IGNORE( CompleteEventMsgL( MSyncMLEventObserver::EJobStop, tempJob->JobId(), KErrNone ));  

                    delete tempJob;

                    prevJob->iNext = nextJob;

                    tempJob = nextJob;

                    return KErrNone;

                    }

                }            

            }

        }

    return KErrNotFound;

    }

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

// void CNSmlSOSHandler::CurrentJob( TInt& aId, TSmlUsageType& aType )

// Return the id and type of a job currently running.

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

//

void CNSmlSOSHandler::CurrentJob( TInt& aId, TSmlUsageType& aType )

    {

    if ( iCurrentJob )

        {

        aId = iCurrentJob->JobId();

        aType = iCurrentJob->UsageType();       

        }

    else    // No job running.

        {

        aId = KNSmlNullId;

        }

    }

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

// void CNSmlSOSHandler::QueuedJobsL( RArray<TInt>& aArray, const TSmlUsageType aType )

// Returns an array of ids of queued jobs of seleted type.

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

//

void CNSmlSOSHandler::QueuedJobsL( RArray<TInt>& aArray, const TSmlUsageType aType )

    {

    // Start from current job. If the usage type matches, append id to the array.

    if ( iCurrentJob )

        {

        CNSmlJob* job = iCurrentJob;

        if ( job->UsageType() == aType )

            {

            aArray.AppendL( job->JobId() );    

            }

        while ( job->iNext )

            {

            job = job->iNext;

            if ( job->UsageType() == aType )

                {

                aArray.AppendL( job->JobId() );    

                }

            }

        }

    }

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

// void CNSmlSOSHandler::AddProgressMsgL( const RMessage2& aMessage )

// Adds progress message to the message array.

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

//

void CNSmlSOSHandler::AddProgressMsgL( const RMessage2& aMessage )

    {

    iProgressMsgs.AppendL( aMessage );

    }

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

// void CNSmlSOSHandler::AddProgressMsgL( const RMessage2& aMessage )

// Adds progress message to the message array.

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

//

void CNSmlSOSHandler::AddContactSuiteProgressMsgL( const RMessage2& aMessage )

    {

        iContactSuiteProgressMsgs.AppendL( aMessage );

    }

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

// TBool CNSmlSOSHandler::CompleteBufProgressMsg( const TDesC8& aBuf, 

// const CNSmlSOSSession* aSession )

// Write data to the progress message and completes it.

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

//

TBool CNSmlSOSHandler::CompleteBufProgressMsg( 

const TDesC8& aBuf, 

const CNSmlSOSSession* aSession  )

    {

    _DBG_FILE("CNSmlSOSHandler::CompleteBufProgressMsg : Begin");

    TBool request( EFalse );    

    // Session info is stored to job and compared to session of the message.

    for( TInt i(0); i < iProgressMsgs.Count(); i++ )

        {

        if ( aSession == iProgressMsgs[i].Session() )

            {     

            _DBG_FILE("Owner session of job found. Progress completed.");    

            request = ETrue;

            iProgressMsgs[i].Write( 0, aBuf, 0 );

            iProgressMsgs[i].Complete( KErrNone );

            iProgressMsgs.Remove(i);        

            }

        }    

    _DBG_FILE("CNSmlSOSHandler::CompleteBufProgressMsg : End");    

    return request;     

    }

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

// TBool CNSmlSOSHandler::CompleteBufProgressMsg( const TDesC8& aBuf, 

// const CNSmlSOSSession* aSession )

// Write data to the progress message and completes it.

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

//

TBool CNSmlSOSHandler::CompleteBufContactSuiteProgressMsg( 

const TDesC8& aBuf, 

const CNSmlSOSSession* aSession  )

    {

    _DBG_FILE("CNSmlSOSHandler::CompleteBufProgressMsg : Begin");

    TBool request( EFalse );    

	    // Session info is stored to job and compared to session of the message.

    for( TInt i(0); i < iContactSuiteProgressMsgs.Count(); i++ )

        {

            request = ETrue;

		    if(!iContactSuiteProgressMsgs[i].IsNull())

                {

                iContactSuiteProgressMsgs[i].Write( 0, aBuf, 0 );

                iContactSuiteProgressMsgs[i].Complete( KErrNone );

                }

            iContactSuiteProgressMsgs.Remove(i);

        }    

    _DBG_FILE("CNSmlSOSHandler::CompleteBufProgressMsg : End");    

    return request;     

    }

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

// void CNSmlSOSHandler::CancelContactSuiteProgressMsg( const CNSmlSOSSession* aSession )

// Completes cancelled progress message and removes it from array.

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

//

void CNSmlSOSHandler::CancelContactSuiteProgressMsg( const CNSmlSOSSession* aSession )

    {

    for ( TInt i(0) ; i < iContactSuiteProgressMsgs.Count() ; i++ )

        {

        //if ( iContactSuiteProgressMsgs[i].Session() == aSession )

            {

            iContactSuiteProgressMsgs[i].Complete( KErrCancel );

            iContactSuiteProgressMsgs.Remove(i);

            }

        }

    }

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

// void CNSmlSOSHandler::CancelProgressMsg( const CNSmlSOSSession* aSession )

// Completes cancelled progress message and removes it from array.

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

//

void CNSmlSOSHandler::CancelProgressMsg( const CNSmlSOSSession* aSession )

    {

    for ( TInt i(0) ; i < iProgressMsgs.Count() ; i++ )

        {

        if ( iProgressMsgs[i].Session() == aSession )

            {

            iProgressMsgs[i].Complete( KErrCancel );

            iProgressMsgs.Remove(i);

            }

        }

    }

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

// void CNSmlSOSHandler::AddEventMsgL( const RMessage2& aMessagePtr )

// Adds event message to the message array.

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

//

void CNSmlSOSHandler::AddEventMsgL( const RMessage2& aMessagePtr )

    {

    iEventMsgs.AppendL( aMessagePtr );

    }

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

// void CNSmlSOSHandler::CompleteEventMsgL( MSyncMLEventObserver::TEvent aEvent, TInt aId, TInt aError, TInt aAdditional )

// Writes data to all event messages and completes them.

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

//

void CNSmlSOSHandler::CompleteEventMsgL( MSyncMLEventObserver::TEvent aEvent, TInt aId, TInt aError, TInt aAdditional )

    {

    if ( iEventMsgs.Count() )

        {

        HBufC8* buf = HBufC8::NewLC(( (2*KSizeofTInt8) + (3*KSizeofTInt32) ));

        TPtr8 bufPtr = buf->Des();

        RDesWriteStream stream;

        stream.Open(bufPtr);

        CleanupClosePushL(stream);

        stream.WriteInt8L( (TInt8) ENSmlTypeEvent );

        stream.WriteInt8L( (TInt8) aEvent );

        stream.WriteInt32L( aId );

        stream.WriteInt32L( aError );

        stream.WriteInt32L( aAdditional );

        stream.CommitL();

        while ( iEventMsgs.Count() > 0 )

            {

            if(!iEventMsgs[0].IsNull()&& iEventMsgs[0].Handle())

                {

                iEventMsgs[0].Write( 0, bufPtr, 0 );

                iEventMsgs[0].Complete( KErrNone );

                }

            iEventMsgs.Remove(0);

            }

        CleanupStack::PopAndDestroy(&stream); 

        CleanupStack::PopAndDestroy(buf);

        }

    }

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

// void CNSmlSOSHandler::CancelEventMsg( TInt aHandle )

// Completes cancelled event message and removes it from array.

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

//

void CNSmlSOSHandler::CancelEventMsg( TInt aHandle )

    {

    for ( TInt i(0) ; i < iEventMsgs.Count() ; i++ )

        {

        if ( iEventMsgs[i].Handle() == aHandle )

            {

            iEventMsgs[i].Complete( KErrCancel );

            iEventMsgs.Remove(i);

            }

        }

    }

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

// void CNSmlSOSHandler::ServerAlertL( TDesC8& aData, TSmlUsageType aType, TSmlProtocolVersion aVersion )

// Add server alert message to message queue.

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

//

void CNSmlSOSHandler::ServerAlertL( TDesC8& aData, TSmlUsageType aType, TSmlProtocolVersion aVersion, TInt aBearerType )

    {

    iMsgQueue->AddMessageL( aData, aType, aVersion, aBearerType );

    }

// FOTA

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

// void CNSmlSOSHandler::GenericAlertL( HBufC8* aMgmtUri, HBufC8* aMetaType, HBufC8* aMetaFormat, TInt aFinalResult, HBufC8* aCorrelator )

// Adds Generic Alert to DM Agent if it is currently running.

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

//

void CNSmlSOSHandler::GenericAlertL( HBufC8* aMgmtUri, HBufC8* aMetaType, HBufC8* aMetaFormat, TInt aFinalResult, HBufC8* aCorrelator )

	{

	if ( !iParams || !iParams->iThreadEngine )

		{

		User::Leave( KErrNotFound );

		}

	iParams->iThreadEngine->DMAgentL()->SetGenericAlertL( *aMgmtUri, *aMetaType, *aMetaFormat, aFinalResult, *aCorrelator );

	}

// FOTA end

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

// void CNSmlSOSHandler::GenericAlertL( HBufC8* aMgmtUri, HBufC8* aMetaType, HBufC8* aMetaFormat, HBufC8* aCorrelator, HBufC8* aTargetUri, HBufC8* aMark, HBufC8* aData )

// Adds Generic Alert to DM Agent if it is currently running.

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

//

void CNSmlSOSHandler::GenericAlertL( HBufC8* aCorrelator, RArray<CNSmlDMAlertItem>* aItem )

	{

	if ( !iParams || !iParams->iThreadEngine )

		{

		User::Leave( KErrNotFound );

		}