Fragment and It uses In Android

Hello Guys, Hopes You are Doing Well.
Today  I am going to discuss Fragment and it use in Android. Fragment introduced in Android Version 3.0 (HoneyComb). To use the larger screen size device(Tablet). But now it is  used actively in  responsive design and reuse-ability of code. Before proceeding in depth the first basic question?
What is Fragment? and what is  the benefit to use it?
 A fragment is simply a block of UI, with its own life cycle, that can be reused within different activities. Fragments allow developers to create highly modular user interface components that can change dramatically based on screen sizes, orientation, and other aspects of the display that might be relevant to the design.
What is the inter-dependency between Activity and Fragment ?
A fragment must always be embedded in an activity and the fragment's life cycle is directly affected by the host activity's lifecycle. For example, when the activity is paused, so are all fragments in it, and when the activity is destroyed, so are all fragments. However, while an activity is running, you can manipulate each fragment independently, such as add or remove them.
When you perform such a fragment transaction, you can also add it to a back stack that's managed by the activity—each back stack entry in the activity is a record of the fragment transaction that occurred. The back stack allows the user to reverse a fragment transaction (navigate backwards), by pressing the Back button.
How  We can add fragment and what is the process?
When you add a fragment as a part of your activity layout, it lives in a ViewGroup inside the activity's view hierarchy and the fragment defines its own view layout. You can insert a fragment into your activity layout by declaring the fragment in the activity's layout file, as a <fragment> element, or from your application code by adding it to an existing ViewGroup.
However, a fragment is not required to be a part of the activity layout; you may also use a fragment without its own UI as an invisible worker for the activity.
     
To define a new fragment you extend either the android.app.Fragment class or one of its subclasses, for example ListFragment, DialogFragment, PreferenceFragment or WebViewFragment. The following code shows an example implementation.

In that code I am showing two pan layout for tablet and single pan layout for device(Just like above given Images).  There are 4 java class file and two xml file under layout folder and one xml file under layout-large.
Here is following java and xml file name:-
/src folder
1. HomeActivity .java
2. HeaderFragment.java
3. ArticleFragment.java
4. DataCenter.java
/layout folder
1. activity_home.xml
2. article_view.xml
/layout-large folder
1. news_articles.xml
I have putted the detailed description of individual function in comment. So please going through this code have a look on that comments. It help you to understand this code thoroughly.

package com.sks.fragment;

import android.os.Bundle;

import android.app.Activity;

import android.support.v4.app.FragmentActivity;

import android.support.v4.app.FragmentTransaction;

import android.view.Menu;

public class HomeActivity extends FragmentActivity

implements HeadlineFragment.OnHeadlineSelectedListener {

       @Override

       protected void onCreate(Bundle savedInstanceState) {

              super.onCreate(savedInstanceState);

              setContentView(R.layout.activity_home);

        // Check whether the activity is using the layout version with

        // the fragment_container FrameLayout. If so, we must add the first fragment

        if (findViewById(R.id.fragment_container) != null) {

            // However, if we're being restored from a previous state,

            // then we don't need to do anything and should return or else

            // we could end up with overlapping fragments.

            if (savedInstanceState != null) {

                return;

            }

            // Create an instance of ExampleFragment

            HeadlineFragment firstFragment = new HeadlineFragment();

            // In case this activity was started with special instructions from an Intent,

            // pass the Intent's extras to the fragment as arguments

            firstFragment.setArguments(getIntent().getExtras());

            // Add the fragment to the 'fragment_container' FrameLayout

            getSupportFragmentManager().beginTransaction()

                    .add(R.id.fragment_container, firstFragment).commit();

        }

             

       }

    public void onArticleSelected(int position) {

        // The user selected the headline of an article from the HeadlinesFragment

        // Capture the article fragment from the activity layout

        ArticleFragment articleFrag = (ArticleFragment)

                getSupportFragmentManager().findFragmentById(R.id.article_fragment);

        if (articleFrag != null) {

            // If article frag is available, we're in two-pane layout...

            // Call a method in the ArticleFragment to update its content

            articleFrag.updateArticleView(position);

        } else {

            // If the frag is not available, we're in the one-pane layout and must swap frags...

            // Create fragment and give it an argument for the selected article

            ArticleFragment newFragment = new ArticleFragment();

            Bundle args = new Bundle();

            args.putInt(ArticleFragment.ARG_POSITION, position);

            newFragment.setArguments(args);

            FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

            // Replace whatever is in the fragment_container view with this fragment,

            // and add the transaction to the back stack so the user can navigate back

            transaction.replace(R.id.fragment_container, newFragment);

            transaction.addToBackStack(null);

            // Commit the transaction

            transaction.commit();

        }

    }

       @Override

       public boolean onCreateOptionsMenu(Menu menu) {

              // Inflate the menu; this adds items to the action bar if it is present.

              getMenuInflater().inflate(R.menu.home, menu);

              return true;

       }

}

 2. HeadlineFragment

