The role of Transformation Matrices in Animation

The mechanics of animation of are quite simple. Take any scene and if you repaint it quick while some aspect of that scene is changing you get the impression that something is moving smoothly although the repaint is happening only with a certain frequency which is typically 24 or 12 frames per second.

what changes at every redraw may be color, position, orientation, or size or any combination of these. If you want to take a view or a scene or a picture and want to move that scene to the right by a few pixels, you will typically define a transformation matrix and then apply a matrix multiplication or transformation on every pixel of the scene to get the new location. So each tranformation is identified by a certain matrix.

If you start with an identity matrix and then apply each transformation to it then you will get a final matrix that you can apply just one time to transform the view. By changing these matrices in a gradual manner in a time loop you will accomplish animation. Let's spend a little bit more time and understand the matrix api before going further.

You can get an identity matrix by doing

import android.graphics.Matrix;
Matrix matrix = new Matrix();

To achieve rotation you can do

matrix.setRotate(degrees)

This method will rotate the view around origin by those many degrees in a 2D space. Some other methods are

matrix.setScale(x,y);
matrix.setTranslate(x,y);
matrix.setSkew(x,y); 

As you call these methods to arrive at a desired matrix be aware of the "set" semantics. "set" semantics works like a "setting" a variable which means "replace" the current value with the new value. All of these methods, if you follow the java source code of android eventually resolve to some c++ code from a core google graphics library called "skia". You can explore the source code online at

http://android.git.kernel.org/

"git" is a source code control system used by the android open source project. You can learn more about "git" SCM here at

http://git.or.cz/

Now back to understanding of the "set" semantics on these graphics matrices. Let us take a look at the source code for "setScale":

void SkMatrix::setScale(SkScalar sx, SkScalar sy) {
    fMat[kMScaleX] = sx;
    fMat[kMScaleY] = sy;
    fMat[kMPersp2] = kMatrix22Elem;

    fMat[kMTransX] = fMat[kMTransY] =
    fMat[kMSkewX]  = fMat[kMSkewY] = 
    fMat[kMPersp0] = fMat[kMPersp1] = 0;

    this->setTypeMask(kScale_Mask | kRectStaysRect_Mask);
}

The scale function replaces all previous scaling values and pretty much resets the matrix and sets the scale. So if you have done anything else to the matrix all that is gone. Let us take a look at the "setTranslate" to see if that is any different.

void SkMatrix::setTranslate(SkScalar dx, SkScalar dy) {
    if (SkScalarAs2sCompliment(dx) | SkScalarAs2sCompliment(dy)) {
        fMat[kMTransX] = dx;
        fMat[kMTransY] = dy;

        fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
        fMat[kMSkewX]  = fMat[kMSkewY] = 
        fMat[kMPersp0] = fMat[kMPersp1] = 0;
        fMat[kMPersp2] = kMatrix22Elem;

        this->setTypeMask(kTranslate_Mask | kRectStaysRect_Mask);
    } else {
        this->reset();
    }
}

Basically sets the scale back to 1 and sets the translations replacing everything before.

So what do you do if you want to apply multiple transformations in a tow. Matrix class provides a set of "pre*" and "post*" functions for each of the "set*" fucnctions. Let us take a look at the source code for "preScale"

bool SkMatrix::preScale(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py) {
    SkMatrix    m;
    m.setScale(sx, sy, px, py);
    return this->preConcat(m);
}

bool SkMatrix::preConcat(const SkMatrix& mat) {
    return this->setConcat(*this, mat);
}

bool SkMatrix::postConcat(const SkMatrix& mat) {
    return this->setConcat(mat, *this);
}

Essentially "preScale" creates a brand new matrix with the given scale and then multiplies that matrix with the current matrix and replaces the current matrix with the resultant matrix. When matrices are multiplied the order is important. So if we do

m.setScale(..) = rm1
m.preScale(..) = m2 x rm1 = rm3
m.postScale(..) = rm3 x m4 = rm5

I could have acheived the same with

m1.setScale() = m1
m2.setScale() = m2
m3.setScale() = m3

m1.setConcat(m2,m1); // rm3
m1.setConcat(m1,m3); // rm5

You can concat

If "m1" was an identity matrix then the following two would be equal as well

m1.postTranslate(); // take it to the origin
m1.postScale(); //scale it
m1.postTranslate();// take it back to the center

m2.setScale();
m2.preTranslate();
m2.postTranslate();

Here is some more sample code demonstrating matrix equivalence based on the order of operations on that matrix

	public class TestMatrix
	{
	public static void test(SomeActivity a)
	{
	test1(a);
	test2(a);
	test3(a);
	}
	public static void test1(SomeActivity a)
	{
	Matrix m1 = new Matrix();
	m1.setScale(2, 2);
	m1.preScale(2, 2);
	m1.postScale(2, 2);
	Matrix m2 = new Matrix();
	m2.postScale(2, 2);
	m2.postScale(2, 2);
	m2.postScale(2, 2);
	assertL("test1",a,m1,m2,"m1 and m2 will be same");
	}
	public static void test2(SomeActivity a)
	{
	Matrix m1 = new Matrix();
	m1.setScale(2, 2);
	m1.preTranslate(-2, -2);
	m1.postTranslate(2, 2);
	Matrix m2 = new Matrix();
	m2.postTranslate(-2, -2);
	m2.postScale(2, 2);
	m2.postTranslate(2, 2);
	assertL("test2",a,m1,m2,"m1 and m2 will be the same");
	}
	public static void test3(SomeActivity a)
	{
	Matrix m1 = new Matrix();
	m1.setScale(2, 2);
	m1.preTranslate(-2, -2);
	m1.postTranslate(2, 2);
	Matrix m2 = new Matrix();
	m2.preTranslate(-2, -2);
	m2.postTranslate(2, 2);
	m2.setScale(2, 2);
	assertL("test4",a,m1,m2,"m1 and m2 will not be the same");
	Matrix m3 = new Matrix();
	m3.setScale(2, 2);
	assertL("test3",a,m2,m3,"m2 and m3 will be the same");
	}
	private static void assertL(String testName
	, SomeActivity a
	, Matrix m1
	, Matrix m2
	, String assertText)
	{
	if (m1.equals(m2))
	{
	a.appendText("\n" + testName + ": m1 is same as m2");
	}
	else
	{
	a.appendText("\n" + testName + ": m1 is NOT same as m2");
	}
	}
	}

view raw TestMatrix.java hosted with ❤ by GitHub

In summary all the "pre*" and "post*" methods are mere shortcuts to "setConcat" against itself.

preTranslate(m) -> setConcat(m x self) 
preRotate(m) -> setConcat(m x self)
preScale(m) -> setConcat(m x self)
preSkew(m) -> setConcat(m x self)

postTranslate(m) -> setConcat (self x m)
postRotate(m) -> setConcat (self x m)
postScale(m) -> setConcat (self x m)


postSkew(m) -> setConcat (self x m)

Introduction To Animation In Android

Android supports two kinds of animation. 

• One is called "Tweened Animation". 
• The second one is called "Frame by Frame" animation. 

"Tween" is a short for "in-between" borrowed from traditional animators. Inbetweens are drawings that simulate motion between key frames. There may be 24 inbetweens between two key frames or there could be 12 between two key frames. The former case is called "on ones" and the later ones are called "on twos".

In Android here is how "tweening" works. You start with a view. This view can be any view including a view group with any set of complex composed graphical objects. When tweening animation is attached to this view, the animation gets a call back at regular intervals to change any aspect of the tranformation matrix that would be used to render the view.

Moving an object or scaling an object, or changing the shade of an object can all be represented as a set of matrix transformations. By changing this matrix in the call back of the animation you will render the object at a different place with a different scale or a diferent color.

So at a general level, tweening animation is acomplished by changing the properties of a view at various time intervals during the alloted time of an animation.

Android supports the following types of "tween" animations

• AlphaAnimation: Changing Transparency of an object

• RotateAnimation: Rotating an object

• ScaleAnimation: Scale an object

• TranslateAnimation: Move an object

In Android frame by frame animation a series of drawable resources are loaded one after the other. The class AnimationDrawable is responsible for frame by frame animation. Each frame in this animation is a drawable resource.

As you get deeper into Android animation you will see that the distinction is not so clearcut where you can mix both concepts by essentially redrawing the canvas one way or the other.

ViewPager and PagerTabStrip

