How to Store Application Data Locally

https://code.tutsplus.com/tutorials/android-from-scratch-how-to-store-application-data-locally--cms-26853

Background process

Aside from the most basic of Android applications, everything you build will require at least some use of background threading to perform an operation. This is because Android has something known as an ANR(Application Not Responsive) timeout, which is caused when an operation takes five seconds or longer on the UI thread, preventing user input and causing what appears to the user to be a hanging app. 

In order to avoid this, you must move longer running operations, such as network requests or slow database queries, to a different thread so as to not prevent the user from continuing to use your app. Although comprehensive coverage of threading is a large and complex subject in computer science, this tutorial will introduce you to the core concepts of threading in Android, and to some of the tools available to help you build apps that perform better by using background processes.

Generally, the system displays an ANR if an application cannot respond to user input. For example, if an application blocks on some I/O operation (frequently a network access) on the UI thread so the system can't process incoming user input events. Or perhaps the app spends too much time building an elaborate in-memory structure or computing the next move in a game on the UI thread. It's always important to make sure these computations are efficient, but even the most efficient code still takes time to run.

Understanding Threading

When an application is launched, a new Linux process with a single main execution thread is started. This is the thread that has access to the Android UI toolkit, listens for user inputs, and handles drawing to the Android device screen. Because of this, it is also commonly referred to as the UI thread. 

All components of an application run within the same thread and process by default, though additional threads can be created to move tasks off the UI thread and prevent an ANR. When it comes to threading in Android, there are two simple rules to remember to keep your app functioning as expected:

1. Do not block the UI thread.
2. Do not attempt to access Android UI components from outside the UI thread.

Reference

https://code.tutsplus.com/tutorials/android-from-scratch-background-operations--cms-26810 

Broadcast Reciever

Most of us are all too familiar with announcements in public places. They are loud messages that are meant to inform large groups of people about something important. Android applications also have to deal with announcements sometimes—announcements generated either by other applications or by the Android operating system itself. Such announcements are called broadcasts, and they are seen as an important form of asynchronous inter-process communication on the Android platform.

<receiver android:name="MyReceiver">
   
      <intent-filter>
         <action android:name="android.intent.action.BOOT_COMPLETED">
         </action>
      </intent-filter>
   
   </receiver>

https://code.tutsplus.com/tutorials/android-from-scratch-understanding-android-broadcasts--cms-27026

Singleton

The Singleton's purpose is to control object creation, limiting the number of objects to only one. Since there is only one Singleton instance, any instance fields of a Singleton will occur only once per class, just like static fields. Singletons often control access to resources, such as database connections or sockets.

For example, if you have a license for only one connection for your database or your JDBC driver has trouble with multithreading, the Singleton makes sure that only one connection is made or that only one thread can access the connection at a time.

Implementing Singletons

Example 1

The easiest implementation consists of a private constructor and a field to hold its result, and a static accessor method with a name like getInstance().

The private field can be assigned from within a static initializer block or, more simply, using an initializer. The getInstance( ) method (which must be public) then simply returns this instance −

// File Name: Singleton.java
public class Singleton {

   private static Singleton singleton = new Singleton();

   /* A private Constructor prevents any other
    * class from instantiating.
    */
   private Singleton() { }

   /* Static 'instance' method */
   public static Singleton getInstance( ) {
      return singleton;
   }

   /* Other methods protected by singleton-ness */
   protected static void demoMethod( ) {
      System.out.println("demoMethod for singleton");
   }
}

// File Name: SingletonDemo.java

public class SingletonDemo {

   public static void main(String[] args) {
      Singleton tmp = Singleton.getInstance( );
      tmp.demoMethod( );
   }
}

Inter process communication

down voteaccepted

There are three types of IPC mechanism in Android: Intents (along with Bundles) Binders ASHMEM (Anonymous Shared Memory) - The main difference between Linux shared memory and this shared memory is, in Linux other processes can't free the shared memory but here if other processes require memory this memory can be freed by Android OS.

Android screen orientation Lifecycle

Android screen orientation Lifecycle

We might have some confusion on the android screen orientation change lifecycle of an Android activity.  Sometimes you might observe  that your activity getting restarted, while the you rotate the device. Sometimes nothing happens. Below is the simple rule for android screen orientation change lifecycle.

1. If you already @Override the onConfigurationChanged() function in your java code( in your Android activity class) for handle Android Screen Orientation Change. Then your activity will never restart for any screen orientation changes. As i explained it in point-4 above.

2. If you do not @Override onConfigurationChanged() function as above, then your running activity will get restart every time for any screen orientation change happens in your device. That means your activity will destroy first by calling onDestroy() API and then onCreate()method will call again for your running activity to restart it.

3. To properly handle your activity’s restart state, you need to restores its previous state through the normal Activity lifecycle, in which Android OS calls onSaveInstanceState() method before it destroys your activity. So that you can save your data(variable values)and your application state. You can then restore the previous state during onCreate() or onRestoreInstanceState() method call of your activity.

Service

Android user interface is restricted to perform long running jobs to make user experience smoother.
 A typical long running tasks can be periodic downloading of data from internet, saving multiple records into database, perform file I/O, fetching your phone contacts list, etc. For such long running tasks, Service is the alternative.

1. A service is a application component used to perform long running tasks in background.
2. A service doesn’t have any user interface and neither can directly communicate to an activity.
3. A service can run in the background indefinitely, even if component that started the service is destroyed.
4. Usually a service always performs a single operation and stops itself once intended task is complete.
5. A service runs in the main thread of the application instance. It doesn’t create its own thread. If your service is going to do any long running blocking operation, it might cause Application Not Responding (ANR).  And hence, you should create a new thread within the service.

service is a component that is used to perform operations on the background such as playing music, handle network transactions, interacting content providers etc. It doesn't has any UI (user interface).

