AndroidAan de slag met Android


Opmerkingen

Als je meer wilt weten over de instelling van de android-gradle plug-in, bekijk dan de android-gradle documentatie .

Als u geïnteresseerd bent in alternatieve emulators, kunt u kijken naar Genymotion . Het biedt een gratis abonnement en vereist een kleinere hoeveelheid RAM.

versies

Versie API niveau Versie code Publicatiedatum
1.0 1 BASE 2008-09-23
1.1 2 BASE_1_1 2009-02-09
1.5 3 CUPCAKE 2009-04-27
1.6 4 DONUT 2009-09-15
2.0 5 ECLAIR 2009-10-26
2.0.1 6 ECLAIR_0_1 2009-12-03
2.1.x 7 ECLAIR_MR1 2010-01-12
2.2.x 8 FROYO 2010-05-20
2.3 9 GINGERBREAD 2010-12-06
2.3.3 10 GINGERBREAD_MR1 2011-02-09
3.0.x 11 HONEYCOMB 2011-02-22
3.1.x 12 HONEYCOMB_MR1 2011-05-10
3.2.x 13 HONEYCOMB_MR2 2011-07-15
4.0 14 ICE_CREAM_SANDWICH 2011-10-18
4.0.3 15 ICE_CREAM_SANDWICH_MR1 2011-12-16
4.1 16 JELLY_BEAN 2012-07-09
4.2 17 JELLY_BEAN_MR1 2012/11/13
4.3 18 JELLY_BEAN_MR2 2013/07/24
4.4 19 KITKAT 2013/10/31
4.4W 20 KITKAT_WATCH 2014/06/25
5.0 21 LOLLIPOP 2014/11/12
5.1 22 LOLLIPOP_MR1 2015/03/09
6.0 23 M (Marshmallow) 2015/10/05
7.0 24 N (Nougat) 2016/08/22
7.1 25 N_MR1 (Nougat MR1) 2016/10/04
8.0 26 O (Developer Preview 4) 2017/07/24

Android-programmering zonder IDE

Dit is een minimalistisch Hello World-voorbeeld dat alleen de meest elementaire Android-tools gebruikt.

Vereisten en veronderstellingen

Dit voorbeeld veronderstelt Linux. Mogelijk moet u de syntaxis voor uw eigen platform aanpassen.

De Android SDK instellen

Na het uitpakken van de SDK-release:

  1. Installeer extra pakketten met behulp van de SDK-manager. Gebruik de android update sdk --no-ui volgens de instructies in de gebundelde Readme.txt; het downloadt ongeveer 30 GB onnodige bestanden. Gebruik in plaats daarvan de interactieve SDK-manager android sdk om het aanbevolen minimum aantal pakketten te krijgen.

  2. Voeg de volgende JDK- en SDK-mappen toe aan uw uitvoering PATH. Dit is optioneel, maar in de onderstaande instructies wordt ervan uitgegaan.

    • JDK / bin
    • SDK / platform-gereedschappen
    • SDK / gereedschappen
    • SDK / build-tools / LAATSTE (zoals geïnstalleerd in stap 1)
  3. Maak een virtueel Android-apparaat. Gebruik de interactieve AVD Manager ( android avd ). Misschien moet je een beetje prutsen en zoeken naar advies; de instructies op de site zijn niet altijd nuttig.

    (U kunt ook uw eigen apparaat gebruiken)

  4. Voer het apparaat uit:

    emulator -avd DEVICE
     
  5. Als het scherm van het apparaat lijkt te zijn vergrendeld, veegt u om het te ontgrendelen.

    Laat het draaien terwijl u de app codeert.

Codering van de app

  1. Ga naar een lege werkmap.

  2. Maak het bronbestand:

    mkdir --parents src/dom/domain
    touch src/dom/domain/SayingHello.java
     

    Inhoud:

    package dom.domain;
    import android.widget.TextView;
    
    public final class SayingHello extends android.app.Activity
    {
        protected @Override void onCreate( final android.os.Bundle activityState )
        {
            super.onCreate( activityState );
            final TextView textV = new TextView( SayingHello.this );
            textV.setText( "Hello world" );
            setContentView( textV );
        }
    }
     
  3. Voeg een manifest toe:

    touch AndroidManifest.xml
     

    Inhoud:

    <?xml version='1.0'?>
    <manifest xmlns:a='http://schemas.android.com/apk/res/android'
     package='dom.domain' a:versionCode='0' a:versionName='0'>
        <application a:label='Saying hello'>
            <activity a:name='dom.domain.SayingHello'>
                 <intent-filter>
                    <category a:name='android.intent.category.LAUNCHER'/>
                    <action a:name='android.intent.action.MAIN'/>
                    </intent-filter>
                </activity>
            </application>
        </manifest>
     
  4. Maak een submap voor de aangegeven bronnen:

    mkdir res
     

    Laat het voorlopig leeg.

