App Development for Android in 2017: Challenges and Solutions

Since Android OS took over the world, it’s hard to imagine the outsourcing niche without a mobile app development. Usually, the launching of the app is a quite time-consuming process. When a company decides to make an enterprise application, it is needed here and now. That’s why the mechanism of building hybrid or native apps for Android usually requires using a third-party library to speed-up the process. Let’s take a look at the top-four of them, which are often used by mobile application developers nowadays and review their most interesting functions and possibilities.

Butter Knife

Butter Knife is a small library that is used to reduce the number of the code lines in your project and make it clear. The library doesn’t affect the final apk-file size. Butter Knife uses annotations to bind objects from an xml file with objects from application’s logic. Also, it binds some objects’ actions (for example, you click on the object or choose an item from the list) with the overall logic of an application. If you want to include this library in your project, write in your module’s gradle: Java

compile 'com.jakewharton:butterknife:8.4.0' annotationProcessor
 'com.jakewharton:butterknife-compiler:8.4.0'

After this action, Butter Knife library will be ready for use. In the example below, you can see how you can make the Button item bound with TextView item, performing a simple activity: when user clicks on the button, the text changes. Java

@BindView(R.id.text_view)
TextView textView;
@BindView(R.id.button)
Button button;

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ButterKnife.bind(this);
}

@OnClick(R.id.button)
public void onButtonClick()
{
    textView.setText("On Button Click");
}

As simple as that. You don’t need to use findViewById for each view item and don’t need to implement onClickListener and the respective methods onClick. You can also bind pre-defined resources with annotation. In our example it will look like: “Java”

@BindView(R.id.button)
Button button;
@BindString(R.string.text)
String text;

@OnClick(R.id.button)
public void onButtonClick()
{
    textView.setText(text);
}

Now our resource file contains string value text. If we need to add multiple translates for this value - we can duplicate the resource file as many times, as many languages we want to have in the app, and translate the needed information within each file into the foreign language. You can use ButterKnife.bind anywhere you would otherwise put findViewById calls. It means that you may use it in fragments, view holders, etc. This is only a tiny piece of what this library can do. If you are interested in the other possibilities of this one, just visit the official Butter Knife web-page and read more.

Glide

Glide is an image-loading and caching library for Android focused on smooth scrolling. If you need to display images, video stills or animated GIFs in your application - this library is for you. In order to include this library in your project, you need to write one row of code in your module’s gradle: Java

compile 'com.github.bumptech.glide:glide:3.7.0'

    // When you need to show an image, type-in this one:

    Glide
        .with(this)
        .load("https://lh6.ggpht.com/9SZhHdv4URtBzRmXpnWxZcYhkgTQurFuuQ8OR7WZ3R7fyTmha77dYkVvcuqMu3DLvMQ=w300")
        .into(imageView);

Where "https://lh6.ggpht.com/9SZhHdv4URtBzRmXpnWxZcYhkgTQurFuuQ8OR7WZ3R7fyTmha77dYkVvcuqMu3DLvMQ=w300" - our image’s URL, imageView - the window where the image is loaded and showed. Glide provides not only the function of displaying our images. It can also produce memory caching and a big variety of transformations. The function, which is quite popular due to the fact, that it’s frequently used by mobile application developers - is creating rounded image view. For this solution you need to create a custom class extended BitmapTransformation and override the method transform: Java

public class CircleTransform extends BitmapTransformation {
    public CircleTransform(Context context)
    {
        super(context);
    }

    @Override
    protected Bitmap transform(BitmapPool pool, Bitmap toTransform,
                               int outWidth, int outHeight)
    {
        return circleCrop(pool, toTransform);
    }

    private static Bitmap circleCrop(BitmapPool pool, Bitmap source)
    {
        if (source == null)
            return null;

        int size = Math.min(source.getWidth(), source.getHeight());
        int x = (source.getWidth() - size) / 2;
        int y = (source.getHeight() - size) / 2;

        Bitmap squared = Bitmap.createBitmap(source, x, y, size, size);
        Bitmap result = pool.get(size, size, Bitmap.Config.ARGB_8888);
        if (result == null)
            result = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);

        Canvas canvas = new Canvas(result);
        Paint paint = new Paint();
        paint.setShader(new BitmapShader(squared,
                                         BitmapShader.TileMode.CLAMP,
                                         BitmapShader.TileMode.CLAMP));
        paint.setAntiAlias(true);
        float r = size / 2f;
        canvas.drawCircle(r, r, r, paint);
        return result;
    }

    @Override
    public String getId()
    {
        return getClass().getName();
    }

    // Then we will add a small change to the way our image will be shown:

    Glide
        .with(this)
        .load("https://lh6.ggpht.com/9SZhHdv4URtBzRmXpnWxZcYhkgTQurFuuQ8OR7WZ3R7fyTmha77dYkVvcuqMu3DLvMQ=w300")
        .transform(new CircleTransform(context))
        .into(imageView);

Finally, our image will be rounded. With the help of the Glide library, we can round all images that we need in such a simple way. Describing the second useful feature of this library that we’ve mentioned above, which is cashing, we can mention that Glide cashes resized images to the memory or disk. For example, there is an image on the server with a resolution of 1000*1000 pixels and your application has image view with a resolution of 100*100 pixels. The library will resize downloaded image to 100*100 pixels and will cash it with such resolution. In case your application will need to show this image again, it will automatically get this image from cash and will show it immediately. The library won’t need to resize the image again because it is already resized in cash. More information about useful features of this library you can read on Glide official web-page.

Retrofit

We can’t imagine an application that is not connected to the web-server or some informational web-source. Retrofit is a type-safe HTTP client for Android and Java. We use this library to create HTTP request to the server. You need only one row of code to include the library to your current project: Java

compile 'com.squareup.retrofit2:retrofit:2.1.0'

Let’s test it out on a simple example, where we will receive a list of emojis from GitHub. Firstly, we add the following row to our gradle file: “Java”

compile 'com.squareup.retrofit2:converter-gson:2.1.0'

We have added gson converter to our project allowing the library automatically convert the result of the request to the custom object. Then we create ServiceGenerator class: Java

public class ServiceGenerator {
    public static final String API_BASE_URL = "https://api.github.com/";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder = new Retrofit.Builder()
                                  .baseUrl(API_BASE_URL)
                                  .addConverterFactory(GsonConverterFactory.create());

    public static S createService(Class serviceClass)
    {
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }
}

This class defines one method to create a basic REST adapter for a given class/interface. The following code defines the RestClient and a method to request the list of emojis.