If you want to learn more about the Android Gradle Plugin setting check out the android-gradle Documentation.

If you are interested in alternative emulators, you could look at Genymotion. It provides a free plan and requires smaller amount of RAM.

LayoutParams and Layout_ Attributes

Performance impact from using RelativeLayouts near the top of your view hierarchy

As explained in this article on performance in Android, a RelativeLayout requires two layout passes to render properly. For complex view hierarchies, this can have a significant impact on performance. Nesting RelativeLayouts makes this problem even worse, because every RelativeLayout causes the number of layout passes to go up.

• The official gradle homepage
• How to configure gradle builds
• The android plugin for gradle
• Android Gradle DSL

Gradle for Android - Extended documentation:

There is another tag where you can find more topics and examples about the use of gradle in Android.
http://stackoverflow.com/documentation/android-gradle/topics

 dependencies {
    compile 'com.android.support:design:24.2.0'
}

Official Documentation:

https://developer.android.com/reference/android/support/design/widget/NavigationView.html

Material Design Specifications:

https://material.google.com/patterns/navigation-drawer.html#navigation-drawer-content

Caveats of using implicit intent

When calling a implicit intent it's always helpful to check if it's possible by the system to handle it.

This can be done by checking using PackageManager.queryIntentActivities(Intent intent, int flags)

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

Starting Activity which is a singleTask or singleTop

When the activity's launch mode is singleTask or singleTop, the onActivityResult will be called as soon as the activity is started with a data null. To prevent this, use Intent.setFlags(0) to reset the default flags.

This topic is about using the org.json package that is included in the Android SDK.

android {
    ....
    dataBinding {
        enabled = true
    }
}

• Official documentation

Official Documentation

https://developer.android.com/reference/android/content/SharedPreferences.html

Also see the original Android blog post introducing the Design Support Library

Official Documentation

https://developer.android.com/design/material/index.html

Guidelines for Material Design

https://material.io/guidelines

Other design resources and libraries

https://design.google.com/resources/

Official documentation:

https://developer.android.com/studio/write/lint.html

For info on IntentService, see here: IntentService Example

• targetSdkVersion is the latest version of Android that you have tested against.

  The framework will use targetSdkVersion to determine when to enable certain compatibility behaviors. For example, targeting API level 23 or above will opt you in to the runtime permissions model.

• minSdkVersion is the minimum version of Android that your application supports. Users running any version of Android older than this version will not be able to install your application or see it in the Play Store.

• maxSdkVersion is the maximum version of Android that your application supports. Users running any version of Android newer than this version will not be able to install your application or see it in the Play Store. This should generally not be used as most applications will work on newer versions of Android without any additional effort.

• compileSdkVersion is the version of the Android SDK that your application will be compiled with. It should generally be the latest version of Android that has been publicly released. This defines which APIs you can access when writing your code. You cannot call methods introduced in API level 23 if your compileSdkVersion is set to 22 or lower.

dependencies {
    // Match the version of your support library dependency
    compile 'com.android.support:recyclerview-v7:25.3.1'
}

You can find latest version number of recyclerview from official site.

Other related topics:

There are other topics which describe the RecyclerView components:

• RecyclerView LayoutManagers
• RecyclerView ItemDecorations
• RecyclerView onClickListeners

Official Documentation

http://developer.android.com/reference/android/support/v7/widget/RecyclerView.html

Older versions:

  //it requires compileSdkVersion 25
  compile 'com.android.support:recyclerview-v7:25.2.0'
  compile 'com.android.support:recyclerview-v7:25.1.0'
  compile 'com.android.support:recyclerview-v7:25.0.0'

  //it requires compileSdkVersion 24
  compile 'com.android.support:recyclerview-v7:24.2.1' 
  compile 'com.android.support:recyclerview-v7:24.2.0' 
  compile 'com.android.support:recyclerview-v7:24.1.1'  
  compile 'com.android.support:recyclerview-v7:24.1.0'  

  //it requires compileSdkVersion 23
  compile 'com.android.support:recyclerview-v7:23.4.0'
  compile 'com.android.support:recyclerview-v7:23.3.0'
  compile 'com.android.support:recyclerview-v7:23.2.1'
  compile 'com.android.support:recyclerview-v7:23.2.0'
  compile 'com.android.support:recyclerview-v7:23.1.1'
  compile 'com.android.support:recyclerview-v7:23.1.0'
  compile 'com.android.support:recyclerview-v7:23.0.1'
  compile 'com.android.support:recyclerview-v7:23.0.0'

  //it requires compileSdkVersion 22
  compile 'com.android.support:recyclerview-v7:22.2.1'
  compile 'com.android.support:recyclerview-v7:22.2.0'
  compile 'com.android.support:recyclerview-v7:22.1.1'
  compile 'com.android.support:recyclerview-v7:22.1.0'
  compile 'com.android.support:recyclerview-v7:22.0.0'

  //it requires compileSdkVersion 21
  compile 'com.android.support:recyclerview-v7:21.0.3'
  compile 'com.android.support:recyclerview-v7:21.0.2'
  compile 'com.android.support:recyclerview-v7:21.0.0'

