[android] 标题部分管理（android标题栏）

25-02-26 12

本文将带您了解关于[android]标题部分管理的新内容，同时我们还将为您解释android标题栏的相关知识，另外，我们还将为您提供关于Android-Android面试题集--Android部分答案

本文将带您了解关于[android] 标题部分管理的新内容，同时我们还将为您解释android标题栏的相关知识，另外，我们还将为您提供关于Android - Android 面试题集 -- Android 部分答案、Android 4.0子标题(部分)标签样式、android @android:Theme.Dialog 和 @android:Widget.Button找不到、Android Emulator 是否包含 Android SDK 或 Android Studio？的实用信息。

本文目录一览：

[android] 标题部分管理（android标题栏）
Android - Android 面试题集 -- Android 部分答案
Android 4.0子标题(部分)标签样式
android @android:Theme.Dialog 和 @android:Widget.Button找不到
Android Emulator 是否包含 Android SDK 或 Android Studio？

[android] 标题部分管理（android标题栏）

标题分类

1.1 普通标题

1.1.1 标题内容管理

1.1.2 帮助和返回的按钮

1.2 未登录的标题

1.3 登陆中的标题

1.4 登陆完成后的标题

package com.tsh.lottery.view.manager;

import com.tsh.lottery.R;

 android.app.Activity;
 android.view.View;
 android.widget.RelativeLayout;
/**
 * 标题管理
 * @author taoshihan
 *
 */
public class TitleManager {
    private RelativeLayout generalTitle,unloginTitle,loginTitle;
    private static TitleManager instance=new TitleManager();
     TitleManager(){}
    static TitleManager getInstance(){
        return instance;
    }
    
     * 初始化标题
     * @param activity
     */
    void init(Activity activity){
        generalTitle=(RelativeLayout) activity.findViewById(R.id.title_general);
        loginTitle=(RelativeLayout) activity.findViewById(R.id.title_login);
        unloginTitle=(RelativeLayout) activity.findViewById(R.id.title_unlogin);
    }
    
     * 隐藏所有标题
      hideTitle(){
        generalTitle.setVisibility(View.GONE);
        unloginTitle.setVisibility(View.GONE);
        loginTitle.setVisibility(View.GONE);
    }
    
     * 显示通用的标题
      showGeneralTitle() {
        hideTitle();
        generalTitle.setVisibility(View.VISIBLE);
    }
    
     * 显示未登录的标题
      showUnloginTitle() {
        hideTitle();
        unloginTitle.setVisibility(View.VISIBLE);
    }
    
     * 显示已经登陆的标题
      showLoginTitle() {
        hideTitle();
        loginTitle.setVisibility(View.VISIBLE);
    }
}

使用ActionBar

2.1 清单文本配置

2.2 新建menu资源文件

2.3 Activity中设置

清单文件：

设置主题是Theme.Holo下面的就可以

菜单文件：

item里面的showAsAction属性必须填，例如：always是总是显示的意思，never不显示

actionViewClass 属性，可以设置View控件，例如：android.widget.SearchView 是显示搜索

解决overflow的按钮不可见问题：

当存在物理menu键的时候，会出现这个问题，只有按物理menu键，隐藏的按钮从下面出来

使用反射修改ViewConfiguration类的sHasPermanentMenuKey静态变量

    
     * 添加菜单
     */
    @Override
    boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater=getMenuInflater();
        inflater.inflate(R.menu.menu,menu);
        return super.onCreateOptionsMenu(menu);
    }
    
     * 解决ActionBar的问题
      setoverflowMenuQues(){
        ViewConfiguration viewConfiguration=ViewConfiguration.get(this);
        try {
            Field field=ViewConfiguration.class.getDeclaredField("sHasPermanentMenuKey");
            field.setAccessible(true);
            field.setBoolean(viewConfiguration,false);
        } catch (Exception e) {
            e.printstacktrace();
        }
    }

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android" >

    item
        android:id="@+id/menu_search"
        android:actionViewClass="android.widget.SearchView"
        android:showAsAction="always"
        android:title="搜索"/>
    android:showAsAction
        android:id="@+id/menu_user"="用户"="never"="@+id/menu_cart"="购物"="@+id/menu_edit"="编辑"="@+id/menu_setting"="设置"/>

</menu>

Android - Android 面试题集 -- Android 部分答案

2.1 Activity
1.Activity 是什么？
Activity 是 Android 的四大组件之一。是用户操作的可视化界面；它为用户提供了一个完成操作指令的窗口。
当我们创建完毕 Activity 之后，需要调用 setContentView () 方法来完成界面的显示；以此来为用户提供交互的入口。

