/*

* 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:  

*

*/

// INCLUDES

#include "AspSyncHandler.h"

#include "AspDebug.h"

#include "AspSettingDialog.h"

#include <aspsyncutil.mbg>  // for progress dialog bitmap enumerations

#include <SyncMLErr.h>  // sync error codes

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <rconnmon.h>

#include <e32std.h> //For TRequestStatus

#include <e32property.h>

#include "CPreSyncPlugin.h"

#include "AspPreSyncPluginInterface.h"

#include <DataSyncInternalPSKeys.h>

#include <featmgr.h>

/******************************************************************************

 * class TAspSyncParam

 ******************************************************************************/

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

// TAspSyncParam::TAspSyncParam

//

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

//

TAspSyncParam::TAspSyncParam(TInt aApplicationId)

 : iApplicationId(aApplicationId), iProfileId(KErrNotFound), iJobId(KErrNotFound),

   iTaskId(KErrNotFound), iSyncDirection(KErrNotFound), iDialogMode(EModeDialogNoWait)

	 {

	 }

/******************************************************************************

 * class CAspSyncHandler

 ******************************************************************************/

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

// CAspSyncHandler::NewL

//

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

//

CAspSyncHandler* CAspSyncHandler::NewL(const TAspParam& aParam)

    {

    FLOG( _L("CAspSyncHandler::NewL START") );

    CAspSyncHandler* self = new (ELeave) CAspSyncHandler(aParam);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

    FLOG( _L("CAspSyncHandler::NewL END") );

    return self;

    }

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

// Destructor

//

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

//

CAspSyncHandler::~CAspSyncHandler()

    {

    FLOG( _L("CAspSyncHandler::~CAspSyncHandler START") );

    delete iProgressDialog;

	delete iState;

	delete iResHandler;

	delete iActiveCaller;

	delete iTextResolver;

	delete iContentList;

    if (iWait && iWait->IsStarted())

        {

        iWait->AsyncStop();

        }

	delete iWait;

	RProperty::Delete(KPSUidNSmlDSSyncApp, KDsJobCancel);

	CloseSyncSession();

	FLOG( _L("CAspSyncHandler::~CAspSyncHandler END") );

    }

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

// CAspSyncHandler::ConstructL

//

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

//

void CAspSyncHandler::ConstructL()

    {

	FLOG( _L("CAspSyncHandler::ConstructL START") );

	iState = CAspState::NewL();

	iActiveCaller = CAspActiveCaller::NewL(this);

	iTextResolver = CTextResolver::NewL();

	iServerAlertSync = EFalse;

	iSyncRunning = EFalse;

	iSyncError = KErrNone;

	iCurrentSyncJobId = KErrNotFound;

	iSyncSessionOpen = EFalse;

	iWait = new (ELeave) CActiveSchedulerWait();

	//Define property for cancel operation.

    static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

    static _LIT_SECURITY_POLICY_C1(KAllowWriteDeviceDataPolicy, ECapabilityWriteDeviceData);

	RProperty::Define( KPSUidNSmlDSSyncApp,KDsJobCancel,RProperty::EInt,

	        KAllowAllPolicy,KAllowWriteDeviceDataPolicy); 

	RProperty::Set( KPSUidNSmlDSSyncApp,

	            KDsJobCancel, KErrNone );   

	FLOG( _L("CAspSyncHandler::ConstructL END") );

    }

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

// CAspSyncHandler::CAspSyncHandler

//

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

//

CAspSyncHandler::CAspSyncHandler(const TAspParam& /*aParam*/)

	{

	}

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

// CAspSyncHandler::SetObserver

//

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

//

void CAspSyncHandler::SetObserver(MAspSyncObserver* aObserver)

	{

	iSyncObserver = aObserver;

	}

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

// CAspSyncHandler::HandleDialogEventL (from MAspProgressDialogObserver)

//

// 

// Canceling sequence after user presses "Cancel":

//

// 1. framework calls CAspProgressDialog2::OkToExitL

// 2. OkToExitL calls CAspProgressDialog::DialogDismissedL

// 3. DialogDismissedL calls CAspSyncHandler::HandleDialogEventL

// 4. HandleDialogEventL cancels sync (RSyncMLDataSyncJob::StopL)

//    and updates progress dialog text ("Cancelling")

// 5. MSyncMLEventObserver::EJobStop arrives (asynchronously)

//    and CAspProgressDialog is closed

//

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

//

