Tworzenie pierwszej aplikacji na Androida

Tworzenie pierwszej aplikacji na Androida

dlaczego zależy nam na Androidzie? Dbamy o platformę Android, ponieważ jest to najbardziej rozpowszechniona platforma mobilna na świecie i jest dostępna dla konsumentów na całym świecie. W gospodarkach, w których posiadanie komputera osobistego jest luksusem, korzystanie z urządzeń mobilnych jest normą–a Android odgrywa ważną rolę w łączeniu ludzi ze sobą. Jak dowiesz się w tym samouczku, Android ma odrębne podejście do aplikacji. Architektura Androida pozwala na wysoce konfigurowalne środowisko oprogramowania dzięki powiązaniu żądanych akcji i kodowi, aby spełnić te żądania. Niezależnie od tego, czy chodzi o względy RYNKOWE, czy techniczne aspekty Androida, jest to platforma warta zbadania. Ponadto, jeśli poważnie rozważasz posiadanie mobilnego doświadczenia na swojej platformie, nie możesz zignorować Androida.

wymagania wstępne

ten poradnik wymaga kilku technologii, które współpracują ze sobą. Potrzebujesz ich wszystkich do tego samouczka.

• Android Studio – Android Studio jest podstawowym punktem wyjścia do konstruowania aplikacji na Androida
• urządzenie z Androidem lub Emulator – będziesz potrzebował fizycznego urządzenia z Androidem lub emulatora Androida. Tak czy inaczej, przeczytanie tego samouczka pomoże Ci zrozumieć podstawowe punkty połączenia aplikacji na Androida.

• kod źródłowy-fragmenty kodu źródłowego w tym samouczku obejmują:

  • AndroidManifest.snippet xml – ten plik jest deskryptorem wdrażania aplikacji dla aplikacji na Androida.
  • java-to implementuje aktywność Androida, główny punkt wejścia do przykładowej aplikacji tego samouczka.
  • dzialalnosc.xml-zawiera definicje elementów wizualnych lub zasobów do wykorzystania przez działania systemu Android.
  • AndroidManifest.XML complete-wyświetla pełną listę AndroidManfest.plik xml wraz z opisem każdego z ważnych elementów.

przedstawiamy architekturę Androida

zanim zanurzysz się w tajniki studia Android i stworzysz aplikacje na Androida, rzućmy okiem na architekturę Androida i niektóre kluczowe terminy, które będą pomocne w samouczku i poza nim, gdy zaczniesz budować aplikacje na Androida dla siebie.

terminologia Androida

zrozumienie poniższych terminów jest pomocne w tworzeniu aplikacji na Androida z Android Studio.

• Android to otwarte środowisko operacyjne przeznaczone dla urządzeń mobilnych. Coraz częściej Android znajduje się w aplikacjach poza „smartfonami”. Obejmują one technologię noszenia, urządzenia takie jak projektory, głośniki i telewizory, a nawet samochody.
• Emulator jest narzędziem programowym reprezentującym inny system. Często emulator to środowisko, które działa na komputerze osobistym (PC, Mac, Linux), które emuluje inne środowisko, takie jak urządzenie mobilne.
• Linux jest jądrem systemu operacyjnego open source, będącym sercem wielu platform obliczeniowych, w tym serwerów, komputerów stacjonarnych, urządzeń sieciowych i urządzeń mobilnych. Android działa na jądrze Linux.
• Android Run Time (ART) to środowisko operacyjne znajdujące się w stosie Androida, które wykonuje kod aplikacji w czasie wykonywania. Czas pracy systemu Android zastępuje „starszą” maszynę wirtualną Dalvik (VM) z wcześniejszych wersji systemu Android, która działała w sposób podobny do zgodnej maszyny wirtualnej Java.

intent

od momentu powstania Android stał się dominującą siłą w przestrzeni telefonów komórkowych. Jego model aplikacji jest wyjątkowy, ponieważ aplikacje nie są monolitycznymi aplikacjami z menu, które wymagają dużego kliknięcia i dotknięcia do działania. Oczywiście istnieją menu i przyciski, które należy wykorzystać, ale Android ma innowacyjny element projektowy w swojej architekturze znany jako intencja.

