Android 硬件通讯之 蓝牙，USB，WIFI（二.WIFI）

最新推荐文章于 2023-10-18 14:36:43 发布
最新推荐文章于 2023-10-18 14:36:43 发布
阅读量1k 收藏 8
点赞数 1
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ding_gc/article/details/106075574
版权

WIFI通讯：双网络通讯

随着公司产品的不断迭代，发现上位机（App）与下位机（Vci）通讯，在收发长包数据时，蓝牙通道出现了丢字节，丢包现象。而这时候会提示用户使用USB串口通讯方式。但是USB串口通讯，必须局限于线束的连接。

为了优化这个问题，增加引入了WIFI上下位机通讯通道。

应用场景

App与硬件使用WIFI（无网）通道进行命令收到，并在App内强制使用4G通道进行Http请求

 

1，接收到WIFI接连的广播后，执行连接操作

    /**
     * 发现wifi设备
     *
     * @param wifiScanResultEvent
     */
    @Subscribe(threadMode = ThreadMode.BACKGROUND)
    public void onRecivedBluetoothDevice(WifiScanResultEvent wifiScanResultEvent) {
        if (deviceInfo == null) {
            Log.e(TAG, "WIFI信息为空，停止扫描");
            return;
        }

        if (isConnecting()) {
            Log.e(TAG, "WIFI连接中，停止此次扫描");
            return;
        }
        //如果WIFI已连接上则退出
        if (isConnected()) {
            Log.e(TAG, "WIFI已连接上，不在扫描");
            return;
        }
        if (addNetworkConfiguration(deviceInfo.getBssid())) {
            stopScanDevice();
            connecting();
            if (connectToNetwork(deviceInfo.getSsid(), deviceInfo.getPassword(), deviceInfo.getWifiType()) < 0) {
                connectionError(-3, "无法添加wifi配置信息");
            } else {
                stopDiscovery();
                Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) {
                        createScokect();
                        emitter.onNext("");
                    }
                });

                Consumer<String> consumer = new Consumer<String>() {
                    @Override
                    public void accept(String bean) {

                    }
                };
                observable.subscribeOn(Schedulers.newThread())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(consumer);
            }
        }
    }


  /**
     * 添加wifi链接配置
     *
     * @param bssid 下位机wifi mac地址
     * @return 有该wifi设备信号
     */
    private boolean addNetworkConfiguration(String bssid) {
        //获取当前wifi 列表，有可能要链接的wifi不处于当前列表中
        List<ScanResult> wifiList = mWifiManager.getScanResults();
        if (wifiList == null || wifiList.size() == 0) {
            return false;
        }

        ScanResult scanResul;
        for (int i = 0, size = wifiList.size(); i < size; i++) {
            scanResul = wifiList.get(i);
            Log.e(TAG, "wifi name " + scanResul.SSID + " mac " + scanResul.BSSID);
            Loger.printLog("scanWifiList", "wifi name " + scanResul.SSID + " mac " + scanResul.BSSID);
            if (scanResul.BSSID.equals(bssid)) {
                Log.e(TAG, "匹配到wifi name " + scanResul.SSID + " mac " + scanResul.BSSID);
                return true;
            }
        }
        return false;
    }

    /**
     * 链接到wifi网络
     *
     * @param ssid
     * @param password
     * @param type
     * @return 成功链接到wifi后返回
     */
    private int connectToNetwork(String ssid, String password, @WifiType int type) {
        WifiConfiguration configuration = createWifiInfo(ssid, password, type);
        int networkId = mWifiManager.addNetwork(configuration);  // 添加WIFI网络
        if (networkId < 0) {
            Log.e(TAG, "WIFI已连接失败 networkId:" + networkId);
            return -1;
        }
        // 使WIFI网络有效
        mWifiManager.enableNetwork(networkId, true);
        Log.e(TAG, "WIFI已连接成功 networkId:" + networkId);
        return networkId;
    }

    /**
     * 创建WiFi配置
     *
     * @param ssid
     * @param password
     * @param type
     * @return
     */
    private WifiConfiguration createWifiInfo(String ssid, String password, @WifiType int type) {

        clearOldConfiguration(ssid);

        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + ssid + "\"";

        // 分为三种情况：1没有密码2用wep加密3用wpa加密
        if (type == WifiType.TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS
            config.wepKeys[0] = "";
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;

        } else if (type == WifiType.TYPE_WEP) {  //  WIFICIPHER_WEP
            config.hiddenSSID = true;
            config.wepKeys[0] = "\"" + password + "\"";
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        } else if (type == WifiType.TYPE_WPA) {   // WIFICIPHER_WPA
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            config.status = WifiConfiguration.Status.ENABLED;
            config.status = WifiConfiguration.Status.ENABLED;
        } else if (type == WifiType.TYPE_WPA2) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        }
        return config;
    }

    /**
     * 删除之前的链接配置信息
     *
     * @param ssid
     */
    private void clearOldConfiguration(String ssid) {

        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
        if (existingConfigs == null || existingConfigs.size() == 0) {
            return;
        }

        WifiConfiguration wiifConfig;
        for (int i = 0, size = existingConfigs.size(); i < size; i++) {
            wiifConfig = existingConfigs.get(i);
            if (wiifConfig.SSID.equals("\"" + ssid + "\"")) {
                mWifiManager.removeNetwork(wiifConfig.networkId);        //TODO 删除之前保存的wifi链接信息 ？
            }
        }
    }

