So maybe I should share some techniques/tips on how to improve the UX.

1) Analyze

Do some analysis on your current (or future) UX design. As designer and/or developer we tend to think we know everything, but we don’t. Your application may be used differently than you might think.
Knowing how users are using or will use your application is valid information in making a good UX design, as the focus is, and always should be, the user.

• Do usability tests to discover problems or bottle-necks in your design. This can be done by actually sitting down with a user and observe his/her behavior while he/she is using your application or prototype.
• Use analyzing tools like Google analytics to find how user are using your application, so you know the user focus (or lack of) inside your application.
• Or just look around how people are using there device to know basic human-device interaction. A good example might be when you application is using the camera as feature. You’ve probably seen that “selfiesticks” are becoming more populair, so your application might be needing front-camera support as well.
• And finally have a look at user reviews in Google Play. They might supply you with vital information on how to make your users happy (and getting good ratings at the same time).

2) (Re)Think

It might be a good idea to have a second (or third) look at your current UX design and re-think.
Try to look for these bad UX omens:

• Additional texts to explain how it elements work. You can’t document your way out of confusing UX.
• Novel paradigms. Stick to known patterns, so users feel quickly at ease.
• FAQ section. The information presented to the user should be obvious and clear.
• “Pop-ups”, like a confirm dialog. Don’t block the UX. Don’t say that something is dangerous if you can’t fix the danger. Do support “undo”.
• Too much information. Keep it simple (is always the hardest to do).

So how can you test if your new UX is wel thought out you may ask, well:

• You might want to prototype your new UX design first in stead of rewriting your app. This is quick and easy to do and can test if your redesign has been improved.
• Try doing A/B testing so you can compare the new design against your current one. Testing eliminates guesswork and turns “I think” into “I know”.

3) Adapt

As described in the previous section it’s important to stick to known patterns, so the user can quickly become acquainted with your application features.
Adapting platform standards is the way to go. And Google has done a great job with the introduction of Material Design, by suppling us with well thought out UX design patterns.
Learn these pattern and apply them to your UX design.
One question I get asked a lot is when an application is adapting Material design will it still contain its uniqueness and will my branding survive. My answer is yes.

• The application or product icon.
• Use of colors.
• And the actual application itself, meaning your brand should be reflected in the application.

Let me explain this by giving you an example giving to me by Marie Schweiz about her redesign of the Top Gear application.
The succes of Top Gear (brand) is not the cars, but the three guys hosting it and the fun they have with cars. This should be reflected in the UX design, so make if playful.

4) Add

It might sounds strange, adding features to transform UX design, but it’s not. Let me be clear, I’m not talking about adding more content but adding features like feedback, value and user aid.
So you can add:

	Interaction feedback, which gives the user confidence that he/she is using the content correctly
	Error feedback, which warns the user and a possible solution. But be careful not to block the user while giving this type of feedback.
	Loading feedback, which gives the user options, should I wait or just continue. Again don’t block the user.
	Action aid, which gives the the user the option to “undo stupidity”

If you want to know more, you may want to visit:

• Google Material design introduction
• User testing explained, part 1
• User testing explained, part 2
• Android UI/UX website by Taylor Ling
• Android UI patterns website by Juhani Lehtimäki
• Udacity course: UX Design for Mobile Developers
• Google design Youtube channel

I really want to thank my friend and colleague Ali Derbane for reviewing this post

During Droidcon Italy Stephan Linzner from Google explained upcoming features in the Android Testing Support Library. Lets have a closer look at some:

Test Filtering

If you want to suppress a test to run on certain target Api levels, just add the @SdkSuppress annotation.

You can also filter tests to only run on a (physical) device by adding the @RequiresDevice annotation.

ActivityTestRule

Because ActivityInstrumentationTestCase2 will become deprecated you need to define a @Rule.

Rules allow very flexible addition or redefinition of the behavior of each test method in a test class

