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

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

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

packagecn.tch;

importjava.util.List;

importandroid.content.Context;
importandroid.net.wifi.ScanResult;
importandroid.net.wifi.WifiConfiguration;
importandroid.net.wifi.WifiInfo;
importandroid.net.wifi.WifiManager;
importandroid.net.wifi.WifiManager.WifiLock;

publicclassWifiHelper{
//定义WifiManager对象
privateWifiManagermWifiManager;
//定义WifiInfo对象
privateWifiInfomWifiInfo;
//扫描出的网络连接列表
privateList<ScanResult>mWifiList;
//网络连接列表
privateList<WifiConfiguration>mWifiConfiguration;
//定义一个WifiLock
WifiLockmWifiLock;

//构造器
publicWifiHelper(Contextcontext){
//取得WifiManager对象
mWifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);
//取得WifiInfo对象
mWifiInfo=mWifiManager.getConnectionInfo();
}

publicWifiManagergetWifiManager(){
returnmWifiManager;
}

//打开WIFI
publicbooleanopenWifi(){
booleanflag=false;
if(!mWifiManager.isWifiEnabled()){
flag=mWifiManager.setWifiEnabled(true);
}elseif(mWifiManager.isWifiEnabled()){
flag=true;
}
returnflag;
}

//关闭WIFI
publicvoidcloseWifi(){
if(!mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(false);
}
}

//锁定WifiLock
publicvoidacquireWifiLock(){
mWifiLock.acquire();
}

//解锁WifiLock
publicvoidreleaseWifiLock(){
//判断时候锁定
if(mWifiLock.isHeld()){
mWifiLock.acquire();
}
}

//创建一个WifiLock
publicvoidcreatWifiLock(){
mWifiLock=mWifiManager.createWifiLock("Test");
}

//得到配置好的网络
publicList<WifiConfiguration>getConfiguration(){
returnmWifiConfiguration;
}

//指定配置好的网络进行连接
publicvoidconnectConfiguration(intindex){
//索引大于配置好的网络索引返回
if(index>mWifiConfiguration.size()){
return;
}
//连接配置好的指定ID的网络
mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,true);
}

publicvoidstartScan(){
mWifiManager.startScan();
//得到扫描结果
mWifiList=mWifiManager.getScanResults();
//得到配置好的网络连接
mWifiConfiguration=mWifiManager.getConfiguredNetworks();
}

//得到网络列表
publicList<ScanResult>getWifiList(){
mWifiManager.startScan();
//得到扫描结果
returnmWifiManager.getScanResults();
}

//查看扫描结果
publicStringBuilderlookUpScan(List<ScanResult>list){
StringBuilderstringBuilder=newStringBuilder();
for(inti=0;i<list.size();i++){
stringBuilder
.append("\n结果"+newInteger(i+1).toString()+"(");
//将ScanResult信息转换成一个字符串包
//其中把包括：BSSID、SSID、capabilities、frequency、level
stringBuilder.append((list.get(i)).toString());
stringBuilder.append(")\n");
}
returnstringBuilder;
}

//得到MAC地址
publicStringgetMacAddress(){
return(mWifiInfo==null)?"NULL":mWifiInfo.getMacAddress();
}

//得到接入点的BSSID
publicStringgetBSSID(){
return(mWifiInfo==null)?"NULL":mWifiInfo.getBSSID();
}

//得到IP地址
publicintgetIPAddress(){
return(mWifiInfo==null)?0:mWifiInfo.getIpAddress();
}

//得到连接的ID
publicintgetNetworkId(){
return(mWifiInfo==null)?0:mWifiInfo.getNetworkId();
}

//得到WifiInfo的所有信息包
publicStringgetWifiInfo(){
return(mWifiInfo==null)?"NULL":mWifiInfo.toString();
}

//添加一个网络并连接
publicvoidaddNetwork(WifiConfigurationwcg){
intwcgID=mWifiManager.addNetwork(wcg);
mWifiManager.enableNetwork(wcgID,true);
}

