Android Activity从入门到精通

来日可期Dream

已于 2024-07-22 12:49:21 修改

阅读量673

点赞数 28

分类专栏： Android 文章标签： android studio

于 2024-07-15 10:59:09 首次发布

本文链接：https://blog.csdn.net/Dream__Y/article/details/140432915

版权

Android 专栏收录该内容

2 篇文章 1 订阅

订阅专栏

新建的安卓工程中，存在三个文件：

MainActivity.java [src/main/java]
activity_main.xml [res/layout]
AndroidManifest.xml [src/main]

其中，java文件用于控制界面逻辑，layout文件用于预设UI摆放，清单文件（AndroidManifest）用于通知系统app包含哪些组件及对应权限。

Layout 界面布局

在新建项目中，as会默认给出ConstrantLayout（如activity_main.xml）

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <!-- 省略默认的TextView -->

</androidx.constraintlayout.widget.ConstraintLayout>

为更好的理解项目，将ConstraintLayout替换为LinearLayout，将标签的开头和结尾换成LinearLayout即可：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <!-- 省略默认的TextView -->

</LinearLayout>

Java 控制页面

layout文件设计的是页面的初始布局，用于安排界面上的UI组件与排放方式。而在MainActivity.java文件中，onCreate()方法里的R.layout.activity_main指的就是activity_main.xml文件。

当layout文件中若存在一个TextView（用于显示文字），我们想在MainActivity中控制它，则可以先删除其TextView中的ConstraintLayout用的属性，然后添加一个Id（这个Id是整个layout文件中独一无二的，设id为tv1），如下所示：

<TextView
// 添加id
    android:id="@+id/tv1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!" />

目前，TextView就有了[身份Id]，在activity中可以找到它，可以用findViewById()，也可以对其进行操作。

// 找到id对应的TextView
TextView tv1 = findViewById(R.id.tv1);
// 对tv1设置内容
tv1.setText("Hello World!");

AndroidManifest.xml 清单文件

简称为[manifest文件]，用于告知系统app中有哪些activity以及对应的权限，所以若要新建activity则需要在清单文件中注册，如例：

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    // 注册activity
    <activity 
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

从清单文件中可以看出，activity是属于application的，即application就是我们的应用。

同样，application标签中也指定了各种元素，如应用的图标、名字、主题等等。

MainActivity是应用启动的第一个activity，设置了action和category属性。

android.intent.action.MAIN决定应用程序最先启动的Activity
android.intent.action.LAUNCHER用于表示可以手机“桌面”上看到的应用图标

以上两个标签用于决定该activity是点击图标时[第一个启动的界面]

以上，可以了解到activity通常需要一个java文件、layout文件，并且要在清单文件中注册。

与Web开发类比，layout文件相当于html、Java相当于js、style样式相当于css。

Activity的生命周期

暂时无法在飞书文档外展示此内容

OnCreate()和OnStart()的区别：

OnCreate()在系统首次创建Activity时就会触发，进入“已创建”状态
当Activity进入“已开始”状态时，OnStart()调用会使Activity对用户可见，其方法会非常快速完成，部位一直处于“已开始”状态，一旦调用结束，即刻进入“已恢复”状态，系统调用OnResume()方法

OnPause()和OnStop()的区别：

OnPause()执行时不一定需要足够的时间保存操作。因此不能用于保存应用/用户数据、网络调用、执行数据库事务。（因为在该方法完成前，上述工作可能无法形成）

在进入“已停止”状态时，系统将调用OnStop()（例如新启动的Activity覆盖整个屏幕）

OnStop()方法中，应用释放或调用对用户不见时的无用资源（例如暂停动画效果）。使用OnStop()和非OnPause()可确保与界面相关的工作继续进行，即使用户在多窗口模式下查看Activity也可以。因此可以使用OnStop()执行CPU相对密集的关闭操作。

启动方式

在一个APP内通常会包含有多个界面(Activity)，那么不同的界面切换则需要有不同的Activity启动的方式。

通常Activity之间的跳转需要Intent类，将信息放到Intent对象中，再执行。如：启动RelationLayoutGuideAct

