AndroidKomma igång med Android


Anmärkningar

Om du vill lära dig mer om Android Gradle Plugin-inställningen, kolla dokumentationen för android-gradle .

Om du är intresserad av alternativa emulatorer kan du titta på Genymotion . Det ger en gratis plan och kräver mindre RAM-minne.

versioner

Version API-nivå Versionskod Utgivningsdatum
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 (Förhandsvisning av utvecklare 4) 2017/07/24

Android-programmering utan IDE

Detta är ett minimalistiskt Hello World-exempel som bara använder de mest grundläggande Android-verktygen.

Krav och antaganden

Detta exempel antar Linux. Du kanske måste justera syntaxen för din egen plattform.

Ställa in Android SDK

Efter packning av SDK-utgåvan:

  1. Installera ytterligare paket med SDK-hanteraren. Använd inte android update sdk --no-ui enligt instruktionerna i den medföljande Readme.txt; den laddar ner ungefär 30 GB onödiga filer. android sdk istället den interaktiva SDK-manager android sdk att få det rekommenderade minimipaketet.

  2. Lägg till följande JDK- och SDK-kataloger till din körning PATH. Detta är valfritt, men instruktionerna nedan antar det.

    • JDK / bin
    • SDK / plattform-verktyg
    • SDK / verktyg
    • SDK / build-tools / LATEST (som installerat i steg 1)
  3. Skapa en virtuell Android-enhet. Använd den interaktiva AVD-hanteraren ( android avd ). Du kanske måste fikra lite och söka efter råd; instruktionerna på plats hjälper inte alltid.

    (Du kan också använda din egen enhet)

  4. Kör enheten:

    emulator -avd DEVICE
     
  5. Om enhetsskärmen verkar vara låst, svep sedan för att låsa upp den.

    Låt den gå medan du kodar appen.

Kodar appen

  1. Byt till en tom fungerande katalog.

  2. Gör källfilen:

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

    Innehåll:

    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. Lägg till ett manifest:

    touch AndroidManifest.xml
     

    Innehåll:

    <?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. Skapa en underkatalog för de deklarerade resurserna:

    mkdir res
     

    Lämna det tomt för nu.

Bygg koden

  1. Generera källan för resursdeklarationerna. Ersätt här rätt väg till din SDK och det installerade API: n för att bygga mot (t.ex. "android-23"):

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

    Resursdeklarationer (beskrivs vidare nedan) är faktiskt valfria. Under tiden gör ovanstående samtal ingenting om res / är fortfarande tomt.

  2. Kompilera källkoden till Java-bytekod (.java → .klass):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
     
  3. Översätt bytekoden från Java till Android (.klass → .dex):

    Först med Jill (.klass → .jayce):

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

    Sedan Jack (.jayce → .dex):

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

    Android-bytekod kallades tidigare "Dalvik körbar kod", och så "dex".

    Du kan ersätta steg 11 och 12 med ett enda samtal till Jack om du vill; det kan kompilera direkt från Java-källa (.java → .dex). Men det finns fördelar med att sammanställa med javac . Det är ett mer känt, bättre dokumenterat och mer tillämpligt verktyg.

  4. Paketera resursfilerna, inklusive manifestet:

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

    Det resulterar i en partiell APK-fil (Android-applikationspaket).

  5. Gör hela APK med hjälp av ApkBuilder verktyget:

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

    Den varnar, "DETTA VERKTYG ÄR DEPRECATERAD. Se - hjälp för mer information." Om --help misslyckas med en ArrayIndexOutOfBoundsException , ArrayIndexOutOfBoundsException stället inga argument:

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

    Det förklarar att CLI ( ApkBuilderMain ) ApkBuilderMain för att direkt ringa Java API ( ApkBuilder ). (Om du vet hur du gör det från kommandoraden, uppdatera detta exempel.)

  6. Optimera APK-datainriktningen ( rekommenderad praxis ):

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

Installera och köra

  1. Installera appen på Android-enheten:

    adb install -r app.apk
     
  2. Starta appen:

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

    Den borde springa och säga hej.

Det är allt. Det är vad som krävs för att säga hej med hjälp av de grundläggande Android-verktygen.

Att förklara en resurs

Det här avsnittet är valfritt. Resursdeklarationer krävs inte för en enkel "hejvärld" -app. Om de inte heller krävs för din app kan du effektivisera byggandet något genom att utelämna steg 10 och ta bort referensen till res / katalogen från steg 13.

