het ontwikkelen van uw eerste Android applicatie

het ontwikkelen van uw eerste Android applicatie

waarom geven we om Android? We geven om het Android-platform omdat het het meest verspreide mobiele platform op de planeet is en toegankelijk is voor consumenten over de hele wereld. In economieën waar het bezit van een personal computer een luxe is, is het gebruik van mobiele apparaten de norm–en Android speelt een belangrijke rol in het verbinden van mensen met elkaar. Zoals u zult leren in deze tutorial, Android neemt een duidelijke benadering van toepassingen. De architectuur van Android maakt een zeer aanpasbare software-omgeving dankzij de runtime binding van de gevraagde acties en de code om aan deze verzoeken te voldoen. Of het nu marktgedreven overwegingen of de technische aspecten van Android, het is een platform waard onderzoek. Verder, als u serieus overwegen om het hebben van een mobiele ervaring voor uw platform, je kunt Android niet negeren.

vereisten

deze handleiding vereist verschillende technologieën die samenwerken. Je hebt ze allemaal nodig voor deze tutorial.

• Android Studio-Android Studio is het primaire startpunt voor het maken van Android – toepassingen
• Android-apparaat of Emulator-u wilt een fysiek Android-apparaat, of de Android-Emulator. Hoe dan ook, het lezen door middel van deze tutorial zal u helpen bij het begrijpen van de fundamentele verbindingspunten van een Android-applicatie.

• broncode-broncodefragmenten in deze tutorial omvatten:

  • AndroidManifest.xml snippet-dit bestand is de toepassing deployment descriptor voor Android-toepassingen.
  • hoofdactiviteit.java-dit implementeert een Android-activiteit, het primaire toegangspunt tot de voorbeeldtoepassing van deze tutorial.
  • Activity_main.xml-dit bevat definities voor de visuele elementen, of middelen, voor gebruik door Android-activiteiten.
  • AndroidManifest.xml compleet-dit toont een volledige AndroidManfest.xml-bestand, samen met een beschrijving van elk van de belangrijke elementen.

introduceer de Android-architectuur

voordat u direct in de ins en outs van de Android Studio duikt en Android-applicaties ontwikkelt, laten we eens kijken naar de architectuur van Android en enkele van de belangrijkste termen die nuttig zullen zijn in de tutorial en verder, als u begint met het bouwen van Android-applicaties voor uzelf.

Android terminologie

een begrip van de onderstaande termen is nuttig bij de ontwikkeling van Android-applicaties met Android Studio.

• Android is een open source besturingsomgeving gericht op mobiele apparaten. In toenemende mate, Android is te vinden in toepassingen buiten “smartphones”. Deze omvatten draagbare technologie, apparaten zoals projectoren, Luidsprekers en televisies, en zelfs auto ‘ s.
• Emulator is een softwaretool die representatief is voor een ander systeem. Vaak is een emulator een omgeving die draait op een personal computer (PC, Mac, Linux machine) die een andere omgeving emuleert, zoals een mobiel computerapparaat.
• Linux is een open source besturingssysteem kernel in het hart van vele computerplatforms, waaronder servers, desktop computers, netwerkapparatuur, en mobiele-computer apparaten. Android draait op de top van een Linux kernel.
• Android Runtime (ART) is een besturingsomgeving die in de Android stack wordt gevonden, die programmacode uitvoert tijdens runtime. De Android Runtime vervangt de” legacy ” Dalvik Virtual Machine (VM) van eerdere versies van Android die op een manier vergelijkbaar met een compatibele Java VM werkte.

the intent

sinds de oprichting is Android een dominante kracht geworden in de mobiele telefoonruimte. Het toepassingsmodel is uniek omdat toepassingen niet monolithische, menu-beladen toepassingen zijn die veel klikken en tikken vereisen om te werken. Zeker, er zijn menu ‘ s en knoppen te tikken, maar Android heeft een innovatief ontwerpelement aan de architectuur bekend als een intentie.

een intent is een constructie die een toepassing toestaat om een verzoek uit te geven, wat enigszins lijkt op een Help-wanted teken. Misschien ziet het er zo uit.:

• ” gezocht: Een toepassing om mij te helpen een contact op te zoeken”
• “gevraagd: een toepassing om mij te helpen deze afbeelding weer te geven”
• “gevraagd: een toepassing om deze geografische zoekopdracht uit te voeren.”

