Android USB通訊(完整版)

阿新 • • 發佈：2018-12-31

這裡寫圖片描述

1.Host端程式碼:

package com.tcl.navigator.hostchart.activity;

import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbConstants;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import 
 android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import 
 android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import com.tcl.navigator.hostchart.R;
import com.tcl.navigator.hostchart.base.MyApplication;
import com.tcl.navigator.hostchart.receiver.OpenDevicesReceiver;
import com.tcl.navigator.hostchart.receiver.UsbDetachedReceiver;

import 
 java.util.Collection;
import java.util.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 
 */

public class MainActivity extends AppCompatActivity implements UsbDetachedReceiver.UsbDetachedListener, OpenDevicesReceiver.OpenDevicesListener, View.OnClickListener {

    private static final int    CONNECTED_SUCCESS        = 0;
    private static final int    RECEIVER_MESSAGE_SUCCESS = 1;
    private static final int    SEND_MESSAGE_SUCCESS     = 2;
    private static final String USB_ACTION               = "com.tcl.navigator.hostchart";
    private TextView            mLog;
    private EditText            mMessage;
    private UsbDetachedReceiver mUsbDetachedReceiver;
    private ExecutorService     mThreadPool;
    private UsbManager          mUsbManager;
    private OpenDevicesReceiver mOpenDevicesReceiver;
    private TextView            mError;
    private UsbDeviceConnection mUsbDeviceConnection;
    private UsbEndpoint         mUsbEndpointOut;
    private UsbEndpoint         mUsbEndpointIn;
    private boolean mToggle = true;
    private Button mSendMessage;
    private boolean isDetached        = false;
    private byte[]  mBytes            = new byte[1024];
    private boolean isReceiverMessage = true;
    private UsbInterface mUsbInterface;
    private StringBuffer mStringBuffer = new StringBuffer();
    private Context mContext;

    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case CONNECTED_SUCCESS://車機和手機連線成功
                    mError.setText("");
                    mSendMessage.setEnabled(true);
                    loopReceiverMessage();
                    break;

                case RECEIVER_MESSAGE_SUCCESS://成功接受到資料
                    mLog.setText(mStringBuffer.toString());
                    break;

