Tutorial #95: Resolving the Dalvik compiler limitation on 65K methods

Hello everyone!

In previous versions of the Android operating system, as applications grew in size one would encounter build errors that would indicate that the application has reached a limit of the Android application build architecture. The error would be as follows,

Conversion to Dalvik format failed:
Unable to execute dex: method ID not in [0, 0xffff]: 65536

If you observe the error closely, it specifies the number 65536. As mentioned on the developer’s page, this number is significant as it represents the total number of references that can be invoked by the code within a single Dalvik Executable (dex) bytecode file.

Developers hence need to resolve this error by adding multidex support to their application. From Android 5.0 (Lollipop) onwards, Android uses a runtime called ART which natively supports loading multiple dex files from application APK files. However, through this tutorial, we will learn one of the ways to resolve the Dalvik compiler limitation in previous (older) versions of Android.

Pre-requisites: Android Studio (version 1.0.0-rc4), Gradle plugin (version 2.2.1), latest Android SDK (with build tools installed for version 21)

Step 1: Configure application to add multidex support

Launch the Android Studio IDE and open any of your existing Android projects that contain more than 65K methods due to external libraries (.jar) files. Open the build.gradle file of your project and add the following lines of code,

apply plugin: 'com.android.application'
....
....

    compileSdkVersion 21
    buildToolsVersion '21.1.1'

    defaultConfig {
        applicationId "com.app.multidex"
        minSdkVersion 19
        targetSdkVersion 20
        versionCode 1
        versionName "1.0"

        // Enabling multidex support.
        multiDexEnabled true
    }
    buildTypes {
        release {
            runProguard true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile 'com.android.support:multidex:1.0.0'
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile files('libs/my_large_file1.jar')
    compile files('libs/my_large_file2.jar')
}

As seen above, it is important to specify the multiDexEnabled setting in the defaultConfig, buildType, or productFlavor sections of your Gradle build file. In addition, one needs to add the multidex support library as a dependency in the dependencies section.

Step 2: Edit AndroidManifest.xml file

In the manifest file one needs to add the MultiDexApplication class from the multidex support library to the application element as follows,

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.app.multidex">
    <application
        ...
        android:name="android.support.multidex.MultiDexApplication">
        ...
    </application>
</manifest>

Finally, save all changes. Make sure no errors are present. Once the project has compiled successfully the Android build tools construct a primary dex (classes.dex) and supporting (classes2.dex, classes3.dex) as needed.

multidex_support_android

Alternatively, one can also use an opensource GitHub project that when downloaded provides a custom_rules.xml build script that can be easily integrated in any Android application.

Reference: Building apps with over 65K methods

Tutorial #94: Using Retrofit for Android

Hello friends!

In one of my previous tutorials, I had talked about using the Volley networking library in Android. However, Volley is less documented and is totally focused on handling individual, small HTTP requests.

Retrofit on the other hand makes it incredibly easy to download JSON or XML data from a web API and parse it into a Plain Old Java Object (POJO). It’s released by Square and offers very easy to use REST API’s. Through this tutorial, we will learn how to use Retrofit for Android.

Pre-requisites: Eclipse IDE, Android SDK

Step 1: Create Android project

Create a new Android application project called AndroidRetrofitExample with package name com.app.retrofit. Choose the target SDK as Android 4.4 (API level 19)

Step 2: Create REST service interface

Create a new interface called GithubApiService that will help fetch the list of contributors for a particular repository as follows,

GithubApiService.java

package com.app.retrofit;

import java.util.List;
import retrofit.http.GET;
import retrofit.http.Path;

public interface GithubApiService {
	@GET("/repos/{owner}/{repo}/contributors")
	List<Contributor> contributors(
			@Path("owner") String owner,
			@Path("repo") String repo
	);
}

Step 3: Create Activity class

Now, let’s implement our MainActivity class. We will create an AsyncTask in order to call the public Github API service.

MainActivity.java

package com.app.retrofit;

import java.util.List;
import retrofit.RestAdapter;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends Activity {

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

	private class GetUserInfo extends AsyncTask<String, Void, String>{

		@Override
		protected String doInBackground(String... params) {
			// TODO Auto-generated method stub	
			try{ 
				RestAdapter restAdapter = new RestAdapter.Builder()
				.setEndpoint("https://api.github.com") 
				.build();

				GithubApiService github = restAdapter.create(GithubApiService.class);
				List<Contributor> contributors = github.contributors("pscholl", "glass_snippets");

				for (Contributor contributor : contributors) {
					Log.i("App", contributor.login + " - " + contributor.contributions);
				}

			}catch(Exception e){
				e.printStackTrace();
				return "failure";
			}	
           return "success";
	    }
      }
}

The RestAdapter is the class through which your API interfaces are turned into callable objects. By default, Retrofit will give you sane defaults for your platform but it allows for customization.

Contributor.java

package com.app.retrofit;

//POJO class
public class Contributor {
	
	// GitHub username
	public String login; 
	// Commit count
	public int contributions;
	
	public String getLogin() {
		return login;
	}
	public void setLogin(String login) {
		this.login = login;
	}
	public int getContributions() {
		return contributions;
	}
	public void setContributions(int contributions) {
		this.contributions = contributions;
	} 
}

Note: Make sure you have added the android.permission.INTERNET feature in the AndroidManifest.xml file. One also needs to add the following .jar files in the libs folder of the Android project.

  • retrofit-1.4.1.jar
  • okhttp-1.3.0-jar-with-dependencies.jar
  • gson-2.2.4.jar

Finally, save all changes. Make no errors are present. Run the application on an Android device and you should the following output in the Logcat window!

output

That’s it for this tutorial. Stay tuned for more! 🙂

Reference: Retrofit for Android

A date with Java 8!

[This is a long overdue post…]

Hello everyone!

Java is a pure object oriented programming language. Over the years, there have been many enhancements including some of the features like Annotations, Generics etc. Prior to Java 8, it was difficult to pass plain methods as arguments. Java 8 helps overcome this limitation by introducing a new feature called Lambda expressions. This addition to the language brings Java in line with other functional JVM-based languages such as Scala and Clojure.

Java 8 has introduced a lot more features including parallel operations, new date/time API’s, internationalization, concurrency etc. Through this post, we will learn how to implement two of the new features in Java 8 with the help of sample programs.

Pre-requisites: Java SE Development Kit 8, Notepad

1. Lambda expressions

Lambda Expressions, a new language feature, has been introduced in this release. They enable you to treat functionality as a method argument, or code as data. Lambda expressions let you express instances of single-method interfaces (referred to as functional interfaces) more compactly.

Create a new Java file called JavaEightTest and write the following code!

JavaEightTest.java

import java.io.*;
import java.lang.*;
import java.util.*;

public class JavaEightTest{

   public static void main(String args[]){
       
      //the old way 
      List<String> names = Arrays.asList("orange", "apples", "grapes", "bananas");
      Collections.sort(names, new Comparator<String>() {
              @Override
              public int compare(String a, String b) {
               return b.compareTo(a);
              }
      });

      //the new way
      Collections.sort(names, (String a, String b) -> b.compareTo(a));

      new Thread(
            () -> System.out.println("Hello from thread")
      ).start();

    }
}

2. Date/Time API’s

The Date-Time APIs, introduced in JDK 8, are a set of packages that model the most important aspects of date and time. The core classes in the java.time package use the calendar system defined in ISO-8601 (based on the Gregorian calendar system) as the default calendar. Other non-ISO calendar systems can be represented using the java.time.chrono package.

Create a new Java file called JavaEightDate and write the following code!

JavaEightDate.java

import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;
 
public class JavaEightDate {
 
    public static void main(String[] args) {
         
        //show the current date
        LocalDate today = LocalDate.now();
        System.out.println("Current Date is="+today);
         
        //create LocalDate 
        LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
        System.out.println("Specific Date="+firstDay_2014);
                  
        //current date in a specific zone, say "Asia/Kolkata"
        LocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));
        System.out.println("Current Date in IST="+todayKolkata);
     
        //getting date from the base date i.e 01/01/1970
        LocalDate dateFromBase = LocalDate.ofEpochDay(365);
        System.out.println("365th day from base date= "+dateFromBase);
       
    }
}

