utveckla din första Android-applikation

utveckla din första Android-applikation

Varför bryr vi oss om Android? Vi bryr oss om Android-plattformen eftersom den är den mest distribuerade mobilplattformen på planeten och är tillgänglig för konsumenter runt om i världen. I ekonomier där ägandet av en persondator är en lyx är användningen av mobila enheter normen–och Android spelar en viktig roll för att ansluta människor till varandra. Som du kommer att lära dig i denna handledning tar Android ett tydligt tillvägagångssätt för applikationer. Arkitekturen i Android tillåter en mycket anpassningsbar mjukvarumiljö tack vare sin runtime-bindning av begärda åtgärder och koden för att tillgodose dessa förfrågningar. Oavsett om det är marknadsdrivna överväganden eller de tekniska aspekterna av Android, är det en plattform som är värd att undersöka. Vidare, om du seriöst överväger att ha en mobilupplevelse för din plattform, kan du inte ignorera Android.

förutsättningar

denna handledning kräver flera tekniker som fungerar tillsammans. Du behöver dem alla för denna handledning.

• Android Studio-Android Studio är den primära utgångspunkten för att konstruera Android – applikationer
• Android-enhet eller Emulator-du vill ha antingen en fysisk Android-enhet eller Android-emulatorn. Hur som helst, att läsa igenom denna handledning hjälper dig att förstå de grundläggande anslutningspunkterna för en Android-applikation.

• källkod-Källkodsutdrag i denna handledning inkluderar:

  • AndroidManifest.xml snippet-den här filen är application deployment descriptor för Android-applikationer.
  • huvudaktivitet.java-detta implementerar en Android-aktivitet, den primära ingångspunkten till exempelapplikationen för denna handledning.
  • Activity_main.xml-detta innehåller definitioner för de visuella elementen, eller resurser, för användning av Android aktiviteter.
  • AndroidManifest.xml complete-detta listar en fullständig AndroidManfest.xml-fil, tillsammans med en beskrivning av var och en av de viktiga elementen.

introduktion av Android-arkitekturen

innan du dyker rakt in i Android Studio och utvecklar Android-applikationer, låt oss ta en titt på Android-arkitekturen och några av de viktigaste termerna som kommer att vara till hjälp i handledningen och därefter, när du börjar bygga Android-applikationer för dig själv.

Android terminologi

en förståelse av Villkoren nedan är till hjälp i Android applikationsutveckling med Android Studio.

• Android är en öppen källkodsmiljö riktad för Mobila enheter. I allt högre grad finns Android i applikationer utöver”smartphones”. Dessa inkluderar Bärbar Teknik, apparater som Projektorer, högtalare och TV-apparater och till och med bilar.
• Emulator är ett mjukvaruverktyg som är representativt för ett annat system. Ofta är en emulator en miljö som körs på en persondator (PC, Mac, Linux-maskin) som emulerar en annan miljö, till exempel en mobildator.
• Linux är en operativsystemkärna med öppen källkod i hjärtat av många datorplattformar, inklusive servrar, stationära datorer, nätverksapparater och mobila datorer. Android körs ovanpå en Linux-kärna.
• Android Run Time (ART) är en driftsmiljö som finns i Android-stacken, som kör programkod vid körning. Android-körtiden ersätter den” äldre ” Dalvik virtuella maskinen (VM) från tidigare versioner av Android som fungerade på ett sätt som liknar en kompatibel Java VM.

avsikten

sedan starten har Android blivit en dominerande kraft i mobiltelefonutrymmet. Dess applikationsmodell är unik genom att applikationer inte är monolitiska, menybelastade applikationer som kräver mycket klick och knackning för att fungera. Visst, det finns menyer och knappar som ska knackas, men Android har ett innovativt designelement till sin arkitektur som kallas en avsikt.

en avsikt är en konstruktion som tillåter en ansökan att utfärda en begäran, vilket är något som ett hjälpsökt tecken. Det kan se ut så här:

• ”sökes: En applikation som hjälper mig att leta upp en kontakt”
• ”Wanted: ett program som hjälper mig att visa den här bilden”
• ”Wanted: ett program för att utföra denna geografiska baserade sökning.”

