从PC上读取收到Android手机的数据

Question

我需要实现从Android设备读取数据的解决方案，通过USB线连接到PC。即连接到PC的手机将通过NFC通过另一个Android设备接收数据，其中PC - C#程序必须从插入的Android手机中读取收到的数据下方。

[PC]<----(2. read data) usb cable----[android phone]<-----NFC (1. transmit string)-----[android phone]

我已通过NFC实现了数据传输，只需输入此处的链接 - http://developer.android.com/guide/topics/connectivity/nfc/nfc.html即可。但是，当我通过NFC收到内容（一个小字符串消息）时，我可以找到关于从Android手机读取数据的任何参考。

我尝试了很多谷歌搜索，但由于我是这个领域的新手而空手而归。如果您的专家可以指出一些关于如何实现此任务的教程/代码片段/参考资料，我将非常感激。

如果这个问题重复或含糊，请原谅。我是这个领域的新手，并不知道寻找在线帮助的关键字。

谢谢：）

Answer 1

我认为这是你应该做的。收到NFC数据后，将其存储在预定位置的SD卡中。同时运行一个连续的线程来为该特定文件执行adb pull。如果adb pull下载了该文件，那么您就完成了。

Answer 2

首先，我不是C＃程序员，所以请原谅我从MSDN examples page复制粘贴C＃套接字客户端。

基本上，如果您想通过USB与Android应用程序进行通信，您需要指示您的手机通过adb（Android Debug Bridge）创建端口转发，然后您可以使用普通的TCP / IP套接字建立与客户进行流媒体沟通。

首先，您必须在PC上安装正确的驱动程序（您可以在制造商的网站上找到它们），这样当您运行adb devices时，您的手机就会被正确识别：

C:\adt-bundle-windows-x86-20140321\sdk\platform-tools>adb devices
List of devices attached
039d78fa2518e606        device

接下来您需要在Android端设置端口转发，以便PC上本地主机上/之间的套接字连接可以正确地转发到手机上的本地主机。这也是通过adb：

完成的

C:\adt-bundle-windows-x86-20140321\sdk\platform-tools>adb forward tcp:6000 tcp:6000

验证它是否成功：

C:\adt-bundle-windows-x86-20140321\sdk\platform-tools>adb forward --list
039d78fa2518e606 tcp:6000 tcp:6000

现在您可以在Android端创建常规套接字服务器应用程序。我很抱歉这个例子非常简单（我很晚才注意到这个问题，并且没有时间来实现正确的通信协议）。但是这应该向您展示如何在客户端和主机之间传输字符串，并且您可以实现必要的循环，或者在需要时实现更复杂的传输协议。

基本上这只是默认的Android项目，添加了1个类，它在一个单独的线程中运行（GUI和网络活动不能在同一个线程中运行）。

所以，我们的MainActivity.java看起来像这样：

package com.example.dataexchange;

import android.support.v7.app.ActionBarActivity;
import android.support.v7.app.ActionBar;
import android.support.v4.app.Fragment;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.os.Build;

public class MainActivity extends ActionBarActivity {

SocketHandler server;

@Override
protected void onCreate(Bundle savedInstanceState) {

    Log.v("jlumme", "Main/ start network task");

    new Thread(new Runnable() {
        public void run() {
            server = new SocketHandler(6000);
            server.run();
        }
    }).start();

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState == null) {
        getSupportFragmentManager().beginTransaction()
                .add(R.id.container, new PlaceholderFragment())
                .commit();
    }
}


@Override
public boolean onCreateOptionsMenu(Menu menu) {

    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle action bar item clicks here. The action bar will
    // automatically handle clicks on the Home/Up button, so long
    // as you specify a parent activity in AndroidManifest.xml.
    int id = item.getItemId();
    if (id == R.id.action_settings) {
        return true;
    }
    return super.onOptionsItemSelected(item);
}

/**
 * A placeholder fragment containing a simple view.
 */
public static class PlaceholderFragment extends Fragment {

    public PlaceholderFragment() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View rootView = inflater.inflate(R.layout.fragment_main, container, false);
        return rootView;
    }
}
}

通常情况下，我们只是在一个单独的线程中启动SocketHandler类。 SocketThread类看起来像这样：

package com.example.dataexchange;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