De code bouwen

  1. Genereer de bron voor de bronverklaringen. Vervang hier het juiste pad naar uw SDK en de geïnstalleerde API om tegen te bouwen (bijv. "Android-23"):

    aapt package -f \
      -I SDK/platforms/android-API/android.jar \
      -J src -m \
      -M AndroidManifest.xml -S res -v
     

    Bronverklaringen (hieronder verder beschreven) zijn eigenlijk optioneel. Ondertussen doet de bovenstaande oproep niets als res / nog steeds leeg is.

  2. Compileer de broncode met Java bytecode (.java → .class):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
     
  3. Vertaal de bytecode van Java naar Android (.class → .dex):

    Gebruik eerst Jill (.class → .jayce):

    java -jar SDK/build-tools/LATEST/jill.jar \
      --output classes.jayce src
     

    Dan Jack (.jayce → .dex):

    java -jar SDK/build-tools/LATEST/jack.jar \
      --import classes.jayce --output-dex .
     

    Vroeger werd Android bytecode "Dalvik uitvoerbare code" genoemd, en dus "dex".

    Je zou stappen 11 en 12 kunnen vervangen door een enkele oproep aan Jack als je wilt; het kan rechtstreeks compileren vanuit de Java-bron (.java → .dex). Maar er zijn voordelen aan het compileren met javac . Het is een beter bekend, beter gedocumenteerd en breder toepasbaar hulpmiddel.

  4. Verpak de bronbestanden, inclusief het manifest:

    aapt package -f \
      -F app.apkPart \
      -I SDK/platforms/android-API/android.jar \
      -M AndroidManifest.xml -S res -v
     

    Dat resulteert in een gedeeltelijk APK-bestand (Android-toepassingspakket).

  5. Maak de volledige APK met behulp van de tool ApkBuilder :

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain \
      app.apkUnalign \
      -d -f classes.dex -v -z app.apkPart
     

    Het waarschuwt: "DIT GEREEDSCHAP IS AFGESCHREVEN. Zie --help voor meer informatie." Als --help mislukt met een ArrayIndexOutOfBoundsException , geef dan geen argumenten door:

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain
     

    Er wordt uitgelegd dat de CLI ( ApkBuilderMain ) is afgeschaft ten gunste van het rechtstreeks aanroepen van de Java API ( ApkBuilder ). (Werk dit voorbeeld bij als u weet hoe u dat vanaf de opdrachtregel kunt doen.)

  6. Optimaliseer de gegevensuitlijning van de APK ( aanbevolen werkwijze ):

    zipalign -f -v 4 app.apkUnalign app.apk
     

Installeren en uitvoeren

  1. Installeer de app op het Android-apparaat:

    adb install -r app.apk
     
  2. Start de app:

    adb shell am start -n dom.domain/.SayingHello
     

    Het zou moeten lopen en hallo zeggen.

Dat is alles. Dat is wat er nodig is om hallo te zeggen met behulp van de basis-Android-tools.

Een bron aangeven

Deze sectie is optioneel. Bronverklaringen zijn niet vereist voor een eenvoudige 'hallo wereld'-app. Als ze ook niet nodig zijn voor uw app, kunt u de build enigszins stroomlijnen door stap 10 weg te laten en de verwijzing naar de res / directory uit stap 13 te verwijderen.

Anders is hier een kort voorbeeld van hoe u een resource kunt aangeven en hoe u ernaar kunt verwijzen.

  1. Voeg een bronbestand toe:

    mkdir res/values
    touch res/values/values.xml
     

    Inhoud:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
     
  2. Verwijs naar de resource uit het XML-manifest. Dit is een declaratieve referentiestijl:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
     
  3. Verwijs naar dezelfde bron uit de Java-bron. Dit is een absolute referentie:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
     
  4. Test de bovenstaande wijzigingen door de app opnieuw te bouwen, opnieuw te installeren en opnieuw uit te voeren (stappen 10-17).

    Het zou opnieuw moeten beginnen en zeggen: "Deze app heet hallo".

