Android FM模块学习之源码分析（六）

最新推荐文章于 2024-04-10 20:16:33 发布
最新推荐文章于 2024-04-10 20:16:33 发布
阅读量2.1k 收藏 3
点赞数 1
分类专栏： 移动 开发 文章标签： Android FM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tfslovexizi/article/details/42393371
版权

现在是2015年1月啦，得改口说去年了，去年抽时间整理了一些FM模块的主要源码类的东西，今年再整理一下几个次要的类的源码。这样来看FM上层的东西不是太多。

请看android\vendor\qcom\opensource\fm\fmapp2\src\com\caf\fmradio\Settings.java

protected void onCreate(BundlesavedInstanceState) 从FMRadio.java用使用Intent跳转携带参数过来，在onCreate获取携带数据。

<span style="font-family:KaiTi_GB2312;font-size:18px;">protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          Intent intent = getIntent();
          if (intent != null) {
              mRxMode = intent.getBooleanExtra(RX_MODE, false);
          }
          mPrefs = new FmSharedPreferences(this);
          if (mPrefs != null) {
              setPreferenceScreen(createPreferenceHierarchy());
          }
        }</span>

private PreferenceScreen createPreferenceHierarchy() 初始化创建收音机设置里显示控件

 

<span style="font-family:KaiTi_GB2312;font-size:18px;">private PreferenceScreen createPreferenceHierarchy() {
          int index = 0;
          if (mPrefs == null) {
              return null;
          }
          // Root
          PreferenceScreen root = getPreferenceManager().createPreferenceScreen(
                                this);

           summaryBandItems = getResources().getStringArray(
                                R.array.regional_band_summary);
           chSpacingItems = getResources().getStringArray(
                                R.array.channel_spacing_entries);
           mBandPreference = new ListPreference(this);
           mBandPreference.setEntries(R.array.regional_band_entries);
           mBandPreference.setEntryValues(R.array.regional_band_values);
           mBandPreference.setDialogTitle(R.string.sel_band_menu);
           mBandPreference.setKey(REGIONAL_BAND_KEY);
           mBandPreference.setTitle(R.string.regional_band);index = FmSharedPreferences.getCountry();
           Log.d(LOGTAG, "createPreferenceHierarchy: Country: " + index);
           // Get the preference and list the value.
           if ((index < 0) || (index >= summaryBandItems.length)) {
                index = 0;
           }
           mBandPreference.setValueIndex(index);
           root.addPreference(mBandPreference);

           mChannelSpacingPref = new ListPreference(this);
           mChannelSpacingPref.setEntries(R.array.channel_spacing_entries);
           mChannelSpacingPref.setEntryValues(R.array.channel_spacing_val);
           mChannelSpacingPref.setDialogTitle(R.string.sel_chanl_spacing);
           mChannelSpacingPref.setTitle(R.string.chanl_spacing);
           mChannelSpacingPref.setKey(CHAN_SPACING_KEY);

           mUserBandMinPref = new EditTextPreference(this);
           mUserBandMinPref.setKey(USER_DEFINED_BAND_MIN_KEY);
           mUserBandMinPref.setTitle(R.string.usr_def_band_min);
           mUserBandMinPref.getEditText().setInputType(InputType.TYPE_CLASS_NUMBER |
                                                        InputType.TYPE_NUMBER_FLAG_DECIMAL);
           mUserBandMinPref.setDialogTitle(R.string.usr_def_band_min);

           mUserBandMaxPref = new EditTextPreference(this);
           mUserBandMaxPref.setKey(USER_DEFINED_BAND_MAX_KEY);
           mUserBandMaxPref.setTitle(R.string.usr_def_band_max);
           mUserBandMaxPref.setDialogTitle(R.string.usr_def_band_max);
           mUserBandMaxPref.getEditText().setInputType(InputType.TYPE_CLASS_NUMBER |
                                                        InputType.TYPE_NUMBER_FLAG_DECIMAL);

           setBandSummary(index);
 
           if (mRxMode) {
               // Audio Output (Stereo or Mono)
               summaryAudioModeItems = getResources().getStringArray(
                                        R.array.ster_mon_entries);
               mAudioPreference = new ListPreference(this);
               mAudioPreference.setEntries(R.array.ster_mon_entries);
               mAudioPreference.setEntryValues(R.array.ster_mon_values);
               mAudioPreference.setDialogTitle(R.string.sel_audio_output);
               mAudioPreference.setKey(AUDIO_OUTPUT_KEY);
               mAudioPreference.setTitle(R.string.aud_output_mode);
               boolean audiomode = FmSharedPreferences.getAudioOutputMode();
               if (audiomode) {
                   index = 0;
               } else {
                   index = 1;
               }
               Log.d(LOGTAG, "createPreferenceHierarchy: audiomode: " + audiomode);
               mAudioPreference.setSummary(summaryAudioModeItems[index]);
               mAudioPreference.setValueIndex(index);
 
               // AF Auto Enable (Checkbox)
               mAfPref = new CheckBoxPreference(this);
               mAfPref.setKey(AUTO_AF);
               mAfPref.setTitle(R.string.auto_select_af);
               mAfPref.setSummaryOn(R.string.auto_select_af_enabled);
               mAfPref.setSummaryOff(R.string.auto_select_af_disabled);
               boolean bAFAutoSwitch = FmSharedPreferences.getAutoAFSwitch();
               Log.d(LOGTAG, "createPreferenceHierarchy: bAFAutoSwitch: "
                              + bAFAutoSwitch);
               mAfPref.setChecked(bAFAutoSwitch);
               root.addPreference(mAfPref);

             if(FMRadio.RECORDING_ENABLE) {
                  summaryRecordItems = getResources().getStringArray(
                   R.array.record_durations_entries);
                int nRecordDuration = 0;
                mRecordDurPreference = new ListPreference(this);
                mRecordDurPreference.setEntries(R.array.record_durations_entries);
                mRecordDurPreference.setEntryValues(R.array.record_duration_values);
                mRecordDurPreference.setDialogTitle(R.string.sel_rec_dur);
                mRecordDurPreference.setKey(RECORD_DURATION_KEY);
                mRecordDurPreference.setTitle(R.string.record_dur);
                nRecordDuration = FmSharedPreferences.getRecordDuration();
                Log.d(LOGTAG, "createPreferenceHierarchy: recordDuration: "
                        + nRecordDuration);
                switch(nRecordDuration) {
                case FmSharedPreferences.RECORD_DUR_INDEX_0_VAL:
                     index = 0;
                     break;
                case FmSharedPreferences.RECORD_DUR_INDEX_1_VAL:
                     index = 1;
                     break;
                case FmSharedPreferences.RECORD_DUR_INDEX_2_VAL:
                     index = 2;
                     break;
                case FmSharedPreferences.RECORD_DUR_INDEX_3_VAL:
                     index = 3;
                     break;
                }
                // Get the preference and list the value.
                if ((index < 0) || (index >= summaryRecordItems.length)) {
                   index = 0;
                }
                Log.d(LOGTAG, "createPreferenceHierarchy: recordDurationSummary: "
                    + summaryRecordItems[index]);
                mRecordDurPreference.setSummary(summaryRecordItems[index]);
                mRecordDurPreference.setValueIndex(index);
                root.addPreference(mRecordDurPreference);
             }
          }
          mRestoreDefaultPreference = new Preference(this);
          mRestoreDefaultPreference.setTitle(
                                       R.string.settings_revert_defaults_title);
          mRestoreDefaultPreference.setKey(RESTORE_FACTORY_DEFAULT);
          mRestoreDefaultPreference
                                .setSummary(R.string.settings_revert_defaults_summary);
          mRestoreDefaultPreference.setOnPreferenceClickListener(this);
          root.addPreference(mRestoreDefaultPreference);
          return root;
        }

