Android WI-Fi直连实现

已于 2022-10-14 14:49:15 修改
阅读量1.3k 收藏 5
点赞数 2
分类专栏： Android 个人笔记 文章标签： p2p 网络 网络协议
于 2022-10-09 20:56:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_pun/article/details/127233803
版权

P2P Demo

整个的调用流程已经用编号在代码中编写好，跟随代码即可理顺逻辑
参考至官方文档

链接: WI-FI直连

MainActivity
public class MainActivity extends AppCompatActivity {
    private static String TAG = "P2P_Test MainActivity";
    private final static int SERVER_PROt = 8888;
    private ListView mListView;
    private ArrayAdapter<String> mWiFiPeerListAdapter;

    private WifiP2pManager.Channel mChannel;
    private WifiP2pManager mManager;
    private IntentFilter intentFilter = new IntentFilter();
    private WiFiDirectBroadcastReceiver mReceiver;
    private boolean mIsWifiP2pEnabled = false;

    private List<WifiP2pDevice> mPeers = new ArrayList<>();
    private List<String> mDeviceNames = new ArrayList<>();
    private WifiP2pManager.PeerListListener peerListListener = new WifiP2pManager.PeerListListener() {
        @Override
        public void onPeersAvailable(WifiP2pDeviceList peerList) {

            Collection<WifiP2pDevice> refreshedPeers = peerList.getDeviceList();
            mPeers.clear();
            mDeviceNames.clear();
            mPeers.addAll(refreshedPeers);
            for (WifiP2pDevice peer : refreshedPeers){
                mDeviceNames.add(peer.deviceName);
            }

            mWiFiPeerListAdapter.notifyDataSetChanged();
        }
    };

    private WifiP2pManager.ConnectionInfoListener connectionInfoListener = new WifiP2pManager.ConnectionInfoListener() {
        @Override
        public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {
            // InetAddress from WifiP2pInfo struct.
            String groupOwnerAddress = wifiP2pInfo.groupOwnerAddress.getHostAddress();
            //7.连接成功!!
            Log.v(TAG,"7.连接成功!!");

            if (wifiP2pInfo.groupFormed && wifiP2pInfo.isGroupOwner) {
                //群主
                Log.v(TAG,"Group ---- > 群主?");
                createServerSocket();
            } else if (wifiP2pInfo.groupFormed) {
                //组员
                Log.v(TAG,"Group ---- > 组员?");
                createClientSocket(groupOwnerAddress);
            }
        }
    };

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

        initListView();

        //1.申请权限
        Log.v(TAG,"1.申请权限");
        getPermission();
        //2.初始化 P2p Manager 和 Channel
        Log.v(TAG,"2.初始化 P2p Manager 和 Channel");
        mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mManager.initialize(this, getMainLooper(), null);
        Log.v(TAG,"3.启动广播监听器");
        // Indicates a change in the Wi-Fi P2P status.
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        // Indicates a change in the list of available peers.
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        // Indicates the state of Wi-Fi P2P connectivity has changed.
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        // Indicates this device's details have changed.
        intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        mReceiver = new WiFiDirectBroadcastReceiver(mManager, mChannel, this,peerListListener,connectionInfoListener);
        registerReceiver(mReceiver, intentFilter);

