/*

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

*      CIrMtmui class

*

*

*/

// INCLUDE FILES

#include "irmtmui.h"

#include "debug.h"

#include <MuiuMsvProgressReporterOperation.h>

#include <ircmtm.h>

#include <mtmuidef.hrh>

#include <mtclreg.h>

#include <obexutilsuilayer.h>

#include <Obexutils.rsg>

#include <msvuids.h>

#include <msvids.h>

#include <obexconstants.h>

#include <btnotif.h>        	// Notifier UID's

#include <aknnotewrappers.h> 	//For notifier

#include <featmgr.h>

#include <SecondaryDisplay/obexutilssecondarydisplayapi.h>

const TInt KIrMtmUiConnectionTimeout     = 20000000;

const TInt KIrMtmUiReceiveTimeout        = 0;

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

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

// might leave.

//

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

    :   CBaseMtmUi(aBaseMtm, aRegisteredMtmDll)

    {

    }

// Two-phased constructor.

CIrMtmUi* CIrMtmUi::NewL(

    CBaseMtm& aBaseMtm, 

    CRegisteredMtmDll& aRegisteredMtmDll)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CIrMtmUi::~CIrMtmUi()

    {

    delete iClientRegistry;

    }

// Symbian OS default constructor can leave.

void CIrMtmUi::ConstructL()

    {

    // --- Make sure base class correctly constructed ---

    CBaseMtmUi::ConstructL();

    TObexUtilsUiLayer::ReadResourceL( iConnectingText, R_IR_CONNECTING );

    TObexUtilsUiLayer::ReadResourceL( iSendingText, R_IR_SENDING_DATA );

    iCurrentlySending = EFalse;

    }

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

// GetResourceFileName(...)

// return progress status.

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

//

void CIrMtmUi::GetResourceFileName( TFileName& aFileName ) const

    { 

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

    aFileName = KObexUtilsFileDrive;

    aFileName += KDC_RESOURCE_FILES_DIR;

    aFileName += KObexUtilsResourceFileName;

    }

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

// QueryCapability(TUid aCapability, TInt& aResponse)

// return capability of mtm.

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

//

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

    {  // Querying of menu availablility is done in syni.

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

    if (aCapability.iUid == KUidMsvMtmUiQueryCanPrintMsgValue)

        {

        aResponse=ETrue;

        return KErrNone;

        }

    return CBaseMtmUi::QueryCapability(aCapability, aResponse);

    }

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

// InvokeSyncFunctionL(...)

// Invoke sync -function from BaseMTM.

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

//

void CIrMtmUi::InvokeSyncFunctionL(

    TInt aFunctionId, 

    const CMsvEntrySelection& aSelection, 

    TDes8& aParameter)

    {

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

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

    }

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

// CreateL(...)

// Entry creation forbidden.

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

//

CMsvOperation* CIrMtmUi::CreateL(

    const TMsvEntry& /*aEntry*/,

    CMsvEntry& /*aParent*/, 

    TRequestStatus& /*aStatus*/)

    {

    // Entries created through utility functions.

    User::Leave(KErrNotSupported);  

    return NULL;

    }

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

// OpenL(TRequestStatus& aStatus)

// handles opening entry.

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

//

