/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.inputmethod.pinyin;
import com.android.inputmethod.pinyin.IPinyinDecoderService;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;
import java.util.Vector;
import android.app.Service;
import android.content.Intent;
import android.content.res.AssetFileDescriptor;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
/**
* This class is used to separate the input method kernel in an individual
* service so that both IME and IME-syncer can use it.
*/
public class PinyinDecoderService extends Service {
native static boolean nativeImOpenDecoder(byte fn_sys_dict[],
byte fn_usr_dict[]);
native static boolean nativeImOpenDecoderFd(FileDescriptor fd,
long startOffset, long length, byte fn_usr_dict[]);
native static void nativeImSetMaxLens(int maxSpsLen, int maxHzsLen);
native static boolean nativeImCloseDecoder();
native static int nativeImSearch(byte pyBuf[], int pyLen);
native static int nativeImDelSearch(int pos, boolean is_pos_in_splid,
boolean clear_fixed_this_step);
native static void nativeImResetSearch();
native static int nativeImAddLetter(byte ch);
native static String nativeImGetPyStr(boolean decoded);
native static int nativeImGetPyStrLen(boolean decoded);
native static int[] nativeImGetSplStart();
native static String nativeImGetChoice(int choiceId);
native static int nativeImChoose(int choiceId);
native static int nativeImCancelLastChoice();
native static int nativeImGetFixedLen();
native static boolean nativeImCancelInput();
native static boolean nativeImFlushCache();
native static int nativeImGetPredictsNum(String fixedStr);
native static String nativeImGetPredictItem(int predictNo);
// Sync related
native static String nativeSyncUserDict(byte[] user_dict, String tomerge);
native static boolean nativeSyncBegin(byte[] user_dict);
native static boolean nativeSyncFinish();
native static String nativeSyncGetLemmas();
native static int nativeSyncPutLemmas(String tomerge);
native static int nativeSyncGetLastCount();
native static int nativeSyncGetTotalCount();
native static boolean nativeSyncClearLastGot();
native static int nativeSyncGetCapacity();
private final static int MAX_PATH_FILE_LENGTH = 100;
private static boolean inited = false;
private String mUsr_dict_file;
static {
try {
System.loadLibrary("jni_pinyinime");
} catch (UnsatisfiedLinkError ule) {
Log.e("PinyinDecoderService",
"WARNING: Could not load jni_pinyinime natives");
}
}
// Get file name of the specified dictionary
private boolean getUsrDictFileName(byte usr_dict[]) {
if (null == usr_dict) {
return false;
}
for (int i = 0; i < mUsr_dict_file.length(); i++)
usr_dict[i] = (byte) mUsr_dict_file.charAt(i);
usr_dict[mUsr_dict_file.length()] = 0;
return true;
}
private void initPinyinEngine() {
byte usr_dict[];
usr_dict = new byte[MAX_PATH_FILE_LENGTH];
// Here is how we open a built-in dictionary for access through
// a file descriptor...
AssetFileDescriptor afd = getResources().openRawResourceFd(
R.raw.dict_pinyin);
if (Environment.getInstance().needDebug()) {
Log
.i("foo", "Dict: start=" + afd.getStartOffset()
+ ", length=" + afd.getLength() + ", fd="
+ afd.getParcelFileDescriptor());
}
if (getUsrDictFileName(usr_dict)) {
inited = nativeImOpenDecoderFd(afd.getFileDescriptor(), afd
.getStartOffset(), afd.getLength(), usr_dict);
}
try {
afd.close();
} catch (IOException e) {
}
}
@Override
public void onCreate() {
super.onCreate();
mUsr_dict_file = getFileStreamPath("usr_dict.dat").getPath();
// This is a hack to make sure our "files" directory has been
// created.
try {
openFileOutput("dummy", 0).close();
} catch (FileNotFoundException e) {
} catch (IOException e) {
}
initPinyinEngine();
}
@Override
public void onDestroy() {
nativeImCloseDecoder();
inited = false;
super.onDestroy();
}
private final IPinyinDecoderService.Stub mBinder = new IPinyinDecoderService.Stub() {
public int getInt() {
return 12345;
}
public void setMaxLens(int maxSpsLen, int maxHzsLen) {
nativeImSetMaxLens(maxSpsLen, maxHzsLen);
}
public int imSearch(byte[] pyBuf, int pyLen) {
return nativeImSearch(pyBuf, pyLen);
}
public int imDelSearch(int pos, boolean is_pos_in_splid,
boolean clear_fixed_this_step) {
return nativeImDelSearch(pos, is_pos_in_splid,
clear_fixed_this_step);
}
public void imResetSearch() {
nativeImResetSearch();
}
public int imAddLetter(byte ch) {
return nativeImAddLetter(ch);
}
public String imGetPyStr(boolean decoded) {
return nativeImGetPyStr(decoded);
}
public int imGetPyStrLen(boolean decoded) {
return nativeImGetPyStrLen(decoded);
}
public int[] imGetSplStart() {
return nativeImGetSplStart();
}
public String imGetChoice(int choiceId) {
return nativeImGetChoice(choiceId);
}
public String imGetChoices(int choicesNum) {
String retStr = null;
for (int i = 0; i < choicesNum; i++) {
if (null == retStr)
retStr = nativeImGetChoice(i);
else
retStr += " " + nativeImGetChoice(i);
}
return retStr;
}
public List<String> imGetChoiceList(int choicesStart, int choicesNum,
int sentFixedLen) {
Vector<String> choiceList = new Vector<String>();
for (int i = choicesStart; i < choicesStart + choicesNum; i++) {
String retStr = nativeImGetChoice(i);
if (0 == i) retStr = retStr.substring(sentFixedLen);
choiceList.add(retStr);
}
return choiceList;
}
public int imChoose(int choiceId) {
return nativeImChoose(choiceId);
}
public int imCancelLastChoice() {
return nativeImCancelLastChoice();
}
public int imGetFixedLen() {
return nativeImGetFixedLen();
}
public boolean imCancelInput() {
return nativeImCancelInput();
}
public void imFlushCache() {
nativeImFlushCache();
}
public int imGetPredictsNum(String fixedStr) {
return nativeImGetPredictsNum(fixedStr);
}
public String imGetPredictItem(int predictNo) {
return nativeImGetPredictItem(predictNo);
}
public List<String> imGetPredictList(int predictsStart, int predictsNum) {
Vector<String> predictList = new Vector<String>();
for (int i = predictsStart; i < predictsStart + predictsNum; i++) {
predictList.add(nativeImGetPredictItem(i));
}
return predictList;
}
public String syncUserDict(String tomerge) {
byte usr_dict[];
usr_dict = new byte[MAX_PATH_FILE_LENGTH];
if (getUsrDictFileName(usr_dict)) {
return nativeSyncUserDict(usr_dict, tomerge);
}
return null;
}
public boolean syncBegin() {
byte usr_dict[];
usr_dict = new byte[MAX_PATH_FILE_LENGTH];
if (getUsrDictFileName(usr_dict)) {
return nativeSyncBegin(usr_dict);
}
return false;
}
public void syncFinish() {
nativeSyncFinish();
}
public int syncPutLemmas(String tomerge) {
return nativeSyncPutLemmas(tomerge);
}
public String syncGetLemmas() {
return nativeSyncGetLemmas();
}
public int syncGetLastCount() {
return nativeSyncGetLastCount();
}
public int syncGetTotalCount() {
return nativeSyncGetTotalCount();
}
public void syncClearLastGot() {
nativeSyncClearLastGot();
}
public int imSyncGetCapacity() {
return nativeSyncGetCapacity();
}
};
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
}
|
