xiaoyan159/OneMapQS
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

优化数据库查询

Browse Source
This commit is contained in:
squallzhjch 2023-10-25 10:17:16 +08:00
parent 9cf39d476c
commit c7122376cf
19 changed files with 1301 additions and 840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
app/src/main/assets/omdb_config.json
View File

@ -59,15 +59,7 @@
"name": "道路方向",
"zoomMin": 15,
"zoomMax": 17,
"checkLinkId": false,
"transformer": [
{
"k": "geometry",
"v": "~",
"klib": "geometry",
"vlib": "addRdLinkDirect()"
}
]
"checkLinkId": false
},
"2011": {
"table": "OMDB_LINK_NAME",

64
app/src/main/java/com/navinfo/omqs/bean/ImportConfig.kt
View File

@ -4,6 +4,7 @@ import android.util.Log
import com.google.gson.annotations.Expose
import com.navinfo.collect.library.data.entity.RenderEntity
import com.navinfo.omqs.db.ImportPreProcess
import io.realm.Realm
import kotlin.reflect.KFunction
import kotlin.reflect.KParameter
import kotlin.reflect.full.declaredMemberFunctions
@ -12,13 +13,15 @@ import kotlin.reflect.full.declaredMemberFunctions
class ImportConfig {
@Expose
var tableMap: MutableMap<String, TableInfo> = mutableMapOf()
@Expose
val tableGroupName: String = "OMDB数据"
@Expose
var checked : Boolean = true
val preProcess: ImportPreProcess = ImportPreProcess()
fun transformProperties(renderEntity: RenderEntity): RenderEntity? {
@Expose
var checked: Boolean = true
val preProcess: ImportPreProcess = ImportPreProcess()
fun transformProperties(renderEntity: RenderEntity, realm: Realm): RenderEntity? {
preProcess.realm = realm
val transformList = tableMap[renderEntity.code.toString()]?.transformer
if (transformList.isNullOrEmpty()) {
Log.e("qj", "子表转换为空===${renderEntity.code}")
@ -27,7 +30,7 @@ class ImportConfig {
Log.e("qj", "子表转换不为空===${renderEntity.code}")
for (transform in transformList) {
// 开始执行转换
val key:String = transform.k
val key: String = transform.k
val value = transform.v
val keylib = transform.klib
val valuelib = transform.vlib
@ -36,7 +39,10 @@ class ImportConfig {
continue
}
// 如果key和value都为空，说明当前数据需要增加一个新字段
if (key.isNullOrEmpty()&&value.isNullOrEmpty()&&!renderEntity.properties.containsKey(keylib)) {
if (key.isNullOrEmpty() && value.isNullOrEmpty() && !renderEntity.properties.containsKey(
keylib
)
) {
renderEntity.properties[keylib] = valuelib
continue
}
@ -44,26 +50,32 @@ class ImportConfig {
m@ for (k in processKeyOrValue(key)) {
if (renderEntity.properties.containsKey(k)) { // json配置的key可以匹配到数据
for (v in processKeyOrValue(value)) {
if ("~" == v ) { // ~符可以匹配任意元素
if ("~" == v) { // ~符可以匹配任意元素
if (valuelib.endsWith(")")) { // 以()结尾，说明该value配置是一个function，需要通过反射调用指定方法
// 获取方法名
val methodName = valuelib.substringBefore("(")
// 获取参数
val params: List<String> = valuelib.substringAfter("(").substringBefore(")").split(",").filter{ it.isNotEmpty() }.map { it.trim() }
val method = preProcess::class.members.filter { it.name == methodName }.first() as KFunction<*>
val params: List<String> =
valuelib.substringAfter("(").substringBefore(")").split(",")
.filter { it.isNotEmpty() }.map { it.trim() }
val method =
preProcess::class.members.filter { it.name == methodName }
.first() as KFunction<*>
val methodParams = method.parameters
val callByParams = mutableMapOf<KParameter, Any>(
methodParams[0] to preProcess,
methodParams[1] to renderEntity
methodParams[1] to renderEntity,
)
for ((index, value) in params.withIndex()) {
// 前2个参数确定为对象本身和RenderEntity，因此自定义参数从index+2开始设置
if (methodParams.size>index+2) {
callByParams[methodParams[index+2]] = value.replace("'", "")
if (methodParams.size > index + 2) {
callByParams[methodParams[index + 2]] =
value.replace("'", "")
}
}
when(val result = method.callBy(callByParams)) { // 如果方法返回的数据类型是boolean，且返回为false，则该数据不处理
when (val result =
method.callBy(callByParams)) { // 如果方法返回的数据类型是boolean，且返回为false，则该数据不处理
is Boolean ->
if (!result) {
return null
@ -78,8 +90,12 @@ class ImportConfig {
// 获取方法名
val methodName = valuelib.substringBefore("(")
// 获取参数
val params: List<String> = valuelib.substringAfter("(").substringBefore(")").split(",").filter{ it.isNotEmpty() }.map { it.trim() }
val method = preProcess::class.members.filter { it.name == methodName }.first() as KFunction<*>
val params: List<String> =
valuelib.substringAfter("(").substringBefore(")").split(",")
.filter { it.isNotEmpty() }.map { it.trim() }
val method =
preProcess::class.members.filter { it.name == methodName }
.first() as KFunction<*>
val methodParams = method.parameters
val callByParams = mutableMapOf<KParameter, Any>(
@ -88,11 +104,11 @@ class ImportConfig {
)
for ((index, value) in params.withIndex()) {
// 前2个参数确定为对象本身和RenderEntity，因此自定义参数从index+2开始设置
if (methodParams.size>index+2) {
callByParams[methodParams[index+2]] = value
if (methodParams.size > index + 2) {
callByParams[methodParams[index + 2]] = value
}
}
when(val result = method.callBy(callByParams)) {
when (val result = method.callBy(callByParams)) {
is Boolean ->
if (!result) {
return null
@ -107,6 +123,7 @@ class ImportConfig {
}
}
}
preProcess.realm = null
return renderEntity
}
@ -125,14 +142,15 @@ class TableInfo {
val zoomMin: Int = 16
val zoomMax: Int = 21
val checkLinkId: Boolean = true//是否需要校验linkid
val filterData : Boolean = false//是否需要过滤数据
val existSubCode : Boolean = false//是否存在子编码
val filterData: Boolean = false//是否需要过滤数据
val existSubCode: Boolean = false//是否存在子编码
val catch: Boolean = false//是否需要捕捉 // 需要根据丹丹提供的捕捉原则进行设置，参考文档W行设置条件，https://navinfo.feishu.cn/sheets/shtcnfsxKZhekU26ezBcHgl7aWh?sheet=BZd6yM
val catch: Boolean =
false//是否需要捕捉 // 需要根据丹丹提供的捕捉原则进行设置，参考文档W行设置条件，https://navinfo.feishu.cn/sheets/shtcnfsxKZhekU26ezBcHgl7aWh?sheet=BZd6yM
val name: String = ""
var checked : Boolean = true
var checked: Boolean = true
var transformer: MutableList<Transform> = mutableListOf()
var is3D : Boolean = false // 是否支持3D，默认情况下都不支持3D，在数据导入阶段会自动抹去Z轴高程信息
var is3D: Boolean = false // 是否支持3D，默认情况下都不支持3D，在数据导入阶段会自动抹去Z轴高程信息
}
class Transform {

663
app/src/main/java/com/navinfo/omqs/db/ImportOMDBHelper.kt
View File

@ -10,12 +10,10 @@ import com.blankj.utilcode.util.FileIOUtils
import com.blankj.utilcode.util.ZipUtils
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.navinfo.collect.library.data.entity.HadLinkDvoBean
import com.navinfo.collect.library.data.entity.LinkRelation
import com.navinfo.collect.library.data.entity.RenderEntity
import com.navinfo.collect.library.data.entity.TaskBean
import com.navinfo.collect.library.data.entity.*
import com.navinfo.collect.library.enums.DataCodeEnum
import com.navinfo.collect.library.utils.GeometryTools
import com.navinfo.collect.library.utils.StrZipUtil
import com.navinfo.omqs.Constant
import com.navinfo.omqs.Constant.Companion.currentInstallTaskConfig
import com.navinfo.omqs.Constant.Companion.currentInstallTaskFolder
@ -28,6 +26,7 @@ import dagger.assisted.AssistedInject
import io.realm.Realm
import io.realm.RealmConfiguration
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.withContext
@ -36,7 +35,9 @@ import org.locationtech.jts.geom.GeometryFactory
import org.locationtech.jts.geom.LineString
import org.locationtech.jts.geom.MultiLineString
import org.spatialite.database.SQLiteDatabase
import java.io.BufferedReader
import java.io.File
import java.io.FileReader
import java.util.*
import javax.inject.Inject
import kotlin.collections.HashMap
@ -46,8 +47,7 @@ import kotlin.streams.toList
* 导入omdb数据的帮助类
* */
class ImportOMDBHelper @AssistedInject constructor(
@Assisted("context") val context: Context,
@Assisted("omdbFile") val omdbFile: File
@Assisted("context") val context: Context, @Assisted("omdbFile") val omdbFile: File
) {
@Inject
lateinit var omdbHiltFactory: OMDBDataBaseHiltFactory
@ -56,13 +56,10 @@ class ImportOMDBHelper @AssistedInject constructor(
lateinit var gson: Gson
private val database by lazy {
omdbHiltFactory.obtainOmdbDataBaseHelper(
context,
omdbFile.absolutePath,
1
context, omdbFile.absolutePath, 1
).writableDatabase
}
private val configFile: File =
File("${Constant.USER_DATA_PATH}", Constant.OMDB_CONFIG)
private val configFile: File = File("${Constant.USER_DATA_PATH}", Constant.OMDB_CONFIG)
private val importConfigList by lazy {
openConfigFile()
@ -106,8 +103,14 @@ class ImportOMDBHelper @AssistedInject constructor(
}.toList()
val cursor = database.query(
table, finalColumns.toTypedArray(), "1=1",
mutableListOf<String>().toTypedArray(), null, null, null, null
table,
finalColumns.toTypedArray(),
"1=1",
mutableListOf<String>().toTypedArray(),
null,
null,
null,
null
)
with(cursor) {
if (moveToFirst()) {
@ -151,9 +154,11 @@ class ImportOMDBHelper @AssistedInject constructor(
suspend fun importOmdbZipFile(omdbZipFile: File, task: TaskBean): Flow<String> =
withContext(Dispatchers.IO) {
installTaskid = task.id.toString()
currentInstallTaskFolder = File(Constant.USER_DATA_PATH + "/$installTaskid")
// currentInstallTaskFolder = File(Constant.USER_DATA_PATH + "/$installTaskid")
currentInstallTaskFolder = File(Constant.USER_DATA_PATH + "/237")
if (!currentInstallTaskFolder.exists()) currentInstallTaskFolder.mkdirs()
currentInstallTaskConfig = RealmConfiguration.Builder()
currentInstallTaskConfig =
RealmConfiguration.Builder()
.directory(currentInstallTaskFolder)
.name("OMQS.realm")
.encryptionKey(Constant.PASSWORD)
@ -169,7 +174,6 @@ class ImportOMDBHelper @AssistedInject constructor(
unZipFolder.mkdirs()
// 开始解压zip文件
val unZipFiles = ZipUtils.unzipFile(omdbZipFile, unZipFolder)
// 先获取当前配置的所有图层的个数，方便后续计算数据解析进度
var tableNum = 0
var processIndex = 0
@ -180,10 +184,12 @@ class ImportOMDBHelper @AssistedInject constructor(
//单个表要素统计
var elementIndex = 0
//单个表要素时间统计
var tableImportTime = System.currentTimeMillis()
// var tableImportTime = System.currentTimeMillis()
//总表要素统计时间
var dataImportTime = System.currentTimeMillis()
val realm = Realm.getInstance(currentInstallTaskConfig)
// var dataImportTime = System.currentTimeMillis()
// Realm.compactRealm(currentInstallTaskConfig)
var realm = Realm.getInstance(currentInstallTaskConfig)
realm.beginTransaction()
for (importConfig in importConfigList) {
tableNum += importConfig.tableMap.size
@ -199,51 +205,49 @@ class ImportOMDBHelper @AssistedInject constructor(
// index++
}
val resHashMap: HashMap<String, RenderEntity> =
HashMap<String, RenderEntity>() //define empty hashmap
val resHashMap: HashMap<String, RenderEntity> = HashMap() //define empty hashmap
val listRenderEntity = mutableListOf<RenderEntity>()
val listRenderEntity1 = mutableListOf<RenderEntity1>()
try {
// var multipLine = MultiLineString(lineList, GeometryFactory())
// 遍历解压后的文件，读取该数据返回
Log.d("ImportOMDBHelper", "表解析===开始时间$dataImportTime===")
// Log.d("ImportOMDBHelper", "表解析===开始时间$dataImportTime===")
for (importConfig in importConfigList) {
for ((index, currentEntry) in importConfig.tableMap.entries.withIndex()) {
processIndex += 1
Log.d(
"ImportOMDBHelper",
"表解析===开始时间$tableImportTime===${currentEntry.value.table}"
)
Log.d(
"ImportOMDBHelper",
"表解析===processIndex${processIndex}====${processIndex}/${tableNum}"
)
val listResult = mutableListOf<RenderEntity>()
// Log.d(
// "ImportOMDBHelper",
// "表解析===开始时间$tableImportTime===${currentEntry.value.table}"
// )
// Log.d(
// "ImportOMDBHelper",
// "表解析===processIndex${processIndex}====${processIndex}/${tableNum}"
// )
// val listResult = mutableListOf<RenderEntity>()
val currentConfig = currentEntry.value
val txtFile = unZipFiles.find {
it.name == currentConfig.table
}
// 将listResult数据插入到Realm数据库中
currentConfig?.let {
val list = FileIOUtils.readFile2List(txtFile, "UTF-8")
Log.d("ImportOMDBHelper", "开始解析：${txtFile?.name}")
if (list != null) {
// 将list数据转换为map
for ((index, line) in list.withIndex()) {
if (txtFile != null) {
val fileReader = FileReader(txtFile)
val bufferedReader = BufferedReader(fileReader)
var line: String? = bufferedReader.readLine()
while (line != null) {
if (line == null || line.trim() == "") {
line = bufferedReader.readLine()
continue
}
elementIndex += 1
dataIndex += 1
Log.d("ImportOMDBHelper", "解析第：${index + 1}行")
// Log.d("ImportOMDBHelper", "解析第：${index + 1}行")
val map = gson.fromJson<Map<String, Any>>(
line,
object : TypeToken<Map<String, Any>>() {}.getType()
)
.toMutableMap()
line, object : TypeToken<Map<String, Any>>() {}.type
).toMutableMap()
map["qi_table"] = currentConfig.table
map["qi_name"] = currentConfig.name
map["qi_code"] =
@ -259,31 +263,30 @@ class ImportOMDBHelper @AssistedInject constructor(
renderEntity.taskId = task.id
renderEntity.zoomMin = map["qi_zoomMin"].toString().toInt()
renderEntity.zoomMax = map["qi_zoomMax"].toString().toInt()
// 在外层记录当前数据的linkPid
if (map.containsKey("linkPid")) {
renderEntity.linkPid =
map["linkPid"].toString().split(",")
?.get(0)
.toString()
map["linkPid"].toString().split(",")[0]
} else if (map.containsKey("linkList")) {
val linkList =
map["linkList"].toString()
val linkList = map["linkList"].toString()
if (!linkList.isNullOrEmpty() && linkList != "null") {
val list: List<LinkList> = gson.fromJson(
linkList,
object :
TypeToken<List<LinkList>>() {}.type
object : TypeToken<List<LinkList>>() {}.type
)
if (list != null) {
renderEntity.linkPid = list[0].linkPid
}
}
}
Log.e(
"jingo",
"安装数据 ${renderEntity.table} ${renderEntity.linkPid} ${elementIndex} ${insertIndex}"
)
renderEntity.geometry = map["geometry"].toString()
Log.d("ImportOMDBHelper", "解析===1处理3D")
// Log.d("ImportOMDBHelper", "解析===1处理3D")
// 其他数据插入到Properties中
/* if (!currentConfig.is3D) { // 如果是非3d要素，则自动将Z轴坐标全部置为0
/* if (!currentConfig.is3D) { // 如果是非3d要素，则自动将Z轴坐标全部置为0
val coordinates =
renderEntity.wkt?.coordinates?.map { coordinate ->
coordinate.z = 0.0
@ -306,115 +309,114 @@ class ImportOMDBHelper @AssistedInject constructor(
renderEntity.geometry = newGeometry.toString()
}
}*/
Log.d("ImportOMDBHelper", "解析===2处理3D")
Log.d("ImportOMDBHelper", "解析===1处理属性")
// Log.d("ImportOMDBHelper", "解析===2处理3D")
// Log.d("ImportOMDBHelper", "解析===1处理属性")
for ((key, value) in map) {
when (value) {
is String -> renderEntity.properties.put(key, value)
is Int -> renderEntity.properties.put(
key,
is String -> renderEntity.properties[key] = value
is Int -> renderEntity.properties[key] =
value.toInt().toString()
)
is Double -> renderEntity.properties.put(
key,
is Double -> renderEntity.properties[key] =
value.toDouble().toString()
)
else -> renderEntity.properties.put(
key,
else -> renderEntity.properties[key] =
value.toString()
)
}
}
Log.d("ImportOMDBHelper", "解析===2处理属性")
Log.d("ImportOMDBHelper", "解析===1处理name")
// Log.d("ImportOMDBHelper", "解析===2处理属性")
// Log.d("ImportOMDBHelper", "解析===1处理name")
// 如果properties中不包含name，那么自动将要素名称添加进properties中
if (!renderEntity.properties.containsKey("name")) {
renderEntity.properties["name"] = renderEntity.name;
}
Log.d("ImportOMDBHelper", "解析===2处理name")
Log.d("ImportOMDBHelper", "解析===1处理杆状物")
// Log.d("ImportOMDBHelper", "解析===2处理name")
// Log.d("ImportOMDBHelper", "解析===1处理杆状物")
if (currentConfig.filterData) {
when (renderEntity.code.toInt()) {
DataCodeEnum.OMDB_POLE.code.toInt() -> {
//过滤树类型的杆状物，无需导入到数据库中
val poleType =
renderEntity.properties["poleType"]
if (poleType != null && poleType.toInt() == 2) {
continue
}
}
// DataCodeEnum.OMDB_POLE.code.toInt() -> {
// //过滤树类型的杆状物，无需导入到数据库中
// val poleType =
// renderEntity.properties["poleType"]
// if (poleType != null && poleType.toInt() == 2) {
// line = bufferedReader.readLine()
// continue
// }
// }
DataCodeEnum.OMDB_LANE_MARK_BOUNDARYTYPE.code.toInt() -> {
var boundaryType =
renderEntity.properties["boundaryType"]
if (boundaryType != null) {
when (boundaryType.toInt()) {
0, 1, 6, 8, 9 -> {
renderEntity.enable = 0
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
continue
}
}
}
}
// DataCodeEnum.OMDB_LANE_MARK_BOUNDARYTYPE.code.toInt() -> {
// val boundaryType =
// renderEntity.properties["boundaryType"]
// if (boundaryType != null) {
// when (boundaryType.toInt()) {
// 0, 1, 6, 8, 9 -> {
// renderEntity.enable = 0
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
// line = bufferedReader.readLine()
// continue
// }
// }
// }
// }
DataCodeEnum.OMDB_RDBOUND_BOUNDARYTYPE.code.toInt() -> {
var boundaryType =
renderEntity.properties["boundaryType"]
if (boundaryType != null) {
when (boundaryType.toInt()) {
0, 1, 3, 4, 5, 7, 9 -> {
renderEntity.enable = 0
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
continue
}
}
}
}
// DataCodeEnum.OMDB_RDBOUND_BOUNDARYTYPE.code.toInt() -> {
// val boundaryType =
// renderEntity.properties["boundaryType"]
// if (boundaryType != null) {
// when (boundaryType.toInt()) {
// 0, 1, 3, 4, 5, 7, 9 -> {
// renderEntity.enable = 0
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
// line = bufferedReader.readLine()
// continue
// }
// }
// }
// }
DataCodeEnum.OMDB_OBJECT_STOPLOCATION.code.toInt() -> {
var locationType =
renderEntity.properties["locationType"]
if (locationType != null) {
when (locationType.toInt()) {
3, 4 -> {
renderEntity.enable = 0
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
continue
}
}
}
}
// DataCodeEnum.OMDB_OBJECT_STOPLOCATION.code.toInt() -> {
// val locationType =
// renderEntity.properties["locationType"]
// if (locationType != null) {
// when (locationType.toInt()) {
// 3, 4 -> {
// renderEntity.enable = 0
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
// line = bufferedReader.readLine()
// continue
// }
// }
// }
// }
DataCodeEnum.OMDB_RESTRICTION.code.toInt() -> {
if (renderEntity.properties.containsKey("linkIn") && renderEntity.properties.containsKey(
"linkOut"
)
) {
var linkIn =
val linkIn =
renderEntity.properties["linkIn"]
var linkOut =
val linkOut =
renderEntity.properties["linkOut"]
if (linkIn != null && linkOut != null) {
var checkMsg = "$linkIn$linkOut"
val checkMsg = "$linkIn$linkOut"
if (resHashMap.containsKey(checkMsg)) {
Log.e(
"qj",
"${renderEntity.name}==过滤交限linkin与linkout相同且存在多条数据"
)
// Log.e(
// "qj",
// "${renderEntity.name}==过滤交限linkin与linkout相同且存在多条数据"
// )
line = bufferedReader.readLine()
continue
} else {
resHashMap[checkMsg] = renderEntity
@ -426,40 +428,39 @@ class ImportOMDBHelper @AssistedInject constructor(
}
Log.d("ImportOMDBHelper", "解析===2处理杆状物")
Log.d("ImportOMDBHelper", "解析===1任务路线匹配")
// Log.d("ImportOMDBHelper", "解析===2处理杆状物")
// Log.d("ImportOMDBHelper", "解析===1任务路线匹配")
//遍历判断只显示与任务Link相关的任务数据
if (currentConfig.checkLinkId) {
if (renderEntity.properties.containsKey("linkPid")) {
if (renderEntity.linkPid.isNotEmpty()) {
var currentLinkPid =
renderEntity.properties["linkPid"]
val currentLinkPid = renderEntity.linkPid
Log.d(
"ImportOMDBHelper",
"解析===1任务路线匹配${currentLinkPid}"
)
// Log.d(
// "ImportOMDBHelper",
// "解析===1任务路线匹配${currentLinkPid}"
// )
if (!currentLinkPid.isNullOrEmpty() && currentLinkPid != "null") {
var list = currentLinkPid.split(",")
val list = currentLinkPid.split(",")
if (list != null && list.isNotEmpty()) {
if (list.isNotEmpty()) {
Log.d(
"ImportOMDBHelper",
"解析===1任务路线匹配${list.size}"
)
// Log.d(
// "ImportOMDBHelper",
// "解析===1任务路线匹配${list.size}"
// )
m@ for (linkPid in list) {
if (hashMap.containsKey(linkPid.toLong())) {
renderEntity.enable = 1
Log.e(
"qj",
"${renderEntity.name}==包括任务link"
)
// Log.e(
// "qj",
// "${renderEntity.name}==包括任务link"
// )
break@m
}
}
@ -473,20 +474,20 @@ class ImportOMDBHelper @AssistedInject constructor(
if (renderEntity.properties["linkList"] != null) {
Log.e(
"qj",
"linkList==开始${renderEntity.name}==${renderEntity.properties["linkList"]}}"
)
// Log.e(
// "qj",
// "linkList==开始${renderEntity.name}==${renderEntity.properties["linkList"]}}"
// )
val linkList =
renderEntity.properties["linkList"]
if (!linkList.isNullOrEmpty() && linkList != "null") {
Log.e(
"qj",
"linkList==${renderEntity.name}==${renderEntity.properties["linkList"]}}"
)
// Log.e(
// "qj",
// "linkList==${renderEntity.name}==${renderEntity.properties["linkList"]}}"
// )
val list: List<LinkList> = gson.fromJson(
linkList,
@ -494,32 +495,33 @@ class ImportOMDBHelper @AssistedInject constructor(
TypeToken<List<LinkList>>() {}.type
)
if (list != null) {
m@ for (link in list) {
if (hashMap.containsKey(link.linkPid.toLong())) {
renderEntity.enable = 1
Log.e(
"qj",
"${renderEntity.name}==包括任务link"
)
// Log.e(
// "qj",
// "${renderEntity.name}==包括任务link"
// )
break@m
}
}
}
}
}
} else {
//不包括linkPid直接过滤
continue
}
//过滤掉非任务路线上的数据
if (renderEntity.enable != 1) {
Log.e(
"qj",
"${renderEntity.name}==过滤不包括任务路线上的数据"
)
continue
}
// else {
// //不包括linkPid直接过滤
// line = bufferedReader.readLine()
// continue
// }
// //过滤掉非任务路线上的数据
// if (renderEntity.enable != 1) {
//// Log.e(
//// "qj",
//// "${renderEntity.name}==过滤不包括任务路线上的数据"
//// )
// line = bufferedReader.readLine()
// continue
// }
} else {
renderEntity.enable = 1
@ -535,10 +537,10 @@ class ImportOMDBHelper @AssistedInject constructor(
renderEntity.enable = 1
}
}*/
Log.e("qj", "${renderEntity.name}==不包括任务linkPid")
// Log.e("qj", "${renderEntity.name}==不包括任务linkPid")
}
Log.d("ImportOMDBHelper", "解析===2任务路线匹配")
Log.d("ImportOMDBHelper", "解析===1预处理")
// Log.d("ImportOMDBHelper", "解析===2任务路线匹配")
// Log.d("ImportOMDBHelper", "解析===1预处理")
if (currentConfig.catch) {
renderEntity.catchEnable = 1
@ -548,31 +550,31 @@ class ImportOMDBHelper @AssistedInject constructor(
// 对renderEntity做预处理后再保存
val resultEntity =
importConfig.transformProperties(renderEntity)
Log.d("ImportOMDBHelper", "解析===2预处理")
importConfig.transformProperties(renderEntity, realm)
// Log.d("ImportOMDBHelper", "解析===2预处理")
if (resultEntity != null) {
Log.d("ImportOMDBHelper", "解析===1子code处理")
// Log.d("ImportOMDBHelper", "解析===1子code处理")
//对code编码需要特殊处理 存在多个属性值时，渲染优先级：SA>PA,存在多个属性值时，渲染优先级：FRONTAGE>MAIN_SIDE_A CCESS
if (currentConfig.existSubCode) {
when (renderEntity.code.toInt()) {
DataCodeEnum.OMDB_LINK_ATTRIBUTE.code.toInt() -> {
Log.e("qj", "道路属性===0")
// Log.e("qj", "道路属性===0")
var type = renderEntity.properties["sa"]
if (type != null && type == "1") {
renderEntity.code =
DataCodeEnum.OMDB_LINK_ATTRIBUTE_SA.code
Log.e("qj", "道路属性===1")
// Log.e("qj", "道路属性===1")
} else {
type = renderEntity.properties["pa"]
if (type != null && type == "1") {
renderEntity.code =
DataCodeEnum.OMDB_LINK_ATTRIBUTE_PA.code
Log.e("qj", "道路属性===2")
// Log.e("qj", "道路属性===2")
} else {
type =
renderEntity.properties["frontage"]
@ -581,7 +583,7 @@ class ImportOMDBHelper @AssistedInject constructor(
DataCodeEnum.OMDB_LINK_ATTRIBUTE_FORNTAGE.code
renderEntity.zoomMin = 15
renderEntity.zoomMax = 17
Log.e("qj", "道路属性===3")
// Log.e("qj", "道路属性===3")
} else {
type =
renderEntity.properties["mainSideAccess"]
@ -590,18 +592,20 @@ class ImportOMDBHelper @AssistedInject constructor(
DataCodeEnum.OMDB_LINK_ATTRIBUTE_MAIN_SIDE_ACCESS.code
renderEntity.zoomMin = 15
renderEntity.zoomMax = 17
Log.e("qj", "道路属性===4")
} else {
renderEntity.enable = 0
renderEntity.zoomMin = 15
renderEntity.zoomMax = 17
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
Log.e("qj", "道路属性===5")
continue
// Log.e("qj", "道路属性===4")
}
// else {
// renderEntity.enable = 0
// renderEntity.zoomMin = 15
// renderEntity.zoomMax = 17
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
//// Log.e("qj", "道路属性===5")
// line = bufferedReader.readLine()
// continue
// }
}
}
}
@ -613,14 +617,14 @@ class ImportOMDBHelper @AssistedInject constructor(
DataCodeEnum.OMDB_BRIDGE_1.code
"2" -> renderEntity.code =
DataCodeEnum.OMDB_BRIDGE_2.code
// "3" -> renderEntity.code = DataCodeEnum.OMDB_BRIDGE_3.code
// "3" -> renderEntity.code = DataCodeEnum.OMDB_BRIDGE_3.code
else -> DataCodeEnum.OMDB_BRIDGE.code
}
}
DataCodeEnum.OMDB_RAMP.code.toInt() -> {
/*匝道*/
var formWay =
val formWay =
renderEntity.properties["formOfWay"]
if (formWay != null) {
when (formWay.toInt()) {
@ -650,7 +654,7 @@ class ImportOMDBHelper @AssistedInject constructor(
DataCodeEnum.OMDB_LINK_FORM1.code.toInt() -> {
/*道路形态1*/
var formWay =
val formWay =
renderEntity.properties["formOfWay"]
if (formWay != null) {
when (formWay.toInt()) {
@ -667,12 +671,12 @@ class ImportOMDBHelper @AssistedInject constructor(
}
DataCodeEnum.OMDB_LINK_FORM2.code.toInt() -> {
Log.e(
"qj",
"道路形态2${renderEntity.properties["formOfWay"]}"
)
// Log.e(
// "qj",
// "道路形态2${renderEntity.properties["formOfWay"]}"
// )
/*道路形态2*/
var formWay =
val formWay =
renderEntity.properties["formOfWay"]
if (formWay != null) {
when (formWay.toInt()) {
@ -720,7 +724,7 @@ class ImportOMDBHelper @AssistedInject constructor(
DataCodeEnum.OMDB_LANE_CONSTRUCTION.code.toInt() -> {
//特殊处理空数据，渲染原则使用
var startTime =
val startTime =
renderEntity.properties["startTime"]
if (startTime == null || startTime == "") {
renderEntity.properties["startTime"] =
@ -729,40 +733,42 @@ class ImportOMDBHelper @AssistedInject constructor(
}
}
if (renderEntity.table == DataCodeEnum.OMDB_NODE_FORM.name) {//特殊处理，因为code相同，使用表名判断
//过滤不需要渲染的要素
var formOfWay =
renderEntity.properties["formOfWay"]
if (formOfWay != null && formOfWay.toInt() == 30) {
renderEntity.enable = 2
renderEntity.code =
DataCodeEnum.OMDB_NODE_FORM.code
} else {
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
continue
}
} else if (renderEntity.table == DataCodeEnum.OMDB_NODE_PA.name) {//特殊处理，因为code相同，使用表名判断
//过滤不需要渲染的要素
var attributeType =
renderEntity.properties["attributeType"]
if (attributeType != null && attributeType.toInt() == 30) {
renderEntity.enable = 2
renderEntity.code =
DataCodeEnum.OMDB_NODE_PA.code
} else {
Log.e(
"qj",
"过滤不显示数据${renderEntity.table}"
)
continue
}
}
// if (renderEntity.table == DataCodeEnum.OMDB_NODE_FORM.name) {//特殊处理，因为code相同，使用表名判断
// //过滤不需要渲染的要素
// val formOfWay =
// renderEntity.properties["formOfWay"]
// if (formOfWay != null && formOfWay.toInt() == 30) {
// renderEntity.enable = 2
// renderEntity.code =
// DataCodeEnum.OMDB_NODE_FORM.code
// } else {
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
// line = bufferedReader.readLine()
// continue
// }
// } else if (renderEntity.table == DataCodeEnum.OMDB_NODE_PA.name) {//特殊处理，因为code相同，使用表名判断
// //过滤不需要渲染的要素
// val attributeType =
// renderEntity.properties["attributeType"]
// if (attributeType != null && attributeType.toInt() == 30) {
// renderEntity.enable = 2
// renderEntity.code =
// DataCodeEnum.OMDB_NODE_PA.code
// } else {
//// Log.e(
//// "qj",
//// "过滤不显示数据${renderEntity.table}"
//// )
// line = bufferedReader.readLine()
// continue
// }
// }
}
Log.d("ImportOMDBHelper", "解析===2子code处理")
// Log.d("ImportOMDBHelper", "解析===2子code处理")
++insertIndex
Log.e("qj", "统计==${insertIndex}")
@ -771,69 +777,156 @@ class ImportOMDBHelper @AssistedInject constructor(
renderEntity.properties.remove("geometry")
}
//移除该字段，减少数据量
if (renderEntity.properties.containsKey("linkPid")) {
renderEntity.properties.remove("linkPid")
}
// 如果当前解析的是OMDB_RD_LINK数据，将其缓存在预处理类中，以便后续处理其他要素时使用
if (currentConfig.code == DataCodeEnum.OMDB_RD_LINK.code.toInt()) {
if (renderEntity.linkRelation == null) {
renderEntity.linkRelation = LinkRelation()
}
renderEntity.linkRelation!!.linkPid =
renderEntity.linkPid
renderEntity.linkRelation!!.sNodeId =
renderEntity.properties["snodePid"]
renderEntity.linkRelation!!.eNodeId =
renderEntity.properties["enodePid"]
// 同时尝试更新RD_link的relation记录中的名称字段
renderEntity.linkRelation!!.linkPid =
renderEntity.properties["linkPid"]
?: UUID.randomUUID().toString()
}
renderEntity.propertiesDb = StrZipUtil.compress(
gson.toJson(renderEntity.properties).toString()
)
Log.d("ImportOMDBHelper", "解析===1insert")
realm.insert(renderEntity)
Log.d("ImportOMDBHelper", "解析===2insert")
}
if (currentConfig.code == DataCodeEnum.OMDB_RD_LINK.code.toInt()) {
listResult.add(renderEntity)
}
}
}
}
// 如果当前解析的是OMDB_RD_LINK数据，将其缓存在预处理类中，以便后续处理其他要素时使用
if (currentConfig.code == DataCodeEnum.OMDB_RD_LINK.code.toInt()) {
// importConfig.preProcess.cacheRdLink =
// listResult.associateBy { it.properties["linkPid"] }
// 将sNodeId和eNodeId放在外层关联对象中，优化查询效率
}
// 1个文件发送一次flow流
emit("${processIndex}/${tableNum}")
Log.d("ImportOMDBHelper", "表解析===2${currentConfig.table}")
Log.d(
"ImportOMDBHelper",
"表解析===结束用时时间${(System.currentTimeMillis() - tableImportTime)}===${currentEntry.value.table}===$elementIndex"
)
elementIndex = 0
tableImportTime = System.currentTimeMillis()
if (insertIndex % 20000 == 0 || currentEntry.value.table == DataCodeEnum.OMDB_RD_LINK.name) {
Log.d(
"ImportOMDBHelper",
"表解析===结束用时时间===事物开始"
)
realm.commitTransaction()
realm.refresh()
realm.beginTransaction()
Log.d(
"ImportOMDBHelper",
"表解析===结束用时时间===事物结束"
)
}
when (renderEntity.code) {
DataCodeEnum.OMDB_LANE_LINK_LG.code,
DataCodeEnum.OMDB_LINK_SPEEDLIMIT.code,
DataCodeEnum.OMDB_POLE.code,
DataCodeEnum.OMDB_LINK_DIRECT.code,
DataCodeEnum.OMDB_RD_LINK_FUNCTION_CLASS.code,
DataCodeEnum.OMDB_LINK_NAME.code,
DataCodeEnum.OMDB_OBJECT_ARROW.code,
DataCodeEnum.OMDB_TRAFFICLIGHT.code -> {
val renderEntity1 = RenderEntity1()
renderEntity1.code = resultEntity.code
renderEntity1.linkPid = renderEntity.linkPid
renderEntity1.table = renderEntity.table
renderEntity1.name = renderEntity.name
renderEntity1.linkRelation =
renderEntity.linkRelation
renderEntity1.catchEnable = renderEntity.catchEnable
renderEntity1.enable = renderEntity.enable
renderEntity1.geometry = renderEntity.geometry
renderEntity1.taskId = renderEntity.taskId
// renderEntity1.tileX = renderEntity.tileX
// renderEntity1.tileY = renderEntity.tileY
renderEntity1.tileXMin = renderEntity.tileXMin
renderEntity1.tileXMax = renderEntity.tileXMax
renderEntity1.tileYMin = renderEntity.tileYMin
renderEntity1.tileYMax = renderEntity.tileYMax
// renderEntity1.wkt = renderEntity.wkt
renderEntity1.zoomMin = renderEntity.zoomMin
renderEntity1.zoomMax = renderEntity.zoomMax
renderEntity1.propertiesDb =
renderEntity.propertiesDb
listRenderEntity1.add(renderEntity1)
}
else -> listRenderEntity.add(renderEntity)
}
// Log.d("ImportOMDBHelper", "解析===1insert")
// realm.insert(renderEntity)
// Log.d("ImportOMDBHelper", "解析===2insert")
}
// if (currentConfig.code == DataCodeEnum.OMDB_RD_LINK.code.toInt()) {
// listResult.add(renderEntity)
// }
if (listRenderEntity.size > 10000) {
Log.e(
"jingo", "20000刷新"
)
realm.copyToRealm(listRenderEntity)
realm.commitTransaction()
realm.close()
Log.d(
"ImportOMDBHelper",
"表解析===结束用时时间${(System.currentTimeMillis() - dataImportTime)}===$dataIndex===插入$insertIndex"
listRenderEntity.clear()
insertIndex = 0
delay(100)
// Realm.compactRealm(currentInstallTaskConfig)
realm = Realm.getInstance(currentInstallTaskConfig)
realm.beginTransaction()
}
if (listRenderEntity1.size > 10000) {
Log.e(
"jingo", "20000刷新"
)
realm.copyToRealm(listRenderEntity1)
realm.commitTransaction()
realm.close()
listRenderEntity1.clear()
insertIndex = 0
delay(100)
// Realm.compactRealm(currentInstallTaskConfig)
realm = Realm.getInstance(currentInstallTaskConfig)
realm.beginTransaction()
// Log.d(
// "ImportOMDBHelper",
// "表解析===结束用时时间===事物结束"
// )
}
line = bufferedReader.readLine()
}
bufferedReader.close()
}
// // 将listResult数据插入到Realm数据库中
// currentConfig.let {
// val list = FileIOUtils.readFile2List(txtFile, "UTF-8")
//// Log.d("ImportOMDBHelper", "开始解析：${txtFile?.name}")
// if (list != null) {
// // 将list数据转换为map
// for ((index, line) in list.withIndex()) {
//
// }
//
// }
// }
// // 如果当前解析的是OMDB_RD_LINK数据，将其缓存在预处理类中，以便后续处理其他要素时使用
// if (currentConfig.code == DataCodeEnum.OMDB_RD_LINK.code.toInt()) {
//// importConfig.preProcess.cacheRdLink =
//// listResult.associateBy { it.properties["linkPid"] }
// // 将sNodeId和eNodeId放在外层关联对象中，优化查询效率
// }
// 1个文件发送一次flow流
emit("${processIndex}/${tableNum}")
// Log.d("ImportOMDBHelper", "表解析===2${currentConfig.table}")
// Log.d(
// "ImportOMDBHelper",
// "表解析===结束用时时间${(System.currentTimeMillis() - tableImportTime)}===${currentEntry.value.table}===$elementIndex"
// )
elementIndex = 0
// tableImportTime = System.currentTimeMillis()
}
}
realm.copyToRealm(listRenderEntity)
realm.commitTransaction()
realm.close()
listRenderEntity.clear()
// Log.d(
// "ImportOMDBHelper",
// "表解析===结束用时时间${(System.currentTimeMillis() - dataImportTime)}===$dataIndex===插入$insertIndex"
// )
Log.e("qj", "安装结束")
} catch (e: Exception) {
if (realm.isInTransaction) {

101
app/src/main/java/com/navinfo/omqs/db/ImportPreProcess.kt
View File

@ -20,24 +20,23 @@ import java.util.*
class ImportPreProcess {
val code2NameMap = Code2NameMap()
// lateinit var cacheRdLink: Map<String?, RenderEntity>
// lateinit var cacheRdLink: Map<String?, RenderEntity>
val defaultTranslateDistance = 3.0
val testFlag: Boolean = false
var realm: Realm? = null
fun checkCircleRoad(renderEntity: RenderEntity): Boolean {
val linkInId = renderEntity.properties["linkIn"]
val linkOutId = renderEntity.properties["linkOut"]
// // 根据linkIn和linkOut获取对应的link数据
// val linkInEntity = cacheRdLink[linkInId]
// val linkOutEntity = cacheRdLink[linkOutId]
// 根据linkIn和linkOut从数据库获取对应的link数据
Realm.getInstance(Constant.currentInstallTaskConfig)
.use { realm ->
val linkInEntity = realm.where(RenderEntity::class.java)
realm?.let {
val linkInEntity = it.where(RenderEntity::class.java)
.equalTo("code", DataCodeEnum.OMDB_RD_LINK.code)
.and().equalTo("linkPid", linkInId)
.findFirst()
val linkOutEntity = realm.where(RenderEntity::class.java)
val linkOutEntity = it.where(RenderEntity::class.java)
.equalTo("code", DataCodeEnum.OMDB_RD_LINK.code)
.and().equalTo("linkPid", linkOutId)
.findFirst()
@ -55,6 +54,9 @@ class ImportPreProcess {
}
}
}
// // 根据linkIn和linkOut从数据库获取对应的link数据
// Realm.getInstance(Constant.currentInstallTaskConfig)
return true
}
@ -78,8 +80,8 @@ class ImportPreProcess {
}
}
// 如果是正向，则取最后一个点作为渲染图标的位置
var point = geometry!!.coordinates[geometry!!.coordinates.size-1]
if (isReverse){
var point = geometry!!.coordinates[geometry!!.coordinates.size - 1]
if (isReverse) {
// 逆向的话取第一个点作为渲染图标的位置
point = geometry.coordinates[0]
}
@ -214,16 +216,16 @@ class ImportPreProcess {
startGeometry!!.coordinates[startGeometry.numPoints - 1] // 获取这个geometry对应的结束点坐标
if (translateGeometry.geometryType == Geometry.TYPENAME_LINESTRING) { // 如果是线数据，则取倒数第二个点作为偏移的起止点
pointEnd =
translateGeometry!!.coordinates[translateGeometry.numPoints - 2] // 获取这个geometry对应的结束点坐标
translateGeometry.coordinates[translateGeometry.numPoints - 2] // 获取这个geometry对应的结束点坐标
}
if (startGeometry.geometryType == Geometry.TYPENAME_LINESTRING) { // 如果是线数据，则取倒数第二个点作为偏移的起止点
pointStart =
startGeometry!!.coordinates[startGeometry.numPoints - 2] // 获取这个geometry对应的结束点坐标
startGeometry.coordinates[startGeometry.numPoints - 2] // 获取这个geometry对应的结束点坐标
}
// 将这个起终点的线记录在数据中
val startEndReference = ReferenceEntity()
startEndReference.renderEntityId = renderEntity.id
// startEndReference.renderEntityId = renderEntity.id
startEndReference.name = "${renderEntity.name}参考线"
startEndReference.table = renderEntity.table
startEndReference.zoomMin = renderEntity.zoomMin
@ -253,7 +255,7 @@ class ImportPreProcess {
// 将这个起终点的线记录在数据中
val startReference = ReferenceEntity()
startReference.renderEntityId = renderEntity.id
// startReference.renderEntityId = renderEntity.id
startReference.name = "${renderEntity.name}参考点"
startReference.code = renderEntity.code
startReference.table = renderEntity.table
@ -290,7 +292,7 @@ class ImportPreProcess {
Log.e("qj", "generateS2EReferencePoint===1")
val endReference = ReferenceEntity()
endReference.renderEntityId = renderEntity.id
// endReference.renderEntityId = renderEntity.id
endReference.name = "${renderEntity.name}参考点"
endReference.code = renderEntity.code
endReference.table = renderEntity.table
@ -405,7 +407,7 @@ class ImportPreProcess {
val coorEnd = Coordinate(pointStart.getX() + dx, pointStart.getY() + dy, pointStart.z)
val angleReference = ReferenceEntity()
angleReference.renderEntityId = renderEntity.id
// angleReference.renderEntityId = renderEntity.id
angleReference.name = "${renderEntity.name}参考方向"
angleReference.table = renderEntity.table
angleReference.zoomMin = renderEntity.zoomMin
@ -492,7 +494,7 @@ class ImportPreProcess {
for (i in 0 until laneInfoDirectArray.length()) {
// 根据后续的数据生成辅助表数据
val referenceEntity = ReferenceEntity()
referenceEntity.renderEntityId = renderEntity.id
// referenceEntity.renderEntityId = renderEntity.id
referenceEntity.name = "${renderEntity.name}参考方向"
referenceEntity.table = renderEntity.table
referenceEntity.enable = renderEntity.enable
@ -500,7 +502,7 @@ class ImportPreProcess {
referenceEntity.zoomMin = renderEntity.zoomMin
referenceEntity.zoomMax = renderEntity.zoomMax
// 与原数据使用相同的geometry
referenceEntity.geometry = renderEntity.geometry.toString()
referenceEntity.geometry = renderEntity.geometry
referenceEntity.properties["qi_table"] = renderEntity.table
referenceEntity.properties["currentDirect"] =
laneInfoDirectArray[i].toString().split(",").distinct().joinToString("_")
@ -579,7 +581,7 @@ class ImportPreProcess {
}
// 获取最小的shape值，将其记录增加记录在properties的name属性下
if (shape != null) {
renderEntity.properties["name"] = shape["name"].toString()
renderEntity.properties["name"] = shape.optString("name", "")
} else {
renderEntity.properties["name"] = ""
}
@ -588,25 +590,25 @@ class ImportPreProcess {
/**
* 通过rdDirect对象向rdLink的relation字段
* */
fun addRdLinkDirect(renderEntity: RenderEntity) {
// 尝试更新RD_link的relation记录中的方向字段
val rdLinkEntity = queryRdLink(renderEntity.properties["linkPid"]!!)
if (rdLinkEntity?.linkRelation == null) {
rdLinkEntity?.linkRelation = LinkRelation()
}
rdLinkEntity?.linkRelation?.direct = renderEntity.properties["direct"]!!.toInt()
Realm.getInstance(Constant.currentInstallTaskConfig).insertOrUpdate(rdLinkEntity)
}
// fun addRdLinkDirect(renderEntity: RenderEntity) {
// // 尝试更新RD_link的relation记录中的方向字段
// val rdLinkEntity = queryRdLink(renderEntity.properties["linkPid"]!!)
// if (rdLinkEntity?.linkRelation == null) {
// rdLinkEntity?.linkRelation = LinkRelation()
// }
// rdLinkEntity?.linkRelation?.direct = renderEntity.properties["direct"]!!.toInt()
// Realm.getInstance(Constant.currentInstallTaskConfig).insertOrUpdate(rdLinkEntity)
// }
/**
* 查询指定的Rdlink数据
* */
fun queryRdLink(rdLinkId: String): RenderEntity? {
return Realm.getInstance(Constant.currentInstallTaskConfig).where(RenderEntity::class.java)
.equalTo("code", DataCodeEnum.OMDB_RD_LINK.code)
.and().equalTo("linkPid", rdLinkId)
.findFirst()
}
// fun queryRdLink(rdLinkId: String): RenderEntity? {
// //////// return Realm.getInstance(Constant.currentInstallTaskConfig).where(RenderEntity::class.java)
// .equalTo("code", DataCodeEnum.OMDB_RD_LINK.code)
// .and().equalTo("linkPid", rdLinkId)
// .findFirst()
// }
/**
* 生成电子眼对应的渲染名称
@ -626,12 +628,15 @@ class ImportPreProcess {
* 生成车道中心线面宽度
* */
fun generateAddWidthLine(renderEntity: RenderEntity) {
try {
// 添加车道中心面渲染原则，根据车道宽度进行渲染
val angleReference = ReferenceEntity()
angleReference.renderEntityId = renderEntity.id
// angleReference.renderEntityId = renderEntity.id
angleReference.name = "${renderEntity.name}车道中线面"
angleReference.table = renderEntity.table
angleReference.geometry = GeometryTools.createGeometry(renderEntity.geometry).buffer(0.000035).toString()//GeometryTools.computeLine(0.000035,0.000035,renderEntity.geometry)
angleReference.geometry =
GeometryTools.createGeometry(renderEntity.geometry).buffer(0.000035)
.toString()//GeometryTools.computeLine(0.000035,0.000035,renderEntity.geometry)
angleReference.properties["qi_table"] = renderEntity.table
angleReference.properties["widthProperties"] = "3"
angleReference.zoomMin = renderEntity.zoomMin
@ -641,6 +646,10 @@ class ImportPreProcess {
val listResult = mutableListOf<ReferenceEntity>()
listResult.add(angleReference)
insertData(listResult)
} catch (e: Exception) {
Log.e("jingo", "车道中心线 generateAddWidthLine ${e.message}")
}
}
@ -656,7 +665,7 @@ class ImportPreProcess {
for (i in 0 until nodeListJsonArray.length()) {
val nodeJSONObject = nodeListJsonArray.getJSONObject(i)
val intersectionReference = ReferenceEntity()
intersectionReference.renderEntityId = renderEntity.id
// intersectionReference.renderEntityId = renderEntity.id
intersectionReference.name = "${renderEntity.name}参考点"
intersectionReference.code = renderEntity.code
intersectionReference.table = renderEntity.table
@ -823,7 +832,7 @@ class ImportPreProcess {
val coorEnd = Coordinate(pointStart.getX() + dx, pointStart.getY() + dy, pointStart.z)
val dynamicSrcReference = ReferenceEntity()
dynamicSrcReference.renderEntityId = renderEntity.id
// dynamicSrcReference.renderEntityId = renderEntity.id
dynamicSrcReference.name = "${renderEntity.name}动态icon"
dynamicSrcReference.table = renderEntity.table
dynamicSrcReference.zoomMin = renderEntity.zoomMin
@ -842,15 +851,18 @@ class ImportPreProcess {
insertData(listResult)
}
private fun insertData(list:List<ReferenceEntity>){
private fun insertData(list: List<ReferenceEntity>) {
realm?.let {
Log.e("qj", "子表插入==")
if(list!=null&& list.isNotEmpty()){
if (list != null && list.isNotEmpty()) {
Log.e("qj", "子表插入开始==")
Realm.getInstance(Constant.currentInstallTaskConfig).insert(list)
it.insert(list)
Log.e("qj", "子表插入结束==")
}
}
}
/**
* 向当前renderEntity中添加动态属性
* */
@ -894,7 +906,8 @@ class ImportPreProcess {
val coorEnd = Coordinate(pointStart.getX() + dx, pointStart.getY() + dy, pointStart.z)
// renderEntity.geometry = WKTWriter(3).write(GeometryTools.createLineString(arrayOf(pointStart, coorEnd)))
renderEntity.geometry = GeometryTools.createGeometry(GeoPoint(centerPoint!!.y, centerPoint.x)).toString()
renderEntity.geometry =
GeometryTools.createGeometry(GeoPoint(centerPoint!!.y, centerPoint.x)).toString()
val code = renderEntity.properties["signType"]
renderEntity.properties["src"] = "assets:omdb/appendix/1105_${code}_0.svg"
}
@ -930,9 +943,11 @@ class ImportPreProcess {
val listResult = mutableListOf<ReferenceEntity>()
val coorEnd = Coordinate(pointStart.getX() + dx, pointStart.getY() + dy, pointStart.z)
renderEntity.geometry = WKTWriter(3).write(GeometryTools.createLineString(arrayOf(pointStart, coorEnd)))
renderEntity.geometry =
WKTWriter(3).write(GeometryTools.createLineString(arrayOf(pointStart, coorEnd)))
} else {
renderEntity.geometry = GeometryTools.createGeometry(GeoPoint(centerPoint!!.y, centerPoint.x)).toString()
renderEntity.geometry =
GeometryTools.createGeometry(GeoPoint(centerPoint!!.y, centerPoint.x)).toString()
}
}
}

15
app/src/main/java/com/navinfo/omqs/db/RealmOperateHelper.kt
View File

@ -65,13 +65,12 @@ class RealmOperateHelper() {
val yEnd = tileYSet.stream().max(Comparator.naturalOrder()).orElse(null)
// 查询realm中对应tile号的数据
// val realm = getSelectTaskRealmInstance()
val sql =
" ((tileXMin <= $xStart and tileXMax >= $xStart) or (tileXMin <=$xEnd and tileXMax >=$xStart)) and ((tileYMin <= $yStart and tileYMax >= $yStart) or (tileYMin <=$yEnd and tileYMin >=$yStart))"
val realmList =
getSelectTaskRealmTools(realm, RenderEntity::class.java, false)
.equalTo("table", DataCodeEnum.OMDB_LINK_DIRECT.name)
.greaterThanOrEqualTo("tileX", xStart)
.lessThanOrEqualTo("tileX", xEnd)
.greaterThanOrEqualTo("tileY", yStart)
.lessThanOrEqualTo("tileY", yEnd)
.rawPredicate(sql)
.findAll()
// 将获取到的数据和查询的polygon做相交，只返回相交的数据
val dataList = realm.copyFromRealm(realmList)
@ -285,11 +284,11 @@ class RealmOperateHelper() {
val yEnd = tileYSet.stream().max(Comparator.naturalOrder()).orElse(null)
val realm = getSelectTaskRealmInstance()
var realmList = mutableListOf<RenderEntity>()
val sql =
" ((tileXMin <= $xStart and tileXMax >= $xStart) or (tileXMin <=$xEnd and tileXMax >=$xStart)) and ((tileYMin <= $yStart and tileYMax >= $yStart) or (tileYMin <=$yEnd and tileYMin >=$yStart))"
val realmQuery = getSelectTaskRealmTools(realm, RenderEntity::class.java, false)
.greaterThanOrEqualTo("tileX", xStart)
.lessThanOrEqualTo("tileX", xEnd)
.greaterThanOrEqualTo("tileY", yStart)
.lessThanOrEqualTo("tileY", yEnd)
.rawPredicate(sql)
// 筛选不显示的数据
if (catchAll) {
// 查询realm中对应tile号的数据

14
app/src/main/java/com/navinfo/omqs/hilt/GlobalModule.kt
View File

@ -154,20 +154,6 @@ class GlobalModule {
)
}
// /**
// * realm 注册
// */
// @Provides
// @Singleton
// fun provideRealmService(context: Application): RealmCoroutineScope {
// return RealmCoroutineScope(context)
// }
// @Singleton
// @Provides
// fun provideRealmDefaultInstance(): Realm {
// return Realm.getDefaultInstance()
// }
@Singleton
@Provides

5
app/src/main/java/com/navinfo/omqs/ui/activity/login/LoginActivity.kt
View File

@ -1,7 +1,5 @@
package com.navinfo.omqs.ui.activity.login
import android.app.Activity
import android.app.ActivityManager
import android.content.Intent
import android.os.Bundle
import android.util.DisplayMetrics
@ -11,7 +9,6 @@ import androidx.activity.viewModels
import androidx.appcompat.app.AlertDialog
import androidx.databinding.DataBindingUtil
import androidx.lifecycle.Observer
import androidx.lifecycle.viewModelScope
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.navinfo.omqs.R
import com.navinfo.omqs.databinding.ActivityLoginBinding
@ -19,8 +16,6 @@ import com.navinfo.omqs.ui.activity.CheckPermissionsActivity
import com.navinfo.omqs.ui.activity.map.MainActivity
import com.umeng.commonsdk.UMConfigure
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
/**
* 登陆页面

3
app/src/main/java/com/navinfo/omqs/ui/activity/map/MainViewModel.kt
View File

@ -342,6 +342,8 @@ class MainViewModel @Inject constructor(
Constant.currentSelectTaskConfig =
RealmConfiguration.Builder().directory(Constant.currentSelectTaskFolder)
.name("OMQS.realm").encryptionKey(Constant.PASSWORD)
// .assetFile("${Constant.currentSelectTaskFolder}/OMQS.realm")
// .readOnly()
// .allowQueriesOnUiThread(true)
.schemaVersion(2).build()
MapParamUtils.setTaskConfig(Constant.currentSelectTaskConfig)
@ -353,7 +355,6 @@ class MainViewModel @Inject constructor(
if (naviEngineStatus == 1) {
naviEngineNew.let {
// naviMutex.lock()
Log.e("jingo","${Thread.currentThread().name} ${Thread.currentThread().hashCode()}")
if (testRealm == null)
testRealm = realmOperateHelper.getSelectTaskRealmInstance()
if (currentTaskBean != null) {

25
app/src/main/java/com/navinfo/omqs/ui/fragment/tasklist/TaskViewModel.kt
View File

@ -107,7 +107,8 @@ class TaskViewModel @Inject constructor(
if (currentSelectTaskBean == null) {
liveDataToastMessage.postValue("还没有开启任何任务")
} else {
val links = realmOperateHelper.queryLink(realm,
val links = realmOperateHelper.queryLink(
realm,
point = point,
)
if (links.isNotEmpty()) {
@ -184,7 +185,7 @@ class TaskViewModel @Inject constructor(
if (task.syncStatus != FileManager.Companion.FileUploadStatus.DONE) {
//赋值时间，用于查询过滤
task.operationTime = DateTimeUtil.getNowDate().time
}else{//已上传数据不做更新
} else {//已上传数据不做更新
continue
}
} else {
@ -194,7 +195,7 @@ class TaskViewModel @Inject constructor(
//赋值时间，用于查询过滤
task.operationTime = DateTimeUtil.getNowDate().time
}
realm.copyToRealmOrUpdate(task)
it.copyToRealmOrUpdate(task)
}
}
@ -273,10 +274,15 @@ class TaskViewModel @Inject constructor(
liveDataTaskLinks.value = taskBean.hadLinkDvoList
showTaskLinks(taskBean)
MapParamUtils.setTaskId(taskBean.id)
Constant.currentSelectTaskFolder = File(Constant.USER_DATA_PATH + "/${taskBean.id}")
// Constant.currentSelectTaskFolder = File(Constant.USER_DATA_PATH + "/${taskBean.id}")
Constant.currentSelectTaskFolder = File(Constant.USER_DATA_PATH + "/237")
Constant.currentSelectTaskConfig =
RealmConfiguration.Builder().directory(Constant.currentSelectTaskFolder)
.name("OMQS.realm").encryptionKey(Constant.PASSWORD)
RealmConfiguration.Builder()
.directory(Constant.currentSelectTaskFolder)
.name("OMQS.realm")
.encryptionKey(Constant.PASSWORD)
// .assetFile("${Constant.currentSelectTaskFolder}/OMQS.realm")
// .readOnly()
//.allowQueriesOnUiThread(true)
.schemaVersion(2).build()
MapParamUtils.setTaskConfig(Constant.currentSelectTaskConfig)
@ -574,7 +580,7 @@ class TaskViewModel @Inject constructor(
}
//根据Link数据查询对应数据上要素，对要素进行显示重置
data.properties["linkPid"]?.let {
realmOperateHelper.queryLinkToMutableRenderEntityList(realm,it)
realmOperateHelper.queryLinkToMutableRenderEntityList(realm, it)
?.forEach { renderEntity ->
if (renderEntity.enable != 1) {
renderEntity.enable = 1
@ -629,7 +635,10 @@ class TaskViewModel @Inject constructor(
//重置数据为隐藏
if (hadLinkDvoBean.linkStatus == 2) {
realmOperateHelper.queryLinkToMutableRenderEntityList(realm,hadLinkDvoBean.linkPid)
realmOperateHelper.queryLinkToMutableRenderEntityList(
realm,
hadLinkDvoBean.linkPid
)
?.forEach { renderEntity ->
if (renderEntity.enable == 1) {
renderEntity.enable = 0

11
collect-library/src/main/java/com/navinfo/collect/library/data/entity/LinkRelation.kt
View File

@ -21,16 +21,7 @@ import java.util.*
* */
@Parcelize
open class LinkRelation() : RealmObject(), Parcelable {
@PrimaryKey
var linkPid:String = UUID.randomUUID().toString()
@Index
var linkPid:String = ""
var sNodeId: String? = null
@Index
var eNodeId: String? = null
var direct: Int = 0
constructor(direct: Int) : this() {
this.direct = direct
}
}

29
collect-library/src/main/java/com/navinfo/collect/library/data/entity/ReferenceEntity.kt
View File

@ -14,21 +14,25 @@ import java.util.*
* 渲染要素对应的实体
* */
open class ReferenceEntity() : RealmObject() {
@PrimaryKey
var id: String = UUID.randomUUID().toString() // id
var renderEntityId: String = "" // 参考的renderEntity的Id
// @PrimaryKey
// var id: Int = 0 // id
// var renderEntityId: Int = 0 // 参考的renderEntity的Id
@Ignore
lateinit var name: String //要素名
lateinit var table: String //要素表名
var code: String = "0" // 要素编码
@Ignore
var zoomMin: Int = 18 //显示最小级别
@Ignore
var zoomMax: Int = 23 //显示最大级别
var taskId: Int = 0 //任务ID
var enable:Int = 0 // 默认0不是显示 1为渲染显示
var tileXMin:Int =0
var tileXMax:Int = 0
var tileYMin:Int =0
var tileYMax:Int = 0
var geometry: String = "" // 要素渲染参考的geometry，该数据可能会在导入预处理环节被修改，原始geometry会保存在properties的geometry字段下
var enable: Int = 0 // 默认0不是显示 1为渲染显示
var tileXMin: Int = 0
var tileXMax: Int = 0
var tileYMin: Int = 0
var tileYMax: Int = 0
var geometry: String =
"" // 要素渲染参考的geometry，该数据可能会在导入预处理环节被修改，原始geometry会保存在properties的geometry字段下
get() {
wkt = GeometryTools.createGeometry(field)
return field
@ -64,11 +68,16 @@ open class ReferenceEntity() : RealmObject() {
}
return field
}
@Ignore
var properties: RealmDictionary<String> = RealmDictionary()
@Ignore
var tileX: RealmSet<Int> = RealmSet() // x方向的tile编码
@Ignore
var tileY: RealmSet<Int> = RealmSet() // y方向的tile编码
constructor(name: String): this() {
constructor(name: String) : this() {
this.name = name
}
}

54
collect-library/src/main/java/com/navinfo/collect/library/data/entity/RenderEntity.kt
View File

@ -1,9 +1,12 @@
package com.navinfo.collect.library.data.entity
import android.os.Parcelable
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.navinfo.collect.library.system.Constant
import com.navinfo.collect.library.utils.GeometryTools
import com.navinfo.collect.library.utils.GeometryToolsKt
import com.navinfo.collect.library.utils.StrZipUtil
import io.realm.RealmDictionary
import io.realm.RealmObject
import io.realm.RealmSet
@ -15,24 +18,35 @@ import org.locationtech.jts.geom.Coordinate
import org.locationtech.jts.geom.Geometry
import org.oscim.core.MercatorProjection
import java.util.*
import java.util.zip.GZIPInputStream
/**
* 渲染要素对应的实体
* */
@Parcelize
open class RenderEntity() : RealmObject(), Parcelable {
@PrimaryKey
var id: String = UUID.randomUUID().toString() // id
// @PrimaryKey
// var id: String = UUID.randomUUID().toString() // id
lateinit var name: String //要素名
lateinit var table: String //要素表名
var code: String = "0" // 要素编码
var geometry: String = "" // 要素渲染参考的geometry，该数据可能会在导入预处理环节被修改，原始geometry会保存在properties的geometry字段下
// var geometryDb: String = ""
var geometry: String =
"" // 要素渲染参考的geometry，该数据可能会在导入预处理环节被修改，原始geometry会保存在properties的geometry字段下
get() {
wkt = GeometryTools.createGeometry(field)
return field
}
// get() {
// if (geometryDb != null && geometryDb.isNotEmpty() && field.isEmpty()) {
// field = StrZipUtil.uncompress(geometryDb)
// }
// return field
// }
set(value) {
field = value
// geometryDb = StrZipUtil.compress(value)
// 根据geometry自动计算当前要素的x-tile和y-tile
GeometryToolsKt.getTileXByGeometry(value, tileX)
@ -64,22 +78,40 @@ open class RenderEntity() : RealmObject(), Parcelable {
}
return field
}
@Ignore
var properties: RealmDictionary<String> = RealmDictionary()
get() {
if (propertiesDb != null && propertiesDb.isNotEmpty() && field.isEmpty()) {
try {
val gson = Gson()
val type = object : TypeToken<List<RealmDictionary<String>>>() {}.type
field = gson.fromJson(StrZipUtil.uncompress(propertiesDb), type)
} catch (e: Exception) {
}
}
return field
}
var propertiesDb: String = ""
@Ignore
var tileX: RealmSet<Int> = RealmSet() // x方向的tile编码
@Ignore
var tileY: RealmSet<Int> = RealmSet() // y方向的tile编码
var tileXMin:Int =0
var tileXMax:Int = 0
var tileYMin:Int =0
var tileYMax:Int = 0
var tileXMin: Int = 0
var tileXMax: Int = 0
var tileYMin: Int = 0
var tileYMax: Int = 0
var taskId: Int = 0 //任务ID
var zoomMin: Int = 18 //显示最小级别
var zoomMax: Int = 23 //显示最大级别
var enable:Int = 0 // 默认0不是显示 1为渲染显示 2为常显
var catchEnable:Int = 0 // 0不捕捉 1捕捉
@Index
lateinit var linkPid: String // RenderEntity关联的linkPid集合(可能会关联多个)
var enable: Int = 0 // 默认0不是显示 1为渲染显示 2为常显
var catchEnable: Int = 0 // 0不捕捉 1捕捉
var linkPid: String = "" // RenderEntity关联的linkPid集合(可能会关联多个)
var linkRelation: LinkRelation? = null
constructor(name: String) : this() {

40
collect-library/src/main/java/com/navinfo/collect/library/data/entity/RenderEntity1.kt Normal file
View File

@ -0,0 +1,40 @@
package com.navinfo.collect.library.data.entity
import android.os.Parcelable
import com.navinfo.collect.library.utils.GeometryTools
import com.navinfo.collect.library.utils.GeometryToolsKt
import io.realm.RealmDictionary
import io.realm.RealmObject
import io.realm.RealmSet
import io.realm.annotations.Ignore
import io.realm.annotations.Index
import kotlinx.parcelize.Parcelize
import org.locationtech.jts.geom.Geometry
/**
* 渲染要素对应的实体
* */
@Parcelize
open class RenderEntity1() : RealmObject(), Parcelable {
lateinit var name: String //要素名
lateinit var table: String //要素表名
var code: String = "0" // 要素编码
var geometry: String = ""
var propertiesDb: String = ""
var tileXMin: Int = 0
var tileXMax: Int = 0
var tileYMin: Int = 0
var tileYMax: Int = 0
var taskId: Int = 0 //任务ID
var zoomMin: Int = 18 //显示最小级别
var zoomMax: Int = 23 //显示最大级别
var enable: Int = 0 // 默认0不是显示 1为渲染显示 2为常显
var catchEnable: Int = 0 // 0不捕捉 1捕捉
var linkPid: String = "" // RenderEntity关联的linkPid集合(可能会关联多个)
var linkRelation: LinkRelation? = null
constructor(name: String) : this() {
this.name = name
}
}

7
collect-library/src/main/java/com/navinfo/collect/library/map/source/OMDBReferenceDataSource.java
View File

@ -110,13 +110,12 @@ public class OMDBReferenceDataSource implements ITileDataSource {
@Override
public void cancel() {
if (Realm.getDefaultInstance().isInTransaction()) {
Realm.getDefaultInstance().cancelTransaction();
}
// if (Realm.getDefaultInstance().isInTransaction()) {
// Realm.getDefaultInstance().cancelTransaction();
// }
}
public void update() {
isUpdate = true;
Log.e("qj", Thread.currentThread().getName());
}
}

7
collect-library/src/main/java/com/navinfo/collect/library/map/source/OMDBTileDataSource.java
View File

@ -207,13 +207,12 @@ public class OMDBTileDataSource implements ITileDataSource {
@Override
public void cancel() {
if (Realm.getDefaultInstance().isInTransaction()) {
Realm.getDefaultInstance().cancelTransaction();
}
// if (Realm.getDefaultInstance().isInTransaction()) {
// Realm.getDefaultInstance().cancelTransaction();
// }
}
public void update() {
isUpdate = true;
Log.e("qj", Thread.currentThread().getName());
}
}

2
collect-library/src/main/java/com/navinfo/collect/library/map/source/OMDBTileSource.java
View File

@ -27,7 +27,7 @@ public class OMDBTileSource extends RealmDBTileSource {
@Override
public OpenResult open() {
Log.d("qj", Realm.getDefaultInstance().where(RenderEntity.class).findAll().size()+"open安装数量");
// Log.d("qj", Realm.getDefaultInstance().where(RenderEntity.class).findAll().size()+"open安装数量");
return OpenResult.SUCCESS;
}

47
collect-library/src/main/java/com/navinfo/collect/library/map/source/RealmDBTileDataSource.java
View File

@ -35,27 +35,28 @@ public class RealmDBTileDataSource implements ITileDataSource {
public void query(MapTile tile, ITileDataSink mapDataSink) {
// 获取tile对应的坐标范围
if (tile.zoomLevel>=15&&tile.zoomLevel<=Constant.OVER_ZOOM) {
int m = Constant.OVER_ZOOM-tile.zoomLevel;
int xStart = (int)tile.tileX<<m;
int xEnd = (int)((tile.tileX+1)<<m);
int yStart = (int)tile.tileY<<m;
int yEnd = (int)((tile.tileY+1)<<m);
RealmQuery<GeometryFeatureEntity> realmQuery = Realm.getDefaultInstance().where(GeometryFeatureEntity.class)
.rawPredicate("tileX>="+xStart+" and tileX<="+xEnd+" and tileY>="+yStart+" and tileY<="+yEnd);
// 筛选不显示的数据
if (Constant.HAD_LAYER_INVISIABLE_ARRAY!=null&&Constant.HAD_LAYER_INVISIABLE_ARRAY.length>0) {
realmQuery.beginGroup();
for (String type: Constant.HAD_LAYER_INVISIABLE_ARRAY) {
realmQuery.notEqualTo("name", type);
}
realmQuery.endGroup();
}
List<GeometryFeatureEntity> listResult = realmQuery.distinct("id").findAll();
mThreadLocalDecoders.get().decode(tile, mapDataSink, listResult);
mapDataSink.completed(QueryResult.SUCCESS);
Realm.getDefaultInstance().close();
// int m = Constant.OVER_ZOOM-tile.zoomLevel;
// int xStart = (int)tile.tileX<<m;
// int xEnd = (int)((tile.tileX+1)<<m);
// int yStart = (int)tile.tileY<<m;
// int yEnd = (int)((tile.tileY+1)<<m);
//
// RealmQuery<GeometryFeatureEntity> realmQuery = Realm.getDefaultInstance().where(GeometryFeatureEntity.class)
// .rawPredicate("tileX>="+xStart+" and tileX<="+xEnd+" and tileY>="+yStart+" and tileY<="+yEnd);
// // 筛选不显示的数据
// if (Constant.HAD_LAYER_INVISIABLE_ARRAY!=null&&Constant.HAD_LAYER_INVISIABLE_ARRAY.length>0) {
// realmQuery.beginGroup();
// for (String type: Constant.HAD_LAYER_INVISIABLE_ARRAY) {
// realmQuery.notEqualTo("name", type);
// }
// realmQuery.endGroup();
// }
// List<GeometryFeatureEntity> listResult = realmQuery.distinct("id").findAll();
// mThreadLocalDecoders.get().decode(tile, mapDataSink, listResult);
// mapDataSink.completed(QueryResult.SUCCESS);
// Realm.getDefaultInstance().close();
// Log.d("RealmDBTileDataSource", "tile:"+tile.getBoundingBox().toString());
mapDataSink.completed(QueryResult.SUCCESS);
} else {
mapDataSink.completed(QueryResult.SUCCESS);
}
@ -68,8 +69,8 @@ public class RealmDBTileDataSource implements ITileDataSource {
@Override
public void cancel() {
if (Realm.getInstance(RealmUtils.getInstance().getRealmConfiguration()).isInTransaction()) {
Realm.getInstance(RealmUtils.getInstance().getRealmConfiguration()).cancelTransaction();
}
// if (Realm.getInstance(RealmUtils.getInstance().getRealmConfiguration()).isInTransaction()) {
// Realm.getInstance(RealmUtils.getInstance().getRealmConfiguration()).cancelTransaction();
// }
}
}

282
collect-library/src/main/java/com/navinfo/collect/library/utils/StrZipUtil.kt Normal file
View File

@ -0,0 +1,282 @@
package com.navinfo.collect.library.utils
import sun.misc.BASE64Decoder
import sun.misc.BASE64Encoder
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.io.IOException
import java.util.*
import java.util.zip.*
object StrZipUtil {
/**
* @param input 需要压缩的字符串
* @return 压缩后的字符串
* @throws IOException IO
*/
fun compress(input: String): String {
if (input.isEmpty()) {
return input
}
try {
val out = ByteArrayOutputStream()
val gzipOs = GZIPOutputStream(out)
gzipOs.write(input.toByteArray())
gzipOs.close()
return BASE64Encoder().encode(out.toByteArray())
} catch (e: Exception) {
return input
}
}
/**
* @param zippedStr 压缩后的字符串
* @return 解压缩后的
* @throws IOException IO
*/
fun uncompress(zippedStr: String): String {
if (zippedStr.isEmpty()) {
return zippedStr
}
try {
val out = ByteArrayOutputStream()
val `in` = ByteArrayInputStream(
BASE64Decoder().decodeBuffer(zippedStr)
)
val gzipIs = GZIPInputStream(`in`)
val buffer = ByteArray(256)
var n: Int
while (gzipIs.read(buffer).also { n = it } >= 0) {
out.write(buffer, 0, n)
}
// toString()使用平台默认编码，也可以显式的指定如toString("GBK")
return out.toString()
} catch (e: Exception) {
return zippedStr
}
}
/***
* 压缩GZip
*
* @param data
* @return
*/
fun gZip(data: ByteArray?): ByteArray? {
var b: ByteArray? = null
try {
val bos = ByteArrayOutputStream()
val gzip = GZIPOutputStream(bos)
gzip.write(data)
gzip.finish()
gzip.close()
b = bos.toByteArray()
bos.close()
} catch (ex: java.lang.Exception) {
ex.printStackTrace()
}
return b
}
/***
* 解压GZip
*
* @param data
* @return
*/
fun unGZip(data: ByteArray?): ByteArray? {
var b: ByteArray? = null
try {
val bis = ByteArrayInputStream(data)
val gzip = GZIPInputStream(bis)
val buf = ByteArray(1024)
var num = -1
val baos = ByteArrayOutputStream()
while (gzip.read(buf, 0, buf.size).also { num = it } != -1) {
baos.write(buf, 0, num)
}
b = baos.toByteArray()
baos.flush()
baos.close()
gzip.close()
bis.close()
} catch (ex: java.lang.Exception) {
ex.printStackTrace()
}
return b
}
/***
* 压缩Zip
*
* @param data
* @return
*/
fun zip(data: ByteArray): ByteArray? {
var b: ByteArray? = null
try {
val bos = ByteArrayOutputStream()
val zip = ZipOutputStream(bos)
val entry = ZipEntry("zip")
entry.size = data.size.toLong()
zip.putNextEntry(entry)
zip.write(data)
zip.closeEntry()
zip.close()
b = bos.toByteArray()
bos.close()
} catch (ex: java.lang.Exception) {
ex.printStackTrace()
}
return b
}
/***
* 解压Zip
*
* @param data
* @return
*/
fun unZip(data: ByteArray?): ByteArray? {
var b: ByteArray? = null
try {
val bis = ByteArrayInputStream(data)
val zip = ZipInputStream(bis)
while (zip.nextEntry != null) {
val buf = ByteArray(1024)
var num = -1
val baos = ByteArrayOutputStream()
while (zip.read(buf, 0, buf.size).also { num = it } != -1) {
baos.write(buf, 0, num)
}
b = baos.toByteArray()
baos.flush()
baos.close()
}
zip.close()
bis.close()
} catch (ex: java.lang.Exception) {
ex.printStackTrace()
}
return b
}
// /***
// * 压缩BZip2
// *
// * @param data
// * @return
// */
// public static byte[] bZip2(byte[] data) {
// byte[] b = null;
// try {
// ByteArrayOutputStream bos = new ByteArrayOutputStream();
// CBZip2OutputStream bzip2 = new CBZip2OutputStream(bos);
// bzip2.write(data);
// bzip2.flush();
// bzip2.close();
// b = bos.toByteArray();
// bos.close();
// } catch (Exception ex) {
// ex.printStackTrace();
// }
// return b;
// }
// /***
// * 解压BZip2
// *
// * @param data
// * @return
// */
// public static byte[] unBZip2(byte[] data) {
// byte[] b = null;
// try {
// ByteArrayInputStream bis = new ByteArrayInputStream(data);
// CBZip2InputStream bzip2 = new CBZip2InputStream(bis);
// byte[] buf = new byte[1024];
// int num = -1;
// ByteArrayOutputStream baos = new ByteArrayOutputStream();
// while ((num = bzip2.read(buf, 0, buf.length)) != -1) {
// baos.write(buf, 0, num);
// }
// b = baos.toByteArray();
// baos.flush();
// baos.close();
// bzip2.close();
// bis.close();
// } catch (Exception ex) {
// ex.printStackTrace();
// }
// return b;
// }
// /***
// * 压缩BZip2
// *
// * @param data
// * @return
// */
// public static byte[] bZip2(byte[] data) {
// byte[] b = null;
// try {
// ByteArrayOutputStream bos = new ByteArrayOutputStream();
// CBZip2OutputStream bzip2 = new CBZip2OutputStream(bos);
// bzip2.write(data);
// bzip2.flush();
// bzip2.close();
// b = bos.toByteArray();
// bos.close();
// } catch (Exception ex) {
// ex.printStackTrace();
// }
// return b;
// }
// /***
// * 解压BZip2
// *
// * @param data
// * @return
// */
// public static byte[] unBZip2(byte[] data) {
// byte[] b = null;
// try {
// ByteArrayInputStream bis = new ByteArrayInputStream(data);
// CBZip2InputStream bzip2 = new CBZip2InputStream(bis);
// byte[] buf = new byte[1024];
// int num = -1;
// ByteArrayOutputStream baos = new ByteArrayOutputStream();
// while ((num = bzip2.read(buf, 0, buf.length)) != -1) {
// baos.write(buf, 0, num);
// }
// b = baos.toByteArray();
// baos.flush();
// baos.close();
// bzip2.close();
// bis.close();
// } catch (Exception ex) {
// ex.printStackTrace();
// }
// return b;
// }
/**
* 把字节数组转换成16进制字符串
*
* @param bArray
* @return
*/
fun bytesToHexString(bArray: ByteArray): String? {
val sb = StringBuffer(bArray.size)
var sTemp: String
for (i in bArray.indices) {
sTemp = Integer.toHexString(0xFF and bArray[i].toInt())
if (sTemp.length < 2) sb.append(0)
sb.append(sTemp.uppercase(Locale.getDefault()))
}
return sb.toString()
}
}

2
vtm

@ -1 +1 @@
Subproject commit 6a6bb9ab5eaf6bb4c05b3110c612c32ef4c6ef3d
Subproject commit c046e788f5c739612a31c308639fca2de639669a