Note: Require "android-support-v4.jar" and its size greater than 3mb.

	/* main.xml
	<?xml version="1.0" encoding="utf-8"?>
	<android.support.v4.view.ViewPager xmlns:android="http://schemas.android.com/apk/res/android"
	android:id="@+id/viewpager"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent"
	android:background="@drawable/background" >
	<android.support.v4.view.PagerTabStrip
	android:layout_width="wrap_content"
	android:layout_height="wrap_content"
	android:layout_gravity="top" />
	</android.support.v4.view.ViewPager>
	*/
	//ViewPager Adapter
	public class ViewPagerAdapter extends PagerAdapter {
	// ----------------------------------------------------------------
	private Gallery gallery_disc, gallery_fest, gallery_combo;
	private ImageView selectedImageView;
	private ImageView leftArrowImageView;
	private ImageView rightArrowImageView;
	private int discPos, festPos, comboPos = 0;
	private List<String> drawable, d1, d2, d3;
	private GalleryImageAdapter disc_adapter, fest_adapter, combo_adapter;
	TextView tvOfferName_disc, tvDesc_disc, tvItems_disc, tvDiscount_disc;
	TextView tvOfferName_fest, tvDesc_fest, tvItems_fest, tvDiscount_fest;
	TextView tvOfferName_combo, tvDesc_combo, tvItems_combo, tvDiscount_combo;
	String discOffer[][];
	String comboOffer[][];
	String festOffer[][];
	String temp = "% Discount on Following Items:";
	ProgressDialog pd;
	// --------------------------------------
	private static String[] titles = new String[] { "Sport", "Music",
	"Games" };
	private final Context context;
	private int[] scrollPosition = new int[titles.length];
	public ViewPagerAdapter(Context context) {
	this.context = context;
	for (int i = 0; i < titles.length; i++) {
	scrollPosition[i] = 0;
	}
	}
	@Override
	public String getPageTitle(int position) {
	return titles[position];
	}
	@Override
	public int getCount() {
	return titles.length;
	}
	@Override
	public Object instantiateItem(View pager, final int position) {
	//Instantiate your all controls here
	LinearLayout llmain=new LinearLayout(context);
	((ViewPager) pager).addView(llmain, 0);
	return llmain;
	}
	@Override
	public void destroyItem(View pager, int position, Object view) {
	((ViewPager) pager).removeView((LinearLayout) view);
	}
	@Override
	public boolean isViewFromObject(View view, Object object) {
	return view.equals(object);
	}
	@Override
	public void finishUpdate(View view) {
	}
	@Override
	public void restoreState(Parcelable p, ClassLoader c) {
	if (p instanceof ScrollState) {
	scrollPosition = ((ScrollState) p).getScrollPos();
	}
	}
	@Override
	public Parcelable saveState() {
	return new ScrollState(scrollPosition);
	}
	@Override
	public void startUpdate(View view) {
	}
	}
	//To Maintain Scroll State after each Swipe
	public class ScrollState implements Parcelable
	{
	private int[] scrollPos;
	public static Parcelable.Creator<ScrollState> CREATOR = new Parcelable.Creator<ScrollState>()
	{
	@Override
	public ScrollState createFromParcel( Parcel source )
	{
	int size = source.readInt();
	int[] scrollPos = new int[ size ];
	source.readIntArray( scrollPos );
	return new ScrollState( scrollPos );
	}
	@Override
	public ScrollState[] newArray( int size )
	{
	return new ScrollState[ size ];
	}
	};
	public ScrollState( int[] scrollPos )
	{
	this.scrollPos = scrollPos;
	}
	@Override
	public int describeContents()
	{
	return 0;
	}
	@Override
	public void writeToParcel( Parcel dest, int flags )
	{
	dest.writeInt( scrollPos.length );
	dest.writeIntArray( scrollPos );
	}
	public int[] getScrollPos()
	{
	return scrollPos;
	}
	}

view raw ViewPagerAdapter.java hosted with ❤ by GitHub

