开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> 20220423-安卓基础学习（2） -> 正文阅读

[移动开发]20220423-安卓基础学习（2）

Activity

创建一个Activity

? 当我们创建一个Activity后，都需要在AndroidManifest中进行注册才能生效

? Activity的注册声明式放在标签中的。

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

    <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/Theme.UIBestPractice">
        <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>
</manifest>

? 在中加入标签表示将此Activity作为启动的Activity。

? label：指定Activity中标题栏的内容，将显示在Activity的最顶部

Activity中使用Toast

? Toast式Android提供的一种提醒方式，在程序中可以使用它将一些短小的消息通知给用户，这些消息会在一段时间后消失，并且不占用任何屏幕空间

Toast.makeText(this, "You clicked Button1", Toast.LENGTH_SHORT).show()

? Toast有三个参数：

Context：Toast要求的上下文，由于Activity本身就是一个Context对象，所以可以直接传入this
String: Toast需要显示的文本内容
Toast显示的时长，有两个可选参数：Toast.LENGTH_SHORT和Toast.LENGTH_LONG

简化findViewById()

? 在kotlin中，可以在app/build.gradle文件中加入kotlin-android-extensions，就可以直接使用控件的id进行调用，而不需要使用findViewById()方法了

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-android-extensions'//根据布局文件自动生成一个具有相同名称的变量
}


override fun onCreate(savedInstanceState: Bundle?){
        super.onCreate(savedInstanceState)
        //不在活动中显示标题栏
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        //加载一个布局，传入布局文件的ID
        setContentView(R.layout.first_layout)
        Log.d("FirstActivity", "OnCreate execute")
        //val button1:Button = findViewById(R.id.button_1)
        button_1.setOnClickListener{
            //三个参数，第一个是要求的上下文即activity本身，第二个是内容，第三个是显式时长
            Toast.makeText(this, "You clicked Button1", Toast.LENGTH_SHORT).show()
            //val intent = Intent(this, ThirdActivity::class.java)
            val intent = Intent(Intent.ACTION_VIEW)
            intent.data = Uri.parse("https://www.baidu.com")
            startActivity(intent)
        }
    }
//直接使用在布局中的button1变量

Menu的使用

? 通过New->Menu resource file创建一个menu文件.

? 标签用于创建具体的菜单项，然后通过id表示唯一的标识符

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/add_item"
        android:title="Add"/>
    <item
        android:id="@+id/remove_item"
        android:title="Remove"/>
</menu>

? 然后在Activity中重写onCreateOptionsMenu()方法，可以使用Ctrl + O快捷键。inflate接收两个参数，第一个参数用于指定我们通过哪一个资源文件来创建菜单，第二个用于指定我们的菜单添加到哪一个Menu对象中。然后可以通过重写onOptionsItemSelected()方法来对菜单定义响应事件

override fun onCreateOptionsMenu(menu: Menu?): Boolean {
    menuInflater.inflate(R.menu.main, menu)
    return true
    //ture表示显示菜单，false表示不显示
}

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    //通过itemId判断点击的是哪一个菜单项
    when(item.itemId){
        R.id.add_item->Toast.makeText(this, "you clicked add", Toast.LENGTH_SHORT).show()
        R.id.remove_item->Toast.makeText(this, "you clicked remove", Toast.LENGTH_SHORT).show()
    }
    return true
}

销毁一个Activity

? 可以通过back键来销毁，也可以调用finish()方法对activity进行销毁。

button_1.setOnClickListener{
    finish()
}

使用Intent对Activity进行切换

显式Intent切换

? Intent()方法接收两个参数，第一个Context要求提供Activity的上下文，第二个用于指定想要启动的目标Activity。

override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.First_layout)
        button_2.setOnClickListener{
            val intent = Intent(this, SecondActivity::class.java)
            startActivity(intent)
        }
    }

隐式Intent切换