//断开指定ID的网络
publicvoiddisconnectWifi(intnetId){
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}


}

2、蓝牙

booleanflag=false;
lt;preclass="java"name="code">BluetoothAdapterbluetoothAdapter=BluetoothAdapter.getDefaultAdapter();

if (bluetoothAdapter.isEnabled()) { bluetoothAdapter.disable(); flag = bluetoothAdapter.enable(); } else { flag = bluetoothAdapter.enable(); }

3、电池

1、新建一个广播接收类

packagecn.tch;

importandroid.content.BroadcastReceiver;
importandroid.content.Context;
importandroid.content.Intent;
importandroid.content.res.Resources;
importandroid.os.BatteryManager;
importandroid.util.Log;

importjava.util.ArrayList;

publicclassBatteryBroadcastReceiverextendsBroadcastReceiver{

privateStringaction;
privateintstatus;
privateinthealth;
privateintplugged;
privateStringstatusString;
privateStringhealthString;
privateStringacString;
privateResourcesmResources;
privateStringBufferbuffer=newStringBuffer();
privatestaticintcount=0;
privateArrayList<String>batteryMsg;

intlevel;//电池电量，数字
intscale;//电池最大容量
intvoltage;//电池伏数
inttemperature;//电池温度

publicBatteryBroadcastReceiver(Resourcesres){
mResources=res;
batteryMsg=newArrayList<String>();
}

@Override
publicvoidonReceive(Contextcontext,Intentintent){
action=intent.getAction();
status=intent.getIntExtra("status",0);
health=intent.getIntExtra("health",0);
plugged=intent.getIntExtra("plugged",0);
switch(status){
caseBatteryManager.BATTERY_STATUS_UNKNOWN:
statusString="unknown";
break;
caseBatteryManager.BATTERY_STATUS_CHARGING:
statusString="charging";
break;
caseBatteryManager.BATTERY_STATUS_DISCHARGING:
statusString="discharging";
break;
caseBatteryManager.BATTERY_STATUS_NOT_CHARGING:
statusString="notcharging";
break;
caseBatteryManager.BATTERY_STATUS_FULL:
statusString="full";
break;
}

switch(health){
caseBatteryManager.BATTERY_HEALTH_UNKNOWN:
healthString="unknown";
break;
caseBatteryManager.BATTERY_HEALTH_GOOD:
healthString="good";
break;
caseBatteryManager.BATTERY_HEALTH_OVERHEAT:
healthString="overheat";
break;
caseBatteryManager.BATTERY_HEALTH_DEAD:
healthString="dead";
break;
caseBatteryManager.BATTERY_HEALTH_OVER_VOLTAGE:
healthString="voltage";
break;
caseBatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE:
healthString="unspecifiedfailure";
break;
}
switch(plugged){
caseBatteryManager.BATTERY_PLUGGED_AC:
acString="pluggedac";
break;
caseBatteryManager.BATTERY_PLUGGED_USB:
acString="pluggedusb";
break;
}
//if(action.equals(Intent.ACTION_BATTERY_CHANGED)){
//for(inti=count;i<10;i++){
//level=intent.getIntExtra("level",0);//电池电量，数字
//scale=intent.getIntExtra("scale",0);//电池最大容量
//voltage=intent.getIntExtra("voltage",0);//电池伏数
//temperature=intent.getIntExtra("temperature",0);//电池温度
//Stringmsg=String.format(res.getString(R.string.battery_chenged_msg),level,scale,voltage,
//temperature,statusString,acString,healthString);
//batteryMsg.add(msg);
//count++;
//}
//}
}


//电池状态，返回是一个数字
//BatteryManager.BATTERY_STATUS_CHARGING表示是充电状态
//BatteryManager.BATTERY_STATUS_DISCHARGING放电中
//BatteryManager.BATTERY_STATUS_NOT_CHARGING未充电
//BatteryManager.BATTERY_STATUS_FULL电池满
//充电类型BatteryManager.BATTERY_PLUGGED_AC表示是充电器，不是这个值，表示是USB
//电池健康情况，返回也是一个数字
//BatteryManager.BATTERY_HEALTH_GOOD良好
//BatteryManager.BATTERY_HEALTH_OVERHEAT过热
//BatteryManager.BATTERY_HEALTH_DEAD没电
//BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE过电压
//BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE未知错误
}

