Ejemplo n.º 1
0
 private SVNErrorMessage readData(
     InputStream is, String method, String path, DefaultHandler handler)
     throws FactoryConfigurationError, UnsupportedEncodingException, IOException {
   try {
     if (mySAXParser == null) {
       mySAXParser = getSAXParserFactory().newSAXParser();
     }
     XMLReader reader = new XMLReader(is);
     while (!reader.isClosed()) {
       org.xml.sax.XMLReader xmlReader = mySAXParser.getXMLReader();
       xmlReader.setContentHandler(handler);
       xmlReader.setDTDHandler(handler);
       xmlReader.setErrorHandler(handler);
       xmlReader.setEntityResolver(NO_ENTITY_RESOLVER);
       xmlReader.parse(new InputSource(reader));
     }
   } catch (SAXException e) {
     if (e instanceof SAXParseException) {
       if (handler instanceof DAVErrorHandler) {
         // failed to read svn-specific error, return null.
         return null;
       }
     } else if (e.getException() instanceof SVNException) {
       return ((SVNException) e.getException()).getErrorMessage();
     } else if (e.getCause() instanceof SVNException) {
       return ((SVNException) e.getCause()).getErrorMessage();
     }
     return SVNErrorMessage.create(
         SVNErrorCode.RA_DAV_REQUEST_FAILED,
         "Processing {0} request response failed: {1} ({2}) ",
         new Object[] {method, e.getMessage(), path});
   } catch (ParserConfigurationException e) {
     return SVNErrorMessage.create(
         SVNErrorCode.RA_DAV_REQUEST_FAILED,
         "XML parser configuration error while processing {0} request response: {1} ({2}) ",
         new Object[] {method, e.getMessage(), path});
   } catch (EOFException e) {
     // skip it.
   } finally {
     if (mySAXParser != null) {
       // to avoid memory leaks when connection is cached.
       org.xml.sax.XMLReader xmlReader = null;
       try {
         xmlReader = mySAXParser.getXMLReader();
       } catch (SAXException e) {
       }
       if (xmlReader != null) {
         xmlReader.setContentHandler(DEFAULT_SAX_HANDLER);
         xmlReader.setDTDHandler(DEFAULT_SAX_HANDLER);
         xmlReader.setErrorHandler(DEFAULT_SAX_HANDLER);
         xmlReader.setEntityResolver(NO_ENTITY_RESOLVER);
       }
     }
     myRepository.getDebugLog().flushStream(is);
   }
   return null;
 }
Ejemplo n.º 2
0
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.flash_card_activity);

    // Initialize fields
    initialize();

    try {
      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();
      XMLReader xr = sp.getXMLReader();
      myParser = new XMLParser();
      xr.setContentHandler(myParser);
      xr.parse(new InputSource(this.getResources().openRawResource(R.raw.words)));
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      words = myParser.getWordsList();
      // db = dbh.getWritableDatabase();
      // myWords = dbh.getMyWordsList();
      displayWord(words.get(index));
    }

    pbProgress.setMax(words.size());
  }
