/*

* Copyright (c) 2008 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:  ?Description

 *

*/

// INCLUDE FILES

#include <cmsvattachment.h>

#include <cmsvmimeheaders.h>

#include <mmsvattachmentmanager.h>

#include "logger.h"

#include "fs_methodcall.h"

#include "s60commonutils.h"

#include "cmmsmessageattachment.h"

#include "cmmsplatformservices60impl.h"

#include "mmsserverconnection.h"

#include "mmsserverconnectionfactory.h"

//constants

const TInt KMaxAppIDLength = 34;

using namespace java::push;

using namespace java::util;

namespace java

{

namespace wma

{

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

 * constructor

 *------------------------------------------------------------------------------

 * private CMMSPlatformServiceS60Impl

 *

 *------------------------------------------------------------------------------

 */

CMMSPlatformServiceS60Impl::CMMSPlatformServiceS60Impl(

    const bool aServerConnection,

    HBufC* aServerApplicationId,

    ConnectionListener* aListener)

        :CActive(EPriorityNormal), java::util::FunctionServer("CMMSPlatformService"),

        mIsSending(false), mServerConnection(aServerConnection), mNewMessages(0),

        mServerApplicationId(aServerApplicationId)

{

    JELOG2(EWMA);

    //Creates a new thread and starts active scheduler

    //This results in call to doServerSideInit()

    createServerToNewThread();

    mSendMsgArray = NULL;

    mMessageListener = aListener;

}

/**

 * Gets the instance of OS Specific class which implements the interface

 * CMMSPlatformService.

 * @param aJni - jni interface pointer

 * @param aPeer - java side peer reference.

 * @param aServerConnection - boolean value to identify client/server

 *                            connection.

 * @param aUri - uri on which the connection to be opened.

 * @param aListener - listener to be notified about incoming messages.

 */

MMSPlatformService* MMSPlatformService::getInstance(JNIEnv& aJni,

        jobject aPeer,const bool aServerConnection,const std::wstring& aUri,

        ConnectionListener* aListener)

{

    return CMMSPlatformServiceS60Impl::New(aJni,aPeer,aServerConnection,aUri,

                                           aListener);

}

CMMSPlatformServiceS60Impl* CMMSPlatformServiceS60Impl::New(JNIEnv& aJni,

        jobject aPeer,const bool aServerConnection,const std::wstring& aUri,

        ConnectionListener* aListener)

{

    JELOG2(EWMA);

    HBufC* serverApplicationId = NULL;

    int error = KErrNone;

    if (aServerConnection)

    {

        serverApplicationId = S60CommonUtils::wstringToDes(

                                  (aUri.substr(7)).c_str());

    }

    CMMSPlatformServiceS60Impl * self = new CMMSPlatformServiceS60Impl(

        aServerConnection, serverApplicationId, aListener);

    error = self->getError();

    if (KErrNone == error)

    {

        //Attaches the function server thread to VM, to make callbacks to java

        //This results in call to vmAttached()

        self->attachToVm(aJni, aPeer);

        LOG(EWMA, EInfo, "CMMSPlatformServiceS60Impl Successfully attached to VM");

        TRAP(error, self->ConstructL());

    }

    if (error != KErrNone)

    {

        ELOG1(EWMA, "CMMSPlatformServiceS60Impl : Error while opening %d", error);

        // If there is any error while opening close the connection

        self->closeConnection(aJni,aPeer);

        delete self;

        throw error;

    }

    return self;

}

/**------------------------------------------------------------------------------

 * EPOC default constructor can leave.

 * private ConstructL

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::ConstructL()

{

    JELOG2(EWMA);

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

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

    CreateSendMessageArrayL(); // create send array

    mMessageDeliveryDate = TTime(0);

    mMmsMessagePriority = EMmsPriorityHigh;

    mMessageHandler = CJavaMMSMessageHandler::NewL(mRFs);

    // If server connection then check for messages already available in MMS

    // message store.

    if (mServerConnection)

    {

        LOG(EWMA, EInfo , "CMMSPlatformServiceS60Impl::ConstructL() Check for"

            "any messages availble in message store");

        CallMethodL(this, &CMMSPlatformServiceS60Impl::NotifyReceivedMessageL,

                    this);

    }

}

void CMMSPlatformServiceS60Impl::vmAttached()

{

    JELOG2(EWMA);

    jclass sessionClass = mJniEnv->FindClass(

                              "com/nokia/mj/impl/mms/MMSConnectionImpl");

    mSendCallBackMethodId = mJniEnv->GetMethodID(sessionClass,

                            "messageSentCallback", "(I)V");

}

/**

 * Returns total number of messages that are arrived

 * from opening the connection

 */

int CMMSPlatformServiceS60Impl::getNumberOfMessages()

{

    JELOG2(EWMA);

    return mNewMessages;

}

/**

 * Does the MMS Engine side initializations .Registers with MMS Engine

 * for notification about incoming message in case of server connection.

 */

void CMMSPlatformServiceS60Impl::doServerSideInit()

{

    JELOG2(EWMA);

    FunctionServer::doServerSideInit();

    CActiveScheduler::Add(this);

    TRAPD(error,

    {

        mSession = CMsvSession::OpenSyncL(*this);

        mClientMtmRegistry = CClientMtmRegistry::NewL(*mSession);

        mMmsClient = (CMmsClientMtm *) mClientMtmRegistry->NewMtmL(

                         KUidMsgTypeMultimedia);

        mSendTMsvIdArray = RArray<TMsvId>(KArrayGranularity);

        mMmsApplicationAdapter = CMmsApplicationAdapter::NewL();

        if (mServerConnection)

        {

            mServerMmsMtm = (CMmsClientMtm *) mClientMtmRegistry->NewMtmL(

                                KUidMsgTypeMultimedia);

            mReceivedMsgArray = new(ELeave) CArrayPtrSeg

            <CMMSMessageInformation>(KArrayGranularity);

            TBool isRegister = EFalse;

            // If launched by push the application would have already registered

            // with mms engine . check before registering.

            LOG(EWMA, EInfo , "Checking whether application is already"

                "registered or not");

            isRegister = mMmsApplicationAdapter->RegisteredL

                         (*mServerApplicationId);

            // If not registered , register now.

            if (!isRegister)

            {

                TMsvId folderId;

                LOG(EWMA, EInfo , "Registering the AppId with MMS engine");

                mMmsApplicationAdapter->RegisterL(*mServerApplicationId,folderId);

                isRegister = true;

            }

            TMsvId tmsvId = mMmsApplicationAdapter->FolderIdL(

                                *mServerApplicationId);

            if (0 != tmsvId)

            {

                mRegisterCMsvEntry = mSession->GetEntryL(tmsvId);

                // Add listener to the created entry for that application Id

                mRegisterCMsvEntry->AddObserverL(*this);

            }

        }

    });

    mError = error;

}

/* -----------------------------------------------------------------------------

 * CMMSPlatformServiceS60Impl::Send

 * Sends a multimedia message to its recipients.

 * -----------------------------------------------------------------------------

 */

int CMMSPlatformServiceS60Impl::send(JNIEnv& aJniEnv,

                                     jbyteArray aBytes, int aOffset, int aLength, jstring /*aDestination*/)

{

    JELOG2(EWMA);

    // put the jbyteArray into the mSendBuffer

    delete mSendBuf; // avoid the memory leak

    mSendBuf = NULL;

    TRAPD(error,

    {

        mSendBuf = CBufFlat::NewL(aLength);

        // Extends the size of the buffer by the required size

        mSendBuf->ExpandL(aOffset, aLength);

        // Transfer the data from java

        TPtr8 sendBufPtr = mSendBuf->Ptr(0);

        S60CommonUtils::CopyToNative(aJniEnv, aBytes, aOffset, aLength,sendBufPtr);

        // If the object is active then it is currently sending a message

        // it will also send the newly added message.

        iStatus = KRequestPending;

        SetActive();

        CallMethodL(this, &CMMSPlatformServiceS60Impl::mmsRequestComplete,

                    KErrNone,this);

    });

    ELOG1(EWMA, "CMMSPlatformServiceS60Impl : status of send %d",error);

    return error;

}

/*------------------------------------------------------------------------------

 * protected SetObjectActive locally

 * .

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::mmsRequestComplete(int result)

{

    JELOG2(EWMA);

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, result);

}

/*------------------------------------------------------------------------------

 * Notifies java side about success or failure of sending MMS message

 * .

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::NotifySend(JNIEnv& aJni,jobject aPeer,

        int aError)

{

    JELOG2(EWMA);

    aJni.CallVoidMethod(aPeer, mSendCallBackMethodId, aError);

    mIsSending = false;

}

/*------------------------------------------------------------------------------

 * RunL from CActive

 * .

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::RunL()

{

    JELOG2(EWMA);

    if (iStatus.Int() ==KErrNone)

    {

        mIsSending = true;

        SendMultiPartMessageL();

    }

}

/*------------------------------------------------------------------------------

 * protected DoCancel

 * Cancel the sending of the message. If the message is in the creation phase

 * we can cancel the sending of the message. If the deviec is actually sending

 * the message we cannot cancel it.

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::DoCancel()

{

    // clean up the entry

    JELOG2(EWMA);

}

/*------------------------------------------------------------------------------

 * protected RunError

 * .

 *------------------------------------------------------------------------------

 */

TInt CMMSPlatformServiceS60Impl::RunError(TInt aError)

{

    JELOG2(EWMA);

    ELOG1(EWMA, "+ In runerror %d this %d", aError);

    NotifySend(*mJniEnv, mJavaPeerObject, aError);

    return KErrNone;

}

/* -----------------------------------------------------------------------------

 * CMMSPlatformServiceS60Impl::RetrieveMessageL

 * Retrieves the first received message from the queue. After delivering the

 * message to the caller, the message is removed from the queue.

 * -----------------------------------------------------------------------------

 */

jbyteArray CMMSPlatformServiceS60Impl::retrieveMessage(JNIEnv& aJni)

{

    JELOG2(EWMA);

    // check if there is something in the queue

    if (mReceivedMMSIDs.Count() <= 0)

    {

        return NULL;

    }

    // retrieve the first message whose ID is in the queue

    TMsvId id = mReceivedMMSIDs[0];

    mReceivedMMSIDs.Remove(0);

    CMMSMessageInformation* mms = ReceivedMessage(id);

    if (!mms)

    {

        return NULL;

    }

    CleanupStack::PushL(mms);

    // serialize the received MMS

    LOG(EWMA, EInfo , "Serializing the message before giving to java");

    CBufFlat& receiveBuffer = mMessageHandler->SerializeLC(*mms);

    // receiveBuffer is on the cleanup stack

    TPtr8 receiveBufferPtr = receiveBuffer.Ptr(0);

    //get the jbyteArray

    TInt dataLength = receiveBuffer.Capacity();

    jbyteArray array = aJni.NewByteArray(dataLength);

    S60CommonUtils::CopyToJava(aJni, receiveBufferPtr, array, 0,dataLength);

    CleanupStack::PopAndDestroy(&receiveBuffer); // receiveBuffer

    CleanupStack::PopAndDestroy(mms);

    return array;

}

/*------------------------------------------------------------------------------

 * public CreateMessageL

 * create an empty messsage in draft folder. Later we will add the information

 * (attachments addresses, subject etc)

 *------------------------------------------------------------------------------

 */

TMsvId CMMSPlatformServiceS60Impl::CreateMessageL()

{

    JELOG2(EWMA);

    TMsvId serviceId = mMmsClient->DefaultServiceL();

    // Context must be set to parent folder for CreateMessageL

    mMmsClient->SwitchCurrentEntryL(KMsvDraftEntryId);

    mMmsClient->CreateMessageL(serviceId);

    CMsvEntry& cmsvEntry = mMmsClient->Entry();

    TMsvId msvId = cmsvEntry.EntryId();

    return msvId;

}

/*------------------------------------------------------------------------------

 * private DeleteSentMessage

 * When the message is gone from the device. Delete the message from

 * the sent folder.

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::DeleteSentMessageL(TMsvId aMsvId)

{

    JELOG2(EWMA);

    TInt index = mSendTMsvIdArray.Find(aMsvId);

    if (KErrNotFound == index)

    {

        return;

    }

    mSendTMsvIdArray.Remove(index);

    DeleteMmsMessageL(aMsvId);

}

/*------------------------------------------------------------------------------

 * public DeleteMessage

 * Delete the message from message store. We are deleting two type of

 * multimedia messages.Messages that we send from Java side. When they

 * are gone from the device. We delete the message from the sent folder.

 * Second is when we receive the message we delete it after

 * reading it from Java side.

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::DeleteMmsMessageL(TMsvId aMsvId)

{

    JELOG2(EWMA);

    LoadMessageL(aMsvId);

    CMsvEntry& cmsvEntry = mMmsClient->Entry();

    TMsvEntry tmsvEntry(cmsvEntry.Entry());

    if ((tmsvEntry.iMtm != KUidMsgTypeMultimedia)||(tmsvEntry.InPreparation()))

    {

        // It is not MMS  or the entry is not ready

        return;

    }

    //Taking a handle to the Sent folder...

    TMsvSelectionOrdering sort = cmsvEntry.SortType();

    sort.SetShowInvisibleEntries(ETrue);

    // we want to handle also the invisible entries

    // Take a handle to the parent entry

    CMsvEntry* parentEntry = CMsvEntry::NewL(mMmsClient->Session(),

                             tmsvEntry.Parent(), sort);

    CleanupStack::PushL(parentEntry); //

    TRAPD(err, parentEntry->DeleteL(aMsvId));

    if (err != KErrNone)

    {

        mSession->RemoveEntry(aMsvId);

    }

    CleanupStack::PopAndDestroy(parentEntry);

}

/*------------------------------------------------------------------------------

 * public LoadMessage

 * laod the message  from the given TMsvId,

 * After this call message will be current message

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::LoadMessageL(TMsvId aMessageEntry)

{

    JELOG2(EWMA);

    mMmsClient->SwitchCurrentEntryL(aMessageEntry);

    mMmsClient->LoadMessageL();

}

/*------------------------------------------------------------------------------

 * AddAttachments

 * add attachment, location, contentId, and set the message root here

 *

 *------------------------------------------------------------------------------

 */

void CMMSPlatformServiceS60Impl::AddAttachmentsL(

    CMMSMessageInformation* aMidMessageInformation)

{

    JELOG2(EWMA);

    // Add attachments also set the started ID

    CMsvStore* store = mMmsClient->Entry().EditStoreL();

    CleanupStack::PushL(store);

    TInt count = aMidMessageInformation->AttachmentCount();

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

    {

        CMMSMessageAttachment& messageAttachment =

            aMidMessageInformation->Attachment(i);

        TDesC& fileName = messageAttachment.AttachmentName();

        TDesC8& mimeType8 = messageAttachment.AttachmentType();

        TDesC8& contentLocation8 = messageAttachment.ContentLocationL();

        TDesC8& contentId8 = messageAttachment.ContentIdL();

        TInt charEncoding = messageAttachment.Encoding();

        TDesC* contentLocation = NULL;

        S60CommonUtils::ConvertNarrowToWiderLC(contentLocation8,contentLocation);

        CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewLC();

        // set the attachment mime type in the CMsvMimeHeaders

        if (&mimeType8)

        {

            TInt position = mimeType8.Find(KSlash);

            if (position > 0 && position < mimeType8.Length() - 1)

            {

                mimeHeaders->SetContentTypeL(mimeType8.Left(position));

                mimeHeaders->SetContentSubTypeL(mimeType8.Mid(position + 1));

            }

            else

            {

                mimeHeaders->SetContentTypeL(mimeType8);

            }

        }

        CMsvAttachment* attachment = CMsvAttachment::NewL(

                                         CMsvAttachment::EMsvFile);

        if (contentLocation)

        {

            mimeHeaders->SetContentLocationL(*contentLocation);

        }

        // contentId8 can be NULL

        if (&contentId8)

        {

            mimeHeaders->SetContentIdL(contentId8);

        }

        // set Charset in attachment

        if (charEncoding >= 0)

        {

            mimeHeaders->SetMimeCharset(charEncoding);

        }

        RFile attaFile;

        User::LeaveIfError(attaFile.Open(mRFs, fileName,

                                         EFileShareReadersOnly | EFileRead));

        CleanupClosePushL(attaFile);

        TMsvAttachmentId attaId = 0;

        // attachment ownerhip will be transferred to Attachment Manager

        // It must not be pushed onto the cleanupStack before calling

        // CreateAttachment2L

        HBufC8* emptyMime = NULL;

        if (&mimeType8)

        {

            mMmsClient->CreateAttachment2L(*store, // edit store

                                           attaFile, // open file handle

                                           mimeType8,

                                           // combination type like image/jpeg

                                           *mimeHeaders, attachment, attaId);

        }

        else

        {

            emptyMime = HBufC8::NewLC(0);

            mMmsClient->CreateAttachment2L(*store, // edit store

                                           attaFile, // open file handle

                                           *emptyMime,

                                           // combination type like image/jpeg

                                           *mimeHeaders, attachment, attaId);

        }

        // Now Attachment Manager owns the attachment object, so assign it NULL.

        attachment = NULL;

        // check also isStarted Id

        if (messageAttachment.IsStarterContentId())

        {

            mMmsClient->SetMessageRootL(attaId);

        }

        if (emptyMime)

        {

            CleanupStack::PopAndDestroy(emptyMime);

        }

        CleanupStack::PopAndDestroy(&attaFile); // attaFile.Close()

        CleanupStack::PopAndDestroy(mimeHeaders); // mimeHeaders