/*

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

 *

*/

#include <fstream>

#include "logger.h"

#include "monitor.h"

#include "pushexception.h"

#include "pusherrorcodes.h"

#include "applicationinfo.h"

#include "cbsserverconnection.h"

#include "connectionlistener.h"

#include "cbsserverconnectionfactory.h"

//custom error code for filter mismatches

const TInt KErrDoesNotMatchMessageId = -20012;

// Default array granularity, ~half of 15 pages

const TInt KDefaultArrayGranularity = 8;

using namespace java::util;

namespace java

{

namespace wma

{

OS_EXPORT CbsServerConnection::CbsServerConnection(const std::wstring& aUri,

        const std::wstring& aFilter)

        :CActive(EPriorityStandard),ServerConnectionBase(aUri, aFilter),

        mCbsMessageReceived(EFalse),mCbsPartiallyReceived(EFalse),

        mBroadcastMsgAttributePackage(mBroadcastMsgAttributes),

        mBroadcastPhoneCapsPckg(mBroadcastPhoneCaps)

{

    JELOG2(EWMA);

    std::wstring port = aUri.substr(KPortFieldStartIndex); // "cbs://:"

    mPort = JavaCommonUtils::wstringToInt(port);

    LOG1(EWMA, EInfo, "created CbsServerConnection on ID %d", mPort);

}

ServerConnection* ServerConnectionBase::getServerConnection(

    const std::wstring& aUri, const std::wstring& aFilter)

{

    JELOG2(EWMA);

    CbsServerConnection* cbsConn = new CbsServerConnection(aUri, aFilter);

    return cbsConn;

}

{

    JELOG2(EWMA);

}

void CbsServerConnection::initializeL()

{

    JELOG2(EWMA);

    TUint32 modemNo = 0;

    // get the name of the TSY

    mTsyName = HBufC16::NewL(KCommsDbSvrMaxFieldLength);

    TPtr tsyPtr(mTsyName->Des());

    CCommsDatabase* database = CCommsDatabase::NewL(EDatabaseTypeUnspecified);

    CleanupStack::PushL(database);

    database->GetGlobalSettingL(TPtrC(MODEM_PHONE_SERVICES_SMS), modemNo);

    // Now read the TSY name from the modem table record

    CCommsDbTableView* dbTable = database->OpenViewMatchingUintLC(TPtrC(MODEM),

                                 TPtrC(COMMDB_ID), modemNo);

    User::LeaveIfError(dbTable->GotoFirstRecord());

    dbTable->ReadTextL(TPtrC(MODEM_TSY_NAME), tsyPtr);

    CleanupStack::PopAndDestroy(dbTable);

    CleanupStack::PopAndDestroy(database);

    // Make a connection to RTelServer

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

    User::LeaveIfError(mTelServer.ShareAuto());

    User::LeaveIfError(mTelServer.LoadPhoneModule(*mTsyName));

    // Get the name of the first phone

    TInt phones;

    User::LeaveIfError(mTelServer.EnumeratePhones(phones));

    // Find the one which has the cbs functionality

    while (phones--)

    {

        TName tsyPhone;

        User::LeaveIfError(mTelServer.GetTsyName(phones, tsyPhone));

        if (tsyPhone.CompareF(*mTsyName) == KErrNone)

        {

            // Get the phone info

            RTelServer::TPhoneInfo tPhone;

            User::LeaveIfError(mTelServer.GetPhoneInfo(phones, tPhone));

            User::LeaveIfError(mMobilePhone.Open(mTelServer, tPhone.iName));

            // No need to look through any more of the available phones

            break;

        }

    }

    mCbsMessagePagesData = new(ELeave) CDesCArrayFlat(KDefaultArrayGranularity);

    mOpenMonitor = Monitor::createMonitor();

    int result = pthread_mutex_init(&mMutex, 0);

    if (result == 0)

    {

        result = pthread_cond_init(&mCondVar, 0);

    }

    if (0 != result)

    {

        User::Leave(result);

    }

}

