Things every android developer should know - part 5

Description: Hello coders! In this post I'm gonna show some interesting tips and tricks you can start using in your android project.

Also check out Part 1,Part 2, Part 3 and Part 4

So let's get started.

1. How to remove boiler plate code of  Parcelable interface?

Let's consider this class with Parcelable Interface implementation. This class contains overriden methods which are boiler plate at larger extends

class User(val id: String, val name: String, val age: Long, val address: String, val isPrime: Boolean, val contact: String) : Parcelable {
    constructor(parcel: Parcel) : this(
            parcel.readString(),
            parcel.readString(),
            parcel.readLong(),
            parcel.readString(),
            parcel.readByte() != 0.toByte(),
            parcel.readString())

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(id)
        parcel.writeString(name)
        parcel.writeLong(age)
        parcel.writeString(address)
        parcel.writeByte(if (isPrime) 1 else 0)
        parcel.writeString(contact)
    }

    override fun describeContents(): Int = 0

    companion object CREATOR : Parcelable.Creator {
        override fun createFromParcel(parcel: Parcel): User {
            return User(parcel)
        }

        override fun newArray(size: Int): Array {
            return arrayOfNulls(size)
        }
    }

}

So here comes @Parcelize annotation into picture. Lets modify our User class using @Parcelize

@Parcelize
class User(val id: String, val name: String, val age: Long, val address: String, 
           val isPrime: Boolean, val contact: String) : Parcelable

@Parcelize is the part of androidExtensions we have to enable it by adding below snippets within module's build.gradle section.

android {
    ...
    androidExtensions {
        experimental true
    }
    ...
}

2. Using Plurals

Although plurals where introduced long time back, but have seen developers adding logics for plural strings. Let's take an example of adding plural, when any post is liked.

    <plurals> name="like_count">
        <item quantity="one">%d second ago</item>
        <item quantity="other">%d seconds ago</item>
    </plurals>

Access within the code

mContext.resources.getQuantityString(R.plurals.like_count, 1, 2)

#Output:
2 second ago

#Note: First argument matches the plural and second is the argument for %d 

3. How to Change Default layout of activity?

Its interesting because it will help to add some constant template(toolbar in all the activity etc ) which we normally add after the activity is created, henceforth saving time. Simply Go to File -> New -> Edit File Templates

Edit Templates

Changing Root Tag for layouts

In the above example we can simply replace  ROOT_TAG with <LinearLayout> and next time when we create new layout it will start with <LinearLayout>



Bingo we're done.

For more updates follow us on -  Twitter

#codingIsAnArt
#coderconsole

Read More

Switch from Java to Kotlin

Description: In this post I'm gonna show some of the basic syntax and semantics difference while we use "KOTLIN" in your android application w.r.t JAVA(Java v/s KOTLIN).

So let's get started.



1. Variable Declaration

Java:
String name="coderconsole";

Kotlin:
val  name:String="coderconsole"

2. Casting

Java:
WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);

Kotlin:
val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager

3. Function Declaration

Java:

void methodDeclaration(){
    methodDeclaration("First Method ");
}

void methodDeclaration(String firstParam) {
    methodDeclaration(firstParam, "Second Method ");
}

void methodDeclaration(String firstParam, String secondParams) {
    System.out.println(firstParam + secondParams);
}


Kotlin:


fun methodDeclaration(){
    methodDeclaration("First Method ")
}

fun methodDeclaration(name : String){
    methodDeclaration(name, "Second Method ")
}

fun methodDeclaration(first : String, second: String){
    println(first + second)
}

4. Static Functions and Variable

Java:

class DeviceUtils{
    static final String name = "coderconsole";

    public static String getAndroidId(Context context){
        return Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
    }
}



Kotlin:


class DeviceUtils {

    companion object {
        val name: String = "coderconsole"
        @JvmStatic fun getAndroidId(context: Context): String = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
   }

}

5. Ternary

Java:
String ternary(String name) {
    return name.equalsIgnoreCase("coderconsole") ? " Ternary success" : " Ternary failed";
}

Kotlin:
fun ternary(name: String): String {
    return if (name.equals("coderconsole"))"Ternary success" else "Ternary failed"
}

6. Operators(this operators are only useful in kotlin)

a) Null Type(?)- variable can be made null only using null type operator

   val array: String = null /** Null cannot be the value of not null type**/ 
   val array: String? = null  /** Bingo! Will work now **/

