floraachy
/
ImageKnife
mirror of https://gitee.com/openharmony-tpc/ImageKnife.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

1.delete disklrucache native library 

2.add @ohos/disklrucache dependence

Signed-off-by: dodozhou5 <abczp555555@163.com>
This commit is contained in:
dodozhou5 2022-08-23 01:50:06 -07:00
parent 744e896409
commit 36bffd3be2
13 changed files with 18 additions and 1078 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
disklrucache/.gitignore vendored
View File

@ -1,3 +0,0 @@
/node_modules
/.preview
/build

5
disklrucache/build-profile.json5
View File

@ -1,5 +0,0 @@
{
"apiType": "stageMode",
"buildOption": {
}
}

3
disklrucache/hvigorfile.js
View File

@ -1,3 +0,0 @@
// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
module.exports = require('@ohos/hvigor-ohos-plugin').harTasks

20
disklrucache/index.ets
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http:// www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* disklrucache
*/
export * from './src/main/ets/components/disklrucache/DiskLruCache'
export * from './src/main/ets/components/disklrucache/DiskCacheEntry'

18
disklrucache/package.json
View File

@ -1,18 +0,0 @@
{
"license":"ISC",
"types":"",
"devDependencies":{
"@types/spark-md5":"^3.0.2"
},
"name":"@ohos/disklrucache",
"description":"a npm package which contains arkUI2.0 page",
"ohos":{
"org":""
},
"main":"index.ets",
"repository":{},
"version":"1.0.0",
"dependencies":{
"spark-md5":"^3.0.2"
}
}

115
disklrucache/src/main/ets/components/disklrucache/CustomMap.ts
View File

@ -1,115 +0,0 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export class CustomMap<K, V> {
map: Map<K, V> = new Map<K, V>()
/**
* 获取键对应的值
*
* @param key 键值
*/
get(key: K): V | undefined {
if (key == null) {
throw new Error('key is null,checking the parameter');
}
return this.map.get(key)
}
/**
* 是否含有key的缓存
*
* @param key 键值
*/
hasKey(key: K) {
if (key == null) {
throw new Error('key is null,checking the parameter');
}
return this.map.has(key)
}
/**
* 添加键值对
*
* @param key 键值
* @param value 键对应的值
*/
put(key: K, value: V): V | undefined {
if (key == null || value == null) {
throw new Error('key or value is invalid,checking the parameter');
}
let pre = this.map.get(key)
if (this.hasKey(key)) {
this.map.delete(key)
}
this.map.set(key, value);
return pre
}
/**
* 去除键值，(去除键数据中的键名及对应的值)
*
* @param key 键值
*/
remove(key: K): boolean {
if (key == null) {
throw new Error('key is null,checking the parameter');
}
return this.map.delete(key)
}
/**
* 获取最先存储的数据的key
*/
getFirstKey(): K { // keys()可以遍历后需要优化put()方法，暂时仅获取index=0的key
return this.map.keys().next().value
}
/**
* 判断键值元素是否为空
*/
isEmpty(): boolean {
return this.map.size == 0;
}
/**
* 获取键值元素大小
*/
size(): number {
return this.map.size;
}
/**
* 遍历Map,执行处理函数. 回调函数 function(key,value,index){..}
*
* @param fn 遍历回调方法
*/
each(fn) {
this.map.forEach(fn)
}
/**
* 清除键值对
*/
clear() {
this.map.clear()
}
/**
* 遍历key
*/
keys(): IterableIterator<K> {
return this.map.keys()
}
}

46
disklrucache/src/main/ets/components/disklrucache/DiskCacheEntry.ts
View File

@ -1,46 +0,0 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
export class DiskCacheEntry {
// 缓存的key
key: string = ''
// 缓存文件大小
length: number = 0
constructor(key: string, length?: number) {
this.key = key
this.length = length
}
setKey(key: string) {
this.key = key
}
getKey(): string {
return this.key
}
setLength(length: number) {
this.length = length
}
getLength(): number {
return this.length
}
toString(): string {
return this.key + ' - ' + this.length
}
}

492
disklrucache/src/main/ets/components/disklrucache/DiskLruCache.ts
View File