2. 典型情况下的 Activity 生命周期？
Activity 启动–>onCreate ()–>onStart ()–>onResume ()
点击 home 键回到桌面–>onPause ()–>onStop ()
再次回到原 Activity 时–>onRestart ()–>onStart ()–>onResume ()
退出当前 Activity 时–>onPause ()–>onStop ()–>onDestroy ()

3. 异常情况下的 Activity 的生命周期 & 数据如何保存和恢复？
在 onStop 之前调用 onSaveInstanceState 保存当前 Activity 状态，当 Activity 被重新创建后，系统调用
onRestoreInstanceState，并且把 Activity 销毁时 onSaveInstanceState 方法所保存的 Bundle 对象
作为参数传递给 onRestoreInstanceState 和 onCreate 方法
onRestoreInstanceState 的调用时机发生在 onStart 之后

4. 从 Activity A 跳转到 Activity B 之后，然后再点击 back 键之后，它们的生命周期调用流程是什么？
从 Activity A 跳转到 Activity B
Activity A -> onPause()
Activity B -> onCreate()
Activity B -> onStart()
Activity B -> onResume()
Activity A -> onStop()

点击 back 键
Activity B -> onPause()
Activity A -> onRestart()
Activity A -> onStart()
Activity A -> onResume()
Activity B -> onStop()
Activity B -> onDestroy()

5. 如何统计 Activity 的工作时间？
Activity 开始工作的起点是 onResume () 而工作的停止点为 onPause (),
因此当每次 Activity 调用 onResume () 的时候记录一个时间 a，每次调用 onPause () 的时候再记录一个时间 b,
那么由 b-a 可得当次 Activity 工作的时间。

6. 给我说说 Activity 的启动模式 & 使用场景。
系统默认的启动模式:standard
系统的默认模式，每次启动一个 Activity 都会重新创建一个新的实例
栈顶复用模式：singleTop
如果在任务的栈顶正好存在该 Activity 的实例，就重用该实例 (会调用实例的 onNewIntent () )，
否则就会创建新的实例并放入栈顶，即使栈中已经存在该 Activity 的实例，只要不在栈顶，都会创建新的实例。
使用场景如新闻类或者阅读类 App 的内容页面。
栈内复用模式：singleTask
如果在栈中已经有该 Activity 的实例，就重用该实例 (会调用实例的 onNewIntent () )。
重用时，会让该实例回到栈顶，因此在它上面的实例将会被移出栈。如果栈中不存在该实例，将会创建新的实例放入栈中。
使用场景如浏览器的主界面。不管从多少个应用启动浏览器，只会启动主界面一次，其余情况都会走 onNewIntent，
并且会清空主界面上面的其他页面。
单实例模式：singleInstance
在一个新栈中创建该 Activity 的实例，并让多个应用共享该栈中的该 Activity 实例。
一旦该模式的 Activity 实例已经存在于某个栈中，任何应用再激活该 Activity 时都会重用该栈中的实例
(会调用实例的 onNewIntent () )。其效果相当于多个应用共享一个应用，不管谁激活该 Activity 都会进入同一个应用中。
使用场景如闹铃提醒，将闹铃提醒与闹铃设置分离。singleInstance 不要用于中间页面，如果用于中间页面，跳转会有问题，
比如：A -> B (singleInstance) -> C，完全退出后，在此启动，首先打开的是 B。

7. 如何在任意位置关掉应用所有 Activity & 如何在任意位置关掉指定的 Activity？
封装一个类，成员变量有一个 List 集合，当 Activity 执行 onCreate () 方法时将当前的 Activity 实例加入，
遍历这个 List 且逐一调用 finish () 即可
给每个启动的 Activity 一个 tag, 根据这个 tag 和集合可达到在任意位置关闭指定 Activity 的效果。