                               bool aIsAppLaunched)

{

    JELOG2(EWMA);

    mIsAppLaunched = aIsAppLaunched;

    CbsServerConnection::open(aListener);

}

OS_EXPORT void CbsServerConnection::open(ConnectionListener* aListener)

{

    JELOG2(EWMA);

    int error = 0;

    mListener = aListener;

    //If it is push launched Message store will have received cbs messages

    //notify the listener

    if (mMessagesOnStore > 0)

    {

        mListener->msgArrived();

        CbsServerConnectionFactory::getFactory().setPendingMsgFlag(mUri, false);

    }

    else if (!mIsListening)

    {

        TRAP(error, initializeL());

        if (error != KErrNone)

        {

            ELOG1(EWMA, "CBS : Error while Initializing = %d", error);

            std::string errTxt("ERROR!!! CBS : Error while Initializing");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR, errTxt, __FILE__,

                                __FUNCTION__, __LINE__);

        }

        mInitialized = ETrue;

        // Set up RBroadcastMessaging

        error = mBroadcastMessage.Open(mMobilePhone);

        if (error != KErrNone)

        {

            ELOG1(EWMA, "CBS : RBroadcastMessaging Open failed : %d", error);

            std::string errTxt("ERROR!!! CBS :RBroadcastMessaging Open failed");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR, errTxt, __FILE__,

                                __FUNCTION__, __LINE__);

        }

        // Get the phone capabilities to find out if it is a GSM or WCDMA

        // based phone

        error = mBroadcastMessage.GetCaps(mBroadcastPhoneCapsPckg);

        if (error != KErrNone)

        {

            ELOG1(EWMA, "CBS : Get Capabilities failed : %d", error);

            std::string errTxt("ERROR!!! CBS: Get Capabilities failed");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR, errTxt, __FILE__,

                                __FUNCTION__, __LINE__);

        }

        // If the phone supports CDMA networks, then return KErrNotSupported

        if ((mBroadcastPhoneCaps.iModeCaps

                & RMobileBroadcastMessaging::KCapsCdmaTpduFormat)

                == RMobileBroadcastMessaging::KCapsCdmaTpduFormat)

        {

            ELOG(EWMA, "CBS : CDMA networks - Not Supported");

            std::string errTxt("ERROR!!!CBS : CDMA networks - Not Supported");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR, errTxt, __FILE__,

                                __FUNCTION__, __LINE__);

        }

        // Create Message Store

        const java::runtime::ApplicationInfo& appInf =

            java::runtime::ApplicationInfo::getInstance();

        const std::wstring& root = appInf.getRootPath();

        if (error != KErrNone)

        {

            ELOG1(EWMA,"CBS : create message store failed : %d",error);

            std::string errTxt("ERROR!!! CBS : create message store failed");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR,errTxt,__FILE__,

                                __FUNCTION__,__LINE__);

        }

        mState = ECbsOpen;

        //Create the listening thread which listens for Cbs messages

        error = pthread_create(&mThreadId, NULL,

                               CbsServerConnection::listenThread, this);

        if (error != KErrNone)

        {

            ELOG1(EWMA,"CBS : listenThread creation failed : %d",error);

            std::string errTxt("ERROR!!! CBS : listenThread creation failed");

            throw PushException(COMMON_SRV_CONN_PLUGIN_ERROR,errTxt,__FILE__,

                                __FUNCTION__,__LINE__);

        }

        mOpenMonitor->wait();

        mIsListening = true;

    }

}

void* CbsServerConnection::listenThread(void* aParams)

{

    JELOG2(EWMA);

    CTrapCleanup* tc = CTrapCleanup::New();

    CbsServerConnection* aCbsSrvConn =

        reinterpret_cast<CbsServerConnection*>(aParams);

    // As there is no possibility of active scheduler being installed to this

    // thread prior to this , there is no need for any checks.

    CActiveScheduler* activeScheduler = new CActiveScheduler();

    CActiveScheduler::Install(activeScheduler);

    CActiveScheduler::Add(aCbsSrvConn);

    aCbsSrvConn->setFilterSettings();

    aCbsSrvConn->SetActive();

    (aCbsSrvConn->mOpenMonitor)->notify();

    activeScheduler->Start();

    delete activeScheduler;

    delete tc;

    return 0;

}

void CbsServerConnection::setFilterSettings()

{

    JELOG2(EWMA);

    mBroadcastMessage.SetFilterSetting(iStatus,

                                       RMobileBroadcastMessaging::EBroadcastAcceptAll);

}

