Share
L’une des nombreuses API disponibles dans les services Google Play est la API Connexions à proximité. Introduit début 2015, ce cadre vous permet de configurer un périphérique exécutant votre application en tant qu'hôte et de le connecter à plusieurs autres périphériques afin de pouvoir communiquer entre eux. Réseau local (LAN).
Les cas d'utilisation de cette fonctionnalité comprennent la connexion d'un téléphone à un téléviseur Android pour contrôler une application et permettre aux utilisateurs de participer à un jeu multijoueur. Dans ce didacticiel, vous apprendrez à configurer des applications pour connecter plusieurs périphériques ensemble sur un réseau et à envoyer des données via cette connexion. Vous trouverez un exemple de travail pour ce tutoriel sur GitHub..
Une fois votre programme initial créé dans Android Studio, vous devez importer la bibliothèque Play Services dans votre application. Pour ce faire, placez la ligne de code suivante sous le nœud de dépendance du build.gradle fichier. Au moment de la rédaction de ce document, Play Services 7.5.0 est la version la plus récente pour le développement..
compiler 'com.google.android.gms: play-services: 7.5.0'
Une fois que Play Services est inclus dans votre application, vous pouvez fermer build.gradle et ouvert AndroidManifest.xml. Puisque cette fonctionnalité utilise un réseau local pour communiquer, vous devrez inclure le ACCESS_NETWORK_STATE permission dans votre manifeste.
Ensuite, vous devrez ajouter un morceau de méta-données dans le application nœud qui définit un identifiant de service qui sera utilisé par votre application afin qu'elle puisse découvrir les hôtes publicitaires avec ce même identifiant. Dans cet exemple, notre identifiant de service est défini dans strings.xml comme tutsplus_service_id.
Lorsque vous avez terminé avec le manifeste, vous pouvez passer à MainActivity.java. C'est la classe où nous allons implémenter à la fois la publicité et la découverte. Dans Activité principale, vous contrôlerez également l'envoi de messages entre différents appareils.
Pour commencer à utiliser l'API Connexions à proximité, vous devez configurer et vous connecter au client API Google. Commencez par mettre en œuvre ConnectionCallbacks et OnConnectionFailedListener au sommet de votre classe. Pendant que nous ajoutons nos interfaces, incluons également les trois requis par l’API et un OnClickListener.
Classe publique MainActivity étend AppCompatActivity implémente GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, Connections.ConnectionRequestListener, Connections.MessageListener, Connections.EndpointDiscoveryListener, View.OnClickListener.
Créons maintenant les variables de membre dont nous aurons besoin pour ce tutoriel en haut de la Activité principale classe. Par souci de brièveté, je mentionnerai simplement que la mise en page de cette classe consiste en un ListView pour afficher des messages, un Éditer le texte champ avec un Bouton pour l'envoi de messages après connexion, un Bouton pour la publicité, la connexion ou la déconnexion, en fonction du rôle de l'appareil, et une Affichage pour afficher des informations d'état de base.
Vous remarquerez qu'il y a deux drapeaux booléens pour indiquer si le périphérique est connecté et si c'est l'hôte de connexion, le GoogleApiClient cela est nécessaire pour utiliser l'API Near Connections et un tableau d'entiers pour garder une trace des types de connexion réseau que nous prendrons en charge pour cette API.
private GoogleApiClient mGoogleApiClient; Spinner privé mTypeSpinner; TextView privé mStatusText; bouton privé mConnectionButton; bouton privé mSendButton; liste privée mListView; ViewGroup privé mSendTextContainer; private EditText mSendEditText; ArrayAdapter privémMessageAdapter; boIlean privé mIsHost; privé booléen mIsConnected; private String mRemoteHostEndpoint; liste privée mRemotePeerEndpoints = new ArrayList (); privé statique final long CONNECTION_TIME_OUT = 10000L; private static int [] NETWORK_TYPES = ConnectivityManager.TYPE_WIFI, ConnectivityManager.TYPE_ETHERNET;
Si vous avez déjà utilisé des classes d'API Android Google Google auparavant, la dernière partie de la configuration devrait vous paraître assez familière. Vous devez initialiser le GoogleApiClient et se connecter à onCreate.
mGoogleApiClient = new GoogleApiClient.Builder (this) .addConnectionCallbacks (this) .addOnConnectionFailedListener (this) .addApi (Nearby.CONNECTIONS_API) .build ();
Dans onStart et onStop, nous gérons la connexion et la déconnexion.
@Override protected void onStart () super.onStart (); mGoogleApiClient.connect (); @Override protected void onStop () super.onStop (); if (mGoogleApiClient! = null && mGoogleApiClient.isConnected ()) mGoogleApiClient.disconnect ();
Une fois que vous vous êtes connecté au client API Google, vous pouvez commencer à utiliser les connexions à proximité. Le premier composant que nous allons examiner est La publicité, qui permet à un périphérique d’assumer le rôle d’hôte et de gérer les connexions entre différents homologues pour la communication.
La publicité elle-même est assez simple. Vous devez simplement vérifier que le périphérique dispose d'un type de connexion acceptable, puis appeler Nearby.Connections.StartAdvertising avec les paramètres appropriés. Cela entraînera le périphérique à annoncer sur votre réseau local qu'il est disponible pour accepter les connexions d'autres applications..
Dans cet exemple, nous passons un délai d'attente de dix secondes pour la publicité. Cependant, vous pouvez passer une valeur de 0 faire de la publicité indéfiniment. Dans le code suivant, isConnectedToNetwork est une méthode d'assistance destinée à vérifier si de la publicité doit apparaître.
private void advertise () if (! isConnectedToNetwork ()) return; String name = "Publicité à proximité"; Nearby.Connections.startAdvertising (mGoogleApiClient, nom, null, CONNECTION_TIME_OUT, this) .setResultCallback (nouveau ResultCallback() @Override public void onResult (Connections.StartAdvertisingResult result) if (result.getStatus (). IsSuccess ()) mStatusText.setText ("Advertising"); ); private boolean isConnectedToNetwork () ConnectivityManager connManager = (ConnectivityManager) getSystemService (Context.CONNECTIVITY_SERVICE); for (int networkType: NETWORK_TYPES) Info réseau Info = connManager.getNetworkInfo (type de réseau); if (info! = null && info.isConnectedOrConnecting ()) return true; return false;
Une fois que votre application hôte fait de la publicité, elle pourra recevoir les demandes de connexion de ses pairs. Lorsqu'un périphérique tente de se connecter, la méthode suivante est appelée:
onConnectionRequest public final (String final remoteEndpointId, final String remoteDeviceId, final String remoteEndpointName, byte [] charge utile)
En utilisant cette méthode, vous pouvez accepter ou refuser la connexion. Pour accepter la demande, vous appelez Nearby.Connections.acceptConnectionRequest avec un RésultatsCallback. Vous pouvez ensuite effectuer des actions, selon que la connexion est acceptée ou non..
Pour cet exemple, nous allons simplement ajouter le point de terminaison distant à une liste pour en assurer le suivi et le diffuser à tous les homologues connectés auxquels ce nouveau périphérique a été connecté. Si, pour une raison quelconque, vous déterminez que le périphérique ne doit pas se connecter à votre application, vous pouvez le refuser en appelant Nearby.Connections.rejectConnectionRequest.
@Override public void onConnectionRequest (final String remoteEndpointId, final String remoteDeviceId, final String remoteEndpointName, byte [] payload) if (mIsHost) Nearby.Connections.acceptConnectionRequest (mGoogleApiClient, remoteEndpointId, payload).() @Override public void onResult (Status status) if (status.isSuccess ()) if (! MRemotePeerEndpoints.contains (remoteEndpointId)) mRemotePeerEndpoints.add (remoteEndpointId); mMessageAdapter.add (remoteDeviceId + "connected!"); mMessageAdapter.notifyDataSetChanged (); sendMessage (remoteDeviceId + "connected!"); mSendTextContainer.setVisibility (View.VISIBLE); ); else Nearby.Connections.rejectConnectionRequest (mGoogleApiClient, remoteEndpointId);
Tout comme la publicité, la découverte repose sur la connexion au réseau. GoogleApiClient et ayant une connexion réseau acceptable. Vous pouvez lancer la découverte en transmettant l'identifiant de service de l'application au Nearby.Connections.startDiscovery méthode, qui met le périphérique de votre utilisateur en mode découverte.
Lorsque le périphérique détecte un hôte faisant actuellement de la publicité à l'aide de l'identificateur de service prédéfini, le onEndpointFound le rappel sera déclenché. Il convient de noter que cette méthode peut être appelée plusieurs fois s'il y a plusieurs hôtes en diffusion. Dans cette situation, vous pouvez créer une boîte de dialogue pour vos utilisateurs, qui affiche tous les hôtes disponibles afin de leur permettre de sélectionner les objets auxquels ils souhaitent être connectés..
Pour cet exemple, supposons qu’il n’ya qu’un seul hôte à la fois, nous demanderons immédiatement à vous connecter en appelant Nearby.Connections.sendConnectionRequest. Si la connexion est acceptée ou rejetée par l'hôte, le sendConnectionRequest le rappel de résultat sera appelé. Si la connexion est acceptée, l'état est défini sur Succès. Nous pouvons enregistrer l'identificateur du noeud final de l'hôte et préparer l'envoi des messages via le canal de connexion..
private void discover () if (! isConnectedToNetwork ()) return; String serviceId = getString (R.string.service_id); Nearby.Connections.startDiscovery (mGoogleApiClient, serviceId, 10000L, this) .setResultCallback (nouveau ResultCallback() @Override public void onResult (Status status) if (status.isSuccess ()) mStatusText.setText ("Discovering"); else Log.e ("TutsPlus", "La détection a échoué:" + status.getStatusMessage ()); ); @Override public void onEndpointFound (String endpointId, String deviceId, final String serviceId, String endpointName) byte [] payload = null; Nearby.Connections.sendConnectionRequest (mGoogleApiClient, deviceId, endpointId, charge utile, nouveau Connections.ConnectionResponseCallback () @Override public void onConnectionResponse (String endpointId, Status Status, byte [] bytes) if (status.isSuccess). setText ("Connecté à:" + endpointId); Nearby.Connections.stopDiscovery (mGoogleApiClient, serviceId); mRemoteHostEndpoint = endpointId; mSendTextContainer.setVisibility (View.VISIBLE); si (! mIsH .setText ("Connexion à" + endpointId + "échoué"); if (! mIsHost) mIsConnected = false;, this);
Dans le cas où vous écoutez plusieurs terminaux pour présenter un choix à vos utilisateurs, le onEndpointLost Cette méthode vous permettra de savoir si un hôte a cessé de diffuser de la publicité avant que votre utilisateur ait tenté de s'y connecter. le onDisconnected Le rappel est également disponible pour les périphériques clients et peut être utilisé pour se reconnecter à des hôtes publicitaires en cas de déconnexion imprévue..
Une fois vos appareils connectés, il est temps de commencer à communiquer. Il existe deux types de messages qui peuvent être envoyés, fiable et non fiable. Si vous êtes familier avec la technologie de réseau, vous pouvez l’envisager en termes de TCP (Protocole de contrôle de transmission) et UDP (Protocole de datagramme utilisateur). Une explication simplifiée est que les messages fiables réessayeront d’essayer d’envoyer un message s’ils échouent, alors que les messages non fiables abandonnent simplement les données si elles ne sont pas envoyées et reçues avec succès..
Pour ce tutoriel, vous utiliserez des messages fiables. Lorsqu'un message est reçu via l'API, onMessageReceived sera appelé. Cette méthode accepte l'identificateur de point final, une charge utile et un booléen indiquant si la connexion est fiable ou non fiable. La charge utile contient le message et l'identificateur de noeud final est l'identifiant du périphérique ayant envoyé le message..
Dans l’exemple d’application, vous allez utiliser ceci pour afficher la charge utile sous forme de chaîne dans un fichier. ListView et, si le périphérique est l'hôte, retransmettez-le à chaque périphérique connecté.
@Override public void onMessageReceived (String endpointId, byte [] charge utile, boolean isReliable) mMessageAdapter.add (new String (charge))); mMessageAdapter.notifyDataSetChanged (); if (mIsHost) sendMessage (new String (charge utile));
le envoyer le message méthode est une méthode d'assistance qui montre deux versions de Nearby.Connections.sendReliableMessage. Pour les applications hôtes, sendReliableMessage acceptera une liste de points de terminaison auxquels envoyer le message. Cela vous permet de communiquer avec plusieurs appareils avec une seule ligne de code. Pour les clients, les messages doivent uniquement aller à l'hôte, de sorte que seul le nom d'hôte est requis en tant que paramètre avec le paramètre GoogleApiClient et message tableau d'octets.
void privé sendMessage (message de chaîne) if (mIsHost) Nearby.Connections.sendReliableMessage (mGoogleApiClient, mRemotePeerEndpoints, message.getBytes ()); mMessageAdapter.add (message); mMessageAdapter.notifyDataSetChanged (); else Nearby.Connections.sendReliableMessage (mGoogleApiClient, mRemoteHostEndpoint, (Nearby.Connections.getLocalDeviceId (mGoogleApiClient) + dit: "+ message) .getBytes ());
Lorsque vous êtes prêt à vous déconnecter du côté hôte ou côté client de l'application, vous devez effectuer un peu de nettoyage. Pour les hôtes, vous devez arrêter la publicité et déconnecter tous vos points finaux..
Dans l'exemple de code, vous remarquerez qu'un message est également envoyé pour tenter d'informer les pairs que l'hôte s'est déconnecté. Dans une application plus complète, vous souhaitez que vos clients écoutent ce type de message afin de pouvoir gérer la situation de manière appropriée..
Si vous essayez de vous déconnecter sur un client qui ne s'est pas encore connecté à un hôte, vous devez simplement arrêter la découverte. Si vous êtes déjà connecté à un hôte, vous appelez disconnectFromEndpoint et l'API va gérer la rupture de la connexion.
Accentsconagua
private void disconnect () if (! isConnectedToNetwork ()) return; if (mIsHost) sendMessage ("Arrêt de l'hôte"); Nearby.Connections.stopAdvertising (mGoogleApiClient); Nearby.Connections.stopAllEndpoints (mGoogleApiClient); mIsHost = false; mStatusText.setText ("Non connecté"); mRemotePeerEndpoints.clear (); else if (! mIsConnected || TextUtils.isEmpty (mRemoteHostEndpoint)) Nearby.Connections.stopDiscovery (mGoogleApiClient, getString (R.string.service_id)); revenir; sendMessage ("Déconnexion"); Nearby.Connections.disconnectFromEndpoint (mGoogleApiClient, mRemoteHostEndpoint); mRemoteHostEndpoint = null; mStatusText.setText ("Disconnected"); mIsConnected = false; 
Dans ce didacticiel, vous avez appris à implémenter la communication entre divers périphériques Android sur un réseau local à l'aide de l'API Connexions à proximité. Vous devriez maintenant pouvoir améliorer vos propres applications en connectant des appareils ensemble et en les synchronisant via diverses mises à jour..
Pendant que ce didacticiel vous a présenté une application client de chat assez simple, vous pouvez utiliser ce que vous avez appris ici pour créer des expériences multijoueurs raffinées, fournir des écrans secondaires aux utilisateurs ou rendre vos applications plus sensibles au contexte en fournissant un canal de communication supplémentaire pour l'environnement. autour d'eux.
Alors que l'API Near Connections continue de se développer avec l'ajout des balises Eddystone et de Bluetooth, cela s'avérera être une compétence inestimable lors du développement d'applications Android..
