AndroidRozpoczęcie pracy z systemem Android


Uwagi

Jeśli chcesz dowiedzieć się więcej o ustawieniach wtyczki Gradle dla Androida, zapoznaj się z Dokumentacją dla android-gradle .

Jeśli interesują Cię alternatywne emulatory, możesz spojrzeć na Genymotion . Zapewnia bezpłatny plan i wymaga mniejszej ilości pamięci RAM.

Wersje

Wersja Poziom API Kod wersji Data wydania
1.0 1 BASE 23.09.2008
1.1 2) BASE_1_1 2009-02-09
1.5 3) CUPCAKE 27.04.2009
1.6 4 DONUT 15.09.2009
2.0 5 ECLAIR 26.10.2009
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 06.12.2010
2.3.3 10 GINGERBREAD_MR1 2011-02-09
3.0.x 11 HONEYCOMB 22.02.2011
3.1.x 12 HONEYCOMB_MR1 2011-05-10
3.2.x 13 HONEYCOMB_MR2 2011-07-15
4.0 14 ICE_CREAM_SANDWICH 18.10.2011
4.0.3 15 ICE_CREAM_SANDWICH_MR1 16.12.2011
4.1 16 JELLY_BEAN 09.07.2012
4.2 17 JELLY_BEAN_MR1 13.11.2012
4.3 18 JELLY_BEAN_MR2 2013-07-24
4.4 19 KITKAT 31.10.2013
4,4 W. 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 (Zefir) 2015-10-05
7.0 24 N (Nugat) 22.08.2016
7.1 25 N_MR1 (Nougat MR1) 04.10.2016
8.0 26 O (podgląd programisty 4) 2017-07-24

Programowanie na Androida bez IDE

Jest to minimalistyczny przykład Hello World, który używa tylko najbardziej podstawowych narzędzi Androida.

Wymagania i założenia

W tym przykładzie przyjęto, że Linux. Może być konieczne dostosowanie składni dla własnej platformy.

Konfigurowanie zestawu SDK systemu Android

Po rozpakowaniu wydania zestawu SDK:

  1. Zainstaluj dodatkowe pakiety za pomocą menedżera SDK. Nie używaj android update sdk --no-ui zgodnie z instrukcją w dołączonym pliku Readme.txt; pobiera około 30 GB niepotrzebnych plików. Zamiast tego użyj interaktywnego menedżera SDK android sdk SDK, aby uzyskać zalecane minimum pakietów.

  2. Dołącz następujące katalogi JDK i SDK do PATH wykonania. Jest to opcjonalne, ale zakładają to poniższe instrukcje.

    • JDK / bin
    • SDK / narzędzia platformy
    • SDK / narzędzia
    • SDK / build-tools / NAJNOWSZE (zainstalowane w kroku 1)
  3. Utwórz wirtualne urządzenie z Androidem. Użyj interaktywnego AVD Managera ( android avd AVD). Być może będziesz musiał trochę pogrzebać i poszukać porady; instrukcje na miejscu nie zawsze są pomocne.

    (Możesz także użyć własnego urządzenia)

  4. Uruchom urządzenie:

    emulator -avd DEVICE
     
  5. Jeśli ekran urządzenia wydaje się być zablokowany, przeciągnij, aby go odblokować.

    Pozostaw kod uruchomiony podczas pisania aplikacji.

Kodowanie aplikacji

  1. Przejdź do pustego katalogu roboczego.

  2. Utwórz plik źródłowy:

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

    Zawartość:

    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. Dodaj manifest:

    touch AndroidManifest.xml
     

    Zawartość:

    <?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. Utwórz podkatalog dla zadeklarowanych zasobów:

    mkdir res
     

    Na razie zostaw to puste.

