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:  PIMListImpl JNI wrapper.

    15  *

    16 */

    17 

    18 

    19 //  INCLUDE FILES

    20 

    21 #include "com_nokia_mj_impl_pim_PIMListImpl.h"

    22 #include "pimbaselist.h"

    23 #include "pimbaseitem.h"

    24 #include "pimcommon.h"

    25 #include "pimutils.h"

    26 #include "pimpanics.h"

    27 #include "cpimlist.h"

    28 #include "logger.h"

    29 #include "s60commonutils.h" // need to be removed once localisation is finalised

    30 

    31 //  CONSTANTS

    32 

    33 /**

    34  * Represents the type of label fetched from the framework. Used in

    35  * the common implementation of all three label getting operations.

    36  */

    37 enum TPIMLabelType

    38 {

    39     EPIMLabelTypeField = com_nokia_mj_impl_pim_PIMListImpl_LABEL_TYPE_FIELD,

    40 

    41     EPIMLabelTypeAttribute = com_nokia_mj_impl_pim_PIMListImpl_LABEL_TYPE_ATTRIBUTE,

    42 

    43     EPIMLabelTypeArrayElement = com_nokia_mj_impl_pim_PIMListImpl_LABEL_TYPE_ARRAY_ELEMENT

    44 };

    45 

    46 /**

    47  * Represents enumeration (item listing) type in different enumeration

    48  * operations.

    49  */

    50 enum TPIMEnumerationType

    51 {

    52     EPIMEnumerationTypeAll = com_nokia_mj_impl_pim_PIMListImpl_ENUMERATION_ITEMS_ALL,

    53 

    54     EPIMEnumerationTypeMatchingItem = com_nokia_mj_impl_pim_PIMListImpl_ENUMERATION_ITEMS_MATCHING_ITEM,

    55 

    56     EPIMEnumerationTypeMatchingString = com_nokia_mj_impl_pim_PIMListImpl_ENUMERATION_ITEMS_MATCHING_STRING,

    57 

    58     EPIMEnumerationTypeMatchingCategory = com_nokia_mj_impl_pim_PIMListImpl_ENUMERATION_ITEMS_MATCHING_CATEGORY

    59 };

    60 

    61 JNIEXPORT void

    62 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1dispose(

    63     JNIEnv* /*aJniEnv*/,

    64     jobject /*aPeer*/,

    65     jint aListHandle)

    66 {

    67     JELOG2(EPim);

    68     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

    69     delete list;

    70 }

    71 

    72 JNIEXPORT jint

    73 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1createItem(

    74     JNIEnv* aJniEnv,

    75     jobject /*aPeer*/,

    76     jint aListHandle,

    77     jintArray aError)

    78 {

    79     JELOG2(EPim);

    80     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

    81     pimbaseitem* item = NULL;

    82     int error = 0;

    83     try

    84     {

    85         item = list->createItem();

    86     }

    87     catch (int aErr)

    88     {

    89         error = aErr;

    90     }

    91     SetJavaErrorCode(aJniEnv, aError, error);

    92     // We now own the item (through the handle)

    93     return reinterpret_cast<int>(item);

    94 }

    95 

    96 JNIEXPORT jint

    97 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1removeItem(

    98     JNIEnv* /*aJniEnv*/,

    99     jobject /*aPeer*/,

   100     jint aListHandle,

   101     jint aItemHandle)

   102 {

   103     JELOG2(EPim);

   104     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   105     pimbaseitem* item = reinterpret_cast< pimbaseitem *>(aItemHandle);

   106     int error = 0;

   107     try

   108     {

   109         list->removeItem(item);

   110     }

   111     catch (int err)

   112     {

   113         error = err;

   114     }

   115     return error;

   116 }

   117 

   118 JNIEXPORT jint

   119 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1addCommittedItem(

   120     JNIEnv* /*aJniEnv*/,

   121     jobject /*aPeer*/,

   122     jint aListHandle,

   123     jint aItemHandle)

   124 {

   125     JELOG2(EPim);

   126     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   127     pimbaseitem* item = reinterpret_cast< pimbaseitem *>(aItemHandle);

   128     int error = 0;

   129     // Ownership of the item retains with the Java side peer item object.

   130     try

   131     {

   132         list->addCommittedItem(item);

   133     }

   134     catch (int err)

   135     {

   136         error = err;

   137     }

   138     return error;

   139 }

   140 

   141 JNIEXPORT jstring

   142 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getName(

   143     JNIEnv* aJniEnv,

   144     jobject /*aPeer*/,

   145     jint aListHandle)

   146 {

   147     JELOG2(EPim);

   148     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   149     jstring javaName = javaName =list->getName(aJniEnv);

   150     // We now own the name

   151     return javaName; // if NULL, it indicates error

   152 }

   153 

   154 JNIEXPORT jint

   155 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1close(

   156     JNIEnv* /*aJniEnv*/,

   157     jobject /*aPeer*/,

   158     jint aListHandle)

   159 {

   160     JELOG2(EPim);

   161     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   162     int error = 0;

   163     try

   164     {

   165         list->close();

   166     }

   167     catch (int aError)

   168     {

   169         error = aError;

   170     }

   171     return error;

   172 }

   173 

   174 JNIEXPORT jintArray

   175 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1items(

   176     JNIEnv* aJniEnv,

   177     jobject /*aPeer*/,

   178     jint aListHandle,

   179     jint aEnumerationType,

   180     jint aMatchingItemHandle,

   181     jstring aStringArg,

   182     jintArray aError)

   183 {

   184     JELOG2(EPim);

   185     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   186     int enumerationType;

   187     switch (aEnumerationType)

   188     {

   189     case EPIMEnumerationTypeAll:

   190         enumerationType = EPIMItemAll;

   191         break;

   192     case EPIMEnumerationTypeMatchingItem:

   193         enumerationType = EPIMItemMatchingItem;

   194         break;

   195     case EPIMEnumerationTypeMatchingString:

   196         enumerationType = EPIMItemMatchingString;

   197         break;

   198     case EPIMEnumerationTypeMatchingCategory:

   199         enumerationType = EPIMItemMatchingCategory;

   200         break;

   201     default:

   202         enumerationType = EPIMItemCorrupt;

   203     }

   204 

   205     jintArray itemHandles =list->callItemsByEnumerationType(

   206                                aJniEnv,

   207                                enumerationType,

   208                                aMatchingItemHandle,

   209                                aStringArg,

   210                                aError);

   211 

   212     return itemHandles;

   213 }

   214 

   215 JNIEXPORT jobjectArray

   216 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getCategories(

   217     JNIEnv* aJniEnv,

   218     jobject /*aPeer*/,

   219     jint aListHandle,

   220     jintArray aError)

   221 {

   222     JELOG2(EPim);

   223     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   224     jobjectArray javaCategories = list->getCategories(aJniEnv, aError);

   225     // Ownership of the categories is not transferred.

   226     return javaCategories;

   227 }

   228 

   229 JNIEXPORT jboolean

   230 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1isCategory(

   231     JNIEnv* aJniEnv,

   232     jobject /*aPeer*/,

   233     jint aListHandle,

   234     jstring aCategory,

   235     jintArray aError)

   236 {

   237     JELOG2(EPim);

   238     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   239 

   240     jboolean isCategory = list->isCategory(

   241                               aCategory, aJniEnv, aError);

   242     return isCategory;

   243 }

   244 

   245 JNIEXPORT void

   246 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1addCategory(

   247     JNIEnv* aJniEnv,

   248     jobject /*aPeer*/,

   249     jint aListHandle,

   250     jstring aCategory,

   251     jintArray aError)

   252 {

   253     JELOG2(EPim);

   254     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   255 

   256     list->addCategory(aCategory,aJniEnv,aError);

   257 }

   258 

   259 JNIEXPORT jintArray

   260 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1deleteCategory(

   261     JNIEnv* aJniEnv,

   262     jobject /*aPeer*/,

   263     jint aListHandle,

   264     jstring aCategory,

   265     jintArray aError)

   266 {

   267     JELOG2(EPim);

   268     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   269 

   270     jintArray itemHandles = list->deleteCategory(aCategory,aJniEnv, aError);

   271 

   272     return itemHandles;

   273 }

   274 

   275 JNIEXPORT jint

   276 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1renameCategory(

   277     JNIEnv* aJniEnv,

   278     jobject /*aPeer*/,

   279     jint aListHandle,

   280     jstring aCurrentCategory,

   281     jstring aNewCategory)

   282 {

   283     JELOG2(EPim);

   284     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   285 

   286     jint error = list->renameCategory(

   287                      aCurrentCategory, aNewCategory, aJniEnv);

   288 

   289     return error;

   290 }

   291 

   292 JNIEXPORT jint

   293 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1maxCategories(

   294     JNIEnv* /*aJniEnv*/,

   295     jobject /*aPeer*/,

   296     jint aListHandle)

   297 {

   298     JELOG2(EPim);

   299     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   300     jint maxCategories = list->maxCategories();

   301     return maxCategories;

   302 }

   303 

   304 JNIEXPORT jboolean

   305 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1isSupportedField(

   306     JNIEnv* /*aJniEnv*/,

   307     jobject /*aPeer*/,

   308     jint aListHandle,

   309     jint aField)

   310 {

   311     JELOG2(EPim);

   312     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   313     jboolean isSupportedField = isSupportedField = list->isSupportedField(aField);

   314     return isSupportedField;

   315 }

   316 

   317 JNIEXPORT jintArray

   318 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getSupportedFields(

   319     JNIEnv* aJniEnv,

   320     jobject /*aPeer*/,

   321     jint aListHandle)

   322 {

   323     JELOG2(EPim);

   324     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   325     jintArray javaFields = list->getSupportedFields(aJniEnv);

   326     return javaFields; // NULL indicates error

   327 }

   328 

   329 JNIEXPORT jboolean

   330 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1isSupportedAttribute(

   331     JNIEnv* /*aJniEnv*/,

   332     jobject /*aPeer*/,

   333     jint aListHandle,

   334     jint aField,

   335     jint aAttribute)

   336 {

   337     JELOG2(EPim);

   338     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   339     jboolean isSupportedAttribute = list->isSupportedAttribute(

   340                                         aField,

   341                                         aAttribute);

   342     return isSupportedAttribute;

   343 }

   344 

   345 JNIEXPORT jintArray

   346 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getSupportedAttributes(

   347     JNIEnv* aJniEnv,

   348     jobject /*aPeer*/,

   349     jint aListHandle,

   350     jint aField,

   351     jintArray aError)

   352 {

   353     JELOG2(EPim);

   354     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   355 

   356     jintArray javaAttributes = list->getSupportedAttributes(

   357                                    aField,

   358                                    aJniEnv,

   359                                    aError);

   360 

   361     return javaAttributes;

   362 }

   363 

   364 JNIEXPORT jboolean

   365 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1isSupportedArrayElement(

   366     JNIEnv* /*aJniEnv*/,

   367     jobject /*aPeer*/,

   368     jint aListHandle,

   369     jint aStringArrayField,

   370     jint aStringArrayElement)

   371 {

   372     JELOG2(EPim);

   373     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   374     jboolean isSupportedArrayElement = list->isSupportedArrayElement(

   375                                            aStringArrayField,

   376                                            aStringArrayElement);

   377 

   378     return isSupportedArrayElement;

   379 }

   380 

   381 JNIEXPORT jintArray

   382 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getSupportedArrayElements(

   383     JNIEnv* aJniEnv,

   384     jobject /*aPeer*/,

   385     jint aListHandle,

   386     jint aStringArrayField,

   387     jintArray aError)

   388 {

   389     JELOG2(EPim);

   390     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   391 

   392     jintArray javaElements = list->getSupportedArrayElements(

   393                                  aStringArrayField,

   394                                  aJniEnv,

   395                                  aError);

   396 

   397     return javaElements;

   398 }

   399 

   400 JNIEXPORT jint

   401 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getFieldDataType(

   402     JNIEnv* aJniEnv,

   403     jobject /*aPeer*/,

   404     jint aListHandle,

   405     jint aField,

   406     jintArray aError)

   407 {

   408     JELOG2(EPim);

   409     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   410     jint fieldDataType = list->getFieldDataType(

   411                              aField,

   412                              aJniEnv,

   413                              aError);

   414     return fieldDataType;

   415 }

   416 

   417 /**

   418  * Calls GetFieldLabelL, GetAttributeLabelL or GetArrayElementLabelL

   419  * as indicated by the aLabelType argument.

   420  *

   421  * @param aList The list to which the call is delegated.

   422  * @param aLabelType Label type (field, attribute, array element).

   423  * @param aLabelSpecElems Label specification elements which specify

   424  *        the requested label.

   425  * @param aLabelSpecLen Length of the label specification.

   426  * @param aRetVal The label. Ownership of the label is transferred to

   427  *        caller.

   428  */

   429 LOCAL_C void CallGetLabelL(CPIMList* aList, jint aLabelType,

   430                            jint* aLabelSpecElems, jint /*aLabelSpecLen*/, HBufC** aRetVal)

   431 {

   432     if (aLabelType == EPIMLabelTypeField)

   433     {

   434         *aRetVal = aList->GetFieldLabelL(aLabelSpecElems[0]); // field constant

   435     }

   436     else if (aLabelType == EPIMLabelTypeAttribute)

   437     {

   438         *aRetVal = aList->GetAttributeLabelL(aLabelSpecElems[0]); // attribute constant

   439     }

   440     else if (aLabelType == EPIMLabelTypeArrayElement)

   441     {

   442         *aRetVal = aList->GetArrayElementLabelL(aLabelSpecElems[0], // string array field constant

   443                                                 aLabelSpecElems[1]); // string array element constant

   444     }

   445     else

   446     {

   447         // We should never end up here

   448         User::Panic(KPIMPanicCategory, EPIMPanicInvalidState);

   449     }

   450 }

   451 

   452 JNIEXPORT jstring

   453 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1getLabel(

   454     JNIEnv* aJniEnv,

   455     jobject /*aPeer*/,

   456     jint aListHandle,

   457     jint aLabelType,

   458     jintArray aLabelSpec,

   459     jintArray aError)

   460 {

   461     JELOG2(EPim);

   462     pimbaselist* baseList = reinterpret_cast< pimbaselist*>(aListHandle);

   463     CPIMList* list = static_cast< CPIMList*>(baseList);

   464 

   465     TInt labelSpecLen = aJniEnv->GetArrayLength(aLabelSpec);

   466     jint* labelSpecElems = aJniEnv->GetIntArrayElements(aLabelSpec, NULL);

   467 

   468     if (!labelSpecElems)

   469     {

   470         SetJavaErrorCode(aJniEnv, aError, KErrNoMemory);

   471         return NULL;

   472     }

   473 

   474     HBufC* label = NULL;

   475 

   476     TInt error = 0;

   477     TRAP(error, CallGetLabelL(

   478              list,

   479              aLabelType,

   480              labelSpecElems,

   481              labelSpecLen,

   482              &label));

   483 

   484     SetJavaErrorCode(aJniEnv, aError, error);

   485     aJniEnv->ReleaseIntArrayElements(aLabelSpec, labelSpecElems, 0);

   486 

   487     // The label might be NULL on error

   488     if (error != KErrNone || !label)

   489     {

   490         return NULL;

   491     }

   492 

   493     // We now own the label

   494 

   495     jstring javaLabel = java::util::S60CommonUtils::NativeToJavaString(*aJniEnv, *label);

   496     delete label;

   497 

   498     if (!javaLabel)

   499     {

   500         SetJavaErrorCode(aJniEnv, aError, KErrNoMemory);

   501     }

   502 

   503     return javaLabel;

   504 }

   505 

   506 JNIEXPORT jint

   507 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1maxValues(

   508     JNIEnv* aJniEnv,

   509     jobject /*aPeer*/,

   510     jint aListHandle,

   511     jint aField,

   512     jintArray aError)

   513 {

   514     JELOG2(EPim);

   515     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   516     jint maxValues = list->maxValues(

   517                          aField,

   518                          aJniEnv,

   519                          aError);

   520 

   521     return maxValues;

   522 }

   523 

   524 JNIEXPORT jint

   525 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1stringArraySize(

   526     JNIEnv* aJniEnv,

   527     jobject /*aPeer*/,

   528     jint aListHandle,

   529     jint aStringArrayField,

   530     jintArray aError)

   531 {

   532     JELOG2(EPim);

   533     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   534 

   535     int stringArraySize = list->stringArraySize(

   536                               aStringArrayField,

   537                               aError,

   538                               aJniEnv);

   539 

   540     return stringArraySize;

   541 }

   542 

   543 /**

   544  * Calls CPIMList::UpdateListL() for given list and converts the

   545  * result into set of JNI handles.

   546  *

   547  * New handles are made and set for new items and the items are added

   548  * to the Event Source.

   549  *

   550  * @param aJniEnv JNIEnv for jintArray manipulation.

   551  * @param aList The list for which the update is called and the list

   552  *        of new and removed items is got.

   553  * @param aMatchingItem An item from which the initialized fields

   554  *        can be fetched and loaded from the database to all items

   555  * @param aNewAndRemovedItemHandles Pointer to a jintArray (pointer

   556  *        to a pointer) through which the resulting array of new

   557  *        and removed item handles are returned.

   558  *

   559  * @par Leaving:

   560  * @li Any - internal error.

   561  */

   562 

   563 JNIEXPORT jintArray

   564 JNICALL Java_com_nokia_mj_impl_pim_PIMListImpl__1updateList(

   565     JNIEnv* aJniEnv,

   566     jobject /*aPeer*/,

   567     jint aListHandle,

   568     jint aMatchingItemHandle,

   569     jintArray aError)

   570 {

   571     JELOG2(EPim);

   572     pimbaseitem* matchingItem = NULL;

   573     if (aMatchingItemHandle)

   574     {

   575         matchingItem = reinterpret_cast< pimbaseitem *>(aMatchingItemHandle);

   576     }

   577 

   578     pimbaselist* list = reinterpret_cast< pimbaselist*>(aListHandle);

   579     jintArray newAndRemovedItemHandles = NULL;

   580     try

   581     {

   582         newAndRemovedItemHandles = list->updateList(aJniEnv,

   583                                    matchingItem);

   584         SetJavaErrorCode(aJniEnv, aError, 0);

   585     }

   586     catch (int error)

   587     {

   588         SetJavaErrorCode(aJniEnv, aError, error);

   589     }

   590 

   591     return newAndRemovedItemHandles;

   592 }

   593 

   594 // End of File