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

最新推荐文章于 2022-04-10 19:00:00 发布
最新推荐文章于 2022-04-10 19:00:00 发布
阅读量1.9k 收藏
点赞数
分类专栏： android 文章标签： button null 网络 照片 parameters service

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

view plain
  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、蓝牙

view plain
  1. boolean flag = false;  
  2. lt;pre class="java" name="code">        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();  
if (bluetoothAdapter.isEnabled()) { bluetoothAdapter.disable(); flag = bluetoothAdapter.enable(); } else { flag = bluetoothAdapter.enable(); } 
 
 
 
 
 
 
 3、电池
 
 
 1、新建一个广播接收类
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  package cn.tch;  
  2.    
  3.  import android.content.BroadcastReceiver;  
  4.  import android.content.Context;  
  5.  import android.content.Intent;  
  6.  import android.content.res.Resources;  
  7.  import android.os.BatteryManager;  
  8.  import android.util.Log;  
  9.    
  10.  import java.util.ArrayList;  
  11.    
  12.  public class BatteryBroadcastReceiver extends BroadcastReceiver {  
  13.    
  14.      private String action;  
  15.      private int status;  
  16.      private int health;  
  17.      private int plugged;  
  18.      private String statusString;  
  19.      private String healthString;  
  20.      private String acString;  
  21.      private Resources mResources;  
  22.      private StringBuffer buffer = new StringBuffer();  
  23.      private static int count = 0;  
  24.      private ArrayList<String> batteryMsg;  
  25.    
  26.      int level;// 电池电量，数字  
  27.      int scale;// 电池最大容量  
  28.      int voltage;// 电池伏数  
  29.      int temperature;// 电池温度  
  30.        
  31.      public BatteryBroadcastReceiver(Resources res) {  
  32.          mResources = res;  
  33.          batteryMsg  = new ArrayList<String>();  
  34.      }  
  35.    
  36.      @Override  
  37.      public void onReceive(Context context, Intent intent) {  
  38.          action = intent.getAction();  
  39.          status = intent.getIntExtra("status", 0);  
  40.          health = intent.getIntExtra("health", 0);  
  41.          plugged = intent.getIntExtra("plugged", 0);  
  42.          switch (status) {  
  43.              case BatteryManager.BATTERY_STATUS_UNKNOWN:  
  44.                  statusString = "unknown";  
  45.                  break;  
  46.              case BatteryManager.BATTERY_STATUS_CHARGING:  
  47.                  statusString = "charging";  
  48.                  break;  
  49.              case BatteryManager.BATTERY_STATUS_DISCHARGING:  
  50.                  statusString = "discharging";  
  51.                  break;  
  52.              case BatteryManager.BATTERY_STATUS_NOT_CHARGING:  
  53.                  statusString = "not charging";  
  54.                  break;  
  55.              case BatteryManager.BATTERY_STATUS_FULL:  
  56.                  statusString = "full";  
  57.                  break;  
  58.          }  
  59.    
  60.          switch (health) {  
  61.              case BatteryManager.BATTERY_HEALTH_UNKNOWN:  
  62.                  healthString = "unknown";  
  63.                  break;  
  64.              case BatteryManager.BATTERY_HEALTH_GOOD:  
  65.                  healthString = "good";  
  66.                  break;  
  67.              case BatteryManager.BATTERY_HEALTH_OVERHEAT:  
  68.                  healthString = "overheat";  
  69.                  break;  
  70.              case BatteryManager.BATTERY_HEALTH_DEAD:  
  71.                  healthString = "dead";  
  72.                  break;  
  73.              case BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:  
  74.                  healthString = "voltage";  
  75.                  break;  
  76.              case BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:  
  77.                  healthString = "unspecified failure";  
  78.                  break;  
  79.          }  
  80.          switch (plugged) {  
  81.              case BatteryManager.BATTERY_PLUGGED_AC:  
  82.                  acString = "plugged ac";  
  83.                  break;  
  84.              case BatteryManager.BATTERY_PLUGGED_USB:  
  85.                  acString = "plugged usb";  
  86.                  break;  
  87.          }  
  88.  //        if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {  
  89.  //            for (int i = count; i < 10; i++) {  
  90.  //                level = intent.getIntExtra("level", 0);// 电池电量，数字  
  91.  //                scale = intent.getIntExtra("scale", 0);// 电池最大容量  
  92.  //                voltage = intent.getIntExtra("voltage", 0);// 电池伏数  
  93.  //                temperature = intent.getIntExtra("temperature", 0);// 电池温度  
  94.  //                String msg = String.format(res.getString(R.string.battery_chenged_msg), level, scale, voltage,  
  95.  //                        temperature, statusString, acString, healthString);  
  96.  //                batteryMsg.add(msg);  
  97.  //                count++;  
  98.  //            }  
  99.  //        }  
  100.      }  
  101.        
  102.    
  103.      // 电池状态，返回是一个数字  
  104.      // BatteryManager.BATTERY_STATUS_CHARGING 表示是充电状态  
  105.      // BatteryManager.BATTERY_STATUS_DISCHARGING 放电中  
  106.      // BatteryManager.BATTERY_STATUS_NOT_CHARGING 未充电  
  107.      // BatteryManager.BATTERY_STATUS_FULL 电池满  
  108.      // 充电类型 BatteryManager.BATTERY_PLUGGED_AC 表示是充电器，不是这个值，表示是 USB  
  109.      // 电池健康情况，返回也是一个数字  
  110.      // BatteryManager.BATTERY_HEALTH_GOOD 良好  
  111.      // BatteryManager.BATTERY_HEALTH_OVERHEAT 过热  
  112.      // BatteryManager.BATTERY_HEALTH_DEAD 没电  
  113.      // BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE 过电压  
  114.      // BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE 未知错误  
  115.  }  
 
  
 
  
 
  
 2、注册广播
 
 
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  IntentFilter intentFilter = new IntentFilter();  
  2.          intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);  
  3.          registerReceiver(batteryReceiver, intentFilter);  
 
  
 
  
 4、背光
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  package cn.tch;  
  2.    
  3.  import android.app.Activity;  
  4.  import android.app.AlertDialog;  
  5.  import android.content.DialogInterface;  
  6.  import android.content.Intent;  
  7.  import android.content.res.Resources;  
  8.  import android.os.Bundle;  
  9.  import android.os.Handler;  
  10.  import android.os.Message;  
  11.  import android.os.RemoteException;  
  12.  import android.provider.Settings;  
  13.  import android.provider.Settings.SettingNotFoundException;  
  14.  import android.util.Log;  
  15.  import android.view.View;  
  16.  import android.view.View.OnClickListener;  
  17.  import android.widget.Button;  
  18.  import android.widget.ProgressBar;  
  19.  import android.widget.SeekBar;  
  20.  import android.widget.SeekBar.OnSeekBarChangeListener;  
  21.  import android.os.IPowerManager;  
  22.  import android.os.ServiceManager;  
  23.    
  24.  import static cn.tch.Constant.*;  
  25.    
  26.  public class BacklightActivity extends Activity implements OnSeekBarChangeListener{  
  27.    
  28.      private final static String TAG = "BacklightActivity";  
  29.      private SeekBar seekBar;  
  30.      private Button btnFinish;  
  31.      private Resources res;  
  32.        
  33.      private int mOldBrightness = 0;  
  34.      private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;  
  35.      private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;  
  36.        
  37.      private boolean isRun = true;  
  38.        
  39.      @Override  
  40.      protected void onCreate(Bundle savedInstanceState) {  
  41.          super.onCreate(savedInstanceState);  
  42.            
  43.          setContentView(R.layout.backlight);  
  44.          res = getResources();  
  45.          seekBar = (SeekBar) findViewById(R.id.bl_seekbar);  
  46.          btnFinish = (Button) findViewById(R.id.bl_finish);  
  47.          initBrightness();  
  48.            
  49.            
  50.          seekBar.setOnSeekBarChangeListener(this);  
  51.          btnFinish.setOnClickListener(new OnClickListener() {  
  52.                
  53.              //@Override  
  54.              public void onClick(View v) {  
  55.                  new AlertDialog.Builder(BacklightActivity.this).setIcon(  
  56.                          R.drawable.icon).setTitle(res.getString(R.string.backlight_title))  
  57.                          .setMessage(res.getString(R.string.backlight_msg)).setPositiveButton(  
  58.                                  res.getString(R.string.yes), dialogClick)  
  59.                          .setNegativeButton(res.getString(R.string.no), dialogClick).create().show();  
  60.              }  
  61.          });  
  62.            
  63.            
  64.      }  
  65.        
  66.        
  67.      private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
  68.    
  69.          //@Override  
  70.          public void onClick(DialogInterface dialog, int which) {  
  71.              switch (which) {  
  72.              case DialogInterface.BUTTON_POSITIVE:  
  73.                  resultRquest(true);  
  74.                  break;  
  75.              case DialogInterface.BUTTON_NEGATIVE:  
  76.                  resultRquest(false);  
  77.                  break;  
  78.              default:  
  79.                  break;  
  80.              }  
  81.          }  
  82.      };  
  83.        
  84.      private void resultRquest(boolean flag){  
  85.          Intent intent = new Intent(this, MainActivity.class);  
  86.          intent.putExtra(BACKLIGHT_RESULT,flag);  
  87.          setResult(REQUESTCODE_BACKLIGHT_RESULT, intent);  
  88.          finish();  
  89.      }  
  90.    
  91.      //@Override  
  92.      public void onProgressChanged(SeekBar seekBar, int progress,  
  93.              boolean fromUser) {  
  94.          int step = 25;  
  95.          Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS, progress + MINIMUM_BACKLIGHT);  
  96.          setBrightness(progress + MINIMUM_BACKLIGHT);  
  97.      }  
  98.        
  99.      private void initBrightness(){  
  100.          // 获取当前背光亮度  
  101.          try {  
  102.              mOldBrightness = Settings.System.getInt(BacklightActivity.this.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS);  
  103.          } catch (SettingNotFoundException e) {  
  104.              mOldBrightness = MAXIMUM_BACKLIGHT;  
  105.          }  
  106.          seekBar.setMax(MAXIMUM_BACKLIGHT - MINIMUM_BACKLIGHT);  
  107.          Log.v("Brightness max", "setmax:" + (MAXIMUM_BACKLIGHT - MINIMUM_BACKLIGHT));  
  108.          //seekBar.setProgress(mOldBrightness - MINIMUM_BACKLIGHT);  
  109.          seekBar.setProgress(0);  
  110.            
  111.          new Thread(new Runnable() {  
  112.              int value = 0;  
  113.              public void run() {  
  114.                  while (isRun) {  
  115.                      try {  
  116.                          Thread.sleep(150);  
  117.                          value = value+5;   
  118.                          Message message = new Message();  
  119.                          message.what = value;  
  120.                          handler.sendEmptyMessage(message.what);  
  121.                      } catch (InterruptedException e) {  
  122.                      }  
  123.                  }  
  124.              }  
  125.          }).start();  
  126.      }   
  127.        
  128.      private Handler handler = new Handler(){  
  129.          public void handleMessage(android.os.Message msg) {  
  130.              if(msg.what<=MAXIMUM_BACKLIGHT){  
  131.                  seekBar.setProgress(msg.what);  
  132.  //              Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS, msg.what + MINIMUM_BACKLIGHT);       
  133.                  setBrightness(msg.what);  
  134.              }else{  
  135.                  isRun = false;  
  136.              }  
  137.               
  138.          };  
  139.      };  
  140.        
  141.      private void setBrightness(int brightness) {  
  142.          try {  
  143.              IPowerManager power = IPowerManager.Stub.asInterface(ServiceManager.getService("power"));  
  144.              if (power != null) {  
  145.                  power.setBacklightBrightness(brightness);  
  146.              }  
  147.          } catch (RemoteException doe) {  
  148.              Log.e(TAG,"Setting Brightness RemoteException!");         
  149.          }          
  150.      }  
  151.        
  152.      //@Override  
  153.      public void onStartTrackingTouch(SeekBar seekBar) {}  
  154.    
  155.      //@Override  
  156.      public void onStopTrackingTouch(SeekBar seekBar) {}  
  157.  }  
 
  
 
  
 
 
 
 
 5、判断SDcard和获取SDCard的路径
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  static String getSdcardPath(){  
  2.      return Environment.getExternalStorageDirectory().getPath();  
  3.  }  
  4.    
  5.  static boolean checkSdcard(){  
  6.      boolean flag = false;  
  7.      if(Environment.getExternalStorageDirectory().toString().equals("/mnt/sdcard")){  
  8.          flag = true;  
  9.      }  
  10.      return flag;  
  11.  }  
 
  
 
  
 
  
 6、屏幕校准（请参看前面说明）
 
 
 
 
 7、振动马达
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  
  2.         long[] pattern = {  
  3.                 800, 50, 400, 30  
  4.         }; // OFF/ON/OFF/ON...  
  5.         vibrator.vibrate(pattern, 2);  
 
  
 
  
 
  
 8、摄像头（拍照和预览）
 
 
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  public class CameraActivity extends Activity{  
  2.      /** 
  3.       * 第一种方式实现拍照 
  4.       */  
  5.      // private PreView preView = null;  
  6.      //  
  7.      // @Override  
  8.      // protected void onCreate(Bundle savedInstanceState) {  
  9.      // super.onCreate(savedInstanceState);  
  10.      // this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
  11.      // preView = new PreView(this);  
  12.      // setContentView(preView,new LayoutParams(400, 300));  
  13.      // }  
  14.      //  
  15.      // @Override  
  16.      // public boolean onKeyDown(int keyCode, KeyEvent event) {  
  17.      // return preView.onKeyDown(keyCode, event);  
  18.      // }  
  19.    
  20.      private final static String TAG = "CameraActivity";  
  21.      private SurfaceView surfaceView;  
  22.      private SurfaceHolder surfaceHolder;  
  23.      private Camera camera;  
  24.      private File picture;  
  25.        
  26.      private Button btnFinish;  
  27.        
  28.      private Dialog mDialog;  
  29.      private Resources res;  
  30.    
  31.      @Override  
  32.      public void onCreate(Bundle savedInstanceState) {  
  33.          super.onCreate(savedInstanceState);  
  34.           this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
  35.          setContentView(R.layout.camera);  
  36.          setupViews();  
  37.      }  
  38.        
  39.      private void setupViews(){  
  40.          surfaceView = (SurfaceView) findViewById(R.id.camera_preview); // 实例化拍照界面组件  
  41.          surfaceHolder = surfaceView.getHolder(); // 实例化拍照界面组件  
  42.          surfaceHolder.addCallback(surfaceCallback); // 为SurfaceHolder 添加回调  
  43.          surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
  44.          res = getResources();  
  45.          btnFinish =(Button) findViewById(R.id.camera_finish);  
  46.            
  47.          btnFinish.setOnClickListener(new OnClickListener() {  
  48.                
  49.              //@Override  
  50.              public void onClick(View v) {  
  51.                    
  52.                  // 提示是否看到预览  
  53.                  if(mDialog == null){  
  54.                  mDialog = new AlertDialog.Builder(CameraActivity.this).setIcon(  
  55.                          R.drawable.icon).setTitle(res.getString(R.string.camera_title))  
  56.                          .setMessage(res.getString(R.string.camera_msg)).setPositiveButton(  
  57.                                  res.getString(R.string.yes), dialogClick)  
  58.                          .setNegativeButton(res.getString(R.string.no), dialogClick).create();  
  59.                  mDialog.show();}  
  60.              }  
  61.          });  
  62.      }  
  63.        
  64.         private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
  65.    
  66.  //        @Override  
  67.              public void onClick(DialogInterface dialog, int which) {  
  68.                  switch (which) {  
  69.                  case DialogInterface.BUTTON_POSITIVE:  
  70.                      resultRquest(true);  
  71.                      break;  
  72.                  case DialogInterface.BUTTON_NEGATIVE:  
  73.                      resultRquest(false);  
  74.                      break;  
  75.                  default:  
  76.                      break;  
  77.                  }  
  78.    
  79.              }  
  80.          };  
  81.            
  82.          private void resultRquest(boolean flag){  
  83.              Intent intent = new Intent(CameraActivity.this, MainActivity.class);  
  84.              intent.putExtra(CAMERA_RESULT, flag);  
  85.              setResult(REQUESTCODE_CAMERA_RESULT, intent);  
  86.              finish();  
  87.          }  
  88.    
  89.      @Override  
  90.      public boolean onKeyDown(int keyCode, KeyEvent event) {  
  91.          if (keyCode == KeyEvent.KEYCODE_CAMERA  
  92.                  || keyCode == KeyEvent.KEYCODE_SEARCH) {  
  93.              takePic();  
  94.              return true;  
  95.          }  
  96.          return super.onKeyDown(keyCode, event);  
  97.      }  
  98.    
  99.      private void takePic() {  
  100.    
  101.          camera.stopPreview();// 停止预览  
  102.    
  103.          camera.takePicture(null, null, pictureCallback); // 拍照  
  104.      }  
  105.    
  106.      // 照片回调  
  107.      Camera.PictureCallback pictureCallback = new Camera.PictureCallback() {  
  108.          //@Override  
  109.          public void onPictureTaken(byte[] data, Camera camera) {  
  110.              new SavePictureTask().execute(data);  
  111.              camera.startPreview();  
  112.          }  
  113.      };  
  114.    
  115.      // 保存照片任务类  
  116.      class SavePictureTask extends AsyncTask<byte[], String, String> {  
  117.          @Override  
  118.          protected String doInBackground(byte[]... params) {  
  119.    
  120.              picture = new File(Environment.getExternalStorageDirectory(),  
  121.                      "picture.jpg");// 创建文件  
  122.    
  123.              if (picture.exists())  
  124.                  picture.delete(); // 如果文件存在删除掉  
  125.              try {  
  126.                  FileOutputStream fos = new FileOutputStream(picture.getPath()); // 获得文件输出流  
  127.                  fos.write(params[0]); // 写到该文件  
  128.                  fos.close(); // 关闭文件流  
  129.              } catch (Exception e) {  
  130.                  e.printStackTrace();  
  131.              }  
  132.              return null;  
  133.          }  
  134.      }  
  135.    
  136.      // SurfaceHodler 回调，处理打开相机，关闭相机以及照片尺寸的改变  
  137.      SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {  
  138.          //@Override  
  139.          public void surfaceCreated(SurfaceHolder holder) {  
  140.              camera = Camera.open(); // 打开相机  
  141.              try {  
  142.                  camera.setPreviewDisplay(holder); // 设置预览  
  143.              } catch (IOException e) {  
  144.                  camera.release();// 释放  
  145.                  camera = null;  
  146.              }  
  147.          }  
  148.    
  149.          //@Override  
  150.          public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  151.                  int height) {  
  152.              Camera.Parameters parameters = camera.getParameters(); // 获得相机参数  
  153.              parameters.setPictureFormat(PixelFormat.JPEG);// 设置照片格式  
  154.              parameters.setPreviewSize(400, 300); // 设置照片大小  
  155.              camera.setParameters(parameters); // 设置相机参数  
  156.              camera.startPreview(); // 开始预览  
  157.                
  158.          }  
  159.    
  160.          //@Override  
  161.          public void surfaceDestroyed(SurfaceHolder holder) {  
  162.              Log.i(TAG,"====surfaceDestroyed");  
  163.              camera.stopPreview();// 停止预览  
  164.              camera.release(); // 释放相机资源  
  165.              camera = null;  
  166.          }  
  167.      };  
  168.    
  169.        
  170.  }  
 
  
 
  
 
  
 9、按键（只要重写dispoatchKeyEvent即可）
 
 
 
 

   以下是屏蔽Home键的方法： 
 
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  @Override  
  2.      public void onAttachedToWindow() {  
  3.          this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);     
  4.          super.onAttachedToWindow();       
  5.      }  
 
  
 
  
 
  
 
 
 
 
 
 
 11、录音
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  public class MicActivity extends Activity implements OnClickListener{  
  2.    
  3.      private final static String TAG="MicActivity";  
  4.        
  5.      private Button btnMicRecord;  
  6.      private Button btnMicPlay;  
  7.      private Button btnMicFinish;  
  8.      private TextView txtMicAmplitudeMsg;  
  9.      private TextView txtMicTimeMsg;  
  10.        
  11.      private File recAudioFile;  
  12.      private MediaRecorder mMediaRecorder;  
  13.      private Resources res;  
  14.        
  15.      private static int time;  
  16.      private static int mic_state = MIC_STATE_RECORD;  
  17.        
  18.      private Thread threadAmplitude;  
  19.      private Thread threadTime;  
  20.      private static boolean threadRun ;  
  21.        
  22.      @Override  
  23.      protected void onCreate(Bundle savedInstanceState) {  
  24.          super.onCreate(savedInstanceState);  
  25.          setContentView(R.layout.mic);  
  26.          setupViews();  
  27.      }  
  28.        
  29.      @Override  
  30.      protected void onPause() {  
  31.          super.onPause();  
  32.          threadAmplitude = null;  
  33.          threadTime = null;  
  34.            
  35.      }  
  36.        
  37.      private void setupViews() {  
  38.            
  39.            
  40.          btnMicRecord = (Button) findViewById(R.id.mic_record);  
  41.          btnMicPlay = (Button) findViewById(R.id.mic_play);  
  42.          btnMicFinish = (Button) findViewById(R.id.mic_finish);  
  43.          txtMicAmplitudeMsg = (TextView) findViewById(R.id.mic_amplitude_msg);  
  44.          txtMicTimeMsg = (TextView) findViewById(R.id.mic_time_msg);  
  45.            
  46.          btnMicRecord.setOnClickListener(this);  
  47.          btnMicPlay.setOnClickListener(this);  
  48.          btnMicFinish.setOnClickListener(this);  
  49.            
  50.          res = getResources();  
  51.          threadAmplitude = new Thread(new UpdateAmplitude());  
  52.          threadTime = new Thread(new UpdateTime());  
  53.      }  
  54.        
  55.        
  56.      //@Override  
  57.      public void onClick(View v) {  
  58.          switch (v.getId()) {  
  59.          case R.id.mic_record:  
  60.              if (mic_state== MIC_STATE_RECORD) { // 录音  
  61.                  btnMicRecord.setText(res.getString(R.string.mic_record_save_text));  
  62.                  mic_state = MIC_STATE_SAVE;  
  63.                  startRecorder();  
  64.              } else if (mic_state== MIC_STATE_SAVE) {  
  65.                  btnMicRecord.setText(res.getString(R.string.mic_record_text));  
  66.                  btnMicRecord.setEnabled(false);  
  67.                  btnMicPlay.setEnabled(true);  
  68.                  mic_state = MIC_STATE_RECORD;  
  69.                  stopRecorder();  
  70.              }  
  71.              break;  
  72.          case R.id.mic_play:  
  73.              openFile(recAudioFile);  
  74.              btnMicRecord.setEnabled(true);  
  75.              btnMicFinish.setEnabled(true);  
  76.              break;  
  77.          case R.id.mic_finish:  
  78.              new AlertDialog.Builder(MicActivity.this).setIcon(  
  79.                      R.drawable.icon).setTitle(res.getString(R.string.mic_title))  
  80.                      .setMessage(res.getString(R.string.mic_msg)).setPositiveButton(  
  81.                              res.getString(R.string.yes), dialogClick)  
  82.                      .setNegativeButton(res.getString(R.string.no), dialogClick).create().show();  
  83.              break;  
  84.          default:  
  85.              break;  
  86.          }  
  87.      }  
  88.        
  89.      private android.content.DialogInterface.OnClickListener dialogClick = new android.content.DialogInterface.OnClickListener() {  
  90.    
  91.          //@Override  
  92.          public void onClick(DialogInterface dialog, int which) {  
  93.              switch (which) {  
  94.              case DialogInterface.BUTTON_POSITIVE:  
  95.                  result(true);  
  96.                  break;  
  97.              case DialogInterface.BUTTON_NEGATIVE:  
  98.                  result(false);  
  99.                  break;  
  100.              default:  
  101.                  break;  
  102.              }  
  103.                
  104.    
  105.          }  
  106.      };  
  107.        
  108.        
  109.      private void result(boolean flag){  
  110.          Intent intent = new Intent(MicActivity.this, MainActivity.class);  
  111.          intent.putExtra(MIC_RESULT, flag);  
  112.          setResult(REQUESTCODE_MIC_RESULT, intent);  
  113.          finish();  
  114.      }  
  115.        
  116.      private class UpdateAmplitude implements Runnable{  
  117.    
  118.          //@Override  
  119.          public void run() {  
  120.              while (threadRun) {  
  121.                  try {  
  122.                      Message msg = new Message();  
  123.                      msg.what = mMediaRecorder.getMaxAmplitude();  
  124.                      amplitudeHandler.sendMessage(msg);  
  125.                      Thread.sleep(250);  
  126.                  } catch (InterruptedException e) {  
  127.                      e.printStackTrace();  
  128.                  }  
  129.              }  
  130.          }  
  131.      }  
  132.        
  133.      private Handler amplitudeHandler = new Handler(){  
  134.          @Override  
  135.          public void handleMessage(Message msg) {  
  136.              super.handleMessage(msg);  
  137.              String text = String.format(res.getString(R.string.mic_status_amplitude),String.valueOf(msg.what));  
  138.              txtMicAmplitudeMsg.setText(text);  
  139.          }  
  140.      };  
  141.        
  142.      private class UpdateTime implements Runnable{  
  143.          //@Override  
  144.          public void run() {  
  145.              while (threadRun) {  
  146.                  try {  
  147.                      Thread.sleep(1000);  
  148.                      time++;  
  149.                      timeHandler.sendEmptyMessage(time);  
  150.                  } catch (InterruptedException e) {  
  151.                      e.printStackTrace();  
  152.                  }  
  153.                    
  154.              }  
  155.          }  
  156.      }  
  157.        
  158.      private Handler timeHandler = new Handler(){  
  159.          public void handleMessage(Message msg) {  
  160.              super.handleMessage(msg);  
  161.              String text = String.format(res.getString(R.string.mic_status_time), String.valueOf(msg.what));  
  162.              txtMicTimeMsg.setText(text);  
  163.          };  
  164.      };  
  165.        
  166.      private void startRecorder(){  
  167.          mMediaRecorder = new MediaRecorder();  
  168.          recAudioFile = new File("/mnt/flash", "new.amr");  
  169.          if (recAudioFile.exists()) {  
  170.              recAudioFile.delete();  
  171.          }  
  172.          mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); // 设置录音来源  
  173.          mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);  
  174.          mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);   
  175.          mMediaRecorder.setOutputFile(recAudioFile.getAbsolutePath());    
  176.            
  177.          try {  
  178.              mMediaRecorder.prepare();  
  179.          } catch (IllegalStateException e) {  
  180.              e.printStackTrace();  
  181.          } catch (IOException e) {  
  182.              e.printStackTrace();  
  183.          }  
  184.          mMediaRecorder.start();  
  185.          threadRun = true;  
  186.          threadAmplitude.start();  
  187.          threadTime.start();  
  188.      }  
  189.        
  190.      private void stopRecorder(){  
  191.          time = 0;  
  192.          threadRun = false;  
  193.          if (recAudioFile!=null) {  
  194.              mMediaRecorder.stop();  
  195.              mMediaRecorder.release();  
  196.          }  
  197.      }  
  198.    
  199.      /* 打开播放录音文件的程序 */  
  200.      private void openFile(File f) {  
  201.          Intent intent = new Intent();  
  202.          intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
  203.          intent.setAction(android.content.Intent.ACTION_VIEW);  
  204.          String type = getMIMEType(f);  
  205.          intent.setDataAndType(Uri.fromFile(f), type);  
  206.          startActivity(intent);  
  207.      }  
  208.    
  209.      private String getMIMEType(File f) {  
  210.          String end = f.getName().substring(f.getName().lastIndexOf(".") + 1,  
  211.                  f.getName().length()).toLowerCase();  
  212.          String type = "";  
  213.          if (end.equals("mp3") || end.equals("aac") || end.equals("aac")  
  214.                  || end.equals("amr") || end.equals("mpeg") || end.equals("mp4")) {  
  215.              type = "audio";  
  216.          } else if (end.equals("jpg") || end.equals("gif") || end.equals("png")  
  217.                  || end.equals("jpeg")) {  
  218.              type = "image";  
  219.          } else {  
  220.              type = "*";  
  221.          }  
  222.          type += "/*";  
  223.          return type;  
  224.      }  
  225.        
  226.  }  
 
  
 12、重力感应 
 
 
 
 
  
 
   
 
    
 
     view plain 
    
 
   
 
   
  1.  public class MySensorEventListener implements SensorEventListener {  
  2.    
  3.      private boolean isPass;  
  4.    
  5.      private SaveMessage saveMessage;  
  6.    
  7.      public MySensorEventListener(Context context) {  
  8.          saveMessage = new SaveMessage(context);  
  9.      }  
  10.    
  11.      // @Override  
  12.      public void onAccuracyChanged(Sensor sensor, int accuracy) {  
  13.      }  
  14.    
  15.      // @Override  
  16.      public void onSensorChanged(SensorEvent event) {  
  17.          if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {  
  18.              // 得到方向的值  
  19.              float x = event.values[SensorManager.DATA_X];  
  20.              float y = event.values[SensorManager.DATA_Y];  
  21.              float z = event.values[SensorManager.DATA_Z];  
  22.              isPass = x != 0 || y != 0 || z != 0;  
  23.              System.out.println("Orientation-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
  24.              saveMessage.setMessage(MSG_SENEOR, "Orientation-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
  25.          } else if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {  
  26.              // 得到加速度的值  
  27.              float x = event.values[SensorManager.DATA_X];  
  28.              float y = event.values[SensorManager.DATA_Y];  
  29.              float z = event.values[SensorManager.DATA_Z];  
  30.              isPass = x != 0 || y != 0 || z != 0;  
  31.              System.out.println("Accelerometer-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
  32.              saveMessage.setMessage(MSG_SENEOR, "Accelerometer-Seneor " + (isPass ? "ok!" + " x=" + x + " y=" + y + " z=" + z : "error!"));  
  33.          }  
  34.      }  
  35.    
  36.  }  
 
  
 
  
 原创文章，转载请注明出处： 
  http://blog.csdn.net/tangcheng_ok/article/details/6684646 
 
 


                

        

        

    




    

      

        

            

              
                
                  qeqeqe236
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
基于一种可以用按键进行调节LCD背光亮度的解决方案

				
			

			

				

					01-19
				

			

		

		

			
				
考虑到设备功耗的降低以及使用的便利性，本文在嵌入式Linux下，设计了一种使用S3C2440的定时器产生PWM （Pulse Width Modulation）信号，根据设备实际使用需要，和外界光线强度的变化用按键调节LCD背光亮度的解决...

			
		

	



                

              
                



	

		

			

				
					
普及型手机LCD背光驱动趋向使用LDO

				
			

			

				

					11-18
				

			

		

		

			
				
手机彩色LCD屏的背光一般使用2颗-8颗LED灯，它们的驱动用并联或单颗恒流供电的方式居多。自2000年来，手机彩色LCD屏常用LED驱动器有DC/DC开关稳压器、电荷泵、恒流源和低压差稳压器(LDO)。  　DC/DC开关稳压器是用...

			
		

	



                


  
              

                


	

		

			

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

				
			

			

				

					Delion
				

				

					10-19
					
					1881
					
				

			

		

		

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

1、WIFI（打开，关闭，使能，扫描等）
2、蓝牙（打开关闭）
3、电池（获取电池的各种参数和状态信息）
4、背光（背光调节）
5、U盘/SDcard（判断是否插入，读取等）
6、屏幕校准（准确的说是点击屏幕的准确度，不是校准屏幕，这是一个简单的算法

			
		

	





	

		

			

				
					
Android 蓝牙通信及WiFi开发

				
			

			

				

					Bug不知所起，一往而深。
				

				

					03-16
					
					5127
					
				

			

		

		

			
				
在我们正常的Android蓝牙功能开发步骤中，一般要经过系统权限和蓝牙开关状态监测、设备扫描、设备连接、蓝牙数据通信这几个过程。 
在Android 4.3系统之后，我们可以使用蓝牙4.0（低功耗蓝牙），它最主要的特点是低功耗，普及率高。现在所说的蓝牙设备，大部分都是在说4.0设备，ble也特指4.0设备。 在4.0之前重要的版本有2.1版本-基本速率／增强数据率(BR/EDR)和3.0 高速蓝牙版

			
		

	



		

			
		



	

		

			

				
					
android设置wifi蓝牙共享文件,无需互联网或蓝牙即可通过WiFi通过android共享文件...

				
			

			

				

					weixin_30247833的博客
				

				

					05-26
					
					761
					
				

			

		

		

			
				
我们需要蓝牙在手机之间传输文件的日子已经一去不复返了。不仅蓝牙文件传输缓慢，而且范围也非常有限!。当我们可以使用WiFi在短短几秒钟内将文件传输到40MB时，为什么还要浪费几分钟执行同一任务呢?。以下是3个适用于Android的最佳免费WiFi传输应用程序，可用于通过WiFi将文件从Android传输到Android或PC，而无需蓝牙或互联网连接。应用程式1 – Lenovo的ShareItSha...

			
		

	





	

		

			

				
					
android开发教程之 十八 蓝牙及Wi-Fi

				
			

			

				

					张晨光老师的播客
				

				

					05-07
					
					2633
					
				

			

		

		

			
				
学习内容Ø蓝牙的基本概念ØAndroid中蓝牙的应用 能力目标Ø了解蓝牙的基本概念Ø掌握Android中蓝牙的应用 Ø掌握如何使用Android中Wi-Fi本章简介	蓝牙是一种重要的短距离无线通信技术，它被广泛应用于各种设备，比如计算机、手机、汽车等，支持设备之间的近距离通信，从而是数据传输更加快捷有效。Wi-Fi是一种高速的无线通信协议，它具有传输速度高，传输距离长的特点。通过Wi...

			
		

	





	

		

			

				
					
【Android】关于WIFI局域网的手机摄像头当视频监控用实现方案详解

					
热门推荐

				
			

			

				

					TA远方
				

				

					04-10
					
					1万+
					
				

			

		

		

			
				
现有的智能手机是可以充当Wifi摄像头来使用的，这就需要装一个App就能实现了，如果是用别的下载来APP安装用来会不会不放心呢，如果自己有能力，那就可以通过开发Android App项目过程来实现视频监控，有兴趣的来看看接下来的实现方案

			
		

	





	

		

			

				
					
使用LED边缘光源技术优化背光系统

				
			

			

				

					01-19
				

			

		

		

			
				
生产成本更低、更薄、更轻的背光单元包括小于0.6mm厚的背光组件，并使用薄至0.25mm的导光体已经成为事实，如图1所示。背光单元的厚度已经达到了场致发光背光的厚度，并具有当今先进LED所具有的优异发光特性和其他...

			
		

	





	

		

			

				
					
Maxim推出具有自适应模式切换功能的背光驱动器

				
			

			

				

					11-07
				

			

		

		

			
				
该系列背光驱动器采用负压电荷泵架构，消除了电池和WLED之间的线路电阻，从而在电池放电期间延长了从1倍压切换至1.5倍压的时间，最大程度地降低了压差。专有的自适应模式切换技术独立控制每个LED，能够将LED效率提高...

			
		

	





	

		

			

				
					
Analogic推出具备闪光灯功能的六通道背光电荷泵

				
			

			

				

					12-01
				

			

		

		

			
				
该设备支持针对便携式系统(采用聚合物锂离子电池)的白光LED背光和相机闪光灯应用产品。 AAT2803可单独控制三个独立的LED组(其中两个用于背光，另一个用于相机闪光灯)，并且配备七个通道(其中六个用于背光，另一个...

			
		

	





	

		

			

				
					
android开发实例-sdcard文件读写及WIFI检测

				
			

			

				

					02-20
				

			

		

		

			
				
android开发实例-sdcard文件读写
WIFI检测、下载文件等
开发环境：JAVA SDK1.7及android最新的开发包

			
		

	





	

		

			

				
					
android wifi网络摄像头源代码

				
			

			

				

					07-22
				

			

		

		

			
				
源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码

			
		

	





	

		

			

				
					
家用WiFi网络摄像头Android代码

				
			

			

				

					10-21
				

			

		

		

			
				
底层主控：arduino数码版，此资源为Android部分代码

			
		

	





	

		

			

				
					
Android WiFi Camera (无线局域网IP摄像头)

				
			

			

				

					04-01
				

			

		

		

			
				
Android WiFi Camera (无线局域网IP摄像头)
支持闪光灯，可以远程截取图片

			
		

	





	

		

			

				
					
Arduino蓝牙摄像头（ABC）

				
			

			

				

					03-30
				

			

		

		

			
				
通过蓝牙在Arduino和Android手机之间传输图像。

			
		

	





	

		

			

				
					
lcd1602按键背光电路图

					
最新发布

				
			

			

				

					05-26
				

			

		

		

			
				
下面是一种常见的LCD1602按键背光电路图：

![LCD1602按键背光电路图](https://img-blog.csdn.net/20151203165922610)

其中，VCC和GND分别连接电源正负极，RS、RW、E分别为LCD控制接口，K1和K2分别为背光LED的阳极和阴极，而K3和K4则是两个按键的接口引脚。在实际应用中，K3和K4可以连接到外部按键，以便用户控制LCD屏幕的显示和背光亮度。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值