b) Safe Type:(?.) - Helpful when we donot know when the variable be null.So instead of throwing NPE it return the value as null.

//The below code will return "customerId" if present else return null even if the "customerObject" is null.
fun safeTypeDemo(customerObject: JSONObject?): String?{
         return customerObject?.optString("customerId")     
}

c) Elvis Operator(?:) - Helpful when we want to return some not-null values, if the first result is null.

Java:
int elvisDemo(JSONObject result){
      if (result != null)
        return result.optInt("marks");
     else  return -1;
   }

Kotlin: 
fun elvisDemo(marksObject: JSONObject?): Int {
         return marksObject?.optInt("marks")?:-1      
}
                                 (or)
fun elvisDemo(marksObject: JSONObject?): Int = marksObject?.optInt("marks")?:-1

d) !! operator - throws Null Pointer when asked explicitly

//The below code will throw NullPointerException if customerObject is null.
fun npeTypeDemoDemo(customerObject: JSONObject?): String{
         return customerObject!!.optString("customerId")     
}

7. Loops
a) for loop:

Java
void forLoopDemo(List mList) {
        for (String item : mList)Log.d("Loop", item);
    }

Kotlin
fun forLoopDemo(mList: List) {
       for (item in mList) Log.d("Loop", item)
    }

b) while/do-while: - there is no syntactical difference from Java.

8. Switch Case

Java
void switchCaseDemo(int type) {
    switch (type){
        case 0:
            Log.d("switch", "value - " + type);
            break;
        case 1:
            Log.d("switch", "value - " + type);
            break;
        default:
            Log.d("switch", "value default");
            break;

    }
}

Kotlin
fun switchCaseDemo(type: Int) {
    when (type) {
        0 -> Log.d("switch", "value - " + type)
        1 -> Log.d("switch", "value - " + type)
        else -> Log.d("switch", "value default")
    }
}

9. Extends/Implements

//This sample contains abstract class and an interface to printData.
public abstract class AbstractA {
    public void printAbstractData(String data){
        System.out.println(data);
    }
}
public interface InterfaceA {
    public void printData(String data);
}


public class ExtendsImpDemo extends AbstractA implements InterfaceA {
    @Override    public void printData(String data) {
        printAbstractData(data);
    }
}


Kotlin

abstract class AbstractA{
    public fun printAbstractData(data: String){
        println(data)
    }
}

interface InterfaceA{
    fun printData(data: String)
}

class ExtendsImpDemo : AbstractA(), InterfaceA {
    override fun printData(data: String) {
        printAbstractData(data)
    }
}

10. Iterating JSONArray

Java:
void arrayTest(JSONArray jsonArray) {
    for (int i = 0; i < jsonArray.length(); i++) {
        JSONObject jsonObject = jsonArray.optJSONObject(i);
        Log.d("ArrayTest", jsonObject.optString("name"));
    }
}

Kotlin:
fun arrayTest(jsonArray: JSONArray){
    jsonArray.items<JSONObject>().forEachIndexed { i, jsonObject ->
        Log.d("ArrayTest", jsonObject.optString("name"))
    }
}

Kotlin is an awesome language and very fun to write code in it.
For further reference you can try https://try.kotlinlang.org

For more updates follow us on -  Twitter

Read More

Introduction to Internet of things platform Octoblu

Description: 

In this post I'm gonna describe very helpful platform for building some stuff that involves 'Internet of thing'/ Internet of apis.
 
So lets get started.

Octoblu - It's an platform to build an amazing iot/iota projects that involve connection of  'things' with variety of tools involved in it. The 'things' could be sensors/led lights/apis from social networks like G+ or twitter etc.

Few key terms

1. Things - Entity that you need to integrate. E.g: Twitter, G+, Http Api,Sensors etc.
2. Tools - Connectors to connect the things. E,g: Less than, Greater than operators, Timer.
3. Flow - Actual Work space which contains THINGS and TOOLS
4. Bluprints - Final Shared FLOW is Bluprint.

Note: 1. For the sake simplicity we're gonna build a Flow which triggers Twitter post after 5 mins.
          2. DONOT spam your timeline. This may result about your account may get blocked.

Step 1: Create flow

 After successful signup create an Flow and enter name and description as per your choice from  "Flow Inspector" as shown  in fig.1

fig.1

Step 2: Add things.