Finally, save all changes. Compile the above Java class using the javac command. If no errors occur then you should see the following output!

output

Reference: What’s New in JDK 8?

Tutorial #93: Implement CardView in Android

Hello everyone!

Prior to Android 5.0 Lollipop, developers would use open source libraries in order to implement a Card based view in Android. However, the latest release of Android now provides a CardView widget to show information inside cards that have a consistent look across the platform. In general, CardView widgets can have shadows and rounded corners.

As mentioned on the developer’s page, in order to create a card with a shadow, one can use the card_view:cardElevation attribute. CardView uses real elevation and dynamic shadows on Android 5.0 (API level 21) and above and falls back to a programmatic shadow implementation on earlier versions. Through this tutorial, we will learn how to implement a CardView in Android.

Pre-requisites: Eclipse IDE, Android SDK 5.0

Step 1: Create Android project

Launch the Eclipse IDE and create a new Android application project called AndroidLollipopNewExamples with package name com.app.lollipop.test. Let the target SDK be Android 5.0 (API level 21)

Step 2: Create Card layout

Now, let’s create our card layout using XML. Create a new XML file called activity_cardview and add the following code!

activity_cardview.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:card_view="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:gravity="center_horizontal"
    android:layout_height="match_parent">

    <android.support.v7.widget.CardView
        xmlns:card_view="http://schemas.android.com/apk/res-auto"
        android:id="@+id/card_view"
        android:layout_marginTop="20dp"
        android:layout_width="200dp"
        android:layout_height="100dp"
        card_view:cardCornerRadius="8dp"
        card_view:cardBackgroundColor="#C92A2A">

        <TextView
            android:id="@+id/info_text_header"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:text="@string/sample_text_header" />

        <ImageView
            android:id="@+id/info_image"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:contentDescription="@string/sample_text_image"
            android:layout_gravity="center"
            android:layout_marginTop="2dp"
            android:src="@drawable/ic_launcher" />

        <TextView
            android:id="@+id/info_text_footer"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:paddingTop="80dp"
            android:text="@string/sample_text_footer" />
    </android.support.v7.widget.CardView>