intencja jest konstrukcją, która pozwala aplikacji na wysłanie żądania, co jest nieco jak znak pomocy. Może wyglądać tak:

• „poszukiwany: Aplikacja, która pomoże mi wyszukać kontakt ”
• „Wanted: aplikacja, która pomoże mi wyświetlić ten obraz”
• ” Wanted: aplikacja do wykonywania tego wyszukiwania geograficznego.”

w podobny i uzupełniający sposób aplikacje mogą rejestrować się jako zdolne i zainteresowane zaspokajaniem różnych próśb lub zamiarów. Aby podążać za tajnym paradygmatem reklamy, mogą one wyglądać następująco:

• „dostępne: aplikacja gotowa i chętna do prezentacji danych kontaktowych w jasny, zwięzły sposób”
• ” dostępna: Aplikacja gotowa i chętna do przeprowadzenia wyszukiwania geograficznego.”

są to przykłady filtrów Intentfilter, które są omówione dalej.

Intentfilter

aplikacje ogłaszają swoją dostępność do wykonywania tego typu operacji za pomocą konstrukcji znanej jako IntentFilter. IntentFilter jest zarejestrowany w środowisku wykonawczym lub jest wyliczany w AndroidManifest.plik xml. Poniższy fragment pochodzi z aplikacji na Androida, która odpowiada na przychodzące wiadomości SMS (tekstowe) :

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

IntentFilter, następna sekcja wprowadza cztery główne typy aplikacji na Androida.

rodzaje Aplikacji na Androida

poświęćmy chwilę na zbadanie czterech głównych typów aplikacji na Androida:

• aktywność
• usługa
• Odbiornik
• ContentProvider

przyjrzymy się również widokom, aby wyświetlić elementy interfejsu użytkownika (UI).

Aplikacje aktywności

aktywność jest najbardziej widoczną i widoczną formą aplikacji na Androida. Działanie prezentuje interfejs użytkownika aplikacji wraz z pomocą klasy znanej jako widok. Klasa view jest zaimplementowana jako różne elementy interfejsu użytkownika, takie jak Pola tekstowe, etykiety, przyciski i inne interfejsy użytkownika typowe dla platform komputerowych, mobilnych lub otherwise.An aplikacja może zawierać jedną lub więcej czynności. Aktywność jest zazwyczaj definiowana na podstawie relacji jeden do jednego z ekranami znajdującymi się w aplikacji.

aplikacja przechodzi z jednej aktywności do drugiej przez wywołanie metody znanej jako startsubactivity() lub startSubActivity(). Pierwsza metoda jest używana, gdy aplikacja chce po prostu „przełączyć się” na nową aktywność. Ten ostatni jest używany, gdy pożądany jest paradygmat wywołania synchronicznego/odpowiedzi. W obu przypadkach intencja jest przekazywana jako argument do wywołanej metody.

obowiązkiem systemu operacyjnego jest określenie najlepiej wykwalifikowanej aktywności w celu spełnienia określonych intencji.

Aplikacje serwisowe i odbiorcze

podobnie jak inne wielozadaniowe środowiska obliczeniowe, istnieją aplikacje działające „w tle”, które wykonują różne zadania. Android wywołuje tego typu usługi aplikacji. Usługa jest aplikacją na Androida, która nie ma interfejsu użytkownika.

odbiornik jest komponentem aplikacji, który odbiera żądania przetwarzania intencji. Podobnie jak usługa, odbiornik nie ma, w normalnej praktyce, elementu interfejsu użytkownika. Odbiorniki są zazwyczaj rejestrowane w AndroidManifest.plik xml.

poniższy fragment (taki sam jak ten pokazany dla IntentFilter) jest przykładem zdefiniowanej aplikacji odbiorczej. Zauważ, że atrybut name odbiornika jest klasą Java odpowiedzialną za implementację odbiornika.

