devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

获取系统服务getSystemService()的使用

作者：不正经 | 2024-05-18 15:50:37

赞

踩

getsystemservice

getSystemService()是Android的一个重要API，它允许开发者获取系统的各种服务。

1.WindowManager

(1)获取屏幕大小&&dp与px的转换

  1. WindowManager windowManager= (WindowManager) getSystemService(WINDOW_SERVICE);
  2.  
  3. DisplayMetrics displayMetrics=new DisplayMetrics();
  4.  
  5. windowManager.getDefaultDisplay().getMetrics(displayMetrics);
  6.  
  7. int widthPixels=displayMetrics.widthPixels;
  8. int heightPixels=displayMetrics.heightPixels;
  9.  
  10. //虚拟像素（dp）*屏幕密度（density)=实际像素（px)
  11. density=displayMetrics.density;

(2)添加悬浮窗

  1. WindowManager windowManager= (WindowManager) getSystemService(WINDOW_SERVICE);
  2.  
  3. View view= LayoutInflater.from(MainActivity.this).inflate(R.layout.testLayout,null,false);
  4.  
  5. WindowManager.LayoutParams layoutParams=new WindowManager.LayoutParams();
  6.  
  7. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
  8.     layoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
  9. //用于设置悬浮窗类型，即覆盖于所有应用之上且不受限于当前Activity
  10. } else {
  11.     layoutParams.type = WindowManager.LayoutParams.TYPE_PHONE;
  12. }
  13. layoutParams.format = PixelFormat.RGBA_8888;
  14.  
  15. layoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | 
  16. WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;//设置不可触碰（触碰后传递给下一次）|不获焦点（使周围空白处操作不受影响）
  17.  
  18. layoutParams.gravity = Gravity.LEFT | Gravity.TOP;
  19. layoutParams.screenOrientation= ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
  20. layoutParams.width=10;
  21. layoutParams.height=10;
  22. layoutParams.x=10;
  23. layoutParams.y=10;
  24.  
  25. windowManager.addView(view,layoutParams);

2.AudioManager

(1)获取最大音量(各类型)

(2)设置音量(各类型)

(3)选择声音类型（即使用/设置哪个类型音量）

  1. AudioManager audioManager = (AudioManager)getSystemService(AUDIO_SERVICE);
  2. int max=audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
  3. audioManager.setStreamVolume(AudioManager.STREAM_MUSIC,max,AudioManager.FLAG_PLAY_SOUND);  //AudioManager.FLAG_PLAY_SOUND（第三个参数）是一个标志，它指示在调整音量时是否播放声音效果，当前为调整时播放声音。

3.NotificationManager

