{"id":75491,"date":"2023-11-05T16:04:30","date_gmt":"2023-11-05T16:04:30","guid":{"rendered":"https:\/\/essays.homeworkacetutors.com\/an-android-application-development\/"},"modified":"2023-11-05T16:04:30","modified_gmt":"2023-11-05T16:04:30","slug":"an-android-application-development","status":"publish","type":"post","link":"https:\/\/www.colapapers.com\/us\/an-android-application-development\/","title":{"rendered":"An Android Application Development"},"content":{"rendered":"
\n

This paper talks briefly about developing applications on the android mobile platform using the Java Programming language. The overview includes introduction to the android platform features, architecture, APIs, application framework and the android SDK. A Hello World application walks you through the development process to understand the concepts of the android software stack and the tools involved.<\/p>\n

In late 2007, a group of industry leaders came together around the Android Platform to form the Open Handset Alliance (http:\/\/www.openhandsetalliance.com). Some of the alliance\u2019s prominent members include:\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Sprint Nextel \u00e2\u20ac\u00a2 T-Mobile\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Motorola \u00e2\u20ac\u00a2 Samsung\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Sony Ericsson \u00e2\u20ac\u00a2 Toshiba\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Vodafone\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Google\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Intel\u00a0<\/p>\n

\u00e2\u20ac\u00a2 Texas Instruments.\u00a0<\/p>\n

Android was designed to serve the needs of mobile operators, handset manufacturers, and application developers [3].<\/p>\n

Android is:<\/h2>\n

A software stack for mobile devices that includes an operating system (Linux Kernel version 2.6), middleware and key applications. The Android SDK provides the tools and APIs necessary to begin developing applications on the Android platform using the Java programming language [1].<\/p>\n

The Figure1: \u201cAndroid Architecture diagram\u201d gives a good overview of what constitutes the android platform. Android includes a set of C\/C++ libraries (indicated green in Figure1) used by various components of the Android system. These capabilities are exposed to developers through the Android application framework.<\/p>\n

Android Platform Features:<\/h2>\n

The following is an explanation of the building blocks of the platform as indicated in Figure1.<\/p>\n

Application framework: Developers have full access to the same framework APIs used by the core applications (refer Figure1) written in Java. An application can publish its capabilities and any other application may then make use of those capabilities. Underlying all applications is a set of services and systems, including:<\/p>\n

A rich and extensible set of Views that can be used to build an application, including<\/p>\n

lists, grids, text boxes, buttons, and even an embeddable web browser<\/p>\n

Content Providers that enable applications to access data from other applications (such as<\/p>\n

Contacts), or to share their own data<\/p>\n

A Resource Manager, providing access to non-code resources such as localized strings,<\/p>\n

graphics, and layout files<\/p>\n

A Notification Manager that enables all applications to display custom alerts in the status<\/p>\n

bar<\/p>\n

An Activity Manager that manages the lifecycle of applications and provides a common<\/p>\n

navigation backstack<\/p>\n

Dalvik virtual machine optimized for mobile devices, executes files in the Dalvik<\/p>\n

Executable (.dex) format. The \u2018dx\u2019 tool included in the SDK converts .class files into .dex<\/p>\n

files.<\/p>\n

Integrated browser based on the open source WebKit engine<\/p>\n

Optimized graphics powered by a custom 2D graphics library; 3D graphics based on<\/p>\n

the OpenGL ES 1.0 specification (hardware acceleration optional)<\/p>\n

SQLite for structured data storage<\/p>\n

Media support for common audio, video, and still image formats (MPEG4, H.264,<\/p>\n

MP3, AAC, AMR, JPG, PNG, GIF)<\/p>\n

GSM Telephony (hardware dependent)<\/p>\n

Bluetooth, EDGE, 3G, and WiFi (hardware dependent)<\/p>\n

Camera, GPS, compass, and accelerometer (hardware dependent)<\/p>\n

Rich development environment including a device emulator, tools for debugging,<\/p>\n

memory and performance profiling, and a plugin for the Eclipse IDE<\/p>\n

Application Fundamentals:<\/h2>\n

Android applications are written in the Java programming language. The compiled Java code along with any data and resource files required by the application is bundled by the aapt tool into an Android package, an archive file marked by an .apk suffix. This file is the vehicle for distributing the application and installing it on mobile devices; it\u2019s the file users download to their devices. All the code in a single .apk file is considered to be one application. By default, every application runs in its own Linux process, with a unique linux user id. Each process has its own virtual machine (VM).<\/p>\n

Application Components:<\/h2>\n

Android applications consist of loosely coupled components, bound using a project manifest that describes each component and how they interact. There are six components that provide the building blocks for your applications:<\/p>\n

1) Activities:<\/h2>\n

Your application\u2019s presentation layer. Every screen in your application will be an<\/p>\n

extension of the Activity class. Activities use Views to form graphical user interfaces that<\/p>\n

displays information and respond to user actions. In terms of desktop development, an<\/p>\n

Activity is equivalent to a Form.<\/p>\n

2) Services:<\/h2>\n