void CAspSyncHandler::HandleDialogEventL(TInt aButtonId)

    {

    FLOG( _L("CAspSyncHandler::HandleDialogEventL START") );

    TBool syncRunning = SyncRunning();

	//  close handling (eg. end key)

	if (aButtonId == EKeyPhoneEnd && syncRunning)

		{

        //Set Cancel  property when user cancel the Caopy All from Server. 

		RProperty::Set( KPSUidNSmlDSSyncApp,

		                KDsJobCancel, KErrCancel );

		TRAPD(err, iSyncJob.StopL());

		if (err != KErrNone)

			{

			FLOG( _L("### RSyncMLDataSyncJob::StopL failed (%d) ###"), err );

			}

	    iSyncJob.Close(); // this can be done when job has not been opened

	    CloseSyncSession();

		iSyncRunning = EFalse;

	 	if (iIsSynchronousOperation && iWait->IsStarted())

		    {

	        iWait->AsyncStop();

		    }

		FLOG( _L("CAspSyncHandler::HandleDialogEventL: end key handling done") );

		FLOG( _L("CAspSyncHandler::HandleDialogEventL END") );

		return;

		}

	// cancel key handling

	if (aButtonId == EEikBidCancel && syncRunning)

		{

        RProperty::Set( KPSUidNSmlDSSyncApp,

                KDsJobCancel, KErrCancel );

		if (iStopEventReceived)

			{

			CompleteWithDelay(KErrNone);

        	FLOG( _L("### EJobStop already received ###") );

        	FLOG( _L("CAspSyncHandler::HandleDialogEventL END") );

	        return;

			}

		TInt jobId = CAspProfile::CurrentJob(&iSyncSession);

       	if (jobId != iCurrentSyncJobId)

	        {

	        CompleteWithDelay(KErrNotFound);

	        FLOG( _L("### job conflict (%d/%d) ###"), iCurrentSyncJobId, jobId );

        	FLOG( _L("CAspSyncHandler::HandleDialogEventL END") );

	        return;

	        }

		TRAPD(err, iSyncJob.StopL());

       	if (err != KErrNone)

	        {

	        CompleteWithDelay(err);

	        FLOG( _L("### RSyncMLDataSyncJob::StopL failed (%d) ###"), err );

        	FLOG( _L("CAspSyncHandler::HandleDialogEventL END") );

	        return;

	        }

	    State()->SetSyncPhase(CAspState::EPhaseCanceling);

        UpdateDialog();

        FLOG( _L("CAspSyncHandler::HandleDialogEventL: cancel key handling done") );

		}

	FLOG( _L("CAspSyncHandler::HandleDialogEventL END") );

    }

TBool CAspSyncHandler::IsRoamingL()

    {

    RConnectionMonitor conMon;

    conMon.ConnectL();

    TRequestStatus status;

    TInt registrationStatus(0);

    //check network status

    conMon.GetIntAttribute(EBearerIdGSM, 0, KNetworkRegistration, 

                            registrationStatus, status);

    User::WaitForRequest(status);

    conMon.Close();

    if (registrationStatus == ENetworkRegistrationRoaming)

        {

        return ETrue;   

        }

    return EFalse;

    }

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

// CAspSyncHandler::ReadRepositoryL

//

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

//

void CAspSyncHandler::ReadRepositoryL(TInt aKey, TInt& aValue)

    {

    CRepository* rep = CRepository::NewLC(KCRUidNSmlDSApp);

    TInt err = rep->Get(aKey, aValue);

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy(rep);

    }

TInt CAspSyncHandler::BearerTypeL(TInt aProfileId)

    {    

    TInt BearerType = KErrNotFound;

    // sync session

    RSyncMLSession syncSession;

    syncSession.OpenL();

    CleanupClosePushL( syncSession );

    RSyncMLDataSyncProfile syncProfile;

    syncProfile.OpenL( syncSession, aProfileId, ESmlOpenRead );

    CleanupClosePushL( syncProfile );

    // Check if always ask is selected as accesspoint

    RSyncMLConnection connection;

    TInt err = KErrNone;

    RArray<TSmlTransportId> arr;

    TRAP(err, syncProfile.ListConnectionsL(arr));

    if (err != KErrNone)

        {

        syncProfile.Close();

        CleanupStack::Pop( &syncProfile );

        return KErrNotFound; 

        }

    if (arr.Count() == 0)

        {

        syncProfile.Close();

        CleanupStack::Pop( &syncProfile );

        arr.Close();  

        return KErrNotFound; // no connection

        }

    TInt transportId = arr[0];

    arr.Close();

    TRAP(err, connection.OpenL( syncProfile, transportId ) );

    CleanupClosePushL( connection );

    if ( err == KErrNone )

        {

        TInt id = connection.Identifier();

        if (id == KUidNSmlMediumTypeInternet.iUid)

            {

            BearerType = EAspBearerInternet;

            }

        else if (id == KUidNSmlMediumTypeBluetooth.iUid)

            {

            BearerType = EAspBearerBlueTooth;

            }

        else if (id == KUidNSmlMediumTypeUSB.iUid)

            {

            BearerType = EAspBearerUsb;

            }

        else if (id == KUidNSmlMediumTypeIrDA.iUid)

            {

            BearerType = EAspBearerIrda;

            }

        }

    connection.Close();

    CleanupStack::Pop( &connection );

    syncProfile.Close();

    CleanupStack::Pop( &syncProfile );

    syncSession.Close();

    CleanupStack::Pop( &syncSession );

    return BearerType;

    }

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

// CAspSyncHandler::SynchronizeL

//

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

//

