Shmuel Rosansky

Learning Android Development

Thu, 28 Jan 2016 12:31:19 +0000

People have asked me how they can learn Android development. This is a list of free resources that I used in my growth as an Android Developer. I’m still learning and growing and I will try to keep this list current with new material. Please send me an email if you feel that I’ve missed something.

###Beginner Android Vogella Android

Android Bootcamp

Google Android

SlideNerd Begining Android

Google IO 2010 - The World of ListView (even though ListView was replaced by RecyclerView this video is a must watch to learn fundamental concepts)

TwistedEquations Tutorials - (1- 12 Begginer, 13+ Intermediate to Advanced)

###Intermediate Android Google’s UX (User Experince) best practices

Google’s Material Design specifcations

SlideNerd Andorid 5.0 Tutorials

SlideNerd Database Tutorials

####Important Google IO Conferences: Memory Managment

What’s New in Android Developer Tools (Most of the videos in this playlist are very important)

Android Design for UI Developers

Android ProTips

Google’s Location Tutorial

Android UI Patterns

Android Developers Blog (a must read)

Andrew Ruffolo Channel (he has a lot of good videos) -

###Advanced Android Graphics performance tips

Android Performance Patterns

Optimizing App Performance

Writing Zippy Android Apps

Google’s Best Practices for performance

Android Debugging - Method Profiling

Learn how to performance tune an Android application

Ten tips for memory management

###Useful Google Plus Groups Android Performance Patterns

Android Developer Tools

Material Style Apps

Material Design Apps

Android App Design

Remember, premature optimization is the root of all evil. See here and here. It’s always best to get it working first and then optimize. Use Android profiling tools to identify ‘pain points’ and focus on those areas.

Don’t forget about Stackoverflow. It is a great place to ask (and answer) questions.

Have fun and good luck!

Shabbos Zmanim App

Mon, 07 Dec 2015 12:31:19 +0000

Three years ago I started developing my first Android app. Back then I was an IT guy, fixing computers and removing viruses, but that just didn’t appeal to me anymore. I wanted to write software and create apps. Shabbos Zmanim, and app to know when the Shabbat (Sabbath) starts and ends each week, was the first app I developed. It was a huge undertaking for me, but well worth the time and effort. What started as a small hobby with a few hundred downloads has evolved into a global app that catapulted my software development career.

What started as a small hobby with a few hundred downloads and has evolved into a global app that catapulted my software development career.

The Jewish Sabbath begins at sunset on Friday and lasts until nightfall Saturday night. Every Friday afternoon Jews around the world light candles to signify the onset of the Sabbath. Because the Sabbath times are connected to sunset, the exact time changes with the seasons and depending on your location. Most people have calendars that show what time the Sabbath starts each week for a given location.

One Friday morning I realized that there had to be a better way. Smartphones know our precise location and the date. Why not use that information to calculate the sunset time dynamically each week? That way anyone can know the correct Zmanim (times) wherever they are. Thus began Shabbos Zmanim.

The development of the app has taught me a tremendous amount. Most importantly it taught me to believe in myself. I never would have dreamed of creating an app that is used by over thirty thousand people. But here I am today, with thirty two thousand downloads. The journey was a long one, involving numerous late night development sessions, a lot of beer, and many bags of M&Ms. I loved every moment of it.

I loved every moment of it.

I learned that coding is hard, but so much fun. The feeling of frustration at why something isn’t working, only to realize that you mistyped a variable name or method. The feeling of joy when a user is happy with your project and sends you a message of thanks. The feeling of anxiety when you are about to launch an update and you are afraid of regressing a feature. This is the rollercoaster ride of software development, and it is a wild ride.

Every day has successes and failures, but most importantly every day is a learning experience. Each mistake that I made was an opportunity to grow and learn. That time when my app crashed for users with a negative elevation taught me to validate sensor data and think about how the app can malfunction. The time when my app crashed on a specific phone and Android version taught me I need to test my apps better before launching them. I learned how to use analytics and metrics to improve my app and focus my efforts on the most used feature. I learned that I need to roll out releases slowly to my users because there will inevitably be an issue that I need to address.

Now, as I launch the 4.0 update, I want to say thank you to each and every one of my users. You guys are the reason I spend time developing this app. Each piece of feedback I’ve received, both positive and negative, has helped me improve the app and my skills as a developer.

So please, download the app, leave some feedback, and of course, Shabbat Shalom! Shmuel Dovid Rosansky

PNGs on a diet with WebP

Sun, 11 Oct 2015 12:31:19 +0000