Create Quick Action Menu

	//Main Activity
	public class QuickMenuActivity extends Activity {
	/** Called when the activity is first created. */
	private static final int ID_UP = 1;
	private static final int ID_DOWN = 2;
	private static final int ID_SEARCH = 3;
	private static final int ID_INFO = 4;
	private static final int ID_ERASE = 5;
	private static final int ID_OK = 6;
	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	ActionItem nextItem = new ActionItem(ID_DOWN, "Next", getResources()
	.getDrawable(R.drawable.menu_down_arrow));
	ActionItem prevItem = new ActionItem(ID_UP, "Prev", getResources()
	.getDrawable(R.drawable.menu_up_arrow));
	ActionItem searchItem = new ActionItem(ID_SEARCH, "Find",
	getResources().getDrawable(R.drawable.menu_search));
	ActionItem infoItem = new ActionItem(ID_INFO, "Info", getResources()
	.getDrawable(R.drawable.menu_info));
	ActionItem eraseItem = new ActionItem(ID_ERASE, "Clear", getResources()
	.getDrawable(R.drawable.menu_eraser));
	ActionItem okItem = new ActionItem(ID_OK, "OK", getResources()
	.getDrawable(R.drawable.menu_ok));
	// use setSticky(true) to disable QuickAction dialog being dismissed
	// after an item is clicked
	prevItem.setSticky(true);
	nextItem.setSticky(true);
	// create QuickAction. Use QuickAction.VERTICAL or
	// QuickAction.HORIZONTAL param to define layout
	// orientation
	final QuickAction quickAction = new QuickAction(this,
	QuickAction.VERTICAL);
	// add action items into QuickAction
	quickAction.addActionItem(nextItem);
	quickAction.addActionItem(prevItem);
	quickAction.addActionItem(searchItem);
	quickAction.addActionItem(infoItem);
	quickAction.addActionItem(eraseItem);
	quickAction.addActionItem(okItem);
	// Set listener for action item clicked
	quickAction
	.setOnActionItemClickListener(new QuickAction.OnActionItemClickListener() {
	@Override
	public void onItemClick(QuickAction source, int pos,
	int actionId) {
	ActionItem actionItem = quickAction.getActionItem(pos);
	// here we can filter which action item was clicked with
	// pos or actionId parameter
	if (actionId == ID_SEARCH) {
	Toast.makeText(getApplicationContext(),
	"Let's do some search action",
	Toast.LENGTH_SHORT).show();
	} else if (actionId == ID_INFO) {
	Toast.makeText(getApplicationContext(),
	"I have no info this time",
	Toast.LENGTH_SHORT).show();
	} else {
	Toast.makeText(getApplicationContext(),
	actionItem.getTitle() + " selected",
	Toast.LENGTH_SHORT).show();
	}
	}
	});
	// set listnener for on dismiss event, this listener will be called only
	// if QuickAction dialog was dismissed
	// by clicking the area outside the dialog.
	quickAction.setOnDismissListener(new QuickAction.OnDismissListener() {
	@Override
	public void onDismiss() {
	Toast.makeText(getApplicationContext(), "Dismissed",
	Toast.LENGTH_SHORT).show();
	}
	});
	// show on btn1
	Button btn1 = (Button) this.findViewById(R.id.btn1);
	btn1.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	}
	});
	Button btn2 = (Button) this.findViewById(R.id.btn2);
	btn2.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	}
	});
	Button btn3 = (Button) this.findViewById(R.id.btn3);
	btn3.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	quickAction.setAnimStyle(QuickAction.ANIM_REFLECT);
	}
	});
	}
	}
	//Popup Window Open and Dismiss
	/**
	* QuickAction dialog, shows action list as icon and text like the one in Gallery3D app. Currently supports vertical
	* and horizontal layout.
	*
	*
	*/
	public class QuickAction extends PopupWindows implements OnDismissListener {
	private View mRootView;
	private ImageView mArrowUp;
	private ImageView mArrowDown;
	private LayoutInflater mInflater;
	private ViewGroup mTrack;
	private ScrollView mScroller;
	private OnActionItemClickListener mItemClickListener;
	private OnDismissListener mDismissListener;
	private List<ActionItem> actionItems = new ArrayList<ActionItem>();
	private boolean mDidAction;
	private int mChildPos;
	private int mInsertPos;
	private int mAnimStyle;
	private int mOrientation;
	private int rootWidth=0;
	public static final int HORIZONTAL = 0;
	public static final int VERTICAL = 1;
	public static final int ANIM_GROW_FROM_LEFT = 1;
	public static final int ANIM_GROW_FROM_RIGHT = 2;
	public static final int ANIM_GROW_FROM_CENTER = 3;
	public static final int ANIM_REFLECT = 4;
	public static final int ANIM_AUTO = 5;
	/**
	* Constructor for default vertical layout
	*
	* @param context Context
	*/
	public QuickAction(Context context) {
	this(context, VERTICAL);
	}
	/**
	* Constructor allowing orientation override
	*
	* @param context Context
	* @param orientation Layout orientation, can be vartical or horizontal
	*/
	public QuickAction(Context context, int orientation) {
	super(context);
	mOrientation = orientation;
	mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	if (mOrientation == HORIZONTAL) {
	setRootViewId(R.layout.popup_horizontal);
	} else {
	setRootViewId(R.layout.popup_vertical);
	}
	mAnimStyle = ANIM_AUTO;
	mChildPos = 0;
	}
	/**
	* Get action item at an index
	*
	* @param index Index of item (position from callback)
	*
	* @return Action Item at the position
	*/
	public ActionItem getActionItem(int index) {
	return actionItems.get(index);
	}
	/**
	* Set root view.
	*
	* @param id Layout resource id
	*/
	public void setRootViewId(int id) {
	mRootView = (ViewGroup) mInflater.inflate(id, null);
	mTrack = (ViewGroup) mRootView.findViewById(R.id.tracks);
	mArrowDown = (ImageView) mRootView.findViewById(R.id.arrow_down);
	mArrowUp = (ImageView) mRootView.findViewById(R.id.arrow_up);
	mScroller = (ScrollView) mRootView.findViewById(R.id.scroller);
	//This was previously defined on show() method, moved here to prevent force close that occured
	//when tapping fastly on a view to show quickaction dialog.
	//Thanx to zammbi (github.com/zammbi)
	mRootView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
	setContentView(mRootView);
	}
	/**
	* Set animation style
	*
	* @param mAnimStyle animation style, default is set to ANIM_AUTO
	*/
	public void setAnimStyle(int mAnimStyle) {
	this.mAnimStyle = mAnimStyle;
	}
	/**
	* Set listener for action item clicked.
	*
	* @param listener Listener
	*/
	public void setOnActionItemClickListener(OnActionItemClickListener listener) {
	mItemClickListener = listener;
	}
	/**
	* Add action item
	*
	* @param action {@link ActionItem}
	*/
	public void addActionItem(ActionItem action) {
	actionItems.add(action);
	String title = action.getTitle();
	Drawable icon = action.getIcon();
	View container;
	if (mOrientation == HORIZONTAL) {
	container = mInflater.inflate(R.layout.action_item_horizontal, null);
	} else {
	container = mInflater.inflate(R.layout.action_item_vertical, null);
	}
	ImageView img = (ImageView) container.findViewById(R.id.iv_icon);
	TextView text = (TextView) container.findViewById(R.id.tv_title);
	if (icon != null) {
	img.setImageDrawable(icon);
	} else {
	img.setVisibility(View.GONE);
	}
	if (title != null) {
	text.setText(title);
	} else {
	text.setVisibility(View.GONE);
	}
	final int pos = mChildPos;
	final int actionId = action.getActionId();
	container.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	if (mItemClickListener != null) {
	mItemClickListener.onItemClick(QuickAction.this, pos, actionId);
	}
	if (!getActionItem(pos).isSticky()) {
	mDidAction = true;
	dismiss();
	}
	}
	});
	container.setFocusable(true);
	container.setClickable(true);
	if (mOrientation == HORIZONTAL && mChildPos != 0) {
	View separator = mInflater.inflate(R.layout.horiz_separator, null);
	RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.FILL_PARENT);
	separator.setLayoutParams(params);
	separator.setPadding(5, 0, 5, 0);
	mTrack.addView(separator, mInsertPos);
	mInsertPos++;
	}
	mTrack.addView(container, mInsertPos);
	mChildPos++;
	mInsertPos++;
	}
	/**
	* Show quickaction popup. Popup is automatically positioned, on top or bottom of anchor view.
	*
	*/
	public void show (View anchor) {
	preShow();
	int xPos, yPos, arrowPos;
	mDidAction = false;
	int[] location = new int[2];
	anchor.getLocationOnScreen(location);
	Rect anchorRect = new Rect(location[0], location[1], location[0] + anchor.getWidth(), location[1]
	+ anchor.getHeight());
	//mRootView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
	mRootView.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
	int rootHeight = mRootView.getMeasuredHeight();
	if (rootWidth == 0) {
	rootWidth = mRootView.getMeasuredWidth();
	}
	int screenWidth = mWindowManager.getDefaultDisplay().getWidth();
	int screenHeight = mWindowManager.getDefaultDisplay().getHeight();
	//automatically get X coord of popup (top left)
	if ((anchorRect.left + rootWidth) > screenWidth) {
	xPos = anchorRect.left - (rootWidth-anchor.getWidth());
	xPos = (xPos < 0) ? 0 : xPos;
	arrowPos = anchorRect.centerX()-xPos;
	} else {
	if (anchor.getWidth() > rootWidth) {
	xPos = anchorRect.centerX() - (rootWidth/2);
	} else {
	xPos = anchorRect.left;
	}
	arrowPos = anchorRect.centerX()-xPos;
	}
	int dyTop = anchorRect.top;
	int dyBottom = screenHeight - anchorRect.bottom;
	boolean onTop = (dyTop > dyBottom) ? true : false;
	if (onTop) {
	if (rootHeight > dyTop) {
	yPos = 15;
	LayoutParams l = mScroller.getLayoutParams();
	l.height = dyTop - anchor.getHeight();
	} else {
	yPos = anchorRect.top - rootHeight;
	}
	} else {
	yPos = anchorRect.bottom;
	if (rootHeight > dyBottom) {
	LayoutParams l = mScroller.getLayoutParams();
	l.height = dyBottom;
	}
	}
	showArrow(((onTop) ? R.id.arrow_down : R.id.arrow_up), arrowPos);
	setAnimationStyle(screenWidth, anchorRect.centerX(), onTop);
	mWindow.showAtLocation(anchor, Gravity.NO_GRAVITY, xPos, yPos);
	}
	/**
	* Set animation style
	*
	* @param screenWidth screen width
	* @param requestedX distance from left edge
	* @param onTop flag to indicate where the popup should be displayed. Set TRUE if displayed on top of anchor view
	* and vice versa
	*/
	private void setAnimationStyle(int screenWidth, int requestedX, boolean onTop) {
	int arrowPos = requestedX - mArrowUp.getMeasuredWidth()/2;
	switch (mAnimStyle) {
	case ANIM_GROW_FROM_LEFT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Left : R.style.Animations_PopDownMenu_Left);
	break;
	case ANIM_GROW_FROM_RIGHT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Right : R.style.Animations_PopDownMenu_Right);
	break;
	case ANIM_GROW_FROM_CENTER:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Center : R.style.Animations_PopDownMenu_Center);
	break;
	case ANIM_REFLECT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Reflect : R.style.Animations_PopDownMenu_Reflect);
	break;
	case ANIM_AUTO:
	if (arrowPos <= screenWidth/4) {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Left : R.style.Animations_PopDownMenu_Left);
	} else if (arrowPos > screenWidth/4 && arrowPos < 3 * (screenWidth/4)) {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Center : R.style.Animations_PopDownMenu_Center);
	} else {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Right : R.style.Animations_PopDownMenu_Right);
	}
	break;
	}
	}
	/**
	* Show arrow
	*
	* @param whichArrow arrow type resource id
	* @param requestedX distance from left screen
	*/
	private void showArrow(int whichArrow, int requestedX) {
	final View showArrow = (whichArrow == R.id.arrow_up) ? mArrowUp : mArrowDown;
	final View hideArrow = (whichArrow == R.id.arrow_up) ? mArrowDown : mArrowUp;
	final int arrowWidth = mArrowUp.getMeasuredWidth();
	showArrow.setVisibility(View.VISIBLE);
	ViewGroup.MarginLayoutParams param = (ViewGroup.MarginLayoutParams)showArrow.getLayoutParams();
	param.leftMargin = requestedX - arrowWidth / 2;
	hideArrow.setVisibility(View.INVISIBLE);
	}
	/**
	* Set listener for window dismissed. This listener will only be fired if the quicakction dialog is dismissed
	* by clicking outside the dialog or clicking on sticky item.
	*/
	public void setOnDismissListener(QuickAction.OnDismissListener listener) {
	setOnDismissListener(this);
	mDismissListener = listener;
	}
	@Override
	public void onDismiss() {
	if (!mDidAction && mDismissListener != null) {
	mDismissListener.onDismiss();
	}
	}
	/**
	* Listener for item click
	*
	*/
	public interface OnActionItemClickListener {
	public abstract void onItemClick(QuickAction source, int pos, int actionId);
	}
	/**
	* Listener for window dismiss
	*
	*/
	public interface OnDismissListener {
	public abstract void onDismiss();
	}
	}
	//--------------- Create Another Class------------------------------------------------------------------------
	public class PopupWindows {
	protected Context mContext;
	protected PopupWindow mWindow;
	protected View mRootView;
	protected Drawable mBackground = null;
	protected WindowManager mWindowManager;
	/**
	* Constructor.
	*
	* @param context Context
	*/
	public PopupWindows(Context context) {
	mContext = context;
	mWindow = new PopupWindow(context);
	mWindow.setTouchInterceptor(new OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
	if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {
	mWindow.dismiss();
	return true;
	}
	return false;
	}
	});
	mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
	}
	/**
	* On dismiss
	*/
	protected void onDismiss() {
	}
	/**
	* On show
	*/
	protected void onShow() {
	}
	/**
	* On pre show
	*/
	protected void preShow() {
	if (mRootView == null)
	throw new IllegalStateException("setContentView was not called with a view to display.");
	onShow();
	if (mBackground == null)
	mWindow.setBackgroundDrawable(new BitmapDrawable());
	else
	mWindow.setBackgroundDrawable(mBackground);
	mWindow.setWidth(WindowManager.LayoutParams.WRAP_CONTENT);
	mWindow.setHeight(WindowManager.LayoutParams.WRAP_CONTENT);
	mWindow.setTouchable(true);
	mWindow.setFocusable(true);
	mWindow.setOutsideTouchable(true);
	mWindow.setContentView(mRootView);
	}
	/**
	* Set background drawable.
	*
	* @param background Background drawable
	*/
	public void setBackgroundDrawable(Drawable background) {
	mBackground = background;
	}
	/**
	* Set content view.
	*
	* @param root Root view
	*/
	public void setContentView(View root) {
	mRootView = root;
	mWindow.setContentView(root);
	}
	/**
	* Set content view.
	*
	* @param layoutResID Resource id
	*/
	public void setContentView(int layoutResID) {
	LayoutInflater inflator = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	setContentView(inflator.inflate(layoutResID, null));
	}
	/**
	* Set listener on window dismissed.
	*
	* @param listener
	*/
	public void setOnDismissListener(PopupWindow.OnDismissListener listener) {
	mWindow.setOnDismissListener(listener);
	}
	/**
	* Dismiss the popup window.
	*/
	public void dismiss() {
	mWindow.dismiss();
	}
	}
	//Defining Action Items with Quick menu
	/**
	* Action item, displayed as menu with icon and text.
	*/
	public class ActionItem {
	private Drawable icon;
	private Bitmap thumb;
	private String title;
	private int actionId = -1;
	private boolean selected;
	private boolean sticky;
	/**
	* Constructor
	*
	* @param actionId Action id for case statements
	* @param title Title
	* @param icon Icon to use
	*/
	public ActionItem(int actionId, String title, Drawable icon) {
	this.title = title;
	this.icon = icon;
	this.actionId = actionId;
	}
	/**
	* Constructor
	*/
	public ActionItem() {
	this(-1, null, null);
	}
	/**
	* Constructor
	*
	* @param actionId Action id of the item
	* @param title Text to show for the item
	*/
	public ActionItem(int actionId, String title) {
	this(actionId, title, null);
	}
	/**
	* Constructor
	*
	* @param icon {@link Drawable} action icon
	*/
	public ActionItem(Drawable icon) {
	this(-1, null, icon);
	}
	/**
	* Constructor
	*
	* @param actionId Action ID of item
	* @param icon {@link Drawable} action icon
	*/
	public ActionItem(int actionId, Drawable icon) {
	this(actionId, null, icon);
	}
	/**
	* Set action title
	*
	* @param title action title
	*/
	public void setTitle(String title) {
	this.title = title;
	}
	/**
	* Get action title
	*
	* @return action title
	*/
	public String getTitle() {
	return this.title;
	}
	/**
	* Set action icon
	*
	* @param icon {@link Drawable} action icon
	*/
	public void setIcon(Drawable icon) {
	this.icon = icon;
	}
	/**
	* Get action icon
	* @return {@link Drawable} action icon
	*/
	public Drawable getIcon() {
	return this.icon;
	}
	/**
	* Set action id
	*
	* @param actionId Action id for this action
	*/
	public void setActionId(int actionId) {
	this.actionId = actionId;
	}
	/**
	* @return Our action id
	*/
	public int getActionId() {
	return actionId;
	}
	/**
	* Set sticky status of button
	*
	* @param sticky true for sticky, pop up sends event but does not disappear
	*/
	public void setSticky(boolean sticky) {
	this.sticky = sticky;
	}
	/**
	* @return true if button is sticky, menu stays visible after press
	*/
	public boolean isSticky() {
	return sticky;
	}
	/**
	* Set selected flag;
	*
	* @param selected Flag to indicate the item is selected
	*/
	public void setSelected(boolean selected) {
	this.selected = selected;
	}
	/**
	* Check if item is selected
	*
	* @return true or false
	*/
	public boolean isSelected() {
	return this.selected;
	}
	/**
	* Set thumb
	*
	* @param thumb Thumb image
	*/
	public void setThumb(Bitmap thumb) {
	this.thumb = thumb;
	}
	/**
	* Get thumb image
	*
	* @return Thumb image
	*/
	public Bitmap getThumb() {
	return this.thumb;
	}
	}

