src/be/nikiroo/fanfix/VersionCheck.java

   1 package be.nikiroo.fanfix;
   2
   3 import java.io.BufferedReader;
   4 import java.io.IOException;
   5 import java.io.InputStream;
   6 import java.io.InputStreamReader;
   7 import java.net.URL;
   8 import java.util.ArrayList;
   9 import java.util.HashMap;
  10 import java.util.List;
  11 import java.util.Locale;
  12 import java.util.Map;
  13
  14 import be.nikiroo.utils.Version;
  15
  16 /**
  17  * Version checker: can check the current version of the program against a
  18  * remote changelog, and list the missed updates and their description.
  19  *
  20  * @author niki
  21  */
  22 public class VersionCheck {
  23         private static final String base = "https://github.com/nikiroo/fanfix/raw/master/changelog${LANG}.md";
  24
  25         private Version current;
  26         private List<Version> newer;
  27         private Map<Version, List<String>> changes;
  28
  29         /**
  30          * Create a new {@link VersionCheck}.
  31          *
  32          * @param current
  33          *            the current version of the program
  34          * @param newer
  35          *            the list of available {@link Version}s newer the current one
  36          * @param changes
  37          *            the list of changes
  38          */
  39         private VersionCheck(Version current, List<Version> newer,
  40                         Map<Version, List<String>> changes) {
  41                 this.current = current;
  42                 this.newer = newer;
  43                 this.changes = changes;
  44         }
  45
  46         /**
  47          * Check if there are more recent {@link Version}s of this program
  48          * available.
  49          *
  50          * @return TRUE if there is at least one
  51          */
  52         public boolean isNewVersionAvailable() {
  53                 return !newer.isEmpty();
  54         }
  55
  56         /**
  57          * The current {@link Version} of the program.
  58          *
  59          * @return the current {@link Version}
  60          */
  61         public Version getCurrentVersion() {
  62                 return current;
  63         }
  64
  65         /**
  66          * The list of available {@link Version}s newer than the current one.
  67          *
  68          * @return the newer {@link Version}s
  69          */
  70         public List<Version> getNewer() {
  71                 return newer;
  72         }
  73
  74         /**
  75          * The list of changes for each available {@link Version} newer than the
  76          * current one.
  77          *
  78          * @return the list of changes
  79          */
  80         public Map<Version, List<String>> getChanges() {
  81                 return changes;
  82         }
  83
  84         /**
  85          * Ignore the check result.
  86          */
  87         public void ignore() {
  88
  89         }
  90
  91         /**
  92          * Accept the information, and do not check again until the minimum wait
  93          * time has elapsed.
  94          */
  95         public void ok() {
  96                 Instance.getInstance().setVersionChecked();
  97         }
  98
  99         /**
 100          * Check if there are available {@link Version}s of this program more recent
 101          * than the current one.
 102          *
 103          * @return a {@link VersionCheck}
 104          */
 105         public static VersionCheck check() {
 106                 Version current = Version.getCurrentVersion();
 107                 List<Version> newer = new ArrayList<Version>();
 108                 Map<Version, List<String>> changes = new HashMap<Version, List<String>>();
 109
 110                 if (Instance.getInstance().isVersionCheckNeeded()) {
 111                         try {
 112                                 // Prepare the URLs according to the user's language
 113                                 Locale lang = Instance.getInstance().getTrans().getLocale();
 114                                 String fr = lang.getLanguage();
 115                                 String BE = lang.getCountry().replace(".UTF8", "");
 116                                 String urlFrBE = base.replace("${LANG}", "-" + fr + "_" + BE);
 117                                 String urlFr = base.replace("${LANG}", "-" + fr);
 118                                 String urlDefault = base.replace("${LANG}", "");
 119
 120                                 InputStream in = null;
 121                                 for (String url : new String[] { urlFrBE, urlFr, urlDefault }) {
 122                                         try {
 123                                                 in = Instance.getInstance().getCache().open(new URL(url), null, false);
 124                                                 break;
 125                                         } catch (IOException e) {
 126                                         }
 127                                 }
 128
 129                                 if (in == null) {
 130                                         throw new IOException("No changelog found");
 131                                 }
 132
 133                                 BufferedReader reader = new BufferedReader(
 134                                                 new InputStreamReader(in, "UTF-8"));
 135                                 try {
 136                                         Version version = new Version();
 137                                         for (String line = reader.readLine(); line != null; line = reader
 138                                                         .readLine()) {
 139                                                 if (line.startsWith("## Version ")) {
 140                                                         version = new Version(line.substring("## Version "
 141                                                                         .length()));
 142                                                         if (version.isNewerThan(current)) {
 143                                                                 newer.add(version);
 144                                                                 changes.put(version, new ArrayList<String>());
 145                                                         } else {
 146                                                                 version = new Version();
 147                                                         }
 148                                                 } else if (!version.isEmpty() && !newer.isEmpty()
 149                                                                 && !line.isEmpty()) {
 150                                                         List<String> ch = changes.get(newer.get(newer
 151                                                                         .size() - 1));
 152                                                         if (!ch.isEmpty() && !line.startsWith("- ")) {
 153                                                                 int i = ch.size() - 1;
 154                                                                 ch.set(i, ch.get(i) + " " + line.trim());
 155                                                         } else {
 156                                                                 ch.add(line.substring("- ".length()).trim());
 157                                                         }
 158                                                 }
 159                                         }
 160                                 } finally {
 161                                         reader.close();
 162                                 }
 163                         } catch (IOException e) {
 164                                 Instance.getInstance().getTraceHandler()
 165                                                 .error(new IOException("Cannot download latest changelist on github.com", e));
 166                         }
 167                 }
 168
 169                 return new VersionCheck(current, newer, changes);
 170         }
 171 }