Recently I was working on a project with a large amount of png files. Our designers had created a bunch of custom assets and animations for the project. After resizing the assets for different screen densities the project was left bloated from all the png files. It was compiling (with progaurd enabled) to over 150mb. Even though Google recently raised the apk size limit from 50mb to 100mb, we were still way oversized.

I had read a while back about Google’s webp image format and figured it would be worth a shot to try it out. Boy was I shocked. By converting our images from png format to webp format I was able to reduce our apk size from over 150mb to 34mb.

I was able to reduce our apk size from over 150mb to 34mb.

But what about compatibity?

Webp is natively compatible with Android 4.0 and higher. This makes it the perfect solution for most modern projects.

On Windows you can install this codec to enable you to view the images in any photo viewer. Unfortunately there is no such plugin from Google for Mac. I did find this tool for Mac, but I haven’t tried it.

Let’s do it!

First you need to download the compiled binaries from here. To convert your png files you’ll want to run the cwebp executable. The docs tell you eveything you need to know.

Warning!

The Google Play store does not allow an apk to use .webp for the app icon. In in the Mac Bash script below I’ve set it to skip mipmap directories because that is where my app icons are. The Windows batch script does not check for this.

Also, these scripts will overwrite your png file. Make sure to back them up!

Scripts

Here’s a Windows batch script I wrote to easily convert the entire project to webp. Just replace the two comments with your path structure.

@echo off
setlocal enableextensions enabledelayedexpansion
echo Converting to webp
echo script by Shmuel Rosansky

echo Warning, this will convert app icons also!

echo Listing all png files..
SET /A COUNT=0

cd [path to your res folder]

for /r . %%g in (*.png) do (

echo %%g
echo Old Size
echo   %%~zg

[path to webp.exe]\cwebp.exe %%g -o %%g -q 80 -alpha_cleanup -alpha_filter best -m 6 -mt -af -short

ren %%g *.webp

SET /A COUNT+=1
echo File # !COUNT!
echo ----

 )
 endlocal

If you perfer Mac here’s a bash script.

find ./ -type f -name "*.png" |while read line
do  

if [[ $line == *"mipmap"* ]]
then
  continue
fi
  	./cwebp $line -o $line -q 80 -alpha_cleanup -alpha_filter best -m 6 -mt -af -short || { echo 'Convert to webp failed' ; exit 1; }
  	mv "$line" "${line%.png}.webp"
done

You can change the quality level by raising or lowering 80. I found no visible loss of image quality at 80. Remember, your users will be on small phone screens and will not be able to analyze every pixel like you can on your desktop.

Jackson and Android

Mon, 20 Jul 2015 12:31:19 +0000

Json (or javascript object notiation) is a great way to transfer data over the web or persist data to disk. It is not the only way, but it is by far the most popular due to its clear-text format and ease of use. Developers love that you can read json and understand what it represents. Contrast this to a binary protocol (such as Google’s Protobuf library) which is faster and has a smaller data size, but cannot be read by humans. Readablity is the major reason why Json became the defacto standard for public api communication.

There are a couple of ways to work with json on Android. You can use the standard Java/Android libraries, Google’s GSON library, or FasterXML’s Jackson library. There are discussions online which is the best to use and the generally accepted answer is Jackson. The native libraries are slow and cumbersome. GSON is the next best choice. It is really simple to use and a lot faster than the native libs. Jackson is (usally) the fastest one. But Jackson can be a bit confusing to setup.

(Edit - Nov 2015 - Turns out that on Android GSON is faster for small Json strings. This is because Jackson has a longer initialization time. With larger Json strings the longer initialization time is made up by the faster proccessing time. But for shorter Json strings GSON is faster because it initializes faster.)

####First, an overview of how Jackson works.

In your project you need to create a model of the object which the api is sending you. Json is merely a textual representation of some object. Once you have a Pojo (plain old Java object) representing the Json object you can use that with Jackson. You have to give Jackson both the Json (either as a String or a Stream) and the class that you want to build. Jackson will then create an object of that class type using the json to fill its fields.

####Great, lets do it!

Step one is to add the Jackson library to your app’s gradle file. (replace 2.5.3 with the latest version)

compile 'com.fasterxml.jackson.core:jackson-core:2.5.3'
compile 'com.fasterxml.jackson.core:jackson-annotations:2.5.3'
compile 'com.fasterxml.jackson.core:jackson-databind:2.5.3'

After you’ve added these lines Android Studio should prompt you to ‘sync gradle’. Do that. If that prompt doesn’t come up then you should run Build > Clean.

Awesome, now you have Jackson added to your project.

Next lets create a Pojo for the json that we’ll be using. For this example I will be using this dictionary api from Mashape. This is an example of the Json it returns for a search query ‘book’.

