diff -r 159fc2f68139 -r d59c248c9d36 ImagePrint/ImagePrintUI/imgpprintdll/src/cuiprotocolcontroller.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ImagePrint/ImagePrintUI/imgpprintdll/src/cuiprotocolcontroller.cpp	Wed Sep 01 12:30:38 2010 +0100
@@ -0,0 +1,558 @@
+/*
+* 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 )
+    {
+    LOG("CUIProtocolController::UsbStateChanged START");
+    if ( aState == ENOUSBEvent )
+    	{
+	    TRAP_IGNORE( IMGPPrintAppUtil::ShowErrorMsgL( aError ) );	
+    	}
+    LOG("CUIProtocolController::UsbStateChanged END");
+    }
+
+//Idle observer method
+void CUIProtocolController::ReadyToContinue()
+    {
+    LOG("CUIProtocolController::ReadyToContinue START");
+    LOG("CUIProtocolController::ReadyToContinue END");
+    }
+
+void CUIProtocolController::AsynchronousServerLeave( TInt /*aError*/ )
+	{
+	LOG("CUIProtocolController::AsynchronousServerLeave START");
+
+	// Cancel discovery in case of server leave. No can do if Cancel leaves.
+	LOG("CUIProtocolController::AsynchronousServerLeave CancelDeviceDiscoveryL()");
+	TRAP_IGNORE( iIFFactory->DiscoveryIF()->CancelDeviceDiscoveryL() );
+
+	// Cancel printing in case of server leave. No can do if Cancel leaves.
+	TRAP_IGNORE( iIFFactory->PrintJobIF()->CancelL() );
+    LOG("CUIProtocolController::AsynchronousServerLeave END");
+	}
+
+//  End of File