yetangitu/FBReaderJ
1
0
Fork 0
mirror of https://github.com/geometer/FBReaderJ.git synced 2025-10-04 02:09:35 +02:00
Code Issues Releases Wiki Activity

cover loading in fb2 native plugin

Browse source
This commit is contained in:
Nikolay Pultsin 2012-03-27 17:46:37 +01:00
parent 79a06410ae
commit 1f63a57f17
12 changed files with 88 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

4
TODO.1.4.2
View file

@ -7,10 +7,10 @@ litres: author photos
DONE rtf: images
* rtf: underline & strikethrough
* fb2 plugin: use java plugin first (?)
* native fb2 plugin: images: Base64InputStream speed optimization
DONE native fb2 plugin: images: Base64InputStream speed optimization
??? native fb2 plugin: underline
DONE native fb2 plugin: strikethrough
* native fb2 plugin: cover
DONE native fb2 plugin: cover
DONE native fb2 plugin: cover in text
* fb2 plugins: compare native & java
* java fb2 plugin: use Base64InputStream technique

21
jni/NativeFormats/JavaNativeFormatPlugin.cpp
View file

@ -20,6 +20,7 @@
#include <jni.h>
#include <AndroidUtil.h>
#include <ZLFileImage.h>
#include "fbreader/src/bookmodel/BookModel.h"
#include "fbreader/src/formats/FormatPlugin.h"
@ -226,8 +227,8 @@ static bool initTOC(JNIEnv *env, jobject javaModel, BookModel &model) {
childrenNumbers.push_back(par->children().size());
referenceNumbers.push_back(contentsModel.reference(par));
}
jintArray javaChildrenNumbers = AndroidUtil::createIntArray(env, childrenNumbers);
jintArray javaReferenceNumbers = AndroidUtil::createIntArray(env, referenceNumbers);
jintArray javaChildrenNumbers = AndroidUtil::createJavaIntArray(env, childrenNumbers);
jintArray javaReferenceNumbers = AndroidUtil::createJavaIntArray(env, referenceNumbers);
env->CallVoidMethod(javaModel, AndroidUtil::MID_NativeBookModel_initTOC,
javaTextModel, javaChildrenNumbers, javaReferenceNumbers);
@ -288,5 +289,19 @@ JNIEXPORT jboolean JNICALL Java_org_geometerplus_fbreader_formats_NativeFormatPl
extern "C"
JNIEXPORT void JNICALL Java_org_geometerplus_fbreader_formats_NativeFormatPlugin_readCoverInternal(JNIEnv* env, jobject thiz, jobject file, jobjectArray box) {
// TODO: implement
shared_ptr<FormatPlugin> plugin = findCppPlugin(env, thiz);
if (plugin.isNull()) {
return;
}
jstring javaPath = (jstring)env->CallObjectMethod(file, AndroidUtil::MID_ZLFile_getPath);
const std::string path = AndroidUtil::fromJavaString(env, javaPath);
env->DeleteLocalRef(javaPath);
shared_ptr<ZLImage> image = plugin->coverImage(ZLFile(path));
if (!image.isNull()) {
jobject javaImage = AndroidUtil::createJavaImage(env, (const ZLFileImage&)*image);
env->SetObjectArrayElement(box, 0, javaImage);
env->DeleteLocalRef(javaImage);
}
}

7
jni/NativeFormats/fbreader/src/bookmodel/BookModel.cpp
View file