De-installatie van de app

adb uninstall dom.domain
 

Zie ook

Toepassingsgrondslagen

Android-apps zijn geschreven in Java. De Android SDK-tools compileren de code, gegevens en bronbestanden in een APK (Android-pakket). Over het algemeen bevat één APK-bestand alle inhoud van de app.

Elke app draait op zijn eigen virtuele machine (VM) zodat de app geïsoleerd van andere apps kan worden uitgevoerd. Android-systeem werkt met het principe van minste privilege. Elke app heeft alleen toegang tot de componenten die hij nodig heeft om zijn werk te doen, en niet meer. Er zijn echter manieren waarop een app gegevens kan delen met andere apps, bijvoorbeeld door een Linux-gebruikers-ID tussen de app te delen, of apps kunnen toestemming vragen voor toegang tot apparaatgegevens zoals SD-kaart, contacten, enz.

App-componenten

App-componenten zijn de bouwstenen van een Android-app. Elke component speelt een specifieke rol in een Android-app die een specifiek doel dient en verschillende levenscycli heeft (de stroom van hoe en wanneer de component wordt gemaakt en vernietigd). Hier zijn de vier soorten app-componenten:

  1. Activiteiten: een activiteit vertegenwoordigt een enkel scherm met een gebruikersinterface (UI). Een Android-app kan meer dan één activiteit hebben. (een e-mailapp kan bijvoorbeeld één activiteit hebben om alle e-mails weer te geven, een andere om de inhoud van elke e-mail weer te geven en een andere om een nieuwe e-mail samen te stellen.) Alle activiteiten in een app werken samen om een User eXperience (UX) te creëren.
  2. Services: een service wordt op de achtergrond uitgevoerd om langlopende bewerkingen uit te voeren of om werkzaamheden voor externe processen uit te voeren. Een service biedt geen gebruikersinterface, deze wordt alleen op de achtergrond uitgevoerd met de invoer van de gebruiker. (een service kan bijvoorbeeld muziek op de achtergrond afspelen terwijl de gebruiker zich in een andere app bevindt, of het kan gegevens van internet downloaden zonder de interactie van de gebruiker met het Android-apparaat te blokkeren.)
  3. Inhoudsproviders: een inhoudsprovider beheert gedeelde app-gegevens. Er zijn vier manieren om gegevens in een app op te slaan: deze kunnen naar een bestand worden geschreven en in het bestandssysteem worden opgeslagen, worden ingevoegd of bijgewerkt in een SQLite-database, op internet worden geplaatst of worden opgeslagen op een andere permanente opslaglocatie waartoe de app toegang heeft . Via inhoudsproviders kunnen andere apps de gegevens opvragen of zelfs wijzigen. (bijv. het Android-systeem biedt een inhoudprovider die de contactgegevens van de gebruiker beheert, zodat elke app met toestemming de contacten kan opvragen.) Inhoudproviders kunnen ook worden gebruikt om de privégegevens van de app op te slaan voor een betere gegevensintegriteit.
  4. Uitzendontvangers: een uitzendontvanger reageert op de systeembrede uitzendingen van aankondigingen (bijv. Een uitzending die aankondigt dat het scherm is uitgeschakeld, de batterij bijna leeg is, enz.) Of van Apps (bijv. Om andere apps te laten weten dat bepaalde gegevens gedownload naar het apparaat en is beschikbaar voor gebruik). Uitzendontvangers hebben geen gebruikersinterface, maar ze kunnen een melding in de statusbalk weergeven om de gebruiker te waarschuwen. Gewoonlijk worden omroepontvangers gebruikt als een gateway naar andere componenten van de app, die voornamelijk bestaan uit activiteiten en diensten.

