/*

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

*

*/

#include <e32cmn.h>

#include <bttypes.h>

#include "functionserver.h"

#include "javajniutils.h"

#include "jniarrayutils.h"

#include "jstringutils.h"

#include "logger.h"

#include "fs_methodcall.h"

#include "monitor.h"

#include "exceptionbase.h"

#include "bluetoothconsts.h"

#include "bluetoothfunctionserver.h"

#include "discoveryagent.h"

#include "bluetoothclientconnection.h"

#include "btl2capserverconnection.h"

#include "btrfcommserverconnection.h"

#include "bluetoothstructs.h"

#include "servicerecord.h"

#include "bluetoothremotedevice.h"

//Push related stuff

#include "btl2cappushserverconnection.h"

#include "btl2capserverconnectionfactory.h"

#include "btrfcommpushserverconnection.h"

#include "btrfcommserverconnectionfactory.h"

#include "btobexserverconnectionfactory.h"

#include "pushexception.h"

#include "pusherrorcodes.h"

#include "com_nokia_mj_impl_bluetooth_BluetoothStackS60.h"

using namespace std;

using namespace java::util;

using namespace java::push;

using namespace java::bluetooth;

//

// JNI functions specific to Bluetooth Stack

//

JNIEXPORT jlong JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1createFunctionServer

(JNIEnv *aJni, jobject aPeer)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::BluetoothFunctionServer* server =

        new java::bluetooth::BluetoothFunctionServer(*aJni, aPeer);

    return reinterpret_cast<jlong>(server);

}

//

// JNI functions specific to Discovery Agent

//

JNIEXPORT jlong JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1createNativeDiscoveryAgent

(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aServer)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::BluetoothFunctionServer *server =

        reinterpret_cast<java::bluetooth::BluetoothFunctionServer *>(

            static_cast<long>(aServer));

    java::bluetooth::DiscoveryAgent* agent =

        new java::bluetooth::DiscoveryAgent(server);

    jlong ret = reinterpret_cast<jlong>(agent);

    return ret;

}

//

// JNI functions specific to Device Discovery

//

JNIEXPORT jint JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1runDeviceInquiry

(JNIEnv *aJni, jobject aPeer, jint aAccessCode, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo, "+ JNI::runDeviceInquiry %X", aAccessCode);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    int result = KErrNone;

    result = agent->startDeviceDiscovery(aJni, aPeer, aAccessCode);

    if (KErrNone != result)

    {

        ELOG1(EJavaBluetooth,

              "- JNI::runDeviceInquiry Error before starting inquiry %d",

              result);

        java::util::JniUtils::throwNewException(aJni,

                                                "javax/bluetooth/BluetoothStateException",

                                                "Device inquiry failed. Symbian OS error: "

                                                + JavaCommonUtils::intToString(result));

        return INQUIRY_ERROR;

    }

    int discStatus = 0;

    do

    {

        //Wait for discovery agent to unlock this.

        LOG(EJavaBluetooth, EInfo,

            "  JNI::runDeviceInquiry: Getting next device");

        DiscoveredDevice device;

        discStatus = agent->getNextDevice(device);

        agent->doDeviceDiscoveryCallback(aJni, aPeer, device);

        device.clean();

        LOG1(EJavaBluetooth, EInfo,

             "  JNI::runDeviceInquiry doDeviceDiscoveryCallback return: %d",

             discStatus);

    }

    while ((INQUIRY_ERROR != discStatus) &&

            (INQUIRY_COMPLETED != discStatus) &&

            (INQUIRY_TERMINATED != discStatus));

    return discStatus;

}

JNIEXPORT jboolean JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1cancelInquiry

(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    jboolean ret = agent->cancelDeviceDiscovery();

    return ret;

}

JNIEXPORT jstring JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1getRemoteDeviceFriendlyName

