接口名
|
描述
|
|---|
stopInput(callback: AsyncCallback<boolean>): void;
|
隐藏输入法，使用callback形式返回结果。参数个数为1，否则抛出异常
|
stopInput(): Promise<boolean>;
|
隐藏输入法，使用promise形式返回结果。参数个数为0，否则抛出异常
|
showSoftKeyboard(callback: AsyncCallback<void>);
|
显示软键盘，使用callback形式返回结果。参数个数为1，否则抛出异常
|
stopInput(): Promise<void>;
|
显示软键盘，使用promise形式返回结果。参数个数为0，否则抛出异常
|
hideSoftKeyboard(callback: AsyncCallback<void>);
|
隐藏软键盘，使用callback形式返回结果。参数个数为1，否则抛出异常
|
hideSoftKeyboard(): Promise<void>;
|
隐藏软键盘，使用promise形式返回结果。参数个数为0，否则抛出异常
|
##### 使用说明
```
// 导入模块
import inputmethod from '@ohos.inputmethod';
console.log('Get inputMethodController');
let inputMethodController = inputmethod.getInputMethodController();
// 隐藏输入法callback
inputMethodController.stopInput((err, result) => {
if (err == undefined) {
console.error("stopInput callback result---err: " + err.msg);
return;
}
if (result) {
console.info("Success to stopInput.(callback)");
} else {
console.info("Failed to stopInput.(callback)");
}
});
// 隐藏输入法promise
await inputMethodController.stopInput().then((result)=>{
if (result) {
console.info("Success to stopInput.(promise)");
} else {
console.info("Failed to stopInput.(promise)");
}
}).catch((err) => {
console.error("stopInput promise err: " + err.msg);
});
// 显示软键盘callback
inputMethodController.showSoftKeyboard((err) => {
if (err == undefined) {
console.error("showSoftKeyboard callback result---err: " + err.msg);
return;
}
console.info("Success to showSoftKeyboard.(callback)");
});
// 显示软键盘promise
await inputMethodController.showSoftKeyboard().then(()=>{
console.info("Success to showSoftKeyboard.(promise)");
}).catch((err) => {
console.error("showSoftKeyboard promise err: " + err.msg);
});
// 隐藏软键盘callback
inputMethodController.hideSoftKeyboard((err) => {
if (err == undefined) {
console.error("hideSoftKeyboard callback result---err: " + err.msg);
return;
}
console.info("Success to hideSoftKeyboard.(callback)");
});
// 隐藏软键盘promise
await inputMethodController.hideSoftKeyboard().then(()=>{
console.info("Success to hideSoftKeyboard.(promise)");
}).catch((err) => {
console.error("hideSoftKeyboard promise err: " + err.msg);
});
```
**表 3** InputMethodSetting开放的主要方法
接口名
|
描述
|
|---|
listInputMethod(callback: AsyncCallback<Array<InputMethodProperty>>): void;
|
查询已安装的输入法列表，使用callback形式返回结果。参数个数为1，否则抛出异常。
|
listInputMethod(): Promise<Array<InputMethodProperty>>;
|
查询已安装的输入法列表，使用promise形式返回结果。参数个数为0，否则抛出异常。
|
displayOptionalInputMethod(callback: AsyncCallback<void>): void;
|
显示输入法选择对话框，使用callback形式返回结果。参数个数为1，否则抛出异常。
|
displayOptionalInputMethod(): Promise<void>;
|
显示输入法选择对话框，使用promise形式返回结果。参数个数为0，否则抛出异常。
|
##### 使用说明
```
// 导入模块
import inputmethod from '@ohos.inputmethod';
console.log('Get inputMethodSetting');
let inputMethodSetting = inputmethod.getInputMethodSetting();
// 查询已安装的输入法列表callback
inputMethodSetting.listInputMethod((err,data) => {
if (err == undefined) {
console.error("listInputMethod callback result---err: " + err.msg);
return;
}
console.info("listInputMethod callback result---data: " + JSON.stringify(data));
});
// 查询已安装的输入法列表promise
await inputMethodSetting.listInputMethod().then((data)=>{
console.info("listInputMethod promise result---data: " + JSON.stringify(data));
}).catch((err) => {
console.info("listInputMethod promise err:" + err.msg);
});
// 显示输入法选择对话框callback
inputMethodSetting.displayOptionalInputMethod((err) => {
if (err == undefined) {
console.error("displayOptionalInputMethod callback---err: " + err.msg);
return;
}
console.info("displayOptionalInputMethod callback");
});
// 显示输入法选择对话框promise
await inputMethodSetting.displayOptionalInputMethod().then(()=>{
console.info("displayOptionalInputMethod promise");
}).catch((err) => {
console.info("listInputMethod promise err: " + err.msg);
});
```
**表 4** inputMethodEngine开放的主要方法
接口名
|
描述
|
|---|
on(type: 'keyDown'|'keyUp', callback: (event: KeyEvent) => boolean): void;
|
订阅硬键盘事件，使用callback回调返回按键信息。参数个数为2，参数1为napi_string，参数2为napi_function，否则抛出异常。
|
off(type: 'keyDown'|'keyUp', callback?: (event: KeyEvent) => boolean): void;
|
取消订阅硬键盘事件。参数个数不为1或2抛出异常，若为1，参数不为napi_string抛出异常，若为2，参数1不为napi_string，参数2不为napi_function抛出异常。参数若为1，取消此类型所有监听，参数若为2，取消此类型当前监听。
|
on(type: 'cursorContextChange', callback: (x: number, y:number, height:number) => void): void;
|
订阅光标变化事件，使用callback回调返回光标信息，使用callback回调返回按键信息。参数个数为2，参数1为napi_string，参数2为napi_function，否则抛出异常。
|
off(type: 'cursorContextChange', callback?: (x: number, y:number, height:number) => void): void;
|
取消订阅光标变化事件。参数个数不为1或2抛出异常，若为1，参数不为napi_string抛出异常，若为2，参数1不为napi_string，参数2不为napi_function抛出异常。参数若为1，取消此类型所有监听，参数若为2，取消此类型当前监听。
|
on(type: 'selectionChange', callback: (oldBegin: number, oldEnd: number, newBegin: number, newEnd: number) => void): void;
|
订阅文本选择变化事件，使用callback回调返回文本选择信息，使用callback回调返回按键信息。参数个数为2，参数1为napi_string，参数2为napi_function，否则抛出异常。
|
off(type: 'selectionChange', callback?: (oldBegin: number, oldEnd: number, newBegin: number, newEnd: number) => void): void;
|
取消订阅文本选择变化事件。参数个数不为1或2抛出异常，若为1，参数不为napi_string抛出异常，若为2，参数1不为napi_string，参数2不为napi_function抛出异常。参数若为1，取消此类型所有监听，参数若为2，取消此类型当前监听。
|
on(type: 'textChange', callback: (text: string) => void): void;
|
订阅文本变化事件，使用callback回调返回当前文本内容，使用callback回调返回按键信息。参数个数为2，参数1为napi_string，参数2为napi_function，否则抛出异常。
|
off(type: 'textChange', callback?: (text: string) => void): void;
|
取消订阅文本变化事件。参数个数不为1或2抛出异常，若为1，参数不为napi_string抛出异常，若为2，参数1不为napi_string，参数2不为napi_function抛出异常。参数若为1，取消此类型所有监听，参数若为2，取消此类型当前监听。
|
**使用说明**
```
// 导入模块
import inputmethodengine from '@ohos.inputmethodengine';
// 获取客户端监听实例
console.log('Get keyboardDelegate');
let keyboardDelegate = inputmethodengine.createKeyboardDelegate();
// 订阅硬键盘事件
keyboardDelegate.on('keyUp', (keyEvent) => {
console.info("inputMethodEngine keyCode.(keyUp):" + JSON.stringify(keyEvent.keyCode));
console.info("inputMethodEngine keyAction.(keyUp):" + JSON.stringify(keyEvent.keyAction));
return true;
});
keyboardDelegate.on('keyDown', (keyEvent) => {
console.info("inputMethodEngine keyCode.(keyDown):" + JSON.stringify(keyEvent.keyCode));
console.info("inputMethodEngine keyAction.(keyDown):" + JSON.stringify(keyEvent.keyAction));
return true;
});
// 取消订阅硬键盘事件
keyboardDelegate.off('keyUp', (keyEvent) => {
console.log("delete keyUp notification.");
return true;
});
keyboardDelegate.off('keyDown', (keyEvent) => {
console.log("delete keyDown notification.");
return true;
});
// 订阅光标变化事件
keyboardDelegate.on('cursorContextChange', (x, y, height) => {
console.log("inputMethodEngine cursorContextChange x:" + x);
console.log("inputMethodEngine cursorContextChange y:" + y);
console.log("inputMethodEngine cursorContextChange height:" + height);
});
// 取消订阅光标变化事件
keyboardDelegate.off('cursorContextChange', (x, y, height) => {
console.log("delete cursorContextChange notification.");
});
// 订阅文本选择变化事件
keyboardDelegate.on('selectionChange', (oldBegin, oldEnd, newBegin, newEnd) => {
console.log("inputMethodEngine beforeEach selectionChange oldBegin:" + oldBegin);
console.log("inputMethodEngine beforeEach selectionChange oldEnd:" + oldEnd);
console.log("inputMethodEngine beforeEach selectionChange newBegin:" + newBegin);
console.log("inputMethodEngine beforeEach selectionChange newEnd:" + newEnd);
});
// 取消订阅文本选择变化事件
keyboardDelegate.off('selectionChange', (oldBegin, oldEnd, newBegin, newEnd) => {
console.log("delete selectionChange notification.");
});
// 订阅文本变化事件
keyboardDelegate.on('textChange', (text) => {
console.log("inputMethodEngine textChange. text:" + text);
});
// 取消订阅文本变化事件
keyboardDelegate.off('textChange', (text) => {
console.log("delete textChange notification. text:" + text);
});
```
**表 7** KeyboardController开放的主要方法
接口名
|
描述
|
|---|
getForward(length:number, callback: AsyncCallback<string>): void;
|
获取光标前固定长度的文本，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
getForward(length:number): Promise<string>;
|
获取光标前固定长度的文本,使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
getBackward(length:number, callback: AsyncCallback<string>): void;
|
获取光标后固定长度的文本，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
getBackward(length:number): Promise<string>;
|
获取光标后固定长度的文本，使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
deleteForward(length:number, callback: AsyncCallback<boolean>): void;
|
删除光标前固定长度的文本，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
deleteForward(length:number): Promise<boolean>;
|
删除光标前固定长度的文本，使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
deleteBackward(length:number, callback: AsyncCallback<boolean>): void;
|
删除光标后固定长度的文本，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
deleteBackward(length:number): Promise<boolean>;
|
删除光标后固定长度的文本，使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
sendKeyFunction(action:number, callback: AsyncCallback<boolean>): void;
|
发送功能键，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
sendKeyFunction(action:number): Promise<boolean>;
|
发送功能键，使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
insertText(text:string, callback: AsyncCallback<boolean>): void;
|
插入文本，使用callback形式返回结果。参数个数为2，否侧抛出异常。
|
insertText(text:string): Promise<boolean>;
|
插入文本，使用promise形式返回结果。参数个数为1，否侧抛出异常。
|
getEditorAttribute(callback: AsyncCallback<EditorAttribute>): void;
|
获取编辑框属性值，使用callback形式返回结果。参数个数为1，否侧抛出异常。
|
getEditorAttribute(): Promise<EditorAttribute>;
|
获取编辑框属性值，使用promise形式返回结果。参数个数为0，否侧抛出异常。
|
**使用说明**
```
// 导入模块
import inputmethodengine from '@ohos.inputmethodengine';
var client = null;
var length = 1;
var keyFunction = 0;
console.log('Get inputMethodEngine');
let inputMethodEngine = inputmethodengine.getInputMethodEngine();
inputMethodEngine.on('inputStart', (kbController, textInputClient) => {
console.log("inputMethodEngine inputStart:" + JSON.stringify(textInputClient));
client = textInputClient;
});
// 获取光标前固定长度的文本callback
client.getForward(length, (err, text) => {
if (err == undefined) {
console.error("getForward callback result---err: " + err.msg);
return;
}
console.log("getForward callback result---text: " + text);
});
// 获取光标前固定长度的文本promise
await client.getForward(length).then((text) => {
console.info("getForward promise result---res: " + text);
}).catch((err) => {
console.error("getForward promise err: " + err.msg);
});
// 获取光标后固定长度的文本callback
client.getBackward(length, (err, text) => {
if (err == undefined) {
console.error("getBackward callback result---err: " + err.msg);
return;
}
console.log("getBackward callback result---text: " + text);
});
// 获取光标后固定长度的文本promise
await client.getBackward(length).then((text) => {
console.info("getBackward promise result---res: " + text);
}).catch((err) => {
console.error("getBackward promise err: " + err.msg);
});
// 删除光标前固定长度的文本callback
client.deleteForward(length, (err, result) => {
if (err == undefined) {
console.error('deleteForward callback result---err: ' + err.msg);
return;
}
if (result) {
console.info("Success to deleteForward.(callback) ");
} else {
console.error("Failed to deleteForward.(callback) ");
}
});
// 删除光标前固定长度的文本promise
await client.deleteForward(length).then((result) => {
if (result) {
console.info("Success to deleteForward.(promise) ");
} else {
console.error("Failed to deleteForward.(promise) ");
}
}).catch((err) => {
console.error("deleteForward promise err: " + err.msg);
});
// 删除光标前固定长度的文本callback
client.deleteBackward(length, (err, result) => {
if (err == undefined) {
console.error("deleteBackward callback result---err: " + err.msg);
return;
}
if (result) {
console.info("Success to deleteBackward.(callback) ");
} else {
console.error("Failed to deleteBackward.(callback) ");
}
});
// 删除光标前固定长度的文本promise
await client.deleteBackward(length).then((result) => {
if (result) {
console.info("Success to deleteBackward.(promise) ");
} else {
console.error("Failed to deleteBackward.(promise) ");
}
}).catch((err) => {
console.error("deleteBackward promise err: " + err.msg);
});
// 发送功能键callback
client.sendKeyFunction(keyFunction, (err, result) => {
if (err == undefined) {
console.error("sendKeyFunction callback result---err: " + err.msg);
return;
}
if (result) {
console.info("Success to sendKeyFunction.(callback) ");
} else {
console.error("Failed to sendKeyFunction.(callback) ");
}
});
// 发送功能键promise
await client.sendKeyFunction(keyFunction).then((result) => {
if (result) {
console.info("Success to sendKeyFunction.(promise) ");
} else {
console.error("Failed to sendKeyFunction.(promise) ");
}
}).catch((err) => {
console.error("sendKeyFunction promise err:" + err.msg);
});
// 插入文本callback
client.insertText('test', (err, result) => {
if (err == undefined) {
console.error("insertText callback result---err: " + err.msg);
return;
}
if (result) {
console.info("Success to insertText.(callback) ");
} else {
console.error("Failed to insertText.(callback) ");
}
});
// 插入文本promise
await client.insertText('test').then((result) => {
if (result) {
console.info("Success to insertText.(promise) ");
} else {
console.error("Failed to insertText.(promise) ");
}
}).catch((err) => {
console.error("insertText promise err: " + err.msg);
});
// 获取编辑框属性值callback
client.getEditorAttribute((err, editorAttribute) => {
if (err == undefined) {
console.error("getEditorAttribute callback result---err: " + err.msg);
return;
}
console.log("editorAttribute.inputPattern(callback): " + JSON.stringify(editorAttribute.inputPattern));
console.log("editorAttribute.enterKeyType(callback): " + JSON.stringify(editorAttribute.enterKeyType));
});
// 获取编辑框属性值promise
await client.getEditorAttribute().then((editorAttribute) => {
console.info("editorAttribute.inputPattern(promise): " + JSON.stringify(editorAttribute.inputPattern));
console.info("editorAttribute.enterKeyType(promise): " + JSON.stringify(editorAttribute.enterKeyType));
}).catch((err) => {
console.error("getEditorAttribute promise err: " + err.msg);
});
```
**EditorAttribute**
**编辑框属性值**
| 名称 | 参数类型 | 可读 | 可写 | 说明 |
| ------------ | -------- | ---- | ---- | ------------------ |
| enterKeyType | number | 是 | 否 | 编辑框的功能属性。 |
| inputPattern | number | 是 | 否 | 编辑框的文本属性。 |
**KeyEvent**
**按键属性值**
| 名称 | 参数类型 | 可读 | 可写 | 说明 |
| --------- | -------- | ---- | ---- | ------------ |
| keyCode | number | 是 | 否 | 按键的键值。 |
| keyAction | number | 是 | 否 | 按键的状态。 |
#### 框架主要支持功能
1.在编辑属性的控件中进行点击操作，即可通过输入法框架调起默认输入法应用
2.通过输入法应用可以进行打字，并上屏输入字符到应用客户端
#### 本框架编译调试方法
1. 编译命令
./build.sh --product-name (填写具体的产品名，如：Hi3516DV300) --build-target imf
2. 推送so文件
将工程目录下out\ohos-arm-release\inputmethod\imf 下的libinputmethod_client.z.so libinputmethod_ability.z.so
libinputmethod_service.z.so libinputmethod_para.z.so推送到system/lib，将libinputmethodengine.z.so libinputmethod.z.so 推送到system/lib/module下，并确保六个so至少为可读状态。
3. 重启设备
#### 参与贡献
1. Fork 本仓库
2. 提交代码
3. 新建 Pull Request
4. commit完成即可