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 DONE rtf: images
* rtf: underline & strikethrough * rtf: underline & strikethrough
* fb2 plugin: use java plugin first (?) * 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 ??? native fb2 plugin: underline
DONE native fb2 plugin: strikethrough DONE native fb2 plugin: strikethrough
* native fb2 plugin: cover DONE native fb2 plugin: cover
DONE native fb2 plugin: cover in text DONE native fb2 plugin: cover in text
* fb2 plugins: compare native & java * fb2 plugins: compare native & java
* java fb2 plugin: use Base64InputStream technique * java fb2 plugin: use Base64InputStream technique

21
jni/NativeFormats/JavaNativeFormatPlugin.cpp
View file

@ -20,6 +20,7 @@
#include <jni.h> #include <jni.h>
#include <AndroidUtil.h> #include <AndroidUtil.h>
#include <ZLFileImage.h>
#include "fbreader/src/bookmodel/BookModel.h" #include "fbreader/src/bookmodel/BookModel.h"
#include "fbreader/src/formats/FormatPlugin.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()); childrenNumbers.push_back(par->children().size());
referenceNumbers.push_back(contentsModel.reference(par)); referenceNumbers.push_back(contentsModel.reference(par));
} }
jintArray javaChildrenNumbers = AndroidUtil::createIntArray(env, childrenNumbers); jintArray javaChildrenNumbers = AndroidUtil::createJavaIntArray(env, childrenNumbers);
jintArray javaReferenceNumbers = AndroidUtil::createIntArray(env, referenceNumbers); jintArray javaReferenceNumbers = AndroidUtil::createJavaIntArray(env, referenceNumbers);
env->CallVoidMethod(javaModel, AndroidUtil::MID_NativeBookModel_initTOC, env->CallVoidMethod(javaModel, AndroidUtil::MID_NativeBookModel_initTOC,
javaTextModel, javaChildrenNumbers, javaReferenceNumbers); javaTextModel, javaChildrenNumbers, javaReferenceNumbers);
@ -288,5 +289,19 @@ JNIEXPORT jboolean JNICALL Java_org_geometerplus_fbreader_formats_NativeFormatPl
extern "C" extern "C"
JNIEXPORT void JNICALL Java_org_geometerplus_fbreader_formats_NativeFormatPlugin_readCoverInternal(JNIEnv* env, jobject thiz, jobject file, jobjectArray box) { 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. * 02110-1301, USA.
*/ */
#include <AndroidUtil.h>
#include <ZLImage.h> #include <ZLImage.h>
#include <ZLFile.h> #include <ZLFile.h>
@ -27,7 +29,9 @@
#include "../library/Book.h" #include "../library/Book.h"
#include "../library/Library.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(); const std::string cacheDirectory = Library::Instance().cacheDirectory();
myBookTextModel = new ZLTextPlainModel(std::string(), book->language(), 131072, cacheDirectory, "ncache"); myBookTextModel = new ZLTextPlainModel(std::string(), book->language(), 131072, cacheDirectory, "ncache");
myContentsModel = new ContentsModel(book->language(), cacheDirectory, "ncontents"); myContentsModel = new ContentsModel(book->language(), cacheDirectory, "ncontents");
@ -38,6 +42,7 @@ BookModel::BookModel(const shared_ptr<Book> book, jobject javaModel) : myBook(bo
} }
BookModel::~BookModel() { BookModel::~BookModel() {
AndroidUtil::getEnv()->DeleteGlobalRef(myJavaModel);
} }
void BookModel::setHyperlinkMatcher(shared_ptr<HyperlinkMatcher> matcher) { 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(); JNIEnv *env = AndroidUtil::getEnv();
jstring javaMimeType = AndroidUtil::createJavaString(env, fileImage.mimeType()); jobject javaImage = AndroidUtil::createJavaImage(env, (const ZLFileImage&)*image);
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()
);
jstring javaId = AndroidUtil::createJavaString(env, id); jstring javaId = AndroidUtil::createJavaString(env, id);
env->CallObjectMethod(myModel.myJavaModel, AndroidUtil::MID_NativeBookModel_addImage, javaId, javaImage); env->CallObjectMethod(myModel.myJavaModel, AndroidUtil::MID_NativeBookModel_addImage, javaId, javaImage);
env->DeleteLocalRef(javaId); env->DeleteLocalRef(javaId);
env->DeleteLocalRef(cls);
env->DeleteLocalRef(javaImage); env->DeleteLocalRef(javaImage);
env->DeleteLocalRef(javaEncoding);
env->DeleteLocalRef(javaFile);
env->DeleteLocalRef(javaMimeType);
} }
void BookReader::insertEndParagraph(ZLTextParagraph::Kind kind) { 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(), myModelReader.model().book()->file(),
"base64", "base64",
myCurrentImageStart, myCurrentImageStart,
getCurrentPosition() getCurrentPosition() - myCurrentImageStart
)); ));
} }
myCurrentImageId.clear(); myCurrentImageId.clear();

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

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

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

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

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