8.Activity 的启动流程 (从源码角度解析)？
app 启动的过程有两种情况，第一种是从桌面 launcher 上点击相应的应用图标，
第二种是在 activity 中通过调用 startActivity 来启动一个新的 activity。
我们创建一个新的项目，默认的根 activity 都是 MainActivity，而所有的 activity 都是保存在堆栈中的，
我们启动一个新的 activity 就会放在上一个 activity 上面，而我们从桌面点击应用图标的时候，由于 launcher 本身也是一个应用，
当我们点击图标的时候，系统就会调用 startActivitySately (), 一般情况下，我们所启动的 activity 的相关信息都会保存在 intent 中，
比如 action，category 等等。我们在安装这个应用的时候，系统也会启动一个 PackaManagerService 的管理服务，
这个管理服务会对 AndroidManifest.xml 文件进行解析，从而得到应用程序中的相关信息，比如 service，activity，Broadcast 等等，然后获得相关组件的信息。
当我们点击应用图标的时候，就会调用 startActivitySately () 方法，而这个方法内部则是调用 startActivty (),
而 startActivity () 方法最终还是会调用 startActivityForResult () 这个方法。
因为 startActivityForResult () 方法是有返回结果的，所以系统就直接给一个 - 1，就表示不需要结果返回了。
而 startActivityForResult () 这个方法实际是通过 Instrumentation 类中的 execStartActivity () 方法来启动 activity，
Instrumentation 这个类主要作用就是监控程序和系统之间的交互。而在这个 execStartActivity () 方法中会获取 ActivityManagerService 的代理对象，
通过这个代理对象进行启动 activity。启动会就会调用一个 checkStartActivityResult () 方法，如果说没有在配置清单中配置有这个组件，就会在这个方法中抛出异常了。
当然最后是调用的是 Application.scheduleLaunchActivity () 进行启动 activity，而这个方法中通过获取得到一个 ActivityClientRecord 对象，
而这个 ActivityClientRecord 通过 handler 来进行消息的发送，系统内部会将每一个 activity 组件使用 ActivityClientRecord 对象来进行描述，
而 ActivityClientRecord 对象中保存有一个 LoaderApk 对象，通过这个对象调用 handleLaunchActivity 来启动 activity 组件，
而页面的生命周期方法也就是在这个方法中进行调用。

9. 启动一个其它应用的 Activity 的生命周期分析。
同 4

10.Activity 任务栈是什么？在项目中有用到它吗？说给我听听
-android 任务栈又称为 Task，它是一个栈结构，具有后进先出的特性，用于存放我们的 Activity 组件。
- 我们每次打开一个新的 Activity 或者退出当前 Activity 都会在一个称为任务栈的结构中添加或者减少一个 Activity 组件，因此一个任务栈包含了一个 activity 的集合，android 系统可以通过 Task 有序地管理每个 activity，并决定哪个 Activity 与用户进行交互：只有在任务栈栈顶的 activity 才可以跟用户进行交互。
- 在我们退出应用程序时，必须把所有的任务栈中所有的 activity 清除出栈时，任务栈才会被销毁。当然任务栈也可以移动到后台，并且保留了每一个 activity 的状态。可以有序的给用户列出它们的任务，同时也不会丢失 Activity 的状态信息。
- 需要注意的是，一个 App 中可能不止一个任务栈，某些特殊情况下，单独一个 Actvity 可以独享一个任务栈。还有一点就是一个 Task 中的 Actvity 可以来自不同的 App，同一个 App 的 Activity 也可能不在一个 Task 中。

11. 什么情况下 Activity 不走 onDestory?
当 Activity 被另外一个 Activity 覆盖、失去焦点并不可见时处于 Stoped 状态。
9.0 的时候如果强行终止 activity，那么也不会执行 onDestory

12. 什么情况下 Activity 会单独执行 onPause?
同 11

13.a->b->c 界面，其中 b 是 SingleInstance 的，那么 c 界面点 back 返回 a 界面，为什么？
SingleInstance 这是一种加强的 singleTask 模式，它除了具有 singleTask 模式所有的特性外，还加强了一点，那就是具有此种模式的 Activity 只能单独位于一个任务栈中，换句话说，比如 Activity A 是 singleInstance 模式，当 A 启动后，系统会为它创建一个新的任务栈，然后 A 独自在这个新的任务栈中，由于栈内复用的特性，后续的请求均不会创建新的 Activity, 除非这个独特的任务栈被系统销毁了

14. 如果一个 Activity 弹出一个 Dialog, 那么这个 Acitvity 会回调哪些生命周期函数呢？
是否弹出 Dialog，并不影响 Activity 的生命周期，所以这时和正常启动时 Activity 的生命回调方法一致: onCreate () -> onStart () -> onResume ()。

15.Activity 之间如何通信 & Activity 和 Fragment 之间通信 & Activity 和 Service 之间通信？
1.Activity->Activity
[1]Intent/Bundle
这种方式多用于 Activity 之间传递数据
[2] 类静态变量
在 Activity 内部定义静态的变量，这种方式见于少量的数据通信，如果数据过多，还是使用第一种方式
[3] 全局变量
创建一个类，里面定义一批静态变量，Activity 之间通信都可以访问这个类里面的静态变量，这就是全局变量。

2.Activity->Service
[1] 绑定服务的方式，利用 ServiceConnection 这个接口
[2]Intent
这种方式很简单，我们在启动和停止 Service 时所调用的方法都需要传入一个 Intent 实例对象，通过这个传入的 Intent 对象，我们就可以与 Service 进行通信。
[3] CallBack + Handler, 监听服务的进程变化

