[nikiroo-utils.git] / src / be / nikiroo / fanfix / supported / BasicSupport.java

package be.nikiroo.fanfix.supported;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.jsoup.helper.DataUtil;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.bundles.StringId;
import be.nikiroo.fanfix.data.Chapter;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.utils.Progress;
import be.nikiroo.utils.StringUtils;

/**
 * This class is the base class used by the other support classes. It can be
 * used outside of this package, and have static method that you can use to get
 * access to the correct support class.
 * <p>
 * It will be used with 'resources' (usually web pages or files).
 * 
 * @author niki
 */
public abstract class BasicSupport {
	private Document sourceNode;
	private URL source;
	private SupportType type;
	private URL currentReferer; // with only one 'r', as in 'HTTP'...

	/**
	 * The name of this support class.
	 * 
	 * @return the name
	 */
	protected abstract String getSourceName();

	/**
	 * Check if the given resource is supported by this {@link BasicSupport}.
	 * 
	 * @param url
	 *            the resource to check for
	 * 
	 * @return TRUE if it is
	 */
	protected abstract boolean supports(URL url);

	/**
	 * Return TRUE if the support will return HTML encoded content values for
	 * the chapters content.
	 * 
	 * @return TRUE for HTML
	 */
	protected abstract boolean isHtml();

	/**
	 * Return the {@link MetaData} of this story.
	 * 
	 * @return the associated {@link MetaData}, never NULL
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected abstract MetaData getMeta() throws IOException;

	/**
	 * Return the story description.
	 * 
	 * @return the description
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected abstract String getDesc() throws IOException;

	/**
	 * Return the list of chapters (name and resource).
	 * <p>
	 * Can be NULL if this {@link BasicSupport} do no use chapters.
	 * 
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the chapters or NULL
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected abstract List<Entry<String, URL>> getChapters(Progress pg)
			throws IOException;

	/**
	 * Return the content of the chapter (possibly HTML encoded, if
	 * {@link BasicSupport#isHtml()} is TRUE).
	 * 
	 * @param chapUrl
	 *            the chapter {@link URL}
	 * @param number
	 *            the chapter number
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the content
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected abstract String getChapterContent(URL chapUrl, int number,
			Progress pg) throws IOException;

	/**
	 * Return the list of cookies (values included) that must be used to
	 * correctly fetch the resources.
	 * <p>
	 * You are expected to call the super method implementation if you override
	 * it.
	 * 
	 * @return the cookies
	 */
	public Map<String, String> getCookies() {
		return new HashMap<String, String>();
	}

	/**
	 * OAuth authorisation (aka, "bearer XXXXXXX").
	 * 
	 * @return the OAuth string
	 */
	public String getOAuth() {
		return null;
	}

	/**
	 * Return the canonical form of the main {@link URL}.
	 * 
	 * @param source
	 *            the source {@link URL}, which can be NULL
	 * 
	 * @return the canonical form of this {@link URL} or NULL if the source was
	 *         NULL
	 */
	protected URL getCanonicalUrl(URL source) {
		return source;
	}

	/**
	 * The main {@link Node} for this {@link Story}.
	 * 
	 * @return the node
	 */
	protected Element getSourceNode() {
		return sourceNode;
	}

	/**
	 * The main {@link URL} for this {@link Story}.
	 * 
	 * @return the URL
	 */
	protected URL getSource() {
		return source;
	}

	/**
	 * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
	 * the current {@link URL} we work on.
	 * 
	 * @return the referer
	 */
	public URL getCurrentReferer() {
		return currentReferer;
	}

	/**
	 * The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
	 * the current {@link URL} we work on.
	 * 
	 * @param currentReferer
	 *            the new referer
	 */
	protected void setCurrentReferer(URL currentReferer) {
		this.currentReferer = currentReferer;
	}

	/**
	 * The support type.
	 * 
	 * @return the type
	 */
	public SupportType getType() {
		return type;
	}

	/**
	 * The support type.
	 * 
	 * @param type
	 *            the new type
	 */
	protected void setType(SupportType type) {
		this.type = type;
	}