(1)发送通知

  1. //获取通知管理者
  2. NotificationManager notificationManager= (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
  3.  
  4. //创建通知
  5. Notification notification;
  6.  
  7. //创建点击跳转
  8. //PendingIntent四个参数分别为 环境 请求码 执行的Intent 标志
  9. //标志建议使用PendingIntent.FLAG_IMMUTABLE创建不可变PendingIntent，只有在某些功能依赖于 PendingIntent 的可变性，才应使用PendingIntent.FLAG_MUTABLE
  10. Intent intent=new Intent(MainActivity.this,SecondActivity.class);
  11. PendingIntent pendingIntent=PendingIntent.getActivity(MainActivity.this,1,intent,PendingIntent.FLAG_IMMUTABLE);
  12.  
  13. //通知渠道是在API26以上使用，需判断
  14. if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.O){
  15.     
  16.     //创建通知渠道
  17.     NotificationChannel notificationChannel=new NotificationChannel("ChannelID","ChannelName", NotificationManager.IMPORTANCE_HIGH);
  18.     //向通知管理器中创建通知渠道
  19.     notificationManager.createNotificationChannel(notificationChannel);
  20.     
  21.     //设置通知
  22.     notification= new Notification.Builder(MainActivity.this)
  23.             .setChannelId("ChannelID") //渠道ID 要与渠道对应
  24.             .setAutoCancel(false) //设置点击后是否清除通知
  25.             .setContentTitle("标题")
  26.             .setContentText("你好")
  27.             .setSmallIcon(R.drawable.icon) //状态栏中小图标
  28.             
  29.             .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.drawable.icon)) //下拉显示的大图标-从res中获取资源并生成位图
  30.             .setWhen(System.currentTimeMillis()) //设置发送时间-当前时间
  31.             .setContentIntent(pendingIntent) //设置等待Intent(点击通知后执行，可不写)
  32.             .build();
  33.  
  34. }else {
  35.     
  36.     //设置通知
  37.     notification= new Notification.Builder(MainActivity.this)
  38.             .setAutoCancel(false)
  39.             .setContentTitle("标题")
  40.             .setContentText("你好")
  41.             .setSmallIcon(R.drawable.icon) //状态栏中小图标
  42.  
  43.             .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.drawable.icon)) //下拉显示的大图标-从res中获取资源并生成位图
  44.             .setWhen(System.currentTimeMillis()) //设置发送时间-当前时间
  45.             .setContentIntent(pendingIntent) //设置等待Intent(点击通知后执行，可不写)
  46.             .build();
  47.  
  48. }
  49.  
  50. //发送通知；参数为 通知的ID、通知
  51. notificationManager.notify(1,notification);
  52.  
  53. //根据通知ID删除通知
  54. notificationManager.cancel(1);
  55. //删除全部通知
  56. notificationManager.cancelAll();

4.Vibrator

(1) 振动器振动

  1. //获取系统服务-振动器
  2. Vibrator vibrator= (Vibrator) getSystemService(VIBRATOR_SERVICE);
  3.  
  4. //判断是否有振动器
  5. if(vibrator.hasVibrator()){
  6.  
  7.     //振动（参数为振动毫秒数-long型）
  8.     vibrator.vibrate(1000);
  9.  
  10.     //振动（参数为振动频率，循环次数；循环次数为-1时表示不循环）
  11.     //振动频率为 静止->振动->静止->振动->... ...的毫秒数
  12.     vibrator.vibrate(new long[]{0,2000,2000,4000},-1)；
  13.  
  14. }
  15.  
  16.         ... ...
  17.  
  18. //关闭或停止振动器
  19. vibrator.cancel();

5.AlarmManager 闹钟管理者

(1) 定时执行PendingIntent（如发送广播），App关闭依然执行

  1. //创建Intent意图，用于发送广播
  2. Intent intent=new Intent().setAction("MyTestBroadcast");
  3. //根据Intent意图创建PendingIntent等待意图
  4. PendingIntent pendingIntent=PendingIntent.getBroadcast(MainActivity.this,2333,intent,PendingIntent.FLAG_IMMUTABLE);
  5.  
  6. //获取执行时间
  7. //创建Calendar
  8. Calendar calendar=Calendar.getInstance();
  9. //将时间设置为当前时间
  10. calendar.setTimeInMillis(System.currentTimeMillis());
  11. //增加时间
  12. calendar.add(Calendar.MILLISECOND,7);
  13. //获取最终时间
  14. long time=calendar.getTimeInMillis();
  15.  
  16. //创建Alarm闹钟
  17. AlarmManager alarmManager= (AlarmManager) getSystemService(ALARM_SERVICE);
  18. //设置闹钟
  19. alarmManager.set(AlarmManager.RTC_WAKEUP,time,pendingIntent);

6.InputMethodManager输入法管理者

