Window与Android的socket通信_图片

 

这是我学习Android的第一个小项目，稍作记录，也希望大家看了能多帮我提出宝贵意见，共同交流进步。^_^

原型是基于C++的，只提供了最基本的socket连接功能。在此基础上，增加了以二进制流收发文件(.jpg)的方法，并且在client端显示收到的图片。

一. SOCKET连接

SERVER端：

 

int CppServer::initialize()
{
    int iResult = 0;

    ListenSocket = INVALID_SOCKET;
    ClientSocket = INVALID_SOCKET;
    result = NULL;
    rcvbuflen = DATA_BUFLEN - 1;
    sendbuflen = DATA_BUFLEN - 1;
    quit = false;
    initialized = false;

    memset(rcvbuf, 0x00, sizeof(rcvbuf));
    memset(sendbuf, 0x00, sizeof(sendbuf));

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return -1;
    }

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    // Resolve the server address and port
    iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
    if ( iResult != 0 ) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return -1;
    }

    // Create a SOCKET for connecting to server
    ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (ListenSocket == INVALID_SOCKET) {
        printf("socket failed with error: %ld\n", WSAGetLastError());
        freeaddrinfo(result);
        WSACleanup();
        return -1;
    }

    // Setup the TCP listening socket
    iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
    if (iResult == SOCKET_ERROR) {
        printf("bind failed with error: %d\n", WSAGetLastError());
        freeaddrinfo(result);
        closesocket(ListenSocket);
        WSACleanup();
        return -1;
    }

    freeaddrinfo(result);

    iResult = listen(ListenSocket, SOMAXCONN);
    if (iResult == SOCKET_ERROR) {
        printf("listen failed with error: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return -1;
    }

    // Accept a client socket
    ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed with error: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return -1;
    }
    printf("Client have connected.\n");

    initialized = true;
    return 0;
}

 

这部分代码是C/C++ socket编程中流程化的部分，可以直接借鉴。其中的accept函数是阻塞的，当有client发来连接请求时，才往下执行。

CLIENT端：