Budowanie kodu

  1. Wygeneruj źródło dla deklaracji zasobów. Podaj tutaj poprawną ścieżkę do zestawu SDK i zainstalowanego interfejsu API, na którym chcesz budować (np. „Android-23”):

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

    Deklaracje zasobów (opisane poniżej) są w rzeczywistości opcjonalne. W międzyczasie powyższe wywołanie nic nie robi, jeśli res / jest nadal pusty.

  2. Skompiluj kod źródłowy do kodu bajtowego Java (.java → .class):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
     
  3. Przetłumacz kod bajtowy z Java na Android (.class → .dex):

    Najpierw użyj Jill (.class → .jayce):

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

    Następnie Jack (.jayce → .dex):

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

    Android bajtecode był kiedyś nazywany „kodem wykonywalnym Dalvik”, a więc „dex”.

    Jeśli chcesz, możesz zastąpić kroki 11 i 12 jednym telefonem do Jacka; można go skompilować bezpośrednio ze źródła Java (.java → .dex). Ale kompilacja z javac ma zalety. Jest to lepiej znane, lepiej udokumentowane i szerzej stosowane narzędzie.

  4. Spakuj pliki zasobów, w tym manifest:

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

    Powoduje to częściowy plik APK (pakiet aplikacji dla systemu Android).

  5. Zrób pełny ApkBuilder APK za pomocą narzędzia ApkBuilder :

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

    Ostrzega: „TO NARZĘDZIE JEST DEPRECATED. Zobacz - help, aby uzyskać więcej informacji”. Jeśli --help nie powiedzie się z ArrayIndexOutOfBoundsException , zamiast tego nie przekazuj żadnych argumentów:

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

    Wyjaśnia, że CLI ( ApkBuilderMain ) jest przestarzały na korzyść bezpośredniego wywoływania Java API ( ApkBuilder ). (Jeśli wiesz, jak to zrobić z wiersza polecenia, zaktualizuj ten przykład).

  6. Zoptymalizuj wyrównanie danych APK ( zalecana praktyka ):

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

Instalowanie i uruchamianie

  1. Zainstaluj aplikację na urządzeniu z Androidem:

    adb install -r app.apk
     
  2. Uruchom aplikację:

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

    Powinien biec i przywitać się.

To wszystko. Tak trzeba się przywitać za pomocą podstawowych narzędzi Androida.

Deklarowanie zasobu

Ta sekcja jest opcjonalna. Deklaracje zasobów nie są wymagane w przypadku prostej aplikacji „hello world”. Jeśli nie są one również wymagane w Twojej aplikacji, możesz nieco usprawnić kompilację, pomijając krok 10 i usuwając odniesienie do katalogu res / z kroku 13.

W przeciwnym razie oto krótki przykład, jak zadeklarować zasób i jak do niego odwoływać.

  1. Dodaj plik zasobów:

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

    Zawartość:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
     
  2. Odwołaj się do zasobu z manifestu XML. Jest to deklaratywny styl odniesienia:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
     
  3. Odwołaj się do tego samego zasobu ze źródła Java. Jest to bezwzględnie konieczne odniesienie:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
     
  4. Przetestuj powyższe modyfikacje, przebudowując, ponownie instalując i ponownie uruchamiając aplikację (kroki 10-17).

    Powinien zostać ponownie uruchomiony i powiedzieć: „Ta aplikacja nazywa się Saying hello”.

Odinstalowywanie aplikacji

adb uninstall dom.domain
 

Zobacz też

Podstawy aplikacji

Aplikacje na Androida są napisane w Javie. Narzędzia zestawu SDK systemu Android kompilują kod, dane i pliki zasobów w pakiecie APK (pakiet systemu Android). Zasadniczo jeden plik APK zawiera całą zawartość aplikacji.

Każda aplikacja działa na własnej maszynie wirtualnej (VM), dzięki czemu można ją uruchomić w izolacji od innych aplikacji. System Android działa na zasadzie najmniejszych uprawnień. Każda aplikacja ma dostęp tylko do komponentów, których wymaga do wykonania swojej pracy, i nie więcej. Istnieją jednak sposoby udostępniania aplikacji przez inne aplikacje, na przykład poprzez udostępnianie identyfikatora użytkownika Linux między aplikacjami, lub aplikacje mogą poprosić o pozwolenie na dostęp do danych urządzenia, takich jak karta SD, kontakty itp.

Komponenty aplikacji

