/*

* 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:  Image push implementation

*

*/

// INCLUDE FILES

#include "BTSBIPController.h"

#include "BTSUDebug.h"

#include "BTSUImageConverter.h"

#include "BTSUXmlParser.h"

#include <Obexutils.rsg>

// CONSTANTS

// image push target header

_LIT8( KBIPImagePushID, "\xE3\x3D\x95\x45\x83\x74\x4A\xD7\x9E\xC5\xC1\x6B\xE3\x1E\xDE\x8E" );

// type headers

_LIT8( KBTSBIPCapabilities, "x-bt/img-capabilities\0");

_LIT8( KBTSBIPImageType,    "x-bt/img-img\0");

_LIT8( KBTSBIPThmType,      "x-bt/img-thm\0");

// imageBTS descriptor

_LIT8( KBTSBIPDescriptorStart,     "<image-descriptor version=\"1.0\">\r" );

_LIT8( KBTSBIPDescriptorEncoding,  "<image encoding=\"" );

_LIT8( KBTSBIPDescriptorPixel,     "\" pixel=\"" );

_LIT8( KBTSBIPDescriptorSize,      "\" size=\"" );

_LIT8( KBTSBIPDescriptorEnd,       "\"/>\r</image-descriptor>" );

// temp file path for capabilities object

//temp file path drive letter

_LIT(KBTSBIPTempPathDrive,"c:");

const TInt KBTSUMaxPathLenght=256;

const TInt KBTSUMaxPrivatePathLenght=20;

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

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

// CBTSBIPController::CBTSBIPController

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

// might leave.

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

//

CBTSBIPController::CBTSBIPController( MBTServiceObserver* aObserver, 

                                      CBTServiceParameterList* aList ) :

                                      iListPtr( aList ),

                                      iObserverPtr( aObserver )

    {

    }

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

// CBTSBIPController::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CBTSBIPController::ConstructL( const TUint aRemotePort, 

                                    const TBTDevAddr& aRemoteDeviceAddr )

    {

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

    // Add image push target header

    //

    CObexHeader* header = CObexHeader::NewL();

    CleanupStack::PushL( header );

    header->SetByteSeqL( KBTSUTargetHeader, KBIPImagePushID );

    RArray<CObexHeader*> headerList;

    CleanupClosePushL( headerList );

    headerList.Append( header );

    CreateClientL ( this, aRemoteDeviceAddr, aRemotePort, headerList );    

    CleanupStack::Pop( 2 ); //header, headerlist

    headerList.Close();

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

    }

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

// CBTSBIPController::NewL

// Two-phased constructor.

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

//

CBTSBIPController* CBTSBIPController::NewL( MBTServiceObserver* aObserver,

                                           const TUint aRemotePort,

                                           const TBTDevAddr& aRemoteDeviceAddr,

                                           CBTServiceParameterList* aList )

    {

    CBTSBIPController* self = 

        new( ELeave ) CBTSBIPController( aObserver, aList );

    CleanupStack::PushL( self );

    self->ConstructL( aRemotePort, aRemoteDeviceAddr );

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CBTSBIPController::~CBTSBIPController()

    {

    DeleteTempFile( iThumbnailFileName );

    }

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

// CBTSBIPController::ConnectCompleted

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

//

void CBTSBIPController::ConnectCompleted( TInt aStatus )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::ConnectCompleted()"));

    if ( aStatus == KErrNone )

        {

        iFileIndex = 0;

        // get remote device capabilities

        //

        TRAPD( error, GetL() );

        if ( error != KErrNone )

            {

            iObserverPtr->ControllerComplete( EBTSGettingFailed );

            }

        }

    else

        {

        //Error on Obex level

        //

        iObserverPtr->ControllerComplete( EBTSConnectingFailed );

        }

    FLOG(_L("[BTSU]\t CBTSBIPController::ConnectCompleted() completed"));

    }

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

// CBTSBIPController::ClientConnectionClosed

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

//

void CBTSBIPController::ClientConnectionClosed()

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::ClientConnectionClosed()"));

    // Everything ready, stop service

    //    

    iObserverPtr->ControllerComplete( EBTSNoError );	

    FLOG(_L("[BTSU]\t CBTSBIPController::ClientConnectionClosed() completed"));

    }

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

// CBTSBIPController::PutCompleted

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

//

void CBTSBIPController::PutCompleted( TInt aStatus, 

                                      const CObexHeaderSet* aPutResponse )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::PutCompleted()"));

    // Remove temporary thumbnail file

    //

    DeleteTempFile( iThumbnailFileName );

    if ( aStatus == KErrNone )

        {              

        iFileIndex++;

        // Send was ok. Start sending next image

        //

        TRAPD( error, SendL() );

        if ( error )

            {

            FTRACE(FPrint(_L("[BTSU]\t CBTSBPPController::Send leaved with %d"), error ));

            iObserverPtr->ControllerComplete( EBTSPuttingFailed);

            }                

        }

    else if ( aStatus == KErrIrObexRespPartialContent )

        {

        // Remote device has requested a thumbnail image

        //

        TRAPD( error, SendThumbnailL(aPutResponse ) );

        if ( error )

            {

            FTRACE(FPrint(_L("[BTSU]\t CBTSBPPController::Send thumbnail leaved with %d"), error ));

            iObserverPtr->ControllerComplete( EBTSPuttingFailed );

            }

        }

    else

        {

        // Some error on Obex level

        //

        iObserverPtr->ControllerComplete( EBTSPuttingFailed);

        }

    FLOG(_L("[BTSU]\t CBTSBIPController::PutCompleted() done"));

    }

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

