Android FM模块学习之二 FM搜索频率流程

亦凉 2022-04-08 08:19 136阅读 0赞

上一篇大概分析了一下FM启动流程，若不了解Fm启动流程的，可以去打开前面的链接先了解FM启动流程，接下来我们简单分析一下FM的搜索频率流程。

在了解源码之前，我们先看一下流程图：

![Center][]

其实从图中可以看到，实现搜索频率的功能是在底层CPP文件，java层只操作和更新一些界面（GUI），Java调用JNI实现功能。Java app基本核心，通过方法回调实现a类和b类方法，b类调a类方法信息交互相互控制融为一体。App实现一些JNI接口最终实现核心功能是cpp文件，最后通过Service类（耗时操作）调用New一个线程循环不断的获取cpp里的信息，去更新UI界面活动状态。

搜索流程简单分析：点击搜索按钮，通过互调方法，最后调到FMReceiverJNI类中的方法实现功能。通过FMRxEventListner类不断获取cpp变频的频率，每获取一次频率(直到频率搜索完成停止调用)就回调FMRadioService内部FmRxEvCallbacksAdaptor的方法在回调到FMRadio类中方法，将频率存入FmSharedPreferences类xml文档中，发送Handler更新UI，即刻度盘，对话框，左右箭头中间显示的频率一致跳动。

接下来详细代码分析：

FMRadio中的菜单搜索功能，onOptionsItemSelected(MenuItem item)监听中走initiateSearch(mScanPtyIndex);方法。

![Center 1][]

![Center 2][]

![Center 3][]

调用FMRadioService的scan()方法（mService.scan(pty)）进行扫描频率

![Center 4][]

updateSearchProgress()里加了同步方法对象锁

![Center 5][]

调用了private Dialog createProgressDialog(int id)对话框进行搜索信息

标准耳机FmSharedPreferences.isRBDSStd()

private Dialog createProgressDialog(int id) \{ 
      String msgStr = ""; 
      String titleStr = ""; 
      String \[\]items; 
      double frequency = mTunedStation.getFrequency() / 1000.0; 
      boolean bSearchActive = false; 
  
      if (isSeekActive()) \{ 
          msgStr = getString(R.string.msg\_seeking); 
          bSearchActive = true; 
      \}else if (isScanActive()) \{ 
          if(FmSharedPreferences.isRBDSStd()) \{//标准耳机 
                items = getResources(). 
                         getStringArray(R.array.search\_category\_rbds\_entries); 
          \}else \{ // if(FmSharedPreferences.isRDSStd()) 
                items = getResources(). 
                         getStringArray(R.array.search\_category\_rds\_entries); 
          \}String ptyStr = ""; 
          if (items.length > mScanPtyIndex) 
              ptyStr = items\[mScanPtyIndex\]; 
          if (!TextUtils.isEmpty(ptyStr)) \{ 
             msgStr = getString(R.string.msg\_scanning\_pty, ptyStr); 
          \}else \{ 
             Log.d(LOGTAG, "pty is null\\n"); 
             msgStr = getString(R.string.msg\_scanning); 
          \} 
          titleStr = getString(R.string.msg\_search\_title, ("" + frequency)); 
          bSearchActive=true; 
      \}else if (isSearchActive()) \{ 
         msgStr = getString(R.string.msg\_searching); 
         titleStr = getString(R.string.msg\_searching\_title); 
         bSearchActive = true; 
      \} 
      if (bSearchActive) \{mProgressDialog = new ProgressDialog(FMRadio.this); 
          if (mProgressDialog != null) \{ 
              mProgressDialog.setTitle(titleStr); 
              mProgressDialog.setMessage(msgStr); 
              mProgressDialog.setIcon(R.drawable.ic\_launcher\_fmradio); 
              mProgressDialog.setProgressStyle(ProgressDialog.STYLE\_SPINNER); 
              mProgressDialog.setCanceledOnTouchOutside(false); 
              mProgressDialog.setButton(DialogInterface.BUTTON\_POSITIVE, 
                                   getText(R.string.button\_text\_stop), 
               new DialogInterface.OnClickListener() \{ 
                  public void onClick(DialogInterface dialog, int whichButton) \{ 
                      cancelSearch(); 
                  \} 
              \}); 
              mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() \{ public void onCancel(DialogInterface dialog) \{ 
                   cancelSearch(); 
                \} 
              \}); 
              mProgressDialog.setOnKeyListener(new OnKeyListener() \{ 
                public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) \{ 
                    Log.d(LOGTAG, "OnKeyListener event received in ProgressDialog" + keyCode); 
                    switch (keyCode) \{ 
                        case KeyEvent.KEYCODE\_MEDIA\_PLAY\_PAUSE: 
                        case 126: //KeyEvent.KEYCODE\_MEDIA\_PLAY: 
                        case 127: //KeyEvent.KEYCODE\_MEDIA\_PAUSE: 
                        case KeyEvent.KEYCODE\_MEDIA\_FAST\_FORWARD: 
                        case KeyEvent.KEYCODE\_MEDIA\_NEXT: 
                        case KeyEvent.KEYCODE\_MEDIA\_PREVIOUS: 
                        case KeyEvent.KEYCODE\_MEDIA\_REWIND: 
                        case KeyEvent.KEYCODE\_MEDIA\_STOP: 
                            return true; 
                    \} return false; 
                \} 
            \}); 
          \} 
          Message msg = new Message(); 
          msg.what = TIMEOUT\_PROGRESS\_DLG; 
          mSearchProgressHandler.sendMessageDelayed(msg, SHOWBUSY\_TIMEOUT); 
      \} 
      return mProgressDialog; 
   \} 