Komponenty aplikacji są elementami składowymi aplikacji na Androida. Każdy komponent odgrywa określoną rolę w aplikacji na Androida, która służy do określonego celu i ma odrębne cykle życia (przebieg, w jaki sposób i kiedy komponent jest tworzony i niszczony). Oto cztery typy komponentów aplikacji:

  1. Działania: Działanie reprezentuje pojedynczy ekran z interfejsem użytkownika (UI). Aplikacja na Androida może mieć więcej niż jedną aktywność. (np. aplikacja e-mailowa może mieć jedno działanie, aby wyświetlić listę wszystkich e-maili, drugie, aby wyświetlić zawartość każdego e-maila, a drugie, aby utworzyć nową wiadomość e-mail). Wszystkie działania w aplikacji współpracują ze sobą, aby utworzyć User eXperience (UX).
  2. Usługi: usługa działa w tle, aby wykonywać długotrwałe operacje lub wykonywać prace na rzecz zdalnych procesów. Usługa nie zapewnia interfejsu użytkownika, działa tylko w tle, z danymi wejściowymi użytkownika. (np. usługa może odtwarzać muzykę w tle, gdy użytkownik jest w innej aplikacji lub może pobierać dane z Internetu bez blokowania interakcji użytkownika z urządzeniem z Androidem).
  3. Dostawcy treści: dostawca treści zarządza udostępnianymi danymi aplikacji. Istnieją cztery sposoby przechowywania danych w aplikacji: można je zapisać do pliku i zapisać w systemie plików, wstawić lub zaktualizować w bazie danych SQLite, opublikować w Internecie lub zapisać w innym stałym miejscu do przechowywania, do którego aplikacja może uzyskać dostęp . Za pośrednictwem dostawców treści inne aplikacje mogą wyszukiwać, a nawet modyfikować dane. (np. system Android zapewnia dostawcę treści, który zarządza danymi kontaktowymi użytkownika, dzięki czemu dowolna aplikacja, która ma uprawnienia, może wysyłać zapytania do kontaktów.) Dostawców treści można również używać do zapisywania danych prywatnych w aplikacji w celu lepszej integralności danych.
  4. Odbiorniki rozgłoszeniowe: Odbiornik rozgłoszeniowy reaguje na ogólnosystemowe transmisje zapowiedzi (np. Transmisja zapowiadająca wyłączenie ekranu, niski poziom naładowania akumulatora itp.) Lub z aplikacji (np. Aby poinformować inne aplikacje, że niektóre dane zostały pobrane na urządzenie i jest dla nich dostępny). Odbiorniki rozgłoszeniowe nie mają interfejsów użytkownika, ale mogą wyświetlać powiadomienia na pasku stanu, aby ostrzec użytkownika. Zwykle odbiorniki nadawcze są używane jako brama do innych elementów aplikacji, składających się głównie z działań i usług.

Jednym unikalnym aspektem systemu Android jest to, że każda aplikacja może uruchomić komponent innej aplikacji (np. Jeśli chcesz zadzwonić, wysłać SMS, otworzyć stronę internetową lub wyświetlić zdjęcie, istnieje aplikacja, która już to robi, a Twoja aplikacja może skorzystaj z niego, zamiast opracowywać nowe działanie dla tego samego zadania).

Kiedy system uruchamia komponent, uruchamia proces dla tej aplikacji (jeśli jeszcze nie jest uruchomiony, tj. Tylko jeden proces pierwszego planu na aplikację może być uruchomiony w danym momencie w systemie Android) i tworzy instancję klas potrzebnych dla tego komponentu. W ten sposób komponent działa w procesie aplikacji, do której należy. Dlatego, w przeciwieństwie do aplikacji na innych systemach, aplikacje na Androida nie mają jednego punktu wejścia (nie ma metody main() ).

Ponieważ system uruchamia każdą aplikację w osobnym procesie, jedna aplikacja nie może bezpośrednio aktywować składników innej aplikacji, jednak system Android może to zrobić. Tak więc, aby uruchomić komponent innej aplikacji, jedna aplikacja musi wysłać do systemu komunikat określający zamiar uruchomienia tego komponentu, a następnie system uruchomi ten komponent.

Kontekst

Wystąpienia klasy android.content.Context zapewniają połączenie z systemem Android, który wykonuje aplikację. Wystąpienie kontekstu jest wymagane, aby uzyskać dostęp do zasobów projektu i globalnych informacji o środowisku aplikacji.