// CBTSBIPController::GetCompleted

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

//

void CBTSBIPController::GetCompleted( TInt aStatus, 

                                      CObexBufObject* aGetResponse )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::GetCompleted()"));	

    if ( aStatus == KErrAbort )

        {

        // Connection is cancelled

        //

        iObserverPtr->ControllerComplete( EBTSGettingFailed );

        }

    else if ( aStatus == KErrNone )

        {

        TRAPD( error, HandleGetCompleteIndicationL( aGetResponse ) );

        if ( error != KErrNone )

            {

            DeleteTempFile( iTempFileName );

            // Error on capability handling

            //

            iObserverPtr->ControllerComplete( EBTSGettingFailed );

            }

        }

    else if( aStatus != KErrAbort && aGetResponse->BytesReceived()==0 )

        {

        TRAPD( error,iObserverPtr->LaunchProgressNoteL( iClient, iListPtr->ImageListSize(),iListPtr->ImageCount() ) );

        error=KErrNone;

        TRAP(error, SendL() );    	 

        if ( error != KErrNone )

            {            

            iObserverPtr->ControllerComplete( EBTSPuttingFailed );

            }    	      

        } 	

    else if ( aStatus != KErrNone && aGetResponse->BytesReceived()>0 )

        {

        // Error on Obex level

        //

        iObserverPtr->ControllerComplete( EBTSGettingFailed );

        }

    FLOG(_L("[BTSU]\t CBTSBIPController::GetCompleted() done"));

    }

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

// CBTSBIPController::SendL

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

//

void CBTSBIPController::SendL()

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::SendL()"));

    if ( iListPtr->ImageCount() > 0 && iFileIndex < iListPtr->ImageCount())

        {        

        RArray<CObexHeader*> headerList;

        CleanupClosePushL( headerList );

        // Add Type header

        //

        CObexHeader* typeHeader = CObexHeader::NewL();

        CleanupStack::PushL( typeHeader );

        typeHeader->SetByteSeqL( KBTSUTypeHeader, KBTSBIPImageType );

        headerList.Append( typeHeader );

        // Add image descriptor

        //

        HBufC8* imagedescriptor = CreateImageDescriptorL( );

        CleanupStack::PushL( imagedescriptor );

        CObexHeader* imageDescriptorHeader = CObexHeader::NewL();

        CleanupStack::PushL( imageDescriptorHeader );

        imageDescriptorHeader->SetByteSeqL( KBTSUImgDescriptorHeader, imagedescriptor->Des() );

        headerList.Append( imageDescriptorHeader );

        // Send image

        //

        TBTSUImageParam imageparam = iListPtr->ImageAtL( iFileIndex );        

        RBuf filename;

        filename.CreateL(256);

        CleanupClosePushL(filename);

        imageparam.iFile.Name(filename);

        iObserverPtr->UpdateProgressNoteL(imageparam.iFileSize,iFileIndex,filename);

        CleanupStack::PopAndDestroy(&filename);

        iListPtr->MarkAsSendL(iFileIndex);

        iClient->PutObjectL( headerList, imageparam.iFile );

        CleanupStack::Pop(4); // headerList, imageDescriptorHeader, typeHeader, imagedescriptor

        delete imagedescriptor;

        headerList.Close();

        }

    else

        {

        FLOG(_L("[BTSU]\t CBTSBIPController::SendL() all images sent, closing connection"));

        // All images sent, close client connection.

        //

        iClient->CloseClientConnection();

        }

    FLOG(_L("[BTSU]\t CBTSBIPController::SendL() completed"));

    }

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

// CBTSBIPController::GetL

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

//

void CBTSBIPController::GetL()

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::GetL()"));

    RArray<CObexHeader*> headerList;

    CleanupClosePushL(headerList);

    // Add capabilities type header

    //

    CObexHeader* typeHeader = CObexHeader::NewL();

    CleanupStack::PushL( typeHeader );

    typeHeader->SetByteSeqL( KBTSUTypeHeader, KBTSBIPCapabilities );

    headerList.Append( typeHeader );

    // Get capabilities object from remote device

    //

    iClient->GetObjectL( headerList );

    CleanupStack::Pop(2); // headerList, typeHeader

    headerList.Close();

    }

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

// CBTSBIPController::SendThumbnailL

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

//