                case SEND_MESSAGE_SUCCESS://成功傳送資料
                    mMessage.setText("");
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
    }

    private void init() {
        initView();
        initListener();
        initData();
    }

    private void initView() {
        mLog = (TextView) findViewById(R.id.log);
        mError = (TextView) findViewById(R.id.error);
        mMessage = (EditText) findViewById(R.id.message);
        mSendMessage = (Button) findViewById(R.id.sendmessage);
    }

    private void initListener() {
        mSendMessage.setOnClickListener(this);
    }

    private void initData() {
        mContext = getApplicationContext();
        mSendMessage.setEnabled(false);
        mUsbDetachedReceiver = new UsbDetachedReceiver(this);
        IntentFilter intentFilter = new IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED);
        registerReceiver(mUsbDetachedReceiver, intentFilter);

        mThreadPool = Executors.newFixedThreadPool(5);

        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);

        openDevices();
    }

    /**
     * 開啟裝置 , 讓車機和手機端連起來
     */
    private void openDevices() {
        PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(USB_ACTION), 0);
        IntentFilter intentFilter = new IntentFilter(USB_ACTION);
        mOpenDevicesReceiver = new OpenDevicesReceiver(this);
        registerReceiver(mOpenDevicesReceiver, intentFilter);

        //列舉裝置(手機)
        HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
        if (deviceList != null) {
            for (UsbDevice usbDevice : deviceList.values()) {
                int productId = usbDevice.getProductId();
                if (productId != 377 && productId != 7205) {
                //這裡說明下,這裡的377 , 7205是我這臺機子上獨有,因為我這上面有多臺裝置,所以我在這裡
                //判斷了下.只有一臺裝置的無需這一步.
                    if (mUsbManager.hasPermission(usbDevice)) {
                        initAccessory(usbDevice);
                    } else {
                        mUsbManager.requestPermission(usbDevice, pendingIntent);
                    }
                }
            }
        } else {
            mError.setText("請連線USB");
        }
    }

    /**
     * 傳送命令 , 讓手機進入Accessory模式
     *
     * @param usbDevice
     */
    private void initAccessory(UsbDevice usbDevice) {
        UsbDeviceConnection usbDeviceConnection = mUsbManager.openDevice(usbDevice);
        if (usbDeviceConnection == null) {
            mError.setText("請連線USB");
            return;
        }

        //根據AOA協議開啟Accessory模式
        initStringControlTransfer(usbDeviceConnection, 0, "Google, Inc."); // MANUFACTURER
        initStringControlTransfer(usbDeviceConnection, 1, "AccessoryChat"); // MODEL
        initStringControlTransfer(usbDeviceConnection, 2, "Accessory Chat"); // DESCRIPTION
        initStringControlTransfer(usbDeviceConnection, 3, "1.0"); // VERSION
        initStringControlTransfer(usbDeviceConnection, 4, "http://www.android.com"); // URI
        initStringControlTransfer(usbDeviceConnection, 5, "0123456789"); // SERIAL
        usbDeviceConnection.controlTransfer(0x40, 53, 0, 0, new byte[]{}, 0, 100);
        usbDeviceConnection.close();
        MyApplication.printLogDebug("initAccessory success");
        initDevice();
    }

    private void initStringControlTransfer(UsbDeviceConnection deviceConnection, int index, String string) {
        deviceConnection.controlTransfer(0x40, 52, 0, index, string.getBytes(), string.length(), 100);
    }

    /**
     * 初始化裝置(手機) , 當手機進入Accessory模式後 , 手機的PID會變為Google定義的2個常量值其中的一個 ,
     */
    private void initDevice() {
        mThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                while (mToggle) {
                    SystemClock.sleep(1000);
                    HashMap<String, UsbDevice> deviceList = mUsbManager.getDeviceList();
                    Collection<UsbDevice> values = deviceList.values();
                    if (!values.isEmpty()) {
                        for (UsbDevice usbDevice : values) {
                            int productId = usbDevice.getProductId();
                            if (productId == 0x2D00 || productId == 0x2D01) {
                                if (mUsbManager.hasPermission(usbDevice)) {
                                    mUsbDeviceConnection = mUsbManager.openDevice(usbDevice);
                                    if (mUsbDeviceConnection != null) {
                                        mUsbInterface = usbDevice.getInterface(0);
                                        int endpointCount = mUsbInterface.getEndpointCount();
                                        for (int i = 0; i < endpointCount; i++) {
                                            UsbEndpoint usbEndpoint = mUsbInterface.getEndpoint(i);
                                            if (usbEndpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                                                if (usbEndpoint.getDirection() == UsbConstants.USB_DIR_OUT) {
                                                    mUsbEndpointOut = usbEndpoint;
                                                } else if (usbEndpoint.getDirection() == UsbConstants.USB_DIR_IN) {
                                                    mUsbEndpointIn = usbEndpoint;
                                                }
                                            }
                                        }
                                        if (mUsbEndpointOut != null && mUsbEndpointIn != null) {
                                            MyApplication.printLogDebug("connected success");
                                            mHandler.sendEmptyMessage(CONNECTED_SUCCESS);
                                            mToggle = false;
                                            isDetached = true;
                                        }
                                    }
                                } else {
                                    mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(""), 0));
                                }
                            }
                        }
                    } else {
                        finish();
                    }
                }
            }
        });
    }

    /**
     * 接受訊息執行緒 , 此執行緒在裝置(手機)初始化完成後 , 就一直迴圈接受訊息
     */
    private void loopReceiverMessage() {
        mThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(1000);
                while (isReceiverMessage) {
                    /**
                     * 迴圈接受資料的地方 , 只接受byte資料型別的資料
                     */
                    if (mUsbDeviceConnection != null && mUsbEndpointIn != null) {
                        int i = mUsbDeviceConnection.bulkTransfer(mUsbEndpointIn, mBytes, mBytes.length, 3000);
                        MyApplication.printLogDebug(i + "");
                        if (i > 0) {
                            mStringBuffer.append(new String(mBytes, 0, i) + "\n");
                            mHandler.sendEmptyMessage(RECEIVER_MESSAGE_SUCCESS);
                        }
                    }
                }
            }
        });
    }

    @Override
    public void usbDetached() {
        if (isDetached) {
            finish();
        }
    }

    @Override
    public void openAccessoryModel(UsbDevice usbDevice) {
        initAccessory(usbDevice);
    }

    @Override
    public void openDevicesError() {
        mError.setText("USB連線錯誤");
    }

    @Override
    public void onClick(View v) {
        final String messageContent = mMessage.getText().toString();
        if (!TextUtils.isEmpty(messageContent)) {
            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    /**
                     * 傳送資料的地方 , 只接受byte資料型別的資料
                     */
                    int i = mUsbDeviceConnection.bulkTransfer(mUsbEndpointOut, messageContent.getBytes(), messageContent.getBytes().length, 3000);
                    if (i > 0) {
                        mHandler.sendEmptyMessage(SEND_MESSAGE_SUCCESS);
                    }
                }
            });
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        if (mUsbDeviceConnection != null) {
            mUsbDeviceConnection.releaseInterface(mUsbInterface);
            mUsbDeviceConnection.close();
            mUsbDeviceConnection = null;
        }
        mUsbEndpointIn = null;
        mUsbEndpointOut = null;
        mToggle = false;
        isReceiverMessage = false;
        mThreadPool.shutdownNow();
        unregisterReceiver(mUsbDetachedReceiver);
        unregisterReceiver(mOpenDevicesReceiver);
    }
}

