外文与翻译.安卓体系架构

MVC框架中英⽂对照外⽂翻译⽂献中英⽂对照外⽂翻译⽂献(⽂档含英⽂原⽂和中⽂翻译)译⽂：Web 2.0下的Spring MVC框架摘要 - 当要建⽴丰富⽤户体验的WEB应⽤时，有⼤量的WED应⽤框架可以使⽤，却很少有该选择哪⼀种的指导。

WEB 2.0应⽤允许个体管理他们⾃⼰的在线⽹页，并能与其他在线⽤户和服务器共享。

这样分享需要访问控制器来实现。

然⽽，现有的访问控制器解决⽅案不是令⼈很满意。

因为在开放且由⽤户主导的WEB环境下，它满⾜不了⽤户的功能需求。

MVC框架是在所有的WEB开发框架中最受欢迎的。

模型-视图-控制器（MVC）是⼀种软件架构，如今被认为是⼀种体系结构在软件⼯程模式中使⽤。

该模式从⽤户界⾯（输⼊和演⽰）分离出了“领域逻辑”（基于⽤户的应⽤逻辑），它允许独⽴地开发，测试和维护每个分离的部分。

模型-视图-控制器（MVC）模型创建的应⽤分离为不同的层次应⽤，同时在每两者之间建⽴松散的耦合。

关键字 - Spring MVC, 结构， XStudio, SOA, 控制器I.绪论如何确切地定义⼀个⽹站为“WEB 2.0”的呢？关于这有着许多不同见解，使它很难精确地下⼀个确切的定论。

但当我们将所有的WEB开发框架过⼀遍之后它就会变得清晰了。

各种基于WEB开发的架构如下：●Ntier架构（Ntier Architecture）在软件⼯程中，多层架构（常被称为n-tier架构）是⼀种表⽰层，应⽤处理层和数据管理层在逻辑上分开处理的客户端-服务器架构。

例如，⼀个应⽤在⽤户与数据库之间使⽤中间件提供数据请求服务就⽤到了多层体系结构。

最为⼴泛应⽤的多层体系结构是三层架构。

N-tier 应⽤架构为开发者提供了⽤来创建了⼀个灵活且可复⽤的模型。

通过打破应⽤层次，开发者只需修改或添加⼀个特定的层，⽽不是要去重写⼀遍整个应⽤。

它需要有⼀个表⽰层，⼀个业务层或者数据访问层和⼀个数据层。

层（layer）和层(tier)之间的概念常常是可以互换的。

Android系统的架构与应用开发技术随着智能手机的日益普及，Android作为最为流行的手机操作系统之一，已经成为了很多人在日常生活中不可或缺的工具。

而对于程序员们来说，了解Android的架构和开发技术更是必不可少的。

本文将详细介绍Android的架构和应用开发技术。

一、Android系统的架构Android是以Linux内核为基础的开源移动操作系统，由Google主导开发，它的架构主要由四个部分组成：应用层、应用框架层、系统运行库层和Linux内核层。

1. 应用层应用层是Android中最上层的部分，它包含所有用户直接和操作系统打交道的应用程序，如浏览器、音乐播放器、短信应用、邮件应用等。

这些应用程序使用了Android提供的各种API，如图形用户界面（GUI）、电话服务、短信服务等。

2. 应用框架层应用框架层包含了Android提供的各种各样的服务和API。

应用程序可以通过这些服务和API，来实现与其他应用程序的交互、访问系统资源和网络等。

这一层为应用程序提供了很多基础设施，如界面框架、管理应用程序、位置管理、通知管理等。

3. 系统运行库层系统运行库层包括了Android提供的一系列C/C++库，用于应用程序和系统级进程间的交互。

这些库包括许多不同的组件，如SQLite数据库、SSL、OpenGL等。

4. Linux内核层Linux内核层负责处理底层硬件接口和设备驱动程序。

Android系统的内核层实现了Linux内核的各种功能，如进程管理、内存管理、文件系统管理和网络管理等。

二、Android应用开发技术1. Java语言和XMLAndroid应用开发使用的是Java语言和XML（标准通用标记语言）。

Java是一种面向对象的编程语言，常用于开发Android应用，XML则用于应用程序中定义布局、动作和关键字。

2. Android SDKAndroid SDK（Software Development Kit）是一个包含各种开发工具的软件包，供开发者使用。

毕业设计（论文）外文文献翻译文献、资料中文题目：通过开发Android平台上的社交应用和游戏应用来比较学习软件体系结构文献、资料英文题目：文献、资料来源：文献、资料发表（出版）日期：院（部）：专业：班级：姓名：学号：指导教师：翻译日期： 2017.02.14通过开发Android平台上的社交应用和游戏应用来比较学习软件体系结构1.引言电脑游戏和视频游戏非常受儿童和青少年的欢迎，在年轻人的文化发挥了突出的作用[1]。

现在游戏可以在技术丰富的配备了笔记本电脑，智能手机，游戏机（移动和固定），机顶盒，和其他数字设备的环境中运行。

从这一现象，人们相信将年轻人对游戏的内在动机与教育内容和目标结合就会变成Prensky称之为“以数字游戏为基础的学习”的学习方法[2]。

青年学生生活的游戏中除了丰富的外观，游戏开发技术已经成熟，并且越来越先进[3]。

基于现有的各种游戏开发环境，游戏开发过程中的全部责任可以分为几个的专家领域和角色，如游戏程序员，3D模型的创造者，游戏设计师，音乐家，漫画家，剧作家，等等。

游戏内容与技术相结合的过程可以通过游戏引擎和使用网络上的各种用户和专家社区的可用信息得到简化。

例如，微软的XNA 游戏开发工具包提供的游戏循环函数绘制及更新游戏内容，而且还提供了方便的游戏开发组件来加载不同格式的图形，音频和视频。

这使得游戏迷们如无论有没有编程背景的学生修改现有的游戏或开发新游戏。

他们可以用这些游戏创作工具实现自己的游戏概念设计，学习发展技能和相关知识，积累相关的实际经验。

在这种情况下，不但游戏可以用于学习而且通过激发任务机制，游戏开发工具可以用来研究计算机科学（CS），软件工程（SE），和游戏编程相关主题。

一般来说，游戏可以用三种方式集成在教育中[4,5]。

首先，游戏可以用来代替传统的练习，鼓励学生把额外的努力用来做练习，给老师或助教一个实时地监控学生是如何练习的机会[6，7]。

第二，游戏可以作为一个讲座的一部分来促进学生的参与，增加学生的动力[8,9]。