Ejemplo n.º 3
0
  public void loadIdea() {

    try {

      URL url = new URL(idea_url);

      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();

      XMLReader xr = sp.getXMLReader();
      IdeaDetailHandler myExampleHandler = new IdeaDetailHandler();
      xr.setContentHandler(myExampleHandler);

      InputSource is = new InputSource(url.openStream());
      is.setEncoding("UTF-8");
      xr.parse(is);

      idea = myExampleHandler.getParsedData();

      Message myMessage = new Message();
      myMessage.obj = "SUCCESS";
      handler.sendMessage(myMessage);

    } catch (Exception e) {
      // Log.e("Ideas4All", "Error", e);
    }
  }
 /**
  * Deconstructs response into given content handler
  *
  * @param entity returned HttpEntity
  * @return deconstructed response
  * @throws java.io.IOException
  * @see org.apache.http.HttpEntity
  */
 @Override
 protected byte[] getResponseData(HttpEntity entity) throws IOException {
   if (entity != null) {
     InputStream instream = entity.getContent();
     InputStreamReader inputStreamReader = null;
     if (instream != null) {
       try {
         SAXParserFactory sfactory = SAXParserFactory.newInstance();
         SAXParser sparser = sfactory.newSAXParser();
         XMLReader rssReader = sparser.getXMLReader();
         rssReader.setContentHandler(handler);
         inputStreamReader = new InputStreamReader(instream, DEFAULT_CHARSET);
         rssReader.parse(new InputSource(inputStreamReader));
       } catch (SAXException e) {
         Log.e(LOG_TAG, "getResponseData exception", e);
       } catch (ParserConfigurationException e) {
         Log.e(LOG_TAG, "getResponseData exception", e);
       } finally {
         AsyncHttpClient.silentCloseInputStream(instream);
         if (inputStreamReader != null) {
           try {
             inputStreamReader.close();
           } catch (IOException e) {
             /*ignore*/
           }
         }
       }
     }
   }
   return null;
 }
  private boolean loadParticleXML() {
    InputStream is = null;
    try {
      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();

      QuickTiGame2dParticleParser handler = new QuickTiGame2dParticleParser(this);

      XMLReader xr = sp.getXMLReader();
      xr.setContentHandler(handler);

      is = QuickTiGame2dUtil.getFileInputStream(image);
      xr.parse(new InputSource(new BufferedInputStream(is)));

      emissionRate = maxParticles / particleLifespan;

      sourcePosition.x = x;
      sourcePosition.y = y;

    } catch (Exception e) {
      if (debug)
        Log.w(Quicktigame2dModule.LOG_TAG, String.format("failed to load particle: %s", image), e);
      return false;
    } finally {
      if (is != null) {
        try {
          is.close();
        } catch (IOException e) {
          // nothing to do
        }
      }
    }

    return true;
  }
Ejemplo n.º 6
0
  private static Service parseServicePayload(String payload) throws ResponseParseException {

    JAXBContext jaxbContext;
    Service service = null;

    try {
      jaxbContext = JAXBContext.newInstance(Service.class);
      Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

      InputStream inputStream =
          new ByteArrayInputStream(payload.getBytes(Charset.forName("UTF-8")));

      SAXParserFactory spf = SAXParserFactory.newInstance();
      spf.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
      SAXParser sp = spf.newSAXParser();
      XMLReader xmlReader = sp.getXMLReader();
      InputSource inputSource = new InputSource(inputStream);
      SAXSource saxSource = new SAXSource(xmlReader, inputSource);

      service = (Service) jaxbUnmarshaller.unmarshal(saxSource);

    } catch (JAXBException
        | FactoryConfigurationError
        | ParserConfigurationException
        | SAXException e) {
      throw new ResponseParseException(e);
    }

    return service;
  }
Ejemplo n.º 7
0
  public void load(PageProcessor processor) {
    SAXParserFactory factory = SAXParserFactory.newInstance();
    try {

      SAXParser parser = factory.newSAXParser();
      XMLReader xmlReader = parser.getXMLReader();
      // String file = "enwiki-20151201-pages-meta-current.xml.bz2";

      xmlReader.setContentHandler(new PageHandler(xmlReader));
      FileInputStream fis = new FileInputStream(fileName);
      BZip2CompressorInputStream bzIn = new BZip2CompressorInputStream(fis);
      InputSource inputSource = new InputSource(bzIn);
      xmlReader.parse(inputSource);
      System.out.println("###### " + threadName + " processing completed ######");

    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      // System.out.println("Closing Thread- " + threadName);
      DataIndexer.getInstance().threadClosing();
    }
  }
