Ⅰ android客户端作为服务器局域网用Socket，在一个activity中监听端口。其他activity发送数据。如何实现呢
1 最简单也是最笨的办法是启动要发送数据的Activity，然后在这个Activtiy进行发送数据。
2 如果你不能接受这样的话，发送广播通知那个Activity发送数据。
3 另外，个人觉得，在后台发送数据的功能还是不要写在Activity的好，可以用service或者线程来实现。
4 如果你决定了用某种方法，咱们在进一步讨论
Ⅱ android怎么写socket一对一聊天弹出界面
1 用一个EditText作为用户名输入口，用一个按键确定。
2 注册一个广播接收器，专门接收由后来的聊天界面发过来的消息广播（包括发信人，收信人，消息体）。
3 创建一个客户端连接服务端的方法（要在线程中启动该方法），连接成功并获取输入输出流以后，再在里面启动一个输入流管理线程（接受并处理由服务端发送过来的消息）。并通过intent启动下一个好友列表界面（同时把自身用户名发给下一界面）。
4 对于输入流管理线程，要先判断接收到的是好友名单还是聊天消息发送两种广播，（服务端发送两种信息时可以加个标签以便线程区分）。然后分发出两种广播，一种广播后面的好友列表界面接受的在线好友名单，另一种广播出聊天界面接收的聊天信息。
5 在菜单下做一个退出Activity按键，方便用户退出程序。
6 当一切准备好以后，用户在输入用户名并点击确定，就可以实现以上操作，同时进入了好友列表界面（前提是能正确连接上服务端）。二 好友列表界面
1 注册一个广播接收器，专门接收由登录界面的输入流管理线程发送过来的好友名单广播
2 用listView逐个显示好友名单。
3 获取用户登录界面发过来的自身用户名。
4 给listView绑定一个监听器，当用户点击listView上的某一好友时，通过intent启动下一个聊天界面，并把所点击到的好友用户名以及自身用户名发给下一个界面。
三 聊天界面
1 获取好友列表界面发送过来的聊天好友用户名以及自身用户名，并在Title上显示。
2 用一个EditText作为聊天消息输入口，用一个按键确定输出。
3 当用户点击确定以后，发送一个消息广播（包含发信人，收信人，消息体），让用户登录界面的消息广播接收器接收。
4 注册一个广播接收器接受用户登录界面的输入流管理线程发送过来的消息。
服务端设计思路：
消息处理界面（只有一个界面）
1 创建一个监听连接请求方法 （监听客户端发送连接请求，需要在线程中启动）。
A 当用户发送连接请求时，生成socket对象。由该socket对象生成输出流和输入流，从输入流中提取出客户端发送过来的用户名，把用户名放到sickName数组上，把输出流放在ArrayOut数组中。
B 发送新客户端XXX连接成功广播。
C 预先用sickName数组和ArrayOut数组创建发送好友列表方法（给各已连接客户端发送好友名单），在这里调用方法。
D 新生成并启动输入流管理线程（接受并处理客户端发送过来的消息，由于有一个新用户生成，就新生一个输入流管理线程，所以客户端发送的消息不会混乱）。
2 创建发送好友列表方法。
3 注册两个广播接收器，一个接收新客户端XXX连接成功广播；另一个接收输入流管理线程发送过来的聊天消息，识别出目标对象，并向目标对象分别发送消息。
4 在onResume方法中启动监听线程。
5 在菜单下做一个退出Activity按键和刷新按钮（再次发送已连接用户名单给各客户端）。
Ⅲ socket 的广播地址怎么用
针对255.255.255.255这个地址，实际上是个受限的广播地址，在操作系统上，一般用应用层上的UDP发送，是发不出这个地址的。你可以容易发送一个针对指向网络的广播：192.168.1.255。而实际上，我们也基本用不到4个255地址的广播报文。像ARP、DHCP这样的广播报文，是系统自身的特殊协议数据包。所以不用在应用层上试图发送4个255的受限报文。
在一些单片机上，可以直接在发送的原始数据包中填写4个255的地址。
你用抓包软件可以看到这些数据包，但是在应用层上，你基本上收不到这些报文。
Ⅳ android如何与手机进行通信（Socket连接）
其实跟电脑差不多了，android里调用socket的方法，拿到socket后就可以发送数据并接收数据。
我最近正在做android方面的通信，真的想把完整的代码都给你，可是没办法，公司机密。。
给你我的socket连接类吧。。。
package sean.socket;
///////////把MyType的一些方法替换成Writer的方法
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import sean.Sysout;
import sean.business.BusinessCenter;
import sean.business.LoginManager;
import sean.format.MyType;
import sean.io.Reader;
import sean.transfer.BytesBuffer;
import sean.transfer.DataCenter;
public class SocketThread implements Runnable {
String Server = "";
int Port = 0;
static Socket cs = null;
// Thread ioThread=null;
static boolean bool_SocketThread = false;
static OutputStream output = null;
public SocketThread(String server, int port) {
Server = server;
Port = port;
bool_SocketThread = true;
}
@Override
public void run() {
// TODO Auto-generated method stub
while (bool_SocketThread) {
try {
// if (cs == null) {
DataCenter.setBool_Login(false);// 设置登录失败
Sysout.println("正在尝试连接ClientSocket...", Sysout.TempOutDebug);
cs = new Socket(InetAddress.getByName(Server), Port);
if (cs != null) {
Sysout.println("ClientSocket连接成功！__" + cs,
Sysout.TempOutDebug);
cs.setKeepAlive(true);//让socket保持活动状态
InputStream input = cs.getInputStream();
output = cs.getOutputStream();
BusinessCenter.sendLoginData();
BytesBuffer bBuffer = new BytesBuffer();
byte[] Buffer = new byte[1024];
int ReadBytes = input.read(Buffer);
while (ReadBytes != -1) {
Sysout.println("已读取" + ReadBytes + "个字节到缓冲区",
Sysout.TempOutDebug);
byte[] b = new byte[ReadBytes];
b = MyType.BytesInsertToBytes(Buffer, b, 0);
Reader r = new Reader(b);
Sysout.println(r.toString() + "____ReadBytes=="
+ ReadBytes, Sysout.TempOutDebug);
bBuffer.InsertToBuffer(Buffer, ReadBytes);
ReadBytes = input.read(Buffer);
}
} else {
Sysout.printException("ClientSocket连接失败！请确认网络正常且服务器已开启。");
}
// }
// 执行到这里说明inputstream.read()已中断，说明socket已断开连接
// cs=null;
LoginManager.setLoginValue(-1);// 业务中心登录注销，即登录管理器注销登录
DataCenter.setBool_Login(false);// 数据中心登录注销
Sysout.printException(cs + "已断开。");
Thread.sleep(2 * 1000);// 睡眠2秒后继续循环
// try {
// // 判断ClientSocket是否已断开
// cs.sendUrgentData(0);
// } catch (IOException e) {
// // TODO Auto-generated catch block
// Sysout.printException("ClientSocket已断开，重新连接。"+e);
// cs.close();
// cs = null;
// }
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====解析服务器名称发生异常！" + e);
// e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread发生IO异常，异常消息：" + e);
try {
if (cs != null) {
Sysout.println("准备关闭" + cs, Sysout.TempOutDebug);
cs.shutdownOutput();
cs.shutdownInput();
cs.close();
cs = null;
output = null;
LoginManager.setLoginValue(-1);// 业务中心登录注销，即登录管理器注销登录
DataCenter.setBool_Login(false);// 数据中心登录注销
Sysout.println(cs + "已关闭。", Sysout.TempOutDebug);
}
try {
Thread.sleep(5000);
} catch (InterruptedException e2) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====线程睡眠异常！！"
+ e2);
// e2.printStackTrace();
}
String ExceptionInfos=e.toString();
if(ExceptionInfos.endsWith("Connection refused")){
stopSocketThread();
}
} catch (IOException e1) {
// TODO Auto-generated catch block
Sysout.printException(cs + "关闭发生异常::" + e1);
// e1.printStackTrace();
try {
Thread.sleep(5000);
} catch (InterruptedException e2) {
// TODO Auto-generated catch block
Sysout.printException("SocketThread.java====线程睡眠异常！！"
+ e2);
// e2.printStackTrace();
}
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}// while(bool_SocketThread)
Sysout.println("SocketThread已停止。", Sysout.TempOutDebug);
}
public static Socket getSocket() {
return cs;
}
// public void setBool(boolean bool0) {
// bool_SocketThread = bool0;
// }
public static OutputStream getOutputStream() {
return output;
}
public static void stopSocketThread() {
try {
// 停止SocketThread线程，必须先把循环的标志bool_SocketThread置为false，否则可能继续循环，重新建立socket连接
bool_SocketThread = false;
// 关闭socket
if (cs != null) {
cs.shutdownOutput();
cs.shutdownInput();
cs.close();
cs = null;
output = null;
Sysout.println("ClientSocket已被强制关闭。");
// LoginManager.setLoginValue(-1);// 业务中心登录注销，即登录管理器注销登录
// DataCenter.setBool_Login(false);// 数据中心登录注销
// byte[] lock=LoginActivity.getLock();
// synchronized(lock){
// lock.notify();
// }
}
} catch (IOException e) {
// TODO Auto-generated catch block
Sysout.printException("强制关闭" + cs + "发生异常::" + e);
// e.printStackTrace();
}
}
}
必须先在android里启动一个服务，由服务去启动这个socket线程，因为如果是UI去启动的话，页面会卡住。。。
Ⅳ 关于socket广播，请问下面的程序什么意思啊，大家能帮帮忙么。详细点啊~~
同学，你给的这段程序从哪里来的，有问题，虽然可能可以运行。
我注解了一下，你看看好使不：
//发送端程序
#include <stdio.h>
#include <winsock.h>
int main(int argc, char* argv[])
{
WSADATA wsaData; //指向WinSocket信息结构的指针
SOCKET sockListener;
SOCKADDR_IN sin,saUdpServ;
BOOL fBroadcast = TRUE;
char sendBuff[1024];
int nSize;
int ncount=0;
// 初始化winsock库，使用socket的前提
if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化
{
printf("Can't initiates windows socket!Program stop.\n");//初始化失败返回-1
return -1;
}
// 创建socket
sockListener=socket(PF_INET,SOCK_DGRAM,0);
// 打开广播选项，是socket可以广播消息
setsockopt ( sockListener,SOL_SOCKET,SO_BROADCAST, (CHAR *)&fBroadcast,sizeof ( BOOL ));
// 将socket绑定到本地端口
sin.sin_family = AF_INET;
sin.sin_port = htons(0);
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind( sockListener, (SOCKADDR *)&sin, sizeof(sin))!=0)
{
printf("Can't bind socket to local port!Program stop.\n");//初始化失败返回-1
return -1;
}
// 设定广播的目的端口
saUdpServ.sin_family = AF_INET;
saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST );
saUdpServ.sin_port = htons (7001);//发送用的端口，可以根据需要更改
nSize = sizeof ( SOCKADDR_IN );
while(1)
{
// 广播消息
sprintf(sendBuff,"Message %d",ncount++);
sendto ( sockListener,sendBuff,
lstrlen (sendBuff),
0,
(SOCKADDR *) &saUdpServ,
sizeof ( SOCKADDR_IN ));
printf("%s\n",sendBuff);
}
return 0;
}
//接收
#include <stdio.h>
#include <winsock.h>
#include <conio.h>
int main(int argc, char* argv[])
{
WSADATA wsaData; //指向WinSocket信息结构的指针
SOCKET sockListener;
SOCKADDR_IN sin,saClient;
char cRecvBuff[1024];
int nSize,nbSize;
int iAddrLen=sizeof(saClient);
if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化
{
printf("Can't initiates windows socket!Program stop.\n");//初始化失败返回-1
return -1;
}
// 绑定到7001端口，以监听来自网络的数据
sockListener=socket(AF_INET, SOCK_DGRAM,0);
sin.sin_family = AF_INET;
sin.sin_port = htons(7001);//发送端使用的发送端口，可以根据需要更改
sin.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind( sockListener, (SOCKADDR FAR *)&sin, sizeof(sin))!=0)
{
printf("Can't bind socket to local port!Program stop.\n");//初始化失败返回-1
return -1;
}
while(1)
{
nSize = sizeof ( SOCKADDR_IN );
// 接受消息
if((nbSize=recvfrom (sockListener,cRecvBuff,1024,0,(SOCKADDR FAR *) &saClient,&nSize))==SOCKET_ERROR)
{
printf("Recive Error");
break;
}
cRecvBuff[nbSize] = '\0';
printf("%s\n",cRecvBuff);
}
return 0;
}
Ⅵ 如何用socket发送广播帧
这是一个发送多播帧的例子:
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <resolv.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#define SERV_PORT 5000
int main(int,char**)
{
int SendtoSocket;
sockaddr_in SendtoAddr;
int AddrLen=sizeof(SendtoAddr);
char szBuffer[200]="This is a test\n";
char *szTime;
SendtoSocket=socket(AF_INET,SOCK_DGRAM,0);
bzero(&SendtoAddr,sizeof(SendtoAddr));
SendtoAddr.sin_family=AF_INET;
SendtoAddr.sin_port=htons(SERV_PORT);
inet_pton(AF_INET,"224.0.3.1",&SendtoAddr.sin_addr);
const int on=1;
// setsockopt(SendtoSocket,SOL_SOCKET,SO_BROADCAST,&on,sizeof(on));
time_t CurrentTime;
for(;;)
{
time(&CurrentTime);
szTime=ctime(&CurrentTime);
sendto(SendtoSocket,szTime,strlen(szTime),0,(sockaddr *)&SendtoAddr,AddrLe
n);
sleep(1);
}
}
这是接收多播帧的例子:
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <resolv.h>
#include <string.h>
#include <unistd.h>
#define SERV_PORT 5000
int main(int,char**)
{
int RecvSocket;
sockaddr_in ServAddr;
socklen_t AddrLen=sizeof(ServAddr);
char szBuffer[201];
RecvSocket=socket(AF_INET,SOCK_DGRAM,0);
bzero(&ServAddr,sizeof(ServAddr));
ServAddr.sin_family=AF_INET;
ServAddr.sin_addr.s_addr=htonl(INADDR_ANY);
ServAddr.sin_port=htons(SERV_PORT);
bind(RecvSocket,(sockaddr *)&ServAddr,AddrLen);
ip_mreq mreq;
inet_pton(AF_INET,"224.0.3.1",&mreq.imr_multiaddr.s_addr);
mreq.imr_interface.s_addr=ServAddr.sin_addr.s_addr;
setsockopt(RecvSocket,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq));
int nRecv;
for(;;)
{
nRecv=recvfrom(RecvSocket,szBuffer,200,0,(sockaddr *)&ServAddr,&AddrLen);
szBuffer[nRecv]='\0';
printf(szBuffer);
}
}
Ⅶ 请教如何搜索周边的android设备，并发送消息
局域网，例如同一个路由器下，利用socket编程，向255.255.255.255以及指定端口发送广播，然后所有该局域网内，设置了指定端口监听的手机应用都可以收到广播，收到广播后，就可以获取到发送广播的手机的IP地址，然后通过该IP地址向主机监听的端口发送信息，这样主机就知道附近有哪些其他的安卓手机了；
不同的局域网，需要借助有公网IP地址的服务器进行转发，才可以实现，这个叫云穿透，所有手机连接到网络后要向服务器注册，然后服务器就知道有哪些手机，然后其他手机只要通过服务器的公网IP提出请求，就可以通过服务器间接的进行通讯。
Ⅷ nodejs的socket.io的广播机制是怎样的
node.js提供了高效的服务端运行环境，但是由于浏览器端对HTML5的支持不一，为了兼容所有浏览器，提供卓越的实时的用户体验，并且为程序员提供客户端与服务端一致的编程体验，于是socket.io诞生。
socket.io设计的目标是支持任何的浏览器，任何Mobile设备。目前支持主流的PC浏览器 (IE,Safari,Chrome,Firefox,Opera等)，Mobile浏览器(iphone Safari/ipad Safari/android WebKit/WebOS WebKit等)。socket.io基于node.js并简化了WebSocket API，统一了通信的API。它支持：WebSocket, Flash Socket, AJAX long-polling, AJAX multipart streaming, Forever IFrame, JSONP polling。
socket.io解决了实时的通信问题，并统一了服务端与客户端的编程方式。启动了socket以后，就像建立了一条客户端与服务端的管道，两边可以互通有无。
Ⅸ Android 进程间通信的几种实现方式
Android 进程间通信的几种实现方式
主要有4种方式：
这4种方式正好对应于android系统中4种应用程序组件：Activity、Content Provider、Broadcast和Service。
主要实现原理：
由于应用程序之间不能共享内存。为了在不同应用程序之间交互数据（跨进程通讯），AndroidSDK中提供了4种用于跨进程通讯的方式进行交互数据，实现进程间通信主要是使用sdk中提供的4组组件根据实际开发情况进行实现数据交互。
详细实现方式：
Acitivity实现方式
Activity的跨进程访问与进程内访问略有不同。虽然它们都需要Intent对象，但跨进程访问并不需要指定Context对象和Activity的 Class对象，而需要指定的是要访问的Activity所对应的Action（一个字符串）。有些Activity还需要指定一个Uri（通过 Intent构造方法的第2个参数指定）。 在android系统中有很多应用程序提供了可以跨进程访问的Activity，例如，下面的代码可以直接调用拨打电话的Activity。
IntentcallIntent=newIntent(Intent.ACTION_CALL,Uri.parse("tel:12345678");
startActivity(callIntent);Content Provider实现方式
Android应用程序可以使用文件或SqlLite数据库来存储数据。Content Provider提供了一种在多个应用程序之间数据共享的方式（跨进程共享数据）
应用程序可以利用Content Provider完成下面的工作
1. 查询数据
2. 修改数据
3. 添加数据
4. 删除数据
Broadcast 广播实现方式
广播是一种被动跨进程通讯的方式。当某个程序向系统发送广播时，其他的应用程序只能被动地接收广播数据。这就象电台进行广播一样，听众只能被动地收听，而不能主动与电台进行沟通。在应用程序中发送广播比较简单。只需要调用sendBroadcast方法即可。该方法需要一个Intent对象。通过Intent对象可以发送需要广播的数据。
Service实现方式
常用的使用方式之一：利用AIDL Service实现跨进程通信
这是我个人比较推崇的方式，因为它相比Broadcast而言，虽然实现上稍微麻烦了一点，但是它的优势就是不会像广播那样在手机中的广播较多时会有明显的时延，甚至有广播发送不成功的情况出现。
注意普通的Service并不能实现跨进程操作，实际上普通的Service和它所在的应用处于同一个进程中，而且它也不会专门开一条新的线程，因此如果在普通的Service中实现在耗时的任务，需要新开线程。
要实现跨进程通信，需要借助AIDL(Android Interface Definition Language)。Android中的跨进程服务其实是采用C/S的架构，因而AIDL的目的就是实现通信接口。
总结
跨进程通讯这个方面service方式的通讯远远复杂于其他几种通讯方式，实际开发中Activity、Content Provider、Broadcast和Service。4种经常用到，学习过程中要对没种实现方式有一定的了解。
Ⅹ android:udp广播
首先手机作为终端 可以不必要知道终端的数量、 还有就是我建议你多学习下基础，android的广播机制不是把广播在终端之间传输，广播是在应用程序里面发送，在应用程序进行接收。个人建议基础才是王道。 对于你现在这个问题，不妨采用发送消息的方式 实现该功能。一个终端发送消息 其他终端接收消息，当然也相当于写一个socket通信。通信建立之后 ，可以取得各个连接的终端的IP 然后怎么逻辑就看你怎么写算法了。还有就是，这个功能也可以用消息推送的方式（建议采用此方法）、android系统内置有消息推送，逻辑都和上述的差不多，至于具体用那些方法 那些内置类，个人建议多查API。软件开发必须靠自学。。。。