Share
În această serie construim un client Twitter pentru platforma Android folosind biblioteca Twitter4J. Acest tutorial se va axa pe implementarea de tweeting, retweeting și răspuns la tweet-uri. Vom crea o nouă activitate de tweeting și de răspuns, cu ajutorul butoanelor retweet și răspuns implementate pentru fiecare tweet în cronologia utilizatorului.
În primele patru tutoriale:
Aplicația noastră va avea o a doua activitate în plus față de ecranul cronologiei principale. Această nouă activitate este pentru trimiterea de Tweets. În interiorul său, utilizatorul poate introduce text pentru a trimite un tweet de pe contul lor Twitter. Utilizatorul poate intra în Activitatea Tweet în două moduri - prin apăsarea butonului Tweet din ecranul principal al aplicației sau prin apăsarea unui buton de răspuns din cronologie.
Dacă utilizatorul apasă butonul Tweet, acesta va fi prezentat cu un câmp de text gol pentru introducerea tweet-ului, cu un buton de expediere pentru a merge mai departe și trimite-l.
În cazul în care utilizatorul apasă butonul de răspuns într-un tweet de cronologie, acestea vor fi prezentate și cu câmpul de text, dar numele de răspuns va fi deja populate în câmp. De asemenea, răspunsul trebuie să fie trimis cu ajutorul ID-ului tweet-ului la care trebuie să răspundem, pe care îl vom implementa, de asemenea.
Creați o nouă clasă în proiectul dvs. Android, numind-o "NiceTweet" pentru a se potrivi cu numele pe care l-ați inclus în fișierul Manifest în primul tutorial. Modificați declarația de clasă după cum urmează:
clasa publică NiceTweet se extinde Activitatea implementează OnClickListener
Veți avea nevoie de următoarele importuri Android:
importă android.app.Activity; import android.content.SharedPreferences; import android.os.Bundle; import șiroid.util.Log; import șiroid.view.View; importă android.view.View.OnClickListener; import șiroid.widget.Button; importă android.widget.EditText; importă android.widget.LinearLayout;
Plus aceste importuri Twitter4J:
import twitter4j.StatusUpdate; import twitter4j.Twitter; import twitter4j.TwitterException; import twitter4j.TwitterFactory; import twitter4j.conf.Configuration; import twitter4j.conf.ConfigurationBuilder;
Includeți următoarele variabile de instanță în declarația de clasă:
/ ** preferințe partajate pentru detalii twitter utilizator * / private SharedPreferences tweetPrefs; / ** twitter obiect ** / Twitter privat tweetTwitter; / ** Cheie twitter * / String public final static TWIT_KEY = "cheia ta"; / ** twitter secret * / public final static String TWIT_SECRET = "secretul tău"; / ** ID-ul de actualizare pentru acest tweet dacă acesta este un răspuns * / private long tweetID = 0; / ** numele de utilizator pentru tweet dacă este un răspuns * / private String tweetName = "";
Vom folosi variabilele Preferences, Twitter, key și secret pentru a accesa metodele Twitter4J pentru tweeting din contul de utilizator. Modificați cheia și secretul pentru a vă potrivi. Cele două variabile finale sunt pentru răspunsuri. Când utilizatorul apasă butonul de răspuns într-un tweet, vom transmite ID-ul tweet-ului la care suntem de răspuns, alături de numele de ecran Twitter al contului la care răspundem. Vom păstra aceste în cele două variabile de instanță.
Să implementăm metoda de creare a activității:
/ * * onCreate apelat când activitatea este creată * / @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); // set tweet layout setContentView (R.layout.tweet);
Tot ce facem aici este setarea aspectului tweet pe care l-am definit mai devreme în XML. Aplicați în continuare metoda de reluare, care se numește ori de câte ori activitatea devine vizibilă pentru utilizator:
/ * * Metoda de configurare a apelului când începe această activitate * / @Override public void onResume () super.onResume (); // apelați metoda de ajutor helper setupTweet ();
Vom furniza metoda de ajutor specificată pentru a seta Activitatea în sus pentru interacțiunea cu utilizatorul.
Adăugați metoda "setupTweet" la clasa dvs. după cum urmează:
/ ** * Metodă apelată ori de câte ori această activitate începe * - pregătiți-vă să tweet * Setează twitter și onClick ascultători * - de asemenea, stabilește pentru răspunsuri * / private void setupTweet () // pregătiți să tweet
În cadrul acestei metode, trebuie să pregătim clasa pentru a trimite mesaje tweets obișnuite, precum și răspunsuri. Mai întâi, să folosim preferințele partajate pentru a instanțiza obiectul Twitter:
Accentsconagua
// primi preferințe pentru twitter twitter user tweetPrefs = getSharedPreferences ("TwitNicePrefs", 0); // primiți tokenul utilizatorului și secretul pentru autentificare String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // crea o nouă configurație twitter usign detalii utilizator Configurație twitConf = nou ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken) .setOAuthAccessTokenSecret (userSecret) .build (); // creați o instanță twitter tweetTwitter = noul TwitterFactory (twitConf) .getInstance (); Aici vom crea un obiect Twitter folosind informațiile de autentificare ale utilizatorului împreună cu cheia dezvoltatorului și secret pentru aplicație. Când luăm utilizatorii la această clasă de activitate, vom trece în ID și numele de utilizator dacă se răspunde la un tweet. Le obținem de la intenția:
// primiți orice date transmise acestui intenție pentru un răspuns Bundle extras = getIntent () getExtras ();
Dacă tweet-ul este o actualizare obișnuită și nu un răspuns, nu vor mai fi disponibile nici un extras. Dacă există extra, știm că tweet-ul este un răspuns:
dacă (extra! = null) // obțineți ID-ul tweetului pe care îl răspundem la tweetID = extras.getLong ("tweetID"); // obțineți numele de ecran al utilizatorului pentru tweetul pe care îl răspundem la tweetName = extras.getString ("tweetUser"); // utilizați informațiile transmise Aici vom prelua ID-ul și numele de ecran pentru tweet-ul pentru a răspunde. Apoi vom folosi aceste informații pentru a adăuga numele de utilizator în câmpul de text, aflat încă în declarația "if":
// primiți o referință la câmpul de text pentru tweeting EditText theReply = (EditText) findViewById (R.id.tweettext); // începe textul de tweet pentru răspunsul @username theReply.setText ("@" + tweetName + ""); // setați cursorul la sfârșitul textului pentru introducerea luiReply.setSelection (lungimeaReply.getText ().); Am setat numele de utilizator ca prima parte a textului tweet, plasând cursorul la sfârșit, astfel încât utilizatorul să-și poată scrie imediat textul de răspuns.
Înainte să luăm grijă de cazurile în care tweetul nu este un răspuns:
altceva EditText theReply = (EditText) findViewById (R.id.tweettext); theReply.setText ( "");
Aici am setat pur și simplu textul la un String gol, folosind din nou ID-ul pe care l-am dat câmpul text în layout-ul XML. Acum putem termina metoda "setupTweet" prin adăugarea de ascultători de clic pentru butonul "trimite" și butonul "home" pentru a reveni la ecranul cronologiei principale:
// set up listener pentru alegerea butonului home pentru a merge la cronologie LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.homebtn); tweetClicker.setOnClickListener (aceasta); // configurați ascultător pentru a trimite butonul tweet Buton tweetButton = (buton) findViewById (R.id.dotweet); tweetButton.setOnClickListener (aceasta);
Utilizăm din nou valorile ID identificate în fișierele noastre de aspect.
Amintiți-vă că Activitatea Tweet va conține un buton pentru a duce utilizatorii înapoi la cronologia de acasă, precum și butonul pentru a trimite tweet-ul. Să adăugăm acum metoda "onClick" pentru a trata utilizatorii care fac clic pe aceste butoane:
/ ** * Metoda de ascultare pentru clicurile pe butoane * - pentru butonul acasă și trimiterea butonului tweet * / public void onClick (View v) // acționa acasă și trimite clicuri pe buton
Mai întâi primiți o referință la câmpul de text:
EditareText tweetTxt = (EditText) findViewById (R.id.tweettext);
Acum trebuie să analizăm ce buton a fost apăsat pe butoanele switch și case:
// afla care vizualizare a fost făcută clic pe comutator (v.getId ()) caz R.id.dotweet: // trimite tweet break; caz R.id.homebtn: // mergeți la pauza cronologică de acasă; prestabilit: pauză;
În interiorul instrucțiunii de caz "dotweet", înainte de instrucțiunea break, implementați trimiterea unui tweet după cum urmează:
String pentru toTweet = tweetTxt.getText (). ToString (); încercați // preluați răspunsurile dacă (tweetName.length ()> 0) tweetTwitter.updateStatus (new StatusUpdate (toTweet) .inReplyToStatusId (tweetID)); // manipula tweets normal altundeva tweetTwitter.updateStatus (toTweet); // resetați textul de editare tweetTxt.setText (""); captură (TwitterException te) Log.e ("NiceTweet", te.getMessage ()); Aici verificăm dacă mesajul tweet este un răspuns sau nu. Instrucțiunea "if" se execută dacă tweet-ul este un răspuns, inclusiv textul din câmpul text și ID-ul actualizării de stare la care răspundem. Instrucțiunea "else" se ocupă de trimiterea de tweete obișnuite, în care numai textul este trecut ca parametru. Blocurile de încercare și capturare sunt necesare deoarece încercăm să ne conectăm la Twitter prin rețea. Dupa trimiterea tweet-ului, indiferent daca a fost sau nu un raspuns, am setat campul text inapoi la gol in pregatirea pentru urmatoarea update tweet.
Pentru instrucțiunea "homebtn", setați simplu câmpul text la un String gol:
tweetTxt.setText ( "");
În cele din urmă, după declarația comutatorului, dar încă în metoda "onClick", terminați activitatea astfel încât să revină la cronologia de acasă:
finalizarea();
Dacă tweet-ul este un răspuns sau o actualizare obișnuită, îl vom întoarce imediat pe ecranul principal atunci când este trimis, ceea ce facem și atunci când apasă butonul de acasă - instrucțiunea finală se va executa în toate cele trei cazuri.
Pentru a implementa retweeting-ul și răspunsul, trebuie să stocăm ID-ul tweet-ului și numele de ecran al utilizatorului în butoanele retweet și reply pentru fiecare tweet din cronologie. Prin stocarea acestor date în butoanele Vizualizări pentru retweet și răspuns, vom putea detecta ce tweet este returmat sau răspuns la momentul în care utilizatorul apasă un buton.
Deoarece informațiile de care avem nevoie pentru stocare cuprind un număr și un anumit text, vom crea o clasă care să o modeleze. Creați o nouă clasă în proiectul dvs. și denumiți-o "StatusData". Noua dvs. clasă ar trebui să înceapă după cum urmează:
clasă publică StatusData
În interiorul clasei, adăugați variabile de instanță pentru ID-ul tweet și numele de utilizator:
/ ** tweet ID * / private tweetID privat; / ** numele de ecran al utilizatorului cu tweeter * / private String tweetUser;
ID-ul este modelat ca lung, cu numele de ecran un text String. Adăugați o metodă constructor la clasă:
/ ** * Constructorul primește ID-ul și numele de utilizator * @param ID * @param screenName * / StatusData public (lung ID, String screenName) // instantiate variables tweetID = ID; tweetUser = screenname;
Metoda simplifică pur și simplu cele două variabile. Apoi, adăugați o metodă publică, astfel încât să putem prelua ID-ul tweet-ului în altă parte:
/ ** * Obțineți ID-ul tweet-ului * @return tweetID ca lung * / public long getID () return tweetID;
Apoi adăugați o metodă pentru a reveni la numele de ecran:
/ ** * Obțineți numele de ecran al utilizatorului pentru tweet * @return tweetUser ca String * / public String getUser () return tweetUser;
Aceste metode ne vor permite să preluăm aceste informații când utilizatorii fac clic pe butonul retweet sau răspuns pentru un anumit tweet.
Acum trebuie să extindem codul în clasa adaptoare pe care am creat-o ("UpdateAdapter"). În metoda "bindView", am adaptat cartografierea datelor în Vizualizările interfeței utilizator. Acum vom adăuga procesarea ulterioară pentru a include datele tweet în fiecare buton retweet și răspuns. Înainte de sfârșitul metodei "bindView", începeți după cum urmează:
// obține status ID lung statusID = cursor.getLong (cursor.getColumnIndex (BaseColumns._ID)); // a obține numele de utilizator String statusName = cursor.getString (cursor.getColumnIndex ("user_screen")); Rețineți că metoda "bindView" este trecută cu un obiect Cursor pentru traversarea datelor. Aici folosim Cursorul pentru a extrage valoarea ID lungă și numele de utilizator String pentru tweet-ul curent. Veți avea nevoie de următorul import suplimentar:
import android.provider.BaseColumns;
Acum vom instantiza un obiect al noii clase StatusData, trecand datele tweet la metoda constructorului:
// crea un obiect StatusData pentru a stoca aceste StatusData tweetData = new StatusData (statusID, statusName);
Obiectul StatusData conține tot ceea ce este necesar pentru a trimite un retweet sau un răspuns pentru tweet-ul în cauză. Vom atașa acum o referință la acest obiect în butoanele retweet și răspuns pentru tweet, astfel încât să putem accesa informațiile după clicurile utilizatorilor. Folosim metoda "setTag":
// setați obiectul de date de stare ca tag pentru ambele butoane retweet și răspuns în această vizualizare row.findViewById (R.id.retweet) .setTag (tweetData); row.findViewById (R.id.reply) .setTag (tweetData);
Metoda "bindView" primește, de asemenea, un parametru reprezentând rândul Vizualizare în care va fi afișat mesajul tweet. Dacă vă uitați înapoi la fișierul de aspect XML de actualizare, veți vedea că aceste două valori ID sunt incluse pentru butoane. Am setat eticheta în fiecare buton pentru a reflecta obiectul StatusData care deține ID-ul și numele de utilizator pentru tweet-ul afișat. Acum trebuie să setăm clicurile pentru butoane:
// configurați ascultătorii onclick pentru butoanele retweet și răspuns row.findViewById (R.id.retweet) .setOnClickListener (tweetListener); row.findViewById (R.id.reply) .setOnClickListener (tweetListener);
Aici specificăm un ascultător de clic pentru a face față clicurilor pe butoane. În cadrul metodei ascultătorului, vom putea prelua obiectele StatusData ale oricărui buton de retweet și de răspuns pe care l-ați dat clic. De asemenea, vom permite utilizatorilor să facă clic pe numele de utilizator pentru un tweet pentru a deschide profilul de utilizator în browserul Web. Adăugați un ascultător de clic la care Vizualizați și aici:
// setare onclick pentru numele de ecran al utilizatorului în rândul tweet row.findViewById (R.id.userScreen) .setOnClickListener (tweetListener);
Acest lucru ne va permite să conectăm interfața Web Twitter astfel încât utilizatorii să poată accesa funcțiile pe care nu le-am furnizat în cadrul aplicației.
În clasa dvs. UpdateAdapter, creați un "onClickListener" pentru a gestiona clicurile, utilizând numele "tweetListener" pentru a se potrivi cu ceea ce am specificat în metoda "bindView":
/ ** * tweetListener se ocupă de clicurile butoanelor de răspuns și retweet * - se ocupă, de asemenea, cu clic pe numele de utilizator într-un tweet * / private OnClickListener tweetListener = new OnClickListener () // onClick metoda public void onClick (View v) ;
Adăugați următoarele importuri adiționale la clasa Adaptor:
importă android.view.View.OnClickListener; import șiroid.content.Intent; import android.content.SharedPreferences; importă android.widget.Toast; importul android.net.Uri; import twitter4j.Twitter; import twitter4j.TwitterException; import twitter4j.TwitterFactory; import twitter4j.conf.Configuration; import twitter4j.conf.ConfigurationBuilder;
În cadrul metodei "onClick" vom implementa clicurile ambelor butoane plus numele de utilizator. Pentru a detecta pe care a fost făcut clic, adăugați o instrucțiune de comutare:
// care vizualizare a fost făcută clic pe comutator (v.getId ()) // butonul de răspuns apăsat R.id.reply: // implement reply break; // caseta apăsată de butonul retweet R.id.retweet: // implementați retweet break; // utilizatorul a apăsat cazul de nume de utilizator tweet R.id.userScreen: // implementa ruperea profilului de utilizator; prestabilit: pauză;
În cadrul declarației de răspuns de răspuns, începem clasa Activitate Tweet, trecând datele de răspuns, astfel încât ID-ul de răspuns și numele de utilizator pot fi incluse la trimiterea mesajului tweet:
// creați o intenție pentru trimiterea unui nou tweet Intent replyIntent = intenție nouă (v.getContext (), NiceTweet.class); // obțineți datele din etichetă în butonul StatusData viewData = (StatusData) v.getTag (); // treceți ID-ul de stare replyIntent.putExtra ("tweetID", dataData.getID ()); // treci numele de utilizator replyIntent.putExtra ("tweetUser", dataData.getUser ()); // du-te la ecranul tweet v.getContext () startActivity (replyIntent); Observați că extragem eticheta pentru vizualizarea apăsată, turnându-o ca obiect StatusData. Apoi, apelăm metodele publice pe care le-am furnizat în cadrul clasei StatusData pentru a returna ID-ul tweet-ului și numele de ecran al utilizatorului. Le transmitem activității Tweet ca extras, apoi începem activitatea. În acest moment, utilizatorul va fi dus la ecranul Tweet, unde datele de răspuns vor fi folosite pentru implementarea răspunsului la tweet-ul corect.
În declarația caz retweet, vom retweet tweet-ul relevant, utilizând metodele Twitter4J. Inițializați mai întâi un obiect Twitter utilizând Preferințele partajate, plus cheia dvs. de dezvoltator și secret pentru aplicație:
// a lua context Context appCont = v.getContext (); // obține preferințe pentru accesul utilizatorilor SharedPreferences tweetPrefs = appCont.getSharedPreferences ("TwitNicePrefs", 0); String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // crea noua Configurare Twitter configurare twitConf = new ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken). setOAuthAccessTokenSecret (userSecret) .build (); // creați instanță Twitter pentru repetare Twitter retweetTwitter = new TwitterFactory (twitConf) .getInstance (); Aceasta este aceeasi tehnica pe care am folosit-o pentru a instantiza clasa Twitter inainte. Acum putem folosi obiectul Twitter pentru a trimite retweet-ul. Mai întâi trebuie să preluăm obiectul StatusData din butonul care a fost apăsat:
// a obține datele tweet din eticheta de vizualizare StatusData tweetData = (StatusData) v.getTag ();
Acum putem încerca să returneze actualizarea într-un bloc try:
încercați // retweet, trecând codul de stare din tagul retweetTwitter.retweetStatus (tweetData.getID ()); captură (TwitterException te) Log.e (LOG_TAG, te.getMessage ());
Toate obiectele Twitter trebuie să trimită un retweet este ID-ul tweet-ului original. Cu toate acestea, permiteți utilizatorului să confirme că retweet-ul a fost trimis, încă în interiorul blocului de încercare:
// confirmați utilizarea funcției CharSequence text = "Retweeted!"; int duration = Toast.LENGTH_SHORT; Toast toast = Toast.makeText (appCont, text, durată); toast.show ();
Puteți schimba, desigur, mesajul dacă doriți. Asa arata:
Acum permiteți utilizatorului să acceseze o pagină de profil Twitter în browserul Web făcând clic pe numele ecranului din tweet-ul curent, în cadrul instrucțiunii de caz "userScreen":
// a obține numele de ecran al utilizatorului TextView tv = (TextView) v.findViewById (R.id.userScreen); String userScreenName = tv.getText (). ToString (); // deschideți pagina de profil a utilizatorului în browserul Intenție browserIntent = intenție nouă (Intent.ACTION_VIEW, Uri.parse ("http://twitter.com/" + userScreenName)); . V.getContext () startActivity (browserIntent); Aici vom prelua numele de utilizator ca un String de text din Vizualizare în sine, care, oricum, afișează numele de ecran ca String. Construim acest lucru într-o adresă de pagină de profil Twitter, parsând-o ca un URI și instruind browserul să o deschidă.
Rețineți că aplicația principală Activitate afișează un buton pentru a duce utilizatorii direct la ecranul Tweet. Să implementăm asta acum. În clasa principală a activității, adăugați următoarele în interiorul metodei "setupTimeline", oriunde ați setat vizualizarea principală a conținutului:
// setare ascultare onclick pentru butonul tweet LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.tweetbtn); tweetClicker.setOnClickListener (aceasta);
ID-ul butonului Tweet se potrivește cu ceea ce am inclus în fișierul de aspect XML al cronologiei principale. Clasa de activitate principală va gestiona clicurile butonului Tweet. Dacă te uiți la metoda "onClick" din activitatea principală ("TwitNiceActivity" dacă ai folosit numele în primul tutorial), ar trebui să vezi o instrucțiune de comutare cu o instrucțiune de caz pentru butonul "signin". Adăugați o instrucțiune pentru cel de-al doilea caz pentru butonul Tweet, după cum urmează (înainte de instrucțiunea implicită):
// user a apăsat butonul de tip tweet R.id.tweetbtn: // lansarea activității tweet startActivity (nou intenție (this, NiceTweet.class)); pauză;
Aici începem pur și simplu activitatea Tweet. Nu trebuie să transmitem nicio informație activității, deoarece în acest caz utilizatorul o lansează pur și simplu pentru a trimite un tweet obișnuit.
Aceasta este completarea aplicației noastre Twitter! Rulați aplicația pe un emulator sau dispozitiv pentru a vedea că funcționează. La prima rulare, va trebui, desigur, să fiți de acord să lăsați aplicația să vă utilizeze contul dvs. Twitter. Puteți să creați opțional un cont Twitter separat pentru a testa aplicația, mai degrabă decât să utilizați contul dvs. normal. După autorizare, trebuie să vi se prezinte cronologia de acasă reprezentând cele mai recente tweet-uri din conturile pe care le urmăriți. Verificați tentativul, repetați și răspundeți, precum și asigurați-vă că linia temporală se actualizează automat la intervalul ales.
În această serie de tutori am creat un client de bază Twitter pentru Android. Există multe modalități prin care puteți îmbunătăți și îmbunătăți aplicația, cum ar fi includerea abilității de a vizualiza mesaje directe sau de a vizualiza profiluri de utilizatori în cadrul aplicației, în loc să fie necesar să utilizați browserul Web. Puteți face, de asemenea, menționări ale utilizatorilor în tweets clickabile (adică legarea oricărui text String precedat de "@" la pagina de profil pentru respectivul utilizator). Un proces similar vă va permite să sprijiniți hashtag-urile. Cei mai avansați clienți Twitter afișează și conversații atunci când selectează un tweet individual, afișând răspunsurile în ordine cronologică.
În ceea ce privește implementarea aplicației, există și îmbunătățiri pe care le puteți lua în considerare. De exemplu, în cazul în care utilizatorul are conectivitate scăzută, puteți implementa descărcarea imaginilor de profil ca proces de fundal. De asemenea, puteți implementa o anumită formă de cache imagine pentru a maximiza eficiența. Mai degrabă decât actualizarea automată a aplicației ListView cu Tweets noi, puteți implementa un buton în partea de sus a liniei de timp, pentru ca utilizatorii să poată controla afișajul, cu butonul indicând câte mesaje tweets sunt disponibile. În cele din urmă, puteți îmbunătăți eficiența prin rularea Serviciului într-un Thread separat.
Sper că v-ați bucurat de această serie despre Crearea unui Client Twitter pentru platforma Android! Pe lângă faptul că învățați cum să vă conectați aplicațiile la Twitter, aveți acum experiența utilizării unei biblioteci externe plus o varietate de resurse de platformă Android, cum ar fi baze de date, adaptoare, servicii și difuzări. Acestea sunt toate abilități cheie pe care viitoarele proiecte Android le vor beneficia. Codul sursă care se poate descărca conține note suplimentare pe care le puteți considera utile.
