// 隐式Intent - 通过Action和数据类型描述意图
val implicitIntent = Intent().apply {
    action = Intent.ACTION_VIEW
    data = Uri.parse("https://www.example.com")
}
startActivity(implicitIntent)

<activity android:name=".MyShareActivity">
  <!-- 声明Intent过滤器 -->
  <intent-filter>
    <!-- 定义Action -->
    <action android:name="android.intent.action.SEND" />

    <!-- 定义数据类型 -->
    <data android:mimeType="text/plain" />

    <!-- 定义类别 -->
    <category android:name="android.intent.category.DEFAULT" />
  </intent-filter>
</activity>

class MyShareActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_share)

        // 检查Intent的Action
        when (intent?.action) {
            Intent.ACTION_SEND -> {
                if (intent.type == "text/plain") {
                    handleSendText(intent)
                } else if (intent.type?.startsWith("image/") == true) {
                    handleSendImage(intent)
                }
            }
        }
    }

    private fun handleSendText(intent: Intent) {
        val sharedText = intent.getStringExtra(Intent.EXTRA_TEXT)
        // 处理文本分享
        textView.text = sharedText
    }

    private fun handleSendImage(intent: Intent) {
        val imageUri = intent.getParcelableExtra<Uri>(Intent.EXTRA_STREAM)
        // 处理图片分享
        imageView.setImageURI(imageUri)
    }
}

// 第一个Activity
class FirstActivity : AppCompatActivity() {
    
    companion object {
        const val REQUEST_CODE = 1001
        const val EXTRA_KEY = "result_data"
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_first)
        
        val button = findViewById<Button>(R.id.button)
        val resultTextView = findViewById<TextView>(R.id.result_text_view)
        
        button.setOnClickListener {
            val intent = Intent(this, SecondActivity::class.java)
            startActivityForResult(intent, REQUEST_CODE)
        }
    }
    
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        if (requestCode == REQUEST_CODE) {
            val result = data?.getStringExtra(EXTRA_KEY) ?: "没有数据返回"
            
            when (resultCode) {
                RESULT_OK -> {
                    // 用户主动提交
                    Toast.makeText(this, "提交成功: $result", Toast.LENGTH_SHORT).show()
                }
                RESULT_CANCELED -> {
                    // 用户按返回键
                    Toast.makeText(this, "已取消: $result", Toast.LENGTH_SHORT).show()
                }
            }
        }
    }
}

// 第二个Activity  按钮返回
class SecondActivity : AppCompatActivity() {
    
    private var isSubmitted = false
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_second)
        
        val submitButton = findViewById<Button>(R.id.submit_button)
        val editText = findViewById<EditText>(R.id.input_edit_text)
        
        submitButton.setOnClickListener {
            isSubmitted = true
            val input = editText.text.toString()
            val data = Intent().apply {
                putExtra(FirstActivity.EXTRA_KEY, input)
            }
            setResult(RESULT_OK, data)
            finish()
        }
        
        // 处理返回键
        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                returnWithCancel("用户取消了操作")
            }
        })
    }
    
    private fun returnWithCancel(message: String) {
        val data = Intent().apply {
            putExtra(FirstActivity.EXTRA_KEY, message)
        }
        setResult(RESULT_CANCELED, data)
        finish()
    }
    
    // 或者重写onBackPressed（已弃用，但还能用）
    @Deprecated("Deprecated in Java")
    override fun onBackPressed() {
        returnWithCancel("通过onBackPressed返回")
    }
}

// 第一个Activity
class FirstActivity : AppCompatActivity() {
    
    // 注册Activity Result合约
    private val startForResult = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()
    ) { result ->
        when (result.resultCode) {
            RESULT_OK -> {
                val data = result.data?.getStringExtra("result_data")
                val actionType = result.data?.getStringExtra("action_type")
                
                when (actionType) {
                    "submit" -> {
                        Toast.makeText(this, "提交成功: $data", Toast.LENGTH_SHORT).show()
                    }
                    "cancel" -> {
                        Toast.makeText(this, "用户取消: $data", Toast.LENGTH_SHORT).show()
                    }
                    "back" -> {
                        Toast.makeText(this, "用户按返回键: $data", Toast.LENGTH_SHORT).show()
                    }
                }
            }
            RESULT_CANCELED -> {
                Toast.makeText(this, "操作被取消", Toast.LENGTH_SHORT).show()
            }
        }
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_first)
        
        val button = findViewById<Button>(R.id.button)
        button.setOnClickListener {
            val intent = Intent(this, SecondActivity::class.java)
            startForResult.launch(intent)
        }
    }
}