</LinearLayout>

To set the corner radius in your layouts, use the card_view:cardCornerRadius attribute. To set the corner radius in your Java code, use the CardView.setRadius method. Finally, in order to set the background color of a card, use the card_view:cardBackgroundColor attribute.

strings.xml

<resources>
    <string name="app_name">AndroidLollipopNewExamples</string>
    <string name="sample_text_header">Sample card header</string>
    <string name="sample_text_footer">Sample card footer</string>
    <string name="sample_text_image">Sample image</string>
</resources>

Step 3: Create Activity class

Our Activity class called TestCardActivity would be as follows,

TestCardActivity.java

package com.app.lollipop.test;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

public class TestCardActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_cardview);
	}	
}

No changes are to be made to the AndroidManifest.xml file. Run the application on an emulator and you should see the following output!

output

Reference: Creating Cards in Android

AngularJS: Routing

In any web application, navigation is crucial. If users can’t navigate through your application easily, you will quickly lose them. AngularJS provides an out of the box service provider called $routeProvider. Through AngularJS, developers can use routes to create different URLs for different content in an application.

As mentioned in the documentation, the routing functionality in Angular is due to the ngRoute module, which is distributed separately from the core Angular framework. The application’s module needs to declare this dependency in order to use the features provided by the ngRoute module. Through this post, we will learn how to implement routing using AngularJS.

Pre-requisites: Eclipse IDE (for Java EE developers), Apache Tomcat

Step 1: Launch Eclipse IDE and create a new Dynamic Web Project called AngularRouting. Choose the target runtime as Apache Tomcat 7.0

Step 2: Create HTML page

Create a new HTML page called index.html and place it inside the WebContent folder of your web project. In order to implement routing, the first thing to do is add the extra JavaScript inside the head section as follows!

index.html

....
  <head>
    <title>AngularJS Routing tutorial </title>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.26/angular.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.5/angular-route.min.js"></script>
  </head>
....

Next, let’s implement our $routeProvider. The $routeProvider is configured in the module’s config() function via calls to the when() and otherwise() functions.

index.html

....
var app = angular.module("demo",['ngRoute']);
app.config(['$routeProvider',
		  function($routeProvider) {
			$routeProvider.
				when('/ShowResult/:id', {
					templateUrl: 'templates/show_result.html',
					controller: 'ShowResultController'
				}).
				otherwise({
					redirectTo: '/'
				});
		}]);