startActivity(new Intent(getApplicationContext(), RelativeLayoutGuideAct.class));

其中startActivity属于Context类。

携带参数启动

每当跳转到另一个页面时，往往会希望携带一些参数，因此，可以借助上述方式实现。

基本类型/String

Intent intent = new Intent(getApplicationContext(), SendParamsDemo.class);
// SendParamsDemo.K_INT 作为Key， 100 为存放值
intent.putExtra(SendParamsDemo.K_INT, 100);
intent.putExtra(SendParamsDemo.K_BOOL, true);
intent.putExtra(SendParamsDemo.K_STR, "Input string");
startActivity(intent);

intent.putExtra()方法可以传入参数，接受String数值作为Key，后面为具体参数。其中，作为Key的SendParamasDemo完整代码如下：

public class SendParamsDemo extends AbsActivity {

    public static final String K_INT = "k_int";
    public static final String K_BOOL = "k_bool";
    public static final String K_STR = "k_str";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        gotInput();
    }

    private void gotInput() {
        Intent intent = getIntent();
        if (intent != null) {
            int i = intent.getIntExtra(K_INT, -1);
            boolean b = intent.getBooleanExtra(K_BOOL, false);
            String str = intent.getStringExtra(K_STR);
            Log.d(TAG, "gotInput: i:" + i + ", b: " + b + ", str: " + str);
        } else {
            Log.d(TAG, "gotInput: input null.");
        }
    }
}

执行结果为：

 gotInput: i:100, b: true, str: Input string

Serializable

Serializable本身是一个接口，在实现之后即可被Intent携带，如：

// 实现Serializable接口
public class DataTest implements Serializable { // 实现接口
}
----
// 将对象传到Inten中
Intent intent = new Intent(getApplicationContext(), RecyclerViewDemo2Act.class);
DataTest out = new DataTest("input time", 233, 666, 999);
Log.d(TAG, "startInputData: sending object: " + out);
intent.putExtra(RecyclerViewDemo2Act.K_INPUT_DATA, out);
startActivity(intent);
-----
// 启动的Activity传入Intent并取出对象
Intent intent = getIntent();
if (intent != null) {
    DataTest d = (DataTest) intent.getSerializableExtra(K_INPUT_DATA);
    // 取出了对象，拿去显示
}
-----
// 打印出发送和接受到的对象：
// startInputData: sending object: com.rustfisher.tutorial2020.recycler.data.DataTest@fb43df5
// getInputData: input data object: com.rustfisher.tutorial2020.recycler.data.DataTest@a588b5c

因为Serializable接口不含任何方法，所以实现了这个接口的类，系统会自动将其序列化。

Parcelable

Parcelable是Android sdk提供的一个接口，用于实现数据序列化。与Java中的基于磁盘或网络的Serializable不同，Parcelable是基于内存的。由于内存的读写速度高于磁盘，因此在Android中跨进程对象传递一般使用Parcelable。Parcelable是Android为我们提供的序列化的接口，相对于Serializable的使用相对复杂一些，但效率相对Serializable也高很多。

与Serializable不同，Parcelable接口的类不会被系统序列化。具体传输方式如下：

数据准备

自定义一个类DataParcel实现Parcelabel接口，其中自动生成了CREATOR

import android.os.Parcel;
import android.os.Parcelable;

public class DataParcel implements Parcelable {
    private int number;
    private String str1;
    private String str2;
    private String noSave = "[不传送的字符串]";

    // getter setter ...

    public String info() {
        return "number: "+number+", str1: "+str1+", str2: "+str2+", noSave: "+noSave;
    }
    // 读出操作，需要特别关注
    protected DataParcel(Parcel in) {
        number = in.readInt();
        str1 = in.readString();
        str2 = in.readString();
    }

    public DataParcel(int number, String str1, String str2, String noSave) {
        this.number = number;
        this.str1 = str1;
        this.str2 = str2;
        this.noSave = noSave;
    }
    // 强制使用了一个Parcelable.Creator对象。
    // 非重要，里面的方法暂时不管也不修改
    public static final Creator<DataParcel> CREATOR = new Creator<DataParcel>() {
        @Override
        public DataParcel createFromParcel(Parcel in) {
            return new DataParcel(in);
        }

        @Override
        public DataParcel[] newArray(int size) {
            return new DataParcel[size];
        }

    };