view raw QuickMenuActivity.java hosted with ❤ by GitHub

Awesome Gallery With Android....

Gallery With Reflection

	//Main Activity
	public class TryGallaryActivity extends Activity {
	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	Integer[] images = { R.drawable.img0001, R.drawable.img0030,
	R.drawable.img0100, R.drawable.img0130, R.drawable.img0200,
	R.drawable.img0230, R.drawable.img0300, R.drawable.img0330,
	R.drawable.img0354 };
	ImageAdapter adapter = new ImageAdapter(this, images);
	adapter.createReflectedImages();
	GalleryFlow galleryFlow = (GalleryFlow) findViewById(R.id.Gallery01);
	galleryFlow.setAdapter(adapter);
	}
	}
	//For Rotation make one class GalleryFlow
	public class GalleryFlow extends Gallery {
	private Camera mCamera = new Camera();
	private int mMaxRotationAngle = 60;
	private int mMaxZoom = -120;
	private int mCoveflowCenter;
	public GalleryFlow(Context context) {
	super(context);
	this.setStaticTransformationsEnabled(true);
	}
	public GalleryFlow(Context context, AttributeSet attrs) {
	super(context, attrs);
	this.setStaticTransformationsEnabled(true);
	}
	public GalleryFlow(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	this.setStaticTransformationsEnabled(true);
	}
	public int getMaxRotationAngle() {
	return mMaxRotationAngle;
	}
	public void setMaxRotationAngle(int maxRotationAngle) {
	mMaxRotationAngle = maxRotationAngle;
	}
	public int getMaxZoom() {
	return mMaxZoom;
	}
	public void setMaxZoom(int maxZoom) {
	mMaxZoom = maxZoom;
	}
	private int getCenterOfCoverflow() {
	return (getWidth() - getPaddingLeft() - getPaddingRight()) / 2
	+ getPaddingLeft();
	}
	private static int getCenterOfView(View view) {
	return view.getLeft() + view.getWidth() / 2;
	}
	protected boolean getChildStaticTransformation(View child, Transformation t) {
	final int childCenter = getCenterOfView(child);
	final int childWidth = child.getWidth();
	int rotationAngle = 0;
	t.clear();
	t.setTransformationType(Transformation.TYPE_MATRIX);
	if (childCenter == mCoveflowCenter) {
	transformImageBitmap((ImageView) child, t, 0);
	} else {
	rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
	if (Math.abs(rotationAngle) > mMaxRotationAngle) {
	rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle
	: mMaxRotationAngle;
	}
	transformImageBitmap((ImageView) child, t, rotationAngle);
	}
	return true;
	}
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
	mCoveflowCenter = getCenterOfCoverflow();
	super.onSizeChanged(w, h, oldw, oldh);
	}
	private void transformImageBitmap(ImageView child, Transformation t,
	int rotationAngle) {
	mCamera.save();
	final Matrix imageMatrix = t.getMatrix();
	final int imageHeight = child.getLayoutParams().height;
	final int imageWidth = child.getLayoutParams().width;
	final int rotation = Math.abs(rotationAngle);
	mCamera.translate(0.0f, 0.0f, 100.0f);
	// As the angle of the view gets less, zoom in
	if (rotation < mMaxRotationAngle) {
	float zoomAmount = (float) (mMaxZoom + (rotation * 1.5));
	mCamera.translate(0.0f, 0.0f, zoomAmount);
	}
	mCamera.rotateY(rotationAngle);
	mCamera.getMatrix(imageMatrix);
	imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));
	imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));
	mCamera.restore();
	}
	}
	//And at last Image Adapter for Reflection and Shadow Effect...
	public class ImageAdapter extends BaseAdapter {
	int mGalleryItemBackground;
	private Context mContext;
	private Integer[] mImageIds;
	private ImageView[] mImages;
	public ImageAdapter(Context c, Integer[] ImageIds) {
	mContext = c;
	mImageIds = ImageIds;
	mImages = new ImageView[mImageIds.length];
	}
	public boolean createReflectedImages() {
	final int reflectionGap = 4;
	int index = 0;
	for (int imageId : mImageIds) {
	Bitmap originalImage = BitmapFactory.decodeResource(mContext
	.getResources(), imageId);
	int width = originalImage.getWidth();
	int height = originalImage.getHeight();
	Matrix matrix = new Matrix();
	matrix.preScale(1, -1);
	Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,
	height / 2, width, height / 2, matrix, false);
	Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
	(height + height / 2), Config.ARGB_8888);
	Canvas canvas = new Canvas(bitmapWithReflection);
	canvas.drawBitmap(originalImage, 0, 0, null);
	Paint deafaultPaint = new Paint();
	canvas.drawRect(0, height, width, height + reflectionGap,
	deafaultPaint);
	canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
	Paint paint = new Paint();
	LinearGradient shader = new LinearGradient(0, originalImage
	.getHeight(), 0, bitmapWithReflection.getHeight()
	+ reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);
	paint.setShader(shader);
	paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
	canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
	+ reflectionGap, paint);
	ImageView imageView = new ImageView(mContext);
	imageView.setImageBitmap(bitmapWithReflection);
	imageView.setLayoutParams(new GalleryFlow.LayoutParams(450,300));
	// imageView.setScaleType(ScaleType.MATRIX);
	mImages[index++] = imageView;
	}
	return true;
	}
	private Resources getResources() {
	// TODO Auto-generated method stub
	return null;
	}
	public int getCount() {
	return mImageIds.length;
	}
	public Object getItem(int position) {
	return position;
	}
	public long getItemId(int position) {
	return position;
	}
	public View getView(int position, View convertView, ViewGroup parent) {
	return mImages[position];
	}
	public float getScale(boolean focused, int offset) {
	return Math.max(0, 1.0f / (float) Math.pow(2, Math.abs(offset)));
	///return 1;
	}
	}
	//Your main.xml should be like this ...
	/*
	<?xml version="1.0" encoding="utf-8"?>
	<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical"
	android:layout_width="fill_parent"
	android:layout_height="fill_parent"
	android:background="#ffffff"
	>
	<com.test.gly.GalleryFlow
	android:id="@+id/Gallery01"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content" android:layout_centerInParent="true"/>
	</RelativeLayout>
	*/