International Journal of Computer Networks & Communications (IJCNC) Vol.6, No.1, January 2014基于Android应用的无处不在的智能家居系统Shiu KumarDepartment of Information Electronics Engineering, Mokpo National University,534-729, Mokpo, South Korea摘要本文提出了一种灵活独立的，低成本的智能家居系统，它是基于Android应用与微web服务器通信，不仅仅提供交换功能。

Arduino以太网的使用是为了避免使用个人电脑从而保证整个系统成本最低，语音激活时用来实现切换功能的。

光开关，电源插头，温度传感器，湿度传感器，电流传感器，入侵检测传感器，烟雾/气体传感器和警报器等这些设备集成在系统中，表明了所提出的智能家居系统的有效性和可行性。

经过检测，智能家居应用程序可以成功地进行智能家居操作，例如开关功能，自动环境监测，和入侵监测，在监测到有不法入侵后，系统会自动发送一个邮件，并响警笛。

关键字：Android智能手机，智能家居，物联网（loTs），远程控制1.引言随着移动设备受欢迎程度的不断增长和人们日常生活中对无处不在的先进的移动应用的功能需求不断增加，利用Web服务是提供远程访问服务的最开放和可互操作的方式，并且使应用程序能够彼此通信。

一个有吸引力的市场产品自动化和网络化是忙碌的家庭和有生理缺陷的个人的代表。

loTs可以被描述为连接智能手机，网络电视，传感器等到互联网，实现人们之间沟通的新形势。

过去几年中loTs的发展，创造了一个新层面的世界。

这使得人们可以在任何时间，任何地点，联通任何期望的东西。

物联网技术可用于为智能家居创建新的概念和广阔的空间，以提供智能，舒适的发展空间和完善生活质量。

Android Application Architectureauthor：Lars V ogel1、AndroidManifest.xmlThe components and settings of an Android application are described in the file AndroidManifest.xml. For example all Activities and Services of the application must be declared in this file.It must also contain the required permissions for the application. For example if the application requires network access it must be specified here.<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="/apk/res/android"package="de.vogella.android.temperature"android:versionCode="1"android:versionName="1.0"><application android:icon="@drawable/icon"android:label="@string/app_name"><activity android:name=".Convert"android:label="@string/app_name"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /></intent-filter></activity></application><uses-sdk android:minSdkVersion="9" /></manifest>The package attribute defines the base package for the Java objects referred to in this file. If a Java object lies within a different package, it must be declared with thefull qualified package name.Google Play requires that every Android application uses its own unique package. Therefore it is a good habit to use your reverse domain name as package name. This will avoid collisions with other Android applications.android:versionName and android:versionCode specify the version of your application. versionName is what the user sees and can be any String.versionCode must be an integer. The Android Market determine based on the versionCode, if it should perform an update of the applications for the existing installations. You typically start with "1" and increase this value by one, if you roll-out a new version of your application.The tag <activity> defines an Activity, in this example pointing to the Convert class in the de.vogella.android.temperature package. An intent filter is registered for this class which defines that this Activity is started once the application starts (action android:name="android.intent.action.MAIN"). The category definition category android:name="UNCHER" defines that this application is added to the application directory on the Android device.The @string/app_name value refers to resource files which contain the actual value of the application name. The usage of resource file makes it easy to provide different resources, e.g. strings, colors, icons, for different devices and makes it easy to translate applications.The "uses-sdk" part of the "AndroidManifest.xml" file defines the minimal SDK version for which your application is valid. This will prevent your application being installed on devices with older SDK versions.2、R.java and ResourcesThe " gen " directory in an Android project contains generated values. R.java is a generated class which contains references to certain resources of the project.These resources must be defined in the "res" directory and can be XML files, icons or pictures. You can for example define values, menus, layouts or animations via XML files.If you create a new resource, the corresponding reference is automatically created in R.java via the Eclipse ADT tools. These references are static int values and defineID's for the resources.The Android system provides methods to access the corresponding resource via these ID's.For example to access a String with the R.string.yourString ID, you would use the getString(R.string.yourString)) method.R.java is automatically created by the Eclipse development environment, manual changes are not necessary and will be overridden by the tooling.3、AssetsWhile the res directory contains structured values which are known to the Android platform, the assets directory can be used to store any kind of data. You access this data via the AssetsManager which you can access the getAssets() method.AssetsManager allows to read an assets as InputStream with the open() method.// Get the AssetManagerAssetManager manager = getAssets();// Read a Bitmap from Assetstry {InputStream open = manager.open("logo.png");Bitmap bitmap = BitmapFactory.decodeStream(open);// Assign the bitmap to an ImageView in this layoutImageView view = (ImageView) findViewById(R.id.imageView1);view.setImageBitmap(bitmap);} catch (IOException e) {e.printStackTrace();}4、Activities and LayoutsThe user interface for Activities is defined via layouts. The layout defines the included Views (widgets) and their properties.A layout can be defined via Java code or via XML. In most cases the layout is defined as an XML file.XML based layouts are defined via a resource file in the /res/layout folder. This file specifies the ViewGroups, Views, their relationship and their attributes forthis specific layout.If a View needs to be accessed via Java code, you have to give the View a unique ID via the android:id attribute. To assign a new ID to a View use @+id/yourvalue. The following shows an example in which a Button gets the "button1" ID assigned.<Buttonandroid:id="@+id/button1"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="Show Preferences" ></Button>By conversion this will create and assign a new yourvalue ID to the corresponding View. In your Java code you can later access a View via the method findViewById(R.id.yourvalue).Defining layouts via XML is usually the preferred way as this separates the programming logic from the layout definition. It also allows the definition of different layouts for different devices. You can also mix both approaches.5、Reference to resources in XML filesIn your XML files, for example your layout files, you can refer to other resources via the @ sign.For example, if you want to refer to a color which is defined in a XML resource, you can refer to it via @color/your_id. Or if you defined a "hello" string in an XML resource, you could access it via @string/hello.6、Activities and LifecycleThe Android system controls the lifecycle of your application. At any time the Android system may stop or destroy your application, e.g. because of an incoming call. The Android system defines a lifecycle for Activities via predefined methods. The most important methods are:onSaveInstanceState() - called if the Activity is stopped. Used to save data so that the Activity can restore its states if re-startedonPause() - always called if the Activity ends, can be used to release resource orsave dataonResume() - called if the Activity is re-started, can be used to initialize fields7、Configuration ChangeAn Activity will also be restarted, if a so called "configuration change" happens.A configuration change happens if an event is triggered which may be relevant for the application. For example if the user changes the orientation of the device (vertically or horizontally). Android assumes that an Activity might want to use different resources for these orientations and restarts the Activity.In the emulator you can simulate the change of the orientation via CNTR+F11.You can avoid a restart of your application for certain configuration changes via the configChanges attribute on your Activity definition in your AndroidManifest.xml. The following Activity will not be restarted in case of orientation changes or position of the physical keyboard (hidden / visible).<activity android:name=".ProgressTestActivity"android:label="@string/app_name"android:configChanges="orientation|keyboardHidden|keyboard"> </activity>8、ContextThe class android.content.Context provides the connections to the Android system. It is the interface to global information about the application environment. Context also provides access to Android Services, e.g. the Location Service. Activities and Services extend the Context class and can therefore be used as Context.Android应用架构作者：Lars Vogel(拉尔斯·沃格尔)1、AndroidManifest.xml一个Android应用程序的组件和设置描述文件中的AndroidManifest.xml。