Weźmy prosty przykład: zastanów się, czy jesteś w hotelu i chcesz coś zjeść. Dzwonisz do obsługi pokoju i prosisz ich o przyniesienie ci rzeczy lub posprzątanie rzeczy dla ciebie. Teraz pomyśl o tym hotelu jako aplikacji na Androida, o sobie jako o działalności, a osoba zajmująca się obsługą pokoju jest Twoim kontekstem, który zapewnia dostęp do zasobów hotelu, takich jak obsługa pokoju, artykuły spożywcze itp.

Jeszcze inny przykład: jesteś w restauracji siedzącej na stole, każdy stół ma opiekuna, a kiedy chcesz zamówić produkty spożywcze, poprosisz o to. Obsługujący następnie składa zamówienie, a artykuły żywnościowe są podawane na stole. Ponownie w tym przykładzie restauracja jest aplikacją na Androida, stoły lub klienci są komponentami aplikacji, produkty żywnościowe są zasobami aplikacji, a opiekun jest twoim kontekstem, umożliwiając w ten sposób dostęp do zasobów takich jak produkty żywnościowe.

Aktywacja dowolnego z powyższych składników wymaga wystąpienia kontekstu. Nie tylko powyższe, ale prawie każdy zasób systemowy: tworzenie interfejsu użytkownika za pomocą widoków (omówione później), tworzenie instancji usług systemowych, rozpoczynanie nowych działań lub usług - wszystko to wymaga kontekstu.

Bardziej szczegółowy opis znajduje się tutaj .

Tworzenie nowego projektu

Skonfiguruj Android Studio

Zacznij od skonfigurowania Android Studio, a następnie otwórz go. Teraz możesz przygotować swoją pierwszą aplikację na Androida!

Uwaga: ten przewodnik jest oparty na systemie Android Studio 2.2, ale proces w innych wersjach jest zasadniczo taki sam.

Skonfiguruj swój projekt

Podstawowa konfiguracja

Możesz rozpocząć nowy projekt na dwa sposoby:

  • Kliknij Start a New Android Studio Project na ekranie powitalnym.
  • Przejdź do FileNew Project jeśli masz już otwarty projekt.

Następnie musisz opisać swoją aplikację, wypełniając niektóre pola:

  1. Nazwa aplikacji - ta nazwa będzie wyświetlana użytkownikowi.

    Przykład: Hello World . Zawsze możesz go później zmienić w pliku AndroidManifest.xml .

  2. Domena firmy - jest to kwalifikator dla nazwy pakietu projektu.

    Przykład: stackoverflow.com .

  3. Nazwa pakietu (inaczej applicationId ) - jest to w pełni kwalifikowana nazwa pakietu projektu.

    Należy postępować Odwrócona Domain Name notacją (aka): Odwrócona DNS domeny najwyższego poziomu. Domena firmy . [ Segment firmy . ] Nazwa aplikacji .

    Przykład: com.stackoverflow.android.helloworld lub com.stackoverflow.helloworld . Zawsze możesz zmienić swoją aplikację , zastępując ją w pliku ocen .

Nie używaj domyślnego przedrostka „com.example”, chyba że nie zamierzasz przesyłać aplikacji do sklepu Google Play. Nazwa pakietu będzie Twoją unikalną aplikacją w Google Play.

  1. Lokalizacja projektu - jest to katalog, w którym będzie przechowywany projekt.

Okno dialogowe nowego projektu

Wybierz Form Factors i API Level

Następne okno pozwala wybrać czynniki kształtu obsługiwane przez aplikację, takie jak telefon, tablet, telewizor, odzież i Google Glass. Wybrane czynniki kształtu stają się modułami aplikacji w ramach projektu. Dla każdego współczynnika kształtu możesz także wybrać poziom API dla tej aplikacji. Aby uzyskać więcej informacji, kliknij opcję Pomóż mi wybrać

wprowadź opis zdjęcia tutaj Wykres aktualnych dystrybucji wersji Androida, pokazany po kliknięciu Pomóż mi wybrać.

Okno dystrybucji platformy Android pokazuje dystrybucję urządzeń mobilnych z każdą wersją Androida, jak pokazano na rysunku 2. Kliknij poziom interfejsu API, aby zobaczyć listę funkcji wprowadzonych w odpowiedniej wersji Androida. Pomaga to wybrać minimalny poziom interfejsu API, który ma wszystkie funkcje potrzebne aplikacjom, dzięki czemu można dotrzeć do jak największej liczby urządzeń. Następnie kliknij OK .

