Kah - The Developer

[Android] Downloading and Displaying RSS Content

kahgoh — Tue, 13 Dec 2011 12:18:38 +0000

RSS feeds list the latest content added to a site. The sample in this post demonstrates how to obtain RSS content and display the latest item. It will cover:

Downloading the RSS
Extract an item
Display the content

The sample code can be downloaded from the GitHub repository.

Downloading the RSS

To download RSS content, the app must first have the INTERNET permission. Declaring this in the manifest:

...

    ...
    
...

The demo activity contains only a WebView, so it may as well download the content when the activity starts:

protected void onStart() {
    super.onStart();

    // Downloading the RSS feed needs to be done on a separate thread.
    Thread downloadThread = new Thread(new Runnable() {

        public void run() {
            try {
                updateView(getLatestContent(retrieveRssDocument()));
            } catch (Exception e) {
                Log.e("Content Retriever", e.getLocalizedMessage(), e);
            }
        }
    });

    downloadThread.start();
}

Note that because obtaining data over HTTP can be slow, it must be done on a separate thread. Failure to do so may result in a NetworkOnMainThreadException (at least for API 11 anyway).

To download the content, create an URL based on the location of the RSS content and call its openConnection method and extract the content from an InputStream. Since RSS uses the XML format, the content is read into a Document:

private Document retrieveRssDocument() throws IOException,
        ParserConfigurationException, SAXException {

    URL url = new URL(source);
    URLConnection connection = url.openConnection();
    InputStream inStream = connection.getInputStream();

    try {
        DocumentBuilder builder = DocumentBuilderFactory.newInstance()
                .newDocumentBuilder();
        return builder.parse(new BufferedInputStream(inStream));
    } finally {
        inStream.close();
    }
}

Extract an item

RSS uses the XML format and its specification can be found on the RSS Advisory Board. Here is small sample of RSS content:



   
      ...(Name for RSS channel)...
      ...(Link to the site)...
      ...(description for the channel)...

      
         ...(item title)...
         ...(URL to the story)...
         ...(sample content)...
         ...(when the item was published)...
         ...(string to identify the item)...
      

      ...(possibly more items)...

An _item_ represents the content that has been added, such as a post, comment or article. Earlier, the content has already been read into a Document. From this, we can extract the _description_ of the first _item_:

private String getLatestContent(Document document) throws IOException,
        ParserConfigurationException, SAXException {

    NodeList nodeList = document.getElementsByTagName("item");
    int length = nodeList.getLength();
    if (length > 0) {
        return getDescriptionContent(nodeList.item(0));
    }

    return null;
}

private String getDescriptionContent(Node root) {
    if (root instanceof Element) {
        Element asElement = (Element) root;
        if (asElement.getTagName().equalsIgnoreCase("description")) {
            return asElement.getTextContent();
        }
    }

    NodeList children = root.getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
        Node node = children.item(i);
        String result = getDescriptionContent(node);
        if (result != null) {
            return result;
        }
    }
    return null;
}

Display the content

Finally, displaying the content is as simple as setting the content of a view! The description of the items from some RSS feeds may contain HTML. For a WebView, the content may be loaded like this:

private void updateView(final String content) {
    final WebView view = (WebView) findViewById(R.id.content);
    view.loadData("" + content + "",
            "text/html", null);
}

[Java] Specifying the column widths of a JTable as percentages

kahgoh — Sun, 30 Oct 2011 08:41:25 +0000

The widths of the columns of a JTable are specified through TableColumn.setWidth. To set the widths of the columns as percentage, set the widths of column in proportion to each other. For example:

private static JTable createTable() {
    JTable table = new JTable(1, 3);
    TableColumnModel model = table.getColumnModel();

    model.getColumn(0).setHeaderValue("20 %");
    model.getColumn(1).setHeaderValue("30 %");
    model.getColumn(2).setHeaderValue("50 %");

    setWidthAsPercentages(table, 0.20, 0.30, 0.50);
    TableModel tableModel = table.getModel();

    tableModel.setValueAt("First Column", 0, 0);
    tableModel.setValueAt("Second Column", 0, 1);
    tableModel.setValueAt("Third Column", 0, 2);
}

