Share
În această serie construim un client Twitter pentru platforma Android folosind biblioteca Twitter4J. Acest tutorial va crea o bază de date SQLite pentru stocarea liniei cronologice a utilizatorului. De asemenea, vom mapa datele din baza de date către vizitele pe care le-am creat ultima oară folosind un adaptor, astfel încât utilizatorul să poată vedea actualizările.
În primele două tutoriale am setat proiectul în Eclipse, am înregistrat aplicația cu Twitter, am importat fișierul JAR Twitter4J și am construit interfața cu utilizatorul. De asemenea, am gestionat conectarea utilizatorilor la conturile lor Twitter și autorizarea aplicației pentru a accesa tweets-urile lor.
Acest tutorial va crea o bază de date SQLite pentru stocarea liniei cronologice a utilizatorului. De asemenea, vom mapa datele din baza de date către vizitele pe care le-am creat ultima oară folosind un adaptor, astfel încât utilizatorul să poată vedea actualizările.
Să mergem direct și să creăm baza de date cronologică folosind SQLite. Creați o nouă clasă în proiectul dvs. selectând-o în Pachetul Explorer, selectând File, New then Class. Introduceți "NiceDataHelper" ca nume de clasă. Deschideți noul fișier de clasă și extindeți declarația după cum urmează:
clasa publica NiceDataHelper extinde SQLiteOpenHelper
Aceasta este o clasă de ajutor de baze de date pentru sistemul SQLite. În această clasă vom crea și gestiona baza de date pentru tweets cronologie acasă.
Adăugați următoarele declarații de import în partea de sus a clasei:
importați android.content.Context; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.provider.BaseColumns; import șiroid.util.Log;
Aceste importuri sunt pentru procesarea bazelor de date de bază și pentru înregistrarea erorilor, plus contextul aplicației pentru referințe generale.
Baza de date va conține un singur tabel pentru actualizările tweet. Acest tabel va include următoarele coloane pentru fiecare tweet: ID-ul statusului Twitter; textul tweet; numele de ecran al tweeter-ului; momentul în care a fost trimis mesajul tweet; adresa URL a imaginii profilului tweeter-ului.
Începeți prin crearea unor constante în clasă:
/ ** db versiune * / privat static final int DATABASE_VERSION = 1; / ** numele bazei de date * / static final final String DATABASE_NAME = "home.db"; / ** Coloana ID * / statică finală privată String HOME_COL = BaseColumns._ID; / ** tweet text * / String final static privat UPDATE_COL = "update_text"; / ** nume de ecran twitter * / String final static privat USER_COL = "user_screen"; / ** timpul tweeted * / final static final String TIME_COL = "update_time"; / ** imaginea profilului utilizatorului * / final static final String USER_IMG = "user_img";
Aceste variabile constante includ numele versiunii bazei de date, pe care ar trebui să îl modificați dacă doriți să actualizați baza de date în viitoarele dezvoltări ale aplicației dvs. Variabilele includ, de asemenea, numele bazei de date și numele pentru coloane. Clasa BaseColumns ne ajută să atribuim o coloană unică ID utilizând sufixul "_id".
Construiți în continuare tabela de creație SQLite String pentru tabela de domiciliu:
Accentsconagua
/ ** Codul de creare a bazei de date * / String final static privat DATABASE_CREATE = "CREATE TABLE acasă (" + HOME_COL + "INTEGER NOT NULL KEY PRIMARY," + UPDATE_COL + "TEXT," + USER_COL + "TEXT," + TIME_COL + "INTEGER , "+ USER_IMG +" TEXT); "; Creați metoda constructorului pentru clasa dvs. de bază de date helper:
/ ** * Metoda constructorului * @ context parament * / NiceDataHelper (Context context) super (context, DATABASE_NAME, null, DATABASE_VERSION);
Constructorul numește pur și simplu metoda superclass. Apoi adăugați metoda "onCreate" în care vom executa crearea tabelei bazei de date:
/ * * onCreate execută șir de creare a bazei de date * / @Override public void onCreate (SQLiteDatabase db) db.execSQL (DATABASE_CREATE);
Aici execlam pur și simplu crearea bazei de date SQL String. La sfârșitul metodei, tabelul va fi creat.
Pentru a finaliza pregătirea bazei de date, implementați metoda "onUpgrade" în cazul în care decideți să modificați baza de date în viitor:
/ * * onUpgrade creează tabela de domiciliu și execută șirul de creare * / @Override public void onUpgrade (SQLiteDatabase db, int oldVersion, int newVersion) db.execSQL ("DROP TABLE IF EXISTS acasă"); db.execSQL ( "vidate"); onCreate (db); Aceasta vă permite să vă actualizați baza de date modificând numărul versiunii și crearea String sau oricare dintre coloane.
Vom adăuga acum o metodă finală la clasa helper de baze de date. Această metodă va reveni la valori din cele mai recente actualizări ale statusului Twitter și va fi apelată din clasa Service pe care o creăm în următorul tutorial. Adăugați schița metodei după cum urmează:
/ ** * getValues preia înregistrările bazei de date * - apelat din TimelineUpdater în TimelineService * - aceasta este o metodă statică care poate fi apelată fără o instanță a clasei * * @param status * @return ContentValues result * / static public ContentValues getValues Starea statutului) // pregăti conținuturi pentru a reveni la ContentValues homeValues = new ContentValues (); // a obține valorile // returnează valorile returnate homeValues;
În cadrul acestei metode, vom transforma obiectul Status transmis într-un set de ContentValues. Clasa Status face parte din biblioteca Twitter4J, modelând o actualizare de stare unică sau tweet. Când serviciul de aplicații preia linia temporală a utilizatorului, acesta va trece fiecare dintre actualizările de stare din acesta la metoda "getValues". Această metodă va prelua informațiile din tweet-ul pe care dorim să-l stocăm în baza de date, adică ID-ul, textul, numele de utilizator, ora și adresa URL a imaginii profilului. Metoda va pune fiecare dintre acestea într-un set de ContentValues pe care apoi le va reveni. Serviciul va încerca apoi să scrie datele în ContentValues în baza de date, actualizând-o cu tweets nou preluate.
Vom implementa majoritatea acestui proces atunci când vom crea Serviciul în următorul tutorial. Pentru moment, tot ce trebuie să facem este să furnizăm corpul metodei "getValues". Înainte de linia în care sunt returnate valorile, adăugați următoarele:
încercați // obțineți fiecare valoare din tabelul homeValues.put (HOME_COL, status.getId ()); homeValues.put (UPDATE_COL, status.getText ()); homeValues.put (USER_COL, status.getUser (); getScreenName ()); homeValues.put (TIME_COL, status.getCreatedAt (); getTime ()); homeValues.put (USER_IMG, status.getUser (), getProfileImageURL (), toString ()); captură (Excepție te) Log.e ("NiceDataHelper", te.getMessage ()); Procesul poate provoca excepții, deci încercați și blocați blocurile. Observați că metoda încearcă să recupereze fiecare element al actualizării de stare pe care am proiectat-o pentru a stoca baza de date utilizând metodele Twitter4J. Veți avea nevoie de alte două importuri adăugate la clasă:
import twitter4j.Status; import șiroid.content.ContentValues;
Vom folosi o clasă Adaptor pentru a mapa datele tweet în interfața cu utilizatorul Vizualizări create în ultimul tutorial. ListView pe care am creat-o în fișierul de aspect XML al cronologiei va afișa noile actualizări de tweet-uri în momentul în care acestea vor deveni disponibile. Fiecare actualizare tweet va fi afișată în cadrul layout-ului de actualizare XML pe care l-am definit de asemenea. Dacă vă uitați înapoi la "res / layout / update.xml" veți vedea că există secțiuni pentru afișarea tuturor elementelor de date pe care le stocăm în bază de date, adică imaginea profilului utilizatorului și numele ecranului, tweet-ul și timpul a fost tweeted.
Clasa Adaptor va mapa datele de tweet de actualizare la aceste interfețe de utilizator Vizualizați elementele. Mai degrabă decât de a implementa manual acest lucru, clasa "SimpleCursorAdapter" ne permite să automatizeze o parte a procesului, să cartografiem date către Vizualizări, permițându-ne în același timp să adaptăm acest proces de cartografiere pentru a satisface nevoile aplicației.
Creați o nouă clasă în aplicația dvs., numind-o "UpdateAdapter". Extindeți declarația de clasă după cum urmează:
public class UpdateAdapter extinde SimpleCursorAdapter
Importați clasa părinte și clasa de jurnal după cum urmează:
import android.widget.SimpleCursorAdapter; import șiroid.util.Log;
Adăugați variabile de instanță după cum urmează:
/ ** twitter dezvoltator cheie * / public final static String TWIT_KEY = "cheia ta"; // alter / ** twitter dezvoltator secret * / public final static String TWIT_SECRET = "secretul tău"; // alter / ** șiruri de caractere reprezentând baza de date nume de coloane care să fie afișate în vizualizări * / String final static [] din = "update_text", "user_screen", "update_time", "user_img"; / ** vizualizarea ID-urilor de elemente pentru maparea valorilor înregistrare a bazei de date la * / static final int [] la = R.id.updateText, R.id.userScreen, R.id.updateTime, R.id.userImg; fișierul privat LOG_TAG = "UpdateAdapter";
Modificați dezvoltatorul de chei Twitter și Secret pentru a reflecta propriul dvs., așa cum ați folosit în clasa principală a activității aplicației din ultimul tutorial. Matricea "din" reprezintă numele fiecărei coloane de tabelă de bază de date care este mapată. Matricea "la" reprezintă ID-urile vizualizărilor pe care vor fi mapate elementele "de la". ID-urile au fost incluse în layout-urile XML pe care le-am creat în ultimul tutorial.
În clasa Adaptor, adăugați o metodă constructor după cum urmează:
/ ** * constructor stabilește adaptor, trecând 'de la' date și 'la' vizualizări * @ param context * @param c * / public UpdateAdapter (Context context, Cursor c) super (context, R.layout.update, c , de la catre);
Acest cod numește constructorul superclass, trecând Contextul aplicației, elementul Vizualizare în care vor fi afișate datele, Cursorul pentru traversarea datelor și matricele "de la" și "la" pe care le-am creat ca variabile de instanță. Veți avea nevoie de următoarele declarații de import pentru acest cod:
importați android.content.Context; import android.database.Cursor;
Aceasta realizează partea centrală a procesului de mapare, adică afișarea datelor în vizualizările specificate. Cu toate acestea, dorim, de asemenea, să adaptăm comportamentul și aspectul elementelor interfeței utilizator rezultate. Vom adapta procedura de mapare pentru a prelua imaginea de profil pentru fiecare tweet și pentru a formata timpul de actualizare. În ultimul tutorial al seriei vom extinde, de asemenea, acest cod pentru a seta ascultătorii de clic pentru butonul retweet, butonul de răspuns și numele de utilizator Twitter pentru fiecare tweet.
Implementați metoda "bindView" în clasa Adaptor folosind următoarea schiță:
/ * * Legarea datelor în vizualizările vizibile * / @Override public void bindView (Vizualizare rând, Context context, Cursor cursor) super.bindView (rând, context, cursor);
Aici pur și simplu sunăm metoda superclass. Metoda "bindView" ne permite să specificăm procesarea suplimentară pentru momentul în care datele sunt mapate în vizualizări. În primul rând, să încercăm să descărcăm imaginea de profil pentru tweet-ul curent de actualizare:
încercați // obțineți adresa URL a profilului profilURL = noua adresă URL (cursor.getString (cursor.getColumnIndex ("user_img"))); // setați imaginea în vizualizare pentru tweet-ul curent ImageView profPic = (ImageView) row.findViewById (R.id.userImg); profPic.setImageDrawable (Drawable.createFromStream ((InputStream) profilURL.getContent (), "")); captură (Excepție te) Log.e (LOG_TAG, te.getMessage ()); Avem nevoie de încercarea și blocarea blocurilor deoarece încercăm să încărcăm o resursă externă. Metoda primește adresa URL a imaginii profilului așa cum este stocată în coloana bazei de date. Apoi, metoda face o trimitere la elementul Vizualizare pentru a afișa imaginea, utilizând atributul său de identitate, așa cum am stabilit în fișierul de aspect XML de actualizare. În cele din urmă, codul prelucrează imaginea ca un InputStream, importându-l ca fiind Drawable și setând-o ca imagine în cadrul ImageView. Veți avea nevoie de următoarele importuri:
import java.io.InputStream; import java.net.URL; import șiroid.graphics.drawable.Drawable; import șiroid.view.View; importă android.widget.ImageView;
Acum, să modificăm afișarea timpului de actualizare, deoarece acesta va fi stocat în bază de date ca număr. Pentru a le converti într-un timp relativ lizibil de om, adăugați următorul cod după blocul de captură:
// obțineți timpul de actualizare lung creatAt = cursor.getLong (cursor.getColumnIndex ("update_time")); // obțineți vizualizarea timpului de actualizare TextView textCreatedAt = (TextView) row.findViewById (R.id.updateTime); // ajustați modul în care este afișat ora pentru a putea fi citit de oameni textCreatedAt.setText (DateUtils.getRelativeTimeSpanString (createdAt) + ""); Mai întâi vom prelua valoarea coloanei ca o lungime, apoi obțineți o referință la elementul Vizualizare pentru ao afișa ca parte a XML-ului de actualizare. În cele din urmă, îl formăm ca pe o coardă, astfel încât utilizatorul să poată vedea când tweet-ul a fost trimis în raport cu momentul prezent. Veți avea nevoie de următoarele declarații de import suplimentare:
import șiroid.text.format.DateUtils; import șiroid.widget.TextView;
Înapoi în clasa de activitate principală a aplicației "TwitNiceActivity", să punem acum în aplicare metoda "setupTimeline". În tutorialul următor vom adăuga procesarea serviciului la metodă, dar deocamdată să procedăm la pornirea bazei de date și a Adaptorului. Înainte de a începe metoda, adăugați următoarele variabile de instanță în partea de sus a clasei:
/ ** vizualizarea principală pentru cronologia de acasă * / private ListView homeTimeline; / ** baza de date ajutor pentru actualizarea datelor * / private NiceDataHelper timelineHelper; / ** actualizare baza de date * / privat SQLiteDatabase timelineDB; / ** Cursor pentru manipularea datelor * / Cursor privat CursorCursor; / ** Adaptor pentru cartografiere de date * / UpdateAdapter privat calendar Adapter;
Vom folosi aceste variabile atunci când construim cronologia. Adăugați următoarele pentru a specifica dimensiunea implicită pentru afișarea imaginii profilului:
ProfileImage.ImageSize imageSize = ProfilImage.NORMAL;
Va trebui să adăugați următoarele importuri:
import twitter4j.ProfileImage; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; importă android.widget.ListView; importă android.widget.LinearLayout;
Acum pentru a seta cronologia în sus. Dacă ați creat schița metodei "setupTimeline" pentru testarea ultima dată, puteți adăuga pur și simplu corpul metodei următor. Dacă nu, creați acum schița metodei:
/ ** * setupTimeline afișează principala pagină de pornire Twitter a utilizatorului * / private void setupTimeline () // method body
Este posibil să vă amintiți din ultima oară că această metodă este apelată atunci când utilizatorul a autorizat deja aplicația să utilizeze contul de Twitter. În cadrul metodei vom instanțializa clasa Helper de baze de date, vom prelua o bază de date lizibilă, vom instanța clasa Adaptor și vom seta să grupeze datele în Vizualizări. Începeți prin setarea conținutului cronologie Vizualizare:
setContentView (R.layout.timeline);
Unele dintre metodele pe care le vom folosi pot arunca excepții, deci adăugați și încercați și blocați:
încercați // obțineți cronologia captură (Excepție te) Log.e (LOG_TAG, "Nu a putut fi preluată cronologia:" + te.getMessage ());
Vom adăuga următoarele fragmente de cod în blocul de încercare. Aici vom instanțiza variabilele pe care le-am declarat în partea de sus a clasei. Mai întâi primiți o referință la ListView din layout-ul cronologiei, în care va apărea actualizarea Views:
// obțineți o referință la vizualizarea listă homeTimeline = (ListView) findViewById (R.id.homeList);
Apoi creați o instanță a clasei Helper de baze de date și o utilizați pentru a prelua o bază de date lizibilă:
// instanțiate baza de date helper timelineHelper = new NiceDataHelper (this); // a obține cronologia bazei de dateDB = timelineHelper.getReadableDatabase ();
Prima linie creează aici o instanță a clasei Helper de baze de date pe care am definit-o, în timp ce cea de-a doua recuperează de fapt baza de date. Acum, să analizăm baza de date și să dobândim un Cursor pentru traversarea acestuia, trecând acest Cursor la clasa Adaptor:
// interogați baza de date, cele mai recente tweet-uri prima cronologieCursor = cronologieDB.query ("home", null, null, null, null, null, "update_time DESC"); // gestionați actualizările utilizând un cursor startManagingCursor (timelineCursor); // instanțiate adaptorul cronologieAdapter = noul UpdateAdapter (acest lucru, linia temporalăCursor); Interogarea bazei de date este pur și simplu preluarea de tot din tabel, ordonându-l cu cea mai recentă actualizare tweets primul. Trecem Cursorul la metoda constructorului din clasa Adaptor pe care am creat-o.
În acest tutorial am construit baza de date tweet timeline, am definit un Adaptor pentru afișarea datelor în cadrul interfeței noastre de utilizatori Vizualizează și folosește aceste clase în cadrul activității principale a aplicației noastre pentru a construi o cronologie vizibilă.
În următorul tutorial vom configura un serviciu și un receptor de transmisie pentru a prelua în permanență noi actualizări și a le afișa în cadrul cronologiei de acasă a utilizatorului. În momentul în care executați aplicația, nu veți vedea niciun fel de actualizări, deoarece nu am redus încă cronologia utilizatorului. Ca parte a clasei Service vom prelua cronologia utilizând metodele Twitter4J, sunând la intervale fixe pentru a prelua în mod repetat cele mai recente tweets din conturile pe care utilizatorul le urmează. Apoi vom scrie rezultatele în baza de date și le vom prezenta în afișarea cronologică.
