com.imalu.alyou.activity.MainActivity.java Source code

Java tutorial

Introduction

Here is the source code for com.imalu.alyou.activity.MainActivity.java

Source

/**
 * Copyright (C) 2013-2014 EaseMob Technologies. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.imalu.alyou.activity;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.apache.http.Header;
import org.json.JSONArray;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentTransaction;
import android.text.TextUtils;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.Button;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.imalu.alyou.AlUApplication;
import com.imalu.alyou.R;

/*import com.easemob.EMConnectionListener;
import com.easemob.EMError;
import com.easemob.chat.CmdMessageBody;
import com.easemob.chat.EMChat;
import com.easemob.chat.EMChatManager;
import com.easemob.chat.EMContactListener;
import com.easemob.chat.EMContactManager;
import com.easemob.chat.EMConversation;
import com.easemob.chat.EMGroup;
import com.easemob.chat.EMGroupManager;
import com.easemob.chat.EMMessage;
import com.easemob.chat.EMMessage.ChatType;
import com.easemob.chat.EMMessage.Type;
import com.easemob.chat.EMNotifier;
import com.easemob.chat.GroupChangeListener;
import com.easemob.chat.TextMessageBody;
    
import com.easemob.util.EMLog;
import com.easemob.util.HanziToPinyin;
import com.easemob.util.NetUtils;*/
import com.imalu.alyou.Constant;
//import com.imalu.alyou.AlUApplication;
import com.imalu.alyou.db.InviteMessgeDao;
import com.imalu.alyou.domain.InviteMessage;
import com.imalu.alyou.domain.User;
import com.imalu.alyou.domain.InviteMessage.InviteMesageStatus;
import com.imalu.alyou.net.JsonHttpResponseHandler;
import com.imalu.alyou.net.NetManager;
import com.imalu.alyou.net.request.SearchFriendRequest;
import com.imalu.alyou.net.response.FriendListResponse;
import com.imalu.alyou.utils.CommonUtils;
//import com.umeng.analytics.MobclickAgent;

public class MainActivity extends BaseActivity {

    protected static final String TAG = "MainActivity";
    // ?textview
    private TextView unreadLabel;
    // textview
    private TextView unreadAddressLable;

