diff -r e8e63152f320 -r 2a9601315dfc javaextensions/location/common/src/lapijnicommon.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/location/common/src/lapijnicommon.cpp Mon May 03 12:27:20 2010 +0300 @@ -0,0 +1,244 @@ +/* +* 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: Common JNI implementations + * +*/ + + +// INTERNAL INCLUDES +#include "lapijnicommon.h" +#include "clapilandmark.h" +#include "cleanupresetanddestroy.h" +#include "lapipanics.h" +#include "jstringutils.h" +#include "s60commonutils.h" +#include "logger.h" + +// EXTERNAL INCLUDES +#include + +// UNNAMED LOCAL NAMESPACE +namespace +{ +// Size of the coordinates array (latitude and longitude) +const TInt KLAPINumCoordinates = 2; +// Size of the coordinate information array (altitude, horizontal +// accuracy and vertical accuracy +const TInt KLAPINumCoordinateInfos = 3; +} + +/** + * Sets an error code to an error array + * @param aJniEnv Pointer to the JNI environment + * @param aTo The array to which the error is to be added + * @param aFrom The value which will be added to the array + */ +void SetJavaErrorCode(JNIEnv& aJniEnv, jintArray aTo, TInt aFrom) +{ + JELOG2(EJavaLocation); + jint javaError[1] = + { aFrom }; + aJniEnv.SetIntArrayRegion(aTo, 0, 1, javaError); +} + +/** + * Creates a position from the passed coordinate information + * @param aJniEnv A reference to the JNI environment + * @param aCoordinates Latitude and longitude values + * @param aCoordinateInfo Altitude, horizontal accuracy and vertical accurazy + */ +TLocality CreatePosition(JNIEnv& aJniEnv, jdoubleArray aCoordinates, + jfloatArray aCoordinateInfo) +{ + JELOG2(EJavaLocation); + __ASSERT_DEBUG(aCoordinates && aCoordinateInfo, LAPIError::Panic( + ELAPIPanicNullArgument)); + + jdouble dArray[KLAPINumCoordinates]; + jfloat fArray[KLAPINumCoordinateInfos]; + + // Get latitude and longitude + aJniEnv.GetDoubleArrayRegion(aCoordinates, 0, KLAPINumCoordinates, dArray); + // Get altitude, horizontal accuracy and vertical accuracy + aJniEnv.GetFloatArrayRegion(aCoordinateInfo, 0, KLAPINumCoordinateInfos, + fArray); + + TCoordinate coordinates(dArray[0], dArray[1], fArray[0]); + TLocality position(coordinates, fArray[1], fArray[2]); + return position; +} + +/** + * Creates a position information from the passed position + * @param aJniEnv A reference to the JNI environment + * @param aCoordinates Latitude and longitude values + * @param aCoordinateInfo Altitude, horizontal accuracy and vertical accurazy + */ +void CreateCoordinateInfos(JNIEnv& aJniEnv, const TLocality& aPosition, + jdoubleArray aCoordinates, jfloatArray aCoordinateInfo) +{ + JELOG2(EJavaLocation); + __ASSERT_DEBUG( + (aJniEnv.GetArrayLength(aCoordinates) >= KLAPINumCoordinates), + LAPIError::Panic(ELAPIPanicJniIncorrectArrayLength)); + __ASSERT_DEBUG((aJniEnv.GetArrayLength(aCoordinateInfo) + >= KLAPINumCoordinateInfos), LAPIError::Panic( + ELAPIPanicJniIncorrectArrayLength)); + + jdouble coordinates[KLAPINumCoordinates] = + { aPosition.Latitude(), aPosition.Longitude() }; + + jfloat coordinateInfo[KLAPINumCoordinateInfos] = + { aPosition.Altitude(), aPosition.HorizontalAccuracy(), + aPosition.VerticalAccuracy() + }; + + // Set coordinate values to the java array + aJniEnv.SetDoubleArrayRegion(aCoordinates, 0, KLAPINumCoordinates, + coordinates); + // Set coordinate information to the java array + aJniEnv.SetFloatArrayRegion(aCoordinateInfo, 0, KLAPINumCoordinateInfos, + coordinateInfo); +} + +/** + * Creates a new native string array from java string array + * @param aJniEnv A reference to the JNI environment + * @param aJavaArray The Java string array from which the new array is created + */ +RPointerArray CreateNativeStringArrayL(JNIEnv& aJniEnv, + jobjectArray aJavaArray) +{ + JELOG2(EJavaLocation); + TInt count = 0; + if (aJavaArray) + { + count = aJniEnv.GetArrayLength(aJavaArray); + } + // Create pointer array holding HBufCs so that null java elements + // can be represented as NULL pointers in the array + RPointerArray nativeArray(10); + CleanupResetAndDestroyPushL(nativeArray); + + for (TInt i = 0; i < count; i++) + { + // Creates a new local reference + jobject joe = aJniEnv.GetObjectArrayElement(aJavaArray, i); + jstring javaString = static_cast(joe); + if (!javaString) + { + nativeArray.AppendL(NULL); + } + else + { + // The value returned by GetObjectArrayElement is not really + // a pointer to the object, but it is a "local reference". + // In practice, it is a pointer to a pointer which points to the + // object. If the object is null, we get a pointer which points + // to a pointer which points to null. + TAny** objPointer = reinterpret_cast(joe); + TAny* obj = *objPointer; + if (!obj) + { + nativeArray.AppendL(NULL); + } + else + { + JStringUtils nativeElem(aJniEnv, javaString); + HBufC* element = nativeElem.AllocLC(); + nativeArray.AppendL(element); + CleanupStack::Pop(element); + } + } + // The VM runs out of temporary local references, unless the + // elements are not released here + aJniEnv.DeleteLocalRef(joe); + } + + CleanupStack::Pop(&nativeArray); + return nativeArray; +} + +/** + * Creates a new java string array from a native string array + * @param aJniEnv A reference to the JNI environment + * @param aNativeArray The native string array from which the new array is created + */ +jobjectArray CreateJavaStringArray(JNIEnv& aJniEnv, + RPointerArray& aNativeArray) +{ + JELOG2(EJavaLocation); + return java::util::S60CommonUtils::NativeToJavaStringArray(aJniEnv, + aNativeArray); +} + +jobjectArray CopyToNewJavaStringArrayL(JNIEnv& aJni, + const CDesCArray& aNativeArray) +{ + JELOG2(EJavaLocation); + jclass stringClass = aJni.FindClass("java/lang/String"); + User::LeaveIfNull(stringClass); + // + jobjectArray result = aJni.NewObjectArray(aNativeArray.Count(), + stringClass, NULL); + if (result != NULL) + { + TPtrC item; + for (int i = 0; i < aNativeArray.Count(); ++i) + { + item.Set(aNativeArray[i]); + jstring javaString = + java::util::S60CommonUtils::NativeToJavaString(aJni, item); + User::LeaveIfNull(javaString); + // + aJni.SetObjectArrayElement(result, i, javaString); + aJni.DeleteLocalRef(javaString); + } + } + return result; +} + +/** + * Creates an item handle array from the paased landmarks + * @param aJniEnv A reference to the JNI environment + * @param aLandmarks The landmarks from which the handles are created + * @return Java integer array. Ownership is transferred to the caller + */ +jintArray CreateHandleArray(JNIEnv& aJniEnv, + const CArrayPtr& aLandmarks) +{ + JELOG2(EJavaLocation); + TInt count = aLandmarks.Count(); + jintArray handles = aJniEnv.NewIntArray(count); + + if (handles && count > 0) + { + jint* elems = aJniEnv.GetIntArrayElements(handles, NULL); + if (!elems) + { + return NULL; // Error + } + // Make handles from the native side peer objects + for (TInt i = 0; i < count; i++) + { + elems[i] = reinterpret_cast(aLandmarks[i]); + } + // Elemenet must be released since it is local + aJniEnv.ReleaseIntArrayElements(handles, elems, 0); + } + + return handles; +} + +// End of file