på ett liknande och kompletterande sätt kan applikationer registrera sig som kapabla och intresserade av att uppfylla olika förfrågningar eller avsikter. För att följa det klassificerade annonsparadigmet kan dessa se ut så här:

• ”tillgänglig: ansökan redo och villig att presentera kontaktposter på ett tydligt och koncist sätt”
• ” tillgänglig: Ansökan redo och villig att utföra en geografisk sökning.”

dessa är exempel på Avsiktfilter, som diskuteras nästa.

IntentFilter

program meddelar att de är tillgängliga för att utföra dessa typer av operationer via en konstruktion som kallasIntentFilter . IntentFilter registreras antingen vid körning eller räknas upp i AndroidManifest.xml-fil. Följande utdrag kommer från en Android-applikation som svarar på inkommande SMS (text) meddelanden:

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

IntentFilter introducerar nästa avsnitt de fyra huvudtyperna av Android-applikationer.

typer av Android-applikationer

Låt oss ta en stund att undersöka de fyra huvudtyperna av Android-applikationer:

• aktivitet
• Service
• mottagare
• ContentProvider

vi tar också en titt på vyerna för att visa användargränssnittselementen.

Aktivitetsappar

aktiviteten är den mest synliga och framträdande formen av en Android-applikation. En aktivitet presenterar användargränssnittet för en applikation, tillsammans med hjälp av en klass som kallas en vy. Vyklassen implementeras som olika gränssnittselement, till exempel textrutor, etiketter, knappar och andra UI: er som är typiska för datorplattformar, mobila eller otherwise.An ansökan kan innehålla en eller flera aktiviteter. En aktivitet definieras vanligtvis i en en-till-en-relation med skärmarna som finns i ett program.

ett program flyttas från en aktivitet till en annan genom att anropa en metod som kallas startActivity()eller startSubActivity(). Den tidigare metoden används när applikationen önskar att helt enkelt ”byta” till den nya aktiviteten. Den senare används när ett synkront samtal/svarsparadigm önskas. I båda fallen skickas en avsikt som ett argument till den kallade metoden.

det är operativsystemets ansvar att bestämma den mest kvalificerade aktiviteten för att uppfylla den angivna avsikten.

Service-och mottagarappar

liksom andra Multi-tasked datormiljöer finns det applikationer som körs ”i bakgrunden” som utför olika uppgifter. Android kallar dessa typer av applikationstjänster. Tjänsten är en Android-applikation som inte har något användargränssnitt.

mottagaren är en applikationskomponent som tar emot förfrågningar om att behandla avsikter. Liksom tjänsten har en mottagare inte i normal praxis ett gränssnittselement. Mottagare är vanligtvis registrerade i AndroidManifest.xml-fil.

följande utdrag (som är detsamma som det som visas för IntentFilter) är ett exempel på att en mottagarapplikation definieras. Observera att mottagarens namnattribut är Java-klassen som ansvarar för att implementera mottagaren.

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

ContentProvider är Android-mekanismen för datalagringsabstraktion. Låt oss titta på en viss typ av data som finns på en mobil enhet: adressboken eller kontaktdatabasen. Adressboken innehåller alla kontakter och telefonnummer en person kan behöva när du använder en mobiltelefon.

den ContentProvider är en mekanism för att Abstrakt tillgång till en viss datalager. På många sätt fungerar ContentProvider i rollen som en databasserver. Åtgärder för att läsa och skriva innehåll till ett visst datalager bör skickas via en lämplig ContentProvider , snarare än att komma åt en fil eller Databas direkt. Det kan finnas både ”klienter” och ”implementeringar” av ContentProvider.

Android-vyer

Android-vyer är ANVÄNDARGRÄNSSNITTSMEKANISMEN för att sätta saker på skärmen på en Android-enhet. Android-aktiviteten använder vyer för att visa gränssnittselement. Några av de mer populära layoutdesignerna inkluderar:

• LinearVertical-varje efterföljande element följer sin föregångare genom att flyta under den i en enda kolumn.
• Linjärhorisontellt – varje efterföljande element följer sin föregångare genom att flyta till höger i en enda rad.
• tabell – en serie rader och kolumner, som liknar en HTML-tabell. Varje cell kan innehålla ett visningselement.
• begränsning – varje element är ”begränsat” till en aspekt av skärmen, t.ex. skärmens övre eller sida eller ett annat element. Denna layout hjälper till att bygga ”responsiva” applikationer och är arvtagaren till den äldre relativa layouten som introducerades i tidigare versioner av Android-plattformen.