调用FMRadioService类中的Scan()方法扫描 
调用 FMReceiver的searchStations()方法进行扫描

public boolean scan(int pty) 
   \{ 
      boolean bCommandSent=false; 
      if (mReceiver != null) 
      \{ 
         Log.d(LOGTAG, "scan:  PTY: " + pty); 
         if(FmSharedPreferences.isRBDSStd()) 
         \{ 
            /\* RBDS : Validate PTY value?? \*/ 
            if( ((pty  > 0) && (pty  <= 23)) || ((pty  >= 29) && (pty  <= 31)) ) 
            \{bCommandSent = mReceiver.searchStations(FmReceiver.FM\_RX\_SRCHRDS\_MODE\_SCAN\_PTY, 
                                                       FmReceiver.FM\_RX\_DWELL\_PERIOD\_2S, 
                                                       FmReceiver.FM\_RX\_SEARCHDIR\_UP, 
                                                       pty, 
                                                       0); 
            \} 
            else 
            \{ 
               bCommandSent = mReceiver.searchStations(FmReceiver.FM\_RX\_SRCH\_MODE\_SCAN, 
                                                FmReceiver.FM\_RX\_DWELL\_PERIOD\_2S, 
                                                FmReceiver.FM\_RX\_SEARCHDIR\_UP); 
            \}\} 
         else 
         \{ 
            /\* RDS : Validate PTY value?? \*/ 
            if( (pty  > 0) && (pty  <= 31) ) 
            \{ 
               bCommandSent = mReceiver.searchStations(FmReceiver.FM\_RX\_SRCHRDS\_MODE\_SCAN\_PTY, 
                                                          FmReceiver.FM\_RX\_DWELL\_PERIOD\_2S, 
                                                          FmReceiver.FM\_RX\_SEARCHDIR\_UP, 
                                                          pty, 
                                                          0); 
            \} 
            else\{ 
               bCommandSent = mReceiver.searchStations(FmReceiver.FM\_RX\_SRCH\_MODE\_SCAN, 
                                                FmReceiver.FM\_RX\_DWELL\_PERIOD\_2S, 
                                                FmReceiver.FM\_RX\_SEARCHDIR\_UP); 
            \} 
         \} 
      \} 
      return bCommandSent; 
   \}