So in your test add a @Rule annotation, and create an ActivityTestRule for your Activity

Now create your ActivityTestRule

Espresso-Intents

Espresso-Intents is like Mockito but for Intent, basically hermetic inter-app testing.
To give you an example, lets say in your application when a user presses a “call” button, you want to know if the correct data will be send to the Intent.ACTION_CALL.

So first create an IntentsTestRule and then verify that the Intent was sent using Espresso-Intents

So now you know…

All code can be found in android-testing github:

• ActivityTestRule Sample
• IntentsBasicSample
• General Espresso Github samples by Google

Thanks Stephan Linzner for the resources. #HappyTesting

Introduction

Introduced at the GTAC in 2013, Espresso is designed to be used in environments where the developers write their own tests, and makes it possible to write concise, beautiful, and reliable Android UI tests quickly.
Espresso has several general components:

• The Espresso class offers the onView and onData methods which, alone, can be used for a good numbers of possible tests on a given interface.
• ViewMatchers contains a collection of objects that implements the interface Matcher <? super View>. Using this Class you can collect and check View elements. For example, getting a View element (Button) with text “7”.
• ViewActions contains a collection of viewAction objects to perform actions on a view. These actions are passed to the method ViewInteraction.perform and may contain multiple actions. For example, clicking on a View element (Button).
• ViewAssertions contains a collection of ViewAssertion to conduct checks on views.

To illustrate these components a test can look like this:

And the good news, as of last year Google has introduced a Testing Support Library containing Espresso. So lets start by implementing Espresso.

Define the test runner

To use Espresso we first need to define who is running the tests. Espresso uses a new runner named AndroidJUnitRunner. This runner, based on InstrumentationTestRunner and GoogleInstrumentationTestRunner, runs JUnit3 and JUnit4 tests against your Android application.

First add the dependencies to your build.gradle, assuming you have installed the Testing Support Library.

Then add the runner in your build.gradleandroid.defaultConfig configuration:

Writing the test

As you may know test classes must be in src\androidTest\com.example.package.tests, com.example.package being the package specified in the package attribute of the manifest element in the AndroidManifest file. 
Also each test class must extend the abstract class ActivityInstrumentationTestCase2 and supply the Test Activity as generic type that will be used by default for testing.
It must also be passed to the superclass via the super(). To make the Test Activity being called by the test framework, simply define a setup which calls the synchronous method getActivity().

As mentioned we want to check if ‘6’ x ‘7’ equals ‘42’.

You may have noticed, this example is using static imports. This is solely done to make the code more readable.

Other actions you want to use are:

• pressBack(); to simulate the use of the “back” button,
• isDisplayed(); to check if an element is being shown and
• scrollTo(); to scroll to an element.

Running the test

Now lets do the fun part, lets run the test. This can be done from the command line with he command line with gradle connectedAndroidTest or using Android Studio by:

1. Open Run menu | Edit Configurations
2. Add a new Android Tests configuration
3. Choose the module you are testing
4. Define our test runner: android.support.test.runner.AndroidJUnitRunner

So now you know a bit more about Espresso. If you want to know more, you may want to visit:

• Espresso website
• Github repo corresponding to this article
• General Espresso Github samples by Google

Updated (08-04) When running the tests with gradle you can just use gradle connectedAndroidTest

Beside your APK there are some additional artifacts you want/need to save, and you want gradle to do this. Most common ones are Javadoc, your source files and perhaps your proguard generated files like the mapping file.

I naturally wanted a Gradle task to handle this. So lets have a look as some tasks you may want to use.

Adding Javadoc archive tasks

The following will add tasks to generate Javadocs for each build type and assemble it into a jar archive .

When added to your build.gradle file, generate your Javadoc jar archive from the command line with gradle generateReleaseJavadocJar.

Adding Source archive tasks

The following will add tasks to assemble a jar archive containing the Java sources.

