akquinet StAnD components

STAND is a set of components interacting to make your development more efficient. STAND's components cover everything from the development phase to the runtime phase via testing and delivery. This page explains the principal benefits of STAND across the lifetime of your application.

 

Bootstrap a new project in less than 5 minutes

STAND allows you to bootstrap a new project in less than five minutes. Relying on akquinet maven-android-archetypes, you get a ready-to-use project containing:

  • The main application
  • A project configured to test your application (integration-test)
  • A configured release process to deliver a Marketplace-ready Android application

The resulting project is ready to be run on your device or inside an emulator.

Other STAND components are also pre-configured directly, so you benefit from all the features without any cumbersome configuration.

Build your application in a reliable and independent way

STAND makes the choice to rely on Apache Maven to build the application. Apache Maven offers a lot of advantages for Android application development over the traditional Eclipse development or Apache Ant, such as:

  1. It can be integrated on a continuous integration server, allowing continuous testing and nightly-build delivery
  2. It provides a strict release process avoiding errors and inconsistencies. The resulting APKs are ‘marketplace-ready’
  3. It also provides a common way to build and package applications
  4. It supports modular development, allowing the integration of classes and resources from other projects

STAND relies on the maven-android-plugin to build applications, but it also extends it to improve the modularity and so the reuse of Android components among several projects.

Simplify the development model

As soon as your application grows, the Android development model starts to be quite cumbersome. Asynchronous tasks, communication with other components such as services, threading issues and connectivity disruption are just the most well-known issues. However, there are a lot of areas where the Android development model makes even simple things quite hard to achieve. StAnD relies on akquinet Roboject, a simple and extensible injection framework simplifying the development model. Thanks to a couple of annotations, your code is then completely managed by Roboject, reducing the amont of code required in order to (list definitely not exhaustive):

  • Bind to services, and be notified when all the services are bound
  • Inject views, intent extras, resources and assets
@InjectLayout("R.layout.myLayout")
public class Example extends RobojectActivity {
    @Inject(AdderService.class)
    private AdderBinder adder;

    @InjectView
    private TextView theTextView;

    @InjectView("R.id.theTextView")
    private TextView theTextViewExplicitId;

    private int result;

    @override
    public void onServicesConnected() {
        // AdderService is connected and binder object 
        // was returned.
        // Code here is executed in background thread.
        // Used for time-consuming tasks like complex
        // computations or database access.
        result = adder.add(3,4);
    }

    @Override
    public void onReady() {
        // Code is executed in UI thread 
        // after onServicesConnected.
        // Use to configure views.
        theTextView.setText("3 + 4 = " + result);
    }
}

Developing with Roboject drastically reduces the boilerplace code you need in Android. Moreover, the footprint is small and you won't see any difference in terms of performance.

Improve the logging

Logging is a stringent requirement during the development of any application. However, Android logging suffers from a couple of flaws:

  • Logging cannot be disabled completely (which is required for the marketplace)
  • The log level cannot be configured per logger (i.e. tag)

STAND is using akquinet Androlog to improve the logging. Androlog's loggers are enabled only inside your development environment; on end-user phones, the logging is disabled. It supports advanced configuration and provides an extended API, making logging even easier.

package my.application;

import de.akquinet.android.androlog.Log;
import android.app.Activity;
import android.os.Bundle;

public class MyActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Initializes androlog
        // This will read /sdcard/my.application.properties
        Log.init(this);

        // Log a message
        Log.i(this, "This is a logged message");

        setContentView(R.layout.main);
    }
}

Using Androlog not only improves your logging, but also your reporting!

Test your application

Android supports integration testing. However, it becomes rather complex when your application uses several activities and services. Moreover, testing complete scenarios spread over several views is challenging. STAND supports and automates the running of unit tests, integration tests and story tests. To simplify the writing of integration and story tests, STAND relies on akquinet Marvin, a library which reduces the boilerplate code to deeply test Android applications.

public void testValidAuth() throws Exception {
    activity().view().withId(R.id.username).setText("testuser");
    activity().view().withId(R.id.password).setText("testpw");

    activity().view().withId(R.id.buttonSubmit).click();

    NextActivity nextActivity = await().activity(
        NextActivity.class, 10, TimeUnit.SECONDS);
    assertThat(nextActivity, notNullValue());
    assertThat(activity(nextActivity).view().
        withId(R.id.nextActivityContent), hasText("success"));
}

Using Marvin makes your tests more reliable, powerful and easier to write.

Continuously integrate and test your application

Nowadays, the benefits of continuous integration are well-known. By compiling, packaging and testing your application peridocially, you improve its quality and increase your confidence in it. STAND supports continuous integration and allows you to test your application on several Android versions, with different parameters such as languages and screen densities. STAND eases the configuration of such test matrices and is able to create and deploy nighly-build versions of your application, that you can deliver regularly.

To support continuous integration, STAND is using Jenkins and a custom Android STAND plugin.

Make your application Marketplace-ready

STAND integrates a release process, making it easy to release Marketplace-ready applications. The release process takes care of all the preparation required to publish your application to the Marketplace. It can also obfuscate your code using ProGuard. Thanks to the STAND release process, releasing is no longer a painful step in your development process. All the safeguards are already configured, and it will warn you of any problems.

Get feedback

Android supports crash reporting, but the reports are limited to the stack trace and a message written by the user (generally empty). STAND provides more sophisticated reporting support, with:

  • The stack trace
  • The log (even if it's disabled)
  • Device information
  • No private data

Moreover, the report can either be sent by email or uploaded to a backend server. Reports can also be triggered by your application, when errors and misbehavior are detected. Thanks to this reporting support, you can more easily find and fix the issues, and so improve the quality of your application.

Build enterprise applications

Enterprise applications have different requirements regarding deployment, security and communication with the backend system. STAND provides several components to build enterprise solutions on Android:

  • Delivery Portal: Manage your users and deliver/update/manage your application over the air.
  • Advanced Backend Connector: Ease the communication with your backend using REST, Web Services, JSON or ProtoBuf. Several encryption methods are supported, as well as using Cloud services.
  • Synchronization: Keep the data from the field device in sync with the backend, supporting offline mode and merge.
  • Privacy Storage: Improve the security of your data on the device through encryption and making the data private to your application.

Thanks to STAND, you can easily build enterprise solutions based on Android.