In elk bedrijf is het begin het moeilijkste. Het is vaak moeilijk om in de context te komen, en dat is wat ik tegenkwam toen ik besloot mijn eerste Android-applicatie te ontwikkelen. Dit artikel is voor degenen die willen beginnen, maar niet weten waar.

Het artikel behandelt de gehele ontwikkelingscyclus van applicaties. Samen gaan we een eenvoudig Tic-Tac-Toe-spel schrijven met één scherm (in Android OS heet dit Activiteit).

Gebrek aan ervaring met Java-ontwikkeling mag geen obstakel zijn voor het beheersen van Android. De voorbeelden zullen dus geen Java-specifieke constructies gebruiken (of ze zullen zoveel mogelijk worden geminimaliseerd). Als je bijvoorbeeld in PHP schrijft en bekend bent met de fundamentele principes van softwareontwikkeling, zal dit artikel voor jou het nuttigst zijn. Omdat ik geen expert ben op het gebied van Java-ontwikkeling, kan er op mijn beurt worden aangenomen dat de broncode niet in aanmerking komt voor het label “best practices voor Java-ontwikkeling”.

Het installeren van de benodigde programma's en hulpprogramma's

Ik zal een lijst maken noodzakelijke hulpmiddelen. Er zijn er 3:

1. IDE met ondersteuning voor Android-ontwikkeling:
   • Eclipse + ADT-plug-in;
   • IntelliJ IDEE Community-editie;
   • Netbeans + nbandroid-plug-in;

De hulpprogramma's worden geïnstalleerd in de hierboven aangegeven volgorde. Het heeft geen zin om alle genoemde IDE's te installeren (tenzij u problemen ondervindt bij het kiezen van de juiste). Ik gebruik IntelliJ IDEA Community Edition, een van de meest geavanceerde IDE's voor Java die momenteel beschikbaar zijn.

Een virtueel apparaat starten

Door AVD Manager te starten en aanvullende pakketten (SDK verschillende versies), kunt u beginnen met het maken van een virtueel apparaat met de benodigde parameters. Het begrijpen van de interface zou niet moeilijk moeten zijn.

Apparaatlijst

Een project maken

Ik ga altijd graag aan de slag en minimaliseer voorbereidende activiteiten, waaronder het maken van een project in de IO, vooral als het project educatief is en niet bedoeld is om te worden geproduceerd.

Dus Bestand->Nieuw project:

Door op de F6-knop te drukken, wordt het project samengesteld, gecompileerd en gelanceerd op het virtuele apparaat.

Projectstructuur

De vorige schermafbeelding toont de structuur van het project. Omdat we in dit artikel puur praktische doelen nastreven, zullen we ons alleen concentreren op de mappen die we tijdens het werk zullen gebruiken. Dit zijn de volgende mappen: gen, res En src.

In een map gen er zijn bestanden die automatisch worden gegenereerd wanneer het project wordt gebouwd. U kunt deze niet handmatig wijzigen.

De map res is bedoeld voor het opslaan van bronnen zoals afbeeldingen, teksten (inclusief vertalingen), standaardwaarden, lay-outs.

src- dit is de map waarin het grootste deel van het werk zal plaatsvinden, omdat hier bestanden met de broncode van ons programma worden opgeslagen.

Eerste regels

Zodra de Activiteit (applicatiescherm) is aangemaakt, wordt de methode onCreate() aangeroepen. De IDE vulde het met 2 regels:
super.onCreate(savedInstanceState); setContentView(R.layout.main);
De setContentView-methode (equivalent aan this.setContentView) stelt de XML-indeling voor het huidige scherm in. In wat volgt noemen we XML-lay-outs “lay-out” en schermen “Activiteit”. De lay-out in de applicatie zal als volgt zijn:

TableLayout is ideaal voor deze toepassing. ID kan aan elke resource worden toegewezen. IN in dit geval, TableLayout krijgt id = main_l toegewezen. Met de methode findViewById() krijgt u toegang tot de weergave:
privé TableLayout-indeling; // dit is een eigenschap van de klasse KrestikinolikiActivity public void onCreate(Bundle SavedInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.main); layout = (TableLayout) findViewById(R.id.main_l); buildGameField( );

Nu moeten we de buildGameField() -methode implementeren. Om dit te doen, moet u een veld in de vorm van een matrix genereren. Dit wordt gedaan door de klas Game. Eerst moet je een Square-klasse voor de cellen maken en een Player-klasse waarvan de objecten deze cellen zullen vullen.

Vierkant.java

pakket com.voorbeeld; openbare klasse Vierkant (privé Speler speler= nul;

public void fill(Speler speler) ( this.player = speler; ) public boolean isFilled() ( if (speler != null) ( return true; ) return false; ) public Player getPlayer() ( return speler; ) )

Speler.java

pakket com.voorbeeld; public class Player ( private String-naam; public Player(String-naam) ( this.name = naam; ) public CharSequence getName() ( return (CharSequence) naam; ) )

Alle klassen van onze applicatie bevinden zich in de src-map.

Game.java