<receiver android:name=".MySMSMailBox" android:exported="true"> <intent-filter> <action android:name="android.provider.Telephony.SMS_RECEIVED" /> </intent-filter> </receiver>

ContentProvider to mechanizm Android do abstrakcji magazynu danych. Przyjrzyjmy się konkretnemu typowi danych znalezionych na urządzeniu mobilnym: książce adresowej lub bazie kontaktów. Książka adresowa zawiera wszystkie kontakty i numery telefonów, których dana osoba może potrzebować podczas korzystania z telefonu komórkowego.

ContentProvider jest mechanizmem abstrakcyjnego dostępu do określonego magazynu danych. Pod wieloma względami ContentProvider działa w roli serwera bazy danych. Operacje odczytu i zapisu zawartości do określonego magazynu danych powinny być przekazywane przez odpowiedni ContentProvider, zamiast uzyskiwać bezpośredni dostęp do pliku lub bazy danych. Mogą istnieć zarówno „klienci”, jak i „implementacje” ContentProvider.

widoki Androida

widoki Androida są mechanizmem interfejsu użytkownika do umieszczania rzeczy na ekranie urządzenia z Androidem. Aktywność Androida wykorzystuje widoki do wyświetlania elementów interfejsu użytkownika. Niektóre z bardziej popularnych projektów layoutów obejmują:

• LinearVertical-każdy kolejny element podąża za swoim poprzednikiem przepływając pod nim w jednej kolumnie.
• LinearHorizontal-każdy kolejny element podąża za swoim poprzednikiem, płynąc w prawo w jednym rzędzie.
• Table-seria wierszy i kolumn, podobna do tabeli HTML. Każda komórka może pomieścić jeden element widoku.
• Constraint – każdy element jest „ograniczony” do jakiegoś aspektu wyświetlacza, takiego jak Góra lub bok ekranu lub inny element. Ten układ pomaga w budowie” responsywnych ” aplikacji i jest spadkobiercą starszego układu względnego wprowadzonego we wcześniejszych wersjach Platformy Android.

po wybraniu określonego układu (lub kombinacji układów), do definiowania interfejsu użytkownika używane są pojedyncze widoki.

Elementy widoku składają się ze znanych elementów interfejsu użytkownika, w tym:

• przycisk
• ImageView
• EditText do zbierania danych wejściowych z różnymi filtrami, takimi jak Data lub numeryczny
• TextView (podobny do etykiety, wyświetla statyczny tekst)
• CheckBox
• przycisk radiowy
• Spinner (podobny do rozwijanej listy)
• Autouzupełnianie (EditText z funkcją Auto Text-Complete)

widoki są definiowane w pliku XML. Na przykład, pokazuje to prosty widok liniowy, z zdefiniowanymi przyciskami i podglądami tekstu:

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent" ><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1!" /><TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Activity 1, second text view!" /><Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Switch To Activity 2" /></LinearLayout>

https://developer.android.com/, i przewiń w dół, aby pobrać Android Studio. Android Studio jest dostępny dla Systemów Windows, Mac i Linux.

Android Studio jest oparty na platformie IntelliJ IDE. Jeśli jesteś programistą interesującym się wykorzystywaniem skrótów klawiaturowych, możesz rozważyć dowiedzenie się więcej o IntelliJ ze strony jetbrains.

pierwsze kroki z Android SDK

teraz, gdy mamy zainstalowane Android Studio, nadszedł czas, aby uzyskać Software Developer Kit (SDK) dla Androida.

ale zanim przejdziemy dalej, musimy przeprowadzić dyskusję na temat wersji Androida.

wersje Androida

od momentu powstania Android został wydany pod nieco równoległą ścieżką numerycznych wersji, poziomów API, a także „słodkich” nazw, w tym Jelly Bean, KitKat, Oreo i innych ulubionych słodyczy.

łatwo jest być przytłoczonym przez dostępne opcje. Na razie potrzebujesz tylko trochę zrozumienia tego „krajobrazu wersji”, aby rozpocząć pracę jako programista Androida.

