/*
* 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:  Functional implementation of PIM service (for vCalendar, vCard)
*
*/


// INCLUDE FILES
#include "../../../symbian_version.hrh"

#include "HtiPIMServicePlugin.h"
#include "PIMHandler.h"

#include <HtiDispatcherInterface.h>
#include <HtiLogging.h>

#include <utf.h>
#include <calcommon.h>
#include <calsession.h>
#include <calentryview.h>

#include <cntdb.h> 
#include <cntitem.h> 
#include <cntfldst.h> 
#include <cntvcard.h> 
#include <cntfilt.h> 
#include <caldataexchange.h> 
#include <caldataformat.h> 

// CONSTANTS
_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );
_LIT8( KErrorCalendarFileFormat, "Invalid format of calendar file name");
_LIT8( KErrorVCardImportFailed, "vCard import failed" );
_LIT8( KErrorVCalendarImportFailed, "vCalendar import failed" );
_LIT8( KErrorMissingVCalendar, "Missing vCalendar object" );
_LIT8( KErrorMissingVCard, "Missing vCard object" );
_LIT8( KErrorInvalidId, "Invalid ID parameter" );
_LIT8( KErrorItemNotFound, "Item not found" );
_LIT8( KErrorFailedDelete, "Failed to delete item" );
_LIT8( KErrorFailedDeleteAll, "Failed to delete all items" );
_LIT8( KErrorFailedOpenCalendar, "Failed to open calendar file");
//_LIT8( KErrorFailedOpenContact, "Failed to open contact database");



_LIT( KDefaultAgendaFile, "" ); // A default file is opened if fileName is KNullDesC

#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )  
_LIT8( KErrorMissingText, "Text parameter missing" );
_LIT8( KErrorMissingFilepath, "Filepath parameter missing" );
_LIT8( KErrorNotepadAddMemoFailed, "Notepad add memo failed" );
_LIT8( KErrorNotepadAddMemoFromFileFailed, "Notepad add memo from file failed" );
_LIT8( KErrorNotepadDeleteAllFailed, "Notepad delete all failed" );

_LIT( KHtiNpdHlpExe,       "HtiNpdHlp.exe" );
_LIT( KCmdAddMemo,         "AddMemo" );
_LIT( KCmdAddMemoFromFile, "AddMemoFromFile" );
_LIT( KCmdDeleteAll,       "DeleteAll" );
_LIT( KCmdDelim,           " " );
#else
_LIT8( KErrorNotepadNotSupported, "Notepad not supported" );
#endif

// ----------------------------------------------------------------------------
CPIMHandler* CPIMHandler::NewL()
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::NewL" );
    CPIMHandler* self = new (ELeave) CPIMHandler();
    CleanupStack::PushL ( self );
    self->ConstructL();
    CleanupStack::Pop();
    HTI_LOG_FUNC_OUT( "CPIMHandler::Done" );
    return self;
    }

// ----------------------------------------------------------------------------
CPIMHandler::CPIMHandler():iIsBusy( EFalse ), iEntryViewErr( KErrNone ),
        iCalSession(NULL)
    {
    }

// ----------------------------------------------------------------------------
CPIMHandler::~CPIMHandler()
    {
    HTI_LOG_TEXT( "CPIMHandler destroy" );
    HTI_LOG_TEXT( "Deleting iCalSession");
    delete iCalSession;
    HTI_LOG_TEXT( "Deleting iWaiter" );
    delete iWaiter;
    }

// ----------------------------------------------------------------------------
void CPIMHandler::ConstructL()
    {
    HTI_LOG_TEXT( "CPIMHandler::ConstructL" );
    iWaiter = new ( ELeave ) CActiveSchedulerWait;
    }

// ----------------------------------------------------------------------------
void CPIMHandler::SetDispatcher( MHtiDispatcher* aDispatcher )
    {
    iDispatcher = aDispatcher;
    }

