nyancrimew/LatinIME
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Cleanup gesture code overlay

Browse source 
Change-Id: I6ab1462f62b2d53a157494d27342a832ec1f15f7
This commit is contained in:
Satoshi Kataoka 2012-07-03 17:45:50 +09:00
parent accd63f35f
commit deb0987274
15 changed files with 100 additions and 369 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
native/jni/Android.mk
View file

@ -49,7 +49,7 @@ LATIN_IME_CORE_SRC_FILES := \
proximity_info.cpp \
proximity_info_state.cpp \
unigram_dictionary.cpp \
gesture/incremental_decoder_interface.cpp
gesture/gesture_decoder_wrapper.cpp
LOCAL_SRC_FILES := \
$(LATIN_IME_JNI_SRC_FILES) \
@ -78,49 +78,8 @@ include $(BUILD_STATIC_LIBRARY)
######################################
include $(CLEAR_VARS)
LOCAL_C_INCLUDES += $(LATIN_IME_SRC_FULLPATH_DIR) \
$(addprefix $(LATIN_IME_SRC_FULLPATH_DIR)/, gesture gesture/impl)
LOCAL_CFLAGS += -Werror -Wall
# To suppress compiler warnings for unused variables/functions used for debug features etc.
LOCAL_CFLAGS += -Wno-unused-parameter -Wno-unused-function
LATIN_IME_GESTURE_IMPL_SRC_FILES := \
gesture/impl/gesture_decoder_impl.cpp \
gesture/impl/incremental_decoder_impl.cpp \
gesture/impl/token_beam_impl.cpp \
gesture/impl/token_impl.cpp
LOCAL_SRC_FILES := $(addprefix $(LATIN_IME_SRC_DIR)/, $(LATIN_IME_GESTURE_IMPL_SRC_FILES))
ifeq ($(FLAG_DO_PROFILE), true)
$(warning Making profiling version of native library)
LOCAL_CFLAGS += -DFLAG_DO_PROFILE
else # FLAG_DO_PROFILE
ifeq ($(FLAG_DBG), true)
$(warning Making debug version of native library)
LOCAL_CFLAGS += -DFLAG_DBG
endif # FLAG_DBG
endif # FLAG_DO_PROFILE
# TODO: Can remove this static library from AOSP completely?
LOCAL_MODULE := libjni_latinime_gesture_impl_aosp_static
LOCAL_MODULE_TAGS := optional
ifdef HISTORICAL_NDK_VERSIONS_ROOT # In the platform build system
include external/stlport/libstlport.mk
else # In the NDK build system
LOCAL_C_INCLUDES += external/stlport/stlport bionic
endif
include $(BUILD_STATIC_LIBRARY)
######################################
include $(CLEAR_VARS)
# All code in LOCAL_WHOLE_STATIC_LIBRARIES will be built into this shared library.
LOCAL_WHOLE_STATIC_LIBRARIES := \
libjni_latinime_common_static libjni_latinime_gesture_impl_aosp_static
LOCAL_WHOLE_STATIC_LIBRARIES := libjni_latinime_common_static
ifdef HISTORICAL_NDK_VERSIONS_ROOT # In the platform build system
LOCAL_SHARED_LIBRARIES := libstlport

5
native/jni/src/dictionary.cpp
View file