// 第二个Activity  按钮返回
class SecondActivity : AppCompatActivity() {
    
    private var isSubmitted = false
    private var inputData: String = ""
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_second)
        
        val submitButton = findViewById<Button>(R.id.submit_button)
        val cancelButton = findViewById<Button>(R.id.cancel_button)
        val editText = findViewById<EditText>(R.id.input_edit_text)
        
        submitButton.setOnClickListener {
            inputData = editText.text.toString()
            isSubmitted = true
            returnResult("submit", inputData)
        }
        
        cancelButton.setOnClickListener {
            returnResult("cancel", "用户手动取消")
        }
        
        // 处理返回键 - 使用 onBackPressedDispatcher（推荐）
        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                returnResult("back", "用户按返回键")
            }
        })
    }
    
    private fun returnResult(actionType: String, data: String) {
        val resultData = Intent().apply {
            putExtra("result_data", data)
            putExtra("action_type", actionType)
        }
        setResult(RESULT_OK, resultData)
        finish()
    }
}

class FruitAdapter(val fruitList: List<Fruit>) : 
RecyclerView.Adapter<FruitAdapter.ViewHolder>() { 

    // view 子项最外层布局
    inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) { 
        val fruitImage: ImageView = view.findViewById(R.id.fruitImage) 
        val fruitName: TextView = view.findViewById(R.id.fruitName) 
    } 

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder { 
        val view = LayoutInflater.from(parent.context) 
            .inflate(R.layout.fruit_item, parent, false) 
        // 此处添加点击事件
        return ViewHolder(view) 
    } 

    // 对子项数据复制
    override fun onBindViewHolder(holder: ViewHolder, position: Int) { 
        val fruit = fruitList[position] 
        holder.fruitImage.setImageResource(fruit.imageId) 
        holder.fruitName.text = fruit.name 
    } 

    override fun getItemCount() = fruitList.size 

} 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
    android:orientation="horizontal" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" > 
 
    <fragment 
        android:id="@+id/leftFrag" 
        android:name="com.example.fragmenttest.LeftFragment" 
        android:layout_width="0dp" 
        android:layout_height="match_parent" 
        android:layout_weight="1" /> 
 
    <fragment 
        android:id="@+id/rightFrag" 
        android:name="com.example.fragmenttest.RightFragment" 
        android:layout_width="0dp" 
        android:layout_height="match_parent" 
        android:layout_weight="1" /> 
 
</LinearLayout> 

    private fun replaceFragment(fragment: Fragment) { 
        val fragmentManager = supportFragmentManager 
        val transaction = fragmentManager.beginTransaction() 
        transaction.replace(R.id.rightLayout, fragment) 
        transaction.commit() 
    } 

val fragment = leftFrag as LeftFragment 

if (activity != null) { 
    // 将 activity 强制转换为 MainActivity 类型
    val mainActivity = activity as MainActivity 
} 

// Activity中定义接口
class MainActivity : AppCompatActivity(), FragmentA.OnDataListener {
    
    fun sendDataToFragmentB(data: String) {
        val fragmentB = supportFragmentManager.findFragmentById(R.id.fragment_b) as? FragmentB
        fragmentB?.updateData(data)
    }
}

// FragmentA
class FragmentA : Fragment() {
    // 定义通信接口
    interface OnDataListener {
        fun onDataSent(data: String)
    }
    
    private var listener: OnDataListener? = null
    
    override fun onAttach(context: Context) {
        // 将Activity转换为OnDataListener接口
        super.onAttach(context)
        listener = context as? OnDataListener
    }

