Android与计算机的USB串行通信

我需要创建一个应用程序，从计算机接收文本数据并将其传输到Android应用程序。我找到了这个：。 我用这个例子来看看，如果我像这样开始，我可以看到一个通信，然后，当我在我的手机上使用时，似乎1设备发现供应商1519产品0020没有驱动程序。就像没有发生通讯，也没有找到电脑一样

代码如下：

SerialConsoleActivity.java--

package com.hoho.android.usbserial.examples；
导入android.app.Activity；
导入android.content.Context；
导入android.content.Intent；
导入android.os.Bundle；
导入android.util.Log；
导入android.widget.ScrollView；
导入android.widget.TextView；
导入com.hoho.android.usbserial.driver.UsbSerialDriver；
导入com.hoho.android.usbserial.util.hextump；
导入com.hoho.android.usbserial.util.SerialInputInputManager；
导入java.io.IOException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
/**
*监视单个{@link UsbSerialDriver}实例，显示所有数据
*收到。
*
*@作者迈克·韦克莉(opensource@hoho.com)
*/
公共类SerialConsoleActivity扩展了活动{
private final String TAG=SerialConsoleActivity.class.getSimpleName（）；
/**
*驱动程序实例，通过
*{@link#show（上下文，UsbSerialDriver）}。
*
*

*这是一个狡猾的黑客；使用
*参数以{@link#startActivity（Intent）}意图传入
*因为这两个活动将在同一时间运行，所以可以不受影响
*这是一个简单的演示。
*/
专用静态UsbSerialDriver sDriver=null；
私有文本视图mTitleTextView；
私有文本视图mDumpTextView；
私有滚动视图mScrollView；
private final executor service mExecutor=Executors.newSingleThreadExecutor（）；
专用串行输入输出管理器mSerialIoManager；
私有最终SerialInputOutputManager.Listener mListener=
新建SerialInputOutManager.Listener（）{
@凌驾
公共void onRunError（异常e）{
Log.d（标签“Runner stopped”）；
}
@凌驾
公共无效onNewData（最终字节[]数据）{
SerialConsoleActivity.this.runOnUiThread（new Runnable（））{
@凌驾
公开募捐{
SerialConsoleActivity.this.updateReceivedData（数据）；
}
});
}
};
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.serial_控制台）；
mTitleTextView=（TextView）findViewById（R.id.demoTitle）；
mDumpTextView=（TextView）findViewById（R.id.consoleText）；
mScrollView=（ScrollView）findViewById（R.id.demoScroller）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
停止管理器（）；
if（sDriver！=null）{
试一试{
sDriver.close（）；
}捕获（IOE异常）{
//忽略。
}
sDriver=null；
}
完成（）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
Log.d（标签，“恢复，sDriver=“+sDriver”）；
if（sDriver==null）{
mTitleTextView.setText（“无串行设备”）；
}否则{
试一试{
sDriver.open（）；
sDriver.setParameters（115200,8，UsbSerialDriver.STOPBITS_1，UsbSerialDriver.PARITY_NONE）；
}捕获（IOE异常）{
Log.e（标签，“设置设备时出错：”+e.getMessage（），e）；
mTitleTextView.setText（“打开设备时出错：+e.getMessage（））；
试一试{
sDriver.close（）；
}捕获（IOE2异常）{
//忽略。
}
sDriver=null；
返回；
}
mTitleTextView.setText（“串行设备：+sDriver.getClass（）.getSimpleName（））；
}
onDeviceStateChange（）；
}
私有void stopIoManager（）{
if（mSerialIoManager！=null）{
Log.i（标记“停止io管理器…”）；
mSerialIoManager.stop（）；
mSerialIoManager=null；
}
}
私人经理（）{
if（sDriver！=null）{
Log.i（标记“启动io管理器…”）；
mSerialIoManager=新的串行输入输出管理器（sDriver，mListener）；
mExecutor.submit（mSerialIoManager）；
}
}
私有无效OnDevicestatechRange（）{
停止管理器（）；
startIoManager（）；
}
私有void updateReceivedData（字节[]数据）{
最终字符串message=“Read”+data.length+“字节：\n”
+hextump.dumphextstring（数据）+“\n\n”；
mDumpTextView.append（消息）；
mScrollView.smoothScrollTo（0，mDumpTextView.getBottom（））；
}
/**
*使用提供的驱动程序实例启动活动。
*
*@param上下文
*@param驱动程序
*/
静态void显示（上下文，UsbSerialDriver驱动程序）{
sDriver=驱动器；
最终意图=新意图（上下文，SerialConsoleActivity.class）；
intent.addFlags（intent.FLAG_ACTIVITY_SINGLE_TOP | intent.FLAG_ACTIVITY_NO_HISTORY）；
背景。开始触觉（意图）；
}
}

抗恶魔性--