After creating dummy flow its time to add "Things". For our demo we're gonna add "Twitter" as our thing from the Things tab.

Select the endpoint as "Post Tweet" and add a message for post.
Add status as "Hello world"

 As shown in the fig.2.

Note: You can also search through the things and simply drag and drop. You have to add your twitter account for testing.

fig.2

Step 3: Add trigger.

After adding "Things" its time to add trigger to initiate our twitter post. You can find triggers within the "Tool" tabs as shown in the fig.3

fig.3

Step 4: Connection

Now comes the best part "Connections" .Octoblu connections are seamless. We have two points for each "trigger" and "things" simple drag from one point to another as shown in fig4.

fig.4

Step 5: Lets wrap everything up.

Now simply run the flow created above as shown in fig.5 this will make sure your flow is ready to get triggered

Note: You have to run the flow every time whenever you have made any changes

fig.5

Step 6: Trigger the flow 

Simple click the play icon on the trigger. fig.3. This is trigger your twitter post with the text as "Hello world" on your twitter profile page.

Thats It !!!

How to debug?

This will help to figureout whats happening whenever the trigger  is initiated.

To debug the flow

1. You have to enabled "DEBUG" mode from "Thing Inspectors" by  first clicking the things on the flow first.

How To Automate?

1. To automate you can use a tool called as "INTERVAL" and can assign the triggering time as 5 minutes


So finally we have automated our twitter post using "Octoblu". It has got immense power and can come handy for demo projects involving 'Internet of things/Internet of APIS'.

For more updates follow us on -  Twitter

Read More

Things every android developer should know - part 3

Description: In this post I'm gonna demonstrate some useful tips which we could come handy in our app development life cycle

Also check out Part 1 and Part 2.

So let 's get started.

1. Grant all permissions at once in Marshmallow and above.  

GIST Snippet Here

As we know marshmallow compatible apps require permissions. So we normally show permission dialog to the user asking to grant us. That's fine. But every time clicking that 'allow' feels annoying for developers.

So the idea is to allow all the permissions at once without every time clicking the allow button.

Below  shell script will help to make it happen flawlessly.

#!/bin/sh

#add your package_name
PACKAGE=com.app.code2concept

#create array with all the permission you need to enabled    
PKG_ARRAY='android.permission.CALL_PHONE
        android.permission.GET_ACCOUNTS
        android.permission.READ_SMS
        android.permission.READ_CONTACTS
        android.permission.ACCESS_FINE_LOCATION
        android.permission.CAMERA
        android.permission.WRITE_EXTERNAL_STORAGE'

#lets exceute our command
for permissions in $PKG_ARRAY; 
do
 echo $permissions + ' granted'
 adb shell pm grant $PACKAGE $permissions
done

echo 'Bingo its done'

OUTPUT:

$ sh grant_all_permissions.sh
android.permission.CALL_PHONE +  granted
android.permission.GET_ACCOUNTS +  granted
android.permission.READ_SMS +  granted
android.permission.READ_CONTACTS +  granted
android.permission.ACCESS_FINE_LOCATION +  granted
android.permission.CAMERA +  granted
android.permission.WRITE_EXTERNAL_STORAGE +  granted
Bingo its done'

Before


After

2. Battery Historian

Battery historian translate the battery stats into visualization form thereby helping us to figure out whats the cause and how we can optimized our battery usage.

Pre-requisite:
1. 'adb' is configured
2. Devices is detectable using 'adb devices' command
3. Python(2.7)  is install and path is set.

Step 1: Reset the battery stats to fetch fresh info using below

adb shell dumpsys batterystats --reset

Note: Disconnect phone and explore the app for few minutes and connect again

Step 2: Capture 'batterystats' using below command

adb shell dumpsys batterystats > batterystats.txt

Note: The command creates a file name 'batterystats.txt' into the current directory

Step 3: Clone or download the Github repo of 'Battery Historian' from Here. You will find a python script at path '../battery-historian/scripts/historian.py'

Note: You can keep both 'historian.py' and 'batterystats.txt' in the same folder for ease

Step 4: Finally let execute the python script against our 'batterstats.txt' as input as show below

python historian.py batterystats.txt > batterystats.html

This will create 'battertstats.html' fig.1 which we can use to analyse the battery usage as shown HERE.

fig.1

Read More

Android Data binding

Description: In this post I'm gonna illustrate concept of 'Data Binding' in android. So straight away.