"Porter Duff" in itself is an alpha compositing technique named after a paper by Thomas Porter and Tom Duff.

To summarize, the technique takes two images with alpha channel and generates the output image by combining pixels values of two images. The various combining modes result in different output image. For example, in following image, blue shape (source, existing pixels) is combined with Yellow shape (destination, new pixels) in different modes:

A Nine Patch (9-Patch) image is a bitmap that has a single pixel wide border around the entire image. Ignoring the 4 pixels in the corners of the image. This border provides metadata for the bitmap itself. Bounds are marked by solid black line(s).

A Nine Patch image is stored with the extension .9.png.

The top border indicates areas that stretch horizontally. The left border indicates areas that stretch vertically.

The bottom border indicates padding horizontally. The right border indicates padding vertically.

The padding borders are usually used to determine where text is to be drawn.

There is an excellent tool provided by Google that greatly simplifies the creation of these files.

Located in the Android SDK: android-sdk\tools\lib\draw9patch.jar

Decorations are static

Since decorations are only drawn, it is not possible to add click listeners or other UI functionality to them.

Multiple decorations

Adding multiple decorations to a RecyclerView will work in some cases, but there is currently no public API to take other possible decorations into account when measuring or drawing. You can get the view bounds or the view decorated bounds, where the decorated bounds are the sum of all the decoration offsets applied.

Other related topics:

RecyclerView
RecyclerView onClickListeners

Official javadoc

https://developer.android.com/reference/android/support/v7/widget/RecyclerView.ItemDecoration.html

If you are using android.app.Fragment native Fragments with a FragmentPagerAdapter or FragmentStatePagerAdapter, you need to use the v13 support library versions of the adapter, i.e. android.support.v13.app.FragmentStatePagerAdapter.

If you are using android.support.v4.app.Fragment support library Fragments with a FragmentPagerAdapter or FragmentStatePagerAdapter, you need to use the v4 support library versions of the adapter, i.e. android.support.v4.app.FragmentStatePagerAdapter.

dependencies{
    compile 'com.android.support:cardview-v7:25.2.0'
}

A number of the latest version may be found here

Official Documentation:

https://developer.android.com/reference/android/support/v7/widget/CardView.html https://developer.android.com/training/material/lists-cards.html

HttpURLConnection is the standard HTTP client for Android, used to send and receive data over the web. It is a concrete implementation of URLConnection for HTTP (RFC 2616).

The SQLiteOpenHelper class defines static onCreate() and onUpgrade() methods. These methods are called in the corresponding methods of a SQLiteOpenHelper subclass that you customize with your own tables.

List of examples moved to adb shell:

• Granting & revoking API 23+ permissions
• Send text, key pressed and touch events to Android Device via ADB
• List packages
• Recording the display
• Open Developer Options
• Set Date/Time via adb
• Changing file permissions using chmod command
• Generating a "Boot Complete" broadcast
• Print application data
• View external/secondary storage content
• http://stackoverflow.com/documentation/android/9408/adb-shell/29140/adb-shell
• kill a process inside an Android device

More info: http://jakewharton.github.io/butterknife/

License

Copyright 2013 Jake Wharton

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

• https://developer.android.com/guide/practices/screens_support.html
• http://developer.android.com/guide/topics/resources/more-resources.html

Glide supports fetching, decoding, and displaying video stills, images, and animated GIFs. Glide includes a flexible API that allows developers to plug in to almost any network stack.
By default Glide uses a custom HttpUrlConnection based stack, but also includes utility libraries plug in to Google's Volley project or Square's OkHttp library instead.

Glide's primary focus is on making scrolling any kind of a list of images as smooth and fast as possible, but Glide is also effective for almost any case where you need to fetch, resize, and display a remote image.