Teraz wybierz platformy i wersje zestawu Android SDK, które aplikacja będzie obsługiwać.

Okno dialogowe wersji SDK

Na razie wybierz tylko telefon i tablet .

Minimalny zestaw SDK to dolna granica dla Twojej aplikacji. Jest to jeden z sygnałów wykorzystywanych przez Google Play Store do określania, na których urządzeniach można zainstalować aplikację. Na przykład aplikacja Stack Exchange obsługuje system Android 4.1+.

Aplikacja Stack Exchange
Android Studio poinformuje (w przybliżeniu), jaki procent urządzeń będzie obsługiwany, biorąc pod uwagę określony minimalny zestaw SDK.

Niższe poziomy API są kierowane na większą liczbę urządzeń, ale dostępnych jest mniej funkcji.

Decydując się na minimalny zestaw SDK , powinieneś wziąć pod uwagę statystyki paneli kontrolnych , które dostarczą informacji o wersji urządzeń, które odwiedziły sklep Google Play na całym świecie w ostatnim tygodniu.

Zrzut ekranu bieżącej dystrybucji Androida

Od: Pulpity nawigacyjne na stronie programisty Androida.

Dodaj aktywność

Teraz wybierzemy domyślną aktywność dla naszej aplikacji. W Androidzie Activity to pojedynczy ekran, który zostanie przedstawiony użytkownikowi. Aplikacja może pomieścić wiele działań i nawigować między nimi. W tym przykładzie wybierz Empty Activity i kliknij przycisk Dalej.

Tutaj, jeśli chcesz, możesz zmienić nazwę działania i układu. Dobrą praktyką jest zachowanie Activity jako sufiksu nazwy działania, a activity_ jako prefiksu nazwy układu. Jeśli pozostawimy je jako domyślne, Android Studio wygeneruje dla nas działanie o nazwie MainActivity i plik układu o nazwie activity_main . Teraz kliknij przycisk Finish .

Android Studio utworzy i skonfiguruje nasz projekt, co może zająć trochę czasu w zależności od systemu.

Sprawdzanie projektu

Aby zrozumieć, jak działa Android, rzućmy okiem na niektóre pliki, które zostały dla nas utworzone.

W lewym okienku Android Studio możemy zobaczyć strukturę naszej aplikacji na Androida .

Podstawowa struktura aplikacji

Najpierw otwórzmy AndroidManifest.xml , klikając go dwukrotnie. Plik manifestu Androida opisuje niektóre podstawowe informacje o aplikacji na Androida. Zawiera deklarację naszych działań, a także niektóre bardziej zaawansowane komponenty.

Jeśli aplikacja potrzebuje dostępu do funkcji chronionej uprawnieniem, musi zadeklarować, że wymaga tego uprawnienia z elementem <uses-permission> w manifeście. Następnie, gdy aplikacja jest instalowana na urządzeniu, instalator określa, czy udzielić żądanego pozwolenia, sprawdzając organy, które podpisały certyfikaty aplikacji, a w niektórych przypadkach pytając użytkownika. Aplikacja może również chronić własne komponenty (działania, usługi, odbiorniki i dostawcy treści) za pomocą uprawnień. Może wykorzystywać dowolne uprawnienia zdefiniowane przez Androida (wymienione w android.Manifest.permission) lub zadeklarowane przez inne aplikacje. Lub może zdefiniować własne.

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

Następnie otwórzmy plik activity_main.xml który znajduje się w app/src/main/res/layout/ . Ten plik zawiera deklaracje dotyczące elementów wizualnych naszej MainActivity. Zobaczysz projektanta wizualnego. Umożliwia to przeciąganie i upuszczanie elementów na wybrany układ.

Możesz także przejść do projektanta układu XML, klikając „Tekst” na dole Android Studio, jak pokazano tutaj:

Projektowanie układu / karty tekstowe

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

W tym układzie zobaczysz widżet o nazwie TextView z ustawieniem właściwości android:text na „Hello World!”. Jest to blok tekstu, który zostanie wyświetlony użytkownikowi po uruchomieniu aplikacji.

