roi

AndroidManifest.xml是一个重要的配置文件，它包含了Android应用程序的所有配置信息。在Manifest中，可以添加许多内容，比如：1.声明应用程序的唯一标识符包名2.配置应用程序的权限3.配置应用程序的启动活动4.配置应用程序的服务5.配置应用程序的广播接收器必须按照规定的格式和标签添加相应的内容。另外，Manifest文件还要添加每个扩展组件的元素声明，包括Activity、Service、Receiver 和 Content Provider等组件。正确配置AndroidManifest.xml的内容是保证Android应用程序正常运行的关键之一。

每个app 或 module 或 组件 都会包含一个manifest文件，即 AndroidMnifest.xml ，用于配置当前的 app 或 module 或 组件的各方面信息。然而，最终构建成APK时，会合并成一个AndroidManifest文件。 那么，manifest文件是怎么合并的呢？ 合并冲突，是指多个Manifest文件中含有同一属性但值不同时，默认合并规则解决不了从而导致的冲突。 合并的优先级从高到低依次是： 属性的高低优先级合并结果: 当然还存在例外情况： 合并冲突标记，是android tools namespace中的一个属性，用来解决默认冲突规则解决不了的冲突。 主要包含以下几个： merge : 默认合并操作。 replace : 高优先级替换低优先级Manifest文件中的属性 strict : 属性相同而值不同时会报错，除非通过冲突规则resolved merge-only : 仅合并低优先级的属性 remove : 移除指定的低优先级的属性 remove-All : 移除相同节点类型下所有低优先级的属性 注： 节点层面默认使用merge，属性层面默认使用strict (部分内容参考于 http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2016/0216/3968.html ，如有不妥，请联系删除～)

我们在进行APP开发的时候都会遇到一个文件：AndroidManifest.xml。从刚开始进行Android开发，到现在已经过去了几个月，还是对这个文件一知半解，只知道它是配置用的。但是这文件里的东西具体有什么用，该怎么用一直都没有理解。借着做项目的机会，仔细研究一下这个文件。 研究AndroidManifest.xml最好的方式自然就是对照着官方文档详细理解项目中每个字段的作用，并且做出一些修改来验证。 AndroidManifest是什么?AndroidManifest.xml是一个什么文件? AndroidManifest官方解释是应用清单（manifest意思是货单），每个应用的根目录中都必须包含一个，并且文件名必须一模一样。这个文件中包含了APP的配置信息，系统需要根据里面的内容运行APP的代码，显示界面。 AndroidManifest.xml是每个apk(zip)文件解压后根目录下的一个文件,每个apk都必须包含一个AndroidManifest.xml文件,且名字必须与此完全一致. AndroidManifest.xml的作用是什么？ 描述app的包名： Android设备据此区分不同的app,如果每个app是一个人的话,包名就相当于是这个人的名字(为了防止恶意软件仿冒其他app,只有新的app的包名和签名均与旧的app相同时才能升级覆盖安装成功). 描述app使用的android系统版本信息： 因为android系统在不断的升级,新的系统版本会增加新的API,但是旧的Android设备上并没有这些API,那么就会出现新版本的应用使用新的API但是在旧的系统上运行的问题(在旧的系统上调用新的API应用会崩溃),因此需要说明本应用支持的最低android系统版本是哪个,比如说将minSdkVersion设置为19就是说这个应用在API19以及以上的设备上运行没有问题. 描述app本身的版本信息，这样对于同一个app的两个版本,系统就能区分那个是新版本,哪个是旧版本. 很重要的一个作用是描述应用对外暴露的组件(或者叫接口)： Activity，Service，Provider，BroadcastReceiver这四大组件的每一个都可以独立运行，都可以作为app启动的入口点。 AndroidManifest.xml可以告知系统点击应用图标后进入哪个Activity；可以告知系统本应用某个类(BroadcastReceiver的子类)需要监听网络变化等信息(广播)；告知系统本应用可以其他应用提供服务(ContentProvider和Service)；告知系统本应用某些类能够处理一些特定的请求(比如打开pdf扩展名的文件)；等等 其他各种需要用文本直接告知系统的：比如申请的权限,应用的主题等等。 归根结底就是Android系统的app需要通过文本方式直接告诉系统的信息太多了 一份真实的AndroidManifest.xml文件 这是Google官方示例中的teapots项目中的一个文件，我们就针对这份文件来分析字段的意义。字段的意义参考的是官方文档。 元素 首先，所有的xml都必须包含元素。这是文件的根节点。它必须要包含元素，并且指明xmlns:android和package属性。 元素中的属性 xmlns:android 这个属性定义了Android命名空间。必须设置成”http://schemas.android.com/apk/res/android”。不要手动修改。 package 这是一个完整的Java语言风格包名。包名由英文字母（大小写均可）、数字和下划线组成。每个独立的名字必须以字母开头。 构建APK的时候，构建系统使用这个属性来做两件事： 1、生成R.java类时用这个名字作为命名空间（用于访问APP的资源） 比如：package被设置成com.sample.teapot，那么生成的R类就是：com.sample.teapot.R2、用来生成在manifest文件中定义的类的完整类名。比如package被设置成com.sample.teapot，并且activity元素被声明成，完整的类名就是com.sample.teapot.MainActivity。包名也代表着唯一的application ID，用来发布应用。但是，要注意的一点是：在APK构建过程的最后一步，package名会被build.gradle文件中的applicationId属性取代。如果这两个属性值一样，那么万事大吉，如果不一样，那就要小心了。 android:versionCode 内部的版本号。用来表明哪个版本更新。这个数字不会显示给用户。显示给用户的是versionName。这个数字必须是整数。不能用16进制，也就是说不接受”0x1”这种参数 android:versionName 显示给用户看的版本号。 元素中的元素 元素 Google Play利用这个元素的值从不符合应用需要的设备上将应用过滤。 这东西的作用是将APP所依赖的硬件或者软件条件告诉别人。它说明了APP的哪些功能可以随设备的变化而变化。 使用的时候要注意，必须在单独的元素中指定每个功能，如果要多个功能，需要多个元素。比如要求设备同时具有蓝牙和相机功能： 的属性 android:name 该属性以字符串形式指定了APP要用的硬件或软件功能。 android:required 这项属性如果值为true表示需要这项功能否则应用无法工作，如果为false表示应用在必要时会使用该功能，但是如果没有此功能应用也能工作。 android:glEsVersion 指明应用需要的Opengl ES版本。高16位表示主版本号，低16位表示次版本号。例如，如果是要3.2的版本，就是0x00030002。如果定义多个glEsVersion，应用会自动启用最高的设置。 元素 此元素描述了应用的配置。这是一个必备的元素，它包含了很多子元素来描述应用的组件，它的属性影响到所有的子组件。许多属性（例如icon、label、permission、process、taskAffinity和allowTaskReparenting）都可以设置成默认值。 的属性 android:allowBackup 表示是否允许APP加入到备份还原的结构中。如果设置成false，那么应用就不会备份还原。默认值为true。 android:fullBackupContent 这个属性指向了一个xml文件，该文件中包含了在进行自动备份时的完全备份规则。这些规则定义了哪些文件需要备份。此属性是一个可选属性。默认情况下，自动备份包含了大部分app文件。 android:supportsRtl 声明你的APP是否支持RTL（Right To Left）布局。如果设置成true，并且targetSdkVersion被设置成17或更高。很多RTL API会被集火，这样你的应用就可以显示RTL布局了。如果设置成false或者targetSdkVersion被设置成16或更低。哪些RTL API就不起作用了。 该属性的默认的值是false。 android:icon APP的图标，以及每个组件的默认图标。可以在组价中自定义图标。这个属性必须设置成一个引用，指向一个可绘制的资源，这个资源必须包含图片。系统不设置默认图标。例如mipmap/ic_launcher引用的就是下面的资源 android:label 一个用户可读的标签，以及所有组件的默认标签。子组件可以用他们的label属性定义自己的标签，如果没有定义，那么就用这个标签。 标签必须设置成一个字符串资源的引用。这样它们就能和其他东西一样被定位，比如@string/app_name。当然，为了开发方便，你也可以定义一个原始字符串。 android:theme 该属性定义了应用使用的主题的，它是一个指向style资源的引用。各个activity也可以用自己的theme属性设置自己的主题。 android:name Application子类的全名。包括前面的路径。例如com.sample.teapot.TeapotApplication。当应用启动时，这个类的实例被第一个创建。这个属性是可选的，大多数APP都不需要这个属性。在没有这个属性的时候，Android会启动一个Application类的实例。 元素 该元素声明一个实现应用可视化界面的Activity（Activity类子类）。这是元素中必要的子元素。所有Activity都必须由清单文件中的元素表示。任何未在该处声明的Activity对系统都不可见，并且永远不会被执行。 android:name Activity类的名称，是Activity类的子类。该属性值为完全限定类名称，例如com.sample.teapot.TeapotNativeActivity。为了方便起见，如果第一个字符是点（"."），就需要加上元素中的包名。应用一旦发布，不应更改该名称。 没有默认值，必须指定该名称。 android:label Activity标签，可以被用户读取。该标签会在Activity激活时显示在屏幕上。如果未设置，用中的label属性。对属性的设置要求和中一样。 android:configChanges 列出 Activity 将自行处理的配置更改消息。在运行时发生配置更改时，默认情况下会关闭 Activity 然后将其重新启动，但使用该属性声明配置将阻止 Activity 重新启动。 Activity 反而会保持运行状态，并且系统会调用其 onConfigurationChanged()方法。

MANIFEST.MF是一个文本文件，里面记录了包里面所有文件的SHA1值META-INF文件夹其实就是包的签名，如果修改了包的内容后，签名中记录的值和文件不匹配就会导致文件无法使用！

AndroidManifest.xml是每个android程序中必须的文件。它位于整个项目的根目录，描述了package中暴露的组件（activities,services,等等），他们各自的实现类，各种能被处理的数据和启动位置。除了能声明程序中的Activities,ContentProviders,Services,和IntentReceivers,还能指定permissions和instrumentation（安全控制和测试）。AndroidManifest能够包含的标签：1.。2.。3.。4.。5.。6.。Service的正确注册方式：启动service应该要调用startService而不是startActivity。

android新创建Activity是需要在Manifest文件中进行注册的。注册步骤如下：一、新建一个类（*.class），继承自android.app.Activity类。二、在res/layout目录下新建一个布局xml文件，文件名随意（只能包含小写字母数字或下划线），用来设置新Activity的布局（对于如何设置Activity的布局，可参考本站相关内容）。三、打开AndroidManifest.xml文件，在里面进行一下新Activity的注册。方法是双击AndroidManifest.xml这个文件，在eclipse的编辑区下面会出现这样的选项：选择Application这个选项，将编辑区的滚动条拖到最下面，找到：当前里面有的Activity是主Activity，我们点add按钮，选择Activity，这时你会发现上面的Application Nodes中多了一个Activity，点一下左面的新的Activity，确保它被选中，之后点击在右侧的Attributes for Activity中的Name项，在弹出的对话框中输入新Activity的名字（就是你第一步新建的类的类名），输入名字时它有自动查找功能，之后点击保存，新的Activity就被注册了，我们也可以从AndroidManifest.xml的代码中看到新注册的Activity（当然你也可以直接加代码）。之后去你第一步建的那个类中为新Activity添加OnCreate方法，在类中加上：这样一个Activity就被创建好了。Manifest是什么？manifest是一种软件，属于AndroidManifest.xml文件，在简单的Android系统的应用中提出了重要的信息，它可以运行任何应用程序的代码。

只能通过sd卡的形式进行卡刷了，如果自己弄不好，可以找人维修，给你刷机一下。

android.provider.Settings1. ACTION_ACCESSIBILITY_SETTINGS ： // 跳转系统辅助功能界面Intent intent = new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS); startActivity(intent); 2. ACTION_ADD_ACCOUNT ： // 显示添加帐户创建新帐户屏幕【测试跳转微信登录界面】 Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT); startActivity(intent);3. ACTION_AIRPLANE_MODE_SETTINGS： // 飞行模式线网网络设置界面Intent intent = new Intent(Settings.ACTION_AIRPLANE_MODE_SETTINGS); startActivity(intent);或者：ACTION_WIRELESS_SETTINGS ： Intent intent = new Intent(Settings.ACTION_WIFI_SETTINGS); startActivity(intent);4. ACTION_APN_SETTINGS： // 跳转 APN设置界面Intent intent = new Intent(Settings.ACTION_APN_SETTINGS); startActivity(intent);5. 【需要参数】 ACTION_APPLICATION_DETAILS_SETTINGS： // 根据包名跳转系统自带应用程序信息界面 Uri packageURI = Uri.parse("package:" + "com.tencent.WBlog");Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,packageURI); startActivity(intent);6. ACTION_APPLICATION_DEVELOPMENT_SETTINGS : // 跳转发员选项界面Intent intent = new Intent(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS); startActivity(intent);7. ACTION_APPLICATION_SETTINGS ： // 跳转应用程序列表界面Intent intent = new Intent(Settings.ACTION_APPLICATION_SETTINGS); startActivity(intent);或者：ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS // 跳转应用程序界面【所】Intent intent = new Intent(Settings.ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS); startActivity(intent);或者：ACTION_MANAGE_APPLICATIONS_SETTINGS ：// 跳转 应用程序列表界面【已安装】Intent intent = new Intent(Settings.ACTION_MANAGE_APPLICATIONS_SETTINGS); startActivity(intent);8. ACTION_BLUETOOTH_SETTINGS ： // 跳转系统蓝牙设置界面Intent intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS); startActivity(intent);9. ACTION_DATA_ROAMING_SETTINGS ： // 跳转移网络设置界面Intent intent = new Intent(Settings.ACTION_DATA_ROAMING_SETTINGS); startActivity(intent);10. ACTION_DATE_SETTINGS ： // 跳转期间设置界面Intent intent = new Intent(Settings.ACTION_DATA_ROAMING_SETTINGS); startActivity(intent);11. ACTION_DEVICE_INFO_SETTINGS ： // 跳转手机状态界面Intent intent = new Intent(Settings.ACTION_DEVICE_INFO_SETTINGS); startActivity(intent);12. ACTION_DISPLAY_SETTINGS ： // 跳转手机显示界面Intent intent = new Intent(Settings.ACTION_DISPLAY_SETTINGS); startActivity(intent);13. ACTION_DREAM_SETTINGS 【API 18及 没测试】Intent intent = new Intent(Settings.ACTION_DREAM_SETTINGS); startActivity(intent);14. ACTION_INPUT_METHOD_SETTINGS ： // 跳转语言输入设备Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SETTINGS); startActivity(intent);15. ACTION_INPUT_METHOD_SUBTYPE_SETTINGS 【API 11及】 // 跳转 语言选择界面 【语言选择】Intent intent = new Intent(Settings.ACTION_INPUT_METHOD_SUBTYPE_SETTINGS); startActivity(intent);16. ACTION_INTERNAL_STORAGE_SETTINGS // 跳转存储设置界面【内部存储】Intent intent = new Intent(Settings.ACTION_INTERNAL_STORAGE_SETTINGS); startActivity(intent);或者：ACTION_MEMORY_CARD_SETTINGS ： // 跳转 存储设置 【记忆卡存储】Intent intent = new Intent(Settings.ACTION_MEMORY_CARD_SETTINGS); startActivity(intent);17. ACTION_LOCALE_SETTINGS ： // 跳转语言选择界面【仅English 文两种选择】 Intent intent = new Intent(Settings.ACTION_LOCALE_SETTINGS); startActivity(intent);18. ACTION_LOCATION_SOURCE_SETTINGS : // 跳转位置服务界面【管理已安装应用程序】Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS); startActivity(intent);19. ACTION_NETWORK_OPERATOR_SETTINGS ： // 跳转 显示设置选择网络运营商Intent intent = new Intent(Settings.ACTION_NETWORK_OPERATOR_SETTINGS); startActivity(intent);20. ACTION_NFCSHARING_SETTINGS ： // 显示NFC共享设置 【API 14及】Intent intent = new Intent(Settings.ACTION_NFCSHARING_SETTINGS); startActivity(intent);21. ACTION_NFC_SETTINGS ： // 显示NFC设置显示用户界面,允许NFC打或关闭 【API 16及】Intent intent = new Intent(Settings.ACTION_NFC_SETTINGS); startActivity(intent);22. ACTION_PRIVACY_SETTINGS ： // 跳转备份重置界面Intent intent = new Intent(Settings.ACTION_PRIVACY_SETTINGS); startActivity(intent);23. ACTION_QUICK_LAUNCH_SETTINGS ： // 跳转快速启设置界面Intent intent = new Intent(Settings.ACTION_QUICK_LAUNCH_SETTINGS); startActivity(intent);24. ACTION_SEARCH_SETTINGS ： // 跳转 搜索设置界面Intent intent = new Intent(Settings.ACTION_SEARCH_SETTINGS); startActivity(intent);25. ACTION_SECURITY_SETTINGS ： // 跳转安全设置界面Intent intent = new Intent(Settings.ACTION_SECURITY_SETTINGS); startActivity(intent);26. ACTION_SETTINGS ： // 跳转设置界面Intent intent = new Intent(Settings.ACTION_SETTINGS); startActivity(intent);27. ACTION_SOUND_SETTINGS // 跳转声音设置界面Intent intent = new Intent(Settings.ACTION_SOUND_SETTINGS); startActivity(intent);28. ACTION_SYNC_SETTINGS ： // 跳转账户同步界面Intent intent = new Intent(Settings.ACTION_SYNC_SETTINGS); startActivity(intent);29. ACTION_USER_DICTIONARY_SETTINGS ： // 跳转用户字典界面Intent intent = new Intent(Settings.ACTION_USER_DICTIONARY_SETTINGS); startActivity(intent);30. ACTION_WIFI_IP_SETTINGS ： // 跳转IP设定界面Intent intent = new Intent(Settings.ACTION_WIFI_IP_SETTINGS); startActivity(intent);31. ACTION_WIFI_SETTINGS ： // 跳转Wifi列表设置跳转式Intent intent = new Intent(Settings.*********);startActivity(intent);