</span><span style="font-family:KaiTi_GB2312;font-size:18px;">
</span>

 

public void clearStationList()清除显示列表的电台。

<span style="font-family:KaiTi_GB2312;font-size:18px;">public void clearStationList() {
          SharedPreferences sp = getSharedPreferences(FMRadio.SCAN_STATION_PREFS_NAME, 0);
          SharedPreferences.Editor editor = sp.edit();
          editor.clear();
          editor.commit();
        }</span>

public void onSharedPreferenceChanged(SharedPreferencessharedPreferences, String key) ListPerences的监听事件，电台信息改变

 

<span style="font-family:KaiTi_GB2312;font-size:18px;">public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
                        String key) {
          int mTunedFreq = 0;
          boolean bStatus = false;
          if (key.equals(REGIONAL_BAND_KEY)) {
              int curListIndex = FmSharedPreferences.getCurrentListIndex();
              PresetList curList = FmSharedPreferences.getStationList(curListIndex);
              String valueStr = sharedPreferences.getString(key, "");
              int index = 0;
              if(valueStr != null) {
                  index = mBandPreference.findIndexOfValue(valueStr);
              }
              if((index < 0) || (index >= summaryBandItems.length)) {
                  index = 0;
                  mBandPreference.setValueIndex(0);
              }else if((index + 1) == summaryBandItems.length) {
                   mChannelSpacingPref.setEnabled(true);
              }else {
                   mChannelSpacingPref.setEnabled(false);
              }
              Log.d(LOGTAG, "onSharedPreferenceChanged: Country Change: "
                                                        + index);
              FmSharedPreferences.setCountry(index);
              setBandSummary(index);
              sendSettingsChangedIntent(FM_BAND_CHANGED);
              if (curList != null) {
                  curList.clear();
              }
              clearStationList();
           }else if(key.equals(CHAN_SPACING_KEY)) {
               int curListIndex = FmSharedPreferences.getCurrentListIndex();
               PresetList curList = FmSharedPreferences.getStationList(curListIndex);
               String valStr = mChannelSpacingPref.getValue();
               int index = 0;
               if(valStr != null) {
                  index  = mChannelSpacingPref.findIndexOfValue(valStr);
               }
               if ((index < 0) || (index >= chSpacingItems.length)) {
                   index = 0;
                   mChannelSpacingPref.setValueIndex(0);
               }
               mChannelSpacingPref.setSummary(chSpacingItems[index]);
               FmSharedPreferences.setChSpacing(2 - index);
               sendSettingsChangedIntent(FM_CHAN_SPACING_CHANGED);
               if(curList != null) {
                  curList.clear();
               }
               clearStationList();}else if(key.equals(USER_DEFINED_BAND_MIN_KEY)) {
               String valStr = mUserBandMinPref.getText();
               double freq = 0;
               try {
                    freq = Double.parseDouble(valStr) * 1000;
               }catch(NumberFormatException e) {
                    e.printStackTrace();
                    return;
               }
               max_freq = FmSharedPreferences.getUpperLimit();
               min_freq = FmSharedPreferences.getLowerLimit();
               if((freq > 0) && (freq < max_freq) && (freq >= 76000)) {
                  FmSharedPreferences.setLowerLimit((int)freq);
                  sendSettingsChangedIntent(FM_BAND_CHANGED);
                  setBandSummary(summaryBandItems.length - 1);
                  clearStationList();
               }else {
                  Toast.makeText(this, getString(R.string.user_defind_band_msg),
                                                            Toast.LENGTH_SHORT).show();
               } }else if(key.equals(USER_DEFINED_BAND_MAX_KEY)) {
               String valStr = mUserBandMaxPref.getText();
               double freq = 0;
               try {
                    freq = Double.parseDouble(valStr) * 1000;
               }catch(NumberFormatException e) {
                    e.printStackTrace();
                    return;
               }
               min_freq = FmSharedPreferences.getLowerLimit();
               max_freq = FmSharedPreferences.getUpperLimit();
               if((freq > 0) && (freq > min_freq) && (freq <= 108000)) {
                  FmSharedPreferences.setUpperLimit((int)freq);
                  sendSettingsChangedIntent(FM_BAND_CHANGED);
                  setBandSummary(summaryBandItems.length - 1);
                  clearStationList();
               }else {
                  Toast.makeText(this, getString(R.string.user_defind_band_msg),
                                                            Toast.LENGTH_SHORT).show();
               }
          }else {
              if(mRxMode) { if (key.equals(AUTO_AF)) {
                     boolean bAFAutoSwitch = mAfPref.isChecked();
                     Log.d(LOGTAG, "onSharedPreferenceChanged: Auto AF Enable: "
                                               + bAFAutoSwitch);
                     FmSharedPreferences.setAutoAFSwitch(bAFAutoSwitch);
                     mPrefs.Save();
                     sendSettingsChangedIntent(FM_AF_OPTION_CHANGED);
                 }else if(key.equals(RECORD_DURATION_KEY)) {
                     if(FMRadio.RECORDING_ENABLE) {
                        String valueStr = mRecordDurPreference.getValue();
                        int index = 0;
                        if (valueStr != null) {
                            index = mRecordDurPreference.findIndexOfValue(valueStr);
                        }
                          if ((index < 0) || (index >= summaryRecordItems.length)) {
                             index = 0;
                             mRecordDurPreference.setValueIndex(index);
                        }
                        Log.d(LOGTAG, "onSharedPreferenceChanged: recorddur: "
                                     + summaryRecordItems[index]);
                          mRecordDurPreference.setSummary(summaryRecordItems[index]);
                          FmSharedPreferences.setRecordDuration(index);
                       }
                   } else if (key.equals(AUDIO_OUTPUT_KEY)) {String valueStr = mAudioPreference.getValue();
                       int index = 0;
                       if (valueStr != null) {
                           index = mAudioPreference.findIndexOfValue(valueStr);
                       }
                       if (index != 1) {
                          if (index != 0) {
                              index = 0;
                              /* It shud be 0(Stereo) or 1(Mono) */
                              mAudioPreference.setValueIndex(index);
                          }
                       }
                       Log.d(LOGTAG, "onSharedPreferenceChanged: audiomode: "
                                      + summaryAudioModeItems[index]);
                       mAudioPreference.setSummary(summaryAudioModeItems[index]);
                     if (index == 0) {
                         // Stereo
                         FmSharedPreferences.setAudioOutputMode(true);
                     }else {
                         // Mono
                         FmSharedPreferences.setAudioOutputMode(false);
                     }
                     mPrefs.Save();
                     sendSettingsChangedIntent(FM_AUDIO_MODE_CHANGED);
                 }
              }
          }
          if (mPrefs != null) {
              if(bStatus) {
                 mPrefs.Save();
              }else {
                 mTunedFreq = FmSharedPreferences.getTunedFrequency();
                 if (mTunedFreq > FmSharedPreferences.getUpperLimit() ||
                          mTunedFreq < FmSharedPreferences.getLowerLimit()) {
                     FmSharedPreferences.setTunedFrequency(
                          FmSharedPreferences.getLowerLimit());
                 }
                 mPrefs.Save();
              }
          }
        }</span>