Let's get started.

'DataBinding' in android was introduced as an effort to coupled the model i.e data directly into the view, thereby eliminating findViewById()  at much larger extend. Although its not limited to this and can help to remove lots of boilerplate code thereby. Its the direct roadway to implement MVVM pattern in our apps.

Prerequisite:

1. Add below snippets into your 'Module' build.gradle within 'android' section

    dataBinding {
        enabled true
       }

2. Now just add below line within the your 'Project'  build.gradle within 'dependencies' section.
Note: The gradle plugin should be greater or equals v1.5 +

 classpath 'com.android.tools.build:gradle:1.5.0 

Let's start with simple example of how to eliminate findViewById in activity.

1. Eliminate findViewById();

Step 1: Simply create a model with a field name as 'title' and also the POJO for the same.

public class SingleModel {

    private String title;

    public SingleModel() {
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

Step 2: In our activity_main.xml wrap your parent layout within '<layout> ...< /layout>' . As shown below. Create a <data> ...</data> tag with <variable>...</variable> to access its model variables

   <layout xmlns:android="http://schemas.android.com/apk/res/android">

    <data>
        <variable
            name="single"
            type="com.code2concept.databinding.models.SingleModel"/>
    </data>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="@{single.getTitle()}"/>
    </RelativeLayout>
</layout>

Note: 1. Once you have created a variable into <layout> apt builds the binding file name BR.java(similar concept what R.java does) which and other binding functions.

Step 3: Lets integrate in our MainActivity. 

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityMainBinding mainActivity = DataBindingUtil.setContentView(this, R.layout.activity_main);

        SingleModel singleModel = new SingleModel();
        singleModel.setTitle("Wow ! Data binding is awesome");
        mainActivity.setVariable(BR.single, singleModel);

    }
}

Bingo ! we have integrated databinding in our app

2. Handle click.

Step 1: Create a <variable> ... </variable> tag with name and type as shown below.

Note: Type can be created from separate class as well. We're gonna implement onClick in Activity.

<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="single"
            type="com.code2concept.databinding.models.SingleModel"/>

        <variable
            name="singleClick"
            type="com.code2concept.databinding.MainActivity"/>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:onClick="@{singleClick.onClick}"
            android:text="@{single.getTitle()}"/>
    </RelativeLayout>
</layout>

    

Step 2: Finally bind the singleClick to the activity as shown below.

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ActivityMainBinding mainActivity = DataBindingUtil.setContentView(this, R.layout.activity_main);

        SingleModel singleModel = new SingleModel();
        singleModel.setTitle("Wow ! Data binding is awesome");
        mainActivity.setVariable(com.code2concept.databinding.BR.single, singleModel);

        //bind click to the  activity
        mainActivity.setSingleClick(this);
    }

    @Override
    public void onClick(View view) {
        Toast.makeText(this, "Single Model view is clicked", Toast.LENGTH_SHORT).show();
    }
}

Great, we have handled onClick event as well

Question: what happens when the content of the view need to be changed in the runtime?.
No need to worry 'DataBinding' helps us effortlessly.

3. NotifyChangeProperty

Step1: Add @Bindable annotation to the getters and notifyPropertyChanged() to the setters as shown below.

public class SingleModel extends BaseObservable {

    private String title;


    @Bindable
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
        notifyPropertyChanged(BR.title);
    }
}

Step 2: Finally lets change our title on onClick. fig.1

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private SingleModel singleModel;
    private ActivityMainBinding mainActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mainActivity = DataBindingUtil.setContentView(this, R.layout.activity_main);

        singleModel = new SingleModel();
        singleModel.setTitle("Wow ! Data binding is awesome");
        mainActivity.setVariable(BR.singleModel, singleModel);

        //bind click to the  activity
        mainActivity.setSingleClick(this);
    }

    @Override
    public void onClick(View view) {
        singleModel.setTitle("Title is changes successfully");
    }
}

fig.1

Awesome, finally we have integrated databinding in our project ;-). Part 2 coming soon

Read More

Things every android developer should know - part 2

Description: In the post, we'll continue the legacy of  Part 1 :-). Below are some tools provided by Google Android which is helpful for Android developers during the development and debugging session of the Production app issues

So let's get started :-)

Note: If you have missed part 1. Please refer here

1. Capture or record screen without any external app.

