1 /*

     2 * Copyright (c) 2005-2007 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:  TunerControl JNI wrapper.

    15  *

    16 */

    17 

    18 

    19 // EXTERNAL INCLUDES

    20 #include <jutils.h>

    21 

    22 // INTERNAL INCLUDES

    23 #include "com_nokia_amms_control_tuner_TunerControlImpl.h"

    24 #include <CMMAEventSource.h>

    25 #include "CAMMSTunerControl.h"

    26 

    27 /**

    28 * Static delegator function for getMinFreq

    29 */

    30 LOCAL_C void GetMinFreqL(CAMMSTunerControl* aNativeClass,

    31                          TInt *aMinFreq)

    32 {

    33 

    34     *aMinFreq = aNativeClass->MinFreqL();

    35 }

    36 

    37 /**

    38 *  getMinFreq JNI function

    39 */

    40 JNIEXPORT jint JNICALL

    41 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getMinFreq(

    42     JNIEnv* /*aJni*/,

    43     jobject /*aJobject*/,

    44     jint aEventSourceHandle,

    45     jint aTunerControlHandle)

    46 {

    47     TInt minFreq;

    48 

    49     CMMAEventSource* eventSource =

    50         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

    51 

    52     CAMMSTunerControl* nativeHandle =

    53         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

    54 

    55     TInt err = eventSource->ExecuteTrap(GetMinFreqL,

    56                                         nativeHandle,

    57                                         &minFreq);

    58 

    59     if (err != KErrNone)

    60     {

    61         return err;

    62     }

    63 

    64     return minFreq;

    65 }

    66 

    67 

    68 /**

    69 * Static delegator function for getMaxFreq

    70 */

    71 LOCAL_C void GetMaxFreqL(CAMMSTunerControl* aNativeClass,

    72                          TInt *aMaxFreq)

    73 {

    74 

    75     *aMaxFreq = aNativeClass->MaxFreqL();

    76 }

    77 

    78 /**

    79 *  getMaxFreq JNI function

    80 */

    81 JNIEXPORT jint JNICALL

    82 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getMaxFreq(

    83     JNIEnv* /*aJni*/,

    84     jobject /*aJobject*/,

    85     jint aEventSourceHandle,

    86     jint aTunerControlHandle)

    87 {

    88     TInt maxFreq;

    89 

    90     CMMAEventSource* eventSource =

    91         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

    92 

    93     CAMMSTunerControl* nativeHandle =

    94         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

    95 

    96     TInt err = eventSource->ExecuteTrap(GetMaxFreqL,

    97                                         nativeHandle,

    98                                         &maxFreq);

    99 

   100     if (err != KErrNone)

   101     {

   102         return err;

   103     }

   104 

   105     return maxFreq;

   106 }

   107 

   108 

   109 /**

   110 * Static delegator function for setFrequency

   111 */

   112 LOCAL_C void SetFreqL(CAMMSTunerControl* aNativeClass,

   113                       TInt aFreq)

   114 {

   115 

   116     aNativeClass->SetFrequencyL(aFreq);

   117 }

   118 

   119 /**

   120 * Static delegator function for getFrequency

   121 */

   122 LOCAL_C void GetFreqL(CAMMSTunerControl* aNativeClass,

   123                       TInt *aFreq)

   124 {

   125     *aFreq = aNativeClass->FrequencyL();

   126 }

   127 

   128 /**

   129 *  setFrequency JNI function

   130 */

   131 JNIEXPORT jint JNICALL

   132 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setFrequency(

   133     JNIEnv* /*aJni*/,

   134     jobject /*aJobject*/,

   135     jint aEventSourceHandle,

   136     jint aTunerControlHandle,

   137     jint aFreq)

   138 {

   139     CMMAEventSource* eventSource =

   140         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   141 

   142     CAMMSTunerControl* nativeHandle =

   143         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   144 

   145     TInt err = eventSource->ExecuteTrap(SetFreqL,

   146                                         nativeHandle,

   147                                         aFreq);

   148 

   149     if (err != KErrNone)

   150     {

   151         return err;

   152     }

   153 

   154     //get tuned frequency

   155     TInt tunedFreq;

   156     err = eventSource->ExecuteTrap(GetFreqL,

   157                                    nativeHandle,

   158                                    &tunedFreq);

   159     if (err != KErrNone)

   160     {

   161         return err;

   162     }

   163 

   164     return tunedFreq;

   165 }

   166 

   167 /**

   168 *  getFrequency JNI function

   169 */

   170 JNIEXPORT jint JNICALL

   171 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getFrequency(

   172     JNIEnv* /*aJni*/,

   173     jobject /*aJobject*/,

   174     jint aEventSourceHandle,

   175     jint aTunerControlHandle)

   176 {

   177     TInt freq;

   178 

   179     CMMAEventSource* eventSource =

   180         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   181 

   182     CAMMSTunerControl* nativeHandle =

   183         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   184 

   185     TInt err = eventSource->ExecuteTrap(GetFreqL,

   186                                         nativeHandle,

   187                                         &freq);

   188     if (err != KErrNone)

   189     {

   190         return err;

   191     }

   192 

   193     return freq;

   194 }

   195 

   196 

   197 /**

   198 * Static delegator function for seek

   199 */

   200 LOCAL_C void SeekL(CAMMSTunerControl* aNativeClass,

   201                    TInt aStartFreq,

   202                    TBool aUpwards,

   203                    TInt* aSeekedFreq)

   204 {

   205 

   206     *aSeekedFreq = aNativeClass->SeekL(aStartFreq, aUpwards);

   207 }

   208 

   209 /**

   210 *  seek JNI function

   211 */

   212 JNIEXPORT jint JNICALL

   213 Java_com_nokia_amms_control_tuner_TunerControlImpl__1seek(

   214     JNIEnv* /*aJni*/,

   215     jobject /*aJobject*/,

   216     jint aEventSourceHandle,

   217     jint aTunerControlHandle,

   218     jint aStartFreq,

   219     jboolean aUpwards)

   220 {

   221     TInt seekedFreq;

   222 

   223     CMMAEventSource* eventSource =

   224         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   225 

   226     CAMMSTunerControl* nativeHandle =

   227         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   228 

   229     TInt err = eventSource->ExecuteTrap(SeekL,

   230                                         nativeHandle,

   231                                         aStartFreq,

   232                                         (TBool) aUpwards,

   233                                         &seekedFreq);

   234 

   235     if (err != KErrNone)

   236     {

   237         return err;

   238     }

   239 

   240     return seekedFreq;

   241 }

   242 

   243 

   244 /**

   245 * Static delegator function for getSquelch

   246 */

   247 LOCAL_C void GetSquelchL(CAMMSTunerControl* aNativeClass,

   248                          TBool* aSquelch)

   249 {

   250 

   251     *aSquelch = aNativeClass->SquelchL();

   252 }

   253 

   254 /**

   255 *  getSquelch JNI function

   256 */

   257 JNIEXPORT jint JNICALL

   258 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getSquelch(

   259     JNIEnv* /*aJni*/,

   260     jobject /*aJobject*/,

   261     jint aEventSourceHandle,

   262     jint aTunerControlHandle)

   263 {

   264     CMMAEventSource* eventSource =

   265         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   266 

   267     CAMMSTunerControl* nativeHandle =

   268         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   269 

   270     TBool squelch = EFalse;

   271 

   272     TInt err = eventSource->ExecuteTrap(GetSquelchL,

   273                                         nativeHandle,

   274                                         &squelch);

   275 

   276     if (err != KErrNone)

   277     {

   278         return err;

   279     }

   280 

   281     if (!squelch)

   282     {

   283         //return 1 if false

   284         return 1;

   285     }

   286     //return 0 if true

   287     return KErrNone;

   288 }

   289 

   290 

   291 /**

   292 * Static delegator function for setSquelch

   293 */

   294 LOCAL_C void SetSquelchL(CAMMSTunerControl* aNativeClass,

   295                          TBool aSquelch)

   296 {

   297 

   298     aNativeClass->SetSquelchL(aSquelch);

   299 }

   300 

   301 /**

   302 *  setSquelch JNI function

   303 */

   304 JNIEXPORT jint JNICALL

   305 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setSquelch(

   306     JNIEnv* /*aJni*/,

   307     jobject /*aJobject*/,

   308     jint aEventSourceHandle,

   309     jint aTunerControlHandle,

   310     jboolean aSquelch)

   311 {

   312     CMMAEventSource* eventSource =

   313         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   314 

   315     CAMMSTunerControl* nativeHandle =

   316         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   317 

   318     TInt err = eventSource->ExecuteTrap(SetSquelchL,

   319                                         nativeHandle,

   320                                         (TBool) aSquelch);

   321 

   322     if (err != KErrNone)

   323     {

   324         return err;

   325     }

   326 

   327     return KErrNone;

   328 }

   329 

   330 

   331 /**

   332 * Static delegator function for getSignalStrength

   333 */

   334 LOCAL_C void GetSignalStrengthL(CAMMSTunerControl* aNativeClass,

   335                                 TInt *aSignalStrength)

   336 {

   337 

   338     *aSignalStrength = aNativeClass->SignalStrengthL();

   339 }

   340 

   341 /**

   342 *  getSignalStrength JNI function

   343 */

   344 JNIEXPORT jint JNICALL

   345 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getSignalStrength(

   346     JNIEnv* /*aJni*/,

   347     jobject /*aJobject*/,

   348     jint aEventSourceHandle,

   349     jint aTunerControlHandle)

   350 {

   351     TInt signalStrength;

   352 

   353     CMMAEventSource* eventSource =

   354         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   355 

   356     CAMMSTunerControl* nativeHandle =

   357         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   358 

   359     TInt err = eventSource->ExecuteTrap(GetSignalStrengthL,

   360                                         nativeHandle,

   361                                         &signalStrength);

   362     if (err != KErrNone)

   363     {

   364         return err;

   365     }

   366 

   367     return signalStrength;

   368 }

   369 

   370 

   371 /**

   372 * Static delegator function for getStereoMode

   373 */

   374 LOCAL_C void GetStereoModeL(CAMMSTunerControl* aNativeClass,

   375                             TInt *aStereoMode)

   376 {

   377 

   378     *aStereoMode = aNativeClass->StereoModeL();

   379 }

   380 

   381 /**

   382 *  getStereoMode JNI function

   383 */

   384 JNIEXPORT jint JNICALL

   385 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getStereoMode(

   386     JNIEnv* /*aJni*/,

   387     jobject /*aJobject*/,

   388     jint aEventSourceHandle,

   389     jint aTunerControlHandle)

   390 {

   391     TInt stereoMode;

   392 

   393     CMMAEventSource* eventSource =

   394         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   395 

   396     CAMMSTunerControl* nativeHandle =

   397         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   398 

   399     TInt err = eventSource->ExecuteTrap(GetStereoModeL,

   400                                         nativeHandle,

   401                                         &stereoMode);

   402     if (err != KErrNone)

   403     {

   404         return err;

   405     }

   406 

   407     return stereoMode;

   408 }

   409 

   410 

   411 /**

   412 * Static delegator function for setStereoMode

   413 */

   414 LOCAL_C void SetStereoModeL(CAMMSTunerControl* aNativeClass,

   415                             TInt aStereoMode)

   416 {

   417     aNativeClass->SetStereoModeL(aStereoMode);

   418 }

   419 

   420 /**

   421 *  setStereoMode JNI function

   422 */

   423 JNIEXPORT jint JNICALL

   424 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setStereoMode(

   425     JNIEnv* /*aJni*/,

   426     jobject /*aJobject*/,

   427     jint aEventSourceHandle,

   428     jint aTunerControlHandle,

   429     jint aStereoMode)

   430 {

   431     CMMAEventSource* eventSource =

   432         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   433 

   434     CAMMSTunerControl* nativeHandle =

   435         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   436 

   437     TInt err = eventSource->ExecuteTrap(SetStereoModeL,

   438                                         nativeHandle,

   439                                         aStereoMode);

   440 

   441     return err;

   442 }

   443 

   444 

   445 /**

   446 * Static delegator function for usePreset

   447 */

   448 LOCAL_C void UsePresetL(CAMMSTunerControl* aNativeClass,

   449                         TInt aPreset)

   450 {

   451     aNativeClass->UsePresetL(aPreset);

   452 }

   453 

   454 /**

   455 *  usePreset JNI function

   456 */

   457 JNIEXPORT jint JNICALL

   458 Java_com_nokia_amms_control_tuner_TunerControlImpl__1usePreset(

   459     JNIEnv* /*aJni*/,

   460     jobject /*aJobject*/,

   461     jint aEventSourceHandle,

   462     jint aTunerControlHandle,

   463     jint aPreset)

   464 {

   465     CMMAEventSource* eventSource =

   466         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   467 

   468     CAMMSTunerControl* nativeHandle =

   469         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   470 

   471     TInt err = eventSource->ExecuteTrap(UsePresetL,

   472                                         nativeHandle,

   473                                         aPreset);

   474 

   475     return err;

   476 }

   477 

   478 

   479 /**

   480 * Static delegator function for setPreset__III

   481 */

   482 LOCAL_C void SetPresetL(CAMMSTunerControl* aNativeClass,

   483                         TInt aPreset)

   484 {

   485     aNativeClass->SetPresetL(aPreset);

   486 }

   487 

   488 /**

   489 *  setPreset__III JNI function

   490 */

   491 JNIEXPORT jint JNICALL

   492 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setPreset__III(

   493     JNIEnv* /*aJni*/,

   494     jobject /*aJobject*/,

   495     jint aEventSourceHandle,

   496     jint aTunerControlHandle,

   497     jint aPreset)

   498 {

   499     CMMAEventSource* eventSource =

   500         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   501 

   502     CAMMSTunerControl* nativeHandle =

   503         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   504 

   505     TInt err = eventSource->ExecuteTrap(SetPresetL,

   506                                         nativeHandle,

   507                                         aPreset);

   508 

   509     return err;

   510 }

   511 

   512 

   513 /**

   514 * Static delegator function for setPreset__IIIII

   515 */

   516 LOCAL_C void SetPresetL(CAMMSTunerControl* aNativeClass,

   517                         TInt aPreset,

   518                         TInt aFrequency,

   519                         TInt aStereoMode)

   520 {

   521     aNativeClass->SetPresetL(aPreset, aFrequency, aStereoMode);

   522 }

   523 

   524 /**

   525 *  setPreset__IIIII JNI function

   526 */

   527 JNIEXPORT jint JNICALL

   528 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setPreset__IIIII(

   529     JNIEnv* /*aJni*/,

   530     jobject /*aJobject*/,

   531     jint aEventSourceHandle,

   532     jint aTunerControlHandle,

   533     jint aPreset,

   534     jint aFrequency,

   535     jint aStereoMode)

   536 {

   537     CMMAEventSource* eventSource =

   538         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   539 

   540     CAMMSTunerControl* nativeHandle =

   541         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   542 

   543     TInt err = eventSource->ExecuteTrap(SetPresetL,

   544                                         nativeHandle,

   545                                         aPreset,

   546                                         aFrequency,

   547                                         aStereoMode);

   548 

   549     return err;

   550 }

   551 

   552 

   553 /**

   554 * Static delegator function for getPresetFrequency

   555 */

   556 LOCAL_C void GetPresetFreqL(CAMMSTunerControl* aNativeClass,

   557                             TInt aPreset,

   558                             TInt *aPresetFreq)

   559 {

   560 

   561     *aPresetFreq = aNativeClass->PresetFrequencyL(aPreset);

   562 }

   563 

   564 /**

   565 *  getPresetFrequency JNI function

   566 */

   567 JNIEXPORT jint JNICALL

   568 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getPresetFrequency(

   569     JNIEnv* /*aJni*/,

   570     jobject /*aJobject*/,

   571     jint aEventSourceHandle,

   572     jint aTunerControlHandle,

   573     jint aPreset)

   574 {

   575     TInt presetFreq;

   576 

   577     CMMAEventSource* eventSource =

   578         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   579 

   580     CAMMSTunerControl* nativeHandle =

   581         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   582 

   583     TInt err = eventSource->ExecuteTrap(GetPresetFreqL,

   584                                         nativeHandle,

   585                                         aPreset,

   586                                         &presetFreq);

   587     if (err != KErrNone)

   588     {

   589         return err;

   590     }

   591 

   592     return presetFreq;

   593 }

   594 

   595 

   596 /**

   597 * Static delegator function for getPresetStereoMode

   598 */

   599 LOCAL_C void GetPresetStereoModeL(CAMMSTunerControl* aNativeClass,

   600                                   TInt aPreset,

   601                                   TInt *aPresetStereoMode)

   602 {

   603 

   604     *aPresetStereoMode = aNativeClass->PresetStereoModeL(aPreset);

   605 }

   606 

   607 /**

   608 *  getPresetStereoMode JNI function

   609 */

   610 JNIEXPORT jint JNICALL

   611 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getPresetStereoMode(

   612     JNIEnv* /*aJni*/,

   613     jobject /*aJobject*/,

   614     jint aEventSourceHandle,

   615     jint aTunerControlHandle,

   616     jint aPreset)

   617 {

   618     TInt presetStereoMode;

   619 

   620     CMMAEventSource* eventSource =

   621         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   622 

   623     CAMMSTunerControl* nativeHandle =

   624         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   625 

   626     TInt err = eventSource->ExecuteTrap(GetPresetStereoModeL,

   627                                         nativeHandle,

   628                                         aPreset,

   629                                         &presetStereoMode);

   630     if (err != KErrNone)

   631     {

   632         return err;

   633     }

   634 

   635     return presetStereoMode;

   636 }

   637 

   638 

   639 /**

   640 * Static delegator function for setPresetName

   641 */

   642 LOCAL_C void SetPresetNameL(CAMMSTunerControl* aNativeClass,

   643                             TInt aPreset,

   644                             const TDesC* aPresetName)

   645 {

   646     aNativeClass->SetPresetNameL(aPreset, aPresetName);

   647 }

   648 

   649 /**

   650 *  setPresetName JNI function

   651 */

   652 JNIEXPORT jint JNICALL

   653 Java_com_nokia_amms_control_tuner_TunerControlImpl__1setPresetName(

   654     JNIEnv* aJni,

   655     jobject /*aJobject*/,

   656     jint aEventSourceHandle,

   657     jint aTunerControlHandle,

   658     jint aPreset,

   659     jstring aPresetName)

   660 {

   661     CMMAEventSource* eventSource =

   662         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   663 

   664     CAMMSTunerControl* nativeHandle =

   665         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   666 

   667     RJString presetName(*aJni, aPresetName);

   668 

   669     TInt err = eventSource->ExecuteTrap(SetPresetNameL,

   670                                         nativeHandle,

   671                                         aPreset,

   672                                         (const TDesC*)&presetName);

   673 

   674     return err;

   675 }

   676 

   677 

   678 /**

   679 * Static delegator function for getPresetName

   680 */

   681 LOCAL_C void GetPresetNameL(CAMMSTunerControl* aNativeClass,

   682                             TInt aPreset,

   683                             TPtrC* aPresetName)

   684 {

   685     aNativeClass->GetPresetNameL(aPreset, aPresetName);

   686 }

   687 

   688 /**

   689 *  getPresetName JNI function

   690 */

   691 JNIEXPORT jstring JNICALL

   692 Java_com_nokia_amms_control_tuner_TunerControlImpl__1getPresetName(

   693     JNIEnv* aJni,

   694     jobject /*aJobject*/,

   695     jint aEventSourceHandle,

   696     jint aTunerControlHandle,

   697     jint aPreset,

   698     jintArray aError)

   699 {

   700     CMMAEventSource* eventSource =

   701         JavaUnhand<CMMAEventSource>(aEventSourceHandle);

   702 

   703     CAMMSTunerControl* nativeHandle =

   704         JavaUnhand<CAMMSTunerControl>(aTunerControlHandle);

   705 

   706     TPtrC presetNamePtr(NULL, 0);

   707     jstring presetName = NULL;

   708 

   709     TInt err = eventSource->ExecuteTrap(GetPresetNameL,

   710                                         nativeHandle,

   711                                         aPreset,

   712                                         &presetNamePtr);

   713 

   714     if (err == KErrNone)

   715     {

   716         presetName = CreateJavaString(*aJni, presetNamePtr);

   717         if (!presetName)

   718         {

   719             err = KErrNotSupported;

   720         }

   721     }

   722 

   723     jint javaErr[ 1 ] = { err };

   724     aJni->SetIntArrayRegion(aError, 0, 1, javaErr);

   725 

   726     return presetName;

   727 }

   728 

   729 // End of file