Web Deploy is a great tool for deploying ASP.NET projects: it simplifies deployments, can target IIS 6 or 7, is pretty easy to get working on the server and the project side, and is supported by many hosting providers. It works really well when used along with continuous integration. In the first phase, the project is built and a Web Deploy package is made; the command used is (for example) “msbuild [something.sln or something.csproj or something.vbproj] /m /p:Configuration=release /p:DeployOnBuild=True /p:DeployTarget=Package /p:skipJsHint=true”. In the second phase, the Web Deploy package is deployed to servers for testing.

One of the problems I noticed was that a user could browse around the site and hit a compilation error. For instance, if there was a misspelled variable in an ASPX page, the user would get a standard “500″ error page.

One of the purposes of continuous integration, and build/testing systems in general, is to avoid such problems. If the code behind fails to compile, the team is notified immediately – but if the ASPX page fails to compile, we have to wait for a user to report the problem. That is not acceptable.

The aspnet_compiler tool is the solution to this problem. If you use ASP.NET MVC, your project’s MSBuild file will contain a target named “MVCBuildViews” that will run aspnet_compiler for you. Enabling the use of this target by setting the “MvcBuildViews” property makes the build take a bit longer, but there are less surprises – to me, the benefit far outweighs the cost.

So the first option is to simply enable “MvcBuildViews.” “MVCBuildViews” writes the precompiled files to the ASP.NET temporary directory (the precompiled output is not included in the Web Deploy package), so they’ll be used only by the system that invoked the target (in my case, the continuous integration server). So for server deployments, you get the benefit of knowing that the pages compiled (solving the original problem), but you don’t get the other major benefit of precompiling – the startup performance boost.

It turns that combining aspnet_compiler and Web Deploy is a bit tricky. I won’t go into the details, other than to say I figured it out and made an MSBuild target file that can be easily included into projects that use Web Deploy.

So, to get Web Deploy working with precompilation:

1. Grab Precompile.targets from my blog post and put it into the directory with your .csproj/.vbproj project file.
2. Modify your .csproj or .vbproj file, add <Import Project=”$(MSBuildProjectDirectory)\Precompile.targets” /> towards the end of the file.
3. In your project’s configuration, set the “AspNetCompiler” property to “true” for whatever configurations you want (I have it enabled for the “Release” configuration in my case).
4. If you also want to invoke aspnet_merge, you need to ensure the system that does the building has Visual Studio or the Windows SDK installed, then in your project’s configuration, set the “AspNetMerge” property to “true” for whatever configurations you want.

aspnet_merge is another interesting tool that merges assemblies. You can read about its benefits on the aspnet_merge MSDN page. I found that it is beneficial to use aspnet_merge almost always – the only problem I had was on one of my very large projects (with dozens of ASPX page and the total web site size being a few hundred megabytes), aspnet_merge took an exorbitantly long time. For example, on our normal project, it takes ~1 minute. On this very large project, it took over an hour.

This article has been cross-posted to my personal blog – please comment there.

“My goal is to omit everything superfluous so that the essential is shown to the best possible advantage”.

1. Good design is innovative: The possibilities for innovation are not, by any means, exhausted. Technological development is always offering new opportunities for innovative design. But innovative design always develops in tandem with innovative technology, and can never be an end in itself.
2. Good design makes a product useful: A product is bought to be used. It has to satisfy certain criteria, not only functional, but also psychological and aesthetic. Good design emphasizes the usefulness of a product whilst disregarding anything that could possibly detract from it.
3. Good design is aesthetic: The aesthetic quality of a product is integral to its usefulness because products we use every day affect our person and our well-being. But only well-executed objects can be beautiful.
4. Good design makes a product understandable: It clarifies the product’s structure. Better still, it can make the product talk. At best, it is self-explanatory.
5. Good design is unobtrusive: Products fulfilling a purpose are like tools. They are neither decorative objects nor works of art. Their design should therefore be both neutral and restrained, to leave room for the user’s self-expression.
6. Good design is honest: It does not make a product more innovative, powerful or valuable than it really is. It does not attempt to manipulate the consumer with promises that cannot be kept.
7. Good design is long-lasting: It avoids being fashionable and therefore never appears antiquated. Unlike fashionable design, it lasts many years – even in today’s throwaway society.
8. Good design is thorough, down to the last detail: Nothing must be arbitrary or left to chance. Care and accuracy in the design process show respect towards the consumer.
9. Good design is environmentally friendly: Design makes an important contribution to the preservation of the environment. It conserves resources and minimizes physical and visual pollution throughout the life cycle of the product.
10. Good design is as little design as possible: Less, but better – because it concentrates on the essential aspects, and the products are not burdened with non-essentials.  Back to purity, back to simplicity.