Android开发之Android体系架构介绍在Android中，整个框架由应用、应用框架、原生库、Android实时库、硬件抽象层、Linux内核等若干部分组成。

其中最核心的Android虚拟机部分也已经开放源码。

对开发者而言，如果期望在深度定制的基础上开发出差异化、高度竞争力的产品，需要在应用框架、原生库、硬件抽象层、Linux内核等方面有较深入的理解。

图1显示了Android的体系架构。

图1 Android体系架构1 核心服务所谓Android的核心服务主要包括熵服务（Entropy Service）、电源管理器（Power Manager）、Activity管理器（Activity Manager）、通话寄存器（Telephony Registry）、包管理器（Package Manager）、账户管理器（Account Manager）、内容管理器（Content Manager）、内容提供器（System Content Providers）、电池服务（Battery Service）、光线服务（Lights Service）、振动服务（Vibrator Service）、闹钟管理器（Alarm Manager）、看门狗（Init Watchdog）、窗口管理器（Window Manager）、蓝牙服务（Bluetooth Service）等。

这些服务和应用程序密切相关，但通常应用程序不能直接接入核心服务。

早期版本中的硬件服务（Hardware Service）和传感器服务（Sensor Service）已经被移除，光线服务和振动服务在核心服务通过系统服务器来启动。

系统服务器的实现位于SystemServer.java中。

2 原生服务在Android中，上层的应用是基于Java开发的，但是框架层的服务很多是基于C/C++的，为了说明的方便，在本书中，将基于C/C++的服务称为原生服务。

软考系统架构设计师易错知识点（三）1、系统架构设计知识点软件架构设计是降低成本、改进质量、按时和按需交付产品的关键因素。

软件架构设计能够满足系统的性能、安全性、可维护性等品质；软件架构设计能够帮助项目干系人(Stakeholder)更好地理解软件结构；软件架构设计能够有效地管理系统的复杂性，并降低系统维护费用；软件架构设计对系统开发具有指导性；软件架构设计为系统复用奠定的基础；软件架构设计能够支持冲突分析。

需要注意的是，软件架构设计与系统需求是直交的，两者并无必然联系。

2、英语翻译（软件架构知识点）Software architecture reconstruction is an interpretive,interactive,and iterative process includingmany rmation extraction involves analyzing a system's existing design and implementation artifacts to construct a model of it.The result is used inthe following activities to construct a view of thesystem.The database construction activity converts the Element and relation contained in the view into a standard format for storage in a database.The View fusion activityinvolves defining and manipulating the information stored in database toreconcile,augment,andestablish connections between the elements.Reconstruction consists of two primary activities:visualization and interaction.The former provides a mechanism for the user to manipulate architectural elements,and the latter provides facilities for architecture reconstruction.软件体系结构重构是一种解释性的、交互式的、迭代的过程，包括许多活动。

安卓的四大框架xx年xx月xx日CATALOGUE目录•安卓简介•安卓的四大框架概述•活动（Activity）•服务（Service）•广播接收器（Broadcast Receiver）•内容提供者（Content Provider）01安卓简介安卓是一种基于Linux的开放源代码移动设备操作系统。

它主要用于智能手机、平板电脑等移动设备。

安卓系统由谷歌公司进行维护和更新，全球市场份额位居首位。

安卓的定义安卓的发展史2003年，Andy Rubin创立安卓公司。

2007年，安卓开发者使用安卓开源项目发布了第一个操作系统。

2005年，谷歌收购安卓公司并将其作为开源项目。

2011年，安卓市场份额超过塞班成为全球第一大智能手机操作系统。

安卓系统的特点安卓系统是开放源代码的，这使得开发者可以自由地访问源代码并自由地使用、修改和分发它。

开放源代码免费和开源定制性高支持各种设备安卓系统是免费的，并且它的源代码可以被任何一个人查看、使用、修改和分发。

安卓系统允许用户和开发者高度定制手机，可以随意更换操作系统组件和应用程序。

安卓系统支持各种设备，包括智能手机、平板电脑、智能手表、电视盒子等。

02安卓的四大框架概述活动（Activity）它是一个应用程序当前所执行的操作，并且是应用程序中最重要的组件之一。

活动是用户界面的基础，是应用程序与用户进行交互的组件。

活动保存了应用程序的状态，并且提供了应用程序与用户交互的接口。

服务（Service）服务是在后台运行且不与用户界面交互的组件。

它可以在用户界面和后台任务之间提供一个桥梁，使应用程序可以在后台执行长时间运行的操作，而无需与用户界面进行交互。

服务可以在应用程序的任何地方使用，并且可以在任何时候启动和停止。

广播接收器（Broadcast Receiver）广播接收器是一个用于接收来自系统或其他应用程序的广播消息的组件。

它可以在应用程序不活动时接收广播，然后在接收到广播时执行相应的操作。

基本框架设计模式Essential Framework DesignPatternsWolfgang PreeUniversity of ConstanceD-78434 Constance, GermanyVoice: +49.7531.88.44.33; Fax: +49.7531.88.35.77E-mail: pree@informatik.uni-konstanz.de摘要大多数优秀的面向对象的框架仍然或多或少的处于混乱发展过程中，通常进行的类似设置的研究。

这种贡献首先涉及几点框架建设的基本原则。

框架代表的是特定域的通用解决方案，使面向对象软件配置的全部潜力得以开发:不仅源代码和单个组件，体系结构设计也被重复使用。

预定义细化发生的适应点我们称之为扩展点。

如果发现这些扩展点有明确的需求阶段，它们能以基本的形式组合成特定域的设计模式。

这种扩展点驱动的框架设计可以为一个更系统的发展过程做出贡献。

关键词：设计模式，框架，面向对象设计，面向对象软件发展，软件可重用性1.框架类型框架非常适合大量类似的应用程序的重写。

框架结构定义了一种通过创建特定领域的应用程序的高级语言专业化（=适应）。

特定领域的一种扩展槽我们称之为扩展点。

如果一个框架提供了足够的可以改编的扩展点，我们就认为这是一个具备合格属性的框架。