2、注册广播

IntentFilterintentFilter=newIntentFilter();
intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
registerReceiver(batteryReceiver,intentFilter);

4、背光

packagecn.tch;

importandroid.app.Activity;
importandroid.app.AlertDialog;
importandroid.content.DialogInterface;
importandroid.content.Intent;
importandroid.content.res.Resources;
importandroid.os.Bundle;
importandroid.os.Handler;
importandroid.os.Message;
importandroid.os.RemoteException;
importandroid.provider.Settings;
importandroid.provider.Settings.SettingNotFoundException;
importandroid.util.Log;
importandroid.view.View;
importandroid.view.View.OnClickListener;
importandroid.widget.Button;
importandroid.widget.ProgressBar;
importandroid.widget.SeekBar;
importandroid.widget.SeekBar.OnSeekBarChangeListener;
importandroid.os.IPowerManager;
importandroid.os.ServiceManager;

importstaticcn.tch.Constant.*;

publicclassBacklightActivityextendsActivityimplementsOnSeekBarChangeListener{

privatefinalstaticStringTAG="BacklightActivity";
privateSeekBarseekBar;
privateButtonbtnFinish;
privateResourcesres;

privateintmOldBrightness=0;
privatestaticfinalintMINIMUM_BACKLIGHT=android.os.Power.BRIGHTNESS_DIM+10;
privatestaticfinalintMAXIMUM_BACKLIGHT=android.os.Power.BRIGHTNESS_ON;

privatebooleanisRun=true;

@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);

setContentView(R.layout.backlight);
res=getResources();
seekBar=(SeekBar)findViewById(R.id.bl_seekbar);
btnFinish=(Button)findViewById(R.id.bl_finish);
initBrightness();


seekBar.setOnSeekBarChangeListener(this);
btnFinish.setOnClickListener(newOnClickListener(){

//@Override
publicvoidonClick(Viewv){
newAlertDialog.Builder(BacklightActivity.this).setIcon(
R.drawable.icon).setTitle(res.getString(R.string.backlight_title))
.setMessage(res.getString(R.string.backlight_msg)).setPositiveButton(
res.getString(R.string.yes),dialogClick)
.setNegativeButton(res.getString(R.string.no),dialogClick).create().show();
}
});


}


privateandroid.content.DialogInterface.OnClickListenerdialogClick=newandroid.content.DialogInterface.OnClickListener(){

//@Override
publicvoidonClick(DialogInterfacedialog,intwhich){
switch(which){
caseDialogInterface.BUTTON_POSITIVE:
resultRquest(true);
break;
caseDialogInterface.BUTTON_NEGATIVE:
resultRquest(false);
break;
default:
break;
}
}
};

privatevoidresultRquest(booleanflag){
Intentintent=newIntent(this,MainActivity.class);
intent.putExtra(BACKLIGHT_RESULT,flag);
setResult(REQUESTCODE_BACKLIGHT_RESULT,intent);
finish();
}

//@Override
publicvoidonProgressChanged(SeekBarseekBar,intprogress,
booleanfromUser){
intstep=25;
Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS,progress+MINIMUM_BACKLIGHT);
setBrightness(progress+MINIMUM_BACKLIGHT);
}

