| /* |
| * Copyright (c) 2009-2013, 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; |
| |
| |
| /** |
| * This class contains all interfaces and types needed to control the FM transmitter. |
| * @hide |
| */ |
| public class FmTransmitter extends FmTransceiver |
| { |
| private final String TAG = "FmTransmitter"; |
| /** |
| * An object that contains the PS Features that SoC supports |
| * |
| * @see #getPSFeatures |
| */ |
| public class FmPSFeatures |
| { |
| public int maxPSCharacters; |
| public int maxPSStringRepeatCount; |
| }; |
| |
| |
| /** |
| * Command types for the RDS group transmission. |
| * This is used as argument to #transmitRdsGroupControl to |
| * control the RDS group transmission. |
| * |
| * @see #transmitRdsGroupControl |
| */ |
| |
| public static final int RDS_GRPS_TX_PAUSE = 0; /* Pauses the Group transmission*/ |
| |
| public static final int RDS_GRPS_TX_RESUME = 1; /* Resumes the Group transmission*/ |
| |
| public static final int RDS_GRPS_TX_STOP = 2; /* Stops and clear the Group transmission */ |
| |
| public static final int FM_TX_MAX_PS_LEN = (96+1); |
| public static final int FM_TX_MAX_RT_LEN = (64-1); /*One space to include NULL*/ |
| |
| private static final int MAX_PS_CHARS = 97; |
| private static final int MAX_PS_REP_COUNT = 15; |
| private static final int MAX_RDS_GROUP_BUF_SIZE = 62; |
| |
| private FmTransmitterCallbacksAdaptor mTxCallbacks; |
| private boolean mPSStarted = false; |
| private boolean mRTStarted = false; |
| private static final int V4L2_CID_PRIVATE_BASE = 0x8000000; |
| private static final int V4L2_CID_PRIVATE_TAVARUA_ANTENNA = V4L2_CID_PRIVATE_BASE + 18; |
| |
| /** |
| * Power settings |
| * |
| * @see #setPowerMode |
| * @see #getPowerMode |
| */ |
| public static final int FM_TX_NORMAL_POWER_MODE =0; |
| public static final int FM_TX_LOW_POWER_MODE =1; |
| |
| /** |
| * Transmit Power level settings |
| * |
| * @see #setTxPowerLevel |
| */ |
| public static final int FM_TX_PWR_LEVEL_0 =0; |
| public static final int FM_TX_PWR_LEVEL_1 =1; |
| public static final int FM_TX_PWR_LEVEL_2 =2; |
| public static final int FM_TX_PWR_LEVEL_3 =3; |
| public static final int FM_TX_PWR_LEVEL_4 =4; |
| public static final int FM_TX_PWR_LEVEL_5 =5; |
| public static final int FM_TX_PWR_LEVEL_6 =6; |
| public static final int FM_TX_PWR_LEVEL_7 =7; |
| |
| |
| /** |
| * Constructor for the transmitter class that takes path to |
| * radio device and event callback adapter |
| */ |
| public FmTransmitter(String path, FmTransmitterCallbacksAdaptor callbacks) throws InstantiationException{ |
| |
| mTxEvents = new FmTxEventListner(); |
| mControl = new FmRxControls(); |
| mTxCallbacks = callbacks; |
| } |
| |
| /*============================================================== |
| FUNCTION: enable |
| ==============================================================*/ |
| /** |
| * Enables the FM device in Transmit Mode. |
| * <p> |
| * This is a synchronous method used to initialize the FM |
| * device in transmitt mode. If already initialized this function will |
| * intialize the Fm device with default settings. Only after |
| * successfully calling this function can many of the FM device |
| * interfaces be used. |
| * <p> |
| * When enabling the transmitter, the application must also |
| * provide the regional settings in which the transmitter will |
| * operate. These settings (included in argument |
| * configSettings) are typically used for setting up the FM |
| * Transmitter for operating in a particular geographical |
| * region. These settings can be changed after the FM driver |
| * is enabled through the use of the function {@link |
| * #configure}. |
| * <p> |
| * This command can only be issued by the owner of an FM |
| * transmitter. |
| * |
| * @param configSettings the settings to be applied when |
| * turning on the radio |
| * @return true if Initialization succeeded, false if |
| * Initialization failed. |
| * <p> |
| * @see #enable |
| * @see #registerTransmitClient |
| * @see #disable |
| * |
| */ |
| public boolean enable (FmConfig configSettings){ |
| boolean status = false; |
| |
| int state = getFMState(); |
| if (state == FMState_Tx_Turned_On) { |
| Log.d(TAG, "enable: FM Tx already turned On and running"); |
| return status; |
| }else if (state == subPwrLevel_FMTurning_Off) { |
| Log.v(TAG, "FM is in the process of turning off.Pls wait for sometime."); |
| return status; |
| }else if((state == subPwrLevel_FMTx_Starting) |
| ||(state == subPwrLevel_FMRx_Starting)) { |
| Log.v(TAG, "FM is in the process of turning On.Pls wait for sometime."); |
| return status; |
| }else if((state == FMState_Srch_InProg) |
| ||(state == FMState_Rx_Turned_On)) { |
| Log.v(TAG, "FM Rx is turned on"); |
| return status; |
| } |
| setFMPowerState(subPwrLevel_FMTx_Starting); |
| Log.v(TAG, "enable: CURRENT-STATE : FMOff ---> NEW-STATE : FMTxStarting"); |
| status = super.enable(configSettings, FmTransceiver.FM_TX); |
| if(status == true) { |
| registerTransmitClient(mTxCallbacks); |
| mRdsData = new FmRxRdsData(sFd); |
| } else { |
| status = false; |
| Log.e(TAG, "enable: failed to turn On FM TX"); |
| Log.e(TAG, "enable: CURRENT-STATE : FMTxStarting ---> NEW-STATE : FMOff"); |
| setFMPowerState(FMState_Turned_Off); |
| } |
| return status; |
| } |
| /*============================================================== |
| FUNCTION: setRdsOn |
| ==============================================================*/ |
| /** |
| * |
| * This function enables RDSCTRL register for SoC. |
| * |
| * <p> |
| * This API enables the ability of the FM driver |
| * to send Program Service, RadioText information. |
| * |
| * |
| * @return true if the command was placed successfully, false |
| * if command failed. |
| * |
| */ |
| public boolean setRdsOn (){ |
| |
| if (mRdsData == null) |
| return false; |
| // Enable RDS |
| int re = mRdsData.rdsOn(true); |
| |
| if (re ==0) |
| return true; |
| |
| return false; |
| } |
| |
| /*============================================================== |
| FUNCTION: disable |
| ==============================================================*/ |
| /** |
| * Disables the FM Transmitter Device. |
| * <p> |
| * This is a synchronous command used to disable the FM |
| * device. This function is expected to be used when the |
| * application no longer requires use of the FM device. Once |
| * called, most functionality offered by the FM device will be |
| * disabled until the application re-enables the device again |
| * via {@link #enable}. |
| * |
| * <p> |
| * @return true if disabling succeeded, false if disabling |
| * failed. |
| * |
| * @see #enable |
| * @see #registerTransmitClient |
| */ |
| public boolean disable(){ |
| boolean status = false; |
| int state; |
| |
| state = getFMState(); |
| switch(state) { |
| case FMState_Turned_Off: |
| Log.d(TAG, "FM already tuned Off."); |
| return true; |
| case subPwrLevel_FMTx_Starting: |
| /* |
| * If, FM is in the process of turning On, then wait for |
| * the turn on operation to complete before turning off. |
| */ |
| Log.d(TAG, "disable: FM not yet turned On..."); |
| try { |
| Thread.sleep(100); |
| } catch (InterruptedException e) { |
| e.printStackTrace(); |
| } |
| /* Check for the state of FM device */ |
| state = getFMState(); |
| if(state == subPwrLevel_FMTx_Starting) { |
| Log.e(TAG, "disable: FM in bad state"); |
| return status; |
| } |
| break; |
| case subPwrLevel_FMTurning_Off: |
| /* |
| * If, FM is in the process of turning Off, then wait for |
| * the turn off operation to complete. |
| */ |
| Log.v(TAG, "disable: FM is getting turned Off."); |
| return status; |
| } |
| setFMPowerState(subPwrLevel_FMTurning_Off); |
| Log.v(TAG, "disable: CURRENT-STATE : FMTxOn ---> NEW-STATE : FMTurningOff"); |
| //Stop all the RDS transmissions if there any |
| if(mPSStarted) { |
| if(!stopPSInfo()) { |
| Log.d(TAG, "FmTrasmitter:stopPSInfo failed\n"); |
| } |
| } |
| if(mRTStarted) { |
| if(!stopRTInfo()) { |
| Log.d(TAG, "FmTrasmitter:stopRTInfo failed\n"); |
| } |
| } |
| if(!transmitRdsGroupControl(RDS_GRPS_TX_STOP) ) { |
| Log.d(TAG, "FmTrasmitter:transmitRdsGroupControl failed\n"); |
| } |
| super.disable(); |
| return true; |
| } |
| |
| /*============================================================== |
| FUNCTION: reset |
| ==============================================================*/ |
| /** |
| * Reset the FM Device. |
| * <p> |
| * This is a synchronous command used to reset the state of FM |
| * device in case of unrecoverable error. This function is |
| * expected to be used when the client receives unexpected |
| * notification of radio disabled. Once called, most |
| * functionality offered by the FM device will be disabled |
| * until the client re-enables the device again via |
| * {@link #enable}. |
| * <p> |
| * @return true if reset succeeded, false if reset failed. |
| * @see #enable |
| * @see #disable |
| * @see #registerTransmitClient |
| */ |
| public boolean reset(){ |
| boolean status = false; |
| int state = getFMState(); |
| |
| if(state == FMState_Turned_Off) { |
| Log.d(TAG, "FM already turned Off."); |
| return false; |
| } |
| setFMPowerState(FMState_Turned_Off); |
| Log.v(TAG, "reset: NEW-STATE : FMState_Turned_Off"); |
| status = unregisterTransmitClient(); |
| release("/dev/radio0"); |
| return status; |
| } |
| |
| /*============================================================== |
| FUNCTION: setStation |
| ==============================================================*/ |
| /** |
| * Tunes the FM device to the specified FM frequency. |
| * <p> |
| * This method tunes the FM device to a station specified by the |
| * provided frequency. Only valid frequencies within the band |
| * set by enable or configure can be tuned by this function. |
| * Attempting to tune to frequencies outside of the set band |
| * will result in an error. |
| * <p> |
| * Once tuning to the specified frequency is completed, the |
| * event callback FmTransmitterCallbacks::onTuneStatusChange will be called. |
| * |
| * @param frequencyKHz Frequency (in kHz) to be tuned |
| * (Example: 96500 = 96.5Mhz) |
| * @return true if setStation call was placed successfully, |
| * false if setStation failed. |
| */ |
| public boolean setStation (int frequencyKHz) { |
| |
| //Stop If there is any ongoing RDS transmissions |
| boolean status = false; |
| if( mPSStarted ){ |
| Log.d(TAG,"FmTransmitter:setStation mPSStarted"); |
| if( !stopPSInfo() ) return status; |
| } |
| if( mRTStarted ) { |
| Log.d(TAG,"FmTransmitter:setStation mRTStarted"); |
| if(!stopRTInfo()) return status; |
| } |
| if(!transmitRdsGroupControl(RDS_GRPS_TX_STOP) )return status; |
| |
| Log.d(TAG, "FmTrasmitter:SetStation\n"); |
| status = super.setStation(frequencyKHz); |
| |
| return status; |
| } |
| /*============================================================== |
| FUNCTION: setPowerMode |
| ==============================================================*/ |
| /** |
| * Puts the driver into or out of low power mode. |
| * |
| * <p> |
| * This is an synchronous command which can put the FM |
| * device and driver into and out of low power mode. Low power mode |
| * should be used when the receiver is tuned to a station and only |
| * the FM audio is required. The typical scenario for low power mode |
| * is when the FM application is no longer visible. |
| * |
| * <p> |
| * While in low power mode, all normal FM and RDS indications from |
| * the FM driver will be suppressed. By disabling these indications, |
| * low power mode can result in fewer interruptions and this may lead |
| * to a power savings. |
| * |
| * <p> |
| * @param powerMode the new driver operating mode. |
| * |
| * @return true if setPowerMode succeeded, false if |
| * setPowerMode failed. |
| */ |
| public boolean setPowerMode(int powerMode){ |
| |
| int re; |
| |
| if (powerMode == FM_TX_LOW_POWER_MODE) { |
| re = mControl.setLowPwrMode (sFd, true); |
| } |
| else { |
| re = mControl.setLowPwrMode (sFd, false); |
| } |
| |
| if (re == 0) |
| return true; |
| return false; |
| } |
| |
| |
| /*============================================================== |
| FUNCTION: getPSFeatures |
| ==============================================================*/ |
| /** |
| * This function returns the features supported by the FM |
| * driver when using {@link #setPSInfo}. |
| * <p> |
| * This function is used to get the features the FM driver |
| * supports when transmitting Program Service information. |
| * Included in the returned features is the number of Program |
| * Service (PS) characters which can be transmitted using |
| * {@link #setPSInfo}. If the driver supports continuous |
| * transmission of Program Service Information, this function |
| * will return a value greater than 0 for |
| * FmPSFeatures.maxPSCharacters. Although the RDS/RBDS |
| * standard defines each Program Service (PS) string as eight |
| * characters in length, the FM driver may have the ability to |
| * accept a string that is greater than eight character. This |
| * extended string will thenbe broken up into multiple strings |
| * of length eight and transmitted continuously. |
| * <p> |
| * When transmitting more than one string, the application may |
| * want to control the timing of how long each string is |
| * transmitted. Included in the features returned from this |
| * function is the maximum Program Service string repeat count |
| * (FmPSFeatures.maxPSStringRepeatCount). When using the |
| * function {@link #setPSInfo}, the application can specify how |
| * many times each string is repeated before the next string is |
| * transmitted. |
| * |
| * @return the Program service maximum characters and repeat |
| * count |
| * |
| * @see #setPSInfo |
| * |
| */ |
| public FmPSFeatures getPSFeatures(){ |
| FmPSFeatures psFeatures = new FmPSFeatures(); |
| |
| psFeatures.maxPSCharacters = MAX_PS_CHARS; |
| psFeatures.maxPSStringRepeatCount = MAX_PS_REP_COUNT; |
| return psFeatures; |
| } |
| |
| /*============================================================== |
| FUNCTION: startPSInfo |
| ==============================================================*/ |
| /** |
| * Continuously transmit RDS/RBDS Program Service information |
| * over an already tuned station. |
| * <p> |
| * This is a synchronous function used to continuously transmit Program |
| * Service information over an already tuned station. While |
| * Program Service information can be transmitted using {@link |
| * #transmitRdsGroups} and 0A/0B groups, this function makes |
| * the same output possible with limited input needed from the |
| * application. |
| * <p> |
| * Included in the Program Service information is an RDS/RBDS |
| * program type (PTY), and one or more Program Service |
| * strings. The program type (PTY) is used to describe the |
| * content being transmitted and follows the RDS/RBDS program |
| * types described in the RDS/RBDS specifications. |
| * <p> |
| * Program Service information also includes an eight |
| * character string. This string can be used to display any |
| * information, but is typically used to display information |
| * about the audio being transmitted. Although the RDS/RBDS |
| * standard defines a Program Service (PS) string as eight |
| * characters in length, the FM driver may have the ability to |
| * accept a string that is greater than eight characters. This |
| * extended string will then be broken up into multiple eight |
| * character strings which will be transmitted continuously. |
| * All strings passed to this function must be terminated by a |
| * null character (0x00). |
| * <p> |
| * When transmitting more than one string, the application may |
| * want to control the timing of how long each string is |
| * transmitted. To control this timing and to ensure that the FM |
| * receiver receives each string, the application can specify |
| * how many times each string is repeated before the next string |
| * is transmitted. This command can only be issued by the owner |
| * of an FM transmitter. |
| * <p> |
| * Maximux Programme service string lenght that can be sent is |
| * FM_TX_MAX_PS_LEN. If the application sends PS string longer than |
| * this threshold, string will be truncated to FM_TX_MAX_PS_LEN. |
| * |
| * @param psStr the program service strings to transmit |
| * @param pty the program type to use in the program Service |
| * information. |
| * @param pi the program type to use in the program Service |
| * information. |
| * @param repeatCount the number of times each 8 char string is |
| * repeated before next string |
| * |
| * @return true if PS information was successfully sent to the |
| * driver, false if PS information could not be sent |
| * to the driver. |
| * |
| * @see #getPSFeatures |
| * @see #stopPSInfo |
| */ |
| public boolean startPSInfo(String psStr, int pty, int pi, int repeatCount){ |
| |
| //Set the PTY |
| if((pty < 0) || (pty > 31 )) { |
| Log.d(TAG,"pTy is expected from 0 to 31"); |
| return false; |
| } |
| |
| int err = FmReceiverJNI.setPTYNative( sFd, pty ); |
| if( err < 0 ){ |
| Log.d(TAG,"setPTYNative is failure"); |
| return false; |
| } |
| |
| if((pi < 0) || (pi > 65535)) { |
| Log.d(TAG,"pi is expected from 0 to 65535"); |
| return false; |
| } |
| |
| //Set the PI |
| err = FmReceiverJNI.setPINative( sFd, pi ); |
| if( err < 0 ){ |
| Log.d(TAG,"setPINative is failure"); |
| return false; |
| } |
| |
| if((repeatCount < 0) || (repeatCount > 15)) { |
| Log.d(TAG,"repeat count is expected from 0 to 15"); |
| return false; |
| } |
| |
| err = FmReceiverJNI.setPSRepeatCountNative( sFd, repeatCount ); |
| if( err < 0 ){ |
| Log.d(TAG,"setPSRepeatCountNative is failure"); |
| return false; |
| } |
| |
| if( psStr.length() > FM_TX_MAX_PS_LEN ){ |
| /*truncate the PS string to |
| MAX possible length*/ |
| psStr = psStr.substring( 0, FM_TX_MAX_PS_LEN ); |
| |
| } |
| |
| err = FmReceiverJNI.startPSNative( sFd, psStr , psStr.length() ); |
| Log.d(TAG,"return for startPS is "+err); |
| |
| if( err < 0 ){ |
| Log.d(TAG, "FmReceiverJNI.startPSNative returned false\n"); |
| return false; |
| |
| } else { |
| Log.d(TAG,"startPSNative is successful"); |
| mPSStarted = true; |
| return true; |
| } |
| } |
| |
| /*============================================================== |
| FUNCTION: stopPSInfo |
| ==============================================================*/ |
| /** |
| * Stops an active Program Service transmission. |
| * |
| * <p> |
| * This is a synchrnous function used to stop an active Program Service transmission |
| * started by {@link #startPSInfo}. |
| * |
| * @return true if Stop PS information was successfully sent to |
| * the driver, false if Stop PS information could not |
| * be sent to the driver. |
| * |
| * @see #getPSFeatures |
| * @see #startPSInfo |
| * |
| */ |
| public boolean stopPSInfo(){ |
| int err =0; |
| if( (err =FmReceiverJNI.stopPSNative( sFd )) < 0 ){ |
| Log.d(TAG,"return for startPS is "+err); |
| return false; |
| } else{ |
| Log.d(TAG,"stopPSNative is successful"); |
| mPSStarted = false; |
| return true; |
| } |
| } |
| |
| |
| /*============================================================== |
| FUNCTION: startRTInfo |
| ==============================================================*/ |
| /** |
| * Continuously transmit RDS/RBDS RadioText information over an |
| * already tuned station. |
| * |
| * <p> |
| * This is a synchronous function used to continuously transmit RadioText |
| * information over an already tuned station. While RadioText |
| * information can be transmitted using |
| * {@link #transmitRdsGroups} and 2A/2B groups, this function |
| * makes the same output possible with limited input needed from |
| * the application. |
| * <p> |
| * Included in the RadioText information is an RDS/RBDS program type (PTY), |
| * and a single string of up to 64 characters. The program type (PTY) is used |
| * to describe the content being transmitted and follows the RDS/RBDS program |
| * types described in the RDS/RBDS specifications. |
| * <p> |
| * RadioText information also includes a string that consists of up to 64 |
| * characters. This string can be used to display any information, but is |
| * typically used to display information about the audio being transmitted. |
| * This RadioText string is expected to be at 64 characters in length, or less |
| * than 64 characters and terminated by a return carriage (0x0D). All strings |
| * passed to this function must be terminated by a null character (0x00). |
| * <p> |
| * <p> |
| * Maximux Radio Text string length that can be sent is |
| * FM_TX_MAX_RT_LEN. If the application sends RT string longer than |
| * this threshold, string will be truncated to FM_TX_MAX_RT_LEN. |
| * |
| * @param rtStr the Radio Text string to transmit |
| * @param pty the program type to use in the Radio text |
| * transmissions. |
| * @param pi the program identifier to use in the Radio text |
| * transmissions. |
| * |
| * @return true if RT information String was successfully sent |
| * to the driver, false if RT information string |
| * could not be sent to the driver. |
| * |
| * @see #stopRTInfo |
| */ |
| public boolean startRTInfo(String rtStr, int pty, int pi){ |
| |
| if((pty < 0) || (pty > 31 )) { |
| Log.d(TAG,"pTy is expected from 0 to 31"); |
| return false; |
| } |
| //Set the PTY |
| int err = FmReceiverJNI.setPTYNative( sFd, pty ); |
| if( err < 0 ){ |
| Log.d(TAG,"setPTYNative is failure"); |
| return false; |
| } |
| |
| if((pi < 0) || (pi > 65535)) { |
| Log.d(TAG,"pi is expected from 0 to 65535"); |
| return false; |
| } |
| |
| err = FmReceiverJNI.setPINative( sFd, pi ); |
| if( err < 0 ){ |
| Log.d(TAG,"setPINative is failure"); |
| return false; |
| } |
| |
| |
| if( rtStr.length() > FM_TX_MAX_RT_LEN ) |
| { |
| //truncate it to max length |
| rtStr = rtStr.substring( 0, FM_TX_MAX_RT_LEN ); |
| } |
| |
| err = FmReceiverJNI.startRTNative( sFd, rtStr, rtStr.length() ); |
| |
| if( err < 0 ){ |
| Log.d(TAG, "FmReceiverJNI.startRTNative returned false\n"); |
| return false; |
| } else { |
| Log.d(TAG,"mRTStarted is true"); |
| mRTStarted = true; |
| return true; |
| } |
| } |
| |
| /*============================================================== |
| FUNCTION: stopRTInfo |
| ==============================================================*/ |
| /** |
| * Stops an active Radio Text information transmission. |
| * |
| * <p> |
| * This is a synchrnous function used to stop an active Radio Text |
| * transmission started by {@link #startRTInfo}. |
| * |
| * @return true if Stop RT information was successfully sent to |
| * the driver, false if Stop RT information could not |
| * be sent to the driver. |
| * |
| * @see #startRTInfo |
| * |
| */ |
| public boolean stopRTInfo(){ |
| |
| if( FmReceiverJNI.stopRTNative( sFd ) < 0 ){ |
| Log.d(TAG,"stopRTNative is failure"); |
| return false; |
| } else{ |
| Log.d(TAG,"mRTStarted is false"); |
| mRTStarted = false; |
| return true; |
| } |
| } |
| |
| /*============================================================== |
| FUNCTION: getRdsGroupBufSize |
| ==============================================================*/ |
| /** |
| * Get the maximum number of RDS/RBDS groups which can be passed |
| * to the FM driver. |
| * <p> |
| * This is a function used to determine the maximum RDS/RBDS |
| * buffer size for use when calling {@link #transmitRdsGroups} |
| * |
| * @return the maximum number of RDS/RBDS groups which can be |
| * passed to the FM driver at any one time. |
| * |
| */ |
| public int getRdsGroupBufSize(){ |
| |
| return MAX_RDS_GROUP_BUF_SIZE; |
| } |
| |
| |
| /*============================================================== |
| FUNCTION: transmitRdsGroups |
| ==============================================================*/ |
| /** |
| * This function will transmit RDS/RBDS groups |
| * over an already tuned station. |
| * This is an asynchronous function used to transmit RDS/RBDS |
| * groups over an already tuned station. This functionality is |
| * is currently unsupported. |
| * <p> |
| * This function accepts a buffer (rdsGroups) containing one or |
| * more RDS groups. When sending this buffer, the application |
| * must also indicate how many groups should be taken from this |
| * buffer (numGroupsToTransmit). It may be possible that the FM |
| * driver can not accept the number of group contained in the |
| * buffer and will indicate how many group were actually |
| * accepted through the return value. |
| * |
| * <p> |
| * The FM driver will indicate to the application when it is |
| * ready to accept more data via both the |
| * "onRDSGroupsAvailable()" and "onRDSGroupsComplete()" events |
| * callbacks. The "onRDSGroupsAvailable()" callback will |
| * indicate to the application that the FM driver can accept |
| * additional groups even though all groups may not have been |
| * passed to the FM transmitter. The onRDSGroupsComplete() |
| * callback will indicate when the FM driver has a complete |
| * buffer to transmit RDS data. In many cases all data passed to |
| * the FM driver will be passed to the FM hardware and only a |
| * onRDSGroupsComplete() event will be generated by the |
| * FM driver. |
| * <p> If the application attempts to send more groups than the |
| * FM driver can handle, the application must wait until it |
| * receives a onRDSGroupsAvailable or a onRDSGroupsComplete |
| * event before attempting to transmit more groups. Failure to |
| * do so may result in no group being consumed by the FM driver. |
| * <p> It is important to note that switching between continuous |
| * and non-continuous transmission of RDS groups can only happen |
| * when no RDS/RBDS group transmission is underway. If an |
| * RDS/RBDS group transmission is already underway, the |
| * application must wait for a onRDSGroupsComplete. If the application |
| * wishes to switch from continuous to non-continuous (or |
| * vice-versa) without waiting for the current transmission to |
| * complete, the application can clear all remaining groups |
| * using the {@link #transmitRdsGroupControl} command. |
| * <p> |
| * Once completed, this command will generate a |
| * onRDSGroupsComplete event to all registered applications. |
| * |
| * @param rdsGroups The RDS/RBDS groups buffer to transmit. |
| * @param numGroupsToTransmit The number of groups in the buffer |
| * to transmit. |
| * |
| * @return The number of groups the FM driver actually accepted. |
| * A value >0 indicates the command was successfully |
| * accepted and a return value of "-1" indicates error. |
| * |
| * @see #transmitRdsGroupControl |
| */ |
| |
| public int transmitRdsGroups(byte[] rdsGroups, long numGroupsToTransmit){ |
| /* |
| * This functionality is currently unsupported |
| */ |
| |
| return -1; |
| } |
| /*============================================================== |
| FUNCTION: transmitContRdsGroups |
| ==============================================================*/ |
| /** |
| * This function will continuously transmit RDS/RBDS groups over an already tuned station. |
| * <p> |
| * This is an asynchronous function used to continuously |
| * transmit RDS/RBDS groups over an already tuned station. |
| * This functionality is currently unsupported. |
| * <p> |
| * This function accepts a buffer (rdsGroups) containing one or |
| * more RDS groups. When sending this buffer, the application |
| * must also indicate how many groups should be taken from this |
| * buffer (numGroupsToTransmit). It may be possible that the FM |
| * driver can not accept the number of group contained in the |
| * buffer and will indicate how many group were actually |
| * accepted through the return value. |
| * |
| * <p> |
| * Application can send a complete RDS group buffer for the transmission. |
| * This data will be sent continuously to the driver. Only single RDS |
| * group can be continuously transmitter at a time. So, application has to |
| * send the complete RDS buffer it intends to transmit. trying to pass the |
| * single buffer in two calls will be interprted as two different RDS/RBDS |
| * groups and hence all the unset groups will be cleared. |
| * <p> |
| * As continuous RDS/RBDS group transmission is done over single buffer, |
| * Application has to wait for the "onContRDSGroupsComplete()" callback |
| * to initiate the further RDS/RBDS group transmissions. Failure to |
| * do so may result in no group being consumed by the FM driver. |
| * <p> It is important to note that switching between continuous |
| * and non-continuous transmission of RDS groups can only happen |
| * when no RDS/RBDS group transmission is underway. If an |
| * RDS/RBDS group transmission is already underway, the |
| * application must wait for a onRDSGroupsComplete or onContRDSGroupsComplete. |
| * If the application wishes to switch from continuous to non-continuous (or |
| * vice-versa) without waiting for the current transmission to |
| * complete, the application can clear all remaining groups |
| * using the {@link #transmitRdsGroupControl} command. |
| * <p> |
| * Once completed, this command will generate a |
| * onRDSContGroupsComplete event to all registered applications. |
| * |
| * @param rdsGroups The RDS/RBDS groups buffer to transmit. |
| * @param numGroupsToTransmit The number of groups in the buffer |
| * to transmit. |
| * |
| * @return The number of groups the FM driver actually accepted. |
| * A value >0 indicates the command was successfully |
| * accepted and a return value of "-1" indicates error. |
| * |
| * @see #transmitRdsGroupControl |
| */ |
| |
| public int transmitRdsContGroups(byte[] rdsGroups, long numGroupsToTransmit){ |
| /* |
| * This functionality is currently unsupported. |
| */ |
| return -1; |
| } |
| |
| /*============================================================== |
| FUNCTION: transmitRdsGroupControl |
| ==============================================================*/ |
| /** |
| * Pause/Resume RDS/RBDS group transmission, or stop and clear |
| * all RDS groups. |
| * <p> |
| * This is a function used to pause/resume RDS/RBDS |
| * group transmission, or stop and clear all RDS groups. This |
| * function can be used to control continuous and |
| * non-continuous RDS/RBDS group transmissions. This functionality |
| * is currently unsupported. |
| * <p> |
| * @param ctrlCmd The Tx RDS group control.This should be one of the |
| * contants RDS_GRPS_TX_PAUSE/RDS_GRPS_TX_RESUME/RDS_GRPS_TX_STOP |
| * |
| * @return true if RDS Group Control command was |
| * successfully sent to the driver, false if RDS |
| * Group Control command could not be sent to the |
| * driver. |
| * |
| * @see #rdsGroupControlCmdType |
| * @see #transmitRdsGroups |
| */ |
| public boolean transmitRdsGroupControl(int ctrlCmd){ |
| boolean bStatus = true; |
| /* |
| * This functionality is currently unsupported. |
| */ |
| int val = 0; |
| switch( ctrlCmd ) { |
| case RDS_GRPS_TX_PAUSE:break; |
| case RDS_GRPS_TX_RESUME:break; |
| case RDS_GRPS_TX_STOP:break; |
| default: |
| /*Shouldn't reach here*/ |
| bStatus = false; |
| } |
| return bStatus; |
| } |
| |
| /*============================================================== |
| FUNCTION: setTxPowerLevel |
| ==============================================================*/ |
| /** |
| * Sets the transmitter power level. |
| * |
| * <p> |
| * This is a function used for setting the power level of |
| * Tx device. |
| * <p> |
| * @param powLevel The Tx power level value to be set. The value should be |
| * in range 0-7.If input is -ve level will be set to 0 |
| * and if it is above 7 level will be set to max i.e.,7. |
| * |
| * @return true on success, false on failure. |
| * |
| */ |
| public boolean setTxPowerLevel(int powLevel){ |
| boolean bStatus = true; |
| int err = FmReceiverJNI.setTxPowerLevelNative( sFd, powLevel ); |
| if( err < 0 ){ |
| Log.d(TAG,"setTxPowerLevel is failure"); |
| return false; |
| } |
| return bStatus; |
| } |
| |
| /* |
| * getFMState() returns: |
| * '0' if FM State is OFF |
| * '1' if FM Rx is On |
| * '2' if FM Tx is On |
| * '3' if FM device is Searching |
| */ |
| public int getFMState() { |
| /* Current State of FM device */ |
| int currFMState = FmTransceiver.getFMPowerState(); |
| return currFMState; |
| } |
| }; |