/*

 * Copyright (c) 2007 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:  CS Preview Plugin Handler, This class creates and updates sqlite based db

 *                with the message-preview data.

 *

 */

// USER INCLUDES

#include "ccspreviewpluginhandler.h"

#include "UniObject.h"

// SYSTEM INCLUDES

#include <mmsclient.h>

#include <mtclreg.h>

#include <msvids.h>

#include <e32const.h>

#include <SendUiConsts.h>

#include <utf.h>

#include <centralrepository.h>

#include <MmsConformance.h>

#include <mmsconst.h>

#include <msgmediainfo.h>

#include <MsgMediaResolver.h>

#include <fileprotectionresolver.h>

#include <MmsEngineInternalCRKeys.h>

//CONSTANTS

//DB-file

_LIT(KDbFileName, "c:[2002A542]conversations.db");

//Encoding

_LIT(KEncodingStmnt,"PRAGMA encoding=\"UTF-8\"");

//Size

_LIT(KCacheSizeStmnt,"PRAGMA default_cache_size = 1024");

// Create table query statement

_LIT(KSqlCreateStmt, "CREATE TABLE IF NOT EXISTS conversation_messages ( message_id  INTEGER PRIMARY KEY, msg_processingstate INTEGER DEFAULT 0, subject TEXT(100), body_text TEXT(160), preview_path TEXT, msg_property INTEGER, preview_icon BLOB DEFAULT NULL ) " );

//Create an empty record for the given message id

_LIT(KSqlBasicInsertStmt, "INSERT OR REPLACE INTO conversation_messages ( message_id ) VALUES( :message_id )");

//Insert without bitmap query

_LIT(KSqlInsertStmt, "INSERT OR REPLACE INTO conversation_messages ( message_id, msg_processingstate, subject, body_text, preview_path, msg_property ) VALUES( :message_id, :msg_processingstate, :subject, :body_text, :preview_path,  :msg_property )");

//update processing-state flag of a message

_LIT(KSqlUpdateProcessingStateStmt, "UPDATE conversation_messages SET msg_processingstate=:msg_processingstate WHERE message_id=:message_id " );

//update with bitmap query

_LIT(KSqlUpdateBitmapStmt, "UPDATE conversation_messages SET preview_icon=:preview_icon WHERE message_id=:message_id " );

// query to see if msg is under process at the moment

_LIT(KSelectProcessingStateStmt, " SELECT message_id, msg_processingstate FROM conversation_messages WHERE message_id=:message_id ");

// Remove record from conversation_messages table.

_LIT(KRemoveMsgStmnt,"DELETE FROM conversation_messages WHERE message_id=:message_id");

const TInt KDefaultMaxSize = 300 * 1024;

// NOTE:- DRAFTS ENTRIES ARE NOT HANDLED IN THE PLUGIN

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

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

// CCsPreviewPluginHandler::NewL

// Two Phase Construction

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

//

CCsPreviewPluginHandler* CCsPreviewPluginHandler::NewL(

    CCsPreviewPlugin *aMsgObserver)

{

    PRINT ( _L("Enter CCsMsgHandler::NewL") );

    CCsPreviewPluginHandler* self = new (ELeave) CCsPreviewPluginHandler();

    CleanupStack::PushL(self);

    self->ConstructL(aMsgObserver);

    CleanupStack::Pop(self);

    PRINT ( _L("End CCsPreviewPluginHandler::NewL") );

    return self;

}

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

// CCsPreviewPluginHandler::~CCsPreviewPluginHandler

// Destructor

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

//

CCsPreviewPluginHandler::~CCsPreviewPluginHandler()

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::~CCsPreviewPluginHandler") );

    iSqlDb.Close();

    iThumbnailRequestArray.Close();

    ifsSession.Close();

    if (iMmsMtm)

    {

        delete iMmsMtm;

        iMmsMtm = NULL;

    }

    if (iMtmRegistry)

    {

        delete iMtmRegistry;

        iMtmRegistry = NULL;

    }

    if (iSession)

    {

        delete iSession;

        iSession = NULL;

    }

    if (iThumbnailManager)

    {

        delete iThumbnailManager;

        iThumbnailManager = NULL;

    }

    PRINT ( _L("End CCsPreviewPluginHandler::~CCsPreviewPluginHandler") );

}

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