(JNIEnv* aJni, jobject /*aPeer*/, jlong aAgent, jlong aAddr)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo,

         "+ JNI::getRemoteDeviceFriendlyName DeviceAddress:%ld",

         aAddr);

    java::bluetooth::DiscoveryAgent* dAgent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aAgent));

    std::wstring* friendlyName = NULL;

    TRAPD(err,

          friendlyName = dAgent->lookupFriendlyNameL(aAddr));

    if (KErrNone != err)

    {

        ELOG1(EJavaBluetooth,

              "- JNI::getRemoteDeviceFriendlyName while lookupFriendlyNameL:%d",

              err);

        java::util::JniUtils::throwNewException(aJni,

                                                "java/io/IOException",

                                                "Retrieving remote device friendly name failed. Symbian OS error: "

                                                + JavaCommonUtils::intToString(err));

        return NULL;

    }

    jstring ret;

    try

    {

        if (NULL != friendlyName)

        {

            ret = java::util::JniUtils::wstringToJstring(aJni, *friendlyName);

            delete friendlyName;

        }

        else

        {

            std::wstring str(L"");

            ret = java::util::JniUtils::wstringToJstring(aJni, str);

        }

    }

    {

        ELOG1(EJavaBluetooth,

              "- JNI::getRemoteDeviceFriendlyName Exception:%S", ex.what());

        java::util::JniUtils::throwNewException(aJni,

                                                "java/lang/RunTimeException", "Retrieving friendly name failed");

        delete friendlyName;

        return NULL;

    }

    return ret;

}

//

// JNI functions specific to Service Search & Populate Records

//

JNIEXPORT jint JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1runSearchServices

(JNIEnv *aEnv, jobject aPeer, jlong aRemoteAddress, jbyteArray aUuidSet,

 jintArray aAttrSet, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    // ...convert the UUID bytes into an 8-bit descriptor...

    jbyte* byteArray = aEnv->GetByteArrayElements(aUuidSet, NULL);

    TInt numUuidBytes = aEnv->GetArrayLength(aUuidSet);

    TPtrC8 uuidsDes(reinterpret_cast<TUint8*>(byteArray), numUuidBytes);

    // ...convert the Attribute IDs into pairs of 16-bits in a descriptor...

    int numAttrIds = aEnv->GetArrayLength(aAttrSet);

    jint* intArray = aEnv->GetIntArrayElements(aAttrSet, NULL);

    TPtrC16 attrIdsDes(reinterpret_cast<TUint16*>(intArray), numAttrIds*2);

    java::util::Monitor* serviceSearchMonitor =

        java::util::Monitor::createMonitor();

    LOG(EJavaBluetooth, EInfo,

        "   JNI::runSearchServices calling StartSearchServices");

    int result = KErrNone;

    result = agent->StartSearchServices(

                 aEnv, aPeer, aRemoteAddress, uuidsDes, attrIdsDes,

                 serviceSearchMonitor);

    LOG(EJavaBluetooth, EInfo,

        "  JNI::runSearchServices returned from StartSearchServices");

    if (KErrNone != result)

    {

        LOG(EJavaBluetooth, EInfo,

            "  JNI::runSearchServices Error occurred before starting service search!");

        delete serviceSearchMonitor;

        serviceSearchMonitor = NULL;

        return SERVICE_SEARCH_ERROR;

    }

    int searchStatus = -1;

    LOG(EJavaBluetooth, EInfo,

        "  JNI::runSearchServices waiting for search complete");

    while ((SERVICE_SEARCH_ERROR != searchStatus) &&

            (SERVICE_SEARCH_COMPLETED != searchStatus) &&

            (SERVICE_SEARCH_TERMINATED != searchStatus) &&

            (SERVICE_SEARCH_NO_RECORDS != searchStatus) &&

            (SERVICE_SEARCH_DEVICE_NOT_REACHABLE != searchStatus))

    {

        //Wait for discoveryagent to unlock this.

        serviceSearchMonitor->wait();

        searchStatus = agent->getStatusOfCompletion();

        LOG1(EJavaBluetooth, EInfo,

             "  JNI::runSearchServices doServiceDiscoveredCallback return: %d",

             searchStatus);

    }

    delete serviceSearchMonitor;

    serviceSearchMonitor = NULL;

    LOG1(EJavaBluetooth, EInfo,

         "- JNI::runSearchServices status:%d", searchStatus);

    return searchStatus;

}

