/*

* 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 : Utils used for calendar's attachment support

*

*/

#include <eikenv.h>

#include <eikappui.h>

#include <txtetext.h>

#include <NpdApi.h>

#include <StringLoader.h>

#include <MGFetch.h>

#include <apparc.h>

#include <bautils.h>

#include <apgcli.h>

#include <AknCommonDialogsDynMem.h>

#include <aknlistquerydialog.h>

#include <AiwGenericParam.hrh>

#include <AiwGenericParam.h>

#include <AiwVariant.h>

#include <StringLoader.h>           // StringLoader

#include <DRMHelper.h>

#include <caf/data.h>

#include <caf/caf.h>  

#include <driveinfo.h>

#include <apmrec.h>

#include <calencommonui.rsg>

#include <avkon.rsg>

#include <coemain.h>

#include <calattachment.h>

#include <CalenInterimUtils2.h>

#include <aknnotewrappers.h>

#include <DocumentHandler.h>

#include <bautils.h>

#include "calendar.hrh"

#include "calenattachmentutils.h"

#include "calendarui_debug.h"

const TInt KCalenTextFileNameLength = 20;

_LIT( KTextFilenameExtension, ".txt" );

_LIT8( KNotePadTextDataType, "text/plain" );

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

// CCalenAttachmentUtils::FetchFile

// Fetches any media file like images/audio files/video files

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

//

EXPORT_C TBool CCalenAttachmentUtils::FetchFileL ( TCalenAttachmentFileType aType,

                    CDesCArray& aSelectedFiles, CAiwGenericParamList* /*aParams*/,

                    TBool /*aCheckDiskSpace*/, TBool aMultiSelect,

                    MMGFetchVerifier* aVerifier )

    {

    TRACE_ENTRY_POINT;

    TBool result = EFalse;

    switch(aType)

        {

        case EImage:

            {

            result = FetchExistingL( EImageFile, aSelectedFiles, aMultiSelect, aVerifier );

            break;

            }

        case ENote:

            {

            result = FetchNoteL( aSelectedFiles );

            break;

            }            

        case EAudio:

            {

            result = FetchExistingL( EAudioFile, aSelectedFiles, aMultiSelect, aVerifier );

            break;

            }

        case EVideo:

            {

            result = FetchExistingL( EVideoFile, aSelectedFiles, aMultiSelect, aVerifier );

            break;

            }

        default:

            {

            break;

            }

        }

    TRACE_EXIT_POINT;

    return result;

    }

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

// CCalenAttachmentUtils::FetchExistingL

// Fetches existing file 

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

//

TBool CCalenAttachmentUtils::FetchExistingL( TMediaFileType aFileType,

                                             CDesCArray& aSelectedFiles,

                                             TBool aMultiSelect,

                                             MMGFetchVerifier* aVerifier )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return MGFetch::RunL( aSelectedFiles, aFileType, aMultiSelect, aVerifier );

    }

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

// CCalenAttachmentUtils::FetchNoteL

// Fetches note using notepad api

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

//

TBool CCalenAttachmentUtils::FetchNoteL(CDesCArray& aSelectedFiles)

    {

    TRACE_ENTRY_POINT;

    TBool result = EFalse;

    CEikonEnv* eikonEnv = CEikonEnv::Static();

    // get memo content from notepad to buffer.

    HBufC* buf = CNotepadApi::FetchMemoL();

    if(buf)

        {

        CleanupStack::PushL(buf);

        RFs& fs = eikonEnv->FsSession();

        TFileName filename;

        TInt max = KCalenTextFileNameLength;

        // first try to create filename from memo text.

        GetFileNameFromBuffer( filename, *buf, max, &KTextFilenameExtension );

        if(filename.Length()== 0)

            {

            eikonEnv->ReadResourceL( filename, R_QTN_CALEN_NO_NAME_FOR_FILE );

            filename.Append( KTextFilenameExtension );

            }

        TFileName pathname;

        GetCalenEditorTempPath( pathname, &filename );

        // check the file name for validity and possible name duplicates.

        TInt err = KErrNone;

        if(!BaflUtils::FolderExists(fs,pathname))

            {

            err = CApaApplication::GenerateFileName( fs, pathname );

            }

        if(err==KErrNone)

            {

            // write buffer to text file

            CPlainText* text = CPlainText::NewL();

            CleanupStack::PushL( text );

            text->InsertL( 0, *buf );

            text->ExportAsTextL( pathname, CPlainText::EOrganiseByParagraph, 0 );

            CleanupStack::PopAndDestroy( text );

            aSelectedFiles.AppendL( pathname );

            result = ETrue;

            }

        CleanupStack::PopAndDestroy( buf );

        }

    TRACE_EXIT_POINT;

    return result;

    }

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

