/*

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

*

*/

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <imageprintapp.rsg>

#include "cuiprotocolcontroller.h"

#include "muimodeobserver.h"

#include "ciffactory.h"

#include "midleprinteventregisterif.h"

#include "mdiscovery.h"

#include "mprintjob.h"

#include "mprintsettings.h"

#include "mdiscoveryobserver.h"

#include "tprinter.h"

#include "imgpprintapputil.h"

#include "ccustomnotedialog.h"

#include "clog.h"

const TInt KMMCID( 1 );

// CONSTRUCTOR

EXPORT_C CUIProtocolController* CUIProtocolController::NewL(

                       MProtocolObserver* aProtocolObserver,

                       CIFFactory& aIFFactory )

    {

    CUIProtocolController* self = NewLC( aProtocolObserver,

                                         aIFFactory );

    CleanupStack::Pop( self );

    return self;

    }

CUIProtocolController* CUIProtocolController::NewLC(

                       MProtocolObserver* aProtocolObserver,

                       CIFFactory& aIFFactory )

    {

    CUIProtocolController* self = new ( ELeave ) CUIProtocolController(

                                                 aProtocolObserver,

                                                 aIFFactory );

    CleanupStack::PushL( self );

    self->ConstructL( aIFFactory );

    return self;

    }

// Default constructor

CUIProtocolController::CUIProtocolController(

                       MProtocolObserver* aProtocolObserver,

                       CIFFactory& aIFFactory ) :

                       iProtocolObserver(aProtocolObserver)

    {

    iIFFactory = &aIFFactory;

    iClassState = ENormalState;

    iDiscoveryDlgManager = NULL;

    iStartUsb = EFalse;

    iWasUsbDisconnected = EFalse;

    }

// 2nd phase constructor

void CUIProtocolController::ConstructL( CIFFactory& aIFFactory )

    {

    iIdleEventRegister = aIFFactory.IdlePrintEventRegisterIF();

    // Register to receive idle event from engine

    iIdleEventRegister->RegisterObserver( this );

    iSettings = aIFFactory.SettingsIF();

    iDiscovery = aIFFactory.DiscoveryIF();

    }

// Destructor

CUIProtocolController::~CUIProtocolController()

    {

    if(iUSBConnectionWaitNote)

    {

      delete iUSBConnectionWaitNote;	

      iUSBConnectionWaitNote = NULL;

    }

    // Unregister from engine

    if ( iIdleEventRegister )

    	{

    	iIdleEventRegister->UnRegisterObserver( this );  	

    	}

	}

EXPORT_C TBool CUIProtocolController::SearchDefaultPrinterL()

    {

    LOG("CUIProtocolController::SearchDefaultPrinterL START");

    TBool retValue = EFalse;

    TInt defaultProtocol = -1;

	TBool usbOnlyMode = EFalse;

    // Get supported protocols from the engine

	TInt supportedProtocols = iIFFactory->DiscoveryIF()->SupportedProtocols();

	// If PictBridge is only supported protocol, set it as default

	if( !(supportedProtocols & KImagePrint_PrinterProtocol_BPP)  && 

    	!(supportedProtocols & KImagePrint_PrinterProtocol_DPOF) && 

    	!(supportedProtocols & KImagePrint_PrinterProtocol_UPnP) && 

     	(supportedProtocols & KImagePrint_PrinterProtocol_PictBridge) )

		{

		LOG("CUIProtocolController::SearchDefaultPrinterL: USB only mode detected");

		defaultProtocol = MDiscoveryObserver::EUSB;

		usbOnlyMode = ETrue;

		}

    // If usb is connected and PictBridge selected it will be used

    else if( iDiscovery->IsPictBridgeMode() > 0 )

        {

        defaultProtocol = MDiscoveryObserver::EUSB;

        }

    else // check default printer.

        {

        LOG("iSettings->GetDefaultPrinterProtocol()");

        defaultProtocol = iSettings->GetDefaultPrinterProtocol();

        LOG1("defaultProtocol = %d",defaultProtocol);

        }

   retValue = SetDefaultPrinterL( defaultProtocol );

   // If there is no default printer or default printer not available

   // start settings view with no printer information (but not in usb only mode)

   if( retValue == EFalse && usbOnlyMode == EFalse )

        {

        retValue = ETrue;

        iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::ENOPRINTER );

        iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::ENOPRINTER );

        HBufC* noPrinterText = StringLoader::LoadLC( R_PRINT_NO_PRINTER ); 

        iSettings->SetCurrentPrinterName( *noPrinterText );

        iSettings->SetDefaultPrinterNameL( *noPrinterText );

        CleanupStack::PopAndDestroy ( noPrinterText ); //noPrinterText        

        }

   if( iStartUsb )

        {

        iStartUsb = EFalse;

        defaultProtocol = MDiscoveryObserver::EUSB;

        retValue = SearchUSBPrinterL();

        if( retValue )

            {

            iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EUSB );

            // In USB case it also must be checked whether default printer is

            // set at this point, and if not, set USB as default. This is because

            // in normal cases usb overrides the default protocol without 

            // changing itself to default.

            TInt realDefault = iSettings->GetDefaultPrinterProtocol();

            if ( realDefault == KErrNotFound )

                {

                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EUSB );

                iSettings->SetDefaultPrinterNameL( *iSettings->GetCurrentPrinterName() );                	

                }

            }

        }

    LOG("CUIProtocolController::SearchDefaultPrinterL END");

    return retValue;

    }