Source code and further documentation is available on GitHub: https://github.com/bumptech/glide

From the official documentation:

Gradle:

dependencies {
    ...
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'    
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    ...
}

Maven:

<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>retrofit</artifactId>
  <version>2.3.0</version>
</dependency>

• The dialog in the first example(Dialog) does not need to call show() when it is created as it is handled in the constructor

• Alert Dialogs must be constructed through a new instance of the AlertDialog.Builder() class. Following the Builder Pattern, all members of the AlertDialog.Builder can be method chained to 'build up' the dialog instance.

• The Alert Dialog builder can directly show() the dialog -- you do not need to call create() then show() on the AlertDialog instance

• ACRA no longer supports Google forms, so you need a backend: https://github.com/ACRA/acra/wiki/Backends

Constructor

An Activity is an application component that provides a screen with which users can interact in order to do something, such as dial the phone, take a photo, send an email, or view a map. Each activity is given a window in which to draw its user interface. The window typically fills the screen, but may be smaller than the screen and float on top of other windows.

Snackbar provides lightweight feedback about an operation. It displays a brief message at the bottom of the screen on mobile and at the bottom left on larger devices. Snackbars appear above all other elements on the screen and only one can be displayed at a time.

They automatically disappear after a timeout or after user interaction elsewhere on the screen, particularly after interactions that summon a new surface or activity. Snackbar can be swiped off screen.

Before using SnackBar you must add the design support library dependency in the build.gradle file:

dependencies {
    compile 'com.android.support:design:25.3.1'
}

Official Documentation

https://developer.android.com/reference/android/support/design/widget/Snackbar.html

Definition

Logcat is a command-line tool that dumps a log of system messages, including stack traces when the device throws an error and messages that you have written from your app with the Log class.

When to use

If you are considering using Java's System.out methods for printing to the console instead of using one of Android's Log methods, then you should know that they basically work the same. However, it is better to avoid using Java's methods because the extra information and formatting provided by Android's Log methods are more beneficial. Also, the System.out print methods are redirected to the Log.i() method.

Useful links

• Android developer official documentation for Log and logcat.
• Stackoveflow Question : Android Log.v(), Log.d(), Log.i(), Log.w(), Log.e() - When to use each one?

A more recent alternative to Toast is SnackBar. SnackBar offers an updated visual style and allows the user to dismiss the message or take further action. See the SnackBar documentation for details.

Official Documentation:

https://developer.android.com/reference/android/widget/Toast.html

• Android's native open source LocationManager
• Google's FusedLocationProviderApi, which is part of Google Play Services

LocationManager

Pros

• More granular control
• Available in all devices
• Part of the Android framework

Cons

• Battery drain is an issue, if not managed properly
• Requires logic to switch location providers, if the device is unable to find a location (ex. poor GPS inside a building)

Features

• NMEA Listener
• GPS Status Listener
• Listen to provider status changes (ex. GPS is turned off by user)
• List of providers to choose location source from

Providers

GPS

• Permissions Required:
  • ACCESS_FINE_LOCATION
• Accuracy: 10m - 100m
• Power Requirements: HIGH
• Availability: Worldwide (with clear view of the sky)
• NOTES:
  • Location updates typically come in once every second, but in situations where GPS has not been used for some time and A-GPS is unavailable, it make take several minutes for a location to be received.
  • In cases where clear view of the sky is obstructed, GPS points will not cluster very well (location points "jump") and accuracy may be misleading in certain areas due to the "Urban Canyon" effect.

Network

• Permissions Required:
  • ACCESS_COARSE_LOCATION or ACCESS_FINE_LOCATION
• Accuracy: 100m - 1000m+
• Power Requirements: LOW - MEDIUM
• Availability: Within range of cell tower or wifi signal
• NOTES:
  • Location updates occur less frequently than GPS
  • Location updates typically do not cluster well (location points "jump") and accuracy can range depending number of different factors (number of wifi signals, signal strength, type of cell tower, etc.)

Passive

• Permissions Required:
  • ACCESS_FINE_LOCATION
• Accuracy: 10m - 1000m+
• Power Requirements: NONE
• Availability: Only when another app receives a location from either GPS or Network
• NOTES:
  • Don't rely on this to give you continuous updates. This listens passively to other apps that make location requests, and passes those locations back.
  • Does not return FusedLocationProviderApi generated points, only the underlying location points used to generate them.

FusedLocationProviderApi

Pros

