1.1 Activity

1、概念

Application：由多个相关的松散的与用户进行交互Activity组成，通常被打包成apk后缀文件中；
Activity：就是被用来进行与用户交互和用来与android内部特性交互的组件，是应用程序的核心；
ActivityStack：将应用程序中打开的Activity保存在历史栈中；Start Activity时入栈，返回时出栈；
AcitivityManager(Service)：Activity管理的核心，是一个独立的进程，负责管理Activity的生命周期；
Task：任务栈，将一系列相关的Activity组合（可以包含多个APP），完成某个应用程序完整操作；
ActivityThread：每一个应用程序所在进程的主线程，循环的消息处理；
ApplicationThread： Binder对象，完成ActivityThread与AcitivityManager的通信，属于进程间通信；

2、 Activity启动过程

ActivityManager和ActivityStack位于同一个进程中，而ApplicationThread和ActivityThread位于另一个进程中。
ActivityManager借助ActivityStack是来把所有的Activity按照后进先出的顺序放在一个堆栈中；
每一个APP都有一个ActivityThread来表示主进程，而其中都包含一个ApplicationThread实例。

下面简要介绍一下Activity启动的过程：(对照以上时序图)

在APK文件安装的时候，PackageManager会解析APK中重要的AndroidManifest.xml文件，你在其中注册过的所有Activity和Service等四大组件的信息，也就会在此刻被PM获取到并存储起来。

Step1：无论是通过Launcher来启动Activity，还是通过Activity内部调用startActivity接口来启动新的Activity，都通过Binder进程间通信进入到ActivityManager进程中，并且调用ActivityManager.startActivity接口；
Step2：ActivityManager调用ActivityStack.startActivityMayWait来做准备要启动的Activity的相关信息；
Step3：ActivityStack通知ApplicationThread要进行Activity启动调度了，这里的ApplicationThread代表的是调用ActivityManager.startActivity接口的进程，对于通过点击应用程序图标的情景来说，这个进程就是Launcher了，而对于通过在Activity内部调用startActivity的情景来说，这个进程就是这个Activity所在的进程了；
Step4：ApplicationThread不执行真正的启动操作，它通过调用ActivityManager.activityPaused接口进入到ActivityManager进程中，看看是否需要创建新的进程来启动Activity；
Step5：对于通过点击应用程序图标来启动Activity的情景来说，ActivityManager在这一步中，会调用startProcessLocked来创建一个新的进程，而对于通过在Activity内部调用startActivity来启动新的Activity来说，这一步是不需要执行的，因为新的Activity就在原来的Activity所在的进程中进行启动；
Step6：调用ApplicationThread.scheduleLaunchActivity通知相应的进程ActivityThread执行启动Activity的操作；
Step7：ApplicationThread把这个启动Activity的操作转发给ActivityThread，ActivityThread通过ClassLoader导入相应的Activity类，然后把它启动起来。

3、 Activity和View的关系

主要涉及的对象：

Window 类是一个抽象类，提供了绘制窗口的一组通用API。
PhoneWindow类继承于Window类，是Window类的具体实现，即我们可以通过该类具体去绘制窗口。该类内部包含了一个DecorView对象，并对其进行一定的包装，将它作为根View，并提供一组通用的窗口操作接口。
DecorView类是PhoneWindow类的内部类。该类是一个FrameLayout的子类（联系<Merge>标签），并且是PhoneWindow的子类，该类就是对普通的FrameLayout进行功能的扩展，更确切点可以说是修饰(Decor的英文全称是Decoration)，比如说添加TitleBar(标题栏)，以及TitleBar上的滚动条等。它是所有应用窗口的根View！
WindowManager是Android中一个重要的服务(Service)。WindowManager Service 是全局的，是唯一的。它将用户的操作，翻译成为指令，发送给呈现在界面上的各个Window。
ViewRoot是GUI管理系统与GUI呈现系统之间的桥梁，根据ViewRoot的定义，我们发现它并不是一个View类型，而是一个Handler，连接的是PhoneWindow跟WindowManagerService。
- 它的主要作用如下：（WindowManager读取android系统里所有事件通过这个ViewRoot分发到各个activity）
  - A. 向DecorView分发收到的用户发起的event事件，如按键，触屏，轨迹球等事件；
  - B. 与WindowManager Service交互，完成整个Activity的GUI的绘制。