HTTP caching is both important, as it reduces bandwidth use and improves performance, and complex, as the rules are far from simple. In my experience, most Java and Android applications either don’t do HTTP caching, or they roll their own and up doing it wrong or in way too complicated a fashion. In other words, they create a non-standard, one off, unmaintainable solution. And IMHO, that’s no solution at all.

If you find yourself using HttpClient, you can use HttpClient-Cache, which is an easy drop in for Java. See my previous post about HttpClient-Cache for Android. But if you’re using HttpUrlConnection (aka java.net.URL.openConnection()), there’s no good solution for regular Java or Android. Well, in Android 4.0 and later, you can use HttpResponseCache, but with only a small percentage of Android devices using 4.0 or later, that’s not a terribly good solution. If you use Android 4.0+’s HttpResponseCache as recommended by Google, then all previous Android versions end up with no HTTP response caching – this causes excess load on your servers, slower performance for the app, and unnecessary bandwidth use.

To fix this problem, I grabbed all the code from AOSP that implements Android 4.0′s HttpResponseCache and made it a separate library. This library is easy to use, works on Java 1.5+, all versions of Android, and is licensed under APLv2 (just like everything else in AOSP). Really, there’s no reason not to use it! You can even use in Java server applications, such as those that use Spring.

To use it, if you’re using Maven, simply add this block to your pom.xml (all artifacts are in Maven Central):
<dependency>
<groupId>
<com.integralblue</groupId>
<artifactId>httpresponsecache</artifactId>
<version>1.0.0</version>
</dependency>
If you’re not using Maven, you’ll need to add the httpresponsecache jar and its dependency, disklrucache.jar, to your project.