privatevoidinitBrightness(){
//获取当前背光亮度
try{
mOldBrightness=Settings.System.getInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS);
}catch(SettingNotFoundExceptione){
mOldBrightness=MAXIMUM_BACKLIGHT;
}
seekBar.setMax(MAXIMUM_BACKLIGHT-MINIMUM_BACKLIGHT);
Log.v("Brightnessmax","setmax:"+(MAXIMUM_BACKLIGHT-MINIMUM_BACKLIGHT));
//seekBar.setProgress(mOldBrightness-MINIMUM_BACKLIGHT);
seekBar.setProgress(0);

newThread(newRunnable(){
intvalue=0;
publicvoidrun(){
while(isRun){
try{
Thread.sleep(150);
value=value+5;
Messagemessage=newMessage();
message.what=value;
handler.sendEmptyMessage(message.what);
}catch(InterruptedExceptione){
}
}
}
}).start();
}

privateHandlerhandler=newHandler(){
publicvoidhandleMessage(android.os.Messagemsg){
if(msg.what<=MAXIMUM_BACKLIGHT){
seekBar.setProgress(msg.what);
//Settings.System.putInt(BacklightActivity.this.getContentResolver(),Settings.System.SCREEN_BRIGHTNESS,msg.what+MINIMUM_BACKLIGHT);
setBrightness(msg.what);
}else{
isRun=false;
}

};
};

privatevoidsetBrightness(intbrightness){
try{
IPowerManagerpower=IPowerManager.Stub.asInterface(ServiceManager.getService("power"));
if(power!=null){
power.setBacklightBrightness(brightness);
}
}catch(RemoteExceptiondoe){
Log.e(TAG,"SettingBrightnessRemoteException!");
}
}

//@Override
publicvoidonStartTrackingTouch(SeekBarseekBar){}

//@Override
publicvoidonStopTrackingTouch(SeekBarseekBar){}
}

5、判断SDcard和获取SDCard的路径

staticStringgetSdcardPath(){
returnEnvironment.getExternalStorageDirectory().getPath();
}

staticbooleancheckSdcard(){
booleanflag=false;
if(Environment.getExternalStorageDirectory().toString().equals("/mnt/sdcard")){
flag=true;
}
returnflag;
}

6、屏幕校准（请参看前面说明）

7、振动马达

vibrator=(Vibrator)getSystemService(VIBRATOR_SERVICE);
long[]pattern={
800,50,400,30
};//OFF/ON/OFF/ON...
vibrator.vibrate(pattern,2);

8、摄像头（拍照和预览）

publicclassCameraActivityextendsActivity{
/**
*第一种方式实现拍照
*/
//privatePreViewpreView=null;
//
//@Override
//protectedvoidonCreate(BundlesavedInstanceState){
//super.onCreate(savedInstanceState);
//this.requestWindowFeature(Window.FEATURE_NO_TITLE);
//preView=newPreView(this);
//setContentView(preView,newLayoutParams(400,300));
//}
//
//@Override
//publicbooleanonKeyDown(intkeyCode,KeyEventevent){
//returnpreView.onKeyDown(keyCode,event);
//}

privatefinalstaticStringTAG="CameraActivity";
privateSurfaceViewsurfaceView;
privateSurfaceHoldersurfaceHolder;
privateCameracamera;
privateFilepicture;

privateButtonbtnFinish;

privateDialogmDialog;
privateResourcesres;

@Override
publicvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
this.requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.camera);
setupViews();
}

privatevoidsetupViews(){
surfaceView=(SurfaceView)findViewById(R.id.camera_preview);//实例化拍照界面组件
surfaceHolder=surfaceView.getHolder();//实例化拍照界面组件
surfaceHolder.addCallback(surfaceCallback);//为SurfaceHolder添加回调
surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
res=getResources();
btnFinish=(Button)findViewById(R.id.camera_finish);

btnFinish.setOnClickListener(newOnClickListener(){

//@Override
publicvoidonClick(Viewv){

//提示是否看到预览
if(mDialog==null){
mDialog=newAlertDialog.Builder(CameraActivity.this).setIcon(
R.drawable.icon).setTitle(res.getString(R.string.camera_title))
.setMessage(res.getString(R.string.camera_msg)).setPositiveButton(
res.getString(R.string.yes),dialogClick)
.setNegativeButton(res.getString(R.string.no),dialogClick).create();
mDialog.show();}
}
});
}