@ -17,6 +17,8 @@
* 02110-1301, USA.
*/
#include <AndroidUtil.h>
#include <ZLImage.h>
#include <ZLFile.h>
@ -27,7 +29,9 @@
#include "../library/Book.h"
#include "../library/Library.h"
BookModel::BookModel(const shared_ptr<Book> book, jobject javaModel) : myBook(book), myJavaModel(javaModel) {
BookModel::BookModel(const shared_ptr<Book> book, jobject javaModel) : myBook(book) {
myJavaModel = AndroidUtil::getEnv()->NewGlobalRef(javaModel);
const std::string cacheDirectory = Library::Instance().cacheDirectory();
myBookTextModel = new ZLTextPlainModel(std::string(), book->language(), 131072, cacheDirectory, "ncache");
myContentsModel = new ContentsModel(book->language(), cacheDirectory, "ncontents");
@ -38,6 +42,7 @@ BookModel::BookModel(const shared_ptr<Book> book, jobject javaModel) : myBook(bo
}
BookModel::~BookModel() {
AndroidUtil::getEnv()->DeleteGlobalRef(myJavaModel);
}
void BookModel::setHyperlinkMatcher(shared_ptr<HyperlinkMatcher> matcher) {

15
jni/NativeFormats/fbreader/src/bookmodel/BookReader.cpp
View file

@ -202,25 +202,12 @@ void BookReader::addImage(const std::string &id, shared_ptr<const ZLImage> image
JNIEnv *env = AndroidUtil::getEnv();
jstring javaMimeType = AndroidUtil::createJavaString(env, fileImage.mimeType());
jobject javaFile = AndroidUtil::createZLFile(env, fileImage.file().path());
jstring javaEncoding = AndroidUtil::createJavaString(env, fileImage.encoding());
jclass cls = env->FindClass(AndroidUtil::Class_ZLFileImage);
jobject javaImage = env->NewObject(
cls, AndroidUtil::MID_ZLFileImage_init,
javaMimeType, javaFile, javaEncoding,
fileImage.offset(), fileImage.size()
);
jobject javaImage = AndroidUtil::createJavaImage(env, (const ZLFileImage&)*image);
jstring javaId = AndroidUtil::createJavaString(env, id);
env->CallObjectMethod(myModel.myJavaModel, AndroidUtil::MID_NativeBookModel_addImage, javaId, javaImage);
env->DeleteLocalRef(javaId);
env->DeleteLocalRef(cls);
env->DeleteLocalRef(javaImage);
env->DeleteLocalRef(javaEncoding);
env->DeleteLocalRef(javaFile);
env->DeleteLocalRef(javaMimeType);
}
void BookReader::insertEndParagraph(ZLTextParagraph::Kind kind) {

2
jni/NativeFormats/fbreader/src/formats/fb2/FB2BookReader.cpp
View file

@ -308,7 +308,7 @@ void FB2BookReader::endElementHandler(int tag) {
myModelReader.model().book()->file(),
"base64",
myCurrentImageStart,
getCurrentPosition()
getCurrentPosition() - myCurrentImageStart
));
}
myCurrentImageId.clear();

32
jni/NativeFormats/fbreader/src/formats/fb2/FB2CoverReader.cpp
View file

@ -17,9 +17,7 @@
* 02110-1301, USA.
*/
#include <ZLFile.h>
#include <ZLImage.h>
//#include <ZLBase64EncodedImage.h>
#include <ZLFileImage.h>
#include "FB2CoverReader.h"
@ -30,8 +28,12 @@ FB2CoverReader::FB2CoverReader(const ZLFile &file) : myFile(file) {
shared_ptr<ZLImage> FB2CoverReader::readCover() {
myReadCoverPage = false;
myImageReference.erase();
myLookForImage = false;
myImageId.erase();
myImageStart = -1;
readDocument(myFile);
return myImage;
}
@ -45,7 +47,7 @@ void FB2CoverReader::startElementHandler(int tag, const char **attributes) {
const std::string hrefName = xlinkNamespace() + ":href";
const char *ref = attributeValue(attributes, hrefName.c_str());
if (ref != 0 && *ref == '#' && *(ref + 1) != '\0') {
myImageReference = ref + 1;
myImageId = ref + 1;
}
}
break;
@ -53,8 +55,8 @@ void FB2CoverReader::startElementHandler(int tag, const char **attributes) {
{
const char *id = attributeValue(attributes, "id");
const char *contentType = attributeValue(attributes, "content-type");
if (id != 0 && contentType != 0 && myImageReference == id) {
//myImage = new ZLBase64EncodedImage(contentType);
if (id != 0 && contentType != 0 && myImageId == id) {
myLookForImage = true;
}
}
}
@ -66,18 +68,13 @@ void FB2CoverReader::endElementHandler(int tag) {
myReadCoverPage = false;
break;
case _DESCRIPTION:
if (myImageReference.empty()) {
if (myImageId.empty()) {
interrupt();
}
break;
case _BINARY:
if (!myImage.isNull()) {
if (!myImageBuffer.empty()) {
//((ZLBase64EncodedImage&)*myImage).addData(myImageBuffer);
myImageBuffer.clear();
} else {
myImage = 0;
}
if (!myImageId.empty() && myImageStart >= 0) {
myImage = new ZLFileImage(myFile, "base64", myImageStart, getCurrentPosition() - myImageStart);
interrupt();
}
break;
@ -85,7 +82,8 @@ void FB2CoverReader::endElementHandler(int tag) {
}
void FB2CoverReader::characterDataHandler(const char *text, size_t len) {
if (len > 0 && !myImage.isNull()) {
myImageBuffer.push_back(std::string(text, len));
if (len > 0 && myLookForImage) {
myImageStart = getCurrentPosition();
myLookForImage = false;
}
}

12
jni/NativeFormats/fbreader/src/formats/fb2/FB2CoverReader.h
View file

@ -20,11 +20,10 @@
#ifndef __FB2COVERREADER_H__
#define __FB2COVERREADER_H__
#include "FB2Reader.h"
#include <ZLFile.h>
#include <ZLImage.h>
class Book;
class ZLFile;
class ZLImage;
#include "FB2Reader.h"
class FB2CoverReader : public FB2Reader {
@ -40,9 +39,10 @@ private:
private:
const ZLFile myFile;
bool myReadCoverPage;
std::string myImageReference;
bool myLookForImage;
std::string myImageId;
int myImageStart;
shared_ptr<ZLImage> myImage;
std::vector<std::string> myImageBuffer;
};
#endif /* __FB2COVERREADER_H__ */

35
jni/NativeFormats/util/AndroidUtil.cpp
View file

@ -18,6 +18,7 @@
*/
#include <ZLFile.h>
#include <ZLFileImage.h>
#include "AndroidUtil.h"
@ -235,7 +236,7 @@ bool AndroidUtil::init(JavaVM* jvm) {
return true;
}
jobject AndroidUtil::createZLFile(JNIEnv *env, const std::string &path) {
jobject AndroidUtil::createJavaFile(JNIEnv *env, const std::string &path) {
jstring javaPath = env->NewStringUTF(path.c_str());
jclass cls = env->FindClass(Class_ZLFile);
jobject javaFile = env->CallStaticObjectMethod(cls, SMID_ZLFile_createFileByPath, javaPath);
@ -244,6 +245,26 @@ jobject AndroidUtil::createZLFile(JNIEnv *env, const std::string &path) {
return javaFile;
}
jobject AndroidUtil::createJavaImage(JNIEnv *env, const ZLFileImage &image) {
jstring javaMimeType = createJavaString(env, image.mimeType());
jobject javaFile = createJavaFile(env, image.file().path());
jstring javaEncoding = createJavaString(env, image.encoding());
jclass cls = env->FindClass(Class_ZLFileImage);
jobject javaImage = env->NewObject(
cls, MID_ZLFileImage_init,
javaMimeType, javaFile, javaEncoding,
image.offset(), image.size()
);
env->DeleteLocalRef(cls);
env->DeleteLocalRef(javaEncoding);
env->DeleteLocalRef(javaFile);
env->DeleteLocalRef(javaMimeType);
return javaImage;
}
std::string AndroidUtil::fromJavaString(JNIEnv *env, jstring from) {
if (from == 0) {
return std::string();
@ -281,24 +302,23 @@ std::string AndroidUtil::convertNonUtfString(const std::string &str) {
return result;
}
jintArray AndroidUtil::createIntArray(JNIEnv *env, const std::vector<jint> &data) {
jintArray AndroidUtil::createJavaIntArray(JNIEnv *env, const std::vector<jint> &data) {
size_t size = data.size();
jintArray array = env->NewIntArray(size);
env->SetIntArrayRegion(array, 0, size, &data.front());
return array;
}
jbyteArray AndroidUtil::createByteArray(JNIEnv *env, const std::vector<jbyte> &data) {
jbyteArray AndroidUtil::createJavaByteArray(JNIEnv *env, const std::vector<jbyte> &data) {
size_t size = data.size();
jbyteArray array = env->NewByteArray(size);
env->SetByteArrayRegion(array, 0, size, &data.front());
return array;
}
jobjectArray AndroidUtil::createStringArray(JNIEnv *env, const std::vector<std::string> &data) {
jobjectArray AndroidUtil::createJavaStringArray(JNIEnv *env, const std::vector<std::string> &data) {
size_t size = data.size();
jclass cls = env->FindClass("java/lang/String");
// TODO: memory leak?
jobjectArray array = env->NewObjectArray(size, cls, 0);
for (size_t i = 0; i < size; ++i) {
const std::string &str = data[i];
@ -308,10 +328,12 @@ jobjectArray AndroidUtil::createStringArray(JNIEnv *env, const std::vector<std::
env->DeleteLocalRef(javaStr);
}
}
env->DeleteLocalRef(cls);
return array;
}
void AndroidUtil::throwRuntimeException(JNIEnv *env, const std::string &message) {
// TODO: possible memory leak
jclass cls = env->FindClass("java/lang/RuntimeException");
env->ThrowNew(cls, message.c_str());
}
@ -323,7 +345,8 @@ void AndroidUtil::throwBookReadingException(const std::string &resourceId, const
cls,
SMID_BookReadingException_throwForFile,
AndroidUtil::createJavaString(env, resourceId),
AndroidUtil::createZLFile(env, file.path())
AndroidUtil::createJavaFile(env, file.path())
);
// TODO: possible memory leak
// TODO: clear cls & ZLFile object references
}

11
jni/NativeFormats/util/AndroidUtil.h
View file

@ -26,6 +26,7 @@
#include <vector>
class ZLFile;
class ZLFileImage;
class AndroidUtil {
@ -125,14 +126,16 @@ public:
static bool init(JavaVM* jvm);
static JNIEnv *getEnv();
static jobject createZLFile(JNIEnv *env, const std::string &path);
static std::string fromJavaString(JNIEnv *env, jstring from);
static jstring createJavaString(JNIEnv* env, const std::string &str);
static std::string convertNonUtfString(const std::string &str);
static jintArray createIntArray(JNIEnv *env, const std::vector<jint> &data);
static jbyteArray createByteArray(JNIEnv *env, const std::vector<jbyte> &data);
static jobjectArray createStringArray(JNIEnv *env, const std::vector<std::string> &data);
static jobject createJavaFile(JNIEnv *env, const std::string &path);
static jobject createJavaImage(JNIEnv *env, const ZLFileImage &image);
static jintArray createJavaIntArray(JNIEnv *env, const std::vector<jint> &data);
static jbyteArray createJavaByteArray(JNIEnv *env, const std::vector<jbyte> &data);
static jobjectArray createJavaStringArray(JNIEnv *env, const std::vector<std::string> &data);
static void throwRuntimeException(JNIEnv *env, const std::string &message);
static void throwBookReadingException(const std::string &resourceId, const ZLFile &file);

2
jni/NativeFormats/zlibrary/ui/src/android/filesystem/JavaFSDir.cpp
View file

@ -35,7 +35,7 @@ JavaFSDir::~JavaFSDir() {
void JavaFSDir::initJavaFile(JNIEnv *env) {
if (myJavaFile == 0) {
jobject javaFile = AndroidUtil::createZLFile(env, path());
jobject javaFile = AndroidUtil::createJavaFile(env, path());
myJavaFile = env->NewGlobalRef(javaFile);
env->DeleteLocalRef(javaFile);
}

2
jni/NativeFormats/zlibrary/ui/src/android/filesystem/JavaInputStream.cpp
View file

@ -44,7 +44,7 @@ JavaInputStream::~JavaInputStream() {
void JavaInputStream::initStream(JNIEnv *env) {
if (myJavaFile == 0) {
jobject javaFile = AndroidUtil::createZLFile(env, myName);
jobject javaFile = AndroidUtil::createJavaFile(env, myName);
myJavaFile = env->NewGlobalRef(javaFile);
env->DeleteLocalRef(javaFile);
if (myJavaFile == 0) {

2
jni/NativeFormats/zlibrary/ui/src/android/filesystem/ZLAndroidFSManager.cpp
View file

@ -84,7 +84,7 @@ ZLFileInfo ZLAndroidFSManager::fileInfo(const std::string &path) const {
ZLFileInfo info;
JNIEnv *env = AndroidUtil::getEnv();
jobject javaFile = AndroidUtil::createZLFile(env, path);
jobject javaFile = AndroidUtil::createJavaFile(env, path);
if (javaFile == 0) {
return info;
}