/*

* 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:  S60 AppUi class

*

*/

#include <avkon.hrh>

#include <avkon.rsg> 

#include <AiwGenericParam.h>

#include <GenericParamConsumer.h>

#include <aknnavide.h>

#include <imageprintui.rsg>

#include <AknWaitDialog.h>

#include <f32file.h>

#include <s32file.h>

// #include <d32usbc.h>

#include <badesca.h>

#include <bautils.h>

#include <e32std.h>

#include <pathinfo.h> 

#include "imageprintui.hrh"

#include "imageprintuiappui.h"

#include "imageprintuidocument.h"

#include "emptyview.h"

#include "settingsview.h"

#include "imageprintuidebug.h"

#include "connectionmanager.h"

#include "capabilitymanager.h"

#include "requestmanager.h"

#include "eventmanager.h"

#include "notes.h"

#include "notetimer.h"

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

// ---------------------------------------------------------------------------

//  ConstructL()

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::ConstructL()

    {

    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::ConstructL()"));

    BaseConstructL( EAknEnableSkin | EAknEnableMSK );

    iEngine = static_cast<CImagePrintUiDocument*>(Document())->Engine();

    iImageFiles = new (ELeave) CDesCArrayFlat(KImageDefaultArray);

    iNotes = CNotes::NewL(this);

    iNoteShowed = EFalse;

    LoadImagesL();

    CAknView* emptyview = CEmptyView::NewLC();

    AddViewL(emptyview);

    CleanupStack::Pop(emptyview); 

    CAknView* settingsview = CSettingsView::NewLC();

    AddViewL(settingsview);

    CleanupStack::Pop(settingsview);

    ActivateLocalViewL( emptyview->Id() ); 

    iCableConnected = EFalse;

    iActiveNote = EFalse;

    iNumberOfUnSuppFiles = 0;

    iCapabilityChanged = EFalse;

    iPrintActive = EFalse;

    iErrorState = EFalse;

    iStartJobOK = EFalse;

    iPaperEmpty = EFalse;

    iNoteTimeOut = EFalse;

    iCloseTimeOut = EFalse;

    iCapabilityTimeOut = EFalse;

    iRequestTimeOut = EFalse;

    iNoteTimer = CNoteTimer::NewL(this);

    ReadNumberOfUnSuppL();

    iConnectionManager = CConnectionManager::NewL(this, iEngine, iNotes);

    iConnectionManager->StartSearchPrinter();

    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::ConstructL() complete"));

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CImagePrintUiAppUi::~CImagePrintUiAppUi()

    {

    delete iNaviDecorator;

    delete iCapabilityManager; 

    delete iRequestManager; 

    delete iEventManager;

    delete iConnectionManager; 

    delete iNoteTimer;    	

    delete iNotes;

    delete iImageFiles;

    }

// ---------------------------------------------------------------------------

// Handle global commands

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::HandleCommandL(TInt aCommand)

    {

    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::HandleCommandL()"));

    // Handle global events

    switch ( aCommand )

        {

        case EAknSoftkeyExit: 

        case EAknSoftkeyBack:

        case EAknCmdExit:

        case EEikCmdExit:

            {

            Exit(); 

            break;

            }

        default:

            break;

        }

    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::HandleCommandL() complete"));

    }

// ---------------------------------------------------------------------------

// Closes the application when the cable is disconnected or when some other

// mode is selected. 

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::CloseApplication(TBool aDisconnect)

	{

    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::CloseApplication"));

    iNotes->SetDisconnectState(aDisconnect);

    if(iPrintActive)

    	{

    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::CloseApplication show note"));

    	TRAP_IGNORE(iNotes->ShowErrorMsgL(R_ERROR_CONNECTION_LOST));

    	if(!iNoteTimer->IsActive())

    		iCloseTimeOut = ETrue;

    		iNoteTimer->After(KRetryClose);

    	}

    else

    	{

    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::CloseApplication just now"));

    	TRAPD(err, ProcessCommandL(EAknCmdExit));  

    	if(err)

    		{

    		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::error when CloseApplication"));

    		}

    	}

	}

// ---------------------------------------------------------------------------

// Closes the application after showing note

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::CloseAfterNoteL()

	{

	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::CloseAfterNoteL "));

	ProcessCommandL(EAknCmdExit);  

	}

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//	

void CImagePrintUiAppUi::NotifyPrintStatus(TInt aStatus)

	{

	FLOG(_L("[IMAGEPRINTUI]>>> CImagePrintUiAppUi::NotifyPrintStatus "));

	FTRACE(FPrint(_L("[IMAGEPRINTUI] CImagePrintUiAppUi  aStatus is %x"), aStatus ));

	FTRACE(FPrint(_L("[IMAGEPRINTUI] CImagePrintUiAppUi  aStatus is %d"), aStatus ));

	if(aStatus == EDpsPrintServiceStatusPrinting || aStatus == EDpsPrintServiceStatusIdle)

		{

		FLOG(_L("[IMAGEPRINTUI]>>> CImagePrintUiAppUi::NotifyPrintStatus set flag false "));

		iPaperEmpty = EFalse;

		}

	if(aStatus == EDpsPrintServiceStatusPrinting)

		{

		FLOG(_L("[IMAGEPRINTUI]>>> CImagePrintUiAppUi::Print status active "));

	    iPrintActive = ETrue;	

		}

	if(aStatus == EDpsPrintServiceStatusIdle)

		{

		FLOG(_L("[IMAGEPRINTUI]>>> CImagePrintUiAppUi::Print status idle"));

		iNotes->PrintProgress(KPrintFinishValue);   

	    iPrintActive = EFalse;	

		}

	FLOG(_L("[IMAGEPRINTUI]>>> CImagePrintUiAppUi::NotifyPrintStatus "));

	}

// ---------------------------------------------------------------------------

// 

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::NotifyPrintProgress(TInt aImagesPrinted, TInt aProgress)

	{

	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress"));

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi aImagesPrinted value is %d"), aImagesPrinted ));

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi aProgress value is %d"), aProgress ));

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi iNumberOfImages value is %d"), iNumberOfImages ));

    TInt realProgress;

    TUint currentlayout;

    currentlayout = iCapabilityManager->Layout();

	if(currentlayout == EDpsLayoutDefault || currentlayout == EDpsLayout1Up)

		{

		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress progress print"));

		if(iNumberOfImages == KImageNumber)

			{

			FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress layout case 1 image"));

			aImagesPrinted = aImagesPrinted*KPrintFinishValue;

			realProgress = aImagesPrinted/iNumberOfImages;

			realProgress = (realProgress <= KPrintFinishValue) ? realProgress : KPrintFinishValue;

			if(!iErrorState)	

				{

				FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress no error "));

			    iNotes->PrintProgress(realProgress);	

				}

			}

		if(iNumberOfImages > KImageNumber)

			{

			FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress one print image several images"));

			if(aProgress < KPrintFinishValue)

				{

				FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress one print image several images update"));

			    if(!iErrorState)

			    	{

			    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress no error state "));

			        iNotes->PrintProgress(aProgress); 	

			    	}

				}

			}

		}

	else

		{

		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress NumberOfImages print"));

		aImagesPrinted = aImagesPrinted*KPrintFinishValue;

		realProgress = aImagesPrinted/iNumberOfImages;

		realProgress = (realProgress <= KPrintFinishValue) ? realProgress : KPrintFinishValue;

		if(realProgress == KPrintFinishValue)

			{

			FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress printing done layout big"));

			}

		if(realProgress < KPrintFinishValue)

			{

			FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress show progress layout big"));

			if(!iErrorState)

				{

				FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress no error state"));

			    iNotes->PrintProgress(realProgress); 	

				}

		    else

		    	{

		    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::NotifyPrintProgress error state"));

		    	}

			}

		}

	}

// ---------------------------------------------------------------------------

// To inform about info from eventmanager

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::NotifyEventL( TInt aEventNotifyType)

	{

	FLOG(_L("[IMAGEPRINTUI] CImagePrintUiAppUi NotifyEvent start"));

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi aEventNotifyType is  %d"), aEventNotifyType ));

	switch(aEventNotifyType)

		{

        case CEventManager::ENewJobOK:

            FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> New job OK"));

            break;

        case CEventManager::ENewJobNOK: 

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> New job NOK"));

             iNotes->ShowErrorMsgL(R_ERROR_PRINTER_BUSY);

             break;    

        case CEventManager::ECapabilityChange:

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> Capability change"));

             TRAPD(err, iCapabilityManager->AskCapabilitiesL(ETrue));

             if(err)

             	{

             	iNotes->ShowErrorMsgL(R_ERROR_GENERAL);

             	}

             break; 

        case EDpsPaperJam: 

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi Paper Jam"));	 	

        	 iNotes->ShowErrorMsgL(R_ERROR_PAPER_JAM);

             break;  

        case EDpsPaperEmpty: 

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi Paper empty"));

        	 iPaperEmpty = ETrue;

        	 iNotes->ShowErrorMsgL(R_ERROR_OUT_OF_PAPER);

             break;       

        case CEventManager::EInkEmpty:

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi Ink empty"));

        	 iNotes->PrintFinished();	

        	 iNotes->ShowErrorMsgL(R_ERROR_OUT_OF_INK); 

             break;

        case EDpsInkLow: 

        	 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi Ink low"));	

        	 iNotes->ShowErrorMsgL(R_ERROR_INK_LOW);  

             break;   

		case EDpsJobStatusEndedOther: 

			 FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> User cancel from printer"));	

			 if(iPrintActive )

			 	{

			 	iNotes->PrintFinished();

				FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> User cancel print active"));

				iPrintActive = EFalse;

			 	}

			 break;	

        case EDpsJobStatusEndedOk: 

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi >>> Job eneded normally"));

        	break;

		case EDpsJobStatusEndedAbortImmediately: 

			FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  User aborted"));

			break;

		case EDpsErrorStatusFatal: 

		    FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  Fatal error in printer side"));

		    if(iPrintActive)

		    	{

		    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  Fatal error in printer side, stop progress note"));

		    	iNotes->PrintFinished();

		    	iPrintActive = EFalse;

		    	}

		    iNotes->ShowErrorMsgL(R_ERROR_CHECK_STATUS);

            break;

        case CEventManager::EWarning:

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  Warning in printer side"));

        	if(!iPaperEmpty)

        		{

        		if(iPrintActive)

			    	{

			    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  Warning in printer side, stop progress note"));

			    	iNotes->PrintFinished();

			    	iPrintActive = EFalse;

			    	}

			    	iNotes->ShowErrorMsgL(R_ERROR_CHECK_STATUS);

        		}

            break;

        case CEventManager::ENotErrorState:

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi,  Not Error State"));

        	iErrorState = EFalse;

        	break;

        case CEventManager::EErrorState:  

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi,  Error State"));

        	iErrorState = ETrue;

        	break;

        case CEventManager::EShowError:

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi, EShowError"));

        	if(iPrintActive)

		    	{

		    	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  EShowError in printer side, stop progress note"));

		    	iNotes->PrintFinished();

		    	iPrintActive = EFalse;

		    	}

        	iNotes->ShowErrorMsgL(R_ERROR_GENERAL);

        	break;

	// 	case KErrUsbInterfaceNotReady:

		// 	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi, KErrUsbInterfaceNotReady"));

			// break;

        default:

        	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi  NotifyEvent::Default branch"));  		

            break;   

		}

	}

// ---------------------------------------------------------------------------

// To inform about info from requestmanager

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::NotifyRequestL(TInt aNotifyType)

	{

	FLOG(_L("[IMAGEPRINTUI] CImagePrintUiAppUi NotifyRequest start"));

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi aNotifyType is  %d"), aNotifyType ));

	switch(aNotifyType)

		{

        case CRequestManager::EConfigurePrintServiceOK:

            FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EConfigurePrintServiceOK "));

            TRAPD(err, iCapabilityManager->AskCapabilitiesL(EFalse));

            if(err)

            	{

            	iNotes->ShowErrorMsgL(R_ERROR_GENERAL);

            	}

            break;

        case CRequestManager::EConfigurePrintServiceNOK:

             //printer does not support

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EConfigurePrintServiceNOK "));

             iNotes->ShowErrorMsgL(R_ERROR_UNABLE_TO_CONNECT); 

             break;    

        case CRequestManager::EGetJobStatusOK:

        	 FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EGetJobStatusOK "));	

             break; 

        case CRequestManager::EGetJobStatusNOK:

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EGetJobStatusNOK "));

             iNotes->ShowErrorMsgL(R_ERROR_GENERAL);  

             break;      

        case CRequestManager::EGetDeviceStatusOK:

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EGetDeviceStatusOK, start print "));

             break;

        case CRequestManager::EGetDeviceStatusNOK:

             // printer is busy

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EGetDeviceStatusNOK "));

             iNotes->ShowErrorMsgL(R_ERROR_PRINTER_BUSY); 

             break;  

        case CRequestManager::EStartJobOK:	

             //printing start ok

             FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi::EStartJobOK"));

             iPrintActive = ETrue;

             iStartJobOK = ETrue;

             FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi EStartJobOK  iPrintActiveis  %d"), iPrintActive ));

             break;

        case CRequestManager::EStartJobNOK:

             //printing start nok

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EStartJobNOK "));

             iNotes->ShowErrorMsgL(R_ERROR_GENERAL); 

             break;     

        case CRequestManager::EAbortJobOK:

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EAbortJobOK ")); 

             break; 

        case CRequestManager::EAbortJobNOK:

             iNotes->ShowErrorMsgL(R_ERROR_GENERAL); 

             CloseApplication(EFalse);

             FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EAbortJobNOK ")); 

             break;

        case CRequestManager::EPicturesNotFound:  

        	FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; EPicturesNotFound ")); 

        	iNotes->ShowErrorMsgL(R_ERROR_FILE_NOT_FOUND); 

        	break;

        default:

            FLOG(_L("[IMAGEPRINTUI]<<< CImagePrintUiAppUi NotifyRequest; Default branch")); 

            break;   

		}

	FLOG(_L("[IMAGEPRINTUI] CImagePrintUiAppUi NotifyRequest; END "));

	}

// ---------------------------------------------------------------------------

// To inform number of images

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::NumberOfImages(TInt aNumberOfImages)

	{

	FTRACE(FPrint(_L("[IMAGEPRINTUI]\t NumberOfImages iNumberOfImages  is %d"), iNumberOfImages));

	iNumberOfImages = aNumberOfImages;

	}

// ---------------------------------------------------------------------------

// To handle timer timeout

// ---------------------------------------------------------------------------

//

void CImagePrintUiAppUi::HandleTimeOutL()

	{

	FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi <<< HandleTimeOutL"));

	if(iNoteTimeOut)

		{

		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi <<< HandleTimeOutL, note"));

		iNoteTimeOut = EFalse;

		ShowNoteL(); 		

		}

	else if(iCloseTimeOut)

		{

		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi <<< HandleTimeOutL, close"));

		iCloseTimeOut = EFalse;

		CloseAfterNoteL();

		}

	else if(iCapabilityTimeOut)

		{

		FLOG(_L("[IMAGEPRINTUI]\t CImagePrintUiAppUi <<< HandleTimeOutL, capability"));

		iCapabilityTimeOut = EFalse;

		iCapabilityManager->AskCapabilitiesL(EFalse);

    	}

	else if(iRequestTimeOut)