privateandroid.content.DialogInterface.OnClickListenerdialogClick=newandroid.content.DialogInterface.OnClickListener(){

//@Override
publicvoidonClick(DialogInterfacedialog,intwhich){
switch(which){
caseDialogInterface.BUTTON_POSITIVE:
resultRquest(true);
break;
caseDialogInterface.BUTTON_NEGATIVE:
resultRquest(false);
break;
default:
break;
}

}
};

privatevoidresultRquest(booleanflag){
Intentintent=newIntent(CameraActivity.this,MainActivity.class);
intent.putExtra(CAMERA_RESULT,flag);
setResult(REQUESTCODE_CAMERA_RESULT,intent);
finish();
}

@Override
publicbooleanonKeyDown(intkeyCode,KeyEventevent){
if(keyCode==KeyEvent.KEYCODE_CAMERA
||keyCode==KeyEvent.KEYCODE_SEARCH){
takePic();
returntrue;
}
returnsuper.onKeyDown(keyCode,event);
}

privatevoidtakePic(){

camera.stopPreview();//停止预览

camera.takePicture(null,null,pictureCallback);//拍照
}

//照片回调
Camera.PictureCallbackpictureCallback=newCamera.PictureCallback(){
//@Override
publicvoidonPictureTaken(byte[]data,Cameracamera){
newSavePictureTask().execute(data);
camera.startPreview();
}
};

//保存照片任务类
classSavePictureTaskextendsAsyncTask<byte[],String,String>{
@Override
protectedStringdoInBackground(byte[]...params){

picture=newFile(Environment.getExternalStorageDirectory(),
"picture.jpg");//创建文件

if(picture.exists())
picture.delete();//如果文件存在删除掉
try{
FileOutputStreamfos=newFileOutputStream(picture.getPath());//获得文件输出流
fos.write(params[0]);//写到该文件
fos.close();//关闭文件流
}catch(Exceptione){
e.printStackTrace();
}
returnnull;
}
}

//SurfaceHodler回调，处理打开相机，关闭相机以及照片尺寸的改变
SurfaceHolder.CallbacksurfaceCallback=newSurfaceHolder.Callback(){
//@Override
publicvoidsurfaceCreated(SurfaceHolderholder){
camera=Camera.open();//打开相机
try{
camera.setPreviewDisplay(holder);//设置预览
}catch(IOExceptione){
camera.release();//释放
camera=null;
}
}

//@Override
publicvoidsurfaceChanged(SurfaceHolderholder,intformat,intwidth,
intheight){
Camera.Parametersparameters=camera.getParameters();//获得相机参数
parameters.setPictureFormat(PixelFormat.JPEG);//设置照片格式
parameters.setPreviewSize(400,300);//设置照片大小
camera.setParameters(parameters);//设置相机参数
camera.startPreview();//开始预览

}

//@Override
publicvoidsurfaceDestroyed(SurfaceHolderholder){
Log.i(TAG,"====surfaceDestroyed");
camera.stopPreview();//停止预览
camera.release();//释放相机资源
camera=null;
}
};


}

9、按键（只要重写dispoatchKeyEvent即可）

以下是屏蔽Home键的方法：

@Override
publicvoidonAttachedToWindow(){
this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);
super.onAttachedToWindow();
}

10、音乐播放器

代码太多了，给个给力的连接吧！http://hi.baidu.com/orangejackylee/blog/item/6afb84d68e36cbd0a9ec9a36.html/cmtid/ce7e663d9938dffdb211c7d6

11、录音