CMsvOperation* CIrMtmUi::OpenL(TRequestStatus& aStatus)

    {

    FLOG( _L( "[IRU] CIrMtmUi: 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* CIrMtmUi::OpenL(

    TRequestStatus& aStatus, 

    const CMsvEntrySelection& aSelection)

    {

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

    return OpenL(aStatus);

    }

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

// CloseL(TRequestStatus& aStatus)

// Closes entry.

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

//

CMsvOperation* CIrMtmUi::CloseL(TRequestStatus& aStatus)

    {

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

    CMsvCompletedOperation* op=CMsvCompletedOperation::NewL(

        Session(), 

        Type(), 

        KNullDesC8, 

        KMsvLocalServiceIndexEntryId, 

        aStatus);

    return op;

    }

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

// CloseL(TRequestStatus& aStatus)

// Closes entry using selection.

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

//

CMsvOperation* CIrMtmUi::CloseL(

    TRequestStatus& aStatus, 

    const CMsvEntrySelection& aSelection)

    {

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

    return CloseL(aStatus);

    }

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

// EditL(TRequestStatus& aStatus)

// Handles message sending.

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

//

CMsvOperation* CIrMtmUi::EditL(TRequestStatus& aStatus)

    {

    FLOG( _L( "[IRU] CIrMtmUi: EditL\t" ) );

    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

                {

                FeatureManager::InitializeLibL();                    	

                if(!FeatureManager::FeatureSupported(KFeatureIdIrda))

    			    {

   					FLOG(_L("[IRSS]\t FeatMgr doesn't find IrDA, show not_supported "));

	    			RNotifier notifier;    

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

					TBTGenericInfoNotiferParamsPckg paramsPckg;

					paramsPckg().iMessageType=EIRNotSupported;		

		            TInt status = notifier.StartNotifier(KBTGenericInfoNotifierUid, paramsPckg);

	                if ( status != KErrNone )

	                    {

	                    FTRACE(FPrint(_L("[IRSS]\t void CIrMtmUi::EditL()  ERROR: StartNotifier() failed. Code: %d "), status));

	                    }	    

	                notifier.Close();    	

	                User::Leave(KErrNone);

    	            }    	

    		    FeatureManager::UnInitializeLib();

                CIrClientMtm::STimeouts timeouts;

                timeouts.iConnectTimeout = KIrMtmUiConnectionTimeout;

                timeouts.iPutTimeout     = KIrMtmUiReceiveTimeout;

                TPckgBuf<CIrClientMtm::STimeouts> timeoutBuf( timeouts );

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

                CleanupStack::PushL( sel );

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

                CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

                TBuf<KObexUtilsMaxCharToFromField> toFrom;

                TInt resourceId = R_IR_SEND_OUTBOX_SENDING;

                TObexUtilsUiLayer::ReadResourceL( toFrom, resourceId );

                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 );

                CMsvOperation* moveOp = entry->MoveL(

                    *sel, 

                    KMsvGlobalOutBoxIndexEntryId, 

                    waiter->iStatus );

                CleanupStack::PopAndDestroy(entry);

                waiter->Start();

                CActiveScheduler::Start();

                delete moveOp;

                CleanupStack::PopAndDestroy(waiter);

                TInt dialogIndex =((R_IR_SENDING_DATA & KResourceNumberMask) - KFirstResourceOffset) + KEnumStart;

                CMsvProgressReporterOperation* reporter = 

                    CMsvProgressReporterOperation::NewL( Session(), aStatus, dialogIndex, KObexUtilsCategory);

                CleanupStack::PushL( reporter );

                CMsvOperation* op = BaseMtm().InvokeAsyncFunctionL(

                    CIrClientMtm::EIrcCmdSend, 

                    *sel, 

                    timeoutBuf, 

                    reporter->RequestStatus() );

                // ownership of op transfered to reporter

                reporter->SetOperationL( op ); 

                reporter->SetTitleL(iConnectingText);

                aStatus = KRequestPending;

                CleanupStack::Pop(reporter);

                CleanupStack::PopAndDestroy(sel);

                // ownership of reporter transfered to caller

                return reporter; 

                }

            }

        case KUidMsvServiceEntryValue:

        case KUidMsvAttachmentEntryValue:

        case KUidMsvFolderEntryValue:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        default:

            {

            break;

            }

        }

    CMsvCompletedOperation* op = CMsvCompletedOperation::NewL(

        Session(), 

        Type(), 

        KNullDesC8, 

        KMsvLocalServiceIndexEntryId, 

        aStatus );

    FLOG( _L( "[IrMtmUi] CIrMtmUi: EditL Done\t" ) );

    aStatus = KRequestPending;

    return op;

    }

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

// EditL(...)

// Handles message sending using selection.

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

//

CMsvOperation* CIrMtmUi::EditL( TRequestStatus& aStatus, 

                               const CMsvEntrySelection& aSelection)

    {

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

    return EditL( aStatus );

    }

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

// ViewL(TRequestStatus& aStatus)

// Handles viewing of received object.

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

//

CMsvOperation* CIrMtmUi::ViewL( TRequestStatus& aStatus )

    {

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

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

    }

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