settings 数据管理了系统的普通设置，比如铃声uri，音量,用来保证下次用户开机时候和前次关机的配置信息一直的。保存信息在android是肯定用sqlite, 这个东西真是博大精深。对数据库还有很多不理解的地方。要加强。我们OEM厂商，出货后，用户第一次开机，系统保存了些默认的配置，是怎么来的呢。有settingprovider提供。这个是个单独的apk ,就是用来共各个ap查询记录系统信息的。肯定用provider方式。在base/core/java/android/provider/settings.java这个文件提供了很多的接口用来操作数据。相对来说。及时不用看数据库的实现，只要简单操作这个类就够了。数据库名字是settings.db 创建了两个表 system, secure 要往某个表里写东西，可以直接叫到 Settings.System.put**() 跟上contentresolver,我不怕苦，不怕输，只怕再多的努力也无助。苏州 qisda 臧春杰 键明，值，同样也可以Settings.System.get** 用法类似。当然也可以Settings.secure.get put ， 安全表主要用来记录一些网络配置信息。这个完全可以通过sqliteexpert打开看看。第一开机时候，查询时候，会指定数据库名字版本private static final String DATABASE_NAME = "settings.db"; // Please, please please. If you update the database version, check to make sure the // database gets upgraded properly. At a minimum, please confirm that "upgradeVersion" // is properly propagated through your change. Not doing so will result in a loss of user // settings. private static final int DATABASE_VERSION = 80;然后oncreate时候，创建表，然后加载默认数据loadSystemSettings(db); //nancy, 有问题多讨论。loadSecureSettings(db);insert or ignore into system values();

刷机

RoI是Region of Interest的简写，是指对一张图片的“感兴趣区域”，用于RCNN系列算法当中，输入图片在经过卷积网络得到feature maps后，利用选择搜索或者RPN算法来得到多个目标候选框，这些以输入图片为参考坐标的候选框在feature maps上的映射区域，即为目标检测中所说的RoI。 RoI Pooling的过程如上图所示，其中有两个计算细节的问题有： 问题1、以输入图片为参考坐标的候选框在feature maps上如何映射？ scale = Sf / Si, Xf = scale * Xi，Yf = scale * Yi，其中 Sf 为feature map的Size，Si 为输入image的Size，（Xf，Yf）为feature map上的坐标点，（Xi，Yi）为输入image的坐标点。 问题2、如何把形状和大小各异的候选区域归一化为固定大小的目标识别区域？ 通过对feature map分块池化实现归一化到固定大小，假设ROI Pooling层的输出大小为 Wr * Hr，输入候选区域的大小为 Wi * Hi，ROI Pooling的过程包括两个步骤： ( Hi / Hr) * (Wi / Wr)，这里会有一个取整量化的操作； 候选框从原图坐标映射到的feature map坐标时，位置坐标可能存在浮点数，此时进行取整操作从而出现第一次量化；其次，在ROI Pooling求取每个小网格的位置时也同样存在浮点数取整的情况。这两次量化的结果都使得候选框的位置出现了偏差。 为了解决RoI Pooling两次量化问题，RoI Align不再采用取整量化操作，而是保留了浮点数的运算，并使用双线性插值的方式来求取像素值。具体的过程步骤如下： 假设需要输出2x2的fixed size feature map：

百度

关闭腾讯管家之类的，这些都是些使手机界面自动弹出某些很烦的东西出来，而且又不好用。

操作系统Windows 8.1处理器处理器Intel Core i5-5200U(2.2GHz/L3 3M)核心/线程双核心/四线程核心架构Broadwell处理器系列第五代酷睿i5处理器主频2.2GHz最高频率2.7GHz三级缓存L3 3M运行内存内存容量8GB内存类型DDR3L 1600存储设备硬盘类型机械硬盘硬盘容量1TB HDD光驱类型无光驱显示屏屏幕尺寸14英寸分辨率1920×1080显示屏描述宽屏,LED背光,16:9比例显示卡显卡类型独立显卡显卡芯片NVIDIA GeForce 830M显存容量2GB显存位宽64bit显存类型DDR3显卡性能支持DirectX 11电源电池电池类型锂电池电源适配器100V-240V 自适应交流电源供应器续航时间具体时间视使用环境而定

nekohiroimasita喂她吃东西的办法基本如下所示：把食物放在冰箱或者屋子里面的灶台中，让她自己回去拿，或者好感度达到二星以后直接叫她去吃东西。相关的注意事项游戏有智力游戏和活动性游戏之分，前者如下棋、积木、麻将、打牌等，后者如追逐、接力及利用球、棒、绳等器材进行的活动，多为集体活动，并有情节和规则，具有竞赛性。合理适度的游戏允许人类在模拟环境下挑战和克服障碍，可以帮助人类开发智力、锻炼思维和反应能力、训练技能、培养规则意识等，大型网络游戏还可以培养战略战术意识和团队精神。

都是在手机端，IOS和Android可以知识平台可以等同，微信开发是在电脑端完成的。通过第三方平台进行设置。而APP则是软件

特征（feature)1、1：1触控运动 Swiper默认提供1:1的触控距离，当然，这个比率是可以设置的。（touchRatio）2、触控模仿 这个功能对于开发桌面网站会很有用。简单来说，就是因为Swiper能够让鼠标事件表现得像触屏事件（点击以及拖曳滑块）3、水平/垂直 Swiper运动主要有两种模式，horizontal(水平滑动)以及vertical（垂直运动的滑动）4、自由模式（Free Mode） 这种模式下能够让slides 无需定位，就像通常的滑动条。（看下面的例子）5、旋转调整 （rotation/resize） Swiper 在移动设备旋转后能自适应尺寸。6、响应式 能使用百分比的宽高定义slides,为移动端提供不同的解决方案。7、滑动阻止 简单来说，就是，只能使用一种模式，水平或者垂直滑动。8、抵抗反弹（resistant bounds） Swiper能够提供一种机制，就是当滑动滑块超过最左以及最右（最上或最下）的位置时触发的一种抵御机制。9、原生要素（native momentum） 有不少的原生东西提供给Swiper。10、内建分页控制 Swiper能够快速生成内建的分页控制（pagination）,指定html 某一标签为pagination，Swiper就能做很多东西了。11、自动播放 只用设置延迟时间，Swiper就会自动地轮播slides直到你触碰该滑块（touch）为止。12、循环模式（Loop mode） 该种模式下，你能够无限滑动滑块，到最后一个之后会跳转回第一个。13、旋转模式（Carousel mode） Swiper 能够让你在slides父容器下设置你所需要展示的slides数量。14、滑动容器 在该特征下能够使用Swiper在一些简单的能滑动的区域里，没有slides。在Apps里十分有用。15、嵌套Swipers 能够将Swipers嵌套入各种不同的Swiper 的slide里，例如垂直的或水平的。16、任意的HTML 标签 可以将任一的HTML 内容放到slide里，不止仅限于图像。17、硬件加速 swiper 使用硬件加速技术（如果该移动设备支持的话）能够得到良好流畅的动画效果以及优美的外观，尤其是在IOS设备里。18、丰富的API Swiper拥有丰富的API接口。（不过关于中文文档似乎不多，没找着。）能够让开发者生成个人独有的分页器（pagination），上下滑块的按钮以及4个回调函数：onTouchStart,onTouchMove,onTouchEnd,onSlideSwitch。19、灵活的配置 Swiper在初始化的时候能够接受多个参数以便让其尽可能的灵活。能够配置动画的速度（speed），模式（mode水平抑或垂直的），以及自由模式（free mode）...以及其他..20、插件API（Plugins API） Swiper从1.7版本开始就变得强大起来了，因为有更多而简单的插件API允许开发者创造属于自己的Swiper 插件或通过Swiper的核心创制hooks(挂钩)（该官网处提供了几款优秀的插件Swiper smooth progress, Swiper hash navigation,swiper scrollbar）21、良好的兼容性 Swiper通用性的测试环境：移动端的Safari（iOS5下），Android 2.1+，windows Phone 8,以及最新版本的谷歌浏览器（Chrome），Safari，Firefox，IE10 以及欧朋浏览器（Opera）22、老版本IE的兼容 Swiper 2.x 开始，通过DOM动画，而非css transitions 兼容IE7 以上（需要包含jQuery），因为IE7不支持css3 transitions....简单来说，支持IE7 以上版本。23、独立性 Swiper不依赖像jQuery那样的js类库，因此能够让Swiper更加的小型以及快速。所以Swiper能够很安全地应用诸如jQuery、jQuery Mobile，jQTouch等等其他的js类库。24、超轻量级 压缩后仅仅10KB左右。以上，就是Swiper能够做的，应用以上特征就使用原生属性方法能够快速生成令人惊叹的触控接口以及apps。Usage:

二者不同一时代的系统，在各自的时代都发挥着各自的作用。塞班系统优点：1对于手机配置要求不高；2省电，手机续航时间长；3上网流量耗费得比较少。塞班系统缺点：塞班系统多为键盘操作，占用机身，因此显示界面会小，影响用户体验。安卓系统优点：1平台开放应用丰富2接入网络便利、流畅3多为触屏手机，显示界面宽裕，用户体验好。安卓系统较之塞班系统的缺陷：费电、费流量。由于科技的不断进步，已经使得安卓系统手机成本降低，大多数用户会选择更好的体验效果。因此这是时代的选择，两种系统在各自的时代都方便了用户。

完全无可比性！

Android

这是些互不沾边的词汇。 〔sao〕 Sao Paulo 的缩写，指 巴基斯的坦圣保罗 〔day〕天 /日 〔som〕是somatology (人体学) 或 start of message (报文开始) 的缩写 〔the.〕 theater (剧场/电影院) 的缩写 〔em〕印刷的行长单位 〔di〕diameter 或 diametral (直径) 的缩写 〔lam〕鞭打 / 潜逃 〔roi〕 return on investment (投资回收率) 的缩写

为了正常安装并使用ViPER4 Android-FX音效驱动程序，请检查并遵守如下安装过程。使用前检查：1、确保手机的操作系统为Android(安卓)4.0或4.1版(ICS和JB)。2、手机必须已经ROOT，即应用程序可以获取root权限。安装过busybox的可提高驱动安装成功率。3、手机的CPU主频必须大于等于500MHz。注意：对于HTC和索尼(索爱)品牌的手机或其他ROM内已经带有Beats、SRS、XLOUD的用户请下载手动安装包进行手动安装。以下自动安装模式将会禁用机器内原有的效果器。安装过程：1、安装V4AManager.apk。2、打开V4A管理器，并点击“安装/更新”按钮，安装ViPER4Android音效驱动程序。此时请授予V4A管理器的root权限。在执行此步骤时，V4A管理器会将系统内已经存在的音效驱动程序进行备份，然后安装ViPER4Android驱动。3、如不需要的话可以将V4AManager.apk卸载(不会影响将来还原驱动)。4、安装ViPER4Android.apk。5、在360、LBE等系统内存清理或禁止开机自启的管理软件中将ViPER4Android加入白名单。6、打开程序管理器，找到ViPER4Android FX，并选择清除数据。7、重启手机。8、打开ViPER4Android并进行偏好的音效设定。该音效会应用到系统内的所有声音上，包括自带/第三方播放器、游戏等(不包括通话)。验证自动安装是否成功：1、打开RootExplorer或其他文件浏览器。2、定位至/system/lib/soundfx/。3、查看是否存在libv4a_fx_ics.so。4、不存在libviper4android_ics.so(若存在此文件则手动删除)。若以上4点均满足，则可以以最大兼容性完美使用V4A音效。否则请参考手动安装进行安装。卸载(还原)过程：1、卸载ViPER4Android.apk。2、安装V4AManager.apk。3、打开V4A管理器，并点击“卸载/还原”按钮。4、卸载V4AManager.apk并重新启动手机。

为了正常安装并使用ViPER4 Android-FX音效驱动程序，请检查并遵守如下安装过程。使用前检查：1、确保手机的操作系统为Android(安卓)4.0或4.1版(ICS和JB)。2、手机必须已经ROOT，即应用程序可以获取root权限。安装过busybox的可提高驱动安装成功率。3、手机的CPU主频必须大于等于500MHz。注意：对于HTC和索尼(索爱)品牌的手机或其他ROM内已经带有Beats、SRS、XLOUD的用户请下载手动安装包进行手动安装。以下自动安装模式将会禁用机器内原有的效果器。安装过程：1、安装V4AManager.apk。2、打开V4A管理器，并点击“安装/更新”按钮，安装ViPER4Android音效驱动程序。此时请授予V4A管理器的root权限。在执行此步骤时，V4A管理器会将系统内已经存在的音效驱动程序进行备份，然后安装ViPER4Android驱动。3、如不需要的话可以将V4AManager.apk卸载(不会影响将来还原驱动)。4、安装ViPER4Android.apk。5、在360、LBE等系统内存清理或禁止开机自启的管理软件中将ViPER4Android加入白名单。6、打开程序管理器，找到ViPER4Android FX，并选择清除数据。7、重启手机。8、打开ViPER4Android并进行偏好的音效设定。该音效会应用到系统内的所有声音上，包括自带/第三方播放器、游戏等(不包括通话)。验证自动安装是否成功：1、打开RootExplorer或其他文件浏览器。2、定位至/system/lib/soundfx/。3、查看是否存在libv4a_fx_ics.so。4、不存在libviper4android_ics.so(若存在此文件则手动删除)。若以上4点均满足，则可以以最大兼容性完美使用V4A音效。否则请参考手动安装进行安装。卸载(还原)过程：1、卸载ViPER4Android.apk。2、安装V4AManager.apk。3、打开V4A管理器，并点击“卸载/还原”按钮。4、卸载V4AManager.apk并重新启动手机。