istnieje wiele wersji lub wersji Androida w środowisku naturalnym. Jeśli zamierzasz napisać aplikację do wydania komercyjnego,musisz wiedzieć, które urządzenia kierujesz. Wikipedia ma ładne podsumowanie wersji Androida, nazwy, daty premiery, a także grafikę przedstawiającą przybliżoną liczbę każdego urządzenia na rynku.

nowsze urządzenia uruchamiają najnowszy kod, a starsze urządzenia mogą być nieco ograniczone w możliwości aktualizacji do nowszej wersji Androida. Czasami nowsze wersje obsługują funkcje, których starsze telefony nie są w stanie obsługiwać (pomyśl o drugiej kamerze, komunikacji w pobliżu pola itp.). Innym nietrywialnym powodem, dla którego starsze telefony mogą nie być w stanie uruchomić najnowszej wersji Androida, jest to, że zarówno producent, jak i operator telekomunikacyjny (Verizon, AT&T itd.) muszą obsługiwać oprogramowanie działające w ich ekosystemie. Obsługa nowego systemu operacyjnego wymaga zasobów ze strony producenta urządzenia i nośnika. Siły rynkowe sugerują, że ci uczestnicy rynku są bardziej zainteresowani przyszłą sprzedażą niż wspieraniem wcześniejszej sprzedaży i odpowiednio inwestują swój kapitał ludzki.

jako programista, jakie to ma znaczenie, że istnieją nowe wersje systemu operacyjnego? Dzieli się to na dwie szerokie kategorie, jeśli chodzi o aplikacje programistyczne:

• nowa wersja systemu operacyjnego często wprowadza nowe funkcje, z których możemy skorzystać i / lub nasza baza użytkowników oczekuje wsparcia naszych aplikacji.
• starsze (lub starsze) funkcje środowiska mogą faktycznie utrudniać nowsze funkcje i/lub reprezentować gorsze podejście do dostarczania określonego zestawu funkcji. Czasami kod musi zostać faktycznie usunięty z definicji API. Istnieje specjalny termin na to „usunięcie” wcześniej działającego kodu – nazywamy to”wycofaniem kodu”. Gdy API zostało oznaczone do usunięcia, mówimy, że jest to przestarzałe API. Jest to zasadniczo komunikat do dewelopera, który brzmi mniej więcej tak: „Ostrzeżenie” ten kod zostanie usunięty w przyszłości, proszę zaplanować odpowiednio.”

Platforma Android była dość liberalna (to znaczy korzystna dla programisty) ze swoim podejściem do przestarzałego kodu, zezwalając aplikacjom na kontynuowanie korzystania ze starszych interfejsów API przez dłuższy czas po oznaczeniu jako przestarzałe. (Takie podejście kontrastuje z podejściem Apple z przestarzałym kodem w systemie iOS, gdzie starszy kod może po prostu przestać działać na następnym wydaniu systemu operacyjnego. Z iOS nawet język programowania wydaje się zmieniać, gdy nie patrzymy!)

chociaż Android może być nieco bardziej wyrozumiały ze swoim długim cierpieniem przestarzałego kodu, musimy mieć oko na tag documentation, który mówi, że dany API jest przestarzały. Jeśli jakiś kod, którego używamy, jest oznaczony jako przestarzały, będziemy musieli ostatecznie zmienić nasze podejście w przyszłej wersji naszej aplikacji, ponieważ każde API, które jest oznaczone jako przestarzały, może zostać usunięte w przyszłej wersji. Markery deprecjacji w SDK to nasza Mapa Drogowa do przyszłych możliwości poprawy i potencjalnych bólów głowy. Czasami „nowy” sposób robienia rzeczy jest prosty i prosty, ale nie w każdym przypadku!

bycie odnoszącym sukcesy programistą aplikacji mobilnych wymaga ciągłych inwestycji w ciągu całego życia aplikacji, w której czas zwykle mija jak Psie lata … bardzo szybko!

z tym podstawowym wstępem do wersji Androida, nadszedł czas, aby uzyskać Android SDK.

