1import prompt from '@ohos.prompt'; 2/* 3 * Copyright (c) 2024 Huawei Device Co., Ltd. 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16import inputmethodengine from '@ohos.inputMethodEngine'; 17import display from '@ohos.display'; 18import windowManager from '@ohos.window'; 19import commoneventmanager from '@ohos.commonEventManager'; 20 21 22let inputMethodEngine = inputmethodengine.getInputMethodEngine(); 23let inputKeyboardDelegate = inputmethodengine.createKeyboardDelegate(); 24let inputMethodAbility = inputmethodengine.getInputMethodAbility(); 25const TAG = 'keyboardController'; 26 27export class KeyboardController { 28 mContext; 29 WINDOW_TYPE_INPUT_METHOD_FLOAT = 2105; 30 windowName = 'inputApp'; 31 private windowHeight: number = 0; 32 private windowWidth: number = 0; 33 private nonBarPosition: number = 0; 34 private keyboardController: inputmethodengine.KeyboardController; 35 private TextInputClient: inputmethodengine.TextInputClient; 36 private InputClient: inputmethodengine.InputClient; 37 38 constructor(context) { 39 this.mContext = context; 40 } 41 42 public onCreate(): void { 43 this.initWindow(); 44 let that = this; 45 inputMethodAbility.on('inputStop', () => { 46 inputMethodAbility.off('inputStop', () => { 47 console.log('====>inputMethodEngine delete inputStop notification.'); 48 }); 49 inputMethodEngine.off('inputStart', () =>{}) 50 inputMethodAbility.off('inputStart', () =>{}) 51 inputMethodAbility.off('inputStart') 52 try { 53 that.mContext.destroy((err) => { 54 console.info(TAG + '====>inputMethodEngine destroy err:' + JSON.stringify(err)); 55 }) 56 } catch (err) { 57 console.info(TAG + '====>inputMethodEngine destroy catch err:' + JSON.stringify(err)); 58 } 59 }) 60 61 inputMethodEngine.on('inputStart', async (keyboardController, TextInputClient) => { 62 this.keyboardController = keyboardController; 63 this.TextInputClient = TextInputClient 64 console.info(TAG + '====>inputMethodEngine inputStart into'); 65 }) 66 inputMethodAbility.on('inputStart', async (keyboardController, InputClient) => { 67 this.InputClient = InputClient 68 console.info(TAG + '====>inputMethodAbility inputStart into'); 69 }) 70 71 function subscriberCallback(err, data) { 72 console.info(TAG + '====>receive event err: ' + JSON.stringify(err)); 73 console.info(TAG + '====>receive event data ' + JSON.stringify(data)); 74 switch (data.code) { 75 case 1: 76 console.info(TAG + '====>inputMethodEngine_test_getInputMethodEngine_001 event:' + data.event); 77 that.inputMethodEngine_test_getInputMethodEngine_001(); 78 break; 79 case 2: 80 console.info(TAG + '====>inputMethodEngine_test_getKeyboardDelegate_001 event:' + data.event); 81 that.inputMethodEngine_test_getKeyboardDelegate_001(); 82 break; 83 case 28: 84 console.info(TAG + '====>inputMethodEngine_test_028 event:' + data.event); 85 that.inputMethodEngine_test_028(); 86 break; 87 case 29: 88 console.info(TAG + '====>inputMethodEngine_test_029 event:' + data.event); 89 that.inputMethodEngine_test_029(); 90 break; 91 case 30: 92 console.info(TAG + '====>inputMethodEngine_test_030 event:' + data.event); 93 that.inputMethodEngine_test_030(); 94 break; 95 case 31: 96 console.info(TAG + '====>inputMethodEngine_test_031 event:' + data.event); 97 that.inputMethodEngine_test_031(); 98 break; 99 case 32: 100 console.info(TAG + '====>inputMethodEngine_test_032 event:' + data.event); 101 that.inputMethodEngine_test_032(); 102 break; 103 case 33: 104 console.info(TAG + '====>inputMethodEngine_test_033 event:' + data.event); 105 that.inputMethodEngine_test_033(); 106 break; 107 case 34: 108 console.info(TAG + '====>inputMethodEngine_test_034 event:' + data.event); 109 that.inputMethodEngine_test_034(); 110 break; 111 case 35: 112 console.info(TAG + '====>inputMethodEngine_test_035 event:' + data.event); 113 that.inputMethodEngine_test_035(); 114 break; 115 case 36: 116 console.info(TAG + '====>inputMethodEngine_test_036 event:' + data.event); 117 that.inputMethodEngine_test_036(); 118 break; 119 case 37: 120 console.info(TAG + '====>inputMethodEngine_test_037 event:' + data.event); 121 that.inputMethodEngine_test_037(); 122 break; 123 case 38: 124 console.info(TAG + '====>inputMethodEngine_test_038 event:' + data.event); 125 that.inputMethodEngine_test_038(); 126 break; 127 case 39: 128 console.info(TAG + '====>inputMethodEngine_test_039 event:' + data.event); 129 that.inputMethodEngine_test_039(); 130 break; 131 case 40: 132 console.info(TAG + '====>inputMethodEngine_test_040 event:' + data.event); 133 that.inputMethodEngine_test_040(); 134 break; 135 case 41: 136 console.info(TAG + '====>inputMethodEngine_test_041 event:' + data.event); 137 that.inputMethodEngine_test_041(); 138 break; 139 case 42: 140 console.info(TAG + '====>inputMethodEngine_test_042 event:' + data.event); 141 that.inputMethodEngine_test_042(); 142 break; 143 case 43: 144 console.info(TAG + '====>inputMethodEngine_test_043 event:' + data.event); 145 that.inputMethodEngine_test_043(); 146 break; 147 case 49: 148 console.info(TAG + '====>inputMethodEngine_test_049 event:' + data.event); 149 that.inputMethodEngine_test_049(); 150 break; 151 case 50: 152 console.info(TAG + '====>inputMethodEngine_test_050 event:' + data.event); 153 that.inputMethodEngine_test_050(); 154 break; 155 case 71: 156 console.info(TAG + '====>inputMethodEngine_test_071 event:' + data.event); 157 that.inputMethodEngine_test_071(); 158 break; 159 case 72: 160 console.info(TAG + '====>inputMethodEngine_test_072 event:' + data.event); 161 that.inputMethodEngine_test_072(); 162 break; 163 case 73: 164 console.info(TAG + '====>inputMethodEngine_test_073 event:' + data.event); 165 that.inputMethodEngine_test_073(); 166 break; 167 case 74: 168 console.info(TAG + '====>inputMethodEngine_test_074 event:' + data.event); 169 that.inputMethodEngine_test_074(); 170 break; 171 case 76: 172 console.info(TAG + '====>inputMethodEngine_test_076 event:' + data.event); 173 that.inputMethodEngine_test_076(); 174 break; 175 case 77: 176 console.info(TAG + '====>inputMethodEngine_test_077 event:' + data.event); 177 that.inputMethodEngine_test_077(); 178 break; 179 case 78: 180 console.debug(TAG + '====>Sub_InputMethod_IME_VisualInput_0500 event:' + data.event); 181 that.Sub_InputMethod_IME_VisualInput_0500(); 182 break; 183 case 79: 184 console.debug(TAG + '====>Sub_InputMethod_IME_VisualInput_0600 event:' + data.event); 185 that.Sub_InputMethod_IME_VisualInput_0600(); 186 break; 187 case 80: 188 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100 event:' + data.event); 189 that.Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100(); 190 break; 191 case 81: 192 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200 event:' + data.event); 193 that.Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200(); 194 break; 195 case 82: 196 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100 event:' + data.event); 197 that.Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100(); 198 break; 199 case 83: 200 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200 event:' + data.event); 201 that.Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200(); 202 break; 203 case 84: 204 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0100 event:' + data.event); 205 that.Sub_Misc_inputMethodEngine_InputClient_insertText_0100(); 206 break; 207 case 85: 208 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0200 event:' + data.event); 209 that.Sub_Misc_inputMethodEngine_InputClient_insertText_0200(); 210 break; 211 case 86: 212 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0100 event:' + data.event); 213 that.Sub_Misc_inputMethodEngine_InputClient_getForward_0100(); 214 break; 215 case 87: 216 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0200 event:' + data.event); 217 that.Sub_Misc_inputMethodEngine_InputClient_getForward_0200(); 218 break; 219 case 88: 220 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0100 event:' + data.event); 221 that.Sub_Misc_inputMethodEngine_InputClient_getBackward_0100(); 222 break; 223 case 89: 224 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0200 event:' + data.event); 225 that.Sub_Misc_inputMethodEngine_InputClient_getBackward_0200(); 226 break; 227 case 90: 228 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100 event:' + data.event); 229 that.Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100(); 230 break; 231 case 91: 232 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200 event:' + data.event); 233 that.Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200(); 234 break; 235 case 92: 236 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100 event:' + data.event); 237 that.Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100(); 238 break; 239 case 93: 240 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200 event:' + data.event); 241 that.Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200(); 242 break; 243 case 94: 244 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100 event:' + data.event); 245 that.Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100(); 246 break; 247 case 95: 248 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200 event:' + data.event); 249 that.Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200(); 250 break; 251 case 96: 252 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100 event:' + data.event); 253 that.Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100(); 254 break; 255 case 97: 256 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200 event:' + data.event); 257 that.Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200(); 258 break; 259 case 98: 260 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200 event:' + data.event); 261 that.Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200(); 262 break; 263 case 99: 264 console.debug(TAG + '====>Sub_InputMethod_IMF_SecurityKeyboard_0601 event:' + data.event); 265 that.Sub_InputMethod_IMF_SecurityKeyboard_0601(); 266 break; 267 case 100: 268 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100 event:' + data.event); 269 that.Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100(); 270 break; 271 case 101: 272 console.debug(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200 event:' + data.event); 273 that.Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200(); 274 case 102: 275 console.debug(TAG + '====>SUB_InputMethod_IME_PrivateDateTransferred_1101 event:' + data.event); 276 that.SUB_InputMethod_IME_PrivateDateTransferred_1101(); 277 } 278 } 279 280 var commonEventSubscribeInfo = { 281 events: ['inputMethodEngineTest'] 282 }; 283 284 var subscriber; 285 commoneventmanager.createSubscriber(commonEventSubscribeInfo).then(function (data) { 286 subscriber = data; 287 commoneventmanager.subscribe(subscriber, subscriberCallback); 288 console.info(TAG + '====>scene subscribe finish===='); 289 }); 290 } 291 292 public onDestroy(): void { 293 console.log('imsakitjsapp onDestroy'); 294 globalThis.textInputClient.getTextIndexAtCursor().then((index) => { 295 console.log('imsakitjsapp getTextIndexAtCursor: index = ' + index); 296 prompt.showToast({ message: 'getTextIndexAtCursor success' + index, duration: 200, bottom: 500 }); 297 var win = windowManager.findWindow(this.windowName); 298 win.destroyWindow(); 299 this.mContext.terminateSelf(); 300 return true; 301 }).catch((err) => { 302 prompt.showToast({ message: 'getTextIndexAtCursor failed', duration: 200, bottom: 500 }); 303 }); 304 } 305 306 private initWindow(): void { 307 display.getDefaultDisplay().then(dis => { 308 var dWidth = dis.width; 309 var dHeight = dis.height; 310 var keyHeightRate = 0.47; 311 var keyHeight = dHeight * keyHeightRate; 312 this.windowWidth = dWidth; 313 this.windowHeight = keyHeight; 314 this.nonBarPosition = dHeight - keyHeight; 315 316 var config = { 317 name: this.windowName, 318 windowType: windowManager.WindowType.TYPE_INPUT_METHOD, 319 ctx: this.mContext 320 }; 321 windowManager.createWindow(config).then((win) => { 322 win.resize(dWidth, keyHeight).then(() => { 323 win.moveWindowTo(0, this.nonBarPosition).then(() => { 324 win.setUIContent('pages/service/index').then(() => { 325 }); 326 }); 327 }); 328 }); 329 }); 330 } 331 332 private publishCallback(err): void { 333 if (err) { 334 console.error(TAG + '====>publish failed: ' + JSON.stringify(err)); 335 } else { 336 console.log(TAG + '====>publish'); 337 } 338 } 339 340 private inputMethodEngine_test_getInputMethodEngine_001(): void { 341 console.info(TAG + '====>receive inputMethodEngine_test_getInputMethodEngine_001 data'); 342 if (typeof (inputMethodEngine) === 'object') { 343 console.info(TAG + '====>receive inputMethodEngine_test_getInputMethodEngine_001 object'); 344 var commonEventPublishData = { 345 data: 'SUCCESS' 346 }; 347 } else { 348 console.info(TAG + '====>receive inputMethodEngine_test_getInputMethodEngine_001 failed'); 349 var commonEventPublishData = { 350 data: 'FAILED' 351 }; 352 }; 353 commoneventmanager.publish('inputMethodEngine_test_getInputMethodEngine_001', commonEventPublishData, 354 this.publishCallback); 355 } 356 357 private inputMethodEngine_test_getKeyboardDelegate_001(): void { 358 console.info(TAG + '====>receive inputMethodEngine_test_getKeyboardDelegate_001 data'); 359 if (typeof (inputKeyboardDelegate) === 'object') { 360 console.info(TAG + '====>receive inputMethodEngine_test_getKeyboardDelegate_001 object'); 361 var commonEventPublishData = { 362 data: 'SUCCESS' 363 }; 364 } else { 365 console.info(TAG + '====>receive inputMethodEngine_test_getKeyboardDelegate_001 failed'); 366 var commonEventPublishData = { 367 data: 'FAILED' 368 }; 369 }; 370 commoneventmanager.publish('inputMethodEngine_test_getKeyboardDelegate_001', commonEventPublishData, 371 this.publishCallback); 372 } 373 374 async inputMethodEngine_test_028(): Promise<void> { 375 console.info(TAG + '====>receive inputMethodEngine_test_028 data'); 376 let commonEventPublishData; 377 let editorAttribyte = await this.TextInputClient.getEditorAttribute(); 378 console.info(TAG + '====>receive inputMethodEngine_test_028 editorAttribyte: ' + JSON.stringify(editorAttribyte)); 379 this.TextInputClient.sendKeyFunction(editorAttribyte.enterKeyType, (err, value) => { 380 if (err) { 381 commonEventPublishData = { 382 data: 'FAILED' 383 }; 384 console.info(TAG + '====>inputMethodEngine_test_028 TextInputClient sendKeyFunction err: ' + 385 JSON.stringify(err)); 386 } else { 387 console.info(TAG + '====>inputMethodEngine_test_028 TextInputClient sendKeyFunction value: ' + 388 JSON.stringify(value)); 389 if (value) { 390 commonEventPublishData = { 391 data: 'SUCCESS' 392 }; 393 } else { 394 commonEventPublishData = { 395 data: 'FAILED' 396 }; 397 } 398 399 } 400 commoneventmanager.publish('inputMethodEngine_test_028', commonEventPublishData, this.publishCallback); 401 }) 402 } 403 404 async inputMethodEngine_test_029(): Promise<void> { 405 console.info(TAG + '====>receive inputMethodEngine_test_029 data'); 406 let commonEventPublishData; 407 let editorAttribyte = await this.TextInputClient.getEditorAttribute(); 408 console.info(TAG + '====>inputMethodEngine_test_029 editorAttribyte:' + JSON.stringify(editorAttribyte)); 409 let value = await this.TextInputClient.sendKeyFunction(editorAttribyte.inputPattern); 410 console.info(TAG + '====>inputMethodEngine_test_029 sendKeyFunction:' + JSON.stringify(value)); 411 if (value) { 412 commonEventPublishData = { 413 data: 'SUCCESS' 414 }; 415 } else { 416 commonEventPublishData = { 417 data: 'FAILED' 418 }; 419 } 420 commoneventmanager.publish('inputMethodEngine_test_029', commonEventPublishData, this.publishCallback); 421 } 422 423 async inputMethodEngine_test_030(): Promise<void> { 424 console.info(TAG + '====>receive inputMethodEngine_test_030 data'); 425 let commonEventPublishData; 426 this.TextInputClient.deleteForward(1, (err, value) => { 427 if (err) { 428 console.info(TAG + '====>inputMethodEngine_test_030 deleteForward err:' + JSON.stringify(err)); 429 commonEventPublishData = { 430 data: 'FAILED' 431 }; 432 } else { 433 console.info(TAG + '====>inputMethodEngine_test_030 deleteForward value:' + JSON.stringify(value)); 434 if (typeof (value) === 'boolean') { 435 commonEventPublishData = { 436 data: 'SUCCESS' 437 }; 438 } else { 439 commonEventPublishData = { 440 data: 'FAILED' 441 }; 442 } 443 } 444 commoneventmanager.publish('inputMethodEngine_test_030', commonEventPublishData, this.publishCallback); 445 }); 446 } 447 448 async inputMethodEngine_test_031(): Promise<void> { 449 console.info(TAG + '====>receive inputMethodEngine_test_031 data'); 450 let commonEventPublishData; 451 let value = await this.TextInputClient.deleteForward(1); 452 console.info(TAG + '====>inputMethodEngine_test_031 deleteForward:' + JSON.stringify(value)); 453 if (typeof (value) === 'boolean') { 454 commonEventPublishData = { 455 data: 'SUCCESS' 456 }; 457 } else { 458 commonEventPublishData = { 459 data: 'FAILED' 460 }; 461 } 462 commoneventmanager.publish('inputMethodEngine_test_031', commonEventPublishData, this.publishCallback); 463 } 464 465 async inputMethodEngine_test_032(): Promise<void> { 466 console.info(TAG + '====>receive inputMethodEngine_test_032 data'); 467 let commonEventPublishData; 468 this.TextInputClient.deleteBackward(1, (err, value) => { 469 if (err) { 470 console.info(TAG + '====>inputMethodEngine_test_032 deleteBackward err:' + JSON.stringify(err)); 471 commonEventPublishData = { 472 data: 'FAILED' 473 }; 474 } else { 475 console.info(TAG + '====>inputMethodEngine_test_032 deleteBackward value:' + JSON.stringify(value)); 476 if (value) { 477 commonEventPublishData = { 478 data: 'SUCCESS' 479 }; 480 } else { 481 commonEventPublishData = { 482 data: 'FAILED' 483 }; 484 } 485 } 486 commoneventmanager.publish('inputMethodEngine_test_032', commonEventPublishData, this.publishCallback); 487 }); 488 } 489 490 async inputMethodEngine_test_033(): Promise<void> { 491 console.info(TAG + '====>receive inputMethodEngine_test_033 data'); 492 let commonEventPublishData; 493 let value = await this.TextInputClient.deleteBackward(1); 494 console.info(TAG + '====>inputMethodEngine_test_033 deleteBackward:' + JSON.stringify(value)); 495 if (value) { 496 commonEventPublishData = { 497 data: 'SUCCESS' 498 }; 499 } else { 500 commonEventPublishData = { 501 data: 'FAILED' 502 }; 503 } 504 commoneventmanager.publish('inputMethodEngine_test_033', commonEventPublishData, this.publishCallback); 505 } 506 507 async inputMethodEngine_test_034(): Promise<void> { 508 console.info(TAG + '====>receive inputMethodEngine_test_034 data'); 509 let commonEventPublishData; 510 this.TextInputClient.insertText('test', (err, value) => { 511 if (err) { 512 console.info(TAG + '====>inputMethodEngine_test_034 insertText err:' + JSON.stringify(err)); 513 commonEventPublishData = { 514 data: 'FAILED' 515 }; 516 } else { 517 console.info(TAG + '====>inputMethodEngine_test_034 insertText value:' + JSON.stringify(value)); 518 if (value) { 519 commonEventPublishData = { 520 data: 'SUCCESS' 521 }; 522 } else { 523 commonEventPublishData = { 524 data: 'FAILED' 525 }; 526 } 527 } 528 commoneventmanager.publish('inputMethodEngine_test_034', commonEventPublishData, this.publishCallback); 529 }); 530 } 531 532 async inputMethodEngine_test_035(): Promise<void> { 533 console.info(TAG + '====>receive inputMethodEngine_test_035 data'); 534 let commonEventPublishData; 535 let value = await this.TextInputClient.insertText('test'); 536 console.info(TAG + '====>inputMethodEngine_test_035 insertText:' + JSON.stringify(value)); 537 if (value) { 538 commonEventPublishData = { 539 data: 'SUCCESS' 540 }; 541 } else { 542 commonEventPublishData = { 543 data: 'FAILED' 544 }; 545 } 546 commoneventmanager.publish('inputMethodEngine_test_035', commonEventPublishData, this.publishCallback); 547 } 548 549 async inputMethodEngine_test_036(): Promise<void> { 550 console.info(TAG + '====>receive inputMethodEngine_test_036 data'); 551 let commonEventPublishData; 552 this.TextInputClient.getForward(1, (err, value) => { 553 if (err) { 554 console.info(TAG + '====>inputMethodEngine_test_036 getForward err:' + JSON.stringify(err)); 555 commonEventPublishData = { 556 data: 'FAILED' 557 }; 558 } else { 559 console.info(TAG + '====>inputMethodEngine_test_036 getForward value:' + JSON.stringify(value)); 560 if (typeof (value) !== null) { 561 commonEventPublishData = { 562 data: 'SUCCESS' 563 }; 564 } else { 565 commonEventPublishData = { 566 data: 'FAILED' 567 }; 568 } 569 } 570 commoneventmanager.publish('inputMethodEngine_test_036', commonEventPublishData, this.publishCallback); 571 }); 572 } 573 574 async inputMethodEngine_test_037(): Promise<void> { 575 console.info(TAG + '====>receive inputMethodEngine_test_037 data'); 576 let commonEventPublishData; 577 let value = await this.TextInputClient.getForward(1); 578 console.info(TAG + '====>inputMethodEngine_test_037 getForward:' + JSON.stringify(value)); 579 if (typeof (value) !== null) { 580 commonEventPublishData = { 581 data: 'SUCCESS' 582 }; 583 } else { 584 commonEventPublishData = { 585 data: 'FAILED' 586 }; 587 } 588 commoneventmanager.publish('inputMethodEngine_test_037', commonEventPublishData, this.publishCallback); 589 } 590 591 async inputMethodEngine_test_038(): Promise<void> { 592 console.info(TAG + '====>receive inputMethodEngine_test_038 data'); 593 let commonEventPublishData; 594 this.TextInputClient.getEditorAttribute((err, value) => { 595 if (err) { 596 console.info(TAG + '====>inputMethodEngine_test_038 getEditorAttribute err:' + JSON.stringify(err)); 597 commonEventPublishData = { 598 data: 'FAILED' 599 }; 600 } else { 601 console.info(TAG + '====>inputMethodEngine_test_038 getEditorAttribute value:' + JSON.stringify(value)); 602 if (value) { 603 commonEventPublishData = { 604 data: 'SUCCESS' 605 }; 606 } else { 607 commonEventPublishData = { 608 data: 'FAILED' 609 }; 610 } 611 } 612 commoneventmanager.publish('inputMethodEngine_test_038', commonEventPublishData, this.publishCallback); 613 }); 614 } 615 616 async inputMethodEngine_test_039(): Promise<void> { 617 console.info(TAG + '====>receive inputMethodEngine_test_039 data'); 618 let commonEventPublishData; 619 let value = await this.TextInputClient.getEditorAttribute(); 620 console.info(TAG + '====>inputMethodEngine_test_039 getEditorAttribute:' + JSON.stringify(value)); 621 if (value) { 622 commonEventPublishData = { 623 data: 'SUCCESS' 624 }; 625 } else { 626 commonEventPublishData = { 627 data: 'FAILED' 628 }; 629 } 630 commoneventmanager.publish('inputMethodEngine_test_039', commonEventPublishData, this.publishCallback); 631 } 632 633 async inputMethodEngine_test_040(): Promise<void> { 634 console.info(TAG + '====>receive inputMethodEngine_test_040 data'); 635 let commonEventPublishData; 636 try { 637 this.keyboardController.hideKeyboard((err, value) => { 638 if (err) { 639 console.info(TAG + '====>inputMethodEngine_test_040 hideKeyboard:' + JSON.stringify(err)); 640 commonEventPublishData = { 641 data: 'FAILED' 642 }; 643 } else { 644 commonEventPublishData = { 645 data: 'SUCCESS' 646 }; 647 } 648 commoneventmanager.publish('inputMethodEngine_test_040', commonEventPublishData, this.publishCallback); 649 }); 650 } catch (err) { 651 commonEventPublishData = { 652 data: 'FAILED' 653 }; 654 console.info(TAG + '====>inputMethodEngine_test_040 hideKeyboard throw_err:'); 655 commoneventmanager.publish('inputMethodEngine_test_040', commonEventPublishData, this.publishCallback); 656 } 657 } 658 659 async inputMethodEngine_test_041(): Promise<void> { 660 console.info(TAG + '====>receive inputMethodEngine_test_041 data'); 661 let commonEventPublishData; 662 try { 663 await this.keyboardController.hideKeyboard(); 664 console.info(TAG + '====>inputMethodEngine_test_041 hideKeyboard success'); 665 commonEventPublishData = { 666 data: 'SUCCESS' 667 }; 668 } catch (err) { 669 commonEventPublishData = { 670 data: 'FAILED' 671 }; 672 console.info(TAG + '====>inputMethodEngine_test_041 hideKeyboard catch err:'); 673 } 674 commoneventmanager.publish('inputMethodEngine_test_041', commonEventPublishData, this.publishCallback); 675 } 676 677 async inputMethodEngine_test_042(): Promise<void> { 678 console.info(TAG + '====>receive inputMethodEngine_test_042 data'); 679 let commonEventPublishData; 680 this.TextInputClient.getBackward(1, (err, value) => { 681 if (err) { 682 console.info(TAG + '====>inputMethodEngine_test_042 getBackward err:' + JSON.stringify(err)); 683 commonEventPublishData = { 684 data: 'FAILED' 685 }; 686 } else { 687 console.info(TAG + '====>inputMethodEngine_test_042 getBackward value:' + JSON.stringify(value)); 688 commonEventPublishData = { 689 data: 'SUCCESS' 690 }; 691 } 692 commoneventmanager.publish('inputMethodEngine_test_042', commonEventPublishData, this.publishCallback); 693 }); 694 } 695 696 async inputMethodEngine_test_043(): Promise<void> { 697 console.info(TAG + '====>receive inputMethodEngine_test_043 data'); 698 let commonEventPublishData; 699 let value = await this.TextInputClient.getBackward(1); 700 console.info(TAG + '====>inputMethodEngine_test_043 getBackward:' + JSON.stringify(value)); 701 commonEventPublishData = { 702 data: 'SUCCESS' 703 }; 704 commoneventmanager.publish('inputMethodEngine_test_043', commonEventPublishData, this.publishCallback); 705 } 706 707 async inputMethodEngine_test_049(): Promise<void> { 708 console.info(TAG + '====>receive inputMethodEngine_test_049 data'); 709 let commonEventPublishData; 710 try { 711 this.keyboardController.hide((err, value) => { 712 if (err) { 713 console.info(TAG + '====>inputMethodEngine_test_049 hide:' + JSON.stringify(err)); 714 commonEventPublishData = { 715 data: 'FAILED' 716 }; 717 } else { 718 commonEventPublishData = { 719 data: 'SUCCESS' 720 }; 721 } 722 commoneventmanager.publish('inputMethodEngine_test_049', commonEventPublishData, this.publishCallback); 723 }); 724 } catch (err) { 725 commonEventPublishData = { 726 data: 'FAILED' 727 }; 728 console.info(TAG + '====>inputMethodEngine_test_049 hide throw_err:'); 729 commoneventmanager.publish('inputMethodEngine_test_040', commonEventPublishData, this.publishCallback); 730 } 731 } 732 733 async inputMethodEngine_test_050(): Promise<void> { 734 console.info(TAG + '====>receive inputMethodEngine_test_050 data'); 735 let commonEventPublishData; 736 try { 737 await this.keyboardController.hide(); 738 console.info(TAG + '====>inputMethodEngine_test_050 hideKeyboard success'); 739 commonEventPublishData = { 740 data: 'SUCCESS' 741 }; 742 } catch (err) { 743 commonEventPublishData = { 744 data: 'FAILED' 745 }; 746 console.info(TAG + '====>inputMethodEngine_test_050 hideKeyboard catch err:'); 747 } 748 commoneventmanager.publish('inputMethodEngine_test_050', commonEventPublishData, this.publishCallback); 749 } 750 751 async inputMethodEngine_test_071(): Promise<void> { 752 let commonEventPublishData = { 753 data: 'FAILED' 754 }; 755 console.info(TAG + '====>receive inputMethodEngine_test_071 success'); 756 let count = 0; 757 inputMethodEngine.on('keyboardHide', () => { 758 count += 1; 759 inputMethodEngine.off('keyboardHide'); 760 console.info(TAG + '====>inputMethodEngine.off("keyboardHide") count: ' + count); 761 }); 762 763 let t = setTimeout(async () => { 764 clearTimeout(t); 765 await this.keyboardController.hideKeyboard(); 766 console.info(TAG + '====>inputMethodEngine_test_071 hideKeyboard success'); 767 }, 100); 768 769 let t1 = setTimeout(() => { 770 if (count === 1) { 771 commonEventPublishData = { 772 data: 'SUCCESS' 773 }; 774 } 775 commoneventmanager.publish('inputMethodEngine_test_071', commonEventPublishData, this.publishCallback); 776 clearTimeout(t1); 777 }, 1000); 778 } 779 780 async inputMethodEngine_test_072(): Promise<void> { 781 let commonEventPublishData = { 782 data: 'FAILED' 783 }; 784 console.info(TAG + '====>receive inputMethodEngine_test_072 success'); 785 let count = 0; 786 inputMethodEngine.on('keyboardShow', () => { 787 count += 1; 788 inputMethodEngine.off('keyboardShow'); 789 console.info(TAG + '====>inputMethodEngine.off("keyboardShow") count: ' + count); 790 }); 791 792 let t1 = setTimeout(() => { 793 if (count === 1) { 794 commonEventPublishData = { 795 data: 'SUCCESS' 796 }; 797 } 798 commoneventmanager.publish('inputMethodEngine_test_072', commonEventPublishData, this.publishCallback); 799 clearTimeout(t1); 800 }, 1500); 801 } 802 803 async inputMethodEngine_test_073(): Promise<void> { 804 let commonEventPublishData = { 805 data: 'FAILED' 806 }; 807 console.info(TAG + '====>receive inputMethodEngine_test_073 success'); 808 let count = 0; 809 inputKeyboardDelegate.on('keyDown', (keyEvent) => { 810 inputKeyboardDelegate.off('keyDown'); 811 console.info(TAG + '====>inputKeyboardDelegate.on("keyDown") count: ' + count); 812 console.info(TAG + '====>inputKeyboardDelegate.keyEvent.keyAction ' + keyEvent.keyAction); 813 if (keyEvent.keyCode === 2000 && keyEvent.keyAction === 2) { 814 count += 1; 815 } 816 return true; 817 }); 818 inputKeyboardDelegate.on('keyUp', (keyEvent) => { 819 inputKeyboardDelegate.off('keyUp'); 820 console.info(TAG + '====>inputKeyboardDelegate.on("keyUp") count: ' + count); 821 console.info(TAG + '====>inputKeyboardDelegate.keyEvent.keyAction ' + keyEvent.keyAction); 822 if (keyEvent.keyCode === 2000 && keyEvent.keyAction === 3) { 823 count += 1; 824 } 825 return true; 826 }); 827 let t = setTimeout(() => { 828 commonEventPublishData = { 829 data: 'SUCCESS' 830 }; 831 commoneventmanager.publish('inputMethodEngine_test_073', commonEventPublishData, this.publishCallback); 832 clearTimeout(t); 833 }, 1000); 834 } 835 836 async inputMethodEngine_test_074(): Promise<void> { 837 let commonEventPublishData = { 838 data: 'FAILED' 839 }; 840 console.info(TAG + '====>receive inputMethodEngine_test_074 success'); 841 let count = 0; 842 843 let t = setTimeout(async () => { 844 clearTimeout(t); 845 inputKeyboardDelegate.on('cursorContextChange', (x, y, h) => { 846 console.info(TAG + '====>inputKeyboardDelegate.on("cursorContextChange") count: ' + count); 847 if (count === 1) { 848 inputKeyboardDelegate.off('cursorContextChange'); 849 console.info(TAG + '====>inputMethodEngine_test_074 inputKeyboardDelegate.off'); 850 } 851 count += 1; 852 console.info(TAG + '====>inputMethodEngine_test_074 x,y,z: ' + x + '---' + y + '---' + h); 853 }); 854 855 let loop = 0; 856 let t1 = setInterval(async () => { 857 await this.TextInputClient.insertText('ttt'); 858 console.info(TAG + '====>keyboardController.insertText count: ' + count); 859 console.info(TAG + '====>keyboardController.insertText loop: ' + loop); 860 loop += 1; 861 if (loop === 3) { 862 clearInterval(t1); 863 } 864 }, 500); 865 }, 1000); 866 867 let t1 = setTimeout(() => { 868 if (count === 2) { 869 commonEventPublishData = { 870 data: 'SUCCESS' 871 }; 872 } 873 commoneventmanager.publish('inputMethodEngine_test_074', commonEventPublishData, this.publishCallback); 874 clearTimeout(t1); 875 }, 4000); 876 } 877 878 async inputMethodEngine_test_076(): Promise<void> { 879 let commonEventPublishData = { 880 data: 'FAILED' 881 }; 882 console.info(TAG + '====>receive inputMethodEngine_test_076 success'); 883 inputKeyboardDelegate.on('selectionChange', (oldBegin, oldEnd, newBegin, newEnd) => { 884 console.info(TAG + '====>inputKeyboardDelegate.on("selectionChange")'); 885 inputKeyboardDelegate.off('selectionChange'); 886 commonEventPublishData = { 887 data: 'SUCCESS' 888 }; 889 console.info(TAG + '====>inputMethodEngine_test_076 oldBegin,oldEnd,newBegin,newEnd: ' + oldBegin + '---' + 890 oldEnd + '---' + newBegin + '---' + newEnd); 891 }); 892 893 let t = setTimeout(() => { 894 commoneventmanager.publish('inputMethodEngine_test_076', commonEventPublishData, this.publishCallback); 895 clearTimeout(t); 896 }, 2000); 897 } 898 899 async inputMethodEngine_test_077(): Promise<void> { 900 let commonEventPublishData = { 901 data: 'FAILED' 902 }; 903 console.info(TAG + '====>receive inputMethodEngine_test_077 success'); 904 let count = 0; 905 inputKeyboardDelegate.on('textChange', (text) => { 906 console.info(TAG + '====>inputKeyboardDelegate.on("textChange") count:' + count); 907 if (count === 1) { 908 inputKeyboardDelegate.off('textChange'); 909 } 910 count += 1; 911 console.info(TAG + '====>inputMethodEngine_test_077 text: ' + text); 912 }); 913 914 let loopCount = 0; 915 let t = setInterval(async () => { 916 await this.TextInputClient.insertText('tttt'); 917 console.info(TAG + '====>keyboardController.insertText count: ' + count); 918 if (loopCount === 2) { 919 clearInterval(t); 920 } 921 loopCount += 1; 922 }, 300); 923 924 let t1 = setTimeout(() => { 925 if (count === 2) { 926 commonEventPublishData = { 927 data: 'SUCCESS' 928 }; 929 } 930 commoneventmanager.publish('inputMethodEngine_test_077', commonEventPublishData, this.publishCallback); 931 clearTimeout(t1); 932 }, 2000); 933 } 934 935 async Sub_InputMethod_IME_VisualInput_0500(): Promise<void> { 936 console.info(TAG + '====>receive Sub_InputMethod_IME_VisualInput_0500 data'); 937 let commonEventPublishData = { 938 data: 'FAILED' 939 }; 940 try { 941 console.info(TAG + '====>Sub_InputMethod_IME_VisualInput_0500 exitCurrentInputType start'); 942 await this.keyboardController.exitCurrentInputType(); 943 console.info(TAG + '====>Sub_InputMethod_IME_VisualInput_0500 exitCurrentInputType success'); 944 commonEventPublishData = { 945 data: 'FAILED' 946 }; 947 } catch (err) { 948 console.info(TAG + '====>Sub_InputMethod_IME_VisualInput_0500 exitCurrentInputType catch err:' + 949 JSON.stringify(err)); 950 if (err.code === 12800010) { 951 commonEventPublishData = { 952 data: 'SUCCESS' 953 }; 954 } 955 } 956 commoneventmanager.publish('Sub_InputMethod_IME_VisualInput_0500', commonEventPublishData, this.publishCallback); 957 } 958 959 async Sub_InputMethod_IME_VisualInput_0600(): Promise<void> { 960 console.info(TAG + '====>receive Sub_InputMethod_IME_VisualInput_0600 data'); 961 let commonEventPublishData = { 962 data: 'FAILED' 963 }; 964 this.keyboardController.exitCurrentInputType((err) => { 965 console.info(TAG + '====>Sub_InputMethod_IME_VisualInput_0600 exitCurrentInputType failed: ' + 966 JSON.stringify(err)); 967 if (err.code === 12800010) { 968 commonEventPublishData = { 969 data: 'SUCCESS' 970 }; 971 } else { 972 console.info(TAG + '====>Sub_InputMethod_IME_VisualInput_0600 exitCurrentInputType not throw 12800010'); 973 } 974 commoneventmanager.publish('Sub_InputMethod_IME_VisualInput_0600', commonEventPublishData, this.publishCallback); 975 }); 976 } 977 978 async Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100(): Promise<void> { 979 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100 data'); 980 let commonEventPublishData = { 981 data: 'FAILED' 982 }; 983 try { 984 this.InputClient.sendKeyFunction(undefined, (err, value) => { 985 if (err) { 986 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100 sendKeyFunction err:' + JSON.stringify(err)); 987 commonEventPublishData = { 988 data: 'SUCCESS' 989 }; 990 } 991 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100 sendKeyFunction success' ); 992 }); 993 } catch (err) { 994 if (err.code === 401) { 995 commonEventPublishData = { 996 data: 'SUCCESS' 997 }; 998 } 999 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100 catch err: ' + JSON.stringify(err)); 1000 } 1001 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0100', commonEventPublishData, this.publishCallback); 1002 } 1003 1004 async Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200(): Promise<void> { 1005 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200 data'); 1006 let commonEventPublishData = { 1007 data: 'FAILED' 1008 }; 1009 try { 1010 this.InputClient.sendKeyFunction(undefined).then((data) => { 1011 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200 Succeed in sendKeyFunction.' + JSON.stringify(data)); 1012 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200', commonEventPublishData, this.publishCallback); 1013 }).catch((err) => { 1014 commonEventPublishData = { 1015 data: 'SUCCESS' 1016 }; 1017 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1018 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200', commonEventPublishData, this.publishCallback); 1019 }); 1020 } catch (err) { 1021 if (err.code === 401) { 1022 commonEventPublishData = { 1023 data: 'SUCCESS' 1024 }; 1025 } 1026 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200 err: ' + JSON.stringify(err)); 1027 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendKeyFunction_0200', commonEventPublishData, this.publishCallback); 1028 } 1029 } 1030 1031 async Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100(): Promise<void> { 1032 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100 data'); 1033 let commonEventPublishData = { 1034 data: 'FAILED' 1035 }; 1036 try { 1037 this.InputClient.deleteForward(undefined, (err, result) => { 1038 if (err) { 1039 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100 sendKeyFunction err:' + JSON.stringify(err)); 1040 commonEventPublishData = { 1041 data: 'SUCCESS' 1042 }; 1043 } 1044 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100 sendKeyFunction success' ); 1045 }); 1046 } catch (err) { 1047 if (err.code === 401) { 1048 commonEventPublishData = { 1049 data: 'SUCCESS' 1050 }; 1051 } 1052 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100 catch err: ' + JSON.stringify(err)); 1053 } 1054 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteForward_0100', commonEventPublishData, this.publishCallback); 1055 } 1056 1057 async Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200(): Promise<void> { 1058 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200 data'); 1059 let commonEventPublishData = { 1060 data: 'FAILED' 1061 }; 1062 try { 1063 this.InputClient.deleteForward(undefined).then((result) => { 1064 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200 Succeed in sendKeyFunction.' + JSON.stringify(result)); 1065 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200', commonEventPublishData, this.publishCallback); 1066 }).catch((err) => { 1067 commonEventPublishData = { 1068 data: 'SUCCESS' 1069 }; 1070 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1071 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200', commonEventPublishData, this.publishCallback); 1072 }); 1073 } catch (err) { 1074 if (err.code === 401) { 1075 commonEventPublishData = { 1076 data: 'SUCCESS' 1077 }; 1078 } 1079 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200 err: ' + JSON.stringify(err)); 1080 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteForward_0200', commonEventPublishData, this.publishCallback); 1081 } 1082 } 1083 1084 async Sub_Misc_inputMethodEngine_InputClient_insertText_0100(): Promise<void> { 1085 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_insertText_0100 data'); 1086 let commonEventPublishData = { 1087 data: 'FAILED' 1088 }; 1089 try { 1090 this.InputClient.insertText(undefined, (err, result) => { 1091 if (err) { 1092 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0100 sendKeyFunction err:' + JSON.stringify(err)); 1093 commonEventPublishData = { 1094 data: 'SUCCESS' 1095 }; 1096 } 1097 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0100 sendKeyFunction success' ); 1098 }); 1099 } catch (err) { 1100 if (err.code === 401) { 1101 commonEventPublishData = { 1102 data: 'SUCCESS' 1103 }; 1104 } 1105 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0100 catch err: ' + JSON.stringify(err)); 1106 } 1107 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_insertText_0100', commonEventPublishData, this.publishCallback); 1108 } 1109 1110 async Sub_Misc_inputMethodEngine_InputClient_insertText_0200(): Promise<void> { 1111 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_insertText_0200 data'); 1112 let commonEventPublishData = { 1113 data: 'FAILED' 1114 }; 1115 try { 1116 this.InputClient.insertText(undefined).then((result) => { 1117 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0200 Succeed in sendKeyFunction.' + JSON.stringify(result)); 1118 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_insertText_0200', commonEventPublishData, this.publishCallback); 1119 }).catch((err) => { 1120 commonEventPublishData = { 1121 data: 'SUCCESS' 1122 }; 1123 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_insertText_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1124 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_insertText_0200', commonEventPublishData, this.publishCallback); 1125 }); 1126 } catch (err) { 1127 if (err.code === 401) { 1128 commonEventPublishData = { 1129 data: 'SUCCESS' 1130 }; 1131 } 1132 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_insertText_0200 err: ' + JSON.stringify(err)); 1133 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_insertText_0200', commonEventPublishData, this.publishCallback); 1134 } 1135 } 1136 1137 async Sub_Misc_inputMethodEngine_InputClient_getForward_0100(): Promise<void> { 1138 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getForward_0100 data'); 1139 let commonEventPublishData = { 1140 data: 'FAILED' 1141 }; 1142 try { 1143 this.InputClient.getForward(undefined, (err, result) => { 1144 if (err) { 1145 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0100 sendKeyFunction err:' + JSON.stringify(err)); 1146 commonEventPublishData = { 1147 data: 'SUCCESS' 1148 }; 1149 } 1150 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0100 sendKeyFunction success' ); 1151 }); 1152 } catch (err) { 1153 if (err.code === 401) { 1154 commonEventPublishData = { 1155 data: 'SUCCESS' 1156 }; 1157 } 1158 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0100 catch err: ' + JSON.stringify(err)); 1159 } 1160 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getForward_0100', commonEventPublishData, this.publishCallback); 1161 } 1162 1163 async Sub_Misc_inputMethodEngine_InputClient_getForward_0200(): Promise<void> { 1164 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getForward_0200 data'); 1165 let commonEventPublishData = { 1166 data: 'FAILED' 1167 }; 1168 try { 1169 this.InputClient.getForward(undefined).then((result) => { 1170 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0200 Succeed in sendKeyFunction.' + JSON.stringify(result)); 1171 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getForward_0200', commonEventPublishData, this.publishCallback); 1172 }).catch((err) => { 1173 commonEventPublishData = { 1174 data: 'SUCCESS' 1175 }; 1176 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getForward_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1177 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getForward_0200', commonEventPublishData, this.publishCallback); 1178 }); 1179 } catch (err) { 1180 if (err.code === 401) { 1181 commonEventPublishData = { 1182 data: 'SUCCESS' 1183 }; 1184 } 1185 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getForward_0200 err: ' + JSON.stringify(err)); 1186 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getForward_0200', commonEventPublishData, this.publishCallback); 1187 } 1188 } 1189 1190 async Sub_Misc_inputMethodEngine_InputClient_getBackward_0100(): Promise<void> { 1191 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getBackward_0100 data'); 1192 let commonEventPublishData = { 1193 data: 'FAILED' 1194 }; 1195 try { 1196 this.InputClient.getBackward(undefined, (err, result) => { 1197 if (err) { 1198 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0100 sendKeyFunction err:' + JSON.stringify(err)); 1199 commonEventPublishData = { 1200 data: 'SUCCESS' 1201 }; 1202 } 1203 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0100 sendKeyFunction success' ); 1204 }); 1205 } catch (err) { 1206 if (err.code === 401) { 1207 commonEventPublishData = { 1208 data: 'SUCCESS' 1209 }; 1210 } 1211 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0100 catch err: ' + JSON.stringify(err)); 1212 } 1213 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getBackward_0100', commonEventPublishData, this.publishCallback); 1214 } 1215 1216 async Sub_Misc_inputMethodEngine_InputClient_getBackward_0200(): Promise<void> { 1217 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getBackward_0200 data'); 1218 let commonEventPublishData = { 1219 data: 'FAILED' 1220 }; 1221 try { 1222 this.InputClient.getBackward(undefined).then((result) => { 1223 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0200 Succeed in sendKeyFunction.' + JSON.stringify(result)); 1224 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getBackward_0200', commonEventPublishData, this.publishCallback); 1225 }).catch((err) => { 1226 commonEventPublishData = { 1227 data: 'SUCCESS' 1228 }; 1229 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_getBackward_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1230 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getBackward_0200', commonEventPublishData, this.publishCallback); 1231 }); 1232 } catch (err) { 1233 if (err.code === 401) { 1234 commonEventPublishData = { 1235 data: 'SUCCESS' 1236 }; 1237 } 1238 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_getBackward_0200 err: ' + JSON.stringify(err)); 1239 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_getBackward_0200', commonEventPublishData, this.publishCallback); 1240 } 1241 } 1242 1243 async Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100(): Promise<void> { 1244 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100 data'); 1245 let commonEventPublishData = { 1246 data: 'FAILED' 1247 }; 1248 try { 1249 this.InputClient.moveCursor(undefined, (err) => { 1250 if (err) { 1251 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100 sendKeyFunction err:' + JSON.stringify(err)); 1252 commonEventPublishData = { 1253 data: 'SUCCESS' 1254 }; 1255 } 1256 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100 sendKeyFunction success' ); 1257 }); 1258 } catch (err) { 1259 if (err.code === 401) { 1260 commonEventPublishData = { 1261 data: 'SUCCESS' 1262 }; 1263 } 1264 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100 catch err: ' + JSON.stringify(err)); 1265 } 1266 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_moveCursor_0100', commonEventPublishData, this.publishCallback); 1267 } 1268 1269 async Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200(): Promise<void> { 1270 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200 data'); 1271 let commonEventPublishData = { 1272 data: 'FAILED' 1273 }; 1274 try { 1275 this.InputClient.moveCursor(undefined).then( () => { 1276 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200 Succeed in sendKeyFunction.'); 1277 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200', commonEventPublishData, this.publishCallback); 1278 }).catch((err) => { 1279 commonEventPublishData = { 1280 data: 'SUCCESS' 1281 }; 1282 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1283 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200', commonEventPublishData, this.publishCallback); 1284 }); 1285 } catch (err) { 1286 if (err.code === 401) { 1287 commonEventPublishData = { 1288 data: 'SUCCESS' 1289 }; 1290 } 1291 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200 err: ' + JSON.stringify(err)); 1292 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_moveCursor_0200', commonEventPublishData, this.publishCallback); 1293 } 1294 } 1295 1296 async Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100(): Promise<void> { 1297 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100 data'); 1298 let commonEventPublishData = { 1299 data: 'FAILED' 1300 }; 1301 try { 1302 this.InputClient.selectByRange(undefined, (err) => { 1303 if (err) { 1304 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100 sendKeyFunction err:' + JSON.stringify(err)); 1305 commonEventPublishData = { 1306 data: 'SUCCESS' 1307 }; 1308 } 1309 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100 sendKeyFunction success' ); 1310 }); 1311 } catch (err) { 1312 if (err.code === 401) { 1313 commonEventPublishData = { 1314 data: 'SUCCESS' 1315 }; 1316 } 1317 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100 catch err: ' + JSON.stringify(err)); 1318 } 1319 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByRange_0100', commonEventPublishData, this.publishCallback); 1320 } 1321 1322 async Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200(): Promise<void> { 1323 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200 data'); 1324 let commonEventPublishData = { 1325 data: 'FAILED' 1326 }; 1327 try { 1328 this.InputClient.selectByRange(undefined).then( () => { 1329 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200 Succeed in sendKeyFunction.'); 1330 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200', commonEventPublishData, this.publishCallback); 1331 }).catch((err) => { 1332 commonEventPublishData = { 1333 data: 'SUCCESS' 1334 }; 1335 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1336 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200', commonEventPublishData, this.publishCallback); 1337 }); 1338 } catch (err) { 1339 if (err.code === 401) { 1340 commonEventPublishData = { 1341 data: 'SUCCESS' 1342 }; 1343 } 1344 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200 err: ' + JSON.stringify(err)); 1345 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByRange_0200', commonEventPublishData, this.publishCallback); 1346 } 1347 } 1348 1349 async Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100(): Promise<void> { 1350 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100 data'); 1351 let commonEventPublishData = { 1352 data: 'FAILED' 1353 }; 1354 try { 1355 this.InputClient.selectByMovement(undefined, (err) => { 1356 if (err) { 1357 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100 sendKeyFunction err:' + JSON.stringify(err)); 1358 commonEventPublishData = { 1359 data: 'SUCCESS' 1360 }; 1361 } 1362 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100 sendKeyFunction success' ); 1363 }); 1364 } catch (err) { 1365 if (err.code === 401) { 1366 commonEventPublishData = { 1367 data: 'SUCCESS' 1368 }; 1369 } 1370 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100 catch err: ' + JSON.stringify(err)); 1371 } 1372 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0100', commonEventPublishData, this.publishCallback); 1373 } 1374 1375 async Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200(): Promise<void> { 1376 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200 data'); 1377 let commonEventPublishData = { 1378 data: 'FAILED' 1379 }; 1380 try { 1381 this.InputClient.selectByMovement(undefined).then( () => { 1382 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200 Succeed in sendKeyFunction.'); 1383 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200', commonEventPublishData, this.publishCallback); 1384 }).catch((err) => { 1385 commonEventPublishData = { 1386 data: 'SUCCESS' 1387 }; 1388 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1389 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200', commonEventPublishData, this.publishCallback); 1390 }); 1391 } catch (err) { 1392 if (err.code === 401) { 1393 commonEventPublishData = { 1394 data: 'SUCCESS' 1395 }; 1396 } 1397 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200 err: ' + JSON.stringify(err)); 1398 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_selectByMovement_0200', commonEventPublishData, this.publishCallback); 1399 } 1400 } 1401 1402 async Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100(): Promise<void> { 1403 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100 data'); 1404 let commonEventPublishData = { 1405 data: 'FAILED' 1406 }; 1407 try { 1408 this.InputClient.sendExtendAction(undefined, (err) => { 1409 if (err) { 1410 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100 sendKeyFunction err:' + JSON.stringify(err)); 1411 commonEventPublishData = { 1412 data: 'SUCCESS' 1413 }; 1414 } 1415 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100 sendKeyFunction success' ); 1416 }); 1417 } catch (err) { 1418 if (err.code === 401) { 1419 commonEventPublishData = { 1420 data: 'SUCCESS' 1421 }; 1422 } 1423 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100 catch err: ' + JSON.stringify(err)); 1424 } 1425 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0100', commonEventPublishData, this.publishCallback); 1426 } 1427 1428 async Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200(): Promise<void> { 1429 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200 data'); 1430 let commonEventPublishData = { 1431 data: 'FAILED' 1432 }; 1433 try { 1434 this.InputClient.sendExtendAction(undefined).then( () => { 1435 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200 Succeed in sendKeyFunction.'); 1436 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200', commonEventPublishData, this.publishCallback); 1437 }).catch((err) => { 1438 commonEventPublishData = { 1439 data: 'SUCCESS' 1440 }; 1441 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1442 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200', commonEventPublishData, this.publishCallback); 1443 }); 1444 } catch (err) { 1445 if (err.code === 401) { 1446 commonEventPublishData = { 1447 data: 'SUCCESS' 1448 }; 1449 } 1450 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200 err: ' + JSON.stringify(err)); 1451 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendExtendAction_0200', commonEventPublishData, this.publishCallback); 1452 } 1453 } 1454 1455 async Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200(): Promise<void> { 1456 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200 data'); 1457 let commonEventPublishData = { 1458 data: 'FAILED' 1459 }; 1460 try { 1461 let record: Record<string, inputmethodengine.CommandDataType> = { 1462 'valueString1': 'abcdefg', 1463 'valueString2': true, 1464 'valueString3': 500, 1465 'valueString4': 400, 1466 'valueString5': 300, 1467 'valueString6': 200, 1468 }; 1469 this.InputClient.sendPrivateCommand(record).then( () => { 1470 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200 Succeed in sendKeyFunction.'); 1471 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200', commonEventPublishData, this.publishCallback); 1472 }).catch((err) => { 1473 commonEventPublishData = { 1474 data: 'SUCCESS' 1475 }; 1476 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1477 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200', commonEventPublishData, this.publishCallback); 1478 }); 1479 } catch (err) { 1480 if (err.code === 401) { 1481 commonEventPublishData = { 1482 data: 'SUCCESS' 1483 }; 1484 }; 1485 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200 err: ' + JSON.stringify(err)); 1486 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_sendPrivateCommand_0200', commonEventPublishData, this.publishCallback); 1487 } 1488 } 1489 1490 private async Sub_InputMethod_IMF_SecurityKeyboard_0601(): Promise<void> { 1491 let commonEventPublishData = { 1492 data: 'FAILED' 1493 }; 1494 console.info(TAG + '====>Sub_InputMethod_IMF_SecurityKeyboard_0601 success'); 1495 let panelInfo1 = { 1496 type: 0, 1497 flag:1 1498 }; 1499 let inputPanel = await inputMethodAbility.createPanel(this.mContext, panelInfo1); 1500 try { 1501 let isPrivacyMode: boolean = true; 1502 inputPanel.setPrivacyMode(isPrivacyMode); 1503 console.info(TAG + '====>Sub_InputMethod_IMF_SecurityKeyboard_0601 setPrivacyMode success'); 1504 commoneventmanager.publish('Sub_InputMethod_IMF_SecurityKeyboard_0601', commonEventPublishData, this.publishCallback); 1505 } catch (error) { 1506 if (error.code === 201) { 1507 commonEventPublishData = { 1508 data: 'SUCCESS' 1509 }; 1510 }; 1511 await inputMethodAbility.destroyPanel(inputPanel); 1512 console.info(TAG + '====>Sub_InputMethod_IMF_SecurityKeyboard_0601 catch error: ' + JSON.stringify(error)); 1513 commoneventmanager.publish('Sub_InputMethod_IMF_SecurityKeyboard_0601', commonEventPublishData, this.publishCallback); 1514 } 1515 } 1516 1517 async Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100(): Promise<void> { 1518 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100 data'); 1519 let commonEventPublishData = { 1520 data: 'FAILED' 1521 }; 1522 try { 1523 this.InputClient.deleteBackward(undefined, (err, result) => { 1524 if (err) { 1525 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100 sendKeyFunction err:' + JSON.stringify(err)); 1526 commonEventPublishData = { 1527 data: 'SUCCESS' 1528 }; 1529 } 1530 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100 sendKeyFunction success' ); 1531 }); 1532 } catch (err) { 1533 if (err.code === 401) { 1534 commonEventPublishData = { 1535 data: 'SUCCESS' 1536 }; 1537 } 1538 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100 catch err: ' + JSON.stringify(err)); 1539 } 1540 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0100', commonEventPublishData, this.publishCallback); 1541 } 1542 1543 async Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200(): Promise<void> { 1544 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200 data'); 1545 let commonEventPublishData = { 1546 data: 'FAILED' 1547 }; 1548 try { 1549 this.InputClient.deleteBackward(undefined).then((result) => { 1550 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200 Succeed in sendKeyFunction.' + JSON.stringify(result)); 1551 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200', commonEventPublishData, this.publishCallback); 1552 }).catch((err) => { 1553 commonEventPublishData = { 1554 data: 'SUCCESS' 1555 }; 1556 console.info(TAG + '====>receive Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200 sendKeyFunction error: ' + JSON.stringify(err)); 1557 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200', commonEventPublishData, this.publishCallback); 1558 }); 1559 } catch (err) { 1560 if (err.code === 401) { 1561 commonEventPublishData = { 1562 data: 'SUCCESS' 1563 }; 1564 } 1565 console.info(TAG + '====>Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200 err: ' + JSON.stringify(err)); 1566 commoneventmanager.publish('Sub_Misc_inputMethodEngine_InputClient_deleteBackward_0200', commonEventPublishData, this.publishCallback); 1567 } 1568 } 1569 1570 async SUB_InputMethod_IME_PrivateDateTransferred_1101(): Promise<void> { 1571 console.info(TAG + '====>receive SUB_InputMethod_IME_PrivateDateTransferred_1101 data'); 1572 let commonEventPublishData = { 1573 data: 'FAILED' 1574 }; 1575 try { 1576 await this.mContext.startAbility(undefined); 1577 console.info(TAG + '====>SUB_InputMethod_IME_PrivateDateTransferred_1101 startAbility success'); 1578 } catch (err) { 1579 console.info(TAG + '====>SUB_InputMethod_IME_PrivateDateTransferred_1101 err: ' + JSON.stringify(err)); 1580 if (err.code === 401) { 1581 commonEventPublishData = { 1582 data: 'SUCCESS' 1583 }; 1584 } 1585 }; 1586 commoneventmanager.publish('SUB_InputMethod_IME_PrivateDateTransferred_1101', commonEventPublishData, this.publishCallback); 1587 } 1588}