/*
* Copyright (c) 2002-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: Declares CUPJobState class
*
*/
#include <e32math.h>
#include "cupjobstate.h"
#include "upconsts.h"
#include "cupprintingjob.h"
#include "cuplogger.h"
//--------------------------------------------------------------------------------------------
//
// CUPJobState::NewL
//
//--------------------------------------------------------------------------------------------
CUPJobState* CUPJobState::NewL()
{
CUPJobState *self = NewLC();
CleanupStack::Pop(); // self
return self;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::NewLC
//
//--------------------------------------------------------------------------------------------
CUPJobState* CUPJobState::NewLC()
{
CUPJobState *self = new (ELeave) CUPJobState();
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::ConstructL
//
//--------------------------------------------------------------------------------------------
void CUPJobState::ConstructL()
{
LOG("[CUPFileParser]\t ConstructL");
Init();
InitErrorValues();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::CUPJobState
//
//--------------------------------------------------------------------------------------------
CUPJobState::~CUPJobState()
{
Init();
iErrorValues.Reset();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::Init
//
//--------------------------------------------------------------------------------------------
void CUPJobState::Init()
{
iSheetsCompleted = KErrNotFound;
iSheetsToPrint = 0; // cannot be negative for progress
iId.Copy(KNullDesC8());
iReason = ENoMessage;
iState = EStateUnknown;
iActiveId.Copy(KNullDesC8());
iEndState.Init();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::InitErrorValues
//
//--------------------------------------------------------------------------------------------
void CUPJobState::InitErrorValues()
{
TMapError err;
err.iErrorCode = ENoMessage;
err.iErrorString.Set(KUPnPStateNone);
iErrorValues.Append(err);
err.iErrorCode = EPbCheckPrinter;
err.iErrorString.Set(KUPnPStateAttentionRequired);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonPaperJam;
err.iErrorString.Set(KUPnPStateMediaJam);
iErrorValues.Append(err);
err.iErrorCode = EPbCheckPrinter;
err.iErrorString.Set(KUPnPStatePaused);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonHardwareCoverOpen;
err.iErrorString.Set(KUPnPStateDoorOpen);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonPaperNearlyEmpty;
err.iErrorString.Set(KUPnPStateMediaLow);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonPaperEmpty;
err.iErrorString.Set(KUPnPStateMediaEmpty);
iErrorValues.Append(err);
err.iErrorCode = ENoMessage;
err.iErrorString.Set(KUPnPStateOutputAreaAlmostFull);
iErrorValues.Append(err);
err.iErrorCode = EPbCheckPrinter;
err.iErrorString.Set(KUPnPStateOutputAreaFull);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonInkLow;
err.iErrorString.Set(KUPnPStateMarkerSupplyLow);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonInkEmpty;
err.iErrorString.Set(KUPnPStateMarkerSupplyEmpty);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonInk;
err.iErrorString.Set(KUPnPStateMarkerFailure);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonPaperMedia;
err.iErrorString.Set(KUPnPStateMediaChangeRequest);
iErrorValues.Append(err);
err.iErrorCode = EPbCheckPrinter;
err.iErrorString.Set(KUPnPStateVendorDefined);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateCopies);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateSides);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateNumberUp);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateOrientationRequested);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateMediaSize);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateMediaType);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStatePrintQuality);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateTextLayout);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateImageLayout);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateImageOrientation);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStatePdlFidelity);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateFontFamily);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateFontSize);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateFormatError);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateHttpError);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonHardware;
err.iErrorString.Set(KUPnPJobStateHwError);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateObjectFailure);
iErrorValues.Append(err);
err.iErrorCode = EPbStatusErrorReasonFile;
err.iErrorString.Set(KUPnPJobStateUriNotFound);
iErrorValues.Append(err);
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::GetErrorValue
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::GetErrorValue(const TDesC8& aError)
{
LOG81("[CUPJobState::GetErrorValue]\t for: %S", &aError);
for (TInt i = 0; i < iErrorValues.Count();++i)
{
if(0 == aError.Compare(iErrorValues[i].iErrorString))
{
// LOG1("[CUPJobState::GetErrorValue]\t returns: %d", iErrorValues[i].iErrorCode);
return iErrorValues[i].iErrorCode;
}
}
// LOG("[CUPJobState::GetErrorValue]\t returns: EPbCheckPrinter");
return EPbCheckPrinter;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetState
//
//--------------------------------------------------------------------------------------------
void CUPJobState::SetState(TUPnPState aState)
{
LOG1("[CUPJobState::SetState]\t %d", aState);
if(iActiveId.Length() < 1)
{
iState = EStateUnknown;
return;
}
// return if state is one of the terminating states
if( EStateReady == iState ||
EPrinterStateStopped == iState ||
EStatePending == iState ||
EJobStateAborted == iState ||
EJobStateCanceled == iState )
return;
switch ( aState )
{
case EPrinterStateStopped:
case EStatePending:
case EJobStateAborted:
case EJobStateCanceled:
case EStateReady:
Init();
iState = aState;
break;
case EStatePrinting:
iState = aState;
break;
case EJobStateSuccessful:
iState = EStatePrinting;
break;
default:
if(0 == iId.Compare(ActiveId()))
{
if(SheetsToPrint() == SheetsCompleted())
iState = EStateReady;
else if (EStateUnknown == iState)
iState = EStatePrinting;
}
break;
}
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::State
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::State()
{
// LOG1("[CUPJobState::State]\t : %d",iState);
return iState;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetActiveId
//
//--------------------------------------------------------------------------------------------
void CUPJobState::SetActiveId(const TDesC8& aId)
{
Init();
iActiveId.Copy(aId);
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::ActiveId
//
//--------------------------------------------------------------------------------------------
TPtrC8 CUPJobState::ActiveId()
{
return iActiveId;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetSheetsCompleted
//
//--------------------------------------------------------------------------------------------
void CUPJobState::SetSheetsCompleted(const TDesC8& aSheetsCompleted)
{
// LOG1("[CUPJobState::SetSheetsCompleted]\t - at the beginning SheetsCompleted(): %d",SheetsCompleted());
// LOG8S("[CUPJobState::SetSheetsCompleted]\t - aSheetsCompleted: ",aSheetsCompleted);
if(EStateReady == State())
{
iSheetsCompleted = SheetsToPrint();
LOG1("[CUPJobState::SetSheetsCompleted]\t - State ready, set SheetsToPrint(): %d",SheetsToPrint());
}
else
{
TLex8 sheetsLex(aSheetsCompleted);
//Should here be an check about return value of Val??? /TTP
sheetsLex.Val(iSheetsCompleted);
}
LOG1("[CUPJobState::SetSheetsCompleted]\t - iSheetsCompleted: %d",SheetsCompleted());
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SheetsCompleted
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::SheetsCompleted()
{
return iSheetsCompleted;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetReason
//
//--------------------------------------------------------------------------------------------
void CUPJobState::SetReason(TInt aReason)
{
iReason = aReason;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::Reason
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::Reason()
{
return iReason;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetJobList
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::SetJobList(const TDesC8& aJobIdList)
{
TInt pos = PendingJobId(aJobIdList);
if(1 < pos)
SetState(EStatePending);
else if (1 == pos)
{
iId = ActiveId();
SetState(EStatePrinting);
}
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SetSheetsToPrint
//
//--------------------------------------------------------------------------------------------
void CUPJobState::SetSheetsToPrint(TInt aSheets)
{
LOG1("[CUPJobState::SetSheetsToPrint]\t aSheets\t = %d", aSheets);
if(0 < aSheets)
iSheetsToPrint = aSheets;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::SheetsToPrint
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::SheetsToPrint()
{
// LOG1("[CUPJobState::SheetsToPrint]\t iSheetsToPrint\t = %d", iSheetsToPrint);
return iSheetsToPrint;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::Progress
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::Progress(TInt aSheets)
{
TInt percentage = 0;
if(State() == EStateReady)
percentage = 100;
else if(0 < SheetsCompleted() && 0 < aSheets)
percentage = (((SheetsCompleted() << 8) / aSheets) * 100) >> 8;
// LOG1("[CUPJobState::Progress]\t SheetsCompleted()\t = %d", SheetsCompleted());
// LOG1("[CUPJobState::Progress]\t aSheets\t\t\t = %d", aSheets);
LOG1("[CUPJobState::Progress]\t percentage\t\t\t = %d%%", percentage);
return percentage;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::Progress
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::Progress()
{
return Progress(SheetsToPrint());
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::UpdateJobState
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::UpdateJobState(const TDesC8& aPrinterState, const TDesC8& aReason, const TDesC8& aJobList, const TDesC8& aJobId, const TDesC8& aSheetsCompleted)
{
LOG81("[CUPJobState::UpdateJobState]\t active job: %S", &(ActiveId()));
LOG81("[CUPJobState]\t - aPrinterState: %S", &aPrinterState);
LOG81("[CUPJobState]\t - aReason: %S", &aReason);
LOG81("[CUPJobState]\t - aJobList: %S", &aJobList);
LOG81("[CUPJobState]\t - aJobId: %S", &aJobId);
LOG81("[CUPJobState]\t - aSheetsCompleted: %S", &aSheetsCompleted);
SetReason(GetErrorValue(aReason));
//Set sheets for progress
SetSheetsCompleted(aSheetsCompleted);
// If printer state stopped, no reason to continue
if(KErrNotFound != aPrinterState.Find(KUPnPPrinterStateStopped()))
{
SetState(EPrinterStateStopped);
return State();
}
// If job is in the list, state is printing or pending. Else the job does not exist.
SetJobList(aJobList);
if(EStatePending == State())
{
SetReason(EPbStatusErrorReasonHardwarePrinterBusy);
}
else if(State() == EStatePrinting && aJobId.Compare(ActiveId()) != 0 )
{
LOG82("[CUPJobState::State]\t - Ready: iState: %d, aJobId; %S",iState, &aJobId);
SetState(EStateReady);
}
return State();
}
//// PRIVATE ///
//--------------------------------------------------------------------------------------------
//
// CUPJobState::CUPJobState
//
//--------------------------------------------------------------------------------------------
CUPJobState::CUPJobState()
{
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::PendingJobId
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::PendingJobId(const TDesC8& aJobIdList)
{
if(0 >= aJobIdList.Length())
return KErrNotFound;
TInt count = 0;
TLex8 list(aJobIdList);
TLex8 idLex(ActiveId());
TInt activeId;
if (idLex.Val(activeId) != KErrNone)
{
return KErrArgument;
}
while(!list.Eos() && count < 50)
{
++count;
TInt val = KErrNotFound;
if(KErrNone == list.Val(val))
{
if(activeId == val)
return count;
else
list.Inc();
}
}
return KErrNotFound;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::ParseState
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::ParseState(const TDesC8& aState)
{
if(KErrNotFound != aState.Find(KUPnPJobStateSuccessful()))
return EJobStateSuccessful;
if(KErrNotFound != aState.Find(KUPnPJobStateAborted()))
return EJobStateAborted;
if(KErrNotFound != aState.Find(KUPnPJobStateCanceled()))
return EJobStateCanceled;
if(KErrNotFound != aState.Find(KUPnPPrinterStateIdle()))
return EPrinterStateIdle;
if(KErrNotFound != aState.Find(KUPnPPrinterStateProcessing()))
return EPrinterStateProcessing;
if(KErrNotFound != aState.Find(KUPnPPrinterStateStopped()))
return EPrinterStateStopped;
return EStateUnknown;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::ParseJobEndStateL
//
//--------------------------------------------------------------------------------------------
TInt CUPJobState::ParseJobEndStateL(const TDesC8& aJobEndState)
{
// LOG("[CUPJobState::ParseJobEndState]\t");
iEndState.Init();
TInt res = KErrNotFound;
// Return if no data
if(1 > aJobEndState.Length())
return res;
// Parse current job and state from JobEndState
_LIT8(KSeparator, ",");
RArray<TPtrC8> strings;
CleanupClosePushL(strings);
strings.Reset();
TPtrC8 ptr(aJobEndState);
TInt pos = aJobEndState.Find(KSeparator());
while(KErrNotFound != pos)
{
strings.Append(ptr.Left(pos));
pos += KSeparator().Length();
ptr.Set(ptr.Right(ptr.Length() - pos));
pos = ptr.Find(KSeparator());
if(KErrNotFound == pos)
strings.Append(ptr);
}
// Assign strings in member variables if current job's state
if(1 <= strings.Count() && 0 == strings[0].Compare(ActiveId()))
{
if(1 <= strings.Count())
{
iId.Copy(strings[0]);
iEndState.iId.Set(iId);
}
if(2 <= strings.Count())
iEndState.iJobName.Set(strings[1]);
if(3 <= strings.Count())
iEndState.iOriginator.Set(strings[2]);
if(4 <= strings.Count())
{
SetSheetsCompleted(strings[3]);
iEndState.iSheets = SheetsCompleted();
}
if(5 <= strings.Count())
iEndState.iState = ParseState(strings[4]);
if(6 <= strings.Count())
iEndState.iReason = GetErrorValue(strings[5]);
res = KErrNone;
}
CleanupStack::PopAndDestroy( &strings );
return res;
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::PrinterStateUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::PrinterStateUpdated( const TDesC8& aEvent )
{
// If printer state not stopped, no reason to assign it
if(KErrNotFound < aEvent.Find(KUPnPPrinterStateStopped()))
{
SetState(EPrinterStateStopped);
}
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::PrinterStateReasonsUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::PrinterStateReasonsUpdated( const TDesC8& aEvent )
{
SetReason(GetErrorValue(aEvent));
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::JobIdListUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::JobIdListUpdated( const TDesC8& aEvent )
{
//Check if pending
SetJobList(aEvent);
if(EStatePending == State())
{
SetReason(EPbStatusErrorReasonHardwarePrinterBusy);
}
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::JobEndStateUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::JobEndStateUpdatedL( const TDesC8& aEvent )
{
// init id
iId.Copy(KNullDesC8());
// Parse if contains data and for this job
TInt res = ParseJobEndStateL(aEvent);
if(KErrNotFound != res)
{
SetState(iEndState.iState);
// if any abort state updates never received, let's wait the one concerning this case
if(EJobStateAborted == iEndState.iState && iEndState.iAbortState)
return EStatePrinting;
}
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::JobMediaSheetsCompletedUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::JobMediaSheetsCompletedUpdated( const TDesC8& aEvent )
{
JobMediaSheetsCompletedUpdated(iId, aEvent);
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::JobMediaSheetsCompletedUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::JobMediaSheetsCompletedUpdated(const TDesC8& aId, const TDesC8& aEvent )
{
LOG82("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - aId: %S aEvent: %S", &aId, &aEvent);
// id matches to active id
if(0 == aId.Compare(ActiveId()))
{
SetSheetsCompleted(aEvent);
// -1 for unknown, 0 for pending or processing (or finished)
if( (-1 == SheetsCompleted()) || (0 == SheetsCompleted()) )
{
LOG81("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - aId:%S\t",&aId);
}
else if (SheetsToPrint() == SheetsCompleted())
{
LOG1("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - state ready -> SheetsToPrint(): %d",SheetsToPrint());
SetState(EStateReady);
}
else
{
LOG1("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - state printing -> SheetsToPrint(): %d",SheetsToPrint());
SetState(EStatePrinting);
}
}
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::ContentCompleteListUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::ContentCompleteListUpdated( const TDesC8& /*aEvent*/ )
{
return State();
}
//--------------------------------------------------------------------------------------------
//
// CUPJobState::JobAbortStateUpdated
//
//--------------------------------------------------------------------------------------------
TUPnPState CUPJobState::JobAbortStateUpdatedL( const TDesC8& aEvent )
{
// Mark flag as true that any abort state messages never received
iEndState.iAbortState = ETrue;
// Parse if contains data and for this job
TInt res = ParseJobEndStateL(aEvent);
if(KErrNotFound != res)
{
SetReason(iEndState.iReason);
SetState(iEndState.iState);
}
return State();
}
// End of File