import android.util.Log;

public class SocketHandler implements Runnable {

private Socket socket;
private ServerSocket server;
private PrintWriter out;
private BufferedReader in;

private int socketPort;
SocketHandler(int port) {
    socketPort = port;
}

@Override
public void run() {

    Log.v("jlumme", "Socket thread has started");
    String inputText;

    // TODO Auto-generated method stub
    try {
        Log.v("jlumme", "Starting socket server ");

        server = new ServerSocket(6000);
        socket = server.accept();

        Log.v("jlumme", "Client connected");

        out = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())),true); 
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));                

        while ((inputText = in.readLine()) != null) {
            Log.v("jlumme", "Received:" + inputText);
            out.println("you wrote:" + inputText);
        }

        Log.v("jlumme", "connection established");

    } catch (IOException ioe) {
        ioe.printStackTrace();
    }
}
}

基本上在run()方法中，您启动一​​个新的SocketServer，然后开始等待客户端。一旦客户端连接，您可以设置两种方式的流缓冲区，并开始等待一条消息（以换行符结尾的任何内容，'\n'都可以）。

在C＃方面，应用程序非常简单。它连接到localhost端口6000并发送一行：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

public class SynchronousSocketClient
{

public static void StartClient() {
    // Data buffer for incoming data.
    byte[] bytes = new byte[1024];

    // Connect to a remote device.
    try {

        IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6000);

        // Create a TCP/IP  socket.
        Socket sender = new Socket(AddressFamily.InterNetwork, 
            SocketType.Stream, ProtocolType.Tcp );

        // Connect the socket to the remote endpoint. Catch any errors.
        try {
            sender.Connect(remoteEP);

            Console.WriteLine("Socket connected to {0}",
                sender.RemoteEndPoint.ToString());

            // Encode the data string into a byte array.
            byte[] msg = Encoding.ASCII.GetBytes("This is a test\n");

            // Send the data through the socket.
            int bytesSent = sender.Send(msg);

            // Receive the response from the remote device.
            int bytesRec = sender.Receive(bytes);
            Console.WriteLine("Echoed test = {0}",
                Encoding.ASCII.GetString(bytes,0,bytesRec));

            // Release the socket.
            sender.Shutdown(SocketShutdown.Both);
            sender.Close();

        } catch (ArgumentNullException ane) {
            Console.WriteLine("ArgumentNullException : {0}",ane.ToString());
        } catch (SocketException se) {
            Console.WriteLine("SocketException : {0}",se.ToString());
        } catch (Exception e) {
            Console.WriteLine("Unexpected exception : {0}", e.ToString());
        }

    } catch (Exception e) {
        Console.WriteLine( e.ToString());
    }
}

public static int Main(String[] args)
{
    StartClient();
    return 0;
}
}

如果执行C＃程序时，它会向客户端发送this is a test字符串，客户端将回复它：

c:\Visual Studio 2013\Projects\ConsoleApplication2\ConsoleApplication2\bin\Debug>ConsoleApplication2.exe
Socket connected to 127.0.0.1:6000
Echoed test = you wrote:This is a test

我想在赏金结束之前到达截止日期，所以目前没有正确的消息处理，c＃会立即退出（而Android方面会因此而感到困惑），我为此道歉。但是我认为一旦你运行这个例子，你就可以轻松地将它扩展到你的需求，并实现必要的逻辑来处理终端和其他东西。

希望有所帮助

Answer 3

另一种方法是监视logcat输出：您的应用程序可以将消息写入logcat输出，该输出通过您的应用程序进行监视。

来自this SO question的示例代码以及this other question

上的其他讨论

但@Sagar提到的内容似乎也是明智的，如果做得好，可以防止任何数据丢失。使用logcat方法，如果它断开连接，那么在断开连接期间传输的任何数据都将丢失。

Answer 4

您可以设置HTTPListener，然后在预定义的端口上向目标PC的IP地址发出HTTP请求。您需要提前配置Android应用程序，以便将请求发送到特定IP地址或扫描一系列IP地址以查找正确的IP地址（在这种情况下，您的侦听器需要响应＆＃ 34;搜索＆＃34;类型请求。）

基本上，您在C＃中创建了一个mini-REST服务。然后，您可以issue REST API calls from your Android app。