WiFi P2P network in Android Things

See also questions close to this topic

• Waiting for a message using Bluetoothctl

  I'm working on linux application. I'm planning to use bluetoothctl for bluetooth communication. Is it possible to receive string from android app ? Please provide any tutorial pages. I heard about RFCOMM as well what is the difference with bluetoothcli. Please provide information. Thanks
• BLE - Bluetooth GATT service can't close connection

  I have implemented BLE and it works. The flow is: DrawerActivity starts, it sets a fragmentA, which has BLE implementation, because I want active BLE only in fragmentA. So if you switch to fragmentB it should terminate the BLE connection and upair the device.

  What happens is that the only time it completely disconnects is, when you close the app, or turn off the bluetooth. If you close the fragmentA and open it again it works from drawerActivity. If you do it again, so this is now the 3rd time, it won't pair to the BLE device. When I investigated further, it won't even find the correct BLE device.. Meaning if you run the fragment the 4th, 5th time it is the same result.

  What I want to achieve is when onDestroy in Fragment is called it should disconnect from the BLE and destroy all references. And then if you go into the fragmentA again it should recreate everything again, no matter how many times you open the fragmentA.But now the device isn't found anymore, probably because it didn't disconnect properly and BLE device has old references or something. This is how I disconnect.

  This is onDestroy method:

      override fun onDestroy() {
      super.onDestroy()
  
      activity?.unregisterReceiver(bluetoothReceiver)
      bluetoothManager?.disconnectBluetoothService()
      bluetoothManager = null
  }
  

  And in bluetoothManager

  fun disconnectBluetoothService() {
      bluetoothService?.disconnectGattServer()
  }
  

  And at the bluetoothService:

  fun disconnectGattServer() {
      mConnected = false
      mBluetoothGatt?.disconnect()
      mBluetoothGatt?.close()
      mBluetoothGatt = null
  }
  

  Here are the all 3 files that are used for BLE.

  FragmentA

  private var bluetoothManager: MyBluetoothManager? = null
  
  private val bluetoothReceiver = object : BroadcastReceiver() {
          override fun onReceive(context: Context, intent: Intent) {
              val action = intent.action
  
              if (action == BluetoothAdapter.ACTION_STATE_CHANGED) {
                  when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)) {
                      BluetoothAdapter.STATE_OFF -> {}
                      BluetoothAdapter.STATE_ON -> {
                          initBluetoothIfPossible()
                          bluetoothManager?.scanForBluetoothDevicesIfPossible(true)
                      }
                  }
              }
          }
      }
  
      override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
          super.onViewCreated(view, savedInstanceState)
  
          listenToBluetoothChanges()
      }
  
      override fun onDestroy() {
          super.onDestroy()
  
          activity?.unregisterReceiver(bluetoothReceiver)
          bluetoothManager?.disconnectBluetoothService()
          bluetoothManager = null
      }
  
      private fun listenToBluetoothChanges() {
          val filter = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)
          carSharingActivity?.registerReceiver(bluetoothReceiver, filter)
      }
  
      private fun initBluetoothIfPossible() {
          bluetoothToken ?: return
          if (bluetoothManager != null) {
              bluetoothManager!!.pairDevice()
          } else {
              bluetoothManager = MyBluetoothManager(activity as Activity,
                      this,
                      bluetoothToken!!.token,
                      bluetoothToken!!.sessionKey,
                      bluetoothToken!!.uuid)
          }
          setImageForBluetoothStatus()
      }
  

  MyBluetoothManager

  class ACCarBluetoothManager(var activity: Activity,
                              var listener: MyBluetoothListener,
                              private var token: String,
                              private var sessionKey: String,
                              private var accessDeviceUID: String) {
          // Bluetooth adapter
          private var bluetoothAdapter: BluetoothAdapter?
  
          // Bluetooth service
          private var bluetoothService: MyBluetoothService? = null
          private var isBluetoothAvailable: Boolean = false
  
          val isBluetoothEnabled: Boolean
              get() = bluetoothAdapter?.isEnabled == true
          var connectionStatus: Boolean = false
              set(value) {
                  if (field == value) return
                  field = value
                  if (value) stopScanning()
                  else startScanning()
              }
          private var savedDevice: BluetoothDevice? = null
      /**
           * Service lifecyle management.
           */
          private val serviceConnection = object : ServiceConnection {
              override fun onServiceConnected(componentName: ComponentName, service: IBinder) {
                  bluetoothService = (service as MyBluetoothService.LocalBinder).service
  
                  bluetoothService?.isConnectedListener = { isConnected ->
                      listener.isConnected(isConnected)
                      connectionStatus = isConnected
                  }
  
                  isBluetoothAvailable = bluetoothService?.initialize() == true
              }
  
              override fun onServiceDisconnected(componentName: ComponentName) {
                  bluetoothService = null
                  connectionStatus = false
              }
          }
  
          /**
           * Broadcast receiver.
           */
  
          private val gattUpdateReceiver = object : BroadcastReceiver() {
              override fun onReceive(context: Context, intent: Intent) {
                  try {
                      when (intent.action) {
                          BluetoothConstants.ACTION_GATT_SERVICES_DISCOVERED -> bluetoothService?.initializeIndications()
                          BluetoothConstants.ACTION_INDICATIONS_INITIALIZED -> bluetoothService?.startAuthentication(token)
                      }
                  } catch (e: Exception) {
                      Log.e("GattUpdateReciever", e.message)
                  }
              }
          }
  
          /**
           * Bluetooth device scanning callback. The scanned device is added to the list of available
           * devices.
           */
          private val bluetoothScanCallback = object : ScanCallback() {
              override fun onScanResult(callbackType: Int, result: ScanResult) {
                  super.onScanResult(callbackType, result)
                  val btDevice = result.device
                  if (btDevice.name.isNullOrEmpty()) return
  
                  if (deviceMatchesUID(btDevice)) {
                      savedDevice = btDevice
                      pairDevice()
                  }
              }
          }  
  
          init {
              val gattServiceIntent = Intent(activity, MyBluetoothService::class.java)
              activity.bindService(gattServiceIntent, this.serviceConnection, Context.BIND_AUTO_CREATE)
  
              // Setup bluetooth adapter
              val bluetoothManager = activity.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
              bluetoothAdapter = bluetoothManager.adapter
  
              // If bluetooth is not enabled, request permission, otherwise start scanning process, Not IMPLEMENTED, because it is not needed.
              scanForBluetoothDevicesIfPossible()
              activity.registerReceiver(gattUpdateReceiver, BluetoothConstants.makeGattUpdateIntentFilter())
          }
  
          fun scanForBluetoothDevicesIfPossible(enable: Boolean = isBluetoothEnabled) {
              val hasLocationPermission = ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
              if (enable) {
                  if (hasLocationPermission) {
                      startScanning()
                  }
                  //You can request for location permission if he doesn't have permission
              } else {
                  stopScanning()
              }
          }
  
  
          fun pairDevice() {
              if (isBluetoothAvailable && savedDevice != null) {
                  bluetoothService?.connect(savedDevice!!)
              }
          }
  
          fun startScanning() {
              bluetoothAdapter?.bluetoothLeScanner?.startScan(bluetoothScanCallback)
          }
  
          fun stopScanning() {
              bluetoothAdapter?.bluetoothLeScanner?.stopScan(bluetoothScanCallback)
          }
  
          fun deviceMatchesUID(device: BluetoothDevice): Boolean {
              return device.name.equals(accessDeviceUID, ignoreCase = true)
          }
  }
  

  MyBluetoothService

  class ACCarBluetoothService : Service() {
      var isConnectedListener: ((Boolean) -> Unit)? = null
      var mConnected = false
          set(value) {
              field = value
              isConnectedListener?.invoke(value)
          }
      private val mBinder = LocalBinder()
      private var mBluetoothManager: BluetoothManager? = null
      private var mBluetoothAdapter: BluetoothAdapter? = null
      private var mBluetoothGatt: BluetoothGatt? = null
      private var mDividedTokenList: MutableList<ByteArray>? = null
      // Various callback methods defined by the BLE API.
      private val mGattCallback = object : BluetoothGattCallback() {
          override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
              if (status == BluetoothGatt.GATT_FAILURE
                      || status != BluetoothGatt.GATT_SUCCESS
                      || newState == BluetoothProfile.STATE_DISCONNECTED) {
                  disconnectGattServer()
                  return
              }
  
              if (newState == BluetoothProfile.STATE_CONNECTED) {
                  gatt.discoverServices()
              }
  
          }
  
          override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
              if (status == BluetoothGatt.GATT_SUCCESS) onServiceDiscoveryReady()
          }
  
          override fun onDescriptorWrite(gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) {
              when {
                  descriptor.characteristic.uuid == BluetoothConstants.UUID_COMMAND_CHALLENGE -> setCharacteristicNotification(
                          BluetoothConstants.UUID_DEBUG,
                          true)
                  descriptor.characteristic.uuid == BluetoothConstants.UUID_DEBUG -> setCharacteristicNotification(
                          BluetoothConstants.UUID_STATUS_1,
                          true)
                  descriptor.characteristic.uuid == BluetoothConstants.UUID_STATUS_1 -> setCharacteristicNotification(
                          BluetoothConstants.UUID_STATUS_2,
                          true)
  
                  descriptor.characteristic.uuid == BluetoothConstants.UUID_STATUS_2-> setCharacteristicNotification(
                          BluetoothConstants.UUID_STATUS_3,
                          true)
                  else -> onIndicationsInitialized()
              }
          }
  
          override fun onCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
              if (status == BluetoothGatt.GATT_SUCCESS) broadcastUpdate(characteristic)
          }
  
          override fun onCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
              if (characteristic.uuid == BluetoothConstants.UUID_COMMAND_CHALLENGE) {
                  commandChallenge = characteristic.value
              } else {
                  broadcastUpdate(characteristic)
              }
          }
  
          override fun onCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
              if (BluetoothConstants.UUID_AUTHORIZE_PHONE == characteristic.uuid) writeNextPartToken()
          }
      }
  
      override fun onBind(intent: Intent): IBinder? {
          return mBinder
      }
  
      /**
       * Initializes a reference to the local Bluetooth adapter.
       *
       * @return Return true if the initialization is successful.
       */
      fun initialize(): Boolean {
          if (mBluetoothManager == null) {
              mBluetoothManager = getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
              if (mBluetoothManager == null) return false
          }
  
          mBluetoothAdapter = mBluetoothManager!!.adapter
          if (mBluetoothAdapter == null) return false
          return true
      }
  
  
      fun initializeIndications() {
          setCharacteristicNotification(BluetoothConstants.UUID_COMMAND_CHALLENGE, true)
      }
  
      fun startAuthentication(token: String) {
          mDividedTokenList = Tools.divideArray(Tools.decodeBase64(token))
          writeNextPartToken()
      }
  
      fun writeCommand(sessionKey: String, command: ByteArray) {
          val safeCommand = Tools.generateSafeCommand(command, commandChallenge, Tools.decodeBase64(sessionKey))
          val commandCharacteristic = mBluetoothGatt!!.getService(BluetoothConstants.UUID_CAR_CONTROL_SERVICE)
                  .getCharacteristic(BluetoothConstants.UUID_COMMAND_PHONE)
          commandCharacteristic.value = safeCommand
          mBluetoothGatt!!.writeCharacteristic(commandCharacteristic)
      }
  
      fun connect(device: BluetoothDevice) {
          mBluetoothGatt = device.connectGatt(this, false, this.mGattCallback)
      }
  
      fun disconnectGattServer() {
          mConnected = false
          mBluetoothGatt?.disconnect()
          mBluetoothGatt?.close()
          mBluetoothGatt = null
      }
  
  
      private fun onIndicationsInitialized() {
          val intent = Intent()
          intent.action = BluetoothConstants.ACTION_INDICATIONS_INITIALIZED
          sendBroadcast(intent)
      }
  
      private fun onServiceDiscoveryReady() {
          val intent = Intent()
          intent.action = BluetoothConstants.ACTION_GATT_SERVICES_DISCOVERED
          sendBroadcast(intent)
      }
  
      private fun writeNextPartToken() {
          if (mDividedTokenList!!.isEmpty()) {
              broadcastUpdate(BluetoothConstants.ACTION_INIT_READY)
              return
          }
          writeValue(BluetoothConstants.UUID_AUTHORIZE_PHONE, mDividedTokenList!!.removeAt(0))
      }
  
      private fun broadcastUpdate(action: String) {
          val intent = Intent(action)
          sendBroadcast(intent)
      }
  
      private fun writeValue(characteristicUUID: UUID, valueBytes: ByteArray) {
          if (mBluetoothAdapter == null || mBluetoothGatt == null) return
  
          val service = mBluetoothGatt!!.getService(BluetoothConstants.UUID_CAR_CONTROL_SERVICE)
          val characteristic = service.getCharacteristic(characteristicUUID)
  
          characteristic.value = valueBytes
          mBluetoothGatt!!.writeCharacteristic(characteristic)
      }
  
      private fun setCharacteristicNotification(characteristicUUID: UUID, enabled: Boolean) {
          if (mBluetoothAdapter == null || mBluetoothGatt == null) return
  
          val characteristic = mBluetoothGatt!!
                  .getService(BluetoothConstants.UUID_CAR_INFORMATION_SERVICE)
                  .getCharacteristic(characteristicUUID)
          mBluetoothGatt!!.setCharacteristicNotification(characteristic, enabled)
  
          characteristic.getDescriptor(CONFIG_DESCRIPTOR)?.let {
              it.value = if (enabled) BluetoothGattDescriptor.ENABLE_INDICATION_VALUE
              else BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE
              mBluetoothGatt!!.writeDescriptor(it)
          }
      }
  
  
      private fun broadcastUpdate(characteristic: BluetoothGattCharacteristic) {
          val intent = Intent()
          if (BluetoothConstants.UUID_STATUS_1 == characteristic.uuid) {
              if (!hasDataInBluetooth(characteristic.value)) {
                  mConnected = true
                  statusListener?.invoke()
              }
              intent.action = BluetoothConstants.ACTION_STATUS_1_AVAILABLE
              intent.putExtra(BluetoothConstants.EXTRA_DATA, characteristic.value)
          }
          if (BluetoothConstants.UUID_DEBUG == characteristic.uuid) {
              intent.action = BluetoothConstants.ACTION_DEBUG_AVAILABLE
              intent.putExtra(BluetoothConstants.EXTRA_DATA, characteristic.value)
          }
          if (BluetoothConstants.UUID_STATUS_2 == characteristic.uuid) {
              intent.action = BluetoothConstants.ACTION_STATUS_1_AVAILABLE
              intent.putExtra(BluetoothConstants.EXTRA_DATA, characteristic.value)
          }
          if (BluetoothConstants.UUID_STATUS_3 == characteristic.uuid) {
              intent.action = BluetoothConstants.ACTION_STATUS_1_AVAILABLE
              intent.putExtra(BluetoothConstants.EXTRA_DATA, characteristic.value)
          }
  
          sendBroadcast(intent)
      }
  
      private fun hasDataInBluetooth(byteArray: ByteArray): Boolean {
          for (b in byteArray) {
              if (b.toInt() != 0) {
                  return false
              }
          }
          return true
      }
  
      inner class LocalBinder : Binder() {
          val service: MyBluetoothService
              get() = this@MyBluetoothService
      }
  
  }
  