// CCsMsgHandler::ConstructL

// Two Phase Construction

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

//

void CCsPreviewPluginHandler::ConstructL(CCsPreviewPlugin *aMsgObserver)

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::ConstructL") );

    iMsgObserver = aMsgObserver;

    //file session connect

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

    //create msv session

    iSession = CMsvSession::OpenSyncL(*this);

    //create mtm registry

    iMtmRegistry = CClientMtmRegistry::NewL(*iSession);

    //create mms client mtm

    iMmsMtm = static_cast<CMmsClientMtm*> (iMtmRegistry-> NewMtmL(

        KSenduiMtmMmsUid));

    //create thumbnail manager

    iThumbnailManager = CThumbnailManager::NewL(*this);

    // open DB

    TInt error = iSqlDb.Open(KDbFileName);

    PRINT1 ( _L("End CCsPreviewPluginHandler::ConstructL open DB file error=%d"), error );

    // if not found, create DB

    if (error == KErrNotFound)

    {

        //create sqlite-DB

        TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

        RSqlSecurityPolicy securityPolicy;

        securityPolicy.Create(defaultPolicy);

        // TODO, setting UID security policy

        //TSecurityPolicy readPolicy(ECapabilityReadUserData);  

        //securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, readPolicy);

        iSqlDb.Create(KDbFileName, securityPolicy);

        //Create the table inside DB

        iSqlDb.Exec(KSqlCreateStmt);

        iSqlDb.Exec(KEncodingStmnt);

        iSqlDb.Exec(KCacheSizeStmnt);

    }

    else

    {

        User::LeaveIfError(error);

    }

    //get the max size of mms from the repository

    TRAP_IGNORE(

            CRepository* repository = CRepository::NewL(KCRUidMmsEngine);

            CleanupStack::PushL(repository);

            //Fetch and set max mms composition size

            TInt maxSize = KDefaultMaxSize;

            repository->Get( KMmsEngineMaximumSendSize, maxSize );

            iMaxMmsSize = maxSize;

            //Fetch and set creation mode

            TInt creationMode = EMmsCreationModeRestricted;

            repository->Get(KMmsEngineCreationMode, creationMode);

            iCreationMode = creationMode;

            CleanupStack::PopAndDestroy(repository);

    );

    PRINT ( _L("End CCsPreviewPluginHandler::ConstructL") );

}

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

// CCsPreviewPluginHandler::CCsPreviewPluginHandler

// Two Phase Construction

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

//

CCsPreviewPluginHandler::CCsPreviewPluginHandler()

{

}

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

// CCsPreviewPluginHandler::HandleSessionEventL

// Implemented for MMsvSessionObserver

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

//

void CCsPreviewPluginHandler::HandleSessionEventL(TMsvSessionEvent aEvent,

    TAny* aArg1, TAny* aArg2, TAny* /*aArg3*/)

{

    PRINT1 ( _L("Enter CCsPreviewPluginHandler::HandleSessionEventL aEvent=%d"),aEvent );

    CMsvEntrySelection* selection = NULL;

    TMsvId parent;

    //args

    if (aArg1 == NULL || aArg2 == NULL)

    {

        PRINT ( _L("Enter CCsPreviewPluginHandler::HandleSessionEventL arguments invalid"));

        return;

    }

    //start, processing the event

    selection = (CMsvEntrySelection*) aArg1;

    parent = *(TMsvId*) aArg2;

    //Drafts not handled

    if (KMsvDraftEntryIdValue == parent)

    {

        return;

    }

    switch (aEvent)

    {

        case EMsvEntriesChanged:

        case EMsvEntriesMoved:

        {

            HandleEventL(selection);

        }

        break;

        case EMsvEntriesDeleted:

        {

            for (TInt i = 0; i < selection->Count(); i++)

            {

                RSqlStatement sqlDeleteStmt;

                CleanupClosePushL(sqlDeleteStmt);

                sqlDeleteStmt.PrepareL(iSqlDb, KRemoveMsgStmnt);

                TInt messageIdIndex = sqlDeleteStmt.ParameterIndex(_L(

                    ":message_id"));

                User::LeaveIfError(sqlDeleteStmt.BindInt(messageIdIndex, selection->At(i)));

                User::LeaveIfError(sqlDeleteStmt.Exec());

                CleanupStack::PopAndDestroy(&sqlDeleteStmt);

            }

        }

        break;

    }

    PRINT ( _L("Exit CCsPreviewPluginHandler::HandleSessionEventL") );

}

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

