package be.nikiroo.fanfix.reader;
+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.Date;
+import java.util.Map;
+import java.util.TreeMap;
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.supported.BasicSupport;
-import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
+import be.nikiroo.fanfix.library.BasicLibrary;
+import be.nikiroo.utils.StringUtils;
/**
- * Command line {@link Story} reader.
- * <p>
- * Will output stories to the console.
+ * The class that handles the different {@link Story} readers you can use.
*
* @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 */
- LOCAL
- }
-
- private static ReaderType defaultType = ReaderType.CLI;
- private Story story;
- private ReaderType type;
-
/**
- * Take the default reader type configuration from the config file.
+ * Return an {@link URL} from this {@link String}, be it a file path or an
+ * actual {@link URL}.
+ *
+ * @param sourceString
+ * the source
+ *
+ * @return the corresponding {@link URL}
+ *
+ * @throws MalformedURLException
+ * if this is neither a file nor a conventional {@link URL}
*/
- static {
- String typeString = Instance.getConfig().getString(Config.READER_TYPE);
- if (typeString != null && !typeString.isEmpty()) {
- try {
- ReaderType type = ReaderType.valueOf(typeString.toUpperCase());
- defaultType = type;
- } catch (IllegalArgumentException e) {
- // Do nothing
- }
+ public static URL getUrl(String sourceString) throws MalformedURLException {
+ if (sourceString == null || sourceString.isEmpty()) {
+ throw new MalformedURLException("Empty url");
}
- }
- /**
- * The type of this reader.
- *
- * @return the type
- */
- public ReaderType getType() {
- return type;
- }
+ URL source = null;
+ try {
+ source = new URL(sourceString);
+ } catch (MalformedURLException e) {
+ File sourceFile = new File(sourceString);
+ source = sourceFile.toURI().toURL();
+ }
- /**
- * The type of this reader.
- *
- * @param type
- * the new type
- */
- protected BasicReader setType(ReaderType type) {
- this.type = type;
- return this;
+ return source;
}
/**
- * Return the current {@link Story}.
+ * 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 {@link Story}
+ * @return the information
*/
- public Story getStory() {
- return story;
+ public static Map<String, String> getMetaDesc(MetaData meta) {
+ Map<String, String> metaDesc = new TreeMap<String, String>();
+
+ // TODO: i18n
+
+ StringBuilder tags = new StringBuilder();
+ for (String tag : meta.getTags()) {
+ if (tags.length() > 0) {
+ tags.append(", ");
+ }
+ tags.append(tag);
+ }
+
+ // TODO: i18n
+ metaDesc.put("Author", meta.getAuthor());
+ metaDesc.put("Publication date", formatDate(meta.getDate()));
+ metaDesc.put("Published on", meta.getPublisher());
+ metaDesc.put("URL", meta.getUrl());
+ String count = "";
+ if (meta.getWords() > 0) {
+ count = StringUtils.formatNumber(meta.getWords());
+ }
+ if (meta.isImageDocument()) {
+ metaDesc.put("Number of images", count);
+ } else {
+ metaDesc.put("Number of words", count);
+ }
+ metaDesc.put("Source", meta.getSource());
+ metaDesc.put("Subject", meta.getSubject());
+ metaDesc.put("Language", meta.getLang());
+ metaDesc.put("Tags", tags.toString());
+
+ return metaDesc;
}
/**
- * Create a new {@link BasicReader} for a {@link Story} in the
- * {@link Library} .
+ * 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} ID
+ * 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
*/
- public void setStory(String luid) throws IOException {
- story = Instance.getLibrary().getStory(luid);
- if (story == null) {
- // if the LUID is wrong and < 3, pad it to 3 chars with "0" then
- // retry (since LUIDs are %03d)
- if (luid != null && luid.length() < 3) {
- while (luid.length() < 3) {
- luid = "0" + luid;
- }
- setStory(luid);
- } else {
- throw new IOException("Cannot retrieve story from library: "
- + luid);
- }
- }
+ public void openExternal(BasicLibrary lib, String luid, boolean sync)
+ throws IOException {
+ MetaData meta = lib.getInfo(luid);
+ File target = lib.getFile(luid, null);
+
+ openExternal(meta, target, sync);
}
/**
- * Create a new {@link BasicReader} for an external {@link Story}.
+ * 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)
*
- * @param source
- * the {@link Story} {@link URL}
* @throws IOException
* in case of I/O error
*/
- public void setStory(URL source) throws IOException {
- BasicSupport support = BasicSupport.getSupport(source);
- if (support == null) {
- throw new IOException("URL not supported: " + source.toString());
+ protected void openExternal(MetaData meta, File target, boolean sync)
+ throws IOException {
+ String program = null;
+ if (meta.isImageDocument()) {
+ program = Instance.getInstance().getUiConfig().getString(UiConfig.IMAGES_DOCUMENT_READER);
+ } else {
+ program = Instance.getInstance().getUiConfig().getString(UiConfig.NON_IMAGES_DOCUMENT_READER);
}
- story = support.process(source);
- if (story == null) {
- throw new IOException(
- "Cannot retrieve story from external source: "
- + source.toString());
-
+ if (program != null && program.trim().isEmpty()) {
+ program = null;
}
+
+ start(target, program, sync);
}
/**
- * Start the {@link Story} Reading.
+ * 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 or if the {@link Story} was not
- * previously set
+ * in case of I/O error
*/
- public abstract void read() throws IOException;
+ 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.getInstance().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 {
+ Instance.getInstance().getTraceHandler().trace("starting external program");
+ proc = Runtime.getRuntime().exec(
+ new String[] { program, target.getAbsolutePath() });
+ }
- /**
- * Read the selected chapter (starting at 1).
- *
- * @param chapter
- * the chapter
- */
- public abstract void read(int chapter);
+ if (proc != null && sync) {
+ try {
+ proc.waitFor();
+ } catch (InterruptedException e) {
+ }
+ }
+ }
- /**
- * 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(SupportType type);
+ static private String formatDate(String date) {
+ long ms = 0;
- /**
- * Return a new {@link BasicReader} ready for use if one is configured.
- * <p>
- * Can return NULL if none are configured.
- *
- * @return a {@link BasicReader}, or NULL if none configured
- */
- public static BasicReader getReader() {
- if (defaultType != null) {
- switch (defaultType) {
- //case LOCAL:
- //return new LocalReader().setType(ReaderType.LOCAL);
- case CLI:
- return new CliReader().setType(ReaderType.CLI);
+ if (date != null && !date.isEmpty()) {
+ try {
+ ms = StringUtils.toTime(date);
+ } catch (ParseException e) {
}
- }
- return null;
- }
+ if (ms <= 0) {
+ SimpleDateFormat sdf = new SimpleDateFormat(
+ "yyyy-MM-dd'T'HH:mm:ssSSS");
+ try {
+ ms = sdf.parse(date).getTime();
+ } catch (ParseException e) {
+ }
+ }
- /**
- * The default {@link ReaderType} used when calling
- * {@link BasicReader#getReader()}.
- *
- * @return the default type
- */
- public static ReaderType getDefaultReaderType() {
- return defaultType;
- }
+ if (ms > 0) {
+ SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+ return sdf.format(new Date(ms));
+ }
+ }
- /**
- * The default {@link ReaderType} used when calling
- * {@link BasicReader#getReader()}.
- *
- * @param defaultType
- * the new default type
- */
- public static void setDefaultReaderType(ReaderType defaultType) {
- BasicReader.defaultType = defaultType;
+ if (date == null) {
+ date = "";
+ }
+
+ // :(
+ return date;
}
}