@ -18,6 +18,7 @@
*/ */
#include <ZLFile.h> #include <ZLFile.h>
#include <ZLFileImage.h>
#include "AndroidUtil.h" #include "AndroidUtil.h"
@ -235,7 +236,7 @@ bool AndroidUtil::init(JavaVM* jvm) {
return true; 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()); jstring javaPath = env->NewStringUTF(path.c_str());
jclass cls = env->FindClass(Class_ZLFile); jclass cls = env->FindClass(Class_ZLFile);
jobject javaFile = env->CallStaticObjectMethod(cls, SMID_ZLFile_createFileByPath, javaPath); jobject javaFile = env->CallStaticObjectMethod(cls, SMID_ZLFile_createFileByPath, javaPath);
@ -244,6 +245,26 @@ jobject AndroidUtil::createZLFile(JNIEnv *env, const std::string &path) {
return javaFile; 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) { std::string AndroidUtil::fromJavaString(JNIEnv *env, jstring from) {
if (from == 0) { if (from == 0) {
return std::string(); return std::string();
@ -281,24 +302,23 @@ std::string AndroidUtil::convertNonUtfString(const std::string &str) {
return result; 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(); size_t size = data.size();
jintArray array = env->NewIntArray(size); jintArray array = env->NewIntArray(size);
env->SetIntArrayRegion(array, 0, size, &data.front()); env->SetIntArrayRegion(array, 0, size, &data.front());
return array; 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(); size_t size = data.size();
jbyteArray array = env->NewByteArray(size); jbyteArray array = env->NewByteArray(size);
env->SetByteArrayRegion(array, 0, size, &data.front()); env->SetByteArrayRegion(array, 0, size, &data.front());
return array; 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(); size_t size = data.size();
jclass cls = env->FindClass("java/lang/String"); jclass cls = env->FindClass("java/lang/String");
// TODO: memory leak?
jobjectArray array = env->NewObjectArray(size, cls, 0); jobjectArray array = env->NewObjectArray(size, cls, 0);
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
const std::string &str = data[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(javaStr);
} }
} }
env->DeleteLocalRef(cls);
return array; return array;
} }
void AndroidUtil::throwRuntimeException(JNIEnv *env, const std::string &message) { void AndroidUtil::throwRuntimeException(JNIEnv *env, const std::string &message) {
// TODO: possible memory leak
jclass cls = env->FindClass("java/lang/RuntimeException"); jclass cls = env->FindClass("java/lang/RuntimeException");
env->ThrowNew(cls, message.c_str()); env->ThrowNew(cls, message.c_str());
} }
@ -323,7 +345,8 @@ void AndroidUtil::throwBookReadingException(const std::string &resourceId, const
cls, cls,
SMID_BookReadingException_throwForFile, SMID_BookReadingException_throwForFile,
AndroidUtil::createJavaString(env, resourceId), AndroidUtil::createJavaString(env, resourceId),
AndroidUtil::createZLFile(env, file.path()) AndroidUtil::createJavaFile(env, file.path())
); );
// TODO: possible memory leak
// TODO: clear cls & ZLFile object references // TODO: clear cls & ZLFile object references
} }

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

@ -26,6 +26,7 @@
#include <vector> #include <vector>
class ZLFile; class ZLFile;
class ZLFileImage;
class AndroidUtil { class AndroidUtil {
@ -125,14 +126,16 @@ public:
static bool init(JavaVM* jvm); static bool init(JavaVM* jvm);
static JNIEnv *getEnv(); static JNIEnv *getEnv();
static jobject createZLFile(JNIEnv *env, const std::string &path);
static std::string fromJavaString(JNIEnv *env, jstring from); static std::string fromJavaString(JNIEnv *env, jstring from);
static jstring createJavaString(JNIEnv* env, const std::string &str); static jstring createJavaString(JNIEnv* env, const std::string &str);
static std::string convertNonUtfString(const std::string &str); static std::string convertNonUtfString(const std::string &str);
static jintArray createIntArray(JNIEnv *env, const std::vector<jint> &data); static jobject createJavaFile(JNIEnv *env, const std::string &path);
static jbyteArray createByteArray(JNIEnv *env, const std::vector<jbyte> &data); static jobject createJavaImage(JNIEnv *env, const ZLFileImage &image);
static jobjectArray createStringArray(JNIEnv *env, const std::vector<std::string> &data);
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 throwRuntimeException(JNIEnv *env, const std::string &message);
static void throwBookReadingException(const std::string &resourceId, const ZLFile &file); 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) { void JavaFSDir::initJavaFile(JNIEnv *env) {
if (myJavaFile == 0) { if (myJavaFile == 0) {
jobject javaFile = AndroidUtil::createZLFile(env, path()); jobject javaFile = AndroidUtil::createJavaFile(env, path());
myJavaFile = env->NewGlobalRef(javaFile); myJavaFile = env->NewGlobalRef(javaFile);
env->DeleteLocalRef(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) { void JavaInputStream::initStream(JNIEnv *env) {
if (myJavaFile == 0) { if (myJavaFile == 0) {
jobject javaFile = AndroidUtil::createZLFile(env, myName); jobject javaFile = AndroidUtil::createJavaFile(env, myName);
myJavaFile = env->NewGlobalRef(javaFile); myJavaFile = env->NewGlobalRef(javaFile);
env->DeleteLocalRef(javaFile); env->DeleteLocalRef(javaFile);
if (myJavaFile == 0) { 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; ZLFileInfo info;
JNIEnv *env = AndroidUtil::getEnv(); JNIEnv *env = AndroidUtil::getEnv();
jobject javaFile = AndroidUtil::createZLFile(env, path); jobject javaFile = AndroidUtil::createJavaFile(env, path);
if (javaFile == 0) { if (javaFile == 0) {
return info; return info;
} }