为了正常安装并使用ViPER4 Android-FX音效驱动程序，请检查并遵守如下安装过程。使用前检查：1、确保手机的操作系统为Android(安卓)4.0或4.1版(ICS和JB)。2、手机必须已经ROOT，即应用程序可以获取root权限。安装过busybox的可提高驱动安装成功率。3、手机的CPU主频必须大于等于500MHz。注意：对于HTC和索尼(索爱)品牌的手机或其他ROM内已经带有Beats、SRS、XLOUD的用户请下载手动安装包进行手动安装。以下自动安装模式将会禁用机器内原有的效果器。安装过程：1、安装V4AManager.apk。2、打开V4A管理器，并点击“安装/更新”按钮，安装ViPER4Android音效驱动程序。此时请授予V4A管理器的root权限。在执行此步骤时，V4A管理器会将系统内已经存在的音效驱动程序进行备份，然后安装ViPER4Android驱动。3、如不需要的话可以将V4AManager.apk卸载(不会影响将来还原驱动)。4、安装ViPER4Android.apk。5、在360、LBE等系统内存清理或禁止开机自启的管理软件中将ViPER4Android加入白名单。6、打开程序管理器，找到ViPER4Android FX，并选择清除数据。7、重启手机。8、打开ViPER4Android并进行偏好的音效设定。该音效会应用到系统内的所有声音上，包括自带/第三方播放器、游戏等(不包括通话)。验证自动安装是否成功：1、打开RootExplorer或其他文件浏览器。2、定位至/system/lib/soundfx/。3、查看是否存在libv4a_fx_ics.so。4、不存在libviper4android_ics.so(若存在此文件则手动删除)。若以上4点均满足，则可以以最大兼容性完美使用V4A音效。否则请参考手动安装进行安装。卸载(还原)过程：1、卸载ViPER4Android.apk。2、安装V4AManager.apk。3、打开V4A管理器，并点击“卸载/还原”按钮。4、卸载V4AManager.apk并重新启动手机。

Android为了保证系统及应用的安全性，在安装APK的时候需要校验包的完整性，同时，对于覆盖安装的场景还要校验新旧是否匹配，这两者都是通过Android签名机制来进行保证的，本文就简单看下Android的签名与校验原理，分一下几个部分分析下： 签名是摘要与非对称密钥加密相相结合的产物，摘要就像内容的一个指纹信息，一旦内容被篡改，摘要就会改变，签名是摘要的加密结果，摘要改变，签名也会失效。Android APK签名也是这个道理，如果APK签名跟内容对应不起来，Android系统就认为APK内容被篡改了，从而拒绝安装，以保证系统的安全性。目前Android有三种签名V1、V2（N）、V3（P），本文只看前两种V1跟V2，对于V3的轮密先不考虑。先看下只有V1签名后APK的样式： 再看下只有V2签名的APK包样式： 同时具有V1 V2签名： 可以看到，如果只有V2签名，那么APK包内容几乎是没有改动的，META_INF中不会有新增文件，按Google官方文档：在使用v2签名方案进行签名时，会在APK文件中插入一个APK签名分块，该分块位于zip中央目录部分之前并紧邻该部分。在APK签名分块内， 签名和签名者身份信息会存储在APK签名方案v2分块中，保证整个APK文件不可修改 ，如下图： 而V1签名是通过META-INF中的三个文件保证签名及信息的完整性： V1签名是如何保证信息的完整性呢？V1签名主要包含三部分内容，如果狭义上说签名跟公钥的话，仅仅在.rsa文件中，V1签名的三个文件其实是一套机制，不能单单拿一个来说事， 如果对APK中的资源文件进行了替换，那么该资源的摘要必定发生改变，如果没有修改MANIFEST.MF中的信息，那么在安装时候V1校验就会失败，无法安装，不过如果篡改文件的同时，也修改其MANIFEST.MF中的摘要值，那么MANIFEST.MF校验就可以绕过。 CERT.SF个人觉得有点像冗余，更像对文件完整性的二次保证，同绕过MANIFEST.MF一样，.SF校验也很容易被绕过。 CERT.RSA与CERT.SF是相互对应的，两者名字前缀必须一致，不知道算不算一个无聊的标准。看下CERT.RSA文件内容： CERT.RSA文件里面存储了证书公钥、过期日期、发行人、加密算法等信息，根据公钥及加密算法，Android系统就能计算出CERT.SF的摘要信息，其严格的格式如下： 从CERT.RSA中，我们能获的证书的指纹信息，在微信分享、第三方SDK申请的时候经常用到，其实就是公钥+开发者信息的一个签名： 除了CERT.RSA文件，其余两个签名文件其实跟keystore没什么关系，主要是文件自身的摘要及二次摘要，用不同的keystore进行签名，生成的MANIFEST.MF与CERT.SF都是一样的，不同的只有CERT.RSA签名文件。也就是说前两者主要保证各个文件的完整性，CERT.RSA从整体上保证APK的来源及完整性，不过META_INF中的文件不在校验范围中，这也是V1的一个缺点。V2签名又是如何保证信息的完整性呢？ 前面说过V1签名中文件的完整性很容易被绕过，可以理解 单个文件完整性校验的意义并不是很大 ，安装的时候反而耗时，不如采用更加简单的便捷的校验方式。V2签名就不针对单个文件校验了，而是 针对APK进行校验 ，将APK分成1M的块，对每个块计算值摘要，之后针对所有摘要进行摘要，再利用摘要进行签名。 也就是说，V2摘要签名分两级，第一级是对APK文件的1、3 、4 部分进行摘要，第二级是对第一级的摘要集合进行摘要，然后利用秘钥进行签名。安装的时候，块摘要可以并行处理，这样可以提高校验速度。 APK是先摘要，再签名，先看下摘要的定义：Message Digest：摘要是对消息数据执行一个单向Hash，从而生成一个固定长度的Hash值，这个值就是消息摘要，至于常听到的MD5、SHA1都是摘要算法的一种。理论上说，摘要一定会有碰撞，但只要保证有限长度内碰撞率很低就可以，这样就能利用摘要来保证消息的完整性，只要消息被篡改，摘要一定会发生改变。但是，如果消息跟摘要同时被修改，那就无从得知了。 而数字签名是什么呢（公钥数字签名），利用非对称加密技术，通过私钥对摘要进行加密，产生一个字符串，这个字符串+公钥证书就可以看做消息的数字签名，如RSA就是常用的非对称加密算法。在没有私钥的前提下，非对称加密算法能确保别人无法伪造签名，因此数字签名也是对发送者信息真实性的一个有效证明。不过由于Android的keystore证书是自签名的，没有第三方权威机构认证，用户可以自行生成keystore，Android签名方案无法保证APK不被二次签名。 知道了摘要跟签名的概念后，再来看看Android的签名文件怎么来的？如何影响原来APK包？通过sdk中的apksign来对一个APK进行签名的命令如下： 其主要实现在 android/platform/tools/apksig 文件夹中，主体是ApkSigner.java的sign函数，函数比较长，分几步分析 先来看这一步，ApkUtils.findZipSections，这个函数主要是解析APK文件，获得ZIP格式的一些简单信息，并返回一个ZipSections， ZipSections包含了ZIP文件格式的一些信息，比如中央目录信息、中央目录结尾信息等，对比到zip文件格式如下： 获取到 ZipSections之后，就可以进一步解析APK这个ZIP包，继续走后面的签名流程， 可以看到先进行了一个V2签名的检验，这里是用来签名，为什么先检验了一次？第一次签名的时候会直接走这个异常逻辑分支，重复签名的时候才能获到取之前的V2签名，怀疑这里获取V2签名的目的应该是为了排除V2签名，并获取V2签名以外的数据块，因为签名本身不能被算入到签名中，之后会解析中央目录区，构建一个DefaultApkSignerEngine用于签名 先解析中央目录区，获取AndroidManifest文件，获取minSdkVersion(影响签名算法)，并构建DefaultApkSignerEngine，默认情况下V1 V2签名都是打开的。 第五步与第六步的主要工作是：apk的预处理，包括目录的一些排序之类的工作，应该是为了更高效处理签名，预处理结束后，就开始签名流程，首先做的是V1签名（默认存在，除非主动关闭）： 步骤7、8、9都可以看做是V1签名的处理逻辑，主要在V1SchemeSigner中处理，其中包括创建META-INFO文件夹下的一些签名文件，更新中央目录、更新中央目录结尾等，流程不复杂，不在赘述，简单流程就是： 这里特殊提一下重复签名的问题： 对一个已经V1签名的APK再次V1签名不会有任何问题 ，原理就是：再次签名的时候，会排除之前的签名文件。 可以看到目录、META-INF文件夹下的文件、sf、rsa等结尾的文件都不会被V1签名进行处理，所以这里不用担心多次签名的问题。接下来就是处理V2签名。 V2SchemeSigner处理V2签名，逻辑比较清晰，直接对V1签名过的APK进行分块摘要，再集合签名，V2签名不会改变之前V1签名后的任何信息，签名后，在中央目录前添加V2签名块，并更新中央目录结尾信息，因为V2签名后，中央目录的偏移会再次改变： 签名校验的过程可以看做签名的逆向，只不过覆盖安装可能还要校验公钥及证书信息一致，否则覆盖安装会失败。签名校验的入口在PackageManagerService的install里，安装官方文档，7.0以上的手机优先检测V2签名，如果V2签名不存在，再校验V1签名，对于7.0以下的手机，不存在V2签名校验机制，只会校验V1，所以，如果你的App的miniSdkVersion<24(N)，那么你的签名方式必须内含V1签名： 校验流程就是签名的逆向，了解签名流程即可，本文不求甚解，有兴趣自己去分析，只是额外提下覆盖安装，覆盖安装除了检验APK自己的完整性以外，还要校验证书是否一致只有证书一致（同一个keystore签名），才有可能覆盖升级。覆盖安装同全新安装相比较多了几个校验 这里只关心证书部分： Android V1及V2签名签名原理简析 仅供参考，欢迎指正

可以 android和web联系不大 和swing很像

基于本控件内的位置关系。

PTP修改： 路径：frameworksavmediamtpMtpServer.cpp MTP在PC端显示的名称： 路径：frameworksasemediajavaandroidmtpMtpDatabase.java 修改蓝牙名称： 路径：devicegenericcommonluetoothdroid_buildcfg.h 路径：devicemediatekcommoncustom.conf 路径：vendormediatekproprietaryframeworksasecustomcustom.conf

//新建数组适配器（ArrayAdapter） list:数据源ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); //设置adapter设置下一列表样式 adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

ArrayAdapter adapter = ArrayAdapter.createFromResource ( this , R.array. cities , R.layout. spinnerlayout ); spinnerlayout.xml 这样就可以居中显示了

能把你要实现的效果或功能说详细点吗

你可以给Spinner的layout定义加个android:background属性，引用一张图片当背景或者用某种颜色当背景。

spinner.setOnItemSelectedListener(new Spinner.OnItemSelectedListener() { @Override public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) { // TODO Auto-generated method stub String ditem = item.getItemAtPosition(arg2).toString();//取的选择的值，根据选择的值输出内容操作 } @Override public void onNothingSelected(AdapterView<?> arg0) { // TODO Auto-generated method stub } });

这里是看不出什么问题的你的这段处理是在Activity的onCreate里面写的吗？我这里的示例代码String[] from = new String[] { "colorsData" }; int[] to = new int[] { android.R.id.text1 };Spinner spinner = (Spinner) findViewById(R.id.spinner); SimpleAdapter simpleAdapter = new SimpleAdapter(this, data, android.R.layout.simple_spinner_item, from, to); simpleAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); spinner.setAdapter(simpleAdapter); spinner.setOnItemSelectedListener(new OnItemSelectedListener() { @Override public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { Toast.makeText( parent.getContext(), "Selected Color:- " + parent.getItemAtPosition(position), Toast.LENGTH_LONG).show(); } }); }

点击setting--》plugins--》找到“Android Support”选项，并勾选，然后会提示重启android studio ，点击重启，ok，如果已经设置好SDK的路径的话，问题解决，。

ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource ( this , R.array. cities , R.layout. spinnerlayout ); spinnerlayout.xml<?xml version = "1.0" encoding = "utf-8"?><TextView xmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="fill_parent"android:layout_height="fill_parent"android:gravity="center" />这样就可以居中显示了

用intent传。

原生spinner太难看一般都自定义一个popupwindow更好看

//新建数组适配器（ArrayAdapter） list:数据源 ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item, list); //设置adapter设置下一列表样式 adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