{
  "definitions": [
    {
      "text": "A set of written, printed, or blank pages fastened along one side and encased between protective covers.",
      "attribution": "from The American Heritage® Dictionary of the English Language, 4th Edition"
    },
    {
      "text": "A printed or written literary work.",
      "attribution": "from The American Heritage® Dictionary of the English Language, 4th Edition"
    },
    {
      "text": "throw the book at  To reprimand or punish severely.",
      "attribution": "from The American Heritage® Dictionary of the English Language, 4th Edition"
    }
  ]
}

We can see there are two Json objects here. The first is the Response object and that contains and array of Definition objects.

Building the Java models

We need Java models for these objects. To do that we head over to one of my favorite websites, JsonSchema2Pojo. Copy the Json into the input box, set the ‘Source Type’ to Json, and hit ‘Generate’.

package com.example;

import java.util.HashMap;
import java.util.Map;
import javax.annotation.Generated;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("org.jsonschema2pojo")
@JsonPropertyOrder({
"text",
"attribution"
})
public class Definition {

@JsonProperty("text")
private String text;
@JsonProperty("attribution")
private String attribution;
@JsonIgnore
private Map<String, Object> additionalProperties = new HashMap<String, Object>();

/**
* 
* @return
* The text
*/
@JsonProperty("text")
public String getText() {
return text;
}

/**
* 
* @param text
* The text
*/
@JsonProperty("text")
public void setText(String text) {
this.text = text;
}

/**
* 
* @return
* The attribution
*/
@JsonProperty("attribution")
public String getAttribution() {
return attribution;
}

/**
* 
* @param attribution
* The attribution
*/
@JsonProperty("attribution")
public void setAttribution(String attribution) {
this.attribution = attribution;
}

@JsonAnyGetter
public Map<String, Object> getAdditionalProperties() {
return this.additionalProperties;
}

@JsonAnySetter
public void setAdditionalProperty(String name, Object value) {
this.additionalProperties.put(name, value);
}

}

package com.example;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Generated;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("org.jsonschema2pojo")
@JsonPropertyOrder({
"definitions"
})
public class Response {

@JsonProperty("definitions")
private List<Definition> definitions = new ArrayList<Definition>();
@JsonIgnore
private Map<String, Object> additionalProperties = new HashMap<String, Object>();

/**
* 
* @return
* The definitions
*/
@JsonProperty("definitions")
public List<Definition> getDefinitions() {
return definitions;
}

/**
* 
* @param definitions
* The definitions
*/
@JsonProperty("definitions")
public void setDefinitions(List<Definition> definitions) {
this.definitions = definitions;
}

@JsonAnyGetter
public Map<String, Object> getAdditionalProperties() {
return this.additionalProperties;
}

@JsonAnySetter
public void setAdditionalProperty(String name, Object value) {
this.additionalProperties.put(name, value);
}

}

Boom. We now have our Java Pojo models. Add them to your project (I like to create a models package and put all my model objects there.)

Create the actual Java objects from the Json

In your project write code to get the Json. You can do this with HttpURLConnection, OkHttp, or just loading a String. Once you have the Json Stream or Json String these are the lines that do the magic:

ObjectMapper objectMapper = new ObjectMapper();
Response response = objectMapper.readValue(okhttpResponse.body().byteStream(), Response.class);

We are creating a Jackson ObjectMapper and providing it with our input (in this case I used a Stream but you can replace that with a String) and the class that we want to build. Jackson handles everything else.

That’s it. Now you have a Pojo for the server’s response. You can use it in your Java code wherever needed.

Obligatory Hello World

Wed, 15 Jul 2015 12:31:19 +0000

I still remember the first line of code I wrote. It was a ‘Hello World’ written in python. Since then I’ve learnt that Hello World is more than just being polite, it’s part of our culture as programmers. In fact, one way to rank languages is by how fast you can write a Hello World program. In that respect, python is pretty awesome.

On a side note, I recently picked up python again after a 7+ year hiatus. Back then I had no idea what I was doing, all I wanted to do was develop a video game. Yah, Rollercoaster Tycoon was that awesome. It made me dream of creating my own game one day. But I digress.

Python turned out to be a fun and fast way of accomplishing a task that was needed. At first I was going to write something in Java to hit an api and do the work I needed. After firing up intellij I knew there had to be a better way.

A software engineer must know his tools

Pankaj Pal

Java is my best language, but for this task it just seemed overkill. Enter python.

It took a bit of Googling to get up to speed after not using python for 7 years, but it was well worth it. Python is a ‘Hello Word’ friendly language and really easy to use.

Lesson learned: Know your tools. If all you have is a hammer, everything looks like a nail.