安卓系统的操作与应用外文文献翻译2014年译文3000字

合集下载

手机系统安卓系统中英文对照外文翻译文献

中英文对照外文翻译文献(文档含英文原文和中文翻译)译文：深入理解安卓系统的安全性下一代开放操作系统的主流将不会在桌面上，但是将会出现在我们每天携带的手机上。

这些开放性的环境将会带领这些新的应用可能集成这些已经存在的在线服务，当然随着日以具增的数据与服务在手机上的支持，手机上的安全缺陷也越发明显。

下一代操作系统本质在于是否提供一个完整综合的安全平台。

由开放手机联盟（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技术英文文献翻译

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的一个很重要的中心特征就是一个应用程序能充分利用其他的应用程序的一些组件（前提是被允许的）例如：如果的当前开发的应用需要一个滚动的列表去展示相片并且当时其他的程序已经开发了一个合适的滚动列表并且对其他人可用，你可以调用这个滚动的列表来完成你的工作而不是开发你自己的。

安卓应用开发中英文对照外文翻译文献

安卓应用开发中英文对照外文翻译文献(文档含英文原文和中文翻译)中英文翻译安卓应用开发基础在Java编程语言编写的Android应用程序的Android的SDK工具编译代码以及与任何数据和到一个Android的包，一个归档文件档案资源的.apk后缀，所有的在一个单一的代码.apk文件被认为是一个应用程序，是Android的文件，供电设备来安装应用程序。

一旦安装在设备上，每个Android应用程序的生命在它自己的安全沙箱：而Android操作系统是一个多用户Linux系统中，每个应用程序是一个不同的用户。

默认情况下，每个应用程序的系统分配一个唯一的Linux用户ID （该ID仅用于由系统是未知的应用程序），系统设置所有的应用程序中的文件权限，以便只有用户ID分配给该应用程序可以访问它们。

每个进程都有它自己的虚拟机（VM），因此应用程序的代码在从其他应用程序隔离运行。

默认情况下，每个应用程序运行在它自己的Linux进程。

Android 的启动过程时，应用程序的任何组件需要被执行，然后关闭该进程时，它不再需要或恢复时，系统必须为其他应用程序的内存。

这样一来，Android系统实现了最小特权原则，也就是说，每个应用程序，默认情况下，只能访问的组件，它需要做的工作，没有更多，这将创建一个非常安全的环境，使应用程序无法访问的，这就是它没有给予许可制度的部分。

但是，有一个应用程序的方法与其他应用程序和应用程序访问系统服务的数据：这有可能为两个应用程序安排共享相同的Linux用户ID，在这种情况下，它们能够相互访问的文件。

为了节约使用相同的用户ID系统资源，应用程序还可以安排运行在相同的Linux进程和共享同一个VM （应用也必须使用相同的证书签名）。

应用程序可以请求访问权限，如用户的联系人，短信，可安装存储（SD卡），摄像头，蓝牙等设备的数据，所有应用程序的权限必须由用户在安装时授予。

这涵盖了基本就如何Android应用程序在系统中存在这个文件的其余部分向您介绍：1、框架的核心组件定义应用程序。

A Study on the Performance of Android Platform(外文翻译)

外文翻译题目安卓平台性能研究A Study on the Performance of AndroidPlatform姓名学号专业计算机科学与技术学制四年指导教师职称/学位讲师/硕士中国·武汉二○一七年一月安卓平台性能研究原文来源：Hyeon-Ju Yoon. A Study on the Performance of Android Platform. International Journal on Computer Science and Engineering. 2014: 532-537摘要由于Android平台广泛应用于包括智能移动设备在内的嵌入式系统设备，所以系统性能分析的需求显着增加。

系统性能通常由基准测试仪和剖析仪软件来测量。

我们使用基准应用程序和公共资料软件研究了Android平台的性能。

对于更多的细节和综合的性能分析，我们提出了一个Android平台的分析架构。

关键词安卓；性能；基准；剖析；1 引言智能手机和平板电脑让我们的生活发生了巨大变化。

最流行的智能设备操作系统是苹果的iOS和Google的Android。

由于Android是开源软件，并为开发人员提供免费的平台来制作自己的应用程序，许多硬件厂商都采用Android，市场份额也在不断增加。

即使平台是通用的，具有相同的软件功能，实际的性能随着硬件和其他软件组件的不同而不同。

所以每个硬件和软件开发人员都在努力实现更高的优化性能。

要发布智能手机产品的一些优选的软件，开发人员应该详细估计性能，以纠正或减少弱点。

在本文中，我们研究了两种用于测量系统性能，基准测试和分析软件的软件工具。

基准测试对于评估和估计每个设备和整个系统的相对水平非常有用，因此可以帮助我们选择硬件或调整系统变量以实现更高的性能。

分析软件跟踪程序活动并收集有关函数调用，内存使用，进程和通信的信息。

在分别引入代表性的基准和配置文件软件之后，我们提出了对标准工具的修改，并显示了简单的性能分析结果。

Android毕设外文资料和译文

东北大学东软信息学院专业：计算机科学与技术（嵌入式软件开发方向）班级：计嵌入式000000姓名：XXXX学号：08111XXXXX指导教师：XXXX 教授2011 年12 月18 日译文这篇文档主要讲述 An droid 应用框架的核心原则。

站在高层来说，以用户为中心来设计良好的交互程序，对于应用设计者或是开发者来说是非常重要的。

下面用例子来阐述了 activities 和tasks 的一些底层原则和机制，例如导航，多任务，activity 重用，意图和activity栈。

这篇文档也着重讨论了一些设计决策，针对如何利用好它们去设计你的应用程序UI 。

这篇文档中的例子均是An droid 应用程序，包括默认应用程序（比如拨号器）、Google应用程序（比如地图）。

你可以自己在 An droid 模拟器上或是 An droid 手机上去试验这些例子。

如果你使用An droid 手机试验时，可能未提供本文档中的某些例子。

App lications, Activities, Activity Stack and Tasks理解An droid 系统中的四个基本概念对你是很有帮助的，它们分别是：App licati ons （应用）Activities（活动）Activity Stack （活动堆栈）Tasks （任务）App licati ons一个An droid 应用程序其实就是由一个或者多个Activity 组成。

它们被捆绑在一起并存放进.apk 文件中，这就是 An droid 应用程序。

An droid 中有着丰富的应用程序，比如邮件、日历、地图定位、文本消息、联系人、照相机、打电话、音乐播放器，系统设置等应用。

一般情况下，桌面上都会有 An droid 应用程序快捷图标，用户可以选择某一个图标来启动应用程序。

ActivitiesActivity 是An droid 应用程序的主要组成部分，activity 可以是你自己创建的，当然, 。

外文翻译安卓

