/*
* 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:  Handles DpeEventNotify call with AO
*
*/



#include <e32base.h>
#include <dpsdefs.h>
#include <dpsparam.h>
#include <s32file.h>
#include <f32file.h>
#include <e32std.h>
#include <coemain.h>
#include <d32usbc.h>

#include "eventmanager.h"
#include "imageprintuidebug.h"
#include "pictbridge.h"
#include "imageprintuiappui.h"
 
 
// ---------------------------------------------------------------------------
//  constructor
// ---------------------------------------------------------------------------
//
CEventManager::CEventManager(CImagePrintUiAppUi* aAppUi, CDpsEngine* aDpsEngine)
    : CActive(CActive::EPriorityStandard), iAppUi(aAppUi),iDpsEngine(aDpsEngine),
      iErrorState(EFalse)
    {
    CActiveScheduler::Add(this);
    StartListening();
    }



// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CEventManager* CEventManager::NewL(CImagePrintUiAppUi* aAppUi, CDpsEngine* aDpsEngine)
    {
    CEventManager* self = new( ELeave ) CEventManager(aAppUi, aDpsEngine);
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CEventManager::~CEventManager()
    {
    Cancel();
    }

// ---------------------------------------------------------------------------
// Start listening events
// 
// ---------------------------------------------------------------------------
//
void CEventManager::StartListening()
	{
	FLOG(_L("[IMAGEPRINTUI]\t CEventManager::Start listening"));
	iDpsEngine->DpsEventNotify(iEventRequest, iStatus);
	SetActive();
	}
 	
// ---------------------------------------------------------------------------
// Handles situation depends on result after calling DpsEventNotify 
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleReturnStatusL()
	{
    FLOG(_L("[IMAGEPRINTUI]>>> CEventManager; HandleReturnStatus"));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager event value is %d"), iEventRequest.iEvent ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iPrintStatus is %x"), iEventRequest.iPrinterEvent.iRepParam.iPrintStatus ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iJobStatus is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobStatus ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iErrorStatus hex is %x"), iEventRequest.iPrinterEvent.iRepParam.iErrorStatus ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iJobEndReason is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iPaperMinor is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iPaperMinor ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iInkMinor is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iInkMinor ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iHardMinor is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iHardMinor ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iFileMinor is %x"), iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iFileMinor ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iDisconnectEnable is %d"), iEventRequest.iPrinterEvent.iRepParam.iDisconnectEnable ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iCapabilityChange is %d"), iEventRequest.iPrinterEvent.iRepParam.iCapabilityChange ));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager iNewJobOk is is %d"), iEventRequest.iPrinterEvent.iRepParam.iNewJobOk ));
    
    
	if(iEventRequest.iEvent == EDpsEvtNotifyJobStatus)	
		{
		FLOG(_L("[IMAGEPRINTUI]<<< CEventManager; NotifyPrintProgress"));
		FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager  iImagesPrinted is %d"), iEventRequest.iJobEvent.iRepParam.iImagesPrinted ));
		FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager  iProgress is %d"), iEventRequest.iJobEvent.iRepParam.iProgress ));
	    iAppUi->NotifyPrintProgress(iEventRequest.iJobEvent.iRepParam.iImagesPrinted, 
	                                 iEventRequest.iJobEvent.iRepParam.iProgress);
		}
		
	else if(iEventRequest.iEvent == EDpsEvtNotifyDeviceStatus)
		    {		    		    
		    FLOG(_L("[IMAGEPRINTUI]<<< CEventManager; HandleReturnStatus, EDpsEvtNotifyDeviceStatus"));
		    iAppUi->NotifyPrintStatus(iEventRequest.iPrinterEvent.iRepParam.iPrintStatus);
		    
		    HandleJobStatusL(iEventRequest.iPrinterEvent.iRepParam.iJobStatus);
		    
		    HandleErrorStatusL(iEventRequest.iPrinterEvent.iRepParam.iErrorStatus);
		    
		    if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorPaper)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::EDpsJobErrorPaper"));
				HandlePaperErrorL(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iPaperMinor);
				}
			else if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorInk)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::EDpsJobErrorInk"));
				HandleInkErrorL(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iInkMinor);
				}
			else if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorFile)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::EDpsJobErrorFile"));
				HandleFileErrorL(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iFileMinor);
				}
			else if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorHardware)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::EDpsJobErrorHardware"));
				HandleHardwareErrorL(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iHardMinor);
				}			
		    
		    if(iEventRequest.iPrinterEvent.iRepParam.iNewJobOk)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, NewJob is OK"));
				iAppUi->NotifyEventL(CEventManager::ENewJobOK );
		    	}
	        //capability change	
			else if(iEventRequest.iPrinterEvent.iRepParam.iCapabilityChange)
				{
				FLOG(_L("[IMAGEPRINTUI] CEventManager::capability change"));
				iAppUi->NotifyEventL(CEventManager::ECapabilityChange);
				}
		    }
    FLOG(_L("[IMAGEPRINTUI]<<< CEventManager; HandleReturnStatus, next call StartListening"));		    
	StartListening();
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleErrorStatusL(TInt aStatus)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleErrorStatusL"));
	if(aStatus  == EDpsErrorStatusOk)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, EDpsErrorStatusOk"));
	    iAppUi->NotifyEventL(CEventManager::ENotErrorState);
		}	
	else if(aStatus == EDpsErrorStatusFatal)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, Fatal error"));
		iAppUi->NotifyEventL(CEventManager::EErrorState);
		
		if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iInkMinor == EDpsInkEmpty ||
		   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iInkMinor == EDpsInkLow ||
		   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iPaperMinor == EDpsPaperJam )
			{
			FLOG(_L("[IMAGEPRINTUI] CEventManager Fatal error, don't show note"));
			}
		else if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorPaper ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorInk ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorHardware ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorFile )
			{
			FLOG(_L("[IMAGEPRINTUI] CEventManager error major, don't show note"));
			}
		 	
		else 
			{
			FLOG(_L("[IMAGEPRINTUI] CEventManager Fatal error, show note"));
		    iAppUi->NotifyEventL(EDpsErrorStatusFatal);	
			}		
		}
	else if(aStatus == EDpsErrorStatusWarning)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, Warning"));
		iAppUi->NotifyEventL(CEventManager::EErrorState);
				
	    if(iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorPaper ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorInk ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorHardware ||
    	   iEventRequest.iPrinterEvent.iRepParam.iJobEndReason.iMajor == EDpsJobErrorFile )
			{
			FLOG(_L("[IMAGEPRINTUI] CEventManager warning major, don't show note"));
			}
		else
			{
			FLOG(_L("[IMAGEPRINTUI] CEventManager warning,  show note"));
			iAppUi->NotifyEventL(CEventManager::EWarning);	
			}
		}	
	}
	
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleJobStatusL(TInt aStatus)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleJobStatusL"));
	if( aStatus == EDpsJobStatusEndedOther)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, User cancel from printer"));
		iAppUi->NotifyEventL(EDpsJobStatusEndedOther);
		}
		
	else if( aStatus  == EDpsJobStatusEndedOk)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, Job ended normally"));
		iAppUi->NotifyEventL(EDpsJobStatusEndedOk );
		}	
	else if( aStatus  == EDpsJobStatusEndedAbortImmediately)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleDeviceStatusL, User has abort job"));
		iAppUi->NotifyEventL(EDpsJobStatusEndedAbortImmediately);
		}	
	
	}
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleHardwareErrorL(TInt aError)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleHardwareErrorL"));
	 if( aError ==  EDpsHardFatal || aError ==  EDpsHardServiceCall ||
         aError ==  EDpsHardNotAvailable || aError ==  EDpsHardBusy || 
         aError ==  EDpsHardLever || aError ==  EDpsHardCoverOpen ||
         aError ==  EDpsHardNoMarkingHead || aError ==  EDpsHardInkCoverOpen ||
         aError ==  EDpsHardNoInkCartridge  )
		{
		FLOG(_L("[IMAGEPRINTUI]\t CEventManager::harware  minor"));
		iAppUi->NotifyEventL(CEventManager::EWarning);
		}	
	else 
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::Hardware major"));
		iAppUi->NotifyEventL(CEventManager::EShowError);
		} 		
	
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleInkErrorL(TInt aError)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleInkErrorL"));
	if(aError == EDpsInkEmpty)
	    {
		FLOG(_L("[IMAGEPRINTUI] CEventManager::ink empty"));
		iAppUi->NotifyEventL(CEventManager::EInkEmpty); 
		}
	else if(aError == EDpsInkLow )
	    {
	    FLOG(_L("[IMAGEPRINTUI] CEventManager::ink low"));
	    iAppUi->NotifyEventL(EDpsInkLow);	
	    }
	else if( aError== EDpsInkWaste)	
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::ink general"));
		iAppUi->NotifyEventL(CEventManager::EWarning);
		}
	else 
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager ink major,  show note"));
	    iAppUi->NotifyEventL(CEventManager::EShowError);	
		}
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandlePaperErrorL(TInt aError)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandlePaperErrorL"));
	
	if( aError == EDpsPaperLoad  || aError == EDpsPaperEject ||
	    aError == EDpsPaperMedia || aError == EDpsPaperNearlyEmpty ||
	    aError == EDpsPaperTypeSizeNoMatch ) 
		{
		FLOG(_L("[IMAGEPRINTUI]\t CEventManager::paperMinor, show warning"));
		iAppUi->NotifyEventL(CEventManager::EWarning);
		}
	else if( aError == EDpsPaperJam)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::Paper jam"));
		iAppUi->NotifyEventL(EDpsPaperJam);
		}
	else if( aError == EDpsPaperEmpty)
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::Paper empty"));
		iAppUi->NotifyEventL(EDpsPaperEmpty);
		}	
    else
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager paper major, show note"));
	    iAppUi->NotifyEventL(CEventManager::EShowError);	
		}		
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::HandleFileErrorL(TInt aError)
	{
	FLOG(_L("[IMAGEPRINTUI] CEventManager::HandleFileErrorL"));
	
	if(aError ==  EDpsFilePrintInfo ||
       aError ==  EDpsFileDecode  )
	    {
		FLOG(_L("[IMAGEPRINTUI] CEventManager::file minor"));
		iAppUi->NotifyEventL(CEventManager::EWarning);
		}	
	else
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::file major"));
		iAppUi->NotifyEventL(CEventManager::EShowError);
		}
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CEventManager::RunError()
    {
    FLOG(_L("[IMAGEPRINTUI] CEventManager::RunError"));
    
    StartListening();
    if(iStatus.Int() == KErrTimedOut)
    	{
    	FLOG(_L("[IMAGEPRINTUI]<<< CEventManager; RunError, timed out"));	
    	}
    else if( iStatus.Int() == KErrUsbInterfaceNotReady)	
		{
		FLOG(_L("[IMAGEPRINTUI] CEventManager::KErrUsbInterfaceNotReady"));
		// iAppUi->NotifyEventL(KErrUsbInterfaceNotReady);
		}		
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager::RunError iStatus is is %d"), iStatus.Int() ));
    // iAppUi->NotifyEventL(CEventManager::ESeriousError);
    }
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//	
void CEventManager::RunL()
    {
    FLOG(_L("[IMAGEPRINTUI]\t CEventManager::RunL"));
    FTRACE(FPrint(_L("[IMAGEPRINTUI]\t CEventManager::RunL iStatus   is %d"), iStatus.Int() ));
    if (iStatus.Int() == KErrNone)
		{
		FLOG(_L("[IMAGEPRINTUI]\t CEventManager::RunL no error"));
	    HandleReturnStatusL();
		}
	else
		{
		FLOG(_L("[IMAGEPRINTUI]\t CEventManager::RunL there is error in iStatus"));
		User::LeaveIfError(iStatus.Int());
		}
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CEventManager::DoCancel()
    {
    FLOG(_L("[IMAGEPRINTUI]>>> CEventManager  DoCancel"));
    iDpsEngine->CancelDpsEventNotify();
    FLOG(_L("[IMAGEPRINTUI]>>> CEventManager  DoCancel complete"));
    }