FmReceiver类的public boolean searchStations (int mode,int dwellPeriod,intdirection,int pty,Int pi)  方法

获得FMState状态

int state = getFMState();

/ \* 验证参数\* /

调用setSearchState(subSrchLevel\_ScanInProg);

re = mControl.searchStations(sFd, mode,dwellPeriod, direction, pty, pi);

public boolean searchStations (int mode, 
                                  int dwellPeriod, 
                                  int direction)\{ 
  
      int state = getFMState();//获得FMState状态 
      boolean bStatus = true; 
      int re; 
  
      /\* Check current state of FM device \*/ 
      if (state == FMState\_Turned\_Off || state == FMState\_Srch\_InProg) \{ 
          Log.d(TAG, "searchStations: Device currently busy in executing another command."); 
          return false; 
      \} 
  
      Log.d (TAG, "Basic search..."); 
      /\* Validate the arguments \*/ 
      if ( (mode != FM\_RX\_SRCH\_MODE\_SEEK) && 
           (mode != FM\_RX\_SRCH\_MODE\_SCAN)) 
      \{ 
         Log.d (TAG, "Invalid search mode: " + mode ); 
         bStatus = false; 
      \} 
      if ( (dwellPeriod < FM\_RX\_DWELL\_PERIOD\_0S ) || 
           (dwellPeriod > FM\_RX\_DWELL\_PERIOD\_7S)) 
      \{ 
         Log.d (TAG, "Invalid dwelling time: " + dwellPeriod); 
         bStatus = false; 
      \} 
      if ( (direction != FM\_RX\_SEARCHDIR\_DOWN) && 
           (direction != FM\_RX\_SEARCHDIR\_UP)) 
      \{ 
         Log.d (TAG, "Invalid search direction: " + direction); 
         bStatus = false; 
      \} 
      if (bStatus) 
      \{ 
         Log.d (TAG, "searchStations: mode " + mode + "direction:  " + direction); 
  
         if (mode == FM\_RX\_SRCH\_MODE\_SEEK) 
             setSearchState(subSrchLevel\_SeekInPrg); 
         else if (mode == FM\_RX\_SRCH\_MODE\_SCAN) 
             setSearchState(subSrchLevel\_ScanInProg); 
         Log.v(TAG, "searchStations: CURRENT-STATE : FMRxOn ---> NEW-STATE : SearchInProg"); 
  
        re = mControl.searchStations(sFd, mode, dwellPeriod, direction, 0, 0); 
         if (re != 0) \{ 
             Log.e(TAG, "search station failed"); 
             if (getFMState() == FMState\_Srch\_InProg) 
                 setSearchState(subSrchLevel\_SrchComplete); 
             return false; 
         \}         state = getFMState(); 
         if (state == FMState\_Turned\_Off) \{ 
             Log.d(TAG, "searchStations: CURRENT-STATE : FMState\_Off (unexpected)"); 
             return false; 
         \} 
      \} 
      return bStatus; 
   \} 
设置FM搜索电源状态

static void setSearchState(int state) 
   \{ 
      mSearchState = state; 
      switch(mSearchState) \{ 
         case subSrchLevel\_SeekInPrg: 
         case subSrchLevel\_ScanInProg: 
         case subSrchLevel\_SrchListInProg: 
            setFMPowerState(FMState\_Srch\_InProg); 
            break; 
         case subSrchLevel\_SrchComplete: 
            /\* Update the state of the FM device \*/ 
            mSearchState = subSrchLevel\_NoSearch; 
            setFMPowerState(FMState\_Rx\_Turned\_On); 
            break; 
         case subSrchLevel\_SrchAbort: 
            break; 
         default: 
            mSearchState = subSrchLevel\_NoSearch; 
            break; 
      \} 
   \} 