/**
 * Set the width of the columns as percentages.
 * 
 * @param table
 *            the {@link JTable} whose columns will be set
 * @param percentages
 *            the widths of the columns as percentages; note: this method
 *            does NOT verify that all percentages add up to 100% and for
 *            the columns to appear properly, it is recommended that the
 *            widths for ALL columns be specified
 */
private static void setWidthAsPercentages(JTable table,
        double... percentages) {
    final double factor = 10000;

    TableColumnModel model = table.getColumnModel();
    for (int columnIndex = 0; columnIndex < percentages.length; columnIndex++) {
        TableColumn column = model.getColumn(columnIndex);
        column.setPreferredWidth((int) (percentages[columnIndex] * factor));
    }
}

The percentage can be specified in the range from 0 to 1 (with 0 being 0% and 1 being 100%) or the range from 0 to 100. Note that the above implementation of setWidthAsPercentages relies that the widths for ALL columns are specified. It also relies a value of factor that is sufficiently large to guarantee that the total of the widths is greater than the width of the table. If the sum of the column widths is less than the table’s initial width, some of the columns will be expanded. Yet, when the total is greater than the table’s widths, the columns widths are reduced in the required fashion.

This means you would need to ensure that the initial width of the table is less than 10000 and if changes are made later, this value may need to be revised. If the table is being placed in a JScrollPane, you could use getPreferredScrollableViewportSize instead:

    ...
    final double factor = table.getPreferredScrollableViewportSize().getWidth();
    ...

Interesting, a factor that is too large can cause the table headings to be rendererd incorrectly. When factor is changed to Double.MAX_VALUE, the table is rendered like this when it is first loaded:

Admittedly, I have do yet fully understand why this happens when (however, I think there could be an overflow when Java is performing the calculations for laying out the table). When this happens, you can get the headings to appear by moving the mouse over them. When using the view port size, beware that the default viewport size happens to be 450 x 400 and is coded into the JTable‘s initializeLocalVars method (at least for Oracle Java) – so it is possible for the value to differ between different Java implementations.

[Java] Getting Combo Box Renderers to Look Consistent with Other Combo Boxes

kahgoh — Tue, 20 Sep 2011 12:29:21 +0000

One way of controlling the text in a JComboBox is to provide a custom ListCellRenderer. I have seen implementations that subclass a concrete implementation (such as DefaultListCellRenderer or the BasicComboBoxRenderer). Generally though, I find that the combo boxes using such renderers can appear inconsistent with another combo box that may not have a renderer set or one that extends a different implementation. To illustrate the inconsistency that could happen, I prepared a small test program that you can download from my Github repository. It displays a number of combo boxes that are based on different renderers. Just running it produces the following dialog in Windows 7:

For reference, the following table describes the types of renderers that are displayed:

Combo Box	Renderer
Unchanged	No custom renderer. This is how the combo box would normally appear if renderer is set.
Basic	A custom renderer that is based on BasicComboBoxRenderer.
Substance	A custom renderer that is based on Substance’s default list cell renderer (SubstanceDefaultListCellRenderer).
Static Default	Based on DefaultListCellRenderer.
Refreshing Default	A renderer that is also based on DefaultListCellRenderer, but the renderer is reset each time the look and feel is changed.
Static Delegate	A custom renderer that will delegates to the implementation that would normally be used in a combo box.
Refreshing Delegate	A custom renderer that also delegates to an implementation that would normally be used in a combo box. However, it will also update the renderer that it delegates to when the look and feel is changed.

The Unchanged combo box is the reference and would be how the combo boxes would normally appear, if you did not change the renderer. It can be seen that the Basic combo box appears to with a different background, whereas the Substance appears to indent its contents. Next, the results of changing to one of the Substance look and feels:

Now the Substance and Refreshing Delegate renderers appear consistent with the unchanged and the Static Delegate does not appear to have the same indent (more on the delegate renderers later). From these, it should be obvious that changing the renderers will effect how the combo boxes will appear on the screen. If you had a custom render that extended one of base implementations (e.g. , BasicComboBoxRenderer or SubstanceDefaultListCellRenderer, you might have to change it to extend a different implementation when you change the application’s look and feel and makes it harder to reuse the renderer across different applications that use different look and feels.

Avoiding a Custom Renderer

Normally, a JComboBox will get its renderer through an UI object that implements ComboBoxUI(see JComboBox.setUI()). In most cases, this is also a subclass of BasicComboBoxUI, which provides the renderer through createRenderer(). By overriding this method, different look and feels can provide their own renderers. But, according to the Javadocs for createRenderer(), it is used only “if a renderer has not been explicitly set with setRenderer“. So, one way of achieving a consistent look is to never to change the renderer. In this case, you would have to override the object’s toString() method to control the text in the combo box. If you want to put objects from an external library into a combo box, you could “wrap” them into one that you define (of course, you could also consider extending the class of the object and override toString(), but this will only work if the class of the object is not final). For example, the look and feel combo box in the above examples uses this method. The following listing is an extract that shows how it is implemented:

private static JComboBox lnfComboBox() {
    final JComboBox skinSelector = new JComboBox();

    // ...
    for (LookAndFeelInfo lookAndFeel : UIManager.getInstalledLookAndFeels()) {
        LnfLoader item = standard(lookAndFeel);
        skinSelector.addItem(item);
        // ...
    }

    // ...
    
    for (SkinInfo skin : skins.values()) {
        LnfLoader item = substance(skin);
        skinSelector.addItem(item);
        // ...
    }

    // ...
    return skinSelector
}

// ...
private static LnfLoader standard(final LookAndFeelInfo lookAndFeel) {
    return new LnfLoader() {

        // ... 
        public String toString() {
            return lookAndFeel.getName();
        }
    };
}

// ...
private static LnfLoader substance(final SkinInfo skin) {
    return new LnfLoader() {

        // ... 
        public String toString() {
            return skin.getDisplayName();
        }
    };
}

// ...

Of course this only works if you want to control only the text in the combo box. If you want to change other aspects (such as the background or the icon), you will still need to provide your own renderer and some people may prefer to change the renderer instead. Next, we will have a look at the Static Delegate and the Refreshing Delegate renderers and how they help to produce a consistent looking combo box.

The Static Delegate Renderer

This renderer works by creating a custom renderer that translates the object into text and uses an original renderer to render the contents. In using this approach, it will appear as if the original renderer was being used. This is how the renderer is created and implemented:

public void installRenderer(JComboBox comboBox) {
    final ListCellRenderer original = new JComboBox()
            .getRenderer();
    comboBox.setRenderer(new ListCellRenderer() {

        public Component getListCellRendererComponent(
                JList list, Fruit value,
                int index, boolean isSelected, boolean cellHasFocus) {

            return original.getListCellRendererComponent(list,
                    nameOf(value), index, isSelected, cellHasFocus);
        }
    });
}

This approach works in cases where the renderer is created and set after the look and feel is set and does not change. In one of the above screenshots the renderer produces an inconsistent look, but it was produced by starting the application with a Windows look and feel and then was changed to Substance. This happens because the combo box’s UI class provides Substance’s renderer, which chooses to render its contents differently to the standard ones. However, if the demo was modified to start with Substance instead, then Static Delegate will delegate to a Substance renderer:

The Refreshing Delegate Renderer

The Refreshing Delegate solves the problem of the changing look and feel by updating the delegate renderer when ever the look and feel is changed:

public class DelegatingRenderer implements ListCellRenderer {

	// ...
	public static void install(JComboBox comboBox) {
		DelegatingRenderer renderer = new DelegatingRenderer(comboBox);
		renderer.initialise();
		comboBox.setRenderer(renderer);
	}

    // ...
	private final JComboBox comboBox;

	// ...
	private ListCellRenderer delegate;

	// ...
	private DelegatingRenderer(JComboBox comboBox) {
		this.comboBox = comboBox;
	}

	// ...
	private void initialise() {
		delegate = new JComboBox().getRenderer();
		comboBox.addPropertyChangeListener("UI", new PropertyChangeListener() {

			public void propertyChange(PropertyChangeEvent evt) {
				delegate = new JComboBox().getRenderer();
			}
		});
	}

	// ...
	public Component getListCellRendererComponent(JList list,
			Fruit value, int index, boolean isSelected, boolean cellHasFocus) {

		return delegate.getListCellRendererComponent(list, value.getName(),
				index, isSelected, cellHasFocus);
	}
}

The PropertyChangeListener listens for changes to the UI property. This is property that is fired when the new combo box’s UI is set (which is what happens when changing the look and feel). When triggered, it simply updates the delegate. In doing so, it will ensure that combo box will appear as if the renderer had not been changed and can also be reused, without modification, in another application that may have a different look and feel.

[Android] Using Frame Animation to Recreate the Flashing Arrow

kahgoh — Wed, 27 Jul 2011 12:51:29 +0000

Previously, I wrote about creating a simple animation of a flashing arrow using timers to hide and display a view at regular intervals (see A Simple Way To Make View Flash on Top of Another View). Another way to do this is to use Frame Animation, which is created by displaying a series of frames. Frame animation is actually covered in the Android Dev Guide, under View Animation. Here, using the same steps as described in the guide, the animation of the flashing arrow from the previous post is recreated.

First, we need to place the contents of each of the frames in a Drawable resource. This animation requires only two frames – one to show the arrow and another to completely hide it. The image for the first frame is easily taken from the example from last post. Using an image editor, the second frame is created from a copy of the first frame by completely erasing its contents. The resulting images can then be added as image resources.

With images in place, the Frame Animation, is defined in an frame animation resource XML file. The file is stored in the drawable resource (i.e. “res/drawable”) directory.

The oneshot attribute in the tag is set to false so that the animation is repeated. If it was set to true, the animation would run only once. The tags define each frame. Note that they refer to another image resource and that the duration are specified in milliseconds.

If the main layout is defined in an XML layout, the frame animation resource can referenced just like any other drawable resource. The main layout XML from the previous tutorial can be updated so that the ImageView holds the animation instead of the arrow image. With the animation was defined in a file called flashing.xml, the layout XML would now contain something like this:

...


...

To start the animation in the Activity, get a hold of the AnimationDrawable from the ImageView and call the start. Use the stop method to stop the animation:

...
final AnimationDrawable animation = (AnimationDrawable) arrowView.getDrawable();

if (arrowView.getVisibility() != View.VISIBLE) {
    arrowView.setVisibility(View.VISIBLE);
}

if (animation.isRunning()) {
    animation.stop();
} else {
    animation.start();
}
...

The source code for my example can be downloaded from my GitHub repository.

[Android] A Simple Way To Make View Flash on Top of Another View

kahgoh — Fri, 24 Jun 2011 13:49:14 +0000

[Android] Simple Flashing a View on Top of Another View

Flashing an image is a simple animation that can be achieved by laying an image on top of another and toggling the visibility at regular intervals. In Android, a View can be placed on top of another View, with a FrameLayout. Views can also be hidden and displayed by changing its visibility, through setVisibility. To demonstrate this method, I’ve prepared a small example of an arrow that flashes over a rocket when the rocket is clicked (the rocket and arrow clipart were obtained from Open Clip Art Library). The source is available from my Github repository.

The main layout, defined by rocket.xml, contains the FrameLayout:

By positioning mentioning the rocketImage before the uparrowImage, the image of the arrow will be placed on top of the rocket. However, the XML also sets the arrow to be invisible, so the arrow will not be visible when this view is displayed.

To perform the flashing, the visibility of the arrow is toggled at regular intervals. The changing of the visibility status should be done on the UI thread (see the article Painless Threading). Since there is a defined interval between changing the visibility, I use postDelayed as follows:

    // ...

	private final OnClickListener trigger = new OnClickListener() {

		@Override
		public void onClick(View v) {
			arrowView.removeCallbacks(flashTask);
			flashTask.reset();
			postFlashTask();
		}
	};

    // ...

    private View arrowView;

    // ...

	/**
	 * Reposts the task to toggle the visibility after short interval.
	 */
	private void postFlashTask() {
		arrowView.postDelayed(flashTask, 250);
	}

	/**
	 * This is the {@link Runnable} that will toggle the visibility of the
	 * arrow. This can be configured to flash up a certain number of times.
	 */
	private class FlashTask implements Runnable {

		/**
		 * The number of times to flash before stopping.
		 */
		private int countDown = 0;

		/**
		 * Resets the {@link Runnable}, ready to flash the arrow a certain
		 * number of times again.
		 */
		public void reset() {
			countDown = 3;
		}

		@Override
		public void run() {
			if (arrowView.getVisibility() == View.VISIBLE) {
				arrowView.setVisibility(View.INVISIBLE);
				countDown--;
				if (countDown > 0) {
					// Can continue flashing.
					postFlashTask();
				}
			} else {
				arrowView.setVisibility(View.VISIBLE);

				// The arrow should should always finish in the invisible state.
				postFlashTask();
			}
		}
	}

    // ...

That is all there is to in this technique! Another possibility is to use ~~AlphaAnimation~~ frame animation as described in the View Animation section of the developer guide and version 3 introduces Property Animation, but I’ll leave that for another time. With the technique illustrated in this tutorial, you are not limited to ImageViews – you can also do this with other types of views.

[KVM] Installing Virtio drivers in a KVM Windows guest VM

kahgoh — Mon, 30 May 2011 15:07:09 +0000

KVM provides a Virtio interface for the virtual hard disk and NIC. To use them in a Windows guest VM, the drivers from Fedora (you only need the ISO file) must first be installed into Windows. To install them in a Windows guest VM, it must also be started with these interfaces so that Windows can detect them. While the Windows guest could be started with the Virtio NIC without any problems, we can not start with the Windows image (i.e. the virtual hard disk image where Windows is installed on your guest VM) using the Virtio hard disk interface (until the driver is installed, Windows will not know how to use the Virtio hard disk interface). The easiest solution to this problem is to create another virtual disk that can use Virtio:

qemu-img create -f qcow2

Now, start the Windows VM with the Virtio interfaces:

qemu-kvm \
    -hda  \
    -drive file=,if=virtio \
    -drive file=,media=cdrom,index=1 \
    -net nic,model=virtio \
    -net user \
    -boot d \
    -vga std \
    -m 1024

When Windows is loaded in your guest VM, go in to the Device Manager. Under Other Devices, there should be two entries – one for the SCSI controller to the the temporary virtual hard drive and the other for the Virtio network card.

On one of the items, right click on it and select Properties, go to the Driver tab. You should now see the following:

Click on Update Driver. In the next dialog, choose to specify a location and install the Red Hat Virtio drivers. The dialogs for installing the drivers will vary, depending on the installed version of Windows. It should be fairly easy to work how to install the drivers, but installing the drivers for Windows 7 and Windows XP are here if you need them ( skip to instructions for Windows 7).

Installing the Drivers on Windows XP

For Windows XP, choose Install from a list or specific location on the first prompt.

On the next set of options, choose Search for the best driver in these locations and ensure that Search removable media is ticked and click on Next again.

When installing the hard disk controller, you might be prompted, at this point, to choose a driver. At this point, choose the one in the wxp directory.

Eventually, you will probably be warned that you are installing an unsigned driver. Select Continue Anyway to install the driver.

When installation is complete, you should get a confirmation, similar to the following:

After repeating the steps for the other driver, you use the Virtio interface on your Windows hard disk image (see After Installing the Drivers…).

Installing the Drivers on Windows 7

For Windows 7, choose Browse my computer for driver software.

On the next screen, choose the drive for your CDROM. You should be able to let Windows search the CD for the drive.

When prompted, confirm that you want to install the driver.

There will be a confirmation that the driver was installed, similar to this one:

Close the dialog and repeat the steps for the other driver.

After Installing the Drivers…

After both drivers are installed, the device manager should contain a Red Hat VirtIO device for the SCSI controller and another one for the ethernet adapter.

Next time you start the guest VM, you can use the Virtio interface for the Windows image:

qemu-kvm \
    -drive file=,if=virtio \
    -net nic,model=virtio \
    -net user \
    -vga std \
    -m 1024

Your Windows VM is now using the Virtio interfaces for your Windows virtual hard drive and NIC. If you wish to know more about Virtio and how it works, I suggest having a read of the article Virtio: An I/O virtualization framework for Linux.

[Python] Creating Custom Cookies for HTTP Requests

kahgoh — Sat, 14 May 2011 15:28:00 +0000

One way of adding a custom cookie is to directly specify the "cookie" field in your request header. For example:

 
request.add_header("Cookie", "something=test+1+2+3; source=script")

Here, two cookies are set in the request ("something" and "source"). Notice that the cookies are fully specified in the string, instead of using urllib.urlencode. Another way of adding cookies is to create Cookie objects and add them to your CookieJar. Before sending your request, add the cookies by using add_cookie_header.

An example for Python 2.7:

from cookielib import Cookie
from cookielib import CookieJar
from urllib2 import Request
import urllib2
import urllib

'''
    Makes a cookie with provided name and value.
'''
def makeCookie(name, value):
    return Cookie(
        version=0, 
        name=name, 
        value=value,
        port=None, 
        port_specified=False,
        domain="kahdev.bur.st", 
        domain_specified=True, 
        domain_initial_dot=False,
        path="/", 
        path_specified=True,
        secure=False,
        expires=None,
        discard=False,
        comment=None,
        comment_url=None,
        rest=None
    )

# Create a cookie jar to store our custom cookies.
jar = CookieJar()

# Generate a request to make use of these cookies.
request = Request(url="http://kahdev.bur.st/python/cookies/receiver.php")

# Use makeCookie to generate a cookie and add it to the cookie jar.
jar.set_cookie(makeCookie("name", "kahdev"))
jar.set_cookie(makeCookie("where", "here"))

# Add the cookies from the jar to the request.
jar.add_cookie_header(request)

# Now, let us try open and read.
opener = urllib2.build_opener()
f = opener.open(request)

print "Server responds with: "
print f.read()

The above source can also be downloaded from my Github repository. If you run it, you should see the following output:

# python cookies.py
Server responds with: 
Cookies:
    [where] = [here] 
    [name] = [kahdev]

Note that the 2.7 documentation for Cookie indicates that you should not need to be doing this often:

It is not expected that users of cookielib construct their own Cookie instances. Instead, if necessary, call make_cookies() on a CookieJar instance.

However, the method make_cookies is for extracting cookies from HTTP responses.

[Python] Using Basic HTTP Authentication

kahgoh — Sat, 16 Apr 2011 02:19:04 +0000

To use urllib2 to access content that requires HTTP authentication, you need to create an OpenerDirector with a HTTPBasicAuthHandler. With HTTPBasicAuthHandler, add the authentication details by calling its add_password method. It takes in four parameters – realm, uri, user and passwd.

The user and passwd are, quite obviously, the user name and password. The uri specifies the location where the user name and password applies. If there is only one location, this is usually specified as a string. However, if it can also be applied to more locations, you specify the locations as a sequence. The realm is the name of protected area where the authentication is applied to. You can get the realm from your browser, by trying to access the protected area.

With the handler created, build an opener that uses this handler. Then, use the opener to access the protected site or webpage. For example:

import urllib2

authHandler = urllib2.HTTPBasicAuthHandler()
    
authHandler.add_password(
    realm="Protected Area",
    uri="http://local.intranet",
    # If there were multiple URIs then we can specify then like this:
    # uri = ["site1", "site2"]

    user="user", 
    passwd="my_password")
opener = urllib2.build_opener(authHandler)
    
content = opener.open("http://192.168.1.254")
print content.read()

[Android] Using Projects to Separate Content Provider from Application Code

kahgoh — Sat, 29 Jan 2011 04:38:38 +0000

Content providers can be used to store and share data between two or more applications. The applications are usually independent of each other and they do not need to know the content provider stores and retrieves its data. Instead of lumping all of them together in one project, I generally find it easier to work with when they are separated out into their own individual projects. In this example (downloadable from here), this is separated in to four projects:

CategoryEditor – Contains a ListActivity for editing the Categories.
CategoryField – Contains another activity that displays the Categories in a combo box.
CategoryProviderApi – Contains an API for other projects to make use of the content provider.
CategoryProviderImpl – Contains the content provider implementation.

The reason for this separation is because the activities in CategoryEditor and CategoryField do not need to know the implementation details of the content provider – how it stores its data and how it retrieves it. All they require is the information contained in CategoryProviderApi. In fact, CategoryProviderApi contains only a single class that provides constants for the other applications to access the content provider.

To use this kind of structure, the CategoryProviderApi must first be marked as a library. This is done via the Android properties:

Next, the other projects are referencing this project (including CategoryProviderImpl). In the Android properties in each of the projects, they need to add CategoryProviderApi

We also have to declare the content provider in an AndroidManifest.xml file. With the projects separated like this, we could still place this information inside the manifest for CategoryProviderImpl. The manifest would look something like this:

However, this would make CategoryProviderImpl look like another application and you would have to install this into the emulator or phone separately from the other applications.

Alternatively, we could make CategoryProviderImpl another library and have one of the project’s manifest declare the provider. However, this would require the application declaring the content provider to be installed first. Furthermore, if the user chooses to uninstall the application declaring the content provider, than the other application will no longer have access to the same content provider. Unfortunately, I’m not aware of any other solutions that do not have this draw backs. Please, feel free to leave a comment if you do know of a better way or suggestions.

[Maven] Placing Third Party Libraries in your own Repository

kahgoh — Sat, 25 Dec 2010 05:50:43 +0000

Although the public repositories for Maven contains a vast collection of third party libraries. Despite this, there are some libraries that you would be able to find in them. Fortunately, you can place the library into your local repository or set up your own internal repository. If you are setting up a large internal repository, you might consider using a repository manager, such as Archiva. However, if you do not want to install one, you can set your own internal repository or place it directly in your private repository.

Installing to your personal local repository

Use the install plugin to install the files directly into the personal local repository (usually, ~/.m2/repository or c:\Documents and Settings\\.m2\repository). Use the install-file goal to place specific files from third party libraries. The structure of the command:

mvn install:install-file \
    -Dfile= \
    -DartifactId= \
    -DgroupId= \
    -Dpackaging= \
    -Dversion=

The above command assumes that your personal local repository is in the default path (as mentioned before, either ~/.m2/repository or c:\Documents and Settings\\.m2\repository). If it is in a different location, you need to provide it in the localRepositoryPath parameter. This can also be used to place the artifact in an internal repository.

If the artifact has any dependencies that may not be directly referenced by the your project, you will also have to add them into the repository. You should also edit the generated pom to include the dependency.

Deploying the artifact to the repository

The deploy can also be used to add artifacts to a repository. Unlike the install plugin, it does not assume a default location for the respository. Instead, you must specify the repository location, using the url parameter.

mvn deploy:deploy-file \
    -Dfile= \
    -DartifactId= \
    -DgroupId= \
    -Dpackaging= \
    -Dversion= \
    -Durl=

It is important to note that url parameter is expecting a full url path, including the protocol. If the repository is a location within the file system, you should specify it with file://. The localRepositoryPath parameter for install already expects a file system path and does not require the protocol to be specified. If the artifact has any dependencies on any other artifacts, you will need to edit the pom generated for the artifact.

Manually adding the artifact to the repository

When you add artifacts using either the install or deploy plugins, these steps are performed. To add the artifact manually, you must first set up the appropriate directory structure in the repository. The directory structure is related to the group id of the artifact and is set up in a way that is similar to how directory structure to represent Java packages. For example, if the group id was org.example.project, the directory structure would look like this:

repository root
|
+- org
 |
 +- example
  |
  +- project

For group ids that do not use the dot notation, you would only need a single directory to represent the group id. At end of the directory structure (e.g. the project directory in the above example), you will need to create a directory for each of the artifacts. The name of the directory will correspond to the artifact id. Inside the artifact directory, you also need to create a directory per version of the artifact. For example, if you were adding version 1.0.1 of an artifact with the id sample in the above example, your directory structure would now be:

repository root
|
+- org
 |
 +- example
  |
  +- project
   |
   +- sample
    |
    +- 1.0.1

The artifact is placed in the directory representing the version. However, its file name needs to be in the following format:

-.

Following on from the example, if the artifact was a jar file, the file name would be sample-1.0.1.jar. Finally, set up a pom file for the artifact. The file name for the pom should follow the same format (e.g. sample-1.0.1.pom).

Once the pom is set up, you should be able to start pulling the artifact from the repository. As mentioned before, the install and deploy plugins will do all this for you. However, they also generate the hashes for the poms and the artifacts, a few other files. If you wish you could also manually create these files, but is not really necessary to start using the artifact from the repository.