Activity创建View的流程如下：

　　Activity创建后，系统会调用其attach方法，将其添加到ActivityThread当中，在attach方法中创建了一个PhoneWindow对象实例，要注意PhoneWindow对象创建时并没有创建Decor对象。当我们调用Acitivity的setContentView()时，实际上是调用的PhoneWindow对象的setContentView方法，这时会检查 DecorView是否存在，如果不存在则(才)创建DecorView对象，将其设置为所有窗口的根View，然后把自己的View添加到DecorView中。

　　Android中的视图都是通过Window来呈现的，然后通过WindowManager来管理View。

　　在建立PhoneWindow的过程中，会得到WindowManager实例，系统会调用WindowManger的addView(decor,l)，把DecorView加入到WindowManagerProxy的mViews（保存View的数组）中，即Activity会将DecorView注册到WindowManager中。

　　WindowManger在保存好这个DecorView对象的同时，也会新创建一个ViewRoot对象用来沟通WindowManager。这样，当用户触碰屏幕或键盘的时候，WindowManager就会通知到；而当控件有一些请求产生，也会经由ViewParent送回到Window Manager中，从而完成整个通信流程。Activity是Android应用程序的载体，允许用户在其上创建一个用户界面，并提供用户处理事件的API，如 onKeyEvent，onTouchEvent等，并维护应用程序的生命周期。Activity也可以理解成Android应用程序的入口，系统服务ActivityManager负责维护Activity的实例对象，并根据运行状态维护其状态信息。

4、 Activity编程

　　Activity之间通过Intent进行通信，android应用中每一个Activity都必须要在AndroidManifest.xml配置文件中声明，否则系统将不识别也不执行该Activity。Activity的加载模式（launchMode）受启动Activity的Intent对象中设置的Flag和manifest文件中Activity的元素的特性值交互控制。

l launchMode：

Standard：标准模式，调用一次startActivity()就产生一个实例
singleTop：Task顶单例模式，即若已有一个实例在栈顶，则（才）不产生新的实例，转而调用onNewIntent()。
singleTask：Task内单例模式，栈内可以有其他Activity实例
singleInstance：全局单单例模式，独占Task

大致生命周期：onCreate >>onStart>> onResume>>onPause>> onStop>> onDestroy

SingleTask时有 onStop>> (onNewIntent>>) onRestart>>onStart>>onResume

横竖屏切换：onSaveInstance->onPause->onStop->onDestory->onCreate->onStart->onRestoreInstance->onResume

launchMode为singleTask的时候，通过Intent启到一个Activity,如果系统已经存在一个实例，系统就会将请求发送到这个实例上，但这个时候，系统就不会再调用通常情况下我们处理请求数据的onCreate方法，而是调用onNewIntent方法，类似onCreate用法，需要更新intent：调用setIntent(intent)

l 打开Activity：

1、startActivity( ) ：仅仅是跳转到目标页面，若是想跳回当前页面，则必须再使用一次startActivity( )。

2、startActivityForResult( ) ：可以一次性完成这项任务，当程序执行到这段代码的时候，假若从A跳转到下一个B，而当这个B调用了finish()方法以后，程序会自动跳转回A，并调用A中的onActivityResult( )方法。

A: 调用 startActivityForResult(intent, RequestCode); //此处的RequestCode的值要大于0；

并重写 onActivityResult(int requestCode, int resultCode, Intent data)

B: setResult(RESULT_OK, intent); // RESULT_OK为resultCode

finish();

将一个activity设置成窗口模式： 将activity的属性android:theme="@style/Theme.Dialog"
退出Activity：

退出单一Activity：finish()
退出多Activity：

