HarmonyOS 鸿蒙Next onBackground

export class ScannerImp extends ScannerStub implements BaseDeviceService { initialized = InitializeState.PADDING

private cameraId: number
private bundle: Bundle
private scanParam
private timer: Timer
ERROR_ENUM = scannerApi.ErrorCode
errorCodeOffset = 0x10910000
private resultNotified = false

constructor(param: Bundle) {
    super()
    this.bundle = param
    this.cameraId = param.cameraId
}

initialize(): Promise<void> {
    logger.info("initialize " + scannerApi.CameraId[this.cameraId])
    return new Promise(async (resolve, reject) => {
        resolve()
    })
}

init(config): Promise<void> {
    return Promise.resolve()
}

startScan(param: Bundle): Promise<void> {
    logger.info(`startScan ${JSON.stringify(param)}`)
    this.scanParam = param
    this.resultNotified = false
    return new Promise(async (resolve, reject) => {
        if (hasStarted) {
            logger.error(`Scanner busy`)
            reject({ code: 1, message: "Scanner busy" })
            return
        }
        hasStarted = true

        this.setTimer()
        this.subscribeScanEvent()
        if (this.cameraId == scannerApi.CameraId.FRONT) {
            try {
                if (mScanner == null) {
                    mScanner = new ScanDecoder(this.bundle)
                    await mScanner.openDevice(this.cameraId)
                }
                if (this.scanParam?.["showDefaultUI"] != false) {
                    await this.startScanView()
                }
                await mScanner.startScan(param)
                resolve()
            } catch (error) {
                this.onFinish()
                convertErrorCode(logger, reject, error, this.errorCodeOffset, this.ERROR_ENUM)
            }
        } else {
            try {
                logger.info("close ScanDecoder")
                await mScanner?.closeDevice()
                logger.info("close ScanDecoder 1")
                mScanner = null
                await this.startScanView()
                resolve()
            } catch (error) {
                logger.error("failed to close ScanDecoder")
                this.onFinish()
                convertErrorCode(logger, reject, error, this.errorCodeOffset, this.ERROR_ENUM)
            }
        }
    })
}

stopScan(): Promise<void> {
    logger.info(`stopScan`)
    this.onFinish()
    return mScanner?.stopScan()
}

on(type: 'scanSuccess' | 'scanFail', callback: any): Promise<void> {
    logger.info(`on[${type}] event`)
    if (type === 'scanSuccess') {
        successCallback = callback
    } else {
        failCallback = callback
    }
    return Promise.resolve()
}

off(type: 'scanSuccess' | 'scanFail'): Promise<void> {
    logger.info(`off[${type}] event`)
    if (type === 'scanSuccess') {
        successCallback = null
    } else {
        failCallback = null
    }
    return Promise.resolve()
}

private async subscribeScanEvent() {
    logger.debug("subscribeScanEvent")
    //订阅者信息
    emitter.once({ eventId: EventType.EVENT_STOP_SCAN, priority: emitter.EventPriority.IMMEDIATE }, () => {
        this.onFinish()
        this.stopScan()
    })
    emitter.once({ eventId: EventType.EVENT_SCAN_RESULT, priority: emitter.EventPriority.IMMEDIATE }, (data) => {
        if (this.resultNotified || data.data.cameraId != this.cameraId) {
            logger.warn("result already notified")
            return
        }
        this.onFinish()
        if (data.data.code == 0) {
            const result = BytesUtil.hexString2Bytes(data.data.result)
            logger.debug(`scanSuccess: ${result} cameraId: ${this.cameraId}`)
            if (successCallback) {
                successCallback(result)
            }
        } else {
            logger.error(`on scanFail: ${data.data.code} ${data.data.message}`)
            if (failCallback) {
                failCallback(data.data.code)
            }
        }
    })
}

private setTimer() {
    const timeout = this.scanParam?.timeout == null ? scannerApi.DEFAULT_TIMEOUT : this.scanParam.timeout
    logger.debug(`set timer ${timeout}`)
    this.timer = new Timer()
    this.timer.start(() => {
        publishResult(this.cameraId, scannerApi.ErrorCode.ERROR_TIMEOUT)
        mScanner?.stopScan()
    }, timeout)
}

private removeTimer() {
    logger.debug("remove timer")
    this.timer?.stop()
}

private onFinish() {
    logger.info("onFinish")
    emitter.off(EventType.EVENT_SCAN_RESULT)
    emitter.off(EventType.EVENT_STOP_SCAN)
    this.resultNotified = true
    this.removeTimer()
    hasStarted = false
    //避免出现问题关闭时，页面还未成功启动导致无法关闭的情况
    setTimeout(() => {
        publishClose()
    }, 30)
}

async release() {
    logger.info("release")
    this.initialized = InitializeState.PADDING
    mScanner?.closeDevice()
    mScanner = null
}

private startScanView(): Promise<void> {

    const url = this.cameraId == scannerApi.CameraId.BACK ? 'PageAbility/scanner/ScanPreviewer' : 'PageAbility/scanner/ScanPrompt'
    const timeout = this.scanParam?.["timeout"] == null ? scannerApi.DEFAULT_TIMEOUT : this.scanParam?.["timeout"]
    return new Promise(async (resolve, reject) => {
        try {
            let mContext = globalThis.serviceContext
            let want = {
                bundleName: 'oha.icbc.apiservice',
                abilityName: 'PageAbility',
                parameters: {
                    url: url,
                    cameraId: this.cameraId,
                    timeout: timeout,
                    [wantConstant.Params.ABILITY_BACK_TO_OTHER_MISSION_STACK]: true
                }
            }

            if (mContext) {
                await mContext.startAbility(want)
                resolve()
                logger.info('start callee ability succeed')
            }
        } catch (error) {
            logger.error(`start callee ability failed with ${error.code}`)
            reject(error)
        }
    })
}

}