setFMPowerState(FMState\_Rx\_Turned\_On); 是调用FmTransceiver类发射器类，FM电源状态 
/\*============================================================== 
   FUNCTION:  setFMPowerState 
   ==============================================================\*/ 
   /\*\* 
   \*    Sets the FM power state 
   \* 
   \*     
   \*    This method sets the FM power state. 
   \* 
   \*     
   \*/ 
   static void setFMPowerState(int state) 
   \{ 
      FMState = state; 
   \} 
调用FMRxControls.java类的

/ \* 配置各种搜索参数,开始搜索\* /

public int searchStations (int fd, int mode,int dwell, int dir, int pty, int pi)

设置一些参数

FmReceiverJNI.setControlNative();

设置的搜索模式

设置扫描居住的时间

设置的企业

设置PI

/\* configure various search parameters and start search \*/ 
   public int searchStations (int fd, int mode, int dwell, 
                               int dir, int pty, int pi)\{ 
      int re = 0; 
  
  
      Log.d(TAG, "Mode is " + mode + " Dwell is " + dwell); 
      Log.d(TAG, "dir is "  + dir + " PTY is " + pty); 
      Log.d(TAG, "pi is " + pi + " id " +  V4L2\_CID\_PRIVATE\_TAVARUA\_SRCHMODE); 
  
  
  
      re = FmReceiverJNI.setControlNative (fd, V4L2\_CID\_PRIVATE\_TAVARUA\_SRCHMODE, mode); 
      if (re != 0) \{ 
          Log.e(TAG, "setting of search mode failed"); 
          return re; 
      \} 
      re = FmReceiverJNI.setControlNative (fd, V4L2\_CID\_PRIVATE\_TAVARUA\_SCANDWELL, dwell); 
      if (re != 0) \{ 
          Log.e(TAG, "setting of scan dwell time failed"); 
          return re; 
      \} 
      if (pty != 0) 
      \{  re = FmReceiverJNI.setControlNative (fd, V4L2\_CID\_PRIVATE\_TAVARUA\_SRCH\_PTY, pty); 
         if (re != 0) \{ 
             Log.e(TAG, "setting of PTY failed"); 
             return re; 
         \} 
      \} 
  
      if (pi != 0) 
      \{ 
        re = FmReceiverJNI.setControlNative (fd, V4L2\_CID\_PRIVATE\_TAVARUA\_SRCH\_PI, pi); 
         if (re != 0) \{ 
             Log.e(TAG, "setting of PI failed"); 
             return re; 
         \} 
      \} 
  
      re = FmReceiverJNI.startSearchNative (fd, dir ); 
      return re; 
   \} 
启动搜索 FmReceiverJNI.startSearchNative (fd, dir );

关闭搜索

FMRadio 调用 FMRadioService 的CancelSearch()方法

public boolean cancelSearch()

public boolean cancelSearch() 
   \{ 
      boolean bCommandSent=false; 
      if (mReceiver != null) 
      \{ 
         Log.d(LOGTAG, "cancelSearch"); 
         bCommandSent = mReceiver.cancelSearch(); 
      \} 
      return bCommandSent; 
   \} 
调用FRReceiver的cancelSearch() 
mReceiver.cancelSearch()

更新搜索 FMRadio.java中

updateSearchProgress();

private void updateSearchProgress() \{ 
      boolean searchActive = isScanActive() || isSeekActive() || isSearchActive(); 
      if (searchActive) \{ 
         synchronized (this) \{ 
            if(mProgressDialog == null) \{ 
               showDialog(DIALOG\_PROGRESS\_PROGRESS); 
            \}else \{ 
               Message msg = new Message(); 
               msg.what = UPDATE\_PROGRESS\_DLG; 
               mSearchProgressHandler.sendMessage(msg); 
            \} 
         \} 
      \}else \{ 
         Message msg = new Message(); 
         msg.what = END\_PROGRESS\_DLG; 
         mSearchProgressHandler.sendMessage(msg); 
      \} 
   \}

初始化菜单  invalidateOptionsMenu();  
调用FMRxControls类的public void cancelSearch (int fd)方法