自定义吧，没有直接设置颜色的很简单的东西，重写一下Adapter，然后自己对Adapter每个Item布局，在布局里面设置一下点击效果就行了。如：public class MainActivity extends Activity {private Spinner mSpinner;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);initView();}private void initView(){mSpinner = (Spinner)findViewById(R.id.spinner);MyAdapter adapter = new MyAdapter(getResources().getStringArray(R.array.girl_names));mSpinner.setAdapter(adapter);}private class MyAdapter extends BaseAdapter{private String[] idInt ;public MyAdapter(String[] idInt){this.idInt = idInt;}@Overridepublic int getCount() {// TODO Auto-generated method stubreturn idInt.length;}@Overridepublic Object getItem(int arg0) {// TODO Auto-generated method stubreturn idInt[arg0];}@Overridepublic long getItemId(int arg0) {// TODO Auto-generated method stubreturn 0;}@Overridepublic View getView(int arg0, View arg1, ViewGroup arg2) {// TODO Auto-generated method stubif(arg1 == null){arg1 = getLayoutInflater().inflate(R.layout.spinner_item, null);}TextView text = (TextView)arg1.findViewById(R.id.spinner_item_id);text.setText(idInt[arg0]);return arg1;}}spinner_item.xml<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:background="@drawable/text_selector"android:orientation="vertical" ><TextViewandroid:layout_margin="10dip"android:id="@+id/spinner_item_id"android:layout_width="match_parent"android:layout_height="wrap_content"android:textIsSelectable="true" ></TextView></LinearLayout>然后：text_selector.xml:<?xml version="1.0" encoding="utf-8"?><selector xmlns:android="http://schemas.android.com/apk/res/android" ><item android:state_pressed="true" android:drawable="@android:color/black"></item><item android:state_pressed="false" android:drawable="@android:color/transparent"></item></selector>

在layout中自定义spinner_item.xml，里面设置字体颜色大小等，然后代码中新建new ArrayAdapter<String>(this,R.layout.spinner_item);然后setAdapter(xx);即可

1、准备两张图片，并做好9.png2、在drawable中定义spinner_selector.xml<?xml version="1.0" encoding="utf-8"?><selector xmlns:android="http://schemas.android.com/apk/res/android" > <item android:state_pressed="true" android:drawable="@drawable/spinner_press" /><!--按下时效果--> <item android:state_pressed="false" android:drawable="@drawable/spinner" /><!--默认效果--> </selector>3、style中定义 <!-- spinner --> <style name="spinner_style"> <item name="android:background">@drawable/spinner_selector</item> <item name="android:paddingLeft">5dip</item> </style>4、调用<Spinner android:id="@+id/field_item_spinner_content" style="@style/spinner_style" android:layout_width="fill_parent" android:layout_height="wrap_content" android:animationCache="true" android:drawSelectorOnTop="true" />5、在layout中定义simple_spinner_item.xml<?xml version="1.0" encoding="utf-8"?><CheckedTextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@android:id/text1" android:paddingLeft="5dip" android:paddingRight="5dip" android:gravity="center_vertical" android:textColor="#808080" android:singleLine="true" android:layout_width="fill_parent" android:layout_height="wrap_content" />6、java代码ArrayAdapter<String> adapter = new ArrayAdapter<String>(mContext, R.layout.simple_spinner_item);String level[] = getResources().getStringArray(R.array.affair_level);//资源文件for (int i = 0; i < level.length; i++) {adapter.add(level[i]);}adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);spinner.setAdapter(adapter);

spinner.setOnItemSelectedListener(new OnItemSelectedListener() { @Override public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { switch (position) { case 0: if(isFirstIn){ isFirstIn = false; }else{ Toast.makeText(PostDetail.this, "分享", Toast.LENGTH_SHORT).show(); } break;...懂了没，很简单的标记就可以了

xiaotian0627说的不是默认，就是你选的。如果你的意思是选择的条目对应的数据那么就要用map

s1.getSelectedItem()).toString()

自定义

ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource ( this , R.array. cities , R.layout. spinnerlayout ); spinnerlayout.xml<?xml version = "1.0" encoding = "utf-8"?><TextView xmlns:android="http //schemas android com/apk/res/android"android:layout_width="fill_parent"android:layout_height="fill_parent"android:gravity="center" />这样就可以居中显示了

1、获取选中值要通过spinner的setOnItemSelectedListener()事件来操作，根据spinner绑定值的方式的不一样，获取选中值的方式略有不同。2、如果没有用实体层绑定数据的话，诸如通过SimpleAdapter adapter = new SimpleAdapter(HRInputBase_Activity.this, items, R.layout.sp_item,new String[] { "text", "value" }, new int[] {R.id.sp_text, R.id.sp_value });sp_privince.setAdapter(adapter);这种方式绑定的。获取的方式为：TextView ProvinceTxt = (TextView) sp_privince.getSelectedView().findViewById(R.id.sp_value); // 得到选中的选项IdString codeString = ProvinceTxt.getText().toString();如果使用的是实体层的话，在setOnItemSelectedListener()事件中根据点击的索引值获取相对应的实体类，然后从实体类中获取对应得Code和Value值，相对来说，使用实体层更加的方便，代码整洁。3、两者都使用的是Adapter数据集的绑定，主要是考察对adapter的知识，可以对这方面多学习一点。

千峰扣丁学堂Android 培训为您解答：　　首先了解Spinner所用到的适配器相关的参数　　AdapterView parent, 表示Spinner　　View view, 表示被选择的条目　　int position, 表示数据的下标　　long id 表示该条目在所有条目中的下标　　一般来说 postion 和 id 都是相同的　　理解了适配器相关的参数的意思，就很容易写出得到item的代码，　　public void onItemSelected(AdapterView parent, View view, int position,　　long id) {　　//知道那个条目被选择啦　　//1 由于数据在view上可以直接从view里面获取　　/* TextView tv_city = (TextView) view.findViewById(R.id.tv_city);　　String city = tv_city.getText().toString();　　Toast.makeText(this, city, 1).show();*/　　//2 知道数据的下标可以从数据里面直接获取　　/* String city = citys[position];　　Toast.makeText(this, city, 1).show();*/　　//3 从Spinner身上直接获取　　/* String city = (String) spinner.getSelectedItem();　　Toast.makeText(this, city, 1).show();*/　　//4 从adapter获取　　String city = adapter.getItem(position);　　Toast.makeText(this, city, 1).show();　　}

-spinner.setOnItemSelectedListener(new OnItemSelectedListener(){ @Override public void onItemSelected(AdapterView parent, View view, int position, long id){ curyid = position; //showPrice(position); TextView tv = (TextView)view; tv.setTextColor(getResources().getColor(R.color.white)); //设置颜色 tv.setTextSize(12.0f); //设置大小 tv.setGravity(android.view.Gravity.CENTER_HORIZONTAL); //设置居中 } @Override public void onNothingSelected(AdapterView parent){} });

1，获取选中值要通过spinner的setOnItemSelectedListener()事件来操作，根据spinner绑定值的方式的不一样，获取选中值的方式略有不同。2，如果没有用实体层绑定数据的话，诸如通过SimpleAdapter adapter = new SimpleAdapter(HRInputBase_Activity.this, items, R.layout.sp_item,new String[] { "text", "value" }, new int[] {R.id.sp_text, R.id.sp_value });sp_privince.setAdapter(adapter);这种方式绑定的。获取的方式为：TextView ProvinceTxt = (TextView) sp_privince.getSelectedView().findViewById(R.id.sp_value); // 得到选中的选项IdString codeString = ProvinceTxt.getText().toString();如果使用的是实体层的话，在setOnItemSelectedListener()事件中根据点击的索引值获取相对应的实体类，然后从实体类中获取对应得Code和Value值，相对来说，使用实体层更加的方便，代码整洁。3，两者都使用的是Adapter数据集的绑定，主要是考察对adapter的知识，可以对这方面多学习一点。

　　1、在layout中自定义spinner_item.xml，里面设置字体颜色大小等，然后代码中新建newArrayAdapter<String>(this,R.layout.spinner_item);然后setAdapter(xx);　　2、自定义一个布局文件spinner_item.xml，这个就是spinner每一项的样式，一般是TextView，当然也可以是其他控件　　3、也可以监听listview点击事件，在里面改变颜色，

1，获取选中值要通过spinner的setOnItemSelectedListener()事件来操作，根据spinner绑定值的方式的不一样，获取选中值的方式略有不同。2，如果没有用实体层绑定数据的话，诸如通过SimpleAdapter adapter = new SimpleAdapter(HRInputBase_Activity.this, items, R.layout.sp_item,new String[] { "text", "value" }, new int[] {R.id.sp_text, R.id.sp_value });sp_privince.setAdapter(adapter);这种方式绑定的。获取的方式为：TextView ProvinceTxt = (TextView) sp_privince.getSelectedView().findViewById(R.id.sp_value); // 得到选中的选项IdString codeString = ProvinceTxt.getText().toString();如果使用的是实体层的话，在setOnItemSelectedListener()事件中根据点击的索引值获取相对应的实体类，然后从实体类中获取对应得Code和Value值，相对来说，使用实体层更加的方便，代码整洁。3，两者都使用的是Adapter数据集的绑定，主要是考察对adapter的知识，可以对这方面多学习一点。

使用Looper判断，方法为: Looper.myLooper() != Looper.getMainLooper()使用线程句柄判断，将主线程的Thread.currentThread()获取到主线程当前句柄，保存起来，在需要判断的时候调用Thread.currentThread()来与之比较，即可判断当前线程是否是主线程了

1.android dvm 的进程和Linux的进程，应用程序的进程是否为同一个概念：答：dvm是dalivk虚拟机。每一个android应用程序都在自己的进程中运行，都拥有一个dalivk虚拟机实例。而每一个dvm都是在linux的一个进程。所以说可以认为是同一个概念。2.android的动画有哪几种？他们的特点和区别是什么？答：两种，一种是tween动画，一种是frame动画。tween动画，这种实现方式可以使视图组件移动，放大或缩小以及产生透明度的变化。frame动画，传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。3.handler进制的原理：答：android提供了handler和looper来满足线程间的通信。Handler先进先出原则。looper用来管理特定线程内对象之间的消息交换(message Exchange).1)looper:一个线程可以产生一个looper对象，由它来管理此线程里的message queue(消息队列)2)handler:你可以构造一个handler对象来与looper沟通，以便push新消息到messagequeue里;或者接收looper(从messagequeue里取出)所送来的消息。3)messagequeue:用来存放线程放入的消息。4)线程：UI thread 通常就是main thread,而android启动程序时会为它建立一个message queue.4.android view的刷新：答：Android中对View的更新有很多种方式，使用时要区分不同的应用场合。我感觉最要紧的是分清：多线程和双缓冲的使用情况。1).不使用多线程和双缓冲这种情况最简单了，一般只是希望在View发生改变时对UI进行重绘。你只需在Activity中显式地调用View对象中的invalidate()方法即可。系统会自动调用 View的onDraw()方法。2).使用多线程和不使用双缓冲这种情况需要开启新的线程，新开的线程就不好访问View对象了。强行访问的话会报：android.view.ViewRoot$CalledFromWrongThreadException：Only the originalthread that created a view hierarchy can touch its views.这时候你需要创建一个继承了android.os.Handler的子类，并重写handleMessage(Messagemsg)方法。android.os.Handler是能发送和处理消息的，你需要在Activity中发出更新UI的消息，然后再你的Handler(可以使用匿名内部类)中处理消息(因为匿名内部类可以访问父类变量，你可以直接调用View对象中的invalidate()方法 )。也就是说：在新线程创建并发送一个Message，然后再主线程中捕获、处理该消息。3).使用多线程和双缓冲Android中SurfaceView是View的子类，她同时也实现了双缓冲。你可以定义一个她的子类并实现SurfaceHolder.Callback接口。由于实现SurfaceHolder.Callback接口，新线程就不需要android.os.Handler帮忙了。SurfaceHolder中lockCanvas()方法可以锁定画布，绘制玩新的图像后调用unlockCanvasAndPost(canvas)解锁(显示)，还是比较方便得。5.说说mvc模式的原理，它在android中的运用:答：android的官方建议应用程序的开发采用mvc模式。何谓mvc?mvc是model,view,controller的缩写，mvc包含三个部分：l模型(model)对象：是应用程序的主体部分，所有的业务逻辑都应该写在该层。2视图(view)对象：是应用程序中负责生成用户界面的部分。也是在整个mvc架构中用户唯一可以看到的一层，接收用户的输入，显示处理结果。3控制器(control)对象：是根据用户的输入，控制用户界面数据显示及更新model对象状态的部分，控制器更重要的一种导航功能，想用用户出发的相关事件，交给m哦得了处理。android鼓励弱耦合和组件的重用，在android中mvc的具体体现如下：1)视图层(view)：一般采用xml文件进行界面的描述，使用的时候可以非常方便的引入，当然，如何你对android了解的比较的多了话，就一定 可以想到在android中也可以使用javascript+html等的方式作为view层，当然这里需要进行java和javascript之间的通 信，幸运的是，android提供了它们之间非常方便的通信实现。2)控制层(controller)：android的控制层的重 任通常落在了众多的acitvity的肩上，这句话也就暗含了不要在acitivity中写代码，要通过activity交割model业务逻辑层处理， 这样做的另外一个原因是android中的acitivity的响应时间是5s，如果耗时的操作放在这里，程序就很容易被回收掉。3)模型层(model)：对数据库的操作、对网络等的操作都应该在model里面处理，当然对业务计算等操作也是必须放在的该层的。6.Activity的生命周期:答：onCreate: 在这里创建界面，做一些数据 的初始化工作onStart: 到这一步变成用户可见不可交互的onResume:变成和用户可交互 的，(在activity 栈系统通过栈的方式管理这些个Activity的最上面，运行完弹出栈，则回到上一个Activity)onPause: 到这一步是可见但不可交互的，系统会停止动画 等消耗CPU 的事情从上文的描述已经知道，应该在这里保存你的一些数据,因为这个时候你的程序的优先级降低，有可能被系统收回。在这里保存的数据，应该在onstop: 变得不可见，被下一个activity覆盖了onDestroy: 这是activity被干掉前最后一个被调用方法了，可能是外面类调用finish方法或者是系统为了节省空间将它暂时性的干掉7.让Activity变成一个窗口：答：Activity属性设定：有时候会做个应用程序是漂浮在手机主界面的。这个只需要在设置下Activity的主题theme,即在Manifest.xml定义Activity的地方加一句：android :theme="@android:style/Theme.Dialog"如果是作半透明的效果：android:theme="@android:style/Theme.Translucent"8.Android中常用的五种布局:答：LinearLayout线性布局;AbsoluteLayout绝对布局;TableLayout表格布局;RelativeLayout相对布局;FrameLayout帧布局;9.Android的五种数据存储方式：答：sharedPreferences;文件;SQLite;contentProvider;网络附上出处链接：http://www.51edu.com/it/bckf/36635.html

当Android应用启动的时候，会先创建一个应用主线程的Looper对象，Looper实现了一个简单的消息队列，一个一个的处理里面的Message对象。主线程Looper对象在整个应用生命周期中存在。当在主线程中初始化Handler时，该Handler和Looper的消息队列关联。发送到消息队列的Message会引用发送该消息的Handler对象，这样系统可以调用 Handler#handleMessage(Message) 来分发处理该消息。在Java中，非静态(匿名)内部类会引用外部类对象。而静态内部类不会引用外部类对象。如果外部类是Activity，则会引起Activity泄露 。当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。要修改该问题，只需要按照Lint提示的那样，把Handler类定义为静态即可，然后通过WeakReference 来保持外部的Activity对象。