op een vergelijkbare en complementaire manier kunnen applicaties zich registreren als capabel en geïnteresseerd in het voldoen aan verschillende verzoeken of intenties. Om het geclassificeerde advertentieparadigma te volgen, kunnen deze er zo uitzien:

• “Beschikbaar: applicatie klaar en bereid om contactgegevens op een duidelijke, beknopte manier te presenteren”
• ” beschikbaar: Applicatie klaar en bereid om een geografische zoekopdracht uit te voeren.”

dit zijn voorbeelden van IntentFilters, die hierna worden besproken.

de IntentFilter

toepassingen kondigen hun beschikbaarheid aan om dit soort bewerkingen uit te voeren via een constructie die bekend staat als een IntentFilter . Het IntentFilter wordt tijdens runtime geregistreerd of wordt opgesomd in het AndroidManifest.xml-bestand. Het volgende fragment komt van een Android-applicatie die reageert op inkomende SMS (tekst) berichten:

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

IntentFilter, introduceert de volgende sectie De vier hoofdtypen van Android-toepassingen.

typen Android-toepassingen

laten we een moment nemen om de vier belangrijkste typen Android-toepassingen te onderzoeken:

• activiteit
• Service
• ontvanger
• ContentProvider

we zullen ook de weergaven bekijken om de gebruikersinterface (UI) elementen weer te geven.

Activity apps

de activiteit is de meest zichtbare en prominente vorm van een Android-applicatie. Een activiteit presenteert de UI aan een toepassing, samen met de hulp van een klasse bekend als een view. De view class wordt geïmplementeerd als Verschillende UI-elementen, zoals tekstvakken, labels, knoppen en andere UI ‘ s die typisch zijn voor computerplatforms, mobiele of otherwise.An de aanvraag kan één of meer activiteiten bevatten. Een activiteit wordt meestal gedefinieerd op een een-op-een relatie met de schermen in een toepassing.

een toepassing verplaatst zich van de ene activiteit naar de andere door een methode aan te roepen die bekend staat als startActivity() of startSubActivity(). De eerste methode wordt gebruikt wanneer de toepassing wil gewoon “overschakelen” naar de nieuwe activiteit. Dit laatste wordt gebruikt wanneer een synchrone call/response paradigma gewenst is. In beide gevallen wordt een intentie doorgegeven als argument voor de genoemde methode.

het is de verantwoordelijkheid van het besturingssysteem om de best gekwalificeerde activiteit te bepalen die voldoet aan de gespecificeerde Intentie.

Service-en ontvangerapps

net als andere multi-tasked computing-omgevingen zijn er toepassingen die “op de achtergrond” draaien en die verschillende taken uitvoeren. Android noemt dit soort toepassingen diensten. De service is een Android-applicatie die geen gebruikersinterface heeft.

de ontvanger is een applicatie-component die verzoeken ontvangt om intents te verwerken. Net als de service heeft een ontvanger in de normale praktijk geen UI-element. Ontvangers worden meestal geregistreerd in de AndroidManifest.xml-bestand.

het volgende fragment (dat hetzelfde is als het fragment dat getoond wordt voor IntentFilter) is een voorbeeld van een ontvangertoepassing die gedefinieerd wordt. Merk op dat de naam attribuut van de ontvanger is de Java klasse die verantwoordelijk is voor de implementatie van de ontvanger.

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

de ContentProvider is het Android-mechanisme voor data-store abstractie. Laten we eens kijken naar een specifiek type gegevens gevonden op een mobiel apparaat: het adresboek of contacten database. Het adresboek bevat alle contacten en telefoonnummers die een persoon nodig heeft bij het gebruik van een mobiele telefoon.

de ContentProvider is een mechanisme voor abstracte toegang tot een bepaalde gegevensopslag. In veel opzichten werkt de ContentProviderin de rol van een databaseserver. Bewerkingen voor het lezen en schrijven van inhoud naar een bepaalde gegevensopslag moeten worden doorgegeven via een geschikte ContentProvider, in plaats van rechtstreeks toegang te krijgen tot een bestand of database. Er kunnen zowel "clients" als "implementations" van de ContentProviderzijn.

Android-weergaven

Android-weergaven zijn het UI-mechanisme om dingen op het scherm van een Android-apparaat te zetten. De Android-activiteit gebruikt weergaven om UI-elementen weer te geven. Enkele van de meer populaire lay-out ontwerpen omvatten:

