/*
* Copyright (c) 2006-2007 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:  obexservicemanager client class implementation
*
*/


// INCLUDE FILES
#include "obexsmclient.h"
#include <e32std.h>
#include "debug.h"


// CONSTANTS
const TInt KServerConnectRetries = 2;       // How many times client tries to make connection to server

// ======== LOCAL FUNCTIONS ========

// ---------------------------------------------------------
// StartThread
//
// Create the server thread/process depending on the framework.
// This function is exported from the DLL and called from the client
// RObexSMServer::Connect() -method.
// Returns: TInt: Error Code
//
// ---------------------------------------------------------

TInt StartThread()
    {
    TRACE_FUNC  
	
    TInt retVal = KErrNone;
    // create server - if one of this name does not already exist
    TFindServer findSrcs(KSrcsName);
    TFullName name;

    if ( findSrcs.Next( name ) != KErrNone ) // we don't exist already
        {
        TRequestStatus started;
        //TSrcsStart start( started );
        const TUidType serverUid( KNullUid,KNullUid,KSrcsUid );

        // Then we have to create the server
        // This depends on if we are in WINS or target HW environment.
	
		TRACE_INFO(_L("[SRCS]\tclient\tSrcs StartThread(): create the server"));
        // We are on target HW or EKA2 WINS.
        // New process has to be created for the SRCS		
        RProcess server;        
        retVal=server.Create(KSrcsName,             // Full path to SRCS
                             KNullDesC,     // Descriptor of parameters
                             serverUid);            // Triplet UID of executable

        // Check the return value of process creation
        if ( retVal != KErrNone )
            {
            // Loading failed.
			TRACE_ERROR((_L("[SRCS]\tclient\tSrcs StartThread(): process creation failed %d"), retVal));
            return retVal;
            }

		TRACE_INFO(_L("[SRCS]\tclient\tSrcs StartThread(): Process created successfully"));


        // Process/Thread has been created
        // Now logon to the server
        TRequestStatus stat;
        //server.Logon(died);
		server.Rendezvous(stat);

		if (stat!=KRequestPending)
			{
			server.Kill(0);		// abort startup
			//FTRACE(FPrint(_L("c\tclient\tSrcs abort startup.\n")));
			}
		else
			{
			server.Resume();	// logon OK - start the server
			//FTRACE(FPrint(_L("c\tclient\tSrcs Resumed.\n")));
			}

        // Then wait the start or death of the server.
        User::WaitForRequest(stat);

		// we can't use the 'exit reason' if the server panicked as this
		// is the panic 'reason' and may be '0' which cannot be distinguished
		// from KErrNone
		TRACE_INFO((_L("[SRCS]\tclient\tSrcs Server started, code %d (0=>success)\n"), stat.Int()));
		retVal=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();
		
		server.Close(); 
        TRACE_INFO(_L("[SRCS]\tclient\tSrcs server handle closed."));
        }

    return retVal;
    }

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

// ---------------------------------------------------------------------------
// Default constructor
// ---------------------------------------------------------------------------
//
RObexSMServer::RObexSMServer()
    {
    }


// ---------------------------------------------------------
// Connect
// Handles connection to server( creates session )
// ---------------------------------------------------------
//
TInt RObexSMServer::Connect()
    {
    TRACE_FUNC 

    // IF there is allready a session handle,
    // no other session is created.
    if ( Handle() )
        {
        return KErrAlreadyExists;
        }

    // Else try to create a new session with server
    TInt retry= KServerConnectRetries;

    FOREVER
    {
        // Try to make session with server
        TInt retVal=CreateSession(KSrcsName,Version());
        TRACE_INFO((_L("[SRCS]\tclient\tRSrcs: create Session returned: %d"), retVal));
        if ( retVal != KErrNotFound && retVal != KErrServerTerminated )
        {
        // Error which can't be handled happened.
        return retVal;
        }
    // Decrease count
    --retry;
    if ( retry == 0 )
        {
        return retVal;
        }

    // Try to start the server
	TRACE_INFO(_L("[SRCS]\tclient\tRSrcs::Connect(): try to start server"));
    retVal=StartThread();
    TRACE_INFO((_L("[SRCS]\tclient\tRSrcs: StartThread returned: %d"), retVal));

    if ( retVal != KErrNone && retVal != KErrAlreadyExists )
        {
        // Error can't be handled.
        return retVal;
        }
	}	
	
    }

// ---------------------------------------------------------
// Version
// Defines server version number
// ---------------------------------------------------------
//
TVersion RObexSMServer::Version() const
    {
    TRACE_FUNC        
    return( TVersion( KSrcsMajorVersionNumber,
                      KSrcsMinorVersionNumber,
                      KSrcsBuildVersionNumber ));
    }

// ---------------------------------------------------------
// ManageServices
// Sends Manage services command to SRCS.
// ---------------------------------------------------------
//
TInt RObexSMServer::ManageServices(TLocodBearer aBearer, TBool aBearStatus,TRequestStatus &aStatus )
    {
    TRACE_FUNC  
    TInt retVal = KErrNone;

    TPckgBuf<TInt> pckg;
    TIpcArgs args( &pckg, NULL, NULL );
    TSrcsServRequest request;
    
    switch(aBearer)
        {
        case ELocodBearerBT:
            {
            if(aBearStatus)
                {
                request=ESrcsBTServicesON;    
                }
            else
                {
                request=ESrcsBTServicesOFF;    
                }                        
            }
            break;
        case ELocodBearerIR:
            {
            if(aBearStatus)
                {
                request=ESrcsIrDAServicesON;    
                }
            else
                {
                request=ESrcsIrDAServicesOFF;    
                }            
            }
            break;
        case ELocodBearerUSB:
            {
            if(aBearStatus)
                {
                request=ESrcsStartUSB;    
                }
            else
                {
                request=ESrcsStopUSB;    
                }                
            }
            break;
        default:
            {
            TRACE_ERROR(_L("[SRCS]\tclient\tRSrcs Manageservice: Bad bearer"));    
            return KErrArgument;    
            }               
        }    
    if ( Handle() )
        {                       
        SendReceive( request, args, aStatus );        
        }        
    else
        {
        TRACE_ERROR(_L("[SRCS]\tclient\tRSrcs ManageBTServices. No Handle"));
        retVal = KErrBadHandle;
        }                
    return retVal;
    }

// ---------------------------------------------------------
// CancelRequest
// ---------------------------------------------------------
//
void RObexSMServer::CancelRequest()
    {    
    TPckgBuf<TInt> pckg;    
    TIpcArgs args( &pckg, NULL, NULL );
    TSrcsServRequest request;
    request=ESrcsCancelRequest;    
    if ( Handle() )
        {               
        SendReceive( request, args );                     
        }    
    
    }    
//end of file