18034727885
2026-09-18 1328a7b0b90825b1fd63bca8f7675e52df8b151d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package com.igo.user.db
 
import android.content.ContentValues
import android.content.Context
import cn.sinata.xldutils.sysErr
import com.igo.user.network.entity.LatLonPoint
import com.igo.user.network.entity.Tip
import org.jetbrains.anko.db.RowParser
import org.jetbrains.anko.db.SqlOrderDirection
import org.jetbrains.anko.db.delete
import org.jetbrains.anko.db.select
 
/**
 * 历史记录数据库操作
 */
object HistoryDBManager {
 
    private fun hasSameAddress(context: Context, name: String, address: String, table: String = DBHelper.HISTORY_TABLE_NAME): Long {
        return context.database.use {
            return@use select(table)
                    .columns("id")
                    .whereSimple("name=? and address=?", name, address)
                    .exec {
                        if (this.moveToFirst()) {
                            this.getLong(0)
                        } else {
                            -1
                        }
                    }
        }
    }
 
 
    fun getAddressList(context: Context,city: String = "", limit: Int = 10, table: String = DBHelper.HISTORY_TABLE_NAME): List<Tip> {
        return context.database.use {
            val columns1 = select(table)
                .columns("name", "lat", "lng", "district", "address", "code", "time")
            if (city.isNotEmpty()){
                columns1.whereSimple("city=?",city)
            }
            return@use columns1
                    .limit(limit)
                    .orderBy("time", SqlOrderDirection.DESC)
                    .parseList(object : RowParser<Tip> {
                        override fun parseRow(columns: Array<Any?>): Tip {
                            val tip = Tip()
                            tip.name = columns[0].toString()
                            val lat = columns[1].toString().toDoubleOrNull()
                            val lng = columns[2].toString().toDoubleOrNull()
                            sysErr("----->$lat-------->$lng")
                            if (lat != null && lng != null)
                                tip.setPostion(LatLonPoint(lat, lng))
                            tip.district = columns[3].toString()
                            tip.address = columns[4].toString()
                            tip.adcode = columns[5].toString()
                            return tip
                        }
                    })
        }
    }
 
 
    fun saveHistory(context: Context, tip: Tip,city:String, table: String= DBHelper.HISTORY_TABLE_NAME): Long {
        return context.database.use {
            //最多存储20条
            getAllCount(context, table)
            val values = ContentValues()
            val id = hasSameAddress(context, tip.name, tip.address, table)
            //有
            if (id != -1L) {
                values.put("time", System.currentTimeMillis())
                return@use update(table, values, "id=?", arrayOf(id.toString())).toLong()
            } else {
                values.put("name", tip.name)
                values.put("lat", tip.point.latitude)
                values.put("lng", tip.point.longitude)
                values.put("district", tip.district)
                values.put("address", tip.address)
                values.put("code", tip.adcode)
                values.put("city", city)
                values.put("time", System.currentTimeMillis())
                return@use insert(table, null, values)
            }
        }
    }
 
 
    fun clearHistory(context: Context, table: String= DBHelper.HISTORY_TABLE_NAME) {
        context.database.use {
            delete(table)
        }
    }
 
    private fun getAllCount(context: Context, table: String) {
        context.database.use {
            val list = select(table)
                    .columns("time")
                    .orderBy("time", SqlOrderDirection.DESC)
                    .parseList(object : RowParser<Long> {
                        override fun parseRow(columns: Array<Any?>): Long {
                            return columns[0].toString().toLong()
                        }
                    })
            if (list.size >= 20) {
                val last = list[18]
                delete(table, "time<?", arrayOf(last.toString()))
            }
        }
    }
 
}