när en viss layout (eller kombination av layouter) har valts används enskilda vyer för att definiera användargränssnittet.

Visa element består av bekanta gränssnittselement, inklusive:

• knapp
• ImageView
• EditText för att samla in inmatning med olika filter som datum eller numerisk
• TextView (liknar en etikett, visar statisk text)
• kryssruta
• radioknapp
• Spinner (liknar en ”rullgardins” kombinationsruta)
• Komplettera automatiskt (Edittext med automatisk text-komplett funktion)

vyer definieras i en XML-fil. Till exempel visar detta en enkel Linjärvertikal vy, med knappar och textvisningar definierade:

<?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/, och bläddra ner för att ladda ner Android Studio. Android Studio är tillgängligt för Windows, Mac och Linux.

Android Studio är baserad på IntelliJ IDE-plattformen. Om du är den typ av utvecklare som är intressant att utnyttja kortkommandon, kan du överväga att lära dig mer om IntelliJ från jetbrains webbplats.

komma igång med Android SDK

nu när vi har Android Studio installerat är det dags att få Software Developer Kit (SDK) för Android.

men innan vi går längre måste vi diskutera Android-versioner.

Android-versioner

sedan starten har Android släppts under en något parallell väg med numeriska versioner, API-nivåer och även ”söta” namn inklusive Jelly Bean, KitKat, Oreo och andra konfektyrfavoriter.

det är lätt att bli överväldigad av de tillgängliga valen. För nu behöver du bara lite förståelse för detta” versionslandskap ” för att komma igång som Android-utvecklare.

det finns många versioner eller versioner av Android i naturen. Om du ska skriva en ansökan om kommersiell release måste du veta vilka enheter du riktar in dig på. Wikipedia har en fin sammanfattning av Android-versionerna, namnen, släppdatum samt en grafik som visar Ungefärligt antal av varje enhet på marknaden.

nyare enheter kör den senaste koden, och äldre enheter kan vara något begränsade i sin förmåga att uppgradera till en nyare version av Android. Ibland stöder de nyare versionerna funktioner som de äldre telefonerna inte kan stödja (tänk andra kamera, nära fältkommunikation och så vidare). En annan icke-trivial anledning till att äldre telefoner kanske inte kan köra den senaste Android-versionen är att både tillverkaren och telekombäraren (Verizon, vid&T, och så vidare) behöver stödja programvaran som körs inom deras ekosystem. Att stödja ett nytt operativsystem kräver resurser från enhetstillverkaren och bäraren. Marknadskrafterna tyder på att dessa marknadsaktörer är mer intresserade av framtida försäljning än att stödja tidigare försäljning och investera sitt humankapital i enlighet därmed.

som mjukvaruutvecklare, vad spelar det för roll att det finns nya versioner av operativsystemet? Detta delas upp i två breda kategorier när det gäller programmeringsapplikationer:

• en ny version av operativsystemet introducerar ofta nya funktioner som vi kan dra nytta av och/eller vår användarbas förväntar oss att våra applikationer stöder.
• äldre (eller äldre) funktioner i miljön kan faktiskt hindra nyare funktioner och/eller representera ett sämre sätt att tillhandahålla en specifik uppsättning funktionalitet. Ibland måste kod faktiskt tas bort från API-definitionerna. Det finns en speciell term för denna ”borttagning” av tidigare fungerande kod – vi kallar det ”kodavskrivning”. När ett API har markerats för borttagning säger vi att detta är ett föråldrat API. Detta är i huvudsak ett meddelande till utvecklaren som går ungefär så här: ”Varning” Den här koden kommer att tas bort i framtiden, vänligen planera därefter.”

Android-plattformen har varit ganska liberal (det vill säga gynnsam för utvecklaren) med sin inställning till föråldrad kod genom att tillåta applikationer att fortsätta använda äldre API: er ganska länge efter att ha markerats som föråldrade. (Detta tillvägagångssätt står i kontrast till Apples tillvägagångssätt med föråldrad kod i iOS där äldre kod helt enkelt kan sluta fungera på nästa OS-utgåva. Med iOS verkar även programmeringsspråket förändras medan vi inte letar!)

