Android Service和Activity基于串口蓝牙模块的双向通信【第二篇】

最新推荐文章于 2024-07-11 12:03:54 发布
最新推荐文章于 2024-07-11 12:03:54 发布
阅读量2.1k 收藏 3
点赞数
分类专栏： Android学习笔记 文章标签： service android cmd command byte filter

一直以来都想利用手机来控制一些东西,比如电灯,电风扇等家电或者智能小车等.

驱动蓝牙模块可以在Activity中直接调用,也可以在多线程下直接使用,但这样会存在一个缺陷:当你按下手机的Home或者Back键的时候.程序退出了,下次你重新启动软件的时候又需要重新建立蓝牙的链接了.

     为了克服以上问题,我把蓝牙模块的调用放到Service里面使用.首先对Service说明下:(来源于http://tianrui-wang-163-com.iteye.com/blog/983099)

Service介绍
Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。

由于没有可视化界面，Service都是从其它程序组件中启动、停止和控制，这些组件包括其它的Service、Activity和Broadcast Receiver。如果你的应用程序正常且不间断的运行，而不直接依赖于用户输入，Service是你最佳的选择。

Service生命周期

服务常用生命周期回调方法如下：
onCreate() 该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，服务也只被创建一次。
onDestroy()该方法在服务被终止时调用。

Service对象不能自己启动，需要通过某个Activity、Service或者其他Context对象来启动。启动的方法有两种，Context.startService和Context.bindService()。两种方式的生命周期是不同的，具体如下所示。
Context.startService方式的生命周期：
启动时，startService –> onCreate() –> onStart()
停止时，stopService –> onDestroy()
Context.bindService方式的生命周期：
绑定时,bindService  -> onCreate() –> onBind()
解绑定时,unbindService –>onUnbind() –> onDestory()

Service实现
定义一个Service只需要如下两步：

第一步：继承Service类
public class SMSService extends Service { } 这里可以选择要实现的方法
第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:
<service android:name=".SMSService" ”></service>

 

好了,废话少说,下面从我的代码直接开始:

[java] view plain copy print ?
  1. package com.lxx;  
  2.   
  3.   
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.util.UUID;  
  8.   
  9. import android.app.Service;  
  10. import android.bluetooth.BluetoothAdapter;  
  11. import android.bluetooth.BluetoothDevice;  
  12. import android.bluetooth.BluetoothSocket;  
  13. import android.content.BroadcastReceiver;  
  14. import android.content.Context;  
  15. import android.content.Intent;  
  16. import android.content.IntentFilter;  
  17. import android.os.IBinder;  
  18. import android.util.Log;  
  19.   
  20.   
  21. public class MyService extends Service{  
  22.   
  23.     public boolean threadFlag = true;  
  24.     MyThread myThread;  
  25.     CommandReceiver cmdReceiver;//继承自BroadcastReceiver对象，用于得到Activity发送过来的命令   
  26.   
  27.     /**************service 命令*********/   
  28.     static final int CMD_STOP_SERVICE = 0x01;  
  29.     static final int CMD_SEND_DATA = 0x02;  
  30.     static final int CMD_SYSTEM_EXIT =0x03;  
  31.     static final int CMD_SHOW_TOAST =0x04;  
  32.       
  33.      private BluetoothAdapter mBluetoothAdapter = null;  
  34.      private BluetoothSocket btSocket = null;  
  35.      private OutputStream outStream = null;  
  36.      private InputStream  inStream = null;  
  37.      public  boolean bluetoothFlag  = true;  
  38.      private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");  
  39.      private static String address = "00:19:5D:EE:9B:8F"; // <==要连接的蓝牙设备MAC地址   
  40.       
  41.     @Override  
  42.     public IBinder onBind(Intent intent) {  
  43.         // TODO Auto-generated method stub   
  44.         return null;  
  45.     }  
  46.   
  47.     @Override  
  48.     public void onCreate() {  
  49.         // TODO Auto-generated method stub   
  50.         super.onCreate();  
  51.           
  52.     }  
  53.       
  54.       
  55.       
  56.     //前台Activity调用startService时，该方法自动执行   
  57.     @Override  
  58.     public int onStartCommand(Intent intent, int flags, int startId) {  
  59.         // TODO Auto-generated method stub   
  60.         cmdReceiver = new CommandReceiver();  
  61.         IntentFilter filter = new IntentFilter();//创建IntentFilter对象   
  62.         //注册一个广播，用于接收Activity传送过来的命令，控制Service的行为，如：发送数据，停止服务等   
  63.         filter.addAction("android.intent.action.cmd");  
  64.         //注册Broadcast Receiver   
  65.         registerReceiver(cmdReceiver, filter);  
  66.         doJob();//调用方法启动线程   
  67.         return super.onStartCommand(intent, flags, startId);  
  68.   
  69.     }  
  70.       
  71.       
  72.   
  73.     @Override  
  74.     public void onDestroy() {  
  75.         // TODO Auto-generated method stub   
  76.         super.onDestroy();  
  77.         this.unregisterReceiver(cmdReceiver);//取消注册的CommandReceiver   
  78.         threadFlag = false;  
  79.         boolean retry = true;  
  80.         while(retry){  
  81.             try{   
  82.                  myThread.join();  
  83.                  retry = false;  
  84.             }catch(Exception e){  
  85.                 e.printStackTrace();  
  86.             }  
  87.               
  88.         }  
  89.     }  
  90.       
  91.     public class MyThread extends Thread{          
  92.         @Override  
  93.         public void run() {  
  94.             // TODO Auto-generated method stub   
  95.             super.run();  
  96.             connectDevice();//连接蓝牙设备   
  97.          while(threadFlag){  
  98.              int value = readByte();              
  99.             if(value != -1){                  
  100.                 DisplayToast(value + "");         
  101.             }  
  102.               
  103.             try{  
  104.                 Thread.sleep(50);  
  105.             }catch(Exception e){  
  106.                 e.printStackTrace();  
  107.             }              
  108.          }  
  109.        }      
  110.     }  
  111.       
  112.     public void doJob(){      
  113.          mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();  
  114.         if (mBluetoothAdapter == null) {   
  115.             DisplayToast("蓝牙设备不可用，请打开蓝牙！");  
  116.             bluetoothFlag  = false;  
  117.             return;  
  118.         }  
  119.   
  120.         if (!mBluetoothAdapter.isEnabled()) {  
  121.             DisplayToast("请打开蓝牙并重新运行程序！");  
  122.             bluetoothFlag  = false;  
  123.             stopService();  
  124.             showToast("请打开蓝牙并重新运行程序！");  
  125.             return;  
  126.         }        
  127.         showToast("搜索到蓝牙设备!");        
  128.         threadFlag = true;    
  129.         myThread = new MyThread();  
  130.         myThread.start();  
  131.           
  132.     }  
  133.     public  void connectDevice(){   
  134.         DisplayToast("正在尝试连接蓝牙设备，请稍后····");  
  135.         BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);  
  136.         try {  
  137.            btSocket = device.createRfcommSocketToServiceRecord(MY_UUID);  
  138.         } catch (IOException e) {  
  139.             DisplayToast("套接字创建失败！");  
  140.             bluetoothFlag = false;  
  141.         }  
  142.         DisplayToast("成功连接蓝牙设备！");  
  143.         mBluetoothAdapter.cancelDiscovery();  
  144.         try {  
  145.                 btSocket.connect();  
  146.                 DisplayToast("连接成功建立，可以开始操控了!");  
  147.                 showToast("连接成功建立，可以开始操控了!");  
  148.                 bluetoothFlag = true;  
  149.         } catch (IOException e) {  
  150.                try {  
  151.                     btSocket.close();  
  152.                     bluetoothFlag = false;  
  153.                 } catch (IOException e2) {                          
  154.                    DisplayToast("连接没有建立，无法关闭套接字！");  
  155.                 }  
  156.         }     
  157.           
  158.         if(bluetoothFlag){  
  159.             try {  
  160.                 inStream = btSocket.getInputStream();  
  161.               } catch (IOException e) {  
  162.                   e.printStackTrace();  
  163.               } //绑定读接口   
  164.                 
  165.               try {  
  166.                     outStream = btSocket.getOutputStream();  
  167.                 } catch (IOException e) {  
  168.                     e.printStackTrace();  
  169.                 } //绑定写接口   
  170.               
  171.         }  
  172.     }    
  173.       
  174.     public void sendCmd(byte cmd, int value)//串口发送数据   
  175.     {     
  176.         if(!bluetoothFlag){  
  177.             return;  
  178.         }  
  179.         byte[] msgBuffer = new byte[5];                                   
  180.           msgBuffer[0] = cmd;  
  181.           msgBuffer[1] = (byte)(value >> 0  & 0xff);  
  182.           msgBuffer[2] = (byte)(value >> 8  & 0xff);  
  183.           msgBuffer[3] = (byte)(value >> 16 & 0xff);  
  184.           msgBuffer[4] = (byte)(value >> 24 & 0xff);  
  185.             
  186.           try {  
  187.             outStream.write(msgBuffer, 0, 5);  
  188.             outStream.flush();  
  189.           } catch (IOException e) {  
  190.               e.printStackTrace();  
  191.           }           
  192.     }    
  193.       
  194.     public int readByte(){//return -1 if no data   
  195.         int ret = -1;     
  196.         if(!bluetoothFlag){  
  197.             return ret;  
  198.         }  
  199.         try {  
  200.               ret = inStream.read();  
  201.             } catch (IOException e) {  
  202.               e.printStackTrace();  
  203.             }              
  204.         return ret;  
  205.     }  
  206.       
  207.     public void stopService(){//停止服务       
  208.         threadFlag = false;//停止线程   
  209.         stopSelf();//停止服务   
  210.     }  
  211.       
  212.     public void showToast(String str){//显示提示信息   
  213.         Intent intent = new Intent();  
  214.         intent.putExtra("cmd", CMD_SHOW_TOAST);  
  215.         intent.putExtra("str", str);  
  216.         intent.setAction("android.intent.action.lxx");  
  217.         sendBroadcast(intent);    
  218.     }  
  219.       
  220.     public void DisplayToast(String str)  
  221.     {  
  222.         Log.d("Season",str);      
  223.     }  
  224.       
  225.      //接收Activity传送过来的命令   
  226.     private class CommandReceiver extends BroadcastReceiver{  
  227.         @Override  
  228.         public void onReceive(Context context, Intent intent) {  
  229.             if(intent.getAction().equals("android.intent.action.cmd")){  
  230.                 int cmd = intent.getIntExtra("cmd", -1);//获取Extra信息                               
  231.                   if(cmd == CMD_STOP_SERVICE){  
  232.                       stopService();  
  233.                   }    
  234.                     
  235.                   if(cmd == CMD_SEND_DATA)  
  236.                   {  
  237.                      byte command = intent.getByteExtra("command", (byte) 0);  
  238.                      int value =  intent.getIntExtra("value", 0);  
  239.                       sendCmd(command,value);  
  240.                   }  
  241.                           
  242.             }     
  243.         }                          
  244.     }  
  245.   
  246.       
  247.       
  248. }  

 