(1) 软键盘展开

  1. //方法1 使用InputMethodManager收起键盘
  2.  
  3. //编辑视图获取焦点
  4. editText.requestFocus(); 
  5. //展开软键盘
  6. InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
  7. imm.showSoftInput(editText,InputMethodManager.SHOW_IMPLICIT);
  8. //在上述代码中，editText是你想要显示键盘的EditText控件的引用。showSoftInput方法的第一个参数是你想要显示键盘的View，第二个参数是一个标志，通常为InputMethodManager.SHOW_IMPLICIT，表示如果没有焦点，也会显示键盘。
  9. //展开键盘前需要让编辑器获取焦点，如果展开后再获取焦点，可能会获取焦点失败。
  10.  
  11.  
  12. //方法2 设置软键盘状态
  13.  
  14. //编辑视图获取焦点
  15. editText.requestFocus(); 
  16. //展开软键盘
  17. InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
  18. imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
  19. //在上述代码中，toggleSoftInput方法的第一个参数是InputMethodManager.SHOW_FORCED，表示强制显示键盘，第二个参数通常为0。
  20.  
  21.  
  22. //方法3 失去焦点自动收起
  23.  
  24. //获取焦点时，通常会自动触发软键盘展开。
  25. editText.clearFocus();

(2) 软键盘收起

  1. //方法1 使用InputMethodManager收起键盘
  2.  
  3. InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
  4. imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
  5. //在上面的代码中，editText是你的EditText控件的引用。hideSoftInputFromWindow方法接受两个参数：第一个参数是与输入法交互的窗口标记，通常是EditText的getWindowToken()方法提供的，第二个参数是一个标志，通常为0。
  6.  
  7.  
  8. //方法2 设置软键盘状态
  9.  
  10. InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
  11. imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
  12. //上述代码中的toggleSoftInput方法会切换软键盘的状态。第一个参数指定了软键盘的显示状态，InputMethodManager.HIDE_IMPLICIT_ONLY表示只在当前焦点不是EditText时才隐藏软键盘。第二个参数同样是一个标志，通常为0。
  13.  
  14.  
  15. //方法3 失去焦点自动收起
  16.  
  17. //失去焦点时，通常会自动触发软键盘收起。
  18. editText.clearFocus();

7.CameraManager

(1) 启动Camera2

Camera2的使用

(2) 打开、关闭手电筒

单纯的开启手电筒我们可以使用CameraManager的.setTorchMode()方法。

cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE)获取该相机特征是否可获取闪光灯。

  1. CameraManager cameraManager= (CameraManager) getSystemService(CAMERA_SERVICE);
  2. String cameraIdList[]=cameraManager.getCameraIdList();
  3. String cameraId = null;
  4. for(int i=0;i<cameraIdList.length;i++){
  5.     CameraCharacteristics cameraCharacteristics=cameraManager.getCameraCharacteristics(cameraIdList[i]);
  6.     //可获取闪光灯&&朝向为后置
  7.     if(cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE)&&
  8.                         cameraCharacteristics.get(CameraCharacteristics.LENS_FACING)==CameraCharacteristics.LENS_FACING_BACK){
  9.         cameraId=cameraIdList[i];
  10.         break;
  11.     }
  12. }
  13. //打开手电筒
  14. cameraManager.setTorchMode(cameraId,true);
  15. //关闭手电筒
  16. cameraManager.setTorchMode(cameraId,false);

8. SensorManager 传感器管理者

(1) 操作传感器（注册传感器监听）

  1. //传感器管理者
  2. SensorManager sensorManager= (SensorManager) view.getContext().getSystemService(Context.SENSOR_SERVICE);
  3. //传感器
  4. Sensor sensor=sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
  5. if(sensor!=null){
  6.     //传感器不为空
  7.     sensorManager.registerListener(new SensorEventListener() {
  8.         public void onSensorChanged(SensorEvent sensorEvent) {
  9.             // 数值变化
  10.             // 光强度发生变化时的处理逻辑
  11.             float lightIntensity = sensorEvent.values[0];
  12.         }
  13.         public void onAccuracyChanged(Sensor sensor, int i) {
  14.             // 传感器精度发生变化时的回调方法
  15.         }
  16.     }, sensor, SensorManager.SENSOR_DELAY_NORMAL);
  17. }

9. JobScheduler

获取JobScheduler调度JobInfo（启动JobSevice）

创建一个继承JobService类的子类，并实现其中的onStartJob()方法和onStopJob()方法。