public boolean onPreferenceClick(Preferencepreference) 收音机恢复出厂设置监听事件

，后fm播放状态显示对话框，调用restoreSettingsDefault()存入初始化数据。

 

<span style="font-family:KaiTi_GB2312;font-size:18px;">public boolean onPreferenceClick(Preference preference) {
          boolean handled = false;
          if (preference == mRestoreDefaultPreference) {
              showDialog(RESTORE_FACTORY_DEFAULT_INT);
          }
          return handled;
        }</span>

ListPreferences属性注册：

<span style="font-family:KaiTi_GB2312;font-size:18px;"> private void restoreSettingsDefault() {
          if (mPrefs != null) {
             if (Locale.getDefault().equals(Locale.CHINA)) {
                 mBandPreference
                        .setValueIndex(FmSharedPreferences.REGIONAL_BAND_CHINA);
		}else{				
                 mBandPreference
                        .setValueIndex(FmSharedPreferences.REGIONAL_BAND_INDONESIA);
             }
             if (mRxMode) { mAudioPreference.setValueIndex(0);
                if (FMRadio.RECORDING_ENABLE) {
                    mRecordDurPreference.setValueIndex(0);
                }
                mAfPref.setChecked(true);
                FmSharedPreferences.SetDefaults();
             }else {
                if (Locale.getDefault().equals(Locale.CHINA)) {
                    FmSharedPreferences
                    .setCountry(FmSharedPreferences.REGIONAL_BAND_CHINA);				
             }else{FmSharedPreferences
                    .setCountry(FmSharedPreferences.REGIONAL_BAND_INDONESIA);
                }
             }
             mPrefs.Save();
          }
        }</span>