uzyskanie i instalacja zestawu SDK dla Androida

Uruchom Android Studio. W menu Narzędzia wybierz Menedżer SDK. Ta opcja menu ładuje okno dialogowe preferencji Android Studio i wstępnie wybiera menu podrzędne Android SDK. To menu jest naszym głównym środkiem interakcji z różnymi zestawami SDK dostępnymi dla wielu wersji Androida.

przy każdym wydaniu systemu operacyjnego przyrosty poziomu API. Zauważ, że zmiana wzrasta wolniej niż poziom API. Możesz myśleć o wersji jako o” generacji „platformy lub jako o” głównym ” numerze wersji. Podczas przeglądania dokumentacji systemu Android Należy pamiętać o tym, na jakim poziomie API wprowadzono daną funkcję. Każdy API jest dostępny na wskazanym i wyższym poziomie API, chyba że API zostało przestarzałe, a następnie usunięte. Na przykład API ContactsContract zostało wprowadzone na poziomie 5, który jest w tym momencie dość „stary”.

wybierz jeden lub dwa poziomy SDK do pracy na razie. Menedżer SDK następnie pobierze powiązane pliki i udostępni je do użytku w Android Studio.

również w menu Narzędzia znajduje się opcja dla Menedżera AVD. AVD oznacza Android Virtual Device. To jest emulator. Emulator jest pomocny, ponieważ pozwala nam testować aplikacje na różnych typach urządzeń, rozmiarach i wersjach. Zrzuty ekranu w tym samouczku są pobierane z emulatora. Więcej na ten temat później.

budowanie pierwszej aplikacji na Androida

ten samouczek przeprowadzi Cię przez stworzenie podstawowej aplikacji na Androida o nazwie SaySomething, używając Android Studio i demonstrując ją na emulatorze Androida.

Pobierz kod

Krok 1: Utwórz nowy projekt

1. Wybierz plik > Nowy Projekt.

2. wypełnij okno dialogowe Utwórz projekt Androida i kliknij Dalej.

   

   wymagania dla nowego projektu obejmują:

   • Nazwa aplikacji
   • domena firmy (zostanie to odwrócone do com.domena), aby aplikacje były podzielone na partycje, nawet jeśli mają tę samą nazwę aplikacji.
   • lokalizacja projektu – gdzie przechowywać pliki
   • Nazwa pakietu jest sugerowana z nazwy aplikacji i domeny firmy
   • domyślnie aplikacje na Androida są napisane w języku Java. Jeśli chcesz obsługiwać alternatywne języki, takie jak C++ (dla kodu natywnego) lub Kotlin, zaznacz odpowiednie pola wyboru.

3. w oknie dialogowym Docelowe urządzenia z systemem Android określ poziom interfejsu API i platformy docelowe. Jak wspomniano wcześniej, Android jest czymś więcej niż tylko telefonami, choć dla naszych celów po prostu wybierzemy współczynnik kształtu telefonu i tabletu dla tego samouczka. Następnie kliknij przycisk Dalej.

   

4. w oknie dialogowym Dodaj aktywność do telefonu komórkowego wybierz typ pustej aktywności. Następnie kliknij przycisk Dalej.

   

   spowoduje to utworzenie domyślnej aplikacji gotowej do zbudowania i uruchomienia bezpośrednio z Android Studio.

5. w oknie dialogowym Konfiguruj aktywność nadaj nazwy plikom aplikacji.

   

Krok 2: przejrzyj kod

poniższy rysunek pokazuje elementy naszego nowego projektu:

istnieją dwa foldery: appi Skrypty Gradle.