主界面Activity只有一个按钮,就是通过Broadcast来想Service发送数据,Service收到数据进行命令等的解析,然后调用相应的函数,相当于直接调用了Service中的函数.因为Activity和Service是运行在不同的进程中的,两者不能进行直接的通讯,必须通过一个"桥梁"建立起联系才行.

[java] view plain copy print ?
  1. package com.lxx;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.BroadcastReceiver;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.IntentFilter;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.view.View;  
  11. import android.view.View.OnClickListener;  
  12. import android.widget.Button;  
  13. import android.widget.TextView;  
  14. import android.widget.Toast;  
  15.   
  16. public class BroadcastActivity extends Activity {  
  17.     /** Called when the activity is first created. */  
  18.   
  19.     TextView myTextView;  
  20.     Button sendButton;  
  21.     MyReceiver receiver;  
  22.     IBinder serviceBinder;  
  23.     MyService mService;  
  24.     Intent intent;  
  25.     int value = 0;  
  26.       
  27.     /**************service 命令*********/   
  28.     static final int CMD_STOP_SERVICE = 0x01;  
  29.     static final int CMD_SEND_DATA = 0x02;  
  30.     static final int CMD_SYSTEM_EXIT =0x03;  
  31.     static final int CMD_SHOW_TOAST =0x04;  
  32.       
  33.     @Override  
  34.     public void onCreate(Bundle savedInstanceState) {  
  35.         super.onCreate(savedInstanceState);  
  36.         setContentView(R.layout.main);  
  37.           
  38.         myTextView = (TextView)findViewById(R.id.myTextView);  
  39.         myTextView.setText("Season");    
  40.         sendButton = (Button)findViewById(R.id.sendButton);  
  41.         sendButton.setOnClickListener(new SendButtonClickListener());  
  42.                     
  43.         intent = new Intent(BroadcastActivity.this,MyService.class);  
  44.         startService(intent);  
  45.     }  
  46.       
  47.     
  48.     public class SendButtonClickListener implements OnClickListener{  
  49.   
  50.         @Override  
  51.         public void onClick(View v) {  
  52.             // TODO Auto-generated method stub   
  53.             byte command = 45;  
  54.             int value = 0x12345;  
  55.             sendCmd(command,value);  
  56.         }     
  57.     }  
  58.       
  59.     @Override  
  60.     protected void onDestroy() {  
  61.         // TODO Auto-generated method stub   
  62.         super.onDestroy();  
  63.           
  64.         if(receiver!=null){  
  65.             BroadcastActivity.this.unregisterReceiver(receiver);  
  66.         }  
  67.     }  
  68.   
  69.      
  70.   
  71.   
  72.     @Override  
  73.     protected void onResume() {  
  74.         // TODO Auto-generated method stub   
  75.         super.onResume();  
  76.         receiver = new MyReceiver();  
  77.         IntentFilter filter=new IntentFilter();  
  78.         filter.addAction("android.intent.action.lxx");  
  79.         BroadcastActivity.this.registerReceiver(receiver,filter);  
  80.     }  
  81.   
  82.     public void showToast(String str){//显示提示信息   
  83.         Toast.makeText(getApplicationContext(), str, Toast.LENGTH_SHORT).show();      
  84.     }  
  85.   
  86.   
  87.     public class MyReceiver extends BroadcastReceiver{  
  88.     @Override  
  89.     public void onReceive(Context context, Intent intent) {  
  90.         // TODO Auto-generated method stub   
  91.         if(intent.getAction().equals("android.intent.action.lxx")){  
  92.             Bundle bundle = intent.getExtras();  
  93.             int cmd = bundle.getInt("cmd");  
  94.               
  95.             if(cmd == CMD_SHOW_TOAST){  
  96.                 String str = bundle.getString("str");  
  97.                 showToast(str);  
  98.             }  
  99.               
  100.             else if(cmd == CMD_SYSTEM_EXIT){  
  101.                 System.exit(0);  
  102.             }  
  103.               
  104.         }  
  105.      }     
  106.    }  
  107.   
  108.     public void sendCmd(byte command, int value){  
  109.         Intent intent = new Intent();//创建Intent对象   
  110.         intent.setAction("android.intent.action.cmd");  
  111.         intent.putExtra("cmd", CMD_SEND_DATA);  
  112.         intent.putExtra("command", command);  
  113.         intent.putExtra("value", value);  
  114.         sendBroadcast(intent);//发送广播       
  115.     }  
  116.       
  117.    
  118. }  