onStartJob()方法中重写后台任务逻辑，该方法返回true表示作业在这里执行，返回false表示作业执行完毕。

onStopJob()方法中重写作业取消逻辑，该方法返回true表示希望作业被重新调度，返回false表示作业无需再次执行。

想中止任务，可使用JobFinished(JobParameters jp,boolean b)方法并在onStartJob()返回false，该方法第一个参数是当前作业的参数（用于告知系统哪个作业结束了），第二个参数是是否重新调度作业。

  1. public class MyJobService extends JobService {
  2.     @Override
  3.     public boolean onStartJob(JobParameters params) {
  4.         // 在这里执行后台任务逻辑
  5.  
  6.         // 返回 true 表示作业在这里执行，返回 false 表示作业已经执行完毕
  7.         return true;
  8.  
  9.         // 停止JobService可使用 jobFinished(params, false)并返回false
  10.         // jobFinished(params, false);
  11.         // return false;
  12.     }
  13.  
  14.     @Override
  15.     public boolean onStopJob(JobParameters params) {
  16.         // 在这里处理作业被取消的逻辑
  17.  
  18.         // 返回 true 表示希望作业被重新调度
  19.         return false;
  20.     }
  21. }

请注意，一定要包含 android:permission="android.permission.BIND_JOB_SERVICE" 。 

  1. <application
  2.         ... ... >
  3.         ... ...
  4.  
  5.         <service android:name=".MyJobService"
  6.             android:permission="android.permission.BIND_JOB_SERVICE"
  7.             android:exported="false"/>
  8.  
  9. </application>

(1) 准备JobInfo(作业信息)
使用JobInfo.Builder创建，可在其中设置网络条件、充电条件、作业执行周期(单位毫秒)、设备重启自动重新调度作业。

(2) 获取JobScheduler(作业调度)
使用getSystemService(JOB_SCHEDULER_SERVICE)获取JobSecheduler。

(3) JobScheduler调度JobInfo
使用schedule()方法调度JobInfo，启动JobService。

  1. JobInfo jobInfo = new JobInfo.Builder(JOB_ID, new ComponentName(this, MyJobService.class))
  2.         .setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED)  // 设置网络条件
  3.         .setRequiresCharging(true)  // 设置充电条件
  4.         .setPeriodic(15 * 60 * 1000)  // 设置作业的周期性执行，单位是毫秒
  5.         //.setPersisted(true)  // 设备重启，作业重新调度
  6.         .build();
  7.  
  8. JobScheduler jobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
  9. jobScheduler.schedule(jobInfo);

10.LocationManager定位管理器