3.Activity->Fragment
[1]Bundle
在创建 Fragment 实例的时候，调用方法 setArguments 将一个 Bundle 对象传递给 Fragment，然后在 Fragment 中先去判断是否和当前 Activity 绑定上了，如果绑定上了，就可以拿出这个 Bundle 中的数据
[2] 直接进行方法调用
在 Activity 里通过 Fragment 的引用，可以直接调用 Framgent 中的定义的任何方法。

16. 说说 Activity 横竖屏切换的生命周期。
onPause
onSaveInstanceState // 这里可以用来横竖屏切换的保存数据
onStop
onDestroy
onCreate
onStart
onRestoreInstanceState// 这里可以用来横竖屏切换的恢复数据
onResume

17. 前台切换到后台，然后在回到前台时 Activity 的生命周期。
点击 home 键回到桌面–>onPause ()–>onStop ()
再次回到原 Activity 时–>onRestart ()–>onStart ()–>onResume ()

18. 下拉状态栏时 Activity 的生命周期？
首先，通知栏下拉一点点，符合一般描述中 “Activity 被部分遮挡”——onPause ()
然后，通知栏完全落下之后，“Activity 被全部遮挡”——onStop ()

19.Activity 与 Fragment 的生命周期比较？
onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()->onResume()；
Fragment 变为不可见状态（锁屏、回到桌面、被 Activity 完全覆盖）：onPause ()->onSaveInstanceState ()->onStop ()；
Fragment 变为部分可见状态（打开 Dialog 样式的 Activity）：onPause ()->onSaveInstanceState ()；
Fragment 由不可见变为活动状态：onStart ()->OnResume ()；
Fragment 由部分可见变为活动状态：onResume ()；
退出应用：onPause ()->onStop ()->onDestroyView ()->onDestroy ()->onDetach ()
Fragment 被回收又重新创建：被回收执行 onPause ()->onSaveInstanceState ()->onStop ()->onDestroyView ()->onDestroy ()->onDetach ()，重新创建执行 onAttach ()->onCreate ()->onCreateView ()->onActivityCreated ()->onStart ()->onResume ()->setUserVisibleHint ()；
横竖屏切换：与 Fragment 被回收又重新创建一样。

20. 了解哪些 Activity 常用的标记位 Flags？
1.Intent.FLAG_ACTIVITY_NEW_TASK，是为 Activity 指定 “singleTask” 启动模式
2.Intent.FLAG_ACTIVITY_SINGLE_TOP，是为 Activity 指定 “singleTop” 启动模式
3.FLAG_ACTIVITY_CLEAR_TOP，如果跟 singleTask 启动模式一起出现，如果被启动的 Activity 已经存在实例，则 onNewIntent 方法会被回调，如果被启动的 Activity 采用 standard 模式启动，那么连同它跟它之上的 Activity 都要出栈，并且创建新的实例放入栈顶。
4.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS，新的 Activity 不会在最近启动的 Activity 的列表中保存。等同于指定属性 android:excludeFromRecents="true"

21. 谈谈隐式启动和显示启动 Activity 的方式？
显式启动：直接指定要跳转的 Activity 类名，不用过滤，效率高，适用于同一个应用中的不同 Activity 跳转
隐式启动：需要过滤，相对耗时，但可以找到所有之匹配的应用。适用于不同应用之间的 Activity 跳转。
隐式启动会找到所匹配到的应用，并提示用户选择打开方式，如果有多个组件被匹配成功，就会以对话框列表的方式让用户进行选择。

22.Activity 用 Intent 传递数据和 Bundle 传递数据的区别？为什么不用 HashMap 呢？
要把值通过 A 经过 B 传给 C
如果用 Intent 的话 A-B 先写一遍再在 B 中都取出来然后在把值塞到 Intent 中再跳到 C 累吗？
如果我在 A 中用了 Bundle 的话我把 Bundle 传给 B 在 B 中再转传到 C C 就可以直接去了
这样的话还有一个好处就是在 B 中还可以给 Bundle 对象添加新的 key - value 同样可以在 C 中取出来

