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

转载 2012年12月17日 10:15:07

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.                 8005040030  
  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(nullnull, 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(400300); // 设置照片大小  
  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.