Android外文翻译(Android中英文献)
手机系统安卓系统中英文对照外文翻译文献
中英文对照外文翻译文献(文档含英文原文和中文翻译)译文：深入理解安卓系统的安全性下一代开放操作系统的主流将不会在桌面上，但是将会出现在我们每天携带的手机上。
这些开放性的环境将会带领这些新的应用可能集成这些已经存在的在线服务，当然随着日以具增的数据与服务在手机上的支持，手机上的安全缺陷也越发明显。
下一代操作系统本质在于是否提供一个完整综合的安全平台。
由开放手机联盟（open Handset Alliance 谷歌领导）所开发的android 系统是一个被广泛看好的一个手机开源系统，该系统提供一个基本的操作系统，一个中间件应用层，一个java开发工具和一个系统应用收集器（collection of systemapplications ）。
尽管android SDK自2007年就发布了，但是第一部android 手机却在2008年10月才诞生。
自从这时起谷歌开起了自己的时代，T-Mobile的G1的制造商台湾HTC估算G1的发货量在2008年底已经超过100万部。
据业内人士预期该G1手机的销量将会在2009年继续保持。
不久的将来其他许多手机供应商要计划支持这个系统。
一个围绕android庞大的开发者社区已经建立，同时很多新的产品和应用已经可以在android上使用。
一个Android的主要卖点是它使开发人员无缝把在线服务扩展到手机。
这方面最明显的例子是谷歌的紧密集成Gmail，日历和联系人Web应用程序通过该系统。
用户只需提供一个android用户名和密码，其手机自动同步与谷歌的服务。
其他厂商正在迅速适应自己的现有的即时通讯，社交网络和游戏服务。
Android和许多企业寻找新途径来整合他们的自己已有的业务到android上。
传统的台式机和服务器的操作系统一直在努力进行安全功能的集成。
这些个人和商业应用在单一平台的很出色，然而这一块业务一个手机平台上像android上不是很有用。
它给了许多研究人员希望。
外文翻译安卓系统的大体描述
附录二外文文献（原文）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 2020 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 2020. According to industry insiders expect the G1 mobile phone sales in 2020 continue. Many other mobile phone suppliers in the near future plans to support this system.Around an android and a huge developer community has beenestablished, 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 JAVA middle ware, the middle ware running on the embedded Linux kernel. Therefore, developers should deploy their applications to the Android must use 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 takesuch 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 initiatean 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 resourcefiles 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 other applications.（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 ofelements 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 worktogether 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'sinteraction 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 mayuse 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,amongother 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 that connection,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 themanifest,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,thescreen 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：外文原文What Is Android?It can be said that, for a while, traditional desktop application developers have beenspoiled. This is not to say that traditional desktop application development is easier thanother forms of development. However, as traditional desktop application developers, wehave had the ability to create almost any kind of application we can imagine. I amincluding myself in this grouping because I got my start in desktop programming.One aspect that has made desktop programming more accessible is that we havehad the ability to interact with the desktop operating system, and thus interact with anyunderlying hardware, pretty freely (or at least with minimal exceptions). This kind offreedom to program independently, however, has never really been available to thesmall group of programmers who dared to venture into the murky waters of cell phonedevelopment.For a long time, cell phone developers comprised a small sect of a slightly larger group of developers known as embedded device developers. Seen as a less “glamorous” sibling to desktop—and later web—development, embedded device development typically got the proverbial short end of the stick as far as hardware and operating system features, because embedded device manufacturers were notoriously stingy on feature support. Embedded device manufacturers typically needed to guard their hardware secrets closely, so they gave embedded device developers few libraries to call when trying to interact with a specific device. Embedded devices differ from desktops in that an embedded device is typically a “computer on a chip.” For example, consider your standard television remote control; it is not really seen as an overwhelming achievement of technological complexity. When any button is pressed, a chip interprets the signal in a way that has been programmed into the device. This allows the device to know what to expect from the input device (key pad), and how to respond to those commands (for example, turn on the television). This is a simple form of embedded device programming. However, believe it or not, simple devices such as these are definitely related to the roots of early cell phone devices and development.Most embedded devices ran (and in some cases still run) proprietary operating systems. The reason for choosing to create a proprietary operating system rather than use any consumer system was really a product of necessity. Simple devices did not need very robust and optimized operating systems.As a product of device evolution, many of the more complex embedded devices, such as early PDAs, household security systems, and GPSs, moved to somewhat standardized operating system platforms about five years ago. Small-footprintoperating systems such as Linux, or even an embedded version of Microsoft Windows, have become more prevalent on many embedded devices. Around this time in device evolution, cell phones branched from other embedded devices onto their own path. This branching is evident when you examine their architecture.Nearly since their inception, cell phones have been fringe devices insofar as they run on proprietary software—software that is owned and controlled by the manufacturer, and is almost always considered to be a “closed” system. The practice of manufacturers using proprietary operating systems began more out of necessity than any other reason. That is, cell phone manufacturers typically used hardware that was completely developed in-house, or at least hardware that was specifically developed for the purposes of running cell phone equipment. As a result, there were no openly available, off-the-shelf software packages or solutions that would reliably interact with their hardware. Since the manufacturers also wanted to guard very closely their hardware trade secrets, some of which could be revealed by allowing access to the software level of the device, the common practice was, and in most cases still is, to use completely proprietary and closed software to run their devices. The downside to this is that anyone who wanted to develop applications for cell phones needed to have intimate knowledge of the proprietary environment within which it was to run. The solution was to purchase expensive development tools directly from the manufacturer. This isolated many of the “homebrew” develo pers.Another, more compelling “necessity” that kept cell phone development out of the hands of the everyday developer was the hardware manufacturers’ solution to the “memory versus need” dilemma. Until recently, cell phones did little more than execute and receive phone calls, track your contacts, and possibly send and receive short text messages; not really the “Swiss army knives” of technology they are today. Even as late as 2002, cell phones with cameras were not commonly found in the hands of consumers.By 1997, small applications such as calculators and games (Tetris, for example) crept their way onto cell phones, but the overwhelming function was still that of a phone dialer itself. Cell phones had not yet become the multiuse, multifunction personal tools they are today. No one yet saw the need for Internet browsing, MP3 playing, or any of the multitudes of functions we are accustomed to using today. It is possible that the cell phone manufacturers of 1997 did not fully perceive the need consumers would have for an all-in-one device. However, even if the need was present, a lack of device memory and storage capacity was an even bigger obstacle to overcome. More people may have wanted their devices to be all-in-one tools, but manufacturers still had to climb the memory hurdle.To put the problem simply, it takes memory to store and run applications on any device, cell phones included. Cell phones, as a device, until recently did not have the amount of memory available to them that would facilitate the inc lusion of “extra” programs. Within the last two years, the price of memory has reached very low levels.Device manufacturers now have the ability to include more memory at lower prices. Many cell phones now have more standard memory than the average PC had in the mid-1990s. So, now that we have the need, and the memory, we can all jump inand develop cool applications for cell phones around the world, right? Not exactly.Device manufacturers still closely guard the operating systems that run on their devices. While a few have opened up to the point where they will allow some Java-based applications to run within a small environment on the phone, many do not allow this. Even the systems that do allow some Java apps to run do not allow the kind of access to t he “core” system that standard desktop developers are accustomed to having.This barrier to application development began to crumble in November of 2007 whenGoogle, under the Open Handset Alliance, released Android. The Open Handset Allianceis a group of hardware and software developers, including Google, NTT DoCoMo,Sprint Nextel, and HTC, whose goal is to create a more open cell phone environment.The first product to be released under the alliance is the mobile device operatingsystem, Android. (For more information about the Open Handset Alliance, see)With the release of Android, Google made available a host of development toolsand tutorials to aid would-be developers onto the new system. Help files, the platformsoftware development kit (SDK), and even a developers’ community can be found atGoogle’s Android website, /android. This site should be yourstarting point, and I highly encourage you to visit the site.While cell phones running Linux, Windows, and even PalmOS are easy to find, as ofthis writing, no hardware platforms have been announced for Android to run on. HTC, LGElectronics, Motorola, and Samsung are members of the Open Handset Alliance, underwhich Android has been released, so we can only hope that they have plans for a fewAndroid-based devices in the near future. With its release in November 2007, the systemitself is still in a software-only beta. This is good news for developers because it gives usa rare advance look at a future system and a chance to begin developing applications thatwill run as soon as the hardware is released.Android, as a system, is a Java-based operating system that runs on the Linux 2.6 kernel.The system is very lightweight and full featured. Figure 1-1 shows the unmodifiedAndroid home screen.Figure 1-1 The current Android home screen as seen on the Android EmulatorAndroid applications are developed using Java and can be ported rather easily to thenew platform. If you have not yet downloaded Java or are unsure about which version youneed, I detail the installation of the development environment in Chapter 2. Other featuresof Android include an accelerated 3-D graphics engine (based on hardware support),database support powered by SQLite, and an integrated web browser.If you are familiar with Java programming or are an OOP developer of any sort, youare likely used to programmatic user interface (UI) development—that is, UI placementwhich is handled directly within the program code. Android, while recognizing and allowingfor programmatic UI development, also supports the newer, XML-based UI layout. XMLUI layout is a fairly new concept to the average desktop developer. I will cover boththe XML UI layout and the programmatic UI development in the supporting chaptersof this book.One of the more exciting and compelling features of Android is that, because of itsarchitecture, third-party applications—including those that are “home grown”—areexecuted with the same system priority as those that are bundled with the core system.This is a major departure from most systems, which give embedded system apps agreater execution priority than the thread priority available to apps created by third-partydevelopers. Also, each application is executed within its own thread using a verylightweight virtual machine.Aside from the very generous SDK and the well-formed libraries that are availabletous to develop with, the most exciting feature for Android developers is that we now haveaccess to anything the operating system has access to. In other words, if you want tocreate an application that dials the phone, you have access to the phone’s dialer; if youwant to create an application that utilizes the phone’s internal GPS (if equipped), you haveaccess to it. The potential for developers to create dynamic and intriguing applications isnow wide open.On top of all the features that are available from the Android side of the equation,Google has thrown in some very tantalizing features of its own. Developers of Androidapplications will be able to tie their applications into existing Google offerings such asGoogle Maps and the omnipresent Google Search. Suppose you want to write anapplication that pulls up a Google map of where an incoming call is emanating from,or you want to be able to store common search results with your contacts; the doors ofpossibility have been flung wide open with Android.Ask the ExpertQ: What is the difference between Google and the Open Handset Alliance?A: Google is a member of the Open Handset Alliance. Google, after purchasing the originaldeveloper of Android, released the operating system under the Open Handset Alliance.Q: Is Android capable of running any Linux software?A: Not necessarily. While I am sure that there will be ways to get around most any opensource system, applications need to be compiled using the Android SDK to run onAndroid. The main reason for this is that Android applications execute files in a specificformat; this will be discussed in later chapters.Reference：[1]Hello Android. Introdu cing Google’s Mobile Developmeng Platform 3rd.Edition,EdBurnette,The Pragmatic Bookshelf[2]The.Android.Developers.Cookbook Building Applications with the Android SDK,James Steele Nelson,Addison-Wesley[3] Pro Android Media. Developing Graphics,Music,Video and Rich Media Apps for Smartphones and Tablets,Shawn Van Every,Apress[4] Professional.Android.2.Application.Development.(Wrox,.2010,.0470565527)附录2：外文译文什么是Android?可以说，于此同时，传统的桌面应用程序开发人员已经被宠坏了。
android手机操作系统中英文对照
android⼿机操作系统中英⽂对照general 常规silent mode 静⾳模式 (silence all sounds except media & alarms 对所有⾮多媒体声⾳进⾏静⾳处理)vibrate 震动(always 始终 / never ⼀律不 / only in silent mode 仅在静⾳模式下来电震动 / only whe n not in silent mode 仅在⾮静⾳模式下来电震动)volume ⾳量 (use incoming call volume for notifications 将来电⾳量⽤作通知⾳量)incoming calls 来电phone ringtone ⼿机铃声notification 通知notification ringtone 通知铃声feedback 反馈audible touch tones 按键操作⾳(play tones when using dial pad 使⽤拨号键盘时播放按键⾳效) audible selection 选择操作⾳(play sound when making screen selcction 进⾏屏幕选择时播放⾳效)sereen lock sounds 屏幕锁定操作⾳(play sound when locking and unlocking the screen 锁定和解锁屏幕时播放声⾳)haptic feedback 触感 (vibrate when pressing soft keys and on certain UI interactions 按软键以及进⾏某些UI交互时震动)display 显⽰brightness 亮度(automatic brightness ⾃动调节亮度)auto-rotate screen ⾃动旋转屏幕animation 动画(no window animations are shown 不显⽰窗⼝动画 - (no animations ⽆动画 / some animationgs 部分动画 / all animations 所有动画))screen timeout 屏幕超时(adjust the delay before the screen automatically turns off 调整屏幕⾃动锁定前的延时)number of home panels 屏幕个数 (adjust the number of panels on home screen 调整主屏的屏幕个数)location & security 位置和安全my location 我的位置use wireless network 使⽤⽆线⽹络(location determined by Wi-Fi and/or mobile networks 通过W i-Fi和/或移动⽹络确定的位置)use GPS satellites 使⽤GPS卫星(locate to street-level(requires more battery plus view of sky) 定位时，精确度设定为街道级别（取消选中可节约电量）)phone lock ⼿机锁定phone lock settings ⼿机锁定设置phone lock type ⼿机锁定类型(phone lock is off 关闭⼿机锁定功能(none ⽆ / password 密码 / p attern 图案))change unlock password timeout 更改解锁密码超时时间use visible pattern 使⽤图案use tactile feedback 使⽤触感screen unlock 屏幕解锁set up screen lock 设置屏幕锁定(lock screen with a pattern,PIN,or password 使⽤图案、PIN或密码锁定屏幕)none ⽆(disable screen unlock security 停⽤屏幕锁定保护功能)pattern 图案(draw pattern to unlock screen 绘制图案给屏幕解锁)PIN (enter a number PIN to unlock screen 输⼊数字PIN给屏幕解锁)password 密码(enter a password to unlcok screen 输⼊密码给屏幕解锁)SIM card lock SIM卡锁定set up SIM card lock 设置SIM卡锁定lock SIM card 锁定SIM卡(require PIN to phone 需要输⼊PIN才能使⽤⼿机)change SIM PIN 更改SIM卡PINpassword 密码visible passwords 密码可见(show password as you type 输⼊密码时可见)device administration 设备管理select device admindtrators 学则设备管理器(add or remove device administrators 添加或删除设备管理器)(no available device administrators 没有可供显⽰的设备管理器)credential stronge 凭证存储use secure credentials 使⽤安全凭证(allow applications to access secure certificates and other credentials 允许应⽤程序访问安全凭证和其他凭证)install from SD card 从SD卡安装(install encrypted certificates from SD card 从SD卡安装加密的证书)(no certificate file found in the SD card 在SD卡上找不到证书⽂件)set password 设置密码(set or change the credential storage password 设置或更改凭证存储密码) (set a password for the credenntial storage(at least 8 characters) 设置凭证存储密码（⾄少8个字符） / n ew password 新密码 / confirm new password 确认新密码)clear storage 清楚存储(clear credential storage of all contents and reset its password 清楚所有内容的凭证存储并重置其密码)applications 应⽤程序unknown sources 未知来源(allow installation of non-Market applications 允许安装⾮电⼦市场提供的的应⽤程序)quick launch 快速启动(set keyboard shortcuts to launch applictions 设置快捷键启动程序)(no shortc ut 没有快捷键)manage applicatings 管理应⽤程序(manage and remove installed applications 管理和删除按章的应⽤程序)(sort by size 按⼤⼩排序)running services 正在运⾏的服务(view and control currently running services 查看和控制当前正在运⾏的服务)development 开发(set options for application development 设置应⽤程序开发选项)USB debugging USB调试(debug mode when USB is connected 连接USB后启⽤调试模式)stay awake 保持唤醒状态(screen will never sleep while charging 充电时屏幕不会休眠)allow mock locations 允许模拟地点(allow mock locations 允许模拟地点)accounts & sync 账户与同步 (add account 添加账户)general sync settings 常规同步设置background data 背景数据(applications can sync,send,and receive data at any time 应⽤程序随时可以同步、发送和接收数据)auto-sync ⾃动同步(applications sync data automatically 应⽤程序⾃动同步数据)manage accounts 管理账户(remove account 删除账户)data & synchronization 数据与同步sync contacts 同步联系⼈ (touch to sync now 触摸可⽴即同步)sync gmail 同步Gmailsync calendar 同步⽇历privacy 隐私权backup and restore 备份和还原back up my data 备份我的数据(back up my settings and other apppliction data 备份我的设置和其他应⽤程序数据)automatic restore ⾃动还原 (if I reinstall an application,restore backed up settings or other data 重新安装某个应⽤程序后，系统会还原已经备份的设置或其他数据)personal data 个⼈数据factory data reset 恢复出⼚设置(erases all data on phone 清除⼿机上的所有设置)SD card & phone storage SD卡和⼿机内存SD card SD卡total space 总容量available space 可⽤空间unmount/mount SD card 卸载/安装SD卡(unmount the SD card for safe removal 必须先卸载SD卡，才能将其安全移除)format SD card 格式化SD卡 (format(erase)the SD card 格式化（清除）SD卡)internal phone storage ⼿机内存available space 可⽤空间language & keyboard 语⾔和键盘select language 选择语⾔multi-touch keyboard 多点触摸键盘input languages 输⼊语⾔(slide finger on spacebar to change language 在空格键滑动⼿指可更改语⾔)on-screen keyboard 屏幕键盘show suggestions 显⽰建议(display corrections and completions while typing 输⼊时启⽤联想提⽰)auto-correct errors ⾃动纠错(spacebar and punctuation automatically insert highlighted wordFriday / Fri. 星期五Saturday / Sat. 星期六Sunday / Sun. 星期⽇。
安卓应用开发基础论文中英文对照资料外文翻译文献
安卓应用开发基础论文中英文对照资料外文翻译文献中英文对照资料外文翻译文献安卓应用开发基础在Java编程语言编写的Android应用程序的Android的SDK工具编译代码以及与任何数据和到一个Android的包，一个归档文件档案资源的.apk后缀，所有的在一个单一的代码.apk文件被认为是一个应用程序，是Android的文件，供电设备来安装应用程序。
一旦安装在设备上，每个Android应用程序的生命在它自己的安全沙箱：而Android操作系统是一个多用户Linux系统中，每个应用程序是一个不同的用户。
默认情况下，每个应用程序的系统分配一个唯一的Linux用户ID，系统设置所有的应用程序中的文件权限，以便只有用户ID分配给该应用程序可以访问它们。
每个进程都有它自己的虚拟机，因此应用程序的代码在从其他应用程序隔离运行。
默认情况下，每个应用程序运行在它自己的Linux进程。
Android的启动过程时，应用程序的任何组件需要被执行，然后关闭该进程时，它不再需要或恢复时，系统必须为其他应用程序的内存。
这样一来，Android系统实现了最小特权原则，也就是说，每个应用程序，默认情况下，只能访问的组件，它需要做的工作，没有更多，这将创建一个非常安全的环境，使应用程序无法访问的，这就是它没有给予许可制度的部分。
但是，有一个应用程序的方法与其他应用程序和应用程序访问系统服务的数据：这有可能为两个应用程序安排共享相同的Linux用户ID，在这种情况下，它们能够相互访问的文件。
为了节约使用相同的用户ID系统资源，应用程序还1 可以安排运行在相同的Linux进程和共享同一个VM。
应用程序可以请求访问权限，如用户的联系人，短信，可安装存储，摄像头，蓝牙等设备的数据，所有应用程序的权限必须用户在安装时授予。
这涵盖了基本就如何Android应用程序在系统中存在这个文件的其余部分向您介绍：1、框架的核心组件定义应用程序。
2、清单文件中声明组件和应用程序所需的设备功能。
网络工程外文翻译---安卓程序员指南
毕业论文(设计)外文翻译原文来源Android™A Programmer’s Guide 中文翻译安卓程序员指南学院数学与计算机科学学院专业网络工程姓名学号200808204105指导教师Android™A Programmer’s Guid eJ.F. DiMarzioNew York Chicago San FranciscoLisbon London Madrid Mexico CityMilan New Delhi San JuanSeoul Singapore Sydney TorontoAbout the AuthorJ.F. DiMarzio is a developer with over 15 years ofexperience in networking and application developmentand is the author of seven books on computing technologies.He has become a leading resource in the fields of ITconsulting and development. He lives in Central Florida.About the Technical EditorGilbert L. Polo is a software developer with over 20years of experience working in the telecommunications, financial, and, most recently, educational industries. Hehas programmed in various languages including C, C++,Java, and C#.Chapter1What Is Android?Key Skills & ConceptsHistory of embedded device programming●Explanation of Open Handset Alliance●First look at the Android home screenIt can be said that, for a while, traditional desktop application developers have been spoiled. This is not to say that traditional desktop application development is easier than other forms of development. However, as traditional desktop application developers, we have had the ability to create almost any kind of application we can imagine. I am including myself in this grouping because I got my start in desktop programming.One aspect that has made desktop programming more accessible is that we have had the ability to interact with the desktop operating system, and thus interact with any underlying hardware, pretty freely (or at least with minimal exceptions). This kind of freedom to program independently, however, has never really been available to the small group of programmers who dared to venture into the murky waters of cell phone development.NOTEI refer to two different kinds of developers in this discussion: traditional desktop application developers, who work in almost any language and whose end product, applications, are built to run on any “desktop” operating system; and Android developers, Java developers who develop for the Android platform. This is not for the purposes of saying one is by any means better or worse than the other.Rather, the distinction is made for purposes of comparing the development styles and tools of desktop operating system environments to the mobile operating system environment, Android.Brief History of Embedd ed Device Programming For a long time, cell phone developers comprised a small sect of a slightly larger group of developers known as embedded device developers. Seen as a less “glamorous” sibling to desktop—and later web—development, embedded device development typically got the proverbial short end of the stick as far as hardware and operating system features, because embedded device manufacturers were notoriously stingy on feature support. Embedded device manufacturers typically needed to guard their hardware secrets closely, so they gave embedded device developers few libraries to call when trying to interact with a specific device. Embedded devices differ from desktops in that an embedded device is typically a “computer on a chip.” For example, consider your standard television remote control; it is not really seen as an overwhelming achievement of technological complexity. When any button is pressed, a chip interprets the signal in a way that has been programmed into the device. This allows the device to know what to expect from the input device (key pad), and how to respond to those commands (for example, turn on the television). This is a simple form of embedded device programming. However, believe it or not, simple devices such as these are definitely related to the roots ofearly cell phone devices and development.Most embedded devices ran (and in some cases still run) proprietary operating systems. The reason for choosing to create a proprietary operating system rather than use any consumer system was really a product of necessity. Simple devices did not need very robust and optimized operating systems.As a product of device evolution, many of the more complex embedded devices, such as early PDAs, household security systems, and GPSs, moved to somewhat standardized operating system platforms about five years ago. Small-footprint operating systems such as Linux, or even an embedded version of Microsoft Windows, have become more prevalent on many embedded devices. Around this time in device evolution, cell phones branched from other embedded devices onto their own path. This branching is evident when you examine their architecture.Nearly since their inception, cell phones have been fringe devices insofar as they run on proprietary software—software that is owned and controlled by the manufacturer, and is almost always considered to be a “closed” system. The practice of manufacturers using proprietary operating systems began more out of necessity than any other reason. That is, cell phone manufacturers typically used hardware that was completely developed in-house, or at least hardware that was specifically developed for the purposes of running cell phone equipment. As a result, there were no openly available, off-the-shelf software packages or solutions that would reliably interact with their hardware. Since the manufacturers also wanted to guard very closely their hardware trade secrets, some of which could be revealed by allowing access to the software level of the device, the common practice was, and in most cases still is, to use completely proprietary and closed software to run their devices. The downside to this is that anyone who wanted to develop applications for cell phones needed to have intimate knowledge of the proprietary environment within which it was to run. The solution was to purchase expensive development tools directly from the manufacturer. This isolated many of the “homebrew” developers.NOTEA growing culture of homebrew developers has embraced cell phone application development. The term “homebrew” refers to the fact that these developers typically do not work for a cell phone development company and generally produce small, one-off products on their own time.Another, more co mpelling “necessity” that kept cell phone development out of the hands of the everyday developer was the hardware manufacturers’ solution to the “memory versus need” dilemma. Until recently, cell phones did little more than execute and receive phone calls, track your contacts, and possibly send and receive short text messages; not really the “Swiss army knives” of technology they are today. Even as late as 2002, cell phones with cameras were not commonly found in the hands of consumers.By 1997, small applications such as calculators and games (Tetris, for example) crept their way onto cell phones, but the overwhelming function was still that of a phone dialer itself. Cell phones had not yet become the multiuse, multifunctionpersonal tools they are today. No one yet saw the need for Internet browsing, MP3 playing, or any of the multitudes of functions we are accustomed to using today. It is possible that the cell phone manufacturers of 1997 did not fully perceive the need consumers would have for an all-in-one device. However, even if the need was present, a lack of device memory and storage capacity was an even bigger obstacle to overcome. More people may have wanted their devices to be all-in-one tools, but manufacturers still had to climb the memory hurdle.To put the problem simply, it takes memory to store and run applications on any device, cell phones included. Cell phones, as a device, until recently did not have the amount of memory available to them that would facilitate the inclusion of “extra”programs. Within the last two years, the price of memory has reached very low levels.Device manufacturers now have the ability to include more memory at lower prices. Many cell phones now have more standard memory than the average PC had in the mid-1990s. So, now that we have the need, and the memory, we can all jump in and develop cool applications for cell phones around the world, right? Not exactly.Device manufacturers still closely guard the operating systems that run on their devices. While a few have opened up to the point where they will allow some Java-based applications to run within a small environment on the phone, many do not allow this. Even the systems that do allow some Java apps to run do not allow the kind of access to the “core” system that standard desktop developers are accustomed to having.Open Handset Alliance and AndroidThis barrier to application development began to crumble in November of 2007 when Google, under the Open Handset Alliance, released Android. The Open Handset Alliance is a group of hardware and software developers, including Google, NTT DoCoMo, Sprint Nextel, and HTC, whose goal is to create a more open cell phone environment.The first product to be released under the alliance is the mobile device operating system, Android. (For more information about the Open Handset Alliance, see .) With the release of Android, Google made available a host of development tools and tutorials to aid would-be developers onto the new system. Help files, the platform software development kit (SDK), and even a developers’ community can be found at Google’s Android website, /android. This site should be your starting point, and I highly encourage you to visit the site.NOTEGoogle, in promoting the new Android operating system, even went as far as to create a $10 million contest looking for new and exciting Android applications.While cell phones running Linux, Windows, and even PalmOS are easy to find, as of this writing, no hardware platforms have been announced for Android to run on. HTC, LGElectronics, Motorola, and Samsung are members of the Open Handset Alliance, under which Android has been released, so we can only hope that they have plans for a few Android-based devices in the near future. With its release in November 2007, the system itself is still in a software-only beta. This is good news for developers because it gives us a rare advance look at a future system and a chance to begin developing applications that will run as soon as the hardware is released.NOTEThis strategy clearly gives the Open Handset Alliance a big advantage over other cell phone operating system developers, because there could be an uncountable number of applications available immediately for the first devices released to run Android.Introduction to AndroidAndroid, as a system, is a Java-based operating system that runs on the Linux 2.6 kernel. The system is very lightweight and full featured. Figure 1-1 shows the unmodified Android home screen.Figure 1-1 The current Android home screen as seen on the Android Emulator Android applications are developed using Java and can be ported rather easily to the new platform. If you have not yet downloaded Java or are unsure about whichversion you need, I detail the installation of the development environment in Chapter 2. Other features of Android include an accelerated 3-D graphics engine (based on hardware support), database support powered by SQLite, and an integrated web browser.If you are familiar with Java programming or are an OOP developer of any sort, you are likely used to programmatic user interface (UI) development—that is, UI placement which is handled directly within the program code. Android, while recognizing and allowing for programmatic UI development, also supports the newer, XML-based UI layout. XMLUI layout is a fairly new concept to the average desktop developer. I will cover both the XML UI layout and the programmatic UI development in the supporting chapters of this book.One of the more exciting and compelling features of Android is that, because of its architecture, third-party applications—including those that are “home grown”—are executed with the same system priority as those that are bundled with the core system.This is a major departure from most systems, which give embedded system apps a greater execution priority than the thread priority available to apps created by third-party developers. Also, each application is executed within its own thread using a very lightweight virtual machine.Aside from the very generous SDK and the well-formed libraries that are available to us to develop with, the most exciting feature for Android developers is that we now have access to anything the operating system has access to. In other words, if you want to create an application that dials the phone, you have access to the phone’s dialer; if you want to create an application that utilizes the phone’s internal GPS (if equipped), you have access to it. The potential for developers to create dynamic and intriguing applications is now wide open.On top of all the features that are available from the Android side of the equation, Google has thrown in some very tantalizing features of its own. Developers of Android applications will be able to tie their applications into existing Google offerings such as Google Maps and the omnipresent Google Search. Suppose you want to write an application that pulls up a Google map of where an incoming call is emanating from, or you want to be able to store common search results with your contacts; the doors of possibility have been flung wide open with Android.Ask the ExpertQ: What is the difference between Google and the Open Handset Alliance?A: Google is a member of the Open Handset Alliance. Google, after purchasing the original developer of Android, released the operating system under the Open Handset Alliance.Q: Is Android capable of running any Linux software?A: Not necessarily. While I am sure that there will be ways to get around most any open source system, applications need to be compiled using the Android SDK to run on Android. The main reason for this is that Android applications execute files in a specific format; this will be discussed in later chapters.Reference：[1]Hello Android. Introducing Google’s Mobile Developmeng Platform 3rd.Edition,Ed Burnette,The Pragmatic Bookshelf[2]The.Android.Developers.Cookbook Building Applications with the Android SDK,James Steele Nelson,Addison-Wesley[3] Pro Android Media. Developing Graphics,Music,Video and Rich Media Apps for Smartphones and Tablets,Shawn Van Every,Apress[4] Professional.Android.2.Application.Development.(Wrox,.2010,.0470565527)程序员指南原著：J.F.DiMarzio翻译：张劲锋关于作者：J.F.DiMarzio是一个在网络和程序开发领域拥有超过15年经验的程序开发员并且是7本关于计算机科学书籍的作者。
有关android技术英文文献翻译
Application FundamentalsAndroid 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's the file users download to their devices. All the code in a single .apk file is considered to be one application.Android应用基础：Android应用程序是通过java语言开发的，通过绑定一些应用所需要的东西，例如：编译的Java代码，加上数据和一些资源文件，使用一个apt的工具将所有的东西封装成一个android包，这个文件的文件后缀是.apk。
这个文件是分发并安装应用程序到移动设备的载体，是用户获得该应用程序所需要的下载的文件。
Application Components A central feature of Android is that one application can make use of elements of other applications (provided those applications 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:Activities An 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 changesettings. Though 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. Android有四大应用程序组件Android的一个很重要的中心特征就是一个应用程序能充分利用其他的应用程序的一些组件（前提是被允许的）例如：如果的当前开发的应用需要一个滚动的列表去展示相片并且当时其他的程序已经开发了一个合适的滚动列表并且对其他人可用，你可以调用这个滚动的列表来完成你的工作而不是开发你自己的。
谷歌Android内置APK程序中英文对照表
OneTimeInitializer.apk 【首次啟動時用來裝 Google Apps 的，可刪除】
OxygenSettings.apk 【是氧气的快捷设置.目前是英文版的,删不删随意.不建议删】
PackageInstaller.apk 【apk安装程序/删了是**不解释】
SoundRecorder.apk 【录音机删之】（可用第三方录音软件替代）】
SpareParts.apk 【附加设置高级设置英文的删之
Stk.apk 【SIM卡工具 sim卡服务（可删，有机油把联系人复制在sim卡上的就不要删它，删了可解决信号问题）】
Superuser.apk 【授权程序（就是程序列表上面那个，用这个获取root才有的）root权限用的删了影响智商！！！】
Calendar.apk 【日历/（不用日历的可删）换第三方可删】
CalendarProvider.apk 【日历储存 日历程序支持服务（不用日历的可删）可删】
Camera.apk 【照相机/换第三方可删】
CertInstaller.apk 【证书服务 证书安装/貌似没用可删/暂无副作用】
CMParts.apk 【CM设置/保留 】touchpal输入法拼音语言包（可删）
Gallery.apk 相机相框 （可删）
GoMarket.apk 【安智市场/可删】
GenieWidget.apk 天气与新闻（我自己不用他看新闻，删了）
Gmail.apk Gmail邮件（可删）
GoogleBackupTransport.apk 谷歌备份（可删）
GoogleCalendarSyncAdapter.apk 谷歌日历同步适配器（可删）
Android系统应用程序中英文对照表
htccalendarwidgetsHTC日历桌面小插件
HTCCamera照相机（没人想把它删了吧）
HtcClockWidget闹钟小插件
HtcCompressViewer
HtcContacts联系人
CertInstaller证书安装器（貌似不能删）
CheckinProvider签入服务
Clicker键盘校准（貌似是）
com.htc.FMRadioWidget桌面收音机插件（插件类都可以删，自己决定）
com.htc.FriendStreamWidget好友流小插件（可删）
com.htc.MusicWidget桌面音乐插件
HtcScreenTimeoutWidget.apk调节屏幕延时插件
HtcSettingsProvider.apk HTC设置
htcsettingwidgets.apk HTC设置小插件，WIFI、移动网络、GPS、飞行模式、蓝牙的开关（好用）
HTCSetupWizard.apk HTC安装向导
GoogleFeedback谷歌反馈（反馈啥，直接干掉）
GooglePartnerSetup Google助手（直接干掉）
GoogleQuickSearchBox谷歌搜索（删了影响到桌面的搜索插件，自启动，干掉他）
GoogleServicesFramework谷歌同步支持服务框架（删了不能同步联系人，不能登录google，我留着呢）
HtcPushMedia.apk
pk
HtcRecommendsWidget.apk
HtcRingtoneTrimmer.apk铃声剪辑（无视，删了）
安卓 android 翻译 中英文 对照 毕设
欣达维出版公司国际电脑游戏技术期刊卷2012，文章编号：494232，共10页DOI：10.1155/2012/494232研究课题通过比较学习发展中的社会应用程序与安卓平台上的游戏的软件体系结构BianWu和Alf IngeWang挪威特隆赫姆科技大学计算机科学系学习软件体系结构的比较研究论文7491邮件联系方式BianWu：bian@idi.ntnu.no收件时间：2012年4月15日，回复时间：2012年7月16日学术责任编辑：丹尼尔·塔尔曼版权©2012 B. Wu and A. I.Wang。
这是一个开放的，允许无限制地使用和分配在任何媒体上，原来的工作是正确的引用在创作公用署名许可下发布的文章。
本文描述了一个实证研究：重点是发现使用相同的安卓开发平台的游戏开发工作与学生工作的学生的社交应用开发的异同。
在2010-2011年之间，学生参加课程挪威科技大学（NTNU）的软件架构，可以选择四种类型的项目。
独立所选择的项目类型，所有的学生必须要经过相同的阶段，产生相同的模板，基于相同的文件，并按照完全相同的进程。
本研究的重点项目是安卓项目，看看有多少应用程序域的独立影响的课程项目所选择的技术。
我们的研究结果，为学生做游戏开发的社交应用开发，学习软件架构，积极地工作与游戏，更好地专注于发展过程中的质量属性，如可修改性和可测试性，软件架构，较高的生产复杂性，更高效的编码工作的项目揭示了一些积极的作用。
然而，，对于学生选择两个不同的领域而获得等级，我们并没有发现有显着差异。
1.介绍电脑游戏和视频游戏已经非常流行,在儿童、青少年和年轻人的文化中发挥了突出的作用。
游戏是现在可以到处都在播放的技术，丰富的环境，配备笔记本电脑，智能手机，游戏机（移动和固定），机顶盒和其它数字设备。
这种现象，被认为是年轻人显示对游戏的内在动机，可以结合教育内容和目标，并且关系到一种普伦斯基所谓的“数字游戏为基础的学习”。
安卓手机中英文对照
GoogleCalendarSyncAdapter.apk 谷歌日历同步适配器（我要用日历，没删）
DownloadProvider.apk 下载管理器(别删)
DrmProvider.apk DRM数字版权管理（我没删）
Facebook.apk Facebook（国内连不上，没啥用）
com.htc.rosiewidgets.todayinhistory.apk 历史上的今天
com.htc.rosiewidgets.translator.apk 翻译
com.htc.rosiewidgets.wordoftheday.apk 每日一词（不学英语的没鸟用）
Flickr.apk Flickr应用（国内连不上，没啥用）
GenieWidget.apk 天气与新闻（自启动，自上网，重点删除对象）
FieldTest.apk 测试程序（别删，删了没信号）
FilePicker.apk 文件定位（我没删）
Flashlight.apk 手电筒（我没删）
com.htc.rosiewidgets.sandtimer.apk 沙漏
com.htc.rosiewidgets.task.apk 未知插件
com.htc.rosiewidgets.tipcalculator.apk 小费计算器
GoogleContactsSyncAdapter.apk 谷歌联系人同步适配器（担心他自上网，我删了）
GoogleFeedback.apk 谷歌反馈（反馈啥，直接干掉）
GooglePartnerSetup.apk Google助手（直接干掉）
Android系统外文翻译
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。
安卓系统与IOS系统比较—英文文献翻译外文翻译
ESEP 2011: 9-10 December 2011, SingaporeAn Analysis and Comparison of Open and Closed MobilePlatformsAndroid vs. iPhoneYinglu ZOUa, , Hao WU b, Jianxin HUANG a,ba Information Engineering College,7 JianXue Road, JinShui District, ZhengZhou,450001, ChinaAbstractWith the release of Android 2.2 Froyo and iPhone 4, the war between open and closed mobile platforms tends to befiercer. Being the representatives of the two parties, Froyo and iOS 4 are quite different at system framework, newfeature, application market and integration model. According to the company spirits of Google and Apple, we do some analyses and comparisons of the above points, explain the differences of Android and iPhone from the shallower to the deeper, then conclude the characteristics of open and closed mobile platforms, aiming at providing an objective reference for researchers of mobile platforms, helping them see clearer into mobile industry. As a result,both Froyo and iOS 4 have their advantages and disadvantages, still they are far from being perfect, there‟s room forfurther improvement.Keywords: Android；iPhone；Froyo；iOS 4；smart phone；mobile platform1. IntroductionIn recent years, the popularity of smart phone kept going up. More and more smart phones are sold anda lot of people are embracing them. Smart phones brought great convenience to users, as well created opportunities for smart phone researchers. That‟s to say, the wide spread of smart phones benefited both sides. At the same time, developing of smart phone OS becomes one of the smartest industry. To be a smart phone OS, the system should: 1. Provide services like a PC. 2. Work with a GPU for better visual effects. 3. Allow the user to surf on Internet freely. And apparently, there‟re also some weaknesses:1.Limited batte ry. 2. Poor CPU performance against PC CPU. 3. Small storage. 4. The use of RAM may leads to loss of data when the phone runs out of batteryNow the 2 giants of smart phone OS are Android and iPhone OS. On one side, Android is based on Linux kernel and Dalvik virtual machine, and it is open sourced. The upper layer of Android is Java based,allowing developers to develop Android applications with Google SDK and sell their software in Android Market. On theother side, iPhone OS, which bases on Unix kernel and Darwin model but is closed sourced,evolves from Mac OS X and is the default OS of iPhone, iPod Touch and iPad. Objective C based software can run in iPhone OS, and just like Android, you can develop your own iPhone applications and upload them onto Apple‟s …App Store‟ for sale [1] [2] [3] [4].By comparing the latest Android and iPhone OS, Android 2.2 Froyo and iOS 4, we can take a glimpse at the main feature of open and closed smart phone OSs. While the 2 OSs are designed in rather different mentality an d functionality, it‟s a little early to tell which one is better.2. Smart Phone OS2.1. AndroidThe system architecture of Android consists of 5 layers, which are Linux Kernel, Android Runtime, Libraries, Application Framework and Applications, from bottom to top.Android provides core services like security, memory management, process management, network stack and drivers, basing on Linux 2.6. Being the abstract layer between software and hardware, the layer of Linux Kernel hides the implementing details of hardware and provides integrated services for upper layer.Dalvik virtual machine and Java core libraries are included in the layer of Android Runtime, providing most functions in Java core libraries.The layer of Libraries contains a class of C/C++ libraries for Android components. Those libraries are integrated by the layer of Application Framework and then provided to developers.The layer of Application Framework provides all kinds of modules for program initialization to simplify the use of components, allowing developers do whatever they want and provide services for other softwares, under the limitation of security, of course.Mainstream applications are located in the layer of Application, including e-mail, SMS, calendar, Google map, Web browser and contacts. Users interact directly with this layer [1] [2].The latest version of Android, Android 2.2 Froyo, puts on some new features. They are: 1. Support Flash 10.1, enables user to watch flash on the phone. 2. V8 JavaScript engine in web browser leads to faster Internet data transportation. 3. Big advance in network sharing. You can use the phone as a 3G NIC,or convert 3G signalto Wi-Fi. 4. Automatically software update. 5. Softwares can be setup in SD card to extend file storages.2.2. iPhoneiPhone OS is consist of 4 abstract layers: Core OS, Core Service, Media and Cocoa Touch respectively.Layers of Core OS and Core Service are designed in C language to handle core system services, enabling developers to perform file access, sockets calling and data handling. CFNetwork and SQLite are also parts of these 2 layers.The layer of Media, according to its name, this layer is used to control video and audio, as well handle 2D and 3D images. The Open GL-ES Quratz part of the layer is coded with C language, while the part of Core-Audio and Core-Animation is Objective C based.The layer of Cocoa Touch builds a basic framework for all kinds of programs in iPhone. Most programs run in Cocoa Touch layer, and it‟s surely Objective C based [3] [4].The latest iPhone OS is iOS 4. It includes the following new features: 1.Software classification. Thisfeature enables user to place sorted softwares into different documents, making it clearer to manage. 2. Email integration. One account is for all e-mails from different providers. 3. iBook, originally from iPad, is built in iOS. 4. A brand new Apple Game Center makes iPhone a tremendous entertainment platform.2.3. Android vs. iPhoneBeing the top 2 smart phone OSs, we‟re sure that both Android and iPhone have their own advantages and disadvantages. Now let‟s take a look at each of them, and see what unique feature they have.Android 2.2 Froyo fully support multitask, which means you can listen to music while writing blog. And iOS 4, officially announced to be …multitasked‟, is in fact a play of concept. Only a few of softwares which are authorized by Apple can run …simultaneously‟, whose principle is much easier that multitask:when an application is switched out, its current state is saved and then the system just closes it. And when it‟s switched in, we‟re back to the previous snapshot [5] [6] [7].During the publication of Android 2.2 Froyo, Google announced it has …the most fluent web browser‟,because the use of V8 JavaScript engine. V8 is a brand new engine, designed for running big size JavaScript application. In some kind of tests, V8is much faster than JScript from Internet Explorer, SpiderMonkey from Firefox and JavaScriptCore from Safari. It all owe to 3 key parts of V8, they‟re fast attribute access, dynamic code generation, effective trash cleaning.2.3.1. Fast Attribute AccessJavaScript is a kind of dynamic language, which means attributes can be added or deleted at runtime, and they‟re frequently changed. Most JavaScript engines use a dictionary style structure to store the attributes of an object, so it requires a whole dictionary search to find the position of attributes in memory.It‟s quite inefficient and it‟s slower than Java and Smalltalk.To solve this problem, V8 discarded dynamic search and realized it in a different way: Create hidden classes for objects dynamically. In JavaScript, every time when we‟re adding a new attribute to an object,we create a subclass with the new attribute from a hidden class as the super class. It‟s a recursive course and the above performance happens only once when we first do this. Later we just use the previous hidden subclass when we‟re in the same situation. So there‟s no need to repeat operation and create a dictionary. This leads to the save of time and energy, as well make it easier for the implementation of class optimization and inner cache [4].2.3.2. Dynamic Code GenerationWhen JavaScript is running for the very first time, V8 translate it directly into local machine code, rather than explain it to bytecode. Attribute access is done by inner cache, which is often translated into instructions by V8 at runtime.When it comes to the code where certain object is accessed, V8 tries to find the current hidden class. Meanwhile, V8 assumes that all objects in the snippet are described by the same hidden class, so V8 willmodify corresponding inner cache to make the direct use of the hidden class more convenient. If thisassumption is correct, the access of attributes can be all done in only 1 instruction. Even if the predictionfails, inner cache is modified again by V8, which won‟t take too much time and resource. When one hidden class is shared by a lot of objects, the access speed can be close to most dynamic language access speed. Inner cache and hidden class, mixed with dynamic code and class optimization, improve the efficiency of JavaScript at a large scale [4].2.3.3. Effective Trash CleaningV8 does memory recycles automatically. To guarantee the speed of object distribution, as well cut the time of trash cleaning and clear fragment up, V8 willinterrupt the running application when performing trash cleaning. Mostly, only a small part of object stack is involved in trash cleaning cycle, so the interruption caused little. All location of objects and pointers are logged by V8, so the system won‟t take object for pointer and memory overflow is avoided [4].Besides …the most fluent web browser‟, Google collaborated with Adobe and Android 2.2 Froyo fully supports Flash. That‟s to say, not only flash media, but all flash web pages can display perfectly on Android. To the contrary, Apple turned down Adobe and take HTML5 as iPhone‟s web protocol, making it unable to show some flash based animation.Android 2.2 Froyo also leads the way in network sharing. Smart phone with Froyo can be connected toa PC as a 3G NIC, and can also conveniently convert 3G signal to Wi-Fi. iOS 4 can do the first too, butfailed to convert 3G to Wi-Fi.Video conference is both supported by Froyo and iOS 4, but the conditions are different. You can see aFroyo user via camera as long as you get a camera also. However, iOS 4 user can only do video talk toanother iOS 4 user, which is a big limitation.While Android is ascendant in network interaction, Apple is unique in its friendship and entertainment.The added feature of …software classification‟ enables user to place sorted softwares into differentdocuments, making it clearer to manage. What‟s more, there‟re hundreds of thousands applications inApp Store, meaning that iPhone can have up to hundreds of thousands functions. This is a ratherremarkable feature that Apple publicizes.And the most convincing point given by Apple, is that …Android looks exactly familiar with iPhone.‟Although it‟s just a subjective sense, the born of iPhone really brought big revolution to the phone industry, and the name …Apple‟ itself is a world famous brand [7] [8].3. Open and Closed platforms3.1. SDKThe most important part of every developing platform is SDK, enable 3rd party developers to make software for the platform. Usually, libraries, debug tools and emulators are included in SDK. Different platforms distribute their SDKs differently. Some SDK is complete free and open, while others are strictly limited.Developers of open platforms can get and modify part or all of the source code. Google and Linux are leaders of open platforms; they publicized the whole sourcecode of Android and Linux. The good point is that, platform owners can save a great amount of time and energy developing and maintaining the platform, because 3rd party developers will do this for them. With less money spent on development and maintenance, a relatively low price can attract more and more phone users.Contrarily, closed platforms lock their source code in the safety and forbid 3rd party accesses. Apple and Microsoft are the representatives of them, they are both closed sourced, but some differences do exists. 3rd party iPhone applications are restricted within narrow limits, for that Apple will look through every application which is uploaded onto …App Store‟, and a lot of applications are turned down.Microsoft don‟t check Windows applications at all, it all depends on the users themselves. You installed the mareware, you suffer the loss.3.2. Application MarketMarket is the medium between de velopers and users, hence it‟s very important. Some predicted that there will be more and more application markets while some don‟t think so. In current markets, both do exist. Some specify only one market for their products, while others sell their softwares in various markets.Softwares from Nokia, Microsoft and Linux Mobile are sold in every market. Developers of these platforms can release their own application in whatever markets, so markets have to compete with each other for a living. This is good for users. However, the lack of universal management may lead to mess and chaos, softwares that have the same functionality exist in different markets, which confuses users a lot.Correspondingly, sole markets claim that most applications should be sold in them. This kind of monopolization leads to no competitor. …App Store‟ and ‟Android Market‟ are deputy of sole markets. Normally, iPhone applications can only be found in …App Store‟, and Apple will check every one of them by itself. Good news is that every application in …App Store‟ is officially tested, it‟s safe; Bad news is that a lot of pretty good softwares are rejected for various reasons. And a big unofficial mechanism is built by hackers, that is …jailbreak‟ and …SIM unlock‟.…Jailbreak‟ is a process that allows iPad, iPhone and iPod Touch users to gain root access and unlock the operating system thus removing any limitations imposed upon them by Apple. Once jailbroken, iPhone users are able to download many extensions and themes previously unavailable through the App Store via installers such as Cydia. A jailbroken iPad, iPhone or iPod Touch is still able to use the App Store and iTunes [9].And a …SIM lock‟ is a capability built into GSM phones by mobile phonemanufacturers. Networkproviders use this capability to restrict the use of these phones to specific countries and network providers.Generally, phones can be locked to accept only SIM cards based on the International Mobile Subscriber Identity. …SIM unlock‟ make it possible to use a mobile phone without considering countries and networks specified by mobile phone manufacturers.However in Android, Google doesn‟t test every application at all, so although there‟s an official market for Android applications, you can still release your product anywhere you want. Considering security problems, Google banned the use of some components. Like …jailbreak‟ and …SIM unlock‟ in iPhone, …root‟ in Android gives users 100% control of their devices, along with some security risks. …Root‟ is a process that allows users of cellphones running the Android operating system to attain privileged control (known as "root access") within Android's Linux subsystem, similar to jailbreaking on Apple devices running the iOS operating system, overcoming limitations that the carriers and manufacturers put on such phones. Rooting makes it possible to use custom versions of the Android system such as CyanogenMod, supporting features unavailable in stock ROMs. It also allows for newer versions of Android not supplied by the original device manufacturer. In contrast to iOS jailbreaking, rooting is not needed to run applications not distributed by the official Android Market. It is needed however, when trying to access paid Android applications from countries which are not part of the paid applications market.3.3. IntegrationSome companies focus only on their core industry, i.e. develop an operating system and provide an environment for 3rd party development. Others not only do these, but manage the process of developing a software to publicizing it. Depending on the integration of platforms, we sort them to 4 kinds: full integration platform, market integration platform, device integration platform and no integration platform.The publicizing model of full integration platform is very strict. Its management ranges from device manufacturing to application release, whose representative is Apple. Apple‟s factory produces iPhone,Apple‟s …App Store‟ sells application, Apple‟s …iTunes‟ is the channel of Apple‟s resources. The whole process is under Apple‟s control.Market integration platforms commit themselves to developing and selling softwares. Google is one of them. Unlike apple, Google don‟t have a factory tomanufacture its own handsets, but only developed Android and set up …Android M arket‟ for Android applications. However, companies like Google definitely have the capability to produce its own devices. Google is in good relationship with HTC, who is the OEM of T-Mobile, O2 and Orange, etc.Device integration platforms produce their o wn handsets, but don‟t set up application markets. Forexample, RIM makes Blackberry, but there‟s no official application market for Blackberry. No integration platforms do few things. Microsoft neither makes mobile phones, nor sets up a market.What they do is only developing the operating system: Windows Phone 7.4. ConclusionRepresentatives of open and closed platforms, Android 2.2 Froyo and iOS 4 are both loved and hated.Great browsers are built into them, and their producers are both world famous revolutionary. Android leans to Internet experience, which comes down in one continuous line with Google. But currently, various versions of Android fill the market, and most companies in Open Handset Alliance tend to customize their own Android systems. These facts make Android lack of a general brand image, so people may feel confused and say …No‟ to Android. iPhone OS focuses more on entertainment and it‟s very friendly. But Apple is too cool to attract more customers: Diehard fans of Steve Jobs buy every product made by Apple, and people who dislike the style Apple do things may just sniffed at Apple.Besides, Android 2.2 Froyo succeeds the features of open platforms well. It‟s a …users only‟ platform, because users of Froyo can almost customize everything they want. And members of Open HandsetAlliance tend to provide more choices for users. And iOS 4, typically closed platform member, manages everything ranging from OS development to device manufacturing. It‟s a …consider for users‟ platform.To some extent, u sers of Android canonizes …free‟ and …open‟, what they care is if they have 100% management of their handsets, no matter whether the OS is called …Android‟ or …Another‟. Apple users are loyal to the brand; they would like to authorize Apple to make decisions for them. So although some iPhone users love physical keyboards, they bought iPhone. In other words, Android users think a lot of …open platform‟ rather than the brand Google; most iPhone users are follower of Apple, they love the …closed platforms‟ cre ated by Steve Jobs.Both Android and iPhone have their unique IDE, SDK and other characteristics. Believe it or not, no perfection exists in the world, so none of today‟s mobileplatforms fully meets the needs of users and researchers. The choice of platform boils down to the needs of users and researchers, this article should make the decision easier. Of course the content of this article is time sensitive; platforms will gradually meet the demands of consumers as new technologies emerging.References[1] Dave Mark, Jeff LaMarche. “Beginning iPhone 3 Development: Exploring the iPhone SDK”. 2009.[2] Erica Sadun. “The iPhone Developer‟s Cookbook: Building Application with the iPhone SDK”, 2009.[3] Ed Burnette. “Hello, Android: Introducing Google‟s Mobile De velopment Platform”, 2009.[4] W.Frank Ableson, Charlie Collins, Robi Sen. “Unlocking Android: A Developer‟s Guide”, 2010.[5] Hee- Yeon Cho, Choon- Sung Nam, Dong- Ryeol Shin. “A Comparison of Open and Closed Mobile Platforms”.International Conference on Electronics and Information Engineering, 2010.[6] Ryan C. McKeen, Finis R. Price III. “DROID v iPHONE”. ABA Journal, 2010.[7] Mies Ginny, Sullivan Mark. “iPhone 4 vs. Droid X: A Head-to-Head Comparison”. PC World, 2010.[8] Fleishman, Glenn. “More Options With Tomorrow's Cell Phones”. PC World, 2008.[9] Keller, Mike. “Jailbreaking Your iPhone: The Pros and Cons”. PC World, 2010.分析和比较开放和封闭的移动平台摘要随着Android 2.2 Froyo和iPhone 4版本的发布，开放式和封闭式的移动平台之间的战争愈演愈烈。
安卓系统文件中英文对照
安卓系统文件中英文对照安卓系统文件中英文对照，给你的手机减减肥吧。
来源：石小田的日志模拟安卓机身内存里的\system\app，app文件夹里就是装系统自带的文件。
将那些不要的，也用不到的删了。
速度提升很明显的【文件夹功能简介】\system\app这个里面主要存放的是常规下载的应用程序，可以看到都是以APK格式结尾的文件。
在这个文件夹下的程序为系统默认的组件，自己安装的软件将不会出现在这里，而是\data\文件夹中。
\system\bin这个目录下的文件都是系统的本地程序，从bin文件夹名称可以看出是binary二进制的程序，里面主要是Linux系统自带的组件(命令)\system\etc从文件夹名称来看保存的都是系统的配置文件，比如APN接入点设置等核心配置。
\system\fonts字体文件夹，除了标准字体和粗体、斜体外可以看到文件体积最大的可能是中文字库，或一些unicode字库，从T-Mobile G1上可以清楚的看到显示简体中文正常，其中DroidSansFallback.ttf文件大小。
\system\frameworkframework主要是一些核心的文件，从后缀名为jar可以看出是是系统平台框架。
\system\liblib目录中存放的主要是系统底层库，一些so文件，如平台运行时库。
\system\media\system\media\audio铃声音乐文件夹，除了常规的铃声外还有一些系统提示事件音。
\system\sounds默认的音乐测试文件，仅有一个test.mid文件，用于播放测试的文件。
\system\usr用户文件夹，包含共享、键盘布局、时间区域文件等。
---------------------------------------------------------------------------------------------------------------------------------下面是app文件夹里面的程序的中英文对照表：注：带*号的千万不能删*AccountAndSyncSettings.apk 同步与帐户设定*ApplicationsProvider.apk 应用程序支持服务Bluetooth.apk 蓝牙（删了就没有蓝牙了）Browser.apk 谷歌浏览器（喜欢UC的可用UC替代）Calculator.apk 计算器（自带计算器较弱，可用其他替代）Calendar.apk 日历（不用日历的可删）CalendarProvider.apk 日历程序支持服务（不用日历的可删）Camera.apk 自带相机（用360的可删）*CertInstaller.apk 证书服务ChsPack.apk touchpal输入法拼音语言包（可删）－ChtPack.apk touchpal输入法注音语言包（从来不用注音的删）Contacts.apk 通讯录/联系人（用第三方通讯录的可删）*ContactsProvider.apk 通讯录/联系人数据存储服务*DefaultContainerService.apk 默认通讯录服务DeskClock.apk 自带闹钟（用第三方闹钟的可删）*DownloadProvider.apk 下载管理器*DrmProvider.apk DRM受保护数据存储服务Email.apk Email（不用自带email接受邮件的可删）－facebook.apk facebook(用不到的删)fmradio.apk 收音机（可删）Gallery.apk 相机相框（可删）GenieWidget.apk 天气与新闻（我自己不用他看新闻，删了）Gmail.apk Gmail邮件（可删）GoogleBackupTransport.apk 谷歌备份（可删）GoogleCalendarSyncAdapter.apk 谷歌日历同步适配器（可删）GoogleContactsSyncAdapter.apk 谷歌联系人同步适配器（删了，好像不能拷贝SIM卡联系人了）GoogleFeedback.apk 谷歌反馈（可删）GooglePartnerSetup.apk Google合作伙伴设置（可删）GoogleQuickSearchBox.apk 谷歌搜索（删了影响到桌面的搜索插件）GoogleServicesFramework.apk 谷歌同步支持服务框架（删了不能同步联系人，不能登录google）HTMLViewer.apk HTML浏览器（本地看html，用不到可删）HWCalla_TaiWan.apk 繁体中文手写输入法(可写简体的，不用手写的可删)LatinIME.apk android键盘输入法(可删)LatinImeTutorial.apk android键盘输入法设置(可删)Launcher2.apk 2.2原生桌面（用ADW和PRO的可删，删了以后第三方桌面要在开机以后从电脑安装，91，豌豆助手都可）LiveWall**s.apk 动态壁纸（可删）LiveWall**sPicker.apk 同上动态壁纸（可删）Maps.apk Google地图（可删，自行换成brust版本）MarketUpdater.apk 谷歌市场升级（软件更新用到，可删）*MediaProvider.apk 媒体数据存储服务MediaUploader.apk 媒体上传（可删）MMITest_II.apk 工程模式里用到的手机测试程序(可删)Mms.apk 自带信息（可删，用第三方短信的就删了吧，提示：删了后，用handsms的的弹出短信框会变得延时，chomp没自带短信甚至不能使用）Music.apk 自带音乐（可删，换成其他播放器）NetworkLocation.apk 网络位置（可删）NotePad.apk 记事本(可删)*PackageInstaller.apk 程序安装*Phone.apk 电话拨号程序PicoTts.apk 可删（文字语言转换的语音合成引擎，设置-语音输入与输出中）ProjectMenuAct.apk 工程菜单-Protips.apk 桌面小绿人插件（可删，就是有提示怎么玩手机）*Settings.apk 系统设置*SettingsProvider.apk 设置服务程序SetupWizard.apk 开机引导(在定制rom时不可删，刷好机可用rootexplorer删掉,恢复出厂前要装回去)SoundRecorder.apk 录音机（可用第三方录音软件替代）Stk.apk sim卡服务（可删，有机油把联系人复制在sim卡上的就不要删它，删了可解决信号问题）Street.apk 谷歌街道（可删，对于国内街道无效果的貌似，与地图关联）Superuser.apk 授权程序（就是程序列表上面那个，用这个获取root才有的）Talk.apk 谷歌talk（可删，但删了就用不了电子市场）*TelephonyProvider.apk 拨号记录存储服务TouchPal.apk TouchPal输入法(可删,但自带的三种输入法最好至少保留一种) TtsService.apk Google TTS(Text-to-speech)语音库服务(可删)-TwidroydFree342-Huawei-rev1.apk twitter客户端(不用的删了)Updataonline.apk 在线升级（可删）UserDictionaryProvider.apk 用户数据字典服务（可删）V ending.apk 电子市场（可删，不过不建议，很多软件的自动升级时候有它很方便）-VisualizationWall**s.apk 动态音乐背景壁纸(删了)V oiceSearch.apk 语音搜索（可删，虽然看上去很美好，事实上我从未用过）VpnServices.apk VPN服务（vpn服务，可删）-Y ouTube.apk Y ouTube视频(要vpn才能看,删了)googlevoice。
Android外文文献翻译11
Android Application Fundamentals nguage pil.th.code—alon.wit.an.dat.an.resourc.files—int.an Androi.package.a.archiv.an .apk suffix.Al.th.cod.i..single .apk.considere.t.b.on. applicatio.an.i.th..t.instal.th.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.e .I.(e.onl.b.th.syste.an.i.unknow.t.th.application). Th.syste.set.permission.fo.al.th.file.i.a.applicatio.s.tha.o e.I.assigne.t.tha.applicatio.ca.acces.them.Each process has its own virtual machine (VM), so an application's code runs in isolation from other applications.B.default.ever.applicatio.run.i.it.ow.Linu.process.Androi.st art.th.proces.whe.an.o.th.application'.component.nee.t.b.exe cuted.the.shut.dow.th.proces.whe.it'.n.longe.neede.o.whe.th. syste.mus.recove.memor.fo.othe.applications.I.thi.way.th.Androi.syste.implement.the principl.o.leas.pri vilege.Tha.is.eac.application.b.default.ha.acces.onl.t.th.co mponent.tha.i.require.t.d.it.wor.an.n.more.Thi.create..ver.s ecur.environmen.i.whic.a.applicatio.canno.acces.part.o.th.sy ste.fo.whic.i.i.no.give.permission.However, there are ways for an application to share data with other applications and for an application to access system services:It'.possibl.t.arrang.fo.tw.application.t.shar.th.sam.Lin e.ID.i.whic.cas.the.ar.abl.t.acces.eac.other'.files.T.co e.I.ca.als.ar rang.t.ru.i.th.sam.Linu.proces.an.shar.th.sam.V.(th.applicat ion.mus.als.b.signe.wit.th.sam.certificate).A.applicatio.ca.reques.permissio.t.acces.devic.dat.suc.a.th. user'.contacts.SM.messages.th.mountabl.storag.(S.card).camer a.Bluetooth.an.more.Al.applicatio.permission.mus.b.grante.b. e.a.instal.time.Tha.cover.th.basic.regardin.ho.a.Androi.applicatio.exist .withi.th.system.Th.res.o.thi.documen.introduce.yo.to:1.The core framework components that define your application.2.The manifest which you declare components and required device features for your application.3、Resource.tha.ar.separat.fro.th.applicatio.cod.an.allo.you.ap plicatio.t.gracefull.optimiz.it.behavio.fo..variet.o.devic.c onfigurations.Application Componentsponent.ar.th.essentia.buildin.block.o.a. ponen.i..differen.poin.throug.whic ponent.ar.actua.e e.an.som.depen.o.eac.other.bu.eac.on.exist .a.it.ow.entit.an.play..specifi.role—eac.on.i..uniqu.buildin.bloc.tha.help.defin.you.application' .overal.behavior.ponents.Eac.ty p.serve..distinc.purpos.an.ha..distinc.lifecycl.tha.define.h ponen.i.create.an.destroyed.Here are the four types of application components: ActivitiesAn activity e.interface. Fo.example.a.emai.applicatio.migh.hav.on.activit.tha.show..l pos.a.email.an.anothe.activit.fo.readin.emails.Althoug.th.activitie.wor.togethe.t.for e.experienc.i.th.emai.application.eac.on.i.indep enden.o.th.others.A.such..differen.applicatio.ca.star.an.on. o.thes.activitie.(i.th.emai.applicatio.allow.it).Fo.example. .camer.applicatio.ca.star.th.activit.i.th.emai.applicatio.th e.t.shar..picture.An activity is implemented as a subclass of Activity and you can learn more about it in the Activities developer guide. ServicesA service ponen.tha.run.i.th.backgroun.t.perfor. long-runnin.operation.o.t.perfor.wor.fo.remot.processes..ser e.interface.Fo.example..servic.migh.pla e.i.i..differen.application.o e.interactio ponent.suc.a.a.activity.ca.star.th .servic.an.le.i.ru.o.bin.t.i.i.orde.t.interac.wit.it.A service is implemented as a subclass of Service and you can learn more about it in the Services developer guide. Content providersA conten.provider manage..share.se.o.applicatio.data.Y o.ca.stor.th.dat.i.th..a.SQLit.database.o.th.web.o.an.othe.p ersisten.storag.locatio.you.applicatio.ca.access.Throug.th.conten.provider.othe.application.ca.quer.o.eve.modif.th.dat.( i.th.conten.provide.allow.it).Fo.example.th.Androi.syste.pro er'rmation.A.such.an.applicatio.wit.th.prope.permission.ca.quer.par.o.t h.conten.provide.(suc.as ContactsContract.Data.t.rea.an.wri rmatio.abou..particula.person.efu.fo.readin.an.writin.dat.tha .i.privat.t.you.applicatio.an.no.shared.Fo.example.the Not. Pad e..conten.provide.t.sav.notes..conten.provide.i.implemente.a..subclas.of ContentProvider an.mus.implemen..standar.se.o.API.tha.enabl.othe.applicati rmation.se.the Conten.P roviders develope.guide.Broadcast receiversA broadcas.receiver ponen.tha.respond.t.system-w id.broadcas.announcements.Man.broadcast.originat.fro.th.syst em—fo.example..broadcas.announcin.tha.th.scree.ha.turne.off.th. batter.i.low.o..pictur.wa.captured.Application.ca.als.initia t.broadcasts—fo.example.t.le.othe.application.kno.tha.som.dat.ha.bee.down e.Althoug.broadcas .receiver.don'e.interface.the.may creat..statu.ba.notification e.whe..broadcas.even.occurs.Mor. commonly.though..broadcas.receive.i.jus.." ponent.an.i.intende.t.d..ver.minima.amoun.o.work.Fo.instance .i.migh.initiat..servic.t.perfor.som.wor.base.o.th.event. .broadcas.receive.i.implemente.a..subclas.of BroadcastRecei ver an.eac.broadcas.i.delivere.a.an Intent object.Fo.mor. information.se.th.BroadcastReceiver class..uniqu.aspec.o.th.Androi.syste.desig.i.tha.an.applicatio. ca.star.anothe.application’.component.Fo.example.i.yo.wan.t e.t.captur..phot.wit.th.devic.camera.there'.probabl.anot .it.instea. o.developin.a.activit.t.captur..phot.yourself.Yo.don'.nee.t. incorporat.o.eve.lin.t.th.cod.fro.th.camer.application.Inste ad.yo.ca.simpl.star.th.activit.i.th.camer.applicatio.tha.cap plete.th.phot.i.eve.returne.t.you.applica er.i.seem.a.i.th.camer.i.actuall..p ar.o.you.application.ponent.i.start.th.proces.fo.tha.ap plicatio.(i.it'.no.alread.running.an.instantiate.th.classe.n ponent.Fo.example.i.you.applicatio.start.th.ac tivit.i.th.camer.applicatio.tha.capture..photo.tha.activit.r un.i.th.proces.tha.belong.t.th.camer.application.no.i.you.application'.process.Therefore.unlik.application.o.mos.othe.sy stems.Androi.application.don'.hav..singl.entr.poin.(there'.n o main() function.fo.example).Becaus.th.syste.run.eac.applicatio.i..separat.proces.wit. tha.restric.acces.t.othe.applications.you.applicatio.canno.d ponen.fro.anothe.application.Th.Androi.sy ponen.i.anothe.application .yo.mus.delive..messag.t.th.syste.tha.specifie.your intent ponen.fo.you.Activating Componentsponen.types—activities.services.an.broadcas.receivers—ar.activate.b.a.asynchronou.messag.calle.an intent.Intent.b ponent.t.eac.othe.a.runtim.(yo.ca.thin.o.the ponents).whet ponen.belong.t.you.applicatio.o.another.An intent is created with an Intent object, which defines a message to activate either a specific component or a specific type of component—an intent can be either explicit or implicit, respectively.Fo.activitie.an.services.a.inten.define.th.actio.t.perfor .(fo.example.t."view.o."send.something.an.ma.specif.th.UR.o. th.dat.t.ac.o.(ponen.bein.starte.m igh.nee.t.know).Fo.example.a.inten.migh.conve..reques.fo.a.a ctivit.t.sho.a.imag.o.t.ope..we.page.I.som.cases.yo.ca.star.a.activit.t.receiv..result.i.whic.case.th.activit.als.return .th.resul.i.an Intent (fo.example.yo.ca.issu.a.inten.t.le. e.pic..persona.contac.an.hav.i.returne.t.you—th.retur.inten.include..UR.pointin.t.th.chose.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").ponen.type.conten.provider.i.no.activate.b. intents.Rather.i.i.activate.whe.targete.b..reques.fro.a Con tentResolver.Th.conten.resolve.handle.al.direc.transaction.w ponen.that'.performin.trans action.wit.th.provide.doesn'.nee.t.an.instea.call.method.o.t he ContentResolver ye.o.abstractio.bet rmatio.(f o.security).There are separate methods for activating each type of component:You can start an activity (or give it something new to do) by passingan Intent to startActivity()or startActivityForResult( )(when you want the activity to return a result).Yo.ca.star..servic.(o.giv.ne.instruction.t.a.ongoin.serv ice.b.passin.an Intent to startService().O.yo.ca.bin.t.th .servic.b.passin.an Intent tobindService().You can initiate a broadcast by passing an Intent to methods like sendBroadcast(), sendOrderedBroadcast(),or sendStickyBroadcast().You can perform a query to a content provider bycalling query()on a ContentResolver.in.intents.se.the Intent.an.Inten .Filters ponent.i.als.provide.i.th.followin.documents: Activities, Services, BroadcastReceiver and Conten.Providers.Declaring components<?xm.version="1.0.encoding="utf-8"?><manifes....>..<applicatio.android:icon="@drawable/app_icon.png....> ....<activit.android:name="com.example.project.ExampleActivi ty".........android:label="@string/example_label....>....</activity>.........</application></manifest>In the <application>element, theandroid:icon attribute points to resources for an icon that identifies the application.In the <activity>element, the android:name at tribute specifies the fu lly qualified class name of theActivity subclass and the android:label attributes specifies a string to use as the user-visible label for the activity.You must declare all application components this way:1.<activity> elements for activities2.<service> elements for services3.<receiver> elements for broadcast receivers4.<provider> elements for content providersActivities.services.an.conten.provider.tha.yo.includ.i.yo u.sourc.bu.d.no.declar.i.th.manifes.ar.no.visibl.t.th.syste. and.consequently.ca.neve.run.However.broadcas.receiver.ca.b. eithe.declare.i.th.manifes.o.create.dynamicall.i.cod.(as Br oadcastReceiver objects.an.registere.wit.th.syste.b.callingregisterReceiver().Declaring component capabilitiesA.discusse.above.in .an In tent t.star.activities.services.an.broadcas.receivers.Yo.ca ponen.(ponen.c .i.th.intent.However.th.rea.powe.o.intent.lie.i.th.c oncep.o.inten.actions.Wit.inten.actions.yo.simpl.describ.th. typ.o.actio.yo.wan.t.perfor.(an.optionally.th.dat.upo.whic.y ou’ponen .o.th.devic.tha.ca.perfor.th.actio.an.star.it.I.ther.ar.mult ponent.tha.ca.perfor.th.actio.describe.b.th.intent.th e.The way the system identifies the components that can respond to an intent is by comparing the intent received to the intent filters provided in the manifest other applications on the device.ponen.i.you.application'.manifest.yo.ca .optionall.includ.inten.filter.tha.declar.th.capabilitie.o.t ponen.s.i.ca.respon.t.intent.fro.othe.applications.Yo.c ponen.b.addin.an <intent-f ilter> ponent'.declaratio.element.posin..n e.emai.migh.declar.a.inten.filte.i.it.manifes.entr.t.respon. t."send.intent.(i.orde.t.sen.email).A.activit.i.you.applicat io.ca.the.creat.a.inten.wit.th.“send.actio.(ACTION_SEND).whic.th.syste.matche.t.th.emai.ap plication’.“unche.i.whe.yo.invok.th.inten.with star tActivity().For more about creating intent filters, see the Intents and Intent Filters document.Declaring application requirementsTher.ar..variet.o.device.powere.b.Androi.an.no.al.o.the.p rovid.th.sam.feature.an.capabilities.I.orde.t.preven.you.app c.feature.neede.b.y ou.application.it'.importan.tha.yo.clearl.defin..pr.th.type. o.device.you.applicatio.support.b.declarin.devic.an.softwar. requirement.i.you.manifes.file.Mos.o.thes.declaration.ar.informationa.onl.an.th.syste.doe.no.rea.them.bu.externa.service er. whe.the.searc.fo.application.fro.thei.device.e.API.int roduce.i.Androi.2..(AP.Level 7).yo.shoul.declar.thes.a.requ irement.i.you.manifes.file.Tha.way.device.tha.do not hav.. camer.an.hav.a.Androi.version lower tha.2..canno.instal.yo u.applicatio.fro.Googl.Play.e.th.camera .bu.doe.not require it.I.tha.case.you.applicatio.mus.perfo r..chec.a.runtim.t.determin.i.th.devic.ha..camer.an.disabl.a .th.camer.i.on.i.no.available.Here are some of the important device characteristics that you should consider as you design and develop your application: Screen size and densityI.orde.t.categoriz.device.b.thei.scree.type.Androi.defin e.tw.characteristic.fo.eac.device.scree.siz.(th.physica.dime nsion.o.th.screen.an.scree.densit.(th.physica.densit.o.th.pi xel.o.th.screen.o.dpi—dot.pe.inch).T.simplif.al.th.differen.type.o.scree.configura tions.th.Androi.syste.generalize.the.int.selec.group.tha.mak .the.easie.t.target.The screen sizes are: small, normal, large, and extra large. The screen densities are: low density, medium density, high density, and extra high density.patibl.wit.al.scree.size.a n.densities.becaus.th.Androi.syste.make.th.appropriat.adjust you.an.imag.resources.However.yo.shoul.creat. yout.fo.certai.scree.size.an.provid.specialize. you.resources.an .b.declarin.i.you.manifes.exactl.whic.scree.size.you.applica tio.support.wit.the <supports-screens> element.For more information, see the Supporting Multiple Screens document.Input configurationse.inpu.mechanism.suc.a.. hardwar.keyboard..trackball.o..five-wa.navigatio.pad.I.you.a pplicatio.require..particula.kin.o.inpu.hardware.the.yo.shou l.declar.i.i.you.manifes.wit.the <uses-configuration> elem ent.However.i.i.rar.tha.a.applicatio.shoul.requir..certai.in pu.configuration.Device featuresTher.ar.man.hardwar.an.softwar.feature.tha.ma.o.ma.no.exis.o ..give.Android-powere.device.suc.a..camera..ligh.sensor.blue tooth..certai.versio.o.OpenGL.o.th.fidelit.o.th.touchscreen.Yo.shoul.neve.assum.tha..certai.featur.i.availabl.o.al.Andro id-powere.device.(othe.tha.th.availabilit.o.th.standar.Andro i.library)e.b.you.applicatio .wit.the <uses-feature> element.Platform VersionDifferen.Android-powere.device.ofte.ru.differen.version.o.th .Androi.platform.suc.a.Androi.1..o.Androi.2.3.Eac.successiv. versio.ofte.include.additiona.API.no.availabl.i.th.previou.v ersion.I.orde.t.indicat.whic.se.o.API.ar.available.eac.platf or.versio.specifie.an AP.Level (fo.example.Androi.1..i.AP. Leve..an.Androi.2..i.AP.Leve.9).an.API.tha.wer.adde. t.th.platfor.afte.versio.1.0.yo.shoul.declar.th.minimu.AP.Le in.the <uses-sdk> eleme nt.It'.importan.tha.yo.declar.al.suc.requirement.fo.you.appl ication.because.whe.yo.distribut.you.applicatio.o.Googl.Play e.thes.declaration.t.filte.whic.application.ar.av ailabl.o.eac.device.A.such.you.applicatio.shoul.b.availabl.o nl.t.device.tha.mee.al.you.applicatio.requirements.For more information about how Google Play filters applications based on these (and other) requirements, see the Filters on Google Play document.Application Resourcespose.o.mor.tha.jus.code—i.require.resource.tha.ar.separat.fro.th.sourc.code.suc.a.im ages.audi.files.an.anythin.relatin.t.th.visua.presentatio.o. th.application.Fo.example.yo.shoul.defin.animations.menus.st e.interface.wit.XM.files .Usin.applicatio.resource.make.i.eas.t.updat.variou.characte ristic.o.you.applicatio.withou.modifyin.cod.and—b.providin.set.o.alternativ.resources—enable.yo.t.optimiz.you.applicatio.fo..variet.o.devic.config uration.(nguage.an.scree.sizes).Fo.ever.resourc.tha.yo.includ.i.you.Androi.project.th.SD. .t.referenc.th .resourc.fro.you.applicatio.cod.o.fro.othe.resource.define.i .XML.Fo.example.i.you.applicatio.contain.a.imag. logo.png (save.i.the res/drawable/ directory).th.SD.tool.generat..r d .t.referenc.th. e.interface.On.o.th.mos.importan.aspect.o.providin.resource.separat.f ro.you.sourc.cod.i.th.abilit.fo.yo.t.provid.alternativ.resou rce.fo.differen.devic.configurations.Fo.example.b.definin.U. nguage.an.snguag.qualifie .tha.yo.appen.t.th.resourc.directory'.nam.(suc.as res/value s-fr/ er'.languag.setting.th. nguag.string.t.you.UI.Androi.support.man.different qualifiers fo.you.alternat iv.resources.Th.qualifie.i..shor.strin.tha.yo.includ.i.th.na m.o.you.resourc.directorie.i.orde.t.defin.th.devic.configura ed.A.anothe.example.yo.s yout.fo.you.activities.dependin.o .th.device'.scree.orientatio.an.size.Fo.example.whe.th.devic .scree.i.i.portrai.orientatio.(tall)you.wit. ndscap.orientatio. (wide)yo yout.a yout'.Th you.dependin .o.th.curren.devic.orientation.For more about the different kinds of resources you can include in your application and how to create alternative resources for various device configurations, see theApplication Resources developer guide.安卓应用基础在Java编程语言编写的Android应用程序的Android的SDK工具编译代码以及及任何数据和到一个Android的包, 一个归档文件档案资源的.apk后缀, 所有的在一个单一的代码.apk文件被认为是一个应用程序, 是Android的文件, 供电设备来安装应用程序。
基于Android平台的多语种文字识别翻译APP
基于Android平台的多语种文字识别翻译APP
张璘;唐瑞寒
【期刊名称】《厦门理工学院学报》
【年(卷),期】2017(25)5
【摘要】集成中、英、日、韩、法、西班牙6种世界主要语种,通过jTessBoxEditor OCR开发引擎自主生成训练文字库,利用Tesseract识别引擎对文字进行识别,并将已识别文字送入第三方翻译接口进行目标语种翻译,开发了一款基于Android平台的集成了多语种文字的拍照识别翻译软件APP.通过景区样本实测结果验证,该APP的文字识别率可达93%,实现有效翻译,达到市场准入水平.
【总页数】6页(P61-66)
【作者】张璘;唐瑞寒
【作者单位】厦门理工学院光电与通信工程学院, 福建厦门361024;厦门理工学院光电与通信工程学院, 福建厦门361024
【正文语种】中文
【中图分类】TP391.43
【相关文献】
1.一种基于Android平台的图像文字识别系统 [J], 赵思宁
2.基于文字识别与页面布局的APP控件识别算法 [J], 丁世举;顾乃杰;黄章进;侯津
3.畅玩儿去多语种、便携翻译App推荐 [J],
4.基于平行语料和翻译概率的多语种词对齐方法 [J], 杨飞扬; 赵亚慧; 崔荣一; 易志
伟
5.基于多模态输入的多语种实时翻译软件设计与实现 [J], 权朝臣;邓长明;袁凌云因版权原因，仅展示原文概要，查看原文内容请购买。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
本科毕业设计（论文）外文参考文献译文及原文学院信息工程学院专业测控技术与仪器（光机电一体化方向) 年级班别 2011级（1）班学号学生姓名指导教师2015年 6 月目录1应用程序基础 (1)1.1应用程序组件 (1)1.2激活组件：intent (3)1.3 关闭组件 (4)1.4manifest文件 (5)1.5Intent过滤器 (6)1.6基于XML的布局 (7)1Application Fundamentals (8)1.1 Application Components (8)1.2Activating components:intent (11)1.3 Shutting down components (12)1.4 The manifest file (13)1.5Intent filters (14)1.6XML-Based Layout (15)1 应用程序基础Android应用程序使用Java编程语言开发。
aapt工具把编译后的Java代码连同应用程序所需的其他数据和资源文件一起打包到一个Android包文件中，这个文件使用.apk作为扩展名。
此文件是分发并安装应用程序到移动设备的载体；是用户下载到他们的设备的文件。
单一.apk文件中的所有代码被认为是一个应用程序。
从多个角度来看，每个Android应用程序都存在于它自己的世界之中：1 默认情况下，每个应用程序均运行于它自己的Linux进程中。
当应用程序中的任何代码需要被执行时，Android启动此进程，而当不再需要此进程并且其它应用程序又请求系统资源时，则就关闭了这个进程。
2 每个进程都有其独有的虚拟机（VM），所以应用程序代码与所有其它应用程序代码是隔离运行的。
3 默认情况下，每个应用程序均被赋予一个唯一的Linux用户ID，并加以权限设置，使得应用程序的文件仅对此用户及此应用程序可见——尽管也有其它的方法使得这些文件同样能为其他应用程序所访问。
1.1 应用程序组件Android的一个核心的特性就是一个应用程序可以使用其它应用程序的元素（如果那个应用程序允许的话）。
例如，如果你的应用程序需要显示一个图片卷动列表，而另一个应用程序已经开发了一个合用的而又允许别的应用程序使用的话，你可以直接调用那个卷动列表来完成工作，而不用自己再开发一个。
你的应用程序并没有吸纳或链接其它应用程序的代码。
它只是在有需求的时候启动了其它应用程序的那个功能部分。
为达到这个目的，系统必须能够在一个应用程序的任何一部分被需要时启动一个此应用程序的进程，并将那个部分的Java对象实例化。
因此，不像其它大多数系统上的应用程序，Android应用程序并没有为应用程序提供一个单独的入口点（比如说，没有main()函数），而是为系统提供了可以实例化和运行所需的必备组件。
一共有四种组件类型：(1)Activityactivity是为用户操作而展示的可视化用户界面。
例如，一个activity可以展示一个菜单项列表供用户选择，戒者显示一些包含说明文字的照片。
一个短消息应用程序可以包括一个用于显示要发送消息到的联系人列表的activity，一个给选定的联系人写短信的activity以及翻阅以前的短信或改变设置的其他activity。
尽管它们一起组成了一个内聚的用户界面，但其中每个activity都不其它的保持独立。
每一个都实现为以Activity类为基类的子类。
一个应用程序可以只有一个activity，戒者，如刚才提到的短信应用程序那样，包含很多个。
每个activity的作用，以及有多少个activity，当然是取决于应用程序及其设计的。
一般情况下，总有一个应用程序被标记为用户在应用程序启动的时候第一个看到的。
从一个activity转向另一个靠的是用当前的activity启动下一个。
每个activity都被给予一个默认的窗口以进行绘制。
一般情况下，这个窗口是满屏的，但它也可以是一个小的位于其它窗口之上的浮动的窗口。
一个activity也可以使用附加的窗口——例如，一个在activity运行过程中弹出的供用户响应的对话框，这是一个当用户选择了屏幕上特定项目后显示的必要信息的窗口。
窗口显示的可视内容是由一系列层次化view构成的，这些view均继承自View 基类。
每个view均控制着窗口中一块特定的矩形区域。
父级view包含并组织其子view的布局。
叶节点view（位于层次结构最底端）在它们控制的矩形区域中进行绘制，并对用户直达其区域的操作做出响应。
因此，view是activity与用户进行交互的界面。
例如，view可以显示一个小图片，并在用户指点它的时候产生动作。
Android有一些预置的view供开发者使用——包括按钮、文本域、滚动条、菜单项、复选框等等。
view的层次结构是由Activity.setContentView() 方法放入activity的窗口之中的。
content view是位于层次结构根位置的View对象。
（参见独立的用户界面文档以获取关于view及层次结构的更多信息。
）(2) Serviceservice没有可视化的用户界面，而是在一段时间内在后台运行。
例如，一个service可以在用户做其它事情的时候在后台播放背景音乐、从网络上获取数据或者计算一些东西并提供给需要这个运算结果的activity使用。
每个service都继承自Service基类。
一个媒体播放器播放播放列表中的曲目是一个不错的例子。
播放器应用程序可能有一个或多个activity来给用户选择歌曲并进行播放。
然而，音乐播放这个任务本身丌应该由任何activity来处理，因为用户的期望即使在他们离开播放器的应用程序而已经在开始做别的事情时，音乐仍然在继续播放。
为达到这个目的，媒体播放器activity可以启动一个运行于后台的service服务。
系统将在这个activity不再显示于屏幕后，仍维持音乐播放的service的运行。
连接至（绑定到）一个正在运行的service（如果service没有运行，则启动之）是可能的。
连接之后，你可以通过那个service暴露出来的接口不service进行通讯。
对于音乐service来说，这个接口可以允许用户暂停、回退、停止以及重新开始播放。
如同activity和其它的组件一样，service服务运行于应用程序进程的主线程内。
所以它不会对其它组件或者用户界面有任何的妨碍作用，它们一般会派生一个新线程来执行一些时间消耗型任务（比如音乐回放和网络下载）。
参见稍后的进程和线程介绍。
(3) BroadcastReceiverbroadcast receiver是一个与注于接收广播通知信息，并做出相应处理的组件。
许多广播是由系统代码产生的——例如，通知时区改变、电池电量低、拍摄了一张照片或者用户改变了语言选项。
应用程序也可以发起广播——例如，通知其它应用程序一些数据已经下载到设备上并处于可用状态。
一个应用程序可以拥有任意数量的broadcast receiver，以对所有它认为重要的通知信息予以各种响应。
所有的receiver均继承自BroadcastReceiver基类。
broadcast receiver没有用户界面。
然而，它们可以启动一个activity或者service 来响应它们收到的信息，当然也可以使用NotificationManager来通知用户。
通知可以用多种方式来吸引用户的注意力──闪动背光灯、震动设备、播放声音等等。
通知一般是在状态栏上放一个持丽的图标，用户可以点击打开它并获取所要消息。
(4)Contentprovidercontent provider将一些特定的应用程序数据供给其它应用程序使用处理。
数据可以存储于文件系统、SQLite数据库或其它有意丿的方式。
content provider继承于ContentProvider 基类，实现了一套使得其他应用程序能够检索和存储它所管理的类型数据的标准方法。
然而，应用程序并不直接调用返些方法，而是使用一个ContentResolver 对象，调用它的方法作为替代。
ContentResolver可以与任何content provider进行会话；与其合作对任何相关的进程间通讯进行管理。
参阅独立的Content Providers文档以获得更多关于使用content provider的信息。
每当出现一个需要被特定组件处理的请求时，Android会确保那个组件的应用程序进程处于运行状态，必要时会启动它，并确保那个组件的一个合适的实例可用，必要时会创建那个实例。
1.2激活组件：intent当接收到ContentResolver发出的请求后，content provider被激活。
而其它三种组件——activity、service和broadcast receiver，被一种叫做intent的异步消息所激活。
intent是一个保存着消息内容的Intent对象。
对于activity和service来说，它指明了所请求的操作名称，并指定了用来操作的数据的URI和其它一些信息。
例如，它可以承载一个对一个activity的请求，让它为用户显示一张图片，或者让用户编辑一些文本。
而对于broadcast receiver来说，Intent对象指明了所通报的操作。
例如，它可以对所有感兴趣的对象通报照相按钮被按下。
对于每种组件来说，激活的方法也是不同的：1 通过传递一IntentContext.startActivity()Activity.startActivityForResult(以启动（或指定新工作给）另外一个activity。
相应的activity可以通过调用自身的getIntent() 方法来查看并且激活它的intent。
Android通过调用activity的onNewIntent()方法来传递给它随后的任何intent。
一个activity经常启动另一个activity。
如果它期望它所启动的那个activity返回一个结果，它会调用startActivityForResult()而不是startActivity()。
例如，如果它启动了另外一个activity以使用户挑选一张自己的照片，它也许想知道哪张照片被选中了。
其结果将会被封装在一个Intent对象中，并传递给发出调用的activity 的onActivityResult() 方法。
2 通过传递一个Intent对象至Context.startService()以启动一个service（或向正在运行的service给出一个新的指令）。
Android调用此service的onStart()方法并将Intent对象传递给它。