Ejemplo n.º 8
0
 /**
  * This method parses the data from the BBC XML link, via the SAX Parser and XMLHandler class.
  *
  * @see XMLHandler
  */
 private void getNews() {
   try {
     URL xmlUrl = new URL("http://feeds.bbci.co.uk/news/uk/rss.xml");
     SAXParserFactory mySAXParserFactory = SAXParserFactory.newInstance();
     SAXParser mySAXParser = mySAXParserFactory.newSAXParser();
     XMLReader myXMLReader = mySAXParser.getXMLReader();
     XMLHandler myXMLHandler = new XMLHandler();
     myXMLReader.setContentHandler(myXMLHandler);
     InputSource myInputSource = new InputSource(xmlUrl.openStream());
     myXMLReader.parse(myInputSource);
     myXMLFeed = myXMLHandler.getFeed();
   }
   // catch a bunch of exceptions
   catch (MalformedURLException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (ParserConfigurationException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (SAXException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (IOException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
 }
  public ArrayList<String> recomendaciones() {
    try {
      String direccion = "http://www.thetvdb.com/api/User_Favorites.php?accountid=7FB13C3CF230D455";

      URL url = new URL(direccion);

      HttpURLConnection conexion = (HttpURLConnection) url.openConnection();

      if (conexion.getResponseCode() == HttpURLConnection.HTTP_OK) {
        SAXParserFactory fabrica = SAXParserFactory.newInstance();
        SAXParser parser = fabrica.newSAXParser();
        XMLReader lector = parser.getXMLReader();
        ManejadorSerWeb manejadorXML = new ManejadorSerWeb();
        lector.setContentHandler(manejadorXML);
        lector.parse(new InputSource(conexion.getInputStream()));

        return manejadorXML.getRecomendaciones();
      } else {
        Log.e("ANDseries", conexion.getResponseMessage());
        return null;
      }
    } catch (Exception e) {
      Log.e("ANDseries", e.getMessage(), e);
      return null;
    }
  }
  public WebXMLDefinition loadWebXML() throws Exception {
    URL url = _bundle.getEntry("WEB-INF/web.xml");

    if (url != null) {
      try (InputStream inputStream = url.openStream()) {
        SAXParser saxParser = _saxParserFactory.newSAXParser();

        XMLReader xmlReader = saxParser.getXMLReader();

        xmlReader.setContentHandler(this);

        xmlReader.parse(new InputSource(inputStream));
      } catch (SAXParseException saxpe) {
        String message = saxpe.getMessage();

        if (message.contains("DOCTYPE is disallowed")) {
          throw new Exception(
              "WEB-INF/web.xml must be updated to the Servlet 2.4 " + "specification");
        }

        throw saxpe;
      }
    }

    return _webXMLDefinition;
  }
Ejemplo n.º 11
0
  private XMLReader getXMLReader(ContentHandler contentHandler, ErrorHandler errorHandler)
      throws ParserConfigurationException, SAXException {

    // setup sax factory ; be sure just one instance!
    SAXParserFactory saxFactory = SAXParserFactory.newInstance();

    // Enable validation stuff
    saxFactory.setValidating(true);
    saxFactory.setNamespaceAware(true);

    // Create xml reader
    SAXParser saxParser = saxFactory.newSAXParser();
    XMLReader xmlReader = saxParser.getXMLReader();

    // Setup xmlreader
    xmlReader.setProperty(
        XMLReaderObjectFactory.APACHE_PROPERTIES_INTERNAL_GRAMMARPOOL, grammarPool);

    xmlReader.setFeature(Namespaces.SAX_VALIDATION, true);
    xmlReader.setFeature(Namespaces.SAX_VALIDATION_DYNAMIC, false);
    xmlReader.setFeature(XMLReaderObjectFactory.APACHE_FEATURES_VALIDATION_SCHEMA, true);
    xmlReader.setFeature(XMLReaderObjectFactory.APACHE_PROPERTIES_LOAD_EXT_DTD, true);
    xmlReader.setFeature(Namespaces.SAX_NAMESPACES_PREFIXES, true);

    xmlReader.setContentHandler(contentHandler);
    xmlReader.setErrorHandler(errorHandler);

    return xmlReader;
  }
Ejemplo n.º 12
0
  public RSSFeed readFile() {
    try {
      // get the XML reader
      SAXParserFactory factory = SAXParserFactory.newInstance();
      SAXParser parser = factory.newSAXParser();
      XMLReader xmlreader = parser.getXMLReader();

      // set content handler
      RSSFeedHandler theRssHandler = new RSSFeedHandler();
      xmlreader.setContentHandler(theRssHandler);

      // read the file from internal storage
      FileInputStream in = context.openFileInput(FILENAME);

      // parse the data
      InputSource is = new InputSource(in);
      xmlreader.parse(is);

      // set the feed in the activity
      RSSFeed feed = theRssHandler.getFeed();
      return feed;
    } catch (Exception e) {
      Log.e("News reader", e.toString());
      return null;
    }
  }
Ejemplo n.º 13
0
  public void parseServicesXml(String servicesDotXml) {

    try {
      /* Create a URL we want to load some xml-data from. */
      // URL url = new URL("https://services.appmobi.com/testing/AppConfig.xml");

      /* Get a SAXParser from the SAXPArserFactory. */
      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();

      /* Get the XMLReader of the SAXParser we created. */
      XMLReader xr = sp.getXMLReader();
      /* Create a new ContentHandler and apply it to the XML-Reader*/
      ServicesHandler handler = new ServicesHandler(this);
      xr.setContentHandler(handler);

      /* Parse the xml-data from our URL. */
      xr.parse(new InputSource(new StringReader(servicesDotXml)));
      /* Parsing has finished. */

    } catch (Exception e) {
      /* Display any Error to the GUI. */
      // if(Debug.isDebuggerConnected()) Log.e("[appMobi]", "services.xml Parsing Error", e);
    }
  }
Ejemplo n.º 14
0
  @Override
  public void internalParse(InputStream input) {
    try {
      try {
        Thread.sleep(4000);
      } catch (Throwable t) {

      }

      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
      saxParserFactory.setValidating(false);
      SAXParser saxParser = saxParserFactory.newSAXParser();
      XMLReader xmlReader = saxParser.getXMLReader();
      xmlReader.setFeature("http://xml.org/sax/features/validation", false);
      xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);

      ZipInputStream zis = new ZipInputStream(input);
      ZipEntry ze = zis.getNextEntry();
      while (ze != null && !ze.getName().equals("content.xml")) {
        ze = zis.getNextEntry();
      }

      OpenOfficeContentHandler contentHandler = new OpenOfficeContentHandler();
      xmlReader.setContentHandler(contentHandler);
      try {
        xmlReader.parse(new InputSource(zis));
      } finally {
        zis.close();
      }

      content.append(StringUtil.writeToString(new StringReader(contentHandler.getContent())));
    } catch (Exception e) {
      log.warn("Failed to extract OpenOffice text content", e);
    }
  }
Ejemplo n.º 15
0
  public void testWithDummyExtSubset() throws Exception {
    final String XML =
        "<!DOCTYPE root PUBLIC '//some//public//id' 'no-such-thing.dtd'>\n" + "<root />";

    SAXParserFactoryImpl spf = new SAXParserFactoryImpl();
    spf.setNamespaceAware(true);
    SAXParser sp = spf.newSAXParser();
    DefaultHandler h = new DefaultHandler();

    /* First: let's verify that we get an exception for
     * unresolved reference...
     */
    try {
      sp.parse(new InputSource(new StringReader(XML)), h);
    } catch (SAXException e) {
      verifyException(e, "No such file or directory");
    }

    // And then with dummy resolver; should work ok now
    sp = spf.newSAXParser();
    sp.getXMLReader().setEntityResolver(new MyResolver("   "));
    h = new DefaultHandler();
    try {
      sp.parse(new InputSource(new StringReader(XML)), h);
    } catch (SAXException e) {
      fail(
          "Should not have failed with entity resolver, got ("
              + e.getClass()
              + "): "
              + e.getMessage());
    }
  }
Ejemplo n.º 16
0
 Parser(String uri) {
   try {
     SAXParserFactory parserFactory = SAXParserFactory.newInstance();
     SAXParser parser = parserFactory.newSAXParser();
     ConfigHandler handler = new ConfigHandler();
     parser.getXMLReader().setFeature("http://xml.org/sax/features/validation", true);
     parser.parse(new File(uri), handler);
   } catch (IOException e) {
     System.out.println("Error reading URI: " + e.getMessage());
   } catch (SAXException e) {
     System.out.println("Error in parsing: " + e.getMessage());
   } catch (ParserConfigurationException e) {
     System.out.println("Error in XML parser configuration: " + e.getMessage());
   }
   // System.out.println("Number of Persons : " + Person.numberOfPersons());
   // nameLengthStatistics();
   // System.out.println("Number of Publications with authors/editors: " +
   //                   Publication.getNumberOfPublications());
   // System.out.println("Maximum number of authors/editors in a publication: " +
   //                           Publication.getMaxNumberOfAuthors());
   // publicationCountStatistics();
   // Person.enterPublications();
   // Person.printCoauthorTable();
   // Person.printNamePartTable();
   // Person.findSimilarNames();
 }
 @Override
 protected String getDocumentText(String absolutePath, String encoding) throws IOException {
   String text;
   try {
     SAXParserFactory spf = SAXParserFactory.newInstance();
     spf.setValidating(false);
     spf.setNamespaceAware(true);
     spf.setFeature("http://xml.org/sax/features/namespaces", true);
     spf.setFeature("http://xml.org/sax/features/validation", false);
     spf.setFeature("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", false);
     spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
     SAXParser saxParser = spf.newSAXParser();
     XMLReader xmlReader = saxParser.getXMLReader();
     TeiToTxtSaxHandler handler = new TeiToTxtSaxHandler();
     xmlReader.setContentHandler(handler);
     xmlReader.parse(new InputSource(absolutePath));
     text = handler.getText();
   } catch (ParserConfigurationException | SAXException e) {
     logger.error("Could not read TEI document: {}", absolutePath);
     logger.warn("Ignoring TEI document " + absolutePath);
     text = "";
     this.failedFileCounter++;
   }
   return text;
 }
 private static SVG parse(
     InputStream in, Integer searchColor, Integer replaceColor, boolean whiteMode)
     throws SVGParseException {
   //        Util.debug("Parsing SVG...");
   try {
     //            long start = System.currentTimeMillis();
     SAXParserFactory spf = SAXParserFactory.newInstance();
     SAXParser sp = spf.newSAXParser();
     XMLReader xr = sp.getXMLReader();
     final Picture picture = new Picture();
     SVGHandler handler = new SVGHandler(picture);
     handler.setColorSwap(searchColor, replaceColor);
     handler.setWhiteMode(whiteMode);
     xr.setContentHandler(handler);
     xr.parse(new InputSource(in));
     //        Util.debug("Parsing complete in " + (System.currentTimeMillis() - start) + "
     // millis.");
     SVG result = new SVG(picture, handler.bounds);
     // Skip bounds if it was an empty pic
     if (!Float.isInfinite(handler.limits.top)) {
       result.setLimits(handler.limits);
     }
     return result;
   } catch (Exception e) {
     throw new SVGParseException(e);
   }
 }
 private CloudServersException parseCloudServersException(HttpResponse response) {
   CloudServersException cse = new CloudServersException();
   try {
     BasicResponseHandler responseHandler = new BasicResponseHandler();
     String body = responseHandler.handleResponse(response);
     CloudServersFaultXMLParser parser = new CloudServersFaultXMLParser();
     SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
     XMLReader xmlReader = saxParser.getXMLReader();
     xmlReader.setContentHandler(parser);
     xmlReader.parse(new InputSource(new StringReader(body)));
     cse = parser.getException();
   } catch (ClientProtocolException e) {
     cse = new CloudServersException();
     cse.setMessage(e.getLocalizedMessage());
   } catch (IOException e) {
     cse = new CloudServersException();
     cse.setMessage(e.getLocalizedMessage());
   } catch (ParserConfigurationException e) {
     cse = new CloudServersException();
     cse.setMessage(e.getLocalizedMessage());
   } catch (SAXException e) {
     cse = new CloudServersException();
     cse.setMessage(e.getLocalizedMessage());
   } catch (FactoryConfigurationError e) {
     cse = new CloudServersException();
     cse.setMessage(e.getLocalizedMessage());
   }
   return cse;
 }
 // This method is executed in the background thread on our Survey object
 private String uploadSurveyData(String myXML) {
   // Set up communication with the server
   DefaultHttpClient client = new DefaultHttpClient();
   String result = null;
   //
   HttpPost httpPost;
   httpPost =
       new HttpPost(
           "http://YOUR DOMAIN HERE/survey-webApp/index.php/webUser_Controllers/android_controller/save_survey_xml");
   try {
     // Encode the xml, add header and set it to POST request
     StringEntity entity = new StringEntity(myXML, HTTP.UTF_8);
     // entity.setContentType("text/xml");
     httpPost.setEntity(entity);
     // Execute POST request and get response
     HttpResponse response = client.execute(httpPost);
     HttpEntity responseEntity = response.getEntity();
     // System.out.print(EntityUtils.toString(responseEntity));
     // Set up XML parsing objects
     SAXParserFactory spf = SAXParserFactory.newInstance();
     SAXParser sp = spf.newSAXParser();
     XMLReader xr = sp.getXMLReader();
     // Set up an instance of our class to parse the status response
     HttpResponseHandler myResponseHandler = new HttpResponseHandler();
     xr.setContentHandler(myResponseHandler);
     xr.parse(retrieveInputStream(responseEntity));
     // check myResponseHandler for response
     result = myResponseHandler.getStatus();
   } catch (Exception e) {
     result = "Exception - " + e.getMessage();
   }
   return result;
 }
Ejemplo n.º 21
0
 private void processCommentLines(File file) throws SAXException, IOException {
   SAXParser parser = newSaxParser(false);
   XMLReader xmlReader = parser.getXMLReader();
   commentHandler = new CommentHandler();
   xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", commentHandler);
   parser.parse(FileUtils.openInputStream(file), commentHandler);
 }
Ejemplo n.º 22
0
  private void fetchComments() {
    try {
      final URL newUrl = new URL(book.get().getCommentsUrl());

      // sax stuff
      final SAXParserFactory factory = SAXParserFactory.newInstance();
      final SAXParser parser = factory.newSAXParser();

      final XMLReader reader = parser.getXMLReader();

      // initialize our parser logic
      final CommentsHandler commentsHandler = new CommentsHandler(book.get().getComments());
      reader.setContentHandler(commentsHandler);

      // get the xml feed
      reader.parse(new InputSource(newUrl.openStream()));
    } catch (MalformedURLException e) {
      COMMENTS_ERROR = MALFORMED_URL;
      Log.e(TAG, "MalformedURLException: " + e + "\nIn fetchComments()");
    } catch (ParserConfigurationException pce) {
      COMMENTS_ERROR = PARSER_CONFIG_ERROR;
      Log.e(TAG, "ParserConfigurationException: " + pce + "\nIn fetchComments()");
    } catch (SAXException se) {
      COMMENTS_ERROR = SAX_ERROR;
      Log.e(TAG, "SAXException: " + se + "\nIn fetchComments()");
    } catch (IOException ioe) {
      COMMENTS_ERROR = IO_ERROR;
      Log.e(TAG, "IOException: " + ioe + "\nIn fetchComments()");
    }
  }
Ejemplo n.º 23
0
  private RSSFeed getFeed(String urlToRssFeed) {
    try {
      // setup the url
      URL url = new URL(urlToRssFeed);

      // create the factory
      SAXParserFactory factory = SAXParserFactory.newInstance();
      // create a parser
      SAXParser parser = factory.newSAXParser();

      // create the reader (scanner)
      XMLReader xmlreader = parser.getXMLReader();
      // instantiate our handler
      RSSHandler theRssHandler = new RSSHandler();
      // assign our handler
      xmlreader.setContentHandler(theRssHandler);
      // get our data via the url class
      InputSource is = new InputSource(url.openStream());
      // perform the synchronous parse
      xmlreader.parse(is);
      // get the results - should be a fully populated RSSFeed instance,
      // or null on error
      return theRssHandler.getFeed();
    } catch (Exception ee) {
      // if we have a problem, simply return null
      return null;
    }
  }
Ejemplo n.º 24
0
  @Override
  protected RssItem doInBackground(RssParser... params) {

    RssParser parser = params[0];
    RssItem item = null;

    try {
      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();
      XMLReader xr = sp.getXMLReader();
      xr.setContentHandler(parser);

      // chamar arquivo xml
      // xr.parse(new InputSource(activity.getAssets().open("image_of_the_day.xml")));

      // chamar link na internet
      URL url = new URL("http://www.nasa.gov/rss/dyn/image_of_the_day.rss");
      xr.parse(new InputSource(url.openConnection().getInputStream()));

      item = parser.getFirstItem();
      if (item != null) {
        /*item.setImagem(
        BitmapFactory.decodeResource(
        		activity.getResources(), R.drawable.image_of_the_day));*/
        item.setImagem(getBitmap(item.getImagemUrl()));
      }

    } catch (Exception e) {
      e.printStackTrace();
    }

    return item;
  }
Ejemplo n.º 25
0
  /** Simple ctor */
  public StringSAXEventProvider(String xmlstr) throws ParserConfigurationException, SAXException {
    this.xmlstr = xmlstr;

    SAXParserFactory fact = SAXParserFactory.newInstance();
    SAXParser parser = fact.newSAXParser();

    reader = parser.getXMLReader();
  }
Ejemplo n.º 26
0
  /**
   * 通过XSD(XML Schema)校验XML
   *
   * @throws FileNotFoundException
   */
  public boolean validateXMLByXSD(String testXSD, String xmlFileName) throws FileNotFoundException {
    //        String xmlFileName = "Q:\\_dev_stu\\xsdtest\\src\\note.xml";
    String xsdFileName = "E:/datashare/" + testXSD;
    FileInputStream fls = new FileInputStream(new File(xmlFileName));
    try {

      // 创建默认的XML错误处理器
      XMLErrorHandler errorHandler = new XMLErrorHandler();
      // 获取基于 SAX 的解析器的实例
      SAXParserFactory factory = SAXParserFactory.newInstance();
      // 解析器在解析时验证 XML 内容。
      factory.setValidating(true);
      // 指定由此代码生成的解析器将提供对 XML 名称空间的支持。
      factory.setNamespaceAware(true);
      // 使用当前配置的工厂参数创建 SAXParser 的一个新实例。
      SAXParser parser = factory.newSAXParser();
      // 创建一个读取工具
      SAXReader xmlReader = new SAXReader();
      // 获取要校验xml文档实例
      Document xmlDocument = (Document) xmlReader.read(fls);
      // 设置 XMLReader 的基础实现中的特定属性。核心功能和属性列表可以在
      // [url]http://sax.sourceforge.net/?selected=get-set[/url] 中找到。
      parser.setProperty(
          "http://java.sun.com/xml/jaxp/properties/schemaLanguage",
          "http://www.w3.org/2001/XMLSchema");
      parser.setProperty(
          "http://java.sun.com/xml/jaxp/properties/schemaSource", "file:" + xsdFileName);
      // 创建一个SAXValidator校验工具,并设置校验工具的属性
      SAXValidator validator = new SAXValidator(parser.getXMLReader());
      // 设置校验工具的错误处理器,当发生错误时,可以从处理器对象中得到错误信息。
      validator.setErrorHandler(errorHandler);
      // 校验
      validator.validate(xmlDocument);

      XMLWriter writer = new XMLWriter(OutputFormat.createPrettyPrint());
      // 如果错误信息不为空,说明校验失败,打印错误信息
      if (errorHandler.getErrors().hasContent()) {
        System.out.println("XML文件校验失败!");
        writer.write(errorHandler.getErrors());
        return false;
      } else {
        System.out.println("XML文件校验成功!");
        return true;
      }
    } catch (Exception ex) {
      System.out.println(
          "XML文件: " + xmlFileName + " 通过XSD文件:" + xsdFileName + "检验失败。\n原因: " + ex.getMessage());
      // ex.printStackTrace();
      return false;
    } finally {
      try {
        fls.close();
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
Ejemplo n.º 27
0
 /**
  * Read this shared strings table from an XML file.
  *
  * @param is The input stream containing the XML document.
  * @throws IOException if an error occurs while reading.
  * @throws SAXException
  * @throws ParserConfigurationException
  */
 public void readFrom(InputStream is)
     throws IOException, SAXException, ParserConfigurationException {
   InputSource sheetSource = new InputSource(is);
   SAXParserFactory saxFactory = SAXParserFactory.newInstance();
   SAXParser saxParser = saxFactory.newSAXParser();
   XMLReader sheetParser = saxParser.getXMLReader();
   sheetParser.setContentHandler(this);
   sheetParser.parse(sheetSource);
 }
Ejemplo n.º 28
0
 /**
  * Validates given XML file using specified schema.
  *
  * @param fileUrl the URL of the file to be validated.
  * @param schemaUrl the URL of the schema to be used.
  * @throws ParserConfigurationException if parser is badly configured.
  * @throws IOException if the schema does not exist.
  * @throws SAXException if the schema is malformed.
  */
 public void validate(URL fileUrl, URL schemaUrl)
     throws SAXException, ParserConfigurationException, IOException {
   Verifier verifier = getVerifier(schemaUrl);
   XMLReader reader = saxParser.getXMLReader();
   InputSource source = new InputSource(fileUrl.toString());
   reader.setContentHandler(verifier);
   reader.setDTDHandler(verifier);
   reader.parse(source);
 }
 /*
  * Main method to parse specific MetaData file.
  */
 public Collection<Designate> doParse() throws IOException, SAXException {
   _dp_xmlReader = _dp_parser.getXMLReader();
   _dp_xmlReader.setContentHandler(new RootHandler());
   _dp_xmlReader.setErrorHandler(new MyErrorHandler(System.err));
   InputStream is = _dp_url.openStream();
   InputSource isource = new InputSource(is);
   logger.log(LogService.LOG_DEBUG, "Starting to parse " + _dp_url); // $NON-NLS-1$		
   _dp_xmlReader.parse(isource);
   return designates;
 }
Ejemplo n.º 30
0
 public static XMLReader newXMLReader(XMLUtils.ParserConfiguration parserConfiguration) {
   final SAXParser saxParser = XMLUtils.newSAXParser(parserConfiguration);
   try {
     final XMLReader xmlReader = saxParser.getXMLReader();
     xmlReader.setEntityResolver(XMLUtils.ENTITY_RESOLVER);
     xmlReader.setErrorHandler(XMLUtils.ERROR_HANDLER);
     return xmlReader;
   } catch (Exception e) {
     throw new OXFException(e);
   }
 }