　　　　1) 记录打开的Activity：自定义一个单例模式的Activity栈来管理所有Activity，在需要退出时，逐个关闭即可。
　　　　2) 发送特定广播：在需要结束应用时，发送一个特定的广播，每个Activity收到广播后，关闭即可。
　　　　3) 递归退出：都使用startActivityForResult，然后自己加标志，在onActivityResult中处理，递归关闭。
　　　　4) 抛异常强制退出：通过抛异常，使程序Force Close。问题是如何使程序结束而不弹出Force Close窗口
　　　　5) 通用方法：Dalvik VM的本地方法
　　　　　　　　android.os.Process.killProcess(android.os.Process.myPid()) //获取PID
　　　　　　　　System.exit(0); //常规Java、c#的标准退出法，返回值为0代表正常退出

　　另：在Intent中加入标志Intent.FLAG_ACTIVITY_CLEAR_TOP，这打开时将会清除该进程空间的所有Activity。

横竖屏切换时Activity的生命周期：

　　　　1) 不设置Activity的configChanges 属性时，切屏会重新调用各个生命周期（见上），切横屏会执行一次，竖屏两次。

　　　　2) 设置Activity的android:configChanges=”orientation”时，横竖屏切换都只执行一次

　　　　3) 设置Activity的android:configChanges=”orientation|keyboardHidden”时，屏幕切换不会重新调用个各生命周期，只会执行：onConfigurationChange()。

在onCreate方法中 Bundle savedInstanceSate这个参数作用：

　　在实际应用中，当一个Activity结束前，如果需要保存状态，就在onsaveInstanceState()中，将状态数据以key-value的形式放入到savedInstanceState()中。这样，当一个Activity被创建时，就能从onCreate的参数savedInsanceState中获得状态数据。

　　onsaveInstanceState ()触发条件（五个）：按下HOME键时；长按HOME键选择运行其他程序时；关闭屏幕显示时；启动一个新的Activity时；屏幕方向切换时。（当系统“未经你许可”时销毁了你的activity时）

　　与之配套的有onRestoreInstanceState()方法，但不一定成对出现。这个方法被调用的前提是activity“确实”被系统销毁了。它的bundle参数也会传递到onCreate方法中，你也可以选择在onCreate方法中做数据还原。

5、Activity 和Fragment

传递参数：

　　　　1) Fragment中通过getActivity()获得Activity对象，调用Activity中的公有方法((RootActivity)getActivity()).fun();

　　　　2) Activity实现一个接口，Fragment在onAttach()方法中，将该Activity转化为该接口，在需要调用的时候回调。

　　　　3) Activity在切换Fragment的时候，通过setArguments向Fragment传递参数，Fragment通过getArguments()取值。

通过FragmentManager管理：我们创建Fragment和销毁Fragment的时候，可以通过栈的方式：

　　　　1) FragmentTransaction的add()方法，添加一个Fragment；

　　　　2) FragmentTransaction的popBackStack()弹出

public class MainActivity extends ActionBarActivity implements FragmentCallBack{

    private Button btn;

    private MyFragment1 fragment1;

    private MyFragment2 fragment2;

    private FragmentManager fragmentManager;

    private Fragment currentFragment;

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        fragmentManager = getSupportFragmentManager();

        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

        fragmentTransaction.setCustomAnimations(android.R.anim.fade_in, android.R.anim.fade_out);

        fragment1 = new MyFragment1();

        Bundle data = new Bundle();

        data.putString("TEXT", "这是Activiy通过Bundle传递过来的值");

        fragment1.setArguments(data);//通过Bundle向Fragment中传递值，在onCreateView中getArguments()

        fragmentTransaction.add(R.id.rl_container, fragment1);//将fragment1设置到Activity的布局rl_container上

        fragmentTransaction.addToBackStack(null);

        fragmentTransaction.commitAllowingStateLoss();

        currentFragment = fragment1;

        btn = (Button)findViewById(R.id.btn);