• folder aplikacja zawiera cały kod naszej aplikacji.
• folder manifestuje w folderze aplikacja zawiera AndroidManifest.xml, który jest deskryptorem wdrożenia dla tej aplikacji. Ten plik informuje urządzenie z Androidem o tym, jak współdziałać z aplikacją, jaką aktywność pokazać po uruchomieniu aplikacji, która planuje usługi aplikacji, które ikony do wyświetlenia i wiele więcej.
• folder java zawiera kod źródłowy aplikacji. W tym przypadku plik, który implementuje naszą aktywność oraz kilka plików klas do wykonywania testów automatycznych (które zignorujemy w tym samouczku).
• folder res zawiera zasoby aplikacji, w tym ikony, Pliki Układów, ciągi znaków, menu i tak dalej.
• folder Gradle Scripts zawiera wszystkie elementy skryptowalne do budowy aplikacji. System budowania Gradle jest tematem samym w sobie. Na razie zrozum, że te skrypty rządzą procesem budowania aplikacji – i co ważne dla bardziej dojrzałych projektów i zespołów, każdy z tych kroków można uruchomić z wiersza poleceń. Jest to ważne, ponieważ takie podejście wspiera automatyzację i należy do kategorii ciągłej integracji.

teraz przyjrzyjmy się bliżej kodowi źródłowemu.

Podstawowa aktywność dla aplikacji

nasza przykładowa aplikacja składa się z pojedynczej aktywności o nazwie główna aktywność.

package com.navitend.saysomething;import android.content.Intent;import android.net.Uri;import android.os.Bundle;import android.support.v7.app.AppCompatActivity;import android.view.View;import android.util.Log;import android.widget.Button;import android.widget.TextView;import android.widget.EditText;public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.i("IBM","Hello there logcat!"); setContentView(R.layout.activity_main); final Button btnHitMe = (Button) findViewById(R.id.hitme); final Button btnMapMe = (Button) findViewById(R.id.mapme); final TextView tvLabel = (TextView) findViewById(R.id.thelabel); final EditText etLatitude = (EditText) findViewById(R.id.etLatitude); final EditText etLongitude = (EditText) findViewById(R.id.etLongitude); btnHitMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { tvLabel.setText("Ouch!"); } } ); btnMapMe.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { String coords = etLatitude.getText()+","+etLongitude.getText(); Log.i("IBM",coords); Uri mapsIntentUri = Uri.parse("geo:" + coords); Intent mapIntent = new Intent(Intent.ACTION_VIEW, mapsIntentUri); startActivity(mapIntent); } } ); }}

MainActivity jest normalną klasą Javy, z pakietem i importem, zgodnie z oczekiwaniami.

zasoby dla aplikacji

zasoby w systemie Android są zorganizowane w podkatalog projektu o nazwie res, jak opisano wcześniej. Zasoby można podzielić na kilka kategorii. Trzy z tych kategorii to:

• Drawables – ten folder zawiera pliki graficzne, takie jak ikony i mapy bitowe
• Układy – ten folder zawiera pliki XML, które reprezentują układy i widoki aplikacji. Zostaną one szczegółowo przeanalizowane poniżej.
• wartości – ten folder zawiera plik o nazwie strings.xml. Jest to podstawowy sposób lokalizacji ciągów znaków dla aplikacji. Kolory plików.xml jest przydatny do definiowania kodów kolorów używanych przez aplikację. Ten plik jest analogiczny do arkusza stylów css dla osób zaznajomionych z technikami programowania internetowego.

podstawowe zasoby interfejsu użytkownika w main_activity.plik xml

przykładowa aplikacja zawiera jedno działanie i jeden widok. Aplikacja zawiera plik o nazwie main_activity.xml, który reprezentuje wizualne aspekty głównego interfejsu użytkownika działania. Zauważ, że nie ma odniesienia w main_activity.xml gdzie używany jest układ. Oznacza to, że może być stosowany w więcej niż jednym działaniu, jeśli jest to pożądane. Zobacz poniższą listę kodów

