ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupjobstate.cpp
changeset 0 d11fb78c4374
equal deleted inserted replaced
-1:000000000000 0:d11fb78c4374
       
     1 /*
       
     2 * Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Declares CUPJobState class
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include <e32math.h>
       
    20 
       
    21 #include "cupjobstate.h"
       
    22 #include "upconsts.h"
       
    23 #include "cupprintingjob.h"
       
    24 #include "cuplogger.h"
       
    25 
       
    26 //--------------------------------------------------------------------------------------------
       
    27 //
       
    28 // CUPJobState::NewL
       
    29 //
       
    30 //--------------------------------------------------------------------------------------------
       
    31 CUPJobState* CUPJobState::NewL()
       
    32 	{
       
    33 		CUPJobState *self = NewLC();
       
    34 		CleanupStack::Pop();	// self
       
    35 		
       
    36 		return self;
       
    37 	}
       
    38 
       
    39 //--------------------------------------------------------------------------------------------
       
    40 //
       
    41 // CUPJobState::NewLC
       
    42 //
       
    43 //--------------------------------------------------------------------------------------------
       
    44 CUPJobState* CUPJobState::NewLC()
       
    45 {
       
    46 		CUPJobState *self = new (ELeave) CUPJobState();
       
    47 		CleanupStack::PushL(self);
       
    48 		self->ConstructL();
       
    49 		
       
    50 		return self;
       
    51 }
       
    52 
       
    53 //--------------------------------------------------------------------------------------------
       
    54 //
       
    55 // CUPJobState::ConstructL
       
    56 //
       
    57 //--------------------------------------------------------------------------------------------
       
    58 void CUPJobState::ConstructL()
       
    59 {
       
    60 	LOG("[CUPFileParser]\t ConstructL");
       
    61 	Init();
       
    62 	InitErrorValues();
       
    63 }
       
    64 
       
    65 //--------------------------------------------------------------------------------------------
       
    66 //
       
    67 // CUPJobState::CUPJobState
       
    68 //
       
    69 //--------------------------------------------------------------------------------------------
       
    70 CUPJobState::~CUPJobState()
       
    71 {
       
    72 	Init();
       
    73 	iErrorValues.Reset();
       
    74 }
       
    75 
       
    76 //--------------------------------------------------------------------------------------------
       
    77 //
       
    78 // CUPJobState::Init
       
    79 //
       
    80 //--------------------------------------------------------------------------------------------
       
    81 void CUPJobState::Init()
       
    82 {
       
    83 	iSheetsCompleted = KErrNotFound;
       
    84 	iSheetsToPrint = 0; // cannot be negative for progress
       
    85 	iId.Copy(KNullDesC8());
       
    86 	iReason = ENoMessage;
       
    87 	iState = EStateUnknown;
       
    88 	iActiveId.Copy(KNullDesC8());
       
    89 	iEndState.Init();
       
    90 }
       
    91 
       
    92 //--------------------------------------------------------------------------------------------
       
    93 //
       
    94 // CUPJobState::InitErrorValues
       
    95 //
       
    96 //--------------------------------------------------------------------------------------------
       
    97 void CUPJobState::InitErrorValues()
       
    98 {
       
    99 	TMapError err;
       
   100 
       
   101 	err.iErrorCode = ENoMessage;
       
   102 	err.iErrorString.Set(KUPnPStateNone);
       
   103 	iErrorValues.Append(err);
       
   104 
       
   105 	err.iErrorCode = EPbCheckPrinter;
       
   106 	err.iErrorString.Set(KUPnPStateAttentionRequired);
       
   107 	iErrorValues.Append(err);
       
   108 
       
   109 	err.iErrorCode = EPbStatusErrorReasonPaperJam;
       
   110 	err.iErrorString.Set(KUPnPStateMediaJam);
       
   111 	iErrorValues.Append(err);
       
   112 
       
   113 	err.iErrorCode = EPbCheckPrinter;
       
   114 	err.iErrorString.Set(KUPnPStatePaused);
       
   115 	iErrorValues.Append(err);
       
   116 
       
   117 	err.iErrorCode = EPbStatusErrorReasonHardwareCoverOpen;
       
   118 	err.iErrorString.Set(KUPnPStateDoorOpen);
       
   119 	iErrorValues.Append(err);
       
   120 
       
   121 	err.iErrorCode = EPbStatusErrorReasonPaperNearlyEmpty;
       
   122 	err.iErrorString.Set(KUPnPStateMediaLow);
       
   123 	iErrorValues.Append(err);
       
   124 
       
   125 	err.iErrorCode = EPbStatusErrorReasonPaperEmpty;
       
   126 	err.iErrorString.Set(KUPnPStateMediaEmpty);
       
   127 	iErrorValues.Append(err);
       
   128 
       
   129 	err.iErrorCode = ENoMessage;
       
   130 	err.iErrorString.Set(KUPnPStateOutputAreaAlmostFull);
       
   131 	iErrorValues.Append(err);
       
   132 
       
   133 	err.iErrorCode = EPbCheckPrinter;
       
   134 	err.iErrorString.Set(KUPnPStateOutputAreaFull);
       
   135 	iErrorValues.Append(err);
       
   136 
       
   137 	err.iErrorCode = EPbStatusErrorReasonInkLow;
       
   138 	err.iErrorString.Set(KUPnPStateMarkerSupplyLow);
       
   139 	iErrorValues.Append(err);
       
   140 
       
   141 	err.iErrorCode = EPbStatusErrorReasonInkEmpty;
       
   142 	err.iErrorString.Set(KUPnPStateMarkerSupplyEmpty);
       
   143 	iErrorValues.Append(err);
       
   144 
       
   145 	err.iErrorCode = EPbStatusErrorReasonInk;
       
   146 	err.iErrorString.Set(KUPnPStateMarkerFailure);
       
   147 	iErrorValues.Append(err);
       
   148 
       
   149 	err.iErrorCode = EPbStatusErrorReasonPaperMedia;
       
   150 	err.iErrorString.Set(KUPnPStateMediaChangeRequest);
       
   151 	iErrorValues.Append(err);
       
   152 
       
   153 	err.iErrorCode = EPbCheckPrinter;
       
   154 	err.iErrorString.Set(KUPnPStateVendorDefined);
       
   155 	iErrorValues.Append(err);
       
   156 
       
   157 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   158 	err.iErrorString.Set(KUPnPJobStateCopies);
       
   159 	iErrorValues.Append(err);
       
   160 	
       
   161 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   162 	err.iErrorString.Set(KUPnPJobStateSides);
       
   163 	iErrorValues.Append(err);
       
   164 	
       
   165 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   166 	err.iErrorString.Set(KUPnPJobStateNumberUp);
       
   167 	iErrorValues.Append(err);
       
   168 	
       
   169 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   170 	err.iErrorString.Set(KUPnPJobStateOrientationRequested);
       
   171 	iErrorValues.Append(err);
       
   172 	
       
   173 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   174 	err.iErrorString.Set(KUPnPJobStateMediaSize);
       
   175 	iErrorValues.Append(err);
       
   176 	
       
   177 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   178 	err.iErrorString.Set(KUPnPJobStateMediaType);
       
   179 	iErrorValues.Append(err);
       
   180 	
       
   181 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   182 	err.iErrorString.Set(KUPnPJobStatePrintQuality);
       
   183 	iErrorValues.Append(err);
       
   184 	
       
   185 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   186 	err.iErrorString.Set(KUPnPJobStateTextLayout);
       
   187 	iErrorValues.Append(err);
       
   188 	
       
   189 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   190 	err.iErrorString.Set(KUPnPJobStateImageLayout);
       
   191 	iErrorValues.Append(err);
       
   192 	
       
   193 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   194 	err.iErrorString.Set(KUPnPJobStateImageOrientation);
       
   195 	iErrorValues.Append(err);
       
   196 	
       
   197 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   198 	err.iErrorString.Set(KUPnPJobStatePdlFidelity);
       
   199 	iErrorValues.Append(err);
       
   200 	
       
   201 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   202 	err.iErrorString.Set(KUPnPJobStateFontFamily);
       
   203 	iErrorValues.Append(err);
       
   204 	
       
   205 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   206 	err.iErrorString.Set(KUPnPJobStateFontSize);
       
   207 	iErrorValues.Append(err);
       
   208 
       
   209 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   210 	err.iErrorString.Set(KUPnPJobStateFormatError);
       
   211 	iErrorValues.Append(err);
       
   212 
       
   213 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   214 	err.iErrorString.Set(KUPnPJobStateHttpError);
       
   215 	iErrorValues.Append(err);
       
   216 
       
   217 	err.iErrorCode = EPbStatusErrorReasonHardware;
       
   218 	err.iErrorString.Set(KUPnPJobStateHwError);
       
   219 	iErrorValues.Append(err);
       
   220 
       
   221 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   222 	err.iErrorString.Set(KUPnPJobStateObjectFailure);
       
   223 	iErrorValues.Append(err);
       
   224 
       
   225 	err.iErrorCode = EPbStatusErrorReasonFile;
       
   226 	err.iErrorString.Set(KUPnPJobStateUriNotFound);
       
   227 	iErrorValues.Append(err);
       
   228 
       
   229 }
       
   230 
       
   231 //--------------------------------------------------------------------------------------------
       
   232 //
       
   233 // CUPJobState::GetErrorValue
       
   234 //
       
   235 //--------------------------------------------------------------------------------------------
       
   236 TInt CUPJobState::GetErrorValue(const TDesC8& aError)
       
   237 {
       
   238 	LOG81("[CUPJobState::GetErrorValue]\t  for: %S", &aError);
       
   239 	for (TInt i = 0; i < iErrorValues.Count();++i)
       
   240 	{
       
   241 		if(0 == aError.Compare(iErrorValues[i].iErrorString))
       
   242 		{
       
   243 //			LOG1("[CUPJobState::GetErrorValue]\t returns: %d", iErrorValues[i].iErrorCode);
       
   244 			return iErrorValues[i].iErrorCode;
       
   245 		}
       
   246 	}
       
   247 //	LOG("[CUPJobState::GetErrorValue]\t returns: EPbCheckPrinter");
       
   248 	return EPbCheckPrinter;
       
   249 }
       
   250 
       
   251 //--------------------------------------------------------------------------------------------
       
   252 //
       
   253 // CUPJobState::SetState
       
   254 //
       
   255 //--------------------------------------------------------------------------------------------
       
   256 void CUPJobState::SetState(TUPnPState aState)
       
   257 {
       
   258 	LOG1("[CUPJobState::SetState]\t %d", aState);
       
   259 
       
   260 	if(iActiveId.Length() < 1)
       
   261 	{
       
   262 		iState = EStateUnknown;
       
   263 		return;
       
   264 	}
       
   265 
       
   266 	// return if state is one of the terminating states
       
   267 	if(	EStateReady == iState ||	
       
   268 		EPrinterStateStopped == iState ||
       
   269 		EStatePending == iState ||
       
   270 		EJobStateAborted == iState ||
       
   271 		EJobStateCanceled == iState )
       
   272 		return;
       
   273 
       
   274 	switch ( aState )
       
   275 	{
       
   276 		case EPrinterStateStopped:
       
   277 		case EStatePending:
       
   278 		case EJobStateAborted:
       
   279 		case EJobStateCanceled:
       
   280 		case EStateReady:
       
   281 			Init();
       
   282 			iState = aState;
       
   283 			break;
       
   284 		case EStatePrinting:
       
   285 			iState = aState;
       
   286 			break;
       
   287 		case EJobStateSuccessful:
       
   288 			iState = EStatePrinting;
       
   289 			break;
       
   290 		default:
       
   291 			if(0 == iId.Compare(ActiveId()))
       
   292 			{
       
   293 				if(SheetsToPrint() == SheetsCompleted())
       
   294 					iState = EStateReady;
       
   295 				else if (EStateUnknown == iState)
       
   296 					iState = EStatePrinting;
       
   297 			}
       
   298 			break;
       
   299 	}
       
   300 }
       
   301 
       
   302 
       
   303 //--------------------------------------------------------------------------------------------
       
   304 //
       
   305 // CUPJobState::State
       
   306 //
       
   307 //--------------------------------------------------------------------------------------------
       
   308 TUPnPState CUPJobState::State()
       
   309 {
       
   310 //	LOG1("[CUPJobState::State]\t : %d",iState);
       
   311 	return iState;
       
   312 }
       
   313 
       
   314 //--------------------------------------------------------------------------------------------
       
   315 //
       
   316 // CUPJobState::SetActiveId
       
   317 //
       
   318 //--------------------------------------------------------------------------------------------
       
   319 void CUPJobState::SetActiveId(const TDesC8& aId)
       
   320 {
       
   321 	Init();
       
   322 	iActiveId.Copy(aId);
       
   323 }
       
   324 
       
   325 //--------------------------------------------------------------------------------------------
       
   326 //
       
   327 // CUPJobState::ActiveId
       
   328 //
       
   329 //--------------------------------------------------------------------------------------------
       
   330 TPtrC8 CUPJobState::ActiveId()
       
   331 {
       
   332 	return iActiveId;
       
   333 }
       
   334 
       
   335 //--------------------------------------------------------------------------------------------
       
   336 //
       
   337 // CUPJobState::SetSheetsCompleted
       
   338 //
       
   339 //--------------------------------------------------------------------------------------------
       
   340 void CUPJobState::SetSheetsCompleted(const TDesC8& aSheetsCompleted)
       
   341 {
       
   342 //	LOG1("[CUPJobState::SetSheetsCompleted]\t - at the beginning SheetsCompleted(): %d",SheetsCompleted());
       
   343 //	LOG8S("[CUPJobState::SetSheetsCompleted]\t - aSheetsCompleted: ",aSheetsCompleted);
       
   344 
       
   345 	if(EStateReady == State())
       
   346 	{
       
   347 		iSheetsCompleted = SheetsToPrint();
       
   348 		LOG1("[CUPJobState::SetSheetsCompleted]\t - State ready, set SheetsToPrint(): %d",SheetsToPrint());
       
   349 	}
       
   350 	else
       
   351 	{
       
   352 		TLex8 sheetsLex(aSheetsCompleted);
       
   353 		//Should here be an check about return value of Val??? /TTP
       
   354 		sheetsLex.Val(iSheetsCompleted);
       
   355 	}
       
   356 	LOG1("[CUPJobState::SetSheetsCompleted]\t - iSheetsCompleted: %d",SheetsCompleted());
       
   357 }
       
   358 
       
   359 //--------------------------------------------------------------------------------------------
       
   360 //
       
   361 // CUPJobState::SheetsCompleted
       
   362 //
       
   363 //--------------------------------------------------------------------------------------------
       
   364 TInt CUPJobState::SheetsCompleted()
       
   365 {
       
   366 	return iSheetsCompleted;
       
   367 }
       
   368 
       
   369 //--------------------------------------------------------------------------------------------
       
   370 //
       
   371 // CUPJobState::SetReason
       
   372 //
       
   373 //--------------------------------------------------------------------------------------------
       
   374 void CUPJobState::SetReason(TInt aReason)
       
   375 {
       
   376 	iReason = aReason;
       
   377 }
       
   378 
       
   379 //--------------------------------------------------------------------------------------------
       
   380 //
       
   381 // CUPJobState::Reason
       
   382 //
       
   383 //--------------------------------------------------------------------------------------------
       
   384 TInt CUPJobState::Reason()
       
   385 {
       
   386 	return iReason;
       
   387 }
       
   388 
       
   389 //--------------------------------------------------------------------------------------------
       
   390 //
       
   391 // CUPJobState::SetJobList
       
   392 //
       
   393 //--------------------------------------------------------------------------------------------
       
   394 TUPnPState CUPJobState::SetJobList(const TDesC8& aJobIdList)
       
   395 {
       
   396 	TInt pos = PendingJobId(aJobIdList);
       
   397 	if(1 < pos)
       
   398 		SetState(EStatePending);
       
   399 	else if (1 == pos)
       
   400 	{
       
   401 		iId = ActiveId();
       
   402 		SetState(EStatePrinting);
       
   403 	}
       
   404 	
       
   405 	return State();
       
   406 }
       
   407 
       
   408 //--------------------------------------------------------------------------------------------
       
   409 //
       
   410 // CUPJobState::SetSheetsToPrint
       
   411 //
       
   412 //--------------------------------------------------------------------------------------------
       
   413 void CUPJobState::SetSheetsToPrint(TInt aSheets)
       
   414 {
       
   415 	LOG1("[CUPJobState::SetSheetsToPrint]\t aSheets\t = %d", aSheets);
       
   416 	if(0 < aSheets)
       
   417 		iSheetsToPrint = aSheets;
       
   418 }
       
   419 
       
   420 //--------------------------------------------------------------------------------------------
       
   421 //
       
   422 // CUPJobState::SheetsToPrint
       
   423 //
       
   424 //--------------------------------------------------------------------------------------------
       
   425 TInt CUPJobState::SheetsToPrint()
       
   426 {
       
   427 //	LOG1("[CUPJobState::SheetsToPrint]\t iSheetsToPrint\t = %d", iSheetsToPrint);
       
   428 	return iSheetsToPrint;
       
   429 }
       
   430 
       
   431 //--------------------------------------------------------------------------------------------
       
   432 //
       
   433 // CUPJobState::Progress
       
   434 //
       
   435 //--------------------------------------------------------------------------------------------
       
   436 TInt CUPJobState::Progress(TInt aSheets)
       
   437 {
       
   438 	TInt percentage = 0;
       
   439 	if(State() == EStateReady)
       
   440 		percentage = 100;
       
   441 	else if(0 < SheetsCompleted() && 0 < aSheets)
       
   442 		percentage = (((SheetsCompleted() << 8) / aSheets) * 100) >> 8;
       
   443 	
       
   444 //	LOG1("[CUPJobState::Progress]\t SheetsCompleted()\t = %d", SheetsCompleted());
       
   445 //	LOG1("[CUPJobState::Progress]\t aSheets\t\t\t = %d", aSheets);
       
   446 	LOG1("[CUPJobState::Progress]\t percentage\t\t\t = %d%%", percentage);
       
   447 
       
   448 	return percentage;
       
   449 }
       
   450 
       
   451 //--------------------------------------------------------------------------------------------
       
   452 //
       
   453 // CUPJobState::Progress
       
   454 //
       
   455 //--------------------------------------------------------------------------------------------
       
   456 TInt CUPJobState::Progress()
       
   457 {
       
   458 	return Progress(SheetsToPrint());
       
   459 }
       
   460 
       
   461 //--------------------------------------------------------------------------------------------
       
   462 //
       
   463 // CUPJobState::UpdateJobState
       
   464 //
       
   465 //--------------------------------------------------------------------------------------------
       
   466 TUPnPState CUPJobState::UpdateJobState(const TDesC8& aPrinterState, const TDesC8& aReason, const TDesC8& aJobList, const TDesC8& aJobId, const TDesC8& aSheetsCompleted)
       
   467 {
       
   468 	LOG81("[CUPJobState::UpdateJobState]\t active job: %S", &(ActiveId()));
       
   469 
       
   470 	LOG81("[CUPJobState]\t - aPrinterState: %S", &aPrinterState);
       
   471 	LOG81("[CUPJobState]\t - aReason: %S", &aReason);
       
   472 	LOG81("[CUPJobState]\t - aJobList: %S", &aJobList);
       
   473 	LOG81("[CUPJobState]\t - aJobId: %S", &aJobId);
       
   474 	LOG81("[CUPJobState]\t - aSheetsCompleted: %S", &aSheetsCompleted);
       
   475 
       
   476 	SetReason(GetErrorValue(aReason));
       
   477 
       
   478 	//Set sheets for progress
       
   479 	SetSheetsCompleted(aSheetsCompleted);
       
   480 
       
   481 	// If printer state stopped, no reason to continue
       
   482 	if(KErrNotFound != aPrinterState.Find(KUPnPPrinterStateStopped()))
       
   483 	{
       
   484 		SetState(EPrinterStateStopped);
       
   485 		return State();
       
   486 	}
       
   487 
       
   488 	// If job is in the list, state is printing or pending. Else the job does not exist.
       
   489 	SetJobList(aJobList);
       
   490 	if(EStatePending == State())
       
   491 	{
       
   492 		SetReason(EPbStatusErrorReasonHardwarePrinterBusy);
       
   493 	}
       
   494 	else if(State() == EStatePrinting  && aJobId.Compare(ActiveId()) != 0 )
       
   495 	{
       
   496 		LOG82("[CUPJobState::State]\t - Ready: iState: %d, aJobId; %S",iState, &aJobId);
       
   497 		SetState(EStateReady);
       
   498 	}
       
   499 
       
   500 	return State();
       
   501 }
       
   502 
       
   503 //// PRIVATE ///
       
   504 
       
   505 
       
   506 //--------------------------------------------------------------------------------------------
       
   507 //
       
   508 // CUPJobState::CUPJobState
       
   509 //
       
   510 //--------------------------------------------------------------------------------------------
       
   511 CUPJobState::CUPJobState()
       
   512 {
       
   513 }
       
   514 
       
   515 //--------------------------------------------------------------------------------------------
       
   516 //
       
   517 // CUPJobState::PendingJobId
       
   518 //
       
   519 //--------------------------------------------------------------------------------------------
       
   520 TInt CUPJobState::PendingJobId(const TDesC8& aJobIdList)
       
   521 {
       
   522 	if(0 >= aJobIdList.Length())
       
   523 		return KErrNotFound;
       
   524 	
       
   525 	TInt count = 0;
       
   526 	TLex8 list(aJobIdList);
       
   527 
       
   528 	TLex8 idLex(ActiveId());
       
   529 	TInt activeId;
       
   530 	if (idLex.Val(activeId) != KErrNone)
       
   531 	{
       
   532 		return KErrArgument;
       
   533 	}
       
   534 
       
   535 	while(!list.Eos() && count < 50)
       
   536 	{
       
   537 		++count;
       
   538 		TInt val = KErrNotFound;
       
   539 		if(KErrNone == list.Val(val))
       
   540 		{
       
   541 			if(activeId == val)
       
   542 				return count;
       
   543 			else
       
   544 				list.Inc();
       
   545 		}
       
   546 	}
       
   547 	return KErrNotFound;
       
   548 }
       
   549 
       
   550 //--------------------------------------------------------------------------------------------
       
   551 //
       
   552 // CUPJobState::ParseState
       
   553 //
       
   554 //--------------------------------------------------------------------------------------------
       
   555 TUPnPState CUPJobState::ParseState(const TDesC8& aState)
       
   556 {
       
   557 	if(KErrNotFound != aState.Find(KUPnPJobStateSuccessful()))
       
   558 		return EJobStateSuccessful;
       
   559 	if(KErrNotFound != aState.Find(KUPnPJobStateAborted()))
       
   560 		return EJobStateAborted;
       
   561 	if(KErrNotFound != aState.Find(KUPnPJobStateCanceled()))
       
   562 		return EJobStateCanceled;
       
   563 	if(KErrNotFound != aState.Find(KUPnPPrinterStateIdle()))
       
   564 		return EPrinterStateIdle;
       
   565 	if(KErrNotFound != aState.Find(KUPnPPrinterStateProcessing()))
       
   566 		return EPrinterStateProcessing;
       
   567 	if(KErrNotFound != aState.Find(KUPnPPrinterStateStopped()))
       
   568 		return EPrinterStateStopped;
       
   569 
       
   570 	return EStateUnknown;
       
   571 }
       
   572 
       
   573 //--------------------------------------------------------------------------------------------
       
   574 //
       
   575 // CUPJobState::ParseJobEndStateL
       
   576 //
       
   577 //--------------------------------------------------------------------------------------------
       
   578 TInt CUPJobState::ParseJobEndStateL(const TDesC8& aJobEndState)
       
   579 {
       
   580 //	LOG("[CUPJobState::ParseJobEndState]\t");
       
   581 	iEndState.Init();
       
   582 	TInt res = KErrNotFound;
       
   583 
       
   584 	// Return if no data
       
   585 	if(1 > aJobEndState.Length())
       
   586 		return res;
       
   587 
       
   588 	// Parse current job and state from JobEndState
       
   589 	_LIT8(KSeparator, ",");
       
   590 	
       
   591 	RArray<TPtrC8> strings;
       
   592 	CleanupClosePushL(strings);
       
   593 	strings.Reset();
       
   594 	
       
   595 	TPtrC8 ptr(aJobEndState);
       
   596 	TInt pos = aJobEndState.Find(KSeparator());
       
   597 	while(KErrNotFound != pos)
       
   598 	{
       
   599 		strings.Append(ptr.Left(pos));
       
   600 		pos += KSeparator().Length();
       
   601 		ptr.Set(ptr.Right(ptr.Length() - pos));
       
   602 
       
   603 		pos = ptr.Find(KSeparator());
       
   604 		if(KErrNotFound == pos)
       
   605 			strings.Append(ptr);
       
   606 	}
       
   607 	
       
   608 	// Assign strings in member variables if current job's state
       
   609 	if(1 <= strings.Count() && 0 == strings[0].Compare(ActiveId()))
       
   610 	{
       
   611 		if(1 <= strings.Count())
       
   612 		{
       
   613 			iId.Copy(strings[0]);
       
   614 			iEndState.iId.Set(iId);
       
   615 		}
       
   616 		if(2 <= strings.Count())
       
   617 			iEndState.iJobName.Set(strings[1]);
       
   618 		if(3 <= strings.Count())
       
   619 			iEndState.iOriginator.Set(strings[2]);
       
   620 		if(4 <= strings.Count())
       
   621 		{
       
   622 			SetSheetsCompleted(strings[3]);
       
   623 			iEndState.iSheets = SheetsCompleted();
       
   624 		}
       
   625 		if(5 <= strings.Count())
       
   626 			iEndState.iState = ParseState(strings[4]);
       
   627 		if(6 <= strings.Count())
       
   628 			iEndState.iReason = GetErrorValue(strings[5]);
       
   629 
       
   630 		res = KErrNone;
       
   631 	}
       
   632 	CleanupStack::PopAndDestroy( &strings );
       
   633 
       
   634 	return res;
       
   635 
       
   636 }
       
   637 
       
   638 //--------------------------------------------------------------------------------------------
       
   639 //
       
   640 // CUPJobState::PrinterStateUpdated
       
   641 //
       
   642 //--------------------------------------------------------------------------------------------
       
   643 TUPnPState CUPJobState::PrinterStateUpdated( const TDesC8& aEvent )
       
   644 {
       
   645 	// If printer state not stopped, no reason to assign it
       
   646 	if(KErrNotFound < aEvent.Find(KUPnPPrinterStateStopped()))
       
   647 	{
       
   648 		SetState(EPrinterStateStopped);
       
   649 	}
       
   650 	return State();
       
   651 }
       
   652 
       
   653 //--------------------------------------------------------------------------------------------
       
   654 //
       
   655 // CUPJobState::PrinterStateReasonsUpdated
       
   656 //
       
   657 //--------------------------------------------------------------------------------------------
       
   658 TUPnPState CUPJobState::PrinterStateReasonsUpdated( const TDesC8& aEvent )
       
   659 {
       
   660 	SetReason(GetErrorValue(aEvent));
       
   661 	return State();
       
   662 }
       
   663 
       
   664 //--------------------------------------------------------------------------------------------
       
   665 //
       
   666 // CUPJobState::JobIdListUpdated
       
   667 //
       
   668 //--------------------------------------------------------------------------------------------
       
   669 TUPnPState CUPJobState::JobIdListUpdated( const TDesC8& aEvent )
       
   670 {
       
   671 	//Check if pending
       
   672 	SetJobList(aEvent);
       
   673 	if(EStatePending == State())
       
   674 	{
       
   675 		SetReason(EPbStatusErrorReasonHardwarePrinterBusy);
       
   676 	}
       
   677 	return State();
       
   678 }
       
   679 
       
   680 //--------------------------------------------------------------------------------------------
       
   681 //
       
   682 // CUPJobState::JobEndStateUpdated
       
   683 //
       
   684 //--------------------------------------------------------------------------------------------
       
   685 TUPnPState CUPJobState::JobEndStateUpdatedL( const TDesC8& aEvent )
       
   686 {
       
   687 	// init id
       
   688 	iId.Copy(KNullDesC8());
       
   689 
       
   690 	// Parse if contains data and for this job
       
   691 	TInt res = ParseJobEndStateL(aEvent);
       
   692 	if(KErrNotFound != res)
       
   693 	{
       
   694 		SetState(iEndState.iState);
       
   695 
       
   696 		// if any abort state updates never received, let's wait the one concerning this case
       
   697 		if(EJobStateAborted == iEndState.iState && iEndState.iAbortState)
       
   698 			return EStatePrinting;
       
   699 	}
       
   700 	return State();
       
   701 }
       
   702 
       
   703 //--------------------------------------------------------------------------------------------
       
   704 //
       
   705 // CUPJobState::JobMediaSheetsCompletedUpdated
       
   706 //
       
   707 //--------------------------------------------------------------------------------------------
       
   708 TUPnPState CUPJobState::JobMediaSheetsCompletedUpdated( const TDesC8& aEvent )
       
   709 {
       
   710 	JobMediaSheetsCompletedUpdated(iId, aEvent);
       
   711 	return State();
       
   712 }
       
   713 
       
   714 //--------------------------------------------------------------------------------------------
       
   715 //
       
   716 // CUPJobState::JobMediaSheetsCompletedUpdated
       
   717 //
       
   718 //--------------------------------------------------------------------------------------------
       
   719 TUPnPState CUPJobState::JobMediaSheetsCompletedUpdated(const TDesC8& aId, const TDesC8& aEvent )
       
   720 {
       
   721 	LOG82("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - aId: %S aEvent: %S", &aId, &aEvent);
       
   722 
       
   723 	// id matches to active id
       
   724 	if(0 == aId.Compare(ActiveId()))
       
   725 	{
       
   726 		SetSheetsCompleted(aEvent);
       
   727 
       
   728 		// -1 for unknown, 0 for pending or processing (or finished)
       
   729 		if( (-1 == SheetsCompleted()) || (0 == SheetsCompleted()) )
       
   730 		{
       
   731 			LOG81("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - aId:%S\t",&aId);
       
   732 		}
       
   733 		else if (SheetsToPrint() == SheetsCompleted())
       
   734 		{
       
   735 			LOG1("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - state ready -> SheetsToPrint(): %d",SheetsToPrint());
       
   736 			SetState(EStateReady);
       
   737 		}
       
   738 		else
       
   739 		{
       
   740 			LOG1("[CUPJobState::JobMediaSheetsCompletedUpdated]\t - state printing -> SheetsToPrint(): %d",SheetsToPrint());
       
   741 			SetState(EStatePrinting);
       
   742 		}
       
   743 	}
       
   744 
       
   745 	return State();	
       
   746 }
       
   747 
       
   748 //--------------------------------------------------------------------------------------------
       
   749 //
       
   750 // CUPJobState::ContentCompleteListUpdated
       
   751 //
       
   752 //--------------------------------------------------------------------------------------------
       
   753 TUPnPState CUPJobState::ContentCompleteListUpdated( const TDesC8& /*aEvent*/ )
       
   754 {
       
   755 	return State();
       
   756 }
       
   757 
       
   758 //--------------------------------------------------------------------------------------------
       
   759 //
       
   760 // CUPJobState::JobAbortStateUpdated
       
   761 //
       
   762 //--------------------------------------------------------------------------------------------
       
   763 TUPnPState CUPJobState::JobAbortStateUpdatedL( const TDesC8& aEvent )
       
   764 {
       
   765 	// Mark flag as true that any abort state messages never received
       
   766 	iEndState.iAbortState = ETrue;
       
   767 	
       
   768 	// Parse if contains data and for this job
       
   769 	TInt res = ParseJobEndStateL(aEvent);
       
   770 	if(KErrNotFound != res)
       
   771 	{
       
   772 		SetReason(iEndState.iReason);
       
   773 		SetState(iEndState.iState);
       
   774 	}
       
   775 
       
   776 	return State();
       
   777 }
       
   778 
       
   779 //  End of File