Możesz przeczytać więcej o układach i atrybutach .

Następnie spójrzmy na MainActivity . To jest kod Java, który został wygenerowany dla 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);
    }
}
 

Zgodnie z definicją w naszym manifeście dla Androida, MainActivity uruchomi się domyślnie, gdy użytkownik uruchomi aplikację HelloWorld .

Na koniec otwórz plik o nazwie build.gradle znajdujący się w app/ .
Android Studio używa systemu kompilacji Gradle do kompilacji i kompilacji aplikacji i bibliotek na Androida.

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

Ten plik zawiera informacje o kompilacji i wersji aplikacji. Można go również użyć do dodania zależności do bibliotek zewnętrznych. Na razie nie wprowadzajmy żadnych zmian.

Wskazane jest, aby zawsze wybierać najnowszą dostępną wersję dla zależności:

compileSdkVersion

compileSdkVersion to sposób, aby powiedzieć Gradle, z jaką wersją zestawu SDK systemu Android chcesz skompilować aplikację. Korzystanie z nowego zestawu SDK systemu Android jest wymagane, aby użyć dowolnego z nowych interfejsów API dodanych na tym poziomie.

Należy podkreślić, że zmiana twojego compileSdkVersion nie zmienia zachowania środowiska wykonawczego. Podczas gdy nowe ostrzeżenia / błędy kompilatora mogą compileSdkVersion podczas zmiany twojego compileSdkVersion , twój compileSdkVersion nie jest zawarty w twoim APK: jest używany tylko podczas kompilacji.

Dlatego zdecydowanie zaleca się, aby zawsze kompilować z najnowszym zestawem SDK. Otrzymasz wszystkie korzyści z nowych kontroli kompilacji istniejącego kodu, unikniesz nowo przestarzałych interfejsów API i będziesz gotowy do korzystania z nowych interfejsów API.

minSdkVersion

Jeśli compileSdkVersion ustawia najnowsze dostępne interfejsy API, minSdkVersion jest dolną granicą dla Twojej aplikacji. minSdkVersion jest jednym z sygnałów wykorzystywanych przez Sklep Google Play do określania, na których urządzeniach użytkownika można zainstalować aplikację.

Odgrywa także ważną rolę podczas programowania: domyślnie linka działa na Twój projekt, ostrzegając Cię, gdy używasz interfejsów API powyżej minSdkVersion , pomagając uniknąć problemu w czasie wykonywania próby wywołania API, który nie istnieje. Sprawdzanie wersji systemu w czasie wykonywania jest powszechną techniką w przypadku używania interfejsów API tylko w nowszych wersjach platformy.

targetSdkVersion

targetSdkVersion jest głównym sposobem, w jaki Android zapewnia kompatybilność do przodu, nie stosując zmian w zachowaniu, chyba że targetSdkVersion jest aktualizowany. Umożliwia to korzystanie z nowych interfejsów API przed omówieniem zmian w zachowaniu. Aktualizacja w celu kierowania na najnowszy zestaw SDK powinna mieć wysoki priorytet dla każdej aplikacji. Nie oznacza to, że musisz korzystać z każdej nowej wprowadzonej funkcji, ani nie powinieneś ślepo aktualizować targetSdkVersion bez testowania.

targetSDKVersion to wersja Androida, która jest górną granicą dostępnych narzędzi. Jeśli wartość targetSDKVersion jest mniejsza niż 23, aplikacja nie musi żądać uprawnień w czasie wykonywania dla instancji, nawet jeśli aplikacja jest uruchomiona w interfejsie API 23+. TargetSDKVersion nie zapobiega uruchamianiu aplikacji w wersjach Androida powyżej wybranej wersji Androida.

Możesz znaleźć więcej informacji o wtyczce Gradle:

Uruchamianie aplikacji

Teraz uruchommy naszą aplikację HelloWorld. Możesz uruchomić urządzenie wirtualne z systemem Android (które można skonfigurować za pomocą Menedżera AVD w Android Studio, jak opisano w poniższym przykładzie) lub podłączyć własne urządzenie z Androidem za pomocą kabla USB.

Konfigurowanie urządzenia z Androidem