? 隐式切换不会指明想要启动的Activity，而是通过抽象的action和category等信息，然后通过系统分析Intent找到合适的Activity来启动。

? 首先在AndroidManifest文件中指明和信息。default表示一种默认的category，在调用startActivity时会自动将其添加到intent中

<activity android:name=".SecondActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="com.example.activitytest.ACTION_START"/>
                <category android:name="android.intent.category.DEFAULT"/>
                <category android:name="com.example.activitytest_MY_CATEGORY"/>
            </intent-filter>
        </activity>

? 然后就可以通过隐式intent来切换Activity

button_2.setOnClickListener{
    val intent = Intent("com.example.activitytest.ACTOPM_START")
    //intent.addCategory("com.example.activitytest.MY_CATEGORY")
    startActivity(intent)
}

? 除此之外，隐式Intent还可以启动其他程序的Activity。

button_1.setOnClickListener{
    val intent = Intent(Intent.ACTION_VIEW)
    intent.data = Uri.prase("https://www.baidu.com")
    startActivity(intent)
}

传递数据到下一个Activity

? Intent提供了一系列putExtra()方法的重载，可以将想要的数据暂存在Intent中。

override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.First_layout)
        button_2.setOnClickListener{
            val data : String = "Hello SecondActivity"
            val intent = Intent(this, SecondActivity::class.java)
            intent.putExtra("extra_data", data)
            startActivity(intent)
        }
    }


class SecondActivity: AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.second_layout)
        val extraData = intent.getStringExtra("extra_data")
        Log.d("SecondActivity", "extra data is $extraData")
    }
}

返回给上一个Activity

? Activity类中提供了一个用于启动Activity的startActivityForResult()方法，它期望在Activity销毁的时候能够返回给上一个Activity。

startActivityForResult()方法接收两个参数：第一个参数是Intent，第二个参数是请求吗，用于判断数据的来源。

class FirstActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?){
        ...
        button1.setOnClickListener{
    	val intent = Intent(this, secondActivity::class.java)
    	startActivityForResult(intent, 1)
		}
    }
    override fun onActivityResult(requestCode: Int, resultCode: Int, data:Intent?){
        super.onActivityResult(requestCode, resultCode, data)
        when(requestCode){
            1-> if(resultCode == RESULT_OK){
                val returnData = data?.getStringExtra("data_return")
            }
        }
    }
}



class SecondActivity:AppCompatActivity{
    override fun onCreate(savedInstanceState: Bundle?){
        super.onCreate(savedInstanceState)
        setContentView(R.layout.second_layout)
        button2.setOnClickListener{
            val intent = Intent()
            intent.putExtra("data_return", "Hello FirstActivity")
            setResult(RESULT_OK, intent)
            finish()
        }
    }
}

Activity的生命周期

返回栈

? Android使用任务(task)来管理Activity，一个任务就是一组存放在返回栈中的Activity集合。每当我们启动一个Activity时，它就会在返回栈中入栈，并处于栈顶位置。每当我们按下Back或者调用finish方法销毁Activity时，处于栈顶的Activity就会出栈。系统总是显式处于栈顶的Activity给用户

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bvweZqEL-1650718347510)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220423164022217.png)]

Activity状态

? 每个Activity在其生命周期中最多可能有四种状态

运行状态：当Activity处于栈顶时，Activity就处于运行状态
暂停状态：当Activity不再处于栈顶，但仍然可见时就处于暂停状态
停止状态：当Activity不再处于栈顶，且完全不可见时，处于停止状态
销毁状态：当Activity从栈中一出时处于销毁状态

Activity的生存期

? Activity定义了7个回调方法，覆盖了Activity生命周期的每一个环节。

onCreate()：当Activity第一次被创建时调用
onStart()：当Activity由不可见到可见时调用
onResume()：当Activity准备好和用户进行交互的时候调用。此时Activity处于栈顶并处于运行态
onPause()：当系统准备启动或恢复另一个Activity时调用
onStop()：当Activity完全不可用时调用
onDestory()：在Activity被销毁之前调用
onRestart()：当Activity由停止变为运行之前调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lu6W121v-1650718347511)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20220423165533274.png)]