....

We also need to register the ShowResultController and hence navigate to the new page depending upon the request parameter (in this case id). Here’s how our HTML page finally looks,

index.html

<!DOCTYPE html>
<html ng-app="demo">
  <head>
    <title>AngularJS Routing tutorial </title>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.26/angular.min.js"></script>
	<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.5/angular-route.min.js"></script>
  </head>
  <body>
	
	<div ng-controller="TableController">

	    <h2>Student data</h2>
		
		<table>
		    <tr>
			  <th> Id </th>
			  <th> Name </th>
			  <th> Age </th>
			  <th> Email </th>
			  <th> City </th>
			  <th> Action </th>
			</tr>
		   <tr ng-repeat="student in students">
		      <td>{{ student.id }} </td>
		      <td>{{ student.name | uppercase}} </td>
			  <td>{{ student.age }} </td>
			  <td>{{ student.email | lowercase }} </td>
		      <td>{{ student.city | uppercase}} </td>
			  <td> <a href="#ShowResult/{{student.id}}">Show Result</a></td>
		  </tr>	   
		</table>
	 	
		<div ng-view></div>

		
	</div>

	<script type="text/javascript">
		
		var app = angular.module("demo",['ngRoute']);
		app.controller("TableController", function($scope){
		    $scope.students = [
				{ id:"101", name: 'Hari', city: 'Mumbai', email:'hari@gmail.com',age:'16'},
				{ id:"102", name: 'Alexander', city: 'Paris', email:'alex@gmail.com',age:'18'}
			];
		});
		
		app.config(['$routeProvider',
		  function($routeProvider) {
			$routeProvider.
				when('/ShowResult/:id', {
					templateUrl: 'templates/show_result.html',
					controller: 'ShowResultController'
				}).
				otherwise({
					redirectTo: '/'
				});
		}]);
		
		app.controller('ShowResultController', function($scope, $routeParams) {
		    $scope.id = $routeParams.id;
		    
		    if($scope.id == 101){
		    	$scope.message = 'The result for student is passed';
		    }else{
		    	$scope.message = 'The result for student is failed';
		    }
		});
	
	</script>
	
  </body>
</html>

Important: Notice the ngView directive in the above page. Inside the div with the ngView directive (can also be written ng-view) the HTML template specific to the given route will be displayed.

show_result.html

<h2>Show Result</h2>
 
{{ message }}

Finally, save all changes and make sure no errors are present. Run the application on the Tomcat server and you should see the following output!

output

Reference: Routing in AngularJS

Tutorial #92: Live Streaming using Vitamio in Android

Hello friends!

Live video streaming is one of the most challenging functionalities to incorporate in an Android application. RTMP (Real Time Messaging Protocol) was developed by Adobe for Flash Player to transmit real-time media (audio, video) between a server and flash player. However, Android does not support RTMP out of the box. Hence, developers need to use third party libraries in order to stream a RTMP video.

Vitamio is an open multimedia framework or library for Android and iOS, with full and real hardware accelerated decoder and renderer. It supports streaming network protocols such as RTSP, RTMP, HLS and can play 720p/1080p HD mp4, mkv, m4v, mov, flv, avi, rmvb and many other video formats in Android and iOS. Through this tutorial, we will learn how to implement live streaming using Vitamio in Android.

Pre-requisites: Eclipse IDE, Android SDK

Step 1: Create Android project

Launch Eclipse IDE and create a new Android application project called AndroidVitamioDemo with package name com.app.vitamio.stream. Choose the target SDK as Android 4.4

Step 2: Add reference to Vitamio bundle (library)

Before creating the streaming Activity class, one needs to download the Vitamio Bundle and add the same as a reference to the above Android project. The Vitamio library will provide the required classes to setup, initialize and play the live stream.

Step 3: Create Activity class

Create a new Activity class called LiveStreamingActivity in order to implement the streaming process. Developers can also add an EditText to obtain the path or URL of the media file. For this tutorial, I have directly provided the URL to the media file.

LiveStreamingActivity.java

package com.app.vitamio.stream;

