android中wifidirect的操作学习

最新推荐文章于 2022-12-01 11:14:18 发布
最新推荐文章于 2022-12-01 11:14:18 发布
阅读量2.4k 收藏
点赞数 1
分类专栏： android 文章标签： android wifi network p2p
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mockingbirds/article/details/40794865
版权

android4.0以后增加了wifidirect直接连接，两台手机可以通过wifidirect直接连接，方便快速传递东西。

其中涉及到了几个常用的类

WifiP2pDevice表示具体的wifi设备

WifiManager用于代开关闭wifi状态的

WifiP2pManager用来控制整个连接过程操作的类

WifiP2pInfo用于获取连接设备信息的类

具体流程：

首先自定义一个广播接收者，用于监听mWifiP2pManager.initialize(MainActivity.this,getMainLooper(),null);返回的wifidirect状态，包含四个action，WifiDirectBroadReceiver.java

	@Override
	public void onReceive(Context context, Intent intent) {
		// TODO Auto-generated method stub
		String action = intent.getAction();

		if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {//P2P功能是否打开
			int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE,-1);// EXTRA_WIFI_STATE 为发现wifi P2p是否可见的key
			if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) {
				Log.d(TAG, "t"+state);
			}else{
				Log.d(TAG, "f"+state);
			}
		}
		if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {// 发现对等p2p
			if (manager != null) {
				manager.requestPeers(channel, (PeerListListener)activity);//
				Log.d(TAG, "WIFI_P2P_PEERS_CHANGED_ACTION请求当前对等信息执行");
			}
		}
		if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {//显示自己p2p信息
			activity.updateThisDevice((WifiP2pDevice) intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_DEVICE));
			Log.d(TAG,"显示自己的设备信息");
		}
		if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {//连接action
			if (null == manager) {
				return;
			}
			NetworkInfo netWorkInfo = intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO);
			if (netWorkInfo.isConnected()) {
				manager.requestConnectionInfo(channel,(ConnectionInfoListener)activity);
			}else {
				activity.resetData();
			}

		}
	}
新建类FindPeers实现PeerListListener接口，当搜索到可用的wifi设备时候，回调onPeersAvailable(WifiP2pDeviceList deviceList)方法

FindPeers.java

public class FindPeers implements PeerListListener {
	private static final String TAG = "findpeers";
	private List<WifiP2pDevice>list = new ArrayList<WifiP2pDevice>();
	private ProgressDialog progressDialog = null;
	private Context context;
	private WifiManager manager;
	private ListView listView;
	private Handler handler;
	
	public FindPeers(Context context,Handler handler) {
		this.context = context;
		manager = (WifiManager) context.getSystemService(context.WIFI_SERVICE);
		this.handler = handler;
	}
	
	/**
	 * 搜索对等的peers 启动WIFI_P2P_STATE_ENABLED action
	 */
	@Override
	public void onPeersAvailable(WifiP2pDeviceList deviceList) {
		
		list.clear();
		list.addAll(deviceList.getDeviceList());
		handler.sendEmptyMessage(1);
	}
	
	public boolean isWifiEnable() {
		if (manager != null) {
			return manager.isWifiEnabled();
		}else{
			return false;
		}
	}
	
	public void openWifi() {
		manager.setWifiEnabled(true);
	}
	
	public List<WifiP2pDevice> getP2pDevice() {
		return list;
	}

}

最后在MainActivity中的oncreate方法中进行IntentFilter必要的初始化，以及在onresume中注册已经写好的广播接受者

MainActivity.java