    // 调用Activity方法实现与另一个Fragment通信
    fun sendData() {
        listener?.onDataSent("Hello from FragmentA")
    }
} 

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // 检查是否是双面板布局
        isDualPane = findViewById<View>(R.id.fragment_container_right) != null
        
        if (savedInstanceState == null) {
            if (isDualPane) {
                // 平板设备 - 显示两个Fragment
                setupTabletLayout()
            } else {
                // 手机设备 - 显示一个Fragment
                setupPhoneLayout()
            }
        }
    }

class MainActivity : AppCompatActivity() { 
    lateinit var timeChangeReceiver: TimeChangeReceiver 
    override fun onCreate(savedInstanceState: Bundle?) { 
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_main) 
        val intentFilter = IntentFilter() 
        // 设置监听广播类型
        intentFilter.addAction("android.intent.action.TIME_TICK") 
        timeChangeReceiver = TimeChangeReceiver() 
        registerReceiver(timeChangeReceiver, intentFilter) 
    } 
    override fun onDestroy() { 
        super.onDestroy() 
        // 注销接收器
        unregisterReceiver(timeChangeReceiver) 
    } 
    
    inner class TimeChangeReceiver : BroadcastReceiver() { 
        override fun onReceive(context: Context, intent: Intent) { 
            Toast.makeText(context, "Time has changed", Toast.LENGTH_SHORT).show()
        }
    }
}

 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />  

val intent = Intent("com.example.broadcasttest.MY_BROADCAST") 
// 指明要发送的程序
intent.setPackage(packageName) 
sendBroadcast(intent) 

 val intent = Intent("com.example.broadcasttest.MY_BROADCAST") 
intent.setPackage(packageName) 
sendOrderedBroadcast(intent, null)   //  intent,权限相关字符 

<receiver 
  android:name=".MyBroadcastReceiver" 
  android:enabled="true" 
  android:exported="true"> 
  <intent-filter android:priority="100">   
    <action android:name="com.example.broadcasttest.MY_BROADCAST"/> 
  </intent-filter> 
</receiver> 

// 写入文件
fun save(inputText: String) { 
    try { 
        val output = openFileOutput("data", Context.MODE_PRIVATE) 
        val writer = BufferedWriter(OutputStreamWriter(output)) 
        writer.use {   // use 代码块结束后，自动关闭 流
            it.write(inputText) 
        } 
    } catch (e: IOException) { 
        e.printStackTrace() 
    } 
} 

fun load(): String { 
    val content = StringBuilder() 
    try { 
        val input = openFileInput("data") 
        val reader = BufferedReader(InputStreamReader(input)) 
        reader.use { 
            reader.forEachLine { 
                content.append(it) 
            } 
        } 
    } catch (e: IOException) { 
        e.printStackTrace() 
    } 
    return content.toString() 
} 

val editor = getSharedPreferences("data", Context.MODE_PRIVATE).edit() 
editor.putString("name", "Tom") 
editor.putInt("age", 28) 
editor.putBoolean("married", false) 
editor.apply() 

val prefs = getSharedPreferences("data", Context.MODE_PRIVATE) 
val name = prefs.getString("name", "") 
val age = prefs.getInt("age", 0) 
val married = prefs.getBoolean("married", false) 

/*
context: 
name: 数据库名
cursor: 在查询数据的时候返回一个自定义的Cursor，一般传入null即可
version: 数据库版本号
*/
class MyDatabaseHelper(val context: Context, name: String, version: Int) : 
        SQLiteOpenHelper(context, name, null, version) {
    // 构建sql语句
    private val createBook = "create table Book (" + 
            " id integer primary key autoincrement," + 
            "author text," + 
            "price real," + 
            "pages integer," + 
            "name text)" 
 
    override fun onCreate(db: SQLiteDatabase) { 
        db.execSQL(createBook) 
        Toast.makeText(context, "Create succeeded", Toast.LENGTH_SHORT).show() 
    } 
    // 用于对数据库进行升级
    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { 
    } 
 
} 