public class SocketClient extends Activity {
    private final String HOST = "10.0.2.2";    // Android虚拟机访问本地，不用127.0.0.1
    private final int PORT = 9527;        // 访问Server使用的端口号
    protected void onCreate(Bundle savedInstanceState) {
        new Thread() {
            public void run() {
                Socket s = null;
                try {
                    // Connect to server
                    s = new Socket(HOST, PORT);
                    // 更多处理：接收发送图片，显示图片
                } catch (UnknownHostException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        s.close(); // 断开连接
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

    // 更多私有方法：提供显示图片用到的Handler，判断收发终了标志等
}

以上是client端连接server socket的代码，核心只有

s = new Socket(HOST, PORT);

其他部分说明程序的结构。

※在Android 4 之后的版本中，不能在UI线程中使用连接socket这种阻塞式的方法，这将导致画面失去响应。因此这里在一个新启动的线程中发起socket连接。

二. SERVER端向CLIENT端发送图片

SERVER端：

int comm::sendData(char *file)
{
    int iResult = 0;

    if(0 > _access(file, 0)) {
        // If resource file don't exist, send its name to client.
        iResult = send(ClientSocket, file, strlen(file), 0);
        printf("--File %s is not accessable, check please.\n", file);
        return -1;
    } else {
        FILE *rcFile = NULL;

        Beep(500, 350);
        // Open the resource file.
        rcFile = fopen(file, "rb+");
        if(!rcFile) {
            printf("Failed to open resource file: %s\n", file);
            return -1;
        }

        // Send resource file with 1024 byte per piece.
        memset(sendbuf, 0x00, sizeof(sendbuf));
        while(fread(sendbuf, sendbuflen, 1, rcFile) >= 0) {
            if(SOCKET_ERROR == send(ClientSocket, sendbuf, sendbuflen, 0)) {
                closesocket(ClientSocket);
                WSACleanup();
                return -1;
            }
            if(feof(rcFile)) {
                break;
            }
        }
        fclose(rcFile);

        // Send end mark to client.
        memset(sendbuf, 0x00, sizeof(sendbuf));
        strncpy_s(sendbuf, ENDMARK, sendbuflen);
        if(SOCKET_ERROR == send(ClientSocket, sendbuf, sendbuflen, 0)) {
            closesocket(ClientSocket);
            WSACleanup();
            return -1;
        }

    }

    printf("--File %s have been sended successfully.\n", file);
    return 0;
}

fread函数的原型是：

size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;
Params:
    buffer            // 存放从文件读取的内容，这里是char*类型
    size               // 读取内容元素的单位大小，单位是字节
    count            // 读取内容元素的数目（最大值）
                         // 个人理解前三个参数的关系为：buffer.size >= size * count
    stream          // 数据来源文件
Returns:
    // 实际读取内容元素的数目，返回值小于count说明到达文件末尾或者发生错误。我们的count==1，所以小于等于0时，为这种情况。

这个函数多次调用可以顺序读取stream指向的文件，直到文件末尾。使用feof函数判断是否到达文件结尾。

对于第一个参数void*到底选用什么类型，看到网上有朋友在这里定义了结构体，用结构体封装文件的每个片段，这种做法的好处是添加一些标记字段。这种做法虽然很标准，但是并不适合这个project。

在SERVER端有封装操作，CLIENT端必须有对应的解析操作。而我们都知道C/C++中，即使是基本数据类型，也有宽度和编译器有关系的，比如long，这无疑增加了用java解析数据包的难度，还要考虑到内存是否对齐等等问题，相当复杂且容易出错。因此这里使用简单的char来作为发送的buffer类型，它与java的byte类型具有相同且固定的宽度，方便数据解析（事实上这种情况已经简单到不需要解析了），对于一些必要的标记，比如终了标记OVER，单独发送一次，在client端做判断即可。

CLIENT端：

// Receive picture
private void rcvData() {
    try {
        // DataInputStream提供的read方法很适合读取byte[]类型数据
        sis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
        // 打开Android内部存储空间的文件，必须使用openFileInput/openFileOutput
        // 可以直接返回FileInputStream/FileOutputStream，它们提供的read/write方法都对byte[]很友好
        fos = openFileOutput(tempFileName, MODE_PRIVATE);

        while (true) {
            Arrays.fill(buf,(byte) 0);
            int readnum = sis.read(buf, 0, buflen);
            if (ifEnd(buf) || 0>readnum) {
                break;
            }
            fos.write(buf);// write byte[] into file
            fos.flush();
        }
    } catch (UnknownHostException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            sis.close();
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // getFilesDir() + "/" 可以用来读取程序内部存储空间的files目录
    // 取到的路径为：/data/data/$appname/files
    // ※最后是不带斜线的
    bitmap = BitmapFactory.decodeFile(getFilesDir()+"/"+tempFileName, null);
    handler.sendEmptyMessage(0);
}

// Check received data for whether it's end mark.
private boolean ifEnd(byte[] data) {
    String rcvData;
    try {
        // 这里把取到的byte[]按照ISO-8859-1转换为String
        // byte[]每个单位1字节，String每个单位2字节
        rcvData = new String(data, "ISO-8859-1");
        // buffer可能不为空，在ENDMARK后还有其他数据，因此不用equals，改用startsWith
        if(rcvData.startsWith(ENDMARK)) {
            Log.i("DOCK", "ENDMARK found.");
            return true;
        }
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    
    return false;
}

// 在socket线程之外使用handler，来改变activity上的内容
private Handler handler = new Handler() {
    public void handleMessage(Message msg) {
        // 一般的用法是switch XXX，我偷懒了~
        super.handleMessage(msg);
        showField.setImageBitmap(bitmap);
    }
};

这部分是整个过程中耗时最多的部分，这次学到的东西都写在注释里面了。

需要交代的是Android的文件存放方式，请参考（感谢经验提供者）

http://www.open-open.com/lib/view/open1330957864280.html

三. CLIENT端向SERVER端发送图片

SERVER端：

int CppServer::recvData(char *file)
{
    int returnValue=0;
    int iResult = 1;
    FILE *rcvFile = NULL;

    if(0 == _access(file, 0)) {
        // If resource file already exist, print warning message.
        printf("----File %s have already existed. It will be clear.\n", file);
    }

    rcvFile=fopen(file, "wb+");
    if(!rcvFile) {
        printf("Failed to open rcvFile. %s\n", file);
        return -1;
    }

    while(iResult > 0) {
        memset(rcvbuf, 0x00, DATA_BUFLEN);
        iResult = recv(ClientSocket, rcvbuf, rcvbuflen, 0);

        if(0 == strncmp(rcvbuf, "over", sizeof(rcvbuf))) {
            //printf("Receive end signal from client.\n");
            returnValue = 1;
            break;
        }
        
        if (iResult > 0) {
            fwrite(rcvbuf, rcvbuflen, 1, rcvFile);
        } else if (iResult == 0) {
            printf("Connection closed response...\n");
            returnValue = 0;
            break;
        } else {
            printf("recv failed with error: %d\n", WSAGetLastError());
            closesocket(ClientSocket);
            WSACleanup();
            returnValue = -1;
            initialized = false;
            break;
        }
    }
    
    fclose(rcvFile);
    printf("--Data have been received successfully. Write data in file %s\n", file);
    return returnValue;
}

fwrite可以类比fread函数，参数与返回值的意义是类似的。

CLIENT端：

// Send picture.
private void rcvData() {
    int readNum = 0;
    fis = openFileInput(tempFileName);
    sos = new DataOutputStream(s.getOutputStream());
    while (true) {
        Arrays.fill(buf, (byte)0);
        readNum = fis.read(buf);
        if(0 > readNum) {
            break;
        }
        sos.write(buf, 0, readNum);
    }
    sendEndMark(sos);
}

整个client向server发送的过程，与server向client发送数据是类似的，只不过是read、write，inputstram、outputstream的变化，这里就不再分析。