package com.sks.fragment;

import android.app.Activity;

import android.support.v4.app.ListFragment;

import android.os.Build;

import android.os.Bundle;

import android.view.View;

import android.widget.ArrayAdapter;

import android.widget.ListView;

public class HeadlineFragment extends ListFragment {

    OnHeadlineSelectedListener mCallback;

    // The container Activity must implement this interface so the frag can deliver messages

    public interface OnHeadlineSelectedListener {

        /** Called by HeadlinesFragment when a list item is selected */

        public void onArticleSelected(int position);

    }

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // We need to use a different list item layout for devices older than Honeycomb

        int layout = Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB ?

                android.R.layout.simple_list_item_activated_1 : android.R.layout.simple_list_item_1;

        // Create an array adapter for the list view, using the Ipsum headlines array

        setListAdapter(new ArrayAdapter<String>(getActivity(), layout, DataContainer.Headlines));

    }

    @Override

    public void onStart() {

        super.onStart();

        // When in two-pane layout, set the listview to highlight the selected list item

        // (We do this during onStart because at the point the listview is available.)

        if (getFragmentManager().findFragmentById(R.id.article_fragment) != null) {

            getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);

        }

    }

    @Override

    public void onAttach(Activity activity) {

        super.onAttach(activity);

        // This makes sure that the container activity has implemented

        // the callback interface. If not, it throws an exception.

        try {

            mCallback = (OnHeadlineSelectedListener) activity;

        } catch (ClassCastException e) {

            throw new ClassCastException(activity.toString()

                    + " must implement OnHeadlineSelectedListener");

        }

    }

    @Override

    public void onListItemClick(ListView l, View v, int position, long id) {

        // Notify the parent activity of selected item

        mCallback.onArticleSelected(position);

       

        // Set the item as checked to be highlighted when in two-pane layout

        getListView().setItemChecked(position, true);

    }

}

3. public class ArticleFragment extends Fragment {

    final static String ARG_POSITION = "position";

    int mCurrentPosition = -1;

    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container,

        Bundle savedInstanceState) {

        // If activity recreated (such as from screen rotate), restore

        // the previous article selection set by onSaveInstanceState().

        // This is primarily necessary when in the two-pane layout.

        if (savedInstanceState != null) {

            mCurrentPosition = savedInstanceState.getInt(ARG_POSITION);

        }

        // Inflate the layout for this fragment

        return inflater.inflate(R.layout.article_view, container, false);

    }

    @Override

    public void onStart() {

        super.onStart();

        // During startup, check if there are arguments passed to the fragment.

        // onStart is a good place to do this because the layout has already been

        // applied to the fragment at this point so we can safely call the method

        // below that sets the article text.

        Bundle args = getArguments();

        if (args != null) {

            // Set article based on argument passed in

            updateArticleView(args.getInt(ARG_POSITION));

        } else if (mCurrentPosition != -1) {

            // Set article based on saved instance state defined during onCreateView

            updateArticleView(mCurrentPosition);

        }

    }

    public void updateArticleView(int position) {

        TextView article = (TextView) getActivity().findViewById(R.id.article);

        article.setText(DataContainer.Articles[position]);

        mCurrentPosition = position;

    }

    @Override

    public void onSaveInstanceState(Bundle outState) {

        super.onSaveInstanceState(outState);

        // Save the current article selection in case we need to recreate the fragment

        outState.putInt(ARG_POSITION, mCurrentPosition);

    }

}

 4. package com.sks.fragment;