Often we are required to take snapshots of the app's screen or even record a video to show some features to colleagues QA or Clients. It comes in handy very often.

Step 1: Simply connect your device. Open the Android Monitor from Android Studio you'll see as fig.1.

fig.1

Step 2: Now, you can open your app and click on the camera icon from the Android monitor located in the extreme top-left corner to capture any screen you want. Bingo !!!

For video: Click the video icon below the camera icon. Enter the resolution with multiples of 16x. fig.2. That's it. It'll start recording your actions on the app.

fig.2

2. How to find layout boundaries?

Layout boundaries are very useful when we develop our UI components. It gives a real sense of layout, thereby letting us study the arrangement of different widgets in the layout.

Step 1: Open Settings - Developer Options - Show layout boundaries. From drawing section

fig.3.LinkedIn app

fig.3. A Simple analysis of pencil icon. (without opening our layout)

1. The Edit pencil icon has some padding to it. 

2. It's aligned to the top-right corner of its parent layout.

Really awesome.

3. How to debug obfuscated code using proguard tool?

Note: This tool is inbuild provided by Google Android Sdk for developers and is helpful during debugging for live issues 

As we know, code is obfuscated when we build our app with Proguard enabled. We often come in contact with obfuscated code in our app while debugging the stack trace of the crashes.

So decoding is very much needed to study the stack trace. Android builds a file called "mapping.txt" which serves as the key ingredient to decode, in a combination with "retrace".

In Windows

Step 1: Go to  (android-studio-install-dir-path)\tools\proguard\bin  open "proguardgui.bat"  fig.4

fig.4

Step 2: Click on "ReTrace" fig.5. and upload your "mapping.txt" file from app/build/outputs/mapping/.../mapping.txt   and the obfuscated code file (e.g: crash.txt). You can also simply paste the stack trace in the box provided.

fig.5

You can also use command line code to do that.

\tool\proguard\bin> retrace.bat -verbose   (path_to_mapping.txt)\mapping.txt  (path_to_stacktrace)\crash.txt


For more updates follow us on -  Twitter

#codingIsAnArt
#coderconsole

Read More

Things every android developer should know - part 1

Description: In this post, I'm gonna demonstrate tools that help solve some common problems while app development & help increase the speed as well.

So let's get started :-)

1. How to run app on phone without USB cord.(need USB initially to make connection) 

Note: Android Studio has provided a more sophisticated option to connect without USP using wireless debugging. Do check out the blog

Step 1: Connect the device with the cord to your system. Ensure that USB debugging is enabled from Developer options. Open cmd(windows) or Terminal(Linux) run the command. You'll find the connected device.

adb kill-server && adb devices

Step 2: Run the next command to restart in tcp mode on port 5555

adb tcpip 5555

Step 3: Now disconnect your device from the system and note down your ip address of the phone from Setting > About Phone > Status. 

E.g It could be something like 192.168.0.3(IP address) Now run the final command by replacing it with your IP address

adb connect 192.168.0.3:5555

Bingo we're done now your device is connected and you can run it wirelessly :-)

2. How to find SHA1 key from android studio?

SHA1 key is needed in many different apps containing maps or social sites authentication or using any Google apps and services. It's super useful. So the simplest way to get that is using Android Studio.

Step 1: Select the Gradle projects from the right pane and expand Tasks > Android> signingReport. (fig.1).

Note: If you do not find your project in Gradle Projects sync the project from Android Studio.

fig.1

3. Best way to create icons for android app using vector asset.

Many times in our development we need icons for small things with varied colors or shape. Using Vector Asset in Android Studio we can create our icons with super ease.

Step 1: Right-click on app > New > Vector Asset you'll see Fig. 3. You can choose Material Icons which contains a whole lot of icons in different categories. This will create <vector> for the icon you have selected. (fig.4) in drawable folder

fig.3

Vector Asset for the icon

fig.4

Step 2: Awesome now just we can simply set it to background or src of ImageView and other widgets.

For more updates follow us on -  Twitter

#codingIsAnArt
#coderconsole

Read More

Android Studio Flavors Demo

Description: In this post I'm gonna explain and show you guys how to use flavors in android studio.

Android Studio's flavors help as totally avoid chaos in code by separating our release code setup and staging code setup or by creating free/premium version for the same code base.

Really awesome :-)

Lets get started by creating two flavors for our project i.e prod and stag and find how it actually works!!!

Here we goo.

