Chat Screens

create class name ChatInvitationDialogActivity

import java.util.ArrayList;
import java.util.List;

import org.apache.http.Header;
import org.apache.http.message.BasicHeader;
import org.jivesoftware.smack.packet.Message;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

import com.easychat.constant.Global;
import com.easychat.data.UserInfoChat;
import com.easychat.parsedata.SendChatInvitation;
import com.easychat.rinterface.ResponseListener;
import com.easychat.task.HttpDeleteAsync;
import com.easychat.task.HttpPostAsync;
import com.easychat.utility.AroundLogger;
import com.easychat.utility.Utility;
import com.easychat.xmpp.XmppClient;
import com.google.gson.Gson;

public class ChatInvitationDialogActivity extends DialogActivity implements OnClickListener {

private static final String TAG = "ChatInvitationDialogActivity";

Context mContext;

//Widget
Button btnAccept, btnDecline;
TextView tvTitle, tvMessage;

// String sender;
String ownId;
// String status;
// String senderId;

UserInfoChat infoChat;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.chatinvitationdialog);

mContext = this;

// sender = getIntent().getStringExtra("sender");
// userId = getIntent().getStringExtra("userid");
// status = getIntent().getStringExtra("status");
// senderId = getIntent().getStringExtra("senderid");

bindComponents();
init();
addListeners();
}


private void bindComponents(){
btnAccept = (Button) findViewById(R.id.btnAccept);
btnDecline = (Button) findViewById(R.id.btnDecline);
tvTitle = (TextView)findViewById(R.id.tvTitle);
tvMessage = (TextView)findViewById(R.id.tvMessage);
}

private void init(){
infoChat = (UserInfoChat) getIntent().getSerializableExtra("userinfo");
ownId = Utility.getSharedKey("userid", this);

tvMessage.setText(String.format(getString(R.string.chatdialog_message), infoChat.sender));
}

private void addListeners(){
btnAccept.setOnClickListener(this);
btnDecline.setOnClickListener(this);
}

@Override
public void onClick(View v) {
switch(v.getId()){
case R.id.btnAccept:
approveFriendRequest(ownId, infoChat.userid);
// approveFriendRequest(senderId, userId);
return;

case R.id.btnDecline:
delineFriendRequest(ownId, infoChat.userid);
// delineFriendRequest(senderId, userId);
return;
}
}


private void approveInvitationUsingXmpp() {
UserInfoChat userInfoChat = new UserInfoChat();
// userInfoChat.status = status;


/**
* Set current login user's id as a userid
*/
userInfoChat.userid = ownId;
// userInfoChat.senderId = senderId;

Message message = new Message(Global.getReceiver(infoChat.sender), Message.Type.chat);
message.setFrom(Utility.getSharedKey("username", mContext));
message.setBody(Global.TYPE_INVITATION_ACCEPT);
// message.setProperty("userid", userId);
// message.setProperty("status", status);
message.setProperty("userinfo", userInfoChat);
XmppClient.sendMessage(this, message);
}

private void declineInvitationUsingXmpp() {
UserInfoChat userInfoChat1 = new UserInfoChat();
// userInfoChat1.status = status;
userInfoChat1.userid = ownId;
// userInfoChat1.senderId = senderId;

Message message1 = new Message( Global.getReceiver(infoChat.sender), Message.Type.chat);
message1.setFrom(Utility.getSharedKey("username", mContext));
message1.setBody(Global.TYPE_INVITATION_DECLINE);
// message1.setProperty("userid", userId);
// message1.setProperty("status", status);
message1.setProperty("userinfo", userInfoChat1);

XmppClient.sendMessage(this, message1);
}

private void approveFriendRequest(String userId, String requestId) {
AroundLogger.info(TAG + " ApproveFriendRequest   called---");
String token = Utility.getSharedKey("token", this);
List<Header> lstHeader = new ArrayList<Header>();
lstHeader.add(new BasicHeader("X-Apn-Authorization", token));

HttpPostAsync post = new HttpPostAsync(this);
post.setHeader(lstHeader);
post.isProgressBarEnabled(true);

post.setResponseListener(new ResponseListener() {
@Override
public void responseListener(String response) {
AroundLogger.info(TAG + "responseListener - response: " + response);
if(!TextUtils.isEmpty(response)) {

Gson mGson = new Gson();
SendChatInvitation mChatInvitation = mGson.fromJson(response, SendChatInvitation.class);
if(mChatInvitation == null || !TextUtils.isEmpty(mChatInvitation.error)) {
Utility.showToast(mChatInvitation.error, mContext);

}else {
approveInvitationUsingXmpp();
Intent chatintent = new Intent(mContext, ChatListAct.class);
chatintent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
chatintent.putExtra("userid", infoChat.userid);
chatintent.putExtra("username", infoChat.sender);
startActivity(chatintent);
}

finish();
}
}
});
String StrUrl = Global.HOST + "users/" + userId + "/requests/" + requestId;
post.execute(StrUrl, null);

}

private void delineFriendRequest(String userId, String requestId) {
AroundLogger.info(TAG + " delineFriendRequest   called---");
String token = Utility.getSharedKey("token", this);
List<Header> lstHeader = new ArrayList<Header>();
lstHeader.add(new BasicHeader("X-Apn-Authorization", token));

HttpDeleteAsync delete = new HttpDeleteAsync(mContext);
delete.setHeader(lstHeader);
delete.isProgressBarEnabled(true);

delete.setResponseListener(new ResponseListener() {
@Override
public void responseListener(String response) {
AroundLogger.info(TAG + "responseListener - response: " + response);
if(!TextUtils.isEmpty(response)) {
Gson mGson = new Gson();
SendChatInvitation mChatInvitation = mGson.fromJson(response, SendChatInvitation.class);

if(mChatInvitation == null || !TextUtils.isEmpty(mChatInvitation.error)) {
Utility.showToast(mChatInvitation.error, mContext);

}else {
declineInvitationUsingXmpp();
}

finish();
}
}
});
String StrUrl = Global.HOST + "users/" + userId + "/requests/" + requestId;
delete.execute(StrUrl);

}

@Override
public void onBackPressed() {

}


}

cretae class name UserInfoChat

import java.io.Serializable;

public class UserInfoChat implements Serializable{

/**

* 

*/

private static final long serialVersionUID = 1L;

public String userid;

// public String status;

// public String senderId;

public String sender;

}

create class name DialogActivity

import android.app.Activity;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.os.Bundle;

import android.util.Log;

import com.easychat.constant.Global;

public class DialogActivity extends Activity{

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

IntentFilter intentFilter = new IntentFilter();

intentFilter.addAction(Global.ACTION_LOGOUT);

registerReceiver(mBroadcastReceiver, intentFilter);

}

BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

Log.d("onReceive","Logout in progress");

finish();

}

};

@Override

protected void onDestroy() {

super.onDestroy();

unregisterReceiver(mBroadcastReceiver);

}

}

create class name ChatListAct

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.List;

import java.util.Map;

import org.apache.http.Header;

import org.apache.http.NameValuePair;

import org.apache.http.message.BasicHeader;

import org.apache.http.message.BasicNameValuePair;

import org.jivesoftware.smack.packet.Message;

import org.jivesoftware.smack.util.StringUtils;

import android.content.Context;

import android.os.Bundle;

import android.text.TextUtils;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.View.OnFocusChangeListener;

import android.view.ViewGroup;

import android.view.inputmethod.InputMethodManager;

import android.widget.BaseAdapter;

import android.widget.Button;

import android.widget.EditText;

import android.widget.HorizontalScrollView;

import android.widget.ImageButton;

import android.widget.ImageView;

import android.widget.ListView;

import android.widget.TextView;

import com.easychat.constant.Global;

import com.easychat.data.ChatInfo;

import com.easychat.data.UserInfoChat;

import com.easychat.mlisteners.ChatReceiver;

import com.easychat.parsedata.History;

