import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public List getEnclosures() {
    List<SyndEnclosure> enc = super.getEnclosures();
    List<SyndEnclosure> result = new ArrayList<SyndEnclosure>(enc.size());
    for (SyndEnclosure e : enc) {
        SyndEnclosureImpl ee = new SyndEnclosureImpl();
        if (e != null) {
            ee.setLength(e.getLength());
            ee.setType(removeInvalidChars(e.getType()));
            ee.setUrl(removeInvalidChars(e.getUrl()));
        }
        result.add(ee);
    }
    return result;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
protected void _testEntry(int i) throws Exception {
    List items = getCachedSyndFeed().getEntries();
    SyndEntry entry = (SyndEntry) items.get(i);

    assertProperty(entry.getTitle(),"feed.entry["+i+"].title");
    assertProperty(entry.getTitleEx().getValue(),"feed.entry["+i+"].title");
    assertEquals("text",entry.getTitleEx().getType());
    
    assertEquals(entry.getLink(),"http://example.com/blog/entry" + (i + 1));
    assertEquals(((SyndEnclosure)entry.getEnclosures().get(0)).getUrl(),"http://example.com/blog/enclosure"+(i+1)+".gif");
    assertProperty(entry.getAuthor(),"feed.entry["+i+"].author.name");
    Date d = DateParser.parseW3CDateTime("2000-0"+(i+1)+"-01T01:00:00Z");
    assertEquals(entry.getPublishedDate(),d);
    assertProperty(entry.getDescription().getValue(),"feed.entry["+i+"].summary");
    assertProperty(((SyndContent)entry.getContents().get(0)).getValue(),"feed.entry["+i+"].content[0]");
    assertEquals(1, ((List)entry.getForeignMarkup()).size());
    SyndLink slink = (SyndLink)entry.getLinks().get(2);
    assertTrue(slink.getHref().startsWith("tag:"));
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
protected void _testEnclosures(List encs,String prefix) throws Exception {
    Set s1 = new HashSet();
    Set s2 = new HashSet();
    for (int i=0;i<encs.size();i++) {
        SyndEnclosure enc = (SyndEnclosure) encs.get(i);
        s1.add(enc.getUrl()+" "+enc.getType()+" "+enc.getLength());
        s2.add(getPrefix() + "." +prefix+".enclousure["+i+"]^url"+" "+
               getPrefix() + "." +prefix+".enclousure["+i+"]^type"+" "+
               "100");
    }
    assertTrue(s1.equals(s2));
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
public SyndEnclosure createSyndEnclosure(Feed feed, Entry entry,
        Link link) {
    SyndEnclosure syndEncl = new SyndEnclosureImpl();
    syndEncl.setUrl(link.getHrefResolved());
    syndEncl.setType(link.getType());
    syndEncl.setLength(link.getLength());
    return syndEncl;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
public Link createAtomEnclosure(SyndEnclosure syndEnclosure) {
  Link link = new Link();
  link.setRel(     "enclosure");
  link.setType(    syndEnclosure.getType());
  link.setHref(    syndEnclosure.getUrl());
  link.setLength(  syndEnclosure.getLength());
  return link;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
public SyndEnclosure createSyndEnclosure(Entry entry, Link link) {
    SyndEnclosure syndEncl = new SyndEnclosureImpl();
    syndEncl.setUrl(link.getHrefResolved());
    syndEncl.setType(link.getType());
    syndEncl.setLength(link.getLength());
    return syndEncl;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
protected List createSyndEnclosures(List enclosures) {
    List sEnclosures = new ArrayList();
    for (int i=0;i<enclosures.size();i++) {
        Enclosure enc = (Enclosure) enclosures.get(i);
        SyndEnclosure sEnc = new SyndEnclosureImpl();
        sEnc.setUrl(enc.getUrl());
        sEnc.setType(enc.getType());
        sEnc.setLength(enc.getLength());
        sEnclosures.add(sEnc);
    }
    return sEnclosures;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
protected List createEnclosures(List sEnclosures) {
    List enclosures = new ArrayList();
    for (int i=0;i<sEnclosures.size();i++) {
        SyndEnclosure sEnc = (SyndEnclosure) sEnclosures.get(i);
        Enclosure enc = new Enclosure();
        enc.setUrl(sEnc.getUrl());
        enc.setType(sEnc.getType());
        enc.setLength(sEnc.getLength());
        enclosures.add(enc);
    }
    return enclosures;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
public SyndEnclosure createSyndEnclosure(Feed feed, Entry entry,
        Link link) {
    SyndEnclosure syndEncl = new SyndEnclosureImpl();
    syndEncl.setUrl(link.getHref());
    syndEncl.setType(link.getType());
    syndEncl.setLength(link.getLength());
    return syndEncl;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void parse() throws Exception {
	SyndFeedInput input = new SyndFeedInput();
	byte b[] = downloadAndSendBinary(url);
	if (b != null) {
		SyndFeed feed = input.build(new XmlReader(new ByteArrayInputStream(b)));
		name = feed.getTitle();
		if (feed.getCategories() != null && feed.getCategories().size() > 0) {
			SyndCategory category = (SyndCategory) feed.getCategories().get(0);
			tempCategory = category.getName();
		}
		List<SyndEntry> entries = feed.getEntries();
		for (SyndEntry entry : entries) {
			tempItemTitle = entry.getTitle();
			tempItemLink = entry.getLink();
			tempFeedLink = entry.getUri();
			tempItemThumbURL = null;

			ArrayList<Element> elements = (ArrayList<Element>) entry.getForeignMarkup();
			for (Element elt : elements) {
				if ("group".equals(elt.getName()) && "media".equals(elt.getNamespacePrefix())) {
					List<Content> subElts = elt.getContent();
					for (Content subelt : subElts) {
						if (subelt instanceof Element) {
							parseElement((Element) subelt, false);
						}
					}
				}
				parseElement(elt, true);
			}
			List<SyndEnclosure> enclosures = entry.getEnclosures();
			for (SyndEnclosure enc : enclosures) {
				if (StringUtils.isNotBlank(enc.getUrl())) {
					tempItemLink = enc.getUrl();
				}
			}
			manageItem();
		}
	}
	setLastModified(System.currentTimeMillis());
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
/**
 * Parses the entries contained in an RSS feed, extracts the enclosures, converts them to an {@link Attachment}
 * adds them to the map with the entry uri as key.
 * <p>The RSS spec says there is only one enclosure per item so this is what we work with. We don't actually check this so it's possible
 * that if you have more than one enclosure attached to an item that only the latest one will be presented in the end.
 *
 * @param feed
 * @return
 */
public static Map<String, Attachment> parseFeedEnclosures(SyndFeed feed) {
	
	Map<String,Attachment> attachments = new HashMap<String,Attachment>();
	
	// image mime types that are ok to be rendered as an image
	List<String> imageTypes = new ArrayList<String>();
	imageTypes.add("image/jpeg");
	imageTypes.add("image/gif");
	imageTypes.add("image/png");
	imageTypes.add("image/jpg");
	
	List<SyndEntry> entries = feed.getEntries();
	for(SyndEntry entry: entries) {
		
		//get entry uri, but it could be blank so if so, skip this item
		if(StringUtils.isBlank(entry.getUri())) {
			continue;
		}
		
		//for each enclosure attached to an entry get the first one and use that.			
		List<SyndEnclosure> enclosures = entry.getEnclosures();
		for(SyndEnclosure e: enclosures) {
			
			//convert to an Attachment
			Attachment a = new Attachment();
			a.setUrl(e.getUrl());
			a.setDisplayLength(formatLength(e.getLength()));
			a.setType(e.getType());
			
			//process the url into a displayname (get just the filename from the full URL)
			String displayName = StringUtils.substringAfterLast(e.getUrl(), "/");
			if(StringUtils.isNotBlank(displayName)){
				a.setDisplayName(displayName);
			} else {
				a.setDisplayName(Messages.getString("view.attachment.default"));
			}
			
			//check if its an iamge we are able to display as the thumbnail for the entry
			if(imageTypes.contains(e.getType())){
				a.setImage(true);
			} 
			
			attachments.put(entry.getUri(), a);
		}
	}
	
	return attachments;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
/**
 * Converts a <code>SyndEntry</code> into an <code>Item</code>
 * 
 * @param entry
 *            The SyndEntry
 * @return The Item
 */
private Item convertToItem(final SyndEntry entry) {
    // A SyncEntry can potentially have many attributes like title, description,
    // guid, link, enclosure or content. In OLAT, however, items are limited
    // to the attributes, title, description and one media file (called
    // enclosure in RSS) for simplicity.
    final Item e = new Item();
    e.setTitle(entry.getTitle());
    e.setDescription(entry.getDescription() != null ? entry.getDescription().getValue() : null);
    // Extract content objects from syndication item
    final StringBuffer sb = new StringBuffer();
    for (final SyndContent content : (List<SyndContent>) entry.getContents()) {
        // we don't check for type, assume it is html or txt
        if (sb.length() > 0) {
            sb.append("<p />");
        }
        sb.append(content.getValue());
    }
    // Set aggregated content from syndication item as our content
    if (sb.length() > 0) {
        e.setContent(sb.toString());
    }
    e.setGuid(entry.getUri());
    e.setExternalLink(entry.getLink());
    e.setLastModified(entry.getUpdatedDate());
    e.setPublishDate(entry.getPublishedDate());

    for (final Object enclosure : entry.getEnclosures()) {
        if (enclosure instanceof SyndEnclosure) {
            final SyndEnclosure syndEnclosure = (SyndEnclosure) enclosure;
            final Enclosure media = new Enclosure();
            media.setExternalUrl(syndEnclosure.getUrl());
            media.setType(syndEnclosure.getType());
            media.setLength(syndEnclosure.getLength());
            e.setEnclosure(media);
        }
        // Break after one cycle because only one media file is supported
        break;
    }
    return e;
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
/**
    * Constructor. The identityKey is needed to generate personal URLs for the corresponding user.
    */
protected RSSFeed(final Feed feed, final Identity identity, final Long courseId, final String nodeId,final Translator translator, RepositoryService repositoryService) {
       super();

       // This helper object is required for generating the appropriate URLs for
       // the given user (identity)
	final FeedViewHelper helper = new FeedViewHelper(feed, identity, courseId, nodeId, translator, repositoryService);

       setFeedType("rss_2.0");
       setEncoding(RSSServlet.DEFAULT_ENCODING);
       setTitle(feed.getTitle());
       // According to the rss specification, the feed channel description is not
       // (explicitly) allowed to contain html tags.
       String strippedDescription = FilterFactory.getHtmlTagsFilter().filter(feed.getDescription());
       strippedDescription = strippedDescription.replaceAll(" ", " "); // TODO: remove when filter
       // does it
       setDescription(strippedDescription);
       setLink(helper.getJumpInLink());

       setPublishedDate(feed.getLastModified());
       // The image
       if (feed.getImageName() != null) {
           final SyndImage image = new SyndImageImpl();
           image.setDescription(feed.getDescription());
           image.setTitle(feed.getTitle());
           image.setLink(getLink());
           image.setUrl(helper.getImageUrl());
           setImage(image);
       }

       final List<SyndEntry> episodes = new ArrayList<SyndEntry>();
       for (final Item item : feed.getPublishedItems()) {
           final SyndEntry entry = new SyndEntryImpl();
           entry.setTitle(item.getTitle());

           final SyndContent itemDescription = new SyndContentImpl();
           itemDescription.setType("text/plain");
           itemDescription.setValue(helper.getItemDescriptionForBrowser(item));
           entry.setDescription(itemDescription);

           // Link will also be converted to the rss guid tag. Except if there's an
           // enclosure, then the enclosure url is used.
           // Use jump-in link far all entries. This will be overriden if the item
           // has an enclosure.
           entry.setLink(helper.getJumpInLink() + "#" + item.getGuid());
           entry.setPublishedDate(item.getPublishDate());
           entry.setUpdatedDate(item.getLastModified());

           // The enclosure is the media (audio or video) file of the episode
           final Enclosure media = item.getEnclosure();
           if (media != null) {
               final SyndEnclosure enclosure = new SyndEnclosureImpl();
               enclosure.setUrl(helper.getMediaUrl(item));
               enclosure.setType(media.getType());
               enclosure.setLength(media.getLength());
               // Also set the item link to point to the enclosure
               entry.setLink(helper.getMediaUrl(item));
               final List<SyndEnclosure> enclosures = new ArrayList<SyndEnclosure>();
               enclosures.add(enclosure);
               entry.setEnclosures(enclosures);
           }

           episodes.add(entry);
       }
       setEntries(episodes);
   }
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
/**
 * Constructor. The identityKey is needed to generate personal URLs for the corresponding user.
 */
protected RSSFeed(final Feed feed, final Identity identity, final Long courseId, final String nodeId, final Translator translator, RepositoryService repositoryService) {
    super();

    // This helper object is required for generating the appropriate URLs for
    // the given user (identity)
    final FeedViewHelper helper = new FeedViewHelper(feed, identity, courseId, nodeId, translator, repositoryService);

    setFeedType("rss_2.0");
    setEncoding(DEFAULT_ENCODING);
    setTitle(feed.getTitle());
    // According to the rss specification, the feed channel description is not
    // (explicitly) allowed to contain html tags.
    String strippedDescription = FilterFactory.getHtmlTagsFilter().filter(feed.getDescription());
    strippedDescription = strippedDescription.replaceAll(" ", " "); // TODO: remove when filter
    // does it
    setDescription(strippedDescription);
    setLink(helper.getJumpInLink());

    setPublishedDate(feed.getLastModified());
    // The image
    if (feed.getImageName() != null) {
        final SyndImage image = new SyndImageImpl();
        image.setDescription(feed.getDescription());
        image.setTitle(feed.getTitle());
        image.setLink(getLink());
        image.setUrl(helper.getImageUrl());
        setImage(image);
    }

    final List<SyndEntry> episodes = new ArrayList<SyndEntry>();
    for (final Item item : feed.getPublishedItems()) {
        final SyndEntry entry = new SyndEntryImpl();
        entry.setTitle(item.getTitle());

        final SyndContent itemDescription = new SyndContentImpl();
        itemDescription.setType("text/plain");
        itemDescription.setValue(helper.getItemDescriptionForBrowser(item));
        entry.setDescription(itemDescription);

        // Link will also be converted to the rss guid tag. Except if there's an
        // enclosure, then the enclosure url is used.
        // Use jump-in link far all entries. This will be overriden if the item
        // has an enclosure.
        entry.setLink(helper.getJumpInLink() + "#" + item.getGuid());
        entry.setPublishedDate(item.getPublishDate());
        entry.setUpdatedDate(item.getLastModified());

        // The enclosure is the media (audio or video) file of the episode
        final Enclosure media = item.getEnclosure();
        if (media != null) {
            final SyndEnclosure enclosure = new SyndEnclosureImpl();
            enclosure.setUrl(helper.getMediaUrl(item));
            enclosure.setType(media.getType());
            enclosure.setLength(media.getLength());
            // Also set the item link to point to the enclosure
            entry.setLink(helper.getMediaUrl(item));
            final List<SyndEnclosure> enclosures = new ArrayList<SyndEnclosure>();
            enclosures.add(enclosure);
            entry.setEnclosures(enclosures);
        }

        episodes.add(entry);
    }
    setEntries(episodes);
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
/**
 * @param seriesId
 * @param transcodingProfileId
 * @param feed
 */
@SuppressWarnings("rawtypes")
public void purgeFeed(String seriesId, String transcodingProfileId, SyndFeed feed) {
  final File encodingDirectory = new File(feedFilePath, transcodingProfileId);

  // delete feed
  final File feedFile = new File(encodingDirectory, seriesId + feedFileExtension);
  if (feedFile.canWrite()) {
    feedFile.delete();
  }

  // delete feed thumbnail
  final File feedThumbnail = new File(encodingDirectory, seriesId + PNG_EXTENSION);
  if (feedThumbnail.canWrite()) {
    feedThumbnail.delete();
  }

  // delete feed transformation
  final File feedTransformationFile =
      new File(encodingDirectory, seriesId + feedTransformationOutputFileExtension);
  if (feedTransformationFile.canWrite()) {
    feedTransformationFile.delete();
  }

  if (feed != null) {
    final Iterator it = feed.getEntries().iterator();
    while (it.hasNext()) {
      SyndEntry entry = (SyndEntry) it.next();
      final List enclosures = entry.getEnclosures();
      if (enclosures.size() > 0) {
        Iterator enclosureIterator = enclosures.iterator();
        while (enclosureIterator.hasNext()) {
          SyndEnclosure enclosure = (SyndEnclosure) enclosureIterator.next();
          String encUrl = enclosure.getUrl();
          encUrl = encUrl.substring(encUrl.lastIndexOf('/') + 1);

          final TranscodingProfile profile =
              transcodingProfilesDao.findAllProfiles().get(transcodingProfileId);
          if (profile != null) {
            profile.deleteEncoding(this.feedFilePath, enclosure.getUrl(), entry.getUri());
          } else {
            // fabricate a profile for the purpose of deleting the encoding output
            final TranscodingProfile fakeProfile = new TranscodingProfile();
            fakeProfile.setId(transcodingProfileId);
            if (enclosure.getUrl().endsWith(".m3u8")) {
              fakeProfile.setMode(TranscoderType.ONE_PASS_HTTP_SEGMENTED_VOD);
            } else {
              fakeProfile.setMode(TranscoderType.ONE_PASS);
            }

            fakeProfile.deleteEncoding(this.feedFilePath, enclosure.getUrl(), entry.getUri());
          }
        }
      } else {
        LOGGER.debug("No enclosures specified in the entry, continuing");
        continue;
      }
    }
  }

  // delete the encoding profile directory if it is empty following the purge
  if (encodingDirectory.list().length == 0) {
    LOGGER.info("Deleting empty encoding profile directory: "
        + encodingDirectory.getAbsolutePath());
    encodingDirectory.delete();
  }
}
 

import com.sun.syndication.feed.synd.SyndEnclosure; //导入依赖的package包/类
@GET
@Path("/add/{podcastUrl}")
@Produces(MediaType.APPLICATION_JSON)
public Response addPodcast(@PathParam("podcastUrl") String podcastUrl) throws IllegalArgumentException, FeedException, IOException {
	System.out.println("Got podcast URL: " + podcastUrl);
	
	URL url = new URL(podcastUrl);
	SyndFeedInput input = new SyndFeedInput();
	SyndFeed feed = input.build(new XmlReader(url));

	StringBuilder episodeUrls = new StringBuilder();
	for (Object entry : feed.getEntries()) {
	    if (!(entry instanceof SyndEntryImpl)) {
	        // Throw an error?
	    }
	    SyndEntryImpl episode = (SyndEntryImpl) entry;
	    /*
	    System.out.println("Episode: { "
	                + ", 'title' : " + episode.getTitle()
	                + ", 'description' : " + episode.getDescription()
	                + " }");
	    */
	    for (Object possibleEnclosure : episode.getEnclosures()) {
	        if (!(possibleEnclosure instanceof SyndEnclosure)) {
	            // Throw an error?
	        }

	        SyndEnclosure enclosure = (SyndEnclosure) possibleEnclosure;
	        /*
	        System.out.println("\tEnclosure: { " 
	                + ", 'type' : " + enclosure.getType() 
	                + ", 'length' : " + enclosure.getLength()
	                + ", 'url' : " + enclosure.getUrl()
	                + " }");
	        */
	        
	        episodeUrls.append("Episode - PubDate: " + episode.getPublishedDate() + ", URL: " + enclosure.getUrl() + "\n");
	        
	        
	    }
	}
	
	return Response.ok().entity(episodeUrls.toString()).build();
}