导入android.app.Activity；
导入android.content.Context；
导入android.hardware.usb.UsbDevice；
导入android.hardware.usb.UsbManager；
导入android.os.AsyncTask；
导入android.os.Bundle；
导入android.os.Handler；
导入android.os.Message；
导入android.os.SystemClock；
导入android.util.Log；
导入android.view.LayoutInflater；
导入android.view.view；
导入android.view.ViewGroup；
导入android.widget.AdapterView；
导入android.widget.ArrayAdapter；
package com.hoho.android.usbserial.examples;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.widget.ScrollView;
import android.widget.TextView;

import com.hoho.android.usbserial.driver.UsbSerialDriver;
import com.hoho.android.usbserial.util.HexDump;
import com.hoho.android.usbserial.util.SerialInputOutputManager;

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Monitors a single {@link UsbSerialDriver} instance, showing all data
 * received.
 *
 * @author mike wakerly (opensource@hoho.com)
 */
public class SerialConsoleActivity extends Activity {

    private final String TAG = SerialConsoleActivity.class.getSimpleName();

    /**
     * Driver instance, passed in statically via
     * {@link #show(Context, UsbSerialDriver)}.
     *
     * <p/>
     * This is a devious hack; it'd be cleaner to re-create the driver using
     * arguments passed in with the {@link #startActivity(Intent)} intent. We
     * can get away with it because both activities will run in the same
     * process, and this is a simple demo.
     */
    private static UsbSerialDriver sDriver = null;

    private TextView mTitleTextView;
    private TextView mDumpTextView;
    private ScrollView mScrollView;

    private final ExecutorService mExecutor = Executors.newSingleThreadExecutor();

    private SerialInputOutputManager mSerialIoManager;

    private final SerialInputOutputManager.Listener mListener =
            new SerialInputOutputManager.Listener() {

        @Override
        public void onRunError(Exception e) {
            Log.d(TAG, "Runner stopped.");
        }

        @Override
        public void onNewData(final byte[] data) {
            SerialConsoleActivity.this.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    SerialConsoleActivity.this.updateReceivedData(data);
                }
            });
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.serial_console);
        mTitleTextView = (TextView) findViewById(R.id.demoTitle);
        mDumpTextView = (TextView) findViewById(R.id.consoleText);
        mScrollView = (ScrollView) findViewById(R.id.demoScroller);
    }

    @Override
    protected void onPause() {
        super.onPause();
        stopIoManager();
        if (sDriver != null) {
            try {
                sDriver.close();
            } catch (IOException e) {
                // Ignore.
            }
            sDriver = null;
        }
        finish();
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "Resumed, sDriver=" + sDriver);
        if (sDriver == null) {
            mTitleTextView.setText("No serial device.");
        } else {
            try {
                sDriver.open();
                sDriver.setParameters(115200, 8, UsbSerialDriver.STOPBITS_1, UsbSerialDriver.PARITY_NONE);
            } catch (IOException e) {
                Log.e(TAG, "Error setting up device: " + e.getMessage(), e);
                mTitleTextView.setText("Error opening device: " + e.getMessage());
                try {
                    sDriver.close();
                } catch (IOException e2) {
                    // Ignore.
                }
                sDriver = null;
                return;
            }
            mTitleTextView.setText("Serial device: " + sDriver.getClass().getSimpleName());
        }
        onDeviceStateChange();
    }

    private void stopIoManager() {
        if (mSerialIoManager != null) {
            Log.i(TAG, "Stopping io manager ..");
            mSerialIoManager.stop();
            mSerialIoManager = null;
        }
    }

    private void startIoManager() {
        if (sDriver != null) {
            Log.i(TAG, "Starting io manager ..");
            mSerialIoManager = new SerialInputOutputManager(sDriver, mListener);
            mExecutor.submit(mSerialIoManager);
        }
    }

    private void onDeviceStateChange() {
        stopIoManager();
        startIoManager();
    }

    private void updateReceivedData(byte[] data) {
        final String message = "Read " + data.length + " bytes: \n"
                + HexDump.dumpHexString(data) + "\n\n";
        mDumpTextView.append(message);
        mScrollView.smoothScrollTo(0, mDumpTextView.getBottom());
    }

    /**
     * Starts the activity, using the supplied driver instance.
     *
     * @param context
     * @param driver
     */
    static void show(Context context, UsbSerialDriver driver) {
        sDriver = driver;
        final Intent intent = new Intent(context, SerialConsoleActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_NO_HISTORY);
        context.startActivity(intent);
    }

}

  import android.app.Activity;
import android.content.Context;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.TwoLineListItem;

import com.hoho.android.usbserial.driver.UsbSerialDriver;
import com.hoho.android.usbserial.driver.UsbSerialProber;
import com.hoho.android.usbserial.util.HexDump;

import java.util.ArrayList;
import java.util.List;

