androidsocket连接

Ⅰ android studio连接io.socket:sokect.io-client服务器的条件

条件是socket协议。
WebSocket是跟随HTML5一同提出的，所以在兼容性上存在问题，这时一个非常好用的库就登场了——Socket.io。
socket.io封装了websocket，同时包含了其它的连接方式，你在任何浏览器里都可以使用socket.io来建立异步的连接。socket.io包含了服务端和客户端的库，如果在浏览器中使用了socket.io的js，服务端也必须同样适用。
socket.io是基于Websocket的Client-Server实时通信库。
socket.io底层是基于engine.io这个库。engine.io为socket.io提供跨浏览器/跨设备的双向通信的底层库。engine.io使用了Websocket和XHR方式封装了一套socket协议。在低版本的浏览器中，不支持Websocket，为了兼容使用长轮询(polling)替代。

Ⅱ 请问下,android能不能直接通过手机IP进行socket通信,不是局域.

可以的，只要通信的IP是通的就行了。
有两种方案：
1、在PC机上建立服务器，手机与手机之间的通信通过服务器进行中转
2、一部手机作为服务器，另一部手机作为客户端接入该手机
一般是第一种方案
1、pc端：
serverSocket=new ServerSocket(5648); //在5648端口进行侦听
Socket sk = serverSocket.accept();//如果有接入，则创建对应的socket;
2、手机端:
socket=new Socket("tobacco5648.xicp.net",5648);//连接socket
3、消息输入输出：
pw=new PrintWriter(socket.getOutputStream()); //消息输出
pw.println("发送消息");
pw.flush();
br=new BufferedReader(new InputStreamReader(socket.getInputStream())); //消息接收
while((str=br.readLine())!=null){
//接收消息
}

Ⅲ 自己写了一个Android的APP，想用socket连接服务器

最近我在在写一个APP，用到了socket，在自己电脑上搭建的服务器，具体过程： 用eclipse写java代码，创建一个serversocket，用来监听客户端的请求； 客户端在发送数据前，首先创建一个Socket，然后直接请求服务器即可。自己写了一个Android的APP，想用socket连接服务器

Ⅳ 求教android socket连接不成功如何弹出对话框提示不成功，代码要如何写

dialog.show要代码私信

Dialog dialog;
dialog=new AlertDialog.Builder(activity).setTitle("请输入设备号和密码")
.setIcon(android.R.drawable.ic_menu_send)
.setView(layout)
.setPositiveButton("确定", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
}
}).create();
dialog.setCancelable(false);
dialog.setCanceledOnTouchOutside(false);
dialog.show();

Ⅳ 求教android socket连接不成功如何弹出对话框提示不成成，代码要如何写

1 用一个EditText作为用户名输入口，用一个按键确定。

2 注册一个广播接收器，专门接收由后来的聊天界面发过来的消息广播（包括发信人，收信人，消息体）。

3 创建一个客户端连接服务端的方法（要在线程中启动该方法），连接成功并获取输入输出流以后，再在里面启动一个输入流管理线程（接受并处理由服务端发送过来的消息）。并通过intent启动下一个好友列表界面（同时把自身用户名发给下一界面）。

4 对于输入流管理线程，要先判断接收到的是好友名单还是聊天消息发送两种广播，（服务端发送两种信息时可以加个标签以便线程区分）。然后分发出两种广播，一种广播后面的好友列表界面接受的在线好友名单，另一种广播出聊天界面接收的聊天信息。

Ⅵ android socket有几种方法

/***第一种：客户端Socket通过构造方法连接服务器***/
//客户端Socket可以通过指定IP地址或域名两种方式来连接服务器端,实际最终都是通过IP地址来连接服务器
//新建一个Socket，指定其IP地址及端口号
Socket socket = new Socket("192.168.0.7",80);
/***Socket 客户端 一些常用设置***/
//客户端socket在接收数据时，有两种超时：1.连接服务器超时，即连接超时；2.连接服务器成功后，接收服务器数据超时，即接收超时
//*设置socket 读取数据流的超时时间
socket.setSoTimeout(5000);
//发送数据包，默认为false，即客户端发送数据采用Nagle算法；
//但是对于实时交互性高的程序，建议其改为true，即关闭Nagle算法，客户端每发送一次数据，无论数据包大小都会将这些数据发送出去
socket.setTcpNoDelay(true);
//设置客户端socket关闭时，close（）方法起作用时延迟1分钟关闭，如果1分钟内尽量将未发送的数据包发送出去
socket.setSoLinger(true, 60);
//设置输出流的发送缓冲区大小，默认是8KB，即8096字节
socket.setSendBufferSize(8096);
//设置输入流的接收缓冲区大小，默认是8KB，即8096字节
socket.setReceiveBufferSize(8096);
//作用：每隔一段时间检查服务器是否处于活动状态，如果服务器端长时间没响应，自动关闭客户端socket
//防止服务器端无效时，客户端长时间处于连接状态
socket.setKeepAlive(true);
/*** Socket客户端向服务器端发送数据 ****/
//客户端向服务器端发送数据，获取客户端向服务器端输出流
OutputStream os = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bw = new BufferedWriter(osw);
//代表可以立即向服务器端发送单字节数据
socket.setOOBInline(true);
//数据不经过输出缓冲区，立即发送
socket.sendUrgentData(65);//"A"
//向服务器端写数据，写入一个缓冲区
//注：此处字符串最后必须包含“\r\n\r\n”，告诉服务器HTTP头已经结束，可以处理数据，否则会造成下面的读取数据出现阻塞
//在write（）方法中可以定义规则，与后台匹配来识别相应的功能，例如登录Login（）方法，可以写为write("Login|test,123 \r\n\r\n"),供后台识别;
bw.write("Login|test,123 \r\n\r\n");
//发送缓冲区中数据，必须有
bw.flush();

