怎么用android获取bluetooth的信号强度

CAsyncSocket::OnReceivevirtual void OnReceive( int nErrorCode );ParametersnErrorCodeThe most recent error on a socket. The following error codes apply to the OnReceive member function: 0 The function executed successfully.WSAENETDOWN The Windows Sockets implementation detected that the network subsystem failed. RemarksCalled by the framework to notify this socket that there is data in the buffer that can be retrieved by calling the Receive member function. For more information, see the articleWindows Sockets: Socket Notifications in Visual C++ Programmer"s Guide.Examplevoid CMyAsyncSocket::OnReceive(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ static int i=0; i++; TCHAR buff[4096]; int nRead; nRead = Receive(buff, 4096); switch (nRead) { case 0: Close(); break; case SOCKET_ERROR: if (GetLastError() != WSAEWOULDBLOCK) { AfxMessageBox ("Error occurred"); Close(); } break; default: buff[nRead] = 0; //terminate the string CString szTemp(buff); m_strRecv += szTemp; // m_strRecv is a CString declared // in CMyAsyncSocket if (szTemp.CompareNoCase("bye") == 0 ) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}

这个不适合你，回去种地吧，~~(╯﹏╰)b

该函数是个需要重载的回调函数，当一个套接口已经准备好数据，并且可以由函数Receive()接收时，就可以调用此函数处理相应的消息。//下面的CMyAsyncSocket是CAsyncSocket类的派生类void CMyAsyncSocket::OnReceive(int nErrorCode){ static int i=0; i++; TCHAR buf[4096]; int nRead; nRead=Receive(buff,4096); switch(nRead) { case 0: Close(); break; case SOCKET_ERROR: if(GetLastError()!=WSAEWOULDBLOCK) { AfxMessageBox("Error occurred"); Close(); } break; default: buff[uRead]=0; CString szTemp(buff); m_strRecv+=szTemp;//m_strRecv是一个在CMyAsyncSocket中说明的字符串 if(szTemp.CompareNoCase("bye")==0) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}

起一个线程，每发一个广播后就sleep一分钟，如此循环。（或者接受系统的timechanged这个广播，这个广播好像一分钟发一次）。 Android 在发送广播时的方法 sendBroadcast（Intent）。 ①：Intent myIntent = new Intent();——【创建Intent对象】 ②：myIntent.setAction(String)——【设置一般的要执行的动作。参数：动作一个动作的名称，如ACTION_VIEW。应用程序的具体行动，应与供应商的包名作为前缀。】 ③：myIntent.putExtra(String,Object)——【广播中额外发送的数据，String为自定义key,Object表示多种数据类型】 ④：sendBroadcast(myIntent);——【发送广播】接收广播 Android在接收广播的方法是注册一个广播接收器 registerReceiver(MyReceiver,IntentFilter)。 ①：首先创建MyReceiver类（类名自定义） 继承 BroadcastReceiver类。——【创建广播接收器】 ②：在MyReceiver中重写public void onReceive(Context context, Intent intent)方法。这个方法在接收到广播后触发。——【重写处理方法】 ③：在Activity或者Service启动时 onCreate()、onStartCommand()等方法中实例化 MyReceiver类——【启动时实例化广播接收器】 ④：IntentFilter filter = new IntentFilter();——【创建IntentFilter对象 意图过滤器】 ⑤：filter.addAction(String);——【在过滤器中加入过滤条件，说明接收什么广播】 ⑥：registerReceiver(cmdReceiver, filter);——【注册广播，参数为（广播接收器，意图过滤器）】

代码好像是没什么问题，不过可以修改一下：public class Test extends Activity {@Overridepublic void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_OFF); registerReceiver(new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { System.out.println("Screen off..................."); } }, filter);}@Overrideprotected void onResume() { super.onResume(); System.out.println("onResume()");}@Overrideprotected void onDestroy() { super.onDestroy(); System.out.println("onDestroy()");}@Overrideprotected void onPause() { super.onPause(); System.out.println("onPause()");}

