Before diving into the vast field of Android Development, there is a need to understand the tool required for it. The name of the tool is Android Studio, used for developing Android Applications. Android Studio is developed by Google and Jetbrains. It’s the most widely used software for developing Android Applications. So in this article, there is a deep discussion about Android Studio. Like how to install it, tips and tricks that increase productivity while developing an Android application. So stay tuned till the end.
So in this article, we have covered the following things:
- What is Android Studio?
- How to Install Android Studio?
- File Structure of a Project in Android Studio
- Writing first Android Studio Application
- Understanding the Designing Part
- Understanding the Coding Part
- Run Android App
- Essential Android Studio Keyboard Shortcuts
- Some Android Studio Tips and Tricks
- Complete Android Studio Tutorial
1. What is Android Studio?
Before starting and learning any programming language, the one thing required to learn to program is IDE (Integrated Development Environment). It provides a convenient way to write code. If there are any errors or bugs after compiling, they can be debugged. So, Android Studio is an official IDE for developing Android applications. It provides features that enrich productivity while writing code. It provides features like:
- A flexible Gradle build system, easy to manage all the dependencies in a single place.
- It allows you to run and test applications if one doesn’t have an Android smartphone. Because of its feature-rich emulator, it can run one or more emulators at a time to test client-server applications. And it also allows you to run and test physical Android Smartphones.
- It provides a unified environment so that applications can be developed for all types of Android devices.
- Intelligent code completion feature.
- Predefined code templates.
- Git integration makes developers maintain repositories, and also helps to build common app features and import sample code.
- C++ and Native Development Kit(NDK) support.
2. How to Install Android Studio?
To install Android Studio, visit the Android Studio Download page. Make sure to install the latest stable version of the Android Studio. Before installing the Android Studio, check the system requirements on the same page, so that the system meets its minimum requirement to run Android Studio smoothly. Visit Android Install and Set up Android Studio in Windows. To find out how to install the Android Studio on Windows OS-based systems. Or one may visit the official page Install Android Studio to find out how to install Android Studio on Windows, Mac, and Linux.
3. File Structure of a Project in Android Studio
Android studio project folder structure: There are two view types of the project file structure in Android Studio. One is Android View(Summarised), another is Project View(Detailed View). Most beginners use the Android View(Summarised). Have a look at the following image to see the differences between these views. One can read the detailed info about the Android project folder structure here: Android Project folder Structure
Android Studio Application File structure:
This folder is responsible for holding the Application’s Manifest file, looking at the main application’s Business logic (Java/Kotlin), drawable files (images, vector graphics), Application’s UI layout files, mipmap (app’s icon files), colors(application’s branding color), strings(all the texts, used for localizing the application), styles(predefined or user-defined styles of application), app-level gradle file(managing the dependencies). To find out more about the app file structure read: Android Application File Structure
Application Manifest File: The manifest file is an important part of our app because it defines the structure and metadata of our application, its components, and its requirements. This file includes nodes for each of the Activities, Services, Content Providers, and Broadcast Receiver that make the application and, using Intent Filters and Permissions, determine how they co-ordinate with each other and other applications. To get more insights about the Android Manifest read: The Application Manifest File. The typical very basic manifest file looks like this:
res/values folder: The values folder used to store the values for the resources that are used in many Android projects includes features of color, styles, dimensions, padding values, margin values, etc. There are 4 main files under the res/values folder. Those are: colors.xml, dimens.xml, strings.xml, styles.xml. Read on the res/values folder to find out the details of the res/values folder. Have a look at the following image where it’s found:
build.gradle file: Gradle is a build system (open source) that is used to automate building, testing, deployment, etc. Every Android project needs a Gradle for generating an apk from the .java and .xml files in the project. It is located in the root project directory and its main function is to define the build configurations that will be applied to all the modules in the project. Read: build.gradle and get to know more about the various build.gradle. Have a look at the following image to get the location of build.gradle files.
Assets Folder: Assets provide a way to add arbitrary files like text, XML, HTML, fonts, music, and video in the application. If one tries to add these files as “resources“, Android will treat them into its resource system and you will be unable to get the raw data. Read Assets Folder in Android Studio for a detailed view of the assets folder. Have a look at the following image to get the location of the assets folder in Android Studio.
Resource Raw Folder: The raw folder in Android is used to keep mp3, mp4, sfb files, etc. The raw folder is created inside the res folder: main/res/raw. So we will simply create it inside the res folder. Read: Resource Raw Folder in Android Studio to know details about the raw folder. Have a look at the following image to get the location of the folder where it needs to be created:
Logcat window: Logcat Window is the place where various messages can be printed when an application runs. Suppose, you are running your application and the program crashes, unfortunately. Then, Logcat Window is going to help you to debug the output by collecting and viewing all the messages that your emulator throws. Read: Logcat window in Android Studio to know more about the Logcat in Android Studio. Have a look at the following image to locate the Logcat window:
debug.keystore file: is one of the most important files which is present in almost every application when we download that app from the Google Play Store. This file is basically considered as the certificate of any application which is being verified by Google each and every time. Each app that you are using on your phone needs to be signed. Read: Where is debug.keystore in Android Studio? to know where it is located and to generate the certificate for the Android app.
4. Writing first Android Studio Application
As in features of Android Studio, it’s mentioned that Android Studio provides various numbers of templates by default. It allows you to select them before creating a project. To create a new project click on “Create New Project“.
After clicking, another new window pops up to select several predefined templates. Pick what suits the current project needs. If there is no desired template, choose “Empty Activity” and click on the “Next” button.
To find out more on this, refer to Android Studio Main Window
After clicking on the Next button, another window pops up asking to enter the name of the project, package name, location to save the project, programming language to select(as two programming languages are supporting Kotlin & Java), and the minimum SDK API level (The minimum API level that is supported by the app). After entering the information, click on the “Finish” button.
Congratulations, the first Android Studio project is ready. Initially, it shows the tip of the day, which gives tips to improve work efficiency. Before going to explore the Android Studio, get familiar with the initial screen which is shown below.
For a better understanding of the Android Studio environment, it has been divided into 4 parts:
1. Menu Part: In this section, it provides options to create a new project, open an existing android studio project, a button to run the application, dropdown for selecting the desired device to run and test an application on.
2. Coding Area: This section provides for writing code for files like .xml, .java, .kt. It allows you to open multiple files at a time in different tabs, but it allows you to edit one file at a time.
3. Project Structure: This area allows us to explore every file of the project. There are various views of the structure. Android is a summarised view of the project structure hierarchy and Project is a detailed view of the project hierarchy. Have a look at the following image.
4. Current Execution Part: One of the most important parts of the Android Studio environment. It provides a detailed view of the current execution of the process or activity. It shows what errors, build outputs, logcat results, etc.
5. Understanding the Designing Part
All the UI layouts of the application can be found under the res/layout directory. These are of the .xml extension, responsible for building the UIs for application. Android Studio provides two types of ways of designing UI for applications. One is Text, where one needs to design the UI by hardcoding and one is the Design section that provides a convenient drag and drop mechanism for building UI. Have a look at the following image which shows how the code is being written, it goes on to show the result in the right pane.
The following image shows the drag and drop environment for widgets to pick and add in the UI of the application. One can switch to the Design layout by clicking on the bottom left button, shown as the following.
6. Understanding the Coding Part
As we have understood the design part similarly, another main part is the coding part. In the image below you can see a file named MainActivity.kt. Yes, this is the file where you write the backend part. The logic part. For example, you want to add two numbers. So, after entering two numbers in the EditText, when the user clicks on the Button, it will give the output as the sum of two numbers. So to calculate the sum, you have to write the logic in its part.
Note: If you select Language as Java during project creation, then the file name will be MainActivity.java.
7. Run Android App
To run an application there are two ways to do it. One is using an emulator, another is using a physical device by connecting it through a USB cable. Refer to How to install Android Virtual Device(AVD) how to set up an android virtual device or refer to How to Run the Android App on a Real Device? setting up a real physical android device and running applications on it. Have a look at the following image of what the Android Virtual Device looks like on the first run of the application.
8. Essential Android Studio Keyboard Shortcuts
Keyboard shortcuts make work a lot easier and increase productivity. One may refer to 10 Important Android Studio Shortcuts You Need the Most getting to know the essential keyboard shortcuts for Android Studio.
9. Android Studio Tips and Tricks
There are some tips and tricks that can be used to master Android development using Android Studio. These tips and tricks are:
- Setting up the theme of Android Studio
- Changing color of Logcat
- Fast Searching
- Split Screen
- Distraction-free mode
- Code completion
- Multi cursor feature and many more
You may refer to the following articles to find out more about Android Studio Tips and Tricks
- Top 20 Tips and Tricks of Android Studio
- 10 Android Studio Tips and Tricks For Android Developers
10. For the complete Android Studio Tutorial, you may refer to this article: Android Studio Tutorial
Android’s enterprise features provide organizations with a secure, flexible, and
unified Android mobility platform—combining devices, applications,
and management. Android apps are compatible with Android’s enterprise features
by default. However, there are additional features you can use to make
your app work best on managed Android devices:
-
Work profile compatibility—Modify your Android
app so it functions best on a managed device. -
Managed configurations—Modify
your app to allow IT admins the option to specify custom
settings for your apps. -
Dedicated devices—Optimize your
app so that it can be deployed on an Android device as a kiosk. -
Single Sign-On (SSO)—Simplify the sign-on process
for users signing in to different apps on their managed Android device.
Prerequisites
- You’ve created an Android app.
- You’re ready to modify your app so that it works best for organizations.
- Minimum version: Android 5.0 Lollipop recommended version:
Android 6.0 Marshmallow and later.
Note: Android’s enterprise features are built into most
Android 5.0 devices; however, Android 6.0 and later offers
additional features, especially with regard to dedicated devices.
Work profiles
You can manage a user’s business data and applications through a
work profile. A work profile is a managed corporate profile
associated with the primary user account on an Android device. A
work profile securely isolates work apps and data from personal apps
and data. This work profile is in a separate container from the
personal profile, which your user controls. These separate profiles
allow organizations to manage the business data they care about, but
leave everything else on a user’s device under the user’s control.
For a deep dive into best practices, see the
Work profiles
guide. For an overview of those best practices, see below.
Key features of a work profile
- Separate and secure profile
- Managed Google Play for application distribution
- Separate badged work applications
- Profile-only management capabilities controlled by an admin
Work profile benefits on Android 5.0+
- Full device encryption
- One Android application package (APK) for both profiles when
there’s a personal profile and a work profile present on the device - Device policy controller (DPC) is limited to the work profile
- Device administration via the
DevicePolicyManager class
Considerations for work profiles
- The Android system prevents intents
from crossing profiles and IT admins can
enable or disable system apps. - A file path (Uniform Resource Identifier [URI]) that’s valid on
one profile may not be valid on the other.
Prevent intents from failing between profiles
It’s difficult to know which intents can cross between profiles, and
which ones are blocked. The only way to know for sure is by testing.
Before your app starts an activity, you should verify that the
request is resolved by calling
Intent.resolveActivity().
- If it returns
null, the request doesn’t resolve. - If it returns something, it shows that the intent resolves,
and it’s safe to send the intent.
Note: For detailed testing instructions, see
Prevent Failed Intents.
Some developers use URIs to mark file paths in Android. However,
because there are separate file systems when a work profile is present, we
recommend:
|
Use: Content URIs |
|
|
Don’t use: File URI |
|
Next steps: Once your app supports managed
profiles, test it in a work profile. See Test your app.
Implement managed configurations
Managed configurations are a set of instructions that IT admins
can use to manage their users’ mobile devices in a specific way.
These instructions are universal and work across any EMM, allowing
admins to remotely configure applications on their users’
phones.
If you’re developing apps for business or government, you may need
to satisfy your industry’s specific set of requirements. Using
managed configurations, the IT admin can remotely specify
settings and enforce policies for their users’ Android apps; for
example:
- Configure if an app can sync data via cellular/3G, or only Wi-Fi
- Allow or block URLs on a web browser
- Configure an app’s email settings
- Enable or disable printing
- Manage bookmarks
Best practices for implementing managed configurations
The Set up Managed Configurations
guide is the key source for information on how to build and deploy
managed configurations. After you’ve reviewed this documentation, see
recommendations below for additional guidance.
When first launching the app
As soon as you launch an application, you can see if managed
configurations are already set for this app in onStart() or
onResume(). Additionally, you can find out if your
application is managed or unmanaged. For example, if
getApplicationRestrictions() returns:
- A set of application-specific restrictions—You
can configure the managed configurations silently (without requiring
user input). - An empty bundle—Your application acts like
it’s unmanaged (for example, how the app behaves in a personal
profile). - A bundle with a single key value pair with
KEY_RESTRICTIONS_PENDINGset to true—your
application is being managed, but the DPC isn’t configured
correctly. You should block this user from your app, and direct
them to their IT admin.
Listen for changes to managed configurations
IT admins can change managed configurations and what
policies they want to enforce on their users at any time. Because of
this, we recommend you ensure that your app can accept new
restrictions for your managed configuration as follows:
- Fetch restrictions on launch—Your app should
callgetApplicationRestrictions()inonStart()
andonResume(), and compare against old restrictions
to see if changes are required. - Listen while running—Dynamically register
ACTION_APPLICATION_RESTRICTIONS_CHANGEDin your
running activities or services, after you’ve checked for new
restrictions. This intent is sent only to listeners that are
dynamically registered, and not to listeners declared in the app
manifest. - Unregister while not running—In
onPause(),
you should unregister for the broadcast of
ACTION_APPLICATION_RESTRICTIONS_CHANGED.
Dedicated devices
Dedicated devices are kiosk devices used
for a single purpose, such as digital signage displays, ticket
printing kiosks, or checkout registers.
When an Android device is configured as a dedicated device, the user sees
an application locked to the screen with no Home or Recent Apps
buttons to escape the app. Dedicated devices can also be configured to show a set
of applications, such as a library kiosk with an app for the library
catalog and a web browser.
For instructions, see
Dedicated-device.
Set up single sign-on with Chrome Custom Tabs
Enterprise users often have multiple apps on their device, and they
prefer to sign in once to access all of their work applications.
Typically, users sign in through a
WebView;
however, there are a couple reasons why this isn’t ideal:
-
Users often need to sign in multiple times with the same
credentials. The WebView solution often isn’t a true single
sign-on (SSO) experience. -
There can be security risks, including malicious applications
inspecting cookies or injecting JavaScript® to access a user’s
credentials. Even trusted developers are at risk if they rely on
potentially malicious third-party SDKs.
A solution to both problems is to authenticate users using browser
Custom Tabs, instead of WebView. This ensures that authentication:
-
Occurs in a secure context (the system browser) where the host app
cannot inspect contents. -
Has a shared cookie state, ensuring the user has to sign in only
once.
Requirements
Custom Tabs are supported back to API level 15 (Android 4.0.3).
To use Custom Tabs you need a supported browser, such as Chrome.
Chrome 45 and later implement this feature as
Chrome Custom Tabs.
How do I implement SSO with Custom Tabs?
Google has open sourced an OAuth client library that uses Custom
Tabs, contributing it to the OpenID Connect working group of the
OpenID Foundation. To set up Custom Tabs for SSO with the
AppAuth library, see the
documentation and sample code
on GitHub.
Test your app
After you’ve developed your app, you’ll want to test it—both in a work profile and on a fully
managed device. See the instructions below.
Use Test DPC to test your Android app
We provide the Test DPC app to help Android developers test their apps in an enterprise
environment. Using Test DPC, you can set EMM policies or managed configuration values on a
device—as if an organization managed the device using an EMM. To install Test DPC on a device,
choose one of the following methods:
- Install Test DPC from
GooglePlay. - Build from the source on
GitHub.
For more information on how to configure Test DPC, see the instructions below and the
Test DPC User
Guide.
Provision a work profile
To test your app in a work profile, you need to first provision a work profile on device using the
Test DPC app, as follows:
- Install Test DPC on the device.
- In the Android launcher, tap the Set up Test DPC app icon.
- Follow the onscreen instructions.
- Install your app on the device and test to see how it runs in the work profile.
Android creates a work profile and installs a copy of Test DPC in the work profile. You use this
work-badged instance of Test DPC to set policies and managed configurations in the work profile. To
learn more about setting up a work profile for development, read the developer’s guide
Work profiles.
Provision a fully managed device
Organizations use fully managed devices because they can enforce a full range of management
policies on the device. To provision a fully managed device, follow these steps:
- Install Test DPC on the device.
- Confirm that there are no other users or a work profile on the device.
- Confirm that there are no accounts on the device.
- Run the following Android Debug Bridge (adb) command in
your terminal:adb shell dpm set-device-owner com.afwsamples.testdpc/.DeviceAdminReceiver
- Once you’ve completed provisioning the device owner, you can test your app on that device. You
should specifically test how
managed configurations and
intents work on that device.
You can also use other provisioning methods—see the Test DPC User Guide. To learn how IT
admins typically enroll and provision Android-powered devices, read
Provision
devices.
End-to-end testing
After you’ve finished testing your app in the environments above,
you’ll likely want to test your app in an end-to-end production
environment. This process includes the steps a customer needs to
take to deploy your app in their organization, including:
- App distribution through Play
- Server-side managed configuration
- Server-side profile policy control
You need to access an EMM console to complete the end-to-end
testing. The easiest way to get one is to request a testing console
from your EMM. Once you have access, complete these tasks:
- Create a test version of your application with a
new ApplicationId. - Claim a managed Google domain and bind it to your EMM. If you
already have a testing domain that’s bound to an EMM, you may need
to unbind it to test it with your preferred EMM. Please consult your
EMM for the specific unbinding steps. - Publish your application to the private channel for their
managed Google domain. - Use the EMM console and EMM application to:
- Set up work devices.
- Distribute your application.
- Set managed configuration.
- Set device policies.
This process will differ based on your EMM. Please consult your
EMM’s documentation for further details. Congrats! You’ve completed
these steps and verified that your app works well for enterprise users.
Время на прочтение
6 мин
Количество просмотров 59K
И так, давайте начнем с того, что должен знать и уметь человек, чтобы стать Android разработчиком? Скиллсет будем смотреть по вот этому Roadmap
-
Язык. Kotlin
-
Основные компоненты Android
-
Верстка
-
Работа с сетью
-
Работа с БД
-
Работа с многопоточностью
-
Работа в фоне
-
Виды архитектур
-
DI
-
Анимации
-
Тестирование
-
GIT
-
Agile, таск-треккеры, документация
Далее будет разбор каждого из пунктов с курсами/книгами/материалами для изучения. Это будет моя личная субъективная подборка, не является рекламой)
Kotlin
Каждый год я делал подобные статьи и всегда писал, что нужно изучать Kotlin, с оговоркой, что есть Java и начинать нужно с нее и, кажется в 2023 году Java уже практически полностью потеряла актуальность в Android разработке. Проектов на Java уже не осталось, но на собеседованиях деды все еще любят поспрашивать «А как оно там работает?». Практической пользы в изучении Java стало меньше, но это все еще очень полезно для общего понимания.
И так, как изучать Kotlin? Есть два основных ресурса https://kotlinlang.org/ и его аналог на русском https://kotlinlang.ru/ . Для того чтобы изучать язык даже не потребуется компьютер, потому что у языка есть отличный Playground, который позволяет запускать программы в браузере и оттачивать свои навыки даже с мобильного телефона. Вам необходимо полностью проштудировать эти ресурсы.
Так же очень полезно будет просмотреть этот видео-урок про Kotlin.
В формате книги наиболее актуален «Kotlin in action» Дмитрий Жемеров, Светлана Исакова.
Основные компоненты Android
Основных компонентов в Android 4 — это Activity, Service, Broadcast Receiver, Content Provider. Называются они основными, поскольку они могут являться точками входа в ваше будущее приложение. Нам нужно разобраться что они делают и для чего они нужны.
Про работу Activity и прочих UI компонентов рекомендую это видео.
Про работу Service — видео.
Content Provider — урок на StartAndroid и официальная документация.
BroadcastReceiver — урок на Fandroid.
Со всеми компонентами нужно попрактиковаться и посмотреть как они работают.
Верстка
Сейчас переломный момент — существуют два подхода к верстке: XML и Compose. В моменте, практически все проекты все еще написаны на XML и Compose сейчас можно встретить довольно редко в коммерческой разработке, но тут все динамично меняется и, думаю, к концу года уже большое количество компаний будет использовать оба подхода либо уже полностью перейдут на верстку через Jetpack Compose
Для изучения подхода к верстке через XML отлично подойдет это видео.
Для изучения Compose лучше всего подойдут официальные туториалы от Google, Видео-курс Алексея Гладкова, а так же вот такой репозиторий с кучей полезных ссылок для изучения Compose.
Работа с сетью
Существует несколько подходов к построению сетевого взаимодействия: REST, SOAP, RPC, GraphQL. В вашем проекте может использоваться любой, но чаще всего это будет REST. Обязательно нужно изучить базовые концепции этого подхода. Исчерпывающей статьи на эту тему у меня нет, поэтому тут придется погуглить и почитать все подряд для того, чтобы сформировались общие знания. Для более базового понимания как все это работает советую изучить Сетевую модель OSI.
И так, на проекте у вас скорее всего будет REST и одна из основных Android-библиотек: либо Okhttp+Retrofit, либо Ktor.
Видео по Okhttp+Retrofit
Видео по Ktor BE+Android
Так же вам нужно будет изучить как работает сериализация в Android. В чем разница Serializable от Parcelable и попрактиковаться с одной из библиотек, которая позволяет сериализовать Json в Kotlin и наоборот. Библиотек много, но по факту все делают примерно одно и тоже, но с разной степенью эффективности. Названия библиотек — Kotlin Serialization, Gson, Jackson. В целом, для изучения особой разницы нет — берите любую
Работа с базой данных
В андроид есть две основные БД: Sqlite (Room), Realm. Google продвигает библиотеку Room, а значит скорее всего на своей потенциальной работе вы скорее всего будете использовать именно его.
Видео урок по базовым концепциям SQL и работе с Room
Серия уроков по работе с Room от Start Android
Базово этих знаний будет достаточно для разработки, если вы хотите понять как все это работает значительно глубже советую отложить себе в закладки книжку с кабанчиком. Небольшой спойлер — для новичка она будет неподъемной, и вы будете возвращаться к ней и перечитывать еще несколько лет подряд, после того как найдете работу.
Работа с многопоточностью
В Android есть три основных подхода к многопоточности: нативные Thread, RxJava, Kotlin Coroutines. Здесь вам нужно обязательно выучить базовые концепции многопоточности. Выбор между RxJava и Kotlin Coroutines довольно сложный, в идеале надо на базовом уровне уметь пользоваться обеими библиотеками, поскольку компании все еще используют разные подходы, и универсального решения тут нет.
Видео по базовым концепциям многопоточности и корутинам
Курс по корутинам от Кирилла Розова
Видео по RxJava
Книга для изучения базовых концепций:
Работа в фоне
Важно изучить способы запуска задач фоново через Service и Workmanager, методы обмена данными между этими задачами и основным приложением, а так же ограничения, которые есть в системе Android. Видео-урок на эти темы.
Виды архитектур
Это самая холиварная тема, архитектур довольно много, универсального и правильного решения нет — каждый развлекается как он хочет. Вам важно разобраться в базовых концепциях MVC/MVP/MVVM/MVI, понять как они работают и попрактиковаться в реализации. Видео-урок об основных архитектурах. После просмотра рекомендую зайти на Github и в просто скачать основные реализации по поисковым запросам MVP Android, MVVM Android, MVI Android etc. Так же нужно разобраться с основными концепциями SOLID, DRY, KISS, Clean Architecture и основными паттернами программирования.
DI
В Android довольно много реализаций Dependency Injection: Dagger, Hilt, Koin, Toothpick, ручное создание DI через фабрики. Я считаю, что правильнее всего разобраться с Dagger, это наиболее сложная реализация, но если вы поймете эти концепции, разобраться как работают другие библиотеки — труда не составит.
Ссылочки — Обзорное видео по основным DI библиотекам, Курс по Dagger 2, Видео об внутреннем устройстве Dagger 2.
Анимации
Чаще всего эту тему опускают, потому что в большинстве компаний нет времени на укарашалки в виде анимаций и, скорее всего, для старта можно эту тему изучать и вернуться к ней чуть позже, но, в любом случае, моя задача предоставить материалы для изучения.
Видео по анимациям Android c XML
Видео по анимациям Android с Jetpack Compose
Тестирование
Аналогично предыдущей теме, с написанием Unit/UI тестов вы стоклнетесь только, если придете в достаточно крутую компанию, которая уделяет время качеству приложений. В небольших командах на 2-5 разработчика, чаще всего написание тестов экономически нецелесообразно, поэтому в очень многих компаниях тесты практически не пишут
Видео урок про тестирование в двух частях Part 1 и Part 2
GIT
Обычно для начала работы достаточно разобраться с базовыми операциями — clone, pull, checkout, add, commit, push, cherry-pick. Просто заводим приватный репозиторий на Github и пробуем выполнять все команды
У Git-a есть прекрасная документация, где есть абсолютно все, что нужно
Agile, таск трекеры, докментация и тд
Чаще всего у компаний свое представление и реализация Agile/Scrum, поэтому об этом вам скорее всего уже расскажут, после того как вы устроитесь на работу. Базовые концепции Scrum можно прочитать вот в этой книжке:
Либо в более короткой версии Scrum guide.
Таск треккеры, сервисы документации — некоторые компании требуют чтобы у вас был опыт работы с Jira, Confluence, Trello и тд. Какой в этом практический смысл — не знаю, вся задача разработчика при работе с таск-трекером это своевременно двигать задачки из колонки слева в колонки справа. Какие-то более сложные настройки на старте вам все равно не доверят, поэтому советую просто запустить любую демо версию таск-трекера и посмотреть какие функции у него есть. По сервисам документации — аналогично, вести в них документацию не сложнее, чем писать ее в Word.
Практика
И теперь самое важное, мы изучили все теоретические материалы и теперь нам нужно отточить практические навыки. Работодатель будет требовать от вас примеры работ, но где их взять? Начать стоит с разработки стандартных приложений — Cinema App, Weather App, Currency Converter etc. Для этого идем на Behance (либо любой другой сервис с дизайн макетами), вводим там одно из вышеперечисленных названий и ищем макеты. Находим открытую API платформу, ссылок тут уже не будет — если вы изучили все вышеперечисленное и дошли до этого момента, то скорее всего вы справитесь с этой задачей без моей помощи 
Берем API, берем макеты и начинаем кодить! Пробуем реализовывать разные подходы, все это оставляем в своем портфолио на Github, когда вы пойдете на собеседование и вас попросят реализовать тестовое задание, то у вас скорее всего уже будет готовая реализация на их задачу и вы сразу же будете в более выгодном положении на фоне других кандидатов.
По ходу изучения всего этого материала, вы, однозначно, столкнетесь с кучей разнообразных проблем — это нормально, все мы когда-то сидели и тупили над элементарными вещами. Главное делать, практиковаться и не останавливаться
Для тех, кто дочитал до конца, хотел бы запустить небольшой эксперимент: вы делаете любой тестовый проект — я помогаю его вам доработать до приемлемого состояния. Не знаю какой будет спрос, но на всякий случай ограничиваю первыми пятью, кто разработает приложение и напишет мне в Telegram.
Contents:
- The development process
- Using Android Studio
- Exploring a project
- Understanding the Android manifest
- Understanding the build process
- Running the app on an emulator or a device
- Using the log
- Related practical
- Learn more
This chapter describes how to develop applications using Android Studio, which is an integrated development environment (IDE) for Android.
The development process
An Android app project begins with an idea and a definition of the requirements necessary to realize that idea. You may want to sketch user interfaces (UIs) for the various app functions. To show what a UI would look like and how it would work, use drawings, mockups, and prototypes.
When you are ready to start coding, you use Android Studio to go through the following steps:
- Create the project in Android Studio and choose an appropriate template.
- Define a layout for each screen that has UI elements. You can place UI elements on the screen using the layout editor, or you can write code directly in the Extensible Markup Language (XML).
- Write code using the Java programming language. Create source code for all of the app’s components.
- Build and run the app on real and virtual devices. Use the default build configuration or create custom builds for different versions of your app.©
- Test and debug the app’s logic and UI.
- Publish the app by assembling the final APK (package file) and distributing it through channels such as Google Play.
Using Android Studio
Android Studio provides a unified development environment for creating apps for all Android-powered devices. Android Studio includes code templates with sample code for common app features, extensive testing tools and frameworks, and a flexible build system.
Starting an Android Studio project
After you have successfully installed the Android Studio IDE, double-click the Android Studio application icon to start it. Click Start a new Android Studio project in the Welcome window, and name the project the same name that you want to use for the app.
When choosing a unique Company domain, keep in mind that apps published to Google Play must have a unique package name. Because domains are unique, prepending the app’s name with your name, or your company’s domain name, should provide an adequately unique package name. If you don’t plan to publish the app, you can accept the default example domain. Be aware that changing the package name later is extra work.
Choosing target devices and the minimum SDK
When choosing Target Android Devices, Phone and Tablet are selected by default, as shown in the figure below. The choice shown in the figure for the Minimum SDK—API 15: Android 4.0.3 (IceCreamSandwich)—makes your app compatible with 97% of Android-powered devices active on the Google Play Store.
Different devices run different versions of the Android system, such as Android 4.0.3 or Android 4.4. Each successive version often adds new APIs not available in the previous version. To indicate which set of APIs are available, each version specifies an API level. For instance, Android 1.0 is API level 1 and Android 4.0.3 is API level 15.
The Minimum SDK declares the minimum Android version for your app. Each successive version of Android provides compatibility for apps that were built using the APIs from previous versions. That means your app should always be compatible with future versions of Android, if you use the documented Android APIs.
Choosing an Activity template
An Activity is a single, focused thing that the user can do. It is a crucial component of any Android app. An Activity typically has a layout associated with it that defines how UI elements appear on a screen.
Android Studio pre-populates your project with minimal code for an Activity and layout based on a template. Available Activity templates range from a virtually blank template (Add No Activity) to an Activity that includes navigation and an options menu.
You can customize the Activity after you select your template. For example, the Empty Activity choice provides a single Activity with a single layout resource for the screen. The Configure Activity screen appears after you click Next. On the Configure Activity screen you can accept the commonly used name for the Activity (such as MainActivity), or you can change the name.
Tip: This course covers the Activity class in more detail in another practical. You can also read Introduction to Activities for a comprehensive introduction.
The Configure Activity screen differs depending on which template you chose. In most cases you can select the following options, if they are not already selected:
- Generate Layout file: Leave this checkbox selected to create the layout resource connected to this
Activity, which is usually namedactivity_main. The layout defines the UI for theActivity. - Backwards Compatibility (AppCompat): Leave this checkbox selected to include the
AppCompatlibrary. Use theAppCompatlibrary to make sure that the app is compatible with previous versions of Android, even if the app uses features found only in newer Android versions.
Android Studio creates a folder for your projects, and builds the project with Gradle.
Tip: See the Configure your build developer page for detailed information.
Exploring a project
An Android Studio project contains all of the source code and all resources for an app. The resources include layouts, strings, colors, dimensions, and images. The Android Studio main window is made up of several logical areas, or panes, as shown in the figure below.
In the figure above:
- Toolbar: Provides a wide range of actions, including running the Android app and launching Android tools.
- Navigation bar: Navigate through the project and open files for editing.
- Project pane: Displays project files in a hierarchy. The selected hierarchy in the figure above is Android.
- Editor: The contents of a selected file in the project. For example, after you select a layout (as shown in the figure above), the editor pane shows the layout editor with tools to edit the layout. After you select a Java code file, the editor pane shows the Java code with tools for editing the code.
- Tabs along the left, right, and bottom of the window: You can click tabs to open other panes, such as Logcat to open the Logcat pane with log messages, or TODO to manage tasks.
The status bar at the bottom of the Android Studio window displays the status of the project and Android Studio itself, as well as any warnings or messages. You can watch the build progress in the status bar.
Tip: You can organize the main window to give yourself more screen space by hiding or moving panes. You can also use keyboard shortcuts to access most features. See Keyboard Shortcuts for a complete list.
Using the Project pane
You can view the project organization in several ways in the Project pane. If it is not already selected, click the Project tab. (The Project tab is in the vertical tab column on the left side of the Android Studio window.)
The Project pane appears. To view the project in the standard Android project hierarchy, select Android from the Down arrow at the top of the Project pane.
Note: This chapter and other chapters refer to the Project pane, when set to Android, as the Project > Android pane.
Gradle files
When you first create an app project, the Project > Android pane appears with the Gradle Scripts folder expanded as shown below. If the Gradle Scripts folder is not expanded, click the triangle to expand it. This folder contains all the files needed by the build system.
The build.gradle(Module:app) file specifies additional libraries and the module’s build configuration. The Activity template that you select creates this file. The file includes the minSdkVersion attribute that declares the minimum version for the app, and the targetSdkVersion attribute that declares the highest (newest) version for which the app has been optimized.
This file also includes a list of dependencies, which are libraries required by the code—such as the AppCompat library for supporting a wide range of Android versions.
App code
To view and edit the Java code, expand the app folder, the java folder, and the com.example.android.helloworld folder. Double-click the MainActivity java file to open it in the code editor.
The java folder includes Java class files. Each Activity, Service, or other component (such as a Fragment) is defined as a Java class, usually in its own file. Tests and other Java class files are also located here.
The java folder contains three subfolders:
com.example.hello.helloworld(or the domain name you have specified): All the files for a package are in a folder named after the package. For your Hello World app, there is one package, and it contains onlyMainActivity.java. The firstActivity(screen) that the user sees, which also initializes app-wide resources, is customarily calledMainActivity. (The file extension is omitted in the Project > Android pane.)com.example.hello.helloworld(androidTest): This folder is for your instrumented tests, and starts out with a skeleton test file.com.example.hello.helloworld(test): This folder is for your unit tests and starts out with an automatically created skeleton unit test file.
Layout files
To view and edit a layout file, expand the res folder and the layout folder to see the layout file. In the figure below, the layout file is called activity_main.xml.
Double-click the file to open it in the layout editor. Layout files are written in XML.
Resource files
The res folder holds resources, such as layouts, strings, and images. An Activity is usually associated with a layout of UI views that are defined as an XML file. This XML file is usually named after its Activity. The res folder includes these subfolders:
drawable: Store all your app’s images in this folder.layout: EveryActivityhas at least one XML layout file that describes the UI. For Hello World, this folder containsactivity_main.xml.mipmap: The launcher icons are stored in this folder. There is a subfolder for each supported screen density. Android uses the screen density (the number of pixels per inch) to determine the required image resolution. Android groups all actual screen densities into generalized densities, such as medium (mdpi), high (hdpi), or extra-extra-extra-high (xxxhdpi).
Theic_launcher.pngfolder contains the default launcher icons for all the densities supported by your app.values: Instead of hardcoding values like strings, dimensions, and colors in your XML and Java files, it is best practice to define them in their respectivevaluesfiles. This practice makes it easier to change the values and keep the values consistent across your app.
The values subfolder includes these subfolders:
colors.xml: Shows the default colors for your chosen theme. You can add your own colors or change the colors based on your app’s requirements.dimens.xml: Store the sizes of views and objects for different resolutions.strings.xml: Create resources for all your strings. Doing this makes it easy to translate the strings to other languages.styles.xml: All the styles for your app and theme go here. Styles help give your app a consistent look for all UI elements.
Using the editor pane
If you select a file, the editor pane appears. A tab appears for the file so that you can open multiple files and switch between them. For example, if you double-click the activity_main.xml layout file in the Project > Android pane, the layout editor appears as shown below.
If you double-click the MainActivity file in the Project > Android pane, the editor changes to the code editor as shown below, with a tab for MainActivity.java:
At the top of the MainActivity.java file is a package statement that defines the app package. This package statement is followed by an import block condensed with ..., as shown in the figure above. Click the dots to expand the block to view it. The import statements import libraries needed for the app. For example, the following statement imports the AppCompatActivity library:
import android.support.v7.app.AppCompatActivity;
Each Activity in an app is implemented as a Java class. The following class declaration extends the AppCompatActivity class to implement features in a way that is backward-compatible with previous versions of Android:
public class MainActivity extends AppCompatActivity {
// ... Rest of the code for the class.
}
Understanding the Android manifest
Before the Android system can start an app component such as an Activity, the system must know that the Activity exists. It does so by reading the app’s AndroidManifest.xml file, which describes all of the components of your Android app. Each Activity must be listed in this XML file, along with all components for the app.
To view and edit the AndroidManifest.xml file, expand the manifests folder in the Project > Android pane, and double-click AndroidManifest.xml. Its contents appear in the editing pane:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.helloworld">
<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">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Android namespace and application tag
The Android Manifest is coded in XML and always uses the Android namespace:
xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.helloworld">
The package expression shows the unique package name of the new app. Do not change the package expression after the app is published.
The <application> tag, with its closing </application> tag, defines the manifest settings for the entire app.
Automatic backup
The android:allowBackup attribute enables automatic app data backup:
android:allowBackup="true"
Setting the android:allowBackup attribute to true enables the app to be backed up automatically and restored as needed. Users invest time and effort to configure apps. Switching to a new device can cancel out all that careful configuration. The system performs this automatic backup for nearly all app data by default, and does so without the developer having to write any additional app code.
For apps whose target SDK version is Android 6.0 (API level 23) and higher, devices running Android 6.0 and higher automatically create backups of app data to the cloud because the android:allowBackup attribute defaults to true if omitted. For apps < API level 22 you have to explicitly add the android:allowBackup attribute and set it to true.
Tip: To learn more about the automatic backup for apps, see Configuring Auto Backup for Apps.
The app icon
The android:icon attribute sets the icon for the app:
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
The android:icon attribute assigns to the app an icon in the mipmap folder (inside the res folder in the Project > Android pane). The icon appears on the home screen or in the Search Apps screen for launching the app. The icon is also used as the default icon for app components.
App label and string resources
The android:label attribute shows the string "Hello World" highlighted. If you click the string, it changes to show the string resource @string/app_name:
android:label="@string/app_name"
Tip: To see the context menu, ctrl-click or right-click app_name in the editor pane. Select Go To > Declaration to see where the string resource is declared: in the strings.xml file. When you select Go To > Declaration or open the file by double-clicking strings.xml inside the values folder in the Project > Android pane, the file’s contents appear in the editor pane.
After opening the strings.xml file, you can see that the string name app_name is set to Hello World. You can change the app name by changing the Hello World string to something else. String resources are described in a separate lesson.
App theme
The android:theme attribute sets the app’s theme, which defines the appearance of UI elements such as text:
android:theme="@style/AppTheme">
The theme attribute is set to the standard theme AppTheme. Themes are described in a separate lesson.
Declaring the Android version
Different devices may run different versions of the Android system, such as Android 4.0 or Android 4.4. Each successive version can add new APIs not available in the previous version. To indicate which set of APIs are available, each version specifies an API level. For instance, Android 1.0 is API level 1 and Android 4.4 is API level 19.
The API level allows a developer to declare the minimum version with which the app is compatible, using the <uses-sdk> manifest tag and its minSdkVersion attribute. For example, the Calendar Provider APIs were added in Android 4.0 (API level 14). If your app can’t function without these APIs, declare API level 14 as the app’s minimum supported version like this:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.helloworld">
<uses-sdk android:minSdkVersion="14" android:targetSdkVersion="19" />
// ... Rest of manifest information
</manifest>
The minSdkVersion attribute declares the minimum version for the app, and the targetSdkVersion attribute declares the highest (newest) version which has been optimized within the app. Each successive version of Android provides compatibility for apps that were built using the APIs from previous versions, so the app should always be compatible with future versions of Android while using the documented Android APIs.
The targetSdkVersion attribute does not prevent an app from being installed on Android versions that are higher (newer) than the specified value. Even so, the target attribute is important, because it indicates to the system whether the app should inherit behavior changes in newer versions.
If you don’t update the targetSdkVersion to the latest version, the system assumes that your app requires backward-compatible behaviors when it runs on the latest version. For example, among the behavior changes in Android 4.4, alarms created with the AlarmManager APIs are now inexact by default so that the system can batch app alarms and preserve system power. If your target API level is lower than "19", the system retains the previous API’s behavior for your app.
Understanding the build process
The Android application package (APK) is the package file format for distributing and installing Android mobile apps. The build process involves tools and processes that automatically convert each project into an APK.
Android Studio uses Gradle as the foundation of the build system, with more Android-specific capabilities provided by the Android Plugin for Gradle. This build system runs as an integrated tool from the Android Studio menu.
Understanding build.gradle files
When you create a project, Android Studio automatically generates the necessary build files in the Gradle Scripts folder in the Project > Android pane. Android Studio build files are named build.gradle as shown below:
build.gradle (Project: apptitle)
This file is the top-level build file for the entire project, located in the root project folder, which defines build configurations that apply to all modules in your project. This file, generated by Android Studio, should not be edited to include app dependencies.
If a dependency is something other than a local library or file tree, Gradle looks for the files in whichever online repositories are specified in the repositories block of this file. By default, new Android Studio projects declare JCenter and Google (which includes the Google Maven repository) as the repository locations:
allprojects {
repositories {
google()
jcenter()
}
}
build.gradle (Module: app)
Android Studio creates separate build.gradle (Module: app) files for each module. You can edit the build settings to provide custom packaging options for each module, such as additional build types and product flavors, and to override settings in the manifest or top-level build.gradle file. This file is most often the file to edit when changing app-level configurations, such as declaring dependencies in the dependencies section. The following shows the contents of a project’s build.gradle (Module: app) file:
apply plugin: 'com.android.application'
android {
compileSdkVersion 26
defaultConfig {
applicationId "com.example.android.helloworld"
minSdkVersion 15
targetSdkVersion 26
versionCode 1
versionName "1.0"
testInstrumentationRunner
"android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:appcompat-v7:26.1.0'
implementation 'com.android.support.constraint:constraint-layout:1.0.2'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner:1.0.1'
androidTestImplementation
'com.android.support.test.espresso:espresso-core:3.0.1'
}
The build.gradle files use Gradle syntax. Gradle is a Domain Specific Language (DSL) for describing and manipulating the build logic using Groovy, which is a dynamic language for the Java Virtual Machine (JVM). You don’t need to learn Groovy to make changes, because the Android Plugin for Gradle introduces most of the DSL elements you need.
Tip: To learn more about the Android plugin DSL, read the DSL reference documentation.
Plugin and Android blocks
In the build.gradle (Module: app) file above, the first statement applies the Android-specific Gradle plug-in build tasks:
apply plugin: 'com.android.application'
android {
compileSdkVersion 26
// ... Rest of android block.
}
The android { } block specifies the target SDK version for compiling the app code ( compileSdkVersion 26) and several blocks of information.
The defaultConfig block
Core settings and entries for the app are specified in the defaultConfig { } block within the android { } block:
defaultConfig {
applicationId "com.example.android.helloworld"
minSdkVersion 15
targetSdkVersion 26
versionCode 1
versionName "1.0"
testInstrumentationRunner
"android.support.test.runner.AndroidJUnitRunner"
}
The minSdkVersion and targetSdkVersion settings override any AndroidManifest.xml settings for the minimum SDK version and the target SDK version. See «Declaring the Android version» previously in this chapter for background information on these settings.
The testInstrumentationRunner statement adds the instrumentation support for testing the UI using Espresso and UIAutomator. These tools are described in a separate lesson.
Build types
Build types for the app are specified in a buildTypes { } block, which controls how the app is built and packaged.
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'),
'proguard-rules.pro'
}
}
The build type specified is release for the app’s release. Another common build type is debug. Configuring build types is described in a separate lesson.
Dependencies
Dependencies for the app are defined in the dependencies { } block, which is the part of the build.gradle file that is most likely to change as you start developing code that depends on other libraries. The block is part of the standard Gradle API and belongs outside the android { } block.
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'com.android.support:appcompat-v7:26.1.0'
implementation 'com.android.support.constraint:constraint-layout:1.0.2'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner:1.0.1'
androidTestImplementation
'com.android.support.test.espresso:espresso-core:3.0.1'
}
In the snippet above, the statement implementation fileTree(dir: 'libs', include: ['*.jar']) adds a dependency of all «.jar» files inside the libs folder.
Syncing your project
When you make changes to the build configuration files in a project, Android Studio requires that you sync the project files. During the sync, Android Studio imports the build configuration changes and runs checks to make sure the configuration won’t create build errors.
To sync the project files, click Sync Now in the notification bar that appears when making a change (as shown in the figure below), or click the Sync Project with Gradle Files button
in the menu bar.
If Android Studio notices any errors with the configuration — for example, if the source code uses API features that are only available in an API level higher than the compileSdkVersion—the Messages window appears to describe the issue.
Running the app on an emulator or a device
With virtual device emulators, you can test an app on different devices such as tablets or smartphones—with different API levels for different Android versions—to make sure it looks good and works for most users. You don’t have to depend on having a physical device available for app development.
The Android Virtual Device (AVD) manager creates a virtual device or emulator that simulates the configuration for a particular type of Android-powered device. Use the AVD Manager to define the hardware characteristics of a device and its API level, and to save it as a virtual device configuration. When you start the Android emulator, it reads a specified configuration and creates an emulated device on your computer that behaves exactly like a physical version of that device.
Creating a virtual device
To run an emulator on your computer, use the AVD Manager to create a configuration that describes the virtual device. Select Tools > Android > AVD Manager, or click the AVD Manager icon
in the toolbar.
The Your Virtual Devices screen appears showing all of the virtual devices created previously. Click the +Create Virtual Device button to create a new virtual device.
You can select a device from a list of predefined hardware devices. For each device, the table provides a column for its diagonal display size (Size), screen resolution in pixels (Resolution), and pixel density (Density). For example, the pixel density of the Nexus 5 device is xxhdpi, which means the app uses the icons in the xxhdpi folder of the mipmap folder. Likewise, the app uses layouts and drawables from folders defined for that density.
After you click Next, the System Image screen appears for choosing the version of the Android system for the device. The Recommended tab shows the recommended systems for the device. More versions are available under the x86 Images and Other Images tabs. If a Download link is visible next to a system image version, it is not installed yet. Click the link to start the download, and click Finish when it’s done.
Running the app on the virtual device
To run the app on the virtual device you created in the previous section, follow these steps:
-
In Android Studio, select Run > Run app or click the
Run icon in the toolbar. -
In the Select Deployment Target window, under Available Emulators, select the virtual device you created, and click OK.
Run icon in the toolbar.The emulator starts and boots just like a physical device. Depending on the speed of your computer, the startup process might take a while. The app builds, and once the emulator is ready, Android Studio uploads the app to the emulator and runs it.
You should see the app created from the Empty Activity template («Hello World») as shown in the following figure, which also shows Android Studio’s Run pane that displays the actions performed to run the app on the emulator.
Tip: When testing on a virtual device, it is a good practice to start it up once, at the very beginning of your session. Do not close it until you are done testing your app, so that your app doesn’t have to go through the device startup process again. To close the virtual device, select Quit from the menu or press Control-Q in Windows or Command-Q in macOS.
The figure above shows the emulator and the run log:
- The Emulator running the app.
- The Run pane, which shows the actions taken to install and run the app.
- The Run tab, which you click to open or close the Run pane.
Running the app on a physical device
Always test your apps on a physical device. While emulators are useful, they can’t show all possible device states, such as what happens if an incoming call occurs while the app is running. To run the app on a physical device, you need the following:
- An Android-powered device such as a phone or tablet.
- A data cable to connect your Android-powered device to your computer via the USB port.
- If you are using a Linux or Windows system, you may need to perform additional steps to run on a hardware device. Check the Using Hardware Devices documentation. You may also need to install the appropriate USB driver for your device. See OEM USB Drivers.
To let Android Studio communicate with your Android-powered device, you must turn on USB Debugging on the device. You enable USB Debugging in the device’s Developer options settings. (Note that enabling USB Debugging is not the same as rooting your device.)
On Android 4.2 and higher, the Developer options screen is hidden by default. To show developer options and enable USB Debugging:
- On your device, open Settings > About phone and tap Build number seven times.
- Return to the previous screen (Settings). Developer options appears at the bottom of the list. Tap Developer options.
- Select USB Debugging.
- Connect the device and run the app from Android Studio.
Using the log
The log is a powerful debugging tool you can use to look at values, execution paths, and exceptions. After you add logging statements to an app, your log messages appear along with general log messages in the Logcat pane.
Viewing log messages
To see the Logcat pane, click the Logcat tab at the bottom of the Android Studio window as shown in the figure below.
In the figure above:
- The Logcat tab for opening and closing the Logcat pane, which displays information about your app as it is running. If you add
Logstatements to your app,Logmessages appear here. - The
Loglevel menu set to Verbose (the default), which shows allLogmessages. Other settings include Debug, Error, Info, and Warn.
Adding logging statements to your app
Logging statements add whatever messages you specify to the log. Adding logging statements at certain points in the code allows the developer to look at values, execution paths, and exceptions. For example, the following logging statement adds "MainActivity" and "Hello World" to the log:
Log.d("MainActivity", "Hello World");
The following are the elements of this statement:
Log: TheLogclass for sending log messages to the Logcat pane.d: The DebugLoglevel setting to filter log message display in the Logcat pane. Other log levels areefor Error,wfor Warn, andifor Info. You assign a log level so that you can filter the log messages using the drop-down menu in the center of the Logcat pane."MainActivity": The first argument is a tag which can be used to filter messages in the Logcat pane. This tag is commonly the name of theActivityfrom which the message originates. However, you can name the tag anything that is useful to you for debugging."Hello world": The second argument is the actual message.
By convention, log tags are defined as constants for the Activity:
private static final String LOG_TAG = MainActivity.class.getSimpleName();
Use the constant in the logging statements:
Log.d(LOG_TAG, "Hello World");
After you add the Log.d statement shown above, follow these steps to see the log message:
- If the Logcat pane is not already open, click the Logcat tab at the bottom of Android Studio to open it.
- Change the
Loglevel in the Logcat pane to Debug. (You can also leave theLoglevel as Verbose, because there are so few log messages.) - Run your app on a virtual device.
The following message should appear in the Logcat pane:
11-24 14:06:59.001 4696-4696/? D/MainActivity: Hello World
The related practical is 1.1 Android Studio and Hello World.
Learn more
Android Studio documentation:
- Android Studio download page
- Meet Android Studio
- Reading and writing logs
- Android Virtual Device (AVD) manager
- App Manifest
- Configure Your Build
Logclass- Configure Build Variants
- Create and Manage Virtual Devices
- Sign Your App
- Shrink Your Code and Resources
Android API Guide, «Develop» section:
- Introduction to Android
- Platform Architecture
- UI Overview
- Platform versions
- Supporting Different Platform Versions
- Supporting Multiple Screens
Other:
- Wikipedia: Summary of Android version history
- Groovy syntax
- How do I install Java?
- Installing the JDK Software and Setting JAVA_HOME
- Gradle site
- Gradle Wikipedia page
Android – базирующаяся на ОС Linux операционная система с открытым исходным кодом, предназначенная для мобильных устройств – таких, как, например, смартфоны или планшетные компьютеры.
Это руководство предназначено для введения в основные понятия программирования под Android, так что после его изучения вы будете понимать некоторые базовые концепции программирования под эту ОС.
От вас же, в свою очередь, требуется только желание и базовое понимание программирования на языке Java. Не так много, правда? Что ж, начнём!
Среда разработки
Для разработки приложений под Android можно использовать любые из перечисленных операционных систем:
- Microsoft Windows XP или более поздняя версия
- Mac OS X 10.5.8 или более поздняя версия с чипом Intel
- Linux, включающая GNU C Library 2.7 или более позднюю версию
При этом все необходимые инструменты для разработки Android-приложений находятся в свободном доступе и вы можете загрузить их из Интернета. Для того, чтобы начать создавать приложения под Android, вам понадобятся:
- Java JDK5 или более поздняя версия
- Android Studio
Структура приложений
Поздравляем, ваше оборудование готово к работе! Однако прежде чем приступить к вашему первому приложению, поговорим о том, что из себя представляет приложение на Android и из чего оно состоит.
Компоненты приложения являются своего рода «строительными блоками» для приложения Android. Эти компоненты связаны файлом-манифестом приложения AndroidManifest.xml, который описывает каждый компонент приложения и взаимодействие этих компонентов между собой.
Есть четыре базовых типа компонентов, которые могут быть использованы в приложении Android:
- Операции (Activities) представляют собой элементы пользовательского интерфейса (одна операция – один экран) и отвечают за взаимодействие пользователя с экраном мобильного устройства;
- Службы (Services) представляют собой длительные операции, работающие в фоновом режиме и не имеющие пользовательского интерфейса (например, передача данных), вместо этого они, как правило, запускаются иными элементами, уже имеющими пользовательский интерфейс, и взаимодействуют с ними;
- Приемники широковещательных сообщений (Broadcast receivers) представляют собой компоненты, реагирующие на объявления самой ОС, передаваемые всей системе (как хороший пример – объявление о низком уровне заряда батареи устройства). Они также не имеют пользовательского интерфейса, однако могут передавать данные другим компонентам, где они демонстрируются пользователю в виде уведомлений;
- Поставщики контента (Content providers) представляют собой компоненты, управляющие взаимодействием приложения с его базой данных — посредством поставщика контента другие компоненты приложения могут запрашивать или изменять данные.
Помимо четырех базовых типов, существуют дополнительные типы компонентов, используемые для выстраивания взаимодействий и связей как между базовыми типами компонентов, так и между компонентами и внешними элементами. К ним относятся:
- Фрагменты (Fragments) – части пользовательского интерфейса в Операциях (см. выше);
- Виды (Views) – элементы пользовательского интерфейса, отображаемые на экране, например, кнопки, списки и т. д.;
- Макеты (Layouts) – определяют элементы пользовательского интерфейса, их свойства и расположение;
- Намерения (Intents) – соединяют вместе различные компоненты приложения или связывают друг с другом работу разных приложений;
- Ресурсы (Resources) – внешние элементы, такие, как строки, константы или изображения;
- Манифест (Manifest) – конфигурационный файл приложения.
Теперь, когда вы получили базовое понимание о структуре приложений на Android, хотелось бы предложить вам самим попробовать создать свое первое приложение.
Первое приложение
Итак, давайте приступим к созданию простого Android-приложения, которое будет выводить на экран «Hello World!».
У вас к этому времени уже должен быть установлен Android Studio последней версии. Ниже будет приведена небольшая пошаговая инструкция:
- Откройте Android Studio.
- В открывшемся окне кликните на «Start a new Android Studio project», чтобы создать новый проект.
- В открывшемся окне в строку «Application name» введите название вашего будущего приложения. Нажмите Next.
- В следующем окне вам нужно выбрать тип устройств, для которых создается приложение – в нашем случае необходимо выбрать «Phone and Tablet» (смартфоны и планшетные компьютеры), а в выпадающем списке под названием «Minimum SDK» нужно выбрать версию Android, для которой создается приложение (обычно указывается самая ранняя версия, способная запустить приложение) – в нашем конкретном случае выберем версию Android 6.0. Если в вашей версии есть возможность выбрать язык программирования (выпадающее окно Language), выберите пункт “Java”. Остальные опции можно оставить без изменений. Нажмите Next.
- На следующем этапе выберите пункт Empty Activity – это будет означать, что экран нашего приложения не будет иметь никаких дополнительных элементов. Нажмите Next.
Теперь перед вами открылась привычная среда разработки. К сожалению или к счастью, но сейчас вам не нужно будет писать код – среда разработки уже сделала это за вас, создав файлы для приложения, выводящего «Hello world!» на экран, по умолчанию. Вместо этого хотелось бы обратить ваше внимание на несколько созданных файлов и папок, найти которые вы можете в колонке слева, отображающей все элементы проекта.
- Файл MainActivity.java
В папке «Java» содержатся исходные файлы формата .java для вашего приложения. По умолчанию в ней находится исходный файл MainActivity.java, имеющий класс Операция – он запускается при нажатии пользователем на иконку приложения на устройстве. Этот файл содержит главный код приложения, и именно он преобразуется в файл .exe для запуска приложения на устройстве.
- Файл AndroidManifest.xml
Это файл типа «Манифест», который описывает основные характеристики приложения и определяет каждый из его компонентов. Он является своего рода интерфейсом между ОС Android и вашим приложением – если компонент не упомянут в этом файле, он не будет отображен и в операционной системе.
- Файл Build.gradle
Это автоматически генерируемый файл, содержащий определённые данные касательно приложения – такие, как, например, версия SDK.
Запустить приложение можно двумя способами: на реальном устройстве или на эмуляторе в самой среде разработки. В нашем случае мы рассмотрим более универсальный случай – запуск на эмуляторе, полностью имитирующем работу устройства с операционной системой Android.
Запуск приложения на эмуляторе
Попытайтесь запустить приложение кнопкой «Run» – в появившемся диалоговом окне выберите пункт «Create New Virtual Device». В последующих окнах нужно будет выбрать размер экрана и версию Android – помните, что она должна быть не ниже, чем указанная на этапе создания проекта. В случае, если данная версия Android будет отсутствовать на компьютере, Android Studio предложит ее загрузить. Остальные пункты можно оставить без изменений – на данный момент нет необходимости их изменять. После выбора всех настроек нажмите кнопку «Finish», и если вы увидели на своем мониторе экран телефона с названием вашего приложения сверху и с надписью «Hello world!» на экране, значит, вы можете себя поздравить – вы создали свое первое Android-приложение!
Теперь у вас есть базовое понимание и минимальный опыт в создании приложений на Android. Этого, разумеется, совершенно не хватит, чтобы заниматься разработкой, но это необходимый для дальнейшего развития фундамент – продолжайте изучать и практиковаться! Всего наилучшего!
Также можно научиться создавать приложения на Android и другие ОС после прохождения нашего шестимесячного курса «Профессия: Разработчик» 👉 Узнать подробности!