为什么不用 HashMap 呢？
Bundle 内部是由 ArrayMap 实现的，ArrayMap 的内部实现是两个数组，一个 int 数组是存储对象数据对应下标，一个对象数组保存 key 和 value，内部使用二分法对 key 进行排序，所以在添加、删除、查找数据的时候，都会使用二分法查找，只适合于小数据量操作，如果在数据量比较大的情况下，那么它的性能将退化。而 HashMap 内部则是数组 + 链表结构，所以在数据量较少的时候，HashMap 的 Entry Array 比 ArrayMap 占用更多的内存。因为使用 Bundle 的场景大多数为小数据量
在 Android 中如果使用 Intent 来携带数据的话，需要数据是基本类型或者是可序列化类型，HashMap 使用 Serializable 进行序列化，而 Bundle 则是使用 Parcelable 进行序列化。而在 Android 平台中，更推荐使用 Parcelable 实现序列化，虽然写法复杂，但是开销更小，所以为了更加快速的进行数据的序列化和反序列化，系统封装了 Bundle 类，方便我们进行数据的传输。

23. 在隐式启动中 Intent 可以设置多个 action, 多个 category 吗 & 顺便讲讲它们的匹配规则？
一个 Intent 对象中最多只能包括一个 Action 属性，但可以包含多个 Category 属性

24.Activity 可以设置为对话框的形式吗？
在 mainifest 中对应的 activity 上配置如下的代码，即可让 activity 以对话框的方式表现出来
< android:theme="@android:style/Theme.Dialog">

25. 如何给 Activity 设置进入和退出的动画？
一种是直接在代码中设置，这需要使用到 Activity 的 overridePendingTransition 方法；
另一种是通过自定义 Activity 的主题来实现。

26.Activity 使用 Intent 传递数据是否有限制 & 如果传递一个复杂的对象，例如一个复杂的控件对象应该怎么做？
1 传 512K 以下的数据的数据可以正常传递。
2 传 512K~1024K 的数据会出错，闪退。
3 传 1024K 以上的数据会报错：TransactionTooLargeException。
4 考虑到 Intent 还包括要启动的 Activity 等信息，实际可以传的数据略小于 512K

如果传递一个复杂的对象，例如一个复杂的控件对象应该怎么做？
1）将对象转换为 Json 字符串
2）使用 Serializable,Parcelable 序列化对象
1.Serializable 实现:
    ①业务 Bean 实现：Serializable 接口，写上 getter 和 setter 方法
    ②Intent 通过调用 putExtra (String name, Serializable value) 传入对象实例当然对象有多个的话多个的话，我们也可以先 Bundle.putSerializable (x,x);
    ③新 Activity 调用 getSerializableExtra () 方法获得对象实例: eg:Product pd = (Product) getIntent ().getSerializableExtra ("Product");
    ④调用对象 get 方法获得相应参数
2.Parcelable 实现:
一般流程:
    ①业务 Bean 继承 Parcelable 接口，重写 writeToParcel 方法，将你的对象序列化为一个 Parcel 对象；
    ②重写 describeContents 方法，内容接口描述，默认返回 0 就可以
    ③实例化静态内部对象 CREATOR 实现接口 Parcelable.Creator
    ④同样式通过 Intent 的 putExtra () 方法传入对象实例，当然多个对象的话，我们可以先放到 Bundle 里 Bundle.putParcelable (x,x), 再 Intent.putExtras () 即可
3. 使用数据库

2.2 BroadcastReceiver
1. 广播是什么？
它是一种广泛运用在应用程序之间传输信息的机制，Android 中我们发送广播内容是一个 Intent, 这个 Intent 中可以携带我们要发送的数据。

2. 广播的注册方式有哪些？
1 静态注册：创建一个广播接收器类，广播接收器在 AndroidManifest.xml 文件中注册
2 动态注册：新建一个类，让它继承自 BroadcastReceiver, 并重写父类的 onReceive () 方法就行了

3. 广播的分类 & 特性 & 使用场景？
3.1 无序广播
context.sendBroadcast (Intent) 方法发送的广播，不可被拦截，当然发送的数据，接收者是不能进行修改的。
3.2 有序广播
context.sendOrderBroadcast (Intent) 方法发送的广播，可被拦截，而且接收者是可以修改其中要发送的数据，修改和添加都是可以的，这就意味着优先接收者对数据修改之后，下一个接收者接受的数据是上一个接收者已经修改了的，这必须明白。
3.3 本地广播
localBroadcastManager.sendBroadcast (Intent)，只在 app 内传播。