例如，Lewis et al. (1995 年) 提供大量高质量框架。

白盒框架中的扩展点白盒框架由几个不完整的类组成，也就是类包含没有实际实现的办法。

A类的抽象方法必须在子类中重写。

这种类型的框架中的抽象方法形成扩展点。

图1 的示例框架中描述的A 类层次结构说明了一个白盒框架的这一特性。

A类的抽象方法必须在子类中重写。

这种类型的框架中的抽象方法形成扩展点。

图1 示例框架类层次结构程序员通过衍生子类或重写父类的成员方法来修改白盒框架的方法。

必须重写的方法意味着程序员必须在一定程度上了解框架的设计和实施的细节信息。

Android体系架构APPLICATIONS——应用程序层：Android发布时自身包含的一些基础应用程序，包括Email 客户端，SMS短消息程序，日历，地图，浏览器，联系人管理程序等。

开发者独立开发的应用程序也包含在这一层当中，所有应用程序都使用Java语言编写。

APPLICATION FRAMEWORK——应用程序框架层：Android的应用程序编程接口（API），一系列的基础组件，其中包括：●View System:丰富且可扩展的视图组件，用来构建应用程序的界面，包括列表（lists），网格(grids)，文本框(textboxs)，按钮(buttons)，甚至可嵌入web浏览器。

●Content Providers:内容提供器，使得应用程序可以访问另一个应用程序的数据(例如联系人数据库)，或者共享自己的数据。

●Resource Manager:资源管理器，提供非代码资源的访问，例如本地字符串，图形，和布局文件(layout files)。

●Notification Manager:通知管理器，使得应用程序可以在状态栏中显示自定义的提示信息。

●Activity Manager:活动管理器，用来管理应用程序的生命周期并提供常用的导航回退功能。

LIBRARIES——程序库：底层的核心程序库，这些程序被APPLICATION FRAMEWORK层中的不同组件所使用，APPLICATION FRAMEWORK层是对这些程序库的面向对象封装。

这些程序库通过APPLICATION FRAMEWORK层为开发者提供服务。

包括以下核心库：●Libc：系统C库，一个从BSD继承来的标准C系统函数库，它是专门为基于embeddedlinux的设备定制的。

●Media Framework：媒体库，基于PacketVideo OpenCORE；该库支持多种常用的音频，视频格式回放和录制，同时支持静态图像文件。

英文资料翻译****：******：***2015年06月XMPP协议1绪论1.1概述可扩展的消息和出席信息协议(XMPP)是一个可扩展标记语言XML应用，让任何两个或多个网络实体之间进行结构化和可扩展的准实时信息交流. 本文定义了XMPP的核心协议方法: XML流的配置和解除, 通道加密, 验证, 错误处理, 以及消息通讯基础, 网络可用性("presence"), 和请求-应答交互.1.2历史XMPP的基本语法和语义最开始是由Jabber开源社区开发的, 主要是在1999年. 2002年, 根据IMP-REQS ，XMPP工作组被允许基于Jabber协议开发一个适合IETF的即时消息和出席信息技术. 到了2004年10月, 发布了RFC3920 和RFC3921 , 意味着那时候XMPP的主要定义完成了.从2004年开始，互联网社区已经获得了广泛的XMPP实现和布署经验, 包括XMPP标准基金会(XSF)主持下开展的正式的互操作性测试. 本文全面整合了从软件开发者和XMPP服务提供者得到的反馈, 包含了一系列向后兼容的修改，见附录D . 结果是, 本文反映了互联网社区对于XMPP1.0核心功能的初步共识, 因此废止了RFC 3920.1.3功能汇总这个不规范的章节提供了一个方便开发者的XMPP功能汇总; 接下来的其他章节则是XMPP的规范定义.XMPP的目标是允许两个(或多个)实体通过网络来交换相关的小件结构化数据(所谓"XML节"). XMPP典型地使用分布式的客户端-服务器体系结构来实现, 这里客户端需要连接到一个服务器以获得对网络的访问，从而被允许和其他实体(可能在其他服务器上)交换XML节. 一个客户端连接到一个服务器，交换XML 节，以及结束连接，这样的流程如下:确定要连接的IP地址和端口号, 典型的做法是对一个合格的域名做出解析( 3.2 )打开一个传输控制协议TCP 连接通过TCP打开一个XML流 4.2握手最好使用传输层安全性TLS 来进行通道加密( 5 )使用简单验证和安全层SASL 机制来验证( 6 )绑定一个资源到这个流上( 7 )和其他网络上的实体交换不限数量的XML节( 8 )关闭XML流( 4.4 )关闭TCP连接在XMPP中, 一个服务器可以选择性地连接到另一个服务器以激活域间或服务器间的通讯. 这种情形下, 两个服务器需要在他们自身之间建立一个连接然后交换XML节; 这个过程所做的事情如下:1.确定要连接的IP地址和端口号, 典型的做法是对一个合格的域名做出解析( 3.2 )2.打开一个TCP连接3.打开一个XML流4.24.握手最好使用TLS来进行通道加密( 5 )5.使用简单验证和安全层SASL 机制来验证( 6 ) *6.交换不限数量的XML节，可以服务器之间直接交换，也可以代表每台服务器上的相关实体来交换，例如那些连到服务器上的客户端( 8 )7.关闭XML流( 4.4 )8.关闭TCP连接互操作性提示: 在本文写就的时候, 大多数已布署的服务器仍使用服务器回拨协议XEP-0220 来提供弱身份验证，而不是使用SASL的PKIX证书来提供强验证, 特别在这些情况下，SASL握手无论如何将不会得到强验证(例如, 因为TLS握手没有被对方服务器强制要求, 或因为当TLS握手时对方服务器提供的PKIX证书是自签名的并且之前没有被接受过); 细节请见XEP-0220 . 本文的解决方案显然提供了一个更高级别的安全性(参见13.6 ).本文指定了客户端如何连接到服务器以及基本的XML节语义. 然而, 本文不定义一个连接成功建立之后可能用来交换的XML节的"载荷"; 反之, 那些载荷被定义在各种XMPP扩展之中. 例如, XMPP-IM 定义了基本的即时消息和出席信息功能的扩展. 另外, XSF创造了各种扩展协议，即XEP系列XEP-0001 ,也为广泛的应用程序定义了扩展.1.4术语本文中的关键字"MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", 和"OPTIONAL" 的解释参见RFC 2119 关键字.特定的安全相关的术语的含义参见安全术语 ; 这些术语包括但不限于, "assurance", "attack", "authentication", "authorization", "certificate", "certification authority", "certification path", "confidentiality", "credential", "downgrade", "encryption", "hash value", "identity", "integrity", "signature", "self-signed certificate", "sign", "spoof", "tamper", "trust", "trust anchor", "validate", and "verify".特定的和证书，域名，应用服务身份相关的术语参见TLS-证书 ; 这包括但不限于, "PKIX certificate", "source domain", "derived domain", 以及身份类型"CN-ID", "DNS-ID", 和"SRV-ID".其他安全相关的术语定义于参考协议中(例如, "denial of service" (拒绝服务)定义于DOS 或"end entity certificate" (终端实体证书)定义于PKIX ).术语"whitespace" (空格) 用于指代XML 中任何匹配"S"的字符或字符串, 也就是说, 一个或多个满足ABNF 定义的SP, HTAB, CR, 或LF 规则的实例.术语"localpart" (本地部分), "domainpart" (域部分), 以及"resourcepart" (资源部分)定义于XMPP地址.术语"bare JID" (纯JID) 指代一个格式为<localpart@domainpart> (对于一个位于某个服务器上的帐户而言) 或<domainpart> (对于一个服务器而言) 的XMPP地址.术语"full JID" (全JID) 指代一个格式为<localpart@domainpart/resourcepart> (对一个典型的已授权客户端或和某个帐号相关的设备而言) 或<domainpart/resourcepart> (对于一个典型的资源或和某个服务器相关的文字)的XMPP地址.术语"XML stream" (也称为"stream" (流)) 定义于 4.1 .术语"XML stanza" (也称为"stanza" (节)) 定义于 4.1 . 有三种stanzas（节）: message, presence, 和IQ ("Info/Query"的简称). 这些通讯原语分别定义于8.2.1 , 8.2.2 , 和8.2.3 .术语"originating entity" (原实体)指的是第一次生成一个发送到XMPP网络的stanza(节)的实体(例如, 一个已连接的客户端, 一个附加的服务, 或一个服务器). 术语"generated stanza" (生成的节)值的是生成的节那个节.术语"input stream" (输入流)指定这样一个XML流，服务器通过这个流从一个已连接的客户端或远端服务器接收数据, 而术语"output stream" (输出流)指定这样一个流，服务器通过这个流发送数据到一个已连接的客户端或远程服务器. 以下术语指定一些动作，处理从输入流收到的数据时服务器可以执行这些动作: route(路由):传递数据到一个远端服务器让它自行处理或最终递送到一个和远端服务器关联的客户端deliver(递送):传递数据到一个已连接的客户端ignore(忽略):丢弃数据不做任何处理或返回一个错误给发送者sender 当术语"ignore" (忽略)用于客户端处理收到的数据时, 短语"without acting upon it" (不做任何处理)明确的包括不展示任何数据给使用者(人).接下来的"XML符号" 被IRI 用于展示无法用仅用ASCII码呈现的字符, 本文的一些例子使用了类似"&#x...." 的格式来表现UNICODE 字符串(例如, 字符串"ř" 表示Unicode字符LATIN SMALL LETTER R WITH CARON); 这种形式是绝对不会在XMPP系统将通过网络发送的.和URI 展现统一资源定位符的规则一样, XMPP地址文本也是用'<' 和'>' 括起来的(尽管基本上它们不属于URIs).例如, 被括起来的行是用来提高可读性的, "[...]" 表示省略, 并且还是用了以下预定义字符串(这些预定义的字符串不会通过网络发送出去):∙C: = 客户端∙E: = 任何XMPP实体∙I: = 发起实体∙P: = 对端服务器∙R: = 接收实体∙S: = 服务器∙S1: = 服务器1∙S2: = 服务器2读者需要注意这些例子不包括细节, 并且例子里的一些协议流程中, 展示的备用步骤不一定是由前一个步骤发送的确切的数据触发的; 本文或常用参考文档中的协议规范所用到的所有用例里面提供的例子都遵从上述规则. 所有例子都是虚构的并且交换的信息(例如, 用户名和密码) 不代表任何现存的用户和服务器.2体系结构XMPP提供一种异步的端到端的结构化数据交换技术，在一个分布式的可全球寻址和出席信息感知的客户端和服务器的网络中使用直接的持久XML流。