medan Android kan vara lite mer förlåtande med sitt långa lidande av föråldrad kod, behöver vi hålla ett öga på dokumentationstaggen som säger att ett visst API är föråldrat. Om någon kod som vi använder är markerad som föråldrad måste vi så småningom ändra vårt tillvägagångssätt i en framtida version av vår applikation eftersom alla API som är markerade som föråldrade kan tas bort i en framtida version. Avskrivningsmarkörer i SDK är vår färdplan för framtida möjligheter till förbättring och för potentiell huvudvärk. Ibland är det” nya ” sättet att göra saker enkelt och rakt framåt, men inte i alla fall!

att vara en framgångsrik mobilapplikationsutvecklare kräver en pågående investering under en applikations livstid där tiden tenderar att passera som hundår…mycket snabbt!

med denna grundläggande introduktion till versionerna av Android är det dags att skaffa Android SDK.

hämta och installera Android SDK

starta Android Studio. Under Verktyg-menyn väljer du SDK Manager. Det här menyalternativet laddar dialogrutan för Android Studio-Inställningar och väljer undermenyn Android SDK i förväg. Den här menyn är vårt primära sätt att interagera med de olika SDK: erna som finns tillgängliga för de många versionerna av Android.

med varje utgåva av operativsystemet ökar API-nivån. Observera att revisionen ökar långsammare än API-nivån. Du kan tänka på revisionen som en” generation ”av plattformen, eller som ett” stort ” versionsnummer. När du bläddrar i Android-dokumentationen, se till att du noterar vilken API-nivå som en viss kapacitet introducerades. Varje API är tillgängligt på den angivna API-nivån och högre, såvida inte API: et har avlägsnats och därefter tagits bort. Till exempel introducerades ContactsContract API på nivå 5, vilket är ganska ”gammalt” vid denna tidpunkt.

välj en eller två SDK-nivåer att arbeta med för tillfället. SDK Manager kommer därefter att ladda ner relaterade filer och göra dem tillgängliga för användning i Android Studio.

även under Verktyg-menyn finns ett alternativ för AVD Manager. AVD står för Android Virtual Device. Detta är emulatorn. Emulatorn är till hjälp eftersom den tillåter oss att testa applikationer på olika enhetstyper, storlekar och versioner. Skärmbilderna i denna handledning tas från emulatorn. Mer om detta senare.

bygga din första Android-applikation

denna handledning leder dig genom att skapa en grundläggande Android-applikation, kallad SaySomething, med Android Studio och demonstrerar den på Android-emulatorn.

Hämta koden

Steg 1: Skapa ett nytt projekt

1. välj Arkiv > nytt projekt.

2. fyll i dialogrutan Skapa Android-projekt och klicka på Nästa.

   

   kraven för det nya projektet inkluderar:

   • Programnamn
   • företagsdomän (detta blir omvänd till com.domän) för att hålla applikationer partitionerade även om de har samma Applikationsnamn.
   • projektplats – var filerna ska lagras
   • paketnamnet föreslås från applikationsnamnet och Företagsdomänen
   • som standard skrivs Android-applikationer i Java. Om du vill stödja alternativa språk, till exempel C++ (för inbyggd kod) eller Kotlin, markera lämpliga kryssrutor.

3. ange API-nivå och målplattformar i dialogrutan target Android-enheter. Som tidigare nämnts är Android för mer än bara telefoner, men för våra ändamål väljer vi helt enkelt telefon-och Surfplattformfaktorn för denna handledning. Klicka sedan på Nästa.

   

4. välj den tomma Aktivitetstypen i dialogrutan Lägg till en aktivitet i mobil. Klicka sedan på Nästa.

   

   detta skapar en standardapplikation redo att byggas och köras direkt från Android Studio.

5. namnge filerna för programmet i dialogrutan Konfigurera aktivitet.

   

steg 2: granska koden

följande figur visar komponenterna i vårt nya projekt:

det finns två mappar: appoch Gradle Scripts.