TBool CUIProtocolController::SetDefaultPrinterL( TInt aDefaultProtocol )

	{

	 TBool retValue = EFalse;

	 switch( aDefaultProtocol )

	        {

	        case MDiscoveryObserver::EUSB:

	            {

	            retValue = SearchUSBPrinterL();

	            if( retValue )

	                {

	                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EUSB );

	                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EUSB );			

	                iSettings->SetDefaultPrinterNameL( *iSettings->GetCurrentPrinterName() );    

	                }

	            return retValue;

	            }

	        case MDiscoveryObserver::EBPP:

	            {

	            retValue = SearchDefaultBTPrinterL();

	            if( retValue )

	                {

	                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EBPP );

	                }

	            return retValue;

	            }

	        case MDiscoveryObserver::EOPP:            

	            {

	            retValue = SearchDefaultBTPrinterL();

	            if( retValue )

	                {

	                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EOPP );

	                }

	            return retValue;

	            }

	        case MDiscoveryObserver::EMMC:

	            {

	           retValue = SearchMMCPrinterL();

	            if( retValue )

	                {

	                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EMMC );

	                }

	            return retValue;

	            }

	        case MDiscoveryObserver::EWLAN:

	            {

	            retValue = SearchDefaultUPnPPrinterL();

	            if( retValue )

	                {

	                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EWLAN );

	                }

	            return retValue;

	            }

	        default:

	            {

	            return retValue;

	            }

	        }

	}

// Changes default printer

EXPORT_C TBool CUIProtocolController::ChangeDefaultPrinterL( TInt aProtocol )

    {

    LOG("CUIProtocolController::ChangeDefaultPrinterL START");

    TBool retValue;

	TInt previousDefaultProtocol = iSettings->GetDefaultPrinterProtocol();

	iSettings->SetDefaultPrinterProtocol( KErrNotFound );

	iClassState = EDiscoveryOngoing;

    switch( aProtocol )

        {

        case MDiscoveryObserver::EUSB:

            {

            retValue = SearchUSBPrinterL();

            if( retValue )

                {

                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EUSB );

                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EUSB );

                iSettings->SetDefaultPrinterNameL( *iSettings->GetCurrentPrinterName() );

                }

            break;

            }

        case MDiscoveryObserver::EBPP:

            {

            retValue = SearchBTPrinterL();

            if( retValue )

                {

                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EBPP );

                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EBPP );

                }

            break;

            }

        case MDiscoveryObserver::EMMC:

            {

            retValue = SearchMMCPrinterL();

            if( retValue )

                {

                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EMMC );

                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EMMC );

                }

            break;

            }

        case MDiscoveryObserver::EWLAN:

            {

            retValue = SearchUPnPPrinterL();

            if( retValue )

                {

                iSettings->SetDefaultPrinterProtocol( MDiscoveryObserver::EWLAN );

                iSettings->SetCurrentPrinterProtocol( MDiscoveryObserver::EWLAN );

                }

            break;

            }

        default:

            {

            // protocol not supported

            retValue = EFalse;

            break;

            }

        }

	if ( retValue == EFalse )

		{

		iSettings->SetDefaultPrinterProtocol( previousDefaultProtocol );

	    LOG1("CUIProtocolController::ChangeDefaultPrinterL iClassState == %d", iClassState);

		if ( iClassState == EUSBDisconnectedDuringDiscovery )

			{

			iClassState = ENormalState;

			UsbPrinterDisconnected();

			}

		else if( MDiscoveryObserver::EUSB == previousDefaultProtocol && iWasUsbDisconnected )

			{

		    LOG("CUIProtocolController::ChangeDefaultPrinterL nothing selected, but usb previously disconnected, discoverying");

			SearchDefaultPrinterL();

			}

		}

	iClassState = ENormalState;

    LOG("CUIProtocolController::ChangeDefaultPrinterL END");

    return retValue;

    }

