/*
* 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);
}
}
catch (ExceptionBase &ex)
{
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
(JNIEnv *aEnv, jobject /*aPeer*/, jlong aRemoteDevice, jlong aHandle,
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(
aEnv, aRemoteDevice, aHandle, attrIdsDes, serviceRecGlobalRef,
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();
return retVal;
}
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2GetReceiveMTU
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
int retVal = conn->getReceiveMTU();
return retVal;
}
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1available
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
int retVal = conn->available();
return retVal;
}
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1clientReceive
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle, jbyteArray aBuffer)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
// Memory needs to be allocated inside ClientConnection implementation.
// Reason to keep this here is to prevent passing JNI parameters to client.
char* bufferToFill = NULL;
int length = 0;
// Length returned will be positive if no errors resent.
// Else it will be error code.
length = conn->receive(bufferToFill);
if (length>0)
{
if (NULL == bufferToFill)
{
LOG(EJavaBluetooth, EInfo,
"JNI_BluetoothStackS60_clientReceive: Buffer NULL");
return 0; //EOF
}
LOG1(EJavaBluetooth, EInfo,
"JNI_BluetoothStackS60_clientReceive: Data %s",
bufferToFill);
JNIArrayUtils::CopyToJava((*aJni),
bufferToFill, length, aBuffer, 0, length);
}
LOG1(EJavaBluetooth, EInfo,
"JNI_BluetoothStackS60_clientReceive: Returning %d", length);
delete[] bufferToFill;
return length;
}
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1clientSend
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle,
jbyteArray aBuffer, jlong aLength)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
char* bufferToSend = new char[aLength+1];
JNIArrayUtils::CopyToNative((*aJni), aBuffer, 0, aLength, bufferToSend);
bufferToSend[aLength] = '\0';
int res = conn->send(bufferToSend, aLength);
LOG1(EJavaBluetooth,EInfo,
"Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1clientSend: Sent %d"
, res);
delete[] bufferToSend;
return res;
}
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1clientClose
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
conn->close();
delete conn;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: registerForCallback
* Signature: (J)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1registerForCallback
(JNIEnv *aJni, jobject peer, jlong aHandle)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *conn =
reinterpret_cast<BluetoothClientConnection *>(
static_cast<long>(aHandle));
conn->registerCallback(aJni, peer);
}
//------------------------------------------------------------------------------
// L2CAP Server Implementations
//------------------------------------------------------------------------------
JNIEXPORT jboolean JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1isL2ServerAlreadyRunning
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
return server->isActive();
}
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1restoreL2ServiceRecord(
JNIEnv *aJni, jobject /*peer*/,
jlong aHandle, jobject aServiceRecordImpl)
{
JELOG2(EJavaBluetooth);
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
ServiceRecord* srvRecHandle = srvHandle->getServiceRecordHandle();
if (NULL != srvRecHandle)
{
TRAP_IGNORE(
srvRecHandle->restoreJavaServiceRecordL(aJni, aServiceRecordImpl));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2ServerOpen
* Signature: (ZZZZZII)J
*/
JNIEXPORT jlong JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2ServerOpen
(JNIEnv *aJni, jobject /*peer*/, jstring aUrl, jboolean aAuthorize,
jboolean aAuthenticate, jboolean aEncrypt, jboolean aMaster,
jint aReceiveMTU, jint aTransmitMTU)
{
JELOG2(EJavaBluetooth);
LOG2(EJavaBluetooth, EInfo,
"+ JNI::l2ServerOpen TxMTU:%d RxMTU:%d",
aTransmitMTU, aReceiveMTU);
std::wstring connectionUrl;
try
{
connectionUrl = JniUtils::jstringToWstring(aJni, aUrl);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::l2ServerOpen Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException",
"Opening L2CAP server connection failed");
return NULL;
}
//Get handle to ServerConnectionFactory object.
BtL2CapServerConnectionFactory& connectionFactory =
BtL2CapServerConnectionFactory::getFactory();
L2CapPushServerConnection *l2CapPushServer;
ServerConnection *serverConn = connectionFactory.create(connectionUrl);
l2CapPushServer =
reinterpret_cast<L2CapPushServerConnection*>(serverConn);
if (l2CapPushServer->isActive())
{
//if we have already accepted connection or are listening, we need not
//go any further. return handle.
LOG(EJavaBluetooth, EInfo,
"- JNI::l2ServerOpen: Bluetooth server already running ");
return reinterpret_cast<jlong>(l2CapPushServer);
}
else
{
LOG(EJavaBluetooth, EInfo,
" JNI::l2ServerOpen: Trying to create and run a bluetooth server ");
L2CAPServerConnection* srvHandle = l2CapPushServer->getServerObject();
LOG(EJavaBluetooth, EInfo,
" JNI::l2ServerOpen: Calling open on Server Object");
TInt err;
err = srvHandle->ServerOpen(aAuthorize, aAuthenticate, aEncrypt,
aMaster, aReceiveMTU, aTransmitMTU);
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::l2ServerOpen Error on L2CAPServerConnection.ServerOpen: %d",
err);
if (l2CapPushServer->isCreatedByPush())
{
connectionFactory.releaseConnection(connectionUrl);
}
else
{
l2CapPushServer->close();
delete l2CapPushServer;
}
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening L2CAP server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
return NULL;
}
return reinterpret_cast<jlong>(l2CapPushServer);
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2ServerGetPSM
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2ServerGetPSM
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
//We should never be here if push plugin is already running.
int psmVal = srvHandle->GetServerPSM();
if (psmVal < 0)
{
ELOG1(EJavaBluetooth,
"- JNI::l2ServerGetPSM Error while GetServerPSM: %d",
psmVal);
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening L2CAP server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(psmVal));
}
LOG1(EJavaBluetooth, EInfo, "- JNI::l2ServerGetPSM PSM value:%d ", psmVal);
return psmVal;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2ServerGetServiceRecord
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2ServerGetServiceRecord
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
int servRecId = 0;
ServiceRecord* srvRecHandle = srvHandle->getServiceRecordHandle();
if (NULL != srvRecHandle)
{
servRecId = srvRecHandle->getServiceRecordID();
}
LOG1(EJavaBluetooth, EInfo,
"- JNI::l2ServerGetServiceRecord: %d", servRecId);
return servRecId;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2capRegisterSDPRecord
* Signature: (JI[BLjava/lang/String;)I
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2capRegisterSDPRecord
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle, jint aPsmVal,
jbyteArray aUuid, jstring aServerName)
{
JELOG2(EJavaBluetooth);
TInt err;
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
if (server->isActive())
{
//If the server is active it means that it has already done registration
//and has started advertising.
//If connection has already been accepted, then no issues at all.
return;
}
L2CAPServerConnection *srvHandle = server->getServerObject();
jbyte* byteArray = aJni->GetByteArrayElements(aUuid, NULL);
TPtrC8 uuidDes(reinterpret_cast<TUint8*>(byteArray),
aJni->GetArrayLength(aUuid));
TUUID uuid;
TRAP(err, uuid.SetL(uuidDes));
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::l2capRegisterSDPRecord Error while converting UUID: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening L2CAP server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
return;
}
JStringUtils servName(*aJni, aServerName);
TPtrC8 servNameP(
reinterpret_cast<const TUint8*>(servName.Ptr()),
servName.Size());
err = srvHandle->initializeServiceRecord(aPsmVal, uuid, servNameP);
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::l2capRegisterSDPRecord Error while initializeServiceRecord: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening L2CAP server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2ServerAcceptAndOpenServerConnection
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2ServerAcceptAndOpenServerConnection
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle, jintArray aReceiveMtu)
{
JELOG2(EJavaBluetooth);
BluetoothClientConnection *clientHandle;
int receiveMtu = 0;
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
if (server->isConnectionAccepted())
{
LOG(EJavaBluetooth, EInfo,
" JNI::l2ServerAcceptAndOpenServerConnection: returning already accepted push client ");
//Since connection has already been accepted, return the client object.
clientHandle = server->getConnectedClient();
receiveMtu = clientHandle->getReceiveMTU();
aJni->SetIntArrayRegion(aReceiveMtu, 0, 1, &receiveMtu);
return reinterpret_cast<jlong>(clientHandle);
}
if (server->isListening())
{
//Wait till connect and then return.
//Then we return client here.
java::util::Monitor* acceptMonitor =
java::util::Monitor::createMonitor();
server->setAcceptMonitor(acceptMonitor);
LOG(EJavaBluetooth, EInfo,
" JNI::l2ServerAcceptAndOpenServerConnection: waiting for connection accept ");
acceptMonitor->wait();
server->unsetAcceptMonitor();
delete acceptMonitor;
clientHandle = server->getConnectedClient();
receiveMtu = clientHandle->getReceiveMTU();
aJni->SetIntArrayRegion(aReceiveMtu, 0, 1, &receiveMtu);
return reinterpret_cast<jlong>(clientHandle);
}
// NOTE: In case we reached here, it means that there was no corresponding
// push plugin active when the midlet was launched.
// So we go ahead with usual stuff.
L2CAPServerConnection *srvHandle = server->getServerObject();
long retVal = srvHandle->Accept();
if (retVal < KErrNone)
{
ELOG1(EJavaBluetooth,
" JNI::l2ServerAcceptAndOpenServerConnection Error while Accept: %d ",
retVal);
if (KErrCancel == retVal)
{
java::util::JniUtils::throwNewException(aJni,
"java/io/InterruptedIOException",
"acceptAndOpen() failed: L2CAP server connection is closed");
}
else
{
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"acceptAndOpen() on L2CAP server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(retVal));
}
}
else
{
clientHandle = reinterpret_cast<BluetoothClientConnection *>(retVal);
receiveMtu = clientHandle->getReceiveMTU();
aJni->SetIntArrayRegion(aReceiveMtu, 0, 1, &receiveMtu);
}
return retVal;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: l2ServerClose
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1l2ServerClose
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
BtL2CapServerConnectionFactory& connectionFactory =
BtL2CapServerConnectionFactory::getFactory();
std::wstring uri = server->getUri();
server->unsetClearServiceClassBitsFlag();
if (server->isCreatedByPush())
{
connectionFactory.releaseConnection(uri);
}
else
{
server->close();
delete server;
}
return 0;
}
//-----------------------------------------------------------------------------
// RFCOMM Server Implementations
//-----------------------------------------------------------------------------
JNIEXPORT jboolean JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1isRfServerAlreadyRunning
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
return server->isActive();
}
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1restoreRfServiceRecord(
JNIEnv *aJni, jobject /*peer*/,
jlong aHandle, jobject aServiceRecordImpl)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
ServiceRecord* srvRecHandle = srvHandle->getServiceRecordHandle();
if (NULL != srvRecHandle)
{
TRAP_IGNORE(
srvRecHandle->restoreJavaServiceRecordL(aJni, aServiceRecordImpl));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfServerOpen
* Signature: (ZZZJ)J
*/
JNIEXPORT jlong JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfServerOpen
(JNIEnv *aJni, jobject /*peer*/, jstring aUrl, jboolean aAuthorize,
jboolean aAuthenticate, jboolean aEncrypt, jboolean aIsGOEP)
{
JELOG2(EJavaBluetooth);
std::wstring connectionUrl;
try
{
connectionUrl = JniUtils::jstringToWstring(aJni, aUrl);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::rfServerOpen Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException",
"Opening server connection failed");
return NULL;
}
//Get handle to ServerConnectionFactory object.
ServerConnectionFactory* connectionFactory = 0;
if (!aIsGOEP)
{
connectionFactory = &BTRFCOMMServerConnectionFactory::getFactory();
}
else
{
connectionFactory = &BTOBEXServerConnectionFactory::getFactory();
}
RFCOMMPushServerConnection *rfcommPushServer;
ServerConnection *serverConn =
connectionFactory->create(connectionUrl);
rfcommPushServer =
reinterpret_cast<RFCOMMPushServerConnection*>(serverConn);
if (rfcommPushServer->isActive())
{
//if we have already accepted connection or are listening, we need not
//go any further. return handle.
LOG(EJavaBluetooth, EInfo,
"- JNI::rfServerOpen: Bluetooth server already running ");
return reinterpret_cast<jlong>(rfcommPushServer);
}
else
{
LOG(EJavaBluetooth, EInfo,
" JNI::rfServerOpen: Opening server ");
RFCOMMServerConnection* srvHandle =
rfcommPushServer->getServerObject();
TInt err;
err = srvHandle->ServerOpen(aAuthorize, aAuthenticate, aEncrypt);
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::rfServerOpen Error on RFCOMMServerConnection.ServerOpen: %d",
err);
if (rfcommPushServer->isCreatedByPush())
{
connectionFactory->releaseConnection(connectionUrl);
}
else
{
rfcommPushServer->close();
delete rfcommPushServer;
}
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
return NULL;
}
}
return reinterpret_cast<jlong>(rfcommPushServer);
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfcommRegisterSDPRecord
* Signature: (JI[BLjava/lang/String;)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfcommRegisterSDPRecord
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle, jint aChannel,
jbyteArray aUuid, jstring aServerName, jboolean aIsObex)
{
JELOG2(EJavaBluetooth);
TInt err;
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
if (server->isActive())
{
//If the server is active it means that it has already done
//registration and has started advertising.
//If connection has already been accepted, then no issues at all.
return;
}
LOG(EJavaBluetooth, EInfo,
" JNI::rfcommRegisterSDPRecord Getting server object");
RFCOMMServerConnection *srvHandle = server->getServerObject();
jbyte* byteArray = aJni->GetByteArrayElements(aUuid, NULL);
TPtrC8 uuidDes(
reinterpret_cast<TUint8*>(byteArray), aJni->GetArrayLength(aUuid));
TUUID uuid;
TRAP(err, uuid.SetL(uuidDes));
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::rfcommRegisterSDPRecord Error while converting UUID: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
return;
}
JStringUtils servName(*aJni, aServerName);
TPtrC8 servNameP(
reinterpret_cast<const TUint8*>(servName.Ptr()), servName.Size());
err = srvHandle->initializeServiceRecord(
aChannel, uuid, servNameP, aIsObex);
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::rfcommRegisterSDPRecord Error while initializeServiceRecord: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"Opening server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfGetChannel
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfGetChannel
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
int channel = srvHandle->GetRfListeningChannel();
LOG1(EJavaBluetooth, EInfo, "- JNI::rfGetChannel: %d", channel);
return channel;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfServerGetServiceRecord
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfServerGetServiceRecord
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
int servRecId = 0;
ServiceRecord* srvRecHandle = srvHandle->getServiceRecordHandle();
if (NULL != srvRecHandle)
{
srvRecHandle->getServiceRecordID();
}
LOG1(EJavaBluetooth, EInfo,
"- JNI::rfServerGetServiceRecord: %d", srvRecHandle);
return servRecId;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfServerAcceptAndOpenServerConnection
* Signature: (J)J
*/
JNIEXPORT jlong JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfServerAcceptAndOpenServerConnection
(JNIEnv *aJni, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
if (server->isConnectionAccepted())
{
LOG(EJavaBluetooth, EInfo,
" JNI::rfServerAcceptAndOpenServerConnection: returning already accepted push client ");
//Since connection has already been accepted, return the client object.
return reinterpret_cast<jlong>(server->getConnectedClient());
}
if (server->isListening())
{
//Wait till connect and then return.
//Then we return client here.
java::util::Monitor* acceptMonitor =
java::util::Monitor::createMonitor();
server->setAcceptMonitor(acceptMonitor);
LOG(EJavaBluetooth, EInfo,
" JNI::rfServerAcceptAndOpenServerConnection: waiting for connection accept ");
acceptMonitor->wait();
server->unsetAcceptMonitor();
delete acceptMonitor;
return reinterpret_cast<jlong>(server->getConnectedClient());
}
LOG(EJavaBluetooth, EInfo,
" JNI::rfServerAcceptAndOpenServerConnection Getting server object");
//NOTE: In case we reached here, it means that there was no corresponding
//push plugin active when the midlet was launched.
//So we go ahead with usual stuff.
RFCOMMServerConnection *srvHandle = server->getServerObject();
long clientHandle;
clientHandle = srvHandle->Accept();
if (clientHandle < KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::rfServerAcceptAndOpenServerConnection Error while Accept: %d ",
clientHandle);
if (KErrCancel == clientHandle)
{
java::util::JniUtils::throwNewException(aJni,
"java/io/InterruptedIOException",
"acceptAndOpen() on server connection failed: connection is closed ");
}
else
{
java::util::JniUtils::throwNewException(aJni,
"java/io/IOException",
"acceptAndOpen() on server connection failed. Symbian OS error: "
+ JavaCommonUtils::intToString(clientHandle));
}
}
return (clientHandle);
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: rfServerClose
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1rfServerClose
(JNIEnv* /*aJni*/, jobject /*peer*/, jlong aHandle)
{
JELOG2(EJavaBluetooth);
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
ServerConnectionFactory* connectionFactory = 0;
if (!(server->isGOEPConnection()))
{
connectionFactory = &BTRFCOMMServerConnectionFactory::getFactory();
}
else
{
connectionFactory = &BTOBEXServerConnectionFactory::getFactory();
}
std::wstring uri = server->getUri();
server->unsetClearServiceClassBitsFlag();
if (server->isCreatedByPush())
{
connectionFactory->releaseConnection(uri);
}
else
{
server->close();
delete server;
}
return 0;
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: initializeUpdateRecord
* Signature: (Ljava/lang/String;J)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1initializeUpdateRecord
(JNIEnv *aJni, jobject /*peer*/,
jstring aProtocol, jlong aHandle, jint aDeviceServiceClasses)
{
JELOG2(EJavaBluetooth);
ServiceRecord* srvRec;
std::wstring protocol;
try
{
protocol = java::util::JniUtils::jstringToWstring(aJni, aProtocol);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::initializeUpdateRecord Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException", "Updating service record failed");
return;
}
if (0 == protocol.compare(L"btl2cap"))
{
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
else //if protocol is "btspp"
{
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
srvRec->initializeUpdateRecord(aDeviceServiceClasses);
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: completesUpdateRecord
* Signature: (Ljava/lang/String;J)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1completesUpdateRecord
(JNIEnv *aJni, jobject /*peer*/, jstring aProtocol, jlong aHandle)
{
JELOG2(EJavaBluetooth);
ServiceRecord* srvRec;
std::wstring protocol;
try
{
protocol = java::util::JniUtils::jstringToWstring(aJni, aProtocol);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::completesUpdateRecord Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException", "Updating service record failed");
return;
}
if (0 == protocol.compare(L"btl2cap"))
{
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
else // if protocol is "btspp"
{
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
srvRec->completesUpdateRecord();
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: sdpAddAttribute
* Signature: (Ljava/lang/String;JIIJ[B)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1sdpAddAttribute
(JNIEnv *aJni, jobject /*peer*/, jstring aProtocol, jlong aHandle,
jint aAttrID, jint aAttrType, jlong aNumValue, jbyteArray aBytesValue)
{
JELOG2(EJavaBluetooth);
ServiceRecord* srvRec;
int err = 0;
std::wstring protocol;
try
{
protocol = java::util::JniUtils::jstringToWstring(aJni, aProtocol);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAddAttribute Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException", "Updating service record failed");
return;
}
if (0 == protocol.compare(L"btl2cap"))
{
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
else // if protocol is "btspp"
{
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
LOG1(EJavaBluetooth, EInfo,
" JNI::sdpAddAttribute aAttrType:%d", aAttrType);
switch (aAttrType)
{
case DataElement_NULL:
{
err = srvRec->setAttributeNil(aAttrID);
break;
}
case DataElement_BOOL:
{
TBool val = (aNumValue) ? ETrue : EFalse;
err = srvRec->setAttributeBool(aAttrID, val);
break;
}
case DataElement_U_INT_1:
case DataElement_INT_1:
case DataElement_U_INT_2:
case DataElement_INT_2:
case DataElement_U_INT_4:
case DataElement_INT_4:
{
ELOG(EJavaBluetooth, " JNI::sdpAddAttribute UINT/INT/1/2/4 element.");
TSdpIntBuf<TUint> val(aNumValue);
err = srvRec->setAttributeInt(aAttrID, aAttrType, val);
break;
}
case DataElement_INT_8:
{
TSdpIntBuf<TUint64> val(aNumValue);
err = srvRec->setAttributeInt(aAttrID, aAttrType, val);
break;
}
case DataElement_U_INT_8:
case DataElement_U_INT_16:
case DataElement_INT_16:
{
jbyte* bytes = aJni->GetByteArrayElements(aBytesValue, NULL);
TPtrC8 val(reinterpret_cast<TUint8*>(bytes),
aJni->GetArrayLength(aBytesValue));
err = srvRec->setAttributeUint(aAttrID, aAttrType, val);
break;
}
case DataElement_UUID:
{
jbyte* bytes = aJni->GetByteArrayElements(aBytesValue, NULL);
TPtrC8 uuidDes(reinterpret_cast<TUint8*>(bytes),
aJni->GetArrayLength(aBytesValue));
TUUID val;
TRAP(err, val.SetL(uuidDes));
if (err != KErrNone)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAddAttribute Error while converting UUID: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"javax/bluetooth/ServiceRegistrationException",
"Updating service record failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
return;
}
err = srvRec->setAttributeUUID(aAttrID, val);
break;
}
case DataElement_STRING:
{
jbyte* bytes = aJni->GetByteArrayElements(aBytesValue, NULL);
TPtrC8 val(reinterpret_cast<TUint8*>(bytes),
aJni->GetArrayLength(aBytesValue));
err = srvRec->setAttributeString(aAttrID, val);
break;
}
case DataElement_URL:
{
jbyte* bytes = aJni->GetByteArrayElements(aBytesValue, NULL);
TPtrC8 val(reinterpret_cast<TUint8*>(bytes),
aJni->GetArrayLength(aBytesValue));
err = srvRec->setAttributeUrl(aAttrID, val);
break;
}
default:
break;
}
if (KErrNone != err)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAddAttribute Failed to update service record %d",
err);
java::util::JniUtils::throwNewException(aJni,
"javax/bluetooth/ServiceRegistrationException",
"Updating service record failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: sdpAttributeListStart
* Signature: (Ljava/lang/String;JII)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1sdpAttributeListStart
(JNIEnv *aJni, jobject /*peer*/, jstring aProtocol, jlong aHandle,
jint aAttrID, jint aAttrType)
{
JELOG2(EJavaBluetooth);
ServiceRecord* srvRec;
int err = 0;
std::wstring protocol;
try
{
protocol = java::util::JniUtils::jstringToWstring(aJni, aProtocol);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAttributeListStart Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException", "Updating service record failed");
return;
}
if (0 == protocol.compare(L"btl2cap"))
{
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
else // if protocol is "btspp"
{
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
err = srvRec->attributeListStart(aAttrID, aAttrType);
if (KErrNone != err)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAttributeListStart Error while attributeListStart: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"javax/bluetooth/ServiceRegistrationException",
"Updating service record failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
}
}
/*
* Class: com_nokia_mj_impl_bluetooth_BluetoothStackS60
* Method: sdpAttributeListEnd
* Signature: (Ljava/lang/String;JI)V
*/
JNIEXPORT void JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1sdpAttributeListEnd
(JNIEnv *aJni, jobject /*peer*/, jstring aProtocol, jlong aHandle,
jint aAttrID)
{
JELOG2(EJavaBluetooth);
ServiceRecord* srvRec;
int err = 0;
std::wstring protocol;
try
{
protocol = java::util::JniUtils::jstringToWstring(aJni, aProtocol);
}
catch (ExceptionBase &ex)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAttributeListEnd Exception:%S", ex.what());
java::util::JniUtils::throwNewException(aJni,
"java/lang/RunTimeException", "Updating service record failed");
return;
}
if (0 == protocol.compare(L"btl2cap"))
{
L2CapPushServerConnection* server =
reinterpret_cast<L2CapPushServerConnection *>(
static_cast<long>(aHandle));
L2CAPServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
else // if protocol is "btspp"
{
RFCOMMPushServerConnection* server =
reinterpret_cast<RFCOMMPushServerConnection *>(
static_cast<long>(aHandle));
RFCOMMServerConnection *srvHandle = server->getServerObject();
srvRec = srvHandle->getServiceRecordHandle();
}
err = srvRec->attributeListEnd(aAttrID);
if (KErrNone != err)
{
ELOG1(EJavaBluetooth,
"- JNI::sdpAttributeListEnd Error while attributeListEnd: %d",
err);
java::util::JniUtils::throwNewException(aJni,
"javax/bluetooth/ServiceRegistrationException",
"Updating service record failed. Symbian OS error: "
+ JavaCommonUtils::intToString(err));
}
}
//
// JNI functions specific to Remote Device operations
//
JNIEXPORT jboolean JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1isAuthenticated
(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aRemoteAddress)
{
JELOG2(EJavaBluetooth);
jboolean ret = java::bluetooth::BluetoothRemoteDevice::getSecurityProperty(
REMOTE_AUTHENTICATED, aRemoteAddress);
return ret;
}
JNIEXPORT jboolean JNICALL
Java_com_nokia_mj_impl_bluetooth_BluetoothStackS60__1isTrusted
(JNIEnv* /*aJni*/, jobject /*aPeer*/, jlong aRemoteAddress)
{
JELOG2(EJavaBluetooth);
jboolean ret = java::bluetooth::BluetoothRemoteDevice::getSecurityProperty(
REMOTE_TRUSTED, aRemoteAddress);
return ret;
}