Services are the invisible workers of your application. Service components run invisibly,<\/p>\n

updating your data sources and visible Activities and triggering Notifi cations. They\u2019re used<\/p>\n

to perform regular processing that needs to continue even when your application\u2019s Activities<\/p>\n

aren\u2019t active or visible.<\/p>\n

3) Content Providers:<\/h2>\n

Are a shareable data store. Content Providers are used to manage and share application<\/p>\n

databases. Content Providers are the preferred way of sharing data across application<\/p>\n

boundaries. This means that you can confi gure your own Content Providers to permit access<\/p>\n

from other applications and use Content Providers exposed by others to access their stored<\/p>\n

data. Android devices include several native Content Providers that expose useful databases<\/p>\n

like contact information.<\/p>\n

4) Intents:<\/h2>\n

They are simple message-passing framework. Using Intents, you can broadcast messages<\/p>\n

system-wide or to a target Activity or Service, stating your intention to have an action<\/p>\n

performed. The system will then determine the target(s) that will perform any actions as<\/p>\n

appropriate.<\/p>\n

5) Broadcast Receivers:<\/h2>\n

By creating and registering a Broadcast Receiver, your application can listen for broadcast<\/p>\n

Intents that match specific filter criteria. Broadcast Receivers will automatically start your<\/p>\n

application to respond to an incoming Intent, making them ideal for event-driven<\/p>\n

applications.<\/p>\n

6) Notifications:<\/h2>\n

They are user notification framework. Notifi cations let you signal users without stealing<\/p>\n

focus or interrupting their current Activities. They are the preferred technique for getting<\/p>\n

a user\u2019s attention from within a Service or Broadcast Receiver. For example, when a device<\/p>\n

receives a text message or an incoming call, it alerts you by fl ashing lights, making sounds,<\/p>\n

displaying icons, or showing dialog messages. You can trigger these same events from your<\/p>\n

own applications using Notifications. By decoupling the dependencies between application<\/p>\n

components, you can share and interchange individual pieces, such as Content Providers or<\/p>\n

Services, with other applications \u2013 both your own and those of third parties.<\/p>\n

The manifest file:<\/h2>\n

The AndroidManifest.xml file is where your global settings are made. If you are an<\/p>\n

ASP.NET developer, you can think of AndroidManifest.xml as Web.config and<\/p>\n

Global.asax rolled into one. (If you are not an ASP.NET developer, this means that<\/p>\n

AndroidManifest.xml is a place for storing settings.) AndroidManifest.xml will include<\/p>\n

such settings as application permissions, Activities, and intent filters. [4]<\/p>\n

Please refer to Code 1: Manifest file<\/p>\n

Building Hello World Application:<\/h2>\n

We will write the first android application, Hello World, using the eclipse IDE.<\/p>\n

Make sure that you have a suitable version of Eclipse(3.5 or 3.6 recommended) installed on<\/p>\n

your computer. Download the windows .zip file for the SDK starter package. Unpack the<\/p>\n

SDK files into a directory named android-sdk- in a safe location on<\/machine-platform><\/p>\n

your computer.<\/p>\n

Next, install the Eclipse(3.5 or 3.6) ADT plug-in for Android as follows:<\/h2>\n

Start Eclipse, then select Help > Install New Software\u2026.<\/p>\n

Click Add, in the top-right corner.<\/p>\n

In the Add Repository dialog that appears, enter \u201cADT Plugin\u201d for the Name and the<\/p>\n

following URL for the Location: https:\/\/dl-ssl.google.com\/android\/eclipse\/<\/p>\n

In Available Software dialog, select checkbox next to Developer Tools, click Next<\/p>\n

In the next window, you\u2019ll see a list of the tools to be downloaded. Click Next.<\/p>\n

