Android 监听双卡信号强度

监听单卡信号强度

  1. 监听单卡的信号强度非常简单直接用TelephonyManager.listen()去监听sim卡的信号强度.
  1. TelephonyManager = mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE)
  2. mTelephonyManager.listen(new PhoneStateListener(), PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);

单这只是针对单卡的时候, 现在手机基本标配双卡, 如果要监测sim卡的信号强度就要考虑到双卡, 然而百度了一下, 并没有博文去介绍怎么去监测双卡, 这下只能靠自己了.

监测sim卡1的信号强度

  1. //SubscriptionManager  该类主要包含了所有sim卡的信息
  2. SubscriptionManager mSubscriptionManager = SubscriptionManager.from(mContext);
  3. //获取sim卡1的信息
  4. SubscriptionInfo sub0 = mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(0);
  6. if(null != sub0) {
  7.     //如果不为空 说明sim卡1存在
  8.     /*
  9.         sub0.getSubscriptionId() 获取sim卡1的 subId
  10.     */
  11.     Sim1SignalStrengthsListener mSim1SignalStrengthsListener = new Sim1SignalStrengthsListener(sub0.getSubscriptionId());
  12.     //开始监听
  13.      mTelephonyManager.listen(mSim1SignalStrengthsListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
  14. }

上面只是设置并开始监听, 具体去监听哪一个sim卡的, 还需要具体去看 Sim1SignalStrengthsListener 中对 subId 的具体处理

PhoneStateListener 类中有一个成员变量 mSubId , 这个值就是当前默认操作的sim卡, 如果不明确指定, 默认值就是 SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, 看PhoneStateListener在有带参构造设置subId, 但是都是hide隐藏, 既然无法初始化去设置subId, 那么我们就用Java强大的功能”反射”去设置mSubId的值, 设置完成之后, PhoneStateListener 就成了我们指定监测的sim卡了.

  1. /*
  2.   * Subscription used to listen to the phone state changes
  3.   * @hide
  4.   */
  5.  /** @hide */
  6.  protected int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
  8.  /**
  9.   * Create a PhoneStateListener for the Phone with the default subscription
  10.   * using a particular non-null Looper.
  11.   * @hide
  12.   */
  13.  public PhoneStateListener(Looper looper) {
  14.      this(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, looper);
  15.  }
  16. /**
  17.   * Create a PhoneStateListener for the Phone using the specified subscription
  18.   * and non-null Looper.
  19.   * @hide
  20.   */
  21.  public PhoneStateListener(int subId, Looper looper) {
  22.   ...
  23.  }
  1.  public static final int DEFAULT_SUBSCRIPTION_ID = Integer.MAX_VALUE;
  • 1
  1. class Sim1SignalStrengthsListener extends PhoneStateListener {
  3.         public Sim1SignalStrengthsListener(int subId) {
  4.             super();
  5.             ReflectUtil.setFieldValue(this, "mSubId", subId);
  6.         }
  8.         @Override
  9.         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
  10.             super.onSignalStrengthsChanged(signalStrength);
  11.             int level = getSignalStrengthsLevel(signalStrength);
  12.         }
  13.     }

