/*

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

*       CBtMtmUi class

*

*/

// INCLUDE FILES

#include "btmtmui.h"

#include "btmtmuidebug.h"

//#include <obexmtmuilayer.h>

#include <MuiuMsvProgressReporterOperation.h>

#include <btcmtm.h>

#include <mtmuidef.hrh>

#include <mtclreg.h>

#include <obexutilsuilayer.h>

#include <Obexutils.rsg>

#include <msvuids.h>

#include <msvids.h>

#include <obexconstants.h>

// CONSTANTS

const TInt KBtMtmUiToFromFieldBuffer     = 80;

const TInt KBtMtmUiConnectionTimeout     = 20000000;

const TInt KBtMtmUiConnectionPutTimeout  = 0;

const TInt KBtMtmUiObexPort              = 1;

const TInt KBtMtmUiAddressMaxLength      = 3;

// ENUMS

enum TBtMtmAsyncCmds

    {

    EBtMtmCmdSend

    };

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

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

// might leave.

//

CBtMtmUi::CBtMtmUi( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll )

	:	CBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

	{

    FLOG( _L( "[CBtMtmUi] CBtMtmUi: CBtMtmUi\t" ) );

	}

// Two-phased constructor.

CBtMtmUi* CBtMtmUi::NewL( CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll )

	{

    FLOG( _L( "[CBtMtmUi] CBtMtmUi: NewL\t" ) );

	CBtMtmUi* self = new( ELeave ) CBtMtmUi( aBaseMtm, aRegisteredMtmDll );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

// Destructor

CBtMtmUi::~CBtMtmUi()

	{

    FLOG( _L( "[CBtMtmUi] CBtMtmUi: ~CBtMtmUi\t" ) );

	delete iClientRegistry;

	}

// Symbian OS default constructor can leave.

void CBtMtmUi::ConstructL()

	{

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

    CBaseMtmUi::ConstructL();

	}

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

// GetResourceFileName(...)

// return progress status.

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

//

void CBtMtmUi::GetResourceFileName( TFileName& aFileName ) const

	{ 

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: GetResourceFileName\t" ) );

    aFileName = KObexUtilsFileDrive;

    aFileName += KDC_RESOURCE_FILES_DIR;

    aFileName += KObexUtilsResourceFileName;

	}

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

// QueryCapability(TUid aCapability, TInt& aResponse)

// return capability of mtm.

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

//

TInt CBtMtmUi::QueryCapability(TUid aCapability, TInt& aResponse)

	{ 

    // Querying of menu availablility is done in syni.

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: QueryCapability\t" ) );

	if( aCapability.iUid == KUidMsvMtmUiQueryCanPrintMsgValue )

		{

		aResponse = ETrue;

		return KErrNone;

		}

	return CBaseMtmUi::QueryCapability( aCapability, aResponse );

	}

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

// InvokeSyncFunctionL(...)

// Invoke sync -function from BaseMTM.

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

//

void CBtMtmUi::InvokeSyncFunctionL( TInt aFunctionId, 

                                   const CMsvEntrySelection& aSelection, 

                                   TDes8& aParameter )

	{

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: InvokeSyncFunctionL\t" ) );

	CBaseMtmUi::InvokeSyncFunctionL( aFunctionId, aSelection, aParameter );

	}

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

// CreateL(...)

// Entry creation forbidden.

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

//

CMsvOperation* CBtMtmUi::CreateL( const TMsvEntry& /*aEntry*/,

                                 CMsvEntry& /*aParent*/, 

                                 TRequestStatus& /*aStatus*/ )

	{

    FLOG( _L( "[CBtMtmUi] CBtMtmUi: CreateL\t" ) );

    // Entries created through utility functions.

	User::Leave( KErrNotSupported );

    // Return value is needed for removing compilation errors

    return NULL;

	}

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

// OpenL(TRequestStatus& aStatus)

// handles opening entry.

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

//

CMsvOperation* CBtMtmUi::OpenL( TRequestStatus& aStatus )

	{

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: OpenL\t" ) );

	const TMsvEntry& context = iBaseMtm.Entry().Entry();

	const TUid type( context.iType );

	if( ( type == KUidMsvMessageEntry ) &&  

         ( ( context.Parent() == KMsvSentEntryIdValue )

         ||( context.Parent() == KMsvGlobalInBoxIndexEntryIdValue ) ) )

        {

		// Message is in the sent folder, so can't be edited

		return ViewL( aStatus );

        }

	return EditL( aStatus );

	}

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

// OpenL(...)

// handles opening entry using selection.

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

//

CMsvOperation* CBtMtmUi::OpenL( TRequestStatus& aStatus, 

                               const CMsvEntrySelection& aSelection )

	{

	iBaseMtm.Entry().SetEntryL( aSelection.At(0) );

	return OpenL( aStatus );

	}

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

// CloseL(TRequestStatus& aStatus)

// Closes entry.

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

//

CMsvOperation* CBtMtmUi::CloseL( TRequestStatus& aStatus )

	{

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: CloseL\t" ) );

	CMsvCompletedOperation* op = CMsvCompletedOperation::NewL( Session(), 

        Type(), 

        KNullDesC8, 

        KMsvLocalServiceIndexEntryId, 

        aStatus);

	return op;

	}

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

// CloseL(TRequestStatus& aStatus)

// Closes entry using selection.

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

//

CMsvOperation* CBtMtmUi::CloseL(

    TRequestStatus& aStatus, 

    const CMsvEntrySelection& aSelection)

	{

	iBaseMtm.Entry().SetEntryL( aSelection.At(0) );

	return CloseL( aStatus );

	}

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

// EditL(...)

// Handles message sending using selection.

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

//

CMsvOperation* CBtMtmUi::EditL( TRequestStatus& aStatus, const CMsvEntrySelection& aSelection )

	{

    FLOG( _L( "[BtMtmUi] CBtMtmUi: EditL 1 \t" ) );

	iBaseMtm.Entry().SetEntryL( aSelection.At(0) );

	return EditL( aStatus );

	}

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

// EditL(TRequestStatus& aStatus)

// Handles message sending over Bluetooth.

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

//

CMsvOperation* CBtMtmUi::EditL( TRequestStatus& aStatus )

	{

	FLOG( _L( "[BtMtmUi] CBtMtmUi: EditL 2 \t" ) );

    TInt resourceId;

    TInt retVal=0;

	switch( iBaseMtm.Entry().Entry().iType.iUid )

		{

	    case KUidMsvMessageEntryValue:

		    {

		    if( iBaseMtm.Entry().Entry().Parent() != KMsvDraftEntryId &&

		       iBaseMtm.Entry().Entry().Parent() != KMsvGlobalOutBoxIndexEntryId )

			    {

			    //   Edit/"use" entries in the Inbox

			    return LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session() );   

			    }

		    else

			    {

                HBufC* password = HBufC::NewL(1);

                CleanupStack::PushL( password );  // 1st push

                BaseMtm().LoadMessageL();

                TBTDevAddr address;

                CBtClientMtm::SBtcCmdSendParams sendparams;

			    sendparams.iTimeouts.iConnectTimeout    = KBtMtmUiConnectionTimeout;

			    sendparams.iTimeouts.iPutTimeout        = KBtMtmUiConnectionPutTimeout;

			    sendparams.iRemoteObexPort              = KBtMtmUiObexPort;

			    sendparams.iConnectPassword             = password;

                iDiscovery = CBTEngDiscovery::NewL(this);

				CBTDevice* iDevice = CBTDevice::NewL( );

                if ( iDiscovery->SearchRemoteDevice( iDevice ) == KErrNone )

				{ 

				    iWaiter.Start();

				    if ( iState ==KErrNone)

				        {

					    address = iDevice->BDAddr();

				        FLOG( _L( "[BtMtmUi] CBtMtmUi:SearchRemoteChannelL \t" ) );

                        retVal = iDiscovery->RemoteProtocolChannelQuery(address, TUUID(KBTSdpObjectPush));

                        if(retVal == KErrNone)

                            {

                            iWaiter.Start();

                            }

                        }

                    if ( retVal != KErrNone ||iState  != KErrNone )

                        {

                        resourceId = R_BT_DEV_NOT_AVAIL;                        

						TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

                        CleanupStack::PopAndDestroy(3); // BtDevice, BtConnection, password

                        return CMsvCompletedOperation::NewL(

                             Session(), 

                             Type(), 

                             KNullDesC8, 

                             KMsvLocalServiceIndexEntryId, 

                            aStatus );

                        }                     

                    sendparams.iRemoteObexPort = iClientChannel;

			        TPtrC8 ptr8 = address.Des();

                    TBuf16<KBtMtmUiAddressMaxLength> convertedaddress16;//48 bits

                    // Bt address conversion

			        TInt i;

                    for( i=0; i<3; i++ )

                        {

			            TUint16 word = ptr8[( i*2 )+1];

			            word = ( TUint16 )( word << 8 );

			            word = ( TUint16 )( word + ptr8[i*2] );

			            convertedaddress16.Append( &word, 1 );

			            }

			        BaseMtm().AddAddresseeL( convertedaddress16 );

                    }

                else

                    {

                    CleanupStack::PopAndDestroy(3); // BtDevice, BTConnection, password

				    FLOG( _L( "[BTMTMUI] CBtMtmUi:CMsvCompletedOperation NewL\t" ) );

                    return CMsvCompletedOperation::NewL(

                        Session(), 

                        Type(), 

                        KNullDesC8, 

                        KMsvLocalServiceIndexEntryId, 

                        aStatus );

                    }

			    CMsvEntrySelection* sel = new( ELeave ) CMsvEntrySelection();

			    CleanupStack::PushL( sel );					// 4th push

			    sel->AppendL( BaseMtm().Entry().EntryId() );

			    CMsvOperationWait* waiter = CMsvOperationWait::NewLC();	// 5th push

                TBuf<KBtMtmUiToFromFieldBuffer> toFrom;

                resourceId = R_BT_SEND_OUTBOX_SENDING;                

				TObexUtilsUiLayer::ReadResourceL( toFrom, resourceId );

                BaseMtm().SaveMessageL();

                TMsvEntry newTEntry( iBaseMtm.Entry().Entry() );

			    newTEntry.iDetails.Set( toFrom );

                newTEntry.SetVisible( ETrue );

                newTEntry.SetInPreparation( ETrue );

                iBaseMtm.Entry().ChangeL( newTEntry );

			    CMsvEntry* entry = 

                    BaseMtm().Session().GetEntryL( KMsvDraftEntryId );

                CleanupStack::PushL( entry );  // 6th push

			    CMsvOperation* moveOp = entry->MoveL(

                    *sel,

                    KMsvGlobalOutBoxIndexEntryId, 

                    waiter->iStatus );

                CleanupStack::PopAndDestroy( entry );

			    waiter->Start();

			    CActiveScheduler::Start();

			    delete moveOp;

                CMsvProgressReporterOperation* reporter 

                    = CMsvProgressReporterOperation::NewL( Session(), aStatus );

			    CleanupStack::PushL( reporter );  // 6th push

   			    TPckgBuf<CBtClientMtm::SBtcCmdSendParams> paramBuf( sendparams );

  			    CMsvOperation* op = BaseMtm().InvokeAsyncFunctionL(

                    EBtMtmCmdSend, 

                    *sel,

                    paramBuf, 

                    reporter->RequestStatus() );

                // ownership of op transfered to reporter

		        reporter->SetOperationL( op ); 

                aStatus = KRequestPending;

                CleanupStack::Pop( reporter );

                CleanupStack::PopAndDestroy(3);  // waiter, sel,  password

                return reporter;

			    }

		    }

	    case KUidMsvServiceEntryValue:

	    case KUidMsvAttachmentEntryValue:

	    case KUidMsvFolderEntryValue:

            {

		    User::Leave( KErrNotSupported );

            }

        default:

            {

            break;

            }

		}

	CMsvCompletedOperation* op = CMsvCompletedOperation::NewL(

        Session(), 

        Type(), 

        KNullDesC8, 

        KMsvLocalServiceIndexEntryId, 

        aStatus );

    aStatus = KRequestPending;

	return op;

	}

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