@ -1,492 +0,0 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import fileio from '@ohos.fileio'
import { CustomMap } from './CustomMap'
import { FileUtils } from './FileUtils'
import { FileReader } from './FileReader'
import { DiskCacheEntry } from './DiskCacheEntry'
import SparkMD5 from "spark-md5"
export class DiskLruCache {
// 默认缓存数据最大值
private static readonly DEFAULT_MAX_SIZE: number = 300 * 1024 * 1024
// 默认缓存文件名
private static readonly DEFAULT_NAME: string = 'diskLruCache'
// 缓存journal文件名称
private static readonly journal: string = 'journal'
// 缓存journal备份文件名称
private static readonly journalTemp: string = 'journal_temp'
// 备份文件save标识符
private static readonly SAVE: string = 'save'
// 备份文件read标识符
private static readonly READ: string = 'read'
// 备份文件remove标识符
private static readonly REMOVE: string = 'remove'
// 缓存文件路径地址
private path: string = ''
// 缓存journal文件路径
private journalPath: string = ''
// 缓存journal备份文件路径
private journalPathTemp: string = ''
// 缓存数据最大值
private maxSize: number = DiskLruCache.DEFAULT_MAX_SIZE
// 当前缓存数据值
private size: number = 0
// 缓存数据集合
private cacheMap: CustomMap<string, DiskCacheEntry> = new CustomMap<string, DiskCacheEntry>()
private constructor(path: string, maxSize: number) {
this.path = path
this.maxSize = maxSize
this.journalPath = path + DiskLruCache.journal
this.journalPathTemp = path + DiskLruCache.journalTemp
}
/**
* 打开path中的缓存，如果不存在缓存，则创建新缓存
*
* @param path 缓存文件路径地址
* @param maxSize 缓存数据最大值，默认值为3M
*/
public static create(context, maxSize?: number): DiskLruCache {
if (!!!context) {
throw new Error('DiskLruCache create context is empty, checking the parameter');
}
if (!!!maxSize) {
maxSize = DiskLruCache.DEFAULT_MAX_SIZE
}
if (maxSize <= 0) {
throw new Error("DiskLruCache create maxSize <= 0, checking the parameter");
}
// 使用默认应用在内部存储上的缓存路径，作为存储地址
let path = context.cacheDir + FileUtils.SEPARATOR + DiskLruCache.DEFAULT_NAME
if (!FileUtils.getInstance().existFolder(path)) {
FileUtils.getInstance().createFolder(path, true)
}
if (path.endsWith(FileUtils.SEPARATOR)) {
path = path
} else {
path = path + FileUtils.SEPARATOR
}
let journalPath = path + DiskLruCache.journal
let journalPathTemp = path + DiskLruCache.journalTemp
// 判断日志文件是否存在，如果没有初始化创建
if (FileUtils.getInstance().exist(journalPath)) {
let stat = fileio.statSync(journalPath)
if (stat.size > 0) {
FileUtils.getInstance().createFile(journalPathTemp)
FileUtils.getInstance().copyFile(journalPath, journalPathTemp)
let diskLruCache: DiskLruCache = new DiskLruCache(path, maxSize)
diskLruCache.readJournal(journalPathTemp)
diskLruCache.resetJournalFile()
return diskLruCache
} else {
return new DiskLruCache(path, maxSize)
}
} else {
FileUtils.getInstance().createFile(journalPath)
return new DiskLruCache(path, maxSize)
}
}
/**
* 设置disk缓存最大数据值
*
* @param max 缓存数据最大值
*/
setMaxSize(max: number) {
if (max <= 0 || max > DiskLruCache.DEFAULT_MAX_SIZE) {
throw new Error('setMaxSize error, checking the parameter');
}
this.maxSize = max
this.trimToSize()
}
/**
* 存储disk缓存数据
*
* @param key 键值
* @param content 文件内容
*/
set(key: string, content: ArrayBuffer | string) {
if (!!!key) {
throw new Error('key is null, checking the parameter')
}
let fileSize
if (content instanceof ArrayBuffer) {
if (content == null || content.byteLength == 0) {
throw new Error('content is null. checking the parameter')
}
fileSize = content.byteLength
} else {
if (!!!content) {
throw new Error('content is null, checking the parameter')
}
fileSize = content.length;
}
if (this.fileSizeMoreThenMaxSize(fileSize)) {
throw new Error('content must be less then DiskLruCache Size, checking the parameter')
return
}
key = SparkMD5.hash(key)
this.size = this.size + fileSize
this.putCacheMap(key, fileSize)
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.SAVE + ' ' + key + FileReader.LF)
this.trimToSize()
let tempPath = this.path + key
FileUtils.getInstance().writeNewFile(tempPath, content)
}
/**
* 异步存储disk缓存数据
*
* @param key 键值
* @param content 文件内容
*/
async setAsync(key: string, content: ArrayBuffer | string): Promise<void> {
if (!!!key) {
throw new Error('key is null, checking the parameter')
}
let fileSize
if (content instanceof ArrayBuffer) {
if (content == null || content.byteLength == 0) {
throw new Error('content is null. checking the parameter')
}
fileSize = content.byteLength
} else {
if (!!!content) {
throw new Error('content is null, checking the parameter')
}
fileSize = content.length;
}
if (this.fileSizeMoreThenMaxSize(fileSize)) {
throw new Error('content must be less then DiskLruCache Size, checking the parameter')
return
}
key = SparkMD5.hash(key)
this.size = this.size + fileSize
this.putCacheMap(key, fileSize)
await FileUtils.getInstance().writeDataAsync(this.journalPath, DiskLruCache.SAVE + ' ' + key + FileReader.LF)
this.trimToSize()
let tempPath = this.path + key
await FileUtils.getInstance().writeNewFileAsync(tempPath, content)
}
/**
* 获取key缓存数据
*
* @param key key 键值
*/
get(key: string): ArrayBuffer {
if (!!!key) {
throw new Error('key is null,checking the parameter');
}
key = SparkMD5.hash(key)
let path = this.path + key;
if (FileUtils.getInstance().exist(path)) {
let ab: ArrayBuffer = FileUtils.getInstance().readFile(path)
this.putCacheMap(key, ab.byteLength)
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.READ + ' ' + key + FileReader.LF)
return ab
} else {
return null;
}
}
/**
* 异步获取key缓存数据
*
* @param key 键值
*/
async getAsync(key: string): Promise<ArrayBuffer> {
if (!!!key) {
throw new Error('key is null,checking the parameter');
}
key = SparkMD5.hash(key)
let path = this.path + key;
if (FileUtils.getInstance().exist(path)) {
let ab: ArrayBuffer = await FileUtils.getInstance().readFileAsync(path)
this.putCacheMap(key, ab.byteLength)
await FileUtils.getInstance().writeDataAsync(this.journalPath, DiskLruCache.READ + ' ' + key + FileReader.LF)
return ab
} else {
return null;
}
}
/**
* 获取key缓存数据绝对路径
*
* @param key 键值
*/
getFileToPath(key: string): string {
if (!!!key) {
throw new Error('key is null,checking the parameter');
}
key = SparkMD5.hash(key);
let path = this.path + key;
if (FileUtils.getInstance().exist(path)) {
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.READ + ' ' + key + FileReader.LF);
return path
} else {
return null
}
}
/**
* 异步获取key缓存数据绝对路径
*
* @param key 键值
*/
async getFileToPathAsync(key: string): Promise<string> {
if (!!!key) {
throw new Error('key is null,checking the parameter');
}
key = SparkMD5.hash(key);
let path = this.path + key;
if (FileUtils.getInstance().exist(path)) {
await FileUtils.getInstance().writeDataAsync(this.journalPath, DiskLruCache.READ + ' ' + key + FileReader.LF);
return path
} else {
return null
}
}
/**
* 获取缓存路径
*/
getPath(): string{
return this.path;
}
/**
* 删除key缓存数据
*
* @param key 键值
*/
deleteCacheDataByKey(key: string): DiskCacheEntry {
if (!!!key) {
throw new Error('key is null,checking the parameter');
}
key = SparkMD5.hash(key)
let path = this.path + key;
if (FileUtils.getInstance().exist(path)) {
let ab = FileUtils.getInstance().readFile(path)
this.size = this.size - ab.byteLength
this.cacheMap.remove(key)
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.REMOVE + ' ' + key + FileReader.LF)
FileUtils.getInstance().deleteFile(path)
}
return this.cacheMap.get(key)
}
/**
*遍历当前的磁盘缓存数据
*
* @param fn 遍历后方法回调
*/
foreachDiskLruCache(fn) {
this.cacheMap.each(fn)
}
/**
* 清除所有disk缓存数据
*/
cleanCacheData() {
this.cacheMap.each((value, key) => {
FileUtils.getInstance().deleteFile(this.path + key)
})
FileUtils.getInstance().deleteFile(this.journalPath)
this.cacheMap.clear()
this.size = 0
}
getCacheMap() {
return this.cacheMap;
}
/**
* 返回当前DiskLruCache的size大小
*/
getSize() {
return this.size;
}
/**
* 处理journal文件数据
*
* @param line 日志行字符串
*/
private dealWithJournal(line: string) {
let filePath = ''
try {
let lineData = line.split(' ')
if (lineData.length > 1) {
if (lineData[0] != DiskLruCache.REMOVE) {
filePath = this.path + lineData[1]
let fileStat = fileio.statSync(filePath)
if (fileStat.isFile() && fileStat.size > 0) {
this.size = this.size + fileStat.size
FileUtils.getInstance().writeData(this.journalPath, line + FileReader.LF)
this.putCacheMap(lineData[1], fileStat.size)
}
} else {
if (this.cacheMap.hasKey(lineData[1])) {
let cacheEntry: DiskCacheEntry = this.cacheMap.get(lineData[1])
this.size = this.size - cacheEntry.getLength()
this.cacheMap.remove(lineData[1])
}
}
}
} catch (e) {
console.error('DiskLruCache - dealWithJournal e ' + e)
}
}
/**
* 存储disk缓存数据
*
* @param key key 键值
* @param path 文件路径
*/
private setFileByPath(key: string, path: string) {
if (!!!key) {
throw new Error('key is null, checking the parameter')
}
if (!!!path || !FileUtils.getInstance().exist(path)) {
throw new Error('path is null or no exist file, checking the parameter')
}
let fileSize = FileUtils.getInstance().getFileSize(path)
if (fileSize == -1) {
throw new Error('path getFileSize error ')
}
key = SparkMD5.hash(key)
this.size = this.size + fileSize
this.putCacheMap(key, fileSize)
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.SAVE + ' ' + key + FileReader.LF)
this.trimToSize()
fileSize = FileUtils.getInstance().getFileSize(path)
FileUtils.getInstance().copyFile(path, this.path + key)
}
/**
* 异步存储disk缓存数据
*
* @param key key 键值
* @param path 文件路径
*/
private async setFileByPathAsync(key: string, path: string): Promise<void> {
if (!!!key) {
throw new Error('key is null, checking the parameter')
}
if (!!!path || !FileUtils.getInstance().exist(path)) {
throw new Error('path is null or no exist file, checking the parameter')
}
let fileSize = FileUtils.getInstance().getFileSize(path)
if (fileSize == -1) {
throw new Error('path getFileSize error ')
}
key = SparkMD5.hash(key)
this.size = this.size + fileSize
this.putCacheMap(key, fileSize)
await FileUtils.getInstance().writeDataAsync(this.journalPath, DiskLruCache.SAVE + ' ' + key + FileReader.LF)
this.trimToSize()
fileSize = FileUtils.getInstance().getFileSize(path)
await FileUtils.getInstance().copyFileAsync(path, this.path + key)
}
/**
* 重置journal文件数据
*/
private resetJournalFile() {
FileUtils.getInstance().clearFile(this.journalPath)
for (let key of this.cacheMap.keys()) {
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.SAVE + ' ' + key + FileReader.LF)
}
}
/**
* 读取journal文件的缓存数据
*
* @param path 日志缓存文件路径地址
*/
private readJournal(path: string) {
let fileReader = new FileReader(path)
let line: string = ''
while (!fileReader.isEnd()) {
line = fileReader.readLine()
line = line.replace(FileReader.LF, '').replace(FileReader.CR, '')
this.dealWithJournal(line)
}
fileReader.close()
FileUtils.getInstance().deleteFile(this.journalPathTemp)
this.trimToSize()
}
/**
* 缓存数据map集合
*
* @param key 键值
* @param length 缓存文件大小
*/
private putCacheMap(key: string, length?: number) {
if (length > 0) {
this.cacheMap.put(key, new DiskCacheEntry(key, length))
} else {
this.cacheMap.put(key, new DiskCacheEntry(key))
}
}
/**
* 根据LRU算法删除多余缓存数据
*/
private trimToSize() {
while (this.size > this.maxSize) {
let tempKey: string = this.cacheMap.getFirstKey()
let fileSize = FileUtils.getInstance().getFileSize(this.path + tempKey)
if (fileSize > 0) {
this.size = this.size - fileSize
}
FileUtils.getInstance().deleteFile(this.path + tempKey)
this.cacheMap.remove(tempKey)
FileUtils.getInstance().writeData(this.journalPath, DiskLruCache.REMOVE + ' ' + tempKey + FileReader.LF)
}
}
/**
* 图片文件过大 直接超过DiskLruCache上限
*/
private fileSizeMoreThenMaxSize(fileSize: number): boolean{
if (fileSize > this.maxSize) {
return true;
}
return false;
}
}

