Android开发之--(WIFI，蓝牙，电池，背光，SD卡，摄像头，按键，MIC，重力感应等)功能的简单使用

http://blog.csdn.net/tangcheng_ok/article/details/6684646

    这篇文章主要是记录前段时间开发所用到的一些技术，在这里做个总结，文中有不足之处还请看到本文的你多多指点。分享分享开发经验，一起提高！

1、WIFI（打开，关闭，使能，扫描等）

2、蓝牙（打开关闭）

3、电池（获取电池的各种参数和状态信息）

4、背光（背光调节）

5、U盘/SDcard（判断是否插入，读取等）

6、屏幕校准（准确的说是点击屏幕的准确度，不是校准屏幕，这是一个简单的算法，这里只提供思路了：屏幕上放5个Button，分别位于左上；左下；右上；右下；获取图片所在屏幕的位置，和图片的长宽，在用户点击Button时获取点击的坐标位置，进行判断。这种方式可能不正确，希望看到这篇文章的各位前辈大哥指点）

7、振动马达（简单的调用振动马达的服务）

8、摄像头（简单的预览图像）

9、按键（获取用户点击的按键，包括Home按键）

10、音乐（使用MediaPlayer调用音频文件播放）

11、MIC（获得当前录音的振幅和录制音频文件）

12、重力感应（通过监听方式获取X、Y、Z三点坐标的值）

    以上是对本文提到的几个基本功能的简单介绍，如果你看到此处说明很期待下文。哈哈，且看一下代码！记住这里只是一些基本功能的使用，至于要实现其他的效果，还是要看自己好好研究了。一般看看API和提供的DEMO都能解决的。

    1、WIFI

1. package cn.tch;  
2.   
3. import java.util.List;  
4.   
5. import android.content.Context;  
6. import android.net.wifi.ScanResult;  
7. import android.net.wifi.WifiConfiguration;  
8. import android.net.wifi.WifiInfo;  
9. import android.net.wifi.WifiManager;  
10. import android.net.wifi.WifiManager.WifiLock;  
11.   
12. public class WifiHelper {  
13.     // 定义WifiManager对象  
14.     private WifiManager mWifiManager;  
15.     // 定义WifiInfo对象  
16.     private WifiInfo mWifiInfo;  
17.     // 扫描出的网络连接列表  
18.     private List<ScanResult> mWifiList;  
19.     // 网络连接列表  
20.     private List<WifiConfiguration> mWifiConfiguration;  
21.     // 定义一个WifiLock  
22.     WifiLock mWifiLock;  
23.   
24.     // 构造器  
25.     public WifiHelper(Context context) {  
26.         // 取得WifiManager对象  
27.         mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
28.         // 取得WifiInfo对象  
29.         mWifiInfo = mWifiManager.getConnectionInfo();  
30.     }  
31.       
32.     public WifiManager getWifiManager(){  
33.         return mWifiManager;  
34.     }  
35.   
36.     // 打开WIFI  
37.     public boolean openWifi() {  
38.         boolean flag = false;  
39.         if (!mWifiManager.isWifiEnabled()) {  
40.             flag =  mWifiManager.setWifiEnabled(true);  
41.         }else if(mWifiManager.isWifiEnabled()){  
42.             flag = true;  
43.         }  
44.         return flag;  
45.     }  
46.   
47.     // 关闭WIFI  
48.     public void closeWifi() {  
49.         if (!mWifiManager.isWifiEnabled()) {  
50.             mWifiManager.setWifiEnabled(false);  
51.         }  
52.     }  
53.   
54.     // 锁定WifiLock  
55.     public void acquireWifiLock() {  
56.         mWifiLock.acquire();  
57.     }  
58.   
59.     // 解锁WifiLock  
60.     public void releaseWifiLock() {  
61.         // 判断时候锁定  
62.         if (mWifiLock.isHeld()) {  
63.             mWifiLock.acquire();  
64.         }  
65.     }  
66.   
67.     // 创建一个WifiLock  
68.     public void creatWifiLock() {  
69.         mWifiLock = mWifiManager.createWifiLock("Test");  
70.     }  
71.   
72.     // 得到配置好的网络  
73.     public List<WifiConfiguration> getConfiguration() {  
74.         return mWifiConfiguration;  
75.     }  
76.   
77.     // 指定配置好的网络进行连接  
78.     public void connectConfiguration(int index) {  
79.         // 索引大于配置好的网络索引返回  
80.         if (index > mWifiConfiguration.size()) {  
81.             return;  
82.         }  
83.         // 连接配置好的指定ID的网络  
84.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,true);  
85.     }  
86.   
87.     public void startScan() {  
88.         mWifiManager.startScan();  
89.         // 得到扫描结果  
90.         mWifiList = mWifiManager.getScanResults();  
91.         // 得到配置好的网络连接  
92.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
93.     }  
94.   
95.     // 得到网络列表  
96.     public List<ScanResult> getWifiList() {  
97.         mWifiManager.startScan();  
98.         // 得到扫描结果  
99.         return mWifiManager.getScanResults();  
100.     }  
101.   
102.     // 查看扫描结果  
103.     public StringBuilder lookUpScan(List<ScanResult> list) {  
104.         StringBuilder stringBuilder = new StringBuilder();  
105.         for (int i = 0; i < list.size(); i++) {  
106.             stringBuilder  
107.                     .append("\n    结果" + new Integer(i + 1).toString() + " (");  
108.             // 将ScanResult信息转换成一个字符串包  
109.             // 其中把包括：BSSID、SSID、capabilities、frequency、level  
110.             stringBuilder.append((list.get(i)).toString());  
111.             stringBuilder.append(")\n");  
112.         }  
113.         return stringBuilder;  
114.     }  
115.   
116.     // 得到MAC地址  
117.     public String getMacAddress() {  
118.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
119.     }  
120.   
121.     // 得到接入点的BSSID  
122.     public String getBSSID() {  
123.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
124.     }  
125.   
126.     // 得到IP地址  
127.     public int getIPAddress() {  
128.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
129.     }  
130.   
131.     // 得到连接的ID  
132.     public int getNetworkId() {  
133.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
134.     }  
135.   
136.     // 得到WifiInfo的所有信息包  
137.     public String getWifiInfo() {  
138.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
139.     }  
140.   
141.     // 添加一个网络并连接  
142.     public void addNetwork(WifiConfiguration wcg) {  
143.         int wcgID = mWifiManager.addNetwork(wcg);  
144.         mWifiManager.enableNetwork(wcgID, true);  
145.     }  
146.   
147.     // 断开指定ID的网络  
148.     public void disconnectWifi(int netId) {  
149.         mWifiManager.disableNetwork(netId);  
150.         mWifiManager.disconnect();  
151.     }  
152.   
153.       
154. }  