Step 1: Add productFlavors in your  app's build.gradle  within android section.

productFlavors{
    prodFlavors{

    }

    stageFlavors{

    }
}

*Just sync the gradle or rebuild the project you will find variants for two flavors in "Build Variants"(fig.1)

                                      (fig.1)


Step 2: Now let's create the folder structure for flavors to use prod and stage flavors similar to the structure of the main.

(Here we have created the folder structure same as the main i.e containing java and res folders respectively)

(fig.2)

Step 3: Lets add a constant file containing our dummy values.Thus we can easily switch the build variant & our constants values get changed as per the build variant selected.

Note: Always change the "Build Variant" when ever you want to change any thing within the flavors code base. (as shown in fig.1)

                                   (fig.3)

Step 4: Bingo !!!Final code and output.

In production flavor:

public class Constant {
    public static final String FLAVOUR_ID = "Woot !!! This is production setup";
}

In staging flavor

public class Constant {
    public static final String FLAVOUR_ID = "Woot !!! This is staging setup";
}

MainActivity:

public class MainActivity extends AppCompatActivity {

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

        //This is where by just changing by build variant we can change our setup easily
        TextView flavourType = (TextView)findViewById(R.id.flavourType);
        flavourType.setText(Constant.FLAVOUR_ID);

    }
}

How to change configuration of the build as per the variant? - (listed below)

productFlavors{

    prodFlavors{
        applicationId "com.buildvariant.prod"
        minSdkVersion 10
        targetSdkVersion 23
        versionCode 2
        versionName "1.1"
 
}

    stageFlavors{
        applicationId "com.buildvariant.stage"
        minSdkVersion 10
        targetSdkVersion 23
        versionCode 2
        versionName "1.1"
    }
}

Thus we can change our project setup thereby avoiding unnecessary chaos by separating our production setup code against staging.

Awesome!!!Android.

Output:

 

Read More

Android support v7 palette demo

Description: In this post I'm gonna show you how to use android's support library v7 palette for extracting color from bitmap. Its can have variety of use-cases like making the background of the profile image somewhat similar to profile image or changing the whole UI as per the bitmap into the screen. Really Awesome !!!

Github project here

Lets get started.

Step 1: Add this into build.gradle.

compile 'com.android.support:palette-v7:+'

Step 2: Pass the bitmap into palette to get List<Palette.Swatch> as shown below.

Palette.from(bitmap).generate(new Palette.PaletteAsyncListener() {
    @Override    public void onGenerated(Palette palette) {
        swatchesList = palette.getSwatches();

        }
    }
});

Step 3: Here we have used CountDownTimer to display the RGB of the bitmap into the background of parent layout after the interval of 1sec. As shown below

mainContainer.setBackground(AppUtils.createGradient(swatch.getRgb()));

Steps 4: Lets combine everything :-)

public class MainActivity extends AppCompatActivity implements INotifyTimer {

    private static final String TAG = MainActivity.class.getName();

    private List<Palette.Swatch> swatchesList;
    private CountDownTimerPalette countDownTimer;

    private int size ;

    private RelativeLayout mainContainer;
    private ImageView circularImageView;

    @Override    protected void onCreate(Bundle savedInstanceState) {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();

        extractColorFromBitmap();
    }

    private void init() {
        mainContainer = (RelativeLayout)findViewById(R.id.mainContainer);
        circularImageView = (ImageView)findViewById(R.id.circularImageView);
    }

    private void extractColorFromBitmap() {

        Bitmap bitmap = AppUtils.getCircleBitmap(BitmapFactory.decodeResource(MainActivity.this.getResources(), R.mipmap.capture_palette));
        circularImageView.setImageBitmap(bitmap);

        Palette.from(bitmap).generate(new Palette.PaletteAsyncListener() {
            @Override            public void onGenerated(Palette palette) {
                swatchesList = palette.getSwatches();

                if (swatchesList != null && swatchesList.size() > 0) {
                    countDownTimer = new CountDownTimerPalette(1000 * swatchesList.size(), 1000, MainActivity.this);
                    countDownTimer.start();
                }
            }
        });
    }

