RemediationInstruction.java

/*
 * Copyright (C) 2013 Tobias Brunner
 * Hochschule fuer Technik Rapperswil
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * for more details.
 */

package org.strongswan.android.logic.imc;

import java.io.IOException;
import java.io.StringReader;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import android.os.Parcel;
import android.os.Parcelable;
import android.util.Xml;

public class RemediationInstruction implements Parcelable
{
	private String mTitle;
	private String mDescription;
	private String mHeader;
	private final List<String> mItems = new LinkedList<String>();

	@Override
	public int describeContents()
	{
		return 0;
	}

	@Override
	public void writeToParcel(Parcel dest, int flags)
	{
		dest.writeString(mTitle);
		dest.writeString(mDescription);
		dest.writeString(mHeader);
		dest.writeStringList(mItems);
	}

	public static final Parcelable.Creator<RemediationInstruction> CREATOR = new Creator<RemediationInstruction>() {

		@Override
		public RemediationInstruction[] newArray(int size)
		{
			return new RemediationInstruction[size];
		}

		@Override
		public RemediationInstruction createFromParcel(Parcel source)
		{
			return new RemediationInstruction(source);
		}
	};

	private RemediationInstruction()
	{
	}

	private RemediationInstruction(Parcel source)
	{
		mTitle = source.readString();
		mDescription = source.readString();
		mHeader = source.readString();
		source.readStringList(mItems);
	}

	public String getTitle()
	{
		return mTitle;
	}

	private void setTitle(String title)
	{
		mTitle = title;
	}

	public String getDescription()
	{
		return mDescription;
	}

	private void setDescription(String description)
	{
		mDescription = description;
	}

	public String getHeader()
	{
		return mHeader;
	}

	private void setHeader(String header)
	{
		mHeader = header;
	}

	public List<String> getItems()
	{
		return Collections.unmodifiableList(mItems);
	}

	private void addItem(String item)
	{
		mItems.add(item);
	}

	/**
	 * Create a list of RemediationInstruction objects from the given XML data.
	 *
	 * @param xml XML data
	 * @return list of RemediationInstruction objects
	 */
	public static List<RemediationInstruction> fromXml(String xml)
	{
		List<RemediationInstruction> instructions = new LinkedList<RemediationInstruction>();
		XmlPullParser parser = Xml.newPullParser();
		try
		{
			parser.setInput(new StringReader(xml));
			parser.nextTag();
			readInstructions(parser, instructions);
		}
		catch (XmlPullParserException e)
		{
			e.printStackTrace();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		return instructions;
	}

	/**
	 * Read a <remediationinstructions> element and store the extracted
	 * RemediationInstruction objects in the given list.
	 *
	 * @param parser
	 * @param instructions
	 * @throws XmlPullParserException
	 * @throws IOException
	 */
	private static void readInstructions(XmlPullParser parser, List<RemediationInstruction> instructions) throws XmlPullParserException, IOException
	{
		parser.require(XmlPullParser.START_TAG, null, "remediationinstructions");
		while (parser.next() != XmlPullParser.END_TAG)
		{
			if (parser.getEventType() != XmlPullParser.START_TAG)
			{
				continue;
			}
			if (parser.getName().equals("instruction"))
			{
				RemediationInstruction instruction = new RemediationInstruction();
				readInstruction(parser, instruction);
				instructions.add(instruction);
			}
			else
			{
				skipTag(parser);
			}
		}
	}

	/**
	 * Read an <instruction> element and store the information in the
	 * given RemediationInstruction object.
	 *
	 * @param parser
	 * @param instruction
	 * @throws XmlPullParserException
	 * @throws IOException
	 */
	private static void readInstruction(XmlPullParser parser, RemediationInstruction instruction) throws XmlPullParserException, IOException
	{
		parser.require(XmlPullParser.START_TAG, null, "instruction");
		while (parser.next() != XmlPullParser.END_TAG)
		{
			if (parser.getEventType() != XmlPullParser.START_TAG)
			{
				continue;
			}
			String name = parser.getName();
			if (name.equals("title"))
			{
				instruction.setTitle(parser.nextText());
			}
			else if (name.equals("description"))
			{
				instruction.setDescription(parser.nextText());
			}
			else if (name.equals("itemsheader"))
			{
				instruction.setHeader(parser.nextText());
			}
			else if (name.equals("items"))
			{
				readItems(parser, instruction);
			}
			else
			{
				skipTag(parser);
			}
		}
	}

	/**
	 * Read all items of an <items> node and add them to the given
	 * RemediationInstruction object.
	 *
	 * @param parser
	 * @param instruction
	 * @throws XmlPullParserException
	 * @throws IOException
	 */
	private static void readItems(XmlPullParser parser, RemediationInstruction instruction) throws XmlPullParserException, IOException
	{
		while (parser.next() != XmlPullParser.END_TAG)
		{
			if (parser.getEventType() != XmlPullParser.START_TAG)
			{
				continue;
			}
			if (parser.getName().equals("item"))
			{
				instruction.addItem(parser.nextText());
			}
			else
			{
				skipTag(parser);
			}
		}
	}

	/**
	 * Skip the current tag and all child elements.
	 *
	 * @param parser
	 * @throws XmlPullParserException
	 * @throws IOException
	 */
	private static void skipTag(XmlPullParser parser) throws XmlPullParserException, IOException
	{
		int depth = 1;

		parser.require(XmlPullParser.START_TAG, null, null);
		while (depth != 0)
		{
			switch (parser.next())
			{
				case XmlPullParser.END_TAG:
					depth--;
					break;
				case XmlPullParser.START_TAG:
					depth++;
					break;
			}
		}
	}
}