Annars är här ett kort exempel på hur man deklarerar en resurs och hur man refererar till den.

  1. Lägg till en resursfil:

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

    Innehåll:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
     
  2. Hänvisning till resursen från XML-manifestet. Detta är en deklarativ referensstil:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
     
  3. Hänvisning till samma resurs från Java-källan. Detta är en absolut hänvisning:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
     
  4. Testa ovanstående ändringar genom att bygga om, installera om och köra appen igen (steg 10-17).

    Det bör starta om och säga, "Den här appen heter Saying hej".

Avinstallera appen

adb uninstall dom.domain
 

Se även

Grundläggande för ansökan

Android-appar skrivs i Java. Android SDK-verktygen sammanställer kod, data och resursfiler till en APK (Android-paket). I allmänhet innehåller en APK-fil allt appens innehåll.

Varje app körs på sin egen virtuella maskin (VM) så att appen kan köra isolerat från andra appar. Android-systemet fungerar med principen om minst privilegium. Varje app har bara åtkomst till de komponenter som den kräver för att utföra sitt arbete och inte mer. Det finns dock sätt för en app att dela data med andra appar, till exempel genom att dela Linux-användar-ID mellan appen, eller appar kan begära tillåtelse att få åtkomst till enhetsdata som SD-kort, kontakter etc.

App-komponenter

Appskomponenter är byggstenarna i en Android-app. Varje komponenter spelar en specifik roll i en Android-app som tjänar ett tydligt syfte och har distinkta livscykler (flödet av hur och när komponenten skapas och förstörs). Här är de fyra typerna av appkomponenter:

  1. Aktiviteter: En aktivitet representerar en enda skärm med ett användargränssnitt (UI). En Android-app kan ha mer än en aktivitet. (t.ex. en e-post-app kan ha en aktivitet för att lista alla e-postmeddelanden, en annan för att visa innehållet i varje e-postmeddelande och en annan för att skriva ett nytt e-postmeddelande.) Alla aktiviteter i en app fungerar tillsammans för att skapa en User eXperience (UX).
  2. Tjänster: En tjänst körs i bakgrunden för att utföra långvariga operationer eller för att utföra arbete för fjärrprocesser. En tjänst tillhandahåller inget användargränssnitt, den körs bara i bakgrunden med användarens input. (t.ex. kan en tjänst spela musik i bakgrunden medan användaren är i en annan app, eller så kan den hämta data från internet utan att blockera användarens interaktion med Android-enheten.)
  3. Innehållsleverantörer: En innehållsleverantör hanterar delade appdata. Det finns fyra sätt att lagra data i en app: det kan skrivas till en fil och lagras i filsystemet, infogas eller uppdateras till en SQLite-databas, läggas ut på webben eller sparas på någon annan bestående lagringsplats som appen kan komma åt . Genom innehållsleverantörer kan andra appar fråga eller till och med ändra uppgifterna. (t.ex. Android-system tillhandahåller en innehållsleverantör som hanterar användarens kontaktinformation så att alla appar som har tillåtelse kan fråga kontakter.) Innehållsleverantörer kan också användas för att spara informationen som är privat för appen för bättre dataintegritet.
  4. Sändningsmottagare: En sändningsmottagare svarar på systemomfattande sändningar av tillkännagivanden (t.ex. en sändning som tillkännager att skärmen har stängts av, batteriet är svagt etc.) eller från appar (t.ex. för att låta andra appar veta att vissa data har varit laddas ner till enheten och är tillgänglig för dem att använda). Broadcastmottagare har inte UI men de kan visa meddelanden i statusfältet för att varna användaren. Vanligtvis används sändningsmottagare som en gateway till andra komponenter i appen, som huvudsakligen består av aktiviteter och tjänster.

En unik aspekt av Android-systemet är att alla appar kan starta en annan apps komponent (t.ex. om du vill ringa, skicka SMS, öppna en webbsida eller visa en bild, det finns en app som redan gör det och din app kan utnyttja den istället för att utveckla en ny aktivitet för samma uppgift).

När systemet startar en komponent startar det processen för den appen (om den inte redan körs, dvs endast en förgrundsprocess per app kan köras vid en viss tidpunkt på ett Android-system) och instanseras de klasser som behövs för den komponenten. Således körs komponenten på den app som den tillhör. Därför, till skillnad från appar på andra system, Android-appar har inte en enda ingång (det finns ingen main() metod).