When your application starts, before it makes any HTTP requests, execute this method:
com.integralblue.httpresponsecache.HttpResponseCache.install(File directory, long maxSize);
If you’re using Android, and you want to use Android 4.0′s HttpResponseCache if it’s available, and fallback to this library if it’s not available:
final long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
final File httpCacheDir = new File(getCacheDir(), "http");
try {
Class.forName("android.net.http.HttpResponseCache")
.getMethod("install", File.class, long.class)
.invoke(null, httpCacheDir, httpCacheSize);
} catch (Exception httpResponseCacheNotAvailable) {
Ln.d(httpResponseCacheNotAvailable, "android.net.http.HttpResponseCache not available, probably because we're running on a pre-ICS version of Android. Using c$
try{
com.integralblue.httpresponsecache.HttpResponseCache.install(httpCacheDir, httpCacheSize);
}catch(Exception e){
Ln.e(e, "Failed to set up com.integralblue.httpresponsecache.HttpResponseCache");
}
}

The source code to the library is available on GitHub. I’m already using it in my CallerID Android app. If you end up using this library, please leave me a comment.

That’s it – enjoy easy to use HTTP caching!

This article has been cross-posted to my personal blog – please comment there.

1. Just be chill and take it in.  It is best to observe and not ask a lot of questions. Typically in user testing, we are taught to prompt the user and ask questions.  In ethnography, it is best to be part of the group and engage in normal conversation. Remember – you are one of them.
2. Go often.  Don’t make assumptions off of minimal visits.  Often see how the environment or group changes based on other factors like time of day, weather, etc.
3. Participate and try it out . If you are studying how an ice cream scooper typically makes a banana split, try making one yourself. Then you can ask her about the job, but it is important to test it out yourself.
4. Don’t judge.  The thing or people you are studying may be different from you or your belief system.  That does not make it wrong, just different and that is why you are studying them.
5. What are other people reporting: Do a literature review. Are your findings consistent with what other people have found?  Check journals, websites, asking your peers, etc.

I recently had to add build time Javascript validation to an ASP.NET project. It took me quite a while to figure out how to do so in a (reasonably) maintainable, understandable way.

I’m using Visual Studio 2010, and the project targets .NET 3.5. The same approach would work fine if the project was targeting .NET 4.0.

I’m using NuGet to manage dependencies. The first thing I did was add node-jshint as a dependency of the project.

I opened the project’s file (something.csproj). I added a target:

<Target Name=”jshint”>
<ItemGroup>
<JavaScript Include=”@(Content)” Condition=”%(Extension) == ‘.js’” />
</ItemGroup>
<PropertyGroup>
<node-jshint>$(PackagesDir)\node-jshint.0.5.5</node-jshint>
</PropertyGroup>
<Exec Command=”&quot;$(node-jshint)\tools\jshint.bat&quot; &quot;%(JavaScript.FullPath)&quot; –reporter &quot;$(node-jshint)\tools\lib\vs_reporter.js&quot; –config &quot;$(MSBuildProjectDirectory)\jshintrc.json&quot;” ContinueOnError=”true” />
</Target>

Make BeforeBuild depend on jshint:

<Target Name=”BeforeBuild” DependsOnTargets=”jshint”>

Add a new text file to the root of project called “jshintrc.json” If the file is included in the Visual Studio project, make sure the build action is “None” so Visual Studio doesn’t try to do anything with it. The file contents should look like this. The latest available version of node-json at this time, 0.5.5, doesn’t deal with a Byte Order Markers (BOM) in the jshintrc.json file, so when saving it, be sure the BOM isn’t included.

Now whenever Visual Studio builds the project, JSHint errors will appear in the VS error list just like all other types of errors. It runs JSHint on all .js files included in your project as content (the way .js should be included in your project).

This article has been cross-posted to my personal blog – please comment there.

Women’s retailer Madewell released a unique take on a look book video last week where the user can choose their own fashion adventure through the interactive video, just like the old Choose Your Own Adventure books. It’s a fun and easy way to spend 5 or 35 minutes…far longer an engagement than a typical brand video. This longer engagement is a huge payoff , allowing the brand to stay in front of a potential customer longer, showing their product and stating their brand’s case. Madewell’s video joins a growing group of rich media such as Arcade Fire’s We Used to Wait video and Take this Lollipop that actively and personally engage users as opposed to having them passively watch. As HD video continues to become the main medium for creating engaging content, it will be interesting to see how more companies will seek to enhance the format and capture people’s attention.

Check out Madewell’s Choose Your Own Adventure here: http://www.madewell.com/pressplay.jsp

Chevy released this video at the beginning of November about two sons and their five year search for their father’s 1960′s Impala SS. He’d sold it in the 1980′s when times were tough for the family.  The brothers tracked down not only an identical Impala SS, but their father’s original one, truly a remarkable feat.

Kudos to Chevy on telling a great story, but more importantly in recognizing where their value is. General Motors and thus Chevy are in an interesting place currently, but their brand still resonates with people. Particularly from a nostalgia standpoint when American cars were king. To the people in this video, the Impala isn’t just a car, it’s an icon of their past, of achievement, of simpler times, and people they love. I think males even more so connect emotionally with car brands. The fact is brands aren’t always what we as marketers want them to be, they’re how people emotionally respond to them. Chevy appears to understand that, time will tell if they can rebuild on it. Do you think they can instill that connection in a new generation? I’m not sure people still feel that connection to modern cars.

A Week of Check-ins on the Path to One Billion from foursquare on Vimeo.

On Black Friday Patagonia ran a full page ad in the New York Times doing the inverse of every other retailer in existence, they told people not to buy their R2 jacket. Not content to just say that, they went on to tell readers exactly why they shouldn’t make the purchase listing the shockingly high environmental impact of each R2 they produce. It’s a bold move centering around their Common Threads Initiative aiming to get consumers to Reduce, Repair, Reuse, Recycle, and Reimagine.

While the campaign and initiative are ripe for calls of hypocrisy, Patagonia hasn’t been shy in proactively addressing the legitimate claim. It’s an interesting play by a company that truly does seem to care about the environment (as much as a for-profit manufacturer can). I think it’s a bold step forward for the outdoor industry that potentially sets a new benchmark and a line in the sand for other companies pledging a green agenda. What do you think? Is Patagonia walking the walk or just grabbing attention?

FITC//Screens-2011, Toronto! Wow …Yay!

My scheduled talks:
1. Android Open Accessory API, Pearl Chen – Karma-Laboratory.com
2. Creating Android Tablet Experiences, Greg Carron and Matthew Patience – Mobicartel.com
3. From Desktop to Android in a Flash, Hod Greenly, Samsung
4. Honeycomb Development 101, Faisal Abid, Andspot
5. Get your application optimized for Honeycomb, Hod Greenly, Samsung
6. Ponycorns: Catching lightning in a jar, Ryab Creighton, Ponycorns- Sissy’s magical Ponycorn adventures

Some of my highlights:
1. Android Open Accessory API, Pearl Chen
Kicked-off my Android sessions with the Android Open Accessory API talk, by Pearl Chen from Karma-Laboratory.com . If you’re into robotics and have heard about Arduino boards…then you’re gonna have fun!

The Open Accessory API, allows android-devices to interact with external USB devices in a special “accessory” mode. The ADK (Android Development Kit) includes the Arduino software and firmware for the Arduino board, CapSense library, and the ADK itself with additional firmware and goodies!

So, if you’re tired of making those lights blink with your Arduino board, give the ADK a ride!

Peal Chen - Karma-Laboratory.com

Android Robot built using Android Open Accessory API

Further info: http://developer.android.com/guide/topics/usb/adk.html

2. Creating Android Tablet Experiences,Greg Carron and Matthew Patience, Mobicartel.com
Matthew and Greg demonstrated two of their in-house products, LovePlus and Twithaus.
LovePlus uses the Google+ API for creating a social meeting place for daters alike. Twithaus, is a twitter client which sports a social-gaming spin where users can play space invaders, with spaceships representing their friends!

6. Ponycorns: Catching lightning in a jar, Ryab Creighton, Untolentainment
Rayn Creighton, gives a personal account of how he came up with the idea with his 5-year old daughter for Ponycorns- Sissy’s magical Ponycorn adventures. It’s a delightful and inspirational father-daughter story showing that David(s) can truimph over Goliath(s) in the big world of game development, but also lessons learnt about the do’s & dont’s of commercializing software.

Overall impressions:
FITC//Screens-2011, was an awesome event highlighting the latest in mobile development…..and hey….how about those cupcakes! :-)

Are you a developer, entrepreneur or startup looking to create the next generation of mobile interactive technologies? The Isobar Create 32 NFC Hackathon @ APPNATION III might be remembered as the tipping point - the pivotal two days - when Near Field Communication (NFC) technology became more than a promise.

And you might be remembered as somebody who made it happen.

• NFC for a Cause
• NFC and Non-NFC Enabled Devices
• NFC in the NFL (& other sports)
• NFC and the Environment
• NFC for Business
• NFC for Play
• NFC for Media
• NFC for Cars

• Impact on a brand or a business (e.g., does it increase sales, improve customer retention, etc.)
• Impact on consumers (e.g., does it fundamentally change the way consumers behave)
• Commercial viability and market potential (e.g., does it have the ability to succeed and be profitable)
• The 'like never before' factor (e.g., novelty value and overall coolness of the idea)

1. If you're looking for a team to develop something with, arrive by 7:30am so you have time to mingle and hook up or ask us to help you.
2. We'll get started at 8:00am sharp. Michael Nicholas, Chief Strategy Offer at Isobar, will kick things off with some opening remarks, including a brief look at Isobar, who we are, what we do, why we're hosting this event, and what we hope to see from the teams.
3. At 8:15am, we'll welcome Damien Balsan, Director of NFC Business Development at Nokia and NFC guru to the stage. Damien will provide an overview of NFC technology and showcase some of the NFC apps working today all around the world.
4. At 8:45am, Isobar's Director of Mobile, Yuval Zukerman, will provide information about all the tools that will be at your disposal.
5. Then, finally, at 9:00am, coding will begin.
6. We'll feed you and water you and Red Bull you throughout the 32 hours. We'll also have a couple of couches if you need a nap.
7. At 4:00pm on Thursday 12/1, everyone stops coding. Each team will have five minutes to present their work to the audience -- and the judges. Then we'll go our separate ways for an hour or so. We think you'll go home and clean yourselves up!
8. At 5:30 on Thursday 12/1, we'll reveal the top 3 apps created during the hackathon and hand out prizes and respect to the winners.

Today, Isobar announced it has been recognized with 10 industry awards – including an OMMA Award, an Ad Club Hatch Award, five W³ awards and three WebAwards – for its innovation and dedication to bringing people and brands together like never before.

The OMMA Awards, which celebrate the year’s best in online media, marketing and advertising, recognized Isobar’s innovative work on “Dolby Update Theater” with an award for Online Advertising Creativity in the Social: App as Advertising category. The campaign showed consumers how Dolby makes virtually any media experience more real and amazing, thanks to a live event on the Dolby Facebook page where every member of Dolby’s Facebook community had their Facebook status update submitted for consideration by the original Batman, Adam West. The best status updates were read by West and offered to their authors as a “More Intense and Entertaining” version of their status update to post on their wall. The campaign generated a 500 percent increase in fans of Dolby’s Facebook page and a 50 percent increase in posting activity.

Isobar was also honored with five W³ Awards for its creative excellence on the Web, including two Gold Awards for itsadidas Climacool Ride and Yahoo! Sports Grudge Judge campaigns.  Isobar helped adidas make Climacool Ride its most successful launch of the year with a multi-platform campaign that included print, out-of home, online ads, and a revolutionary user-controlled, 3D mobile experience that fully demonstrated the 360° ventilation offered by the shoe.  Isobar’s work for Yahoo! Sports, also recognized at the Hatch Club awards, went beyond a campaign, providing a platform where fans can settle burning sports arguments once and for all by putting their cases to vote among the Facebook community.  Isobar also picked up three Silver W³ awards for its viral video campaign for the adidas TechFit Compression Jersey Launch, a Facebook launch for adidas’ new adiZero 5-Star football cleat, and for the aforementioned Dolby Update Theater campaign.

Isobar’s recent work was also celebrated by the WebAwards, the premier annual website award competition that recognizes the people and organizations responsible for some of the most effective and best web sites on the Internet today.  Isobar’s work on adidas miCoach, Tauck.com and a website for a global pharmaceutical company garnered awards for Outstanding Website in the consumer packaged goods, travel and healthcare categories respectively.

“It’s an honor to receive such significant accolades in some of digital marketing’s most prestigious awards,” said Darryl Gehly, president, Isobar U.S. “With consumers more connected than ever before and battling information overload, it is crucial that brands build new and engaging experiences to capture and hold their target audience’s attention. We’re excited to be recognized as an agency behind campaigns that are pushing the boundaries of digital marketing and helping bring brands and people together like never before.”

Isobar is proud to announce that we’ve won 2 Gold awards in the 2011 W³ Awards!

Adidas Climacool Ride won a Gold Award in the Integrated Campaign-Consumer Goods Category, and Yahoo! Sports Grudge Judge won a Gold Award in the Integrated Campaign – Sports Category.

The W³ Awards recognizes creative excellence on the web and the creative and marketing geniuses that made it all happen. Isobar is proud to be a part of a group of such outstanding winners!

Many Android applications access the Internet resources over HTTP (and my projects are no exception). There are 2 common ways to do that: use Apache HttpClient 4.x (which is included in Android) or use HttpURLConnection (from Java). Google stated in a September 29, 2011 blog post that they prefer you use HttpURLConnection, but many apps and a large number of Java libraries already use HttpClient and won’t be changing soon (if ever). So HttpClient is here to stay.

With that in mind, the performance and footprint of HttpClient can vary widely based on how its set up. Here are my recommendations:

• Always use one HttpClient instance for your entire application. HttpClient is not free to instantiate – each additional instance takes time to create and uses more memory. However, more importantly, using one instance allows HttpClient to pool and reuse connections along with other optimizations that can make big differences in how your application performs.
• Use a thread safe connection manager. If you’re using one global HttpClient, it will be accessed by multiple threads concurrently – so if you don’t use a thread safe connection manager, Bad Things will happen.
• Use Android’s android.net.SSLCertificateSocketFactory and android.net.SSLSessionCache if they’re available. Using these instead of the base HttpClient SSLSocketFactory will reduce round trips when connecting to the same https site multiple times, making your application feel faster.
• Set the user agent to something useful. That way, the server’s logs will be far more useful, which may save you (or someone else) a lot of time later if (when) a problem occurs.

With all that said, here’s how I get my global HttpClient instance. This code should work on all Android versions (it should even work all the way back to 1.0 – if anyone cares). I use Google Guice‘s Provider interface and injection to get the application, but you can easily adopt this to a form that doesn’t use Guice.

import java.lang.reflect.Method;
import java.util.Locale;

import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.scheme.SocketFactory;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;

import android.app.Application;
import android.content.Context;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Build;
import android.util.Log;

import com.google.inject.Inject;
import com.google.inject.Provider;

public class HttpClientProvider implements Provider {
	@Inject
	Application application;

    // Wait this many milliseconds max for the TCP connection to be established
    private static final int CONNECTION_TIMEOUT = 60 * 1000;

    // Wait this many milliseconds max for the server to send us data once the connection has been established
    private static final int SO_TIMEOUT = 5 * 60 * 1000;

    private String getUserAgent(String defaultHttpClientUserAgent){
    	String versionName;
		try {
			versionName = application.getPackageManager().getPackageInfo(
					application.getPackageName(), 0).versionName;
		} catch (NameNotFoundException e) {
			throw new RuntimeException(e);
		}
		StringBuilder ret = new StringBuilder();
		ret.append(application.getPackageName());
		ret.append("/");
		ret.append(versionName);
		ret.append(" (");
		ret.append("Linux; U; Android ");
		ret.append(Build.VERSION.RELEASE);
		ret.append("; ");
		ret.append(Locale.getDefault());
		ret.append("; ");
		ret.append(Build.PRODUCT);
		ret.append(")");
		if(defaultHttpClientUserAgent!=null){
			ret.append(" ");
			ret.append(defaultHttpClientUserAgent);
		}
		return ret.toString();
    }

	@Override
	public HttpClient get() {
		AbstractHttpClient client = new DefaultHttpClient(){
		    @Override
		    protected ClientConnectionManager createClientConnectionManager() {
		        SchemeRegistry registry = new SchemeRegistry();
		        registry.register(
		                new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		        registry.register(
		                new Scheme("https", getHttpsSocketFactory(), 443));
		        HttpParams params = getParams();
		        HttpConnectionParams.setConnectionTimeout(params, CONNECTION_TIMEOUT);
		        HttpConnectionParams.setSoTimeout(params, SO_TIMEOUT);
		        HttpProtocolParams.setUserAgent(params, getUserAgent(HttpProtocolParams.getUserAgent(params)));
		        return new ThreadSafeClientConnManager(params, registry);
		    }

		    /** Gets an HTTPS socket factory with SSL Session Caching if such support is available, otherwise falls back to a non-caching factory
		     * @return
		     */
		    protected SocketFactory getHttpsSocketFactory(){
				try {
					Class< ?> sslSessionCacheClass = Class.forName("android.net.SSLSessionCache");
			    	Object sslSessionCache = sslSessionCacheClass.getConstructor(Context.class).newInstance(application);
			    	Method getHttpSocketFactory = Class.forName("android.net.SSLCertificateSocketFactory").getMethod("getHttpSocketFactory", new Class< ?>[]{int.class, sslSessionCacheClass});
			    	return (SocketFactory) getHttpSocketFactory.invoke(null, CONNECTION_TIMEOUT, sslSessionCache);
				}catch(Exception e){
					Log.e("HttpClientProvider", "Unable to use android.net.SSLCertificateSocketFactory to get a SSL session caching socket factory, falling back to a non-caching socket factory",e);
					return SSLSocketFactory.getSocketFactory();
				}

		    }
		};
        return client;
	}

}

I use this approach in my CallerID app (source) and an upcoming app (that I cannot yet talk about). I’ve also submitted patches (which have been accepted) to reddit is fun, so it will use this approach in its next version.

This article has been cross-posted to my personal blog – please comment there.