最后调用FMReceiver类的cancelSearchNative()

/\* cancel search in progress \*/ 
   public void cancelSearch (int fd)\{ 
      FmReceiverJNI.cancelSearchNative(fd); 
   \} 
最后发送一个mSearchProgressHandler 
  msg.what = END\_PROGRESS\_DLG;

mSearchProgressHandler.sendMessage(msg)

删除handler发送消息关闭对话框

private Handler mSearchProgressHandler = new Handler() \{ 
       public void handleMessage(Message msg) \{ 
           if (msg.what == UPDATE\_PROGRESS\_DLG) \{ 
              if(mProgressDialog != null) \{ 
                 double frequency = mTunedStation.getFrequency() / 1000.0; 
                 String titleStr = getString(R.string.msg\_search\_title, ("" + frequency)); 
                 mProgressDialog.setTitle(titleStr); 
              \} 
           \}else if (msg.what == END\_PROGRESS\_DLG) \{ 
              mSearchProgressHandler.removeMessages(END\_PROGRESS\_DLG); 
              mSearchProgressHandler.removeMessages(UPDATE\_PROGRESS\_DLG); 
              mSearchProgressHandler.removeMessages(TIMEOUT\_PROGRESS\_DLG); 
              removeDialog(DIALOG\_PROGRESS\_PROGRESS); 
              mProgressDialog = null; 
           \}else if (msg.what == TIMEOUT\_PROGRESS\_DLG) \{ 
              cancelSearch(); 
           \} 
       \} 
   \};

在搜索中更新FMRadioUI界面的监听类FmRxEventListner.java