以下主要对代码部分进行详细的说明:

1.为了方便Activity和Service简历起良好的通信关系,需要在各自发送的数据进行命令的解释,这些命令在两者之间是一致的,能够相互读懂对方发送过来的数据.

[java] view plain copy print ?
  1. /**************service 命令*********/   
  2.     static final int CMD_STOP_SERVICE = 0x01;//停止服务   
  3.     static final int CMD_SEND_DATA = 0x02;//发送数据   
  4.     static final int CMD_SYSTEM_EXIT =0x03;//退出程序   
  5.     static final int CMD_SHOW_TOAST =0x04;//界面上显示toast  


2.Service传送数据到Activity:

要接收Broadcast首先的有个Receiver:

[java] view plain copy print ?
  1. //接收Activity传送过来的命令   
  2.    private class CommandReceiver extends BroadcastReceiver{  
  3.        @Override  
  4.        public void onReceive(Context context, Intent intent) {  
  5.         if(intent.getAction().equals("android.intent.action.cmd")){  
  6.             int cmd = intent.getIntExtra("cmd", -1);//获取Extra信息                               
  7.                  if(cmd == CMD_STOP_SERVICE){  
  8.                   stopService();  
  9.                  }    
  10.                    
  11.                  if(cmd == CMD_SEND_DATA)  
  12.                  {  
  13.                  byte command = intent.getByteExtra("command", (byte) 0);  
  14.                  int value =  intent.getIntExtra("value", 0);  
  15.                   sendCmd(command,value);  
  16.                  }  
  17.                           
  18.         }     
  19.        }                          
  20.    }  