• Offers less battery drain "out of the box"
• Handles poor GPS well
• Gets updates more regularly

Cons

• Less granular control over GPS
• May not be available on all devices or in certain countries
• Requires third party library dependency

Features

• Well managed use of location providers for optimal batter savings
• Typically generates more accurate points then Network Location Provider
• More frequent updates of library, allowing for more improvement
• No need to specify what type of provider to use

LocationRequest Priority Levels

PRIORITY_HIGH_ACCURACY

• Permissions Required:
  • ACCESS_FINE_LOCATION for more accurate location or ACCESS_COARSE_LOCATION for less accurate location
• Accuracy: 10m - 100m
• Power Requirements: HIGH
• Availability: Wherever Google Play Services is available.
• NOTES:
  • If ACCESS_FINE_LOCATION is not used, this will not use GPS for generating location updates, but will still find a fairly accurate point in the right conditions.
  • If ACCESS_FINE_LOCATION is used, it may or may not use GPS to generate location points, depending on how accurate it can currently track the device given the environmental conditions.
  • Although this may report more accurate location updates than the other settings, it is still prone to the "Urban Canyon" effect.

PRIORITY_BALANCED_POWER_ACCURACY

• Permissions Required:
  • ACCESS_FINE_LOCATION for more accurate location or ACCESS_COARSE_LOCATION for less accurate location
• Accuracy: 100m - 1000m+
• Power Requirements: MEDIUM
• Availability: Wherever Google Play Services is available.
• NOTES:
  • Same notes as PRIORITY_HIGH_ACCURACY
  • Although it is unlikely, this setting may still use GPS to generate a location.

PRIORITY_LOW_POWER

• Permissions Required:
  • ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION
• Accuracy: 100m - 1000m+
• Power Requirements: LOW
• Availability: Wherever Google Play Services is available.
• NOTES:
  • Probably does not use GPS, but untested thus far.
  • Updates are typically not very accurate
  • Used generally to detect significant changes in location

PRIORITY_NO_POWER

• Permissions Required:
  • ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION
• Accuracy: 10m - 1000m+
• Power Requirements: NONE
• Availability: Wherever Google Play Services is available.
• NOTES:
  • Functions almost identically to LocationManager PASSIVE_PROVIDER
  • Reports back Google Play Services updates when received, where PASSIVE_PROVIDER reports back underlying location updates used

TroubleShooting

OnLocationChanged() Never Called

Since this seems to be a common issue with getting Android Locations, I'll put down a quick checklist of common fixes:

1. Check your manifest!

   One of the most common issues is that the right permissions were never given. If you are using GPS (with or without Network), use <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>, else use <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>. Google's FusedLocationApi requires ACCESS_FINE_LOCATION.

2. (For Android 6+) Check runtime permissions!

   Check for and request permissions! If you are never given permissions, you'll end up with crashes, or worse (if you are catching all exceptions), you'll end up with no indication of anything! It doesn't matter if the user grants you permission at the start of the app, always check to see if you have permissions for all calls. The user can easily go to their settings and revoke them.

3. Double check your code!

   Are you sure you are passing in the right listener? Did you add that BroadcastReceiver or IntentService to your manifest? Are you using PendingIntent.getService() on a BroadcastReceiver class, or getBroadcast() on an IntentService class? Are you sure you are not unregistering your listener somewhere else in your code immediately after requesting?

4. Check device settings!

   Obviously, make sure you have location services turned on.

   

   If you are using Network services, did you turn on "Scanning Always Available"? Do you have your location mode set to "Best" ("High Accuracy") or "Battery Saving" ("Network Only")?

   

   If you are using GPS, did you turn on "Best" ("High Accuracy") or "Device only" in location mode?

   

5. Double check your code!

   Yes, this is on here twice. Did you try using a LocationListener instead of a PendingIntent, or vice-versa, to ensure you actually implemented LocationManager properly? Are you sure that the location request isn't being removed in some part of the Activity or Service lifecycle that you didn't expect to happen?

6. Check your surroundings!

   Are you testing GPS on the first floor of a building in the middle of San Francisco? Are you testing Network locations in the middle of nowhere? Do you work in a secret underground bunker void of all radio signals, wondering why your device isn't getting location? Always double check your surroundings when trying to troubleshoot location problems!

There could be many other less obvious reasons why location isn't working, but before searching out those esoteric fixes, just run through this quick checklist.

