Beispiel #1
0
        public void OnPeersAvailable(WifiP2pDeviceList peers)
        {
            WifiManager.PhoneDevices.Clear();

            foreach (var peer in peers.DeviceList)
            {
                foreach (var p in WifiManager.PhoneDevices)
                {
                    if (p.DeviceName == peer.DeviceName)
                    {
                        continue;
                    }
                }

                WifiManager.PhoneDevices.Add(peer);
            }

            List <string> lstDevice = new List <string>();

            foreach (var p in WifiManager.PhoneDevices)
            {
                lstDevice.Add(p.DeviceName);
            }

            WiFiService.wifiService.RefreshPeersChanged(lstDevice);
        }
Beispiel #2
0
 public void OnPeersAvailable(WifiP2pDeviceList peers)
 {
     Log.Info("PeerListListener", "OnPeersAvailable called");
     foreach (var peer in peers.DeviceList)
     {
         Log.Debug("PeerListListener", string.Format("Found {0}", peer.DeviceName));
     }
 }
Beispiel #3
0
 public void OnPeersAvailable(WifiP2pDeviceList peers)
 {
     if (peers.DeviceList.Count == 0)
     {
         return;
     }
     foreach (WifiP2pDevice device in peers.DeviceList)
     {
         Send.Devices.Add(new Device(device.DeviceName, device.DeviceAddress));
     }
 }
Beispiel #4
0
        /// <summary>
        /// <see cref="WifiP2pActivity.OnPeersAvailable(WifiP2pDeviceList)"/>
        /// </summary>
        override public void OnPeersAvailable(WifiP2pDeviceList peers)
        {
            m_Views.GlobalProgressBar.Visibility = ViewStates.Gone;
            m_Views.TitleLayout.Visibility       = ViewStates.Visible;
            m_WasDiscoveryRequested = false;

            foreach (WifiP2pDevice device in peers.DeviceList)
            {
                m_CurrentPeers.Add(device);
            }

            m_Adapter.NotifyDataSetChanged();
        }
Beispiel #5
0
            void IPeerListListener.OnPeersAvailable(WifiP2pDeviceList peers)
            {
                var droidDeviceList             = peers.DeviceList;
                List <WifiDirectDevice> devices = new List <WifiDirectDevice>();

                foreach (WifiP2pDevice device in droidDeviceList)
                {
                    WifiDirectDevice wifiDirectDevice = new WifiDirectDevice(device);
                    devices.Add(wifiDirectDevice);
                }
                System.Diagnostics.Debug.WriteLine("(FOUND PEERS " + devices.Count + ")");
                if (devices.Count > 0)
                {
                    _WifiDirectManager.OnPeersFound?.Invoke(_WifiDirectManager, devices.ToArray());
                }
            }
Beispiel #6
0
        public void OnPeersAvailable(WifiP2pDeviceList peers)
        {
            if (_progressDialog != null && _progressDialog.IsShowing)
            {
                _progressDialog.Dismiss();
            }

            _peers.Clear();
            foreach (var peer in peers.DeviceList)
            {
                _peers.Add(peer);
            }
            ListAdapter = new WiFiPeerListAdapter(Activity, Resource.Layout.row_devices, _peers);
            //((WiFiPeerListAdapter)ListAdapter).NotifyDataSetChanged();
            if (_peers.Count == 0)
            {
                Log.Debug(WiFiDirectActivity.Tag, "No devices found");
            }
        }
Beispiel #7
0
        public void OnPeersAvailable(WifiP2pDeviceList peers)
        {
            mPeers.Clear();
            mAdapter.Clear();

            foreach (var peer in peers.DeviceList)
            {
                mPeers.Add(peer);
                mAdapter.Add(new PeerItem {
                    Address = peer.DeviceAddress, Name = peer.DeviceName
                });
            }

            mLvPeers.Adapter = mAdapter;

            if (mPeers.Count == 0)
            {
                Toast.MakeText(this, "No devices found", ToastLength.Short).Show();
            }
        }
        ///// <summary>
        ///// Start another <see cref="AbstractWifiP2pActivity"/> and pass in the current Wifi P2P parameters to avoid resetting an existing connection.
        ///// </summary>
        ///// <param name="activity">The activity to start</param>
        //protected void StartWifi2pActivity(AbstractWifiP2pActivity activity)
        //{
        //    Intent intent = new Intent(this, activity.GetType());
        //    Bundle args = new Bundle();
        //    args.Put
        //}

        /// <summary>
        /// <see cref="IPeerListListener.OnPeersAvailable(WifiP2pDeviceList)"/>
        /// </summary>
        abstract public void OnPeersAvailable(WifiP2pDeviceList peers);
 /// <summary>
 /// <see cref="IPeerListListener.OnPeersAvailable(WifiP2pDeviceList)"/>
 /// </summary>
 virtual public void OnPeersAvailable(WifiP2pDeviceList peers)
 {
 }
        /// <summary>
        /// <see cref="BroadcastReceiver.OnReceive(Context, Intent)"/>
        /// </summary>
        override public void OnReceive(Context context, Intent intent)
        {
            // Filter Messages intents
            if (intent is WifiP2pMessageIntent messageIntent)
            {
                // Load extra data from the intent.
                messageIntent.Load();
                switch (messageIntent.Action)
                {
                case WifiP2pMessageIntent.ActionMessageReceivedProgress:
                    if (messageIntent.IsCompleted)
                    {
                        m_CallbackHandler.OnMessageReceived(messageIntent.Message);
                    }
                    else
                    {
                        m_CallbackHandler.OnMessageReceivedProgressChanged(messageIntent.Message.MessageType, messageIntent.Progress);
                    }
                    break;

                case WifiP2pMessageIntent.ActionMessageSentProgress:
                    if (messageIntent.IsCompleted)
                    {
                        m_CallbackHandler.OnMessageSent(messageIntent.Message);
                    }
                    else
                    {
                        m_CallbackHandler.OnMessageSendingProgressChanged(messageIntent.Message, messageIntent.Progress);
                    }
                    break;
                }
            }
            else
            {
                switch (intent.Action)
                {
                case WifiP2pConnectionChangedAction:
                    NetworkInfo  networkInfo = (NetworkInfo)intent.GetParcelableExtra(ExtraNetworkInfo);
                    WifiP2pInfo  p2pInfo     = (WifiP2pInfo)intent.GetParcelableExtra(ExtraWifiP2pInfo);
                    WifiP2pGroup groupInfo   = (WifiP2pGroup)intent.GetParcelableExtra(ExtraWifiP2pGroup);
                    m_CallbackHandler.OnWifiP2pConnectionChanged(networkInfo, p2pInfo, groupInfo);
                    break;

                case WifiP2pPeersChangedAction:
                    WifiP2pDeviceList peers = (WifiP2pDeviceList)intent.GetParcelableExtra(ExtraP2pDeviceList);
                    m_CallbackHandler.OnPeersAvailable(peers);
                    break;

                case WifiP2pStateChangedAction:
                    EWifiState wifiState = (EWifiState)intent.GetIntExtra(ExtraWifiState, 0);
                    m_CallbackHandler.OnWifiP2pStateChanged(wifiState);
                    break;

                case WifiP2pThisDeviceChangedAction:
                    WifiP2pDevice deviceDetails = (WifiP2pDevice)intent.GetParcelableExtra(ExtraWifiP2pDevice);
                    m_CallbackHandler.OnThisDeviceChanged(deviceDetails);
                    break;

                default:
                    throw new NotSupportedException($"The action {intent.Action} is not handled by this receiver.");
                }
            }
        }