/*
* 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 "trkdebugmgrcallbacks.h"
#include "trkdebugmanager.h"
#ifndef __TEXT_SHELL__
#include "DebugNotifier.h"
#endif
// System includes
#include <e32debug.h>

//Constants
#ifndef __TEXT_SHELL__
_LIT(KLibraryName, "DebugNotifier.dll");
#endif

#define SafeDelete(x) { if (x) delete x; x = NULL; }

//
// CTrkDebugManager (source)
//

//
// CTrkDebugManager::CTrkDebugManager()
//
// Constructor
//
CTrkDebugManager::CTrkDebugManager() : iTrkEngine(NULL), iConnStatus(ETrkNotConnected), iDebugging(EFalse), iPlugAndPlay(ETrue),
                                       iDebugMgrCallback(NULL)
#ifndef __TEXT_SHELL__                                       
, iToolsConnectionListener(NULL)
#endif
{
    
}

//
// CTrkDebugManager::~CTrkDebugManager()
//
// Destructor
//
CTrkDebugManager::~CTrkDebugManager()
{
    StopListening();
#ifndef __TEXT_SHELL__
    SafeDelete(iToolsConnectionListener);
#endif
    SafeDelete(iTrkEngine);
}

//
// CTrkDebugManager::ConstructL()
//
// Second level constructor
//
void CTrkDebugManager::ConstructL()
{	
	iTrkEngine = CTrkEngine::NewL(this);
#ifndef __TEXT_SHELL__
	TRAPD(err,iToolsConnectionListener = CToolsConnectionListener::NewL(this));
	if(!err)
	iToolsConnectionListener->StartListening();
#endif
}

//
// CTrkDebugManager::NewL()
//
// Creates an instance of CTrkDebugManager
//
CTrkDebugManager* CTrkDebugManager::NewL()
{
	CTrkDebugManager* self = new(ELeave) CTrkDebugManager();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
}


//
// CTrkDebugManager::NewLC()
//
// Creates an instance of CTrkDebugManager
//
CTrkDebugManager* CTrkDebugManager::NewLC()
{
	CTrkDebugManager* self = new(ELeave) CTrkDebugManager();
	CleanupStack::PushL(self);
	self->ConstructL();
	
	return self;
}
//
// CTrkDebugManager::StartDebugging()
//
// This method is to start debugging when the connection changes and also to handle command line arguments
//
void CTrkDebugManager::StartDebuggingL(TTrkConnType aConnType)
{   
    TRAPD(error, iTrkEngine->StartL(aConnType));
    
    if (error != KErrNone)
    {
        iTrkEngine->GetErrorInfo(iConnMsg);
        iConnStatus = ETrkNotConnected;
        iTrkEngine->Stop();
    }
    else
    {
        iTrkEngine->GetConnectionInfo(iConnMsg);
        iConnStatus = ETrkConnected;
    }
    User::Leave(error);
}
//
// CTrkSrvScheduler::StartDebuggingL()
//
// This method is to start debugging with the bluetooth connection
//
void CTrkDebugManager::StartDebuggingL()
{	
	TRAPD(error, iTrkEngine->StartL());

	if (error != KErrNone)
	{
		iTrkEngine->GetErrorInfo(iConnMsg);
		iConnStatus = ETrkNotConnected;
		iTrkEngine->Stop();
	}
	else
	{
		iTrkEngine->GetConnectionInfo(iConnMsg);
		iConnStatus = iTrkEngine->GetConnectionStatus();
	}
}
//
// CTrkSrvScheduler::StopDebugging()
//
// This method is to stop the debugging
//
void CTrkDebugManager::StopDebugging()
{   
	iTrkEngine->Stop();
	iConnStatus = ETrkNotConnected;
	iConnMsg = KNullDesC;
}
//
// CTrkSrvScheduler::StopDebugging()
//
// To get the version info of TRK
//
void CTrkDebugManager::GetVersion(TTRKVersion& aVersion)
{
	iTrkEngine->GetVersionInfo(aVersion.iMajor, aVersion.iMinor, aVersion.iMajorAPI, aVersion.iMinorAPI, aVersion.iBuild);
}
//
// CTrkSrvScheduler::GetConnectionMsg()
//
// To find out the connection msg 
//
void CTrkDebugManager::GetConnectionMsg(TDes& aConnStatusMsg)
{
    aConnStatusMsg = iConnMsg;        
}

//
// CTrkDebugManager::ConnectToDebuggerL()
//
void CTrkDebugManager::ConnectToDebuggerL()
{	
    StartDebuggingL();
}

//
// CTrkSrvScheduler::DisConnect()
//
void CTrkDebugManager::DisConnect()
{
    StopDebugging();
}

//
// CTrkDebugManager::GetCurrentConnData()
//
void CTrkDebugManager::GetCurrentConnData(TTrkConnData& aConnData)
{
    iTrkEngine->GetConnectionData(aConnData);
}

//
//CTrkDebugManager::SetCurrentConnData()
//
void CTrkDebugManager::SetCurrentConnData(TTrkConnData& aConnData)
{
    iTrkEngine->SetConnectionData(aConnData);
}
//
// CTrkDebugManager::IsDebugging()
// returns whether debugging started or not
//
TBool CTrkDebugManager::IsDebugging()
{
    iDebugging = iTrkEngine->IsDebugging();
    return iDebugging;
}
//
// CTrkDebugManager::GetPlugAndPlayOption()
// returns whether the plug and play is set or not
//
TBool CTrkDebugManager::GetPlugAndPlayOption()
{   
    return iPlugAndPlay;
    
}
//
// CTrkDebugManager::SetPlugAndPlayOption()
// To set the plug and play option 
//
void CTrkDebugManager::SetPlugAndPlayOption(TBool aPlugAndPlay)
{
    iPlugAndPlay = aPlugAndPlay;
    
}
// ----------------------------------------------------
// CTrkDebugManager::OnConnection
// Called when a connection is opened, right now nothing is done
// as connection is always established from the user side.
// This call would be useful when we add for connecting automatically 
// when a USB cable is plugged in while TRK is running.
// ----------------------------------------------------
//
void CTrkDebugManager::OnConnection()
{
    iConnStatus = ETrkConnected;
    iTrkEngine->GetConnectionInfo(iConnMsg);
    if (iDebugMgrCallback)
         iDebugMgrCallback->DebugConnStatusChanged(iConnStatus);
}

// ----------------------------------------------------
// CTrkDebugManager::OnCloseConnection
// Called when a connection is closed, update any of the UI clients.
// ----------------------------------------------------
//
void CTrkDebugManager::OnCloseConnection()
{   
    iConnStatus = ETrkNotConnected;
    if (iDebugMgrCallback)
          iDebugMgrCallback->DebugConnStatusChanged(iConnStatus);
}

//
// ----------------------------------------------------
// CTrkDebugManager::DebuggingStarted
// Called when a debug session is started.
// ----------------------------------------------------
//
void CTrkDebugManager::DebuggingStarted()
{
    iDebugging = ETrue;
    if (iDebugMgrCallback)
        iDebugMgrCallback->DebuggingStatusChanged(iDebugging);
}

//
// ----------------------------------------------------
// CTrkDebugManager::DebuggingEnded
// Called when a debug session is ended.
// ----------------------------------------------------
//
void CTrkDebugManager::DebuggingEnded()
{
    iDebugging = EFalse;
    if (iDebugMgrCallback)
        iDebugMgrCallback->DebuggingStatusChanged(iDebugging);
}

//
//----------------------------------------------------
//CTrkDebugManager::OnAsyncConnectionFailed()
//Called when bluetooth connection falied
//----------------------------------------------------
//
void CTrkDebugManager::OnAsyncConnectionFailed()
{
    
    iConnStatus = ETrkConnectionError;
    iTrkEngine->GetErrorInfo(iConnMsg);
    if (iDebugMgrCallback)
          iDebugMgrCallback->DebugConnStatusChanged(iConnStatus);
    
}

//
//----------------------------------------------------
// CTrkDebugManager::ConnectionAvailable()
// Called when the usb connection available
//----------------------------------------------------
//
void CTrkDebugManager::ConnectionAvailable()
{   
    iPlugAndPlay = iTrkEngine->GetPlugPlaySetting(); 
  
    if(!iDebugging && iPlugAndPlay)
    {   
       StopDebugging();
       TRAPD(error, StartDebuggingL(ETrkUsbDbgTrc));
        if (!error)
        {   
            TRAP(error, NotifyTheUserL());           
        } 
            if (iDebugMgrCallback)
                iDebugMgrCallback->DebugConnStatusChanged(iConnStatus);
        }       
}

//
//----------------------------------------------------
// CTrkDebugManager::ConnectionUnAvailable()
// Called when the usb cable is disconnected
//----------------------------------------------------
//
void CTrkDebugManager::ConnectionUnAvailable()
{   
    TTrkConnType connType = iTrkEngine->GetConnectionType();
    if(connType == ETrkUsbDbgTrc)
    {
        StopDebugging();
        TRAPD(error, StartDebuggingL(ETrkXti));
        if (!error)
        {   
            // Nothing to do for now                       
        }
        if (iDebugMgrCallback)
            iDebugMgrCallback->DebugConnStatusChanged(iConnStatus);
    }    
}

//
//----------------------------------------------------
// CTrkDebugManager::NotifyTheUser()
// To notify the user that debug services have started
//----------------------------------------------------
//
void CTrkDebugManager::NotifyTheUserL()
{
#ifndef __TEXT_SHELL__
    RLibrary library;
    // Dynamically load DLL
    TInt err = library.Load(KLibraryName);
    if(!err)
    {
        TLibraryFunction entry=library.Lookup(1);
        IDebugNotifier* notify =(IDebugNotifier*)entry();
        CleanupStack::PushL(notify);
        notify->NotifyTheUserL();
        CleanupStack::PopAndDestroy();
        // Finished with the DLL
        library.Close();
    }
#endif    
}
//
//----------------------------------------------------
// CTrkDebugManager::StopListening()
// To stop listening to cable connections
//----------------------------------------------------
//
void CTrkDebugManager::StopListening()
{    
#ifndef __TEXT_SHELL__
    if(iToolsConnectionListener)
    iToolsConnectionListener->StopListening();
#endif
}