JNIEXPORT jboolean JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1cancelServiceSearch

(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    jboolean ret = agent->CancelServiceSearch();

    return ret;

}

JNIEXPORT jint JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1populateServiceRecordAttributeValues

 jintArray aAttrSet, jobject aServiceRecordImpl, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    // ...convert the Attribute IDs into pairs of 16-bits in a descriptor...

    int numAttrIds = aEnv->GetArrayLength(aAttrSet);

    jint* intArray = aEnv->GetIntArrayElements(aAttrSet, NULL);

    TPtrC16 attrIdsDes(reinterpret_cast<TUint16*>(intArray), numAttrIds*2);

    java::util::Monitor* serviceSearchMonitor =

        java::util::Monitor::createMonitor();

    jobject serviceRecGlobalRef = aEnv->NewGlobalRef(aServiceRecordImpl);

    LOG(EJavaBluetooth, EInfo,

        "   JNI::populateServiceRecordAttributeValues calling PopulateServiceRecord");

    int result = KErrNone;

    result = agent->PopulateServiceRecordAttrValue(

                 serviceSearchMonitor);

    if (KErrNone != result)

    {

        aEnv->DeleteGlobalRef(serviceRecGlobalRef);

        return SERVICE_SEARCH_ERROR;

    }

    // Waiting for populateServiceRecord to finish

    serviceSearchMonitor->wait();

    aEnv->DeleteGlobalRef(serviceRecGlobalRef);

    return agent->GetPopulateServiceRecordStatus();

}

JNIEXPORT void JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1cancelPopulateServicesRecordAttributeValues

(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aDiscAgent)

{

    JELOG2(EJavaBluetooth);

    java::bluetooth::DiscoveryAgent* agent =

        reinterpret_cast<java::bluetooth::DiscoveryAgent *>(

            static_cast<long>(aDiscAgent));

    jboolean result = agent->CancelPopulateServiceRecordAttrValue();

    LOG1(EJavaBluetooth, EInfo,

         "- JNI::cancelPopulateServicesRecordAttributeValues Result:%d",

         result);

    return;

}

JNIEXPORT jlong JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1getRemoteAddress

(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aHandle)

{

    JELOG2(EJavaBluetooth);

    BluetoothClientConnection *conn =

        reinterpret_cast<BluetoothClientConnection *>(

            static_cast<long>(aHandle));

    return conn->getRemoteAddress();

}

JNIEXPORT jlong JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2OpenClientConnection

(JNIEnv* aJni, jobject /*peer*/, jlong aBtAddress, jint aChannel,

 jboolean aAuthenticate, jboolean aEncrypt, jint aReceiveMTU,

 jint aTransmitMTU, jlong aServer)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo,

         "+ JNI:l2OpenClientConnection: btAddress = %x", aBtAddress);

    BluetoothFunctionServer *server =

        reinterpret_cast<BluetoothFunctionServer *>(

            static_cast<long>(aServer));

    BluetoothClientConnection* conn = new BluetoothClientConnection(server);

    //Initialize Bluetooth Connection to L2CAP

    int error = conn->init(PROTOCOL_L2CAP);

    if (error != 0)

    {

        // If initialization was not successful,

        // then delete BluetoothClientConnection.

        conn->close();

        delete conn;

        ELOG1(EJavaBluetooth,

              "JNI:l2OpenClientConnection: Error during init: %d", error);

        jclass cls = aJni->FindClass(

                         "javax/bluetooth/BluetoothConnectionException");

        jmethodID constructorID = aJni->GetMethodID(cls, "<init>", "(I)V");

        jthrowable bcexception = (jthrowable) aJni->NewObject(

                                     cls, constructorID, BC_FAILED_NOINFO);

        aJni->Throw(bcexception);

        // free the local ref

        aJni->DeleteLocalRef(cls);

        return error;

    }

    //Connect to the server

    error = conn->connect(aBtAddress, aChannel, aAuthenticate, aEncrypt,

                          aReceiveMTU, aTransmitMTU);

    if (error<0)

    {

        ELOG1(EJavaBluetooth,

              "JNI:l2OpenClientConnection: Error during connect: %d",

              error);

        jclass cls = aJni->FindClass(

                         "javax/bluetooth/BluetoothConnectionException");

        jmethodID constructorID = aJni->GetMethodID(cls, "<init>", "(I)V");

        if (error == HCI_TIMEOUT)

        {

            jthrowable bcexception = (jthrowable) aJni->NewObject(

                                         cls, constructorID, BC_TIMEOUT);

            aJni->Throw(bcexception);

        }

        else

        {

            jthrowable bcexception = (jthrowable) aJni->NewObject(

                                         cls, constructorID, BC_FAILED_NOINFO);

            aJni->Throw(bcexception);

        }

        // free the local ref

        aJni->DeleteLocalRef(cls);

        conn->close();

        delete conn;

        return error;

    }

    LOG1(EJavaBluetooth, EInfo,

         "- JNI:l2OpenClientConnection: Handle = %ld", conn);

    return reinterpret_cast<jlong>(conn);

}