CAsyncSocket::OnReceiveCalled by the framework to notify this socket that there is data in the buffer that can be retrieved by calling the Receive member function.virtual void OnReceive( int nErrorCode );ParametersnErrorCode The most recent error on a socket. The following error codes apply to the OnReceive member function: 0 The function executed successfully. WSAENETDOWN The Windows Sockets implementation detected that the network subsystem failed. RemarksFor more information, see Windows Sockets: Socket Notifications.Examplevoid CMyAsyncSocket::OnReceive(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ static int i=0; i++; TCHAR buff[4096]; int nRead; nRead = Receive(buff, 4096); switch (nRead) { case 0: Close(); break; case SOCKET_ERROR: if (GetLastError() != WSAEWOULDBLOCK) { AfxMessageBox ("Error occurred"); Close(); } break; default: buff[nRead] = 0; //terminate the string CString szTemp(buff); m_strRecv += szTemp; // m_strRecv is a CString declared // in CMyAsyncSocket if (szTemp.CompareNoCase("bye") == 0 ) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}由以上可知， 这个参数是输出参数，如果函数成功接收数据，则该参数为0,否则输出为错误代码。能否讲一下什么是函数的输出参数?////////////////////////////////如果说这样的函数:void add(int & value){ value++;}int n = 5;add(n);n就变成6了。///////////////////////////////////////我看错了，呵呵，不是输出参数，因为函数原型是：virtual void OnReceive( int nErrorCode );nErrorCode是int，不是int &或者int *,所以不是输出参数。我查看了一下MSDN和CAsyncSocket的源码：/////////////////////////////////////////////////////////////////////////////// CAsyncSocket Overridable callbacksvoid CAsyncSocket::OnReceive(int /*nErrorCode*/){}这个函数什么都没做。我估计当框架接收到数据到来的消息后，就调用CAsyncSocket::OnReceive，而nErrorCode这个参数也是框架自己提供的，表示当前网络的状态。程序员不用管它，只须在自己的socket类中重载该函数，并在函数体内实现自己的接收代码就可以了。

重载CAsyncSocket::OnReceive添加代码char buf[10];int len=receive(buf,10);if(len>0){//你想扎存那就存那}

收到context，执行intent。

重载CAsyncSocket::OnReceive添加代码char buf[10];int len=receive(buf,10);if(len>0){//你想扎存那就存那}

1.你怎么确定run的代码没有执行的？2.tv_show是什么？

要拿到蓝牙信号指示值 rssi 分为两个步骤。 1.在oncreate方法里面增加 注册扫描广播 public void onCreate(Bundle savedInstanceState) { // 注册开始发现广播。 IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED); this.registerReceiver(mReceiver, filter); } 2.新建BroadcastReceiver广播对象，并实现里面的onreceive方法,在onreceive得到rssi（信号强度）。 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); //当设备开始扫描时。 if (BluetoothDevice.ACTION_FOUND.equals(action)) { //从Intent得到blueDevice对象 BluetoothDevice device = intent .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); if (device.getBondState() != BluetoothDevice.BOND_BONDED) { //信号强度。 short rssi = intent.getExtras().getShort( BluetoothDevice.EXTRA_RSSI); } } } };

context是上下文环境，一般是说明你这个在哪个包里面进行的活动还有加载资源值也要用到，你可以先记住有这么一个东西，intent用于页面跳转可指定包名显式跳转，也可以设定参数进行隐式跳转，多用用就知道了，建议自己手打不要光看书

2

BroadCastReceiver 简介 （末尾有源码）BroadCastReceiver 源码位于： framework/base/core/java/android.content.BroadcastReceiver.java广播接收者（ BroadcastReceiver ）用于接收广播 Intent ，广播 Intent 的发送是通过调用Context.sendBroadcast() 、 Context.sendOrderedBroadcast() 来实现的。通常一个广播 Intent 可以被订阅了此Intent 的多个广播接收者所接收。广播是一种广泛运用的在应用程序之间传输信息的机制 。而 BroadcastReceiver 是对发送出来的广播进行过滤接收并响应的一类组件；来自普通应用程序，如一个应用程序通知其他应用程序某些数据已经下载完毕。 BroadcastReceiver 自身并不实现图形用户界面，但是当它收到某个通知后， BroadcastReceiver 可以启动Activity 作为响应，或者通过 NotificationMananger 提醒用户，或者启动 Service 等等。BroadCastReceiver 的机制1. 机制在 Android 里面有各种各样的广播，比如电池的使用状态，电话的接收和短信的接收都会产生一个广播，应用程序开发者也可以监听这些广播并做出程序逻辑的处理。如图：2. 实现用接收短信举例：第一种方式 ：实现public class MyBroadcastReceiver extends BroadcastReceiver { // action 名称 String SMS_RECEIVED = "android.provider.Telephony.SMS_RECEIVED" ; public void onReceive(Context context, Intent intent) { if (intent.getAction().equals( SMS_RECEIVED )) { // 相关处理 : 地域变换、电量不足、来电来信； } }}系统注册：在 AndroidManifest.xml 中注册< receiver android:name = ".MyBroadcastReceiver" > < intent-filter android:priority = "1000" >< action android:name = " android.provider.Telephony.SMS_RECEIVED" /> </ intent-filter > </ receiver > 当然了需要权限 ：< uses-permission android:name = "android.permission.RECEIVE_SMS" />< uses-permission android:name = "android.permission.SEND_SMS" />第二种方式：// 广播接收者 - 广播的接收private BroadcastReceiver myBroadcastReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { // 相关处理，如收短信，监听电量变化信息 } };代码中注册：IntentFilter intentFilter = new IntentFilter( "android.provider.Telephony.SMS_RECEIVED " );registerReceiver( mBatteryInfoReceiver , intentFilter);3. 生命周期描述了 Android 中广播的生命周期，其次它并不像 Activity 一样复杂，运行原理很简单如下图：生命周期只有十秒左右，如果在 onReceive() 内做超过十秒内的事情，就会报错 。每次广播到来时 , 会重新创建 BroadcastReceiver 对象 , 并且调用 onReceive() 方法 , 执行完以后 , 该对象即被销毁 . 当 onReceive() 方法在 10 秒内没有执行完毕， Android 会认为该程序无响应 . 所以在BroadcastReceiver 里不能做一些比较耗时的操作 , 否侧会弹出 ANR(Application NoResponse) 的对话框 . 。

那你就是发了两次广播了喽，也有可能是生命周期的原因，可以在这方面找找原因

ActiveX控件用于Web的过程是将控件嵌入主页中，用户通过浏览器访问该主页时，将主页中的控件下载，并在用户机器上注册，以后就可在用户的浏览器上运行。控件下载一次后就驻留在用户本地机器上，下次再访问相同的主页时，可不再下载该控件，而是直接运行用户本地的控件。这里控件容器就是浏览器，用户不需要通过浏览器调用控件的属性或方法。因此，开发面向Web的ActiveX控件比开发桌面的控件还要简单些，所复杂的是如何将该控件很好地嵌入主页，使用户能正常浏览。

要把socket设为允许读才可以。

如果是OnReceive里，需要给intent加一个flag NEW_TASK那个。因为是在BroadcastReciever的上下文中。

虽然我眼拙没有看出什么不对劲，网上博文写的基本也如此，但也有点心得：从短信接收后系统发出广播，虽然是异步广播，但是实际上到你写的接收器接收到并处理之间可能会有一段较长的时间，可能是几秒；先检查接收器是否注册成功。

在Intent内可以设置一个字段作为应用的标示符，广播通过解析这个Intent内的标示符来匹配是哪个应用发送的。简单来说，你有3个应用能发送broadcast，用标示符0,1,2来分别标示，receiver接收到这个intent以后，解析标示符，然后就可以知道是哪个应用发送的broadcast了。

　　AlarmManager实质是一个全局的定时器，是Android中常用的一种系统级别的提示服务，在指定时间或周期性启动其它组件（包括Activity,Service,BroadcastReceiver）。　　概述：　　该类提供一种访问系统闹钟服务的方式，允许你去设置在将来的某个时间点去执行你的应用程序。当你的闹钟响起（时间到）时，在它上面注册的一个意图(Intent)将会被系统以广播发出，然后自动启动目标程序，如果它没有正在运行。注册的闹钟会被保留即使设备处于休眠中(如果闹钟在给定时间响起可以选择是否唤醒设备)。如果闹钟关闭或者重启，闹钟将被清除。　　只要广播的onReceive()方法正在执行，这闹钟管理者(AlarmManager)会持有一个CPU唤醒锁，这是为了保证手机不会休眠直到处理完该广播，一旦onReceive()返回，那么闹钟管理者将会释放唤醒锁。这意味着只要OnReceive()方法完成，你的手机可能在某些情况下进入休眠，如果你的闹钟广播接收者调用的是Context.startService()，那么手机有可能在被请求的服务执行之前进入休眠，为了防止这种情况，你的BroadcastReceiver和服务需要实现一个单独的唤醒锁策略以确保手机继续运行，直到服务可用。　　注：该类适用于你想让应用程序在将来某个指定时间点执行的情况，即使你的应用程序现在没有运行。对一般的时间操作，使用Handler是更容易和更有效率的。

程序中注册广播接收器，广播接收器中启动服务。

服务端有调用CSocket::Receive吗?

在Win32的库里用WSASocket创建SOCKETWSACreateEvent创建一个WSAEvent，使用WSAEventSelect注册感兴趣的事件（FD_READ|FD_CONNECT|FD_CLOSE）使用WSAWaitForMultipleEvents等待WSAEvent（可以另起一线程）使用WSAEnumNetworkEvents获取相关SOCKET上发生了什么，并对应进行处理（将原来的OnReceive(); OnConnect() ；OnClose()实现去掉MFC特有的代码）

创建一个activity管理类，打开新的activity时就将activity添加入栈，你可以看下开源中国手机客户端的源码，里面有实现，类文件我放上来。

很多时候我们都需要实时监听网络状态，当网络状态发生变化之后立即通知程序进行不同的操作。 监听广播的两种方式： （1）在AndroidManifest.xml配置文件中声明<receiver android:name=".NetworkConnectChangedReceiver" ><intent-filter><action android:name="android.net.conn.CONNECTIVITY_CHANGE" /><action android:name="android.net.wifi.WIFI_STATE_CHANGED" /><action android:name="android.net.wifi.STATE_CHANGE" /></intent-filter></receiver>1234567（2）在代码中注册IntentFilter filter = new IntentFilter(); filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);registerReceiver(new NetworkConnectChangedReceiver(), filter);12345接下来创建实时监听网络连接与断开状态变化的BroadcastReceiver对象，我们需要继承android.content.BroadcastReceiver，并实现其onReceive方法，下面我们就创建一个名为NetworkConnectChangedReceiver广播接收者，看一下具体的实现代码，由于代码写得很详细，就不一一解释了package com.per.networkconnectdome;import android.content.BroadcastReceiver;import android.content.Context;import android.content.Intent;import android.net.ConnectivityManager;import android.net.NetworkInfo;import android.net.wifi.WifiManager;import android.os.Parcelable;import android.util.Log;public class NetworkConnectChangedReceiver extends BroadcastReceiver {private String getConnectionType(int type) {String connType = ""; if (type == ConnectivityManager.TYPE_MOBILE) {connType = "3G网络数据";} else if (type == ConnectivityManager.TYPE_WIFI) {connType = "WIFI网络";} return connType;} @Overridepublic void onReceive(Context context, Intent intent) { if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {// 监听wifi的打开与关闭，与wifi的连接无关int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);Log.e("TAG", "wifiState:" + wifiState); switch (wifiState) { case WifiManager.WIFI_STATE_DISABLED: break; case WifiManager.WIFI_STATE_DISABLING: break;}} // 监听wifi的连接状态即是否连上了一个有效无线路由if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {Parcelable parcelableExtra = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); if (null != parcelableExtra) { // 获取联网状态的NetWorkInfo对象NetworkInfo networkInfo = (NetworkInfo) parcelableExtra; //获取的State对象则代表着连接成功与否等状态NetworkInfo.State state = networkInfo.getState(); //判断网络是否已经连接boolean isConnected = state == NetworkInfo.State.CONNECTED;Log.e("TAG", "isConnected:" + isConnected); if (isConnected) {} else {}}} // 监听网络连接，包括wifi和移动数据的打开和关闭,以及连接上可用的连接都会接到监听if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) { //获取联网状态的NetworkInfo对象NetworkInfo info = intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO); if (info != null) { //如果当前的网络连接成功并且网络连接可用if (NetworkInfo.State.CONNECTED == info.getState() && info.isAvailable()) { if (info.getType() == ConnectivityManager.TYPE_WIFI|| info.getType() == ConnectivityManager.TYPE_MOBILE) {Log.i("TAG", getConnectionType(info.getType()) + "连上");}} else {Log.i("TAG", getConnectionType(info.getType()) + "断开");}}}}}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071在onReceive方法里面，我们可以获取从广播而来的Intent中的数据，这包含很多有用的信息，其中 ConnectivityManager ： 主要管理和网络连接相关的操作 WifiManager： 管理和wifi相关的信息 TelephonyManager： 管理和手机、运营商等的相关信息 NetworkInfo类包含了对wifi和mobile两种网络模式连接的详细描述，通过getState()方法获取的State对象，代表着连接成功与否的状态。 最后记得添加权限：<uses-permission android:name="android.permission.access_wifi_state" /><uses-permission android:name="android.permission.access_network_state" />

代码如下:class WidgetProvider extends AppWidgetProvider { private static final String TAG="mythou_Widget_Tag"; // 没接收一次广播消息就调用一次，使用频繁 public void onReceive(Context context, Intent intent) { Log.d(TAG, "mythou--------->onReceive"); super.onReceive(context, intent); }

可以的啊 Intent 跳转就是啊

CliSock.Create(0,SOCK_STREAM,FD_CONNECT|FD_READ);

第一步：首先创建一个广播接收者,重构其抽象方法 onReceive(Context context, Intent intent)，在其中启动你想要启动的Service或app。 import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.util.Log; public class BootBroadcastReceiver extends BroadcastReceiver { //重写onReceive方法 @Override public void onReceive(Context context, Intent intent) { //后边的XXX.class就是要启动的服务 Intent service = new Intent(context,XXXclass); context.startService(service); Log.v("TAG", "开机自动服务自动启动....."); //启动应用，参数为需要自动启动的应用的包名 Intent intent = getPackageManager().getLaunchIntentForPackage(packageName); context.startActivity(intent ); } } 第二步：配置xml文件，在receiver接收这种添加intent-filter配置 <receiver android:name="BootBroadcastReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"></action> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </receiver> 第三步：添加权限 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

要拿到蓝牙信号指示值 rssi 分为两个步骤。 1.在oncreate方法里面增加 注册扫描广播 public void onCreate(Bundle savedInstanceState) { // 注册开始发现广播。 IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED); this.registerReceiver(mReceiver, filter); } 2.新建BroadcastReceiver广播对象，并实现里面的onreceive方法,在onreceive得到rssi（信号强度）。 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); //当设备开始扫描时。 if (BluetoothDevice.ACTION_FOUND.equals(action)) { //从Intent得到blueDevice对象 BluetoothDevice device = intent .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); if (device.getBondState() != BluetoothDevice.BOND_BONDED) { //信号强度。 short rssi = intent.getExtras().getShort( BluetoothDevice.EXTRA_RSSI);

android手机的充电情况监视/** * 先声明一个 IntentFilter 对象 */ private IntentFilter mIntentFilter; public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); mIntentFilter = new IntentFilter(); mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED); } protected void onResume() { super.onResume(); // 注册消息处理器 registerReceiver(mIntentReceiver, mIntentFilter); } //声明消息处理过程 private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); //要看看是不是我们要处理的消息 if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { //电池电量，数字 Log.d("Battery", "" + intent.getIntExtra("level", 0)); //电池最大容量 Log.d("Battery", "" + intent.getIntExtra("scale", 0)); //电池伏数 Log.d("Battery", "" + intent.getIntExtra("voltage", 0)); //电池温度 Log.d("Battery", "" + intent.getIntExtra("temperature", 0)); //电池状态，返回是一个数字 // BatteryManager.BATTERY_STATUS_CHARGING 表示是充电状态 // BatteryManager.BATTERY_STATUS_DISCHARGING 放电中 // BatteryManager.BATTERY_STATUS_NOT_CHARGING 未充电 // BatteryManager.BATTERY_STATUS_FULL 电池满 Log.d("Battery", "" + intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN)); //充电类型 BatteryManager.BATTERY_PLUGGED_AC 表示是充电器，不是这个值，表示是 USB Log.d("Battery", "" + intent.getIntExtra("plugged", 0)); //电池健康情况，返回也是一个数字 //BatteryManager.BATTERY_HEALTH_GOOD 良好 //BatteryManager.BATTERY_HEALTH_OVERHEAT 过热 //BatteryManager.BATTERY_HEALTH_DEAD 没电 //BatteryManager.BATTERY_HEALTH_OVER_VOLTAGE 过电压 //BatteryManager.BATTERY_HEALTH_UNSPECIFIED_FAILURE 未知错误 Log.d("Battery", "" + intent.getIntExtra("health", BatteryManager.BATTERY_HEALTH_UNKNOWN)); } } };

恩

[转]基于多线程的CSocket网络编程技术 收藏人：BuYuLibrary 2015-06-09 | 阅：1 转：20 MFC下使用CSocket或者CAsyncSocket进行Socket通信，CSocket继承自CAsyncSocket。这两者的区别在于，CSocket是同步的Socket，CAsyncSocket则是异步的。使用时，CSocket::Receive()和CSocket::Send()函数会阻塞当前线程，直至操作完成；而CAsyncSocket::Receive()和CAsyncSocket::Send()函数则不阻塞线程，函数立即返回。所以这两者在使用方式上有所不同。这里探讨一种使用CSocket配合CSocketFile、CArchive和CThread的多线程C/S模式。{网络通信主要有阻塞和非阻塞两种编程，前者是可靠连接通信（相当于一问须一答方式），后者只是传声筒，只管发出去，不管接收}CSocket通过CSocketFile由CArchive管理，可以得到类似iostream方式的流输入输出。这种方式的主要过程有：创建连接、接受数据、发送数据和断开连接。CSocket必须附加在与其一起工作的线程上，不能通过其他线程调用，所以主要通过在线程之间的传递消息和加锁实现线程的通信和同步。我们将分服务端（Server）和客户端（Client）分别讨论具体实现。{流文件方式通信，很方便对各数据类型读写操作，实现数据传输（JAVA基本传输就是这种模式）。CSocket必须在一个工作线程内实现，不能分开在不同的线程上}1.服务端 服务端有一个主界面，其类为CSCEServerDlg，继承自CDialog，它保存线程池和锁。为了简单起见，后面的类声明中大部分的成员变量访问控制都是public。{主应用程序线程，采用线程池（保存线程的列表）和锁进行同步运行控制，创建服务端的Socket(m_socketListen)监听客户连接。}声明类似如下： typedef list<CWinThread*> PThreadList;class CSCEServerDlg : public CDialog{ ...public: CCriticalSection m_csThrdList; // 线程池锁 PThreadList m_thrdList; // 线程池 int m_thrdIndex; // 线程计数器 CServerSocket m_socketListen // 监听CSocket …};和CSocket一起工作的线程类为CSerSocketThread，继承自CWinThread。这里使用CWinThread是因为它可以处理消息，这样便于线程间通信。重载了CWinThread::InitInstance()，在线程建立时做处理，具体实现在后面会有。声明如下：{采用可以处理消息传递的CWinThread线程类，把Socket工作绑定到该线程上去}class CSerSocketThread : public CWinThread{ DECLARE_DYNCREATE(CSerSocketThread)public: CSerSocketThread(void); ~CSerSocketThread(void); virtual int ExitInstance(); virtual BOOL InitInstance(); int m_thrdIndex; CSCEServerDlg* m_pSerDlg; // 主界面指针 SOCKET m_hSocket; // Socket 句柄 CServerSocket m_serverSocket; // 附加在这个线程上的CSocket CSocketFile* m_socketFile; // CSocketFile CArchive* m_arIn; // 输入CArchive CArchive* m_arOut; // 输出CArchive ...protected: DECLARE_MESSAGE_MAP() afx_msg void OnCustomMsg(WPARAM wParam,LPARAM lParam); void ReceiveData(); void SendData(const int WP, const CString& strMsg); ...};我们使用的具体的CSocket类是CServerSocket，继承自CSocket，重载了CSocket::OnAccept()函数和CSocket::OnReceive()函数。监听端口的CSocket在有Socket连接时会调用OnAccept()函数处理连接的建立。当已经连接的CSocket接收到数据时，则会调用OnReceive()函数，这里要注意的是，如果对方发送的数据较大，则有可能被分成多次发送，这种情况下会多次调用OnReceive()函数，后面会提高如何来处理这个问题。同样的道理，在发送数据时则会调用OnSend()函数，这里我们不会用到它。{服务端的Socket类主要是接收客户端的连接和接收客户端数据，当接收数据很大时，采用多次发送和接收方式（这是采用CSocketFile方式的好处，自动处理数据量传输大小）}CServerSocket的声明：class CServerSocket : public CSocket{public: CServerSocket(void); ~CServerSocket(void); virtual void OnAccept(int nErrorCode); virtual void OnReceive(int nErrorCode); CSCEServerDlg* m_pSerDlg; // 主界面指针 CWinThread* m_pThrd; // 该CSocket所在的线程 int m_thrdIndex; // 该CSocket所属线程的index，服务 Socket 为 -1};{除了Socket类绑定到工作线程上，Socket类中也包含其工作线程指针和主程序指针}OnAccept()函数的实现： void CServerSocket::OnAccept(int nErrorCode){ // TODO: 在此添加专用代码和/或调用基类 if(nErrorCode == 0) { // 创建一个连接Socket CServerSocket connectSocket; Accept(connectSocket); // connectSocket将和客户端连接 // 创建一个线程 CSerSocketThread* pThread = (CSerSocketThread*)AfxBeginThread( RUNTIME_CLASS(CSerSocketThread), THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED); {服务端Socket得到客服端连接，要创建一个连接的Socket与客户端连接通信（以后这个连接Socket与客户端绑定通信），创建一个线程来为连接Socket服务} // 添加到线程池中 m_pSerDlg->m_csThrdList.Lock(); // 加锁 m_pSerDlg->m_thrdList.push_back(pThread); m_pSerDlg->m_csThrdList.Unlock(); // 解锁 pThread->m_pSerDlg = m_pSerDlg; /* * 将CSocket交给新建的线程 * 这样这个CSocket将和新建的线程一起工作 * 注意现在是在界面线程中，因为是监听CSocket，是CServerDlg的成员变量 * 必须通过Detach()得到HANDLE之后在工作线程中重新Attach()才行 */ {如何把创建的Socket绑定到新建的工作线程中？现在用服务端Socket是在主应用程序中，用Detach、attach对Socket进行解绑、加绑，即把主线程中创建的连接Socket“离开”主线程，附加在工作线程上} pThread->m_hSocket = connectSocket.Detach(); // 线程编号，通过这个在通信时区别不同的客户端 {如何区分各工作线程（与客户端连接通信的Socket）？通过主程序（主线程）中的id标示} pThread->m_thrdIndex = m_pSerDlg->m_thrdIndex++; // 启动线程 pThread->ResumeThread(); } CSocket::OnAccept(nErrorCode);}当监听CSocket监听到有客户端接入，调用OnAccept()函数。通过Accept()函数将连接建立，之后建立一个新的线程，让连接的CSocket附加上去，将线程加入线程池，OnAccept()函数的主要工作就完成了。{各连接客户端的工作线程是在监听接受函数中创建}OnReceive()函数的实现： void CServerSocket::OnReceive(int nErrorCode){ // 通过自定义消息WM_THREAD和消息参数WP_RECV通知线程去读取数据 {由Socket绑定的线程通过消息去通知接收数据} m_pThrd->PostThreadMessage(WM_THREAD, WP_RECV, 0); //CSocket::OnReceive(nErrorCode);}当接收到数据时，CServerSocket就通知它附加的线程去接收数据，以便进一步处理。 下面看一下CSerSocketThread的几个处理的实现： InitInstance()函数，这个函数在新线程被构造出来后调用，用来完成一些自定义的新建过程： BOOL CSerSocketThread::InitInstance(){ // TODO: 在此添加专用代码和/或调用基类 if (!AfxSocketInit()) // 初始化CSocket必须调用的 { return CWinThread::InitInstance(); // 立刻退出 } {对服务端Socket附加的socket句柄} if(m_serverSocket.Attach(m_hSocket)) // 重新Attach之前传入的Socket { m_serverSocket.m_pThrd = this; // 告诉CSocket它所附加工作的线程 m_serverSocket.m_thrdIndex = m_thrdIndex; m_serverSocket.m_pSerDlg = m_pSerDlg; // 建立CSocketFile，将CSocket附加在上面 {把服务端Socket绑定到sockfile上，通信采用文件流方式进行} m_socketFile = new CSocketFile(&m_serverSocket); // 输入CArchive m_arIn = new CArchive(m_socketFile, CArchive::load); // 输出CArchive m_arOut = new CArchive(m_socketFile, CArchive::store); return TRUE; // 这样线程就不会立刻退出 } return CWinThread::InitInstance(); // 立刻退出}当新线程构造好了之后，InitInstance()函数被调用。将传入的CSocket的HANDLE重新Attach到线程自己的CSocket成员上，之后建立CSocketFile和两个CArchive用于输入输出，这里CSocketFile会互斥访问，输入和输出的CArchive无法并发操作它。{新线程构造调用InitInstance()，应是线程启动调用}之前的CServerSocket::OnReceive()中通过消息通知线程来接受数据，下面看具体的实现。 首先声明将WM_THREAD消息绑定到CSerSocketThread::OnCustomMsg()函数： BEGIN_MESSAGE_MAP(CSerSocketThread, CWinThread) ON_THREAD_MESSAGE(WM_THREAD, OnCustomMsg) ... END_MESSAGE_MAP() OnCustomMsg()函数的实现： void CSerSocketThread::OnCustomMsg(WPARAM wParam,LPARAM lParam) { switch(wParam) { case WP_RECV: // 接收数据 // 先把接收数据事件关掉 {关闭接受数据，避免后续接受数据不停传来，造成处理堵塞，这样读写一次完成} m_serverSocket.AsyncSelect(FD_CLOSE); *m_arIn >> ...; // 读取数据 // 重新打开接收数据事件 m_serverSocket.AsyncSelect(FD_READ|FD_CLOSE); ... break; ... } } 接收到的WM_THREAD消息包含WP_RECV的消息参数后，首先先关掉接收数据事件，这样就可以通过CArchive的operator >>一次读取完所有数据（根据自己定义的方式），读取完成后再打开接收数据事件。通过这个流程，每次数据发送就只会调用一次OnReceive()函数。这里要注意的是必须用CArchive的operator >>根据发送的情况正确的读取数据，最好都读取出来，否则下次读取时可能会出现错误。 {CArchive读写顺序要一致} 如果需要发送数据，则在CSerSocketThread线程中使用CArchive的operator <<发送所有支持operator <<的类型。注意的是必须是在这个工作线程中调用，CSocket是附加在线程上的，同样CArchive也只能在工作线程上使用，如果通过别的线程调用，就和系统的Socket表不对应了。另外还有注意的是输出完后需要显式调用CArchive::Flush()将数据发出。 {同一线程读写（接收和发射）} 主界面对CServerSocket的使用则比较简单，如下： m_socketListen.m_pSerDlg = this; if (!AfxSocketInit()) // Socket初始化 SomeMessageFunc("SOCKET 初始化失败！"); else if (!m_socketListen.Create(xxxx)) // 创建监听Socket SomeMessageFunc("监听 SOCKET 创建失败！"); else if (!m_socketListen.Listen()) // Socket监听 SomeMessageFunc("监听 SOCKET 监听失败！"); else SomeMessageFunc("监听建立"); 2.客户端 客户端部分的大部分处理和服务端是类似的，主要区别在于客户端主动连接服务端的监听端口。客户端首先建立工作线程，在线程重载的InitInstance()函数中建立到服务端的连接，成功就继续工作，失败就停止线程即可。之后当CSocket接收数据是，调用重载的OnReceive()函数，通过消息通知工作线程使用CArchive读取数据。发送时则由工作线程使用CArchive发送数据，显式调用CArchive::Flush()。 {客户端必须知道服务器端IP和工作端口，才能连接} 连接代码，依然是在： BOOL CCliSocketThread::InitInstance() { // TODO: 在此添加专用代码和/或调用基类 if (!AfxSocketInit()) // 一样的初始化，必须调用 { return CWinThread::InitInstance(); } if (!m_clientSocket.Create()) // 建立CSocket { SomeMessageFunc("Socket 创建失败"); return CWinThread::InitInstance(); } m_clientSocket.m_pCliDlg = m_pCliDlg; CString strIP(”xxx.xxx.xxx.xxx”); UINT port = xxxx; if (m_clientSocket.Connect(strIP, port)) // 连接服务端 { // 连接建立 m_clientSocket.m_thrd = this; m_socketFile = new CSocketFile(&m_clientSocket); m_arIn = new CArchive(m_socketFile, CArchive::load); m_arOut = new CArchive(m_socketFile, CArchive::store); SomeMessageFunc("连接成功"); return TRUE; // 线程继续工作 } return CWinThread::InitInstance(); }

第一步：首先创建一个广播接收者,重构其抽象方法 onReceive(Context context, Intent intent)，在其中启动你想要启动的Service或app。 import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.util.Log; public class BootBroadcastReceiver extends BroadcastReceiver { //重写onReceive方法 @Override public void onReceive(Context context, Intent intent) { //后边的XXX.class就是要启动的服务 Intent service = new Intent(context,XXXclass); context.startService(service); Log.v("TAG", "开机自动服务自动启动....."); //启动应用，参数为需要自动启动的应用的包名 Intent intent = getPackageManager().getLaunchIntentForPackage(packageName); context.startActivity(intent ); } } 第二步：配置xml文件，在receiver接收这种添加intent-filter配置 <receiver android:name="BootBroadcastReceiver"> <intent-filter> <action android:name="android.intent.action.BOOT_COMPLETED"></action> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </receiver> 第三步：添加权限 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

在Intent内可以设置一个字段作为应用的标示符，广播通过解析这个Intent内的标示符来匹配是哪个应用发送的。简单来说，你有3个应用能发送broadcast，用标示符0,1,2来分别标示，receiver接收到这个intent以后，解析标示符，然后就可以知道是哪个应用发送的broadcast了。

android中，不同进程之间传递信息要用到广播，可以有两种方式来实现。第一种方式：在Manifest.xml中注册广播，是一种比较推荐的方法，因为它不需要手动注销广播（如果广播未注销，程序退出时可能会出错）。具体实现在Manifest的application中添加：上面两个android:name分别是广播名和广播的动作（这里的动作是表示系统启动完成），如果要自己发送一个广播，在代码中为：Intent i = new Intent(“android.intent.action.BOOT_COMPLETED”);sendBroadcast(i);这样，广播就发出去了，然后是接收。接收可以新建一个类，继承至BroadcastReceiver，也可以建一个BroadcastReceiver的实例，然后得写onReceive方法，实现如下：protected BroadcastReceiver mEvtReceiver = new BroadcastReceiver() {@Overridepublic void onReceive(Context context, Intent intent) {String action = intent.getAction();if (action.equals(“android.intent.action.BOOT_COMPLETED”)) {//Do something}}};第二种方式，直接在代码中实现，但需要手动注册注销，实现如下：IntentFilter filter = new IntentFilter();filter.addAction(“android.intent.action.BOOT_COMPLETED”);registerReceiver(mEvtReceiver, filter); //这时注册了一个recevier ,名为mEvtReceiver，然后同样用上面的方法以重写onReceiver，最后在程序的onDestroy中要注销广播，实现如下：@Overridepublic void onDestroy() {super.onDestroy();unregisterReceiver(mPlayerEvtReceiver);}

在让TCPCLIENT,直接让 TcpClient1.BlockMode :=bmNonBlocking; TcpClient1.Active :=True;就和帮定的ip port连上了 不用再执行connect 可是在这种情况下 他仍旧不会自动响应onreceive事件，我的意思是说 我用vb写server在收到delphi下client发来的数据后立即向delphi返回数据 ，d下onreceive没反应！

　android上获取短信信息主要有BroadcastReceiver方式与数据库方式，要实时的话就BroadcastReceiver比较方便public class SMSReceiver extends BroadcastReceiver{ private String verifyCode=""; public static final String TAG = "SMSReceiver"; public static final String SMS_RECEIVED_ACTION = "android.provider.Telephony.SMS_RECEIVED"; @Override public void onReceive(Context context, Intent intent){ if (intent.getAction().equals(SMS_RECEIVED_ACTION)){ SmsMessage[] messages = getMessagesFromIntent(intent); for (SmsMessage message : messages){ Log.i(TAG, message.getOriginatingAddress() + " : " + message.getDisplayOriginatingAddress() + " : " + message.getDisplayMessageBody() + " : " + message.getTimestampMillis()); String smsContent=message.getDisplayMessageBody(); Log.i(TAG, smsContent); writeFile(smsContent);//将短信内容写入SD卡 } } } public final SmsMessage[] getMessagesFromIntent(Intent intent){ Object[] messages = (Object[]) intent.getSerializableExtra("pdus"); byte[][] pduObjs = new byte[messages.length][]; for (int i = 0; i < messages.length; i++) { pduObjs[i] = (byte[]) messages[i]; } byte[][] pdus = new byte[pduObjs.length][]; int pduCount = pdus.length; SmsMessage[] msgs = new SmsMessage[pduCount]; for (int i = 0; i < pduCount; i++) { pdus[i] = pduObjs[i]; msgs[i] = SmsMessage.createFromPdu(pdus[i]); } return msgs; } //将短信内容写到SD卡上的文件里，便于将文件pull到PC，这样可方便其它如WWW/WAP平台的自动化 @SuppressLint("SdCardPath") public void writeFile(String str){ String filePath="/mnt/sdcard/verifyCode.txt"; byte [] bytes = str.getBytes(); try{ File file=new File(filePath); file.createNewFile(); FileOutputStream fos=new FileOutputStream(file); fos.write(bytes); fos.close(); }catch(IOException e){ e.printStackTrace(); } }　　如此当有短信收到时就可以将短信内容写到SD卡中的文件里　　在另一个java类中写个读取文件内容的方法，并在写测试用例过程中，将得到的String按验证码的具体位置截取即可。public String read(String str) throws IOException{ File file=new File(str); FileInputStream fis=new FileInputStream(file); StringBuffer sb=new StringBuffer(); BufferedInputStream bis=new BufferedInputStream(fis); BufferedReader read = new BufferedReader (new InputStreamReader(bis)); int c=0; while ((c=read.read())!=-1) { sb.append((char) c); } read.close(); bis.close(); fis.close(); Log.i(TAG, sb.toString()); String verify=sb.toString(); return verify; } 　　最后需要在manifest中增加申明，且注册权限<receiver android:name="com.cplatform.surfdesktop.test.util.SMSReceiver"><intent-filter><action android:name="android.provider.Telephony.SMS_RECEIVED" /></intent-filter></receiver><uses-permission android:name="android.permission.RECEIVE_SMS"></uses-permission><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission><uses-permission android:name="android.permission.READ_SMS"/>　　测试过程中需要用到短信验证码时就可以实时获取了

Android Ethernet 有线网络监听import android.net.ConnectivityManager;ConnectivityManager conn = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo[] networkInfo = conn.getAllNetworkInfo(); if(networkInfo != null){ for(int i=0;i<networkInfo.length;i++){ if(networkInfo[i].getType() == ConnectivityManager.TYPE_ETHERNET){ //有线网络连接成功，更新UI } } }// 监听有线网络连接状态（插拔网线）private BroadcastReceiver mEthernetReceiver = new BroadcastReceiver(){ @Override public void onReceive(Context context, Intent intent) { if (intent.getAction().equals(ConnectivityManager.ACTION_ETHERNET_STATE_CHANGED)){ String state = intent.getStringExtra(ConnectivityManager.EXTRA_ETH_STATUS); if(state.equals(ConnectivityManager.EXTRA_ETH_CONNECT)){ //网线连接成功！ } else if(state.equals(ConnectivityManager.EXTRA_ETH_UNLINK)){ //网线断开！ } } } };IntentFilter filter = new IntentFilter(); filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); filter.addAction(ConnectivityManager.INET_CONDITION_ACTION); filter.addAction(ConnectivityManager.ACTION_ETHERNET_STATE_CHANGED); filter.addAction(ConnectivityManager.ACTION_ETHERNET_DONGLE_IN); filter.addAction(ConnectivityManager.ACTION_ETHERNET_DONGLE_OUT); registerReceiver(mEthernetReceiver, filter);添加权限：<uses-permission android:name="android.permission.INTERNET" /><uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

CAsyncSocket::OnConnectvirtual void OnConnect( int nErrorCode );ParametersnErrorCodeThe most recent error on a socket. The following error codes apply to the OnConnect member function: 0 The function executed successfully.WSAEADDRINUSE The specified address is already in use.WSAEADDRNOTAVAIL The specified address is not available from the local machine.WSAEAFNOSUPPORT Addresses in the specified family cannot be used with this socket.WSAECONNREFUSED The attempt to connect was forcefully rejected.WSAEDESTADDRREQ A destination address is required.WSAEFAULT The lpSockAddrLen argument is incorrect.WSAEINVAL The socket is already bound to an address.WSAEISCONN The socket is already connected.WSAEMFILE No more file descriptors are available.WSAENETUNREACH The network cannot be reached from this host at this time.WSAENOBUFS No buffer space is available. The socket cannot be connected.WSAENOTCONN The socket is not connected.WSAENOTSOCK The descriptor is a file, not a socket.WSAETIMEDOUT The attempt to connect timed out without establishing a connection. RemarksCalled by the framework to notify this connecting socket that its connection attempt is completed, whether successfully or in error.Important In CSocket, the OnConnect notification function is never called. For connections, you simply call Connect, which will return when the connection is completed (either successfully or in error). How connection notifications are handled is an MFC implementation detail. For more information, see the articleWindows Sockets: Socket Notifications in Visual C++ Programmer"s Guide.Examplevoid CMyAsyncSocket::OnConnect(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ if (0 != nErrorCode) { switch( nErrorCode ) { case WSAEADDRINUSE: AfxMessageBox("The specified address is already in use. "); break; case WSAEADDRNOTAVAIL: AfxMessageBox("The specified address is not available from the local machine. "); break; case WSAEAFNOSUPPORT: AfxMessageBox("Addresses in the specified family cannot be used with this socket. "); break; case WSAECONNREFUSED: AfxMessageBox("The attempt to connect was forcefully rejected. "); break; case WSAEDESTADDRREQ: AfxMessageBox("A destination address is required. "); break; case WSAEFAULT: AfxMessageBox("The lpSockAddrLen argument is incorrect. "); break; case WSAEINVAL: AfxMessageBox("The socket is already bound to an address. "); break; case WSAEISCONN: AfxMessageBox("The socket is already connected. "); break; case WSAEMFILE: AfxMessageBox("No more file descriptors are available. "); break; case WSAENETUNREACH: AfxMessageBox("The network cannot be reached from this host at this time. "); break; case WSAENOBUFS: AfxMessageBox("No buffer space is available. The socket cannot be connected. "); break; case WSAENOTCONN: AfxMessageBox("The socket is not connected. "); break; case WSAENOTSOCK: AfxMessageBox("The descriptor is a file, not a socket. "); break; case WSAETIMEDOUT: AfxMessageBox("The attempt to connect timed out without establishing a connection. "); break; default: TCHAR szError[256]; wsprintf(szError, "OnConnect error: %d", nErrorCode); AfxMessageBox(szError); break; } AfxMessageBox("Please close the application"); } CAsyncSocket::OnConnect(nErrorCode);}CAsyncSocket::OnReceivevirtual void OnReceive( int nErrorCode );ParametersnErrorCodeThe most recent error on a socket. The following error codes apply to the OnReceive member function: 0 The function executed successfully.WSAENETDOWN The Windows Sockets implementation detected that the network subsystem failed. RemarksCalled by the framework to notify this socket that there is data in the buffer that can be retrieved by calling the Receive member function. For more information, see the articleWindows Sockets: Socket Notifications in Visual C++ Programmer"s Guide.Examplevoid CMyAsyncSocket::OnReceive(int nErrorCode) // CMyAsyncSocket is // derived from CAsyncSocket{ static int i=0; i++; TCHAR buff[4096]; int nRead; nRead = Receive(buff, 4096); switch (nRead) { case 0: Close(); break; case SOCKET_ERROR: if (GetLastError() != WSAEWOULDBLOCK) { AfxMessageBox ("Error occurred"); Close(); } break; default: buff[nRead] = 0; //terminate the string CString szTemp(buff); m_strRecv += szTemp; // m_strRecv is a CString declared // in CMyAsyncSocket if (szTemp.CompareNoCase("bye") == 0 ) ShutDown(); } CAsyncSocket::OnReceive(nErrorCode);}

建议看经典入门书Visual C++_Turbo C串口通信编程实践循序渐进

这是明显的交叉编译问题，你在这里include了Sock1Dlg.h，然后再Sock1Dlg.h里面又inlcude了这个头文件。编译器处理总有个先后啊。修改方法如下：// Sock1Dlg.h : header file//#pragma once#include "afxwin.h"//#include "MySocket.h"class CMySocket;class CSock1Dlg : public CDialog{// Constructionpublic: CSock1Dlg(CWnd* pParent = NULL); // standard constructor// Dialog Data enum { IDD = IDD_SOCK1_DIALOG }; protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support// Implementationprotected: HICON m_hIcon; // Generated message map functions virtual BOOL OnInitDialog(); afx_msg void OnSysCommand(UINT nID, LPARAM lParam); afx_msg void OnPaint(); afx_msg HCURSOR OnQueryDragIcon(); DECLARE_MESSAGE_MAP()public: CMySocket *m_sConnectSock; CMySocket *m_sListenSock; CButton m_ctlConnect; CString m_strMessage; CString m_strName; int m_iPort; int m_iType; afx_msg void OnBnClickedBclose(); afx_msg void OnBnClickedBsend(); afx_msg void OnBnClickedConnect(); CListBox m_ctlSend; CListBox m_ctlRecvd; afx_msg void OnBnClickedRclient();public: void OnClose(); void OnReceive(); void OnAccept();};然后在cpp文件里面将对象调用改成指针调用，还有这两个对象在构造函数里面new出来。

另外，creditCard是堆栈上创建的实类，当它的生命周期（这里是if语句的作用域）中的结束后，newCard将会变成悬挂指针。

android 实现来电自动接听和自动挂断的方法：第一步：准备应用环境需要的系统包和aidl文件。 （1）在应用中创建包:android.telephony将android系统框架下的framework elephonyjavaandroid elephony目录中的NeighboringCellInfo.aidl文件复制到上面创建的包（android.telephony ）中；（2）在应用中创建包:com.android.internal.telephony将android系统框架下的framework elephonyjavacomandroidinternal elephony目录中的ITelephony.aidl文件复制到上面创建的包（com.android.internal.telephony ）中。 第二步：创建一个获取ITelephony的方法PhoneUtils.javapackage com.zhouzijing.android.demo;import java.lang.reflect.Method; import com.android.internal.telephony.ITelephony; import android.telephony.TelephonyManager;public class PhoneUtils {/*** 根据传入的TelephonyManager来取得系统的ITelephony实例.* @param telephony* @return 系统的ITelephony实例* @throws Exception*/public static ITelephony getITelephony(TelephonyManager telephony) throws Exception {Method getITelephonyMethod = telephony.getClass().getDeclaredMethod("getITelephony");getITelephonyMethod.setAccessible(true);//私有化函数也能使用return (ITelephony)getITelephonyMethod.invoke(telephony);} }第三步：创建电话广播拦截器MyPhoneBroadcastReceiver.javapackage com.zhouzijing.android.demo;import com.android.internal.telephony.ITelephony; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.telephony.TelephonyManager; import android.util.Log;public class MyPhoneBroadcastReceiver extends BroadcastReceiver {private final static String TAG = MyPhone.TAG;@Overridepublic void onReceive(Context context, Intent intent) {String action = intent.getAction();Log.i(TAG, "[Broadcast]"+action);//呼入电话if(action.equals(MyPhone.B_PHONE_STATE)){Log.i(TAG, "[Broadcast]PHONE_STATE");doReceivePhone(context,intent);}}/*** 处理电话广播.* @param context* @param intent*/public void doReceivePhone(Context context, Intent intent) {String phoneNumber = intent.getStringExtra( TelephonyManager.EXTRA_INCOMING_NUMBER);TelephonyManager telephony = (TelephonyManager)context.getSystemService( Context.TELEPHONY_SERVICE);int state = telephony.getCallState();switch(state){case TelephonyManager.CALL_STATE_RINGING:Log.i(TAG, "[Broadcast]等待接电话="+phoneNumber);try {ITelephony iTelephony = PhoneUtils.getITelephony(telephony);iTelephony.answerRingingCall();//自动接通电话//iTelephony.endCall();//自动挂断电话} catch (Exception e) {Log.e(TAG, "[Broadcast]Exception="+e.getMessage(), e);}break;case TelephonyManager.CALL_STATE_IDLE:Log.i(TAG, "[Broadcast]电话挂断="+phoneNumber);break;case TelephonyManager.CALL_STATE_OFFHOOK:Log.i(TAG, "[Broadcast]通话中="+phoneNumber);break;}}} 第四部：注册电话广播拦截器MyPhone.javapackage com.zhouzijing.android.demo;import android.app.Activity; import android.content.IntentFilter; import android.os.Bundle; import android.telephony.TelephonyManager; import android.util.Log; import android.view.View;public class MyPhone extends Activity {public final static String TAG = "MyPhone";public final static String B_PHONE_STATE = TelephonyManager.ACTION_PHONE_STATE_CHANGED;private MyPhoneBroadcastReceiver mBroadcastReceiver;@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.my_phone);}//按钮1-注册广播public void registerThis(View v) {Log.i(TAG, "registerThis");mBroadcastReceiver = new MyPhoneBroadcastReceiver();IntentFilter intentFilter = new IntentFilter();intentFilter.addAction(B_PHONE_STATE);intentFilter.setPriority(Integer.MAX_VALUE);registerReceiver(mBroadcastReceiver, intentFilter);}//按钮2-撤销广播public void unregisterThis(View v) {Log.i(TAG, "unregisterThis");unregisterReceiver(mBroadcastReceiver);}}第5步：在AndroidManifest.xml配置权限<uses-permission android:name="android.permission.READ_PHONE_STATE" /> <uses-permission android:name="android.permission.MODIFY_PHONE_STATE" /> <uses-permission android:name="android.permission.CALL_PHONE"/>其中：iTelephony.answerRingingCall();//自动接通电话必须有权限 android.permission.MODIFY_PHONE_STATEiTelephony.endCall();//自动挂断电话必须有权限 android.permission.CALL_PHONE。

这个名字都给你取的这么好听了。广播：需要向外接广泛传播的数据。适用于1对多方案。党中央宣布人民集体戴口罩。就是用的广播！懂了么兄弟

在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应用程序所接收。广播机制最大的特点就是发送方并不关心接收方是否接到数据，也不关心接收方是如何处理数据的。Android中广播的是操作系统中产生的各种各样的事件。例如，收到一条短信就会产生一个收到短信息的事件。而Android操作系统一旦内部产生了这些事件，就会向所有的广播接收器对象来广播这些事件。1.1 广播接收器BroadcastReceiverBroadcastReceiver(广播接收器)是为了实现系统广播而提供的一种组件，并且广播事件处理机制是系统级别的。比如，我们可以发出一种广播来测试是否收到短信，这时候就可以定义一个BraodcastReceiver来接受广播，当收到短信时提示用户。我们既可以用Intent来启动一个组件，也可以用sendBroadcast()方法发起一个系统级别的事件广播来传递消息。我们也可以在自己的应用程序中开发BroadcastReceiver，然后把广播接收器这个类或者对象注册到Android操作系统上去，让操作系统知道现在有这样一个广播接收器正在等待接收Android操作系统的广播，即在自己的应用程序中实现BroadcastReceiver来监听和响应广播的Intent。当有广播事件产生时，Android操作系统首先告诉注册到其上面的广播接收器产生了一个怎么样的事件，每个接收器首先判断是不是我这个接收器需要的事件，如果是它所需要的事件，再进行相应的处理。例子，我们把骚扰电话的黑名单放到数据库中去，当接到电话时会产生一个接电话事件，事先在Android操作系统中注册一个BroadcastReceiver的对象，当产生事件的时候，会通知我们的广播接收器对象，接收器对象接收到消息之后，就会到数据库里面去取所有黑名单电话和接到的这个电话号码进行比较，如果匹配就直接挂掉。1.2 注册BroadcastReceiver的方法BroadcastReceiver用于监听被广播的事件（Intent），为了达到这个目的，BroadcastReceiver必须进行注册，注册的方法有以下两种：1.静态注册静态注册方式是在AndroidManifest.xml的application里面定义receiver并设置要接收的action。静态注册方式的特点：不管该应用程序是否处于活动状态，都会进行监听。<receiver android:name=MyReceiver><intent-filter><action android:name=MyReceiver_Action/></intent-filter></receiver>其中，MyReceiver为继承BroadcastReceiver的类，重写了onReceiver方法，并在onReceiver方法中对广播进行处理。<intent-filter>标签设置过滤器，接收指定action广播。2.动态注册动态注册方式在activity里面调用函数来注册，和静态的内容差不多。一个形参是receiver，另一个是IntentFilter，其中里面是要接收的action。动态注册方式特点：在代码中进行注册后，当应用程序关闭后，就不再进行监听。MyReceiver receiver = new MyReceiver();//创建过滤器，并指定action，使之用于接收同action的广播IntentFilter filter = new IntentFilter(MyReceiver_Action);//注册广播接收器registerReceiver(receiver, filter); // 指定广播目标ActionIntent intent = new Intent(MyReceiver_Action);// 可通过Intent携带消息intent.putExtra(msg, 发送广播);// 发送广播消息sendBroadcast(intent); //注销广播接收器unregisterReceiver(receiver);注：1.一般在onStart中注册BroadcastReceiver，在onStop中取消BroadcastReceiver。2.一个BroadcastReceiver 对象只有在被调用onReceive(Context, Intent)时才有效，当从该函数返回后，该对象就无效的了，结束生命周期。

1.oncreate面增加 注册扫描广播 public void onCreate(Bundle savedInstanceState) { // 注册始发现广播 IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_ACL_CONNECTED); this.registerReceiver(mReceiver, filter); } 2.新建BroadcastReceiver广播象并实现面onreceive,onreceiverssi（信号强度） private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); //设备始扫描 if (BluetoothDevice.ACTION_FOUND.equals(action)) { //IntentblueDevice象 BluetoothDevice device = intent .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); if (device.getBondState() != BluetoothDevice.BOND_BONDED) { //信号强度 short rssi = intent.getExtras().getShort( BluetoothDevice.EXTRA_RSSI); } } } };

用户在拿到一个单片机TCP/IP协议栈以后该如何处理呢。其中的处理分为两个部分：上层接口和下层接口。4. 1 上层接口用户使用单片机TCP/IP的目的实际非常明了，就是要实现数据的传送，即从PC机（或者另一个单片机）上传送过来的数据能够在本地单片机上接收，反之亦然。所以如果屏蔽底层的话，单片机TCP/IP协议栈就是一个传输数据的手段。所以最后归结到了使用send()、recv()函数即可。这就是使用单片机TCP/IP协议栈的核心所在。但是事实上并没有这么简单，因为对于TCP需要有发起连接、接受连接、发送数据、接收数据、关闭连接等操作以配合数据的传输。TCP/IP协议栈一般为用户提供如下的接口：1． 初始化协议栈和释放协议栈的函数接口，类似Init(), Release()之类的函数。2． 提供类似BSD socket的socket, sendto, recvfro, connect, bind, listen, accept, send, recv, closesocket, shutdown, getpeername, getsockname, htonl, htons, ntohl, ntohs, inet_addr,inet_ntoa,ioctlsocket,setsockopt, getsockopt,select等API函数，用户调用此类函数进行发起连接、接受连接、发送数据、接收数据、关闭连接等操作。3． 接受连接、接收数据、被动关闭的处理：由于此类操作是上位机发起的，所以TCP/IP协议栈必须提供一套机制来处理此类事件的发生。一般来说有两种方法：a) 主动等待：例如使用BSD的recv()函数等待数据的到来。b) 回调机制：采用类似MFC的OnReceive()函数的回调机制，也即是说在接收到数据的时候会自动调用OnReceive()函数。那么用户如何使用以上的接口来实现远程控制、远程数据采集呢？方法很简单。例如现在需要实现一个对LED灯的亮和灭的远程控制应用。首先PC机使用TCP/IP发送工具例如SocketDlgTest程序发送一个字节的“1”到开发板（根据开发板的IP地址发送）。开发板在OnReceive函数中发现收到的是“1”，那么就通过P1端口将灯打开；反之如果收到的是“0”则将灯熄灭。如果是实现一个远程数据采集的应用，例如定时进行温度采集。首先PC机使用SocketDlgTest程序等待发来数据。开发板每隔一段时间采集一个数据，然后通过send()函数将数据发送给PC机（根据PC机的IP地址发送），这样PC就接收到了当前的远程温度数据。4. 1 下层接口下层接口是一个比较复杂的部分，实际上是TCP/IP协议栈和底层硬件的对接问题。如果用户将TCP/IP协议栈移植到自己的单片机系统上。由于硬件上存在一定的差异，就需要修改底层代码。这里需要包括：1．网卡驱动：如果TCP/IP协议栈已经提供了网卡驱动，并且驱动和用户使用的网卡芯片一样，那么就相对容易一些。这里只需要修改网卡的基地址即可。否则需要自己动手写驱动程序。如果网卡采用RTL8019AS可以参考老古开发网的单片机与TCP/IP网络。如果网卡采用CS8900，可以参考《嵌入式 TCP/IP 协议单片机技术在网络通信中的应用》2．TCP/IP底层接口。一般单片机TCP/IP需要底层为其提供定时中断、网卡中断处理的入口。底层需要做相应的处理。

private void mySendMessage(String phoneNum, String content) { String SENT_SMS_ACTION = "SENT_SMS_ACTION"; Intent sentIntent = new Intent(SENT_SMS_ACTION); PendingIntent sentPI = PendingIntent.getBroadcast( context.getApplicationContext(), 0, sentIntent, 0); // register the Broadcast Receivers context.registerReceiver(new BroadcastReceiver() { @Override public void onReceive(Context _context, Intent _intent) { switch (getResultCode()) { case Activity.RESULT_OK: handler.sendEmptyMessage(Mark.SMS_SUCCESS); //成功 下面的都是不成功 break; case SmsManager.RESULT_ERROR_GENERIC_FAILURE: case SmsManager.RESULT_ERROR_RADIO_OFF: case SmsManager.RESULT_ERROR_NULL_PDU: handler.sendEmptyMessage(Mark.SMS_FAIL); break; default: handler.sendEmptyMessage(Mark.SMS_FAIL); break; } } }, new IntentFilter(SENT_SMS_ACTION)); // 直接调用短信接口发短信 SmsManager smsManager = SmsManager.getDefau