import io.vov.vitamio.LibsChecker;
import io.vov.vitamio.MediaPlayer;
import io.vov.vitamio.widget.MediaController;
import io.vov.vitamio.widget.VideoView;
import android.app.Activity;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.Toast;

public class LiveStreamingActivity extends Activity {

	private String pathToFileOrUrl= "rtmp://204.107.26.252:8086/live/796.high.stream";
	private VideoView mVideoView;
	
	@Override
	public void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		
		if (!LibsChecker.checkVitamioLibs(this))
			return;
		
		setContentView(R.layout.activity_video_stream);
		mVideoView = (VideoView) findViewById(R.id.surface_view);

		if (pathToFileOrUrl == "") {
			Toast.makeText(this, "Please set the video path for your media file", Toast.LENGTH_LONG).show();
			return;
		} else {

			/*
			 * Alternatively,for streaming media you can use
			 * mVideoView.setVideoURI(Uri.parse(URLstring));
			 */
			mVideoView.setVideoPath(pathToFileOrUrl);
			mVideoView.setMediaController(new MediaController(this));
			mVideoView.requestFocus();

			mVideoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
				@Override
				public void onPrepared(MediaPlayer mediaPlayer) {
					// optional need Vitamio 4.0
					mediaPlayer.setPlaybackSpeed(1.0f);
				}
			});
		}

	}
	
	public void startPlay(View view) {
		if (!TextUtils.isEmpty(pathToFileOrUrl)) {
			mVideoView.setVideoPath(pathToFileOrUrl);
		}
	}

	public void openVideo(View View) {
		mVideoView.setVideoPath(pathToFileOrUrl);
	}

}

activity_video_stream.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:orientation="horizontal">

        <Button
            android:id="@+id/start"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:onClick="startPlay"
            android:text="@string/play_video"/>
    </LinearLayout>

    <io.vov.vitamio.widget.VideoView
        android:id="@+id/surface_view"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:onClick="openVideo"
        android:text="@string/open_video"/>

</LinearLayout>

Step 4: Add permissions to Manifest file!

One needs to update the AndroidManifest.xml file in order to include the required permissions.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.app.vitamio.stream"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="19" />
 
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name">
        <activity
            android:name=".LiveStreamingActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
       
        <activity
            android:name="io.vov.vitamio.activity.InitActivity"
            android:configChanges="orientation|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
            android:launchMode="singleTop"
            android:theme="@android:style/Theme.NoTitleBar"
            android:windowSoftInputMode="stateAlwaysHidden" />
        
    </application>

</manifest>

Save all changes. Make sure no errors are present. Run the application on an Android device and you should see the following output!

output_1

output_2

That’s it for this tutorial. Stay tuned for more! 🙂

Reference: Vitamio Bundle

Using multiple processes in Android

Hello everyone!

In Android, when an application’s first component starts, a new process for the application with a single thread of execution called main thread or UI Thread gets created. By default, all components of the same application usually run in the same process. A Service when invoked using the startService method from an Activity runs on the main application thread. However, if the Service performs an intensive task then it may cause your application to become unresponsive eventually resulting in an ANR (Application Not Responding) message.

Memory management plays an important role in applications involving multiple processes. As mentioned on the Android developer’s page, one can specify a separate process for each application component by declaring the android:process attribute for each component in the manifest file. For example, one can specify a service to run in a process separate from the application’s main process by declaring a new process named background as follows.

<service android:name= ".MyBackgroundService"
         android:process= ":background" />

Through this post, we will learn how to manage and use multiple processes in Android.

Pre-requisites: Eclipse IDE, Android SDK

Step 1: Create Service class

In any of your existing Android projects, create two new Service classes named FirstService and SecondService respectively.

FirstService.java

package com.example;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class FirstService extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		// TODO Auto-generated method stub
		Log.i("FirstService", "onStartCommand method is called");
		return Service.START_NOT_STICKY;
	}
	
	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		Log.i("FirstService","onCreate Method is called");
		super.onCreate();
	}

	@Override
	public void onDestroy() {
		// TODO Auto-generated method stub
		Log.i("FirstService","OnDestroy Method is called");
		super.onDestroy();
	}

	@Override
	public boolean stopService(Intent name) {
		// TODO Auto-generated method stub
		Log.i("FirstService","stopService Method is called");
		return super.stopService(name);
	}

}

SecondService.java

