udvikling af din første Android-applikation

udvikling af din første Android-applikation

hvorfor bekymrer vi os om Android? Vi er interesserede i Android-platformen, fordi den er den mest udbredte mobile platform på planeten og er tilgængelig for forbrugere over hele kloden. I økonomier, hvor ejerskabet af en personlig computer er en luksus, brug af mobilenheder er normen–og Android spiller en vigtig rolle i at forbinde mennesker til hinanden. Som du vil lære i denne vejledning, tager Android en særskilt tilgang til applikationer. Arkitekturen i Android tillader et meget tilpasseligt programmiljø takket være dets runtime-binding af anmodede handlinger og koden for at imødekomme disse anmodninger. Uanset om det er markedsdrevne overvejelser eller de tekniske aspekter af Android, er det en platform, der er værd at undersøge. Yderligere, hvis du seriøst overvejer at have en mobiloplevelse til din platform, kan du ikke ignorere Android.

forudsætninger

denne tutorial kræver flere teknologier, der arbejder sammen. Du har brug for dem alle til denne tutorial.

• Android Studio – Android Studio er det primære udgangspunkt for at konstruere Android – applikationer
• Android-enhed eller Emulator-du vil enten have en fysisk Android-enhed eller Android-emulatoren. Uanset hvad vil læsning gennem denne tutorial hjælpe dig med at forstå de grundlæggende forbindelsespunkter i en Android-applikation.

• kildekode-Kildekodestykker i denne tutorial inkluderer:

  • AndroidManifest.- denne fil er programmet deployment descriptor til Android-applikationer.
  • hovedaktivitet.java-Dette implementerer en Android aktivitet, den primære indgang til prøven anvendelse af denne tutorial.
  • Aktivitet_main.dette indeholder definitioner for de visuelle elementer eller ressourcer til brug for Android-aktiviteter.
  • AndroidManifest.dette viser en fuld AndroidManfest.en beskrivelse af hvert af de vigtige elementer.

Introduktion til Android-arkitekturen

før du dykker lige ind i Android-studiets ins og outs og Udvikler Android-applikationer, lad os se på arkitekturen i Android og nogle af de nøgleudtryk, der vil være nyttige i tutorial og videre, når du begynder at opbygge Android-applikationer til dig selv.

Android terminologi

en forståelse af vilkårene nedenfor er nyttigt i Android applikationsudvikling med Android Studio.

• Android er et open source driftsmiljø målrettet til mobile enheder. I stigende grad findes Android i applikationer ud over “smartphones”. Disse inkluderer bærbar teknologi, apparater som projektorer, højttalere og fjernsyn og endda biler.
• Emulator er et værktøj, der er repræsentativt for et andet system. Ofte er en emulator et miljø, der kører på en pc (PC, Mac), der emulerer et andet miljø, f.eks.
• er en open source-operativsystemkerne i hjertet af mange computerplatforme, herunder servere, stationære computere, netværksapparater og mobile computerenheder. Android kører oven på en Linuk-kerne.
• Android Run Time (ART) er et driftsmiljø, der findes i Android-stakken, som udfører applikationskode ved kørsel. Android Run Time erstatter” legacy ” Dalvik Virtual Machine (VM) fra tidligere versioner af Android, der fungerede på en måde svarende til en kompatibel Java VM.

hensigten

siden starten er Android blevet en dominerende kraft i mobiltelefonrummet. Dens applikationsmodel er unik, fordi applikationer ikke er monolitiske, menubelastede applikationer, der kræver meget klik og tapping for at fungere. Sikker på, der er menuer og knapper, der skal tappes, men Android har et innovativt designelement til sin arkitektur kendt som en hensigt.

en hensigt er en konstruktion, der tillader en ansøgning at udstede en anmodning, hvilket er lidt som et hjælp-ønsket tegn. Det kan se ud som disse:

• “ønskede: Et program til at hjælpe mig med at slå en kontakt op”
• “ønsket: et program til at hjælpe mig med at vise dette billede”
• “ønsket: et program til at udføre denne geografiske baserede søgning.”

på en lignende og komplementær måde kan applikationer registrere sig som dygtige og interesserede i at imødekomme forskellige anmodninger eller hensigter. For at følge det klassificerede reklameparadigme kan disse se sådan ud:

• “tilgængelig: ansøgning klar og villig til at præsentere kontaktposter på en klar, kortfattet måde”
• ” tilgængelig: Ansøgning klar og villig til at udføre en geografisk søgning.”

dette er eksempler på Intentfiltre, som diskuteres næste.

Intentfilteret

applikationer annoncerer deres tilgængelighed til at udføre disse typer operationer via en konstruktion kendt som etIntentFilter . IntentFilter er enten registreret på runtime eller er opregnet i AndroidManifest.fil. Følgende uddrag kommer fra en Android-applikation, der reagerer på indgående SMS-beskeder (tekst) :

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

IntentFilter introducerer det næste afsnit de fire hovedtyper af Android-applikationer.

typer af Android-applikationer

lad os tage et øjeblik til at undersøge de fire hovedtyper af Android-applikationer:

• aktivitet
• Service
• modtager
• ContentProvider

vi vil også se på visningerne for at vise brugergrænsefladeelementerne (UI).

aktivitet apps

aktiviteten er den mest synlige og fremtrædende form for en Android-applikation. En aktivitet præsenterer brugergrænsefladen til en applikation sammen med hjælp fra en klasse kendt som en visning. Visningsklassen implementeres som forskellige UI-elementer, såsom tekstbokse, etiketter, knapper og andre UI ‘ er, der er typiske i computerplatforme, mobil eller otherwise.An ansøgningen kan indeholde en eller flere aktiviteter. En aktivitet defineres typisk på et en-til-en-forhold til de skærme, der findes i en applikation.

et program bevæger sig fra en aktivitet til en anden ved at kalde en metode kendt somstartActivity () eller startSubActivity () . Den tidligere metode bruges, når applikationen blot ønsker at “skifte” til den nye aktivitet. Sidstnævnte bruges, når et synkront opkald/responsparadigme ønskes. I begge tilfælde overføres en hensigt som et argument til den kaldte metode.

det er operativsystemets ansvar at bestemme den bedst kvalificerede aktivitet for at opfylde den angivne hensigt.

Service-og modtagerapps

ligesom andre multi-opgavede computermiljøer er der applikationer, der kører “i baggrunden”, der udfører forskellige opgaver. Android kalder disse typer applikationstjenester. Tjenesten er en Android-applikation, der ikke har nogen brugergrænseflade.

modtageren er en applikationskomponent, der modtager anmodninger om at behandle hensigter. Ligesom tjenesten har en modtager ikke i normal praksis et UI-element. Modtagere er typisk registreret i AndroidManifest.fil.

følgende uddrag (som er det samme som vist for IntentFilter) er et eksempel på, at en modtagerapplikation defineres. Bemærk, at modtagerens navneattribut er Java-klassen, der er ansvarlig for implementering af modtageren.

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

den ContentProvider er Android mekanisme til data-store abstraktion. Lad os se på en bestemt type data, der findes på en mobilenhed: adressebogen eller kontaktdatabasen. Adressebogen indeholder alle de kontakter og telefonnumre, en person kan kræve, når du bruger en mobiltelefon.

ContentProvider er en mekanisme til abstrakt adgang til en bestemt datalager. På mange måder virker ContentProvider i rollen som en databaseserver. Operationer til at læse og skrive indhold til et bestemt datalager skal sendes gennem en passende ContentProvider i stedet for at få adgang til en fil eller database direkte. Der kan være både “klienter” og “implementeringer” af ContentProvider.

Android-visninger

Android-visninger er UI-mekanismen til at sætte ting på skærmen på en Android-enhed. Android-aktiviteten anvender visninger til at vise UI-elementer. Nogle af de mere populære layoutdesign inkluderer:

• Lineærlodret-hvert efterfølgende element følger sin forgænger ved at strømme under det i en enkelt kolonne.
• Lineærvandret – hvert efterfølgende element følger sin forgænger ved at strømme til højre i en enkelt række.
• tabel-en række rækker og kolonner, der ligner en HTML-tabel. Hver celle kan indeholde et visningselement.
• begrænsning – hvert element er “begrænset” til et aspekt af skærmen, såsom toppen eller siden af skærmen eller et andet element. Dette layout hjælper med konstruktionen af” responsive ” applikationer og er arvingen til det ældre Relative Layout, der blev introduceret i tidligere versioner af Android-platformen.

når et bestemt layout (eller en kombination af layout) er valgt, bruges individuelle visninger til at definere brugergrænsefladen.