void CBTSBIPController::SendThumbnailL( const CObexHeaderSet *aPutResponse )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::SendThumbnail()"));

    // Create thumbnail for sending

    // Delete the created thumbnail on PutComplete

    //

    // Fill header array

    //

    RArray<CObexHeader*> headerList;

    CleanupClosePushL(headerList);

    // Add ImageHandle header

    //

    CObexHeader* imageHandleHeader = CObexHeader::NewL();

    CleanupStack::PushL( imageHandleHeader );

    aPutResponse->First();

	User::LeaveIfError(aPutResponse->Find(KBTSUImageHandleHeader,

			 *imageHandleHeader ) );

	headerList.Append( imageHandleHeader );

    // Add Type header

    //

    CObexHeader* typeHeader = CObexHeader::NewL();

    CleanupStack::PushL( typeHeader );

    typeHeader->SetByteSeqL( KBTSUTypeHeader, KBTSBIPThmType );

    headerList.Append( typeHeader );

    CreateTempFileL( iThumbnailFileName );

    CBTSUImageConverter* imageConverter = CBTSUImageConverter::NewL();

    CleanupStack::PushL( imageConverter );

    TBTSUImageParam imgparam = iListPtr->ImageAtL( iFileIndex );

    imageConverter->CreateThumbnailL(imgparam.iFile, iThumbnailFileName );

    CleanupStack::PopAndDestroy(imageConverter);    

	// Add Name header

    //

    TParse parse;

    User::LeaveIfError( parse.Set( iThumbnailFileName, NULL, NULL ) );

    CObexHeader* nameHeader = CObexHeader::NewL();

    CleanupStack::PushL( nameHeader );

    nameHeader->SetUnicodeL( KBTSUNameHeader, parse.NameAndExt() );

    headerList.Append( nameHeader );

    // send thumbnail

    //

    iClient->PutObjectL( headerList, iThumbnailFileName );

    // Cleanup

    //

    CleanupStack::Pop(4); // headerList, imageHandleHeader, typeHeader, nameHeader

    headerList.Close();

    }

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

// CBTSBIPController::CreateTempFileL

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

//

void CBTSBIPController::CreateTempFileL( TFileName& aFileName )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::CreateTempFileL()"));

    RFs fileSession;

    RFile file;    

    TBuf<KBTSUMaxPrivatePathLenght> privatepath;     

    TBuf<KBTSUMaxPathLenght> tempPath;     

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

    CleanupClosePushL( fileSession );    

    User::LeaveIfError(fileSession.CreatePrivatePath(EDriveC));

    User::LeaveIfError(fileSession.PrivatePath(privatepath));

    tempPath.Append(KBTSBIPTempPathDrive());

    tempPath.Append(privatepath);    

    User::LeaveIfError( file.Temp( fileSession, privatepath, 

                            aFileName, EFileWrite ) );

    file.Flush();

    file.Close();

    CleanupStack::Pop();    // Close fileSession

    fileSession.Close();

    }

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

// CBTSBIPController::GenerateTempFileNameL

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

//

void CBTSBIPController::GenerateTempFileNameL( TFileName& aFileName )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::GenerateTempFileNameL()"));

    RFs fileSession;

    RFile file;  

    TBuf<KBTSUMaxPrivatePathLenght> privatepath;     

    TBuf<KBTSUMaxPathLenght> tempPath;     

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

    CleanupClosePushL( fileSession );

    User::LeaveIfError(fileSession.CreatePrivatePath(EDriveC));

    User::LeaveIfError(fileSession.PrivatePath(privatepath ));

    tempPath.Append(KBTSBIPTempPathDrive());

    tempPath.Append(privatepath);

    User::LeaveIfError(file.Temp( fileSession, tempPath, 

                            aFileName, EFileWrite ) );                            

    file.Flush();

    file.Close();

    // Delete the file so that only a unique name is created

    fileSession.Delete( aFileName );

    CleanupStack::Pop();    // Close fileSession

    fileSession.Close();

    }    

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

// CBTSBIPController::DeleteTempFileL

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

//

void CBTSBIPController::DeleteTempFile( TFileName& aFileName )

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::DeleteTempFile()"));

    if ( &aFileName != NULL )

        {

        if ( aFileName.Length() > 0 )

            {

            RFs fileSession;

            TInt retVal = fileSession.Connect();

            if (retVal == KErrNone)

                {

                fileSession.Delete( aFileName );

                }

            fileSession.Close();

            }

        }

    FLOG(_L("[BTSU]\t CBTSBIPController::DeleteTempFile() complete"));

    }

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

// CBTSBIPController::CreateImageDescriptorL

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

//

HBufC8*  CBTSBIPController::CreateImageDescriptorL()

    {

    FLOG(_L("[BTSU]\t CBTSBIPController::CreateImageDescriptorL()"));

    //   Example image descriptor of an small jpeg picture

    //   with size 160*120 pixels and a size of 5000 bytes.

    //

    //  <image-descriptor version=\"1.0\">

    //  <image encoding=\"JPEG\" pixel=\"160*120\" size=\"5000\"/>

    //  </image-descriptor>

    TBTSUImageParam param = iListPtr->ImageAtL( iFileIndex );

    // Add start of image description

    //

    TBuf8<KBTSUMaxStringLength> string( KBTSBIPDescriptorStart );

    // Add image encoding

    //

    string.Append( KBTSBIPDescriptorEncoding );

    string.Append( *param.iDisplayName );

    // Add image pixel size

    //