Eftersom systemet kör varje app i en separat process kan en app inte direkt aktivera en annan apps komponenter, men Android-systemet kan det. Således för att starta en annan apps komponent måste en app skicka ett meddelande till systemet som anger en avsikt att starta den komponenten, då kommer systemet att starta den komponenten.

Sammanhang

Instanser av klassen android.content.Context ger anslutningen till Android-systemet som kör applikationen. Instance of Context krävs för att få tillgång till projektets resurser och den globala informationen om appens miljö.

Låt oss ha ett enkelt smälta exempel: Tänk på att du är på ett hotell och vill äta något. Du ringer rumsservice och ber dem ta med dig saker eller städa upp saker åt dig. Tänk nu på detta hotell som en Android-app, dig själv som en aktivitet, och rumsservicepersonen är då ditt sammanhang, som ger dig tillgång till hotellresurserna som rumservice, matvaror etc.

Ännu ett annat exempel: Du är i en restaurang som sitter vid ett bord, varje bord har en skötare, när du någonsin vill beställa matvaror ber du skötaren att göra det. Skötaren lägger sedan din beställning och dina matvaror serveras på ditt bord. Återigen i det här exemplet är restaurangen en Android-app, borden eller kunderna är appkomponenter, matvarorna är dina appresurser och tillhörande är ditt sammanhang, vilket ger dig ett sätt att få tillgång till resurserna som matvaror.

Att aktivera någon av ovanstående komponenter kräver sammanhangets instans. Inte bara bara ovanstående, utan nästan alla systemresurser: skapande av UI med hjälp av vyer (diskuteras senare), skapa instanser av systemtjänster, starta nya aktiviteter eller tjänster - allt kräver sammanhang.

Mer detaljerad beskrivning skrivs här .

Skapa ett nytt projekt

Ställ in Android Studio

Börja med att ställa in Android Studio och öppna sedan den. Nu är du redo att skapa din första Android-app!

Obs! Den här guiden är baserad på Android Studio 2.2, men processen i andra versioner är huvudsakligen densamma.

Konfigurera ditt projekt

Grundläggande konfiguration

Du kan starta ett nytt projekt på två sätt:

  • Klicka på Start a New Android Studio Project från välkomstskärmen.
  • Navigera till FileNew Project om du redan har ett projekt öppet.

Därefter måste du beskriva din ansökan genom att fylla i några fält:

  1. Programnamn - Detta namn visas för användaren.

    Exempel: Hello World . Du kan alltid ändra det senare i filen AndroidManifest.xml .

  2. Företagsdomän - Detta är kvalificeringen för ditt projekt paketnamn.

    Exempel: stackoverflow.com .

  3. Paketnamn (aka applicationId ) - Detta är det fullt kvalificerade projektpaketnamnet.

    Det bör följa Notera omvänd domännamn (aka Reverse DNS ): Top Level Domain . Företagets domän . [ Företagssegment . ] Programnamn .

    Exempel: com.stackoverflow.android.helloworld eller com.stackoverflow.helloworld . Du kan alltid ändra din applikation genom att åsidosätta den i din gradfil .

Använd inte standardprefixet "com.example" såvida du inte tänker skicka in din ansökan till Google Play Store. Paketnamnet kommer att vara din unika applikation i Google Play.

  1. Projektplats - Detta är katalogen där ditt projekt kommer att lagras.

Ny projektdialog

Välj Formfaktorer och API-nivå

I nästa fönster kan du välja formulärfaktorer som stöds av din app, till exempel telefon, surfplatta, TV, Wear och Google Glass. De valda formfaktorerna blir appmodulerna i projektet. För varje formfaktor kan du också välja API-nivå för den appen. För att få mer information, klicka på Hjälp mig att välja

ange bildbeskrivning här Diagram över de aktuella Android-versionens distributioner, visas när du klickar på Hjälp mig att välja.

Fönstret Distribution för Android-plattformen visar distributionen av mobila enheter som kör varje version av Android, som visas i figur 2. Klicka på en API-nivå för att se en lista med funktioner som introducerats i motsvarande Android-version. Detta hjälper dig att välja den minsta API-nivån som har alla funktioner som dina appar behöver, så att du kan nå så många enheter som möjligt. Klicka sedan på OK .

Välj nu vilka plattformar och version av Android SDK som applikationen kommer att stödja.

SDK-version Dialog

För nu väljer du bara Telefon och surfplatta .

Minsta SDK är den nedre gränsen för din app. Det är en av signalerna som Google Play Store använder för att avgöra vilka enheter en app kan installeras på. Till exempel stöder Stack Exchange-appen Android 4.1+.