// ViewL(TRequestStatus& aStatus)

// Handles viewing of received object.

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

//

CMsvOperation* CBtMtmUi::ViewL( TRequestStatus& aStatus )

	{

	FLOG( _L( "[CBtMtmUi] CBtMtmUi: ViewL\t" ) );

	return LaunchEditorApplicationL( aStatus, iBaseMtm.Entry().Session() );

	}

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

// ViewL(...)

// Handles viewing of received object using selection.

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

//

CMsvOperation* CBtMtmUi::ViewL( TRequestStatus& aStatus, 

                               const CMsvEntrySelection& aSelection )

	{

    FLOG( _L( "[CBtMtmUi] CBtMtmUi: ViewL 1\t" ) );

	iBaseMtm.Entry().SetEntryL( aSelection.At(0) );

	return ViewL( aStatus );

	}

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

// CopyFromL(...)

// Not supported.

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

//

CMsvOperation* CBtMtmUi::CopyFromL( const CMsvEntrySelection& /*aSelection*/, 

                                   TMsvId /*aTargetId*/, 

                                   TRequestStatus& /*aStatus*/ )

	{

    User::Leave( KErrNotSupported );

    // Return value is needed for removing compilation errors

    return NULL;

	}

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

// MoveFromL(...)

// Not supported.

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