void CbsServerConnection::startCBSListening()

{

    JELOG2(EWMA);

    mState = ECbsReceivingActive;

    mBroadcastMessage.ReceiveMessage(iStatus, mBroadcastPageData,

                                     mBroadcastMsgAttributePackage);

}

void CbsServerConnection::DoCancel()

{

    JELOG2(EWMA);

    // Only cancel the appropriate asynchronous request

    switch (mState)

    {

    case ECbsOpen:

    {

        mBroadcastMessage.CancelAsyncRequest(

            EMobileBroadcastMessagingSetFilterSetting);

        break;

    }

    default:

    {

        mBroadcastMessage.CancelAsyncRequest(

            EMobileBroadcastMessagingReceiveMessage);

        break;

    }

    }

}

{

    JELOG2(EWMA);

    TCBSParametersBuf cbsParametersBuf;

    std::wstring path;

    char* messagePath =0;

    path += mMessageStoreDirName;

    try

    {

        path += JavaCommonUtils::intToWstring(mFirstMessageInStore);

        messagePath = JavaCommonUtils::wstringToUtf8(path);

        // Read the CBS file contents

        readStream.exceptions(std::ifstream::failbit|std::ifstream::badbit);

        readStream.open(messagePath, std::ios::in | std::ios::binary);

        readStream.read((char*) cbsParametersBuf.Ptr(), cbsParametersBuf.Size());

        readStream.read((char*)(aCbsBuf().mData).Ptr(),

                        cbsParametersBuf().mDataSize);

        readStream.close();

        (aCbsBuf().mData).SetLength((cbsParametersBuf().mDataSize)>>1);

        LOG1(EWMA,EInfo,"WMA : CBS Message Data Length %d",

             cbsParametersBuf().mDataSize);

        aCbsBuf().mAddress = cbsParametersBuf().mAddress;

        aCbsBuf().mPort = 0;

        // Get encoding

        aCbsBuf().mEncoding = cbsParametersBuf().mEncoding;

        deleteMessage();

        delete[] messagePath;

    }

    catch (std::ifstream::failure e)

    {

        ELOG(EWMA,"CBS : Exception while opening/reading file");

        delete[] messagePath;

        readStream.exceptions(std::ofstream::goodbit);

        readStream.close();

        return KErrGeneral;

    }

    catch (ExceptionBase ex)

    {

        delete[] messagePath;

        return KErrGeneral;

    }

    return KErrNone;

}

{

    JELOG2(EWMA);

    // the close and RunL are synchronized to make it SMP safe.

    if (mInitialized)

    {

        pthread_mutex_lock(&mMutex);

        mMessagesOnStore = 0;

        mInitialized = EFalse;

        mIsListening = false;

        mIsAppLaunched = false;

        mCbsMessageReceived = EFalse;

        mCbsPartiallyReceived = EFalse;

        if (mState != ECbsReceivingDeactive)

        {

            // Cancel blocks, so it is not called. Instead we check for any

            // outstanding request and call DoCancel().

            if (IsActive())

            {

                DoCancel();

            }

            mState = ECbsReceivingDeactive;

            if (mRunning)

            {

                pthread_cond_wait(&mCondVar, &mMutex);

            }

            mBroadcastMessage.Close();

            mMobilePhone.Close();

            mTelServer.Close();

            mCbsMessagePagesRef.Reset();

            delete mCbsMessagePagesData; // invokes Reset() if necessary

            delete mOpenMonitor;

            delete mTsyName;

        }

        pthread_mutex_unlock(&mMutex);

        pthread_mutex_destroy(&mMutex);

        pthread_cond_destroy(&mCondVar);

    }

}

TInt CbsServerConnection::RunError(TInt aError)

{

    JELOG2(EWMA);

    mListener->error(mUri, aError, "CBS :Error Receiving Broadcast Message");

    mRunning = EFalse;

    pthread_cond_signal(&mCondVar);

    pthread_mutex_unlock(&mMutex);

    CActiveScheduler::Stop();

    return KErrNone;

}

void CbsServerConnection::RunL()