view raw TryGallaryActivity.java hosted with ❤ by GitHub

Convert Numeric To Varchar in SQL

RIGHT('000000' + CONVERT(VARCHAR(6), BranchMaster.Pincode), 6)

Android Distance Direction With Google Map (JSON)

Output: 

NOTE: Check  your Android Manifest..

	<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.test"
	android:versionCode="1"
	android:versionName="1.0" >
	<uses-sdk android:minSdkVersion="8" />
	<uses-permission android:name="android.permission.INTERNET" />
	<uses-permission android:name="android.permission.WRITE_CONTACTS" />
	<uses-permission android:name="android.permission.READ_CONTACTS" />
	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" >
	</uses-permission>
	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" >
	</uses-permission>
	<application
	android:icon="@drawable/ic_launcher"
	android:label="@string/app_name" >
	<activity
	android:label="@string/app_name"
	android:name=".JsonMapActivity" >
	<intent-filter >
	<action android:name="android.intent.action.MAIN" />
	<category android:name="android.intent.category.LAUNCHER" />
	</intent-filter>
	</activity>
	<uses-library android:name="com.google.android.maps" >
	</uses-library>
	</application>
	</manifest>

view raw Manifest.xml hosted with ❤ by GitHub

My Layout.xml

	<linearlayout android:layout_height="fill_parent"
	android:layout_width="fill_parent"
	android:orientation="vertical"
	xmlns:android="http://schemas.android.com/apk/res/android">
	<button android:id="@+id/btnPutAddress"
	android:layout_height="wrap_content"
	android:layout_width="fill_parent"
	android:text="Put New Address" >
	</button>
	<com .google.android.maps.mapview=""
	android:apikey="your key"
	android:id="@+id/mpBranch"
	android:layout_height="fill_parent"
	android:layout_width="fill_parent" />
	<linearlayout android:id="@+id/zoom"
	android:layout_alignparentbottom="true"
	android:layout_centerhorizontal="true"
	android:layout_height="wrap_content"
	android:layout_width="wrap_content">
	</linearlayout>
	</linearlayout>

view raw My Layout.xml hosted with ❤ by GitHub

1) Create class MyOverLay which extends Overlay

	public class MyOverLay extends Overlay
	{
	private GeoPoint gp1;
	private GeoPoint gp2;
	//private int mRadius=6;
	private int mode=0;
	private int defaultColor;
	private String text="";
	private Bitmap img = null;
	Context mContext;
	public MyOverLay(Context context,GeoPoint gp1,GeoPoint gp2,int mode) // GeoPoint is a int. (6E)
	{
	this.gp1 = gp1;
	this.gp2 = gp2;
	this.mode = mode;
	this.mContext = context;
	defaultColor = 999; // no defaultColor
	}
	public MyOverLay(GeoPoint gp1,GeoPoint gp2,int mode, int defaultColor)
	{
	this.gp1 = gp1;
	this.gp2 = gp2;
	this.mode = mode;
	this.defaultColor = defaultColor;
	}
	public void setText(String t)
	{
	this.text = t;
	}
	public void setBitmap(Bitmap bitmap)
	{
	this.img = bitmap;
	}
	public int getMode()
	{
	return mode;
	}
	@Override
	public boolean draw
	(Canvas canvas, MapView mapView, boolean shadow, long when)
	{
	Projection projection = mapView.getProjection();
	if (shadow == false)
	{
	Paint paint = new Paint();
	paint.setAntiAlias(true);
	Point point = new Point();
	projection.toPixels(gp1, point);
	// mode=1：start
	if(mode==1)
	{
	if(defaultColor==999)
	paint.setColor(Color.BLUE);
	else
	paint.setColor(defaultColor);
	// start point
	}
	// mode=2：path
	else if(mode==2)
	{
	if(defaultColor==999)
	paint.setColor(Color.RED);
	else
	paint.setColor(defaultColor);
	Point point2 = new Point();
	projection.toPixels(gp2, point2);
	paint.setStrokeWidth(5);
	paint.setAlpha(120);
	canvas.drawLine(point.x, point.y, point2.x,point2.y, paint);
	}
	/* mode=3：end */
	else if(mode==3)
	{
	/* the last path */
	if(defaultColor==999)
	paint.setColor(Color.GREEN);
	else
	paint.setColor(defaultColor);
	Point point2 = new Point();
	projection.toPixels(gp2, point2);
	paint.setStrokeWidth(5);
	paint.setAlpha(120);
	canvas.drawLine(point.x, point.y, point2.x,point2.y, paint);
	/* end point */
	}
	}
	return super.draw(canvas, mapView, shadow, when);
	}
	}

view raw MyOverLay.java hosted with ❤ by GitHub