OpenDevicesReceiver廣播程式碼:

package com.tcl.navigator.hostchart.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;

/**
 * Created by yaohui on 2017/3/3.
 */

public class OpenDevicesReceiver extends BroadcastReceiver {

    private OpenDevicesListener mOpenDevicesListener;

    public OpenDevicesReceiver(OpenDevicesListener openDevicesListener) {
        mOpenDevicesListener = openDevicesListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
            if (usbDevice != null) {
                mOpenDevicesListener.openAccessoryModel(usbDevice);
            } else {
                mOpenDevicesListener.openDevicesError();
            }
        } else {
            mOpenDevicesListener.openDevicesError();
        }
    }

    public interface OpenDevicesListener {
        /**
         * 開啟Accessory模式
         *
         * @param usbDevice
         */
        void openAccessoryModel(UsbDevice usbDevice);

        /**
         * 開啟裝置(手機)失敗
         */
        void openDevicesError();
    }
}

UsbDetachedReceiver廣播程式碼:

package com.tcl.navigator.hostchart.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

public class UsbDetachedReceiver extends BroadcastReceiver {

    private UsbDetachedListener mUsbDetachedListener;

    public UsbDetachedReceiver(UsbDetachedListener usbDetachedListener) {
        mUsbDetachedListener = usbDetachedListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        mUsbDetachedListener.usbDetached();
    }

    public interface UsbDetachedListener {
        /**
         * usb斷開連線
         */
        void usbDetached();
    }
}

以上就是Host端程式碼了.

2.Accessory端程式碼:

package com.tcl.navigator.accessorychart.activity;

