src/FruitandVegetableGuide/.idea/misc.xml

@@ -1,7 +1,6 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="jbr-17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">

src/FruitandVegetableGuide/app/src/main/java/com/example/fruitandvegetableguide/README.md

@@ -1,15 +1 @@
-# 要做的事还有很多
-![TODO](../../../../res/drawable/todo_list.png)
-
-运行前，先放一张西红柿图片在相册中，方便测试
-
-Android Studio无法预览Markdown文件解决方法
-```
-In the Android Studio:
-
-1. Find action (ctrl + shift + A / command + shift + A)
-2. Search for Choose Boot Java Runtime for the IDE
-3. Select the latest version in the "New:" dropdown - e.g. 11.0.12+7-b1504.27 JetBrains Runtime with JCEF // 这里我选择的最新版本即可。
-4. OK
-5. Restart
-```
+系统简介及配置环境

src/FruitandVegetableGuide/app/src/main/java/com/example/fruitandvegetableguide/data/dbhelper/DBHelper.kt

@@ -1,20 +1,22 @@
 package com.example.fruitandvegetableguide.data.dbhelper
 
-// TODO 这里放数据库工具方法，这些方法可以去网上找现成的
 import android.util.Log
 import androidx.compose.runtime.rememberCompositionContext
 import com.example.fruitandvegetableguide.R
 import com.example.fruitandvegetableguide.data.Guide
 import com.example.fruitandvegetableguide.data.Post
+import com.example.fruitandvegetableguide.data.local.LocalGuidesDataProvider
 import java.sql.Connection
 import java.sql.DriverManager
 import java.sql.PreparedStatement
 import java.sql.ResultSet
 import java.sql.SQLException
 import kotlinx.coroutines.*
+
 object DbHelper {
     //private const val DB_URL = "jdbc:sqlserver://rm-2ze1sd060o140gu067o.sqlserver.rds.aliyuncs.com:3433;databaseName=FruitandVegetableGuide"
-    private const val DB_URL = "jdbc:jtds:sqlserver://rm-2ze1sd060o140gu067o.sqlserver.rds.aliyuncs.com:3433/FruitandVegetableGuide"
+    private const val DB_URL =
+        "jdbc:jtds:sqlserver://rm-2ze1sd060o140gu067o.sqlserver.rds.aliyuncs.com:3433/FruitandVegetableGuide"
     private const val USER = "aruan"
     private const val PASS = "WRLXwrlx465434"
 
@@ -39,7 +41,6 @@ object DbHelper {
         }
     }
 
-
     fun login(username: String, password: String): Int {
         val conn = connect()
         var userId = -1 // 默认为 -1，表示未找到用户或不匹配
@@ -67,6 +68,7 @@ object DbHelper {
         }
         return userId
     }
+
     fun register(username: String, password: String): Boolean {
         val conn = connect()
         var rowsAffected = 0
@@ -87,14 +89,15 @@ object DbHelper {
         }
         return rowsAffected > 0
     }
