为了实现一个功能，需要搜集手机信息，自己先在网上找了相关信息进行了汇总，主要是汇集手机的信息，一般想要的信息在手机设置->关于手机->状态消息里面包含了手机的各种信息，下面的代码中也主要显示了那些信息，但是源码的方法我还没有看，先把总结的贴出来。先上图（太多就截取几个）。

【小功能2】android获取手机信息（号码，内存，CPU，分辨率，MAC，IP，SD卡，IMEI,经纬度，信号强度等等）_内存【小功能2】android获取手机信息（号码，内存，CPU，分辨率，MAC，IP，SD卡，IMEI,经纬度，信号强度等等）_内存_02 

【小功能2】android获取手机信息（号码，内存，CPU，分辨率，MAC，IP，SD卡，IMEI,经纬度，信号强度等等）_获取手机信息_03【小功能2】android获取手机信息（号码，内存，CPU，分辨率，MAC，IP，SD卡，IMEI,经纬度，信号强度等等）_CPU_04

 

【小功能2】android获取手机信息（号码，内存，CPU，分辨率，MAC，IP，SD卡，IMEI,经纬度，信号强度等等）_获取手机信息_05 上代码啦，太多了，就写主要代码了。

 

  1.     // 获取Android手机中SD卡存储信息 获取剩余空间  
  2. public void getSDCardInfo() {  
  3.     // 在manifest.xml文件中要添加  
  4.     /*  
  5.      * <uses-permission  
  6.      * android:name="android.permission.WRITE_EXTERNAL_STORAGE">  
  7.      * </uses-permission>  
  8.      */ 
  9.     // 需要判断手机上面SD卡是否插好，如果有SD卡的情况下，我们才可以访问得到并获取到它的相关信息，当然以下这个语句需要用if做判断  
  10.     if (Environment.getExternalStorageState().equals(  
  11.             Environment.MEDIA_MOUNTED)) {  
  12.         // 取得sdcard文件路径  
  13.         File path = Environment.getExternalStorageDirectory();  
  14.         StatFs statfs = new StatFs(path.getPath());  
  15.         // 获取block的SIZE  
  16.         long blocSize = statfs.getBlockSize();  
  17.         // 获取BLOCK数量  
  18.         long totalBlocks = statfs.getBlockCount();  
  19.         // 空闲的Block的数量  
  20.         long availaBlock = statfs.getAvailableBlocks();  
  21.         // 计算总空间大小和空闲的空间大小  
  22.         // 存储空间大小跟空闲的存储空间大小就被计算出来了。  
  23.         long availableSize = blocSize * availaBlock;  
  24.         // (availableBlocks * blockSize)/1024 KIB 单位  
  25.         // (availableBlocks * blockSize)/1024 /1024 MIB单位  
  26.         long allSize = blocSize * totalBlocks;  
  27.     }  
  28.  
  29. }  
  30.  
  31. // 获取手机ip method-1  
  32. public String getLocalIpAddress() {  
  33.     try {  
  34.         for (Enumeration<NetworkInterface> en = NetworkInterface  
  35.                 .getNetworkInterfaces(); en.hasMoreElements();) {  
  36.             NetworkInterface intf = en.nextElement();  
  37.             for (Enumeration<InetAddress> enumIpAddr = intf  
  38.                     .getInetAddresses(); enumIpAddr.hasMoreElements();) {  
  39.                 InetAddress inetAddress = enumIpAddr.nextElement();  
  40.                 if (!inetAddress.isLoopbackAddress()) {  
  41.                     Toast.makeText(this,  
  42.                             inetAddress.getHostAddress().toString(), 3000)  
  43.                             .show();  
  44.                     return inetAddress.getHostAddress().toString();  
  45.                 }  
  46.             }  
  47.         }  
  48.     } catch (SocketException ex) {  
  49.         ex.printStackTrace();  
  50.         // Log.e("ifo", ex.toString());  
  51.     }  
  52.     return "";  
  53. } // 需要权限<uses-permission  
  54.     // android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>  
  55.     // <uses-permission  
  56.     // android:name="android.permission.INTERNET"></uses-permission>  
  57.  
  58. // 获取手机ip method-2  
  59. // 首先设置用户权限  
  60. // <uses-permission  
  61. // android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>  
  62. // <uses-permission  
  63. // android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>  
  64. // <uses-permission  
  65. // android:name="android.permission.WAKE_LOCK"></uses-permission>  
  66. public String getLocalIpAddress2() {  
  67.     // 获取wifi服务  
  68.     WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);  
  69.     // 判断wifi是否开启  
  70.     if (!wifiManager.isWifiEnabled()) {  
  71.         wifiManager.setWifiEnabled(true);  
  72.     }  
  73.     WifiInfo wifiInfo = wifiManager.getConnectionInfo();  
  74.     int ipAddress = wifiInfo.getIpAddress();  
  75.     String ip = intToIp(ipAddress);  
  76.     return ip;  
  77. }  
  78.  
  79. private String intToIp(int i) {  
  80.     return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)  
  81.             + "." + (i >> 24 & 0xFF);  
  82. }  
  83.  
  84. // 查看本机外网IP  
  85. /*  
  86.  * 该方法需要设备支持上网 查看  
  87.  * System.out.println((GetNetIp("http://fw.qq.com/ipaddress"))); 加权限  
  88.  * <uses-permission  
  89.  * android:name="android.permission.INTERNET"></uses-permission>  
  90.  * 通过获取http://fw.qq.com/ipaddress网页取得外网IP 这里有几个查看IP的网址然后提取IP试试。  
  91.  * http://ip168.com/ http://www.cmyip.com/ http://city.ip138.com/ip2city.asp  
  92.  */ 
  93. public String GetNetIp(String ipaddr) {  
  94.     URL infoUrl = null;  
  95.     InputStream inStream = null;  
  96.     try {  
  97.         infoUrl = new URL(ipaddr);  
  98.         URLConnection connection = infoUrl.openConnection();  
  99.         HttpURLConnection httpConnection = (HttpURLConnection) connection;  
  100.         int responseCode = httpConnection.getResponseCode();  
  101.         if (responseCode == HttpURLConnection.HTTP_OK) {  
  102.             inStream = httpConnection.getInputStream();  
  103.             BufferedReader reader = new BufferedReader(  
  104.                     new InputStreamReader(inStream, "utf-8"));  
  105.             StringBuilder strber = new StringBuilder();  
  106.             String line = null;  
  107.             while ((line = reader.readLine()) != null)  
  108.                 strber.append(line + "\n");  
  109.             inStream.close();  
  110.             return strber.toString();  
  111.         }  
  112.     } catch (MalformedURLException e) {  
  113.         // TODO Auto-generated catch block  
  114.         e.printStackTrace();  
  115.     } catch (IOException e) {  
  116.         // TODO Auto-generated catch block  
  117.         e.printStackTrace();  
  118.     }  
  119.     return "";  
  120. }  
  121.  
  122. // 获取手机MAC地址  
  123. private String getMacAddress() {  
  124.     String result = "";  
  125.     WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);  
  126.     WifiInfo wifiInfo = wifiManager.getConnectionInfo();  
  127.     result = wifiInfo.getMacAddress();  
  128.     // Log.i(TAG, "macAdd:" + result);  
  129.     return result;  
  130. }  
  131.  
  132. // 获取手机屏幕高度  
  133. private String getWeithAndHeight() {  
  134.     // 这种方式在service中无法使用，  
  135.     DisplayMetrics dm = new DisplayMetrics();  
  136.     getWindowManager().getDefaultDisplay().getMetrics(dm);  
  137.     int width = dm.widthPixels; // 宽  
  138.     int height = dm.heightPixels; // 高  
  139.     float density = dm.density; // 屏幕密度（0.75 / 1.0 / 1.5）  
  140.     int densityDpi = dm.densityDpi; // 屏幕密度DPI（120 / 160 / 240）  
  141.     // 在service中也能得到高和宽  
  142.     WindowManager mWindowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);  
  143.     width = mWindowManager.getDefaultDisplay().getWidth();  
  144.     height = mWindowManager.getDefaultDisplay().getHeight();  
  145.  
  146.     // 居中显示Toast  
  147.     Toast msg = Toast.makeText(this, "宽=" + width + "   高=" + height,  
  148.             Toast.LENGTH_LONG);  
  149.     msg.setGravity(Gravity.CENTER, msg.getXOffset() / 2,  
  150.             msg.getYOffset() / 2);  
  151.     msg.show();  
  152.     return "(像素)宽:" + width + "\n" + "(像素)高:" + height + "\n" 
  153.             + "屏幕密度（0.75 / 1.0 / 1.5）:" + density + "\n" 
  154.             + "屏幕密度DPI（120 / 160 / 240）:" + densityDpi + "\n";  
  155.     /*  
  156.      * 下面的代码即可获取屏幕的尺寸。 在一个Activity的onCreate方法中，写入如下代码： 
  157.       DisplayMetrics metric   = new DisplayMetrics();  
  158.      * getWindowManager().getDefaultDisplay().getMetrics(metric);  
  159.      * int width  = metric.widthPixels; // 屏幕宽度（像素） 
  160.      * int height = metric.heightPixels;   // 屏幕高度（像素） 
  161.      * float density = metric.density; // 屏幕密度（0.75 / 1.0 / 1.5）  
  162.      * int densityDpi = metric.densityDpi; // 屏幕密度DPI（120 / 160 / 240）  
  163.      *   
  164.      * 但是，需要注意的是，在一个低密度的小屏手机上，仅靠上面的代码是不能获取正确的尺寸的。  
  165.      * 比如说，一部240x320像素的低密度手机，如果运行上述代码，获取到的屏幕尺寸是320x427。  
  166.      * 因此，研究之后发现，若没有设定多分辨率支持的话  
  167.      * ，Android系统会将240x320的低密度（120）尺寸转换为中等密度（160）对应的尺寸，  
  168.      * 这样的话就大大影响了程序的编码。所以，需要在工程的AndroidManifest  
  169.      * .xml文件中，加入supports-screens节点，具体的内容如下： <supports-screens  
  170.      * android:smallScreens="true" android:normalScreens="true"  
  171.      * android:largeScreens="true" android:resizeable="true"  
  172.      * android:anyDensity="true" />  
  173.      * 这样的话，当前的Android程序就支持了多种分辨率，那么就可以得到正确的物理尺寸了。  
  174.      */ 
  175. }  
  176.  
  177. // 获取手机经纬度  
  178. public void getLocation() {  
  179.     // 1. 创建一个 LocationManager对象。  
  180.     LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);  
  181.     // 2. 创建一个 LocationListener对象。  
  182.     LocationListener myGPSListener = new LocationListener() {  
  183.         // 一旦Location发生改变就会调用这个方法  
  184.         public void onLocationChanged(Location location) {  
  185.             double latitude = location.getLatitude();  
  186.             double longitude = location.getLongitude();  
  187.         }  
  188.  
  189.         public void onStatusChanged(String provider, int status,  
  190.                 Bundle extras) {  
  191.         }  
  192.  
  193.         public void onProviderEnabled(String provider) {  
  194.         }  
  195.  
  196.         public void onProviderDisabled(String provider) {  
  197.         }  
  198.     };  
  199.     // 3.向LocationManager 注册一个LocationListener。  
  200.     Criteria criteria = new Criteria();  
  201.     criteria.setAccuracy(Criteria.ACCURACY_COARSE);  
  202.     criteria.setAltitudeRequired(false);  
  203.     criteria.setCostAllowed(true);  
  204.     criteria.setPowerRequirement(Criteria.POWER_LOW);  
  205.     String provider = locationManager.getBestProvider(criteria, true); // 根据Criteria  
  206.                                                                         // 的设置获取一个最佳的Provider  
  207.     locationManager  
  208.             .requestLocationUpdates(provider, 5000, 0, myGPSListener);  
  209.     // 4.移除LocationManager 注册的 LocationListener。  
  210.     locationManager.removeUpdates(myGPSListener);  
  211.  
  212. }  
  213.  
  214. // 当前网络是否连接  
  215. public boolean isNetConnecting() {  
  216.     ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);  
  217.     NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();  
  218.     if (networkInfo == null || !networkInfo.isConnected()) {  
  219.         // info.setConnected(false);  
  220.         return false;  
  221.     } else {  
  222.         // info.setConnected(true);  
  223.         return true;  
  224.     }  
  225. }  
  226.  
  227. // 获取信号强度  
  228. public void getPhoneState() {  
  229.     // 1. 创建telephonyManager 对象。  
  230.     TelephonyManager telephonyManager = (TelephonyManager) /* context. */getSystemService(Context.TELEPHONY_SERVICE);  
  231.     // 2. 创建PhoneStateListener 对象  
  232.     PhoneStateListener MyPhoneListener = new PhoneStateListener() {  
  233.         @Override 
  234.         public void onCellLocationChanged(CellLocation location) {  
  235.             if (location instanceof GsmCellLocation) {// gsm网络  
  236.                 int CID = ((GsmCellLocation) location).getCid();  
  237.             } else if (location instanceof CdmaCellLocation) {// 其他CDMA等网络  
  238.                 int ID = ((CdmaCellLocation) location).getBaseStationId();  
  239.             }  
  240.         }  
  241.  
  242.         @Override 
  243.         public void onServiceStateChanged(ServiceState serviceState) {  
  244.             super.onServiceStateChanged(serviceState);  
  245.         }  
  246.  
  247.         @Override 
  248.         public void onSignalStrengthsChanged(SignalStrength signalStrength) {  
  249.             int asu = signalStrength.getGsmSignalStrength();  
  250.             int dbm = -113 + 2 * asu; // 信号强度  
  251.             super.onSignalStrengthsChanged(signalStrength);  
  252.         }  
  253.     };  
  254.     // 3. 监听信号改变  
  255.     telephonyManager.listen(MyPhoneListener,  
  256.             PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);  
  257.  
  258.     /*  
  259.      * 可能需要的权限 <uses-permission  
  260.      * android:name="android.permission.WAKE_LOCK"></uses-permission>  
  261.      * <uses-permission  
  262.      * android:name="android.permission.ACCESS_COARSE_LOCATION"/>  
  263.      * <uses-permission  
  264.      * android:name="android.permission.ACCESS_FINE_LOCATION"/>  
  265.      * <uses-permission android:name="android.permission.READ_PHONE_STATE"  
  266.      * /> <uses-permission  
  267.      * android:name="android.permission.ACCESS_NETWORK_STATE" />  
  268.      */ 
  269. }  
  270.  
  271. // 获取手机可用内存和总内存  
  272. private String getSystemMemory() {  
  273.     /*  
  274.      * 在android开发中，有时候我们想获取手机的一些硬件信息，比如android手机的总内存和可用内存大小。这个该如何实现呢？  
  275.      * 通过读取文件"/proc/meminfo"  的信息能够获取手机Memory的总量，而通过ActivityManager.getMemoryInfo  
  276.      * (ActivityManager.MemoryInfo)方法可以获取当前的可用Memory量。  
  277.      * "/proc/meminfo"文件记录了android手机的一些内存信息  
  278.      * ，在命令行窗口里输入"adb shell"，进入shell环境，输入  
  279.      * "cat /proc/meminfo"即可在命令行里显示meminfo文件的内容，具体如下所示。  
  280.      *   
  281.      * C:\Users\Figo>adb shell # cat /proc/meminfo cat /proc/meminfo  
  282.      * MemTotal: 94096 kB 
  283.       * MemFree: 1684 kB     Buffers: 16 kB     Cached: 27160 kB  
  284.      * SwapCached: 0 kB     Active: 35392 kB    Inactive: 44180 kB 
  285.      *  Active(anon): 26540 kB Inactive(anon): 28244 kB   Active(file): 8852 kB  
  286.      * Inactive(file): 15936 kB  Unevictable: 280 kB  Mlocked: 0 kB       * SwapTotal:   0 kB SwapFree: 0 kB Dirty: 0 kB Writeback: 0 kB AnonPages: 52688 kB  
  287.      * Mapped: 17960 kB Slab: 3816 kB SReclaimable: 936 kB SUnreclaim: 2880  
  288.      * kB PageTables: 5260 kB NFS_Unstable: 0 kB Bounce: 0 kB    
  289.      * WritebackTmp:   0 kB 
  290.      * CommitLimit: 47048 kB 
  291.      * Committed_AS: 1483784 kB 
  292.      * VmallocTotal:  876544 kB 
  293.      * VmallocUsed: 15456 kB 
  294.       * VmallocChunk: 829444 kB #  
  295.      *   
  296.      * 下面先对"/proc/meminfo"文件里列出的字段进行粗略解释： MemTotal: 所有可用RAM大小。 MemFree:  
  297.      * LowFree与HighFree的总和，被系统留着未使用的内存。 Buffers: 用来给文件做缓冲大小。 Cached:  
  298.      * 被高速缓冲存储器（cache memory）用的内存的大小（等于diskcache minus SwapCache）。  
  299.      * SwapCached:被高速缓冲存储器（cache  
  300.      * memory）用的交换空间的大小。已经被交换出来的内存，仍然被存放在swapfile中，  
  301.      * 用来在需要的时候很快的被替换而不需要再次打开I/O端口。 Active:  
  302.      * 在活跃使用中的缓冲或高速缓冲存储器页面文件的大小，除非非常必要，否则不会被移作他用。 Inactive:  
  303.      * 在不经常使用中的缓冲或高速缓冲存储器页面文件的大小，可能被用于其他途径。 SwapTotal: 交换空间的总大小。 SwapFree:  
  304.      * 未被使用交换空间的大小。 Dirty: 等待被写回到磁盘的内存大小。 Writeback: 正在被写回到磁盘的内存大小。  
  305.      * AnonPages：未映射页的内存大小。 Mapped: 设备和文件等映射的大小。 Slab:  
  306.      * 内核数据结构缓存的大小，可以减少申请和释放内存带来的消耗。 SReclaimable:可收回Slab的大小。  
  307.      * SUnreclaim：不可收回Slab的大小（SUnreclaim+SReclaimable＝Slab）。  
  308.      * PageTables：管理内存分页页面的索引表的大小。 NFS_Unstable:不稳定页表的大小。  
  309.      * 要获取android手机总内存大小，只需读取"/proc/meminfo"文件的第1行，并进行简单的字符串处理即可。  
  310.      */ 
  311.     String availMemory = getAvailMemory();  
  312.     String totalMemory = getTotalMemory();  
  313.     return "可用内存=" + availMemory + "\n" + "总内存=" + totalMemory;  
  314.  
  315. }// 手机的内存信息主要在/proc/meminfo文件中，其中第一行是总内存，而剩余内存可通过ActivityManager.MemoryInfo得到。  
  316.  
  317. private String getAvailMemory() {// 获取android当前可用内存大小  
  318.     ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
  319.     MemoryInfo mi = new MemoryInfo();  
  320.     am.getMemoryInfo(mi);  
  321.     // mi.availMem; 当前系统的可用内存  
  322.     return Formatter.formatFileSize(getBaseContext(), mi.availMem);// 将获取的内存大小规格化  
  323. }  
  324.  
  325. private String getTotalMemory() {  
  326.     String str1 = "/proc/meminfo";// 系统内存信息文件  
  327.     String str2;  
  328.     String[] arrayOfString;  
  329.     long initial_memory = 0;  
  330.     try {  
  331.         FileReader localFileReader = new FileReader(str1);  
  332.         BufferedReader localBufferedReader = new BufferedReader(  
  333.                 localFileReader, 8192);  
  334.         str2 = localBufferedReader.readLine();// 读取meminfo第一行，系统总内存大小  
  335.  
  336.         arrayOfString = str2.split("\\s+");  
  337.         for (String num : arrayOfString) {  
  338.             Log.i(str2, num + "\t");  
  339.         }  
  340.  
  341.         initial_memory = Integer.valueOf(arrayOfString[1]).intValue() * 1024;// 获得系统总内存，单位是KB，乘以1024转换为Byte  
  342.         localBufferedReader.close();  
  343.  
  344.     } catch (IOException e) {  
  345.     }  
  346.     return Formatter.formatFileSize(getBaseContext(), initial_memory);// Byte转换为KB或者MB，内存大小规格化  
  347. }  
  348.  
  349. // 获取手机CPU信息  
  350. private String getCpuInfo() {  
  351.     String str1 = "/proc/cpuinfo";  
  352.     String str2 = "";  
  353.     String[] cpuInfo = { "", "" }; // 1-cpu型号 //2-cpu频率  
  354.     String[] arrayOfString;  
  355.     try {  
  356.         FileReader fr = new FileReader(str1);  
  357.         BufferedReader localBufferedReader = new BufferedReader(fr, 8192);  
  358.         str2 = localBufferedReader.readLine();  
  359.         arrayOfString = str2.split("\\s+");  
  360.         for (int i = 2; i < arrayOfString.length; i++) {  
  361.             cpuInfo[0] = cpuInfo[0] + arrayOfString[i] + " ";  
  362.         }  
  363.         str2 = localBufferedReader.readLine();  
  364.         arrayOfString = str2.split("\\s+");  
  365.         cpuInfo[1] += arrayOfString[2];  
  366.         localBufferedReader.close();  
  367.     } catch (IOException e) {  
  368.     }  
  369.     // Log.i(TAG, "cpuinfo:" + cpuInfo[0] + " " + cpuInfo[1]);  
  370.     return "1-cpu型号:" + cpuInfo[0] + "2-cpu频率:" + cpuInfo[1];  
  371. }// 和内存信息同理，cpu信息可通过读取/proc/cpuinfo文件来得到，其中第一行为cpu型号，第二行为cpu频率。  
  372.  
  373. /*  
  374.  * 一、Android 获取手机中已安装apk文件信息(PackageInfo、ResolveInfo)(应用图片、应用名、包名等)  
  375.  * 1、通过PackageManager可获取手机端已安装的apk文件的信息，具体代码如下: PackageManager  
  376.  * packageManager = this.getPackageManager(); List<PackageInfo>  
  377.  * packageInfoList = packageManager.getInstalledPackages(0);  
  378.  * 通过上述方法，可得到手机中安装的所有应用程序，包括手动安装的apk包的信息、、系统预装的应用软件的信息，要区分这两类软件可使用以下方法:  
  379.  * （a）从packageInfoList获取的packageInfo  
  380.  * ，再通过packageInfo.applicationInfo获取applicationInfo。  
  381.  * （b）判断(applicationInfo.flags &  
  382.  * ApplicationInfo.FLAG_SYSTEM)的值，该值大于0时，表示获取的应用为系统预装的应用，反之则为手动安装的应用。  
  383.  * (1)获取应用的代码: public static List<PackageInfo> getAllApps(Context context) {  
  384.  * List<PackageInfo> apps = new ArrayList<PackageInfo>(); PackageManager  
  385.  * pManager = context.getPackageManager(); //获取手机内所有应用 List<PackageInfo>  
  386.  * paklist = pManager.getInstalledPackages(0); for (int i = 0; i <  
  387.  * paklist.size(); i++) { PackageInfo pak = (PackageInfo) paklist.get(i);  
  388.  * //判断是否为非系统预装的应用程序 if ((pak.applicationInfo.flags &  
  389.  * pak.applicationInfo.FLAG_SYSTEM) <= 0) { apps.add(pak); } } return apps;  
  390.  * } (2)、获取图片、应用名、包名: PackageManager pManager =  
  391.  * MessageSendActivity.this.getPackageManager(); List<PackageInfo> appList =  
  392.  * Utils.getAllApps(MessageSendActivity.this); for(int  
  393.  * i=0;i<appList.size();i++) { PackageInfo pinfo = appList.get(i); shareItem  
  394.  * = new ShareItemInfo();  
  395.  * shareItem.setIcon(pManager.getApplicationIcon(pinfo.applicationInfo));  
  396.  * shareItem  
  397.  * .setLabel(pManager.getApplicationLabel(pinfo.applicationInfo).toString  
  398.  * ()); shareItem.setPackageName(pinfo.applicationInfo.packageName); }  
  399.  * 其中ShareItemInfo 类自己写的，各位可以忽略 (3)获取支持分享的应用的代码： public static  
  400.  * List<ResolveInfo> getShareApps(Context context){ List<ResolveInfo> mApps  
  401.  * = new ArrayList<ResolveInfo>(); Intent intent=new  
  402.  * Intent(Intent.ACTION_SEND,null);  
  403.  * intent.addCategory(Intent.CATEGORY_DEFAULT);  
  404.  * intent.setType("text/plain"); PackageManager pManager =  
  405.  * context.getPackageManager(); mApps =  
  406.  * pManager.queryIntentActivities(intent  
  407.  * ,PackageManager.COMPONENT_ENABLED_STATE_DEFAULT); return mApps; }  
  408.  * 由于该方法，返回的并不是PackageInfo 对象。而是ResolveInfo。因此获取图片、应用名、包名的方法不一样，如下：  
  409.  * PackageManager pManager = MessageSendActivity.this.getPackageManager();  
  410.  * List<ResolveInfo> resolveList =  
  411.  * Utils.getShareApps(MessageSendActivity.this); for(int  
  412.  * i=0;i<resolveList.size();i++) { ResolveInfo resolve = resolveList.get(i);  
  413.  * ShareItemInfo shareItem = new ShareItemInfo(); //set Icon  
  414.  * shareItem.setIcon(resolve.loadIcon(pManager)); //set Application Name  
  415.  * shareItem.setLabel(resolve.loadLabel(pManager).toString()); //set Package  
  416.  * Name shareItem.setPackageName(resolve.activityInfo.packageName); } 总结： 通过  
  417.  * PackageInfo 获取具体信息方法： 包名获取方法：packageInfo.packageName  
  418.  * icon获取获取方法：packageManager.getApplicationIcon(applicationInfo)  
  419.  * 应用名称获取方法：packageManager.getApplicationLabel(applicationInfo)  
  420.  * 使用权限获取方法：packageManager  
  421.  * .getPackageInfo(packageName,PackageManager.GET_PERMISSIONS)  
  422.  * .requestedPermissions 通过 ResolveInfo 获取具体信息方法：  
  423.  * 包名获取方法：resolve.activityInfo.packageName  
  424.  * icon获取获取方法：resolve.loadIcon(packageManager)  
  425.  * 应用名称获取方法：resolve.loadLabel(packageManager).toString()  
  426.  */ 
  427. ublic String getSimCardInfo() {  
  428.     // 在manifest.xml文件中要添加  
  429.     // <uses-permission android:name="android.permission.READ_PHONE_STATE"/>  
  430.     /*  
  431.      * TelephonyManager类主要提供了一系列用于访问与手机通讯相关的状态和信息的get方法。其中包括手机SIM的状态和信息  
  432.      * 、电信网络的状态及手机用户的信息。  
  433.      * 在应用程序中可以使用这些get方法获取相关数据。TelephonyManager类的对象可以通过Context  
  434.      * .getSystemService(Context.TELEPHONY_SERVICE)  
  435.      * 方法来获得，需要注意的是有些通讯信息的获取对应用程序的权限有一定的限制  
  436.      * ，在开发的时候需要为其添加相应的权限。以下列出TelephonyManager类所有方法及说明：  
  437.      * TelephonyManager提供设备上获取通讯服务信息的入口。 应用程序可以使用这个类方法确定的电信服务商和国家  
  438.      * 以及某些类型的用户访问信息。 应用程序也可以注册一个监听器到电话收状态的变化。不需要直接实例化这个类  
  439.      * 使用Context.getSystemService (Context.TELEPHONY_SERVICE)来获取这个类的实例。  
  440.      */ 
  441.  
  442.     // 解释：  
  443.     // IMSI是国际移动用户识别码的简称(International Mobile Subscriber Identity)  
  444.     // IMSI共有15位，其结构如下：  
  445.     // MCC+MNC+MIN  
  446.     // MCC：Mobile Country Code，移动国家码，共3位，中国为460;  
  447.     // MNC:Mobile NetworkCode，移动网络码，共2位  
  448.     // 在中国，移动的代码为电00和02，联通的代码为01，电信的代码为03  
  449.     // 合起来就是（也是Android手机中APN配置文件中的代码）：  
  450.     // 中国移动：46000 46002  
  451.     // 中国联通：46001  
  452.     // 中国电信：46003  
  453.     // 举例，一个典型的IMSI号码为460030912121001  
  454.  
  455.     // IMEI是International Mobile Equipment Identity （国际移动设备标识）的简称  
  456.     // IMEI由15位数字组成的”电子串号”，它与每台手机一一对应，而且该码是全世界唯一的  
  457.     // 其组成为：  
  458.     // 1. 前6位数(TAC)是”型号核准号码”，一般代表机型  
  459.     // 2. 接着的2位数(FAC)是”最后装配号”，一般代表产地  
  460.     // 3. 之后的6位数(SNR)是”串号”，一般代表生产顺序号  
  461.     // 4. 最后1位数(SP)通常是”0″，为检验码，目前暂备用  
  462.  
  463.     TelephonyManager tm = (TelephonyManager) this 
  464.             .getSystemService(TELEPHONY_SERVICE);  
  465.     /*  
  466.      * 电话状态： 1.tm.CALL_STATE_IDLE=0 无活动，无任何状态时 2.tm.CALL_STATE_RINGING=1  
  467.      * 响铃，电话进来时 3.tm.CALL_STATE_OFFHOOK=2 摘机  
  468.      */ 
  469.     tm.getCallState();// int  
  470.  
  471.     /*  
  472.      * 电话方位：  
  473.      */ 
  474.     // 返回当前移动终端的位置  
  475.     CellLocation location = tm.getCellLocation();  
  476.     // 请求位置更新，如果更新将产生广播，接收对象为注册LISTEN_CELL_LOCATION的对象，需要的permission名称为  
  477.     // ACCESS_COARSE_LOCATION。  
  478.     location.requestLocationUpdate();  
  479.  
  480.     /**  
  481.      * 获取数据活动状态  
  482.      *   
  483.      * DATA_ACTIVITY_IN 数据连接状态：活动，正在接受数据 DATA_ACTIVITY_OUT 数据连接状态：活动，正在发送数据  
  484.      * DATA_ACTIVITY_INOUT 数据连接状态：活动，正在接受和发送数据 DATA_ACTIVITY_NONE  
  485.      * 数据连接状态：活动，但无数据发送和接受  
  486.      */ 
  487.     tm.getDataActivity();  
  488.  
  489.     /**  
  490.      * 获取数据连接状态  
  491.      *   
  492.      * DATA_CONNECTED 数据连接状态：已连接 DATA_CONNECTING 数据连接状态：正在连接  
  493.      * DATA_DISCONNECTED 数据连接状态：断开 DATA_SUSPENDED 数据连接状态：暂停  
  494.      */ 
  495.     tm.getDataState();  
  496.  
  497.     /**  
  498.      * 返回当前移动终端的唯一标识，设备ID  
  499.      *   
  500.      * 如果是GSM网络，返回IMEI；如果是CDMA网络，返回MEID Return null if device ID is not  
  501.      * available.  
  502.      */ 
  503.     String Imei = tm.getDeviceId();// String  
  504.  
  505.     /*  
  506.      * 返回移动终端的软件版本，例如：GSM手机的IMEI/SV码。 设备的软件版本号： 例如：the IMEI/SV(software  
  507.      * version) for GSM phones. Return null if the software version is not  
  508.      * available.  
  509.      */ 
  510.     tm.getDeviceSoftwareVersion();// String  
  511.  
  512.     /*  
  513.      * 手机号： GSM手机的 MSISDN. Return null if it is unavailable.  
  514.      */ 
  515.     String phoneNum = tm.getLine1Number();// String  
  516.  
  517.     /*  
  518.      * 获取ISO标准的国家码，即国际长途区号。 注意：仅当用户已在网络注册后有效。 在CDMA网络中结果也许不可靠。  
  519.      */ 
  520.     tm.getNetworkCountryIso();// String  
  521.  
  522.     /*  
  523.      * MCC+MNC(mobile country code + mobile network code) 注意：仅当用户已在网络注册时有效。  
  524.      * 在CDMA网络中结果也许不可靠。  
  525.      */ 
  526.     tm.getNetworkOperator();// String  
  527.  
  528.     /*  
  529.      * 按照字母次序的current registered operator(当前已注册的用户)的名字 注意：仅当用户已在网络注册时有效。  
  530.      * 在CDMA网络中结果也许不可靠。  
  531.      */ 
  532.  
  533.     tm.getNetworkOperatorName();// String  
  534.  
  535.     /*  
  536.      * 当前使用的网络类型： 例如： NETWORK_TYPE_UNKNOWN 网络类型未知 0 NETWORK_TYPE_GPRS GPRS网络  
  537.      * 1 NETWORK_TYPE_EDGE EDGE网络 2 NETWORK_TYPE_UMTS UMTS网络 3  
  538.      * NETWORK_TYPE_HSDPA HSDPA网络 8 NETWORK_TYPE_HSUPA HSUPA网络 9  
  539.      * NETWORK_TYPE_HSPA HSPA网络 10 NETWORK_TYPE_CDMA CDMA网络,IS95A 或 IS95B. 4  
  540.      * NETWORK_TYPE_EVDO_0 EVDO网络, revision 0. 5 NETWORK_TYPE_EVDO_A EVDO网络,  
  541.      * revision A. 6 NETWORK_TYPE_1xRTT 1xRTT网络 7  
  542.      */ 
  543.     tm.getNetworkType();// int  
  544.  
  545.     /*  
  546.      * 手机类型： 例如： PHONE_TYPE_NONE 无信号 PHONE_TYPE_GSM GSM信号 PHONE_TYPE_CDMA  
  547.      * CDMA信号  
  548.      */ 
  549.     tm.getPhoneType();// int  
  550.  
  551.     /*  
  552.      * Returns the ISO country code equivalent for the SIM provider's  
  553.      * country code. 获取ISO国家码，相当于提供SIM卡的国家码。  
  554.      */ 
  555.     tm.getSimCountryIso();// String  
  556.  
  557.     /*  
  558.      * Returns the MCC+MNC (mobile country code + mobile network code) of  
  559.      * the provider of the SIM. 5 or 6 decimal digits.  
  560.      * 获取SIM卡提供的移动国家码和移动网络码.5或6位的十进制数字. SIM卡的状态必须是  
  561.      * SIM_STATE_READY(使用getSimState()判断).  
  562.      */ 
  563.     tm.getSimOperator();// String  
  564.  
  565.     /*  
  566.      * 服务商名称： 例如：中国移动、联通 SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断).  
  567.      */ 
  568.     tm.getSimOperatorName();// String  
  569.  
  570.     /*  
  571.      * SIM卡的序列号： 需要权限：READ_PHONE_STATE  
  572.      */ 
  573.     tm.getSimSerialNumber();// String  
  574.  
  575.     /*  
  576.      * SIM的状态信息： SIM_STATE_UNKNOWN 未知状态 0 SIM_STATE_ABSENT 没插卡 1  
  577.      * SIM_STATE_PIN_REQUIRED 锁定状态，需要用户的PIN码解锁 2 SIM_STATE_PUK_REQUIRED  
  578.      * 锁定状态，需要用户的PUK码解锁 3 SIM_STATE_NETWORK_LOCKED 锁定状态，需要网络的PIN码解锁 4  
  579.      * SIM_STATE_READY 就绪状态 5  
  580.      */ 
  581.     tm.getSimState();// int  
  582.  
  583.     /*  
  584.      * 唯一的用户ID： 例如：IMSI(国际移动用户识别码) for a GSM phone. 需要权限：READ_PHONE_STATE  
  585.      */ 
  586.     tm.getSubscriberId();// String  
  587.  
  588.     /*  
  589.      * 取得和语音邮件相关的标签，即为识别符 需要权限：READ_PHONE_STATE  
  590.      */ 
  591.  
  592.     tm.getVoiceMailAlphaTag();// String  
  593.  
  594.     /*  
  595.      * 获取语音邮件号码： 需要权限：READ_PHONE_STATE  
  596.      */ 
  597.     tm.getVoiceMailNumber();// String  
  598.  
  599.     /*  
  600.      * ICC卡是否存在  
  601.      */ 
  602.     tm.hasIccCard();// boolean  
  603.  
  604.     /*  
  605.      * 是否漫游: (在GSM用途下)  
  606.      */ 
  607.     tm.isNetworkRoaming();//  
  608.  
  609.     String ProvidersName = null;  
  610.     // 返回唯一的用户ID;就是这张卡的编号神马的  
  611.     String IMSI = tm.getSubscriberId(); // 国际移动用户识别码  
  612.     // IMSI号前面3位460是国家，紧接着后面2位00 02是中国移动，01是中国联通，03是中国电信。  
  613.     System.out.println(IMSI);  
  614.     if (IMSI.startsWith("46000") || IMSI.startsWith("46002")) {  
  615.         ProvidersName = "中国移动";  
  616.     } else if (IMSI.startsWith("46001")) {  
  617.  
  618.         ProvidersName = "中国联通";  
  619.  
  620.     } else if (IMSI.startsWith("46003")) {  
  621.  
  622.         ProvidersName = "中国电信";  
  623.  
  624.     }  
  625.     // 返回当前移动终端附近移动终端的信息  
  626.     /*  
  627.      * 附近的电话的信息: 类型：List<NeighboringCellInfo>  
  628.      * 需要权限：android.Manifest.permission#ACCESS_COARSE_UPDATES  
  629.      */ 
  630.     List<NeighboringCellInfo> infos = tm.getNeighboringCellInfo();  
  631.     for (NeighboringCellInfo info : infos) {  
  632.         // 获取邻居小区号  
  633.         int cid = info.getCid();  
  634.         // 获取邻居小区LAC，LAC:  
  635.         // 位置区域码。为了确定移动台的位置，每个GSM/PLMN的覆盖区都被划分成许多位置区，LAC则用于标识不同的位置区。  
  636.         info.getLac();  
  637.         info.getNetworkType();  
  638.         info.getPsc();  
  639.         // 获取邻居小区信号强度  
  640.         info.getRssi();  
  641.     }  
  642.     return "手机号码:" + phoneNum + "\n" + "服务商：" + ProvidersName+"\n" + "IMEI：" + Imei;  
  643.  
  644. }  
  645.  
  646.  
  647. // 显示信息对话框  
  648. public void showDialog(String title, String info) {  
  649.     AlertDialog dialog = new AlertDialog.Builder(this)  
  650.             .setTitle(title)  
  651.             .setMessage(info)  
  652.             .setPositiveButton("close",  
  653.                     new DialogInterface.OnClickListener() {  
  654.                         @Override 
  655.                         public void onClick(DialogInterface dialog,  
  656.                                 int which) {  
  657.                             dialog.cancel();  
  658.                             dialog = null;  
  659.                         }  
  660.                     }).create();  
  661.     dialog.show();  
  662. }