Vis elementer består af velkendte UI elementer, herunder:

• knap
• billedvisning
• Redigeringtekst for at samle input med forskellige filtre såsom dato eller numerisk
• tekstvisning (svarende til en etiket, viser statisk tekst)
• afkrydsningsfelt
• radioknap
• Spinner (svarende til en “rullemenu” kombinationsboks)
• autofuldførelse (Edittekst med automatisk tekst-komplet funktion)

visninger er defineret i en fil. For eksempel viser dette en simpel Lineærvertikal visning med definerede knapper og tekstvisninger:

<?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/, og rul ned for at hente Android Studio. Android Studio er tilgængelig til Android.

Android Studio er baseret på IntelliJ IDE-platformen. Hvis du er den slags udvikler, der er interessant i at udnytte tastaturgenveje, kan du overveje at lære mere om IntelliJ fra jetbrains hjemmeside.

Kom godt i gang med Android SDK

nu hvor vi har Android Studio installeret, er det tid til at få programmet Developer Kit (SDK) til Android.

men inden vi går videre, skal vi have en diskussion omkring Android-versioner.

Android-versioner

siden starten er Android blevet frigivet under en noget parallel sti med numeriske udgivelsesrevisioner, API-niveauer og også “søde” navne inklusive Jelly Bean, KitKat, Oreo og andre konfekturefavoritter.

det er let at blive overvældet af de tilgængelige valg. For nu har du brug for bare en lille smule forståelse af dette “versionslandskab” for at komme i gang som Android-Udvikler.

der er mange versioner eller revisioner af Android i naturen. Hvis du skal skrive en ansøgning om kommerciel udgivelse, skal du vide, hvilke enheder du målretter mod. Android-versionerne, navnene, udgivelsesdatoerne samt en grafik, der viser det omtrentlige antal af hver enhed på markedet.

nyere enheder kører den nyeste kode, og ældre enheder kan være noget begrænset i deres evne til at opgradere til en nyere version af Android. Nogle gange understøtter de nyere versioner kapaciteter, som de ældre håndsæt ikke er i stand til at understøtte (tænk andet kamera, nær feltkommunikation osv.). En anden ikke-triviel grund til, at ældre håndsæt muligvis ikke kan køre den nyeste Android-version, er, at både producenten og teleselskabet (Verison, på&T osv.) skal understøtte programmet, der kører inden for deres økosystem. Understøttelse af et nyt operativsystem kræver ressourcer fra enhedsproducenten og transportøren. Markedskræfterne antyder, at disse markedsdeltagere er mere optaget af fremtidigt salg end at støtte tidligere salg og investerer deres menneskelige kapital i overensstemmelse hermed.

hvad betyder det som programudvikler, at der er nye versioner af operativsystemet? Dette opdeles i to brede kategorier, når det kommer til programmeringsapplikationer:

• en ny version af operativsystemet introducerer ofte nye funktioner, som vi kan drage fordel af, og/eller vores brugerbase forventer, at vores applikationer understøtter.
• ældre (eller ældre) funktioner i miljøet kan faktisk hindre nyere funktioner og/eller repræsentere en ringere tilgang til at levere et specifikt sæt funktionalitet. Nogle gange skal kode faktisk fjernes fra API-definitionerne. Der er en særlig betegnelse for denne “fjernelse” af tidligere arbejdskode – vi kalder det “kodeafskrivning”. Når en API er blevet markeret til fjernelse, siger vi, at dette er en forældet API. Dette er hovedsagelig en besked til udvikleren, der går noget som dette: “Advarsel” Denne kode vil blive fjernet i fremtiden, skal du planlægge i overensstemmelse hermed.”

Android-platformen har været ret liberal (det vil sige gunstig for udvikleren) med sin tilgang til forældet kode ved at tillade applikationer at fortsætte med at bruge ældre API ‘ er i et stykke tid efter at være markeret som forældet. (Denne tilgang står i kontrast til Apples tilgang med forældet kode i iOS, hvor ældre kode simpelthen bare kan stoppe med at arbejde på den næste OS-udgivelse. Med iOS ser selv programmeringssproget ud til at ændre sig, mens vi ikke ser ud!)