• Lineairverticaal – elk volgend element volgt zijn voorganger door onder het in een enkele kolom te stromen.
• Lineairhorizontaal – elk volgend element volgt zijn voorganger door in één rij naar rechts te stromen.
• tabel-een reeks rijen en kolommen, vergelijkbaar met een HTML-tabel. Elke cel kan één weergaveelement bevatten.
• beperking-elk element is “beperkt” tot een aspect van het scherm, zoals de bovenkant of zijkant van het scherm of een ander element. Deze lay-out helpt bij de bouw van “responsieve” applicaties en is de erfgenaam-ogenschijnlijk aan de legacy relatieve lay-out geïntroduceerd in eerdere versies van het Android-platform.

nadat een bepaalde opmaak (of combinatie van opmaak) is geselecteerd, worden afzonderlijke weergaven gebruikt om de gebruikersinterface te definiëren.

Weergaveelementen bestaan uit bekende UI-elementen, waaronder:

• Button
• ImageView
• EditText om invoer te verzamelen met verschillende filters zoals datum of numeriek
• TextView (vergelijkbaar met een label, geeft statische tekst weer)
• CheckBox
• radioknop
• Spinner (vergelijkbaar met een “drop-down” combo box)
• AutoComplete (EditText with auto text-complete feature)

weergaven worden gedefinieerd in een XML-bestand. Dit toont bijvoorbeeld een eenvoudige Linearverticale weergave, met knoppen en tekstviews gedefinieerd:

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent" ><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1!" /><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1, second text view!" /><Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Switch To Activity 2" /></LinearLayout>

https://developer.android.com/, en scroll naar beneden om Android Studio te downloaden. Android Studio is beschikbaar voor Windows, Mac en Linux.

Android Studio is gebaseerd op het IntelliJ IDE-platform. Als je het soort ontwikkelaar die is interessant in het gebruik van sneltoetsen, kunt u overwegen om meer te leren over IntelliJ van de JetBrains website.

aan de slag met de Android SDK

nu We Android Studio hebben geïnstalleerd, is het tijd om de Software Developer Kit (SDK) voor Android te krijgen.

maar voordat we verder gaan, moeten we een discussie hebben over Android-versies.

Android versies

sinds de oprichting is Android uitgebracht onder een enigszins parallel pad van numerieke release revisies, API levels, en ook “zoete” namen zoals Jelly Bean, KitKat, Oreo, en andere zoetwaren favorieten.

het is gemakkelijk om overweldigd te worden door de beschikbare keuzes. Voor nu moet je gewoon een beetje begrip van deze “versie landschap” aan de slag als een Android-Ontwikkelaar.

er zijn veel versies of revisies van Android in het wild. Als u een applicatie voor commerciële release gaat schrijven, moet u weten op welke apparaten u zich richt. Wikipedia heeft een mooie samenvatting van de Android-versies, de namen, de releasedata en een afbeelding van het Geschatte aantal van elk apparaat in de markt.

nieuwere apparaten draaien de nieuwste code, en oudere apparaten kunnen enigszins beperkt zijn in hun mogelijkheid om te upgraden naar een nieuwere versie van Android. Soms ondersteunen de nieuwere versies mogelijkheden die de oudere handsets niet kunnen ondersteunen (denk tweede camera, Near Field Communications, enzovoort). Een andere niet-triviale reden dat oudere handsets niet in staat zijn om de nieuwste Android-versie te draaien is dat zowel de fabrikant als de telecom carrier (Verizon, op&T, enzovoort) nodig hebben om de software die binnen hun ecosysteem. Het ondersteunen van een nieuw besturingssysteem vereist middelen van de kant van de fabrikant van het apparaat en de vervoerder. De marktkrachten suggereren dat deze marktdeelnemers zich meer bezighouden met toekomstige verkopen dan met het ondersteunen van eerdere verkopen en hun menselijk kapitaal dienovereenkomstig investeren.

als softwareontwikkelaar, wat maakt het uit dat er nieuwe versies van het besturingssysteem zijn? Dit valt uiteen in twee grote categorieën als het gaat om programmeertoepassingen:

• een nieuwe versie van het besturingssysteem introduceert vaak nieuwe functies waarvan we kunnen profiteren en/of onze gebruikers verwachten dat onze applicaties deze ondersteunen.
• oudere (of oudere) kenmerken van de omgeving kunnen in feite nieuwere functies belemmeren en/of een inferieure benadering zijn om een specifieke set functionaliteit aan te bieden. Soms code moet eigenlijk worden verwijderd uit de API definities. Er is een speciale term voor deze” verwijdering “van voorheen werkende code – we noemen het”code deprecation”. Wanneer een API is gemarkeerd voor verwijdering, we zeggen dat dit een verouderde API. Dit is in wezen een bericht aan de ontwikkelaar dat gaat iets als dit: “Waarschuwing” deze code zal worden verwijderd in de toekomst, gelieve dienovereenkomstig te plannen.”

het Android-platform is vrij liberaal (dat wil zeggen, gunstig voor de ontwikkelaar) met zijn aanpak van verouderde code door toepassingen toe te staan om verder te gaan met behulp van oudere API ‘ s voor een tijdje na te zijn gemarkeerd als verouderd. (Deze aanpak contrasteert met Apple ‘ s aanpak met verouderde code in iOS waar oudere code gewoon kan stoppen met werken aan de volgende OS release. Met iOS lijkt zelfs de programmeertaal te veranderen terwijl we niet kijken!)

hoewel Android misschien een beetje meer vergevingsgezind is met zijn lange lijden aan verouderde code, moeten we een oogje houden op de documentatie tag die zegt dat een bepaalde API is verouderd. Als sommige code die we gebruiken is gemarkeerd als verouderd, moeten we uiteindelijk onze aanpak in een toekomstige versie van onze applicatie te veranderen, omdat elke API die is gemarkeerd als verouderd kan worden verwijderd in een toekomstige release. Deprecation markers in de SDK zijn onze roadmap naar toekomstige kansen voor verbetering en voor potentiële hoofdpijn. Soms is de” nieuwe ” manier van doen eenvoudig en rechttoe rechtaan, maar niet in alle gevallen!

een succesvolle ontwikkelaar van mobiele applicaties zijn vereist een voortdurende investering gedurende de levensduur van een applicatie waar de tijd de neiging heeft om voorbij te gaan als hondenjaren … zeer snel!

met deze basisintro tot de versies van Android, is het tijd om de Android SDK te verkrijgen.

het verkrijgen en installeren van de Android SDK

Start Android Studio. Selecteer SDK Manager in het menu Extra. Deze menuoptie laadt het dialoogvenster Voorkeuren voor Android Studio en selecteert vooraf het submenu Android SDK. Dit menu is onze primaire manier van interactie met de verschillende SDK ‘ s beschikbaar voor de vele versies van Android.

bij elke release van het besturingssysteem wordt het API-niveau verhoogd. Merk op dat de revisie langzamer toeneemt dan het API-niveau. Je kunt de revisie zien als een” generatie “van het platform, of als een” groot ” versienummer. Wanneer u bladeren door de Android-documentatie, zorg ervoor dat u noteert welk API-niveau dat een bepaalde mogelijkheid werd geïntroduceerd. Elke API is beschikbaar op het API-niveau aangegeven en groter, tenzij de API is verouderd en vervolgens verwijderd. Bijvoorbeeld, de ContactsContract API werd geïntroduceerd op niveau 5, dat is vrij ” oud ” op dit punt.

selecteer een of twee SDK-niveaus om mee te werken. De SDK Manager zal vervolgens de gerelateerde bestanden downloaden en beschikbaar maken voor gebruik binnen Android Studio.

ook onder het menu Hulpmiddelen is een optie voor de Avd-Manager. AVD staat voor Android Virtual Device. Dit is de emulator. De emulator is nuttig omdat het ons in staat stelt om toepassingen te testen op verschillende soorten apparaten, maten en versies. De schermafbeeldingen in deze tutorial zijn genomen uit de emulator. Meer hierover later.

het bouwen van uw eerste Android-applicatie

deze tutorial stap je door het maken van een basis Android-applicatie, genaamd Say Something, met behulp van Android Studio en het demonstreren op de Android emulator.

haal de code

Stap 1: Maak een nieuw project aan

1. Selecteer bestand > nieuw Project.