import com.easychat.parsedata.HistoryallData;

import com.easychat.parsedata.HistoryallListData;

import com.easychat.parsedata.Userdata;

import com.easychat.quickactionbar.ActionItem;

import com.easychat.quickactionbar.QuickAction;

import com.easychat.rinterface.ResponseListener;

import com.easychat.task.HttpGetAsync;

import com.easychat.task.HttpPostAsync;

import com.easychat.utility.AroundLogger;

import com.easychat.utility.Utility;

import com.easychat.xmpp.XmppClient;

import com.google.gson.Gson;

import com.koushikdutta.urlimageviewhelper.UrlImageViewHelper;

public class ChatListAct extends Default implements OnClickListener, ChatReceiver {

private static final String TAG = "UserlistAct-";

//Widgets

EditText cedtchat;

Button cbtnsend;

ListView lvwUserlist;

TextView tvUsername;

ImageView ivStatus;

ImageButton imgbtnSmiley;

static HorizontalScrollView hScrollFooter;

ChatListAdapter mAdapter;

String username;

String ownId;

String userId;

String token;

String ownUsername;

public static String userProfileImage;

public static String ownProfileImage;

QuickAction quickAction;

HistoryallListData historyparselist;

List<HistoryallData> historylist;

ArrayList<ChatInfo> chatList;

Context mContext;

// XmppService mXmppService;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState, R.layout.chatlist);

mContext = this;

bindComponents();

init();

addListeners();

}

private void bindComponents() {

AroundLogger.info(TAG + " bindComponents-");

lvwUserlist = (ListView) findViewById(R.id.clistchat);

hScrollFooter = (HorizontalScrollView) findViewById(R.id.hscrollview);

cedtchat = (EditText)findViewById(R.id.cedtchat);

cbtnsend = (Button)findViewById(R.id.cbtnsend);

tvUsername = (TextView) findViewById(R.id.tvUsername);

ivStatus = (ImageView) findViewById(R.id.ivStatus);

imgbtnSmiley = (ImageButton)findViewById(R.id.imgbtnSmiley);

}

private void init() {

AroundLogger.info(TAG + " init-");

chatList = new ArrayList<ChatInfo>();

mAdapter = new ChatListAdapter();

hScrollFooter.setVisibility(View.GONE);

lvwUserlist.setFocusable(false);

lvwUserlist.setFocusableInTouchMode(false);

lvwUserlist.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL);

lvwUserlist.setStackFromBottom(true);

lvwUserlist.setAdapter(mAdapter);

ownUsername = Utility.getSharedKey("username", this);

username = getIntent().getStringExtra("username");

userId = getIntent().getStringExtra("userid");

ownId = Utility.getSharedKey("userid", this);

if(BuildConfig.DEBUG) {

AroundLogger.info(TAG + " init - userId=" + userId + " ownId=" + ownId);

}

GetUserInfo(userId, false);

GetUserInfo(ownId, true);

if(getIntent().getBooleanExtra("fromhistory", false)) {

AllchatHistory();

}

/*mAdapter = new ChatListAdapter(this, new ArrayList<ChatInfo>());

lvwUserlist.setAdapter(mAdapter);

lvwUserlist.setDivider(null);

lvwUserlist.setDividerHeight(0);*/

// userid = getIntent().getStringExtra("userid");

// status = getIntent().getStringExtra("status");

// sender_id = getIntent().getStringExtra("userid");

// Log.i(Global.TAG, "init - Status--->: "+status);

/*if(!TextUtils.isEmpty(status)) {

if (status.equalsIgnoreCase(getResources().getString(R.string.S_online))) {

ivStatus.setImageResource(R.drawable.green);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.S_busy))) {

ivStatus.setImageResource(R.drawable.orange);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.S_do_not_disturb))) {

ivStatus.setImageResource(R.drawable.grey);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.S_Offline))) {

ivStatus.setImageResource(R.drawable.red);

}

}*/

String text = getIntent().getStringExtra("message");

if(!TextUtils.isEmpty(text)) {

ChatInfo mChatInfo = new ChatInfo();

mChatInfo.setComment(text);

mChatInfo.setReceiver(ownUsername);

mChatInfo.setSender(username);

mChatInfo.setTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

chatList.add(mChatInfo);

notifyAdapter();

// mAdapter.add(mChatInfo);

/*Message message = new Message(ownUsername, Message.Type.chat);

message.setFrom(username);

message.setBody(text);

mAdapter.add(message);*/

}

tvUsername.setText(username);

setUpSmiles();

cedtchat.setOnFocusChangeListener(new OnFocusChangeListener() {

@Override

public void onFocusChange(View v, boolean hasFocus) {

cedtchat.setText(Global.getSmiledText(ChatListAct.this, cedtchat.getText().toString()));

}

});

}

private void addListeners() {

AroundLogger.info(TAG + " addListeners-");

imgbtn_back.setOnClickListener(this);

cbtnsend.setOnClickListener(this);

imgbtnSmiley.setOnClickListener(this);

}

@Override

public void onClick(View v) {

super.onClick(v);

switch (v.getId()) {

case R.id.imgbtn_back:

finish();

break;

case R.id.cbtnsend:

InputMethodManager imm = (InputMethodManager)getSystemService(

     Context.INPUT_METHOD_SERVICE);

imm.hideSoftInputFromWindow(cedtchat.getWindowToken(), 0);

String comment = cedtchat.getText().toString();

if(comment.trim().length() == 0) {

return;

}

cedtchat.setText("");

UserInfoChat mInfoChat = new UserInfoChat();

// mInfoChat.senderId = sender_id;

mInfoChat.userid = ownId;

Message message = new Message( Global.getReceiver(username), Message.Type.chat);

message.setFrom(Utility.getSharedKey("username", v.getContext()));

// message.setProperty("userid", userId);

message.setProperty("userinfo", mInfoChat);

message.setBody(comment);

XmppClient.sendMessage(this, message);

mAdapter.add(message);

notifyAdapter();

PostChat(comment);

break;

case R.id.imgbtnSmiley:

quickAction.show(v);

break;

default:

break;

}

}

@Override

public void receive(Message message) {

if(mAdapter != null) {

mAdapter.add(message);

notifyAdapter();

}

}

private void notifyAdapter() {

runOnUiThread(new Runnable() {

@Override

public void run() {

mAdapter.notifyDataSetChanged();

}

});

}

@Override

protected void onStart() {

super.onStart();

XmppClient.setCurrentChatListener(username, this);

// XmppClient.addChatReceiver(this);

}

@Override

protected void onStop() {

super.onStop();

XmppClient.removeCurrentChatListener();

// XmppClient.removeChatReceiver(this);

}

public void PostChat(String content) {

AroundLogger.info(TAG + "Post Chat is called---");

String token = Utility.getSharedKey("token", this);

List<Header> lstHeader = new ArrayList<Header>();

lstHeader.add(new BasicHeader("X-Apn-Authorization", token));

List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();

nameValuePairs.add(new BasicNameValuePair("receiver_id", userId));

nameValuePairs.add(new BasicNameValuePair("content", content));

HttpPostAsync post = new HttpPostAsync(this);

post.isProgressBarEnabled(false);

post.setHeader(lstHeader);

post.setResponseListener(new ResponseListener() {

@Override

public void responseListener(String response) {

AroundLogger.info(TAG + "responseListener - response: " + response);

}

});

String StrUrl = Global.HOST + "chatHistory";

post.execute(StrUrl, nameValuePairs);

}