import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import com.tcl.navigator.accessorychart.R;
import com.tcl.navigator.accessorychart.receiver.OpenAccessoryReceiver;
import com.tcl.navigator.accessorychart.receiver.UsbDetachedReceiver;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MainActivity extends AppCompatActivity implements OpenAccessoryReceiver.OpenAccessoryListener, View.OnClickListener, UsbDetachedReceiver.UsbDetachedListener {

    private static final int    SEND_MESSAGE_SUCCESS     = 0;
    private static final int    RECEIVER_MESSAGE_SUCCESS = 1;
    private static final String USB_ACTION               = "com.tcl.navigator.accessorychart";
    private TextView              mLog;
    private EditText              mMessage;
    private Button                mSend;
    private UsbManager            mUsbManager;
    private OpenAccessoryReceiver mOpenAccessoryReceiver;
    private ParcelFileDescriptor  mParcelFileDescriptor;
    private FileInputStream       mFileInputStream;
    private FileOutputStream      mFileOutputStream;
    private ExecutorService       mThreadPool;
    private byte[]       mBytes        = new byte[1024];
    private StringBuffer mStringBuffer = new StringBuffer();
    private UsbDetachedReceiver mUsbDetachedReceiver;

    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SEND_MESSAGE_SUCCESS:
                    mMessage.setText("");
                    mMessage.clearComposingText();
                    break;

                case RECEIVER_MESSAGE_SUCCESS:
                    mLog.setText(mStringBuffer.toString());
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
    }

    private void init() {
        initView();
        initListener();
        initData();
    }

    private void initView() {
        mLog = (TextView) findViewById(R.id.log);
        mMessage = (EditText) findViewById(R.id.message);
        mSend = (Button) findViewById(R.id.send);
    }

    private void initListener() {
        mSend.setOnClickListener(this);
    }

    private void initData() {
        mSend.setEnabled(false);
        mUsbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
        mThreadPool = Executors.newFixedThreadPool(3);

        mUsbDetachedReceiver = new UsbDetachedReceiver(this);
        IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
        registerReceiver(mUsbDetachedReceiver, filter);

        mOpenAccessoryReceiver = new OpenAccessoryReceiver(this);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(USB_ACTION), 0);
        IntentFilter intentFilter = new IntentFilter(USB_ACTION);
        registerReceiver(mOpenAccessoryReceiver, intentFilter);

        UsbAccessory[] accessories = mUsbManager.getAccessoryList();
        UsbAccessory usbAccessory = (accessories == null ? null : accessories[0]);
        if (usbAccessory != null) {
            if (mUsbManager.hasPermission(usbAccessory)) {
                openAccessory(usbAccessory);
            } else {
                mUsbManager.requestPermission(usbAccessory, pendingIntent);
            }
        }
    }

    /**
     * 開啟Accessory模式
     *
     * @param usbAccessory
     */
    private void openAccessory(UsbAccessory usbAccessory) {
        mParcelFileDescriptor = mUsbManager.openAccessory(usbAccessory);
        if (mParcelFileDescriptor != null) {
            FileDescriptor fileDescriptor = mParcelFileDescriptor.getFileDescriptor();
            mFileInputStream = new FileInputStream(fileDescriptor);
            mFileOutputStream = new FileOutputStream(fileDescriptor);
            mSend.setEnabled(true);

            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    int i = 0;
                    while (i >= 0) {
                        try {
                            i = mFileInputStream.read(mBytes);
                        } catch (IOException e) {
                            e.printStackTrace();
                            break;
                        }
                        if (i > 0) {
                            mStringBuffer.append(new String(mBytes, 0, i) + "\n");
                            mHandler.sendEmptyMessage(RECEIVER_MESSAGE_SUCCESS);
                        }
                    }
                }
            });
        }
    }

    @Override
    public void openAccessoryModel(UsbAccessory usbAccessory) {
        openAccessory(usbAccessory);
    }

    @Override
    public void openAccessoryError() {

    }

    @Override
    public void onClick(View v) {
        final String mMessageContent = mMessage.getText().toString();
        if (!TextUtils.isEmpty(mMessageContent)) {
            mThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        mFileOutputStream.write(mMessageContent.getBytes());
                        mHandler.sendEmptyMessage(SEND_MESSAGE_SUCCESS);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void usbDetached() {

        finish();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        unregisterReceiver(mOpenAccessoryReceiver);
        unregisterReceiver(mUsbDetachedReceiver);
        if (mParcelFileDescriptor != null) {
            try {
                mParcelFileDescriptor.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mFileInputStream != null) {
            try {
                mFileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (mFileOutputStream != null) {
            try {
                mFileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

OpenAccessoryReceiver廣播程式碼:

package com.tcl.navigator.accessorychart.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.hardware.usb.UsbAccessory;
import android.hardware.usb.UsbManager;

public class OpenAccessoryReceiver extends BroadcastReceiver {

    private OpenAccessoryListener mOpenAccessoryListener;

    public OpenAccessoryReceiver(OpenAccessoryListener openAccessoryListener) {
        mOpenAccessoryListener = openAccessoryListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        UsbAccessory usbAccessory = intent.getParcelableExtra(UsbManager.EXTRA_ACCESSORY);
        if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
            if (usbAccessory != null) {
                mOpenAccessoryListener.openAccessoryModel(usbAccessory);
            } else {
                mOpenAccessoryListener.openAccessoryError();
            }
        } else {
            mOpenAccessoryListener.openAccessoryError();
        }
    }

    public interface OpenAccessoryListener {
        /**
         * 開啟Accessory模式
         *
         * @param usbAccessory
         */
        void openAccessoryModel(UsbAccessory usbAccessory);

        /**
         * 開啟裝置(手機)失敗
         */
        void openAccessoryError();
    }
}

UsbDetachedReceiver廣播程式碼:

package com.tcl.navigator.accessorychart.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

public class UsbDetachedReceiver extends BroadcastReceiver {

    private UsbDetachedListener mUsbDetachedListener;

    public UsbDetachedReceiver(UsbDetachedListener usbDetachedListener) {
        mUsbDetachedListener = usbDetachedListener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        mUsbDetachedListener.usbDetached();
    }

    public interface UsbDetachedListener {
        /**
         * usb斷開連線
         */
        void usbDetached();
    }
}

最後在AndroidManifest裡面有些小改動:

<activity android:name=".activity.MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <action android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"/>

                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>

            <meta-data
                android:name="android.hardware.usb.action.USB_ACCESSORY_ATTACHED"
                android:resource="@xml/accessory_filter"/>
        </activity>

其中USB通訊是需要使用者手動賦予許可權的,所以2個手機都會有提示的.
到此基本上就完了,我寫的這2個app執行在2個安卓手機上,通過資料線是可以進行聊天的.
不懂的請給我留言,我看到了都會回覆的,再見啦! ! !
原始碼下載地址:HostChart,AccessoryChart

Android USB通訊(完整版)

1.Host端程式碼: package com.tcl.navigator.hostchart.activity; import android.app.PendingIntent; import android.content.Context; imp

Android照片牆完整版，完美結合LruCache和DiskLruCache

在上一篇文章當中，我們學習了DiskLruCache的概念和基本用法，但僅僅是掌握理論知識顯然是不夠的，那麼本篇文章我們就來繼續進階一下，看一看在實戰當中應該怎樣合理使用DiskLruCache。還不熟悉DiskLruCache用法的朋友可以先去參考我的上一篇文章 Androi

基於ＡＯＡ協議的android USB通訊

摘要：AOA協議是Google公司推出的用於實現Android裝置與外圍裝置之間USB通訊的協議。該協議拓展了Android裝置USB介面的功能，為基於Android系統的智慧裝置應用於資料採集和裝置控制領域提供了條件。介紹了Android系統下USB通訊的兩種模式，並給出

Android事件分發完整版總結，終結版解析！

總體的流程分發 Acticity —–> ViewGroup ——->View 事件分發涉及的幾個方法: 1、dispatchTouchEvent 2、onInterceptTouchEvent

Android USB Host與USB Hid裝置的通訊（印表機和android通訊,通過USB）

記事：android和印表機通過網路通訊（網路印表機），有空也要記錄一下堆疊關係也要記錄一下（通常我們所說的堆疊都是指棧，比如一個方法被呼叫的時候，我們就會把相關變數壓棧(巢狀才會壓棧，一個方法呼叫完是要出棧的)，除非遞迴，一般情況下，棧是不會溢位的）近期一直在做Android USB

Android 密碼輸入框、驗證碼輸入框，完整版；

接上篇，優化了一下程式碼，新增一些屬性； "space" //每個輸入框之間的間距； "strokeWidth" //邊框的高度； "checke

Android實戰技巧之四十九：Usb通訊之USB Host

零 USB背景知識 USB是一種資料通訊方式，也是一種資料匯流排，而且是最複雜的匯流排之一。硬體上，它是用插頭連線。一邊是公頭（plug），一邊是母頭（receptacle）。例如，PC上的插座就是母頭，USB裝置使用公頭與PC連線。目前USB硬體介面

Cocos2dx3.1-Android開發環境搭建完整版

1、下載android開發工具 eclipse、sdk等，連結：http://pan.baidu.com/s/1ge3rlT5 密碼：ou1w 2、下載安裝ndk，連結：http://pan.baidu.com/s/1bp9fpRT 密碼：0mfv 3、下載安裝cygwin，連結：http:

Android SDK 完整版

更新是更新不了了只能一點點自己下載 AndroidDevTools簡介收集整理Android開發所需的Android SDK、開發中用到的工具、Android開發教程、Android設計規範，免費的設計素材等。歡迎大家推薦自己在Androi

在ubuntu下安裝android studio完整版吐血整理

有 2 個候選項可用於替換 java (提供 /usr/bin/java)。選擇路徑優先順序狀態 --------------------------------------------------------

谷歌官方Android應用架構庫（Android Architecture Components）學習完整版

架構庫版本：1.0.0 Alpha 2 - June 2, 2017 1 導語本次 Google IO 大會不僅確立了 Kotlin 為安卓開發的官方語言，不為人注意是，還發布了谷歌官方 Android 應用架構庫。這個新的架構庫旨在幫助我們設計健壯、

完整版linux下android原始碼下載、編譯、模擬器啟動執行

一、環境說明： 1、VMware版本：8.0.3 build-703057 2、liunx系統：Ubuntu10.10 3、jdk：sun-java6-jdk 二、Ubuntu 10.10更新源列表由於Ubuntu 10.10版本的源已經過期了，所以，需要

下載Android原始碼流程（完整版）

要在Linux環境下操作，要在Linux環境下操作，要在Linux環境下操作~~ 不要想在Windows環境下操作，因為會有各種問題。Windows環境的童鞋又不想裝雙系統的可以跟著下面的操作，Linux的童鞋可以直接跳過看。Mac的童鞋就略過~~~

Android開發之Android studio自動簽名打包release 版本的正確姿勢(完整版)

1.從以下方面講解打包正式版本分為：自動打包(也就是每次專案跑起來就是release正式版本)apk手動打包：就是每次需要重新簽名後選擇release正式版本再跑起來生成apk先說手動版本特別簡單圖文解說：你要先建立一個簽名檔案如下：再說下自動簽名打包：

教你如何使用android studio釋出release 版本（完整版）

想必還有人對如何在android studio （以下簡稱as）釋出release版本的app而狂刷百度吧？都是過來人，我很理解這種心情，百度到的基本是半成品，為什麼這麼說呢？百度一下，你就知道，好了

Android---服務的最佳實踐（完整版的下載例項）

一、定義回撥介面 public interface DownloadListener { /* * 介面類，使用回撥 */ void onProgress(int progress); void onSuccess(); void on

Android USB Host 與 HID 之通訊方法(bulkTransfer()與controlTransfer()方法使用)

轉載地址：差滿多乃幾 Android USB Host與HID通訊，就目前Google Developer提供的方法有bulkTransfer()與controlTransfer(),看是簡簡單單的兩個方法，要實現真正的通訊可謂要難倒一大片android開發者，至少對於

Android作為伺服器與PC作為客戶端通過USB通訊

需求：前幾天做專案過程中，遇到一個問題，需要Android的APP作為伺服器端，PC端作為客戶端去向伺服器端請求資料。解決過程。（1）第一個想到的是通過Socket通訊，Android作為So

Appium 新手貼:Windows 平臺上的使用 Python 語言實現 appium 自動化程式 for Android (完整版)

https://testerhome.com/topics/646 前面寫了個《新手貼:Windows 平臺上的使用 Java 語言實現 appium 自動化程式 for Android（完整版）》的帖子：http://testerhome.com/topics/645

字符串函數---atof()函數具體解釋及實現（完整版）

記錄 == include als 技術整數 ast fill 跳過 atof()函數 atof():double atof(const char *str ); 功能：把字符串轉換成浮點數 str：要轉換的字符串。返回值：每一個函數返回 double 值。此值

Android USB通訊(完整版)

相關推薦