Share
I denne serien bygger vi en Twitter-klient for Android-plattformen ved hjelp av Twitter4J-biblioteket. Denne opplæringen vil fokusere på å implementere tweeting, retweeting og svare på tweets. Vi vil opprette en ny aktivitet for tweeting og svar, med retweet og svarknapper implementert for hver tweet i brukerens hjemme tidslinje.
I de første fire opplæringen vi:
Vår app kommer til å ha en annen aktivitet i tillegg til hovedtidslinjeskjermbildet. Denne nye aktiviteten er for å sende Tweets. Innenfor det kan brukeren skrive inn tekst for å sende en tweet fra sin Twitter-konto. Brukeren kan legge inn Tweet-aktiviteten på to måter - ved å trykke på knappen Tweet på appens hovedskjerm eller ved å trykke på en svarknapp innenfor tidslinjen.
Hvis brukeren trykker på knappen Tweet, vil de bli presentert med et tomt tekstfelt for å skrive inn tweet, med en send-knapp for å fortsette og sende den.
Hvis brukeren trykker på svarknappen innenfor en tidslinje tweet, vil de også bli presentert med tekstfeltet, men svaret til brukernavnet vil allerede bli fylt ut i feltet. Svaret må også sendes ved hjelp av ID-nummeret til tweet som besvares, som vi også skal implementere.
Opprett en ny klasse i Android-prosjektet ditt, og navngi det "NiceTweet" for å matche navnet du inkluderte i din Manifest-fil i den første opplæringen. Endre klassedeklarasjonen som følger:
offentlig klasse NiceTweet utvider Aktivitetsredskaper OnClickListener
Du trenger følgende Android-import:
importer android.app.Activity; importer android.content.SharedPreferences; importere 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;
Pluss disse Twitter4J-importene:
importer twitter4j.StatusUpdate; importere twitter4j.Twitter; importere twitter4j.TwitterException; importer twitter4j.TwitterFactory; importer twitter4j.conf.Configuration; importer twitter4j.conf.ConfigurationBuilder;
Inkluder følgende forekomstvariabler i klassedeklarasjonen din:
/ ** delte preferanser for bruker twitter detaljer * / private SharedPreferences tweetPrefs; / ** twitter objekt ** / privat Twitter tweetTwitter; / ** twitter nøkkel * / offentlig endelig statisk streng TWIT_KEY = "din nøkkel"; / ** twitter hemmelig * / offentlig endelig statisk streng TWIT_SECRET = "din hemmelige"; / ** oppdaterings-ID for denne tweet hvis det er et svar * / privat long tweetID = 0; / ** brukernavnet for tweet hvis det er et svar * / privat String tweetName = "";
Vi vil bruke Preferans, Twitter, nøkkel og hemmelige variabler for å få tilgang til Twitter4J-metodene for tweeting fra brukerkontoen. Endre nøkkelen og hemmelig for å passe dine egne. De to siste variablene er for svar. Når brukeren trykker på svarknappen i en tweet, skal vi passere IDen til tweet som besvares, sammen med Twitter-skjermnavnet på kontoen vi svarer på. Vi lagrer disse i de to instansvariablene.
La oss implementere opprettelsesmetoden for aktivitet:
/ * * onCreate kalt når aktivitet er opprettet * / @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); // sett tweet layout setContentView (R.layout.tweet);
Alt vi gjør her er satt tweet-oppsettet vi definerte i XML tidligere. Neste implementere CV-metoden, som kalles når aktiviteten blir synlig for brukeren:
/ * * Ring oppsettmetode når denne aktiviteten starter * / @Override public void onResume () super.onResume (); // oppringingsmetode setupTweet ();
Vi skal gi den angitte hjelpemetoden for å stille aktiviteten opp for brukerinteraksjon.
Legg til "setupTweet" -metoden i klassen din som følger:
/ ** * Metode kalt når denne aktiviteten starter * - gjør deg klar til tweet * Setter opp twitter og onClick lyttere * - setter også opp for svar * / private void setupTweet () // forberede seg til tweet
Inne i denne metoden må vi forberede klassen for å sende vanlige tweets samt svar. Først, la oss bruke de delte innstillingene for å instantiere vårt Twitter-objekt:
Accentsconagua
// få preferanser for bruker twitter detaljer tweetPrefs = getSharedPreferences ("TwitNicePrefs", 0); // få bruker token og hemmelighet for godkjenning String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // opprette en ny twitter-konfigurasjon usign brukerdetaljer Konfigurasjon twitConf = ny ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken) .setOAuthAccessTokenSecret (userSecret) .build (); // opprette en twitter-forekomst tweetTwitter = ny TwitterFactory (twitConf) .getInstance (); Her oppretter vi et Twitter-objekt ved hjelp av brukerens autentiseringsinformasjon sammen med utviklernøkkelen og hemmeligheten for applikasjonen. Når vi tar brukere til denne aktivitetsklassen, skal vi passere i ID og brukernavn hvis en tweet blir besvart. Vi får disse fra hensikten:
// få data sendt til denne hensikten for et svar Bundle extras = getIntent (). getExtras ();
Hvis tweet er en vanlig oppdatering i stedet for et svar, vil det ikke være noen ekstramateriale. Hvis det er ekstramateriale, vet vi at tweet er et svar:
hvis (statister! = null) // få IDen til tweetet vi svarer på tweetID = extras.getLong ("tweetID"); // få brukernavnet til tweetet vi svarer på tweetName = extras.getString ("tweetUser"); // bruk bestått informasjon Her henter vi ID og skjermnavn for tweetet for å svare på. Deretter bruker vi denne informasjonen til å legge til brukernavnet til tekstfeltet, fortsatt inne i setningen "if":
// få en referanse til tekstfeltet for tweeting EditText theReply = (EditText) findViewById (R.id.tweettext); // start tweet-teksten for svaret @ brukernavnet theReply.setText ("@" + tweetName + ""); // Sett markøren til slutten av teksten for oppføring theReply.setSelection (theReply.getText (). lengde ()); Vi setter brukernavnet som den første delen av tweetteksten, plasserer markøren på slutten, slik at brukeren kan skrive inn sin svartekst straks.
Neste, la oss ta vare på tilfeller der tweet ikke er et svar:
ellers EditText theReply = (EditText) findViewById (R.id.tweettext); theReply.setText ( "");
Her setter vi bare teksten til en tom streng, igjen ved hjelp av ID-en vi ga tekstfeltet i layout XML. Nå kan vi fullføre "setupTweet" -metoden ved å legge til klikkelyttere for "send" -knappen og "hjem" -knappen for å gå tilbake til hovedtidslinjeskjermbildet:
// sette opp lytteren for å velge hjemme-knappen for å gå til tidslinjen LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.homebtn); tweetClicker.setOnClickListener (this); // sette opp lytteren for å sende tweet-knappen Button tweetButton = (Button) findViewById (R.id.dotweet); tweetButton.setOnClickListener (this);
Vi bruker igjen ID-verdiene vi angav i våre layoutfiler.
Husk at Tweet-aktiviteten skal inneholde en knapp for å få brukerne tilbake til starttidslinjen, samt knappen for å sende tweetet. La oss nå legge til "onClick" -metoden for å håndtere brukere som klikker på disse knappene:
/ ** * Lyttemetode for knappeklikk * - for hjemmeknapp og send tweet-knapp * / offentlig tomgang påClick (Vis v) // håndtere hjem og send knappeklikk
Først få en referanse til tekstfeltet:
EditText tweetTxt = (EditText) findViewById (R.id.tweettext);
Nå må vi finne ut hvilken knapp som ble klikket ved hjelp av bytte- og saksdeklarasjoner:
// finn ut hvilken visning som er klikket bryteren (v.getId ()) tilfelle R.id.dotweet: // send tweet break; sak R.id.homebtn: // gå til hjemmet tidslinje pause; standard: break;
Inne i "dotweet" saken setningen, før break statement, implementere sende en tweet som følger:
String toTweet = tweetTxt.getText (). ToString (); prøv // håndtere svar hvis (tweetName.length ()> 0) tweetTwitter.updateStatus (ny StatusUpdate (toTweet) .inReplyToStatusId (tweetID)); // håndtere vanlige tweets ellers tweetTwitter.updateStatus (toTweet); // tilbakestill redigeringsteksten tweetTxt.setText (""); fangst (TwitterException te) Log.e ("NiceTweet", te.getMessage ()); Her kontrollerer vi om tweet er et svar eller ikke. If-setningen utføres hvis tweet er et svar, inkludert teksten fra tekstfeltet og ID-en for statusoppdateringen vi svarer på. "Ellers" -oppgaven tar seg av å sende vanlige tweets, hvor kun teksten sendes som parameter. Prøv og fang blokkene er nødvendige da vi forsøker å koble til Twitter over nettverket. Etter at du har sendt tweetet, enten det er et svar eller ikke, setter vi tekstfeltet tilbake til tomt som forberedelse til neste tweet-oppdatering.
For "homebtn" saken setningen, bare sett tekstfeltet til en tom String:
tweetTxt.setText ( "");
Til slutt, etter bryteroppstillingen, men likevel inne i "onClick" -metoden, avslutt aktiviteten slik at den vender tilbake til hjemme tidslinjen:
bli ferdig();
Om tweet er et svar eller en vanlig oppdatering, tar vi straks brukeren tilbake til hovedskjermbildet når den sendes, som vi også gjør når de trykker på hjemme-knappen - ferdig utsagn vil utføre i alle tre tilfeller.
For å implementere retweeting og svar, må vi lagre tweet-ID- og brukerskjermnavnet i retweet- og svarknappene for hver tweet på tidslinjen. Ved å lagre disse dataene i knappen Visninger for retweet og svare, vil vi kunne oppdage hvilken tweet som blir retweetet eller svart på når brukeren trykker på en knapp.
Fordi informasjonen vi trenger å lagre består av et tall og litt tekst, vil vi lage en klasse for å modellere den. Opprett en ny klasse i prosjektet ditt og kaller det "StatusData". Din nye klasse skal begynne som følger:
offentlig klasse StatusData
Inne i klassen legger du til forekomstvariabler for tweet-ID og brukernavn:
/ ** tweet ID * / privat lang tweetID; / ** bruker skjerm navn på diskant * / privat String tweetUser;
IDen er modellert som en lang, med skjermnavnet en tekst String. Legg til en konstruktormetode for klassen:
/ ** * Konstruktør mottar ID og brukernavn * @param ID * @param skjermnavn * / offentlig StatusData (lang ID, String skjermnavn) // instantiate variables tweetID = ID; tweetUser = screen;
Metoden enkelt instantiates de to variablene. Deretter legger du til en offentlig metode slik at vi kan hente tweet-IDen andre steder:
/ ** * Få IDen til tweet * @return tweetID som en lang * / offentlig lang getID () return tweetID;
Legg deretter til en metode for å returnere skjermnavnet:
/ ** * Få brukernavnet til tweetet * @return tweetUser som en streng * / public String getUser () return tweetUser;
Disse metodene lar oss hente denne informasjonen når brukere klikker på retweet- eller svarknappen for en bestemt tweet.
Nå må vi utvide koden i Adapter-klassen vi opprettet ("UpdateAdapter"). I "bindView" -metoden skredde vi kartlegging av data til brukergrensesnittet. Nå vil vi legge til ytterligere behandling for å inkludere tweet-dataene i hver retweet- og svarknapp. Før slutten av bindView-metoden din, begynner du som følger:
// få status ID lang statusID = cursor.getLong (cursor.getColumnIndex (BaseColumns._ID)); // få brukernavnet String statusName = cursor.getString (cursor.getColumnIndex ("user_screen")); Husk at "bindView" -metoden er bestått et markørobjekt for å krysse dataene. Her bruker vi Markøren til å hente den lange ID-verdien og String-brukernavnet for gjeldende tweet. Du trenger følgende ekstra import:
importer android.provider.BaseColumns;
Nå vil vi instantiere et objekt av vår nye StatusData-klasse, som sender tweet-dataene til konstruktormetoden:
// opprett et StatusData-objekt for å lagre disse StatusData tweetData = ny StatusData (statusID, statusnavn);
StatusData-objektet inneholder alt som er nødvendig for å sende en retweet eller svare på det aktuelle tweetet. Vi legger nå en referanse til dette objektet i retweet- og svarknappene for tweetet, slik at vi får tilgang til informasjonen som følger med brukerklikk. Vi bruker "setTag" metoden:
// angi statusdataobjektet som tag for både retweet og svarknapper i denne visningen row.findViewById (R.id.retweet) .setTag (tweetData); row.findViewById (R.id.reply) .setTag (tweetData);
"BindView" -metoden mottar også en parameter som representerer radvisningen der tweeten skal vises. Hvis du ser tilbake på oppdaterings XML-layoutfilen, ser du at disse to ID-verdiene er inkludert for knappene. Vi setter taggen i hver knapp for å gjenspeile StatusData-objektet som inneholder IDen og brukernavnet for tweeten som vises. Nå må vi sette opp knappeklikk for disse:
// setup onclick lyttere for retweet og svar knapper row.findViewById (R.id.retweet) .setOnClickListener (tweetListener); row.findViewById (R.id.reply) .setOnClickListener (tweetListener);
Her spesifiserer vi en klikklytter for å håndtere knappeklikk. Inne i lytteremetoden vil vi kunne hente StatusData-objekter av eventuelle retweet- og svarknapper som er klikket. Vi skal også tillate brukere å klikke brukernavnet for en tweet for å åpne brukerprofilen i nettleseren. Legg til en klikklytter til det Se også her:
// setup onclick for brukerens skjermnavn i tweet row.findViewById (R.id.userScreen) .setOnClickListener (tweetListener);
Dette vil tillate oss å koble inn i Twitter-webgrensesnittet slik at brukere kan få tilgang til funksjoner vi ikke har oppgitt i selve appen.
Opprett en "onClickListener" i klassen UpdateAdapter for å håndtere klikk ved å bruke navnet "tweetListener" for å matche det vi spesifiserte i bindView-metoden:
/ ** * tweetListener håndterer klikk med svar og retweet-knapper * - også håndterer å klikke brukernavnet i en tweet * / privat OnClickListener tweetListener = ny OnClickListener () // onClick-metode offentlig tomgang påClick (Vis v) ;
Legg til følgende ekstra import til Adapter-klassen:
importer android.view.View.OnClickListener; importer android.content.Intent; importer android.content.SharedPreferences; importer android.widget.Toast; importer android.net.Uri; importere twitter4j.Twitter; importere twitter4j.TwitterException; importer twitter4j.TwitterFactory; importer twitter4j.conf.Configuration; importer twitter4j.conf.ConfigurationBuilder;
Inne i "onClick" -metoden vil vi implementere klikk på begge knappene pluss brukernavnet. For å oppdage hvilken som er klikket, legg til en bryteretning:
// hvilken visning var klikket bryteren (v.getId ()) // Svar-knappen trykket tilfelle R.id.reply: // implementere svar pause; // retweet-knappen trykket tilfelle R.id.retweet: // implementere retweet pause; // bruker har trykket tweet brukernavn tilfelle R.id.userScreen: // implementere besøker brukerprofil pause; standard: break;
Inne i svaret saken setningen, starter vi Tweet Aktivitetsklassen, og sender svardataene slik at svar-ID og brukernavn kan inkluderes når du sender tweet:
// opprette en hensikt for å sende en ny tweet Intent replyIntent = new Intent (v.getContext (), NiceTweet.class); // hente dataene fra taggen i knappvisningen StatusData theData = (StatusData) v.getTag (); // pass status ID answerIntent.putExtra ("tweetID", theData.getID ()); // pass brukernavnet answerIntent.putExtra ("tweetUser", theData.getUser ()); // gå til tweet-skjermen v.getContext (). startAktivitet (replyIntent); Legg merke til at vi henter taggen for den pressede View, kaster den som et StatusData-objekt. Vi kaller deretter de offentlige metodene vi oppgav i StatusData-klassen for å returnere tweet-ID og brukerskjermnavn. Vi sender disse til Tweetaktiviteten som tillegg, og deretter starter aktiviteten. På dette tidspunktet blir brukeren tatt til skjermbildet Tweet hvor svardataene blir brukt til å implementere svar på riktig tweet.
I retweet-saken, vil vi retweetes relevant tweet direkte, ved hjelp av Twitter4J-metodene. Installer først et Twitter-objekt ved hjelp av de delte innstillingene pluss utvikler nøkkelen din og hemmelighet for appen:
// få kontekst Kontekst appCont = v.getContext (); // få preferanser for brukertilgang SharedPreferences tweetPrefs = appCont.getSharedPreferences ("TwitNicePrefs", 0); String userToken = tweetPrefs.getString ("user_token", null); String userSecret = tweetPrefs.getString ("user_secret", null); // opprett ny Twitter konfigurasjon Konfigurasjon twitConf = ny ConfigurationBuilder () .setOAuthConsumerKey (TWIT_KEY) .setOAuthConsumerSecret (TWIT_SECRET) .setOAuthAccessToken (userToken) .setOAuthAccessTokenSecret (userSecret) .build (); // lage Twitter-forekomst for retweeting Twitter retweetTwitter = ny TwitterFactory (twitConf) .getInstance (); Dette er den samme teknikken vi har brukt til å ordne Twitter-klassen før. Vi kan nå bruke Twitter-objektet til å sende retweeten. Først må vi hente StatusData-objektet fra knappen som har blitt klikket:
// få tweet data fra visning tag StatusData tweetData = (StatusData) v.getTag ();
Nå kan vi prøve å retweete oppdateringen i en prøveblokk:
prøv // retweet, passerer status-ID fra taggen retweetTwitter.retweetStatus (tweetData.getID ()); fangst (TwitterException te) Log.e (LOG_TAG, te.getMessage ());
Alt Twitter-objektet må sende en retweet er IDen til den opprinnelige tweeten. La oss imidlertid gi brukeren bekreftelse på at deres retweet ble sendt, fortsatt inne i forsøksblokken:
// bekreft å bruke CharSequence text = "Retweeted!"; int varighet = Toast.LENGTH_SHORT; Toast toast = Toast.makeText (appCont, tekst, varighet); toast.show ();
Du kan selvfølgelig endre meldingen hvis du vil. Slik ser det ut:
La oss nå tillate brukeren å besøke en Twitter-profilside i nettleseren ved å klikke på skjermnavnet i gjeldende tweet, inne i "userScreen" -saken setningen:
// få brukerens skjermnavn TextView tv = (TextView) v.findViewById (R.id.userScreen); String userScreenName = tv.getText (). ToString (); // åpne brukerens profilside i nettleseren Intent browserIntent = new Intent (Intent.ACTION_VIEW, Uri.parse ("http://twitter.com/" + userScreenName)); . V.getContext () startActivity (browserIntent); Her henter vi brukernavnet som en tekst String fra selve Se, som altså viser skjermnavnet som en streng. Vi bygger dette inn i en Twitter-profilsideadresse, parsing den som en URI og instruerer nettleseren til å åpne den.
Husk at vår hovedappaktivitet viser en knapp for å få brukerne rett til Tweet-skjermen. La oss implementere det nå. I din hovedaktivitetsklasse legger du til følgende i "setupTimeline" -metoden din, hvor som helst etter at du har angitt hovedinnholdsvisningen:
// setup onclick listener for tweet-knappen LinearLayout tweetClicker = (LinearLayout) findViewById (R.id.tweetbtn); tweetClicker.setOnClickListener (this);
Tweet-knappen-IDen samsvarer med det vi inkluderte i XML-layoutfilen for hovedtidslinjen. Hovedaktivitetsklassen skal håndtere klikk på Tweet-knappen. Hvis du ser på "onClick" -metoden i hovedaktiviteten ("TwitNiceActivity" hvis du brukte navnet i den første opplæringen), bør du se en svarserklæring med en saksdeklarasjon for "signin" -knappen. Legg til en andre tilfelle setning for Tweet-knappen som følger (før standard setningen):
// bruker har trykket tweet button case R.id.tweetbtn: // start tweet aktivitet startActivity (new Intent (dette, NiceTweet.class)); gå i stykker;
Her starter vi ganske enkelt Tweetaktiviteten. Vi trenger ikke å sende noen informasjon til aktiviteten som i dette tilfellet brukeren bare lanserer den for å sende en vanlig tweet.
Det er vår Twitter app komplett! Kjør appen på en emulator eller enhet for å se den fungere. På første løp må du selvsagt gi samtykke til at appen kan bruke din Twitter-konto. Du kan eventuelt opprette en egen Twitter-konto for å teste appen, i stedet for å bruke din normale konto. Etter autorisasjon bør du bli presentert med hjemmets tidslinje som representerer de siste tweets fra kontoene du følger. Test tweeting, retweeting og svar, samt sørge for at tidslinjen din oppdateres automatisk på ditt valgte intervall.
I denne opplæringsserien har vi opprettet en grunnleggende Twitter-klient for Android. Det er mange måter du kan forbedre og forbedre på appen, som for eksempel muligheten til å vise direkte meldinger eller vise brukerprofiler i appen, i stedet for å måtte bruke nettleseren. Du kan også gjøre omtale av brukere innen tweets clickable (dvs. å koble til en tekst String foran "@" til profilsiden for den brukeren). En lignende prosess vil tillate deg å støtte hashtags. Mer avanserte Twitter-klienter viser også samtaler når du velger en individuell tweet, som viser svar i kronologisk rekkefølge.
Når det gjelder implementering av programmet, er det også forbedringer du kan vurdere. For eksempel, hvis brukeren har lav tilkobling, kan du implementere nedlasting av profilbildene som en bakgrunnsprosess. Du kan også implementere en form for image caching for å maksimere effektiviteten. I stedet for at appen automatisk fornyer ListView med nye Tweets, kan du implementere en knapp øverst på tidslinjen, slik at brukerne kan styre skjermen, med knappen som angir hvor mange nye tweets som er tilgjengelige. Til slutt kan du forbedre effektiviteten ved å kjøre Tjenesten i en egen tråd.
Håper du har hatt glede av denne serien på å skape en Twitter-klient for Android-plattformen! I tillegg til å lære å koble appene dine til Twitter, har du nå erfaring med å bruke et eksternt bibliotek, pluss en rekke Android-plattformressurser som databaser, adaptere, tjenester og kringkastinger. Dette er alle viktige ferdigheter dine fremtidige Android-prosjekter vil dra nytte av. Den nedlastbare kildekoden inneholder flere notater du kan finne nyttige.