private void setUpSmiles() {

quickAction = new QuickAction(this, QuickAction.VERTICAL);

addActionItem(R.drawable.wink_,  ";)");

addActionItem(R.drawable.smile,  ":-)");

addActionItem(R.drawable.grin_,  ":D");

addActionItem(R.drawable.grumpy,  ">:c");

addActionItem(R.drawable.sunglasses,  "8-)");

addActionItem(R.drawable.gasp,  ":-o");

addActionItem(R.drawable.upset,  ">.<");

addActionItem(R.drawable.cry,  ":'c");

addActionItem(R.drawable.sad,  ":(");

addActionItem(R.drawable.the_softy,  ":'c");

addActionItem(R.drawable.the_sketchbag,  "x-c");

//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);

cedtchat.setText(Global.getSmiledText(ChatListAct.this, cedtchat.getText() + actionItem.getSmileyName()));

cedtchat.setSelection(cedtchat.getText().length());

}

});

}

private void addActionItem(int drawable, String text) {

ActionItem actionItem = new ActionItem(drawable, null, getResources().getDrawable(drawable), text);

quickAction.addActionItem(actionItem);

}

public void AllchatHistory()

{

AroundLogger.info(TAG + "AllChatHistory is called-----");

token = Utility.getSharedKey("token",ChatListAct.this);

List<Header> lstHeader = new ArrayList<Header>();

lstHeader.add(new BasicHeader("X-Apn-Authorization",token));

HttpGetAsync get = new HttpGetAsync(mContext);

get.setHeader(lstHeader);

get.setResponseListener(new ResponseListener() { 

@Override

public void responseListener(String response) {

AroundLogger.info(TAG + "responseListener - response: " + response);

if(!response.equalsIgnoreCase("")) {

Gson gson = new Gson();

historyparselist = gson.fromJson(response, HistoryallListData.class);

Map<Integer, History> mHashMap = historyparselist.historyList;

for (Integer key : mHashMap.keySet()) {

History mHistories = mHashMap.get(key);

ChatInfo  chat= new ChatInfo();

chat.setSender(mHistories.sender);

chat.setReceiver(mHistories.receiver);

chat.setComment(mHistories.content);

chat.setTime(mHistories.time);

chatList.add(chat);

notifyAdapter();

}

/* historylist =  historyparselist.historylist;

HistoryallData  historydata;

for(int i=0;i<historylist.size();i++)

{

ChatInfo  chat= new ChatInfo();

historydata=historylist.get(i);

chat.setSender(historydata.senderusername);

chat.setReceiver(ownUsername);

chat.setComment(historydata.content);

chat.setTime(historydata.createdate);

chatList.add(chat);

notifyAdapter();

}

*/

Collections.sort(chatList, mComparator);

notifyAdapter();

}

}

});

String StrUrl = Global.HOST+"chatHistory/" + userId;

get.execute(StrUrl);

}

Comparator<ChatInfo> mComparator = new Comparator<ChatInfo>() {

@Override

public int compare(ChatInfo lhs, ChatInfo rhs) {

return lhs.getTime().compareTo(rhs.getTime());

}

};

public void GetUserInfo(String uId, final boolean isOwnProfile) {

AroundLogger.info(TAG + "GetUser info is called---");

token = Utility.getSharedKey("token", this);

List<Header> lstHeader = new ArrayList<Header>();

lstHeader.add(new BasicHeader("X-Apn-Authorization", token));

AroundLogger.info(TAG + "User Info  called---");

HttpGetAsync get = new HttpGetAsync(this);

get.setHeader(lstHeader);

get.setResponseListener(new ResponseListener() {

@Override

public void responseListener(String response) {

AroundLogger.info(TAG + "responseListener - response: " + response);

if(!TextUtils.isEmpty(response)) {

try {

Gson gson = new Gson();

Userdata userprofiledata = gson.fromJson(response,Userdata.class);

if(!isOwnProfile) {

String status = userprofiledata.status;

AroundLogger.info(TAG + "responseListener - Status--->: "+status);

if (status.equalsIgnoreCase(getResources().getString(R.string.S_online))) {

ivStatus.setImageResource(R.drawable.green);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.S_busy))) {

ivStatus.setImageResource(R.drawable.orange);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.dnd))) {

ivStatus.setImageResource(R.drawable.grey);

} else if (status.equalsIgnoreCase(getResources().getString(R.string.S_Offline))) {

ivStatus.setImageResource(R.drawable.red);

}

userProfileImage = userprofiledata.thumbnail_url;

tvUsername.setText(Global.getDisplayName(userprofiledata.nickname, userprofiledata.firstname, userprofiledata.lname, userprofiledata.username));

}else {

ownProfileImage = userprofiledata.thumbnail_url;

}

} catch (Exception e) {

// TODO: handle exception

AroundLogger.info(TAG + "catch clause....");

}

}

}

});

AroundLogger.info(TAG + "GetUserInfo - ");

String StrUrl = Global.HOST + "users/" + uId;

get.execute(StrUrl);

}

public class ChatListAdapter extends BaseAdapter{

String receiver;

SimpleDateFormat mDateFormat;

SimpleDateFormat mDateFormat2;

public ChatListAdapter() {

receiver = Utility.getSharedKey("username", ChatListAct.this);

chatList = new ArrayList<ChatInfo>();

mDateFormat = new SimpleDateFormat("dd-MM-yyyy hh:mm aa");

mDateFormat2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

}

public void add(ChatInfo mChatInfo) {

chatList.add(mChatInfo);

// notifyDataSetChanged();

}

public void add(Message message) {

ChatInfo mChatInfo = new ChatInfo();

if(message.getFrom().contains("@")) {

mChatInfo.setSender(StringUtils.parseName(message.getFrom()));

}else {

mChatInfo.setSender(message.getFrom());

}

mChatInfo.setReceiver(receiver);

mChatInfo.setComment(message.getBody());

mChatInfo.setTime(mDateFormat2.format(new Date()));

chatList.add(mChatInfo);

// notifyDataSetChanged();

}

@Override

public int getCount() {

return chatList.size();

}

@Override

public Object getItem(int position) {

return chatList.get(position);

}

@Override

public long getItemId(int position) {

return position;

}

@Override

public int getViewTypeCount() {

return 2;

}

@Override

public View getView(int position, View convertView, ViewGroup parent) {

ChatInfo mChatInfo = chatList.get(position);

if(mChatInfo.getSender() == null || mChatInfo.getSender().equalsIgnoreCase(receiver)) {

convertView = getLayoutInflater().inflate(R.layout.chatlist_row_own, null);

}else {

convertView = getLayoutInflater().inflate(R.layout.chatlist_row_user, null);

}

TextView tvUsername = (TextView) convertView.findViewById(R.id.tvUsername);

ImageView userimage = (ImageView) convertView.findViewById(R.id.ivwuser);

if(mChatInfo.getSender() == null || mChatInfo.getSender().equalsIgnoreCase(receiver)) {

UrlImageViewHelper.setUrlDrawable(userimage, ChatListAct.ownProfileImage, R.drawable.no_image);

tvUsername.setText("Me");

}else {

UrlImageViewHelper.setUrlDrawable(userimage, ChatListAct.userProfileImage, R.drawable.no_image);

tvUsername.setText(mChatInfo.getSender());

}

TextView mView = (TextView)convertView.findViewById(R.id.tvComment);

mView.setText(Global.getSmiledText(mContext, mChatInfo.getComment()));

TextView tvChatTime = (TextView) convertView.findViewById(R.id.tvChatTime);

try {

tvChatTime.setText((mDateFormat.format(mDateFormat2.parse(mChatInfo.getTime()))));

} catch (ParseException e) {

e.printStackTrace();

}

return convertView;

}

}

}

create class name ChatListAdapter

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import org.jivesoftware.smack.packet.Message;

import org.jivesoftware.smack.util.StringUtils;

import android.app.Activity;

import android.content.Context;

import android.view.View;

import android.view.ViewGroup;

import android.widget.BaseAdapter;

import android.widget.TextView;

import com.easychat.app.R;

import com.easychat.constant.Global;

import com.easychat.data.ChatInfo;

import com.easychat.utility.Utility;