<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" android:gravity="center_vertical"> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal" android:gravity="center" tools:layout_editor_absoluteX="8dp" tools:layout_editor_absoluteY="301dp"> <Button android:id="@+id/hitme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hit Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="383dp" /> <Button android:id="@+id/mapme" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Map Me!" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" tools:layout_editor_absoluteY="460dp" /> </LinearLayout> <TextView android:id="@+id/thelabel" android:layout_width="match_parent" android:layout_height="wrap_content" android:gravity="center" android:text="Hello World, Say Something!!!!!" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintLeft_toLeftOf="parent" app:layout_constraintRight_toRightOf="parent" app:layout_constraintTop_toTopOf="parent" /> <EditText android:id="@+id/etLatitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Latitude" android:inputType="numberDecimal" android:text="40.9241164" /> <EditText android:id="@+id/etLongitude" android:layout_width="match_parent" android:layout_height="wrap_content" android:ems="10" android:hint="Longitude" android:inputType="numberDecimal" android:text="-74.7213913" /></LinearLayout>

LinearLayoutistnieje drugi LinearLayout zorganizowany jako układ poziomy. Ten wewnętrzny układ zawiera parę widżetów przycisków. Poniżej poziomej linii LinearLayout znajduje się pojedynczy element TextView, który można porównać do etykiety w innych środowiskach programistycznych. TextView reprezentuje tekst statyczny, który nie jest edytowalny. Poniżej TextView znajdują się dwa widżety EditText , skonfigurowane do pobierania wejść numerycznych. Te elementy wejściowe są wykorzystywane do przechwytywania wartości szerokości i długości geograficznej, które następnie zostaną przekazane do aplikacji mapującej, jak pokazano poniżej.

zauważ, że każdy element widoku ma atrybuty w przestrzeni nazw Androida. Niektóre atrybuty są wspólne dla wszystkich widoków-na przykład atrybuty android:layout_width i android:layout_height . Wartości dostępne dla tych atrybutów to:

• Match Parent-rozszerza element widoku o maksymalną dostępną przestrzeń. Można to również traktować jako ” rozciągnięcie.”
• Zawijanie zawartości-ta opcja powoduje, że element rozszerza się na tyle, aby zawierał widoki potomne lub atrybuty, takie jak tekst lub obraz.

deskryptor wdrożenia dla aplikacji Android (AndroidManifest.xml)

AndroidManifest.plik xml reprezentuje deskryptor wdrożenia dla aplikacji na Androida. Plik zawiera listę działań, usług, dostawców treści lub odbiorców zawartych w aplikacji wraz z odpowiednimi filtrami Intentfilter obsługiwanymi przez aplikację. Oto kompletny AndroidManifest.plik xml dla przykładowej aplikacji:

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.navitend.saysomething"> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name=".MainActivity" android:label="@string/app_name" android:theme="@style/AppTheme.NoActionBar"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application></manifest>

<manifest> zasadniczo importuje klasy z tego pakietu. Wszystkie Nie w pełni kwalifikowane klasy w tym Pliku znajdują się w pakiecie określonym w atrybucie pakiet.

Krok 3: Zbuduj aplikację

aby zbudować aplikację, wybierz ikonę klucza (dla mnie wygląda bardziej jak młotek) w menu Android Studio.

proces kompilacji, wprowadzony wcześniej, jest wieloetapowym procesem, który można dostosować do dowolnej aplikacji. W tym samouczku nie modyfikujemy procesu budowania. Wynik procesu budowania powinien wyglądać mniej więcej tak:

aby zademonstrować proces kompilacji, wprowadziliśmy błąd w kodzie źródłowym; dodaliśmy dodatkowe miejsce w nazwie metody findViewById, pokazane na poniższym rysunku:

tworzy to błąd składni lub parsowania, który jest wykrywany przez proces kompilacji i wyświetlany w szczegółach okna wyników kompilacji w Android Studio. Po naprawieniu błędu w kodzie źródłowym, aplikacja buduje się poprawnie, a błędy są usuwane z listy problemów.

Krok 4: Uruchom aplikację

teraz, gdy aplikacja została skompilowana pomyślnie, nadszedł czas, aby uruchomić przykładową aplikację.

wcześniej w tym samouczku został wprowadzony menedżer AVD jako środek do konfigurowania emulatora do testowania aplikacji bez potrzeby używania prawdziwego urządzenia. Uruchomienie aplikacji za pomocą emulatora jest szczególnie przydatne, ponieważ pozwala na testowanie bez konieczności zakupu wielu kosztownych urządzeń.

