Share
Dans cette série, nous construisons un client Twitter pour la plate-forme Android à l'aide de la bibliothèque Twitter4J. Ce tutoriel se concentrera sur l'implémentation de tweet, le retweet et la réponse aux tweets. Nous allons créer une nouvelle activité pour tweeter et répondre, avec des boutons de retweet et de réponse mis en œuvre pour chaque tweet dans la chronologie de départ de l'utilisateur..
Dans les quatre premiers tutoriels, nous:
Notre application va avoir une deuxième activité en plus de l'écran de la chronologie principale. Cette nouvelle activité concerne l'envoi de tweets. À l'intérieur, l'utilisateur peut saisir du texte pour envoyer un tweet à partir de son compte Twitter. L'utilisateur peut entrer dans l'activité Tweet de deux manières: en appuyant sur le bouton Tweet de l'écran principal de l'application ou en appuyant sur un bouton de réponse dans la timeline..
Si l'utilisateur appuie sur le bouton Tweet, un champ de texte vide lui permettant de saisir son tweet lui sera présenté, avec un bouton d'envoi pour continuer et l'envoyer..
Si l'utilisateur appuie sur le bouton de réponse dans un tweet de la timeline, le champ de texte lui sera également présenté, mais le nom d'utilisateur de la réponse sera déjà renseigné dans le champ. La réponse doit également être envoyée à l'aide de l'ID du tweet auquel nous répondons, que nous mettrons également en œuvre..
Créez une nouvelle classe dans votre projet Android, en la nommant "NiceTweet" pour correspondre au nom que vous avez inclus dans votre fichier Manifest dans le premier tutoriel. Modifiez la déclaration de classe comme suit:
Classe publique NiceTweet étend Activity implémente OnClickListener
Vous aurez besoin des importations Android suivantes:
importer android.app.Activity; importer android.content.SharedPreferences; importer android.os.Bundle; importer android.util.Log; importer android.view.View; importer android.view.View.OnClickListener; importer android.widget.Button; importer android.widget.EditText; importer android.widget.LinearLayout;
Plus ces importations Twitter4J:
importer twitter4j.StatusUpdate; importer twitter4j.Twitter; importer twitter4j.TwitterException; importer twitter4j.TwitterFactory; importer twitter4j.conf.Configuration; importer twitter4j.conf.ConfigurationBuilder;
Incluez les variables d'instance suivantes dans votre déclaration de classe:
/ ** préférences partagées pour les détails de l'utilisateur Twitter * / private SharedPreferences tweetPrefs; / ** objet twitter ** / private Twitter tweetTwitter; / ** clé twitter * / public final static String TWIT_KEY = "votre clé"; / ** twitter secret * / public final static String TWIT_SECRET = "votre secret"; / ** l'identifiant de mise à jour pour ce tweet s'il s'agit d'une réponse * / private long tweetID = 0; / ** le nom d'utilisateur du tweet s'il s'agit d'une réponse * / private String tweetName = "";
Nous utiliserons les variables Preferences, Twitter, key et secret pour accéder aux méthodes Twitter4J de tweet à partir du compte utilisateur. Modifiez la clé et le secret en fonction des vôtres. Les deux dernières variables sont pour les réponses. Lorsque l'utilisateur appuie sur le bouton de réponse dans un tweet, nous allons transmettre l'ID du tweet auquel on répond, ainsi que le nom d'écran Twitter du compte auquel nous répondons. Nous allons les stocker dans les deux variables d'instance.
Implémentons la méthode Activity create:
/ * * onCreate appelé lors de la création de l'activité * / @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); // set tweet layout setContentView (R.layout.tweet);
Tout ce que nous faisons ici est de définir la disposition du tweet que nous avons définie plus tôt dans XML. Ensuite, implémentez la méthode resume, appelée chaque fois que l’activité devient visible pour l’utilisateur:
/ * * Méthode de configuration de l'appel au démarrage de cette activité * / @Override public void onResume () super.onResume (); // appelle la méthode d'assistance setupTweet ();
Nous allons fournir la méthode d'assistance spécifiée pour configurer l'activité pour l'interaction utilisateur.
Ajoutez la méthode "setupTweet" à votre classe comme suit:
/ ** * Méthode appelée à chaque démarrage de cette activité * - préparez-vous à tweeter * Configure les écouteurs twitter et onClick * - configure également les réponses * / private void setupTweet () // prépare le tweet
Dans cette méthode, nous devons préparer la classe à envoyer des tweets ordinaires ainsi que des réponses. Premièrement, utilisons les préférences partagées pour instancier notre objet Twitter:
Accentsconagua
// Obtenir les préférences pour les détails de l'utilisateur Twitter tweetPrefs = getSharedPreferences ("TwitNicePrefs", 0); // récupère le jeton utilisateur et le secret pour l'authentification String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // crée une nouvelle configuration twitter utilise les détails de l'utilisateur. Configuration twitConf = new ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken) .setOAuthAccessTokenSecret ().) // crée une instance Twitter tweetTwitter = new TwitterFactory (twitConf) .getInstance (); Ici, nous créons un objet Twitter en utilisant les informations d'authentification de l'utilisateur avec la clé de développeur et le secret de l'application. Lorsque nous conduisons les utilisateurs vers cette classe d’activité, nous allons passer l’ID et le nom d’utilisateur si un tweet est en cours de réponse. Nous les obtenons de l'intention:
// récupère toutes les données transmises à cette intention pour une réponse Bundle extras = getIntent (). getExtras ();
Si le tweet est une mise à jour ordinaire plutôt qu'une réponse, il n'y aura pas de suppléments. S'il y a des extras, nous savons que le tweet est une réponse:
if (extras! = null) // récupère l'identifiant du tweet auquel nous répondons tweetID = extras.getLong ("tweetID"); // récupère le pseudonyme de l'utilisateur pour le tweet auquel nous répondons tweetName = extras.getString ("tweetUser"); // utilise les informations transmises Ici, nous récupérons l'ID et le pseudonyme du tweet auquel répondre. Ensuite, nous utilisons ces informations pour ajouter le nom d'utilisateur au champ de texte, toujours à l'intérieur de l'instruction "if":
// obtient une référence au champ de texte pour le tweet EditText theReply = (EditText) findViewById (R.id.tweettext); // démarre le texte du tweet pour la réponse @nom_utilisateur theReply.setText ("@" + tweetName + ""); // place le curseur à la fin du texte pour l'entrée theReply.setSelection (theReply.getText (). length ()); Nous définissons le nom d'utilisateur comme première partie du texte du tweet, en plaçant le curseur à la fin pour que l'utilisateur puisse taper son texte de réponse immédiatement.
Ensuite, prenons en charge les cas où le tweet n’est pas une réponse:
else EditText theReply = (EditText) findViewById (R.id.tweettext); theReply.setText (""); Ici, nous définissons simplement le texte sur une chaîne vide, en utilisant à nouveau l'ID que nous avons donné au champ de texte dans le format XML. Nous pouvons maintenant terminer la méthode "setupTweet" en ajoutant des écouteurs de clic pour le bouton "Envoyer" et le bouton "Accueil" pour revenir à l'écran principal de la timeline:
// configure le programme d'écoute pour que le bouton d'accueil soit choisi pour accéder à la timeline LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.homebtn); tweetClicker.setOnClickListener (this); // configuration du programme d'écoute pour l'envoi du tweet Button Button tweetButton = (Button) findViewById (R.id.dotweet); tweetButton.setOnClickListener (this);
Nous utilisons à nouveau les valeurs d'ID spécifiées dans nos fichiers de mise en page.
Rappelez-vous que l'activité de Tweet va contenir un bouton pour ramener les utilisateurs au plan de montage chronologique ainsi qu'un bouton pour envoyer le tweet. Ajoutons maintenant la méthode "onClick" pour gérer les utilisateurs en cliquant sur ces boutons:
/ ** * Méthode d'écoute pour les clics sur les boutons * - pour le bouton d'accueil et le bouton d'envoi de tweet * / public void onClick (Afficher v) // gérer l'accueil et envoyer des clics de bouton
Commencez par obtenir une référence au champ de texte:
EditText tweetTxt = (EditText) findViewById (R.id.tweettext);
Nous devons maintenant déterminer le bouton sur lequel vous avez cliqué à l’aide des instructions switch et case:
// découvre quelle vue a été cliquée switch (v.getId ()) case R.id.dotweet: // send tweet break; case R.id.homebtn: // aller à la pause de la ligne de temps du domicile; défaut: break;
Dans la déclaration de cas "dotweet", avant la déclaration de rupture, implémentez l'envoi d'un tweet comme suit:
String toTweet = tweetTxt.getText (). ToString (); try // gérer les réponses if (tweetName.length ()> 0) tweetTwitter.updateStatus (new StatusUpdate (toTweet) .inReplyToStatusId (tweetID)); // gère les tweets normaux else tweetTwitter.updateStatus (toTweet); // réinitialiser le texte à modifier tweetTxt.setText (""); catch (TwitterException te) Log.e ("NiceTweet", te.getMessage ()); Ici, nous vérifions si le tweet est une réponse ou non. L'instruction "if" est exécutée si le tweet est une réponse, y compris le texte du champ de texte et l'ID de la mise à jour de statut à laquelle nous répondons. L'instruction "else" se charge de l'envoi de tweets ordinaires, dans lesquels seul le texte est transmis en tant que paramètre. Les blocs try and catch sont nécessaires car nous essayons de nous connecter à Twitter via le réseau. Après l'envoi du tweet, qu'il s'agisse d'une réponse ou non, nous définissons le champ de texte comme vide pour préparer la prochaine mise à jour du tweet..
Pour l'instruction de cas "homebtn", définissez simplement le champ de texte sur une chaîne vide:
tweetTxt.setText (""); Enfin, après l’instruction switch mais toujours dans la méthode "onClick", terminez l’Activité afin qu’elle revienne à la timeline de base:
terminer();
Que le tweet soit une réponse ou une mise à jour ordinaire, nous ramenons immédiatement l’utilisateur à l’écran principal lorsqu’il est envoyé, ce que nous faisons également quand ils appuient sur le bouton principal. L’instruction finish est exécutée dans les trois cas..
Pour mettre en œuvre le retweet et la réponse, nous devons stocker l'ID de tweet et le nom d'écran de l'utilisateur dans les boutons retweet et répondre pour chaque tweet de la chronologie. En stockant ces données dans le bouton Vues pour retweet et répondre, nous serons en mesure de détecter le tweet en cours de retweet ou de réponse lorsque l'utilisateur appuie sur un bouton.
Comme les informations que nous devons stocker comprennent un nombre et du texte, nous allons créer une classe pour les modéliser. Créez une nouvelle classe dans votre projet et nommez-la "StatusData". Votre nouvelle classe devrait commencer comme suit:
Classe publique StatusData
Dans la classe, ajoutez des variables d'instance pour l'identifiant et le nom d'utilisateur du tweet:
/ ** ID tweet * / private long tweetID; / ** Nom d'utilisateur du tweeter * / private String tweetUser;
L'ID est modélisé comme un long, avec le nom d'écran une chaîne de texte. Ajoutez une méthode constructeur à la classe:
/ ** * Le constructeur reçoit l'ID et le nom d'utilisateur * @ IDParam * @param screenName * / public StatusData (ID long, String screenName) // instancie les variables tweetID = ID; tweetUser = screenName;
La méthode instancie simplement les deux variables. Ajoutez ensuite une méthode publique afin que nous puissions récupérer l'identifiant du tweet ailleurs:
/ ** * Obtenir l'ID du tweet * @return tweetID sous la forme d'un long * / public long getID () return tweetID;
Ajoutez ensuite une méthode pour renvoyer le nom d’écran:
/ ** * Récupère le pseudonyme de l'utilisateur pour le tweet * @return tweetUser sous forme de chaîne * / public String getUser () return tweetUser;
Ces méthodes nous permettront de récupérer ces informations lorsque les utilisateurs cliquent sur le bouton retweet ou répondre à un tweet particulier..
Nous devons maintenant étendre le code dans la classe Adapter créée ("UpdateAdapter"). Dans la méthode "bindView", nous avons personnalisé le mappage des données sur les vues de l'interface utilisateur. Nous allons maintenant ajouter un traitement supplémentaire pour inclure les données de tweet dans chaque bouton retweet et réponse. Avant la fin de votre méthode "bindView", commencez comme suit:
// récupère l'identifiant de statut long statusID = cursor.getLong (cursor.getColumnIndex (BaseColumns._ID)); // récupère le nom d'utilisateur String statusName = cursor.getString (cursor.getColumnIndex ("user_screen")); N'oubliez pas que la méthode "bindView" reçoit un objet Cursor pour parcourir les données. Ici, nous utilisons le curseur pour récupérer la valeur de l'identifiant long et le nom d'utilisateur String pour le tweet en cours. Vous aurez besoin de l'importation supplémentaire suivante:
importer android.provider.BaseColumns;
Nous allons maintenant instancier un objet de notre nouvelle classe StatusData, en transmettant les données tweet à la méthode du constructeur:
// crée un objet StatusData pour stocker ces StatusData tweetData = new StatusData (statusID, statusName);
L'objet StatusData contient tout le nécessaire pour envoyer un retweet ou une réponse au tweet en question. Nous allons maintenant attacher une référence à cet objet dans les boutons de retweet et de réponse du tweet, afin de pouvoir accéder aux informations après les clics de l'utilisateur. Nous utilisons la méthode "setTag":
// définit l'objet de données d'état en tant que balise pour les boutons Retweet et Reply dans cette vue row.findViewById (R.id.retweet) .setTag (tweetData); row.findViewById (R.id.reply) .setTag (tweetData);
La méthode "bindView" reçoit également un paramètre représentant la ligne View dans laquelle le tweet va être affiché. Si vous examinez le fichier de mise en forme XML mis à jour, vous verrez que ces deux valeurs d’ID sont incluses pour les boutons. Nous avons défini la balise dans chaque bouton pour refléter l’objet StatusData contenant l’ID et le nom d’utilisateur du tweet affiché. Maintenant, nous devons configurer les clics des boutons pour ceux-ci:
// configure les écouteurs onclick pour les boutons de retweet et de réponse row.findViewById (R.id.retweet) .setOnClickListener (tweetListener); row.findViewById (R.id.reply) .setOnClickListener (tweetListener);
Ici, nous spécifions un écouteur de clic pour gérer les clics de bouton. Dans la méthode d'écoute, nous pourrons récupérer les objets StatusData de tous les boutons de retweet et de réponse sur lesquels l'utilisateur a cliqué. Nous allons également permettre aux utilisateurs de cliquer sur le nom d'utilisateur d'un tweet afin d'ouvrir le profil de l'utilisateur dans le navigateur Web. Ajoutez un écouteur de clic à cette vue. Voir aussi ici:
// setup onclick pour le nom d'écran de l'utilisateur dans le tweet row.findViewById (R.id.userScreen) .setOnClickListener (tweetListener);
Cela nous permettra de nous connecter à l'interface Web de Twitter afin que les utilisateurs puissent accéder à des fonctions que nous n'avons pas fournies dans l'application elle-même..
Dans votre classe UpdateAdapter, créez un "onClickListener" pour gérer les clics, en utilisant le nom "tweetListener" pour correspondre à ce que nous avons spécifié dans la méthode "bindView":
/ ** * tweetListener gère les clics de réponse et les boutons retweet * - traite également de cliquer sur le nom d'utilisateur dans un tweet * / private OnClickListener tweetListener = new OnClickListener () // méthode onClick public void onClick (View v) ;
Ajoutez les importations supplémentaires suivantes à la classe Adapter:
importer android.view.View.OnClickListener; importer android.content.Intent; importer android.content.SharedPreferences; importer android.widget.Toast; importer android.net.Uri; importer twitter4j.Twitter; importer twitter4j.TwitterException; importer twitter4j.TwitterFactory; importer twitter4j.conf.Configuration; importer twitter4j.conf.ConfigurationBuilder;
Dans la méthode "onClick", nous allons implémenter les clics des deux boutons plus le nom d'utilisateur. Pour détecter le clic sur lequel vous avez cliqué, ajoutez une instruction switch:
// quelle vue a été cliqué switch (v.getId ()) // bouton de réponse enfoncé case R.id.reply: // Implement reply // bouton retweet pressé le cas R.id.retweet: // implémenter retweet break; // l'utilisateur a appuyé sur tweet le nom d'utilisateur case R.id.userScreen: // implémente le profil utilisateur en visite break; défaut: break;
À l'intérieur de l'instruction de réponse, nous commençons la classe d'activité Tweet, en transmettant les données de réponse afin que l'ID de réponse et le nom d'utilisateur puissent être inclus lors de l'envoi du tweet:
// crée une intention pour l'envoi d'un nouveau tweet Intention replyIntent = new Intent (v.getContext (), NiceTweet.class); // récupère les données de la balise dans la vue du bouton StatusData theData = (StatusData) v.getTag (); // passe l'ID d'état replyIntent.putExtra ("tweetID", theData.getID ()); // passe le nom d'utilisateur replyIntent.putExtra ("tweetUser", theData.getUser ()); // va à l'écran du tweet v.getContext (). startActivity (replyIntent); Notez que nous récupérons la balise pour la vue pressée en la transformant en objet StatusData. Nous appelons ensuite les méthodes publiques fournies dans la classe StatusData pour renvoyer l'ID de tweet et le nom d'écran de l'utilisateur. Nous les transmettons à l'activité Tweet en tant qu'extras, puis nous commençons l'activité. À ce stade, l'utilisateur sera dirigé vers l'écran Tweet où les données de réponse seront utilisées pour mettre en œuvre la réponse au tweet correct..
Dans la déclaration de cas retweet, nous retweetons directement le tweet correspondant, en utilisant les méthodes Twitter4J. Instanciez d’abord un objet Twitter à l’aide des préférences partagées, de votre clé de développeur et du secret de l’application:
// get context Context appCont = v.getContext (); // obtenir les préférences pour l'accès utilisateur SharedPreferences tweetPrefs = appCont.getSharedPreferences ("TwitNicePrefs", 0); String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // crée une nouvelle configuration Twitter Configuration twitConf = new ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken) .setOAuthAccessTokenSecret (userSecret). // créer une instance Twitter pour retweet Twitter retweetTwitter = new TwitterFactory (twitConf) .getInstance (); C'est la même technique que nous avons utilisée pour instancier la classe Twitter auparavant. Nous pouvons maintenant utiliser l'objet Twitter pour envoyer le retweet. Nous devons d’abord récupérer l’objet StatusData à partir du bouton sur lequel on a cliqué:
// récupère les données tweet de la balise de vue StatusData tweetData = (StatusData) v.getTag ();
Nous pouvons maintenant essayer de retweeter la mise à jour dans un bloc try:
try // retweet, en passant l'ID de statut de la balise retweetTwitter.retweetStatus (tweetData.getID ()); catch (TwitterException te) Log.e (LOG_TAG, te.getMessage ());
Tout l'objet Twitter nécessaire pour envoyer un retweet est l'identifiant du tweet d'origine. Cependant, donnons à l'utilisateur la confirmation que son retweet a été envoyé, toujours dans le bloc try:
// confirme l'utilisation de CharSequence text = "Retweeted!"; int duration = Toast.LENGTH_SHORT; Toast Toast = Toast.makeText (appCont, texte, durée); toast.show ();
Vous pouvez bien sûr modifier le message si vous le souhaitez. Voici à quoi ça ressemble:
Permettez maintenant à l'utilisateur de visiter une page de profil Twitter dans le navigateur Web en cliquant sur le nom d'écran dans le tweet en cours, dans la déclaration de cas "userScreen":
// récupère le nom d'écran de l'utilisateur TextView tv = (TextView) v.findViewById (R.id.userScreen); String userScreenName = tv.getText (). ToString (); // ouvre la page de profil de l'utilisateur dans le navigateur. Intention browserIntent = new Intent (Intent.ACTION_VIEW, Uri.parse ("http://twitter.com/" + userScreenName)); v.getContext (). startActivity (browserIntent); Ici, nous récupérons le nom d'utilisateur sous forme de chaîne de texte à partir de la vue elle-même, qui affiche néanmoins le nom d'écran sous forme de chaîne. Nous construisons cela dans une adresse de page de profil Twitter, en l’analysant comme un URI et en demandant au navigateur de l’ouvrir..
Rappelez-vous que l'activité principale de notre application affiche un bouton permettant aux utilisateurs d'accéder directement à l'écran Tweet. Mettons cela en application maintenant. Dans votre classe d'activité principale, ajoutez ce qui suit dans votre méthode "setupTimeline" n'importe où après avoir défini la vue de contenu principale:
// configuration de l'écouteur onclick pour le bouton de tweet LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.tweetbtn); tweetClicker.setOnClickListener (this);
L'ID du bouton Tweet correspond à ce que nous avons inclus dans le fichier de disposition XML de la timeline principale. La classe d'activité principale va gérer les clics du bouton Tweet. Si vous examinez votre méthode "onClick" dans l'activité principale ("TwitNiceActivity" si vous avez utilisé le nom dans le premier tutoriel), vous devriez voir une instruction switch avec une instruction case pour le bouton "connexion". Ajoutez une deuxième instruction de casse pour le bouton Tweet comme suit (avant l'instruction par défaut):
// l'utilisateur a appuyé sur le bouton de tweet case R.id.tweetbtn: // a lancé l'activité tweet startActivity (new Intent (this, NiceTweet.class)); Pause;
Ici, nous commençons simplement l'activité de Tweet. Nous n'avons pas besoin de transmettre d'informations à l'activité car, dans ce cas, l'utilisateur la lance simplement pour envoyer un tweet ordinaire..
C'est notre application Twitter complète! Exécutez l'application sur un émulateur ou un périphérique pour le voir fonctionner. Lors de la première utilisation, vous devrez bien entendu consentir à ce que l'application utilise votre compte Twitter. Vous pouvez éventuellement créer un compte Twitter distinct pour tester l'application, plutôt que d'utiliser votre compte normal. Après autorisation, la chronologie de votre domicile devrait vous être présentée. Elle représente les tweets les plus récents des comptes que vous suivez. Testez les tweets, les retweet et les réponses, et assurez-vous également que votre calendrier est mis à jour automatiquement à l'intervalle choisi..
Dans cette série de tutoriels, nous avons créé un client Twitter de base pour Android. Vous pouvez améliorer et améliorer l'application de nombreuses façons, par exemple en permettant de visualiser des messages directs ou de voir les profils d'utilisateurs dans l'application au lieu d'utiliser le navigateur Web. Vous pouvez également faire des mentions des utilisateurs dans les tweets cliquables (c'est-à-dire, lier n'importe quelle chaîne de texte précédée de "@" à la page de profil de cet utilisateur). Un processus similaire vous permettrait de prendre en charge les hashtags. Les clients Twitter plus avancés affichent également les conversations lors de la sélection d'un tweet individuel, affichant les réponses par ordre chronologique..
En ce qui concerne la mise en œuvre de l’application, vous pouvez également envisager des améliorations. Par exemple, si la connectivité de l'utilisateur est faible, vous pouvez implémenter le téléchargement des images de profil en tant que processus en arrière-plan. Vous pouvez également implémenter une forme de mise en cache des images pour optimiser l'efficacité. Plutôt que d’actualiser automatiquement l’affichage de la liste avec de nouveaux tweets, vous pouvez implémenter un bouton en haut de la chronologie pour permettre aux utilisateurs de contrôler l’affichage, le bouton indiquant le nombre de nouveaux tweets disponibles. Enfin, vous pouvez améliorer l’efficacité en exécutant le service dans un thread séparé..
J'espère que vous avez apprécié cette série sur la création d'un client Twitter pour la plateforme Android! En plus d'apprendre à connecter vos applications à Twitter, vous pouvez maintenant utiliser une bibliothèque externe ainsi que diverses ressources de la plateforme Android telles que des bases de données, des adaptateurs, des services et des diffusions. Ce sont toutes des compétences clés dont bénéficieront vos futurs projets Android. Le code source téléchargeable contient des notes supplémentaires qui pourraient vous être utiles..