public class DataContainer {

    static String[] Headlines = {

        "Android",

        "java",

        "Database"

    };

    static String[] Articles = {

        "Android\n\nExcepteur pour-over occaecat squid biodiesel umami gastropub, nulla laborum salvia dreamcatcher fanny pack. Ullamco culpa retro ea, trust fund excepteur eiusmod direct trade banksy nisi lo-fi cray messenger bag. Nesciunt esse carles selvage put a bird on it gluten-free, wes anderson ut trust fund twee occupy viral. Laboris small batch scenester pork belly, leggings ut farm-to-table aliquip yr nostrud iphone viral next level. Craft beer dreamcatcher pinterest truffaut ethnic, authentic brunch. Esse single-origin coffee banksy do next level tempor. Velit synth dreamcatcher, magna shoreditch in american apparel messenger bag narwhal PBR ennui farm-to-table.",

        "javao\n\nVinyl williamsburg non velit, master cleanse four loko banh mi. Enim kogi keytar trust fund pop-up portland gentrify. Non ea typewriter dolore deserunt Austin. Ad magna ethical kogi mixtape next level. Aliqua pork belly thundercats, ut pop-up tattooed dreamcatcher kogi accusamus photo booth irony portland. Semiotics brunch ut locavore irure, enim etsy laborum stumptown carles gentrify post-ironic cray. Butcher 3 wolf moon blog synth, vegan carles odd future.",

        "DataBase\n\nsgshuishuihsuish89 ugishuhs huisuihs8uh , huihsuihj. gfuyghuygh HGUygh bhuih8ihun dHJAGDSYUGS7GBV . ftF6TYF76TGF78YGH78 YUG7GUKBHUIH H78UH78H87UH.YUG78Y87YU9KHNUIY,HIHU "

    };

}

 Now xml file, at first under layout folder

1. activity_home.xml

<?xml version="1.0" encoding="utf-8"?>

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

    android:id="@+id/fragment_container"

    android:layout_width="match_parent"

    android:layout_height="match_parent" />

 2. article_view.xml

<?xml version="1.0" encoding="utf-8"?>

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

    android:id="@+id/article"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:padding="16dp"

    android:textSize="18sp" />

lastly

3.  news_articles.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:baselineAligned="false"

    android:orientation="horizontal" >

    <fragment

        android:id="@+id/headlines_fragment"

        android:name="com.example.android.fragments.HeadlinesFragment"

        android:layout_width="0dp"

        android:layout_height="match_parent"

        android:layout_weight="1" />

    <fragment

        android:id="@+id/article_fragment"

        android:name="com.example.android.fragments.ArticleFragment"

        android:layout_width="0dp"

        android:layout_height="match_parent"

        android:layout_weight="2" />

</LinearLayout>

this is the starting code for Fragment. In next blog  I will put more light on Fragment LifeCycle and different type of fragment and Its uses. 

              Happy Coding !!!

Process lifecycle and it types in Android

Hello Guys!!! Hope you all are doing well . Today I am going to discuss Android process and  resource management.  At first we have to understand the Android application process and its type.

The Android system tries to maintain an application process for as long as possible, but eventually needs to remove old processes to reclaim memory for new or more important processes.

To determine which processes to keep and which to kill, the system places each process into an “importance hierarchy” based on the components running in the process and the state of those components.

Processes with the lowest importance are eliminated first, then those with the next lowest importance, and so on, as necessary to recover system resources.

There are five levels in the importance hierarchy.  I am putting here the list presents the different types of processes in order of importance (the first process is most important and is killed last)

1. Foreground process A process that is required for what the user is currently doing. A process is considered to be in the foreground if any of the following conditions are true:

• It hosts an Activity that the user is interacting with (the Activity‘s onResume() method has been called).
• It hosts a Service that’s bound to the activity that the user is interacting with.
• It hosts a Service that’s running “in the foreground”—the service has called startForeground() .
• It hosts a Service that’s executing one of its lifecycle callbacks ( onCreate() , onStart() , or onDestroy() ).
• It hosts a BroadcastReceiver that’s executing its onReceive() method.