When added to your build.gradle file, generate your Sources jar archive from the command line with gradle generateReleaseSourcesJar.

Adding Proguard archive tasks

The following will add tasks to assemble a zip archive containing the generated proguard files.

When added to your build.gradle file, generate your Proguard zip archive from the command line with gradle generateReleaseProguardFilesJar.

The library is a unbundled static testing library for Android that containers all Android testing frameworks by Google. It will become a available through the Android Support repository and as open source in AOSP.

So what does it contain?

• AndroidJUnitRunner
  This Runner, based on android.test.InstrumentationTestRunner, runs JUnit3 and JUnit4 tests against an Android package (application). Let me give an example:
  @RunWith (JUnit4.class)
  public class MyJUnit4Test {
  {
    Droidcon mDroidconUK;
   
    @Before
    public void setUp() {
      mDroidconUK = new Droidcons.get(Droidcon.UK);
      mDroidconUK.open();
    }
  
    @Test
    public void checkPreconditions() {
      assertNotNull("mDroidconUK cannot be null", mDroidconUK);
    }
  
    @After
    public void tearDown() {
      mDroidconUK.close();
    }
  }

• Espresso
  Introduced at the GTAC in 2013, Espresso makes it possible to write concise, beautiful, and reliable Android UI tests quickly. Lets look at some examples:
  // Find view using a Matcher and type text using a ViewAction
  onView(withId(R.id.message_edit_text)).perform(typeText(TEXT_MESSAGE), closeSoftKeyboard());
  
  // Perform a click ViewAction
  onView(withId(R.id.send_button)).perform(click());
  
  // Verify using a ViewAssertion
  onView(withId(R.id.received_message_text_view)).check(matches(withText((TEXT_MESSAGE))));

• Intento
  Intento is like Mockito but for Intents. Basically a mock framework that allows you to create and configure mock objects. Let me give you an example:
  public void testDailerInput_typeNumberAndCall() {
   
    //Type phonenumber in dialer
    onView(withId(R.id.send_data_to_call_edit_text)).perform(scrollTo(), typeText("123-345-6789"), closeSoftKeyboard());
   
    // Click the call button
    onView(withId(R.id.send_to_call_button)).perform(scrollTo(), click());
   
    //Validate Intent has been send
    intended(allOf(
        hasAction(Intent.ACTION_CALL),
        toPackage("com.android.phone"),
        hasData(allOf(hasSchemaSpecificPart("tel", "123-345-6789")))),
        times(1));
  }

In conclusion: Testing with Android is finally becoming a more prominent part of Android Development cycle with the introduction of the Android Testing Support Library

Taking pictures and video or getting information from the internet seems to be the biggest need for the first time Google Glass users.
But the technology that Google Glass provides is much bigger, and it is already being trailed in different industries. So what are some real-world applications that are already being developed

1. Healthcare

Using Google Glass in healthcare has a big potential. Not only for the specialist, but also for patients and students. Google Glass can be applied in different settings. During operative procedures, outside the hospital like trauma-helicopter and during house calls. Radboud UMC (The Netherlands) are doing research on the use of Google Glass in the operating room. Using the video footage that is being live streamed shows the surgeons perspective and is useful for medical students and colleagues. And asking a colleague in another location (or country perhaps) to have a look while operating is made possible.

Helping nurses or doctors to identify patients so up-to-date information is always at hand (or eye) which increases the efficiency of staff and accuracy of treatment given to patients.

We are currently testing a Glass application called MedicAR which combines augmented reality and Google Glass to improve the simulation and teaching of certain procedures in surgery and patient care.

Talking about augmented reality

2. Augmented Reality

Google Glass and the use of AR (augmented reality) allows you to enhance the user experience and support the customer with additional information to better serve their needs. Maybe a few years from now we will be living in an AR world. Google Glass applications will be available to highlight the health benefits of foods and any promotions while shopping. Google Glass retail assistants will be able to help customers by providing information on products and check stock levels.

Layar has created a Google Glass application to view their AR content. It allows the consumer to look at geo location information, view movie trailers right from the poster and accessing extra content hidden away in magazines.

3. Assistance for the disabled

Google Glass has the potential to make life-changing differences for those with disabilities. Because Google Glass is voice activated, it can be incredibly beneficial. The hands-free form factor allows paraplegics to easily stay connected without using their hands.

With facial analytics, it’s possible to, with the subject’s approval, have Google Glass scan a face and put up a green light if the person is intrigued, yellow if they’re confused or red if they’re bored.
This helps those with conditions such as Agnosia to make sense of facial expressions.

Google Glass is also being used to help those who, or know people that are blind or deaf. The Smartsign app is designed to enhance communication between parents and their deaf children. It can be difficult for parents to keep up with children who may be learning sign language at a rapid pace and this can disrupt communication. The application allows parents to look up words so they can communicate effectively, instead of having to consult a nearby book or computer.

4. Logistics

Already warehouse managers and trucking companies have tools to monitor stock levels and positioning, but Google Glass can offer more effective, compact and less obtrusive ways to collect the (real time) data. The camera will play a pivotal role – allowing to scan barcodes and NFC tags to identify packages, bring up order records and verify the location. The benefits are that operations can move faster and safer as handlers have both hands available.

5. Public service

Imagine the police wearing Google Glass, supplying them with critical information at the right moment. Scanning a numberplate to know if the driver has a firearm is useful information to protect the user, or prevent bad situations. Firefighter Patrick Jackson created a Google Glass that can show nearby hydrants at the location of the incident. In the near future his application can provide him with vital information, like building blueprints, floor plans and emergency exits, before he even enters the building.

In conclusion

In my opinion probably every industry would have some use for Google Glass. New (business) cases will emerge from trial and error as early adopters discover what works and what doesn’t. And with any new technology, it’s important to carefully evaluate whether or not the potential benefits make sense to you and/or your organization.
In essence, the technology that Google Glass provides is easily learned by Android developers but like most revolutionary technologies the main challenge is finding useful applications.

Introduction

Glass was designed to be used everyday and everywhere as content provider, so having a easy and clear UX is essential.
Its UX is remarkably consistent with the UX of other Google products: crisp and flat.
Controlling Glass through voice commands, navigating from the touch-sensitive side or using the camera button on top, are all done with ease.
Lets have a closer look at some of these UX features.

Home

The home card is the starting point for all things Glass, and from this screen, you can invoke Glass through voice activation.
A user can activate the home card, and basically use Glass by either tapping the touchpad or tilting ones head (up).
Why they chose to add this feature, I still don’t know, but using this “head wake up” only enhances the weirdness of wearing Glass.

Lists

Talking about voice activation, when you actually want to have a look at some of the voice triggered actions, you first have to say the magic phrase “ok Glass”. Doing so will show you a list of voice commands that are available by default.

Timeline

The UI is driven by the timeline, a series of information cards displayed depending on what you’re doing and where you are in the timeline.
For example, to go to the previous cards (photos, messages, emails, etc.), you swipe from back to front, pulling up the past from behind you.
Cards associated with upcoming events, like Google Now cards for traffic, flights, restaurant recommendations, etc. are all ahead of you. So you swipe backward to pull those things into your view.

Conclusion

In conclusion, Google has managed to simplify the UX. The technology is there when they want it but out of the way when they don’t.
From an UX point of view it’s not really as consistent, and there is definitely a learning curve.
So Glass has still a long way to go, but is paving the way to new possibilities.

Up next: Glass, a Developers point of view.

So lets have a look at the device definition:

This setup is for a 720p resolution, for a 1080p you must change the resolution to 1920×1080 and the density from tvdpito xhdpi. Once the device definition is created, the next step is to create a new Android Virtual Device using it:

Updated (20-12) Another great Mobile year in review video.