@ -22,7 +22,7 @@
#include "binary_format.h"
#include "defines.h"
#include "dictionary.h"
#include "incremental_decoder_interface.h"
#include "gesture_decoder_wrapper.h"
namespace latinime {
@ -44,8 +44,7 @@ Dictionary::Dictionary(void *dict, int dictSize, int mmapFd, int dictBufAdjust,
mUnigramDictionary = new UnigramDictionary(mDict + headerSize, typedLetterMultiplier,
fullWordMultiplier, maxWordLength, maxWords, options);
mBigramDictionary = new BigramDictionary(mDict + headerSize, maxWordLength);
mGestureDecoder = IncrementalDecoderInterface::getGestureDecoderInstance(maxWordLength,
maxWords);
mGestureDecoder = new GestureDecoderWrapper(maxWordLength, maxWords);
mGestureDecoder->setDict(mUnigramDictionary, mBigramDictionary,
mDict + headerSize /* dict root */, 0 /* root pos */);
}

3
native/jni/src/dictionary.h
View file

@ -45,6 +45,7 @@ class Dictionary {
result = mGestureDecoder->getSuggestions(proximityInfo, xcoordinates, ycoordinates,
times, pointerIds, codes, codesSize, commitPoint,
outWords, frequencies, spaceIndices);
return result;
} else {
std::map<int, int> bigramMap;
uint8_t bigramFilter[BIGRAM_FILTER_BYTE_SIZE];
@ -53,8 +54,8 @@ class Dictionary {
result = mUnigramDictionary->getSuggestions(proximityInfo, xcoordinates,
ycoordinates, codes, codesSize, &bigramMap, bigramFilter,
useFullEditDistance, outWords, frequencies);
return result;
}
return result;
}
int getBigrams(const int32_t *word, int length, int *codes, int codesSize,

4
native/jni/src/gesture/impl/token_impl.cpp → native/jni/src/gesture/gesture_decoder_wrapper.cpp
View file

@ -14,7 +14,9 @@
* limitations under the License.
*/
#include "token_impl.h"
#include "gesture_decoder_wrapper.h"
namespace latinime {
IncrementalDecoderInterface *
(*GestureDecoderWrapper::sGestureDecoderFactoryMethod)(int, int) = 0;
} // namespace latinime

91
native/jni/src/gesture/gesture_decoder_wrapper.h Normal file
View file

@ -0,0 +1,91 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_GESTURE_DECODER_WRAPPER_H
#define LATINIME_GESTURE_DECODER_WRAPPER_H
#include <stdint.h>
#include "defines.h"
#include "incremental_decoder_interface.h"
namespace latinime {
class UnigramDictionary;
class BigramDictionary;
class ProximityInfo;
class GestureDecoderWrapper : public IncrementalDecoderInterface {
public:
GestureDecoderWrapper(const int maxWordLength, const int maxWords) {
mIncrementalDecoderInterface = getGestureDecoderInstance(maxWordLength, maxWords);
}
virtual ~GestureDecoderWrapper() {
delete mIncrementalDecoderInterface;
}
int getSuggestions(ProximityInfo *pInfo, int *inputXs, int *inputYs, int *times,
int *pointerIds, int *codes, int inputSize, int commitPoint,
unsigned short *outWords, int *frequencies, int *outputIndices) {
if (!mIncrementalDecoderInterface) {
return 0;
}
return mIncrementalDecoderInterface->getSuggestions(
pInfo, inputXs, inputYs, times, pointerIds, codes, inputSize, commitPoint,
outWords, frequencies, outputIndices);
}
void reset() {
if (!mIncrementalDecoderInterface) {
return;
}
mIncrementalDecoderInterface->reset();
}
void setDict(const UnigramDictionary *dict, const BigramDictionary *bigram,
const uint8_t *dictRoot, int rootPos) {
if (!mIncrementalDecoderInterface) {
return;
}
mIncrementalDecoderInterface->setDict(dict, bigram, dictRoot, rootPos);
}
void setPrevWord(const int32_t *prevWord, int prevWordLength) {
if (!mIncrementalDecoderInterface) {
return;
}
mIncrementalDecoderInterface->setPrevWord(prevWord, prevWordLength);
}
static void setGestureDecoderFactoryMethod(
IncrementalDecoderInterface *(*factoryMethod)(int, int)) {
sGestureDecoderFactoryMethod = factoryMethod;
}
private:
DISALLOW_COPY_AND_ASSIGN(GestureDecoderWrapper);
static IncrementalDecoderInterface *getGestureDecoderInstance(int maxWordLength, int maxWords) {
if (sGestureDecoderFactoryMethod) {
return sGestureDecoderFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static IncrementalDecoderInterface *(*sGestureDecoderFactoryMethod)(int, int);
IncrementalDecoderInterface *mIncrementalDecoderInterface;
};
} // namespace latinime
#endif // LATINIME_GESTURE_DECODER_WRAPPER_H

40
native/jni/src/gesture/impl/gesture_decoder_impl.cpp
View file

@ -1,40 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#include "gesture_decoder_impl.h"
#include "incremental_decoder_interface.h"
namespace latinime {
// A factory method for GestureDecoderImpl
static IncrementalDecoderInterface *getDecoderInstance(int maxWordLength, int maxWords) {
return new GestureDecoderImpl(maxWordLength, maxWords);
}
// An ad-hoc internal class to register the factory method defined above
class GestureDecoderFactoryRegisterer {
public:
GestureDecoderFactoryRegisterer() {
IncrementalDecoderInterface::setGestureDecoderFactoryMethod(getDecoderInstance);
}
private:
DISALLOW_COPY_AND_ASSIGN(GestureDecoderFactoryRegisterer);
};
// To invoke the GestureDecoderFactoryRegisterer constructor in the global constructor
// Not sure, but can be static?
GestureDecoderFactoryRegisterer gestureDecoderFactoryRegisterer;
} // namespace latinime

41
native/jni/src/gesture/impl/gesture_decoder_impl.h
View file

@ -1,41 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_GESTURE_DECODER_IMPL_H
#define LATINIME_GESTURE_DECODER_IMPL_H
#include "defines.h"
#include "incremental_decoder_impl.h"
namespace latinime {
class GestureDecoderImpl : public IncrementalDecoderImpl {
public:
GestureDecoderImpl(int maxWordLength, int maxWords) :
IncrementalDecoderImpl(maxWordLength, maxWords) {
}
int getSuggestions(ProximityInfo *pInfo, int *inputXs, int *inputYs, int *times,
int *pointerIds, int *codes, int inputSize, int commitPoint,
unsigned short *outWords, int *frequencies, int *outputIndices) {
return 0;
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(GestureDecoderImpl);
};
} // namespace latinime
#endif // LATINIME_GESTURE_DECODER_IMPL_H

23
native/jni/src/gesture/impl/header/nothing.h
View file

@ -1,23 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_NOTHING_H
#define LATINIME_NOTHING_H
namespace latinime {
} // namespace latinime
#endif // LATINIME_NOTHING_H

40
native/jni/src/gesture/impl/incremental_decoder_impl.cpp
View file

@ -1,40 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#include "incremental_decoder_impl.h"
#include "incremental_decoder_interface.h"
namespace latinime {
// A factory method for IncrementalDecoderImpl
static IncrementalDecoderInterface *getDecoderInstance(int maxWordLength, int maxWords) {
return new IncrementalDecoderImpl(maxWordLength, maxWords);
}
// An ad-hoc internal class to register the factory method defined above
class IncrementalDecoderFactoryRegisterer {
public:
IncrementalDecoderFactoryRegisterer() {
IncrementalDecoderInterface::setIncrementalDecoderFactoryMethod(getDecoderInstance);
}
private:
DISALLOW_COPY_AND_ASSIGN(IncrementalDecoderFactoryRegisterer);
};
// To invoke the IncrementalDecoderFactoryRegisterer constructor in the global constructor
// Not sure, but can be static?
IncrementalDecoderFactoryRegisterer incrementalDecoderFactoryRegisterer;
} // namespace latinime

46
native/jni/src/gesture/impl/incremental_decoder_impl.h
View file

@ -1,46 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_INCREMENTAL_DECODER_IMPL_H
#define LATINIME_INCREMENTAL_DECODER_IMPL_H
#include "defines.h"
#include "incremental_decoder_interface.h"
namespace latinime {
class UnigramDictionary;
class BigramDictionary;
class IncrementalDecoderImpl : public IncrementalDecoderInterface {
public:
IncrementalDecoderImpl(int maxWordLength, int maxWords) { };
void setDict(const UnigramDictionary *dict, const BigramDictionary *bigram,
const uint8_t *dictRoot, int rootPos) { };
void setPrevWord(const int32_t *prevWord, int prevWordLength) { };
void reset() { };
int getSuggestions(ProximityInfo *pInfo, int *inputXs, int *inputYs, int *times,
int *pointerIds, int *codes, int inputSize, int commitPoint,
unsigned short *outWords, int *frequencies, int *outputIndices) {
return 0;
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalDecoderImpl);
};
} // namespace latinime
#endif // LATINIME_INCREMENTAL_DECODER_IMPL_H

20
native/jni/src/gesture/impl/token_beam_impl.cpp
View file

@ -1,20 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#include "token_beam_impl.h"
namespace latinime {
} // namespace latinime

29
native/jni/src/gesture/impl/token_beam_impl.h
View file

@ -1,29 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_TOKEN_BEAM_IMPL_H
#define LATINIME_TOKEN_BEAM_IMPL_H
#include "defines.h"
namespace latinime {
class TokenBeamImpl {
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(TokenBeamImpl);
};
} // namespace latinime
#endif // LATINIME_TOKEN_BEAM_IMPL_H

29
native/jni/src/gesture/impl/token_impl.h
View file

@ -1,29 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#ifndef LATINIME_TOKEN_IMPL_H
#define LATINIME_TOKEN_IMPL_H
#include "defines.h"
namespace latinime {
struct TokenImpl {
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(TokenImpl);
};
} // namespace latinime
#endif // LATINIME_TOKEN_IMPL_H

24
native/jni/src/gesture/incremental_decoder_interface.cpp
View file

@ -1,24 +0,0 @@
/*
* Copyright (C) 2012 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.
*/
#include "incremental_decoder_interface.h"
namespace latinime {
IncrementalDecoderInterface *
(*IncrementalDecoderInterface::sGestureDecoderFactoryMethod)(int, int) = 0;
IncrementalDecoderInterface *
(*IncrementalDecoderInterface::sIncrementalDecoderFactoryMethod)(int, int) = 0;
} // namespace latinime

29
native/jni/src/gesture/incremental_decoder_interface.h
View file

@ -36,35 +36,6 @@ class IncrementalDecoderInterface {
const uint8_t *dictRoot, int rootPos) = 0;
virtual void setPrevWord(const int32_t *prevWord, int prevWordLength) = 0;
virtual ~IncrementalDecoderInterface() { };
static IncrementalDecoderInterface *getGestureDecoderInstance(int maxWordLength, int maxWords) {
if (sGestureDecoderFactoryMethod) {
return sGestureDecoderFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static IncrementalDecoderInterface *getIncrementalDecoderInstance(int maxWordLength,
int maxWords) {
if (sIncrementalDecoderFactoryMethod) {
return sIncrementalDecoderFactoryMethod(maxWordLength, maxWords);
}
return 0;
}
static void setGestureDecoderFactoryMethod(
IncrementalDecoderInterface *(*factoryMethod)(int, int)) {
sGestureDecoderFactoryMethod = factoryMethod;
}
static void setIncrementalDecoderFactoryMethod(
IncrementalDecoderInterface *(*factoryMethod)(int, int)) {
sIncrementalDecoderFactoryMethod = factoryMethod;
}
private:
static IncrementalDecoderInterface *(*sGestureDecoderFactoryMethod)(int, int);
static IncrementalDecoderInterface *(*sIncrementalDecoderFactoryMethod)(int, int);
};
} // namespace latinime
#endif // LATINIME_INCREMENTAL_DECODER_INTERFACE_H