// CCsPreviewPluginHandler::HandleEvent

// Handle events

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

//

void CCsPreviewPluginHandler::HandleEventL(CMsvEntrySelection* aSelection)

{

    PRINT ( _L("Enter CCsPreviewPluginHandler::HandleEvent") );

    TMsvEntry entry;

    TMsvId service;

    TInt error = KErrNone;

    for (TInt i = 0; i < aSelection->Count(); i++)

    {

        error = iSession->GetEntry(aSelection->At(i), service, entry);

        if ( (KErrNone == error) && !entry.InPreparation() && entry.Visible()

                && (KSenduiMtmMmsUidValue == entry.iMtm.iUid))

        {

            PRINT ( _L("Enter CCsPreviewPluginHandler::HandleEvent for loop started.") );

            TInt msgId = entry.Id();

            // check if the msg is already under processing Or processed

            if( EPreviewMsgNotProcessed != msgProcessingState(msgId) )

            {

                // skip processing this event for the given message

                continue;

            }

            else

            {

                // start processing message, set flag

                setMsgProcessingState(msgId, EPreviewMsgProcessing);

            }

            // update db with message preview data

            RSqlStatement sqlInsertStmt;

            CleanupClosePushL(sqlInsertStmt);

            sqlInsertStmt.PrepareL(iSqlDb, KSqlInsertStmt);

            // parse message

            iMmsMtm->SwitchCurrentEntryL(msgId);

            iMmsMtm->LoadMessageL();

            CUniDataModel* iUniDataModel = CUniDataModel::NewL(ifsSession,

                *iMmsMtm);

            CleanupStack::PushL(iUniDataModel);

            iUniDataModel->RestoreL(*this, ETrue);

            //msg property

            TInt msgProperty = 0;

            if (iUniDataModel->AttachmentList().Count() > 0)

            {

                msgProperty |= EPreviewAttachment;

            }

            //check for msg forward

            //Validate if the mms msg can be forwarded or not

            if (ValidateMsgForForward(iUniDataModel))

            {

                msgProperty |= EPreviewForward;

            }

            TPtrC videoPath;

            TPtrC imagePath;

            // preview parsing

            TInt slideCount = iUniDataModel->SmilModel().SlideCount();

            TBool isBodyTextSet = EFalse;

            TBool isImageSet = EFalse;

            TBool isAudioSet = EFalse;

            TBool isVideoSet = EFalse;

            for (int i = 0; i < slideCount; i++)

            {

                int slideobjcount =

                        iUniDataModel->SmilModel().SlideObjectCount(i);

                for (int j = 0; j < slideobjcount; j++)

                {

                    CUniObject *obj =

                            iUniDataModel->SmilModel(). GetObjectByIndex(i, j);

                    CMsgMediaInfo *mediaInfo = obj->MediaInfo();

                    TPtrC8 mimetype = obj->MimeType();

                    TMsvAttachmentId attachId = obj->AttachmentId();

                    //bodytext

                    if (!isBodyTextSet && (mimetype.Find(_L8("text"))

                            != KErrNotFound))

                    {

                        //bind bodytext into statement

                        BindBodyText(sqlInsertStmt, attachId);

                        isBodyTextSet = ETrue;

                    }

                    //image parsing

                            != KErrNotFound))

                    {

                        //get thumbnail for this image

                        isImageSet = ETrue;

                        imagePath.Set(mediaInfo->FullFilePath());

                        msgProperty |= EPreviewImage;

                        if (EFileProtNoProtection != mediaInfo->Protection())

                        {

                            msgProperty |= EPreviewProtectedImage;

                        }

                        if (mediaInfo->Corrupt())

                        {

                            msgProperty |= EPreviewCorruptedImage;

                        }

                        if (!(EPreviewProtectedImage & msgProperty) &&

                            !(EPreviewCorruptedImage & msgProperty))

                        {

                            //Generate thumbnail for non protected,

                            //non corrupted image.

                            GetThumbNailL(attachId, mimetype, msgId);

                        }

                    }

                    //audio content

                            != KErrNotFound))

                    {

                        isAudioSet = ETrue;

                        msgProperty |= EPreviewAudio;

                        if (EFileProtNoProtection != mediaInfo->Protection())

                        {

                            msgProperty |= EPreviewProtectedAudio;

                        }

                        if (mediaInfo->Corrupt())

                        {

                            msgProperty |= EPreviewCorruptedAudio;

                        }

                    }

                    //video content

                            != KErrNotFound))

                    {

                        videoPath.Set(mediaInfo->FullFilePath());

                        isVideoSet = ETrue;

                        msgProperty |= EPreviewVideo;

                        if (EFileProtNoProtection != mediaInfo->Protection())

                        {

                            msgProperty |= EPreviewProtectedVideo;

                        }

                        if (mediaInfo->Corrupt())

                        {

                            msgProperty |= EPreviewCorruptedVideo;

                        }

                    }

                }

            }

            //set preview path

            TInt previewPathIndex = sqlInsertStmt.ParameterIndex(_L(

                ":preview_path"));

            if (isVideoSet)

            {

                User::LeaveIfError(sqlInsertStmt.BindText(previewPathIndex,

                    videoPath));

            }

            else if (isImageSet)

            {

                User::LeaveIfError(sqlInsertStmt.BindText(previewPathIndex,

                    imagePath));

            }

            //msg_id

            TInt msgIdIndex = sqlInsertStmt.ParameterIndex(_L(":message_id"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgIdIndex, msgId));

            //subjext

            TInt subjectIndex = sqlInsertStmt.ParameterIndex(_L(":subject"));

            User::LeaveIfError(sqlInsertStmt.BindText(subjectIndex,

                iMmsMtm->SubjectL()));

            //msg_property

            TInt msgPropertyIndex = sqlInsertStmt.ParameterIndex(_L(

                ":msg_property"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgPropertyIndex,

                msgProperty));

            //msg_processingstate

            TInt msgProcessingStateIndex = sqlInsertStmt.ParameterIndex(_L(":msg_processingstate"));

            User::LeaveIfError(sqlInsertStmt.BindInt(msgProcessingStateIndex, EPreviewMsgProcessed));

            //execute sql stament

            User::LeaveIfError(sqlInsertStmt.Exec());

            //cleanup

            CleanupStack::PopAndDestroy(2, &sqlInsertStmt);

        }

}//end for loop

