/*
* Copyright (c) 2004-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:
*
*/
/**
* @file CBtJobChannel.h
* @brief Defines the CBtJobChannel class.
*/
#include <obex.h>
#include "crsbtdevice.h"
#include "cbtjobchannel.h"
#include "cbtsoapcodec.h"
#include "clog.h"
#include "tbtmapper.h"
#include "cbtdiscover.h"
#include "printmessagecodes.h"
#include "cbtstatuschannel.h"
#include "rsutils.h"
#include "cbttimer.h"
#include "btprotocolconsts.h"
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::NewL
//
//--------------------------------------------------------------------------------------------
CBtJobChannel* CBtJobChannel::NewL(MBtPCObserver& aObs)
{
CBtJobChannel *self = NewLC(aObs);
CleanupStack::Pop(); // self
return self;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::NewLC
//
//--------------------------------------------------------------------------------------------
CBtJobChannel* CBtJobChannel::NewLC(MBtPCObserver& aObs)
{
CBtJobChannel *self = new (ELeave) CBtJobChannel(aObs);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CBtJobChannel
//
//--------------------------------------------------------------------------------------------
CBtJobChannel::CBtJobChannel(MBtPCObserver& aObs):
CBtChannelBase(aObs),
iJobFile(KNullDesC8()),
iJobFileNum(0),
iImageCount(0),
iFileObjectSize(0),
iObexFileObject(NULL),
iPercents(0),
iTimer(NULL),
iStatusChannel(NULL)
{
LOG("[CBtJobChannel::CBtJobChannel]\t");
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::~CBtJobChannel
//
//--------------------------------------------------------------------------------------------
CBtJobChannel::~CBtJobChannel()
{
LOG("[CBtJobChannel::~CBtJobChannel]\t");
Stop();
// ignore leave: if cleaning fails, no can do.
TRAP_IGNORE(CleanXhtmlDirL())
if(iObexFileObject)
delete iObexFileObject;
if(iTimer)
delete iTimer;
if(iStatusChannel)
{
delete iStatusChannel;
iStatusChannel = NULL;
}
// deleting iChannel here because review-x report error.
if(iChannel)
{
delete iChannel;
iChannel = NULL;
}
iImageList.Reset();
iImageList.Close();
if (iUpdateProgress)
{
delete iUpdateProgress;
iUpdateProgress = NULL;
}
LOG("[CBtJobChannel::~CBtJobChannel]\t out");
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::ConstructL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::ConstructL()
{
LOG("[CBtJobChannel::ConstructL]\t begin");
CBtChannelBase::ConstructL();
iObexFileObject = CObexFileObject::NewL();
iStatusChannel = CBtStatusChannel::NewL(iObs);
iState = EStateNone;
iPercents = 0;
iImageCount = 0;
// Create periodic timer to update progress of printing.
iUpdateProgress = CPeriodic::NewL( CActive::EPriorityStandard );
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::RunL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::RunL()
{
LOG2("[CBtJobChannel::RunL]\t BEGIN iStatus %d at state %d", iStatus.Int(), iState);
//Finish if required
if( EStateFinish == iState )
{
ClearConnection();
return;
}
// leave if "not allowed" error
DoLeaveL( iStatus.Int() );
switch( iState )
{
case EStateConnecting:
RemoveObexCmdTimeOut();
iObexNullObject->Reset();
LOG("[CBtJobChannel::RunL]\t EStateConnecting");
StopWaiting();
break;
case EStateDisconnecting:
StopWaiting();
// Go to disconnection again in case it is not finished yet...
Disconnect();
break;
case EStateGettingCapabilities:
GetSoapResponseL();
GetPrinterCapabilitiesResponseL();
StopWaiting();
iState = EStateNone;
break;
case EStateGettingPrinterState:
GetSoapResponseL();
GetPrinterStateResponseL();
iState = EStateNone;
break;
case EStateCreatingJob:
{
GetSoapResponseL();
TInt res = CreateJobResponseL();
StopWaiting();
// No reason to send doc in error case
if(KErrNone == res)
{
LOG("[CBtJobChannel::RunL]\t CreateJobResponseL() returns %d");
SendXhtmlDocumentL();
}
}
break;
case EStateCancellingJob:
GetSoapResponseL();
CancelJobResponseL();
iDevice = NULL;
iState = EStateNone;
break;
case EStateGettingJobAttributes:
GetSoapResponseL();
GetJobAttributesResponseL();
iState = EStateNone;
break;
case EStateSendingXhtml:
iState = EStateNone;
iObexBufObject->Reset();
iObs.GetEventResponse(iJobId, EBtStateSending, EBtStatePrinting, ENoMessage, iStatus.Int());
break;
case EStateSendingOPP:
SendOPPL();
break;
default:
break;
}
LOG("[CBtJobChannel::RunL]\t out");
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::RunError
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::RunError(TInt aError)
{
LOG1("[CBtJobChannel::RunError]\t state %d", iState);
LOG2("[CBtJobChannel::RunError]\t error %d, iStatus %d", aError, iStatus.Int() );
TInt id = KErrNotFound;
StopWaiting();
switch ( iState )
{
case EStateGettingPrinterState:
if(iDevice)
id = iDevice->DeviceId();
iState = EStateFinish;
iObs.GetPrinterStateResponse(EBtStateIdle, ENoMessage, aError, id);
break;
case EStateCreatingJob:
iState = EStateFinish;
iObs.CreateJobResponse(KErrNotFound, aError);
break;
case EStateCancellingJob:
iState = EStateFinish;
iObs.CancelJobResponse(aError);
break;
case EStateGettingJobAttributes:
iState = EStateFinish;
iObs.GetJobAttributesResponse(iJobId, KNullDesC8(), KNullDesC8(), KErrNotFound, KErrNotFound, aError);
break;
case EStateSendingXhtml:
case EStateSendingOPP:
default:
iState = EStateFinish;
iObs.GetEventResponse(KErrNotFound, KErrNotFound, KErrNotFound, KErrNotFound, aError);
LOG("[CBtJobChannel::RunError]\t GetEventResponse sent" );
break;
}
iResponseError = aError;
return KErrNone; // othervise error returns to CActive: that's what we don't want.
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::DoCancel
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::DoCancel()
{
LOG2("[CBtJobChannel::DoCancel]\t at state %d, iStatus 0x%X", iState, iStatus.Int());
StopWaiting();
iState = EStateNone;
CBtChannelBase::DoCancel();
iStatusChannel->Cancel();
LOG1("[CBtJobChannel::DoCancel]\t out iStatus 0x%X", iStatus.Int());
}
//------------------------------
// InCalls
//------------------------------
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::HandleTimeoutL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::HandleTimeoutL()
{
LOG1("[CBtJobChannel::HandleTimeoutL]\t at state %d", iState);
if(EStateSendingOPP != iState)
return;
TInt state(EBtStateSending);
if( 100 == iPercents )
{
state = EBtStateCompleted;
}
else if(iTimer)
iTimer->Start(KSentPercentsDelay);
iObs.GetEventResponse(iJobId, state, EBtStatePrinting, KErrNone, KErrNone);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetPercentSent
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::GetPercentSent()
{
LOG1("[CBtJobChannel::GetPercentSent]\t at state %d", iState);
iPercents = 100;
if(EStateSendingOPP == iState)
{
// Store current bytes sent.
TReal32 bytesSent = iObexFileObject->BytesSent();
TInt temp = iProgressOfFullImages - iFileObjectSize;
iPercents = ( 100 * ( ( temp + bytesSent ) / iJobSize) );
LOG2("[CBtJobChannel::GetPercentSent]\t iJobId %d, iImageCount: %d", iJobId, iImageCount);
LOG2("[CBtJobChannel::GetPercentSent]\t BytesSent %d, iFileObjectSize %d", iObexFileObject->BytesSent(), iFileObjectSize);
}
LOG1("[CBtJobChannel::GetPercentSent]\t at state %d", iPercents);
return iPercents;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CreateJobL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::CreateJobL(CPrintJob& aJob)
{
LOG("[CBtJobChannel::CreateJob]\t begin");
if(!IsConnected())
User::Leave( KErrDisconnected );
Cancel();
iProgressOfFullImages = 0;
++iJobFileNum;
iJobFile.Format(KXHTMLFileName8(), iJobFileNum);
aJob.GetPrintFileL(iJobFile);
iImageList.Reset();
aJob.Images(iImageList);
iJobSize = CalculateJobSizeL();
iImageCount = iImageList.Count();
LOG1("[CBtJobChannel::CreateJob]\t iImageList.Count(): %d", iImageList.Count());
iJobId = KErrNotFound;
iResponseError = KErrNone;
LOG1("[CBtJobChannel::CreateJob]\t aDevice.UsedProtocol() %d", iDevice->UsedProtocol());
if(KImagePrint_PrinterProtocol_BPP == iDevice->UsedProtocol())
{
iState = EStateCreatingJob;
SendSoapRequestL(EBtCreateJob, iJobFileNum);
// do asynchronously to indicate to start the object server
WaitL();
}
else
{
iState = EStateSendingOPP;
iJobId = 1;
SendOPPL();
Activate();
}
LOG1("[CBtJobChannel::CreateJob]\t Request sent. iResponseError: %d", iResponseError);
if( KErrNone != iResponseError )
{
User::Leave( iResponseError );
}
LOG("[CBtJobChannel::CreateJob]\t out");
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetCapabilitiesL
//
// Fully independent and synchronous method. Does not require any existing
// connections and all connections will be deleted after execution.
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::GetCapabilitiesL(CRsBtDevice& aDevice)
{
LOG("[CBtJobChannel::GetCapabilitiesL]\t");
Cancel();
if( KImagePrint_PrinterProtocol_BPP != aDevice.UsedProtocol() )
User::Leave(KErrNotSupported);
if( !RsUtils::IsBluetoothOn() )
User::Leave(KErrCancel);
CRsBtDevice* tmpDevice = iDevice;
iDevice = &aDevice;
TBool connected = IsConnected();
iResponseError = KErrNone;
ConnectL();
WaitL();
LOG1("[CBtJobChannel::GetCapabilitiesL]\t ConnectL done: %d", IsConnected());
iState = EStateGettingCapabilities;
SendSoapRequestL(EBtGetPrinterAttributes);
LOG1("[CBtJobChannel::GetCapabilitiesL]\t SendSoapRequestL done: %d", IsConnected());
WaitL();
if(!connected)
{
ClearConnection();
}
iDevice = tmpDevice;
tmpDevice = NULL;
LOG("[CBtJobChannel::GetCapabilitiesL]\t OUT");
User::LeaveIfError(iResponseError);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetPrinterStateL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::GetPrinterStateL()
{
LOG1("[CBtJobChannel::GetPrinterStateL]\t begin for protocol %d", iDevice->UsedProtocol());
if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())
{
iObs.GetPrinterStateResponse(EBtStatePrinting, ENoMessage, KErrNone, iDevice->DeviceId());
return;
}
if(!IsConnected())
User::Leave(KErrDisconnected);
iStatusChannel->StartL(*iDevice);
iStatusChannel->GetPrinterStateL();
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetJobAttributesL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::GetJobAttributesL(TInt aJobId)
{
LOG("[CBtJobChannel::GetJobAttributesL]\t begin");
if(!iDevice)
{
User::Leave(KErrDisconnected);
}
LOG1("[CBtJobChannel::GetJobAttributesL]\t begin for protocol %d", iDevice->UsedProtocol());
if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())
{
TInt state(EBtStateSending), completed(0);
if(100 == iPercents)
{
state = EBtStateCompleted;
completed = iImageCount;
}
iObs.GetJobAttributesResponse(state, KNullDesC8(), KNullDesC8(), completed, 0, KErrNone);
return;
}
if(!IsConnected())
User::Leave(KErrDisconnected);
LOG("[CBtJobChannel::GetJobAttributesL]\t start status channel if required");
if(!iStatusChannel->IsConnected())
iStatusChannel->StartL(*iDevice);
LOG1("[CBtJobChannel::GetJobAttributesL]\t iStatusChannel->GetJobAttributesL(%d)", iJobId);
iStatusChannel->GetJobAttributesL(aJobId);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetEventL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::GetEventL(TInt aJobId)
{
LOG("[CBtJobChannel::GetJobAttributesL]\t begin");
if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())
{
TInt state(EBtStateSending);
if(100 == iPercents)
{
state = EBtStateCompleted;
}
iObs.GetEventResponse(iJobId, state, EBtStatePrinting, KErrNone, KErrNone);
return;
}
if(!IsConnected())
User::Leave(KErrDisconnected);
iStatusChannel->StartL(*iDevice);
iStatusChannel->GetEventL(aJobId);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CancelJobL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::CancelJobL(TInt aJobId)
{
LOG("[CBtJobChannel::CancelJob(TInt)]\t begin");
if(!IsConnected())
User::Leave(KErrDisconnected);
Cancel();
iJobId = aJobId;
iState = EStateCancellingJob;
SendSoapRequestL(EBtCancelJob, iJobId);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::SendOPPL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::SendOPPL()
{
LOG("[CBtJobChannel::SendOPPL]\t begin");
TInt tmpNumberOfCopies(0);
// Delete file object
iObexFileObject->Reset();
if(iTimer)
iTimer->Cancel();
// all sent
if(0 >= iImageList.Count())
{
LOG1("[CBtJobChannel::SendOPPL]\t Finishing... iImageList.Count(): %d", iImageList.Count());
iJobFile.Zero();
iImageList.Reset();
iState = EStateNone;
ClearConnection();
iObs.GetEventResponse(iJobId, EBtStateCompleted, EBtStateIdle, KErrNone, KErrNone);
iJobId = KErrNotFound;
if(iTimer)
delete iTimer;
iTimer = NULL;
return;
}
LOG2("[CBtJobChannel::SendOPPL]\t iChannel: %d, iChannel->IsConnected(): %d", iChannel, iChannel->IsConnected());
if(!IsConnected())
User::Leave(KErrDisconnected);
iState = EStateSendingOPP;
TFileName fn;
iImageList[0].GetFilePathL(fn);
tmpNumberOfCopies = iImageList[0].Copies();
LOG1("[CBtJobChannel::SendOPPL]\t init file object with \"%S\"", &fn);
iObexFileObject->InitFromFileL(fn);
// check that does user wants print more than one copy of the currently printing picture.
if(tmpNumberOfCopies > 1)
{
tmpNumberOfCopies--;
iImageList[0].SetCopies(tmpNumberOfCopies);
}
else
{
iImageList.Remove(0);
}
LOG81("[CBtJobChannel::SendOPPL]\t set type \"%S\"...", &KBtMimeTypeJpeg());
iObexFileObject->SetTypeL(KBtMimeTypeJpeg());
LOG1("[CBtJobChannel::SendOPPL]\t ...and name \"%S\"", &fn);
iObexFileObject->SetNameL(fn);
iFileObjectSize = iObexFileObject->Length();
if(!iTimer)
iTimer = CBtTimer::NewL(*this);
iTimer->Start(KSentPercentsDelay);
LOG("[CBtJobChannel::SendOPPL]\t put");
iChannel->Put(*iObexFileObject, iStatus);
iProgressOfFullImages = iProgressOfFullImages + iFileObjectSize;
if (iUpdateProgress)
{
iUpdateProgress->Cancel();
}
// Start periodic timer to track data transfer process.
// Event interval is setup to 1 second.
iUpdateProgress->Start(5000, KProgressUpdateInterval, TCallBack( CheckProgress, this ));
iObs.GetEventResponse(iJobId, EBtStateSending, EBtStatePrinting, KErrNone, KErrNone);
Activate();
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CheckProgress
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::CheckProgress( TAny *aObj )
{
CBtJobChannel* obj = (CBtJobChannel*)aObj;
obj->UpdateProgress();
return 1;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::UpdateProgress
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::UpdateProgress()
{
TInt percentBuffer = GetPercentSent();
// If all data has been sent, it's OK to stop timer
if ( percentBuffer == 100 )
{
iUpdateProgress->Cancel();
}
// Update progress bar using MBtPCObserver.
iObs.OPPSendProgress(percentBuffer);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::SendXhtmlDocumentL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::SendXhtmlDocumentL()
{
LOG("[CBtJobChannel::SendXhtmlDocumentL]\t begin");
if( !iDevice || !iChannel || !iChannel->IsConnected() )
User::Leave( EObexConnectError );
iState = EStateSendingXhtml;
TFileName fn;
fn.Copy( iJobFile );
iObexFileObject->Reset();
LOG("[CBtJobChannel::SendXhtmlDocumentL]\t fill in iObexBufObject");
iObexFileObject->InitFromFileL( fn );
TBuf8<50> mime;
mime.Copy( KBtMimeTypeXhtml() );
mime.ZeroTerminate();
iObexFileObject->SetTypeL( mime );
// name initialized automatically...
// Job ID (application parameters)
TUint32 jobId = iJobId;
TBuf8<20> triplet;
triplet.Zero();
triplet.Append((TChar)KBtObexTagJobId);
triplet.Append((TChar)KBtDataLength4);
//append value
triplet.Append((TChar) ((jobId & 0xFF000000) >> 24) );
triplet.Append((TChar) ((jobId & 0xFF0000) >> 16) );
triplet.Append((TChar) ((jobId & 0xFF00) >> 8) );
triplet.Append((TChar) (jobId & 0xFF) );
triplet.ZeroTerminate();
#ifdef _DEBUG
const TUint8* aPtr = triplet.Ptr();
_LIT(KBTHexFormatString,"%02x");
TBuf<50> line;
for (TInt j=0; j<triplet.Length(); j++)
line.AppendFormat(KBTHexFormatString,aPtr[j]);
LOG1("[CBtJobChannel::SendXhtmlDocumentL]\t line: %S", &line);
#endif
iObexFileObject->SetAppParamL(triplet);
LOG("[CBtJobChannel::SendXhtmlDocumentL]\t putting...");
iChannel->Put(*iObexFileObject, iStatus);
Activate();
LOG("[CBtJobChannel::SendXhtmlDocumentL]\t end");
}
//------------------------------
// Responses
//------------------------------
TInt CBtJobChannel::CreateJobResponseL()
{
LOG("[CBtJobChannel::CreateJobResponseL]\t ");
User::LeaveIfNull(iSoapCodec);
iJobId = KErrNotFound;
TInt err = KErrGeneral;
iSoapCodec->CreateJobResponseL(iJobId, err);
iResponseError = err;
iObs.CreateJobResponse(iJobId, err);
LOG("[CBtJobChannel::CreateJobResponseL]\t out");
return err;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetPrinterStateResponseL
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::GetPrinterStateResponseL()
{
LOG("[CBtJobChannel::GetPrinterStateResponseL]\t");
User::LeaveIfNull(iSoapCodec);
TInt state = EBtStateUnknown;
TInt reasons = EPbCheckPrinter;
TInt opStatus = KErrGeneral;
iSoapCodec->GetPrinterStateResponseL(state, reasons, opStatus);
iObs.GetPrinterStateResponse(state, reasons, opStatus, iDevice->DeviceId());
LOG("[CBtJobChannel::GetPrinterAttributesResponseL]\t out");
return opStatus;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetPrinterCapabilitiesResponseL
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::GetPrinterCapabilitiesResponseL()
{
LOG("[CBtJobChannel::GetPrinterCapabilitiesResponseL]\t");
User::LeaveIfNull(iSoapCodec);
RArray<TPrintCapability> capab;
CleanupClosePushL(capab);
TInt opStatus = KErrGeneral;
iSoapCodec->GetPrinterCapabilitiesResponseL(capab, opStatus);
if(iDevice)
{
for(TInt i = 0; i < capab.Count(); ++i)
{
iDevice->AddCapability(capab[i]);
}
LOG("[CBtJobChannel::GetPrinterCapabilitiesResponseL]\t returning to iObs...");
}
else
{
opStatus = KErrNotFound;
}
CleanupStack::PopAndDestroy(&capab);
LOG("[CBtJobChannel::GetPrinterCapabilitiesResponseL]\t out");
return opStatus;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::GetJobAttributesResponseL
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::GetJobAttributesResponseL()
{
LOG("[CBtJobChannel::GetJobAttributesResponseL]\t");
User::LeaveIfNull(iSoapCodec);
TInt state, sheets, pendingJobs, opStatus;
TBtAttrString8 jobName;
TBtAttrString8 originator;
iSoapCodec->GetJobAttributesResponseL( iJobId, state, jobName, originator,sheets, pendingJobs, opStatus);
iObs.GetJobAttributesResponse(state, jobName, originator,sheets, pendingJobs, opStatus);
return opStatus;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CancelJobResponseL
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::CancelJobResponseL()
{
LOG("[CBtJobChannel::CancelJobResponseL]\t");
User::LeaveIfNull(iSoapCodec);
TInt err = KErrNotFound;
iSoapCodec->CancelJobResponseL(iJobId, err);
LOG1("[CBtJobChannel::CancelJobResponseL]\t err %d", err);
iObs.CancelJobResponse(err);
return err;
}
///////////////////////////////
// Private
///////////////////////////////
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::ConnectL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::ConnectL()
{
LOG("[CBtJobChannel::ConnectL]\t");
User::LeaveIfNull( iDevice );
if( IsConnected() )
{
LOG1("[CBtJobChannel::ConnectL]\t return isConnected: %d", IsConnected());
return;
}
// delete old if exists
if ( iChannel )
{
delete iChannel;
iChannel = NULL;
}
iState = EStateConnecting;
// set common parts of protocol info
TObexBluetoothProtocolInfo protocolInfo;
protocolInfo.iTransport.Copy( KRFCOMMDesC );
protocolInfo.iAddr.SetBTAddr( iDevice->BDAddr() );//Address of server bt device
// connect profile specifically
LOG1("[CBtJobChannel::ConnectL]\t aDevice.UsedProtocol(): %d", iDevice->UsedProtocol());
if( KImagePrint_PrinterProtocol_BPP == iDevice->UsedProtocol() )
{
LOG("[CBtJobChannel::ConnectL]\t connect BPP");
protocolInfo.iAddr.SetPort( iDevice->BPPPort() );//Service channel of server rfcomm
TUUID uuid( KBTSDPDirectPrinting );
iObexNullObject->Reset();
iObexNullObject->SetTargetL( uuid.Des() );
// create channel
iChannel = CObexClient::NewL( protocolInfo );
iChannel->SetCallBack( *this );
iChannel->Connect( *iObexNullObject, iStatus );
}
else
{
LOG("[CBtJobChannel::ConnectL]\t connect OPP");
protocolInfo.iAddr.SetPort(iDevice->OPPPort());
// create channel
iChannel = CObexClient::NewL( protocolInfo );
iChannel->SetCallBack(*this);
iChannel->SetCommandTimeOut(KObexCmdTimeOut);
iChannel->Connect(iStatus);
}
Activate();
LOG("[CBtJobChannel::ConnectL]\t out.");
return;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::IsError
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::DoLeaveL(TInt aError)
{
LOG2("[CBtJobChannel::DoLeaveL]\t aError %d at state %d", aError, iState);
if(KErrNone == aError)
return;
if(EStateDisconnecting == iState)
return;
// obex connection objects returns 'KErrCompletion' at destructor. Ignore.
if(KErrCompletion == aError)
return;
LOG("[CBtJobChannel::DoLeaveL]\t Leave");
User::Leave(aError);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::ClearConnection
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::ClearConnection()
{
LOG1("[CBtJobChannel::ClearConnection]\t iState %d", iState);
if(iStatusChannel)
{
LOG("[CBtJobChannel::ClearConnections]\t **** iStatusChannel stop");
iStatusChannel->Stop();
}
CBtChannelBase::ClearConnection();
iObexFileObject->Reset();
iState = EStateNone;
iUpdateProgress->Cancel();
iImageCount = 0;
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CleanXhtmlDirL
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::CleanXhtmlDirL()
{
LOG1("[CBtJobChannel::CleanXhtmlDirL]\t iJobFileNum %d", iJobFileNum);
RFs fs;
CleanupClosePushL(fs);
User::LeaveIfError(fs.Connect());
CFileMan* fm = CFileMan::NewL(fs);
CleanupStack::PushL(fm);
while(0 < iJobFileNum)
{
TFileName fn;
fn.Format(KXHTMLFileName, iJobFileNum);
TInt err = fm->Delete(fn);
LOG2("[CBtJobChannel::CleanXhtmlDirL]\t delete file %S, err %d", &fn, err);
--iJobFileNum;
}
CleanupStack::PopAndDestroy( 2 ); // fm, fs
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::RemoveObexCmdTimeOut
//
//--------------------------------------------------------------------------------------------
void CBtJobChannel::RemoveObexCmdTimeOut()
{
iChannel->SetCommandTimeOut(0);
}
//--------------------------------------------------------------------------------------------
//
// CBtJobChannel::CalculateJobSizeL
//
//--------------------------------------------------------------------------------------------
TInt CBtJobChannel::CalculateJobSizeL()
{
TInt imgCount= iImageList.Count();
TInt size = 0;
for (TInt i = 0; i<imgCount; i++)
{
TFileName fn;
iImageList[i].GetFilePathL(fn);
iObexFileObject->InitFromFileL(fn);
TInt tempSize = iObexFileObject->Length();
iObexFileObject->Reset();
size = size + tempSize;
}
return size;
}
// End of File