lder namedsrc. This is the source code folder for the given sample application. Youcan use this to view, edit,and recompile the code for any of the applications. Takeadvantage of this source code to learn some tricks and tips about the Android platform.Android ToolsThe Android SDK supplies developers with a number of powerful and useful tools.Throughoutthis book, you will use only a handful of them directly. This section takes aquick look at just afew of these tools, which will be covered in much more depth in thefollowing chapters, as youdive into command-line development.NOTEFor more detailed information about the other tools included in the Android SDK,consult the Android doc files.emulator.exeArguably one of the most important tools included in the Android SDK is emulator.exe.emulator.exe launches the Android Emulator. The Android Emulator is used toyou're yourapplications in a pseudo-Android environment. Given that, as of the writing of this book,therewere no hardware devices yet released for the Android platform, emulator.exe isgoing to be your only means to test applications on a “native” platform.You can run emulator.exe from the command line or execute it from within Eclipse.In this book, you’ll usually let Eclipse launch the Android Emulator environment for you.However, in theinterest of giving you all the information you need to program with theAndroid SDK outside of Eclipse, Chapter 6 covers command-line usage of emulator.exewhen you create your Hello World! applications.When using the Android Emulator to test your applications, you have two choices fornavigatingthe user interface. First, the emulator comes with usable buttons, as shown inFigure 4-1. You can use these buttons to navigate Android and any applications that youdevelop for the platform.TIPThe Power On/Off, V olume Up, and V olume Down buttons are slightly hidden to thesides of the virtual device. They identify themselves when you hover the mouse pointerover them.Given that many higher-end phones now include a touch screen, the second inputchoice you have when using the emulator is a simulated touch screen. You use yourmouse as a stylus. The objects on the emulator’s screen can be interacted with usingthe mouse.adb.exeAnother tool that will become very useful to you when you are using command-lineprogrammingis Android Debug Bridge or adb (adb.exe). This tool allows you to issuecommands to the Emulator.exe tool. When you are working in a command-lineenvironment, the adb tool allows you to do the following:● Start and stop the ser ver● Install and uninstall applications● Move files to and from the emulatorMKSDCARD.exeMKSDCARD.exe is a very useful tool if you are testing an application that will needto read orwrite files to or from an SD Memory Card inserted into the mobile device.MKSDCARD.execreates a small partition drive on your drive that will hold and retainthetest files. The emulatorwill treat this partition like an SD Memory Card.DX.exeDX.exe is the compiler of the Android SDK. When run against your Java files, DX.exewill createfiles with .dex extensions—Dalvik executable format. These files are in thecorrect format to beunderstood by, and run on, an Android device.NOTEAndroid executable files are called Dalvik executable files as a reference to the Dalvikvirtual machine that Android used to run all applications. The Dalvik virtual machineruns each application in its own thread with the same priority as core Androidapplications. activityCreator(.bat or .pn)activityCreator is a simple command-line tool that is used to set up a basic developmentenvironment. When run from the command line, activityCreator will set up the shell filesneeded to create a basic Android application. Having these shell files is especially usefulif you are not using Eclipse. The Android plugin for Eclipse sets up these shell files foryou by calling the activityCreator when you create a new project.Depending on what type of environment you are running, you will see theactivityCreator represented by a different type of script file. If you are in a Windowsenvironment, this will be a .bat file; otherwise it will be a python (.pn) script. Yousimply execute the script, which in turn calls the actual activityCreator process withthe correct parameters.APIsThe API, or application programming interface, is the core of the Android SDK. An APIis a collection of functions, methods, properties, classes, and libraries that is used byapplication developers to create programs that work on specific platforms. The AndroidAPI contains all thespecific information that you need to create applications that canwork on and interact with an Android-based application.The Android SDK also contains two supplementary sets of APIs—the Google APIsand the Optional APIs. Subsequent chapters will focus much more on these APIs as youbegin writingapplications that utilize them. For now, take a quick look at what theyinclude so that you are familiar with their uses.Google API sThe Google APIs are included in the Android SDK and contain the programmingreferences that allow you to tie your applications into existing Google services. If youare writing an Androidapplication and want to allow your user to access Google servicesthrough your application, you need to include the Google API.Located in the android.jar file, the Google API is contained within the com.google.*package. There are quite a few packages that are included with the Google API. Some ofthe packages that are shipped in the Google API include those for graphics, portability,contacts, and calendar utilities. However, the packages devoted to Google Maps will bethe primary focus in this book. Using the com.google.android.maps package, which contains information for GoogleMaps, you can create applications that interact seamlessly with the already familiarinterface of Google Maps. This one set of packages opens a whole world of usefulapplications just waiting to be created.The Google API also contains a useful set of packages that allows you to takeadvantage of the newer Extensible Messaging and Presence Protocol (XMPP) developedby the Jabber open source community. Using XMPP, applications can quickly becomeaware of other clients’ presence andavailability for the purpose of messaging andcommunications. The API packages dealing with XMPP are very useful if you wantto create a “chat”-style program that utilizes the phone messaging capabilities.Optional APIsThe Android SDK includes a number of Optional APIs that cover functionality notcovered by the standard Android APIs. These Optional APIs are considered optionalbecause they deal with functionality that may or may not be present on a given handsetdevice. That is, some devices created for the Android platform may include upgradesand features that others do not; the Optional APIs cover your programming optionswhen trying to utilize these features in your Android applications.One of these optional features (which you will use later in the book) is a cell-phone-basedGPS. The Android LBS (Location-Based Services) API deals with the functionalityneeded to receive and utilize informatio n from a device’s GPS unit. (Combine theinformation in the Android LBS API with that in the Google Maps API, and you mighthave a very useful application that can automatically display a map of where you arelocated at any given point in time.)Other Optional APIs include those for utilizing Bluetooth, Wi-Fi, playing MP3s, andaccessing 3-D—OpenGL-enable hardware.Application Life CycleIf you have a decent amount of experience as an application developer, you are familiarwith theconcept of an application life cycle. An application life cycle consists of thesteps that theapplication’s processes must follow from execution to termination. Everyapplication, regardless of the language it was written in, has a specific life cycle, andAndroid applications are no exception. This section examines the life cycle of an ASPapplication and compares that to an Android application’s life cycle.Standard ASP Application Life CycleThe life cycle of a standard ASP application is similar enough to that of an Androidapplication to make this a good comparison. ASP applications step through fivedistinct processes from launch to disposal. These steps are required to be implementedby all ASP applications, and really define what an ASP application is. The steps, inorder, are1. Application_Start2. Event3. HTTPApplication.Init4. Disposal5. Application_EndChapter 4: Exploring the Android SDK 4950 Android: A Programmer’s GuideTIPSome ASP reference materials consider Disposal and Application_End to be one stepin the life cycle. However, the Disposal call can be intercepted before it is passed toApplication_End. This can allow the application to perform specific functions beforeit is actually destroyed.Application_Start is called when the application is requested from the server. Thisprocess in turn leads into the Event process(es). When all associated application moduleshave loaded, HTTPApplication.Init is called. The application executes its events, andwhen the user attempts toclose it, Dispose is called. Dispose then passes processingon to the Application_End process, which closes the application.This is a fairly standard application life cycle. Most applications follow similar lifecycles: an application is created, loaded, has events, and is destroyed. The followingsection demonstrates how this compares to the Android application life cycle.Android Application Life CycleThe Android application life cycle is unique in that the system controls much of the lifecycle of the application. All Android applications, or Activities, are run within their ownprocess. All of the running processes are watched by Android and, depending on howthe activity is running (this is, a foreground activity, background activity, and so forth),Android may choose to end the activity to reclaim needed resources.NOTEWhen deciding whether an activity should be shut down, Android takes into accountseveral factors, such as user input, memory usage, and processing time.Some of the specific methods called during the life cycle of an android activity are● onC reate● onStart● Process-specific events (for example: launching activities or accessing a database)● onStop● onDestroyFollowing the same logic as other application life cycles, an Android applicationis created, the processes are started, events are fired, processes are stopped, and theapplication is destroyed. Though there are a few differences, many application developersshould be comfortable with the steps in the life cycle.文献出处:DiMarzio,J.F.Android: A Programmer's Guide[M].McGraw-Hill Prof Med/Tech, 2008:41-50NotePad写字板NotePad,允许你打开，创建并且编辑小的笔记。

安卓 android 翻译中英文对照毕设