99
disklrucache/src/main/ets/components/disklrucache/FileReader.ts
View File

@ -1,99 +0,0 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import fileio from '@ohos.fileio'
export class FileReader {
// 换行符
static readonly LF: string = '\n'
// CR符
static readonly CR: string = '\r'
// 文件大小
fileLength: number = 0
// 读取的长度
length: number = 0
// 读写stream
stream: any = null
// 缓存buf
buf: ArrayBuffer = new ArrayBuffer(1)
/**
* 读取文件行
*
* @param path 文件路径
*/
constructor(path: string) {
if (!!!path) {
throw new Error('FileReader constructor path is null, checking the parameter')
return;
}
this.stream = fileio.createStreamSync(path, 'r+');
let stat = fileio.statSync(path)
this.fileLength = stat.size
}
/**
* 循环读取文件数据
*/
readLine(): string {
let line = ''
while (this.length < this.fileLength) {
this.stream.readSync(this.buf, { position: this.length })
this.length++
let temp = String.fromCharCode.apply(null, new Uint8Array(this.buf));
line = line + temp
// check CRLF
if (temp == FileReader.CR) {
// 边界判断 首先拿到下一个字符判断是否是LF 如果是CRLF需要再向后挪一位
if(this.length < this.fileLength) {
let nextBuf = new ArrayBuffer(1)
this.stream.readSync(nextBuf, { position: this.length })
let nextTemp = String.fromCharCode.apply(null, new Uint8Array(nextBuf))
// 如果是CRLF 需要给当前length+1 向后挪一位
if (nextTemp == FileReader.LF) {
this.length++
}
}
// 如果不是CRLF 只有一个CR结尾length不用变
return line;
} else {
// 判断LF情况
if (temp == FileReader.LF) {
return line
}
}
}
return line
}
/**
* 判断文件是否结束
*/
isEnd() {
return this.fileLength <= 0 || this.length == this.fileLength
}
/**
* 关闭stream
*/
close() {
this.stream.closeSync()
}
}