• mappenapp innehåller all vår applikations kod.
• manifest mappen iapp mappen innehåller AndroidManifest.xml som är distributionsbeskrivaren för denna applikation. Den här filen berättar för Android-enheten om hur man interagerar med applikationen, vilken aktivitet som ska visas när applikationen startas, vilken avser applikationstjänsterna, vilka ikoner som ska visas och mycket mer.
• mappenjava innehåller källkoden för programmet. I det här fallet filen som implementerar vår aktivitet plus ett par klassfiler för att utföra automatiserade tester (som vi kommer att ignorera för denna handledning).
• mappenres innehåller resurserna för applikationen, inklusive ikoner, layoutfiler, strängar, menyer och så vidare.
• mappenGradle Scripts innehåller alla skriptbara element för att bygga applikationen. Gradle build-systemet är ett ämne för sig själv. För närvarande förstår du att dessa skript styr processen för att bygga applikationen – och viktigare för mer mogna projekt och team kan var och en av dessa steg köras från kommandoraden. Detta är viktigt eftersom detta tillvägagångssätt stöder automatisering och faller i kategorin kontinuerlig Integration.

låt oss nu undersöka källkoden mer detaljerat.

primär aktivitet för applikationen

vår exempelapplikation består av en enda aktivitet med namnetMainActivity .

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 är en vanlig Java-klass, med ett paket och import, som förväntat.

resurser för applikationen

resurser i Android är organiserade i en underkatalog till projektet med namnet res, som beskrivits tidigare. Resurser faller i ett antal kategorier. Tre av dessa kategorier är:

• Drawables – den här mappen innehåller grafikfiler, till exempel ikoner och bitmappar
• layouter – den här mappen innehåller XML-filer som representerar programmets layouter och vyer. Dessa kommer att undersökas i detalj nedan.
• värden – den här mappen innehåller en fil med namnet strängar.xml. Detta är det primära sättet för stränglokalisering för applikationen. Filen färger.xml är användbart för att definiera färgkoder som används av programmet. Den här filen är analog med ett css-stilark för dem som är bekanta med webbprogrammeringstekniker.

primära UI-resurser i main_activity.xml-fil

exempelprogrammet innehåller en enda aktivitet och en enda vy. Applikationen innehåller en fil med namnet main_activity.xml som representerar de visuella aspekterna av aktivitetens primära användargränssnitt. Observera att det inte finns någon referens i main_activity.xml där layouten används. Detta innebär att det kan användas i mer än en aktivitet, om så önskas. Se följande kodlista

<?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 finns en andra LinearLayout organiserad som en horisontell layout. Denna inre layout innehåller ett par knapp widgets. Under det horisontella LinearLayout finns ett enda TextView-element som kan liknas vid en etikett i andra utvecklingsmiljöer. En TextView representerar statisk text som inte kan redigeras. UnderTextView finns det tvåEditText widgets, konfigurerade för att ta numeriska ingångar. Dessa inmatningselement används för att fånga ett Latitud-och Longitudvärde som därefter skickas vidare till en kartläggningsapplikation, som visas nedan.

Observera att varje visningselement har attribut i android-namnutrymmet. Vissa attribut är gemensamma för alla vyer — attributen android:layout_width och android:layout_height, till exempel. De värden som är tillgängliga för dessa attribut är:

• matcha förälder-detta utökar visningselementet för att ta maximalt tillgängligt utrymme. Detta kan också ses som betyder ” stretch.”
• Wrap – innehåll-det här alternativet resulterar i att elementet expanderar tillräckligt för att innehålla dess underordnade vyer eller attribut som text eller bild.

Deployment descriptor för en Android-applikation (AndroidManifest.xml)

AndroidManifest.xml-fil representerar distributionsbeskrivaren för en Android-applikation. Filen listar någon aktivitet, tjänst, innehållsleverantör, eller mottagare som finns i programmet, tillsammans med lämpliga IntentFilters stöds av programmet. Här är den kompletta Androidenmanifest.xml-fil för exempelprogrammet:

<?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> importerar i huvudsak klasser från detta paket. Alla icke-fullständigt kvalificerade klasser i den här filen finns i paketet som identifieras i paketattributet.

steg 3: Bygg applikationen

för att bygga applikationen, välj skiftnyckelsymbolen (ser mer ut som en hammare för mig) i menyn i Android Studio.

