android 常用方法总结

1. public class Toolkit {
2. /**
3. *
4. * Role:Telecom service providers获取手机服务商信息 <BR>
5. *
6. * 需要加入权限<uses-permission
7. * android:name="android.permission.READ_PHONE_STATE"/> <BR>
8. * Date:2012-3-12 <BR>
9. *
10. * @author CODYY)allen
11. */
12. public static String getProvidersName(Context context) {
13. String ProvidersName = "nosim";
14. try {
15. // 返回唯一的用户ID;就是这张卡的编号神马的
16. TelephonyManager telephonyManager = (TelephonyManager) context
17. .getSystemService(Context.TELEPHONY_SERVICE);
18. String IMSI = telephonyManager.getSubscriberId();
19. // IMSI号前面3位460是国家，紧接着后面2位00 02是中国移动，01是中国联通，03是中国电信。
20. if (IMSI.startsWith("46000") || IMSI.startsWith("46002"))
21. ProvidersName = "中国移动";
22. else if (IMSI.startsWith("46001"))
23. ProvidersName = "中国联通";
24. else if (IMSI.startsWith("46003"))
25. ProvidersName = "中国电信";
26. } catch (Exception e) {
27. // TODO Auto-generated catch block
28. e.printStackTrace();
29. return ProvidersName;
30. }
31. return ProvidersName;
32. }
33. /**
34. * 获取手机号
35. *
36. * @param context
37. * @return
38. */
39. public static String getPhone(Context context) {
40. TelephonyManager phoneMgr = (TelephonyManager) context
41. .getSystemService(Context.TELEPHONY_SERVICE);
42. return phoneMgr.getLine1Number();
43. }
44. /**
45. * 获取手机型号
46. *
47. * @return
48. */
49. public static String getPhoneType() {
50. return Build.MODEL;
51. }
52. /**
53. * 获取sdk版本
54. *
55. * @return
56. */
57. public static String getSDKVersion() {
58. return Build.VERSION.SDK;
59. }
60. /**
61. * 获取版本号
62. *
63. * @return
64. */
65. public static String getVersion() {
66. return Build.VERSION.RELEASE;
67. }
68. public static class TelephonyManagerInfo {
69. /**
70. * 电话状态： 1.tm.CALL_STATE_IDLE=0 无活动
71. *
72. * 2.tm.CALL_STATE_RINGING=1 响铃
73. *
74. * 3.tm.CALL_STATE_OFFHOOK=2 摘机
75. */
76. public static int CallState;
77. /**
78. *
79. * 电话方位：(需要权限：android.permission.ACCESS_COARSE_LOCATION)
80. */
81. public static String CellLocation;
82. /**
83. *
84. * 唯一的设备ID：
85. *
86. * GSM手机的 IMEI 和 CDMA手机的 MEID.
87. *
88. * Return null if device ID is not available.
89. */
90. public static String DeviceId;
91. /**
92. *
93. * 设备的软件版本号：
94. *
95. * 例如：the IMEI/SV(software version) for GSM phones.
96. *
97. * Return null if the software version is not available.
98. */
99. public static String DeviceSoftwareVersion;
100. /**
101. *
102. * 手机号：
103. *
104. * GSM手机的 MSISDN.
105. *
106. * Return null if it is unavailable.
107. */
108. public static String Line1Number;
109. /**
110. *
111. * 附近的电话的信息:
112. *
113. * 类型：List<NeighboringCellInfo>
114. *
115. * 需要权限：android.Manifest.permission#ACCESS_COARSE_UPDATES
116. */
117. public static List<NeighboringCellInfo> NeighboringCellInfo;// List<NeighboringCellInfo>
118. /**
119. *
120. * 获取ISO标准的国家码，即国际长途区号。
121. *
122. * 注意：仅当用户已在网络注册后有效。
123. *
124. * 在CDMA网络中结果也许不可靠。
125. */
126. public static String NetworkCountryIso;
127. /**
128. *
129. * MCC+MNC(mobile country code + mobile network code)
130. *
131. * 注意：仅当用户已在网络注册时有效。
132. *
133. * 在CDMA网络中结果也许不可靠。
134. */
135. public static String NetworkOperator;
136. /**
137. *
138. * 按照字母次序的current registered operator(当前已注册的用户)的名字
139. *
140. * 注意：仅当用户已在网络注册时有效。
141. *
142. * 在CDMA网络中结果也许不可靠。
143. */
144. public static String NetworkOperatorName;// String
145. /**
146. * 当前使用的网络类型：
147. *
148. * 例如： NETWORK_TYPE_UNKNOWN 网络类型未知 0 NETWORK_TYPE_GPRS GPRS网络 1
149. *
150. * NETWORK_TYPE_EDGE EDGE网络 2
151. *
152. * NETWORK_TYPE_UMTS UMTS网络 3
153. *
154. * NETWORK_TYPE_HSDPA HSDPA网络 8
155. *
156. * NETWORK_TYPE_HSUPA HSUPA网络 9
157. *
158. * NETWORK_TYPE_HSPA HSPA网络 10
159. *
160. * NETWORK_TYPE_CDMA CDMA网络,IS95A 或 IS95B. 4
161. *
162. * NETWORK_TYPE_EVDO_0 EVDO网络, revision 0. 5
163. *
164. * NETWORK_TYPE_EVDO_A EVDO网络, revision A. 6
165. *
166. * NETWORK_TYPE_1xRTT 1xRTT网络 7
167. */
168. public static int NetworkType;// int
169. /**
170. *
171. * 手机类型：
172. *
173. * 例如： PHONE_TYPE_NONE 无信号
174. *
175. * PHONE_TYPE_GSM GSM信号
176. *
177. * PHONE_TYPE_CDMA CDMA信号
178. */
179. public static int PhoneType;// int
180. /**
181. *
182. * Returns the ISO country code equivalent for the SIM provider's
183. * country code.
184. *
185. * 获取ISO国家码，相当于提供SIM卡的国家码。
186. */
187. public static String SimCountryIso;// String
188. /**
189. *
190. * Returns the MCC+MNC (mobile country code + mobile network code) of
191. * the provider of the SIM. 5 or 6 decimal digits.
192. *
193. * 获取SIM卡提供的移动国家码和移动网络码.5或6位的十进制数字.
194. *
195. * SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断).
196. */
197. public static String SimOperator;// String
198. /**
199. *
200. * 服务商名称：
201. *
202. * 例如：中国移动、联通
203. *
204. * SIM卡的状态必须是 SIM_STATE_READY(使用getSimState()判断).
205. */
206. public static String SimOperatorName;// String
207. /**
208. *
209. * SIM卡的序列号：
210. *
211. * 需要权限：READ_PHONE_STATE
212. */
213. public static String SimSerialNumber;// String
214. /**
215. *
216. * SIM的状态信息：
217. *
218. * SIM_STATE_UNKNOWN 未知状态 0
219. *
220. * SIM_STATE_ABSENT 没插卡 1
221. *
222. * SIM_STATE_PIN_REQUIRED 锁定状态，需要用户的PIN码解锁 2
223. *
224. * SIM_STATE_PUK_REQUIRED 锁定状态，需要用户的PUK码解锁 3
225. *
226. * SIM_STATE_NETWORK_LOCKED 锁定状态，需要网络的PIN码解锁 4
227. *
228. * SIM_STATE_READY 就绪状态 5
229. */
230. public static int SimState;// int
231. /**
232. *
233. * 唯一的用户ID：
234. *
235. * 例如：IMSI(国际移动用户识别码) for a GSM phone.
236. *
237. * 需要权限：READ_PHONE_STATE
238. */
239. public static String SubscriberId;// String
240. /**
241. *
242. * 取得和语音邮件相关的标签，即为识别符
243. *
244. * 需要权限：READ_PHONE_STATE
245. */
246. public static String VoiceMailAlphaTag;// String
247. /**
248. *
249. * 获取语音邮件号码：
250. *
251. * 需要权限：READ_PHONE_STATE
252. */
253. public static String VoiceMailNumber;// String
254. /**
255. *
256. * ICC卡是否存在
257. */
258. public static boolean hasIccCard;// boolean
259. /**
260. *
261. * 是否漫游:
262. *
263. * (在GSM用途下)
264. */
265. public static boolean isNetworkRoaming;
266. }
267. /**
268. * 获取手机唯一ID
269. *
270. * @param context
271. * @return
272. */
273. public static String getPhoneUniqueId(Context context) {
274. TelephonyManager tm = (TelephonyManager) context
275. .getSystemService(context.TELEPHONY_SERVICE);
276. return tm.getDeviceId();
277. }
278. /**
279. * 获取手机信息实体
280. *
281. * @param context
282. * @return
283. */
284. public static TelephonyManagerInfo getTelephonyInfo(Context context) {
285. TelephonyManagerInfo info = new TelephonyManagerInfo();
286. TelephonyManager tm = (TelephonyManager) context
287. .getSystemService(context.TELEPHONY_SERVICE);
288. info.CallState = tm.getCallState();
289. info.CellLocation = tm.getCellLocation().toString();
290. info.DeviceId = tm.getDeviceId();
291. info.DeviceSoftwareVersion = tm.getDeviceSoftwareVersion();
292. info.hasIccCard = tm.hasIccCard();
293. info.isNetworkRoaming = tm.isNetworkRoaming();
294. info.Line1Number = tm.getLine1Number();
295. info.NeighboringCellInfo = tm.getNeighboringCellInfo();
296. info.NetworkCountryIso = tm.getNetworkCountryIso();
297. info.NetworkOperator = tm.getNetworkOperator();
298. info.NetworkOperatorName = tm.getNetworkOperatorName();
299. info.NetworkType = tm.getNetworkType();
300. info.PhoneType = tm.getPhoneType();
301. info.SimCountryIso = tm.getSimCountryIso();
302. info.SimOperator = tm.getSimOperator();
303. info.SimOperatorName = tm.getSimOperatorName();
304. info.SimSerialNumber = tm.getSimSerialNumber();
305. info.SimState = tm.getSimState();
306. info.SubscriberId = tm.getSubscriberId();
307. info.VoiceMailAlphaTag = tm.getVoiceMailAlphaTag();
308. info.VoiceMailNumber = tm.getVoiceMailNumber();
309. return info;
310. }
311. /**
312. * 取得屏幕分辨率大小
313. *
314. * @param context
315. *            Activity上下文
316. * @return第一个值为宽度
317. */
318. public static int[] getDisplayPixes(Activity context) {
319. DisplayMetrics dm = new DisplayMetrics();
320. context.getWindowManager().getDefaultDisplay().getMetrics(dm);
321. return new int[] { dm.widthPixels, dm.heightPixels };
322. }
323. /**
324. * 取得屏幕分辨宽度和高度
325. *
326. * @param context
327. *            Activity上下文
328. * @return第一个值为宽度
329. */
330. public static int[] getDisplayWidthHeight(Activity context) {
331. Display dis = context.getWindowManager().getDefaultDisplay();
332. return new int[] { dis.getWidth(), dis.getHeight() };
333. }
334. /**
335. * 检查是否有可用的网络
336. *
337. * @param context
338. *            上下文
339. * @return true:有网络
340. */
341. public static boolean isAvaliable(Context context) {
342. if (isWiFiActive(context) || isNetworkAvailable(context))
343. // Toast.makeText(context, "有网络！", 300).show();
344. return true;
345. else
346. // Toast.makeText(context, "网络不正常！", 300).show();
347. return false;
348. }
349. /** 返回当前网速 */
350. public static long getNetworkSpeed() {
351. // TODO Auto-generated method stub
352. ProcessBuilder cmd;
353. long readBytes = 0;
354. BufferedReader rd = null;
355. try {
356. String[] args = { "/system/bin/cat", "/proc/net/dev" };
357. cmd = new ProcessBuilder(args);
358. Process process = cmd.start();
359. rd = new BufferedReader(new InputStreamReader(
360. process.getInputStream()));
361. String line;
362. int linecount = 0;
363. while ((line = rd.readLine()) != null) {
364. linecount++;
365. if (line.contains("wlan0") || line.contains("eth0")) {
366. // L.E("获取流量整条字符串",line);
367. String[] delim = line.split(":");
368. if (delim.length >= 2) {
369. String[] numbers = delim[1].trim().split(" ");// 提取数据
370. readBytes = Long.parseLong(numbers[0].trim());//
371. break;
372. }
373. }
374. }
375. rd.close();
376. } catch (Exception ex) {
377. ex.printStackTrace();
378. } finally {
379. if (rd != null) {
380. try {
381. rd.close();
382. } catch (IOException e) {
383. // TODO Auto-generated catch block
384. e.printStackTrace();
385. }
386. }
387. }
388. return readBytes;
389. }
390. /**
391. * 检查wifi是否可用
392. *
393. * @param inContext
394. * @return
395. */
396. public static boolean isWiFiActive(Context inContext) {
397. WifiManager mWifiManager = (WifiManager) inContext
398. .getSystemService(Context.WIFI_SERVICE);
399. WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
400. int ipAddress = wifiInfo == null ? 0 : wifiInfo.getIpAddress();
401. if (mWifiManager.isWifiEnabled() && ipAddress != 0) {
402. System.out.println("**** WIFI is on");
403. return true;
404. } else {
405. System.out.println("**** WIFI is off");
406. return false;
407. }
408. }
409. /**
410. * 检查手机网络(非wifi)是否有用
411. *
412. * @param context
413. * @return
414. */
415. public static boolean isNetworkAvailable(Context context) {
416. ConnectivityManager connectivity = (ConnectivityManager) context
417. .getSystemService(Context.CONNECTIVITY_SERVICE);
418. if (connectivity == null) {
419. return false;
420. } else {
421. NetworkInfo info = connectivity.getActiveNetworkInfo();
422. if (info == null) {
423. return false;
424. } else {
425. if (info.isAvailable()) {
426. return true;
427. }
428. }
429. }
430. return false;
431. }
432. /**
433. * 判断是否为wifi的连接ip
434. *
435. * @return
436. */
437. public static boolean isWifiConnected(Context context) {
438. int ipAddress = getWifiIpInfo(context);
439. if (ipAddress > 0)
440. return true;
441. else
442. return false;
443. }
444. private static int getWifiIpInfo(Context context) {
445. // 获取wifi服务
446. WifiManager wifiManager = (WifiManager) context
447. .getSystemService(Context.WIFI_SERVICE);
448. // 判断wifi是否开启
449. if (!wifiManager.isWifiEnabled()) {
450. wifiManager.setWifiEnabled(true);
451. }
452. WifiInfo wifiInfo = wifiManager.getConnectionInfo();
453. // return String.valueOf(wifiInfo.getIpAddress());
454. int ipAddress = wifiInfo.getIpAddress();
455. return ipAddress;
456. }
457. /**
458. * 获取wifi ip
459. *
460. * @return
461. */
462. public static String getWifiAddress(Context context) {
463. int ipAddress = getWifiIpInfo(context);
464. return intToIp(ipAddress);
465. }
466. private static String intToIp(int i) {
467. return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)
468. + "." + (i >> 24 & 0xFF);
469. }
470. /**
471. * 获取手机mac地址<br/>
472. * 错误返回12个0
473. */
474. public static String getMacAddress(Context context) {
475. // 获取mac地址：
476. String macAddress = "000000000000";
477. try {
478. WifiManager wifiMgr = (WifiManager) context
479. .getSystemService(Context.WIFI_SERVICE);
480. WifiInfo info = (null == wifiMgr ? null : wifiMgr
481. .getConnectionInfo());
482. if (null != info) {
483. if (!TextUtils.isEmpty(info.getMacAddress()))
484. macAddress = info.getMacAddress().replace(":", "");
485. else
486. return macAddress;
487. }
488. } catch (Exception e) {
489. // TODO Auto-generated catch block
490. e.printStackTrace();
491. return macAddress;
492. }
493. return macAddress;
494. }
495. /**
496. * 获取手机ip(此方法在android中使用获取3G网络ip地址)
497. *
498. * @return
499. * @throws SocketException
500. * @throws UnknownHostException
501. */
502. public static String getLocalIpAddress() throws SocketException {
503. for (Enumeration<NetworkInterface> en = NetworkInterface
504. .getNetworkInterfaces(); en.hasMoreElements();) {
505. NetworkInterface intf = en.nextElement();
506. for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr
507. .hasMoreElements();) {
508. InetAddress inetAddress = enumIpAddr.nextElement();
509. if (!inetAddress.isLoopbackAddress()) {
510. return inetAddress.getHostAddress().toString();
511. }
512. }
513. }
514. return null;
515. }
516. /**
517. * 获取本机ip(此方法仅在java程序中)
518. *
519. * @return
520. * @throws UnknownHostException
521. */
522. public static String getHostAddress() throws UnknownHostException {
523. InetAddress address = null;
524. address = InetAddress.getLocalHost();
525. return address.getHostAddress();
526. }
527. /**
528. * 读取文本，一次读取多个字节，默认为1024
529. *
530. * @param file
531. *            文件名称(在sd卡下面的data/data/应用程序包下面)
532. * @param context
533. *            上下文
534. * @param encode
535. *            编码方式
536. * @return
537. * @throws IOException
538. */
539. public static String readFromFileByChar(String file, Context context,
540. String encode) throws IOException {
541. FileInputStream fis = context.openFileInput(file);
542. BufferedReader br = new BufferedReader(new InputStreamReader(fis,
543. encode));
544. // Log.i(TAG, br.readLine());
545. int index = 0;
546. char[] buffer = new char[1024];// 一次性读取1024个字符
547. StringBuffer sb = new StringBuffer();
548. while ((index = br.read(buffer)) != -1) {// 一次读多个字符
549. // 同样屏蔽掉r不显示
550. if ((index == buffer.length) && (buffer[buffer.length - 1] != 'r')) {
551. sb.append(buffer);
552. } else {
553. for (int i = 0; i < index; i++) {
554. if (buffer[i] == 'r') {
555. continue;// 停止执行当前的迭代,然后退回循环开始处
556. } else {
557. sb.append(buffer[i]);
558. }
559. }
560. }
561. }
562. br.close();
563. fis.close();
564. return sb.toString();
565. // return br.readLine();
566. }
567. /**
568. * 按行读取文本
569. *
570. * @param file
571. *            文件名
572. * @param context
573. *            上下文
574. * @param encode
575. *            编码方式
576. * @return
577. * @throws IOException
578. */
579. public static String readFromFileByLine(String file, Context context,
580. String encode) throws IOException {
581. FileInputStream fis = context.openFileInput(file);
582. BufferedReader br = new BufferedReader(new InputStreamReader(fis,
583. encode));
584. // Log.i(TAG, br.readLine());
585. StringBuffer sb = new StringBuffer();
586. String temp;
587. while ((temp = br.readLine()) != null) {// 一次读一行
588. sb.append(temp);
589. }
590. br.close();
591. fis.close();
592. return sb.toString();
593. // return br.readLine();
594. }
595. /**
596. * 一次将string内容写入到文件
597. *
598. * @param context
599. *            上下文
600. * @param file
601. *            文件名
602. * @param content
603. *            写入的内容
604. * @throws IOException
605. */
606. public static void writeToFile(Context context, String file, String content)
607. throws IOException {
608. FileOutputStream fos = context.openFileOutput(file,
609. context.MODE_PRIVATE);
610. BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(fos));
611. bw.write(content);
612. bw.flush();
613. bw.close();
614. fos.close();
615. }
616. /**
617. * 将object序列化到filename文件中
618. *
619. * @param fileName
620. *            文件名,包括路径
621. * @param object
622. *            序列化的对象
623. */
624. public static boolean writeFileByObject(String fileName, Object object) {
625. try {
626. FileOutputStream fos = new FileOutputStream(fileName);
627. ObjectOutputStream oos = new ObjectOutputStream(fos);
628. oos.writeObject(object);
629. oos.flush();
630. oos.close();
631. fos.close();
632. return true;
633. } catch (Exception e) {
634. e.printStackTrace();
635. return false;
636. }
637. }
638. /**
639. * 反序列化
640. *
641. * @param fileName
642. *            文件名,包括详细路径
643. * @return Object类型的对象
644. */
645. public static Object readFileByObject(String fileName) {
646. try {
647. FileInputStream fis = new FileInputStream(fileName);
648. ObjectInputStream ois = new ObjectInputStream(fis);
649. Object o = ois.readObject();
650. ois.close();
651. fis.close();
652. return o;
653. } catch (Exception e) {
654. return null;
655. }
656. }
657. /**
658. * 按照指定的宽度和高度压缩图片(这是android 2.2以上才有的方法)
659. *
660. * @param bm
661. * @param w
662. * @param h
663. * @return
664. */
665. public static Bitmap compressBitmap(Bitmap bm, int w, int h) {
666. return ThumbnailUtils.extractThumbnail(bm, w, h);
667. }
668. /**
669. * 等比例压缩图片
670. *
671. * @param is
672. *            图片输入流
673. * @param scalePix
674. *            压缩的尺寸
675. * @return
676. */
677. public static Bitmap compressBitmapByscale(InputStream is, int scalePix) {
678. BitmapFactory.Options opt = new Options();
679. opt.inSampleSize = scalePix;
680. return BitmapFactory.decodeStream(is, null, opt);
681. }
682. /**
683. * 等比例压缩图片
684. *
685. * @param data
686. *            byte[]数组
687. *
688. * @param ratio
689. *            压缩的尺寸
690. * @return
691. */
692. public static Bitmap compressBitmap(byte[] data, int ratio) {
693. BitmapFactory.Options opts = new Options();
694. opts.inJustDecodeBounds = false;
695. opts.inSampleSize = ratio;
696. // 得到新的图片
697. return BitmapFactory.decodeByteArray(data, 0, data.length, opts);
698. }
699. /**
700. * 自动压缩图片(根据能够压缩的比例)
701. *
702. * @param map
703. * @return
704. */
705. public static Bitmap compressBitmapAuto(Bitmap map, int scalePix) {
706. BitmapFactory.Options opts = new BitmapFactory.Options();
707. ByteArrayOutputStream os = new ByteArrayOutputStream();
708. byte[] data = os.toByteArray();
709. opts.inJustDecodeBounds = true;
710. map.compress(CompressFormat.PNG, 100, os);
711. Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
712. opts.inJustDecodeBounds = false;
713. int be = (int) (opts.outHeight / (float) scalePix);
714. if (be <= 0)
715. be = 1;
716. opts.inSampleSize = be;
717. bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, opts);
718. return bitmap;
719. }
720. /** 根据屏幕大小适屏压缩 --2012/11/13-- */
721. public static Bitmap compressBitmapFixDisplay(Activity context, byte[] data) {
722. BitmapFactory.Options opts = new Options();
723. opts.inJustDecodeBounds = true;// 设置查看图片的大小，不分配内存
724. BitmapFactory.decodeByteArray(data, 0, data.length, opts);
725. int height = context.getWindowManager().getDefaultDisplay().getHeight();// 获取屏幕大小
726. int width = context.getWindowManager().getDefaultDisplay().getWidth();
727. int hratio = (int) Math.ceil(opts.outHeight / (float) height);// 图片的高度比上屏幕的高度
728. int wratio = (int) Math.ceil(opts.outWidth / (float) width);
729. if (hratio > 1 || wratio > 1) {// 如果图片超出屏幕范围
730. if (hratio > wratio)// 如果高度大于宽度
731. opts.inSampleSize = hratio;
732. else
733. opts.inSampleSize = wratio;
734. }
735. opts.inJustDecodeBounds = false;// 设置分配图片的大小
736. Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,
737. opts);
738. return bitmap;
739. }
740. /**
741. * 压缩图片
742. *
743. * @param bm
744. *            所要转换的bitmap
745. * @param newWidth新的宽
746. * @param newHeight新的高
747. * @return 指定宽高的bitmap
748. */
749. public static Bitmap zoomImg(Bitmap bm, int newWidth, int newHeight) {
750. // 获得图片的宽高
751. int width = bm.getWidth();
752. int height = bm.getHeight();
753. // 计算缩放比例
754. float scaleWidth = ((float) newWidth) / width;
755. float scaleHeight = ((float) newHeight) / height;
756. // 取得想要缩放的matrix参数
757. Matrix matrix = new Matrix();
758. matrix.postScale(scaleWidth, scaleHeight);
759. // 得到新的图片
760. Bitmap newbm = Bitmap.createBitmap(bm, 0, 0, width, height, matrix,
761. true);
762. if (!bm.isRecycled())// 回收bitmap
763. bm.recycle();
764. return newbm;
765. }
766. /**
767. * 动态设置ImageView的布局宽度和高度
768. *
769. * @param iv
770. *            ImageView对象
771. * @param width
772. *            要设置的宽度(0:充满父容器)
773. * @param height
774. *            要设置的高度(0:充满父容器)
775. */
776. public static void setImagePixes(ImageView iv, int width, int height) {
777. ViewGroup.LayoutParams params = iv.getLayoutParams();
778. if (width == 0 && height != 0)// 如果宽度为0
779. {
780. params.height = height;
781. params.width = ViewGroup.LayoutParams.FILL_PARENT;
782. } else if (height == 0 && width != 0) {// 高度为 0
783. params.height = ViewGroup.LayoutParams.FILL_PARENT;
784. params.width = width;
785. } else if (width == 0 && height == 0) {
786. params.height = ViewGroup.LayoutParams.FILL_PARENT;
787. params.width = ViewGroup.LayoutParams.FILL_PARENT;
788. } else {
789. params.height = height;
790. params.width = width;
791. }
792. iv.setLayoutParams(params);
793. }
794. /** activity转换为view */
795. @SuppressWarnings("deprecation")
796. public static View activityToView(Context parent, Intent intent) {
797. LocalActivityManager mLocalActivityManager = new LocalActivityManager(
798. (Activity) parent, true);
799. final Window w = mLocalActivityManager.startActivity("TagName", intent);
800. final View wd = w != null ? w.getDecorView() : null;
801. if (wd != null) {
802. wd.setVisibility(View.VISIBLE);
803. wd.setFocusableInTouchMode(true);
804. ((ViewGroup) wd)
805. .setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
806. }
807. return wd;
808. }
809. /***
810. * 动态设置listview的高度
811. *
812. * @param listView
813. */
814. public static void setListViewHeightBasedOnChildren(ListView listView) {
815. ListAdapter listAdapter = listView.getAdapter();
816. if (listAdapter == null) {
817. return;
818. }
819. int totalHeight = 0;
820. for (int i = 0; i < listAdapter.getCount(); i++) {
821. View listItem = listAdapter.getView(i, null, listView);
822. listItem.measure(0, 0);
823. totalHeight += listItem.getMeasuredHeight();
824. }
825. ViewGroup.LayoutParams params = listView.getLayoutParams();
826. params.height = totalHeight
827. + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
828. // params.height += 5;// if without this statement,the listview will be
829. // a
830. // little short
831. // listView.getDividerHeight()获取子项间分隔符占用的高度
832. // params.height最后得到整个ListView完整显示需要的高度
833. listView.setLayoutParams(params);
834. }
835. /**
836. * 将Drawable转化为Bitmap
837. *
838. * @param drawable
839. * @return
840. */
841. public static Bitmap drawableToBitmap(Drawable drawable) {
842. int width = drawable.getIntrinsicWidth();
843. int height = drawable.getIntrinsicHeight();
844. Bitmap bitmap = Bitmap.createBitmap(width, height, drawable
845. .getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
846. : Bitmap.Config.RGB_565);
847. Canvas canvas = new Canvas(bitmap);
848. drawable.setBounds(0, 0, width, height);
849. drawable.draw(canvas);
850. return bitmap;
851. }
852. /**
853. * 将图片的四角圆化
854. *
855. * @param bitmap
856. * @param radius
857. *            圆角弧度，数值越大弧度越大
858. * @return
859. */
860. public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, int radius) {
861. Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
862. bitmap.getHeight(), Config.ARGB_8888);
863. // 得到画布
864. Canvas canvas = new Canvas(output);
865. // 将画布的四角圆化
866. final int color = Color.RED;
867. final Paint paint = new Paint();
868. // 得到与图像相同大小的区域 由构造的四个值决定区域的位置以及大小
869. final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
870. final RectF rectF = new RectF(rect);
871. // 值越大角度越明显
872. final float roundPx = radius;
873. paint.setAntiAlias(true);
874. canvas.drawARGB(0, 0, 0, 0);
875. paint.setColor(color);
876. // drawRoundRect的第2,3个参数一样则画的是正圆的一角，如果数值不同则是椭圆的一角
877. canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
878. paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); // 设置形式为背景
879. canvas.drawBitmap(bitmap, rect, rect, paint);
880. return output;
881. }
882. /**
883. * 获得带倒影的图片方法
884. *
885. * @param bitmap
886. * @return
887. */
888. public static Bitmap createReflectionImageWithOrigin(Bitmap bitmap) {
889. final int reflectionGap = 4;
890. int width = bitmap.getWidth();
891. int height = bitmap.getHeight();
892. Matrix matrix = new Matrix();
893. matrix.preScale(1, -1);
894. Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2,
895. width, height / 2, matrix, false);
896. Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
897. (height + height / 2), Config.ARGB_8888);
898. Canvas canvas = new Canvas(bitmapWithReflection);
899. canvas.drawBitmap(bitmap, 0, 0, null);
900. Paint deafalutPaint = new Paint();
901. canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);
902. canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
903. Paint paint = new Paint();
904. LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
905. bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
906. 0x00ffffff, TileMode.CLAMP);
907. paint.setShader(shader);// 设置阴影
908. // Set the Transfer mode to be porter duff and destination in
909. paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
910. // Draw a rectangle using the paint with our linear gradient
911. canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
912. + reflectionGap, paint);
913. return bitmapWithReflection;
914. }
915. /**
916. * 向preferences写入数据
917. *
918. * @param context
919. *            上下文
920. * @param key
921. *            键
922. * @param value
923. *            写入的内容
924. */
925. public static void writeToPreferences(Context context, String filename,
926. String key, String value) {
927. // 得到preferences对象
928. SharedPreferences.Editor editor = context.getSharedPreferences(
929. filename, android.content.Context.MODE_PRIVATE).edit();
930. // editor = preferences.edit();
931. editor.putString(key, value);
932. editor.commit();
933. }
934. /**
935. * 向preference中读取数据 data/data/package/shared_prefs
936. *
937. * @param context
938. *            上下文
939. * @param filename
940. *            文件名
941. * @param key
942. *            键
943. * @param defaultValue
944. *            默认值
945. * @return
946. */
947. public static String readFromPreferences(Context context, String filename,
948. String key, String defaultValue) {
949. // 得到preferences对象
950. SharedPreferences preferences = context.getSharedPreferences(filename,
951. android.content.Context.MODE_PRIVATE
952. | android.content.Context.MODE_APPEND);
953. return preferences.getString(key, defaultValue);
954. }
955. /**
956. * 加载properties文件
957. *
958. * @param context
959. * @param file
960. * @return
961. * @throws Exception
962. */
963. public static Properties loadProperties(Context context, String file,
964. String encode) throws Exception {
965. Properties properties = new Properties();
966. FileInputStream s = new FileInputStream(file);
967. properties.load(s);
968. return properties;
969. }
970. /**
971. * 保存到properties文件中
972. *
973. * @param context
974. * @param file
975. * @param properties
976. * @throws Exception
977. */
978. public static void saveProperties(Context context, String file,
979. String encode, Properties properties) throws Exception {
980. FileOutputStream s = new FileOutputStream(file, false);
981. properties.store(s, "");
982. }
983. // ---------------------------------------------------------------------------------------------------
984. /**
985. * 从网络上下载
986. *
987. * @param url
988. * @return
989. * @throws IOException
990. */
991. public static Bitmap getBitMapFromUrl(String url) throws IOException {
992. Bitmap bitmap = null;
993. URL u = null;
994. HttpURLConnection conn = null;
995. InputStream is = null;
996. u = new URL(url);
997. conn = (HttpURLConnection) u.openConnection();
998. is = conn.getInputStream();
999. bitmap = BitmapFactory.decodeStream(is);
1000. return bitmap;
1001. }
1002. /**
1003. * 异步加载网络图片
1004. *
1005. * @param src图片路径
1006. * @param iv
1007. *            imageview
1008. * @param callback回调接口
1009. */
1010. public static void loadImage(final String src, final ImageView iv,
1011. final ImageCallBack callback) {
1012. final Handler handler = new Handler() {
1013. public void handleMessage(Message msg) {
1014. super.handleMessage(msg);
1015. callback.setImageBitmap((Bitmap) msg.obj, iv, src);
1016. }
1017. };
1018. new Thread(new Runnable() {
1019. @Override
1020. public void run() {
1021. Bitmap bitmap = null;
1022. try {
1023. bitmap = getBitMapFromUrl(src);
1024. } catch (IOException e) {
1025. e.printStackTrace();
1026. }
1027. if (bitmap != null) {
1028. Message msg = handler.obtainMessage(0, bitmap);
1029. handler.sendMessage(msg);
1030. }
1031. }
1032. }).start();
1033. }
1034. /**
1035. * 获取网络byte流的图片
1036. *
1037. * @param src
1038. * @return
1039. * @throws Exception
1040. */
1041. public static byte[] getImageBytes(String src) throws Exception {
1042. URL url = new URL(src);
1043. HttpURLConnection conn = (HttpURLConnection) url.openConnection();
1044. conn.setDoInput(true);
1045. conn.setRequestMethod("GET");
1046. conn.setConnectTimeout(5000);// 设置延迟时间为5s
1047. InputStream is = conn.getInputStream();
1048. ByteArrayOutputStream bos = new ByteArrayOutputStream();
1049. int len = 0;
1050. byte[] buffer = new byte[1024];
1051. while ((len = is.read(buffer)) != -1) {
1052. bos.write(buffer, 0, len);
1053. }
1054. return bos.toByteArray();
1055. }
1056. /**
1057. * 压缩图片
1058. *
1059. * @param bm
1060. *            所要转换的bitmap
1061. * @param newWidth新的宽
1062. * @param newHeight新的高
1063. * @return 指定宽高的bitmap
1064. */
1065. public static Bitmap zoomBitmap(byte[] data, int newWidth, int newHeight) {
1066. BitmapFactory.Options opts = new Options();
1067. opts.inJustDecodeBounds = false;
1068. opts.inSampleSize = 10;
1069. // 得到新的图片
1070. Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,
1071. opts);
1072. // 获得图片的宽高
1073. int width = bitmap.getWidth();
1074. int height = bitmap.getHeight();
1075. // 计算缩放比例
1076. float scaleWidth = ((float) newWidth) / width;
1077. float scaleHeight = ((float) newHeight) / height;
1078. // 取得想要缩放的matrix参数
1079. Matrix matrix = new Matrix();
1080. matrix.postScale(scaleWidth, scaleHeight);
1081. Bitmap newbm = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix,
1082. true);
1083. if (!bitmap.isRecycled())// 回收bitmap
1084. bitmap.recycle();
1085. return newbm;
1086. }
1087. /**
1088. * 异步加载网络图片
1089. *
1090. * @param src
1091. *            url地址
1092. * @param iv
1093. *            传入的iamgeView
1094. * @param callback
1095. *            回调函数
1096. */
1097. public static void AsycloadImage(final String src, final ImageView iv,
1098. final ImageCallBack callback) {
1099. final Handler handler = new Handler() {
1100. public void handleMessage(Message msg) {
1101. super.handleMessage(msg);
1102. callback.setImageBitmap((Bitmap) msg.obj, iv, src);
1103. }
1104. };
1105. new Thread(new Runnable() {
1106. @Override
1107. public void run() {
1108. byte[] data = null;
1109. Bitmap bitmap = null;
1110. try {
1111. data = getImageBytes(src);
1112. bitmap = compressBitmap(data, 3);
1113. } catch (Exception e) {
1114. e.printStackTrace();
1115. }
1116. if (bitmap != null) {
1117. Message msg = handler.obtainMessage(0, bitmap);
1118. handler.sendMessage(msg);
1119. }
1120. }
1121. }).start();
1122. }
1123. /**
1124. * 异步加载图片
1125. *
1126. * @param url
1127. *            图片路径
1128. * @param iv
1129. *            ImageView
1130. * @param imgCache
1131. *            缓存
1132. * @param callback
1133. *            回调接口
1134. */
1135. public static void AyncLoadImageFromUrl(final String url,
1136. final ImageView iv,
1137. final Map<String, SoftReference<Bitmap>> imgCache,
1138. final ImageCallBack callback) {
1139. if (imgCache.containsKey(url))// 如果缓存中存在
1140. {
1141. iv.setImageBitmap(imgCache.get(url).get());
1142. return;
1143. }
1144. final Handler handler = new Handler() {
1145. public void handleMessage(Message msg) {
1146. super.handleMessage(msg);
1147. callback.setImageBitmap((Bitmap) msg.obj, iv, url);
1148. }
1149. };
1150. new Thread(new Runnable() {
1151. @Override
1152. public void run() {
1153. byte[] data = null;
1154. Bitmap bitmap = null;
1155. try {
1156. data = getImageBytes(url);
1157. bitmap = compressBitmap(data, 3);
1158. } catch (Exception e) {
1159. e.printStackTrace();
1160. }
1161. if (bitmap != null) {
1162. // 保存到缓存中
1163. // 将图片保存到缓存中
1164. imgCache.put(url, new SoftReference<Bitmap>(bitmap));
1165. Message msg = handler.obtainMessage(0, bitmap);
1166. handler.sendMessage(msg);
1167. }
1168. }
1169. }).start();
1170. }
1171. /**
1172. * 保存图片到sdcard，并且返回图片名称，带后缀名
1173. *
1174. * @param context
1175. * @param fileName
1176. *            图片目录名称
1177. * @param photo
1178. *            图片路径
1179. * @throws IOException
1180. */
1181. public static String saveImgToSdcard(Context context, String fileName,
1182. String photo) throws IOException {
1183. String url = photo;
1184. // 获取图片名称,包含后缀
1185. String imgName = url.substring(url.lastIndexOf("/") + 1, url.length());
1186. URL Url = new URL(url);
1187. HttpURLConnection conn = (HttpURLConnection) Url.openConnection();
1188. InputStream is = conn.getInputStream();
1189. String saveUrl = context.getFilesDir() + "/" + fileName + "/" + imgName;
1190. File file = new File(saveUrl);
1191. // 如果图片文件存在
1192. if (file.exists())
1193. return imgName;
1194. FileOutputStream fos = new FileOutputStream(file);
1195. byte[] data = new byte[512];
1196. int len = 0;
1197. while ((len = is.read(data)) != -1) {
1198. fos.write(data, 0, len);
1199. }
1200. fos.flush();
1201. fos.close();
1202. return imgName;
1203. }
1204. /**
1205. * 保存图片到指定的目录
1206. *
1207. * @param context
1208. *            上下文
1209. * @param filedir
1210. *            图片目录名称
1211. * @param name
1212. *            图片名称
1213. * @param bitmap
1214. *            图片
1215. * @throws Exception
1216. */
1217. public static void saveBitmapToSdcard(Context context, String filedir,
1218. String name, Bitmap bitmap) throws Exception {
1219. String path = context.getFilesDir() + File.separator + filedir
1220. + File.separator;
1221. File file = new File(path);
1222. if (!file.exists()) {
1223. file.mkdir();
1224. }
1225. file = new File(path + name + ".png");
1226. if (file.exists())
1227. return;
1228. FileOutputStream fos = new FileOutputStream(file);
1229. bitmap.compress(CompressFormat.PNG, 100, fos);
1230. fos.close();
1231. }
1232. /** 从sdcard制定目录读取图片 */
1233. public static Bitmap getBitmapFromSdcard(Context context, String file,
1234. String name) {
1235. String src = context.getFilesDir() + "/" + file + "/" + name;
1236. Bitmap bitmap = BitmapFactory.decodeFile(src);
1237. return bitmap;
1238. }
1239. /**
1240. * 从缓存中读取
1241. *
1242. * @param url
1243. * @return
1244. * @throws Exception
1245. */
1246. public static Bitmap getImgFromCache(final String url, final ImageView iv,
1247. final Map<String, SoftReference<Bitmap>> imgCache,
1248. final ImageCallBack callback) throws Exception {
1249. // 从内存中读取
1250. if (imgCache.containsKey(url)) {
1251. synchronized (imgCache) {
1252. SoftReference<Bitmap> bitmapReference = imgCache.get(url);
1253. if (null != bitmapReference) {
1254. return bitmapReference.get();
1255. }
1256. }
1257. }
1258. final Handler handler = new Handler() {
1259. @Override
1260. public void handleMessage(Message msg) {
1261. super.handleMessage(msg);
1262. callback.setImageBitmap((Bitmap) msg.obj, iv, url);
1263. }
1264. };
1265. // 從網絡中下載
1266. new Thread(new Runnable() {
1267. @Override
1268. public void run() {
1269. Bitmap bitmap = null;
1270. try {
1271. bitmap = getBitMapFromUrl(url);
1272. } catch (IOException e) {
1273. e.printStackTrace();
1274. }
1275. // 将图片保存进内存中
1276. imgCache.put(url, new SoftReference<Bitmap>(bitmap));
1277. Message msg = handler.obtainMessage(0, bitmap);
1278. handler.sendMessage(msg);
1279. }
1280. }).start();
1281. return null;
1282. }
1283. public interface ImageCallBack {
1284. public void setImageBitmap(Bitmap bitmap, ImageView iv, String url);
1285. }
1286. /**
1287. * get 请求
1288. *
1289. * @param url路径
1290. * @return
1291. * @throws Exception
1292. * @throws ClientProtocolException
1293. */
1294. public static HttpResponse get(String url) throws Exception {
1295. HttpResponse response = null;
1296. HttpClient client = new DefaultHttpClient();
1297. // 设置连接超时
1298. client.getParams().setIntParameter(
1299. HttpConnectionParams.CONNECTION_TIMEOUT, 10000);
1300. // 设置编码
1301. // client.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET,
1302. // "gb2312");
1303. // get方式
1304. HttpGet httpRequest = new HttpGet(url);
1305. // 发出一个request,并返回一个基于http协议的response
1306. // System.out.println("------toolkit 1066----------");
1307. response = client.execute(httpRequest);
1308. return response;
1309. }
1310. /**
1311. * post请求
1312. *
1313. * @param path
1314. *            请求的地址
1315. * @param params
1316. *            参数列表
1317. * @return
1318. * @throws Exception
1319. */
1320. public static InputStream postRequest(String path,
1321. Map<String, String> params) throws Exception {
1322. // 封装请求参数
1323. List<NameValuePair> pair = new ArrayList<NameValuePair>();
1324. if (params != null && !params.isEmpty()) {
1325. for (Map.Entry<String, String> entry : params.entrySet()) {
1326. pair.add(new BasicNameValuePair(entry.getKey(), entry
1327. .getValue()));
1328. }
1329. }
1330. // 把请求参数变成请求体部分
1331. UrlEncodedFormEntity uee = new UrlEncodedFormEntity(pair, "utf-8");
1332. // 使用HttpPost对象设置发送的URL路径
1333. final HttpPost post = new HttpPost(path);
1334. // 发送请求体
1335. post.setEntity(uee);
1336. // 创建一个浏览器对象，以把POST对象向服务器发送，并返回响应消息
1337. DefaultHttpClient dhc = new DefaultHttpClient();
1338. // 设置连接超时
1339. dhc.getParams().setIntParameter(
1340. HttpConnectionParams.CONNECTION_TIMEOUT, 10000);
1341. dhc.getParams().setIntParameter(HttpConnectionParams.SO_TIMEOUT, 10000); // 设置等待数据超时10s
1342. HttpResponse response = dhc.execute(post);
1343. Log.e("TAG", "服务器返回状态：----" + response.getStatusLine().getStatusCode());
1344. if (response != null && response.getStatusLine().getStatusCode() == 200) {
1345. return response.getEntity().getContent();
1346. } else
1347. post.abort();
1348. return null;
1349. }
1350. /**
1351. * post请求
1352. *
1353. * @param url路径
1354. * @param list
1355. *            参数列表
1356. * @return
1357. * @throws IOException
1358. * @throws ClientProtocolException
1359. */
1360. public static HttpResponse post(String url, List<BasicNameValuePair> list,
1361. String encode) throws Throwable {
1362. HttpResponse response = null;
1363. HttpClient client = new DefaultHttpClient();
1364. // 设置连接超时
1365. client.getParams().setIntParameter(
1366. HttpConnectionParams.CONNECTION_TIMEOUT, 5000);
1367. client.getParams().setIntParameter(HttpConnectionParams.SO_TIMEOUT,
1368. 5000); // 设置等待数据超时5s
1369. // 创建一个 基于http协议的请求(post方式)
1370. HttpPost httpRequest = new HttpPost(url);
1371. if (list != null) {
1372. UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, encode);
1373. // 将请求中的参数信息放置到request中
1374. httpRequest.setEntity(entity);
1375. }
1376. // 发出一个request,并返回一个基于http协议的response
1377. response = client.execute(httpRequest);
1378. return response;
1379. }
1380. /*
1381. * 参数说明: uploadUrl: Servlet的url fileName: 上传图片的文件名(如: qq.png) fileUrl:
1382. * 上传文件在手机客户端的完整路径(如: /sdcard/qq.png)
1383. */
1384. public static InputStream upload(String uploadUrl, String fileName,
1385. String fileUrl) throws Exception {
1386. String end = "\r\n";
1387. String twoHyphens = "--";
1388. String boundary = "*****";
1389. InputStream is = null;
1390. URL url = new URL(uploadUrl);
1391. HttpURLConnection conn = (HttpURLConnection) url.openConnection();
1392. /* 允许Input、Output，不使用Cache */
1393. conn.setDoInput(true);
1394. conn.setDoOutput(true);
1395. conn.setUseCaches(false);
1396. /* 设置传送的method=POST */
1397. conn.setRequestMethod("POST");
1398. /* setRequestProperty */
1399. conn.setRequestProperty("Connection", "Keep-Alive");
1400. conn.setRequestProperty("Charset", "UTF-8");
1401. conn.setRequestProperty("Content-Type", "multipart/form-data;boundary="
1402. + boundary);
1403. // 将phone放置到请求的头部
1404. if (fileName != null && fileUrl != null) {
1405. conn.setRequestProperty("picName", fileName);
1406. /* 设置DataOutputStream */
1407. DataOutputStream ds = new DataOutputStream(conn.getOutputStream());
1408. ds.writeBytes(twoHyphens + boundary + end);
1409. ds.writeBytes("Content-Disposition: form-data; "
1410. + "name=\"file1\";filename=\"" + fileName + "\"" + end);
1411. ds.writeBytes(end);
1412. /* 取得文件的FileInputStream */
1413. FileInputStream fStream = new FileInputStream(fileUrl);
1414. /* 设置每次写入1024bytes */
1415. int bufferSize = 1024;
1416. byte[] buffer = new byte[bufferSize];
1417. int length = -1;
1418. /* 从文件读取数据至缓冲区 */
1419. while ((length = fStream.read(buffer)) != -1) {
1420. /* 将资料写入DataOutputStream中 */
1421. ds.write(buffer, 0, length);
1422. }
1423. ds.writeBytes(end);
1424. ds.writeBytes(twoHyphens + boundary + twoHyphens + end);
1425. /* close streams */
1426. fStream.close();
1427. ds.flush();
1428. ds.close();
1429. }
1430. /* 取得Response内容 */
1431. is = conn.getInputStream();
1432. return is;
1433. }
1434. // -------------------------------------加密，验证，转换系列-----------------------------------------------------------
1435. /**
1436. * 验证是否为手机号码
1437. *
1438. * @param mobiles
1439. * @return
1440. */
1441. public static boolean isMobileNO(String mobiles) {
1442. // Pattern p =
1443. // Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,1,2,5-9]))\\d{8}$");
1444. Pattern p = Pattern.compile("^([0-9]{3})\\d{8}$");
1445. Matcher m = p.matcher(mobiles);
1446. return m.matches();
1447. }
1448. /**
1449. * 验证输入是否为邮箱
1450. *
1451. * @param strEmail
1452. * @return
1453. */
1454. public static boolean isEmail(String strEmail) {
1455. String strPattern = "^[a-zA-Z][\\w\\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\\w\\.-]*[a-zA-Z0-9]\\.[a-zA-Z][a-zA-Z\\.]*[a-zA-Z]$";
1456. Pattern p = Pattern.compile(strPattern);
1457. Matcher m = p.matcher(strEmail);
1458. return m.matches();
1459. }
1460. /**
1461. * 验证输入是否6位数字
1462. *
1463. * @param strEmail
1464. * @return
1465. */
1466. public static boolean isCode(String strCode) {
1467. String strPattern = "^[0-9]{6}";
1468. Pattern p = Pattern.compile(strPattern);
1469. Matcher m = p.matcher(strCode);
1470. return m.matches();
1471. }
1472. /**
1473. * 验证输入是否6位字符包含数字和字母，不包含特殊字符
1474. *
1475. * @param strEmail
1476. * @return
1477. */
1478. public static boolean isCheckCode(String strCode) {
1479. String strPattern = "^[0-9a-zA-Z]{6}";
1480. Pattern p = Pattern.compile(strPattern);
1481. Matcher m = p.matcher(strCode);
1482. return m.matches();
1483. }
1484. /**
1485. * 验证输入是否6到12位上字符包含数字和字母，包含特殊字符
1486. *
1487. * @param strEmail
1488. * @return
1489. */
1490. public static boolean isPassCode(String strCode) {
1491. String strPattern = "^[0-9a-zA-Z@*%#()><!_~]{6,12}";
1492. Pattern p = Pattern.compile(strPattern);
1493. Matcher m = p.matcher(strCode);
1494. return m.matches();
1495. }
1496. /**
1497. * 过滤url
1498. *
1499. * @param str
1500. * @return
1501. */
1502. public static boolean isLegalUrlParameters(String str) {
1503. String strPattern = "[&=\\s]+";
1504. Pattern p = Pattern.compile(strPattern);
1505. Matcher m = p.matcher(str);
1506. return m.find();
1507. }
1508. /**
1509. * 验证ip
1510. *
1511. * @param text
1512. * @return
1513. */
1514. public static boolean isIp(String text) {
1515. if (text != null && text != "") {
1516. // 定义正则表达式
1517. String regex = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
1518. + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
1519. + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
1520. + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";
1521. // 判断ip地址是否与正则表达式匹配
1522. if (text.matches(regex)) {
1523. // 返回判断信息
1524. return true;
1525. } else {
1526. return false;
1527. }
1528. }
1529. return false;
1530. }
1531. /**
1532. * md5加密
1533. *
1534. * @param s
1535. * @return
1536. * @throws Exception
1537. */
1538. public final static String MD5(String s) throws Exception {
1539. char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
1540. 'a', 'b', 'c', 'd', 'e', 'f' };
1541. byte[] strTemp = s.getBytes();
1542. MessageDigest mdTemp = MessageDigest.getInstance("MD5");
1543. mdTemp.update(strTemp);
1544. byte[] md = mdTemp.digest();
1545. int j = md.length;
1546. char str[] = new char[j * 2];
1547. int k = 0;
1548. for (int i = 0; i < j; i++) {
1549. byte byte0 = md[i];
1550. str[k++] = hexDigits[byte0 >>> 4 & 0xf];
1551. str[k++] = hexDigits[byte0 & 0xf];
1552. }
1553. return new String(str);
1554. }
1555. /**
1556. * 加密
1557. *
1558. * @param sSrc
1559. *            原文
1560. * @param sKey
1561. *            密码是16位
1562. * @return
1563. * @throws Exception
1564. */
1565. public static String AESEncrypt(String sSrc, String sKey) throws Exception {
1566. if (sKey == null) {
1567. System.out.print("Key为空null");
1568. return null;
1569. }
1570. // 判断Key是否为16位
1571. if (sKey.length() != 16) {
1572. System.out.print("Key无效");
1573. return null;
1574. }
1575. byte[] raw = sKey.getBytes();
1576. SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
1577. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
1578. IvParameterSpec iv = new IvParameterSpec("0102030405060708".getBytes());
1579. cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
1580. byte[] encrypted = cipher.doFinal(sSrc.getBytes());
1581. return byte2hex(encrypted).toLowerCase();
1582. }
1583. /**
1584. * 解密
1585. *
1586. * @param sSrc
1587. * @param sKey密码是16位
1588. * @return
1589. * @throws Exception
1590. */
1591. public static String AESDecrypt(String sSrc, String sKey) throws Exception {
1592. // 判断Key是否正确
1593. if (sKey == null) {
1594. System.out.print("Key为空null");
1595. return null;
1596. }
1597. // 判断Key是否为16位
1598. if (sKey.length() != 16) {
1599. System.out.print("Key无效");
1600. return null;
1601. }
1602. byte[] raw = sKey.getBytes("ASCII");
1603. SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
1604. Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
1605. IvParameterSpec iv = new IvParameterSpec("0102030405060708".getBytes());
1606. cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
1607. byte[] encrypted1 = hex2byte(sSrc);
1608. byte[] original = cipher.doFinal(encrypted1);
1609. String originalString = new String(original);
1610. return originalString;
1611. }
1612. private static final byte[] HEX_CHAR_TABLE = { (byte) '0', (byte) '1',
1613. (byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6',
1614. (byte) '7', (byte) '8', (byte) '9', (byte) 'A', (byte) 'B',
1615. (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F' };
1616. /**
1617. * 十六进制无符号整数形式
1618. *
1619. * @param raw
1620. * @param len
1621. * @return
1622. */
1623. public static String getHex(byte[] raw, int len) {
1624. byte[] hex = new byte[2 * len];
1625. int index = 0;
1626. int pos = 0;
1627. for (byte b : raw) {
1628. if (pos >= len)
1629. break;
1630. pos++;
1631. int v = b & 0xFF;
1632. hex[index++] = HEX_CHAR_TABLE[v >>> 4];
1633. hex[index++] = HEX_CHAR_TABLE[v & 0xF];
1634. }
1635. return new String(hex);
1636. }
1637. /**
1638. * 转换为10进制无符号字符串
1639. *
1640. * @param bytes
1641. * @return
1642. */
1643. public static long getDec(byte[] bytes) {
1644. long result = 0;
1645. long factor = 1;
1646. for (int i = 0; i < bytes.length; ++i) {
1647. long value = bytes[i] & 0xffl;
1648. result += value * factor;
1649. factor *= 256l;
1650. }
1651. return result;
1652. }
1653. /**
1654. * 二进制转换为16进制
1655. *
1656. * @param b
1657. * @return
1658. */
1659. public static String byte2hex(byte[] b) {
1660. String hs = "";
1661. String stmp = "";
1662. for (int n = 0; n < b.length; n++) {
1663. stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
1664. if (stmp.length() == 1) {
1665. hs = hs + "0" + stmp;
1666. } else {
1667. hs = hs + stmp;
1668. }
1669. }
1670. return hs.toUpperCase();
1671. }
1672. /**
1673. * 16进制转换为二进制
1674. *
1675. * @param strhex
1676. * @return
1677. */
1678. public static byte[] hex2byte(String strhex) {
1679. if (strhex == null) {
1680. return null;
1681. }
1682. int l = strhex.length();
1683. if (l % 2 == 1) {
1684. return null;
1685. }
1686. byte[] b = new byte[l / 2];
1687. for (int i = 0; i != l / 2; i++) {
1688. b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),
1689. 16);
1690. }
1691. return b;
1692. }
1693. /**
1694. * 16进制字符转换为int
1695. *
1696. * @param c
1697. * @return
1698. */
1699. public static int reverseToInt(char c) {
1700. if (c == 'A')
1701. return 10;
1702. else if (c == 'B')
1703. return 11;
1704. else if (c == 'C')
1705. return 12;
1706. else if (c == 'D')
1707. return 13;
1708. else if (c == 'E')
1709. return 14;
1710. else if (c == 'F')
1711. return 15;
1712. else
1713. return Integer.parseInt(String.valueOf(c));
1714. }
1715. /**
1716. * 16进制加法
1717. *
1718. * @param src1
1719. * @param src2
1720. * @return
1721. */
1722. public static String hexAdd(String src1, String src2) {
1723. int length1 = src1.toUpperCase().length();
1724. int length2 = src2.toUpperCase().length();
1725. String extend = "";
1726. char sum[] = null;
1727. if (length1 > length2) {// 如果src1的长度大于src2
1728. int num = length1 - length2;
1729. sum = new char[length1];
1730. String zero = "";
1731. for (int i = 0; i < num; i++) {
1732. zero += "0";
1733. }
1734. src2 = zero + src2;
1735. // 遍历数组，然后相加
1736. int add = 0, rest = 0;
1737. for (int i = length1 - 1; i >= 0; i--) {
1738. int a = reverseToInt(src1.toUpperCase().charAt(i));
1739. int b = reverseToInt(src2.toUpperCase().charAt(i));
1740. if (a + b + add >= 16) {
1741. int temp = add;
1742. add = (a + b + add) / 16;
1743. rest = (a + b + temp) % 16;
1744. sum[i] = reverseToChar(rest);
1745. } else {
1746. sum[i] = reverseToChar(a + b + add);
1747. add = 0;
1748. }
1749. }
1750. } else if (length1 < length2) {// src1的长度小于src2
1751. int num = length2 - length1;
1752. sum = new char[length2];
1753. String zero = "";
1754. for (int i = 0; i < num; i++) {
1755. zero += "0";
1756. }
1757. src1 = zero + src1;
1758. // 遍历数组，然后相加
1759. int add = 0, rest = 0;
1760. for (int i = length2 - 1; i >= 0; i--) {
1761. int a = reverseToInt(src1.toUpperCase().charAt(i));
1762. int b = reverseToInt(src2.toUpperCase().charAt(i));
1763. if (a + b + add >= 16) {
1764. int temp = add;
1765. add = (a + b + add) / 16;
1766. rest = (a + b + temp) % 16;
1767. sum[i] = reverseToChar(rest);
1768. } else {
1769. sum[i] = reverseToChar(a + b + add);
1770. add = 0;
1771. }
1772. }
1773. } else {// 如果相等
1774. // 遍历数组，然后相加
1775. sum = new char[length2];
1776. int add = 0, rest = 0;
1777. for (int i = length2 - 1; i >= 0; i--) {
1778. int a = reverseToInt(src1.toUpperCase().charAt(i));
1779. int b = reverseToInt(src2.toUpperCase().charAt(i));
1780. if (a + b + add >= 16) {
1781. int temp = add;
1782. add = (a + b + add) / 16;
1783. rest = (a + b + temp) % 16;
1784. sum[i] = reverseToChar(rest);
1785. if (i == 0) {// 如果i==0
1786. extend = String.valueOf(add);
1787. }
1788. } else {
1789. sum[i] = reverseToChar(a + b + add);
1790. add = 0;
1791. }
1792. }
1793. }
1794. return extend + String.valueOf(sum);
1795. }
1796. /**
1797. * 整形转为16进制表示的char
1798. *
1799. * @param num
1800. * @return
1801. */
1802. public static char reverseToChar(int num) {
1803. /*
1804. * if (num == 10) return 'A'; else if (num == 11) return 'B'; else if
1805. * (num == 12) return 'C'; else if (num == 13) return 'D'; else if (num
1806. * == 14) return 'E'; else if (num == 15) return 'F'; else return
1807. * String.valueOf(num).charAt(0);
1808. */
1809. return Integer.toHexString(num).charAt(0);
1810. }
1811. /**
1812. * 16进制字符按位取反
1813. *
1814. * @param num
1815. * @return
1816. */
1817. public static String revers(String num) {
1818. num = num.toUpperCase();
1819. char array[] = num.toCharArray();
1820. for (int i = 0; i < array.length; i++) {
1821. if (array[i] == 'A')
1822. array[i] = reverseToChar(15 - 10);
1823. else if (array[i] == 'B')
1824. array[i] = reverseToChar(15 - 11);
1825. else if (array[i] == 'C')
1826. array[i] = reverseToChar(15 - 12);
1827. else if (array[i] == 'D')
1828. array[i] = reverseToChar(15 - 13);
1829. else if (array[i] == 'E')
1830. array[i] = reverseToChar(15 - 14);
1831. else if (array[i] == 'F')
1832. array[i] = reverseToChar(15 - 15);
1833. else
1834. array[i] = reverseToChar(15 - Integer.parseInt(String
1835. .valueOf(array[i])));
1836. }
1837. //
1838. return String.valueOf(array);
1839. }
1840. /**
1841. * 输入流转换为byte数组
1842. *
1843. * @param is
1844. * @return
1845. * @throws IOException
1846. */
1847. public static byte[] streamToBytes(InputStream is) throws IOException {
1848. ByteArrayOutputStream os = new ByteArrayOutputStream();
1849. byte[] buffer = new byte[1024];
1850. int len;
1851. while ((len = is.read(buffer)) != -1) {
1852. os.write(buffer, 0, len);
1853. }
1854. return os.toByteArray();
1855. }
1856. /**
1857. * 将输入流转为字符串
1858. *
1859. * @param is
1860. *            输入流
1861. * @param encode
1862. *            编码方式
1863. * @return
1864. * @throws Exception
1865. */
1866. public static String streamToString(InputStream is, String encode)
1867. throws Exception {
1868. byte[] data = streamToBytes(is);
1869. return new String(data, encode);
1870. }
1871. /**
1872. * 将String转换成InputStream
1873. *
1874. * @param in
1875. * @return
1876. * @throws UnsupportedEncodingException
1877. * @throws Exception
1878. */
1879. public static InputStream StringTOInputStream(String in, String encode)
1880. throws IOException {
1881. ByteArrayInputStream is = new ByteArrayInputStream(in.getBytes(encode));
1882. return is;
1883. }
1884. /**
1885. * 将byte数组转换为输入流
1886. *
1887. * @param data
1888. * @return
1889. */
1890. public static InputStream ByteToStream(byte[] data) {
1891. ByteArrayInputStream os = new ByteArrayInputStream(data);
1892. return os;
1893. }
1894. /**
1895. * 资源文件转换为bitmap
1896. *
1897. * @param context
1898. * @param resId
1899. * @return
1900. */
1901. public static Bitmap getBitmapFromResource(Context context, int resId) {
1902. InputStream is = context.getResources().openRawResource(resId);
1903. return BitmapFactory.decodeStream(is);
1904. }
1905. /**
1906. * 返回当前日期xxxx年x月xx日x星期
1907. *
1908. * @return
1909. */
1910. public static String getDate() {
1911. Date date = new Date();
1912. Calendar c = Calendar.getInstance();
1913. c.setTime(date);
1914. String[] weekDays = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
1915. int w = c.get(Calendar.DAY_OF_WEEK) - 1;
1916. if (w < 0) {
1917. w = 0;
1918. }
1919. String mDate = c.get(Calendar.YEAR) + "年" + c.get(Calendar.MONTH) + "月"
1920. + c.get(Calendar.DATE) + "日  " + weekDays[w];
1921. return mDate;
1922. }
1923. }