为了能够接收到数据,首先得把这个Receiver注册:

[java] view plain copy print ?
  1. public class MyReceiver extends BroadcastReceiver{  
  2.     @Override  
  3.     public void onReceive(Context context, Intent intent) {  
  4.         // TODO Auto-generated method stub   
  5.         if(intent.getAction().equals("android.intent.action.lxx")){  
  6.             Bundle bundle = intent.getExtras();  
  7.             int cmd = bundle.getInt("cmd");  
  8.               
  9.             if(cmd == CMD_SHOW_TOAST){  
  10.                 String str = bundle.getString("str");  
  11.                 showToast(str);  
  12.             }  
  13.               
  14.             else if(cmd == CMD_SYSTEM_EXIT){  
  15.                 System.exit(0);  
  16.             }  
  17.               
  18.         }  
  19.      }     
  20.    }  



 

其中doJob是启动一个线程,定时的去读取蓝牙串口的数据,然后根据里面的数据解析就可以实现不同的操作了,这个反过来就是外设直接控制手机了.因为这个线程是一直在后台运行着的,只要不结束Service,它就一直保持这与外设串口蓝牙模块的通讯.

[java] view plain copy print ?
  1. public class MyThread extends Thread{          
  2.         @Override  
  3.         public void run() {  
  4.             // TODO Auto-generated method stub   
  5.             super.run();  
  6.             connectDevice();//连接蓝牙设备   
  7.          while(threadFlag){  
  8.              int value = readByte();//从蓝牙模块读取一个字节的数据,解释命令用             
  9.             if(value != -1){                  
  10.                 DisplayToast(value + "");         
  11.             }  
  12.               
  13.             try{  
  14.                 Thread.sleep(50);  
  15.             }catch(Exception e){  
  16.                 e.printStackTrace();  
  17.             }              
  18.          }  
  19.        }      
  20.     }  

