/*
* 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