Een uniek aspect van het Android-systeem is dat elke app een component van een andere app kan starten (bijvoorbeeld als u wilt bellen, sms'en, een webpagina wilt openen of een foto wilt bekijken, er is een app die dat al doet en uw app kan gebruik ervan, in plaats van een nieuwe activiteit voor dezelfde taak te ontwikkelen).

Wanneer het systeem een component start, start het het proces voor die app (als het nog niet actief is, dat wil zeggen dat er slechts één voorgrondproces per app op een bepaald moment op een Android-systeem kan worden uitgevoerd) en instantieert het de klassen die nodig zijn voor die component. Het onderdeel draait dus op het proces van die app waartoe het behoort. Daarom hebben Android-apps, anders dan apps op andere systemen, geen enkel toegangspunt (er is geen main() -methode).

Omdat het systeem elke app in een afzonderlijk proces uitvoert, kan een app de componenten van een andere app niet direct activeren, maar het Android-systeem wel. Om een component van een andere app te starten, moet een app een bericht naar het systeem sturen met de intentie om die component te starten, waarna het systeem die component start.

Context

Instanties van de klasse android.content.Context bieden de verbinding met het Android-systeem dat de toepassing uitvoert. Instance of Context is vereist om toegang te krijgen tot de bronnen van het project en de algemene informatie over de omgeving van de app.

Laten we een gemakkelijk te verteren voorbeeld nemen: bedenk dat u in een hotel bent en iets wilt eten. U belt roomservice en vraagt hen om u dingen te brengen of dingen voor u op te ruimen. Beschouw dit hotel nu als een Android-app, uzelf als een activiteit, en de roomservice-persoon is dan uw context, die u toegang geeft tot de hotelbronnen zoals roomservice, etenswaren etc.

Nog een ander voorbeeld, u bevindt zich in een restaurant dat op een tafel zit, elke tafel heeft een begeleider, wanneer u eten wilt bestellen, vraagt u de begeleider om dit te doen. De begeleider plaatst vervolgens uw bestelling en uw etenswaren worden op uw tafel geserveerd. Nogmaals, in dit voorbeeld is het restaurant een Android-app, zijn de tafels of de klanten app-componenten, zijn de voedselitems uw app-middelen en is de begeleider uw context waardoor u een manier krijgt om toegang te krijgen tot de middelen zoals voedselitems.

Voor het activeren van een van de bovenstaande componenten is het exemplaar van de context vereist. Niet alleen het bovenstaande, maar bijna elke systeemresource: het maken van de gebruikersinterface met behulp van views (later besproken), het creëren van instantie van systeemservices, het starten van nieuwe activiteiten of services - allemaal vereisen context.

Een meer gedetailleerde beschrijving is hier geschreven.

Een nieuw project maken

Android Studio instellen

Begin met het instellen van Android Studio en open het vervolgens. Nu ben je klaar om je eerste Android-app te maken!

Opmerking: deze handleiding is gebaseerd op Android Studio 2.2, maar het proces op andere versies is hoofdzakelijk hetzelfde.

Configureer uw project

Basis configuratie

U kunt op twee manieren een nieuw project starten:

  • Klik in het welkomstscherm op Start a New Android Studio Project .
  • Navigeer naar FileNew Project als u al een project hebt geopend.

Vervolgens moet u uw aanvraag beschrijven door enkele velden in te vullen:

  1. Applicatienaam - Deze naam wordt aan de gebruiker getoond.

    Voorbeeld: Hello World . U kunt dit later altijd wijzigen in het bestand AndroidManifest.xml .

  2. Bedrijfsdomein - Dit is de kwalificatie voor de pakketnaam van uw project.

    Voorbeeld: stackoverflow.com .

  3. Pakketnaam (aka applicationId ) - Dit is de volledig gekwalificeerde projectpakketnaam.

    Het moet volgen Reverse Domain Name Notation (aka Reverse DNS ): Top Level Domain . Bedrijfsdomein . [ Bedrijfssegment . ] Naam van toepassing .

    Voorbeeld: com.stackoverflow.android.helloworld of com.stackoverflow.helloworld . Je kunt je applicatie- ID altijd wijzigen door het te overschrijven in je gradle-bestand .

Gebruik niet het standaardvoorvoegsel 'com.example' tenzij u niet van plan bent uw aanvraag in te dienen bij de Google Play Store. De pakketnaam wordt uw unieke applicatie-ID in Google Play.

  1. Projectlocatie - Dit is de map waarin uw project wordt opgeslagen.

Nieuw projectdialoogvenster

Selecteer vormfactoren en API-niveau

In het volgende venster kunt u de vormfactoren selecteren die door uw app worden ondersteund, zoals telefoon, tablet, tv, slijtage en Google Glass. De geselecteerde vormfactoren worden de app-modules binnen het project. Voor elke vormfactor kunt u ook het API-niveau voor die app selecteren. Klik op Help mij bij het kiezen voor meer informatie

voer hier de afbeeldingsbeschrijving in Grafiek van de huidige Android-distributieverdelingen, weergegeven als u op Help mij kiezen klikt.

Het Android Platform Distribution-venster toont de distributie van mobiele apparaten met elke versie van Android, zoals getoond in figuur 2. Klik op een API-niveau om een lijst met functies te zien die in de overeenkomstige versie van Android zijn geïntroduceerd. Dit helpt u bij het kiezen van het minimale API-niveau met alle functies die uw apps nodig hebben, zodat u zoveel mogelijk apparaten kunt bereiken. Klik vervolgens op OK .

Kies nu welke platforms en versie van Android SDK de toepassing ondersteunt.

Dialoogvenster SDK-versie

Selecteer voorlopig alleen Telefoon en Tablet .

De minimale SDK is de ondergrens voor uw app. Het is een van de signalen die de Google Play Store gebruikt om te bepalen op welke apparaten een app kan worden geïnstalleerd. De app van Stack Exchange ondersteunt bijvoorbeeld Android 4.1+.

Stack Exchange's app
Android Studio vertelt je (ongeveer) welk percentage apparaten wordt ondersteund gezien de opgegeven minimale SDK.

Lagere API-niveaus zijn gericht op meer apparaten maar hebben minder functies beschikbaar.

Bij het kiezen van de minimale SDK moet u rekening houden met de Dashboards-statistieken , die u versiegegevens geven over de apparaten die de afgelopen week de Google Play Store wereldwijd hebben bezocht.

Schermafbeelding van de huidige Android-distributie

Van: Dashboards op Android Developer-website.

Voeg een activiteit toe

Nu gaan we een standaardactiviteit selecteren voor onze applicatie. In Android is een Activity een enkel scherm dat aan de gebruiker wordt gepresenteerd. Een applicatie kan meerdere activiteiten huisvesten en daartussen navigeren. Kies voor dit voorbeeld Empty Activity en klik op volgende.

Hier kunt u desgewenst de naam van de activiteit en de lay-out wijzigen. Het is een goede gewoonte om Activity te houden als een achtervoegsel voor de naam van de activiteit en activity_ als een voorvoegsel voor de naam van de lay-out. Als we deze als standaard laten, genereert Android Studio voor ons een activiteit met de naam MainActivity en een lay- MainActivity naam activity_main . Klik nu op Finish .

Android Studio maakt en configureert ons project, wat enige tijd kan duren, afhankelijk van het systeem.

Inspectie van het project

Laten we eens kijken naar enkele van de bestanden die voor ons zijn gemaakt om te begrijpen hoe Android werkt.

In het linkerdeelvenster van Android Studio zien we de structuur van onze Android-applicatie .

Basis applicatiestructuur

Laten we eerst AndroidManifest.xml openen door erop te dubbelklikken. Het Android-manifestbestand beschrijft enkele basisinformatie over een Android-applicatie. Het bevat de verklaring van onze activiteiten, evenals enkele meer geavanceerde componenten.

Als een toepassing toegang nodig heeft tot een functie die wordt beschermd door een machtiging, moet deze verklaren dat deze toestemming vereist is met een element <uses-permission> in het manifest. Wanneer de toepassing vervolgens op het apparaat wordt geïnstalleerd, bepaalt het installatieprogramma of de gevraagde toestemming al dan niet wordt verleend door de autoriteiten te controleren die de certificaten van de toepassing hebben ondertekend en, in sommige gevallen, de gebruiker te vragen. Een applicatie kan ook zijn eigen componenten (activiteiten, services, uitzendontvangers en contentproviders) beschermen met machtigingen. Het kan gebruikmaken van alle machtigingen die zijn gedefinieerd door Android (vermeld in android.Manifest.permission) of die zijn gedeclareerd door andere applicaties. Of het kan zijn eigen definiëren.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.stackoverflow.helloworld">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
 

Laten we vervolgens activity_main.xml openen die zich in app/src/main/res/layout/ . Dit bestand bevat verklaringen voor de visuele componenten van onze MainActivity. U zult visueel ontwerper zien. Hiermee kunt u elementen naar de geselecteerde lay-out slepen en neerzetten.

U kunt ook overschakelen naar de XML-lay-outontwerper door op 'Tekst' onder aan Android Studio te klikken, zoals hier:

Lay-outontwerp / teksttabs

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.stackexchange.docs.helloworld.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>
 

Binnen deze lay-out ziet u een widget met de naam TextView , met de eigenschap android:text ingesteld op "Hello World!". Dit is een tekstblok dat aan de gebruiker wordt getoond wanneer deze de toepassing uitvoert.

U kunt meer lezen over Layouts en attributen .

Laten we nu eens kijken naar MainActivity . Dit is de Java-code die is gegenereerd voor MainActivity .

public class MainActivity extends AppCompatActivity {

    // The onCreate method is called when an Activity starts
    // This is where we will set up our layout
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // setContentView sets the Activity's layout to a specified XML layout
        // In our case we are using the activity_main layout
        setContentView(R.layout.activity_main);
    }
}
 