2) Create another class CustomItemizedOverlay which extends ItemizedOverlay<OverlayItem>

 

	class CustomItemizedOverlay extends ItemizedOverlay<OverlayItem> {
	private final ArrayList<OverlayItem> mapOverlays = new ArrayList<OverlayItem>();
	private Context context;
	public CustomItemizedOverlay(Drawable defaultMarker) {
	super(boundCenterBottom(defaultMarker));
	}
	public CustomItemizedOverlay(Drawable defaultMarker, Context context) {
	this(defaultMarker);
	this.context = context;
	}
	@Override
	protected OverlayItem createItem(int i) {
	return mapOverlays.get(i);
	}
	@Override
	public int size() {
	return mapOverlays.size();
	}
	public void addOverlay(OverlayItem overlay) {
	mapOverlays.add(overlay);
	this.populate();
	}
	@Override
	protected boolean onTap(int index) {
	OverlayItem item = mapOverlays.get(index);
	AlertDialog.Builder dialog = new AlertDialog.Builder(context);
	dialog.setTitle(item.getTitle());dialog.setMessage(item.getSnippet());
	dialog.setNeutralButton("OK", new DialogInterface.OnClickListener() {
	@Override
	public void onClick(DialogInterface dialog, int which) {
	dialog.dismiss();
	}
	});
	dialog.show();
	return true;
	}
	}

view raw CustomItemizedOverlay.java hosted with ❤ by GitHub

3) Now Create Main Activity which extends MapActivity

	public class JsonMapActivity extends MapActivity {
	/** Called when the activity is first created. */
	static double srclongitute, destlongitute;
	static double srclatitude, destlatitude;
	static String distance_km = "";
	MapView mapView;
	private JsonMapActivity _activity;
	GeoPoint srcGeoPoint, destGeoPoint;
	private static List<Overlay> mOverlays;
	static String distance = "";
	JSONObject jsonObj;
	static String _path, start_address, end_address;
	Drawable srcdrawable;
	static String GPsLoc;
	Context context = this;
	Button btnDialog;
	LocationManager locationManager;
	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	jsonObj = getLocationInfo("GandhiNagar", "Surat");
	Toast.makeText(getApplicationContext(), "" + jsonObj.length(), 5)
	.show();
	if (getLatLong(jsonObj)) {
	Log.i("srcLati", "" + srclatitude);
	Log.i("srcLungi", "" + srclongitute);
	Log.i("destLati", "" + destlatitude);
	Log.i("destLungi", "" + destlongitute);
	}
	_activity = this;
	mapView = (MapView) findViewById(R.id.mpBranch);
	mapView.setBuiltInZoomControls(true);
	mapView.displayZoomControls(true);
	mapView.setClickable(true);
	srcGeoPoint = new GeoPoint((int) (srclatitude * 1E6),
	(int) (srclongitute * 1E6));
	destGeoPoint = new GeoPoint((int) (destlatitude * 1E6),
	(int) (destlongitute * 1E6));
	List<Overlay> mapOverlays = mapView.getOverlays();
	srcdrawable = getApplicationContext().getResources().getDrawable(
	R.drawable.map_user);// // user
	CustomItemizedOverlay srcitemizedOverlay = new CustomItemizedOverlay(
	srcdrawable, this);
	OverlayItem srcoverlayitem = new OverlayItem(srcGeoPoint,
	"My Location", start_address);
	Drawable destdrawable = this.getResources().getDrawable(
	R.drawable.map_restaurant); // rest
	CustomItemizedOverlay destitemizedOverlay = new CustomItemizedOverlay(
	destdrawable, this);
	OverlayItem destoverlayitem = new OverlayItem(destGeoPoint,
	"FoodCorner Branch", end_address);
	srcitemizedOverlay.addOverlay(srcoverlayitem);
	destitemizedOverlay.addOverlay(destoverlayitem);
	mapOverlays.add(srcitemizedOverlay);
	mapOverlays.add(destitemizedOverlay);
	connectAsyncTask _connectAsyncTask = new connectAsyncTask();
	_connectAsyncTask.execute();
	mOverlays = mapView.getOverlays();
	mapView.getController().animateTo(srcGeoPoint);
	mapView.getController().setZoom(8);
	}
	@Override
	protected boolean isRouteDisplayed() {
	// TODO Auto-generated method stub
	return false;
	}
	public static JSONObject getLocationInfo(String origin, String dest) {
	StringBuilder stringBuilder = new StringBuilder();
	try {
	origin = origin.replaceAll(" ", "%20");
	dest = dest.replaceAll(" ", "%20");
	HttpPost httppost = new HttpPost(
	"http://maps.googleapis.com/maps/api/directions/json?origin="
	+ origin + "&destination=" + dest + "&sensor=false");
	// http://maps.googleapis.com/maps/api/directions/json?origin=Chicago,IL&destination=Los+Angeles,CA&sensor=false
	HttpClient client = new DefaultHttpClient();
	HttpResponse response;
	stringBuilder = new StringBuilder();
	response = client.execute(httppost);
	HttpEntity entity = response.getEntity();
	InputStream stream = entity.getContent();
	int b;
	while ((b = stream.read()) != -1) {
	stringBuilder.append((char) b);
	}
	} catch (ClientProtocolException e) {
	} catch (IOException e) {
	}
	JSONObject jsonObject = new JSONObject();
	try {
	jsonObject = new JSONObject(stringBuilder.toString());
	} catch (JSONException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	return jsonObject;
	}
	// --------------------------------------------------------------------------
	// class Asych task
	private class connectAsyncTask extends AsyncTask<Void, Void, Void> {
	@Override
	protected void onPreExecute() {
	// TODO Auto-generated method stub
	super.onPreExecute();
	// SHOW YOU PROGRESS BAR HERE
	}
	@Override
	protected Void doInBackground(Void... params) {
	// TODO Auto-generated method stub
	return null;
	}
	@Override
	protected void onPostExecute(Void result) {
	// TODO Auto-generated method stub
	super.onPostExecute(result);
	if (_path != null) {
	Overlay ol = new MyOverLay(_activity, srcGeoPoint, srcGeoPoint,
	1);
	mOverlays.add(ol);
	List<GeoPoint> _geopoints = decodePoly(_path);
	GeoPoint gp1;
	GeoPoint gp2;
	gp2 = _geopoints.get(0);
	for (int i = 1; i < _geopoints.size(); i++) // the last one
	// would be
	// crash
	{
	gp1 = gp2;
	gp2 = _geopoints.get(i);
	Overlay ol1 = new MyOverLay(gp1, gp2, 2, Color.BLUE);
	mOverlays.add(ol1);
	}
	Overlay ol2 = new MyOverLay(_activity, destGeoPoint,
	destGeoPoint, 3);
	mOverlays.add(ol2);
	// DISMISS PROGRESS BAR HERE
	} else {
	// showAlert AS "Unable to find the route"
	}
	Overlay ol2 = new MyOverLay(_activity, destGeoPoint, destGeoPoint,
	3);
	mOverlays.add(ol2);
	// DISMISS PROGRESS BAR HERE
	}
	}// end of class
	// --------------------------------------------------------------------------
	private List<GeoPoint> decodePoly(String encoded) {
	List<GeoPoint> poly = new ArrayList<GeoPoint>();
	int index = 0, len = encoded.length();
	int lat = 0, lng = 0;
	while (index < len) {
	int b, shift = 0, result = 0;
	do {
	b = encoded.charAt(index++) - 63;
	result |= (b & 0x1f) << shift;
	shift += 5;
	} while (b >= 0x20);
	int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
	lat += dlat;
	shift = 0;
	result = 0;
	do {
	b = encoded.charAt(index++) - 63;
	result |= (b & 0x1f) << shift;
	shift += 5;
	} while (b >= 0x20);
	int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
	lng += dlng;
	GeoPoint p = new GeoPoint((int) (((double) lat / 1E5) * 1E6),
	(int) (((double) lng / 1E5) * 1E6));
	poly.add(p);
	}
	return poly;
	}
	// --------------------------------------------------
	public static boolean getLatLong(JSONObject jsonObject) {
	try {
	JSONObject jsonOb = ((JSONArray) jsonObject.get("routes"))
	.getJSONObject(0);
	JSONArray jsonArray = jsonOb.getJSONArray("legs");
	JSONObject j1 = jsonArray.getJSONObject(0);
	srclatitude = j1.getJSONObject("start_location").getDouble("lat");
	srclongitute = j1.getJSONObject("start_location").getDouble("lng");
	destlatitude = j1.getJSONObject("end_location").getDouble("lat");
	destlongitute = j1.getJSONObject("end_location").getDouble("lng");
	start_address = j1.getString("start_address");
	end_address = j1.getString("end_address");
	JSONObject ja = j1.getJSONObject("distance");
	// Log.i("jsonOb size", "" + ja.getString("text"));
	JSONObject ja_line = jsonOb.getJSONObject("overview_polyline");
	// Log.i("ja_line size", "" + ja_line.getString("points"));
	_path = ja_line.getString("points");
	} catch (JSONException e) {
	return false;
	}
	return true;
	}
	public class MyLocationListener implements LocationListener
	{
	@Override
	public void onLocationChanged(Location loc)
	{
	GPsLoc=new Double(loc.getLatitude()).toString()+",";
	GPsLoc+=loc.getLongitude();
	String Text = "My current location is: " + "Latitud = "
	+ loc.getLatitude() + "Longitud = " + loc.getLongitude();
	Toast.makeText(getApplicationContext(), Text, Toast.LENGTH_SHORT)
	.show();
	}
	@Override
	public void onProviderDisabled(String provider)
	{
	Toast.makeText(getApplicationContext(), "Gps Disabled",
	Toast.LENGTH_SHORT).show();
	}
	@Override
	public void onProviderEnabled(String provider)
	{
	Toast.makeText(getApplicationContext(), "Gps Enabled",
	Toast.LENGTH_SHORT).show();
	}
	@Override
	public void onStatusChanged(String provider, int status, Bundle extras)
	{
	}
	}/* End of Class MyLocationListener */
	}

