Android studio四大组件(一)(Activity)

最新推荐文章于 2024-10-13 11:40:40 发布

码农小K

最新推荐文章于 2024-10-13 11:40:40 发布

阅读量1w

点赞数 6

分类专栏： Android开发文章标签： android开发

Android开发专栏收录该内容

4 篇文章 2 订阅

订阅专栏

Android中的四大组件(Activity、Service、BroadcastReceiver、Content Provider)

总体来说：

Activity：Activity是Android程序与用户交互的窗口，是Android构造块中最基本的一种，它需要为保持各界面的状态，做很多持久化的事情，妥善管理生命周期以及一些跳转逻辑；
service：后台服务于Activity，封装有一个完整的功能逻辑实现，接受上层指令，完成相关的事物，定义好需要接受的Intent提供同步和异步的接口；
BroadCast Receiver：接受一种或者多种Intent作触发事件，接受相关消息，做一些简单处理，转换成一条Notification，统一了Android的事件广播模型；
Content Provider：是Android提供的第三方应用数据的访问方案，可以派生Content Provider类，对外提供数据，可以像数据库一样进行选择排序，屏蔽内部数据的存储细节，向外提供统一的借口模型，大大简化上层应用，对数据的整合提供了更方便的途径

一、Activity

1 . 简单介绍：Activity是一个应用程序组件，提供用户与程序交互的界面。
2 . Activity的创建于使用
基本步骤：
- 继承Activity类；
- 重写方法；
- 设置布局；
- 再AndroidManifest文件中注册Activity
配置文件的activity标签中有”< intent-filter>”的表示入口，是首先启动的页面。
这里写图片描述
3 . Activity的生命周期
- onCreate();创建
- onStart();运行
- onResume();获取焦点
- onPause();失去焦点
- onStop();暂停
- onDestroy();销毁
- onRestart();重启

这里细谈四种状态：
- 活动状态(Active/Running)：Activity处于界面最顶端，获取焦点；
- 暂停状态(Paused)：Activity失去焦点，但对用户可见；
- 停止状态(Stopped):Activity被完全遮挡，但保留所有状态和成员信息；
- 非活动状态(Killed):Activity被停止

例子如下：
(1). 从创建到销毁的生命周期：
onCreate()->onStart()->onResume()->onPause()->onStop()->onDestroy()
(2). 从启动到后台再到前台：
onCreate()->onStart()->onResume()->onPause()->onStop()->onRestart()->onStart()->onResume()
(3). 从启动到失去焦点再到获取焦点：
onCreate()->onStart()->onResume()->onPause()->onResume()

进一步以实例说明：(因为覆盖不好体现，我就先画图再截图了)
这里写图片描述

4 . 在多个Activity之间传递参数
(1). 传递简单数据：通过 Intent中的putExtra()和getStringExtra()。

MainActivity.Java:

findViewById(R.id.btn_StaActy).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Intent i = new Intent(MainActivity.this, TheAty.class);
        i.putExtra("data", "Hello FanFF");// 传递参数
        startActivity(i);
    }
});

AnotherActivity.java:

Intent i = getIntent();
tv = (TextView) findViewById(R.id.tV);
tv.setText(i.getStringExtra("data"));// 获取参数

(2). 传递数据包 Bundle：可以先将Bundle进行封装，然后通过Intent的putExtras(Bundle)和getExtras()方法进行封装和解析；也可以通过Intent的putExtra(Key, Bundle)和getBundleExtra(Key)的方法进行封装和解析。

MainActivity.java:

// 使用Bundle进行数据包的封装,Bundle里也可以嵌套Bundle
Intent i = new Intent(MainActivity.this, TheAty.class);
Bundle b = new Bundle();
b.putString("name", "FanFF");
b.putInt("age", 1);
i.putExtras(b);
/*
// 第二种封装Bundle的方式
i.putExtra(“data”, b);
*/

AnotherActivity.java:

// 使用Bundle进行数据包接收数据
Intent i = getIntent();
tv1 = (TextView) findViewById(R.id.tV1);
Bundle data = i.getExtras();
// 第二种获取Bundle的方式
Bundle data = i.getBundleExtra(“data”);
*/
// 如果关键字不存在，则可以通过getString(String key, String defaultValue)设置默认值
tv1.setText(String.format("name=%s,age=%d,sex=%s",
 data.getString("name"),
 data.getInt("age"),
 data.getString("sex", "男")));

