没有合适的资源?快使用搜索试试~ 我知道了~
有关android专业技术英文文献翻译.docx
1.该资源内容由用户上传,如若侵权请联系客服进行举报
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
2.虚拟产品一经售出概不退款(资源遇到问题,请及时私信上传者)
版权申诉
0 下载量 79 浏览量
2021-12-02
13:19:45
上传
评论
收藏 139KB DOCX 举报
温馨提示
试读
22页
有关android专业技术英文文献翻译.docx
资源详情
资源评论
资源推荐
英语原文
Android Application Fundamentals
Android applications are written in the Java programming language. The Android SDK
tools compile the code—along with any data and resource files—into anAndroid package, an
archive file with an.apksuffix. All the code in a single.apkfile is considered to be one
application and is the file that Android-powered devices use to install the application.
Once installed on a device, each Android application lives in its own security sandbox:
The Android operating system is a multi-user Linux system in which each
application is a different user.
By default, the system assigns each application a unique Linux user ID (the ID is
used only by the system and is unknown to the application). The system sets
permissions for all the files in an application so that only the user ID assigned to that
application can access them.
Each process has its own virtual machine (VM), so an application's code runs in
isolation from other applications.
By default, every application runs in its own Linux process. Android starts the
process when any of the application's components need to be executed, then shuts
down the process when it's no longer needed or when the system must recover
memory for other applications.
In this way, the Android system implements theprinciple of least privilege. That is, each
application, by default, has access only to the components that it requires to do its work and
no more. This creates a very secure environment in which an application cannot access parts
of the system for which it is not given permission.
However, there are ways for an application to share data with other applications and for
an application to access system services:
It's possible to arrange for two applications to share the same Linux user ID, in which
case they are able to access each other's files. To conserve system resources,
applications with the same user ID can also arrange to run in the same Linux process
and share the same VM (the applications must also be signed with the same
certificate).
An application can request permission to access device data such as the user's
contacts, SMS messages, the mountable storage (SD card), camera, Bluetooth, and
more. All application permissions must be granted by the user at install time.
That covers the basics regarding how an Android application exists within the system. The
rest of this document introduces you to:
The core framework components that define your application.
The manifest file in which you declare components and required device features for
your application.
Resources that are separate from the application code and allow your application to
gracefully optimize its behavior for a variety of device configurations.
Application Components
Application components are the essential building blocks of an Android application. Each
component is a different point through which the system can enter your application. Not all
components are actual entry points for the user and some depend on each other, but each one
exists as its own entity and plays a specific role—each one is a unique building block that
helps define your application's overall behavior.
There are four different types of application components. Each type serves a distinct purpose
and has a distinct lifecycle that defines how the component is created and destroyed.
Here are the four types of application components:
Activities
Anactivityrepresents 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. Although the activities
work together to form a cohesive user experience in the email application, each one is
independent of the others. As such, a different application can start any one of these
activities (if the email application allows it). For example, a camera application can
start the activity in the email application that composes new mail, in order for the user
to share a picture.
共 21 页 第 1 页
An activity is implemented as a subclass ofActivityand you can learn more about it in
theActivitiesdeveloper guide.
Services
Aserviceis a component that runs in the background to perform long-running
operations or to perform work for remote processes. A service does not provide a user
interface. 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. Another component, such as an activity, can start the
service and let it run or bind to it in order to interact with it.
A service is implemented as a subclass ofServiceand you can learn more about it in
theServicesdeveloper guide.
Content providers
Acontent providermanages a shared set of application data. You can store the data in
the file system, an SQLite database, on the web, or any other persistent storage
location your application can access. Through the content provider, other applications
can query or even modify the data (if the content provider allows it). For example, the
Android system provides a content provider that manages the user's contact
information. As such, any application with the proper permissions can query part of
the content provider (such asContactsContract.Data) to read and write information
about a particular person.
Content providers are also useful for reading and writing data that is private to your
application and not shared. For example, theNote Padsample application uses a
content provider to save notes.
A content provider is implemented as a subclass ofContentProviderand must
implement a standard set of APIs that enable other applications to perform
transactions. For more information, see theContent Providersdeveloper guide.
Broadcast receivers
Abroadcast receiveris a component that responds to system-wide broadcast
announcements. Many broadcasts originate from the system—for example, a
broadcast announcing that the screen has turned off, the battery is low, or a picture was
共 21 页 第 2 页
captured. Applications can also initiate broadcasts—for example, to let other
applications know that some data has been downloaded to the device and is available
for them to use. Although broadcast receivers don't display a user interface, they
maycreate a status bar notificationto alert the user when a broadcast event occurs.
More commonly, though, a broadcast receiver is just a "gateway" to other components
and is intended to do a very minimal amount of work. For instance, it might initiate a
service to perform some work based on the event.
A broadcast receiver is implemented as a subclass ofBroadcastReceiverand each
broadcast is delivered as anIntentobject. For more information, see
theBroadcastReceiverclass.
A unique aspect of the Android system design is that any application can start another
application’s component. For example, if you want the user to capture a photo with the device
camera, there's probably another application that does that and your application can use it,
instead of developing an activity to capture a photo yourself. You don't need to incorporate or
even link to the code from the camera application. Instead, you can simply start the activity in
the camera application that captures a photo. When complete, the photo is even returned to
your application so you can use it. To the user, it seems as if the camera is actually a part of
your application.
When the system starts a component, it starts the process for that application (if it's not
already running) and instantiates the classes needed for the component. For example, if your
application starts the activity in the camera application that captures a photo, that activity runs
in the process that belongs to the camera application, not in your application's process.
Therefore, unlike applications on most other systems, Android applications don't have a single
entry point (there's nomain()function, for example).
Because the system runs each application in a separate process with file permissions that
restrict access to other applications, your application cannot directly activate a component
from another application. The Android system, however, can. So, to activate a component in
another application, you must deliver a message to the system that specifies yourintentto
start a particular component. The system then activates the component for you.
Activating Components
共 21 页 第 3 页
Three of the four component types—activities, services, and broadcast receivers—are
activated by an asynchronous message called anintent. Intents bind individual components to
each other at runtime (you can think of them as the messengers that request an action from
other components), whether the component belongs to your application or another.
An intent is created with anIntentobject, which defines a message to activate either a
specific component or a specifictypeof component—an intent can be either explicit or
implicit, respectively.
For activities and services, an intent defines the action to perform (for example, to "view"
or "send" something) and may specify the URI of the data to act on (among other things that
the component being started might need to know). For example, an intent might convey a
request for an activity to show an image or to open a web page. In some cases, you can start
an activity to receive a result, in which case, the activity also returns the result in
anIntent(for example, you can issue an intent to let the user pick a personal contact and have
it returned to you—the return intent includes a URI pointing to the chosen contact).
For broadcast receivers, the intent simply defines the announcement being broadcast (for
example, a broadcast to indicate the device battery is low includes only a known action string
that indicates "battery is low").
The other component type, content provider, is not activated by intents. Rather, it is
activated when targeted by a request from aContentResolver. The content resolver handles all
direct transactions with the content provider so that the component that's performing
transactions with the provider doesn't need to and instead calls methods on
theContentResolverobject. This leaves a layer of abstraction between the content provider
and the component requesting information (for security).
There are separate methods for activating each type of component:
You can start an activity (or give it something new to do) by passing
anIntenttostartActivity()orstartActivityForResult()(when you want the activity to
return a result).
You can start a service (or give new instructions to an ongoing service) by passing
anIntenttostartService(). Or you can bind to the service by passing
anIntenttobindService().
共 21 页 第 4 页
剩余21页未读,继续阅读
学习使人快乐张
- 粉丝: 14
- 资源: 6万+
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- 基于Javascript的影视动画设计源码 - cad
- 基于Java和深度学习的瓦斯浓度预测系统后端设计源码 - 瓦斯浓度预测后端
- Screenshot_20240528_103010.jpg
- 基于Python的新能源承载力计算及界面设计源码 - HAINING-DG
- 基于Java的本科探索学习项目设计源码 - 本科探索
- 基于Javascript和Python的微商城项目设计源码 - MicroMall
- 基于Java的网上订餐系统设计源码 - online ordering system
- 基于Javascript的超级美眉网络资源管理应用模块设计源码
- 基于Typescript和PHP的编程知识储备库设计源码 - study-php
- Screenshot_2024-05-28-11-40-58-177_com.tencent.mm.jpg
资源上传下载、课程学习等过程中有任何疑问或建议,欢迎提出宝贵意见哦~我们会及时处理!
点击此处反馈
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功
评论0