/*
* Copyright (c) 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: 
*
*/

#include "toolssrvsession.h"
#include "toolssrvserver.h"
// System includes

//User Includes
#include "ToolsCmdCodes.h"

// Type definitions

// Constants
const TInt KToolsServerTransferBufferExpandSize = 100;
const TInt KSlot0 = 0;

// Enumerations

// Classes referenced


// Static functions
//
// Checks for a null'd handle before attempting complete. 
// If handle is null'd then don't complete as this will panic server.
//
void SafeComplete(const RMessagePtr2& aMessage, TInt aCompletionCode)
{
    if(!aMessage.IsNull())
    {
        aMessage.Complete(aCompletionCode);
    }
}



//
// CToolsSrvSession (source)
//

//
// CToolsSrvServer::CToolsSrvSession()
//
// Constructor
//
CToolsSrvSession::CToolsSrvSession()
:   iPendingRead(EFalse),
    iLaunchManager(NULL)
{
}

//
// CToolsSrvServer::~CToolsSrvSession()
//
// Destructor
//
CToolsSrvSession::~CToolsSrvSession()
{
	HandleServerDestruction();
	delete iTransferBuffer;
	//get a reference to the server
	CToolsSrvServer* toolsserver = (CToolsSrvServer*)Server();
	
	//notify the server that the session has been opened
	if (toolsserver != NULL)
	    toolsserver->SessionClosed();
	if(iLaunchManager)
	    iLaunchManager->UnregisterListener(this);
}

//
// CToolsSrvServer::ConstructL()
//
// Creates an instance of CToolsSrvSession.
//
void CToolsSrvSession::ConstructL()
{
    iTransferBuffer = CBufFlat::NewL(KToolsServerTransferBufferExpandSize);
}

//
//  CToolsSrvSession::CreateL()
//
void CToolsSrvSession::CreateL()
{
    //get a reference to the server
    CToolsSrvServer* toolsserver = (CToolsSrvServer*)Server();
    
    //notify the server that the session has been opened
    if (toolsserver != NULL)
    {
        toolsserver->SessionOpened();
        iLaunchManager = toolsserver->GetLaunchInterface();
    }
  
}
//
// CToolsSrvServer::NewL()
//
// Static self construction
//
CToolsSrvSession* CToolsSrvSession::NewL()
{
	CToolsSrvSession* self = new(ELeave) CToolsSrvSession();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
}

//
// CToolsSrvServer::HandleServerDestruction()
//
// Called by the server's destructor. We need to be told that the server is
// being destroyed.
//
void CToolsSrvSession::HandleServerDestruction()
{
}

//
// CToolsSrvServer::ServiceL()
//
// Services requests from a client.
// Called by the IPC framework whenever a client sends a request to the server.
//
void CToolsSrvSession::ServiceL(const RMessage2& aMessage)
{

    const TInt cmd = aMessage.Function();

	switch(cmd)
	{
		case EToolsCmdCodeGetUsbConnStatus:
			 CmdGetUsbConnStatus(aMessage);
			break;
		case EToolsCmdCodeConnNotify:
			CmdConnNofify(aMessage);
			break;
		case EToolCmdCodeConnNotifyCancel:
			CmdConnNotifyCancel(aMessage);
			break;		
		case EToolsCmdCodeShutDownServer:
			CmdShutDownServer();			
			break;
	
		default:
			aMessage.Panic(KServerIntiatedSessionPanic, EToolsServerInitiatedClientPanicInvalidOperation);
			break;
	}
		
}

//
//  CToolsSrvSession::CmdGetUsbConnStatus      
//
//  Command implementation to find out the usb connection status
//
void CToolsSrvSession::CmdGetUsbConnStatus(const RMessage2& aMessage)
{
    TConnectionStatus status = iLaunchManager->GetUsbConnStatus();
    TPckg<TConnectionStatus> package(status);
    TRAPD(err,aMessage.Write(KSlot0,package)); 
    if (err != KErrNone)
    {
        aMessage.Panic(_L("ToolsServer"),2);
    }
    SafeComplete(aMessage,KErrNone);
}
//
//  CToolsSrvSession::CmdConnNofify      
//
//  To register for usb cable connection notifications
//
void CToolsSrvSession::CmdConnNofify(const RMessage2& aMessage)
{   
    if (iPendingRead)
    {   
        SafeComplete(aMessage, KErrAlreadyExists);
    }
    else
    {
        iLaunchManager->RegisterListener(this);
        iBlockedRead = aMessage;
        iPendingRead = ETrue;     
        
    }   
}
//
//  CToolsSrvSession::CmdConnNotifyCancel      
//
//  To unregister for usb cable connection notifications
//
void CToolsSrvSession::CmdConnNotifyCancel(const RMessage2& aMessage)
{
    if ( iPendingRead && iBlockedRead.Handle())
    {
        SafeComplete(iBlockedRead, KErrCancel);
        iPendingRead = EFalse;
        iLaunchManager->UnregisterListener(this);
    }
    SafeComplete(aMessage, KErrNone);
}

//
//  CToolsSrvSession::ConnStatusChanged
//
//  Called when the usb cable connection changes
//
void CToolsSrvSession::ConnStatusChanged(TConnectionStatus aStatus)
{
    if(iPendingRead && iBlockedRead.Handle())
    {
        iPendingRead = EFalse;
        TConnectionStatus status = aStatus;
        TPckg<TConnectionStatus> package(status);
        TRAPD(err, iBlockedRead.WriteL(KSlot0, package));  
        if ( err != KErrNone )
        {
            iBlockedRead.Panic(_L("ToolsServer"),2);
        }
        SafeComplete(iBlockedRead,KErrNone);
    }
       
}
//
// CToolsSrvServer::CmdShutDownServer()
//
// Stops the active scheduler. This way, server process will run to completion.
//
void CToolsSrvSession::CmdShutDownServer()
{
	CActiveScheduler::Stop();
}