Read and accept the license agreements, then click Finish.<\/p>\n

When the installation completes, restart Eclipse.<\/p>\n

Then, configure ADT by doing following steps:<\/h2>\n

Select Window > Preferences\u2026 to open the Preferences panel<\/p>\n

Select Android from the left panel.<\/p>\n

For the SDK Location in the main panel, click Browse\u2026 and locate your downloaded<\/p>\n

SDK directory.<\/p>\n

Click Apply, then OK.<\/p>\n

Now, to install a platform in Eclipse:<\/h2>\n

In the Android SDK and AVD Manager, choose Available Packages in the left panel.<\/p>\n

Click the repository site checkbox to display the components available for installation.<\/p>\n

Select at least one platform to install, and click Install Selected. If you aren\u2019t sure which<\/p>\n

platform to install, use the latest version.<\/p>\n

Go on, and create an AVD:<\/h2>\n

In Eclipse, choose Window > Android SDK and AVD Manager.<\/p>\n

Select Virtual Devices in the left panel.<\/p>\n

Click New. (The Create New AVD dialog appears.)<\/p>\n

Type the name of the AVD, such as \u201cmy_avd\u201d.<\/p>\n

Choose a target. The target is the platform (that is, the version of the Android SDK, such<\/p>\n

as 2.1) you want to run on the emulator.<\/p>\n

You can ignore the rest of the fields for now.<\/p>\n

Click Create AVD.<\/p>\n

Create a New Android Project:<\/h2>\n

After you\u2019ve created an AVD, the next step is to start a new Android project in Eclipse.<\/p>\n

Please refer to Figure 1&2: New Android Project and also follow the steps below.<\/p>\n

Fill in the project details with the following values:<\/p>\n

Project name: HelloAndroid<\/p>\n

Application name: Hello, Android<\/p>\n

Package name: com.example.helloandroid (or your own private namespace)<\/p>\n

Create Activity: HelloAndroid<\/p>\n

Click Finish.<\/p>\n

Here is a description of each field:<\/p>\n

Project Name: The name of the directory that will contain the project files.<\/p>\n

Application Name: This is the human-readable title for your application \u2013 the name that<\/p>\n

will appear on the Android device.<\/p>\n

Package Name: This is the package namespace (following the same rules as for packages<\/p>\n

in the Java programming language) that you want all your source code to reside under. This<\/p>\n

also sets the package name under which the stub Activity will be generated.<\/p>\n

Your package name must be unique across all packages installed on the Android system; for this reason, it\u2019s important to use a standard domain-style package for your applications. The example above uses the \u201ccom.example\u201d namespace, which is a namespace reserved for example documentation \u2013 when you develop your own applications, you should use a namespace that\u2019s appropriate to your organization or entity.<\/p>\n

Create Activity<\/h2>\n

This is the name for the class stub that will be generated by the plugin. This will be a subclass of Android\u2019s Activity class. An Activity is simply a class that can run and do work. It can create a UI if it chooses, but it doesn\u2019t need to. As the checkbox suggests, this is optional, but an Activity is almost always used as the basis for an application.<\/p>\n

Min SDK Version: This value specifies the minimum API Level required by your application. For more information, see Android API Levels.<\/p>\n

Other fields: The checkbox for \u201cUse default location\u201d allows you to change the location on disk where the project\u2019s files will be generated and stored. \u201cBuild Target\u201d is the platform target that your application will be compiled against (this should be selected automatically, based on your Min SDK Version). Notice that the \u201cBuild Target\u201d you\u2019ve selected uses the Android 1.1 platform. This means that your application will be compiled against the Android 1.1 platform library. If you recall, the AVD created above runs on the Android 1.5 platform. These don\u2019t have to match; Android applications are forward-compatible, so an application built against the 1.1 platform library will run normally on the 1.5 platform. The reverse is not true.<\/p>\n

Your Android project is now ready. It should be visible in the Package Explorer on the left. Open the HelloAndroid.java file, located inside HelloAndroid > src > com.example.helloandroid). Please refer to Code2: HelloAndroid. Notice that the class is based on the Activity class. An Activity is a single application entity that is used to perform actions. An application may have many separate activities, but the user interacts with them one at a time. The onCreate() method will be called by the Android system when your Activity starts \u2013 it is where you should perform all initialization and UI setup. An activity is not required to have a user interface, but usually will. Now let\u2019s modify some code!<\/p>\n

