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:  LocationProviderImpl JNI context

    15  *

    16 */

    17 

    18 

    19 #include <e32def.h>

    20 #include <lbs.h>

    21 #include "com_nokia_mj_impl_location_LocationProviderImpl.h"

    22 #include "clocationprovider.h"

    23 #include "cpositionerbase.h"

    24 #include "s60commonutils.h"

    25 #include "ctrackingpositioner.h"

    26 #include "fs_methodcall.h"

    27 #include "logger.h"

    28 #include "monitor.h"

    29 

    30 #ifdef RD_JAVA_PROXIMITY_LISTENER_ENABLED

    31 #include "cproximitylistener.h"

    32 #endif

    33 

    34 using namespace java::location;

    35 

    36 /*

    37  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

    38  * Method:    _createFunctionSource

    39  * Signature: ()I

    40  */

    41 JNIEXPORT jint JNICALL

    42 Java_com_nokia_mj_impl_location_LocationProviderImpl__1createFunctionSource

    43 (JNIEnv* aJni, jobject aLocationProvider)

    44 {

    45     JELOG2(EJavaLocation);

    46 

    47     LocationFunctionServer* mFunctionServer =

    48         new LocationFunctionServer(*aJni, aLocationProvider);

    49     return reinterpret_cast<jint>(mFunctionServer);

    50 }

    51 

    52 /*

    53  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

    54  * Method:    _createProvider

    55  * Signature: (J)I

    56  */

    57 JNIEXPORT jint

    58 JNICALL Java_com_nokia_mj_impl_location_LocationProviderImpl__1createProvider

    59 (JNIEnv*, jobject, jint aFunctionServerHandle)

    60 {

    61     JELOG2(EJavaLocation);

    62     LocationFunctionServer *server =

    63         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

    64 

    65     TInt handle(0);

    66 

    67     TRAPD(err, CLocationProvider::NewL(server, &handle));

    68 

    69     if (err != KErrNone)

    70     {

    71         return err;

    72     }

    73 

    74     return handle;

    75 }

    76 

    77 #ifdef RD_JAVA_PROXIMITY_LISTENER_ENABLED

    78 /*

    79  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

    80  * Method:    _createNativeProximityListener

    81  * Signature: (I)I

    82  */

    83 JNIEXPORT jint JNICALL

    84 Java_com_nokia_mj_impl_location_LocationProviderImpl__1createNativeProximityListener

    85 (JNIEnv * , jclass, jint aFunctionServerHandle)

    86 {

    87     JELOG2(EJavaLocation);

    88 

    89     LocationFunctionServer *server =

    90         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

    91 

    92     CProximityListener * self = KErrNone;

    93 

    94     TRAPD(error, self = CallMethodL(&CProximityListener::NewL, server, server));

    95 

    96     if (error < KErrNone)

    97     {

    98         return error;

    99     }

   100 

   101     return   reinterpret_cast<int>(self);

   102 }

   103 

   104 /*

   105  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   106  * Method:    _addProxmityListener

   107  * Signature: (IIDDFF)I

   108  */

   109 JNIEXPORT jint JNICALL

   110 Java_com_nokia_mj_impl_location_LocationProviderImpl__1addProxmityListener

   111 (JNIEnv* , jclass, jint aProximityNativeHandle, jint aFunctionServerHandle,

   112  jdouble aLat, jdouble aLon, jfloat aAlt, jfloat aProximityRadius)

   113 {

   114     JELOG2(EJavaLocation);

   115 

   116     LocationFunctionServer *server =

   117         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   118 

   119     CProximityListener *proximitylistener =

   120         reinterpret_cast<CProximityListener *>(aProximityNativeHandle);

   121 

   122 

   123     java::util::Monitor* proximityMonitor =

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

   125 

   126     TInt error = KErrNone;

   127     TInt TrigID = KErrNone;

   128 

   129     TRAP(error, CallMethodL(proximitylistener,

   130                             &CProximityListener::IntializeTriggerL,

   131                             aLat, aLon, aAlt, aProximityRadius,

   132                             proximityMonitor, server));

   133 

   134     if (error < KErrNone)

   135     {

   136         return error;

   137     }

   138 

   139     // Wait for the trigger to get created.

   140     proximityMonitor->wait();

   141 

   142     TRAPD(err, CallMethodL(TrigID, proximitylistener,

   143                            &CProximityListener::StartTriggerL,

   144                            server));

   145 

   146     if (err < KErrNone)

   147     {

   148         return err;

   149     }

   150 

   151     return TrigID;

   152 }

   153 

   154 /*

   155  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   156  * Method:    _isMonitoringNotActive

   157  * Signature: (I)Z

   158  */

   159 JNIEXPORT jboolean JNICALL

   160 Java_com_nokia_mj_impl_location_LocationProviderImpl__1isMonitoringNotActive

   161 (JNIEnv *, jclass, jint aProximityNativeHandle)

   162 {

   163     CProximityListener *proximitylistener =

   164         reinterpret_cast<CProximityListener *>(aProximityNativeHandle);

   165 

   166     return proximitylistener->iIsStatusNotActive;

   167 }

   168 

   169 /*

   170  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   171  * Method:    _deleteTrigger

   172  * Signature: (III)V

   173  */

   174 JNIEXPORT void JNICALL

   175 Java_com_nokia_mj_impl_location_LocationProviderImpl__1deleteTrigger

   176 (JNIEnv *, jclass, jint aFunctionServerHandle, jint aProximityNativeHandle,

   177  jint aTriggerID)

   178 {

   179     JELOG2(EJavaLocation);

   180 

   181     LocationFunctionServer *server =

   182         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   183 

   184     CProximityListener *proximitylistener =

   185         reinterpret_cast<CProximityListener *>(aProximityNativeHandle);

   186 

   187     TRAPD(error, CallMethodL(proximitylistener,

   188                              &CProximityListener::DeleteTriggerL,

   189                              aTriggerID, server));

   190 

   191     if (error < KErrNone)

   192     {

   193         ELOG1(EJavaLocation,

   194               "LocationProviderImpl__1deleteTrigger error = %d", error);

   195     }

   196 }

   197 

   198 LOCAL_C void

   199 DisposeProximityListenerObject(CProximityListener* aproximitylistener)

   200 {

   201     delete aproximitylistener;

   202 }

   203 

   204 /*

   205  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   206  * Method:    _disposeNativeProximityListener

   207  * Signature: (IIZ)V

   208  */

   209 JNIEXPORT void JNICALL

   210 Java_com_nokia_mj_impl_location_LocationProviderImpl__1disposeNativeProximityListener

   211 (JNIEnv *, jclass, jint aFunctionServerHandle, jint aProximityNativeHandle,

   212  jboolean aIsFuncSrvCont)

   213 {

   214     JELOG2(EJavaLocation);

   215 

   216     LocationFunctionServer *server =

   217         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   218 

   219     CProximityListener *proximitylistener =

   220         reinterpret_cast<CProximityListener *>(aProximityNativeHandle);

   221 

   222     if (aIsFuncSrvCont)

   223     {

   224         delete proximitylistener;

   225     }

   226     else

   227     {

   228         CallMethod(DisposeProximityListenerObject, proximitylistener, server);

   229     }

   230 }

   231 

   232 #endif

   233 

   234 /*

   235  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   236  * Method:    _selectModule

   237  * Signature: (JIIIIII[I)I

   238  */

   239 JNIEXPORT jint JNICALL

   240 Java_com_nokia_mj_impl_location_LocationProviderImpl__1selectModule

   241 (JNIEnv* aJni, jobject, jint aFunctionServerHandle, jint aHandle, jint aHacc,

   242  jint aVacc, jint aRespTime, jint aPower, jint aRequired,

   243  jintArray aMethodTimeout)

   244 {

   245     JELOG2(EJavaLocation);

   246     jint methodTimeout[2];

   247 

   248     LocationFunctionServer *server =

   249         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   250 

   251     CLocationProvider* locationProvider =

   252         reinterpret_cast<CLocationProvider *>(aHandle);

   253 

   254     TInt trackingPositionerHandle(0);

   255 

   256     TRAPD(err, CallMethodL(locationProvider, &CLocationProvider::SelectModuleL,

   257                            aHacc, aVacc, aRespTime, aPower, aRequired,

   258                            methodTimeout, server));

   259 

   260     trackingPositionerHandle =

   261         reinterpret_cast<TInt>(locationProvider->iTrackingPositioner);

   262 

   263     if (err != KErrNone)

   264     {

   265         return err;

   266     }

   267 

   268     aJni->SetIntArrayRegion(aMethodTimeout, 0, 2, methodTimeout);

   269 

   270     return trackingPositionerHandle;

   271 }

   272 

   273 LOCAL_C void DisposeObject(CLocationProvider* alocationProvider)

   274 {

   275     delete alocationProvider;

   276 }

   277 

   278 JNIEXPORT void JNICALL

   279 Java_com_nokia_mj_impl_location_LocationProviderImpl__1dispose

   280 (JNIEnv*, jobject, jint aFunctionServerHandle, jint aHandle)

   281 {

   282     JELOG2(EJavaLocation);

   283 

   284     LocationFunctionServer *server =

   285         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   286 

   287     CLocationProvider* locationProvider =

   288         reinterpret_cast<CLocationProvider *>(aHandle);

   289 

   290     CallMethod(DisposeObject, locationProvider, server);

   291 

   292     delete server;

   293 }

   294 

   295 /*

   296  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   297  * Method:    _getQualifiedCoordinates

   298  * Signature: (JI[D[F[Ljava/lang/String;)J

   299  */

   300 JNIEXPORT jlong JNICALL

   301 Java_com_nokia_mj_impl_location_LocationProviderImpl__1getQualifiedCoordinates

   302 (JNIEnv* aJni, jobject, jint aPositionerHandle, jdoubleArray aLatLon,

   303  jfloatArray aAltHaccVacc, jobjectArray aNmeaData)

   304 {

   305     JELOG2(EJavaLocation);

   306     jdouble latlon[2];

   307     jfloat altHaccVacc[3];

   308     jlong timestamp;

   309 

   310     CPositionerBase* positioner =

   311         reinterpret_cast<CPositionerBase *>(aPositionerHandle);;

   312 

   313     CPositionerBase::GetQualifiedCoordinates(positioner, aJni, latlon,

   314             altHaccVacc, &timestamp, aNmeaData);

   315 

   316     aJni->SetDoubleArrayRegion(aLatLon, 0, 2, latlon);

   317     aJni->SetFloatArrayRegion(aAltHaccVacc, 0, 3, altHaccVacc);

   318 

   319     return timestamp;

   320 }

   321 

   322 /*

   323  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   324  * Method:    _getSpeedAndCourse

   325  * Signature: (JI[F)Z

   326  */

   327 JNIEXPORT jboolean JNICALL

   328 Java_com_nokia_mj_impl_location_LocationProviderImpl__1getSpeedAndCourse

   329 (JNIEnv* aJni, jobject, jint aPositionerHandle, jfloatArray aSpeedCourse)

   330 {

   331     JELOG2(EJavaLocation);

   332     jfloat speedCourse[2];

   333 

   334     CPositionerBase* positioner =

   335         reinterpret_cast<CPositionerBase *>(aPositionerHandle);

   336 

   337     TInt err = CPositionerBase::GetSpeedAndCourse(positioner, speedCourse);

   338 

   339     if (err != KErrNone)

   340     {

   341         return JNI_FALSE;

   342     }

   343 

   344     aJni->SetFloatArrayRegion(aSpeedCourse, 0, 2, speedCourse);

   345 

   346     return JNI_TRUE;

   347 }

   348 

   349 /*

   350  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   351  * Method:    _startTracking

   352  * Signature: (JIIII)I

   353  */

   354 JNIEXPORT jint JNICALL

   355 Java_com_nokia_mj_impl_location_LocationProviderImpl__1startTracking

   356 (JNIEnv*, jobject, jint aFunctionServerHandle, jint aHandle, jint aInterval,

   357  jint aTimeout, jint aMaxAge)

   358 {

   359     JELOG2(EJavaLocation);

   360     LocationFunctionServer *server =

   361         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   362 

   363     CLocationProvider* locationProvider =

   364         reinterpret_cast<CLocationProvider *>(aHandle);

   365 

   366     TInt err = KErrNone;

   367 

   368     CallMethod(err, locationProvider->iTrackingPositioner,

   369                &CTrackingPositioner::StartTracking,

   370                aInterval,

   371                aTimeout,

   372                aMaxAge,

   373                server);

   374 

   375     return err;

   376 }

   377 

   378 /*

   379  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   380  * Method:    _stopTracking

   381  * Signature: (JI)V

   382  */

   383 JNIEXPORT void JNICALL

   384 Java_com_nokia_mj_impl_location_LocationProviderImpl__1stopTracking

   385 (JNIEnv*, jobject, jint aFunctionServerHandle, jint aHandle)

   386 {

   387     JELOG2(EJavaLocation);

   388     LocationFunctionServer *server =

   389         reinterpret_cast<LocationFunctionServer *>(aFunctionServerHandle);

   390 

   391     CLocationProvider* locationProvider =

   392         reinterpret_cast<CLocationProvider *>(aHandle);

   393 

   394     if (locationProvider->iTrackingPositioner)

   395     {

   396         CallMethod(locationProvider->iTrackingPositioner,

   397                    &CTrackingPositioner::StopTracking, server);

   398     }

   399 }

   400 

   401 /*

   402  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   403  * Method:    _getAddressInfo

   404  * Signature: (JI[Ljava/lang/String;)I

   405  */

   406 JNIEXPORT jint JNICALL

   407 Java_com_nokia_mj_impl_location_LocationProviderImpl__1getAddressInfo

   408 (JNIEnv* aJni, jobject, jint aPositionerHandle, jobjectArray aAddress)

   409 {

   410     JELOG2(EJavaLocation);

   411 

   412     CPositionerBase* positioner =

   413         reinterpret_cast<CPositionerBase *>(aPositionerHandle);

   414 

   415     TInt availableFields = CPositionerBase::GetAddressInfo(positioner,

   416                            aJni, aAddress);

   417 

   418     return availableFields;

   419 }

   420 

   421 /*

   422  * Class:     com_nokia_mj_impl_location_LocationProviderImpl

   423  * Method:    _getLastKnownLocation

   424  * Signature: ([D[F[J)I

   425  */

   426 JNIEXPORT jint JNICALL

   427 Java_com_nokia_mj_impl_location_LocationProviderImpl__1getLastKnownLocation

   428 (JNIEnv* aJni, jclass, jdoubleArray aLatLon, jfloatArray aAltHaccVacc,

   429  jlongArray aTimestamp)

   430 {

   431     JELOG2(EJavaLocation);

   432     jdouble latlon[2];

   433     jfloat altHaccVacc[3];

   434     jlong timestamp[1];

   435 

   436     RPositionServer server;

   437     TInt err = server.Connect();

   438     if (err != KErrNone)

   439     {

   440         return err;

   441     }

   442 

   443     RPositioner positioner;

   444     err = positioner.Open(server);

   445     if (err != KErrNone)

   446     {

   447         server.Close();

   448         return err;

   449     }

   450 

   451     _LIT(KService, "JavaVM");

   452     positioner.SetRequestor(CRequestor::ERequestorService,

   453                             CRequestor::EFormatApplication,

   454                             KService);

   455 

   456     TPositionInfo posInfo;

   457     TRequestStatus status;

   458     positioner.GetLastKnownPosition(posInfo, status);

   459     User::WaitForRequest(status);

   460     positioner.Close();

   461     server.Close();

   462 

   463     err = status.Int();

   464 

   465     if (err == KErrNone)

   466     {

   467         TPosition pos;

   468         posInfo.GetPosition(pos);

   469 

   470         latlon[0] = static_cast<jdouble>(pos.Latitude());

   471         latlon[1] = static_cast<jdouble>(pos.Longitude());

   472         altHaccVacc[0] = static_cast<jfloat>(pos.Altitude());

   473         altHaccVacc[1] = static_cast<jfloat>(pos.HorizontalAccuracy());

   474         altHaccVacc[2] = static_cast<jfloat>(pos.VerticalAccuracy());

   475 

   476         timestamp[0] = java::util::S60CommonUtils::TTimeToJavaTime(pos.Time());

   477 

   478         aJni->SetDoubleArrayRegion(aLatLon, 0, 2, latlon);

   479         aJni->SetFloatArrayRegion(aAltHaccVacc, 0, 3, altHaccVacc);

   480 

   481         aJni->SetLongArrayRegion(aTimestamp, 0, 1, timestamp);

   482     }

   483 

   484     return err;

   485 }

   486