How to clear Associate Android Developer exam?

If you are an experienced android developer or you are looking for a job opportunity in android and you are looking for the way to qualify and certify your android application development skills, Associate Android Developer Certification is the one you should be looking for.

In this article, you will know, how you can apply for the certification and how you can crack the exam.


What is Associate Android Developer?

Google introduced the Associate Android Developer Certification at Google I/O 2016.

The Associate Android Developer exam demonstrates the type of skill that a newer Android Developer should have as they begin their career. By passing this exam and earning the Associate Android Developer Certification, you will show that you are competent and skilled in tasks that a developer typically performs.

Here is the introduction video, which will give you more insight into the program.


How to apply for the certification?

To apply for the android certification, visit the Google Developer Certification website and sign up for the exam.

The fee for the exam is $149 or INR 6500 while writing this post. You can pay the fees using available payment options.

Once you pay your exam fees you can start your exam whenever you want.


What things should you learn before starting the exam?

AAD exam is to check your skills in application development.

Before applying for the exam you must have good knowledge of following areas:

1. Testing and Debugging:

  • You should be able to analyze application crashes and find common bugs such as layout errors and memory leaks.
  • Also, you must have the knowledge of writing the espresso test cases and unit tests.

2. Application User Interface (UI) and User Experience (UX):

  • You must have the knowledge of how to construct layouts–using both XML and Java code for the standard framework UI elements as well as custom views.
  • You should have knowledge of creating custom views, applying themes to the views, implementing RecyclerView, apply accessibility description to view.
  • You should also know how to localize the application’s UI text into one other language

3. Fundamental Application Components:

  • You should have good knowledge of handling the activity and fragment life-cycle, orientation changes, data loaders, deep links, notifications, async tasks and integrating code from external support library.
  • You must have knowledge of handling background services and schedule a task using alarm manager.

4. Persistent Data Storage:

  • You should have good command over creating SQLite database and querying it.
  • You should have knowledge of content provider and shared preferences.

5. Enhanced System Integration:

  • You should be able to create a widget, update the widget and also creating and updating the notifications.

Once you are prepared with all the above areas, apply for the exam. Let’s see the exam procedure in detail.


What is the exam procedure?

AAD exam is made up of two rounds.

  1. Practical exam, where you will write real code.
  2. An exit interview.

Practical exam:

null

Practical exam will be 48 hours long.

Google certification team will provide you the source code of one application and the list of tasks you need to perform. You need to complete those tasks before 48 hours and submit the application source code.

These tasks are divided into three categories:

1. Build some code from scratch.

  • In these types of tasks, you have to develop some functionality in the application from the scratch. These tasks may ask you to develop some activity, create database structure or implement a content provider for the application.
  • To complete these tasks you will require a good knowledge of all the above-described topics. Also, it is very important that the code you write should follow proper coding guidelines and it doesn’t break any existing functionality.
  • Check the implemented functionality with edge cases (e.g. rotation changes, network conditions) before you submit your application code for review.

2. Add new functionality to your existing code.

  • These type of tasks ask you to build something upon the existing functionality. You will also find ‘//TODO‘ comments throughout the code provided while starting the exams. e.g. These tasks may ask you to create a table in existing database, display some list items in the existing activity using RecyclerView etc.
  • To complete these type of tasks you must have sound knowledge of Android components. Also, you need to see that you don’t make any changes in the existing code or change the name of the classes/methods.
  • Check the functionality you worked on, thoroughly before submitting the code to review.

3. Fix bugs in existing code and test the application.

  • These tasks are specifically designed to check you testing and debugging skills. These tasks may ask you to fix some existing bugs in the application code and also ask you to write some espresso tests to test the application.
  • To complete these tasks, you must have knowledge of how to instrumentation and unit tests. You must know how to write test cases in espresso.
  • Before submitting your code it is advisable that you run your test cases and make sure that all tests are passing.

After completing all the tasks, upload your code in .zip format and submit the code for review. You will receive the result for the same within 45 days.

Exit interview:

null

Once you pass the practice exam, certification team will ask you to choose your convenient time for the exit interview. This will be a chance for you to explain your work and your knowledge.

The exit interview will be taken by one of the members from the certification team. It will be through a video call.

You have to provide proof of your identity using any other government authorized identity card at the starting of the interview.

After that, the interviewer will ask you to explain your work and the tasks you performed in the practical exam. The interviewer will also ask you some questions related to fundamentals of the Android to validate your skill level. The exit interview will take about 15 to 30 minutes.

Once you complete the interview, you will receive the final result within a couple of weeks.


How are you going to receive your badge?

  • If you pass the exam you will also receive your “Android Associate Developer” badge in the email with which you applied for the exam.