    @Override
    public int describeContents() {
        return 0;
    }
    // 写入操作，需要特别关注
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(number);
        dest.writeString(str1);
        dest.writeString(str2);
    }
}

可以看出，Parcelable没有传入Key，在writeToParcel中按顺序写入了int和2个String，在私有构造器中，按顺序读出了int和2个String，nosave用于对比使用。

传输Parcelable对象

把DataParcel对象交给intent。

DataParcel dataParcel = new DataParcel(100, "s1", "s2", "改变这个字符串看看能否被传递");
intent.putExtra(SendParamsDemo.K_PARCEL, dataParcel);

被打开的Activity接收传入的对象。

DataParcel dataParcel = intent.getParcelableExtra(K_PARCEL);

log中打印出发送和传入的对象信息。

D/rustAppMainActivity: goSendParamsDemo: parcel obj: com.rustfisher.tutorial2020.act.DataParcel@d8ce985
D/rustAppMainActivity: goSendParamsDemo: parcel obj: number: 100, str1: s1, str2: s2, noSave: 改变这个字符串看看能否被传递
D/rustAppSendParamsDemo: gotInput: parcel obj: com.rustfisher.tutorial2020.act.DataParcel@d90a3a6
D/rustAppSendParamsDemo: gotInput: number: 100, str1: s1, str2: s2, noSave: [不传送的字符串]

从log中我们可以看出，发送的对象和接收到的对象并不是同一个对象。但我们指定的那3个属性是相同的。

携带参数返回

在知道了如何携带参数启动，那么也需要知道如何携带参数返回上一个Activity。

给出1个例子，实现关闭activity时，将一些数据传回给上一个activity。

例子中会有2个Activity来做示范，ForResultFirstAct和ForResultSecondAct。

启动新的Activity

private static final int REQ_CODE = 10;

startActivityForResult(new Intent(getApplicationContext(), ForResultSecondAct.class), REQ_CODE);

装载回传数据

// ForResultSecondAct是第二个activity，可以设置返回时携带的数据
Intent resultIntent = new Intent();
resultIntent.putExtra(K_TITLE, mTitleEt.getText().toString());
resultIntent.putExtra(K_SUB_TITLE, mSubTitleEt.getText().toString());
setResult(RESULT_OK, resultIntent);
finish();

----

// RESULT_OK是Activity类的静态常量，用于代表操作结果
/** Standard activity result: operation canceled. */
public static final int RESULT_CANCELED    = 0;
/** Standard activity result: operation succeeded. */
public static final int RESULT_OK           = -1;
/** Start of user-defined activity results. */
public static final int RESULT_FIRST_USER   = 1;

获取回传数据

// ForResultFirstAct中需要复写方法，获取返回的数据
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch (requestCode) {
        case REQ_CODE:
            if (resultCode == RESULT_OK) {
                if (data != null) {
                    mTitleTv.setText(data.getStringExtra(ForResultSecondAct.K_TITLE));
                    mSubTitleTv.setText(data.getStringExtra(ForResultSecondAct.K_SUB_TITLE));
                }
            } else {
                Toast.makeText(getApplicationContext(), "未保存修改", Toast.LENGTH_SHORT).show();
            }
            break;
    }
}

以上是activity回传数据的一个例子。我们着重注意

startActivityForResult方法，启动下一个activity。
setResult方法，装载回传数据。
onActivityResult方法，获取回传结果。

启动模式

首先介绍两个概念：

任务：执行特定作业时与用户交互的一系列Activity
栈：这些Activity按照各自的打开顺序排列在堆栈中

Activity的4种启动模式：

standard：多个实例，可叠加
singleTask：task中唯一实例，可以把在它上面的activity干掉再onNewIntent
singleTop：多实例，不能叠加，栈顶走onNewIntent
singleInstance：只有一个实例，并且运行在一个独立task中，且task不允许其它实例存在

动画效果

可以定义动画xml在drawable中