附录二外文文献（原文）The basic of description of android system The mainstream of the next generation of open operating systems will not be on the desktop, but will appear in the phone that we carry every day. Open environment will lead these new applications may be integrated into these online services that already exist, of course, as with growing data services on mobile phones support the security flaws on the phone is also becoming increasingly clear. The nature of the next-generation operating system, whether to provide a complete integrated security platform.By the Open Mobile Alliance (open Handset Alliance led by Google) developed the android system is a widely optimistic about an open source phone system, the system provides a basic operating system, a middle ware application layer, a java development tools and a system Application collector (collection of system applications). The android the SDK since 2007 on the release of the first android phone in October 2008 before the birth. Google opened since then on his own time, Taiwan's HTC, the manufacturer of the T-Mobile G1 estimate G1 shipments have more than one million at the end of 2008. According to industry insiders expect the G1 mobile phone sales in 2009 continue. Many other mobile phone suppliers in the near future plans to support this system.Around an android and a huge developer community has been established, while a lot of new products and applications on the android. Android's main selling point is that it enables developers to seamlessly expand online services to mobile phones. This is the most obvious example is Google's tightly integrated with Gmail, Calendar and Contacts Web applications through the system. Users only need to provide an android user name and password, the phone automatically sync with Google services. The other vendors are quickly adapt their existing instant messaging, social networking and gaming services. Android and many companies find new ways to integrate their existing business to the android.Traditional desktop and server operating system has been working for the integration of security features. These individuals and business applications on a single platform is very good, however a business phone platform like android is not very useful. It gives the hope of many researchers. Android is not parked in the body for other platform application support: the implementation of the application depends on a top-level JA V A middle ware, the middle ware running on the embedded Linux kernel. Therefore, developers should deploy their applications to the Android mustuse a custom user interface environment.In addition, the android system applications limit the application to call each other API collaboration, and the other to authenticate the user application. Although these applications have certain safety features, some of our experienced developers to create Android applications who revealed that the design of security applications is not always straight forward. Android uses a simple permission label distribution mode to restrict access to resources, but the reasons for the necessity and convenience of other applications, the designers have increased the confusion on this system. This paper attempts to explain the complexity of the Android security, and pay attention to some of the possible development defects and application security. We try to draw some lessons learned, and hope that the safety of the future.Android application framework for developers is a mandatory framework. It does not have a main () function function or a single entry point for the implementation of the contrary, the developer must in the design of application components. We developed applications to help the API of the android sdkThe Android system defines four kinds of component type.Activity component that defines the application user interface. Usually, the application developer defines each activity screen. Activity can start, it may pass and return values. Can be handled at a time only a keyboard system Activity, all other Activity will be suspended at this time.Service components perform background processing. The need for some operations when an activity, after the disappearance of the user interface (such as downloading a file or playing music), it usually take such action specially designed services. Developers can also use a special daemon at system startup, the service is usually defined a remote procedure call (RPC), and other system components can be used to send the interface command and retrieve data, as well as to register a callback function.ContentProvider component storage and share data with relational database interfaces. Each Content supplier has an associated "rights" to describe its contents contains. Other components when used as a handle to execute SQL queries (eg SELECT, INSERT, or DELETE content. Content suppliers are typically stored the values on the database records, data retrieval is a special case, the file is also shared by the content provider interface.The components of the broadcast receiver as to send a message from the mailbox to the application. Typically, the broadcast message, the application code implicit destination. Therefore, the radio receiver subscribe to these destinations receive messages sent to it. The application code can also be solved explicitly broadcast receivers, including the name space allocation.The main mechanism of the interaction of the components of the Component Interaction, is an intent, which is a simple message object, which contains a destination address and data components. The Android API defines his approach into intent, and use that information to initiate an activity such as start an activity (startActivity (An intent)) start services (the startService (An intent)) and radio (sendBroadcast (An intent)). Android framework to inform the calls to these methods began to perform in the target application code. This process, the internal components of communication is called an action. Simply put, the Intent object defined in the "Intent to implement the" action ". One of the most powerful features of the Android is allowed a variety of intent addressing mechanism. The developer can solve the space of a target component using its applications, they can also specify an implicit name. In the latter case, the system determines the best components of an action by considering the installed applications and user choice.Implicit name is called the action string because of his special type of the requested action. Such as a view action string, in an intent data field points to an image file, the system will directly referring to the preferred image viewer.Developers can also use the action string a large number of radio to send and receive. Receiver at the receiving end, the developers use an intent filter to customize the special action string. Android Department, including the additional goal of the resolution rules, but an optional string type of data manipulation is the most common.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 apt 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's the file users download to their devices.All the code in a single.apk file is considered to be one application.In many ways,each Android application lives in its own world:（1）By default,every application runs in its own Linux process.Android starts the process when any of the application's code needs to be executed,and shuts down the process when it's no longer needed and system resources are required by otherapplications.（2）Each process has its own virtual machine(VM),so application code runs in isolation from the code of all other applications.（3）By default,each application is assigned a unique Linux user ID.Permissions are set so that the application's files are visible only to that user and only to the application itself —altough there are ways to export them to other applications as well.It's possible to arrange for two applications to share the same user ID,in while case they will be able to see each other's files.To conserve system resources,applications with the same ID can also arrange to run in the same Linux process,sharing the same VM.Application ComponentsA central feature of Android is that one application can make use of elements of other application (provided those application permit it).For example,if your application needs to display a scrolling list of images and another application has developed a suitable scroller and made it available to others,you can call upon that scroller to do the work,rather than develop your own.Your application doesn't incorporate the code of the other application or link to it.Rather,it simply starts up that piece of the other application when the need arises.For this to work,the system must be able to start an application process when any part of it is needed,and instantiate the Java objects for that part.Therefore,unlike applications on most other systems,Android applications don't have a single entry point for everything in the application(no main()function,for example).Rather,they have essential components that the system can instantiate and run as needed.There are four types of components:ActivitiesAn activity presents a visual user interface for one focused endeavor the user can undertake.For example,an activity might present a list of menu items users can choose from or it might display photographs along with their captions.A text messaging application might have one activity that shows a list of contacts to send messages to,a second activity to write the message to the chosen contact,and other activities to review old messages or change or change settings.Tough they work together to form a cohesive user interface,each activity is independent of the others.Each one is implemented as a subclass of the Activity base class.An application might consist of just one activity or,like the text messaging application just mentioned,it may contain several.What the activities are,and how many there are depends,of course,on the application and its design.Typically,one of the activities is marked as the first one that should be presented to the user when the application is launched.Moving from one activity to another is accomplished by having the current activity start the next one.Each activity is given a default window to draw in.Typically,the window fills the screen,but it might be smaller than the screen and float on top of other windows.An activity can also make use of additional windows —for example,a pop-up dialog that calls for a user response in the midst of the activity,or a window that presents users with vital information when they select a particular item on-screen.The visual content of the window is provided by a hierarchy of views —objects derived from the base View class.Each view controls a particular rectangular space within the window.Parent views contain and organize the layout of their children.Leaf views(those at the bottom of the hierarchy)draw in the rectangles they control and respond to user actions directed at that space.Thus,views are where the activity's interaction with the user takes place.For example,a view might display a small image and initiate an action when the user taps that image.Android has a number of ready-made views that you can use —including buttons,text fields,scroll bars,menu items,check boxes,and more.A view hierarchy is placed within an activity's window by the Activity.setContentView()method.The content view is the View object at the root of the hierarchy.(See the separate User Interface document for more information on views and the hierarchy.)ServicesA service doesn't have a visual user interface,but rather runs in the background for an indefinite period of time.For example,a service might play background music as the user attends to other matters,or it might fetch data over the network or calculate something and provide the result to activities that need it.Each service extends the Service base class.A prime example is a media player songs from a play list.The player application would probably have one or more activities that allow the user to choose songs and start playing them.However,the music playback itself would bot be handled by an activity because users will expect the music to keep the music going,the media player activity could start a service to run in the background.The system would then keep themusic playback service running even after the activity that started it leaves the screen.It's possible to connect to (bind to)an ongoing service(and start the service if it's not already running).While connected,you can communicate with the service through an interface that the service exposes.For the music service,this interface might allow users to pause,rewind,stop,and restart the playback.Like activities and the other components,services run in the main thread of the application process.So that they won't block other components or the user interface,they often spawn another thread for time-consuming tasks(like music playback).See Processes and Thread,later.Broadcast receiversA broadcast receiver is a component that does nothing but receive and react to broadcast announcements.Many broadcasts originate in system code —for example,announcements that the timezone has changed,that the battery is low,that a picture has been taken,or that the user changed a language preference.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.An application can have any number of broadcast receivers to respond to respond to respond to any announcements it considers important.All receivers extend the BroadcastReceiver base class.Broadcast receivers do not display a user interface.However,they may start an activity in response to the information they receive,or they may use the NotificationManager to alert the user.Notifications can get the user's attention in various ways —flashing the backlight,vibrating the device,playing a sound,and so on,They typically place a persistent icon in the status bar,which users can open to get the message.Content providersA content provider makes a specific set of the application's data available to other applications.The data can be stored in the file system,in an SQLite database,or in any other manner that makes sense.The content provider extends the ContentProvider base class to implement a standard set of methods that enable other applications to retrieve and store data of the type it controls.However,applications do not call these methods directly.Rather they use a ContentResolver object and call its methods instead.A ContentResolver can talk to any content provider;it cooperates with the provider to manage any interprocess communication that's involved.See the separate Content Providers document for more information on using content providers.Whenever there's a request that should be handled by a particular component,Android makes sure that the application process of the component is running,starting it if necessary,and that an appropriate instance of the component is available,creating the instance if necessary.Activating components:intentsContent providers are activated when they're targeted by a request from a ContentResolver.The other three components —activities,services,and broadcast receivers —are activated by asynchronous messages called intents.An intent is an Intent object that holds the content of the message.For activities and services,it names the action being requested and specifies the URI of the data to act on,among other things.For example,it might convey a request for an activity to present an image t the user or let the user edit some text.For broadcast receivers,the Intent object names the action being announced.For example,it might announce to interested parties that the camera button has been pressed.There are separate methods for activating each type of component:1.An activity is launched(or given something new to do)by passing an Intent object to Context.startActivity() or Activity.startActivityForResult().The responding activity can look at the initial intent that caused it to be launched by calling its getIntent() method.Android calls the activity's onNewIntent()method to pass it any subsequent intents.One activity often starts the next one.If it expects a result back from the activity it's starting,it calls startActivityForResult() instead of startActivity().For example,if it starts an activity that lets the user pick a photo,it might expect to be returned the chosen photo.The result is returned in an Intent object that's passed to the calling activity's onActivityResult() method.2.A service is started(or new instructions are given to an ongoing service)by passing an Intent object to Context.startService().Android calls the service's onStart() method and passes it the Intent object.Similarly,an intent can be passed to Context.bindService() to establish an ongoing connection between the calling component and a target service.The service receives the Intent object in an onBind() call.(If the service is not already running,bindService() can optionally start it.)For example,an activity might establish a connection with the music playback service mentioned earlier so that it can provide the user with the means(a user interface)for controlling the playback.The activity would call bindService() to set up thatconnection,and then call methods defined by the service to affect the playback.A later section,Remote procedure calls,has more details about binding to a service.3.An application can initiate a broadcast by passing an Intent object to methods like Context.sendStickyBroadcast() in any of their variations.Android delivers the intent to all interested broadcast receivers by calling their onReceive() methods.For more on intent messages,see the separate article,Intents and Intent Filters.Shutting down componentsA content provider is active only while it's responding to a request from a ContentResolver.And a broadcast receiver is active only while it's responding to a broadcast message.So there's no need to explicitly shut down these components.Activities,on the other hand,provide the user interface.They're in a long-running conversation with the user and may remain active,even when idle,as long time.So Android has methods to shut down activities and services in an orderly way:1.An activity can be shut down by calling its finish() method.Onte activity can shut down another activity (one it started with startActivityForResult())by calling finishActivity().2.A service can be stopped by calling its stopSelf() method,or by calling Context.stopService().Components might also be shut down by the system when they are no longer being used or when Android must reclaim memory for more active components.A later section,Component Lifecycles,discusses this possibility and its ramifications in more detail.The manifest fileBefore Android can start an application component,it must learn that the component exists.Therefore,applications declare their components in a manifest file that's bundled into the Android package,the .apk file that also holds the application's code,files, and resources.The manifest is a structured XML file and is always named AndroidManifest.xml for all applications.It does a number of things in addition to declaring the application's components,such as naming any libraries the application needs to be linked against(besides the default Android library)and identifying any permissions the application expects to be granted.But the principal task of the manifest is to inform Android about the application's components.For example,an activity might be declared as follows:The name attribute of the <activity>element names the Activity subclass that implements the activity.The icon and label attributes point to resource files containing an icon and label that can be displayed to users to resource files containing an icon and label that can be displayed to users to represent the activity.The other components are declared in a similar way —<service>elements for services,<receiver>elements for broadcast receivers,and<provider>elements for content providers.Activities,services,and content providers that are not declared in the manifest are not visible to the system and are consequently never run.However,broadcast receivers can either be declared in the manifest,or they can be created dynamically i code (as BroadcastReceiver objects)and registered with the system by calling Context.registerReceiber().For more on how to structure a manifest file for your application,see The Android Manifest.xml File.Intent filtersAn Intent object can explicitly name a target component.If it does,Android finds that component(based on the declarations in the manifest file)and activates it.But if a target is not explicitly named,Android must locate the best component to respond to the intent.It does s by comparing the Intent object to the intent filters of potential targets.A component's intent filters inform Android of the kinds of intents the component is able to handle.Like other essential information about the component,they're declared in the manifest.Here's an extension of the previous example that adds two intent filters to the activity:The first filter in the example —the combination of the action "android.intent.action.MAIN"and the category "UNCHER"—is a common one.It marks the activity as one that should be represented in the application launcher,the screen listing applications users can launch on the device.In other words,the activity is the entry point for the application,the initial one users would see when they choose the application in the launcher.The component can have any number of intent filters,each one declaring a different set of capabilities.If it doesn't have any filters,it can be activated only by intents that explicitly name the component as the target.For a broadcast receiver that's created and registered in code,the intent filter is instantiated directly as an IntentFilter object.All other filters are set up in the manifest.For more on intent filters,see a separate document, Intents and Intent Filters.附录三外文文献（译文）安卓系统的基本描述下一代开放操作系统的主流将不会在桌面上，但是将会出现在我们每天携带的手机上。