(3). 传递值对象(类对象)
方法一：新建类，并实现Serializable接口；Intent的putExtra(Key, Class)进行封装和getSerializableExtra(Key)进行解析。

public class User implements Serializable {
    private String name;
    private int age;

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }
set|get方法
}

MainActivity.java:

Intent i = new Intent(MainActivity.this, TheAty.class);
i.putExtra("user", new User("FanFF", 1));

TheAty.java:

Intent i = getIntent();
User user = (User) i.getSerializableExtra("user");
tv1.setText(String.format("name=%s,age=%d",user.getName(), user.getAge()));

方法二：新建类，并实现Parcelable接口，需要自己完成序列化，通过实现writeToParce方法和创建Creator。

User.java:

public class User implements Parcelable{
    private String name;
    private int age;

    public User(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }

    @Override
    public int describeContents() {
        return 0;
    }
// 将数据写入到Parcel分配的内存空间中。该函数的写入顺序决定了读取的顺序
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(getName());
        dest.writeInt(getAge());
    }

    public static final Creator<User> CREATOR = new Creator<User>() {
        @Override
        public User createFromParcel(Parcel source) {
            // 如果数据很多，则可以利用readBundle()进行封装和读取
            return new User(source.readString(),source.readInt());
        }
        @Override
        public User[] newArray(int size) {
            return new User[size];
        }
    };
}

MainActivity.java：

Intent i = new Intent(MainActivity.this, TheAty.class);
i.putExtra("user", new User("FanFF", 1));
startActivity(i);

TheAty.java:

Intent i = getIntent();
User user = i.getParcelableExtra("user");
tv1.setText(String.format("name=%s,age=%d",user.getName(), user.getAge()));

关于：Parcelable中describeContents()方法。
这个方法返回的值通常为0。这个方法到目前为止返回其他唯一有效的值就是CONTENTS_FILE_DESCRIPTOR(0x01)，指明这个Parcel的内容包含文件描述符。DropBoxManager、ParcelFileDescriptor和InputChannel等用到这个值。
在类UNIX系统中，一切皆是文件，文件描述符就是操作文件的数据结构，获取到文件描述符可以完成所有文件相关的操作。因为文件描述符的作用如此之大，为了防止leak，需要禁止在Bundle传输Parcel时包含文件描述符，所以通过Parcel中包含ParcelFileDescriptor等在Bundle中使用时会抛出IllegalArgumentException。所以，这个值是在系统内部进行安全保护所使用的，其他情况下填0即可。

对比：

实现Serializable接口效率较低，自动提供了序列化机制，实现简单；Android平台下有Parcelable接口，效率较高，但是没有提供自动序列化机制，需要通过writeToParcel()方法纯手工地去实现序列化。
Serialize是Java语言自带的序列化功能，而Parcel是android特有的。Parcel类被设计出来，其定位就是轻量级的高效的对象序列化和反序列化机制。 Serializable在序列化的时候会产生大量的临时变量，而Parcel的序列化和反序列化的读写全是在内存中进行，所以效率比Serialize序列化中使用外部存储器会高很多。

(4). 获取Activity的返回参数：前一个Activity跳转到后一个Activity后，又返回并获取了后一个Activity的参数。前一个Activity使用startActivityForResult而不是startActivity,并实现onActivityResult，以获取后一个Activity返回的参数；后一个Activity通过setResult方法需要回传的参数。

MainActivity.java