mens Android kan være lidt mere tilgivende med sin Langmodighed af forældet kode, er vi nødt til at holde øje med dokumentationsmærket, der siger, at en bestemt API er forældet. Hvis en kode, som vi bruger, er markeret som forældet, skal vi til sidst ændre vores tilgang i en fremtidig version af vores applikation, fordi enhver API, der er markeret som forældet, kan fjernes i en fremtidig udgivelse. Afskrivningsmarkører i SDK er vores køreplan for fremtidige muligheder for forbedring og for potentiel hovedpine. Nogle gange er den” nye ” måde at gøre tingene på enkel og ligetil, men ikke i alle tilfælde!

at være en succesfuld mobilapplikationsudvikler kræver en løbende investering i løbet af en applikations levetid, hvor tiden har tendens til at gå som hundeår…meget hurtigt!

med denne grundlæggende introduktion til versionerne af Android er det tid til at få Android SDK.

indhentning og installation af Android SDK

Start Android Studio. Vælg SDK Manager under menuen Funktioner. Denne menupunkt indlæser dialogboksen Android Studio-Indstillinger og vælger undermenuen Android SDK på forhånd. Denne menu er vores primære middel til at interagere med de forskellige SDK ‘ er, der er tilgængelige for de mange versioner af Android.

med hver udgivelse af operativsystemet øges API-niveauet. Bemærk, at revisionen stiger langsommere end API-niveauet. Du kan tænke på revisionen som en “generation” af platformen eller som et “større” versionsnummer. Når du gennemser Android-dokumentationen, skal du være sikker på, at du bemærker, hvilket API-niveau en bestemt kapacitet blev introduceret. Hver API er tilgængelig på det angivne API-niveau og større, medmindre API ‘ en er blevet forældet og efterfølgende fjernet. For eksempel blev ContactsContract API introduceret på niveau 5, hvilket er ret “gammelt” på dette tidspunkt.

Vælg et eller to SDK-niveauer for at arbejde med for nu. SDK Manager vil efterfølgende hente de relaterede filer og gøre dem tilgængelige til brug i Android Studio.

også under menuen Funktioner er en mulighed for AVD Manager. AVD står for Android virtuel enhed. Dette er emulatoren. Emulatoren er nyttig, fordi den tillader os at teste applikationer på forskellige enhedstyper, størrelser og versioner. Skærmbillederne i denne tutorial er taget fra emulatoren. Mere om dette senere.

opbygning af din første Android-applikation

denne tutorial trin dig gennem oprettelse af en grundlæggende Android-applikation, kaldet SaySomething , ved hjælp af Android Studio og demonstrere det på Android emulator.

Få koden

Trin 1: Opret et nyt projekt

1. Vælg fil > nyt projekt.

2. udfyld dialogboksen Opret Android-projekt, og klik på Næste.

   

   kravene til det nye projekt inkluderer:

   • ansøgning navn
   • selskab domæne (dette bliver vendt til com.domæne) for at holde applikationer partitioneret, selvom de har samme applikationsnavn.
   • Projektplacering – hvor skal filerne gemmes
   • pakkenavnet foreslås fra applikationsnavnet og Firmadomænet
   • som standard er Android-applikationer skrevet i Java. Hvis du vil understøtte alternative sprog, såsom C++ (for native code) eller Kotlin, skal du markere de relevante afkrydsningsfelter.

3. i dialogboksen mål Android-enheder skal du angive API-niveau og målplatforme. Som tidligere nævnt er Android til mere end bare telefoner, men til vores formål vælger vi simpelthen telefon-og Tabletformfaktoren til denne tutorial. Klik derefter på Næste.

   

4. vælg den tomme aktivitetstype i dialogboksen Føj en aktivitet til mobil. Klik derefter på Næste.

   

   dette opretter en standardapplikation, der er klar til at blive bygget og køre direkte fra Android Studio.

5. i dialogboksen Konfigurer aktivitet skal du navngive filerne til applikationen.

   

Trin 2: gennemgå koden

følgende figur viser komponenterne i vores nye projekt:

der er to mapper: app og Gradle Scripts.