• Can some one help me with the implementation of unit testing for bluetooth connection in android

  Can some one help me with the implementation of unit testing for Bluetooth connection in android. What would be the unit testing implementation for scanning for bluetooth connection.
• How to get the time between WiFi signal sending and receiving in code?

  I want to calculate distance from WiFi router in c++ code.

  There are some methods which use received signal strength indication(RSSI) to get distance. But the results of this method depends on the environment.

  Now I want to use time-of-flight method.

  Timestamps provided by the wireless interfaces are for calculating the ToF of signals and then use this information to estimate the distance and relative position of one client device with respect to access points(ToF). How can I get the time between WiFi signal sending and receiving in my code? Thanks.
• How can I connect my Arduino(with ESP8266) to WiFi which has SSID, and requires e-mail and password to login?

  I have an Arduino UNO and ESP8266 WiFi module. I need to connect my Arduino to my school's internet network via ESP8266. But my school WiFi asks for my school email adress and password to login. My project will be in school for 7/24 and it requires non-stop internet connection. Briefly, my school's WiFi has a SSID and when I try to connect, it asks for not only password; but my school email adress and password. How do I connect my Arduino via ESP8266? Thanks in advance. Here is the picture of when I try to connect WiFi in my phone
• How to fetch client connetced wifi ssid and bssid on my site?

  I need to fetch my client connected wifi information like SSID, BSSID etc. on my site.

  My functionality is when user is on my site I want need to know which WIFI (if connected through Wi-Fi) client is connected and get connected Wi-Fi information.

  I have used "node-wifi" module for nodejs to achieve my task but it is fetch server side data not actual client data.

  Is there any solution for getting connected wifi data?