That means that in order to play audio/video a defined sequence of action must occur is specific order. It also states what actions can be made in which state.

The MediaPlayer API lacks flexibility (adding custom decoder and rendering logic) and lacks sSupport for Dynamic Adaptive Streaming over HTTP (DASH) and SmoothStreaming. For these, look into ExoPlayer.

What is dex?

Dex is the name of the file format and encoding to which Android Java code is compiled. Early versions of Android would load and execute dex binaries directly in a virtual machine named Dalvik. More recent versions of Android use the Android Runtime (ART), which treats dex files as an intermediate representation and performs further compilations on it prior to running the application.

Dex is a very old file format, in terms of the lifespan of smartphones, and was designed for devices whose main memory was measured in tens of megabytes. The design limitations of those days have remained with us to this day.

The problem:

The dex file format encodes a limit to the number of methods that can be referenced in a single binary. Because the portion of the file format that stores the number of references is two bytes long, the maximum number of method references is 0xFFFF, or 65535. If an application contains more than that number of method references, it will fail to compile.

What to do about it:

Google has provided a way around this problem, called Multidex. It has compile-time and run-time components. As its name implies, at compile-time it will divide code between one or more dex files. At runtime, it will teach the default ClassLoader how to look up classes from these files.

This approach works well on newer devices, but has some substantial drawbacks. It can increase application startup time dramatically, and on older devices can cause Application Not Responding failures.

Multidex, while effective, should be avoided if possible.

How to avoid the limit:

Before configuring your app to enable use of 64K or more method references, you should take steps to reduce the total number of references called by your app code, including methods defined by your app code or included libraries. The following strategies can help you avoid hitting the dex reference limit:

• Review your app's direct and transitive dependencies - Ensure any large library dependency you include in your app is used in a manner that outweighs the amount of code being added to the application. A common anti-pattern is to include a very large library because a few utility methods were useful. Reducing your app code dependencies can often help you avoid the dex reference limit.
• Remove unused code with ProGuard - Configure the ProGuard settings for your app to run ProGuard and ensure you have shrinking enabled for release builds. Enabling shrinking ensures you are not shipping unused code with your APKs.

The first point requires diligence and discipline on the part of the developer. When incorporating third-party libraries, one must consider the size of the library. For example, two popular JSON libraries are Jackson and Gson. Functionally they are quite similar, but Gson tends to see greater use in Android. One reason is that Jackson weighs in around 9,000 methods, whereas Gson contributes 1,900.

There are several tools available to help developers keep track of the size of their application:

• dexcount-gradle-plugin reports the number of method references in your APK or AAR on each build
• dex-method-counts is a commandline tool that counts the number of method references in an APK
• www.methodscount.com is a web service which will count the method references in any APK that you upload.

To know more about Menus, read this. Hope it helps!

Documentation

Picasso is a powerful image downloading and caching library for Android.
Follow this example to add the library to your project.

Websites:

• Source
• Doc
• Change Log

Installation

You can build Volley from the official Google source code. For a while, that was the only option. Or using one of the third-party pre-built versions. However, Google finally released an official maven package on jcenter.

In your application-level build.gradle file, add this to your dependencies list:

dependencies {
    ...
    compile 'com.android.volley:volley:1.0.0'
}

Ensure the INTERNET permission is set in your app's manifest:

<uses-permission android:name="android.permission.INTERNET"/>

Official Documentation

Google has not provided very extensive documentation on this library, and they haven't touched it in years. But what is available can be found at:

https://developer.android.com/training/volley/index.html

There is unofficial documentation hosted on GitHub, although there should be a better location to host this in the future:

https://pablobaxter.github.io/volley-docs/

dependencies {
    compile 'com.android.support:design:25.1.0'
}

Official Documentation:

https://developer.android.com/reference/android/support/design/widget/FloatingActionButton.html

Material Design Specifications:

https://material.google.com/components/buttons-floating-action-button.html

• Vogella: Unit Testing with JUnit
• Junit Annotations: java2novice.com
• Assert Class: junit.org
• JUnit Api: tutorialspoint.com
• Anroid testing Medium.com posts

Official Documentation: ProgressBar

Remember, the Snapshot API is used to request current state while the Fence API continuously checks for a specified state and sends callbacks when an app isn't running.

Overall, there are a few basic steps in order to use the Snapshot API or Fence API:

• Get an API key from the Google Developers Console