2. vul het dialoogvenster Android-Project maken in en klik op Volgende.

   

   de vereisten voor het nieuwe project zijn::

   • toepassingsnaam
   • bedrijfsdomein (dit wordt teruggedraaid naar com.domein) om toepassingen gepartitioneerd te houden, zelfs als ze dezelfde naam hebben.
   • projectlocatie-waar de bestanden moeten worden opgeslagen
   • de pakketnaam wordt voorgesteld uit de naam van de toepassing en het bedrijfsdomein
   • standaard worden Android-toepassingen geschreven in Java. Als u alternatieve talen wilt ondersteunen, zoals C++ (voor native code) of Kotlin, schakelt u de juiste selectievakjes in.

3. op het doel Android-apparaten dialoogvenster, geef het API-niveau en doelplatforms. Zoals eerder vermeld, Android is voor meer dan alleen telefoons, maar voor onze doeleinden zullen we gewoon de telefoon en Tablet form factor voor deze tutorial te selecteren. Klik vervolgens op Volgende.

   

4. selecteer in het dialoogvenster Activiteit toevoegen aan mobiel het type lege activiteit. Klik vervolgens op Volgende.

   

   Hiermee wordt een standaardtoepassing gemaakt die direct vanuit Android Studio kan worden gebouwd en uitgevoerd.

5. geef in het dialoogvenster activiteit configureren de bestanden een naam voor de toepassing.

   

Stap 2: Bekijk de code

de volgende afbeelding toont de componenten van ons nieuwe project:

er zijn twee mappen: app en Gradle Scripts.

• de map app bevat alle code van onze toepassing.
• de map manifesteert in de map app bevat AndroidManifest.xml, de Deployment descriptor voor deze toepassing. Dit bestand vertelt het Android-apparaat over hoe om te communiceren met de applicatie, welke activiteit te laten zien wanneer de applicatie wordt gestart, die de applicatie services Intents, welke pictogrammen weer te geven en nog veel meer.
• de map java bevat de broncode voor de toepassing. In dit geval, het bestand dat onze activiteit implementeert plus een paar class-bestanden voor het uitvoeren van geautomatiseerde tests (die we zullen negeren voor deze tutorial).
• de map res bevat de Bronnen voor de toepassing, waaronder pictogrammen, opmaakbestanden, tekenreeksen, menu ‘ s, enzovoort.
• de map Gradle Scripts bevat alle scriptbare elementen voor het bouwen van de toepassing. Het Gradle build systeem is een onderwerp op zich. Voor nu, begrijpen dat deze scripts regelen het proces van het bouwen van de applicatie – en belangrijk voor meer volwassen projecten en teams, elk van deze stappen kan worden uitgevoerd vanaf de opdrachtregel. Dit is belangrijk omdat deze aanpak automatisering ondersteunt en in de categorie van continue integratie valt.

laten we nu de broncode nader onderzoeken.

primaire activiteit voor de aanvraag

onze voorbeeldaanvraag bestaat uit één enkele activiteit, genaamd hoofdactiviteit.

package com.navitend.saysomething;import android.content.Intent;import android.net.Uri;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.view.View;import android.util.Log;import android.widget.Button;import android.widget.TextView;import android.widget.EditText;public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.i("IBM","Hello there logcat!"); setContentView(R.layout.activity_main); final Button btnHitMe = (Button) findViewById(R.id.hitme); final Button btnMapMe = (Button) findViewById(R.id.mapme); final TextView tvLabel = (TextView) findViewById(R.id.thelabel); final EditText etLatitude = (EditText) findViewById(R.id.etLatitude); final EditText etLongitude = (EditText) findViewById(R.id.etLongitude); btnHitMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { tvLabel.setText("Ouch!"); } } ); btnMapMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { String coords = etLatitude.getText()+","+etLongitude.getText(); Log.i("IBM",coords); Uri mapsIntentUri = Uri.parse("geo:" + coords); Intent mapIntent = new Intent(Intent.ACTION_VIEW, mapsIntentUri); startActivity(mapIntent); } } ); }}

MainActivity is een normale Java-klasse, met een pakket en import zoals verwacht.

bronnen voor de toepassing

bronnen in Android zijn georganiseerd in een submap van het project met de naam res, zoals eerder beschreven. Middelen vallen in een aantal categorieën. Drie van deze categorieën zijn::

• Drawables – deze map bevat grafische bestanden, zoals pictogrammen en bitmaps
• lay-outs – deze map bevat XML-bestanden die de lay-outs en weergaven van de toepassing vertegenwoordigen. Deze zullen hieronder in detail worden besproken.
• waarden – deze map bevat een bestand met de naam tekenreeksen.xml. Dit is het primaire middel voor string lokalisatie voor de toepassing. De bestandskleuren.xml is handig voor het definiëren van kleurcodes die door de toepassing worden gebruikt. Dit bestand is analoog aan een css style sheet voor degenen die bekend zijn met web programmeertechnieken.

