Wednesday, June 29, 2016
Monday, June 20, 2016
Running Your App
If you followed the previous lesson to create an Android project, it includes
a default set of "Hello World" source files that allow you to
immediately run the app.
How you run your app depends on two
things: whether you have a real device running Android and whether you're using
Android Studio. This lesson shows you how to install and run your app on a real
device and on the Android emulator, and in both cases with either Android
Studio or the command line tools.
Run
on a Real Device
If you have a device
running Android, here's how to install and run your app.
Set up your device
1. Plug in your device to your development machine with a USB
cable. If you're developing on Windows, you might need to install the
appropriate USB driver for your device. For help installing drivers, see
the OEM USB Drivers document.
2. Enable USB debugging on your device. On
Android 4.0 and newer, go to Settings > Developer options.
Note: On Android 4.2 and
newer, Developer options is hidden by default. To make it
available, go to Settings > About phone and tap Build
number seven
times. Return to the previous screen to find Developer options.
Run the app from Android Studio
1. Select one of your project's files and click Run 
from
the toolbar.
from
the toolbar.
2. In the Choose Device window that appears,
select the Choose a running device radio button, select your
device, and click OK .
Android Studio installs the app on your
connected device and starts it.
Run on the
Emulator
Whether you're using Android Studio or the command line, to
run your app on the emulator you need to first create an Android Virtual Device (AVD). An AVD is a device
configuration for the Android emulator that allows you to model a specific
device.
Create an AVD
Launch the Android
Virtual Device Manager:
·
In Android Studio, select Tools
> Android > AVD Manager, or click the AVD Manager icon 
in
the toolbar. The AVD Manager screen appears.
in
the toolbar. The AVD Manager screen appears.
·
Or, from the command line, change
directories to sdk/ and
execute:
·
tools/android avd
Note: The AVD Manager that
appears when launched from the command line is different from the version in
Android Studio, so the following instructions may not all apply.
2. On the AVD Manager main screen, click Create
Virtual Device.
3. In the Select Hardware window, select a
device configuration, such as Nexus 6, then click Next.
4. Select the desired system version for
the AVD and click Next.
5. Verify the configuration settings, then
click Finish.
For more information
about using AVDs, see Managing
AVDs with AVD Manager.
Run the app from Android Studio
1. In Android Studio, select your project and
click Run from
the toolbar.
from
the toolbar.
2. In the Choose Device window, click
the Launch emulator radio button.
3. From the Android virtual device pull-down
menu, select the emulator you created, and click OK.
It can take a few minutes for the
emulator to load itself. You may have to unlock the screen. When you do, My
First App appears on the emulator screen.
That's how you build and run your
Android app on the emulator!
Android Resources
Your Android project is now a basic
"Hello World" app that contains some default files. Take a moment to
review the most important of these:
app/src/main/res/layout/activity_my.xml
This
XML layout file is for the activity you added when you created the project with
Android Studio. Following the New Project workflow, Android Studio presents
this file with both a text view and a preview of the screen UI. The file
contains some default interface elements from the material design library,
including the app bar and
a floating action button. It also includes a separate layout file with the main
content.
app/src/main/res/layout/content_my.xml
This
XML layout file resides in activity_my.xml, and contains some settings and a TextView element that displays the
message, "Hello world!".
app/src/main/java/com.mycompany.myfirstapp/MyActivity.java
A
tab for this file appears in Android Studio when the New Project workflow
finishes. When you select the file you see the class definition for the
activity you created. When you build and run the app, the Activity class starts the activity and loads the layout file
that says "Hello World!"
app/src/main/AndroidManifest.xml
The manifest file describes
the fundamental characteristics of the app and defines each of its components.
You'll revisit this file as you follow these lessons and add more components to
your app.
app/build.gradle
Android
Studio uses Gradle to compile and build your app. There is a build.gradle file for each module of your
project, as well as abuild.gradle file for the entire project. Usually, you're only
interested in the build.gradle file for the module, in this case the app or application module. This is
where your app's build dependencies are set, including the defaultConfig settings:
·
compiledSdkVersion is the platform version against which you will compile
your app. By default, this is set to the latest version of Android available in
your SDK. (It should be Android 4.1 or greater; if you don't have such a
version available, you must install one using the SDK Manager.)
You can still build your app to support older versions, but setting this to the
latest version allows you to enable new features and optimize your app for a
great user experience on the latest devices.
·
applicationId is the fully qualified package name for your
application that you specified during the New Project workflow.
·
minSdkVersion is the Minimum SDK version you specified during the
New Project workflow. This is the earliest version of the Android SDK that your
app supports.
·
targetSdkVersion indicates the highest version of Android with which
you have tested your application. As new versions of Android become available,
you should test your app on the new version and update this value to match the
latest API level and thereby take advantage of new platform features. For more
information, read Supporting
Different Platform Versions.
See Building Your
Project with Gradle for more information about Gradle.
drawable-<density>/
Directories
for drawable
resources, other than launcher icons, designed for various densities.
layout/
Directory
for files that define your app's user interface like activity_my.xml, discussed above, which describes a
basic layout for the MyActivityclass.
menu/
Directory
for files that define your app's menu items.
mipmap/
Launcher
icons reside in the mipmap/ folder rather than the drawable/ folders. This folder contains
the ic_launcher.png image that appears when you run the default app.
values/
Directory
for other XML files that contain a collection of resources, such as string and
color definitions.
Create a Project with Android Studio
1. In Android Studio, create a new
project:
o If you don't have a project opened, in
the Welcome screen, click New Project.
o If you have a project opened, from the File menu, select New Project. The Create New Project screen appears.
2. Fill out the fields on the screen, and
click Next.
It is easier to follow these lessons if you use the same
values as shown.
o Application Name is the app name that appears to users. For this project, use
"My First App."
o Company domain provides a qualifier that will be appended to the package
name; Android Studio will remember this qualifier for each new project you
create.
o Package name is the fully qualified name for the project (following the
same rules as those for naming packages in the Java programming language). Your
package name must be unique across all packages installed on the Android
system. You can Edit this value independently from the
application name or the company domain.
o Project location is the directory on your system that holds the project
files.
1. Under Select the form factors your
app will run on, check the box for Phone and Tablet.
2. For Minimum SDK, select API 8: Android 2.2 (Froyo).
The Minimum Required SDK is the earliest version of Android
that your app supports, indicated using the API level. To support as many devices as possible, you should
set this to the lowest version available that allows your app to provide its
core feature set. If any feature of your app is possible only on newer versions
of Android and it's not critical to the app's core feature set, you can enable
the feature only when running on the versions that support it (as discussed in Supporting Different Platform Versions).
5. Leave all of the other
options (TV, Wear, and Glass) unchecked and click Next.
Activities
An
activity is one of the distinguishing features of the Android framework.
Activities provide the user with access to your app, and there may be many
activities. An application will usually have a main activity for when the user
launches the application, another activity for when she selects some content to
view, for example, and other activities for when she performs other tasks
within the app. See Activities for
more information.
6. Under Add an
activity to <template>, select Blank
Activity and
click Next.
7. Under Customize
the Activity, change the Activity Name to MyActivity. The Layout
Name changes toactivity_my, and
the Title to MyActivity. The Menu
Resource Name is menu_my.
8. Click the Finish button to create the project.
Set Up Your Environment
Before you start this class, be sure you have your development
environment set up. You need to:
1. Download Android Studio.
2. Download the latest SDK tools and
platforms using the SDK Manager.
Install Android
studio
Setting up Android Studio takes just a
few clicks.
While the Android
Studio download completes, verify which version of the JDK you
have: open a command line and typejavac -version. If the JDK is not available or the version is lower than
1.8, download the Java SE Development Kit 8.
To install Android Studio on Windows,
proceed as follows:
1. Launch the .exe file
you downloaded.
2. Follow the setup wizard to install Android Studio and any
necessary SDK tools.
On
some Windows systems, the launcher script does not find where the JDK is
installed. If you encounter this problem, you need to set an environment
variable indicating the correct location.
Select Start
menu > Computer > System Properties > Advanced System Properties.
Then open Advanced tab > Environment Variables and add a
new system variable JAVA_HOME that points to your JDK folder, for example C:\Program Files\Java\jdk1.8.0_77.
Android
Architecture
Android
operating system is a stack of software components which is roughly divided
into five sections and four main layers as shown below in the architecture diagram.
Linux
kernel
At the bottom of the layers is Linux - Linux
2.6 with approximately 115 patches. This provides basic system functionality
like process management, memory management, device management like camera,
keypad, display etc. Also, the kernel handles all the things that Linux is
really good at such as networking and a vast array of device drivers, which
take the pain out of interfacing to peripheral hardware.
Libraries
On
top of Linux kernel there is a set of libraries including open-source Web
browser engine WebKit, well known library libc, SQLite database which is a
useful repository for storage and sharing of application data, libraries to
play and record audio and video, SSL libraries responsible for Internet
security etc.
Android
Runtime
This
is the third section of the architecture and available on the second layer from
the bottom. This section provides a key component called Dalvik Virtual Machine
which is a kind of Java Virtual Machine specially designed and optimized for
Android. The Dalvik VM makes use of Linux core features like memory management
and multi-threading, which is intrinsic in the Java language. The Dalvik VM enables every Android application to
run in its own process, with its own instance of the Dalvik virtual machine. The Android runtime
also provides a set of core libraries which enable Android application
developers to write Android applications using standard Java programming
language.
Application
Framework
The
Application Framework layer provides many higher-level services to applications
in the form of Java classes. Application developers are allowed to make use of
these services in their applications.
Applications
You
will find all the Android application at the top layer. You will write your
application to be installed on this layer only. Examples of such applications
are Contacts Books, Browser, Games etc.
Application Components
Application
components are the essential building blocks of an Android application. These
components are loosely coupled by the application manifest file
AndroidManifest.xml that describes each component of the application and how
they interact. There are following four main components that can be used within
an Android application:
Activities
An
activity represents a single screen with a user interface. For example, an
email application might have one activity that shows a list of new emails,
another activity to compose an email, and another activity for reading emails.
If an application has more than one activity, then one of them should be marked
as the activity that is presented when the application is launched. An activity
is implemented as a subclass of Activity class as follows:
public class MainActivity extends Activity
{
}
Services
A service is a component that runs in the
background to perform long-running operations. For example, a service might
play music in the background while the user is in a different application, or
it might fetch data over the network without blocking user interaction with an
activity. A service is implemented as a subclass of Service class as follows:
public class MyService extends Service {
Broadcast
Receivers
Broadcast Receivers
simply respond to broadcast messages from other applications or from the
system. For example, applications can also initiate broadcasts to let other
applications know that some data has been downloaded to the device and is
available for them to use, so this is broadcast receiver who will intercept
this communication and will initiate appropriate action. A broadcast receiver
is implemented as a subclass of BroadcastReceiver class and each message is
broadcasted as an Intent object.
public class MyReceiver extends BroadcastReceiver
{
}
Content
Providers
A
content provider component supplies data from one application to others on
request. Such requests are handled by the methods of the ContentResolver class.
The data may be stored in the file system, the database or somewhere else
entirely. A content provider is implemented as a subclass of ContentProvider
class and must implement a standard set of APIs that enable other applications
to perform transactions.
About Android
Android is a mobile
operating system (OS) currently developed by Google, based on the Linux
kernel and designed
primarily for touch screen mobile devices such as smart phones and tablets.
It has been the best-selling OS on tablets and on smart phones since 2013, and
has the largest installed base.
The
first beta version of the Android Software Development Kit (SDK) was released
by Google in 2007 where as the first commercial version, Android 1.0, was
released in September 2008. On June 27, 2012, at the Google I/O conference,
Google announced the next Android version, 4.1 Jelly Bean. Jelly Bean is an
incremental update, with the primary aim of improving the user interface, both
in terms of functionality and performance. The source code for Android is
available under free and open source software licenses. Google publishes most
of the code under the Apache License version 2.0 and the rest, Linux kernel
changes, under the GNU General Public License version 2.
Android
Applications
Android
applications are usually developed in the Java language using the Android
Software Development Kit. Once developed, Android applications can be packaged
easily and sold out either through a store such as Google Play or the Amazon
Appstore. Android powers hundreds of millions of mobile devices in more than
190 countries around the world. It's the largest installed base of any mobile
platform and growing fast. Every day more than 1 million new Android devices
are activated worldwide. This tutorial has been written with an aim to teach
you how to develop and package Android application. We will start from
environment setup for Android application programming and then drill down to
look into various aspects of Android applications.
Subscribe to:
Comments (Atom)