|
|
export const normalizeBase64Pure = (input) => {
|
|
|
let text = String(input ?? '').trim().replace(/\s/g, '')
|
|
|
if (!text) return ''
|
|
|
if (/^data:image\/[\w+.-]+;base64,/i.test(text)) {
|
|
|
text = text.replace(/^data:image\/[\w+.-]+;base64,/i, '')
|
|
|
}
|
|
|
return text
|
|
|
}
|
|
|
|
|
|
/** 补齐 padding，并兼容 URL-safe Base64 */
|
|
|
export const fixBase64ForDecode = (pure) => {
|
|
|
let text = String(pure ?? '').replace(/-/g, '+').replace(/_/g, '/')
|
|
|
const mod = text.length % 4
|
|
|
if (mod === 2) text += '=='
|
|
|
else if (mod === 3) text += '='
|
|
|
return text
|
|
|
}
|
|
|
|
|
|
export const getMimeTypeFromBase64 = (pure) => {
|
|
|
if (pure.startsWith('iVBORw0KGgo')) return 'image/png'
|
|
|
return 'image/jpeg'
|
|
|
}
|
|
|
|
|
|
export const extractImageBase64FromResponse = (result) => {
|
|
|
if (result === undefined || result === null) return ''
|
|
|
if (typeof result === 'string') return result
|
|
|
if (result.imageBase64) return result.imageBase64
|
|
|
if (result.data !== undefined && result.data !== null) {
|
|
|
return extractImageBase64FromResponse(result.data)
|
|
|
}
|
|
|
return ''
|
|
|
}
|
|
|
|
|
|
export const isWebPlatform = () => {
|
|
|
if (typeof window === 'undefined' || typeof document === 'undefined') {
|
|
|
return false
|
|
|
}
|
|
|
try {
|
|
|
const sys = uni.getSystemInfoSync()
|
|
|
return sys.uniPlatform === 'web' || sys.uniPlatform === 'h5'
|
|
|
} catch {
|
|
|
return true
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const decodeBase64ToBytes = (pure) => {
|
|
|
const normalized = fixBase64ForDecode(pure)
|
|
|
const binary = atob(normalized)
|
|
|
const bytes = new Uint8Array(binary.length)
|
|
|
for (let i = 0; i < binary.length; i++) {
|
|
|
bytes[i] = binary.charCodeAt(i)
|
|
|
}
|
|
|
return bytes
|
|
|
}
|
|
|
|
|
|
const createBlobUrlFromBase64 = (pure, mime) => {
|
|
|
const bytes = decodeBase64ToBytes(pure)
|
|
|
const blob = new Blob([bytes], { type: mime })
|
|
|
const blobUrl = URL.createObjectURL(blob)
|
|
|
return {
|
|
|
src: blobUrl,
|
|
|
revoke: () => URL.revokeObjectURL(blobUrl),
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const createDataUrlFromBase64 = (pure, mime) => {
|
|
|
const normalized = fixBase64ForDecode(pure)
|
|
|
return {
|
|
|
src: `data:${mime};base64,${normalized}`,
|
|
|
revoke: null,
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const tryWebDisplay = (pure, mime, resolve) => {
|
|
|
if (typeof window !== 'undefined' && typeof atob === 'function') {
|
|
|
try {
|
|
|
const blobResult = createBlobUrlFromBase64(pure, mime)
|
|
|
console.log('[face-image] 使用 Blob URL 展示')
|
|
|
resolve(blobResult)
|
|
|
return
|
|
|
} catch (error) {
|
|
|
console.log('[face-image] Blob URL 创建失败，回退 dataUrl', error)
|
|
|
}
|
|
|
}
|
|
|
console.log('[face-image] 使用 dataUrl 展示')
|
|
|
resolve(createDataUrlFromBase64(pure, mime))
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 将 Base64 转为可在页面中展示的图片地址
|
|
|
*/
|
|
|
export const loadFaceImageDisplaySrc = (base64Raw) => {
|
|
|
return new Promise((resolve, reject) => {
|
|
|
const pure = normalizeBase64Pure(base64Raw)
|
|
|
if (!pure) {
|
|
|
reject(new Error('图片 Base64 为空'))
|
|
|
return
|
|
|
}
|
|
|
|
|
|
const mime = getMimeTypeFromBase64(pure)
|
|
|
console.log('[face-image] base64 前缀:', pure.slice(0, 24), 'mime:', mime)
|
|
|
|
|
|
if (isWebPlatform()) {
|
|
|
tryWebDisplay(pure, mime, resolve)
|
|
|
return
|
|
|
}
|
|
|
|
|
|
if (typeof uni.base64ToTempFilePath === 'function') {
|
|
|
uni.base64ToTempFilePath({
|
|
|
base64Data: fixBase64ForDecode(pure),
|
|
|
extension: mime === 'image/png' ? 'png' : 'jpg',
|
|
|
success: (res) => {
|
|
|
console.log('[face-image] 使用临时文件展示:', res.tempFilePath)
|
|
|
resolve({
|
|
|
src: res.tempFilePath,
|
|
|
revoke: null,
|
|
|
})
|
|
|
},
|
|
|
fail: (err) => {
|
|
|
console.log('[face-image] base64ToTempFilePath 失败', err)
|
|
|
tryWebDisplay(pure, mime, resolve)
|
|
|
},
|
|
|
})
|
|
|
return
|
|
|
}
|
|
|
|
|
|
tryWebDisplay(pure, mime, resolve)
|
|
|
})
|
|
|
}
|