val db = dbHelper.writableDatabase 
val values1 = ContentValues().apply { 
    // 开始组装第一条数据 
    put("name", "The Da Vinci Code") 
    put("author", "Dan Brown") 
    put("pages", 454) 
    put("price", 16.96) 
} 
db.insert("Book", null, values1) // 插入第一条数据 
val values2 = ContentValues().apply { 
    // 开始组装第二条数据 
    put("name", "The Lost Symbol") 
    put("author", "Dan Brown") 
    put("pages", 510) 
    put("price", 19.95) 
} 
// insert(表名 为空的列自动赋值NULL ContentValues对象)
db.insert("Book", null, values2) // 插入第二条数据 

val db = dbHelper.writableDatabase 
val values = ContentValues() 
values.put("price", 10.99) 
db.update("Book", values, "name = ?", arrayOf("The Da Vinci Code"))   // 加入了数据约束

val db = dbHelper.writableDatabase 
db.delete("Book", "pages > ?", arrayOf("500")) 

db.execSQL("insert into Book (name, author, pages, price) values(?, ?, ?, ?)", 
    arrayOf("The Da Vinci Code", "Dan Brown", "454", "16.96") 
) 

override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) { 
    if (oldVersion <= 1) { 
        db.execSQL(createCategory) 
    } 
    if (oldVersion <= 2) { 
        db.execSQL("alter table Book add column category_id integer") 
    } 
} 

class MainActivity : AppCompatActivity() { 
 
    override fun onCreate(savedInstanceState: Bundle?) { 
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_main) 
                makeCall.setOnClickListener { 
            // 判断用户是否授权
            if (ContextCompat.checkSelfPermission(this, 
                Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) { 
                // 未授权时则需要请求对应权限
                ActivityCompat.requestPermissions(this, 
                    arrayOf(Manifest.permission.CALL_PHONE), 1) 
            } else { 
                call() 
            } 
        } 
    } 

    //  未授权 ->  请求对应权限 -> 请求结果的回调
    // grantResults 为 请求结果
    override fun onRequestPermissionsResult(requestCode: Int, 
            permissions: Array<String>, grantResults: IntArray) { 
        super.onRequestPermissionsResult(requestCode, permissions, grantResults) 
        when (requestCode) { 
            1 -> { 
                if (grantResults.isNotEmpty() && 
                    grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
                    call() 
                } else { 
                    Toast.makeText(this, "You denied the permission", 
                        Toast.LENGTH_SHORT).show() 
                } 
            } 
        } 
    } 
 
    private fun call() { 
        try { 
            val intent = Intent(Intent.ACTION_CALL) 
            intent.data = Uri.parse("tel:10086") 
            startActivity(intent) 
        } catch (e: SecurityException) { 
            e.printStackTrace() 
        } 
    } 
 
}

val uri = Uri.parse("content://com.example.app.provider/table1") 
// 通过 query 查询数据
val cursor = contentResolver.query( 
    uri, 
    projection, 
    selection, 
    selectionArgs, 
    sortOrder) 

        // 查询联系人数据 
        contentResolver.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, 
                null, null, null, null)?.apply { 
            while (moveToNext()) { 
                // 获取联系人姓名 
                val displayName = getString(getColumnIndex( 
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME)) 
                // 获取联系人手机号 
                val number = getString(getColumnIndex( 
                ContactsContract.CommonDataKinds.Phone.NUMBER)) 
                contactsList.add("$displayName\n$number") 
            } 
            adapter.notifyDataSetChanged() 
            close() 
        } 

class MyProvider : ContentProvider() { 
    // 初始化调用，数据库创建与升级
    override fun onCreate(): Boolean { 
        return false 
    } 
    // 查询数据 
    // uri -- 表   projection -- 列 selection和selectionArgs -- 约束参数  sortOrder -- 结果排序  
    override fun query(uri: Uri, projection: Array<String>?, selection: String?, 
            selectionArgs: Array<String>?, sortOrder: String?): Cursor? { 
        return null 
    }
    // 添加一条数据
    override fun insert(uri: Uri, values: ContentValues?): Uri? { 
        return null 
    } 
} 
    override fun update(uri: Uri, values: ContentValues?, selection: String?, 
            selectionArgs: Array<String>?): Int { 
        return 0 
    } 
    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int { 
        return 0 
    } 
    // 获取Uri对象所对应的MIME类型
    override fun getType(uri: Uri): String? { 
        return null 
    }

class MyProvider : ContentProvider() { 
 