4. 说说系统广播和本地广播的原理 & 区别 & 使用场景。
4.1 系统广播的源码角度分析
a. 自定义广播接收者 BroadcastReceiver, 并且重写 onReceiver () 方法。
b. 通过 Binder 机制向 AMS (Activity Manager Service) 进行注册。
c. 广播发送者通过 Binder 机制向 AMS 发送广播。
d.AMS 查找符合条件 (IntentFilter/Permission 等) 的 BroadcastReceiver，将广播发送到相应的 BroadcastReceiver (一般情况下是 Activity) 的消息队列中。
e. 消息循环执行拿到此广播，回调 BroadcastReceiver 中的 onReceiver () 方法。
4.2 本地广播的源码角度分析
相比于系统广播而言，本地广播更加安全，更加高效，以下是本地广播的特点以及内部的实现机制：
特点：
a. 使用它发送的广播将只在自身 app 内传播，因此你不必担心泄漏隐私的数据。
b. 其他 app 无法对你的 app 发送该广播，因此你的 app 根本不可能收到非自身 app 发送的该广播，因此你不必担心有安全漏洞可以利用。
c. 比系统广播更加高效。

5. 有两个应用注册了一样的广播，一个是静态，一个是动态，连优先级也一样，那么当广播从系统发出来后，哪个应用先接收到广播？
动态注册的接收者会先执行

2.3 ContentProvider
1. 什么是内容提供者？
（Content Provider）主要用于在不同的应用程序之间实现数据共享的功能

2. 说说如何创建自己应用的内容提供者 & 使用场景。
新建一个类去继承 ContentProvider 类的方式来创建一个自己的内容提供器。ContentProvider 类有 6 个抽象方法，我们在使用子类继承它的时候，需要将这 6 个方法全部重写。

3. 说说 ContentProvider 的原理。
一种进程间通信的方式，其实它原理核心就是 Binder。

4.ContentProvider,ContentResolver,ContentObserver 之间的关系？
ContentProvider—— 内容提供者，在 android 中的作用是对外共享数据，也就是说你可以通过
ContentProvider 把应用中的数据共享给其他应用访问，其他应用可以通过 ContentProvider 对你应用中的数据进行添删改查。
ContentResolver—— 内容解析者，其作用是按照一定规则访问内容提供者的数据（其实就是调用内容提供者自定义的接口来操作它的数据）。 ContentObserver—— 内容观察者，目的是观察 (捕捉) 特定 Uri 引起的数据库的变化，继而做一些相应的处理，它类似于数据库技术中的触发器 (Trigger)，当 ContentObserver 所观察的 Uri 发生变化时，便会触发它

5. 说说 ContentProvider 的权限管理。
android:grantUriPermssions: 临时许可标志。
android:permission:Provider 读写权限。
android:readPermission:Provider 的读权限。
android:writePermission:Provider 的写权限。
android:enabled: 标记允许系统启动 Provider。
android:exported: 标记允许其他应用程序使用这个 Provider。
android:multiProcess: 标记允许系统启动 Provider 相同的进程中调用客户端。

2.4 Service
1. 什么是 Service?
Service (服务) 是一个一种可以在后台执行长时间运行操作而没有用户界面的组件。它运行于 UI 线程，因此不能进行耗时的操作。

2. 说说 Service 的生命周期。
bindService:onCreate()-onBind()-unBind()-onDestroy()
这种方式进行启动 service 好处是更加便利 activity 中操作 service, 通过 ServiceConnection 来获取 service 中内部类的类对象，然后通过这个类对象就可以调用类中的方法
startService:onCreate()-onStartCommon()-onDestroy()
当我们通过 startService 被调用以后，多次在调用 startService (),onCreate () 方法也只会被调用一次，而 onStartConmon () 会被多次调用

3.Service 和 Thread 的区别？
Service 的运行是在 UI 线程当中的，是绝对绝对不能进行耗时操作的，而 Thread 开启的子线程则可以进行耗时操作，但是 Thread 开启的子线程是不能直接对 UI 进行操作的，否则极有可能发生直接让程序崩掉，这就是它们的区别。

4.Android 5.0 以上的隐式启动问题及其解决方案。
1 将隐式启动转换为显式启动，兼容编译 sdk5.0 以后版本
2 直接写上包名以及标志
3 判断应用是否安装

5. 给我说说 Service 保活方案
1) onStartCommand 方法，返回 START_STICKY
2) 提升 service 优先级
在 AndroidManifest.xml 文件中对于 intent-filter 可以通过 android:priority = "1000" 这个属性设置最高优先级，1000 是最高值，如果数字越小则优先级越低，同时适用于广播。
3) 提升 service 进程优先级
Android 中的进程是托管的，当系统进程空间紧张的时候，会依照优先级自动进行进程的回收。Android 将进程分为 6 个等级，它们按优先级顺序由高到低依次是:
复制代码
1. 前台进程 (FOREGROUND_APP)
2. 可视进程 (VISIBLE_APP)
3. 次要服务进程 (SECONDARY_SERVER)
4. 后台进程 (HIDDEN_APP)
5. 内容供应节点 (CONTENT_PROVIDER)
6. 空进程 (EMPTY_APP)
4) onDestroy 方法里重启 service
5) Application 加上 Persistent 属性

