/*

* Copyright (c) 2009 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:

*

*/

#include <aknlistquerydialog.h>

#include <AiwGenericParam.hrh>

#include <AiwGenericParam.h>

#include <AiwVariant.h>

#include <eikappui.h>

#include <aknnotewrappers.h>

#include <AknWaitDialog.h>

#include <coemain.h>

#include <calattachment.h>

#include <CalenInterimUtils2.h>

#include <calencommonui.rsg>

#include <StringLoader.h>           // StringLoader

#include <DRMHelper.h>

#include <caf/data.h>

#include <caf/caf.h>

#include <calencommandhandler.h>

#include <calencontext.h>

#include <calentoolbar.h>

#include "calenattachmentui.h"

#include "calendarui_debug.h"

#include "calenattachmentutils.h"

#include "calencontroller.h"

#include "calenviewattachmentsdialog.h"

#include "calendar.hrh"

#include "calenattachmentmodel.h"

#include "calenattachmentinfo.h"

#include "CleanupResetAndDestroy.h"

#include "calenviewmanager.h"

//_LIT16( KTextDataType, ".txt" );

const TInt KCalenAttachmentOverhead = 1024;

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

// CCalenAttachmentUi::NewL

// 1st phase of construction

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

//

CCalenAttachmentUi* CCalenAttachmentUi::NewL(CCalenController& aController)

    {

    TRACE_ENTRY_POINT;

    CCalenAttachmentUi* self = new (ELeave) CCalenAttachmentUi(aController);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenAttachmentUi::~CCalenAttachmentUi

// Destructor

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

//

CCalenAttachmentUi::~CCalenAttachmentUi()

    {

    TRACE_ENTRY_POINT;

    delete iTitle;

    iController.CancelNotifications( this );

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUi::CCalenAttachmentUi

// Default constructor

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

//        

CCalenAttachmentUi::CCalenAttachmentUi(CCalenController& aController)

: iController(aController), iAttachmentLoadingOn(EFalse), 

iAddAttachmentFromViewer(EFalse),iViewerActive(EFalse)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;    

    }

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

// CCalenAttachmentUi::ConstructL

// 2nd phase constructor

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

//        

void CCalenAttachmentUi::ConstructL()

    {

    TRACE_ENTRY_POINT;

    RArray<TCalenNotification> notificationArray;

    notificationArray.Append(ECalenNotifyEntrySaved);

    notificationArray.Append(ECalenNotifyEntryDeleted);

    notificationArray.Append(ECalenNotifyEntryClosed);

    notificationArray.Append(ECalenNotifyInstanceDeleted);

    notificationArray.Append(ECalenNotifyMarkedEntryDeleted);

    notificationArray.Append(ECalenNotifyMultipleEntriesDeleted);

    notificationArray.Append(ECalenNotifyDialogClosed);

    notificationArray.Append(ECalenNotifyAttachmentViewerClosed);

    iController.RegisterForNotificationsL( this, notificationArray );

    notificationArray.Reset();

    iAttachmentModel = &iController.AttachmentData();

    iAttachmentModel->SetObserver(this);

    iAttachmentAlreadyExists = EFalse;

    iAttachmentInfoIntialized = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUi::HandleCommandL

// Handles the attachement commands

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

//        

TBool CCalenAttachmentUi::HandleCommandL(const TCalenCommand& aCommand)

    {

    TRACE_ENTRY_POINT;

    TInt continueCommand(EFalse);

    switch(aCommand.Command())

        {

        case ECalenAddAttachment:

            {

            HandleAddAttachmentL();

            }

            break;

        case ECalenAddAttachmentFromViewer:

            {

            iAddAttachmentFromViewer = ETrue;

            HandleAddAttachmentL();

            }

            break;

        case ECalenViewAttachmentList:

            {

            DoAttachmentL();

            }

            break;

        case ECalenRemoveAttachment:

            {

            CheckForExistingAttachmentsL();

            RPointerArray<CCalenAttachmentInfo> attachmentInfoList;

            iAttachmentModel->GetAttachmentListL(attachmentInfoList); 

            if(!iAddAttachmentFromViewer && (attachmentInfoList.Count()))

                {                                

                iAttachmentModel->Reset();

                iController.BroadcastNotification(ECalenNotifyAttachmentRemoved);

                }                    

            else

                {

                iAttachmentModel->DeleteAttachment(0);

                }

            RemoveTemporaryFiles();

            attachmentInfoList.Close(); 

            }

            break;

        default:

            break;

        }

    TRACE_EXIT_POINT;

    return continueCommand;

    }

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

// CCalenAttachmentUi::CalenCommandHandlerExtensionL

// Dummy implementation.

// (other items were commented in a header).

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

//

TAny* CCalenAttachmentUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return NULL;

    }

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

// CCalenAttachmentUi::HandleNotification

// Handle notifications

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

//        

void CCalenAttachmentUi::HandleNotification(const TCalenNotification aNotification)

    {

    TRACE_ENTRY_POINT;

    TRAP_IGNORE(DoHandleNotificationL(aNotification));

    TRACE_EXIT_POINT;     

    }

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

// CCalenAttachmentUi::DoHandleNotificationL

// Handle notifications

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

// 

void CCalenAttachmentUi::DoHandleNotificationL(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    switch(aNotification)

        {

        case ECalenNotifyEntrySaved:

        case ECalenNotifyEntryDeleted:

        case ECalenNotifyInstanceDeleted:            

            {

            if(!(iAddAttachmentFromViewer))

                {

                iAttachmentModel->Reset();

                } 

            // clear calendar editor's folder

            RemoveTemporaryFiles();

            iAttachmentInfoIntialized = EFalse;

            }

            break;            

        case ECalenNotifyEntryClosed:

        case ECalenNotifyMarkedEntryDeleted:

        case ECalenNotifyMultipleEntriesDeleted:

        case ECalenNotifyDialogClosed:

            {

            if(!(iAddAttachmentFromViewer) && !(iAttachmentAlreadyExists))

                {

                iAttachmentModel->Reset();

                }    

            iAttachmentAlreadyExists = EFalse;

            iAttachmentInfoIntialized = EFalse;

            }

            break;

        case ECalenNotifyAttachmentViewerClosed:

            {

            if(iAddAttachmentFromViewer)

                {

                // add attachments to the entry being viewed in event viewer

                AddAttachmentsToEntryL();

                // Do not reset the model if the attachment list has been opened from the editor.

                if(!iController.IsEditorActive())

                    {

                    // clear calendar editor's folder

                    RemoveTemporaryFiles();

                    iAttachmentModel->Reset();

                    }

                iAddAttachmentFromViewer = EFalse;

                // refresh the event view

                iController.ViewManager().StartActiveStepL();

                }

            MCalenToolbar* toolbar = iController.Services().ToolbarOrNull();

            if(toolbar)

                {

                if(iShowToolbar)

                    {

                    toolbar->SetToolbarVisibilityL(ETrue);

                    }

                iShowToolbar = EFalse;

                }

            iAttachmentInfoIntialized = EFalse;            

            iViewerActive = EFalse;

            }

            break;

        default:

            break;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUi::HandleAddAttachmentL

// Handles the command ECalenAddAttachment

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

// 

void CCalenAttachmentUi::HandleAddAttachmentL()

    {

    TRACE_ENTRY_POINT;

    TInt selectedIndex(0);

    CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog(&selectedIndex);

    dlg->PrepareLC( R_ATTACHMENT_LIST_QUERY );

    if(dlg->RunLD())

        {

        iSelectedCommand = selectedIndex;

        switch(selectedIndex)

            {

            case ECalenAddImage:

                {

                FetchFileL(CCalenAttachmentUtils::EImage);

                }

                break;

            case ECalenAddNote:

                {

                FetchFileL(CCalenAttachmentUtils::ENote);

                }

                break;

            case ECalenAddAudio:

                {

                FetchFileL(CCalenAttachmentUtils::EAudio);

                }

                break;

            case ECalenAddVideo:

                {

                FetchFileL(CCalenAttachmentUtils::EVideo);

                }

                break;

            case ECalenAddOtherFiles:

                {

                FetchFileL(CCalenAttachmentUtils::EUnknown);

                }

                break;

            default:

                break;

            }

        }

    else

        {

        iController.BroadcastNotification(ECalenNotifyDialogClosed);

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUi::FetchFileL

// For fetching the file from other apps

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

//

TBool CCalenAttachmentUi::FetchFileL( 

                    CCalenAttachmentUtils::TCalenAttachmentFileType aFetchType)

    {

    TRACE_ENTRY_POINT;       

    TAiwVariant sizeLimit( KCalenAttachmentOverhead );

    TAiwGenericParam sizeLimitParam( EGenericParamMMSSizeLimit, sizeLimit );

    CAiwGenericParamList* paramList = CAiwGenericParamList::NewLC();

    paramList->AppendL( sizeLimitParam );

    CDesCArrayFlat* files = new( ELeave ) CDesC16ArrayFlat(1);

    CleanupStack::PushL(files);

    TBool fetchOk(EFalse);

    if(aFetchType == CCalenAttachmentUtils::EUnknown)

        {

        TFileName fileName(KNullDesC);

        // used for fetching any file from the file system

        if(CCalenAttachmentUtils::FetchAnyFileL( fileName, this ))

            {

            fetchOk = ETrue;

            }

        }

    else

        {       

        // used for fetching media file and notes 

        fetchOk = CCalenAttachmentUtils::FetchFileL( aFetchType, *files,

                                        paramList, EFalse, EFalse, this );

        if(fetchOk && iSelectedCommand == ECalenAddNote)

            {         

            AddAttachmentL(files->MdcaPoint(0));

            }                

        }

    CleanupStack::PopAndDestroy( 2, paramList );

    if(!fetchOk)

        {

        iController.BroadcastNotification(ECalenNotifyDialogClosed);

        }

    TRACE_EXIT_POINT;

    return fetchOk;

    }

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

// CCalenAttachmentUi::VerifySelectionL

// Interface for verifying fetched media files selection

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

//

TBool CCalenAttachmentUi::VerifySelectionL(const MDesCArray* aSelectedFiles)

    {

    TRACE_ENTRY_POINT;

    TInt selectedFilesCount = aSelectedFiles->MdcaCount();

    for(TInt index=0;index<selectedFilesCount;index++)

        {

        RFile file;

        CEikonEnv* eikonEnv = CEikonEnv::Static();

        RFs& fs = eikonEnv->FsSession();

        User::LeaveIfError(fs.ShareProtected());

        TInt err = file.Open( fs, aSelectedFiles->MdcaPoint(index), EFileRead );

        file.Close();

        if( KErrNone != err )

            {

            // if any error in opening file then return EFalse

            return EFalse;

            }

        AddAttachmentL(aSelectedFiles->MdcaPoint(index));

        } 

    TRACE_EXIT_POINT; 

    return ETrue;

	}

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

// CCalenAttachmentUi::OkToExitL

// Get's called when user selects any file from file system through common

// memory dialogs

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

//

TBool CCalenAttachmentUi::OkToExitL( const TDesC& aDriveAndPath, const TEntry& aEntry )

    {

    TRACE_ENTRY_POINT;

    TInt length = aDriveAndPath.Length() + aEntry.iName.Length();

    if(length)

        {

        HBufC* filename = HBufC::NewLC( length );

        TPtr ptr = filename->Des();

        ptr.Append( aDriveAndPath );

        ptr.Append( aEntry.iName );

        RFile file;

        CEikonEnv* eikonEnv = CEikonEnv::Static();

        RFs& fs = eikonEnv->FsSession();

        User::LeaveIfError(fs.ShareProtected());

        TInt err = file.Open( fs, *filename, EFileRead );

        file.Close();

        if( KErrNone != err )

            {

            // if any error in opening file then return EFalse

            return EFalse;

            }

        AddAttachmentL(*filename);

        CleanupStack::PopAndDestroy(filename);

        }

    TRACE_EXIT_POINT;

    return ETrue;

    }

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

// CCalenAttachmentUi::CheckForExistingAttachmentsL

// check for already existing attachments from the entry

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

//

void CCalenAttachmentUi::CheckForExistingAttachmentsL()

    {

    TRACE_ENTRY_POINT;

    if( iAttachmentInfoIntialized )

        return;

    MCalenContext& context = iController.Services().Context();

    TCalLocalUid entryUid = context.InstanceId().iEntryLocalUid;

    if(entryUid)  // If it is not for new entry

	    {

	    CCalEntry* entry = iController.Services().EntryViewL(context.InstanceId().iColId)->FetchL(entryUid);

	    CleanupStack::PushL(entry);

	    if(entry)

	        {

	        iAttachmentModel->CheckForExistingAttachmentsL(entry);

	        iAttachmentInfoIntialized = ETrue;

	        }

	    CleanupStack::PopAndDestroy(entry);

	    }

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUi::NotifyChanges

// Notify if attachment added or removed

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

//

void CCalenAttachmentUi::NotifyChanges( TCalenAttachmentCommand aCommand, 

                                       TInt aAttachmentIndex )

    {

    TRACE_ENTRY_POINT;

    if(iViewerActive)

        {

        iController.ViewManager().SetRepopulation(ETrue);

        }

    if(aCommand == ECalenAttachmentAdded)

        {

        iController.BroadcastNotification(ECalenNotifyAttachmentAdded);

        }

    else if(aCommand == ECalenAttachmentRemoved)

        {

        TRAP_IGNORE(RemoveAttachmentFromEntryL(aAttachmentIndex));

        iController.BroadcastNotification(ECalenNotifyAttachmentRemoved);

        }

    TRACE_ENTRY_POINT;

    }

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

// CCalenAttachmentUi::GetAttachmentFileL

// Notify if attachment added or removed

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

//

RFile CCalenAttachmentUi::GetAttachmentFileL(TInt aIndex)

    {

    TRACE_ENTRY_POINT;

    MCalenContext& context = iController.Services().Context();