Aby uruchomić aplikację z Android Studio na urządzeniu z Androidem, musisz włączyć USB Debugging w Developer Options w ustawieniach urządzenia.

Settings > Developer options > USB debugging

Jeśli Developer Options nie są widoczne w ustawieniach, przejdź do About Phone i dotknij Build Number siedem razy. Umożliwi to wyświetlanie Developer Options programisty w ustawieniach.

Settings > About phone > Build number

Konieczna może być również zmiana konfiguracji build.gradle aby budować na wersji posiadanej przez urządzenie.

Uruchamianie z Android Studio

Kliknij zielony przycisk Run na pasku narzędzi u góry Android Studio. W wyświetlonym oknie wybierz urządzenie, na którym chcesz uruchomić aplikację (w razie potrzeby uruchom urządzenie wirtualne z systemem Android lub zobacz Konfigurowanie AVD (urządzenie wirtualne z systemem Android), jeśli chcesz je skonfigurować) i kliknij przycisk OK .

Uruchom przycisk

Na urządzeniach z Androidem 4.4 (KitKat) i prawdopodobnie nowszym, pojawi się wyskakujące okienko autoryzujące debugowanie USB. Kliknij OK aby zaakceptować.

Aplikacja zostanie teraz zainstalowana i uruchomiona na urządzeniu z Androidem lub emulatorze.

Lokalizacja pliku APK

Przygotowując aplikację do wydania, konfigurujesz, budujesz i testujesz wersję aplikacji. Zadania konfiguracyjne są proste i obejmują podstawowe zadania czyszczenia i modyfikacji kodu, które pomagają zoptymalizować aplikację. Proces kompilacji jest podobny do procesu budowania debugowania i można go wykonać za pomocą narzędzi JDK i Android SDK. Zadania testowe służą jako końcowa kontrola, zapewniająca, że aplikacja działa zgodnie z oczekiwaniami w rzeczywistych warunkach. Po zakończeniu przygotowywania aplikacji do wydania masz podpisany plik APK, który możesz rozpowszechniać bezpośrednio wśród użytkowników lub za pośrednictwem rynku aplikacji, takiego jak Google Play.

Android Studio

Ponieważ w powyższych przykładach użyto opcji Gradle, lokalizacja wygenerowanego pliku APK to: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Jeśli jesteś użytkownikiem IntelliJ przed przejściem do Studio i importujesz bezpośrednio swój projekt IntelliJ, nic się nie zmieniło. Lokalizacja danych wyjściowych będzie taka sama w:

out/production/...
 

Uwaga: jest to przestarzałe czasami około 1.0

Zaćmienie

Jeśli importujesz projekt Android Eclipse bezpośrednio, nie rób tego! Gdy tylko będziesz mieć zależności w swoim projekcie (słoiki lub projekty biblioteczne), to nie zadziała, a twój projekt nie będzie poprawnie skonfigurowany. Jeśli nie masz żadnych zależności, apk będzie w tej samej lokalizacji, co w Eclipse:

bin/...
 

Konfigurowanie AVD (urządzenie wirtualne z systemem Android)

TL; DR Zasadniczo pozwala nam symulować rzeczywiste urządzenia i testować nasze aplikacje bez prawdziwego urządzenia.

Zgodnie z dokumentacją dla programistów Androida ,

definicja urządzenia wirtualnego z systemem Android (AVD) pozwala zdefiniować cechy telefonu z Androidem, tabletu, urządzenia Android Wear lub urządzenia z systemem Android TV, które chcesz symulować w emulatorze Androida. Menedżer AVD pomaga w łatwym tworzeniu AVD i zarządzaniu nimi.

Aby skonfigurować AVD, wykonaj następujące kroki:

1. Kliknij ten przycisk, aby wyświetlić Menedżera AVD:

Ikona AVD Manager

2. Powinieneś zobaczyć takie okno dialogowe:

Okno dialogowe Menedżera AVD

3. Teraz kliknij przycisk + Create Virtual Device... Spowoduje to otwarcie okna dialogowego konfiguracji urządzenia wirtualnego:

Okno dialogowe konfiguracji urządzenia wirtualnego

4. Wybierz dowolne urządzenie, a następnie kliknij przycisk Next :