-    //未测试
+
+    //
     fun postListInit(): MutableList<Post> {
         val conn = connect()
         val posts = mutableListOf<Post>()
 
         if (conn != null) {
             try {
-                val postQuery = "SELECT * FROM Post LIMIT 100" // 假设post表是你的帖子表
+                val postQuery = "SELECT TOP 100 * FROM Post" // 假设post表是你的帖子表
 
                 val preparedStatement = conn.prepareStatement(postQuery)
                 val resultSet = preparedStatement.executeQuery()
@@ -117,6 +120,7 @@ object DbHelper {
         println("贴子初始化成功")
         return posts
     }
+
     fun getPostByPostId(postId: Int): Post {
         val conn = connect()
         var post = Post(0, 0, "", labels = "", content = "")
@@ -132,7 +136,13 @@ object DbHelper {
                 val title = resultSet.getString("title")
                 val labels = resultSet.getString("labels")
                 val content = resultSet.getString("content")
-                post = Post(id = id, userId = userId, title = title, labels = labels, content = content)
+                post = Post(
+                    id = id,
+                    userId = userId,
+                    title = title,
+                    labels = labels,
+                    content = content
+                )
                 preparedStatement.close()
             } catch (e: SQLException) {
                 e.printStackTrace()
@@ -142,16 +152,17 @@ object DbHelper {
         }
         return post
     }
+
     fun getGuideByKind(kind: String): List<Guide> {
         var guides = mutableListOf<Guide>()
         var coon = connect()
-        if(coon != null){
-            try{
+        if (coon != null) {
+            try {
                 val guideQuery = "select * from Guide where kind = ?"
                 val preparedStatement = coon.prepareStatement(guideQuery)
                 preparedStatement.setString(1, kind)
                 val resultSet = preparedStatement.executeQuery()
-                while(resultSet.next()) {
+                while (resultSet.next()) {
                     val id = resultSet.getInt("id")
                     val kind = resultSet.getString("kind")
                     val identify = resultSet.getString("identify")
@@ -159,29 +170,38 @@ object DbHelper {
                     val taboo = resultSet.getString("taboo")
                     val nutritiveValue = resultSet.getString("nutritiveValue")
                     val recommendedMenu = resultSet.getString("recommendedMenu")
-                    val guide = Guide(id, kind = kind, identify = identify, suitable = suitable, taboo = taboo, nutritiveValue = nutritiveValue, recommendedMenu = recommendedMenu)
+                    val guide = Guide(
+                        id,
+                        kind = kind,
+                        identify = identify,
+                        suitable = suitable,
+                        taboo = taboo,
+                        nutritiveValue = nutritiveValue,
+                        recommendedMenu = recommendedMenu
+                    )
                     guides.add(guide)
                 }
                 preparedStatement.close()
-            }catch(e: SQLException){
+            } catch (e: SQLException) {
                 e.printStackTrace()
-            }finally{
+            } finally {
                 closeConnection(coon)
             }
         }
         return guides
     }
+
     fun getPostByLabels(labels: String): List<Post> {
         var posts = mutableListOf<Post>()
         var coon = connect()
-        if(coon != null){
-            try{
+        if (coon != null) {
+            try {
                 val postQuery = "select * from Post where labels LIKE ?"
                 val preparedStatement = coon.prepareStatement(postQuery)
                 val temp = "%$labels%"
                 preparedStatement.setString(1, temp)
                 val resultSet = preparedStatement.executeQuery()
-                while(resultSet.next()) {
+                while (resultSet.next()) {
                     val id = resultSet.getInt("id")
                     val userid = resultSet.getInt("userid")
                     val title = resultSet.getString("title")
@@ -191,18 +211,27 @@ object DbHelper {
                     posts.add(post)
                 }
                 preparedStatement.close()
-            }catch(e: SQLException){
+            } catch (e: SQLException) {
                 //e.printStackTrace()
-            }finally{
+            } finally {
                 closeConnection(coon)
             }
         }
 
         return posts
     }
+
     fun getGuideByGuideId(guideId: Int): Guide {
         val conn = connect()
-        var guide = Guide(0, kind = "", identify = "", suitable = "", taboo = "", nutritiveValue = "", recommendedMenu = "")
+        var guide = Guide(
+            0,
+            kind = "",
+            identify = "",
+            suitable = "",
+            taboo = "",
+            nutritiveValue = "",
+            recommendedMenu = ""
+        )
         if (conn != null) {
             try {
 
@@ -218,7 +247,15 @@ object DbHelper {
                 val taboo = resultSet.getString("taboo")
                 val nutritiveValue = resultSet.getString("nutritiveValue")
                 val recommendedMenu = resultSet.getString("recommendedMenu")
-                guide = Guide(id=guideId, kind = kind, identify = identify, suitable = suitable, taboo = taboo, nutritiveValue = nutritiveValue, recommendedMenu = recommendedMenu)
+                guide = Guide(
+                    id = guideId,
+                    kind = kind,
+                    identify = identify,
+                    suitable = suitable,
+                    taboo = taboo,
+                    nutritiveValue = nutritiveValue,
+                    recommendedMenu = recommendedMenu
+                )
                 preparedStatement.close()
             } catch (e: SQLException) {
                 e.printStackTrace()
@@ -228,15 +265,16 @@ object DbHelper {
         }
         return guide
     }
-    //未测试
+
+    //
     fun guideListInit(): List<Guide> {
         val conn = connect()
-        val guides = mutableListOf<Guide>()
+        val guides = LocalGuidesDataProvider.allGuides
 
         if (conn != null) {
             try {
-                val guideQuery = "SELECT * FROM Guide LIMIT 100" // 假设post表是你的帖子表
-
+                val guideQuery = "SELECT TOP 100 * FROM Guide"
+                Log.d("guides", "guideListInit")
                 val preparedStatement = conn.prepareStatement(guideQuery)
                 val resultSet = preparedStatement.executeQuery()
                 while (resultSet.next()) {
@@ -247,7 +285,15 @@ object DbHelper {
                     val taboo = resultSet.getString("taboo")
                     val nutritiveValue = resultSet.getString("nutritiveValue")
                     val recommendedMenu = resultSet.getString("recommendedMenu")
-                    val guide = Guide(id, kind = kind, identify = identify, suitable = suitable, taboo = taboo, nutritiveValue = nutritiveValue, recommendedMenu = recommendedMenu)
+                    val guide = Guide(
+                        id,
+                        kind = kind,
+                        identify = identify,
+                        suitable = suitable,
+                        taboo = taboo,
+                        nutritiveValue = nutritiveValue,
+                        recommendedMenu = recommendedMenu
+                    )
                     guides.add(guide)
                 }
                 preparedStatement.close()
@@ -257,15 +303,25 @@ object DbHelper {
                 closeConnection(conn)
             }
         }
-        println("guideListInit成功")
+        for (guide in guides) {
+            Log.d("guides", "dbHelper,guideListInit: $guide")
+        }
         return guides
     }
-    fun postInsert(userid: Int, title: String, imgId: Int = R.drawable.loading, labels: String, content: String) : Boolean{
+
+    fun postInsert(
+        userid: Int,
+        title: String,
+        imgId: Int = R.drawable.loading,
+        labels: String,
+        content: String
+    ): Boolean {
         val coon = connect()
         var rowsAffected = 0
-        if(coon != null){
-            try{
-                val postInsert = "insert into Post (userId, title, imgId, labels, content) values (?, ?, ?, ?, ?)"
+        if (coon != null) {
+            try {
+                val postInsert =
+                    "insert into Post (userId, title, imgId, labels, content) values (?, ?, ?, ?, ?)"
                 val preparedStatement = coon.prepareStatement(postInsert)
                 preparedStatement.setInt(1, userid);
                 preparedStatement.setString(2, title)
@@ -274,20 +330,21 @@ object DbHelper {
                 preparedStatement.setString(5, content)
                 rowsAffected = preparedStatement.executeUpdate()
                 preparedStatement.close()
-            }catch (e: SQLException){
+            } catch (e: SQLException) {
                 e.printStackTrace()
-            }finally{
+            } finally {
                 closeConnection(coon)
             }
         }
         println("postInsert成功")
         return rowsAffected > 0
     }
+
     fun getUsernameByUserid(userid: Int): String {
         val coon = connect()
         var username = ""
-        if(coon != null){
-            try{
+        if (coon != null) {
+            try {
                 val accountQuery = "select * from Account where id = ?"
                 val preparedStatement = coon.prepareStatement(accountQuery)
                 preparedStatement.setInt(1, userid)
@@ -295,25 +352,26 @@ object DbHelper {
                 resultSet.next()
                 username = resultSet.getString("username")
                 preparedStatement.close()
-            }catch (e:SQLException){
+            } catch (e: SQLException) {
                 e.printStackTrace()
-            }finally {
+            } finally {
                 closeConnection(coon)
             }
         }
         println("getUsernameByUserid成功")
         return username
     }
+
     fun getPostByUserid(userid: Int): List<Post> {
         var posts = mutableListOf<Post>()
         var coon = connect()
-        if(coon != null){
-            try{
+        if (coon != null) {
+            try {
                 val postQuery = "select * from Post where userID = ?"
                 val preparedStatement = coon.prepareStatement(postQuery)
                 preparedStatement.setInt(1, userid)
                 val resultSet = preparedStatement.executeQuery()
-                while(resultSet.next()) {
+                while (resultSet.next()) {
                     val id = resultSet.getInt("id")
                     val userid = resultSet.getInt("userid")
                     val title = resultSet.getString("title")
@@ -323,41 +381,41 @@ object DbHelper {
                     posts.add(post)
                 }
                 preparedStatement.close()
-            }catch(e: SQLException){
+            } catch (e: SQLException) {
                 e.printStackTrace()
-            }finally{
+            } finally {
                 closeConnection(coon)
             }
         }
         return posts
     }
-    //有问题
+
+    //
     fun DeletePost(postToDeleteList: List<Post>): Boolean {
         var coon = connect()
         var rowsAffected = 0
-        if(coon != null){
-            try{
+        if (coon != null) {
+            try {
                 val postDelete = "delete from Post where id = ?"
                 val preparedStatement = coon.prepareStatement(postDelete)
                 for (post in postToDeleteList) {
                     preparedStatement.setInt(1, post.id)
                     val resultSet = preparedStatement.executeUpdate()
-                    if(resultSet > 0) rowsAffected++
+                    if (resultSet > 0) rowsAffected++
                 }
                 preparedStatement.close()
-            }catch(e: SQLException){
+            } catch (e: SQLException) {
                 e.printStackTrace()
-            }finally{
+            } finally {
                 closeConnection(coon)
             }
         }
-        if(rowsAffected == postToDeleteList.size) {
+        if (rowsAffected == postToDeleteList.size) {
             println("DeletePost成功")
             return true
         }
         //println("DeletePost失败")
         return false
     }
-
 }
 

src/FruitandVegetableGuide/app/src/main/java/com/example/fruitandvegetableguide/data/local/LocalGuidesDataProvider.kt

@@ -7,7 +7,7 @@ import com.example.fruitandvegetableguide.R
 object LocalGuidesDataProvider {
     val allGuides = mutableListOf(
         Guide(
-            1,
+            100000,
             R.drawable.carrots,
             "种类-默认",
             "1、首先就要观察外表，看表皮有没有破损，甚至坑坑洼洼，掉皮的胡萝卜会让其水分蒸发，肯定会影响口感，并且不容易存放。\n" +
@@ -19,7 +19,7 @@ object LocalGuidesDataProvider {
             "推荐菜-默认"
         ),
         Guide(
-            2,
+            29,
             R.drawable.cucumbers,
             "黄瓜",
             "颜色：黄瓜的颜色应该是均匀的绿色，没有任何瑕疵。\n手感：轻轻掐一下黄瓜，如果手感觉进入黄瓜时很脆嫩，而且有水分出来的黄瓜比较鲜嫩。\n刺：黄瓜的刺特别嫩才是质量口感好的黄瓜。看到黄瓜表皮的刺小而密，而且轻轻一摸就会碎断，这种黄瓜十分新鲜润滑。\n纵陵：选择黄瓜的时候要选择黄瓜的瓜体呈棒状带有纵陵的一类黄瓜。\n顶花：好的黄瓜，顶花会在黄瓜成熟后自然脱落，留下个小黄点。\n大小：太大的黄瓜一般是催熟的黄瓜，相对来说个头小的黄瓜比较好吃。",
@@ -29,7 +29,7 @@ object LocalGuidesDataProvider {
             "黄瓜玉子烧"
         ),
         Guide(
-            3,
+            25,
             R.drawable.tomatoes,
             "西红柿",
             "1. 选择正常大小的西红柿，不要买畸形的西红柿，因为畸形的很有可能是打了一些对人体有害的药在里面，有助于西红柿快速的生长.\n2. 选择能从表皮面能看到西红柿内部的大概结构，这也能说明西红柿是很健康的.\n3. 选择西红柿顶端是有裂缝的，意思就是有一些小小的裂缝痕迹，这样也能说明西红柿没有打催生剂.\n4. 选择西红柿里面不是绿色的，因为现场也不能做好实验，可以先买一个回去试一试，切开看西红柿里面是不是绿色的，如果是绿色的，西红柿外表是红色的，这只能说明西红柿并未成熟，而是打了催生剂.\n5. 选择比较硬一点的西红柿，这样就比较新鲜，同时也容易放置，这样也就不容易坏掉了¹.",
@@ -39,7 +39,7 @@ object LocalGuidesDataProvider {
             "番茄乌冬面"
         ),
         Guide(
-            4,
+            27,
             R.drawable.carrots,
             "胡萝卜",
             "1、首先就要观察外表，看表皮有没有破损，甚至坑坑洼洼，掉皮的胡萝卜会让其水分蒸发，肯定会影响口感，并且不容易存放。\n2、把两个相同大小的胡萝卜拿在手里掂一下，如果有一个轻得多的就不要买了，说明放置的时间太长了，里面的水分减少，要买那种沉甸甸的胡萝卜，水分更充足，更新鲜好吃。所以大家买胡萝卜的时候最好用手感受一下重量。\n3、个头偏大的长得比较老，水分肯定少，口感不鲜嫩；而个头偏小的也不行，虽然很脆嫩，但是还没有完全长成熟，营养价值不高。挑胡萝卜尽量选中等个头，粗细均匀，带有根须的。\n",
@@ -49,7 +49,7 @@ object LocalGuidesDataProvider {
             "炝腌萝卜"
         ),
         Guide(
-            5,
+            29,
             R.drawable.cucumbers,
             "黄瓜",
             "颜色：黄瓜的颜色应该是均匀的绿色，没有任何瑕疵。\n手感：轻轻掐一下黄瓜，如果手感觉进入黄瓜时很脆嫩，而且有水分出来的黄瓜比较鲜嫩。\n刺：黄瓜的刺特别嫩才是质量口感好的黄瓜。看到黄瓜表皮的刺小而密，而且轻轻一摸就会碎断，这种黄瓜十分新鲜润滑。\n纵陵：选择黄瓜的时候要选择黄瓜的瓜体呈棒状带有纵陵的一类黄瓜。\n顶花：好的黄瓜，顶花会在黄瓜成熟后自然脱落，留下个小黄点。\n大小：太大的黄瓜一般是催熟的黄瓜，相对来说个头小的黄瓜比较好吃。",
@@ -59,7 +59,7 @@ object LocalGuidesDataProvider {
             "黄瓜玉子烧"
         ),
         Guide(
-            6,
+            25,
             R.drawable.tomatoes,
             "西红柿",
             "1. 选择正常大小的西红柿，不要买畸形的西红柿，因为畸形的很有可能是打了一些对人体有害的药在里面，有助于西红柿快速的生长.\n2. 选择能从表皮面能看到西红柿内部的大概结构，这也能说明西红柿是很健康的.\n3. 选择西红柿顶端是有裂缝的，意思就是有一些小小的裂缝痕迹，这样也能说明西红柿没有打催生剂.\n4. 选择西红柿里面不是绿色的，因为现场也不能做好实验，可以先买一个回去试一试，切开看西红柿里面是不是绿色的，如果是绿色的，西红柿外表是红色的，这只能说明西红柿并未成熟，而是打了催生剂.\n5. 选择比较硬一点的西红柿，这样就比较新鲜，同时也容易放置，这样也就不容易坏掉了¹.",
@@ -69,7 +69,7 @@ object LocalGuidesDataProvider {
             "番茄乌冬面"
         ),
         Guide(
-            7,
+            27,
             R.drawable.carrots,
             "胡萝卜",
             "1、首先就要观察外表，看表皮有没有破损，甚至坑坑洼洼，掉皮的胡萝卜会让其水分蒸发，肯定会影响口感，并且不容易存放。\n2、把两个相同大小的胡萝卜拿在手里掂一下，如果有一个轻得多的就不要买了，说明放置的时间太长了，里面的水分减少，要买那种沉甸甸的胡萝卜，水分更充足，更新鲜好吃。所以大家买胡萝卜的时候最好用手感受一下重量。\n3、个头偏大的长得比较老，水分肯定少，口感不鲜嫩；而个头偏小的也不行，虽然很脆嫩，但是还没有完全长成熟，营养价值不高。挑胡萝卜尽量选中等个头，粗细均匀，带有根须的。\n",
@@ -79,7 +79,7 @@ object LocalGuidesDataProvider {
             "炝腌萝卜"
         ),
         Guide(
-            8,
+            29,
             R.drawable.cucumbers,
             "黄瓜",
             "颜色：黄瓜的颜色应该是均匀的绿色，没有任何瑕疵。\n手感：轻轻掐一下黄瓜，如果手感觉进入黄瓜时很脆嫩，而且有水分出来的黄瓜比较鲜嫩。\n刺：黄瓜的刺特别嫩才是质量口感好的黄瓜。看到黄瓜表皮的刺小而密，而且轻轻一摸就会碎断，这种黄瓜十分新鲜润滑。\n纵陵：选择黄瓜的时候要选择黄瓜的瓜体呈棒状带有纵陵的一类黄瓜。\n顶花：好的黄瓜，顶花会在黄瓜成熟后自然脱落，留下个小黄点。\n大小：太大的黄瓜一般是催熟的黄瓜，相对来说个头小的黄瓜比较好吃。",
@@ -89,7 +89,7 @@ object LocalGuidesDataProvider {
             "黄瓜玉子烧"
         ),
         Guide(
-            9,
+            25,
             R.drawable.tomatoes,
             "西红柿",
             "1. 选择正常大小的西红柿，不要买畸形的西红柿，因为畸形的很有可能是打了一些对人体有害的药在里面，有助于西红柿快速的生长.\n2. 选择能从表皮面能看到西红柿内部的大概结构，这也能说明西红柿是很健康的.\n3. 选择西红柿顶端是有裂缝的，意思就是有一些小小的裂缝痕迹，这样也能说明西红柿没有打催生剂.\n4. 选择西红柿里面不是绿色的，因为现场也不能做好实验，可以先买一个回去试一试，切开看西红柿里面是不是绿色的，如果是绿色的，西红柿外表是红色的，这只能说明西红柿并未成熟，而是打了催生剂.\n5. 选择比较硬一点的西红柿，这样就比较新鲜，同时也容易放置，这样也就不容易坏掉了¹.",
@@ -99,7 +99,7 @@ object LocalGuidesDataProvider {
             "番茄乌冬面"
         ),
         Guide(
-            10,
+            27,
             R.drawable.carrots,
             "胡萝卜",
             "1、首先就要观察外表，看表皮有没有破损，甚至坑坑洼洼，掉皮的胡萝卜会让其水分蒸发，肯定会影响口感，并且不容易存放。\n2、把两个相同大小的胡萝卜拿在手里掂一下，如果有一个轻得多的就不要买了，说明放置的时间太长了，里面的水分减少，要买那种沉甸甸的胡萝卜，水分更充足，更新鲜好吃。所以大家买胡萝卜的时候最好用手感受一下重量。\n3、个头偏大的长得比较老，水分肯定少，口感不鲜嫩；而个头偏小的也不行，虽然很脆嫩，但是还没有完全长成熟，营养价值不高。挑胡萝卜尽量选中等个头，粗细均匀，带有根须的。\n",
@@ -109,7 +109,7 @@ object LocalGuidesDataProvider {
             "炝腌萝卜"
         ),
         Guide(
-            11,
+            29,
             R.drawable.cucumbers,
             "黄瓜",
             "颜色：黄瓜的颜色应该是均匀的绿色，没有任何瑕疵。\n手感：轻轻掐一下黄瓜，如果手感觉进入黄瓜时很脆嫩，而且有水分出来的黄瓜比较鲜嫩。\n刺：黄瓜的刺特别嫩才是质量口感好的黄瓜。看到黄瓜表皮的刺小而密，而且轻轻一摸就会碎断，这种黄瓜十分新鲜润滑。\n纵陵：选择黄瓜的时候要选择黄瓜的瓜体呈棒状带有纵陵的一类黄瓜。\n顶花：好的黄瓜，顶花会在黄瓜成熟后自然脱落，留下个小黄点。\n大小：太大的黄瓜一般是催熟的黄瓜，相对来说个头小的黄瓜比较好吃。",
@@ -119,7 +119,7 @@ object LocalGuidesDataProvider {
             "黄瓜玉子烧"
         ),
         Guide(
-            12,
+            25,
             R.drawable.tomatoes,
             "西红柿",
             "1. 选择正常大小的西红柿，不要买畸形的西红柿，因为畸形的很有可能是打了一些对人体有害的药在里面，有助于西红柿快速的生长.\n2. 选择能从表皮面能看到西红柿内部的大概结构，这也能说明西红柿是很健康的.\n3. 选择西红柿顶端是有裂缝的，意思就是有一些小小的裂缝痕迹，这样也能说明西红柿没有打催生剂.\n4. 选择西红柿里面不是绿色的，因为现场也不能做好实验，可以先买一个回去试一试，切开看西红柿里面是不是绿色的，如果是绿色的，西红柿外表是红色的，这只能说明西红柿并未成熟，而是打了催生剂.\n5. 选择比较硬一点的西红柿，这样就比较新鲜，同时也容易放置，这样也就不容易坏掉了¹.",

src/FruitandVegetableGuide/app/src/main/java/com/example/fruitandvegetableguide/ui/main/MainScreen.kt

@@ -1,5 +1,6 @@
 package com.example.fruitandvegetableguide.ui.main
 
+import android.annotation.SuppressLint
 import androidx.annotation.DrawableRes
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.layout.Arrangement
@@ -51,6 +52,7 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import com.example.fruitandvegetableguide.R
 import com.example.fruitandvegetableguide.ui.theme.FruitandVegetableGuideTheme
 import com.example.fruitandvegetableguide.utils.guideListInit
 import com.example.fruitandvegetableguide.utils.postListInit
@@ -183,7 +185,8 @@ fun GuideElement(
         colors = ButtonDefaults.buttonColors(
             containerColor = Color.White,
         ),
-        contentPadding = PaddingValues(1.dp)
+        contentPadding = PaddingValues(1.dp),
+        modifier = Modifier.width(90.dp)
     ) {
         Column(
             modifier = modifier,
@@ -193,9 +196,16 @@ fun GuideElement(
                 painter = painterResource(id = drawable),
                 contentDescription = null,
                 contentScale = ContentScale.Crop,
-                modifier = Modifier
-                    .size(88.dp)
-                    .clip(CircleShape)
+                modifier = if (R.drawable.loading == drawable) {
+                    Modifier
+//                        .size(24.dp)
+//                        .padding(32.dp)
+                        .clip(CircleShape)
+                } else {
+                    Modifier
+                        .size(88.dp)
+                        .clip(CircleShape)
+                }
             )
             Text(
                 text = kind,
@@ -209,6 +219,7 @@ fun GuideElement(
 }
 
 //帖子元素
+@SuppressLint("InvalidColorHexValue")
 @Composable
 fun PostCard(
     postId: Int,
@@ -229,18 +240,25 @@ fun PostCard(
             Button(
                 onClick = { onClickToPostDetail(postId) },
                 colors = ButtonDefaults.buttonColors(
-                    containerColor = Color.LightGray,
-                )
+                    containerColor = Color(0x0000),
+                ),
+                modifier = Modifier.width(251.dp)
             ) {
                 Image(
-                    painter = painterResource(id = drawable), contentDescription = null,
+                    painter = painterResource(id = drawable),
+                    contentDescription = null,
                     contentScale = ContentScale.Crop,
-                    modifier = Modifier.size(80.dp)
+                    modifier = if (R.drawable.loading != drawable) {
+                        Modifier.size(80.dp)
+                    } else {
+                        Modifier
+                    }
                 )
                 Text(
                     text = title,
                     style = MaterialTheme.typography.titleMedium,
-                    modifier = Modifier.padding(horizontal = 16.dp)
+                    color = Color.Black,
+                    modifier = Modifier.padding(horizontal = 10.dp)
                 )
             }
         }
@@ -254,6 +272,7 @@ fun GuideGrid(
     modifier: Modifier = Modifier,
     onClickToGuideDetail: (guideId: Int) -> Unit = {},
 ) {
+    val guideList = guideListInit()
     LazyHorizontalGrid(
         rows = GridCells.Fixed(2),
         contentPadding = PaddingValues(horizontal = 8.dp),
@@ -261,7 +280,7 @@ fun GuideGrid(
         verticalArrangement = Arrangement.spacedBy(2.dp),
         modifier = modifier.height(300.dp)
     ) {
-        items(guideListInit()) { item ->
+        items(guideList) { item ->
             GuideElement(
                 guideId = item.id,
                 drawable = item.imgId,
@@ -278,6 +297,7 @@ fun PostGrid(
     modifier: Modifier = Modifier,
     onClickToPostDetail: (postId: Int) -> Unit = {},
 ) {
+    val postList = postListInit()
     LazyHorizontalGrid(
         rows = GridCells.Fixed(4),
         contentPadding = PaddingValues(horizontal = 16.dp),
@@ -285,7 +305,7 @@ fun PostGrid(
         verticalArrangement = Arrangement.spacedBy(16.dp),
         modifier = modifier.height(300.dp)
     ) {
-        items(postListInit()) { item ->
+        items(postList) { item ->
             PostCard(
                 postId = item.id,
                 drawable = item.imgId,

src/FruitandVegetableGuide/app/src/main/java/com/example/fruitandvegetableguide/utils/Utils.kt

@@ -9,7 +9,7 @@ import com.example.fruitandvegetableguide.data.local.LocalGuidesDataProvider
 import com.example.fruitandvegetableguide.data.local.LocalPostsDataProvider
 import kotlinx.coroutines.*
 
-// TODO 这里放页面逻辑相关代码，要自己写，通过调用数据库工具方法实现
+// TODO 这里放页面逻辑相关代码
 // 输入参数和返回参数不要改
 
 fun loginVerification(username: String, password: String): Int {