public class ChatListAdapter extends BaseAdapter{

ArrayList <ChatInfo> list;

Context mContext;

String receiver;

SimpleDateFormat mDateFormat;

public ChatListAdapter(Context context, ArrayList<ChatInfo> mList) {

this.mContext = context;

receiver = Utility.getSharedKey("username", context);

list = new ArrayList<ChatInfo>();

list = mList;

mDateFormat = new SimpleDateFormat("HH:mm aa");

}

public void add(ChatInfo mChatInfo) {

list.add(mChatInfo);

// notifyDataSetChanged();

}

public void add(Message message) {

ChatInfo mChatInfo = new ChatInfo();

if(message.getFrom().contains("@")) {

mChatInfo.setSender(StringUtils.parseName(message.getFrom()));

}else {

mChatInfo.setSender(message.getFrom());

}

mChatInfo.setReceiver(receiver);

mChatInfo.setComment(message.getBody());

mChatInfo.setTime(mDateFormat.format(new Date()));

list.add(mChatInfo);

// notifyDataSetChanged();

}

@Override

public int getCount() {

return list.size();

}

@Override

public Object getItem(int position) {

return list.get(position);

}

@Override

public long getItemId(int position) {

return position;

}

@Override

public View getView(int position, View convertView, ViewGroup parent) {

ChatInfo mChatInfo = list.get(position);

if(mChatInfo.getSender() == null || mChatInfo.getSender().equals(receiver)) {

convertView = ((Activity)mContext).getLayoutInflater().inflate(R.layout.chatlist_row_own, null);

}else {

convertView = ((Activity)mContext).getLayoutInflater().inflate(R.layout.chatlist_row_user, null);

}

if(mChatInfo.getSender() == null || mChatInfo.getSender().equals(receiver)) {

}else {

}

TextView mView = (TextView)convertView.findViewById(R.id.tvComment);

mView.setText(Global.getSmiledText(mContext, mChatInfo.getComment()));

TextView tvUsername = (TextView) convertView.findViewById(R.id.tvUsername);

tvUsername.setText(mChatInfo.getSender());

TextView tvChatTime = (TextView) convertView.findViewById(R.id.tvChatTime);

tvChatTime.setText((mChatInfo.getTime()));

return convertView;

}

}

create class name QuickAction

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.graphics.Rect;

import android.graphics.drawable.Drawable;

import android.view.Gravity;

import android.view.LayoutInflater;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.ViewGroup;

import android.view.ViewGroup.LayoutParams;

import android.widget.ImageView;

import android.widget.PopupWindow.OnDismissListener;

import android.widget.RelativeLayout;

import android.widget.ScrollView;

import android.widget.TextView;

import com.easychat.app.R;

/**

 * QuickAction dialog, shows action list as icon and text like the one in Gallery3D app. Currently supports vertical 

 * and horizontal layout.

 * 

 * @author Lorensius W. L. T <lorenz@londatiga.net>

 * 

 * Contributors:

 * - Kevin Peck <kevinwpeck@gmail.com>

 */

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 class name PopupWindows

import android.content.Context;

import android.graphics.drawable.BitmapDrawable;

import android.graphics.drawable.Drawable;

import android.view.LayoutInflater;

import android.view.MotionEvent;

import android.view.View;

import android.view.View.OnTouchListener;

import android.view.WindowManager;

import android.widget.PopupWindow;

/**

 * Custom popup window.

 * 

 * @author Lorensius W. L. T <lorenz@londatiga.net>

 *

 */

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();

}

}

create class name HistoryallListData

import java.io.Serializable;

import java.util.Map;

import com.google.gson.annotations.SerializedName;

public class HistoryallListData implements Serializable{

/**

* 

*/

private static final long serialVersionUID = 5319370330373259907L;

@SerializedName("chat_user_data")

public HistoryallData historyData;

@SerializedName("history")

public Map<Integer, History> historyList;

}

cretae class name ChatInfo

public class ChatInfo {

String sender;

String receiver;

String comment;

String image;

String time;

public String getTime() {

return time;

}

public void setTime(String time) {

this.time = time;

}

public String getSender() {

return sender;

}

public void setSender(String sender) {

this.sender = sender;

}

public String getReceiver() {

return receiver;

}

public void setReceiver(String receiver) {

this.receiver = receiver;

}

public String getComment() {

return comment;

}

public void setComment(String comment) {

this.comment = comment;

}

public String getImage() {

return image;

}

public void setImage(String image) {

this.image = image;

}

}

create class name HttpPostAsync

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.apache.http.Header;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.StatusLine;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.HttpResponseException;

import org.apache.http.client.ResponseHandler;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.entity.mime.HttpMultipartMode;

import org.apache.http.entity.mime.MultipartEntity;

import org.apache.http.entity.mime.content.ContentBody;

import org.apache.http.entity.mime.content.FileBody;

import org.apache.http.entity.mime.content.StringBody;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.util.EntityUtils;

import android.app.Activity;

import android.app.ProgressDialog;

import android.content.Context;

import android.os.AsyncTask;

import com.easychat.app.R;

import com.easychat.rinterface.ResponseListener;

import com.easychat.utility.AroundLogger;

import com.easychat.utility.Utility;

public class HttpPostAsync extends AsyncTask<Object, Object, Object> {

private static final String TAG = "HttpGetAsync - ";

Context mContext;

ProgressDialog progress;

ResponseListener mListener;

boolean mIsProgress = true;

int responseCode;

String message;

List<Header> mHeader = null;

String mFilePath = "";

public HttpPostAsync(Context context) {

AroundLogger.info(TAG + "HttpGetAsync - ");

mContext = context;

}

public void setResponseListener(ResponseListener listener) {

AroundLogger.info(TAG + "setResponseListener - ");

mListener = listener;

}

public void isProgressBarEnabled(boolean isProgress) {

mIsProgress = isProgress;

}

public void setHeader(List<Header> header) {

mHeader = header;

}

public void setFilePath(String filePath){

mFilePath = filePath;

}

@Override

protected void onPreExecute() {

AroundLogger.info(TAG + "onPreExecute - ");

if (mIsProgress) {

progress = new ProgressDialog(mContext);

progress.show();

progress.setContentView(R.layout.custom_progress);

}

}

@Override

protected Object doInBackground(Object... params) {

String response = "";

String strUrl = (String) params[0];

if(Utility.isNetworkAvailable(mContext)){

}

AroundLogger.info(TAG + "doInBackground - strUrl:" + strUrl);

@SuppressWarnings("unchecked")

List<NameValuePair> nameValuePair = (ArrayList<NameValuePair>) params[1];

AroundLogger.info(TAG + "doInBackground - nameValuePair:" + nameValuePair);

String filepath = mFilePath;

HttpClient httpClient = new DefaultHttpClient();

HttpPost httpPost = new HttpPost(strUrl);

if (mHeader != null) {

for (Header header : mHeader) {

httpPost.addHeader(header);

}

}

try {

MultipartEntity entity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);

if (nameValuePair != null) {

ContentBody cb;

for(NameValuePair value: nameValuePair){

cb =  new StringBody(value.getValue(),"", null);

entity.addPart(value.getName(), cb);

}

}

if(filepath != null && filepath.length() > 0){

File f = new File(filepath);

entity.addPart("uploadedfile", new FileBody(f));

}

httpPost.setEntity(entity);

HttpResponse httpResponse = httpClient.execute(httpPost);

response = EntityUtils.toString(httpResponse.getEntity());

} catch (ClientProtocolException e) {

e.printStackTrace();

//Display();

} catch (IOException e) {

e.printStackTrace();

//Display();

}

if (mIsProgress)

progress.dismiss();

return response;

}

@Override

protected void onPostExecute(Object response) {

AroundLogger.info(TAG + "onPostExecute - response: " + response);

mListener.responseListener((String) response);

}

ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

public String handleResponse(final HttpResponse response)

