1/* 2 * Copyright (c) 2022 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 */ 15import inputMethodEngine from '@ohos.inputMethodEngine'; 16import display from '@ohos.display'; 17import windowManager from '@ohos.window'; 18import promptAction from '@ohos.promptAction'; 19import commoneventmanager from '@ohos.commonEventManager'; 20 21let inputMethodAbility = inputMethodEngine.getInputMethodAbility(); 22let inputKeyboardDelegate = inputMethodEngine.getKeyboardDelegate(); 23 24const TAG = 'KeyboardDelegate'; 25 26export class KeyboardDelegate { 27 mContext; 28 WINDOW_TYPE_INPUT_METHOD_FLOAT = 2105; 29 windowName = 'inputApp'; 30 private windowHeight: number = 0; 31 private windowWidth: number = 0; 32 private nonBarPosition: number = 0; 33 34 constructor(context) { 35 this.mContext = context; 36 } 37 38 public onCreate(): void { 39 this.initWindow(); 40 let that = this; 41 inputMethodAbility.on("inputStop", () => { 42 try{ 43 that.mContext.destroy((err) => { 44 console.info(TAG + '====>inputMethodAbility destroy err:' + JSON.stringify(err)); 45 }) 46 }catch(err){ 47 console.info(TAG + '====>inputMethodAbility destroy catch err:' + JSON.stringify(err)); 48 console.info(TAG + '====>inputMethodAbility destroy catch err:' + err); 49 } 50 }) 51 52 function subscriberCallback(err, data) { 53 console.debug(TAG + '====>receive event err:' + JSON.stringify(err)); 54 console.debug(TAG + '====>receive event data:' + JSON.stringify(data)); 55 switch (data.code) { 56 case 1: 57 console.debug(TAG + '====>inputMethodAbility_test_getInputMethodAbility_001 event:' + data.event); 58 that.inputMethodAbility_test_getInputMethodAbility_001(); 59 break; 60 case 2: 61 console.debug(TAG + '====>inputMethodAbility_test_getInputMethodDelegate_001 event:' + data.event); 62 that.inputMethodAbility_test_getKeyboardDelegate_001(); 63 break; 64 case 28: 65 console.debug(TAG + '====>inputMethodAbility_test_028 event:' + data.event); 66 that.inputMethodAbility_test_028(); 67 break; 68 case 29: 69 console.debug(TAG + '====>inputMethodAbility_test_029 event:' + data.event); 70 that.inputMethodAbility_test_029(); 71 break; 72 case 30: 73 console.debug(TAG + '====>inputMethodAbility_test_030 event:' + data.event); 74 that.inputMethodAbility_test_030(); 75 break; 76 case 31: 77 console.debug(TAG + '====>inputMethodAbility_test_031 event:' + data.event); 78 that.inputMethodAbility_test_031(); 79 break; 80 case 32: 81 console.debug(TAG + '====>inputMethodAbility_test_032 event:' + data.event); 82 that.inputMethodAbility_test_032(); 83 break; 84 case 33: 85 console.debug(TAG + '====>inputMethodAbility_test_033 event:' + data.event); 86 that.inputMethodAbility_test_033(); 87 break; 88 case 34: 89 console.debug(TAG + '====>inputMethodAbility_test_034 event:' + data.event); 90 that.inputMethodAbility_test_034(); 91 break; 92 case 35: 93 console.debug(TAG + '====>inputMethodAbility_test_035 event:' + data.event); 94 that.inputMethodAbility_test_035(); 95 break; 96 case 36: 97 console.debug(TAG + '====>inputMethodAbility_test_036 event:' + data.event); 98 that.inputMethodAbility_test_036(); 99 break; 100 case 37: 101 console.debug(TAG + '====>inputMethodAbility_test_037 event:' + data.event); 102 that.inputMethodAbility_test_037(); 103 break; 104 case 38: 105 console.debug(TAG + '====>inputMethodAbility_test_038 event:' + data.event); 106 that.inputMethodAbility_test_038(); 107 break; 108 case 39: 109 console.debug(TAG + '====>inputMethodAbility_test_039 event:' + data.event); 110 that.inputMethodAbility_test_039(); 111 break; 112 case 40: 113 console.debug(TAG + '====>inputMethodAbility_test_040 event:' + data.event); 114 that.inputMethodAbility_test_040(); 115 break; 116 case 41: 117 console.debug(TAG + '====>inputMethodAbility_test_041 event:' + data.event); 118 that.inputMethodAbility_test_041(); 119 break; 120 case 42: 121 console.debug(TAG + '====>inputMethodAbility_test_042 event:' + data.event); 122 that.inputMethodAbility_test_042(); 123 break; 124 case 43: 125 console.debug(TAG + '====>inputMethodAbility_test_043 event:' + data.event); 126 that.inputMethodAbility_test_043(); 127 break; 128 case 45: 129 console.debug(TAG + '====>inputMethodAbility_test_045 event:' + data.event); 130 that.inputMethodAbility_test_045(); 131 break; 132 case 46: 133 console.debug(TAG + '====>inputMethodAbility_test_046 event:' + data.event); 134 that.inputMethodAbility_test_046(); 135 break; 136 case 47: 137 console.debug(TAG + '====>inputMethodAbility_test_047 event:' + data.event); 138 that.inputMethodAbility_test_047(); 139 break; 140 case 48: 141 console.debug(TAG + '====>inputMethodAbility_test_048 event:' + data.event); 142 that.inputMethodAbility_test_048(); 143 break; 144 case 49: 145 console.debug(TAG + '====>inputMethodAbility_test_049 event:' + data.event); 146 that.inputMethodAbility_test_049(); 147 break; 148 case 50: 149 console.debug(TAG + '====>inputMethodAbility_test_050 event:' + data.event); 150 that.inputMethodAbility_test_050(); 151 break; 152 } 153 } 154 155 var commonEventSubscribeInfo = { 156 events: ["test"] 157 }; 158 159 var subscriber; 160 commoneventmanager.createSubscriber(commonEventSubscribeInfo).then(function (data) { 161 subscriber = data; 162 commoneventmanager.subscribe(subscriber, subscriberCallback); 163 console.debug(TAG + '====>scene subscribe finish===='); 164 }); 165 } 166 167 public initWindow(): void { 168 let dis = display.getDefaultDisplaySync(); 169 var dWidth = dis.width; 170 var dHeight = dis.height; 171 var keyHeightRate = 0.47; 172 var keyHeight = dHeight * keyHeightRate; 173 this.windowWidth = dWidth; 174 this.windowHeight = keyHeight; 175 this.nonBarPosition = dHeight - keyHeight; 176 177 var config = { 178 name: this.windowName, 179 windowType: this.WINDOW_TYPE_INPUT_METHOD_FLOAT, 180 cts: this.mContext 181 }; 182 183 windowManager.createWindow(config).then((win) => { 184 win.resize(dWidth, keyHeight).then(() => { 185 win.moveWindowTo(0, this.nonBarPosition).then(() => { 186 win.setUIContent('page/service/index').then(() => { 187 }); 188 }); 189 }); 190 }); 191 } 192 193 public onDestroy(): void { 194 console.debug(TAG + '====>onDestroy'); 195 globalThis.textInputClient.getTextIndexAtCursor().then((index) => { 196 console.debug(TAG + '====>getTextIndexAtCursor index:' + index); 197 promptAction.showToast({ message: 'getTextIndexAtCursor success' + index, duration: 200, bottom: 500 }); 198 var win = windowManager.findWindow(this.windowName); 199 win.destroyWindow(); 200 this.mContext.terminateSelf(); 201 return true; 202 }).catch((err) => { 203 promptAction.showToast({ message: 'getTextIndexAtCursor failed', duration: 200, bottom: 500 }); 204 }); 205 } 206 207 private publishCallback(err): void { 208 if (err) { 209 console.error(TAG + '====>publish failed:' + JSON.stringify(err)); 210 } else { 211 console.debug(TAG + '====>publish'); 212 } 213 } 214 215 private inputMethodAbility_test_getInputMethodAbility_001(): void { 216 console.debug(TAG + '====>receive inputMethodAbility_test_getInputMethodAbility_001 data'); 217 if (typeof(inputMethodAbility) === 'object') { 218 console.debug(TAG + '====>inputMethodAbility_test_getInputMethodAbility_001 success'); 219 var commonEventPublishData = { 220 data: "SUCCESS" 221 }; 222 } else { 223 console.debug(TAG + '====>inputMethodAbility_test_getInputMethodAbility_001 failed'); 224 var commonEventPublishData = { 225 data: "FAILED" 226 }; 227 } 228 commoneventmanager.publish("inputMethodAbility_test_getInputMethodAbility_001", commonEventPublishData, this.publishCallback); 229 } 230 231 private inputMethodAbility_test_getKeyboardDelegate_001(): void { 232 console.debug(TAG + '====>receive inputMethodAbility_test_getKeyboardDelegate_001 data'); 233 if (typeof (inputKeyboardDelegate) === 'object') { 234 console.debug(TAG + '====>inputMethodAbility_test_getKeyboardDelegate_001 success'); 235 var commonEventPublishData = { 236 data: "SUCCESS" 237 }; 238 } else { 239 console.debug(TAG + '====>inputMethodAbility_test_getKeyboardDelegate_001 failed'); 240 var commonEventPublishData = { 241 data: "FAILED" 242 }; 243 } 244 commoneventmanager.publish("inputMethodAbility_test_getKeyboardDelegate_001", commonEventPublishData, this.publishCallback); 245 } 246 247 private inputMethodAbility_test_028(): void { 248 console.debug(TAG + '====>receive inputMethodAbility_test_028 data'); 249 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 250 inputMethodAbility.off('inputStart'); 251 let commonEventPublishData; 252 if (InputClient == null) { 253 commonEventPublishData = { 254 data: "FAILED" 255 }; 256 commoneventmanager.publish("inputMethodAbility_test_028", commonEventPublishData, this.publishCallback); 257 } else { 258 let editorAttribyte = await InputClient.getEditorAttribute(); 259 console.debug(TAG + '====>inputMethodAbility_test_028 editorAttribyte:' + JSON.stringify(editorAttribyte)); 260 InputClient.sendKeyFunction(editorAttribyte.enterKeyType, (err, value) => { 261 if (err) { 262 console.debug(TAG + '====>inputMethodAbility_test_028 sendKeyFunction err:' + JSON.stringify(err)); 263 commonEventPublishData = { 264 data: "FAILED" 265 }; 266 } else { 267 console.debug(TAG + '====>inputMethodAbility_test_028 sendKeyFunction value:' + JSON.stringify(value)); 268 if (value) { 269 commonEventPublishData = { 270 data: "SUCCESS" 271 }; 272 } else { 273 commonEventPublishData = { 274 data: "FAILED" 275 }; 276 } 277 } 278 commoneventmanager.publish("inputMethodAbility_test_028", commonEventPublishData, this.publishCallback); 279 }); 280 } 281 }); 282 } 283 284 private inputMethodAbility_test_029(): void { 285 console.debug(TAG + '====>receive inputMethodAbility_test_029 data'); 286 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 287 inputMethodAbility.off('inputStart'); 288 let commonEventPublishData; 289 if (InputClient == null) { 290 commonEventPublishData = { 291 data: "FAILED" 292 }; 293 commoneventmanager.publish("inputMethodAbility_test_029", commonEventPublishData, this.publishCallback); 294 } else { 295 let editorAttribyte = await InputClient.getEditorAttribute(); 296 console.debug(TAG + '====>inputMethodAbility_test_029 editorAttribyte:' + JSON.stringify(editorAttribyte)); 297 let value = InputClient.sendKeyFunction(editorAttribyte.enterKeyType); 298 console.debug(TAG + '====>inputMethodAbility_test_029 sendKeyFunction value:' + JSON.stringify(value)); 299 if (value) { 300 commonEventPublishData = { 301 data: "SUCCESS" 302 }; 303 } else { 304 commonEventPublishData = { 305 data: "FAILED" 306 }; 307 } 308 commoneventmanager.publish("inputMethodAbility_test_029", commonEventPublishData, this.publishCallback); 309 } 310 }); 311 } 312 313 private inputMethodAbility_test_030(): void { 314 console.debug(TAG + '====>receive inputMethodAbility_test_030 data'); 315 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 316 inputMethodAbility.off('inputStart'); 317 let commonEventPublishData; 318 if (InputClient == null) { 319 commonEventPublishData = { 320 data: "FAILED" 321 }; 322 commoneventmanager.publish("inputMethodAbility_test_030", commonEventPublishData, this.publishCallback); 323 } else { 324 InputClient.deleteForward(1, (err, value) => { 325 if (err) { 326 console.debug(TAG + '====>inputMethodAbility_test_030 deleteForward err:' + JSON.stringify(err)); 327 commonEventPublishData = { 328 data: "FAILED" 329 }; 330 } else { 331 console.debug(TAG + '====>inputMethodAbility_test_030 deleteForward value:' + JSON.stringify(value)); 332 if (typeof value === 'boolean') { 333 commonEventPublishData = { 334 data: "SUCCESS" 335 }; 336 } else { 337 commonEventPublishData = { 338 data: "FAILED" 339 }; 340 } 341 } 342 commoneventmanager.publish("inputMethodAbility_test_030", commonEventPublishData, this.publishCallback); 343 }); 344 } 345 }); 346 } 347 348 private inputMethodAbility_test_031(): void { 349 console.debug(TAG + '====>receive inputMethodAbility_test_031 data'); 350 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 351 inputMethodAbility.off('inputStart'); 352 let commonEventPublishData; 353 if (InputClient == null) { 354 commonEventPublishData = { 355 data: "FAILED" 356 }; 357 commoneventmanager.publish("inputMethodAbility_test_031", commonEventPublishData, this.publishCallback); 358 } else { 359 let value = await InputClient.deleteForward(1); 360 console.debug(TAG + '====>inputMethodAbility_test_031 deleteForward value:' + value); 361 if (typeof value === 'boolean') { 362 commonEventPublishData = { 363 data: "SUCCESS" 364 }; 365 } else { 366 commonEventPublishData = { 367 data: "FAILED" 368 }; 369 } 370 commoneventmanager.publish("inputMethodAbility_test_031", commonEventPublishData, this.publishCallback); 371 } 372 }); 373 } 374 375 private inputMethodAbility_test_032(): void { 376 console.debug(TAG + '====>receive inputMethodAbility_test_032 data'); 377 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 378 inputMethodAbility.off('inputStart'); 379 let commonEventPublishData; 380 if (InputClient == null) { 381 commonEventPublishData = { 382 data: "FAILED" 383 }; 384 commoneventmanager.publish("inputMethodAbility_test_032", commonEventPublishData, this.publishCallback); 385 } else { 386 InputClient.deleteBackward(1, (err, value) => { 387 if (err) { 388 console.debug(TAG + '====>inputMethodAbility_test_032 deleteBackward err:' + JSON.stringify(err)); 389 commonEventPublishData = { 390 data: "FAILED" 391 }; 392 } else { 393 console.debug(TAG + '====>inputMethodAbility_test_032 deleteBackward value:' + JSON.stringify(value)); 394 if (value) { 395 commonEventPublishData = { 396 data: "SUCCESS" 397 }; 398 } else { 399 commonEventPublishData = { 400 data: "FAILED" 401 }; 402 } 403 } 404 commoneventmanager.publish("inputMethodAbility_test_032", commonEventPublishData, this.publishCallback); 405 }); 406 } 407 }); 408 } 409 410 private inputMethodAbility_test_033(): void { 411 console.debug(TAG + '====>receive inputMethodAbility_test_033 data'); 412 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 413 inputMethodAbility.off('inputStart'); 414 let commonEventPublishData; 415 if (InputClient == null) { 416 commonEventPublishData = { 417 data: "FAILED" 418 }; 419 commoneventmanager.publish("inputMethodAbility_test_033", commonEventPublishData, this.publishCallback); 420 } else { 421 let value = await InputClient.deleteBackward(1); 422 console.debug(TAG + '====>inputMethodAbility_test_033 deleteBackward value:' + JSON.stringify(value)); 423 if (value) { 424 commonEventPublishData = { 425 data: "SUCCESS" 426 }; 427 } else { 428 commonEventPublishData = { 429 data: "FAILED" 430 }; 431 } 432 commoneventmanager.publish("inputMethodAbility_test_033", commonEventPublishData, this.publishCallback); 433 } 434 }); 435 } 436 437 private inputMethodAbility_test_034(): void { 438 console.debug(TAG + '====>receive inputMethodAbility_test_034 data'); 439 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 440 inputMethodAbility.off('inputStart'); 441 let commonEventPublishData; 442 if (InputClient == null) { 443 commonEventPublishData = { 444 data: "FAILED" 445 }; 446 commoneventmanager.publish("inputMethodAbility_test_034", commonEventPublishData, this.publishCallback); 447 } else { 448 InputClient.insertText('test', (err, value) => { 449 if (err) { 450 console.debug(TAG + '====>inputMethodAbility_test_034 insertText err:' + JSON.stringify(err)); 451 commonEventPublishData = { 452 data: "FAILED" 453 }; 454 } else { 455 console.debug(TAG + '====>inputMethodAbility_test_034 insertText value:' + JSON.stringify(value)); 456 if (value) { 457 commonEventPublishData = { 458 data: "SUCCESS" 459 }; 460 } else { 461 commonEventPublishData = { 462 data: "FAILED" 463 }; 464 } 465 } 466 commoneventmanager.publish("inputMethodAbility_test_034", commonEventPublishData, this.publishCallback); 467 }); 468 } 469 }); 470 } 471 472 private inputMethodAbility_test_035(): void { 473 console.debug(TAG + '====>receive inputMethodAbility_test_035 data'); 474 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 475 inputMethodAbility.off('inputStart'); 476 let commonEventPublishData; 477 if (InputClient == null) { 478 commonEventPublishData = { 479 data: "FAILED" 480 }; 481 commoneventmanager.publish("inputMethodAbility_test_035", commonEventPublishData, this.publishCallback); 482 } else { 483 let value = InputClient.insertText('test'); 484 console.debug(TAG + '====>inputMethodAbility_test_035 insertText value:' + JSON.stringify(value)); 485 if (value) { 486 commonEventPublishData = { 487 data: "SUCCESS" 488 }; 489 } else { 490 commonEventPublishData = { 491 data: "FAILED" 492 }; 493 } 494 commoneventmanager.publish("inputMethodAbility_test_035", commonEventPublishData, this.publishCallback); 495 } 496 }); 497 } 498 499 private inputMethodAbility_test_036(): void { 500 console.debug(TAG + '====>receive inputMethodAbility_test_036 data'); 501 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 502 inputMethodAbility.off('inputStart'); 503 let commonEventPublishData; 504 if (InputClient == null) { 505 commonEventPublishData = { 506 data: "FAILED" 507 }; 508 commoneventmanager.publish("inputMethodAbility_test_036", commonEventPublishData, this.publishCallback); 509 } else { 510 InputClient.getForward(1, (err, value) => { 511 if (err) { 512 console.debug(TAG + '====>inputMethodAbility_test_036 getForward err:' + JSON.stringify(err)); 513 commonEventPublishData = { 514 data: "FAILED" 515 }; 516 } else { 517 console.debug(TAG + '====>inputMethodAbility_test_036 getForward 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("inputMethodAbility_test_036", commonEventPublishData, this.publishCallback); 529 }); 530 } 531 }); 532 } 533 534 private inputMethodAbility_test_037(): void { 535 console.debug(TAG + '====>receive inputMethodAbility_test_037 data'); 536 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 537 inputMethodAbility.off('inputStart'); 538 let commonEventPublishData; 539 if (InputClient == null) { 540 commonEventPublishData = { 541 data: "FAILED" 542 }; 543 commoneventmanager.publish("inputMethodAbility_test_037", commonEventPublishData, this.publishCallback); 544 } else { 545 let value = InputClient.getForward(1); 546 console.debug(TAG + '====>inputMethodAbility_test_037 getForward value' + JSON.stringify(value)); 547 if (value) { 548 commonEventPublishData = { 549 data: "SUCCESS" 550 }; 551 } else { 552 commonEventPublishData = { 553 data: "FAILED" 554 }; 555 } 556 commoneventmanager.publish("inputMethodAbility_test_037", commonEventPublishData, this.publishCallback); 557 } 558 }); 559 } 560 561 private inputMethodAbility_test_038(): void { 562 console.debug(TAG + '====>receive inputMethodAbility_test_038 data'); 563 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 564 inputMethodAbility.off('inputStart'); 565 let commonEventPublishData; 566 if (InputClient == null) { 567 commonEventPublishData = { 568 data: "FAILED" 569 }; 570 commoneventmanager.publish("inputMethodAbility_test_038", commonEventPublishData, this.publishCallback); 571 } else { 572 InputClient.getEditorAttribute((err, value) => { 573 if (err) { 574 console.debug(TAG + '====>inputMethodAbility_test_038 getEditorAttribute err:' + JSON.stringify(err)); 575 commonEventPublishData = { 576 data: "FAILED" 577 }; 578 } else { 579 console.debug(TAG + '====>inputMethodAbility_test_038 getEditorAttribute value:' + JSON.stringify(value)); 580 if (value) { 581 commonEventPublishData = { 582 data: "SUCCESS" 583 }; 584 } else { 585 commonEventPublishData = { 586 data: "FAILED" 587 }; 588 } 589 } 590 commoneventmanager.publish("inputMethodAbility_test_038", commonEventPublishData, this.publishCallback); 591 }); 592 } 593 }); 594 } 595 596 private inputMethodAbility_test_039(): void { 597 console.debug(TAG + '====>receive inputMethodAbility_test_039 data'); 598 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 599 inputMethodAbility.off('inputStart'); 600 let commonEventPublishData; 601 if (InputClient == null) { 602 commonEventPublishData = { 603 data: "FAILED" 604 }; 605 commoneventmanager.publish("inputMethodAbility_test_039", commonEventPublishData, this.publishCallback); 606 } else { 607 let value = InputClient.getEditorAttribute(); 608 console.debug(TAG + '====>inputMethodAbility_test_039 getEditorAttribute value:' + JSON.stringify(value)); 609 if (value) { 610 commonEventPublishData = { 611 data: "SUCCESS" 612 }; 613 } else { 614 commonEventPublishData = { 615 data: "FAILED" 616 }; 617 } 618 commoneventmanager.publish("inputMethodAbility_test_039", commonEventPublishData, this.publishCallback); 619 } 620 }); 621 } 622 623 private inputMethodAbility_test_040(): void { 624 console.debug(TAG + '====>receive inputMethodAbility_test_040 data'); 625 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 626 inputMethodAbility.off('inputStart'); 627 let commonEventPublishData; 628 if (InputClient == null) { 629 commonEventPublishData = { 630 data: "FAILED" 631 }; 632 commoneventmanager.publish("inputMethodAbility_test_040", commonEventPublishData, this.publishCallback); 633 } else { 634 try { 635 KeyboardDelegate.hideKeyboard((err, value) => { 636 if (err) { 637 console.debug(TAG + '====>inputMethodAbility_test_040 hideKeyboard err:' + JSON.stringify(err)); 638 commonEventPublishData = { 639 data: "FAILED" 640 }; 641 } else { 642 commonEventPublishData = { 643 data: "SUCCESS" 644 }; 645 } 646 commoneventmanager.publish("inputMethodAbility_test_040", commonEventPublishData, this.publishCallback); 647 }); 648 } catch (err) { 649 commonEventPublishData = { 650 data: "FAILED" 651 }; 652 console.debug(TAG + '====>inputMethodAbility_test_040 hideKeyboard throw_err:'); 653 commoneventmanager.publish("inputMethodAbility_test_040", commonEventPublishData, this.publishCallback); 654 } 655 } 656 }); 657 } 658 659 private inputMethodAbility_test_041(): void { 660 console.debug(TAG + '====>receive inputMethodAbility_test_041 data'); 661 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 662 inputMethodAbility.off('inputStart'); 663 let commonEventPublishData; 664 if (InputClient == null) { 665 commonEventPublishData = { 666 data: "FAILED" 667 }; 668 commoneventmanager.publish("inputMethodAbility_test_041", commonEventPublishData, this.publishCallback); 669 } else { 670 try { 671 await KeyboardDelegate.hideKeyboard(); 672 console.debug(TAG + '====>inputMethodAbility_test_041 hideKeyboard success'); 673 commonEventPublishData = { 674 data: "SUCCESS" 675 }; 676 } catch (err) { 677 commonEventPublishData = { 678 data: "FAILED" 679 }; 680 console.debug(TAG + '====>inputMethodAbility_test_041 hideKeyboard catch err:' + JSON.stringify(err)); 681 } 682 commoneventmanager.publish("inputMethodAbility_test_041", commonEventPublishData, this.publishCallback); 683 } 684 }); 685 } 686 687 private inputMethodAbility_test_042(): void { 688 console.debug(TAG + '====>receive inputMethodAbility_test_042 data'); 689 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 690 inputMethodAbility.off('inputStart'); 691 let commonEventPublishData; 692 if (InputClient == null) { 693 commonEventPublishData = { 694 data: "FAILED" 695 }; 696 commoneventmanager.publish("inputMethodAbility_test_042", commonEventPublishData, this.publishCallback); 697 } else { 698 InputClient.getBackward(1, (err, value) => { 699 if (err) { 700 console.debug(TAG + '====>inputMethodAbility_test_042 getBackward err:' + JSON.stringify(err)); 701 commonEventPublishData = { 702 data: "FAILED" 703 }; 704 } else { 705 console.debug(TAG + '====>inputMethodAbility_test_042 getBackward value:' + JSON.stringify(value)); 706 commonEventPublishData = { 707 data: "SUCCESS" 708 }; 709 } 710 commoneventmanager.publish("inputMethodAbility_test_042", commonEventPublishData, this.publishCallback); 711 }); 712 } 713 }); 714 } 715 716 private inputMethodAbility_test_043(): void { 717 console.debug(TAG + '====>receive inputMethodAbility_test_043 data'); 718 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 719 inputMethodAbility.off('inputStart'); 720 let commonEventPublishData; 721 if (InputClient == null) { 722 commonEventPublishData = { 723 data: "FAILED" 724 }; 725 commoneventmanager.publish("inputMethodAbility_test_043", commonEventPublishData, this.publishCallback); 726 } else { 727 let value = InputClient.getBackward(1); 728 console.debug(TAG + '====>inputMethodAbility_test_043 getBackward value:' + JSON.stringify(value)); 729 commonEventPublishData = { 730 data: "SUCCESS" 731 }; 732 commoneventmanager.publish("inputMethodAbility_test_043", commonEventPublishData, this.publishCallback); 733 } 734 }); 735 } 736 737 private inputMethodAbility_test_045(): void { 738 console.debug(TAG + '====>receive inputMethodAbility_test_045 data'); 739 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 740 inputMethodAbility.off('inputStart'); 741 setTimeout(()=>{ 742 let commonEventPublishData; 743 if (InputClient == null) { 744 commonEventPublishData = { 745 data: "FAILED" 746 }; 747 commoneventmanager.publish("inputMethodAbility_test_045", commonEventPublishData, this.publishCallback); 748 } else { 749 InputClient.moveCursor(inputMethodEngine.CURSOR_UP, (err, value) => { 750 if (err) { 751 console.debug(TAG + '====>inputMethodAbility_test_045 CURSOR_UP err:' + JSON.stringify(err)); 752 commonEventPublishData = { 753 data: "FAILED" 754 }; 755 } else { 756 console.debug(TAG + '====>inputMethodAbility_test_045 CURSOR_UP value:' + JSON.stringify(value)); 757 commonEventPublishData = { 758 data: "SUCCESS" 759 }; 760 } 761 commoneventmanager.publish("inputMethodAbility_test_045", commonEventPublishData, this.publishCallback); 762 }); 763 } 764 },1000); 765 766 }); 767 } 768 769 private inputMethodAbility_test_046(): void { 770 console.debug(TAG + '====>receive inputMethodAbility_test_046 data'); 771 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 772 inputMethodAbility.off('inputStart'); 773 let commonEventPublishData; 774 if (InputClient == null) { 775 commonEventPublishData = { 776 data: "FAILED" 777 }; 778 commoneventmanager.publish("inputMethodAbility_test_046", commonEventPublishData, this.publishCallback); 779 } else { 780 InputClient.moveCursor(inputMethodEngine.CURSOR_DOWN, (err, value) => { 781 if (err) { 782 console.debug(TAG + '====>inputMethodAbility_test_046 CURSOR_DOWN err:' + JSON.stringify(err)); 783 commonEventPublishData = { 784 data: "FAILED" 785 }; 786 } else { 787 console.debug(TAG + '====>inputMethodAbility_test_046 CURSOR_DOWN value:' + JSON.stringify(value)); 788 commonEventPublishData = { 789 data: "SUCCESS" 790 }; 791 } 792 commoneventmanager.publish("inputMethodAbility_test_046", commonEventPublishData, this.publishCallback); 793 }); 794 } 795 }); 796 } 797 798 private inputMethodAbility_test_047(): void { 799 console.debug(TAG + '====>receive inputMethodAbility_test_047 data'); 800 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 801 inputMethodAbility.off('inputStart'); 802 let commonEventPublishData; 803 if (InputClient == null) { 804 commonEventPublishData = { 805 data: "FAILED" 806 }; 807 commoneventmanager.publish("inputMethodAbility_test_047", commonEventPublishData, this.publishCallback); 808 } else { 809 await InputClient.moveCursor(inputMethodEngine.CURSOR_LEFT); 810 console.debug(TAG + '====>inputMethodAbility_test_047 CURSOR_LEFT success'); 811 commonEventPublishData = { 812 data: "SUCCESS" 813 }; 814 commoneventmanager.publish("inputMethodAbility_test_047", commonEventPublishData, this.publishCallback); 815 } 816 }); 817 } 818 819 private inputMethodAbility_test_048(): void { 820 console.debug(TAG + '====>receive inputMethodAbility_test_048 data'); 821 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 822 inputMethodAbility.off('inputStart'); 823 let commonEventPublishData; 824 if (InputClient == null) { 825 commonEventPublishData = { 826 data: "FAILED" 827 }; 828 commoneventmanager.publish("inputMethodAbility_test_048", commonEventPublishData, this.publishCallback); 829 } else { 830 await InputClient.moveCursor(inputMethodEngine.CURSOR_RIGHT); 831 console.debug(TAG + '====>inputMethodAbility_test_048 CURSOR_RIGHT success'); 832 commonEventPublishData = { 833 data: "SUCCESS" 834 }; 835 commoneventmanager.publish("inputMethodAbility_test_048", commonEventPublishData, this.publishCallback); 836 } 837 }); 838 } 839 840 private inputMethodAbility_test_049(): void { 841 console.debug(TAG + '====>receive inputMethodAbility_test_049 data'); 842 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 843 inputMethodAbility.off('inputStart'); 844 let commonEventPublishData; 845 if (InputClient == null) { 846 commonEventPublishData = { 847 data: "FAILED" 848 }; 849 commoneventmanager.publish("inputMethodAbility_test_049", commonEventPublishData, this.publishCallback); 850 } else { 851 try { 852 KeyboardDelegate.hide((err, value) => { 853 if (err) { 854 console.debug(TAG + '====>inputMethodAbility_test_049 hide err:' + JSON.stringify(err)); 855 commonEventPublishData = { 856 data: "FAILED" 857 }; 858 } else { 859 commonEventPublishData = { 860 data: "SUCCESS" 861 }; 862 } 863 commoneventmanager.publish("inputMethodAbility_test_049", commonEventPublishData, this.publishCallback); 864 }); 865 } catch (err) { 866 commonEventPublishData = { 867 data: "FAILED" 868 }; 869 console.debug(TAG + '====>inputMethodAbility_test_049 hide throw_err:'); 870 commoneventmanager.publish("inputMethodAbility_test_040", commonEventPublishData, this.publishCallback); 871 } 872 } 873 }); 874 } 875 876 private inputMethodAbility_test_050(): void { 877 console.debug(TAG + '====>receive inputMethodAbility_test_050 data'); 878 inputMethodAbility.on('inputStart', async (KeyboardDelegate, InputClient) => { 879 inputMethodAbility.off('inputStart'); 880 let commonEventPublishData; 881 if (InputClient == null) { 882 commonEventPublishData = { 883 data: "FAILED" 884 }; 885 commoneventmanager.publish("inputMethodAbility_test_050", commonEventPublishData, this.publishCallback); 886 } else { 887 try { 888 await KeyboardDelegate.hide(); 889 console.debug(TAG + '====>inputMethodAbility_test_050 hideKeyboard success'); 890 commonEventPublishData = { 891 data: "SUCCESS" 892 }; 893 } catch (err) { 894 commonEventPublishData = { 895 data: "FAILED" 896 }; 897 console.debug(TAG + '====>inputMethodAbility_test_050 hideKeyboard catch err:' + JSON.stringify(err)); 898 } 899 commoneventmanager.publish("inputMethodAbility_test_050", commonEventPublishData, this.publishCallback); 900 } 901 }); 902 } 903 904}