从左到右入场

enter_from_left_to_right.xml，从左到右入场

<?xml version="1.0" encoding="utf-8"?><translate xmlns:android="http://schemas.android.com/apk/res/android"    android:duration="@android:integer/config_shortAnimTime"    android:fromXDelta="-100%p"    android:toXDelta="0%p" />

可以看出x轴方向上的动画使用的是fromXDelta和toXDelta属性。

右到左入场

enter_from_right_to_left.xml，右到左入场

<?xml version="1.0" encoding="utf-8"?><translate xmlns:android="http://schemas.android.com/apk/res/android"    android:duration="@android:integer/config_shortAnimTime"    android:fromXDelta="100%p"    android:toXDelta="0%p" />

从左边退场

exit_to_left.xml，从左边退场

<?xml version="1.0" encoding="utf-8"?><translate xmlns:android="http://schemas.android.com/apk/res/android"    android:duration="@android:integer/config_shortAnimTime"    android:fromXDelta="0%p"    android:toXDelta="-100%p" />

从右边退场

exit_to_right.xml，从右边退场

<?xml version="1.0" encoding="utf-8"?><translate xmlns:android="http://schemas.android.com/apk/res/android"    android:duration="@android:integer/config_shortAnimTime"    android:fromXDelta="0%p"    android:toXDelta="100%p" />

使用动画

然后在styles.xml中定义使用的动画效果。

<style name="AppMainTheme" parent="Theme.AppCompat.NoActionBar">    <item name="android:windowAnimationStyle">@style/DefActivityAnimation</item></style><!-- 指定过场动画 --><style name="DefActivityAnimation">    <item name="android:activityOpenExitAnimation">@anim/exit_to_left</item>    <item name="android:activityOpenEnterAnimation">@anim/enter_from_right_to_left</item>    <item name="android:activityCloseExitAnimation">@anim/exit_to_right</item>    <item name="android:activityCloseEnterAnimation">@anim/enter_from_left_to_right</item></style>

获得View的宽高

有时候我们还需要获得View的宽高信息，但是在OnCreate()和OnResume()中尝试获取宽高，取到的都是0。因为Activity在创建之后，各个子view不一定会被加载完成。因此需要下述方法：

在Activity的onWindowFocusChanged获取宽高

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    // 在这里我们可以获取到View的真实宽高
    Log.d(TAG, "onWindowFocusChanged: mBtn1.getWidth == " + mBtn1.getWidth());
}

使用ViewTreeObserver的OnGlobalLayoutListener回调

ViewTreeObserver vto = mBtn1.getViewTreeObserver();
vto.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
        int height = mBtn1.getHeight();
        int width = mBtn1.getWidth();
        Log.d(TAG, "onGlobalLayout: mBtn1 " + width + ", " + height);
        mBtn1.getViewTreeObserver().removeOnGlobalLayoutListener(this);
    }
});

使用View.post(Runnable action)方法

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mBtn1 = findViewById(R.id.btn1);
    Log.d(TAG, "mBtn1 post runnable");
    mBtn1.post(new Runnable() {
        @Override
        public void run() {
            Log.d(TAG, "mBtn1: " + mBtn1.getWidth() + ", " + mBtn1.getHeight());
        }
    });
}

应用：动态调整ImageView的宽高。

获取到view的宽高后，我们可以动态地调整ImageView的高度。假设图片宽高为704 * 440。xml中设置scaleType为fitXY。已知ImageView的宽度是固定的，我们可以调整高度。

<ImageView    
    android:layout_width="match_parent"    
    android:layout_height="wrap_content"    
    android:scaleType="fitXY"/>

根据图片真实大小来重设ImageView的高度。

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    resetIntroIvParams();
}

private void resetIntroIvParams() {
    int height = mIntroIv.getHeight(); // 704 * 440
    int wid = mIntroIv.getWidth();
    if (height > 0 && wid > 0) {
        ViewGroup.LayoutParams layoutParams = mIntroIv.getLayoutParams();
        layoutParams.height = (int) (wid * 440.0 / 704.0);
        mIntroIv.setLayoutParams(layoutParams);
    }
}