byggprocessen, som introducerades tidigare, är en flerstegsprocess som kan anpassas för en viss applikation. För denna handledning ändrar vi inte byggprocessen. Utsignalen från byggprocessen ska se ut så här:

för att demonstrera byggprocessen har vi infört ett fel i källkoden; vi lade till ett extra utrymme i namnet på metoden findViewById, som visas i följande figur:

detta skapar ett syntax-eller analysfel som hämtas av byggprocessen och visas i detaljerna i fönstret byggresultat i Android Studio. När du fixar felet i källkoden bygger programmet ordentligt och felen tas bort från problemlistan.

steg 4: Kör applikationen

nu när applikationen har sammanställts framgångsrikt är det dags att köra exempelprogrammet.

tidigare i denna handledning introducerades AVD-Hanteraren som medel för att konfigurera emulatorn för att testa applikationer utan behov av en riktig enhet. Att köra ett program med hjälp av emulatorn är särskilt användbart eftersom det tillåter testning utan att behöva köpa många dyra enheter.

för att ställa in en emulator, eller mer korrekt, en Android virtuell enhet (Avd), välj Verktyg > avd Manager. Eller klicka bara på ikonen Spela (kör).

detta startar ett fönster som låter dig välja antingen en riktig enhet som är ansluten med en USB-kabel eller en tillgänglig avd-instans, som visas i följande figur:

om det finns anslutna enheter visas var och en i rullgardinsmenyn nedan anslutna enheter. Alternativt kan du välja från en av de tillgängliga virtuella enheterna. I föregående figur finns en enda avd definierad med titeln Nexus One API P. För att skapa en ny Avd, välj knappen Skapa ny virtuell enhet.

Slutligen klickar du på OK för att starta programmet på det valda distributionsmålet. Avd eller emulator startar med vår exempelapplikation som körs på den.

Steg 5: Testa applikationen i emulatorn

nu när applikationen körs på emulatorn, låt oss ta en titt på vad som händer bakom kulisserna. I Android Studio väljer du visa > verktygsfönster. Vi kommer att lyfta fram bara ett par av dessa Verktygsalternativ, men var och en av dem är ett ämne för sig själv.

Android Studio Tools

titta först på Android-profilen som visar ett löpande diagram över CPU, minne och nätverkstrafik. Android Profiler tillåter oss att växla mellan olika enheter/emulator instanser och respektive processer som körs. Följande figur visar mätvärdena för vårt exempelprogram som körs på en emulatorinstans.

loggning är ett användbart verktyg för alla utvecklare på alla plattformar. För Android-utvecklare är namnet på verktyget LogCat.

LogCat är en löpande loggfil med aktivitet som äger rum i VM. Ansökningar kan göra sina egna poster i den här listan med en enkel kodrad enligt följande: Log.i (tagg,meddelande); 1, där tagg och meddelande är båda Java-strängar. Klassen Log är en del av android .util.Logga paket.

ett annat användbart verktyg är file explorer, som tillåter filsystemåtkomst till emulatorn. Följande figur visar var handledningens exempelapplikation distribueras på emulatorn.

användarprogram distribueras i /data/app medan Android inbyggda program finns i katalogen /system/app.

fullskalig felsökning av en Android-applikation ligger utanför ramen för denna handledning, men du kan vara säker på att Android Studio stöder alla moderna programfelsökningsverktyg som vi kan hoppas på med saker som att gå in och gå över funktionssamtal.

testa provprogrammet

tryck på Hit Me! knappen, och innehållet på etiketten ändras till ” Ouch!”

tryck på kartan mig! startas med den angivna latitud och longitud som finns i EditText widgets.

knapparna är i Huvudetaktivitet.xml-kod. Observera särskilt hur latitud-och longitudvärdena extraheras och förpackas i en avsikt, som därefter används för att starta kartläggningsapplikationen.

denna handledning introducerade Android-plattformen, Android-studion och de viktigaste elementen i Android-utvecklingen. Du bör nu vara redo att skapa dina egna Android-applikationer.

är du redo för något mer? Prova denna handledning där du använder Bluetooth Low Energy (BLE) API: er för att bygga IoT-anslutna enheter.