package com.example.wifidirect;

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

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.WifiManager;
import android.net.wifi.WpsInfo;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pInfo;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.ActionListener;
import android.net.wifi.p2p.WifiP2pManager.ChannelListener;
import android.net.wifi.p2p.WifiP2pManager.ConnectionInfoListener;
import android.net.wifi.p2p.WifiP2pManager.PeerListListener;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.telephony.TelephonyManager;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity implements  PeerListListener,ConnectionInfoListener,ChannelListener {

	private static final String TAG = "MainActivity";

	private final IntentFilter mIntentFilter = new IntentFilter();
	private WifiP2pManager mWifiP2pManager;
	//连接设备信息
	private WifiP2pInfo mInfo;
	private boolean isP2pEnabled = false;
	private List<WifiP2pDevice> mpeers =new ArrayList<WifiP2pDevice>();
	private ProgressDialog mProgressDialog = null;
	private WifiP2pDevice mWifiP2pDevice;
	private WifiP2pManager.Channel mChannel;
	private ListView mListView ;
	WifiPeerListAdapter adapter;
	private Button mSearchBtn;
	private FindPeers findPeers;
	private boolean retryChanel = false;
	private WifiDirectBroadReceiver mReceiver;
	/**自己设备的状态	 */
	private String mStatus = "avaliable";

	private TextView mRename;

	private static final int DIALOG_DISCONNECT  = 1;
	private static final int DIALOG_CANCEL_CONNECT = 2;
	private static final int DIALOG_RENAME = 3;

	String deviceName = "temp";

	Handler mHandler = new Handler() {
		public void handleMessage(android.os.Message msg) {
			switch (msg.what) {
			case 1:
				setAdapter();
				break;

			default:
				break;
			}

		};
	};



	@SuppressLint("ShowToast")
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);
		init();

		/**可以探测到有效距离内的对等设备*/
		mWifiP2pManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {

			@Override
			public void onSuccess() {//只会对成功探测到对等设备这一事件做出通知，而并不会提供任何关于已发现的对等设备的具体信息：
			}

			@Override
			public void onFailure(int arg0) {
				// TODO Auto-generated method stub

			}
		});

	}




	private void init() {

		mListView = (ListView) findViewById(R.id.lv);
		mRename = (TextView) findViewById(R.id.rename);
		mSearchBtn = (Button) findViewById(R.id.search);
		findPeers = new FindPeers(MainActivity.this,mHandler);

		mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
		mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
		mIntentFilter
				.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
		mIntentFilter
				.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);

		mWifiP2pManager = (WifiP2pManager) getSystemService(WIFI_P2P_SERVICE);
		if (null != mWifiP2pManager) {
			mChannel = mWifiP2pManager.initialize(MainActivity.this,getMainLooper(),null);
			if (mChannel == null) {
				Log.d(TAG,"setup connection fail");
				mWifiP2pManager = null;
			}
		}else{
			Log.d(TAG, "mWifiP2pManager is null");
		}

		mSearchBtn.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View arg0) {
				// TODO Auto-generated method stub
				if (!findPeers.isWifiEnable()) {
					findPeers.openWifi();
				}
				mpeers.clear();
				setAdapter();

				mWifiP2pManager.discoverPeers(mChannel, new ActionListener() {

					@Override
					public void onSuccess() {
						// TODO Auto-generated method stub
						Toast.makeText(MainActivity.this,"discover success",Toast.LENGTH_SHORT).show();
					}

					@Override
					public void onFailure(int arg0) {
						// TODO Auto-generated method stub
						Toast.makeText(MainActivity.this,"discover fail",Toast.LENGTH_SHORT).show();
					}
				});
			}
		});


	}

	/**
	 * 自定义显示adapter
	 * @author user
	 *
	 */
	private class WifiPeerListAdapter extends ArrayAdapter<WifiP2pDevice> {

		private List<WifiP2pDevice>items;
		public WifiPeerListAdapter(Context context,	int textViewResourceId, List<WifiP2pDevice> objects) {
			super(context, textViewResourceId, objects);
			items = objects;
		}

		public List<WifiP2pDevice> getItems() {
			return items;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			View v = convertView;
			if (null == v) {
				v = LayoutInflater.from(MainActivity.this).inflate(R.layout.row_devices1,null);
			}
			final WifiP2pDevice deviceInfo = items.get(position);
			if (deviceInfo != null) {
				TextView deviceName = (TextView) v.findViewById(R.id.device_name);
				TextView deviceDetail = (TextView) v.findViewById(R.id.device_details);
				if (null != deviceName) {
					deviceName.setText(deviceInfo.deviceName);
				}
				if (null != deviceDetail) {
					deviceDetail.setText(getStateStatus(deviceInfo.status));
				}
				final Button connect = (Button) v.findViewById(R.id.connect);
				if ("avaliable".equalsIgnoreCase(getStateStatus(deviceInfo.status))) {
					connect.setText("链接");
				}
				if ("connnected".equalsIgnoreCase(getStateStatus(deviceInfo.status))) {
					connect.setText("断开");
				}

				connect.setOnClickListener(new OnClickListener() {

					@Override
					public void onClick(View arg0) {
						// TODO Auto-generated method stub
						if (connect.getText().equals("链接")) {
							connect(createP2pConfig(deviceInfo));
						}
						if (connect.getText().equals("断开")) {
							cancleConnect(deviceInfo);
						}
					}
				});

			}
			return v;
		}

	}

	/**
	 * 得到链接的状态
	 * @param deviceStatus
	 * @return
	 */
	private static String getStateStatus(int deviceStatus) {
		switch (deviceStatus) {
		case WifiP2pDevice.AVAILABLE:
			return "avaliable";
		case WifiP2pDevice.CONNECTED:
			return "connnected";
		case WifiP2pDevice.FAILED:
			return "failed";
		case WifiP2pDevice.INVITED:
			return "invited";
		case WifiP2pDevice.UNAVAILABLE:
			return "unavailable";
		default:
			return "unknow";
		}

	}
	/**
	 * 连接指定的peer
	 * @param config
	 */
	public void connect(WifiP2pConfig config) {
		mWifiP2pManager.connect(mChannel, config, new ActionListener() {

			@Override
			public void onSuccess() {
				// TODO Auto-generated method stub
//				Log.d(TAG, "链接到设备："+mWifiP2pDevice.deviceName+"ipaddress:"+mWifiP2pDevice.deviceAddress);
			}

			@Override
			public void onFailure(int arg0) {
				// TODO Auto-generated method stub
				Toast.makeText(MainActivity.this,"connectfail",Toast.LENGTH_SHORT).show();
			}
		});
	}
	/**
	 * 根据device的信息，创建配置信息
	 * @param device
	 * @return
	 */
	public WifiP2pConfig createP2pConfig(WifiP2pDevice device) {
		WifiP2pConfig config = new WifiP2pConfig();
		config.deviceAddress = device.deviceAddress;
		config.wps.setup = WpsInfo.PBC;
		return config;
	}

	public void cancleConnect(WifiP2pDevice device) {
		if (null != mWifiP2pManager) {
			if (device == null || device.status == WifiP2pDevice.CONNECTED) {
				disConnect();
			}else if (device.status == WifiP2pDevice.AVAILABLE || device.status == WifiP2pDevice.INVITED) {
				mWifiP2pManager.cancelConnect(mChannel, new ActionListener() {

					@Override
					public void onSuccess() {
						// TODO Auto-generated method stub
						Toast.makeText(MainActivity.this,"cancleConnect success",Toast.LENGTH_LONG).show();
					}

					@Override
					public void onFailure(int arg0) {
						// TODO Auto-generated method stub
						Toast.makeText(MainActivity.this,"cancleconnect fail error"+arg0,Toast.LENGTH_LONG).show();
					}
				});
			}
		}



	}



	/**
	 * 断开连接
	 */
	public void disConnect() {
		mWifiP2pManager.removeGroup(mChannel, new ActionListener() {

			@Override
			public void onSuccess() {
				// TODO Auto-generated method stub
				mpeers.clear();
				setAdapter();
			}

			@Override
			public void onFailure(int arg0) {
				// TODO Auto-generated method stub
				Toast.makeText(MainActivity.this,"disconnect fail error"+arg0,Toast.LENGTH_LONG).show();
			}
		});
	}

	public void setAdapter() {
		if (null == adapter) {
			adapter = new WifiPeerListAdapter(MainActivity.this,R.layout.row_devices,mpeers);
			mListView.setAdapter(adapter);
		}else{
			for (WifiP2pDevice device: mpeers) {
				String name = device.deviceName;
				String sta = getStateStatus(device.status);
			}
			((WifiPeerListAdapter)mListView.getAdapter()).notifyDataSetChanged();
		}
	}

	/**
	 * action WIFI_P2P_THIS_DEVICE_CHANGED_ACTION检测自身device 显示自身设备信息
	 * @param device
	 */
	public void updateThisDevice(WifiP2pDevice device) {
		this.mWifiP2pDevice = device;
		TextView viewOne = (TextView) this.findViewById(R.id.tv);
		TextView viewTwo = (TextView) this.findViewById(R.id.tv1);
		String name = device.deviceName;
		String status = device.status+"";
		viewOne.setText(device.deviceName);
		viewTwo.setText(getStateStatus(device.status));
		mStatus = getStateStatus(device.status);
		Log.d(TAG, "连接前自己的地址"+device.deviceAddress);
	}

	/**
	 * 清空自身信息
	 */
	public void resetData() {
		mWifiP2pDevice = null;
		mpeers.clear();
		setAdapter();
	}

	@Override
	protected void onResume() {
		super.onResume();
		if (mReceiver == null) {
			mReceiver = new WifiDirectBroadReceiver(mWifiP2pManager, mChannel, this, findPeers);
		}
		registerReceiver(mReceiver, mIntentFilter);
	}

	@Override
	protected void onPause() {
		// TODO Auto-generated method stub
		super.onPause();
		if (mWifiP2pManager != null) {
			mWifiP2pManager.stopPeerDiscovery(mChannel, null);
		}
		unregisterReceiver(mReceiver);
	}


	@Override
	public void onPeersAvailable(WifiP2pDeviceList deviceList) {
		// TODO Auto-generated method stub
		mpeers.clear();
		mpeers.addAll(deviceList.getDeviceList());
		((WifiPeerListAdapter)mListView.getAdapter()).notifyDataSetChanged();
		if (mpeers.size() == 0) {
			Log.d(TAG, "no peer found");
		}
		mHandler.sendEmptyMessage(1);
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
		// TODO Auto-generated method stub
		if (keyCode == KeyEvent.KEYCODE_BACK) {
			if (mStatus.equalsIgnoreCase("Connect")) {
				disConnect();
			}
		}

		return super.onKeyDown(keyCode, event);
	}



	@Override
	public void onChannelDisconnected() {
		// TODO Auto-generated method stub
		if (mWifiP2pManager != null || ! retryChanel) {
			resetData();
			retryChanel = true;
			mWifiP2pManager.initialize(MainActivity.this,getMainLooper(),this);
		}
	}




	@Override
	public void onConnectionInfoAvailable(WifiP2pInfo arg0) {
		// TODO Auto-generated method stub

	}

}

