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