1)一个 Android 程序开始运行时，会单独启动一个Process。默认情况下，所有这个程序中的Activity或者Service都会跑在这个Process。默认情况下，一个Android程序也只有一个Process，但一个Process下却可以有许多个Thread。2)一个 Android 程序开始运行时，就有一个主线程Main Thread被创建。该线程主要负责UI界面的显示、更新和控件交互，所以又叫UI Thread。3)一个Android程序创建之初，一个Process呈现的是单线程模型--即MainThread，所有的任务都在一个线程中运行，所以，MainThread所调用的每一个函数，其耗时应该越短越好，而对于比较耗时的工作，应该交给子线程去做，以避免主线程（UI线程）被阻塞，导致程序出现ANR(Application not response)一个Activity就运行在一个线程中吗？或者编码时，如果不是明确安排在不同线程中的两个Activity，其就都是在同一个线程中？那从一个Activity跳转到另一个Activity时，是不是跳出的那个Activity就处在睡眠状态了？【答】 每个Activity都有一个Process属性，可以指定该Activity是属于哪个进程的。当然如果不明确指明，应该就是从属于默认进程（Application指定的，如其未指定，应该就是默认主进程）。Android中有Task的概念，而同一个Task的各个Activity会形成一个栈，只有站定的Activity才有机会与用户交互。原文地址：Android中的进程与线程 原文作者：江鹏当应用程序的组件第一次运行时，Android将启动一个只有一个执行线程的Linux进程。默认，应用程序所有的组件运行在这个进程和线程中。然而，你可以安排组件运行在其他进程中，且你可以为进程衍生出其它线程。本文从下面几点来介绍Android的进程与线程：1、进程组件运行于哪个进程中由清单文件控制。组件元素——<activity>、<service>、<receiver>、<provider>，都有一个process属性可以指定组件运行在哪个进程中。这个属性可以设置为每个组件运行在自己的进程中，或者某些组件共享一个进程而其他的不共享。他们还可以设置为不同应用程序的组件运行在同一个进程中——假设这些应用程序共享同一个Linux用户ID且被分配了同样的权限。<application>元素也有process属性，为所有的组件设置一个默认值。所有的组件都在特定进程的主线程中实例化，且系统调用组件是由主线程派遣。不会为每个实例创建单独的线程，因此，对应这些调用的方法——诸如View.onKeyDown()报告用用户的行为和生命周期通知，总是运行在进程的主线程中。这意味着，没有组件当被系统调用时应该执行很长时间或阻塞操作（如网络操作或循环计算），因为这将阻塞进程中的其它组件。你可以为长操作衍生独立的线程。public boolean onKeyDown(int keyCode,KeyEvent event)：默认实现KeyEvent.Callback.onKeyMultiple()，当按下视图的KEYCODE_DPAD_CENTER或KEYCODE_ENTER然后释放时执行，如果视图可用且可点击。参数keyCode-表示按钮被按下的键码，来自KeyEvent event-定义了按钮动作的KeyEvent对象返回值如果你处理事件，返回true；如果你想下一个接收者处理事件，返回false。当内存剩余较小且其它进程请求较大内存并需要立即分配，Android要回收某些进程，进程中的应用程序组件会被销毁。当他们再次运行时，会重新开始一个进程。当决定终结哪个进程时，Android会权衡他们对用户重要性的相对权值。例如，与运行在屏幕可见的活动进程相比（前台进程），它更容易关闭一个进程，它的活动在屏幕是不可见（后台进程）。决定是否终结进程，取决于运行在进程中的组件状态。关于组件的状态，将在后面一篇——组件生命周期中介绍。2、线程虽然你可能会将你的应用程序限制在一个进程中，但有时候你会需要衍生一个线程做一些后台工作。因为用户界面必须很快地响应用户的操作，所以活动寄宿的线程不应该做一些耗时的操作如网络下载。任何不可能在短时间完成的操作应该分配到别的线程。线程在代码中是用标准的Java线程对象创建的，Android提供了一些方便的类来管理线程——Looper用于在线程中运行消息循环、Handler用户处理消息、HandlerThread用户设置一个消息循环的线程。Looper类该类用户在线程中运行消息循环。线程默认没有消息循环，可以在线程中调用prepare()创建一个运行循环；然后调用loop()处理消息直到循环结束。大部分消息循环交互是通过Handler类。下面是一个典型的执行一个Looper线程的例子，分别使用prepare()和loop()创建一个初始的Handler与Looper交互： 1. Android中进程与进程、线程与线程之间如何通信？1)一个 Android 程序开始运行时，会单独启动一个Process。默认情况下，所有这个程序中的Activity或者Service都会跑在这个Process。默认情况下，一个Android程序也只有一个Process，但一个Process下却可以有许多个Thread。2)一个 Android 程序开始运行时，就有一个主线程Main Thread被创建。该线程主要负责UI界面的显示、更新和控件交互，所以又叫UI Thread。3)一个Android程序创建之初，一个Process呈现的是单线程模型--即MainThread，所有的任务都在一个线程中运行，所以，MainThread所调用的每一个函数，其耗时应该越短越好，而对于比较耗时的工作，应该交给子线程去做，以避免主线程（UI线程）被阻塞，导致程序出现ANR(Application not response)一个Activity就运行在一个线程中吗？或者编码时，如果不是明确安排在不同线程中的两个Activity，其就都是在同一个线程中？那从一个Activity跳转到另一个Activity时，是不是跳出的那个Activity就处在睡眠状态了？【答】 每个Activity都有一个Process属性，可以指定该Activity是属于哪个进程的。当然如果不明确指明，应该就是从属于默认进程（Application指定的，如其未指定，应该就是默认主进程）。Android中有Task的概念，而同一个Task的各个Activity会形成一个栈，只有站定的Activity才有机会与用户交互。原文地址：Android中的进程与线程 原文作者：江鹏当应用程序的组件第一次运行时，Android将启动一个只有一个执行线程的Linux进程。默认，应用程序所有的组件运行在这个进程和线程中。然而，你可以安排组件运行在其他进程中，且你可以为进程衍生出其它线程。本文从下面几点来介绍Android的进程与线程：1、进程组件运行于哪个进程中由清单文件控制。组件元素——<activity>、<service>、<receiver>、<provider>，都有一个process属性可以指定组件运行在哪个进程中。这个属性可以设置为每个组件运行在自己的进程中，或者某些组件共享一个进程而其他的不共享。他们还可以设置为不同应用程序的组件运行在同一个进程中——假设这些应用程序共享同一个Linux用户ID且被分配了同样的权限。<application>元素也有process属性，为所有的组件设置一个默认值。所有的组件都在特定进程的主线程中实例化，且系统调用组件是由主线程派遣。不会为每个实例创建单独的线程，因此，对应这些调用的方法——诸如View.onKeyDown()报告用用户的行为和生命周期通知，总是运行在进程的主线程中。这意味着，没有组件当被系统调用时应该执行很长时间或阻塞操作（如网络操作或循环计算），因为这将阻塞进程中的其它组件。你可以为长操作衍生独立的线程。public boolean onKeyDown(int keyCode,KeyEvent event)：默认实现KeyEvent.Callback.onKeyMultiple()，当按下视图的KEYCODE_DPAD_CENTER或KEYCODE_ENTER然后释放时执行，如果视图可用且可点击。参数keyCode-表示按钮被按下的键码，来自KeyEvent event-定义了按钮动作的KeyEvent对象返回值如果你处理事件，返回true；如果你想下一个接收者处理事件，返回false。当内存剩余较小且其它进程请求较大内存并需要立即分配，Android要回收某些进程，进程中的应用程序组件会被销毁。当他们再次运行时，会重新开始一个进程。当决定终结哪个进程时，Android会权衡他们对用户重要性的相对权值。例如，与运行在屏幕可见的活动进程相比（前台进程），它更容易关闭一个进程，它的活动在屏幕是不可见（后台进程）。决定是否终结进程，取决于运行在进程中的组件状态。关于组件的状态，将在后面一篇——组件生命周期中介绍。2、线程虽然你可能会将你的应用程序限制在一个进程中，但有时候你会需要衍生一个线程做一些后台工作。因为用户界面必须很快地响应用户的操作，所以活动寄宿的线程不应该做一些耗时的操作如网络下载。任何不可能在短时间完成的操作应该分配到别的线程。线程在代码中是用标准的Java线程对象创建的，Android提供了一些方便的类来管理线程——Looper用于在线程中运行消息循环、Handler用户处理消息、HandlerThread用户设置一个消息循环的线程。Looper类该类用户在线程中运行消息循环。线程默认没有消息循环，可以在线程中调用prepare()创建一个运行循环；然后调用loop()处理消息直到循环结束。大部分消息循环交互是通过Handler类。下面是一个典型的执行一个Looper线程的例子，分别使用prepare()和loop()创建一个初始的Handler与Looper交互： 2.1、远程过程调用（Remote procedure calls，RPCs）Android有一个轻量级的远程过程调用机制——方法在本地调用却在远程（另外一个进程中）执行，结果返回给调用者。这需要将方法调用和它伴随的数据分解为操作系统能够理解的层次，从本地进程和地址空间传输到远程进程和地址空间，并重新组装调用。返回值以相反方向传输。Android提供了做这些工作的所有代码，这样我们可以专注于定义和执行RPC接口本身。一个RPC接口仅包含方法。所有的方法同步地执行（本地方法阻塞直到远程方法执行完成），即使是没有返回值。简言之，该机制工作原理如下：首先，你用简单的IDL（interface definition language，接口定义语言）声明一个你想实现的RPC接口。从这个声明中，aidl工具生成一个Java接口定义，提供给本地和远程进程。它包含两个内部类，如下图所示：内部类有管理你用IDL定义的接口的远程过程调用所需要的所有代码。这两个内部类都实现了IBinder接口。其中之一就是在本地由系统内部使用，你写代码可以忽略它。另外一个是Stub，扩展自Binder类。除了用于有效地IPC（interprocess communication）调用的内部代码，内部类在RPC接口声明中还包含方法声明。你可以定义Stub的子类实现这些方法，如图中所示。通常情况下，远程过程有一个服务管理（因为服务能通知系统关于进程和它连接的其它进程的信息）。它有由aidl工具生成的接口文件和Stub子类实现的RPC方法。服务的客户端仅有由aidl工具生成的接口文件。下面介绍服务如何与它的客户端建立连接：· 服务的客户端（在本地端的）应该实现onServiceConnected() 和onServiceDisconnected() 方法，因此当与远程服务建立连接成功和断开连接是会通知它。然后调用bindService() 建立连接。 · 服务的onBind()方法将实现为接受或拒绝连接，者取决于它接受到的意图（该意图传送到binServive()）。如果连接被接受，它返回一个Stub子类的实例。 · 如果服务接受连接，Android调用客户端的onServiceConnected()方法且传递给它一个IBinder对象，返回由服务管理的Stub子类的一个代理。通过代理，客户端可以调用远程服务。 这里只是简单地描述，省略了一些RPC机制的细节。你可以查阅相关资料或继续关注Android开发之旅，后面将为你奉上。2.2、线程安全方法在一些情况下，你实现的方法可能会被不止一个线程调用，因此必须写成线程安全的。这对远程调用方法是正确的——如上一节讨论的RPC机制。当从IBinder进程中调用一个IBinder对象中实现的一个方法，这个方法在调用者的线程中执行。然而，当从别的进程中调用，方法将在Android维护的IBinder进程中的线程池中选择一个执行，它不在进程的主线程中执行。例如，一个服务的onBind()方法在服务进程的主线程中被调用，在onBind()返回的对象中执行的方法（例如，实现RPC方法的Stub子类）将在线程池中被调用。由于服务可以有一个以上的客户端，所以同时可以有一个以上的线程在执行同一个IBinder方法。因此，IBinder的方法必须是线程安全的。同样，一个内容提供者可以接受其它进程产生的数据请求。虽然ContentResolver 和 ContentProvider 类隐藏进程通信如何管理的，对应哪些请求的ContentResolver 方法——query()、insert()、delete()、update()、getType()，在内容提供者的进程的线程池中被调用，而不是在这一进程的主线程中。因为这些方法可以同时从任意数量的线程中调用，他们也必须实现为线程安全的。

Android 中线程可分为 主线程 和 子线程 两类，其中主线程也就是 UI线程 ，它的主要这作用就是运行四大组件、处理界面交互。子线程则主要是处理耗时任务，也是我们要重点分析的。 首先 Java 中的各种线程在 Android 里是通用的，Android 特有的线程形态也是基于 Java 的实现的，所以有必要先简单的了解下 Java 中的线程，本文主要包括以下内容： 在 Java 中要创建子线程可以直接继承 Thread 类，重写 run() 方法： 或者实现 Runnable 接口，然后用Thread执行Runnable，这种方式比较常用： 简单的总结下： Callable 和 Runnable 类似，都可以用来处理具体的耗时任务逻辑的，但是但具体的差别在哪里呢？看一个小例子： 定义 MyCallable 实现了 Callable 接口，和之前 Runnable 的 run() 方法对比下， call() 方法是有返回值的哦，泛型就是返回值的类型： 一般会通过线程池来执行 Callable （线程池相关内容后边会讲到），执行结果就是一个 Future 对象： 可以看到，通过线程池执行 MyCallable 对象返回了一个 Future 对象，取出执行结果。 Future 是一个接口，从其内部的方法可以看出它提供了取消任务（有坑！！！）、判断任务是否完成、获取任务结果的功能： Future 接口有一个 FutureTask 实现类，同时 FutureTask 也实现了 Runnable 接口，并提供了两个构造函数： 用 FutureTask 一个参数的构造函数来改造下上边的例子： FutureTask 内部有一个 done() 方法，代表 Callable 中的任务已经结束，可以用来获取执行结果： 所以 Future + Callable 的组合可以更方便的获取子线程任务的执行结果，更好的控制任务的执行，主要的用法先说这么多了，其实 AsyncTask 内部也是类似的实现！ 注意， Future 并不能取消掉运行中的任务，这点在后边的 AsyncTask 解析中有提到。 Java 中线程池的具体的实现类是 ThreadPoolExecutor ，继承了 Executor 接口，这些线程池在 Android 中也是通用的。使用线程池的好处： 常用的构造函数如下： 一个常规线程池可以按照如下方式来实现： 执行任务： 基于 ThreadPoolExecutor ，系统扩展了几类具有新特性的线程池： 线程池可以通过 execute() 、 submit() 方法开始执行任务，主要差别从方法的声明就可以看出，由于 submit() 有返回值，可以方便得到任务的执行结果： 要关闭线程池可以使用如下方法： IntentService 是 Android 中一种特殊的 Service，可用于执行后台耗时任务，任务结束时会自动停止，由于属于系统的四大组件之一，相比一般线程具有较高的优先级，不容易被杀死。用法和普通 Service 基本一致，只需要在 onHandleIntent() 中处理耗时任务即可： 至于 HandlerThread，它是 IntentService 内部实现的重要部分，细节内容会在 IntentService 源码中说到。 IntentService 首次创建被启动的时候其生命周期方法 onCreate() 会先被调用，所以我们从这个方法开始分析： 这里出现了 HandlerThread 和 ServiceHandler 两个类，先搞明白它们的作用，以便后续的分析。 首先看 HandlerThread 的核心实现： 首先它继承了 Thread 类，可以当做子线程来使用，并在 run() 方法中创建了一个消息循环系统、开启消息循环。 ServiceHandler 是 IntentService 的内部类，继承了 Handler，具体内容后续分析： 现在回过头来看 onCreate() 方法主要是一些初始化的操作， 首先创建了一个 thread 对象，并启动线程，然后用其内部的 Looper 对象 创建一个 mServiceHandler 对象，将子线程的 Looper 和 ServiceHandler 建立了绑定关系，这样就可以使用 mServiceHandler 将消息发送到子线程去处理了。 生命周期方法 onStartCommand() 方法会在 IntentService 每次被启动时调用，一般会这里处理启动 IntentService 传递 Intent 解析携带的数据： 又调用了 start() 方法： 就是用 mServiceHandler 发送了一条包含 startId 和 intent 的消息，消息的发送还是在主线程进行的，接下来消息的接收、处理就是在子线程进行的： 当接收到消息时，通过 onHandleIntent() 方法在子线程处理 intent 对象， onHandleIntent() 方法执行结束后，通过 stopSelf(msg.arg1) 等待所有消息处理完毕后终止服务。 为什么消息的处理是在子线程呢？这里涉及到 Handler 的内部消息机制，简单的说，因为 ServiceHandler 使用的 Looper 对象就是在 HandlerThread 这个子线程类里创建的，并通过 Looper.loop() 开启消息循环，不断从消息队列（单链表）中取出消息，并执行，截取 loop() 的部分源码： dispatchMessage() 方法间接会调用 handleMessage() 方法，所以最终 onHandleIntent() 就在子线程中划线执行了，即 HandlerThread 的 run() 方法。 这就是 IntentService 实现的核心，通过 HandlerThread + Hanlder 把启动 IntentService 的 Intent 从主线程切换到子线程，实现让 Service 可以处理耗时任务的功能！ AsyncTask 是 Android 中轻量级的异步任务抽象类，它的内部主要由线程池以及 Handler 实现，在线程池中执行耗时任务并把结果通过 Handler 机制中转到主线程以实现UI操作。典型的用法如下： 从 Android3.0 开始，AsyncTask 默认是串行执行的： 如果需要并行执行可以这么做： AsyncTask 的源码不多，还是比较容易理解的。根据上边的用法，可以从 execute() 方法开始我们的分析： 看到 @MainThread 注解了吗？所以 execute() 方法需要在主线程执行哦！ 进而又调用了 executeOnExecutor() ： 可以看到，当任务正在执行或者已经完成，如果又被执行会抛出异常！回调方法 onPreExecute() 最先被执行了。 传入的 sDefaultExecutor 参数，是一个自定义的串行线程池对象，所有任务在该线程池中排队执行： 可以看到 SerialExecutor 线程池仅用于任务的排队， THREAD_POOL_EXECUTOR 线程池才是用于执行真正的任务，就是我们线程池部分讲到的 ThreadPoolExecutor ： 再回到 executeOnExecutor() 方法中，那么 exec.execute(mFuture) 就是触发线程池开始执行任务的操作了。 那 executeOnExecutor() 方法中的 mWorker 是什么？ mFuture 是什么？答案在 AsyncTask 的构造函数中： 原来 mWorker 是一个 Callable 对象， mFuture 是一个 FutureTask 对象，继承了 Runnable 接口。所以 mWorker 的 call() 方法会在 mFuture 的 run() 方法中执行，所以 mWorker 的 call() 方法在线程池得到执行！ 同时 doInBackground() 方法就在 call() 中方法，所以我们自定义的耗时任务逻辑得到执行，不就是我们第二部分讲的那一套吗！ doInBackground() 的返回值会传递给 postResult() 方法： 就是通过 Handler 将最终的耗时任务结果从子线程发送到主线程，具体的过程是这样的， getHandler() 得到的就是 AsyncTask 构造函数中初始化的 mHandler ， mHander 又是通过 getMainHandler() 赋值的： 可以在看到 sHandler 是一个 InternalHandler 类对象： 所以 getHandler() 就是在得到在主线程创建的 InternalHandler 对象，所以 就可以完成耗时任务结果从子线程到主线程的切换，进而可以进行相关UI操作了。 当消息是 MESSAGE_POST_RESULT 时，代表任务执行完成， finish() 方法被调用： 如果任务没有被取消的话执行 onPostExecute() ，否则执行 onCancelled() 。 如果消息是 MESSAGE_POST_PROGRESS ， onProgressUpdate() 方法被执行，根据之前的用法可以 onProgressUpdate() 的执行需要我们手动调用 publishProgress() 方法，就是通过 Handler 来发送进度数据： 进行中的任务如何取消呢？AsyncTask 提供了一个 cancel(boolean mayInterruptIfRunning) ，参数代表是否中断正在执行的线程任务，但是呢并不靠谱， cancel() 的方法注释中有这么一段： 大致意思就是调用 cancel() 方法后， onCancelled(Object) 回调方法会在 doInBackground() 之后被执行而 onPostExecute() 将不会被执行，同时你应该 doInBackground() 回调方法中通过 isCancelled() 来检查任务是否已取消，进而去终止任务的执行！ 所以只能自己动手了： AsyncTask 整体的实现流程就这些了，源码是最好的老师，自己跟着源码走一遍有些问题可能就豁然开朗了！

