package be.nikiroo.fanfix.reader;
-import java.awt.Desktop;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map.Entry;
import be.nikiroo.fanfix.Instance;
-import be.nikiroo.fanfix.Library;
import be.nikiroo.fanfix.bundles.Config;
import be.nikiroo.fanfix.bundles.UiConfig;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Story;
+import be.nikiroo.fanfix.library.BasicLibrary;
+import be.nikiroo.fanfix.library.LocalLibrary;
import be.nikiroo.fanfix.supported.BasicSupport;
import be.nikiroo.utils.Progress;
-import be.nikiroo.utils.ui.UIUtils;
+import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.serial.SerialUtils;
/**
*
* @author niki
*/
-public abstract class BasicReader {
- public enum ReaderType {
- /** Simple reader that outputs everything on the console */
- CLI,
- /** Reader that starts local programs to handle the stories */
- GUI,
- /** A text (UTF-8) reader with menu and text windows */
- TUI,
-
- ;
-
- public String getTypeName() {
- String pkg = "be.nikiroo.fanfix.reader.";
- switch (this) {
- case CLI: return pkg + "CliReader";
- case TUI: return pkg + "TuiReader";
- case GUI: return pkg + "LocalReader";
- }
-
- return null;
- }
- }
-
+public abstract class BasicReader implements Reader {
+ private static BasicLibrary defaultLibrary = Instance.getLibrary();
private static ReaderType defaultType = ReaderType.GUI;
+
+ private BasicLibrary lib;
+ private MetaData meta;
private Story story;
- private ReaderType type;
+ private int chapter;
/**
* Take the default reader type configuration from the config file.
}
}
- /**
- * The type of this reader.
- *
- * @return the type
- */
- public ReaderType getType() {
- return type;
+ @Override
+ public synchronized Story getStory(Progress pg) {
+ if (story == null) {
+ story = getLibrary().getStory(meta.getLuid(), pg);
+ }
+
+ return story;
}
- /**
- * The type of this reader.
- *
- * @param type
- * the new type
- */
- protected BasicReader setType(ReaderType type) {
- this.type = type;
- return this;
+ @Override
+ public BasicLibrary getLibrary() {
+ if (lib == null) {
+ lib = defaultLibrary;
+ }
+
+ return lib;
}
- /**
- * Return the current {@link Story}.
- *
- * @return the {@link Story}
- */
- public Story getStory() {
- return story;
+ @Override
+ public void setLibrary(BasicLibrary lib) {
+ this.lib = lib;
}
- /**
- * Create a new {@link BasicReader} for a {@link Story} in the
- * {@link Library} .
- *
- * @param luid
- * the {@link Story} ID
- * @param pg
- * the optional progress reporter
- *
- * @throws IOException
- * in case of I/O error
- */
- public void setStory(String luid, Progress pg) throws IOException {
- story = Instance.getLibrary().getStory(luid, pg);
- if (story == null) {
+ @Override
+ public synchronized MetaData getMeta() {
+ return meta;
+ }
+
+ @Override
+ public synchronized void setMeta(MetaData meta) throws IOException {
+ setMeta(meta == null ? null : meta.getLuid()); // must check the library
+ }
+
+ @Override
+ public synchronized void setMeta(String luid) throws IOException {
+ story = null;
+ meta = getLibrary().getInfo(luid);
+
+ if (meta == null) {
throw new IOException("Cannot retrieve story from library: " + luid);
}
}
- /**
- * Create a new {@link BasicReader} for an external {@link Story}.
- *
- * @param source
- * the {@link Story} {@link URL}
- * @param pg
- * the optional progress reporter
- *
- * @throws IOException
- * in case of I/O error
- */
- public void setStory(URL source, Progress pg) throws IOException {
- BasicSupport support = BasicSupport.getSupport(source);
+ @Override
+ public synchronized void setMeta(URL url, Progress pg) throws IOException {
+ BasicSupport support = BasicSupport.getSupport(url);
if (support == null) {
- throw new IOException("URL not supported: " + source.toString());
+ throw new IOException("URL not supported: " + url.toString());
}
- story = support.process(source, pg);
+ story = support.process(pg);
if (story == null) {
throw new IOException(
"Cannot retrieve story from external source: "
- + source.toString());
-
+ + url.toString());
}
- }
- /**
- * Start the {@link Story} Reading.
- *
- * @throws IOException
- * in case of I/O error or if the {@link Story} was not
- * previously set
- */
- public abstract void read() throws IOException;
+ meta = story.getMeta();
+ }
- /**
- * Read the selected chapter (starting at 1).
- *
- * @param chapter
- * the chapter
- *
- * @throws IOException
- * in case of I/O error or if the {@link Story} was not
- * previously set
- */
- public abstract void read(int chapter) throws IOException;
+ @Override
+ public int getChapter() {
+ return chapter;
+ }
- /**
- * Start the reader in browse mode for the given type (or pass NULL for all
- * types).
- *
- * @param type
- * the type of {@link Story} to take into account, or NULL for
- * all
- */
- public abstract void start(String type);
+ @Override
+ public void setChapter(int chapter) {
+ this.chapter = chapter;
+ }
/**
* Return a new {@link BasicReader} ready for use if one is configured.
*
* @return a {@link BasicReader}, or NULL if none configured
*/
- public static BasicReader getReader() {
+ public static Reader getReader() {
try {
if (defaultType != null) {
- return ((BasicReader)SerialUtils.createObject
- (defaultType.getTypeName())).setType(defaultType);
+ return (Reader) SerialUtils.createObject(defaultType
+ .getTypeName());
}
} catch (Exception e) {
- Instance.syserr(new Exception("Cannot create a reader of type: "
- + defaultType + " (Not compiled in?)", e));
+ Instance.getTraceHandler().error(
+ new Exception("Cannot create a reader of type: "
+ + defaultType + " (Not compiled in?)", e));
}
return null;
}
/**
- * The default {@link ReaderType} used when calling
+ * The default {@link Reader.ReaderType} used when calling
* {@link BasicReader#getReader()}.
*
* @return the default type
}
/**
- * The default {@link ReaderType} used when calling
+ * The default {@link Reader.ReaderType} used when calling
* {@link BasicReader#getReader()}.
*
* @param defaultType
BasicReader.defaultType = defaultType;
}
+ /**
+ * Change the default {@link LocalLibrary} to open with the
+ * {@link BasicReader}s.
+ *
+ * @param lib
+ * the new {@link LocalLibrary}
+ */
+ public static void setDefaultLibrary(BasicLibrary lib) {
+ BasicReader.defaultLibrary = lib;
+ }
+
/**
* Return an {@link URL} from this {@link String}, be it a file path or an
* actual {@link URL}.
return source;
}
- // open with external player the related file
- public static void open(String luid) throws IOException {
- MetaData meta = Instance.getLibrary().getInfo(luid);
- File target = Instance.getLibrary().getFile(luid);
+ /**
+ * Describe a {@link Story} from its {@link MetaData} and return a list of
+ * title/value that represent this {@link Story}.
+ *
+ * @param meta
+ * the {@link MetaData} to represent
+ *
+ * @return the information
+ */
+ public static List<Entry<String, String>> getMetaDesc(MetaData meta) {
+ List<Entry<String, String>> metaDesc = new ArrayList<Entry<String, String>>();
+
+ // TODO: i18n
+
+ StringBuilder tags = new StringBuilder();
+ for (String tag : meta.getTags()) {
+ if (tags.length() > 0) {
+ tags.append(", ");
+ }
+ tags.append(tag);
+ }
+
+ metaDesc.add(new SimpleEntry<String, String>("Author", meta.getAuthor()));
+ metaDesc.add(new SimpleEntry<String, String>("Publication date",
+ formatDate(meta.getDate())));
+ metaDesc.add(new SimpleEntry<String, String>("Published on", meta
+ .getPublisher()));
+ metaDesc.add(new SimpleEntry<String, String>("URL", meta.getUrl()));
+ metaDesc.add(new SimpleEntry<String, String>("Word count", format(meta
+ .getWords())));
+ metaDesc.add(new SimpleEntry<String, String>("Source", meta.getSource()));
+ metaDesc.add(new SimpleEntry<String, String>("Subject", meta
+ .getSubject()));
+ metaDesc.add(new SimpleEntry<String, String>("Language", meta.getLang()));
+ metaDesc.add(new SimpleEntry<String, String>("Tags", tags.toString()));
+
+ return metaDesc;
+ }
+
+ /**
+ * Open the {@link Story} with an external reader (the program will be
+ * passed the main file associated with this {@link Story}).
+ *
+ * @param lib
+ * the {@link BasicLibrary} to select the {@link Story} from
+ * @param luid
+ * the {@link Story} LUID
+ * @param sync
+ * execute the process synchronously (wait until it is terminated
+ * before returning)
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ @Override
+ public void openExternal(BasicLibrary lib, String luid, boolean sync)
+ throws IOException {
+ MetaData meta = lib.getInfo(luid);
+ File target = lib.getFile(luid, null);
- open(meta, target);
+ openExternal(meta, target, sync);
}
- // open with external player the related file
- protected static void open(MetaData meta, File target) throws IOException {
+ /**
+ * Open the {@link Story} with an external reader (the program will be
+ * passed the given target file).
+ *
+ * @param meta
+ * the {@link Story} to load
+ * @param target
+ * the target {@link File}
+ * @param sync
+ * execute the process synchronously (wait until it is terminated
+ * before returning)
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ protected void openExternal(MetaData meta, File target, boolean sync)
+ throws IOException {
String program = null;
if (meta.isImageDocument()) {
program = Instance.getUiConfig().getString(
program = null;
}
- if (program == null) {
- try {
- Desktop.getDesktop().browse(target.toURI());
- } catch (UnsupportedOperationException e) {
- Runtime.getRuntime().exec(
- new String[] { "xdg-open", target.getAbsolutePath() });
+ start(target, program, sync);
+ }
+ /**
+ * Start a file and open it with the given program if given or the first
+ * default system starter we can find.
+ *
+ * @param target
+ * the target to open
+ * @param program
+ * the program to use or NULL for the default system starter
+ * @param sync
+ * execute the process synchronously (wait until it is terminated
+ * before returning)
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ protected void start(File target, String program, boolean sync)
+ throws IOException {
+
+ Process proc = null;
+ if (program == null) {
+ boolean ok = false;
+ for (String starter : new String[] { "xdg-open", "open", "see",
+ "start", "run" }) {
+ try {
+ Instance.getTraceHandler().trace(
+ "starting external program");
+ proc = Runtime.getRuntime().exec(
+ new String[] { starter, target.getAbsolutePath() });
+ ok = true;
+ break;
+ } catch (IOException e) {
+ }
+ }
+ if (!ok) {
+ throw new IOException("Cannot find a program to start the file");
}
} else {
- Runtime.getRuntime().exec(
+ Instance.getTraceHandler().trace("starting external program");
+ proc = Runtime.getRuntime().exec(
new String[] { program, target.getAbsolutePath() });
}
+
+ if (proc != null && sync) {
+ while (proc.isAlive()) {
+ try {
+ Thread.sleep(100);
+ } catch (InterruptedException e) {
+ }
+ }
+ }
+ }
+
+ static private String format(long value) {
+ String display = "";
+
+ while (value > 0) {
+ if (!display.isEmpty()) {
+ display = "." + display;
+ }
+ display = (value % 1000) + display;
+ value = value / 1000;
+ }
+
+ return display;
+ }
+
+ static private String formatDate(String date) {
+ long ms = 0;
+
+ try {
+ ms = StringUtils.toTime(date);
+ } catch (ParseException e) {
+ }
+
+ if (ms <= 0) {
+ SimpleDateFormat sdf = new SimpleDateFormat(
+ "yyyy-MM-dd'T'HH:mm:ssXXX");
+ try {
+ ms = sdf.parse(date).getTime();
+ } catch (ParseException e) {
+ }
+ }
+
+ if (ms > 0) {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ return sdf.format(new Date(ms));
+ }
+
+ // :(
+ return date;
}
}