/*

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

#include "msgbiouids.h"

// SYSTEM INCLUDES

#include <bioscmds.h>

#include <biocmtm.h>

#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>

#include <imageconversion.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");

//Insert vcard meta-daa query

_LIT(KSqlInsertBioMsgStmt, "INSERT OR REPLACE INTO conversation_messages ( message_id, msg_processingstate, preview_path ) VALUES( :message_id, :msg_processingstate, :preview_path )");

const TInt KDefaultMaxSize = 300 * 1024;

//Preview thumbnail size

const TInt KWidth = 24 * 6.7;

const TInt KHeight = 24 * 6.7;

// 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 (iBioClientMtm)

        {

        delete iBioClientMtm;

        iBioClientMtm = 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 biomsg client mtm

    iBioClientMtm = static_cast<CBIOClientMtm*> (iMtmRegistry->NewMtmL(

            KSenduiMtmBioUid));

    //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 start.") );

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

        {

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

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

                {

                HandleMMSEntryL(entry);

                }

            else if ((KSenduiMtmSmsUidValue == entry.iMtm.iUid) || (KSenduiMtmBioUidValue == entry.iMtm.iUid))

                {

                if ((KMsgBioUidVCard.iUid == entry.iBioType))

                    {                 

                    HandleVCardEntryL(entry);

                    }

                }

            }

        }//end for loop

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

    }

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

// CCsPreviewPluginHandler::HandleMMSEntryL()

// 

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

//

void CCsPreviewPluginHandler::HandleMMSEntryL(const TMsvEntry& aEntry)

    {

    PRINT ( _L("Enter CCsPreviewPluginHandler::HandleMMSEntry start.") );

    TInt msgId = aEntry.Id();

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

    if (EPreviewMsgNotProcessed != msgProcessingState(msgId))

        {

        // skip processing this event for the given message

        return;

        }

    // start processing message, set flag

    setMsgProcessingState(msgId, EPreviewMsgProcessing);

    TRAPD( err,

            {        

    // update db with message preview data

    RSqlStatement sqlInsertStmt;

    CleanupClosePushL(sqlInsertStmt);

    sqlInsertStmt.PrepareL(iSqlDb, KSqlInsertStmt);

    // parse message

    iMmsMtm->SwitchCurrentEntryL(msgId);

    iMmsMtm->LoadMessageL();

    //msg property

    TInt msgProperty = 0;

        {

        msgProperty |= EPreviewAttachment;

        }

    //check for msg forward

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

        {

        msgProperty |= EPreviewForward;

        }

    TPtrC videoPath;

    TPtrC imagePath;

    // preview parsing

    TBool isBodyTextSet = EFalse;

    TBool isImageSet = EFalse;

    TBool isAudioSet = EFalse;

    TBool isVideoSet = EFalse;

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

        {

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

            {

                    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

            if (!isVideoSet && !isImageSet && (mimetype.Find(_L8("image"))

                    != 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

            if (!isVideoSet && !isAudioSet && (mimetype.Find(_L8("audio"))

                    != KErrNotFound))

                {

                isAudioSet = ETrue;

                msgProperty |= EPreviewAudio;

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

                    {

                    msgProperty |= EPreviewProtectedAudio;

                    }

                if (mediaInfo->Corrupt())

                    {

                    msgProperty |= EPreviewCorruptedAudio;

                    }

                }

            //video content

            if (!(isImageSet || isAudioSet) && !isVideoSet && (mimetype.Find(

                    _L8("video")) != 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);

            }); //TRAP

    if( err != KErrNone )

        {

        setMsgProcessingState(msgId, EPreviewMsgNotProcessed);

        }