什么是 Handler 机制 ？ Handler 机制是 Android 中用于 线程间通信 的一套通信机制。 为什么是 Handler ？Handler 机制为什么被那么多次的提及 ？ 从Android4.0开始，Android 中网络请求强制不允许在主线程中操作，而更新UI的操作则不允许在子线程中执行。当在子线程中执行网络请求，拿到服务器返回的数据之后，要更新UI。由于系统的要求，势必会产生一种矛盾：数据在子线程，更新UI要在主线程。此时我们必须要把数据返回到主线程中才行，Handler机制应运而生。 Android 中针对耗时的操作，放在主线程操作，轻者会造成 UI 卡顿，重则会直接无响应，造成 Force Close。同时在 Android 3.0 以后，禁止在主线程进行网络请求。 针对耗时或者网络操作，那就不能在主线程进行直接操作了，需要放在子线程或者是工作线程中进行操作，操作完成以后，再更新主线程即 UI 线程。这里就涉及到一个问题了，在子线程执行完成以后，怎么能更新到主线程即 UI 线程呢，针对以上问题，就需要用到 Android 的消息机制了，即： Handler, Message, MessageQueue, Looper 全家桶 Handler机制中最重要的四个对象 Handler的构造方法: Looper : Handler的使用： MessageQueue： Looper.loop() Handler.dispatchMessage() handler导致activity内存泄露的原因： handler发送的消息在当前handler的消息队列中，如果此时activity finish掉了，那么消息队列的消息依旧会由handler进行处理，若此时handler声明为内部类（非静态内部类），我们知道内部类天然持有外部类的实例引用，这样在GC垃圾回收机制进行回收时发现这个Activity居然还有其他引用存在，因而就不会去回收这个Activity，进而导致activity泄露。 假如在子线程执行了耗时操作，这时用户操作进入了其他的 acitvity， 那么 MainActivity 就会被内存回收的，但是这个时候发现 Handler 还在引用着 MainActivity，内存无法及时回收，造成内存泄漏。 Handler 防止内存泄漏常见方法： 为什么通过 Handler 可以把子线程的结果通知或者携带给 UI 线程 ？ 这里的 Handler 指的是主线程的 Handler ,同时与 Handler 配套的 Looper ， MessageQueue 是在 UI 线程初始化的，所以在子线程中调用 Handler 发送消息可以更新 UI 线程。 Looper 在 UI 线程源码, 在 ActivityThread 类：

本文开始聊聊Android中的硬件渲染。如果跟着我的文章顺序，从SF进程到App进程的绘制流程一直阅读，我们到这里已经有了一定的基础，可以试着进行横向比对如Chrome浏览器渲染流程，看看软件渲染，硬件渲染，SF合成都做了什么程度的优化。 先让我们回顾一下负责硬件渲染的主体对象ThreadedRenderer在整个绘制流程中做了哪几个步骤。 在硬件渲染的过程中，有一个很核心的对象RenderNode，作为每一个View绘制的节点对象。 当每一次进行准备进行绘制的时候，都会雷打不动执行如下三个步骤： 如果遇到什么问题欢迎来到 https://www.jianshu.com/p/c84bfa909810 下进行讨论 实际上整个硬件渲染的设计还是比较庞大。因此本文先聊聊ThreadedRender整个体系中主要对象的构造以及相关的原理。 首先来认识下面几个重要的对象有一个大体的印象。 在Java层中面向Framework中，只有这么多，下面是一一映射的简图。 能看到实际上RenderNode也会跟着View 树的构建同时一起构建整个显示层级。也是因此ThreadedRender也能以RenderNode为线索构建出一套和软件渲染一样的渲染流程。 仅仅这样？如果只是这么简单，知道我习惯的都知道，我喜欢把相关总结写在最后。如果把总揽写在正文开头是因为设计比较繁多。因为我们如果以流水线的形式进行剖析容易造成迷失细节的困境。 让我继续介绍一下，在硬件渲染中native层的核心对象。 如下是一个思维导图： 有这么一个大体印象后，就不容易迷失在源码中。我们先来把这些对象的实例化以及上面列举的ThreadedRenderer在ViewRootImpl中执行行为的顺序和大家来聊聊其原理，先来看看ThreadedRenderer的实例化。 当发现mSurfaceHolder为空的时候会调用如下函数： 而这个方法则调用如下的方法对ThreadedRenderer进行创建： 文件：/ frameworks / base / core / java / android / view / ThreadedRenderer.java 能不能创建的了ThreadedRenderer则决定于全局配置。如果ro.kernel.qemu的配置为0，说明支持OpenGL 则可以直接返回true。如果qemu.gles为-1说明不支持OpenGL es返回false，只能使用软件渲染。如果设置了qemu.gles并大于0，才能打开硬件渲染。 我们能看到ThreadedRenderer在初始化，做了三件事情： 关键是看1-3点中ThreadRenderer都做了什么。 文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp 能看到这里是直接实例化一个RootRenderNode对象，并把指针的地址直接返回。 能看到RootRenderNode继承了RenderNode对象，并且保存一个JavaVM也就是我们所说的Java虚拟机对象，一个java进程全局只有一个。同时通过getForThread方法，获取ThreadLocal中的Looper对象。这里实际上拿的就是UI线程的Looper。 在这个构造函数有一个mDisplayList十分重要，记住之后会频繁出现。接着来看看RenderNode的头文件： 文件：/ frameworks / base / libs / hwui / RenderNode.h 实际上我把几个重要的对象留下来： 文件：/ frameworks / base / core / java / android / view / RenderNode.java 能看到很简单，就是包裹一个native层的RenderNode返回一个Java层对应的对象开放Java层的操作API。 能看到这个过程生成了两个对象： 这个对象实际上让RenderProxy持有一个创建动画上下文的工厂。RenderProxy可以通过ContextFactoryImpl为每一个RenderNode创建一个动画执行对象的上下文AnimationContextBridge。 文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp 在这里有几个十分重要的对象被实例化，当然这几个对象在聊TextureView有聊过( SurfaceView和TextureView 源码浅析 )： 我们依次看看他们初始化都做了什么。 文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.cpp 能看到其实就是简单的调用RenderThread的构造函数进行实例化，并且返回对象的指针。 RenderThread是一个线程对象。先来看看其头文件继承的对象： 文件：/ frameworks / base / libs / hwui / renderthread / RenderThread.h 其中RenderThread的中进行排队处理的任务队列实际上是来自ThreadBase的WorkQueue对象。 文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h ThreadBase则是继承于Thread对象。当调用start方法时候其实就是调用Thread的run方法启动线程。 另一个更加关键的对象，就是实例化一个Looper对象到WorkQueue中。而直接实例化Looper实际上就是新建一个Looper。但是这个Looper并没有获取当先线程的Looper，这个Looper做什么的呢？下文就会揭晓。 WorkQueue把一个Looper的方法指针设置到其中，其作用可能是完成了某一件任务后唤醒Looper继续工作。 而start方法会启动Thread的run方法。而run方法最终会走到threadLoop方法中，至于是怎么走进来的，之后有机会会解剖虚拟机的源码线程篇章进行讲解。 在threadloop中关键的步骤有如下四个： 在这个过程中创建了几个核心对象： 另一个核心的方法就是initializeDisplayEventReceiver，这个方法为WorkQueue的Looper注册了监听： 能看到在这个Looper中注册了对DisplayEventReceiver的监听，也就是Vsync信号的监听，回调方法为displayEventReceiverCallback。 我们暂时先对RenderThread的initializeDisplayEventReceiver方法探索到这里，我们稍后继续看看回调后的逻辑。 文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h 能看到这里的逻辑很简单实际上就是调用Looper的pollOnce方法，阻塞Looper中的循环，直到Vsync的信号到来才会继续往下执行。详细的可以阅读我写的 Handler与相关系统调用的剖析 系列文章。 文件：/ frameworks / base / libs / hwui / thread / ThreadBase.h 实际上调用的是WorkQueue的process方法。 文件：/ frameworks / base / libs / hwui / thread / WorkQueue.h 能看到这个过程中很简单，几乎和Message的loop的逻辑一致。如果Looper的阻塞打开了，则首先找到预计执行时间比当前时刻都大的WorkItem。并且从mWorkQueue移除，最后添加到toProcess中，并且执行每一个WorkItem的work方法。而每一个WorkItem其实就是通过从某一个压入方法添加到mWorkQueue中。 到这里，我们就明白了RenderThread中是如何消费渲染任务的。那么这些渲染任务又是哪里诞生呢？ 上文聊到了在RenderThread中的Looper会监听Vsync信号，当信号回调后将会执行下面的回调。 能看到这个方法的核心实际上就是调用drainDisplayEventQueue方法，对ui渲染任务队列进行处理。 能到在这里mVsyncRequested设置为false，且mFrameCallbackTaskPending将会设置为true，并且调用queue的postAt的方法执行ui渲染方法。 还记得queue实际是是指WorkQueue，而WorkQueue的postAt方法实际实现如下： / frameworks / base / libs / hwui / thread / WorkQueue.h 情景带入，当一个Vsync信号达到Looper的监听者，此时就会通过WorkQueue的drainDisplayEventQueue 压入一个任务到队列中。 每一个默认的任务都是执行dispatchFrameCallback方法。这里的判断mWorkQueue中是否存在比当前时间更迟的时刻，并返回这个WorkItem。如果这个对象在头部needsWakeup为true，说明可以进行唤醒了。而mWakeFunc这个方法指针就是上面传下来： 把阻塞的Looper唤醒。当唤醒后就继续执行WorkQueue的process方法。也就是执行dispatchFrameCallbacks方法。 在这里执行了两个事情： 先添加到mPendingRegistrationFrameCallbacks集合中，在上面提到过的threadLoop中，会执行如下逻辑： 如果mPendingRegistrationFrameCallbacks大小不为0，则的把mPendingRegistrationFrameCallbacks中的IFrameCallback全部迁移到mFrameCallbacks中。 而这个方法什么时候调用呢？稍后就会介绍。其实这部分的逻辑在TextureView的解析中提到过。 接下来将会初始化一个重要对象： 这个对象名字叫做画布的上下文，具体是什么上下文呢？我们现在就来看看其实例化方法。 文件：/ frameworks / base / libs / hwui / renderthread / CanvasContext.cpp 文件：/ device / generic / goldfish / init.ranchu.rc 在init.rc中默认是opengl，那么我们就来看看下面的逻辑： 首先实例化一个OpenGLPipeline管道，接着OpenGLPipeline作为参数实例化CanvasContext。 文件：/ frameworks / base / libs / hwui / renderthread / OpenGLPipeline.cpp 能看到在OpenGLPipeline中，实际上就是存储了RenderThread对象，以及RenderThread中的mEglManager。透过OpenGLPipeline来控制mEglManager进而进一步操作OpenGL。 做了如下操作： 文件：/ frameworks / base / libs / hwui / renderstate / RenderState.cpp 文件：/ frameworks / base / libs / hwui / renderthread / DrawFrameTask.cpp 实际上就是保存这三对象RenderThread；CanvasContext；RenderNode。 文件：/ frameworks / base / core / jni / android_view_ThreadedRenderer.cpp 能看到实际上就是调用RenderProxy的setName方法给当前硬件渲染对象设置名字。 文件：/ frameworks / base / libs / hwui / renderthread / RenderProxy.cpp 能看到在setName方法中，实际上就是调用RenderThread的WorkQueue，把一个任务队列设置进去，并且调用runSync执行。 能看到这个方法实际上也是调用post执行排队执行任务，不同的是，这里使用了线程的Future方式，阻塞了执行，等待CanvasContext的setName工作完毕。