// from: TBool CImRecvConvert::IsIllegalChar(const TUint aChar)

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

LOCAL_C TBool IsIllegalChar(const TUint aChar)

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return (

        aChar == '*'  ||

        aChar == '//' ||

        aChar == '<'  ||

        aChar == '>'  ||

        aChar == ':'  ||

        aChar == '.'  ||

        aChar == '"'  ||

        aChar == '/'  ||

        aChar == '|'  ||

        aChar == '?'  ||

        aChar == CEditableText::EParagraphDelimiter  ||

        aChar == CEditableText::ELineBreak  ||

        aChar <  ' ' );

    }

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

// CCalenAttachmentUtils::GetFileNameFromBuffer

// Get the file name by making use of the content

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

//

void CCalenAttachmentUtils::GetFileNameFromBuffer( TFileName& aFileName,

            const TDesC& aBuffer, TInt aMaxLength, const TDesC* aExt /*= NULL*/ )

    {

    TRACE_ENTRY_POINT;

    if(aExt!=NULL)

        {

        aMaxLength -= aExt->Length();

        }

    TInt len = aBuffer.Length();

    TInt max = Min( len, aMaxLength );

    aFileName.Zero();

    TInt cc = 0;

    TUint ch;

    TUint ch1 = 0;

    TBool spaces = EFalse;

    for( TInt i = 0; i < len && cc < max; i++ )

        {

        ch = aBuffer[i];

        // ignore spaces from beginning of the buffer until first

        // non-space is encountered.

        if( !spaces && ch != ' ' )

            {

            spaces = ETrue;

            }

        if(i>0)

            {

            ch1 = aBuffer[i-1];

            }

        // strip illegal chars away.

        // checks also if previous and current chars are '.'

        if( spaces && !IsIllegalChar(ch) )

            {

            if( !( i > 0 && ch == '.' && ch1 == '.' ) )

                {

                aFileName.Append( ch );

                cc++;

                }

            }

        }

    aFileName.Trim();

    // If filename is empty at this point, do not append extension either.

    // Instead, empty filename is returned so that caller can use whatever

    // default name

    if( aFileName.Length() > 0 && aExt != NULL )

        {

        aFileName.Append(*aExt);

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenAttachmentUtils::GetCalenEditorTempPath

// Returns temp path used by unified editor and optionally

// appends file name to it.

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

//

EXPORT_C void CCalenAttachmentUtils::GetCalenEditorTempPath( TFileName& aTempPath,

                                                    const TDesC* aFileName )

    {

    TRACE_ENTRY_POINT;

    TInt driveNumber( EDriveD );

    #ifdef RD_MULTIPLE_DRIVE

        if(DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRam, driveNumber ) != KErrNone )

            {

            DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, driveNumber );

            }

    #endif

    TChar driveCharacter;

    CEikonEnv::Static()->FsSession().DriveToChar( driveNumber, driveCharacter );

    //aTempPath.Append( driveCharacter );

    aTempPath.Append( KCalenUnifiedEditorTempDir );

    if(aFileName)

        {

        aTempPath.Append(*aFileName);

        }

    TRACE_EXIT_POINT; 

    }

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

// CCalenAttachmentUtils::FetchAnyFileL

// Fetches any file using common dialogs using file storage

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

//

EXPORT_C TBool CCalenAttachmentUtils::FetchAnyFileL( TFileName& aFileName,

                                           MAknFileSelectionObserver* aVerifier,

                                           MAknFileFilter* aFilter )

    {

    TRACE_ENTRY_POINT;

    TBool result(EFalse);

    TInt supportedTypes = AknCommonDialogsDynMem::EMemoryTypePhone | 

                          AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage | 

                          AknCommonDialogsDynMem::EMemoryTypeMMCExternal;

    result = AknCommonDialogsDynMem::RunSelectDlgLD( supportedTypes,

                                               aFileName,

                                               R_CALEN_MEMORY_SELECTION_DIALOG,

                                               aFilter,

                                               aVerifier );

    TRACE_EXIT_POINT;

    return result;

    }

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

// CCalenAttachmentUtils::GetMimeType

// Reads file's Mime type

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

//