• den app mappe indeholder alle vores ansøgning kode.
• manifesterer mappen i app mappen indeholder AndroidManifest.4903 > som er deployment descriptor for denne ansøgning. Denne fil fortæller Android-enheden om, hvordan man interagerer med applikationen, hvilken aktivitet der skal vises, når applikationen startes, som har til hensigt applikationstjenesterne, hvilke ikoner der skal vises og meget mere.
• mappen java indeholder kildekoden til applikationen. I dette tilfælde den fil, der implementerer vores aktivitet plus et par klassefiler til udførelse af automatiserede tests (som vi vil ignorere for denne tutorial).
• mappen res indeholder ressourcerne til applikationen, herunder ikoner, layoutfiler, strenge, menuer og så videre.
• mappen Gradle Scripts indeholder alle de scriptable elementer til opbygning af applikationen. Gradle build-systemet er et emne for sig selv. For nu skal du forstå, at disse scripts styrer processen med at opbygge applikationen – og vigtigere for mere modne projekter og teams, kan hvert af disse trin køres fra kommandolinjen. Dette er vigtigt, fordi denne tilgang understøtter automatisering og falder ind under kategorien Kontinuerlig Integration.

lad os nu undersøge kildekoden nærmere.

primær aktivitet til applikationen

vores prøveapplikation består af en enkelt aktivitet, der hedder MainActivity.

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 er en normal Java klasse, med en pakke og import, som forventet.

ressourcer til applikationen

ressourcer i Android er organiseret i en undermappe af projektet med navnet res, som beskrevet tidligere. Ressourcer falder ind i en række kategorier. Tre af disse kategorier er:

• tegneborde – denne mappe indeholder grafikfiler, såsom ikoner og bitmaps
• Layouts – denne mappe indeholder HML-filer, der repræsenterer layouts og visninger af applikationen. Disse vil blive undersøgt detaljeret nedenfor.
• værdier – denne mappe indeholder en fil med navnet strings.4903>. Dette er det primære middel til strenglokalisering til applikationen. Filen farver.er nyttigt til at definere farvekoder, der anvendes af programmet. Denne fil er analog med et CSS-stilark for dem, der er bekendt med internetprogrammeringsteknikker.

primære UI ressourcer i main_activity.

prøveapplikationen indeholder en enkelt aktivitet og en enkelt visning. Programmet indeholder en fil med navnet main_activity.4903>, der repræsenterer de visuelle aspekter af aktivitetens primære brugergrænseflade. Bemærk, at der ikke er nogen reference i main_activity.4903 > hvor layoutet bruges. Dette betyder, at det kan bruges i mere end en aktivitet, hvis det ønskes. Se følgende kodeliste

<?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>

LinearLayouter der en anden LinearLayout organiseret som et vandret layout. Dette indre layout indeholder et par knapper. Under den vandrette LinearLayout er der et enkelt Tekstvisningselement, som kan sammenlignes med en etiket i andre udviklingsmiljøer. En tekstvisning repræsenterer statisk tekst, der ikke kan redigeres. Under tekstvisninger der to redigeringtekst kontroller, der er konfigureret til at tage numeriske indgange. Disse inputelementer bruges til at fange en bredde-og Længdegradsværdi, som efterfølgende overføres til en kortlægningsapplikation, som vist nedenfor.

Bemærk, at hvert visningselement har attributter i android-navneområdet. Nogle attributter er fælles for alle visninger — android:layout_bredde og android:layout_height attributter, for eksempel. De tilgængelige værdier for disse attributter er:

• Match forælder-dette udvider visningselementet til at tage den maksimale plads til rådighed. Dette kan også betragtes som betyder ” stretch.”
• Indpak Indhold – Denne indstilling resulterer i, at elementet udvides lige nok til at indeholde dets underordnede visninger eller attributter såsom tekst eller billede.