public void startListner (final int fd, final FmRxEvCallbacks cb) \{ 
        /\* start a thread and listen for messages \*/ 
        mThread = new Thread()\{ 
            public void run()\{ 
                byte \[\] buff = new byte\[STD\_BUF\_SIZE\]; 
                Log.d(TAG, "Starting listener " + fd); 
  
                while ((!Thread.currentThread().isInterrupted())) \{ 
  
                    try \{ 
                        int index = 0; 
                        int state = 0; 
                        Arrays.fill(buff, (byte)0x00); 
                        int freq = 0; 
                        int eventCount = FmReceiverJNI.getBufferNative (fd, buff, EVENT\_LISTEN); 
  
                        if (eventCount >= 0) 
                            Log.d(TAG, "Received event. Count: " + eventCount); 
  
                        for (  index = 0; index < eventCount; index++ ) \{ 
                            Log.d(TAG, "Received <" +buff\[index\]+ ">" ); 
  
                            switch(buff\[index\])\{ 
                            case 0:Log.d(TAG, "Got READY\_EVENT"); 
                                if(FmTransceiver.getFMPowerState() == FmTransceiver.subPwrLevel\_FMRx\_Starting) \{ 
                                    /\*Set the state as FMRxOn \*/ 
                                    FmTransceiver.setFMPowerState(FmTransceiver.FMState\_Rx\_Turned\_On); 
                                    Log.v(TAG, "RxEvtList: CURRENT-STATE : FMRxStarting ---> NEW-STATE : FMRxOn"); 
                                    cb.FmRxEvEnableReceiver(); 
                                \} 
                                else 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"); 
                                    FmTransceiver.release("/dev/radio0"); 
                                    cb.FmRxEvDisableReceiver(); 
                                    Thread.currentThread().interrupt(); 
                                \} 
                                break;case 1: 
                                Log.d(TAG, "Got TUNE\_EVENT"); 
                                freq = FmReceiverJNI.getFreqNative(fd); 
                                state = FmReceiver.getSearchState(); 
                                switch(state) \{ 
                                   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"); 
                                        cb.FmRxEvSearchComplete(freq); 
                                        break; 
                                   default: 
                                        if (freq > 0) 
                                            cb.FmRxEvRadioTuneStatus(freq); 
                                        else 
                                            Log.e(TAG, "get frequency command failed"); 
                                        break; 
                                \} 
                                break; 
                            case 2:Log.d(TAG, "Got SEEK\_COMPLETE\_EVENT"); 
                                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"); 
                                      cb.FmRxEvSearchComplete(FmReceiverJNI.getFreqNative(fd)); 
                                      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"); 
                                      cb.FmRxEvSearchComplete(FmReceiverJNI.getFreqNative(fd)); 
                                      break; 
                                \} 
                                break; 
                            case 3:Log.d(TAG, "Got SCAN\_NEXT\_EVENT"); 
                                cb.FmRxEvSearchInProgress(); 
                                break; 
                            case 4: 
                                Log.d(TAG, "Got RAW\_RDS\_EVENT"); 
                                cb.FmRxEvRdsGroupData(); 
                                break; 
                            case 5: 
                                Log.d(TAG, "Got RT\_EVENT"); 
                                cb.FmRxEvRdsRtInfo(); 
                                break; 
                            case 6: 
                                Log.d(TAG, "Got PS\_EVENT"); 
                                cb.FmRxEvRdsPsInfo(); 
                                break; 
                            case 7: 
                                Log.d(TAG, "Got ERROR\_EVENT"); 
                                break; 
                            case 8: 
                                Log.d(TAG, "Got BELOW\_TH\_EVENT"); 
                                cb.FmRxEvServiceAvailable (false); 
                                break; 
                            case 9:Log.d(TAG, "Got ABOVE\_TH\_EVENT"); 
                                cb.FmRxEvServiceAvailable(true); 
                                break; 
                            case 10: 
                                Log.d(TAG, "Got STEREO\_EVENT"); 
                                cb.FmRxEvStereoStatus (true); 
                                break; 
                            case 11: 
                                Log.d(TAG, "Got MONO\_EVENT"); 
                                cb.FmRxEvStereoStatus (false); 
                                break; 
                            case 12: 
                                Log.d(TAG, "Got RDS\_AVAL\_EVENT"); 
                                cb.FmRxEvRdsLockStatus (true); 
                                break; 
                            case 13: 
                                Log.d(TAG, "Got RDS\_NOT\_AVAL\_EVENT"); 
                                cb.FmRxEvRdsLockStatus (false); 
                                break; 
                            case 14:Log.d(TAG, "Got NEW\_SRCH\_LIST"); 
                                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"); 
                                      cb.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"); 
                                      cb.FmRxEvSearchCancelled(); 
                                      break; 
                                \} 
                                break; 
                            case 15:Log.d(TAG, "Got NEW\_AF\_LIST"); 
                                cb.FmRxEvRdsAfInfo(); 
                                break; 
                            case 18: 
                                Log.d(TAG, "Got RADIO\_DISABLED"); 
                                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"); 
                                    FmTransceiver.release("/dev/radio0"); 
                                    cb.FmRxEvDisableReceiver(); 
                                    Thread.currentThread().interrupt(); 
                                \} else \{ 
                                    Log.d(TAG, "Unexpected RADIO\_DISABLED recvd"); 
                                    cb.FmRxEvRadioReset(); 
                                \} 
                                break; 
                            case 19:FmTransceiver.setRDSGrpMask(0); 
                                break; 
                            case 20: 
                                Log.d(TAG, "got RT plus event"); 
                                cb.FmRxEvRTPlus(); 
                                break; 
                            case 21: 
                                Log.d(TAG, "got eRT event"); 
                                cb.FmRxEvERTInfo(); 
                                break; 
                            default: 
                                Log.d(TAG, "Unknown event"); 
                                break; 
                            \} 
                        \}//end of for 
                    \} catch ( Exception ex ) \{ 
                        Log.d( TAG,  "RunningThread InterruptedException"); 
                        ex.printStackTrace(); 
                        Thread.currentThread().interrupt(); 
                    \} 
                \} 
            \} 
        \}; 
        mThread.start(); 
    \} 
Switch case取1的时候就FMReceiverJNI类中获取频率，调FmRxEvRadioTuneStatus接收读取频率  
freq= FmReceiverJNI.getFreqNative(fd);