2、蓝牙

1.         boolean flag = false;  
2.        <pre class="java" name="code">        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();</pre> if (bluetoothAdapter.isEnabled()) { bluetoothAdapter.disable(); flag = bluetoothAdapter.enable(); } else { flag = bluetoothAdapter.enable(); }<br>  
3. <pre></pre>  
4. <p></p>  
5. <pre></pre>  
6. <h1><a name="t2"></a>3、电池</h1>  
7. <h3><a name="t3"></a>1、新建一个广播接收类</h3>  
8. <div><pre class="java" name="code">package cn.tch;  
9.   
10. import android.content.BroadcastReceiver;  
11. import android.content.Context;  
12. import android.content.Intent;  
13. import android.content.res.Resources;  
14. import android.os.BatteryManager;  
15. import android.util.Log;  
16.   
17. import java.util.ArrayList;  
18.   
19. public class BatteryBroadcastReceiver extends BroadcastReceiver {  
20.   
21.     private String action;  
22.     private int status;  
23.     private int health;  
24.     private int plugged;  
25.     private String statusString;  
26.     private String healthString;  
27.     private String acString;  
28.     private Resources mResources;  
29.     private StringBuffer buffer = new StringBuffer();  
30.     private static int count = 0;  
31.     private ArrayList<String> batteryMsg;  
32.   
33.     int level;// 电池电量，数字  
34.     int scale;// 电池最大容量  
35.     int voltage;// 电池伏数  
36.     int temperature;// 电池温度  
37.       
38.     public BatteryBroadcastReceiver(Resources res) {  
39.         mResources = res;  
40.         batteryMsg  = new ArrayList<String>();  
41.     }  
42.   
43.     @Override  
44.     public void onReceive(Context context, Intent intent) {  
45.         action = intent.getAction();  
46.         status = intent.getIntExtra("status", 0);  
47.         health = intent.getIntExtra("health", 0);  
48.         plugged = intent.getIntExtra("plugged", 0);  
49.         switch (status) {  
50.             case BatteryManager.BATTERY_STATUS_UNKNOWN:  
51.                 statusString = "unknown";  
52.                 break;  
53.             case BatteryManager.BATTERY_STATUS_CHARGING:  
54.                 statusString = "charging";  
55.                 break;  
56.             case BatteryManager.BATTERY_STATUS_DISCHARGING:  
57.                 statusString = "discharging";  
58.                 break;  
59.             case BatteryManager.BATTERY_STATUS_NOT_CHARGING:  
60.                 statusString = "not charging";  
61.                 break;  
62.             case BatteryManager.BATTERY_STATUS_FULL:  
63.                 statusString = "full";  
64.                 break;  
65.         }  
66.   
67.         switch (health) {  
68.             case BatteryManager.BATTERY_HEALTH_UNKNOWN:  
69.                 healthString = "unknown";  
70.                 break;  
71.             case BatteryManager.BATTERY_HEALTH_GOOD:  
72.                 healthString = "good";  
73.                 break;  
74.             case BatteryManager.BATTERY_HEALTH_OVERHEAT:  
75.                 healthString = "overheat";  
76.                 break;  
77.             case BatteryManager.BATTERY_HEALTH_DEAD:  
78.                 healthString = "dead";  
79.                 break;  
80.             case BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:  
81.                 healthString = "voltage";  
82.                 break;  
83.             case BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:  
84.                 healthString = "unspecified failure";  
85.                 break;  
86.         }  
87.         switch (plugged) {  
88.             case BatteryManager.BATTERY_PLUGGED_AC:  
89.                 acString = "plugged ac";  
90.                 break;  
91.             case BatteryManager.BATTERY_PLUGGED_USB:  
92.                 acString = "plugged usb";  
93.                 break;  
94.         }  
95. //        if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {  
96. //            for (int i = count; i < 10; i++) {  
97. //                level = intent.getIntExtra("level", 0);// 电池电量，数字  
98. //                scale = intent.getIntExtra("scale", 0);// 电池最大容量  
99. //                voltage = intent.getIntExtra("voltage", 0);// 电池伏数  
100. //                temperature = intent.getIntExtra("temperature", 0);// 电池温度  
101. //                String msg = String.format(res.getString(R.string.battery_chenged_msg), level, scale, voltage,  
102. //                        temperature, statusString, acString, healthString);  
103. //                batteryMsg.add(msg);  
104. //                count++;  
105. //            }  
106. //        }  
107.     }  
108.       
109.   
110.     // 电池状态，返回是一个数字  
111.     // BatteryManager.BATTERY_STATUS_CHARGING 表示是充电状态  
112.     // BatteryManager.BATTERY_STATUS_DISCHARGING 放电中  
113.     // BatteryManager.BATTERY_STATUS_NOT_CHARGING 未充电  
114.     // BatteryManager.BATTERY_STATUS_FULL 电池满  
115.     // 充电类型 BatteryManager.BATTERY_PLUGGED_AC 表示是充电器，不是这个值，表示是 USB  
116.     // 电池健康情况，返回也是一个数字  
117.     // BatteryManager.BATTERY_HEALTH_GOOD 良好  
118.     // BatteryManager.BATTERY_HEALTH_OVERHEAT 过热  
119.     // BatteryManager.BATTERY_HEALTH_DEAD 没电  
120.     // BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE 过电压  
121.     // BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE 未知错误  
122. }  
123. </pre><br>  
124. <h3><a name="t4"></a>2、注册广播</h3>  
125. </div>  
126. <div><pre class="java" name="code">IntentFilter intentFilter = new IntentFilter();  
127.         intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);  
128.         registerReceiver(batteryReceiver, intentFilter);</pre>  
129. <h1><a name="t5"></a>4、背光</h1>  
130. <pre class="java" name="code">package cn.tch;  
131.   
132. import android.app.Activity;  
133. import android.app.AlertDialog;  
134. import android.content.DialogInterface;  
135. import android.content.Intent;  
136. import android.content.res.Resources;  
137. import android.os.Bundle;  
138. import android.os.Handler;  
139. import android.os.Message;  
140. import android.os.RemoteException;  
141. import android.provider.Settings;  
142. import android.provider.Settings.SettingNotFoundException;  
143. import android.util.Log;  
144. import android.view.View;  
145. import android.view.View.OnClickListener;  
146. import android.widget.Button;  
147. import android.widget.ProgressBar;  
148. import android.widget.SeekBar;  
149. import android.widget.SeekBar.OnSeekBarChangeListener;  
150. import android.os.IPowerManager;  
151. import android.os.ServiceManager;  
152.   
153. import static cn.tch.Constant.*;  
154.   
155. public class BacklightActivity extends Activity implements OnSeekBarChangeListener{  
156.   
157.     private final static String TAG = "BacklightActivity";  
158.     private SeekBar seekBar;  
159.     private Button btnFinish;  
160.     private Resources res;  
161.       
162.     private int mOldBrightness = 0;  
163.     private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;  
164.     private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;  
165.       
166.     private boolean isRun = true;  
167.       
168.     @Override  
169.     protected void onCreate(Bundle savedInstanceState) {  
170.         super.onCreate(savedInstanceState);  
171.           
172.         setContentView(R.layout.backlight);  
173.         res = getResources();  
174.         seekBar = (SeekBar) findViewById(R.id.bl_seekbar);  
175.         btnFinish = (Button) findViewById(R.id.bl_finish);  
176.         initBrightness();  
177.           
178.           
179.         seekBar.setOnSeekBarChangeListener(this);  
180.         btnFinish.setOnClickListener(new OnClickListener() {  
181.               
182.             //@Override  
183.             public void onClick(View v) {  
184.                 new AlertDialog.Builder(BacklightActivity.this).setIcon(  
185.                         R.drawable.icon).setTitle(res.getString(R.string.backlight_title))  
186.                         .setMessage(res.getString(R.string.backlight_msg)).setPositiveButton(  
187.                                 res.getString(R.string.yes), dialogClick)  
188.                         .setNegativeButton(res.getString(R.string.no), dialogClick).create().show();  
189.             }  
190.         });  
191.           
192.           
193.     }  
194.       
195.       
196.     private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
197.   
198.         //@Override  
199.         public void onClick(DialogInterface dialog, int which) {  
200.             switch (which) {  
201.             case DialogInterface.BUTTON_POSITIVE:  
202.                 resultRquest(true);  
203.                 break;  
204.             case DialogInterface.BUTTON_NEGATIVE:  
205.                 resultRquest(false);  
206.                 break;  
207.             default:  
208.                 break;  
209.             }  
210.         }  
211.     };  
212.       
213.     private void resultRquest(boolean flag){  
214.         Intent intent = new Intent(this, MainActivity.class);  
215.         intent.putExtra(BACKLIGHT_RESULT,flag);  
216.         setResult(REQUESTCODE_BACKLIGHT_RESULT, intent);  
217.         finish();  
218.     }  
219.   
220.     //@Override  
221.     public void onProgressChanged(SeekBar seekBar, int progress,  
222.             boolean fromUser) {  
223.         int step = 25;  
224.         Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS, progress + MINIMUM_BACKLIGHT);  
225.         setBrightness(progress + MINIMUM_BACKLIGHT);  
226.     }  
227.       
228.     private void initBrightness(){  
229.         // 获取当前背光亮度  
230.         try {  
231.             mOldBrightness = Settings.System.getInt(BacklightActivity.this.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);  
232.         } catch (SettingNotFoundException e) {  
233.             mOldBrightness = MAXIMUM_BACKLIGHT;  
234.         }  
235.         seekBar.setMax(MAXIMUM_BACKLIGHT - MINIMUM_BACKLIGHT);  
236.         Log.v("Brightness max", "setmax:" + (MAXIMUM_BACKLIGHT - MINIMUM_BACKLIGHT));  
237.         //seekBar.setProgress(mOldBrightness - MINIMUM_BACKLIGHT);  
238.         seekBar.setProgress(0);  
239.           
240.         new Thread(new Runnable() {  
241.             int value = 0;  
242.             public void run() {  
243.                 while (isRun) {  
244.                     try {  
245.                         Thread.sleep(150);  
246.                         value = value+5;   
247.                         Message message = new Message();  
248.                         message.what = value;  
249.                         handler.sendEmptyMessage(message.what);  
250.                     } catch (InterruptedException e) {  
251.                     }  
252.                 }  
253.             }  
254.         }).start();  
255.     }   
256.       
257.     private Handler handler = new Handler(){  
258.         public void handleMessage(android.os.Message msg) {  
259.             if(msg.what<=MAXIMUM_BACKLIGHT){  
260.                 seekBar.setProgress(msg.what);  
261. //              Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS, msg.what + MINIMUM_BACKLIGHT);       
262.                 setBrightness(msg.what);  
263.             }else{  
264.                 isRun = false;  
265.             }  
266.              
267.         };  
268.     };  
269.       
270.     private void setBrightness(int brightness) {  
271.         try {  
272.             IPowerManager power = IPowerManager.Stub.asInterface(ServiceManager.getService("power"));  
273.             if (power != null) {  
274.                 power.setBacklightBrightness(brightness);  
275.             }  
276.         } catch (RemoteException doe) {  
277.             Log.e(TAG,"Setting Brightness RemoteException!");         
278.         }          
279.     }  
280.       
281.     //@Override  
282.     public void onStartTrackingTouch(SeekBar seekBar) {}  
283.   
284.     //@Override  
285.     public void onStopTrackingTouch(SeekBar seekBar) {}  
286. }  
287. </pre><br>  
288. </div>  
289. <h1><a name="t6"></a>5、判断SDcard和获取SDCard的路径</h1>  
290. <div><pre class="java" name="code"> static String getSdcardPath(){  
291.         return Environment.getExternalStorageDirectory().getPath();  
292.     }  
293.   
294.     static boolean checkSdcard(){  
295.         boolean flag = false;  
296.         if(Environment.getExternalStorageDirectory().toString().equals("/mnt/sdcard")){  
297.             flag = true;  
298.         }  
299.         return flag;  
300.     }</pre><br>  
301. <h1><a name="t7"></a>6、屏幕校准（请参看前面说明）</h1>  
302. </div>  
303. <h1><a name="t8"></a>7、振动马达</h1>  
304. <div><pre class="java" name="code"> vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  
305.         long[] pattern = {  
306.                 800, 50, 400, 30  
307.         }; // OFF/ON/OFF/ON...  
308.         vibrator.vibrate(pattern, 2);</pre><br>  
309. <h1><a name="t9"></a>8、摄像头（拍照和预览）</h1>  
310. </div>  
311. <div><pre class="java" name="code">public class CameraActivity extends Activity{  
312.     /** 
313.      * 第一种方式实现拍照 
314.      */  
315.     // private PreView preView = null;  
316.     //  
317.     // @Override  
318.     // protected void onCreate(Bundle savedInstanceState) {  
319.     // super.onCreate(savedInstanceState);  
320.     // this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
321.     // preView = new PreView(this);  
322.     // setContentView(preView,new LayoutParams(400, 300));  
323.     // }  
324.     //  
325.     // @Override  
326.     // public boolean onKeyDown(int keyCode, KeyEvent event) {  
327.     // return preView.onKeyDown(keyCode, event);  
328.     // }  
329.   
330.     private final static String TAG = "CameraActivity";  
331.     private SurfaceView surfaceView;  
332.     private SurfaceHolder surfaceHolder;  
333.     private Camera camera;  
334.     private File picture;  
335.       
336.     private Button btnFinish;  
337.       
338.     private Dialog mDialog;  
339.     private Resources res;  
340.   
341.     @Override  
342.     public void onCreate(Bundle savedInstanceState) {  
343.         super.onCreate(savedInstanceState);  
344.          this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
345.         setContentView(R.layout.camera);  
346.         setupViews();  
347.     }  
348.       
349.     private void setupViews(){  
350.         surfaceView = (SurfaceView) findViewById(R.id.camera_preview); // 实例化拍照界面组件  
351.         surfaceHolder = surfaceView.getHolder(); // 实例化拍照界面组件  
352.         surfaceHolder.addCallback(surfaceCallback); // 为SurfaceHolder 添加回调  
353.         surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
354.         res = getResources();  
355.         btnFinish =(Button) findViewById(R.id.camera_finish);  
356.           
357.         btnFinish.setOnClickListener(new OnClickListener() {  
358.               
359.             //@Override  
360.             public void onClick(View v) {  
361.                   
362.                 // 提示是否看到预览  
363.                 if(mDialog == null){  
364.                 mDialog = new AlertDialog.Builder(CameraActivity.this).setIcon(  
365.                         R.drawable.icon).setTitle(res.getString(R.string.camera_title))  
366.                         .setMessage(res.getString(R.string.camera_msg)).setPositiveButton(  
367.                                 res.getString(R.string.yes), dialogClick)  
368.                         .setNegativeButton(res.getString(R.string.no), dialogClick).create();  
369.                 mDialog.show();}  
370.             }  
371.         });  
372.     }  
373.       
374.        private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
375.   
376. //        @Override  
377.             public void onClick(DialogInterface dialog, int which) {  
378.                 switch (which) {  
379.                 case DialogInterface.BUTTON_POSITIVE:  
380.                     resultRquest(true);  
381.                     break;  
382.                 case DialogInterface.BUTTON_NEGATIVE:  
383.                     resultRquest(false);  
384.                     break;  
385.                 default:  
386.                     break;  
387.                 }  
388.   
389.             }  
390.         };  
391.           
392.         private void resultRquest(boolean flag){  
393.             Intent intent = new Intent(CameraActivity.this, MainActivity.class);  
394.             intent.putExtra(CAMERA_RESULT, flag);  
395.             setResult(REQUESTCODE_CAMERA_RESULT, intent);  
396.             finish();  
397.         }  
398.   
399.     @Override  
400.     public boolean onKeyDown(int keyCode, KeyEvent event) {  
401.         if (keyCode == KeyEvent.KEYCODE_CAMERA  
402.                 || keyCode == KeyEvent.KEYCODE_SEARCH) {  
403.             takePic();  
404.             return true;  
405.         }  
406.         return super.onKeyDown(keyCode, event);  
407.     }  
408.   
409.     private void takePic() {  
410.   
411.         camera.stopPreview();// 停止预览  
412.   
413.         camera.takePicture(null, null, pictureCallback); // 拍照  
414.     }  
415.   
416.     // 照片回调  
417.     Camera.PictureCallback pictureCallback = new Camera.PictureCallback() {  
418.         //@Override  
419.         public void onPictureTaken(byte[] data, Camera camera) {  
420.             new SavePictureTask().execute(data);  
421.             camera.startPreview();  
422.         }  
423.     };  
424.   
425.     // 保存照片任务类  
426.     class SavePictureTask extends AsyncTask<byte[], String, String> {  
427.         @Override  
428.         protected String doInBackground(byte[]... params) {  
429.   
430.             picture = new File(Environment.getExternalStorageDirectory(),  
431.                     "picture.jpg");// 创建文件  
432.   
433.             if (picture.exists())  
434.                 picture.delete(); // 如果文件存在删除掉  
435.             try {  
436.                 FileOutputStream fos = new FileOutputStream(picture.getPath()); // 获得文件输出流  
437.                 fos.write(params[0]); // 写到该文件  
438.                 fos.close(); // 关闭文件流  
439.             } catch (Exception e) {  
440.                 e.printStackTrace();  
441.             }  
442.             return null;  
443.         }  
444.     }  
445.   
446.     // SurfaceHodler 回调，处理打开相机，关闭相机以及照片尺寸的改变  
447.     SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {  
448.         //@Override  
449.         public void surfaceCreated(SurfaceHolder holder) {  
450.             camera = Camera.open(); // 打开相机  
451.             try {  
452.                 camera.setPreviewDisplay(holder); // 设置预览  
453.             } catch (IOException e) {  
454.                 camera.release();// 释放  
455.                 camera = null;  
456.             }  
457.         }  
458.   
459.         //@Override  
460.         public void surfaceChanged(SurfaceHolder holder, int format, int width,  
461.                 int height) {  
462.             Camera.Parameters parameters = camera.getParameters(); // 获得相机参数  
463.             parameters.setPictureFormat(PixelFormat.JPEG);// 设置照片格式  
464.             parameters.setPreviewSize(400, 300); // 设置照片大小  
465.             camera.setParameters(parameters); // 设置相机参数  
466.             camera.startPreview(); // 开始预览  
467.               
468.         }  
469.   
470.         //@Override  
471.         public void surfaceDestroyed(SurfaceHolder holder) {  
472.             Log.i(TAG,"====surfaceDestroyed");  
473.             camera.stopPreview();// 停止预览  
474.             camera.release(); // 释放相机资源  
475.             camera = null;  
476.         }  
477.     };  
478.   
479.       
480. }  
481. </pre><br>  
482. <h1><a name="t10"></a>9、按键（只要重写dispoatchKeyEvent即可）</h1>  
483. </div>  
484. <div>以下是屏蔽Home键的方法：</div>  
485. <div><pre class="java" name="code">@Override  
486.     public void onAttachedToWindow() {  
487.         this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);     
488.         super.onAttachedToWindow();       
489.     }</pre><br>  
490. <h1><a name="t11"></a>10、音乐播放器</h1>  
491. </div>  
492. <div>代码太多了，给个给力的连接吧！<a href="http://hi.baidu.com/orangejackylee/blog/item/6afb84d68e36cbd0a9ec9a36.html/cmtid/ce7e663d9938dffdb211c7d6">http://hi.baidu.com/orangejackylee/blog/item/6afb84d68e36cbd0a9ec9a36.html/cmtid/ce7e663d9938dffdb211c7d6</a></div>  
493. <h1><a name="t12"></a>11、录音</h1>  
494. <div><pre class="java" name="code">public class MicActivity extends Activity implements OnClickListener{  
495.   
496.     private final static String TAG="MicActivity";  
497.       
498.     private Button btnMicRecord;  
499.     private Button btnMicPlay;  
500.     private Button btnMicFinish;  
501.     private TextView txtMicAmplitudeMsg;  
502.     private TextView txtMicTimeMsg;  
503.       
504.     private File recAudioFile;  
505.     private MediaRecorder mMediaRecorder;  
506.     private Resources res;  
507.       
508.     private static int time;  
509.     private static int mic_state = MIC_STATE_RECORD;  
510.       
511.     private Thread threadAmplitude;  
512.     private Thread threadTime;  
513.     private static boolean threadRun ;  
514.       
515.     @Override  
516.     protected void onCreate(Bundle savedInstanceState) {  
517.         super.onCreate(savedInstanceState);  
518.         setContentView(R.layout.mic);  
519.         setupViews();  
520.     }  
521.       
522.     @Override  
523.     protected void onPause() {  
524.         super.onPause();  
525.         threadAmplitude = null;  
526.         threadTime = null;  
527.           
528.     }  
529.       
530.     private void setupViews() {  
531.           
532.           
533.         btnMicRecord = (Button) findViewById(R.id.mic_record);  
534.         btnMicPlay = (Button) findViewById(R.id.mic_play);  
535.         btnMicFinish = (Button) findViewById(R.id.mic_finish);  
536.         txtMicAmplitudeMsg = (TextView) findViewById(R.id.mic_amplitude_msg);  
537.         txtMicTimeMsg = (TextView) findViewById(R.id.mic_time_msg);  
538.           
539.         btnMicRecord.setOnClickListener(this);  
540.         btnMicPlay.setOnClickListener(this);  
541.         btnMicFinish.setOnClickListener(this);  
542.           
543.         res = getResources();  
544.         threadAmplitude = new Thread(new UpdateAmplitude());  
545.         threadTime = new Thread(new UpdateTime());  
546.     }  
547.       
548.       
549.     //@Override  
550.     public void onClick(View v) {  
551.         switch (v.getId()) {  
552.         case R.id.mic_record:  
553.             if (mic_state== MIC_STATE_RECORD) { // 录音  
554.                 btnMicRecord.setText(res.getString(R.string.mic_record_save_text));  
555.                 mic_state = MIC_STATE_SAVE;  
556.                 startRecorder();  
557.             } else if (mic_state== MIC_STATE_SAVE) {  
558.                 btnMicRecord.setText(res.getString(R.string.mic_record_text));  
559.                 btnMicRecord.setEnabled(false);  
560.                 btnMicPlay.setEnabled(true);  
561.                 mic_state = MIC_STATE_RECORD;  
562.                 stopRecorder();  
563.             }  
564.             break;  
565.         case R.id.mic_play:  
566.             openFile(recAudioFile);  
567.             btnMicRecord.setEnabled(true);  
568.             btnMicFinish.setEnabled(true);  
569.             break;  
570.         case R.id.mic_finish:  
571.             new AlertDialog.Builder(MicActivity.this).setIcon(  
572.                     R.drawable.icon).setTitle(res.getString(R.string.mic_title))  
573.                     .setMessage(res.getString(R.string.mic_msg)).setPositiveButton(  
574.                             res.getString(R.string.yes), dialogClick)  
575.                     .setNegativeButton(res.getString(R.string.no), dialogClick).create().show();  
576.             break;  
577.         default:  
578.             break;  
579.         }  
580.     }  
581.       
582.     private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
583.   
584.         //@Override  
585.         public void onClick(DialogInterface dialog, int which) {  
586.             switch (which) {  
587.             case DialogInterface.BUTTON_POSITIVE:  
588.                 result(true);  
589.                 break;  
590.             case DialogInterface.BUTTON_NEGATIVE:  
591.                 result(false);  
592.                 break;  
593.             default:  
594.                 break;  
595.             }  
596.               
597.   
598.         }  
599.     };  
600.       
601.       
602.     private void result(boolean flag){  
603.         Intent intent = new Intent(MicActivity.this, MainActivity.class);  
604.         intent.putExtra(MIC_RESULT, flag);  
605.         setResult(REQUESTCODE_MIC_RESULT, intent);  
606.         finish();  
607.     }  
608.       
609.     private class UpdateAmplitude implements Runnable{  
610.   
611.         //@Override  
612.         public void run() {  
613.             while (threadRun) {  
614.                 try {  
615.                     Message msg = new Message();  
616.                     msg.what = mMediaRecorder.getMaxAmplitude();  
617.                     amplitudeHandler.sendMessage(msg);  
618.                     Thread.sleep(250);  
619.                 } catch (InterruptedException e) {  
620.                     e.printStackTrace();  
621.                 }  
622.             }  
623.         }  
624.     }  
625.       
626.     private Handler amplitudeHandler = new Handler(){  
627.         @Override  
628.         public void handleMessage(Message msg) {  
629.             super.handleMessage(msg);  
630.             String text = String.format(res.getString(R.string.mic_status_amplitude),String.valueOf(msg.what));  
631.             txtMicAmplitudeMsg.setText(text);  
632.         }  
633.     };  
634.       
635.     private class UpdateTime implements Runnable{  
636.         //@Override  
637.         public void run() {  
638.             while (threadRun) {  
639.                 try {  
640.                     Thread.sleep(1000);  
641.                     time++;  
642.                     timeHandler.sendEmptyMessage(time);  
643.                 } catch (InterruptedException e) {  
644.                     e.printStackTrace();  
645.                 }  
646.                   
647.             }  
648.         }  
649.     }  
650.       
651.     private Handler timeHandler = new Handler(){  
652.         public void handleMessage(Message msg) {  
653.             super.handleMessage(msg);  
654.             String text = String.format(res.getString(R.string.mic_status_time), String.valueOf(msg.what));  
655.             txtMicTimeMsg.setText(text);  
656.         };  
657.     };  
658.       
659.     private void startRecorder(){  
660.         mMediaRecorder = new MediaRecorder();  
661.         recAudioFile = new File("/mnt/flash", "new.amr");  
662.         if (recAudioFile.exists()) {  
663.             recAudioFile.delete();  
664.         }  
665.         mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); // 设置录音来源  
666.         mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);  
667.         mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);   
668.         mMediaRecorder.setOutputFile(recAudioFile.getAbsolutePath());    
669.           
670.         try {  
671.             mMediaRecorder.prepare();  
672.         } catch (IllegalStateException e) {  
673.             e.printStackTrace();  
674.         } catch (IOException e) {  
675.             e.printStackTrace();  
676.         }  
677.         mMediaRecorder.start();  
678.         threadRun = true;  
679.         threadAmplitude.start();  
680.         threadTime.start();  
681.     }  
682.       
683.     private void stopRecorder(){  
684.         time = 0;  
685.         threadRun = false;  
686.         if (recAudioFile!=null) {  
687.             mMediaRecorder.stop();  
688.             mMediaRecorder.release();  
689.         }  
690.     }  
691.   
692.     /* 打开播放录音文件的程序 */  
693.     private void openFile(File f) {  
694.         Intent intent = new Intent();  
695.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
696.         intent.setAction(android.content.Intent.ACTION_VIEW);  
697.         String type = getMIMEType(f);  
698.         intent.setDataAndType(Uri.fromFile(f), type);  
699.         startActivity(intent);  
700.     }  
701.   
702.     private String getMIMEType(File f) {  
703.         String end = f.getName().substring(f.getName().lastIndexOf(".") + 1,  
704.                 f.getName().length()).toLowerCase();  
705.         String type = "";  
706.         if (end.equals("mp3") || end.equals("aac") || end.equals("aac")  
707.                 || end.equals("amr") || end.equals("mpeg") || end.equals("mp4")) {  
708.             type = "audio";  
709.         } else if (end.equals("jpg") || end.equals("gif") || end.equals("png")  
710.                 || end.equals("jpeg")) {  
711.             type = "image";  
712.         } else {  
713.             type = "*";  
714.         }  
715.         type += "/*";  
716.         return type;  
717.     }  
718.       
719. }</pre>12、重力感应</div>  
720. <div><pre class="java" name="code">public class MySensorEventListener implements SensorEventListener {  
721.   
722.     private boolean isPass;  
723.   
724.     private SaveMessage saveMessage;  
725.   
726.     public MySensorEventListener(Context context) {  
727.         saveMessage = new SaveMessage(context);  
728.     }  
729.   
730.     // @Override  
731.     public void onAccuracyChanged(Sensor sensor, int accuracy) {  
732.     }  
733.   
734.     // @Override  
735.     public void onSensorChanged(SensorEvent event) {  
736.         if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {  
737.             // 得到方向的值  
738.             float x = event.values[SensorManager.DATA_X];  
739.             float y = event.values[SensorManager.DATA_Y];  
740.             float z = event.values[SensorManager.DATA_Z];  
741.             isPass = x != 0 || y != 0 || z != 0;  
742.             System.out.println("Orientation-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
743.             saveMessage.setMessage(MSG_SENEOR, "Orientation-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
744.         } else if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {  
745.             // 得到加速度的值  
746.             float x = event.values[SensorManager.DATA_X];  
747.             float y = event.values[SensorManager.DATA_Y];  
748.             float z = event.values[SensorManager.DATA_Z];  
749.             isPass = x != 0 || y != 0 || z != 0;  
750.             System.out.println("Accelerometer-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
751.             saveMessage.setMessage(MSG_SENEOR, "Accelerometer-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
752.         }  
753.     }  
754.   
755. }</pre><br>