• Add necessary permissions and API key to the manifest:

   <!-- Not required for getting current headphone state -->
   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
   <!-- Only required for actvity recognition -->
   <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION"/>
  
   <!-- Replace with your actual API key from console -->
   <meta-data android:name="com.google.android.awareness.API_KEY"
              android:value="YOUR_API_KEY"/>
  
   <!-- Required for Snapshot API only -->
   <meta-data android:name="com.google.android.geo.API_KEY"
              android:value="YOUR_API_KEY"/> 
  

• Initalize the GoogleApiClient somewhere, preferably in your activity's onCreate() method.

   GoogleApiClient client = new GoogleApiClient.Builder(context)
       .addApi(Awareness.API)
       .build();
   client.connect();
  

• Call the API of your choice

• Parse result

An easy way to check for the needed user permission is a method such as this:

private boolean isFineLocationGranted() {
    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {
        Log.e(getClass().getSimpleName(), "Fine location permission not granted!");
    }
}

Espresso

Espresso cheat sheet will help you write your tests and what you want to test:

https://google.github.io/android-testing-support-library/docs/espresso/cheatsheet/

Also always a good place for reference is the official documentation:

https://google.github.io/android-testing-support-library/docs/espresso/index.html

Advanced espresso video suggestions by Google: https://www.youtube.com/watch?v=isihPOY2vS4

Troubleshooting

• When trying to scroll, be sure to close the keyboard first:

Watchout: not using the "Espresso" version won't do anything when used outside a ViewAction. This may not be obvious if you have an import on the ViewAction version since they have exactly the same method name.

ViewActions.closeSoftKeyboard;
Espresso.closeSoftKeyboard();

• When running tests together in a suite rather than individually, be aware that the Activity from the previous test may still be running. Do not rely on the previous test's onDestroy() being called before the current tests onResume(). It turns out this is actually a bug: http://b.android.com/201513

JUnit rules:

As you can see in MockWebServer example and ActivityTestRule they all fall under category of JUnit rules which you can create yourself which then should be executed for each test defining its behaviour @see: https://github.com/junit-team/junit4/wiki/rules

Appium

Parameters

Since parameters have some issues placing them here until documentation bug is resolved:

• Icon fonts can be used in navigation drawer. Using them in navigation views as icon of menu items is not possible as the menu file cannot be created without specifying the title. So it is advisable to use svg files as resources for these icons.

• Icon fonts cannot be used in floating action button. as they does not have a setText() attribute.

• External fonts cannot be applied from xml. They must be specified using the java file. Or else you need to extend the basic view and create a view as specified in this post

<intent-filter>
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data ... />

</intent-filter>

Resources

