qcom/fmradio/FmReceiverJNI.java - LeafOS-Project/android_vendor_qcom_opensource_fm-commonsys - Gitiles

 /*
  * Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *        * Redistributions of source code must retain the above copyright
  *            notice, this list of conditions and the following disclaimer.
  *        * Redistributions in binary form must reproduce the above copyright
  *            notice, this list of conditions and the following disclaimer in the
  *            documentation and/or other materials provided with the distribution.
  *        * Neither the name of The Linux Foundation nor
  *            the names of its contributors may be used to endorse or promote
  *            products derived from this software without specific prior written
  *            permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NON-INFRINGEMENT ARE DISCLAIMED.    IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 package qcom.fmradio;
 import android.util.Log;
 import java.util.Arrays;
 import java.lang.Runnable;
 import qcom.fmradio.FmReceiver;

 class FmReceiverJNI {
     /**
      * General success
      */
     static final int FM_JNI_SUCCESS = 0;

     /**
      * General failure
      */
     static final int FM_JNI_FAILURE = -1;

     /**
      * native method: Open device
      * @return The file descriptor of the device
      *
      */
     private static final String TAG = "FmReceiverJNI";

     static {
         Log.d(TAG, "classinit native called");
         classInitNative();
     }
     static native void classInitNative();
     static native void initNative();
     static native void cleanupNative();

     final private FmRxEvCallbacks mCallback;
     static private final int STD_BUF_SIZE = 256;
     static private byte[] mRdsBuffer = new byte[STD_BUF_SIZE];

     public static  byte[]  getPsBuffer(byte[] buff) {
         Log.d(TAG, "getPsBuffer enter");
         buff = Arrays.copyOf(mRdsBuffer, mRdsBuffer.length);
         Log.d(TAG, "getPsBuffer exit");
         return buff;
     }

     public void AflistCallback(byte[] aflist) {
         Log.e(TAG, "AflistCallback enter " );
         if (aflist == null) {
             Log.e(TAG, "aflist null return  ");
             return;
         }
         mRdsBuffer = Arrays.copyOf(aflist, aflist.length);
         FmReceiver.mCallback.FmRxEvRdsAfInfo();
         Log.e(TAG, "AflistCallback exit " );
     }

     public void getSigThCallback(int val, int status)
     {
         Log.d(TAG, "get Signal Threshold callback");

         FmReceiver.mCallback.FmRxEvGetSignalThreshold(val, status);
     }

     public void getChDetThCallback(int val, int status)
     {
         FmReceiver.mCallback.FmRxEvGetChDetThreshold(val, status);
     }

     public void setChDetThCallback(int status)
     {
         FmReceiver.mCallback.FmRxEvSetChDetThreshold(status);
     }

     public void DefDataRdCallback(int val, int status)
     {
         FmReceiver.mCallback.FmRxEvDefDataRead(val, status);
     }

     public void DefDataWrtCallback(int status)
     {
         FmReceiver.mCallback.FmRxEvDefDataWrite(status);
     }

     public void getBlendCallback(int val, int status)
     {
         FmReceiver.mCallback.FmRxEvGetBlend(val, status);
     }

     public void setBlendCallback(int status)
     {
         FmReceiver.mCallback.FmRxEvSetBlend(status);
     }

     public void getStnParamCallback(int val, int status)
     {
         FmReceiver.mCallback.FmRxGetStationParam(val, status);
     }

     public void getStnDbgParamCallback(int val, int status)
     {
         FmReceiver.mCallback.FmRxGetStationDbgParam(val, status);
     }

     public void enableSlimbusCallback(int status)
     {
         Log.d(TAG, "++enableSlimbusCallback" );
         FmReceiver.mCallback.FmRxEvEnableSlimbus(status);
         Log.d(TAG, "--enableSlimbusCallback" );
     }

 	public void enableSoftMuteCallback(int status)
     {
         Log.d(TAG, "++enableSoftMuteCallback" );
         FmReceiver.mCallback.FmRxEvEnableSoftMute(status);
         Log.d(TAG, "--enableSoftMuteCallback" );
     }

     public void RtPlusCallback(byte[] rtplus) {
         Log.d(TAG, "RtPlusCallback enter " );
         if (rtplus == null) {
             Log.e(TAG, "psInfo null return  ");
             return;
         }
         mRdsBuffer = Arrays.copyOf(rtplus, rtplus.length);
         FmReceiver.mCallback.FmRxEvRTPlus();
         Log.d(TAG, "RtPlusCallback exit " );
     }

     public void RtCallback(byte[] rt) {
         Log.d(TAG, "RtCallback enter " );
         if (rt == null) {
             Log.e(TAG, "psInfo null return  ");
             return;
         }
         mRdsBuffer = Arrays.copyOf(rt, rt.length);
         FmReceiver.mCallback.FmRxEvRdsRtInfo();
         Log.d(TAG, "RtCallback exit " );
     }

     public void ErtCallback(byte[] ert) {
         Log.d(TAG, "ErtCallback enter " );
         if (ert == null) {
             Log.e(TAG, "ERT null return  ");
             return;
         }
         mRdsBuffer = Arrays.copyOf(ert, ert.length);
         FmReceiver.mCallback.FmRxEvERTInfo();
         Log.d(TAG, "RtCallback exit " );
     }

     public void EccCallback(byte[] ecc) {
         Log.i(TAG, "EccCallback enter " );
         if (ecc == null) {
             Log.e(TAG, "ECC null return  ");
             return;
         }
         mRdsBuffer = Arrays.copyOf(ecc, ecc.length);
         FmReceiver.mCallback.FmRxEvECCInfo();
         Log.i(TAG, "EccCallback exit " );
     }

     public void PsInfoCallback(byte[] psInfo) {
         Log.d(TAG, "PsInfoCallback enter " );
         if (psInfo == null) {
             Log.e(TAG, "psInfo null return  ");
             return;
         }
         Log.e(TAG, "length =  " +psInfo.length);
         mRdsBuffer = Arrays.copyOf(psInfo, psInfo.length);
         FmReceiver.mCallback.FmRxEvRdsPsInfo();
         Log.d(TAG, "PsInfoCallback exit");
     }

     public void enableCallback() {
         Log.d(TAG, "enableCallback enter");
         FmTransceiver.setFMPowerState(FmTransceiver.FMState_Rx_Turned_On);
         Log.v(TAG, "RxEvtList: CURRENT-STATE : FMRxStarting ---> NEW-STATE : FMRxOn");
         FmReceiver.mCallback.FmRxEvEnableReceiver();
         Log.d(TAG, "enableCallback exit");
     }

     public void tuneCallback(int freq) {
         int state;
         Log.d(TAG, "tuneCallback enter");
         state = FmReceiver.getSearchState();
         switch(state) {
         case FmTransceiver.subSrchLevel_SrchAbort:
             Log.v(TAG, "Current state is SRCH_ABORTED");
             Log.v(TAG, "Aborting on-going search command...");
             /* intentional fall through */
         case FmTransceiver.subSrchLevel_SeekInPrg :
             Log.v(TAG, "Current state is " + state);
             FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
             FmReceiver.mCallback.FmRxEvSearchComplete(freq);
             break;
         default:
             if (freq > 0)
                 FmReceiver.mCallback.FmRxEvRadioTuneStatus(freq);
             else
                 Log.e(TAG, "get frequency command failed");
             break;
         }
         Log.d(TAG, "tuneCallback exit");
     }

     public void seekCmplCallback(int freq) {
         int state;

         Log.d(TAG, "seekCmplCallback enter");
         state = FmReceiver.getSearchState();
         switch (state) {
         case FmTransceiver.subSrchLevel_ScanInProg:
             Log.v(TAG, "Current state is " + state);
             FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE :FMRxOn");
             FmReceiver.mCallback.FmRxEvSearchComplete(freq);
             break;
         case FmTransceiver.subSrchLevel_SrchAbort:
             Log.v(TAG, "Current state is SRCH_ABORTED");
             Log.v(TAG, "Aborting on-going search command...");
             FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
             FmReceiver.mCallback.FmRxEvSearchComplete(freq);
             break;
         }
         Log.d(TAG, "seekCmplCallback exit");
     }

     public void srchListCallback(byte[] scan_tbl) {
         int state;
         state = FmReceiver.getSearchState();
         switch (state) {
         case FmTransceiver.subSrchLevel_SrchListInProg:
             Log.v(TAG, "FmRxEventListener: Current state is AUTO_PRESET_INPROGRESS");
             FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
             FmReceiver.mCallback.FmRxEvSearchListComplete();
             break;
         case FmTransceiver.subSrchLevel_SrchAbort:
             Log.v(TAG, "Current state is SRCH_ABORTED");
             Log.v(TAG, "Aborting on-going SearchList command...");
             FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
             FmReceiver.mCallback.FmRxEvSearchCancelled();
             break;
        }
    }

     public void scanNxtCallback() {
         Log.d(TAG, "scanNxtCallback enter");
         FmReceiver.mCallback.FmRxEvSearchInProgress();
         Log.d(TAG, "scanNxtCallback exit");
     }

     public void stereostsCallback(boolean stereo) {
         Log.d(TAG, "stereostsCallback enter");
         FmReceiver.mCallback.FmRxEvStereoStatus (stereo);
         Log.d(TAG, "stereostsCallback exit");
     }

     public void rdsAvlStsCallback(boolean rdsAvl) {
         Log.d(TAG, "rdsAvlStsCallback enter");
         FmReceiver.mCallback.FmRxEvRdsLockStatus(rdsAvl);
         Log.d(TAG, "rdsAvlStsCallback exit");
     }

     public void disableCallback() {
         Log.d(TAG, "disableCallback enter");
         if (FmTransceiver.getFMPowerState() == FmTransceiver.subPwrLevel_FMTurning_Off) {
                  /*Set the state as FMOff */
             FmTransceiver.setFMPowerState(FmTransceiver.FMState_Turned_Off);
             Log.v(TAG, "RxEvtList: CURRENT-STATE : FMTurningOff ---> NEW-STATE : FMOff");
             FmReceiver.mCallback.FmRxEvDisableReceiver();
         } else {
             FmTransceiver.setFMPowerState(FmTransceiver.FMState_Turned_Off);
             Log.d(TAG, "Unexpected RADIO_DISABLED recvd");
             Log.v(TAG, "RxEvtList: CURRENT-STATE : FMRxOn ---> NEW-STATE : FMOff");
             FmReceiver.mCallback.FmRxEvRadioReset();
             Log.d(TAG, "disableCallback exit");
         }
     }

     public FmReceiverJNI(FmRxEvCallbacks callback) {
         mCallback = callback;
         if (mCallback == null)
             Log.e(TAG, "mCallback is null in JNI");
         Log.d(TAG, "init native called");
         initNative();
     }

     static native int acquireFdNative(String path);

     /**
      * native method:
      * @param fd
      * @param control
      * @param field
      * @return
      */
     static native int audioControlNative(int fd, int control, int field);

     /**
      * native method: cancels search
      * @param fd file descriptor of device
      * @return May return
      *             {@link #FM_JNI_SUCCESS}
      *             {@link #FM_JNI_FAILURE}
      */
     static native int cancelSearchNative(int fd);

     /**
      * native method: release control of device
      * @param fd file descriptor of device
      * @return May return
      *             {@link #FM_JNI_SUCCESS}
      *             {@link #FM_JNI_FAILURE}
      */
     static native int closeFdNative(int fd);

     /**
      * native method: get frequency
      * @param fd file descriptor of device
      * @return Returns frequency in int form
      */
     static native int getFreqNative(int fd);

     /**
      * native method: set frequency
      * @param fd file descriptor of device
      * @param freq freq to be set in int form
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      *
      */
     static native int setFreqNative(int fd, int freq);

     /**
      * native method: get v4l2 control
      * @param fd file descriptor of device
      * @param id v4l2 id to be retrieved
      * @return Returns current value of the
      *         v4l2 control
      */
     static native int getControlNative (int fd, int id);

     /**
      * native method: set v4l2 control
      * @param fd file descriptor of device
      * @param id v4l2 control to be set
      * @param value value to be set
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setControlNative (int fd, int id, int value);

     /**
      * native method: start search
      * @param fd file descriptor of device
      * @param dir search direction
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int startSearchNative (int fd, int dir);

     /**
      * native method: get buffer
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param index index of the buffer to be retrieved
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int getBufferNative (int fd, byte  buff[], int index);

     /**
      * native method: get RSSI value of the
      *                received signal
      * @param fd file descriptor of device
      * @return Returns signal strength in int form
      *         Signal value range from -120 to 10
      */
     static native int getRSSINative (int fd);

     /**
      * native method: set FM band
      * @param fd file descriptor of device
      * @param low lower band
      * @param high higher band
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setBandNative (int fd, int low, int high);

     /**
      * native method: get lower band
      * @param fd file descriptor of device
      * @return Returns lower band in int form
      */
     static native int getLowerBandNative (int fd);

     /**
      * native method: get upper band
      * @param fd file descriptor of device
      * @return Returns upper band in int form
      */
     static native int getUpperBandNative (int fd);

     /**
      * native method: force Mono/Stereo mode
      * @param fd file descriptor of device
      * @param val force mono/stereo indicator
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setMonoStereoNative (int fd, int val);

     /**
      * native method: get Raw RDS data
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param count number of bytes to be read
      * @return Returns number of bytes read
      */
     static native int getRawRdsNative (int fd, byte  buff[], int count);

     /**
      * native method: set v4l2 control
      * @param fd file descriptor of device
      * @param id v4l2 control to be set
      * @param value value to be set
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setNotchFilterNative(int fd, int id, boolean value);

     /**
      * native method: enable/disable Analog Mode
      */
     static native int setAnalogModeNative(boolean value);

     /**
      * native method: Starts the RT transmission
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param count number of bytes to be read
      * @return Returns number of bytes read
      */
     static native int startRTNative(int fd, String str, int count);

     /**
      * native method: Stops the RT transmission
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param count number of bytes to be read
      * @return Returns number of bytes read
      */
     static native int stopRTNative(int fd);

     /**
      * native method: Starts the PS transmission
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param count number of bytes to be read
      * @return Returns number of bytes read
      */
     static native int startPSNative(int fd, String str, int count);

     /**
      * native method: Stops the PS transmission
      * @param fd file descriptor of device
      * @param buff[] buffer
      * @param count number of bytes to be read
      */
     static native int stopPSNative(int fd);
    /**
      * native method: Sets the Programme type for transmission
      * @param fd file descriptor of device
      * @param pty program type to be transmited
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setPTYNative (int fd, int pty);

    /**
      * native method: Sets the Programme Id for transmission
      * @param fd file descriptor of device
      * @param pty program Id to be transmited
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setPINative (int fd, int pi);


    /**
      * native method: Sets the repeat count for Programme service
      * transmission.
      * @param fd file descriptor of device
      * @param repeatcount  number of times PS string to be transmited
      *                     repeatedly.
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setPSRepeatCountNative(int fd, int repeatCount);
    /**
      * native method: Sets the power level for the tramsmitter
      * transmission.
      * @param fd file descriptor of device
      * @param powLevel is the level at which transmitter operates.
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setTxPowerLevelNative(int fd, int powLevel);
    /**
      * native method: Sets the calibration
      * @param fd file descriptor of device
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int SetCalibrationNative(int fd);

    /**
      * native method: Configures the spur table
      * @param fd file descriptor of device
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int configureSpurTable(int fd);

     /**
      * native method: Configures the new spur table
      * @param fd file descriptor of device
      * @return {@link #FM_JNI_SUCCESS}
      *         {@link #FM_JNI_FAILURE}
      */
     static native int setSpurDataNative(int fd, short  buff[], int len);
     static native void configurePerformanceParams(int fd);
     static native int enableSlimbus(int fd, int val);
     static native int enableSoftMute(int fd, int val);
 }
	/*
	* Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are met:
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* * Neither the name of The Linux Foundation nor
	* the names of its contributors may be used to endorse or promote
	* products derived from this software without specific prior written
	* permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
	* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
	* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
	* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	package qcom.fmradio;
	import android.util.Log;
	import java.util.Arrays;
	import java.lang.Runnable;
	import qcom.fmradio.FmReceiver;

	class FmReceiverJNI {
	/**
	* General success
	*/
	static final int FM_JNI_SUCCESS = 0;

	/**
	* General failure
	*/
	static final int FM_JNI_FAILURE = -1;

	/**
	* native method: Open device
	* @return The file descriptor of the device
	*
	*/
	private static final String TAG = "FmReceiverJNI";

	static {
	Log.d(TAG, "classinit native called");
	classInitNative();
	}
	static native void classInitNative();
	static native void initNative();
	static native void cleanupNative();

	final private FmRxEvCallbacks mCallback;
	static private final int STD_BUF_SIZE = 256;
	static private byte[] mRdsBuffer = new byte[STD_BUF_SIZE];

	public static byte[] getPsBuffer(byte[] buff) {
	Log.d(TAG, "getPsBuffer enter");
	buff = Arrays.copyOf(mRdsBuffer, mRdsBuffer.length);
	Log.d(TAG, "getPsBuffer exit");
	return buff;
	}

	public void AflistCallback(byte[] aflist) {
	Log.e(TAG, "AflistCallback enter " );
	if (aflist == null) {
	Log.e(TAG, "aflist null return ");
	return;
	}
	mRdsBuffer = Arrays.copyOf(aflist, aflist.length);
	FmReceiver.mCallback.FmRxEvRdsAfInfo();
	Log.e(TAG, "AflistCallback exit " );
	}

	public void getSigThCallback(int val, int status)
	{
	Log.d(TAG, "get Signal Threshold callback");

	FmReceiver.mCallback.FmRxEvGetSignalThreshold(val, status);
	}

	public void getChDetThCallback(int val, int status)
	{
	FmReceiver.mCallback.FmRxEvGetChDetThreshold(val, status);
	}

	public void setChDetThCallback(int status)
	{
	FmReceiver.mCallback.FmRxEvSetChDetThreshold(status);
	}

	public void DefDataRdCallback(int val, int status)
	{
	FmReceiver.mCallback.FmRxEvDefDataRead(val, status);
	}

	public void DefDataWrtCallback(int status)
	{
	FmReceiver.mCallback.FmRxEvDefDataWrite(status);
	}

	public void getBlendCallback(int val, int status)
	{
	FmReceiver.mCallback.FmRxEvGetBlend(val, status);
	}

	public void setBlendCallback(int status)
	{
	FmReceiver.mCallback.FmRxEvSetBlend(status);
	}

	public void getStnParamCallback(int val, int status)
	{
	FmReceiver.mCallback.FmRxGetStationParam(val, status);
	}

	public void getStnDbgParamCallback(int val, int status)
	{
	FmReceiver.mCallback.FmRxGetStationDbgParam(val, status);
	}

	public void enableSlimbusCallback(int status)
	{
	Log.d(TAG, "++enableSlimbusCallback" );
	FmReceiver.mCallback.FmRxEvEnableSlimbus(status);
	Log.d(TAG, "--enableSlimbusCallback" );
	}

	public void enableSoftMuteCallback(int status)
	{
	Log.d(TAG, "++enableSoftMuteCallback" );
	FmReceiver.mCallback.FmRxEvEnableSoftMute(status);
	Log.d(TAG, "--enableSoftMuteCallback" );
	}

	public void RtPlusCallback(byte[] rtplus) {
	Log.d(TAG, "RtPlusCallback enter " );
	if (rtplus == null) {
	Log.e(TAG, "psInfo null return ");
	return;
	}
	mRdsBuffer = Arrays.copyOf(rtplus, rtplus.length);
	FmReceiver.mCallback.FmRxEvRTPlus();
	Log.d(TAG, "RtPlusCallback exit " );
	}

	public void RtCallback(byte[] rt) {
	Log.d(TAG, "RtCallback enter " );
	if (rt == null) {
	Log.e(TAG, "psInfo null return ");
	return;
	}
	mRdsBuffer = Arrays.copyOf(rt, rt.length);
	FmReceiver.mCallback.FmRxEvRdsRtInfo();
	Log.d(TAG, "RtCallback exit " );
	}

	public void ErtCallback(byte[] ert) {
	Log.d(TAG, "ErtCallback enter " );
	if (ert == null) {
	Log.e(TAG, "ERT null return ");
	return;
	}
	mRdsBuffer = Arrays.copyOf(ert, ert.length);
	FmReceiver.mCallback.FmRxEvERTInfo();
	Log.d(TAG, "RtCallback exit " );
	}

	public void EccCallback(byte[] ecc) {
	Log.i(TAG, "EccCallback enter " );
	if (ecc == null) {
	Log.e(TAG, "ECC null return ");
	return;
	}
	mRdsBuffer = Arrays.copyOf(ecc, ecc.length);
	FmReceiver.mCallback.FmRxEvECCInfo();
	Log.i(TAG, "EccCallback exit " );
	}

	public void PsInfoCallback(byte[] psInfo) {
	Log.d(TAG, "PsInfoCallback enter " );
	if (psInfo == null) {
	Log.e(TAG, "psInfo null return ");
	return;
	}
	Log.e(TAG, "length = " +psInfo.length);
	mRdsBuffer = Arrays.copyOf(psInfo, psInfo.length);
	FmReceiver.mCallback.FmRxEvRdsPsInfo();
	Log.d(TAG, "PsInfoCallback exit");
	}

	public void enableCallback() {
	Log.d(TAG, "enableCallback enter");
	FmTransceiver.setFMPowerState(FmTransceiver.FMState_Rx_Turned_On);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : FMRxStarting ---> NEW-STATE : FMRxOn");
	FmReceiver.mCallback.FmRxEvEnableReceiver();
	Log.d(TAG, "enableCallback exit");
	}

	public void tuneCallback(int freq) {
	int state;
	Log.d(TAG, "tuneCallback enter");
	state = FmReceiver.getSearchState();
	switch(state) {
	case FmTransceiver.subSrchLevel_SrchAbort:
	Log.v(TAG, "Current state is SRCH_ABORTED");
	Log.v(TAG, "Aborting on-going search command...");
	/* intentional fall through */
	case FmTransceiver.subSrchLevel_SeekInPrg :
	Log.v(TAG, "Current state is " + state);
	FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
	FmReceiver.mCallback.FmRxEvSearchComplete(freq);
	break;
	default:
	if (freq > 0)
	FmReceiver.mCallback.FmRxEvRadioTuneStatus(freq);
	else
	Log.e(TAG, "get frequency command failed");
	break;
	}
	Log.d(TAG, "tuneCallback exit");
	}

	public void seekCmplCallback(int freq) {
	int state;

	Log.d(TAG, "seekCmplCallback enter");
	state = FmReceiver.getSearchState();
	switch (state) {
	case FmTransceiver.subSrchLevel_ScanInProg:
	Log.v(TAG, "Current state is " + state);
	FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE :FMRxOn");
	FmReceiver.mCallback.FmRxEvSearchComplete(freq);
	break;
	case FmTransceiver.subSrchLevel_SrchAbort:
	Log.v(TAG, "Current state is SRCH_ABORTED");
	Log.v(TAG, "Aborting on-going search command...");
	FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
	FmReceiver.mCallback.FmRxEvSearchComplete(freq);
	break;
	}
	Log.d(TAG, "seekCmplCallback exit");
	}

	public void srchListCallback(byte[] scan_tbl) {
	int state;
	state = FmReceiver.getSearchState();
	switch (state) {
	case FmTransceiver.subSrchLevel_SrchListInProg:
	Log.v(TAG, "FmRxEventListener: Current state is AUTO_PRESET_INPROGRESS");
	FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
	FmReceiver.mCallback.FmRxEvSearchListComplete();
	break;
	case FmTransceiver.subSrchLevel_SrchAbort:
	Log.v(TAG, "Current state is SRCH_ABORTED");
	Log.v(TAG, "Aborting on-going SearchList command...");
	FmReceiver.setSearchState(FmTransceiver.subSrchLevel_SrchComplete);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : Search ---> NEW-STATE : FMRxOn");
	FmReceiver.mCallback.FmRxEvSearchCancelled();
	break;
	}
	}

	public void scanNxtCallback() {
	Log.d(TAG, "scanNxtCallback enter");
	FmReceiver.mCallback.FmRxEvSearchInProgress();
	Log.d(TAG, "scanNxtCallback exit");
	}

	public void stereostsCallback(boolean stereo) {
	Log.d(TAG, "stereostsCallback enter");
	FmReceiver.mCallback.FmRxEvStereoStatus (stereo);
	Log.d(TAG, "stereostsCallback exit");
	}

	public void rdsAvlStsCallback(boolean rdsAvl) {
	Log.d(TAG, "rdsAvlStsCallback enter");
	FmReceiver.mCallback.FmRxEvRdsLockStatus(rdsAvl);
	Log.d(TAG, "rdsAvlStsCallback exit");
	}

	public void disableCallback() {
	Log.d(TAG, "disableCallback enter");
	if (FmTransceiver.getFMPowerState() == FmTransceiver.subPwrLevel_FMTurning_Off) {
	/Set the state as FMOff /
	FmTransceiver.setFMPowerState(FmTransceiver.FMState_Turned_Off);
	Log.v(TAG, "RxEvtList: CURRENT-STATE : FMTurningOff ---> NEW-STATE : FMOff");
	FmReceiver.mCallback.FmRxEvDisableReceiver();
	} else {
	FmTransceiver.setFMPowerState(FmTransceiver.FMState_Turned_Off);
	Log.d(TAG, "Unexpected RADIO_DISABLED recvd");
	Log.v(TAG, "RxEvtList: CURRENT-STATE : FMRxOn ---> NEW-STATE : FMOff");
	FmReceiver.mCallback.FmRxEvRadioReset();
	Log.d(TAG, "disableCallback exit");
	}
	}

	public FmReceiverJNI(FmRxEvCallbacks callback) {
	mCallback = callback;
	if (mCallback == null)
	Log.e(TAG, "mCallback is null in JNI");
	Log.d(TAG, "init native called");
	initNative();
	}

	static native int acquireFdNative(String path);

	/**
	* native method:
	* @param fd
	* @param control
	* @param field
	* @return
	*/
	static native int audioControlNative(int fd, int control, int field);

	/**
	* native method: cancels search
	* @param fd file descriptor of device
	* @return May return
	* {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int cancelSearchNative(int fd);

	/**
	* native method: release control of device
	* @param fd file descriptor of device
	* @return May return
	* {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int closeFdNative(int fd);

	/**
	* native method: get frequency
	* @param fd file descriptor of device
	* @return Returns frequency in int form
	*/
	static native int getFreqNative(int fd);

	/**
	* native method: set frequency
	* @param fd file descriptor of device
	* @param freq freq to be set in int form
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*
	*/
	static native int setFreqNative(int fd, int freq);

	/**
	* native method: get v4l2 control
	* @param fd file descriptor of device
	* @param id v4l2 id to be retrieved
	* @return Returns current value of the
	* v4l2 control
	*/
	static native int getControlNative (int fd, int id);

	/**
	* native method: set v4l2 control
	* @param fd file descriptor of device
	* @param id v4l2 control to be set
	* @param value value to be set
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setControlNative (int fd, int id, int value);

	/**
	* native method: start search
	* @param fd file descriptor of device
	* @param dir search direction
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int startSearchNative (int fd, int dir);

	/**
	* native method: get buffer
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param index index of the buffer to be retrieved
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int getBufferNative (int fd, byte buff[], int index);

	/**
	* native method: get RSSI value of the
	* received signal
	* @param fd file descriptor of device
	* @return Returns signal strength in int form
	* Signal value range from -120 to 10
	*/
	static native int getRSSINative (int fd);

	/**
	* native method: set FM band
	* @param fd file descriptor of device
	* @param low lower band
	* @param high higher band
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setBandNative (int fd, int low, int high);

	/**
	* native method: get lower band
	* @param fd file descriptor of device
	* @return Returns lower band in int form
	*/
	static native int getLowerBandNative (int fd);

	/**
	* native method: get upper band
	* @param fd file descriptor of device
	* @return Returns upper band in int form
	*/
	static native int getUpperBandNative (int fd);

	/**
	* native method: force Mono/Stereo mode
	* @param fd file descriptor of device
	* @param val force mono/stereo indicator
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setMonoStereoNative (int fd, int val);

	/**
	* native method: get Raw RDS data
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param count number of bytes to be read
	* @return Returns number of bytes read
	*/
	static native int getRawRdsNative (int fd, byte buff[], int count);

	/**
	* native method: set v4l2 control
	* @param fd file descriptor of device
	* @param id v4l2 control to be set
	* @param value value to be set
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setNotchFilterNative(int fd, int id, boolean value);

	/**
	* native method: enable/disable Analog Mode
	*/
	static native int setAnalogModeNative(boolean value);

	/**
	* native method: Starts the RT transmission
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param count number of bytes to be read
	* @return Returns number of bytes read
	*/
	static native int startRTNative(int fd, String str, int count);

	/**
	* native method: Stops the RT transmission
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param count number of bytes to be read
	* @return Returns number of bytes read
	*/
	static native int stopRTNative(int fd);

	/**
	* native method: Starts the PS transmission
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param count number of bytes to be read
	* @return Returns number of bytes read
	*/
	static native int startPSNative(int fd, String str, int count);

	/**
	* native method: Stops the PS transmission
	* @param fd file descriptor of device
	* @param buff[] buffer
	* @param count number of bytes to be read
	*/
	static native int stopPSNative(int fd);
	/**
	* native method: Sets the Programme type for transmission
	* @param fd file descriptor of device
	* @param pty program type to be transmited
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setPTYNative (int fd, int pty);

	/**
	* native method: Sets the Programme Id for transmission
	* @param fd file descriptor of device
	* @param pty program Id to be transmited
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setPINative (int fd, int pi);


	/**
	* native method: Sets the repeat count for Programme service
	* transmission.
	* @param fd file descriptor of device
	* @param repeatcount number of times PS string to be transmited
	* repeatedly.
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setPSRepeatCountNative(int fd, int repeatCount);
	/**
	* native method: Sets the power level for the tramsmitter
	* transmission.
	* @param fd file descriptor of device
	* @param powLevel is the level at which transmitter operates.
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setTxPowerLevelNative(int fd, int powLevel);
	/**
	* native method: Sets the calibration
	* @param fd file descriptor of device
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int SetCalibrationNative(int fd);

	/**
	* native method: Configures the spur table
	* @param fd file descriptor of device
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int configureSpurTable(int fd);

	/**
	* native method: Configures the new spur table
	* @param fd file descriptor of device
	* @return {@link #FM_JNI_SUCCESS}
	* {@link #FM_JNI_FAILURE}
	*/
	static native int setSpurDataNative(int fd, short buff[], int len);
	static native void configurePerformanceParams(int fd);
	static native int enableSlimbus(int fd, int val);
	static native int enableSoftMute(int fd, int val);
	}