`````
onCreate(){
findViewById(R.id.btn_StaActy).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Intent i = new Intent(MainActivity.this, TheAty.class);
        // 第一个对象是Intent对象
       // 第二个参数是请求码的一个标识
        startActivityForResult(i, 0);
    }
});
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
      // 通过startActivityForresult跳转，接收返回数据的方法
    // requestCode--请求的标志，该标识用来辨别返回的请求的页面
    // resultCode--第二个页面返回的标识，该标识用来辨别返回的页面的结果
    // data--第二个页面回传的数据
    super.onActivityResult(requestCode, resultCode, data);
    tV = (TextView) findViewById(R.id.tv);
    // 可以根据结果码或者请求码来判断结果的意义，而且可以获取返回的参数
    tV.setText("TheAty返回的参数："+data.getStringExtra("data"));
}

TheAty.java:

findViewById(R.id.sendback).setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Intent i = new Intent();
        i.putExtra("data", editText.getText().toString());
        //ResultCode表明结果状态，一般1表示成功
        setResult(1, i);
        finish();
    }
});

5 . Activity的启动模式
在Mainfest.xml中配置launchMode
这里写图片描述
(1). standard：标准的启动模式(默认启动模式)
Activity跳转机制：同一个Activity会在同一个任务栈里(即TaskID相同)，但是每次启动时就会创建一次不同的Activity实例，依次进栈。每次返回时，栈顶的任务实例就回弹出任务栈。

tv = (TextView) findViewById(R.id.textView1);
tv.setText(String.format("任务ID:%d\n当前的Activity实例:\n%s",getTaskId(), toString()));
btn = (Button) findViewById(R.id.btnStartSelf);
// 同一个任务栈里面，但是不同任务实例。返回时，弹出栈顶实例(这是Activity的跳转机制)
btn.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        startActivity(new Intent(MainActivity.this, MainActivity.class));
    }
});

这里写图片描述
因为栈顶的Activity@527666f8已经被移除了，所以看到的是@527347a0
如下是借用的别人的图

(2). SingleTop
standard和singleTop模式对比：
这两种加载模式下，同一个task栈中可以存在一个activity的多个实例, 并且可以位于activity栈的任意位置。
例子如下：
假设目标task的activity栈为: A->B->C->D(栈底->栈顶)
在程序中调用startActivity(D)
如果D是standard模式，则activity栈变为：
A->B->C->D->D, 也就是会重新创建一个D实例
如果D是singleTop模式，则activity栈变为：
A->B->C->D，不会创建D实例。即如果D在目标task 的activity栈的栈顶，则不会创建新的实例，而是调用D的onNewIntent()方法，反之如果D不在目标task 的activity栈的栈顶，则会重新创建一个D实例
这里写图片描述

注：写代码时发现，根据栈顶判断是否需要新建Activity实例的前提是该Activity是最先启动的。
例如：如果首先启动的是MainActivity，则若此时MainActivity处于栈顶，则跳转时不会新建MainActivity的实例；如果首先启动的是AnotherActivity，则若此时MainActivity处于栈顶，则跳转时仍然会新建MainActivity的实例。

(3). SingleTask
如果A调用startActivity(B)启动B实例，则A和B位于同一个task中，且都只有一个实例存在于task栈中。
(4). singleInstance
如果A调用startActivity(B)启动B实例，则系统会自动给intent添加一个属性LAG_ACTIVITY_NEW_TASK，将B实例放入到一个新的task中，也就是说A实例所在的task中有且只有一个A实例，不能存在其他实例。

简单对比：
- singleTask和singleInstance
相同点：这两种加载模式下，同一个task栈中只会存在一个activity的实例，如果通过startActivity()启动，则调用onNewIntent()方法，而不是创建一个新的实例。这两种模式下，activity实例均位于activity栈的栈底。
- 区别：假设一个Activity的实例A 采用如下两种加载模式：
singleTask:
如果A调用startActivity(B)启动B实例，则A和B位于同一个task中，且都只有一个实例存在于task栈中。
singleInstance:
如果A调用startActivity(B)启动B实例，则系统会自动给intent添加一个属性LAG_ACTIVITY_NEW_TASK，将B实例放入到一个新的task中，也就是说A实例所在的task中有且只有一个A实例，不能存在其他实例。

二、关于配置文件里的一些标签和属性

下面借用的别人的图来谈谈
这里写图片描述
< application android:allowBackup=”true” >
是否允许备份应用的数据，默认是true,当备份数据的时候，它的数据会被备份下来。如果设为false，那么绝对不会备份应用的数据，即使是备份整个系统。

Activity(活动)组件：name是包名.类名或“.类名”(这个.会直接连接package)
这里写图片描述

intent-filter属性，内设action,data与category三种标签
A. action：只有android:name这个属性。常见的android:name值android.intent.action.MAIN
表明此activity是作为应用程序的入口。
B.category：只有android:name属性。常见的android:name值为android.intent.category.LAUNCHER。决定应用程序是否显示在程序列表里。
C .Data略。