Stack Exchange: s app
Android Studio kommer att berätta (ungefär) vilken procentandel enheter som stöds med tanke på det angivna minimum SDK.

Lägre API-nivåer är inriktade på fler enheter men har färre funktioner tillgängliga.

När du beslutar om minimum SDK bör du ta hänsyn till statistiken på Dashboards som ger dig versioninformation om enheterna som besökte Google Play Store globalt under den senaste veckan.

Skärmdump av den nuvarande Android-distributionen

Från: Dashboards på Android Developer-webbplats.

Lägg till en aktivitet

Nu ska vi välja en standardaktivitet för vår applikation. I Android är en Activity en enda skärm som kommer att presenteras för användaren. En applikation kan hysa flera aktiviteter och navigera mellan dem. I det här exemplet väljer du Empty Activity och klickar på Nästa.

Här kan du ändra namnet på aktiviteten och layouten om du vill. En bra praxis är att behålla Activity som ett efterföljd för aktivitetsnamnet och activity_ som ett prefix för layoutnamnet. Om vi lämnar dessa som standard kommer Android Studio generera en aktivitet för oss kallas MainActivity och en layout fil som heter activity_main . Klicka nu på Finish .

Android Studio skapar och konfigurerar vårt projekt, vilket kan ta lite tid beroende på systemet.

Inspekterar projektet

För att förstå hur Android fungerar, låt oss titta på några av filerna som skapades för oss.

På den vänstra rutan för Android Studio kan vi se strukturen för vår Android-applikation .

Grundläggande applikationsstruktur

Låt oss först öppna AndroidManifest.xml genom att dubbelklicka på den. Android-manifestfilen beskriver en del av den grundläggande informationen om en Android-applikation. Den innehåller deklarationen av våra aktiviteter, samt några mer avancerade komponenter.

Om en applikation behöver åtkomst till en funktion som är skyddad av en tillåtelse, måste den förklara att den kräver det tillståndet med ett <uses-permission> -element i manifestet. När applikationen sedan installeras på enheten bestämmer installationsprogrammet huruvida den begärda behörigheten ska beviljas eller inte genom att kontrollera myndigheterna som undertecknade applikationens certifikat och i vissa fall fråga användaren. En applikation kan också skydda sina egna komponenter (aktiviteter, tjänster, sändningsmottagare och innehållsleverantörer) med behörigheter. Den kan använda någon av de behörigheter som definierats av Android (listad i android.Manifest.permission) eller deklarerats av andra applikationer. Eller så kan den definiera sin egen.

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

Låt oss nu öppna activity_main.xml som finns i app/src/main/res/layout/ . Denna fil innehåller deklarationer för de visuella komponenterna i vår MainActivity. Du kommer att se visuell designer. Detta låter dig dra och släppa element till den valda layouten.

Du kan också växla till xml-layoutdesignern genom att klicka på "Text" längst ner i Android Studio, så här:

Layoutdesign / textflikar

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

Du kommer att se en widget som kallas en TextView inuti denna layout, med egenskapen android:text inställd på "Hello World!". Detta är ett textblock som visas för användaren när de kör applikationen.

Du kan läsa mer om layouter och attribut .

Låt oss nu ta en titt på MainActivity . Detta är Java-koden som har genererats för 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);
    }
}
 

Som definierat i vårt Android-manifest kommer MainActivity att starta som standard när en användare startar HelloWorld appen.

Slutligen, öppna upp filen med namnet build.gradle finns i app/ .
Android Studio använder build-systemet Gradle för att sammanställa och bygga Android-applikationer och bibliotek.

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'
}
 

Den här filen innehåller information om build och din appversion, och du kan också använda den för att lägga till beroenden till externa bibliotek. För nu, låt oss inte göra några ändringar.

Det rekommenderas att alltid välja den senaste versionen som är tillgänglig för beroenden:

compileSdkVersion

compileSdkVersion är ditt sätt att berätta för Gradle vilken version av Android SDK som du ska kompilera din app med. Att använda den nya Android SDK är ett krav för att använda någon av de nya API: er som läggs till på den nivån.

Det bör betonas att ändring av din compileSdkVersion inte förändrar körbeteende. Medan nya kompilatorvarningar / -fel kan finnas när du ändrar din compileSdkVersion , ingår inte din compileSdkVersion i din APK: den används rent vid kompileringstiden.