{

    JELOG2(EWMA);

    pthread_mutex_lock(&mMutex);

    if (iStatus.Int() < KErrNone && iStatus.Int() != KErrCancel

            && mState != ECbsReceivingDeactive)

    {

        ELOG1(EWMA,"CBS : Error Receiving Broadcast Message:%d",iStatus.Int());

        mListener->error(mUri, iStatus.Int(),

                         "CBS : Error Receiving Broadcast Message");

        if (mIsAppLaunched)

        {

            startCBSListening();

            SetActive();

        }

        else

        {

            mRunning = EFalse;

            pthread_cond_signal(&mCondVar);

            CActiveScheduler::Stop();

        }

        pthread_mutex_unlock(&mMutex);

        return;

    }

    switch (mState)

    {

    case ECbsOpen:

    {

        mRunning = ETrue;

        //start listening for cbs messages

        startCBSListening();

        SetActive();

        break;

    }

    case ECbsReceivingActive:

    {

        TRAPD(error, readMessageFromStackL());

        if (error != KErrNone)

        {

            // port number does not match

            if (error != KErrDoesNotMatchMessageId)

            {

                // Otherwise report back to client as a system error occurred

                mListener->error(mUri, error,

                                 "CBS : Error Receiving Broadcast Message");

            }

        }

        else

        {

            if (mCbsMessageReceived)

            {

                mCbsMessageReceived = EFalse;

                // we have a complete message, so notify client

                mMessagesOnStore++;

                // If listening by push setPendingMsgFlag to true.

                // This is required as per push framework , so that

                // listConnections & other push calls works fine.

                if (!mIsAppLaunched)

                {

                    CbsServerConnectionFactory::getFactory().setPendingMsgFlag(

                        mUri, true);

                }

                mListener->msgArrived();

            }

        }

        startCBSListening();

        SetActive();

        break;

    }

    case ECbsReceivingDeactive:

    {

        mRunning = EFalse;

        pthread_cond_signal(&mCondVar);

        CActiveScheduler::Stop();

        break;

    }

    default:

    {

        //Nothing to do

    }

    }

    pthread_mutex_unlock(&mMutex);

}

void CbsServerConnection::readMessageFromStackL()

{

    JELOG2(EWMA);

    // Generate a message decoder

    CJavaCbsDecoder* cbsDecoder = new CJavaCbsDecoder();

    CleanupStack::PushL(cbsDecoder);

    TCBSDataBuf messageData = decodeCbsMessageL(cbsDecoder , mBroadcastPageData);

    // Filter the message based on the message Id

    if (mCbsMessageId != mPort)

    {

        CleanupStack::PopAndDestroy(cbsDecoder);

        User::LeaveIfError(KErrDoesNotMatchMessageId);

    }

    // Handle the possiblity of the message being a multipage message

    if (mCbsTotalNumPages != 1)

    {

        // This is a part of a multipage message

        // Get information about the message

        TInt currentPage = mCbsPageNumber;

        TUint messageCode = cbsDecoder->getMessageCode();

        if (mCbsPartiallyReceived)

        {

            // check whether or not this is the same one of already received

            // partial message.

            if ((messageCode != mCbsMultipageMessageCode) ||(mCbsMessageId

                    != mCbsMultipageMessageId))

            {

                // This is a new message, so ignore the old one

                // and setup for a new multipage message

                mCbsMessagePagesData->Reset();

                mCbsMessagePagesRef.Reset();

                mPageCounter = 0;

                mCbsPartiallyReceived = EFalse;

            }

        }

        // Adding more data to a partially saved message

        // For WCDMA messages, it is assumed that the pages will arrive

        // in the correct order.  mPageCounter is used to

        // keep track of the current page number.

        if (currentPage == KUnknownPageNumber)

        {

            currentPage = ++mPageCounter;

        }

        if (!mCbsPartiallyReceived)

        {

            // Start recording a new multipage message

            mCbsReceivedPages = (1 << (currentPage - 1));

            // Set some useful flags

            mCbsMultipageMessageCode = messageCode;

            mCbsMultipageMessageId = mCbsMessageId;

            mCbsPartiallyReceived = ETrue;

        }

        // Store the received page number, such that the message can

        // be reconstructed in the correct order later

        // Store the actual content of the message

        mCbsMessagePagesData->AppendL(messageData);

        // Record which page has been received as a bitmask