throws HttpResponseException, IOException {

StatusLine statusLine = response.getStatusLine();

if (statusLine.getStatusCode() >= 300) {

throw new HttpResponseException(statusLine.getStatusCode(),

statusLine.getReasonPhrase());

}

HttpEntity entity = response.getEntity();

AroundLogger.info(TAG + "doInBackground - entity: " + entity);

byte[] b = EntityUtils.toByteArray(entity);

return new String(b, "windows-1252");

// return entity == null ? null : EntityUtils.toString(entity);

}

};

public void Display()

{

((Activity)mContext).runOnUiThread(new Runnable() {

@Override

public void run() {

Utility.showToast("Internet Not Available..!", mContext);

}

});

}

}

create class name HttpDeleteAsync

import java.io.IOException;

import java.util.List;

import org.apache.http.Header;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.ParseException;

import org.apache.http.StatusLine;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.HttpResponseException;

import org.apache.http.client.ResponseHandler;

import org.apache.http.client.methods.HttpDelete;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.util.EntityUtils;

import android.app.ProgressDialog;

import android.content.Context;

import android.content.Intent;

import android.os.AsyncTask;

import com.easychat.app.R;

import com.easychat.constant.Global;

import com.easychat.rinterface.ResponseListener;

import com.easychat.utility.AroundLogger;

import com.easychat.utility.Utility;

public class HttpDeleteAsync extends AsyncTask<Object, Object, Object> {

private static final String TAG = "HttpDeleteAsync - ";

Context mContext;

ProgressDialog progress;

ResponseListener mListener;

boolean mIsProgress = true;

int responseCode;

String message;

List<Header> mHeader = null;

public HttpDeleteAsync(Context context) {

AroundLogger.info(TAG + "HttpGetAsync - ");

mContext = context;

}

public void setResponseListener(ResponseListener listener) {

AroundLogger.info(TAG + "setResponseListener - ");

mListener = listener;

}

public void isProgressBarEnabled(boolean isProgress) {

mIsProgress = isProgress;

}

public void setHeader(List<Header> header) {

mHeader = header;

}

@Override

protected void onPreExecute() {

AroundLogger.info(TAG + "onPreExecute - ");

if (mIsProgress) {

progress = new ProgressDialog(mContext);

progress.show();

progress.setContentView(R.layout.custom_progress);

}

}

@Override

protected Object doInBackground(Object... params) {

AroundLogger.info(TAG + "doInBackground - ");

String response = "";

String strUrl = (String) params[0];

if(Utility.isNetworkAvailable(mContext)){

AroundLogger.info(TAG + "doInBackground - url: " + strUrl);

HttpClient client = new DefaultHttpClient();

HttpDelete delete = new HttpDelete(strUrl);

if(mHeader != null){

for(Header header: mHeader){

delete.addHeader(header);

}

}

delete.addHeader("Content-Type", "application/json");

HttpResponse hresponse = null;

try {

hresponse = client.execute(delete);

} catch (ClientProtocolException e) {

AroundLogger.info(TAG + "doInBackground - ClientProtocolException - Error:" + e.getMessage());

e.printStackTrace();

} catch (IOException e) {

AroundLogger.info(TAG + "doInBackground - IOException - Error:" + e.getMessage());

e.printStackTrace();

}

HttpEntity resentity = hresponse.getEntity();

try {

response = EntityUtils.toString(resentity);

} catch (ParseException e) {

AroundLogger.info(TAG + "doInBackground - ParseException - Error:" + e.getMessage());

e.printStackTrace();

} catch (IOException e) {

AroundLogger.info(TAG + "doInBackground - IOException - Error:" + e.getMessage());

e.printStackTrace();

}

}else{

// response = "{\"error\":\"No Internet Connection\"}";

Intent intent = new Intent();

intent.setAction(Global.NO_CONNECTION);

mContext.sendBroadcast(intent);

}

if (mIsProgress)

progress.dismiss();

return response;

}

@Override

protected void onPostExecute(Object response) {

AroundLogger.info(TAG + "onPostExecute - response: " + response);

mListener.responseListener((String) response);

}

ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

public String handleResponse(final HttpResponse response)

throws HttpResponseException, IOException {

StatusLine statusLine = response.getStatusLine();

if (statusLine.getStatusCode() >= 300) {

throw new HttpResponseException(statusLine.getStatusCode(),

statusLine.getReasonPhrase());

}

HttpEntity entity = response.getEntity();

AroundLogger.info(TAG + "handleResponse - entity: " + entity);

byte[] b = EntityUtils.toByteArray(entity);

return new String(b, "windows-1252");

// return entity == null ? null : EntityUtils.toString(entity);

}

};

}

create class name ActionItem

import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;

/**
 * Action item, displayed as menu with icon and text.
 *
 * @author Lorensius. W. L. T <lorenz@londatiga.net>
 *
 * Contributors:
 * - Kevin Peck <kevinwpeck@gmail.com>
 *
 */
public class ActionItem {
private Drawable icon;
private Bitmap thumb;
private String title;
private int actionId = -1;
    private boolean selected;
    private boolean sticky;
    private String smileyName;

    /**
     * Constructor
     *
     * @param actionId  Action id for case statements
     * @param title     Title
     * @param smiley      Icon to use
     */
    public ActionItem(int actionId, String title, Drawable smiley, String smileyName) {
        this.title = title;
        this.icon = smiley;
        this.actionId = actionId;
        this.smileyName = smileyName;
    }
   
