/*
* Copyright (c) 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:  Client for DS and DM initiated syncs
*
*/



// INCLUDE FILES

#include <bldvariant.hrh>

#include <centralrepository.h>
#include <SyncMLNotifierDomainCRKeys.h>
#include <SyncServiceSession.h>
#include <SyncServiceParams.h>
#include <SyncService.h>
#include <SyncServiceConst.h>
#include "SyncServiceDebug.h"

#include <apgcli.h>
#include <AknServerApp.h>
#include <barsread2.h>

// ----------------------------------------------------------------------------
// RSyncService::StartSyncL
// ----------------------------------------------------------------------------
//
void RSyncService::StartSyncL( TSyncServiceParam aParam )
	{
	FLOG( _L( "[RSyncService] StartSyncL" ) );
	
	TSyncParameters parameters;
	parameters.iCommand = KSyncServCmdStartSync;
    parameters.iJobId = aParam.iJobId;
    parameters.iProfileId = aParam.iProfileId;
    parameters.iSilent = aParam.iSilent;
    TInt err = 
		SendReceive( ESyncServiceCommand, TIpcArgs( parameters.iCommand,
		                                            parameters.iJobId,
		                                            parameters.iProfileId,
		                                            parameters.iSilent ) );
	User::LeaveIfError( err );
	}

// ----------------------------------------------------------------------------
// RSyncService::EnableProgressNoteL
// ----------------------------------------------------------------------------
//
void RSyncService::EnableProgressNoteL( TBool aEnabled )
	{
	FLOG( _L("[RSyncService] EnableProgressNoteL") );

	TSyncParameters parameters;
	parameters.iCommand = KSyncServCmdShowProgress;

    if ( aEnabled )
        {
        parameters.iJobId = KSyncServEnabled;
        }
    else
        {
        parameters.iJobId = KSyncServDisabled;
        }
    
    TInt err = 
		SendReceive( ESyncServiceCommand, TIpcArgs( parameters.iCommand,
		                                            parameters.iJobId,
		                                            parameters.iProfileId,
		                                            parameters.iSilent ) );
	User::LeaveIfError( err );
	}

// ----------------------------------------------------------------------------
// RSyncService::ServiceUid
// ----------------------------------------------------------------------------
//
TUid RSyncService::ServiceUid() const
	{
	FLOG( _L( "[RSyncService] ServiceUid" ) );
	
	return TUid::Uid( KSyncServiceUid );
	}

// ----------------------------------------------------------------------------
// CSyncService::CSyncService
// ----------------------------------------------------------------------------
//
CSyncService::CSyncService( )
	{
	FLOG( _L( "[CSyncService] CSyncService" ) );
	
	}

// ----------------------------------------------------------------------------
// CSyncService::~CSyncService
// ----------------------------------------------------------------------------
//
CSyncService::~CSyncService( )
	{
	FLOG( _L( "[CSyncService] ~CSyncService" ) );
	
	delete iMonitor;
	iService.Close();
	}

// ----------------------------------------------------------------------------
// CSyncService::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CSyncService* CSyncService::NewL( MAknServerAppExitObserver* aObserver,
                                           TUint aServiceId )
    {
    FLOG( _L( "[CSyncService] NewL" ) );
    
	CSyncService* self = new(ELeave) CSyncService();
	CleanupStack::PushL(self);
    self->ConstructL( aObserver, aServiceId );
	CleanupStack::Pop(self);
	return self;
    }

// ----------------------------------------------------------------------------
// CSyncService::ConstructL
// ----------------------------------------------------------------------------
//
void CSyncService::ConstructL( MAknServerAppExitObserver* /*aObserver*/,
                               TUint aServiceId )
    {
	FLOG( _L( "[CSyncService] ConstructL" ) );
    iServiceId = aServiceId;
    }

// ----------------------------------------------------------------------------
// CSyncService::StartSyncL
// ----------------------------------------------------------------------------
//
EXPORT_C TUid CSyncService::StartSyncL( TSyncServiceParam aParam )
    {
    FLOG( _L( "[CSyncService] StartSyncL" ) );

    iServiceId = aParam.iServiceId;
	iUid = DiscoverL( iServiceId );
	
    TInt error = KErrNotFound;
        
    if( iService.ServerName().Length() > 0 )
        {
        FLOG( _L( "[CSyncService] ConstructL connect to existing app" ) );
  	    TRAP( error, iService.StartSyncL( aParam ) );
  	    if ( error == KErrNone )
  	        {
  	        return iUid;
  	        }
        }
   	if ( error )
		{
		TFullName aServerName;
		if ( iServiceId == KDevManServiceStart )
		    {
    		CRepository* centrep = NULL;
    		centrep = CRepository::NewL( KCRUidNSmlNotifierDomainKeys );
    		centrep->Get( KNSmlDMAppName, aServerName );
    		delete centrep;
		    }
		else
		    {
		    aServerName = KDataSyncServiceName;
		    }
        FLOG( _L( "[CSyncService] ConstructL connect to existing app with predefined name" ) );
        iService.Close();
		TRAP( error, iService.ConnectExistingByNameL( aServerName ) );
		}
   	if ( error )
		{
		FLOG( _L( "[CSyncService] ConstructL connect to new app" ) );
    	TRAP( error, iService.ConnectNewAppL( iUid ) );
    	if( error )
    		{
    		FLOG( _L( "[CSyncService] ConnectNewAppL: Error not supported" ) );
    		User::Leave( KErrNotSupported );
    		}
 		}
    
    iService.StartSyncL( aParam );
    return iUid;
    }