/**
 * Shows a {@link ListView} of available USB devices.
 *
 * @author mike wakerly (opensource@hoho.com)
 */
public class DeviceListActivity extends Activity {

    private final String TAG = DeviceListActivity.class.getSimpleName();

private UsbManager mUsbManager;
private ListView mListView;
private TextView mProgressBarTitle;
private ProgressBar mProgressBar;

private static final int MESSAGE_REFRESH = 101;
private static final long REFRESH_TIMEOUT_MILLIS = 5000;

private final Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case MESSAGE_REFRESH:
                refreshDeviceList();
                mHandler.sendEmptyMessageDelayed(MESSAGE_REFRESH, REFRESH_TIMEOUT_MILLIS);
                break;
            default:
                super.handleMessage(msg);
                break;
        }
    }

};

/** Simple container for a UsbDevice and its driver. */
private static class DeviceEntry {
    public UsbDevice device;
    public UsbSerialDriver driver;

    DeviceEntry(UsbDevice device, UsbSerialDriver driver) {
        this.device = device;
        this.driver = driver;
    }
}

private List<DeviceEntry> mEntries = new ArrayList<DeviceEntry>();
private ArrayAdapter<DeviceEntry> mAdapter;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    mListView = (ListView) findViewById(R.id.deviceList);
    mProgressBar = (ProgressBar) findViewById(R.id.progressBar);
    mProgressBarTitle = (TextView) findViewById(R.id.progressBarTitle);

    mAdapter = new ArrayAdapter<DeviceEntry>(this, android.R.layout.simple_expandable_list_item_2, mEntries) {
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final TwoLineListItem row;
            if (convertView == null){
                final LayoutInflater inflater =
                        (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                row = (TwoLineListItem) inflater.inflate(android.R.layout.simple_list_item_2, null);
            } else {
                row = (TwoLineListItem) convertView;
            }

            final DeviceEntry entry = mEntries.get(position);
            final String title = String.format("Vendor %s Product %s",
                    HexDump.toHexString((short) entry.device.getVendorId()),
                    HexDump.toHexString((short) entry.device.getProductId()));
            row.getText1().setText(title);

            final String subtitle = entry.driver != null ?
                    entry.driver.getClass().getSimpleName() : "No Driver";
            row.getText2().setText(subtitle);

            return row;
        }

    };
    mListView.setAdapter(mAdapter);

    mListView.setOnItemClickListener(new ListView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            Log.d(TAG, "Pressed item " + position);
            if (position >= mEntries.size()) {
                Log.w(TAG, "Illegal position.");
                return;
            }

            final DeviceEntry entry = mEntries.get(position);
            final UsbSerialDriver driver = entry.driver;
            if (driver == null) {
                Log.d(TAG, "No driver.");
                return;
            }

            showConsoleActivity(driver);
        }
    });
}

@Override
protected void onResume() {
    super.onResume();
    mHandler.sendEmptyMessage(MESSAGE_REFRESH);
}

@Override
protected void onPause() {
    super.onPause();
    mHandler.removeMessages(MESSAGE_REFRESH);
}

private void refreshDeviceList() {
    showProgressBar();

    new AsyncTask<Void, Void, List<DeviceEntry>>() {
        @Override
        protected List<DeviceEntry> doInBackground(Void... params) {
            Log.d(TAG, "Refreshing device list ...");
            SystemClock.sleep(1000);
            final List<DeviceEntry> result = new ArrayList<DeviceEntry>();
            for (final UsbDevice device : mUsbManager.getDeviceList().values()) {
                final List<UsbSerialDriver> drivers =
                        UsbSerialProber.probeSingleDevice(mUsbManager, device);
                Log.d(TAG, "Found usb device: " + device);
                if (drivers.isEmpty()) {
                    Log.d(TAG, "  - No UsbSerialDriver available.");
                    result.add(new DeviceEntry(device, null));
                } else {
                    for (UsbSerialDriver driver : drivers) {
                        Log.d(TAG, "  + " + driver);
                        result.add(new DeviceEntry(device, driver));
                    }
                }
            }
            return result;
        }

        @Override
        protected void onPostExecute(List<DeviceEntry> result) {
            mEntries.clear();
            mEntries.addAll(result);
            mAdapter.notifyDataSetChanged();
            mProgressBarTitle.setText(
                    String.format("%s device(s) found",Integer.valueOf(mEntries.size())));
            hideProgressBar();
            Log.d(TAG, "Done refreshing, " + mEntries.size() + " entries found.");
        }

    }.execute((Void) null);
}

private void showProgressBar() {
    mProgressBar.setVisibility(View.VISIBLE);
    mProgressBarTitle.setText(R.string.refreshing);
}

private void hideProgressBar() {
    mProgressBar.setVisibility(View.INVISIBLE);
}

private void showConsoleActivity(UsbSerialDriver driver) {
    SerialConsoleActivity.show(this, driver);
}

}