// ----------------------------------------------------------------------------
void CPIMHandler::ProcessMessageL( const TDesC8& aMessage,
    THtiMessagePriority /*aPriority*/ )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::ProcessMessageL" );

    iIsBusy = ETrue;
    TInt err = KErrNone;

    // Zero legth of aMessage tested already in CHtiPIMServicePlugin.
    // Other sanity checks must be done here.

    TUint8 command = aMessage.Ptr()[0];
    switch ( command )
        {
        case CHtiPIMServicePlugin::EImportVCard:
            {
            TRAP( err, HandleVCardImportFuncL(
                    aMessage.Right( aMessage.Length() - 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::EImportVCalendar:
            {
            TRAP( err, HandleVCalendarImportFuncL(
                    aMessage.Right( aMessage.Length() - 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::EDeleteContact:
            {
            TRAP( err, HandleContactDeleteFuncL(
                    aMessage.Right( aMessage.Length() - 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::EDeleteCalendar:
            {
            TRAP( err, HandleCalendarDeleteFuncL(
                    aMessage.Right( aMessage.Length() - 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::EOpenCalendarFile:
            {
            TRAP( err, HandleOpenCalendarFileL(
                    aMessage.Right( aMessage.Length() - 1 )));
            break;
            }
        case CHtiPIMServicePlugin::EListCalendarFiles:
            {
            TRAP( err, HandleListCalendarFilesL());
            break;
            }
        case CHtiPIMServicePlugin::ENotepadAddMemo:
            {
            TRAP( err, HandleNotepadAddMemoFuncL( aMessage.Mid( 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::ENotepadAddMemoFromFile:
            {
            TRAP( err, HandleNotepadAddMemoFromFileFuncL( aMessage.Mid( 1 ) ) );
            break;
            }
        case CHtiPIMServicePlugin::ENotepadDeleteAll:
            {
            TRAP( err, HandleNotepadDeleteAllFuncL() );
            break;
            }
        default:
            {
            TRAP( err, SendErrorMessageL(
                    KErrArgument, KErrorUnrecognizedCommand ) );
            break;
            }
        }

    if ( err != KErrNone )
        {
        iIsBusy = EFalse;
        User::Leave( err );
        }

    HTI_LOG_FUNC_OUT( "CPIMHandler::ProcessMessageL: Done" );
    }

// ----------------------------------------------------------------------------
TBool CPIMHandler::IsBusy()
    {
    return iIsBusy;
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleOpenCalendarFileL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleOpenCalendarFileL" );
    
    // check the format, the correct format is DriveLetter:FileName
    if (aData.Length() != 0)
        {
        if(aData.Length() < 3 || aData[1] != ':'||
                !(aData[0] >= 'a' && aData[0] <= 'z' || aData[0] >= 'A' && aData[0] <= 'Z'))
            {
            SendErrorMessageL( KErrArgument, KErrorCalendarFileFormat );
            return;
            }
        }
    
    delete iCalSession;
    iCalSession = NULL;
    
    // Open iCalSession
    HTI_LOG_TEXT("Open calendar session");
    iCalSession = CCalSession::NewL();
    TBuf<KMaxFileName + 2> calFile;
    calFile.Copy(aData);
    TRAPD(err, iCalSession->OpenL(calFile));
    if(err == KErrNone)
        {
        HTI_LOG_TEXT("Calendar session open");
        SendOkMsgL( KNullDesC8 );
        }
    else
        {
        HTI_LOG_TEXT("Failed to open calendar file");
        SendErrorMessageL( err, KErrorFailedOpenCalendar );
        delete iCalSession;
        iCalSession = NULL;
        }
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleOpenCalendarFileL: Done" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleListCalendarFilesL()
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleListCalendarFiles" );
    
    CCalSession* calSession = CCalSession::NewL();
    CleanupStack::PushL(calSession);
    HTI_LOG_TEXT("List all calendar files");
    CDesCArray* calFiles = calSession->ListCalFilesL();
    
    if(calFiles == NULL) //No calendar files
        {
        TBuf8<2> reply;
        reply.AppendFill(0, 2);
        SendOkMsgL(reply);
        CleanupStack::PopAndDestroy(); // calSession
        return;
        }
    
    CleanupStack::PushL(calFiles);
    TInt count = calFiles->Count();
    
    // files count + file count * (file name length + max file name + driver letter + ':')
    TInt bufSize = 2 + count * (2 + KMaxFileName + 1 + 1);
    CBufFlat* calListBuf = CBufFlat::NewL( bufSize );
    CleanupStack::PushL(calListBuf);
    
    HBufC8* calArray = HBufC8::NewLC( bufSize );
    TPtr8 calArrayPtr = calArray->Des();
    
    calArrayPtr.Append((TUint8*)(&count), 2);
    TInt pos = 0;
    calListBuf->ExpandL(pos, 2);
    calListBuf->Write(pos, *calArray, 2);
    calArrayPtr.Zero();
    pos += 2;
    
    for(int i = 0; i < count; ++i)
        {
        TInt len = calFiles->MdcaPoint(i).Length();
        calArrayPtr.Append((TUint8*)(&len), 2);
        calArrayPtr.Append(calFiles->MdcaPoint(i));
        calListBuf->ExpandL(pos, calArray->Length());
        calListBuf->Write(pos,*calArray, calArray->Length());
        pos += calArray->Length();
        calArrayPtr.Zero();
        }
    SendOkMsgL( calListBuf->Ptr( 0 ) );
    CleanupStack::PopAndDestroy(4); //calArray, calListBuf, calFiles, calSession;    
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleListCalendarFiles: Done" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleVCardImportFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCardImportFuncL" );
    if ( aData.Length() == 0 )
        {
        SendErrorMessageL( KErrArgument, KErrorMissingVCard );
        return;
        }
    
    CContactDatabase* contactDatabase = CContactDatabase::OpenL();
    HTI_LOG_TEXT( "CPIMHandler: Contact database open" );
    CleanupStack::PushL(contactDatabase);
    
    CBufFlat* buffer = CBufFlat::NewL(aData.Length());
    CleanupStack::PushL(buffer);
    buffer->ExpandL(0, aData.Length());
    buffer->Ptr(0).Copy(aData.Right(aData.Length()));
    RBufReadStream readStream;
    readStream.Open(*buffer, 0);
    CleanupClosePushL<RBufReadStream>( readStream );
    
    // Imports vCard
    TBool success = EFalse;
    TUid format = TUid::Uid(KUidVCardConvDefaultImpl);
    CArrayPtr<CContactItem>* contacts = NULL;
    TRAPD(err,contacts = contactDatabase->ImportContactsL(format, readStream, success, 
            CContactDatabase::EImportSingleContact | CContactDatabase::ETTFormat));
    CleanupStack::PushL(contacts);
    if(err != KErrNone || success == EFalse || contacts == NULL || contacts->Count() == 0)
        {
        HTI_LOG_TEXT("Failed to import vCard");
        SendErrorMessageL( err, KErrorVCardImportFailed );
        }
    else
        {
        // Returns the imported contact id 
        TInt32 entryId = contacts->At(0)->Id();
        TBuf8<4> idBuf;
        idBuf.Append( ( TUint8* ) &entryId, 4 );
        HTI_LOG_TEXT("vCard imported");
        SendOkMsgL( idBuf );
        }
    
    contacts->ResetAndDestroy();
    
    CleanupStack::PopAndDestroy(4); // contacts, readStream, buffer, contactDatabase
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCardImportFuncL: Done" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleVCalendarImportFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCalendarImportFuncL" );

    if ( aData.Length() == 0 )
        {
        HTI_LOG_TEXT( "CPIMHandler::HandleVCalendarImportFuncL: Error: length of data is zero" )
        SendErrorMessageL( KErrArgument, KErrorMissingVCalendar );
        return;
        }

    CBufFlat* buffer = CBufFlat::NewL( aData.Length() );
    CleanupStack::PushL(buffer);
    buffer->ExpandL( 0, aData.Length() );
    buffer->Ptr( 0 ).Copy( aData );
    RBufReadStream readStream;
    readStream.Open( *buffer, 0 );
    CleanupClosePushL( readStream );

    if(iCalSession == NULL)
        {
        HTI_LOG_TEXT( "CPIMHandler: Open default calendar file" );
        iCalSession = CCalSession::NewL();
        iCalSession->OpenL( KDefaultAgendaFile );
        HTI_LOG_TEXT( "CPIMHandler: Calendar session open" );
        }

    CCalDataExchange* importer = CCalDataExchange::NewL(*iCalSession);
    CleanupStack::PushL( importer );
    HTI_LOG_TEXT( "CPIMHandler: Calendar importer created" );

    RPointerArray<CCalEntry> entryArray;
    CleanupClosePushL( entryArray );

    TInt err = KErrNone;
    TInt size = 0;
    // Import as VCalendar
    TRAP( err, importer->ImportL( KUidVCalendar, readStream, entryArray ) );
    HTI_LOG_FORMAT( "ImportL return value %d", err );
    size = entryArray.Count();
    HTI_LOG_FORMAT( "Import VCalendarL imported %d entries", size );
    TCalLocalUid uniqueId = 0;
    TInt success = 0;
    if ( size > 0 )
        {
        CCalEntryView* entryView = CCalEntryView::NewL( *iCalSession, *this );
        iWaiter->Start();
        CleanupStack::PushL(entryView);
        if ( iEntryViewErr == KErrNone )
            {
            TRAP( err, entryView->StoreL( entryArray, success ) );
            HTI_LOG_FORMAT( "StoreL return value %d", err );
            HTI_LOG_FORMAT( "Successfully stored %d entries", success );
            uniqueId = entryArray[0]->LocalUidL();
            }
        CleanupStack::PopAndDestroy();
        }
    entryArray.ResetAndDestroy();
    CleanupStack::PopAndDestroy(); // entryArray

    if ( err == KErrNone && success > 0 )
        {
        HTI_LOG_TEXT("vCalendar imported");
        TBuf8<8> uniqueIdStr;
        uniqueIdStr.Copy( ( TUint8* ) ( &uniqueId ), sizeof( uniqueId ) );
        SendOkMsgL( uniqueIdStr );
        }
    else
        {
        HTI_LOG_TEXT("Failed to import vCalendar");
        if ( err == KErrNone ) 
            {
            err = KErrGeneral;
            }
        SendErrorMessageL( err, KErrorVCalendarImportFailed );
        }

    CleanupStack::PopAndDestroy( 3 ); // buffer, readStream, importer
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCalendarImportFuncL: Done" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleContactDeleteFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleContactDeleteFuncL" );
    TInt dataLength = aData.Length();
    if ( dataLength != 0 && dataLength != 4 )
        {
        HTI_LOG_TEXT( "CPIMHandler: Error: wrong length of data" )
        SendErrorMessageL( KErrArgument, KErrorInvalidId );
        return;
        }
    CContactDatabase* contactDatabase = CContactDatabase::OpenL();
    HTI_LOG_TEXT( "CPIMHandler: Contact database open" );
    CleanupStack::PushL(contactDatabase);
    
    if(dataLength == 0)   // delete all contacts
        {
        //const CContactIdArray* array = iContactDatabase->SortedItemsL();
        CCntFilter *filter = CCntFilter::NewLC();
        filter->SetContactFilterTypeCard(ETrue);
        filter->SetContactFilterTypeGroup(EFalse);
        contactDatabase->FilterDatabaseL(*filter);
        TRAPD(err, contactDatabase->DeleteContactsL(*filter->iIds));
        CleanupStack::PopAndDestroy();
        if(err == KErrNone)
            {
            HTI_LOG_TEXT("All contacts deleted");
            SendOkMsgL( KNullDesC8 );
            }
        else
            {
            HTI_LOG_TEXT("Failed to delete all contacts");
            SendErrorMessageL( err, KErrorFailedDeleteAll );
            }
        }
    else  // delete one contact by id
        {
        TUint id = aData[0] + ( aData[1] << 8 )
                + ( aData[2] << 16 )
                + ( aData[3] << 24 );
        TRAPD(err, contactDatabase->DeleteContactL(id));
        
        if(err == KErrNone)
            {
            HTI_LOG_TEXT("Contact deleted");
            SendOkMsgL( KNullDesC8 );
            }
        else
            {
            HTI_LOG_TEXT("Failed to delete contact");
            SendErrorMessageL( err, KErrorFailedDelete );
            }
        }
    
    CleanupStack::PopAndDestroy();
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleContactDeleteFuncL" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleCalendarDeleteFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleVCalendarDeleteFuncL" );

    TInt dataLength = aData.Length();
    if ( dataLength != 0 && dataLength != 4 )
        {
        HTI_LOG_TEXT( "CPIMHandler: Error: wrong length of data" )
        SendErrorMessageL( KErrArgument, KErrorInvalidId );
        return;
        }


    if(iCalSession == NULL)
        {
        HTI_LOG_TEXT( "CPIMHandler: Open default calendar file" );
        iCalSession = CCalSession::NewL();
        iCalSession->OpenL( KDefaultAgendaFile );
        HTI_LOG_TEXT( "CPIMHandler: Calendar session open" );
        }

    HTI_LOG_TEXT( "CPIMHandler: Creating entry view" );
    CCalEntryView* entryView = CCalEntryView::NewL( *iCalSession, *this );
    iWaiter->Start();
    CleanupStack::PushL(entryView);
    if ( iEntryViewErr != KErrNone )
        {
        User::Leave( iEntryViewErr );
        }

    // If dataLength is 0, no ID given, delete all calendar entries
    if ( dataLength == 0 )
        {
        HTI_LOG_TEXT( "CPIMHandler: Deleting all calendar entries" );
        TCalTime minTime;
        TCalTime maxTime;
        minTime.SetTimeUtcL( TCalTime::MinTime() );
        maxTime.SetTimeUtcL( TCalTime::MaxTime() );
        CalCommon::TCalTimeRange timeRange( minTime, maxTime );
        TRAPD( err, entryView->DeleteL( timeRange,
                CalCommon::EIncludeAll, *this ) );
        iWaiter->Start();
        if ( err == KErrNone && iEntryViewErr == KErrNone )
            {
            HTI_LOG_TEXT("All calendar entries deleted");
            SendOkMsgL( KNullDesC8 );
            }
        else
            {
            HTI_LOG_TEXT("Failed to delete all calendar entries");
            SendErrorMessageL( KErrGeneral, KErrorFailedDeleteAll );
            }
        }

    // If id given, delete only calendar entry having that id
    else
        {
        TCalLocalUid id = aData[0] + ( aData[1] << 8 )
                             + ( aData[2] << 16 )
                             + ( aData[3] << 24 );
        HTI_LOG_FORMAT( "CPIMHandler: Deleting one calendar entry %d", id );
        CCalEntry* entryToDelete = NULL;
        TRAPD( err, entryToDelete = entryView->FetchL( id ) );

        if ( err || entryToDelete == NULL )
            {
            HTI_LOG_TEXT( "CPIMHandler: Calendar entry not found" );
            SendErrorMessageL( KErrNotFound, KErrorItemNotFound );
            }
        else
            {
            CleanupStack::PushL( entryToDelete );
            TRAP( err, entryView->DeleteL( *entryToDelete ) );
            if ( err == KErrNone )
                {
                HTI_LOG_TEXT("calendar entrie deleted");
                SendOkMsgL( KNullDesC8 );
                }
            else
                {
                HTI_LOG_TEXT( "Failed to delete calendar entry" )
                SendErrorMessageL( KErrGeneral, KErrorFailedDelete );
                }
            CleanupStack::PopAndDestroy( entryToDelete );
            }
        }
    CleanupStack::PopAndDestroy(); //entryView;
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleVCalendarDeleteFuncL" );
    }

#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 )  
TInt CallNpdHlp( const TDesC& aCmd )
    {
    HTI_LOG_FUNC_IN( "CallNpdHlp" );

    RProcess HtiNpdHlp;
    TInt err = HtiNpdHlp.Create( KHtiNpdHlpExe, aCmd );
    if ( err )
        {
        HTI_LOG_FORMAT( "Could not create HtiNpdHlp.Exe process %d", err );
        return err;
        }

    TRequestStatus status;
    HtiNpdHlp.Logon( status );
    HtiNpdHlp.Resume();
    User::WaitForRequest( status );
    if ( status.Int() != KErrNone )
        {
        HTI_LOG_FORMAT( "status     %d", status.Int() );
        HTI_LOG_FORMAT( "ExitReason %d", HtiNpdHlp.ExitReason() );
        HTI_LOG_FORMAT( "ExitType   %d", HtiNpdHlp.ExitType() );
        HtiNpdHlp.Close();
        return status.Int();
        }

    HtiNpdHlp.Close();

    HTI_LOG_FUNC_OUT( "CallNpdHlp" );
    return KErrNone;
    }
#endif

// ----------------------------------------------------------------------------
void CPIMHandler::HandleNotepadAddMemoFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleNotepadAddMemoFuncL" );
#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 ) 
    if ( aData.Length() < 1 )
        {
        SendErrorMessageL( KErrArgument, KErrorMissingText );
        return;
        }

    // convert text from TDesC8 -> TDesC
    // expecting the input TDesC8 contains UTF-8 data
    HBufC* text = CnvUtfConverter::ConvertToUnicodeFromUtf8L( aData );
    HTI_LOG_TEXT( "CPIMHandler: Conversion to Unicode done" );
    CleanupStack::PushL( text );

    HBufC* cmd = HBufC::NewLC( KCmdAddMemo().Length() + 1 + ( *text ).Length() );
    cmd->Des().Copy( KCmdAddMemo );
    cmd->Des().Append( KCmdDelim );
    cmd->Des().Append( *text );

    TInt err = CallNpdHlp( *cmd );
    if ( err )
        {
        SendErrorMessageL( err, KErrorNotepadAddMemoFailed );
        }
    else
        {
        SendNotepadOkMsgL( CHtiPIMServicePlugin::ENotepadAddMemo );
        }

    CleanupStack::PopAndDestroy( 2 ); // text, cmd
#else
    SendErrorMessageL(KErrNotSupported, KErrorNotepadNotSupported);
#endif   
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleNotepadAddMemoFuncL" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleNotepadAddMemoFromFileFuncL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleNotepadAddMemoFromFileFuncL" );
#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 ) 
    if ( aData.Length() < 1 )
        {
        SendErrorMessageL( KErrArgument, KErrorMissingFilepath );
        return;
        }

    // convert filename from TDesC8 -> TDesC
    // expecting the input TDesC8 contains UTF-8 data
    HBufC* filename = CnvUtfConverter::ConvertToUnicodeFromUtf8L( aData );
    HTI_LOG_TEXT( "CPIMHandler: Conversion to Unicode done" );
    CleanupStack::PushL( filename );

    HBufC* cmd = HBufC::NewLC( KCmdAddMemoFromFile().Length() + 1 + ( *filename ).Length() );
    cmd->Des().Copy( KCmdAddMemoFromFile );
    cmd->Des().Append( KCmdDelim );
    cmd->Des().Append( *filename );

    TInt err = CallNpdHlp( *cmd );
    if ( err )
        {
        SendErrorMessageL( err, KErrorNotepadAddMemoFromFileFailed );
        }
    else
        {
        SendNotepadOkMsgL( CHtiPIMServicePlugin::ENotepadAddMemoFromFile );
        }

    CleanupStack::PopAndDestroy( 2 ); // filename, cmd
#else
    SendErrorMessageL(KErrNotSupported, KErrorNotepadNotSupported);
#endif 
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleNotepadAddMemoFromFileFuncL" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::HandleNotepadDeleteAllFuncL()
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::HandleNotepadDeleteAllFuncL" );
#if ( SYMBIAN_VERSION_SUPPORT < SYMBIAN_4 ) 
    TInt err = CallNpdHlp( KCmdDeleteAll() );
    if ( err )
        {
        SendErrorMessageL( err, KErrorNotepadDeleteAllFailed );
        }
    else
        {
        SendNotepadOkMsgL( CHtiPIMServicePlugin::ENotepadDeleteAll );
        }
#else
    SendErrorMessageL(KErrNotSupported, KErrorNotepadNotSupported);
#endif 
    HTI_LOG_FUNC_OUT( "CPIMHandler::HandleNotepadDeleteAllFuncL" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::SendNotepadOkMsgL( CHtiPIMServicePlugin::TCommand aCommand )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::SendNotepadOkMsgL" );
    TBuf8<1> msg;
    msg.Append( aCommand );
    User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(
                        msg.AllocL(), KPIMServiceUid ) );
    iIsBusy = EFalse;
    HTI_LOG_FUNC_OUT( "CPIMHandler::SendNotepadOkMsgL" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::SendOkMsgL( const TDesC8& aData )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::SendOkMsgL: Starting" );

    User::LeaveIfNull( iDispatcher );

    HBufC8* temp = HBufC8::NewL( aData.Length() + 1 );
    TPtr8 response = temp->Des();
    response.Append( ( TChar ) CHtiPIMServicePlugin::EResultOk );
    response.Append( aData );
    User::LeaveIfError( iDispatcher->DispatchOutgoingMessage(
        temp, KPIMServiceUid ) );
    iIsBusy = EFalse;
    HTI_LOG_FUNC_OUT( "CPIMHandler::SendOkMsgL: Done" );
    }

// ----------------------------------------------------------------------------
void CPIMHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::SendErrorMessageL: Starting" );
    User::LeaveIfNull( iDispatcher );
    User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage(
        aError, aDescription, KPIMServiceUid ) );
    iIsBusy = EFalse;
    HTI_LOG_FUNC_OUT( "CPIMHandler::SendErrorMessageL: Done" );
    }

// ----------------------------------------------------------------------------
// CPIMHandler::Progress
// Called during calendar entry view creation and operations.
// Called only if NotifyProgress returns ETrue.
// From MCalProgressCallBack
// ----------------------------------------------------------------------------
void CPIMHandler::Progress( TInt /*aProgress*/ )
    {
    }

// ----------------------------------------------------------------------------
// CPIMHandler::Completed
// Called on completion of calendar entry view creation and operations
// From MCalProgressCallBack
// ----------------------------------------------------------------------------
void CPIMHandler::Completed( TInt aError )
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::Completed" );
    HTI_LOG_FORMAT( "Completed with error code %d", aError );
    iEntryViewErr = aError;
    iWaiter->AsyncStop();
    HTI_LOG_FUNC_OUT( "CPIMHandler::Completed" );
    }

// ----------------------------------------------------------------------------
// CPIMHandler::NotifyProgress
// Returns whether or not progress notification is required
// From MCalProgressCallBack
// ----------------------------------------------------------------------------
TBool CPIMHandler::NotifyProgress()
    {
    HTI_LOG_FUNC_IN( "CPIMHandler::NotifyProgress" );
    HTI_LOG_FUNC_OUT( "CPIMHandler::NotifyProgress" );
    return EFalse; // Don't notify about progress
    }