6.IntentService 是什么 & 原理 & 使用场景 & 和 Service 的区别。
IntentService 是继承处理异步请求的一个类，在 IntentService 内有一个工作线程来处理耗时操作，启动 IntentServiced 的方式和启动传统的 Service 一样，同时，当任务执行完成后，IntentService 会自动停止，而不需要我们手动去控制或 stopSelf ()。
a. 它本质是一种特殊的 Service, 继承自 Service 并且本身就是一个抽象类。
b. 它内部是由 HandlerThread 和 Handler 实现异步操作。

7. 创建一个独立进程的 Service 应该怎样做？
创建远程服务
1) 定义 AIDL 接口
2) 新建 Remote Service
3) 在 AndroidManifest.xml 中对 Remote Service 进行配置

8.Service 和 Activity 之间如何通信？
1、Intent 传值，onStartCommand () 接收。
2、通过 onBind () 获取 Service 实例，然后再调用 Binder 中的相关方法。
3、通过回调函数达到侦听 Service 中数据变化。

9. 说说你了解的系统 Service。
https://blog.csdn.net/geyunfei_/article/details/78851024

10. 谈谈你对 ActivityManagerService 的理解。
从系统运行的角度看，AmS 可以分为 Client 端和 Service 端：Client 端运行在各个 app 进程，app 进程实现了具体的 Activity，Service 等，告诉系统我有那些 Activity，Service 等，并且调用系统接口来完成显示；Service 端运行在 SystemServer 进程，是系统级别的 ActivityManagerService 的具体实现，其响应 Client 端的系统调用请求，并且管理 Client 端各个 app 进程的生命周期。
https://www.cnblogs.com/xingchenkn/p/3637137.html

11. 在 Activtiy 中创建一个 Thread 和在一个 Service 中创建一个 Thread 的区别？
Activtiy 中的线程是前台线程，它的生命周期往往是随着 Activity 的，Activity 销毁的时候，那个线程也应该被销毁，否则就会出现内存泄漏现象。而 Service 中开启的线程，它是工作在后台的，一般来讲，后台线程的生存期是比较长的。

2.5 Handler
1. 子线程一定不能更新 UI 吗？
是否有些控件支持在子线程更新 UI 呢？比如：SurfaceViw
在 Activity 的 onResume () 生命周期函数之前是可以在子线程中更新 UI 的。

2. 给我说说 Handler 的原理
Message：消息，其中包含了消息 ID，消息处理对象以及处理的数据等，由 MessageQueue 统一列队，终由 Handler 处理。
Handler：处理者，负责 Message 的发送及处理。使用 Handler 时，需要实现 handleMessage (Message msg) 方法来对特定的 Message 进行处理，例如更新 UI 等。
MessageQueue：消息队列，用来存放 Handler 发送过来的消息，并按照 FIFO 规则执行。当然，存放 Message 并非实际意义的保存，而是将 Message 以链表的方式串联起来的，等待 Looper 的抽取。
Looper：消息泵，不断地从 MessageQueue 中抽取 Message 执行。因此，一个 MessageQueue 需要一个 Looper。
Thread：线程，负责调度整个消息循环，即消息循环的执行场所。
Handler 是可以通过发送和处理 Message 和 Runnable 对象来关联相应线程的 MessageQueue。通常我们认为它是一种异步机制。
a. 可以让对应的 Message 和 Runnable 在未来的某个时间点进行相应的处理。
b. 让自己想要的耗时操作在子线程中完成，让更新 UI 的操作在主线程中完成，而子线程与主线程之间的通信就是靠 Handler 来完成。

3.Handler 导致的内存泄露你是如何解决的？
Handler 导致内存泄漏的原因是：非静态内部类持有外部类的引用，导致外部类在没有被使用的时候，迟迟不能被回收，从而导致内存泄漏。即非静态 Handler 内部类持有外部 Activity 的引用，导致外部 Activity 退出 / 销毁的时候，它迟迟不能被回收，最终导致 Activity 的内存泄漏。解决方法：将 Handler 类声明为静态，如果 Handler 需要访问外部类 Activity 的成员变量或者成员方法，可以用弱引用的方式解决。

4. 如何使用 Handler 让子线程和子线程通信？
在 ThreadA 中准备一个 Looper，也就是消息轮询大管家，然后准备发送消息的 Handler，准备发送消息的 Handler 很容易理解，那就是在 ThreadA 中生成一个 Handler 对象即可，
那么准备 Looper 怎么做呢？在 ThreadA 中调用 Looper.prepare ()，然后再调用 Looper.loop () 即可