view raw JsonMapActivity.java hosted with ❤ by GitHub

OCWCD Chapter 2 : Web App architecture

Containers

______________________________________________________

A container runs and controls the servlets.

A full J2EE application server must have both a web container and an EJB container.

When a request is received by the webserver and needs to access a servlet, the webserver hands the

request to the servlet-helper app : the container. Then the container hands the request to the servlet

itself.

Role

•  Match the request URL to a specific servlet;
• Creates request and response objects used to get informations from the client and send back informations to him;
• Creates the thread for the servlet;
• Calls the servlet’s service() method, passing request and response objects as parameters;
• service() method will call the doXxx() method of the servlet depending on request type;
•  Get the response object from the finished service() method and converts it to an HTTP response;
•  Destroys request and response objects;
•  Sends back response to the webserver

Capabilities of containers

Containers provide :

• Communications support : handles communication between the servlets and the webserver
• Lifecycle management : controls life and death of servlets, class loading, instantiation, initialization, invocation the servlets’ methods, and making servlet instances eligible for GC
• Multithreading support : Automatically creates a new thread for every servlet request received. When the Servlet service() method completes, the thread dies.
• Declarative security : manages the security inside the XML deployment descriptor file. Security can be configured and changed only by modifying this file.
• JSP support : Manages the JSPs.

URL to servlet mapping

The servlet container uses the deployment descriptor to map URL to servlets. Two DD elements

are used to achieve this :

<servlet> : maps internal name to fully qualified class name;

<servlet-mapping> : maps internal name to public URL name.

Model-View-Controller (MVC) Design

MVC does not only separates the Business Logic from the presentation, the Business Logic doesn’t

even know there is a presentation.

MVC : separate Business Logic (model) and the presentation, then put something between them toconnect them (controler), so the business can become a real re-usable code, and the presentation layer can be modified/changed at will.

OCWCD NOTES: Chapter 1 : HTTP

Overview :

• HTTP stands for HyperText Transport Protocol, and is the network protocol used over the web. It runs over TCP/IP.
• HTTP uses a request/response model. Client sends an HTTP request, then the server gives back the HTTP response that the browser will display (depending on the content type of the answer) If the response is an HTML file, then the HTML file is added to the HTTP response body
• An HTTP response includes : status code, the content-type (MIME type), and actuel content of the response
• A MIME type tells the browser what kind of data the response is holding URL stands for Uniform Resource Locator: starts with a protocol, then a server name, optionnaly followed by a port number, then the path to the resource followed by the resource name. Parameters may appear at the end, separated from the rest by a ?

HTTP methods
_________________________________________________________________________________

GET Gets the data identified by an URI
POST Same, the request’s body is passed to the resource specified by the URI
HEAD Sends back only the header of the response that would be sent by a GET
PUT Sends to the server data to store at specified URI. Server does not process the
data ; it only stores them
DELETE Delete specified resource
TRACE When it receives this request, the server sends it back to the client
OPTIONS Ask server informations about a resource or about its own capabilities
CONNECT Ask for a connction (tunnelling)
_________________________________________________________________________________

Differences between GET and POST

POST has a body.
GET parameters are passed on the URL line, after a ?. The URL size is limited.
The parameters appear in the browser URL field, hence showing any password to the world...
GET is supposed to be used to GET things (only retrieval, no modification on the server).
GET processing must be idempotent.

A click on a hyperlink always sends a GET request.
GET is the default method used by HTML forms. Use the method=”POST” to change it.

In POST requests, the parameters are passed in the body of the request, after the header. There is no
size-limit. Parameters are not visible from the user.
POST is supposed to be used to send data to be processed.
POST may not be idempotent and is the only one.

IDEMPOTENT : Can do the same thing over and over again, with no negative side effect.

10 Fantastic Ideas for B2B Mobile Apps

1.) Supply Ordering App: Are you a business product supplier? Create a supply ordering app that lets people order new supplies by photographing a bar code on the product they need restocked. Users can securely store their shipping and billing information in the app, edit the quantity, and quickly get more of the supplies they need. Make their lives even easier by tapping into their buying history and providing push notifications for when they are likely running low on a certain supply. You should also include reviews, recommended products, and shipping status notifications for a superior experience.

2.) Event App: Plan on hosting an event this year? Create an event-specific app with exhibit maps, session schedules, speaker bios, and attendee-provided contact information for networking. You can also let people push out messages to Twitter, LinkedIn, and Facebook right from the app.

3.) ROI Calculator: The ROI calculator is a tried and true app for business people who are constantly on the hook for proving ROI. Whatever action you want your prospects to take, an app that lets them quickly calculate the ROI of some aspect of it not only makes them happier, but it also makes your sale easier.

4.) Code Generator: Have an audience that has to do online design during their day job? Create a code generator to make it easier! For example, a marketer who is a novice with HTML might select your HTML code generator to quickly figure out how to code her next email campaign. That's one helpful app that can be used over and over, and spread to a wider audience quickly.

5.) Security Alert App: Are your customers concerned with online security? People in IT security or software can create an app that delivers security alerts when customers experience a security breach. IT departments the world over will love you for it.

6.) Networking App: Use the location-aware capabilities of mobile devices to create an app that lets your prospects and customers find people in their industry with which to network. Couple this with thought leadership content delivered through your app, and you're on your way to becoming the LinkedIn of your industry.

7.) Content Segmenting App: Is your content one of your biggest assets? If you're publishing high volumes of content, create an app that lets your readers select only the topics they want to learn about, and receive updates when you publish something new on that subject.

8.) Software Features App: If you're a software company, make an app that lets people use features of your software on their mobile devices. For example, create an app that alerts your sales team when a new lead needs to be contacted. This way, they can beat your competitors to the punch and make sales even when they're not at their desk!

9.) Calculator App: B2B companies with an audience in a mathematical field can create a calculator app. Provide quick calculations based on frequently used formulas to help them out in their day-to-day job. This will solidify your status as a reliable and helpful resource in your industry and make you a part of their daily lives.

Basic Syntax And First Java Program

First Java Program:

Let us look at a simple code that would print the words Hello World.

public class MyFirstJavaProgram {

   /* This is my first java program.  
    * This will print 'Hello World' as the output
    */

    public static void main(String []args) {
       System.out.println("Hello World"); // prints Hello World
    }
} 

Lets look at how to save the file, compile and run the program. Please follow the steps given below:

• Open notepad and add the code as above.
• Save the file as : MyFirstJavaProgram.java.
• Open a command prompt window and go o the directory where you saved the class. Assume its C:\.
• Type ' javac MyFirstJavaProgram.java ' and press enter to compile your code. If there are no errors in your code the command prompt will take you to the next line.( Assumption : The path variable is set).
Now type ' java MyFirstJavaProgram ' to run your program.

You will be able to see ' Hello World ' printed on the window.

>
C : > javac MyFirstJavaProgram.java
C : > java MyFirstJavaProgram 
Hello World

Basic Syntax:

About Java programs, it is very important to keep in mind the following points.

• Case Sensitivity - Java is case sensitive which means identifier Hello and hello would have different meaning in Java.
• Class Names - For all class names the first letter should be in Upper Case.
  
  If several words are used to form a name of the class each inner words first letter should be in Upper Case.
  
  Example class MyFirstJavaClass
• Method Names - All method names should start with a Lower Case letter.
  
  If several words are used to form the name of the method, then each inner word's first letter should be in Upper Case.
  
  Example public void myMethodName()