Därför rekommenderas det starkt att du alltid sammanställer med den senaste SDK: n. Du får alla fördelarna med nya sammanställningskontroller av befintlig kod, undvik nyligen avskrivna API: er och vara redo att använda nya API: er.

minSdkVersion

Om compileSdkVersion ställer in de senaste API: erna tillgängliga för dig, är minSdkVersion den undre gränsen för din app. minSdkVersion är en av signalerna som Google Play Store använder för att avgöra vilken av användarens enheter en app kan installeras på.

Det spelar också en viktig roll under utvecklingen: som standard löper ludd mot ditt projekt och varnar dig när du använder några API: er ovanför minSdkVersion , vilket hjälper dig att undvika runtime-problemet med att försöka ringa ett API som inte finns. Att kontrollera systemversionen vid körning är en vanlig teknik när man bara använder API: er på nyare plattformsversioner.

targetSdkVersion

targetSdkVersion är det huvudsakliga sättet för att Android ger framåtkompatibilitet genom att inte tillämpa beteendeförändringar om inte targetSdkVersion är uppdaterad. Detta gör att du kan använda nya API: er innan du arbetar genom beteendeförändringar. Uppdatering för att rikta in sig på den senaste SDK: n bör vara en hög prioritet för varje app. Det betyder inte att du måste använda alla nya funktioner som introduceras och inte heller ska du uppdatera din targetSdkVersion utan att testa.

targetSDKVersion är den version av Android som är den övre gränsen för tillgängliga verktyg. Om targetSDKVersion är mindre än 23, behöver appen inte begära behörigheter vid körning för en instans, även om appen körs på API 23+. TargetSDKVersion hindrar inte Android-versioner ovanför plockas Android-version från att köra appen.

Du kan hitta mer info om Gradle-plugin:

Kör applikationen

Låt oss nu köra vår HelloWorld-applikation. Du kan antingen köra en virtuell Android-enhet (som du kan ställa in med hjälp av AVD Manager i Android Studio, som beskrivs i exemplet nedan) eller ansluta din egen Android-enhet via en USB-kabel.

Ställa in en Android-enhet

Om du USB Debugging köra en applikation från Android Studio på din Android-enhet måste du aktivera USB Debugging i Developer Options i enhetens inställningar.

Settings > Developer options > USB debugging

Om Developer Options inte syns i inställningarna, navigerar du till About Phone och trycker på Build Number sju gånger. Detta gör det möjligt för Developer Options att visas i dina inställningar.

Settings > About phone > Build number

Du kanske också måste ändra build.gradle konfigurationen för att bygga på en version som din enhet har.

Kör från Android Studio

Klicka på den gröna Run knappen från verktygsfältet högst upp i Android Studio. I fönstret som visas väljer du vilken enhet du vill köra appen på (starta en Android Virtual Device om det behövs, eller se Ställa in en AVD (Android Virtual Device) om du behöver installera en) och klicka på OK .

Kör-knappen

På enheter som kör Android 4.4 (KitKat) och eventuellt högre, visas en pop-up som godkänner USB-felsökning. Klicka på OK att acceptera.

Programmet kommer nu att installeras och köras på din Android-enhet eller emulator.

APK-filplats

När du förbereder din ansökan för frisläppning konfigurerar du, bygger och testar en version av din ansökan. Konfigurationsuppgifterna är enkla och involverar grundläggande kodrensning och kodändringsuppgifter som hjälper till att optimera din applikation. Byggprocessen liknar felsökningsprocessen och kan göras med JDK och Android SDK-verktyg. Testuppgifterna fungerar som en slutkontroll, vilket säkerställer att din applikation fungerar som förväntat under verkliga förhållanden. När du är klar med att förbereda din ansökan för utsläpp har du en signerad APK-fil som du kan distribuera direkt till användare eller distribuera via en applikationsmarknad som Google Play.

Android Studio

Eftersom i ovanstående exempel används Gradle är platsen för den genererade APK-filen: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Om du är en användare av IntelliJ innan du byter till Studio och importerar ditt IntelliJ-projekt direkt ändras ingenting. Platsen för utgången kommer att vara densamma under:

out/production/...
 

Obs: detta kommer att avskrivas ibland runt 1,0

Förmörkelse

Om du importerar Android Eclipse-projektet direkt, gör inte detta! Så fort du har beroenden i ditt projekt (burkar eller biblioteksprojekt) fungerar detta inte och ditt projekt kommer inte att konfigureras ordentligt. Om du inte har några beroenden skulle apk vara under samma plats som du hittar den i Eclipse:

bin/...
 

Ställa in en AVD (Android Virtual Device)

TL; DR Det låter oss i princip simulera verkliga enheter och testa våra appar utan en riktig enhet.

Enligt Android Developer Documentation ,

Med en definition av Android Virtual Device (AVD) kan du definiera egenskaperna för en Android-telefon, surfplatta, Android Wear eller Android TV-enhet som du vill simulera i Android-emulatorn. AVD Manager hjälper dig enkelt skapa och hantera AVD: er.

Så här ställer du in en AVD:

1. Klicka på den här knappen för att få fram AVD Manager:

AVD Manager-ikon

2. Du bör se en dialogruta som denna:

AVD Manager Dialog

3. Klicka nu på knappen + Create Virtual Device... Detta kommer att visa dialogrutan för konfigurering av virtuella enheter:

Dialog för konfiguration av virtuella enheter

4. Välj vilken enhet du vill och klicka sedan på Next :

Välj systembild

5. Här måste du välja en Android-version för din emulator. Du kanske också måste ladda ner den först genom att klicka på Download . När du har valt en version klickar du på Next .

Avancerade inställningar

6. Ange här ett namn för din emulator, initial orientering och om du vill visa en ram runt den. När du har valt alla dessa, klicka på Finish .

7. Nu har du en ny AVD redo att starta dina appar på den.

AVD

Ställa in Android Studio

Android Studio är Android-utvecklings-IDE som officiellt stöds och rekommenderas av Google. Android Studio levereras med Android SDK Manager , som är ett verktyg för att ladda ner Android SDK komponenterna som krävs för att börja utveckla appar.

Installera Android Studio och Android SDK verktyg:

  1. Ladda ner och installera Android Studio .
  2. Ladda ner de senaste SDK-verktygen och SDK-plattformsverktygen genom att öppna Android Studio och sedan följa anvisningarna för Android SDK Tool Updates . Du bör installera de senaste tillgängliga stabila paketen.

Om du behöver arbeta med gamla projekt som byggdes med äldre SDK-versioner, kan du behöva ladda ner dessa versioner också

Sedan Android Studio 2.2 kommer en kopia av den senaste OpenJDK med installationen och är den rekommenderade JDK (Java Development Kit) för alla Android Studio-projekt. Detta tar bort kravet på att ha Oracle's JDK-paket installerat. Gör så här för att använda den medföljande SDK: n;

  1. Öppna ditt projekt i Android Studio och välj Arkiv> Projektstruktur i menyraden.
  2. Markera kryssrutan Använd inbäddad JDKSDK-platssidan och under JDK-plats .
  3. Klicka på OK .

Konfigurera Android Studio

Android Studio ger tillgång till två konfigurationsfiler via Hjälp-menyn:

  • studio.vmoptions : Anpassa alternativ för Studio's Java Virtual Machine (JVM), till exempel högstorlek och cache-storlek. Observera att den här filen kan kallas studio64.vmoptions på Linux-maskiner, beroende på din version av Android Studio.
  • idea.properties : Anpassa Android Studio-egenskaper, till exempel mappvägen för plugins eller maximal filstorlek som stöds.

Ändra / lägg till tema

Du kan ändra det efter dina önskemål. File->Settings->Editor->Colors & Fonts-> och välj ett tema. Du kan också ladda ner nya teman från http://color-themes.com/ När du har laddat ner .jar.zip filen, gå till File -> Import Settings... och välj den nedladdade filen.

Kompilera appar

Skapa ett nytt projekt eller öppna ett befintligt projekt i Android Studio och tryck på den gröna Play-knappen ange bildbeskrivning här på det översta verktygsfältet för att köra det. Om det är grått måste du vänta en sekund för att tillåta Android Studio att indexera vissa filer ordentligt, vars framsteg kan ses i den nedre statusfältet.

Om du vill skapa ett projekt från skalet, se till att du har en local.properties fil, som skapas automatiskt av Android Studio. Om du behöver skapa projektet utan Android Studio behöver du en rad som börjar med sdk.dir= följt av sökvägen till din SDK-installation.

Öppna ett skal och gå in i projektets katalog. Ange ./gradlew aR och tryck på enter. aR är en genväg för assembleRelease , som kommer att ladda ner alla beroenden för dig och bygga appen. Den sista APK-filen kommer att vara i ProjectName/ModuleName/build/outputs/apk och kommer att kallas ModuleName-release.apk .