android系统架构图及各层介绍此技术⽂档主要是从基础了解系统，便于对以后开发形成⼀些基本应⽤架构。

的系统架构采⽤了分层架构的思想，如图1所⽰。

从上层到底层共包括四层，分别是应⽤程序程序层、应⽤框架层、系统库和Android运⾏时和内核。

图1：Android系统架构图每层功能简要介绍如下：⼀应⽤程序层该层提供⼀些核⼼应⽤程序包，例如电⼦邮件、短信、⽇历、地图、浏览器和联系⼈管理等。

同时，开发者可以利⽤语⾔设计和编写属于⾃⼰的应⽤程序，⽽这些程序与那些核⼼应⽤程序彼此平等、友好共处。

⼆应⽤程序框架层该层是Android应⽤开发的基础，开发⼈员⼤部分情况是在和她打交道。

应⽤程序框架层包括活动管理器、窗⼝管理器、内容提供者、视图系统、包管理器、电话管理器、资源管理器、位置管理器、通知管理器和XMPP服务⼗个部分。

在Android平台上，开发⼈员可以完全访问核⼼应⽤程序所使⽤的API框架。

并且，任何⼀个应⽤程序都可以发布⾃⾝的功能模块，⽽其他应⽤程序则可以使⽤这些已发布的功能模块。

