/*

* Copyright (c) 2002 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:  Obex client implementation

*

*/

// INCLUDE FILES

#include <obexclient.h>

#include <Obexutils.rsg>

#include <obexutilsuilayer.h>

#include "IRClient.h"

#include "IrSendingServiceDebug.h"

const TUint KIRProgressInterval         = 1000000;

_LIT( KTransportTinyTp, "IrTinyTP" );

_LIT8( KClassNameObex, "OBEX" );

_LIT8( KAttName, "IrDA:TinyTP:LsapSel" );

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CBTServiceClient::CBTServiceClient

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CIRClient::CIRClient(  ) 

    : CActive( EPriorityStandard ), 

      iClientState( EIRCliDisconnected),                             

      iObjectIndex( 0 )

    {

    CActiveScheduler::Add( this );    

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CIRClient::ConstructL( )

    {

    FLOG(_L("[BTSU]\t CBTServiceClient::ConstructL()"));

    User::LeaveIfError( iFileSession.Connect() );

    iDialog = CObexUtilsDialog::NewL( this );

    iTotalBytesSent = 0;

    // Create Obex Client

    //

    TObexIrProtocolInfo  info;

    //info.iTransport = KObexIrTTPProtocol;    

  //  info.iAddr.SetPort( KDefaultObexPort );//default obex server for now

    info.iTransport     = KTransportTinyTp;

    info.iClassName     = KClassNameObex;

    info.iAttributeName = KAttName;

    iClient = CObexClient::NewL( info );

    // Create Connect-object

    //

    iConnectObject = CObexNullObject::NewL();

    //Show note

    //

    iDialog->LaunchWaitDialogL( R_IR_CONNECTING_WAIT_NOTE);

    // Establish client connection

    //

    iClient->Connect( /**iConnectObject,*/ iStatus );

    SetActive();

    iClientState = EIRCliConnecting;

    FLOG(_L("[BTSU]\t CBTServiceClient::ConstructL() completed"));

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CIRClient* CIRClient::NewL()

    {

    CIRClient* self = new( ELeave ) CIRClient( );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CIRClient::~CIRClient()

    { 

    Cancel();

    if(iClient)

        {

        delete iClient;

        iClient = NULL;        

        }    

    iFileSession.Close();    

    delete iConnectObject;

    for (TInt index = 0; index < iFileArray.Count(); index++ )

    	{

    	if(iFileArray[index].SubSessionHandle())

    		{

    		iFileArray[index].Close();

    		}

    	}

    iFileArray.Close();

    if ( iPutBufObject )

        {        

        delete iPutBufObject;

        iPutBufObject = NULL;

        }

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::PutObjectL

// -----------------------------------------------------------------------------

//

void CIRClient::PutObjectL( )

    {

    FLOG(_L("[BTSU]\t CBTServiceClient::PutObjectL()"));

    if ( iPutBufObject )

        {        

        delete iPutBufObject;

        iPutBufObject = NULL;

        }

    // Create object

    //

    iPutBufObject = CObexBufObject::NewL(NULL);    

    RFile file;    

    file.Duplicate(iFileArray[iObjectIndex]);

    iBuffer = CBufFlat::NewL(1000);

    iBuffer ->ResizeL(1000);

    TObexRFileBackedBuffer bufferdetails(*iBuffer,file,CObexBufObject::ESingleBuffering);

    iPutBufObject->SetDataBufL(bufferdetails);

    TFileName filename;    

    file.Name(filename);

    TInt size;

    file.Size(size);

    iPutBufObject->SetLengthL(size);	

    iPutBufObject->SetNameL(filename);

    TTime time;

	if(file.Modified(time) == KErrNone)

		iPutBufObject->SetTimeL(time);

    // Send object

    //

    iClient->Put( *iPutBufObject, iStatus );    

	SetActive();

    iClientState = EIRCliPutting;

    FLOG(_L("[BTSU]\t CBTServiceClient::PutObjectL() completed"));

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::CloseClientConnection

// -----------------------------------------------------------------------------

//

void CIRClient::CloseClientConnection()

    {    

    iClient->Disconnect( iStatus );

   	SetActive();

    iClientState = EIRCliDisconnected;

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::GetProgressStatus

// -----------------------------------------------------------------------------

//

TInt CIRClient::GetProgressStatus()

    {    

    TInt bytesSent = 0;

    if ( iPutBufObject )

        {

        bytesSent = iPutBufObject->BytesSent();

        }

    return iTotalBytesSent + bytesSent;

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::DoCancel

// -----------------------------------------------------------------------------

//

void CIRClient::DoCancel()

    {

    FLOG(_L("[BTSU]\t CBTServiceClient::DoCancel()"));

    // Sending an error to Obex is the only way to cancel active requests

    //    

    if(iClient)

        {

        delete iClient;

        iClient = NULL;        

        }    

    FLOG(_L("[BTSU]\t CBTServiceClient::DoCancel() completed"));

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::RunL

// -----------------------------------------------------------------------------

//

void CIRClient::RunL()

    {

    switch ( iClientState )

        {

        case EIRCliConnecting:

            {

            if ( iPutBufObject )

				{				

				delete iPutBufObject;

				iPutBufObject = NULL;

				}				

				iObjectIndex=0;		

				iDialog->CancelWaitDialogL();		

				iDialog->LaunchProgressDialogL( this, FileListsize(), 

            									R_IR_SENDING_DATA, KIRProgressInterval );             

				TRAPD(error,SendL());

				error=error;         	

            break;

            }

        case EIRCliPutting:

            {

			if ( iPutBufObject )

				{				

				delete iPutBufObject;

				iPutBufObject = NULL;

				}		

		    if(iBuffer)

		        {

		        delete iBuffer;

		        iBuffer=NULL;

		        }

			iObjectIndex++;

			TRAPD(error,SendL());

			error=error;         

            break;

            }

        case EIRCliDisconnected:

            {            

            break;

            }       

        default:

           {

           break;

           }

        }

    FLOG(_L("[BTSU]\t CBTServiceClient::RunL() completed"));

    }

 // -----------------------------------------------------------------------------

// CBTServiceClient::DialogDismissed

// -----------------------------------------------------------------------------

//   

 void CIRClient::DialogDismissed( TInt aButtonId )

    {

    if( aButtonId == EAknSoftkeyCancel )

        {

        FLOG(_L("[BTSU]\t CBTServiceStarter::DialogDissmissed(), cancelled by user"));

        Cancel();

        // Cancelled by user, stop service

        //

        iClientState = EIRCliDisconnected;

        TRequestStatus* temp = &iStatus;

        User::RequestComplete( temp, KErrNone );        

        SetActive();

        }

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::StartSendL

// -----------------------------------------------------------------------------

//     

 void CIRClient::StartSendL(const CAiwGenericParamList& aOutParamList )

    {

    if ( iDialog )

        {

        iDialog->CancelWaitDialogL();        

        }

    for( TInt index = 0; index < aOutParamList.Count(); index++ )

        {

        if ( aOutParamList[index].SemanticId() != EGenericParamFile )

            {

            FLOG(_L("[BTSS]\t CBTSSProvider::AddParametersL() wrong semantic Id: Leave"));

            User::Leave( KErrArgument );

            }

            // Try to add file as an image

            //          

        if(aOutParamList[index].Value().TypeId()== EVariantTypeFileHandle)

        	{        	        	

            AddFileHandleL( aOutParamList[index].Value().AsFileHandle() );           

        	}

        else 

        	{            

            AddFileL( aOutParamList[index].Value().AsDes() );            

        	}

        }      

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::SendL

// -----------------------------------------------------------------------------

//     

 void CIRClient::SendL()

    {

    if(iObjectIndex<iFileArray.Count())

        {        

        PutObjectL();

        }

     else

        {

        ShowNote();            

        iDialog->CancelProgressDialogL();

        iClient->Disconnect( iStatus );        

        SetActive();    

        iClientState=EIRCliDisconnected;        

        }

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::AddFileHandleL

// -----------------------------------------------------------------------------

//      

 void CIRClient::AddFileHandleL(RFile aFile)

    {

    if(!aFile.SubSessionHandle())

        {

        User::Leave( KErrArgument );

        }

    RFile file;

    file.Duplicate(aFile);

    iFileArray.AppendL( file );

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::AddFileL

// -----------------------------------------------------------------------------

//      

 void CIRClient::AddFileL(const TDesC& aFilePath)

    {

    if ( &aFilePath == NULL || 

         aFilePath.Length() == 0 ||

         aFilePath.Length() > KMaxFileName )

        {

        User::Leave( KErrArgument );

        } 

    RFile file;

    User::LeaveIfError( file.Open( iFileSession, aFilePath, EFileShareReadersOnly) );

    AddFileHandleL(file);

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::FileListsize

// -----------------------------------------------------------------------------

//      

 TInt CIRClient::FileListsize()

    {

    TInt totalFileSize = 0; 	    

    for ( TInt index = 0; index < iFileArray.Count(); index++ )

        {                

        TInt fileSize = 0;

        iFileArray[index].Size( fileSize );

        totalFileSize += fileSize;        

        }

    return totalFileSize;

    }

// -----------------------------------------------------------------------------

// CBTServiceClient::ShowNote

// -----------------------------------------------------------------------------

//      

void CIRClient::ShowNote()

    {

    if(iObjectIndex==iFileArray.Count() && iStatus==KErrNone)

        {

        TRAPD(error,TObexUtilsUiLayer::ShowInformationNoteL(R_IR_DATA_SENT));

        error=error;

        }

     else

     	{

     	TRAPD(error,TObexUtilsUiLayer::ShowInformationNoteL(R_IR_SENDING_FAILED));

     	error=error;

     	}

    }

//  End of File