/*** Socket客户端读取服务器端响应数据 ****/
//socket.isConnected代表是否连接成功过
if((socket.isConnected() == true) && (socket.isClosed() == false)){//判断Socket是否处于连接状态
//客户端接收服务器端的响应，读取服务器端向客户端的输入流
InputStream is = socket.getInputStream();
//缓冲区
byte[] buffer = new byte[is.available()];
//读取缓冲区
is.read(buffer);
//转换为字符串
String responseInfo = new String(buffer);
//日志中输出
Log.i("TEST", responseInfo);
} //关闭网络
socket.close();
/***第二种：通过connect方法连接服务器***/
Socket socket_other = new Socket();
//使用默认的连接超时
socket_other.connect(new InetSocketAddress("192.168.0.7",80));
//连接超时2s
socket_other.connect(new InetSocketAddress("192.168.0.7",80),2000);
//关闭socket
socket_other.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}

Ⅶ android socket一直在链接 服务器不响应

connect方法里面:new Socket那会抛异常的。导致你上部分catch到异常。writer没有被初始化。 接下来估计你直接使用了writer。导致了空指针异常。 所以关键是你的:new Socket这里。这个地方很用可能是服务端没有打开，而导致的连接异常

Ⅷ android在线程中socket连接例子

package com.cpa.uri;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
public class ClientDemo {
public static void main(String[] args) throws IOException, Exception {
ClientDemo client=new ClientDemo();
client.open();
}
private void open() throws Exception, IOException{
Socket s=new Socket("localhost",8000);
InputStream in=s.getInputStream();
OutputStream out=s.getOutputStream();
new Reader(out).start();
new Write(in).start();
}
class Reader extends Thread{
OutputStream out;
public Reader(OutputStream out) {
this.out=out;
setDaemon(true);
}
@Override
public void run() {
try {
Scanner s=new Scanner(System.in);
while(true){
String str=s.nextLine();//读取控制台
out.write(str.getBytes());//发送到服务器
out.write('\n');
out.flush();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
super.run();
}
}
class Write extends Thread{
InputStream in;
public Write(InputStream in) {
this.in=in;
}
@Override
public void run() {
int b;
try {
while((b=in.read())!=-1){
System.out.println(b);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
**************************

package com.cpa.uri;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class ServerDemo {

public static void main(String[] args) throws Exception {
ServerDemo server=new ServerDemo();
server.start();
}
private void start() throws Exception{
ServerSocket ss=new ServerSocket(8000);
while (true) {
System.out.println("等待客户端连接!");
Socket s=ss.accept();
System.out.println("客户端连接成功:"+s.getInetAddress());
//为这个客户端创建一个服务线程
new Service(s).start();
}
}
class Service extends Thread{
Socket s;
public Service(Socket s){
this.s=s;
}
@Override
public void run() {
try {
InputStream in=s.getInputStream();
OutputStream out=s.getOutputStream();
//服务器向客户写消息
out.write("说口令".getBytes());
out.flush();
Scanner s=new Scanner(in);
while(true){
String str=s.nextLine();
if (str.equals("A friend in need is a friend indeed")) {
out.write("回答正确".getBytes());
out.flush();
}else if (str.equals("ni是不是笨蛋")) {
out.write("是".getBytes());
out.flush();
break;
}else{
out.write("What do you say!".getBytes());
out.flush();
}
}
s.close();
} catch (Exception e) {
}
super.run();
}
}
}
************************
客户端和服务器端java代码,自己改动下就可以变成android代码了.

Ⅸ 如何干净的实现Android/Java Socket 长连接通信

我们有时候有这种需求，即我们的android客户端要始终保持与服务端的连接，当服务端有任务或消息发送到android客户端的时候就发送，没有任务或消息的时候不发送但要保持这个连接，一旦有任务则开发发送，而我们的android客户端则要保持一个时刻接收任务或消息的状态。。。这个时候我们通过socket来实现这种需求【当然你也可以采用http轮询的方式来不断的从客户端个请求服务端，这样做有一定的弊端】
实现原理：
1：android客户端通过service在后台通过servreScoket不断的accept，一旦有相应的socket到达，则启动一个线程去处理
2:：在线程中处理完返回给我们android客户端的消息或任务之后，要将这种结果表现在ui上，这个步骤方法就比较多了，例如你可以发一个广播来通知ui,或者你可以通过一个static的handler来处理

Ⅹ 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去启动的话，页面会卡住。。。