Wybierz Obraz systemu

5. Tutaj musisz wybrać wersję Androida dla swojego emulatora. Może być konieczne pobranie go najpierw, klikając Download . Po wybraniu wersji kliknij przycisk Next .

Zaawansowane ustawienia

6. Tutaj wpisz nazwę swojego emulatora, orientację początkową i określ, czy chcesz wyświetlić wokół niego ramkę. Po wybraniu wszystkich tych opcji kliknij przycisk Finish .

7. Teraz masz nowy AVD gotowy do uruchamiania na nim aplikacji.

AVD

Konfigurowanie Android Studio

Android Studio to IDE dla programistów Androida, które jest oficjalnie obsługiwane i zalecane przez Google. Android Studio jest dostarczany w pakiecie z Android SDK Manager , który jest narzędziem do pobierania komponentów Android SDK wymaganych do rozpoczęcia tworzenia aplikacji.

Instalowanie narzędzi Android Studio i Android SDK :

  1. Pobierz i zainstaluj Android Studio .
  2. Pobierz najnowsze narzędzia SDK i narzędzia platformy SDK, otwierając Android Studio, a następnie postępując zgodnie z instrukcjami dotyczącymi aktualizacji narzędzi SDK systemu Android . Powinieneś zainstalować najnowsze dostępne stabilne pakiety.

Jeśli musisz pracować nad starymi projektami, które zostały zbudowane przy użyciu starszych wersji zestawu SDK, być może konieczne będzie również pobranie tych wersji

Od wersji Android Studio 2.2, najnowsza wersja OpenJDK jest dołączona do instalacji i jest zalecanym pakietem JDK (Java Development Kit) dla wszystkich projektów Android Studio. Eliminuje to wymóg posiadania pakietu Oracle JDK. Aby użyć dołączonego zestawu SDK, wykonaj następujące czynności;

  1. Otwórz swój projekt w Android Studio i wybierz Plik> Struktura projektu na pasku menu.
  2. Na stronie Położenie SDK i w obszarze Lokalizacja JDK zaznacz pole wyboru Użyj osadzonego JDK .
  3. Kliknij OK .

Skonfiguruj Android Studio

Android Studio zapewnia dostęp do dwóch plików konfiguracyjnych poprzez menu Pomoc :

  • studio.vmoptions : dostosuj opcje wirtualnej maszyny Java (JVM) Studio, takie jak rozmiar sterty i rozmiar pamięci podręcznej. Pamiętaj, że na komputerach z systemem Linux ten plik może mieć nazwę studio64.vmoptions , w zależności od wersji Androida Studio.
  • idea.properties : Dostosuj właściwości Android Studio, takie jak ścieżka folderu wtyczek lub maksymalny obsługiwany rozmiar pliku.

Zmień / dodaj motyw

Możesz to zmienić według własnych preferencji. File->Settings->Editor->Colors & Fonts-> i wybierz motyw. Możesz także pobrać nowe motywy ze strony http://color-themes.com/ Po pobraniu pliku .jar.zip przejdź do File -> Import Settings... i wybierz pobrany plik.

Kompilowanie aplikacji

Utwórz nowy projekt lub otwórz istniejący projekt w Android Studio i naciśnij zielony przycisk Odtwórz wprowadź opis zdjęcia tutaj na górnym pasku narzędzi, aby go uruchomić. Jeśli jest szary, musisz poczekać sekundę, aby umożliwić Android Studio prawidłowe indeksowanie niektórych plików, których postęp można zobaczyć na dolnym pasku stanu.

Jeśli chcesz utworzyć projekt z powłoki, upewnij się, że masz plik local.properties , który jest automatycznie tworzony przez Android Studio. Jeśli chcesz utworzyć projekt bez Android Studio, potrzebujesz linii zaczynającej się od sdk.dir= a następnie ścieżki do instalacji SDK.

Otwórz powłokę i przejdź do katalogu projektu. Wpisz ./gradlew aR i naciśnij enter. aR to skrót do assembleRelease , który pobierze wszystkie zależności dla Ciebie i zbuduje aplikację. Ostateczny plik APK będzie w ProjectName/ModuleName/build/outputs/apk i będzie się nazywał ModuleName-release.apk .