ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cprintercontrolpoint.cpp
/*
* 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 CPrinterControlPoint class
*
*/
#include <f32file.h>
#include <in_sock.h>
#include <upnpservice.h>
#include <upnpdevice.h>
#include <upnpaction.h>
#include <upnphttpmessagefactory.h>
#include "cuplogger.h"
#include "cprintercontrolpoint.h"
#include "mpcpobserver.h"
// CONSTANTS
#define KMaxCancelReqs 100
// -----------------------------------------------------------------------------
// CPrinterControlPoint::NewL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
EXPORT_C CPrinterControlPoint* CPrinterControlPoint::NewL(MPCPObserver& aPCPObserver)
{
LOG("[CPrinterControlPoint] \tCPrinterControlPoint::NewL");
CPrinterControlPoint* self = new (ELeave) CPrinterControlPoint( aPCPObserver);
CleanupStack::PushL( self );
self -> ConstructL( );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::CPrinterControlPoint
// C++ default constructor
// -----------------------------------------------------------------------------
//
CPrinterControlPoint::CPrinterControlPoint( MPCPObserver& aPCPObserver)
: CUpnpControlPoint(), iPCPObserver( aPCPObserver )
{
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::ConstructL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
void CPrinterControlPoint::ConstructL()
{
LOG("[CPrinterControlPoint] \tCPrinterControlPoint::ConstructL");
_LIT8( KPrinter, "Printer:1" );
// Base class ConstructL
CUpnpControlPoint::ConstructL( KPrinter());
// Share Xhtml folder (create if necessary)
RFs fsSession;
User::LeaveIfError( fsSession.Connect() );
CleanupClosePushL( fsSession );
TInt err = fsSession.MkDirAll( KUPnPXhtmlPath() );
if (err != KErrNone && err != KErrAlreadyExists)
{
User::Leave(err);
}
CleanupStack::PopAndDestroy(&fsSession);
iJobStateEvents = NULL;
// Start printer search
TPtrC8 device_ptr;
device_ptr.Set( KPrinterDevice );
SearchL( device_ptr );
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::~CPrinterControlPoint
// C++ default destructor
// -----------------------------------------------------------------------------
//
EXPORT_C CPrinterControlPoint::~CPrinterControlPoint()
{
LOG("[CPrinterControlPoint] \tCPrinterControlPoint::~CPrinterControlPoint()");
iCancelledJobSIDs.Close();
if(iJobStateEvents)
{
delete iJobStateEvents;
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::CreateJobL
// Create printer job
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CPrinterControlPoint::CreateJobL( CUpnpDevice* aPrinter, const TDesC8& aPrintFile,
const TDesC8& aUserName, const TDesC8& aCopies, const TDesC8& aSides,
const TDesC8& aNumberUp, const TDesC8& aOrientationRequest, const TDesC8& aMediaSize,
const TDesC8& aMediaType, const TDesC8& aPrintQuality, TBool aPrintBasic )
{
LOG("[CPrinterControlPoint] \tCPrinterControlPoint::CreateJobL");
if(!aPrinter)
{
User::Leave(KErrArgument);
}
if(iJobStateEvents)
{
iJobStateEvents->InitL();
}
else
{
iJobStateEvents = CJobStateEvents::NewL();
}
// Set printer as authorized device
// - remove the previous printer address from allowed list
// - add the current printer address to allowed list
TBuf8<20> logStr;
CUpnpHttpMessage::AddrOutput(aPrinter->Address(), logStr);
LOG81("[CPrinterControlPoint::CreateJobL]/t Printer address: %S", &logStr);
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if (serviceType == EServiceNone)
{
User::Leave(KErrNotSupported);
}
if (aPrintBasic)
{
// Force to use PrintBasic:1
serviceType = EPrintBasic;
}
// PrintBasic:1 or PrintEnhanced:1 supported
SubscribeL( service );
CUpnpAction* action;
// Create action according to service type
if (serviceType == EPrintEnhanced)
{
LOG("[CPrinterControlPoint] \t -PrintEnhanced:1 - CreateJobV2");
action = service->CreateActionLC( KCreateJobV2 );
}
else // serviceType == EPrintBasic
{
LOG("[CPrinterControlPoint] \t -PrintBasic:1 - CreateJob");
action = service->CreateActionLC( KCreateJob() );
}
User::LeaveIfNull(action);
// Common arguments for both action types
User::LeaveIfError(action -> SetArgumentL( KJobName, aPrintFile ));
User::LeaveIfError(action -> SetArgumentL( KUserName, aUserName));
User::LeaveIfError(action -> SetArgumentL( KDocFormat, KUPnPDocFormat() ));
User::LeaveIfError(action -> SetArgumentL( KCopies, aCopies ));
User::LeaveIfError(action -> SetArgumentL( KSides, aSides ));
User::LeaveIfError(action -> SetArgumentL( KNumberUp, aNumberUp ));
User::LeaveIfError(action -> SetArgumentL( KOrientationRequest, aOrientationRequest ));
User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));
User::LeaveIfError(action -> SetArgumentL( KType, aMediaType ));
User::LeaveIfError(action -> SetArgumentL( KQuality, aPrintQuality ));
if (serviceType == EPrintEnhanced)
{
// Fill in the rest arguments
User::LeaveIfError(action->SetArgumentL( KCriticalAttributes, KNullDesC8() ));
}
// Send action
SendL( action );
// return session id
TInt sessionId = action->SessionId();
CleanupStack::Pop(); // action
return sessionId;
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::PrintingFinishedL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::PrintingFinishedL( CUpnpDevice* aPrinter )
{
LOG("[CPrinterControlPoint::PrintingFinishedL] \t");
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if (serviceType == EServiceNone)
{
User::Leave(KErrNotSupported);
}
// Service is PrintBasic:1 or PrintEnhanced:1 - Unsubscribe
UnsubscribeL(service);
LOG("[CPrinterControlPoint::PrintingFinishedL] \t - unsubscribed... ...deleting event");
// init job state events
if ( iJobStateEvents )
{
iJobStateEvents->InitL();
}
// Remove last printer address from allowed list
LOG("[CPrinterControlPoint::PrintingFinishedL] \t - out");
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::CancelJobL
// Cancel printer job
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::CancelJobL( CUpnpDevice* aPrinter,
const TDesC8& aJobId )
{
LOG81("[CPrinterControlPoint] \tCPrinterControlPoint::CancelJobL %S", &aJobId);
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if (serviceType == EServiceNone)
{
User::Leave(KErrNotSupported);
}
// Service is PrintBasic:1 or PrintEnhanced:1
DoCancelJobL(*service, aJobId);
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::CancelJobL
// Cancel printer job by session id
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::CancelJobL( const TInt aSessionId )
{
LOG1("[CPrinterControlPoint::CancelJobL] \t by session id %d", aSessionId);
// Add id to cancelled jobs - nothing else to do at this point
// Actual cancelling is done when a message with this session id and job id is received from printer
iCancelledJobSIDs.AppendL(aSessionId);
// If number of pending cancel request exceeds KMaxCancelReqs delete the oldest request
if (iCancelledJobSIDs.Count() > KMaxCancelReqs)
{
iCancelledJobSIDs.Remove(0);
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::GetPrinterAttributesL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::GetPrinterAttributesL( CUpnpDevice* aPrinter )
{
LOG("[CPrinterControlPoint::GetPrinterAttributesL]");
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if (serviceType == EServiceNone)
{
User::Leave(KErrNotSupported);
}
if( serviceType == EPrintBasic )
{
CUpnpAction* action = service -> CreateActionLC( KGetPrinterAttr );
User::LeaveIfNull(action);
SendL( action );
CleanupStack::Pop(); // action
}
if( serviceType == EPrintEnhanced )
{
CUpnpAction* action = service -> CreateActionLC( KGetPrinterAttrV2 );
User::LeaveIfNull(action);
SendL( action );
CleanupStack::Pop(); // action
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::GetMarginsL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::GetMarginsL( CUpnpDevice* aPrinter, const TDesC8& aMediaSize, const TDesC8& aMediaType )
{
LOG("[CPrinterControlPoint::GetMarginsL]");
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if( serviceType == EPrintEnhanced )
{
CUpnpAction* action = service -> CreateActionLC( KGetMargins );
User::LeaveIfNull(action);
User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));
User::LeaveIfError(action -> SetArgumentL( KType, aMediaType));
SendL( action );
CleanupStack::Pop(); // action
}
else
{
User::Leave(KErrNotSupported);
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::GetMarginsL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::GetMediaListL( CUpnpDevice* aPrinter, const TDesC8& aMediaSize, const TDesC8& aMediaType )
{
LOG("[CPrinterControlPoint::GetMediaListL]");
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if( serviceType == EPrintEnhanced )
{
CUpnpAction* action = service -> CreateActionLC( KGetMediaList );
User::LeaveIfNull(action);
User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));
User::LeaveIfError(action -> SetArgumentL( KType, aMediaType));
SendL( action );
CleanupStack::Pop(); // action
}
else
{
User::Leave(KErrNotSupported);
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::GetJobAttributesL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::GetJobAttributesL( CUpnpDevice* aPrinter,
const TDesC8& aJobId )
{
LOG("[CPrinterControlPoint::GetJobAttributesL]");
// Check services
TPrintService serviceType;
CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );
if (serviceType == EServiceNone)
{
User::Leave(KErrNotSupported);
}
CUpnpAction* action = service -> CreateActionLC( KGetJobAttr );
User::LeaveIfNull(action);
User::LeaveIfError(action -> SetArgumentL( KJobId, aJobId ));
SendL( action );
CleanupStack::Pop(); // action
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::StateUpdatedL
// From ControlPoint
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::StateUpdatedL( CUpnpService* aService )
{
// Seven evented state variables (see PrintEnhanced:1 and PrintBasic:1 specification for details):
// PrinterState, PrinterStateReasons, JobIdList, JobEndState,
// JobMediaSheetsConpleted, JobAbortState and ContentCompleteList
// JobEndState == JobId,JobName,JobOriginatingUser,
// JobMediaSheetsConpleted,job-completion-state
LOG("[CPrinterControlPoint::StateUpdatedL]");
User::LeaveIfNull(aService);
JobStateLog(aService);
CUpnpStateVariable* prntState = aService->StateVariable( KPrinterState() );
CUpnpStateVariable* prntStateReasons = aService->StateVariable( KPrinterStateReasons() );
CUpnpStateVariable* jobIdList = aService->StateVariable( KJobIdList() );
CUpnpStateVariable* jobEndState = aService->StateVariable( KJobEndState() );
CUpnpStateVariable* sheets = aService->StateVariable( KSheetsCompleted() );
// The next ones are supported only in PrintEnhanced:1
CUpnpStateVariable* jobAbortState = aService->StateVariable( KJobAbortState() );
CUpnpStateVariable* contentCompList = aService->StateVariable( KContentCompleteList() );
if ( iJobStateEvents )
{
if( prntState )
{
TPtrC8 ptr = RemoveTags( prntState->Value());
if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EPrinterState))
iPCPObserver.PrinterStateUpdated( ptr );
}
if ( prntStateReasons )
{
TPtrC8 ptr = RemoveTags( prntStateReasons->Value());
if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EPrinterStateReasons))
iPCPObserver.PrinterStateReasonsUpdated( ptr );
}
if ( jobIdList )
{
TPtrC8 ptr = RemoveTags( jobIdList->Value());
if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobIdList))
iPCPObserver.JobIdListUpdated( ptr );
}
if ( jobEndState )
{
TPtrC8 ptr = RemoveTags( jobEndState->Value());
if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobEndState))
iPCPObserver.JobEndStateUpdated( ptr );
}
if ( sheets )
{
TPtrC8 ptr = RemoveTags( sheets->Value());
if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EJobMediaSheetsCompleted))
iPCPObserver.JobMediaSheetsCompletedUpdated( ptr );
}
if ( jobAbortState )
{
TPtrC8 ptr = RemoveTags( jobAbortState->Value());
if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EContentCompleteList))
iPCPObserver.JobAbortStateUpdated( ptr );
}
if ( contentCompList )
{
TPtrC8 ptr = RemoveTags( contentCompList->Value());
if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobAbortState))
iPCPObserver.ContentCompleteListUpdated( ptr );
}
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DeviceDiscoveredL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::DeviceDiscoveredL( CUpnpDevice* aDevice)
{
LOG("[CPrinterControlPoint::DeviceDiscoveredL]");
iPCPObserver.DeviceDiscoveredL( aDevice );
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DeviceDisappearedL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::DeviceDisappearedL( CUpnpDevice* aDevice )
{
LOG("[CPrinterControlPoint::DeviceDisappearedL]");
iPCPObserver.DeviceDisappeared( aDevice );
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::ActionResponseReceivedL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::ActionResponseReceivedL( CUpnpAction* aAction )
{
User::LeaveIfNull(aAction);
LOG8S("[CPrinterControlPoint::ActionResponseReceivedL]\t - action: ", aAction->Name());
// First check out for pending cancel responses (ie. cancel requestes with session id)
TInt sessionId = aAction->SessionId();
TInt index = iCancelledJobSIDs.Find(sessionId);
if ( index >= 0 )
{
// Cancel requested for this session's job
const TDesC8& jobId = aAction->ArgumentValue( KJobId() );
if (jobId.Length() > 0)
{
LOG("[CPrinterControlPoint::ActionResponseReceivedL] \t - Executing session id based canceling");
DoCancelJobL( aAction->Service(), jobId);
// Remove "queued" cancel job's session id from array
iCancelledJobSIDs.Remove(index);
// No need to handle create job responses for this job id since it was canceled
if(( aAction->Name().Compare( KCreateJob ) == 0 ) ||
( aAction->Name().Compare( KCreateURIJob ) == 0))
{
return;
}
}
}
TInt err = KErrNone;
if( EHttp200Ok != aAction->Error() )
{
err = aAction->Error();
}
// Check CreateJobResponse
if( aAction->Name().Compare( KCreateJob ) == 0 || aAction->Name().Compare( KCreateJobV2 ) == 0 )
{
if( KErrNone == err )
{
const TDesC8& jobName = aAction->ArgumentValue( KJobName() );
const TDesC8& dataSinkUrl = aAction->ArgumentValue( KDataSink() );
// Send XHTML-print data (print data) via HTTP POST
LOG("[CPrinterControlPoint] \t - Sending XHTML-print data via HTTP POST");
TInetAddr addr;
CUpnpHttpMessage::AddrInput(addr, DataSinkUrlAddress( dataSinkUrl ));
addr.SetPort( DataSinkUrlPort( dataSinkUrl ) );
CUpnpHttpMessage* printDataMessage;
//CUpnpHttpMessage* printPictureMessage;
printDataMessage = RUpnpHttpMessageFactory::HttpPostL( addr, DataSinkUrlPath( dataSinkUrl ) );
//printPictureMessage = RUpnpHttpMessageFactory::HttpPostL( addr, DataSinkUrlPath( dataSinkUrl ) );
TFileName8 filePath;
filePath.Copy( KUPnPXhtmlPath() );
filePath.Append(jobName);
printDataMessage->SetOutFilenameL( filePath );
TRAP(err, SendL( printDataMessage ));
}
iPCPObserver.CreateJobResponse( aAction, err );
LOG1("[CPrinterControlPoint] \t - HTTP POST returns: %d", err);
}
else if( aAction->Name().Compare( KCreateURIJob ) == 0 )
{
iPCPObserver.CreateJobResponse( aAction, err );
}
else if( aAction->Name().Compare( KCancelJob ) == 0 )
{
iPCPObserver.CancelJobResponse( aAction, err );
}
else if( aAction->Name().Compare( KGetPrinterAttr ) == 0 )
{
iPCPObserver.GetPrinterAttributesResponse( aAction, err );
}
else if( aAction->Name().Compare( KGetPrinterAttrV2 ) == 0 )
{
iPCPObserver.GetPrinterAttributesResponse( aAction, err );
}
else if( aAction->Name().Compare( KGetJobAttr ) == 0 )
{
iPCPObserver.GetJobAttributesResponse( aAction, err );
}
else if( aAction->Name().Compare( KGetMargins ) == 0 )
{
iPCPObserver.GetMarginsResponse( aAction, err );
}
else if( aAction->Name().Compare( KGetMediaList ) == 0 )
{
iPCPObserver.GetMediaListResponse( aAction, err );
}
else
{
//to avoid lint error
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::HttpResponseReceivedL
// -----------------------------------------------------------------------------
//
EXPORT_C void CPrinterControlPoint::HttpResponseReceivedL(
CUpnpHttpMessage* aMessage )
{
LOG("[CPrinterControlPoint::HttpResponseReceivedL] \t");
if(aMessage)
{
LOG1( "[CPrinterControlPoint] \t - HTTP Response: %d", aMessage->Error() );
}
}
// private functions
// -----------------------------------------------------------------------------
// CPrinterControlPoint::GetServiceFromDevice
// -----------------------------------------------------------------------------
//
CUpnpService* CPrinterControlPoint::GetServiceFromDevice( CUpnpDevice* aPrinter, TPrintService& aService )
{
LOG("[CPrinterControlPoint::GetServiceFromDevice]");
CUpnpService* service = NULL;
aService = EServiceNone;
if(!aPrinter)
{
return service;
}
const RPointerArray<CUpnpDevice>& devices = DeviceList();
//Search of printer device
for( TInt i = 0; i < devices.Count(); i++ )
{
if( devices[i]->DeviceType().Compare( aPrinter->DeviceType() ) == 0 &&
devices[i]->Uuid().Compare( aPrinter->Uuid() ) == 0 )
{
// Printer found - search of services
RPointerArray<CUpnpService>& services = devices[i]->ServiceList();
for( TInt j = 0; j < services.Count(); j++ )
{
//PrintBasic:1
if( services[j]->ServiceType().Compare( KPrintBasic ) == 0 )
{
aService = EPrintBasic;
service = services[j];
continue; // Continue to search for PrintEnhanced:1
}
// PrintEnhanced:1
if( services[j]->ServiceType().Compare( KPrintEnhanced ) == 0 )
{
aService = EPrintEnhanced;
service = services[j];
break;
}
}
break;
}
}
return service;
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DataSinkUrlAddress
// -----------------------------------------------------------------------------
//
const TPtrC8 CPrinterControlPoint::DataSinkUrlAddress( const TDesC8& aDataSinkUrl )
{
LOG("[CPrinterControlPoint::DataSinkUrlAddress] \t");
if ( aDataSinkUrl.Length() > UpnpHTTP::KHTTPUrl().Length() )
{
TPtrC8 addrAndPath = aDataSinkUrl.Right(aDataSinkUrl.Length()-UpnpHTTP::KHTTPUrl().Length());
TInt index = addrAndPath.Find( KUPnPColon() );
if ( index == KErrNotFound )
{
index = addrAndPath.Find( KUPnPSlash() );
}
if ( index == KErrNotFound )
{
return TPtrC8( KNullDesC8().Ptr(), 0);
}
TPtrC8 addr = addrAndPath.Left( index );
return addr;
}
return TPtrC8( KNullDesC8().Ptr(), 0);
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DataSinkUrlPath
// -----------------------------------------------------------------------------
//
const TPtrC8 CPrinterControlPoint::DataSinkUrlPath( const TDesC8& aDataSinkUrl )
{
LOG("[CPrinterControlPoint::DataSinkUrlPath] \t");
if ( aDataSinkUrl.Length() > KHttpPrefix().Length() )
{
TPtrC8 addrAndPath = aDataSinkUrl.Right(aDataSinkUrl.Length()-KHttpPrefix().Length());
TPtrC8 addr;
// Find slash from URL and remove it, if it exists.
TInt index = addrAndPath.Find( KUPnPSlash() );
// If not found, assume that path is right as is
if ( index == KErrNotFound )
{
addr.Set( addrAndPath.Right( addrAndPath.Length() ) );
}
// Slash found, copy data after it
else
{
addr.Set( addrAndPath.Right( addrAndPath.Length() - index ) );
}
return addr;
}
else
{
return TPtrC8( KNullDesC8().Ptr(), 0);
}
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DataSinkUrlPort
//
// -----------------------------------------------------------------------------
//
TInt CPrinterControlPoint::DataSinkUrlPort( const TDesC8& aDataSinkUrl )
{
LOG("[CPrinterControlPoint::DataSinkUrlPort] \t");
if (aDataSinkUrl.Length() > KHttpPrefix().Length())
{
TPtrC8 addrAndPath = aDataSinkUrl.Right(aDataSinkUrl.Length()-KHttpPrefix().Length());
TInt separIndex = addrAndPath.Find( KUPnPColon );
if ( separIndex == KErrNotFound )
{
return KDefaultHttpPortNumber;
}
TInt slashIndex = addrAndPath.Find( KUPnPSlash() );
if ( slashIndex != -1 )
{
TPtrC8 port = addrAndPath.Mid( separIndex+1, slashIndex-separIndex );
TLex8 lex( port );
TInt prt;
lex.Val( prt );
return prt;
}
else
{
TPtrC8 port = addrAndPath.Right( addrAndPath.Length()-separIndex-1 );
TLex8 lex( port );
TInt prt;
lex.Val( prt );
return prt;
}
}
return KDefaultHttpPortNumber;
}
// -----------------------------------------------------------------------------
// CPrinterControlPoint::DoCancelJobL
//
// -----------------------------------------------------------------------------
//
void CPrinterControlPoint::DoCancelJobL(CUpnpService& aService, const TDesC8& aJobId)
{
LOG("[CPrinterControlPoint::DoCancelJobL]");
CUpnpAction* action = aService.CreateActionLC( KCancelJob );
User::LeaveIfNull(action);
User::LeaveIfError(action->SetArgumentL( KJobId, aJobId ));
SendL( action );
CleanupStack::Pop(); // action
}
//--------------------------------------------------------------------------------------------
//
// CPrinterControlPoint::RemoveTags
//
//--------------------------------------------------------------------------------------------
TPtrC8 CPrinterControlPoint::RemoveTags( const TDesC8& aString)
{
LOG("[CPrinterControlPoint::RemoveTags]\t");
_LIT8(KUPnPStartTag, ">");
_LIT8(KUPnPEndTag, "</");
_LIT8(KUPnPEmptyTag, "<*/>");
TPtrC8 midPtr;
midPtr.Set(aString);
// Return if no tags
TInt startPos = aString.Find(KUPnPStartTag());
if(KErrNotFound == startPos)
{
return midPtr;
}
// Return if empty
if(KErrNotFound < aString.Match(KUPnPEmptyTag()))
{
return TPtrC8( KNullDesC8().Ptr(), 0);
}
// Return the mid of tags
startPos += KUPnPStartTag().Length();
TInt endPos = aString.Find(KUPnPEndTag());
if(KErrNotFound == endPos)
{
return midPtr;
}
midPtr.Set(aString.Mid(startPos, endPos - startPos));
return midPtr;
}
//--------------------------------------------------------------------------------------------
//
// CPrinterControlPoint::RemoveTags
//
//--------------------------------------------------------------------------------------------
void CPrinterControlPoint::JobStateLog(CUpnpService* aService)
{
if(!aService)
{
return;
}
LOG81("CPrinterControlPoint::JobStateLog\t prntState\t\t : %S", &(aService->StateVariable( KPrinterState() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t prntStateReasons: %S", &(aService->StateVariable( KPrinterStateReasons() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t jobIdList\t\t : %S", &(aService->StateVariable( KJobIdList() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t jobEndState\t : %S", &(aService->StateVariable( KJobEndState() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t sheets\t\t\t : %S", &(aService->StateVariable( KSheetsCompleted() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t jobAbortState\t : %S", &(aService->StateVariable( KJobAbortState() )->Value()));
LOG81("CPrinterControlPoint::JobStateLog\t contentCompList : %S", &(aService->StateVariable( KContentCompleteList() )->Value()));
}
// End Of File