onResume()方法

<span style="font-family:KaiTi_GB2312;font-size:18px;"> protected void onResume() {
          super.onResume();
          PreferenceScreen preferenceScreen = getPreferenceScreen();
          SharedPreferences sharedPreferences = null;
          if (preferenceScreen != null) {
              sharedPreferences = preferenceScreen.getSharedPreferences();
          }
          if (sharedPreferences != null) {
              sharedPreferences.registerOnSharedPreferenceChangeListener(this);
          }
        }</span>

haredPreferences.registerOnSharedPreferenceChangeListener(this);进行注册

 

protected void onPause()方法

<span style="font-family:KaiTi_GB2312;font-size:18px;">protected void onPause() {
          super.onPause();
          PreferenceScreen preferenceScreen = getPreferenceScreen();
          SharedPreferences sharedPreferences = null;
          if (preferenceScreen != null) {
              sharedPreferences = preferenceScreen.getSharedPreferences();
          }
          if (sharedPreferences != null) {
              sharedPreferences.unregisterOnSharedPreferenceChangeListener(this);
          }
        }</span>

sharedPreferences.unregisterOnSharedPreferenceChangeListener(this);卸载注册

 

private void setBandSummary(int index) 设置ListPreference控件选择地区频率范围后现实在控件上

<span style="font-family:KaiTi_GB2312;font-size:18px;">private void setBandSummary(int index) {
           if((index + 1) == summaryBandItems.length) {
              min_freq = FmSharedPreferences.getLowerLimit();
              max_freq = FmSharedPreferences.getUpperLimit();
              chan_spacing = FmSharedPreferences.getChSpacing();
              if(chan_spacing < 0) {
                 chan_spacing = 0;
              }
              mBandPreference.setSummary(summaryBandItems[index] + "( "
                       + (min_freq / 1000.0) +"Mhz To " + (max_freq / 1000.0) +
                       "Mhz)");
              mChannelSpacingPref.setValueIndex(2 - chan_spacing);
              mChannelSpacingPref.setSummary(chSpacingItems[2 - chan_spacing]);
              mChannelSpacingPref.setEnabled(true);
              mUserBandMinPref.setEnabled(true);mUserBandMaxPref.setEnabled(true);
              mUserBandMinPref.setSummary((min_freq / 1000.0) + "Mhz");
              mUserBandMaxPref.setSummary((max_freq / 1000.0) + "Mhz");
           }else {
              mBandPreference.setSummary(summaryBandItems[index]);
              mChannelSpacingPref.setEnabled(false);
              mUserBandMinPref.setEnabled(false);
              mUserBandMaxPref.setEnabled(false);
           }
        }</span>

 private void displayToast(String msg)实现Toast提示