• Program File Name - Name of the program file should exactly match the class name.
  
  When saving the file you should save it using the class name (Remember java is case sensitive) and append '.java' to the end of the name. (if the file name and the class name do not match your program will not compile).
  
  Example : Assume 'MyFirstJavaProgram' is the class name. Then the file should be saved as'MyFirstJavaProgram.java'
• public static void main(String args[]) - java program processing starts from the main() method which is a mandatory part of every java program..

Java Identifiers:

All java components require names. Names used for classes, variables and methods are called identifiers.

In java there are several points to remember about identifiers. They are as follows:

• All identifiers should begin with a letter (A to Z or a to z ), currency character ($) or an underscore (-).
• After the first character identifiers can have any combination of characters.
• A key word cannot be used as an identifier.
• Most importantly identifiers are case sensitive.
• Examples of legal identifiers:age, $salary, _value, __1_value
• Examples of illegal identifiers : 123abc, -salary

Java Modifiers:

Like other languages it is possible to modify classes, methods etc by using modifiers. There are two categories of modifiers.

• Access Modifiers : defualt, public , protected, private
• Non-access Modifiers : final, abstract, strictfp

We will be looking into more details about modifiers in the next section.

Java Variables:

We would see following type of variables in Java:

• Local Variables
• Class Variables (Static Variables)
• Instance Variables (Non static variables)

Java Arrays:

Arrays are objects that store multiple variables of the same type. However an Array itself is an object on the heap. We will look into how to declare, construct and initialize in the upcoming chapters.

Java Enums:

Enums were introduced in java 5.0. Enums restrict a variable to have one of only a few predefined values. The values in this enumerated list are called enums.

With the use of enums it is possible to reduce the number of bugs in your code.

For example if we consider an application for a fresh juice shop it would be possible to restrict the glass size to small, medium and Large. This would make sure that it would not allow anyone to order any size other than the small, medium or large.

Example:

class FreshJuice {

   enum FreshJuiceSize{ SMALL, MEDUIM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]){
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice. FreshJuiceSize.MEDUIM ;
   }
}

Note: enums can be declared as their own or inside a class. Methods, variables, constructors can be defined inside enums as well.

Java Keywords:

The following list shows the reserved words in Java. These reserved words may not be used as constant or variable or any other identifier names.

abstract	assert	boolean	break
byte	case	catch	char
class	const	continue	default
do	double	else	enum
extends	final	finally	float
for	goto	if	implements
import	instanceof	int	interface
long	native	new	package
private	protected	public	return
short	static	strictfp	super
switch	synchronized	this	throw
throws	transient	try	void
volatile	while

Comments in Java

Java supports single line and multi-line comments very similar to c and c++. All characters available inside any comment are ignored by Java compiler.

public class MyFirstJavaProgram{

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

    public static void main(String []args){
       // This is an example of single line comment
       /* This is also an example of single line comment. */
       System.out.println("Hello World"); 
    }
} 

Using Blank Lines:

A line containing only whitespace, possibly with a comment, is known as a blank line, and Java totally ignores it.

Inheritance:

In java classes can be derived from classes. Basically if you need to create a new class and here is already a class that has some of the code you require, then it is possible to derive your new class from the already existing code.

This concept allows you to reuse the fields and methods of the existing class with out having to rewrite the code in a new class. In this scenario the existing class is called the super class and the derived class is called the subclass.

Interfaces:

In Java language an interface can be defined as a contract between objects on how to communicate with each other. Interfaces play a vital role when it comes to the concept of inheritance.

An interface defines the methods, a deriving class(subclass) should use. But the implementation of the methods is totally up to the subclass.

Features of JAVA

Hello, Welcome Here ...

1) Compiled and Interpreter:- has both Compiled and Interpreter Feature Program of java is First Compiled and Then it is must to Interpret it .First of all The Program of java is Compiled then after Compilation it creates Bytes Codes rather than Machine Language. Then After Bytes Codes are Converted into the Machine Language is Converted into the Machine Language with the help of the Interpreter So For Executing the java Program First of all it is necessary to Compile it then it must be Interpreter

2) Platform Independent:- Java Language is Platform Independent means program of java is Easily transferable because after Compilation of java program bytes code will be created then we have to just transfer the Code of Byte Code to another Computer. This is not necessary for computers having same Operating System in which the code of the java is Created and Executed After Compilation of the Java Program We easily Convert the Program of the java top the another Computer for Execution.

3) Object-Oriented:- We Know that is purely OOP Language that is all the Code of the java Language is Written into the classes and Objects So For This feature java is Most Popular Language because it also Supports Code Reusability, Maintainability etc.

4) Robust and Secure:- The Code of java is Robust andMeans ot first checks the reliability of the code before Execution When We trying to Convert the Higher data type into the Lower Then it Checks the Demotion of the Code the It Will Warns a User to Not to do this So it is called as Robust Secure : When We convert the Code from One Machine to Another the First Check the Code either it is Effected by the Virus or not or it Checks the Safety of the Code if code contains the Virus then it will never Executed that code on to the Machine.

5) Distributed:- Java is Distributed Language Means because the program of java is compiled onto one machine can be easily transferred to machine and Executes them on another machine because facility of Bytes Codes So java is Specially designed For Internet Users which uses the Remote Computers For Executing their Programs on local machine after transferring the Programs from Remote Computers or either from the internet.

6) Simple Small and Familiar:- is a simple Language Because it contains many features of other Languages like c and C++ and Java Removes Complexity because it doesn’t use pointers, Storage Classes and Go to Statements and java Doesn’t support Multiple Inheritance

7) Multithreaded and Interactive:- Java uses Multithreaded Techniques For Execution Means Like in other in Structure Languages Code is Divided into the Small Parts Like These Code of java is divided into the Smaller parts those are Executed by java in Sequence and Timing Manner this is Called as Multithreaded In this Program of java is divided into the Small parts those are Executed by Compiler of java itself Java is Called as Interactive because Code of java Supports Also CUI and Also GUI Programs

8) Dynamic and Extensible Code:- Java has Dynamic and Extensible Code Means With the Help of OOPS java Provides Inheritance and With the Help of Inheritance we Reuse the Code that is Pre-defined and Also uses all the built in Functions of java and Classes

9) Distributed:- Java is a distributed language which means that the program can be design to run on computer networks. Java provides an extensive library of classes for communicating ,using TCP/IP protocols such as HTTP and FTP. This makes creating network connections much easier than in C/C++. You can read and write objects on the remote sites via URL with the same ease that programmers are used to when read and write data from and to a file. This helps the programmers at remote locations to work together on the same project.

10) Secure: Java was designed with security in mind. As Java is intended to be used in networked/distributor environments so it implements several security mechanisms to protect you against malicious code that might try to invade your file system.

For example: The absence of pointers in Java makes it impossible for applications to gain access to memory locations without proper authorization as memory allocation and referencing model is completely opaque to the programmer and controlled entirely by the underlying run-time platform .

11) Architectural Neutral: One of the key feature of Java that makes it different from other programming languages is architectural neutral (or platform independent). This means that the programs written on one platform can run on any other platform without having to rewrite or recompile them. In other words, it follows 'Write-once-run-anywhere' approach.

Java programs are compiled into byte-code format which does not depend on any machine architecture but can be easily translated into a specific machine by a Java Virtual Machine (JVM) for that machine. This is a significant advantage when developing applets or applications that are downloaded from the Internet and are needed to run on different systems.

12) Portable : The portability actually comes from architecture-neutrality. In C/C++, source code may run slightly differently on different hardware platforms because of how these platforms implement arithmetic operations. In Java, it has been simplified.

Unlike C/C++, in Java the size of the primitive data types are machine independent. For example, an int in Java is always a 32-bit integer, and float is always a 32-bit IEEE 754 floating point number. These consistencies make Java programs portable among different platforms such as Windows, Unix and Mac . 13) Interpreted : Unlike most of the programming languages which are either complied or interpreted, Java is both complied and interpreted The Java compiler translates a java source file to bytecodes and the Java interpreter executes the translated byte codes directly on the system that implements the Java Virtual Machine. These two steps of compilation and interpretation allow extensive code checking and improved security .

14) High performance: Java programs are complied to portable intermediate form know as bytecodes, rather than to native machine level instructions and JVM executes Java bytecode on. Any machine on which it is installed. This architecture means that Java programs are faster than program or scripts written in purely interpreted languages but slower than C and C++ programs that compiled to native machine languages.

Although in the early releases of Java, the interpretation of by bytecode resulted in slow performance but the advance version of JVM uses the adaptive and Just in time (JIT) compilation technique that improves performance by converting Java bytecodes to native machine instructions on the fly.