uniapp对接百度云营业执照识别记录

1、在根目录api文件夹下新建baidu.js

/*获取百度云凭证*/
export async function getToken() {
	return new Promise((resolve, reject) => {
		uni.request({
			url: "https://aip.baidubce.com/oauth/2.0/token",
			method: "POST",
			header: {
				'content-type': "application/x-www-form-urlencoded"
			},
			dataType: 'json',
			data: {
				grant_type: "client_credentials",//必须参数，固定为`client_credentials`
				client_id: "API Key",//应用的`API Key`
				client_secret: "Secret Key"//必须参数，应用的`Secret Key`
			},
			success(res) {
				resolve(res.data)
			},
			fail(err) {
				reject(err)
			}
		})
	})
}
/*百度云营业执照识别*/
export async function business_license(access_token, url) {
	return new Promise((resolve, reject) => {
		uni.request({
			url: "https://aip.baidubce.com/rest/2.0/ocr/v1/business_license",
			method: "POST",
			header: {
				'content-type': "application/x-www-form-urlencoded"
			},
			dataType: 'json',
			data: {
				access_token,
				url //image-base64格式,url-网络链接格式
			},
			success(res) {
				resolve(res.data)
			},
			fail(err) {
				reject(err)
			}
		})
	})
}

2、使用

引入

import {getToken,business_license,} from "@/api/baidu.js";

2.1、base64上传方式

上传方式分为两种，一种是base64的格式上传，而另一种是以url的格式上传，具体看百度文档。要是用base64的上传方式必须将图片转为base64。所以这里使用插件市场的image-tools，以下是它的源码。但是我在使用过程中app的效果并不是很理想。有时候转成功，有时候不成功，有谁知道为啥吗？源码采用H5+的api方式来转码，我试着看H5+的文档找去原因，但结果分析不出来。为了不浪费时间，所以我是采用url格式上传去识别。

function getLocalFilePath(path) {
    if (path.indexOf('_www') === 0 || path.indexOf('_doc') === 0 || path.indexOf('_documents') === 0 || path.indexOf('_downloads') === 0) {
        return path
    }
    if (path.indexOf('file://') === 0) {
        return path
    }
    if (path.indexOf('/storage/emulated/0/') === 0) {
        return path
    }
    if (path.indexOf('/') === 0) {
        var localFilePath = plus.io.convertAbsoluteFileSystem(path)
        if (localFilePath !== path) {
            return localFilePath
        } else {
            path = path.substr(1)
        }
    }
    return '_www/' + path
}

function dataUrlToBase64(str) {
    var array = str.split(',')
    return array[array.length - 1]
}

var index = 0
function getNewFileId() {
    return Date.now() + String(index++)
}

function biggerThan(v1, v2) {
    var v1Array = v1.split('.')
    var v2Array = v2.split('.')
    var update = false
    for (var index = 0; index < v2Array.length; index++) {
        var diff = v1Array[index] - v2Array[index]
        if (diff !== 0) {
            update = diff > 0
            break
        }
    }
    return update
}

export function pathToBase64(path) {
    return new Promise(function(resolve, reject) {
        if (typeof window === 'object' && 'document' in window) {
            if (typeof FileReader === 'function') {
                var xhr = new XMLHttpRequest()
                xhr.open('GET', path, true)
                xhr.responseType = 'blob'
                xhr.onload = function() {
                    if (this.status === 200) {
                        let fileReader = new FileReader()
                        fileReader.onload = function(e) {
                            resolve(e.target.result)
                        }
                        fileReader.onerror = reject
                        fileReader.readAsDataURL(this.response)
                    }
                }
                xhr.onerror = reject
                xhr.send()
                return
            }
            var canvas = document.createElement('canvas')
            var c2x = canvas.getContext('2d')
            var img = new Image
            img.onload = function() {
                canvas.width = img.width
                canvas.height = img.height
                c2x.drawImage(img, 0, 0)
                resolve(canvas.toDataURL())
                canvas.height = canvas.width = 0
            }
            img.onerror = reject
            img.src = path
            return
        }
        if (typeof plus === 'object') {
            plus.io.resolveLocalFileSystemURL(getLocalFilePath(path), function(entry) {
                entry.file(function(file) {
                    var fileReader = new plus.io.FileReader()
                    fileReader.onload = function(data) {
                        resolve(data.target.result)
                    }
                    fileReader.onerror = function(error) {
                        reject(error)
                    }
                    fileReader.readAsDataURL(file)
                }, function(error) {
                    reject(error)
                })
            }, function(error) {
                reject(error)
            })
            return
        }
        if (typeof wx === 'object' && wx.canIUse('getFileSystemManager')) {
            wx.getFileSystemManager().readFile({
                filePath: path,
                encoding: 'base64',
                success: function(res) {
                    resolve('data:image/png;base64,' + res.data)
                },
                fail: function(error) {
                    reject(error)
                }
            })
            return
        }
        reject(new Error('not support'))
    })
}