// ----------------------------------------------------------------------------
// CSyncService::EnableProgressNoteL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSyncService::EnableProgressNoteL( TBool aEnabled )
    {
    FLOG( _L( "[CSyncService] EnableProgressNoteL" ) );
    
    TFullName DmAppName;
    CRepository* centrep = NULL;
    centrep = CRepository::NewL( KCRUidNSmlNotifierDomainKeys );
    centrep->Get( KNSmlDMAppName, DmAppName );
    delete centrep;
    
    if( iService.ServerName().Length() > 0 )
        {
		TRAPD(error, iService.EnableProgressNoteL( aEnabled ) );
		if ( error != KErrNone )
		    {
    		TFullName aServerName;
    		if ( iServiceId == KDevManServiceStart )
    		    {
                aServerName = DmAppName;
    		    }
    		else
    		    {
    		    aServerName = KDataSyncServiceName;
    		    }
            FLOG( _L( "[CSyncService] EnableProgressNoteL connect to existing app with predefined name" ) );
            iService.Close();
    		iService.ConnectExistingByNameL( aServerName );        
            iService.EnableProgressNoteL( aEnabled );
		    }
        }
    else
        {
        // Sync has been started from APP UI so connect to the service and enable progressnote
		TFullName aServerName;
		if ( iServiceId == KDevManServiceStart )
		    {
		    aServerName = DmAppName;
		    }
		else
		    {
		    aServerName = KDataSyncServiceName;
		    }
        FLOG( _L( "[CSyncService] EnableProgressNoteL connect to existing app with predefined name" ) );
		iService.ConnectExistingByNameL( aServerName );        
        iService.EnableProgressNoteL( aEnabled );
        }
    FLOG( _L( "[CSyncService] EnableProgressNoteL" ) );
    }

// ----------------------------------------------------------------------------
// CSyncService::DiscoverL
// ----------------------------------------------------------------------------
//
TUid CSyncService::DiscoverL( TUint aServiceId )
	{
	FLOG( _L( "[CSyncService] DiscoverL" ) );
	
	CApaAppServiceInfoArray* services = NULL;	
	RApaLsSession ls;
	TUid appUid = TUid::Uid( 0x0 ); // Set the uid as NULL
	
	if( ls.Connect() == KErrNone )
		{
	    CleanupClosePushL( ls );
		TInt ret = ls.GetServerApps( TUid::Uid( KSyncServiceUid ) );

		if( ret != KErrNone )
			{
		    CleanupStack::PopAndDestroy( );  // closes RApaLsSession		
		    return appUid; // return NULL appUid
			}

		services = ls.GetServiceImplementationsLC( TUid::Uid( KSyncServiceUid ) );			
		
		if( services )
			{
			TArray<TApaAppServiceInfo> s = services->Array( );
			
			TInt count = s.Count( );
		
			if( count != 0)
				{	// 
				for( TInt i = 0; i < count; i++ )
					{
					if( TryMatchL( s[i], appUid, aServiceId ) )
						{ // If one of the services match, return the uid set by TryMatchL
						break;
						}
					}
				}		
			}
	    CleanupStack::PopAndDestroy( 2 );  // destroys services + closes RApaLsSession
		}
	return appUid;
	}

// ----------------------------------------------------------------------------
// CSyncService::TryMatchL
// ----------------------------------------------------------------------------
//
TBool CSyncService::TryMatchL( const TApaAppServiceInfo aInfo,
                               TUid& aAppUid,
                               TUint aServiceId )
	{
	FLOG( _L( "[CSyncService] TryMatchL" ) );
	
	RResourceReader r;
	r.OpenLC( aInfo.OpaqueData() );

	TInt serviceType = r.ReadUint32L( ); // the service type (sync start)

    CleanupStack::PopAndDestroy( );				
	
	if( serviceType == aServiceId )
		{
		aAppUid.iUid = aInfo.Uid( ).iUid;
		FLOG( _L( "[CSyncService] TryMatchL return ETrue" ) );
		return ETrue;
		}
    
    FLOG( _L( "[CSyncService] TryMatchL return EFalse" ) );
	return EFalse;	
	}
	
// End of file