<span style="font-family:KaiTi_GB2312;font-size:18px;">private void displayToast(String msg) {
           Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_LONG).show();
        }</span>

private void sendSettingsChangedIntent(intaction) 发送广播action活动状态，在FMRadio.java的registerFMSettingListner()方法接受（每次走FMRadio.java的activity都会接受下广播）。

<span style="font-family:KaiTi_GB2312;font-size:18px;">private void sendSettingsChangedIntent(int action) {
           Intent intent = new Intent(ACTION_FM_SETTING);
           intent.putExtra("state", action);
           Log.d(LOGTAG, "Sending  FM SETTING Change intent for = " + action);
           getApplicationContext().sendBroadcast(intent);
        }</span>
护士leo
关注
专栏目录
Android 小钢琴源码.zip
07-19
六、源码分析 在“源码的重要性.txt”文件中，可能会详细解释源码组织结构，各模块功能，以及关键类和方法的作用。阅读源码可以帮助我们理解开发者如何实现上述功能，如何优化性能，以及如何处理各种异常情况。 ...
Android FM模块学习之二 FM搜索频率流程
若然的专栏
11-20 7320
上一篇大概分析了一下FM启动流程，若不了解Fm启动流程的，可以去打开前面的链接先了解FM启动流程，接下来我们简单分析一下FM的搜索频率流程。 在了解源码之前，我们先看一下流程图：     其实从图中可以看到，实现搜索频率的功能是在底层CPP文件，java层只操作和更新一些界面（GUI），Java调用JNI实现功能。Java app基本核心，通过方法回调实现a类和b类方法，b类调a类方法信息
Android FM模块学习之四源码分析（七）
若然的专栏
01-04 1843
接上一篇，现在分析android\vendor\qcom\opensource\fm\fmapp2\src\com\caf\fmradio\StationListActivity.java protectedvoid onCreate(Bundle savedInstanceState)方法里 绑定FMRadioService服务 bindService((newIntent()).se
Android监听
pulledup的博客
10-18 4243
Android监听 Android监听接收到短信的广播事件_百度搜索 https://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&wd=Android%E7%9B%91%E5%90%AC%E6%8E%A5%E6%94%B6%E5%88%B0%E7%9F%AD%E4%BF%A1%E7%9A%84%E5%B9%BF%E6%92%AD%E4%BA%8B%E4%BB%B6&fenlei=256&.
mt6735 [Audio APP]如何监听手机上面音乐 /FM等多媒体声音的播放/停止的动作？
szx940213的博客
11-14 887
如何监听手机上面音乐/FM等多媒体声音的播放/停止的动作？
android FM手动调频流程
成长的味道
02-19 2319
首先来看一下流程图： 2.滑动刻度盘HorizontalNumberPicker控件在监听事件里使用方法valueToFrequency(newVal) 1.长按左右箭头居中的频率字符串，弹出FrequencyPickerDialog调频对话框确定调用tuneRadio(frequency)调频。 获取到频率 [java] vie
android调频收音机源码
12-11
通过分析这个"android调频收音机源码"，开发者可以学习到Android音频处理、硬件交互、用户界面设计以及系统级服务的运用等多方面的知识，并能将其应用于实际项目中，提升自己的Android开发能力。
QingTingRadio:蜻蜓FM源码解析
03-23
源码分析可以从以下几个方面展开： 1. **应用程序架构**：蜻蜓FM可能采用模块化设计，包括用户界面、音频播放器、网络请求、数据库管理等多个组件。理解这些模块如何协同工作，可以帮助我们学习到软件工程的最佳...
FM收音机源码
04-16
1. **硬件接口**：MTK6589芯片集成了FM调谐器模块，开发者需要通过特定的硬件接口与之通信，以控制FM接收器的频率设置、音量调节、扫描等功能。这通常涉及I2C或SPI等总线协议。 2. **FM解调**：FM信号的解调是收音...
基于Android的Viewpager实现滑屛切换界面应用设计与实现1(源码)
最新发布
05-29
通过对源码的分析和学习，开发者可以更好地理解`ViewPager`的工作原理，以及如何在实际项目中优化其性能和用户体验。 总之，`ViewPager`是Android开发中不可或缺的组件，它使得多页面间的平滑过渡成为可能。通过...
android 收音机 FM 驱动 hal层 框架层以及应用层代码
06-11
android 收音机 FM 驱动 hal层 框架层以及应用层代码 方法一 不需要framework部分 1.fm放到 \hardware\rk2x 2.FmRadio 放到 packages\apps 3.hardware\libhardware\include\hardware\fm.h 放到hardware\libhardware\include\hardware\fm.h 4.build\target\product中PRODUCT_PACKAGES :=加上 FmRadio \ 5./bionic/libc/kernel/common/linux/Hw_fm.h拷贝过去 6./device/rockchip/rksdk/device.mk中加入PRODUCT_PACKAGES += fm.$(TARGET_BOARD_HARDWARE)让\hardware\rk2x\fm能够编译到 7.device\rockchip\rksdk\init.rc中加上权限chmod 0664 /dev/RADIO_FM8035 chown system system /dev/RADIO_FM8035这样Rk28_fm.c (hardware\rk2x\fm\primitive)中int fm_init(sighandler_t fm_sighandler) 方法二需要在上面移植以后多加framework的内容
FM源码（适合对流程的分析）
08-08
app层及对底层的调用（适合对流程的分析） 可以加深对AIDL和JNI理解
Android Fm radio
03-21
It is a document about fm radio in android.
Android利用系统广播---监听应用程…
星痕_Raphael
04-18 585
第一、 新建监听类：BootReceiver继承BroadcastReceiver Java代码   public class BootReceiver extends BroadcastReceiver {           @Override       public void onReceive(Context context, Intent intent) 
Android FM流程分析
liu362732346的博客
10-29 2051
一，FM主要类介绍 FmMainActivity.java 主界面 FmService.java 核心 FmNative.java 调用JNI和底层通信 二，FM主要功能介绍 1，收音播放： 1 ) 搜台 2）收藏 3）耳机/外放播放 4) 切台 5）定时关闭 6）飞行模式 2，录音播放 三，流程分析 1，不插入耳机...
手机银行客户端框架之TMF框架介绍
银行信息系统应用架构导论
04-10 1931
腾讯移动开发平台（Tencent Mobile Framework）整合了腾讯在移动产品中开发、测试、发布和运营的技术能力，为企业提供一站式、覆盖全生命周期的移动端技术平台。核心服务包括移动客户端开发组件、H5容器、灰度发布、热更新、离线包、网关服务、消息推送、数据同步、移动分析、移动监控、应用加固、环境安全检测等移动端开发运营关键服务，帮助企业低成本、高效率地打造移动服务。
删除系统应用 FMRadio，QuickSearchBox，或增加应用
youthking1314的博客
12-22 419
删除系统应用 FMRadio，QuickSearchBox，或增加应用
【Android项目】本地FM收音机开发及源码简析
热门推荐
bobo_zai的博客
08-31 1万+
【Android项目】本地FM收音机开发及源码简析 目录 1.概述 2.收音机的基本原理 3.收音机其他信息 RDS功能 4.Android开发FM收音机源码解析 5.App层如何设计本地FM应用 6. 总结 1.概述 本地FM（收音机）应用不同于现在的网络FM（喜马拉雅，考拉等），是由Android手机硬件的调谐芯片，通过接收和解调电台发出的电磁波的调频(FM)或调...
Android FM模块学习之一 FM启动流程
若然的专栏
11-19 9055
最近在学习FM模块，FM是一个值得学习的模块，可以从上层看到底层。上层就是FM的按扭操作和界面显示，从而调用到FM底层驱动来实现广播收听的功能。    看看Fm启动流程：如下图： 先进入FMRadio.java类，onCreate初始化一些数据，画出FM界面，启动fm在onStart()方法里启动FMRadioService.java (调用bindToService(this,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值