	/**
	 * Open an input link that will be used for the support.
	 * <p>
	 * Can return NULL, in which case you are supposed to work without a source
	 * node.
	 * 
	 * @param source
	 *            the source {@link URL}
	 * 
	 * @return the {@link InputStream}
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected Document loadDocument(URL source) throws IOException {
		String url = getCanonicalUrl(source).toString();
		return DataUtil.load(Instance.getCache().open(source, this, false),
				"UTF-8", url.toString());
	}

	/**
	 * Log into the support (can be a no-op depending upon the support).
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected void login() throws IOException {
	}

	/**
	 * Now that we have processed the {@link Story}, close the resources if any.
	 */
	protected void close() {
		setCurrentReferer(null);
	}

	/**
	 * Process the given story resource into a partially filled {@link Story}
	 * object containing the name and metadata.
	 * 
	 * @param getDesc
	 *            retrieve the description of the story, or not
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the {@link Story}, never NULL
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected Story processMeta(boolean getDesc, Progress pg)
			throws IOException {
		if (pg == null) {
			pg = new Progress();
		} else {
			pg.setMinMax(0, 100);
		}

		pg.setProgress(30);

		Story story = new Story();
		MetaData meta = getMeta();
		if (meta.getCreationDate() == null || meta.getCreationDate().isEmpty()) {
			meta.setCreationDate(StringUtils.fromTime(new Date().getTime()));
		}
		story.setMeta(meta);

		pg.setProgress(50);

		if (meta.getCover() == null) {
			meta.setCover(BasicSupportHelper.getDefaultCover(meta.getSubject()));
		}

		pg.setProgress(60);

		if (getDesc) {
			String descChapterName = Instance.getTrans().getString(
					StringId.DESCRIPTION);
			story.getMeta().setResume(
					BasicSupportPara.makeChapter(this, source, 0,
							descChapterName, //
							getDesc(), isHtml(), null));
		}

		pg.setProgress(100);
		return story;
	}

	/**
	 * Process the given story resource into a fully filled {@link Story}
	 * object.
	 * 
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the {@link Story}, never NULL
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	// ADD final when BasicSupport_Deprecated is gone
	public Story process(Progress pg) throws IOException {
		setCurrentReferer(source);
		login();
		sourceNode = loadDocument(source);

		try {
			return doProcess(pg);
		} finally {
			close();
		}
	}

	/**
	 * Actual processing step, without the calls to other methods.
	 * <p>
	 * Will convert the story resource into a fully filled {@link Story} object.
	 * 
	 * @param pg
	 *            the optional progress reporter
	 * 
	 * @return the {@link Story}, never NULL
	 * 
	 * @throws IOException
	 *             in case of I/O error
	 */
	protected Story doProcess(Progress pg) throws IOException {
		if (pg == null) {
			pg = new Progress();
		} else {
			pg.setMinMax(0, 100);
		}

		pg.setProgress(1);
		Progress pgMeta = new Progress();
		pg.addProgress(pgMeta, 10);
		Story story = processMeta(true, pgMeta);
		if (!pgMeta.isDone()) {
			pgMeta.setProgress(pgMeta.getMax()); // 10%
		}

		pg.setName("Retrieving " + story.getMeta().getTitle());

		Progress pgGetChapters = new Progress();
		pg.addProgress(pgGetChapters, 10);
		story.setChapters(new ArrayList<Chapter>());
		List<Entry<String, URL>> chapters = getChapters(pgGetChapters);
		if (!pgGetChapters.isDone()) {
			pgGetChapters.setProgress(pgGetChapters.getMax()); // 20%
		}

		if (chapters != null) {
			Progress pgChaps = new Progress("Extracting chapters", 0,
					chapters.size() * 300);
			pg.addProgress(pgChaps, 80);

			long words = 0;
			int i = 1;
			for (Entry<String, URL> chap : chapters) {
				pgChaps.setName("Extracting chapter " + i);
				URL chapUrl = chap.getValue();
				String chapName = chap.getKey();
				if (chapUrl != null) {
					setCurrentReferer(chapUrl);
				}

				pgChaps.setProgress(i * 100);
				Progress pgGetChapterContent = new Progress();
				Progress pgMakeChapter = new Progress();
				pgChaps.addProgress(pgGetChapterContent, 100);
				pgChaps.addProgress(pgMakeChapter, 100);

				String content = getChapterContent(chapUrl, i,
						pgGetChapterContent);
				if (!pgGetChapterContent.isDone()) {
					pgGetChapterContent.setProgress(pgGetChapterContent
							.getMax());
				}

				Chapter cc = BasicSupportPara.makeChapter(this, chapUrl, i,
						chapName, content, isHtml(), pgMakeChapter);
				if (!pgMakeChapter.isDone()) {
					pgMakeChapter.setProgress(pgMakeChapter.getMax());
				}

				words += cc.getWords();
				story.getChapters().add(cc);
				story.getMeta().setWords(words);

				i++;
			}

			pgChaps.setName("Extracting chapters");
		} else {
			pg.setProgress(80);
		}

		return story;
	}