    private val table1Dir = 0 
    private val table1Item = 1 
    private val table2Dir = 2 
    private val table2Item = 3 
 
    private val uriMatcher = UriMatcher(UriMatcher.NO_MATCH) 
 
    init { 
        uriMatcher.addURI("com.example.app.provider", "table1", table1Dir) 
        uriMatcher.addURI("com.example.app.provider ", "table1/#", table1Item) 
        uriMatcher.addURI("com.example.app.provider ", "table2", table2Dir) 
        uriMatcher.addURI("com.example.app.provider ", "table2/#", table2Item) 
    } 
    ... 
    override fun query(uri: Uri, projection: Array<String>?, selection: String?, 
            selectionArgs: Array<String>?, sortOrder: String?): Cursor? { 
        when (uriMatcher.match(uri)) { 
            table1Dir -> { 
                // 查询table1表中的所有数据 
            } 
            table1Item -> { 
                // 查询table1表中的单条数据 
            } 
            table2Dir -> { 
                // 查询table2表中的所有数据 
            } 
            table2Item -> { 
                // 查询table2表中的单条数据 
            } 
        } 
        ... 
    } 
    ... 
} 

val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager 
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { 
    // channelId--渠道ID channelName--渠道名称，表明渠道作用 importance--初始的重要等级
    val channel = NotificationChannel(channelId, channelName, importance) 
    manager.createNotificationChannel(channel) 
} 

val notification = NotificationCompat.Builder(context, channelId) 
    .setContentTitle("This is content title")
    .setContentText("This is content text") 
    .setSmallIcon(R.drawable.small_icon) 
    .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.drawable.large_icon)) 
    .build() 
    
manager.notify(1, notification) 

class MainActivity : AppCompatActivity() { 

    override fun onCreate(savedInstanceState: Bundle?) { 
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_main) 
        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as 
        NotificationManager 
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { 
            val channel = NotificationChannel("normal", "Normal",NotificationManager. 
                                              IMPORTANCE_DEFAULT) 
            manager.createNotificationChannel(channel) 
        } 
        sendNotice.setOnClickListener { 
            val intent = Intent(this, NotificationActivity::class.java) 
            val pi = PendingIntent.getActivity(this, 0, intent, 0) 
            val notification = NotificationCompat.Builder(this, "normal") 
                .setContentTitle("This is content title") 
                .setContentText("This is content text") 
                .setSmallIcon(R.drawable.small_icon) 
                .setLargeIcon(BitmapFactory.decodeResource(resources, 
                                                           R.drawable.large_icon)) 
                // 设置 通知点击跳转Intent
                .setContentIntent(pi) 
                // 点击通知后自动取消 
                .setAutoCancel(true) 
                .build() 
            manager.notify(1, notification) 
        } 
    } 
} 

class MainActivity : AppCompatActivity() { 
    val takePhoto = 1 
    lateinit var imageUri: Uri 
    lateinit var outputImage: File 
    override fun onCreate(savedInstanceState: Bundle?) { 
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_main) 
        takePhotoBtn.setOnClickListener { 
            // 创建File对象，用于存储拍照后的图片 
            outputImage = File(externalCacheDir, "output_image.jpg") 
            if (outputImage.exists()) { 
                outputImage.delete() 
            } 
            outputImage.createNewFile() 
            imageUri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                // 将File对象转换成一个封装过的Uri对象 
                FileProvider.getUriForFile(this, "com.example.cameraalbumtest.
                                           fileprovider", outputImage) 
            } else { 
                Uri.fromFile(outputImage) 
            } 
            // 启动相机程序 
            val intent = Intent("android.media.action.IMAGE_CAPTURE") 
            // 指定图片输出地址
            intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri) 
            startActivityForResult(intent, takePhoto) 
        } 
    } 
    // 传入返回的结果
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { 
        super.onActivityResult(requestCode, resultCode, data) 
        when (requestCode) { 
            takePhoto -> { 
                if (resultCode == Activity.RESULT_OK) { 
                    // 将拍摄的照片显示出来 
                    val bitmap = BitmapFactory.decodeStream(contentResolver. 
                        openInputStream(imageUri)) 
                    imageView.setImageBitmap(rotateIfRequired(bitmap)) 
                } 
            } 
        } 
    } 
    // 根据图片信息确定是否需要旋转图片
    private fun rotateIfRequired(bitmap: Bitmap): Bitmap { 
        val exif = ExifInterface(outputImage.path) 
        val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 
            ExifInterface.ORIENTATION_NORMAL) 
        return when (orientation) { 
            ExifInterface.ORIENTATION_ROTATE_90 -> rotateBitmap(bitmap, 90) 
            ExifInterface.ORIENTATION_ROTATE_180 -> rotateBitmap(bitmap, 180) 
            ExifInterface.ORIENTATION_ROTATE_270 -> rotateBitmap(bitmap, 270) 
            else -> bitmap 
        } 
    } 
    private fun rotateBitmap(bitmap: Bitmap, degree: Int): Bitmap { 
        val matrix = Matrix() 
        matrix.postRotate(degree.toFloat()) 
        val rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, 
            matrix, true) 
        bitmap.recycle() // 将不再需要的Bitmap对象回收 
        return rotatedBitmap 
    } 
}