5. 你能给我说说 Handler 的设计原理？

6.HandlerThread 是什么 & 原理 & 使用场景？
a.HandlerThread 本质上是一个线程类，它继承了 Thread。
b.HandlerThread 有自己内部的 Looper 对象，可以进行 Looper 循环。
c. 通过获取 HandlerThread 的 Looper 对象传递给 Handler 对象，可以在 handlerMessage 方法中执行异步任务。
d. 优点是不会有堵塞，减少对性能的消耗，缺点是不能进行多任务的处理，需要等待进行处理，处理效率较低。
e. 与线程池注重并发不同，HandlerThread 是一个串行队列，HandlerThread 背后只有一个线程

7.IdleHandler 是什么？
IdleHandler 可以用来提升性能，主要用在我们希望能够在当前线程消息队列空闲时做些事情（譬如 UI 线程在显示完成后，如果线程空闲我们就可以提前准备其他内容）的情况下，不过最好不要做耗时操作。

8. 一个线程能否创建多个 Handler,Handler 和 Looper 之间的对应关系？
一个线程可以有多个 Handler，但是一个线程只能有一个 Looper，一个 MessageQueue。因此它们之间的关系是一个线程只能有一个 Looper, 一个 MessageQueue, 多个 Handler。

9. 为什么 Android 系统不建议子线程访问 UI？
UI 控件不是线程安全的，如果多线程并发访问 UI 控件可能会出现不可预期的状态
那为什么系统不对 UI 控件的访问加上锁机制呢？
加上锁机制会让 UI 访问的逻辑变得复杂；锁机制会降低 UI 访问的效率，因为锁机制会阻塞某些线程的执行；

10.Looper 死循环为什么不会导致应用卡死？
ActivityThread 的 main 方法主要就是做消息循环，一旦退出消息循环，那么你的应用也就退出了。

11. 使用 Handler 的 postDealy 后消息队列有什么变化？
https://blog.csdn.net/qingtiantianqing/article/details/72783952

12. 可以在子线程直接 new 一个 Handler 出来吗？
1（需先在该线程中手动开启 Looper（Looper.prepare ()-->Looper.loop ()），然后将其绑定到 Handler 对象上
2（通过 Looper.getMainLooper ()，获得主线程的 Looper，将其绑定到此 Handler 对象上

13.Message 对象创建的方式有哪些 & 区别？
https://blog.csdn.net/dfskhgalshgkajghljgh/article/details/52672115

Android 4.0子标题(部分)标签样式

所以我看着Android Dev Design site的ICS,所有的应用程序都有这些字幕/节标题：

我想知道是否有人知道自定义样式来实现这样的标签.我在Android SDK中找不到任何看起来像这样的标签视图,但我真的很喜欢它们的外观.

提前致谢！

解决方法:

所以这就是我最终使用的：

<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:android="http://schemas.android.com/apk/res/android">
    <style name="sectionHeader" parent="android:Widget.Holo.Light.TextView">
        <item name="android:drawableBottom">@drawable/section_header</item>
        <item name="android:drawablePadding">4dp</item>
        <item name="android:layout_marginTop">8dp</item>
        <item name="android:paddingLeft">4dp</item>
        <item name="android:textAllCaps">true</item>
        <item name="android:textColor">@color/emphasis</item>
        <item name="android:textSize">14sp</item>
    </style>
</resources>

其中@ drawable / section_header是：

<?xml version="1.0" encoding="utf-8"?>
<shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    <size android:width="1000dp" android:height="2dp" />
    <solid 
        android:color="@color/emphasis"/>
</shape>

和@ color的：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="emphasis">#31b6e7</color>
    <color name="bg_gray">#cecbce</color>
</resources>

android @android:Theme.Dialog 和 @android:Widget.Button找不到

android @android :Theme.Dialog 和 @android :Widget.Button找不到是什么回事？

Android Emulator 是否包含 Android SDK 或 Android Studio？

来自Android Emulator release notes

Android 模拟器包含在 Android Studio 中。

25.3.0 之前的模拟器版本作为 Android SDK 工具。

为确保您拥有最新版本，请检查 SDK Manager 更新。

对于 25.3.0 之前的 Android Emulator 版本，请参阅 Android SDK 工具发行说明。

关于[android] 标题部分管理和android标题栏的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于Android - Android 面试题集 -- Android 部分答案、Android 4.0子标题(部分)标签样式、android @android:Theme.Dialog 和 @android:Widget.Button找不到、Android Emulator 是否包含 Android SDK 或 Android Studio？的相关信息，请在本站寻找。

本文标签：