. Android中进程与进程、线程与线程之间如何通信？1)一个 Android 程序开始运行时，会单独启动一个Process。默认情况下，所有这个程序中的Activity或者Service都会跑在这个Process。默认情况下，一个Android程序也只有一个Process，但一个Process下却可以有许多个Thread。2)一个 Android 程序开始运行时，就有一个主线程Main Thread被创建。该线程主要负责UI界面的显示、更新和控件交互，所以又叫UI Thread。3)一个Android程序创建之初，一个Process呈现的是单线程模型--即MainThread，所有的任务都在一个线程中运行，所以，MainThread所调用的每一个函数，其耗时应该越短越好，而对于比较耗时的工作，应该交给子线程去做，以避免主线程（UI线程）被阻塞，导致程序出现ANR(Application not response)一个Activity就运行在一个线程中吗？或者编码时，如果不是明确安排在不同线程中的两个Activity，其就都是在同一个线程中？那从一个Activity跳转到另一个Activity时，是不是跳出的那个Activity就处在睡眠状态了？【答】 每个Activity都有一个Process属性，可以指定该Activity是属于哪个进程的。当然如果不明确指明，应该就是从属于默认进程（Application指定的，如其未指定，应该就是默认主进程）。Android中有Task的概念，而同一个Task的各个Activity会形成一个栈，只有站定的Activity才有机会与用户交互。原文地址：Android中的进程与线程 原文作者：江鹏当应用程序的组件第一次运行时，Android将启动一个只有一个执行线程的Linux进程。默认，应用程序所有的组件运行在这个进程和线程中。然而，你可以安排组件运行在其他进程中，且你可以为进程衍生出其它线程。本文从下面几点来介绍Android的进程与线程：1、进程组件运行于哪个进程中由清单文件控制。组件元素——<activity>、<service>、<receiver>、<provider>，都有一个process属性可以指定组件运行在哪个进程中。这个属性可以设置为每个组件运行在自己的进程中，或者某些组件共享一个进程而其他的不共享。他们还可以设置为不同应用程序的组件运行在同一个进程中——假设这些应用程序共享同一个Linux用户ID且被分配了同样的权限。<application>元素也有process属性，为所有的组件设置一个默认值。所有的组件都在特定进程的主线程中实例化，且系统调用组件是由主线程派遣。不会为每个实例创建单独的线程，因此，对应这些调用的方法——诸如View.onKeyDown()报告用用户的行为和生命周期通知，总是运行在进程的主线程中。这意味着，没有组件当被系统调用时应该执行很长时间或阻塞操作（如网络操作或循环计算），因为这将阻塞进程中的其它组件。你可以为长操作衍生独立的线程。public boolean onKeyDown(int keyCode,KeyEvent event)：默认实现KeyEvent.Callback.onKeyMultiple()，当按下视图的KEYCODE_DPAD_CENTER或KEYCODE_ENTER然后释放时执行，如果视图可用且可点击。参数keyCode-表示按钮被按下的键码，来自KeyEvent event-定义了按钮动作的KeyEvent对象返回值如果你处理事件，返回true；如果你想下一个接收者处理事件，返回false。当内存剩余较小且其它进程请求较大内存并需要立即分配，Android要回收某些进程，进程中的应用程序组件会被销毁。当他们再次运行时，会重新开始一个进程。当决定终结哪个进程时，Android会权衡他们对用户重要性的相对权值。例如，与运行在屏幕可见的活动进程相比（前台进程），它更容易关闭一个进程，它的活动在屏幕是不可见（后台进程）。决定是否终结进程，取决于运行在进程中的组件状态。关于组件的状态，将在后面一篇——组件生命周期中介绍。2、线程虽然你可能会将你的应用程序限制在一个进程中，但有时候你会需要衍生一个线程做一些后台工作。因为用户界面必须很快地响应用户的操作，所以活动寄宿的线程不应该做一些耗时的操作如网络下载。任何不可能在短时间完成的操作应该分配到别的线程。线程在代码中是用标准的Java线程对象创建的，Android提供了一些方便的类来管理线程——Looper用于在线程中运行消息循环、Handler用户处理消息、HandlerThread用户设置一个消息循环的线程。Looper类该类用户在线程中运行消息循环。线程默认没有消息循环，可以在线程中调用prepare()创建一个运行循环；然后调用loop()处理消息直到循环结束。大部分消息循环交互是通过Handler类。下面是一个典型的执行一个Looper线程的例子，分别使用prepare()和loop()创建一个初始的Handler与Looper交互： 1. Android中进程与进程、线程与线程之间如何通信？1)一个 Android 程序开始运行时，会单独启动一个Process。默认情况下，所有这个程序中的Activity或者Service都会跑在这个Process。默认情况下，一个Android程序也只有一个Process，但一个Process下却可以有许多个Thread。2)一个 Android 程序开始运行时，就有一个主线程Main Thread被创建。该线程主要负责UI界面的显示、更新和控件交互，所以又叫UI Thread。3)一个Android程序创建之初，一个Process呈现的是单线程模型--即MainThread，所有的任务都在一个线程中运行，所以，MainThread所调用的每一个函数，其耗时应该越短越好，而对于比较耗时的工作，应该交给子线程去做，以避免主线程（UI线程）被阻塞，导致程序出现ANR(Application not response)一个Activity就运行在一个线程中吗？或者编码时，如果不是明确安排在不同线程中的两个Activity，其就都是在同一个线程中？那从一个Activity跳转到另一个Activity时，是不是跳出的那个Activity就处在睡眠状态了？【答】 每个Activity都有一个Process属性，可以指定该Activity是属于哪个进程的。当然如果不明确指明，应该就是从属于默认进程（Application指定的，如其未指定，应该就是默认主进程）。Android中有Task的概念，而同一个Task的各个Activity会形成一个栈，只有站定的Activity才有机会与用户交互。原文地址：Android中的进程与线程 原文作者：江鹏当应用程序的组件第一次运行时，Android将启动一个只有一个执行线程的Linux进程。默认，应用程序所有的组件运行在这个进程和线程中。然而，你可以安排组件运行在其他进程中，且你可以为进程衍生出其它线程。本文从下面几点来介绍Android的进程与线程：1、进程组件运行于哪个进程中由清单文件控制。组件元素——<activity>、<service>、<receiver>、<provider>，都有一个process属性可以指定组件运行在哪个进程中。这个属性可以设置为每个组件运行在自己的进程中，或者某些组件共享一个进程而其他的不共享。他们还可以设置为不同应用程序的组件运行在同一个进程中——假设这些应用程序共享同一个Linux用户ID且被分配了同样的权限。<application>元素也有process属性，为所有的组件设置一个默认值。所有的组件都在特定进程的主线程中实例化，且系统调用组件是由主线程派遣。不会为每个实例创建单独的线程，因此，对应这些调用的方法——诸如View.onKeyDown()报告用用户的行为和生命周期通知，总是运行在进程的主线程中。这意味着，没有组件当被系统调用时应该执行很长时间或阻塞操作（如网络操作或循环计算），因为这将阻塞进程中的其它组件。你可以为长操作衍生独立的线程。public boolean onKeyDown(int keyCode,KeyEvent event)：默认实现KeyEvent.Callback.onKeyMultiple()，当按下视图的KEYCODE_DPAD_CENTER或KEYCODE_ENTER然后释放时执行，如果视图可用且可点击。参数keyCode-表示按钮被按下的键码，来自KeyEvent event-定义了按钮动作的KeyEvent对象返回值如果你处理事件，返回true；如果你想下一个接收者处理事件，返回false。当内存剩余较小且其它进程请求较大内存并需要立即分配，Android要回收某些进程，进程中的应用程序组件会被销毁。当他们再次运行时，会重新开始一个进程。当决定终结哪个进程时，Android会权衡他们对用户重要性的相对权值。例如，与运行在屏幕可见的活动进程相比（前台进程），它更容易关闭一个进程，它的活动在屏幕是不可见（后台进程）。决定是否终结进程，取决于运行在进程中的组件状态。关于组件的状态，将在后面一篇——组件生命周期中介绍。2、线程虽然你可能会将你的应用程序限制在一个进程中，但有时候你会需要衍生一个线程做一些后台工作。因为用户界面必须很快地响应用户的操作，所以活动寄宿的线程不应该做一些耗时的操作如网络下载。任何不可能在短时间完成的操作应该分配到别的线程。线程在代码中是用标准的Java线程对象创建的，Android提供了一些方便的类来管理线程——Looper用于在线程中运行消息循环、Handler用户处理消息、HandlerThread用户设置一个消息循环的线程。Looper类该类用户在线程中运行消息循环。线程默认没有消息循环，可以在线程中调用prepare()创建一个运行循环；然后调用loop()处理消息直到循环结束。大部分消息循环交互是通过Handler类。下面是一个典型的执行一个Looper线程的例子，分别使用prepare()和loop()创建一个初始的Handler与Looper交互： 2.1、远程过程调用（Remote procedure calls，RPCs）Android有一个轻量级的远程过程调用机制——方法在本地调用却在远程（另外一个进程中）执行，结果返回给调用者。这需要将方法调用和它伴随的数据分解为操作系统能够理解的层次，从本地进程和地址空间传输到远程进程和地址空间，并重新组装调用。返回值以相反方向传输。Android提供了做这些工作的所有代码，这样我们可以专注于定义和执行RPC接口本身。一个RPC接口仅包含方法。所有的方法同步地执行（本地方法阻塞直到远程方法执行完成），即使是没有返回值。简言之，该机制工作原理如下：首先，你用简单的IDL（interface definition language，接口定义语言）声明一个你想实现的RPC接口。从这个声明中，aidl工具生成一个Java接口定义，提供给本地和远程进程。它包含两个内部类，如下图所示：内部类有管理你用IDL定义的接口的远程过程调用所需要的所有代码。这两个内部类都实现了IBinder接口。其中之一就是在本地由系统内部使用，你写代码可以忽略它。另外一个是Stub，扩展自Binder类。除了用于有效地IPC（interprocess communication）调用的内部代码，内部类在RPC接口声明中还包含方法声明。你可以定义Stub的子类实现这些方法，如图中所示。通常情况下，远程过程有一个服务管理（因为服务能通知系统关于进程和它连接的其它进程的信息）。它有由aidl工具生成的接口文件和Stub子类实现的RPC方法。服务的客户端仅有由aidl工具生成的接口文件。下面介绍服务如何与它的客户端建立连接：· 服务的客户端（在本地端的）应该实现onServiceConnected() 和onServiceDisconnected() 方法，因此当与远程服务建立连接成功和断开连接是会通知它。然后调用bindService() 建立连接。 · 服务的onBind()方法将实现为接受或拒绝连接，者取决于它接受到的意图（该意图传送到binServive()）。如果连接被接受，它返回一个Stub子类的实例。 · 如果服务接受连接，Android调用客户端的onServiceConnected()方法且传递给它一个IBinder对象，返回由服务管理的Stub子类的一个代理。通过代理，客户端可以调用远程服务。 这里只是简单地描述，省略了一些RPC机制的细节。你可以查阅相关资料或继续关注Android开发之旅，后面将为你奉上。2.2、线程安全方法在一些情况下，你实现的方法可能会被不止一个线程调用，因此必须写成线程安全的。这对远程调用方法是正确的——如上一节讨论的RPC机制。当从IBinder进程中调用一个IBinder对象中实现的一个方法，这个方法在调用者的线程中执行。然而，当从别的进程中调用，方法将在Android维护的IBinder进程中的线程池中选择一个执行，它不在进程的主线程中执行。例如，一个服务的onBind()方法在服务进程的主线程中被调用，在onBind()返回的对象中执行的方法（例如，实现RPC方法的Stub子类）将在线程池中被调用。由于服务可以有一个以上的客户端，所以同时可以有一个以上的线程在执行同一个IBinder方法。因此，IBinder的方法必须是线程安全的。同样，一个内容提供者可以接受其它进程产生的数据请求。虽然ContentResolver 和 ContentProvider 类隐藏进程通信如何管理的，对应哪些请求的ContentResolver 方法——query()、insert()、delete()、update()、getType()，在内容提供者的进程的线程池中被调用，而不是在这一进程的主线程中。因为这些方法可以同时从任意数量的线程中调用，他们也必须实现为线程安全的。

1. 主线程，负责一些UI更新操作，归类为一个线程，线程在Android中是有生命周期的，任务最终是会结束的。 2. Looper.loop()的死循环正是维护了主线程的超长生命周期，loop方法一直循环处理任务，没有任务的时候会休眠，有任务的时候会唤醒然后进行处理，所以也不会占用太多系统资源。 3. 卡死，可能有误解，循环的过程中本生不会出现ANR，在循环的过程中，如果执行了耗时且在规定时间内没有完成消息派发，才会出现ANR。

Android中的Runnable并不一定是新开的线程，比如下面调用的方法就是运行在UI主线程中Hanlder handler = new Handler();handler.post(new Runnable(){ public void run(){}});官方文档对此的解释是:The runnable will be run on the user interface thread. ”boolean android.view.View .post(Runnable action)Causes the Runnable to be added to the message queue. The runnable will be run on the user interface thread.Parameters: action The Runnable that will be executed. Returns: Returns true if the Runnable was successfully placed in to the message queue. Returns false on failure, usually because the looper processing the message queue is exiting.我们可以通过handler的对象的post方法,把Runnable对象(一般是Runnable的子类)传过去,handler会在Looper中调用Runnable的run方法执行，Runnable是一个接口，不是一个线程,一般线程会实现Runnable接口这里我们看代码handler.post(new Runnable(){好像是new了一个interface,其实是new一个实现Runnable的匿名内部类(Inner Anoymous Class)}) 这是一个简练的方法Runnalbe是一个接口，不是一个线程,一般线程会实现Runnalbe接口,所以如果我们使用匿名内部类是运行在UI主线程的,如果我们使用实现这个Runnable接口的线程类,则是运行在对应的线程的。具体来说这个函数的工作原理如下:View.post(Runnalbe)方法，在post（Runanble action）方法中，View获得当前主线程(即UI线程)的handler，然后将action对象post到handler里面去，在Handler里，它将传递过来的action对象封装成一个Message(Message 的callback为action)，然后将其投入到UI线程的消息循环中，在handler再次处理该Message时，有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法，而此时，已经路由到UI线程里，因此我们可以毫无顾虑来更新UI。如下图,前面看到的代码，我们这里的Message的callback为一个Runnalbe的匿名内部类,这种情况下,由于不是在新的线程中使用，所以千万别做复杂的计算逻辑。

因为Android 的是由事件驱动的，Looper.loop() 不断地接收事件、处理事件，每一个点击触摸或者说Activity的生命周期都是运行在 Looper.loop() 的控制之下。所以不存在主线程会被Looper.loop方法阻塞。如果 Looper.loop()被干掉了，应用也就挂掉了。