package com.example.activitylifecycletest

import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.android.synthetic.main.activity_main.*

class MainActivity : AppCompatActivity() {

    private val tag = "MainActivity"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        startNormalActivity.setOnClickListener{
            val intent = Intent(this, NormalActivity::class.java)
            startActivity(intent)
        }
        startDialogActivity.setOnClickListener{
            val intent = Intent(this, DialogActivity::class.java)
            startActivity(intent)
        }
    }

    override fun onStart() {
        super.onStart()
        Log.d(tag, "onStart")
    }

    override fun onResume(){
        super.onResume()
        Log.d(tag, "onResume")
    }

    override fun onPause() {
        super.onPause()
        Log.d(tag, "onPause")
    }

    override fun onStop() {
        super.onStop()
        Log.d(tag, "onStop")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(tag, "onDestroy")
    }

    override fun onRestart() {
        super.onRestart()
        Log.d(tag, "onRestart")
    }


}

Activity被回收了的处理办法

? 当Activity进入停止状态时，有可能会被系统回收，但此时Activity中可能保存有临时数据和状态。如果丢失这些数据和状态是非常影响用户体验的。为了解决这一问题，Activity中提供了一个onSaveInstanceState()方法，它保证了Activity被回收之前一定会调用。

? onSaveInstanceState()方法会携带一个Bundle类型的参数，它提供了一系列的方法用于保存数据，如putString()、putInt()等。每个保存方法提供了两个参数，第一个是键，第二个是值

override fun onsaveInstanceState(outState:Bundle){
    super.onSaveInstanceState(outState)
    val tmpData = "Something you just typed"
    outState.putString("data_key", tmpData)
}

override fun onCreate(savedInstanceState:Bundle?){
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    if(saveInstanceState != null){
        val tmpData = savedInstanceState.getString("data_key")
    }
    ...
}

Activity 启动模式

? 启动模式一共有四种，分别是standerd、singleTop、singleTask和singleInstance，可以在AndroidManifest中通过标签指定android:launchMode属性来选择启动模式。

standerd：默认启动模式，在此模式下，每当启动一个新的Activity，它就会在返回栈中入栈，并处于栈顶位置。系统不会在乎此Activity是否已经在返回栈中存在，每次启动都会创建一个新的Activity实例
singleTop：在启动Activity时，如果发现返回栈的栈顶已经是该Activity时，则可以直接使用它，不再创建新的Activity实例
singleTask：每次启动Activity时，系统首先会检查返回栈中是否存在该Activity实例，如果发现已经存在则直接使用该实例，并将该Activity之上的所有Activity都出栈，如果没有咋创建一个新的Activity
singleInstance：系统会启用一个新的返回栈来管理这个Activity。

Activity实践

如何知道当前是哪一个Activity

? 先创建一个BaseActivity，然后让此类成为其他Activity类的父类，然后就会打印出当前所在类的类名

open class BaseActivity: AppCompatActivity(){
    
    override fun onCreate(savedInstanceState: Bundle?){
        super.onCreate(savedInstanceState)
        //打印当前实例的类名
        Log.d("BaseActivity", javaClass.simpleName)
    }
}

随时退出Activity

? 新建一个单例类ActivityCollector作为Activity的集合，在创建时将Activity加入到集合中，然后在退出键中调用finishAll函数

object ActivityCollector{
    private val activities = ArrayList<Activity>()
    fun addActivity(activity:Activity){
        activities.add(activity)
    }
    fun removeActivity(activity:Activity){
        activities.add(activity)
    }
    
    fun finishAll(){
        for(activity in activities){
            if(!activity.isFinishing){
                activity.finish()
            }
        }
        activities.clear()
    }
}