	/**
	 * Return a {@link BasicSupport} implementation supporting the given
	 * resource if possible.
	 * 
	 * @param url
	 *            the story resource
	 * 
	 * @return an implementation that supports it, or NULL
	 */
	public static BasicSupport getSupport(URL url) {
		if (url == null) {
			return null;
		}

		// TEXT and INFO_TEXT always support files (not URLs though)
		for (SupportType type : SupportType.values()) {
			if (type != SupportType.TEXT && type != SupportType.INFO_TEXT) {
				BasicSupport support = getSupport(type, url);
				if (support != null && support.supports(url)) {
					return support;
				}
			}
		}

		for (SupportType type : new SupportType[] { SupportType.INFO_TEXT,
				SupportType.TEXT }) {
			BasicSupport support = getSupport(type, url);
			if (support != null && support.supports(url)) {
				return support;
			}
		}

		return null;
	}

	/**
	 * Return a {@link BasicSupport} implementation supporting the given type.
	 * 
	 * @param type
	 *            the type
	 * @param url
	 *            the {@link URL} to support (can be NULL to get an
	 *            "abstract support")
	 * 
	 * @return an implementation that supports it, or NULL
	 */
	public static BasicSupport getSupport(SupportType type, URL url) {
		BasicSupport support = null;

		switch (type) {
		case EPUB:
			support = new Epub();
			break;
		case INFO_TEXT:
			support = new InfoText();
			break;
		case FIMFICTION:
			try {
				// Can fail if no client key or NO in options
				support = new FimfictionApi();
			} catch (IOException e) {
				support = new Fimfiction();
			}
			break;
		case FANFICTION:
			support = new Fanfiction();
			break;
		case TEXT:
			support = new Text();
			break;
		case MANGAFOX:
			support = new MangaFox();
			break;
		case E621:
			support = new E621();
			break;
		case YIFFSTAR:
			support = new YiffStar();
			break;
		case E_HENTAI:
			support = new EHentai();
			break;
		case MANGA_LEL:
			support = new MangaLel();
			break;
		case CBZ:
			support = new Cbz();
			break;
		case HTML:
			support = new Html();
			break;
		}

		if (support != null) {
			support.setType(type);
			support.source = support.getCanonicalUrl(url);
		}

		return support;
	}
}
Commit	Line	Data
	1	package be.nikiroo.fanfix.supported;
	2
	3	import java.io.IOException;
	4	import java.io.InputStream;
	5	import java.net.URL;
	6	import java.util.ArrayList;
	7	import java.util.Date;
	8	import java.util.HashMap;
	9	import java.util.List;
	10	import java.util.Map;
	11	import java.util.Map.Entry;
	12
	13	import org.jsoup.helper.DataUtil;
	14	import org.jsoup.nodes.Document;
	15	import org.jsoup.nodes.Element;
	16	import org.jsoup.nodes.Node;
	17
	18	import be.nikiroo.fanfix.Instance;
	19	import be.nikiroo.fanfix.bundles.StringId;
	20	import be.nikiroo.fanfix.data.Chapter;
	21	import be.nikiroo.fanfix.data.MetaData;
	22	import be.nikiroo.fanfix.data.Story;
	23	import be.nikiroo.utils.Progress;
	24	import be.nikiroo.utils.StringUtils;
	25
	26	/**
	27	* This class is the base class used by the other support classes. It can be
	28	* used outside of this package, and have static method that you can use to get
	29	* access to the correct support class.
	30	* <p>
	31	* It will be used with 'resources' (usually web pages or files).
	32	*
	33	* @author niki
	34	*/
	35	public abstract class BasicSupport {
	36	private Document sourceNode;
	37	private URL source;
	38	private SupportType type;
	39	private URL currentReferer; // with only one 'r', as in 'HTTP'...
	40
	41	/**
	42	* The name of this support class.
	43	*
	44	* @return the name
	45	*/
	46	protected abstract String getSourceName();
	47
	48	/**
	49	* Check if the given resource is supported by this {@link BasicSupport}.
	50	*
	51	* @param url
	52	* the resource to check for
	53	*
	54	* @return TRUE if it is
	55	*/
	56	protected abstract boolean supports(URL url);
	57
	58	/**
	59	* Return TRUE if the support will return HTML encoded content values for
	60	* the chapters content.
	61	*
	62	* @return TRUE for HTML
	63	*/
	64	protected abstract boolean isHtml();
	65
	66	/**
	67	* Return the {@link MetaData} of this story.
	68	*
	69	* @return the associated {@link MetaData}, never NULL
	70	*
	71	* @throws IOException
	72	* in case of I/O error
	73	*/
	74	protected abstract MetaData getMeta() throws IOException;
	75
	76	/**
	77	* Return the story description.
	78	*
	79	* @return the description
	80	*
	81	* @throws IOException
	82	* in case of I/O error
	83	*/
	84	protected abstract String getDesc() throws IOException;
	85
	86	/**
	87	* Return the list of chapters (name and resource).
	88	* <p>
	89	* Can be NULL if this {@link BasicSupport} do no use chapters.
	90	*
	91	* @param pg
	92	* the optional progress reporter
	93	*
	94	* @return the chapters or NULL
	95	*
	96	* @throws IOException
	97	* in case of I/O error
	98	*/
	99	protected abstract List<Entry<String, URL>> getChapters(Progress pg)
	100	throws IOException;
	101
	102	/**
	103	* Return the content of the chapter (possibly HTML encoded, if
	104	* {@link BasicSupport#isHtml()} is TRUE).
	105	*
	106	* @param chapUrl
	107	* the chapter {@link URL}
	108	* @param number
	109	* the chapter number
	110	* @param pg
	111	* the optional progress reporter
	112	*
	113	* @return the content
	114	*
	115	* @throws IOException
	116	* in case of I/O error
	117	*/
	118	protected abstract String getChapterContent(URL chapUrl, int number,
	119	Progress pg) throws IOException;
	120
	121	/**
	122	* Return the list of cookies (values included) that must be used to
	123	* correctly fetch the resources.
	124	* <p>
	125	* You are expected to call the super method implementation if you override
	126	* it.
	127	*
	128	* @return the cookies
	129	*/
	130	public Map<String, String> getCookies() {
	131	return new HashMap<String, String>();
	132	}
	133
	134	/**
	135	* OAuth authorisation (aka, "bearer XXXXXXX").
	136	*
	137	* @return the OAuth string
	138	*/
	139	public String getOAuth() {
	140	return null;
	141	}
	142
	143	/**
	144	* Return the canonical form of the main {@link URL}.
	145	*
	146	* @param source
	147	* the source {@link URL}, which can be NULL
	148	*
	149	* @return the canonical form of this {@link URL} or NULL if the source was
	150	* NULL
	151	*/
	152	protected URL getCanonicalUrl(URL source) {
	153	return source;
	154	}
	155
	156	/**
	157	* The main {@link Node} for this {@link Story}.
	158	*
	159	* @return the node
	160	*/
	161	protected Element getSourceNode() {
	162	return sourceNode;
	163	}
	164
	165	/**
	166	* The main {@link URL} for this {@link Story}.
	167	*
	168	* @return the URL
	169	*/
	170	protected URL getSource() {
	171	return source;
	172	}
	173
	174	/**
	175	* The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
	176	* the current {@link URL} we work on.
	177	*
	178	* @return the referer
	179	*/
	180	public URL getCurrentReferer() {
	181	return currentReferer;
	182	}
	183
	184	/**
	185	* The current referer {@link URL} (only one 'r', as in 'HTML'...), i.e.,
	186	* the current {@link URL} we work on.
	187	*
	188	* @param currentReferer
	189	* the new referer
	190	*/
	191	protected void setCurrentReferer(URL currentReferer) {
	192	this.currentReferer = currentReferer;
	193	}
	194
	195	/**
	196	* The support type.
	197	*
	198	* @return the type
	199	*/
	200	public SupportType getType() {
	201	return type;
	202	}
	203
	204	/**
	205	* The support type.
	206	*
	207	* @param type
	208	* the new type
	209	*/
	210	protected void setType(SupportType type) {
	211	this.type = type;
	212	}
	213
	214	/**
	215	* Open an input link that will be used for the support.
	216	* <p>
	217	* Can return NULL, in which case you are supposed to work without a source
	218	* node.
	219	*
	220	* @param source
	221	* the source {@link URL}
	222	*
	223	* @return the {@link InputStream}
	224	*
	225	* @throws IOException
	226	* in case of I/O error
	227	*/
	228	protected Document loadDocument(URL source) throws IOException {
	229	String url = getCanonicalUrl(source).toString();
	230	return DataUtil.load(Instance.getCache().open(source, this, false),
	231	"UTF-8", url.toString());
	232	}
	233
	234	/**
	235	* Log into the support (can be a no-op depending upon the support).
	236	*
	237	* @throws IOException
	238	* in case of I/O error
	239	*/
	240	protected void login() throws IOException {
	241	}
	242
	243	/**
	244	* Now that we have processed the {@link Story}, close the resources if any.
	245	*/
	246	protected void close() {
	247	setCurrentReferer(null);
	248	}
	249
	250	/**
	251	* Process the given story resource into a partially filled {@link Story}
	252	* object containing the name and metadata.
	253	*
	254	* @param getDesc
	255	* retrieve the description of the story, or not
	256	* @param pg
	257	* the optional progress reporter
	258	*
	259	* @return the {@link Story}, never NULL
	260	*
	261	* @throws IOException
	262	* in case of I/O error
	263	*/
	264	protected Story processMeta(boolean getDesc, Progress pg)
	265	throws IOException {
	266	if (pg == null) {
	267	pg = new Progress();
	268	} else {
	269	pg.setMinMax(0, 100);
	270	}
	271
	272	pg.setProgress(30);
	273
	274	Story story = new Story();
	275	MetaData meta = getMeta();
	276	if (meta.getCreationDate() == null \|\| meta.getCreationDate().isEmpty()) {
	277	meta.setCreationDate(StringUtils.fromTime(new Date().getTime()));
	278	}
	279	story.setMeta(meta);
	280
	281	pg.setProgress(50);
	282
	283	if (meta.getCover() == null) {
	284	meta.setCover(BasicSupportHelper.getDefaultCover(meta.getSubject()));
	285	}
	286
	287	pg.setProgress(60);
	288
	289	if (getDesc) {
	290	String descChapterName = Instance.getTrans().getString(
	291	StringId.DESCRIPTION);
	292	story.getMeta().setResume(
	293	BasicSupportPara.makeChapter(this, source, 0,
	294	descChapterName, //
	295	getDesc(), isHtml(), null));
	296	}
	297
	298	pg.setProgress(100);
	299	return story;
	300	}
	301
	302	/**
	303	* Process the given story resource into a fully filled {@link Story}
	304	* object.
	305	*
	306	* @param pg
	307	* the optional progress reporter
	308	*
	309	* @return the {@link Story}, never NULL
	310	*
	311	* @throws IOException
	312	* in case of I/O error
	313	*/
	314	// ADD final when BasicSupport_Deprecated is gone
	315	public Story process(Progress pg) throws IOException {
	316	setCurrentReferer(source);
	317	login();
	318	sourceNode = loadDocument(source);
	319
	320	try {
	321	return doProcess(pg);
	322	} finally {
	323	close();
	324	}
	325	}
	326
	327	/**
	328	* Actual processing step, without the calls to other methods.
	329	* <p>
	330	* Will convert the story resource into a fully filled {@link Story} object.
	331	*
	332	* @param pg
	333	* the optional progress reporter
	334	*
	335	* @return the {@link Story}, never NULL
	336	*
	337	* @throws IOException
	338	* in case of I/O error
	339	*/
	340	protected Story doProcess(Progress pg) throws IOException {
	341	if (pg == null) {
	342	pg = new Progress();
	343	} else {
	344	pg.setMinMax(0, 100);
	345	}
	346
	347	pg.setProgress(1);
	348	Progress pgMeta = new Progress();
	349	pg.addProgress(pgMeta, 10);
	350	Story story = processMeta(true, pgMeta);
	351	if (!pgMeta.isDone()) {
	352	pgMeta.setProgress(pgMeta.getMax()); // 10%
	353	}
	354
	355	pg.setName("Retrieving " + story.getMeta().getTitle());
	356
	357	Progress pgGetChapters = new Progress();
	358	pg.addProgress(pgGetChapters, 10);
	359	story.setChapters(new ArrayList<Chapter>());
	360	List<Entry<String, URL>> chapters = getChapters(pgGetChapters);
	361	if (!pgGetChapters.isDone()) {
	362	pgGetChapters.setProgress(pgGetChapters.getMax()); // 20%
	363	}
	364
	365	if (chapters != null) {
	366	Progress pgChaps = new Progress("Extracting chapters", 0,
	367	chapters.size() * 300);
	368	pg.addProgress(pgChaps, 80);
	369
	370	long words = 0;
	371	int i = 1;
	372	for (Entry<String, URL> chap : chapters) {
	373	pgChaps.setName("Extracting chapter " + i);
	374	URL chapUrl = chap.getValue();
	375	String chapName = chap.getKey();
	376	if (chapUrl != null) {
	377	setCurrentReferer(chapUrl);
	378	}
	379
	380	pgChaps.setProgress(i * 100);
	381	Progress pgGetChapterContent = new Progress();
	382	Progress pgMakeChapter = new Progress();
	383	pgChaps.addProgress(pgGetChapterContent, 100);
	384	pgChaps.addProgress(pgMakeChapter, 100);
	385
	386	String content = getChapterContent(chapUrl, i,
	387	pgGetChapterContent);
	388	if (!pgGetChapterContent.isDone()) {
	389	pgGetChapterContent.setProgress(pgGetChapterContent
	390	.getMax());
	391	}
	392
	393	Chapter cc = BasicSupportPara.makeChapter(this, chapUrl, i,
	394	chapName, content, isHtml(), pgMakeChapter);
	395	if (!pgMakeChapter.isDone()) {
	396	pgMakeChapter.setProgress(pgMakeChapter.getMax());
	397	}
	398
	399	words += cc.getWords();
	400	story.getChapters().add(cc);
	401	story.getMeta().setWords(words);
	402
	403	i++;
	404	}
	405
	406	pgChaps.setName("Extracting chapters");
	407	} else {
	408	pg.setProgress(80);
	409	}
	410
	411	return story;
	412	}
	413
	414	/**
	415	* Return a {@link BasicSupport} implementation supporting the given
	416	* resource if possible.
	417	*
	418	* @param url
	419	* the story resource
	420	*
	421	* @return an implementation that supports it, or NULL
	422	*/
	423	public static BasicSupport getSupport(URL url) {
	424	if (url == null) {
	425	return null;
	426	}
	427
	428	// TEXT and INFO_TEXT always support files (not URLs though)
	429	for (SupportType type : SupportType.values()) {
	430	if (type != SupportType.TEXT && type != SupportType.INFO_TEXT) {
	431	BasicSupport support = getSupport(type, url);
	432	if (support != null && support.supports(url)) {
	433	return support;
	434	}
	435	}
	436	}
	437
	438	for (SupportType type : new SupportType[] { SupportType.INFO_TEXT,
	439	SupportType.TEXT }) {
	440	BasicSupport support = getSupport(type, url);
	441	if (support != null && support.supports(url)) {
	442	return support;
	443	}
	444	}
	445
	446	return null;
	447	}
	448
	449	/**
	450	* Return a {@link BasicSupport} implementation supporting the given type.
	451	*
	452	* @param type
	453	* the type
	454	* @param url
	455	* the {@link URL} to support (can be NULL to get an
	456	* "abstract support")
	457	*
	458	* @return an implementation that supports it, or NULL
	459	*/
	460	public static BasicSupport getSupport(SupportType type, URL url) {
	461	BasicSupport support = null;
	462
	463	switch (type) {
	464	case EPUB:
	465	support = new Epub();
	466	break;
	467	case INFO_TEXT:
	468	support = new InfoText();
	469	break;
	470	case FIMFICTION:
	471	try {
	472	// Can fail if no client key or NO in options
	473	support = new FimfictionApi();
	474	} catch (IOException e) {
	475	support = new Fimfiction();
	476	}
	477	break;
	478	case FANFICTION:
	479	support = new Fanfiction();
	480	break;
	481	case TEXT:
	482	support = new Text();
	483	break;
	484	case MANGAFOX:
	485	support = new MangaFox();
	486	break;
	487	case E621:
	488	support = new E621();
	489	break;
	490	case YIFFSTAR:
	491	support = new YiffStar();
	492	break;
	493	case E_HENTAI:
	494	support = new EHentai();
	495	break;
	496	case MANGA_LEL:
	497	support = new MangaLel();
	498	break;
	499	case CBZ:
	500	support = new Cbz();
	501	break;
	502	case HTML:
	503	support = new Html();
	504	break;
	505	}
	506
	507	if (support != null) {
	508	support.setType(type);
	509	support.source = support.getCanonicalUrl(url);
	510	}
	511
	512	return support;
	513	}
	514	}