package com.example;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class SecondService extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		// TODO Auto-generated method stub
		Log.i("SecondService", "onStartCommand method is called");
		return Service.START_NOT_STICKY;
	}
	
	@Override
	public void onCreate() {
		// TODO Auto-generated method stub
		Log.i("SecondService","onCreate Method is called");
		super.onCreate();
	}

	@Override
	public void onDestroy() {
		// TODO Auto-generated method stub
		Log.i("SecondService","OnDestroy Method is called");
		super.onDestroy();
	}

	@Override
	public boolean stopService(Intent name) {
		// TODO Auto-generated method stub
		Log.i("SecondService","stopService Method is called");
		return super.stopService(name);
	}

}

Note: Make sure you have registered the above Services in the AndroidManifest.xml file as follows!

AndroidManifest.xml

....
<application
        android:allowBackup="true"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">
        <activity
            android:name="com.example.TestProcessActivity"
            android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
         <service
            android:name="com.example.FirstService"
            android:process=":firstservice">
        </service>
        <service
            android:name="com.example.SecondService"
            android:process=":secondservice">
        </service>
</application>
....

Step 2: Create Activity class

Create a new Activity class called TestProcessActivity that will include certain methods to call the respective Services.

TestProcessActivity.java

package com.example;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class TestProcessActivity extends Activity {

	private Intent m_objServiceIntent = null; 

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

	public void startFirstService(View view){
		m_objServiceIntent = new Intent(TestProcessActivity.this, FirstService.class);
		startService(m_objServiceIntent);
	}

	public void startSecondService(View view){
		m_objServiceIntent = new Intent(TestProcessActivity.this, SecondService.class);
		startService(m_objServiceIntent);
	}
}

activity_process.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="startFirstService"
        android:text="@string/call_first_service"/>

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="startSecondService"
        android:text="@string/call_second_service"/>

</LinearLayout>

Finally, make sure no errors are present. Save all changes and run the application on an Android device. If no errors occur then you should be able to see the following output!

output_1

Next, you need to call each Service by clicking the respective button.

first_service

second_service

Now, try switching to the DDMS perspective in order to view the multiple processes running on the Android device.

ddms_output

Reference: Multiple Processes in Android

AngularJS: Custom directives

Hello everyone!

Directives play an important role in AngularJS applications allowing developers to interact and hence simplify DOM manipulation. One of the most important features of a web application is reusability. AngularJS helps us to build custom directives that can in turn modify or even create a totally new behavior in HTML. To call a directive from HTML, we can simple apply the directive in the DOM. At present, there are four different types of directives namely,

1. Element directives

An element directive is activated when AngularJS finds a matching HTML element in the HTML template. Angular normalizes an element’s tag and attribute name to determine which elements match which directives.

2. Attribute directives

In HTML, we mention attributes for a particular tag. This tag holds the code snippet. Attribute directives help to write specific code that such tags can simply include.

3. CSS class directives

4. Comment directives

Note: AngularJS recommends that you try to use element and attribute directives, and leave the CSS class and comment directives (unless absolutely necessary).

Through this tutorial, we will learn how to use the element directive in AngularJS.

Pre-requisites: Eclipse IDE (for Java EE developers), Apache Tomcat 7.0

Step 1: Launch Eclipse IDE and create a new Dynamic Web Project called AngularCustomDirectives with module version 3.0. Create the following index.html page in the WebContent folder.

index.html

<!DOCTYPE html>
<html ng-app="demo">
  <head>
    <script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.2.26/angular.min.js"></script>
  </head>
  <body>
	
	<div ng-controller="ListController">
		<customerinfo></customerinfo>
	</div>

	<script type="text/javascript">	
		var app = angular.module("demo",[]);
		app.directive('customerinfo', function() {
			
			var directive = {};
		    directive.restrict = 'E'; /* restrict this directive to elements */
			directive.templateUrl = "html-templates/customerinfo-template.html";
			
			return directive;
			
		});
		
		app.controller("ListController", function($scope){
		    $scope.customers = [
				{ name: 'Hari', city: 'Mumbai', email:'hari@gmail.com',age:'16'},
				{ name: 'Alexander', city: 'Paris', email:'alex@gmail.com',age:'18'}
			];
		});
		
	</script>
	
  </body>