cb.FmRxEvRadioTuneStatus(freq);

将频率保存起来

FmSharedPreferences.setTunedFrequency(frequency);

mPrefs.Save();

清除状态信息 clearStationInfo();

调用改变界面状态 mCallbacks.onTuneStatusChanged();

可用存储，设置可用模拟器 enableStereo(FmSharedPreferences.getAudioOutputMode());

public void FmRxEvRadioTuneStatus(int frequency) 
      \{ 
         Log.d(LOGTAG, "FmRxEvRadioTuneStatus: Tuned Frequency: " +frequency); 
         try 
         \{ 
            FmSharedPreferences.setTunedFrequency(frequency); 
            mPrefs.Save(); 
            //Log.d(LOGTAG, "Call mCallbacks.onTuneStatusChanged"); 
            /\* Since the Tuned Status changed, clear out the RDSData cached \*/ 
            if(mReceiver != null) \{ 
              clearStationInfo(); 
            \} 
            if(mCallbacks != null) 
            \{ 
              mCallbacks.onTuneStatusChanged(); 
            \} 
            /\* Update the frequency in the StatusBar's Notification \*/ 
            startNotification(); 
            enableStereo(FmSharedPreferences.getAudioOutputMode()); 
         \} 
         catch (RemoteException e) 
         \{ 
            e.printStackTrace(); 
         \} 
      \}

最后调到底层

FmReceiverJNI.setMonoStereoNative (fd, 1)

/\* force mono/stereo mode \*/  
   public int stereoControl(int fd, boolean stereo) \{  
   
     if (stereo)\{  
       return  FmReceiverJNI.setMonoStereoNative (fd, 1);  
     \}  
     else \{  
       return  FmReceiverJNI.setMonoStereoNative (fd, 0);  
     \}  
   
   \}

通过mCallbacks.onTuneStatusChanged();调用到FMRadio.java的内部存根类IFMRadioServiceCallbacks.stub类的public void onTuneStatusChanged()方法进行存入fm频率，数据最后调用FMRadio的resetFMStationInfoUI()刷新UI 
 public void onTuneStatusChanged() \{ 
         Log.d(LOGTAG, "mServiceCallbacks.onTuneStatusChanged: "); 
         if (mIsScaning) \{ 
             Log.d(LOGTAG, "isScanning...................."); 
             SharedPreferences sp = getSharedPreferences(SCAN\_STATION\_PREFS\_NAME, 0); 
             SharedPreferences.Editor editor = sp.edit(); 
             int station\_number = sp.getInt(NUM\_OF\_STATIONS, 0); 
             station\_number++; 
             editor.putInt(NUM\_OF\_STATIONS, station\_number); 
             editor.putString(STATION\_NAME + station\_number, station\_number + ""); 
             editor.putInt(STATION\_FREQUENCY + station\_number, 
                                   FmSharedPreferences.getTunedFrequency()); 
             editor.commit(); 
         \} 
         cleanupTimeoutHandler(); 
         mHandler.post(mUpdateStationInfo); 
         mHandler.post(mOnStereo); 
      \}

发送一handler跟新UI,调用此回调方法Runnable mUpdateStationInfo = new Runnable() 
 Runnable mUpdateStationInfo = new Runnable() \{ 
      public void run() \{ 
         cleanupTimeoutHandler(); 
         PresetStation station = new PresetStation("", FmSharedPreferences.getTunedFrequency()); 
         if (station != null) \{ 
             mTunedStation.Copy(station); 
         \} 
         updateSearchProgress(); 
         resetFMStationInfoUI(); 
      \} 
   \}; 
updateStationInfoToUI()；