        btn.setOnClickListener(new OnClickListener() {

            @Override

            public void onClick(View v) {

                if(currentFragment instanceof MyFragment1){

                    if(null == fragment2) //可以避免切换的时候重复创建

                        fragment2 = new MyFragment2();

                        ……//设值，同fragment1

　　　　　　     fragmentTransaction.replace(R.id.fl, fragment2); // 替代fl的控件

　　　　　　     fragmentTransaction.commit();

                       currentFragment = fragment2;

                }else{  //当前是fragment2，因此，只需要将fragment2出栈即可变成fragment1

                    fragmentManager.popBackStack();

                    currentFragment = fragment1;

                }

            }

        });

    }

    @Override

    public void callbackFun1(Bundle arg) {…… }

}

数据存储和恢复：

　　和Activity类似，可以用Bundle对象保存Fragment的状态，当重建activity时，可以用于恢复Fragment的状态。存储是利用onSaveInstanceState()回调函数，恢复时是在onCreate,onCreateView或onActivityCreated里。

Back Stack：

　　Activity停止时，时存在一个由系统维护的backsatck中；但是当Fragment停止(被remove)时，需要程序员显示调用addToBackStack()，并且Fragment是保存在一个由宿主activity掌管的backstack中。

　　拥有Fragment的Activity的生命周期直接影响了其中的Fragment的生命周期，这样，针对Activity的每一个生命周期的回调都会有一个类似的针对Fragment的回调。例如，当Activity收到onPause()回调时，在Activity中每个Fragment都会收到onPause()回调。但是，Fragment有几个额外的生命周期回调方法，用来处理跟Activity的交互，以便执行诸如创建和销毁Fragment的UI的动作。

这些额外的回调方法如下：

onAttach()：　　　　当Fragment已经跟Activity关联上的时候调用。Activity会作为该方法的参数来传递。
onCreateView()：　　创建跟Fragment关联的视图层时调用
onActivityCreated()：当onCreate()方法执行完之后调用
onDestroyView()：当关联的视图层正在被删除时调用
onDetach()：　　当从Activity中解除Fragment的关联时调用

　　如下图中说明的那样，Fragment的生命周期流收到持有这些Fragment的Activity的影响，在这个图中，你能看到每个连续的Activity状态决定了Fragment的那个回调方法可以被调用。

　　例如，当Activity已经收到了onCreate()的回调之后，在Activity中的Fragment就不会再接收onActivityCreated()以上的回调了。一旦Activity到达了被恢复的状态，你就可以自由的给这个Activity添加和删除Fragment了，只有Activity在恢复态时，Fragment的生命周期才能独立的改变。但是，当Activity离开恢复态时，Fragment会再次被推进Activity的生命周期中。

6、ViewPager+Fragment实现滑动标签页

1）主布局文件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >

    <include layout="@layout/activity_main_top_tab" />

    <android.support.v4.view.ViewPager

        android:id="@+id/id_page_vp"

        android:layout_width="match_parent"

        android:layout_height="0dp"

        android:layout_weight="1" >

    </android.support.v4.view.ViewPager>

</LinearLayout>

2）加载代码注意：需要引入android-support-v4.jar(正常情况系统会自动引入)

public class MainActivity extends FragmentActivity {

       private ViewPager mPager;

       private ArrayList<Fragment> fragmentList;

       private ImageView image;

       private TextView view1, view2, view3;

       private int currIndex;  // 当前页卡编号

       private int bmpW;    // 横线图片宽度

       private int offset;     // 图片移动的偏移量

       protected void onCreate(Bundle savedInstanceState) {

              super.onCreate(savedInstanceState);

              setContentView(R.layout.activity_main);

              InitTextView();

              InitImage();

              InitViewPager();

       }

       public void InitTextView(){

              view1 = (TextView)findViewById(R.id.tv_guid1);

              view2 = (TextView)findViewById(R.id.tv_guid2);

              view3 = (TextView)findViewById(R.id.tv_guid3);

              view1.setOnClickListener(new txListener(0));

              view2.setOnClickListener(new txListener(1));

              view3.setOnClickListener(new txListener(2));

       }

       public class txListener implements View.OnClickListener{