基于这样的重⽤机制，⽤户就可以⽅便地替换平台本⾝的各种应⽤程序组件。

XMPP(（Extensible Messaging and Presence Protocol 可扩展通讯和表⽰协议，前称Jabber）是⼀种以为基础的开放式协议,XMPP⽹络是基于服务器的（即客户端之间彼此不直接交谈），但是也是分散式的。

不像实时通或等服务，XMPP没有中央官⽅服务器。

的公众服务器上有⼤量的⽤户，所以有些⼈误解了，以为它是官⽅服务器，不过事实上任何⼈都可以在⾃⼰的域名上运⾏XMPP服务器。

Jabber识别符（）是⽤户登录时所使⽤的账号，看起来通常像⼀个电⼦邮件地址，如someone@；前半部分为⽤户名，后半部分为XMPP服务器域名，两个字段以符号区隔。

假设朱丽叶（juliet@）想和罗密欧（romeo@montague）通话，他们两⼈的账号分别在及Montague的服务器上。

Android 技术1. Android简介Android是一种以linux为基础的开放源代码操作系统，主要使用于便携设备。

目前尚未有统一中文名称，中国大陆地区较多人使用“安卓”或“安致”。

Android操作系统最初由Andy Rubin开发，最初主要支持手机。

2005年由google收购注资，并组建开放手机联盟开发改良，逐渐扩展到平板电脑及其他领域上。

Android的主要竞争对手是苹果公司的iOS以及RIM的Blackberry OS。

2011年第一季度，Android在全球的市场份额首次超过塞班系统，跃居全球第一。

2012年2月数据，Android占据全球智能手机操作系统市场52.5%的份额，中国市场占有率为68.4%。

Android的系统架构和其它操作系统一样，采用了分层的架构。

android分为四个层，从高层到低层分别是应用程序层、应用程序框架层、系统运行库层和linux 核心层。

Android是以Linux为核心的手机操作平台，作为一款开放式的操作系统，随着Android的快速发展，如今已允许开发者使用多种编程语言来开发Android应用程序，而不再是以前只能使用Java开发Android应用程序的单一局面，因而受到众多开发者的欢迎，成为真正意义上的开放式操作系统。

在Android中，开发者可以使用Java作为编程语言来开发应用程序，也可以通过NDK使用C/C++作为编程语言来开发应用程序，也可使用SL4A来使用其他各种脚本语言进行编程（如：python、lua、tcl、php等等），还有其他诸如：QT （qt for android）、Mono（mono for android）等一些著名编程框架也开始支持Android 编程，甚至通过MonoDroid，开发者还可以使用C#作为编程语言来开发应用程序。

另外，谷歌还在2009年特别发布了针对初学者的Android Simple语言，该语言类似Basic语言。

Android系统外文翻译What is Android?For a while。

nal。

n developers have had the luxury of being able to create almost any kind of n they can XXX。

this is not tosay that nal。

n development is easier than other forms of development。

As someone who got their start in。

programming。

I include myself in this grouping.XXX with the。

operating system and underlying hardware pretty freely。

or XXX。

This kind of freedom to program independently has never really been available to the small group of programmers who XXX.Overall。

Android is a mobile operating system that allows XXX for mobile devices。

It has opened up a whole new world of possibilities for developers who want to create XXX underlying hardware of mobile devices。

With Android。

developers XXX。

from tracking XXX.Cell phone developers used to be a small group XXX。

and web development。

Android体系结构android 平台大的方面的层次可以划分成三个层次，包括一个操作系统，中间件和应用程序，android 的系统框架图如下：图中的软件层次自上而下分成4个层次1.应用程序（Application）2.用用程序框架（Application Framework）3.各种类库（Libraries）和android运行时（Adnorid Runtime）4.操作系统（OS）一.应用程序（Application）应用层是和用户交互的一个层次，用户可以看得见的一些应用，用户可以操作。

这类应用基本都是通过Java语言编写的独立的能够完成某些功能的应用程序。

Android本身提供了桌面（Home），联系人（Contacts），拨打电话（Phone），浏览器(Browers）等很多基本的应用程序。

开发人员可以使用应用框架提供的API编写自己的应用程序，普通开发人员要做的事情就是开应用层的程序提供该广大消费者使用。

二.应用程序框架（Application Framework）普通开发者可以使用Android基本应用程序使用的系统API，android 应用框架中的各个模块都可以被复用，各种服务也可以被复用，理解了这个机制，开发人员可以更好的更轻松的开发出优秀的android应用。

开发过程中常用到的基本框架组件如下：1.一组View（UI 组件），这些UI组件包括Button(按钮），EidtView（文本框），TextView（标签），List（列表）等等，灵活运用这些组件可以快速方便的创建良好的用户交互界面。

2.Content Providers（内容提供者），听起来有点抽象，通俗的理解Content Provider 就是提供一种服务，通过这种服务应用程序之间可以实现数据的互相访问和共享，比如通讯录的存储就使用了这种服务，其它应用也可以访问通讯录中存储的联系人信息。

3.Resource Manager 顾名思义就是资源管理，android中的资源很多包括图片，用户界面（Layoutxml），字体，颜色，UI组件的Id等等都可以称之为资源，这些丰富的资源，都是通过Resource Manager 来统一进行管理。

《自动化技术与应用》2021年第40卷第5期行业应用与交流Industrial Applications and Communications基于安卓手机系统的英语翻译软件设计李娟(陕西财经职业技术学院,陕西咸阳712000)摘要:随着计算机、移动互联网技术的不断发展，安卓手机设备的硬件布局越来越全面，软件资源也越来越丰富，英语翻译软件也得到了广泛的应用。

为了进一步丰富安卓手机英语翻译软件的功能，完善用户体验，本次研究专门设计了一套应用于安卓手机系统的英语翻译系统，并详细阐述了该系统在主要功能上的设计思路。

关键词:翻译软件；安卓手机中图分类号：TP391.2文献标识码:A文章编号:1003-7241(2021)005-0179-04English Translation Software DesignBased on Android Mobile Phone SystemLI Juan(Shaanxi Technical College of Finance and Economics,Xianyang 712000China )Abstract:With the continuous development of computer and mobile Internet technology,the hardware layout of Android mobile de-vices is more and more comprehensive,software resources are more and more abundant,and English translation software is widely used.In order to further enrich the functions of Android mobile English translation software and improve the us-er experience,this study designs a set of English translation system applied to Android mobile phone system,and elabo-rates the design ideas of the system in the main functions.Key words:translation software;Android phone收稿日期:2020-03-201引言安卓手机在国内占有85%以上的市场份额，但大多数安卓手机在数据处理能力方面存在着较大的差异[1]。