//

CMsvOperation* CBtMtmUi::MoveFromL( const CMsvEntrySelection& /*aSelection*/, 

                                   TMsvId /*aTargetId*/, 

                                   TRequestStatus& /*aStatus*/ )

	{

    User::Leave( KErrNotSupported );

    // Return value is needed for removing compilation errors

    return NULL;

	}

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

// MoveToL(...)

// Not supported.

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

//

CMsvOperation* CBtMtmUi::MoveToL( const CMsvEntrySelection& /*aSelection*/, 

                                 TRequestStatus& /*aStatus*/)

	{

    User::Leave( KErrNotSupported );

    // Return value is needed for removing compilation errors

    return NULL;

	}

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

// CopyToL(...)

// Not supported.

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

//

CMsvOperation* CBtMtmUi::CopyToL( const CMsvEntrySelection& /*aSelection*/, 

                                 TRequestStatus& /*aStatus*/)

	{

    User::Leave( KErrNotSupported );

    // Return value is needed for removing compilation errors

    return NULL;

	}

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

// DisplayProgressSummary(const TDesC8& aProgress) const

// calls leaving DisplayProgressSummaryL -function and

// traps the error.

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

//

TInt CBtMtmUi::DisplayProgressSummary( const TDesC8& aProgress ) const

    {

    TInt retVal = KErrNone;

    TRAP( retVal, retVal = DisplayProgressSummaryL( aProgress ) );

    return retVal;

    }

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

