1/* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import hilog from '@ohos.hilog'; 17import { AsyncCallback, BusinessError } from '@ohos.base'; 18import { CommonEventSubscribeInfo } from 'commonEvent.commonEventSubscribeInfo'; 19 20class Cleaner { 21 private ptr: long = 0 22 23 constructor(ptr:long) { 24 this.ptr = ptr 25 } 26 native clean(): void 27} 28 29function callback(cleaner: Cleaner): void { 30 cleaner.clean() 31} 32let destroyRegister = new FinalizationRegistry<Cleaner>(callback) 33let unregisterToken = new object() 34 35type ResolveCallback<T> = (data: T) => void; 36type RejectCallback = (err: Error) => void; 37const TAG: string = 'commonEventSubscriber'; 38export interface CommonEventSubscriber { 39 getCode(callback: AsyncCallback<number>): void; 40 getCode(): Promise<number>; 41 getCodeSync(): number; 42 setCode(code: number, callback: AsyncCallback<void>): void; 43 setCode(code: number): Promise<void>; 44 setCodeSync(code: number): void; 45 getData(callback: AsyncCallback<string>): void; 46 getData(): Promise<string>; 47 getDataSync(): string; 48 setData(data: string, callback: AsyncCallback<void>): void; 49 setData(data: string): Promise<void>; 50 setDataSync(data: string): void; 51 setCodeAndData(code: number, data: string, callback: AsyncCallback<void>): void; 52 setCodeAndData(code: number, data: string): Promise<void>; 53 setCodeAndDataSync(code: number, data: string): void; 54 isOrderedCommonEvent(callback: AsyncCallback<boolean>): void; 55 isOrderedCommonEvent(): Promise<boolean>; 56 isOrderedCommonEventSync(): boolean; 57 isStickyCommonEvent(callback: AsyncCallback<boolean>): void; 58 isStickyCommonEvent(): Promise<boolean>; 59 isStickyCommonEventSync(): boolean; 60 abortCommonEvent(callback: AsyncCallback<void>): void; 61 abortCommonEvent(): Promise<void>; 62 abortCommonEventSync(): void; 63 clearAbortCommonEvent(callback: AsyncCallback<void>): void; 64 clearAbortCommonEvent(): Promise<void>; 65 clearAbortCommonEventSync(): void; 66 getAbortCommonEvent(callback: AsyncCallback<boolean>): void; 67 getAbortCommonEvent(): Promise<boolean>; 68 getAbortCommonEventSync(): boolean; 69 getSubscribeInfo(callback: AsyncCallback<CommonEventSubscribeInfo>): void; 70 getSubscribeInfo(): Promise<CommonEventSubscribeInfo>; 71 getSubscribeInfoSync(): CommonEventSubscribeInfo; 72 finishCommonEvent(callback: AsyncCallback<void>): void; 73 finishCommonEvent(): Promise<void>; 74} 75 76class CommonEventSubscriberInner implements CommonEventSubscriber { 77 static {loadLibrary("ani_commoneventmanager.z")} 78 private subscriberInstanceWrapper: long = 0; 79 80 public native nativeGetCode(): number; 81 public native nativeSetCode(code: int): int; 82 public native nativeGetData(): string; 83 public native nativeSetData(data: string): int; 84 public native nativeSetCodeAndData(code: int, data: string): int; 85 public native nativeIsOrderedCommonEvent(): boolean; 86 public native nativeIsStickyCommonEvent(): boolean; 87 public native nativeAbortCommonEvent(): int; 88 public native nativeClearAbortCommonEvent(): int; 89 public native nativeGetAbortCommonEvent(): boolean; 90 public native nativeGetSubscribeInfo(): CommonEventSubscribeInfo; 91 public native nativeFinishCommonEvent(): int; 92 93 public getCode(callback: AsyncCallback<number>): void { 94 let p = taskpool.execute((): number => { return this.nativeGetCode(); }); 95 p.then((data: NullishType): void => { 96 let ret : number = data as number; 97 callback(null, ret); 98 }, (error: Error): void => { 99 let ret: number = -1; 100 let err: BusinessError = error as BusinessError; 101 callback(err, ret); 102 }); 103 } 104 105 public getCode(): Promise<number> { 106 let pPromise = new Promise<number>((resolve: ResolveCallback<number>, reject: RejectCallback): void => { 107 let p = taskpool.execute((): number => { return this.nativeGetCode(); }); 108 p.then((data: NullishType): void => { 109 let ret : number = data as number; 110 resolve(ret); 111 }, (error: Error): void => { 112 reject(error); 113 }); 114 }); 115 return pPromise; 116 } 117 118 public getCodeSync(): number { 119 let ret : number = 0; 120 try { 121 ret = this.nativeGetCode() as number; 122 return ret; 123 } catch (err) { 124 return ret; 125 } 126 } 127 128 public setCode(code: number, callback: AsyncCallback<void>): void { 129 let pcode: Int = code as Int; 130 let p = taskpool.execute((): int => { return this.nativeSetCode(pcode); }); 131 p.then((data: NullishType): void => { 132 callback(null, undefined); 133 }, (error: Error): void => { 134 let err: BusinessError = error as BusinessError; 135 callback(err, undefined); 136 }); 137 } 138 139 public setCode(code: number): Promise<void> { 140 let pcode: Int = code as Int; 141 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 142 let p = taskpool.execute((): int => { return this.nativeSetCode(pcode); }); 143 p.then((data: NullishType): void => { 144 resolve(undefined); 145 }, (error: Error): void => { 146 reject(error); 147 }); 148 }); 149 return pPromise; 150 } 151 152 public setCodeSync(code: number): void { 153 try { 154 let pcode: Int = code as Int; 155 this.nativeSetCode(pcode); 156 return; 157 } catch (err) { 158 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 159 } 160 } 161 162 public getData(callback: AsyncCallback<string>): void { 163 let p = taskpool.execute((): string => { return this.nativeGetData(); }); 164 p.then((data: NullishType): void => { 165 let ret : string = data as string; 166 callback(null, ret); 167 }, (error: Object): void => { 168 let err: BusinessError = error as BusinessError; 169 callback(err, undefined); 170 }) 171 } 172 173 public getData(): Promise<string> { 174 let pPromise = new Promise<string>((resolve: ResolveCallback<string>, reject: RejectCallback):void => { 175 let p = taskpool.execute((): string => { return this.nativeGetData(); }); 176 p.then((data :NullishType): void => { 177 let ret : string = data as string; 178 resolve(ret); 179 }, (err:Error): void => { 180 reject(err); 181 }); 182 }); 183 return pPromise; 184 } 185 186 public getDataSync(): string { 187 let ret : string = ''; 188 try { 189 ret = this.nativeGetData() as string; 190 return ret; 191 } catch (err) { 192 return ret; 193 } 194 } 195 196 public setData(data: string, callback: AsyncCallback<void>): void { 197 let p = taskpool.execute((): int => { return this.nativeSetData(data); }); 198 p.then((e: NullishType): void => { 199 callback(null, undefined); 200 }, (error: Error): void => { 201 let err: BusinessError = error as BusinessError; 202 callback(err, undefined); 203 }) 204 } 205 206 public setData(data: string): Promise<void> { 207 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 208 let p = taskpool.execute((): int => { return this.nativeSetData(data); }); 209 p.then((data: NullishType): void => { 210 resolve(undefined); 211 }, (error: Error): void => { 212 reject(error); 213 }); 214 }); 215 return pPromise; 216 } 217 218 public setDataSync(data: string): void { 219 try { 220 this.nativeSetData(data); 221 return; 222 } catch (err) { 223 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 224 } 225 } 226 227 public setCodeAndData(code: number, data: string, callback: AsyncCallback<void>): void { 228 let pcode: Int = code as Int; 229 let p = taskpool.execute((): int => { return this.nativeSetCodeAndData(pcode, data); }); 230 p.then((e: NullishType): void => { 231 callback(null, undefined); 232 }, (error: Error): void => { 233 let err: BusinessError = error as BusinessError; 234 callback(err, undefined); 235 }) 236 } 237 238 public setCodeAndData(code: number, data: string): Promise<void> { 239 let pcode: Int = code as Int; 240 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 241 let p = taskpool.execute((): int => { return this.nativeSetCodeAndData(pcode, data); }); 242 p.then((data: NullishType): void => { 243 resolve(undefined); 244 }, (error: Error): void => { 245 reject(error); 246 }); 247 }); 248 return pPromise; 249 } 250 251 public setCodeAndDataSync(code: number, data: string): void { 252 try { 253 let pcode: Int = code as Int; 254 this.nativeSetCodeAndData(pcode, data); 255 return; 256 } catch (err) { 257 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 258 } 259 } 260 261 public isOrderedCommonEvent(callback: AsyncCallback<boolean>): void { 262 let p = taskpool.execute((): boolean => { return this.nativeIsOrderedCommonEvent(); }); 263 p.then((data: NullishType): void => { 264 let ret : boolean = data as boolean; 265 callback(null, ret); 266 }, (error: Error): void => { 267 let ret : boolean = false; 268 let err: BusinessError = error as BusinessError; 269 callback(err, ret); 270 }) 271 } 272 273 public isOrderedCommonEvent(): Promise<boolean> { 274 let pPromise = new Promise<boolean>((resolve: ResolveCallback<boolean>, reject: RejectCallback): void => { 275 let p = taskpool.execute((): boolean => { return this.nativeIsOrderedCommonEvent(); }); 276 p.then((data: NullishType): void => { 277 let ret : boolean = data as boolean; 278 resolve(ret); 279 }, (error: Error): void => { 280 reject(error); 281 }); 282 }); 283 return pPromise; 284 } 285 286 public isOrderedCommonEventSync(): boolean { 287 try { 288 return this.nativeIsOrderedCommonEvent(); 289 } catch (err) { 290 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 291 return false; 292 } 293 } 294 295 public isStickyCommonEvent(callback: AsyncCallback<boolean>): void { 296 let p = taskpool.execute((): boolean => { return this.nativeIsStickyCommonEvent(); }); 297 p.then((data: NullishType): void => { 298 let ret : boolean = data as boolean; 299 callback(null, ret); 300 }, (error: Error): void => { 301 let ret : boolean = false; 302 let err: BusinessError = error as BusinessError; 303 callback(err, ret); 304 }) 305 } 306 307 public isStickyCommonEvent(): Promise<boolean> { 308 let pPromise = new Promise<boolean>((resolve: ResolveCallback<boolean>, reject: RejectCallback): void => { 309 let p = taskpool.execute((): boolean => { return this.nativeIsStickyCommonEvent(); }); 310 p.then((data: NullishType): void => { 311 let ret : boolean = data as boolean; 312 resolve(ret); 313 }, (error: Error): void => { 314 reject(error); 315 }); 316 }); 317 return pPromise; 318 } 319 320 public isStickyCommonEventSync(): boolean { 321 try { 322 return this.nativeIsStickyCommonEvent(); 323 } catch (err) { 324 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 325 return false; 326 } 327 } 328 329 public abortCommonEvent(callback: AsyncCallback<void>): void { 330 let p = taskpool.execute((): int => { return this.nativeAbortCommonEvent(); }); 331 p.then((data: NullishType): void => { 332 callback(null, undefined); 333 }, (error: Error): void => { 334 let err: BusinessError = error as BusinessError; 335 callback(err, undefined); 336 }); 337 } 338 339 public abortCommonEvent(): Promise<void> { 340 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 341 let p = taskpool.execute((): int => { return this.nativeAbortCommonEvent(); }); 342 p.then((data: NullishType): void => { 343 resolve(undefined); 344 }, (error: Error): void => { 345 reject(error); 346 }); 347 }); 348 return pPromise; 349 } 350 351 public abortCommonEventSync(): void { 352 try { 353 this.nativeAbortCommonEvent(); 354 return; 355 } catch (err) { 356 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 357 } 358 } 359 360 public clearAbortCommonEvent(callback: AsyncCallback<void>): void { 361 let p = taskpool.execute((): int => { return this.nativeClearAbortCommonEvent(); }); 362 p.then((data: NullishType): void => { 363 callback(null, undefined); 364 }, (error: Error): void => { 365 let err: BusinessError = error as BusinessError; 366 callback(err, undefined); 367 }); 368 } 369 370 public clearAbortCommonEvent(): Promise<void> { 371 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 372 let p = taskpool.execute((): int => { return this.nativeClearAbortCommonEvent(); }); 373 p.then((data: NullishType): void => { 374 resolve(undefined); 375 }, (error: Error): void => { 376 reject(error); 377 }); 378 }); 379 return pPromise; 380 } 381 382 public clearAbortCommonEventSync(): void { 383 try { 384 this.nativeClearAbortCommonEvent(); 385 return; 386 } catch (err) { 387 hilog.error(0xD001202, TAG, 'asyncResult is nullptr'); 388 } 389 } 390 391 public getAbortCommonEvent(callback: AsyncCallback<boolean>): void { 392 let p = taskpool.execute((): boolean => { return this.nativeGetAbortCommonEvent(); }); 393 p.then((data: NullishType): void => { 394 let ret : boolean = data as boolean; 395 callback(null, ret); 396 }, (error: Error): void => { 397 let ret : boolean = false; 398 let err: BusinessError = error as BusinessError; 399 callback(err, ret); 400 }) 401 } 402 403 public getAbortCommonEvent(): Promise<boolean> { 404 let pPromise = new Promise<boolean>((resolve: ResolveCallback<boolean>, reject: RejectCallback): void => { 405 let p = taskpool.execute((): boolean => { return this.nativeGetAbortCommonEvent(); }); 406 p.then((data: NullishType): void => { 407 let ret : boolean = data as boolean; 408 resolve(ret); 409 }, (error: Error): void => { 410 reject(error); 411 }); 412 }); 413 return pPromise; 414 } 415 416 public getAbortCommonEventSync(): boolean { 417 let ret : boolean = false; 418 try { 419 ret = this.nativeGetAbortCommonEvent() as boolean; 420 return ret; 421 } catch (err) { 422 return ret; 423 } 424 } 425 426 public getSubscribeInfo(callback: AsyncCallback<CommonEventSubscribeInfo>): void { 427 let p = taskpool.execute((): CommonEventSubscribeInfo => { return this.nativeGetSubscribeInfo(); }); 428 p.then((data: NullishType): void => { 429 let ret : CommonEventSubscribeInfo = data as CommonEventSubscribeInfo; 430 callback(null, ret); 431 }, (error: Error): void => { 432 let ret : CommonEventSubscribeInfo ; 433 let err: BusinessError = error as BusinessError; 434 callback(err, ret); 435 }) 436 } 437 438 public getSubscribeInfo(): Promise<CommonEventSubscribeInfo> { 439 let pPromise = new Promise<CommonEventSubscribeInfo>((resolve: ResolveCallback<CommonEventSubscribeInfo>, 440 reject: RejectCallback): void => { 441 let p = taskpool.execute((): CommonEventSubscribeInfo => { return this.nativeGetSubscribeInfo(); }); 442 p.then((data: NullishType): void => { 443 let ret : CommonEventSubscribeInfo = data as CommonEventSubscribeInfo; 444 resolve(ret); 445 }, (error: Error): void => { 446 reject(error); 447 }); 448 }); 449 return pPromise; 450 } 451 452 public getSubscribeInfoSync(): CommonEventSubscribeInfo { 453 return this.nativeGetSubscribeInfo(); 454 } 455 456 public finishCommonEvent(callback: AsyncCallback<void>): void { 457 let p = taskpool.execute((): int => { return this.nativeFinishCommonEvent(); }); 458 p.then((data: NullishType): void => { 459 callback(null, undefined); 460 }, (error: Error): void => { 461 let err: BusinessError = error as BusinessError; 462 callback(err, undefined); 463 }); 464 } 465 466 public finishCommonEvent(): Promise<void> { 467 let pPromise = new Promise<void>((resolve: ResolveCallback<void>, reject: RejectCallback): void => { 468 let p = taskpool.execute((): int => { return this.nativeFinishCommonEvent(); }); 469 p.then((data: NullishType): void => { 470 resolve(undefined); 471 }, (error: Error): void => { 472 reject(error); 473 }); 474 }); 475 return pPromise; 476 } 477 478 private cleaner: Cleaner | null = null; 479 480 constructor(wrapper:long) { 481 if(this.subscriberInstanceWrapper == 0){ 482 this.subscriberInstanceWrapper = wrapper; 483 } 484 this.registerCleaner(this.subscriberInstanceWrapper) 485 } 486 487 registerCleaner(ptr: long): void { 488 this.cleaner = new Cleaner(ptr) 489 destroyRegister.register(this, this.cleaner!, unregisterToken); 490 } 491}