windows应用程序和android应用程序之间的通信

我很抱歉，如果这是一个非常普遍的问题，但我不知道从哪里开始，所以我正在寻找想法

我有一个windows应用程序（乐谱编辑），目前我正在将它移植到Andriod上，它进展顺利

我想添加一项功能，使windows应用程序中创建的文档可以发送到android平板电脑用户。我想知道，假设两者都在同一个本地网络上，我该如何在Android上编写某种监听器，让windows端可以打开一个套接字或其他东西并向其发送数据

---

谢谢

我认为直接通过本地网络发送文件不是最好的方法。您很容易收到许多用户抱怨共享不起作用。。这主要是由于他们自己的网络配置问题

为什么不使用DropBox这样的服务来实现文件共享呢

DropBox等服务提供了简单的API，可以在应用程序中使用，以便将文件保存到远程文件夹，并从远程文件夹读取文件

这样，用户就不必在同一个网络中。。实现文件共享的大部分繁重工作都将由一个专注于此的服务来完成

添加：

如果您不想为像Dropbox这样的单独服务需要帐户，请考虑此方法：在您自己的Web服务器上实现一个非常简单的Dropbox类服务。制作一个简单的脚本，允许用户通过HTTP匿名上传文件到您的服务器。上传后，他们将收到该文件的5位id，或其他他们可以共享的链接。从第二个应用程序使用此id或链接时，可以下载文件（再次通过HTTP）。如果几小时后自动从服务器删除文件，则不会耗尽空间

您可以用大约20行PHP代码实现这样的服务。所需的应用程序代码非常简单（因为它只依赖于HTTP）。如果你担心网络服务器的成本，你可以从大约5美元/月的价格中获得一台，甚至可以使用免费服务，如谷歌应用引擎（如果你的带宽+空间要求较低，则免费）

---

文件上传的代码。下载应该足够简单，可以单独完成。关于定期文件删除-显而易见的方法是，但我认为没有它很容易管理。每当你接受一个新的上传（在PHP脚本中），检查所有下载并删除旧的。

我写了一个小东西，这样我的windows应用程序就可以在本地网络上找到我的android应用程序的实例，在这里。这是第一个android代码

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;

import android.os.AsyncTask;
import android.util.Log;

public class TabSyncServer extends AsyncTask<Void, Void, Void> {

    ServerSocket mServerSocket = null;
    Socket mSocket = null;
    DataInputStream mDataInputStream = null;
    DataOutputStream mDataOutputStream = null;

