diff --git a/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets b/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets index 506805e821a8110d364a58d37aece8fdc0eb90fa..55690fa174e5f63d51c3d835077df185f9fc3b3c 100644 --- a/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets +++ b/interfaces/ets/ani/resourceManager/ets/@ohos.resourceManager.ets @@ -16,6 +16,7 @@ import { AsyncCallback, BusinessError } from '@ohos.base'; import { RawFileDescriptor as _RawFileDescriptor } from 'global.rawFileDescriptor'; import { Resource as _Resource } from 'global.resource'; +import { RawFileDescriptorInner } from 'global.rawFileDescriptorInner'; export default namespace resourceManager { loadLibrary("resmgr_ani.z"); @@ -65,35 +66,115 @@ export default namespace resourceManager { } export interface ResourceManager { - getStringValue(resource: Resource, callback: AsyncCallback): void; - getStringValue(resource: Resource): Promise; + getDeviceCapability(callback: AsyncCallback): void; + getDeviceCapability(): Promise; + + getConfiguration(callback: AsyncCallback): void; + getConfiguration(): Promise; + + getStringByName(resName: string, callback: AsyncCallback): void; + getStringByName(resName: string): Promise; + + getStringArrayByName(resName: string, callback: AsyncCallback, void>): void; + getStringArrayByName(resName: string): Promise>; + + getMediaByName(resName: string, callback: AsyncCallback): void; + getMediaByName(resName: string, density: number, callback: AsyncCallback): void; + getMediaByName(resName: string): Promise; + getMediaByName(resName: string, density: number): Promise; + + getMediaBase64ByName(resName: string, callback: AsyncCallback): void; + getMediaBase64ByName(resName: string, density: number, callback: AsyncCallback): void; + getMediaBase64ByName(resName: string): Promise; + getMediaBase64ByName(resName: string, density: number): Promise; getStringSync(resId: number): string; getStringSync(resId: number, ...args: (string | number)[]): string; - getStringSync(resource: Resource): string; - getStringSync(resource: Resource, ...args: (string | number)[]): string; + + getStringByNameSync(resName: string): string; + getStringByNameSync(resName: string, ...args: (string | number)[]): string; + + getBoolean(resId: number): boolean; + getBooleanByName(resName: string): boolean; getNumber(resId: number): number; - getNumber(resource: Resource): number; + getNumberByName(resName: string): number; getStringValue(resId: number, callback: AsyncCallback): void; getStringValue(resId: number): Promise; + getStringArrayValue(resId: number, callback: AsyncCallback, void>): void; + getStringArrayValue(resId: number): Promise>; + + getIntPluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; + getIntPluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; + + getDoublePluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; + getDoublePluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; + + getMediaContent(resId: number, callback: AsyncCallback): void; + getMediaContent(resId: number, density: number, callback: AsyncCallback): void; + getMediaContent(resId: number): Promise; + getMediaContent(resId: number, density: number): Promise; + + getMediaContentBase64(resId: number, callback: AsyncCallback): void; + getMediaContentBase64(resId: number, density: number, callback: AsyncCallback): void; + getMediaContentBase64(resId: number): Promise; + getMediaContentBase64(resId: number, density: number): Promise; + getRawFileContent(path: string, callback: AsyncCallback): void; getRawFileContent(path: string): Promise; + getRawFd(path: string, callback: AsyncCallback): void; + getRawFd(path: string): Promise; + + closeRawFd(path: string, callback: AsyncCallback): void; + closeRawFd(path: string): Promise; + + getRawFileList(path: string, callback: AsyncCallback, void>): void; + getRawFileList(path: string): Promise>; + + getColor(resId: number, callback: AsyncCallback): void; + getColor(resId: number): Promise; + + getColorByName(resName: string, callback: AsyncCallback): void; + getColorByName(resName: string): Promise; + getColorSync(resId: number): number; - getColorSync(resource: Resource): number; + getColorByNameSync(resName: string) : number; + + addResource(path: string) : void; + removeResource(path: string) : void; + getRawFdSync(path: string): RawFileDescriptor; + closeRawFdSync(path: string): void; + + getRawFileListSync(path: string): Array; getRawFileContentSync(path: string): Uint8Array; - getIntPluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; - getIntPluralStringValueSync(resource: Resource, num: number, ...args: (string | number)[]): string; - getIntPluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; + getMediaContentSync(resId: number, density?: number): Uint8Array; - getDoublePluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; - getDoublePluralStringValueSync(resource: Resource, num: number, ...args: (string | number)[]): string; - getDoublePluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; + getMediaContentBase64Sync(resId: number, density?: number): string; + + getStringArrayValueSync(resId: number): Array; + + getMediaByNameSync(resName: string, density?: number): Uint8Array; + getMediaBase64ByNameSync(resName: string, density?: number): string; + + getStringArrayByNameSync(resName: string): Array; + + getConfigurationSync(): Configuration; + getDeviceCapabilitySync(): DeviceCapability; + getLocales(includeSystem?: boolean): Array; + + getSymbol(resId: number) : number; + getSymbolByName(resName: string) : number; + + isRawDir(path: string): boolean; + + getOverrideResourceManager(configuration?: Configuration): ResourceManager; + getOverrideConfiguration(): Configuration; + updateOverrideConfiguration(configuration: Configuration): void; } export type RawFileDescriptor = _RawFileDescriptor; @@ -112,30 +193,64 @@ export default namespace resourceManager { native getStringSync(resId: number): string; native getStringSync(resId: number, ...args: (string | number)[]): string; - native getStringSync(resource: Resource): string; - native getStringSync(resource: Resource, ...args: (string | number)[]): string; + + native getStringByNameSync(resName: string): string; + native getStringByNameSync(resName: string, ...args: (string | number)[]): string; + + native getBoolean(resId: number): boolean; + native getBooleanByName(resName: string): boolean; + native getNumber(resId: number): number; - native getNumber(resource: Resource): number; - native getColorSync(resId: number): number; - native getColorSync(resource: Resource): number; - native getRawFileContentSync(path: string): Uint8Array; + native getNumberByName(resName: string): number; native getIntPluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; - native getIntPluralStringValueSync(resource: Resource, num: number, ...args: (string | number)[]): string; native getIntPluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; native getDoublePluralStringValueSync(resId: number, num: number, ...args: (string | number)[]): string; - native getDoublePluralStringValueSync(resource: Resource, num: number, ...args: (string | number)[]): string; native getDoublePluralStringByNameSync(resName: string, num: number, ...args: (string | number)[]): string; + native getColorSync(resId: number): number; + native getColorByNameSync(resName: string) : number; + + native addResource(path: string) : void; + native removeResource(path: string) : void; + + native getRawFdSync(path: string): RawFileDescriptor; + native closeRawFdSync(path: string): void; + native isRawDir(path: string): boolean; + + native getRawFileListSync(path: string): Array; + native getRawFileContentSync(path: string): Uint8Array; + + native getMediaContentSync(resId: number, density?: number): Uint8Array; + + native getMediaContentBase64Sync(resId: number, density?: number): string; + + native getStringArrayValueSync(resId: number): Array; + native getStringArrayByNameSync(resName: string): Array; + + native getMediaByNameSync(resName: string, density?: number): Uint8Array; + native getMediaBase64ByNameSync(resName: string, density?: number): string; + + native getConfigurationSync(): Configuration; + native getDeviceCapabilitySync(): DeviceCapability; + native getLocales(includeSystem?: boolean): Array; + + native getSymbol(resId: number) : number; + native getSymbolByName(resName: string) : number; + + native getOverrideResourceManager(configuration?: Configuration): ResourceManager; + native getOverrideConfiguration(): Configuration; + native updateOverrideConfiguration(configuration: Configuration): void; + getStringValue(resId: number, callback: AsyncCallback): void { let p1 = taskpool.execute((): string => { return this.getStringSync(resId); }) p1.then((content: NullishType) => { - callback(new BusinessError(), content as string); - }).catch((err: BusinessError): void => { - callback(err, ""); + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); }); } @@ -145,30 +260,306 @@ export default namespace resourceManager { return this.getStringSync(resId); }).then((content: NullishType) => { resolve(content as string); - }, (err: BusinessError): void => { + }, (err: Error): void => { reject(err); }); }); } - getStringValue(resource: Resource, callback: AsyncCallback): void { + getStringArrayValue(resId: number, callback: AsyncCallback, void>): void { + let p1 = taskpool.execute((): Array => { + return this.getStringArrayValueSync(resId); + }) + p1.then((content: NullishType) => { + callback(null, content as Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getStringArrayValue(resId: number): Promise> { + return new Promise>((resolve, reject) => { + taskpool.execute((): Array => { + return this.getStringArrayValueSync(resId); + }).then((content: NullishType) => { + resolve(content as Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getDeviceCapability(callback: AsyncCallback): void { + let p1 = taskpool.execute((): DeviceCapability => { + return this.getDeviceCapabilitySync(); + }) + p1.then((content: NullishType) => { + callback(null, content as DeviceCapability); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getDeviceCapability(): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): DeviceCapability => { + return this.getDeviceCapabilitySync(); + }).then((content: NullishType) => { + resolve(content as DeviceCapability); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getConfiguration(callback: AsyncCallback): void { + let p1 = taskpool.execute((): Configuration => { + return this.getConfigurationSync(); + }) + p1.then((content: NullishType) => { + callback(null, content as Configuration); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getConfiguration(): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): Configuration => { + return this.getConfigurationSync(); + }).then((content: NullishType) => { + resolve(content as Configuration); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getStringByName(resName: string, callback: AsyncCallback): void { let p1 = taskpool.execute((): string => { - return this.getStringSync(resource); + return this.getStringByNameSync(resName); }) p1.then((content: NullishType) => { - callback(new BusinessError(), content as string); - }).catch((err: BusinessError): void => { - callback(err, ""); + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); }); } - getStringValue(resource: Resource): Promise { + getStringByName(resName: string): Promise { return new Promise((resolve, reject) => { taskpool.execute((): string => { - return this.getStringSync(resource); + return this.getStringByNameSync(resName); }).then((content: NullishType) => { resolve(content as string); - }, (err: BusinessError): void => { + }, (err: Error): void => { + reject(err); + }); + }); + } + + getStringArrayByName(resName: string, callback: AsyncCallback, void>): void { + let p1 = taskpool.execute((): Array => { + return this.getStringArrayByNameSync(resName); + }) + p1.then((content: NullishType) => { + callback(null, content as Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getStringArrayByName(resName: string): Promise> { + return new Promise>((resolve, reject) => { + taskpool.execute((): Array => { + return this.getStringArrayByNameSync(resName); + }).then((content: NullishType) => { + resolve(content as Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaByName(resName: string, callback: AsyncCallback): void { + let p1 = taskpool.execute((): Uint8Array => { + return this.getMediaByNameSync(resName); + }) + p1.then((content: NullishType) => { + callback(null, content as Uint8Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaByName(resName: string): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): Uint8Array => { + return this.getMediaByNameSync(resName); + }).then((content: NullishType) => { + resolve(content as Uint8Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaByName(resName: string, density: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): Uint8Array => { + return this.getMediaByNameSync(resName, density); + }) + p1.then((content: NullishType) => { + callback(null, content as Uint8Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaByName(resName: string, density: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): Uint8Array => { + return this.getMediaByNameSync(resName, density); + }).then((content: NullishType) => { + resolve(content as Uint8Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaBase64ByName(resName: string, callback: AsyncCallback): void { + let p1 = taskpool.execute((): string => { + return this.getMediaBase64ByNameSync(resName); + }) + p1.then((content: NullishType) => { + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaBase64ByName(resName: string): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): string => { + return this.getMediaBase64ByNameSync(resName); + }).then((content: NullishType) => { + resolve(content as string); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaBase64ByName(resName: string, density: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): string => { + return this.getMediaBase64ByNameSync(resName, density); + }) + p1.then((content: NullishType) => { + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaBase64ByName(resName: string, density: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): string => { + return this.getMediaBase64ByNameSync(resName, density); + }).then((content: NullishType) => { + resolve(content as string); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaContent(resId: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): Uint8Array => { + return this.getMediaContentSync(resId); + }) + p1.then((content: NullishType) => { + callback(null, content as Uint8Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaContent(resId: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): Uint8Array => { + return this.getMediaContentSync(resId); + }).then((content: NullishType) => { + resolve(content as Uint8Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaContent(resId: number, density: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): Uint8Array => { + return this.getMediaContentSync(resId, density); + }) + p1.then((content: NullishType) => { + callback(null, content as Uint8Array); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaContent(resId: number, density: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): Uint8Array => { + return this.getMediaContentSync(resId, density); + }).then((content: NullishType) => { + resolve(content as Uint8Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaContentBase64(resId: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): string => { + return this.getMediaContentBase64Sync(resId); + }) + p1.then((content: NullishType) => { + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaContentBase64(resId: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): string => { + return this.getMediaContentBase64Sync(resId); + }).then((content: NullishType) => { + resolve(content as string); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getMediaContentBase64(resId: number, density: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): string => { + return this.getMediaContentBase64Sync(resId, density); + }) + p1.then((content: NullishType) => { + callback(null, content as string); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getMediaContentBase64(resId: number, density: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): string => { + return this.getMediaContentBase64Sync(resId, density); + }).then((content: NullishType) => { + resolve(content as string); + }, (err: Error): void => { reject(err); }); }); @@ -179,9 +570,9 @@ export default namespace resourceManager { return this.getRawFileContentSync(path); }) p1.then((content: NullishType) => { - callback(new BusinessError(), content as Uint8Array); - }, (err: BusinessError): void => { - callback(err, new Uint8Array()); + callback(null, content as Uint8Array); + }, (err: Error): void => { + callback(err as BusinessError, undefined); }); } @@ -191,7 +582,122 @@ export default namespace resourceManager { return this.getRawFileContentSync(path); }).then((content: NullishType) => { resolve(content as Uint8Array); - }, (err: BusinessError): void => { + }, (err: Error): void => { + reject(err); + }); + }); + } + + getRawFd(path: string, callback: AsyncCallback): void { + let p1 = taskpool.execute((): RawFileDescriptor => { + return this.getRawFdSync(path); + }) + p1.then((content: NullishType) => { + callback(null, content as RawFileDescriptor); + }, (err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getRawFd(path: string): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): RawFileDescriptor => { + return this.getRawFdSync(path); + }).then((content: NullishType) => { + resolve(content as RawFileDescriptor); + }, (err: Error): void => { + reject(err); + }); + }); + } + + closeRawFd(path: string, callback: AsyncCallback): void { + let p1 = taskpool.execute((): void => { + return this.closeRawFdSync(path); + }) + p1.then(() => { + callback(null, undefined); + }, (err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + closeRawFd(path: string): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): void => { + return this.closeRawFdSync(path); + }).then(() => { + resolve(undefined); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getRawFileList(path: string, callback: AsyncCallback, void>): void { + let p1 = taskpool.execute((): Array => { + return this.getRawFileListSync(path); + }) + p1.then((content: NullishType) => { + callback(null, content as Array); + }, (err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getRawFileList(path: string): Promise> { + return new Promise>((resolve, reject) => { + taskpool.execute((): Array => { + return this.getRawFileListSync(path); + }).then((content: NullishType) => { + resolve(content as Array); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getColor(resId: number, callback: AsyncCallback): void { + let p1 = taskpool.execute((): number => { + return this.getColorSync(resId); + }) + p1.then((content: NullishType) => { + callback(null, content as number); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getColor(resId: number): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): number => { + return this.getColorSync(resId); + }).then((content: NullishType) => { + resolve(content as number); + }, (err: Error): void => { + reject(err); + }); + }); + } + + getColorByName(resName: string, callback: AsyncCallback): void { + let p1 = taskpool.execute((): number => { + return this.getColorByNameSync(resName); + }) + p1.then((content: NullishType) => { + callback(null, content as number); + }).catch((err: Error): void => { + callback(err as BusinessError, undefined); + }); + } + + getColorByName(resName: string): Promise { + return new Promise((resolve, reject) => { + taskpool.execute((): number => { + return this.getColorByNameSync(resName); + }).then((content: NullishType) => { + resolve(content as number); + }, (err: Error): void => { reject(err); }); }); diff --git a/interfaces/ets/ani/resourceManager/include/resourceManager.h b/interfaces/ets/ani/resourceManager/include/resourceManager.h index 74cb99439553b8c154b4e0cb38b3c627eb5901a6..faf1b48084369478311a870c84f34b0cbb62d7a1 100644 --- a/interfaces/ets/ani/resourceManager/include/resourceManager.h +++ b/interfaces/ets/ani/resourceManager/include/resourceManager.h @@ -31,33 +31,72 @@ public: ResMgrAddon(const std::string& bundleName, const std::shared_ptr& resMgr, const std::shared_ptr& context, bool isSystem = false); ResMgrAddon(const std::shared_ptr& resMgr, bool isSystem = false); + ani_object CreateOverrideAddon(ani_env* env, const std::shared_ptr& resMgr); + static ani_object CreateResMgr(ani_env* env, const std::string& bundleName, const std::shared_ptr& resMgr, std::shared_ptr context); static ani_object GetSystemResourceManager(ani_env* env); static ani_string GetStringSyncById(ani_env* env, ani_object object, ani_double resId); static ani_string GetFormatStringSyncById(ani_env *env, ani_object object, ani_double resId, ani_object args); - static ani_string GetStringSync(ani_env* env, ani_object object, ani_object resource); - static ani_string GetFormatStringSync(ani_env *env, ani_object object, ani_object resource, ani_object args); + + static ani_string GetStringByNameSync(ani_env* env, ani_object object, ani_string resName); + static ani_string GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string resName, ani_object args); + + static ani_boolean GetBooleanById(ani_env* env, ani_object object, ani_double resId); + static ani_boolean GetBooleanByName(ani_env* env, ani_object object, ani_string resName); + static ani_double GetNumberById(ani_env* env, ani_object object, ani_double resId); - static ani_double GetNumber(ani_env* env, ani_object object, ani_object resource); + static ani_double GetNumberByName(ani_env* env, ani_object object, ani_string resName); + static ani_double GetColorSyncById(ani_env* env, ani_object object, ani_double resId); - static ani_double GetColorSync(ani_env* env, ani_object object, ani_object resource); - static ani_object GetRawFileContentSync(ani_env* env, ani_object object, ani_string path); static ani_string GetIntPluralStringValueSyncById(ani_env* env, ani_object object, ani_double resId, ani_double num, ani_object args); - static ani_string GetIntPluralStringValueSync(ani_env* env, ani_object object, - ani_object resource, ani_double num, ani_object args); + static ani_string GetIntPluralStringByNameSync(ani_env* env, ani_object object, ani_string resName, ani_double num, ani_object args); static ani_string GetDoublePluralStringValueSyncById(ani_env* env, ani_object object, ani_double resId, ani_double num, ani_object args); - static ani_string GetDoublePluralStringValueSync(ani_env* env, ani_object object, - ani_object resource, ani_double num, ani_object args); + static ani_string GetDoublePluralStringByNameSync(ani_env* env, ani_object object, ani_string resName, ani_double num, ani_object args); + + static ani_double GetColorByNameSync(ani_env* env, ani_object object, ani_string resName); + + static void AddResource(ani_env* env, ani_object object, ani_string path); + static void RemoveResource(ani_env* env, ani_object object, ani_string path); + + static ani_object GetRawFdSync(ani_env* env, ani_object object, ani_string path); + static void CloseRawFdSync(ani_env* env, ani_object object, ani_string path); + static ani_boolean IsRawDir(ani_env* env, ani_object object, ani_string path); + + static ani_object GetRawFileListSync(ani_env* env, ani_object object, ani_string path); + static ani_object GetRawFileContentSync(ani_env* env, ani_object object, ani_string path); + + static ani_object GetMediaContentSyncById(ani_env* env, ani_object object, + ani_double resId, ani_object density); + + static ani_string GetMediaContentBase64SyncById(ani_env* env, ani_object object, + ani_double resId, ani_object density); + + static ani_object GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_double resId); + static ani_object GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string resName); + + static ani_object GetMediaByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density); + static ani_string GetMediaBase64ByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density); + + static ani_object GetConfigurationSync(ani_env* env, ani_object object); + static ani_object GetDeviceCapabilitySync(ani_env* env, ani_object object); + static ani_object GetLocales(ani_env* env, ani_object object, ani_object includeSystem); + + static ani_double GetSymbolById(ani_env* env, ani_object object, ani_double resId); + static ani_double GetSymbolByName(ani_env* env, ani_object object, ani_string resName); + + static ani_object GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration); + static ani_object GetOverrideConfiguration(ani_env* env, ani_object object); + static void UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration); static ani_status BindContext(ani_env* env); inline std::shared_ptr GetResMgr() diff --git a/interfaces/ets/ani/resourceManager/src/resourceManager.cpp b/interfaces/ets/ani/resourceManager/src/resourceManager.cpp index e50b70e36d87f6c4d183bfcfe58cc107087f1f63..34eca487dc0c73990815b7187ab2a96ca09e1afd 100644 --- a/interfaces/ets/ani/resourceManager/src/resourceManager.cpp +++ b/interfaces/ets/ani/resourceManager/src/resourceManager.cpp @@ -25,6 +25,15 @@ using namespace Resource; constexpr ani_double ABNORMAL_NUMBER_RETURN_VALUE = -1; +enum ScreenDensityIndex { + SCREEN_DENSITY_ONE = 0, + SCREEN_DENSITY_TWO = 1, + SCREEN_DENSITY_THREE = 2, + SCREEN_DENSITY_FOUR = 3, + SCREEN_DENSITY_FIVE = 4, + SCREEN_DENSITY_SIX = 5, +}; + struct ArrayElement { enum class ElementType { NUMBER, STRING } type; std::variant value; @@ -38,35 +47,72 @@ static std::mutex sysMgrMutex; static std::array methods = { ani_native_function { "getStringSync", "D:Lstd/core/String;", reinterpret_cast(ResMgrAddon::GetStringSyncById) }, - ani_native_function { "getStringSync", "D[Lstd/core/Object;:Lstd/core/String;", + ani_native_function { "getStringSync", "DLescompat/Array;:Lstd/core/String;", reinterpret_cast(ResMgrAddon::GetFormatStringSyncById) }, - ani_native_function { "getStringSync", "Lglobal/resource/Resource;:Lstd/core/String;", - reinterpret_cast(ResMgrAddon::GetStringSync) }, - ani_native_function { "getStringSync", "Lglobal/resource/Resource;[Lstd/core/Object;:Lstd/core/String;", - reinterpret_cast(ResMgrAddon::GetFormatStringSync) }, + + ani_native_function { "getStringByNameSync", "Lstd/core/String;:Lstd/core/String;", + reinterpret_cast(ResMgrAddon::GetStringByNameSync) }, + ani_native_function { "getStringByNameSync", "Lstd/core/String;Lescompat/Array;:Lstd/core/String;", + reinterpret_cast(ResMgrAddon::GetFormatStringByNameSync) }, + + ani_native_function { "getBoolean", "D:Z", reinterpret_cast(ResMgrAddon::GetBooleanById) }, + ani_native_function { "getBooleanByName", nullptr, reinterpret_cast(ResMgrAddon::GetBooleanByName) }, + ani_native_function { "getNumber", "D:D", reinterpret_cast(ResMgrAddon::GetNumberById) }, - ani_native_function { "getNumber", "Lglobal/resource/Resource;:D", - reinterpret_cast(ResMgrAddon::GetNumber) }, - ani_native_function { "getColorSync", "D:D", reinterpret_cast(ResMgrAddon::GetColorSyncById) }, - ani_native_function { "getColorSync", "Lglobal/resource/Resource;:D", - reinterpret_cast(ResMgrAddon::GetColorSync) }, - ani_native_function { "getRawFileContentSync", nullptr, - reinterpret_cast(ResMgrAddon::GetRawFileContentSync) }, - ani_native_function { "getIntPluralStringValueSync", "DD[Lstd/core/Object;:Lstd/core/String;", + ani_native_function { "getNumberByName", nullptr, reinterpret_cast(ResMgrAddon::GetNumberByName) }, + + ani_native_function { "getIntPluralStringValueSync", "DDLescompat/Array;:Lstd/core/String;", reinterpret_cast(ResMgrAddon::GetIntPluralStringValueSyncById) }, - ani_native_function { "getIntPluralStringValueSync", - "Lglobal/resource/Resource;D[Lstd/core/Object;:Lstd/core/String;", - reinterpret_cast(ResMgrAddon::GetIntPluralStringValueSync) }, ani_native_function { "getIntPluralStringByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetIntPluralStringByNameSync) }, - ani_native_function { "getDoublePluralStringValueSync", "DD[Lstd/core/Object;:Lstd/core/String;", + ani_native_function { "getDoublePluralStringValueSync", "DDLescompat/Array;:Lstd/core/String;", reinterpret_cast(ResMgrAddon::GetDoublePluralStringValueSyncById) }, - ani_native_function { "getDoublePluralStringValueSync", - "Lglobal/resource/Resource;D[Lstd/core/Object;:Lstd/core/String;", - reinterpret_cast(ResMgrAddon::GetDoublePluralStringValueSync) }, ani_native_function { "getDoublePluralStringByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetDoublePluralStringByNameSync) }, + + ani_native_function { "getColorSync", "D:D", reinterpret_cast(ResMgrAddon::GetColorSyncById) }, + ani_native_function { "getColorByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetColorByNameSync) }, + + ani_native_function { "addResource", nullptr, reinterpret_cast(ResMgrAddon::AddResource) }, + ani_native_function { "removeResource", nullptr, reinterpret_cast(ResMgrAddon::RemoveResource) }, + + ani_native_function { "getRawFdSync", nullptr, reinterpret_cast(ResMgrAddon::GetRawFdSync) }, + ani_native_function { "closeRawFdSync", nullptr, reinterpret_cast(ResMgrAddon::CloseRawFdSync) }, + ani_native_function { "isRawDir", nullptr, reinterpret_cast(ResMgrAddon::IsRawDir) }, + + ani_native_function { "getRawFileListSync", nullptr, reinterpret_cast(ResMgrAddon::GetRawFileListSync) }, + ani_native_function { "getRawFileContentSync", nullptr, + reinterpret_cast(ResMgrAddon::GetRawFileContentSync) }, + + ani_native_function { "getMediaContentSync", "DLstd/core/Double;:Lescompat/Uint8Array;", + reinterpret_cast(ResMgrAddon::GetMediaContentSyncById) }, + ani_native_function { "getMediaContentBase64Sync", "DLstd/core/Double;:Lstd/core/String;", + reinterpret_cast(ResMgrAddon::GetMediaContentBase64SyncById) }, + + ani_native_function { "getStringArrayValueSync", "D:Lescompat/Array;", + reinterpret_cast(ResMgrAddon::GetStringArrayValueSyncById) }, + ani_native_function { "getStringArrayByNameSync", nullptr, + reinterpret_cast(ResMgrAddon::GetStringArrayByNameSync) }, + + ani_native_function { "getMediaByNameSync", nullptr, reinterpret_cast(ResMgrAddon::GetMediaByNameSync) }, + ani_native_function { "getMediaBase64ByNameSync", nullptr, + reinterpret_cast(ResMgrAddon::GetMediaBase64ByNameSync) }, + + ani_native_function { "getConfigurationSync", nullptr, reinterpret_cast(ResMgrAddon::GetConfigurationSync) }, + ani_native_function { "getDeviceCapabilitySync", nullptr, + reinterpret_cast(ResMgrAddon::GetDeviceCapabilitySync) }, + ani_native_function { "getLocales", nullptr, reinterpret_cast(ResMgrAddon::GetLocales) }, + + ani_native_function { "getSymbol", "D:D", reinterpret_cast(ResMgrAddon::GetSymbolById) }, + ani_native_function { "getSymbolByName", nullptr, reinterpret_cast(ResMgrAddon::GetSymbolByName) }, + + ani_native_function { "getOverrideResourceManager", nullptr, + reinterpret_cast(ResMgrAddon::GetOverrideResourceManager) }, + ani_native_function { "getOverrideConfiguration", nullptr, + reinterpret_cast(ResMgrAddon::GetOverrideConfiguration) }, + ani_native_function { "updateOverrideConfiguration", nullptr, + reinterpret_cast(ResMgrAddon::UpdateOverrideConfiguration) }, }; ResMgrAddon::ResMgrAddon( @@ -181,40 +227,6 @@ static std::shared_ptr UnwrapAddon(ani_env* env, ani_object object) return *reinterpret_cast*>(ptr); } -static int32_t InitDataContext(ani_env* env, ani_object object, - std::unique_ptr& dataContext, const ani_object resource) -{ - dataContext->addon_ = UnwrapAddon(env, object); - auto resourcePtr = std::make_shared(); - if (resource == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Make shared ResourceManager::Resource failed"); - return ERROR; - } - - ani_ref bundleName; - if (ANI_OK != env->Object_GetPropertyByName_Ref(resource, "bundleName", &bundleName)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property 'bundleName' failed"); - return ERROR; - } - - resourcePtr->bundleName = AniStrToString(env, bundleName); - ani_ref moduleName; - if (ANI_OK != env->Object_GetPropertyByName_Ref(resource, "moduleName", &moduleName)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property 'moduleName' failed"); - return ERROR; - } - - resourcePtr->moduleName = AniStrToString(env, moduleName); - ani_double id; - if (ANI_OK != env->Object_GetPropertyByName_Double(resource, "id", &id)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property 'id' failed"); - return ERROR; - } - resourcePtr->id = id; - dataContext->resource_ = resourcePtr; - return SUCCESS; -} - static ani_string CreateAniString(ani_env *env, ResMgrDataContext& context) { ani_string result; @@ -341,6 +353,16 @@ static ArrayElement GetArrayElement(ani_env* env, ani_object args, const int ind } } +static ani_string StringToAniStr(ani_env *env, const std::string &str) +{ + ani_string ret; + if (ANI_OK != env->String_NewUTF8(str.c_str(), str.size(), &ret)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Create ani string failed"); + return nullptr; + } + return ret; +} + static bool InitAniParameters(ani_env *env, ani_object args, std::vector> &jsParams) { @@ -396,192 +418,6 @@ ani_string ResMgrAddon::GetFormatStringSyncById(ani_env *env, ani_object object, return CreateAniString(env, *dataContext); } -ani_string ResMgrAddon::GetStringSync(ani_env* env, ani_object object, ani_object resource) -{ - auto dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getStringSync", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - state = resMgr->GetStringFormatById(resId, dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getStringSync failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetFormatStringSync(ani_env *env, ani_object object, ani_object resource, ani_object args) -{ - auto dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getFormatStringSync", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getFormatStringSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "getFormatStringSync formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - state = resMgr->GetStringFormatById(resId, dataContext->value_, dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getFormatStringSync failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_double ResMgrAddon::GetNumberById(ani_env* env, ani_object object, ani_double resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resId_ = resId; - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumberById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetIntegerById(resId, dataContext->iValue_); - if (state != RState::SUCCESS) { - state = resMgr->GetFloatById(resId, dataContext->fValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process string in getNumberById", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - } - - ani_double aniValue; - if (dataContext->iValue_) { - aniValue = dataContext->iValue_; - } else { - aniValue = dataContext->fValue_; - } - return aniValue; -} - -ani_double ResMgrAddon::GetNumber(ani_env* env, ani_object object, ani_object resource) -{ - auto dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getNumber", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumber"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - state = resMgr->GetIntegerById(resId, dataContext->iValue_); - if (state != RState::SUCCESS) { - state = resMgr->GetFloatById(resId, dataContext->fValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to process string in getNumber", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - } - - ani_double aniValue; - if (dataContext->iValue_) { - aniValue = dataContext->iValue_; - } else { - aniValue = dataContext->fValue_; - } - return aniValue; -} - -ani_double ResMgrAddon::GetColorSyncById(ani_env* env, ani_object object, ani_double resId) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resId_ = resId; - - std::shared_ptr resMgr = nullptr; - uint32_t notUse = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorSyncById"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - RState state = resMgr->GetColorById(resId, dataContext->colorValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getColorSyncById failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->colorValue_; -} - -ani_double ResMgrAddon::GetColorSync(ani_env* env, ani_object object, ani_object resource) -{ - auto dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getColorSync", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - - state = resMgr->GetColorById(resId, dataContext->colorValue_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("getColorSync failed state", true); - ResourceManagerAniUtils::AniThrow(env, state); - return ABNORMAL_NUMBER_RETURN_VALUE; - } - return dataContext->colorValue_; -} - ani_object ResMgrAddon::GetRawFileContentSync(ani_env* env, ani_object object, ani_string path) { std::unique_ptr dataContext = std::make_unique(); @@ -639,49 +475,6 @@ ani_string ResMgrAddon::GetIntPluralStringValueSyncById(ani_env* env, ani_object return CreateAniString(env, *dataContext); } -ani_string ResMgrAddon::GetIntPluralStringValueSync(ani_env* env, ani_object object, - ani_object resource, ani_double num, ani_object args) -{ - std::unique_ptr dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getIntPluralStringValueSync", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - double number = num; - if (number > INT_MAX) { - number = INT_MAX; - } else if (number < INT_MIN) { - number = INT_MIN; - } - dataContext->quantity_ = { true, number, 0.0 }; - - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - state = resMgr->GetFormatPluralStringById(dataContext->value_, resId, dataContext->quantity_, - dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetFormatPluralStringById state", true, state); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - ani_string ResMgrAddon::GetIntPluralStringByNameSync(ani_env* env, ani_object object, ani_string resName, ani_double num, ani_object args) { @@ -751,60 +544,23 @@ ani_string ResMgrAddon::GetDoublePluralStringValueSyncById(ani_env* env, ani_obj return CreateAniString(env, *dataContext); } -ani_string ResMgrAddon::GetDoublePluralStringValueSync(ani_env* env, ani_object object, - ani_object resource, ani_double num, ani_object args) +ani_string ResMgrAddon::GetDoublePluralStringByNameSync(ani_env* env, ani_object object, + ani_string resName, ani_double num, ani_object args) { - std::unique_ptr dataContext = std::make_unique(); - int32_t state = InitDataContext(env, object, dataContext, resource); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to init para in getIntPluralStringValueSync", true); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); dataContext->quantity_ = { false, 0, num }; - std::shared_ptr resMgr = nullptr; - uint32_t resId = 0; - bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); - if (!ret || resMgr == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getIntPluralStringValueSync"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); - return nullptr; - } - if (!InitAniParameters(env, args, dataContext->jsParams_)) { RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); return nullptr; } - state = resMgr->GetFormatPluralStringById(dataContext->value_, resId, dataContext->quantity_, - dataContext->jsParams_); - if (state != RState::SUCCESS) { - dataContext->SetErrorMsg("Failed to GetFormatPluralStringById state", true, state); - ResourceManagerAniUtils::AniThrow(env, state); - return nullptr; - } - return CreateAniString(env, *dataContext); -} - -ani_string ResMgrAddon::GetDoublePluralStringByNameSync(ani_env* env, ani_object object, - ani_string resName, ani_double num, ani_object args) -{ - auto dataContext = std::make_unique(); - dataContext->addon_ = UnwrapAddon(env, object); - dataContext->resName_ = AniStrToString(env, static_cast(resName)); - dataContext->quantity_ = { false, 0, num }; - - if (!InitAniParameters(env, args, dataContext->jsParams_)) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "InitOptionalParameters formatting error"); - ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_ID_FORMAT_ERROR); - return nullptr; - } - - if (dataContext->addon_ == nullptr) { - RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getDoublePluralStringByNameSync"); - ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getDoublePluralStringByNameSync"); + ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); return nullptr; } @@ -849,3 +605,1033 @@ ani_status ResMgrAddon::BindContext(ani_env* env) }; return ANI_OK; } + + +ani_string ResMgrAddon::GetStringByNameSync(ani_env* env, ani_object object, ani_string resName) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetStringFormatByName(dataContext->resName_.c_str(), + dataContext->value_, dataContext->jsParams_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetStringByNameSync failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniString(env, *dataContext); +} + +ani_string ResMgrAddon::GetFormatStringByNameSync(ani_env *env, ani_object object, ani_string resName, ani_object args) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getFormatStringByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + if (!InitAniParameters(env, args, dataContext->jsParams_)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "getFormatStringByNameSync formatting error"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NAME_FORMAT_ERROR); + return nullptr; + } + + RState state = resMgr->GetStringFormatByName(dataContext->resName_.c_str(), + dataContext->value_, dataContext->jsParams_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetStringByNameSync failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniString(env, *dataContext); +} + +ani_boolean ResMgrAddon::GetBooleanById(ani_env* env, ani_object object, ani_double resId) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return false; + } + + RState state = resMgr->GetBooleanById(resId, dataContext->bValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to GetBoolean state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return false; + } + return dataContext->bValue_; +} + +ani_boolean ResMgrAddon::GetBooleanByName(ani_env* env, ani_object object, ani_string resName) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getBooleanByName"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return false; + } + + RState state = resMgr->GetBooleanByName(dataContext->resName_.c_str(), dataContext->bValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetBooleanByName failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return false; + } + return dataContext->bValue_; +} + +ani_double ResMgrAddon::GetNumberById(ani_env* env, ani_object object, ani_double resId) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumberById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetIntegerById(resId, dataContext->iValue_); + if (state != RState::SUCCESS) { + state = resMgr->GetFloatById(resId, dataContext->fValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to process string in getNumberById", true); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + } + + ani_double aniValue; + if (dataContext->iValue_) { + aniValue = dataContext->iValue_; + } else { + aniValue = dataContext->fValue_; + } + return aniValue; +} + +ani_double ResMgrAddon::GetNumberByName(ani_env* env, ani_object object, ani_string resName) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getNumberByName"); + ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + auto resMgr = dataContext->addon_->GetResMgr(); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getNumberByName"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetIntegerByName(dataContext->resName_.c_str(), dataContext->iValue_); + if (state != RState::SUCCESS) { + state = resMgr->GetFloatByName(dataContext->resName_.c_str(), dataContext->fValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to process number in getNumberByName", false); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + } + + ani_double aniValue; + if (dataContext->iValue_) { + aniValue = dataContext->iValue_; + } else { + aniValue = dataContext->fValue_; + } + return aniValue; +} + + +ani_double ResMgrAddon::GetColorSyncById(ani_env* env, ani_object object, ani_double resId) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorSyncById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetColorById(resId, dataContext->colorValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("getColorSyncById failed state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return dataContext->colorValue_; +} + +ani_double ResMgrAddon::GetColorByNameSync(ani_env* env, ani_object object, ani_string resName) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getColorByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetColorByName(dataContext->resName_.c_str(), dataContext->colorValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to process number in getColorByNameSync", false); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return dataContext->colorValue_; +} + + +void ResMgrAddon::AddResource(ani_env* env, ani_object object, ani_string path) +{ + auto dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + + auto resMgr = UnwrapAddon(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, add overlay path = %{public}s", dataContext->path_.c_str()); + return; + } + + if (!resMgr->GetResMgr()->AddAppOverlay(dataContext->path_)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); + return; + } +} + +void ResMgrAddon::RemoveResource(ani_env* env, ani_object object, ani_string path) +{ + auto dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + + auto resMgr = UnwrapAddon(env, object); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_JS_TAG, "resMgr is null, overlay path = %{public}s", dataContext->path_.c_str()); + return; + } + + if (!resMgr->GetResMgr()->RemoveAppOverlay(dataContext->path_)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to add overlay path = %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_OVERLAY_RES_PATH_INVALID); + return; + } +} + +ani_object ResMgrAddon::GetRawFdSync(ani_env* env, ani_object object, ani_string path) +{ + auto dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + dataContext->addon_ = UnwrapAddon(env, object); + + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFdSync"); + ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); + return nullptr; + } + + RState state = dataContext->addon_->GetResMgr()->GetRawFileDescriptorFromHap(dataContext->path_, + dataContext->descriptor_); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfd by %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + + static const char *className = "Lglobal/rawFileDescriptorInner/RawFileDescriptorInner;"; + ani_class cls; + if (ANI_OK != env->FindClass(className, &cls)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); + return nullptr; + } + + ani_method ctor; + if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); + return nullptr; + } + + ani_object obj; + if (ANI_OK != env->Object_New(cls, ctor, &obj)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); + return nullptr; + } + + if (ANI_OK != env->Object_SetPropertyByName_Double(obj, "fd", dataContext->descriptor_.fd)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'fd' failed"); + } + + if (ANI_OK != env->Object_SetPropertyByName_Double(obj, "offset", dataContext->descriptor_.offset)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'offset' failed"); + } + + if (ANI_OK != env->Object_SetPropertyByName_Double(obj, "length", dataContext->descriptor_.length)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'length' failed"); + } + return obj; +} + +void ResMgrAddon::CloseRawFdSync(ani_env* env, ani_object object, ani_string path) +{ + auto dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + dataContext->addon_ = UnwrapAddon(env, object); + + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in closeRawFdSync"); + ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); + return; + } + + RState state = dataContext->addon_->GetResMgr()->CloseRawFileDescriptor(dataContext->path_); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to close rawfd by %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, state); + return; + } +} + +static ani_object CreateAniArray(ani_env *env, const std::vector strs) +{ + static const char *className = "Lescompat/Array;"; + ani_class cls; + if (ANI_OK != env->FindClass(className, &cls)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); + return nullptr; + } + + ani_method ctor; + if (ANI_OK != env->Class_FindMethod(cls, "", "i:", &ctor)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); + return nullptr; + } + + ani_object ret; + if (ANI_OK != env->Object_New(cls, ctor, &ret, strs.size())) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); + return nullptr; + } + + ani_method set; + if (ANI_OK != env->Class_FindMethod(cls, "$_set", "iC{std.core.Object}:", &set)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '$_set' failed"); + return ret; + } + + for (size_t i = 0; i < strs.size(); i++) { + if (ANI_OK != env->Object_CallMethod_Void(ret, set, i, StringToAniStr(env, strs[i]))) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Call method '$_set' failed"); + return ret; + } + } + return ret; +} + +ani_object ResMgrAddon::GetRawFileListSync(ani_env* env, ani_object object, ani_string path) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + dataContext->addon_ = UnwrapAddon(env, object); + + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in getRawFileListSync"); + ResourceManagerAniUtils::AniThrow(env, NOT_FOUND); + return nullptr; + } + + RState state = dataContext->addon_->GetResMgr()->GetRawFileList(dataContext->path_.c_str(), + dataContext->arrayValue_); + if (state != RState::SUCCESS || dataContext->arrayValue_.empty()) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get rawfile list by %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_PATH_INVALID); + return nullptr; + } + + return CreateAniArray(env, dataContext->arrayValue_); +} + +ani_object ResMgrAddon::GetMediaContentSyncById(ani_env* env, ani_object object, + ani_double resId, ani_object density) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + ani_boolean isUndefined; + env->Reference_IsUndefined(density, &isUndefined); + if (!isUndefined) { + ani_double densityInner; + env->Object_CallMethodByName_Double(density, "unboxed", ":D", &densityInner); + dataContext->density_ = densityInner; + } + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentSyncById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetMediaDataById(resId, dataContext->len_, dataContext->mediaData, dataContext->density_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to GetMediaContentSync state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniUint8Array(env, *dataContext); +} + +ani_string ResMgrAddon::GetMediaContentBase64SyncById(ani_env* env, ani_object object, + ani_double resId, ani_object density) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + ani_boolean isUndefined; + env->Reference_IsUndefined(density, &isUndefined); + if (!isUndefined) { + ani_double densityInner; + env->Object_CallMethodByName_Double(density, "unboxed", ":D", &densityInner); + dataContext->density_ = densityInner; + } + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaContentBase64SyncById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetMediaBase64DataById(resId, dataContext->value_, dataContext->density_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to GetMediaContentBase64Sync state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniString(env, *dataContext); +} + +ani_object ResMgrAddon::GetStringArrayValueSyncById(ani_env* env, ani_object object, ani_double resId) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringArrayValueSyncById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetStringArrayById(resId, dataContext->arrayValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to GetStringArrayValueSync state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniArray(env, dataContext->arrayValue_); +} + +ani_object ResMgrAddon::GetMediaByNameSync(ani_env* env, ani_object object, ani_string resName, ani_object density) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + ani_boolean isUndefined; + env->Reference_IsUndefined(density, &isUndefined); + if (!isUndefined) { + ani_double densityInner; + env->Object_CallMethodByName_Double(density, "unboxed", ":D", &densityInner); + dataContext->density_ = densityInner; + } + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetMediaDataByName(dataContext->resName_.c_str(), + dataContext->len_, dataContext->mediaData, dataContext->density_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetMediaByNameSync failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniUint8Array(env, *dataContext); +} + +ani_string ResMgrAddon::GetMediaBase64ByNameSync(ani_env* env, ani_object object, + ani_string resName, ani_object density) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + ani_boolean isUndefined; + env->Reference_IsUndefined(density, &isUndefined); + if (!isUndefined) { + ani_double densityInner; + env->Object_CallMethodByName_Double(density, "unboxed", ":D", &densityInner); + dataContext->density_ = densityInner; + } + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getMediaBase64ByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetMediaBase64DataByName(dataContext->resName_.c_str(), + dataContext->value_, dataContext->density_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to get media data in GetMediaBase64ByNameSync", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniString(env, *dataContext); +} + +ani_object ResMgrAddon::GetStringArrayByNameSync(ani_env* env, ani_object object, ani_string resName) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getStringArrayByNameSync"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + RState state = resMgr->GetStringArrayByName(dataContext->resName_.c_str(), dataContext->arrayValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetStringArrayByNameSync failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + return CreateAniArray(env, dataContext->arrayValue_); +} + +static int GetScreenDensityIndex(ScreenDensity value) +{ + switch (value) { + case ScreenDensity::SCREEN_DENSITY_SDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_ONE); + case ScreenDensity::SCREEN_DENSITY_MDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_TWO); + case ScreenDensity::SCREEN_DENSITY_LDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_THREE); + case ScreenDensity::SCREEN_DENSITY_XLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_FOUR); + case ScreenDensity::SCREEN_DENSITY_XXLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_FIVE); + case ScreenDensity::SCREEN_DENSITY_XXXLDPI: return static_cast(ScreenDensityIndex::SCREEN_DENSITY_SIX); + default: return -1; + } +} + +static void SetEnumMember(ani_env *env, ani_object obj, const char* memberName, const char* enumName, const int index) +{ + if (index < 0) { + RESMGR_HILOGE(RESMGR_TAG, "SetEnumMember: invalid index %{public}d", index); + return; + } + + ani_enum aniEnum; + if (ANI_OK != env->FindEnum(enumName, &aniEnum)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find enum '%{public}s' failed", enumName); + return; + } + + ani_enum_item enumItem; + if (ANI_OK != env->Enum_GetEnumItemByIndex(aniEnum, index, &enumItem)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get enumItem '%{public}s' failed", enumName); + return; + } + + if (ANI_OK != env->Object_SetPropertyByName_Ref(obj, memberName, enumItem)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property '%{public}s' failed", enumName); + return; + } +} + +static std::string GetLocale(std::unique_ptr &cfg) +{ + std::string result; +#ifdef SUPPORT_GRAPHICS + const icu::Locale *localeInfo = cfg->GetLocaleInfo(); + if (localeInfo == nullptr) { + return result; + } + + const char *lang = localeInfo->getLanguage(); + if (lang == nullptr) { + return result; + } + result = lang; + + const char *script = localeInfo->getScript(); + if (script != nullptr) { + result += std::string("_") + script; + } + + const char *region = localeInfo->getCountry(); + if (region != nullptr) { + result += std::string("_") + region; + } +#endif + return result; +} + +static ani_object CreateConfig(ani_env* env, std::unique_ptr &cfg) +{ + static const char *className = "L@ohos/resourceManager/resourceManager/Configuration;"; + ani_class cls; + if (ANI_OK != env->FindClass(className, &cls)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); + return nullptr; + } + + ani_method ctor; + if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); + return nullptr; + } + + ani_object obj; + if (ANI_OK != env->Object_New(cls, ctor, &obj)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); + return nullptr; + } + + SetEnumMember(env, obj, "direction", "L@ohos/resourceManager/resourceManager/Direction;", + static_cast(cfg->GetDirection())); + SetEnumMember(env, obj, "deviceType", "L@ohos/resourceManager/resourceManager/DeviceType;", + static_cast(cfg->GetDeviceType())); + SetEnumMember(env, obj, "screenDensity", "L@ohos/resourceManager/resourceManager/ScreenDensity;", + GetScreenDensityIndex(cfg->GetScreenDensityDpi())); + SetEnumMember(env, obj, "colorMode", "L@ohos/resourceManager/resourceManager/ColorMode;", + static_cast(cfg->GetColorMode())); + + if (ANI_OK != env->Object_SetPropertyByName_Double(obj, "mcc", static_cast(cfg->GetMcc()))) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'mcc' failed"); + return obj; + } + + if (ANI_OK != env->Object_SetPropertyByName_Double(obj, "mnc", static_cast(cfg->GetMnc()))) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'mnc' failed"); + return obj; + } + + std::string value = GetLocale(cfg); + if (ANI_OK != env->Object_SetPropertyByName_Ref(obj, "locale", StringToAniStr(env, value))) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Set property 'locale' failed"); + return obj; + } + return obj; +} + +ani_object ResMgrAddon::GetConfigurationSync(ani_env* env, ani_object object) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (!cfg) { + dataContext->SetErrorMsg("Failed to create ResConfig object."); + return nullptr; + } + dataContext->addon_->GetResMgr()->GetResConfig(*cfg); + return CreateConfig(env, cfg); +} + +ani_object ResMgrAddon::GetDeviceCapabilitySync(ani_env* env, ani_object object) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (!cfg) { + dataContext->SetErrorMsg("Failed to create ResConfig object."); + return nullptr; + } + dataContext->addon_->GetResMgr()->GetResConfig(*cfg); + + static const char *className = "L@ohos/resourceManager/resourceManager/DeviceCapability;"; + ani_class cls; + if (ANI_OK != env->FindClass(className, &cls)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find class '%{public}s' failed", className); + return nullptr; + } + + ani_method ctor; + if (ANI_OK != env->Class_FindMethod(cls, "", nullptr, &ctor)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Find method '' failed"); + return nullptr; + } + + ani_object obj; + if (ANI_OK != env->Object_New(cls, ctor, &obj)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "New object '%{public}s' failed", className); + return nullptr; + } + + SetEnumMember(env, obj, "screenDensity", "L@ohos/resourceManager/resourceManager/ScreenDensity;", + GetScreenDensityIndex(cfg->GetScreenDensityDpi())); + SetEnumMember(env, obj, "deviceType", "L@ohos/resourceManager/resourceManager/DeviceType;", + static_cast(cfg->GetDeviceType())); + return obj; +} + +ani_object ResMgrAddon::GetLocales(ani_env* env, ani_object object, ani_object includeSystem) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get addon in GetConfigurationSync"); + return nullptr; + } + + ani_boolean isUndefined; + env->Reference_IsUndefined(includeSystem, &isUndefined); + if (!isUndefined) { + ani_boolean includeSys; + env->Object_CallMethodByName_Boolean(includeSystem, "unboxed", ":Z", &includeSys); + dataContext->bValue_ = includeSys; + } + + dataContext->addon_->GetResMgr()->GetLocales(dataContext->arrayValue_, dataContext->bValue_); + return CreateAniArray(env, dataContext->arrayValue_); +} + +ani_double ResMgrAddon::GetSymbolById(ani_env* env, ani_object object, ani_double resId) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resId_ = resId; + + std::shared_ptr resMgr = nullptr; + uint32_t notUse = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, notUse); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolById"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetSymbolById(resId, dataContext->symbolValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetSymbol failed state", true); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return dataContext->symbolValue_; +} + +ani_double ResMgrAddon::GetSymbolByName(ani_env* env, ani_object object, ani_string resName) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + dataContext->resName_ = AniStrToString(env, static_cast(resName)); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getSymbolByName"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + + RState state = resMgr->GetSymbolByName(dataContext->resName_.c_str(), dataContext->symbolValue_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("GetSymbolByName failed state", false); + ResourceManagerAniUtils::AniThrow(env, state); + return ABNORMAL_NUMBER_RETURN_VALUE; + } + return dataContext->symbolValue_; +} + +ani_boolean ResMgrAddon::IsRawDir(ani_env* env, ani_object object, ani_string path) +{ + std::unique_ptr dataContext = std::make_unique(); + dataContext->path_ = AniStrToString(env, path); + dataContext->addon_ = UnwrapAddon(env, object); + + std::shared_ptr resMgr = nullptr; + uint32_t resId = 0; + bool ret = GetHapResourceManager(dataContext.get(), resMgr, resId); + if (!ret || resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in isRawDir"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return false; + } + + RState state = resMgr->IsRawDirFromHap(dataContext->path_, dataContext->bValue_); + if (state != RState::SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, + "Failed to determine the raw file is directory by %{public}s", dataContext->path_.c_str()); + ResourceManagerAniUtils::AniThrow(env, state); + return false; + } + return dataContext->bValue_; +} + +static bool GetEnumMember(ani_env *env, ani_object options, const std::string name, int& member) +{ + ani_ref ref; + if (ANI_OK != env->Object_GetPropertyByName_Ref(options, name.c_str(), &ref)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property '%{public}s' failed", name.c_str()); + return false; + } + + ani_boolean isUndefined; + env->Reference_IsUndefined(ref, &isUndefined); + if (isUndefined) { + return false; + } + + if (ANI_OK != env->EnumItem_GetValue_Int(static_cast(ref), &member)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Enum '%{public}s' get value int failed", name.c_str()); + return false; + } + return true; +} + +static bool GetNumberMember(ani_env *env, ani_object options, const std::string name, double& value) +{ + if (ANI_OK != env->Object_GetPropertyByName_Double(options, name.c_str(), &value)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property '%{public}s' failed", name.c_str()); + return false; + } + return true; +} + +static bool GetEnumParamOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) +{ + int intEnum; + if (GetEnumMember(env, configuration, "direction", intEnum)) { + configPtr->SetDirection(static_cast(intEnum)); + } + if (GetEnumMember(env, configuration, "deviceType", intEnum)) { + configPtr->SetDeviceType(static_cast(intEnum)); + } + if (GetEnumMember(env, configuration, "screenDensity", intEnum)) { + configPtr->SetScreenDensityDpi(static_cast(intEnum)); + } + if (GetEnumMember(env, configuration, "colorMode", intEnum)) { + configPtr->SetColorMode(static_cast(intEnum)); + } + + double value; + if (GetNumberMember(env, configuration, "mcc", value)) { + configPtr->SetMcc(value); + } + if (GetNumberMember(env, configuration, "mnc", value)) { + configPtr->SetMnc(value); + } + return true; +} + +static bool GetLocaleOfConfig(ani_env* env, std::shared_ptr configPtr, ani_object configuration) +{ +#ifdef SUPPORT_GRAPHICS + ani_ref ret; + if (ANI_OK != env->Object_GetPropertyByName_Ref(configuration, "locale", &ret)) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Get property 'locale' failed"); + return false; + } + if (ret == nullptr) { + RESMGR_HILOGD(RESMGR_JS_TAG, "GetLocaleOfConfig property locale not set"); + return true; + } + if (configPtr->SetLocaleInfo(AniStrToString(env, static_cast(ret)).c_str()) != SUCCESS) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetLocaleOfConfig failed to SetLocaleInfo"); + return false; + } +#endif + return true; +} + +static RState GetAddonAndConfig(ani_env* env, ani_object object, + ani_object configuration, std::unique_ptr &dataContext) +{ + dataContext->addon_ = UnwrapAddon(env, object); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetAddonAndConfig failed to get addon"); + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + + ani_boolean isUndefined; + env->Reference_IsUndefined(configuration, &isUndefined); + if (isUndefined) { + RESMGR_HILOGD(RESMGR_ANI_TAG, "GetConfigObject, no config"); + return SUCCESS; + } + + ResConfig *config = CreateDefaultResConfig(); + if (config == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetConfigObject, new config failed"); + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + dataContext->overrideResConfig_.reset(config); + + if (!GetEnumParamOfConfig(env, dataContext->overrideResConfig_, configuration)) { + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + if (!GetLocaleOfConfig(env, dataContext->overrideResConfig_, configuration)) { + return ERROR_CODE_INVALID_INPUT_PARAMETER; + } + return SUCCESS; +} + +ani_object ResMgrAddon::CreateOverrideAddon(ani_env* env, const std::shared_ptr& resMgr) +{ + std::shared_ptr addon = std::make_shared(bundleName_, resMgr, context_); + addon->isOverrideAddon_ = true; + return WrapResourceManager(env, addon); +} + +ani_object ResMgrAddon::GetOverrideResourceManager(ani_env* env, ani_object object, ani_object configuration) +{ + auto dataContext = std::make_unique(); + int32_t state = GetAddonAndConfig(env, object, configuration, dataContext); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false); + ResourceManagerAniUtils::AniThrow(env, state); + return nullptr; + } + + std::shared_ptr resMgr = dataContext->addon_->GetResMgr(); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in getOverrideResourceManager"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return nullptr; + } + + std::shared_ptr overrideResMgr = resMgr->GetOverrideResourceManager( + dataContext->overrideResConfig_); + if (overrideResMgr == nullptr) { + dataContext->SetErrorMsg("GetOverrideResourceManager, overrideResMgr is null", false); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return nullptr; + } + + return dataContext->addon_->CreateOverrideAddon(env, overrideResMgr); +} + +ani_object ResMgrAddon::GetOverrideConfiguration(ani_env* env, ani_object object) +{ + auto dataContext = std::make_unique(); + dataContext->addon_ = UnwrapAddon(env, object); + if (dataContext->addon_ == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "GetOverrideConfiguration failed to get addon"); + return nullptr; + } + + std::unique_ptr cfg(CreateResConfig()); + if (!cfg) { + dataContext->SetErrorMsg("Failed to create ResConfig object."); + return nullptr; + } + dataContext->addon_->GetResMgr()->GetOverrideResConfig(*cfg); + return CreateConfig(env, cfg); +} + +void ResMgrAddon::UpdateOverrideConfiguration(ani_env* env, ani_object object, ani_object configuration) +{ + auto dataContext = std::make_unique(); + int32_t state = GetAddonAndConfig(env, object, configuration, dataContext); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("Failed to get param in GetOverrideResourceManager", false); + ResourceManagerAniUtils::AniThrow(env, state); + return; + } + + std::shared_ptr resMgr = dataContext->addon_->GetResMgr(); + if (resMgr == nullptr) { + RESMGR_HILOGE(RESMGR_ANI_TAG, "Failed to get resMgr in updateOverrideConfiguration"); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_RES_NOT_FOUND_BY_ID); + return; + } + + state = resMgr->UpdateOverrideResConfig(*dataContext->overrideResConfig_); + if (state != RState::SUCCESS) { + dataContext->SetErrorMsg("UpdateOverrideConfiguration failed due to invalid config", false); + ResourceManagerAniUtils::AniThrow(env, ERROR_CODE_INVALID_INPUT_PARAMETER); + return; + } +}