2.连接成功WIFI后创建Socket连接（这里是启动ServerSocket,等待下位机连接），下位机连接成功创建IO

    private void createScokect() {
        closeSocket();
        try {
            Log.i(TAG, "server已启动，等待客户端连接");
            int port = 8084;
            serverSocket = new ServerSocket(port);
            Log.i(TAG, serverSocket.toString());
            //侦听对此套接字的连接并接受它。 该方法将阻塞，直到建立连接。
            mWifiSocket = serverSocket.accept();
            Log.i(TAG, "client 已连接");
            //设置服务器等待超时时间，0：表示无限等待
            mWifiSocket.setSoTimeout(30000);
            if (mWifiSocket.isConnected()) {
                mOutputStream = mWifiSocket.getOutputStream();
                mInputStream = mWifiSocket.getInputStream();
                connected();
                Log.e(TAG, "Socket连接成功");
            } else {
                Log.e(TAG, "Socket连接失败1");
            }
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, "ServerSocket" + e.getMessage());
        }
    }

3.数据收发

public class WifiTransfer extends BaseWifiConnceter {

    @Override
    public boolean sendData(byte[] data) {

        if (isConnected()) {

            if (mOutputStream != null) {

                try {
                    mOutputStream.write(data);
                    mOutputStream.flush();
                    onDataSended(data);
                    return true;

                } catch (IOException e) {
                    onSendDataError(-3, "写入时IO异常：" + e.getLocalizedMessage());
                    return false;
                }
            }

            onSendDataError(-2, "程序异常，数据流断开");
            return false;
        } else {
            onSendDataError(-1, "连接已断开");
            return false;
        }
    }

    @Override
    protected byte[] readData() {

        if (mInputStream != null) {

            try {
                int length = mInputStream.available();
                if (length > 1) {
                    byte[] temp = new byte[length];
                    mInputStream.read(temp);
                    return temp;
                }
            } catch (IOException e) {
                onRecivedDataErrror(-4, "读取数据时IO异常");
            }
        }

        return null;
    }
}

4.开启V&P&N

通常Android设备连接了一个无法联网的WIFI时，即使4G打开的情况下，应用内的网络请求也是优先走WIFI通道，导致无法进行常规的Http连接请求。

解决办法：开启V&P&N

if (ret.getDeviceType() == DeviceType.WIFI) {
                journal.setCatalog1("WIFI连接");
                hideBluetoothConnectDialog();
                if (VpnUtils.lacksPermission(VpnUtils.permissions, BaseTopBarActivity.this)) {//判断是否拥有权限
                    //请求权限，第二参数权限String数据，第三个参数是请求码便于在onRequestPermissionsResult 方法中根据code进行判断
                    ActivityCompat.requestPermissions(BaseTopBarActivity.this, permissions, OPEN_SET_REQUEST_CODE);
                } else if (VpnUtils.lacksPermission(VpnUtils.PERMISSIONS_STORAGE, BaseTopBarActivity.this)) {//判断是否拥有权限
                    ActivityCompat.requestPermissions(BaseTopBarActivity.this, VpnUtils.PERMISSIONS_STORAGE, VpnUtils.REQUEST_PERMISSION_CODE);
                } else {
                    //拥有权限执行操作
                    Intent vpnIntent = VpnService.prepare(BaseTopBarActivity.this);
                    if (vpnIntent != null)
                        startActivityForResult(vpnIntent, VpnUtils.VPN_REQUEST_CODE);
                    else {
                        startService(new Intent(BaseTopBarActivity.this, LocalVPNService.class));
                    }
                }
            }