    /**
     * Constructor
     */
    public ActionItem() {
        this(-1, null, 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;
}

public String getSmileyName() {
return smileyName;
}

public void setSmileyName(String smileyName) {
this.smileyName = smileyName;
}

/**
* 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;
}
}
create interface name ResponseListener

public interface ResponseListener {
public void responseListener(String response);

}

create class name XMPPConn

import org.jivesoftware.smack.ConnectionConfiguration;

import org.jivesoftware.smack.XMPPConnection;

import org.jivesoftware.smack.XMPPException;

import org.jivesoftware.smack.packet.Presence;

import android.content.Context;

import android.content.Intent;

import android.os.AsyncTask;

import com.easychat.constant.Global;

import com.easychat.mlisteners.OnLoginListener;

import com.easychat.utility.AroundLogger;

import com.easychat.utility.Utility;

import com.easychat.xmpp.XmppClient;

import com.easychat.xmpp.XmppConnectionListener;

public class XMPPConn extends AsyncTask<Object, Object, XMPPConnection>{

private static final String TAG = "XMPPConn - ";

Context mContext;

OnLoginListener mLoginListener;

XMPPConnection connection = null;

public XMPPConn(Context mContext, OnLoginListener loginListener) {

this.mContext = mContext;

this.mLoginListener = loginListener;

}

@Override

protected XMPPConnection doInBackground(Object... params) {

String host = Global.XMPPHOST;

String port = Global.XMPP_PORT;

if(Utility.isNetworkAvailable(mContext)){

AroundLogger.info(TAG + " host " + host + " port:" + port);

// Create a connection

ConnectionConfiguration connConfig = new ConnectionConfiguration(host, Integer.parseInt(port));

connection = new XMPPConnection(connConfig);

try {

connection.connect();

AroundLogger.info(TAG +  " Connected to " + connection.getHost());

} catch (XMPPException ex) {

AroundLogger.info(TAG + " Failed to connect to " + connection.getHost());

AroundLogger.info(TAG + ex.toString());

connection = null;

return connection;

}

if(connection != null && connection.isConnected()) {

String username = Utility.getSharedKey("username", mContext).toLowerCase();

String password = Utility.getSharedKey("password", mContext);

AroundLogger.info(TAG +  "doInBackground - User Name: " + username + " password:" + password);

try {

connection.login(username, password);

AroundLogger.info(TAG + " Logged in as " + connection.getUser());

Presence presence = new Presence(Presence.Type.available);

connection.sendPacket(presence);

connection.addConnectionListener(new XmppConnectionListener(mContext));

XmppClient mXmppClient = XmppClient.getInstance(mContext);

XmppClient.setConnection(connection, mXmppClient);

AroundLogger.info(TAG + " Registered for chat as " + connection.getUser());

} catch (Exception ex) {

AroundLogger.info(TAG + " Failed to log in as " + username);

AroundLogger.info(TAG +  ex.toString());

connection = null;

ex.printStackTrace();

}

}

}else{

// response = "{\"error\":\"No Internet Connection\"}";

Intent intent = new Intent();

intent.setAction(Global.NO_CONNECTION);

mContext.sendBroadcast(intent);

}

return connection;

}

@Override

protected void onPostExecute(XMPPConnection con) {

super.onPostExecute(con);

if(con != null && con.isConnected()) {

if(mLoginListener != null) {

mLoginListener.onLogin(true);

}

}else {

if(mLoginListener != null) {

mLoginListener.onLogin(false);

}

}

}

}

create interface name OnLoginListener

public interface OnLoginListener {

public void onLogin(boolean success);

}

Chat

First make xmpp package in that package create class name XmppClient

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.filter.MessageTypeFilter;
import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.util.StringUtils;

import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;

import com.easychat.app.ChatListAct;
import com.easychat.app.R;
import com.easychat.constant.Global;
import com.easychat.data.UserInfoChat;
import com.easychat.mlisteners.ChatReceiver;
import com.easychat.mlisteners.QueueChat;
import com.easychat.task.XMPPConn;
import com.easychat.utility.AroundLogger;
import com.easychat.utility.Utility;

public class XmppClient implements PacketListener{

private static final String TAG = "XmppClient";
static XMPPConnection connection;
static List<ChatReceiver> mChatReceivers;
static Context mContext;
private static XmppClient mXmppClient;
// static List<QueueChat> mQueueChats;
static HashMap<String, QueueChat> mQueueChats; 
static QueueChat mCurrentChatListener;
private XmppClient(Context context) {
mContext = context;
mQueueChats = new HashMap<String, QueueChat>();
}


public static XmppClient getInstance(Context context) {
if(mXmppClient == null) {
mXmppClient = new XmppClient(context);
}
return mXmppClient;
}


/*public void setCurrentChatListener(QueueChat queueChat) {
mCurrentChatListener = queueChat;
}*/

public static void setCurrentChatListener(String sender, ChatReceiver chatReceiver) {
mCurrentChatListener = new QueueChat();
mCurrentChatListener.setChatReceiver(chatReceiver);
mCurrentChatListener.setCount(0);
mCurrentChatListener.setSender(sender.toUpperCase());

removeChatFromQueue(sender.toUpperCase());
}

public static void removeCurrentChatListener() {
if(mCurrentChatListener != null) {
mCurrentChatListener = null;
}
}

public static void addChatInQueue(String sender, ChatReceiver chatReceiver) {
if(mQueueChats == null) mQueueChats = new HashMap<String, QueueChat>();
if(mQueueChats.size() > 0 && mQueueChats.containsKey(sender.toUpperCase())) {
QueueChat chat = mQueueChats.get(sender.toUpperCase());
int count = chat.increaseCounter();
QueueChat mQueueChat = new QueueChat();
mQueueChat.setChatReceiver(null);
mQueueChat.setCount(count);
mQueueChat.setSender(sender.toUpperCase());
mQueueChats.put(sender.toUpperCase(), mQueueChat);

// mQueueChats.put(sender.toUpperCase(), mQueueChats.get(sender.toUpperCase()).increaseCounter());
}else {
QueueChat mQueueChat = new QueueChat();
mQueueChat.setChatReceiver(null);
mQueueChat.setCount(1);
mQueueChat.setSender(sender.toUpperCase());
mQueueChats.put(sender.toUpperCase(), mQueueChat);
}
}

public static void removeChatFromQueue(String sender) {
if(mQueueChats != null) {
mQueueChats.remove(sender.toUpperCase());
}
}


public static int getChatQueueCount(String sender) {
if(mQueueChats != null && mQueueChats.containsKey(sender.toUpperCase())) {
return mQueueChats.get(sender.toUpperCase()).getCount();
}else {
return 0;
}
}

/*public static void addChatReceiver(ChatReceiver chatReceiver) {
if(mChatReceivers == null) {
mChatReceivers = new ArrayList<ChatReceiver>();
}

mChatReceivers.add(chatReceiver);
}*/

public static void removeChatReceiver(ChatReceiver chatReceiver) {
if(mChatReceivers != null && mChatReceivers.size()>0) {
mChatReceivers.remove(chatReceiver);
}
}

public static void setConnection(XMPPConnection xmppConnection, PacketListener packetListener) {
connection = xmppConnection;
if (connection != null) {
// Add a packet listener to get messages sent to us
PacketFilter filter = new MessageTypeFilter(Message.Type.chat);
connection.addPacketListener(packetListener, filter);

/*filter = new MessageTypeFilter(Message.Type.fromString(Global.TYPE_INVITETOCHAT));
connection.addPacketListener(packetListener, filter);

filter = new MessageTypeFilter(Message.Type.fromString(Global.TYPE_INVITATION_ACCEPT));
connection.addPacketListener(packetListener, filter);

filter = new MessageTypeFilter(Message.Type.fromString(Global.TYPE_INVITATION_DECLINE));
connection.addPacketListener(packetListener, filter);*/

AroundLogger.info(TAG + "Registered for chat as " + connection.getUser());
}
}


public static void disconnect() {
if(connection != null && connection.isConnected()) {
if(mXmppClient != null) {
connection.removePacketListener(mXmppClient);
}
connection.disconnect();
}

}


@Override
public void processPacket(Packet packet) {
Message message = (Message) packet;

if (message.getBody() != null) {

if(message.getBody().equals(Global.TYPE_INVITETOADDFRIEND)) {
Intent  inivitetoAddFriend = new Intent(Global.ACTION_RECEIVED_INVITOADDFRIEND);

UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender= StringUtils.parseName(message.getFrom());
inivitetoAddFriend.putExtra("userinfo", userInfoChat);
mContext.sendBroadcast(inivitetoAddFriend);
}else if(message.getBody().equals(Global.TYPE_FRIEND_REQUEST_ACCEPT)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_ACCEPT_FRIEND_REQUEST);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);

mContext.sendBroadcast(invitationIntent);


}else if(message.getBody().equals(Global.TYPE_FRIEND_REQUEST_DECLINE)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_DECLINE_FRIEND_REQUEST);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);
mContext.sendBroadcast(invitationIntent);

}else if(message.getBody().equals(Global.TYPE_INVITETOCHAT)) {


Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_INVITATIONTOCHAT);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);
mContext.sendBroadcast(invitationIntent);

}else if(message.getBody().equals(Global.TYPE_INVITATION_ACCEPT)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_ACCEPTCHATINVITATION);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);

mContext.sendBroadcast(invitationIntent);


}else if(message.getBody().equals(Global.TYPE_INVITATION_DECLINE)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_DECLINECHATINVITATION);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);
mContext.sendBroadcast(invitationIntent);

}else if(message.getBody().equals(Global.TYPE_REQUEST_GALLERY)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_GALLERY_REQUEST);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);

mContext.sendBroadcast(invitationIntent);

}else if(message.getBody().equals(Global.TYPE_REQUEST_GALLERY_ACCEPT)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_GALLERY_REQUEST_ACCCEPT);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);

mContext.sendBroadcast(invitationIntent);


}else if(message.getBody().equals(Global.TYPE_REQUEST_GALLERY_DECLINE)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_GALLERY_REQUEST_DECLINE);
UserInfoChat userInfoChat = (UserInfoChat) message.getProperty("userinfo");
userInfoChat.sender = StringUtils.parseName(message.getFrom());
invitationIntent.putExtra("userinfo", userInfoChat);

