对于想了解Android之浏览器作为客户端访问手机socket作为服务端下载图片和网页和APK的读者，本文将提供新的信息，并且为您提供关于(转)Android客户端与PC服务端socket通信接收与发
对于想了解Android之浏览器作为客户端访问手机socket作为服务端下载图片和网页和APK的读者，本文将提供新的信息，并且为您提供关于(转) Android 客户端与 PC 服务端 socket 通信接收与发送图片、android socket 服务端、android socket 问题 android 客户端 与java服务器socket通信 ，当服务器突然中断后、Android socket实现原理详解 服务端和客户端如何搭建的有价值信息。
本文目录一览：- Android之浏览器作为客户端访问手机socket作为服务端下载图片和网页和APK
- (转) Android 客户端与 PC 服务端 socket 通信接收与发送图片
- android socket 服务端
- android socket 问题 android 客户端 与java服务器socket通信 ，当服务器突然中断后
- Android socket实现原理详解 服务端和客户端如何搭建
Android之浏览器作为客户端访问手机socket作为服务端下载图片和网页和APK
1 需求
在同一局域网内，手机（PC端）浏览器作为客户端，然后手机app里面通过socket写服务代码，然后浏览器访问手机服务端的网页和图片和css文件和下载APK
2 代码实现
创建服务线程代码
var serverSocket: ServerSocket? = null
var run = true
inner class HttpServerThread : Runnable {
var TAG = javaClass.name
var context : Context?= null
constructor(context : Context){
this.context = context
}
override fun run() {
Log.i(TAG, "await start")
try {
//Android9.0以下开启了热点服务器的IP值是192.168.43.1,如果Android版本大于9.0 IP服务器地址会随机变
serverSocket = ServerSocket(SocketContants.HTTP_SERVER_PORT)
// serverSocket = ServerSocket(SocketContants.HTTP_SERVER_PORT, 10, InetAddress.
// ("192.168.43.1"))
} catch (e: IOException) {
Log.i(TAG, "has error")
e.printStackTrace()
}
if (serverSocket == null) {
Log.i(TAG, "serverSocket == null")
return;
}
while (run) {
Log.i(TAG, "while (true) start")
var socket: Socket? = null
var input: InputStream? = null
var output: OutputStream? = null
try { //接收了客户端发来的请求，否则一致是等待状态
Log.i(TAG, "serverSocket.accept() start")
socket = serverSocket!!.accept()
Log.i(TAG, "serverSocket.accept() after")
input = socket.getInputStream()
output = socket.getOutputStream()
// create Request object and parse
val request = Request(input)
request.parse() //从请求中读取内容
Log.i(TAG, "shutdown.req=" + request.uri)
val response = Response(output, context)
response.setRequest(request)
response.sendDataToClient()
socket.close()
} catch (e: Exception) {
e.printStackTrace()
Log.i(TAG, "Exception has error ")
}
}
}
}开启服务代码
Thread(context?.let { HttpServerThread(it) }).start()在onDestroy里面关闭服务代码
//关闭socket
if (serverSocket != null) {
Log.i(TAG, "serverSocket != null and close")
serverSocket!!.close()
}
run = falseRequest.java代码
import android.util.Log;
import java.io.IOException;
import java.io.InputStream;
public class Request {
public static final String TAG = "Request";
private static final int SIZE = 2048;
private InputStream input;
private String uri;
public Request(InputStream input) {
this.input = input;
}
public void parse() {
StringBuffer request = new StringBuffer(SIZE);
int i;
byte[] buffer = new byte[SIZE];
try {
i = input.read(buffer); //将从输入流取2048长度的内容存到buffer字节数组中，如果内容不到2048，数组其他空间剩余空着
} catch (IOException e) {
e.printStackTrace();
i = -1;
}
for (int j = 0; j < i; j++) {
request.append((char) buffer[j]);
}
Log.i(TAG, "************Http-request*****************");
Log.i(TAG, request.toString());
uri = parseUri(request.toString().replace(''/'', ''\\''));
Log.i(TAG, "uri is:" + uri);
}
private String parseUri(String requestString) {
int index1, index2;
index1 = requestString.indexOf('' '');
Log.i(TAG, "index1 is:" + index1);
/*
* http请求行的结构:方法 统一资源标识符（URI） 协议/版本(它们之间以空格分隔)
* 例如：POST //examples/default.jsp HTTP/1.1
*/
if (index1 != -1) {// index1 == -1表示没找到
index2 = requestString.indexOf('' '', index1 + 1);//从index+1位置开始寻找‘ ’
Log.i(TAG, "index2 is:" + index2);
if (index2 > index1)
return requestString.substring(index1 + 1, index2);
}
return null;
}
public String getUri() {
return uri;
}
}
Response.java代码
import android.content.Context;
import android.text.TextUtils;
import android.util.Log;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Response {
public static final String TAG = "Response";
private static final int BUFFER_SIZE = 1024;
public Context conext;
Request request;
OutputStream output;
DataOutputStream sout;
public Response(OutputStream output, Context conext) {
this.output = output;
sout = new DataOutputStream(output);
this.conext = conext;
}
public Response(OutputStream output) {
this.output = output;
sout = new DataOutputStream(output);
}
public void setRequest(Request request) {
this.request = request;
}
public void sendDataToClient() {
String url = request.getUri();
Log.i(TAG, "url is:" + url);
if (url != null && "\\".equals(url)) {
//发送apk
// sendAPK(Constants.APK_NAME);
sendHtml();
// sendImage();
} else if (url != null && url.contains("png")){
sendImage();
} else if (url != null && url.contains("css")){
String cssName = getRequestFileName(url);
Log.i(TAG, "css Name is" + cssName);
sendCss(cssName);
} else if (url != null && url.contains("apk")) {
sendAPK(Constants.APK_NAME);
}
}
/**
* 解析url url is:\192.168.43.1:9999\download.css url is:\ url is:\192.168.43.1:9999\ic_launcher_round.png
*/
public String getRequestFileName(String url) {
if (TextUtils.isEmpty(url)) {
return null;
}
String ss = "\\\\";
String[] paths = url.split(ss);
if (paths == null || paths.length == 0) {
Log.i(TAG, "paths is null");
return "";
}
String name = paths[paths.length - 1];
Log.i(TAG, "getNameByImagePath name is:" + name);
return name;
}
public void sendHtml() {
try {
String line="HTTP/1.1 200 OK \r\n";
Log.i(TAG,"line="+line);
sout.write(line.getBytes());//用字节传输，不能用字符，浏览器无法解析
byte[] buff = new byte[1024];
conext.getAssets().open("share/download.html").read(buff);
String header="Content-Type: text/html; charset=utf-8 \r\n"
+"Content-length: "+ buff.length +" \r\n\r\n";
Log.i(TAG,"header="+header);
sout.writeBytes(header);
sout.write(buff);
sout.flush();
sout.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (sout != null)
try {
sout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void sendCss(String fileName) {
try {
String line="HTTP/1.1 200 OK \r\n";
Log.i(TAG,"line="+line);
sout.write(line.getBytes());//用字节传输，不能用字符，浏览器无法解析
byte[] buff = new byte[1024 * 100];
conext.getAssets().open("share/" + fileName).read(buff);
String header="Content-Type: text/css; charset=utf-8 \r\n"
+"Content-length: "+ buff.length +" \r\n\r\n";
Log.i(TAG,"header="+header);
sout.writeBytes(header);
sout.write(buff);
sout.flush();
sout.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (sout != null)
try {
sout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void sendImage() {
try {
String line="HTTP/1.1 200 OK \r\n";
Log.i(TAG,"line="+line);
sout.write(line.getBytes());//用字节传输，不能用字符，浏览器无法解析
byte[] buff = new byte[1024 * 100];
conext.getAssets().open("share/ic_launcher_round.png").read(buff);
String header="Content-Type: image/jpeg; charset=utf-8 \r\n"
+"Content-length: "+ buff.length +" \r\n\r\n";
Log.i(TAG,"header="+header);
sout.writeBytes(header);
sout.write(buff);
sout.flush();
sout.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (sout != null)
try {
sout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void sendAPK(String fileName) {
FileInputStream fis = null;
try {
Log.i(TAG, "request.getUri() is:" + request.getUri());
String apkPath = SPHelper.getInstance().getString(SpConstants.CURRENT_APK_PATH, "");
Log.i(TAG, "apkPath is:" + apkPath);
if (TextUtils.isEmpty(apkPath)) {
sendHtml();
return;
}
File file = new File(apkPath);
// File file = new File("/storage/emulated/0/my.html");
Log.i(TAG, "*************Http-response****************");
if (file != null && file.exists()) {
String line="HTTP/1.1 200 OK \r\n";
Log.i(TAG,"line="+line);
//sout.writeChars(line);
sout.write(line.getBytes());//用字节传输，不能用字符，浏览器无法解析
// String header="Content-Type: application/vnd.android.package-archive; charset=utf-8 \r\n"
String header="Content-Type: application/octet-stream; charset=utf-8 \r\n"
+ "Content-Disposition: attachment; filename=" + fileName+ "\r\n"
+ "Content-length: "+file.length()+" \r\n\r\n";
Log.i(TAG,"header="+header);
sout.writeBytes(header);
fis = new FileInputStream(file);
/**
byte[] bytes = new byte[BUFFER_SIZE];
int ch = fis.read(bytes, 0, BUFFER_SIZE);;
while (ch!=-1) { //ch==-1表示读到末尾了
sout.write(bytes, 0, ch); //写出到浏览器
Log.i(TAG, "ch is:" + ch);
ch = fis.read(bytes, 0, BUFFER_SIZE);//再读会接上一次读的位置往下读，如果读到末尾就会返回-1，终止输出
} **/
byte[] buff = new byte[1024];
int size;
while ((size = fis.read(buff)) != -1) {
Log.i(TAG, "size is:" + size);
sout.write(buff, 0, size);
}
sout.flush();
sout.close();
fis.close();
} else {
// file not found
String errorMessage = "HTTP/1.1 404 File Not Found \r\n"
+ "Content-Type: text/html \r\n"
+ "Content-Length: 23 \r\n"
+ "\r\n"
+ "<h1>File Not Found</h1>";
System.out.println(errorMessage);
output.write(errorMessage.getBytes());
}
} catch (Exception e) {
Log.i(TAG, "sendAPK apk has error");
e.printStackTrace();
} finally {
Log.i(TAG, "finally here.............");
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (sout != null) {
try {
sout.flush();
sout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
这个APK的路径是当前APK在手机里面的路径，然后css和html和image图片放在assets目录下的share目录
******\app\src\main\assets\share\
(转) Android 客户端与 PC 服务端 socket 通信接收与发送图片
Android 客户端与 PC 服务端 socket 通信接收与发送图片 (终结者)
https://blog.csdn.net/CSDN_zhi/article/details/71077050
android 使用 socket 实现实时视频
https://www.cnblogs.com/lijiongquan/p/4729445.html
视频多少帧时才不卡顿
https://blog.csdn.net/XYKenny/article/details/94589494
app 接收并显示视频：
public void OpenTCP() {
System.out.println("***startTCP***" + Ip + ":" + tcpPort);
tcpsendData = "1";
try {
tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
// tcpSocket.setSoTimeout(1000);
} catch (Exception ex) {
Log.e("TCP连接错误:", "TCP连接错误");
Log.e("TCP连接错误:", ex.toString());
ex.printStackTrace();
}
if (tcpSocket != null) {
new Thread(TcpReceiver).start();
}
}
Runnable TcpReceiver = new Runnable() {
@Override
public void run() {
byte[] buffer0=null;
byte[] buffer=null;
System.out.println("***startTCP---tcpPort***" + tcpPort);
while (true) {
try {
// tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
//接收数据
buffer0 = new byte[10];
InputStream inputStream0 = tcpSocket.getInputStream();
DataInputStream input0 = new DataInputStream(inputStream0);
int length0 = input0.read(buffer0);
if (length0 <10) {
//发送数据
OutputStream OutStream = tcpSocket.getOutputStream();
OutStream.write("1".getBytes());
OutStream.flush();
String lengthMsg = new String(buffer0, 0, length0, "gb2312");
Log.e("lengthMsg:", "" + lengthMsg);
int size = Integer.parseInt(lengthMsg);
buffer = new byte[size];
int len = 0;
int offset=0;
while (len < size) {
offset=size-len;
if(offset>=1024*5){
offset=1024*5;
}
len += input0.read(buffer, len, offset);
// System.out.println("***len***" + len);
}
System.out.println("***buffer.length***" + buffer.length);
final Bitmap bitmap = BitmapFactory.decodeByteArray(buffer, 0, buffer.length);
runOnUiThread(new Runnable() {
@Override
public void run() {
image.setImageBitmap(bitmap);
}
});
// if (!bitmap.isRecycled()) {
// bitmap.recycle();
// }
} else {
continue;
}
// tcpSocket.close();
} catch (IOException e) {
Log.e("接收错误:", e.toString());
runOnUiThread(new Runnable() {
@Override
public void run() {
Toast.makeText(MainActivity_tcp.this, "网络接收断开", Toast.LENGTH_SHORT).show();
}
});
try {
tcpSocket = new Socket(Ip, Integer.parseInt(tcpPort));
}catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
};
android socket 服务端
想要一些 android socket 服务端代码资料：
客户端能一直链接服务端 并且在 服务端 有注册
android socket 问题 android 客户端 与java服务器socket通信 ，当服务器突然中断后
1、android socket 问题 android 客户端 与java服务器socket通信 ，当服务器突然中断后.
android 客户端怎么知道 中断了，怎么自动进行重新连接.
2、当客户端从没有网络 恢复至有网络，怎么去连接服务器。
Android socket实现原理详解 服务端和客户端如何搭建
本文实例为大家分享了Android socket的实现原理，供大家参考，具体内容如下
Socket套接字
是网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
socket实现的原理机制：
1、通信的两端都有Socket
2、网络通信其实就是Socket间的通信
3、数据在两个Socket间通过IO传输
建立Socket(客户端)和ServerSocket(服务器端)
建立连接后，通过Socket中的IO流进行数据的传输
关闭socket
同样，客户端与服务器端是两个独立的应用程序。
服务器端思路
1、建立服务器端的socket服务，需要一个端口
2、服务端没有直接的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
3、通过客户端获取流对象的方法,读取数据或者写入数据
4、如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的
服务端实现代码
// 创建服务器端
ServerSocket server = new ServerSocket(5555);
while(true){
// 等待连接
Socket accept = server.accept();
OutputStream outputStream = accept.getoutputStream();
outputStream.write("你好，我是服务器！\r\n".getBytes());
outputStream.flush();
// 读取数据
InputStream inputStream = accept.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(
inputStream));
System.out.println("服务器：" + reader.readLine());
outputStream.close();
inputStream.close();
}
客户端思路
1、建立客户端的Socket服务,并明确要连接的服务器。
2、如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
3、通过Socket对象的方法,可以获取这两个流
4、通过流的对象可以对数据进行传输
5、如果传输数据完毕,关闭资源
客户端实现代码
//创建套接字 确定要连接的服务器ip与端口口
Socket socket=new Socket("172.17.23.77",5555);
InputStream inputStream = socket.getInputStream();
BufferedReader br=new BufferedReader(new InputStreamReader(inputStream));
String readLine = br.readLine();
System.out.println("客户端："+readLine);
//向服务器发送消息
OutputStream outputStream = socket.getoutputStream();
outputStream.write("你好\r\n".getBytes());
outputStream.flush();
outputStream.close();
inputStream.close();
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。
关于Android之浏览器作为客户端访问手机socket作为服务端下载图片和网页和APK的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于(转) Android 客户端与 PC 服务端 socket 通信接收与发送图片、android socket 服务端、android socket 问题 android 客户端 与java服务器socket通信 ，当服务器突然中断后、Android socket实现原理详解 服务端和客户端如何搭建的相关知识，请在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