PRINT ( _L("Exit CCsPreviewPluginHandler::HandleEvent") );

}

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

// CCsPreviewPluginHandler::RestoreReady()

// 

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

//

void CCsPreviewPluginHandler::RestoreReady(TInt /*aParseResult*/, TInt /*aError*/)

{

}

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

// CCsPreviewPluginHandler::ThumbnailReady()

// 

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

//

void CCsPreviewPluginHandler::ThumbnailReady(TInt aError,

    MThumbnailData& aThumbnail, TThumbnailRequestId aId)

{

    // This function must not leave.

    if (!aError)

    {

        PRINT ( _L("CCsPreviewPluginHandler::ThumbnailReady received.") );

        TInt err;

        TRAP(err, HandleThumbnailReadyL(aThumbnail, aId));

        PRINT1 ( _L("CCsPreviewPluginHandler::ThumbnailReady handling error= %d."), err );

    }

    else

    {

        // An error occurred while getting the thumbnail.

        PRINT1 ( _L("End CCsPreviewPluginHandler::ThumbnailReady error= %d."), aError );

    }

}

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

// CCsPreviewPluginHandler::ThumbnailPreviewReady()

// callback

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

//

void CCsPreviewPluginHandler::ThumbnailPreviewReady(

    MThumbnailData& /*aThumbnail*/, TThumbnailRequestId /*aId*/)

{

}

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

// CCsPreviewPluginHandler::HandleThumbnailReadyL()

//