primaire UI-middelen in de hoofdactiviteit.xml-bestand

de voorbeeldtoepassing bevat één activiteit en één weergave. De toepassing bevat een bestand met de naam main_activity.xml die de visuele aspecten van de primaire UI van de activiteit weergeeft. Merk op dat er geen verwijzing is in de main_activity.xml waar de opmaak wordt gebruikt. Dit betekent dat het kan worden gebruikt in meer dan één activiteit, indien gewenst. Zie de volgende code listing

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:gravity="center_vertical"> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal" android:gravity="center" tools:layout_editor_absoluteX="8dp" tools:layout_editor_absoluteY="301dp"> <Button android:id="@+id/hitme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hit Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="383dp" /> <Button android:id="@+id/mapme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Map Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="460dp" /> </LinearLayout> <TextView android:id="@+id/thelabel" android:layout_width="match_parent" android:layout_height="wrap_content" android:gravity="center" android:text="Hello World, Say Something!!!!!" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" /> <EditText android:id="@+id/etLatitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Latitude" android:inputType="numberDecimal" android:text="40.9241164" /> <EditText android:id="@+id/etLongitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Longitude" android:inputType="numberDecimal" android:text="-74.7213913" /></LinearLayout>

LinearLayout is er een tweedeLinearLayout georganiseerd als een horizontale layout. Deze innerlijke lay-out bevat een paar knop widgets. Onder de horizontale LinearLayout bevindt zich een enkel TextView-element, dat kan worden vergeleken met een label in andere ontwikkelingsomgevingen. Een TextView vertegenwoordigt statische tekst die niet bewerkbaar is. Onder de TextView, zijn er tweeEditText widgets, geconfigureerd om numerieke ingangen te nemen. Deze invoerelementen worden gebruikt om een breedtegraad-en Lengtegraadwaarde vast te leggen die vervolgens zal worden doorgegeven aan een kaarttoepassing, zoals hieronder wordt aangetoond.

merk op dat elk weergaveelement attributen heeft in de Android-naamruimte. Sommige attributen zijn gemeenschappelijk voor alle weergaven-deandroid:layout_width enandroid:layout_height attributen, bijvoorbeeld. De beschikbare waarden voor deze attributen zijn:

• Match Parent – dit breidt het view-element uit om de maximale beschikbare ruimte in te nemen. Dit kan ook worden gezien als Betekenis “stretch.”
• inhoud afbreken – deze optie resulteert in het uitbreiden van het element net genoeg om de onderliggende weergaven of attributen zoals tekst of afbeelding te bevatten.

Deployment descriptor for an Android application (AndroidManifest.xml)

het AndroidManifest.xml-bestand vertegenwoordigt de Deployment descriptor voor een Android-applicatie. Het bestand bevat een lijst van activiteiten, service, content provider of ontvanger in de toepassing, samen met de juiste IntentFilters ondersteund door de toepassing. Hier is het complete AndroidManifest.xml-bestand voor de voorbeeldtoepassing:

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.navitend.saysomething"> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name=".MainActivity" android:label="@string/app_name" android:theme="@style/AppTheme.NoActionBar"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application></manifest>

<manifest> label importeert in wezen klassen uit dit pakket. Alle niet-volledig gekwalificeerde klassen in dit bestand zijn te vinden in het pakket geïdentificeerd in het pakket attribuut.

Stap 3: Bouw de applicatie

om de applicatie te bouwen, selecteert u het sleutelpictogram (lijkt meer op een hamer voor mij) in het menu van Android Studio.

het bouwproces, zoals eerder geà ntroduceerd, is een meerstapsproces dat kan worden aangepast voor elke specifieke toepassing. Voor deze tutorial wijzigen we het bouwproces niet. De uitvoer van het bouwproces moet er ongeveer zo uitzien:

om het bouwproces aan te tonen, hebben we een fout in de broncode geà ntroduceerd; we hebben een extra spatie toegevoegd in de naam van de methode findViewById, weergegeven in de volgende figuur:

