introduction
L’une des nombreuses API disponibles dans les services Google Play est la API de connexions à proximité. Introduit au début de 2015, ce framework vous permet de définir un appareil exécutant votre application en tant qu’hôte et de se connecter à plusieurs autres appareils afin de communiquer sur un Réseau local (LAN).
Les cas d’utilisation de cette fonctionnalité incluent la connexion d’un téléphone à un Android TV pour contrôler une application et permettre aux utilisateurs de participer à un jeu multijoueur. Dans ce didacticiel, vous apprendrez comment configurer des applications pour connecter plusieurs appareils ensemble sur un réseau et comment envoyer des données via cette connexion. Un exemple fonctionnel de ce didacticiel est disponible sur GitHub.
1. Configuration du projet
Une fois votre programme initial créé dans Android Studio, vous devrez importer la bibliothèque des services Play 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 cet article, Play Services 7.5.0 est la version la plus récente pour le développement.
compile '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 ouvrir AndroidManifest.xml. Étant donné que cette fonction utilise un LAN pour communiquer, vous devrez inclure le ACCESS_NETWORK_STATE permission dans votre manifeste.
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Ensuite, vous devrez ajouter un morceau de meta-data dans le application nœud qui définit un identifiant de service qui sera utilisé par votre application afin qu’elle puisse découvrir des hôtes faisant de la publicité avec ce même identifiant. Dans cet exemple, notre identifiant de service est défini dans strings.xml comme tutsplus_service_id.
<meta-data android:name="com.google.android.gms.nearby.connection.SERVICE_ID" android:value="@string/service_id" />
Lorsque vous avez terminé avec le manifeste, vous pouvez passer à MainActivity.java. C’est la classe où nous mettrons en œuvre à la fois la publicité et la découverte. Dans MainActivity, 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 nécessaires à l’API et un OnClickListener.
public class MainActivity extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener,
Connections.ConnectionRequestListener,
Connections.MessageListener,
Connections.EndpointDiscoveryListener,
View.OnClickListener {
...
Créons maintenant les variables membres dont nous aurons besoin pour ce tutoriel en haut de la MainActivity classe. Par souci de concision, je mentionnerai simplement que la mise en page de cette classe se compose d’un ListView pour afficher les messages, un EditText champ avec un Button pour envoyer des messages après connexion, un Button pour la publicité, la connexion ou la déconnexion, selon le rôle de l’appareil, et un TextView pour afficher les informations d’état de base.
Vous remarquerez qu’il existe deux indicateurs booléens pour indiquer si l’appareil est connecté ou non et s’il s’agit de l’hôte de connexion, le GoogleApiClient qui est nécessaire pour utiliser l’API Connexions à proximité, 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;
private Spinner mTypeSpinner;
private TextView mStatusText;
private Button mConnectionButton;
private Button mSendButton;
private ListView mListView;
private ViewGroup mSendTextContainer;
private EditText mSendEditText;
private ArrayAdapter<String> mMessageAdapter;
private boolean mIsHost;
private boolean mIsConnected;
private String mRemoteHostEndpoint;
private List<String> mRemotePeerEndpoints = new ArrayList<String>();
private static final long CONNECTION_TIME_OUT = 10000L;
private static int[] NETWORK_TYPES = {ConnectivityManager.TYPE_WIFI,
ConnectivityManager.TYPE_ETHERNET };
Si vous avez déjà travaillé avec des classes d’API Google Android, la dernière configuration devrait vous sembler assez familière. Vous devez initialiser le GoogleApiClient et connectez-vous en 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();
}
}
2. Publicité et acceptation des connexions
Une fois que vous vous êtes connecté au client API Google, vous pouvez commencer à travailler avec des connexions à proximité. Le premier élément que nous allons passer en revue est La publicité, qui permet à un appareil d’assumer le rôle d’hôte et de gérer les connexions entre divers pairs pour la communication.
La publicité elle-même est assez simple. Il vous suffit de vérifier que l’appareil dispose d’un type de connexion acceptable, puis d’appeler Nearby.Connections.StartAdvertising avec les paramètres appropriés. Cela amènera l’appareil à annoncer sur votre réseau local qu’il est disponible pour accepter les connexions d’autres applications.
Dans cet exemple, on passe dans un timeout de dix secondes pour la publicité. Cependant, vous pouvez transmettre une valeur de pour faire de la publicité indéfiniment. Dans le code suivant, isConnectedToNetwork est une méthode d’aide destinée à vérifier si la publicité doit avoir lieu.
private void advertise() {
if( !isConnectedToNetwork() )
return;
String name = "Nearby Advertising";
Nearby.Connections.startAdvertising( mGoogleApiClient, name, null,
CONNECTION_TIME_OUT, this )
.setResultCallback( new ResultCallback<Connections.StartAdvertisingResult>() {
@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 ) {
NetworkInfo info = connManager.getNetworkInfo( networkType );
if( info != null && info.isConnectedOrConnecting() ) {
return true;
}
}
return false;
}
Une fois que votre application hôte fait de la publicité, elle pourra recevoir des demandes de connexion de ses pairs. Lorsqu’un appareil tente de se connecter, la méthode suivante est appelée:
public void onConnectionRequest(final String remoteEndpointId, final String remoteDeviceId, final String remoteEndpointName, byte[] payload)
En utilisant cette méthode, vous pouvez accepter ou rejeter la connexion. Pour accepter la demande, vous appelez Nearby.Connections.acceptConnectionRequest avec un ResultsCallback. Vous pouvez ensuite effectuer des actions, selon que la connexion est acceptée avec succès ou non.
Pour cet exemple, nous allons simplement ajouter le point de terminaison distant à une liste pour en garder une trace et le diffuser à tous les pairs connectés que ce nouvel appareil a connectés. Si, pour une raison quelconque, vous déterminez que l’appareil ne doit pas se connecter à votre application, vous pouvez le rejeter 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, this ).setResultCallback
(new ResultCallback<Status>() {
@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 );
}
}
3. Découverte
Tout comme la publicité, la découverte repose sur la connexion au GoogleApiClient et avoir une connexion réseau acceptable. Vous pouvez démarrer la découverte en passant l’identifiant de service de l’application dans le Nearby.Connections.startDiscovery méthode, qui met l’appareil de votre utilisateur en mode découverte.
Lorsque l’appareil détecte un hôte qui fait actuellement de la publicité à l’aide de l’identifiant de service prédéfini, le onEndpointFound le rappel sera déclenché. Il est à noter que cette méthode peut être appelée plusieurs fois s’il y a plusieurs hôtes diffusant. Dans cette situation, vous pouvez créer une boîte de dialogue pour vos utilisateurs qui affiche tous les hôtes disponibles afin qu’ils puissent sélectionner auxquels ils souhaitent se connecter.
Pour cet exemple, nous supposerons qu’il n’y a qu’un seul hôte publicitaire à la fois, nous demanderons donc immédiatement à nous 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, le statut sera défini sur réussi et nous pouvons enregistrer l’identifiant du point de terminaison de l’hôte et préparer l’envoi de 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(new ResultCallback<Status>() {
@Override
public void onResult(Status status) {
if (status.isSuccess()) {
mStatusText.setText( "Discovering" );
} else {
Log.e( "TutsPlus", "Discovering failed: " + status.getStatusMessage() );
}
}
});
}
@Override
public void onEndpointFound(String endpointId, String deviceId,
final String serviceId, String endpointName) {
byte[] payload = null;
Nearby.Connections.sendConnectionRequest( mGoogleApiClient, deviceId,
endpointId, payload, new Connections.ConnectionResponseCallback() {
@Override
public void onConnectionResponse(String endpointId, Status status, byte[] bytes) {
if( status.isSuccess() ) {
mStatusText.setText( "Connected to: " + endpointId );
Nearby.Connections.stopDiscovery(mGoogleApiClient, serviceId);
mRemoteHostEndpoint = endpointId;
mSendTextContainer.setVisibility(View.VISIBLE);
if( !mIsHost ) {
mIsConnected = true;
}
} else {
mStatusText.setText( "Connection to " + endpointId + " failed" );
if( !mIsHost ) {
mIsConnected = false;
}
}
}
}, this );
}
Dans une situation où vous écoutez plusieurs points de terminaison pour présenter un choix à vos utilisateurs, le onEndpointLost La méthode vous permettra de savoir si un hôte a cessé de faire de la publicité avant que votre utilisateur n’ait tenté de s’y connecter. le onDisconnected Le rappel est également disponible pour les appareils clients et peut être utilisé pour se reconnecter aux hôtes publicitaires en cas de déconnexion inattendue.
4. Envoi de messages
Une fois que vos appareils sont connectés ensemble, il est temps de commencer à communiquer. Il existe deux types de messages qui peuvent être envoyés, fiable et non fiable. Si vous êtes familiarisé avec la technologie réseau, vous pouvez y penser en termes de TCP (Transmission Control Protocol) et UDP (Protocole de datagramme utilisateur). Une explication simplifiée est que les messages fiables réessayeront d’envoyer un message s’ils échouent, alors que les messages non fiables abandonneront simplement les données si elles ne sont pas envoyées et reçues avec succès.
Pour ce didacticiel, 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 de terminaison, une charge utile et un booléen indiquant si la connexion est fiable ou non. La charge utile contient le message et l’identifiant du point de terminaison est l’identifiant de l’appareil qui a envoyé le message.
Dans l’exemple d’application, vous l’utiliserez pour afficher la charge utile sous forme de chaîne dans un ListView et, si l’appareil est l’hôte, retransmettez-le à chaque appareil connecté.
@Override
public void onMessageReceived(String endpointId, byte[] payload, boolean isReliable) {
mMessageAdapter.add( new String( payload ) );
mMessageAdapter.notifyDataSetChanged();
if( mIsHost ) {
sendMessage( new String( payload ) );
}
}
le sendMessage method est une méthode d’assistance qui illustre 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, donc seul le nom d’hôte est nécessaire en tant que paramètre avec le GoogleApiClient et tableau d’octets de message.
private void sendMessage( String message ) {
if( mIsHost ) {
Nearby.Connections.sendReliableMessage( mGoogleApiClient,
mRemotePeerEndpoints,
message.getBytes() );
mMessageAdapter.add( message );
mMessageAdapter.notifyDataSetChanged();
} else {
Nearby.Connections.sendReliableMessage( mGoogleApiClient,
mRemoteHostEndpoint,
( Nearby.Connections.getLocalDeviceId( mGoogleApiClient ) + " says: " + message ).getBytes() );
}
}
5. Déconnexion
Lorsque vous êtes prêt à vous déconnecter du côté hôte ou du côté client de l’application, un petit nettoyage doit avoir lieu. Pour les hôtes, vous devez arrêter la publicité et déconnecter tous vos points de terminaison.
Dans l’exemple de code, vous remarquerez qu’un message est également envoyé qui tente de faire savoir aux pairs que l’hôte s’est déconnecté. Dans une application plus complète, vous voudriez que vos clients écoutent ce type de message afin qu’ils puissent 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 se chargera de couper la connexion.
private void disconnect() {
if( !isConnectedToNetwork() )
return;
if( mIsHost ) {
sendMessage( "Shutting down host" );
Nearby.Connections.stopAdvertising( mGoogleApiClient );
Nearby.Connections.stopAllEndpoints( mGoogleApiClient );
mIsHost = false;
mStatusText.setText( "Not connected" );
mRemotePeerEndpoints.clear();
} else {
if( !mIsConnected || TextUtils.isEmpty( mRemoteHostEndpoint ) ) {
Nearby.Connections.stopDiscovery( mGoogleApiClient, getString( R.string.service_id ) );
return;
}
sendMessage( "Disconnecting" );
Nearby.Connections.disconnectFromEndpoint( mGoogleApiClient, mRemoteHostEndpoint );
mRemoteHostEndpoint = null;
mStatusText.setText( "Disconnected" );
}
mIsConnected = false;
}
Conclusion
Dans ce didacticiel, vous avez appris à implémenter la communication entre divers appareils Android sur un réseau local à l’aide de l’API Connexions à proximité. Vous devriez maintenant être en mesure d’améliorer vos propres applications en connectant des appareils entre eux et en les synchronisant grâce à diverses mises à jour les uns des autres.
Alors que ce didacticiel vous a guidé à travers 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 contextuelles en fournissant un canal de communication supplémentaire pour l’environnement. autour d’eux.
Alors que l’API de connexions à proximité continue de croître avec l’ajout de balises Eddystone et de Bluetooth, cela se révélera être une compétence inestimable lors du développement d’applications Android.