publicclassMicActivityextendsActivityimplementsOnClickListener{

privatefinalstaticStringTAG="MicActivity";

privateButtonbtnMicRecord;
privateButtonbtnMicPlay;
privateButtonbtnMicFinish;
privateTextViewtxtMicAmplitudeMsg;
privateTextViewtxtMicTimeMsg;

privateFilerecAudioFile;
privateMediaRecordermMediaRecorder;
privateResourcesres;

privatestaticinttime;
privatestaticintmic_state=MIC_STATE_RECORD;

privateThreadthreadAmplitude;
privateThreadthreadTime;
privatestaticbooleanthreadRun;

@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.mic);
setupViews();
}

@Override
protectedvoidonPause(){
super.onPause();
threadAmplitude=null;
threadTime=null;

}

privatevoidsetupViews(){


btnMicRecord=(Button)findViewById(R.id.mic_record);
btnMicPlay=(Button)findViewById(R.id.mic_play);
btnMicFinish=(Button)findViewById(R.id.mic_finish);
txtMicAmplitudeMsg=(TextView)findViewById(R.id.mic_amplitude_msg);
txtMicTimeMsg=(TextView)findViewById(R.id.mic_time_msg);

btnMicRecord.setOnClickListener(this);
btnMicPlay.setOnClickListener(this);
btnMicFinish.setOnClickListener(this);

res=getResources();
threadAmplitude=newThread(newUpdateAmplitude());
threadTime=newThread(newUpdateTime());
}


//@Override
publicvoidonClick(Viewv){
switch(v.getId()){
caseR.id.mic_record:
if(mic_state==MIC_STATE_RECORD){//录音
btnMicRecord.setText(res.getString(R.string.mic_record_save_text));
mic_state=MIC_STATE_SAVE;
startRecorder();
}elseif(mic_state==MIC_STATE_SAVE){
btnMicRecord.setText(res.getString(R.string.mic_record_text));
btnMicRecord.setEnabled(false);
btnMicPlay.setEnabled(true);
mic_state=MIC_STATE_RECORD;
stopRecorder();
}
break;
caseR.id.mic_play:
openFile(recAudioFile);
btnMicRecord.setEnabled(true);
btnMicFinish.setEnabled(true);
break;
caseR.id.mic_finish:
newAlertDialog.Builder(MicActivity.this).setIcon(
R.drawable.icon).setTitle(res.getString(R.string.mic_title))
.setMessage(res.getString(R.string.mic_msg)).setPositiveButton(
res.getString(R.string.yes),dialogClick)
.setNegativeButton(res.getString(R.string.no),dialogClick).create().show();
break;
default:
break;
}
}

privateandroid.content.DialogInterface.OnClickListenerdialogClick=newandroid.content.DialogInterface.OnClickListener(){

//@Override
publicvoidonClick(DialogInterfacedialog,intwhich){
switch(which){
caseDialogInterface.BUTTON_POSITIVE:
result(true);
break;
caseDialogInterface.BUTTON_NEGATIVE:
result(false);
break;
default:
break;
}


}
};


privatevoidresult(booleanflag){
Intentintent=newIntent(MicActivity.this,MainActivity.class);
intent.putExtra(MIC_RESULT,flag);
setResult(REQUESTCODE_MIC_RESULT,intent);
finish();
}

privateclassUpdateAmplitudeimplementsRunnable{

//@Override
publicvoidrun(){
while(threadRun){
try{
Messagemsg=newMessage();
msg.what=mMediaRecorder.getMaxAmplitude();
amplitudeHandler.sendMessage(msg);
Thread.sleep(250);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}

privateHandleramplitudeHandler=newHandler(){
@Override
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Stringtext=String.format(res.getString(R.string.mic_status_amplitude),String.valueOf(msg.what));
txtMicAmplitudeMsg.setText(text);
}
};

privateclassUpdateTimeimplementsRunnable{
//@Override
publicvoidrun(){
while(threadRun){
try{
Thread.sleep(1000);
time++;
timeHandler.sendEmptyMessage(time);
}catch(InterruptedExceptione){
e.printStackTrace();
}

}
}
}

privateHandlertimeHandler=newHandler(){
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
Stringtext=String.format(res.getString(R.string.mic_status_time),String.valueOf(msg.what));
txtMicTimeMsg.setText(text);
};
};

privatevoidstartRecorder(){
mMediaRecorder=newMediaRecorder();
recAudioFile=newFile("/mnt/flash","new.amr");
if(recAudioFile.exists()){
recAudioFile.delete();
}
mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);//设置录音来源
mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAULT);
mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
mMediaRecorder.setOutputFile(recAudioFile.getAbsolutePath());