        findViewById(R.id.create_p2p_group).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 3.服务器创建 Group
                Log.v(TAG,"3.服务器创建 Group");
                createP2PGroup();
            }
        });

        findViewById(R.id.sacn_p2p_group).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //4.启动搜索对等设备
                Log.v(TAG,"4.启动搜索对等设备");
                sacnP2PGroup();
            }
        });
    }

    @SuppressLint("MissingPermission")
    private void sacnP2PGroup() {
        Log.v(TAG,"4.启动搜索对等设备 p2p是否可用 : " + mIsWifiP2pEnabled);
        if (mIsWifiP2pEnabled){
            mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {

                @Override
                public void onSuccess() {
                    Log.v(TAG,"4.启动搜索对等设备 p2p搜索是否启动成功 : true");
                    //搜索启动 成功
                }

                @Override
                public void onFailure(int reasonCode) {
                    Log.v(TAG,"4.启动搜索对等设备 p2p搜索是否启动成功 : false");
                    //搜索启动 失败
                }
            });
        }
    }

    public void setIsWifiP2pEnabled(boolean isWifiP2pEnabled){
        mIsWifiP2pEnabled = isWifiP2pEnabled;
    }


    private void getPermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            boolean location = checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
            boolean changeWifiState = checkSelfPermission(android.Manifest.permission.CHANGE_WIFI_STATE) == PackageManager.PERMISSION_GRANTED;
            boolean accessWifiState = checkSelfPermission(android.Manifest.permission.ACCESS_WIFI_STATE) == PackageManager.PERMISSION_GRANTED;
            boolean changeNetworkState = checkSelfPermission(android.Manifest.permission.CHANGE_NETWORK_STATE) == PackageManager.PERMISSION_GRANTED;
            boolean internet = checkSelfPermission(android.Manifest.permission.INTERNET) == PackageManager.PERMISSION_GRANTED;
            boolean accessNetWorkState = checkSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) == PackageManager.PERMISSION_GRANTED;


            boolean result = location && changeWifiState && accessWifiState && changeNetworkState && internet && accessNetWorkState;

            if (!result){
                requestPermissions(new String[]{
                        android.Manifest.permission.ACCESS_FINE_LOCATION,
                        android.Manifest.permission.CHANGE_WIFI_STATE,
                        android.Manifest.permission.ACCESS_WIFI_STATE,
                        android.Manifest.permission.CHANGE_NETWORK_STATE,
                        android.Manifest.permission.INTERNET,
                        android.Manifest.permission.ACCESS_NETWORK_STATE,
                },233);
            }
        }
    }

    private void initListView() {
        mListView = findViewById(R.id.device_list);
        mWiFiPeerListAdapter = new ArrayAdapter<String>(
                this,
                android.R.layout.simple_expandable_list_item_1,
                mDeviceNames
        );
        mListView.setAdapter(mWiFiPeerListAdapter);
        mListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                //6.点击，连接设备
                Log.v(TAG,"6.点击，连接设备");
                connect(position);
            }
        });
    }

    @SuppressLint("MissingPermission")
    public void connect(int position) {
        // Picking the first device found on the network.
        WifiP2pDevice device = mPeers.get(position);

        WifiP2pConfig config = new WifiP2pConfig();
        config.deviceAddress = device.deviceAddress;
        config.wps.setup = WpsInfo.PBC;

        mManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {

            @Override
            public void onSuccess() {
                // WiFiDirectBroadcastReceiver notifies us. Ignore for now.
                Log.v(TAG,"6.点击，连接设备  连接是否启动成功 : true");
            }

            @Override
            public void onFailure(int reason) {
                Log.v(TAG,"6.点击，连接设备  连接是否启动成功 : false");
            }
        });
    }

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

        //最后，一定要退群和取消连接
        cancelConnect();
        removeGroup();
    }

    public void cancelConnect() {
        mManager.cancelConnect(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.v(TAG,"取消连接 成功");
            }

            @Override
            public void onFailure(int reason) {
                Log.v(TAG,"取消连接 失败");
            }
        });
    }

    public void removeGroup() {
        mManager.removeGroup(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                Log.v(TAG,"移除组群 成功");
            }

            @Override
            public void onFailure(int reason) {
                Log.v(TAG,"移除组群 失败");
            }
        });
    }

    @SuppressLint("MissingPermission")
    private void createP2PGroup() {
        setDeviceName("My_P2P_Group");
        mManager.createGroup(mChannel, new WifiP2pManager.ActionListener() {
            @Override
            public void onSuccess() {
                // Device is ready to accept incoming connections from peers.
                Log.v(TAG,"3.服务器创建 Group  创建是否成功 : true");
            }

            @Override
            public void onFailure(int reason) {
                Log.v(TAG,"3.服务器创建 Group  创建是否成功 : false");
            }
        });
    }

    public void setDeviceName(String devName) {

        try {
            Class[] paramTypes = new Class[3];
            paramTypes[0] = WifiP2pManager.Channel.class;
            paramTypes[1] = String.class;
            paramTypes[2] = WifiP2pManager.ActionListener.class;
            Method setDeviceName = mManager.getClass().getMethod(
                    "setDeviceName",paramTypes);
            setDeviceName.setAccessible(true);
            Object arglist[] = new Object[3];
            arglist[0] = mChannel;
            arglist[1] = devName;
            arglist[2] = new WifiP2pManager.ActionListener() {

                @Override
                public void onSuccess() {
                    Log.v(TAG,"setDeviceName succeeded");
                }

                @Override
                public void onFailure(int reason) {
                    Log.v(TAG,"setDeviceName Failed" + reason);
                }
            };
            setDeviceName.invoke(mManager,arglist);

        } catch (Exception e) {
            Log.v(TAG,e.getMessage());
            e.printStackTrace();
        }

    }

    private void createServerSocket() {
        new AsyncTask<Void,Void,Void>(){
            @Override
            protected Void doInBackground(Void... voids) {
                try {
                    //8.创建serverSocket
                    Log.v(TAG,"8.创建serverSocket");
                    ServerSocket serverSocket = new ServerSocket(SERVER_PROt);
                    Socket socket = serverSocket.accept();
                    InputStream is = socket.getInputStream();

                    String text = readText(is);
                    //11.接收客户端数据
                    Log.v(TAG,"11.接收客户端数据 : " + text);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }.execute();
    }

    private void createClientSocket(String groupOwnerAddress) {
        new AsyncTask<Void,Void,Void>(){

            @Override
            protected Void doInBackground(Void... voids) {
                try {
                    //9.创建ClientSocket
                    Log.v(TAG,"9.创建ClientSocket");
                    Socket socket = new Socket(groupOwnerAddress,SERVER_PROt);
                    OutputStream os = socket.getOutputStream();
                    PrintStream ps = new PrintStream(os);
                    //10。连接后发送数据
                    Log.v(TAG,"10。连接后发送数据");
                    ps.println("!!!群主好!!!");
                    ps.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }.execute();
    }


    public static String readText(InputStream inputStream) throws IOException {
        if (inputStream == null) {
            return null;
        }
        byte[] bytes = new byte[inputStream.available()];
        int length = inputStream.read(bytes);
        return new String(bytes, 0, length, Charset.defaultCharset());
    }
}
activity_main 布局
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:orientation="vertical">

    <Button
        android:id="@+id/create_p2p_group"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="create_p2p_group"/>
    <Button
        android:id="@+id/sacn_p2p_group"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="sacn_p2p_group"/>

    <ListView
        android:id="@+id/device_list"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</LinearLayout>
WiFiDirectBroadcastReceiver
public class WiFiDirectBroadcastReceiver extends BroadcastReceiver {
    private static String TAG = "P2P_Test WiFiDirectBroadcastReceiver";

    private WifiP2pManager mManager;
    private WifiP2pManager.Channel mChannel;
    private MainActivity mActivity;
    private WifiP2pManager.PeerListListener mListener;
    private WifiP2pManager.ConnectionInfoListener mConnectionListener;

    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, WifiP2pManager.Channel channel,
                                       MainActivity activity, WifiP2pManager.PeerListListener listener,
                                       WifiP2pManager.ConnectionInfoListener connectionListener) {
        mManager = manager;
        mChannel = channel;
        mActivity = activity;
        mListener = listener;
        mConnectionListener = connectionListener;
    }

    @SuppressLint("MissingPermission")
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.v(TAG,"action --- > " + action);
        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
            // Determine if Wifi P2P mode is enabled or not, alert
            // the Activity.
            int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
            if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
                mActivity.setIsWifiP2pEnabled(true);
            } else {
                mActivity.setIsWifiP2pEnabled(false);
            }
        } else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
            //5.获取搜索结果，并返回
            Log.v(TAG,"5.获取搜索结果");
            if (mManager != null) {
                mManager.requestPeers(mChannel, mListener);
            }

        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
            if (mManager == null) {
                return;
            }

            NetworkInfo networkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);

            if (networkInfo.isConnected()) {
                Log.v(TAG,"6.点击，连接设备 连接成功");
                mManager.requestConnectionInfo(mChannel, mConnectionListener);
            }else {
                Log.v(TAG,"6.点击，连接设备 连接失败");
            }

        } else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {


        }
    }
}
csdn_pun
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Android Wifi——WLAN直连（十三）
小旭的专栏
04-06 1188
WLAN 直连 (对等连接或P2P) 技术，通过 WLAN 进行直接互联。使用这些 API，您可以实现支持 WLAN P2P 的设备间相互发现和连接，从而获得比蓝牙连接更远距离的高速连接通信效果。对于多人游戏或照片共享等需要在用户之间共享数据的应用而言，这一技术非常有用。
Android WLAN 直连（对等连接或 P2P）
saiarcburn的博客
01-17 3400
Android Wifi Direct开发Demo
Android Wifi连接demo
04-28
Android Wifi模块，实现了一些wifi常用的接口封装，可以实现wifi密码连接是否成功，wifi的加密发誓，wifi的(有无)密码连接等等。
android wifi直连 wifip2pmanager
最新发布
一航jason
04-15 600
Android WiFi 直连（Wi-Fi Direct，也称为Wi-Fi P2P）是一种让两台或多台设备通过Wi-Fi技术直接进行点对点连接的技术，无需借助传统的无线路由器或接入点。在这个组中，一台设备会被选为“组主人”（Group Owner，GO），相当于小型网络的接入点，负责管理组内的连接和数据传输。设备发现：启用Wi-Fi Direct功能的设备可以通过广播信号搜索和发现附近的其他支持Wi-Fi Direct的设备。连接请求：用户在设备列表中选择要连接的目标设备后，发起连接请求。
wifi工具类
xiaoerbuyu1233的博客
08-04 128
忘哪儿看到的了,保存一下。
Wi-Fi直连分享：Android设备间的高速连接
chuyouyinghe的专栏
10-05 782
随着无线局域网（Wi-Fi）的普及和发展，使用Wi-Fi直连技术（P2P）在没有中间接入点的情况下实现设备间直接互联成为可能。通过Wi-Fi直连，具备相应硬件的Android 4.0及更高版本设备可以实现高速连接通信，比传统蓝牙连接具有更远的传输距离。你可以根据自己的需求来选择合适的服务类型和设置相应的监听器来处理搜索到的设备服务。的网络，这个网络是为没有Wi-Fi直连功能的设备准备的，它们可以通过连接此网络来加入群组。是通过设备发现获得的对方设备信息，后续会介绍广播的相关内容。
Android 应用内连接指定 WIFI
qq_21216109的博客
11-26 5225
广播过滤Action WifiManager.NETWORK_STATE_CHANGED_ACTION 工具类 package com.yw.wifipage.wifi; import android.content.Context; import android.content.IntentFilter; import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.ne.
Android WIFI 配置、连接
MyLoveGame的专栏
03-22 5617
WIFI 扫描 配置 连接；代码主要摘自系统设置里面的代码，本文主要记住解析扫描wifi的加密类型已经对应的创建wifi加密配置
wifi-easy-transfer:在Android设备中通过Wi-Fi对等共享任何大小的文件
05-21
通过Wi-Fi Direct，"WiFi-Easy-Transfer"实现了设备间的直连通信，从而能够快速传输大文件。 2. **Android的Java编程**：本项目基于Java语言开发，这是Android平台的主要编程语言。Java具有跨平台性、丰富的类库和...
Android系统WIFI直连demo源码
11-21
总之，Android系统的Wi-Fi直连功能为开发者提供了便捷的设备间通信途径，结合提供的demo源码，可以快速理解和实现相关功能。在实际开发过程中，应根据具体需求进行定制和优化，以提供更好的用户体验。
Android-使用NearbyAPI远程连接WiFiheadless设备
08-13
这是一个跨平台的API，允许Android和Chrome OS设备发现彼此，并通过蓝牙、Wi-Fi直连或超声波进行短距离通信。在Android应用中，Nearby API可以用于设备配对、数据传输等场景，尤其适用于需要快速、无需用户手动配置...
Android WIFI直连源码
05-29
为了确保Wi-Fi直连功能的稳定性和兼容性，开发者需要关注Android系统的版本差异，因为某些API在不同版本中可能会有所变化。同时，测试时应涵盖多种设备和网络环境，以确保良好的用户体验。 总之，Android WIFI直连...
基于Android无线直连的抢答系统.pdf
09-21
Android无线直连是一种允许Android设备之间直接建立无线连接的技术，无需通过Wi-Fi热点或路由器。这种技术使得多个Android智能设备可以直接进行数据交换，为抢答系统的实现提供了基础。由于Android系统的普及以及Wi-...
android通过代码连接wifi
11-06 2165
Android SDK API 29（对应Android 10）以下，可以在app之中通过代码直接设置wifi名称和密码进行连接。API 29及其以上版本，增加了动态管理权限功能，启用了之前的接口，同时app连接wifi时必须通过用户同意，具体方式是弹出一个Activity显示wifi列表，用户点击之后再返回app。
Android Wifi——WiFi连接（八）
小旭的专栏
03-17 1353
源码位置：/packages/modules/Wifi/service/java/com/android/server/wifi/WifiBlocklistMonitor.java。源码位置：/packages/modules/Wifi/service/java/com/android/server/wifi/WifiServiceImpl.java。源码位置：/packages/modules/Wifi/framework/java/android/net/wifi/WifiManager.java。
Android NDK开发详解连接性之将 WLAN 直连（点对点）用于服务发现
hnjzfwy的博客
11-18 193
原生开发套件 (NDK) 是一套工具，使您能够在 Android 应用中使用 C 和 C++ 代码，并提供众多平台库，您可使用这些平台库管理原生 activity 和访问实体设备组件，例如传感器和触控输入。NDK 可能不适合大多数 Android 编程初学者，这些初学者只需使用 Java 代码和框架 API 开发应用
Android WIFI连接总结
weixin_40812272的博客
11-24 3222
Android10、11、12连接WIFI
Android实践 -- Android Wi-Fi 直连 传输数据
07-27
对于 Android Wi-Fi 直连传输数据的实践，可以使用 Android 的 Wi-Fi P2P（Wi-Fi Direct）功能来实现。下面是一个简单的示例代码，演示了如何在两台设备之间进行 Wi-Fi 直连传输数据： 首先，在 AndroidManifest....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值