1 /*
2 *
3 * Copyright 2001-2011 Texas Instruments, Inc. - http://www.ti.com/
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include "android_runtime/AndroidRuntime.h"
19 #include "jni.h"
20 #include "JNIHelp.h"
21 #include "v4l2_JbtlLog.h"
22
23
24 #define LOG_TAG "JFmRxNative"
25 #include <cutils/properties.h>
26
27 using namespace android;
28
29 extern "C" {
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <fcntl.h>
33 #include <asoundlib.h>
34 #include <linux/videodev.h>
35 #include <math.h>
36 #include <pthread.h>
37 #include <errno.h>
38 #include <string.h>
39 #include <poll.h>
40
41 #include "JFmRxNative.h"
42
43 /*Callback for FM commands*/
44 void nativeJFmRx_Callback(long context, int status,
45 int command, long value);
46
47 /*Callback for FM PS*/
48
49
50 void nativeJFmRx_PS_Callback(long context,int status, int freq,
51 int len,unsigned char * name,
52 int repertoire) ;
53
54 /*Callback for FM Radio Text*/
55
56 void nativeJFmRx_RadioText_Callback(int status, bool resetDisplay,
57 unsigned char * msg, int len, int startIndex,
58 int repertoire) ;
59 } //extern "C"
60
61 static JavaVM *g_jVM = NULL;
62 static jclass _sJClass;
63
64 typedef pthread_t THREAD_HANDLE;
65 THREAD_HANDLE p_threadHandle; /* Thread Handle for RDS data */
66 static bool isThreadCreated = false;
67 static int radio_fd;
68 //snd_ctl_t *fm_snd_ctrl;
69 long jContext;
70 volatile bool g_stopCommListener = false;
71
72 static int chanl_spacing=200000;
73
74 /* Complete parsing of the RDS data has not been implemented yet
75 Commented the FM RX RDS callbacks functionality start*/
76
77 #if 0
78 static jmethodID _sMethodId_nativeCb_fmRxRawRDS;
79 static jmethodID _sMethodId_nativeCb_fmRxPiCodeChanged;
80 static jmethodID _sMethodId_nativeCb_fmRxPtyCodeChanged;
81 static jmethodID _sMethodId_nativeCb_fmRxMonoStereoModeChanged;
82 static jmethodID _sMethodId_nativeCb_fmRxAudioPathChanged;
83 static jmethodID _sMethodId_nativeCb_fmRxAfSwitchFreqFailed;
84 static jmethodID _sMethodId_nativeCb_fmRxAfSwitchStart;
85 static jmethodID _sMethodId_nativeCb_fmRxAfSwitchComplete;
86 static jmethodID _sMethodId_nativeCb_fmRxAfListChanged;
87 static jmethodID _sMethodId_nativeCb_fmRxCompleteScanDone;
88 #endif
89
90 /*Commented the FM RX RDS callbacks functionality end*/
91
92
93 static jmethodID _sMethodId_nativeCb_fmRxPsChanged;
94 static jmethodID _sMethodId_nativeCb_fmRxRadioText;
95 static jmethodID _sMethodId_nativeCb_fmRxCmdEnable;
96 static jmethodID _sMethodId_nativeCb_fmRxCmdDisable;
97
98 static jmethodID _sMethodId_nativeCb_fmRxCmdEnableAudio;
99 static jmethodID _sMethodId_nativeCb_fmRxCmdChangeAudioTarget;
100 static jmethodID _sMethodId_nativeCb_fmRxCmdSetBand;
101 static jmethodID _sMethodId_nativeCb_fmRxCmdGetBand;
102 static jmethodID _sMethodId_nativeCb_fmRxCmdSetMonoStereoMode;
103 static jmethodID _sMethodId_nativeCb_fmRxCmdGetMonoStereoMode;
104 static jmethodID _sMethodId_nativeCb_fmRxCmdGetMuteMode;
105 static jmethodID _sMethodId_nativeCb_fmRxCmdSetMuteMode;
106 static jmethodID _sMethodId_nativeCb_fmRxCmdSetRfDependentMuteMode;
107 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRfDependentMuteMode;
108 static jmethodID _sMethodId_nativeCb_fmRxCmdSetRssiThreshhold;
109 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRssiThreshhold;
110 static jmethodID _sMethodId_nativeCb_fmRxCmdSetDeemphasisFilter;
111 static jmethodID _sMethodId_nativeCb_fmRxCmdGetDeemphasisFilter;
112 static jmethodID _sMethodId_nativeCb_fmRxCmdSetVolume;
113 static jmethodID _sMethodId_nativeCb_fmRxCmdGetVolume;
114 static jmethodID _sMethodId_nativeCb_fmRxCmdGetChannelSpacing;
115 static jmethodID _sMethodId_nativeCb_fmRxCmdSetChannelSpacing;
116 static jmethodID _sMethodId_nativeCb_fmRxCmdTune;
117 static jmethodID _sMethodId_nativeCb_fmRxCmdGetTunedFrequency;
118 static jmethodID _sMethodId_nativeCb_fmRxCmdSeek;
119 static jmethodID _sMethodId_nativeCb_fmRxCmdStopSeek;
120 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRssi;
121 static jmethodID _sMethodId_nativeCb_fmRxCmdEnableRds;
122 static jmethodID _sMethodId_nativeCb_fmRxCmdDisableRds;
123 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRdsSystem;
124 static jmethodID _sMethodId_nativeCb_fmRxCmdSetRdsSystem;
125 static jmethodID _sMethodId_nativeCb_fmRxCmdSetRdsGroupMask;
126 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRdsGroupMask;
127 static jmethodID _sMethodId_nativeCb_fmRxCmdSetRdsAfSwitchMode;
128 static jmethodID _sMethodId_nativeCb_fmRxCmdGetRdsAfSwitchMode;
129 static jmethodID _sMethodId_nativeCb_fmRxCmdDisableAudio;
130 static jmethodID _sMethodId_nativeCb_fmRxCmdDestroy;
131 static jmethodID _sMethodId_nativeCb_fmRxCmdChangeDigitalAudioConfiguration;
132 static jmethodID _sMethodId_nativeCb_fmRxCmdGetFwVersion;
133 static jmethodID _sMethodId_nativeCb_fmRxCmdIsValidChannel;
134 static jmethodID _sMethodId_nativeCb_fmRxCmdGetCompleteScanProgress;
135 static jmethodID _sMethodId_nativeCb_fmRxCmdStopCompleteScan;
136
137
138
139
140
rdsParseFunc_updateRepertoire(int byte1,int byte2)141 int rdsParseFunc_updateRepertoire(int byte1,int byte2)
142 {
143
144 int repertoire1,repertoire2;
145 int repertoire3,repertoire4;
146 int repertoire;
147
148 /*replace to nibble high/low*/
149 repertoire1 = (FMC_U8)(byte1&RDS_BIT_0_TO_BIT_3);
150 repertoire2 = (FMC_U8)((byte1&RDS_BIT_4_TO_BIT_7)>>4);
151 repertoire3 = (FMC_U8)(byte2&RDS_BIT_0_TO_BIT_3);
152 repertoire4 = (FMC_U8)((byte2&RDS_BIT_4_TO_BIT_7)>>4);
153
154 if((repertoire2==0)&&(repertoire1==15)&&(repertoire4==0)&&(repertoire3==15))
155 {
156 repertoire = FMC_RDS_REPERTOIRE_G0_CODE_TABLE;
157
158 }
159 else if((repertoire2==0)&&(repertoire1==14)&&(repertoire4==0)&&(repertoire3==14))
160 {
161 repertoire = FMC_RDS_REPERTOIRE_G1_CODE_TABLE;
162
163 }
164 else if ((repertoire2==1)&&(repertoire1==11)&&(repertoire4==6)&&(repertoire3==14))
165 {
166 repertoire = FMC_RDS_REPERTOIRE_G2_CODE_TABLE;
167
168 }
169
170 V4L2_JBTL_LOGD(" rdsParseFunc_updateRepertoire repertoire%d\n",repertoire);
171 return repertoire;
172 }
173
174
rds_decode(int blkno,int byte1,int byte2)175 void rds_decode(int blkno, int byte1, int byte2)
176 {
177 static unsigned char rds_psn[9];
178 static unsigned char rds_txt[65];
179 static int rds_pty,ms_code;
180 static int group,spare,blkc_byte1,blkc_byte2;
181 int len;
182 bool resetDisplay =false;
183 int status = 0,startIndex=0,repertoire,freq;
184
185 switch (blkno) {
186 case 0: /* Block A */
187 V4L2_JBTL_LOGD("block A - id=%d\n",(byte1 << 8) | byte2);
188 break;
189 case 1: /* Block B */
190 V4L2_JBTL_LOGD("block B - group=%d%c tp=%d pty=%d spare=%d\n",
191 (byte1 >> 4) & 0x0f,
192 ((byte1 >> 3) & 0x01) + 'A',
193 (byte1 >> 2) & 0x01,
194 ((byte1 << 3) & 0x18) | ((byte2 >> 5) & 0x07),
195 byte2 & 0x1f);
196 group = (byte1 >> 3) & 0x1f;
197 spare = byte2 & 0x1f;
198 rds_pty = ((byte1 << 3) & 0x18) | ((byte2 >> 5) & 0x07);
199 ms_code = (byte2 >> 3)& 0x1;
200
201 break;
202 case 2: /* Block C */
203 V4L2_JBTL_LOGD("block C - 0x%02x 0x%02x\n",byte1,byte2);
204 blkc_byte1 = byte1;
205 blkc_byte2 = byte2;
206 break;
207 case 3 : /* Block D */
208 V4L2_JBTL_LOGD("block D - 0x%02x 0x%02x\n",byte1,byte2);
209 switch (group) {
210 case 0: /* Group 0A */
211 rds_psn[2*(spare & 0x03)+0] = byte1;
212 rds_psn[2*(spare & 0x03)+1] = byte2;
213 if ((spare & 0x03) == 0x03)
214 {
215 V4L2_JBTL_LOGD("PSN: %s, PTY: %d, MS: %s\n",rds_psn,
216 rds_pty,ms_code?"Music":"Speech");
217
218 len = strlen((const char *)rds_psn);
219 V4L2_JBTL_LOGD("PS len %d",len);
220 nativeJFmRx_PS_Callback(jContext,status,freq,len,rds_psn,repertoire);
221 }
222
223 break;
224 case 4: /* Group 2A */
225
226 repertoire = rdsParseFunc_updateRepertoire(byte1,byte2);
227
228 repertoire =0;
229
230 V4L2_JBTL_LOGD("Radio repertoire: %d\n",repertoire);
231 rds_txt[4*(spare & 0x0f)+0] = blkc_byte1;
232 rds_txt[4*(spare & 0x0f)+1] = blkc_byte2;
233 rds_txt[4*(spare & 0x0f)+2] = byte1;
234 rds_txt[4*(spare & 0x0f)+3] = byte2;
235 /* Display radio text once we get 16 characters */
236 if (spare > 16)
237 {
238 len =strlen((const char *)rds_txt);
239
240 V4L2_JBTL_LOGD("RDS len %d",len);
241 V4L2_JBTL_LOGD("Radio Text: %s\n",rds_txt);
242
243 nativeJFmRx_RadioText_Callback(status, resetDisplay,
244 rds_txt, len, startIndex,repertoire) ;
245 }
246 break;
247 }
248 V4L2_JBTL_LOGD("----------------------------------------\n");
249 break;
250 default:
251 V4L2_JBTL_LOGD("unknown block [%d]\n",blkno);
252 }
253 }
254
255 /**
256 * Function: entryFunctionForRdsThread
257 * Brief: Creates a thread for waiting on responses from RDS .
258 * Description:
259 */
260
entryFunctionForRdsThread(void * data)261 void *entryFunctionForRdsThread(void *data)
262 {
263 unsigned char buf[600];
264 int radio_fd;
265 int ret,index;
266 struct pollfd pfd;
267
268 radio_fd = (int)data;
269
270 V4L2_JBTL_LOGD(" entryFunctionForRdsThread: Entering.g_stopCommListener %d \n",g_stopCommListener);
271
272 while(!g_stopCommListener)
273 {
274
275 V4L2_JBTL_LOGD("RDS thread running..\n");
276
277 while(1){
278 memset(&pfd, 0, sizeof(pfd));
279 pfd.fd = radio_fd;
280 pfd.events = POLLIN;
281 ret = poll(&pfd, 1, 10);
282 if (ret == 0){
283 /* Break the poll after RDS data available */
284 break;
285 }
286 }
287
288 ret = read(radio_fd,buf,500);
289 if(ret < 0)
290 { V4L2_JBTL_LOGD("NO RDS data to read..\n");
291 return NULL;
292 }
293
294 else if( ret > 0)
295 {
296
297 V4L2_JBTL_LOGD(" RDS data to read is available..\n");
298 for(index=0;index<ret;index+=3)
299 rds_decode(buf[index+2] & 0x7,buf[index+1],buf[index]);
300 }
301 }
302
303 V4L2_JBTL_LOGD("RDS thread exiting..\n");
304 return NULL;
305 }
306
fm_read_tuner_capabilities(int radio_fd)307 int fm_read_tuner_capabilities(int radio_fd)
308 {
309 struct v4l2_capability cap;
310 int res;
311
312 res = ioctl(radio_fd,VIDIOC_QUERYCAP,&cap);
313 if(res < 0)
314 {
315 V4L2_JBTL_LOGD("Failed to read %s capabilities\n",DEFAULT_RADIO_DEVICE);
316 return FM_FAILED;
317 }
318 if((cap.capabilities & V4L2_CAP_RADIO) == 0)
319 {
320 V4L2_JBTL_LOGD("%s is not radio devcie",DEFAULT_RADIO_DEVICE);
321 return FM_FAILED;
322 }
323 V4L2_JBTL_LOGD("\n***%s Info ****\n",DEFAULT_RADIO_DEVICE);
324 V4L2_JBTL_LOGD("Driver : %s\n",cap.driver);
325 V4L2_JBTL_LOGD("Card : %s\n",cap.card);
326 V4L2_JBTL_LOGD("Bus : %s\n",cap.bus_info);
327 V4L2_JBTL_LOGD("Capabilities : 0x%x\n",cap.capabilities);
328
329 return FM_SUCCESS;
330 }
331
332
nativeJFmRx_Create(JNIEnv * env,jobject obj,jobject jContextValue)333 static int nativeJFmRx_Create(JNIEnv *env,jobject obj,jobject jContextValue)
334 {
335
336 int fmStatus ;
337
338 V4L2_JBTL_LOGD("Java_JFmRx_nativeJFmRx_Create(): Entered");
339
340 radio_fd = open(DEFAULT_RADIO_DEVICE, O_RDWR);
341 if(radio_fd < 0)
342 {
343 V4L2_JBTL_LOGD("Unable to open %s ..\n",DEFAULT_RADIO_DEVICE);
344 jniThrowIOException(env, errno);
345 return FM_FAILED;
346 }
347
348 fmStatus = fm_read_tuner_capabilities(radio_fd);
349 if(fmStatus< 0)
350 {
351 close(radio_fd);
352 return fmStatus;
353 }
354
355 V4L2_JBTL_LOGD("nativeJFmRx_create:Exiting Successfully");
356
357 return fmStatus;
358 }
359
360
361
nativeJFmRx_Destroy(JNIEnv * env,jobject obj,jlong jContextValue)362 static int nativeJFmRx_Destroy(JNIEnv *env, jobject obj,jlong jContextValue)
363 {
364
365 V4L2_JBTL_LOGD("nativeJFmRx_destroy(): Entered");
366
367 V4L2_JBTL_LOGD("nativeJFmRx_destroy(): Exit");
368 return FM_SUCCESS;
369 }
370
371
372
nativeJFmRx_Enable(JNIEnv * env,jobject obj,jlong jContextValue)373 static int nativeJFmRx_Enable(JNIEnv *env, jobject obj, jlong jContextValue)
374 {
375
376 int status ;
377 struct v4l2_tuner vtun;
378
379 V4L2_JBTL_LOGD("nativeJFmRx_enable(): Entered");
380
381 jContext = jContextValue;
382
383 vtun.index = 0;
384 vtun.audmode = V4L2_TUNER_MODE_STEREO;
385 vtun.rxsubchans = V4L2_TUNER_SUB_RDS;
386
387 status = ioctl(radio_fd, VIDIOC_S_TUNER, &vtun);
388 if(status < 0)
389 {
390 V4L2_JBTL_LOGD("Failed to Enable FM\n");
391 return status;
392 }
393
394 V4L2_JBTL_LOGD("nativeJFmRx_enable: FM_RX_Enable() returned %d",(int)status);
395 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_ENABLE,status);
396 V4L2_JBTL_LOGD("nativeJFmRx_enable(): Exit");
397 return status;
398 }
399
400
401
nativeJFmRx_Disable(JNIEnv * env,jobject obj,jlong jContextValue)402 static int nativeJFmRx_Disable(JNIEnv *env, jobject obj, jlong jContextValue)
403 {
404 V4L2_JBTL_LOGD("nativeJFmRx_disable(): Entered");
405
406 // Terminate RDS thread
407 g_stopCommListener = true;
408 isThreadCreated = false;
409
410 close(radio_fd);
411 nativeJFmRx_Callback(jContext,0,FM_RX_CMD_DISABLE,0);
412
413 V4L2_JBTL_LOGD("nativeJFmRx_disable(): Exit");;
414 return FM_SUCCESS;
415 }
416
417
418
nativeJFmRx_SetBand(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmBand)419 static int nativeJFmRx_SetBand(JNIEnv *env, jobject obj,jlong jContextValue, jint jFmBand)
420 {
421 int status=0;
422 static unsigned char last_band = FM_BAND_EUROPE_US;
423 char curr_band;
424 int fd, res;
425
426 switch(jFmBand) {
427 case 1:
428 curr_band = '1';
429 break;
430 case 0:
431 default:
432 curr_band = '0';
433 break;
434 }
435
436 V4L2_JBTL_LOGD("nativeJFmRx_setBand(): EnteredjFmBand %d",jFmBand);
437 V4L2_JBTL_LOGD("nativeJFmRx_setBand(): curr_band %d last_band %d",curr_band,last_band);
438
439 fd = open(FM_BAND_SYSFS_ENTRY, O_RDWR);
440 if (fd < 0) {
441 V4L2_JBTL_LOGD("Can't open %s", FM_BAND_SYSFS_ENTRY);
442 return FM_FAILED;
443 }
444
445 res = write(fd, &curr_band, sizeof(char));
446 if(res <= 0){
447 V4L2_JBTL_LOGD("Failed to set FM Band\n");
448 return FM_FAILED;
449 }
450
451 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_SET_BAND,status);
452
453 V4L2_JBTL_LOGD("nativeJFmRx_setBand(): Exit");
454 return FM_PENDING;
455 }
456
457
nativeJFmRx_GetBand(JNIEnv * env,jobject obj,jlong jContextValue)458 static int nativeJFmRx_GetBand(JNIEnv *env, jobject obj,jlong jContextValue)
459 {
460
461 int status = 0;
462 unsigned char curr_band;
463
464 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_GET_BAND,curr_band);
465
466 V4L2_JBTL_LOGD("nativeJFmRx_getBand(): Exit");
467
468 return FM_PENDING;
469 }
470
471
nativeJFmRx_Tune(JNIEnv * env,jobject obj,jlong jContextValue,jint user_freq)472 static int nativeJFmRx_Tune(JNIEnv *env, jobject obj,jlong jContextValue,jint user_freq)
473 {
474 struct v4l2_frequency vf;
475 struct v4l2_tuner vt;
476 int status, div;
477
478 V4L2_JBTL_LOGD("nativeJFmRx_tune(): Entered");
479
480 vt.index = 0;
481 status = ioctl(radio_fd, VIDIOC_G_TUNER, &vt);
482 if(status < 0)
483 {
484 V4L2_JBTL_LOGD("Failed to get tuner capabilities\n");
485 return FM_FAILED;
486 }
487
488 vf.tuner = 0;
489 vf.frequency = rint(user_freq * 16 + 0.5);
490
491 div = (vt.capability & V4L2_TUNER_CAP_LOW) ? 1000 : 1;
492 if (div == 1)
493 vf.frequency /=1000;
494
495 status = ioctl(radio_fd, VIDIOC_S_FREQUENCY, &vf);
496 if(status < 0)
497 {
498 V4L2_JBTL_LOGD("Failed to tune to frequency %d\n",user_freq);
499 return FM_FAILED;
500 }
501 V4L2_JBTL_LOGD("Tuned to frequency %2.1f MHz\n",user_freq);
502
503 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_TUNE,user_freq);
504
505 V4L2_JBTL_LOGD("nativeJFmRx_Tune(): Exit");
506 return FM_PENDING;
507
508
509
510 }
511
512
nativeJFmRx_GetTunedFrequency(JNIEnv * env,jobject obj,jlong jContextValue)513 static int nativeJFmRx_GetTunedFrequency(JNIEnv *env, jobject obj,jlong jContextValue)
514 {
515 struct v4l2_frequency vf;
516 int status;
517 V4L2_JBTL_LOGD("nativeJFmRx_getTunedFrequency(): Entered");
518
519 status = ioctl(radio_fd, VIDIOC_G_FREQUENCY,&vf);
520 if(status < 0)
521 {
522 V4L2_JBTL_LOGD("Failed to read current frequency\n");
523 return FM_FAILED;
524 }
525
526 V4L2_JBTL_LOGD("Tuned to frequency %2.1f MHz \n",(float)vf.frequency/1000);
527 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_GET_TUNED_FREQUENCY,vf.frequency);
528
529 V4L2_JBTL_LOGD("nativeJFmRx_getTunedFrequency(): Exit");
530 return FM_PENDING;
531
532 }
533
534
535
nativeJFmRx_SetMonoStereoMode(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmMode)536 static int nativeJFmRx_SetMonoStereoMode(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmMode)
537 {
538
539 struct v4l2_tuner vt;
540 int status;
541 V4L2_JBTL_LOGD("nativeJFmRx_SetMonoStereoMode(): Entered");
542
543 vt.index = 0;
544 vt.audmode = jFmMode;
545
546 status = ioctl(radio_fd, VIDIOC_S_TUNER, &vt);
547 if (status < 0){
548 V4L2_JBTL_LOGD("Failed to set stereo/mono mode\n");
549 return FM_FAILED;
550 }
551
552 V4L2_JBTL_LOGD("Set to %d Mode\n",jFmMode);
553 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_MONO_STEREO_MODE,status);
554
555 V4L2_JBTL_LOGD("nativeJFmRx_SetMonoStereoMode(): Exit");
556 return FM_PENDING;
557 }
558
559
560
nativeJFmRx_GetMonoStereoMode(JNIEnv * env,jobject obj,jlong jContextValue)561 static int nativeJFmRx_GetMonoStereoMode(JNIEnv *env, jobject obj,jlong jContextValue)
562 {
563 struct v4l2_tuner vt;
564 int status;
565 unsigned char mode;
566
567 V4L2_JBTL_LOGD("nativeJFmRx_GetMonoStereoMode(): Entered");
568
569 vt.index = 0;
570 status = ioctl(radio_fd, VIDIOC_G_TUNER, &vt);
571 if (status < 0){
572 V4L2_JBTL_LOGD("Failed to get stereo/mono mode\n");
573 return FM_FAILED;
574 }
575 mode = vt.audmode;
576
577 V4L2_JBTL_LOGD("%d mode\n",mode);
578 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_MONO_STEREO_MODE,mode);
579
580 V4L2_JBTL_LOGD("nativeJFmRx_GetMonoStereoMode(): Exit");
581 return FM_PENDING ;
582 }
583
584
585
nativeJFmRx_SetMuteMode(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmMuteMode)586 static int nativeJFmRx_SetMuteMode(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmMuteMode)
587 {
588
589 struct v4l2_control vctrl;
590 int status;
591
592 V4L2_JBTL_LOGD("nativeJFmRx_setMuteMode(): Entered");
593
594 vctrl.id = V4L2_CID_AUDIO_MUTE;
595 vctrl.value = !jFmMuteMode; /* To Do:: Mapping in future for V4L2*/
596 status = ioctl(radio_fd,VIDIOC_S_CTRL,&vctrl);
597 if(status < 0)
598 {
599 V4L2_JBTL_LOGD("Failed to set mute mode\n");
600 return FM_FAILED;
601 }
602
603 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_MUTE_MODE,status);
604 V4L2_JBTL_LOGD("nativeJFmRx_setMuteMode(): Exit");
605 return FM_PENDING;
606
607
608 }
609
610
nativeJFmRx_GetMuteMode(JNIEnv * env,jobject obj,jlong jContextValue)611 static int nativeJFmRx_GetMuteMode(JNIEnv *env, jobject obj,jlong jContextValue)
612 {
613 struct v4l2_control vctrl;
614 int status;
615 V4L2_JBTL_LOGD("nativeJFmRx_getMuteMode(): Entered");
616 vctrl.id = V4L2_CID_AUDIO_MUTE;
617 status = ioctl(radio_fd,VIDIOC_G_CTRL,&vctrl);
618 if(status < 0)
619 {
620 V4L2_JBTL_LOGD("Failed to get mute mode\n");
621 return FM_FAILED;
622 }
623
624 V4L2_JBTL_LOGD("%d\n",vctrl.value);
625 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_MUTE_MODE,vctrl.value);
626
627 V4L2_JBTL_LOGD("nativeJFmRx_getMuteMode(): Exit");
628 return FM_PENDING;
629 }
630
631
nativeJFmRx_SetRssiThreshold(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmRssi)632 static int nativeJFmRx_SetRssiThreshold(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmRssi)
633 {
634
635 int status;
636 char rssi_lvl[10];
637 int fd, res;
638
639 V4L2_JBTL_LOGD("nativeJFmRx_setRssiThreshold(): Entered");
640
641 sprintf(rssi_lvl,"%d",jFmRssi);
642
643 V4L2_JBTL_LOGD("nativeJFmRx_setRssiThreshold(): val = %s", rssi_lvl);
644 ;
645 fd = open(FM_RSSI_LVL_SYSFS_ENTRY, O_RDWR);
646 if (fd < 0) {
647 V4L2_JBTL_LOGD("Can't open %s", FM_RSSI_LVL_SYSFS_ENTRY);
648 return FM_FAILED;
649 }
650
651 res = write(fd, &rssi_lvl, sizeof(char));
652 if(res <= 0){
653 V4L2_JBTL_LOGD("Failed to set FM RSSI level\n");
654 return FM_FAILED;
655 }
656
657 V4L2_JBTL_LOGD("Setting rssi to %d\n",jFmRssi);
658
659 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_RSSI_THRESHOLD,status);
660 V4L2_JBTL_LOGD("nativeJFmRx_setRssiThreshold(): Exit");
661
662 return FM_PENDING;
663 }
664
nativeJFmRx_GetRssiThreshold(JNIEnv * env,jobject obj,jlong jContextValue)665 static int nativeJFmRx_GetRssiThreshold(JNIEnv *env, jobject obj,jlong jContextValue)
666 {
667
668 short rssi_threshold;
669 int status;
670 V4L2_JBTL_LOGD("nativeJFmRx_getRssiThreshold(): Entered");
671
672 status = 0;
673
674 V4L2_JBTL_LOGD("RSSI threshold set to %d\n",rssi_threshold);
675 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RSSI_THRESHOLD,rssi_threshold);
676 V4L2_JBTL_LOGD("nativeJFmRx_getRssiThreshold(): Exit");
677 return FM_PENDING;
678 }
679
nativeJFmRx_GetRssi(JNIEnv * env,jobject obj,jlong jContextValue)680 static int nativeJFmRx_GetRssi(JNIEnv *env, jobject obj,jlong jContextValue)
681 {
682 int status;
683 short curr_rssi_lvl;
684
685 V4L2_JBTL_LOGD("nativeJFmRx_getRssi(): Entered");
686
687 status = 0;
688
689 V4L2_JBTL_LOGD("RSSI level is %d\n",curr_rssi_lvl);
690
691 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RSSI,curr_rssi_lvl);
692 V4L2_JBTL_LOGD("nativeJFmRx_getRssi(): Exit");
693 return FM_PENDING;;
694
695 }
696
nativeJFmRx_SetVolume(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmVolume)697 static int nativeJFmRx_SetVolume(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmVolume)
698 {
699 struct v4l2_control vctrl;
700 int status;
701
702 V4L2_JBTL_LOGD("nativeJFmRx_SetVolume(): Entered");
703
704 vctrl.id = V4L2_CID_AUDIO_VOLUME;
705 vctrl.value = jFmVolume;
706
707 status = ioctl(radio_fd,VIDIOC_S_CTRL,&vctrl);
708 if(status < 0)
709 {
710 V4L2_JBTL_LOGD("nativeJFmRx_SetVolume():Failed to set volume\n");
711 return status;
712 }
713 V4L2_JBTL_LOGD("nativeJFmRx_SetVolume():Setting volume to %d \n",jFmVolume);
714
715 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_VOLUME,status);
716
717 V4L2_JBTL_LOGD("nativeJFmRx_SetVolume(): Exit");
718 return FM_PENDING;
719
720
721 }
722
nativeJFmRx_GetVolume(JNIEnv * env,jobject obj,jlong jContextValue)723 static int nativeJFmRx_GetVolume(JNIEnv *env, jobject obj,jlong jContextValue)
724 {
725 struct v4l2_control vctrl;
726 int status;
727
728 V4L2_JBTL_LOGD("nativeJFmRx_getVolume(): Entered");
729
730
731 vctrl.id = V4L2_CID_AUDIO_VOLUME;
732 status = ioctl(radio_fd,VIDIOC_G_CTRL,&vctrl);
733 if(status < 0)
734 {
735 V4L2_JBTL_LOGD("Failed to get volume\n");
736 return status;
737 }
738
739 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_VOLUME,vctrl.value);
740 V4L2_JBTL_LOGD("nativeJFmRx_getVolume(): Exit");
741 return FM_PENDING;
742 }
743
nativeJFmRx_SetChannelSpacing(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmChannelSpacing)744 static int nativeJFmRx_SetChannelSpacing(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmChannelSpacing)
745 {
746
747 int status = 0;
748 ALOGD("nativeJFmRx_SetChannelSpacing(): Entered");
749
750 chanl_spacing = jFmChannelSpacing * 50000;
751
752 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_CHANNEL_SPACING,status);
753
754 ALOGD("nativeJFmRx_SetChannelSpacing(): Exit");
755 return FM_PENDING;
756
757 }
758
nativeJFmRx_GetChannelSpacing(JNIEnv * env,jobject obj,jlong jContextValue)759 static int nativeJFmRx_GetChannelSpacing(JNIEnv *env, jobject obj,jlong jContextValue)
760 {
761
762 int status =0;
763 ALOGD("nativeJFmRx_GetChannelSpacing(): Entered");
764
765 ALOGD("nativeJFmRx_GetChannelSpacing(): Exit");
766 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_CHANNEL_SPACING,status);
767 return FM_PENDING;
768 }
769
nativeJFmRx_SetDeEmphasisFilter(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmEmphasisFilter)770 static jint nativeJFmRx_SetDeEmphasisFilter(JNIEnv *env, jobject obj,jlong jContextValue,jint jFmEmphasisFilter)
771 {
772
773 int status;
774 V4L2_JBTL_LOGD("nativeJFmRx_SetDeEmphasisFilter(): Entered");
775
776 V4L2_JBTL_LOGD("1. nativeJFmRx_EnableRDS\n");
777 status = 0;
778
779 V4L2_JBTL_LOGD("Set to De-emphasis %d mode\n",jFmEmphasisFilter);
780 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_DEEMPHASIS_FILTER,status);
781 V4L2_JBTL_LOGD("nativeJFmRx_SetDeEmphasisFilter(): Exit");
782 V4L2_JBTL_LOGD("2. nativeJFmRx_EnableRDS\n");
783 return FM_PENDING;
784 }
785
786
nativeJFmRx_GetDeEmphasisFilter(JNIEnv * env,jobject obj,jlong jContextValue)787 static int nativeJFmRx_GetDeEmphasisFilter(JNIEnv *env, jobject obj,jlong jContextValue)
788 {
789
790 int status;
791 unsigned char mode;
792
793 V4L2_JBTL_LOGD("nativeJFmRx_GetDeEmphasisFilter(): Entered");
794
795 V4L2_JBTL_LOGD("1. nativeJFmRx_EnableRDS\n");
796 mode = 0;
797
798 V4L2_JBTL_LOGD("De-emphasis filter %d\n",mode);
799 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_DEEMPHASIS_FILTER,mode);
800
801 V4L2_JBTL_LOGD("nativeJFmRx_GetDeEmphasisFilter(): Exit");
802 V4L2_JBTL_LOGD("2. nativeJFmRx_EnableRDS\n");
803 return FM_PENDING;
804 }
805
806
807
nativeJFmRx_Seek(JNIEnv * env,jobject obj,jlong jContextValue,jint jdirection)808 static int nativeJFmRx_Seek(JNIEnv *env, jobject obj,jlong jContextValue,jint jdirection)
809 {
810
811 struct ti_v4l2_hw_freq_seek frq_seek;
812 struct v4l2_frequency vf;
813 struct v4l2_tuner vt;
814 int status, div;
815
816 V4L2_JBTL_LOGD("nativeJFmRx_Seek(): Entered");
817 V4L2_JBTL_LOGD("Seeking %s.. and channel spacing is %d\n",jdirection?"up":"down", chanl_spacing);
818 frq_seek.seek_upward = jdirection;
819 frq_seek.type = (v4l2_tuner_type)1;
820 frq_seek.spacing = chanl_spacing;
821 frq_seek.wrap_around = 0;
822
823 errno = 0;
824 status = ioctl(radio_fd,VIDIOC_S_HW_FREQ_SEEK,&frq_seek);
825 if(errno == EAGAIN)
826 {
827 V4L2_JBTL_LOGD("Band limit reached\n");
828 }
829 else if(status <0)
830 {
831 V4L2_JBTL_LOGD("Seek operation failed\n");
832 return status;
833 }
834
835 V4L2_JBTL_LOGD("nativeJFmRx_tune(): Entered");
836
837 vt.index = 0;
838 status = ioctl(radio_fd, VIDIOC_G_TUNER, &vt);
839 if(status < 0)
840 {
841 V4L2_JBTL_LOGD("Failed to get tuner capabilities\n");
842 return FM_FAILED;
843 }
844
845 div = (vt.capability & V4L2_TUNER_CAP_LOW) ? 1000 : 1;
846
847 status = ioctl(radio_fd, VIDIOC_G_FREQUENCY,&vf);
848 if(status < 0)
849 {
850 V4L2_JBTL_LOGD("Failed to read current frequency\n");
851 return status;
852 }
853
854 V4L2_JBTL_LOGD("Tuned to frequency %3.2f MHz \n",vf.frequency / (16.0 * div));
855
856 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SEEK,vf.frequency * 1000 / (16 * div));
857
858 V4L2_JBTL_LOGD("nativeJFmRx_Seek(): Exit");
859 return FM_PENDING;
860
861 }
862
863
nativeJFmRx_StopSeek(JNIEnv * env,jobject obj,jlong jContextValue)864 static int nativeJFmRx_StopSeek(JNIEnv *env, jobject obj,jlong jContextValue)
865 {
866 int status =0;
867 V4L2_JBTL_LOGD("nativeJFmRx_StopSeek(): Entered");
868 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_STOP_SEEK,status);
869 V4L2_JBTL_LOGD("nativeJFmRx_StopSeek(): Exit");
870 return FM_PENDING;
871 }
872
nativeJFmRx_EnableRDS(JNIEnv * env,jobject obj,jlong jContextValue)873 static int nativeJFmRx_EnableRDS(JNIEnv *env, jobject obj,jlong jContextValue)
874 {
875
876 int status;
877 unsigned char rds_mode = FM_RDS_ENABLE;
878 struct v4l2_tuner vt;
879
880 V4L2_JBTL_LOGD("nativeJFmRx_enableRDS(): Entered");
881
882 V4L2_JBTL_LOGD("1. nativeJFmRx_EnableRDS\n");
883 vt.index = 0;
884 status = ioctl(radio_fd, VIDIOC_G_TUNER, &vt);
885 if(status < 0)
886 {
887 V4L2_JBTL_LOGD("Failed to get tuner attributes\n");
888 return status;
889 }
890
891 V4L2_JBTL_LOGD("2. nativeJFmRx_EnableRDS\n");
892
893 if ((vt.rxsubchans & V4L2_TUNER_SUB_RDS) != 1)
894 vt.rxsubchans |= V4L2_TUNER_SUB_RDS;
895
896 status = ioctl(radio_fd, VIDIOC_S_TUNER, &vt);
897 if(status < 0)
898 {
899 V4L2_JBTL_LOGD("Failed to set RDS on/off status\n");
900 return status;
901 }
902
903 V4L2_JBTL_LOGD("3. nativeJFmRx_EnableRDS\n");
904 if(isThreadCreated == false)
905 {
906
907 V4L2_JBTL_LOGD(" nativeJFmRx_EnableRDS: creating thread !!! \n");
908 g_stopCommListener = false;
909 /* Create rds receive thread once */
910 status = pthread_create(&p_threadHandle, /* Thread Handle. */
911 NULL, /* Default Atributes. */
912 entryFunctionForRdsThread, /* Entry Function. */
913 (void *)radio_fd); /* Parameters. */
914 if (status < 0)
915 {
916 V4L2_JBTL_LOGD(" nativeJFmRx_EnableRDS: Thread Creation FAILED !!! \n");
917 return FM_ERR_THREAD_CREATION_FAILED;
918 }
919
920 isThreadCreated = true;
921 }
922 else
923 V4L2_JBTL_LOGD("RDS thread already created\n");
924
925 V4L2_JBTL_LOGD("4. nativeJFmRx_EnableRDS\n");
926 V4L2_JBTL_LOGD("RDS %d\n",rds_mode);
927
928 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_ENABLE_RDS,status);
929 V4L2_JBTL_LOGD("nativeJFmRx_enableRDS(): Exit");
930 return FM_PENDING;
931 }
932
nativeJFmRx_DisableRDS(JNIEnv * env,jobject obj,jlong jContextValue)933 static int nativeJFmRx_DisableRDS(JNIEnv *env, jobject obj,jlong jContextValue)
934 {
935
936 int status;
937 unsigned char rds_mode = FM_RDS_DISABLE;
938 struct v4l2_tuner vt;
939
940 V4L2_JBTL_LOGD("1. nativeJFmRx_DisableRDS\n");
941 vt.index = 0;
942 status = ioctl(radio_fd, VIDIOC_G_TUNER, &vt);
943 if(status < 0)
944 {
945 V4L2_JBTL_LOGD("Failed to get tuner attributes\n");
946 return status;
947 }
948
949 if(vt.rxsubchans & V4L2_TUNER_SUB_RDS)
950 vt.rxsubchans &= ~V4L2_TUNER_SUB_RDS;
951
952 V4L2_JBTL_LOGD("2. nativeJFmRx_DisableRDS and vt.rxsubchans = %d\n", vt.rxsubchans);
953
954 status = ioctl(radio_fd, VIDIOC_S_TUNER, &vt);
955 if(status < 0)
956 {
957 V4L2_JBTL_LOGD("Failed to set RDS on/off status\n");
958 return status;
959 }
960
961 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_DISABLE_RDS,status);
962
963 V4L2_JBTL_LOGD("nativeJFmRx_DisableRDS(): Exit");
964 return FM_PENDING;
965 }
966
nativeJFmRx_EnableAudioRouting(JNIEnv * env,jobject obj,jlong jContextValue)967 static int nativeJFmRx_EnableAudioRouting(JNIEnv *env, jobject obj,jlong jContextValue)
968 {
969 int status = 0 ;
970 V4L2_JBTL_LOGD("nativeJFmRx_enableAudioRouting(): Entered");
971
972 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_ENABLE_AUDIO,status);
973
974 V4L2_JBTL_LOGD("nativeJFmRx_enableAudioRouting(): Exit");
975 return FM_PENDING;
976 }
977
nativeJFmRx_DisableAudioRouting(JNIEnv * env,jobject obj,jlong jContextValue)978 static int nativeJFmRx_DisableAudioRouting(JNIEnv *env, jobject obj,jlong jContextValue)
979 {
980 int status = 0 ;
981 V4L2_JBTL_LOGD("nativeJFmRx_disableAudioRouting(): Entered");
982
983 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_ENABLE_AUDIO,status);
984
985 V4L2_JBTL_LOGD("nativeJFmRx_disableAudioRouting(): Exit");
986 return FM_PENDING;
987 }
988
nativeJFmRx_SetRdsAfSwitchMode(JNIEnv * env,jobject obj,jlong jContextValue,jint jRdsAfSwitchMode)989 static int nativeJFmRx_SetRdsAfSwitchMode(JNIEnv *env, jobject obj,jlong jContextValue,jint jRdsAfSwitchMode)
990 {
991
992 int status;
993 char af_switch;
994 int fd, res;
995
996 V4L2_JBTL_LOGD("nativeJFmRx_setRdsAfSwitchMode(): Entered");
997
998 switch(jRdsAfSwitchMode) {
999 case 1:
1000 af_switch = '1';
1001 break;
1002 case 0:
1003 default:
1004 af_switch = '0';
1005 break;
1006 }
1007
1008 fd = open(FM_RDS_AF_SYSFS_ENTRY, O_RDWR);
1009 if (fd < 0) {
1010 V4L2_JBTL_LOGD("Can't open %s", FM_RDS_AF_SYSFS_ENTRY);
1011 return FM_FAILED;
1012 }
1013
1014 res = write(fd, &af_switch, sizeof(char));
1015 if(res <= 0){
1016 V4L2_JBTL_LOGD("Failed to set FM AF Switch\n");
1017 return FM_FAILED;
1018 }
1019
1020
1021 V4L2_JBTL_LOGD("AF Switch %d ",jRdsAfSwitchMode);
1022
1023 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_RDS_AF_SWITCH_MODE,status);
1024 V4L2_JBTL_LOGD("nativeJFmRx_setRdsAfSwitchMode(): Exit");
1025 return FM_PENDING;
1026
1027 }
1028
nativeJFmRx_GetRdsAfSwitchMode(JNIEnv * env,jobject obj,jlong jContextValue)1029 static int nativeJFmRx_GetRdsAfSwitchMode(JNIEnv *env, jobject obj,jlong jContextValue)
1030 {
1031
1032 int status;
1033 unsigned char af_mode;
1034
1035
1036 V4L2_JBTL_LOGD("nativeJFmRx_getRdsAfSwitchMode(): Entered");
1037
1038 status = 0;
1039
1040 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RDS_AF_SWITCH_MODE,af_mode);
1041 V4L2_JBTL_LOGD("nativeJFmRx_getRdsAfSwitchMode(): Exit");
1042 return FM_PENDING;
1043 }
1044
nativeJFmRx_ChangeAudioTarget(JNIEnv * env,jobject obj,jlong jContextValue,jint jFmRxAudioTargetMask,jint digitalConfig)1045 static int nativeJFmRx_ChangeAudioTarget (JNIEnv *env, jobject obj,jlong jContextValue, jint jFmRxAudioTargetMask, jint digitalConfig)
1046 {
1047
1048 V4L2_JBTL_LOGD("nativeJFmRx_ChangeAudioTarget(): Entered");
1049 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_CHANGE_AUDIO_TARGET,status);
1050 V4L2_JBTL_LOGD("nativeJFmRx_ChangeAudioTarget(): Exit");
1051 return FM_PENDING;
1052
1053 }
1054
1055
nativeJFmRx_ChangeDigitalTargetConfiguration(JNIEnv * env,jobject obj,jlong jContextValue,jint digitalConfig)1056 static int nativeJFmRx_ChangeDigitalTargetConfiguration(JNIEnv *env, jobject obj,jlong jContextValue,jint digitalConfig)
1057 {
1058
1059 V4L2_JBTL_LOGD("nativeJFmRx_ChangeDigitalTargetConfiguration(): Entered");
1060
1061 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_CHANGE_DIGITAL_AUDIO_CONFIGURATION,status);
1062
1063 V4L2_JBTL_LOGD("nativeJFmRx_ChangeDigitalTargetConfiguration(): Exit");
1064 return FM_PENDING;
1065
1066 }
1067
1068
nativeJFmRx_SetRfDependentMuteMode(JNIEnv * env,jobject obj,jlong jContextValue,jint rf_mute)1069 static int nativeJFmRx_SetRfDependentMuteMode(JNIEnv *env, jobject obj,jlong jContextValue, jint rf_mute)
1070 {
1071
1072 int status;
1073 V4L2_JBTL_LOGD("nativeJFmRx_SetRfDependentMuteMode(): Entered");
1074
1075 status = 0;
1076
1077 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_RF_DEPENDENT_MUTE_MODE,status);
1078 V4L2_JBTL_LOGD("nativeJFmRx_SetRfDependentMuteMode(): Exit");
1079 return FM_PENDING;
1080
1081
1082
1083 }
1084
1085
nativeJFmRx_GetRfDependentMute(JNIEnv * env,jobject obj,jlong jContextValue)1086 static int nativeJFmRx_GetRfDependentMute(JNIEnv *env, jobject obj,jlong jContextValue)
1087 {
1088
1089 int status;
1090 unsigned char rf_mute;
1091 V4L2_JBTL_LOGD(" nativeJFmRx_GetRfDependentMute(): Entered");
1092
1093 status = 0;
1094
1095 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RF_DEPENDENT_MUTE_MODE,rf_mute);
1096 V4L2_JBTL_LOGD(" nativeJFmRx_GetRfDependentMute(): Exit");
1097 return FM_PENDING;
1098
1099 }
1100
1101
nativeJFmRx_SetRdsSystem(JNIEnv * env,jobject obj,jlong jContextValue,jint rdsSystem)1102 static int nativeJFmRx_SetRdsSystem(JNIEnv *env, jobject obj,jlong jContextValue, jint rdsSystem)
1103 {
1104 int status;
1105
1106 V4L2_JBTL_LOGD(" nativeJFmRx_SetRdsSystem(): Entered");
1107
1108 V4L2_JBTL_LOGD("entered to ELSE\n");
1109 status = 0;
1110
1111 V4L2_JBTL_LOGD("Set to %d\n",rdsSystem);
1112 nativeJFmRx_Callback(jContext,status,FM_RX_CMD_SET_RDS_SYSTEM,status);
1113 V4L2_JBTL_LOGD(" nativeJFmRx_SetRdsSystem(): Exit");
1114 return FM_PENDING;
1115
1116
1117
1118 }
1119
1120
nativeJFmRx_GetRdsSystem(JNIEnv * env,jobject obj,jlong jContextValue)1121 static int nativeJFmRx_GetRdsSystem(JNIEnv *env, jobject obj,jlong jContextValue)
1122 {
1123
1124 int status;
1125 unsigned char mode;
1126
1127 V4L2_JBTL_LOGD("nativeJFmRx_GetRdsSystem(): Entered");
1128
1129 status = 0;
1130
1131 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RDS_SYSTEM,mode);
1132 V4L2_JBTL_LOGD(" nativeJFmRx_GetRdsSystem(): Exit");
1133 return FM_PENDING;
1134
1135 }
1136
1137
nativeJFmRx_SetRdsGroupMask(JNIEnv * env,jobject obj,jlong jContextValue,jlong groupMask)1138 static int nativeJFmRx_SetRdsGroupMask(JNIEnv *env, jobject obj,jlong jContextValue, jlong groupMask)
1139 {
1140 int status =0;
1141 V4L2_JBTL_LOGD("nativeJFmRx_SetRdsGroupMask(): Entered");
1142
1143
1144 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_SET_RDS_GROUP_MASK,status);
1145 V4L2_JBTL_LOGD(" nativeJFmRx_SetRdsGroupMask(): Exit");
1146 return FM_PENDING;
1147
1148 }
1149
nativeJFmRx_GetRdsGroupMask(JNIEnv * env,jobject obj,jlong jContextValue)1150 static int nativeJFmRx_GetRdsGroupMask(JNIEnv *env, jobject obj,jlong jContextValue)
1151 {
1152 int status =0;
1153 V4L2_JBTL_LOGD("nativeJFmRx_GetRdsGroupMask(): Entered");
1154
1155
1156 nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_RDS_GROUP_MASK,status);
1157 V4L2_JBTL_LOGD(" nativeJFmRx_GetRdsGroupMask(): Exit");
1158 return FM_PENDING;
1159
1160 }
1161
nativeJFmRx_CompleteScan(JNIEnv * env,jobject obj,jlong jContextValue)1162 static int nativeJFmRx_CompleteScan(JNIEnv *env, jobject obj, jlong jContextValue)
1163 {
1164
1165 int status =0;
1166 ALOGD("nativeJFmRx_CompleteScan(): Entered");
1167
1168 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_COMPLETE_SCAN,status);
1169 ALOGD("nativeJFmRx_CompleteScan(): Exit");
1170 return FM_PENDING;
1171 }
1172
nativeJFmRx_GetCompleteScanProgress(JNIEnv * env,jobject obj,jlong jContextValue)1173 static int nativeJFmRx_GetCompleteScanProgress(JNIEnv *env, jobject obj, jlong jContextValue)
1174 {
1175 int status =0;
1176 ALOGD("nativeJFmRx_GetCompleteScanProgress(): Entered");
1177 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_COMPLETE_SCAN_PROGRESS,status);
1178
1179 ALOGD("nativeJFmRx_GetCompleteScanProgress(): Exit");
1180 return FM_PENDING;
1181 }
1182
nativeJFmRx_StopCompleteScan(JNIEnv * env,jobject obj,jlong jContextValue)1183 static int nativeJFmRx_StopCompleteScan(JNIEnv *env, jobject obj, jlong jContextValue)
1184 {
1185
1186 ALOGD("nativeJFmRx_StopCompleteScan(): Entered");
1187
1188 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_STOP_COMPLETE_SCAN,status);
1189 ALOGD("nativeJFmRx_StopCompleteScan(): Exit");
1190 return FM_PENDING;
1191 }
1192
nativeJFmRx_IsValidChannel(JNIEnv * env,jobject obj,jlong jContextValue)1193 static int nativeJFmRx_IsValidChannel(JNIEnv *env, jobject obj, jlong jContextValue)
1194 {
1195
1196
1197 ALOGD("nativeJFmRx_IsValidChannel(): Entered");
1198 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_IS_CHANNEL_VALID ,status);
1199 ALOGD("nativeJFmRx_IsValidChannel(): Exit");
1200 return FM_PENDING;
1201 }
1202
1203
nativeJFmRx_GetFwVersion(JNIEnv * env,jobject obj,jlong jContextValue)1204 static int nativeJFmRx_GetFwVersion(JNIEnv *env, jobject obj, jlong jContextValue)
1205 {
1206
1207 ALOGD("nativeJFmRx_GetFwVersion(): Entered");
1208 //nativeJFmRx_Callback(jContext,status, FM_RX_CMD_GET_FW_VERSION,status);
1209 ALOGD("nativeJFmRx_GetFwVersion(): Exit");
1210 return FM_PENDING;
1211 }
1212
1213
1214 //################################################################################
1215
1216 // SIGNALS
1217
1218 //###############################################################################
1219
1220 extern "C"
1221 {
1222
nativeJFmRx_RadioText_Callback(int status,bool resetDisplay,unsigned char * msg,int len,int startIndex,int repertoire)1223 void nativeJFmRx_RadioText_Callback(int status, bool resetDisplay,
1224 unsigned char * msg, int len, int startIndex,
1225 int repertoire)
1226 {
1227 ALOGE("nativeJFmRx_RadioText_Callback: Entering");
1228
1229 ALOGE("nativeJFmRx_RadioText_Callback: msg %s",msg);
1230 JNIEnv* env = NULL;
1231 bool attachedThread = false;
1232 int jRet ;
1233 jbyteArray jRadioTxtMsg = NULL;
1234
1235 /* check whether the current thread is attached to a virtual machine instance,
1236 if no only then try to attach to the current thread. */
1237 jRet = g_jVM->GetEnv((void **)&env,JNI_VERSION_1_4);
1238
1239 if(jRet < 0)
1240 {
1241 ALOGE("failed to get JNI env,assuming native thread");
1242 jRet = g_jVM->AttachCurrentThread((&env), NULL);
1243
1244 if(jRet != JNI_OK)
1245 {
1246 ALOGE("failed to atatch to current thread %d",jRet);
1247 return ;
1248 }
1249
1250 attachedThread = true;
1251 }
1252
1253
1254
1255
1256 if(env == NULL) {
1257 ALOGI("%s: Entered, env is null", __func__);
1258 } else {
1259 ALOGD("%s: jEnv %p", __func__, (void *)env);
1260 }
1261
1262
1263 V4L2_JBTL_LOGD("nativeJFmRx_Callback():EVENT --------------->FM_RX_EVENT_RADIO_TEXT");
1264 jRadioTxtMsg = env->NewByteArray(len);
1265 if (jRadioTxtMsg == NULL) {
1266 ALOGE("%s: Failed converting elements", __func__);
1267 goto CLEANUP;
1268 }
1269
1270 env->SetByteArrayRegion(jRadioTxtMsg,
1271 0,
1272 len,
1273 (jbyte*)msg);
1274
1275 if (env->ExceptionOccurred()) {
1276 ALOGE("%s: Calling nativeCb_fmRxRadioText failed",
1277 __func__);
1278 goto CLEANUP;
1279 }
1280
1281 env->CallStaticVoidMethod(_sJClass,
1282 _sMethodId_nativeCb_fmRxRadioText,(jlong)jContext,
1283 (jint)status,
1284 (jboolean)resetDisplay,
1285 jRadioTxtMsg,
1286 (jint)len,
1287 (jint)startIndex,
1288 (jint)repertoire);
1289
1290 if (env->ExceptionOccurred()) {
1291 ALOGE("nativeJFmRx_RadioText_Callback: ExceptionOccurred");
1292 goto CLEANUP;
1293 }
1294
1295 if(jRadioTxtMsg!= NULL)
1296 env->DeleteLocalRef(jRadioTxtMsg);
1297
1298 if(attachedThread == true)
1299 g_jVM->DetachCurrentThread();
1300
1301 return ;
1302
1303 CLEANUP:
1304 ALOGE("nativeJFmRx_RadioText_Callback: Exiting due to failure");
1305
1306 if(jRadioTxtMsg!= NULL)
1307 env->DeleteLocalRef(jRadioTxtMsg);
1308 if (env->ExceptionOccurred()) {
1309 env->ExceptionDescribe();
1310 env->ExceptionClear();
1311 }
1312
1313 if(attachedThread == true)
1314 g_jVM->DetachCurrentThread();
1315 return ;
1316 }
1317
1318
1319
1320
1321
nativeJFmRx_PS_Callback(long context,int status,int freq,int len,unsigned char * name,int repertoire)1322 void nativeJFmRx_PS_Callback(long context,int status, int freq,
1323 int len,unsigned char * name,
1324 int repertoire)
1325
1326 {
1327 ALOGE("nativeJFmRx_PS_Callback: Exiting due to failure");
1328 JNIEnv* env = NULL;
1329 bool attachedThread = false;
1330 int jRet ;
1331 jbyteArray jNameString = NULL;
1332 int frequency =0;
1333
1334 /* check whether the current thread is attached to a virtual machine instance,
1335 if no only then try to attach to the current thread. */
1336 jRet = g_jVM->GetEnv((void **)&env,JNI_VERSION_1_4);
1337
1338 if(jRet < 0)
1339 {
1340 ALOGE("failed to get JNI env,assuming native thread");
1341 jRet = g_jVM->AttachCurrentThread((&env), NULL);
1342
1343 if(jRet != JNI_OK)
1344 {
1345 ALOGE("failed to atatch to current thread %d",jRet);
1346 return ;
1347 }
1348
1349 attachedThread = true;
1350 }
1351
1352
1353
1354
1355 if(env == NULL) {
1356 ALOGI("%s: Entered, env is null", __func__);
1357 } else {
1358 ALOGD("%s: jEnv %p", __func__, (void *)env);
1359 }
1360
1361 V4L2_JBTL_LOGD("nativeJFmRx_PS_Callback():EVENT --------------->FM_RX_EVENT_PS_CHANGED len %d",len);
1362
1363
1364 jNameString = env->NewByteArray(len);
1365
1366 if (jNameString == NULL)
1367 {
1368 V4L2_JBTL_LOGD("nativeJFmRx_PS_Callback: Failed converting elements");
1369 goto CLEANUP;
1370 }
1371
1372 env->SetByteArrayRegion(jNameString,0,len,(jbyte*)name);
1373
1374 if (env->ExceptionOccurred()) {
1375 V4L2_JBTL_LOGD("nativeJFmRx_PS_Callback: Calling Java nativeCb_fmRxRadioText failed");
1376 goto CLEANUP;
1377 }
1378
1379 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxPsChanged,(jlong)context,
1380 (jint)status,
1381 (jint)frequency,
1382 jNameString,
1383 (jint)repertoire);
1384
1385
1386 if (env->ExceptionOccurred()) {
1387 ALOGE("nativeJFmRx_PS_Callback: ExceptionOccurred");
1388 goto CLEANUP;
1389 }
1390
1391 if(jNameString!= NULL)
1392 env->DeleteLocalRef(jNameString);
1393
1394 if(attachedThread == true)
1395 g_jVM->DetachCurrentThread();
1396
1397 return ;
1398
1399 CLEANUP:
1400 ALOGE("nativeJFmRx_PS_Callback: Exiting due to failure");
1401
1402 if(jNameString!= NULL)
1403 env->DeleteLocalRef(jNameString);
1404 if (env->ExceptionOccurred()) {
1405 env->ExceptionDescribe();
1406 env->ExceptionClear();
1407 }
1408
1409 if(attachedThread == true)
1410 g_jVM->DetachCurrentThread();
1411 return ;
1412 }
1413
1414
nativeJFmRx_Callback(long context,int status,int command,long value)1415 void nativeJFmRx_Callback(long context, int status,
1416 int command, long value)
1417 {
1418
1419 V4L2_JBTL_LOGI("nativeJFmRx_Callback: Entered, ");
1420
1421 JNIEnv* env = NULL;
1422 bool attachedThread = false;
1423 int jRet ;
1424
1425 /* check whether the current thread is attached to a virtual machine instance,
1426 if no only then try to attach to the current thread. */
1427
1428 jRet = g_jVM->GetEnv((void **)&env,JNI_VERSION_1_4);
1429
1430 if(jRet < 0)
1431 {
1432 V4L2_JBTL_LOGI("failed to get JNI env,assuming native thread");
1433 jRet = g_jVM->AttachCurrentThread((&env), NULL);
1434
1435 if(jRet != JNI_OK)
1436 {
1437 V4L2_JBTL_LOGI("failed to atatch to current thread %d",jRet);
1438 return ;
1439 }
1440
1441 attachedThread = true;
1442 }
1443
1444 if(env == NULL)
1445 {
1446 V4L2_JBTL_LOGD("nativeJFmRx_Callback: Entered, env is null");
1447 }
1448
1449
1450 switch (command)
1451 {
1452
1453 case FM_RX_CMD_ENABLE:
1454 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdEnable,(jlong)context,
1455 (jint)status,
1456 (jint)command,
1457 (jlong)value);
1458 break;
1459
1460 case FM_RX_CMD_DISABLE:
1461 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdDisable,(jlong)context,
1462 (jint)status,
1463 (jint)command,
1464 (jlong)value);
1465 break;
1466
1467 case FM_RX_CMD_SET_BAND:
1468 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetBand,(jlong)context,
1469 (jint)status,
1470 (jint)command,
1471 (jlong)value);
1472 break;
1473
1474 case FM_RX_CMD_GET_BAND:
1475 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetBand,(jlong)context,
1476 (jint)status,
1477 (jint)command,
1478 (jlong)value);
1479 break;
1480
1481 case FM_RX_CMD_SET_MONO_STEREO_MODE:
1482 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetMonoStereoMode,(jlong)context,
1483 (jint)status,
1484 (jint)command,
1485 (jlong)value);
1486 break;
1487
1488 case FM_RX_CMD_GET_MONO_STEREO_MODE:
1489 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetMonoStereoMode,(jlong)context,
1490 (jint)status,
1491 (jint)command,
1492 (jlong)value);
1493 break;
1494
1495 case FM_RX_CMD_SET_MUTE_MODE:
1496 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetMuteMode,(jlong)context,
1497 (jint)status,
1498 (jint)command,
1499 (jlong)value);
1500 break;
1501
1502 case FM_RX_CMD_GET_MUTE_MODE:
1503 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetMuteMode,(jlong)context,
1504 (jint)status,
1505 (jint)command,
1506 (jlong)value);
1507 break;
1508
1509 case FM_RX_CMD_SET_RF_DEPENDENT_MUTE_MODE:
1510 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetRfDependentMuteMode,(jlong)context,
1511 (jint)status,
1512 (jint)command,
1513 (jlong)value);
1514 break;
1515
1516 case FM_RX_CMD_GET_RF_DEPENDENT_MUTE_MODE:
1517 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRfDependentMuteMode,(jlong)context,
1518 (jint)status,
1519 (jint)command,
1520 (jlong)value);
1521 break;
1522
1523 case FM_RX_CMD_SET_RSSI_THRESHOLD:
1524 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetRssiThreshhold,(jlong)context,
1525 (jint)status,
1526 (jint)command,
1527 (jlong)value);
1528 break;
1529
1530 case FM_RX_CMD_GET_RSSI_THRESHOLD:
1531 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRssiThreshhold,(jlong)context,
1532 (jint)status,
1533 (jint)command,
1534 (jlong)value);
1535 break;
1536
1537 case FM_RX_CMD_SET_DEEMPHASIS_FILTER:
1538 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetDeemphasisFilter,(jlong)context,
1539 (jint)status,
1540 (jint)command,
1541 (jlong)value);
1542 break;
1543
1544 case FM_RX_CMD_GET_DEEMPHASIS_FILTER:
1545 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetDeemphasisFilter,(jlong)context,
1546 (jint)status,
1547 (jint)command,
1548 (jlong)value);
1549 break;
1550
1551 case FM_RX_CMD_SET_VOLUME:
1552 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetVolume,(jlong)context,
1553 (jint)status,
1554 (jint)command,
1555 (jlong)value);
1556 break;
1557
1558 case FM_RX_CMD_GET_VOLUME:
1559 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetVolume,(jlong)context,
1560 (jint)status,
1561 (jint)command,
1562 (jlong)value);
1563 break;
1564
1565 case FM_RX_CMD_TUNE:
1566 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdTune,(jlong)context,
1567 (jint)status,
1568 (jint)command,
1569 (jlong)value);
1570 break;
1571
1572 case FM_RX_CMD_GET_TUNED_FREQUENCY:
1573 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetTunedFrequency,(jlong)context,
1574 (jint)status,
1575 (jint)command,
1576 (jlong)value);
1577 break;
1578
1579 case FM_RX_CMD_SEEK:
1580 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSeek,(jlong)context,
1581 (jint)status,
1582 (jint)command,
1583 (jlong)value);
1584 break;
1585
1586 case FM_RX_CMD_STOP_SEEK:
1587 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdStopSeek,(jlong)context,
1588 (jint)status,
1589 (jint)command,
1590 (jlong)value);
1591 break;
1592
1593 case FM_RX_CMD_GET_RSSI:
1594 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRssi,(jlong)context,
1595 (jint)status,
1596 (jint)command,
1597 (jlong)value);
1598 break;
1599
1600 case FM_RX_CMD_ENABLE_RDS:
1601 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdEnableRds,(jlong)context,
1602 (jint)status,
1603 (jint)command,
1604 (jlong)value);
1605 break;
1606
1607 case FM_RX_CMD_DISABLE_RDS:
1608 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdDisableRds,(jlong)context,
1609 (jint)status,
1610 (jint)command,
1611 (jlong)value);
1612 break;
1613
1614 case FM_RX_CMD_SET_RDS_SYSTEM:
1615 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetRdsSystem,(jlong)context,
1616 (jint)status,
1617 (jint)command,
1618 (jlong)value);
1619 break;
1620
1621 case FM_RX_CMD_GET_RDS_SYSTEM:
1622 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRdsSystem,(jlong)context,
1623 (jint)status,
1624 (jint)command,
1625 (jlong)value);
1626 break;
1627
1628 case FM_RX_CMD_SET_RDS_GROUP_MASK:
1629 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetRdsGroupMask,(jlong)context,
1630 (jint)status,
1631 (jint)command,
1632 (jlong)value);
1633 break;
1634
1635 case FM_RX_CMD_GET_RDS_GROUP_MASK:
1636 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRdsGroupMask,(jlong)context,
1637 (jint)status,
1638 (jint)command,
1639 (jlong)value);
1640 break;
1641
1642 case FM_RX_CMD_SET_RDS_AF_SWITCH_MODE:
1643 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetRdsAfSwitchMode,(jlong)context,
1644 (jint)status,
1645 (jint)command,
1646 (jlong)value);
1647 break;
1648
1649 case FM_RX_CMD_GET_RDS_AF_SWITCH_MODE:
1650 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetRdsAfSwitchMode,(jlong)context,
1651 (jint)status,
1652 (jint)command,
1653 (jlong)value);
1654 break;
1655
1656 case FM_RX_CMD_ENABLE_AUDIO:
1657 V4L2_JBTL_LOGD("nativeJFmRx_Callback: at FM_RX_CMD_ENABLE_AUDIO step 1");
1658 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdEnableAudio,(jlong)context,
1659 (jint)status,
1660 (jint)command,
1661 (jlong)value);
1662 V4L2_JBTL_LOGD("nativeJFmRx_Callback: at FM_RX_CMD_ENABLE_AUDIO step 2");
1663 break;
1664
1665 case FM_RX_CMD_DISABLE_AUDIO:
1666 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdDisableAudio, (jlong)context,
1667 (jint)status,
1668 (jint)command,
1669 (jlong)value);
1670 break;
1671
1672 case FM_RX_CMD_CHANGE_AUDIO_TARGET:
1673 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdChangeAudioTarget,(jlong)context,
1674 (jint)status,
1675 (jint)command,
1676 (jlong)value);
1677 break;
1678
1679 case FM_RX_CMD_CHANGE_DIGITAL_AUDIO_CONFIGURATION:
1680 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdChangeDigitalAudioConfiguration,(jlong)context,
1681 (jint)status,
1682 (jint)command,
1683 (jlong)value);
1684 break;
1685
1686 case FM_RX_CMD_SET_CHANNEL_SPACING:
1687 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdSetChannelSpacing,(jlong)context,
1688 (jint)status,
1689 (jint)command,
1690 (jlong)value);
1691 break;
1692
1693 case FM_RX_CMD_GET_CHANNEL_SPACING:
1694 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetChannelSpacing,(jlong)context,
1695 (jint)status,
1696 (jint)command,
1697 (jlong)value);
1698 break;
1699
1700 case FM_RX_CMD_GET_FW_VERSION:
1701 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetFwVersion,(jlong)context,
1702 (jint)status,
1703 (jint)command,
1704 (jlong)value);
1705 break;
1706
1707 case FM_RX_CMD_IS_CHANNEL_VALID:
1708 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdIsValidChannel,(jlong)context,
1709 (jint)status,
1710 (jint)command,
1711 (jlong)value);
1712 break;
1713
1714 case FM_RX_CMD_COMPLETE_SCAN_PROGRESS:
1715 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdGetCompleteScanProgress,(jlong)context,
1716 (jint)status,
1717 (jint)command,
1718 (jlong)value);
1719 break;
1720
1721 case FM_RX_CMD_STOP_COMPLETE_SCAN:
1722 env->CallStaticVoidMethod(_sJClass,_sMethodId_nativeCb_fmRxCmdStopCompleteScan,(jlong)context,
1723 (jint)status,
1724 (jint)command,
1725 (jlong)value);
1726 break;
1727
1728 default:
1729 V4L2_JBTL_LOGD("nativeJFmRx_Callback:FM_RX_EVENT_CMD_DONE,unhendeld event");
1730 break;
1731 }
1732
1733 if (env->ExceptionOccurred()) {
1734 V4L2_JBTL_LOGD("nativeJFmRx_Callback: ExceptionOccurred");
1735 goto EXCEPTION;
1736 }
1737
1738 V4L2_JBTL_LOGD("nativeJFmRx_Callback: Exiting, Calling DetachCurrentThread at the END");
1739 if(attachedThread == true)
1740 g_jVM->DetachCurrentThread();
1741
1742 return;
1743
1744 EXCEPTION:
1745
1746 /*Delete Jni Local refrencece */
1747 V4L2_JBTL_LOGD("nativeJFmRx_Callback: Exiting due to failure");
1748 if (env->ExceptionOccurred()) {
1749 env->ExceptionDescribe();
1750 env->ExceptionClear();
1751 }
1752 if(attachedThread == true)
1753 g_jVM->DetachCurrentThread();
1754
1755 return;
1756
1757 }
1758
1759
1760 } //extern c
1761
1762
1763 /**********************************************************************
1764 * Callback registration
1765
1766 ***********************************************************************/
1767 #define VERIFY_METHOD_ID(methodId) \
1768 if (!_VerifyMethodId(methodId, #methodId)) { \
1769 V4L2_JBTL_LOGD("Error obtaining method id for %s", #methodId); \
1770 return; \
1771 }
1772
_VerifyMethodId(jmethodID methodId,const char * name)1773 static bool _VerifyMethodId(jmethodID methodId, const char *name)
1774 {
1775 bool result = true;
1776
1777 if (methodId == NULL)
1778 {
1779 V4L2_JBTL_LOGD("_VerifyMethodId: Failed getting method id of %s", name);
1780 result = false;
1781 }
1782
1783 return result;
1784 }
1785
1786
1787
nativeJFmRx_ClassInitNative(JNIEnv * env,jclass clazz)1788 void nativeJFmRx_ClassInitNative(JNIEnv* env, jclass clazz){
1789 V4L2_JBTL_LOGD("nativeJFmRx_ClassInitNative: Entered");
1790
1791 if (NULL == env)
1792 {
1793 V4L2_JBTL_LOGD("nativeJFmRx_ClassInitNative: NULL == env");
1794 }
1795
1796 env->GetJavaVM(&g_jVM);
1797
1798
1799
1800 /* Save class information in global reference in order to prevent class unloading */
1801 _sJClass = (jclass)env->NewGlobalRef(clazz);
1802
1803
1804 V4L2_JBTL_LOGI("nativeJFmRx_ClassInitNative: Obtaining method IDs");
1805
1806 _sMethodId_nativeCb_fmRxRadioText = env->GetStaticMethodID(clazz,
1807 "nativeCb_fmRxRadioText",
1808 "(JIZ[BIII)V");
1809 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxRadioText);
1810
1811
1812 _sMethodId_nativeCb_fmRxPsChanged = env->GetStaticMethodID(clazz,
1813 "nativeCb_fmRxPsChanged",
1814 "(JII[BI)V");
1815 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxPsChanged);
1816
1817 /* Complete parsing of the RDS data has not been implemented yet
1818 Commented the FM RX RDS callbacks functionality start*/
1819
1820 #if 0
1821 _sMethodId_nativeCb_fmRxRawRDS = env->GetStaticMethodID(clazz,
1822 "nativeCb_fmRxRawRDS",
1823 "(JII[B)V");
1824 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxRawRDS);
1825
1826
1827 _sMethodId_nativeCb_fmRxPiCodeChanged = env->GetStaticMethodID(clazz,
1828 "nativeCb_fmRxPiCodeChanged",
1829 "(JII)V");
1830 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxPiCodeChanged);
1831
1832
1833 _sMethodId_nativeCb_fmRxPtyCodeChanged = env->GetStaticMethodID(clazz,
1834 "nativeCb_fmRxPtyCodeChanged",
1835 "(JII)V");
1836 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxPtyCodeChanged);
1837
1838
1839
1840
1841 _sMethodId_nativeCb_fmRxMonoStereoModeChanged = env->GetStaticMethodID(clazz,
1842 "nativeCb_fmRxMonoStereoModeChanged",
1843 "(JII)V");
1844 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxMonoStereoModeChanged);
1845
1846
1847 _sMethodId_nativeCb_fmRxAudioPathChanged = env->GetStaticMethodID(clazz,
1848 "nativeCb_fmRxAudioPathChanged",
1849 "(JI)V");
1850 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxAudioPathChanged);
1851
1852
1853 _sMethodId_nativeCb_fmRxAfSwitchFreqFailed = env->GetStaticMethodID(clazz,
1854 "nativeCb_fmRxAfSwitchFreqFailed",
1855 "(JIIII)V");
1856 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxAfSwitchFreqFailed);
1857
1858
1859 _sMethodId_nativeCb_fmRxAfSwitchStart = env->GetStaticMethodID(clazz,
1860 "nativeCb_fmRxAfSwitchStart",
1861 "(JIIII)V");
1862 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxAfSwitchStart);
1863
1864
1865 _sMethodId_nativeCb_fmRxAfSwitchComplete = env->GetStaticMethodID(clazz,
1866 "nativeCb_fmRxAfSwitchComplete",
1867 "(JIIII)V");
1868 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxAfSwitchComplete);
1869
1870
1871 _sMethodId_nativeCb_fmRxAfListChanged = env->GetStaticMethodID(clazz,
1872 "nativeCb_fmRxAfListChanged",
1873 "(JII[BI)V");
1874 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxAfListChanged);
1875
1876 #endif
1877 /*Commented the FM RX RDS callbacks functionality end*/
1878
1879
1880 _sMethodId_nativeCb_fmRxCmdEnable = env->GetStaticMethodID(clazz,
1881 "nativeCb_fmRxCmdEnable",
1882 "(JIIJ)V");
1883 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdEnable);
1884
1885
1886 _sMethodId_nativeCb_fmRxCmdDisable = env->GetStaticMethodID(clazz,
1887 "nativeCb_fmRxCmdDisable",
1888 "(JIIJ)V");
1889 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdDisable);
1890
1891 _sMethodId_nativeCb_fmRxCmdEnableAudio = env->GetStaticMethodID(clazz,
1892 "nativeCb_fmRxCmdEnableAudio",
1893 "(JIIJ)V");
1894 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdEnableAudio);
1895
1896
1897
1898 _sMethodId_nativeCb_fmRxCmdChangeAudioTarget = env->GetStaticMethodID(clazz,
1899 "nativeCb_fmRxCmdChangeAudioTarget",
1900 "(JIIJ)V");
1901 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdChangeAudioTarget);
1902
1903
1904 _sMethodId_nativeCb_fmRxCmdSetBand = env->GetStaticMethodID(clazz,
1905 "nativeCb_fmRxCmdSetBand",
1906 "(JIIJ)V");
1907 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetBand);
1908
1909 _sMethodId_nativeCb_fmRxCmdGetBand = env->GetStaticMethodID(clazz,
1910 "nativeCb_fmRxCmdGetBand",
1911 "(JIIJ)V");
1912 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetBand);
1913
1914
1915
1916 _sMethodId_nativeCb_fmRxCmdSetMonoStereoMode = env->GetStaticMethodID(clazz,
1917 "nativeCb_fmRxCmdSetMonoStereoMode",
1918 "(JIIJ)V");
1919 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetMonoStereoMode);
1920
1921
1922
1923 _sMethodId_nativeCb_fmRxCmdGetMonoStereoMode = env->GetStaticMethodID(clazz,
1924 "nativeCb_fmRxCmdGetMonoStereoMode",
1925 "(JIIJ)V");
1926 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetMonoStereoMode);
1927
1928
1929
1930 _sMethodId_nativeCb_fmRxCmdGetMuteMode = env->GetStaticMethodID(clazz,
1931 "nativeCb_fmRxCmdGetMuteMode",
1932 "(JIIJ)V");
1933 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetMuteMode);
1934
1935
1936
1937 _sMethodId_nativeCb_fmRxCmdSetMuteMode = env->GetStaticMethodID(clazz,
1938 "nativeCb_fmRxCmdSetMuteMode",
1939 "(JIIJ)V");
1940 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetMuteMode);
1941
1942
1943
1944 _sMethodId_nativeCb_fmRxCmdSetRfDependentMuteMode = env->GetStaticMethodID(clazz,
1945 "nativeCb_fmRxCmdSetRfDependentMuteMode",
1946 "(JIIJ)V");
1947 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetRfDependentMuteMode);
1948
1949
1950
1951 _sMethodId_nativeCb_fmRxCmdGetRfDependentMuteMode = env->GetStaticMethodID(clazz,
1952 "nativeCb_fmRxCmdGetRfDependentMuteMode",
1953 "(JIIJ)V");
1954 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRfDependentMuteMode);
1955
1956
1957
1958 _sMethodId_nativeCb_fmRxCmdSetRssiThreshhold = env->GetStaticMethodID(clazz,
1959 "nativeCb_fmRxCmdSetRssiThreshhold",
1960 "(JIIJ)V");
1961 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetRssiThreshhold);
1962
1963
1964
1965 _sMethodId_nativeCb_fmRxCmdGetRssiThreshhold = env->GetStaticMethodID(clazz,
1966 "nativeCb_fmRxCmdGetRssiThreshhold",
1967 "(JIIJ)V");
1968 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRssiThreshhold);
1969
1970
1971
1972 _sMethodId_nativeCb_fmRxCmdSetDeemphasisFilter = env->GetStaticMethodID(clazz,
1973 "nativeCb_fmRxCmdSetDeemphasisFilter",
1974 "(JIIJ)V");
1975 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetDeemphasisFilter);
1976
1977
1978 _sMethodId_nativeCb_fmRxCmdGetDeemphasisFilter = env->GetStaticMethodID(clazz,
1979 "nativeCb_fmRxCmdGetDeemphasisFilter",
1980 "(JIIJ)V");
1981 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetDeemphasisFilter);
1982
1983
1984
1985 _sMethodId_nativeCb_fmRxCmdSetVolume = env->GetStaticMethodID(clazz,
1986 "nativeCb_fmRxCmdSetVolume",
1987 "(JIIJ)V");
1988 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetVolume);
1989
1990
1991
1992 _sMethodId_nativeCb_fmRxCmdGetVolume = env->GetStaticMethodID(clazz,
1993 "nativeCb_fmRxCmdGetVolume",
1994 "(JIIJ)V");
1995 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetVolume);
1996
1997 _sMethodId_nativeCb_fmRxCmdSetChannelSpacing = env->GetStaticMethodID(clazz,
1998 "nativeCb_fmRxCmdSetChannelSpacing",
1999 "(JIIJ)V");
2000 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetChannelSpacing);
2001
2002
2003
2004 _sMethodId_nativeCb_fmRxCmdGetChannelSpacing = env->GetStaticMethodID(clazz,
2005 "nativeCb_fmRxCmdGetChannelSpacing",
2006 "(JIIJ)V");
2007 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetChannelSpacing);
2008
2009
2010
2011 _sMethodId_nativeCb_fmRxCmdTune = env->GetStaticMethodID(clazz,
2012 "nativeCb_fmRxCmdTune",
2013 "(JIIJ)V");
2014 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdTune);
2015
2016
2017 _sMethodId_nativeCb_fmRxCmdGetTunedFrequency = env->GetStaticMethodID(clazz,
2018 "nativeCb_fmRxCmdGetTunedFrequency",
2019 "(JIIJ)V");
2020 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetTunedFrequency);
2021
2022
2023 _sMethodId_nativeCb_fmRxCmdSeek = env->GetStaticMethodID(clazz,
2024 "nativeCb_fmRxCmdSeek",
2025 "(JIIJ)V");
2026 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSeek);
2027
2028
2029
2030 _sMethodId_nativeCb_fmRxCmdStopSeek = env->GetStaticMethodID(clazz,
2031 "nativeCb_fmRxCmdStopSeek",
2032 "(JIIJ)V");
2033 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdStopSeek);
2034
2035
2036 _sMethodId_nativeCb_fmRxCmdGetRssi = env->GetStaticMethodID(clazz,
2037 "nativeCb_fmRxCmdGetRssi",
2038 "(JIIJ)V");
2039 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRssi);
2040
2041
2042 _sMethodId_nativeCb_fmRxCmdEnableRds = env->GetStaticMethodID(clazz,
2043 "nativeCb_fmRxCmdEnableRds",
2044 "(JIIJ)V");
2045 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdEnableRds);
2046
2047
2048 _sMethodId_nativeCb_fmRxCmdDisableRds = env->GetStaticMethodID(clazz,
2049 "nativeCb_fmRxCmdDisableRds",
2050 "(JIIJ)V");
2051 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdDisableRds);
2052
2053
2054 _sMethodId_nativeCb_fmRxCmdGetRdsSystem = env->GetStaticMethodID(clazz,
2055 "nativeCb_fmRxCmdGetRdsSystem",
2056 "(JIIJ)V");
2057 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRdsSystem);
2058
2059
2060
2061 _sMethodId_nativeCb_fmRxCmdSetRdsSystem = env->GetStaticMethodID(clazz,
2062 "nativeCb_fmRxCmdSetRdsSystem",
2063 "(JIIJ)V");
2064 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetRdsSystem);
2065
2066
2067 _sMethodId_nativeCb_fmRxCmdSetRdsGroupMask = env->GetStaticMethodID(clazz,
2068 "nativeCb_fmRxCmdSetRdsGroupMask",
2069 "(JIIJ)V");
2070 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetRdsGroupMask);
2071
2072
2073 _sMethodId_nativeCb_fmRxCmdGetRdsGroupMask = env->GetStaticMethodID(clazz,
2074 "nativeCb_fmRxCmdGetRdsGroupMask",
2075 "(JIIJ)V");
2076 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRdsGroupMask);
2077
2078
2079 _sMethodId_nativeCb_fmRxCmdSetRdsAfSwitchMode = env->GetStaticMethodID(clazz,
2080 "nativeCb_fmRxCmdSetRdsAfSwitchMode",
2081 "(JIIJ)V");
2082 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdSetRdsAfSwitchMode);
2083
2084
2085 _sMethodId_nativeCb_fmRxCmdGetRdsAfSwitchMode = env->GetStaticMethodID(clazz,
2086 "nativeCb_fmRxCmdGetRdsAfSwitchMode",
2087 "(JIIJ)V");
2088 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetRdsAfSwitchMode);
2089
2090
2091 _sMethodId_nativeCb_fmRxCmdDisableAudio = env->GetStaticMethodID(clazz,
2092 "nativeCb_fmRxCmdDisableAudio",
2093 "(JIIJ)V");
2094 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdDisableAudio);
2095
2096 _sMethodId_nativeCb_fmRxCmdDestroy = env->GetStaticMethodID(clazz,
2097 "nativeCb_fmRxCmdDestroy",
2098 "(JIIJ)V");
2099 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdDestroy);
2100
2101
2102 _sMethodId_nativeCb_fmRxCmdChangeDigitalAudioConfiguration= env->GetStaticMethodID(clazz,
2103 "nativeCb_fmRxCmdChangeDigitalAudioConfiguration",
2104 "(JIIJ)V");
2105 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdChangeDigitalAudioConfiguration);
2106
2107 /* Complete scan in V4l2 FM driver is not implemented yet
2108 Commented the FM RX Completescan functionality start*/
2109
2110 /*_sMethodId_nativeCb_fmRxCompleteScanDone = env->GetStaticMethodID(clazz,
2111 "nativeCb_fmRxCompleteScanDone",
2112 "(JII[I)V");
2113 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCompleteScanDone);*/
2114
2115 /*Commented the FM RX Completescan functionality end*/
2116
2117
2118 _sMethodId_nativeCb_fmRxCmdGetFwVersion = env->GetStaticMethodID(clazz,
2119 "nativeCb_fmRxCmdGetFwVersion",
2120 "(JIIJ)V");
2121 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetFwVersion);
2122
2123 _sMethodId_nativeCb_fmRxCmdIsValidChannel = env->GetStaticMethodID(clazz,
2124 "nativeCb_fmRxCmdIsValidChannel",
2125 "(JIIJ)V");
2126 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdIsValidChannel);
2127
2128
2129 _sMethodId_nativeCb_fmRxCmdGetCompleteScanProgress = env->GetStaticMethodID(clazz,
2130 "nativeCb_fmRxCmdGetCompleteScanProgress",
2131 "(JIIJ)V");
2132 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdGetCompleteScanProgress);
2133
2134 _sMethodId_nativeCb_fmRxCmdStopCompleteScan = env->GetStaticMethodID(clazz,
2135 "nativeCb_fmRxCmdStopCompleteScan",
2136 "(JIIJ)V");
2137 VERIFY_METHOD_ID(_sMethodId_nativeCb_fmRxCmdStopCompleteScan);
2138
2139 V4L2_JBTL_LOGD("nativeJFmRx_ClassInitNative:Exiting");
2140 }
2141
2142 static JNINativeMethod JFmRxNative_sMethods[] = {
2143 /* name, signature, funcPtr */
2144 {"nativeJFmRx_ClassInitNative", "()V", (void*)nativeJFmRx_ClassInitNative},
2145 {"nativeJFmRx_Create", "(Lcom/ti/jfm/core/JFmContext;)I", (void*)nativeJFmRx_Create},
2146 {"nativeJFmRx_Destroy", "(J)I", (void*)nativeJFmRx_Destroy},
2147 {"nativeJFmRx_Enable", "(J)I", (void*)nativeJFmRx_Enable},
2148 {"nativeJFmRx_Disable", "(J)I", (void*)nativeJFmRx_Disable},
2149 {"nativeJFmRx_SetBand","(JI)I", (void*)nativeJFmRx_SetBand},
2150 {"nativeJFmRx_GetBand","(J)I", (void*)nativeJFmRx_GetBand},
2151 {"nativeJFmRx_Tune","(JI)I", (void*)nativeJFmRx_Tune},
2152 {"nativeJFmRx_GetTunedFrequency","(J)I", (void*)nativeJFmRx_GetTunedFrequency},
2153 {"nativeJFmRx_SetMonoStereoMode","(JI)I", (void*)nativeJFmRx_SetMonoStereoMode},
2154 {"nativeJFmRx_GetMonoStereoMode","(J)I", (void*)nativeJFmRx_GetMonoStereoMode},
2155 {"nativeJFmRx_SetMuteMode","(JI)I", (void*)nativeJFmRx_SetMuteMode},
2156 {"nativeJFmRx_GetMuteMode","(J)I", (void*)nativeJFmRx_GetMuteMode},
2157 {"nativeJFmRx_SetRssiThreshold","(JI)I", (void*)nativeJFmRx_SetRssiThreshold},
2158 {"nativeJFmRx_GetRssiThreshold","(J)I", (void*)nativeJFmRx_GetRssiThreshold},
2159 {"nativeJFmRx_GetRssi","(J)I", (void*)nativeJFmRx_GetRssi},
2160 {"nativeJFmRx_SetVolume","(JI)I", (void*)nativeJFmRx_SetVolume},
2161 {"nativeJFmRx_GetVolume","(J)I", (void*)nativeJFmRx_GetVolume},
2162 {"nativeJFmRx_SetChannelSpacing","(JI)I", (void*)nativeJFmRx_SetChannelSpacing},
2163 {"nativeJFmRx_GetChannelSpacing","(J)I", (void*)nativeJFmRx_GetChannelSpacing},
2164 {"nativeJFmRx_SetDeEmphasisFilter","(JI)I", (void*)nativeJFmRx_SetDeEmphasisFilter},
2165 {"nativeJFmRx_GetDeEmphasisFilter","(J)I", (void*)nativeJFmRx_GetDeEmphasisFilter},
2166 {"nativeJFmRx_Seek","(JI)I", (void*)nativeJFmRx_Seek},
2167 {"nativeJFmRx_StopSeek","(J)I", (void*)nativeJFmRx_StopSeek},
2168 {"nativeJFmRx_EnableRDS","(J)I", (void*)nativeJFmRx_EnableRDS},
2169 {"nativeJFmRx_DisableRDS","(J)I", (void*)nativeJFmRx_DisableRDS},
2170 {"nativeJFmRx_EnableAudioRouting","(J)I", (void*)nativeJFmRx_EnableAudioRouting},
2171 {"nativeJFmRx_DisableAudioRouting","(J)I", (void*)nativeJFmRx_DisableAudioRouting},
2172 {"nativeJFmRx_SetRdsAfSwitchMode","(JI)I", (void*)nativeJFmRx_SetRdsAfSwitchMode},
2173 {"nativeJFmRx_GetRdsAfSwitchMode","(J)I", (void*)nativeJFmRx_GetRdsAfSwitchMode},
2174 {"nativeJFmRx_ChangeAudioTarget","(JII)I",(void*)nativeJFmRx_ChangeAudioTarget},
2175 {"nativeJFmRx_ChangeDigitalTargetConfiguration","(JI)I",(void*)nativeJFmRx_ChangeDigitalTargetConfiguration},
2176 {"nativeJFmRx_SetRfDependentMuteMode","(JI)I",(void*)nativeJFmRx_SetRfDependentMuteMode},
2177 {"nativeJFmRx_GetRfDependentMute","(J)I",(void*)nativeJFmRx_GetRfDependentMute},
2178 {"nativeJFmRx_SetRdsSystem","(JI)I",(void*)nativeJFmRx_SetRdsSystem},
2179 {"nativeJFmRx_GetRdsSystem","(J)I",(void*)nativeJFmRx_GetRdsSystem},
2180 {"nativeJFmRx_SetRdsGroupMask","(JJ)I",(void*)nativeJFmRx_SetRdsGroupMask},
2181 {"nativeJFmRx_GetRdsGroupMask","(J)I",(void*)nativeJFmRx_GetRdsGroupMask},
2182 {"nativeJFmRx_CompleteScan","(J)I",(void*)nativeJFmRx_CompleteScan},
2183 {"nativeJFmRx_IsValidChannel","(J)I",(void*)nativeJFmRx_IsValidChannel},
2184 {"nativeJFmRx_GetFwVersion","(J)I",(void*)nativeJFmRx_GetFwVersion},
2185 {"nativeJFmRx_GetCompleteScanProgress","(J)I",(void*)nativeJFmRx_GetCompleteScanProgress},
2186 {"nativeJFmRx_StopCompleteScan","(J)I",(void*)nativeJFmRx_StopCompleteScan},
2187
2188 };
2189
2190 /**********************************/
2191
2192
2193 /*
2194 * Register several native methods for one class.
2195 */
registerNatives(JNIEnv * env,const char * className,JNINativeMethod * gMethods,int numMethods)2196 static int registerNatives(JNIEnv* env, const char* className,
2197 JNINativeMethod* gMethods, int numMethods)
2198 {
2199 jclass clazz;
2200
2201 clazz = env->FindClass(className);
2202 if (clazz == NULL) {
2203 V4L2_JBTL_LOGD("Can not find class %s\n", className);
2204 return JNI_FALSE;
2205 }
2206
2207 if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
2208 V4L2_JBTL_LOGD("Can not RegisterNatives\n");
2209 return JNI_FALSE;
2210 }
2211
2212 return JNI_TRUE;
2213 }
2214
2215 /*Commented the FM TX functionality start*/
2216
2217 extern JNINativeMethod JFmTxNative_sMethods[];
2218 extern int getTxNativeSize();
2219
2220 /*Commented the FM TX functionality end*/
2221
JNI_OnLoad(JavaVM * vm,void * reserved)2222 jint JNI_OnLoad(JavaVM* vm, void* reserved)
2223 {
2224 JNIEnv* env = NULL;
2225 jint result = -1;
2226
2227 V4L2_JBTL_LOGD("OnLoad");
2228
2229 if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
2230 goto bail;
2231 }
2232
2233 if (!registerNatives(env,
2234 "com/ti/jfm/core/JFmRx",
2235 JFmRxNative_sMethods,
2236 NELEM(JFmRxNative_sMethods))) {
2237 goto bail;
2238 }
2239
2240
2241 if (!registerNatives(env,
2242 "com/ti/jfm/core/JFmTx",
2243 JFmTxNative_sMethods,
2244 getTxNativeSize())) {
2245 goto bail;
2246 }
2247
2248
2249 env->GetJavaVM(&g_jVM);
2250
2251 /* success -- return valid version number */
2252 result = JNI_VERSION_1_4;
2253
2254 bail:
2255 return result;
2256 }
2257
2258
2259