    @Override    public void onTick(int tick) {

        Palette.Swatch swatch = swatchesList.get(tick - 1);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
            mainContainer.setBackground(AppUtils.createGradient(swatch.getRgb()));
        }else {
            mainContainer.setBackgroundDrawable(AppUtils.createGradient(swatch.getRgb()));
        }

    }

    @Override    public void onFinish() {
        countDownTimer.start();
    }


    @Override    protected void onDestroy() {
        super.onDestroy();

        if (countDownTimer != null){
            countDownTimer.cancel();
        }
    }

}

Output:

 

Read More

Android Multiple row layout using RecyclerView

Description: In this post I'm gonna show you how we can have multiple row layout in Android's Material Design  RecyclerView  using   getItemViewType.

compile 'com.android.support:cardview-v7:23.0.0'
compile 'com.android.support:recyclerview-v7:23.0.0'

GitHub Project HERE

So lets get started :-)

Step 1: Create Recycler Adapter by overriding getItemViewType method and giving the type for different layout as shown below.

@Override

public int getItemViewType(int position) {

    MultipleRowModel multipleRowModel = multipleRowModelList.get(position);

    if (multipleRowModel != null)
        return multipleRowMod.type;

    return super.getItemViewType(position);
}

Step 2: Create a viewHolder as per viewType .  We can create different row layout using viewType .

Note: viewType in onCreateviewholder is retured from getItemViewType in Step 1.

@Override
public MultipleRowViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    View view = null;

    if (viewType == AppConstant.FIRST_ROW)
        view = inflater.inflate(R.layout.view_row_first, parent, false);
    else if (viewType == AppConstant.OTHER_ROW)
        view = inflater.inflate(R.layout.view_row_other, parent, false);

    return new MultipleRowViewHolder(view, viewType);
}

Step 3: Lets integrated all this in one RecyclerView adapter.

public class MultipleRowAdapter extends RecyclerView.Adapter<MultipleRowViewHolder> {

    private LayoutInflater inflater = null;
    private List<MultipleRowModel> multipleRowModelList;

    public MultipleRowAdapter(Context context, List<MultipleRowModel> multipleRowModelList){
        this.multipleRowModelList = multipleRowModelList;
        inflater = LayoutInflater.from(context);
    }

    @Override
    public MultipleRowViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

        View view = null;

        if (viewType == AppConstant.FIRST_ROW)
            view = inflater.inflate(R.layout.view_row_first, parent, false);
        else if (viewType == AppConstant.OTHER_ROW)
            view = inflater.inflate(R.layout.view_row_other, parent, false);

        return new MultipleRowViewHolder(view, viewType);
    }

    @Override
    public void onBindViewHolder(MultipleRowViewHolder holder, int position) {
        holder.multipleContent.setText(multipleRowModelList.get(position).modelContent);
    }

    @Override
    public int getItemCount() {
        return (multipleRowModelList!= null && multipleRowModelList.size() > 0 ) ? multipleRowModelList.size() : 0;
    }

    @Override
    public int getItemViewType(int position) {

        MultipleRowModel multipleRowModel = multipleRowModelList.get(position);

        if (multipleRowModel != null)
            return multipleRowModel.type;

        return super.getItemViewType(position);
    }

}

Step 4: Finally our MainActivity looks something like this.

public class MainActivity extends AppCompatActivity {

    private RecyclerView multipleRowRecyclerView;
    private MultipleRowAdapter multipleRowAdapter;

    private List<MultipleRowModel> multipleRowModelList = new ArrayList<>();

    @Override

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        multipleRowRecyclerView = (RecyclerView)findViewById(R.id.multipleRowRecyclerView);
        multipleRowRecyclerView.setHasFixedSize(true);

        LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this, OrientationHelper.VERTICAL, false);
        multipleRowRecyclerView.setLayoutManager(linearLayoutManager);
        multipleRowRecyclerView.setItemAnimator(new DefaultItemAnimator());

        fillAdapter();

        multipleRowAdapter = new MultipleRowAdapter(MainActivity.this, multipleRowModelList);

        multipleRowRecyclerView.setAdapter(multipleRowAdapter);
    }

    private void fillAdapter() {

        int type;

        String content;

        for (int i = 0; i < 10; i++) {

            if (i == 0 || i == 5 || i == 9) {
                type = AppConstant.FIRST_ROW;
                content = "Type 1: This is Multiple row layout";
            } else {
                type = AppConstant.OTHER_ROW;
                content = "Type 2";
            }

            multipleRowModelList.add(new MultipleRowModel(type , content));
        }
    }
}

GitHub Project HERE

Sample Output :

Read More