Nella parte 3, abbiamo continuato questa serie spiegando come aggiungere un contatto nuovo di zecca. Abbiamo anche discusso su come usare l'API Java di Android per accedere e manipolare i contatti in un dispositivo Android. Questo tutorial è l'ultimo capitolo della serie e in esso spiegheremo come eliminare e salvare un contatto utilizzando l'API Java di Android. Descriveremo anche l'ambiente di sviluppo per l'applicazione, discuteremo i file di configurazione per il progetto e forniremo i singoli passaggi per importare il progetto nell'IDE di Eclipse.
Scrivi operazioni per i contatti
Vedremo ora le operazioni di scrittura relative a un contatto. Quelli sono operazione di cancellazione e operazione di salvataggio.
Eliminazione di un contatto
Il seguente metodo in ContactUtility la classe è responsabile dell'eliminazione di un contatto.
pubblico static void deleteContact (String id, ContentResolver contentResolver, String accountType) HashMap contacts = getUsersFromAccount (accountType, contentResolver); String existingContactId = contacts.get (id); if (existingContactId == null) // Il contatto non appartiene al ritorno dell'account; deleteContactInternal (id, contentResolver);
Come accennato in precedenza, non è consentito eliminare o modificare un contatto in questa applicazione di esercitazione a meno che non sia stato creato dall'applicazione stessa. (Questo è semplicemente per evitare danni accidentali a un contatto in un dispositivo reale, dato che si tratta semplicemente di un'applicazione tutorial.) Per rilevare se un contatto è stato creato da questa applicazione, è sufficiente verificare se il contatto appartiene al account con il tipo di account specifico per questa applicazione. Il deleteContact () il metodo sopra prima esegue un metodo chiamato getUsersFromAccount () che restituisce un elenco di tutti gli ID dei contatti per un determinato tipo di account. Se l'ID del contatto richiesto per l'eliminazione è in quell'elenco allora deleteContactInternal () il metodo viene chiamato per eliminare effettivamente il contatto. Altrimenti, deleteContact () il metodo ritorna senza eliminare il contatto.
Il ContactUtility.getUsersFromAccount () il metodo è elencato di seguito. Utilizza la tabella, dove i nomi delle clausole e delle colonne nella query "Contatti associati a un account" sopra.
importare java.util.HashMap ;? HashMap statico privato getUsersFromAccount (String accountType, ContentResolver contentResolver) Cursore cursor = contentResolver.query (ContactsContract.RawContacts.CONTENT_URI, null, ContactsContract.RawContacts.ACCOUNT_TYPE + "=?", new String [] accountType, null); HashMap map = new HashMap(); if (cursor.getCount ()> 0) while (cursor.moveToNext ()) String contactId = cursor.getString (cursor.getColumnIndex (ContactsContract.RawContacts.CONTACT_ID)); map.put (contactId, contactId); restituisce la mappa;
Il ContactUtility.deleteContactInternal () il metodo è elencato di seguito.
L'eliminazione di un contatto dal database consiste in questi passaggi.
Per prima cosa, interrogare il database per ottenere il record del contatto usando ContactsContract.Contacts.CONTENT_URI come la rappresentazione basata sulla URI della tabella.
utilizzando ContactsContract.Contacts.LOOKUP_KEY come descrittore di colonne, ottenere la "chiave di ricerca" per il contatto. Questo è un identificatore univoco da utilizzare per eliminare il contatto.
Costruisci a android.net.Uri oggetto che costruisce una rappresentazione basata su URI dell'identificatore univoco del contatto.
Chiamata ContentResolver.delete () metodo con il Uri rappresentazione del contatto per eliminarlo.
Salvataggio di un contatto
Il salvataggio di un contatto avviene in due scenari. Il contatto potrebbe essere esistente nel database o potrebbe essere un nuovo contatto per cui i record associati devono essere inseriti da zero.
Per salvare un contatto esistente, è possibile utilizzare strategie diverse. Ad esempio, i record esistenti possono essere aggiornati in base all'ID di riga di tali record. In questa applicazione tutorial, per semplicità, abbiamo deciso di salvare un contatto esistente eliminandolo e inserendolo nuovamente come nuovo contatto. Questo è un approccio semplice perché utilizza i metodi già scritti per eliminare un contatto esistente e salvare un contatto nuovo di zecca. Codice aggiuntivo con operazioni di 'aggiornamento' non necessarie.
Il ContactUtility.saveOrUpdateContact () il metodo è elencato di seguito. Viene utilizzato sia per i contatti nuovi che esistenti.
pubblico static void saveOrUpdateContact (Contatto di contatto, ContentResolver contentResolver, String accountName, String accountType) if (contact == null || accountName == null || accountType == null) return; String id = contact.getContactId (); if (! "". equals (replaceNull (id))) // Questo è un contatto esistente per aggiornare HashMap contacts = getUsersFromAccount (accountType, contentResolver); String existingContactId = contacts.get (id); if (existingContactId == null) // Questo è associato a un altro account - non può elaborare il reso; deleteContactInternal (id, contentResolver); saveContact (contact, contentResolver, accountName, accountType);
Ci sono vari controlli di integrità, per evitare oggetti nulli o banali. Il replaceNull () metodo, elencato di seguito, converte una stringa nulla in una stringa vuota e fa parte di quei controlli di integrità.
Se l'id non è una stringa vuota, deve corrispondere a un contatto esistente nel database. In tal caso, controlliamo se appartiene all'account associato a questa applicazione. (Il getUsersFromAccount () metodo è stato rivisto in precedenza.) In caso contrario, il contatto non dovrebbe essere modificato e il metodo ritorna senza alcuna modifica sull'account.
Se il contatto appartiene all'account associato a questa applicazione, viene eliminato.
Finalmente, saveContact () il metodo è chiamato per salvare il contatto.
public static String replaceNull (String in) if (in == null) return ""; else return in;
Il ContactUtility.saveContact () il metodo è elencato di seguito. Definisce una lista di android.content.ContentProviderOperation istanze per l'inserimento di singoli record e quindi chiamate ContentResolver.applyBatch () per eseguire tutte quelle operazioni contemporaneamente.
La prima operazione associa il record di contatto appena creato con il nome dell'account e il tipo di account per questa applicazione. Ricorda che il nome dell'account è stato specificato dall'utente quando l'account è stato creato per la prima volta e il tipo di account è la costante com.jquerymobile.demo.contact.
Il metodo ContentProviderOperation.newInsert () restituisce un'istanza di android.content.ContentProviderOperation.Builder classe, che viene in genere utilizzata per definire i valori dei parametri per ContentProviderOperation oggetto. (Vedi i seguenti riferimenti per ContentProviderOperation e Costruttore.) Il Builder.withValue () operazione restituisce la stessa istanza di Costruttore permettendoci di passare in modo ricorsivo i valori delle colonne per il record inserito.
Il withValueBackReference (ContactsContract.Data.RAW_CONTACT_ID, 0) la clausola consente il collegamento di ciascun record di inserimento con il primo record di inserimento in cui è inserito il record di contatto 'root'.
Dopo il primo record di inserimento, vengono registrati record di inserimento aggiuntivi per nome e cognome, nota, indirizzi, organizzazioni, e-mail, messaggi istantanei e telefoni del contatto.
Finalmente, ContentResolver.applyBatch () viene chiamato per eseguire le operazioni di inserimento batch rispetto al database.
Il nome del pacchetto per la nostra applicazione è com.jquerymobile.demo.contact, che è specificato nel livello superiore manifesto elemento. Le dichiarazioni .authentication.AuthenticationService e .ContactsActivity sono relativi al nome del pacchetto.
Elenchiamo i tipi di permessi richiesti dall'applicazione tramite usa-permessi elementi.
Avevamo discusso il servizio elemento in 'Crea account', parte 2 di questo tutorial.
strings.xml
Contatti
Il strings.xml memorizza stringhe costanti utilizzate nell'applicazione. L'unica costante che usiamo è il nome dell'applicazione elemento che è il nome dell'applicazione. Il valore di tale costante, "Contatti", viene visualizzato in vari punti del dispositivo Android, come mostrato nella figura seguente: schermata di avvio delle applicazioni (a sinistra), schermata iniziale (al centro) e schermata delle applicazioni di gestione (a destra).
Figura 17. Nome dell'applicazione.
Icona di avvio dell'applicazione
Le icone di avvio dell'applicazione sono basate sugli elementi della GUI di Android in http://www.matcheck.cz/androidguipsd/. Per le Linee guida per la progettazione di icone Android, sono stati creati tre file di icone come descritto di seguito.
Nome della cartella
Nome del file
Dimensione del pixel
res \ drawable-ldpi
icon.png
36 x 36
res \ drawable-MDPI
icon.png
48 x 48
res \ drawable-hdpi
icon.png
72 x 72
Quelle icone sono mostrate nella figura sotto. L'icona a sinistra è 36x36 pixel, quella al centro è 48x48 pixel e quella a destra è 72x72 pixel.
Figura 18. Avvia icone.
Ambiente di sviluppo dell'applicazione Android nativo
Ora discuteremo come importare l'applicazione nativa nell'ambiente di sviluppo Eclipse. I file di progetto sono stati testati contro:
Revisione dell'SDK per Android 8.
Eclipse IDE versione 3.5
Android Development Tools (ADT), che è un plugin Eclipse, versione 8.0.1.
Il progetto è stato testato con successo contro la piattaforma Android 2.2 API livello 8.
Importare il progetto
Prima di importare il progetto nel tuo ambiente Eclipse, assicurati che il plug-in di Eclipse ADT indichi la posizione corretta di Android SDK nel tuo sistema locale. Per verificare questo, nel menu Eclipse vai a Finestra -> Preferenze -> Android. Il Posizione SDK la finestra deve essere impostata sulla posizione di Android SDK. Una volta impostato correttamente, dovresti vedere qualcosa di simile a sotto
Figura 19. Preferenze di Eclipse.
I file di progetto sono forniti in un file di archivio chiamato contacts.zip. Per importare il progetto, nel menu Eclipse vai a File -> Importa e quindi nel wizard di importazione dei file selezionare Generale -> Progetti esistenti nello spazio di lavoro (vedi sotto).
Figura 20. Importazione del progetto.
Nella pagina successiva della procedura guidata, scegliere Seleziona il file di archivio: e vai a dove contacts.zip si trova nel tuo file system. Il progetti finestra verrà popolata automaticamente dove il ContactsDemo progetto è già selezionato. Questo è mostrato sotto. premi il finire pulsante per completare l'importazione.
Figura 21. Selezione del file di progetto.
Eclipse costruirà l'applicazione automaticamente dopo l'importazione. Ora, dovresti vedere il progetto ContactsDemo in Project Explorer, come mostrato di seguito.
Figura 22. Project Explorer.
Questo progetto è stato costruito e testato per la piattaforma Android OS 2.2. Per verificare ciò, selezionare il ContactsDemo progetto in Project Explorer e dal menu di scelta rapida scegli Proprietà. Nell'elenco a sinistra delle proprietà, selezionare androide come la proprietà. I target di build disponibili sono visualizzati a destra, come mostrato di seguito. Dovresti vedere che Android 2.2 è stato selezionato.
Figura 23. Android Build Target.
Elenco dei file
Di seguito è riportato un elenco di file nel progetto.
Figura 24. Elenco dei file.
Il src la cartella memorizza il codice Java. Ci sono due pacchetti:
Il com.jquerymobile.demo.contact il pacchetto contiene Indirizzo, Contatto, ContactDisplay, ContactGroup, ContactsActivity, ContactUtility, E-mail, Sono, Nota, Organizzazione e Telefono classi.
Il com.jquerymobile.demo.contact.authentication il pacchetto contiene il AuthenticationService classe.
Il gen la cartella contiene vari file generati automaticamente da Eclipse ADT.
Il risorse la cartella archivia i file HTML, i file di immagine utilizzati in quei file HTML e nelle librerie jQuery Mobile / jQuery. Usiamo jQuery Mobile versione 1.0 Alpha 3, che era l'ultima versione quando è stato scritto il tutorial. (Una versione di Alpha 4 è stata recentemente realizzata con varie correzioni di bug. Vedi l'annuncio.)
Il lib cartella memorizza le librerie Jackson JSON.
Il res la cartella memorizza le varie risorse necessarie all'applicazione. Quelle sono le immagini delle icone e i file di configurazione strings.xml e authenticator.xml.
default.properties è un file generato dal sistema che definisce la versione dell'API per l'applicazione Android.
Il proguard.cfg il file viene creato automaticamente dall'ambiente di sviluppo e viene utilizzato dallo strumento ProGuard. Dettagli possono essere trovati in Documentazione ProGuard.
conclusioni
In questo tutorial, abbiamo implementato un'applicazione Android in cui l'interfaccia utente è costruita tramite HTML / JavaScript e la funzionalità core nativa viene sviluppata tramite Java. Un vantaggio di tale approccio è il fatto che gli sviluppatori web, già in possesso di familiarità con HTML e JavaScript, possono utilizzare le loro conoscenze per costruire l'interfaccia utente senza dover imparare API specifiche di Android, il modello di gestione degli eventi dell'interfaccia utente e il linguaggio di programmazione Java. D'altra parte, gli sviluppatori con competenze Java possono concentrarsi sulla creazione della funzionalità nativa utilizzando l'API Java di Android. In questo modo, lo sforzo di lavoro può essere suddiviso tra due o più sviluppatori sulla base di set di competenze esistenti.
Una tipica considerazione di progettazione per un'applicazione Android è che gli aspetti visivi e il modello di gestione degli eventi dell'interfaccia utente devono essere coerenti tra i vari dispositivi su cui verrà installata l'applicazione. Questi dispositivi possono avere dimensioni dello schermo diverse e possono eseguire diversi set di browser Web con diversi livelli di supporto HTML. A tale proposito, jQuery Mobile è utile perché fornisce componenti dell'interfaccia utente prontamente disponibili con un modello di gestione degli eventi di supporto. È già stato testato per coerenza tra diversi dispositivi e browser, rendendo più facile lo sviluppo multipiattaforma.
Infine, tieni presente che alcune applicazioni non si adattano al modello precedente. Per esempio:
Alcune applicazioni richiedono componenti UI sofisticati, ad es. animazioni complesse, che potrebbero non essere fattibili per costruire usando pagine HTML.
Si può usare un framework applicativo basato sul web, come PhoneGap, per accedere alle funzionalità native tramite un'API JavaScript semplificata, se l'API è sufficiente per soddisfare i requisiti aziendali. In questo caso, l'interfaccia utente può ancora essere costruita con jQuery Mobile, tuttavia, potrebbe non essere necessario sviluppare codice back-end Java.
Share
Accentsconagua