Deployment descriptor til en Android-applikation (AndroidManifest.

Androidmanifesten.filen repræsenterer deployment descriptoren for en Android-applikation. Filen viser enhver aktivitet, tjeneste, indholdsudbyder eller modtager indeholdt i applikationen sammen med de relevante Intentfiltre, der understøttes af applikationen. Her er den komplette AndroidManifest.fil til prøveapplikationen:

<?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> importerer i det væsentlige klasser fra denne pakke. Alle ikke-fuldt kvalificerede klasser i denne fil findes i pakken identificeret i pakkeattributten.

Trin 3: Byg applikationen

for at opbygge applikationen skal du vælge skruenøgleikonet (ligner mere en hammer for mig) i menuen til Android Studio.

byggeprocessen, som introduceret tidligere, er en flertrinsproces, der kan tilpasses til en bestemt applikation. Til denne vejledning ændrer vi ikke byggeprocessen. Udgangen af byggeprocessen skal se sådan ud:

for at demonstrere byggeprocessen har vi introduceret en fejl i kildekoden; vi tilføjede en ekstra plads i navnet på metoden findvisitbyid, vist i følgende figur:

dette skaber en syntaks-eller analysefejl, der hentes af byggeprocessen og vises i detaljerne i vinduet med build-resultater i Android Studio. Ved fastsættelse af fejlen i kildekoden, programmet bygger korrekt, og fejlene fjernes fra listen problemer.

Trin 4: Kør applikationen

nu hvor applikationen er kompileret med succes, er det tid til at køre prøveapplikationen.

tidligere i denne tutorial blev AVD Manager introduceret som middel til at konfigurere emulatoren til test af applikationer uden behov for en rigtig enhed. At køre et program ved hjælp af emulatoren er især nyttigt, fordi det tillader test uden behov for at købe adskillige dyre enheder.

for at opsætte en emulator, eller mere korrekt, en Android Virtual Device (AVD), skal du vælge Værktøjer > AVD Manager. Eller klik blot på ikonet Afspil (Kør).

dette starter et vindue, der lader dig vælge enten en rigtig enhed, der er tilsluttet via et USB-kabel eller en tilgængelig AVD-forekomst, som vist i følgende figur:

hvis der er tilsluttede enheder, vises hver i rullemenuen under tilsluttede enheder. Alternativt kan du vælge fra en af de tilgængelige virtuelle enheder. I den foregående figur er der en enkelt AVD defineret med titlen Link en API P . For at oprette en ny AVD skal du vælge knappen Opret ny virtuel enhed.

klik til sidst på OK for at starte programmet på det valgte implementeringsmål. AVD eller emulator lanceres med vores prøveapplikation, der kører på den.

Trin 5: Test applikationen i emulatoren

nu hvor applikationen kører på emulatoren, lad os se på, hvad der sker bag kulisserne. I Android Studio skal du vælge Vis > Værktøjsvinduer. Vi vil fremhæve blot et par af disse værktøjsmuligheder, selvom hver af dem er et emne for sig selv.

Android Studio Tools

først skal du se på Android Profiler, der viser et løbende diagram over CPU, hukommelse og netværkstrafik. Android Profiler tillader os at skifte mellem forskellige enheder/emulator forekomster og respektive kørende processer. Følgende figur viser metrics for vores prøveapplikation, der kører på en emulatorinstans.

logning er et nyttigt værktøj til enhver udvikler på enhver platform. For Android-udviklere er navnet på værktøjet LogCat.

LogCat er en kørende logfil af aktivitet, der finder sted i VM. Applikationer kan lave deres egne poster til denne liste med en simpel kodelinje som følger: Log.i (tag, message); 1, hvor tag og message begge er Java-strenge. Log klassen er en del af android.util.Log pakke.

et andet nyttigt værktøj er filudforskeren, som tillader filsystemadgang til emulatoren. Følgende figur viser, hvor tutorialens prøveapplikation er implementeret på emulatoren.

brugerapplikationer implementeres i/data/app mens Android-indbyggede applikationer findes i/system/app mappe.

fuldskala debugging af en Android-applikation er uden for rammerne af denne tutorial, men vær sikker på at Android Studio understøtter alle de moderne applikationsfejlværktøjer, vi kan håbe på med ting som at træde ind og træde over funktionsopkald.

test af prøveapplikationen

tryk på Hit Me! knappen, og indholdet af etiketten ændres til “Ouch!”

tryk på kortet mig! en kortlægningsprogram startes med den angivne breddegrad og længdegrad, der er indeholdt i redigeringskontrollerne.

ledningerne af knapperne er i Hovedetaktivitet.kode. Bemærk især, hvordan bredde-og længdegradsværdierne udvindes og pakkes i en hensigt, som efterfølgende bruges til at starte kortlægningsapplikationen.

denne tutorial introducerede Android-platformen, Android-studiet og nøgleelementerne i Android-udviklingen. Du skal nu være klar til at oprette dine egne Android-applikationer.

er du klar til noget mere? Prøv denne vejledning, hvor du bruger Bluetooth lavenergi (BLE) API ‘ er til at opbygge IoT-tilsluttede enheder.