(1) 获取定位状态

  1. //获取定位功能状态
  2. public static boolean getGPSState(Context context){
  3.     //获取定位管理器
  4.     LocationManager locationManager= (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
  5.     return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
  6. }

(2) 获取最佳定位提供者

(3) 设置定位变化监听器(及定位状态监听器)

  1. //获取权限
  2. int i=ActivityCompat.checkSelfPermission(MainActivity.this,"android.permission.ACCESS_FINE_LOCATION");
  3. if(i!= PackageManager.PERMISSION_GRANTED){
  4.     //无权限，请求权限
  5.     requestPermissions(new String[]{"android.permission.ACCESS_FINE_LOCATION"},1234);
  6. }
  7.  
  8. //创建定位条件器
  9. Criteria criteria=new Criteria();
  10. //设置精度，Criteria.ACCURACY_FINE表示精确，Criteria.ACCURACY_COARSE表示粗略
  11. criteria.setAccuracy(Criteria.ACCURACY_FINE);
  12. //设置是否需要海拔信息
  13. criteria.setAltitudeRequired(true);
  14. //设置是否需要方位信息
  15. criteria.setBearingRequired(true);
  16. //设置是否允许运营商扣费
  17. criteria.setCostAllowed(true);
  18. //设置对电源的需求
  19. criteria.setPowerRequirement(Criteria.POWER_LOW);
  20.  
  21. //获取定位管理者
  22. LocationManager locationManager= (LocationManager) getSystemService(LOCATION_SERVICE);
  23. //获取最佳定位提供者；第二个参数表示是否只取可用的内容提供者
  24. String locationProvider=locationManager.getBestProvider(criteria,true);
  25.  
  26. //判断定位提供者是否有效
  27. if(locationProvider!=null){
  28.  
  29.     //设置定位监听器；第一个参数为定位提供者，第二个参数为最小更新时间，第三个参数为最小更新距离，第四个参数为定位监听器
  30.     locationManager.requestLocationUpdates(locationProvider, 300, 0, new LocationListener() {
  31.         //定位发生变化时触发
  32.         public void onLocationChanged(@NonNull Location location) {
  33.             //解析Location对象中的数据
  34.         }
  35.  
  36.         //定位提供者不可用时触发
  37.         public void onProviderDisabled(@NonNull String provider) {}
  38.  
  39.         //定位提供者可用时触发
  40.         public void onProviderEnabled(@NonNull String provider) {}
  41.                 
  42.         //状态变更时触发
  43.         public void onStatusChanged(String provider, int status, Bundle extras) {}
  44.     });
  45.  
  46.     //获取最后的位置
  47.     Location location=locationManager.getLastKnownLocation(locationProvider);
  48.  
  49. }
  50. else{
  51.     //无有效定位提供者
  52. }

11.WiFiManager WiFi管理器

(1) 获取WiFi状态

(2) 设置WiFi状态

  1. //获取WiFi状态
  2. public static boolean getWiFiState(Context context){
  3.     WifiManager wifiManager= (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  4.     return wifiManager.isWifiEnabled();
  5. }
  6.     
  7. //设置WiFi状态
  8. public static void setWiFiState(Context context,boolean state){
  9.     WifiManager wifiManager= (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  10.     wifiManager.setWifiEnabled(state);
  11. }

12.ConnectivityManager 移动数据连接管理器

(1) 获取移动数据连接状态(反射调用)

(2) 设置移动数据连接状态(反射调用)

  1. //获取移动数据连接开关的状态
  2. public static boolean getMobileDataState(Context context){
  3.     //获取连接管理器
  4.     ConnectivityManager connectivityManager= (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
  5.     boolean isOpen=false;
  6.     try {
  7.         //该方法为隐藏方法，需要通过反射调用
  8.         String methodName="getMobileDataEnable";
  9.         Method method=connectivityManager.getClass().getMethod(methodName);
  10.         isOpen= (boolean) method.invoke(connectivityManager);
  11.     }catch (Exception e){
  12.         e.printStackTrace();
  13.     }
  14.         return isOpen;
  15. }
  16.  
  17. //设置移动数据连接开关的状态
  18. public static void setMobileDataState(Context context,boolean state){
  19.     //获取连接管理器
  20.     ConnectivityManager connectivityManager= (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
  21.     try{
  22.         //该方法为隐藏方法，需要通过反射调用
  23.         String methodName="setMobileDataEnable";
  24.         Method method=connectivityManager.getClass().getMethod(methodName);
  25.         method.invoke(connectivityManager,state);
  26.     }catch (Exception e){
  27.         e.printStackTrace();
  28.     }
  29. }

(3) 获取网络连接信息(是否有网络、网络状态、网络类型/子类型)

  1. //获取连接管理器
  2. ConnectivityManager connectivityManager= (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
  3.  
  4. //获取网络信息
  5. NetworkInfo networkInfo=connectivityManager.getActiveNetworkInfo();
  6. //判断是否有网络连接
  7. if(networkInfo==null){
  8.     //无网络
  9.     textView.setText("无网络");
  10.     return;
  11. }
  12.  
  13. //获取网络状态
  14. NetworkInfo.State networkState=networkInfo.getState();
  15. if(networkState!= NetworkInfo.State.CONNECTED){
  16.     //未连接
  17.     textView.setText("网络未连接");
  18.     return;
  19. }
  20.  
  21. //获取网络类型
  22. int networkType=networkInfo.getType();
  23. if(networkType==ConnectivityManager.TYPE_WIFI){
  24.     //WiFi
  25.     textView.setText("连接WiFi");
  26. }
  27. else if(networkType==ConnectivityManager.TYPE_MOBILE){
  28.     //移动数据
  29.     textView.setText("连接移动数据");
  30.     //获取网络子类型
  31.     int subtype=networkInfo.getSubtype();
  32.     if(subtype==TelephonyManager.NETWORK_TYPE_LTE|subtype==TelephonyManager.NETWORK_TYPE_IWLAN){
  33.         textView.setText("连接4G");
  34.     }
  35. }else {
  36.     //其他
  37.     textView.setText("连接其他网络");
  38. }

13.ConsumerIrManager消费者红外管理器

(1) 判断是否有红外发射器

(2) 发射红外信号

  1. //获取消费者红外管理器
  2. ConsumerIrManager consumerIrManager= (ConsumerIrManager) getSystemService(CONSUMER_IR_SERVICE);
  3. //判断是否有红外发射器
  4. if(consumerIrManager.hasIrEmitter()){
  5.     textView.setText("该设备有红外发射器");
  6. }
  7. else {
  8.     textView.setText("该设备无红外发射器");
  9. }
  10. //准备发射信息
  11. int pattern[]={
  12.     //开头两数字代表引导码
  13.     9000,4500,
  14.     //下面两行表示用户码
  15.     560,560,560,1680,560,560,560,560,560,560,560,560,560,560,560,560,
  16.     560,560,560,1680,560,560,560,1680,560,560,560,1680,560,560,560,1680,
  17.     //下面一行表示数据码
  18.     560,560,560,1680,560,560,560,560,560,560,560,1680,560,560,560,560,
  19.     //下面一行表示数据反码
  20.     560,1680,560,560,560,1680,560,1680,560,1680,560,560,560,1680,560,1680,
  21.     //末尾两个数字表示结束码
  22.     560,20000
  23. };
  24. //发射，普通家电红外频率一般为38kHz
  25. consumerIrManager.transmit(38000,pattern);

14.BluetoothManager蓝牙管理器

(1) 搜索蓝牙设备

  1. public class MainActivity extends AppCompatActivity {
  2.     private BluetoothAdapter bluetoothAdapter=null;
  3.     private Button button=null;
  4.     @SuppressLint("MissingInflatedId")
  5.     protected void onCreate(Bundle savedInstanceState) {
  6.         super.onCreate(savedInstanceState);
  7.         setContentView(R.layout.activity_main);
  8.         //获取控件
  9.         button=findViewById(R.id.button);
  10.  
  11.         //获取蓝牙适配器
  12.         //Android4.3以上支持BLE技术(即蓝牙4.0版本及以上)
  13.         if(Build.VERSION.SDK_INT>=Build.VERSION_CODES.JELLY_BEAN_MR2){
  14.             //如需要使用BLE特性，需使用蓝牙管理器获取蓝牙适配器
  15.             BluetoothManager bluetoothManager= (BluetoothManager) getSystemService(BLUETOOTH_SERVICE);
  16.             bluetoothAdapter=bluetoothManager.getAdapter();
  17.         }
  18.         else {
  19.             bluetoothAdapter=BluetoothAdapter.getDefaultAdapter();
  20.         }
  21.  
  22.         //判断是否拥有蓝牙功能
  23.         if(bluetoothAdapter!=null){
  24.             //该设备有蓝牙功能
  25.             openBluetooth();
  26.             //为按钮设置扫描监听器
  27.             button.setOnClickListener(new View.OnClickListener() {
  28.                 @SuppressLint("MissingPermission")
  29.                 public void onClick(View view) {
  30.                     //蓝牙适配器未在搜索中
  31.                     if(!bluetoothAdapter.isDiscovering()){
  32.                         //开始蓝牙搜索
  33.                         bluetoothAdapter.startDiscovery();
  34.                     }
  35.                     //定时停止蓝牙搜索
  36.                     new Thread(new Runnable() {
  37.                         public void run() {
  38.                             try {
  39.                                 Thread.sleep(5000);
  40.                             } catch (InterruptedException e) {
  41.                                 throw new RuntimeException(e);
  42.                             }
  43.                             //蓝牙适配器搜索中
  44.                             if(bluetoothAdapter.isDiscovering()){
  45.                                 //取消蓝牙搜索
  46.                                 bluetoothAdapter.cancelDiscovery();
  47.                             }
  48.                         }
  49.                     }).start();
  50.                 }
  51.             });
  52.         }
  53.         else {
  54.             //该设备无蓝牙功能
  55.         }
  56.  
  57.     }
  58.  
  59.     private int mRequestCode=123456;
  60.     /**
  61.      * 打开蓝牙
  62.      */
  63.     @SuppressLint("MissingPermission")
  64.     private void openBluetooth(){
  65.         //获取蓝牙状态
  66.         int bluetoothState=bluetoothAdapter.getState();
  67.         //蓝牙状态不为打开状态且不为正在打开状态
  68.         if(bluetoothState!=BluetoothAdapter.STATE_ON&&bluetoothState!=BluetoothAdapter.STATE_TURNING_ON){
  69.             //弹出是否允许扫描蓝牙界面
  70.             Intent intent=new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
  71.             startActivityForResult(intent,mRequestCode);
  72.         }
  73.     }
  74.  
  75.     @SuppressLint("MissingPermission")
  76.     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
  77.         super.onActivityResult(requestCode, resultCode, data);
  78.         //由蓝牙弹出窗返回
  79.         if(requestCode==mRequestCode){
  80.             if(resultCode==RESULT_OK){
  81.                 //蓝牙开启
  82.             }
  83.             else if(resultCode==RESULT_CANCELED) {
  84.                 //不允许蓝牙开启
  85.                 //弹出是否允许扫描蓝牙界面
  86.                 Intent intent=new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
  87.                 startActivityForResult(intent,mRequestCode);
  88.             }
  89.         }
  90.     }
  91.  
  92.     private MyReceiver myReceiver=null;
  93.     protected void onStart() {
  94.         super.onStart();
  95.         //创建过滤器
  96.         IntentFilter intentFilter=new IntentFilter();
  97.         //添加发现蓝牙设备活动
  98.         intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
  99.         //添加绑定状态改变活动
  100.         intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
  101.         //创建广播接收者对象
  102.         myReceiver=new MyReceiver();
  103.         //注册广播接收者
  104.         registerReceiver(myReceiver,intentFilter);
  105.     }
  106.  
  107.     protected void onStop() {
  108.         super.onStop();
  109.         //注销广播接收者
  110.         unregisterReceiver(myReceiver);
  111.     }
  1. public class MyReceiver extends BroadcastReceiver {
  2.     public void onReceive(Context context, Intent intent) {
  3.         //获取活动
  4.         String action=intent.getAction();
  5.         //发现蓝牙设备
  6.         if(action.equals(BluetoothDevice.ACTION_FOUND)){
  7.             //获取蓝牙设备
  8.             BluetoothDevice bluetoothDevice=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  9.         }
  10.         //绑定蓝牙状态改变
  11.         else if(action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)){
  12.             //获取蓝牙设备
  13.             BluetoothDevice bluetoothDevice=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
  14.             //获取绑定状态
  15.             int bondState=bluetoothDevice.getBondState();
  16.             //判断绑定状态
  17.             if(bondState==BluetoothDevice.BOND_BONDED){
  18.                 //已绑定
  19.             }
  20.             else if(bondState==BluetoothDevice.BOND_BONDING){
  21.                 //正在绑定
  22.             }
  23.             else if (bondState==BluetoothDevice.BOND_NONE) {
  24.                 //未绑定
  25.             }
  26.         }
  27.     }
  28. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/588989
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号