Construct the UI<\/h2>\n

Please refer to Code 3: Construct UI<\/p>\n

An Android user interface is composed of hierarchies of objects called Views. A View is a drawable object used as an element in your UI layout, such as a button, image, or (in this case) a text label. Each of these objects is a subclass of the View class and the subclass that handles text is TextView. In this change, you create a TextView with the class constructor, which accepts an Android Context instance as its parameter. A Context is a handle to the system; it provides services like resolving resources, obtaining access to databases and preferences, and so on. The Activity class inherits from Context, and because your HelloAndroid class is a subclass of Activity, it is also a Context. So, you can pass this as your Context reference to the TextView.<\/p>\n

Next, you define the text content with setText(). Finally, you pass the TextView to setContentView() in order to display it as the content for the Activity UI. If your Activity doesn\u2019t call this method, then no UI is present and the system will display a blank screen.<\/p>\n

There it is \u2013 \u201cHello, World\u201d in Android! The next step, of course, is to see it running.<\/p>\n

Run the Application:<\/h2>\n

The Eclipse plugin makes it easy to run your applications:<\/p>\n

Select Run > Run.<\/p>\n

Select \u201cAndroid Application\u201d.<\/p>\n

The Eclipse plugin automatically creates a new run configuration for your project and then launches the Android Emulator. Depending on your environment, the Android emulator might take several minutes to boot fully, so please be patient. When the emulator is booted, the Eclipse plugin installs your application and launches the default Activity. You should now see something like this: Please refer to Figure 4: Hello Android. The \u201cHello, Android\u201d you see in the grey bar is actually the application title. The Eclipse plugin creates this automatically (the string is defined in the res\/values\/strings.xml file and referenced by your AndroidManifest.xml file). The text below the title is the actual text that you have created in the TextView object.<\/p>\n

Conclusion:<\/h2>\n

That concludes the basic \u201cHello World\u201d tutorial. Refer to http:\/\/developer.android.com\/index.html for more information. To do that, android offers a number of APIs for developing your applications. The following list of core APIs that provide an insight into what\u2019s available; all Android devices will offer support for at least these Java APIs[2]:<\/p>\n

android.util: The core utility package contains low-level classes like specialized containers,<\/p>\n

string formatters, and XML parsing utilities.<\/p>\n

com.google.android.maps: A high-level API that provides access to native map controls<\/p>\n

that you can use within your application. Includes the MapView control as well as the<\/p>\n

overlay and MapController classes used to annotate and control your embedded maps.<\/p>\n

android.text: The text processing tools for displaying and parsing text.<\/p>\n

android.database: low-level classes required for working with databases.<\/p>\n

Figures:<\/h2>\n

Figure 1: Android Architecture Diagram<\/h2>\n

Figure2: New Android Project<\/h2>\n

Figure3: New Android Project<\/h2>\n

Figure 4: Hello Android<\/h2>\n

Code 1: Manifest File<\/h2>\n<\/p>\n

<\/manifest><\/p>\n

<\/application><\/p>\n

<\/p>\n

android:icon=\u201d@drawable\/small_pic.png\u201d<\/p>\n

android:label=\u201d@string\/freneticLabel\u201d<\/p>\n

. . . ><\/h2>\n<\/p>\n

<\/activity><\/p>\n

. . .<\/h2>\n<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

This paper talks briefly about developing applications on the android mobile platform using the Java Programming language. The overview includes introduction to the android platform features, architecture, APIs, application framework and the android SDK. A Hello World application walks you through the development process to understand the concepts of the android software stack and the […]<\/p>\n","protected":false},"author":8,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5797],"tags":[9790,9869,9870,9889,3953,9940,9799,9939],"class_list":["post-75491","post","type-post","status-publish","format-standard","hentry","category-computer-science","tag-assignment-help-for-masters-students","tag-au","tag-complete-the-assignment-in-a-page-paper","tag-in-1050-word-essay","tag-need-help-writing-a-masters-thesis","tag-online-class-course-exam-help","tag-research-essay-pro","tag-write-my-essay-homework-due-in-hours"],"_links":{"self":[{"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/posts\/75491","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/users\/8"}],"replies":[{"embeddable":true,"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/comments?post=75491"}],"version-history":[{"count":0,"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/posts\/75491\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/media?parent=75491"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/categories?post=75491"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.colapapers.com\/us\/wp-json\/wp\/v2\/tags?post=75491"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}