void CAspSyncHandler::SynchronizeL(TAspSyncParam& aSyncParam)

	{

	iServerAlertSync = EFalse;

	iSyncRunning = EFalse;

	iCurrentSyncJobId = KErrNotFound;

	iSyncError = KErrNone;

	iCompleteEventReceived = EFalse;

	iStopEventReceived = EFalse;

	iIsSynchronousOperation = EFalse;

	TBool bCanSync = ETrue;

    TInt aValue = 0;

    ReadRepositoryL(KNSmlDSRoamingFeature, aValue);

    if(( IsRoamingL() ) && (aValue == EAspRoamingSettingFeatureEnabled))

        {

           TInt bearerType = BearerTypeL(aSyncParam.iProfileId);

           if (bearerType == EAspBearerInternet)           

            {

            CPreSyncPluginInterface* syncPluginInterface = CPreSyncPluginInterface::NewL();

            CPreSyncPlugin* syncPlugin = 

                syncPluginInterface->InstantiateRoamingPluginLC(aSyncParam.iProfileId);

            if(syncPlugin->IsSupported())

                {

                bCanSync = syncPlugin->CanSyncL();

                }

            CleanupStack::PopAndDestroy(syncPlugin);

            //syncPluginInterface->UnloadPlugIns();

            delete  syncPluginInterface;   

            if(!bCanSync)

                {

                return;

                }

            }        

        }	

	State()->SetSyncPhase(CAspState::EPhaseConnecting);

	State()->ResetProgress();

	//State()->SetTotalProgress(KTotalProgress);

	TRAPD(err, DoSynchronizeL(aSyncParam));

	if (err != KErrNone)

		{

		SynchronizeCompleted(err);

     	return;

		}

	}

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

// CAspSyncHandler::DoSynchronizeL

//

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

//

void CAspSyncHandler::DoSynchronizeL(TAspSyncParam& aSyncParam)

	{

	FLOG( _L("CAspSyncHandler::DoSynchronizeL START") );

	 //set the cancel Pub sub key to none

	if(aSyncParam.iSyncDirection == ESyncDirectionRefreshFromServer)

	    {

	    RProperty::Set( KPSUidNSmlDSSyncApp,

	            KDsJobCancel, KErrNone );

	    }

	iApplicationId = aSyncParam.iApplicationId;

	iProfileId = aSyncParam.iProfileId;

	if (aSyncParam.iDialogMode == EModeDialogWait)

		{

		iIsSynchronousOperation = ETrue; // email 3.2 needs synchronous syncing

		}

	ShowProgressDialogL();

    OpenSyncSessionL();

    CreateContentListL();

    iSyncSession.RequestEventL(*this);     // for MSyncMLEventObserver events

    iSyncSession.RequestProgressL(*this);  // for MSyncMLProgressObserver events

 	if (aSyncParam.iTaskId != KErrNotFound && iProfileId != KErrNotFound)

		{

		RArray<TSmlTaskId> arr(1);

		CleanupClosePushL(arr);

		User::LeaveIfError(arr.Append(aSyncParam.iTaskId));

		if (aSyncParam.iSyncDirection != KErrNotFound)

			{

			TSmlSyncType syncDirection = TAspTask::SmlSyncDirection(aSyncParam.iSyncDirection);

			iSyncJob.CreateL(iSyncSession, iProfileId, syncDirection, arr);

			}

		else

			{

			iSyncJob.CreateL(iSyncSession, iProfileId, arr);

			}

		CleanupStack::PopAndDestroy(&arr);

		}

	else if (iProfileId != KErrNotFound)

		{

		if (aSyncParam.iSyncDirection != KErrNotFound)

			{

		    TSmlSyncType syncDirection = TAspTask::SmlSyncDirection(aSyncParam.iSyncDirection);

			iSyncJob.CreateL(iSyncSession, iProfileId, syncDirection);

			}

		else

			{

		    iSyncJob.CreateL(iSyncSession, iProfileId);

			}

		}

	else

		{

		User::Leave(KErrArgument);

		}

	iCurrentSyncJobId = iSyncJob.Identifier();

	iSyncRunning = ETrue;

	if (iIsSynchronousOperation)

		{

		iWait->Start();  // stop here until sync has completed

		}

    FLOG( _L("sync job created: app=%d, profile=%d, job=%d, task=%d"), iApplicationId, iProfileId, aSyncParam.iJobId, aSyncParam.iTaskId );

    FLOG( _L("CAspSyncHandler::DoSynchronizeL END") );

	}

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

// CAspSyncHandler::SynchronizeCompleted

//

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

//

void CAspSyncHandler::SynchronizeCompleted(TInt aError)

	{

	FLOG( _L("CAspSyncHandler::SynchronizeCompleted START") );

	iSyncRunning = EFalse;

	RProperty::Set( KPSUidNSmlDSSyncApp,

	                           KDsJobCancel, KErrNone ); 

	if (aError != KErrNone)

		{

		iSyncError = aError;

		}

   	iSyncJob.Close(); // this can be done when job has not been opened

    TRAP_IGNORE(Dialog()->CancelProgressDialogL());

	if (iSyncError != KErrNone)

		{

	   	CloseSyncSession();