Zoals gedefinieerd in ons Android-manifest, wordt MainActivity standaard gestart wanneer een gebruiker de HelloWorld app start.

Open ten slotte het bestand met de naam build.gradle in app/ .
Android Studio gebruikt het build-systeem Gradle om Android-applicaties en bibliotheken te compileren en te bouwen.

apply plugin: 'com.android.application'

android {
signingConfigs {
         applicationName {
             keyAlias 'applicationName'
             keyPassword 'password'
             storeFile file('../key/applicationName.jks')
             storePassword 'anotherPassword'
         }
     }
    compileSdkVersion 26
    buildToolsVersion "26.0.0"

    defaultConfig {
        applicationId "com.stackexchange.docs.helloworld"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        signingConfig signingConfigs.applicationName
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:26.0.0'
}
 

Dit bestand bevat informatie over de build en uw app-versie en u kunt het ook gebruiken om afhankelijkheden toe te voegen aan externe bibliotheken. Laten we voorlopig geen wijzigingen aanbrengen.

Het is raadzaam om altijd de nieuwste beschikbare versie voor de afhankelijkheden te selecteren:

compileSdkVersion

compileSdkVersion is uw weg naar Gradle vertellen welke versie van de Android SDK om uw app compileren met. Het gebruik van de nieuwe Android SDK is een vereiste om een van de nieuwe API's te gebruiken die op dat niveau zijn toegevoegd.

Benadrukt moet worden dat het wijzigen van uw compileSdkVersion het compileSdkVersion niet verandert. Hoewel nieuwe compilerwaarschuwingen / -fouten aanwezig kunnen zijn bij het wijzigen van uw compileSdkVersion , is uw compileSdkVersion niet opgenomen in uw APK: het wordt puur tijdens het compileren gebruikt.

Daarom wordt het ten zeerste aanbevolen dat u altijd compileert met de nieuwste SDK. U krijgt alle voordelen van nieuwe compilatiecontroles op bestaande code, vermijdt nieuw verouderde API's en bent klaar om nieuwe API's te gebruiken.

minSdkVersion

Als compileSdkVersion de nieuwste API's voor u minSdkVersion is minSdkVersion de ondergrens voor uw app. De minSdkVersion is een van de signalen die de Google Play Store gebruikt om te bepalen op welke apparaten van een gebruiker een app kan worden geïnstalleerd.

Het speelt ook een belangrijke rol tijdens de ontwikkeling: standaard loopt lint tegen uw project en waarschuwt het u wanneer u API's boven uw minSdkVersion , waardoor u het runtime-probleem van het proberen om een API die niet bestaat te voorkomen. Het controleren van de systeemversie tijdens runtime is een veelgebruikte techniek bij het gebruik van API's alleen op nieuwere platformversies.

targetSdkVersion

targetSdkVersion is de belangrijkste manier waarop Android voorwaartse compatibiliteit biedt door gedragsveranderingen niet toe te passen, tenzij de targetSdkVersion is bijgewerkt. Hiermee kunt u nieuwe API's gebruiken voordat u de gedragsveranderingen doorloopt. Updaten om de nieuwste SDK te targeten, zou voor elke app een hoge prioriteit moeten hebben. Dat betekent niet dat u elke nieuwe functie moet gebruiken en dat u uw targetSdkVersion niet blindelings moet bijwerken zonder te testen.

targetSDKVersion is de versie van Android die de bovengrens is voor de beschikbare tools. Als targetSDKVersion kleiner is dan 23, hoeft de app tijdens een runtime geen machtigingen aan te vragen, zelfs niet als de app wordt uitgevoerd op API 23+. TargetSDKVersion voorkomt niet dat Android-versies boven de gekozen Android-versie de app niet uitvoeren.

U kunt meer informatie vinden over de Gradle-plug-in:

De toepassing uitvoeren

Laten we nu onze HelloWorld-applicatie uitvoeren. U kunt een virtueel Android-apparaat uitvoeren (dat u kunt instellen met behulp van AVD Manager in Android Studio, zoals beschreven in het onderstaande voorbeeld) of uw eigen Android-apparaat aansluiten via een USB-kabel.

Een Android-apparaat instellen

Als u een toepassing van Android Studio op uw Android-apparaat wilt uitvoeren, moet u USB Debugging inschakelen in de Developer Options in de instellingen van uw apparaat.

Settings > Developer options > USB debugging

Als Developer Options niet zichtbaar is in de instellingen, navigeert u naar About Phone en tikt u zeven keer op het Build Number . Hiermee kunnen Developer Options worden weergegeven in uw instellingen.

Settings > About phone > Build number

Mogelijk moet u build.gradle configuratie van build.gradle wijzigen om voort te bouwen op een versie van uw apparaat.

Uitgevoerd vanuit Android Studio

Klik op de groene knop Run op de werkbalk bovenaan Android Studio. Selecteer in het venster dat verschijnt het apparaat waarop u de app wilt uitvoeren (start indien nodig een virtueel Android-apparaat of zie Een AVD (virtueel Android-apparaat) instellen als u er een moet instellen) en klik op OK .

Uitvoeren knop

Op apparaten met Android 4.4 (KitKat) en mogelijk hoger, wordt een pop-up getoond om USB-foutopsporing te autoriseren. Klik op OK om te accepteren.

De applicatie wordt nu geïnstalleerd en uitgevoerd op uw Android-apparaat of emulator.

APK-bestandslocatie

Wanneer u uw toepassing voorbereidt op release, configureert, bouwt en test u een releaseversie van uw toepassing. De configuratietaken zijn eenvoudig en omvatten basiscodeschoonmaak en codewijzigingen die helpen bij het optimaliseren van uw toepassing. Het build-proces is vergelijkbaar met het debug-build-proces en kan worden gedaan met behulp van JDK- en Android SDK-tools. De testtaken dienen als een laatste controle en zorgen ervoor dat uw applicatie werkt zoals verwacht onder reële omstandigheden. Wanneer u klaar bent met het voorbereiden van uw applicatie voor release, heeft u een ondertekend APK-bestand dat u rechtstreeks naar gebruikers kunt distribueren of via een applicatiemarktplaats zoals Google Play kunt distribueren.

Android Studio

Omdat in de bovenstaande voorbeelden Gradle wordt gebruikt, is de locatie van het gegenereerde APK-bestand: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Als u IntelliJ gebruikt voordat u naar Studio overschakelde en uw IntelliJ-project rechtstreeks importeert, is er niets veranderd. De locatie van de uitvoer is hetzelfde onder:

out/production/...
 

Opmerking: dit wordt soms rond 1.0 verouderd

Verduistering

Als u het Android Eclipse-project rechtstreeks importeert, doe dit dan niet! Zodra u afhankelijkheden in uw project heeft (potten of bibliotheekprojecten), werkt dit niet en wordt uw project niet correct ingesteld. Als u geen afhankelijkheden heeft, bevindt de apk zich op dezelfde locatie als u deze zou vinden in Eclipse:

bin/...
 

Een AVD (virtueel Android-apparaat) instellen

TL; DR Hiermee kunnen we in feite echte apparaten simuleren en onze apps testen zonder een echt apparaat.

Volgens Android Developer Documentation ,

Met een definitie van Android Virtual Device (AVD) kunt u de kenmerken definiëren van een Android-telefoon, tablet, Android Wear of Android TV-apparaat dat u wilt simuleren in de Android Emulator. Met AVD Manager kunt u eenvoudig AVD's maken en beheren.

Volg deze stappen om een AVD in te stellen:

1. Klik op deze knop om AVD Manager te openen:

AVD Manager-pictogram

2. Je zou een dialoogvenster als dit moeten zien:

AVD Manager-dialoogvenster

3. Klik nu op de knop + Create Virtual Device... Hiermee wordt het dialoogvenster Virtuele apparaatconfiguratie geopend:

Dialoogvenster Configuratie virtueel apparaat

4. Selecteer het gewenste apparaat en klik op Next :

Kies Systeemafbeelding

5. Hier moet u een Android-versie voor uw emulator kiezen. Mogelijk moet u het ook eerst downloaden door op Download klikken. Nadat u een versie hebt gekozen, klikt u op Next .

Geavanceerde instellingen

6. Voer hier een naam in voor uw emulator, de oorspronkelijke oriëntatie en of u er een kader omheen wilt weergeven. Nadat u al deze hebt gekozen, klikt u op Finish .

7. Nu heb je een nieuwe AVD klaar om je apps erop te lanceren.

AVD

Android Studio instellen

Android Studio is de IDE voor Android-ontwikkeling die officieel wordt ondersteund en wordt aanbevolen door Google. Android Studio wordt geleverd met de Android SDK Manager , een hulpmiddel om de Android SDK componenten te downloaden die nodig zijn om apps te ontwikkelen.

Android Studio- en Android SDK tools installeren:

  1. Download en installeer Android Studio .
  2. Download de nieuwste SDK Tools en SDK Platform-tools door Android Studio te openen en vervolgens de instructies voor Android SDK Tool Updates te volgen. U moet de nieuwste beschikbare stabiele pakketten installeren.

Als u moet werken aan oude projecten die zijn gebouwd met oudere SDK-versies, moet u deze versies mogelijk ook downloaden

Sinds Android Studio 2.2 wordt een exemplaar van de nieuwste OpenJDK meegeleverd met de installatie en is dit de aanbevolen JDK (Java Development Kit) voor alle Android Studio-projecten. Hiermee vervalt de eis dat het JDK-pakket van Oracle is geïnstalleerd. Ga als volgt te werk om de gebundelde SDK te gebruiken;

  1. Open uw project in Android Studio en selecteer Bestand> Projectstructuur in de menubalk.
  2. Schakel op de pagina SDK-locatie en onder JDK-locatie het selectievakje Geïntegreerde JDK gebruiken in .
  3. Klik op OK .

Configureer Android Studio

Android Studio biedt toegang tot twee configuratiebestanden via het menu Help :

  • studio.vmoptions : pas opties aan voor Studio's Java Virtual Machine (JVM), zoals heap-grootte en cachegrootte. Merk op dat dit bestand op Linux-machines studio64.vmoptions kan heten , afhankelijk van uw versie van Android Studio.
  • idea.properties : Android Studio-eigenschappen aanpassen, zoals het mappad van de plug-ins of de maximale ondersteunde bestandsgrootte.

Verander / voeg thema toe

U kunt dit als uw voorkeur wijzigen. File->Settings->Editor->Colors & Fonts-> en selecteer een thema. U kunt ook nieuwe thema's downloaden van http://color-themes.com/ Nadat u het .jar.zip bestand hebt gedownload, gaat u naar File -> Import Settings... en kies het gedownloade bestand.

Apps compileren

Maak een nieuw project of open een bestaand project in Android Studio en druk op de groene knop Afspelen voer hier de afbeeldingsbeschrijving in op de bovenste werkbalk om het uit te voeren. Als het grijs is, moet je een seconde wachten voordat Android Studio sommige bestanden correct kan indexeren, waarvan de voortgang wordt weergegeven in de onderste statusbalk.

Als je een project wilt maken vanuit de shell, zorg er dan voor dat je een local.properties bestand hebt, dat automatisch door Android Studio wordt gemaakt. Als u het project zonder Android Studio wilt maken, hebt u een regel nodig die begint met sdk.dir= gevolgd door het pad naar uw SDK-installatie.

Open een shell en ga naar de map van het project. Voer ./gradlew aR en druk op enter. aR is een snelkoppeling voor assembleRelease , waarmee alle afhankelijkheden voor u worden gedownload en de app wordt gebouwd. Het uiteindelijke APK-bestand bevindt zich in ProjectName/ModuleName/build/outputs/apk en wordt ModuleName-release.apk .