              private int index=0;

              public txListener(int i) {       index =i; }

              @Override

              public void onClick(View v) {  mPager.setCurrentItem(index);     }

       }

       public void InitImage(){

              image = (ImageView)findViewById(R.id.cursor);

              bmpW = BitmapFactory.decodeResource(getResources(), R.drawable.cursor).getWidth();

              DisplayMetrics dm = new DisplayMetrics();

              getWindowManager().getDefaultDisplay().getMetrics(dm);

              int screenW = dm.widthPixels;

              offset = (screenW/3 - bmpW)/2;

              //imgageview设置平移，使下划线平移到初始位置（平移一个offset）

              Matrix matrix = new Matrix();

              matrix.postTranslate(offset, 0);

              image.setImageMatrix(matrix);

       }

       public void InitViewPager(){

              mPager = (ViewPager)findViewById(R.id. id_page_vp);

              fragmentList = new ArrayList<Fragment>();

              Fragment btFragment= new ButtonFragment();

              Fragment secondFragment = TestFragment.newInstance("this is second fragment");

              Fragment thirdFragment = TestFragment.newInstance("this is third fragment");

              fragmentList.add(btFragment);

              fragmentList.add(secondFragment);

              fragmentList.add(thirdFragment);

              //给ViewPager设置适配器

              mPager.setAdapter(new MyFragmentPagerAdapter(getSupportFragmentManager(), fragmentList));

              mPager.setCurrentItem(0);//设置当前显示标签页为第一页

              mPager.setOnPageChangeListener(new MyOnPageChangeListener());//页面变化时的监听器

       }

       public class MyOnPageChangeListener implements OnPageChangeListener{

              private int one = offset *2 +bmpW;//两个相邻页面的偏移量

              @Override

              public void onPageScrolled(int arg0, float arg1, int arg2) {  }

              @Override

              public void onPageScrollStateChanged(int arg0) {  }

              @Override

              public void onPageSelected(int arg0) {

                     Animation animation = new TranslateAnimation(currIndex*one,arg0*one,0,0);//平移动画

                     currIndex = arg0;

                     animation.setFillAfter(true);     // 动画终止时停留在最后一帧，不然会回到没有执行前的状态

                     animation.setDuration(200);     // 动画持续时间0.2秒

                     image.startAnimation(animation);// 是用ImageView来显示动画的

                     int i = currIndex + 1;

                     Toast.makeText(MainActivity.this, "您选择了第"+i+"个页卡", Toast.LENGTH_SHORT).show();

              }

       }

}

ViewPager应该和Fragment一起使用时，此时ViewPager的适配器是FragmentPagerAdapter，当你实现一个FragmentPagerAdapter，你必须至少覆盖以下方法：
- getCount()
- getItem()
如果ViewPager没有和Fragment一起，ViewPager的适配器是PagerAdapter，它是基类提供适配器来填充页面ViewPager内部，当你实现一个PagerAdapter,你必须至少覆盖以下方法：
- instantiateItem(ViewGroup, int)
- destroyItem(ViewGroup, int, Object)
- getCount()
- isViewFromObject(View, Object)

3）Adapter

public class MyFragmentPagerAdapter extends FragmentPagerAdapter{

       ArrayList<Fragment> list;

       public MyFragmentPagerAdapter(FragmentManager fm,ArrayList<Fragment> list) {

              super(fm);

              this.list = list;

       }

       @Override

       public int getCount() {

              return list.size();

       }

       @Override

       public Fragment getItem(int arg0) {

              return list.get(arg0);

       }

}

　　ViewPager默认会缓存三页数据，即：Viewpager每加载一个Fragment，都会预先加载此Fragment左侧或右侧的Fragment。而如果每个fragment都需要去加载数据，或从本地加载，或从网络加载，那么在这个activity刚创建的时候就变成需要初始化大量资源，浪费用户流量不止，还造成卡顿。那么，能不能做到当切换到这个fragment的时候，它才去初始化呢？答案就在Fragment里的setUserVisibleHint这个方法里。　　

