1 /*

     2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  JNI implementation for SensorConnectionImpl.java

    15 *

    16 */

    17 

    18 

    19 #include "com_nokia_mj_impl_sensor_SensorConnectionImpl.h"

    20 #include "sensorjniutils.h"

    21 #include "sensornativeconstants.h"

    22 #include "sensor.h"

    23 #include "sensorconnection.h"

    24 #include "sensorconnectionlist.h"

    25 #include "logger.h"

    26 

    27 void ConditionCallback(void* aJniEnv, void* aJavaPeer, void* aHandle, int aChannel,

    28                        double aValue, long aTimeStamp)

    29 {

    30     JELOG2(ESensor);

    31     JNIEnv* jniEnv = (JNIEnv*)aJniEnv;

    32     jobject peer = (jobject) aJavaPeer;

    33     jclass cls = jniEnv->GetObjectClass(peer);

    34     jmethodID mid = jniEnv->GetMethodID(cls, "conditionMet", "(IIDJ)V");

    35     int condId = reinterpret_cast< int >(aHandle);

    36     jniEnv->CallVoidMethod(peer, mid, aChannel, condId, aValue, aTimeStamp);

    37     // Handle possible exception in callback

    38     HandleException(*jniEnv);

    39 }

    40 

    41 void FillData(DataFillerParams* aParams)

    42 {

    43     JELOG2(ESensor);

    44     JNIEnv* jniEnv = (JNIEnv*)aParams->iJniEnv;

    45     jobjectArray destData = (jobjectArray)aParams->iDataObjects;

    46 

    47     // Assign data

    48     for (int i = 0; i < aParams->iDataCount; i++)

    49     {

    50         jobject data = jniEnv->GetObjectArrayElement(destData, i);

    51         jclass dataClass = jniEnv->GetObjectClass(data);

    52 

    53         if (aParams->iDatas[ i ]->iIntValues)

    54         {

    55             jfieldID field = jniEnv->GetFieldID(dataClass, "iIntValues", "[I");

    56             jintArray intValues = jniEnv->NewIntArray(aParams->iDatas[ i ]->iNumOfValues);

    57             jniEnv->SetIntArrayRegion(intValues, 0, aParams->iDatas[ i ]->iNumOfValues,

    58                                       aParams->iDatas[ i ]->iIntValues);

    59             jniEnv->SetObjectField(data, field, intValues);

    60             jniEnv->DeleteLocalRef(intValues);

    61             HandleException(*jniEnv);

    62         }

    63         else if (aParams->iDatas[ i ]->iDoubleValues)

    64         {

    65             jfieldID field = jniEnv->GetFieldID(dataClass, "iDoubleValues", "[D");

    66             jdoubleArray doubleValues = jniEnv->NewDoubleArray(aParams->iDatas[ i ]->iNumOfValues);

    67             jniEnv->SetDoubleArrayRegion(doubleValues, 0, aParams->iDatas[ i ]->iNumOfValues,

    68                                          aParams->iDatas[ i ]->iDoubleValues);

    69             jniEnv->SetObjectField(data, field, doubleValues);

    70             jniEnv->DeleteLocalRef(doubleValues);

    71             HandleException(*jniEnv);

    72         }

    73         if (aParams->iDatas[ i ]->iTimeStampsIncluded)

    74         {

    75             jfieldID field = jniEnv->GetFieldID(dataClass, "iTimestamps", "[J");

    76             jlongArray timestamps = jniEnv->NewLongArray(aParams->iDatas[ i ]->iNumOfValues);

    77             jniEnv->SetLongArrayRegion(timestamps, 0, aParams->iDatas[ i ]->iNumOfValues,

    78                                        reinterpret_cast<jlong*>(aParams->iDatas[ i ]->iTimeStamps));

    79             jniEnv->SetObjectField(data, field, timestamps);

    80             jniEnv->DeleteLocalRef(timestamps);

    81             HandleException(*jniEnv);

    82         }

    83         if (aParams->iDatas[ i ]->iValiditiesIncluded)

    84         {

    85             jfieldID field = jniEnv->GetFieldID(dataClass, "iValidities", "[Z");

    86             jbooleanArray validities = jniEnv->NewBooleanArray(aParams->iDatas[ i ]->iNumOfValues);

    87             jniEnv->SetBooleanArrayRegion(validities, 0, aParams->iDatas[ i ]->iNumOfValues,

    88                                           reinterpret_cast<jboolean*>(aParams->iDatas[ i ]->iValidities));

    89             jniEnv->SetObjectField(data, field, validities);

    90             jniEnv->DeleteLocalRef(validities);

    91             HandleException(*jniEnv);

    92         }

    93     }

    94     jobject peer = (jobject) aParams->iJavaPeer;

    95     jclass cls = jniEnv->GetObjectClass(peer);

    96     jmethodID mid = jniEnv->GetMethodID(cls, "dataReceived", "([Ljavax/microedition/sensor/Data;Z)V");

    97     jniEnv->CallVoidMethod(peer, mid, destData, aParams->iIsDataLost);

    98     // Handle possible exception in callback

    99     HandleException(*jniEnv);

   100 }

   101 

   102 /*

   103  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   104  * Method:    _createSensorConnection

   105  * Signature: (II)I

   106  */

   107 JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1createSensorConnection

   108 (JNIEnv* aJniEnv, jobject aJobj, jint aSensorList, jint aIndex)

   109 {

   110     JELOG2(ESensor);

   111     SensorConnectionList* senList = reinterpret_cast< SensorConnectionList* >(aSensorList);

   112     SensorConnection* conn = senList->CreateSensorConnection(aIndex);

   113     if (!conn)

   114     {

   115         return ERROR_NOMEMORY;

   116     }

   117     int err = conn->GetSensor()->OpenChannel(conn);

   118     if (err)

   119     {

   120         return err;

   121     }

   122     conn->SetJavaPeer(aJniEnv->NewWeakGlobalRef(aJobj));

   123     conn->SetCallbacks(&FillData, &ConditionCallback);

   124     return reinterpret_cast< int >(conn);

   125 }

   126 

   127 /*

   128  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   129  * Method:    _startDataListening

   130  * Signature: ([Ljavax/microedition/sensor/Data;IJZZ)I

   131  */

   132 

   133 JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1startDataListening

   134 (JNIEnv* aJniEnv, jobject /*aPeer*/, jint aSensorConnection, jobjectArray aData,

   135  jint aBufferSize, jlong aBufferingPeriod, jboolean aIsTimestampsIncluded,

   136  jboolean aIsValidityIncluded, jboolean aIsOneShot, jint aDataType)

   137 {

   138     JELOG2(ESensor);

   139     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aSensorConnection);

   140     void* oldData = 0;

   141     void* dataObjects = aJniEnv->NewGlobalRef(aData);

   142     int err = conn->PrepareDataListening(dataObjects,

   143                                          aJniEnv->GetArrayLength(aData),

   144                                          oldData,

   145                                          aDataType);

   146     // Remove possible old data objects

   147     if (oldData)

   148     {

   149         aJniEnv->DeleteGlobalRef((jobject)oldData);

   150     }

   151 

   152     if (!err)

   153     {

   154         err = conn->StartDataListening(aBufferSize, aBufferingPeriod,

   155                                        aIsTimestampsIncluded, aIsValidityIncluded,

   156                                        aIsOneShot);

   157     }

   158     return err;

   159 }

   160 

   161 /*

   162  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   163  * Method:    _cancelDataListening

   164  * Signature: (I)I

   165  */

   166 JNIEXPORT jint JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1cancelDataListening

   167 (JNIEnv *, jobject, jint aSensorConnection)

   168 {

   169     JELOG2(ESensor);

   170     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aSensorConnection);

   171     Sensor* sensor = conn->GetSensor();

   172     return sensor->CancelDataListening();

   173 }

   174 

   175 /*

   176  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   177  * Method:    _removeConnection

   178  * Signature: (II)V

   179  */

   180 JNIEXPORT void JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1removeConnection

   181 (JNIEnv* aJniEnv, jobject, jint aSensorList, jint aSensorConnection)

   182 {

   183     JELOG2(ESensor);

   184     SensorConnectionList* senList = reinterpret_cast< SensorConnectionList* >(aSensorList);

   185     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aSensorConnection);

   186     jobject dataObjects = (jobject)conn->DataObjects();

   187     if (dataObjects)

   188     {

   189         aJniEnv->DeleteGlobalRef(dataObjects);

   190     }

   191     aJniEnv->DeleteWeakGlobalRef((jweak)conn->GetJavaPeer());

   192     senList->RemoveConnection(conn);

   193 }

   194 

   195 /*

   196  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   197  * Method:    _startConditionListening

   198  * Signature: (II)V

   199  */

   200 JNIEXPORT void JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1startConditionListening

   201 (JNIEnv *, jobject, jint aConnectionHandle , jint aListeningType)

   202 {

   203     JELOG2(ESensor);

   204     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aConnectionHandle);

   205     Sensor* sensor = conn->GetSensor();

   206     sensor->StartConditionListening(aListeningType);

   207 }

   208 

   209 /*

   210  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   211  * Method:    _stopConditionListening

   212  * Signature: (I)V

   213  */

   214 JNIEXPORT void JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1stopConditionListening

   215 (JNIEnv *, jobject, jint aConnectionHandle)

   216 {

   217     JELOG2(ESensor);

   218     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aConnectionHandle);

   219     Sensor* sensor = conn->GetSensor();

   220     sensor->StopConditionListening();

   221 }

   222 

   223 /*

   224  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   225  * Method:    _startServer

   226  * Signature: (I)V

   227  */

   228 JNIEXPORT void JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1startServer

   229 (JNIEnv* aJniEnv, jobject, jint aConnectionHandle)

   230 {

   231     JELOG2(ESensor);

   232     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aConnectionHandle);

   233     Sensor* sensor = conn->GetSensor();

   234     // Store JNI env from this thread

   235     conn->SetJni(aJniEnv);

   236     sensor->StartServer();

   237 }

   238 

   239 /*

   240  * Class:     com_nokia_mj_impl_sensor_SensorConnectionImpl

   241  * Method:    _startServer

   242  * Signature: (I)V

   243  */

   244 JNIEXPORT void JNICALL Java_com_nokia_mj_impl_sensor_SensorConnectionImpl__1stopServer

   245 (JNIEnv *, jobject, jint aConnectionHandle)

   246 {

   247     JELOG2(ESensor);

   248     SensorConnection* conn = reinterpret_cast< SensorConnection* >(aConnectionHandle);

   249     Sensor* sensor = conn->GetSensor();

   250     sensor->StopServer();

   251 }