dit creëert een syntaxis of parseerfout die wordt opgepikt door het bouwproces en wordt weergegeven in de details van het venster bouwresultaten in Android Studio. Bij de vaststelling van de fout in de broncode, de toepassing bouwt goed, en de fouten worden verwijderd uit de lijst met problemen.

Stap 4: Start de toepassing

nu de toepassing succesvol is gecompileerd, is het tijd om de voorbeeldtoepassing uit te voeren.

eerder in deze tutorial werd de Avd Manager geïntroduceerd als het middel voor het configureren van de emulator voor het testen van applicaties zonder de noodzaak voor een echt apparaat. Het uitvoeren van een applicatie met behulp van de emulator is vooral handig omdat het testen mogelijk maakt zonder de noodzaak om tal van dure apparaten te kopen.

om een emulator, of meer correct, een Android Virtual Device (Avd) in te stellen, selecteert u Tools > AVD Manager. Of klik gewoon op het pictogram Afspelen (uitvoeren).

dit opent een venster waarin u een echt apparaat kunt selecteren dat is verbonden met een USB-kabel of een AVD-exemplaar, zoals weergegeven in de volgende afbeelding:

als er verbonden apparaten zijn, worden deze weergegeven in de vervolgkeuzelijst onder Verbonden apparaten. U kunt ook kiezen uit een van de beschikbare virtuele apparaten. In de vorige figuur is er één AVD gedefinieerd met de titel Nexus One API P. Als u een nieuwe AVD wilt maken, selecteert u de knop nieuw virtueel apparaat maken.

Klik ten slotte op OK om de toepassing op het geselecteerde implementatiedoel te starten. De AVD of emulator wordt gestart met onze voorbeeldtoepassing die erop draait.

Stap 5: Test de toepassing in de emulator

nu de toepassing op de emulator draait, laten we eens kijken wat er achter de schermen gebeurt. Selecteer in Android Studio beeld > Gereedschapsvensters. We zullen slechts een paar van deze tool opties te markeren, hoewel elk van hen is een onderwerp op zich.

Android Studio Tools

kijk eerst naar de Android Profiler die een draaiende grafiek van CPU -, geheugen-en netwerkverkeer weergeeft. De Android Profiler stelt ons in staat om te schakelen tussen verschillende apparaten/emulator gevallen en de respectieve lopende processen. De volgende figuur toont de statistieken voor onze voorbeeldtoepassing die wordt uitgevoerd op een emulator instantie.

Logging is een handig hulpmiddel voor elke ontwikkelaar op elk platform. Voor Android-ontwikkelaars, de naam van de tool is LogCat.

de LogCat is een draaiend logbestand van activiteiten die plaatsvinden in de VM. Toepassingen kunnen hun eigen items in deze lijst maken met een eenvoudige regel code als volgt: Log.i(tag, message); 1, waarbij tag en message beide Java-strings zijn. DeLog klasse maakt deel uit van de android.util.Log pakket.

een ander nuttig hulpmiddel is de bestandsverkenner, die toegang geeft tot het bestandssysteem van de Emulator. De volgende figuur laat zien waar de voorbeeldtoepassing van de tutorial wordt ingezet op de Emulator.

gebruikersapplicaties worden ingezet in / data / app terwijl Android ingebouwde applicaties worden gevonden in de map/system/app .

Full-scale debugging van een Android-applicatie valt buiten het bereik van deze tutorial, hoewel u er zeker van kunt zijn dat Android Studio alle moderne applicatie debugging tools ondersteunt die we kunnen hopen met dingen als stappen In en stappen over functieaanroepen.

Testing the sample applicatie

Tik op de Hit Me! knop, en de inhoud van het label verandert in ” Ouch!”

Tik op de Map Me! knop, en een toewijzingstoepassing wordt gestart met de opgegeven lengte-en breedtegraad die is opgenomen in de widgets EditText.

de bedrading van de knoppen is in de hoofdactiviteit.xml-code. Let in het bijzonder op hoe de breedtegraad-en lengtegraadwaarden worden geëxtraheerd en verpakt in een intentie, die vervolgens wordt gebruikt om de toewijzingstoepassing te starten.

deze handleiding introduceerde het Android-platform, de Android Studio en de belangrijkste elementen van Android-ontwikkeling. U moet nu klaar zijn om uw eigen Android-toepassingen te maken.

bent u klaar voor iets meer? Probeer deze tutorial waar u Bluetooth Low Energy (BLE) API ‘ s gebruiken om IoT aangesloten apparaten te bouwen.