　　该方法用于告诉系统，这个Fragment的UI是否是可见的。所以我们只需要继承Fragment并重写该方法，即可实现在fragment可见时才进行数据加载操作，即Fragment的懒加载。

/** 基类Fragment  */

public abstract class BaseFragment extends Fragment {

    protected View mRootView;

    public Context mContext;

    protected boolean isVisible;

    private boolean isPrepared;

    private boolean isFirst = true;

    public BaseFragment() { /* Required empty public constructor*/  }

    @Override

    public void setUserVisibleHint(boolean isVisibleToUser) {

        super.setUserVisibleHint(isVisibleToUser);

        if (getUserVisibleHint()) {

            isVisible = true;

            lazyLoad();

        } else {

            isVisible = false;

            onInvisible();

        }

    }

    @Override

    public void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        mContext = getActivity();

        setHasOptionsMenu(true);

    }

    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        if (mRootView == null) {

            mRootView = initView();

        }

        return mRootView;

    }

    @Override

    public void onActivityCreated(@Nullable Bundle savedInstanceState) {

        super.onActivityCreated(savedInstanceState);

        isPrepared = true;

        lazyLoad();

    }

protected void lazyLoad() {

　　//①    isPrepared参数在系统调用onActivityCreated时设置为true,这时onCreateView方法已调用完毕(一般我们在这方法里执行findviewbyid等方法),确保 initData()方法不会报空指针异常。

　　//②    isVisible参数在fragment可见时通过系统回调setUserVisibileHint方法设置为true,不可见时为false，这是fragment实现懒加载的关键。

　　//③    isFirst确保ViewPager来回切换时BaseFragment的initData方法不会被重复调用，initData在该Fragment的整个生命周期只调用一次,第一次调用initData()方法后马上执行 isFirst = false。

        if (!isPrepared || !isVisible || !isFirst)

            return;

        initData();

        isFirst = false;

    }

    protected void onInvisible() { /* do sth*/  }

    public abstract View initView();

    public abstract void initData();

}

　　为了可复用，这里我新建了个BaseFragment，在basefragment，我增加了三个方法：一个是onVisiable，即fragment被设置为可见时调用，一个是onInvisible，即fragment被设置为不可见时调用。另外再写了一个lazyLoad的抽象方法，该方法在onVisible里面调用。　　

【附】

1. Activity怎么获取Service中的信息？
　　1) 使用Intent的putExtras传参数过去；
　　2) 使用SharePreference；
　　3) 使用全局变量Application；
　　4) AIDL；
　　5) 如果是在同一个进程，可以通过Handler发送message；
　　6) 广播发送，效率低点；
　　7) bind service，获得service对象，访问其公共方法。
2. Activity和Service如何通过Handler通信？
　　1) 在Activity中将Handler声明为Static，直接在Service中通过类方法调用：XActivity.myStaticHandler.sendMessage(…);
　　2) 在service中定义一个Activity类本身的静态对象，在Activity中定义一个Public方法返回handler对象。
　　3) Service通过onBind方法返回一个Messager对象给Activity
3. ClassLoader：
　　将制定的class类对象加载到内存中；一个运行的APP至少有两个Classloader。
　　系统启动时创建的BootClassLoader和应用启动时创建的PathClassLoader
4. Android string.xml 通配符 %$用法
　　<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string>
　　在这个例子中，这个格式化的字符串有2个参数
　　属性值举例说明
　　　　%n$ms：输出字符串，n代表是第几个参数，设置m的值可以在输出之前放置空格
　　　　%n$md：输出整数，设置m的值可以在输出之前放置空格，也可以设为0m,在输出之前放置m个0
　　　　%n$mf：输出浮点数，n代表是第几个参数，设置m的值可以控制小数位数，如m=2.2时，输出为00.00
　　在程序中按照下面的方法来根据参数来格式化字符串：
　　　　Resources res = getResources();
　　　　String text = String.format(res.getString(R.string.welcome_messages), username, mailCount);

巴特西

1.1 Activity

最新文章

热门文章