3.Activity传送数据到Service:

 Activity上有一个按钮,点击一下就可以发送数据到蓝牙串口模块,工作原理是这样的:界面上实现按钮的点击事件

[java] view plain copy print ?
  1. public class SendButtonClickListener implements OnClickListener{  
  2.   
  3.     @Override  
  4.     public void onClick(View v) {  
  5.         // TODO Auto-generated method stub   
  6.         byte command = 45;  
  7.         int value = 0x12345;  
  8.            sendCmd(command,value);  
  9.     }     
  10.    }  

这里的sendCmd是关键,里面通过建立起一个广播消息,Service里会负责接收他

[java] view plain copy print ?
  1. public void sendCmd(byte command, int value){  
  2.         Intent intent = new Intent();//创建Intent对象   
  3.         intent.setAction("android.intent.action.cmd");  
  4.         intent.putExtra("cmd", CMD_SEND_DATA);  
  5.         intent.putExtra("command", command);  
  6.         intent.putExtra("value", value);  
  7.         sendBroadcast(intent);//发送广播       
  8.     }  

Service中

[java] view plain copy print ?
  1. //前台Activity调用startService时，该方法自动执行   
  2.     @Override  
  3.     public int onStartCommand(Intent intent, int flags, int startId) {  
  4.         // TODO Auto-generated method stub   
  5.         cmdReceiver = new CommandReceiver();  
  6.         IntentFilter filter = new IntentFilter();//创建IntentFilter对象   
  7.         //注册一个广播，用于接收Activity传送过来的命令，控制Service的行为，如：发送数据，停止服务等   
  8.         filter.addAction("android.intent.action.cmd");  
  9.         //注册Broadcast Receiver   
  10.         registerReceiver(cmdReceiver, filter);  
  11.         doJob();//调用方法启动线程   
  12.         return super.onStartCommand(intent, flags, startId);  
  13.   
  14.     }  