null
My AAD Badge
  • You will also receive an authentication link from the certification team, that you can share on your social media profile and mention it in your resume. This link will contain your badge details and authenticates you as AAD. (Here is the link to my badge: http://bcert.me/svygckgc.)

 


Should I apply for the exam?

Yes, definitely!!!

  • Android Associate Developer certification will authenticate your skill as an android developer. It will help you to increase your career opportunities if you are an employer. It will also help you to get a good job if you are a fresher.
  • Right now this is the only way to authenticate your skills and let the world know about your android development knowledge.

If you have any questions regarding the exam, feel fee to write it as a comment below or you can hit me twitter at @kevalpatel2106.

Best of luck for your exam!!!😃

How to handle background services in ANDROID O?

Nothing makes an android developer more crazy than a new version of Android.

Google has just revealed the DP1 of the next iteration of android: Android O. There are many new exciting features and under the hood performance improvements in the newest version of android.

While others talk about what will be the name of Android O, let’s analyze this flavor of android from developer’s perspective. For android developers there are four groundbreaking changes:

  • Background execution limits
  • Location updates limit
  • Removing of implicit broadcasts
  • Notification channels

Here, in this article let’s talk about background execution limitation. Background execution limitations mainly apply to two major components:

  • Service
  • Wakelocks

Let’s talk about the limitations applied on services in this article.


What is the service in android?

Let’s first refresh what is the service in Android? As per the android documentation:

A Service is an application component that can perform long-running operations in the background, and it does not provide a user interface.

So, fundamentally Service is the same thing as the activity but it doesn’t have the UI component in it. So, it doesn’t have to perform smooth animation at 60 fps. That’s why it can run perform any task for the longer period of time than the activity.

There are three types of the service:

  • Started Service — A service is started when an application component (such as an activity) calls startService().
  • Bound Service — A service is bound when an application component binds to it by calling bindService().
  • Scheduled Service — A service is scheduled when an API such as the JobScheduler.

Background vs Foreground applications:

To learn background execution changes, we need to know the difference between background and foreground application first.

Rule of thumb, your application will be considered as a foreground service if any of the below three cases are true:

  1. Your application has currently visible activity.
  2. Your application has foreground service running.
  3. Your application is connected to another foreground app by binding the service or by consuming their content providers.

If any of the above scenarios is not true in the current instance, your application is considered to be in the background.


Why do we need to restrict the use of background services?

Whenever your applications run in the background using services, your application consumes two precious resources: 1) Memory and 2) Battery.

These two are limited resources on the mobile devices and most of the low to mid-range devices doesn’t have plenty of memory or battery inside it.

Suppose, if your application is doing some very intensive tasks in the background and using the larger amount of RAM to perform that task, then this will create the very junky user experience, especially if the user is using another resource-intensive app, such as playing a game or watching a video in the foreground.

As per the documentation for the started service the best practice is,

When the operation is complete, the service should stop itself.

But, many applications have long running background services, which basically runs for the infinite time to either maintain the socket connection with the server or monitor some tasks or user activity. These services create battery drain and also they constantly consume memory.

From past couple of releases of android (Starting from Marshmallow), Google is trying very hard to increase the battery life and reduce the memory consumption used by the applications by introducing the doze mode and app standby by delaying the background execution by some amount of time if the phone is ideal.

But most of the time despite of knowing the downsides of the long-running services developers still use them. (Mostly because it is easy to implement and maintain rather than using other workarounds.)


What are the limitations on services starting from Android O?

Starting from Android O, if your application is in the background (check above three conditions), your application is allowed to create and run background services for some minutes.

After some minutes passed, your application will enter in the ideal stage. When your application enters in the ideal stage, the system will stop all the background services just like your service calls Service.stopSelf().

And here comes the fun part…

As I discussed above, the problem of battery drain and memory consumption are mainly caused by started services. To eliminate this, Android O completely prevents the use of startService() method to start the service. If you call startService() on Android O, you will end up getting IllegalArgumentException 😲.

1*e6OC5HRUY949JdG89JpXVw.gif

There are some exceptions in these scenarios when your application is whitelisted temporarily for some time window. During this period, your application can create background services freely. The application will put into temporary whitelist under below situations:

  • When high priority FCM message received
  • Receiving a broadcast.
  • Executing a PendingIntent from a notification.

How can you run background tasks?

If you are building a very large android application, there might be some genuine scenarios where you need to perform some tasks in background. Since starting a service using startService() command is not an option, we need to find out other ways to perform the tasks in background.

Scheduling your tasks using Job Scheduler API:

  • JobScheduler API introduced in API21 to perform background tasks.
  • This API allows you to run scheduled service and the android system will batch all the services from different applications and run them together in some particular timeframe. The reason behind this is to reduce the amount of time your phone’s CPU and radio wakes up by batching the tasks together. This will consume less battery and maintains system health.
  • What if your application has minSdkVersion < 21? In this situation, the official way to schedule the job is to use Firebase Job Dispatcher. Firebase Job Dispatcher is supported to all the way down up to API9.

Use foreground service:

If you want some long running tasks to be performed in the background, consider using foreground services for that. None of the above background execution limitations applies to the foreground services.

This will also keep your user aware that your application is performing some background tasks by displaying the ongoing notification. This will increase transparency with your user.

Before Android O, if you want to create foreground service, you usually start a background service by calling startService(). Then after you can promote your service to the foreground service by assigning an ongoing notification using startForeground() method. But starting from Android O, you cannot use startService() anymore. So to create foreground service you have to use NotificationManager.startServiceInForeground(). This method is equivalent to creating background service and promoting it to the foreground service combine.


Conclusion:

These limitations applied to the background service will definitely provide extended battery life and also lower RAM usage. Ultimately it will make your applications smooth and your user happy.

Should you make changes in your application code now?

Android O is still in DP1. There are 3 more developer previews to be release before the final version of Android O gets released. There might be some API changes in upcoming releases. So, right now it’s time to think the effects of these changes in your application and think about the alternative solution for them. Once developer preview 3–4 gets released, apply those changes to your applications and make your application Android O compatible.