// ViewL(...)

// Handles viewing of received object using selection.

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

//

CMsvOperation* CIrMtmUi::ViewL( TRequestStatus& aStatus, 

                               const CMsvEntrySelection& aSelection )

    {

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

    return ViewL(aStatus);

    }

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

// CopyFromL(...)

// Not supported.

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

//

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

                                   TMsvId /*aTargetId*/, 

                                   TRequestStatus& /*aStatus*/)

    {

    User::Leave(KErrNotSupported);

    return NULL;

    }

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

// MoveFromL(...)

// Not supported.

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

//

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

                                   TMsvId /*aTargetId*/, 

                                   TRequestStatus& /*aStatus*/)

    {

    User::Leave(KErrNotSupported);

    return NULL;

    }

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

// MoveToL(...)

// Not supported.

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

//

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

                                 TRequestStatus& /*aStatus*/)

    {

    User::Leave(KErrNotSupported);

    return NULL;

    }

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

// CopyToL(...)

// Not supported.

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

//

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

                                 TRequestStatus& /*aStatus*/ )

    {

    User::Leave(KErrNotSupported);

    return NULL;

    }

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

// DisplayProgressSummary(const TDesC8& aProgress) const

// calls leaving DisplayProgressSummaryL -function and

// traps the error.

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

//

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

    {

    FLOG( _L( "[IRU] CIrMtmUi: DisplayProgressSummary\t" ) );

    TInt retVal = KErrNone;

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

    return retVal;

    }

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

// TInt CIrMtmUi::DisplayProgressSummaryL(const TDesC8& aProgress) const

// Shows connection summary.

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

//

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

    {

    FLOG( _L( "[IRU] CIrMtmUi: 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_IR_CANNOT_ESTABLISH;

        TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

        return KErrNone;

        }

    switch( progressType )

        {

        case TObexMtmProgress::EDisconnected:

            {

            // Allowed to send again.

            CONST_CAST( CIrMtmUi*, this )->iCurrentlySending = EFalse;

            resourceId = R_IR_DATA_SENT;

            TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

            break;

            }

        case TObexMtmProgress::ESendError:

            {

            if( error == KErrIrObexClientNoDevicesFound )

                {

                resourceId = R_IR_CANNOT_ESTABLISH;

                TObexUtilsUiLayer::ShowInformationNoteL( resourceId );

                }

            else

                {

                resourceId = R_IR_SENDING_FAILED;

                TObexUtilsUiLayer::ShowErrorNoteL( resourceId );

                }

            break;

            }

        case TObexMtmProgress::ESendComplete:

            {

            break;

            }

        case TObexMtmProgress::EInitialise:

        case TObexMtmProgress::EConnect:

        case TObexMtmProgress::EConnectAttemptComplete:

        case TObexMtmProgress::ESendObject:

        case TObexMtmProgress::ESendNextObject:

            {

            return KErrCancel;

            }

        case TObexMtmProgress::EUserCancelled:

            {

            return KErrCancel;

            }

        default:

            {

            return KErrCancel;

            }

        }

    FLOG( _L( "[IRU] CIrMtmUi: DisplayProgressSummaryL Done\t" ) );

    return KErrNone;

    }

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

// GetProgress(...)

// return progress status.

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

//

TInt CIrMtmUi::GetProgress( const TDesC8& aProgress,

                           TBuf<EProgressStringMaxLen>& aReturnString, 

                           TInt& aTotalEntryCount, 

                           TInt& aEntriesDone,

                           TInt& aCurrentEntrySize, 

                           TInt& aCurrentBytesTrans ) const

    {

    FLOG( _L( "[CIrMtmUi] CIrMtmUi: GetProgress\t" ) );

    TPckgBuf<TObexMtmProgress> paramPack;

    paramPack.Copy( aProgress );

    TObexMtmProgress& progress = paramPack();

    const TObexMtmProgress::TSendState progressType = progress.iSendState;

    aTotalEntryCount    = progress.iTotalEntryCount;

    aEntriesDone        = progress.iEntriesDone;

    aCurrentEntrySize   = progress.iCurrentEntrySize;