反射代码 ReflectUtil

  3. public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
  4.   Field field = getAccessibleField(obj, fieldName);  
  6.   if (field == null) {
  7.       throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
  8.   }  
  10.   try {
  11.       field.set(obj, value);
  12.   } catch (IllegalAccessException e) {
  13.     e.printStackTrace();
  14.   }
  15. }  
  17. public static Field getAccessibleField(final Object obj, final String fieldName) {
  18.   if (obj == null) {
  19.       throw new IllegalArgumentException("object can't be null");
  20. }
  22.   if (fieldName == null || fieldName.length() <= 0) {
  23. throw new IllegalArgumentException("fieldName can't be blank");
  24. }
  26.   for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) {
  27.       try {
  28.           Field field = superClass.getDeclaredField(fieldName);
  29.           makeAccessible(field);
  30.           return field;
  31.       } catch (NoSuchFieldException e) {
  32.           continue;
  33.       }
  34.   }
  35.   return null;
  36. } 
  38. public static void makeAccessible(Field field) {
  39.       if ((!Modifier.isPublic(field.getModifiers()) ||!Modifier.isPublic(field.getDeclaringClass().getModifiers()) || Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
  40.          field.setAccessible(true);
  41.       }
  42. }

监测sim卡2的信号强度

获取sim卡2的信息, 其他同sim卡1

  1. ...
  2. SubscriptionInfo sub0 = mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(1);
  3. ...
  • 1

附完整代码

  1. /**
  2.  * 手机信号监控(双卡)
  3.  * Created by zengyan on 2016/6/29.
  4.  */
  5. public class SignalStrengthsHandler {
  7.     public static final String TAG = "SignalStrengthsManager";
  8.     public static final int INDEX_SIM1 = 0;
  9.     public static final int INDEX_SIM2 = 1;
  10.     private static SignalStrengthsHandler mInstance = null;
  11.     public static byte[] mLock = new byte[0];
  12.     private final Context mContext;
  13.     private final TelephonyManager mTelephonyManager;
  14.     private final SubscriptionManager mSubscriptionManager;
  15.     private final SimStateReceive mSimStateReceiver;
  17.     private SimSignalInfo mSim1SignalInfo = new SimSignalInfo();
  18.     private SimSignalInfo mSim2SignalInfo = new SimSignalInfo();
  20.     private ArrayList<OnSignalStrengthsChangedListener> mOnSignalStrengthsChangedListeners = null;
  21.     private Sim1SignalStrengthsListener mSim1SignalStrengthsListener;
  22.     private Sim2SignalStrengthsListener mSim2SignalStrengthsListener;
  24.     @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
  25.     private SignalStrengthsHandler() {
  26.         mSubscriptionManager = SubscriptionManager.from(mContext);
  27.         mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
  28.         initListeners();
  30.         mSimStateReceiver = new SimStateReceive();
  31.         IntentFilter intentFilter = new IntentFilter();
  32.         intentFilter.addAction(SimStateReceive.ACTION_SIM_STATE_CHANGED);
  33.         mContext.registerReceiver(mSimStateReceiver, intentFilter);
  34.     }
  36.     public static SignalStrengthsHandler getInstance() {
  37.         if (null == mInstance) {
  38.             synchronized (mLock) {
  39.                 if (null == mInstance) {
  40.                     mInstance = new SignalStrengthsHandler();
  41.                 }
  42.             }
  43.         }
  44.         return mInstance;
  45.     }
  47.     public void destroyInstance() {
  48.         if (null != mInstance) {
  49.             synchronized (mLock) {
  50.                 if (null != mInstance) {
  51.                     if (null != mOnSignalStrengthsChangedListeners) {
  52.                         mOnSignalStrengthsChangedListeners.clear();
  53.                         mOnSignalStrengthsChangedListeners = null;
  54.                     }
  55.                     mContext.unregisterReceiver(mSimStateReceiver);
  56.                     mInstance = null;
  57.                 }
  58.             }
  59.         }
  60.     }
  62.     private void initListeners() {
  63.         listenSimSignalStrengths(SimCard.SIM_CARD_1);
  64.         listenSimSignalStrengths(SimCard.SIM_CARD_2);
  65.     }
  67.     @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
  68.     private void listenSimSignalStrengths(SimCard simCard) {
  69.         if (simCard == SimCard.SIM_CARD_1) {
  70.             SubscriptionInfo sub0 = mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(INDEX_SIM1);
  71.             if (sub0 != null && null == mSim1SignalStrengthsListener) {
  72.                 mSim1SignalStrengthsListener = new Sim1SignalStrengthsListener(sub0.getSubscriptionId());
  73.             }
  74.             mTelephonyManager.listen(mSim1SignalStrengthsListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
  75.         } else if (simCard == SimCard.SIM_CARD_2) {
  76.             SubscriptionInfo sub1 = mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(INDEX_SIM2);
  77.             if (sub1 != null && null == mSim2SignalStrengthsListener) {
  78.                 mSim2SignalStrengthsListener = new Sim2SignalStrengthsListener(sub1.getSubscriptionId());
  79.             }
  80.             mTelephonyManager.listen(mSim2SignalStrengthsListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
  81.         }
  82.     }
  84.     private void unListenSimSignalStrengths(SimCard simCard) {
  85.         if (simCard == SimCard.SIM_CARD_1) {
  86.             mSim1SignalInfo.mIsActive = false;
  87.             mSim1SignalInfo.mLevel = 0;
  88.             if (null != mSim1SignalStrengthsListener) {
  89.                 mTelephonyManager.listen(mSim1SignalStrengthsListener, PhoneStateListener.LISTEN_NONE);
  90.             }
  91.         } else if (simCard == SimCard.SIM_CARD_2) {
  92.             mSim2SignalInfo.mIsActive = false;
  93.             mSim2SignalInfo.mLevel = 0;
  94.             if (null != mSim2SignalStrengthsListener) {
  95.                 mTelephonyManager.listen(mSim2SignalStrengthsListener, PhoneStateListener.LISTEN_NONE);
  96.             }
  97.         }
  99.     }
  101.     /**
  102.      * 添加监听sim卡信号强度
  103.      *
  104.      * @param listener
  105.      */
  106.     public void registerOnSignalStrengthsChangedListener(OnSignalStrengthsChangedListener listener) {
  107.         if (null == mOnSignalStrengthsChangedListeners) {
  108.             mOnSignalStrengthsChangedListeners = new ArrayList<>();
  109.         }
  111.         if (mOnSignalStrengthsChangedListeners.contains(listener)) {
  112.             return;
  113.         }
  115.         if (null != listener) {
  116.             mOnSignalStrengthsChangedListeners.add(listener);
  117.         }
  118.     }
  120.     public void unregisterOnSignalStrengthsChangedListener(OnSignalStrengthsChangedListener listener) {
  121.         if (null == mOnSignalStrengthsChangedListeners) {
  122.             return;
  123.         }
  125.         if (null == listener) {
  126.             return;
  127.         }
  129.         if (mOnSignalStrengthsChangedListeners.contains(listener)) {
  130.             mOnSignalStrengthsChangedListeners.remove(listener);
  131.         }
  132.     }
  134.     public void notyfyStateChange(boolean isSim1Exist, boolean isSim2Exist) {
  135.         if (null != mOnSignalStrengthsChangedListeners && !mOnSignalStrengthsChangedListeners.isEmpty()) {
  136.             for (int i = 0; i < mOnSignalStrengthsChangedListeners.size(); i++) {
  137.                 OnSignalStrengthsChangedListener listener = mOnSignalStrengthsChangedListeners.get(i);
  138.                 if (null != listener) {
  139.                     listener.onSimStateChanged(isSim1Exist, isSim2Exist);
  140.                 }
  141.             }
  142.         }
  143.     }
  145.     public void notifyChange(SimCard simCard, int level) {
  146.         if (null != mOnSignalStrengthsChangedListeners && !mOnSignalStrengthsChangedListeners.isEmpty()) {
  147.             for (int i = 0; i < mOnSignalStrengthsChangedListeners.size(); i++) {
  148.                 OnSignalStrengthsChangedListener listener = mOnSignalStrengthsChangedListeners.get(i);
  149.                 if (null != listener) {
  150.                     listener.onSignalStrengthsChanged(simCard, level);
  151.                 }
  152.             }
  153.         }
  154.     }
  156.     public boolean isSimCardExist(int cardIndex) {
  157.         boolean isSimCardExist = false;
  158.         try {
  159.             Method method = TelephonyManager.class.getMethod("getSimState", new Class[]{int.class});
  160.             int simState = (Integer) method.invoke(mTelephonyManager, new Object[]{Integer.valueOf(cardIndex)});
  161.             if (TelephonyManager.SIM_STATE_READY == simState) {
  162.                 isSimCardExist = true;
  163.             }
  164.         } catch (Exception e) {
  165.             e.printStackTrace();
  166.         }
  168.         return isSimCardExist;
  169.     }
  171.     /**
  172.      * 获取sim信号 状态信息
  173.      *
  174.      * @return int[]  index: 0:sim1 1:sim2
  175.      */
  176.     public SimSignalInfo[] getSimSignalInfos() {
  177.         return new SimSignalInfo[]{mSim1SignalInfo, mSim2SignalInfo};
  178.     }
  180.     private int getSignalStrengthsLevel(SignalStrength signalStrength) {
  181.         int level = -1;
  182.         try {
  183.             Method levelMethod = SignalStrength.class.getDeclaredMethod("getLevel");
  184.             level = (int) levelMethod.invoke(signalStrength);
  185.         } catch (Exception e) {
  186.             LogUtil.e(TAG, e.getMessage());
  187.         }
  188.         return level;
  189.     }
  191.     private class Sim1SignalStrengthsListener extends PhoneStateListener {
  193.         public Sim1SignalStrengthsListener(int subId) {
  194.             super();
  195.             //设置当前监听的sim卡
  196.             ReflectUtil.setFieldValue(this, "mSubId", subId);
  197.         }
  199.         @Override
  200.         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
  201.             super.onSignalStrengthsChanged(signalStrength);
  202.             int level = getSignalStrengthsLevel(signalStrength);
  203.             if (mSim1SignalInfo.mLevel == level) {
  204.                 return;
  205.             }
  206.             mSim1SignalInfo.mLevel = level;
  207.             SignalStrengthsHandler.this.notifyChange(SimCard.SIM_CARD_1, mSim1SignalInfo.mLevel);
  208.             LogUtil.d(TAG, "sim 1 signal strengths level = " + mSim1SignalInfo.mLevel);
  209.         }
  210.     }
  212.     private class Sim2SignalStrengthsListener extends PhoneStateListener {
  214.         public Sim2SignalStrengthsListener(int subId) {
  215.             super();
  216.             //设置当前监听的sim卡
  217.             ReflectUtil.setFieldValue(this, "mSubId", subId);
  218.         }
  220.         @Override
  221.         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
  222.             super.onSignalStrengthsChanged(signalStrength);
  223.             int level = getSignalStrengthsLevel(signalStrength);
  224.             if (mSim2SignalInfo.mLevel == level) {
  225.                 return;
  226.             }
  227.             mSim2SignalInfo.mLevel = level;
  228.             SignalStrengthsHandler.this.notifyChange(SimCard.SIM_CARD_2, mSim2SignalInfo.mLevel);
  229.             LogUtil.d(TAG, "sim 2 signal strengths level = " + mSim2SignalInfo.mLevel);
  230.         }
  231.     }
  233.     public interface OnSignalStrengthsChangedListener {
  234.         void onSignalStrengthsChanged(SimCard simCard, int level);
  236.         void onSimStateChanged(boolean isSim1Exist, boolean isSim2Exist);
  237.     }
  239.     public enum SimCard {
  240.         SIM_CARD_1, SIM_CARD_2
  241.     }
  243.     @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
  244.     class SimStateReceive extends BroadcastReceiver {
  245.         private final static String ACTION_SIM_STATE_CHANGED = "android.intent.action.SIM_STATE_CHANGED";
  247.         @Override
  248.         public void onReceive(Context context, Intent intent) {
  249.             LogUtil.i("SimStateReceive", "sim state changed");
  250.             if (intent.getAction().equals(ACTION_SIM_STATE_CHANGED)) {
  251.                 mSim1SignalInfo.mIsActive = isSimCardExist(INDEX_SIM1)
  252.                         && null != mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(INDEX_SIM1);
  253.                 mSim2SignalInfo.mIsActive = isSimCardExist(INDEX_SIM2)
  254.                         && null != mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(INDEX_SIM2);
  256.                 mSim1SignalInfo.mLevel = 0;
  257.                 mSim2SignalInfo.mLevel = 0;
  258.                 if (mSim1SignalInfo.mIsActive) {
  259.                     listenSimSignalStrengths(SimCard.SIM_CARD_1);
  260.                 } else {
  261.                     unListenSimSignalStrengths(SimCard.SIM_CARD_1);
  262.                 }
  263.                 if (mSim2SignalInfo.mIsActive) {
  264.                     listenSimSignalStrengths(SimCard.SIM_CARD_2);
  265.                 } else {
  266.                     unListenSimSignalStrengths(SimCard.SIM_CARD_2);
  267.                 }
  268.                 notyfyStateChange(mSim1SignalInfo.mIsActive, mSim2SignalInfo.mIsActive);
  269.             }
  270.         }
  271.     }
  273.     public class SimSignalInfo {
  274.         /**
  275.          * 信号强度 0 - 5
  276.          */
  277.         public int mLevel;
  279.         /**
  280.          * sim卡是否有效
  281.          */
  282.         public boolean mIsActive;
  283.     }
  284. }
  • 1
 

Android 监听双卡信号强度(附完整代码)的更多相关文章

  1. Android监听系统短信数据库变化-提取短信内容

    由于监听系统短信广播受到权限的限制,所以很多手机可能使用这种方式没法监听广播,从而没办法获取到系统短信,所以又重新开辟一条路. Android监听系统短信数据库内容变化使用场景: 1.监听短信数据库的 ...

  2. Android监听应用程序安装和卸载

    Android监听应用程序安装和卸载 第一. 新建监听类:BootReceiver继承BroadcastReceiver package com.rongfzh.yc; import android. ...

  3. 【Android】Android 监听apk安装替换卸载广播

    [Android]Android 监听apk安装替换卸载广播 首先是要获取应用的安装状态,通过广播的形式 以下是和应用程序相关的Broadcast Action ACTION_PACKAGE_ADDE ...

  4. Android 监听 ScrollView 滑动到最底部。

    做产品时,有一个需求,需要监听ScrollView滑动到最底部.在网上找了些方法,都有这样或那样的问题,要不就是监听不精确, 要不就是重复监听,那些代码没有产品化,很不可靠. 经过自己试验,终于找到了 ...

  5. Android监听返回键、Home键+再按一次返回键退出应用

    Android监听返回键需重写onKeyDown()方法 Home键keyCode==KeyEvent.KEYCODE_HOME @Override public boolean onKeyDown( ...

  6. Android监听来电和去电

    要监听android打电话和接电话,只需下面2步骤1.第一步,写一个Receiver继承自BroadcastReceiver import android.app.Service; import an ...

  7. Android监听ScrollView滑动到顶端和底部

    Android监听ScrollView滑动到顶端和底部     package cn.testscrollview; import android.os.Bundle; import android. ...

  8. Android 监听网络变化

    Android 监听网络变化

  9. android 监听返回键

    android监听返回键 public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode == KeyEvent.KEYCODE ...

随机推荐

  1. Java类和对象 详解（一）---写的很好通俗易懂---https://blog.csdn.net/wei_zhi/article/details/52745268

    https://blog.csdn.net/wei_zhi/article/details/52745268

  2. Matlab freqs 函数

    freqs 模拟滤波器的频率响应 语法: h = freqs(b,a,w)[h,w] = freqs(b,a)[h,w] = freqs(b,a,f)freqs(b,a) 描述: freqs 返回一个 ...

  3. OOP的三大特性------封装、继承、多态

    封装 1.<1>类背后隐藏的思想是数据抽象和封装 <2>信息隐藏,隐藏对象的实现细节,不让外部直接访问到 将数据成员和成员函数一起包装到一个单元里,单元以类的形式实现 < ...

  4. PAT A+B格式

    A + B格式(20) 时间限制 400毫秒 内存限制 65536 kB 代码长度限制 16000 B. 判断程序 标准 作者 陈,岳 计算a + b并以标准格式输出总和 - 即数字必须用逗号分隔成三 ...

  5. 删除ARCSDE表空间和用户后，新建时出现error -1：O的解决办法

    对于刚开始使用arcsde的用户,可能会出现各种问题,慢慢来就会找到解决办法 当我们删除用户和表空间时,在服务器本地还保留这sde.dbf文件(删除时选择了删除本地文件,不知道为什么), 我们可以换一 ...

  6. HDU6438 Buy and Resell 解题报告（一个有趣的贪心问题的严格证明）

    写在前面 此题是一个很容易想到的贪心题目,但是正确性的证明是非常复杂的.然而,目前网上所有题解并未给出本题贪心算法的任何正确性证明,全部仅停留在描述出一个贪心算法.本着对算法与计算机科学的热爱(逃), ...

  7. 【CCF】除法 树状数组

    [AC] #include<iostream> #include<math.h> #include<cstring> using namespace std; ty ...

  8. layer相关

    关闭窗口 var index = parent.layer.getFrameIndex(window.name);parent.layer.close(index);

  9. SQLalchemy 使用记录

    1.models.py中添加该方法,可通过该方法转dict #驼峰 def to_hump_dict(self): return {commonUtils.str2Hump(c.name): geta ...

  10. BZOJ 3513: [MUTC2013]idiots

    3513: [MUTC2013]idiots Time Limit: 20 Sec  Memory Limit: 128 MBSubmit: 476  Solved: 162[Submit][Stat ...