class MainActivity : AppCompatActivity() { 
    ... 
    val fromAlbum = 2 
    override fun onCreate(savedInstanceState: Bundle?) { 
        ... 
        fromAlbumBtn.setOnClickListener { 
            // 打开文件选择器 
            val intent = Intent(Intent.ACTION_OPEN_DOCUMENT) 
            intent.addCategory(Intent.CATEGORY_OPENABLE) 
            // 指定只显示图片 
            intent.type = "image/*" 
            // fromAlbum：当选择完图片回到onActivityResult()方法时，
            // 就会进入fromAlbum的条件下处理图片。
            startActivityForResult(intent, fromAlbum) 
        } 
    } 
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { 
        super.onActivityResult(requestCode, resultCode, data) 
        when (requestCode) { 
            ... 
            fromAlbum -> { 
                if (resultCode == Activity.RESULT_OK && data != null) { 
                    data.data?.let { uri -> 
                        // 将选择的图片显示 
                        val bitmap = getBitmapFromUri(uri) 
                        imageView.setImageBitmap(bitmap) 
                    } 
                } 
            } 
        } 
    } 
    private fun getBitmapFromUri(uri: Uri) = contentResolver 
        .openFileDescriptor(uri, "r")?.use { 
        BitmapFactory.decodeFileDescriptor(it.fileDescriptor) 
    } 
    ... 
} 

class MainActivity : AppCompatActivity() { 
 
    private val mediaPlayer = MediaPlayer() 
 
    override fun onCreate(savedInstanceState: Bundle?) { 
        super.onCreate(savedInstanceState) 
        setContentView(R.layout.activity_main) 
        initMediaPlayer() 
        play.setOnClickListener { 
            if (!mediaPlayer.isPlaying) { 
                mediaPlayer.start() // 开始播放 
            } 
        } 
        pause.setOnClickListener { 
            if (mediaPlayer.isPlaying) { 
                mediaPlayer.pause() // 暂停播放 
            } 
        } 
        stop.setOnClickListener { 
            if (mediaPlayer.isPlaying) { 
                mediaPlayer.reset() // 停止播放 
                initMediaPlayer() 
            } 
        } 
    } 
 
    private fun initMediaPlayer() { 
        val assetManager = assets 
        val fd = assetManager.openFd("music.mp3") 
        mediaPlayer.setDataSource(fd.fileDescriptor, fd.startOffset, fd.length) 
        mediaPlayer.prepare() 
    } 
 
    override fun onDestroy() { 
        super.onDestroy() 
        mediaPlayer.stop() 
        mediaPlayer.release() 
    } 
 
} 

 webView.settings.javaScriptEnabled=true
 webView.webViewClient = WebViewClient()
 webView.loadUrl("https://www.baidu.com")

// 调用实例
val url = URL("https://www.baidu.com")
val connection = url.openConnection() as HttpURLConnection
// 定义请求方法
connection.requestMethod = "GET"
// 定义请求头
connection.connectTimeout = 8000
connection.readTimeout = 8000
// 获取输入流
val input = connection.inputStream
connection.disconnect()

