--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cprintercontrolpoint.cpp Wed Sep 01 12:30:38 2010 +0100
@@ -0,0 +1,884 @@
+/*
+* 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