    private Button[] mTabs;
    private ContactlistFragment contactListFragment;
    //private ChatHistoryFragment chatHistoryFragment;
    private ChatAllHistoryFragment chatHistoryFragment;
    private SettingsFragment settingFragment;
    private MainPageFragment mainpageFragment;
    private Fragment[] fragments;
    private int index;
    private RelativeLayout[] tab_containers;
    // ?fragmentindex
    private int currentTabIndex;
    //private NewMessageBroadcastReceiver msgReceiver;
    // ?
    public boolean isConflict = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState != null && savedInstanceState.getBoolean("isConflict", false)) {
            //T??home???appcrash
            //fragment??
            finish();
            startActivity(new Intent(this, LoginActivity.class));
            return;
        }
        setContentView(R.layout.activity_main);
        initView();
        getContactList();

        //if (getIntent().getBooleanExtra("conflict", false) && !isConflictDialogShow)
        //   showConflictDialog();

        //inviteMessgeDao = new InviteMessgeDao(this);
        //userDao = new UserDao(this);
        // fragment???
        // chatHistoryFragment = new ChatHistoryFragment();
        // ?fragment
        chatHistoryFragment = new ChatAllHistoryFragment();
        contactListFragment = new ContactlistFragment();
        mainpageFragment = new MainPageFragment();
        settingFragment = new SettingsFragment();
        fragments = new Fragment[] { chatHistoryFragment, contactListFragment, mainpageFragment, settingFragment };
        // fragment
        getSupportFragmentManager().beginTransaction().add(R.id.fragment_container, chatHistoryFragment)
                .add(R.id.fragment_container, contactListFragment).hide(contactListFragment)
                .show(chatHistoryFragment).commit();

        // ?BroadcastReceiver
        /*msgReceiver = new NewMessageBroadcastReceiver();
        IntentFilter intentFilter = new IntentFilter(EMChatManager.getInstance().getNewMessageBroadcastAction());
        intentFilter.setPriority(3);
        registerReceiver(msgReceiver, intentFilter);*/

        // ack?BroadcastReceiver
        /*IntentFilter ackMessageIntentFilter = new IntentFilter(EMChatManager.getInstance().getAckMessageBroadcastAction());
        ackMessageIntentFilter.setPriority(3);
        registerReceiver(ackMessageReceiver, ackMessageIntentFilter);*/

        //??BroadcastReceiver
        /*IntentFilter cmdMessageIntentFilter = new IntentFilter(EMChatManager.getInstance().getCmdMessageBroadcastAction());
        cmdMessageIntentFilter.setPriority(3);
        registerReceiver(cmdMessageReceiver, cmdMessageIntentFilter);*/

        // ?BroadcastReceiver
        // IntentFilter offlineMessageIntentFilter = new
        // IntentFilter(EMChatManager.getInstance()
        // .getOfflineMessageBroadcastAction());
        // registerReceiver(offlineMessageReceiver, offlineMessageIntentFilter);

        // setContactListener???
        //EMContactManager.getInstance().setContactListener(new MyContactListener());
        // ??listener
        //EMChatManager.getInstance().addConnectionListener(new MyConnectionListener());
        // ?listener
        //EMGroupManager.getInstance().addGroupChangeListener(new MyGroupChangeListener());
        // sdkUI ??receiverlistener, ??broadcast
        //EMChat.getInstance().setAppInited();

    }

    private void getContactList() {
        SearchFriendRequest searchFriendReq = new SearchFriendRequest();
        searchFriendReq.setUserKey(AlUApplication.getMyInfo().getKey());

        NetManager.execute(NetManager.MY_FRIEND_OPERATION, searchFriendReq, new JsonHttpResponseHandler() {
            @Override
            public void onSuccess(int statusCode, Header[] headers, JSONArray response) {
                Log.e("FriendListFragament", response.toString());
                super.onSuccess(statusCode, headers, response);
                FriendListResponse friendlist = new FriendListResponse();
                friendlist.setJsonObject(response);
                AlUApplication.setFriends(friendlist);
            }
        });
    }

    /**
     * ?
     */
    private void initView() {
        unreadLabel = (TextView) findViewById(R.id.unread_msg_number);
        unreadAddressLable = (TextView) findViewById(R.id.unread_address_number);
        mTabs = new Button[4];
        mTabs[0] = (Button) findViewById(R.id.btn_conversation);
        mTabs[1] = (Button) findViewById(R.id.btn_address_list);
        mTabs[2] = (Button) findViewById(R.id.btn_mainpage);
        mTabs[3] = (Button) findViewById(R.id.btn_setting);
        // tab?
        mTabs[0].setSelected(true);

    }

    /**
     * button
     * 
     * @param view
     */
    public void onTabClicked(View view) {
        switch (view.getId()) {
        case R.id.btn_conversation:
            index = 0;
            break;
        case R.id.btn_address_list:
            index = 1;
            break;
        case R.id.btn_mainpage:
            index = 2;
            break;
        case R.id.btn_setting:
            index = 3;
            break;
        }
        if (currentTabIndex != index) {
            FragmentTransaction trx = getSupportFragmentManager().beginTransaction();
            trx.hide(fragments[currentTabIndex]);
            if (!fragments[index].isAdded()) {
                trx.add(R.id.fragment_container, fragments[index]);
            }
            trx.show(fragments[index]).commit();
        }
        mTabs[currentTabIndex].setSelected(false);
        // ?tab?
        mTabs[index].setSelected(true);
        currentTabIndex = index;
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 
        try {
            //unregisterReceiver(msgReceiver);
        } catch (Exception e) {
        }
        try {
            //unregisterReceiver(ackMessageReceiver);
        } catch (Exception e) {
        }
        // try {
        // unregisterReceiver(offlineMessageReceiver);
        // } catch (Exception e) {
        // }

        if (conflictBuilder != null) {
            conflictBuilder.create().dismiss();
            conflictBuilder = null;
        }

    }

    /**
     * ?
     */
    //   public void updateUnreadLabel() {
    //      int count = getUnreadMsgCountTotal();
    //      if (count > 0) {
    //         unreadLabel.setText(String.valueOf(count));
    //         unreadLabel.setVisibility(View.VISIBLE);
    //      } else {
    //         unreadLabel.setVisibility(View.INVISIBLE);
    //      }
    //   }

    /**
     * ?
     */
    //   public void updateUnreadAddressLable() {
    //      runOnUiThread(new Runnable() {
    //         public void run() {
    //            int count = getUnreadAddressCountTotal();
    //            if (count > 0) {
    //               unreadAddressLable.setText(String.valueOf(count));
    //               unreadAddressLable.setVisibility(View.VISIBLE);
    //            } else {
    //               unreadAddressLable.setVisibility(View.INVISIBLE);
    //            }
    //         }
    //      });
    //
    //   }

    /**
     * ??
     * 
     * @return
     */
    //   public int getUnreadAddressCountTotal() {
    //      int unreadAddressCountTotal = 0;
    //      if (AlUApplication.getInstance().getContactList().get(Constant.NEW_FRIENDS_USERNAME) != null)
    //         unreadAddressCountTotal = AlUApplication.getInstance().getContactList().get(Constant.NEW_FRIENDS_USERNAME).getUnreadMsgCount();
    //      return unreadAddressCountTotal;
    //   }

    /**
     * ??
     * 
     * @return
     */
    //   public int getUnreadMsgCountTotal() {
    //      int unreadMsgCountTotal = 0;
    //      unreadMsgCountTotal = EMChatManager.getInstance().getUnreadMsgsCount();
    //      return unreadMsgCountTotal;
    //   }

    /**
     * ?
     * 
     * 
     */
    //   private class NewMessageBroadcastReceiver extends BroadcastReceiver {
    //      @Override
    //      public void onReceive(Context context, Intent intent) {
    //         // ????????chat?
    //
    //         String from = intent.getStringExtra("from");
    //         // ?id
    //         String msgId = intent.getStringExtra("msgid");
    //         EMMessage message = EMChatManager.getInstance().getMessage(msgId);
    //         // 2014-10-22 ?????????bug
    //         if (ChatActivity.activityInstance != null) {
    //            if (message.getChatType() == ChatType.GroupChat) {
    //               if (message.getTo().equals(ChatActivity.activityInstance.getToChatUsername()))
    //                  return;
    //            } else {
    //               if (from.equals(ChatActivity.activityInstance.getToChatUsername()))
    //                  return;
    //            }
    //         }
    //         
    //         // ?ChatActivity
    //         abortBroadcast();
    //         
    //         notifyNewMessage(message);
    //
    //         // bottom bar?
    //         updateUnreadLabel();
    //         if (currentTabIndex == 0) {
    //            // ??????
    //            if (chatHistoryFragment != null) {
    //               chatHistoryFragment.refresh();
    //            }
    //         }
    //
    //      }
    //   }

    /**
     * ?BroadcastReceiver
     */
    //   private BroadcastReceiver ackMessageReceiver = new BroadcastReceiver() {
    //
    //      @Override
    //      public void onReceive(Context context, Intent intent) {
    //         abortBroadcast();
    //         
    //         String msgid = intent.getStringExtra("msgid");
    //         String from = intent.getStringExtra("from");
    //
    //         EMConversation conversation = EMChatManager.getInstance().getConversation(from);
    //         if (conversation != null) {
    //            // message
    //            EMMessage msg = conversation.getMessage(msgid);
    //
    //            if (msg != null) {
    //
    //               // 2014-11-5 ????????bug
    //               if (ChatActivity.activityInstance != null) {
    //                  if (msg.getChatType() == ChatType.Chat) {
    //                     if (from.equals(ChatActivity.activityInstance.getToChatUsername()))
    //                        return;
    //                  }
    //               }
    //
    //               msg.isAcked = true;
    //            }
    //         }
    //         
    //      }
    //   };

    /**
     * ??BroadcastReceiver
     */
    //   private BroadcastReceiver cmdMessageReceiver = new BroadcastReceiver() {
    //      
    //      @Override
    //      public void onReceive(Context context, Intent intent) {
    //         abortBroadcast();
    //         EMLog.d(TAG, "??");
    //         //?cmd message
    //         String msgId = intent.getStringExtra("msgid");
    //         EMMessage message = intent.getParcelableExtra("message");
    //         //??body
    //         CmdMessageBody cmdMsgBody = (CmdMessageBody) message.getBody();
    //         String action = cmdMsgBody.action;//?action
    //         
    //         //? ?
    ////         message.getStringAttribute("");
    //         EMLog.d(TAG, String.format("??action:%s,message:%s", action,message.toString()));
    //         Toast.makeText(MainActivity.this, "?action"+action, Toast.LENGTH_SHORT).show();
    //      }
    //   };

    /**
     * ?BroadcastReceiver sdk ????clientreceiverUI
     * ??? UI ????
     */
    // private BroadcastReceiver offlineMessageReceiver = new
    // BroadcastReceiver() {
    //
    // @Override
    // public void onReceive(Context context, Intent intent) {
    // String[] users = intent.getStringArrayExtra("fromuser");
    // String[] groups = intent.getStringArrayExtra("fromgroup");
    // if (users != null) {
    // for (String user : users) {
    // System.out.println("user?" + user);
    // }
    // }
    // if (groups != null) {
    // for (String group : groups) {
    // System.out.println("group?" + group);
    // }
    // }
    // }
    // };

    private InviteMessgeDao inviteMessgeDao;
    //   private UserDao userDao;

    /***
     * ??listener
     * 
     */
    //   private class MyContactListener implements EMContactListener {
    //
    //      @Override
    //      public void onContactAdded(List<String> usernameList) {
    //         // ??
    //         Map<String, User> localUsers = AlUApplication.getInstance().getContactList();
    //         Map<String, User> toAddUsers = new HashMap<String, User>();
    //         for (String username : usernameList) {
    //            User user = setUserHead(username);
    //            // ??added
    //            if (!localUsers.containsKey(username)) {
    //               userDao.saveContact(user);
    //            }
    //            toAddUsers.put(username, user);
    //         }
    //         localUsers.putAll(toAddUsers);
    //         // ui
    //         if (currentTabIndex == 1)
    //            contactListFragment.refresh();
    //
    //      }
    //
    //      @Override
    //      public void onContactDeleted(final List<String> usernameList) {
    //         // 
    //         Map<String, User> localUsers = AlUApplication.getInstance().getContactList();
    //         for (String username : usernameList) {
    //            localUsers.remove(username);
    //            userDao.deleteContact(username);
    //            inviteMessgeDao.deleteMessage(username);
    //         }
    //         runOnUiThread(new Runnable() {
    //            public void run() {
    //               // ??
    //               if (ChatActivity.activityInstance != null && usernameList.contains(ChatActivity.activityInstance.getToChatUsername())) {
    //                  Toast.makeText(MainActivity.this, ChatActivity.activityInstance.getToChatUsername() + "?", 1).show();
    //                  ChatActivity.activityInstance.finish();
    //               }
    //               updateUnreadLabel();
    //               // ui
    //               if (currentTabIndex == 1)
    //                  contactListFragment.refresh();
    //               else if(currentTabIndex == 0)
    //                  chatHistoryFragment.refresh();
    //            }
    //         });
    //      
    //      }
    //
    //      @Override
    //      public void onContactInvited(String username, String reason) {
    //         // ???(???)???????????
    //         List<InviteMessage> msgs = inviteMessgeDao.getMessagesList();
    //
    //         for (InviteMessage inviteMessage : msgs) {
    //            if (inviteMessage.getGroupId() == null && inviteMessage.getFrom().equals(username)) {
    //               inviteMessgeDao.deleteMessage(username);
    //            }
    //         }
    //         // ?javabean
    //         InviteMessage msg = new InviteMessage();
    //         msg.setFrom(username);
    //         msg.setTime(System.currentTimeMillis());
    //         msg.setReason(reason);
    //         Log.d(TAG, username + "?,reason: " + reason);
    //         // status
    //         msg.setStatus(InviteMesageStatus.BEINVITEED);
    //         notifyNewIviteMessage(msg);
    //
    //      }
    //
    //      @Override
    //      public void onContactAgreed(String username) {
    //         List<InviteMessage> msgs = inviteMessgeDao.getMessagesList();
    //         for (InviteMessage inviteMessage : msgs) {
    //            if (inviteMessage.getFrom().equals(username)) {
    //               return;
    //            }
    //         }
    //         // ?javabean
    //         InviteMessage msg = new InviteMessage();
    //         msg.setFrom(username);
    //         msg.setTime(System.currentTimeMillis());
    //         Log.d(TAG, username + "???");
    //         msg.setStatus(InviteMesageStatus.BEAGREED);
    //         notifyNewIviteMessage(msg);
    //
    //      }
    //
    //      @Override
    //      public void onContactRefused(String username) {
    //         // ???,demo
    //         Log.d(username, username + "??");
    //      }
    //
    //   }

    /**
     * ????
     * 
     * @param msg
     */
    //   private void notifyNewIviteMessage(InviteMessage msg) {
    //      saveInviteMsg(msg);
    //      // ???
    //      EMNotifier.getInstance(getApplicationContext()).notifyOnNewMsg();
    //
    //      // bottom bar?
    //      updateUnreadAddressLable();
    //      // ??ui
    //      if (currentTabIndex == 1)
    //         contactListFragment.refresh();
    //   }

    /**
     * ?msg
     * 
     * @param msg
     */
    //   private void saveInviteMsg(InviteMessage msg) {
    //      // ?msg
    //      inviteMessgeDao.saveMessage(msg);
    //      // 1
    //      User user = AlUApplication.getInstance().getContactList().get(Constant.NEW_FRIENDS_USERNAME);
    //      if (user.getUnreadMsgCount() == 0)
    //         user.setUnreadMsgCount(user.getUnreadMsgCount() + 1);
    //   }

    /**
     * set head
     * 
     * @param username
     * @return
     */
    //   User setUserHead(String username) {
    //      User user = new User();
    //      user.setUsername(username);
    //      String headerName = null;
    //      if (!TextUtils.isEmpty(user.getNick())) {
    //         headerName = user.getNick();
    //      } else {
    //         headerName = user.getUsername();
    //      }
    //      if (username.equals(Constant.NEW_FRIENDS_USERNAME)) {
    //         user.setHeader("");
    //      } else if (Character.isDigit(headerName.charAt(0))) {
    //         user.setHeader("#");
    //      } else {
    //         user.setHeader(HanziToPinyin.getInstance().get(headerName.substring(0, 1)).get(0).target.substring(0, 1).toUpperCase());
    //         char header = user.getHeader().toLowerCase().charAt(0);
    //         if (header < 'a' || header > 'z') {
    //            user.setHeader("#");
    //         }
    //      }
    //      return user;
    //   }

    /**
     * ?listener
     * 
     */
    //   private class MyConnectionListener implements EMConnectionListener {
    //
    //      @Override
    //      public void onConnected() {
    //         runOnUiThread(new Runnable() {
    //
    //            @Override
    //            public void run() {
    //               chatHistoryFragment.errorItem.setVisibility(View.GONE);
    //            }
    //
    //         });
    //      }
    //
    //      @Override
    //      public void onDisconnected(final int error) {
    //         runOnUiThread(new Runnable() {
    //
    //            @Override
    //            public void run() {
    //               if (error == EMError.CONNECTION_CONFLICT) {
    //                  // ??dialog
    //                  showConflictDialog();
    //               } else {
    //                  chatHistoryFragment.errorItem.setVisibility(View.VISIBLE);
    //                  if (NetUtils.hasNetwork(MainActivity.this))
    //                     chatHistoryFragment.errorText.setText("???");
    //                  else
    //                     chatHistoryFragment.errorText.setText("???");
    //
    //               }
    //            }
    //
    //         });
    //      }
    //   }
    //
    //   /**
    //    * MyGroupChangeListener
    //    */
    //   private class MyGroupChangeListener implements GroupChangeListener {
    //
    //      @Override
    //      public void onInvitationReceived(String groupId, String groupName, String inviter, String reason) {
    //         boolean hasGroup = false;
    //         for (EMGroup group : EMGroupManager.getInstance().getAllGroups()) {
    //            if (group.getGroupId().equals(groupId)) {
    //               hasGroup = true;
    //               break;
    //            }
    //         }
    //         if (!hasGroup)
    //            return;
    //
    //         // 
    //         EMMessage msg = EMMessage.createReceiveMessage(Type.TXT);
    //         msg.setChatType(ChatType.GroupChat);
    //         msg.setFrom(inviter);
    //         msg.setTo(groupId);
    //         msg.setMsgId(UUID.randomUUID().toString());
    //         msg.addBody(new TextMessageBody(inviter + "?"));
    //         // ??
    //         EMChatManager.getInstance().saveMessage(msg);
    //         // ???
    //         EMNotifier.getInstance(getApplicationContext()).notifyOnNewMsg();
    //
    //         runOnUiThread(new Runnable() {
    //            public void run() {
    //               updateUnreadLabel();
    //               // ui
    //               if (currentTabIndex == 0)
    //                  chatHistoryFragment.refresh();
    //               if (CommonUtils.getTopActivity(MainActivity.this).equals(GroupsActivity.class.getName())) {
    //                  GroupsActivity.instance.onResume();
    //               }
    //            }
    //         });
    //
    //      }
    //
    //      @Override
    //      public void onInvitationAccpted(String groupId, String inviter, String reason) {
    //
    //      }
    //
    //      @Override
    //      public void onInvitationDeclined(String groupId, String invitee, String reason) {
    //
    //      }
    //
    //      @Override
    //      public void onUserRemoved(String groupId, String groupName) {
    //         // ??Tdemo?
    //         // ui
    //         runOnUiThread(new Runnable() {
    //            public void run() {
    //               try {
    //                  updateUnreadLabel();
    //                  if (currentTabIndex == 0)
    //                     chatHistoryFragment.refresh();
    //                  if (CommonUtils.getTopActivity(MainActivity.this).equals(GroupsActivity.class.getName())) {
    //                     GroupsActivity.instance.onResume();
    //                  }
    //               } catch (Exception e) {
    //                  EMLog.e(TAG, "refresh exception " + e.getMessage());
    //               }
    //
    //            }
    //         });
    //      }
    //
    //      @Override
    //      public void onGroupDestroy(String groupId, String groupName) {
    //         // 
    //         // ??,demo?
    //         // ui
    //         runOnUiThread(new Runnable() {
    //            public void run() {
    //               updateUnreadLabel();
    //               if (currentTabIndex == 0)
    //                  chatHistoryFragment.refresh();
    //               if (CommonUtils.getTopActivity(MainActivity.this).equals(GroupsActivity.class.getName())) {
    //                  GroupsActivity.instance.onResume();
    //               }
    //            }
    //         });
    //
    //      }
    //
    //      @Override
    //      public void onApplicationReceived(String groupId, String groupName, String applyer, String reason) {
    //         // ?
    //         InviteMessage msg = new InviteMessage();
    //         msg.setFrom(applyer);
    //         msg.setTime(System.currentTimeMillis());
    //         msg.setGroupId(groupId);
    //         msg.setGroupName(groupName);
    //         msg.setReason(reason);
    //         Log.d(TAG, applyer + " ?" + groupName);
    //         msg.setStatus(InviteMesageStatus.BEAPPLYED);
    //         notifyNewIviteMessage(msg);
    //      }
    //
    //      @Override
    //      public void onApplicationAccept(String groupId, String groupName, String accepter) {
    //         // ??
    //         EMMessage msg = EMMessage.createReceiveMessage(Type.TXT);
    //         msg.setChatType(ChatType.GroupChat);
    //         msg.setFrom(accepter);
    //         msg.setTo(groupId);
    //         msg.setMsgId(UUID.randomUUID().toString());
    //         msg.addBody(new TextMessageBody(accepter + "???"));
    //         // ????
    //         EMChatManager.getInstance().saveMessage(msg);
    //         // ???
    //         EMNotifier.getInstance(getApplicationContext()).notifyOnNewMsg();
    //
    //         runOnUiThread(new Runnable() {
    //            public void run() {
    //               updateUnreadLabel();
    //               // ui
    //               if (currentTabIndex == 0)
    //                  chatHistoryFragment.refresh();
    //               if (CommonUtils.getTopActivity(MainActivity.this).equals(GroupsActivity.class.getName())) {
    //                  GroupsActivity.instance.onResume();
    //               }
    //            }
    //         });
    //      }
    //
    //      @Override
    //      public void onApplicationDeclined(String groupId, String groupName, String decliner, String reason) {
    //         // ?demo
    //      }
    //
    //   }
    //
    //   @Override
    //   protected void onResume() {
    //      super.onResume();
    //      if (!isConflict) {
    //         updateUnreadLabel();
    //         updateUnreadAddressLable();
    //         EMChatManager.getInstance().activityResumed();
    //      }
    //
    //   }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putBoolean("isConflict", isConflict);
        super.onSaveInstanceState(outState);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_BACK) {
            moveTaskToBack(false);
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

    private android.app.AlertDialog.Builder conflictBuilder;
    private boolean isConflictDialogShow;

    /**
     * ??dialog
     */
    //   private void showConflictDialog() {
    //      isConflictDialogShow = true;
    //      AlUApplication.getInstance().logout(null);
    //
    //      if (!MainActivity.this.isFinishing()) {
    //         // clear up global variables
    //         try {
    //            if (conflictBuilder == null)
    //               conflictBuilder = new android.app.AlertDialog.Builder(MainActivity.this);
    //            conflictBuilder.setTitle("");
    //            conflictBuilder.setMessage(R.string.connect_conflict);
    //            conflictBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
    //
    //               @Override
    //               public void onClick(DialogInterface dialog, int which) {
    //                  dialog.dismiss();
    //                  conflictBuilder = null;
    //                  finish();
    //                  startActivity(new Intent(MainActivity.this, LoginActivity.class));
    //               }
    //            });
    //            conflictBuilder.setCancelable(false);
    //            conflictBuilder.create().show();
    //            isConflict = true;
    //         } catch (Exception e) {
    //            //EMLog.e(TAG, "---------color conflictBuilder error" + e.getMessage());
    //         }
    //
    //      }
    //
    //   }

    //   @Override
    //   protected void onNewIntent(Intent intent) {
    //      super.onNewIntent(intent);
    //      if (getIntent().getBooleanExtra("conflict", false) && !isConflictDialogShow)
    //         showConflictDialog();
    //   }

}