EXPORT_C TDataType CCalenAttachmentUtils::GetMimeType(RFile aFile)

    {

    TRACE_ENTRY_POINT;

    TDataType dataType;

    RApaLsSession aApaSession;

    if(aFile.SubSessionHandle())

        {

        TUid appUid(KNullUid);

        TInt error(0);

        if(!aApaSession.Handle())

            {

            error = aApaSession.Connect();

            }

        if(error == KErrNone)

            {

            TDataRecognitionResult recognitionResult;

            error = aApaSession.RecognizeData(aFile, recognitionResult);

            if( recognitionResult.iConfidence != CApaDataRecognizerType::ENotRecognized &&

                error == KErrNone)

                {

                dataType = recognitionResult.iDataType;

                }

            else

                {

                // not recognised

                }

            }

        }

    aApaSession.Close();

    TRACE_EXIT_POINT;

    return dataType;    

    }

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

// CCalenAttachmentUtils::GetMimeType

// Reads file's Mime type

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

//

EXPORT_C TDataType CCalenAttachmentUtils::GetMimeTypeL(const TDesC& aFileName)

    {

    TRACE_ENTRY_POINT;

    TDataType dataType;

    RFs& fs = CCoeEnv::Static()->FsSession();

    RFile attachmentFile;

    User::LeaveIfError( attachmentFile.Open( fs, aFileName,

                                             EFileShareReadersOnly) );

    CleanupClosePushL(attachmentFile);

    dataType = GetMimeType(attachmentFile);    

    CleanupStack::PopAndDestroy();

    TRACE_EXIT_POINT;

    return dataType;    

    }

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

// CCalenAttachmentUtils::GetMimeType

// Gets file size in bytes based on the file name

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

//

EXPORT_C TInt CCalenAttachmentUtils::GetFileSizeL(const TDesC& aFileName)

    {

    TRACE_ENTRY_POINT;

    RFs& fs = CCoeEnv::Static()->FsSession();

    RFile attachmentFile;

    TInt fileSize(0);

    User::LeaveIfError( attachmentFile.Open( fs, aFileName,

                                             EFileShareReadersOnly) );

    CleanupClosePushL(attachmentFile);

    attachmentFile.Size(fileSize);

    CleanupStack::PopAndDestroy();

    TRACE_EXIT_POINT

    return fileSize;

    }

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

// CCalenAttachmentUtils::OpenAttachmentL

// Opens a particular attachment

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

//

EXPORT_C void CCalenAttachmentUtils::OpenAttachmentL(RFile& file, MAknServerAppExitObserver& aExitObserver)

    {

    TRACE_ENTRY_POINT;

    CDocumentHandler* docHandler = CDocumentHandler::NewL( CEikonEnv::Static()->Process() );

    docHandler->SetExitObserver( &aExitObserver );

    TBuf<250> fileName;

    file.FullName(fileName);

    TDataType datatype( GetMimeTypeL(fileName) );

    TInt ret = KErrNone;

    file.Close();

    RFs& fs = CEikonEnv::Static()->FsSession();

    //open the file, before giving it to Notepad.

    TInt err1 = file.Open( fs, fileName, EFileRead | EFileShareReadersOnly );

    CleanupClosePushL( file );

    const TDesC& notepadTitle = _L("NotePad");

    if(datatype == KNotePadTextDataType())

        {

        // file handle ownership transferred.

        ret = CNotepadApi::ExecFileViewerL( file, 

                                            &notepadTitle,

                                            ETrue,

                                            EFalse,

                                            KCharacterSetIdentifierIso88591 );

        }

    else

        {

        //doc handler will open the other files (other than text file).

        TRAP( ret, docHandler->OpenFileEmbeddedL( file, datatype ) );

        }

    CleanupStack::PopAndDestroy(&file);

    delete docHandler;

    switch(ret)

        {

        case KErrNone:

            break;

        default:

            {

            CAknInformationNote* note = new ( ELeave ) CAknInformationNote;

            HBufC* cannotOpen = StringLoader::LoadL( 

                    R_QTN_CALEN_INFO_CANNOT_OPEN, CEikonEnv::Static() );

            note->ExecuteLD( *cannotOpen );

            CleanupStack::PopAndDestroy();

            }

            break;

        }

    TRACE_EXIT_POINT

    }  

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

// CCalenAttachmentUtils::SaveAttachmentL

// Saves a particular attachment

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

//

EXPORT_C TInt CCalenAttachmentUtils::SaveAttachmentL(RFile& aFile, MAknServerAppExitObserver& aExitObserver)

    {

    TRACE_ENTRY_POINT;

    TFileName fileName;

    aFile.FullName(fileName);

    TDataType nullType;

    CDocumentHandler* handler = CDocumentHandler::NewL( CEikonEnv::Static()->Process() );

    handler->SetExitObserver( &aExitObserver );

    TInt error = handler->CopyL( aFile, fileName, nullType, NULL );

    delete handler;

    TRACE_EXIT_POINT

    return error;

    }

// end of file