I tidigare inlägg byggde vi ett första Android-projekt och gick igenom vad katalogstrukturen som genereras med projektet består av, i detta
Vid detta tillfälle kommer vi att se hur man startar vår applikation direkt på en emulator eller virtuell enhet.
Dessa enheter kallas Android Virtual Device (AVD) och består i grunden av emulatorer som vi skapar och konfigurerar efter våra behov gällande typen av enhet oavsett om det är en mobiltelefon eller surfplatta, skärmstorlek eller densitet, egenskaper, operativsystemversion, minne bland andra element som kan vara viktiga för vår applikation.
Android Studio inkluderar sina egna emulatorer, som vi måste ladda ner och konfigurera, även om detta inte är det enda alternativet, eftersom vi kan inkludera emulatorer från tredje part eller helt enkelt köra applikationen på fysiska enheter, är detta sista alternativ idealiskt, eftersom vi kontrollerar direkt på enheten och resursförbrukningen beror på den, medan om vi använder emulatorer måste vi tilldela pc-resurser till emulatorn då de beter sig som virtuella maskiner som kräver en hög förbrukning av RAM-minne, dock är det bra att ha dessa två alternativ.
Skapande av en mobiltelefonemulator.
Om en emulator redan har skapats i Android Studio, kommer namnet på den virtuella enheten att visas i det övre vänstra hörnet, i det här fallet, som nämnt i tidigare inlägg, har vi skapat en emulator API 28 Pixel 2som redan är vald och redo att köra programmet.
Om du vill skapa en till kan vi gå in i alternativet Enhetshanteraren varifrån vi kommer att se den skapade emulatorn och kan ändra den, eller klicka på "Skapa enhet" för att skapa en ny.
Om det tvärtom är första gången som du skapar en Android Studio-emulator, kommer du att se att i det övre vänstra hörnet visas ett alternativ som indikerar att det inte finns några enheter (inga enheter) och om vi visar detta alternativ hittar vi 3 alternativ, varifrån vi kan ange "AVD Manager” eller samma ikon i den översta raden som visas i bilden.
Genom att klicka på alternativet laddas samma skärm som vi visade tidigare, men i det här fallet finns det inga emulatorer skapade och istället ger de oss möjlighet att skapa en.
Genom att klicka på skapa laddas ett fönster där vi ser de olika kategorierna för att skapa emulatorer som TV, mobiltelefoner, klockor, surfplattor, bland annat.
Härifrån väljer vi alternativet "Telefon" och väljer ett av de tillgängliga, där kan vi se namnet på enheten, om den har Google Play (viktigt för resurser som kräver Google APIs), storlek, upplösning och skärmtäthet, i I det här fallet väljer vi "Pixel 2" och klickar på Nästa.
När vi gör detta laddas ett annat fönster där vi måste ladda ner bilden av versionen av operativsystemet vi vill arbeta med. Om det finns bilder som tidigare laddats ner kommer de att visas här, men i det här fallet ser vi att det inte finns några (det är mycket viktigt att vi är anslutna till internet, annars kunde den här processen inte utföras för att ladda ner, efter det är inte nödvändigt), klickar vi på Ladda ner det alternativ vi vill ha, till exempel, som ses på bilden, laddar vi ner "android Pie"
När du gör detta laddas ett annat fönster där vi måste acceptera användningslicensen och klicka på Nästa
Den virtuella enhetens nedladdning och installationsprocessen startar automatiskt, detta kan ta en stund beroende på din internetanslutning.
När vi är klara och klara återgår vi till föregående fönster där vi redan ser den nedladdade bilden, välj den och klicka på Nästa
Vi ser hur ett nytt fönster nu laddas där vi definierar emulatorinställningarna vad gäller namn, skärmorientering och avancerade alternativ där mängden allokerat RAM-minne kan tilldelas manuellt, om minnesanvändning simuleras externt bland andra funktioner så klickar vi på Slutför .
När vi gör detta ser vi att vår emulator redan är associerad och enheten är laddad i avsnittet "Enhetshanteraren" som visas i början av den här guiden.
Om vi vill kan vi starta emulatorn direkt eller klicka på sidofliken "Enhetshanteraren" för att dölja den (ej nödvändigt) och klicka på KÖR-ikonen längst upp.
detta startar emulatorn och visar vår applikation, denna process kan ta ett tag första gången när installationsprocessen startar, efter detta förväntas emulatorn vara mycket snabbare från och med nu.
Om vi vill skapa en ny emulator går vi tillbaka till Enhetshanteraren och klickar på Skapa enhet
När vi gör det upprepar vi de föregående stegen, till exempel kan vi skapa en surfplatta och i slutet kommer vi att se att den nya emulatorn är laddad och när vi visar alternativen hittar vi alla emulatorer som skapats.
Om vi går in i Enhetshanteraren igen kommer vi att se båda emulatorerna och därifrån definierar vi vilken emulator som ska användas för att testa vår applikation, att kunna starta den direkt i varje emulator eller genom att välja den högst upp och köra applikationen direkt
Genom att göra detta laddas emulatorn och vi kan också se hur varje emulatorkörning är uppdelad i flikar.
Emulator display.
Tidigare har standardemulatorn laddats som ett separat fönster, för närvarande ingår den som standard i Android Studio-gränssnittet på vänster sida, men vi kan placera den var som helst eller ta bort den om vi vill att den ska flyta och, så, flytta en extern skärm så att att den är oberoende av IDE.
För att minimera emulatorn kan vi klicka på sidofliken "Emulator" och visa den igen genom att klicka på den igen.
Om vi vill ändra positionen högerklickar vi på "Emulator" och vi ser olika alternativ, i det här fallet väljer vi "Flytta till" och definierar önskad plats.
Om vi nu vill göra emulatorn flytande, väljer vi "Visningsläge" och alternativet "Flytande"
Således har vi emulatorn som ett separat fönster från utvecklingsmiljön.
Och med det har vi redan skapat och konfigurerat virtuella enheter som vi kan testa vår första applikation med.
Det kan också intressera dig.
Finns det något du vill lägga till eller kommentera om det här inlägget? gör gärna....Och om du gillade det... Jag inbjuder dig att dela y Prenumerera genom att klicka på knappen "Gå med på den här webbplatsen" för att höra fler inlägg som detta 😉