• Cannot close p2p connection in Android application

  I'm making a two-player Android game, the peers connect using a WifiP2pManager object, everything works fine until I close one of the peers application (or both), when I open it again the peers cannot communicate although the connection is still intact, and they cannot make a new connection, the only way I found to override the problem (even though it works sometimes, not every time) is to close and reopen the Wifi. Is there any way to close the p2p connection? I tried removeGroup() but it doesn't do the job. In addition; the Android documentation states that the function setWifiEnabled() of WifiManager is deprecated in Android Q, and the applications will not be able to enable or disable WiFi
• issue in setting group owner in wifi direct android

  I am building an android game where 2 devices are connected via wifi direct.

  I have been testing the app on 2 devices, lets say deviceA and deviceB. On discoverPeers on deviceA I selected deviceB from the list and the connection was successful. Here deviceA ended up being group owner and deviceB being client.

  Now the issue is, if i run discoverPeers on deviceB and try to connect to deviceA, even then deviceA ends up being group owner and deviceB will be client.

  I would want the device from which i tried to connect to be the group owner.

  I tried setting config.groupOwnerIntent=15;. Even this seems to be not helping.

  Any idea how to solve this issue?
• Wifi Direct Peerlist when Locations is set to Battery save mode

  According to available information, (including: WiFi getScanResults returns an empty list if GPS is off. (Android 6.0.1)), in order to get the Wifi Direct Peerlist, Location must also be turned on.

  However:

  - if Location is turned on,
  

  - BUT in "Battery save mode " (the name of the option may vary, depending on phone brand), 
  

  then the "isProviderEnabled" method always returns false.

  Please reffer to:

  GPS isProviderEnabled always return false

  Android LocationManager.isProviderEnabled() always returns false

  It already seems to ask alot when the app requests to the user to turn on Wifi AND Location manually (since to my knowledge it's not possible [anymore] to turn them on/off programmatically).

  Please help to find a User friendly way to get the Wifi direct peerlist without asking too much from the user.

  I want to avoid to ask the user to go through the phone's settings and configure the locations to NOT be in Battery Save Mode.

  Thank you
• I2S support on imx7d development board

  Does the current version of Android Things OS support i2s audio with the imx7d development board? I couldn’t find it in the PIO list.
• Does Android Things support Room Database?

  I am migrating an existing app running on Android and is working on its migration to Raspberry Pi. Just wondering if it's possible to directly migrate the usage of Room database.
• Check if an NXP iMX 8M has Android Things flashed?

  Is is possible to check if my NXP iMX 8M Cortex A53 + M4 already has Android Things flashed on it?

  Or do I need to explicitly flash it on the hardware?
• Setup Android Wi-Fi P2P local service without ability to connect

  I would like to setup Android Wi-Fi P2P local service with some dns records, and i've already done it. My application needs only these records and there is no needs to make connection between peers. But I'm facing with a problem, the service is visible from other android users, and they could try to connect to my application's service. My app's user will see acceptance dialog: "Accept sharing request?" and it's quite annoying. Is there any way to make my service not accessible or drop connections before showing acceptance dialog or make password authentication like in wifi hotspot? Thanks.

  private WifiP2pManager manager;
  private WifiP2pManager.Channel channel;
  private WifiP2pDnsSdServiceInfo serviceInfo;
  private final int PERIOD = 5000;
  private String Tag = "WifiP2PService";
  String SERVICE_INSTANCE = "P2p_Service";
  private WifiP2pDnsSdServiceRequest serviceRequest;
  
  public WifiP2PService(Context ctx){
      manager = (WifiP2pManager) ctx.getSystemService(Context.WIFI_P2P_SERVICE);
      channel = manager.initialize(ctx, ctx.getMainLooper(), null);
      serviceRequest = WifiP2pDnsSdServiceRequest.newInstance();
      Map record = new HashMap();
      record.put("user_id", ""+(int)(Math.random() * 1000));
      serviceInfo = WifiP2pDnsSdServiceInfo.newInstance(SERVICE_INSTANCE, "_http._tcp", record);
      manager.setDnsSdResponseListeners(channel, null, new WifiP2pManager.DnsSdTxtRecordListener() {
          @Override
          public void onDnsSdTxtRecordAvailable(String fullDomainName, Map<String, String> txtRecordMap, WifiP2pDevice srcDevice) {
              Log.i(Tag, "Finded: "+txtRecordMap.get("user_id"));
          }
      });
  }
  
  public void startBroadcastingService(){
      manager.clearLocalServices(channel, new WifiP2pManager.ActionListener() {
          @Override
          public void onSuccess() {
              manager.addLocalService(channel, serviceInfo,
                      new WifiP2pManager.ActionListener() {
                          @Override
                          public void onSuccess() {
                              Log.i(Tag, "Started");
                              setWifiDirectName("WifiP2p Android");
                          }
  
                          @Override
                          public void onFailure(int error) {
                              Log.i(Tag, "Failed to start");
                          }
                      });
          }
  
          @Override
          public void onFailure(int error) {
              Log.i(Tag, "Failed to clean");
          }
      });
  }
  
  public void startSearching() {
      manager.removeServiceRequest(
              channel,
              serviceRequest,
              new WifiP2pManager.ActionListener() {
                  @Override
                  public void onSuccess() {
                      manager.addServiceRequest(channel, serviceRequest, new WifiP2pManager.ActionListener() {
                                  @Override
                                  public void onSuccess() {
                                      manager.discoverServices(channel, new WifiP2pManager.ActionListener() {
                                          @Override
                                          public void onSuccess() {
  
                                          }
                                          @Override
                                          public void onFailure(final int error) {
                                          }
                                      });
                                  }
                                  @Override
                                  public void onFailure(final int reason) {
                                  }
                              }
                      );
                  }
                  @Override
                  public void onFailure(final int reason) {
                  }
              }
      );
  }
  
  public void setWifiDirectName(final String deviceName) {
      try {
          final Class[] paramTypes = new Class[3];
          paramTypes[0] = WifiP2pManager.Channel.class;
          paramTypes[1] = String.class;
          paramTypes[2] = WifiP2pManager.ActionListener.class;
          final Method setDeviceName = manager.getClass().getMethod(
                  "setDeviceName", paramTypes);
          setDeviceName.setAccessible(true);
  
          final Object[] arglist = new Object[3];
          arglist[0] = channel;
          arglist[1] = deviceName;
          setDeviceName.invoke(manager, arglist);
      } catch (final Exception e) {
          e.printStackTrace();
      }
  }
  
  public void stopLocalService() {
      Log.i(Tag, "Stopped");
      manager.clearLocalServices(channel, null);
      manager.removeServiceRequest(channel, serviceRequest, null);
  }
  
• App crash while sending data over a socket using WifiP2p connection

  App crashes while sending data over a socket using wifi p2p connection

  I am testing a simple chat application between HTC_Desire_10 pro (running Android 6.0) and OPPO A83 (running Android 7.1.1). I have the same app running on the two devices. The app first turns wifi on, then starts discovering peers on a users click event. The user can choose the device they want to connect to from a dynamically generated peer list. The two devices are able to connect successfully. I am able to send a text message from the HTC to OPPO phone but when I try to send a message from the OPPO phone, the app crashes.

  This is the code that assigns which device will be the host or client

  WifiP2pManager.ConnectionInfoListener connectionInfoListener = new WifiP2pManager.ConnectionInfoListener() {
      @Override
      public void onConnectionInfoAvailable(WifiP2pInfo wifiP2pInfo) {
          final InetAddress groupOwnerAddress = wifiP2pInfo.groupOwnerAddress;
          if(wifiP2pInfo.groupFormed&&wifiP2pInfo.isGroupOwner) {
              ConnectionStatus.setText("Host");
              serverClass = new ServerClass();
              serverClass.start();
          } else if(wifiP2pInfo.groupFormed) {
              ConnectionStatus.setText("Client");
              clientClass = new ClientClass(groupOwnerAddress);
              clientClass.start();
          }
      }
  };
  

  And this is the code for the ServerThread, ClientThread and SendRecieveThread

  public class ServerClass extends Thread{
      Socket socket;
      ServerSocket serverSocket;
  
      @Override
      public void run() {
          try {
              serverSocket = new ServerSocket(8888);
              socket = serverSocket.accept();
              sendReceive = new SendReceive(socket);
              sendReceive.start();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  
  private class SendReceive extends Thread {
      private Socket socket;
      private InputStream inputStream;
      private OutputStream outputStream;
  
      public SendReceive(Socket skt) {
          socket = skt;
          try {
              inputStream = socket.getInputStream();
              outputStream = socket.getOutputStream();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      @Override
      public void run() {
          byte[] buffer = new byte[1024];
          int bytes;
          while (socket!=null) {
              try {
                  bytes = inputStream.read(buffer);
                  if(bytes>0) {
                      handler.obtainMessage(MESSAGE_READ,bytes,-1,buffer).sendToTarget();
                  }
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  
      public void write(byte[] bytes) {
          try {
              outputStream.write(bytes);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  
  public class ClientClass extends Thread {
      Socket socket;
      String hostAdd;
      public ClientClass(InetAddress hostAddress) {
          hostAdd = hostAddress.getHostAddress();
          socket = new Socket();
      }
  
      @Override
      public void run() {
          try {
              socket.connect(new InetSocketAddress(hostAdd, 8888),1000);
              sendReceive = new SendReceive(socket);
              sendReceive.start();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
  

  The SendRecieve functionality gets invoked when a user clicks a send message button.

  btnSend.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
          String msg = writeMsg.getText().toString();
          sendReceive.write(msg.getBytes());
      }
  });
  

  I've run the app in USB-debugging mode using android studio and obtained the crash report from the adb logcat command:

  --------- beginning of crash
  03-27 22:16:54.115  6904  6904 E AndroidRuntime: FATAL EXCEPTION: main
  03-27 22:16:54.115  6904  6904 E AndroidRuntime: Process: june.androidapps.clatt, PID: 6904
  03-27 22:16:54.115  6904  6904 E AndroidRuntime: android.os.NetworkOnMainThreadException
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.os.StrictMode$AndroidBlockGuardPolicy.onNetwork(StrictMode.java:1318)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at java.net.SocketOutputStream.write(SocketOutputStream.java:145)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at june.androidapps.clatt.MainActivity$SendReceive.write(MainActivity.java:264)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at june.androidapps.clatt.MainActivity$5.onClick(MainActivity.java:135)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.view.View.performClick(View.java:5773)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.view.View$PerformClick.run(View.java:23035)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.os.Handler.handleCallback(Handler.java:836)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.os.Handler.dispatchMessage(Handler.java:103)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.os.Looper.loop(Looper.java:232)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at android.app.ActivityThread.main(ActivityThread.java:6802)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at java.lang.reflect.Method.invoke(Native Method)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1103)
  03-27 22:16:54.115  6904  6904 E AndroidRuntime:    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:964)
  03-27 22:17:06.089  7393  7393 E AndroidRuntime: FATAL EXCEPTION: main
  

  ...

  You can see the full log here https://drive.google.com/file/d/1CfKU5x2dQgkGBKHTvMywaNfPtMdCNEXG/view

  Can anyone please explain why the app behaves this way? I have gone through the entire logs for about an hour and I cant seem to find what's exactly going wrong in my code. Any help will be appreciated.

  with regards.
• I have been trying for the past week to get this to work routinely. My WifiP2P will sometimes work but it mostly crashes and I have no idea why

  So I'm just starting to learn how to connect two phones wirelessly over WifiP2p using my app.

  My app is a simple game of Rock, Paper, Scissors. Nothing overly complicated, and I'm trying to get the two test phones I'm using to "talk" to each other (example: one chooses rock, other chooses paper, and they update appropriately).

  My issue is that my app will constantly crash, or if I put in

      if (android.os.Build.VERSION.SDK_INT >= 23) {
              StrictMode.ThreadPolicy policy = new 
      StrictMode.ThreadPolicy.Builder().permitAll().build();
              StrictMode.setThreadPolicy(policy);
          }
  

  just to get it to run for testing purposes (I know the above stated code is a horrible idea), it will sometimes work, but mostly just crash.

  I also constantly keep getting the NetworkOnMainThreadException, which I thought I shouldn't since I extended the Thread class.

  So I've added in all the needed permissions

      <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
      <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
      <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
      <uses-permission android:name="android.permission.INTERNET" />
      <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
      <uses-permission 
      android:name="android.permission.ACCESS_COARSE_LOCATION"/>
      <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
  

  And I've tried creating "implements Runnable" methods to no avail. I considered using AsyncTask, but from what I've read, it'n not entirely the best choice, and also the android developers corner suggested using the Thread class for the simplicity of what I'm trying to do, which is essentially just sending a message from one phone to another.

  My code was created by following the tutorial from "Sarthi Technology", specifically this line of videos: https://www.youtube.com/watch?v=nw627o-8Fok&list=PLFh8wpMiEi88SIJ-PnJjDxktry4lgBtN3&index=1

  Still can't get anything working.

  I have two classes that are trying to run everything, a broadcast receiver class here:

  public class Wifi_P2P_Receiver extends BroadcastReceiver {
  
      private WifiP2pManager mManager;
      private WifiP2pManager.Channel mChannel;
      private MultiPlayer mActivity;
  
      public Wifi_P2P_Receiver(WifiP2pManager manager, WifiP2pManager.Channel channel, MultiPlayer mainActivity) {
          this.mManager = manager;
          this.mChannel = channel;
          this.mActivity = mainActivity;
      }
  
      @Override
      public void onReceive(Context context, Intent intent) {
          String action = intent.getAction();
  
          if(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) {
              int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
              if(state == WifiP2pManager.WIFI_P2P_STATE_ENABLED){
  //                Toast.makeText(context, "Wifi is ON", Toast.LENGTH_LONG).show();
              } else {
  //                Toast.makeText(context, "Wifi is OFF", Toast.LENGTH_LONG).show();
              }
          }
          if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
              if(mManager != null) {
                  mManager.requestPeers(mChannel, mActivity.peerListListener);
              }
          }
          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()){
                  mManager.requestConnectionInfo(mChannel, mActivity.CIL);
              } else {
                  mActivity.status.setText("Device Disconnected");
              }
          }
          else if(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) {
  
          }
      }
  }
  

  And then I have my main multiplayer class caller Multiplayer, which is very large so I'll break it up.

  Here's the first part up to the onCreate() method:

  public class MultiPlayer extends AppCompatActivity {
  
      Button btnDiscover;
      Button sendRock;
      Button sendPaper;
      Button sendScissors;
      String tempMsg = "";
      TextView status;
      TextView opponentChoice;
      TextView gameResult;
      String playerChoice = "";
      ListView playerList;
      WifiP2pManager mManager;
      WifiP2pManager.Channel mChannel;
      IntentFilter filter;
      Wifi_P2P_Receiver mReceiver;
      WifiManager wifi;
  
      List<WifiP2pDevice> peers = new ArrayList<WifiP2pDevice>();
      String[] deviceNameArray;
      WifiP2pDevice[] deviceArray;
  
      static final int MESSAGE_READ = 1;
  
      ServerClass serverClass;
      ClientClass clientClass;
      SendReceive sendReceive;
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.connect);
  
          initialWork();
          exqListener();
      }
  

  initialWork() and exqListener() do all the main work. Here's initialWork():

  public void initialWork() {
          btnDiscover = (Button) findViewById(R.id.btnFindPlayers);
          playerList = (ListView) findViewById(R.id.listPlayerView);
  
          wifi = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  
          mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
          mChannel = mManager.initialize(this, getMainLooper(), null);
  
          mReceiver = new Wifi_P2P_Receiver(mManager, mChannel, this);
  
          filter = new IntentFilter();
          filter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
          filter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
          filter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
          filter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
  
          sendRock = (Button) findViewById(R.id.btnSendRock);
          sendPaper = (Button) findViewById(R.id.btnSendPaper);
          sendScissors = (Button) findViewById(R.id.btnSendScissors);
      }
  

  And exqListener() handles all of the button presses (I have a button for Rock, Paper, and Scissors which sends a String "message" over the network):

  private void exqListener() {
          status = (TextView) findViewById(R.id.connectStatusTV);
          opponentChoice = (TextView) findViewById(R.id.opponentChoiceTV);
          gameResult = (TextView) findViewById(R.id.gameResultTV);
  
          btnDiscover = (Button) findViewById(R.id.btnFindPlayers);
          btnDiscover.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  mManager.discoverPeers(mChannel, new WifiP2pManager.ActionListener() {
                      @Override
                      public void onSuccess() {
  //                        Toast.makeText(getApplication(), "Discovery Started", Toast.LENGTH_LONG).show();
                          status.setText("Discovery Started");
                      }
  
                      @Override
                      public void onFailure(int i) {
  //                        Toast.makeText(getApplication(), "Discovery Failed", Toast.LENGTH_LONG).show();
                          status.setText("Discovery Failed");
                      }
                  });
              }
          });
  
          playerList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
              @Override
              public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
                  final WifiP2pDevice device = deviceArray[i];
                  WifiP2pConfig config = new WifiP2pConfig();
                  config.deviceAddress = device.deviceAddress;
  
                  mManager.connect(mChannel, config, new WifiP2pManager.ActionListener() {
                      @Override
                      public void onSuccess() {
                          Toast.makeText(getApplication(), "Connected to " + device.deviceName, Toast.LENGTH_LONG).show();
                      }
  
                      @Override
                      public void onFailure(int i) {
                          Toast.makeText(getApplication(), "Not connected", Toast.LENGTH_LONG).show();
                      }
                  });
              }
          });
  
          sendRock.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  String msg = "Rock";
                  playerChoice = "Rock";
                  sendReceive.write(msg.getBytes());
                  if(tempMsg.length() > 0){
                      colorChange();
                  }
              }
          });
  
          sendPaper.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  String msg = "Paper";
                  playerChoice = "Paper";
                  sendReceive.write(msg.getBytes());
                  if(tempMsg.length() > 0){
                      colorChange();
                  }
              }
          });
  
          sendScissors.setOnClickListener(new View.OnClickListener() {
              @Override
              public void onClick(View view) {
                  String msg = "Scissors";
                  playerChoice = "Scissors";
                  sendReceive.write(msg.getBytes());
                  if(tempMsg.length() > 0){
                      colorChange();
                  }
              }
          });
      }
  

  I have a listView that displays all nearby devices, which a user can connect to by item click. I also have a WifiP2pManager.ConnectionInfoListener and the appropriate methods for setting a user to host and another to client. These seem to be working so I won't paste the code in an effort to avoid as much clutter as possible. I also won't post the onResume() or onPause() methods as they are not an issue.

  I have a ServerClass, SendReceive, and ClientClass which are all subclasses of Multiplayer. Here's the ServerClass:

  public class ServerClass extends Thread {
  
          Socket socket;
          ServerSocket serverSocket;
  
          @Override
          public void run(){
              try {
                  serverSocket = new ServerSocket(8888);
                  socket = serverSocket.accept();
                  sendReceive = new SendReceive(socket);
                  sendReceive.start();
              } catch(IOException e) {
                  e.printStackTrace();
              }
          }
      }
  

  And my ClientClass:

  public class ClientClass extends Thread {
          Socket socket;
          String hostAdd;
  
          public ClientClass(InetAddress hostAddress){
              hostAdd = hostAddress.getHostAddress();
              socket = new Socket();
          }
  
          @Override
          public void run(){
  //            super.run();
              try {
                  socket.connect(new InetSocketAddress(hostAdd, 8888), 500);
                  sendReceive = new SendReceive(socket);
                  sendReceive.start();
              } catch(IOException e){
                  e.printStackTrace();
              }
          }
      }
  

  And finally the SendReceive subclass:

  private class SendReceive extends Thread {
          private Socket socket;
          private InputStream inputStream;
          private OutputStream outputStream;
  
          public SendReceive(Socket skt) {
              socket = skt;
              try {
                  inputStream = socket.getInputStream();
                  outputStream = socket.getOutputStream();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
  
          @Override
          public void run() {
  //            super.run();
              byte[] buffer = new byte[1024];
              int bytes;
  
              while(socket != null){
                  try {
                      bytes = inputStream.read(buffer);
                      if(bytes > 0){
                          handler.obtainMessage(MESSAGE_READ, bytes, -1, buffer).sendToTarget();
                      }
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
          }
  
          public void write(byte[] bytes){
              try {
                  outputStream.write(bytes);
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  

  One final thing I forgot to mention is my handler method, which is just part of the Multiplayer class by itself. So this is what I'm doing with the messages:

  Handler handler = new Handler(new Handler.Callback() {
          @SuppressLint("ResourceAsColor")
          @Override
          public boolean handleMessage(Message message) {
              switch(message.what){
                  case MESSAGE_READ:
                      byte[] readBuff = (byte[]) message.obj;
                      tempMsg = new String(readBuff, 0, message.arg1);
                      opponentChoice.setText("Your opponent chooses " + tempMsg + "!");
                      break;
              }
              return true;
          }
      });
  

  I believe that one of the main issues is the write(byte[] bytes) method, since every time I press one of the buttons, such as Rock, I get a NetworkOnMainThreadException, where the stackTrace points to the sendReceive.write(msg.getBytes()); line of the button's code. So I'm thinking it has somethign to do with the SendReceive class being on the main UI thread, which I thought it wouldn't be since I overrode the run() method when I had the subclass extend the Thread class.

  Any help would be greatly appreciated.