240
disklrucache/src/main/ets/components/disklrucache/FileUtils.ts
View File

@ -1,240 +0,0 @@
/*
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import fileio from '@ohos.fileio'
export class FileUtils {
static readonly SEPARATOR: string = '/'
private static sInstance: FileUtils
base64Str: string = ''
private constructor() {
}
/**
* 单例实现FileUtils类
*/
public static getInstance(): FileUtils {
if (!this.sInstance) {
this.sInstance = new FileUtils();
}
return this.sInstance;
}
/**
* 新建文件
*
* @param path 文件绝对路径及文件名
* @return number 文件句柄id
*/
createFile(path: string): number {
return fileio.openSync(path, 0o100, 0o664)
}
/**
* 删除文件
*
* @param path 文件绝对路径及文件名
*/
deleteFile(path: string): void {
fileio.unlinkSync(path);
}
/**
* 拷贝文件
*
* @param src 文件绝对路径及文件名
* @param dest 拷贝到对应的路径
*/
copyFile(src: string, dest: string) {
fileio.copyFileSync(src, dest);
}
/**
* 异步拷贝文件
*
* @param src 文件绝对路径及文件名
* @param dest 拷贝到对应的路径
*/
async copyFileAsync(src: string, dest: string): Promise<void> {
await fileio.copyFile(src, dest);
}
/**
* 清空已有文件数据
*
* @param path 文件绝对路径
*/
clearFile(path: string): number {
return fileio.openSync(path, 0o1000)
}
/**
* 向path写入数据
*
* @param path 文件绝对路径
* @param content 文件内容
*/
writeData(path: string, content: ArrayBuffer | string) {
let fd = fileio.openSync(path, 0o102, 0o664)
let stat = fileio.statSync(path)
fileio.writeSync(fd, content, { position: stat.size })
fileio.closeSync(fd)
}
/**
* 异步向path写入数据
*
* @param path 文件绝对路径
* @param content 文件内容
*/
async writeDataAsync(path: string, content: ArrayBuffer | string): Promise<void> {
let fd = await fileio.open(path, 0o102, 0o664)
let stat = await fileio.stat(path)
await fileio.write(fd, content, { position: stat.size })
await fileio.close(fd)
}
/**
* 判断path文件是否存在
*
* @param path 文件绝对路径
*/
exist(path: string): boolean {
try {
let stat = fileio.statSync(path)
return stat.isFile()
} catch (e) {
console.error("FileUtils exist e " + e)
return false
}
}
/**
* 向path写入数据
*
* @param path 文件绝对路径
* @param data 文件内容
*/
writeNewFile(path: string, data: ArrayBuffer | string) {
this.createFile(path)
this.writeFile(path, data)
}
/**
* 向path写入数据
*
* @param path 文件绝对路径
* @param data 文件内容
*/
async writeNewFileAsync(path: string, data: ArrayBuffer | string): Promise<void> {
await fileio.open(path, 0o100, 0o664)
let fd = await fileio.open(path, 0o102, 0o664)
await fileio.ftruncate(fd)
await fileio.write(fd, data)
await fileio.fsync(fd)
await fileio.close(fd)
}
/**
* 获取path的文件大小
*
* @param path 文件绝对路径
*/
getFileSize(path: string): number {
try {
let stat = fileio.statSync(path)
return stat.size
} catch (e) {
console.error("FileUtils getFileSize e " + e)
return -1
}
}
/**
* 读取路径path的文件
*
* @param path 文件绝对路径
*/
readFile(path: string): ArrayBuffer {
let fd = fileio.openSync(path, 0o2);
let length = fileio.statSync(path).size
let buf = new ArrayBuffer(length);
fileio.readSync(fd, buf)
return buf
}
/**
* 读取路径path的文件
*
* @param path 文件绝对路径
*/
async readFileAsync(path: string): Promise<ArrayBuffer> {
let stat = await fileio.stat(path);
let fd = await fileio.open(path, 0o2);
let length = stat.size;
let buf = new ArrayBuffer(length);
await fileio.read(fd, buf);
return buf
}
/**
* 创建文件夹
*
* @param path 文件夹绝对路径，只有是权限范围内的路径，可以生成
* @param recursive
*/
createFolder(path: string, recursive?: boolean) {
if (recursive) {
if (!this.existFolder(path)) {
let lastInterval = path.lastIndexOf(FileUtils.SEPARATOR)
if (lastInterval == 0) {
return
}
let newPath = path.substring(0, lastInterval)
this.createFolder(newPath, true)
if (!this.existFolder(path)) {
fileio.mkdirSync(path)
}
}
} else {
if (!this.existFolder(path)) {
fileio.mkdirSync(path)
}
}
}
/**
* 判断文件夹是否存在
*
* @param path 文件夹绝对路径
*/
existFolder(path: string): boolean {
try {
let stat = fileio.statSync(path)
return stat.isDirectory()
} catch (e) {
console.error("FileUtils folder exist e " + e)
return false
}
}
private writeFile(path: string, content: ArrayBuffer | string) {
let fd = fileio.openSync(path, 0o102, 0o664)
fileio.ftruncateSync(fd)
fileio.writeSync(fd, content)
fileio.fsyncSync(fd)
fileio.closeSync(fd)
}
}

11
disklrucache/src/main/module.json5
View File

@ -1,11 +0,0 @@
{
"module": {
"name": "disklrucache",
"type": "har",
"deviceTypes": [
"default",
"tablet"
],
"uiSyntax": "ets"
}
}

8
disklrucache/src/main/resources/base/element/string.json
View File

@ -1,8 +0,0 @@
{
"string": [
{
"name": "page_show",
"value": "page from npm package"
}
]
}

2
imageknife/package.json
View File

@ -15,7 +15,7 @@
"version": "1.0.2",
"dependencies": {
"pako": "^1.0.5",
"@ohos/disklrucache":"file:../disklrucache",
"@ohos/disklrucache": "^1.0.0",
"crc-32": "^1.2.0"
},
"tags": [