10586 lines
414 KiB
Plaintext
10586 lines
414 KiB
Plaintext
import Want from '@ohos.app.ability.Want';
|
|
import common from '@ohos.app.ability.common';
|
|
import wantConstant from '@ohos.app.ability.wantConstant';
|
|
import buffer from '@ohos.buffer';
|
|
import uniformTypeDescriptor from '@ohos.data.uniformTypeDescriptor';
|
|
import deviceInfo from '@ohos.deviceInfo';
|
|
import fs from '@ohos.file.fs';
|
|
import photoAccessHelper from '@ohos.file.photoAccessHelper';
|
|
import inputMethod from '@ohos.inputMethod';
|
|
import media from '@ohos.multimedia.media';
|
|
import connection from '@ohos.net.connection';
|
|
import webSocket from '@ohos.net.webSocket';
|
|
import pasteboard from '@ohos.pasteboard';
|
|
import cryptoFramework from '@ohos.security.cryptoFramework';
|
|
import call from '@ohos.telephony.call';
|
|
import radio from '@ohos.telephony.radio';
|
|
import uri from '@ohos.uri';
|
|
import util from '@ohos.util';
|
|
import webview from '@ohos.web.webview';
|
|
import zlib from '@ohos.zlib';
|
|
import { BusinessError as BusinessError1 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError10 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError11 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError12 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError13 } from '@ohos.base';
|
|
import { BusinessError as BusinessError14 } from '@ohos.base';
|
|
import { BusinessError as BusinessError2 } from '@ohos.base';
|
|
import { BusinessError as BusinessError3 } from '@ohos.base';
|
|
import { BusinessError as BusinessError4 } from '@ohos.base';
|
|
import { BusinessError as BusinessError5 } from '@ohos.base';
|
|
import { BusinessError as BusinessError6 } from '@ohos.base';
|
|
import { BusinessError as BusinessError7 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError8 } from '@kit.BasicServicesKit';
|
|
import { BusinessError as BusinessError9 } from '@kit.BasicServicesKit';
|
|
import { BusinessError } from '@kit.BasicServicesKit';
|
|
import { CompressorResponseCode, CompressorResponse, VideoCompressor, CompressQuality } from '@ohos/videocompressor';
|
|
import { Emitter as Emitter1, onNativePageReady } from "@dcloudio/uni-mp-sdk";
|
|
import { Emitter as Emitter2, getCurrentMP as getCurrentMP1 } from "@dcloudio/uni-mp-sdk";
|
|
import { Emitter as Emitter5, getCurrentMP as getCurrentMP5 } from "@dcloudio/uni-mp-sdk";
|
|
import { Emitter, getCurrentMP } from "@dcloudio/uni-mp-sdk";
|
|
import Hash from '@ohos.file.hash';
|
|
import I18n from '@ohos.i18n';
|
|
import I18n1 from '@ohos.i18n';
|
|
import I18n2 from '@ohos.i18n';
|
|
import { ListFileOptions } from '@ohos.file.fs';
|
|
import { ReadOptions as ReadOptions2 } from '@ohos.file.fs';
|
|
import { ReadOptions } from '@ohos.file.fs';
|
|
import { UTSHarmony } from "@dcloudio/uni-mp-sdk";
|
|
import { UTSObject, UniError, IUniError, string, ApiError, UniProvider, UTSJSONObject, AsyncApiSuccessResult, AsyncApiResult, ApiOptions, ProtocolOptions, defineAsyncApi, ApiExecutor, defineSyncApi, getUniProviders, defineTaskApi, getUniProvider } from "./shared";
|
|
import Want1 from '@ohos.app.ability.Want';
|
|
import { abilityAccessCtrl } from '@kit.AbilityKit';
|
|
import { access } from '@kit.ConnectivityKit';
|
|
import { audio as audio1 } from '@kit.AudioKit';
|
|
import { audio } from '@kit.AudioKit';
|
|
import { avSession } from '@kit.AVSessionKit';
|
|
import { backgroundTaskManager } from '@kit.BackgroundTasksKit';
|
|
import buffer1 from '@ohos.buffer';
|
|
import { bundleManager } from '@kit.AbilityKit';
|
|
import bundleManager1 from '@ohos.bundle.bundleManager';
|
|
import bundleManager2 from '@ohos.bundle.bundleManager';
|
|
import { camera as camera1 } from '@kit.CameraKit';
|
|
import { camera } from '@kit.CameraKit';
|
|
import { cameraPicker as cameraPicker1 } from '@kit.CameraKit';
|
|
import { cameraPicker } from '@kit.CameraKit';
|
|
import common1 from '@ohos.app.ability.common';
|
|
import common2 from '@ohos.app.ability.common';
|
|
import common3 from '@ohos.app.ability.common';
|
|
import common4 from '@ohos.app.ability.common';
|
|
import { contact } from '@kit.ContactsKit';
|
|
import cryptoFramework1 from '@ohos.security.cryptoFramework';
|
|
import dataPreferences from '@ohos.data.preferences';
|
|
import deviceInfo1 from '@ohos.deviceInfo';
|
|
import { display } from '@kit.ArkUI';
|
|
import { fileIo as fileIo1 } from '@kit.CoreFileKit';
|
|
import { fileIo as fileIo2 } from '@kit.CoreFileKit';
|
|
import { fileIo as fileIo3 } from '@kit.CoreFileKit';
|
|
import { fileIo as fileIo4 } from '@kit.CoreFileKit';
|
|
import { fileIo as fs5 } from '@kit.CoreFileKit';
|
|
import { fileIo } from '@kit.CoreFileKit';
|
|
import fileUri from '@ohos.file.fileuri';
|
|
import fileUri1 from '@ohos.file.fileuri';
|
|
import fs1 from '@ohos.file.fs';
|
|
import fs2, { ReadTextOptions } from '@ohos.file.fs';
|
|
import fs3, { ListFileOptions as ListFileOptions1, WriteOptions as OHWriteOptions, ReadOptions as ReadOptions1, ReadTextOptions as ReadTextOptions1 } from '@ohos.file.fs';
|
|
import fs4 from '@ohos.file.fs';
|
|
import fs6 from '@ohos.file.fs';
|
|
import fs7 from '@ohos.file.fs';
|
|
import fs8 from '@ohos.file.fs';
|
|
import { geoLocationManager } from '@kit.LocationKit';
|
|
import { getCurrentMP as getCurrentMP4 } from "@dcloudio/uni-mp-sdk";
|
|
import { getDeviceId } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv as getEnv1, getRealPath as getRealPath1 } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv as getEnv2, getRealPath as runtimeGetRealPath } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv as getEnv3 } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv as getEnv4 } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv as getEnv5, Emitter as Emitter4, getCurrentMP as getCurrentMP3 } from "@dcloudio/uni-mp-sdk";
|
|
import { getEnv, getRealPath } from "@dcloudio/uni-mp-sdk";
|
|
import { getOSRuntime as getOSRuntime1, onNativePageReady as onNativePageReady2 } from "@dcloudio/uni-mp-sdk";
|
|
import { getOSRuntime, onNativePageReady as onNativePageReady1 } from "@dcloudio/uni-mp-sdk";
|
|
import { getRealPath as getRealPath2 } from "@dcloudio/uni-mp-sdk";
|
|
import { getRealPath as getRealPath3 } from "@dcloudio/uni-mp-sdk";
|
|
import { getRealPath as getRealPath4 } from "@dcloudio/uni-mp-sdk";
|
|
import { getRealPath as getRealPath5, Emitter as Emitter3, getCurrentMP as getCurrentMP2 } from "@dcloudio/uni-mp-sdk";
|
|
import { getResourceStr } from "@dcloudio/uni-mp-sdk";
|
|
import { getWindowInfo as internalGetWindowInfo, getDeviceId as getDeviceId1 } from "@dcloudio/uni-mp-sdk";
|
|
import harmonyUrl from '@ohos.url';
|
|
import harmonyUrl1 from '@ohos.url';
|
|
import harmonyWindow from '@ohos.window';
|
|
import { http } from '@kit.NetworkKit';
|
|
import http1 from '@ohos.net.http';
|
|
import http2 from '@ohos.net.http';
|
|
import http3 from '@ohos.net.http';
|
|
import { image } from '@kit.ImageKit';
|
|
import image1 from '@ohos.multimedia.image';
|
|
import { media as media1 } from '@kit.MediaKit';
|
|
import { media as media2 } from '@kit.MediaKit';
|
|
import media3 from '@ohos.multimedia.media';
|
|
import media4 from '@ohos.multimedia.media';
|
|
import { notificationManager } from '@kit.NotificationKit';
|
|
import photoAccessHelper1 from '@ohos.file.photoAccessHelper';
|
|
import photoAccessHelper2 from '@ohos.file.photoAccessHelper';
|
|
import photoAccessHelper3 from '@ohos.file.photoAccessHelper';
|
|
import photoAccessHelper4 from '@ohos.file.photoAccessHelper';
|
|
import photoAccessHelper5 from '@ohos.file.photoAccessHelper';
|
|
import { picker, fileIo as fileIo5 } from '@kit.CoreFileKit';
|
|
import { promptAction as promptAction2 } from '@kit.ArkUI';
|
|
import { promptAction as promptAction3 } from '@kit.ArkUI';
|
|
import { promptAction as promptAction4 } from '@kit.ArkUI';
|
|
import { promptAction } from '@kit.ArkUI';
|
|
import promptAction1 from '@ohos.promptAction';
|
|
import promptAction5 from '@ohos.promptAction';
|
|
import { scanCore, scanBarcode } from '@kit.ScanKit';
|
|
import { startPullDownRefresh as internalStartPullDownRefresh, stopPullDownRefresh as internalStopPullDownRefresh } from "@dcloudio/uni-mp-sdk";
|
|
import { systemShare } from '@kit.ShareKit';
|
|
import { uni } from "@dcloudio/uni-mp-sdk";
|
|
import { uniformTypeDescriptor as uniformTypeDescriptor1 } from '@kit.ArkData';
|
|
import { userAuth } from '@kit.UserAuthenticationKit';
|
|
import util1 from '@ohos.util';
|
|
import { wantAgent } from '@kit.AbilityKit';
|
|
import { wifiManager } from '@kit.ConnectivityKit';
|
|
import { window as window1 } from '@kit.ArkUI';
|
|
import { window as window2 } from '@kit.ArkUI';
|
|
import { window } from '@kit.ArkUI';
|
|
type AddPhoneContact = (options: AddPhoneContactOptions) => void;
|
|
class AddPhoneContactSuccess extends UTSObject {
|
|
}
|
|
type AddPhoneContactSuccessCallback = (result: AddPhoneContactSuccess) => void;
|
|
type AddPhoneContactFail = UniError;
|
|
type AddPhoneContactFailCallback = (result: AddPhoneContactFail) => void;
|
|
type AddPhoneContactComplete = Object;
|
|
type AddPhoneContactCompleteCallback = (result: AddPhoneContactComplete) => void;
|
|
class AddPhoneContactOptions extends UTSObject {
|
|
photoFilePath: string | null = null;
|
|
nickName: string | null = null;
|
|
lastName: string | null = null;
|
|
middleName: string | null = null;
|
|
firstName: string | null = null;
|
|
remark: string | null = null;
|
|
mobilePhoneNumber: string | null = null;
|
|
weChatNumber: string | null = null;
|
|
addressCountry: string | null = null;
|
|
addressState: string | null = null;
|
|
addressCity: string | null = null;
|
|
addressStreet: string | null = null;
|
|
addressPostalCode: string | null = null;
|
|
organization: string | null = null;
|
|
title: string | null = null;
|
|
workFaxNumber: string | null = null;
|
|
workPhoneNumber: string | null = null;
|
|
hostNumber: string | null = null;
|
|
email: string | null = null;
|
|
url: string | null = null;
|
|
workAddressCountry: string | null = null;
|
|
workAddressState: string | null = null;
|
|
workAddressCity: string | null = null;
|
|
workAddressStreet: string | null = null;
|
|
workAddressPostalCode: string | null = null;
|
|
homeFaxNumber: string | null = null;
|
|
homePhoneNumber: string | null = null;
|
|
homeAddressCountry: string | null = null;
|
|
homeAddressState: string | null = null;
|
|
homeAddressCity: string | null = null;
|
|
homeAddressStreet: string | null = null;
|
|
homeAddressPostalCode: string | null = null;
|
|
success: AddPhoneContactSuccessCallback | null = null;
|
|
fail: AddPhoneContactFailCallback | null = null;
|
|
complete: AddPhoneContactCompleteCallback | null = null;
|
|
}
|
|
type StartSoterAuthentication = (options: StartSoterAuthenticationOptions) => void;
|
|
type SoterAuthMode = 'fingerPrint' | 'facial' | 'speech';
|
|
class StartSoterAuthenticationSuccess extends UTSObject {
|
|
errCode!: number;
|
|
authMode!: SoterAuthMode;
|
|
resultJSON: string | null = null;
|
|
resultJSONSignature: string | null = null;
|
|
errMsg!: string;
|
|
}
|
|
type StartSoterAuthenticationSuccessCallback = (result: StartSoterAuthenticationSuccess) => void;
|
|
type StartSoterAuthenticationFail = UniError;
|
|
type StartSoterAuthenticationFailCallback = (result: StartSoterAuthenticationFail) => void;
|
|
type StartSoterAuthenticationComplete = Object;
|
|
type StartSoterAuthenticationCompleteCallback = (result: StartSoterAuthenticationComplete) => void;
|
|
class StartSoterAuthenticationOptions extends UTSObject {
|
|
requestAuthModes!: SoterAuthMode[];
|
|
challenge: string | null = null;
|
|
authContent: string | null = null;
|
|
success: StartSoterAuthenticationSuccessCallback | null = null;
|
|
fail: StartSoterAuthenticationFailCallback | null = null;
|
|
complete: StartSoterAuthenticationCompleteCallback | null = null;
|
|
}
|
|
type CheckIsSupportSoterAuthentication = (options: CheckIsSupportSoterAuthenticationOptions) => void;
|
|
class CheckIsSupportSoterAuthenticationSuccess extends UTSObject {
|
|
supportMode!: SoterAuthMode[];
|
|
errMsg!: string;
|
|
}
|
|
type CheckIsSupportSoterAuthenticationSuccessCallback = (result: CheckIsSupportSoterAuthenticationSuccess) => void;
|
|
type CheckIsSupportSoterAuthenticationFail = UniError;
|
|
type CheckIsSupportSoterAuthenticationFailCallback = (result: CheckIsSupportSoterAuthenticationFail) => void;
|
|
type CheckIsSupportSoterAuthenticationComplete = Object;
|
|
type CheckIsSupportSoterAuthenticationCompleteCallback = (result: CheckIsSupportSoterAuthenticationComplete) => void;
|
|
class CheckIsSupportSoterAuthenticationOptions extends UTSObject {
|
|
success: CheckIsSupportSoterAuthenticationSuccessCallback | null = null;
|
|
fail: CheckIsSupportSoterAuthenticationFailCallback | null = null;
|
|
complete: CheckIsSupportSoterAuthenticationCompleteCallback | null = null;
|
|
}
|
|
type CheckIsSoterEnrolledInDevice = (options: CheckIsSoterEnrolledInDeviceOptions) => void;
|
|
class CheckIsSoterEnrolledInDeviceSuccess extends UTSObject {
|
|
isEnrolled!: boolean;
|
|
errMsg!: string;
|
|
}
|
|
type CheckIsSoterEnrolledInDeviceSuccessCallback = (result: CheckIsSoterEnrolledInDeviceSuccess) => void;
|
|
type CheckIsSoterEnrolledInDeviceFail = UniError;
|
|
type CheckIsSoterEnrolledInDeviceFailCallback = (result: CheckIsSoterEnrolledInDeviceFail) => void;
|
|
type CheckIsSoterEnrolledInDeviceComplete = Object;
|
|
type CheckIsSoterEnrolledInDeviceCompleteCallback = (result: CheckIsSoterEnrolledInDeviceComplete) => void;
|
|
class CheckIsSoterEnrolledInDeviceOptions extends UTSObject {
|
|
checkAuthMode!: SoterAuthMode;
|
|
success: CheckIsSoterEnrolledInDeviceSuccessCallback | null = null;
|
|
fail: CheckIsSoterEnrolledInDeviceFailCallback | null = null;
|
|
complete: CheckIsSoterEnrolledInDeviceCompleteCallback | null = null;
|
|
}
|
|
type ChooseMediaErrorCode = 1101001 | 1101005 | 1101006 | 1101008;
|
|
interface IChooseMediaError extends IUniError {
|
|
errCode: ChooseMediaErrorCode;
|
|
}
|
|
type ChooseMediaFileType = 'image' | 'video';
|
|
class ChooseMediaTempFile extends UTSObject {
|
|
tempFilePath!: string;
|
|
fileType!: ChooseMediaFileType;
|
|
size!: number;
|
|
duration: number | null = null;
|
|
height: number | null = null;
|
|
width: number | null = null;
|
|
thumbTempFilePath: string | null = null;
|
|
}
|
|
export class ChooseMediaSuccess extends UTSObject {
|
|
tempFiles!: ChooseMediaTempFile[];
|
|
type!: 'image' | 'video' | 'mix';
|
|
}
|
|
type ChooseMediaFail = IChooseMediaError;
|
|
type ChooseMediaSuccessCallback = (callback: ChooseMediaSuccess) => void;
|
|
type ChooseMediaFailCallback = (callback: ChooseMediaFail) => void;
|
|
type ChooseMediaCompleteCallback = (callback: Object) => void;
|
|
type ChooseMediaPageOrientation = "auto" | "portrait" | "landscape";
|
|
export class ChooseMediaOptions extends UTSObject {
|
|
pageOrientation: ChooseMediaPageOrientation | null = null;
|
|
count: number | null = null;
|
|
mediaType: (string[]) | null = null;
|
|
sourceType: (string[]) | null = null;
|
|
maxDuration: number | null = null;
|
|
camera: 'front' | 'back' | null = null;
|
|
success: (ChooseMediaSuccessCallback) | null = null;
|
|
fail: (ChooseMediaFailCallback) | null = null;
|
|
complete: (ChooseMediaCompleteCallback) | null = null;
|
|
}
|
|
export type ChooseMedia = (options: ChooseMediaOptions) => void;
|
|
type _MediaOrientation = 'up' | 'down' | 'left' | 'right' | 'up-mirrored' | 'down-mirrored' | 'left-mirrored' | 'right-mirrored';
|
|
class _GetVideoInfoSuccess extends UTSObject {
|
|
orientation: _MediaOrientation | null = null;
|
|
type: string | null = null;
|
|
duration!: number;
|
|
size!: number;
|
|
height!: number;
|
|
width!: number;
|
|
fps: number | null = null;
|
|
bitrate: number | null = null;
|
|
}
|
|
interface _MediaFile {
|
|
fileType: 'video' | 'image';
|
|
tempFilePath: string;
|
|
size: number;
|
|
width?: number;
|
|
height?: number;
|
|
duration?: number;
|
|
thumbTempFilePath?: string;
|
|
}
|
|
interface __ChooseMediaOptions {
|
|
mimeType: photoAccessHelper.PhotoViewMIMETypes.VIDEO_TYPE | photoAccessHelper.PhotoViewMIMETypes.IMAGE_TYPE | photoAccessHelper.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
|
|
count?: number;
|
|
sourceType?: ('album' | 'camera')[];
|
|
isOriginalSupported?: boolean;
|
|
}
|
|
interface _chooseMediaSuccessCallbackResult {
|
|
tempFiles: _MediaFile[];
|
|
}
|
|
type CameraPosition = 'back' | 'front';
|
|
type UNI_MEDIA_TYPE = 'image' | 'video' | 'mix';
|
|
export type SetClipboardData = (options: SetClipboardDataOptions) => void;
|
|
export class SetClipboardDataSuccess extends UTSObject {
|
|
}
|
|
type SetClipboardDataSuccessCallback = (result: SetClipboardDataSuccess) => void;
|
|
type SetClipboardDataFail = UniError;
|
|
type SetClipboardDataFailCallback = (result: SetClipboardDataFail) => void;
|
|
type SetClipboardDataComplete = Object;
|
|
type SetClipboardDataCompleteCallback = (result: SetClipboardDataComplete) => void;
|
|
export class SetClipboardDataOptions extends UTSObject {
|
|
data!: string;
|
|
showToast: boolean | null = null;
|
|
success: SetClipboardDataSuccessCallback | null = null;
|
|
fail: SetClipboardDataFailCallback | null = null;
|
|
complete: SetClipboardDataCompleteCallback | null = null;
|
|
}
|
|
export type GetClipboardData = (options: GetClipboardDataOptions) => void;
|
|
export class GetClipboardDataSuccess extends UTSObject {
|
|
data!: string;
|
|
}
|
|
type GetClipboardDataSuccessCallback = (result: GetClipboardDataSuccess) => void;
|
|
type GetClipboardDataFail = UniError;
|
|
type GetClipboardDataFailCallback = (result: GetClipboardDataFail) => void;
|
|
type GetClipboardDataComplete = Object;
|
|
type GetClipboardDataCompleteCallback = (result: GetClipboardDataComplete) => void;
|
|
export class GetClipboardDataOptions extends UTSObject {
|
|
success: GetClipboardDataSuccessCallback | null = null;
|
|
fail: GetClipboardDataFailCallback | null = null;
|
|
complete: GetClipboardDataCompleteCallback | null = null;
|
|
}
|
|
class ClipboardCallbackOptions extends UTSObject {
|
|
data!: string;
|
|
result!: 'success' | 'fail';
|
|
}
|
|
type ClipboardCallback = (res: ClipboardCallbackOptions) => void;
|
|
type CreateInnerAudioContext = () => InnerAudioContext;
|
|
interface InnerAudioContext {
|
|
duration: number;
|
|
currentTime: number;
|
|
paused: boolean;
|
|
src: string;
|
|
startTime: number;
|
|
buffered: number;
|
|
autoplay: boolean;
|
|
loop: boolean;
|
|
obeyMuteSwitch: boolean;
|
|
volume: number;
|
|
playbackRate?: number;
|
|
pause(): void;
|
|
stop(): void;
|
|
play(): void;
|
|
seek(position: number): void;
|
|
destroy(): void;
|
|
onCanplay(callback: (result: Object) => void): void;
|
|
onPlay(callback: (result: Object) => void): void;
|
|
onPause(callback: (result: Object) => void): void;
|
|
onStop(callback: (result: Object) => void): void;
|
|
onEnded(callback: (result: Object) => void): void;
|
|
onTimeUpdate(callback: (result: Object) => void): void;
|
|
onError(callback: (result: ICreateInnerAudioContextFail) => void): void;
|
|
onWaiting(callback: (result: Object) => void): void;
|
|
onSeeking(callback: (result: Object) => void): void;
|
|
onSeeked(callback: (result: Object) => void): void;
|
|
offCanplay(callback: (result: Object) => void): void;
|
|
offPlay(callback: (result: Object) => void): void;
|
|
offPause(callback: (result: Object) => void): void;
|
|
offStop(callback: (result: Object) => void): void;
|
|
offEnded(callback: (result: Object) => void): void;
|
|
offTimeUpdate(callback: (result: Object) => void): void;
|
|
offError(callback: (result: ICreateInnerAudioContextFail) => void): void;
|
|
offWaiting(callback: (result: Object) => void): void;
|
|
offSeeking(callback: (result: Object) => void): void;
|
|
offSeeked(callback: (result: Object) => void): void;
|
|
}
|
|
type CreateInnerAudioContextErrorCode = 1107601 | 1107602 | 1107603 | 1107604 | 1107605 | 1107609;
|
|
interface ICreateInnerAudioContextFail extends IUniError {
|
|
errCode: CreateInnerAudioContextErrorCode;
|
|
}
|
|
type $OnCallback = Function;
|
|
type $On = (eventName: string, callback: $OnCallback) => number;
|
|
type $OnceCallback = Function;
|
|
type $Once = (eventName: string, callback: $OnceCallback) => number;
|
|
type $Off = (eventName: string, callback?: Object | null) => void;
|
|
type $Emit = (eventName: string, ...args: Array<Object | null>) => void;
|
|
interface IUniEventEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function | null) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
class ExitSuccess extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type ExitErrorCode = 12001 | 12002 | 12003;
|
|
interface IExitError extends IUniError {
|
|
errCode: ExitErrorCode;
|
|
}
|
|
type ExitFail = IExitError;
|
|
type ExitSuccessCallback = (res: ExitSuccess) => void;
|
|
type ExitFailCallback = (res: ExitFail) => void;
|
|
type ExitCompleteCallback = (res: Object) => void;
|
|
class ExitOptions extends UTSObject {
|
|
success: ExitSuccessCallback | null = null;
|
|
fail: ExitFailCallback | null = null;
|
|
complete: ExitCompleteCallback | null = null;
|
|
}
|
|
type Exit = (options?: ExitOptions | null) => void;
|
|
export class LegacySaveFileSuccess extends UTSObject {
|
|
savedFilePath!: string;
|
|
}
|
|
type LegacySaveFileSuccessCallback = (res: LegacySaveFileSuccess) => void;
|
|
export class LegacySaveFileFail extends UTSObject {
|
|
}
|
|
type LegacySaveFileFailCallback = (res: LegacySaveFileFail) => void;
|
|
type LegacySaveFileCompleteCallback = (res: Object) => void;
|
|
export class LegacySaveFileOptions extends UTSObject {
|
|
tempFilePath!: string;
|
|
success: LegacySaveFileSuccessCallback | null = null;
|
|
fail: LegacySaveFileFailCallback | null = null;
|
|
complete: LegacySaveFileCompleteCallback | null = null;
|
|
}
|
|
export class LegacyGetFileInfoSuccess extends UTSObject {
|
|
digest!: string;
|
|
size!: number;
|
|
}
|
|
type LegacyGetFileInfoSuccessCallback = (res: LegacyGetFileInfoSuccess) => void;
|
|
export class LegacyGetFileInfoFail extends UTSObject {
|
|
}
|
|
type LegacyGetFileInfoFailCallback = (res: LegacyGetFileInfoFail) => void;
|
|
type LegacyGetFileInfoCompleteCallback = (res: Object) => void;
|
|
export class LegacyGetFileInfoOptions extends UTSObject {
|
|
filePath!: string;
|
|
digestAlgorithm: string | null = null;
|
|
success: LegacyGetFileInfoSuccessCallback | null = null;
|
|
fail: LegacyGetFileInfoFailCallback | null = null;
|
|
complete: LegacyGetFileInfoCompleteCallback | null = null;
|
|
}
|
|
export class LegacyGetSavedFileInfoSuccess extends UTSObject {
|
|
size!: number;
|
|
createTime!: number;
|
|
}
|
|
type LegacyGetSavedFileInfoSuccessCallback = (res: LegacyGetSavedFileInfoSuccess) => void;
|
|
export class LegacyGetSavedFileInfoFail extends UTSObject {
|
|
}
|
|
type LegacyGetSavedFileInfoFailCallback = (res: LegacyGetSavedFileInfoFail) => void;
|
|
type LegacyGetSavedFileInfoCompleteCallback = (res: Object) => void;
|
|
export class LegacyGetSavedFileInfoOptions extends UTSObject {
|
|
filePath!: string;
|
|
success: LegacyGetSavedFileInfoSuccessCallback | null = null;
|
|
fail: LegacyGetSavedFileInfoFailCallback | null = null;
|
|
complete: LegacyGetSavedFileInfoCompleteCallback | null = null;
|
|
}
|
|
export class LegacyRemoveSavedFileSuccess extends UTSObject {
|
|
}
|
|
type LegacyRemoveSavedFileSuccessCallback = (res: LegacyRemoveSavedFileSuccess) => void;
|
|
export class LegacyRemoveSavedFileFail extends UTSObject {
|
|
}
|
|
type LegacyRemoveSavedFileFailCallback = (res: LegacyRemoveSavedFileFail) => void;
|
|
type LegacyRemoveSavedFileCompleteCallback = (res: Object) => void;
|
|
export class LegacyRemoveSavedFileOptions extends UTSObject {
|
|
filePath!: string;
|
|
success: LegacyRemoveSavedFileSuccessCallback | null = null;
|
|
fail: LegacyRemoveSavedFileFailCallback | null = null;
|
|
complete: LegacyRemoveSavedFileCompleteCallback | null = null;
|
|
}
|
|
export class LegacySavedFileListItem extends UTSObject {
|
|
filePath!: string;
|
|
size!: number;
|
|
createTime!: number;
|
|
}
|
|
export class LegacyGetSavedFileListSuccess extends UTSObject {
|
|
fileList!: LegacySavedFileListItem[];
|
|
}
|
|
type LegacyGetSavedFileListSuccessCallback = (res: LegacyGetSavedFileListSuccess) => void;
|
|
export class LegacyGetSavedFileListFail extends UTSObject {
|
|
}
|
|
type LegacyGetSavedFileListFailCallback = (res: LegacyGetSavedFileListFail) => void;
|
|
type LegacyGetSavedFileListCompleteCallback = (res: Object) => void;
|
|
export class LegacyGetSavedFileListOptions extends UTSObject {
|
|
success: LegacyGetSavedFileListSuccessCallback | null = null;
|
|
fail: LegacyGetSavedFileListFailCallback | null = null;
|
|
complete: LegacyGetSavedFileListCompleteCallback | null = null;
|
|
}
|
|
export type SaveFile = (options?: LegacySaveFileOptions | null) => void;
|
|
export type GetFileInfo = (options?: LegacyGetFileInfoOptions | null) => void;
|
|
export type GetSavedFileInfo = (options?: LegacyGetSavedFileInfoOptions | null) => void;
|
|
export type RemoveSavedFile = (options?: LegacyRemoveSavedFileOptions | null) => void;
|
|
export type GetSavedFileList = (options?: LegacyGetSavedFileListOptions | null) => void;
|
|
class ReadFileSuccessResult extends UTSObject {
|
|
data!: Object;
|
|
}
|
|
class OpenFileSuccessResult extends UTSObject {
|
|
fd!: string;
|
|
errMsg: string | null = null;
|
|
}
|
|
class FileManagerSuccessResult extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type FileManagerSuccessCallback = (res: FileManagerSuccessResult) => void;
|
|
type FileManagerFailCallback = (res: FileSystemManagerFail) => void;
|
|
type FileManagerCompleteCallback = (res: Object) => void;
|
|
type ReadFileSuccessCallback = (res: ReadFileSuccessResult) => void;
|
|
class ReadFileOptions extends UTSObject {
|
|
encoding: "base64" | "utf-8" | "ascii" | null = null;
|
|
filePath!: string.URIString;
|
|
success: ReadFileSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class WriteFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
data!: Object;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class AppendFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
data!: Object;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
type OpenFileSuccessCallback = (res: OpenFileSuccessResult) => void;
|
|
class OpenFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
flag!: "a" | "ax" | "a+" | "ax+" | "r" | "r+" | "w" | "wx" | "w+" | "wx" | "wx+";
|
|
success: OpenFileSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class OpenFileSyncOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
flag!: "a" | "ax" | "a+" | "ax+" | "r" | "r+" | "w" | "wx" | "w+" | "wx" | "wx+";
|
|
}
|
|
type UnLinkSuccessCallback = (res: FileManagerSuccessResult) => void;
|
|
class UnLinkOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
success: UnLinkSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
type MkDirSuccessCallback = (res: FileManagerSuccessResult) => void;
|
|
class MkDirOptions extends UTSObject {
|
|
dirPath!: string.URIString;
|
|
recursive!: boolean;
|
|
success: MkDirSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class RmDirOptions extends UTSObject {
|
|
dirPath!: string.URIString;
|
|
recursive!: boolean;
|
|
success: MkDirSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class ReadDirSuccessResult extends UTSObject {
|
|
files!: string[];
|
|
errMsg: string | null = null;
|
|
}
|
|
type ReadDirSuccessCallback = (res: ReadDirSuccessResult) => void;
|
|
class ReadDirOptions extends UTSObject {
|
|
dirPath!: string.URIString;
|
|
success: ReadDirSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class AccessOptions extends UTSObject {
|
|
path!: string.URIString;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class RenameOptions extends UTSObject {
|
|
oldPath!: string.URIString;
|
|
newPath!: string.URIString;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class CopyFileOptions extends UTSObject {
|
|
srcPath!: string.URIString;
|
|
destPath!: string.URIString;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class SaveFileOptions extends UTSObject {
|
|
tempFilePath!: string.URIString;
|
|
filePath: string.URIString | null = null;
|
|
success: SaveFileSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
type SaveFileSuccessCallback = (res: SaveFileSuccessResult) => void;
|
|
class SaveFileSuccessResult extends UTSObject {
|
|
savedFilePath!: string;
|
|
}
|
|
class GetFileInfoSuccessResult extends UTSObject {
|
|
digest!: string;
|
|
size!: number;
|
|
errMsg!: string;
|
|
}
|
|
type GetFileInfoSuccessCallback = (res: GetFileInfoSuccessResult) => void;
|
|
class GetFileInfoOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
digestAlgorithm: "md5" | "sha1" | null = null;
|
|
success: GetFileInfoSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
interface Stats {
|
|
mode: number;
|
|
size: number;
|
|
lastAccessedTime: number;
|
|
lastModifiedTime: number;
|
|
mIsFile: boolean;
|
|
isDirectory(): boolean;
|
|
isFile(): boolean;
|
|
}
|
|
class FileStats extends UTSObject {
|
|
path!: string;
|
|
stats!: Stats;
|
|
}
|
|
class StatSuccessResult extends UTSObject {
|
|
errMsg!: string;
|
|
stats!: FileStats[];
|
|
}
|
|
type StatSuccessCallback = (res: StatSuccessResult) => void;
|
|
class StatOptions extends UTSObject {
|
|
path!: string.URIString;
|
|
recursive!: boolean;
|
|
success: StatSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class UnzipFileOptions extends UTSObject {
|
|
zipFilePath!: string;
|
|
targetPath!: string;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class GetSavedFileListResult extends UTSObject {
|
|
fileList!: string[];
|
|
}
|
|
type GetSavedFileListCallback = (res: GetSavedFileListResult) => void;
|
|
class GetSavedFileListOptions extends UTSObject {
|
|
success: GetSavedFileListCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class TruncateFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
length!: number;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class ReadCompressedFileResult extends UTSObject {
|
|
data!: string;
|
|
}
|
|
type ReadCompressedFileCallback = (res: ReadCompressedFileResult) => void;
|
|
class ReadCompressedFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
compressionAlgorithm!: "br";
|
|
success: ReadCompressedFileCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class RemoveSavedFileOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class WriteResult extends UTSObject {
|
|
bytesWritten!: number;
|
|
errMsg!: string;
|
|
}
|
|
type WriteCallback = (res: WriteResult) => void;
|
|
class WriteOptions extends UTSObject {
|
|
fd!: string;
|
|
data!: Object;
|
|
offset: number | null = null;
|
|
length: number | null = null;
|
|
position: number | null = null;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
success: WriteCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class WriteSyncOptions extends UTSObject {
|
|
fd!: string;
|
|
data!: Object;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
length: number | null = null;
|
|
offset: number | null = null;
|
|
position: number | null = null;
|
|
}
|
|
class CloseOptions extends UTSObject {
|
|
fd!: string;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class CloseSyncOptions extends UTSObject {
|
|
fd!: string;
|
|
}
|
|
class FStatSuccessResult extends UTSObject {
|
|
stats!: Stats;
|
|
}
|
|
type FStatSuccessCallback = (res: FStatSuccessResult) => void;
|
|
class FStatOptions extends UTSObject {
|
|
fd!: string;
|
|
success: FStatSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class FStatSyncOptions extends UTSObject {
|
|
fd!: string;
|
|
}
|
|
class FTruncateFileOptions extends UTSObject {
|
|
fd!: string;
|
|
length!: number;
|
|
success: FileManagerSuccessCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class FTruncateFileSyncOptions extends UTSObject {
|
|
fd!: string;
|
|
length!: number;
|
|
}
|
|
class EntryItem extends UTSObject {
|
|
path!: string;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
}
|
|
class EntriesResult extends UTSObject {
|
|
entries!: Map<string, ZipFileItem>;
|
|
result!: Map<string, ZipFileItem>;
|
|
errMsg: string | null = null;
|
|
}
|
|
class ZipFileItem extends UTSObject {
|
|
data: Object | null = null;
|
|
errMsg!: string;
|
|
}
|
|
type ReadZipEntryCallback = (res: EntriesResult) => void;
|
|
class ReadZipEntryOptions extends UTSObject {
|
|
filePath!: string.URIString;
|
|
encoding: "ascii" | "base64" | "utf-8" | null = null;
|
|
entries: EntryItem[] | null = null;
|
|
success: ReadZipEntryCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
}
|
|
class ReadSuccessCallbackResult extends UTSObject {
|
|
arrayBuffer!: ArrayBuffer;
|
|
bytesRead!: number;
|
|
errMsg!: string;
|
|
}
|
|
type ReadSuccessCallback = (result: ReadSuccessCallbackResult) => void;
|
|
class ReadOption extends UTSObject {
|
|
arrayBuffer!: ArrayBuffer;
|
|
fd!: string;
|
|
length: number | null = null;
|
|
offset: number | null = null;
|
|
position: number | null = null;
|
|
complete: FileManagerCompleteCallback | null = null;
|
|
fail: FileManagerFailCallback | null = null;
|
|
success: ReadSuccessCallback | null = null;
|
|
}
|
|
class ReadSyncOption extends UTSObject {
|
|
arrayBuffer!: ArrayBuffer;
|
|
fd!: string;
|
|
length: number | null = null;
|
|
offset: number | null = null;
|
|
position: number | null = null;
|
|
}
|
|
class ReadResult extends UTSObject {
|
|
arrayBuffer!: ArrayBuffer;
|
|
bytesRead!: number;
|
|
}
|
|
interface FileSystemManager {
|
|
readFile(options: ReadFileOptions): void;
|
|
readFileSync(filePath: string, encoding?: string): Object;
|
|
writeFile(options: WriteFileOptions): void;
|
|
read(option: ReadOption): void;
|
|
readSync(option: ReadSyncOption): ReadResult;
|
|
writeFileSync(filePath: string, data: Object, encoding?: string): void;
|
|
unlink(options: UnLinkOptions): void;
|
|
unlinkSync(filePath: string): void;
|
|
mkdir(options: MkDirOptions): void;
|
|
mkdirSync(dirPath: string, recursive: boolean): void;
|
|
rmdir(options: RmDirOptions): void;
|
|
rmdirSync(dirPath: string, recursive: boolean): void;
|
|
readdir(options: ReadDirOptions): void;
|
|
readdirSync(dirPath: string): string[] | null;
|
|
access(options: AccessOptions): void;
|
|
accessSync(path: string): void;
|
|
rename(options: RenameOptions): void;
|
|
renameSync(oldPath: string, newPath: string): void;
|
|
copyFile(options: CopyFileOptions): void;
|
|
copyFileSync(srcPath: string, destPath: string): void;
|
|
getFileInfo(options: GetFileInfoOptions): void;
|
|
stat(options: StatOptions): void;
|
|
statSync(path: string, recursive: boolean): FileStats[];
|
|
appendFile(options: AppendFileOptions): void;
|
|
appendFileSync(filePath: string, data: Object, encoding?: string): void;
|
|
saveFile(options: SaveFileOptions): void;
|
|
saveFileSync(tempFilePath: string, filePath: string | null): string;
|
|
removeSavedFile(options: RemoveSavedFileOptions): void;
|
|
unzip(options: UnzipFileOptions): void;
|
|
getSavedFileList(options: GetSavedFileListOptions): void;
|
|
truncate(options: TruncateFileOptions): void;
|
|
truncateSync(filePath: string, length?: number): void;
|
|
readCompressedFile(options: ReadCompressedFileOptions): void;
|
|
readCompressedFileSync(filePath: string, compressionAlgorithm: string): string;
|
|
open(options: OpenFileOptions): void;
|
|
openSync(options: OpenFileSyncOptions): string;
|
|
write(options: WriteOptions): void;
|
|
writeSync(options: WriteSyncOptions): WriteResult;
|
|
close(options: CloseOptions): void;
|
|
closeSync(options: CloseSyncOptions): void;
|
|
fstat(options: FStatOptions): void;
|
|
fstatSync(options: FStatSyncOptions): Stats;
|
|
ftruncate(options: FTruncateFileOptions): void;
|
|
ftruncateSync(options: FTruncateFileSyncOptions): void;
|
|
readZipEntry(options: ReadZipEntryOptions): void;
|
|
}
|
|
type GetFileSystemManager = () => FileSystemManager;
|
|
type FileSystemManagerErrorCode = 1200002 | 1300002 | 1300013 | 1300021 | 1300022 | 1300066 | 1301003 | 1301005 | 1300201 | 1300202 | 1301111 | 1302003 | 1300009 | 1300010 | 1300011 | 1300012 | 1300015 | 1300014 | 1300016 | 1300017 | 1300018 | 1300019 | 1300020 | 1300021;
|
|
type FileSystemManagerFail = IFileSystemManagerFail;
|
|
interface IFileSystemManagerFail extends IUniError {
|
|
errCode: FileSystemManagerErrorCode;
|
|
}
|
|
interface CallBack {
|
|
success?: Function | null;
|
|
fail?: Function | null;
|
|
complete?: Function | null;
|
|
}
|
|
type ModeReflect = Record<string, string>;
|
|
type BaseType = number | string | boolean | null | undefined;
|
|
type DataType = BaseType | Object | Function | ArrayBuffer | Array<BaseType>;
|
|
interface CustomValidReturn {
|
|
isValid: false;
|
|
err: IFileSystemManagerFail;
|
|
}
|
|
interface CustomValidReturnValid {
|
|
isValid: true;
|
|
}
|
|
interface ObtainUpperPathReturn {
|
|
index: number;
|
|
upperPath: string;
|
|
}
|
|
interface ObtainFileNameReturn {
|
|
index: number;
|
|
fileName: string;
|
|
}
|
|
interface CheckFd {
|
|
isValid: true;
|
|
fd: number;
|
|
}
|
|
interface CheckFdErr {
|
|
isValid: false;
|
|
fd: number;
|
|
err: IFileSystemManagerFail;
|
|
}
|
|
interface CheckEncodingReturn {
|
|
isValid: boolean;
|
|
errMsg: string;
|
|
}
|
|
interface FileSystemManagerApiError extends ApiError {
|
|
errMsg: string;
|
|
}
|
|
type _FLAG = "a" | "ax" | "a+" | "ax+" | "r" | "r+" | "w" | "wx" | "w+" | "wx+";
|
|
type GetAppAuthorizeSetting = () => GetAppAuthorizeSettingResult;
|
|
class GetAppAuthorizeSettingResult extends UTSObject {
|
|
albumAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
bluetoothAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
cameraAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
locationAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
locationAccuracy: 'reduced' | 'full' | 'unsupported' | null = null;
|
|
locationReducedAccuracy: boolean | null = null;
|
|
microphoneAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
notificationAuthorized!: 'authorized' | 'denied' | 'not determined' | 'config error';
|
|
notificationAlertAuthorized: 'authorized' | 'denied' | 'not determined' | 'config error' | null = null;
|
|
notificationBadgeAuthorized: 'authorized' | 'denied' | 'not determined' | 'config error' | null = null;
|
|
notificationSoundAuthorized: 'authorized' | 'denied' | 'not determined' | 'config error' | null = null;
|
|
phoneCalendarAuthorized: 'authorized' | 'denied' | 'not determined' | null = null;
|
|
}
|
|
class GetAppBaseInfoOptions extends UTSObject {
|
|
filter!: Array<string>;
|
|
}
|
|
export class GetAppBaseInfoResult extends UTSObject {
|
|
appId: string | null = null;
|
|
appName: string | null = null;
|
|
appVersion: string | null = null;
|
|
appVersionCode: string | null = null;
|
|
appLanguage: string | null = null;
|
|
language: string | null = null;
|
|
version: string | null = null;
|
|
appWgtVersion: string | null = null;
|
|
hostLanguage: string | null = null;
|
|
hostVersion: string | null = null;
|
|
hostName: string | null = null;
|
|
hostPackageName: string | null = null;
|
|
hostSDKVersion: string | null = null;
|
|
hostTheme: string | null = null;
|
|
isUniAppX: boolean | null = null;
|
|
uniCompileVersion: string | null = null;
|
|
uniCompilerVersion: string | null = null;
|
|
uniPlatform: 'app' | 'web' | 'mp-weixin' | 'mp-alipay' | 'mp-baidu' | 'mp-toutiao' | 'mp-lark' | 'mp-qq' | 'mp-kuaishou' | 'mp-jd' | 'mp-360' | 'quickapp-webview' | 'quickapp-webview-union' | 'quickapp-webview-huawei' | null = null;
|
|
uniRuntimeVersion: string | null = null;
|
|
uniCompileVersionCode: number | null = null;
|
|
uniCompilerVersionCode: number | null = null;
|
|
uniRuntimeVersionCode: number | null = null;
|
|
packageName: string | null = null;
|
|
bundleId: string | null = null;
|
|
signature: string | null = null;
|
|
appTheme: 'light' | 'dark' | 'auto' | null = null;
|
|
channel: string | null = null;
|
|
}
|
|
export type GetAppBaseInfo = (options?: GetAppBaseInfoOptions | null) => GetAppBaseInfoResult;
|
|
interface IAppBaseInfoAppVersion {
|
|
name: string;
|
|
code: string;
|
|
}
|
|
type GetBackgroundAudioManager = () => BackgroundAudioManager;
|
|
interface BackgroundAudioManager {
|
|
duration: number;
|
|
currentTime: number;
|
|
paused: boolean;
|
|
src: string;
|
|
startTime: number;
|
|
buffered: number;
|
|
title: string;
|
|
epname: string;
|
|
singer: string;
|
|
coverImgUrl: string;
|
|
webUrl: string;
|
|
protocol: string;
|
|
playbackRate?: number;
|
|
play(): void;
|
|
pause(): void;
|
|
seek(position: number): void;
|
|
stop(): void;
|
|
onCanplay(callback: (result: Object) => void): void;
|
|
onPlay(callback: (result: Object) => void): void;
|
|
onPause(callback: (result: Object) => void): void;
|
|
onStop(callback: (result: Object) => void): void;
|
|
onEnded(callback: (result: Object) => void): void;
|
|
onSeeking(callback: (result: Object) => void): void;
|
|
onSeeked(callback: (result: Object) => void): void;
|
|
onTimeUpdate(callback: (result: Object) => void): void;
|
|
onPrev(callback: (result: Object) => void): void;
|
|
onNext(callback: (result: Object) => void): void;
|
|
onError(callback: (result: ICreateBackgroundAudioFail) => void): void;
|
|
onWaiting(callback: (result: Object) => void): void;
|
|
}
|
|
type CreateBackgroundAudioErrorCode = 1107601 | 1107602 | 1107603 | 1107604 | 1107605 | 1107609;
|
|
interface ICreateBackgroundAudioFail extends IUniError {
|
|
errCode: CreateBackgroundAudioErrorCode;
|
|
}
|
|
interface TempAbilityInfo {
|
|
bundleName: string;
|
|
name: string;
|
|
}
|
|
class GetDeviceInfoOptions extends UTSObject {
|
|
filter!: Array<string>;
|
|
}
|
|
export class GetDeviceInfoResult extends UTSObject {
|
|
brand: string | null = null;
|
|
deviceBrand: string | null = null;
|
|
deviceId: string | null = null;
|
|
model: string | null = null;
|
|
deviceModel: string | null = null;
|
|
deviceType: 'phone' | 'pad' | 'tv' | 'watch' | 'pc' | 'undefined' | 'car' | 'vr' | 'appliance' | null = null;
|
|
deviceOrientation: string | null = null;
|
|
devicePixelRatio: number | null = null;
|
|
system: string | null = null;
|
|
platform: 'ios' | 'android' | 'harmonyos' | 'mac' | 'windows' | 'linux' | null = null;
|
|
isRoot: boolean | null = null;
|
|
isSimulator: boolean | null = null;
|
|
isUSBDebugging: boolean | null = null;
|
|
osName: 'ios' | 'android' | 'harmonyos' | 'macos' | 'windows' | 'linux' | null = null;
|
|
osVersion: string | null = null;
|
|
osLanguage: string | null = null;
|
|
osTheme: 'light' | 'dark' | null = null;
|
|
osAndroidAPILevel: number | null = null;
|
|
romName: string | null = null;
|
|
romVersion: string | null = null;
|
|
}
|
|
export type GetDeviceInfo = (options?: GetDeviceInfoOptions | null) => GetDeviceInfoResult;
|
|
type GetNetworkType = (options: GetNetworkTypeOptions) => void;
|
|
class GetNetworkTypeSuccess extends UTSObject {
|
|
networkType!: string;
|
|
}
|
|
type GetNetworkTypeSuccessCallback = (result: GetNetworkTypeSuccess) => void;
|
|
type GetNetworkTypeFail = UniError;
|
|
type GetNetworkTypeFailCallback = (result: GetNetworkTypeFail) => void;
|
|
type GetNetworkTypeComplete = Object;
|
|
type GetNetworkTypeCompleteCallback = (result: GetNetworkTypeComplete) => void;
|
|
class GetNetworkTypeOptions extends UTSObject {
|
|
success: GetNetworkTypeSuccessCallback | null = null;
|
|
fail: GetNetworkTypeFailCallback | null = null;
|
|
complete: GetNetworkTypeCompleteCallback | null = null;
|
|
}
|
|
class OnNetworkStatusChangeCallbackResult extends UTSObject {
|
|
isConnected!: boolean;
|
|
networkType!: string;
|
|
}
|
|
type OnNetworkStatusChangeCallback = (result: OnNetworkStatusChangeCallbackResult) => void;
|
|
type OnNetworkStatusChange = (callback: OnNetworkStatusChangeCallback) => void;
|
|
type OffNetworkStatusChange = (callback: (result: Object) => void) => void;
|
|
interface IUniGetNetworkTypeEventEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
export class GetProviderSuccess extends UTSObject {
|
|
service!: 'payment' | 'oauth';
|
|
provider!: string[];
|
|
providers!: UniProvider[];
|
|
}
|
|
export class GetProviderSyncSuccess extends UTSObject {
|
|
service!: 'payment' | 'location' | 'oauth';
|
|
providerIds!: string[];
|
|
providerObjects!: UniProvider[];
|
|
}
|
|
export type GetProviderSync = (options: GetProviderSyncOptions) => GetProviderSyncSuccess;
|
|
export class GetProviderSyncOptions extends UTSObject {
|
|
service!: 'payment' | 'location' | 'oauth';
|
|
}
|
|
type GetProviderSuccessCallback = (result: GetProviderSuccess) => void;
|
|
type GetProviderFail = IGetProviderFail;
|
|
type GetProviderFailCallback = (result: GetProviderFail) => void;
|
|
type GetProviderComplete = Object;
|
|
type GetProviderCompleteCallback = (result: GetProviderComplete) => void;
|
|
export class GetProviderOptions extends UTSObject {
|
|
service!: 'payment' | 'oauth';
|
|
success: GetProviderSuccessCallback | null = null;
|
|
fail: GetProviderFailCallback | null = null;
|
|
complete: GetProviderCompleteCallback | null = null;
|
|
}
|
|
export type GetProvider = (options: GetProviderOptions) => void;
|
|
type ProviderErrorCode = 110600;
|
|
interface IGetProviderFail extends IUniError {
|
|
errCode: ProviderErrorCode;
|
|
}
|
|
type GetRecorderManager = () => RecorderManager;
|
|
class RecorderManagerStartOptions extends UTSObject {
|
|
duration: number | null = null;
|
|
sampleRate: number | null = null;
|
|
numberOfChannels: number | null = null;
|
|
encodeBitRate: number | null = null;
|
|
format: 'aac' | 'mp3' | 'PCM' | 'wav' | null = null;
|
|
frameSize: number | null = null;
|
|
}
|
|
interface RecorderManagerOnStopResult {
|
|
tempFilePath: string;
|
|
}
|
|
interface RecorderManager {
|
|
start(options: RecorderManagerStartOptions): void;
|
|
pause(): void;
|
|
resume(): void;
|
|
stop(): void;
|
|
onStart(options: (result: Object) => void): void;
|
|
onPause(options: (result: Object) => void): void;
|
|
onStop(options: (result: RecorderManagerOnStopResult) => void): void;
|
|
onFrameRecorded(options: (result: Object) => void): void;
|
|
onError(options: (result: Object) => void): void;
|
|
onResume?: (options: (result: Object) => void) => void;
|
|
onInterruptionBegin?: (options: (result: Object) => void) => void;
|
|
onInterruptionEnd?: (options: (result: Object) => void) => void;
|
|
}
|
|
type RecorderState = 'pause' | 'resume' | 'start' | 'stop' | 'error' | 'frameRecorded' | 'interruptionBegin' | 'interruptionEnd';
|
|
interface Callbacks {
|
|
pause?: Function;
|
|
resume?: Function;
|
|
start?: Function;
|
|
stop?: Function;
|
|
error?: Function;
|
|
frameRecorded?: Function;
|
|
interruptionBegin?: Function;
|
|
interruptionEnd?: Function;
|
|
}
|
|
interface StateChangeRes extends RecorderManagerOnStopResult {
|
|
errMsg?: string;
|
|
frameBuffer?: ArrayBuffer;
|
|
isLastFrame?: boolean;
|
|
}
|
|
export type GetSystemInfo = (options: GetSystemInfoOptions) => void;
|
|
export type GetSystemInfoSync = () => GetSystemInfoResult;
|
|
export type GetWindowInfo = () => GetWindowInfoResult;
|
|
export class SafeArea extends UTSObject {
|
|
left!: number;
|
|
right!: number;
|
|
top!: number;
|
|
bottom!: number;
|
|
width!: number;
|
|
height!: number;
|
|
}
|
|
export class SafeAreaInsets extends UTSObject {
|
|
left!: number;
|
|
right!: number;
|
|
top!: number;
|
|
bottom!: number;
|
|
}
|
|
export class GetSystemInfoResult extends UTSObject {
|
|
SDKVersion!: string;
|
|
appId!: string;
|
|
appLanguage!: string;
|
|
appName!: string;
|
|
appVersion!: string;
|
|
appVersionCode!: string;
|
|
appWgtVersion: string | null = null;
|
|
brand!: string;
|
|
browserName!: string;
|
|
browserVersion!: string;
|
|
deviceId!: string;
|
|
deviceBrand!: string;
|
|
deviceModel!: string;
|
|
deviceType!: 'phone' | 'pad' | 'tv' | 'watch' | 'pc' | 'undefined' | 'car' | 'vr' | 'appliance';
|
|
devicePixelRatio!: number;
|
|
deviceOrientation!: 'portrait' | 'landscape';
|
|
language!: string;
|
|
model: string | null = null;
|
|
osName!: 'ios' | 'android' | 'harmonyos' | 'macos' | 'windows' | 'linux';
|
|
osVersion!: string;
|
|
osLanguage!: string;
|
|
osTheme: 'light' | 'dark' | null = null;
|
|
pixelRatio!: number;
|
|
platform!: 'ios' | 'android' | 'harmonyos' | 'mac' | 'windows' | 'linux';
|
|
screenWidth!: number;
|
|
screenHeight!: number;
|
|
statusBarHeight!: number;
|
|
system!: string;
|
|
safeArea!: SafeArea;
|
|
safeAreaInsets!: SafeAreaInsets;
|
|
ua!: string;
|
|
uniCompileVersion!: string;
|
|
uniCompilerVersion!: string;
|
|
uniPlatform!: 'app' | 'web' | 'mp-weixin' | 'mp-alipay' | 'mp-baidu' | 'mp-toutiao' | 'mp-lark' | 'mp-qq' | 'mp-kuaishou' | 'mp-jd' | 'mp-360' | 'quickapp-webview' | 'quickapp-webview-union' | 'quickapp-webview-huawei';
|
|
uniRuntimeVersion!: string;
|
|
uniCompileVersionCode!: number;
|
|
uniCompilerVersionCode!: number;
|
|
uniRuntimeVersionCode!: number;
|
|
version!: string;
|
|
romName!: string;
|
|
romVersion!: string;
|
|
windowWidth!: number;
|
|
windowHeight!: number;
|
|
windowTop!: number;
|
|
windowBottom!: number;
|
|
osAndroidAPILevel: number | null = null;
|
|
appTheme: 'light' | 'dark' | 'auto' | null = null;
|
|
}
|
|
type GetSystemInfoSuccessCallback = (result: GetSystemInfoResult) => void;
|
|
type GetSystemInfoFail = UniError;
|
|
type GetSystemInfoFailCallback = (result: GetSystemInfoFail) => void;
|
|
type GetSystemInfoComplete = Object;
|
|
type GetSystemInfoCompleteCallback = (result: GetSystemInfoComplete) => void;
|
|
export class GetSystemInfoOptions extends UTSObject {
|
|
success: GetSystemInfoSuccessCallback | null = null;
|
|
fail: GetSystemInfoFailCallback | null = null;
|
|
complete: GetSystemInfoCompleteCallback | null = null;
|
|
}
|
|
export class GetWindowInfoResult extends UTSObject {
|
|
pixelRatio!: number;
|
|
screenWidth!: number;
|
|
screenHeight!: number;
|
|
windowWidth!: number;
|
|
windowHeight!: number;
|
|
statusBarHeight!: number;
|
|
windowTop!: number;
|
|
windowBottom!: number;
|
|
safeArea!: SafeArea;
|
|
safeAreaInsets!: SafeAreaInsets;
|
|
screenTop!: number;
|
|
}
|
|
interface ISystemInfoAppVersion {
|
|
name: string;
|
|
code: string;
|
|
}
|
|
class GetSystemSettingResult extends UTSObject {
|
|
bluetoothEnabled: boolean | null = null;
|
|
bluetoothError: string | null = null;
|
|
locationEnabled!: boolean;
|
|
wifiEnabled: boolean | null = null;
|
|
wifiError: string | null = null;
|
|
deviceOrientation!: 'portrait' | 'landscape';
|
|
}
|
|
type GetSystemSetting = () => GetSystemSettingResult;
|
|
export class HideKeyboardSuccess extends UTSObject {
|
|
}
|
|
export class HideKeyboardFail extends UTSObject {
|
|
}
|
|
type HideKeyboardSuccessCallback = (res: HideKeyboardSuccess) => void;
|
|
type HideKeyboardFailCallback = (res: HideKeyboardFail) => void;
|
|
type HideKeyboardCompleteCallback = (res: Object) => void;
|
|
export class HideKeyboardOptions extends UTSObject {
|
|
success: HideKeyboardSuccessCallback | null = null;
|
|
fail: HideKeyboardFailCallback | null = null;
|
|
complete: HideKeyboardCompleteCallback | null = null;
|
|
}
|
|
type HideKeyboard = (options?: HideKeyboardOptions | null) => void;
|
|
export type MakePhoneCall = (options: MakePhoneCallOptions) => void;
|
|
export class MakePhoneCallSuccess extends UTSObject {
|
|
}
|
|
type MakePhoneCallSuccessCallback = (result: MakePhoneCallSuccess) => void;
|
|
type MakePhoneCallFail = UniError;
|
|
type MakePhoneCallFailCallback = (result: MakePhoneCallFail) => void;
|
|
type MakePhoneCallComplete = Object;
|
|
type MakePhoneCallCompleteCallback = (result: MakePhoneCallComplete) => void;
|
|
export class MakePhoneCallOptions extends UTSObject {
|
|
phoneNumber!: string;
|
|
success: MakePhoneCallSuccessCallback | null = null;
|
|
fail: MakePhoneCallFailCallback | null = null;
|
|
complete: MakePhoneCallCompleteCallback | null = null;
|
|
}
|
|
type MediaOrientation = 'up' | 'down' | 'left' | 'right' | 'up-mirrored' | 'down-mirrored' | 'left-mirrored' | 'right-mirrored';
|
|
type MediaErrorCode = 1101001 | 1101002 | 1101003 | 1101004 | 1101005 | 1101006 | 1101007 | 1101008 | 1101009 | 1101010;
|
|
interface IMediaError extends IUniError {
|
|
errCode: MediaErrorCode;
|
|
}
|
|
class ChooseImageTempFile extends UTSObject {
|
|
path!: string;
|
|
size!: number;
|
|
name: string | null = null;
|
|
type: string | null = null;
|
|
}
|
|
export class ChooseImageSuccess extends UTSObject {
|
|
errSubject!: string;
|
|
errMsg!: string;
|
|
tempFilePaths!: Array<string>;
|
|
tempFiles!: ChooseImageTempFile[];
|
|
}
|
|
type ChooseImageFail = IMediaError;
|
|
type ChooseImageSuccessCallback = (callback: ChooseImageSuccess) => void;
|
|
type ChooseImageFailCallback = (callback: ChooseImageFail) => void;
|
|
type ChooseImageCompleteCallback = (callback: Object) => void;
|
|
class ChooseImageCropOptions extends UTSObject {
|
|
width!: number;
|
|
height!: number;
|
|
quality: (number) | null = null;
|
|
resize: (boolean) | null = null;
|
|
}
|
|
type ChooseImagePageOrientation = "auto" | "portrait" | "landscape";
|
|
type ChooseImageAlbumMode = "custom" | "system";
|
|
export class ChooseImageOptions extends UTSObject {
|
|
pageOrientation: ChooseImagePageOrientation | null = null;
|
|
albumMode: ChooseImageAlbumMode | null = null;
|
|
count: (number) | null = null;
|
|
sizeType: (string[]) | null = null;
|
|
sourceType: (string[]) | null = null;
|
|
extension: (string[]) | null = null;
|
|
crop: (ChooseImageCropOptions) | null = null;
|
|
success: (ChooseImageSuccessCallback) | null = null;
|
|
fail: (ChooseImageFailCallback) | null = null;
|
|
complete: (ChooseImageCompleteCallback) | null = null;
|
|
}
|
|
export type ChooseImage = (options: ChooseImageOptions) => void;
|
|
export class PreviewImageSuccess extends UTSObject {
|
|
errSubject!: string;
|
|
errMsg!: string;
|
|
}
|
|
type PreviewImageFail = IMediaError;
|
|
type PreviewImageSuccessCallback = (callback: PreviewImageSuccess) => void;
|
|
type PreviewImageFailCallback = (callback: PreviewImageFail) => void;
|
|
type PreviewImageCompleteCallback = ChooseImageCompleteCallback;
|
|
export class PreviewImageOptions extends UTSObject {
|
|
current: Object | null = null;
|
|
urls!: Array<string.ImageURIString>;
|
|
showmenu: boolean | null = null;
|
|
indicator: 'default' | 'number' | 'none' | null = null;
|
|
loop: boolean | null = null;
|
|
success: (PreviewImageSuccessCallback) | null = null;
|
|
fail: (PreviewImageFailCallback) | null = null;
|
|
complete: (PreviewImageCompleteCallback) | null = null;
|
|
}
|
|
export type PreviewImage = (options: PreviewImageOptions) => void;
|
|
export type ClosePreviewImage = (options: ClosePreviewImageOptions) => void;
|
|
export class ClosePreviewImageSuccess extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type ClosePreviewImageFail = IMediaError;
|
|
type ClosePreviewImageSuccessCallback = (callback: ClosePreviewImageSuccess) => void;
|
|
type ClosePreviewImageFailCallback = (callback: ClosePreviewImageFail) => void;
|
|
type ClosePreviewImageCompleteCallback = ChooseImageCompleteCallback;
|
|
export class ClosePreviewImageOptions extends UTSObject {
|
|
success: (ClosePreviewImageSuccessCallback) | null = null;
|
|
fail: (ClosePreviewImageFailCallback) | null = null;
|
|
complete: (ClosePreviewImageCompleteCallback) | null = null;
|
|
}
|
|
export type GetImageInfo = (options: GetImageInfoOptions) => void;
|
|
export class GetImageInfoSuccess extends UTSObject {
|
|
width!: number;
|
|
height!: number;
|
|
path!: string;
|
|
orientation: MediaOrientation | null = null;
|
|
type: string | null = null;
|
|
}
|
|
type GetImageInfoFail = IMediaError;
|
|
type GetImageInfoSuccessCallback = (callback: GetImageInfoSuccess) => void;
|
|
type GetImageInfoFailCallback = (callback: GetImageInfoFail) => void;
|
|
type GetImageInfoCompleteCallback = ChooseImageCompleteCallback;
|
|
export class GetImageInfoOptions extends UTSObject {
|
|
src!: string.ImageURIString;
|
|
success: (GetImageInfoSuccessCallback) | null = null;
|
|
fail: (GetImageInfoFailCallback) | null = null;
|
|
complete: (GetImageInfoCompleteCallback) | null = null;
|
|
}
|
|
export type SaveImageToPhotosAlbum = (options: SaveImageToPhotosAlbumOptions) => void;
|
|
export class SaveImageToPhotosAlbumSuccess extends UTSObject {
|
|
path!: string;
|
|
}
|
|
type SaveImageToPhotosAlbumFail = IMediaError;
|
|
type SaveImageToPhotosAlbumSuccessCallback = (callback: SaveImageToPhotosAlbumSuccess) => void;
|
|
type SaveImageToPhotosAlbumFailCallback = (callback: SaveImageToPhotosAlbumFail) => void;
|
|
type SaveImageToPhotosAlbumCompleteCallback = ChooseImageCompleteCallback;
|
|
export class SaveImageToPhotosAlbumOptions extends UTSObject {
|
|
filePath!: string.ImageURIString;
|
|
success: (SaveImageToPhotosAlbumSuccessCallback) | null = null;
|
|
fail: (SaveImageToPhotosAlbumFailCallback) | null = null;
|
|
complete: (SaveImageToPhotosAlbumCompleteCallback) | null = null;
|
|
}
|
|
type CompressImage = (options: CompressImageOptions) => void;
|
|
class CompressImageSuccess extends UTSObject {
|
|
tempFilePath!: string;
|
|
}
|
|
type CompressImageFail = IMediaError;
|
|
type CompressImageSuccessCallback = (callback: CompressImageSuccess) => void;
|
|
type CompressImageFailCallback = (callback: CompressImageFail) => void;
|
|
type CompressImageCompleteCallback = ChooseImageCompleteCallback;
|
|
class CompressImageOptions extends UTSObject {
|
|
src!: string.ImageURIString;
|
|
quality: number | null = null;
|
|
rotate: number | null = null;
|
|
width: string | null = null;
|
|
height: string | null = null;
|
|
compressedHeight: number | null = null;
|
|
compressedWidth: number | null = null;
|
|
success: (CompressImageSuccessCallback) | null = null;
|
|
fail: (CompressImageFailCallback) | null = null;
|
|
complete: (CompressImageCompleteCallback) | null = null;
|
|
}
|
|
export class ChooseVideoSuccess extends UTSObject {
|
|
tempFilePath!: string;
|
|
duration!: number;
|
|
size!: number;
|
|
height!: number;
|
|
width!: number;
|
|
}
|
|
type ChooseVideoFail = IMediaError;
|
|
type ChooseVideoSuccessCallback = (callback: ChooseVideoSuccess) => void;
|
|
type ChooseVideoFailCallback = (callback: ChooseVideoFail) => void;
|
|
type ChooseVideoCompleteCallback = ChooseImageCompleteCallback;
|
|
type ChooseVideoPageOrientation = ChooseImagePageOrientation;
|
|
type ChooseVideoAlbumMode = ChooseImageAlbumMode;
|
|
export class ChooseVideoOptions extends UTSObject {
|
|
pageOrientation: ChooseVideoPageOrientation | null = null;
|
|
albumMode: ChooseVideoAlbumMode | null = null;
|
|
sourceType: (string[]) | null = null;
|
|
compressed: boolean | null = true;
|
|
maxDuration: number | null = null;
|
|
camera: 'front' | 'back' | null = null;
|
|
extension: (string[]) | null = null;
|
|
success: (ChooseVideoSuccessCallback) | null = null;
|
|
fail: (ChooseVideoFailCallback) | null = null;
|
|
complete: (ChooseVideoCompleteCallback) | null = null;
|
|
}
|
|
export type ChooseVideo = (options: ChooseVideoOptions) => void;
|
|
export class GetVideoInfoSuccess extends UTSObject {
|
|
orientation: MediaOrientation | null = null;
|
|
type: string | null = null;
|
|
duration!: number;
|
|
size!: number;
|
|
height!: number;
|
|
width!: number;
|
|
fps: number | null = null;
|
|
bitrate: number | null = null;
|
|
}
|
|
type GetVideoInfoFail = IMediaError;
|
|
type GetVideoInfoSuccessCallback = (callback: GetVideoInfoSuccess) => void;
|
|
type GetVideoInfoFailCallback = (callback: GetVideoInfoFail) => void;
|
|
type GetVideoInfoCompleteCallback = ChooseImageCompleteCallback;
|
|
export class GetVideoInfoOptions extends UTSObject {
|
|
src!: string.VideoURIString;
|
|
success: (GetVideoInfoSuccessCallback) | null = null;
|
|
fail: (GetVideoInfoFailCallback) | null = null;
|
|
complete: (GetVideoInfoCompleteCallback) | null = null;
|
|
}
|
|
export type GetVideoInfo = (options: GetVideoInfoOptions) => void;
|
|
export class SaveVideoToPhotosAlbumSuccess extends UTSObject {
|
|
}
|
|
type SaveVideoToPhotosAlbumFail = IMediaError;
|
|
type SaveVideoToPhotosAlbumSuccessCallback = (callback: SaveVideoToPhotosAlbumSuccess) => void;
|
|
type SaveVideoToPhotosAlbumFailCallback = (callback: SaveVideoToPhotosAlbumFail) => void;
|
|
type SaveVideoToPhotosAlbumCompleteCallback = ChooseImageCompleteCallback;
|
|
export class SaveVideoToPhotosAlbumOptions extends UTSObject {
|
|
filePath!: string.VideoURIString;
|
|
success: (SaveVideoToPhotosAlbumSuccessCallback) | null = null;
|
|
fail: (SaveVideoToPhotosAlbumFailCallback) | null = null;
|
|
complete: (SaveVideoToPhotosAlbumCompleteCallback) | null = null;
|
|
}
|
|
export type SaveVideoToPhotosAlbum = (options: SaveVideoToPhotosAlbumOptions) => void;
|
|
export class CompressVideoSuccess extends UTSObject {
|
|
tempFilePath!: string;
|
|
size!: number;
|
|
}
|
|
type CompressVideoFail = IMediaError;
|
|
type CompressVideoSuccessCallback = (callback: CompressVideoSuccess) => void;
|
|
type CompressVideoFailCallback = (callback: CompressVideoFail) => void;
|
|
type CompressVideoCompleteCallback = ChooseImageCompleteCallback;
|
|
export class CompressVideoOptions extends UTSObject {
|
|
src!: string.VideoURIString;
|
|
quality: string | null = null;
|
|
bitrate: number | null = null;
|
|
fps: number | null = null;
|
|
resolution: number | null = null;
|
|
success: (CompressVideoSuccessCallback) | null = null;
|
|
fail: (CompressVideoFailCallback) | null = null;
|
|
complete: (CompressVideoCompleteCallback) | null = null;
|
|
}
|
|
export type CompressVideo = (options: CompressVideoOptions) => void;
|
|
export type ChooseFile = (options: ChooseFileOptions) => void;
|
|
export class ChooseFileSuccess extends UTSObject {
|
|
tempFilePaths!: string[];
|
|
tempFiles!: ChooseFileTempFile[];
|
|
}
|
|
class ChooseFileTempFile extends UTSObject {
|
|
name!: string;
|
|
path!: string;
|
|
size!: number;
|
|
type!: 'video' | 'image' | 'audio' | 'file';
|
|
}
|
|
type ChooseFileSuccessCallback = (result: ChooseFileSuccess) => void;
|
|
type ChooseFileFail = IMediaError;
|
|
type ChooseFileFailCallback = (result: ChooseFileFail) => void;
|
|
type ChooseFileComplete = Object;
|
|
type ChooseFileCompleteCallback = (result: ChooseFileComplete) => void;
|
|
export class ChooseFileOptions extends UTSObject {
|
|
count: number | null = null;
|
|
type: 'image' | 'video' | 'all' | 'audio' | null = null;
|
|
extension: (string[]) | null = null;
|
|
sizeType: Object | null = null;
|
|
sourceType: (string[]) | null = null;
|
|
success: ChooseFileSuccessCallback | null = null;
|
|
fail: ChooseFileFailCallback | null = null;
|
|
complete: ChooseFileCompleteCallback | null = null;
|
|
}
|
|
interface _CompressImageSuccess {
|
|
size: number;
|
|
tempFilePath: string;
|
|
}
|
|
interface MediaFile {
|
|
fileType: 'video' | 'image';
|
|
tempFilePath: string;
|
|
size: number;
|
|
width?: number;
|
|
height?: number;
|
|
duration?: number;
|
|
thumbTempFilePath?: string;
|
|
}
|
|
interface _ChooseMediaOptions {
|
|
mimeType: photoAccessHelper2.PhotoViewMIMETypes.VIDEO_TYPE | photoAccessHelper2.PhotoViewMIMETypes.IMAGE_TYPE | photoAccessHelper2.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE;
|
|
count?: number;
|
|
sourceType?: ('album' | 'camera')[];
|
|
isOriginalSupported?: boolean;
|
|
}
|
|
interface chooseMediaSuccessCallbackResult {
|
|
tempFiles: MediaFile[];
|
|
}
|
|
type CameraPosition1 = 'back' | 'front';
|
|
interface TempFiles {
|
|
tempFilePath: string;
|
|
size: number;
|
|
}
|
|
interface TakePhotoRes {
|
|
tempFiles: TempFiles[];
|
|
}
|
|
interface TakeVideoOptions {
|
|
cameraType?: CameraPosition1;
|
|
videoDuration?: number;
|
|
}
|
|
interface TakeVideoRes {
|
|
path: string;
|
|
duration: number;
|
|
size: number;
|
|
height: number;
|
|
width: number;
|
|
orientation: MediaOrientation;
|
|
type: string;
|
|
}
|
|
interface IGetImageInfoDownloadOptions {
|
|
url: string;
|
|
success: (res: IGetImageInfoDownloadSuccess) => void;
|
|
fail: (err: IGetImageInfoDownloadFail) => void;
|
|
}
|
|
interface IGetImageInfoDownloadSuccess {
|
|
tempFilePath: string;
|
|
}
|
|
interface IGetImageInfoDownloadFail {
|
|
errMsg: string;
|
|
}
|
|
interface IPreviewImageOptions {
|
|
urls: string[];
|
|
current: string;
|
|
showmenu: boolean;
|
|
}
|
|
interface ISaveMediaError {
|
|
code: number;
|
|
message: string;
|
|
}
|
|
export type Request<T = Object> = (param: RequestOptions<T>) => RequestTask;
|
|
export class RequestOptions<T = Object> extends UTSObject {
|
|
url!: string;
|
|
data: Object | null = null;
|
|
header: UTSJSONObject | null = null;
|
|
method: RequestMethod | null = null;
|
|
timeout: number | null = null;
|
|
dataType: string | null = null;
|
|
responseType: string | null = null;
|
|
sslVerify: boolean | null = null;
|
|
withCredentials: boolean | null = null;
|
|
firstIpv4: boolean | null = null;
|
|
success: RequestSuccessCallback<T> | null = null;
|
|
fail: RequestFailCallback | null = null;
|
|
complete: RequestCompleteCallback | null = null;
|
|
}
|
|
export class RequestSuccess<T = Object> extends UTSObject {
|
|
data: T | null = null;
|
|
statusCode!: number;
|
|
header!: Object;
|
|
cookies!: Array<string>;
|
|
}
|
|
type RequestMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
|
|
type RequestErrorCode = 5 | 1000 | 100001 | 100002 | 600003 | 600008 | 600009 | 602001;
|
|
export interface RequestFail extends IUniError {
|
|
errCode: RequestErrorCode;
|
|
}
|
|
type RequestSuccessCallback<T> = (option: RequestSuccess<T>) => void;
|
|
type RequestFailCallback = (option: RequestFail) => void;
|
|
type RequestCompleteCallback = (option: Object) => void;
|
|
export interface RequestTask {
|
|
abort(): void;
|
|
}
|
|
export type UploadFile = (options: UploadFileOptions) => UploadTask;
|
|
class UploadFileOptionFiles extends UTSObject {
|
|
name: string | null = null;
|
|
uri!: string;
|
|
file: Object | null = null;
|
|
}
|
|
export class UploadFileSuccess extends UTSObject {
|
|
data!: string;
|
|
statusCode!: number;
|
|
}
|
|
type UploadFileSuccessCallback = (result: UploadFileSuccess) => void;
|
|
interface UploadFileFail extends IUniError {
|
|
errCode: RequestErrorCode;
|
|
}
|
|
type UploadFileFailCallback = (result: UploadFileFail) => void;
|
|
type UploadFileCompleteCallback = (result: Object) => void;
|
|
export class UploadFileOptions extends UTSObject {
|
|
url!: string;
|
|
filePath: string | null = null;
|
|
name: string | null = null;
|
|
files: (UploadFileOptionFiles[]) | null = null;
|
|
header: UTSJSONObject | null = null;
|
|
formData: UTSJSONObject | null = null;
|
|
timeout: number | null = null;
|
|
success: UploadFileSuccessCallback | null = null;
|
|
fail: UploadFileFailCallback | null = null;
|
|
complete: UploadFileCompleteCallback | null = null;
|
|
}
|
|
export class OnProgressUpdateResult extends UTSObject {
|
|
progress!: number;
|
|
totalBytesSent!: number;
|
|
totalBytesExpectedToSend!: number;
|
|
}
|
|
type UploadFileProgressUpdateCallback = (result: OnProgressUpdateResult) => void;
|
|
export interface UploadTask {
|
|
abort(): void;
|
|
onProgressUpdate(callback: UploadFileProgressUpdateCallback): void;
|
|
}
|
|
export type DownloadFile = (options: DownloadFileOptions) => DownloadTask;
|
|
export class DownloadFileSuccess extends UTSObject {
|
|
tempFilePath!: string;
|
|
statusCode!: number;
|
|
}
|
|
type DownloadFileSuccessCallback = (result: DownloadFileSuccess) => void;
|
|
interface DownloadFileFail extends IUniError {
|
|
errCode: RequestErrorCode;
|
|
}
|
|
type DownloadFileFailCallback = (result: DownloadFileFail) => void;
|
|
type DownloadFileComplete = Object;
|
|
type DownloadFileCompleteCallback = (result: DownloadFileComplete) => void;
|
|
export class DownloadFileOptions extends UTSObject {
|
|
url!: string;
|
|
header: UTSJSONObject | null = null;
|
|
filePath: string | null = null;
|
|
timeout: number | null = null;
|
|
success: DownloadFileSuccessCallback | null = null;
|
|
fail: DownloadFileFailCallback | null = null;
|
|
complete: DownloadFileCompleteCallback | null = null;
|
|
}
|
|
export class OnProgressDownloadResult extends UTSObject {
|
|
progress!: number;
|
|
totalBytesWritten!: number;
|
|
totalBytesExpectedToWrite!: number;
|
|
}
|
|
type DownloadFileProgressUpdateCallback = (result: OnProgressDownloadResult) => void;
|
|
export interface DownloadTask {
|
|
abort(): void;
|
|
onProgressUpdate(callback: DownloadFileProgressUpdateCallback): void;
|
|
}
|
|
export type ConfigMTLS = (options: ConfigMTLSOptions) => void;
|
|
class Certificate extends UTSObject {
|
|
host!: string;
|
|
client: string | null = null;
|
|
clientPassword: string | null = null;
|
|
keyPath: string | null = null;
|
|
server: (string[]) | null = null;
|
|
}
|
|
export class ConfigMTLSSuccess extends UTSObject {
|
|
code!: number;
|
|
}
|
|
type ConfigMTLSSuccessCallback = (result: ConfigMTLSSuccess) => void;
|
|
class ConfigMTLSFail extends UTSObject {
|
|
code!: number;
|
|
}
|
|
type ConfigMTLSFailCallback = (result: ConfigMTLSFail) => void;
|
|
type ConfigMTLSComplete = Object;
|
|
type ConfigMTLSCompleteCallback = (result: ConfigMTLSComplete) => void;
|
|
export class ConfigMTLSOptions extends UTSObject {
|
|
certificates!: Certificate[];
|
|
success: ConfigMTLSSuccessCallback | null = null;
|
|
fail: ConfigMTLSFailCallback | null = null;
|
|
complete: ConfigMTLSCompleteCallback | null = null;
|
|
}
|
|
interface IUniRequestEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function | null) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
interface IRequestTask {
|
|
abort: Function;
|
|
onHeadersReceived: Function;
|
|
offHeadersReceived: Function;
|
|
}
|
|
interface IUniUploadFileEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function | null) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
interface IUploadTask {
|
|
abort: Function;
|
|
onHeadersReceived: Function;
|
|
offHeadersReceived: Function;
|
|
onProgressUpdate: Function;
|
|
offProgressUpdate: Function;
|
|
}
|
|
interface IUniDownloadFileEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function | null) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
interface IDownloadTask {
|
|
abort: Function;
|
|
onHeadersReceived: Function;
|
|
offHeadersReceived: Function;
|
|
onProgressUpdate: Function;
|
|
offProgressUpdate: Function;
|
|
}
|
|
export interface UniOAuthProvider extends UniProvider {
|
|
login(options: LoginOptions): void;
|
|
getUserInfo(options: GetUserInfoOptions): void;
|
|
}
|
|
export type Login = (options: LoginOptions) => void;
|
|
class AppleLoginAppleInfo extends UTSObject {
|
|
authorizationCode: string | null = null;
|
|
fullName: Object | null = null;
|
|
identityToken: string | null = null;
|
|
realUserStatus: number | null = null;
|
|
user: string | null = null;
|
|
}
|
|
export class LoginSuccess extends UTSObject {
|
|
errMsg!: string;
|
|
authResult!: Object;
|
|
code!: string;
|
|
anonymousCode: string | null = null;
|
|
authCode: string | null = null;
|
|
authErrorScope: Object | null = null;
|
|
authSucessScope: (string[]) | null = null;
|
|
appleInfo: AppleLoginAppleInfo | null = null;
|
|
}
|
|
type LoginSuccessCallback = (result: LoginSuccess) => void;
|
|
export type LoginFail = IUniError;
|
|
type LoginFailCallback = (result: LoginFail) => void;
|
|
type LoginComplete = Object;
|
|
type LoginCompleteCallback = (result: LoginComplete) => void;
|
|
export class LoginOptions extends UTSObject {
|
|
provider: 'weixin' | 'qq' | 'sinaweibo' | 'xiaomi' | 'apple' | 'univerify' | 'huawei' | null = null;
|
|
scopes: Object | null = null;
|
|
timeout: number | null = null;
|
|
univerifyStyle: UniverifyStyle | null = null;
|
|
onlyAuthorize: boolean | null = null;
|
|
success: LoginSuccessCallback | null = null;
|
|
fail: LoginFailCallback | null = null;
|
|
complete: LoginCompleteCallback | null = null;
|
|
}
|
|
class UniverifyIconStyles extends UTSObject {
|
|
path!: string;
|
|
width: string | null = null;
|
|
height: string | null = null;
|
|
}
|
|
class UniverifyPhoneNumStyles extends UTSObject {
|
|
color: string | null = null;
|
|
fontSize: string | null = null;
|
|
}
|
|
class UniverifySloganStyles extends UTSObject {
|
|
color: string | null = null;
|
|
fontSize: string | null = null;
|
|
}
|
|
class UniverifyAuthButtonStyles extends UTSObject {
|
|
normalColor: string | null = null;
|
|
highlightColor: string | null = null;
|
|
disabledColor: string | null = null;
|
|
width: string | null = null;
|
|
height: string | null = null;
|
|
textColor: string | null = null;
|
|
title: string | null = null;
|
|
borderRadius: string | null = null;
|
|
}
|
|
class UniverifyOtherButtonStyles extends UTSObject {
|
|
visible: boolean | null = null;
|
|
normalColor: string | null = null;
|
|
highlightColor: string | null = null;
|
|
width: string | null = null;
|
|
height: string | null = null;
|
|
textColor: string | null = null;
|
|
title: string | null = null;
|
|
borderWidth: string | null = null;
|
|
borderColor: string | null = null;
|
|
borderRadius: string | null = null;
|
|
}
|
|
class UniverifyPrivacyItemStyles extends UTSObject {
|
|
url!: string;
|
|
title!: string;
|
|
}
|
|
class UniverifyPrivacyTermsStyles extends UTSObject {
|
|
defaultCheckBoxState: boolean | null = null;
|
|
textColor: string | null = null;
|
|
termsColor: string | null = null;
|
|
prefix: string | null = null;
|
|
suffix: string | null = null;
|
|
fontSize: string | null = null;
|
|
privacyItems: (UniverifyPrivacyItemStyles[]) | null = null;
|
|
}
|
|
class UniVerifyButtonListItem extends UTSObject {
|
|
provider!: string;
|
|
iconPath!: string;
|
|
}
|
|
class UniVerifyButtonsStyles extends UTSObject {
|
|
iconWidth: string | null = null;
|
|
list!: UniVerifyButtonListItem[];
|
|
}
|
|
class UniverifyStyle extends UTSObject {
|
|
fullScreen: boolean | null = null;
|
|
backgroundColor: string | null = null;
|
|
backgroundImage: string | null = null;
|
|
icon: UniverifyIconStyles | null = null;
|
|
phoneNum: UniverifyPhoneNumStyles | null = null;
|
|
slogan: UniverifySloganStyles | null = null;
|
|
authButton: UniverifyAuthButtonStyles | null = null;
|
|
otherLoginButton: UniverifyOtherButtonStyles | null = null;
|
|
privacyTerms: UniverifyPrivacyTermsStyles | null = null;
|
|
buttons: UniVerifyButtonsStyles | null = null;
|
|
}
|
|
export type GetUserInfo = (options: GetUserInfoOptions) => void;
|
|
export class UserInfo extends UTSObject {
|
|
nickName!: string;
|
|
openId: string | null = null;
|
|
avatarUrl!: string;
|
|
}
|
|
export class GetUserInfoSuccess extends UTSObject {
|
|
userInfo!: UserInfo;
|
|
rawData: string | null = null;
|
|
signature: string | null = null;
|
|
encryptedData: string | null = null;
|
|
iv: string | null = null;
|
|
errMsg!: string;
|
|
}
|
|
type GetUserInfoSuccessCallback = (result: GetUserInfoSuccess) => void;
|
|
export type GetUserInfoFail = IUniError;
|
|
type GetUserInfoFailCallback = (result: GetUserInfoFail) => void;
|
|
type GetUserInfoComplete = Object;
|
|
type GetUserInfoCompleteCallback = (result: GetUserInfoComplete) => void;
|
|
export class GetUserInfoOptions extends UTSObject {
|
|
provider: 'weixin' | 'qq' | 'sinaweibo' | 'xiaomi' | 'apple' | 'huawei' | null = null;
|
|
withCredentials: boolean | null = null;
|
|
lang: string | null = null;
|
|
timeout: number | null = null;
|
|
success: GetUserInfoSuccessCallback | null = null;
|
|
fail: GetUserInfoFailCallback | null = null;
|
|
complete: GetUserInfoCompleteCallback | null = null;
|
|
}
|
|
export type OpenAppAuthorizeSetting = (options: OpenAppAuthorizeSettingOptions) => void;
|
|
export class OpenAppAuthorizeSettingSuccess extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type OpenAppAuthorizeSettingSuccessCallback = (result: OpenAppAuthorizeSettingSuccess) => void;
|
|
class OpenAppAuthorizeSettingFail extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type OpenAppAuthorizeSettingFailCallback = (result: OpenAppAuthorizeSettingFail) => void;
|
|
class OpenAppAuthorizeSettingComplete extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type OpenAppAuthorizeSettingCompleteCallback = (result: OpenAppAuthorizeSettingComplete) => void;
|
|
export class OpenAppAuthorizeSettingOptions extends UTSObject {
|
|
success: OpenAppAuthorizeSettingSuccessCallback | null = null;
|
|
fail: OpenAppAuthorizeSettingFailCallback | null = null;
|
|
complete: OpenAppAuthorizeSettingCompleteCallback | null = null;
|
|
}
|
|
export class OpenDocumentSuccess extends UTSObject {
|
|
}
|
|
export class OpenDocumentFail extends UTSObject {
|
|
}
|
|
type OpenDocumentSuccessCallback = (res: OpenDocumentSuccess) => void;
|
|
type OpenDocumentFailCallback = (res: OpenDocumentFail) => void;
|
|
type OpenDocumentCompleteCallback = (res: Object) => void;
|
|
type OpenDocumentSupportedTypes = 'doc' | 'xls' | 'ppt' | 'pdf' | 'docx' | 'xlsx' | 'pptx';
|
|
export class OpenDocumentOptions extends UTSObject {
|
|
filePath!: string;
|
|
fileType: OpenDocumentSupportedTypes | null = null;
|
|
success: OpenDocumentSuccessCallback | null = null;
|
|
fail: OpenDocumentFailCallback | null = null;
|
|
complete: OpenDocumentCompleteCallback | null = null;
|
|
}
|
|
type OpenDocument = (options?: OpenDocumentOptions | null) => void;
|
|
export interface UniPaymentProvider extends UniProvider {
|
|
requestPayment(options: RequestPaymentOptions): void;
|
|
}
|
|
type RequestPaymentErrorCode = 700600 | 701100 | 701110 | 700601 | 700602 | 700603 | 700000 | 700604 | 700605 | 700607 | 700608 | 700800 | 700801;
|
|
export type RequestPayment = (options: RequestPaymentOptions) => void;
|
|
export class RequestPaymentSuccess extends UTSObject {
|
|
data: object | null = null;
|
|
}
|
|
type RequestPaymentSuccessCallback = (result: RequestPaymentSuccess) => void;
|
|
export type RequestPaymentFail = IRequestPaymentFail;
|
|
type RequestPaymentFailCallback = (result: RequestPaymentFail) => void;
|
|
type RequestPaymentComplete = Object;
|
|
interface IRequestPaymentFail extends IUniError {
|
|
errCode: RequestPaymentErrorCode;
|
|
}
|
|
type RequestPaymentCompleteCallback = (result: RequestPaymentComplete) => void;
|
|
export class RequestPaymentOptions extends UTSObject {
|
|
provider!: string;
|
|
orderInfo!: string;
|
|
success: RequestPaymentSuccessCallback | null = null;
|
|
fail: RequestPaymentFailCallback | null = null;
|
|
complete: RequestPaymentCompleteCallback | null = null;
|
|
}
|
|
type PromptErrorCode = 1 | 1001;
|
|
interface IPromptError extends IUniError {
|
|
errCode: PromptErrorCode;
|
|
}
|
|
class ShowToastSuccess extends UTSObject {
|
|
}
|
|
type ShowToastFail = IPromptError;
|
|
type ShowToastSuccessCallback = (res: ShowToastSuccess) => void;
|
|
type ShowToastFailCallback = (res: ShowToastFail) => void;
|
|
type ShowToastCompleteCallback = (res: Object) => void;
|
|
type Icon = "success" | "error" | "fail" | "exception" | "loading" | "none";
|
|
type ShowToastPosition = "top" | "center" | "bottom";
|
|
class ShowToastOptions extends UTSObject {
|
|
title!: string;
|
|
icon: Icon | null = null;
|
|
image: string.ImageURIString | null = null;
|
|
mask: boolean | null = null;
|
|
duration: number | null = null;
|
|
position: ShowToastPosition | null = null;
|
|
success: ShowToastSuccessCallback | null = null;
|
|
fail: ShowToastFailCallback | null = null;
|
|
complete: ShowToastCompleteCallback | null = null;
|
|
}
|
|
type ShowToast = (options: ShowToastOptions) => void;
|
|
type HideToast = () => void;
|
|
class ShowLoadingSuccess extends UTSObject {
|
|
}
|
|
type ShowLoadingFail = IPromptError;
|
|
type ShowLoadingSuccessCallback = (res: ShowLoadingSuccess) => void;
|
|
type ShowLoadingFailCallback = (res: ShowLoadingFail) => void;
|
|
type ShowLoadingCompleteCallback = (res: Object) => void;
|
|
class ShowLoadingOptions extends UTSObject {
|
|
title!: string;
|
|
mask: boolean | null = null;
|
|
success: ShowLoadingSuccessCallback | null = null;
|
|
fail: ShowLoadingFailCallback | null = null;
|
|
complete: ShowLoadingCompleteCallback | null = null;
|
|
}
|
|
type ShowLoading = (options: ShowLoadingOptions) => void;
|
|
type HideLoading = () => void;
|
|
class ShowModalSuccess extends UTSObject {
|
|
confirm!: boolean;
|
|
cancel!: boolean;
|
|
content: string | null = null;
|
|
}
|
|
type ShowModalFail = IPromptError;
|
|
type ShowModalSuccessCallback = (res: ShowModalSuccess) => void;
|
|
type ShowModalFailCallback = (res: ShowModalFail) => void;
|
|
type ShowModalCompleteCallback = (res: Object) => void;
|
|
class ShowModalOptions extends UTSObject {
|
|
title: string | null = null;
|
|
content: string | null = null;
|
|
showCancel: boolean | null = true;
|
|
cancelText: string | null = null;
|
|
cancelColor: string.ColorString | null = null;
|
|
confirmText: string | null = null;
|
|
confirmColor: string.ColorString | null = null;
|
|
editable: boolean | null = false;
|
|
placeholderText: string | null = null;
|
|
success: ShowModalSuccessCallback | null = null;
|
|
fail: ShowModalFailCallback | null = null;
|
|
complete: ShowModalCompleteCallback | null = null;
|
|
}
|
|
type ShowModal = (options: ShowModalOptions) => void;
|
|
class ShowActionSheetSuccess extends UTSObject {
|
|
tapIndex!: number;
|
|
}
|
|
class Popover extends UTSObject {
|
|
top!: number;
|
|
left!: number;
|
|
width!: number;
|
|
height!: number;
|
|
}
|
|
type ShowActionSheetFail = IPromptError;
|
|
type ShowActionSheetSuccessCallback = (res: ShowActionSheetSuccess) => void;
|
|
type ShowActionSheetFailCallback = (res: ShowActionSheetFail) => void;
|
|
type ShowActionSheetCompleteCallback = (res: Object) => void;
|
|
class ShowActionSheetOptions extends UTSObject {
|
|
title: string | null = null;
|
|
alertText: string | null = null;
|
|
itemList!: string[];
|
|
itemColor: string.ColorString | null = null;
|
|
popover: Popover | null = null;
|
|
success: ShowActionSheetSuccessCallback | null = null;
|
|
fail: ShowActionSheetFailCallback | null = null;
|
|
complete: ShowActionSheetCompleteCallback | null = null;
|
|
}
|
|
type ShowActionSheet = (options: ShowActionSheetOptions) => void;
|
|
interface IShowLoadingOptions {
|
|
title: string;
|
|
mask: boolean;
|
|
}
|
|
interface IHideLoadingOptions {
|
|
}
|
|
interface IHideLoadingSuccess {
|
|
}
|
|
type PullDownRefreshErrorCode = 4;
|
|
interface StartPullDownRefreshFail extends IUniError {
|
|
errCode: PullDownRefreshErrorCode;
|
|
}
|
|
export class StartPullDownRefreshOptions extends UTSObject {
|
|
success: StartPullDownRefreshSuccessCallback | null = null;
|
|
fail: StartPullDownRefreshFailCallback | null = null;
|
|
complete: StartPullDownRefreshCompleteCallback | null = null;
|
|
}
|
|
export type StartPullDownRefreshSuccess = AsyncApiSuccessResult;
|
|
type StartPullDownRefreshSuccessCallback = (result: StartPullDownRefreshSuccess) => void;
|
|
type StartPullDownRefreshFailCallback = (result: StartPullDownRefreshFail) => void;
|
|
type StartPullDownRefreshComplete = AsyncApiResult;
|
|
type StartPullDownRefreshCompleteCallback = (result: StartPullDownRefreshComplete) => void;
|
|
type StartPullDownRefresh = (options: StartPullDownRefreshOptions) => void;
|
|
type StopPullDownRefresh = () => void;
|
|
export type Rpx2px = (number: number) => number;
|
|
export class ScanCodeSuccess extends UTSObject {
|
|
result!: string;
|
|
scanType!: string;
|
|
}
|
|
export class ScanCodeFail extends UTSObject {
|
|
}
|
|
type ScanCodeSuccessCallback = (res: ScanCodeSuccess) => void;
|
|
type ScanCodeFailCallback = (res: ScanCodeFail) => void;
|
|
type ScanCodeCompleteCallback = (res: Object) => void;
|
|
type ScanCodeSupportedTypes = 'barCode' | 'qrCode' | 'datamatrix' | 'pdf417';
|
|
export class ScanCodeOptions extends UTSObject {
|
|
onlyFromCamera: boolean | null = null;
|
|
scanType: ScanCodeSupportedTypes[] | null = null;
|
|
success: ScanCodeSuccessCallback | null = null;
|
|
fail: ScanCodeFailCallback | null = null;
|
|
complete: ScanCodeCompleteCallback | null = null;
|
|
}
|
|
type ScanCode = (options?: ScanCodeOptions | null) => void;
|
|
type UniScanOptionsTypes = 'barCode' | 'qrCode' | 'datamatrix' | 'pdf417';
|
|
type UniScanResultTypes = "QR_CODE" | "AZTEC" | "CODABAR" | "CODE_39" | "CODE_93" | "CODE_128" | "DATA_MATRIX" | "EAN_8" | "EAN_13" | "ITF" | "MAXICODE" | "PDF_417" | "RSS_14" | "RSS_EXPANDED" | "UPC_A" | "UPC_E" | "UPC_EAN_EXTENSION" | "WX_CODE" | "CODE_25";
|
|
type HarmonyScanResultTypes = scanCore.ScanType.AZTEC_CODE | scanCore.ScanType.CODABAR_CODE | scanCore.ScanType.CODE128_CODE | scanCore.ScanType.CODE39_CODE | scanCore.ScanType.CODE93_CODE | scanCore.ScanType.DATAMATRIX_CODE | scanCore.ScanType.EAN13_CODE | scanCore.ScanType.EAN8_CODE | scanCore.ScanType.ITF14_CODE | scanCore.ScanType.MULTIFUNCTIONAL_CODE | scanCore.ScanType.PDF417_CODE | scanCore.ScanType.QR_CODE | scanCore.ScanType.UPC_A_CODE | scanCore.ScanType.UPC_E_CODE;
|
|
export class ShareWithSystemSuccess extends UTSObject {
|
|
}
|
|
export type ShareWithSystemFail = IShareWithSystemFail;
|
|
interface IShareWithSystemFail extends IUniError {
|
|
errCode: ShareWithSystemErrorCode;
|
|
}
|
|
type ShareWithSystemErrorCode = 1310600 | 1310601 | 1310602 | 1310603 | 1310604 | 1310605 | 1310606 | 1310607;
|
|
type ShareWithSystemSuccessCallback = (res: ShareWithSystemSuccess) => void;
|
|
type ShareWithSystemFailCallback = (res: ShareWithSystemFail) => void;
|
|
type ShareWithSystemCallback = (res: Object) => void;
|
|
export class ShareWithSystemOptions extends UTSObject {
|
|
type: 'text' | 'image' | 'video' | 'audio' | 'file' | null = null;
|
|
summary: string | null = null;
|
|
href: string | null = null;
|
|
imageUrl: string | null = null;
|
|
imagePaths: Array<string> | null = null;
|
|
videoPaths: Array<string> | null = null;
|
|
audioPaths: Array<string> | null = null;
|
|
filePaths: Array<string> | null = null;
|
|
success: ShareWithSystemSuccessCallback | null = null;
|
|
fail: ShareWithSystemFailCallback | null = null;
|
|
complete: ShareWithSystemCallback | null = null;
|
|
}
|
|
export type ShareWithSystem = (options: ShareWithSystemOptions) => void;
|
|
export class SetStorageSuccess extends UTSObject {
|
|
}
|
|
type SetStorageSuccessCallback = (res: SetStorageSuccess) => void;
|
|
type SetStorageFailCallback = (res: UniError) => void;
|
|
type SetStorageCompleteCallback = (res: Object) => void;
|
|
export class SetStorageOptions extends UTSObject {
|
|
key!: string;
|
|
data!: Object;
|
|
success: SetStorageSuccessCallback | null = null;
|
|
fail: SetStorageFailCallback | null = null;
|
|
complete: SetStorageCompleteCallback | null = null;
|
|
}
|
|
export type SetStorage = (options: SetStorageOptions) => void;
|
|
export type SetStorageSync = (key: string, data: Object) => void;
|
|
export class GetStorageSuccess extends UTSObject {
|
|
data: Object | null = null;
|
|
}
|
|
type GetStorageSuccessCallback = (res: GetStorageSuccess) => void;
|
|
type GetStorageFailCallback = (res: UniError) => void;
|
|
type GetStorageCompleteCallback = (res: Object) => void;
|
|
export class GetStorageOptions extends UTSObject {
|
|
key!: string;
|
|
success: GetStorageSuccessCallback | null = null;
|
|
fail: GetStorageFailCallback | null = null;
|
|
complete: GetStorageCompleteCallback | null = null;
|
|
}
|
|
export type GetStorage = (options: GetStorageOptions) => void;
|
|
export type GetStorageSync = (key: string) => Object | null;
|
|
export class GetStorageInfoSuccess extends UTSObject {
|
|
keys!: Array<string>;
|
|
currentSize!: number;
|
|
limitSize!: number;
|
|
}
|
|
type GetStorageInfoSuccessCallback = (res: GetStorageInfoSuccess) => void;
|
|
type GetStorageInfoFailCallback = (res: UniError) => void;
|
|
type GetStorageInfoCompleteCallback = (res: Object) => void;
|
|
export class GetStorageInfoOptions extends UTSObject {
|
|
success: GetStorageInfoSuccessCallback | null = null;
|
|
fail: GetStorageInfoFailCallback | null = null;
|
|
complete: GetStorageInfoCompleteCallback | null = null;
|
|
}
|
|
export type GetStorageInfo = (options: GetStorageInfoOptions) => void;
|
|
export type GetStorageInfoSync = () => GetStorageInfoSuccess;
|
|
export class RemoveStorageSuccess extends UTSObject {
|
|
}
|
|
type RemoveStorageSuccessCallback = (res: RemoveStorageSuccess) => void;
|
|
type RemoveStorageFailCallback = (res: UniError) => void;
|
|
type RemoveStorageCompleteCallback = (res: Object) => void;
|
|
export class RemoveStorageOptions extends UTSObject {
|
|
key!: string;
|
|
success: RemoveStorageSuccessCallback | null = null;
|
|
fail: RemoveStorageFailCallback | null = null;
|
|
complete: RemoveStorageCompleteCallback | null = null;
|
|
}
|
|
export type RemoveStorage = (options: RemoveStorageOptions) => void;
|
|
export type RemoveStorageSync = (key: string) => void;
|
|
export class ClearStorageSuccess extends UTSObject {
|
|
}
|
|
type ClearStorageSuccessCallback = (res: ClearStorageSuccess) => void;
|
|
type ClearStorageFailCallback = (res: UniError) => void;
|
|
type ClearStorageCompleteCallback = (res: Object) => void;
|
|
export class ClearStorageOptions extends UTSObject {
|
|
success: ClearStorageSuccessCallback | null = null;
|
|
fail: ClearStorageFailCallback | null = null;
|
|
complete: ClearStorageCompleteCallback | null = null;
|
|
}
|
|
export type ClearStorage = (option?: ClearStorageOptions | null) => void;
|
|
export type ClearStorageSync = () => void;
|
|
export type ConnectSocket = (options: ConnectSocketOptions) => SocketTask;
|
|
export class ConnectSocketSuccess extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type ConnectSocketSuccessCallback = (result: ConnectSocketSuccess) => void;
|
|
type ConnectSocketErrorCode = 600009;
|
|
interface ConnectSocketFail extends IUniError {
|
|
errCode: ConnectSocketErrorCode;
|
|
}
|
|
type ConnectSocketFailCallback = (result: ConnectSocketFail) => void;
|
|
type ConnectSocketComplete = Object;
|
|
type ConnectSocketCompleteCallback = (result: ConnectSocketComplete) => void;
|
|
export class ConnectSocketOptions extends UTSObject {
|
|
url!: string;
|
|
header: UTSJSONObject | null = null;
|
|
protocols: (string[]) | null = null;
|
|
success: ConnectSocketSuccessCallback | null = null;
|
|
fail: ConnectSocketFailCallback | null = null;
|
|
complete: ConnectSocketCompleteCallback | null = null;
|
|
}
|
|
class GeneralCallbackResult extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type SendSocketMessageErrorCode = 10001 | 10002 | 602001;
|
|
interface SendSocketMessageFail extends IUniError {
|
|
errCode: SendSocketMessageErrorCode;
|
|
}
|
|
export class SendSocketMessageOptions extends UTSObject {
|
|
data!: Object;
|
|
success: ((result: GeneralCallbackResult) => void) | null = null;
|
|
fail: ((result: SendSocketMessageFail) => void) | null = null;
|
|
complete: ((result: Object) => void) | null = null;
|
|
}
|
|
export class CloseSocketOptions extends UTSObject {
|
|
code: number | null = null;
|
|
reason: string | null = null;
|
|
success: ((result: GeneralCallbackResult) => void) | null = null;
|
|
fail: ((result: GeneralCallbackResult) => void) | null = null;
|
|
complete: ((result: GeneralCallbackResult) => void) | null = null;
|
|
}
|
|
class OnSocketOpenCallbackResult extends UTSObject {
|
|
header!: Object;
|
|
}
|
|
export class OnSocketMessageCallbackResult extends UTSObject {
|
|
data!: Object;
|
|
}
|
|
export interface SocketTask {
|
|
send(options: SendSocketMessageOptions): void;
|
|
close(options: CloseSocketOptions): void;
|
|
onOpen(callback: (result: OnSocketOpenCallbackResult) => void): void;
|
|
onClose(callback: (result: Object) => void): void;
|
|
onError(callback: (result: GeneralCallbackResult) => void): void;
|
|
onMessage(callback: (result: OnSocketMessageCallbackResult) => void): void;
|
|
}
|
|
type OnSocketOpenCallback = (result: OnSocketOpenCallbackResult) => void;
|
|
type OnSocketOpen = (options: OnSocketOpenCallback) => void;
|
|
export class OnSocketErrorCallbackResult extends UTSObject {
|
|
errMsg!: string;
|
|
}
|
|
type OnSocketErrorCallback = (result: OnSocketErrorCallbackResult) => void;
|
|
type OnSocketError = (callback: OnSocketErrorCallback) => void;
|
|
type SendSocketMessage = (options: SendSocketMessageOptions) => void;
|
|
type OnSocketMessageCallback = (result: OnSocketMessageCallbackResult) => void;
|
|
type OnSocketMessage = (callback: OnSocketMessageCallback) => void;
|
|
type CloseSocket = (options: CloseSocketOptions) => void;
|
|
class OnSocketCloseCallbackResult extends UTSObject {
|
|
code!: number;
|
|
reason!: string;
|
|
}
|
|
type OnSocketCloseCallback = (result: OnSocketCloseCallbackResult) => void;
|
|
type OnSocketClose = (callback: OnSocketCloseCallback) => void;
|
|
interface IUniWebsocketEmitter {
|
|
on: (eventName: string, callback: Function) => void;
|
|
once: (eventName: string, callback: Function) => void;
|
|
off: (eventName: string, callback?: Function | null) => void;
|
|
emit: (eventName: string, ...args: (Object | undefined | null)[]) => void;
|
|
}
|
|
interface UniExtApi {
|
|
addPhoneContact: AddPhoneContact;
|
|
startSoterAuthentication: StartSoterAuthentication;
|
|
checkIsSupportSoterAuthentication: CheckIsSupportSoterAuthentication;
|
|
checkIsSoterEnrolledInDevice: CheckIsSoterEnrolledInDevice;
|
|
chooseMedia: ChooseMedia;
|
|
getClipboardData: GetClipboardData;
|
|
setClipboardData: SetClipboardData;
|
|
createInnerAudioContext: CreateInnerAudioContext;
|
|
$on: $On;
|
|
$once: $Once;
|
|
$off: $Off;
|
|
$emit: $Emit;
|
|
exit: Exit;
|
|
saveFile: SaveFile;
|
|
getSavedFileList: GetSavedFileList;
|
|
getSavedFileInfo: GetSavedFileInfo;
|
|
removeSavedFile: RemoveSavedFile;
|
|
getFileInfo: GetFileInfo;
|
|
getFileSystemManager: GetFileSystemManager;
|
|
getAppAuthorizeSetting: GetAppAuthorizeSetting;
|
|
getAppBaseInfo: GetAppBaseInfo;
|
|
getBackgroundAudioManager: GetBackgroundAudioManager;
|
|
getDeviceInfo: GetDeviceInfo;
|
|
getNetworkType: GetNetworkType;
|
|
onNetworkStatusChange: OnNetworkStatusChange;
|
|
offNetworkStatusChange: OffNetworkStatusChange;
|
|
getProvider: GetProvider;
|
|
getProviderSync: GetProviderSync;
|
|
getRecorderManager: GetRecorderManager;
|
|
getSystemInfo: GetSystemInfo;
|
|
getSystemInfoSync: GetSystemInfoSync;
|
|
getWindowInfo: GetWindowInfo;
|
|
getSystemSetting: GetSystemSetting;
|
|
hideKeyboard: HideKeyboard;
|
|
makePhoneCall: MakePhoneCall;
|
|
chooseImage: ChooseImage;
|
|
previewImage: PreviewImage;
|
|
closePreviewImage: ClosePreviewImage;
|
|
getImageInfo: GetImageInfo;
|
|
saveImageToPhotosAlbum: SaveImageToPhotosAlbum;
|
|
compressImage: CompressImage;
|
|
chooseVideo: ChooseVideo;
|
|
saveVideoToPhotosAlbum: SaveVideoToPhotosAlbum;
|
|
getVideoInfo: GetVideoInfo;
|
|
compressVideo: CompressVideo;
|
|
chooseFile: ChooseFile;
|
|
request: Request<Object>;
|
|
uploadFile: UploadFile;
|
|
downloadFile: DownloadFile;
|
|
configMTLS: ConfigMTLS;
|
|
login: Login;
|
|
getUserInfo: GetUserInfo;
|
|
openAppAuthorizeSetting: OpenAppAuthorizeSetting;
|
|
openDocument: OpenDocument;
|
|
requestPayment: RequestPayment;
|
|
showToast: ShowToast;
|
|
hideToast: HideToast;
|
|
showLoading: ShowLoading;
|
|
hideLoading: HideLoading;
|
|
showModal: ShowModal;
|
|
showActionSheet: ShowActionSheet;
|
|
startPullDownRefresh: StartPullDownRefresh;
|
|
stopPullDownRefresh: StopPullDownRefresh;
|
|
rpx2px: Rpx2px;
|
|
scanCode: ScanCode;
|
|
shareWithSystem: ShareWithSystem;
|
|
setStorage: SetStorage;
|
|
setStorageSync: SetStorageSync;
|
|
getStorage: GetStorage;
|
|
getStorageSync: GetStorageSync;
|
|
getStorageInfo: GetStorageInfo;
|
|
getStorageInfoSync: GetStorageInfoSync;
|
|
removeStorage: RemoveStorage;
|
|
removeStorageSync: RemoveStorageSync;
|
|
clearStorage: ClearStorage;
|
|
clearStorageSync: ClearStorageSync;
|
|
connectSocket: ConnectSocket;
|
|
sendSocketMessage: SendSocketMessage;
|
|
closeSocket: CloseSocket;
|
|
onSocketOpen: OnSocketOpen;
|
|
onSocketMessage: OnSocketMessage;
|
|
onSocketClose: OnSocketClose;
|
|
onSocketError: OnSocketError;
|
|
}
|
|
export function initUniExtApi() {
|
|
const API_ADD_PHONE_CONTACT = 'addPhoneContact';
|
|
const AddPhoneContactApiOptions: ApiOptions<AddPhoneContactOptions> = {
|
|
formatArgs: new Map<string, ((firstName: string) => string | undefined)>([
|
|
[
|
|
'firstName',
|
|
(firstName: string)=>{
|
|
if (!firstName) {
|
|
return 'addPhoneContact:fail parameter error: parameter.firstName should not be empty;';
|
|
}
|
|
return undefined;
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const AddPhoneContactApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'firstName',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'photoFilePath',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'nickName',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'lastName',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'middleName',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'remark',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'mobilePhoneNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'weChatNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'addressCountry',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'addressState',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'addressCity',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'addressStreet',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'addressPostalCode',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'organization',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'title',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workFaxNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workPhoneNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'hostNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'email',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'url',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workAddressCountry',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workAddressState',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workAddressCity',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workAddressStreet',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'workAddressPostalCode',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeFaxNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homePhoneNumber',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeAddressCountry',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeAddressState',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeAddressCity',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeAddressStreet',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'homeAddressPostalCode',
|
|
{
|
|
type: 'string'
|
|
}
|
|
]
|
|
]);
|
|
const addPhoneContact: AddPhoneContact = defineAsyncApi<AddPhoneContactOptions, AddPhoneContactSuccess>(API_ADD_PHONE_CONTACT, (args: AddPhoneContactOptions, executor: ApiExecutor<AddPhoneContactSuccess>)=>{
|
|
UTSHarmony.requestSystemPermission([
|
|
'ohos.permission.WRITE_CONTACTS'
|
|
], (allRight: boolean)=>{
|
|
if (allRight) {
|
|
const photoFilePath = args.photoFilePath, _args_nickName = args.nickName, nickName = _args_nickName == null ? '' : _args_nickName, _args_lastName = args.lastName, lastName = _args_lastName == null ? '' : _args_lastName, _args_middleName = args.middleName, middleName = _args_middleName == null ? '' : _args_middleName, _args_firstName = args.firstName, firstName = _args_firstName == null ? '' : _args_firstName, _args_remark = args.remark, remark = _args_remark == null ? '' : _args_remark, _args_mobilePhoneNumber = args.mobilePhoneNumber, mobilePhoneNumber = _args_mobilePhoneNumber == null ? '' : _args_mobilePhoneNumber, _args_addressCountry = args.addressCountry, addressCountry = _args_addressCountry == null ? '' : _args_addressCountry, _args_addressState = args.addressState, addressState = _args_addressState == null ? '' : _args_addressState, _args_addressCity = args.addressCity, addressCity = _args_addressCity == null ? '' : _args_addressCity, _args_addressStreet = args.addressStreet, addressStreet = _args_addressStreet == null ? '' : _args_addressStreet, _args_addressPostalCode = args.addressPostalCode, addressPostalCode = _args_addressPostalCode == null ? '' : _args_addressPostalCode, _args_organization = args.organization, organization = _args_organization == null ? '' : _args_organization, _args_url = args.url, url = _args_url == null ? '' : _args_url, _args_workPhoneNumber = args.workPhoneNumber, workPhoneNumber = _args_workPhoneNumber == null ? '' : _args_workPhoneNumber, _args_workFaxNumber = args.workFaxNumber, workFaxNumber = _args_workFaxNumber == null ? '' : _args_workFaxNumber, _args_hostNumber = args.hostNumber, hostNumber = _args_hostNumber == null ? '' : _args_hostNumber, _args_email = args.email, email = _args_email == null ? '' : _args_email, _args_title = args.title, title = _args_title == null ? '' : _args_title, _args_workAddressCountry = args.workAddressCountry, workAddressCountry = _args_workAddressCountry == null ? '' : _args_workAddressCountry, _args_workAddressState = args.workAddressState, workAddressState = _args_workAddressState == null ? '' : _args_workAddressState, _args_workAddressCity = args.workAddressCity, workAddressCity = _args_workAddressCity == null ? '' : _args_workAddressCity, _args_workAddressStreet = args.workAddressStreet, workAddressStreet = _args_workAddressStreet == null ? '' : _args_workAddressStreet, workAddressPostalCode = args.workAddressPostalCode, _args_homeFaxNumber = args.homeFaxNumber, homeFaxNumber = _args_homeFaxNumber == null ? '' : _args_homeFaxNumber, _args_homePhoneNumber = args.homePhoneNumber, homePhoneNumber = _args_homePhoneNumber == null ? '' : _args_homePhoneNumber, _args_homeAddressCountry = args.homeAddressCountry, homeAddressCountry = _args_homeAddressCountry == null ? '' : _args_homeAddressCountry, _args_homeAddressState = args.homeAddressState, homeAddressState = _args_homeAddressState == null ? '' : _args_homeAddressState, _args_homeAddressCity = args.homeAddressCity, homeAddressCity = _args_homeAddressCity == null ? '' : _args_homeAddressCity, _args_homeAddressStreet = args.homeAddressStreet, homeAddressStreet = _args_homeAddressStreet == null ? '' : _args_homeAddressStreet, _args_homeAddressPostalCode = args.homeAddressPostalCode, homeAddressPostalCode = _args_homeAddressPostalCode == null ? '' : _args_homeAddressPostalCode;
|
|
const contactInfo: contact.Contact = {
|
|
name: {
|
|
givenName: firstName!,
|
|
fullName: lastName! + middleName! + firstName!
|
|
}
|
|
};
|
|
if (nickName) {
|
|
contactInfo.nickName = {
|
|
nickName: nickName!
|
|
} as contact.NickName;
|
|
}
|
|
if (lastName) {
|
|
contactInfo.name!.familyName = lastName;
|
|
}
|
|
if (middleName) {
|
|
contactInfo.name!.middleName = middleName;
|
|
}
|
|
if (email) {
|
|
contactInfo.emails = [
|
|
{
|
|
email: email!,
|
|
displayName: '邮箱'
|
|
} as contact.Email
|
|
];
|
|
}
|
|
if (photoFilePath) {
|
|
contactInfo.portrait = {
|
|
uri: photoFilePath
|
|
} as contact.Portrait;
|
|
}
|
|
if (url) {
|
|
contactInfo.websites = [
|
|
{
|
|
website: url
|
|
} as contact.Website
|
|
];
|
|
}
|
|
if (remark) {
|
|
contactInfo.note = {
|
|
noteContent: remark
|
|
} as contact.Note;
|
|
}
|
|
if (organization) {
|
|
contactInfo.organization = {
|
|
name: organization,
|
|
title: title!
|
|
} as contact.Organization;
|
|
}
|
|
const phoneNumbers: contact.PhoneNumber[] = [];
|
|
if (homePhoneNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: homePhoneNumber!,
|
|
labelId: contact.PhoneNumber.NUM_HOME
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (mobilePhoneNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: mobilePhoneNumber!,
|
|
labelId: contact.PhoneNumber.NUM_MOBILE
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (homeFaxNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: homeFaxNumber!,
|
|
labelId: contact.PhoneNumber.NUM_FAX_HOME
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (workFaxNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: workFaxNumber!,
|
|
labelId: contact.PhoneNumber.NUM_FAX_WORK
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (workPhoneNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: workPhoneNumber!,
|
|
labelId: contact.PhoneNumber.NUM_WORK
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (hostNumber) {
|
|
phoneNumbers.push({
|
|
phoneNumber: hostNumber!,
|
|
labelId: contact.PhoneNumber.NUM_COMPANY_MAIN
|
|
} as contact.PhoneNumber);
|
|
}
|
|
if (phoneNumbers.length) contactInfo.phoneNumbers = phoneNumbers;
|
|
const postalAddresses: contact.PostalAddress[] = [];
|
|
if (homeAddressCity || homeAddressCountry || homeAddressPostalCode || homeAddressStreet) {
|
|
postalAddresses.push({
|
|
city: homeAddressCity!,
|
|
country: homeAddressCountry!,
|
|
postcode: homeAddressPostalCode!,
|
|
street: homeAddressStreet!,
|
|
postalAddress: `${homeAddressCountry!}${homeAddressState!}${homeAddressCity!}${homeAddressStreet!}`,
|
|
labelId: contact.PostalAddress.ADDR_HOME
|
|
} as contact.PostalAddress);
|
|
}
|
|
if (workAddressCity || workAddressCountry || workAddressPostalCode || workAddressStreet) {
|
|
postalAddresses.push({
|
|
city: workAddressCity!,
|
|
country: workAddressCountry!,
|
|
postcode: workAddressPostalCode!,
|
|
street: workAddressStreet!,
|
|
postalAddress: `${workAddressCountry!}${workAddressState!}${workAddressCity!}${workAddressStreet!}`,
|
|
labelId: contact.PostalAddress.ADDR_WORK
|
|
} as contact.PostalAddress);
|
|
}
|
|
if (addressCity || addressCountry || addressPostalCode || addressStreet) {
|
|
postalAddresses.push({
|
|
city: addressCity!,
|
|
country: addressCountry!,
|
|
postcode: addressPostalCode!,
|
|
street: addressStreet!,
|
|
postalAddress: `${addressCountry!}${addressState!}${addressCity!}${addressStreet!}`,
|
|
labelId: contact.PostalAddress.CUSTOM_LABEL
|
|
} as contact.PostalAddress);
|
|
}
|
|
if (postalAddresses.length) contactInfo.postalAddresses = postalAddresses;
|
|
contact.addContact(UTSHarmony.getUIAbilityContext()!, contactInfo).then((contactId)=>{
|
|
executor.resolve(contactId);
|
|
}).catch((err: BusinessError)=>{
|
|
executor.reject(err.message);
|
|
});
|
|
} else {
|
|
executor.reject('Permission denied');
|
|
}
|
|
}, ()=>executor.reject('Permission denied'));
|
|
}, AddPhoneContactApiProtocol, AddPhoneContactApiOptions) as AddPhoneContact;
|
|
const API_START_SOTER_AUTHENTICATION = 'startSoterAuthentication';
|
|
const StartSoterAuthenticationApiOptions: ApiOptions<StartSoterAuthenticationOptions> = {
|
|
formatArgs: new Map<string, ((value: string) => string | undefined)>([
|
|
[
|
|
'requestAuthModes',
|
|
(value: string)=>{
|
|
if (!value.includes('fingerPrint') && !value.includes('facial')) {
|
|
return 'requestAuthModes 填写错误';
|
|
}
|
|
return undefined;
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const StartSoterAuthenticationApiProtocols = new Map<string, ProtocolOptions>([
|
|
[
|
|
'requestAuthModes',
|
|
{
|
|
type: 'array',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'challenge',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'authContent',
|
|
{
|
|
type: 'string'
|
|
}
|
|
]
|
|
]);
|
|
const API_CHECK_IS_SOTER_ENROLLED_IN_DEVICE = 'checkIsSoterEnrolledInDevice';
|
|
const checkAuthModes: SoterAuthMode[] = [
|
|
'fingerPrint',
|
|
'facial',
|
|
'speech'
|
|
];
|
|
const CheckIsSoterEnrolledInDeviceApiOptions: ApiOptions<CheckIsSoterEnrolledInDeviceOptions> = {
|
|
formatArgs: new Map<string, ((value: string) => string | undefined)>([
|
|
[
|
|
'checkAuthMode',
|
|
(value: string)=>{
|
|
if (!checkAuthModes.includes(value as SoterAuthMode)) {
|
|
return 'checkAuthMode 填写错误';
|
|
}
|
|
return undefined;
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const CheckIsSoterEnrolledInDeviceProtocols = new Map<string, ProtocolOptions>([
|
|
[
|
|
'checkAuthMode',
|
|
{
|
|
type: 'string'
|
|
}
|
|
]
|
|
]);
|
|
const API_CHECK_IS_SUPPORT_SOTER_AUTHENTICATION = 'checkIsSupportSoterAuthentication';
|
|
const getErrorMessage = (code: number): string =>{
|
|
switch(code){
|
|
case 201:
|
|
return "权限认证失败";
|
|
case 401:
|
|
return "参数不正确。可能的一个原因: 强制参数未指定";
|
|
case userAuth.UserAuthResultCode.FAIL:
|
|
return "认证失败";
|
|
case userAuth.UserAuthResultCode.GENERAL_ERROR:
|
|
return "操作通用错误";
|
|
case userAuth.UserAuthResultCode.CANCELED:
|
|
return "操作取消";
|
|
case userAuth.UserAuthResultCode.TIMEOUT:
|
|
return "操作超时";
|
|
case userAuth.UserAuthResultCode.TYPE_NOT_SUPPORT:
|
|
return "不支持的认证类型";
|
|
case userAuth.UserAuthResultCode.TRUST_LEVEL_NOT_SUPPORT:
|
|
return "不支持的认证等级";
|
|
case userAuth.UserAuthResultCode.BUSY:
|
|
return "忙碌状态";
|
|
case userAuth.UserAuthResultCode.LOCKED:
|
|
return "认证器已锁定";
|
|
case userAuth.UserAuthResultCode.NOT_ENROLLED:
|
|
return "用户未录入认证信息";
|
|
case userAuth.UserAuthResultCode.CANCELED_FROM_WIDGET:
|
|
return "切换到自定义身份验证过程";
|
|
case 12500013:
|
|
return "系统锁屏密码过期";
|
|
default:
|
|
return '';
|
|
}
|
|
};
|
|
const getUniErrMsg = (code: number): number =>{
|
|
switch(code){
|
|
case 201:
|
|
return 90002;
|
|
case 401:
|
|
return 90004;
|
|
case userAuth.UserAuthResultCode.FAIL:
|
|
return 90009;
|
|
case userAuth.UserAuthResultCode.GENERAL_ERROR:
|
|
return 90007;
|
|
case userAuth.UserAuthResultCode.CANCELED:
|
|
return 90008;
|
|
case userAuth.UserAuthResultCode.TIMEOUT:
|
|
return 90007;
|
|
case userAuth.UserAuthResultCode.TYPE_NOT_SUPPORT:
|
|
return 90003;
|
|
case userAuth.UserAuthResultCode.TRUST_LEVEL_NOT_SUPPORT:
|
|
return 90003;
|
|
case userAuth.UserAuthResultCode.BUSY:
|
|
return 90010;
|
|
case userAuth.UserAuthResultCode.LOCKED:
|
|
return 90010;
|
|
case userAuth.UserAuthResultCode.NOT_ENROLLED:
|
|
return 90011;
|
|
case userAuth.UserAuthResultCode.CANCELED_FROM_WIDGET:
|
|
return userAuth.UserAuthResultCode.CANCELED_FROM_WIDGET;
|
|
case 12500013:
|
|
return 12500013;
|
|
default:
|
|
return -1;
|
|
}
|
|
};
|
|
const toUint8Arr = (str: string)=>{
|
|
const buffer: number[] = [];
|
|
for (let i of str){
|
|
const _code: number = i.charCodeAt(0);
|
|
if (_code < 0x80) {
|
|
buffer.push(_code);
|
|
} else if (_code < 0x800) {
|
|
buffer.push(0xc0 + (_code >> 6));
|
|
buffer.push(0x80 + (_code & 0x3f));
|
|
} else if (_code < 0x10000) {
|
|
buffer.push(0xe0 + (_code >> 12));
|
|
buffer.push(0x80 + (_code >> 6 & 0x3f));
|
|
buffer.push(0x80 + (_code & 0x3f));
|
|
}
|
|
}
|
|
return Uint8Array.from(buffer);
|
|
};
|
|
const startSoterAuthentication: StartSoterAuthentication = defineAsyncApi<StartSoterAuthenticationOptions, StartSoterAuthenticationSuccess>(API_START_SOTER_AUTHENTICATION, (args: StartSoterAuthenticationOptions, executor: ApiExecutor<StartSoterAuthenticationSuccess>)=>{
|
|
const authType: userAuth.UserAuthType[] = [];
|
|
args.requestAuthModes.forEach((item)=>{
|
|
if (item === 'fingerPrint') {
|
|
authType.push(userAuth.UserAuthType.FINGERPRINT);
|
|
} else if (item === 'facial') {
|
|
authType.push(userAuth.UserAuthType.FACE);
|
|
}
|
|
});
|
|
const challengeArr = toUint8Arr(args.challenge ?? '');
|
|
const authContent = args.authContent ?? '';
|
|
try {
|
|
const auth = userAuth.getUserAuthInstance({
|
|
challenge: challengeArr,
|
|
authType,
|
|
authTrustLevel: userAuth.AuthTrustLevel.ATL1
|
|
} as userAuth.AuthParam, {
|
|
title: authContent
|
|
} as userAuth.WidgetParam);
|
|
auth.on("result", {
|
|
onResult: (result: userAuth.UserAuthResult)=>{
|
|
if (result.result === userAuth.UserAuthResultCode.SUCCESS) {
|
|
executor.resolve({
|
|
errCode: 0,
|
|
authMode: result.authType === userAuth.UserAuthType.FINGERPRINT ? 'fingerPrint' : 'facial'
|
|
} as StartSoterAuthenticationSuccess);
|
|
} else {
|
|
const errMsg = getErrorMessage(result.result);
|
|
const errCode = getUniErrMsg(result.result);
|
|
executor.reject(errMsg, {
|
|
errCode
|
|
} as ApiError);
|
|
}
|
|
}
|
|
} as userAuth.IAuthCallback);
|
|
if (authContent) {
|
|
promptAction.showToast({
|
|
message: authContent
|
|
} as promptAction.ShowToastOptions);
|
|
}
|
|
auth.start();
|
|
} catch (error) {
|
|
const code = (error as BusinessError1).code;
|
|
executor.reject(getErrorMessage(code), {
|
|
errCode: getUniErrMsg(code)
|
|
} as ApiError);
|
|
}
|
|
}, StartSoterAuthenticationApiProtocols, StartSoterAuthenticationApiOptions) as StartSoterAuthentication;
|
|
const fingerPrintAvailable = ()=>{
|
|
try {
|
|
userAuth.getAvailableStatus(userAuth.UserAuthType.FINGERPRINT, userAuth.AuthTrustLevel.ATL1);
|
|
return true;
|
|
} catch (error) {
|
|
if ([
|
|
userAuth.UserAuthResultCode.NOT_ENROLLED,
|
|
userAuth.UserAuthResultCode.PIN_EXPIRED
|
|
].includes((error as BusinessError1).code)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
const faceAvailable = ()=>{
|
|
try {
|
|
userAuth.getAvailableStatus(userAuth.UserAuthType.FACE, userAuth.AuthTrustLevel.ATL1);
|
|
return true;
|
|
} catch (error) {
|
|
if ([
|
|
userAuth.UserAuthResultCode.NOT_ENROLLED,
|
|
userAuth.UserAuthResultCode.PIN_EXPIRED
|
|
].includes((error as BusinessError1).code)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
const PERMISSIONS = [
|
|
'ohos.permission.ACCESS_BIOMETRIC'
|
|
];
|
|
const checkIsSupportSoterAuthentication: CheckIsSupportSoterAuthentication = defineAsyncApi<CheckIsSupportSoterAuthenticationOptions, CheckIsSupportSoterAuthenticationSuccess>(API_CHECK_IS_SUPPORT_SOTER_AUTHENTICATION, (args: CheckIsSupportSoterAuthenticationOptions, executor: ApiExecutor<CheckIsSupportSoterAuthenticationSuccess>)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
try {
|
|
const supportMode: SoterAuthMode[] = [];
|
|
if (fingerPrintAvailable()) supportMode.push('fingerPrint');
|
|
if (faceAvailable()) supportMode.push('facial');
|
|
return executor.resolve({
|
|
supportMode,
|
|
errMsg: ''
|
|
} as CheckIsSupportSoterAuthenticationSuccess);
|
|
} catch (error) {
|
|
const code = (error as BusinessError1).code;
|
|
executor.reject(getErrorMessage(code), {
|
|
errCode: getUniErrMsg(code)
|
|
} as ApiError);
|
|
}
|
|
} else {
|
|
executor.reject(getErrorMessage(201));
|
|
}
|
|
}, ()=>{
|
|
executor.reject(getErrorMessage(201));
|
|
});
|
|
}) as CheckIsSupportSoterAuthentication;
|
|
const getFingerPrintEnrolledState = ()=>{
|
|
userAuth.getEnrolledState(userAuth.UserAuthType.FINGERPRINT);
|
|
return true;
|
|
};
|
|
const getFaceEnrolledState = ()=>{
|
|
userAuth.getEnrolledState(userAuth.UserAuthType.FACE);
|
|
return true;
|
|
};
|
|
const harmonyCheckIsSoterEnrolledInDevice = (checkAuthMode: SoterAuthMode): boolean =>{
|
|
if (checkAuthMode === 'fingerPrint') {
|
|
return getFingerPrintEnrolledState();
|
|
} else if (checkAuthMode === 'facial') {
|
|
return getFaceEnrolledState();
|
|
}
|
|
return false;
|
|
};
|
|
const checkIsSoterEnrolledInDevice: CheckIsSoterEnrolledInDevice = defineAsyncApi<CheckIsSoterEnrolledInDeviceOptions, CheckIsSoterEnrolledInDeviceSuccess>(API_CHECK_IS_SOTER_ENROLLED_IN_DEVICE, (args: CheckIsSoterEnrolledInDeviceOptions, executor: ApiExecutor<CheckIsSoterEnrolledInDeviceSuccess>)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
try {
|
|
const isEnrolled = harmonyCheckIsSoterEnrolledInDevice(args.checkAuthMode);
|
|
executor.resolve({
|
|
isEnrolled,
|
|
errMsg: ''
|
|
} as CheckIsSoterEnrolledInDeviceSuccess);
|
|
} catch (error) {
|
|
const code = (error as BusinessError1).code;
|
|
executor.reject(getErrorMessage(code), {
|
|
errCode: getUniErrMsg(code)
|
|
} as ApiError);
|
|
}
|
|
} else {
|
|
executor.reject(getErrorMessage(201));
|
|
}
|
|
}, ()=>{
|
|
executor.reject(getErrorMessage(201));
|
|
});
|
|
}, CheckIsSoterEnrolledInDeviceProtocols, CheckIsSoterEnrolledInDeviceApiOptions) as CheckIsSoterEnrolledInDevice;
|
|
const API_CHOOSE_MEDIA = 'chooseMedia';
|
|
const ChooseMediaApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'count',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'mediaType',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'maxDuration',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'camera',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const ChooseMediaApiOptions: ApiOptions<ChooseMediaOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'count',
|
|
(count: number, params: ChooseMediaOptions)=>{
|
|
if (count == null) {
|
|
params.count = 9;
|
|
}
|
|
if (params.count != null && params.count > 9) {
|
|
params.count = 9;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'mediaType',
|
|
(mediaType: string[], params: ChooseMediaOptions)=>{
|
|
if (mediaType == null) {
|
|
params.mediaType = [
|
|
'image',
|
|
'video'
|
|
];
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
(sourceType: string[], params: ChooseMediaOptions)=>{
|
|
if (sourceType == null) {
|
|
params.sourceType = [
|
|
'album',
|
|
'camera'
|
|
];
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'maxDuration',
|
|
(maxDuration: number, params: ChooseMediaOptions)=>{
|
|
if (maxDuration == null) {
|
|
params.maxDuration = 10;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'camera',
|
|
(camera: string, params: ChooseMediaOptions)=>{
|
|
if (camera == null) {
|
|
params.camera = 'back';
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const _getVideoInfo = async (uri: string): Promise<_GetVideoInfoSuccess> =>{
|
|
const file = await fs.open(uri, fs.OpenMode.READ_ONLY);
|
|
const avMetadataExtractor = await media.createAVMetadataExtractor();
|
|
let metadata: media.AVMetadata | null = null;
|
|
let size: number = 0;
|
|
try {
|
|
size = (await fs.stat(file.fd)).size;
|
|
avMetadataExtractor.dataSrc = {
|
|
fileSize: size,
|
|
callback: (buffer: ArrayBuffer, length: number, pos: number | null = null)=>{
|
|
return fs.readSync(file.fd, buffer, {
|
|
offset: pos,
|
|
length
|
|
} as ReadOptions);
|
|
}
|
|
};
|
|
metadata = await avMetadataExtractor.fetchMetadata();
|
|
} catch (error) {
|
|
throw error as Error;
|
|
} finally{
|
|
await avMetadataExtractor.release();
|
|
await fs.close(file);
|
|
}
|
|
const videoOrientationArr = [
|
|
'up',
|
|
'right',
|
|
'down',
|
|
'left'
|
|
] as _MediaOrientation[];
|
|
return {
|
|
size: size,
|
|
duration: metadata.duration ? Number(metadata.duration) / 1000 : undefined,
|
|
width: metadata.videoWidth ? Number(metadata.videoWidth) : undefined,
|
|
height: metadata.videoHeight ? Number(metadata.videoHeight) : undefined,
|
|
type: metadata.mimeType,
|
|
orientation: metadata.videoOrientation ? videoOrientationArr[Number(metadata.videoOrientation) / 90] : undefined
|
|
} as _GetVideoInfoSuccess;
|
|
};
|
|
const _chooseMedia = async (options: __ChooseMediaOptions): Promise<_chooseMediaSuccessCallbackResult> =>{
|
|
const photoSelectOptions = new photoAccessHelper.PhotoSelectOptions();
|
|
const mimeType = options.mimeType;
|
|
photoSelectOptions.MIMEType = mimeType;
|
|
if (mimeType === photoAccessHelper.PhotoViewMIMETypes.VIDEO_TYPE) {
|
|
photoSelectOptions.maxSelectNumber = 1;
|
|
} else {
|
|
photoSelectOptions.maxSelectNumber = options.count || 9;
|
|
}
|
|
photoSelectOptions.isOriginalSupported = options.isOriginalSupported;
|
|
photoSelectOptions.isPhotoTakingSupported = !(options.sourceType && !options.sourceType.includes('camera'));
|
|
const photoPicker = new photoAccessHelper.PhotoViewPicker();
|
|
const photoSelectResult = await photoPicker.select(photoSelectOptions);
|
|
const uris = photoSelectResult.photoUris;
|
|
if (mimeType !== photoAccessHelper.PhotoViewMIMETypes.VIDEO_TYPE) {
|
|
let realUris: string[] = uris;
|
|
return {
|
|
tempFiles: realUris.map((uri)=>{
|
|
const file = fs.openSync(uri, fs.OpenMode.READ_ONLY);
|
|
const stat = fs.statSync(file.fd);
|
|
fs.closeSync(file);
|
|
return {
|
|
fileType: 'image',
|
|
tempFilePath: uri,
|
|
size: stat.size
|
|
} as _MediaFile;
|
|
})
|
|
};
|
|
}
|
|
const tempFiles: _MediaFile[] = [];
|
|
for(let i = 0; i < uris.length; i++){
|
|
const uri = uris[i];
|
|
const videoInfo = await _getVideoInfo(uri);
|
|
tempFiles.push({
|
|
fileType: 'video',
|
|
tempFilePath: uri,
|
|
size: videoInfo.size,
|
|
duration: videoInfo.duration,
|
|
width: videoInfo.width,
|
|
height: videoInfo.height
|
|
} as _MediaFile);
|
|
}
|
|
return {
|
|
tempFiles
|
|
} as _chooseMediaSuccessCallbackResult;
|
|
};
|
|
const getHMCameraPosition = (cameraType: CameraPosition)=>{
|
|
switch(cameraType){
|
|
case 'back':
|
|
return camera.CameraPosition.CAMERA_POSITION_BACK;
|
|
case 'front':
|
|
return camera.CameraPosition.CAMERA_POSITION_FRONT;
|
|
default:
|
|
return camera.CameraPosition.CAMERA_POSITION_BACK;
|
|
}
|
|
};
|
|
const getCameraPickerMediaTypes = (UniMediaTypes: UNI_MEDIA_TYPE[]): cameraPicker.PickerMediaType[] =>{
|
|
let mediaTypes: Array<cameraPicker.PickerMediaType> = [];
|
|
if (UniMediaTypes.includes('mix')) {
|
|
mediaTypes.push(cameraPicker.PickerMediaType.PHOTO, cameraPicker.PickerMediaType.VIDEO);
|
|
} else {
|
|
if (UniMediaTypes.includes('image')) {
|
|
mediaTypes.push(cameraPicker.PickerMediaType.PHOTO);
|
|
}
|
|
if (UniMediaTypes.includes('video')) {
|
|
mediaTypes.push(cameraPicker.PickerMediaType.VIDEO);
|
|
}
|
|
}
|
|
return mediaTypes;
|
|
};
|
|
const _takeCamera = async (args: ChooseMediaOptions, executor: ApiExecutor<ChooseMediaSuccess>)=>{
|
|
try {
|
|
let pickerProfile: cameraPicker.PickerProfile = {
|
|
cameraPosition: getHMCameraPosition(args?.camera ?? 'back'),
|
|
videoDuration: args?.maxDuration ?? 10
|
|
};
|
|
const mediaTypes = getCameraPickerMediaTypes((args.mediaType ?? []) as UNI_MEDIA_TYPE[]);
|
|
const res = await cameraPicker.pick(UTSHarmony.getUIAbilityContext()!, mediaTypes, pickerProfile);
|
|
executor.resolve({
|
|
type: 'mix',
|
|
tempFiles: [
|
|
{
|
|
tempFilePath: res.resultUri,
|
|
fileType: res.mediaType === cameraPicker.PickerMediaType.PHOTO ? 'image' : 'video'
|
|
}
|
|
]
|
|
} as ChooseMediaSuccess);
|
|
} catch (error) {
|
|
const err = error as BusinessError2;
|
|
executor.reject(err.message, {
|
|
errCode: err.code
|
|
} as ApiError);
|
|
}
|
|
};
|
|
const __chooseMedia = async (args: ChooseMediaOptions, mimeType: photoAccessHelper1.PhotoViewMIMETypes, executor: ApiExecutor<ChooseMediaSuccess>)=>{
|
|
if (args.sourceType?.length === 1 && args.sourceType[0] === 'camera') {
|
|
_takeCamera(args, executor);
|
|
} else {
|
|
_chooseMedia({
|
|
mimeType,
|
|
sourceType: [
|
|
"album"
|
|
],
|
|
count: args.count!,
|
|
isOriginalSupported: true
|
|
} as __ChooseMediaOptions).then((res)=>{
|
|
executor.resolve({
|
|
type: 'mix',
|
|
tempFiles: res.tempFiles.map((tempFile): ChooseMediaTempFile =>{
|
|
if (tempFile.fileType === 'image') {
|
|
return {
|
|
fileType: tempFile.fileType,
|
|
tempFilePath: tempFile.tempFilePath,
|
|
size: tempFile.size
|
|
} as ChooseMediaTempFile;
|
|
}
|
|
return {
|
|
tempFilePath: tempFile.tempFilePath,
|
|
duration: tempFile.duration,
|
|
size: tempFile.size,
|
|
height: tempFile.height,
|
|
width: tempFile.width,
|
|
fileType: tempFile.fileType
|
|
} as ChooseMediaTempFile;
|
|
})
|
|
} as ChooseMediaSuccess);
|
|
}).catch((err: Error)=>{
|
|
executor.reject(err.message);
|
|
});
|
|
}
|
|
};
|
|
const chooseMedia: ChooseMedia = defineAsyncApi<ChooseMediaOptions, ChooseMediaSuccess>(API_CHOOSE_MEDIA, async (args: ChooseMediaOptions, executor: ApiExecutor<ChooseMediaSuccess>)=>{
|
|
if (args.mediaType?.length === 1 && args.mediaType[0] === 'image') {
|
|
__chooseMedia(args, photoAccessHelper1.PhotoViewMIMETypes.IMAGE_TYPE, executor);
|
|
return;
|
|
}
|
|
if (args.mediaType?.length === 1 && args.mediaType[0] === 'video') {
|
|
__chooseMedia(args, photoAccessHelper1.PhotoViewMIMETypes.VIDEO_TYPE, executor);
|
|
return;
|
|
}
|
|
if (args.sourceType?.length === 1 && args.sourceType[0] === 'camera') {
|
|
_takeCamera(args, executor);
|
|
} else {
|
|
const lastWindow = UTSHarmony.getCurrentWindow() as window.Window;
|
|
const UIContextPromptAction = await lastWindow.getUIContext().getPromptAction();
|
|
UIContextPromptAction.showActionMenu({
|
|
buttons: [
|
|
{
|
|
text: '拍摄',
|
|
color: '#000000'
|
|
},
|
|
{
|
|
text: '从相册选择',
|
|
color: '#000000'
|
|
}
|
|
]
|
|
} as promptAction1.ActionMenuOptions, (err, ref)=>{
|
|
let index = ref.index;
|
|
if (err) {
|
|
executor.reject('cancel');
|
|
} else {
|
|
if (index === 0) {
|
|
_takeCamera(args, executor);
|
|
} else if (index === 1) {
|
|
__chooseMedia(args, photoAccessHelper1.PhotoViewMIMETypes.IMAGE_VIDEO_TYPE, executor);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, ChooseMediaApiProtocol, ChooseMediaApiOptions) as ChooseMedia;
|
|
const API_GET_CLIPBOARD_DATA = 'getClipboardData';
|
|
const API_SET_CLIPBOARD_DATA = 'setClipboardData';
|
|
const SetClipboardDataApiOptions: ApiOptions<SetClipboardDataOptions> = {
|
|
formatArgs: new Map<string, boolean>([
|
|
[
|
|
'showToast',
|
|
true
|
|
]
|
|
])
|
|
};
|
|
const SetClipboardDataProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'data',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'showToast',
|
|
{
|
|
type: 'boolean'
|
|
}
|
|
]
|
|
]);
|
|
const getString = (callback: ClipboardCallback)=>{
|
|
const systemPasteboard: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard();
|
|
UTSHarmony.requestSystemPermission([
|
|
'ohos.permission.READ_PASTEBOARD'
|
|
], (allRight: boolean)=>{
|
|
if (allRight) {
|
|
const pasteData = systemPasteboard.getDataSync();
|
|
try {
|
|
const text: string = pasteData.getPrimaryText();
|
|
callback({
|
|
data: text,
|
|
result: 'success'
|
|
} as ClipboardCallbackOptions);
|
|
} catch (err) {
|
|
callback({
|
|
data: (err as BusinessError3<void>).message,
|
|
result: 'fail'
|
|
} as ClipboardCallbackOptions);
|
|
}
|
|
} else {
|
|
callback({
|
|
data: 'Permission denied',
|
|
result: 'fail'
|
|
} as ClipboardCallbackOptions);
|
|
}
|
|
}, ()=>{
|
|
callback({
|
|
data: 'Permission denied',
|
|
result: 'fail'
|
|
} as ClipboardCallbackOptions);
|
|
});
|
|
};
|
|
const setString = (data: string)=>{
|
|
const pasteData: pasteboard.PasteData = pasteboard.createData(pasteboard.MIMETYPE_TEXT_PLAIN, data);
|
|
const systemPasteboard: pasteboard.SystemPasteboard = pasteboard.getSystemPasteboard();
|
|
try {
|
|
systemPasteboard.setDataSync(pasteData);
|
|
return {
|
|
data,
|
|
result: 'success'
|
|
} as ClipboardCallbackOptions;
|
|
} catch (err) {
|
|
return {
|
|
data: (err as BusinessError3<void>).message,
|
|
result: 'fail'
|
|
} as ClipboardCallbackOptions;
|
|
}
|
|
};
|
|
const getClipboardData: GetClipboardData = defineAsyncApi<GetClipboardDataOptions, GetClipboardDataSuccess>(API_GET_CLIPBOARD_DATA, (_: GetClipboardDataOptions, res: ApiExecutor<GetClipboardDataSuccess>)=>{
|
|
getString((ret: ClipboardCallbackOptions)=>{
|
|
if (ret.result === 'success') {
|
|
res.resolve({
|
|
data: ret.data
|
|
} as GetClipboardDataSuccess);
|
|
} else {
|
|
res.reject('getClipboardData:fail ' + ret.data);
|
|
}
|
|
});
|
|
}) as GetClipboardData;
|
|
const setClipboardData: SetClipboardData = defineAsyncApi<SetClipboardDataOptions, SetClipboardDataSuccess>(API_SET_CLIPBOARD_DATA, (options: SetClipboardDataOptions, res: ApiExecutor<SetClipboardDataSuccess>)=>{
|
|
const ret = setString(options.data);
|
|
if (ret.result === 'success') {
|
|
res.resolve();
|
|
} else {
|
|
res.reject('setClipboardData:fail ' + ret.data);
|
|
}
|
|
}, SetClipboardDataProtocol, SetClipboardDataApiOptions) as SetClipboardData;
|
|
const API_CREATE_INNER_AUDIO_CONTEXT = 'createInnerAudioContext';
|
|
const isFileUri = (path: string)=>{
|
|
return path && typeof path === 'string' && (path.startsWith('file://') || path.startsWith('datashare://'));
|
|
};
|
|
const isSandboxPath = (path: string)=>{
|
|
return path && typeof path === 'string' && path.startsWith('/data/storage/');
|
|
};
|
|
const getFdFromUriOrSandBoxPath = (uri: string)=>{
|
|
try {
|
|
const file = fileIo.openSync(uri, fileIo.OpenMode.READ_ONLY);
|
|
return file.fd;
|
|
} catch (error) {
|
|
console.info(`[AdvancedAPI] Can not get file from uri: ${uri} `);
|
|
}
|
|
throw new Error('file is not exist');
|
|
};
|
|
const callCallbacks = (callbacks: Function[], ...args: Object[])=>{
|
|
callbacks.forEach((cb)=>{
|
|
typeof cb === 'function' && cb(...args);
|
|
});
|
|
};
|
|
const remoteCallback = (callbacks: Function[], callback: Function)=>{
|
|
const index = callbacks.indexOf(callback);
|
|
if (index > -1) {
|
|
callbacks.splice(index, 1);
|
|
}
|
|
};
|
|
class AudioPlayerError {
|
|
errMsg: string;
|
|
errCode: number;
|
|
constructor(errMsg: string, errCode: number){
|
|
this.errMsg = errMsg;
|
|
this.errCode = errCode;
|
|
}
|
|
}
|
|
class AudioPlayerCallback {
|
|
onCanplayCallbacks: Function[] = [];
|
|
onPlayCallbacks: Function[] = [];
|
|
onPauseCallbacks: Function[] = [];
|
|
onStopCallbacks: Function[] = [];
|
|
onEndedCallbacks: Function[] = [];
|
|
onTimeUpdateCallbacks: Function[] = [];
|
|
onErrorCallbacks: Function[] = [];
|
|
onWaitingCallbacks: Function[] = [];
|
|
onSeekingCallbacks: Function[] = [];
|
|
onSeekedCallbacks: Function[] = [];
|
|
constructor(){}
|
|
canPlay() {
|
|
callCallbacks(this.onCanplayCallbacks);
|
|
}
|
|
onCanplay(callback: Function) {
|
|
this.onCanplayCallbacks.push(callback);
|
|
}
|
|
offCanplay(callback: Function) {
|
|
remoteCallback(this.onCanplayCallbacks, callback);
|
|
}
|
|
play() {
|
|
callCallbacks(this.onPlayCallbacks);
|
|
}
|
|
onPlay(callback: Function) {
|
|
this.onPlayCallbacks.push(callback);
|
|
}
|
|
offPlay(callback: Function) {
|
|
remoteCallback(this.onPlayCallbacks, callback);
|
|
}
|
|
pause() {
|
|
callCallbacks(this.onPauseCallbacks);
|
|
}
|
|
onPause(callback: Function) {
|
|
this.onPauseCallbacks.push(callback);
|
|
}
|
|
offPause(callback: Function) {
|
|
remoteCallback(this.onPauseCallbacks, callback);
|
|
}
|
|
stop() {
|
|
callCallbacks(this.onStopCallbacks);
|
|
}
|
|
onStop(callback: Function) {
|
|
this.onStopCallbacks.push(callback);
|
|
}
|
|
offStop(callback: Function) {
|
|
remoteCallback(this.onStopCallbacks, callback);
|
|
}
|
|
ended() {
|
|
callCallbacks(this.onEndedCallbacks);
|
|
}
|
|
onEnded(callback: Function) {
|
|
this.onEndedCallbacks.push(callback);
|
|
}
|
|
offEnded(callback: Function) {
|
|
remoteCallback(this.onEndedCallbacks, callback);
|
|
}
|
|
timeUpdate(time: number) {
|
|
callCallbacks(this.onTimeUpdateCallbacks, time);
|
|
}
|
|
onTimeUpdate(callback: Function) {
|
|
this.onTimeUpdateCallbacks.push(callback);
|
|
}
|
|
offTimeUpdate(callback: Function) {
|
|
remoteCallback(this.onTimeUpdateCallbacks, callback);
|
|
}
|
|
error(res: AudioPlayerError) {
|
|
callCallbacks(this.onErrorCallbacks, res);
|
|
}
|
|
onError(callback: Function) {
|
|
this.onErrorCallbacks.push(callback);
|
|
}
|
|
offError(callback: Function) {
|
|
remoteCallback(this.onErrorCallbacks, callback);
|
|
}
|
|
onPrev(callback: Function) {
|
|
console.info('ios only');
|
|
}
|
|
onNext(callback: Function) {
|
|
console.info('ios only');
|
|
}
|
|
waiting() {
|
|
callCallbacks(this.onWaitingCallbacks);
|
|
}
|
|
onWaiting(callback: Function) {
|
|
this.onWaitingCallbacks.push(callback);
|
|
}
|
|
offWaiting(callback: Function) {
|
|
remoteCallback(this.onWaitingCallbacks, callback);
|
|
}
|
|
seeking() {
|
|
callCallbacks(this.onSeekingCallbacks);
|
|
}
|
|
onSeeking(callback: Function) {
|
|
this.onSeekingCallbacks.push(callback);
|
|
}
|
|
offSeeking(callback: Function) {
|
|
remoteCallback(this.onSeekingCallbacks, callback);
|
|
}
|
|
seeked() {
|
|
callCallbacks(this.onSeekedCallbacks);
|
|
}
|
|
onSeeked(callback: Function) {
|
|
this.onSeekedCallbacks.push(callback);
|
|
}
|
|
offSeeked(callback: Function) {
|
|
remoteCallback(this.onSeekedCallbacks, callback);
|
|
}
|
|
}
|
|
const AUDIOS: Record<string, InnerAudioContext | undefined> = {};
|
|
const AUDIO_PLAYERS: Record<string, media1.AudioPlayer | undefined> = {};
|
|
const LOG = (msg: string)=>console.log(`[createInnerAudioContext]: ${msg}`);
|
|
class STATE_TYPE {
|
|
static IDLE: string = 'idle';
|
|
static PLAYING: string = 'playing';
|
|
static PAUSED: string = 'paused';
|
|
static STOPPED: string = 'stopped';
|
|
static ERROR: string = 'error';
|
|
}
|
|
class AudioPlayer implements InnerAudioContext {
|
|
__v_skip: boolean = true;
|
|
private audioPlayerCallback: AudioPlayerCallback = new AudioPlayerCallback();
|
|
private _volume: number = 1;
|
|
private _src: string = '';
|
|
private _autoplay: boolean = false;
|
|
private _startTime: number = 0;
|
|
private _buffered: number = 0;
|
|
private _title: string = '';
|
|
private audioId: string = '';
|
|
private _playbackRate: number = 1;
|
|
readonly obeyMuteSwitch: boolean = false;
|
|
constructor(audioId: string){
|
|
this.audioId = audioId;
|
|
this.init();
|
|
}
|
|
init() {
|
|
AUDIO_PLAYERS[this.audioId]?.on('dataLoad', ()=>{
|
|
this.audioPlayerCallback.canPlay();
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('play', ()=>{
|
|
this.audioPlayerCallback.play();
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('pause', ()=>{
|
|
this.audioPlayerCallback.pause();
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('finish', ()=>{
|
|
this.audioPlayerCallback.ended();
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('timeUpdate', (res)=>{
|
|
this.audioPlayerCallback.timeUpdate(res / 1000);
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('error', (err)=>{
|
|
this.audioPlayerCallback.error(new AudioPlayerError(err.message, err.code));
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('bufferingUpdate', (infoType, value)=>{
|
|
console.info(`[AdvancedAPI] audioPlayer bufferingUpdate ${infoType} ${value}`);
|
|
if (infoType === media1.BufferingInfoType.BUFFERING_PERCENT && value !== 0 && AUDIO_PLAYERS[this.audioId]) {
|
|
this._buffered = value;
|
|
if ((AUDIO_PLAYERS[this.audioId]!.currentTime / 1000) >= (AUDIO_PLAYERS[this.audioId]!.duration * value / 100000)) {
|
|
this.audioPlayerCallback.waiting();
|
|
}
|
|
}
|
|
});
|
|
AUDIO_PLAYERS[this.audioId]?.on('audioInterrupt', (InterruptEvent)=>{
|
|
console.info('[AdvancedAPI] audioInterrupt:' + JSON.stringify(InterruptEvent));
|
|
if (AUDIO_PLAYERS[this.audioId] && InterruptEvent.hintType === audio.InterruptHint.INTERRUPT_HINT_PAUSE) {
|
|
AUDIO_PLAYERS[this.audioId]!.pause();
|
|
}
|
|
});
|
|
}
|
|
get duration() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return 0;
|
|
}
|
|
return audioPlayer.duration / 1000;
|
|
}
|
|
get currentTime() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return 0;
|
|
}
|
|
return audioPlayer.currentTime / 1000;
|
|
}
|
|
get paused() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return false;
|
|
}
|
|
return audioPlayer.state === STATE_TYPE.PAUSED;
|
|
}
|
|
get loop() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return false;
|
|
}
|
|
return audioPlayer.loop;
|
|
}
|
|
set loop(value) {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (audioPlayer) {
|
|
audioPlayer.loop = value;
|
|
}
|
|
}
|
|
get volume() {
|
|
return this._volume;
|
|
}
|
|
set volume(value) {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (audioPlayer) {
|
|
this._volume = value;
|
|
audioPlayer.setVolume(value);
|
|
}
|
|
}
|
|
get src() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return '';
|
|
}
|
|
return audioPlayer.src;
|
|
}
|
|
set src(value) {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (typeof value !== 'string') {
|
|
this.audioPlayerCallback.error(new AudioPlayerError(`set src: ${value} is not string`, 10004));
|
|
return;
|
|
}
|
|
if (!audioPlayer) {
|
|
this.audioPlayerCallback.error(new AudioPlayerError(`player is not exist`, 10001));
|
|
return;
|
|
}
|
|
if (!value || !(value.startsWith('http:') || value.startsWith('https:') || isFileUri(value) || isSandboxPath(value))) {
|
|
LOG(`set src: ${value} is invalid`);
|
|
return;
|
|
}
|
|
let path: string = '';
|
|
if (value.startsWith('http:') || value.startsWith('https:')) {
|
|
path = value;
|
|
} else if (isFileUri(value) || isSandboxPath(value)) {
|
|
try {
|
|
const fd = getFdFromUriOrSandBoxPath(value);
|
|
path = `fd://${fd}`;
|
|
} catch (error) {
|
|
console.error(`${JSON.stringify(error)}`);
|
|
}
|
|
}
|
|
if (audioPlayer.src && path !== audioPlayer.src) {
|
|
audioPlayer.reset();
|
|
}
|
|
AUDIO_PLAYERS[this.audioId]!.src = path;
|
|
this._src = value;
|
|
if (this._autoplay) {
|
|
audioPlayer.play();
|
|
if (this._startTime) {
|
|
audioPlayer.seek(this._startTime);
|
|
}
|
|
}
|
|
}
|
|
get startTime() {
|
|
return this._startTime / 1000;
|
|
}
|
|
set startTime(time: number) {
|
|
this._startTime = time * 1000;
|
|
}
|
|
get autoplay() {
|
|
return this._autoplay;
|
|
}
|
|
set autoplay(flag) {
|
|
this._autoplay = flag;
|
|
}
|
|
get buffered() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) return 0;
|
|
return audioPlayer.duration * this._buffered / 100000;
|
|
}
|
|
set playbackRate(rate: number) {
|
|
this.audioPlayerCallback.error(new AudioPlayerError('HarmonyOS Next Audio setting playbackRate is not supported.', -1));
|
|
}
|
|
get playbackRate() {
|
|
return this._playbackRate;
|
|
}
|
|
play() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return;
|
|
}
|
|
const state = audioPlayer.state ?? '';
|
|
if (![
|
|
STATE_TYPE.PAUSED,
|
|
STATE_TYPE.STOPPED,
|
|
STATE_TYPE.IDLE
|
|
].includes(state)) {
|
|
return;
|
|
}
|
|
if (this._src && audioPlayer.src === '') {
|
|
this.src = this._src;
|
|
}
|
|
audioPlayer.play();
|
|
}
|
|
pause() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return;
|
|
}
|
|
const state = audioPlayer.state;
|
|
if (STATE_TYPE.PLAYING !== state) {
|
|
return;
|
|
}
|
|
audioPlayer.pause();
|
|
}
|
|
stop() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return;
|
|
}
|
|
if (![
|
|
STATE_TYPE.PAUSED,
|
|
STATE_TYPE.PLAYING
|
|
].includes(audioPlayer.state)) {
|
|
return;
|
|
}
|
|
audioPlayer.stop();
|
|
this.audioPlayerCallback.stop();
|
|
audioPlayer.release();
|
|
}
|
|
seek(position: number) {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return;
|
|
}
|
|
const state = audioPlayer.state;
|
|
if (![
|
|
STATE_TYPE.PAUSED,
|
|
STATE_TYPE.PLAYING
|
|
].includes(state)) {
|
|
return;
|
|
}
|
|
this.audioPlayerCallback.seeking();
|
|
audioPlayer.seek(position * 1000);
|
|
this.audioPlayerCallback.seeked();
|
|
}
|
|
destroy() {
|
|
const audioPlayer = AUDIO_PLAYERS[this.audioId];
|
|
if (!audioPlayer) {
|
|
return;
|
|
}
|
|
audioPlayer.release();
|
|
AUDIO_PLAYERS[this.audioId] = undefined;
|
|
AUDIOS[this.audioId] = undefined;
|
|
}
|
|
onCanplay(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onCanplay(callback);
|
|
}
|
|
onPlay(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onPlay(callback);
|
|
}
|
|
onPause(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onPause(callback);
|
|
}
|
|
onStop(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onStop(callback);
|
|
}
|
|
onEnded(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onEnded(callback);
|
|
}
|
|
onTimeUpdate(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onTimeUpdate(callback);
|
|
}
|
|
onError(callback: (result: ICreateInnerAudioContextFail) => void): void {
|
|
this.audioPlayerCallback.onError(callback);
|
|
}
|
|
onWaiting(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onWaiting(callback);
|
|
}
|
|
onSeeking(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onSeeking(callback);
|
|
}
|
|
onSeeked(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.onSeeked(callback);
|
|
}
|
|
offCanplay(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offCanplay(callback);
|
|
}
|
|
offPlay(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offPlay(callback);
|
|
}
|
|
offPause(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offPause(callback);
|
|
}
|
|
offStop(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offStop(callback);
|
|
}
|
|
offEnded(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offEnded(callback);
|
|
}
|
|
offTimeUpdate(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offTimeUpdate(callback);
|
|
}
|
|
offError(callback: (result: ICreateInnerAudioContextFail) => void): void {
|
|
this.audioPlayerCallback.offError(callback);
|
|
}
|
|
offWaiting(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offWaiting(callback);
|
|
}
|
|
offSeeking(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offSeeking(callback);
|
|
}
|
|
offSeeked(callback: (result: Object) => void): void {
|
|
this.audioPlayerCallback.offSeeked(callback);
|
|
}
|
|
}
|
|
const createAudioInstance = ()=>{
|
|
const audioId = `${Date.now()}${Math.random()}`;
|
|
AUDIO_PLAYERS[audioId] = media1.createAudioPlayer();
|
|
AUDIOS[audioId] = new AudioPlayer(audioId);
|
|
return audioId;
|
|
};
|
|
const createInnerAudioContext: CreateInnerAudioContext = defineSyncApi<InnerAudioContext>(API_CREATE_INNER_AUDIO_CONTEXT, ()=>{
|
|
const audioId = createAudioInstance();
|
|
return AUDIOS[audioId];
|
|
}) as CreateInnerAudioContext;
|
|
const API_$_ON = '$on';
|
|
const API_$_ONCE = '$once';
|
|
const API_$_OFF = '$off';
|
|
const API_$_EMIT = '$emit';
|
|
const emitterStore = new Map<string, IUniEventEmitter>();
|
|
const getEmitter = (): IUniEventEmitter =>{
|
|
const mp = getCurrentMP();
|
|
const id = mp.id as string;
|
|
if (emitterStore.has(id)) {
|
|
return emitterStore.get(id) as IUniEventEmitter;
|
|
}
|
|
const emitter = new Emitter() as IUniEventEmitter;
|
|
emitterStore.set(id, emitter);
|
|
mp.on('beforeClose', ()=>{
|
|
emitterStore.delete(id);
|
|
});
|
|
return emitter;
|
|
};
|
|
const $on: $On = defineSyncApi<number>(API_$_ON, (eventName: string, callback: Function)=>{
|
|
return getEmitter().on(eventName, callback);
|
|
}) as $On;
|
|
const $once: $Once = defineSyncApi<number>(API_$_ONCE, (eventName: string, callback: Function)=>{
|
|
return getEmitter().once(eventName, callback);
|
|
}) as $Once;
|
|
const $off: $Off = defineSyncApi<void>(API_$_OFF, (eventName: string, callback: Function)=>{
|
|
getEmitter().off(eventName, callback);
|
|
}) as $Off;
|
|
const $emit: $Emit = defineSyncApi<void>(API_$_EMIT, (eventName: string, ...args: (Object | undefined | null)[])=>{
|
|
getEmitter().emit(eventName, ...args);
|
|
}) as $Emit;
|
|
const API_EXIT = 'exit';
|
|
const exit: Exit = defineSyncApi<void>(API_EXIT, ()=>{
|
|
UTSHarmony.exit();
|
|
}) as Exit;
|
|
const API_SAVE_FILE = 'saveFile';
|
|
const API_GET_FILE_INFO = 'getFileInfo';
|
|
const API_GET_SAVED_FILE_INFO = 'getSavedFileInfo';
|
|
const API_GET_SAVED_FILE_LIST = 'getSavedFileList';
|
|
const API_REMOVE_SAVED_FILE = 'removeSavedFile';
|
|
const getSavedDir = ()=>{
|
|
return getEnv().USER_DATA_PATH + '/saved';
|
|
};
|
|
let savedIndex: [string, number] = [
|
|
'0',
|
|
0
|
|
];
|
|
const getSavedFileName = (filePath: string)=>{
|
|
const ext = filePath.split('/').pop()?.split('.').slice(1).join('.');
|
|
let fileName = Date.now() + '';
|
|
if (savedIndex[0] === fileName) {
|
|
savedIndex[1]++;
|
|
if (savedIndex[1] > 0) {
|
|
fileName += '-' + savedIndex[1];
|
|
}
|
|
} else {
|
|
savedIndex[0] = fileName;
|
|
savedIndex[1] = 0;
|
|
}
|
|
if (ext) {
|
|
fileName += '.' + ext;
|
|
}
|
|
return fileName;
|
|
};
|
|
const getFsPath = (filePath: string)=>{
|
|
filePath = getRealPath(filePath) as string;
|
|
if (!/^file:/.test(filePath)) {
|
|
return filePath;
|
|
}
|
|
const rawPath = filePath.replace(/^file:\/\//, '');
|
|
if (rawPath[0] === '/') {
|
|
return rawPath;
|
|
}
|
|
return filePath;
|
|
};
|
|
const saveFile: SaveFile = defineAsyncApi<LegacySaveFileOptions, LegacySaveFileSuccess>(API_SAVE_FILE, (options: LegacySaveFileOptions, exec: ApiExecutor<LegacySaveFileSuccess>)=>{
|
|
const tempFilePath = getRealPath(options.tempFilePath) as string;
|
|
const savedPath = getSavedDir();
|
|
if (!fs1.accessSync(savedPath)) {
|
|
fs1.mkdirSync(savedPath, true);
|
|
}
|
|
let srcFile: fs1.File;
|
|
try {
|
|
srcFile = fs1.openSync(tempFilePath, fs1.OpenMode.READ_ONLY);
|
|
} catch (error) {
|
|
exec.reject((error as Error).message);
|
|
return;
|
|
}
|
|
const savedFilePath = savedPath + '/' + getSavedFileName(tempFilePath);
|
|
fs1.copyFile(srcFile.fd, savedFilePath, (err)=>{
|
|
fs1.closeSync(srcFile);
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
exec.resolve({
|
|
savedFilePath
|
|
} as LegacySaveFileSuccess);
|
|
}
|
|
});
|
|
}) as SaveFile;
|
|
const getSavedFileList: GetSavedFileList = defineAsyncApi<LegacyGetSavedFileListOptions, LegacyGetSavedFileListSuccess>(API_GET_SAVED_FILE_LIST, (options: LegacyGetSavedFileListOptions, exec: ApiExecutor<LegacyGetSavedFileListSuccess>)=>{
|
|
const savedPath = getSavedDir();
|
|
if (!fs1.accessSync(savedPath)) {
|
|
exec.resolve({
|
|
fileList: []
|
|
} as LegacyGetSavedFileListSuccess);
|
|
}
|
|
fs1.listFile(savedPath, {} as ListFileOptions, (err, fileList)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
exec.resolve({
|
|
fileList: fileList.map((filePath: string)=>{
|
|
const fullPath = savedPath + '/' + filePath;
|
|
const stat = fs1.statSync(fullPath);
|
|
if (!stat.isFile()) {
|
|
return null;
|
|
}
|
|
return {
|
|
filePath: fullPath,
|
|
size: stat.size,
|
|
createTime: stat.ctime
|
|
} as LegacySavedFileListItem;
|
|
}).filter((item)=>!!item)
|
|
} as LegacyGetSavedFileListSuccess);
|
|
}
|
|
});
|
|
}) as GetSavedFileList;
|
|
const getSavedFileInfo: GetSavedFileInfo = defineAsyncApi<LegacyGetSavedFileInfoOptions, LegacyGetSavedFileInfoSuccess>(API_GET_SAVED_FILE_INFO, (options: LegacyGetSavedFileInfoOptions, exec: ApiExecutor<LegacyGetSavedFileInfoSuccess>)=>{
|
|
const savedFilePath = getFsPath(options.filePath);
|
|
if (!fs1.accessSync(savedFilePath)) {
|
|
exec.reject('file not exist');
|
|
return;
|
|
}
|
|
const stat = fs1.statSync(savedFilePath);
|
|
if (!stat.isFile()) {
|
|
exec.reject('file not exist');
|
|
}
|
|
exec.resolve({
|
|
size: stat.size,
|
|
createTime: stat.ctime
|
|
} as LegacyGetSavedFileInfoSuccess);
|
|
}) as GetSavedFileInfo;
|
|
const removeSavedFile: RemoveSavedFile = defineAsyncApi<LegacyRemoveSavedFileOptions, LegacyRemoveSavedFileSuccess>(API_REMOVE_SAVED_FILE, (options: LegacyRemoveSavedFileOptions, exec: ApiExecutor<LegacyRemoveSavedFileSuccess>)=>{
|
|
const savedFilePath = getFsPath(options.filePath);
|
|
if (!fs1.accessSync(savedFilePath)) {
|
|
exec.reject('file not exist');
|
|
return;
|
|
}
|
|
fs1.unlink(savedFilePath, (err)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
exec.resolve();
|
|
}
|
|
});
|
|
}) as RemoveSavedFile;
|
|
const SupportedHashAlgorithm = [
|
|
'md5',
|
|
'sha1'
|
|
];
|
|
const getFileInfo: GetFileInfo = defineAsyncApi<LegacyGetFileInfoOptions, LegacyGetFileInfoSuccess>(API_GET_FILE_INFO, (options: LegacyGetFileInfoOptions, exec: ApiExecutor<LegacyGetFileInfoSuccess>)=>{
|
|
const filePath = getFsPath(options.filePath);
|
|
const digestAlgorithm = options.digestAlgorithm && SupportedHashAlgorithm.includes(options.digestAlgorithm) ? options.digestAlgorithm : 'md5';
|
|
if (!fs1.accessSync(filePath)) {
|
|
exec.reject('file not exist');
|
|
return;
|
|
}
|
|
const stat = fs1.statSync(filePath);
|
|
if (!stat.isFile()) {
|
|
exec.reject('file not exist');
|
|
}
|
|
Hash.hash(filePath, digestAlgorithm, (err, hash)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
exec.resolve({
|
|
size: stat.size,
|
|
digest: hash
|
|
} as LegacyGetFileInfoSuccess);
|
|
}
|
|
});
|
|
}) as GetFileInfo;
|
|
const GET_FILE_SYSTEM_MANAGER = 'getFileSystemManager';
|
|
class FileCallback {
|
|
successFn?: Function;
|
|
failFn?: Function;
|
|
completeFn?: Function;
|
|
constructor(callback: CallBack = {}){
|
|
if (typeof callback.success === 'function') this.successFn = callback.success;
|
|
if (typeof callback.fail === 'function') this.failFn = callback.fail;
|
|
if (typeof callback.complete === 'function') this.completeFn = callback.complete;
|
|
}
|
|
success(...args: Object[]) {
|
|
if (this.successFn) {
|
|
try {
|
|
this.successFn(...args);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
}
|
|
if (this.completeFn) {
|
|
try {
|
|
this.completeFn(...args);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
}
|
|
}
|
|
fail(...args: Object[]) {
|
|
if (this.failFn) {
|
|
try {
|
|
this.failFn(...args);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
}
|
|
if (this.completeFn) {
|
|
try {
|
|
this.completeFn(...args);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const FileSystemManagerUniErrorSubject = 'uni-fileSystemManager';
|
|
const FileSystemManagerUniErrors: Map<FileSystemManagerErrorCode, string> = new Map([
|
|
[
|
|
1200002,
|
|
'Type error. only support base64 / utf-8'
|
|
],
|
|
[
|
|
1300002,
|
|
'No such file or directory'
|
|
],
|
|
[
|
|
1300013,
|
|
'Permission denied'
|
|
],
|
|
[
|
|
1300021,
|
|
'Is a directory'
|
|
],
|
|
[
|
|
1300022,
|
|
'Invalid argument'
|
|
],
|
|
[
|
|
1300066,
|
|
'Directory not empty'
|
|
],
|
|
[
|
|
1301003,
|
|
'Illegal operation on a directory'
|
|
],
|
|
[
|
|
1301005,
|
|
'File already exists'
|
|
],
|
|
[
|
|
1300201,
|
|
'System error'
|
|
],
|
|
[
|
|
1300202,
|
|
'The maximum size of the file storage limit is exceeded'
|
|
],
|
|
[
|
|
1301111,
|
|
'Brotli decompress fail'
|
|
],
|
|
[
|
|
1302003,
|
|
'Invalid flag'
|
|
],
|
|
[
|
|
1300009,
|
|
'Bad file descriptor'
|
|
],
|
|
[
|
|
1300010,
|
|
'Try again'
|
|
],
|
|
[
|
|
1300011,
|
|
'Bad address'
|
|
],
|
|
[
|
|
1300012,
|
|
'Operation would block'
|
|
],
|
|
[
|
|
1300014,
|
|
'Network is unreachable'
|
|
],
|
|
[
|
|
1300015,
|
|
'Unknown error'
|
|
],
|
|
[
|
|
1300016,
|
|
'Not a directory'
|
|
],
|
|
[
|
|
1300017,
|
|
'Text file busy'
|
|
],
|
|
[
|
|
1300018,
|
|
'File too large'
|
|
],
|
|
[
|
|
1300019,
|
|
'Read-only file system'
|
|
],
|
|
[
|
|
1300020,
|
|
'File name too long'
|
|
]
|
|
]);
|
|
class FileSystemManagerFailImpl extends UniError implements IFileSystemManagerFail {
|
|
errCode: FileSystemManagerErrorCode;
|
|
constructor(errCode: FileSystemManagerErrorCode){
|
|
super();
|
|
this.errSubject = FileSystemManagerUniErrorSubject;
|
|
this.errCode = errCode;
|
|
this.errMsg = FileSystemManagerUniErrors.get(errCode) ?? "";
|
|
}
|
|
}
|
|
let type = new util.types();
|
|
const modeReflect: ModeReflect = {
|
|
'ax': 'a',
|
|
'ax+': 'a+',
|
|
'wx': 'w',
|
|
'wx+': 'w+'
|
|
};
|
|
const ENCODING = [
|
|
'utf8',
|
|
'utf-8',
|
|
'ascii',
|
|
'base64',
|
|
'binary',
|
|
'hex',
|
|
'ucs2',
|
|
'ucs-2',
|
|
'utf16le',
|
|
'utf-16le',
|
|
'latin1'
|
|
];
|
|
const getFileTypeMode = (stat: fs2.Stat): number =>{
|
|
if (stat.isBlockDevice()) {
|
|
return 0o060000;
|
|
}
|
|
if (stat.isCharacterDevice()) {
|
|
return 0o020000;
|
|
}
|
|
if (stat.isDirectory()) {
|
|
return 0o040000;
|
|
}
|
|
if (stat.isFIFO()) {
|
|
return 0o010000;
|
|
}
|
|
if (stat.isFile()) {
|
|
return 0o100000;
|
|
}
|
|
if (stat.isSocket()) {
|
|
return 0o140000;
|
|
}
|
|
if (stat.isSymbolicLink()) {
|
|
return 0o120000;
|
|
}
|
|
return 0;
|
|
};
|
|
const getOpenMode = (flag: string): number | null =>{
|
|
switch(flag){
|
|
case 'a':
|
|
return fs2.OpenMode.CREATE | fs2.OpenMode.APPEND;
|
|
case 'a+':
|
|
return fs2.OpenMode.CREATE | fs2.OpenMode.READ_WRITE | fs2.OpenMode.APPEND;
|
|
case 'as':
|
|
return fs2.OpenMode.SYNC | fs2.OpenMode.CREATE | fs2.OpenMode.APPEND;
|
|
case 'as+':
|
|
return fs2.OpenMode.SYNC | fs2.OpenMode.CREATE | fs2.OpenMode.READ_WRITE | fs2.OpenMode.APPEND;
|
|
case 'r':
|
|
return fs2.OpenMode.READ_ONLY;
|
|
case 'r+':
|
|
return fs2.OpenMode.READ_WRITE;
|
|
case 'w':
|
|
return fs2.OpenMode.CREATE | fs2.OpenMode.WRITE_ONLY | fs2.OpenMode.TRUNC;
|
|
case 'w+':
|
|
return fs2.OpenMode.CREATE | fs2.OpenMode.READ_WRITE | fs2.OpenMode.TRUNC;
|
|
}
|
|
return null;
|
|
};
|
|
const transformErrorCode = (errCode: number): FileSystemManagerErrorCode =>{
|
|
switch(errCode){
|
|
case 13900012:
|
|
case 13900001:
|
|
return 1300013;
|
|
case 13900002:
|
|
return 1300002;
|
|
case 13900004:
|
|
return 1300201;
|
|
case 13900005:
|
|
return 1301003;
|
|
case 13900008:
|
|
return 1300009;
|
|
case 13900010:
|
|
return 1300010;
|
|
case 13900013:
|
|
return 1300011;
|
|
case 13900018:
|
|
return 1300016;
|
|
case 13900019:
|
|
return 1300021;
|
|
case 13900020:
|
|
return 1300022;
|
|
case 13900023:
|
|
return 1300017;
|
|
case 13900024:
|
|
return 1300018;
|
|
case 13900027:
|
|
return 1300019;
|
|
case 13900030:
|
|
return 1300020;
|
|
case 13900033:
|
|
return 1300021;
|
|
case 13900034:
|
|
return 1300012;
|
|
case 13900042:
|
|
return 1300013;
|
|
case 13900044:
|
|
return 1300014;
|
|
}
|
|
return 1300201;
|
|
};
|
|
const isString = (data: DataType | null = null): boolean =>{
|
|
return typeof data === 'string';
|
|
};
|
|
const isFunction = (data: DataType | null = null): boolean =>{
|
|
return typeof data === 'function';
|
|
};
|
|
const isNull = (data: DataType | null = null): boolean =>{
|
|
return data === null;
|
|
};
|
|
const isUndefined = (data: DataType | null = null): boolean =>{
|
|
return typeof data === 'undefined';
|
|
};
|
|
const isArray = (data: DataType | null = null): boolean =>{
|
|
return Array.isArray(data);
|
|
};
|
|
const isNumber = (data: DataType | null = null): boolean =>{
|
|
return typeof data === 'number' && !Number.isNaN(data) && Number.isFinite(data);
|
|
};
|
|
const isBoolean = (data: DataType | null = null): boolean =>{
|
|
return typeof data === 'boolean';
|
|
};
|
|
const isArrayBuffer = (data: DataType | null = null): boolean =>{
|
|
return type.isAnyArrayBuffer(data as object);
|
|
};
|
|
const checkSingleDataType = (data: DataType, dataType: string)=>{
|
|
let result = false;
|
|
switch(dataType){
|
|
case 'string':
|
|
result = isString(data);
|
|
break;
|
|
case 'number':
|
|
result = isNumber(data);
|
|
break;
|
|
case 'boolean':
|
|
result = isBoolean(data);
|
|
break;
|
|
case 'function':
|
|
result = isFunction(data);
|
|
break;
|
|
case 'arraybuffer':
|
|
result = isArrayBuffer(data);
|
|
break;
|
|
case 'array':
|
|
result = isArray(data);
|
|
break;
|
|
case 'null':
|
|
result = isNull(data);
|
|
break;
|
|
case 'undefined':
|
|
result = isUndefined(data);
|
|
break;
|
|
}
|
|
return result;
|
|
};
|
|
const checkDataType = (data: DataType, isRequired: boolean, dataType: string, customCheck: ((data: DataType) => boolean) | null = null): boolean =>{
|
|
let result = false;
|
|
try {
|
|
if (isRequired && (isNull(data) || isUndefined(data))) {
|
|
throw new Error('The param data is required');
|
|
}
|
|
if (!isString(dataType) && !isArray(dataType)) {
|
|
throw new Error('The param dataType should be a String or an Array');
|
|
}
|
|
if (customCheck != null && typeof customCheck !== 'function') {
|
|
throw new Error('If customCheck exist,it should be a Function');
|
|
}
|
|
if (!isRequired && (isNull(data) || isUndefined(data))) {
|
|
return true;
|
|
}
|
|
result = checkSingleDataType(data as DataType, dataType);
|
|
if (result && typeof customCheck === 'function') {
|
|
result = customCheck!(data);
|
|
}
|
|
} catch (error) {
|
|
console.log(error);
|
|
return false;
|
|
}
|
|
return result;
|
|
};
|
|
const checkPathExistence = (methodName: string, pathName: string, path: string): CustomValidReturn | CustomValidReturnValid =>{
|
|
const errMsg = `${methodName}: fail ${pathName}`;
|
|
let isValid = false;
|
|
if (!checkDataType(path, true, 'string')) {
|
|
return {
|
|
isValid,
|
|
err: getParameterError(errMsg)
|
|
} as CustomValidReturn;
|
|
}
|
|
if (path === '') {
|
|
return {
|
|
isValid,
|
|
err: getPermissionError(errMsg) as IFileSystemManagerFail
|
|
} as CustomValidReturn;
|
|
}
|
|
if (!fs2.accessSync(path)) {
|
|
return {
|
|
isValid,
|
|
err: getNoSuchFileOrDirectoryError(errMsg) as IFileSystemManagerFail
|
|
} as CustomValidReturn;
|
|
}
|
|
return {
|
|
isValid: true
|
|
} as CustomValidReturnValid;
|
|
};
|
|
const ohosRead = (filePath: string, sizeOfNewArrayBuffer: number, cb: FileCallback)=>{
|
|
const file = fs2.openSync(filePath, fs2.OpenMode.READ_ONLY);
|
|
const buf = new ArrayBuffer(sizeOfNewArrayBuffer);
|
|
fs2.read(file.fd, buf).then((readLen)=>{
|
|
cb.success({
|
|
data: buf
|
|
} as ReadFileSuccessResult);
|
|
}).catch((err: BusinessError4)=>{
|
|
cb.fail(new FileSystemManagerFailImpl(transformErrorCode(err.code)) as ApiError);
|
|
}).finally(()=>{
|
|
fs2.closeSync(file);
|
|
});
|
|
};
|
|
const ohosReadText = (filePath: string, option: ReadTextOptions, cb: FileCallback)=>{
|
|
fs2.readText(filePath, option).then((str)=>{
|
|
cb.success({
|
|
data: str
|
|
} as ReadFileSuccessResult);
|
|
}).catch((err: BusinessError4)=>{
|
|
cb.fail(new FileSystemManagerFailImpl(transformErrorCode(err.code)) as ApiError);
|
|
});
|
|
};
|
|
const obtainUpperPath = (inputPath: string): ObtainUpperPathReturn =>{
|
|
let index = inputPath.lastIndexOf('/');
|
|
let upperPath = inputPath.substring(0, index);
|
|
return {
|
|
index,
|
|
upperPath
|
|
} as ObtainUpperPathReturn;
|
|
};
|
|
const obtainFileName = (inputPath: string): ObtainFileNameReturn =>{
|
|
let index = inputPath.lastIndexOf('/');
|
|
let fileName = inputPath.substring(index);
|
|
if (inputPath.endsWith('/')) {
|
|
fileName = inputPath.substring(inputPath.lastIndexOf("/", inputPath.length - 2) + 1, inputPath.length - 1);
|
|
}
|
|
return {
|
|
index,
|
|
fileName
|
|
} as ObtainFileNameReturn;
|
|
};
|
|
const checkFd = (methodName: string, fd: string): CheckFd | CheckFdErr =>{
|
|
const errMsg = `${methodName}: fail`;
|
|
if (!checkDataType(fd, true, 'string')) {
|
|
return {
|
|
isValid: false,
|
|
fd: 0,
|
|
err: getParameterError(errMsg)
|
|
};
|
|
}
|
|
const transFdToNum = Number(fd);
|
|
if (isNaN(transFdToNum)) {
|
|
return {
|
|
isValid: false,
|
|
fd: 0,
|
|
err: getParameterError(errMsg)
|
|
};
|
|
}
|
|
return {
|
|
isValid: true,
|
|
fd: transFdToNum
|
|
};
|
|
};
|
|
const checkPath = (methodName: string, pathName: string, path: string): CustomValidReturn | CustomValidReturnValid =>{
|
|
const errMsg = `${methodName}: fail ${pathName}`;
|
|
let isValid = false;
|
|
if (!checkDataType(path, true, 'string')) {
|
|
return {
|
|
isValid,
|
|
err: getParameterError(errMsg)
|
|
};
|
|
}
|
|
if (path === '') {
|
|
return {
|
|
isValid,
|
|
err: getPermissionError(errMsg)
|
|
};
|
|
}
|
|
return {
|
|
isValid: true
|
|
};
|
|
};
|
|
const checkPathSync = (methodName: string, pathName: string, path: string): CustomValidReturn | CustomValidReturnValid =>{
|
|
const errMsg = `${methodName}: fail ${pathName}`;
|
|
let isValid = false;
|
|
if (path === '' || !checkDataType(path, true, 'string')) {
|
|
return {
|
|
isValid,
|
|
err: getParameterError(errMsg)
|
|
};
|
|
}
|
|
return {
|
|
isValid: true
|
|
};
|
|
};
|
|
const checkPathExistenceSync = (methodName: string, pathName: string, path: string): CustomValidReturn | CustomValidReturnValid =>{
|
|
const errMsg = `${methodName}: fail ${pathName}`;
|
|
let isValid = false;
|
|
if (path === '' || !checkDataType(path, true, 'string')) {
|
|
return {
|
|
isValid,
|
|
err: getParameterError(errMsg)
|
|
};
|
|
}
|
|
if (!fs2.accessSync(path)) {
|
|
return {
|
|
isValid,
|
|
err: getNoSuchFileOrDirectoryError(errMsg)
|
|
};
|
|
}
|
|
return {
|
|
isValid: true
|
|
};
|
|
};
|
|
const checkEncoding = (methodName: string, encoding: string | null = null): CheckEncodingReturn =>{
|
|
let isValid = false;
|
|
if (encoding === null || !checkDataType(encoding, false, 'string')) {
|
|
return {
|
|
errMsg: `${methodName}: fail invalid encoding: ${encoding}`,
|
|
isValid
|
|
} as CheckEncodingReturn;
|
|
}
|
|
if (encoding !== '' && encoding !== undefined) {
|
|
if (!ENCODING.includes(encoding)) {
|
|
return {
|
|
errMsg: `${methodName}: fail Unknown encoding: ${encoding}`,
|
|
isValid
|
|
} as CheckEncodingReturn;
|
|
}
|
|
if (encoding !== 'utf-8' && encoding !== 'utf8') {
|
|
return {
|
|
errMsg: `${methodName}: fail, The encoding is valid, but is not supported currently: ${encoding}`,
|
|
isValid
|
|
} as CheckEncodingReturn;
|
|
}
|
|
}
|
|
return {
|
|
isValid: true,
|
|
errMsg: ''
|
|
};
|
|
};
|
|
const isFileUri1 = (path: string)=>{
|
|
return path && typeof path === 'string' && (path.startsWith('file://') || path.startsWith('datashare://'));
|
|
};
|
|
class SecurityBase {
|
|
static rsa(algName: string, blob: cryptoFramework.DataBlob): Promise<Uint8Array> {
|
|
return new Promise<Uint8Array>(async (resolve, reject)=>{
|
|
let md: cryptoFramework.Md;
|
|
try {
|
|
md = cryptoFramework.createMd(algName);
|
|
await md.update(blob);
|
|
const mdOutput = await md.digest();
|
|
resolve(mdOutput.data);
|
|
} catch (error) {
|
|
console.error(`rsa fail error code: ${(error as BusinessError4).code}, message is: ${(error as BusinessError4).message}`);
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
const getApiError = (errCode: number, errMsg: string | null = null): FileSystemManagerApiError =>{
|
|
return wrapErrMsg(new FileSystemManagerFailImpl(transformErrorCode(errCode)), errMsg) as FileSystemManagerApiError;
|
|
};
|
|
const wrapErrMsg = (err: IFileSystemManagerFail, errMsg: string | null = null): IFileSystemManagerFail =>{
|
|
if (errMsg) {
|
|
err.errMsg = `${errMsg} ${err.errMsg}`;
|
|
}
|
|
return err;
|
|
};
|
|
const getParameterError = (errMsg: string | null = null): IFileSystemManagerFail =>{
|
|
return getApiError(1300022, errMsg) as IFileSystemManagerFail;
|
|
};
|
|
const getPermissionError = (errMsg: string | null = null): IFileSystemManagerFail =>{
|
|
return getApiError(1300013, errMsg) as IFileSystemManagerFail;
|
|
};
|
|
const getNoSuchFileOrDirectoryError = (errMsg: string | null = null): IFileSystemManagerFail =>{
|
|
return getApiError(1300002, errMsg) as IFileSystemManagerFail;
|
|
};
|
|
const getSavedDir1 = ()=>{
|
|
return getEnv1().USER_DATA_PATH + '/saved';
|
|
};
|
|
let savedIndex1: [string, number] = [
|
|
'0',
|
|
0
|
|
];
|
|
const getSavedFileName1 = (filePath: string)=>{
|
|
const uriInstance = new uri.URI(filePath);
|
|
const ext = uriInstance.clearQuery().getLastSegment().split('.')[1];
|
|
let fileName = Date.now() + '';
|
|
if (savedIndex1[0] === fileName) {
|
|
savedIndex1[1]++;
|
|
if (savedIndex1[1] > 0) {
|
|
fileName += '-' + savedIndex1[1];
|
|
}
|
|
} else {
|
|
savedIndex1[0] = fileName;
|
|
savedIndex1[1] = 0;
|
|
}
|
|
if (ext) {
|
|
fileName += '.' + ext;
|
|
}
|
|
return fileName;
|
|
};
|
|
const getFsPath1 = (filePath: string)=>{
|
|
filePath = getRealPath1(filePath) as string;
|
|
if (!/^file:/.test(filePath)) {
|
|
return filePath;
|
|
}
|
|
const rawPath = filePath.replace(/^file:\/\//, '');
|
|
if (rawPath[0] === '/') {
|
|
return rawPath;
|
|
}
|
|
return filePath;
|
|
};
|
|
const DEFAULT_ENCODING = 'utf-8';
|
|
const ENCODING_SUPPORT = [
|
|
"ascii",
|
|
"base64",
|
|
"utf-8"
|
|
];
|
|
const DIGEST_ALGORITHM_VALUES = [
|
|
"md5",
|
|
"sha1"
|
|
];
|
|
const DEFAULT_POSITION = 0;
|
|
const DEFAULT_LENGTH = 0;
|
|
const DEFAULT_FLAG = 'r';
|
|
const DEFAULT_OFFSET = 0;
|
|
const FLAG = [
|
|
'a',
|
|
'ax',
|
|
'a+',
|
|
'ax+',
|
|
'as',
|
|
'as+',
|
|
'r',
|
|
'r+',
|
|
'w',
|
|
'wx',
|
|
'w+',
|
|
'wx+'
|
|
];
|
|
const useGetRealPath = (filepath: string): string =>{
|
|
return (runtimeGetRealPath(filepath) as string).replace(/^file:\/\//, '');
|
|
};
|
|
class StatsImpl implements Stats {
|
|
stat: fs3.Stat | null = null;
|
|
mode: number = -1;
|
|
size: number = -1;
|
|
lastAccessedTime: number = -1;
|
|
lastModifiedTime: number = -1;
|
|
mIsFile: boolean = false;
|
|
constructor(stat: fs3.Stat, mode: number){
|
|
this.stat = stat;
|
|
this.mode = mode;
|
|
this.size = stat.size;
|
|
this.lastAccessedTime = stat.atime;
|
|
this.lastModifiedTime = stat.mtime;
|
|
this.mIsFile = stat.isFile();
|
|
}
|
|
isDirectory(): boolean {
|
|
if (this.stat == null) {
|
|
return false;
|
|
}
|
|
return this.stat.isDirectory();
|
|
}
|
|
isFile(): boolean {
|
|
if (this.stat == null) {
|
|
return false;
|
|
}
|
|
return this.stat.isFile();
|
|
}
|
|
}
|
|
class FileSystemManagerImpl implements FileSystemManager {
|
|
readFile(options: ReadFileOptions): void {
|
|
const errMsg = `readFile: fail`;
|
|
const filePath = options.filePath, encoding = options.encoding, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const checkRes = checkPathExistence('readFile', 'filePath', filePath);
|
|
if (!checkRes.isValid) {
|
|
cb.fail({
|
|
errMsg: (checkRes as CustomValidReturn).err.errMsg
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const stat = fs3.statSync(filePath);
|
|
if (stat.isDirectory()) {
|
|
cb.fail(getApiError(1300021, errMsg));
|
|
return;
|
|
}
|
|
const lengthOfFile = stat.size;
|
|
if (encoding == undefined) {
|
|
let sizeOfNewArrayBuffer = lengthOfFile;
|
|
ohosRead(filePath, sizeOfNewArrayBuffer, cb);
|
|
} else {
|
|
const res = checkEncoding('readFile', encoding);
|
|
if (!res.isValid) {
|
|
cb.fail({
|
|
errMsg: res.errMsg
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
ohosReadText(filePath, {
|
|
encoding
|
|
} as ReadTextOptions1, cb);
|
|
}
|
|
}
|
|
readFileSync(filePath: string, encoding: string | null = null): ReadFileSuccessResult {
|
|
const errMsg = `readFileSync: fail`;
|
|
const res1 = checkPathExistenceSync('readFileSync', 'filePath', filePath);
|
|
if (!res1.isValid) {
|
|
throw new Error((res1 as CustomValidReturn).err?.errMsg);
|
|
}
|
|
const stat = fs3.statSync(filePath);
|
|
if (stat.isDirectory()) {
|
|
throw new Error(getApiError(1300021, errMsg).errMsg);
|
|
}
|
|
const lengthOfFile = stat.size;
|
|
if (encoding == undefined) {
|
|
let sizeOfNewArrayBuffer = lengthOfFile;
|
|
const file = fs3.openSync(filePath, fs3.OpenMode.READ_ONLY);
|
|
const buf = new ArrayBuffer(sizeOfNewArrayBuffer);
|
|
try {
|
|
fs3.readSync(file.fd, buf);
|
|
} catch (err) {
|
|
console.error(err);
|
|
}
|
|
fs3.closeSync(file);
|
|
return {
|
|
data: buf
|
|
} as ReadFileSuccessResult;
|
|
} else {
|
|
const res2 = checkEncoding('readFileSync', encoding);
|
|
if (!res2.isValid) {
|
|
throw new Error(res2.errMsg);
|
|
}
|
|
if ((encoding as string) === 'utf8') {
|
|
encoding = 'utf-8';
|
|
}
|
|
try {
|
|
const str = fs3.readTextSync(filePath, {
|
|
encoding
|
|
} as ReadTextOptions1);
|
|
return {
|
|
data: str
|
|
} as ReadFileSuccessResult;
|
|
} catch (err) {
|
|
throw new Error(`readFileSync: ${(err as BusinessError5).message}`);
|
|
}
|
|
}
|
|
}
|
|
writeFile(options: WriteFileOptions): void {
|
|
const errMsg = `writeFile: fail`;
|
|
const filePath = options.filePath, data = options.data, _options_encoding = options.encoding, encoding = _options_encoding == null ? DEFAULT_ENCODING : _options_encoding, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} filePath`) as ApiError);
|
|
return;
|
|
}
|
|
if (!ENCODING_SUPPORT.includes(encoding)) {
|
|
cb.fail(getParameterError(`${errMsg} encoding`));
|
|
return;
|
|
}
|
|
let file: fs3.File | null = null;
|
|
try {
|
|
const stat = fs3.statSync(filePath);
|
|
if (stat.isDirectory()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} illegal operation on a directory, open: ${filePath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
} catch (error) {
|
|
try {
|
|
file = fs3.openSync(filePath, fs3.OpenMode.CREATE | fs3.OpenMode.WRITE_ONLY | fs3.OpenMode.TRUNC);
|
|
} catch (error) {
|
|
cb.fail(getApiError((error as BusinessError5).code, errMsg));
|
|
return;
|
|
}
|
|
}
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (checkDataType((data as (string | ArrayBuffer)), true, 'string')) writeOptions.encoding = encoding as string;
|
|
if (file == null) {
|
|
file = fs3.openSync(filePath, fs3.OpenMode.WRITE_ONLY | fs3.OpenMode.TRUNC);
|
|
}
|
|
fs3.write(file.fd, data as (string | ArrayBuffer), writeOptions).then((writeLen)=>{
|
|
cb.success({
|
|
errMsg: 'writeFile: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).finally(()=>{
|
|
fs3.closeSync(file);
|
|
});
|
|
}
|
|
writeFileSync(filePath: string, data: Object, encoding: string = DEFAULT_ENCODING): void {
|
|
const errMsg = `writeFileSync: fail`;
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
throw new Error(getParameterError(`${errMsg} filePath`).errMsg);
|
|
}
|
|
if (!ENCODING_SUPPORT.includes(encoding)) {
|
|
throw new Error(getParameterError(`${errMsg} encoding`).errMsg);
|
|
}
|
|
let file: fs3.File | null = null;
|
|
try {
|
|
const stat = fs3.statSync(filePath);
|
|
if (stat.isDirectory()) {
|
|
throw new Error(`${errMsg} illegal operation on a directory, open: ${filePath}`);
|
|
}
|
|
} catch (error) {
|
|
try {
|
|
file = fs3.openSync(filePath, fs3.OpenMode.CREATE | fs3.OpenMode.WRITE_ONLY | fs3.OpenMode.TRUNC);
|
|
} catch (error) {
|
|
throw new Error(getApiError((error as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (checkDataType((data as (string | ArrayBuffer)), true, 'string')) writeOptions.encoding = encoding;
|
|
if (file == null) {
|
|
file = fs3.openSync(filePath, fs3.OpenMode.WRITE_ONLY | fs3.OpenMode.TRUNC);
|
|
}
|
|
try {
|
|
fs3.writeSync(file.fd, data as (string | ArrayBuffer), writeOptions);
|
|
fs3.closeSync(file);
|
|
} catch (err) {
|
|
fs3.closeSync(file);
|
|
throw new Error(`writeFileSync: ${(err as BusinessError5).message}`);
|
|
}
|
|
}
|
|
read(option: ReadOption): void {
|
|
const errMsg = 'read: fail';
|
|
let inFd = option.fd, arrayBuffer = option.arrayBuffer, offset = option.offset, length = option.length, position = option.position, success = option.success, fail = option.fail, complete = option.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
let fd: number = -1;
|
|
if (!checkDataType(inFd, true, 'string') || inFd === '' || isNaN(Number(inFd))) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} invalid fd`
|
|
} as ApiError);
|
|
return;
|
|
} else {
|
|
fd = Number(inFd);
|
|
}
|
|
if (!checkDataType(arrayBuffer, true, 'arraybuffer')) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} invalid arrayBuffer: ${arrayBuffer}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!checkDataType(offset, false, 'number') || offset! < 0) {
|
|
offset = Number(offset);
|
|
if (isNaN(offset) || offset < 0) {
|
|
offset = DEFAULT_OFFSET;
|
|
}
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0) {
|
|
length = Number(length);
|
|
if (isNaN(length) || length < 0) {
|
|
length = DEFAULT_LENGTH;
|
|
}
|
|
}
|
|
const allowedSize = arrayBuffer.byteLength - offset!;
|
|
if (allowedSize < length!) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} RangeError [ERR_OUT_OF_RANGE]: The value length is out of range. It must be <= ${allowedSize}. Received ${length}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!checkDataType(position, false, 'number') || position! < 0) {
|
|
position = DEFAULT_POSITION;
|
|
}
|
|
const offsetArrayBuffer = offset!;
|
|
const newBuffer = arrayBuffer.slice(offsetArrayBuffer);
|
|
fs3.read(fd, newBuffer, {
|
|
offset: position,
|
|
length
|
|
} as ReadOptions1).then((readLen)=>{
|
|
const viewNewBuffer = new Uint8Array(newBuffer);
|
|
const viewArrayBuffer = new Uint8Array(arrayBuffer);
|
|
viewArrayBuffer.set(viewNewBuffer, offsetArrayBuffer);
|
|
cb.success({
|
|
bytesRead: readLen,
|
|
arrayBuffer: arrayBuffer,
|
|
errMsg: 'read: ok'
|
|
} as ReadSuccessCallbackResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail({
|
|
errMsg: `${errMsg} with error message: ${err.message},error code: ${err.code}`
|
|
} as ApiError);
|
|
});
|
|
}
|
|
readSync(option: ReadSyncOption): ReadResult {
|
|
const errMsg = 'readSync: fail';
|
|
let inFd = option.fd, arrayBuffer = option.arrayBuffer, offset = option.offset, length = option.length, position = option.position;
|
|
let fd: number = -1;
|
|
if (!checkDataType(inFd, true, 'string') || inFd === '' || isNaN(Number(inFd))) {
|
|
throw new Error(`${errMsg} invalid fd`);
|
|
} else {
|
|
fd = Number(inFd);
|
|
}
|
|
if (!checkDataType(arrayBuffer, true, 'arraybuffer')) {
|
|
throw new Error(`${errMsg} invalid arrayBuffer`);
|
|
}
|
|
if (!checkDataType(offset, false, 'number') || offset! < 0) {
|
|
offset = Number(offset);
|
|
if (isNaN(offset) || offset < 0) {
|
|
offset = DEFAULT_OFFSET;
|
|
}
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0) {
|
|
length = Number(length);
|
|
if (isNaN(length) || length < 0) {
|
|
length = DEFAULT_LENGTH;
|
|
}
|
|
}
|
|
const allowedSize = arrayBuffer.byteLength - offset!;
|
|
if (allowedSize < length!) {
|
|
throw new Error(`${errMsg} RangeError [ERR_OUT_OF_RANGE]: The value length is out of range. It must be <= ${allowedSize}. Received ${length}`);
|
|
}
|
|
if (!checkDataType(position, false, 'number') || position! < 0) {
|
|
position = DEFAULT_POSITION;
|
|
}
|
|
try {
|
|
const offsetArrayBuffer = offset!;
|
|
let newBuffer = arrayBuffer.slice(offsetArrayBuffer);
|
|
const len = fs3.readSync(fd, newBuffer, {
|
|
offset: position,
|
|
length
|
|
} as ReadOptions1);
|
|
const viewNewBuffer = new Uint8Array(newBuffer);
|
|
let viewArrayBuffer = new Uint8Array(arrayBuffer);
|
|
viewArrayBuffer.set(viewNewBuffer, offsetArrayBuffer);
|
|
return {
|
|
bytesRead: len,
|
|
arrayBuffer: arrayBuffer
|
|
} as ReadResult;
|
|
} catch (err) {
|
|
throw new Error(`${errMsg} ${(err as BusinessError5).message}`);
|
|
}
|
|
}
|
|
unlink(options: UnLinkOptions): void {
|
|
const errMsg = 'unlink: fail';
|
|
const filePath = options.filePath, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const res = checkPathExistence('unlink', 'filePath', filePath);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
const stat = fs3.statSync(filePath);
|
|
if (stat.isDirectory()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} illegal operation on a directory, unlink: ${filePath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.unlink(filePath).then(()=>{
|
|
cb.success({
|
|
errMsg: 'unlink: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail({
|
|
errMsg: `${errMsg} with error message: ${err.message}, error code: ${err.code}`
|
|
} as ApiError);
|
|
});
|
|
}
|
|
unlinkSync(filePath: string): void {
|
|
const errMsg = 'unlinkSync: fail';
|
|
const res = checkPathExistenceSync('unlinkSync', 'filePath', filePath);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (fs3.statSync(filePath).isDirectory()) {
|
|
throw new Error(`${errMsg} illegal operation on a directory, unlink: ${filePath}`);
|
|
}
|
|
try {
|
|
fs3.unlinkSync(filePath);
|
|
} catch (err) {
|
|
throw new Error(`${errMsg} ${(err as BusinessError5).message}`);
|
|
}
|
|
}
|
|
mkdir(options: MkDirOptions): void {
|
|
const errMsg = `mkdir: fail`;
|
|
let dirPath = options.dirPath, recursive = options.recursive, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
const checkRes = checkPath('mkdir', 'dirPath', dirPath);
|
|
if (!checkRes.isValid) {
|
|
cb.fail((checkRes as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
if (fs3.accessSync(dirPath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} dirPath already exists: ${dirPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const getSubPath = obtainUpperPath(dirPath);
|
|
if (!recursive && !fs3.accessSync(getSubPath.upperPath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} recursive is false and upper path does not exist`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.mkdir(dirPath, recursive).then(()=>{
|
|
cb.success({
|
|
errMsg: 'mkdir: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
});
|
|
}
|
|
mkdirSync(dirPath: string, recursive: boolean): void {
|
|
const errMsg = `mkdirSync: fail`;
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
const res = checkPathSync('mkdirSync', 'dirPath', dirPath);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (fs3.accessSync(dirPath)) {
|
|
throw new Error(`${errMsg} dirPath already exists: ${dirPath}`);
|
|
}
|
|
if (!recursive && !fs3.accessSync(obtainUpperPath(dirPath).upperPath)) {
|
|
throw new Error(`${errMsg} recursive is false and upper path does not exist`);
|
|
}
|
|
try {
|
|
fs3.mkdirSync(dirPath, recursive);
|
|
} catch (error) {
|
|
throw new Error(getApiError((error as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
rmdir(options: RmDirOptions): void {
|
|
const errMsg = 'rmdir: fail';
|
|
let dirPath = options.dirPath, recursive = options.recursive, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
const res = checkPathExistence('rmdir', 'dirPath', dirPath);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
if (!fs3.statSync(dirPath).isDirectory()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} no such directory, open: ${dirPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!recursive) {
|
|
let filenames = fs3.listFileSync(dirPath);
|
|
if (filenames.length) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} directory not empty`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
}
|
|
fs3.rmdir(dirPath).then(()=>{
|
|
cb.success({
|
|
errMsg: 'rmdir: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
rmdirSync(dirPath: string, recursive: boolean): void {
|
|
const errMsg = 'rmdirSync: fail';
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
const res = checkPathExistenceSync('rmdirSync', 'dirPath', dirPath);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (!fs3.statSync(dirPath).isDirectory()) {
|
|
throw new Error(`${errMsg} no such directory, open: ${dirPath}`);
|
|
}
|
|
if (!recursive && (fs3.listFileSync(dirPath).length > 0)) {
|
|
throw new Error(`${errMsg} directory not empty`);
|
|
}
|
|
try {
|
|
fs3.rmdirSync(dirPath);
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
readdir(options: ReadDirOptions): void {
|
|
const errMsg = 'readdir: fail';
|
|
const dirPath = options.dirPath, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const checkRes = checkPathExistence('readdir', 'dirPath', dirPath);
|
|
if (!checkRes.isValid) {
|
|
cb.fail((checkRes as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
const stat = fs3.statSync(dirPath);
|
|
if (stat.isFile()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} dirPath not a directory: ${dirPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.listFile(dirPath).then((files)=>{
|
|
cb.success({
|
|
files,
|
|
errMsg: 'readdir: ok'
|
|
} as ReadDirSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail({
|
|
errMsg: `${errMsg} with error message: ${err.message}, error code: ${err.code}`
|
|
} as ApiError);
|
|
});
|
|
}
|
|
readdirSync(dirPath: string): string[] | null {
|
|
const errMsg = 'readdirSync: fail';
|
|
const res = checkPathExistenceSync('readdirSync', 'dirPath', dirPath);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (fs3.statSync(dirPath).isFile()) {
|
|
throw new Error(`${errMsg} not a directory: ${dirPath}`);
|
|
}
|
|
try {
|
|
return fs3.listFileSync(dirPath);
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
access(options: AccessOptions): void {
|
|
const errMsg = 'access: fail';
|
|
const path = options.path, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(path, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} path`));
|
|
return;
|
|
}
|
|
fs3.access(path).then((res)=>{
|
|
if (res) {
|
|
cb.success({
|
|
errMsg: 'access: ok'
|
|
} as FileManagerSuccessResult);
|
|
} else {
|
|
cb.fail(getNoSuchFileOrDirectoryError(errMsg));
|
|
}
|
|
}, (err: BusinessError5)=>{
|
|
cb.fail({
|
|
errCode: err.code,
|
|
errMsg: getApiError(err.code, errMsg).errMsg
|
|
} as ApiError);
|
|
});
|
|
}
|
|
accessSync(path: string): void {
|
|
const errMsg = 'accessSync: fail';
|
|
if (!checkDataType(path, true, 'string')) {
|
|
throw new Error(`${errMsg} path must be a string`);
|
|
}
|
|
const res = fs3.accessSync(path);
|
|
if (!res) {
|
|
throw new Error(`${errMsg} no such file or directory`);
|
|
}
|
|
}
|
|
rename(options: RenameOptions): void {
|
|
const errMsg = 'rename: fail';
|
|
const oldPath = options.oldPath, newPath = options.newPath, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const checkRes1 = checkPathExistence('rename', 'oldPath', oldPath);
|
|
if (!checkRes1.isValid) {
|
|
cb.fail((checkRes1 as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
const checkRes2 = checkPath('rename', 'newPath', newPath);
|
|
if (!checkRes2.isValid) {
|
|
cb.fail((checkRes2 as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
const ifAccessNewPath = fs3.accessSync(newPath);
|
|
if (!ifAccessNewPath) {
|
|
const getUpperPath = obtainUpperPath(newPath);
|
|
if (!fs3.accessSync(getUpperPath.upperPath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} no such file or directory: ${newPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
}
|
|
if (ifAccessNewPath && (oldPath !== newPath)) {
|
|
cb.fail({
|
|
errMsg
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.rename(oldPath, newPath).then(()=>{
|
|
cb.success({
|
|
errMsg: 'rename: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail({
|
|
errMsg: getApiError((err as BusinessError5).code, errMsg).errMsg
|
|
} as ApiError);
|
|
});
|
|
}
|
|
renameSync(oldPath: string, newPath: string): void {
|
|
const errMsg = 'renameSync: fail';
|
|
const res1 = checkPathExistenceSync('renameSync', 'oldPath', oldPath);
|
|
if (!res1.isValid) {
|
|
throw new Error((res1 as CustomValidReturn).err?.errMsg);
|
|
}
|
|
const res2 = checkPathSync('renameSync', 'newPath', newPath);
|
|
if (!res2.isValid) {
|
|
throw new Error((res2 as CustomValidReturn).err?.errMsg);
|
|
}
|
|
const ifAccessNewPath = fs3.accessSync(newPath);
|
|
if (!ifAccessNewPath && !fs3.accessSync(obtainUpperPath(newPath).upperPath)) {
|
|
throw new Error(`${errMsg} no such file or directory, open: ${newPath}`);
|
|
}
|
|
if (ifAccessNewPath && (oldPath !== newPath)) {
|
|
throw new Error(errMsg);
|
|
}
|
|
try {
|
|
fs3.renameSync(oldPath, newPath);
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
copyFile(options: CopyFileOptions): void {
|
|
const errMsg = 'copyFile: fail';
|
|
let srcPath = options.srcPath, destPath = options.destPath, success = options.success, fail = options.fail, complete = options.complete;
|
|
srcPath = useGetRealPath(srcPath);
|
|
destPath = useGetRealPath(destPath);
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const checkResOfSrcPath = checkPathExistence('copyFile', 'srcPath', srcPath);
|
|
if (!checkResOfSrcPath.isValid) {
|
|
cb.fail((checkResOfSrcPath as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
const checkResOfDestPath = checkPath('copyFile', 'destPath', destPath);
|
|
if (!checkResOfDestPath.isValid) {
|
|
cb.fail((checkResOfDestPath as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
if (fs3.statSync(srcPath).isDirectory()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} illegal operation on a directory, open: ${srcPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!fs3.accessSync(destPath)) {
|
|
const getUpperPath = obtainUpperPath(destPath);
|
|
if (!fs3.accessSync(getUpperPath.upperPath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} no such file or directory, open: ${destPath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
} else {
|
|
const destPathStat = fs3.statSync(destPath);
|
|
if (destPathStat.isDirectory()) {
|
|
destPath = destPath + obtainFileName(srcPath).fileName;
|
|
} else {
|
|
if (destPathStat.isFile() && (srcPath !== destPath)) {
|
|
cb.fail({
|
|
errMsg
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
fs3.copyFile(srcPath, destPath).then(()=>{
|
|
cb.success({
|
|
errMsg: 'copyFile: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
copyFileSync(srcPath: string, destPath: string): void {
|
|
const errMsg = 'copyFileSync: fail';
|
|
srcPath = useGetRealPath(srcPath);
|
|
destPath = useGetRealPath(destPath);
|
|
const checkResSrc = checkPathExistenceSync('copyFileSync', 'srcPath', srcPath);
|
|
if (!checkResSrc.isValid) {
|
|
throw new Error((checkResSrc as CustomValidReturn).err?.errMsg);
|
|
}
|
|
const checkResDest = checkPathSync('copyFileSync', 'destPath', destPath);
|
|
if (!checkResDest.isValid) {
|
|
throw new Error((checkResDest as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (fs3.statSync(srcPath).isDirectory()) {
|
|
throw new Error(`${errMsg} illegal operation on a directory: ${srcPath}`);
|
|
}
|
|
if (!fs3.accessSync(destPath)) {
|
|
const getUpperPath = obtainUpperPath(destPath);
|
|
if (!fs3.accessSync(getUpperPath.upperPath)) {
|
|
throw new Error(`${errMsg} no such file or directory: ${destPath}`);
|
|
}
|
|
} else {
|
|
const destPathStat = fs3.statSync(destPath);
|
|
if (destPathStat.isDirectory()) {
|
|
const index = destPath.lastIndexOf('/');
|
|
let namePath = destPath.substring(index);
|
|
if (destPath.endsWith('/')) {
|
|
namePath = destPath.substring(destPath.lastIndexOf('/', destPath.length - 2) + 1, destPath.length - 1);
|
|
}
|
|
destPath = destPath + namePath;
|
|
} else {
|
|
if (destPathStat.isFile() && (srcPath !== destPath)) {
|
|
throw new Error(`${errMsg} copyFile failed`);
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
fs3.copyFileSync(srcPath, destPath);
|
|
} catch (err) {
|
|
throw new Error(`copyFileSync: ${(err as BusinessError5).message}`);
|
|
}
|
|
}
|
|
getFileInfo(options: GetFileInfoOptions): void {
|
|
const errMsg = 'getFileInfo: fail';
|
|
let filePath = options.filePath, success = options.success, fail = options.fail, complete = options.complete;
|
|
let digestAlgorithm: string = options.digestAlgorithm ?? 'md5';
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const checkResOfFilePath = checkPathExistence('getFileInfo', 'filePath', filePath);
|
|
if (!checkResOfFilePath.isValid) {
|
|
cb.fail((checkResOfFilePath as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
if (typeof digestAlgorithm === 'string') {
|
|
digestAlgorithm = digestAlgorithm.toUpperCase();
|
|
}
|
|
if (!DIGEST_ALGORITHM_VALUES.includes(digestAlgorithm)) {
|
|
digestAlgorithm = 'md5';
|
|
}
|
|
try {
|
|
const fd = fs3.openSync(filePath, fs3.OpenMode.READ_WRITE).fd;
|
|
const stat = isFileUri1(filePath) ? fs3.statSync(fd) : fs3.statSync(filePath);
|
|
const buf = new ArrayBuffer(stat.size);
|
|
fs3.readSync(fd, buf);
|
|
const algName = digestAlgorithm.toLocaleUpperCase();
|
|
SecurityBase.rsa(algName, {
|
|
data: new Uint8Array(buf)
|
|
} as cryptoFramework1.DataBlob).then((resultBuf: Uint8Array)=>{
|
|
const textDecoder = util1.TextDecoder.create('utf-8', {
|
|
ignoreBOM: true
|
|
} as util1.TextDecoderOptions);
|
|
cb.success({
|
|
errMsg: 'getFileInfo ok',
|
|
size: stat.size,
|
|
digest: textDecoder.decodeToString(resultBuf, {
|
|
stream: false
|
|
} as util1.DecodeToStringOptions)
|
|
} as GetFileInfoSuccessResult);
|
|
});
|
|
} catch (err) {
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
}
|
|
}
|
|
stat(options: StatOptions): void {
|
|
const errMsg = 'stat: fail';
|
|
let path = options.path, recursive = options.recursive, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const res = checkPathExistence('stat', 'path', path);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CustomValidReturn).err);
|
|
return;
|
|
}
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
fs3.stat(path, (err, stat)=>{
|
|
if (err) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} with error message: ${err.message}, error code: ${err.code}`
|
|
} as ApiError);
|
|
} else {
|
|
const combinationMode = getFileTypeMode(stat) | stat.mode;
|
|
const fileStats = {
|
|
path,
|
|
stats: new StatsImpl(stat, combinationMode)
|
|
} as FileStats;
|
|
cb.success({
|
|
stats: [
|
|
fileStats
|
|
] as FileStats[],
|
|
errMsg: 'stat: ok'
|
|
} as StatSuccessResult);
|
|
}
|
|
});
|
|
}
|
|
statSync(path: string, recursive: boolean): FileStats[] {
|
|
const errMsg = 'statSync: fail';
|
|
const res = checkPathExistenceSync('statSync', 'path', path);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CustomValidReturn).err?.errMsg);
|
|
}
|
|
if (!checkDataType(recursive, false, 'boolean')) {
|
|
recursive = Boolean(recursive);
|
|
}
|
|
try {
|
|
const stat = fs3.statSync(path);
|
|
const combinationMode = getFileTypeMode(stat) | stat.mode;
|
|
const fileStats = {
|
|
path,
|
|
stats: new StatsImpl(stat, combinationMode)
|
|
} as FileStats;
|
|
return [
|
|
fileStats
|
|
] as FileStats[];
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
appendFile(options: AppendFileOptions): void {
|
|
const errMsg = 'appendFile: fail';
|
|
const filePath = options.filePath, data = options.data, _options_encoding = options.encoding, encoding = _options_encoding == null ? DEFAULT_ENCODING : _options_encoding, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} filePath`));
|
|
return;
|
|
}
|
|
if (!checkDataType(data, true, 'string') && !checkDataType(data, true, 'arraybuffer')) {
|
|
cb.fail(getParameterError(`${errMsg} data`));
|
|
return;
|
|
}
|
|
const res = fs3.accessSync(filePath);
|
|
if (!res) {
|
|
cb.fail(getNoSuchFileOrDirectoryError(errMsg));
|
|
return;
|
|
}
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (checkDataType(data, true, 'string')) writeOptions.encoding = encoding;
|
|
const file = fs3.openSync(filePath, fs3.OpenMode.READ_WRITE | fs3.OpenMode.APPEND);
|
|
fs3.write(file.fd, data as (string | ArrayBuffer), writeOptions).then((_)=>{
|
|
cb.success({
|
|
errMsg: 'appendFile:ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
}).finally(()=>{
|
|
fs3.closeSync(file);
|
|
});
|
|
}
|
|
appendFileSync(filePath: string, data: Object, encoding: string = DEFAULT_ENCODING): void {
|
|
const errMsg = 'appendFileSync: fail';
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
throw new Error(`${errMsg} parameter error: parameter.filePath should be String`);
|
|
}
|
|
if (!checkDataType(data, true, 'string') && !checkDataType(data, true, 'arraybuffer')) {
|
|
throw new Error(`${errMsg} parameter error: parameter.data should be String/ArrayBuffer`);
|
|
}
|
|
const res = fs3.accessSync(filePath);
|
|
if (!res) {
|
|
throw new Error(`${errMsg} no such file or directory, open "${filePath}"`);
|
|
}
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (checkDataType(data, true, 'string')) writeOptions.encoding = encoding;
|
|
const file = fs3.openSync(filePath, fs3.OpenMode.READ_WRITE | fs3.OpenMode.APPEND);
|
|
fs3.writeSync(file.fd, data as (string | ArrayBuffer), writeOptions);
|
|
}
|
|
saveFile(options: SaveFileOptions): void {
|
|
const errMsg = 'saveFile: fail';
|
|
const filePath = options.filePath, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const tempFilePath = useGetRealPath(options.tempFilePath) as string;
|
|
if (!fs3.accessSync(tempFilePath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} no such file or directory. tempFilePath: ${tempFilePath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const savedPath = filePath || getSavedDir1();
|
|
try {
|
|
if (!fs3.accessSync(savedPath)) {
|
|
fs3.mkdirSync(savedPath, true);
|
|
}
|
|
} catch (error) {
|
|
cb.fail({
|
|
errMsg: (error as Error).message
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
let srcFile: fs3.File;
|
|
try {
|
|
srcFile = fs3.openSync(tempFilePath, fs3.OpenMode.READ_ONLY);
|
|
} catch (error) {
|
|
cb.fail({
|
|
errMsg: (error as Error).message
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const savedFilePath = savedPath + '/' + getSavedFileName1(tempFilePath);
|
|
fs3.copyFile(srcFile.fd, savedFilePath).then(()=>{
|
|
cb.success({
|
|
savedFilePath
|
|
} as SaveFileSuccessResult);
|
|
}).catch((err: Error)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
saveFileSync(inTempFilePath: string, filePath: string | null): string {
|
|
const errMsg = 'saveFileSync: fail';
|
|
const tempFilePath = useGetRealPath(inTempFilePath) as string;
|
|
if (!fs3.accessSync(tempFilePath)) {
|
|
throw new Error(`${errMsg} no such file or directory. tempFilePath: ${tempFilePath}`);
|
|
}
|
|
const savedPath = filePath || getSavedDir1();
|
|
try {
|
|
if (!fs3.accessSync(savedPath)) {
|
|
fs3.mkdirSync(savedPath, true);
|
|
}
|
|
} catch (error) {
|
|
throw new Error((error as Error).message);
|
|
}
|
|
let srcFile: fs3.File;
|
|
try {
|
|
srcFile = fs3.openSync(tempFilePath, fs3.OpenMode.READ_ONLY);
|
|
} catch (error) {
|
|
throw new Error((error as Error).message);
|
|
}
|
|
const savedFilePath = `${savedPath}${savedPath.endsWith('/') ? '' : '/'}${getSavedFileName1(tempFilePath)}`;
|
|
try {
|
|
fs3.copyFileSync(srcFile.fd, savedFilePath);
|
|
return savedFilePath;
|
|
} catch (error) {
|
|
throw new Error((error as Error).message);
|
|
}
|
|
}
|
|
removeSavedFile(options: RemoveSavedFileOptions): void {
|
|
const filePath = options.filePath, success = options.success, fail = options.fail, complete = options.complete;
|
|
const savedFilePath = getFsPath1(filePath);
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!fs3.accessSync(savedFilePath)) {
|
|
cb.fail({
|
|
errMsg: 'file not exist'
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.unlink(savedFilePath, (err)=>{
|
|
if (err) {
|
|
cb.fail(getApiError(err.code, 'removeSavedFile: fail'));
|
|
} else {
|
|
cb.success({
|
|
errMsg: 'removeSavedFile: ok'
|
|
} as FileManagerSuccessResult);
|
|
}
|
|
});
|
|
}
|
|
getSavedFileList(options: GetSavedFileListOptions): void {
|
|
const errMsg = 'getSavedFileList: fail';
|
|
const success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const savedPath = getSavedDir1();
|
|
if (!fs3.accessSync(savedPath)) {
|
|
cb.fail(getApiError(1300002, errMsg));
|
|
return;
|
|
}
|
|
fs3.listFile(savedPath, {} as ListFileOptions1, (err, fileList)=>{
|
|
if (err) {
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
} else {
|
|
cb.success({
|
|
fileList: fileList.map((filePath: string)=>{
|
|
const fullPath = savedPath + '/' + filePath;
|
|
const stat = fs3.statSync(fullPath);
|
|
if (!stat.isFile()) {
|
|
return null;
|
|
}
|
|
return fullPath;
|
|
}).filter((item)=>!!item)
|
|
} as GetSavedFileListResult);
|
|
}
|
|
});
|
|
}
|
|
truncate(options: TruncateFileOptions): void {
|
|
const errMsg = 'truncate: fail';
|
|
let filePath = options.filePath, length = options.length, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} parameter error: parameter.filePath should be String`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const res = fs3.accessSync(filePath);
|
|
if (!res) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} no such file or directory, open "${filePath}"`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const fileStat = fs3.statSync(filePath);
|
|
if (fileStat.isDirectory()) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} illegal operation on a directory, open: ${filePath}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0) {
|
|
length = 0;
|
|
}
|
|
const file = fs3.openSync(filePath, fs3.OpenMode.READ_WRITE);
|
|
fs3.truncate(file.fd, length).then(()=>{
|
|
cb.success({
|
|
errMsg: 'truncate: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
});
|
|
}
|
|
truncateSync(filePath: string, length: number | null = null): void {
|
|
const errMsg = 'truncateSync: fail';
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
throw new Error(`${errMsg} parameter error: parameter.filePath should be String`);
|
|
}
|
|
const res = fs3.accessSync(filePath);
|
|
if (!res) {
|
|
throw new Error(`${errMsg} no such file or directory, open "${filePath}"`);
|
|
}
|
|
const fileStat = fs3.statSync(filePath);
|
|
if (fileStat.isDirectory()) {
|
|
throw new Error(`${errMsg} illegal operation on a directory, open: ${filePath}`);
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0) {
|
|
length = 0;
|
|
}
|
|
const file = fs3.openSync(filePath, fs3.OpenMode.READ_WRITE);
|
|
try {
|
|
fs3.truncateSync(file.fd, length!);
|
|
} catch (error) {
|
|
throw new Error(getApiError((error as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
open(options: OpenFileOptions): void {
|
|
const errMsg = 'open: fail';
|
|
let filePath = options.filePath, flag = options.flag, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} parameter error: parameter.filePath should be String`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!FLAG.includes(flag)) {
|
|
flag = DEFAULT_FLAG;
|
|
}
|
|
if (Object.keys(modeReflect).includes(flag)) {
|
|
if (fs3.accessSync(filePath)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} EXIST: file already exists`
|
|
} as ApiError);
|
|
return;
|
|
} else {
|
|
flag = modeReflect[flag as keyof ModeReflect] as _FLAG;
|
|
}
|
|
}
|
|
fs3.open(filePath, getOpenMode(flag)!, (err, file)=>{
|
|
if (err) {
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
} else {
|
|
cb.success({
|
|
fd: file.fd.toString(),
|
|
errMsg: 'open: ok'
|
|
} as OpenFileSuccessResult);
|
|
}
|
|
});
|
|
}
|
|
openSync(options: OpenFileSyncOptions): string {
|
|
let filePath = options.filePath, flag = options.flag;
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
throw new Error('openSync:fail parameter error: parameter.filePath should be String');
|
|
}
|
|
if (!FLAG.includes(flag)) {
|
|
flag = DEFAULT_FLAG;
|
|
}
|
|
if (Object.keys(modeReflect).includes(flag)) {
|
|
if (fs3.accessSync(filePath)) {
|
|
throw new Error('openSync:fail EXIST: file already exists');
|
|
} else {
|
|
flag = modeReflect[flag as keyof ModeReflect] as _FLAG;
|
|
}
|
|
}
|
|
const file = fs3.openSync(filePath, getOpenMode(flag)!);
|
|
return file.fd.toString();
|
|
}
|
|
write(options: WriteOptions): void {
|
|
let inFd = options.fd, data = options.data, offset = options.offset, length = options.length, position = options.position, _options_encoding = options.encoding, encoding = _options_encoding == null ? 'utf-8' : _options_encoding, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
let fd: number = -1;
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (!checkDataType(inFd, true, 'string') || inFd === '' || isNaN(Number(inFd))) {
|
|
cb.fail({
|
|
errMsg: 'write: fail invalid fd'
|
|
} as ApiError);
|
|
return;
|
|
} else {
|
|
fd = Number(inFd);
|
|
}
|
|
if (!checkDataType((data as DataType), true, 'arraybuffer') && !checkDataType((data as DataType), true, 'string')) {
|
|
cb.fail({
|
|
errMsg: 'write: fail data must be a string or ArrayBuffer'
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (checkDataType((data as DataType), true, 'arraybuffer')) {
|
|
const sizeOfArrayBuffer = (data as ArrayBuffer).byteLength as number;
|
|
if (!checkDataType(offset, false, 'number') || offset! < 0 || !offset) {
|
|
offset = DEFAULT_OFFSET;
|
|
}
|
|
if (offset > sizeOfArrayBuffer) {
|
|
cb.fail({
|
|
errMsg: `write: fail RangeError [ERR_OUT_OF_RANGE]: The value of offset is out of range. It must be <= ${sizeOfArrayBuffer}. Received ${offset}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0 || !length) {
|
|
length = sizeOfArrayBuffer - offset;
|
|
}
|
|
if (length > sizeOfArrayBuffer - offset) {
|
|
cb.fail({
|
|
errMsg: `write: fail RangeError [ERR_OUT_OF_RANGE]: The value of length is out of range. It must be <= ${sizeOfArrayBuffer - offset}. Received ${length}`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
const uint8ArrayTemp = new Uint8Array(data as ArrayBuffer);
|
|
const slicedArray = uint8ArrayTemp.slice(offset);
|
|
data = slicedArray.buffer;
|
|
}
|
|
if (checkDataType((data as DataType), true, 'string')) {
|
|
const res = checkEncoding('write', encoding);
|
|
if (!res.isValid) {
|
|
cb.fail({
|
|
errMsg: res.errMsg
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
writeOptions.encoding = encoding as string;
|
|
length = buffer.byteLength(data as string);
|
|
}
|
|
if (!checkDataType(position, false, 'number') || position! < 0 || !position) {
|
|
position = DEFAULT_POSITION;
|
|
}
|
|
writeOptions.offset = position;
|
|
writeOptions.length = length!;
|
|
fs3.write(fd, data as (ArrayBuffer | string), writeOptions).then((writeLen)=>{
|
|
cb.success({
|
|
bytesWritten: writeLen,
|
|
errMsg: 'write:ok'
|
|
} as WriteResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail({
|
|
errMsg: `write data to file failed with error message: ${err.message}, error code: ${err.code}`
|
|
} as ApiError);
|
|
});
|
|
}
|
|
writeSync(options: WriteSyncOptions): WriteResult {
|
|
let inFd = options.fd, data = options.data, offset = options.offset, length = options.length, position = options.position, _options_encoding = options.encoding, encoding = _options_encoding == null ? 'utf-8' : _options_encoding;
|
|
let fd: number = -1;
|
|
const writeOptions: OHWriteOptions = {};
|
|
if (!checkDataType(inFd, true, 'string') || inFd === '' || isNaN(Number(inFd))) {
|
|
throw new Error('writeSync: fail invalid fd');
|
|
} else {
|
|
fd = Number(inFd);
|
|
}
|
|
if (!checkDataType((data as DataType), true, 'arraybuffer') && !checkDataType((data as DataType), true, 'string')) {
|
|
throw new Error('writeSync: fail data must be a string or ArrayBuffer');
|
|
}
|
|
if (checkDataType((data as DataType), true, 'arraybuffer')) {
|
|
const sizeOfArrayBuffer = (data as ArrayBuffer).byteLength as number;
|
|
if (!checkDataType(offset, false, 'number') || offset! < 0 || !offset) {
|
|
offset = DEFAULT_OFFSET;
|
|
}
|
|
if (offset > sizeOfArrayBuffer) {
|
|
throw new Error(`write: fail RangeError [ERR_OUT_OF_RANGE]: The value of offset is out of range. It must be <= ${sizeOfArrayBuffer}. Received ${offset}`);
|
|
}
|
|
if (!checkDataType(length, false, 'number') || length! < 0 || !length) {
|
|
length = sizeOfArrayBuffer - offset;
|
|
}
|
|
if (length > sizeOfArrayBuffer - offset) {
|
|
throw new Error(`write: fail RangeError [ERR_OUT_OF_RANGE]: The value of length is out of range. It must be <= ${sizeOfArrayBuffer - offset}. Received ${length}`);
|
|
}
|
|
const uint8ArrayTemp = new Uint8Array(data as ArrayBuffer);
|
|
const slicedArray = uint8ArrayTemp.slice(offset);
|
|
data = slicedArray.buffer;
|
|
}
|
|
if (checkDataType((data as DataType), true, 'string')) {
|
|
const res = checkEncoding('write', encoding);
|
|
if (!res.isValid) {
|
|
throw new Error(res.errMsg);
|
|
}
|
|
writeOptions.encoding = encoding as string;
|
|
length = buffer.byteLength(data as string);
|
|
}
|
|
if (!checkDataType(position, false, 'number') || position! < 0 || !position) {
|
|
position = DEFAULT_POSITION;
|
|
}
|
|
writeOptions.offset = position;
|
|
writeOptions.length = length!;
|
|
try {
|
|
const writeLen = fs3.writeSync(fd, data as (ArrayBuffer | string), writeOptions);
|
|
return {
|
|
bytesWritten: writeLen,
|
|
errMsg: 'write:ok'
|
|
} as WriteResult;
|
|
} catch (error) {
|
|
throw new Error(`writeSync: fail ${(error as BusinessError5).message}`);
|
|
}
|
|
}
|
|
close(options: CloseOptions): void {
|
|
const errMsg = 'close: fail';
|
|
let inFd = options.fd, success = options.success, fail = options.fail, complete = options.complete;
|
|
let fd: number = -1;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const res = checkFd('fstat', inFd);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CheckFdErr).err);
|
|
return;
|
|
}
|
|
fd = res.fd;
|
|
if (isNaN(fd)) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} bad file descriptor`
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
fs3.close(fd, (err)=>{
|
|
if (err) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} bad file descriptor`
|
|
} as ApiError);
|
|
} else {
|
|
cb.success({
|
|
errMsg: 'close:ok'
|
|
} as FileManagerSuccessResult);
|
|
}
|
|
});
|
|
}
|
|
closeSync(options: CloseSyncOptions): void {
|
|
const errMsg = 'closeSync: fail';
|
|
let inFd = options.fd;
|
|
let fd: number = -1;
|
|
if (inFd === '' || !checkDataType(inFd, true, 'string')) {
|
|
throw new Error(`${errMsg} invalid fd`);
|
|
}
|
|
fd = Number(inFd);
|
|
if (isNaN(fd)) {
|
|
throw new Error(`${errMsg} bad file descriptor`);
|
|
}
|
|
fs3.closeSync(fd);
|
|
}
|
|
fstat(options: FStatOptions): void {
|
|
const errMsg = 'fstat: fail';
|
|
let inFd = options.fd, success = options.success, fail = options.fail, complete = options.complete;
|
|
let fd: number = -1;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
const res = checkFd('fstat', inFd);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CheckFdErr).err);
|
|
return;
|
|
} else {
|
|
fd = res.fd;
|
|
}
|
|
fs3.stat(fd, (err, stat)=>{
|
|
if (err) {
|
|
cb.fail(getApiError(err.code, errMsg));
|
|
} else {
|
|
const combinationMode = getFileTypeMode(stat) | stat.mode;
|
|
cb.success({
|
|
stats: new StatsImpl(stat, combinationMode)
|
|
} as FStatSuccessResult);
|
|
}
|
|
});
|
|
}
|
|
fstatSync(options: FStatSyncOptions): Stats {
|
|
const errMsg = 'fstatSync: fail';
|
|
let fd: number = -1;
|
|
const res = checkFd('fstatSync', options.fd);
|
|
if (!res.isValid) {
|
|
throw new Error((res as CheckFdErr).err?.errMsg);
|
|
} else {
|
|
fd = res.fd;
|
|
}
|
|
try {
|
|
const stat = fs3.statSync(fd);
|
|
const combinationMode = getFileTypeMode(stat) | stat.mode;
|
|
return new StatsImpl(stat, combinationMode);
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
ftruncate(options: FTruncateFileOptions): void {
|
|
const errMsg = 'ftruncate: fail';
|
|
let inFd = options.fd, length = options.length, success = options.success, fail = options.fail, complete = options.complete;
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
let fd: number = -1;
|
|
const res = checkFd('ftruncate', inFd);
|
|
if (!res.isValid) {
|
|
cb.fail((res as CheckFdErr).err);
|
|
return;
|
|
} else {
|
|
fd = res.fd;
|
|
}
|
|
if (!checkDataType(length, true, 'number') || length < 0) {
|
|
length = DEFAULT_LENGTH;
|
|
}
|
|
fs3.truncate(fd, length).then(()=>{
|
|
cb.success({
|
|
errMsg: 'ftruncate: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
ftruncateSync(options: FTruncateFileSyncOptions): void {
|
|
const errMsg = 'ftruncateSync: fail';
|
|
let inFd = options.fd, length = options.length;
|
|
const res = checkFd('ftruncateSync', inFd);
|
|
let fd: number = -1;
|
|
if (!res.isValid) {
|
|
throw new Error((res as CheckFdErr).err?.errMsg);
|
|
} else {
|
|
fd = res.fd;
|
|
}
|
|
if (!checkDataType(length, true, 'number') || length < 0) {
|
|
length = DEFAULT_LENGTH;
|
|
}
|
|
try {
|
|
fs3.truncateSync(fd, length);
|
|
} catch (err) {
|
|
throw new Error(getApiError((err as BusinessError5).code, errMsg).errMsg);
|
|
}
|
|
}
|
|
unzip(options: UnzipFileOptions): void {
|
|
const errMsg = 'unzip: fail';
|
|
let zipFilePath = options.zipFilePath, targetPath = options.targetPath, success = options.success, fail = options.fail, complete = options.complete;
|
|
zipFilePath = useGetRealPath(zipFilePath);
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
if (!checkDataType(zipFilePath, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} zipFilePath`));
|
|
return;
|
|
}
|
|
if (!checkDataType(targetPath, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} targetPath`));
|
|
return;
|
|
}
|
|
const res = fs3.accessSync(zipFilePath);
|
|
if (!res) {
|
|
cb.fail(getNoSuchFileOrDirectoryError(errMsg));
|
|
return;
|
|
}
|
|
const targetStat = fs3.statSync(targetPath);
|
|
if (!targetStat.isDirectory()) {
|
|
cb.fail(getApiError(1300016, errMsg));
|
|
return;
|
|
}
|
|
zlib.decompressFile(zipFilePath, targetPath).then(()=>{
|
|
cb.success({
|
|
errMsg: 'unzip: ok'
|
|
} as FileManagerSuccessResult);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
readZipEntry(options: ReadZipEntryOptions): void {
|
|
const errMsg = 'readZipEntry: fail';
|
|
const okMsg = 'readZipEntry: ok';
|
|
let filePath = options.filePath, encoding = options.encoding, entries = options.entries, success = options.success, fail = options.fail, complete = options.complete;
|
|
filePath = useGetRealPath(filePath);
|
|
const cb = new FileCallback({
|
|
success,
|
|
fail,
|
|
complete
|
|
} as CallBack);
|
|
let isAll = false;
|
|
let encodeArrayBuffer = false;
|
|
if (!checkDataType(filePath, true, 'string')) {
|
|
cb.fail(getParameterError(`${errMsg} filePath`));
|
|
return;
|
|
}
|
|
if (entries != null) {
|
|
if (!Array.isArray(entries)) {
|
|
cb.fail(getParameterError(`${errMsg} entries`));
|
|
return;
|
|
} else {
|
|
if (entries.length === 0) {
|
|
cb.fail(getParameterError(`${errMsg} entries`));
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
isAll = true;
|
|
if (encoding == null) {
|
|
encodeArrayBuffer = true;
|
|
} else if (isString(encoding)) {
|
|
if ((encoding as string) === 'utf8') {
|
|
encoding = 'utf-8';
|
|
}
|
|
}
|
|
}
|
|
if (isString(encoding) && !ENCODING_SUPPORT.includes(encoding as string)) {
|
|
cb.fail(getParameterError(`${errMsg} encoding`));
|
|
return;
|
|
}
|
|
const res = fs3.accessSync(filePath);
|
|
if (!res) {
|
|
cb.fail(getNoSuchFileOrDirectoryError(errMsg));
|
|
return;
|
|
}
|
|
const targetPath = `${getEnv2().TEMP_PATH}/unzip/${Date.now().toString()}`;
|
|
fs3.mkdir(targetPath, true).then(()=>{
|
|
this.unzip({
|
|
zipFilePath: filePath,
|
|
targetPath,
|
|
success: ()=>{
|
|
const entriesResult: Map<string, ZipFileItem> = new Map();
|
|
const readFileSync = (file: string, fullPath: string, encoding: string | null = null)=>{
|
|
const data = this.readFileSync(fullPath).data as ArrayBuffer;
|
|
if (encodeArrayBuffer) {
|
|
entriesResult.set(file, {
|
|
data,
|
|
errMsg: okMsg
|
|
} as ZipFileItem);
|
|
} else {
|
|
entriesResult.set(file, {
|
|
data: buffer.from(data).toString(encoding as string),
|
|
errMsg: okMsg
|
|
} as ZipFileItem);
|
|
}
|
|
};
|
|
try {
|
|
if (isAll) {
|
|
const files = fs3.listFileSync(targetPath);
|
|
for (const file of files){
|
|
const fullPath = `${targetPath}/${file}`;
|
|
if (fs3.statSync(fullPath).isFile()) {
|
|
readFileSync(file, fullPath, encoding as string);
|
|
}
|
|
}
|
|
} else {
|
|
for (const entry of entries!){
|
|
const entryPath = entry.path;
|
|
const fullPath = `${targetPath}/${entryPath}`;
|
|
if (!fs3.accessSync(fullPath) || !fs3.statSync(fullPath).isFile()) {
|
|
continue;
|
|
}
|
|
readFileSync(entryPath, fullPath, entry.encoding as string);
|
|
}
|
|
}
|
|
cb.success({
|
|
entries: entriesResult,
|
|
result: entriesResult,
|
|
errMsg: okMsg
|
|
} as EntriesResult);
|
|
} catch (err) {
|
|
cb.fail({
|
|
errMsg: `${errMsg} ${(err as Error).message}`
|
|
} as FileManagerSuccessResult);
|
|
}
|
|
},
|
|
fail: cb.fail,
|
|
complete: null
|
|
} as UnzipFileOptions);
|
|
}).catch((err: BusinessError5)=>{
|
|
cb.fail(getApiError((err as BusinessError5).code, errMsg));
|
|
});
|
|
}
|
|
readCompressedFile(options: ReadCompressedFileOptions): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
readCompressedFileSync(filePath: string, compressionAlgorithm: string): string {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
}
|
|
const getFileSystemManager = defineSyncApi<FileSystemManager>(GET_FILE_SYSTEM_MANAGER, ()=>{
|
|
return new FileSystemManagerImpl();
|
|
});
|
|
const AUTHORIZED = 'authorized';
|
|
const DENIED = 'denied';
|
|
const NOT_DETERMINED = 'not determined';
|
|
class AppAuthorizeSetting {
|
|
albumAuthorized: string = NOT_DETERMINED;
|
|
bluetoothAuthorized: string = NOT_DETERMINED;
|
|
cameraAuthorized: string = NOT_DETERMINED;
|
|
locationAuthorized: string = NOT_DETERMINED;
|
|
locationAccuracy: string = NOT_DETERMINED;
|
|
microphoneAuthorized: string = NOT_DETERMINED;
|
|
notificationAuthorized: string = NOT_DETERMINED;
|
|
notificationAlertAuthorized: string = NOT_DETERMINED;
|
|
notificationBadgeAuthorized: string = NOT_DETERMINED;
|
|
notificationSoundAuthorized: string = NOT_DETERMINED;
|
|
phoneCalendarAuthorized: string = NOT_DETERMINED;
|
|
}
|
|
class GetAppAuthorizeSettingImpl {
|
|
accessTokenId: number;
|
|
atManager: abilityAccessCtrl.AtManager;
|
|
appAuthorizeSetting: AppAuthorizeSetting;
|
|
constructor(accessTokenId: number, atManager: abilityAccessCtrl.AtManager, appAuthorizeSetting: AppAuthorizeSetting){
|
|
this.accessTokenId = accessTokenId;
|
|
this.atManager = atManager;
|
|
this.appAuthorizeSetting = appAuthorizeSetting;
|
|
this.getAlbumAuthorizeSetting();
|
|
this.getBlueToothAuthorizeSetting();
|
|
this.getCameraAuthorizeSetting();
|
|
this.getLocationAuthorizeSetting();
|
|
this.getMicrophoneAuthorizeSetting();
|
|
this.getNotificationAuthorizeSetting();
|
|
this.getPhoneCalendarAuthorizeSetting();
|
|
}
|
|
getAlbumAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.READ_IMAGEVIDEO');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.albumAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.albumAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
getBlueToothAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.ACCESS_BLUETOOTH');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.bluetoothAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.bluetoothAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
getCameraAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.CAMERA');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.cameraAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.cameraAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
getLocationAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.LOCATION');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.locationAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.locationAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
getMicrophoneAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.MICROPHONE');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.microphoneAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.microphoneAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
getNotificationAuthorizeSetting() {
|
|
try {
|
|
const isNotificationEnabled = notificationManager.isNotificationEnabledSync();
|
|
if (isNotificationEnabled) {
|
|
this.appAuthorizeSetting.notificationAuthorized = DENIED;
|
|
}
|
|
if (isNotificationEnabled) {
|
|
this.appAuthorizeSetting.notificationAuthorized = AUTHORIZED;
|
|
}
|
|
} catch (error) {
|
|
this.appAuthorizeSetting.notificationAuthorized = DENIED;
|
|
}
|
|
}
|
|
getPhoneCalendarAuthorizeSetting() {
|
|
const grantStatus = this.atManager.checkAccessTokenSync(this.accessTokenId, 'ohos.permission.WRITE_CALENDAR');
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_DENIED) {
|
|
this.appAuthorizeSetting.phoneCalendarAuthorized = DENIED;
|
|
}
|
|
if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
|
|
this.appAuthorizeSetting.phoneCalendarAuthorized = AUTHORIZED;
|
|
}
|
|
}
|
|
}
|
|
const getAppAuthorizeSetting: GetAppAuthorizeSetting = defineSyncApi<GetAppAuthorizeSettingResult>('getAppAuthorizeSetting', ()=>{
|
|
const bundleInfoWithApplication = bundleManager.getBundleInfoForSelfSync(bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION);
|
|
const appAuthorizeSettingImpl = new GetAppAuthorizeSettingImpl(bundleInfoWithApplication.appInfo.accessTokenId, abilityAccessCtrl.createAtManager(), new AppAuthorizeSetting());
|
|
return appAuthorizeSettingImpl.appAuthorizeSetting as GetAppAuthorizeSettingResult;
|
|
}) as GetAppAuthorizeSetting;
|
|
const API_GET_APP_BASE_INFO = 'getAppBaseInfo';
|
|
const getBundleInfoOnce = ()=>{
|
|
let bundleInfo: bundleManager1.BundleInfo | null = null;
|
|
return (): bundleManager1.BundleInfo =>{
|
|
if (bundleInfo) {
|
|
return bundleInfo;
|
|
}
|
|
bundleInfo = bundleManager1.getBundleInfoForSelfSync(bundleManager1.BundleFlag.GET_BUNDLE_INFO_DEFAULT);
|
|
return bundleInfo;
|
|
};
|
|
};
|
|
const getBundleInfo = getBundleInfoOnce();
|
|
const getAppBaseInfo: GetAppBaseInfo = defineSyncApi<GetAppBaseInfoResult>(API_GET_APP_BASE_INFO, (): GetAppBaseInfoResult =>{
|
|
const appVersion = UTSHarmony.getAppVersion() as IAppBaseInfoAppVersion;
|
|
const appLanguage = I18n.System.getAppPreferredLanguage();
|
|
const uniCompilerVersion: string = UTSHarmony.getUniCompilerVersion() as string;
|
|
const uniRuntimeVersion: string = UTSHarmony.getUniRuntimeVersion();
|
|
return {
|
|
appId: UTSHarmony.getAppId() as string,
|
|
appLanguage,
|
|
appName: UTSHarmony.getAppName() as string,
|
|
appTheme: UTSHarmony.getAppTheme() as string,
|
|
appVersion: appVersion.name,
|
|
appVersionCode: appVersion.code,
|
|
appWgtVersion: appVersion.name,
|
|
hostLanguage: I18n.System.getSystemLanguage(),
|
|
isUniAppX: UTSHarmony.isUniAppX() as boolean,
|
|
packageName: getBundleInfo().name,
|
|
uniCompilerVersion: uniCompilerVersion,
|
|
uniCompilerVersionCode: parseFloat(uniCompilerVersion),
|
|
uniRuntimeVersion: uniRuntimeVersion,
|
|
uniRuntimeVersionCode: parseFloat(uniRuntimeVersion),
|
|
uniPlatform: 'app'
|
|
} as GetAppBaseInfoResult;
|
|
}) as GetAppBaseInfo;
|
|
const API_GET_BACKGROUND_AUDIO_MANAGER = 'getBackgroundAudioManager';
|
|
const isFileUri2 = (path: string)=>{
|
|
return path && typeof path === 'string' && (path.startsWith('file://') || path.startsWith('datashare://'));
|
|
};
|
|
const isSandboxPath1 = (path: string)=>{
|
|
return path && typeof path === 'string' && path.startsWith('/data/storage/');
|
|
};
|
|
const getFdFromUriOrSandBoxPath1 = (uri: string)=>{
|
|
try {
|
|
const file = fileIo1.openSync(uri, fileIo1.OpenMode.READ_ONLY);
|
|
return file.fd;
|
|
} catch (error) {
|
|
console.info(`[AdvancedAPI] Can not get file from uri: ${uri} `);
|
|
}
|
|
throw new Error('file is not exist');
|
|
};
|
|
const callCallbacks1 = (callbacks: Function[], ...args: Object[])=>{
|
|
callbacks.forEach((cb)=>{
|
|
typeof cb === 'function' && cb(...args);
|
|
});
|
|
};
|
|
const remoteCallback1 = (callbacks: Function[], callback: Function)=>{
|
|
const index = callbacks.indexOf(callback);
|
|
if (index > -1) {
|
|
callbacks.splice(index, 1);
|
|
}
|
|
};
|
|
class AudioPlayerError1 {
|
|
errMsg: string;
|
|
errCode: number;
|
|
constructor(errMsg: string, errCode: number){
|
|
this.errMsg = errMsg;
|
|
this.errCode = errCode;
|
|
}
|
|
}
|
|
class AudioPlayerCallback1 {
|
|
onCanplayCallbacks: Function[] = [];
|
|
onPlayCallbacks: Function[] = [];
|
|
onPauseCallbacks: Function[] = [];
|
|
onStopCallbacks: Function[] = [];
|
|
onEndedCallbacks: Function[] = [];
|
|
onTimeUpdateCallbacks: Function[] = [];
|
|
onErrorCallbacks: Function[] = [];
|
|
onWaitingCallbacks: Function[] = [];
|
|
onSeekingCallbacks: Function[] = [];
|
|
onSeekedCallbacks: Function[] = [];
|
|
constructor(){}
|
|
canPlay() {
|
|
callCallbacks1(this.onCanplayCallbacks);
|
|
}
|
|
onCanplay(callback: Function) {
|
|
this.onCanplayCallbacks.push(callback);
|
|
}
|
|
offCanplay(callback: Function) {
|
|
remoteCallback1(this.onCanplayCallbacks, callback);
|
|
}
|
|
play() {
|
|
callCallbacks1(this.onPlayCallbacks);
|
|
}
|
|
onPlay(callback: Function) {
|
|
this.onPlayCallbacks.push(callback);
|
|
}
|
|
offPlay(callback: Function) {
|
|
remoteCallback1(this.onPlayCallbacks, callback);
|
|
}
|
|
pause() {
|
|
callCallbacks1(this.onPauseCallbacks);
|
|
}
|
|
onPause(callback: Function) {
|
|
this.onPauseCallbacks.push(callback);
|
|
}
|
|
offPause(callback: Function) {
|
|
remoteCallback1(this.onPauseCallbacks, callback);
|
|
}
|
|
stop() {
|
|
callCallbacks1(this.onStopCallbacks);
|
|
}
|
|
onStop(callback: Function) {
|
|
this.onStopCallbacks.push(callback);
|
|
}
|
|
offStop(callback: Function) {
|
|
remoteCallback1(this.onStopCallbacks, callback);
|
|
}
|
|
ended() {
|
|
callCallbacks1(this.onEndedCallbacks);
|
|
}
|
|
onEnded(callback: Function) {
|
|
this.onEndedCallbacks.push(callback);
|
|
}
|
|
offEnded(callback: Function) {
|
|
remoteCallback1(this.onEndedCallbacks, callback);
|
|
}
|
|
timeUpdate(time: number) {
|
|
callCallbacks1(this.onTimeUpdateCallbacks, time);
|
|
}
|
|
onTimeUpdate(callback: Function) {
|
|
this.onTimeUpdateCallbacks.push(callback);
|
|
}
|
|
offTimeUpdate(callback: Function) {
|
|
remoteCallback1(this.onTimeUpdateCallbacks, callback);
|
|
}
|
|
error(res: AudioPlayerError1) {
|
|
callCallbacks1(this.onErrorCallbacks, res);
|
|
}
|
|
onError(callback: Function) {
|
|
this.onErrorCallbacks.push(callback);
|
|
}
|
|
offError(callback: Function) {
|
|
remoteCallback1(this.onErrorCallbacks, callback);
|
|
}
|
|
onPrev(callback: Function) {
|
|
console.info('ios only');
|
|
}
|
|
onNext(callback: Function) {
|
|
console.info('ios only');
|
|
}
|
|
waiting() {
|
|
callCallbacks1(this.onWaitingCallbacks);
|
|
}
|
|
onWaiting(callback: Function) {
|
|
this.onWaitingCallbacks.push(callback);
|
|
}
|
|
offWaiting(callback: Function) {
|
|
remoteCallback1(this.onWaitingCallbacks, callback);
|
|
}
|
|
seeking() {
|
|
callCallbacks1(this.onSeekingCallbacks);
|
|
}
|
|
onSeeking(callback: Function) {
|
|
this.onSeekingCallbacks.push(callback);
|
|
}
|
|
offSeeking(callback: Function) {
|
|
remoteCallback1(this.onSeekingCallbacks, callback);
|
|
}
|
|
seeked() {
|
|
callCallbacks1(this.onSeekedCallbacks);
|
|
}
|
|
onSeeked(callback: Function) {
|
|
this.onSeekedCallbacks.push(callback);
|
|
}
|
|
offSeeked(callback: Function) {
|
|
remoteCallback1(this.onSeekedCallbacks, callback);
|
|
}
|
|
}
|
|
const audioPlayerCallback = new AudioPlayerCallback1();
|
|
let AV_SESSION: avSession.AVSession | null = null;
|
|
const createAVSession = ()=>{
|
|
avSession.createAVSession(UTSHarmony.getUIAbilityContext()!, 'player', 'audio').then((data)=>{
|
|
AV_SESSION = data;
|
|
});
|
|
};
|
|
const destroyAVSession = ()=>{
|
|
if (AV_SESSION === null) {
|
|
return;
|
|
}
|
|
AV_SESSION.destroy();
|
|
AV_SESSION = null;
|
|
};
|
|
const startBackgroundTask = ()=>{
|
|
const abilityInfo = UTSHarmony.getUIAbilityContext()!.abilityInfo as TempAbilityInfo;
|
|
const wantAgentInfo: wantAgent.WantAgentInfo = {
|
|
wants: [
|
|
{
|
|
bundleName: abilityInfo.bundleName,
|
|
abilityName: abilityInfo.name
|
|
}
|
|
],
|
|
operationType: wantAgent.OperationType.START_ABILITY,
|
|
requestCode: 0,
|
|
wantAgentFlags: [
|
|
wantAgent.WantAgentFlags.UPDATE_PRESENT_FLAG
|
|
]
|
|
};
|
|
wantAgent.getWantAgent(wantAgentInfo).then((wantAgentObj)=>{
|
|
return backgroundTaskManager.startBackgroundRunning(UTSHarmony.getUIAbilityContext()!, backgroundTaskManager.BackgroundMode.AUDIO_PLAYBACK, wantAgentObj);
|
|
}).then(()=>{
|
|
console.debug('[getBackgroundAudioManager] start bg operation succeeded');
|
|
}).catch((err: BusinessError6)=>{
|
|
audioPlayerCallback.error(new AudioPlayerError1(err.message, err.code));
|
|
});
|
|
};
|
|
const stopBackgroundTask = ()=>{
|
|
backgroundTaskManager.stopBackgroundRunning(UTSHarmony.getUIAbilityContext()!).then(()=>{
|
|
console.debug('[getBackgroundAudioManager] stop operation succeeded');
|
|
}).catch((err: BusinessError6)=>{
|
|
audioPlayerCallback.error(new AudioPlayerError1(err.message, err.code));
|
|
});
|
|
};
|
|
const START_BACKGROUND = ()=>{
|
|
startBackgroundTask();
|
|
createAVSession();
|
|
};
|
|
const STOP_BACKGROUND = ()=>{
|
|
destroyAVSession();
|
|
stopBackgroundTask();
|
|
};
|
|
const LOG1 = (msg: string)=>console.log(`[getBackgroundAudioManager]: ${msg}`);
|
|
class STATE_TYPE1 {
|
|
static IDLE: string = 'idle';
|
|
static PLAYING: string = 'playing';
|
|
static PAUSED: string = 'paused';
|
|
static STOPPED: string = 'stopped';
|
|
static ERROR: string = 'error';
|
|
}
|
|
class BackgroundAudioManagerImpl implements BackgroundAudioManager {
|
|
static audioPlayer?: media2.AudioPlayer;
|
|
private _src: string = '';
|
|
private _startTime: number = 0;
|
|
private _buffered: number = 0;
|
|
private _title: string = '';
|
|
private _epname: string = '';
|
|
private _singer: string = '';
|
|
private _coverImgUrl: string = '';
|
|
private _webUrl: string = '';
|
|
private _protocol: string = '';
|
|
private _playbackRate: number = 1;
|
|
readonly obeyMuteSwitch: boolean = false;
|
|
constructor(){
|
|
this.init();
|
|
}
|
|
init() {
|
|
BackgroundAudioManagerImpl.audioPlayer = media2.createAudioPlayer();
|
|
BackgroundAudioManagerImpl.audioPlayer.on('dataLoad', ()=>{
|
|
audioPlayerCallback.canPlay();
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('play', ()=>{
|
|
audioPlayerCallback.play();
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('pause', ()=>{
|
|
audioPlayerCallback.pause();
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('finish', ()=>{
|
|
STOP_BACKGROUND();
|
|
audioPlayerCallback.ended();
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('timeUpdate', (res)=>{
|
|
audioPlayerCallback.timeUpdate(res / 1000);
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('error', (err)=>{
|
|
audioPlayerCallback.error(new AudioPlayerError1(err.message, err.code));
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('bufferingUpdate', (infoType, value)=>{
|
|
console.info(`[AdvancedAPI] audioPlayer bufferingUpdate ${infoType} ${value}`);
|
|
if (infoType === media2.BufferingInfoType.BUFFERING_PERCENT && value !== 0 && BackgroundAudioManagerImpl.audioPlayer) {
|
|
this._buffered = value;
|
|
if ((BackgroundAudioManagerImpl.audioPlayer.currentTime / 1000) >= (BackgroundAudioManagerImpl.audioPlayer.duration * value / 100000)) {
|
|
audioPlayerCallback.waiting();
|
|
}
|
|
}
|
|
});
|
|
BackgroundAudioManagerImpl.audioPlayer.on('audioInterrupt', (InterruptEvent)=>{
|
|
console.info('[AdvancedAPI] audioInterrupt:' + JSON.stringify(InterruptEvent));
|
|
if (BackgroundAudioManagerImpl.audioPlayer && InterruptEvent.hintType === audio1.InterruptHint.INTERRUPT_HINT_PAUSE) {
|
|
BackgroundAudioManagerImpl.audioPlayer.pause();
|
|
}
|
|
if (BackgroundAudioManagerImpl.audioPlayer && InterruptEvent.hintType === audio1.InterruptHint.INTERRUPT_HINT_RESUME) {
|
|
BackgroundAudioManagerImpl.audioPlayer.play();
|
|
}
|
|
});
|
|
}
|
|
get duration() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return 0;
|
|
}
|
|
return BackgroundAudioManagerImpl.audioPlayer.duration / 1000;
|
|
}
|
|
get currentTime() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return 0;
|
|
}
|
|
return BackgroundAudioManagerImpl.audioPlayer.currentTime / 1000;
|
|
}
|
|
get paused() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return false;
|
|
}
|
|
return BackgroundAudioManagerImpl.audioPlayer.state === STATE_TYPE1.PAUSED;
|
|
}
|
|
get src() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return '';
|
|
}
|
|
return BackgroundAudioManagerImpl.audioPlayer.src;
|
|
}
|
|
set src(value) {
|
|
if (typeof value !== 'string') {
|
|
audioPlayerCallback.error(new AudioPlayerError1(`set src: ${value} is not string`, 10004));
|
|
return;
|
|
}
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
audioPlayerCallback.error(new AudioPlayerError1(`player is not exist`, 10001));
|
|
return;
|
|
}
|
|
if (!value || !(value.startsWith('http:') || value.startsWith('https:') || isFileUri2(value) || isSandboxPath1(value))) {
|
|
LOG1(`set src: ${value} is invalid`);
|
|
return;
|
|
}
|
|
let path: string = '';
|
|
if (value.startsWith('http:') || value.startsWith('https:')) {
|
|
path = value;
|
|
} else if (isFileUri2(value) || isSandboxPath1(value)) {
|
|
try {
|
|
const fd = getFdFromUriOrSandBoxPath1(value);
|
|
path = `fd://${fd}`;
|
|
} catch (err) {
|
|
audioPlayerCallback.error(new AudioPlayerError1((err as BusinessError6).message, (err as BusinessError6).code));
|
|
}
|
|
}
|
|
if (BackgroundAudioManagerImpl.audioPlayer.src && path !== BackgroundAudioManagerImpl.audioPlayer.src) {
|
|
BackgroundAudioManagerImpl.audioPlayer.reset();
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.src = path;
|
|
this._src = value;
|
|
if (this._startTime) {
|
|
BackgroundAudioManagerImpl.audioPlayer.seek(this._startTime);
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.play();
|
|
START_BACKGROUND();
|
|
}
|
|
get startTime() {
|
|
return this._startTime / 1000;
|
|
}
|
|
set startTime(time: number) {
|
|
this._startTime = time * 1000;
|
|
}
|
|
get title() {
|
|
return this._title;
|
|
}
|
|
set title(titleName: string) {
|
|
this._title = titleName;
|
|
}
|
|
get buffered() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) return 0;
|
|
return BackgroundAudioManagerImpl.audioPlayer.duration * this._buffered / 100000;
|
|
}
|
|
get epname() {
|
|
return this._epname;
|
|
}
|
|
set epname(epName: string) {
|
|
this._epname = epName;
|
|
}
|
|
get singer() {
|
|
return this._singer;
|
|
}
|
|
set singer(singerName: string) {
|
|
this._singer = singerName;
|
|
}
|
|
get coverImgUrl() {
|
|
return this._coverImgUrl;
|
|
}
|
|
set coverImgUrl(url: string) {
|
|
this._coverImgUrl = url;
|
|
}
|
|
get webUrl() {
|
|
return this._webUrl;
|
|
}
|
|
set webUrl(url: string) {
|
|
this._webUrl = url;
|
|
}
|
|
get protocol() {
|
|
return this._protocol;
|
|
}
|
|
set protocol(protocolType: string) {
|
|
this._protocol = protocolType;
|
|
}
|
|
set playbackRate(rate: number) {
|
|
audioPlayerCallback.error(new AudioPlayerError1('HarmonyOS Next Audio setting playbackRate is not supported.', -1));
|
|
}
|
|
get playbackRate() {
|
|
return this._playbackRate;
|
|
}
|
|
play() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return;
|
|
}
|
|
const state = BackgroundAudioManagerImpl.audioPlayer.state;
|
|
if (![
|
|
STATE_TYPE1.PAUSED,
|
|
STATE_TYPE1.STOPPED,
|
|
STATE_TYPE1.IDLE
|
|
].includes(state)) {
|
|
return;
|
|
}
|
|
if (this._src && BackgroundAudioManagerImpl.audioPlayer.src === '') {
|
|
this.src = this._src;
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.play();
|
|
START_BACKGROUND();
|
|
}
|
|
pause() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return;
|
|
}
|
|
const state = BackgroundAudioManagerImpl.audioPlayer.state;
|
|
if (STATE_TYPE1.PLAYING !== state) {
|
|
return;
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.pause();
|
|
}
|
|
stop() {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return;
|
|
}
|
|
if (![
|
|
STATE_TYPE1.PAUSED,
|
|
STATE_TYPE1.PLAYING
|
|
].includes(BackgroundAudioManagerImpl.audioPlayer.state)) {
|
|
return;
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.stop();
|
|
BackgroundAudioManagerImpl.audioPlayer.release();
|
|
this.init();
|
|
STOP_BACKGROUND();
|
|
audioPlayerCallback.stop();
|
|
}
|
|
seek(position: number) {
|
|
if (!BackgroundAudioManagerImpl.audioPlayer) {
|
|
return;
|
|
}
|
|
const state = BackgroundAudioManagerImpl.audioPlayer.state;
|
|
if (![
|
|
STATE_TYPE1.PAUSED,
|
|
STATE_TYPE1.PLAYING
|
|
].includes(state)) {
|
|
return;
|
|
}
|
|
BackgroundAudioManagerImpl.audioPlayer.seek(position * 1000);
|
|
}
|
|
onCanplay(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onCanplay(callback);
|
|
}
|
|
onPlay(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onPlay(callback);
|
|
}
|
|
onPause(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onPause(callback);
|
|
}
|
|
onStop(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onStop(callback);
|
|
}
|
|
onEnded(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onEnded(callback);
|
|
}
|
|
onTimeUpdate(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onTimeUpdate(callback);
|
|
}
|
|
onError(callback: (result: ICreateBackgroundAudioFail) => void): void {
|
|
audioPlayerCallback.onError(callback);
|
|
}
|
|
onWaiting(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.onWaiting(callback);
|
|
}
|
|
offCanplay(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offCanplay(callback);
|
|
}
|
|
offPlay(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offPlay(callback);
|
|
}
|
|
offPause(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offPause(callback);
|
|
}
|
|
offStop(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offStop(callback);
|
|
}
|
|
offEnded(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offEnded(callback);
|
|
}
|
|
offTimeUpdate(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offTimeUpdate(callback);
|
|
}
|
|
offError(callback: (result: ICreateBackgroundAudioFail) => void): void {
|
|
audioPlayerCallback.offError(callback);
|
|
}
|
|
offWaiting(callback: (result: Object) => void): void {
|
|
audioPlayerCallback.offWaiting(callback);
|
|
}
|
|
onPrev(callback: (result: Object) => void): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
onNext(callback: (result: Object) => void): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
onSeeking(callback: (result: Object) => void): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
onSeeked(callback: (result: Object) => void): void {
|
|
throw new Error('Method not implemented.');
|
|
}
|
|
}
|
|
let backgroundAudioManager: BackgroundAudioManager | null = null;
|
|
const getBackgroundAudioManager: GetBackgroundAudioManager = defineSyncApi<BackgroundAudioManager>(API_GET_BACKGROUND_AUDIO_MANAGER, ()=>{
|
|
if (!backgroundAudioManager) backgroundAudioManager = new BackgroundAudioManagerImpl();
|
|
return backgroundAudioManager;
|
|
}) as GetBackgroundAudioManager;
|
|
const API_GET_DEVICE_INFO = 'getDeviceInfo';
|
|
const parseDeviceType = (deviceType: string): 'phone' | 'pad' | 'tv' | 'watch' | 'pc' | 'unknown' | 'car' | 'vr' | 'appliance' =>{
|
|
switch(deviceType){
|
|
case 'phone':
|
|
return 'phone';
|
|
case 'wearable':
|
|
return 'watch';
|
|
case 'tablet':
|
|
return 'pad';
|
|
case '2in1':
|
|
return 'pc';
|
|
case 'tv':
|
|
return 'tv';
|
|
case 'car':
|
|
return 'car';
|
|
case 'smartVision':
|
|
return 'vr';
|
|
default:
|
|
return 'unknown';
|
|
}
|
|
};
|
|
const getDeviceInfo: GetDeviceInfo = defineSyncApi<GetDeviceInfoResult>(API_GET_DEVICE_INFO, (): GetDeviceInfoResult =>{
|
|
return {
|
|
deviceBrand: deviceInfo.brand.toLowerCase(),
|
|
deviceId: getDeviceId(),
|
|
deviceModel: deviceInfo.productModel,
|
|
deviceOrientation: 'portrait',
|
|
devicePixelRatio: vp2px(1),
|
|
deviceType: parseDeviceType(deviceInfo.deviceType),
|
|
osLanguage: I18n1.System.getSystemLanguage(),
|
|
osTheme: UTSHarmony.getOsTheme() as string,
|
|
osVersion: deviceInfo.majorVersion + '.' + deviceInfo.seniorVersion + '.' + deviceInfo.featureVersion + '.' + deviceInfo.buildVersion,
|
|
osName: 'harmonyos',
|
|
platform: 'harmonyos',
|
|
romName: deviceInfo.distributionOSName,
|
|
romVersion: deviceInfo.distributionOSVersion,
|
|
system: deviceInfo.osFullName
|
|
} as GetDeviceInfoResult;
|
|
}) as GetDeviceInfo;
|
|
const API_GET_NETWORK_TYPE = 'getNetworkType';
|
|
const PERMISSIONS1 = [
|
|
'ohos.permission.GET_NETWORK_INFO'
|
|
];
|
|
enum NetworkinfoType {
|
|
UNKNOW = 0,
|
|
NONE = 1,
|
|
ETHERNET = 2,
|
|
WIFI = 3,
|
|
"2G" = 4,
|
|
"3G" = 5,
|
|
"4G" = 6,
|
|
"5G" = 7
|
|
}
|
|
const signalType = (resultObj: radio.NetworkType)=>{
|
|
switch(resultObj){
|
|
case radio.NetworkType.NETWORK_TYPE_GSM:
|
|
case radio.NetworkType.NETWORK_TYPE_CDMA:
|
|
return NetworkinfoType['2G'];
|
|
case radio.NetworkType.NETWORK_TYPE_WCDMA:
|
|
case radio.NetworkType.NETWORK_TYPE_TDSCDMA:
|
|
return NetworkinfoType['3G'];
|
|
case radio.NetworkType.NETWORK_TYPE_LTE:
|
|
return NetworkinfoType['4G'];
|
|
case radio.NetworkType.NETWORK_TYPE_NR:
|
|
return NetworkinfoType['5G'];
|
|
case radio.NetworkType.NETWORK_TYPE_UNKNOWN:
|
|
return NetworkinfoType.UNKNOW;
|
|
default:
|
|
return NetworkinfoType.NONE;
|
|
}
|
|
};
|
|
const networkGetType = ()=>{
|
|
return new Promise<number>((resolve, reject)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS1, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
try {
|
|
radio.getPrimarySlotId().then((slotId: number)=>radio.getSignalInformationSync(slotId)).then((signalInformation: Array<radio.SignalInformation>)=>{
|
|
const data = signalInformation[0];
|
|
if (data && data.signalType) {
|
|
resolve(signalType(data.signalType));
|
|
} else {
|
|
resolve(NetworkinfoType.NONE);
|
|
}
|
|
});
|
|
} catch (error) {
|
|
reject(error as BusinessError7);
|
|
}
|
|
} else {
|
|
reject('permission denied');
|
|
}
|
|
}, ()=>reject('permission denied'));
|
|
});
|
|
};
|
|
class GlobalContext {
|
|
netList: connection.NetHandle[] = [];
|
|
netHandle: connection.NetHandle | null = null;
|
|
private constructor(){}
|
|
private static instance: GlobalContext;
|
|
public static getContext(): GlobalContext {
|
|
if (!GlobalContext.instance) {
|
|
GlobalContext.instance = new GlobalContext();
|
|
}
|
|
return GlobalContext.instance;
|
|
}
|
|
}
|
|
const getCurrentType = ()=>{
|
|
return new Promise<number>((resolve, reject)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS1, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
try {
|
|
connection.getDefaultNet().then((data: connection.NetHandle)=>{
|
|
if (data) {
|
|
GlobalContext.getContext().netHandle = data;
|
|
connection.getNetCapabilities(GlobalContext.getContext().netHandle!).then((data: connection.NetCapabilities)=>{
|
|
const bearerTypes: Set<number> = new Set(data.bearerTypes);
|
|
const bearerTypesNum = Array.from(bearerTypes.values());
|
|
for (const item of bearerTypesNum){
|
|
if (item == connection.NetBearType.BEARER_CELLULAR) {
|
|
networkGetType().then(resolve).catch(reject);
|
|
} else if (item == connection.NetBearType.BEARER_WIFI) {
|
|
resolve(NetworkinfoType.WIFI);
|
|
} else if (item == connection.NetBearType.BEARER_ETHERNET) {
|
|
resolve(NetworkinfoType.ETHERNET);
|
|
} else {
|
|
resolve(NetworkinfoType.UNKNOW);
|
|
}
|
|
}
|
|
}).catch((err: BusinessError7)=>{
|
|
reject(err);
|
|
});
|
|
}
|
|
});
|
|
} catch (error) {
|
|
reject(error);
|
|
}
|
|
} else {
|
|
reject('permission denied');
|
|
}
|
|
});
|
|
});
|
|
};
|
|
class Network {
|
|
static netConnection: connection.NetConnection | null = null;
|
|
constructor(){
|
|
Network.netConnection = connection.createNetConnection();
|
|
}
|
|
static ohoSubscribe() {
|
|
if (!Network.netConnection) {
|
|
Network.netConnection = connection.createNetConnection();
|
|
}
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS1, (allRight: boolean)=>{
|
|
if (allRight && Network.netConnection) {
|
|
Network.netConnection.register((err: BusinessError7)=>{});
|
|
Network.netConnection.on('netCapabilitiesChange', (capability: connection.NetCapabilityInfo)=>{
|
|
const NetBearType = capability?.netCap?.bearerTypes[0];
|
|
let networkType = '';
|
|
switch(NetBearType){
|
|
case connection.NetBearType.BEARER_CELLULAR:
|
|
getCurrentType().then((type: number)=>{
|
|
invokeOnNetworkStatusChange(NetworkinfoType[type]);
|
|
}).catch(()=>{
|
|
invokeOnNetworkStatusChange(NetworkinfoType[1]);
|
|
});
|
|
return;
|
|
case connection.NetBearType.BEARER_WIFI:
|
|
networkType = NetworkinfoType[3];
|
|
break;
|
|
case connection.NetBearType.BEARER_ETHERNET:
|
|
networkType = NetworkinfoType[2];
|
|
break;
|
|
default:
|
|
networkType = NetworkinfoType[1];
|
|
}
|
|
invokeOnNetworkStatusChange(networkType);
|
|
});
|
|
Network.netConnection.on('netLost', (netLost: connection.NetHandle)=>{
|
|
invokeOnNetworkStatusChange(NetworkinfoType[1]);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
new Network();
|
|
onNativePageReady().then(()=>{
|
|
Network.ohoSubscribe();
|
|
});
|
|
const getNetworkType: GetNetworkType = defineAsyncApi<GetNetworkTypeOptions, GetNetworkTypeSuccess>(API_GET_NETWORK_TYPE, (options: GetNetworkTypeOptions, res: ApiExecutor<GetNetworkTypeSuccess>)=>{
|
|
getCurrentType().then((type: number)=>{
|
|
res.resolve({
|
|
networkType: NetworkinfoType[type].toLocaleLowerCase()
|
|
} as GetNetworkTypeSuccess);
|
|
}).catch((err: BusinessError7)=>{
|
|
if (err.code === 2100001) {
|
|
res.resolve({
|
|
networkType: NetworkinfoType[1].toLocaleLowerCase()
|
|
} as GetNetworkTypeSuccess);
|
|
} else {
|
|
res.reject(err.message);
|
|
}
|
|
});
|
|
}) as GetNetworkType;
|
|
const invokeOnNetworkStatusChange = (networkType: string)=>{
|
|
UniGetNetworkTypeEventEmitter.emit('networkStatusChange', {
|
|
isConnected: networkType !== NetworkinfoType[1],
|
|
networkType: networkType.toLocaleLowerCase()
|
|
} as OnNetworkStatusChangeCallbackResult);
|
|
};
|
|
const UniGetNetworkTypeEventEmitter = new Emitter1() as IUniGetNetworkTypeEventEmitter;
|
|
const onNetworkStatusChange: OnNetworkStatusChange = (callback: Function)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS1, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
UniGetNetworkTypeEventEmitter.on('networkStatusChange', callback);
|
|
}
|
|
});
|
|
};
|
|
const offNetworkStatusChange: OffNetworkStatusChange = (callback: Function)=>{
|
|
UTSHarmony.requestSystemPermission(PERMISSIONS1, (allRight: boolean)=>{
|
|
if (allRight) {
|
|
UniGetNetworkTypeEventEmitter.off('networkStatusChange', callback);
|
|
}
|
|
});
|
|
};
|
|
const API_GET_PROVIDER = 'getProvider';
|
|
const API_GET_PROVIDER_SYNC = 'getProviderSync';
|
|
const SupportedProviderServiceList = [
|
|
'oauth',
|
|
'share',
|
|
'payment',
|
|
'push',
|
|
'location'
|
|
];
|
|
const _getProviderSync = (options: GetProviderOptions)=>{
|
|
if (!SupportedProviderServiceList.includes(options.service)) {
|
|
return 'Parameter service invalid.';
|
|
}
|
|
const providers = getUniProviders(options.service);
|
|
const providerIds = providers.map((provider): string =>{
|
|
return provider.id;
|
|
});
|
|
const result: GetProviderSuccess = {
|
|
service: options.service,
|
|
provider: providerIds,
|
|
providers
|
|
};
|
|
return result;
|
|
};
|
|
const getProvider: GetProvider = defineAsyncApi<GetProviderOptions, GetProviderSuccess>(API_GET_PROVIDER, (options: GetProviderOptions, exec: ApiExecutor<GetProviderSuccess>): void =>{
|
|
const res = _getProviderSync(options);
|
|
if (typeof res === 'string') exec.reject(res);
|
|
else exec.resolve(res);
|
|
}) as GetProvider;
|
|
const getProviderSync: GetProviderSync = defineSyncApi<GetProviderSyncSuccess>(API_GET_PROVIDER_SYNC, (options: GetProviderSyncOptions): GetProviderSyncSuccess =>{
|
|
const res = _getProviderSync(options as GetProviderOptions);
|
|
if (typeof res === 'string') throw new Error(res);
|
|
return {
|
|
service: res.service,
|
|
providerIds: res.provider,
|
|
providerObjects: res.providers
|
|
} as GetProviderSyncSuccess;
|
|
}) as GetProviderSync;
|
|
const API_GET_RECORDER_MANAGER = 'getRecorderManager';
|
|
const callbacks: Callbacks = {
|
|
pause: undefined,
|
|
resume: undefined,
|
|
start: undefined,
|
|
stop: undefined,
|
|
error: undefined,
|
|
frameRecorded: undefined,
|
|
interruptionBegin: undefined,
|
|
interruptionEnd: undefined
|
|
};
|
|
const setRecordStateCallback = (state: RecorderState, cb: Function)=>{
|
|
switch(state){
|
|
case 'pause':
|
|
callbacks.pause = cb;
|
|
break;
|
|
case 'resume':
|
|
callbacks.resume = cb;
|
|
break;
|
|
case 'start':
|
|
callbacks.start = cb;
|
|
break;
|
|
case 'stop':
|
|
callbacks.stop = cb;
|
|
break;
|
|
case 'error':
|
|
callbacks.error = cb;
|
|
break;
|
|
case 'frameRecorded':
|
|
callbacks.frameRecorded = cb;
|
|
break;
|
|
case 'interruptionBegin':
|
|
callbacks.interruptionBegin = cb;
|
|
break;
|
|
case 'interruptionEnd':
|
|
callbacks.interruptionEnd = cb;
|
|
break;
|
|
}
|
|
};
|
|
const onRecorderStateChange = (state: RecorderState, res: StateChangeRes | null = null): void =>{
|
|
switch(state){
|
|
case 'pause':
|
|
return callbacks.pause?.(res);
|
|
case 'resume':
|
|
return callbacks.resume?.(res);
|
|
case 'start':
|
|
return callbacks.start?.(res);
|
|
case 'stop':
|
|
return callbacks.stop?.(res);
|
|
case 'error':
|
|
return callbacks.error?.(res);
|
|
case 'frameRecorded':
|
|
return callbacks.frameRecorded?.(res);
|
|
case 'interruptionBegin':
|
|
return callbacks.interruptionBegin?.(res);
|
|
case 'interruptionEnd':
|
|
return callbacks.interruptionEnd?.(res);
|
|
}
|
|
};
|
|
const createFile = (supportFormats: string[], format: string, defaultExt: string)=>{
|
|
const TEMP_PATH = getEnv3().TEMP_PATH as string;
|
|
const filePath = `${TEMP_PATH}/recorder/`;
|
|
if (!fileIo2.accessSync(filePath)) {
|
|
fileIo2.mkdirSync(filePath, true);
|
|
}
|
|
const fileName = `${Date.now()}.${supportFormats.includes(format ?? '') ? format?.toLocaleLowerCase() : defaultExt}`;
|
|
const file: fileIo2.File = fileIo2.openSync(`${filePath}${fileName}`, fileIo2.OpenMode.READ_WRITE | fileIo2.OpenMode.CREATE);
|
|
return file;
|
|
};
|
|
const permissionDenied = ()=>{
|
|
throw new Error('Permission MICROPHONE denied');
|
|
};
|
|
const supportFormats = [
|
|
'aac'
|
|
];
|
|
class AVRecorder implements RecorderManager {
|
|
private avRecorder?: media3.AVRecorder;
|
|
private isFirstStart: boolean = true;
|
|
constructor(){}
|
|
private onStateChange(file: fileIo3.File) {
|
|
if (this.avRecorder) {
|
|
this.avRecorder.on('stateChange', async (state, reason)=>{
|
|
switch(state){
|
|
case 'idle':
|
|
this.isFirstStart = true;
|
|
break;
|
|
case 'started':
|
|
if (this.isFirstStart) {
|
|
this.isFirstStart = false;
|
|
onRecorderStateChange('start');
|
|
} else {
|
|
if (reason === media3.StateChangeReason.BACKGROUND) {
|
|
onRecorderStateChange('interruptionEnd');
|
|
}
|
|
onRecorderStateChange('resume');
|
|
}
|
|
break;
|
|
case 'paused':
|
|
if (reason === media3.StateChangeReason.BACKGROUND) {
|
|
onRecorderStateChange('interruptionBegin');
|
|
}
|
|
onRecorderStateChange('pause');
|
|
break;
|
|
case 'stopped':
|
|
onRecorderStateChange('stop', {
|
|
tempFilePath: file.path
|
|
} as StateChangeRes);
|
|
fileIo3.closeSync(file);
|
|
break;
|
|
}
|
|
});
|
|
this.avRecorder.on('error', (err: BusinessError8)=>{
|
|
onRecorderStateChange('error', {
|
|
errMsg: `${err.message} ${err.code}`
|
|
} as StateChangeRes);
|
|
});
|
|
}
|
|
}
|
|
private async release() {
|
|
if (this.avRecorder !== undefined) {
|
|
await this.avRecorder.reset();
|
|
await this.avRecorder.release();
|
|
this.avRecorder = undefined;
|
|
}
|
|
}
|
|
async start(options: RecorderManagerStartOptions): Promise<void> {
|
|
if (this.avRecorder !== undefined) {
|
|
await this.release();
|
|
}
|
|
this.avRecorder = await media3.createAVRecorder();
|
|
const _options_sampleRate = options.sampleRate, sampleRate = _options_sampleRate == null ? 48000 : _options_sampleRate, _options_numberOfChannels = options.numberOfChannels, numberOfChannels = _options_numberOfChannels == null ? 2 : _options_numberOfChannels, _options_encodeBitRate = options.encodeBitRate, encodeBitRate = _options_encodeBitRate == null ? 48000 : _options_encodeBitRate, _options_duration = options.duration, duration = _options_duration == null ? null : _options_duration;
|
|
const file = createFile(supportFormats, options.format ?? '', 'aac');
|
|
this.onStateChange(file);
|
|
const audioProfile: media3.AVRecorderProfile = {
|
|
audioBitrate: encodeBitRate!,
|
|
audioChannels: numberOfChannels!,
|
|
audioCodec: media3.CodecMimeType.AUDIO_AAC,
|
|
audioSampleRate: sampleRate!,
|
|
fileFormat: media3.ContainerFormatType.CFT_MPEG_4A
|
|
};
|
|
const audioConfig: media3.AVRecorderConfig = {
|
|
audioSourceType: media3.AudioSourceType.AUDIO_SOURCE_TYPE_MIC,
|
|
profile: audioProfile,
|
|
url: 'fd://' + file.fd
|
|
};
|
|
UTSHarmony.requestSystemPermission([
|
|
'ohos.permission.MICROPHONE'
|
|
], async (allRight: boolean)=>{
|
|
if (allRight) {
|
|
await this.avRecorder?.prepare(audioConfig);
|
|
await this.avRecorder?.start();
|
|
if (duration) {
|
|
setTimeout(async ()=>{
|
|
await this.avRecorder?.stop();
|
|
}, duration);
|
|
}
|
|
} else {
|
|
permissionDenied();
|
|
}
|
|
}, permissionDenied);
|
|
}
|
|
async pause(): Promise<void> {
|
|
if (this.avRecorder !== undefined && this.avRecorder.state === 'started') {
|
|
await this.avRecorder.pause();
|
|
}
|
|
}
|
|
async resume(): Promise<void> {
|
|
if (this.avRecorder !== undefined && this.avRecorder.state === 'paused') {
|
|
await this.avRecorder.resume();
|
|
}
|
|
}
|
|
async stop(): Promise<void> {
|
|
if (this.avRecorder !== undefined && (this.avRecorder.state === 'started' || this.avRecorder.state === 'paused')) {
|
|
await this.avRecorder.stop();
|
|
await this.release();
|
|
this.isFirstStart = true;
|
|
}
|
|
}
|
|
onStart(options: (result: Object) => void): void {
|
|
setRecordStateCallback('start', options);
|
|
}
|
|
onPause(options: (result: Object) => void): void {
|
|
setRecordStateCallback('pause', options);
|
|
}
|
|
onStop(options: (result: RecorderManagerOnStopResult) => void): void {
|
|
setRecordStateCallback('stop', options);
|
|
}
|
|
onFrameRecorded(options: (result: Object) => void): void {
|
|
setRecordStateCallback('frameRecorded', options);
|
|
}
|
|
onError(options: (result: Object) => void): void {
|
|
setRecordStateCallback('error', options);
|
|
}
|
|
onResume(options: (result: Object) => void): void {
|
|
setRecordStateCallback('resume', options);
|
|
}
|
|
onInterruptionBegin(options: (result: Object) => void): void {
|
|
setRecordStateCallback('interruptionBegin', options);
|
|
}
|
|
onInterruptionEnd(options: (result: Object) => void): void {
|
|
setRecordStateCallback('interruptionEnd', options);
|
|
}
|
|
}
|
|
let RECORDER_MANAGER: AVRecorder | null = null;
|
|
const DEFAULT_DURATION = 60000;
|
|
const MAX_DURATION = 60000 * 10;
|
|
const DEFAULT_FORMAT = 'aac';
|
|
class RecorderManagerImpl implements RecorderManager {
|
|
start(options: RecorderManagerStartOptions | null = null): void {
|
|
if (options == null) options = {} as RecorderManagerStartOptions;
|
|
if (!options.format) options.format = DEFAULT_FORMAT;
|
|
if (options.duration == null) {
|
|
options.duration = DEFAULT_DURATION;
|
|
}
|
|
if (options.duration > MAX_DURATION) {
|
|
options.duration = MAX_DURATION;
|
|
}
|
|
if (supportFormats.includes(options.format ?? '')) {
|
|
RECORDER_MANAGER = new AVRecorder();
|
|
}
|
|
if (RECORDER_MANAGER) {
|
|
RECORDER_MANAGER.start(options);
|
|
} else {
|
|
onRecorderStateChange('error', {
|
|
errMsg: `format not supported. Only supported ${supportFormats.join(',')}`
|
|
} as StateChangeRes);
|
|
}
|
|
}
|
|
pause(): void {
|
|
if (RECORDER_MANAGER) RECORDER_MANAGER.pause();
|
|
}
|
|
resume(): void {
|
|
if (RECORDER_MANAGER) RECORDER_MANAGER.resume();
|
|
}
|
|
async stop() {
|
|
if (RECORDER_MANAGER) {
|
|
try {
|
|
await RECORDER_MANAGER.stop();
|
|
} catch (error) {}
|
|
RECORDER_MANAGER = null;
|
|
}
|
|
}
|
|
onStart(options: (result: Object) => void): void {
|
|
setRecordStateCallback('start', options);
|
|
}
|
|
onPause(options: (result: Object) => void): void {
|
|
setRecordStateCallback('pause', options);
|
|
}
|
|
onStop(options: (result: RecorderManagerOnStopResult) => void): void {
|
|
setRecordStateCallback('stop', options);
|
|
}
|
|
onFrameRecorded(options: (result: Object) => void): void {
|
|
setRecordStateCallback('frameRecorded', options);
|
|
}
|
|
onError(options: (result: Object) => void): void {
|
|
setRecordStateCallback('error', options);
|
|
}
|
|
onResume(options: (result: Object) => void): void {
|
|
setRecordStateCallback('resume', options);
|
|
}
|
|
onInterruptionBegin(options: (result: Object) => void): void {
|
|
setRecordStateCallback('interruptionBegin', options);
|
|
}
|
|
onInterruptionEnd(options: (result: Object) => void): void {
|
|
setRecordStateCallback('interruptionEnd', options);
|
|
}
|
|
}
|
|
let recorderManager: RecorderManager | null = null;
|
|
const getRecorderManager: GetRecorderManager = defineSyncApi<RecorderManager>(API_GET_RECORDER_MANAGER, (): RecorderManager =>{
|
|
if (recorderManager) return recorderManager;
|
|
else recorderManager = new RecorderManagerImpl();
|
|
return recorderManager;
|
|
}) as GetRecorderManager;
|
|
const API_GET_SYSTEM_INFO = 'getSystemInfo';
|
|
const API_GET_SYSTEM_INFO_SYNC = 'getSystemInfoSync';
|
|
const API_GET_WINDOW_INFO = 'getWindowInfo';
|
|
const parseDeviceType1 = (deviceType: string): 'phone' | 'pad' | 'tv' | 'watch' | 'pc' | 'unknown' | 'car' | 'vr' | 'appliance' =>{
|
|
switch(deviceType){
|
|
case 'phone':
|
|
return 'phone';
|
|
case 'wearable':
|
|
return 'watch';
|
|
case 'tablet':
|
|
return 'pad';
|
|
case '2in1':
|
|
return 'pc';
|
|
case 'tv':
|
|
return 'tv';
|
|
case 'car':
|
|
return 'car';
|
|
case 'smartVision':
|
|
return 'vr';
|
|
default:
|
|
return 'unknown';
|
|
}
|
|
};
|
|
const getWindowInfo: GetWindowInfo = defineSyncApi<GetWindowInfoResult>(API_GET_WINDOW_INFO, (): GetWindowInfoResult =>{
|
|
return internalGetWindowInfo() as GetWindowInfoResult;
|
|
}) as GetWindowInfo;
|
|
const internalGetSystemInfo = (): GetSystemInfoResult =>{
|
|
const appVersion = UTSHarmony.getAppVersion() as ISystemInfoAppVersion;
|
|
const appLanguage = I18n2.System.getAppPreferredLanguage();
|
|
const uniCompilerVersion: string = UTSHarmony.getUniCompilerVersion() as string;
|
|
const uniCompilerVersionCode: number = parseFloat(uniCompilerVersion);
|
|
const uniRuntimeVersion: string = UTSHarmony.getUniRuntimeVersion();
|
|
const windowInfo = internalGetWindowInfo() as GetWindowInfoResult;
|
|
const pixelRatio = windowInfo.pixelRatio;
|
|
const safeArea = windowInfo.safeArea;
|
|
const safeAreaInsets = windowInfo.safeAreaInsets;
|
|
const screenHeight = windowInfo.screenHeight;
|
|
const screenWidth = windowInfo.screenWidth;
|
|
const statusBarHeight = windowInfo.statusBarHeight;
|
|
const windowBottom = windowInfo.windowBottom;
|
|
const windowHeight = windowInfo.windowHeight;
|
|
const windowTop = windowInfo.windowTop;
|
|
const windowWidth = windowInfo.windowWidth;
|
|
return {
|
|
appId: UTSHarmony.getAppId() as string,
|
|
appLanguage,
|
|
appName: UTSHarmony.getAppName() as string,
|
|
appTheme: UTSHarmony.getAppTheme() as string,
|
|
appVersion: appVersion.name,
|
|
appVersionCode: appVersion.code,
|
|
appWgtVersion: appVersion.name,
|
|
uniCompilerVersion: uniCompilerVersion,
|
|
uniCompilerVersionCode: uniCompilerVersionCode,
|
|
uniRuntimeVersion: uniRuntimeVersion,
|
|
uniRuntimeVersionCode: parseFloat(uniRuntimeVersion),
|
|
uniPlatform: 'app',
|
|
deviceBrand: deviceInfo1.brand.toLowerCase(),
|
|
deviceId: getDeviceId1(),
|
|
deviceModel: deviceInfo1.productModel,
|
|
deviceOrientation: 'portrait',
|
|
devicePixelRatio: vp2px(1),
|
|
deviceType: parseDeviceType1(deviceInfo1.deviceType),
|
|
osLanguage: I18n2.System.getSystemLanguage(),
|
|
osTheme: UTSHarmony.getOsTheme() as string,
|
|
osVersion: deviceInfo1.majorVersion + '.' + deviceInfo1.seniorVersion + '.' + deviceInfo1.featureVersion + '.' + deviceInfo1.buildVersion,
|
|
osName: 'harmonyos',
|
|
romName: deviceInfo1.distributionOSName,
|
|
romVersion: deviceInfo1.distributionOSVersion,
|
|
system: deviceInfo1.osFullName,
|
|
pixelRatio,
|
|
safeArea,
|
|
safeAreaInsets,
|
|
screenHeight,
|
|
screenWidth,
|
|
statusBarHeight,
|
|
windowBottom,
|
|
windowHeight,
|
|
windowTop,
|
|
windowWidth,
|
|
SDKVersion: '',
|
|
browserName: '',
|
|
browserVersion: '',
|
|
ua: '',
|
|
language: appLanguage,
|
|
brand: deviceInfo1.brand,
|
|
model: '',
|
|
platform: 'harmonyos',
|
|
uniCompileVersion: uniCompilerVersion,
|
|
uniCompileVersionCode: uniCompilerVersionCode,
|
|
version: ''
|
|
} as GetSystemInfoResult;
|
|
};
|
|
const getSystemInfoSync: GetSystemInfoSync = defineSyncApi<GetSystemInfoResult>(API_GET_SYSTEM_INFO_SYNC, (): GetSystemInfoResult =>{
|
|
return internalGetSystemInfo();
|
|
}) as GetSystemInfoSync;
|
|
const getSystemInfo: GetSystemInfo = defineAsyncApi<GetSystemInfoOptions, GetSystemInfoResult>(API_GET_SYSTEM_INFO, (options: GetSystemInfoOptions, exec: ApiExecutor<GetSystemInfoResult>)=>{
|
|
try {
|
|
exec.resolve(internalGetSystemInfo());
|
|
} catch (error) {
|
|
exec.reject((error as Error).message);
|
|
}
|
|
}) as GetSystemInfo;
|
|
const getSystemSetting: GetSystemSetting = defineSyncApi<GetSystemSettingResult>('getSystemSetting', (): GetSystemSettingResult =>{
|
|
const defaultDisplay = display.getDefaultDisplaySync();
|
|
const res: GetSystemSettingResult = {
|
|
bluetoothEnabled: false,
|
|
bluetoothError: null,
|
|
locationEnabled: false,
|
|
wifiEnabled: false,
|
|
wifiError: null,
|
|
deviceOrientation: (defaultDisplay.orientation === display.Orientation.PORTRAIT || defaultDisplay.orientation === display.Orientation.PORTRAIT_INVERTED) ? 'portrait' : 'landscape'
|
|
};
|
|
try {
|
|
if (access.getState() === access.BluetoothState.STATE_ON) res.bluetoothEnabled = true;
|
|
} catch (err) {
|
|
res.bluetoothError = (err as BusinessError9).message;
|
|
}
|
|
try {
|
|
res.locationEnabled = geoLocationManager.isLocationEnabled();
|
|
} catch (err) {}
|
|
try {
|
|
res.wifiEnabled = wifiManager.isWifiActive();
|
|
} catch (err) {
|
|
res.wifiError = (err as BusinessError9).message;
|
|
}
|
|
return res;
|
|
}) as GetSystemSetting;
|
|
const API_HIDE_KEYBOARD = 'hideKeyboard';
|
|
const hideKeyboard: HideKeyboard = defineAsyncApi<HideKeyboardOptions, HideKeyboardSuccess>(API_HIDE_KEYBOARD, (options: HideKeyboardOptions, exec: ApiExecutor<HideKeyboardSuccess>)=>{
|
|
inputMethod.getController().hideTextInput().then(()=>{
|
|
exec.resolve();
|
|
}, (err: Error)=>{
|
|
exec.reject(err.message);
|
|
});
|
|
}) as HideKeyboard;
|
|
const API_MAKE_PHONE_CALL = 'makePhoneCall';
|
|
const MakePhoneCallProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'phoneNumber',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const isPromise = (res: Object)=>{
|
|
if ((typeof res === "object" || typeof res === "function") && typeof (res as Promise<void>).then === "function") {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
const dial = (number: string, confirm = true)=>{
|
|
if (!confirm && typeof call.dial === 'function') {
|
|
return new Promise<void>((resolve, reject)=>{
|
|
UTSHarmony.requestSystemPermission([
|
|
'ohos.permission.PLACE_CALL'
|
|
], (allRight: boolean)=>{
|
|
if (allRight) {
|
|
call.dial(number).then(()=>{
|
|
resolve();
|
|
}).catch(reject);
|
|
} else {
|
|
reject('permission denied');
|
|
}
|
|
}, ()=>{
|
|
reject('permission denied');
|
|
});
|
|
});
|
|
} else {
|
|
return call.makeCall(number);
|
|
}
|
|
};
|
|
const makePhoneCall: MakePhoneCall = defineAsyncApi<MakePhoneCallOptions, MakePhoneCallSuccess>(API_MAKE_PHONE_CALL, (options: MakePhoneCallOptions, res: ApiExecutor<MakePhoneCallSuccess>)=>{
|
|
const dialRes = dial(options.phoneNumber) as Object as Promise<void>;
|
|
if (isPromise(dialRes)) {
|
|
dialRes.then(res.resolve).catch((err: BusinessError10<void>)=>{
|
|
res.reject(err.message);
|
|
});
|
|
} else {
|
|
res.resolve();
|
|
}
|
|
}, MakePhoneCallProtocol) as MakePhoneCall;
|
|
const API_GET_IMAGE_INFO = 'getImageInfo';
|
|
const GetImageInfoApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'src',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const GetImageInfoApiOptions: ApiOptions<GetImageInfoOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'src',
|
|
(src: string, params: GetImageInfoOptions)=>{
|
|
params.src = getRealPath2(src);
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_CHOOSE_IMAGE = 'chooseImage';
|
|
const ChooseImageApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'count',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'sizeType',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const ChooseImageApiOptions: ApiOptions<ChooseImageOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'count',
|
|
(count: number, params: ChooseImageOptions)=>{
|
|
if (count == null) {
|
|
params.count = 9;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'sizeType',
|
|
(sizeType: string[], params: ChooseImageOptions)=>{
|
|
if (sizeType == null) {
|
|
params.sizeType = [
|
|
'original',
|
|
'compressed'
|
|
];
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
(sourceType: string[], params: ChooseImageOptions)=>{
|
|
if (sourceType == null) {
|
|
params.sourceType = [
|
|
'album',
|
|
'camera'
|
|
];
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
(extension: string[], params: ChooseImageOptions)=>{
|
|
if (extension == null) {
|
|
params.extension = [
|
|
'*'
|
|
];
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_GET_VIDEO_INFO = 'getVideoInfo';
|
|
const GetVideoInfoApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'src',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const GetVideoInfoApiOptions: ApiOptions<GetVideoInfoOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'src',
|
|
(src: string, params: GetVideoInfoOptions)=>{
|
|
params.src = getRealPath2(src);
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_CHOOSE_VIDEO = 'chooseVideo';
|
|
const ChooseVideoApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'sourceType',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'compressed',
|
|
{
|
|
type: 'boolean',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'maxDuration',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'camera',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
{
|
|
type: 'array',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const ChooseVideoApiOptions: ApiOptions<ChooseVideoOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'sourceType',
|
|
(sourceType: string[], params: ChooseVideoOptions)=>{
|
|
if (sourceType == null) {
|
|
params.sourceType = [
|
|
'album',
|
|
'camera'
|
|
];
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'compressed',
|
|
(compressed: boolean, params: ChooseVideoOptions)=>{
|
|
if (compressed == null) {
|
|
params.compressed = true;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'maxDuration',
|
|
(maxDuration: number, params: ChooseVideoOptions)=>{
|
|
if (maxDuration == null) {
|
|
params.maxDuration = 60;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'camera',
|
|
(camera: string, params: ChooseVideoOptions)=>{
|
|
if (camera == null) {
|
|
params.camera = 'back';
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
(extension: string[], params: ChooseVideoOptions)=>{
|
|
if (extension == null) {
|
|
params.extension = [
|
|
'*'
|
|
];
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_PREVIEW_IMAGE = 'previewImage';
|
|
const PreviewImageApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'urls',
|
|
{
|
|
type: 'array',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'current',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const PreviewImageApiOptions: ApiOptions<PreviewImageOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'urls',
|
|
(urls: string[], params: PreviewImageOptions)=>{
|
|
params.urls = urls.map((url)=>getRealPath2(url) as string);
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_CLOSE_PREVIEW_IMAGE = 'closePreviewImage';
|
|
const API_SAVE_IMAGE_TO_PHOTOS_ALBUM = 'saveImageToPhotosAlbum';
|
|
const SaveImageToPhotosAlbumApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'filePath',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const API_SAVE_VIDEO_TO_PHOTOS_ALBUM = 'saveVideoToPhotosAlbum';
|
|
const SaveVideoToPhotosAlbumApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'filePath',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const CompressImageApiOptions: ApiOptions<CompressImageOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'src',
|
|
(src: string, params: CompressImageOptions)=>{
|
|
if (src) params.src = getRealPath2(src);
|
|
}
|
|
],
|
|
[
|
|
'quality',
|
|
(quality: number, params: CompressImageOptions)=>{
|
|
if (quality == null) {
|
|
params.quality = 80;
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const CompressImageApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'src',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'quality',
|
|
{
|
|
type: 'number'
|
|
}
|
|
],
|
|
[
|
|
'compressedWidth',
|
|
{
|
|
type: 'number'
|
|
}
|
|
],
|
|
[
|
|
'compressedHeight',
|
|
{
|
|
type: 'number'
|
|
}
|
|
]
|
|
]);
|
|
const API_CHOOSE_FILE = 'chooseFile';
|
|
const CHOOSE_MEDIA_TYPE: string[] = [
|
|
'all',
|
|
'image',
|
|
'video'
|
|
];
|
|
const CHOOSE_FILE_SOURCE_TYPE: string[] = [
|
|
'album',
|
|
'camera'
|
|
];
|
|
const ChooseFileApiOptions: ApiOptions<ChooseFileOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'count',
|
|
(count: number, params: ChooseFileOptions)=>{
|
|
if (!count || count <= 0) {
|
|
params.count = 100;
|
|
}
|
|
return undefined;
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
(sourceType: string[] = [], params: ChooseFileOptions)=>{
|
|
sourceType = sourceType.filter((type)=>CHOOSE_FILE_SOURCE_TYPE.includes(type));
|
|
if (!sourceType.length) {
|
|
params.sourceType = [
|
|
'album',
|
|
'camera'
|
|
];
|
|
}
|
|
return undefined;
|
|
}
|
|
],
|
|
[
|
|
'type',
|
|
(type: string = 'all', params: ChooseFileOptions)=>{
|
|
if (!CHOOSE_MEDIA_TYPE.includes(type)) {
|
|
params.type = 'all';
|
|
}
|
|
return undefined;
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
(extension: string[], params: ChooseFileOptions)=>{
|
|
if (extension instanceof Array && extension.length === 0) {
|
|
return 'param extension should not be empty.';
|
|
}
|
|
if (!extension) params.extension = [
|
|
''
|
|
];
|
|
return undefined;
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const ChooseFileApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'count',
|
|
{
|
|
type: 'number'
|
|
}
|
|
],
|
|
[
|
|
'sourceType',
|
|
{
|
|
type: 'array'
|
|
}
|
|
],
|
|
[
|
|
'type',
|
|
{
|
|
'type': 'string'
|
|
}
|
|
],
|
|
[
|
|
'extension',
|
|
{
|
|
type: 'array'
|
|
}
|
|
]
|
|
]);
|
|
const API_COMPRESS_VIDEO = 'compressVideo';
|
|
const CompressVideoApiOptions: ApiOptions<CompressVideoOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'src',
|
|
(src: string, params: CompressVideoOptions)=>{
|
|
if (src) params.src = getRealPath2(src);
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const CompressVideoApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'src',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'quality',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'bitrate',
|
|
{
|
|
type: 'number'
|
|
}
|
|
],
|
|
[
|
|
'fps',
|
|
{
|
|
type: 'number'
|
|
}
|
|
],
|
|
[
|
|
'resolution',
|
|
{
|
|
type: 'number'
|
|
}
|
|
]
|
|
]);
|
|
const getFileName = (path: string)=>{
|
|
const array = path.split('/');
|
|
return array[array.length - 1];
|
|
};
|
|
let id: number = 0;
|
|
const _compressImage = (args: CompressImageOptions)=>{
|
|
const imageName = getFileName(args.src);
|
|
const imageExt = imageName.split('.').slice(-1)[0];
|
|
const imagePacker: image.ImagePacker = image.createImagePacker();
|
|
const file2 = fileIo4.openSync(args.src, fileIo4.OpenMode.READ_ONLY);
|
|
if (!file2) {
|
|
throw new Error('open file failed');
|
|
}
|
|
const imageSource: image.ImageSource = image.createImageSource(file2.fd);
|
|
if (imageSource == null) {
|
|
throw new Error('create image source failed');
|
|
}
|
|
let decodingOptions: image.DecodingOptions = {
|
|
editable: true
|
|
};
|
|
if (args.rotate != null) {
|
|
decodingOptions.rotate = args.rotate;
|
|
}
|
|
if (args.compressedHeight != null || args.compressedWidth != null) {
|
|
decodingOptions.desiredSize = {
|
|
height: (args.compressedHeight ?? args.compressedWidth)!,
|
|
width: (args.compressedWidth ?? args.compressedHeight)!
|
|
};
|
|
}
|
|
const pixelMap = imageSource.createPixelMapSync(decodingOptions);
|
|
let format: string = '';
|
|
if ([
|
|
'jpg',
|
|
'jpe',
|
|
'jpeg',
|
|
'png'
|
|
].includes(imageExt)) {
|
|
format = 'image/jpeg';
|
|
}
|
|
if (imageExt === 'webp') format = 'image/webp';
|
|
if (!format.length) {
|
|
throw new Error('error image format');
|
|
}
|
|
const packOptions: image.PackingOption = {
|
|
format,
|
|
quality: args.quality ?? 80
|
|
};
|
|
const tempFileName = `${Date.now()}_${id++}.${imageExt}`;
|
|
const tempDirPath = `${getEnv4().TEMP_PATH}/compress`;
|
|
if (!fileIo4.accessSync(tempDirPath)) {
|
|
fileIo4.mkdirSync(tempDirPath, true);
|
|
}
|
|
const tempFilePath: string = `${tempDirPath}/${tempFileName}`;
|
|
const file = fileIo4.openSync(tempFilePath, fileIo4.OpenMode.CREATE | fileIo4.OpenMode.READ_WRITE);
|
|
return imagePacker.packToFile(pixelMap, file.fd, packOptions).then((_)=>{
|
|
const size = fileIo4.statSync(file.fd).size;
|
|
fileIo4.closeSync(file.fd);
|
|
pixelMap.release();
|
|
return {
|
|
size,
|
|
tempFilePath
|
|
} as _CompressImageSuccess;
|
|
});
|
|
};
|
|
const compressImage: CompressImage = defineAsyncApi<CompressImageOptions, CompressImageSuccess>(API_CHOOSE_IMAGE, (args: CompressImageOptions, executor: ApiExecutor<CompressImageSuccess>)=>{
|
|
try {
|
|
_compressImage(args).then((res)=>{
|
|
executor.resolve({
|
|
tempFilePath: res.tempFilePath
|
|
} as CompressImageSuccess);
|
|
});
|
|
} catch (error) {
|
|
executor.reject((error as BusinessError11).message);
|
|
}
|
|
}, CompressImageApiProtocol, CompressImageApiOptions) as CompressImage;
|
|
const _getVideoInfo1 = async (uri: string): Promise<GetVideoInfoSuccess> =>{
|
|
const file = await fs4.open(uri, fs4.OpenMode.READ_ONLY);
|
|
const avMetadataExtractor = await media4.createAVMetadataExtractor();
|
|
let metadata: media4.AVMetadata | null = null;
|
|
let size: number = 0;
|
|
try {
|
|
size = (await fs4.stat(file.fd)).size;
|
|
avMetadataExtractor.dataSrc = {
|
|
fileSize: size,
|
|
callback: (buffer: ArrayBuffer, length: number, pos: number | null = null)=>{
|
|
return fs4.readSync(file.fd, buffer, {
|
|
offset: pos,
|
|
length
|
|
} as ReadOptions2);
|
|
}
|
|
};
|
|
metadata = await avMetadataExtractor.fetchMetadata();
|
|
} catch (error) {
|
|
throw error as Error;
|
|
} finally{
|
|
await avMetadataExtractor.release();
|
|
await fs4.close(file);
|
|
}
|
|
const videoOrientationArr = [
|
|
'up',
|
|
'right',
|
|
'down',
|
|
'left'
|
|
] as MediaOrientation[];
|
|
return {
|
|
size: size,
|
|
duration: metadata.duration ? Number(metadata.duration) / 1000 : undefined,
|
|
width: metadata.videoWidth ? Number(metadata.videoWidth) : undefined,
|
|
height: metadata.videoHeight ? Number(metadata.videoHeight) : undefined,
|
|
type: metadata.mimeType,
|
|
orientation: metadata.videoOrientation ? videoOrientationArr[Number(metadata.videoOrientation) / 90] : undefined
|
|
} as GetVideoInfoSuccess;
|
|
};
|
|
const _getImageInfo = async (uri: string): Promise<GetImageInfoSuccess> =>{
|
|
const file = await fs4.open(uri, fs4.OpenMode.READ_ONLY);
|
|
const imageSource = image1.createImageSource(file.fd);
|
|
const imageInfo = await imageSource.getImageInfo();
|
|
let orientation: string = '';
|
|
try {
|
|
orientation = await imageSource.getImageProperty(image1.PropertyKey.ORIENTATION);
|
|
} catch (error) {}
|
|
await imageSource.release();
|
|
await fs4.close(file.fd);
|
|
let orientationNum = 0;
|
|
if (typeof orientation === 'string') {
|
|
const matched = orientation.match(/^Unknown value (\d)$/);
|
|
if (matched && matched[1]) {
|
|
orientationNum = Number(matched[1]);
|
|
} else if (/^\d$/.test(orientation)) {
|
|
orientationNum = Number(orientation);
|
|
}
|
|
} else if (typeof orientation === 'number') {
|
|
orientationNum = orientation;
|
|
}
|
|
let orientationStr: MediaOrientation = 'up';
|
|
switch(orientationNum){
|
|
case 2:
|
|
orientationStr = 'up-mirrored';
|
|
break;
|
|
case 3:
|
|
orientationStr = 'down';
|
|
break;
|
|
case 4:
|
|
orientationStr = 'down-mirrored';
|
|
break;
|
|
case 5:
|
|
orientationStr = 'left-mirrored';
|
|
break;
|
|
case 6:
|
|
orientationStr = 'right';
|
|
break;
|
|
case 7:
|
|
orientationStr = 'right-mirrored';
|
|
break;
|
|
case 8:
|
|
orientationStr = 'left';
|
|
break;
|
|
case 0:
|
|
case 1:
|
|
default:
|
|
orientationStr = 'up';
|
|
break;
|
|
}
|
|
return {
|
|
path: uri,
|
|
width: imageInfo.size.width,
|
|
height: imageInfo.size.height,
|
|
orientation: orientationStr
|
|
} as GetImageInfoSuccess;
|
|
};
|
|
const _chooseMedia1 = async (options: _ChooseMediaOptions): Promise<chooseMediaSuccessCallbackResult> =>{
|
|
const photoSelectOptions = new photoAccessHelper2.PhotoSelectOptions();
|
|
const mimeType = options.mimeType;
|
|
photoSelectOptions.MIMEType = mimeType;
|
|
if (mimeType === photoAccessHelper2.PhotoViewMIMETypes.VIDEO_TYPE) {
|
|
photoSelectOptions.maxSelectNumber = 1;
|
|
} else {
|
|
photoSelectOptions.maxSelectNumber = options.count || 9;
|
|
}
|
|
photoSelectOptions.isOriginalSupported = options.isOriginalSupported;
|
|
photoSelectOptions.isPhotoTakingSupported = !(options.sourceType && !options.sourceType.includes('camera'));
|
|
const photoPicker = new photoAccessHelper2.PhotoViewPicker();
|
|
const photoSelectResult = await photoPicker.select(photoSelectOptions);
|
|
const uris = photoSelectResult.photoUris;
|
|
if (mimeType !== photoAccessHelper2.PhotoViewMIMETypes.VIDEO_TYPE) {
|
|
let realUris: string[] = uris;
|
|
if (!photoSelectResult.isOriginalPhoto) {
|
|
const compressResult = await Promise.all(uris.map((uri): Promise<CompressImageSuccess> =>{
|
|
return _compressImage({
|
|
src: uri,
|
|
quality: 80
|
|
} as CompressImageOptions);
|
|
}));
|
|
realUris = compressResult.map((result)=>result.tempFilePath);
|
|
}
|
|
return {
|
|
tempFiles: realUris.map((uri)=>{
|
|
const file = fs4.openSync(uri, fs4.OpenMode.READ_ONLY);
|
|
const stat = fs4.statSync(file.fd);
|
|
fs4.closeSync(file);
|
|
return {
|
|
fileType: 'image',
|
|
tempFilePath: uri,
|
|
size: stat.size
|
|
} as MediaFile;
|
|
})
|
|
};
|
|
}
|
|
const tempFiles: MediaFile[] = [];
|
|
for(let i = 0; i < uris.length; i++){
|
|
const uri = uris[i];
|
|
const videoInfo = await _getVideoInfo1(uri);
|
|
tempFiles.push({
|
|
fileType: 'video',
|
|
tempFilePath: uri,
|
|
size: videoInfo.size,
|
|
duration: videoInfo.duration,
|
|
width: videoInfo.width,
|
|
height: videoInfo.height
|
|
} as MediaFile);
|
|
}
|
|
return {
|
|
tempFiles
|
|
} as chooseMediaSuccessCallbackResult;
|
|
};
|
|
const getMimeTypeFromExtension = (extension: string): string | null =>{
|
|
const typeId = uniformTypeDescriptor.getUniformDataTypeByFilenameExtension('.' + extension);
|
|
const typeObj = uniformTypeDescriptor.getTypeDescriptor(typeId);
|
|
const mimeTypes = typeObj.mimeTypes;
|
|
return mimeTypes[0] || null;
|
|
};
|
|
const MediaUniErrors: Map<number, string> = new Map([
|
|
[
|
|
1101001,
|
|
'user cancel'
|
|
],
|
|
[
|
|
1101002,
|
|
'fail parameter error: parameter.urls should have at least 1 item'
|
|
],
|
|
[
|
|
1101003,
|
|
"file not find"
|
|
],
|
|
[
|
|
1101004,
|
|
"Failed to load resource"
|
|
],
|
|
[
|
|
1101005,
|
|
"No Permission"
|
|
],
|
|
[
|
|
1101006,
|
|
"save error"
|
|
],
|
|
[
|
|
1101007,
|
|
"crop error"
|
|
],
|
|
[
|
|
1101008,
|
|
'camera error'
|
|
],
|
|
[
|
|
1101009,
|
|
"image output failed"
|
|
],
|
|
[
|
|
1101010,
|
|
"unexpect error:"
|
|
]
|
|
]);
|
|
const getHMCameraPosition1 = (cameraType: CameraPosition1)=>{
|
|
switch(cameraType){
|
|
case 'back':
|
|
return camera1.CameraPosition.CAMERA_POSITION_BACK;
|
|
case 'front':
|
|
return camera1.CameraPosition.CAMERA_POSITION_FRONT;
|
|
default:
|
|
return camera1.CameraPosition.CAMERA_POSITION_BACK;
|
|
}
|
|
};
|
|
const takePhoto = async (cameraType: CameraPosition1 = 'back')=>{
|
|
let pickerProfile: cameraPicker1.PickerProfile = {
|
|
cameraPosition: getHMCameraPosition1(cameraType)
|
|
};
|
|
const res = await cameraPicker1.pick(UTSHarmony.getUIAbilityContext()!, [
|
|
cameraPicker1.PickerMediaType.PHOTO
|
|
], pickerProfile);
|
|
const file = fs5.openSync(res.resultUri, fs5.OpenMode.READ_ONLY);
|
|
const stat = fs5.statSync(file.fd);
|
|
return {
|
|
tempFiles: [
|
|
{
|
|
tempFilePath: res.resultUri,
|
|
size: stat.size
|
|
}
|
|
]
|
|
} as TakePhotoRes;
|
|
};
|
|
const takeVideo = async (args: TakeVideoOptions | null = null)=>{
|
|
let pickerProfile: cameraPicker1.PickerProfile = {
|
|
cameraPosition: getHMCameraPosition1(args?.cameraType ?? 'back'),
|
|
videoDuration: args?.videoDuration
|
|
};
|
|
const res = await cameraPicker1.pick(UTSHarmony.getUIAbilityContext()!, [
|
|
cameraPicker1.PickerMediaType.VIDEO
|
|
], pickerProfile);
|
|
return _getVideoInfo1(res.resultUri).then((getVideInfoRes)=>{
|
|
return {
|
|
path: res.resultUri,
|
|
size: getVideInfoRes.size,
|
|
duration: getVideInfoRes.duration!,
|
|
width: getVideInfoRes.width!,
|
|
height: getVideInfoRes.height!,
|
|
type: getVideInfoRes.type!,
|
|
orientation: getVideInfoRes.orientation!
|
|
} as TakeVideoRes;
|
|
});
|
|
};
|
|
const errSubject = 'uni-chooseImage';
|
|
const _chooseImage = (options: ChooseImageOptions, res: ApiExecutor<ChooseImageSuccess>)=>{
|
|
_chooseMedia1({
|
|
mimeType: photoAccessHelper3.PhotoViewMIMETypes.IMAGE_TYPE,
|
|
sourceType: [
|
|
"album"
|
|
],
|
|
isOriginalSupported: options.sizeType?.includes('original') !== false,
|
|
count: options.count!
|
|
} as _ChooseMediaOptions).then((chooseMediaRes)=>{
|
|
const tempFiles = chooseMediaRes.tempFiles;
|
|
if (tempFiles.length === 0) {
|
|
const errMsg = MediaUniErrors.get(1101001) as string;
|
|
res.reject(errMsg, {
|
|
errCode: 1101001
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
res.resolve({
|
|
errMsg: '',
|
|
errSubject,
|
|
tempFilePaths: chooseMediaRes.tempFiles.map((file)=>file.tempFilePath),
|
|
tempFiles: chooseMediaRes.tempFiles.map((file)=>{
|
|
return {
|
|
path: file.tempFilePath,
|
|
size: file.size
|
|
} as ChooseImageTempFile;
|
|
})
|
|
} as ChooseImageSuccess);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
};
|
|
const _takePhoto = (options: ChooseImageOptions, res: ApiExecutor<ChooseImageSuccess>)=>{
|
|
takePhoto().then((photo)=>{
|
|
res.resolve({
|
|
errMsg: '',
|
|
errSubject,
|
|
tempFilePaths: photo.tempFiles.map((file)=>file.tempFilePath),
|
|
tempFiles: photo.tempFiles.map((tempFile): ChooseImageTempFile =>({
|
|
path: tempFile.tempFilePath,
|
|
size: tempFile.size
|
|
} as ChooseImageTempFile))
|
|
} as ChooseImageSuccess);
|
|
}).catch((err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
};
|
|
const chooseImage: ChooseImage = defineAsyncApi<ChooseImageOptions, ChooseImageSuccess>(API_CHOOSE_IMAGE, async (options: ChooseImageOptions, res: ApiExecutor<ChooseImageSuccess>)=>{
|
|
if (options.sourceType?.length === 1 && options.sourceType[0] === 'camera') {
|
|
_takePhoto(options, res);
|
|
} else if (options.sourceType?.length === 1 && options.sourceType[0] === 'album') {
|
|
_chooseImage(options, res);
|
|
} else {
|
|
const lastWindow = UTSHarmony.getCurrentWindow() as window1.Window;
|
|
const UIContextPromptAction = await lastWindow.getUIContext().getPromptAction();
|
|
UIContextPromptAction.showActionMenu({
|
|
buttons: [
|
|
{
|
|
text: '拍照',
|
|
color: '#000000'
|
|
},
|
|
{
|
|
text: '从相册选择',
|
|
color: '#000000'
|
|
}
|
|
]
|
|
} as promptAction2.ActionMenuOptions, (err, ref)=>{
|
|
let index = ref.index;
|
|
if (err) {
|
|
res.reject('cancel');
|
|
} else {
|
|
if (index === 0) {
|
|
_takePhoto(options, res);
|
|
} else if (index === 1) {
|
|
_chooseImage(options, res);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, ChooseImageApiProtocol, ChooseImageApiOptions) as ChooseImage;
|
|
const _chooseVideo = (options: ChooseVideoOptions, res: ApiExecutor<ChooseVideoSuccess>)=>{
|
|
_chooseMedia1({
|
|
mimeType: photoAccessHelper4.PhotoViewMIMETypes.VIDEO_TYPE,
|
|
sourceType: [
|
|
"album"
|
|
],
|
|
isOriginalSupported: options.compressed === false
|
|
} as _ChooseMediaOptions).then((chooseMediaRes)=>{
|
|
const file = chooseMediaRes.tempFiles[0];
|
|
if (!file) {
|
|
const errMsg = MediaUniErrors.get(1101001) as string;
|
|
res.reject(errMsg, {
|
|
errCode: 1101001
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
res.resolve({
|
|
tempFilePath: file.tempFilePath,
|
|
duration: file.duration,
|
|
size: file.size,
|
|
width: file.width,
|
|
height: file.height
|
|
} as ChooseVideoSuccess);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
};
|
|
const _takeVideo = (options: ChooseVideoOptions, res: ApiExecutor<ChooseVideoSuccess>)=>{
|
|
const takeVideoOptions: TakeVideoOptions = {
|
|
cameraType: options.camera! as CameraPosition1,
|
|
videoDuration: options.maxDuration!
|
|
};
|
|
takeVideo(takeVideoOptions).then((video)=>{
|
|
res.resolve({
|
|
tempFilePath: video.path,
|
|
duration: video.duration,
|
|
size: video.size,
|
|
width: video.width,
|
|
height: video.height
|
|
} as ChooseVideoSuccess);
|
|
}).catch((err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
};
|
|
const chooseVideo: ChooseVideo = defineAsyncApi<ChooseVideoOptions, ChooseVideoSuccess>(API_CHOOSE_VIDEO, async (options: ChooseVideoOptions, res: ApiExecutor<ChooseVideoSuccess>)=>{
|
|
if (options.sourceType?.length === 1 && options.sourceType[0] === 'camera') {
|
|
_takeVideo(options, res);
|
|
} else if (options.sourceType?.length === 1 && options.sourceType[0] === 'album') {
|
|
_chooseVideo(options, res);
|
|
} else {
|
|
const lastWindow = UTSHarmony.getCurrentWindow() as window2.Window;
|
|
const UIContextPromptAction = await lastWindow.getUIContext().getPromptAction();
|
|
UIContextPromptAction.showActionMenu({
|
|
buttons: [
|
|
{
|
|
text: '拍摄',
|
|
color: '#000000'
|
|
},
|
|
{
|
|
text: '从相册选择',
|
|
color: '#000000'
|
|
}
|
|
]
|
|
} as promptAction3.ActionMenuOptions, (err, ref)=>{
|
|
let index = ref.index;
|
|
if (err) {
|
|
res.reject('cancel');
|
|
} else {
|
|
if (index === 0) {
|
|
_takeVideo(options, res);
|
|
} else if (index === 1) {
|
|
_chooseVideo(options, res);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, ChooseVideoApiProtocol, ChooseVideoApiOptions) as ChooseVideo;
|
|
const getImageInfo: GetImageInfo = defineAsyncApi<GetImageInfoOptions, GetImageInfoSuccess>(API_GET_IMAGE_INFO, async (options: GetImageInfoOptions, res: ApiExecutor<GetImageInfoSuccess>)=>{
|
|
let src = options.src;
|
|
if (src.startsWith('http:') || src.startsWith('https:')) {
|
|
try {
|
|
src = await new Promise<string>((resolve, reject)=>{
|
|
uni.downloadFile({
|
|
url: options.src,
|
|
success: (res: IGetImageInfoDownloadSuccess)=>{
|
|
resolve(res.tempFilePath);
|
|
},
|
|
fail: (err: IGetImageInfoDownloadFail)=>{
|
|
reject(err);
|
|
}
|
|
} as IGetImageInfoDownloadOptions);
|
|
});
|
|
} catch (err) {
|
|
const error = err as IGetImageInfoDownloadFail;
|
|
res.reject(error.errMsg);
|
|
return;
|
|
}
|
|
}
|
|
_getImageInfo(src).then((getImageInfoRes)=>{
|
|
res.resolve(getImageInfoRes);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
}, GetImageInfoApiProtocol, GetImageInfoApiOptions) as GetImageInfo;
|
|
const getVideoInfo: GetVideoInfo = defineAsyncApi<GetVideoInfoOptions, GetVideoInfoSuccess>(API_GET_VIDEO_INFO, (options: GetVideoInfoOptions, res: ApiExecutor<GetVideoInfoSuccess>)=>{
|
|
_getVideoInfo1(options.src).then((getVideInfoRes)=>{
|
|
res.resolve({
|
|
size: getVideInfoRes.size,
|
|
duration: getVideInfoRes.duration!,
|
|
width: getVideInfoRes.width!,
|
|
height: getVideInfoRes.height!,
|
|
type: getVideInfoRes.type!,
|
|
orientation: getVideInfoRes.orientation!
|
|
} as GetVideoInfoSuccess);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
}, GetVideoInfoApiProtocol, GetVideoInfoApiOptions) as GetVideoInfo;
|
|
const previewImage: PreviewImage = defineAsyncApi<PreviewImageOptions, PreviewImageSuccess>(API_PREVIEW_IMAGE, (options: PreviewImageOptions, exec: ApiExecutor<PreviewImageSuccess>)=>{
|
|
const currentUrl = typeof options.current === 'number' ? options.urls[options.current ?? 0] : options.current as string;
|
|
onNativePageReady1().then((nativePage: Object)=>{
|
|
getOSRuntime().previewImage({
|
|
urls: options.urls.map((url)=>getRealPath3(url) as string),
|
|
current: getRealPath3(currentUrl || ''),
|
|
showmenu: options.showmenu === false ? false : true
|
|
} as IPreviewImageOptions, nativePage);
|
|
exec.resolve({
|
|
errSubject: 'uni-previewImage',
|
|
errMsg: ''
|
|
} as PreviewImageSuccess);
|
|
});
|
|
}, PreviewImageApiProtocol, PreviewImageApiOptions) as PreviewImage;
|
|
const closePreviewImage: ClosePreviewImage = defineAsyncApi<ClosePreviewImageOptions, ClosePreviewImageSuccess>(API_CLOSE_PREVIEW_IMAGE, (options: ClosePreviewImageOptions, exec: ApiExecutor<ClosePreviewImageSuccess>)=>{
|
|
onNativePageReady1().then((nativePage: Object)=>{
|
|
getOSRuntime().closePreviewImage();
|
|
exec.resolve({
|
|
errMsg: ''
|
|
} as ClosePreviewImageSuccess);
|
|
});
|
|
}) as ClosePreviewImage;
|
|
const saveResource = async (src: Resource, dest: string)=>{
|
|
const context = UTSHarmony.getUIAbilityContext() as common.UIAbilityContext;
|
|
const resourceManager = context.resourceManager;
|
|
const srcPath: string = src.params?.[0] as string;
|
|
const destFile = fs6.openSync(dest, fs6.OpenMode.WRITE_ONLY);
|
|
const content = await resourceManager.getRawFileContent(srcPath);
|
|
await fs6.write(destFile.fd, content.buffer as ArrayBuffer);
|
|
await fs6.close(destFile);
|
|
};
|
|
const saveUri = async (src: string, dest: string)=>{
|
|
const srcFile = fs6.openSync(src, fs6.OpenMode.READ_ONLY);
|
|
const destFile = fs6.openSync(dest, fs6.OpenMode.WRITE_ONLY);
|
|
await fs6.copyFile(srcFile.fd, destFile.fd);
|
|
await fs6.close(srcFile);
|
|
await fs6.close(destFile);
|
|
};
|
|
const saveMediaToAlbum = async (fromUri: string, type: 'image' | 'video'): Promise<string | ISaveMediaError> =>{
|
|
const realPath = getResourceStr(fromUri) as string | Resource;
|
|
const context = UTSHarmony.getUIAbilityContext() as common.UIAbilityContext;
|
|
let fileName = Date.now() + (type === 'image' ? '.png' : '.mp4');
|
|
const isResource = typeof realPath !== 'string';
|
|
if (isResource) {
|
|
if (typeof realPath.params?.[0] === 'string') {
|
|
fileName = realPath.params?.[0].split('/').pop() || fileName;
|
|
}
|
|
} else {
|
|
fileName = realPath.split('/').pop() || fileName;
|
|
}
|
|
const phAccessHelper = photoAccessHelper5.getPhotoAccessHelper(context);
|
|
const fileNameParts = fileName.split('.');
|
|
const title = fileNameParts[0];
|
|
const fileNameExtension = fileNameParts.pop()!;
|
|
const photoCreationConfigs: Array<photoAccessHelper5.PhotoCreationConfig> = [
|
|
{
|
|
title,
|
|
fileNameExtension,
|
|
photoType: type === 'image' ? photoAccessHelper5.PhotoType.IMAGE : photoAccessHelper5.PhotoType.VIDEO
|
|
}
|
|
];
|
|
const desFileUris: Array<string> = await phAccessHelper.showAssetsCreationDialog([
|
|
fromUri.startsWith('file://') ? fromUri : fileUri.getUriFromPath(fromUri)
|
|
], photoCreationConfigs);
|
|
if (!desFileUris || desFileUris.length === 0) {
|
|
return {
|
|
code: 1101001,
|
|
message: MediaUniErrors.get(1101001) as string
|
|
} as ISaveMediaError;
|
|
}
|
|
const destUri = desFileUris[0];
|
|
if (!destUri.startsWith('file://')) {
|
|
return {
|
|
code: 1101006,
|
|
message: MediaUniErrors.get(1101006) as string + ', code: ' + destUri
|
|
} as ISaveMediaError;
|
|
}
|
|
if (isResource) {
|
|
await saveResource(realPath as Resource, destUri);
|
|
} else {
|
|
await saveUri(realPath as string, destUri);
|
|
}
|
|
return destUri;
|
|
};
|
|
const saveImageToPhotosAlbum: SaveImageToPhotosAlbum = defineAsyncApi<SaveImageToPhotosAlbumOptions, SaveImageToPhotosAlbumSuccess>(API_SAVE_IMAGE_TO_PHOTOS_ALBUM, (options: SaveImageToPhotosAlbumOptions, res: ApiExecutor<SaveImageToPhotosAlbumSuccess>)=>{
|
|
saveMediaToAlbum(options.filePath, 'image').then((uri)=>{
|
|
if (typeof uri === 'object') {
|
|
const err = uri as ISaveMediaError;
|
|
res.reject(err.message, {
|
|
errCode: err.code
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
res.resolve({
|
|
path: uri
|
|
} as SaveImageToPhotosAlbumSuccess);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
}, SaveImageToPhotosAlbumApiProtocol) as SaveImageToPhotosAlbum;
|
|
const saveVideoToPhotosAlbum: SaveVideoToPhotosAlbum = defineAsyncApi<SaveVideoToPhotosAlbumOptions, SaveVideoToPhotosAlbumSuccess>(API_SAVE_VIDEO_TO_PHOTOS_ALBUM, (options: SaveVideoToPhotosAlbumOptions, res: ApiExecutor<SaveVideoToPhotosAlbumSuccess>)=>{
|
|
saveMediaToAlbum(options.filePath, 'video').then((uri)=>{
|
|
if (typeof uri === 'object') {
|
|
const err = uri as ISaveMediaError;
|
|
res.reject(err.message, {
|
|
errCode: err.code
|
|
} as ApiError);
|
|
return;
|
|
}
|
|
res.resolve({} as SaveVideoToPhotosAlbumSuccess);
|
|
}, (err: Error)=>{
|
|
res.reject(err.message);
|
|
});
|
|
}, SaveVideoToPhotosAlbumApiProtocol) as SaveVideoToPhotosAlbum;
|
|
const IMAGES: string[] = [
|
|
"jpg",
|
|
"jpe",
|
|
"pbm",
|
|
"pgm",
|
|
"pnm",
|
|
"ppm",
|
|
"psd",
|
|
"pic",
|
|
"rgb",
|
|
"svg",
|
|
"svgz",
|
|
"tif",
|
|
"xif",
|
|
"wbmp",
|
|
"wdp",
|
|
"xbm",
|
|
"ico"
|
|
];
|
|
const VIDEOS: string[] = [
|
|
"3g2",
|
|
"3gp",
|
|
"avi",
|
|
"f4v",
|
|
"flv",
|
|
"jpgm",
|
|
"jpgv",
|
|
"m1v",
|
|
"m2v",
|
|
"mpe",
|
|
"mpg",
|
|
"mpg4",
|
|
"m4v",
|
|
"mkv",
|
|
"mov",
|
|
"qt",
|
|
"movie",
|
|
"mp4v",
|
|
"ogv",
|
|
"smv",
|
|
"wm",
|
|
"wmv",
|
|
"wmx",
|
|
"wvx"
|
|
];
|
|
const getFile = (url: string)=>{
|
|
const file = fileIo5.openSync(url, fileIo5.OpenMode.READ_ONLY);
|
|
const size = fileIo5.statSync(file.fd).size;
|
|
const ext = file.name.split('.').pop()!;
|
|
return {
|
|
path: url,
|
|
name: file.name,
|
|
size,
|
|
type: getMimeTypeFromExtension(ext) ?? ext
|
|
} as ChooseFileTempFile;
|
|
};
|
|
const chooseFile: ChooseFile = defineAsyncApi<ChooseFileOptions, ChooseFileSuccess>(API_CHOOSE_FILE, (args: ChooseFileOptions, executor: ApiExecutor<ChooseFileSuccess>)=>{
|
|
if ([
|
|
'image',
|
|
'video'
|
|
].includes(args.type ?? '')) {
|
|
if (args.type === 'image') {
|
|
chooseImage({
|
|
sourceType: args.sourceType,
|
|
success (res: ChooseImageSuccess) {
|
|
executor.resolve({
|
|
tempFilePaths: res.tempFilePaths,
|
|
tempFiles: res.tempFilePaths.map((url): ChooseFileTempFile =>getFile(url))
|
|
} as ChooseFileSuccess);
|
|
},
|
|
fail (err: IMediaError) {
|
|
executor.reject(err.errMsg, {
|
|
errCode: err.errCode
|
|
} as ApiError);
|
|
}
|
|
} as ChooseImageOptions);
|
|
}
|
|
if (args.type === 'video') {
|
|
chooseVideo({
|
|
sourceType: args.sourceType,
|
|
success (res: ChooseVideoSuccess) {
|
|
executor.resolve({
|
|
tempFilePaths: [
|
|
res.tempFilePath
|
|
],
|
|
tempFiles: [
|
|
getFile(res.tempFilePath)
|
|
]
|
|
} as ChooseFileSuccess);
|
|
},
|
|
fail (err: IMediaError) {
|
|
executor.reject(err.errMsg, {
|
|
errCode: err.errCode
|
|
} as ApiError);
|
|
}
|
|
} as ChooseVideoOptions);
|
|
}
|
|
} else {
|
|
try {
|
|
let documentSelectOptions = new picker.DocumentSelectOptions();
|
|
let documentPicker = new picker.DocumentViewPicker(UTSHarmony.getUIAbilityContext()!);
|
|
documentSelectOptions.selectMode = picker.DocumentSelectMode.FILE;
|
|
if (args.count) documentSelectOptions.maxSelectNumber = args.count;
|
|
if (args.extension) documentSelectOptions.fileSuffixFilters = args.extension;
|
|
if (args.type === 'image') {
|
|
documentSelectOptions.fileSuffixFilters = documentSelectOptions.fileSuffixFilters?.concat(IMAGES);
|
|
}
|
|
if (args.type === 'video') {
|
|
documentSelectOptions.fileSuffixFilters = documentSelectOptions.fileSuffixFilters?.concat(VIDEOS);
|
|
}
|
|
documentPicker.select(documentSelectOptions).then((documentSelectResult: Array<string>)=>{
|
|
let tempFiles = documentSelectResult.map((url): ChooseFileTempFile =>getFile(url));
|
|
if (tempFiles.length !== 0) {
|
|
executor.resolve({
|
|
tempFilePaths: documentSelectResult,
|
|
tempFiles
|
|
} as ChooseFileSuccess);
|
|
} else {
|
|
executor.reject('cancel');
|
|
}
|
|
}).catch((err: BusinessError12)=>{
|
|
executor.reject(err.message, {
|
|
errCode: err.code
|
|
} as ApiError);
|
|
});
|
|
} catch (error) {
|
|
let err: BusinessError12 = error as BusinessError12;
|
|
executor.reject(err.message, {
|
|
errCode: err.code
|
|
} as ApiError);
|
|
}
|
|
}
|
|
}, ChooseFileApiProtocol, ChooseFileApiOptions) as ChooseFile;
|
|
const getQuality = (quality: string | null = null)=>{
|
|
switch(quality){
|
|
case "low":
|
|
return CompressQuality.COMPRESS_QUALITY_LOW;
|
|
case 'medium':
|
|
return CompressQuality.COMPRESS_QUALITY_MEDIUM;
|
|
}
|
|
return CompressQuality.COMPRESS_QUALITY_HIGH;
|
|
};
|
|
const compressVideo: CompressVideo = defineAsyncApi<CompressVideoOptions, CompressVideoSuccess>(API_COMPRESS_VIDEO, async (args: CompressVideoOptions, executor: ApiExecutor<CompressVideoSuccess>)=>{
|
|
let videoCompressor = new VideoCompressor();
|
|
videoCompressor.compressVideo(UTSHarmony.getUIAbilityContext()!, args.src, getQuality(args.quality!)).then((data: CompressorResponse): void =>{
|
|
if (data.code == CompressorResponseCode.SUCCESS) {
|
|
_getVideoInfo1(data.outputPath).then((res)=>{
|
|
executor.resolve({
|
|
tempFilePath: data.outputPath,
|
|
size: res.size
|
|
} as CompressVideoSuccess);
|
|
});
|
|
} else {
|
|
executor.reject(data.message, {
|
|
errCode: data.code
|
|
} as ApiError);
|
|
}
|
|
}).catch((err: Error)=>{
|
|
executor.reject(err.message);
|
|
});
|
|
}, CompressVideoApiProtocol, CompressVideoApiOptions) as CompressVideo;
|
|
const API_REQUEST = 'request';
|
|
const RequestApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'url',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'data',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'header',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'method',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'dataType',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'responseType',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'sslVerify',
|
|
{
|
|
type: 'boolean',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'withCredentials',
|
|
{
|
|
type: 'boolean',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'firstIpv4',
|
|
{
|
|
type: 'boolean',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const RequestApiOptions: ApiOptions<RequestOptions<Object>> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'url',
|
|
(url: string, params: RequestOptions<Object>)=>{
|
|
if (url == null) {
|
|
throw new Error('url is required');
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'method',
|
|
(method: string, params: RequestOptions<Object>)=>{
|
|
params.method = (method || 'GET').toUpperCase() as RequestMethod;
|
|
}
|
|
],
|
|
[
|
|
'dataType',
|
|
(dataType: string, params: RequestOptions<Object>)=>{
|
|
if (dataType == null) {
|
|
params.dataType = 'json';
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'responseType',
|
|
(responseType: string, params: RequestOptions<Object>)=>{
|
|
if (responseType == null) {
|
|
params.responseType = 'text';
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
(timeout: number, params: RequestOptions<Object>)=>{
|
|
if (timeout == null) {
|
|
params.timeout = 60000;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'sslVerify',
|
|
(sslVerify: boolean, params: RequestOptions<Object>)=>{
|
|
if (sslVerify == null) {
|
|
params.sslVerify = true;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'withCredentials',
|
|
(withCredentials: boolean, params: RequestOptions<Object>)=>{
|
|
if (withCredentials == null) {
|
|
params.withCredentials = false;
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'firstIpv4',
|
|
(firstIpv4: boolean, params: RequestOptions<Object>)=>{
|
|
if (firstIpv4 == null) {
|
|
params.firstIpv4 = false;
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_DOWNLOAD_FILE = 'downloadFile';
|
|
const DownloadFileApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'url',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'header',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const DownloadFileApiOptions: ApiOptions<DownloadFileOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'url',
|
|
(url: string, params: DownloadFileOptions)=>{
|
|
if (url == null) {
|
|
throw new Error('url is required');
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_UPLOAD_FILE = 'uploadFile';
|
|
const UploadFileApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'url',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'filePath',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'name',
|
|
{
|
|
type: 'string',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'header',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'formData',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
{
|
|
type: 'number',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const UploadFileApiOptions: ApiOptions<UploadFileOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'url',
|
|
(url: string, params: UploadFileOptions)=>{
|
|
if (url == null) {
|
|
throw new Error('url is required');
|
|
}
|
|
}
|
|
],
|
|
[
|
|
'name',
|
|
(name: string, params: UploadFileOptions)=>{
|
|
if (name == null) {
|
|
params.name = 'file';
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_CONFIG_MTLS = 'configMTLS';
|
|
const ConfigMTLSApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'certificates',
|
|
{
|
|
type: 'array',
|
|
required: true
|
|
}
|
|
]
|
|
]);
|
|
const ConfigMTLSApiOptions: ApiOptions<ConfigMTLSOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'certificates',
|
|
(certificates: (Certificate[]) | null = null)=>{
|
|
if (!certificates || certificates.some((item)=>typeof item.host !== 'string')) {
|
|
return '参数 certificates 配置错误，请确认后重试';
|
|
}
|
|
return undefined;
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const needsEncoding = (str: string)=>{
|
|
const decoded = decodeURIComponent(str);
|
|
if (decoded !== str) {
|
|
if (encodeURIComponent(decoded) === str) {
|
|
return false;
|
|
}
|
|
}
|
|
return encodeURIComponent(decoded) !== decoded;
|
|
};
|
|
const parseUrl = (url: string)=>{
|
|
try {
|
|
const urlObj = harmonyUrl.URL.parseURL(url);
|
|
urlObj.params.forEach((value, key)=>{
|
|
if (needsEncoding(value)) {
|
|
urlObj.params.set(key, value);
|
|
}
|
|
});
|
|
return urlObj.toString();
|
|
} catch (error) {
|
|
return url;
|
|
}
|
|
};
|
|
const certificates: Certificate[] = [];
|
|
const getCertType = (certPath: string): http.CertType =>{
|
|
const certExt = certPath.split('.').pop();
|
|
switch(certExt){
|
|
case 'p12':
|
|
return http.CertType.P12;
|
|
case 'pem':
|
|
return http.CertType.PEM;
|
|
default:
|
|
return http.CertType.PEM;
|
|
}
|
|
};
|
|
const getClientCertificate = (url: string): http.ClientCert | undefined =>{
|
|
if (certificates.length === 0) return undefined;
|
|
const urlObj = harmonyUrl.URL.parseURL(url);
|
|
const cert = certificates.find((certificate)=>certificate.host === urlObj.host);
|
|
if (cert) {
|
|
return {
|
|
certType: getCertType(cert.client!),
|
|
certPath: getRealPath4(cert.client!),
|
|
keyPath: cert.keyPath ?? '',
|
|
keyPassword: cert.clientPassword
|
|
} as http.ClientCert;
|
|
}
|
|
return undefined;
|
|
};
|
|
const replaceHttpWithHttps = (url: string): string =>{
|
|
return url.replace(/^http:/, 'https:');
|
|
};
|
|
const getCookieSync = (url: string): string =>{
|
|
return webview.WebCookieManager.fetchCookieSync(replaceHttpWithHttps(url));
|
|
};
|
|
const setCookieSync = (url: string, cookies: string[]): void =>{
|
|
cookies.forEach((cookie)=>{
|
|
let hasSecure = false;
|
|
let hasSameSite = false;
|
|
let savedCookie = cookie.split(';').map((cookieItem)=>{
|
|
const pair = cookieItem.split('=').map((item)=>item.trim());
|
|
const keyLower = pair[0].toLowerCase();
|
|
if (keyLower === 'secure') {
|
|
hasSecure = true;
|
|
return cookieItem;
|
|
}
|
|
if (keyLower === 'samesite') {
|
|
hasSameSite = true;
|
|
return 'samesite=none';
|
|
}
|
|
return cookieItem;
|
|
}).join(';');
|
|
if (!hasSecure) {
|
|
savedCookie += '; secure';
|
|
}
|
|
if (!hasSameSite) {
|
|
savedCookie += '; samesite=none';
|
|
}
|
|
try {
|
|
webview.WebCookieManager.configCookieSync(replaceHttpWithHttps(url), savedCookie);
|
|
} catch (error) {}
|
|
});
|
|
webview.WebCookieManager.saveCookieAsync();
|
|
};
|
|
const cookiesParse = (header: Record<string, string>)=>{
|
|
let cookiesArr: string[] = [];
|
|
const handleCookiesArr = (header['Set-Cookie'] || header['set-cookie'] || []) as string[];
|
|
for(let i = 0; i < handleCookiesArr.length; i++){
|
|
if (handleCookiesArr[i].indexOf('Expires=') !== -1 || handleCookiesArr[i].indexOf('expires=') !== -1) {
|
|
cookiesArr.push(handleCookiesArr[i].replace(',', ''));
|
|
} else {
|
|
cookiesArr.push(handleCookiesArr[i]);
|
|
}
|
|
}
|
|
return cookiesArr;
|
|
};
|
|
class RequestTask1 implements RequestTask {
|
|
__v_skip: boolean = true;
|
|
private _requestTask: IRequestTask;
|
|
constructor(requestTask: IRequestTask){
|
|
this._requestTask = requestTask;
|
|
}
|
|
abort() {
|
|
this._requestTask.abort();
|
|
}
|
|
onHeadersReceived(callback: Function) {
|
|
this._requestTask.onHeadersReceived(callback);
|
|
}
|
|
offHeadersReceived(callback: Function | null = null) {
|
|
this._requestTask.offHeadersReceived(callback);
|
|
}
|
|
}
|
|
const request = defineTaskApi<RequestOptions<Object>, RequestSuccess<Object>, RequestTask>(API_REQUEST, (args: RequestOptions<Object>, exec: ApiExecutor<RequestSuccess<Object>>)=>{
|
|
let header = args.header, method = args.method, data = args.data, dataType = args.dataType, timeout = args.timeout, url = args.url, responseType = args.responseType;
|
|
header = header || {} as ESObject;
|
|
if (!header!['Cookie'] && !header!['cookie']) {
|
|
header!['Cookie'] = getCookieSync(url);
|
|
}
|
|
let contentType = '';
|
|
const headers = {} as Record<string, Object>;
|
|
const headerRecord = header as Object as Record<string, string>;
|
|
const headerKeys = Object.keys(headerRecord);
|
|
for(let i = 0; i < headerKeys.length; i++){
|
|
const name = headerKeys[i];
|
|
if (name.toLowerCase() === 'content-type') {
|
|
contentType = headerRecord[name] as string;
|
|
}
|
|
headers[name.toLowerCase()] = headerRecord[name];
|
|
}
|
|
if (!contentType && method === 'POST') {
|
|
headers['Content-Type'] = 'application/json';
|
|
contentType = 'application/json';
|
|
}
|
|
if (method === 'GET' && data) {
|
|
const dataRecord = data as Record<string, Object>;
|
|
const query = Object.keys(dataRecord).map((key)=>{
|
|
return (encodeURIComponent(key) + '=' + encodeURIComponent(dataRecord[key] as string | number | boolean));
|
|
}).join('&');
|
|
url += query ? (url.indexOf('?') > -1 ? '&' : '?') + query : '';
|
|
data = null;
|
|
} else if (method !== 'GET' && contentType && contentType.indexOf('application/json') === 0 && data) {
|
|
data = JSON.stringify(data);
|
|
} else if (method !== 'GET' && contentType && contentType.indexOf('application/x-www-form-urlencoded') === 0 && data) {
|
|
const dataRecord = data as Record<string, Object>;
|
|
data = Object.keys(dataRecord).map((key)=>{
|
|
return (encodeURIComponent(key) + '=' + encodeURIComponent(dataRecord[key] as number | string | boolean));
|
|
}).join('&');
|
|
}
|
|
const httpRequest = http1.createHttp();
|
|
const mp = getCurrentMP1();
|
|
const userAgent = mp.userAgent.fullUserAgent;
|
|
if (userAgent && headers && !headers!['User-Agent'] && !headers!['user-agent']) {
|
|
headers!['User-Agent'] = userAgent;
|
|
}
|
|
const emitter = new Emitter2() as IUniRequestEmitter;
|
|
const requestTask: IRequestTask = {
|
|
abort () {
|
|
emitter.off('headersReceive');
|
|
httpRequest.destroy();
|
|
},
|
|
onHeadersReceived (callback: Function) {
|
|
emitter.on('headersReceive', callback);
|
|
},
|
|
offHeadersReceived (callback: Function | null = null) {
|
|
emitter.off('headersReceive', callback);
|
|
}
|
|
};
|
|
const destroy = ()=>{
|
|
emitter.off('headersReceive');
|
|
httpRequest.destroy();
|
|
};
|
|
mp.on('beforeClose', destroy);
|
|
let latestHeaders: Object | null = null;
|
|
let lastUrl = url;
|
|
httpRequest.on('headersReceive', (headers: Object)=>{
|
|
const realHeaders = headers as Record<string, string | string[]>;
|
|
const setCookieHeader = realHeaders['set-cookie'] || realHeaders['Set-Cookie'];
|
|
if (setCookieHeader) {
|
|
setCookieSync(lastUrl, setCookieHeader as string[]);
|
|
}
|
|
latestHeaders = headers;
|
|
const location = realHeaders['location'] || realHeaders['Location'];
|
|
if (location) {
|
|
lastUrl = location as string;
|
|
}
|
|
});
|
|
const bufs = [] as buffer1.Buffer[];
|
|
httpRequest.on('dataReceive', (data)=>{
|
|
bufs.push(buffer1.from(data));
|
|
});
|
|
httpRequest.requestInStream(parseUrl(url), {
|
|
header: headers,
|
|
method: (method || 'GET').toUpperCase() as http1.RequestMethod,
|
|
extraData: data || undefined,
|
|
connectTimeout: timeout ? timeout : undefined,
|
|
readTimeout: timeout ? timeout : undefined,
|
|
clientCert: getClientCertificate(url)
|
|
} as http1.HttpRequestOptions, (err, statusCode)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
const responseData = buffer1.concat(bufs);
|
|
let data: ArrayBuffer | string | object = '';
|
|
if (responseType === 'arraybuffer') {
|
|
data = responseData.buffer;
|
|
} else {
|
|
data = responseData.toString('utf8');
|
|
if (dataType === 'json') {
|
|
try {
|
|
data = JSON.parse(data);
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
const headers = latestHeaders as Record<string, string | string[]>;
|
|
const oldCookies = headers ? (headers['Set-Cookie'] || headers['set-cookie'] || []) as string[] : [] as string[];
|
|
const cookies = latestHeaders ? cookiesParse(latestHeaders as Record<string, string>) : [];
|
|
let newCookies = oldCookies.join(',');
|
|
if (newCookies) {
|
|
if (headers['Set-Cookie']) {
|
|
headers['Set-Cookie'] = newCookies;
|
|
} else {
|
|
headers['set-cookie'] = newCookies;
|
|
}
|
|
}
|
|
exec.resolve({
|
|
data,
|
|
statusCode,
|
|
header: latestHeaders!,
|
|
cookies: cookies
|
|
} as RequestSuccess<Object>);
|
|
}
|
|
requestTask.offHeadersReceived();
|
|
httpRequest.destroy();
|
|
mp.off('beforeClose', destroy);
|
|
});
|
|
return new RequestTask1(requestTask);
|
|
}, RequestApiProtocol, RequestApiOptions) as Request<Object>;
|
|
const lookupExt = (contentType: string): string | undefined =>{
|
|
const rawContentType = contentType.split(';')[0].trim().toLowerCase();
|
|
return (UTSHarmony.getExtensionFromMimeType(rawContentType) as string | null) || undefined;
|
|
};
|
|
const lookupContentTypeWithUri = (uri: string): string | undefined =>{
|
|
const uriArr = uri.split('.');
|
|
if (uriArr.length <= 1) {
|
|
return undefined;
|
|
}
|
|
const ext = uriArr.pop() as string;
|
|
return (UTSHarmony.getMimeTypeFromExtension(ext) as string | null) || undefined;
|
|
};
|
|
class UploadTask1 implements UploadTask {
|
|
__v_skip: boolean = true;
|
|
private _uploadTask: IUploadTask;
|
|
constructor(uploadTask: IUploadTask){
|
|
this._uploadTask = uploadTask;
|
|
}
|
|
abort() {
|
|
this._uploadTask.abort();
|
|
}
|
|
onProgressUpdate(callback: Function) {
|
|
this._uploadTask.onProgressUpdate(callback);
|
|
}
|
|
offProgressUpdate(callback: Function | null = null) {
|
|
this._uploadTask.offProgressUpdate(callback);
|
|
}
|
|
onHeadersReceived(callback: Function) {
|
|
this._uploadTask.onHeadersReceived(callback);
|
|
}
|
|
offHeadersReceived(callback: Function | null = null) {
|
|
this._uploadTask.offHeadersReceived(callback);
|
|
}
|
|
}
|
|
const readFile = (filePath: string): ArrayBuffer =>{
|
|
const readFilePath = getRealPath5(filePath) as string;
|
|
const file = fs7.openSync(readFilePath, fs7.OpenMode.READ_ONLY);
|
|
const stat = fs7.statSync(file.fd);
|
|
const data = new ArrayBuffer(stat.size);
|
|
fs7.readSync(file.fd, data);
|
|
fs7.closeSync(file.fd);
|
|
return data;
|
|
};
|
|
const uploadFile = defineTaskApi<UploadFileOptions, UploadFileSuccess, UploadTask>(API_UPLOAD_FILE, (args: UploadFileOptions, exec: ApiExecutor<UploadFileSuccess>)=>{
|
|
let url = args.url, timeout = args.timeout, header = args.header, formData = args.formData, files = args.files, filePath = args.filePath, name = args.name;
|
|
header = header || {} as ESObject;
|
|
if (!header!['Cookie'] && !header!['cookie']) {
|
|
header!['Cookie'] = getCookieSync(url);
|
|
}
|
|
const headers = {} as Record<string, Object>;
|
|
if (header) {
|
|
const headerRecord = header as Object as Record<string, string>;
|
|
const headerKeys = Object.keys(headerRecord);
|
|
for(let i = 0; i < headerKeys.length; i++){
|
|
const name = headerKeys[i];
|
|
headers[name.toLowerCase()] = headerRecord[name];
|
|
}
|
|
}
|
|
headers['Content-Type'] = 'multipart/form-data';
|
|
const multiFormDataList = [] as Array<http2.MultiFormData>;
|
|
if (formData) {
|
|
const formDataRecord = formData as Object as Record<string, Object>;
|
|
const formDataKeys = Object.keys(formDataRecord);
|
|
for(let i = 0; i < formDataKeys.length; i++){
|
|
const name = formDataKeys[i];
|
|
multiFormDataList.push({
|
|
name,
|
|
contentType: 'text/plain',
|
|
data: String(formDataRecord[name])
|
|
} as http2.MultiFormData);
|
|
}
|
|
}
|
|
try {
|
|
if (files && files.length) {
|
|
for(let i = 0; i < files.length; i++){
|
|
const _files_i = files[i], name = _files_i.name, uri = _files_i.uri;
|
|
multiFormDataList.push({
|
|
name: name || 'file',
|
|
contentType: lookupContentTypeWithUri(uri) || 'application/octet-stream',
|
|
remoteFileName: uri.split('/').pop() || 'no-name',
|
|
data: readFile(uri!)
|
|
} as http2.MultiFormData);
|
|
}
|
|
} else if (filePath) {
|
|
multiFormDataList.push({
|
|
name: name || 'file',
|
|
contentType: lookupContentTypeWithUri(filePath!) || 'application/octet-stream',
|
|
remoteFileName: filePath.split('/').pop() || 'no-name',
|
|
data: readFile(filePath!)
|
|
} as http2.MultiFormData);
|
|
}
|
|
} catch (error) {
|
|
exec.reject((error as Error).message);
|
|
return new UploadTask1({
|
|
abort: ()=>{},
|
|
onHeadersReceived: (callback: Function)=>{},
|
|
offHeadersReceived: (callback: Function)=>{},
|
|
onProgressUpdate: (callback: Function)=>{},
|
|
offProgressUpdate: (callback: Function)=>{}
|
|
} as IUploadTask);
|
|
}
|
|
const httpRequest = http2.createHttp();
|
|
const mp = getCurrentMP2();
|
|
const userAgent = mp.userAgent.fullUserAgent;
|
|
if (userAgent && !headers['User-Agent'] && !headers['user-agent']) {
|
|
headers['User-Agent'] = userAgent;
|
|
}
|
|
const emitter = new Emitter3() as IUniUploadFileEmitter;
|
|
const uploadTask: IUploadTask = {
|
|
abort () {
|
|
emitter.off('headersReceive');
|
|
emitter.off('progress');
|
|
httpRequest.destroy();
|
|
},
|
|
onHeadersReceived (callback: Function) {
|
|
emitter.on('headersReceive', callback);
|
|
},
|
|
offHeadersReceived (callback: Function | null = null) {
|
|
emitter.off('headersReceive', callback);
|
|
},
|
|
onProgressUpdate (callback: Function) {
|
|
emitter.on('progress', callback);
|
|
},
|
|
offProgressUpdate (callback: Function | null = null) {
|
|
emitter.off('progress', callback);
|
|
}
|
|
};
|
|
const destroy = ()=>{
|
|
emitter.off('headersReceive');
|
|
emitter.off('progress');
|
|
httpRequest.destroy();
|
|
};
|
|
mp.on('beforeClose', destroy);
|
|
let lastUrl = url;
|
|
httpRequest.on('headersReceive', (headers: Object)=>{
|
|
const realHeaders = headers as Record<string, string | string[]>;
|
|
const setCookieHeader = realHeaders['set-cookie'] || realHeaders['Set-Cookie'];
|
|
if (setCookieHeader) {
|
|
setCookieSync(lastUrl, setCookieHeader as string[]);
|
|
}
|
|
const location = realHeaders['location'] || realHeaders['Location'];
|
|
if (location) {
|
|
lastUrl = location as string;
|
|
}
|
|
});
|
|
httpRequest.on('dataSendProgress', (ref)=>{
|
|
let sendSize = ref.sendSize, totalSize = ref.totalSize;
|
|
emitter.emit('progress', {
|
|
progress: Math.floor((sendSize / totalSize) * 100),
|
|
totalBytesSent: sendSize,
|
|
totalBytesExpectedToSend: totalSize
|
|
} as OnProgressUpdateResult);
|
|
});
|
|
httpRequest.request(parseUrl(url), {
|
|
header: headers,
|
|
method: http2.RequestMethod.POST,
|
|
connectTimeout: timeout ? timeout : undefined,
|
|
readTimeout: timeout ? timeout : undefined,
|
|
multiFormDataList,
|
|
expectDataType: http2.HttpDataType.STRING,
|
|
clientCert: getClientCertificate(url)
|
|
} as http2.HttpRequestOptions, (err, res)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
exec.resolve({
|
|
data: res.result as string,
|
|
statusCode: res.responseCode
|
|
} as UploadFileSuccess);
|
|
}
|
|
uploadTask.offHeadersReceived();
|
|
uploadTask.offProgressUpdate();
|
|
httpRequest.destroy();
|
|
mp.off('beforeClose', destroy);
|
|
});
|
|
return new UploadTask1(uploadTask);
|
|
}, UploadFileApiProtocol, UploadFileApiOptions) as UploadFile;
|
|
const getPossibleExt = (contentType: string, contentDisposition: string, url: string): string =>{
|
|
const contentDispositionFileNameMatches = contentDisposition.match(/filename="(.*)"/);
|
|
const contentDispositionFileName = contentDispositionFileNameMatches ? contentDispositionFileNameMatches[1] : '';
|
|
const contentDispositionExt = contentDispositionFileName ? contentDispositionFileName.split('.').pop() : '';
|
|
if (contentDispositionExt) {
|
|
return contentDispositionExt;
|
|
}
|
|
const urlPath = harmonyUrl1.URL.parseURL(url).pathname;
|
|
const urlExt = urlPath.split('/').pop()?.split('.')[1] || '';
|
|
if (urlExt) {
|
|
return urlExt;
|
|
}
|
|
const contentTypeExt = lookupExt(contentType);
|
|
return contentTypeExt || '';
|
|
};
|
|
class DownloadTask1 implements DownloadTask {
|
|
__v_skip: boolean = true;
|
|
private _downloadTask: IDownloadTask;
|
|
constructor(downloadTask: IDownloadTask){
|
|
this._downloadTask = downloadTask;
|
|
}
|
|
abort() {
|
|
this._downloadTask.abort();
|
|
}
|
|
onProgressUpdate(callback: Function) {
|
|
this._downloadTask.onProgressUpdate(callback);
|
|
}
|
|
offProgressUpdate(callback: Function | null = null) {
|
|
this._downloadTask.offProgressUpdate(callback);
|
|
}
|
|
onHeadersReceived(callback: Function) {
|
|
this._downloadTask.onHeadersReceived(callback);
|
|
}
|
|
offHeadersReceived(callback: Function | null = null) {
|
|
this._downloadTask.offHeadersReceived(callback);
|
|
}
|
|
}
|
|
let downloadIndex: [string, number] = [
|
|
'0',
|
|
0
|
|
];
|
|
const getDownloadFileName = (ext: string)=>{
|
|
let fileName = Date.now() + '';
|
|
if (downloadIndex[0] === fileName) {
|
|
downloadIndex[1]++;
|
|
if (downloadIndex[1] > 0) {
|
|
fileName += '-' + downloadIndex[1];
|
|
}
|
|
} else {
|
|
downloadIndex[0] = fileName;
|
|
downloadIndex[1] = 0;
|
|
}
|
|
if (ext) {
|
|
fileName += '.' + ext;
|
|
}
|
|
return fileName;
|
|
};
|
|
const downloadFile = defineTaskApi<DownloadFileOptions, DownloadFileSuccess, DownloadTask>(API_DOWNLOAD_FILE, (args: DownloadFileOptions, exec: ApiExecutor<DownloadFileSuccess>)=>{
|
|
let url = args.url, timeout = args.timeout, header = args.header, filePath = args.filePath;
|
|
header = header || {} as ESObject;
|
|
if (!header!['Cookie'] && !header!['cookie']) {
|
|
header!['Cookie'] = getCookieSync(url);
|
|
}
|
|
const httpRequest = http3.createHttp();
|
|
const mp = getCurrentMP3();
|
|
const userAgent = mp.userAgent.fullUserAgent;
|
|
if (userAgent && !header!['User-Agent'] && !header!['user-agent']) {
|
|
header!['User-Agent'] = userAgent;
|
|
}
|
|
const emitter = new Emitter4() as IUniDownloadFileEmitter;
|
|
const downloadTask: IDownloadTask = {
|
|
abort () {
|
|
emitter.off('headersReceive');
|
|
emitter.off('progress');
|
|
httpRequest.destroy();
|
|
},
|
|
onHeadersReceived (callback: Function) {
|
|
emitter.on('headersReceive', callback);
|
|
},
|
|
offHeadersReceived (callback: Function | null = null) {
|
|
emitter.off('headersReceive', callback);
|
|
},
|
|
onProgressUpdate (callback: Function) {
|
|
emitter.on('progress', callback);
|
|
},
|
|
offProgressUpdate (callback: Function | null = null) {
|
|
emitter.off('progress', callback);
|
|
}
|
|
};
|
|
const destroy = ()=>{
|
|
downloadTask.abort();
|
|
};
|
|
mp.on('beforeClose', destroy);
|
|
let responseContentType = '';
|
|
let responseContentDisposition = '';
|
|
let lastUrl = url;
|
|
httpRequest.on('headersReceive', (headers: Object)=>{
|
|
const realHeaders = headers as Record<string, string | string[]>;
|
|
responseContentType = realHeaders['content-type'] as string || realHeaders['Content-Type'] as string || '';
|
|
responseContentDisposition = realHeaders['content-disposition'] as string || realHeaders['Content-Disposition'] as string || '';
|
|
const setCookieHeader = realHeaders['set-cookie'] || realHeaders['Set-Cookie'];
|
|
if (setCookieHeader) {
|
|
setCookieSync(lastUrl, setCookieHeader as string[]);
|
|
}
|
|
const location = realHeaders['location'] || realHeaders['Location'];
|
|
if (location) {
|
|
lastUrl = location as string;
|
|
}
|
|
});
|
|
httpRequest.on('dataReceiveProgress', (ref)=>{
|
|
let receiveSize = ref.receiveSize, totalSize = ref.totalSize;
|
|
emitter.emit('progress', {
|
|
progress: Math.floor((receiveSize / totalSize) * 100),
|
|
totalBytesWritten: receiveSize,
|
|
totalBytesExpectedToWrite: totalSize
|
|
} as OnProgressDownloadResult);
|
|
});
|
|
const TEMP_PATH = getEnv5().TEMP_PATH as string;
|
|
const downloadPath = TEMP_PATH + '/download';
|
|
if (!fs8.accessSync(downloadPath)) {
|
|
fs8.mkdirSync(downloadPath, true);
|
|
}
|
|
let stream: fs8.Stream;
|
|
let tempFilePath = '';
|
|
let writePromise = Promise.resolve(0);
|
|
const queueWrite = async (data: ArrayBuffer): Promise<number> =>{
|
|
writePromise = writePromise.then(async (total)=>{
|
|
const length = await stream.write(data);
|
|
return total + length;
|
|
});
|
|
return writePromise;
|
|
};
|
|
httpRequest.on('dataReceive', (data)=>{
|
|
if (!stream) {
|
|
const ext = getPossibleExt(responseContentType, responseContentDisposition, url);
|
|
tempFilePath = filePath ? filePath.replace(/^file:\/\//, '') : downloadPath + '/' + getDownloadFileName(ext);
|
|
stream = fs8.createStreamSync(tempFilePath, 'w+');
|
|
}
|
|
queueWrite(data);
|
|
});
|
|
httpRequest.requestInStream(parseUrl(url), {
|
|
header: header ? header : {} as ESObject,
|
|
method: http3.RequestMethod.GET,
|
|
connectTimeout: timeout ? timeout : undefined,
|
|
readTimeout: timeout ? timeout : undefined,
|
|
clientCert: getClientCertificate(url)
|
|
} as http3.HttpRequestOptions, (err, statusCode)=>{
|
|
let finishPromise: Promise<void> = Promise.resolve();
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
} else {
|
|
finishPromise = writePromise.then(async ()=>{
|
|
await stream.flush();
|
|
await stream.close();
|
|
exec.resolve({
|
|
tempFilePath,
|
|
statusCode
|
|
} as DownloadFileSuccess);
|
|
}).catch((err: Error)=>{
|
|
exec.reject(err.message);
|
|
});
|
|
}
|
|
finishPromise.then(()=>{
|
|
downloadTask.offHeadersReceived();
|
|
downloadTask.offProgressUpdate();
|
|
httpRequest.destroy();
|
|
mp.off('beforeClose', destroy);
|
|
});
|
|
});
|
|
return new DownloadTask1(downloadTask);
|
|
}, DownloadFileApiProtocol, DownloadFileApiOptions) as DownloadFile;
|
|
const configMTLS: ConfigMTLS = defineAsyncApi<ConfigMTLSOptions, ConfigMTLSSuccess>(API_CONFIG_MTLS, (args: ConfigMTLSOptions, executor: ApiExecutor<ConfigMTLSSuccess>)=>{
|
|
try {
|
|
args.certificates.forEach((certificate)=>{
|
|
const certHosts = certificates.map((cert)=>cert.host);
|
|
const certHostIndex = certHosts.indexOf(certificate.host);
|
|
if (certHostIndex > -1) {
|
|
certificates.splice(certHostIndex, 1);
|
|
}
|
|
certificates.push(certificate);
|
|
});
|
|
executor.resolve();
|
|
} catch (error) {
|
|
executor.reject((error as BusinessError13).message);
|
|
}
|
|
}, ConfigMTLSApiProtocol, ConfigMTLSApiOptions) as ConfigMTLS;
|
|
const API_LOGIN = 'login';
|
|
const LoginApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'provider',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
{
|
|
type: 'number'
|
|
}
|
|
]
|
|
]);
|
|
const API_GET_USER_INFO = 'getUserInfo';
|
|
const GetUserInfoApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'provider',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'timeout',
|
|
{
|
|
type: 'number'
|
|
}
|
|
]
|
|
]);
|
|
const SERVICE = 'oauth';
|
|
const PROVIDER = 'huawei';
|
|
const login: Login = defineAsyncApi<LoginOptions, LoginSuccess>(API_LOGIN, (args: LoginOptions, executor: ApiExecutor<LoginSuccess>)=>{
|
|
const provider = getUniProvider<UniOAuthProvider>(SERVICE, args.provider ?? PROVIDER);
|
|
if (!provider) {
|
|
executor.reject('Provider not found.');
|
|
return;
|
|
}
|
|
provider.login({
|
|
success (res) {
|
|
executor.resolve(res);
|
|
},
|
|
fail (err) {
|
|
executor.reject(err.errMsg);
|
|
}
|
|
} as LoginOptions);
|
|
}, LoginApiProtocol) as Login;
|
|
const getUserInfo: GetUserInfo = defineAsyncApi<GetUserInfoOptions, GetUserInfoSuccess>(API_GET_USER_INFO, (args: GetUserInfoOptions, executor: ApiExecutor<GetUserInfoSuccess>)=>{
|
|
const provider = getUniProvider<UniOAuthProvider>(SERVICE, args.provider ?? PROVIDER);
|
|
if (!provider) {
|
|
executor.reject('Provider not found.');
|
|
return;
|
|
}
|
|
provider.getUserInfo({
|
|
success (res) {
|
|
executor.resolve(res);
|
|
},
|
|
fail (err) {
|
|
executor.reject(err.errMsg);
|
|
}
|
|
} as GetUserInfoOptions);
|
|
}, GetUserInfoApiProtocol) as GetUserInfo;
|
|
const API_OPEN_APP_AUTHORIZE_SETTING = 'openAppAuthorizeSetting';
|
|
const openAppAuthorizeSetting: OpenAppAuthorizeSetting = defineAsyncApi<OpenAppAuthorizeSettingOptions, OpenAppAuthorizeSettingSuccess>(API_OPEN_APP_AUTHORIZE_SETTING, (options: OpenAppAuthorizeSettingOptions, exec: ApiExecutor<OpenAppAuthorizeSettingSuccess>)=>{
|
|
const want: Want = {
|
|
bundleName: 'com.huawei.hmos.settings',
|
|
abilityName: 'com.huawei.hmos.settings.MainAbility',
|
|
uri: 'application_info_entry',
|
|
parameters: {
|
|
pushParams: bundleManager2.getBundleInfoForSelfSync(bundleManager2.BundleFlag.GET_BUNDLE_INFO_DEFAULT).name
|
|
}
|
|
} as Want;
|
|
const context = UTSHarmony.getUIAbilityContext() as common1.UIAbilityContext;
|
|
context.startAbility(want).then(()=>{
|
|
exec.resolve({
|
|
errMsg: ''
|
|
} as OpenAppAuthorizeSettingSuccess);
|
|
}, (err: Error)=>{
|
|
exec.reject(err.message);
|
|
});
|
|
}) as OpenAppAuthorizeSetting;
|
|
const API_OPEN_DOCUMENT = 'openDocument';
|
|
const getContentType = (filePath: string, fileType: string | null = null): string | void =>{
|
|
const suffix = fileType || filePath.split('.').pop();
|
|
if (!suffix) {
|
|
return;
|
|
}
|
|
switch(suffix){
|
|
case 'doc':
|
|
case 'docx':
|
|
return 'application/msword';
|
|
case 'xls':
|
|
case 'xlsx':
|
|
return 'application/vnd.ms-excel';
|
|
case 'ppt':
|
|
case 'pptx':
|
|
return 'application/vnd.ms-powerpoint';
|
|
case 'pdf':
|
|
return 'application/pdf';
|
|
default:
|
|
return;
|
|
}
|
|
};
|
|
const openDocument: OpenDocument = defineAsyncApi<OpenDocumentOptions, OpenDocumentSuccess>(API_OPEN_DOCUMENT, (options: OpenDocumentOptions, exec: ApiExecutor<OpenDocumentSuccess>)=>{
|
|
const filePath = options.filePath;
|
|
const uri = fileUri1.getUriFromPath(filePath.replace(/^file:\/\//, ''));
|
|
const fileContentType = getContentType(filePath, options.fileType);
|
|
if (!fileContentType) {
|
|
exec.reject('file type not supported');
|
|
return;
|
|
}
|
|
const want: Want1 = {
|
|
flags: wantConstant.Flags.FLAG_AUTH_WRITE_URI_PERMISSION | wantConstant.Flags.FLAG_AUTH_READ_URI_PERMISSION | wantConstant.Flags.FLAG_AUTH_PERSISTABLE_URI_PERMISSION,
|
|
action: 'ohos.want.action.viewData',
|
|
uri: uri,
|
|
type: fileContentType as string
|
|
};
|
|
const abilityContext = UTSHarmony.getUIAbilityContext() as common2.UIAbilityContext;
|
|
abilityContext.startAbility(want).then(()=>{
|
|
exec.resolve({} as OpenDocumentSuccess);
|
|
}, (err: Error)=>{
|
|
exec.reject(err.message);
|
|
});
|
|
}) as OpenDocument;
|
|
const RequestPaymentUniErrors: Map<RequestPaymentErrorCode, string> = new Map([
|
|
[
|
|
700600,
|
|
'The payment result is unknown (it may have been successfully paid). Please check the payment status of the order in the merchant order list.'
|
|
],
|
|
[
|
|
701100,
|
|
'Order payment failure.'
|
|
],
|
|
[
|
|
701110,
|
|
'Repeat the request.'
|
|
],
|
|
[
|
|
700601,
|
|
'The user canceled midway.'
|
|
],
|
|
[
|
|
700602,
|
|
'Network connection error.'
|
|
],
|
|
[
|
|
700603,
|
|
'Payment result unknown (may have been successfully paid), please check the payment status of the order in the merchant order list.'
|
|
],
|
|
[
|
|
700607,
|
|
'Payment not completed.'
|
|
],
|
|
[
|
|
700608,
|
|
'Parameter error.'
|
|
],
|
|
[
|
|
700000,
|
|
'Other payment errors.'
|
|
],
|
|
[
|
|
700604,
|
|
'Wechat is not installed.'
|
|
],
|
|
[
|
|
700605,
|
|
'Failed to get provider.'
|
|
],
|
|
[
|
|
700800,
|
|
'URL Scheme is not configured.'
|
|
],
|
|
[
|
|
700801,
|
|
'Universal Link is not configured.'
|
|
]
|
|
]);
|
|
const API_REQUEST_PAYMENT = 'requestPayment';
|
|
const requestPayment: RequestPayment = defineAsyncApi<RequestPaymentOptions, RequestPaymentSuccess>(API_REQUEST_PAYMENT, (options: RequestPaymentOptions, exec: ApiExecutor<RequestPaymentSuccess>): void =>{
|
|
const provider = getUniProvider<UniPaymentProvider>('payment', options.provider);
|
|
if (!provider) {
|
|
exec.reject('Provider not found.');
|
|
return;
|
|
}
|
|
provider.requestPayment({
|
|
orderInfo: options.orderInfo,
|
|
success: (result: RequestPaymentSuccess)=>{
|
|
exec.resolve(result);
|
|
},
|
|
fail: (error: RequestPaymentFail)=>{
|
|
const errMsg = RequestPaymentUniErrors.get(error.errCode) ?? "";
|
|
exec.reject(errMsg, {
|
|
errCode: error.errCode
|
|
} as ApiError);
|
|
}
|
|
} as RequestPaymentOptions);
|
|
}) as RequestPayment;
|
|
const API_SHOW_TOAST = 'showToast';
|
|
const ShowToastProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'title',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'duration',
|
|
{
|
|
type: 'number'
|
|
}
|
|
]
|
|
]);
|
|
const ShowToastApiOptions: ApiOptions<ShowToastOptions> = {
|
|
formatArgs: new Map<string, Function | string | number>([
|
|
[
|
|
"title",
|
|
""
|
|
],
|
|
[
|
|
"duration",
|
|
1500
|
|
]
|
|
])
|
|
};
|
|
const API_HIDE_TOAST = 'hideToast';
|
|
const PRIMARY_COLOR = '#007aff';
|
|
const API_SHOW_MODAL = 'showModal';
|
|
const ShowModalProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
"title",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"content",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"showCancel",
|
|
{
|
|
type: "boolean"
|
|
}
|
|
],
|
|
[
|
|
"cancelText",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"cancelColor",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"confirmText",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"confirmColor",
|
|
{
|
|
type: "string"
|
|
}
|
|
]
|
|
]);
|
|
const ShowModalApiOptions: ApiOptions<ShowModalOptions> = {
|
|
formatArgs: new Map<string, Function | string | boolean>([
|
|
[
|
|
"title",
|
|
""
|
|
],
|
|
[
|
|
"content",
|
|
""
|
|
],
|
|
[
|
|
"placeholderText",
|
|
""
|
|
],
|
|
[
|
|
"showCancel",
|
|
true
|
|
],
|
|
[
|
|
"editable",
|
|
false
|
|
],
|
|
[
|
|
"cancelColor",
|
|
"#000000"
|
|
],
|
|
[
|
|
"confirmColor",
|
|
PRIMARY_COLOR
|
|
]
|
|
])
|
|
};
|
|
const API_SHOW_ACTION_SHEET = 'showActionSheet';
|
|
const ShowActionSheetProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
"title",
|
|
{
|
|
type: "string"
|
|
}
|
|
],
|
|
[
|
|
"itemList",
|
|
{
|
|
type: "array",
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
"itemColor",
|
|
{
|
|
type: "string"
|
|
}
|
|
]
|
|
]);
|
|
const ShowActionSheetApiOptions: ApiOptions<ShowActionSheetOptions> = {
|
|
formatArgs: new Map<string, string>([
|
|
[
|
|
"itemColor",
|
|
"#000000"
|
|
]
|
|
])
|
|
};
|
|
const API_SHOW_LOADING = 'showLoading';
|
|
const ShowLoadingProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'title',
|
|
{
|
|
type: 'string'
|
|
}
|
|
],
|
|
[
|
|
'mask',
|
|
{
|
|
type: 'boolean'
|
|
}
|
|
]
|
|
]);
|
|
const ShowLoadingApiOptions: ApiOptions<ShowLoadingOptions> = {
|
|
formatArgs: new Map<string, Function | string | boolean>([
|
|
[
|
|
"title",
|
|
""
|
|
],
|
|
[
|
|
"mask",
|
|
false
|
|
]
|
|
])
|
|
};
|
|
const API_HIDE_LOADING = 'hideLoading';
|
|
const showToast: ShowToast = defineAsyncApi<ShowToastOptions, ShowToastSuccess>(API_SHOW_TOAST, (options: ShowToastOptions, res: ApiExecutor<ShowToastSuccess>)=>{
|
|
try {
|
|
const showToastOptions: promptAction4.ShowToastOptions = {
|
|
message: options.title,
|
|
duration: options.duration!,
|
|
alignment: Alignment.Center
|
|
};
|
|
if (options.position) {
|
|
switch(options.position){
|
|
case 'top':
|
|
showToastOptions.alignment = Alignment.Top;
|
|
break;
|
|
case 'bottom':
|
|
showToastOptions.alignment = Alignment.Bottom;
|
|
break;
|
|
}
|
|
}
|
|
const window = UTSHarmony.getCurrentWindow() as window.Window;
|
|
window.getUIContext().getPromptAction().showToast(showToastOptions);
|
|
res.resolve({} as ShowToastSuccess);
|
|
} catch (error) {
|
|
let message = (error as BusinessError14).message;
|
|
res.reject(message);
|
|
}
|
|
}, ShowToastProtocol, ShowToastApiOptions) as ShowToast;
|
|
const hideToast: HideToast = defineAsyncApi(API_HIDE_TOAST, (_, res: ApiExecutor<Object>)=>{}) as HideToast;
|
|
const showModal: ShowModal = defineAsyncApi<ShowModalOptions, ShowModalSuccess>(API_SHOW_MODAL, async (args: ShowModalOptions, res: ApiExecutor<ShowModalSuccess>)=>{
|
|
const modalRes = await new Promise<ShowModalSuccess>((resolve, reject)=>{
|
|
const confirmButton: AlertDialogButtonOptions = {
|
|
value: args.confirmText ?? '确定',
|
|
fontColor: args.confirmColor!,
|
|
action: ()=>{
|
|
resolve({
|
|
"confirm": true
|
|
} as ShowModalSuccess);
|
|
}
|
|
};
|
|
const cancelButton: AlertDialogButtonOptions = {
|
|
value: args.cancelText ?? '取消',
|
|
fontColor: args.cancelColor ?? '#000000',
|
|
action: ()=>{
|
|
resolve({
|
|
"cancel": true
|
|
} as ShowModalSuccess);
|
|
}
|
|
};
|
|
const buttons: Array<AlertDialogButtonOptions> = [];
|
|
if (args.showCancel) {
|
|
buttons.push(cancelButton);
|
|
}
|
|
buttons.push(confirmButton);
|
|
const window = UTSHarmony.getCurrentWindow() as window.Window;
|
|
window.getUIContext().showAlertDialog({
|
|
title: args.title ?? '',
|
|
message: args.content ?? '',
|
|
autoCancel: false,
|
|
alignment: DialogAlignment.Center,
|
|
buttons,
|
|
cancel: ()=>{
|
|
resolve({
|
|
'cancel': true
|
|
} as ShowModalSuccess);
|
|
}
|
|
} as AlertDialogParamWithOptions);
|
|
});
|
|
if (modalRes.confirm) {
|
|
modalRes.cancel = false;
|
|
}
|
|
if (modalRes.cancel) {
|
|
modalRes.confirm = false;
|
|
}
|
|
modalRes.content = null;
|
|
res.resolve(modalRes as ShowModalSuccess);
|
|
}, ShowModalProtocol, ShowModalApiOptions) as ShowModal;
|
|
const showActionSheet: ShowActionSheet = defineAsyncApi<ShowActionSheetOptions, ShowActionSheetSuccess>(API_SHOW_ACTION_SHEET, async (options: ShowActionSheetOptions, res: ApiExecutor<ShowActionSheetSuccess>)=>{
|
|
const actionItemList = options.itemList.filter(Boolean);
|
|
if (actionItemList.length === 0) {
|
|
return;
|
|
}
|
|
type ActionMenuButtons = [promptAction5.Button, promptAction5.Button?, promptAction5.Button?, promptAction5.Button?, promptAction5.Button?, promptAction5.Button?];
|
|
const actionMenuButtons: ActionMenuButtons = [
|
|
{
|
|
text: actionItemList[0],
|
|
color: options.itemColor!
|
|
}
|
|
];
|
|
actionItemList.slice(1).forEach((item)=>{
|
|
actionMenuButtons.push({
|
|
text: item,
|
|
color: options.itemColor!
|
|
} as promptAction5.Button);
|
|
});
|
|
const window = UTSHarmony.getCurrentWindow() as window.Window;
|
|
window.getUIContext().getPromptAction().showActionMenu({
|
|
title: options.title,
|
|
buttons: actionMenuButtons
|
|
} as promptAction5.ActionMenuOptions).then((showACtionSheetRes)=>{
|
|
res.resolve({
|
|
tapIndex: showACtionSheetRes.index
|
|
} as ShowActionSheetSuccess);
|
|
}).catch((e: Error)=>{
|
|
if (e.message === 'cancel') {
|
|
res.reject('cancel');
|
|
return;
|
|
}
|
|
res.reject(e.message);
|
|
});
|
|
}, ShowActionSheetProtocol, ShowActionSheetApiOptions) as ShowActionSheet;
|
|
const showLoading: ShowLoading = defineAsyncApi<ShowLoadingOptions, ShowLoadingSuccess>(API_SHOW_LOADING, async (options: ShowLoadingOptions, exec: ApiExecutor<ShowLoadingSuccess>)=>{
|
|
onNativePageReady2().then((nativePage: Object)=>{
|
|
getOSRuntime1().showLoading({
|
|
title: options.title || '',
|
|
mask: options.mask == null ? false : options.mask
|
|
} as IShowLoadingOptions, nativePage);
|
|
exec.resolve({} as ShowLoadingSuccess);
|
|
});
|
|
}, ShowLoadingProtocol, ShowLoadingApiOptions) as ShowLoading;
|
|
const hideLoading: HideLoading = defineAsyncApi<IHideLoadingOptions, IHideLoadingSuccess>(API_HIDE_LOADING, (options: IHideLoadingOptions, exec: ApiExecutor<IHideLoadingSuccess>)=>{
|
|
onNativePageReady2().then((nativePage: Object)=>{
|
|
getOSRuntime1().hideLoading();
|
|
exec.resolve({} as IHideLoadingSuccess);
|
|
});
|
|
}) as HideLoading;
|
|
const API_START_PULL_DOWN_REFRESH = 'startPullDownRefresh';
|
|
const API_STOP_PULL_DOWN_REFRESH = 'stopPullDownRefresh';
|
|
const startPullDownRefresh = defineAsyncApi<StartPullDownRefreshOptions, StartPullDownRefreshSuccess>(API_START_PULL_DOWN_REFRESH, (_, res)=>{
|
|
internalStartPullDownRefresh();
|
|
res.resolve();
|
|
}) as StartPullDownRefresh;
|
|
const stopPullDownRefresh = defineSyncApi<void>(API_STOP_PULL_DOWN_REFRESH, ()=>{
|
|
internalStopPullDownRefresh();
|
|
}) as StopPullDownRefresh;
|
|
const API_RPX2PX = 'rpx2px';
|
|
const EPS = 1e-4;
|
|
const rpx2px: Rpx2px = defineSyncApi<number>(API_RPX2PX, (number: number): number =>{
|
|
const windowStage: harmonyWindow.WindowStage = UTSHarmony.getWindowStage() as harmonyWindow.WindowStage;
|
|
let windowWidthInVp: number = 384;
|
|
let windowWidthInPx: number = 1344;
|
|
if (windowStage) {
|
|
const mainWindow: harmonyWindow.Window = windowStage.getMainWindowSync();
|
|
windowWidthInPx = mainWindow.getWindowProperties().windowRect.width;
|
|
windowWidthInVp = px2vp(windowWidthInPx);
|
|
}
|
|
let result = (number / 750) * windowWidthInVp;
|
|
if (result < 0) {
|
|
result = -result;
|
|
}
|
|
result = Math.floor(result + EPS);
|
|
if (result == 0) {
|
|
if (windowWidthInPx == windowWidthInVp) {
|
|
result = 1;
|
|
} else {
|
|
result = 0.5;
|
|
}
|
|
}
|
|
return number < 0 ? -result : result;
|
|
}) as Rpx2px;
|
|
const API_SCAN_CODE = 'scanCode';
|
|
const HarmonyScanTypeMap = new Map<UniScanOptionsTypes, scanCore.ScanType[]>([
|
|
[
|
|
'barCode',
|
|
[
|
|
scanCore.ScanType.ONE_D_CODE
|
|
]
|
|
],
|
|
[
|
|
'qrCode',
|
|
[
|
|
scanCore.ScanType.TWO_D_CODE
|
|
]
|
|
],
|
|
[
|
|
'datamatrix',
|
|
[
|
|
scanCore.ScanType.DATAMATRIX_CODE
|
|
]
|
|
],
|
|
[
|
|
'pdf417',
|
|
[
|
|
scanCore.ScanType.PDF417_CODE
|
|
]
|
|
]
|
|
]);
|
|
const UniScanTypeMap = new Map<HarmonyScanResultTypes, UniScanResultTypes>([
|
|
[
|
|
scanCore.ScanType.AZTEC_CODE,
|
|
'AZTEC'
|
|
],
|
|
[
|
|
scanCore.ScanType.CODABAR_CODE,
|
|
'CODABAR'
|
|
],
|
|
[
|
|
scanCore.ScanType.CODE128_CODE,
|
|
'CODE_128'
|
|
],
|
|
[
|
|
scanCore.ScanType.CODE39_CODE,
|
|
'CODE_39'
|
|
],
|
|
[
|
|
scanCore.ScanType.CODE93_CODE,
|
|
'CODE_93'
|
|
],
|
|
[
|
|
scanCore.ScanType.DATAMATRIX_CODE,
|
|
'DATA_MATRIX'
|
|
],
|
|
[
|
|
scanCore.ScanType.EAN13_CODE,
|
|
'EAN_13'
|
|
],
|
|
[
|
|
scanCore.ScanType.EAN8_CODE,
|
|
'EAN_8'
|
|
],
|
|
[
|
|
scanCore.ScanType.ITF14_CODE,
|
|
'ITF'
|
|
],
|
|
[
|
|
scanCore.ScanType.PDF417_CODE,
|
|
'PDF_417'
|
|
],
|
|
[
|
|
scanCore.ScanType.QR_CODE,
|
|
'QR_CODE'
|
|
],
|
|
[
|
|
scanCore.ScanType.UPC_A_CODE,
|
|
'UPC_A'
|
|
],
|
|
[
|
|
scanCore.ScanType.UPC_E_CODE,
|
|
'UPC_E'
|
|
]
|
|
]);
|
|
const scanCode: ScanCode = defineAsyncApi<ScanCodeOptions, ScanCodeSuccess>(API_SCAN_CODE, (options: ScanCodeOptions, exec: ApiExecutor<ScanCodeSuccess>)=>{
|
|
if (!canIUse('SystemCapability.Multimedia.Scan.ScanBarcode')) {
|
|
exec.reject('not support');
|
|
return;
|
|
}
|
|
let scanTypes: scanCore.ScanType[] = [];
|
|
if (options.scanType && Array.isArray(options.scanType) && options.scanType.length > 0) {
|
|
for(let i = 0; i < options.scanType.length; i++){
|
|
const uniScanType = options.scanType[i];
|
|
const harmonyScanTypes = HarmonyScanTypeMap.get(uniScanType);
|
|
if (!harmonyScanTypes) {
|
|
continue;
|
|
}
|
|
scanTypes = scanTypes.concat(harmonyScanTypes);
|
|
}
|
|
}
|
|
if (scanTypes.length === 0) {
|
|
scanTypes = [
|
|
scanCore.ScanType.ALL
|
|
];
|
|
}
|
|
const scanOptions: scanBarcode.ScanOptions = {
|
|
scanTypes,
|
|
enableMultiMode: true,
|
|
enableAlbum: !options.onlyFromCamera
|
|
};
|
|
scanBarcode.startScanForResult(UTSHarmony.getUIAbilityContext()!, scanOptions, (err, data)=>{
|
|
if (err) {
|
|
exec.reject(err.message);
|
|
return;
|
|
}
|
|
exec.resolve({
|
|
result: data.originalValue,
|
|
scanType: UniScanTypeMap.get(data.scanType as HarmonyScanResultTypes) || ''
|
|
} as ScanCodeSuccess);
|
|
});
|
|
}) as ScanCode;
|
|
const API_SHARE_WITH_SYSTEM = 'shareWithSystem';
|
|
const shareWithSystem = defineAsyncApi<ShareWithSystemOptions, ShareWithSystemSuccess>(API_SHARE_WITH_SYSTEM, (args: ShareWithSystemOptions, exec: ApiExecutor<ShareWithSystemSuccess>)=>{
|
|
const href = args.href;
|
|
const imageUrl = args.imageUrl;
|
|
const summary = args.summary;
|
|
const shareRecords: systemShare.SharedRecord[] = [];
|
|
if (href) {
|
|
shareRecords.push({
|
|
utd: uniformTypeDescriptor1.UniformDataType.HYPERLINK,
|
|
content: href
|
|
} as systemShare.SharedRecord);
|
|
}
|
|
if (imageUrl) {
|
|
shareRecords.push({
|
|
utd: uniformTypeDescriptor1.UniformDataType.IMAGE,
|
|
uri: imageUrl
|
|
} as systemShare.SharedRecord);
|
|
}
|
|
if (summary) {
|
|
shareRecords.push({
|
|
utd: uniformTypeDescriptor1.UniformDataType.TEXT,
|
|
content: summary
|
|
} as systemShare.SharedRecord);
|
|
}
|
|
if (shareRecords.length === 0) {
|
|
exec.reject('No share data');
|
|
return;
|
|
}
|
|
const shareData = new systemShare.SharedData(shareRecords[0]);
|
|
for(let index = 1; index < shareRecords.length; index++){
|
|
shareData.addRecord(shareRecords[index]);
|
|
}
|
|
const shareController: systemShare.ShareController = new systemShare.ShareController(shareData);
|
|
shareController.show(UTSHarmony.getUIAbilityContext() as common3.UIAbilityContext, {} as systemShare.ShareControllerOptions);
|
|
const onDismiss = ()=>{
|
|
shareController.off('dismiss', onDismiss);
|
|
exec.resolve({} as ShareWithSystemSuccess);
|
|
};
|
|
shareController.on('dismiss', onDismiss);
|
|
}) as ShareWithSystem;
|
|
const API_GET_STORAGE = 'getStorage';
|
|
const API_GET_STORAGE_SYNC = 'getStorageSync';
|
|
const API_SET_STORAGE = 'setStorage';
|
|
const API_SET_STORAGE_SYNC = 'setStorageSync';
|
|
const API_REMOVE_STORAGE = 'removeStorage';
|
|
const API_REMOVE_STORAGE_SYNC = 'removeStorageSync';
|
|
const API_CLEAR_STORAGE = 'clearStorage';
|
|
const API_CLEAR_STORAGE_SYNC = 'clearStorageSync';
|
|
const API_GET_STORAGE_INFO = 'getStorageInfo';
|
|
const API_GET_STORAGE_INFO_SYNC = 'getStorageInfoSync';
|
|
const parseStorageValue = (value: string): Object =>{
|
|
try {
|
|
return JSON.parse(value).data;
|
|
} catch (e) {
|
|
return value;
|
|
}
|
|
};
|
|
const stringifyStorageValue = (value: Object): string =>{
|
|
return JSON.stringify({
|
|
type: typeof value,
|
|
data: value
|
|
} as ESObject);
|
|
};
|
|
const stores = new Map<string, dataPreferences.Preferences>();
|
|
const createStore = (): dataPreferences.Preferences =>{
|
|
const id = getCurrentMP4().id;
|
|
if (stores.has(id)) {
|
|
return stores.get(id)!;
|
|
}
|
|
const store = dataPreferences.getPreferencesSync(UTSHarmony.getUIAbilityContext() as common4.UIAbilityContext, {
|
|
name: `storage.${id}`
|
|
} as dataPreferences.Options);
|
|
stores.set(id, store);
|
|
return store;
|
|
};
|
|
const getStorageSync = defineSyncApi<Object>(API_GET_STORAGE_SYNC, (key: string)=>{
|
|
const storeValue = createStore().getSync(key, '');
|
|
if (!storeValue) {
|
|
return '';
|
|
}
|
|
return parseStorageValue(storeValue as string);
|
|
}) as GetStorageSync;
|
|
const getStorage = defineAsyncApi<GetStorageOptions, GetStorageSuccess>(API_GET_STORAGE, (args: GetStorageOptions, exec: ApiExecutor<GetStorageSuccess>)=>{
|
|
createStore().get(args.key, '').then((storeValue)=>{
|
|
if (!storeValue) {
|
|
return exec.reject('data not found');
|
|
}
|
|
let value: Object;
|
|
try {
|
|
value = parseStorageValue(storeValue as string);
|
|
} catch (error) {
|
|
exec.reject('data parse error');
|
|
return;
|
|
}
|
|
exec.resolve({
|
|
data: value
|
|
} as GetStorageSuccess);
|
|
});
|
|
}) as GetStorage;
|
|
const setStorageSync = defineSyncApi<void>(API_SET_STORAGE_SYNC, (key: string, value: Object)=>{
|
|
createStore().putSync(key, stringifyStorageValue(value));
|
|
createStore().flush();
|
|
}) as SetStorageSync;
|
|
const setStorage = defineAsyncApi<SetStorageOptions, SetStorageSuccess>(API_SET_STORAGE, (args: SetStorageOptions, exec: ApiExecutor<SetStorageSuccess>)=>{
|
|
try {
|
|
createStore().put(args.key, stringifyStorageValue(args.data)).then(()=>{
|
|
createStore().flush();
|
|
exec.resolve({} as ESObject);
|
|
}, (error: Error)=>{
|
|
exec.reject(error.message);
|
|
});
|
|
} catch (error) {
|
|
exec.reject((error as Error).message);
|
|
}
|
|
}) as SetStorage;
|
|
const removeStorageSync = defineSyncApi<void>(API_REMOVE_STORAGE_SYNC, (key: string)=>{
|
|
createStore().deleteSync(key);
|
|
createStore().flush();
|
|
}) as RemoveStorageSync;
|
|
const removeStorage = defineAsyncApi<RemoveStorageOptions, RemoveStorageSuccess>(API_REMOVE_STORAGE, (args: RemoveStorageOptions, exec: ApiExecutor<RemoveStorageSuccess>)=>{
|
|
createStore().delete(args.key).then(()=>{
|
|
createStore().flush();
|
|
exec.resolve({} as ESObject);
|
|
}, (error: Error)=>{
|
|
exec.reject(error.message);
|
|
});
|
|
}) as RemoveStorage;
|
|
const clearStorageSync = defineSyncApi<void>(API_CLEAR_STORAGE_SYNC, ()=>{
|
|
createStore().clearSync();
|
|
createStore().flush();
|
|
}) as ClearStorageSync;
|
|
const clearStorage = defineAsyncApi<ClearStorageOptions, ClearStorageSuccess>(API_CLEAR_STORAGE, (args: ClearStorageOptions, exec: ApiExecutor<ClearStorageSuccess>)=>{
|
|
createStore().clear().then(()=>{
|
|
createStore().flush();
|
|
exec.resolve({} as ESObject);
|
|
}, (error: Error)=>{
|
|
exec.reject(error.message);
|
|
});
|
|
}) as ClearStorage;
|
|
const getStorageInfoSync = defineSyncApi<GetStorageInfoSuccess>(API_GET_STORAGE_INFO_SYNC, ()=>{
|
|
const allData = createStore().getAllSync();
|
|
return {
|
|
keys: Object.keys(allData),
|
|
currentSize: 0,
|
|
limitSize: 0
|
|
} as GetStorageInfoSuccess;
|
|
}) as GetStorageInfoSync;
|
|
const getStorageInfo = defineAsyncApi<GetStorageInfoOptions, GetStorageInfoSuccess>(API_GET_STORAGE_INFO, (args: GetStorageInfoOptions, exec: ApiExecutor<GetStorageInfoSuccess>)=>{
|
|
createStore().getAll().then((allData)=>{
|
|
exec.resolve({
|
|
keys: Object.keys(allData),
|
|
currentSize: 0,
|
|
limitSize: 0
|
|
} as GetStorageInfoSuccess);
|
|
});
|
|
}) as GetStorageInfo;
|
|
const API_CONNECT_SOCKET = 'connectSocket';
|
|
const ConnectSocketApiProtocol = new Map<string, ProtocolOptions>([
|
|
[
|
|
'url',
|
|
{
|
|
type: 'string',
|
|
required: true
|
|
}
|
|
],
|
|
[
|
|
'header',
|
|
{
|
|
type: 'object',
|
|
required: false
|
|
}
|
|
],
|
|
[
|
|
'protocols',
|
|
{
|
|
type: 'string[]',
|
|
required: false
|
|
}
|
|
]
|
|
]);
|
|
const ConnectSocketApiOptions: ApiOptions<ConnectSocketOptions> = {
|
|
formatArgs: new Map<string, Function>([
|
|
[
|
|
'url',
|
|
(url: string, params: ConnectSocketOptions)=>{
|
|
if (url == null) {
|
|
throw new Error('url is required');
|
|
}
|
|
}
|
|
]
|
|
])
|
|
};
|
|
const API_SEND_SOCKET_MESSAGE = 'sendSocketMessage';
|
|
const API_CLOSE_SOCKET = 'closeSocket';
|
|
const tryExec = (fn: Function | null | undefined, ...args: Object[])=>{
|
|
if (!fn) {
|
|
return;
|
|
}
|
|
try {
|
|
fn(...args);
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
};
|
|
const GlobalWebsocketEmitter = new Emitter5() as IUniWebsocketEmitter;
|
|
const destroySocketTaskEmitter = (emitter: IUniWebsocketEmitter)=>{
|
|
emitter.off('message');
|
|
emitter.off('open');
|
|
emitter.off('error');
|
|
emitter.off('close');
|
|
};
|
|
class SocketTask1 implements SocketTask {
|
|
__v_skip: boolean = true;
|
|
_destroy: Function;
|
|
private _ws: webSocket.WebSocket;
|
|
private _emitter: IUniWebsocketEmitter = new Emitter5() as IUniWebsocketEmitter;
|
|
constructor(ws: webSocket.WebSocket){
|
|
const mp = getCurrentMP5();
|
|
this._ws = ws;
|
|
this._ws.on('message', (_, data)=>{
|
|
const message = {
|
|
data
|
|
} as OnSocketMessageCallbackResult;
|
|
this._emitter.emit('message', message);
|
|
const socketTasks = getSocketTasks(mp.id);
|
|
if (this === socketTasks[0]) {
|
|
GlobalWebsocketEmitter.emit('message', message);
|
|
}
|
|
});
|
|
this._ws.on('open', (_, data)=>{
|
|
this._emitter.emit('open', data);
|
|
const socketTasks = getSocketTasks(mp.id);
|
|
if (this === socketTasks[0]) {
|
|
GlobalWebsocketEmitter.emit('open', data);
|
|
}
|
|
});
|
|
this._ws.on('error', (error)=>{
|
|
const message = {
|
|
errMsg: error.message
|
|
} as OnSocketErrorCallbackResult;
|
|
this._emitter.emit('error', message);
|
|
const socketTasks = getSocketTasks(mp.id);
|
|
if (this === socketTasks[0]) {
|
|
GlobalWebsocketEmitter.emit('error', message);
|
|
}
|
|
});
|
|
this._ws.on('close', (_, data)=>{
|
|
this._emitter.emit('close', data);
|
|
const socketTasks = getSocketTasks(mp.id);
|
|
if (this === socketTasks[0]) {
|
|
GlobalWebsocketEmitter.emit('close', data);
|
|
}
|
|
const index = socketTasks.indexOf(this);
|
|
if (index >= 0) {
|
|
socketTasks.splice(index, 1);
|
|
}
|
|
});
|
|
this._destroy = ()=>{
|
|
destroySocketTaskEmitter(this._emitter);
|
|
this.close();
|
|
};
|
|
}
|
|
send(options: SendSocketMessageOptions) {
|
|
this._ws.send(options.data as string | ArrayBuffer).then((success: boolean)=>{
|
|
if (success) {
|
|
tryExec(options.success, {} as GeneralCallbackResult);
|
|
} else {
|
|
tryExec(options.fail, new UniError('send message failed'));
|
|
}
|
|
}, (err: Error)=>{
|
|
tryExec(options.fail, new UniError(err.message));
|
|
});
|
|
}
|
|
close(options: CloseSocketOptions | null = null) {
|
|
this._ws.close({
|
|
code: typeof options?.code === 'number' ? options.code : 1000,
|
|
reason: typeof options?.reason === 'string' ? options.reason : ''
|
|
} as webSocket.WebSocketCloseOptions).then((success: boolean)=>{
|
|
if (success) {
|
|
tryExec(options?.success, {} as GeneralCallbackResult);
|
|
} else {
|
|
tryExec(options?.fail, new UniError('close socket failed'));
|
|
}
|
|
}, (err: Error)=>{
|
|
tryExec(options?.fail, new UniError(err.message));
|
|
});
|
|
}
|
|
onMessage(callback: Function) {
|
|
this._emitter.on('message', callback);
|
|
}
|
|
onOpen(callback: Function) {
|
|
this._emitter.on('open', callback);
|
|
}
|
|
onError(callback: Function) {
|
|
this._emitter.on('error', callback);
|
|
}
|
|
onClose(callback: Function) {
|
|
this._emitter.on('close', callback);
|
|
}
|
|
}
|
|
const socketTasksMap: Map<string, SocketTask1[]> = new Map();
|
|
const addSocketTask = (task: SocketTask1)=>{
|
|
const mp = getCurrentMP5();
|
|
mp.on('beforeClose', task._destroy);
|
|
task.onClose(()=>{
|
|
mp.off('beforeClose', task._destroy);
|
|
});
|
|
const id = mp.id;
|
|
if (!socketTasksMap.has(id)) {
|
|
socketTasksMap.set(id, []);
|
|
}
|
|
const socketTasks = socketTasksMap.get(id) as SocketTask1[];
|
|
socketTasks.push(task);
|
|
};
|
|
const getSocketTasks = (id: string | null = null)=>{
|
|
if (!id) {
|
|
const mp = getCurrentMP5();
|
|
id = mp.id;
|
|
}
|
|
return socketTasksMap.get(id!) || [];
|
|
};
|
|
const connectSocket = defineTaskApi<ConnectSocketOptions, ConnectSocketSuccess, SocketTask>(API_CONNECT_SOCKET, (args: ConnectSocketOptions, exec: ApiExecutor<ConnectSocketSuccess>)=>{
|
|
const ws = webSocket.createWebSocket();
|
|
const mp = getCurrentMP5();
|
|
ws.connect(args.url, {
|
|
header: args.header ? args.header as Object : undefined,
|
|
protocol: args.protocols ? Array.isArray(args.protocols) ? args.protocols.join(',') : args.protocols : ''
|
|
} as webSocket.WebSocketRequestOptions);
|
|
const task = new SocketTask1(ws);
|
|
mp.on('beforeClose', task._destroy);
|
|
task.onClose(()=>{
|
|
mp.off('beforeClose', task._destroy);
|
|
});
|
|
addSocketTask(task);
|
|
return task;
|
|
}, ConnectSocketApiProtocol, ConnectSocketApiOptions) as ConnectSocket;
|
|
const onSocketMessage: OnSocketMessage = (callback: Function)=>{
|
|
GlobalWebsocketEmitter.on('message', callback);
|
|
};
|
|
const onSocketOpen: OnSocketOpen = (callback: Function)=>{
|
|
GlobalWebsocketEmitter.on('open', callback);
|
|
};
|
|
const onSocketError: OnSocketError = (callback: Function)=>{
|
|
GlobalWebsocketEmitter.on('error', callback);
|
|
};
|
|
const onSocketClose: OnSocketClose = (callback: Function)=>{
|
|
GlobalWebsocketEmitter.on('close', callback);
|
|
};
|
|
const sendSocketMessage = defineAsyncApi<SendSocketMessageOptions, GeneralCallbackResult>(API_SEND_SOCKET_MESSAGE, (args: SendSocketMessageOptions, exec: ApiExecutor<GeneralCallbackResult>)=>{
|
|
const socketTasks = getSocketTasks();
|
|
const task = socketTasks[0];
|
|
if (task) {
|
|
task.send({
|
|
data: args.data,
|
|
success (res) {
|
|
exec.resolve(res);
|
|
},
|
|
fail (err) {
|
|
exec.reject('sendSocketMessage:fail');
|
|
}
|
|
} as SendSocketMessageOptions);
|
|
} else {
|
|
exec.reject('WebSocket is not connected');
|
|
}
|
|
}) as SendSocketMessage;
|
|
const closeSocket = defineAsyncApi<CloseSocketOptions, GeneralCallbackResult>(API_CLOSE_SOCKET, (args: CloseSocketOptions, exec: ApiExecutor<GeneralCallbackResult>)=>{
|
|
const socketTasks = getSocketTasks();
|
|
const task = socketTasks[0];
|
|
if (task) {
|
|
task.close({
|
|
code: args.code,
|
|
reason: args.reason,
|
|
success (res) {
|
|
exec.resolve(res);
|
|
},
|
|
fail (err) {
|
|
exec.reject('closeSocket:fail');
|
|
}
|
|
} as CloseSocketOptions);
|
|
} else {
|
|
exec.reject('WebSocket is not connected');
|
|
}
|
|
}) as CloseSocket;
|
|
return {
|
|
addPhoneContact,
|
|
startSoterAuthentication,
|
|
checkIsSupportSoterAuthentication,
|
|
checkIsSoterEnrolledInDevice,
|
|
chooseMedia,
|
|
getClipboardData,
|
|
setClipboardData,
|
|
createInnerAudioContext,
|
|
$on,
|
|
$once,
|
|
$off,
|
|
$emit,
|
|
exit,
|
|
saveFile,
|
|
getSavedFileList,
|
|
getSavedFileInfo,
|
|
removeSavedFile,
|
|
getFileInfo,
|
|
getFileSystemManager,
|
|
getAppAuthorizeSetting,
|
|
getAppBaseInfo,
|
|
getBackgroundAudioManager,
|
|
getDeviceInfo,
|
|
getNetworkType,
|
|
onNetworkStatusChange,
|
|
offNetworkStatusChange,
|
|
getProvider,
|
|
getProviderSync,
|
|
getRecorderManager,
|
|
getSystemInfo,
|
|
getSystemInfoSync,
|
|
getWindowInfo,
|
|
getSystemSetting,
|
|
hideKeyboard,
|
|
makePhoneCall,
|
|
chooseImage,
|
|
previewImage,
|
|
closePreviewImage,
|
|
getImageInfo,
|
|
saveImageToPhotosAlbum,
|
|
compressImage,
|
|
chooseVideo,
|
|
saveVideoToPhotosAlbum,
|
|
getVideoInfo,
|
|
compressVideo,
|
|
chooseFile,
|
|
request,
|
|
uploadFile,
|
|
downloadFile,
|
|
configMTLS,
|
|
login,
|
|
getUserInfo,
|
|
openAppAuthorizeSetting,
|
|
openDocument,
|
|
requestPayment,
|
|
showToast,
|
|
hideToast,
|
|
showLoading,
|
|
hideLoading,
|
|
showModal,
|
|
showActionSheet,
|
|
startPullDownRefresh,
|
|
stopPullDownRefresh,
|
|
rpx2px,
|
|
scanCode,
|
|
shareWithSystem,
|
|
setStorage,
|
|
setStorageSync,
|
|
getStorage,
|
|
getStorageSync,
|
|
getStorageInfo,
|
|
getStorageInfoSync,
|
|
removeStorage,
|
|
removeStorageSync,
|
|
clearStorage,
|
|
clearStorageSync,
|
|
connectSocket,
|
|
sendSocketMessage,
|
|
closeSocket,
|
|
onSocketOpen,
|
|
onSocketMessage,
|
|
onSocketClose,
|
|
onSocketError
|
|
} as UniExtApi;
|
|
}
|