JNIEXPORT jlong JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfClientOpen

(JNIEnv* aJni, jobject /*peer*/, jlong aBtAddress, jint aChannel,

 jboolean aAuthenticate, jboolean aEncrypt, jlong aServer)

{

    JELOG2(EJavaBluetooth);

    LOG1(EJavaBluetooth, EInfo,

         "+ JNI:rfClientOpen: btAddress = %ld", aBtAddress);

    BluetoothFunctionServer *server =

        reinterpret_cast<BluetoothFunctionServer *>(

            static_cast<long>(aServer));

    BluetoothClientConnection* conn = new BluetoothClientConnection(server);

    //Initialize Bluetooth Connection to RFCOMM

    int error = conn->init(PROTOCOL_RFCOMM);

    if (error != 0)

    {

        // If initialization was not successful,

        // delete BluetoothClientConnection.

        conn->close();

        delete conn;

        ELOG1(EJavaBluetooth,

              "JNI:rfClientOpen: Error during init: %d", error);

        jclass cls = aJni->FindClass(

                         "javax/bluetooth/BluetoothConnectionException");

        jmethodID constructorID = aJni->GetMethodID(cls, "<init>", "(I)V");

        jthrowable bcexception = (jthrowable) aJni->NewObject(

                                     cls, constructorID, BC_FAILED_NOINFO);

        aJni->Throw(bcexception);

        // free the local ref

        aJni->DeleteLocalRef(cls);

        return error;

    }

    //Connect to the server

    error = conn->connect(aBtAddress, aChannel, aAuthenticate, aEncrypt);

    if (error<0)

    {

        ELOG1(EJavaBluetooth,

              "JNI:rfClientOpen: Error during connect: %d", error);

        jclass cls = aJni->FindClass(

                         "javax/bluetooth/BluetoothConnectionException");

        jmethodID constructorID = aJni->GetMethodID(cls, "<init>", "(I)V");

        if (error == HCI_TIMEOUT)

        {

            jthrowable bcexception = (jthrowable) aJni->NewObject(

                                         cls, constructorID, BC_TIMEOUT);

            aJni->Throw(bcexception);

        }

        else

        {

            jthrowable bcexception = (jthrowable) aJni->NewObject(

                                         cls, constructorID, BC_FAILED_NOINFO);

            aJni->Throw(bcexception);

        }

        // free the local ref

        aJni->DeleteLocalRef(cls);

        conn->close();

        delete conn;

        return error;

    }

    LOG1(EJavaBluetooth, EInfo, "- JNI:rfClientOpen: Handle %ld", conn);

    return reinterpret_cast<jlong>(conn);

}

JNIEXPORT jint JNICALL

Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2GetTransmitMTU

(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)

{

    JELOG2(EJavaBluetooth);

    BluetoothClientConnection *conn =

        reinterpret_cast<BluetoothClientConnection *>(

            static_cast<long>(aHandle));

    int retVal = conn->getTransmitMTU();