mContext.sendBroadcast(invitationIntent);

}else if(message.getBody().equals(Global.TYPE_NOTIFY_ONLINE)) {
Intent invitationIntent = new Intent(Global.ACTION_RECEIVED_NOTIFY_FRIEND_ONLINE);
invitationIntent.putExtra("sender", StringUtils.parseName(message.getFrom()));
mContext.sendBroadcast(invitationIntent);

}else {
// String fromName = StringUtils.parseBareAddress(message.getFrom());
AroundLogger.info(TAG + "Got text [" + message.getBody() + "] from [" + StringUtils.parseName(message.getFrom()) + "]");

if(mCurrentChatListener != null && mCurrentChatListener.getChatReceiver() != null && mCurrentChatListener.getSender().equalsIgnoreCase(StringUtils.parseName(message.getFrom()))) {
mCurrentChatListener.getChatReceiver().receive(message);

}else {
createNotification(message);
addChatInQueue(StringUtils.parseName(message.getFrom()), null);
}
}
}
}


public static boolean isConnected() {
if(connection != null && connection.isConnected()) {
return true;
}else {
return false;
}
}

private void createNotification(Message message) {
NotificationManager mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
int icon = R.drawable.app_icon;
CharSequence tickerText = mContext.getString(R.string.app_name);
long when = System.currentTimeMillis();

Notification notification = new Notification(icon, tickerText, when);
notification.flags |= Notification.FLAG_AUTO_CANCEL;

UserInfoChat mInfoChat = (UserInfoChat) message.getProperty("userinfo");

CharSequence contentTitle = StringUtils.parseName(message.getFrom());
CharSequence contentText = message.getBody();
Intent notificationIntent = new Intent(mContext, ChatListAct.class);
notificationIntent.putExtra("username", contentTitle.toString());
notificationIntent.putExtra("message", contentText);
notificationIntent.putExtra("userid", mInfoChat.userid);

// notificationIntent.putExtra("senderid", mInfoChat.senderId);
// notificationIntent.putExtra("status", (String)message.getProperty("status"));
PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);


notification.setLatestEventInfo(mContext, contentTitle, contentText, contentIntent);
mNotificationManager.notify(1, notification);
}

public static void sendMessage(final Context context, Message message) {

if(connection != null && connection.isConnected()) {
connection.sendPacket(message);
}else {
((Activity)context).runOnUiThread(new Runnable() {

@Override
public void run() {
Utility.showToast(context.getString(R.string.xmpp_disconnected_error), context);
new XMPPConn(context.getApplicationContext(), null).execute();
}
});
}
}




}

create next class name XmppConnectionListener

import org.jivesoftware.smack.ConnectionListener;

import android.content.Context;

import com.easychat.utility.AroundLogger;

public class XmppConnectionListener implements ConnectionListener{

static final String Tag = "XmppConnectionListener";

Context mContext;

public XmppConnectionListener(Context context) {

this.mContext = context;

}

@Override

public void connectionClosed() {

AroundLogger.info(Tag + " connectionClosed()");

// new XMPPConn(mContext, null).execute();

}

@Override

public void connectionClosedOnError(Exception arg0) {

// TODO Auto-generated method stub

AroundLogger.info(Tag + " connectionClosedOnError()");

}

@Override

public void reconnectingIn(int arg0) {

// TODO Auto-generated method stub

AroundLogger.info(Tag + " reconnectingIn()");

}

@Override

public void reconnectionFailed(Exception arg0) {

// TODO Auto-generated method stub

AroundLogger.info(Tag + " reconnectionFailed()");

}

@Override

public void reconnectionSuccessful() {

// TODO Auto-generated method stub

AroundLogger.info(Tag + " reconnectionSuccessful()");

}

}

create BroadcastReceiver class name ChatBroadcastReceiver

import android.app.Notification;

import android.app.NotificationManager;

import android.app.PendingIntent;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.text.TextUtils;

import com.easychat.app.AddFriendInvitationDialogActivity;

import com.easychat.app.ChatInvitationDialogActivity;

import com.easychat.app.R;

import com.easychat.app.RequestGalleryImagesDialogActivity;

import com.easychat.app.SimpleDialogActivity;

import com.easychat.app.SimpleGalleryDialogActivity;

import com.easychat.constant.Global;

import com.easychat.data.UserInfoChat;

import com.easychat.utility.Utility;

public class ChatBroadcastReceiver extends BroadcastReceiver{

@Override

public void onReceive(Context context, Intent intent) {

if(intent.getAction().equals(Global.ACTION_RECEIVED_INVITOADDFRIEND)) {

Intent chatInvitationIntent = new Intent(context,AddFriendInvitationDialogActivity.class);

UserInfoChat mUserInfoChat =(UserInfoChat)intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_ACCEPT_FRIEND_REQUEST)) {

Intent chatInvitationIntent = new Intent(context, SimpleDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", true);

chatInvitationIntent.putExtra("flag", true);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_DECLINE_FRIEND_REQUEST)) {

Intent chatInvitationIntent = new Intent(context, SimpleDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", false);

chatInvitationIntent.putExtra("flag", true);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_INVITATIONTOCHAT)) {

Intent chatInvitationIntent = new Intent(context, ChatInvitationDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_ACCEPTCHATINVITATION)) {

Intent chatInvitationIntent = new Intent(context, SimpleDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", true);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_DECLINECHATINVITATION)) {

Intent chatInvitationIntent = new Intent(context, SimpleDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", false);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_GALLERY_REQUEST)) {

Intent chatInvitationIntent = new Intent(context, RequestGalleryImagesDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_GALLERY_REQUEST_ACCCEPT)) {

Intent chatInvitationIntent = new Intent(context, SimpleGalleryDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", true);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_GALLERY_REQUEST_DECLINE)) {

Intent chatInvitationIntent = new Intent(context, SimpleGalleryDialogActivity.class);

UserInfoChat mUserInfoChat = (UserInfoChat) intent.getSerializableExtra("userinfo");

chatInvitationIntent.putExtra("userinfo", mUserInfoChat);

chatInvitationIntent.putExtra("accepted", false);

chatInvitationIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

context.startActivity(chatInvitationIntent);

}else if(intent.getAction().equals(Global.ACTION_RECEIVED_NOTIFY_FRIEND_ONLINE)) {

String notifyFriendsGetOnline = Utility.getSharedKey(Global.PREF_NOTIFY_FRIENDS_GET_ONLINE, context);

if(!TextUtils.isEmpty(notifyFriendsGetOnline) && Boolean.parseBoolean(notifyFriendsGetOnline)) {

String isStatusBarNotification = Utility.getSharedKey(Global.PREF_STATUSBAR_NOTIFICATION, context);

if(!TextUtils.isEmpty(isStatusBarNotification) && Boolean.parseBoolean(isStatusBarNotification)) {

//Create notification

createNotification(context, intent.getStringExtra("sender"));

}else {

//Display Toast

Utility.showToast(String.format(context.getString(R.string.xxx_user_is_online), intent.getStringExtra("sender")), context);

}

}

}

}

private void createNotification(Context mContext, String username) {

NotificationManager mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);

int icon = R.drawable.app_icon;

CharSequence tickerText = mContext.getString(R.string.app_name);

long when = System.currentTimeMillis();

Notification notification = new Notification(icon, tickerText, when);

notification.flags |= Notification.FLAG_AUTO_CANCEL;

CharSequence contentText = String.format(mContext.getString(R.string.xxx_user_is_online), username);

Intent notificationIntent = new Intent();

PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT);

notification.setLatestEventInfo(mContext, username, contentText, contentIntent);

mNotificationManager.notify(1, notification);

}

}

Interface

create class name MyInterface

public interface MyInterface {

public abstract  void Mydata(List<DataAll> listmy);
}

where you want list put below code

List<DataAll> Dataallobj;

BaseAdapter bas;