</html>

The restrict field is used to set if the directive should be activated by a matching HTML element, or an element attribute. By setting restrict to E one can specify that only HTML elements named customerinfo should activate the directive.

Step 2: Create a new folder called html-templates under the WebContent folder and create the customerinfo-template.html file as follows.

customerinfo-template.html

	<h2>List of customers</h2>
	<ul>
		<li ng-repeat="customer in customers">
		    Name: {{ customer.name |uppercase}} 
		    Age: {{ customer.age }} 
		    Email: {{ customer.email |lowercase }} 
		    City: {{ customer.city | uppercase}}
		</li>
	</ul>

Save all changes. Make sure no errors are present. Run the project on the Tomcat server to launch the corresponding web page in a browser and you should see the following output!

output

Reference: AngularJS directives

Tutorial #91: Setting up Eclipse for Android Wear Development

The Android Wear SDK was officially launched at Google I/O back in June 2014. Android Wear is a version of Google’s Android operating system designed for smartwatches and other wearables. It helps display notifications and integrates the Google Now functionality by pairing with mobile phones. The Wear SDK includes code samples, documentation required to build applications that directly run on wearable, create custom user interfaces and sync data between mobile phones and wearables.

However, it is important for developers to first setup their environment in order to create wearable applications. This tutorial helps to setup up the Eclipse IDE for Android Wear development.

Pre-requisites: Eclipse IDE, Android Wear SDK

Step 1: Install Android Wear SDK and support repository

Before creating wearable applications, one needs to download and install the Android Wear SDK from the SDK manager as shown below. One also needs to install the Android support repository from the Extras section.

sdk_manager_install_wear_sdk

sdk_manager_support_repository

Step 2: Create support library project

Once the Android Wear SDK has been installed successfully, one will find the wearable folder present under,

{ANDROID_SDK}\extras\google\m2repository\com\google\android\support\

Next, rename the wearable-1.0.0.aar file as wearable-1.0.0.zip and extract the .zip file to obtain the wearable Android project. Now, launch Eclipse IDE and choose File –> Import –> Existing Android code into workspace. Navigate to the path where the project exists and import the same. Finally, create a libs folder and move the classes.jar in the libs folder. Right click the imported project, go to Android, select build target as Android 4.4W.2 and tick the checkbox Is Library. This makes sure that the project is setup as a library project targeting Android API 20.

Create library project

Create library project

Our final project structure would look something like this,

Project Structure

Project Structure

One can now create a new Android Wear project, or import one of the samples that come with the SDK, and add the above Wear support library as a dependency.

That’s it for this tutorial. Stay tuned for more! 🙂

Android Tools: Zipalign

Hello friends!

Android provides developers the zipalign tool to align your .apk file before distributing to end-users. The tool not only provides better optimization but also ensures that that all uncompressed data starts with a particular alignment relative to the start of the file. It is important to note that the zipalign must only be performed after the .apk file has been signed with your private key. If you perform zipalign before signing, then the signing procedure will undo the alignment.

Through this post, we will learn how to use the zipalign tool in Android.

Pre-requisites: Eclipse IDE, Android SDK

How to export signed apk?

Launch Eclipse IDE and switch to your Android project workspace. Choose any of your existing Android projects for which you need to zipalign the .apk. Before generating the signed apk for your Android project, it is necessary to follow the below steps as per the official documentation for signing an application.

1. Check the AndroidManifest.xml and verify that android:debuggable attribute is set to false. The attribute indicates whether or not the application can be debugged, even when running on a device in user mode.

2. Check the android:versionCode and android:versionName attributes. If it is a new version of an existing apk, make sure these values are larger than the previous apk file.

3. Finally, right click your application, go to Android Tools -> Export Signed Application Package and sign the application using a release key certificate (not debug) as mentioned over here.

Running zipalign

Once you have obtained the signed apk, you can use the zipalign tool for optimization. The following command converts the signed apk to a zipalign signed apk that can be uploaded on the Google Play Store.

zipalign -v 4 AndroidRandomExamples.apk AndroidRandomExamples_aligned.apk

Syntax

zipalign -v 4 your_project_name-unaligned.apk your_project_name.apk

The output of the zipalign process is as follows!

Output

Output

Reference: Android ZipAlign