src/be/nikiroo/fanfix/reader/BasicReader.java

   1 package be.nikiroo.fanfix.reader;
   2
   3 import java.io.File;
   4 import java.io.IOException;
   5 import java.net.MalformedURLException;
   6 import java.net.URL;
   7 import java.text.ParseException;
   8 import java.text.SimpleDateFormat;
   9 import java.util.Date;
  10 import java.util.Map;
  11 import java.util.TreeMap;
  12
  13 import be.nikiroo.fanfix.Instance;
  14 import be.nikiroo.fanfix.bundles.Config;
  15 import be.nikiroo.fanfix.bundles.UiConfig;
  16 import be.nikiroo.fanfix.data.MetaData;
  17 import be.nikiroo.fanfix.data.Story;
  18 import be.nikiroo.fanfix.library.BasicLibrary;
  19 import be.nikiroo.fanfix.library.LocalLibrary;
  20 import be.nikiroo.fanfix.supported.BasicSupport;
  21 import be.nikiroo.utils.Progress;
  22 import be.nikiroo.utils.StringUtils;
  23 import be.nikiroo.utils.serial.SerialUtils;
  24
  25 /**
  26  * The class that handles the different {@link Story} readers you can use.
  27  * <p>
  28  * All the readers should be accessed via {@link BasicReader#getReader()}.
  29  *
  30  * @author niki
  31  */
  32 public abstract class BasicReader implements Reader {
  33         private static BasicLibrary defaultLibrary = Instance.getLibrary();
  34         private static ReaderType defaultType = ReaderType.GUI;
  35
  36         private BasicLibrary lib;
  37         private MetaData meta;
  38         private Story story;
  39         private int chapter;
  40
  41         /**
  42          * Take the default reader type configuration from the config file.
  43          */
  44         static {
  45                 String typeString = Instance.getConfig().getString(Config.READER_TYPE);
  46                 if (typeString != null && !typeString.isEmpty()) {
  47                         try {
  48                                 ReaderType type = ReaderType.valueOf(typeString.toUpperCase());
  49                                 defaultType = type;
  50                         } catch (IllegalArgumentException e) {
  51                                 // Do nothing
  52                         }
  53                 }
  54         }
  55
  56         @Override
  57         public synchronized Story getStory(Progress pg) {
  58                 if (story == null) {
  59                         story = getLibrary().getStory(meta.getLuid(), pg);
  60                 }
  61
  62                 return story;
  63         }
  64
  65         @Override
  66         public BasicLibrary getLibrary() {
  67                 if (lib == null) {
  68                         lib = defaultLibrary;
  69                 }
  70
  71                 return lib;
  72         }
  73
  74         @Override
  75         public void setLibrary(BasicLibrary lib) {
  76                 this.lib = lib;
  77         }
  78
  79         @Override
  80         public synchronized MetaData getMeta() {
  81                 return meta;
  82         }
  83
  84         @Override
  85         public synchronized void setMeta(MetaData meta) throws IOException {
  86                 setMeta(meta == null ? null : meta.getLuid()); // must check the library
  87         }
  88
  89         @Override
  90         public synchronized void setMeta(String luid) throws IOException {
  91                 story = null;
  92                 meta = getLibrary().getInfo(luid);
  93
  94                 if (meta == null) {
  95                         throw new IOException("Cannot retrieve story from library: " + luid);
  96                 }
  97         }
  98
  99         @Override
 100         public synchronized void setMeta(URL url, Progress pg) throws IOException {
 101                 BasicSupport support = BasicSupport.getSupport(url);
 102                 if (support == null) {
 103                         throw new IOException("URL not supported: " + url.toString());
 104                 }
 105
 106                 story = support.process(pg);
 107                 if (story == null) {
 108                         throw new IOException(
 109                                         "Cannot retrieve story from external source: "
 110                                                         + url.toString());
 111                 }
 112
 113                 meta = story.getMeta();
 114         }
 115
 116         @Override
 117         public int getChapter() {
 118                 return chapter;
 119         }
 120
 121         @Override
 122         public void setChapter(int chapter) {
 123                 this.chapter = chapter;
 124         }
 125
 126         /**
 127          * Return a new {@link BasicReader} ready for use if one is configured.
 128          * <p>
 129          * Can return NULL if none are configured.
 130          *
 131          * @return a {@link BasicReader}, or NULL if none configured
 132          */
 133         public static Reader getReader() {
 134                 try {
 135                         if (defaultType != null) {
 136                                 return (Reader) SerialUtils.createObject(defaultType
 137                                                 .getTypeName());
 138                         }
 139                 } catch (Exception e) {
 140                         Instance.getTraceHandler().error(
 141                                         new Exception("Cannot create a reader of type: "
 142                                                         + defaultType + " (Not compiled in?)", e));
 143                 }
 144
 145                 return null;
 146         }
 147
 148         /**
 149          * The default {@link Reader.ReaderType} used when calling
 150          * {@link BasicReader#getReader()}.
 151          *
 152          * @return the default type
 153          */
 154         public static ReaderType getDefaultReaderType() {
 155                 return defaultType;
 156         }
 157
 158         /**
 159          * The default {@link Reader.ReaderType} used when calling
 160          * {@link BasicReader#getReader()}.
 161          *
 162          * @param defaultType
 163          *            the new default type
 164          */
 165         public static void setDefaultReaderType(ReaderType defaultType) {
 166                 BasicReader.defaultType = defaultType;
 167         }
 168
 169         /**
 170          * Change the default {@link LocalLibrary} to open with the
 171          * {@link BasicReader}s.
 172          *
 173          * @param lib
 174          *            the new {@link LocalLibrary}
 175          */
 176         public static void setDefaultLibrary(BasicLibrary lib) {
 177                 BasicReader.defaultLibrary = lib;
 178         }
 179
 180         /**
 181          * Return an {@link URL} from this {@link String}, be it a file path or an
 182          * actual {@link URL}.
 183          *
 184          * @param sourceString
 185          *            the source
 186          *
 187          * @return the corresponding {@link URL}
 188          *
 189          * @throws MalformedURLException
 190          *             if this is neither a file nor a conventional {@link URL}
 191          */
 192         public static URL getUrl(String sourceString) throws MalformedURLException {
 193                 if (sourceString == null || sourceString.isEmpty()) {
 194                         throw new MalformedURLException("Empty url");
 195                 }
 196
 197                 URL source = null;
 198                 try {
 199                         source = new URL(sourceString);
 200                 } catch (MalformedURLException e) {
 201                         File sourceFile = new File(sourceString);
 202                         source = sourceFile.toURI().toURL();
 203                 }
 204
 205                 return source;
 206         }
 207
 208         /**
 209          * Describe a {@link Story} from its {@link MetaData} and return a list of
 210          * title/value that represent this {@link Story}.
 211          *
 212          * @param meta
 213          *            the {@link MetaData} to represent
 214          *
 215          * @return the information
 216          */
 217         public static Map<String, String> getMetaDesc(MetaData meta) {
 218                 Map<String, String> metaDesc = new TreeMap<String, String>();
 219
 220                 // TODO: i18n
 221
 222                 StringBuilder tags = new StringBuilder();
 223                 for (String tag : meta.getTags()) {
 224                         if (tags.length() > 0) {
 225                                 tags.append(", ");
 226                         }
 227                         tags.append(tag);
 228                 }
 229
 230                 metaDesc.put("Author", meta.getAuthor());
 231                 metaDesc.put("Publication date", formatDate(meta.getDate()));
 232                 metaDesc.put("Published on", meta.getPublisher());
 233                 metaDesc.put("URL", meta.getUrl());
 234                 if (meta.isImageDocument()) {
 235                         metaDesc.put("Number of images", format(meta.getWords()));
 236                 } else {
 237                         metaDesc.put("Number of words", format(meta.getWords()));
 238                 }
 239                 metaDesc.put("Source", meta.getSource());
 240                 metaDesc.put("Subject", meta.getSubject());
 241                 metaDesc.put("Language", meta.getLang());
 242                 metaDesc.put("Tags", tags.toString());
 243
 244                 return metaDesc;
 245         }
 246
 247         /**
 248          * Open the {@link Story} with an external reader (the program will be
 249          * passed the main file associated with this {@link Story}).
 250          *
 251          * @param lib
 252          *            the {@link BasicLibrary} to select the {@link Story} from
 253          * @param luid
 254          *            the {@link Story} LUID
 255          * @param sync
 256          *            execute the process synchronously (wait until it is terminated
 257          *            before returning)
 258          *
 259          * @throws IOException
 260          *             in case of I/O error
 261          */
 262         @Override
 263         public void openExternal(BasicLibrary lib, String luid, boolean sync)
 264                         throws IOException {
 265                 MetaData meta = lib.getInfo(luid);
 266                 File target = lib.getFile(luid, null);
 267
 268                 openExternal(meta, target, sync);
 269         }
 270
 271         /**
 272          * Open the {@link Story} with an external reader (the program will be
 273          * passed the given target file).
 274          *
 275          * @param meta
 276          *            the {@link Story} to load
 277          * @param target
 278          *            the target {@link File}
 279          * @param sync
 280          *            execute the process synchronously (wait until it is terminated
 281          *            before returning)
 282          *
 283          * @throws IOException
 284          *             in case of I/O error
 285          */
 286         protected void openExternal(MetaData meta, File target, boolean sync)
 287                         throws IOException {
 288                 String program = null;
 289                 if (meta.isImageDocument()) {
 290                         program = Instance.getUiConfig().getString(
 291                                         UiConfig.IMAGES_DOCUMENT_READER);
 292                 } else {
 293                         program = Instance.getUiConfig().getString(
 294                                         UiConfig.NON_IMAGES_DOCUMENT_READER);
 295                 }
 296
 297                 if (program != null && program.trim().isEmpty()) {
 298                         program = null;
 299                 }
 300
 301                 start(target, program, sync);
 302         }
 303
 304         /**
 305          * Start a file and open it with the given program if given or the first
 306          * default system starter we can find.
 307          *
 308          * @param target
 309          *            the target to open
 310          * @param program
 311          *            the program to use or NULL for the default system starter
 312          * @param sync
 313          *            execute the process synchronously (wait until it is terminated
 314          *            before returning)
 315          *
 316          * @throws IOException
 317          *             in case of I/O error
 318          */
 319         protected void start(File target, String program, boolean sync)
 320                         throws IOException {
 321
 322                 Process proc = null;
 323                 if (program == null) {
 324                         boolean ok = false;
 325                         for (String starter : new String[] { "xdg-open", "open", "see",
 326                                         "start", "run" }) {
 327                                 try {
 328                                         Instance.getTraceHandler().trace(
 329                                                         "starting external program");
 330                                         proc = Runtime.getRuntime().exec(
 331                                                         new String[] { starter, target.getAbsolutePath() });
 332                                         ok = true;
 333                                         break;
 334                                 } catch (IOException e) {
 335                                 }
 336                         }
 337                         if (!ok) {
 338                                 throw new IOException("Cannot find a program to start the file");
 339                         }
 340                 } else {
 341                         Instance.getTraceHandler().trace("starting external program");
 342                         proc = Runtime.getRuntime().exec(
 343                                         new String[] { program, target.getAbsolutePath() });
 344                 }
 345
 346                 if (proc != null && sync) {
 347                         try {
 348                                 proc.waitFor();
 349                         } catch (InterruptedException e) {
 350                         }
 351                 }
 352         }
 353
 354         static private String format(long value) {
 355                 String display = "";
 356                 String suffix = "";
 357
 358                 if (value > 4000) {
 359                         value = value / 1000;
 360                         suffix = "k";
 361                 }
 362
 363                 while (value > 0) {
 364                         if (!display.isEmpty()) {
 365                                 display = "." + display;
 366                         }
 367                         display = (value % 1000) + display;
 368                         value = value / 1000;
 369                 }
 370
 371                 return display + suffix;
 372         }
 373
 374         static private String formatDate(String date) {
 375                 long ms = 0;
 376
 377                 try {
 378                         ms = StringUtils.toTime(date);
 379                 } catch (ParseException e) {
 380                 }
 381
 382                 if (ms <= 0) {
 383                         SimpleDateFormat sdf = new SimpleDateFormat(
 384                                         "yyyy-MM-dd'T'HH:mm:ssSSS");
 385                         try {
 386                                 ms = sdf.parse(date).getTime();
 387                         } catch (ParseException e) {
 388                         }
 389                 }
 390
 391                 if (ms > 0) {
 392                         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 393                         return sdf.format(new Date(ms));
 394                 }
 395
 396                 // :(
 397                 return date;
 398         }
 399 }