MyTask  task = new MyTask();

    task.setListeners(new MyInterface() {

    @Override

    public void Mydata(List<DataAll> listmy) {

    Dataallobj = listmy;

    mycontnamesetget = listmy;

    bas = new BaseAd(JitegaSlider.this);

    MyHandler.sendEmptyMessage(COMPLETEMAIN);

    }

    });

create class MyTask

public class MyTask  extends  AsyncTask<String,Void, List<DataAll>>

{

private static final String  TAG = "MyTask -";

List<DataAll> Dataallobj = new ArrayList<DataAll>();

MyInterface  objedatasend;

String Response;

boolean temp = true;

InputStream is = null;

 

@Override

protected List<DataAll> doInBackground(String... params) {

Log.i(General.TAG,TAG+"doInBackground -");

List<DataAll> Dataallobj = new ArrayList<DataAll>();

for (String url : params) 

{

DefaultHttpClient client = new DefaultHttpClient();

HttpGet httpGet = new HttpGet(url);

Response = "";

try {

HttpResponse execute = client.execute(httpGet);

InputStream content = execute.getEntity().getContent();

BufferedReader buffer = new BufferedReader(new InputStreamReader(content),8);

String s = "";

while ((s = buffer.readLine()) != null) {

Response += s;

Log.i(General.TAG, "get response....."+Response);

}

} catch (Exception e) {

e.printStackTrace();

}

try {

JSONObject json = new JSONObject(Response.replaceAll("null", ""));

JSONObject jobj = json.getJSONObject("feed");

JSONArray jsonArray = jobj.getJSONArray("entry");

String Title = "";

String Vidio = "";

String Imageurl = "";

String Summary = "";

String ImgHeight = "";

String ImgWidth = "";

String Imgname = "";

String favouritecount = "";

String viewcount = "";

String numDislike = "0";

String numLike = "0";

String currentDateandTime = "";

String videotimedur = "";

String mytime = "";

JSONObject jobtitle = null,jobcontent=null,jobstatistic=null,jobjmedia = null,jobmediadesc=null,jobjrating=null,jobdate = null,jobvideotime = null;

if(jsonArray != null){

for (int i = 0; i < jsonArray.length(); i++) 

{

JSONObject Entryobj = jsonArray.getJSONObject(i);

// This Array For Getting ImageUrl                     

if(Entryobj.has("published")){

jobdate = Entryobj.getJSONObject("published");

}

if(Entryobj.has("title")){

jobtitle = Entryobj.getJSONObject("title");

}

if(Entryobj.has("yt$statistics")){

//null

jobstatistic = Entryobj.getJSONObject("yt$statistics");

}

if(Entryobj.has("media$group")){

jobjmedia = Entryobj.getJSONObject("media$group");

}

if(jobjmedia.has("media$description")){

jobmediadesc = jobjmedia.getJSONObject("media$description");

}

if(jobjmedia.has("yt$videoid")){

jobcontent = jobjmedia.getJSONObject("yt$videoid");

}

if(jobjmedia.has("yt$duration")){

jobvideotime = jobjmedia.getJSONObject("yt$duration");

}

if(Entryobj.has("yt$rating")){

//null

jobjrating = Entryobj.getJSONObject("yt$rating");

}

JSONArray MediaThumbnailArray = jobjmedia.getJSONArray("media$thumbnail");

for (int m = 0; m < MediaThumbnailArray.length(); m++) {

JSONObject MediaImg = MediaThumbnailArray.getJSONObject(m);

ImgHeight = MediaImg.getString("height");

if(ImgHeight.equalsIgnoreCase("360")){

Imageurl = MediaImg.getString("url");

}

ImgWidth = MediaImg.getString("width");

Imgname = MediaImg.getString("yt$name");

Log.i(TAG, "get image....."+Imageurl);

Log.i(TAG, "get ImgHeight....."+ImgHeight);

Log.i(TAG, "get ImgWidth....."+ImgWidth);

Log.i(TAG, "get Imgname....."+Imgname);

}

if(jobdate != null){

if(jobdate.has("$t")){

currentDateandTime = jobdate.getString("$t");

Log.i(TAG, "get currentDateandTime....."+currentDateandTime);

}

}

if(jobtitle != null){

if(jobtitle.has("$t")){

Title = jobtitle.getString("$t");

Log.i(General.TAG, "get title...."+Title);

}

}

if(jobmediadesc != null){

if(jobmediadesc.has("$t")){

Summary = jobmediadesc.getString("$t");

Log.i(General.TAG, "get Summary...."+Summary);

}

}

if(jobcontent != null){

if(jobcontent.has("$t")){

Vidio =  jobcontent.getString("$t");

Log.i(General.TAG, "get Vidio url...."+Vidio);

}

}

if(jobvideotime != null){

if(jobvideotime.has("seconds")){

videotimedur =  jobvideotime.getString("seconds");

Log.i(General.TAG, "get Vidio time in seconds...."+Vidio);

 mytime = getDurationString(Integer.parseInt(videotimedur));

        Log.i(TAG, "get mytime..."+mytime);

}

}

if(jobstatistic != null){

if(jobstatistic.has("favoriteCount")){

favouritecount = jobstatistic.getString("favoriteCount");

Log.i(General.TAG, "get favouritecount...."+favouritecount);

}

if(jobstatistic.has("viewCount")){

viewcount = jobstatistic.getString("viewCount");

Log.i(General.TAG, "get viewcount...."+viewcount);

}

}

if(jobjrating != null){

if(jobjrating.has("numDislikes")){

numDislike = jobjrating.getString("numDislikes");

Log.i(General.TAG, "get numDislike...."+numDislike);

}

if(jobjrating.has("numLikes")){

numLike = jobjrating.getString("numLikes");

Log.i(General.TAG, "get numLike...."+numLike);

}

}

Dataallobj.add(new DataAll(Title,Summary,Vidio,Imageurl,ImgHeight,ImgWidth,Imgname,favouritecount,viewcount,numDislike,numLike,currentDateandTime,mytime));

}}

} catch (Exception e) {

System.out.println("" + e.toString());

Log.i(General.TAG,TAG +" To Parse Json Data On BackGroundMehtod Errore");

}

}

return Dataallobj;

}

@Override

protected void onPostExecute(List<DataAll> result) {

Log.i(General.TAG,TAG+"onPostExecute - Result: "+result);

super.onPostExecute(result);  

objedatasend.Mydata(result);

 

}

public void setListeners(MyInterface  datasend)

{

 Log.i(General.TAG,TAG+" setListeners -");

 objedatasend = datasend;  

}

private String getDurationString(int seconds) {

    int hours = seconds / 3600;

    int minutes = (seconds % 3600) / 60;

    seconds = seconds % 60;

    return twoDigitString(hours) + " : " + twoDigitString(minutes) + " : " + twoDigitString(seconds);

}

private String twoDigitString(int number) {

    if (number == 0) {

        return "00";

    }

    if (number / 10 == 0) {

        return "0" + number;

    }

    return String.valueOf(number);

}

}

Android Set Multiple Alarms

// context variable contains your `Context`
AlarmManager mgrAlarm = (AlarmManager) context.getSystemService(ALARM_SERVICE);
ArrayList<PendingIntent> intentArray = new ArrayList<PendingIntent>();

for(i = 0; i < 10; ++i)
{
   Intent intent = new Intent(context, OnAlarmReceiver.class);
   // Loop counter `i` is used as a `requestCode`
   PendingIntent pendingIntent = PendingIntent.getBroadcast(context, i, intent, 0);
   // Single alarms in 1, 2, ..., 10 minutes (in `i` minutes)
   mgrAlarm.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, 
                SystemClock.elapsedRealtime() + 60000 * i, 
                pendingIntent); 

   intentArray.add(pendingIntent);
}

Then if you need to cancel them:

private void cancelAlarms(){
    if(intentArray.size()>0){
        for(int i=0; i<intentArray.size(); i++){
            alarmmanager.cancel(intentArray.get(i));
        }
        intentArray.clear();
    }
}