Generally, only a few foreground processes exist at any given time. They are killed only as a last resort—if memory is so low that they cannot all continue to run. Generally, at that point, the device has reached a memory paging state, so killing some foreground processes is required to keep the user interface responsive.

2. Visible process: - A process that doesn’t have any foreground components, but still can affect what the user sees on screen. A process is considered to be visible if either of the following conditions is true:

• It hosts an Activity that is not in the foreground, but is still visible to the user (its onPause() method has been called). This might occur, for example, if the foreground activity started a dialog, which allows the previous activity to be seen behind it.
• It hosts a Service that’s bound to a visible (or foreground) activity.

A visible process is considered extremely important and will not be killed unless doing so is required to keep all foreground processes running.

3. Service process: - A process that is running a service that has been started with the startService() method and does not fall into either of the two higher categories. Although service processes are not directly tied to anything the user sees, they are generally doing things that the user cares about (such as playing music in the background or downloading data on the network), so the system keeps them running unless there’s not enough memory to retain them along with all foreground and visible processes.

4. Background process: - A process holding an activity that’s not currently visible to the user (the activity’s onStop() method has been called). These processes have no direct impact on the user experience, and the system can kill them at any time to reclaim memory for a foreground, visible, or service process. Usually there are many background processes running, so they are kept in an LRU (least recently used) list to ensure that the process with the activity that was most recently seen by the user is the last to be killed. If an activity implements its lifecycle methods correctly, and saves its current state, killing its process will not have a visible effect on the user experience, because when the user navigates back to the activity, the activity restores all of its visible state.

5. Empty process: - A process that doesn’t hold any active application components. The only reason to keep this kind of process alive is for caching purposes, to improve startup time the next time a component needs to run in it. The system often kills these processes in order to balance overall system resources between process caches and the underlying kernel caches.

Now some working scenario of android process

1. Android ranks a process at the highest level it can, based upon the importance of the components currently active in the process. For example, if a process hosts a service and a visible activity, the process is ranked as a visible process, not a service process.
2. In addition, a process’s ranking might be increased because other processes are dependent on it—a process that is serving another process can never be ranked lower than the process it is serving. For example, if a content provider in process A is serving a client in process B, or if a service in process A is bound to a component in process B, process A is always considered at least as important as process B.
3. A process running a service is ranked higher than a process with background activities, an activity that initiates a long-running operation might do well to start a service for that operation, rather than simply create a worker thread—particularly if the operation will likely outlast the activity. For example, an activity that’s uploading a picture to a web site should start a service to perform the upload so that the upload can continue in the background even if the user leaves the activity. In that case service process has higher priority and it works regardless of its activity process. This is the same reason that broadcast receivers should employ services rather than simply put time-consuming operations in a thread.

Resource management (App Running memory uses) 
1. The Activity Stack
For each application that is running on an Android device, the run time system maintains an Activity Stack. When an application is launched, the first of the application’s activities to be started is placed onto the stack. When a second activity is started, it is placed on the top of the stack and the previous activity is pushed down. The activity at the top of the stack is referred to as the active (or running) activity. When the active activity exits, it is popped off the stack by the run-time and the activity located immediately beneath it in the stack becomes the current active activity.
 The activity at the top of the stack might, for example, simply exit because the task for which it is responsible has been completed. Alternatively, the user may have selected a “Back” button on the screen to return to the previous activity, causing the current activity to be popped off the stack by the run-time system and therefore destroyed. As  per given image

The Activity Stack is what is referred to in programming terminology as a Last-In-First-Out (LIFO) stack in that the last item to be pushed onto the stack is the first to be popped off.

Summary

Mobile devices are typically considered to be resource constrained, particularly in terms of on board memory capacity. Consequently, a prime responsibility of the Android operating system is to ensure that applications, and the operating system in general, remain responsive to the user.

Applications are hosted on Android within processes (essentially instances of the Dalvik virtual machine). Each application, in turn, is made up of components in the form of activities and Services.

The Android run-time system has the power to terminate both processes and individual activities in order to free up memory. Process state is taken into consideration by the run-time system when deciding whether a process is a suitable candidate for termination. The state of a process is, to a large extent, dependent upon the status of the activities hosted by that process.

    Thanks & Happy Coding !!!