pakket com.voorbeeld; public class Game ( /** * field */ private Square field; /** * Constructor * */ public Game() ( field = new Square; squareCount = 0; // het veld invullen voor (int i = 0, l = veldlengte;
Initialisatie van het spel in de KrestikinolikiActivity-constructor.

De buildGameField()-methode van de klasse KrestikinolikiActivity. Het voegt dynamisch rijen en kolommen toe aan de tabel (spelveld):
privéknopknoppen = nieuwe knop;
//(...) private void buildGameField() ( Vierkant veld = game.getField(); for (int i = 0, lenI = field.length; i
Regel 8 maakt een object dat de View.OnClickListener-interface implementeert. Laten we een geneste klasse Listener maken. Het is alleen zichtbaar vanuit KrestikinolikiActivity.
public class Listener implementeert View.OnClickListener ( private int x = 0; private int y = 0; public Listener(int x, int y) ( this.x = x; this.y = y; ) public void onClick(View view) (Knopknop = (Knop)weergave; ) )
Het blijft nodig om de spellogica te implementeren.

public class Game ( /** * spelers */ privé Speler spelers; /** * veld */ privé Vierkant veld; /** * is het spel begonnen? */ privé boolean gestart; /** * huidige speler */ privé Speler activePlayer; /** * Telt het aantal gevulde cellen */ private int gevuld; /** * Totaal aantal cellen */ private int squareCount; /** * Constructor * */ public Game() ( field = new Square; squareCount = 0; // het veld invullen voor (int i = 0, l = veldlengte; i

Bepaling van de winnaar
K.O suggereert dat de winnaar bij boter-kaas-en-eieren degene is die X of O op een lijn zet die gelijk is aan de lengte van het veld, verticaal, horizontaal of diagonaal. De eerste gedachte die in je opkomt is om voor elk geval methoden te schrijven. Ik denk dat het Chain of Responsobility-patroon in dit geval goed zou werken. Laten we de interface definiëren
pakket com.voorbeeld; openbare interface WinnerCheckerInterface ( openbare Speler checkWinner(); )

Omdat Game de verantwoordelijkheid heeft om de winnaar te bepalen, implementeert het deze interface. Het is tijd om virtuele "grensrechters" te creëren, die elk zijn kant zullen controleren. Ze implementeren allemaal de WinnerCheckerInterface-interface.

WinnerCheckerHorizontal.java

pakket com.voorbeeld; public class WinnerCheckerHorizontal implementeert WinnerCheckerInterface ( private Game game; public WinnerCheckerHorizontal(Game game) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer; Player lastPlayer = null; for (int i = 0, len = veldlengte;

pakket com.voorbeeld; public class WinnerCheckerVertical implementeert WinnerCheckerInterface (privé spelspel; openbaar WinnerCheckerVertical (spelspel) ( this.game = spel; ) public Player checkWinner() ( Vierkant veld = game.getField(); Speler currPlayer; Speler lastPlayer = null; for (int i = 0, len = veldlengte;

WinnerCheckerDiagonalLeft.java

pakket com.voorbeeld; public class WinnerCheckerDiagonalLeft implementeert WinnerCheckerInterface ( private Game game; public WinnerCheckerDiagonalLeft(Game game) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer; Player lastPlayer = null; int successCounter = 1; voor (int i = 0, len = veldlengte; i

WinnerCheckerDiagonalRight.java

pakket com.voorbeeld; public class WinnerCheckerDiagonalRight implementeert WinnerCheckerInterface ( private Game game; public WinnerCheckerDiagonalRight(Game game) ( this.game = game; ) public Player checkWinner() ( Square field = game.getField(); Player currPlayer; Player lastPlayer = null; int successCounter = 1; voor (int i = 0, len = veldlengte; i
Laten we ze initialiseren in de Game-constructor:
//(....) /** * "Rechters" =). Na elke zet controleren ze * of er een winnaar is */ private WinnerCheckerInterface winnaarCheckers;
//(....) public Game() ( //(....) winnaarCheckers = nieuwe WinnerCheckerInterface; winnaarCheckers = nieuwe WinnerCheckerHorizontaal(dit); winnaarCheckers = nieuwe WinnerCheckerVertical(dit); winnaarCheckers = nieuwe WinnerCheckerDiagonalLeft(dit); winnaarCheckers = nieuwe WinnerCheckerDiagonalRight(dit);
Implementatie van checkWinner():
public Player checkWinner() ( for (WinnerCheckerInterface winChecker: winnaarCheckers) ( Speler winnaar = winChecker.checkWinner(); if (winnaar != null) ( return winnaar; ) ) return null; )
Na elke zet controleren wij de winnaar. Laten we code toevoegen aan de onClick() -methode van de klasse Listener
public void onClick(Bekijk weergave) ( Knop knop = (Knop) weergave; Spel g = spel; Speler speler = g.getCurrentActivePlayer(); if (makeTurn(x, y)) ( knop.setText(speler.getName()) ; ) Spelerwinnaar = g.checkWinner(); (winnaar != null) ( gameOver(winnaar); ) if (g.isFieldFilled()) ( // als het veld gevuld is gameOver(); ) )
private void gameOver(Speler speler) ( CharSequence text = "Speler \"" + speler.getName() + "\" gewonnen!"; Toast.makeText(this, text, Toast.LENGTH_SHORT).show(); game.reset (); vernieuwen(); private void gameOver() ( CharSequence text = "Tekenen"; Toast.makeText(dit, tekst, Toast.LENGTH_SHORT).show(); game.reset(); vernieuwen(); )
Voor Java, gameOver(Speler) en gameOver() - verschillende methoden. Met behulp van de Builder Toast.makeText kunt u snel een melding maken en weergeven. refresh() werkt de status van het veld bij:
private void refresh() ( Vierkant veld = game.getField(); for (int i = 0, len = field.length; i

Klaar! Ik hoop dat dit artikel je heeft geholpen om vertrouwd te raken met de wereld van Android-ontwikkeling. Bedankt voor uw aandacht!

Video van de voltooide applicatie

Android OS nadert zijn tienjarig jubileum. Hoewel er zoveel tijd is verstreken sinds de eerste release van dit besturingssysteem, betekent dit niet dat de trein is vertrokken en dat het te laat is om te leren hoe je Android-applicaties kunt ontwikkelen. Sterker nog, nu is het tijd om te leren: nog nooit zijn er zoveel geweest effectieve manieren geweldige Android-apps maken.

En alle nieuwe Chromebooks hebben nu en voor altijd ondersteuning gekregen voor Android-applicaties: ze kunnen worden gedownload, geïnstalleerd en gestart, net als in hun oorspronkelijke omgeving. De markt voor Android-software groeit alleen maar. Je moet niet denken dat de tijd verstreken is; het is nog niet te laat om te beginnen. Alles wat u nodig heeft om aan de slag te gaan: maak u klaar, haal diep adem en ga verder geschikte taal programmeren - en begin uw reis.

Maar welke programmeertaal past het beste bij jou? Het kiezen van de juiste ontwikkeltool is de eerste taak die niemand beter kan doen dan jij. Veel hangt af van ervaring met programmeren (of gebrek aan ervaring in specifieke ontwikkelomgevingen), van persoonlijk comfort bij het gebruik van een bepaalde taal. Gelukkig is er een behoorlijke selectie. In dit artikel wordt een selectie besproken beste talen programmeren voor Android.

Als het om Android-apps gaat, is Java geenszins een verkeerde keuze. Naast het feit dat het zo is officiële taal programmering van dit besturingssysteem, het is ook de tweede meest voorkomende op de GitHub-bron, en het is al meer dan 20 jaar zo populair. Dit betekent dat er een groot aantal instructies en leerboeken over Java bestaan ​​en dat u zich absoluut geen zorgen hoeft te maken dat deze taal in de nabije toekomst verouderd zal raken.

Omdat de Java-taal zich wijd verspreid heeft over tientallen programmeerindustrieën, raden we u aan uw studie te beginnen met boeken die zich richten op Java in de context van het Android-ecosysteem. Natuurlijk is Java in alle omgevingen hetzelfde, maar afzonderlijke paradigma's en uitdrukkingen zullen een nieuwsgierige geest helpen snel de essentie van de ontwikkeling van Android-applicaties te begrijpen. Dit is precies de taak die de meeste boeken over dit onderwerp zichzelf stellen.

Het is de moeite waard om op te merken dat het vanwege de hoge leeftijd van Java een aantal zaken mist karakteristieke kenmerken inherent aan jongere talen. Voor nieuwelingen is dit misschien geen probleem, maar voor meer ervaren programmeurs die de taal van bijvoorbeeld Swift leren kennen, kan Java in eerste instantie claustrofobisch aanvoelen.

De programmeertaal Kotlin is speciaal gemaakt om aan te werken virtuele machines Java. Dit betekent dat Kotlin-applicaties worden gecompileerd in Java-code, waardoor ze op elke Java-compatibele machine kunnen worden uitgevoerd. En aangezien de meeste machines Java ondersteunen, is het gebruik van Kotlin een relatief eenvoudige manier om platformonafhankelijke software te ontwikkelen.

Het gebruik van Kotlin is een applicatie in softwareproduct alle beste aspecten van Java, zonder de nadelen ervan. De syntaxis en andere kenmerken van programmeren in Kotlin zijn modern, begrijpelijk en snel. Het is een hele handige ontwikkelomgeving. Waar Java omslachtig, onhandig en een oude taal lijkt, ziet Kotlin er comfortabel, fris en zelfs mooi uit. Tot op zekere hoogte kunnen we ervan uitgaan dat Kotlin specifiek voor ontwikkeling is gemaakt Android-applicaties.

De andere kant van de medaille? Kotlin is een zeer jonge taal. De eerste versies werden uitgebracht in 2011 en de officiële release vond pas in 2016 plaats. Er zijn ook goed nieuws: Kotlin is gratis en open source. We kunnen verwachten dat het zich met grote sprongen zal ontwikkelen. Maar het zal hoe dan ook enkele jaren duren voordat deze taal een werkelijk betrouwbare keuze blijkt te zijn.

C# is een ongelooflijke programmeertaal! Hij nam het beste van Java mee en liet het achter slechtste kenmerken van deze taal. En het ontwikkelde zich in dezelfde goede richting. Het lijkt erop dat Microsoft ooit de potentie van Java zag en besloot een eigen, betere versie te ontwikkelen.

Een groot nadeel van het gebruik van C# was lange tijd dat het alleen op Windows-systemen werkte: de taal is gebaseerd op het .NET Framework. Maar in 2014 veranderde deze omstandigheid: Microsoft heeft het .NET Framework open source gemaakt. Bovendien nam het bedrijf in 2016 Xamarin over, de ontwikkelaar van Mono (een project waarmee C#-programma's op verschillende platforms kunnen worden uitgevoerd).

Het resultaat van deze glorieuze daden is dat je vandaag de dag de Xamarin.Android- en Xamarin.iOS-omgevingen kunt gebruiken om mobiele applicaties te maken in Visual Studio of Xamarin Studio. Een uitstekende manier om met de ontwikkeling te beginnen, omdat het in de toekomst mogelijk zal zijn om de tools van deze taal op andere gebieden te gebruiken, bijvoorbeeld door complexe games te maken met Unity en C#. Visuele voorbeelden van applicaties gemaakt in Xamarin? MarketWatch – niet meer en niet minder.

Ten slotte merken we op dat het werken in Xamarin tot voor kort een vergoeding vereiste. Maar Microsoft heeft deze omgeving gratis gemaakt!

Hoewel Android geen native ondersteuning voor Python heeft, zijn er tools waarmee je apps in Python kunt schrijven en deze vervolgens kunt converteren naar native Android APK-apps. Een geweldig voorbeeld van de levensvatbaarheid van Python als een werkelijk krachtige taal. Bewonderaars Python-taal Degenen die willen proberen Android-applicaties te ontwikkelen, zullen deze kans zeker waarderen - zonder zich te verdiepen in de jungle van Java.

Een van de meest populaire oplossingen voor het converteren van Python-code naar APK is het Kivy-project. En het gaat niet eens om zijn aard open bron, en niet alleen binnen Windows-ondersteuning, Mac, Linux en iOS naast Android. Kivy is ontworpen om de ontwikkeling van applicaties echt te versnellen. U kunt het in ieder geval gebruiken als hulpmiddel voor het maken van prototypen. Je kunt zoveel doen met slechts een paar regels code!

Bij gebrek aan native Python-ondersteuning kun je echter niet profiteren van de voordelen van native Python. Android-omgeving. Applicaties die met Kivy zijn geschreven, hebben de neiging om in grotere APK's te compileren, hebben trage opstarttijden en presteren over het algemeen onder het gemiddelde. Elke nieuwe release is echter echt beter dan de vorige, en de mobiele apparaten van vandaag zijn zo krachtig dat suboptimale app-prestaties niet zoveel betekenen. Laat deze factor geen obstakel zijn.

Een paar voorbeelden van Android-apps geschreven in Kivy: Kognitivo en Barly.

1. HTML5 + CSS + JavaScript

Dit drietal talen, ooit gemaakt voor het ontwikkelen van front-end applicaties in een webomgeving, is inmiddels uitgegroeid tot iets meer. Nu zijn HTML5-, CSS- en JavaScript-tools voldoende om het meeste te creëren verschillende toepassingen en voor mobiele apparaten, en voor klassieke pc's. In wezen creëert een programmeur een webapplicatie die de kracht en magie van offline platforms kan benutten.

Om Android-applicaties te maken met deze methode, kunt u gebruiken Adobe-functies Cordova is een open source-framework dat ook iOS, Windows 10 Mobile, Blackberry, Firefox en vele andere ondersteunt. Hoe nuttig Cordova ook is, het vergt nog steeds serieus werk om een ​​fatsoenlijke app te maken. Daarom geven veel programmeurs de voorkeur aan het Ionic Framework-project (dat Cordova gebruikt voor implementatie op verschillende platforms).

Voorbeelden van Android-applicaties geschreven in HTML5, JavaScript en CSS: Untappd en TripCase.

Er is nog een andere mogelijkheid: het gebruik van de React Native-bibliotheek. Het kan worden ingezet op Android, iOS en Universal Windows-applicaties" Deze bibliotheek wordt gebruikt door specialisten van Facebook, Instagram en anderen grote bedrijven, zodat u kunt vertrouwen op de betrouwbaarheid ervan. Het is niet de gemakkelijkste leercurve, maar als het op het einde aankomt, heb je alle kracht, flexibiliteit en gemak die je maar kunt wensen binnen handbereik.

Lua is een oude scripttaal die oorspronkelijk is gemaakt als aanvulling op programma's die in meer geschreven zijn complexe talen: C, VB.NET, enz. Deze taal heeft enkele kenmerken die Lua onderscheiden van een aantal vergelijkbare talen - bijvoorbeeld het begin van arrays met 1 in plaats van 0, of de afwezigheid van native klassen.

Voor bepaalde taken kan Lua dus als de belangrijkste programmeertaal worden gebruikt. Het beste voorbeeld hiervan is de Corona SDK. Met Corona kun je krachtige, veelzijdige applicaties maken die kunnen worden ingezet op Windows, Mac, Android, iOS en zelfs Apple TV + Android TV. Corona heeft ook ingebouwde mogelijkheden om inkomsten te genereren, en het is een markt van behoorlijke omvang waar je nuttige plug-ins kunt vinden.

Meestal wordt Corona gebruikt om games te maken (voorbeelden zijn Fun Run 2 en HoPiko), maar er zijn ook voorbeelden van hulpprogramma's en zakelijke toepassingen (My Days en Quebec Tourism).

1. C/C++

Om Android-applicaties te maken, biedt Google officieel twee ontwikkelomgevingen:

• SDK (gebruikt Java);
• en NDK (gebruikt moedertalen zoals C en C++).

Houd er rekening mee dat om een ​​volledige applicatie te maken, het gebruik van C, C++ en “naked” Java niet zal werken. In plaats daarvan kunt u met de NDK bibliotheken maken waarvan de functies toegankelijk zijn via delen van Java-code vanuit uw applicatie.

Normaal gesproken is het niet nodig om de NDK te gebruiken. Deze omgeving mag niet als hoofdomgeving worden gebruikt, al was het maar omdat u meer in C/C++ zult moeten coderen in plaats van in Java. Het bestaan ​​van NDK is gerechtvaardigd voor die taken waarbij het nodig is om zoveel mogelijk prestaties uit te persen bij het uitvoeren van complexe computertaken. Met de NDK kunt u ook C- en C++-bibliotheken in uw toepassing implementeren.

Maar in andere gevallen is het de moeite waard om waar mogelijk bij Java te blijven. Het ontwikkelen van Android-applicaties in C/C++ is vele malen moeilijker dan in Java. En vaker wel dan niet, zijn de prestatiewinsten te klein.

Welke toepassingen wilt u aanpakken?

Boodschappers, spelletjes, rekenmachines, notitieblokken, spelers. De mogelijkheden zijn eindeloos! In veel opzichten zijn ze grenzeloos dankzij de hierboven genoemde programmeertalen en frameworks. Het is niet nodig om ze allemaal achter elkaar te bestuderen - alleen die die specifiek nuttig zijn bij het oplossen van uw probleem. Als je in de toekomst je eigen kennis moet uitbreiden, dan kun je op het juiste moment aan zelfstudie doen.

Ten slotte raden we aan blogs te lezen die gewijd zijn aan de ontwikkeling van mobiele applicaties. Ze stellen u in staat de ingrediënten te bepalen die nodig zijn om een ​​succesvolle mobiele applicatie voor te bereiden en helpen u veel moeilijkheden te overwinnen die onvermijdelijk op het pad van alle programmeurs voorkomen.

In deze tutorial leert u de basisprincipes van het schrijven van een Android-applicatie met behulp van de ontwikkelomgeving. Android-studio. Android-apparaten worden steeds gebruikelijker en de vraag naar nieuwe applicaties neemt alleen maar toe. Android Studio is een gratis, gebruiksvriendelijke ontwikkelomgeving.

Voor deze tutorial is het het beste als je op zijn minst enige kennis van Java hebt, aangezien dat de taal is die door Android wordt gebruikt. Er zal niet te veel code in deze tutorial staan, omdat ik ervan uitga dat je enige kennis van Java hebt of klaar bent om iets te vinden dat je nog niet weet. Het maken van een applicatie duurt 30-60 minuten, afhankelijk van hoe snel u alle benodigde programma's downloadt en installeert. Na het volgen van deze tutorial over hoe u uw eerste Android-app kunt maken, vindt u misschien een leuke nieuwe hobby of begint u zelfs een carrière als beginnende ontwikkelaar van mobiele apps.

Fase 1: Android Studio installeren

1. U moet de JDK ( Java-ontwikkelingskit) en JRE (Java Runtime Environment). Je kunt het downloaden via deze link. Daar selecteert u de versie voor uw besturingssysteem, accepteert u de licentieovereenkomst, downloadt en installeert u.
2. Ga nu hier http://developer.android.com/sdk/index.html en download (let op, je zult ongeveer 3 gigabytes moeten downloaden).
3. We starten de installatie en volgen de instructies.

Fase 2: Maak een nieuw project

1. Open Android-studio.
2. In het menu " Snel beginnen", selecteer" Start een nieuw Android Studio-project».
3. In het venster " Nieuw project maken"(het geopende venster), geef uw project een naam " Hallo Wereld».
4. Bedrijfsnaam optioneel.*
5. Klik op " Volgende».
6. Zorg ervoor dat het selectievakje alleen is ingeschakeld " Telefoon en tablet».
7. Als u van plan bent uw eerste applicatie op uw telefoon te testen, zorg er dan voor dat u dat doet juiste versie Android (niet ouder dan die op de telefoon).
8. Klik op " Volgende».
9. Selecteer " Lege activiteit».
10. Klik op " Volgende».
11. Laat alle overige velden ongewijzigd.
12. Klik op " Finish».

*Typische bedrijfsnaam voor Android-projecten is “example.name.here.com”.

Fase 3: De begroeting bewerken

1. Ga naar het tabblad activiteit_voornaamst.xml, waarschijnlijk is deze al actief.
2. Zorg ervoor dat het tabblad onder aan het scherm actief is Ontwerp(hoogstwaarschijnlijk is dit waar).
3. Sleep de zin " Hallo, Wereld! »van links bovenste hoek telefoon naar het midden van het scherm.
4. Aan de linkerkant van het scherm bevindt zich een mappenboom. Open de map met de naam " waarden».
5. Dubbelklik in deze map op het bestand " snaren.xml».
6. Zoek in dit bestand de regel met de tekst “ Hallo wereld!" en voeg toe aan deze tekst " WelkomnaarMijnapp! ».
7. Keer terug naar de " activiteit_voornaamst.xml».
8. Zorg ervoor dat uw tekst gecentreerd op uw telefoonscherm staat en de tekst ' Hallowereld! WelkomnaarMijnapp! ».

Stap 4: Voeg een knop toe

1. Op de " activiteit_voornaamst.xml"selecteer het tabblad" Ontwerp».
2. Zoek in de kolom aan de linkerkant van het venster waar de telefoon zich bevindt een map met de naam ' Widgets" Daar zitten verschillende knoppen op.
3. Pak de " Knop» en sleep het naar uw telefoonscherm. Het moet gecentreerd zijn op het scherm, direct onder uw tekst.
4. Zorg ervoor dat de knop nog steeds is geselecteerd (blauw kader eromheen).
5. Rechtsonder bevindt zich een venster met de eigenschappen van het geselecteerde object. Scroll naar beneden en vind de regel met de naam " tekst».
6. Verander de tekst " Nieuwe knop" naar " Volgende pagina».

Fase 5: Creëer een tweede activiteit

1. Op de top van de boom bestandssysteem project, klik met de rechtermuisknop op de map met de naam " app».
2. Selecteer Nieuw > Activiteit > Lege activiteit.
3. In het venster dat verschijnt bovenste regel binnenkomen " Tweede activiteit».
4. Klik op " Finish».
5. Ga naar de " activiteit_seconde.xml" en zorg ervoor dat het tabblad " onderaan is geselecteerd Ontwerp».
6. Verplaats de tekst van de linkerbovenhoek van de telefoon naar het midden van het scherm, zoals we in de vorige stappen deden.
7. Zorg ervoor dat het tekstblok nog steeds is geselecteerd (blauw kader) en zoek in de rechter benedenhoek van de eigenschappen van het object naar de regel " Identiteitskaart"en ga daar binnen" tekst2 ».
8. Selecteer in de linkerbovenhoek (in de projectboom) opnieuw dubbelklikken « snaren.xml».
9. Onder de lijn Hallo wereld! Welkom bij mijn app!

   toevoegen volgende regel

   Welkom op de tweede pagina!

10. Keer terug naar de " activiteit_second.xml».
11. Selecteer het tekstblok opnieuw.
12. Zoek in de rechter benedenhoek van de objecteigenschappen de regel “ tekst" en ga daar naar binnen «@ snaar/seconde_pagina».
13. Zorg ervoor dat het tekstvak nu ' Welkomnaardesecondepagina! ' en de blog bevindt zich in het midden van het scherm.

Fase 6: Schrijf de actie voor de knop

Fase 7: Het testen van de applicatie

1. Klik in de werkbalk bovenaan het Android Studio-venster op het groene afspeelsymbool.
2. In het venster " KiezenApparaat» selecteer het item « Launchemulator» en selecteer het apparaat.
3. Klik op de knop OK».
4. Wanneer de emulator start (dit kan lang duren), wordt de applicatie automatisch geopend op het virtuele apparaat.
5. Zorg ervoor dat alle tekst correct wordt weergegeven en dat u door op de knop te klikken naar de volgende pagina gaat.

Aandacht: Als u het bericht ontvangt " HAX-kernelmodule is niet geïnstalleerd!", dan zijn er twee mogelijke opties. Feit is dat alleen moderne Intel-processors deze virtualisatie ondersteunen en je deze alleen in het BIOS hoeft in te schakelen. Als u een processor heeft die deze functie niet ondersteunt, moet u de applicatie op een echte telefoon testen of een emulator van derden gebruiken in plaats van de ingebouwde.

Hoe u een .apk-bestand kunt verkrijgen in Android Studio

Naar mijn mening wordt dit onderwerp goed behandeld in dit artikel, dus ik zal het niet herhalen. Ik vond het het gemakkelijkst voor de eerste les Handmatige methode.

Zodra u het bestand heeft ontvangen, kunt u het naar uw telefoon kopiëren en de app installeren.

Fase 8: Resultaat

Gefeliciteerd! U bent zojuist klaar met het schrijven van uw eerste Android-applicatie met enige basisfunctionaliteit. De voltooide applicatie moet een welkomstpagina voor de gebruiker hebben en een knop die de gebruiker naar de tweede pagina brengt.

Je hebt kort kennis gemaakt met de ontwikkeling van applicaties voor Android en hebt misschien bij jezelf de wens gewekt om alles te leren wat nodig is om je verder in deze richting te ontwikkelen.

Het artikel beschrijft de belangrijkste problemen bij het maken van applicaties voor Android.
Worden overwogen basisconcepten Android-programmering.
Als voorbeeld wordt het maken van een Sudoku-spel uit het boek Hallo, Android - Ed Burnette beschreven.
Let op: er zijn veel screenshots.

1. Ontwikkelingsproblemen

Android is een uniek besturingssysteem. De applicatieontwikkelaar moet de kenmerken en nuances ervan kennen om een ​​goed resultaat te verkrijgen. Er zijn enkele uitdagingen waarmee rekening moet worden gehouden bij het ontwerpen van (). Laten we ze kort opsommen:
1) De applicatie vereist twee keer (of zelfs vier) meer ruimte voor installatie dan originele maat toepassingen.
2) De snelheid van het werken met bestanden op de ingebouwde flashdrive neemt tienvoudig af naarmate de vrije ruimte afneemt.
3) Elk proces kan maximaal 16 MB (soms 24 MB) gebruiken RAM.

2. Principes voor het ontwikkelen van productieve applicaties voor Android

Nodig voor werk Android-SDK en Eclipse. Er staat geschreven hoe je alles kunt installeren en aan de slag kunt gaan.

Volg deze stappen om een ​​project in Eclipse te laden:
1) Pak het project uit in een aparte map in de Eclipse-werkruimte.
2) Selecteer het menu-item Bestand->Nieuw->Android-project.
3) Selecteer in het dialoogvenster Nieuw Android-project de optie Project maken van bestaande bron.
4) Geef in het veld Locatie het pad op naar de map met het project. Klik op Volgende.

Programmamenu

Het spelmenu wordt beschreven in het bestand res/layout/main.xml. De interfacebeschrijving kan worden bewerkt als XML of als een gerenderde interface. Gebruik de tabbladen onder aan het inhoudsweergavegebied om te schakelen.

Meestal bevinden de besturingselementen zich in een container, in ons geval een LinearLayout. Het rangschikt alle elementen in één kolom.

Bronnen

Houd er rekening mee dat alle tekstlabels (android:text) gegevens uit bronnen halen. De invoer android:text="@string/main_title" geeft bijvoorbeeld aan dat de tekst moet worden gezocht in het bestand res/values/string.xml in een knooppunt met de naam main_title (Android Sudoku). De achtergrondkleur is ook opgenomen in de bronnen (android:background="@color/background") maar in het color.xml-bestand (#3500ffff). Er kan een fout optreden bij het openen van bronbestanden in de editor. Maar u kunt altijd overschakelen naar XML-weergave.

Besturingselementen die via code toegankelijk moeten zijn, moeten een ID hebben. Knoppen hebben een id (android:id="@+id/continue_button") zodat er een klikhandler aan de knop kan worden gekoppeld. Het plusteken geeft aan dat u een ID voor de knop moet aanmaken in het bestand /gen/org.example.sudoku/R.java (public static final int continue_button=0x7f0b000b;). Dit bestand wordt automatisch gegenereerd en het wordt niet aanbevolen om het te wijzigen. Het bestand bevat de klasse R, waarmee u toegang hebt tot elk interface-element en andere bronnen.

Vensters maken

Laten we overwegen een venster te maken met informatie over het programma. De lay-out van dit venster bevindt zich in het bestand /res/layout/about.xml. De klasse Activity wordt beschreven in het bestand /src/org.example.sudoku/About.java. De activiteit is gekoppeld aan markeringen in het bestand AndroidManifest.xml. Dit bestand kan via een editor of als XML worden bekeken. U kunt verschillende secties van het bestand selecteren op verschillende editortabbladen. Het gedeelte Toepassing bevat activiteitsparameters. Houd er rekening mee dat de parameter Thema :style/Theme.Dialog is. Hierdoor lijkt de vensterstijl meer op een modaal dialoogvenster.

Het venster met informatie over het programma wordt vanuit de Sudoku-klasse opgeroepen door op de knop Info te klikken. De klasse Sudoku is zo geschreven dat deze de Click-gebeurtenis zelf afhandelt (de openbare klasse Sudoku breidt Activity uit en implementeert OnClickListener). De public void onClick(View v)-methode bepaalt welke knop de gebeurtenis heeft geactiveerd en voert de bijbehorende code uit. Om het venster Over weer te geven, wordt de overeenkomstige Intent aangeroepen.
geval R.id.about_button:
Intentie i = nieuwe intentie (dit, About.class);
startActiviteit(i);
pauze;

Er kunnen ook gebeurtenishandlers op worden geïnstalleerd specifieke elementen beheer. Wanneer de klasse in de klasse Keypad bijvoorbeeld wordt gemaakt, worden handlers voor individuele knoppen geïnstalleerd in de methode setListeners().

Eenvoudige dialoog

De gebruiker moet de mogelijkheid krijgen om de moeilijkheidsgraad te kiezen. Dit is een kleine dialoog waarin u een van de verschillende opties moet kiezen. Ik ben erg blij dat je hiervoor geen aparte Intent hoeft te maken, maar gewoon de klasse AlertDialog hoeft te gebruiken.
Laten we eens kijken naar het proces van het starten van een nieuw spel. De gebruiker klikt op de knop Nieuw spel. De klikhandler is een methode van de Sudoku-klasse - onClick. Vervolgens wordt de openNewGameDialog-methode aangeroepen, die het dialoogvenster voor het selecteren van de moeilijkheidsgraad toont en het spel start met de geselecteerde moeilijkheidsgraad. Dit dialoogvenster is gebouwd met behulp van de klasse AlertDialog.

Privé ongeldig openNewGameDialog() ( nieuwe AlertDialog.Builder(this).setTitle(R.string.new_game_title).setItems(R.array.difficulty, new DialogInterface.OnClickListener() ( openbare ongeldig onClick(DialogInterface dialoginterface, int i) ( startGame (ik); )).toon();

Houd er rekening mee dat de inhoud van het dialoogvenster (een reeks knoppen) is opgebouwd uit een reeks tekenreeksen R.array.difficulty. Er wordt onmiddellijk een dialoogknopklikhandler toegewezen, die, op basis van het nummer van de ingedrukte knop, een nieuw spel met een bepaalde moeilijkheidsgraad start door de startGame-methode aan te roepen.

Grafisch

De klasse Game is verantwoordelijk voor de spellogica. Hier worden taken geladen en worden de winnende voorwaarden gecontroleerd. De klasse Game is een activiteit, maar de interface wordt niet beschreven in XML, maar wordt gemaakt door code. De onCreate-methode creëert een weergave:

PuzzleView = nieuwe PuzzleView(dit);
setContentView(puzzelweergave);
puzzelView.requestFocus();

PazzleView is een klasse afgeleid van View, het tekent het speelveld en verwerkt schermaanraakgebeurtenissen (onTouchEvent-methode) en toetsaanslagen (onKeyDown-methode).

Laten we eens kijken naar het tekenproces in Android. Om te tekenen, moet je de onDraw-methode overbelasten. De methode ontvangt het Canvas-object waarmee wordt getekend. Om kleuren in te stellen, worden objecten van de klasse Paint gemaakt. De kleur wordt opgegeven in ARGB-formaat. Het is beter om kleur op te slaan als bronnen (colors.xml-bestand). Verf is niet alleen een klasse voor het opslaan van kleurinformatie. Wanneer u bijvoorbeeld tekst tekent, bevat deze informatie over de arceringsmethode, het lettertype en de tekstuitlijning.

Canvas bevat een reeks methoden voor het tekenen van afbeeldingen (drawRect, drawLine, drawPath, drawText en andere).

Om afbeeldingen te optimaliseren, is het beter om af te zien van het maken van objecten en onnodige berekeningen binnen de onDraw-methode (het beschouwde voorbeeld van grafische implementatie is niet optimaal).

Muziek

De klasse MediaPlayer wordt gebruikt om muziek af te spelen. Muziek voor de game is toegevoegd aan de bronnen. U hoeft alleen maar de benodigde bestanden naar de map /res/raw te kopiëren (WAV, AAC, MP3, WMA, AMR, OGG, MIDI-formaten).
Eerst moet u een exemplaar van de MediaPlayer-klasse maken:
mp = MediaPlayer.create(context, bron);
hier is context meestal de klasse die de lancering van muziek initieert, resource is de identificatie van de resource met muziek. Om het afspelen te regelen, gebruikt u de start-, stop- en release-methoden.

In het spel wordt muziek gespeeld in het hoofdmenu (gestart vanuit de Sudoku-klasse) en in speelplezier(uitgevoerd vanuit de Game-klasse). De klasse Muziek is gemaakt om het afspelen te regelen. De klasse bevat een statische instantie van MediaPlayer, waardoor het niet meer nodig is om voor elke lancering van de audiobron een afzonderlijk project te maken.

In de klassen Sudoku en Game worden de methoden onResume en onPause overschreven, waarbij muziek begint wanneer de activiteit start en stopt wanneer deze wordt gedeactiveerd.

Conclusies

Het voorbeeld dat in het artikel wordt besproken, is niet al te ingewikkeld, waardoor u het zonder kunt begrijpen bijzondere inspanning. Tegelijkertijd raakt het verschillende aspecten van de Android-ontwikkeling.

P.S. Veel dank aan de gebruiker

Hoe u een mobiele applicatie maakt in Android Studio

Android Studio is een geïntegreerde ontwikkelomgeving (IDE) gebaseerd op IntelliJ IDEA, die Google de officiële IDE voor Android-applicaties noemt.

Deze handleiding beschrijft ontwikkeling van Android-applicaties:

• Navigeer tussen bestanden met behulp van Verkenner
• Het AndroidManifest.xml-bestand installeren
• Bestanden importeren in een project
• Geavanceerde layout-editor met dynamische preview-functie
• Logcat en Android Monitor gebruiken om applicaties te debuggen

Aan de slag met Android Studio

Start Android Studio in een venster Installatiewizard voor Android Studio selecteren Start een nieuw Android Studio-project(een nieuw project starten).

In het raam Nieuw project maken selecteren Applicatienaam(applicatienaam) voer als Fortune ball het bedrijfsdomein in; in het veld Projectlocatie selecteer de locatie waar de applicatie wordt opgeslagen. Klik Volgende.

Er is een raam voor je Target Android-apparaten. Selecteer Telefoon en tablet. In het veld Minimale SDK geef dit alstublieft aan API-15. Klik Volgende.

In het raam Voeg een activiteit toe aan Mobiel selecteren Basisactiviteit. Evalueer alle opties, dit venster geeft een overzicht van de beschikbare lay-outs.

Klik Volgende.

In het raam Pas de activiteit aan, waarvan de schermafbeelding hieronder is geplaatst, kun je wijzigen Activiteitsnaam(naam activiteit), Lay-outnaam(lay-outnaam), Titel(gewone naam) en Naam van menubron(bronmenunaam). Laat de standaardwaarden staan ​​en klik Finish.

Na enkele seconden verschijnt het volgende venster:

Hetzelfde venster verschijnt op uw apparaat of emulator. De emulator functioneert als een apparaat en het laden ervan duurt enige tijd.

Dit is al een aanvraag. Hij mist veel, maar nu kan hij door naar de volgende stap.

Project- en bestandsstructuur

Het venster toont de projectbestanden.

Het vervolgkeuzemenu (schermafbeelding hieronder) bevat verschillende filters voor bestanden. De belangrijkste zijn Project en Android.

Het Projectfilter toont alle applicatiemodules - elk project bevat minstens één module. Andere soorten modules zijn onder meer modules uit bibliotheken van derden, of modules uit andere Android-applicaties (zoals Android Wear-applicaties, Android TV). Elke module heeft zijn eigen set kenmerken, waaronder een gradle-bestand, bronnen en bronbestanden (java-bestanden).

Opmerking. Als het project niet geopend is, klikt u op het tabblad Project aan de linkerkant van het paneel, zoals weergegeven in de schermafbeelding. Standaard is het Android-filter geïnstalleerd, waarmee bestanden worden gegroepeerd een bepaald type. Op het hoogste niveau ziet u de volgende mappen:

• manifesteert
• Gradle-scripts

In de volgende secties wordt elk van deze mappen gedetailleerd beschreven, te beginnen met manifesten.

Overzicht van AndroidManifest.xml

Elke Android-applicatie heeft een AndroidManifest.xml-bestand, dat zich in de map manifesten bevindt. Dit XML-bestand informeert uw systeem over de vereisten van de applicatie. De aanwezigheid van dit bestand is verplicht, omdat het het Android-systeem hierdoor in staat stelt een applicatie te maken.

Open de map manifesten en AndroidManifest.xml. Dubbelklikken opent het bestand.

De manifest- en toepassingstags zijn nodig voor manifest en verschijnen slechts één keer.

Elke tag definieert ook een reeks attributen, samen met de naam van het element. Sommige attributen in de toepassing kunnen er bijvoorbeeld als volgt uitzien:

android:pictogram, android:label en android:thema

In manifest kan onder meer het volgende voorkomen:

• use-permission: Vraagt ​​om speciale toestemming die aan de toepassing wordt gegeven correcte werking. Een applicatie moet de gebruiker bijvoorbeeld om toestemming vragen om toegang te krijgen tot het netwerk - als u de toestemming android.permission.INTERNET toevoegt.
• activiteit: rapporteert een activiteit die gedeeltelijk verantwoordelijk is voor de visuele gebruikersinterface en logica. Elke activiteit die in de applicatie wordt aangeboden, moet aan het manifest worden toegevoegd. Het systeem zal een ongemarkeerde activiteit niet opmerken en deze zal niet in de applicatie worden weergegeven.
• service: Voegt een service toe die u wilt gebruiken om langlopende bewerkingen of geavanceerde API-communicatie met andere applicaties te implementeren. Een voorbeeld in dit geval is een netwerkoproep waarmee een applicatie gegevens ontvangt. In tegenstelling tot activiteiten hebben diensten geen gebruikersinterfaces.
• ontvanger: Dankzij de uitgezonden berichtontvanger ontvangt de applicatie signalen over systeem berichten of berichten van andere applicaties, zelfs als andere applicatiecomponenten niet actief zijn. Een voorbeeld van een dergelijke situatie is een batterij met laag niveau in rekening brengen en hiervan melding maken aan het besturingssysteem.

Een volledige lijst met tags is te vinden in het manifestbestand op de Android Developer-website.

Manifest bestandsinstellingen

Voeg het volgende kenmerk toe aan activiteit:

android:screenOrientation=”portret”. om het scherm alleen in portretmodus te zetten. Als dit niet gebeurt, bevindt het scherm zich, afhankelijk van de locatie van het apparaat, in landschaps- of portretmodus. Na het toevoegen van het attribuut manifest-bestand zal er uitzien als de schermafbeelding.

Maak de applicatie en voer deze uit. Als u uw apparaat test, draai het dan om en zorg ervoor dat het scherm niet beweegt landschapsmodus als u deze mogelijkheid hebt beperkt in het AndroidManifest.

Gradle-overzicht

Laten we verder gaan naar Gradle. Gradle verandert een Android-project in een installeerbare APK die op apparaten kan worden geïnstalleerd. Het build.gradle-bestand is aanwezig in Gradle-scripts, op twee niveaus: module en project.

Open het build.gradle-bestand (Module:app). U ziet de standaard geleidelijke installatie:

plugin toepassen: "com.android.application" android (compileSdkVersion 25buildToolsVersion "25.0.2" defaultConfig (applicationId "com.raywenderlich.fortuneball" minSdkVersion 15targetSdkVersion 25versionCode 1versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitR unner") buildTypes (release (minifyEnabled falseproguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"))) afhankelijkheden (compileer fileTree(dir: "libs", include: ["*.jar"])androidTestCompile( " com.android.support.test.espresso:espresso-core:2.2.2", (exclusief groep: "com.android.support", module: "support-annotations"))compileer "com.android.support:appcompat - v7:25.1.0"compileer "com.android.support:design:25.1.0"testCompileer "junit:junit:4.12")

Laten we eens kijken naar de belangrijkste componenten:

• plug-in toepassen: 'com.android.application' past de Android-plug-in toe op ouderniveau en stelt taken beschikbaar hoogste niveau, die nodig zijn om de applicatie te maken.
• Naast de sectie android(...) staan ​​instellingsopties zoals targetSdkVersion. De doel-SDK voor uw toepassing moet zich bevinden op het nieuwste niveau API. Een ander belangrijk onderdeel is minSDKVersion (definieert de minimale SDK-versie die op het apparaat moet worden geïnstalleerd om de applicatie te kunnen uitvoeren). Als de SDK-versie bijvoorbeeld 14 is, kan de applicatie niet op dat apparaat worden uitgevoerd, omdat in dit specifieke geval de minimaal ondersteunde versie 15 is.
• Het laatste onderdeel zijn afhankelijkheden (…). Het is noodzakelijk om te noteren dat u 'com.android.support:appcompat-v7:VERSION' compileert en 'com.android.support:design:VERSION' compileert. Ze bieden ondersteuning en compatibiliteit van functies van nieuwe en oude API's.

Naast Android-compatibiliteitsbibliotheken kunt u bibliotheken van derden toevoegen aan de component dependencies(...). De animatiebibliotheek bevat bijvoorbeeld UI-effecten. Zoek afhankelijkheden en voeg vervolgens de volgende twee regels toe:

afhankelijkheden ( ... compileer "com.daimajia.easing:library:2.0@aar" compileer "com.daimajia.androidanimations:library:2.2@aar")

Hier kunt u afhankelijkheden van derden toevoegen. Bibliotheken worden automatisch gedownload en geïntegreerd in Android Studio. Klik op Nu synchroniseren om deze afhankelijkheden in uw toepassing te integreren.

Synchronisatie duurt enkele seconden. Gradle-updates verschijnen op het tabblad Berichten van het onderste paneel.

Dit zijn alle instellingen die je voorlopig in Gradle nodig hebt. Dergelijke manipulaties zullen animatie aan de applicatie toevoegen.

Bestanden importeren

Bij het ontwikkelen van een Android-applicatie is integratie met andere bronnen belangrijk: afbeeldingen, aangepaste lettertypen, geluiden, video's, enz. Deze bronnen worden geïmporteerd in Android Studio en in de juiste mappen geplaatst, waardoor het besturingssysteem de juiste bronnen voor de applicatie kan selecteren. sollicitatie. Onze Fortune Ball-applicatie zal afbeeldingen in de tekenbare mappen moeten importeren. Deze mappen kunnen afbeeldingen of speciale bestanden XML-tekenbestanden (dat wil zeggen dat u vormen kunt tekenen met behulp van XML-code en deze in uw lay-outs kunt gebruiken).

Ga in Android Studio van Android naar Project

Open de map res (app> src> main). Klik met de rechtermuisknop op de map res en selecteer Nieuw > Android-bronmap.

Er verschijnt een venster met de naam Nieuwe bronnenmap.

Selecteer in de vervolgkeuzelijst Resourcetype de tekenbare optie. In de lijst Beschikbare kwalificaties selecteert u Dichtheid en klikt u vervolgens op de knop die in de schermafbeelding is gemarkeerd.

Selecteer in het volgende venster XX-High Density in de Density-lijst. Klik op OK.

Herhaal alles om de mappen drawable-xhdpi, drawable-hdpi en drawable-mdpi te maken. Selecteer respectievelijk X-High, High en Medium Density in de Density-lijst.

Elke map met een dichtheidskwalificatie (d.w.z. xxhdpi, xhdpi, hdpi) bevat afbeeldingen die zijn gekoppeld aan een specifieke dichtheid of resolutie. De map drawable-xxhdpi bevat bijvoorbeeld een afbeelding hoge dichtheid betekent dit dat een Android-apparaat met een scherm met hoge resolutie de afbeelding uit deze map zal halen. Het beeld ziet er goed uit op alle Android-apparaten, ongeacht de schermkwaliteit. Meer informatie over schermdichtheid vindt u in de Android-documentatie.

Nadat u alle "getekende" mappen heeft gemaakt, kunt u teruggaan naar de uitgepakte inhoud in de map en de afbeelding uit elke map kopiëren (cmd + C) en deze in de overeenkomstige Android Studio-map plaatsen (cmd + V).

Nadat u de bestanden heeft geplaatst, ziet u het venster Kopiëren. Selecteer OK.

XML-weergave en dynamische lay-outvoorbeelden

Het creëren van een lay-out waarmee gebruikers kunnen communiceren, is een belangrijk onderdeel van het proces. In Android Studio kan dit in de layout-editor. Open content_main.xml vanuit res/layout. Op het tabblad Ontwerpen kunt u interface-elementen (knoppen, tekstvelden) verplaatsen.

Rechts van Ontwerp bevindt zich een tabblad Tekst waarmee u XML rechtstreeks in de lay-out kunt bewerken.

Voordat u het uiterlijk maakt, moet u enkele waarden definiëren. Open strings.xml op het tabblad res/values ​​en voeg het volgende toe:

Stel de vraag voor, die u met “ja” of “nee” kunt beantwoorden, en klik vervolgens op de magische bal.

strings.xml bevat alle tekenreeksen die in de toepassing voorkomen. Het scheiden van deze regels in afzonderlijke bestanden maakt internationalisering eenvoudiger omdat U heeft alleen een stringbestand nodig voor elke taal die vereist is in de applicatie. Zelfs als u niet van plan bent uw applicatie in andere talen te vertalen, wordt het gebruik van een stringbestand altijd aanbevolen.

Open dimens.xml in res/values ​​en voeg het volgende toe:

15 sp20 sp

dimens.xml bevat dimensionale waarden, limietafstanden voor lay-outs, tekstgrootte, enz. Het wordt aanbevolen om deze gegevens in een bestand op te slaan, zodat deze in de toekomst kunnen worden gebruikt om lay-outs te maken.

Ga terug naar content_main.xml en vervang de volledige inhoud van het bestand door de volgende code:

Deze vrij grote code creëert een lay-out voor een applicatie genaamd FortuneBall. Op het hoogste niveau hebt u een RelativeLayout toegevoegd (de relatieve lay-out definieert de positie van de onderliggende componenten ten opzichte van de bovenliggende component). RelativeLayout kan worden uitgerekt zodat deze past bij de grootte van de bovenliggende component.

Relatieve opmaak voegt twee stukken tekst toe, een afbeelding en een knop. Al deze details zijn zichtbaar in de volgorde waarin ze zijn toegevoegd. De inhoud ervan kan worden gelezen in strings.xml (tekst) en tekenbaar (afbeeldingen).

Merk op dat tijdens het updaten van content_main.xml het Preview-venster de gebruikersinterface bijwerkt:

Opmerking: als het voorbeeldvenster niet zichtbaar is, klikt u op het tabblad Tekst op de knop Voorbeeld in het venster van de markup-editor aan de rechterkant.

Creëer en start.

En nu hebt u de applicatie-indeling gemaakt. Maar in dit stadium is het gewoon een mooi beeld - klikken op de knop leidt nergens toe.

Activiteit en weergave combineren

U kunt Java-bestanden in app/src/main/java gebruiken om logische verbindingen in de toepassing tot stand te brengen.

Open MainActivity.java en voeg deze gegevens toe onder de bestaande:

Importeer java.util.Random; importeer android.view.View; importeer android.widget.Button; importeer android.widget.ImageView; importeer android.widget.TextView; importeer com.daimajia.androidanimations.library.Techniques; importeer com.daimajia.androidanimations.library.YoYo;

De eerste vijf importbewerkingen verwijzen naar de overeenkomstige klassen in uw code: Random, View, Button, ImageView en TextView. De volgende twee importgegevens geven aan dat u twee klassen uit bibliotheken gaat gebruiken, incl. build.gradle voor animaties. Voeg in MainActivity.java, in de MainActivity-klasse, het volgende toe:

String FortuneList = ("Reken er niet op", "Vraag het later opnieuw", "U kunt erop vertrouwen", "Zonder enige twijfel", "Vooruitzichten zijn niet zo goed", "Dat is beslist zo", "Tekenen wijs naar ja", "Ja zeker", "Ja", "Mijn bronnen zeggen NEE"); TextView mFortuneText;Button mGenerateFortuneButton;ImageView mFortuneBallImage;

In dit korte stukje code heb je 4 variabelen voor de activiteit ingesteld. De eerste zijn de lijnen die de mogelijke statussen definiëren, de andere drie zijn de UI-elementen die u in de lay-out/opmaak hebt gemaakt.

Vervang nu de inhoud van de methode onCreate() door het volgende:

// 1:super.onCreate(savedInstanceState);// 2:setContentView(R.layout.activity_main);Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);setSupportActionBar(toolbar);// 3:mFortuneText = (TextView) findViewById(R.id.fortuneText);mFortuneBallImage = (ImageView) findViewById(R.id.fortunateImage);mGenerateFortuneButton = ( Knop) findViewById(R.id.fortuneButton); // 4:mGenerateFortuneButton.setOnClickListener (nieuw Weergave.OnClickListener() (@Overridepublic void onClick( Weergave bekijken) (// 5:int index = nieuw Willekeurig().nextInt(fortuneList.length);mFortuneText.setText(fortuneList);// 6:YoYo.with(Techniques.Swing).duration(500).playOn(mFortuneBallImage);)));

• Controleer of de activiteit gereed is (implementatie van superklasse).
• Geef op dat de lay-out voor deze activiteit wordt weergegeven door de lay-out die u eerder hebt gemaakt, controleer de werkbalk.
• Vul de waarden in van de drie variabelen die u eerder hebt gemaakt in de weergavecomponenten van de lay-out met behulp van de findViewById-methode. De id-waarde is hetzelfde als in de XML-indeling.
• Voeg een OnClickListener toe aan de knop. Dit is een eenvoudige klasse die de functionaliteit inkapselt (verpakt) die een klik op een knop oproept.
• Selecteer een aangepaste optie uit de FortuneList voor deze toepassing en werk de Fortune-tekst bij om deze weer te geven.
• Gebruik een bibliotheek van derden om de afhankelijkheid aan het gradle-bestand toe te voegen en zo animatie aan de applicatie toe te voegen.

Het is bijna klaar. Maar je moet de zwevende knop verwijderen. Ga naar res/layout en open Activity_main.xml.

Dit lay-outbestand bevat een link naar de content_main.xml die u eerder hebt bewerkt. Het definieert standaard de inhoud (werkbalk en zwevende actieknop). In deze specifieke toepassing (Fortune Ball) is een zwevende knop echter niet nodig. Verwijder daarom het volgende codeblok uit het XML-bestand:

Er is geen zwevende knop meer in de rechter benedenhoek.

Stel een vraag (Wat is mijn fortuin?) - druk op de knop. Controleer de applicatie.

Android-monitor

Android Studio bevat een grote verscheidenheid aan tools. Open het tabblad Android Monitor onder aan het Android Studio-venster.

Hier vind je veel mogelijkheden voor de ontwikkelaar.

• Met de camera- en afspeelknop aan de linkerkant kun je screenshots maken en video's opnemen.
• Het vergrootglas opent een aantal extra opties, zoals het analyseren van het geheugen van de applicatie.
• De Layout Inspector biedt een visuele interface die bepaalt waarom de interface van een applicatie er op een bepaalde manier uitziet.

LogCat biedt een gedetailleerd overzicht van systeemberichten met de mogelijkheid om in te zoomen op specifieke applicatiegegevens, of zelfs de zoekbalk te gebruiken om berichten te filteren als ze geen specifieke tekens bevatten.

Zorg ervoor dat u Toon alleen geselecteerde applicatie in de rechterbovenhoek hebt geselecteerd, zoals weergegeven in de bovenstaande schermafbeelding. Nu zijn alleen de berichten van uw app zichtbaar.

Voeg in MainActivity.java het volgende toe aan de lijst met importbestanden:

Android.util.Log importeren;

Voeg aan het einde van onCreate() in MainActivity.java de volgende regel toe:

Log.v("FORTUNE APP TAG", "onCreateCalled");

Log.v roept twee parameters aan: tag en bericht. In dit geval wordt de tag gedefinieerd als “FORTUNE APP TAG” en het bericht als “onCreateCalled”.

Voer de applicatie uit om het logbericht in het Logcat-paneel te bekijken.

Filter de inhoud van LogCat, voer onCreateCalled in de zoekbalk boven de console in:

Verwijder vervolgens de zoektekst om alle logberichten weer te zien.

Een andere handige functie is logcat, de mogelijkheid om foutmeldingen te bekijken. Voeg een bug toe aan uw perfect functionele applicatie om te zien hoe alles werkt.

Ga naar MainActivity.java en wijzig de volgende regel in onCreate():

//mFortuneText = (TextView) findViewById(R.id.fortuneText);

Start de applicatie. Klik op de knop Wat is mijn fortuin? Werkt niet!

Hoe zou u de fout oplossen als u niet wist dat er een bug was? Logcat helpt hierbij.

Ga naar het Logcat-paneel - het ziet er ongeveer zo uit:

Er staat hier veel rode tekst. In dit geval is het probleem regel 50 in het bestand MainActivity.java. LogCat heeft deze link omgezet in een blauwe hyperlink. Als u erop drukt, kunt u ontdekken wat het probleem is.

Door mFortuneText = (TextView) findViewById(R.id.fortuneText) te wijzigen, hebt u een variabele gemaakt, maar de waarde ervan niet gespecificeerd - vandaar de null pointer-uitzondering. Ga terug en verander de code, voer de applicatie uit. Deze keer werkt alles soepel. Logcat is een handig hulpmiddel voor het opsporen van fouten.

Deel dit artikel:

Gerelateerde artikelen