TBool CUIProtocolController::SearchUSBPrinterL()

    {

    LOG("CUIProtocolController::SearchUSBPrinterL START");

    TBool retValue = EFalse;

    // if the cable is not physically connected, show connect usb cable note

    if( !IsUsbCableConnected() )

        {

        ShowConnectUsbCableNoteL();

        // Active scheduler is used here to make this method synchronous

        CActiveScheduler::Start();

        }

    // If usb cable is connected and pictbridge mode

    if( iDiscovery->IsPictBridgeMode() > 0 )

        {

        CDiscoveryDlgManager* discoveryDlgManager =

                              CDiscoveryDlgManager::NewLC( *iIFFactory );

        retValue = discoveryDlgManager->StartDlgManagerL(

                            KImagePrint_PrinterProtocol_PictBridge, ETrue );

        CleanupStack::PopAndDestroy( discoveryDlgManager );

        discoveryDlgManager = NULL;

        }

	LOG("CUIProtocolController::SearchUSBPrinterL END");

    return retValue;

    }

// Takes BT printer in use

TBool CUIProtocolController::SearchDefaultBTPrinterL()

    {

    LOG("CUIProtocolController::SearchDefaultBTPrinterL START");

    TBool retValue = EFalse;

    CDiscoveryDlgManager* discoveryDlgManager =

                          CDiscoveryDlgManager::NewLC( *iIFFactory );

    retValue = discoveryDlgManager->StartDlgManagerL( KAllBTProtocols, ETrue );

    CleanupStack::PopAndDestroy( discoveryDlgManager );

    discoveryDlgManager = NULL;

	LOG("CUIProtocolController::SearchDefaultBTPrinterL END");

    return retValue;

    }

// Takes mmc in use

TBool CUIProtocolController::SearchMMCPrinterL()

    {

    LOG("CUIProtocolController::SearchMMCPrinterL START");

    TBool retValue = EFalse;

    TInt err = iDiscovery->ChoosePrinterL( KMMCID );

    if( err == KErrNone)

        {

        LOG("Print job done succesfully with MMC DEFAULT PRINTER");

        // Set current printer name to be mmc

        HBufC* mmcText = StringLoader::LoadLC

                                  ( R_QTN_PRINT_MEMORY_CARD );

        iSettings->SetCurrentPrinterName( *mmcText );

        // Set vendor to none

        iSettings->SetCurrentPrinterVendor( TPrinter::EVendorNone );

        CleanupStack::PopAndDestroy(); //mmmcText

        retValue = ETrue;

        }

    LOG("CUIProtocolController::SearchMMCPrinterL END");

    return retValue;

    }

// Searches WLAN printers

TBool CUIProtocolController::SearchUPnPPrinterL()

    {

    LOG("CUIProtocolController::SearchUPnPPrinterL START");

    TBool retValue = EFalse;

    CDiscoveryDlgManager* discoveryDlgManager =

                          CDiscoveryDlgManager::NewLC( *iIFFactory );

    retValue = discoveryDlgManager->StartDlgManagerL( KImagePrint_PrinterProtocol_UPnP );

    CleanupStack::PopAndDestroy( discoveryDlgManager );

    discoveryDlgManager = NULL;

    LOG("CUIProtocolController::SearchUPnPPrinterL END");

    return retValue;

    }

// Takes WLAN printer in use

TBool CUIProtocolController::SearchDefaultUPnPPrinterL()

    {

    LOG("CUIProtocolController::SearchDefaultUPnPPrinterL START");

    TBool retValue = EFalse;

    CDiscoveryDlgManager* discoveryDlgManager =

                          CDiscoveryDlgManager::NewLC( *iIFFactory );

    retValue = discoveryDlgManager->StartDlgManagerL( KImagePrint_PrinterProtocol_UPnP, ETrue );

    CleanupStack::PopAndDestroy( discoveryDlgManager );

    discoveryDlgManager = NULL;

	LOG("CUIProtocolController::SearchDefaultUPnPPrinterL END");

    return retValue;

    }