Hindawi Publishing CorporationInternational Journal of Computer Games TechnologyVolume2012,Article ID494232,10pagesdoi:10.1155/2012/494232Research ArticleComparison of Learning Software Architecture by Developing Social Applications versus Games on the Android Platform Bian Wu and Alf Inge WangDepartment of Computer Science,Norwegian University of Science and Technology,7491Trondheim,NorwayCorrespondence should be addressed to Bian Wu,bian@idi.ntnu.noReceived15April2012;Accepted16July2012Academic Editor:Daniel ThalmannCopyright©2012B.Wu and A.I.Wang.This is an open access article distributed under the Creative Commons Attribution License,which permits unrestricted use,distribution,and reproduction in any medium,provided the original work is properly cited.This paper describes an empirical study where the focus was on discovering diﬀerences and similarities in students working on development of social applications versus students working on development of games using the same Android development platform.In2010-2011,students attending the software architecture course at the Norwegian University of Science and Technology (NTNU)could choose between four types of projects.Independently of the chosen type of project,all students had to go through the same phases,produce the same documents based on the same templates,and follow exactly the same process.This study focuses on one of projects—Android project,to see how much the application domain aﬀects the course project independently of the chosen technology.Our results revealed some positive eﬀects for the students doing game development compared to social application development to learn software architecture,like motivated to work with games,a better focus on quality attributes such as modiﬁability and testability during the development,production of software architectures of higher complexity,and more productive coding working for the project.However,we did notﬁnd signiﬁcant diﬀerences in awarded grade between students choosing the two diﬀerent domains.1.IntroductionComputer games and video games have become very popular for children and youths and play a prominent role in the culture of young people[1].Games can now be played everywhere in technology-rich environments equipped with laptops,smart phones,game consoles(mobile and station-ary),set-top boxes,and other digital devices.From this phenomenon,it is believed that the intrinsic motivation that young people show towards games could be combined with educational content and objectives into what Prensky calls “digital game based learning”[2].Besides an abundant appearance of games in young students life,game development technology has matured and become more advanced[3].Based on various existing game development environments,the whole duty of game devel-opment process can be divided into several expert domains and roles such as game programmer,3D model creator,game designer,musician,animator,and play writer,and so forth. The process of integrating game content with technology can be simpliﬁed through the usage of game engines and available information on the web from various user and expert communities.For instance,Microsoft’s XNA game development kit provides the game loop function to draw and update the game contents,and it also provides conve-nient game development components to load the diﬀerent format of graphics,audio,and videos.This makes it possible for game fans such as students with or without programming background to modify existing games or develop new games. They can design and implement their own game concepts with these game creation tools,learn the developing skills and relevant knowledge,and accumulate related practical experience.In this context,not only can games be used for learning but also the game development tools can be used for studying relevant topics within computer science(CS),software engi-neering(SE),and game programming through motivating assignments.Generally,games can be integrated in education in three ways[4,5].First,games can be used instead of tradi-tional exercises motivating students to put extra eﬀort indoing the exercises and giving the teacher and/or teaching assistants an opportunity to monitor how the students work with the exercises in real time,for example[6,7].Second, games can be played as a part of a lecture to improve the participation and motivation of students,for example[8,9]. Third,the students are asked to modify or develop a game as a part of a course using a Game Development Framework (GDF)to learn skills within CS and SE,for example[10]. We label the latter learning approach Game Development-Based Learning(GDBL).And the GDF denotes the toolkits that can be used to develop or modify games,for example, game engine,game editors,or game(simulation)platforms, or even any Integrated Development Environment(IDE), like Visual C++,Eclipse,J2ME,and Android SDK since all of them can be used to develop games.This paper focuses on an evaluation where we wanted to discover similarities and diﬀerences between making students learn software architecture through game develop-ment versus social application development(e.g.,weather Forecast,chatting software)using the Android platform.The motivation for bringing game development into a CS or SE course is to exploit the students’fascination for games and game development to stimulate them to work more and better with course material through the project.2.Related WorksThis section describes the research context and previous results about using GDBL method in software engineering ﬁeld.2.1.Research Contexts.The earliest similar application of learning by programming in a game-like environment was in early1970s.The Logo[11],the turtle graphics,is one of the oldest libraries that was used to introduce computing concepts to beginners.The concept was based on a“turtle”that could be moved across a2D screen with a pen,which could be positioned on or oﬀthe screen,and,thus,may leave a trace of the turtle’s movements.Programming the turtle to draw diﬀerent patterns could be used to introduce general computing skill,such as procedural operations,iteration, and recursion.Further,in1987,Micco presented the usage of writing a tic-tac-toe game for learning[12].Afterwards, other studies have been conducted using specialist game programming toolkits such as Stage Cast Creator[13], Gamemaker[14],Alice[15],and Neverwinter Nights[16]. Besides,article[17]presents an investigation for using mobile game development as a motivational tool and a learning context in computing curriculum.From their sur-vey,it shows the relation between game programming and other computer scienceﬁelds—Game development can be used in study of Artiﬁcial intelligence(AI),database,com-puter networks,SE,human-computer interaction,computer graphics,algorithms,programming,computer architecture, and operating system.These studies indicate that making games is motivating and develops storytelling as well as technical programming skills.The nature of the task of making games is slightly diﬀerent in purpose-built environments and the balance of the roles assumed by the learner shifts accordingly.More recent game programming toolkits tend to have a stronger visual aspect than Logo,either in the sense that they enable designers to easily create graphical games or because they have a visual programming language,or both.This shifts the emphasis away from low-level programming,enabling learn-ers to focus on the other roles as designers or writers.Thus, we investigate how GDFs are used in education through an experiment study and explore the evolution of the traditional lecture to be dynamic,collaborative,and attractive to the students under current technology-rich environment. However,this assertion needs to be further supported by relevant theory,application experiences,evaluation results, and empirical evidence.This is one motivation for sharing our experiences and empirical results inﬁeld of GDBL on using Android in a software architecture course.2.2.Course and Project Setting.The software architecture course at Norwegian University of Science and Technology (NTNU)(course code TDT4240)is taught in a diﬀerent way than at most other universities,as the students also have to implement their designed architecture in a project.The motivation for doing so is to make the students understand the relationship between the architecture and the implemen-tation and to be able to perform a real evaluation of whether the architecture and the resulting implementation fulﬁll the quality requirements speciﬁed for the application. The architecture project in the course has similarities with projects in other software engineering courses,but every-thing in the project is carried out from a software architecture perspective.Throughout the project,the students have to use software architecture techniques,methods,and tools to succeed according to the speciﬁed project.The software architecture project consists of the follow-ing phases.(i)COTS(Commercial Oﬀ-the-Shelf)exercise:learn thetechnology to be used through developing a simplegame.(ii)Design pattern:learn how to use and apply design pattern by making changes in an existing system.(iii)Requirements and architecture:list functional and quality requirements and design the software archi-tecture for a game.(iv)Architecture evaluation:use the Architecture Trade-oﬀAnalysis Method(ATAM)[18–20]evaluationmethod to evaluate the software architecture of pro-ject in regards to the quality requirements.(v)Implementation:do a detailed design and implement the game based on the created architecture and on thechanges from the evaluation.(vi)Project evaluation:evaluate the project as a whole using a Postmortem Analysis(PMA)method[21].In theﬁrst two phases of the project,the students work on their own or in pairs.For phases3–6,the students work in self-selected teams of4-5students.Meantime,students haveoneﬁxed primary assigned quality attribute to focus on during the project.For the secondary quality attribute,stu-dents can choose the quality attribute they like.The students spend most time in the implementation phase(six weeks), and they are also encouraged to start the implementation in earlier phases to test their architectural choices(incre-mental development).During the implementation phase,the students continually extend,reﬁne,and evolve the software architecture through several iterations.2.3.Previous Results.Previously,the goal of the project has been to develop a robot controller for the WSU Khepera robot simulator(Robot)in Java[22]with emphasis on an assigned quality attribute such as availability,performance, modiﬁability,or testability.The students were asked to pro-gram the robot controller to move a robot around in a maze, collect four balls,and bring them to a light source in the maze.In2008,the students were allowed to choose between a robot controller project and a game development project. The process,the deliverables,and the evaluation of the project were the same for both types of projects—only the domain was diﬀerent.In the Game project,the students were asked to develop a game using the Microsoft XNA framework and C#.Finally,an evaluation about software architecture course is conducted[23,24].The evaluation is based on data from a project survey,the project deliverables from the students,and other accessible course information.The main conclusion from study was that game development projects can successfully be used to teach software architecture if we consider Robot as an evaluation benchmark.Integrating our experiences on running of game project in software architecture course in2008,we conducted a new option to add one more COTS-Android in software architecture course project during2010-2011.The students could now in addition to the Java Robot project and the XNA Game project choose to develop a social application or a game in Android.Independently of the COTS and the domain chosen,the students had to focus on the same software architecture issues during the project and follow the same templates.The introduction of game and social Android projects allowed us to compare how the domain the students work on in the project aﬀects the learning and the project experiences independently of the COTS.A detailed description was in following sections.3.MethodThis section describes the research method to get the relevant data for our experiment of using Android development in software architecture projects.3.1.Aim.This paper focuses on using the same COTS but with diﬀerent development domains to investigate whether the diﬀerent domains produce diﬀerent output.In our pre-vious research,the eﬀectiveness of GDBL conclusion was based on the diﬀerent COTS-Robot and XNA.This paper excludes game developed in XNA and robot controller developed in Java and only focuses on the Android plat-form and development of social application versus game application.Our evaluation coversﬁve topics:distribution of chosen domain,students’perception of the project,project deliveries and code quality and complexity,students’eﬀort, and awarded project grades.3.2.GQM Approach.The comparison of the social and game project should help to discover the diﬀerences and reveal the eﬀects of introducing a project on the Android platform.This evaluation is a quasiexperiment,not a controlled experiment. The research method used is based on the Goal,Question Metrics(GQM)approach[25]where weﬁrst deﬁne a research goal(conceptual level),then deﬁne a set of research questions(operational level),andﬁnally describe a set of metrics to answer the deﬁned research questions(quanti-tative level).In our case,the metrics used to give answers to the research questions are a mixture of quantitative and qualitative data.Table1shows the GQM approach used to analyze game development project in software architecture course.3.3.Procedures.When students start the project and follow the projects phases,they should report the time they spend on each phase of the project.Theﬁrst two phases allow the students individually or in pairs to get familiar with the COTS and architectural and design patterns.The main work of the project is carried out in the phases3–5and includes requirement speciﬁcation,architectural design,architectural evaluation,implementation,and testing.The students pro-duce a delivery for each phase,which is evaluated by the course staﬀ,and feedback is given to improve before theﬁnal delivery.At the end of phase5,the students will produce a ﬁnal delivery,which is evaluated and graded by the course staﬀ.After completing phase5,the students have to answer a questionnaire that focuses on how the students perceive the project.In phases6,the students must carry out a postmortem analysis of their project as a whole to reﬂect on their successes and their challenges.4.ResultsIn2010and2011,the students could choose to do the project using three COTS:Robot(Java),XNA(C#),and Android (Java).The students’selection of COTS is shown in Figure1, where36students chose Khepera robot(19%),55students chose XNA(27%),and102students(54%)chose Android. Of the students that chose Android,58students(57%)chose social application versus44students(43%)game.If we look at the domains the students chose we see that51%chose game development,30%chose social applications,and19% chose robot controller.The statistics of Figure1clearly reveal that the majority of students prefer game development compared to other domains.And Android is the most popular COTS by far, and we believe this is due to its openness for developers, development in Java,attractive devices,innovative features and development,and a new way of sharing developed appli-cations through Android marked.In theﬁrst phase of the project,the students were asked to ﬁll in a questionnaire on the reasons to choose the COTS andDistribution of domainsSocial app.30%Kheperarobot19%Game51%(a)Distribution of COTSKheperarobot19%XNA28%Android53%(b)Figure1:Distribution of selection of type of software architecture projects.Table1:GQM table.Analyze Software development projectFor the purpose of Comparing social application versus game application domain on same COTS Goal With respect to Diﬀerence and eﬀectiveness of two domains of the projects From the point of view of Researcher and educatorIn context of Students in software architecture courseQuestions Q1:Are there any dif-ferences in how the stu-dents perceive the projectfor students choosing anAndroid game project ver-sus students choosing anAndroid social project?Q2:Are there any diﬀerencesin the software architecturesdesigned by students doing anAndroid game project versusstudents doing an Androidsocial project?Q3:Are there any diﬀer-ences in the implemen-tation eﬀort in the pro-ject by students doingan Android game projectversus students doing anAndroid social project?Q4:Are there any dif-ferences in the perfor-mance of students doingan Android game projectversus students doing anAndroid social project?Metric M1:Number of studentschoosing game projectversus social project.M3:Project reports M4:Source codeﬁles M6:Project scoreM2:Questionnaire surveywith5-Level Likert Scale:Strong disagree(1),Dis-agree(2),Neutral(3),Agree(4),Strong Agree(5)M5:Time spentdomain.The top reasons list was:(1)programming reason (familiar with Java or C#)(70.7%),(2)to learn about the COTS(Robot,XNA,Android)(59.5%),(3)games motiva-tion or amusement reasons(40.1%),(4)social application motivation(39.5%),(5)to learn about the domain(robot, game,social)(34.2%),(6)hardware motivation,running games on Android phone,Zuneplayer(33%),and(7)make games for Android Market or XNA club(24.5%).From above data,we found that the game domain has advantages in drawing students’attention and its attractive peripherals, like hardware or software markets,and so does android social domain.This was not the case for the Robot domain.The following subsections focus on the analysis of whether the domain game versus social causes any signiﬁcant diﬀerent output in the following four aspects:(1)students perception of the project,(2)the design complexity of software architectures,(3)students’implementation eﬀort in the project,and(4)students’score in projects.4.1.Diﬀerences in How Students Perceived the Project.A pro-ject survey was conducted one week after the students com-pleted their software architecture project.The goal of this survey was to reveal possible diﬀerences in the students’perception of the project between teams working with social projects versus teams working with game projects on the same COTS—the Android platform.Statements in the sur-vey made the students reﬂect on how the project helped them to learn software architecture.The hypothesis deﬁned for this survey was the following.H0:There is no diﬀerence in how students doing game project and social project on the same COTS-Android perceive the software architecture project.To test hypothesis we used Kruskal-Wallis Test[26] since it is a nonparametric method for testing equality of population medians among groups[24].This test is usually for(1)users cannot assume a normal population and(2)theTable2:Wilcoxon Test of the statements PS1-PS11.Statement COTS Average Median Standard deviation PPS1:I found it diﬃcult to evaluate the other group’s architecture in the ATAM?Game 3.454 1.060.178 Social 3.7740.91PS2:I found it diﬃcult to focus on our assigned quality attributes Game 3.053 1.090.024 Social 3.5740.85PS3:I found it easy to integrate known architectural or design patterns Game 3.2130.930.332 Social 2.943 1.03PS4:I spent more time on technical matters than on architectural matters Game 3.714 1.200.175 Social 4.064 1.03PS5:I have learned a lot about software architecture during the project Game 3.5040.860.552 Social 3.3140.99PS6:I would have chosen another project if I could go back in time Game 1.1310.340.289 Social 1.2010.41sample sizes of the two groups are diﬀerent.Table2shows the results of Kruskal-Wallis Test on the statements PS1–PS6.38 of44game project students replied while35out of58social project students replied the questionnaire.Each item in the questionnaire is responded to by assigning a scale value from 1to5,where1indicates strong disagreement and5indicates strong agreement.From the test results,the lowest signiﬁcant diﬀerence (P≤0.05)in questionnaire’s response is PS2(P=0.024). We conclude that the Android game and Android social have signiﬁcant diﬀerence on the students perceiving the diﬃculty to focus on the assigned quality attributes in the project. The median of Likert scale score is3for android game,but 4for android social.It indicates that android game project students were neutral on this PS5,but social project students have a tendency on the agreement of PS5.One possible explanation is that quality attribute,like termsmodiﬁability or testability linked to a game concept,is easier to imagine and catch the students’attention to look into it.But social applications may have moreﬁxed impression in students’life and cause less deep eﬀect than games to motivate students to think.Others statement have no signiﬁcant diﬀerence from students perception.Further,even there is no signiﬁcant diﬀerence for the two other low P values,the average value of PS1and PS4 still indicates that students from game project found it less diﬃcult to evaluate the other group’s architecture in the ATAM and spent less time on technical matters than the students from social projects.In addition,PS6:the students had to answer whether they would have chosen another project if they could go back in time.Figure2shows more detailed statistics for it.Figure2shows that there is a higher percentage of the social project students that would have chosen another project(20%)compared to the game project students(13%).As an overall,the survey reveals one signiﬁcant diﬀerence that students from game projects have a better focus on quality attributes.Statements got low P values(P1,P2, P4)that revealed the tendency that game teams receive more positive feedback than the social teams on how they perceived the project.12010080604020(%)13%87%20%80%Other projectsSame projectAndroid game Android socialFigure2:Reponses to PS6:would you have chosen the same project if you could go back in time.4.2.Diﬀerences in the Design of Software Architecture.It is diﬃcult to evaluate software architectures empirically,but we have chosen to do so by comparing the number of design patterns the students used,the number of main modules/classes identiﬁed in the logical view of the software architecture,and the number of hierarchical levels in the architecture.We admit that that there are many sources of errors in this comparison,as the two domains are so diﬀerent.However,the emphasis in this course is on using software design patterns and presenting the diﬀerent views of the software architecture in suﬃcient detail with emphasis on the logical view.The empirical data should highlight the diﬀerences between the two types of projects if any.The empirical data has been collected by reading through and analyzing theﬁnal project reports from12game project teams and16social project teams.4%24%8%Design pattern percentage for game project Fac¸(a)Observer42%Factory5%Design pattern percentage for social project(b)Figure3:Distribution of usage of design patterns for game and social projects.Table3:Number of design patterns used.Average Standard deviation Max MinDesign Patterns Game 2.67 1.9271 Social 1.560.7331e of Design Patterns.Table3presents the descriptive statistics of the number of architectural and design patterns used in the Social and the Game projects.The results in Table3indicate that there are some diﬀerences in how patterns are used in the two types of projects.Table4presents Kruskal-Wallis Test results and shows that there are no statistically signiﬁcant diﬀerences in the number of design patterns produced by the two diﬀerent project types.Table4indicates no statistically signiﬁcant diﬀerence for the number of design pattern used for the two types of projects.From reading through the projects reports,Figure3 presents the distribution of design patterns used by social teams and by game teams.The charts show that the Observer was the most popular for both types of project.Further,the Abstract Factory and State pattern was among the top three for Game teams,singleton and template pattern was among the top three for social teams.The Game projects had more diversity in applying architecture and design patterns than social project.For instance,game projects used eight design patterns compared to six design patterns in social projects as shown in Figure3.Even there is no signiﬁcant diﬀerence,but the low P value is close to0.1.The median in Table4implies that game teams used more design patterns in their projects,it may cause that game projects used more types of patterns than social projects in an overall statistics shown in Figure3.4.2.2.Software Architecture Complexity.Two metrics were chosen to indicate the complexity of the software architecture [24]:(1)the number of main modules or main classes described in the logical view of the software architecture and (2)the number of hierarchical levels in the model presented in the logical view of the software architecture.The reason the logical view was chosen for computing complexity is that the logical view is the main one that gives the best overview of the designed architecture.Table5lists the measurements of the number of main modules/classes and the number of hierarchical levels in the logical view of the software architecture for social and game projects.Table5shows that the game project teams on average have almost four more main modules/classes(28%)than the social teams,and the standard deviation is lower.Further,the number of levels in the architecture in game projects can be decomposed into almost twice as many levels compared to social projects.Table6gives the results from Kruskal-Wallis Test on a number of main modules/classes and numbers of levels in the architecture.Both of the tests give low P values(P<0.05). Speciﬁcally,the tests show that there is statistically signiﬁcant diﬀerence on the number of main classes and levels in architecture.From this result,it implies game project has more complexity in architecture levels than social projects; it may be due to the fact that they used more patterns to implement their game projects that cause this diﬀerence. 4.3.Diﬀerences in the Eﬀort Put into the Project.To evaluate the eﬀort of each project that students put into it,two indicators are used as the measurement criteria:(1)time spent on the project and(2)structure and size of projectﬁles and number of lines of code.4.3.1.Time Spent.We have asked students to estimate on how many hours the project teams worked in the softwareTable4:Hypothesis tests on number of design patterns used.Hypothesis COTS N Median PNo diﬀerence in number of used design patterns Game1220.111 Social161Table5:Measurement of software architecture complexity.Numbers of main modules/classes Number of levels in architectureGame Social Game Social Average149.73 1.75 Standard deviation 4.9 6.60.60.77 Max212843Min7321Table6:Hypothesis tests on architectural complexity.Hypothesis COTS N Median PNo diﬀerence in number of main modules/classes Game12140.021 Social167No diﬀerence in number of levels in architecture Game1230.000 Social162Table7:Time spent on the project for each team.Time per team(hours)Game Social Average334338 Standard deviation133.7114.7 Max520535 Min110183architecture project during the phases3–5(core phases of the project).Table7shows the estimated number of hours given by each team.Based on each team’s time eﬀort,we ran the Kruskal-Wallis Test on the diﬀerence on hours spending in the project for each team.From previous results,there is no statistically signiﬁcant diﬀerence on time spent on the project for game teams and social teams.On contrary,the time spending distribution in both projects is quite similar.4.3.2.Project Analysis.Further,we chose to look at metrics from the implementation to give an estimate on how much was produced during the project.It can give a good indication of the complexity of the software architecture and the resulting implementation of the application[24]. Since both types of teams used Android and the domains are comparable in terms of complexity,we expected toﬁnd diﬀerence in productivity.During the development process, they were free to use online resource or other open source libraries for Android to save coding time for the software architecture design.The following metrics were chosen to compute the eﬀort of the student teams:(1)number of source Files(NoF);(2)number of comments in code(NoC);(3)lines of source codenot counting empty lines or comments(LoC).Table9presents a comparison of the implementationmetrics for the game projects and social projects,only javacodeﬁles to be counted in the table,and the external librarycodeﬁles and resourceﬁles are excluded.Table10shows the results from Kruskal-Wallis Test onthe diﬀerence in the number ofﬁles and the number of linesof code produced by the two diﬀerent types of project.The results from the Kruskal-Wallis Test indicate thatthere is no statistically signiﬁcant diﬀerence in LoC betweenthe two types of project.But the low P value is close to0.1.The average value from Table9indicates game teamsput more eﬀort on the implementation,like coding,makingcomments,structure codes into moreﬁles during the project.From the Tables7,8,9,and10,we canﬁnd the gameproject teams have produced on average almost one thirdas much code(133%more)in similar time spending(334versus338).It implies that game project teams are moreproductive to put eﬀort in coding,comments to construct acomplex game software architecture in similar time spendingthan social project teams.4.4.Diﬀerence in the Project Grades.The project score isbetween0and30points and takes30%of theﬁnal grade.The project grades intervals are classiﬁed as:A:score≥90%;B:score≥80%and score<90%;C:score≥60%and score <80%;D:score≥50%and score<60%;E:score≥40%and score<50%;F:score<40%(fail).In order to investigate if there were any diﬀerences in howthe group scored(0–30points)on the project for studentsthat has chosen game and social projects on Android,theKruskal-Wallis Test was used to test this hypothesis,as wecannot assume a normal population and the sample size of。