public class LocalVPNService extends VpnService {
    private static final String TAG = LocalVPNService.class.getSimpleName();
    private static final String VPN_ADDRESS = "10.0.0.2"; // Only IPv4 support for now
    private static final String VPN_ROUTE = "0.0.0.0"; // Intercept everything

    public static final String BROADCAST_VPN_STATE = "com.commonrail.mft.decoder.localvpn.VPN_STATE";

    private static boolean isRunning = false;

    private ParcelFileDescriptor vpnInterface = null;
    private ConcurrentLinkedQueue<Packet> deviceToNetworkUDPQueue;
    private ConcurrentLinkedQueue<Packet> deviceToNetworkTCPQueue;
    private ConcurrentLinkedQueue<ByteBuffer> networkToDeviceQueue;
    private ExecutorService executorService;

    private Selector udpSelector;
    private Selector tcpSelector;

    public static Network networkId;

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    public void onCreate() {
        super.onCreate();
        isRunning = true;
        setupVPN();
        try {
            udpSelector = Selector.open();
            tcpSelector = Selector.open();
            deviceToNetworkUDPQueue = new ConcurrentLinkedQueue<>();
            deviceToNetworkTCPQueue = new ConcurrentLinkedQueue<>();
            networkToDeviceQueue = new ConcurrentLinkedQueue<>();

            executorService = Executors.newFixedThreadPool(5);
            executorService.submit(new UDPInput(networkToDeviceQueue, udpSelector));
            executorService.submit(new UDPOutput(deviceToNetworkUDPQueue, udpSelector, this));
            executorService.submit(new TCPInput(networkToDeviceQueue, tcpSelector));
            executorService.submit(new TCPOutput(deviceToNetworkTCPQueue, networkToDeviceQueue, tcpSelector, this));
            executorService.submit(new VPNRunnable(vpnInterface.getFileDescriptor(),
                    deviceToNetworkUDPQueue, deviceToNetworkTCPQueue, networkToDeviceQueue));
            LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(BROADCAST_VPN_STATE).putExtra("running", true));
            requestWorkNetForHigh(this);
        } catch (IOException e) {
            Log.e(TAG, "Error starting service", e);
            cleanup();
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    private void setupVPN() {
        if (vpnInterface == null) {
            Builder builder = new Builder();
            builder.addAddress(VPN_ADDRESS, 32);
            builder.addRoute(VPN_ROUTE, 0);
            builder.addDnsServer("8.8.8.8");
            builder.addDnsServer("8.8.4.4");
            builder.addDnsServer("208.67.222.222");
            builder.addDnsServer("114.114.114.114");
            builder.setMtu(1280);
            vpnInterface = builder.setSession(getString(R.string.app_name)).establish();
        }
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return START_STICKY;
    }

    public static boolean isRunning() {
        return isRunning;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        isRunning = false;
        executorService.shutdownNow();
        cleanup();
        Log.i(TAG, "Stopped");
    }

    private void cleanup() {
        deviceToNetworkTCPQueue = null;
        deviceToNetworkUDPQueue = null;
        networkToDeviceQueue = null;
        ByteBufferPool.clear();
        closeResources(udpSelector, tcpSelector, vpnInterface);
    }

    // TODO: Move this to a "utils" class for reuse
    private static void closeResources(Closeable... resources) {
        for (Closeable resource : resources) {
            try {
                resource.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static class VPNRunnable implements Runnable {
        private static final String TAG = VPNRunnable.class.getSimpleName();

        private FileDescriptor vpnFileDescriptor;

        private ConcurrentLinkedQueue<Packet> deviceToNetworkUDPQueue;
        private ConcurrentLinkedQueue<Packet> deviceToNetworkTCPQueue;
        private ConcurrentLinkedQueue<ByteBuffer> networkToDeviceQueue;

        public VPNRunnable(FileDescriptor vpnFileDescriptor,
                           ConcurrentLinkedQueue<Packet> deviceToNetworkUDPQueue,
                           ConcurrentLinkedQueue<Packet> deviceToNetworkTCPQueue,
                           ConcurrentLinkedQueue<ByteBuffer> networkToDeviceQueue) {
            this.vpnFileDescriptor = vpnFileDescriptor;
            this.deviceToNetworkUDPQueue = deviceToNetworkUDPQueue;
            this.deviceToNetworkTCPQueue = deviceToNetworkTCPQueue;
            this.networkToDeviceQueue = networkToDeviceQueue;
        }

        @Override
        public void run() {
            Log.i(TAG, "Started");

            FileChannel vpnInput = new FileInputStream(vpnFileDescriptor).getChannel();
            FileChannel vpnOutput = new FileOutputStream(vpnFileDescriptor).getChannel();

            try {
                ByteBuffer bufferToNetwork = null;
                boolean dataSent = true;
                boolean dataReceived;
                while (!Thread.interrupted()) {
                    if (dataSent)
                        bufferToNetwork = ByteBufferPool.acquire();
                    else
                        bufferToNetwork.clear();

                    // TODO: Block when not connected
                    int readBytes = vpnInput.read(bufferToNetwork);
                    if (readBytes > 0) {
                        dataSent = true;
                        bufferToNetwork.flip();
                        Packet packet = new Packet(bufferToNetwork);
                        if (packet.isUDP()) {
                            deviceToNetworkUDPQueue.offer(packet);
                        } else if (packet.isTCP()) {
                            deviceToNetworkTCPQueue.offer(packet);
                        } else {
                            Log.w(TAG, "Unknown packet type");
                            Log.w(TAG, packet.ip4Header.toString());
                            dataSent = false;
                        }
                    } else {
                        dataSent = false;
                    }

                    ByteBuffer bufferFromNetwork = networkToDeviceQueue.poll();
                    if (bufferFromNetwork != null) {
                        bufferFromNetwork.flip();
                        while (bufferFromNetwork.hasRemaining())
                            vpnOutput.write(bufferFromNetwork);
                        dataReceived = true;

                        ByteBufferPool.release(bufferFromNetwork);
                    } else {
                        dataReceived = false;
                    }

                    // TODO: Sleep-looping is not very battery-friendly, consider blocking instead
                    // Confirm if throughput with ConcurrentQueue is really higher compared to BlockingQueue
                    if (!dataSent && !dataReceived)
                        Thread.sleep(10);
                }
            } catch (InterruptedException e) {
                Log.i(TAG, "Stopping");
            } catch (IOException e) {
                Log.w(TAG, e.toString(), e);
            } finally {
                closeResources(vpnInput, vpnOutput);
            }
        }
    }

    @SuppressLint("WrongConstant")
    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public void requestWorkNetForHigh(Context context) {
        final ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
            Log.i(TAG, "ConnectivityManager is null, cannot try to force a mobile connection");
            return;
        }
        Log.i(TAG, "post50MobileEnable, requesting Cellular network");

        NetworkRequest.Builder builder = new NetworkRequest.Builder();
        builder.addCapability(NET_CAPABILITY_INTERNET);
        //强制使用蜂窝数据网络-移动数据
        builder.addTransportType(TRANSPORT_CELLULAR);
        NetworkRequest build = builder.build();

        try {
            Log.i(TAG, "Requesting Connectivity Manager");
            cm.requestNetwork(build, new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    super.onAvailable(network);
                    networkId = network;
                    Log.i(TAG, TAG + "已根据功能和传输类型找到合适的网络 NetWorkCallBack " + network);
                    if (Build.VERSION.SDK_INT >= 23) {
                        cm.bindProcessToNetwork(network);
                    } else {// 23后这个方法舍弃了
                        ConnectivityManager.setProcessDefaultNetwork(network);
                    }
                }
            });

        } catch (SecurityException e) {
            e.printStackTrace();
            Log.i(TAG, "com.speedify.speedifyAndroid.MobileController Cannot write settings. Requesting Permission");
        } catch (Exception e2) {
            e2.printStackTrace();
            Log.e(TAG, "Unknown Exception", e2);
        }
    }
}

 

Henson_Ding
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 蓝牙、USB、WiFi打印测试demo
09-05
- **Android Example4 WIFI.rar**: 包含WiFi打印的实现，可能涉及到IPP请求的构建和发送，以及Android Print Framework的使用。 在实际应用中，开发者需要根据目标打印机的特性调整和优化这些示例，例如处理不同...
Android 蓝牙、USB、WiFi打印测试demo(源代码)
01-19
这个"Android 蓝牙、USB、WiFi打印测试demo(源代码)"提供了丰富的示例，帮助开发者理解和实践这些技术。以下是每个部分的详细解释： 1. **蓝牙(Bluetooth)打印**： Android的蓝牙API允许开发者建立设备之间的连接...
上位机与下位机都是个啥？
热门推荐
jiayoudangdang的博客
04-03 2万+
上位机与下位机都是个啥？基础概念上位机是指人可以直接发出操控命令的计算机，一般是PC，屏幕上显示各种信号变化（液压，水位，温度等）。下位机是直接控制设备获取设备状况的计算机，一般是PLC/单片机之类的。上位机发出的命令首先给下位机，下位机再根据此命令解释成相应时序信号直接控制相应设备。下位机不时读取设备状态数据（一般为模拟量），转换成数字信号反馈给上位机。简言之如此，实际情况千差万别，但万变不离其...
linux嵌入式上下位机通信
weixin_44934541的博客
05-16 1005
文章目录 前言 一、下位机注册命令 二、下位机注册函数 三丶下位机执行指令 总结 前言 做下位机的人员都清楚一点，整个系统不是一个下位机就能完成的，往往需要很多程序交互完成整个系统运行。接下来用具体代码实现上位机发指令下位机接受并执行。 一、下位机注册命令 1，首先下位机使用枚举对应的命令号。网络数据与命令交互是网络协议支持，socket收发。 enum SPECIAL_COMMAND_LIST { APP_NET_CMD_BEGIN =0x700,...
android 串口通信_探索无线通信领域，8个ZigBee项目实例合集
weixin_39790738的博客
11-24 841
ZigBee是一项新型的无线通信技术，适用于传输范围短数据传输速率低的一系列电子元器件设备之间。 ZigBee无线通信技术可于数以千计的微小传感器相互间，依托专门的无线电标准达成相互协调通信，因而该项技术常被称为Home RF Lite无线技术、FireFly无线技术。ZigBee无线通信技术还可应用于小范围的基于无线通信的控制及自动化等领域，可省去计算机设备、一系列数字设备相互间的有线电缆，更能...
android 串口调试助手_PLC串口通信调试工具&调试过程
weixin_39912566的博客
11-21 575
　　串口通信是一种简单的通信方式，通过连接少量线缆即可完成数据通信。做串口通信调试，一般需要进行如下几个过程：1、确认上位机通信;2、确认下位机通信、3、上、下位机联调通信。(上位机是指PLC，下位机是指进行串口通信调试的器件)　调试工具硬件：USB-RS232串口电缆、PLC、笔记本电脑;(若电脑自带串口则无需USB-RS232电缆)　软件：串口调试助手;　调试过程　STEP1 下位机设备通信设...
安卓开发板之串口通信，通过modbus Rtu协议控制下位机
致力于互联网、物联网领域知识内容分享
11-25 7683
安卓开发板之串口通信，通过modbus Rtu协议控制下位机1.环境准备2.编写串口操作核心类3.编写测试类 1.环境准备 1）.使用该类需要将两个文件夹拷贝到项目目录中，这两个文件夹分别是jni,和jniLibs（jni就是Java本地接口，使用它可以实现java语言与其他语言的交互）jni和jniLibs的压缩包 2）配置app文件夹下的bulid.gradle文件（配置好后重新编译一次） ...
安卓手机实现wifi、蓝牙、usb打印快递小票
01-17
总的来说，安卓手机实现WiFi、蓝牙、USB打印快递小票涉及硬件接口的调用、打印机驱动的适配、ESC/POS指令的编写以及良好的用户交互设计。通过这三个示例项目，开发者可以学习到如何在安卓平台上进行外设通信，为快递...
安卓wifi蓝牙相关-基于socket的Android与Android的蓝牙通讯包含服务端和客户端.rar
07-29
总结来说，基于Socket的Android与Android蓝牙通讯涉及到的关键技术点包括： 1. Android BluetoothAdapter的使用。 2. BluetoothServerSocket和BluetoothSocket的创建与管理。 3. UUID的选择和使用，例如Rfcomm的UUID...
android 串口 上位机程序 集成wifi和蓝牙通信
01-28
在Android平台上开发串口上位机程序，集成WiFi和蓝牙通信功能是一项常见的需求，尤其在物联网(IoT)和嵌入式系统中。这个程序设计允许Android设备作为客户端，通过WiFi或蓝牙与服务器端模块进行数据交互。下面将详细...
RK3588 Android12调试USB 蓝牙模块
franc521的博客
04-12 4465
system/bt目录下，蓝牙协议栈代码和加载libbt-vendor.so库的代码，通常情况下建议使用原生的蓝牙协议栈【在system/bt目录】，如果有厂商的协议栈对原生协议栈做过较大的修正而必须使用厂商自己的协议栈的情况下在 jni 层完成对不同厂商协议栈【一般在hardware目录下】的加载。在device/rockchip/common/wifi_bt_common.mk文件（一般rk平台代码已经添加），这个先关闭BCM的芯片，防止BCM的影响。强制使能A2DP，则将上述接口屏蔽即可。
Android 数据传输方式 WIFI 蓝牙 USB
a772890398的博客
12-22 2378
1、WIFI 通过网络使用Socket来实现通信。 2、蓝牙 蓝牙2.0 和 蓝牙4.0BLE 蓝牙2.0 1、首先扫描到蓝牙 2、通过UUID来配对蓝牙    1）、安全模式是 要输入配对密码的    2）、非安全模式不需要输入配对密码 3、拿到蓝牙类获取BloothSockt进行通信 蓝牙4.0BLE 是针对可穿戴设备推出的低功耗设备。 Andro
基于WiFi模块的Android WiFi通信
Chen_xiaobao的博客
04-28 2439
基于ESP8266的Android WiFi通信广泛应用于物联网领域，常用是通过局域网实现Android端和下位机的通信，达到控制目的。 此篇文章记录的内容，需要手机连接到WiFi模块，通过wifi让Android端和硬件部分处于同一个局域网内。Android网络通信通过socket编程实现网络的连接，通过IO流实现数据的发送与接收。 首先，创建一个Android项目，首先，需要给予APP网络...
Android终端硬件通讯总结（串口通讯、Usb Com、Usb、蓝牙、Wifi）
Kelly
08-05 3660
Android上位机与外设通讯连接库
安卓enableNetwork连接不上指定wifi或连接wifi后断开，连接到其他wifi的原因和解决方法
pxshl的博客
07-24 1万+
原因：enableNetwork会断开的当前连接的wifi，再连接指定wifi，而此时系统检测到wifi断开，也会自动连接wifi（默认为最后连接成功的那个wifi），因此可能导致调用enableNetwork却无法连接到指定wifi，或者连接成功后又被断开。 解决方法：  修改wifi优先级是无效的，原因略。 有2种解决方法，第一种用反射得到WifiManager的connect方
关于安卓WIFI连接的几点随记
weixin_34304013的博客
06-11 181
一：使用到的3个广播a： WifiManager.SCAN_RESULTS_AVAILABLE_ACTION（处理WiFi扫描结果的）b：WifiManager.NETWORK_STATE_CHANGED_ACTION（网络状态变化）c：WifiManager.SUPPLICANT_STATE_CHANGED_ACTION（指示WPA请求状态）二：几个关键的类a：WifiManagerb：Wifi...
Android10连接WiFi时遇到的问题
nn690960430的博客
04-13 1万+
存在的问题：在真机测试时，我的手机安卓9，在使用addNetwork（）方法时功能是正常的，当换一个手机的时候（Android10）时发现连接WiFi的功能无法使用，在网上查阅资料，后发现安卓9和安卓10的连接WiFi的方法不一样，文档链接（https://developer.android.google.cn/guide/topics/connectivity/wifi-bootstrap#ja...
用 WifiManager 代码连接热点的一些坑
Mine
07-05 2545
WifiManager 连接热点的各种情况适配
使用Android的WiFiManager管理WiFi状态
最新发布
chuyouyinghe的专栏
10-18 716
通过使用Android的WiFiManager，我们可以轻松地管理设备的WiFi状态，包括打开/关闭WiFi、扫描可用网络和连接到指定网络。这为我们的移动体验增添了更多便利性。无论是在家中还是在外出，通过管理WiFi状态，我们能够更好地掌控我们的网络连接。希望这篇对你有所帮助！版权声明：本文为CSDN博主「晋级的程序员」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
A20 Android 4.2 WiFi+BT配置教程：EVB板详细指南
全志A20是一款基于Android 4.2平台的开发板，该平台支持多种Wi-Fi（包括USB和SDIO接口）和Wi-Fi+蓝牙（主要通过UART接口）模组的集成。本文档是针对A20 EVB板（Evaluation Board）的详细配置指南，版本为V0.2，发布...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值