TBool CUIProtocolController::SearchBTPrinterL()

    {

    LOG("CUIProtocolController::SearchBTPrinterL START");

    TBool retValue = EFalse;

    CDiscoveryDlgManager* discoveryDlgManager =

                          CDiscoveryDlgManager::NewLC( *iIFFactory );

    retValue = discoveryDlgManager->StartDlgManagerL( KAllBTProtocols );

    CleanupStack::PopAndDestroy( discoveryDlgManager );

    discoveryDlgManager = NULL;

    LOG("CUIProtocolController::SearchBTPrinterL END");

    return retValue;

    }

// Searches all supported protocols

TBool CUIProtocolController::FullSearchL()

    {

    LOG("CUIProtocolController::FullSearchL START");

    TBool retValue = EFalse;

    iDiscoveryDlgManager = CDiscoveryDlgManager::NewL( *iIFFactory );

    LOG("CUIProtocolController::FullSearchL before Fullsearch");

    retValue = iDiscoveryDlgManager->StartDlgManagerL();

    LOG("CUIProtocolController::FullSearchL after FullSearch");

    delete iDiscoveryDlgManager;

    iDiscoveryDlgManager = NULL;

    LOG("CUIProtocolController::FullSearchL END");

    return retValue;

    }

// Is the usb cable connected to phone or not

TBool CUIProtocolController::IsUsbCableConnected()

    {

    LOG("CUIProtocolController::IsUsbCableConnected START");

    TInt err = iUsbManager.Connect();

    if ( err == KErrNone )

    	{

	    iUsbManager.GetDeviceState( iDeviceState );

	    iUsbManager.Close();	

    	}

    else

    	{

	    LOG("CUIProtocolController::IsUsbCableConnected iUsbManager.Connect() FAIL");	

    	}

    LOG("CUIProtocolController::IsUsbCableConnected END");

    return ( iDeviceState != EUsbDeviceStateUndefined );

    }

void CUIProtocolController::ShowConnectUsbCableNoteL()

    {

    LOG("CUIProtocolController::ShowConnectUsbCableNote START");

    iUSBConnectionWaitNote = new (ELeave) CCustomNoteDialog(

	    reinterpret_cast< CEikDialog** > (&iUSBConnectionWaitNote) );

    iUSBConnectionWaitNote->SetCallback( this );

    iUSBConnectionWaitNote->ExecuteLD(R_CONNECT_USB);

    LOG("CUIProtocolController::ShowConnectUsbCableNote END");

    }

// MProgressDialogCallback method

void CUIProtocolController::DialogDismissedL(TInt /*aButtonId*/ )

    {

    LOG("CUIProtocolController::DialogDismissedL START");

    CActiveScheduler::Stop();

    LOG("CUIProtocolController::DialogDismissedL END");

    }

//Idle observer method

void CUIProtocolController::UsbPrinterDisconnected()

    {

    LOG("CUIProtocolController::UsbPrinterDisconnected START");

    if( iSettings->GetCurrentPrinterProtocol() == MDiscoveryObserver::EUSB )

        {

        LOG1("CUIProtocolController::UsbPrinterConnected iClassState is %d", iClassState);

        if ( iClassState == EDiscoveryOngoing || iClassState == EUSBDisconnectedDuringDiscovery )

        	{

        	iClassState = EUSBDisconnectedDuringDiscovery;

        	iWasUsbDisconnected = ETrue;

            LOG("CUIProtocolController::UsbPrinterConnected iClassState is now EUSBDisconnectedDuringDiscovery");

        	}

        else

        	{

	        iProtocolObserver->UsbCableDisconnected();        	

        	}

        }

    LOG("CUIProtocolController::UsbPrinterDisconnected END");

    }

//Idle observer method

void CUIProtocolController::UsbPrinterConnected()

    {

    LOG("CUIProtocolController::UsbPrinterConnected START");

    if( EUSBDisconnectedDuringDiscovery == iClassState )

    	{

    	iClassState = EDiscoveryOngoing;

        LOG("CUIProtocolController::UsbPrinterConnected iClassState is now EDiscoveryOngoing");

    	}

    if( iUSBConnectionWaitNote )    // Remove wait note and start discovery

        {

        delete iUSBConnectionWaitNote;

        iUSBConnectionWaitNote = NULL;

        }

    else

        {

        if(iDiscoveryDlgManager)

            {

            iStartUsb = ETrue;

            iDiscoveryDlgManager->CancelDiscovery();

            }

        }

    LOG("CUIProtocolController::UsbPrinterConnected END");

    }

//Idle observer method

void CUIProtocolController::UsbStateChanged( TImgPrintUSBState aState, TInt aError )

    {