Android应用基础毕设论文外文翻译

英文文献原文:Android Application Fundamentals Androidapplicationsare written in the Java programming language. The Android SDK tools compile the code—along with any data and resource files—into an Android package, anarchive filewith an .apk suffix. All the code in a single .apk file is considered to be one application and is the file that Android-powered devices use to install the application.Once installed on a device, each Android application lives in its own security sandbox:∙The Android operating system is a multi-user Linux system in which each application is a different user.∙By default, the system assigns each application a unique Linux user ID (the ID is used only by the system and is unknown to the application). Thesystem sets permissions for all the files in an application so that only the user ID assigned to that application can access them.∙Each process has its own virtual machine (VM), so an application's code runs in isolation from other applications.∙By default, every application runs in its own Linux process. Android starts the process when any of the application's components need to be executed, then shuts down the process when it's no longer needed or when the system must recover memory for other applications.In this way, the Android system implements the principle of least privilege. That is, each application, by default, has access only to the components that it requires to do its work and no more. This creates a very secure environment in which an application cannot access parts of the system for which it is not given permission. However, there are ways for an application to share data with other applications and for an application to access system services:∙It's possible to arrange for two applications to share the same Linux user ID, in which case they are able to access each other's files. To conserve system resources, applications with the same user ID can also arrange to run in the same Linux process and share the same VM (the applications must also be signed with the same certificate).∙An application can request permission to access device data such as the user's contacts, SMS messages, the mountable storage (SD card), camera,Bluetooth, and more. All application permissions must be granted by the user at install time.That covers the basics regarding how an Android application exists within the system. The rest of this document introduces you to:∙The core framework components that define your application.∙The manifest file in which you declare components and required device features for your application.∙Resources that are separate from the application code and allow your application to gracefully optimize its behavior for a variety of deviceconfigurations.Application ComponentsApplication components are the essential building blocks of an Android application. Each component is a different point through which the system can enter your application. Not all components are actual entry points for the user and some depend on each other, but each one exists as its own entity and plays a specific role—each one is a unique building block that helps define your application's overall behavior.There are four different types of application components. Each type serves a distinct purpose and has a distinct lifecycle that defines how the component is created and destroyed.Here are the four types of application components:ActivitiesAn activity represents a single screen with a user interface. For example, an email application might have one activity that shows a list of new emails, another activity to compose an email, and another activity for reading emails.Although the activities work together to form a cohesive user experience in the email application, each one is independent of the others. As such, adifferent application can start any one of these activities (if the emailapplication allows it). For example, a camera application can start the activity in the email application that composes new mail, in order for the user to sharea picture.An activity is implemented as a subclass of Activity and you can learn more about it in the Activities developer guide.ServicesA service is a component that runs in the background to perform long-runningoperations or to perform work for remote processes. A service does notprovide a user interface. For example, a service might play music in thebackground while the user is in a different application, or it might fetch data over the network without blocking user interaction with an activity. Another component, such as an activity, can start the service and let it run or bind to it in order to interact with it.A service is implemented as a subclass of Service and you can learn moreabout it in the Services developer guide.Content providersA content provider manages a shared set of application data. You can storethe data in the file system, an SQLite database, on the web, or any otherpersistent storage location your application can access. Through the content provider, other applications can query or even modify the data (if the content provider allows it). For example, the Android system provides a contentprovider that manages the user's contact information. As such, any application with the proper permissions can query part of the content provider (such as ContactsContract.Data) to read and write information about a particularperson.Content providers are also useful for reading and writing data that is private to your application and not shared. For example, the Note Pad sampleapplication uses a content provider to save notes.A content provider is implemented as a subclass of ContentProvider and mustimplement a standard set of APIs that enable other applications to perform transactions. For more information, see the Content Providers developerguide.Broadcast receiversA broadcast receiver is a component that responds to system-wide broadcastannouncements. Many broadcasts originate from the system—for example, a broadcast announcing that the screen has turned off, the battery is low, or a picture was captured. Applications can also initiate broadcasts—for example, to let other applications know that some data has been downloaded to thedevice and is available for them to use. Although broadcast receivers don't display a user interface, they may create a status bar notification to alert the user when a broadcast event occurs. More commonly, though, a broadcast receiver is just a "gateway" to other components and is intended to do a very minimal amount of work. For instance, it might initiate a service to perform some work based on the event.A broadcast receiver is implemented as a subclass of BroadcastReceiver andeach broadcast is delivered as an Intent object. For more information, see the BroadcastReceiver class.A unique aspect of the Android system design is that any application can start another applicat ion’s component. For example, if you want the user to capture a photo with the device camera, there's probably another application that does that and your application can use it, instead of developing an activity to capture a photo yourself. You don't need to incorporate or even link to the code from the camera application. Instead, you can simply start the activity in the camera application that captures a photo. When complete, the photo is even returned to your application so you can use it. To the user, it seems as if the camera is actually a part of your application.When the system starts a component, it starts the process for that application (if it's not already running) and instantiates the classes needed for the component. For example, if your application starts the activity in the camera application that captures a photo, that activity runs in the process that belongs to the camera application, not in your application's process. Therefore, unlike applications on most other systems, Android applications don't have a single entry point (there's no main() function, for example).Because the system runs each application in a separate process with file permissions that restrict access to other applications, your application cannot directly activate a component from another application. The Android system, however, can. So, to activate a component in another application, you must deliver a message to the system that specifies your intent to start a particular component. The system then activates the component for you.Activating ComponentsThree of the four component types—activities, services, and broadcast receivers—are activated by an asynchronous message called an intent. Intents bind individual components to each other at runtime (you can think of them as the messengers that request an action from other components), whether the component belongs to your application or another.An intent is created with 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.For activities and services, an intent defines the action to perform (for example, to "view" or "send" something) and may specify the URI of the data to act on (among other things that the component being started might need to know). For example, an intent might convey a request for an activity to show an image or to open a web page. In some cases, you can start an activity to receive a result, in which case, the activity also returns the result in an Intent (for example, you canissue an intent to let the user pick a personal contact and have it returned to you—the return intent includes a URI pointing to the chosen contact).For broadcast receivers, the intent simply defines the announcement being broadcast (for example, a broadcast to indicate the device battery is low includes only a known action string that indicates "battery is low").The other component type, content provider, is not activated by intents. Rather, it is activated when targeted by a request from a ContentResolver. The content resolver handles all direct transactions with the content provider so that the component that's performing transactions with the provider doesn't need to and instead calls methods on the ContentResolver object. This leaves a layer of abstraction between the content provider and the component requesting information (for security).There are separate methods for activating each type of component:∙You can start an activity (or give it something new to do) by passing an Intent to startActivity() or startActivityForResult() (when you want theactivity to return a result).∙You can start a service (or give new instructions to an ongoing service) by passing an Intent to startService(). Or you can bind to the service by passing an Intent to bindService().∙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 by calling query() on a ContentResolver.For more information about using intents, see the Intents and Intent Filters document. More information about activating specific components is also provided in the following documents: Activities, Services, BroadcastReceiver and Content Providers.中文翻译Android应用基础用Java编程语言编写的Android应用程序,被Android的SDK工具将它和数据以及资源文件编译到一个以.apk为后缀的Android程序包。

智能手机中英文外文翻译文献

智能手机中英文外文翻译文献- 字数要求: 800字以上
简介
本文档旨在提供智能手机领域的中英文外文翻译文献，以便读
者了解该领域的最新研究成果和技术发展。

以下是一些相关文献的
摘要：
文献一: "智能手机的嵌入式传感器"
这篇论文讨论了智能手机中嵌入式传感器的应用。

作者详细介
绍了智能手机中使用的各种传感器，如加速度计、陀螺仪和磁力计，并探讨了它们在手机功能和用户体验方面的重要性。

通过深入了解
这些传感器的工作原理和应用，手机制造商可以更好地设计和优化
其产品。

文献二: "智能手机安全性的挑战"
该论文探讨了智能手机安全性面临的挑战。

作者指出了智能手
机的普及导致了个人信息泄露和网络攻击风险的增加。

讨论了不同
的安全威胁，如恶意软件和网络钓鱼，并提出了一些解决方案和规范，以提高智能手机安全性的水平。

文献三: "智能手机摄像技术的发展趋势"
该论文概述了智能手机摄像技术的发展趋势。

作者分析了手机摄像头的硬件和软件改进，以及在图像处理和计算机视觉方面的创新。

讨论了智能手机摄像技术对用户体验、社交媒体和虚拟现实的影响，并展望了未来可能的发展方向。

结论
以上是对智能手机领域的中英文外文翻译文献的简要摘要。

这些文献提供了关于智能手机嵌入式传感器、安全性挑战和摄像技术发展趋势的有价值信息。

希望读者通过阅读这些文献，能够更好地了解智能手机领域的最新研究和创新成果。

外文翻译-微信校园之二手交易市场

1．外文资料翻译译文走向自动化的安卓应用程序串联检测摘要安卓系统支持应用程序之间的多种通信方式。

这将打开可能进行有风险的合作方式，比照c.f.在2011年的例子。

在本文中，我们提供了一个简明的定义在许多自动化检测方法联系和报告，与英特尔合作开发的安全。

导论安卓操作系统（操作系统）是设计了一个内置的安全功能，如应用程序的沙拳和公平粒度访问控制的基础上的权限。

然而，在现实生活中，应用程序的隔离是有限的。

在某些方面甚至相反的是正确的。

应用程序跨边界的通信方式有很多种方式。

Android操作系统支持多个通信方法进行充分的记录（如消息通过意图传达）。

用不同的安全姿势的应用程序通信的能力有负面效应对安全应用程序（在一个沙盒有处理这样的数据权限）可以让敏感的数据流到另一个应用程序（在另一个沙盒已经拒绝处理这样的数据）和最终泄漏。

在Android生态系统的问题和恶化的市场压力导致许多开发商在将广告移到到他们的应用程序中。

作为一个结果，这样的代码可以在成千上万的应用程序的出现（有不同的权限）。

广告主有一个已知的倾向，忽视用户的隐私有利于资本化。

所以，存在一个风险，自广告之间即使没有应用程序沙盒作为作者发送敏感数据在知识交流，冒着暴露隐私的可能。

当然，任何一个不道德的开发者也可以拆分他们更喜欢隐藏在多个应用程序之间的功能。

类似的恶意行为，这是显而易见的，从已知的情况下，应用程序利用不安全的敏感数据影响其他应用程序。

研究人员已经表明，设置的应用程序可能会违反的权限设置，造成数据泄露或携带恶意病毒。

这样的应用程序设置被称为西泸定组，该现象称为应用程序相互勾结。

不幸的是，没有有效的工具来检测APP的相互勾结。

应用程序的可能组合构成的搜索空间意味着这并不是直截了当的。

有效的方法来缩小了搜索者利益勾结。

本文有助于实现一个实用的自动配对系统的共谋检测。

我们在2节给出了一个勾结的定义。

这是由两个潜在的方法来过滤到合谋的潜在候选人，在3节使用Prolog开发了一个基于规则的方法和在第四节使用另一种统计方法。

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。

Android应用程序API中英文对照外文翻译文献

Android应用程序API中英文对照外文翻译文献中英文资料对照外文翻译Android API级别当你开发你的Android应用程序时，了解该平台API变更管理的基本方法和概念是很有帮助的。

同样的，知道API级别标识以及该标识如何保障你的应用与实际硬件设备相兼容对于开发及后续的发布、维护都是有益的。

本节内容告诉你API级别的知识，以及它如何影响你开发和使用的应用。

关于如何使用“以API级别进行过滤”来使用API参考手册，从本文末尾的文档过滤(Filtering the documentation)中可以得到更多信息。

API级别是什么？API级别是一个整数值，它唯一标识了一个具体版本的Android 平台，及其框架的API的版本。

Android平台提供了一套框架API，使得应用程序可以与系统底层进行交互。

该框架API由以下模块组成：一组核心的包和类清单(manifest)文件的XML元素和属性声明资源文件的XML元素和属性声明及访问形式各类意图(Intents)应用程序可以请求的各类授权，以及系统中包含的授权执行每个Android平台的后续版本会包括它提供的更新的Android应用程序框架的API。

该框架的API的更新设计，使高版本的API与早期版本兼容。

也就是说，在新版本API中大多数都是新增功能，和引进新的或替代的功能。

作为API的部分升级，老的替换的部分已过时，但不会从新版本中删除，使得已有的应用程序仍然可以使用它们。

在极少数情况下，旧版本API的部分可能被修改或删除，通常这种变化是为了保障API的稳定性及应用程序或系统的安全。

所有其他早期版本的API将不做修改的保留。

一个Android平台提供的框架API，被指定一个整数标识符，称为“API级别”。

每一个版本的Android平台只支持有一个API级别，虽然该支持是隐含地包括了所有早期的API级别（一直到API级别1级）。

Android平台的最初版本提供的框架API级别是1级，随后的版本依次递增。

安卓系统英文作文怎么写

安卓系统英文作文怎么写英文：Android system is one of the most popular operating systems in the world. It is known for its user-friendly interface, customizable features, and a wide range of applications. I have been using Android for many years, and I can say that it has greatly improved my daily life.One of the things I love about the Android system isits flexibility. I can customize my home screen, install different launchers, and even tweak the system settings to suit my preferences. For example, I can change the theme, font size, and icon layout to make my phone truly unique. This level of customization is something that sets Android apart from other operating systems.Another great thing about Android is the availability of a wide range of applications on the Google Play Store. Whether I need a productivity app, a game, or a socialmedia platform, I can always find what I need on the store. The variety of apps allows me to tailor my phone to my specific needs and interests.In addition, the seamless integration with Google services is a huge plus. I can easily access my emails, documents, and photos through Google Drive, and sync my calendar and contacts with Google Calendar and Google Contacts. This makes it incredibly convenient to stay organized and connected.Overall, the Android system has greatly enhanced my smartphone experience. Its flexibility, app availability, and integration with Google services make it a top choice for me.中文：安卓系统是世界上最受欢迎的操作系统之一。

《说明书的翻译开题报告文献综述3000字》

[5]李泽三. 功能对等理论视角下控制器说明书类文本翻译研究[D].天津理工大学,2018.
[6]郭姗姗. 功能对等理论指导下专利说明书汉译实践报告[D].西安外国语大学,2018.
[7]王嘉楠. 功能对等理论视角下产品使用说明书汉译报告[D].东南大学,2018.
[8]王培. 四川现代汽车公司《技术说明书》英译中翻译项目报告[D].成都理工大学,2017.
2. 现实意义
随着国内外贸易的不断发展和科技的不断进步，我国的手机研发在世界市场上已经有了一席之地。中国迅速崛起成为全球第二大经济体的时代已经到来，我国在各个领域与世界各国的交流也不断增强，尤其是在高新电子技术产品领域的国际合作日益加深。其中，许多大型的工厂和流水线引进的建设和维护变得越来越普遍。作为高新电子产品领域中的关键部分，手机说明书主要包含产品概述、入门指南、操作指导、注意事项以及产品功能和售后保障等介绍。可以说，手机说明书是手机得以能够正常安装APP、运行和维护的基础。要想从容的操作这一切，就需要正确的翻译理论来指导译者翻译出高质量的翻译文件，从而为具体的手机操作和玩法提供正确的实践指导。然而，在控制器说明书类文本的实际英译汉翻译中，存在许多问题。例如，翻译用词不专业、意思模棱两可，甚至意思不对。如果手机说明书汉译文本的译文没有得到准确的翻译，就会给手机软件的安装、运行和维护带来错误的指导，进而影响各个手机设备的正常运行和安全，甚至会造成财产损失和手机系统损坏。为了避免这一系列问题的产生，本文通过功能对等理论来对手机说明书的相关翻译方法进行总结和说明，帮助译者能够准确快速的给出标准的翻译参考，同时提升用户的使用体验感。
毕业论文查重
2020年6月4日至2020年6月5日
参加论文答辩
指导教师对开题报告的意见

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

文献出处：Philippe Nier, The operation and application of Android system [J]. International Journal on Computer Science & Engineering, 2014，13（05）：15-26（声明：本译文归百度文库所有，完整译文请到百度文库。

）原文The Operation and Application of Android SystemPhilippe·NierI. INTRODUCTIONAndroid is a software stack for mobile devices which includes an operating system, middleware and key applications. Since its official public release, Android has captured the interest from companies, developers and the general audience. From that time up to now, this software platform has been constantly improved either in terms of features or supported hardware and, at the same time, extended to new types of devices different from the originally intended mobile ones. Google entered into the mobile market not as a handset manufacturer, but by launching mobile platform called as “Android” for mobile devices such as Smart phones, PDA and net books on 5th November 2007. Google has a vision that Android based cell phone will have all the functions available in the latest PC. In order to make this effort possible, Google launched the Open Handset Alliance. Google introduced Android as an OS which runs the powerful applications and gives the users a choice to select their applications and their carriers. The Android platform is made by keeping in mind various sets of users who can use the available capacity within Android at different levels. Android is gaining strength both in the mobile industry and in other industries with different hardware architectures.The increasing interest from the industry arises from two core aspects: its open-source nature and its architectural model. Being an open-source project, Android allows us to fully analyze and understand it, which enables feature comprehension, bug fixing, further improvements regarding new functionalities and finally, porting to new hardware. On the other hand, its Linux kernel-based architecture model also adds the use of Linux to the mobile industry, allowing to take advantage of the knowledge andfeatures offered by Linux. The Android platform consists of several layers which provide a complete software stack.Android applications are Java-based and this factor entails the use of a virtual machine VM environment, with its advantages. Android uses its own VM called Dalvik, which interprets and executes portable Java-style byte code after transforming it, which is optimized to operate on the mobile platform. All of these aspects make Android an appealing target to be used in other type of environments.The remainder of this paper is organized as follows: Section II briefly describes the Android’s background including architecture, features & programming framework. Section III presents detailed analysis of Android market including comparison with Symbian & Windows Mobile. Finally Section IV concludes this paper.II. ANDROID BACKGROUNDA . Android ArchitectureAndroid Architecture is shown in fig1, which consist of number of layers as Applications, Application framework, Libraries, Android runtime & Linux kernel [1]. Application layer is the uppermost layer which provides a set of core applications including an email, SMS program, calendar, maps, browser, contacts, and others. All applications are written using the Java programming language. It should be mentioned that applications can be run simultaneously; it is possible to hear music and read an email at the same time. The Application Framework is a software framework that is used to implement a standard structure of an application for a specific operating system. With the help of managers, content providers and other services programmers it can reassemble functions used by other existing applications.Layer which is present below Application framework consist of two parts as Libraries which are all written in C/C++. They will be called through a Java interface. This includes the Surface Manager, 2D and 3D graphics, Media Codecs like MPEG-4 and MP3, the SQL database SQLite and the web browser engine WebKit. Second part is Android Runtime which includes a set of core libraries that provides most of the functionality available in the core libraries of the Java programming language. Every Android application runs in its own process, with its own instance of the Dalvikvirtual machine. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The lowest layer is Linux Kernel, Android basically relies on Linux version 2.6 for core system services such as security, memory management, process management, network stack, and driver model. The kernel also acts as an abstraction layer between the hardware and the rest of the software stack.B. Features of AndroidGoogle Android has many features which make it special, but one important feature is Dalvik virtual machine (DVM) [5]. Which is a major component of Android platform. It is optimized for low memory requirements and is designed to allow multiple VM instances to run at the same time. The DVM runs Java applications. However, it is different from standard Java virtual machine in some ways. First, most virtual machines use a stack-based architecture, but Dalvik is a register-based architecture. Second, Dalvik runs Java applications which have been transformed into the Dalvik Executable (.dex) format which is optimized for minimal memory footprint The Dalvik VM relies on the Linux kernel for underlying functionality such as threading and low-level memory management. Java virtual machine tool interface (JVM TI) is a native programming interface on Java virtual machine. The interface provides functionalities to inspect the state of a virtual machine, gather information during run time, and also control the execution of applications running on the Java virtual machine. Android has built in integrated browser based on the open source WebKit engine & built in powerful SQL database engine called SQLite, use for structured data storage. Android support for common audio, video, and still image formats such as AAC, MPEG4, H.264, MP3, AMR, & contains Rich development environment including a device emulator, tools for debugging, & a plug-in for the Eclipse.C. Android Programming FrameworkThe environment requires to develop application for Android consists of the Android SDK, the Eclipse IDE and the Java Development Kit (JDK) which has to be preinstalled for the installation of both, Android SDK and Eclipse. The following versions of the tools mentioned above are used & presented in figure below.1) Android Software Development Kit: The Android SDK includes a comprehensive set of development tools. These include libraries, a handset emulator, documentation, sample code, tutorials & tools such as dx - Dalvik Cross-Assembler, aapt – Android Asset Packaging Tool & adb– Android Debug Bridge. Applications are written using the Java programming language and run on Dalvik, a custom virtual machine designed for embedded use which runs on top of a Linux kernel. The officially supported integrated development environment (IDE) is Eclipse (3.2 or later)2) Android Emulator: The Android SDK includes a mobile device emulator -- a virtual mobile device that runs on your computer. The emulator lets you prototype, develop, and test Android applications without using a physical device. The Android emulator mimics all of the hardware and software features of a typical mobile device, except that it cannot receive or place actual phone calls. It provides a variety of navigation and control keys, which you can "press" using your mouse or keyboard to generate events for your application. It also provides a screen in which your application is displayed, together with any other Android applications running. To let you model and test your application more easily, the emulator supports Android Virtual Device (A VD) configurations. A VDs let you specify the Android platform that you want to run on the emulator, as well as the hardware options and emulator skin files that you want to use.III. ANDROID MARKET ANALYSISA. Android MarketThe Android Market, an online software store, is developed by Google for Android devices. It was made available to users on October 22, 2008. Most of the Android devices come with preinstalled “Market” application which allows users to browse, buy, download, and rate different available applications and other content for mobile phones equipped with the open-source operating system. Unlike with the iPhone App Store, there is no requirement that Android apps should be acquired from Android Market [2]. Android apps may be obtained from any source including a developer's own website. Also, Android developers can create their own application market. Google does not have a strict requirement for the application to show up on theAndroid Market compared to the process used by Apple. Lastly, the Android Market follows a 70/30 revenue-sharing model for applications developed by developers. The developers of priced applications receive 70% of the application price and remaining 30% distributes. As of May 04, 2010, Android apps hit around 49,000 applications which were around 12,500 in August 2009 and 20,000 in December 2009. The global smart phone sell in second quarter of 2009 & 2010 are shown bellow.B. Android vs. Symbian vs. Windows MobileComparison is based on main criteria as follows.1) Portability: Portability is a very important assessment criterion. Symbian OS has many references in this area and having standardized architecture and the openness to software. But the fact that Symbian mostly runs on Nokia cell phones and that it is not Java based lets it fall behind Android. Unfortunately Windows Mobile also has several applications that are specific to certain hardware platforms and therefore are not portable. The Android Mobile platform is a Linux & Java based which allow us to use it on many different platforms unlike Symbian & Win Mobile. As a result Android gets one point, Symbian OS gets half a point and Windows Mobile zero points.译文安卓系统的操作与应用菲利普·尼埃1引言安卓是一个包括操作系统和关键应用程序的移动软件堆栈设备。

安卓系统的操作与应用外文文献翻译2014年译文3000字

手机系统安卓系统中英文对照外文翻译文献

外文翻译安卓系统的大体描述

Android系统外文翻译

有关android技术英文文献翻译

安卓应用开发中英文对照外文翻译文献

A Study on the Performance of Android Platform(外文翻译)

Android毕设外文资料和译文

外文翻译安卓

安卓 android 翻译 中英文 对照 毕设

Android应用基础毕设论文外文翻译

智能手机中英文外文翻译文献

外文翻译-微信校园之二手交易市场

Android系统外文翻译

Android应用程序API中英文对照外文翻译文献

安卓系统英文作文怎么写

《说明书的翻译开题报告文献综述3000字》

安卓 android 翻译中英文对照毕设