实际上：消息发送和计划任务提交之后，它们都会进入某线程的消息队列中，我们可以把这个线程称之为目标线程。不论是主线程还是子线程都可以成为目标线程。上例中之所以在主线程中处理消息，是因为我们要更新UI，按照android中的规定我们必须由主线程更新UI。所以我们让主线程成为了目标线程。那么如何控制让某个线程成为目标线程呢？这就引出了Looper的概念。Android系统中实现了消息循环机制，Android的消息循环是针对线程的，每个线程都可以有自己的消息队列和消息循环。Android系统中的通过Looper帮助线程维护着一个消息队列和消息循环。通过Looper.myLooper()得到当前线程的Looper对象，通过Looper.getMainLooper()得到当前进程的主线程的Looper对象。前面提到每个线程都可以有自己的消息队列和消息循环，然而我们自己创建的线程默认是没有消息队列和消息循环的（及Looper），要想让一个线程具有消息处理机制我们应该在线程中先调用Looper.prepare()来创建一个Looper对象，然后调用Looper.loop()进入消息循环。如上面的源码所示。当我们用Handler的构造方法创建Handler对象时，指定handler对象与哪个具有消息处理机制的线程（具有Looper的线程）相关联，这个线程就成了目标线程，可以接受消息和计划任务了。Handler中的构造方法如下：[java] view plaincopyprint?public Handler() { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName()); } } mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can"t create handler inside thread that has not called Looper.prepare()"); } mQueue = mLooper.mQueue; mCallback = null; } public Handler(Looper looper) { mLooper = looper; mQueue = looper.mQueue; mCallback = null; } public Handler() { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName()); } } mLooper = Looper.myLooper(); if (mLooper == null) { throw new RuntimeException( "Can"t create handler inside thread that has not called Looper.prepare()"); } mQueue = mLooper.mQueue; mCallback = null; } public Handler(Looper looper) { mLooper = looper; mQueue = looper.mQueue; mCallback = null; }在上述的计时器的例子中，之所以可以在主线程中处理消息而我们自己并没有调用Looper.prepare()等方法，是因为Android系统在Activity启动时为其创建一个消息队列和消息循环，当我们用无参的Handler构造方法创建对象时又用了当前线程的Looper对象，及将handler与主线程中的Looper对象进行了关联。android中是使用Looper机制来完成消息循环的，但每次创建线程时都先初始化Looper比较麻烦，因此Android为我们提供了一个HandlerThread类，他封装了Looper对象，是我们不用关心Looper的开启和释放问题。不管是主线程还是其他线程只要有Looper的线程，别的线程就可以向这个线程的消息队列中发送消息和任务。我们使用HandlerThread类代替上一篇文章中的子线程，并用HandlerThread类中的Looper对象构造Handler，则接受消息的目标线程就不是主线程了，而是HandlerThread线程。代码如下：[java] view plaincopyprint?public class clockActivity extends Activity { /** Called when the activity is first created. */ private String TAG="clockActivity"; private Button endButton; private TextView textView; private int timer=0; private boolean isRunning=true; private Handler handler; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); endButton=(Button)findViewById(R.id.endBtn); textView=(TextView)findViewById(R.id.textview); endButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub isRunning=false; } }); HandlerThread thread=new HandlerThread("myThread"); handler=new Handler(thread.getLooper());//与HandlerThread中的Looper对象关联 thread.start(); Runnable r=new Runnable(){ @Override public void run() { // TODO Auto-generated method stub if(isRunning){ textView.setText("走了"+timer+"秒"); timer++; handler.postDelayed(this, 1000);//提交任务r，延时1秒执行 } } }; handler.postDelayed(r, 1000); } } 　　public class clockActivity extends Activity { /** Called when the activity is first created. */ private String TAG="clockActivity"; private Button endButton; private TextView textView; private int timer=0; private boolean isRunning=true; private Handler handler; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); endButton=(Button)findViewById(R.id.endBtn); textView=(TextView)findViewById(R.id.textview); endButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub isRunning=false; } }); HandlerThread thread=new HandlerThread("myThread"); handler=new Handler(thread.getLooper());//与HandlerThread中的Looper对象关联 thread.start(); Runnable r=new Runnable(){ @Override public void run() { // TODO Auto-generated method stub if(isRunning){ textView.setText("走了"+timer+"秒"); timer++; handler.postDelayed(this, 1000);//提交任务r，延时1秒执行 } } }; handler.postDelayed(r, 1000); }}　　此时处理任务会在handlerThread线程中完成。当然这个例子会出线异常：依然是因为在非主线程中更新了UI。这样做只是为了大家能够理解这种机制。　　深入理解Android消息处理机制对于应用程序开发非常重要，也可以让我们对线程同步有更加深刻的认识，希望这篇文章可以对朋友们有所帮助。

Looper.loop是一个死循环，拿不到需要处理的Message就会阻塞，那在UI线程中为什么不会导致ANR？ 首先我们来看造成ANR的原因： 1.当前的事件没有机会得到处理（即主线程正在处理前一个事件，没有及时的完成或者looper被某种原因阻塞住了） 2.当前的事件正在处理，但没有及时完成 我们再来看一下APP的入口ActivityThread的main方法： 显而易见的，如果main方法中没有looper进行死循环，那么主线程一运行完毕就会退出，会导致直接崩溃，还玩什么！ 现在我们知道了消息循环的必要性，那为什么这个死循环不会造成ANR异常呢？ 我们知道Android 的是由事件驱动的，looper.loop() 不断地接收事件、处理事件，每一个点击触摸或者说Activity的生命周期都是运行在 Looper的控制之下，如果它停止了，应用也就停止了。只能是某一个消息或者说对消息的处理阻塞了 Looper.loop()，而不是 Looper.loop() 阻塞它，这也就是我们为什么不能在UI线程中处理耗时操作的原因。 主线程Looper从消息队列读取消息，当读完所有消息时，主线程阻塞。子线程往消息队列发送消息，唤醒主线程，主线程被唤醒只是为了读取消息，当消息读取完毕，再次睡眠。因此loop的循环并不会对CPU性能有过多的消耗。 初始化当前线程和Looper，这样可以在实际开始启动循环(loop())之前创建一个Handler并且关联一个looper。确保在先调用这个方法，然后调用loop()方法，并且通过调用quit()结束。 这里面的入参boolean表示Looper是否允许退出，true就表示允许退出，对于false则表示Looper不允许退出。 初始化当前当前线程的looper。并且标记为一个程序的主Looper。由Android环境来创建应用程序的主Looper。因此这个方法不能由咱们来调用。另请参阅prepare() 这里的sThreadLocal.get()是和prepare(boolean)方法里面的sThreadLocal.set(new Looper(quitAllowed));一一对应的。而在prepareMainLooper()方法里面。 退出循环 将终止(loop()方法)而不处理消息队列中的任何更多消息。在调用quit()后，任何尝试去发送消息都是失败的。例如Handler.sendMessage(Message)方法将返回false。因为循环终止之后一些message可能会被无法传递，所以这个方法是不安全的。可以考虑使用quitSafely()方法来确保所有的工作有序地完成。 安全退出循环 调用quitSafely()方法会使循环结束，只要消息队列中已经被传递的所有消息都将被处理。然而，在循环结束之前，将来不会提交处理延迟消息。 调用退出后，所有尝试去发送消息都将失败。就像调用Handler.sendMessage(Message)将返回false。

Looper是Android中用于实现消息循环的一个类，它和Handler、MessageQueue、Message等一起组成了异步消息处理机制。通过它，我们可以在后台线程中实现UI更新等操作。使用Looper，一般需要以下步骤：1. 在子线程中创建Looper对象，并开启消息循环：```javaLooper.prepare();Looper.loop();```2. 在子线程中创建Handler对象，并通过Handler对象发送消息到消息队列中：```javaHandler handler = new Handler() { @Override public void handleMessage(Message msg) { // 在这里处理消息 }};handler.sendEmptyMessage(0);```3. 在主线程中创建Handler对象，并通过Handler对象发送消息到子线程中的消息队列中：```javanew Thread(new Runnable() { @Override public void run() { Looper.prepare(); Handler handler = new Handler() { @Override public void handleMessage(Message msg) { // 在这里处理消息 } }; Looper.loop(); }}).start();Handler handler = new Handler() { @Override public void handleMessage(Message msg) { // 在这里发送消息到子线程 handler.sendEmptyMessage(0); }};```需要注意的是，子线程中的消息循环要在消息发送之前开启，在消息处理完成之后才能结束，否则程序会崩溃。同时，在子线程退出前，需要调用Looper.quit()方法来结束消息循环。另外，在使用Looper时还需要注意避免内存泄露问题，避免使用匿名内部类等操作。

GPS里的话吧 就像他们说的 第一句 一直走第二句 第二个路口左转没什么可分析的 非常简单法语不太好的话 GPS调成中文或者英文别耽误开车

尽管需要花很多的步骤来帮助客户看到虚拟架构的潜在好处，但是如果集中在服务器巩固的价值时就会变得比较缺乏了。当虚拟化的建议由简单的数据中心工具不断发展时，VMware的ROI/TCO计算工具也在不断进步。　　最新版本的计算工具提供了一种方法来获得总共持有成本(TCO)以及投资收益(ROI)的减少，这从VMware的虚拟化产品和解决方案的实现可以得到：　　1. VMware 架构(VI3)　　2. VMware 实验室管理器　　3. VMware 虚拟桌面架构(VDI)　　你可以通过使用计算工具，完成下面简单的步骤来评估潜在的成本节省：　　1.填写一个简单的调查问卷。回答一些关于你的公司的问题并且选择是否你对巩固成本节省感兴趣，虚拟实验室好处或者桌面控制以及管理节省。　　2.定制化假象。该计算工具使用超过200个附加的办法来计算一个成本收益/ROI分析。这些值可以修改并加以精确。　　3.回顾总共成本节省以及投资收益(ROI)。你可以查看你的定制化成本节省，比较你当前的拥有总共成本以及针对虚拟化VMware环境的成本节省估计　　4.保存你的分析。你可以保存你的分析以备未来回顾或者过一段时间重新打开。　　5.获得详细报告。在注册后，你可以点击报告按钮来获得一个完全的你的个人分析结果报告，该报告包括执行总结概况以及由一个PDF或者RTF格式的分类所得到的详细结果。数据可以导出到一个微软的Excel电子表格中。　　你自己试一下这个计算工具，

loi是法律droit 是权利法律定义权利。

dichroic filter（二向色滤光片）就是一种光学镜片。常规灯里当然没这个镜片。光学镜片：按滤光片的光谱特性分 带通滤光片 截止滤光片 二向分光滤光片 中性密度滤光片 反射滤光片 按应用类型和特点分 医疗生化仪用滤光片 生物芯片阅读仪滤光片 荧光显微镜用滤光片 警用多波段滤光片 激光波长滤光片 分析谱线滤光片 汞灯谱线滤光片 按工作的光谱波段分 紫外滤光片 可见滤光片 红外滤光片 按膜层材料和制造技术分 软膜滤光片 硬膜滤光片二向色滤波片特点、作用：（1）增色或减色增色或减色滤波片可以起到分色的作用。（2）二向色滤波片组二向色滤波片组的交叉使用可以得到所需颜色的波段。在颜色的处理中运用比较广泛。

1）点击左上角的“New”按键，在新对话框中，名字随便取一个，类型选择“Linux”，版本选择“Linux 2.6 /3.x /4.x (32-bit)”：2）选择“Next”，在新对话框中，设置虚拟机的内存大小。笔者设置为2GB：3）点击“Next”，在接下来的对话框中，选择“Create a virtual hard disk now”：4）点击“Create”，在新对话框中，选择磁盘镜像文件类型为VDI，即第一项：5）点击“Next”，选择动态分配：6）再点击“Next”，填入磁盘镜像文件的文件名和容量的上限，笔者选择10GB，应该够用了：7）点击“Create”后，虚拟机就创建成功了。8）在虚拟机中创建一个光盘驱动器，并讲下载下来的Android-x86的光盘镜像文件关联上去。在VirtualBox中，选择你刚才创建的那个虚拟机，然后点击上方的“Settings”按钮。接着选择“Storage”选项卡，在右边的控制器旁边，点击那个带加号的光盘图标，在弹出的对话框中选择“Choose disk”：接下来找到你下载的那个.iso文件，并选择打开就可以了。同时，请确保虚拟机允许光盘启动，还是在“Settings”对话框中，选择“System”，在右边的“Boot Order”中，“Optical”被选上了：9）更改一下网络配置，芯片组请选择Intel的ICH系列的，最好不要选择PIIX3，如上图。在“Network”选项卡中，启动一个网卡适配器，选择网络类型为“NAT”或“Bridged Adapter”，名字是“eth0”，在高级选项中将适配器类型也改成Intel系列的：好了，虚拟机配置好了，下面直接启动虚拟机，进行安装。具体安装的步骤如下：1）在光盘启动界面中，选择“Installation - Install Android-x86 to harddisk”：2）在接下来的对话框中，你应该可以看到“sda”，它就是你前面创建虚拟机时挂载上来的那个磁盘镜像。不过，这个磁盘镜像还没有格式化，还不能用于安装，所以我们先要选择“Create/Modify partitions”：3）下面让你选择是否用GPT，请确保千万选择No：4）再选择“New”，创建磁盘分区：5）选择“Primary”：6）下面的“Size”直接回车，选择默认值。然后，千万记得要将这个分区标记为可启动的：7）再选择“Write”，将改变写入磁盘，请耐心等待，这步可能要花一点时间。最后，选择“Quit”退出到前面的页面。这时，应该可以看到“sda1”了，证明分区成功：8）选择这个分区，并在下面的页面中，选择将磁盘格式化成ext3格式：9）请键入yes确认要格式化。在下面的页面中，请选择安装GRUB，但不用选择安装GRUB2：10）再下面的配置，选什么都随便了，一路回车，安装就会正式进行了。安装完成后，选择“Reboot”重启一下。别忘了，将虚拟机的光盘启动关掉，或者将启动的优先级调到硬盘之后，否则再次启动还是从光盘引导。

你好，据我的了解，目前手机上暂时没有支持这种音频格式的解码软件，建议你使用相关程序转码后进行播放。相关知识：opus是一种声音编码格式，Opus的前身是celt编码器。是由IETF开发，适用于网络上的实时声音传输，标准格式为RFC 6716。转码软件推荐：——TAudioConverter目前支持播放Opus格式音频的程序列表：GStreamer, libavcodec(ffmpeg)——Linux系统Foobar2000——Windows系统Firefox——Windows系统

歌曲名:My Heroine歌手:The Maine专辑:Pioneer & the Good LoveThe Maine - My HeroineI"m feeling pretty dirty babyForgive my sins.I get the feeling you could save me honey,My heroine.Your hips, my hands, you swing and you dance,Yea, I"m feeling pretty lonely babySo just let me inJust let me inYou"re my heroine, just suicideIf I let you in, you crawl inside.Oh you"re savin" my skinShe can"t wait to sink inMy heroineI feel a little withdrawal baby,Come pick me up.Took a hit from your levelNow I just can"t get enoughYour taste, my touch,A little bit of love and a whole lot of lust.I"m feeling pretty lonely baby,So just let me inJust let me inYou"re my heroine, just suicideIf I let you in, you crawl inside.Oh you"re savin" my skinShe can"t wait to sink inMy heroineDada dadada da da da daDada dadada da da da daDada dadada da da da daDada dadada da da da daYour hips, my hands,you swing, and you dance.I"m feeling pretty lonely baby,So just let me inYou"re my heroine, just suicideIf I let you in, you crawl insideOh you"re savin" my skinShe can"t wait to sink inMy heroineYou"re my heroine, just suicideIf I let you in, you crawl insideOh you"re savin" my skinShe can"t wait to sink inMy heroinehttp://music.baidu.com/song/55296723

名词 n. 1. 肝脏[C] Alcohol may cause damage to the liver. 酒精会损坏肝脏。 2. (牛,鸡等供食用的)肝[U] liver2 名词 n. [C] 1. (一般与限定词连用)过着...生活的人 Mr. Kern is a clean liver. 克恩先生是个生活上洁身自好的人。 2. 居住者,...

activity是Android组件中最基本也是最为常见用的四大组件之一。Android四大组件有Activity，Service服务，Content Provider内容提供，BroadcastReceiver广播接收器。 基本介绍 外文名 ：Activity 定义 ：Android系统组件 概要说明,详细说明,基本状态,状态转换,方法通知, 概要说明 Activity是Android组件中最基本也是最为常见用的四大组件（Activity，Service服务,Content Provider内容提供者，BroadcastReceiver广播接收器）之一。 Activity是一个应用程式组件，提供一个萤幕，用户可以用来互动为了完成某项任务。 Activity中所有操作都与用户密切相关，是一个负责与 用户互动 的组件，可以通过setContentView(View)来 显示指定控制项 。 在一个android套用中，一个Activity通常就是一个单独的萤幕，它上面可以显示一些控制项也可以监听并处理用户的事件做出回响。Activity之间通过Intent进行通信。 详细说明 基本状态 在android 中，Activity 拥有四种基本状态： Active/Running 一个新 Activity 启动入栈后，它显示在萤幕最前端，处理是处于栈的最顶端（Activity栈顶），此时它处于可见并可和用户互动的激活状态,叫做活动状态或者运行状态（active or running）。 2 . Paused 当 Activity失去焦点， 被一个新的非全萤幕的Activity 或者一个透明的Activity 被放置在栈顶，此时的状态叫做暂停状态（Paused）。此时它依然与视窗管理器保持连线，Activity依然保持活力（保持所有的状态，成员信息，和视窗管理器保持连线），但是在系统记忆体极端低下的时候将被强行终止掉。所以它仍然可见，但已经失去了焦点故不可与用户进行互动。 3 . Sped 如果一个Activity被另外的Activity完全覆盖掉，叫做停止状态（Sped）。它依然保持所有状态和成员信息，但是它不再可见，所以它的视窗被隐藏，当系统记忆体需要被用在其他地方的时候，Sped的Activity将被强行终止掉。 4 . Killed 如果一个Activity是Paused或者Sped状态，系统可以将该Activity从记忆体中删除，Android系统采用两种方式进行删除，要么要求该Activity结束，要么直接终止它的进程。当该Activity再次显示给用户时，它必须重新开始和重置前面的状态。 状态转换 当一个 Activity 实例被创建、销毁或者启动另外一个 Activity 时，它在这四种状态之间进行转换，这种转换的发生依赖于用户程式的动作。下图说明了 Activity 在不同状态间转换的时机和条件： 图1. Activity 的状 态转换 如上所示，Android 程式设计师可以决定一个 Activity 的“生”，但不能决定它的“死”，也就是说程式设计师可以启动一个 Activity，但是却不能手动的“结束”一个 Activity。当你调用 Activity.finish() 方法时，结果和用户按下 BACK 键一样：告诉 Activity Manager 该 Activity 实例完成了相应的工作，可以被“回收”。随后 Activity Manager 激活处于栈第二层的 Activity 并重新入栈，同时原 Activity 被压入到栈的第二层，从 Active 状态转到 Paused 状态。例如：从 Activity1 中启动了 Activity2，则当前处于栈顶端的是 Activity2，第二层是 Activity1，当我们调用 Activity2.finish() 方法时，Activity Manager 重新激活 Activity1 并入栈，Activity2 从 Active 状态转换 Sed 状态， Activity1. onActivityResult(int requestCode, int resultCode, Intent data) 方法被执行，Activity2 返回的数据通过 data 参数返回给 Activity1。 Activity栈 Android 是通过一种 Activity 栈的方式来管理 Activity 的，一个 Activity 的实例的状态决定它在栈中的位置。处于前台的 Activity 总是在栈的顶端，当前台的 Activity 因为异常或其它原因被销毁时，处于栈第二层的 Activity 将被激活，上浮到栈顶。当新的 Activity 启动入栈时，原 Activity 会被压入到栈的第二层。一个 Activity 在栈中的位置变化反映了它在不同状态间的转换。Activity 的状态与它在栈中的位置关系如下图所示： 图2. Activity 的状 态 与它在 栈 中的位置 关 系 如上所示，除了最顶层即处在 Active 状态的 Activity 外，其它的 Activity 都有可能在系统记忆体不足时被回收，一个 Activity 的实例越是处在栈的底层，它被系统回收的可能性越大。系统负责管理栈中 Activity 的实例，它根据 Activity 所处的状态来改变其在栈中的位置。 方法通知 下面的图显示了Activity的重要状态转换，矩形框表明Activity在状态转换之间的回调接口，开发人员可以重载实现以便执行相关代码，带有颜色的椭圆形表明Activity所处的状态。 图 3 . Activity 的状 态 转换的方法和实现 在上图中，Activity有三个关键的循环： 1. 整个的生命周期，从onCreate(Bundle)开始到onDestroy()结束。Activity在onCreate()设定所有的“全局”状态，在onDestory()释放所有的资源。例如：某个Activity有一个在后台运行的执行绪，用于从网路下载数据，则该Activity可以在onCreate()中创建执行绪,在onDestory()中停止执行绪。 2. 可见的生命周期，从onStart()开始到onS()结束。在这段时间，可以看到Activity在萤幕上，尽管有可能不在前台，不能和用户互动。在这两个接口之间，需要保持显示给用户的UI数据和资源等，例如：可以在onStart中注册一个IntentReceiver来监听数据变化导致UI的变动，当不再需要显示时候，可以在onS()中注销它。onStart()，onS()都可以被多次调用，因为Activity随时可以在可见和隐藏之间转换。 3. 前台的生命周期，从onResume()开始到onPause()结束。在这段时间里，该Activity处于所有 Activity的最前面，和用户进行互动。Activity可以经常性地在resumed和paused状态之间切换，例如：当设备准备休眠时，当一个 Activity处理结果被分发时，当一个新的Intent被分发时。所以在这些接口方法中的代码应该属于非常轻量级的。

哪个？

这个意外进程停止,出现的情况有两种:1.程序后台运行时,系统资源不足时自动杀死该进程从而获取更多的资源,而用户在进入该界面时,进程已被杀死而无法恢复前一状态而引起的程序崩溃.2.手机root后,用户权限扩大导致误删了系统个别文件导致的程序无法运行.解决办法:1.种情况属于系统内部的,无法干涉2.从新刷机,刷机后进行反root,保证用户没有最高权限而不能删除系统文件。现在的人都以为root可以随便弄，权限扩大很危险！系统软件是不能随便删除的！你手机有root过么？

三星手机一般建议进行以下操作：1、重启后尝试；2、查看手机是否有系统推送通知，若有，将手机更新到最新系统版本。3、卸载近期安装的第三方应用后观察。4、备份数据（联系人、短信、照片等），恢复出厂设定尝试。若问题依然存在，建议您携带手机、购机发票、包修卡至当地的三星售后服务中心进行检测。

你好，这是安卓进程停止，一般不是重要进程，需要时会自动启动进程，一般不用管他。安卓系统已启动的程序退出时不会关闭进程，后台自动协调运存，需要时将不重要的进程关闭，以便为其他应用分配存储。