private void updateStationInfoToUI() \{ 
      double frequency = mTunedStation.getFrequency() / 1000.0; 
      mTuneStationFrequencyTV.setText("" + frequency + "MHz"); 
      if ((mPicker != null) && mUpdatePickerValue) \{ 
          mPicker.setValue(((mTunedStation.getFrequency() - mPrefs.getLowerLimit()) 
                              / mPrefs.getFrequencyStepSize())); 
      \} 
      mStationCallSignTV.setText(mTunedStation.getPIString()); 
      mProgramTypeTV.setText(mTunedStation.getPtyString()); 
      mRadioTextTV.setText(""); 
      mERadioTextTV.setText(""); 
      mRadioTextScroller.mOriginalString = ""; 
      mRadioTextScroller.mStringlength = 0; 
      mRadioTextScroller.mIteration = 0; 
      mERadioTextScroller.mOriginalString = ""; 
      mERadioTextScroller.mStringlength = 0; 
      mERadioTextScroller.mIteration = 0; 
      mProgramServiceTV.setText(""); 
      mStereoTV.setText(""); 
      setupPresetLayout(); 
   \} 
FM启动和关闭搜索都是通过JNI调到底层实现，代码路径是：vendor\\qcom\\opensource\\fm\\jni 
android\_hardware\_fm.cpp

/\*  
 \* JNI registration.  
 \*/  
static JNINativeMethod gMethods\[\] = \{  
        /\* name, signature, funcPtr \*/  
        \{ "acquireFdNative", "(Ljava/lang/String;)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_acquireFdNative\},  
        \{ "closeFdNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_closeFdNative\},  
        \{ "getFreqNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getFreqNative\},  
        \{ "setFreqNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setFreqNative\},  
        \{ "getControlNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getControlNative\},  
        \{ "setControlNative", "(III)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setControlNative\},  
        \{ "startSearchNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_startSearchNative\},  
        \{ "cancelSearchNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_cancelSearchNative\}, \{ "getRSSINative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getRSSINative\},  
        \{ "setBandNative", "(III)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setBandNative\},  
        \{ "getLowerBandNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getLowerBandNative\},  
        \{ "getUpperBandNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getUpperBandNative\},  
        \{ "getBufferNative", "(I\[BI)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getBufferNative\},  
        \{ "setMonoStereoNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setMonoStereoNative\},  
        \{ "getRawRdsNative", "(I\[BI)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_getRawRdsNative\},  
       \{ "setNotchFilterNative", "(IIZ)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setNotchFilterNative\},  
        \{ "startRTNative", "(ILjava/lang/String;I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_startRTNative\},  
        \{ "stopRTNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_stopRTNative\},  
        \{ "startPSNative", "(ILjava/lang/String;I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_startPSNative\},  \{ "stopPSNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_stopPSNative\},  
        \{ "setPTYNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setPTYNative\},  
        \{ "setPINative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setPINative\},  
        \{ "setPSRepeatCountNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setPSRepeatCountNative\},  
        \{ "setTxPowerLevelNative", "(II)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setTxPowerLevelNative\},  
       \{ "setAnalogModeNative", "(Z)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_setAnalogModeNative\},  
        \{ "SetCalibrationNative", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_SetCalibrationNative\},  
        \{ "configureSpurTable", "(I)I",  
            (void\*)android\_hardware\_fmradio\_FmReceiverJNI\_configureSpurTable\},  
   
\};  
上面写明了从jni的调用关系。具体的函数实现，请到Android\_hardware\_fm.cpp中去查看。我就不一一写出来了。以上就是FM搜索频率与取消搜索频率的操作与实现。搜索到频率后就可以听FM了。

[Center]: /images/20220407/e94afa14a23e44a38f93f06b6b1efa22.png
[Center 1]: /images/20220407/516be6998a0b4ef9b27d36b662cd592a.png
[Center 2]: /images/20220407/3c4cc2a523474365ba110169aa9db3e4.png
[Center 3]: /images/20220407/820022019d164f36957eeb07bfd1f23e.png
[Center 4]: /images/20220407/fbe32380d6684678b976037b995d8ed7.png
[Center 5]: /images/20220407/fcee77ec2a1f4db0b174eb9454353eaf.png