aby skonfigurować emulator lub bardziej poprawnie urządzenie wirtualne z systemem Android (AVD), wybierz Narzędzia > Menedżer AVD. Lub po prostu kliknij ikonę Odtwórz (Uruchom).

uruchamia się okno, które pozwala wybrać prawdziwe urządzenie podłączone kablem USB lub dostępną instancję AVD, jak pokazano na poniższym rysunku:

jeśli są podłączone urządzenia, każde z nich pojawia się w rozwijanej liście poniżej podłączone urządzenia. Możesz też wybrać jedno z dostępnych urządzeń wirtualnych. Na poprzednim rysunku, istnieje jeden avd zdefiniowane o nazwie Nexus One API P. Aby utworzyć nowy plik AVD, wybierz przycisk Utwórz nowe urządzenie wirtualne.

na koniec kliknij OK, aby uruchomić aplikację na wybranym miejscu docelowym wdrożenia. Avd lub emulator uruchamia się z uruchomioną na nim naszą przykładową aplikacją.

Krok 5: przetestuj aplikację w emulatorze

teraz, gdy aplikacja jest uruchomiona na emulatorze, rzućmy okiem na to, co dzieje się za kulisami. W Android Studio wybierz Widok > okna narzędzi. Podkreślimy tylko kilka z tych opcji narzędzi, chociaż każda z nich jest tematem samym w sobie.

Narzędzia Android Studio

najpierw spójrz na Profiler Androida, który przedstawia działający Wykres CPU, pamięci i ruchu sieciowego. Android Profiler pozwala nam przełączać się między różnymi urządzeniami / instancjami emulatora i odpowiednimi działającymi procesami. Poniższy rysunek wyświetla metryki dla naszej przykładowej aplikacji uruchomionej na instancji emulatora.

Logowanie to przydatne narzędzie dla każdego programisty na dowolnej platformie. Dla programistów Androida NAZWA NARZĘDZIA to LogCat.

LogCat jest uruchomionym plikiem dziennika aktywności w maszynie wirtualnej. Aplikacje mogą tworzyć własne wpisy do tej listy za pomocą prostej linii kodu w następujący sposób: Log.i (tag,message);1, gdzie tag i message są ciągami Java. Klasa Log jest częścią klasy android.util.Pakiet Log.

Innym przydatnym narzędziem jest Eksplorator plików, który umożliwia dostęp do systemu plików emulatora. Poniższy rysunek pokazuje, gdzie przykładowa aplikacja samouczka jest wdrożona na emulatorze.

aplikacje użytkownika są wdrażane w /data/app, podczas gdy aplikacje wbudowane w system Android znajdują się w katalogu /system/app.

debugowanie na pełną skalę aplikacji na Androida wykracza poza zakres tego samouczka, choć zapewniamy, że Android Studio obsługuje wszystkie nowoczesne narzędzia do debugowania aplikacji, na które możemy mieć nadzieję, dzięki takim czynnościom, jak wchodzenie i przechodzenie przez wywołania funkcji.

testowanie przykładowej aplikacji

stuknij w Hit Me! przycisk, a zawartość etykiety zmienia się na ” Ouch!”

Dotknij Mapy Me! przycisk, a aplikacja mapująca jest uruchamiana z określoną szerokością i długością geograficzną zawartą w widżetach EditText.

okablowanie przycisków znajduje się w głównym Menu.kod xml. W szczególności zwróć uwagę, jak wartości szerokości i długości geograficznej są wyodrębniane i pakowane w intencję, która jest następnie używana do uruchomienia aplikacji mapującej.

ten poradnik wprowadził platformę Android, Android Studio i kluczowe elementy rozwoju Androida. Teraz powinieneś być gotowy do tworzenia własnych aplikacji na Androida.

czy jesteś gotowy na coś więcej? Wypróbuj ten samouczek, w którym używasz interfejsów API Bluetooth Low Energy (BLE) do budowania urządzeń podłączonych do Internetu Rzeczy.