export function base64ToPath(base64) {
    return new Promise(function(resolve, reject) {
        if (typeof window === 'object' && 'document' in window) {
            base64 = base64.split(',')
            var type = base64[0].match(/:(.*?);/)[1]
            var str = atob(base64[1])
            var n = str.length
            var array = new Uint8Array(n)
            while (n--) {
                array[n] = str.charCodeAt(n)
            }
            return resolve((window.URL || window.webkitURL).createObjectURL(new Blob([array], { type: type })))
        }
        var extName = base64.split(',')[0].match(/data\:\S+\/(\S+);/)
        if (extName) {
            extName = extName[1]
        } else {
            reject(new Error('base64 error'))
        }
        var fileName = getNewFileId() + '.' + extName
        if (typeof plus === 'object') {
            var basePath = '_doc'
            var dirPath = 'uniapp_temp'
            var filePath = basePath + '/' + dirPath + '/' + fileName
            if (!biggerThan(plus.os.name === 'Android' ? '1.9.9.80627' : '1.9.9.80472', plus.runtime.innerVersion)) {
                plus.io.resolveLocalFileSystemURL(basePath, function(entry) {
                    entry.getDirectory(dirPath, {
                        create: true,
                        exclusive: false,
                    }, function(entry) {
                        entry.getFile(fileName, {
                            create: true,
                            exclusive: false,
                        }, function(entry) {
                            entry.createWriter(function(writer) {
                                writer.onwrite = function() {
                                    resolve(filePath)
                                }
                                writer.onerror = reject
                                writer.seek(0)
                                writer.writeAsBinary(dataUrlToBase64(base64))
                            }, reject)
                        }, reject)
                    }, reject)
                }, reject)
                return
            }
            var bitmap = new plus.nativeObj.Bitmap(fileName)
            bitmap.loadBase64Data(base64, function() {
                bitmap.save(filePath, {}, function() {
                    bitmap.clear()
                    resolve(filePath)
                }, function(error) {
                    bitmap.clear()
                    reject(error)
                })
            }, function(error) {
                bitmap.clear()
                reject(error)
            })
            return
        }
        if (typeof wx === 'object' && wx.canIUse('getFileSystemManager')) {
            var filePath = wx.env.USER_DATA_PATH + '/' + fileName
            wx.getFileSystemManager().writeFile({
                filePath: filePath,
                data: dataUrlToBase64(base64),
                encoding: 'base64',
                success: function() {
                    resolve(filePath)
                },
                fail: function(error) {
                    reject(error)
                }
            })
            return
        }
        reject(new Error('not support'))
    })
}
    

2.2 url格式上传

我这里是使用七牛云的直传，先使用postman获取token，当然正常来话是不会这样做的啦，这个后端返回就行了。然后前端拿token去上传。另外的上传界面和上传的进度，自己实现就好了。

data() {
    return {
	access_token: '',
	qinuiToken: ''
    }
}

    	get_token() {
            getToken().then(res => {
                       this.access_token = res.access_token
            })
	},
        update() {
            uni.chooseImage({
                count: 1, 
		success: (res) => {
                    var file = res.tempFilePaths;
                    uni.uploadFile({
                        url: 'https://up-z2.qiniup.com',//上传地址，详情看下面说明
                        filePath: file[0],
                        name: 'file',
			formData: {
                            'key': new Date().getTime(),
                            'token': this.qinuiToken
			},
			success: (res) => {
                            let data = JSON.parse(res.data)
                            //外链加上kdy就是完整的url了
                            let url = "http://域名.com/" + data.key
                            business_license(this.access_token, url).then(res => {
				console.log(res)//识别数据
                            }).catch(err => {
				uni.showToast({
					title: "上传识别错误",
                                        icon: "icon"
                            })
			})
			console.log(data, url)

                      }
		    });
	       },
               fail(err) {
			console.log(err)
			reject(err)
		}
	})
},
        

地址说明

case 'NCN': uploadURL = 'https://up-z1.qiniup.com'; break;
case 'SCN': uploadURL = 'https://up-z2.qiniup.com'; break;
case 'NA': uploadURL = 'https://up-na0.qiniup.com'; break;
case 'ASG': uploadURL = 'https://up-as0.qiniup.com'; break;
 
 
//qiniu.region.z0: 代表华东区域
//qiniu.region.z1: 代表华北区域
//qiniu.region.z2: 代表华南区域
//qiniu.region.na0: 代表北美区域
//qiniu.region.as0: 代表东南亚区域