    @Override
    protected void onPreExecute() {

        try {
            mServerSocket = new ServerSocket(2112);
            //System.out.println("Listening :2112");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    protected Void doInBackground(Void... args) {
        byte[] bytebuf = new byte[1024];
        while (true) {
            try {

                mSocket = mServerSocket.accept();
                mDataInputStream = new DataInputStream(mSocket.getInputStream());
                mDataOutputStream = new DataOutputStream(mSocket.getOutputStream());
                Log.d("TabSyncServer", "ip: " + mSocket.getInetAddress());
                mDataInputStream.read(bytebuf);

                String str = new String(bytebuf, "UTF8");
                Log.d("TabSyncServer", "message: " + str);
                if(str.contains("Hello Android")) {
                    Log.d("TabSyncServer", "sending reply");
                    mDataOutputStream.writeBytes("Hello Windows");
                }

                // 

            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } finally {
                if (mSocket != null) {
                    try {
                        mSocket.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (mDataInputStream != null) {
                    try {
                        mDataInputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (mDataOutputStream != null) {
                    try {
                        mDataOutputStream.close();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }

    }

}

import java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.util.array；
导入android.os.AsyncTask；
导入android.util.Log；
公共类TabSyncServer扩展异步任务{
ServerSocket mServerSocket=null；
套接字mSocket=null；
DataInputStream mDataInputStream=null；
DataOutputStream mDataOutputStream=null；
@凌驾
受保护的void onPreExecute（）{
试一试{
mServerSocket=新的ServerSocket（2112）；
//System.out.println（“侦听：2112”）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
@凌驾
受保护的Void doInBackground（Void…args）{
byte[]bytebuf=新字节[1024]；
while（true）{
试一试{
mSocket=mServerSocket.accept（）；
mDataInputStream=新的DataInputStream（mSocket.getInputStream（））；
mDataOutputStream=新的DataOutputStream（mSocket.getOutputStream（））；
Log.d（“TabSyncServer”，“ip:+mSocket.getInetAddress（））；
mDataInputStream.read（bytebuf）；
字符串str=新字符串（bytebuf，“UTF8”）；
Log.d（“TabSyncServer”，“message:+str”）；
if（str.contains（“Hello Android”））{
Log.d（“TabSyncServer”，“发送回复”）；
mDataOutputStream.writeBytes（“Hello Windows”）；
}
// 
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}最后{
if（mSocket！=null）{
试一试{
mSocket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
if（mDataInputStream！=null）{
试一试{
mDataInputStream.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
if（mDataOutputStream！=null）{
试一试{
mDataOutputStream.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
}
}
}

和windows MFC代码

    void CMainFrame::OnBrowseMobile() {


    CMobileSync* con = new CMobileSync();
    CString ipaddr_base;
    int my_last_digit;
    if(!con->getMyIP(ipaddr_base, my_last_digit)) {
        setMobilePath("Can't find local network");
        return;
    }


    for(int i=1 ; i<98 ; i++) {
        if(i==my_last_digit)
            continue;       // don;t check self

        CString ipaddr; ipaddr.Format("%s.%d", ipaddr_base, i);
        bool res = con->ConnectToHost(ipaddr);
        if(res) {
            res = con->SendMsg ("Hello Android");

            if(res) {
                TRACE1("send ok %s\n",ipaddr.GetBuffer());
#define RD_BUF_LEN 80
                char buffer[RD_BUF_LEN];
                if(con->ListenOnPortBlocking(buffer, RD_BUF_LEN)) {
                    if(strncmp(buffer, "Hello Windows", 12)==0) {
                        TRACE1("reply ok %s", buffer);
                        setMobilePath(ipaddr);
                        con->CloseConnection ();
                        return;
                    }
                }
            } else {
                TRACE("send FAILED\n");
            }
        }
        con->CloseConnection ();
    }
    setMobilePath("No TabTrax on local network");
}

#include "stdafx.h"
#include <winsock.h>
#include "MobileSync.h"

#define TTPORT 2112
bool CMobileSync::getMyIP(CString& ipaddr_front, int& ipaddr_lastdigit)
{
    char szBuffer[1024];

    #ifdef WIN32
    WSADATA wsaData;
    WORD wVersionRequested = MAKEWORD(2, 0);
    if(::WSAStartup(wVersionRequested, &wsaData) != 0)
        return false;
    #endif


    if(gethostname(szBuffer, sizeof(szBuffer)) == SOCKET_ERROR)
    {
      #ifdef WIN32
      WSACleanup();
      #endif
      return false;
    }

    struct hostent *host = gethostbyname(szBuffer);
    if(host == NULL)
    {
      #ifdef WIN32
      WSACleanup();
      #endif
      return false;
    }

    //Obtain the computer's IP
    unsigned char b1, b2, b3, b4;
    b1 = ((struct in_addr *)(host->h_addr))->S_un.S_un_b.s_b1;
    b2 = ((struct in_addr *)(host->h_addr))->S_un.S_un_b.s_b2;
    b3 = ((struct in_addr *)(host->h_addr))->S_un.S_un_b.s_b3;
    b4 = ((struct in_addr *)(host->h_addr))->S_un.S_un_b.s_b4;

    ipaddr_front.Format("%d.%d.%d", b1, b2, b3);
    ipaddr_lastdigit = b4;
    #ifdef WIN32
    WSACleanup();
    #endif
    return true;
}

//CONNECTTOHOST – Connects to a remote host
bool CMobileSync::ConnectToHost(const char* IPAddress)
{
    //Start up Winsock…
    WSADATA wsadata;

    int error = WSAStartup(0x0202, &wsadata);

    //Did something happen?
    if (error)
        return false;

    //Did we get the right Winsock version?
    if (wsadata.wVersion != 0x0202)
    {
        WSACleanup(); //Clean up Winsock
        return false;
    }

    //Fill out the information needed to initialize a socket…
    SOCKADDR_IN target; //Socket address information

    target.sin_family = AF_INET; // address family Internet
    target.sin_port = htons (TTPORT); //Port to connect on
    target.sin_addr.s_addr = inet_addr (IPAddress); //Target IP

    mSocket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); //Create socket
    if (mSocket == INVALID_SOCKET)
    {
        return false; //Couldn't create the socket
    }  

    //Try connecting...

    if (connect(mSocket, (SOCKADDR *)&target, sizeof(target)) == SOCKET_ERROR)
    {
        return false; //Couldn't connect
    }

    return true; //Success
}

//CLOSECONNECTION – shuts down the socket and closes any connection on it
void CMobileSync::CloseConnection ()
{
    //Close the socket if it exists
    if (mSocket)
        closesocket(mSocket);
    mSocket=0;

    WSACleanup(); //Clean up Winsock
}

int CMobileSync::SendMsg (char* szpText, int buflen)
{
    if(buflen==0)
        buflen = strlen(szpText);
    int ret = send(mSocket, szpText, buflen, 0);
    TRACE1("CMobileSync::SendMsg sent %d bytes\n", ret);
    return ret;
}

WSADATA w;

//LISTENONPORT – Listens on a specified port for incoming connections 
//or data
bool CMobileSync::ListenOnPortBlocking(char* buffer, int buflen)
{
    //Now we can start listening (allowing as many connections as possible to  
    //be made at the same time using SOMAXCONN). You could specify any 
    //integer value equal to or lesser than SOMAXCONN instead for custom 
    //purposes). The function will not //return until a connection request is 
    //made
    // listen(s, SOMAXCONN);

    memset(buffer, 0, sizeof(buffer)); //Clear the buffer

    int iTimeout = 1600;
    setsockopt( mSocket,  SOL_SOCKET, SO_RCVTIMEO, (const char *)&iTimeout, sizeof(iTimeout));

    //Put the incoming text into our buffer
    int ret = recv (mSocket, buffer, buflen-1, 0); 

    //Don't forget to clean up with CloseConnection()!

    if(ret != SOCKET_ERROR)
        return true;

    int err = WSAGetLastError();
    return false;
}

void CMainFrame:：OnBrowseMobile（）{
CMobileSync*con=新的CMobileSync（）；
CString ipaddr_基地；
输入我的最后一位数字；
如果（！con->getMyIP（ipaddr\u base，my\u last\u digital））{
setMobilePath（“找不到本地网络”）；
返回；
}
对于（int i=1；i连接到主机（ipaddr）；
如果（res）{
res=con->SendMsg（“你好，安卓”）；
如果（res）{
TRACE1（“发送确定%s\n”，ipaddr.GetBuffer（））；
#定义RD_BUF_LEN 80
字符缓冲区[RD_BUF_LEN]；
if（con->listenoportblocking（缓冲区，RD\u BUF\u LEN））{
if（strncmp（缓冲区，“你好窗口”，12）==0）{