The service runs in the background indefinitely even if application is destroyed.

Moreover, service can be bounded by a component to perform interactivity and inter process communication (IPC).

The android.app.Service is subclass of ContextWrapper class.

Different Type of Service:-

• Unbound Service
It is a kind of service which runs in the background indefinitely, even if the activity which started this service ends.
• Bound Service
It is a kind of service which runs till the lifespan of the activity which started this service

Life Cycle of Android Service

There can be two forms of a service.The lifecycle of service can follow two different paths: started or bound.

1. Started
2. Bound

1) Started Service

A service is started when component (like activity) calls startService() method, now it runs in the background indefinitely. It is stopped by stopService() method. The service can stop itself by calling the stopSelf() method.

2) Bound Service

A service is bound when another component (e.g. client) calls bindService() method. The client can unbind the service by calling the unbindService() method.

The service cannot be stopped until all clients unbind the service.

                                          Difference between Service and Intentservice

Service is a base class of service implementation. Service is run in the application's main thread which may reduce the application performance. Thus, IntentService, which is a direct subclass of Service is available to make things easier.
The IntentService is used to perform a certain task in the background. Once done, the instance of IntentService terminates itself automatically. Examples for its usage would be to download a certain resource from the Internet.
Differences

1. Service class uses the application's main thread, while IntentService creates a worker thread and uses that thread to run the service.
2. IntentService creates a queue that passes one intent at a time to onHandleIntent(). Thus, implementing a multi-thread should be made by extending Service class directly. Service class needs a manual stop using stopSelf(). Meanwhile, IntentService automatically stops itself when it finishes execution.
3. IntentService implements onBind() that returns null. This means that the IntentService can not be bound by default.
4. IntentService implements onStartCommand() that sends Intent to queue and to onHandleIntent().

In brief, there are only two things to do to use IntentService. Firstly, to implement the constructor. And secondly, to implement onHandleIntent(). For other callback methods, the super is needed to be called so that it can be tracked properly.

ANDROID IMPORTANT LIBRARY

 Systrace 


The Systrace tool helps analyze the performance of your application by capturing and displaying execution times of your applications processes and other Android system processes. The tool combines data from the Android kernel such as the CPU scheduler, disk activity, and application threads to generate an HTML report that shows an overall picture of an Android device’s system processes for a given period of time.


stetho is a debug bridge for Android applications, enabling the powerful Chrome Developer Tools and much more.

https://github.com/facebook/stetho

MaterialLibrary is an Open Source Android library that back-port Material Design components to pre-Lolipop Android. MaterialLibrary's original author is Rey Pham

http://rey5137.com/material/

This application provides a collection of third party libraries, as a developer this application is essential for you.
You will have information about the author, captures, license, description, links of the library and you can try a working example within the application.
Recently it has added a tab with SNIPPETS that will be updated constantly.

https://play.google.com/store/apps/details?id=com.desarrollodroide.repos

Mobile User Interface design helps users to use and work with application easily. Tabs also come in user interface part and makes easy to explore and switch between different views. UI design apps are user friendly and also it helps to increase rating of your application and game. In this post, I have collected some beautiful and amazing tabs ui design for you mobile apps.

http://www.viralandroid.com/2015/09/beautiful-mobile-tabs-ui-design-with-amazing-user-experience.html

Android Library to make a cool intro for your app.

github----https://github.com/PaoloRotolo/AppIntro

https://play.google.com/store/apps/details?id=paolorotolo.github.com.appintroexample

android smart animation

https://github.com/ratty3697/android-smart-animation-library

Difference type of theme for android app

https://play.google.com/store/apps/details?id=com.hexagon.design.ws.hexagon

https://play.google.com/store/apps/details?id=com.wolfsoft.fivedemo

https://play.google.com/store/apps/details?id=com.csform.android.uiapptemplate

https://play.google.com/store/apps/details?id=com.ionicframework.ionictemplates735700

Card Example

Cards Library provides an easy way to display a UI Card in your Android app.
You can display single cards, list of cards and a grid of Cards.
You can find the project on Github (https://github.com/gabrielemariotti/cardslib)

For All of camera 

https://play.google.com/store/apps/details?id=com.jnardari.opencv_androidsamples

Tab with slide animation
https://github.com/Gilgoldzweig/EasyTabs

Using Fan Layout Manager you can implement the horizontal list, the items of which move like fan blades (in a circular way of a radius to your choice). To give a slightly chaotical effect to the motion, it’s possible to set an angle for the list items. So, every implementation of the library can be unique.

https://github.com/Cleveroad/FanLayoutManager

Mobile User Interface design helps users to use and work with application easily. Tabs also come in user interface part and makes easy to explore and switch between different views. UI design apps are user friendly and also it helps to increase rating of your application and game. In this post, I have collected some beautiful and amazing tabs ui design for you mobile apps.

http://www.viralandroid.com/2015/09/beautiful-mobile-tabs-ui-design-with-amazing-user-experience.html


This library provides a simple way to add a draggable sliding up panel (popularized by Google Music and Google Maps) to your Android application.

A beautiful, fluid, and customizable dialogs API. https://aidanfollestad.com
https://github.com/umano/AndroidSlidingUpPanel

Simple, pretty and powerful logger for android

Logger provides :

• Thread information
• Class information
• Method information
• Pretty-print for json content
• Pretty-print for new line "\n"
• Clean output
• Jump to source

https://github.com/orhanobut/logger

SnappyDB is a key-value database for Android it's an alternative for SQLite if you want to use a NoSQL approach.

It allows you to store and get primitive types, but also a Serializable object or array in a type-safe way.

SnappyDB can outperform SQLite in read/write operations. 

https://github.com/nhachicha/SnappyDB