• Enabling Deep Links for App Content (developer.android.com)
• <intent-filter> (developer.android.com

Firebase - Extended documentation:

There is another tag where you can find more topics and examples about the use of Firebase.

Other related topics:

• Firebase Realtime DataBase
• Firebase App Indexing
• Firebase Crash Reporting
• Firebase Cloud Messaging

The best complete wiki is available here in github.

ListView is a view group that displays a list of scrollable items.
The list items are automatically inserted to the list using an Adapter that pulls content from a source such as an array or database query and converts each item result into a view that's placed into the list.

When the content for your layout is dynamic or not pre-determined, you can use a layout that subclasses AdapterView to populate the layout with views at runtime. A subclass of the AdapterView class uses an Adapter to bind data to its layout.

Before using the ListView you should also checking the RecyclerView examples.

• They are available to every Activity and Fragment.
• They provide asynchronous loading of data.
• They monitor the source of their data and deliver new results when the content changes.
• They automatically reconnect to the last loader's cursor when being recreated after a configuration change. Thus, they don't need to re-query their data.

When not to use Loaders

MVP Definition

Model

In an application with a good layered architecture, this model would only be the gateway to the domain layer or business logic. See it as the provider of the data we want to display in the view.

View

The View, usually implemented by an Activity or Fragment, will contain a reference to the presenter. The only thing that the view will do is to call a method from the Presenter every time there is an interface action.

Presenter

The Presenter is responsible to act as the middle man between View and Model. It retrieves data from the Model and returns it formatted to the View. But unlike the typical MVC, it also decides what happens when you interact with the View.

* Definitions from Antonio Leiva’s article.

Recommended App Structure (not required)

The app should be structured by package per feature. This improves readability and modularizes the app in a way that parts of it can be changed independently from each other. Each key feature of the app is in its own Java package.

Reference : https://guides.codepath.com/android/Handling-Configuration-Changes#references

Official Documentation: Detecting Common Gestures

On Android 6.0 Marshmallow: Doze mode gets activated after a while the screen is off, the device is stationary and it's running on battery. As you can see in the diagram above, when Doze Mode gets activated, the device doesn't get any wakelocks, network access, jobs/syncs, Alarms, GPS/Wi-fi scans.

On Android 7.0 Nougat: Imagine if your phone is on your pocket (the screen is off, it's running on battery, but it's not stationary) you might want to get the Doze Mode features as well, right? So that's why Google announced the Extended Doze Mode: It runs when the screen is off, but not stationary. As you can see in this diagram, only Network Access and jobs/syncs are disabled. Note that the Extended Doze doesn't replace the first Doze Mode. They work together, depending on the phone state (stationary or not). Here are the distinctions: Developers should be aware that:

• Doze might keep temporary wakelock and network access for High-priority GCM (Google Cloud Messaging) messages (for cases wwhere the user needs an immediate notification);
• Foreground services (such as a music playback) will continue to work.

You can find more information here: https://developer.android.com/training/monitoring-device-state/doze-standby.html

Fore More About Constraint Layout:

https://codelabs.developers.google.com/codelabs/constraint-layout/index.html

dependencies {
    // Your app's other dependencies.
    compile 'com.facebook.fresco:fresco:0.14.1' // Or a newer version if available.
}

More information can be found here.

• Requires a valid Admob account
• Read the admob policy. Make sure you do not do anything that can get your admob account suspended

• More about Intent

• More about Intent Types

Other related topics:

• Firebase

TextInputLayout is a layout which wraps an EditText (or descendant) to show a floating label when the hint is hidden due to the user inputting text. Additonally the TextInputLayout enables you to display an error message below the EditText.

Make sure the following dependency is added to your app's build.gradle file under dependencies:

compile 'com.android.support:design:25.3.1'

Bottom sheets slide up from the bottom of the screen to reveal more content.
They were added to the Android Support Library in v23.2.0 version.

The CoordinatorLayout is a container that extends the FrameLayout.
By attaching a CoordinatorLayout.Behavior to a direct child of CoordinatorLayout, you’ll be able to intercept touch events, window insets, measurement, layout, and nested scrolling.

By specifying Behaviors for child views of a CoordinatorLayout you can provide many different interactions within a single parent and those views can also interact with one another. View classes can specify a default behavior when used as a child of a CoordinatorLayout using the DefaultBehavior annotation.

Try entering headline you just went through, you will get App page suggestion with that Headline as Title. This is different from App suggestions you get while searching for Apps. This happens because you have written AppIndexing API code for this particular page and title is same as you have initialized in onCreate().

It is recommended to use methods of the DateUtils class in order to format dates which are locale aware, i.e. which consider user preferences (e.g. 12h/24h clock time formats). These methods are most appropriate for dates that are displayed to the user.

For fully customized date representations, it is recommended to use the SimpleDateFormat class, as it allows to fully control all date elements.

CountDownTimer is a pretty lean class - it does one thing very well. Since you can only start/cancel a CountDownTimer, you have to implement pause/resume functionality as shown in the second example. For more complex functionality, or to specify a timer that should run indefinitely, use the Timer object.

QRCodeReaderView

Zxing

Otto is deprecated in favor of RxJava and RxAndroid. These projects permit the same event-driven programming model as Otto, but they’re more capable and offer better control of threading.

Github sample project

Android developer blogspot

Android Developer site

public class CustomBindings {

    @TargetApi(23)
    @BindingAdapter({"bind:textColor"})
    public static void setTextColor(TextView textView, int colorResId) {
        final Context context = textView.getContext();
        final Resources resources = context.getResources();
        final int apiVersion = Build.VERSION.SDK_INT;
        int color;

        if (apiVersion >= Build.VERSION_CODES.M) {
           color = resources.getColor(colorResId, context.getTheme());
        } else {
            color = resources.getColor(colorResId);
        }

        textView.setTextColor(color);
    }

}

For details on how this works check DataBinding Library: Custom Setters

Wait...there is logic in your xml!!!?

You could argue that the things I do in xml for android:visibility and app:textColor are wrong/anti-patterns in the MVVM context because there is view logic in my view. However I would argue it is more important for me to keep android dependencies out of my ViewModel for testing reasons.

Besides, what really does app:textColor do? It only resolves a ressource pointer to the actual color associated with it. So the ViewModel still decides which color is shown based on some condition.

As for the android:visibility I feel because of how the method is named it is actually okay to use the ternary operator here. Because of the name isLoadingVisible and isContentVisible there is really no doubt about what each outcome should resolve to in the view. So I feel it is rather executing a command given by the ViewModel than really doing view logic.

On the other hand I would agree that using viewModel.isLoading ? View.VISIBLE : View.GONE would be a bad thing to do because you are making assumptions in the view what that state means for the view.

Useful Material

The following resources have helped me a lot in trying to understand this concept:

• Jeremy Likness - Model-View-ViewModel (MVVM) Explained (C#) (08.2010)
• Shamlia Shukkur - Understanding the basics of MVVM design pattern (C#) (03.2013)
• Frode Nilsen - Android Databinding: Goodbye Presenter, Hello ViewModel! (07.2015)
• Joe Birch - Approaching Android with MVVM (09.2015)
• Florina Muntenescu - Android Architecture Patterns Part 3: Model-View-ViewModel (10.2016)

Links:

• Official Javadoc

1. First of all, you need to download the latest jar from below link https://developers.google.com/youtube/android/player/downloads/
2. You need to include this jar in your project. Copy and paste this jar in libs folder and don't forget to add it in gradle file dependencies { compile files('libs/YouTubeAndroidPlayerApi.jar') }
3. You need an api key to access youtube api's. Follow this link : https://developers.google.com/youtube/android/player/register to generate your api key.
4. Clean and Build your project. Now you're ready to use the YoutubeAndroidPlayerApi For playing an youtube video, you need to have video id corresponding to it so that you can play it on youtube. For e.g : https://www.youtube.com/watch?v=B08iLAtS3AQ, B08iLAtS3AQ is video id which you need to play it on youtube.

dependencies {
    ...
   compile 'com.android.support:appcompat-v7:23.2.1'
}

// Gradle Plugin 2.0+  
 android {  
   defaultConfig {  
     vectorDrawables.useSupportLibrary = true  
    }  
 }

// Gradle Plugin 1.5  
 android {  
   defaultConfig {  
     generatedDensities = []  
  }  

  // This is handled for you by the 2.0+ Gradle Plugin  
  aaptOptions {  
    additionalParameters "--no-version-vectors"  
  }  
 }

Read Android Support Library 23.2 Release Notes for more info.

NOTE : Even with AppCompat, Vector Drawables wont work outside of your app in older android versions. For instance, you cannot pass vector drawables as Notification icons as they are handled by the system and not the app. See this answer for a workaround.

Docs: https://docs.fastlane.tools/

Source Code: https://github.com/fastlane/fastlane

Android provides means for sharing the file between multiple applications as documented here. This is not required if there is only one app that creates and uses the file.

Android provides alternative storage options like shared and private preferences, saved bundles and built-in database. In some cases, they are better choice than just using plain files.

Android activity does have few specific methods that look like replacements of the Java standard File IO methods. For instance, instead for File.delete() you can call Context.deleteFile(), and instead of applying File.listFiles() recursively you can call Context.fileList() to get the list of all your app specific files with somewhat less code. However, they do not provide extra functionality beyond standard java.io package.

Don't forget, always read the README!

1. Run adb using the command : adb shell
2. Run the following command at the adb command prompt : setprop persist.sys.locale [BCP-47 language tag];stop;sleep 5;start where [BCP-47 language tag] is the language specific code as described here : BCP47 codes

e.g. to check Japanese localization in the app, use the command : setprop persist.sys.locale ja-JP;stop;sleep 5;start

Dagger 2 API:

Dagger 2 exposes a number of special annotations:

@Module for the classes whose methods provide dependencies

@Provides for the methods within @Module classes

@Inject to request a dependency (a constructor, a field, or a method)

@Component is a bridge interface between modules and injection

Important Links:

GitHub: https://github.com/google/dagger

UserGuide(Google): https://google.github.io/dagger/users-guide.html

Videos: https://google.github.io/dagger/resources.html

Vogella Tutorial: http://www.vogella.com/tutorials/Dagger/article.html

Codepath Tutorial: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2

Get your CleverTap credentials from https://clevertap.com.

If you want to learn more about Kotlin Programming Language check out Documentation.

What is Context?

Appreciated work by MindRocks

https://github.com/square/leakcanary

To get more details about the toast message please check this documentation. https://developer.android.com/reference/android/widget/Toast.html