connection.requestMethod = "POST"
val output = DataOutputStream(connection.outputStream)
output.writeBytes("username=admin&password=123456")

val client = OkHttpClient()
// 创建Request对象
val request = Request.Builder().build()
val request = Request.Builder()
     .url("https://www.baidu.com")
     .build()
val response = client.newCall(request).execute()
val responseData = response.body?.string()

// 构建待提交参数
val requestBody = FormBody.Builder()
    .add("username", "admin")
    .add("password", "123456")
    .build()
val request = Request.Builder()
    .url("https://www.baidu.com")
    .post(requestBody)
    .build()
val response = client.newCall(request).execute()
val responseData = response.body?.string()

<apps>
  <app>
    <id>1</id>
    <name>Google Maps</name>
    <version>1.0</version>
  </app>
  <app>
    <id>2</id>
    <name>Chrome</name>
    <version>2.1</version>
  </app>
  <app>
    <id>3</id>
    <name>Google Play</name>
    <version>2.3</version>
  </app>
</apps>

// 通过网络等获取的 XML数据
val response = client.newCall(request).execute()
val responseData = response.body?.string()
if (responseData != null) {
    parseXMLWithPull(responseData)
}
// 解析XML数据
private fun parseXMLWithPull(xmlData: String) {
    try {
        // 创建实例，输入数据
        val factory = XmlPullParserFactory.newInstance()
        val xmlPullParser = factory.newPullParser()
        xmlPullParser.setInput(StringReader(xmlData))
        // 获取当前解析时间
        var eventType = xmlPullParser.eventType
        var id = ""
        var name = ""
        var version = ""
        // 循环节点解析
        while (eventType != XmlPullParser.END_DOCUMENT) {
            val nodeName = xmlPullParser.name
            when (eventType) {
                // 开始解析某个节点
                XmlPullParser.START_TAG -> {
                    when (nodeName) {
                        "id" -> id = xmlPullParser.nextText()
                        "name" -> name = xmlPullParser.nextText()
                        "version" -> version = xmlPullParser.nextText()
                    }
                }
                // 完成解析某个节点
                XmlPullParser.END_TAG -> {
                    if ("app" == nodeName) {
                        Log.d("MainActivity", "id is $id")
                        Log.d("MainActivity", "name is $name")
                        Log.d("MainActivity", "version is $version")
                    }
                }
            }
            eventType = xmlPullParser.next()
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}
}

class ContentHandler : DefaultHandler() {
    private var nodeName = ""
    private lateinit var id: StringBuilder
    private lateinit var name: StringBuilder
    private lateinit var version: StringBuilder
    // 初始化
    override fun startDocument() {
        id = StringBuilder()
        name = StringBuilder()
        version = StringBuilder()
    }
    override fun startElement(uri: String, localName: String, qName: String, attributes:
                           Attributes) {
        // 记录当前节点名
        nodeName = localName
        Log.d("ContentHandler", "uri is $uri")
        Log.d("ContentHandler", "localName is $localName")
        Log.d("ContentHandler", "qName is $qName")
        Log.d("ContentHandler", "attributes is $attributes")
    }
    override fun characters(ch: CharArray, start: Int, length: Int) {
        // 根据当前节点名判断将内容添加到哪一个StringBuilder对象中
        when (nodeName) {
            "id" -> id.append(ch, start, length)
            "name" -> name.append(ch, start, length)
            "version" -> version.append(ch, start, length)
        }
    }
    override fun endElement(uri: String, localName: String, qName: String) {
        if ("app" == localName) {
            Log.d("ContentHandler", "id is ${id.toString().trim()}")
            Log.d("ContentHandler", "name is ${name.toString().trim()}")
            Log.d("ContentHandler", "version is ${version.toString().trim()}")
            // 最后要将StringBuilder清空
            id.setLength(0)
            name.setLength(0)
            version.setLength(0)
        }
    }
    override fun endDocument() {
    }
}

private fun parseXMLWithSAX(xmlData: String) {
    try {
        val factory = SAXParserFactory.newInstance()
        val xmlReader = factory.newSAXParser().XMLReader
        val handler = ContentHandler()
        // 将ContentHandler的实例设置到XMLReader中
        xmlReader.contentHandler = handler
        // 开始执行解析
        xmlReader.parse(InputSource(StringReader(xmlData)))
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

[{"id":"5","version":"5.5","name":"Clash of Clans"},
  {"id":"6","version":"7.0","name":"Boom Beach"},
  {"id":"7","version":"3.5","name":"Clash Royale"}]

private fun parseJSONWithJSONObject(jsonData: String) {
    try {
        val jsonArray = JSONArray(jsonData)
        for (i in 0 until jsonArray.length()) {
            val jsonObject = jsonArray.getJSONObject(i)
            val id = jsonObject.getString("id")
            val name = jsonObject.getString("name")
            val version = jsonObject.getString("version")
            Log.d("MainActivity", "id is $id")
            Log.d("MainActivity", "name is $name")
            Log.d("MainActivity", "version is $version")
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

val gson = Gson()
val person = gson.fromJson(jsonData, Person::class.java)

val typeOf = object : TypeToken<List<Person>>() {}.type
val people = gson.fromJson<List<Person>>(jsonData, typeOf)

HttpUtil.sendOkHttpRequest(address, object : Callback {
    override fun onResponse(call: Call, response: Response) {
        // 得到服务器返回的具体内容
        val responseData = response.body?.string()
    }
    override fun onFailure(call: Call, e: IOException) {
        // 在这里对异常情况进行处理
    }
})

class App(val id: String, val name: String, val version: String) 

// 命名： 以具体的功能种类名开头，以Service结尾
interface AppService { 
    // 返回值必须声明成Retrofit中内置的Call类型
    @GET("get_data.json") 
    fun getAppData(): Call<List<App>> 
} 

// 构建对象并设置根路径
val retrofit = Retrofit.Builder() 
    .baseUrl("http://10.0.2.2/") 
    .addConverterFactory(GsonConverterFactory.create())   // 指定解析库
    .build() 
// 创建接口的动态代理对象  Retrofit会自动检查并通过创建代理对象实现接口。调用方法时由代理对象
// 截调用并执行网络请求
val appService = retrofit.create(AppService::class.java) 
appService.getAppData().enqueue(object : Callback<List<App>> { 
    override fun onResponse(call: Call<List<App>>, 
                                        response: Response<List<App>>) { 
        val list = response.body() 
        if (list != null) { 
            for (app in list) { 
                Log.d("MainActivity", "id is ${app.id}") 
                Log.d("MainActivity", "name is ${app.name}") 
                Log.d("MainActivity", "version is ${app.version}") 
            } 
        } 
    } 
    override fun onFailure(call: Call<List<App>>, t: Throwable) { 
        t.printStackTrace() 
    } 
}) 

interface ExampleService { 
     // 接口动态变化
    @GET("{page}/get_data.json") 
    fun getData(@Path("page") page: Int): Call<Data> 

    // get方法传参： GET http://example.com/get_data.json?u=<user>&t=<token> 
    @GET("get_data.json") 
    fun getData(@Query("u") user: String, @Query("t") token: String): Call<Data> 

    @DELETE("data/{id}") 
    fun deleteData(@Path("id") id: String): Call<ResponseBody> 
} 

interface ExampleService { 
    @POST("data/create") 
    fun createData(@Body data: Data): Call<ResponseBody> 

    // 自定义 Header
    @Headers("User-Agent: okhttp", "Cache-Control: max-age=0") 
    @GET("get_data.json") 
    fun getData(): Call<Data> 

    // Header 的动态声明
    @GET("get_data.json") 
    fun getData(@Header("User-Agent") userAgent: String, 
        @Header("Cache-Control") cacheControl: String): Call<Data> 
} 

object ServiceCreator { 
    // 构建单例类避免retrofit重复创建
    private const val BASE_URL = "http://10.0.2.2/" 
    private val retrofit = Retrofit.Builder() 
        .baseUrl(BASE_URL) 
        .addConverterFactory(GsonConverterFactory.create()) 
        .build() 

     fun <T> create(serviceClass: Class<T>): T = retrofit.create(serviceClass) 
}