try{
mMediaRecorder.prepare();
}catch(IllegalStateExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
mMediaRecorder.start();
threadRun=true;
threadAmplitude.start();
threadTime.start();
}

privatevoidstopRecorder(){
time=0;
threadRun=false;
if(recAudioFile!=null){
mMediaRecorder.stop();
mMediaRecorder.release();
}
}

/*打开播放录音文件的程序*/
privatevoidopenFile(Filef){
Intentintent=newIntent();
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setAction(android.content.Intent.ACTION_VIEW);
Stringtype=getMIMEType(f);
intent.setDataAndType(Uri.fromFile(f),type);
startActivity(intent);
}

privateStringgetMIMEType(Filef){
Stringend=f.getName().substring(f.getName().lastIndexOf(".")+1,
f.getName().length()).toLowerCase();
Stringtype="";
if(end.equals("mp3")||end.equals("aac")||end.equals("aac")
||end.equals("amr")||end.equals("mpeg")||end.equals("mp4")){
type="audio";
}elseif(end.equals("jpg")||end.equals("gif")||end.equals("png")
||end.equals("jpeg")){
type="image";
}else{
type="*";
}
type+="/*";
returntype;
}

}

12、重力感应

publicclassMySensorEventListenerimplementsSensorEventListener{

privatebooleanisPass;

privateSaveMessagesaveMessage;

publicMySensorEventListener(Contextcontext){
saveMessage=newSaveMessage(context);
}

//@Override
publicvoidonAccuracyChanged(Sensorsensor,intaccuracy){
}

//@Override
publicvoidonSensorChanged(SensorEventevent){
if(event.sensor.getType()==Sensor.TYPE_ORIENTATION){
//得到方向的值
floatx=event.values[SensorManager.DATA_X];
floaty=event.values[SensorManager.DATA_Y];
floatz=event.values[SensorManager.DATA_Z];
isPass=x!=0||y!=0||z!=0;
System.out.println("Orientation-Seneor"+(isPass?"ok!"+"x="+x+"y="+y+"z="+z:"error!"));
saveMessage.setMessage(MSG_SENEOR,"Orientation-Seneor"+(isPass?"ok!"+"x="+x+"y="+y+"z="+z:"error!"));
}elseif(event.sensor.getType()==Sensor.TYPE_ACCELEROMETER){
//得到加速度的值
floatx=event.values[SensorManager.DATA_X];
floaty=event.values[SensorManager.DATA_Y];
floatz=event.values[SensorManager.DATA_Z];
isPass=x!=0||y!=0||z!=0;
System.out.println("Accelerometer-Seneor"+(isPass?"ok!"+"x="+x+"y="+y+"z="+z:"error!"));
saveMessage.setMessage(MSG_SENEOR,"Accelerometer-Seneor"+(isPass?"ok!"+"x="+x+"y="+y+"z="+z:"error!"));
}
}

}

评论

1 楼 zy_zhangyuan88 2012-07-16  

//preview-size-values=1280x720,800x480,768x432,720x480,640x480,576x432,480x320,400x240,384x288,352x288,320x240,272x272,240x240,240x160,176x144,160x120
                //picture-size-values=2592x1952,2592x1456,2592x1936,2592x1728,2592x1552,2048x1536,2048x1360,2048x1216,2048x1152,1600x1200,1584x1056,1280x960,1280x848,1280x768,1280x720,1024x768,640x480,640x416,640x384,640x368,512x384,400x400,272x272