通过以上步骤就可以建立起蓝牙模块发送数据到Activity,Activity也可以发送数据到蓝牙模块了;

本例子的源码:

http://download.csdn.net/source/3557026 

博文转自：http://blog.csdn.net/cen616899547/article/category/1133607


greatriver007
关注
专栏目录
Android Service和Activity基于串口蓝牙模块的双向通信
05-15
可以用手机通过蓝牙控制一些东西，比如电灯，电风扇之类的家电，或者其他的东西。
Android 通过基于Service的串口蓝牙双向通讯
08-29
Android 通过基于Service的串口蓝牙双向通讯,经过调试的
Android蓝牙串口通讯（基于service）
04-29
Android蓝牙操作：与蓝牙串口模块通信，或其他蓝牙设备通信。这个程序虽然不是很完善，但作为二次开发是不错的选择，是一个学习蓝牙串口很好的参考，里面有注释
Android之蓝牙驱动开发总结
chiyinming3849的博客
06-11 1983
一Bluetooth基本概念3 二AndroidBluetooth架构3 2.1Bluetooth架构图3 2.2Bluetooth代码层次结构3 三Bluetooth协议栈分析4 3.1蓝牙协议栈4 3.2Android与蓝牙协议栈的关系6 四Bluetooth之...
android自带的示例程序 BluetoothChat 变蓝牙串口助手
Android小子的博客笔记
07-17 4132
bbs_sn=5289768&bbs_page_no=1&search_mode=4&search_text=duxingkei&bbs_id=9999，突然想到通过我的安卓手机蓝牙串口配合蓝牙串口模块可以实现许多有意思的应用：手机蓝牙遥控汽车 手机蓝牙转红外遥控器甚至遥控家电。   在研究了网上的android蓝牙串口代码后发现其代码大部分内容与android系统自带的 示例程序 Bluetoo
基于安卓手机蓝牙控制的智能小车设计论文,带源程序
最新发布
runweipa的博客
07-11 801
基于安卓手机蓝牙控制的智能小车设计论文,带源程序
android将蓝牙与service,android – 将蓝牙连接实施到服务或应用程序类,而不会失去与设备的连接...
weixin_31523667的博客
05-29 834
您可以将所有蓝牙连接代码移动到服务类中.考虑将其用作路线图.public class BluetoothDataService extends Service {final int handlerState = 0; //used to identify handler messageHandler bluetoothIn;private Blueto...
安卓蓝牙服务端(从端、从设备)编程示例
fang0625的专栏
05-30 2555
在网上找了很多安卓蓝牙服务端(从设备)的编程示例，绝大部分都是客户端的示例，偶尔有一两个服务端的盒子，却也不完整，经过一系列折腾，总算是搞通了一个相对完整的例子，写出来给大家参考。
Android 之 Bluetooth 框架
北风
04-30 2088
Android 之 Bluetooth 框架 Bluetooth 框架结构图 在新的android 版本中， 将蓝牙功能从单一的由蓝牙service/apk 完成，变更为由多部分完成蓝牙功能，使得接口更加的统一。 新的改变点 层次接口上： 系统升级8.1之后，增加了HAL 层Service 实现，一改bluedroid 加载vendor 的架构 而是改为： libbluetooth HAL ---...
Android Usb（OTG）串口通信，Service 后台服务实现方式
MSONG93的博客
05-17 4385
库 里面有例子，但发现里面有两个比较大的问题，第一个就是 插入的时候要直接启动 主界面，哪怕在程序里面时候，也需要重新进入。这是一个支持 USB 转串口通信的 Android 库，可以连接到 FTDI、PL2303 等 USB 转串口芯片，并且提供了非常详细的文档和示例代码。这是一个非常流行的 Android 串口通信库，支持多种设备和多种波特率，并且提供了非常详细的文档和示例代码。通过Actitity 启动ConnectService即可！以上三个库都是开源的，可以在 GitHub 上获取源码和文档。
android intent 传递int参数,intent的getIntExtra步骤得不到值
weixin_39996096的博客
05-26 3879
intent的getIntExtra方法得不到值最近在学习APPwidget，我设置了APPwidget中的一个按钮发送一个广播，在广播的intent中putExtra("appWidgetId",appWidgetIds[i]);把当前的widget的ID传递过去，但在接收到的intent中却得不到该id，部分代码如下：publicclassMyAppWidgetProviderex...
AUTOSAR汽车电子嵌入式编程精讲300篇-基于 CAN 总线的车辆数据采集与远程监控系统研发（中）
getusushu的博客
10-27 795
面，在主界面点击头像可以进入登录界面，在登录界面点击注册跳转到注册界面，数据的唯一识别码，这就要求用户上传的数据带有身份信息，因此，注册登录模。即为冻结帧，通过本模块的开发，用户可以随时对车辆进行诊断，并查看到具体。改，为确保密码的一致性以及隐蔽性，密码输入采用暗文重复输入的方式。首次登录，用户名和密码输入栏为空，如果不是首次登录，用户名一栏将自动填。看用户上次登录时是否勾选了自动登录选项，在勾选的情况下，密码输入栏会自。本章对数据采集系统涉及到的开发设计进行研究，该系统涉及两方面的开发，
Android 手机对于Arduino蓝牙控制解决方案
hukejishu的博客
12-25 2554
​Android 系统是 Google 公司基于 Linux 内核开发的移动端操作系统,适用于智能手机智能手表平板电脑等设备，最新的版本为 7.1。Android系统具有免费开源的优势,任何企业与个人都可以查阅公开的 API 文档，并在自己开发的应用中通过调用Android 系统所提供的接口来控制手机上的各类硬件。Android 系统采用了典型的分层架构，其基本原理是将 Linux 内核和 C/C++运行库结合在一起，通过应用程序框架为开发者提供服务。
Android 蓝牙——系统服务（二）
小旭的专栏
01-17 1378
BluetoothManagerService 是 Android 操作系统中的一个系统服务，它负责管理设备的蓝牙功能。该服务提供了一组API，供应用程序与蓝牙功能进行交互，包括打开和关闭蓝牙、搜索和配对其他设备、建立蓝牙连接等操作。BluetoothManagerService 还负责管理蓝牙硬件的驱动程序和蓝牙协议栈的运行。通过这个服务，应用程序可以方便地与蓝牙设备进行通信和交互。
关于getIntExtra()的一些介绍
热门推荐
菜鸡笔记
12-23 2万+
方法内参数类型：getIntExtra(name, defaultValue) 该方法中的 defaultValue 表示name对应的putExtra中没有传入有效的int类型值 就将defaultValue的值作为默认值传入。 其中name作为发送方中putExtra(String,int)中所对应的String。 ...
android 使用服务读取串口数据实例
01-08
android 使用服务读取串口数据实例，读取的数据实时写到txt文本。串口读写的库的地址：https://code.google.com/p/android-serialport-api/。我的博客：http://blog.csdn.net/qq_16064871。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值