// DisplayProgressSummary(const TDesC8& aProgress) const

// calls leaving DisplayProgressSummaryL -function and

// traps the error.

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

//

TInt CBtMtmUi::DisplayProgressSummaryL( const TDesC8& aProgress ) const

	{

	FLOG( _L( "[CBtMtmUi] CBtMtmUi:DisplayProgressSummaryL\t" ) );

    TInt resourceId;

    if( ( !aProgress.Length() ) || ( aProgress.Size() == sizeof( TMsvLocalOperationProgress ) ) )

        {

        // Probably a CMsvCompletedOperation

        return KErrCancel;

        }

	TPckgBuf<TObexMtmProgress> paramPack;

	paramPack.Copy( aProgress );

	TObexMtmProgress& progress = paramPack();

	const TObexMtmProgress::TSendState progressType	= progress.iSendState;

	const TInt error = progress.iError;

    if ( error == KErrInUse )

		{

        resourceId = R_BT_DEV_NOT_AVAIL;

		TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

	    return KErrNone;

		}

	switch( progressType )

		{

	    case TObexMtmProgress::EDisconnected:

            {

            FLOG( _L( "[CBtMtmUi] CBtMtmUi:DisplayProgressSummaryL: EDisconnected\t" ) );

            // Allowed to send again.

            resourceId = R_BT_DATA_SENT;

			TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

		    break;

            }

        case TObexMtmProgress::ESendError:

            {

            FLOG( _L( "[CBtMtmUi] CBtMtmUi:DisplayProgressSummaryL: ESendError\t" ) );

            if( error == KErrIrObexClientNoDevicesFound )

                {

                resourceId = R_BT_DEV_NOT_AVAIL;

				TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

                }

            else

                {

                resourceId = R_BT_FAILED_TO_SEND;

				TObexUtilsUiLayer::ShowErrorNoteL( resourceId );