源码连接： http://download.csdn.net/detail/mockingbirds/8121401


mockingbirds
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Android WifiDirect
qq_38412354的博客
08-28 1406
Android WifiDirect 1. 简介 WiFi直连也就是WiFi设备点对点连接（WiFi P2P），它允许具有适当硬件的Android 4.0（API级别14）或更高版本的设备通过Wi-Fi直接相互连接，而无需中间接入点。使用这些API，您可以发现并连接到其他设备（前提是每个设备支持Wi-Fi P2P），然后通过比蓝牙连接更长的距离快速连接进行通信。这对于在用户之间共享数据的应用程序很有用，例如多人游戏或照片共享应用程序。 Wi-Fi P2P API包含以下主要部分： 允许您发现，请求和连接到对
WiFi Direct详解（p2p使能，扫描，连接流程）基于Android8.1.0
一个Android菜鸟的博客
06-17 2万+
简介：Wi-Fi Direct技术的目的是在没有Wi-Fi AP的情况下由两个或者多个Wi-Fi设备互相之间进行高速的数据通信。通信完全基于TCP/IP 协议，因此对于开发基于Wi-Fi Direct的应用来说非常友好。 Wi-Fi Direct在刚提出时叫Wi-Fi Peer-to-Peer，所以也可以称作Wi-Fi P2P。它的主要竞争对手是Blue Tooth，在目前看来Wi-Fi Dire...
(Android)Wifi-Direct直连
weixin_30475039的博客
08-25 1211
因项目需要Pad端和手机端交互，采用wifi直连。查阅资料，大概写下一些资料和收获吧。注：大公司的代码带不出来，我也比较懒不想再认真去写一遍了，所以大概这个意思哦。 wifi直连也叫做wifi设备点对点连接(peer-peer)，不需要连接热点或者网络，需要打开wifi，就可以查找到附近的设备。大概可以分为以下步骤：1.设置以下权限，并且注意最小sdk=14 2.创建一个广播接收器，通过创...
android wifi-direct 实操指南
看！有只程序猿！
05-06 1901
太忙了，没时间写，如果你们只是想用，而不需要了解运作的的话直接用我上传到github的代码就好了，傻瓜式操作。 后面有时间我会进行补上内容 点击这里进入github...
Android -wifi 直连（wifi direct ）
menuconfig的专栏
02-27 3万+
现在，Android的支持Wi -Fi的直接点对点点对点（P2P）Android系统的供电设备和其他类型的设备，没有一个热点或互联网连接之间的连接。Android框架提供了一套Wi - Fi的P2P的API，允许你去发现和连接到其他设备时，每个设备的Wi -Fi的直接支持，然后沟通跨越距离远远长于蓝牙连接迅速​​连接。 android.net.wifi.p2p，一个新的软件包，包含所有的API执
android中wifidirect操作代码
11-04
该资源包含了一个android中的wifidirect实现的两台或多部手机之间的wifidirect直接连接的代码，简单易懂。
Android端WifiDirect文件传输Demo
10-21
Android端WifiDirect文件传输Demo，基于Google官方WifiDirect修改，实现了文件传输。
android wifi direct代码开启
12-07
android wifi direct代码开启，监听wifi热点的打开和关闭，修改热点名称和密码
Wroup：Android-WiFi Direct Library
02-03
Wroup是WiFi P2P Android库，也称为WiFi Direct。 该库为官方的WiFi Direct API添加了一层，以简化此操作。 库的名称来自Wroup的加入组+ WiFi，因为该库的目的是创建WiFi P2P组，并允许连接的对等方之间进行通信。 ...
android wifi direct Demo
09-22
wifi直连的工作流程
WIFI DIRECT demo
05-22
Wi-Fi直连技术的API包含以下主要部分： 允许用户发现，请求然后连接对等设备的各种方法，定义在WifiP2pManager类中。 允许用户定义收到调用WifiP2pManager类中方法成功或失败的通知的监听器。当用户调用WifiP2pManager类中的方法时，每一个方法都可以收到一个以参数形式传过来的特定监听。 通知用户被Wi-Fi直连技术框架检测到的特定事件的意图，比如一个已丢掉的连接或者一个新的对等设备的发现等。
Android WiFiDirect 一个jar包搞定一切
coycleipenghui的专栏
09-20 5264
概要： 本文主要介绍基于Android原生WiFidirect封装的jar包。其中实现的要点有： 1，IP列表管理； 2，一行代码配置WiFidirect； 3，实现了文本，文件，buffer的通信传递； 4，自动连接与恢复（当应用强制退出后，再次进入的自动连接过程）。 以上4点都是原生WiFidirect未实现的，相信对想基于WiFidirect进行开发的朋友会有所帮助。想必对WiFi
Android WifiDirect学习(一)
weixin_30855099的博客
07-07 266
WiFi Direct基本介绍 Wi-Fi Direct标准允许无线网络中的设备无需通过无线路由器即可相互连接。与蓝牙技术类似，这种标准允许无线设备以点对点形式互连，不过在传输速度与传输距离方面则比蓝牙有大幅提升。 Wi-Fi Direct可以支持一对一直连，也可以实现多台设备同时连接 WiFiDirect 一对一 搜索/连接/传输基本流程 第一步：初始化WifiDirect模...
direct wifi 芯片_Android WifiDirect 学习（三） 一些基础知识和问题
weixin_35167817的博客
12-23 281
P2P架构介绍P2P架构中定义了三个组件，一个设备，两种角色。这三个组件分别是：P2P Device：它是P2P架构中角色的实体，读者可把它当做一个Wi-Fi设备。P2P Group Owner(GO)：P2P网络建立时会产生一个Group。P2P Group Client(GC)：在组建P2P Group(即P2P Network)之前，智能终端都是一个一个的P2P Device。当这些P2P ...
Android WiFi直连 双向通信
奋斗的菜鸟ing
09-02 1万+
本文主要说一下，Android通过WIFi直连的方式实现图片双向传输（图片可以传输，也可以把它修改下传输聊天信息了）。 WiFi直连概述 WiFi直连也就是WiFi设备点对点连接（WiFi P2P），它允许具有适当硬件的Android 4.0（API级别14）或更高版本的设备通过Wi-Fi直接相互连接，而无需中间接入点。使用这些API，您可以发现并连接到其他设备（前提是每个设备支持Wi-F...
【WLAN】Android 13 p2p / wifi direct介绍
weixin_47456647的博客
12-01 1942
【WLAN】Android 13 p2p / wifi direct介绍
Android11 WiFi连接流程梳理
一个Android菜鸟的博客
09-10 9478
梳理一下Android11的wifi连接流程。 一、可以看到点击连接以后，如果config不为null，则先保存网络，再进行连接，所以即使连接失败，此网络依然在已保存网络列表里。 packages/apps/Settings/src/com/android/settings/wifi/WifiSettings.java void submit(WifiConfigController configController) { final WifiConfiguration config = conf
Android Wifi Direct 安卓手机间wifi直连
热门推荐
瞎几把学
04-13 3万+
 Wi-Fi Direct™的API允许应用程序不通过网络或热点，直接与周围的设备进行连接。应用程序可以迅速地查找附近的设备，交换信息。并且与蓝牙相比，Wi-Fi Direct的通讯范围更大。 这节课将向你介绍，如何使用Wi-Fi Direct查找附近的设备，并与之连接。 设置应用程序权限 - Set Up Application Permissions 使用Wi-Fi Direc
android wifidirect启动流程
最新发布
05-12
Android WifiDirect启动流程主要包括以下几个步骤： 1. 检查设备是否支持WifiDirect功能。Android系统会通过硬件和软件检测来确定设备是否能够支持WifiDirect。 2. 打开WifiDirect并搜索设备。WifiDirect需要打开...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值