CallApp v2.226 - PersonSelectActivity.java 源代码

package com.callapp.contacts.activity.select;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.SparseIntArray;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.amazon.aps.ads.activity.a;
import com.callapp.common.model.json.JSONFBEntity;
import com.callapp.common.util.RegexUtils;
import com.callapp.contacts.CallAppApplication;
import com.callapp.contacts.R;
import com.callapp.contacts.activity.chooseContact.TopBarWithSearchActivity;
import com.callapp.contacts.activity.contact.list.search.T9Helper;
import com.callapp.contacts.activity.select.PersonSelectAdapter;
import com.callapp.contacts.api.helper.common.RemoteAccountHelper;
import com.callapp.contacts.api.helper.common.SocialNetworksSearchUtil;
import com.callapp.contacts.api.helper.facebook.FacebookHelper;
import com.callapp.contacts.api.helper.foursquare.FoursquareHelper;
import com.callapp.contacts.api.helper.twitter.TwitterHelper;
import com.callapp.contacts.loader.social.QuotaReachedException;
import com.callapp.contacts.loader.social.SearchIsNotAvailableExecption;
import com.callapp.contacts.loader.social.UnauthorizedAccessErrorException;
import com.callapp.contacts.manager.FeedbackManager;
import com.callapp.contacts.manager.analytics.AnalyticsManager;
import com.callapp.contacts.manager.cache.CacheManager;
import com.callapp.contacts.manager.popup.DialogPopup;
import com.callapp.contacts.manager.popup.PopupManager;
import com.callapp.contacts.manager.task.Task;
import com.callapp.contacts.model.Constants;
import com.callapp.contacts.model.PersonData;
import com.callapp.contacts.model.contact.ContactData;
import com.callapp.contacts.model.contact.SocialSearchResults;
import com.callapp.contacts.popup.contact.DialogSimpleMessage;
import com.callapp.contacts.popup.contact.SimpleProgressDialog;
import com.callapp.contacts.util.Activities;
import com.callapp.contacts.util.AndroidUtils;
import com.callapp.contacts.util.CLog;
import com.callapp.contacts.util.DefaultInterfaceImplUtils$OnDialogSimpleListener;
import com.callapp.contacts.util.ThemeUtils;
import com.callapp.contacts.util.http.HttpUtils;
import com.callapp.contacts.widget.SimpleSearchBarFragment;
import com.callapp.framework.util.CollectionUtils;
import com.callapp.framework.util.StringUtils;
import com.twitter.sdk.android.core.models.User;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;

public class PersonSelectActivity extends TopBarWithSearchActivity {
    public static final String FRIEND_IN_CACHE_KEY = "social_network_friends_";
    public static final String INTENT_EXTRA_CONTACTS_FULL_NAME = "PERSON_SELECT_CONTACTS_FULL_NAME";
    public static final String INTENT_EXTRA_FQL_TYPE = "INTENT_EXTRA_FQL_TYPE";
    public static final String INTENT_EXTRA_HAS_RESULT = "PERSON_SELECT_HAS_RESULT";
    public static final String INTENT_EXTRA_LIST = "PERSON_SELECT_LIST_KEY";
    public static final String INTENT_EXTRA_NET_ID = "PERSON_SELECT_NET_ID";
    public static final String INTENT_EXTRA_OPEN_PROFILE_IF_SINGLE_RESULT = "PERSON_SELECT_OPEN_PROFILE_IF_SINGLE_RESULT";
    public static final String INTENT_EXTRA_PERSON_DATA = "PERSON_SELECT_PERSON_DATA";
    public static final String RESULT_INTENT_EXTRA_USER_ID = "PERSON_SELECT_SELECTED_USER_ID";
    public static final int SELECT_PERSON_REQUEST = 996;
    private static final int TIME_TO_INTERRUPT_SEARCH = 15000;
    private String contactsFullName;
    public String fqlType;
    private boolean hasResult = false;
    private PersonSelectAdapter.ItemSelectListener itemSelectListener;
    private RecyclerView list;
    private boolean openProfileIfSingleResult;
    private PersonSelectAdapter personSelectAdapter;
    private RemoteAccountHelper remoteAccountHelper;
    private Task searchThreadStopper;
    private SimpleProgressDialog searchingProgressDialog;
    private SimpleProgressDialog selectProgressDialog;
    private int socialNetworkId;
    private String socialNetworkName;

    public class AnonymousClass1 implements PersonSelectAdapter.ItemSelectListener {
        public AnonymousClass1() {
        }

        public final void a(final PersonData personData) {
            ?? r0 = PersonSelectActivity.this;
            AndroidUtils.d(r0);
            ((PersonSelectActivity) r0).selectProgressDialog = new SimpleProgressDialog();
            ((PersonSelectActivity) r0).selectProgressDialog.setIndeterminate(true);
            ((PersonSelectActivity) r0).selectProgressDialog.setCancelable(false);
            ((PersonSelectActivity) r0).selectProgressDialog.setMessage(Activities.getString(R.string.please_wait));
            PopupManager.get().c(r0, ((PersonSelectActivity) r0).selectProgressDialog, true);
            new Task() {
                @Override
                public final void doTask() {
                    PersonData personData2 = personData;
                    String id = personData2.getId();
                    boolean x = StringUtils.x(id);
                    AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
                    if (x) {
                        Intent intent = new Intent();
                        intent.putExtra(PersonSelectActivity.RESULT_INTENT_EXTRA_USER_ID, id);
                        intent.putExtra(PersonSelectActivity.INTENT_EXTRA_NET_ID, PersonSelectActivity.this.socialNetworkId);
                        intent.putExtra(PersonSelectActivity.INTENT_EXTRA_PERSON_DATA, (Parcelable) personData2);
                        PersonSelectActivity.this.setResult(-1, intent);
                    } else {
                        PersonSelectActivity.this.setResult(0, null);
                    }
                    SimpleProgressDialog.m(PersonSelectActivity.this.selectProgressDialog);
                    PersonSelectActivity.this.finish();
                }
            }.execute();
        }
    }

    public static class PersonSelectDialogSimpleListener extends DefaultInterfaceImplUtils$OnDialogSimpleListener {
        public final Thread a;

        public PersonSelectDialogSimpleListener(Thread thread, int i) {
            this(thread);
        }

        @Override
        public final void b(DialogPopup dialogPopup) {
            Thread thread = this.a;
            if (thread == null || !thread.isAlive()) {
                return;
            }
            thread.interrupt();
        }

        private PersonSelectDialogSimpleListener(Thread thread) {
            this.a = thread;
        }
    }

    public static class SearchExceptionDialogSimpleListener implements DialogPopup.IDialogOnClickListener {
        public final boolean a;

        public SearchExceptionDialogSimpleListener(boolean z, int i) {
            this(z);
        }

        @Override
        public final void onClickListener(Activity activity) {
            if (this.a) {
                activity.finish();
            }
        }

        private SearchExceptionDialogSimpleListener(boolean z) {
            this.a = z;
        }
    }

    public PersonSelectActivity() {
        AnonymousClass1 anonymousClass1 = new AnonymousClass1();
        this.itemSelectListener = anonymousClass1;
        this.personSelectAdapter = new PersonSelectAdapter(anonymousClass1);
    }

    private static List<PersonData> fBJsonToPersonDataList(List<JSONFBEntity> list) {
        ArrayList arrayList = new ArrayList();
        if (list != null) {
            Iterator<JSONFBEntity> it = list.iterator();
            while (it.hasNext()) {
                PersonData personData = new PersonData(it.next());
                personData.setUnAccanetName(RegexUtils.b(personData.getName()));
                arrayList.add(personData);
            }
        }
        return arrayList;
    }

    private static List<PersonData> getFacebookFriends() {
        return fBJsonToPersonDataList(FacebookHelper.get().getFriends());
    }

    public List<PersonData> getFilteredFriendList(String str) {
        return getFilteredList(getSocialNetworkFriends(), str);
    }

    private static List<PersonData> getFilteredList(Collection<PersonData> collection, String str) {
        ArrayList arrayList = new ArrayList();
        if (CollectionUtils.h(collection)) {
            String b = RegexUtils.b(str.toLowerCase());
            for (PersonData personData : collection) {
                String unAccanetName = personData.getUnAccanetName();
                if (StringUtils.x(unAccanetName) && T9Helper.j(unAccanetName.toLowerCase(), new SparseIntArray(0), b, " ")) {
                    arrayList.add(personData);
                }
            }
        }
        return arrayList;
    }

    public List<PersonData> getFriendsThatContainsName() {
        ArrayList arrayList = new ArrayList();
        if (StringUtils.x(this.contactsFullName)) {
            String b = RegexUtils.b(this.contactsFullName.split(" ")[0]);
            List<PersonData> socialNetworkFriends = getSocialNetworkFriends();
            if (CollectionUtils.h(socialNetworkFriends)) {
                for (PersonData personData : socialNetworkFriends) {
                    String unAccanetName = personData.getUnAccanetName();
                    if (StringUtils.x(unAccanetName) && unAccanetName.contains(b)) {
                        arrayList.add(personData);
                    }
                }
            }
        }
        return arrayList;
    }

    public List<PersonData> getSocialNetworkFriends() {
        String str = FRIEND_IN_CACHE_KEY + this.socialNetworkId;
        List<PersonData> list = (List) CacheManager.get().c(str, List.class, false, false);
        if (CollectionUtils.h(list)) {
            return new ArrayList(list);
        }
        try {
            int i = this.socialNetworkId;
            if (i == 1) {
                list = getFacebookFriends();
            } else if (i == 4) {
                list = getTwitterFriends();
            }
        } catch (QuotaReachedException unused) {
        }
        if (CollectionUtils.f(list)) {
            return new ArrayList();
        }
        Collections.sort(list);
        CacheManager.get().h(List.class, str, list, R.integer.five_hours_in_minutes);
        return list;
    }

    private static List<PersonData> getTwitterFriends() {
        ArrayList arrayList = new ArrayList();
        List T = TwitterHelper.get().T(false, false);
        if (CollectionUtils.h(T)) {
            Iterator it = T.iterator();
            while (it.hasNext()) {
                PersonData personData = new PersonData((User) it.next());
                personData.setUnAccanetName(RegexUtils.b(personData.getName()));
                arrayList.add(personData);
            }
        }
        return arrayList;
    }

    public void handleSearchException(Exception exc, String str, boolean z) {
        CLog.b(PersonSelectActivity.class, exc);
        PopupManager.get().c(this, new DialogSimpleMessage(null, str, Activities.getString(R.string.ok), null, new SearchExceptionDialogSimpleListener(z, 0), null), true);
    }

    public boolean lambda$onCreate$0(View view, MotionEvent motionEvent) {
        hideKeyboard();
        return false;
    }

    private void performSearch(String str) {
        performSearch(str, true, false);
    }

    private void runInSafeBackgroundThread(Runnable runnable) {
        runInSafeBackgroundThread(runnable, true, false);
    }

    private void setupSearchText() {
        setHintText(Activities.f(R.string.person_select_search_by, this.contactsFullName.split(" ")[0], this.socialNetworkName));
    }

    public void showFilteredFriendListAsync(final String str) {
        runInSafeBackgroundThread(new Runnable() {
            @Override
            public final void run() {
                final List filteredFriendList = PersonSelectActivity.this.getFilteredFriendList(str);
                CallAppApplication.get().runOnMainThread(new Runnable() {
                    @Override
                    public final void run() {
                        PersonSelectActivity.this.updateList(filteredFriendList);
                    }
                });
            }
        }, false);
    }

    public void showFriendsAsync() {
        runInSafeBackgroundThread(new Runnable() {
            @Override
            public final void run() {
                PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                final List socialNetworkFriends = personSelectActivity.getSocialNetworkFriends();
                personSelectActivity.safeRunOnUIThread(new Runnable() {
                    @Override
                    public final void run() {
                        PersonSelectActivity.this.updateList(socialNetworkFriends);
                    }
                });
            }
        });
    }

    public void sortSearchResults(List<PersonData> list, String str) {
        Collections.sort(list);
        ArrayList arrayList = new ArrayList();
        for (PersonData personData : list) {
            if (personData.getName().equals(str)) {
                arrayList.add(personData);
            }
        }
        list.removeAll(arrayList);
        list.addAll(0, arrayList);
    }

    public static void startPersonSelectActivity(Activity activity, ContactData contactData, Integer num, String str, String str2, int i) {
        Intent putExtra = new Intent((Context) CallAppApplication.get(), (Class<?>) PersonSelectActivity.class).putExtra(INTENT_EXTRA_NET_ID, num).putExtra(INTENT_EXTRA_CONTACTS_FULL_NAME, str).putExtra(INTENT_EXTRA_FQL_TYPE, str2).putExtra(INTENT_EXTRA_OPEN_PROFILE_IF_SINGLE_RESULT, false);
        SocialSearchResults a = SocialNetworksSearchUtil.a(num.intValue(), contactData);
        if (a == null || num.intValue() == FoursquareHelper.get().getApiConstantNetworkId()) {
            putExtra.putExtra(INTENT_EXTRA_HAS_RESULT, false);
            putExtra.putExtra(TopBarWithSearchActivity.EXTRA_INITIAL_SEARCH_TEXT, str);
        } else {
            putExtra.putExtra(INTENT_EXTRA_HAS_RESULT, true);
            putExtra.putExtra(TopBarWithSearchActivity.EXTRA_INITIAL_SEARCH_TEXT, a.term);
        }
        activity.startActivityForResult(putExtra, i);
    }

    public void updateList(final List<PersonData> list) {
        safeRunOnUIThread(new Runnable() {
            @Override
            public final void run() {
                PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                PersonSelectAdapter personSelectAdapter = personSelectActivity.personSelectAdapter;
                int i = personSelectActivity.socialNetworkId;
                personSelectAdapter.i = list;
                personSelectAdapter.k = i;
                personSelectAdapter.notifyDataSetChanged();
            }
        });
    }

    @Override
    public int getLayoutResourceId() {
        return R.layout.activity_person_select;
    }

    @Override
    public SimpleSearchBarFragment.SearchBarEvents getSearchBarEvents() {
        return new TopBarWithSearchActivity.searchBarEventsImpl() {
            @Override
            public final void a(CharSequence charSequence, int i) {
                PersonSelectActivity.this.showFilteredFriendListAsync(charSequence.toString());
            }

            @Override
            public final void p() {
                PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                personSelectActivity.performSearch(personSelectActivity.getSearchText(), false, true);
            }
        };
    }

    @Override
    public void onBackPressed() {
        Intent intent = new Intent();
        intent.putExtra(INTENT_EXTRA_NET_ID, this.socialNetworkId);
        setResult(0, intent);
        super.onBackPressed();
    }

    @Override
    public void onCreate(Bundle bundle) {
        Intent intent = getIntent();
        if (intent == null || intent.getExtras() == null) {
            finish();
            return;
        }
        setKeyguardDismissAndScreenWindowFlags();
        super.onCreate(bundle);
        getSupportActionBar().r(true);
        Bundle extras = intent.getExtras();
        int i = extras.getInt(INTENT_EXTRA_NET_ID);
        this.socialNetworkId = i;
        this.remoteAccountHelper = RemoteAccountHelper.getRemoteAccountHelper(i);
        this.socialNetworkName = SocialNetworksSearchUtil.getSocialNetworkName(this.socialNetworkId);
        this.contactsFullName = StringUtils.b(extras.getString(INTENT_EXTRA_CONTACTS_FULL_NAME));
        this.fqlType = extras.getString(INTENT_EXTRA_FQL_TYPE);
        this.openProfileIfSingleResult = extras.getBoolean(INTENT_EXTRA_OPEN_PROFILE_IF_SINGLE_RESULT);
        setTitle(Activities.f(R.string.person_select_title, this.contactsFullName, this.socialNetworkName));
        if (StringUtils.t(this.contactsFullName)) {
            this.contactsFullName = Activities.getString(R.string.link_social_network_default_contact);
        }
        this.hasResult = intent.getBooleanExtra(INTENT_EXTRA_HAS_RESULT, false);
        this.list = findViewById(R.id.personList);
        View inflate = getLayoutInflater().inflate(R.layout.friends_list_header, (ViewGroup) null);
        this.list.setLayoutManager(new LinearLayoutManager(this));
        inflate.findViewById(R.id.divider).setBackgroundColor(ThemeUtils.getColor(R.color.separate_line));
        this.list.setAdapter(this.personSelectAdapter);
        findViewById(R.id.search_bar_fragment).setVisibility(0);
        this.list.setOnTouchListener(new a(this, 7));
        final ArrayList parcelableArrayList = extras.getParcelableArrayList("PERSON_SELECT_LIST_KEY");
        String initialSearchText = getInitialSearchText();
        setupSearchText();
        if (parcelableArrayList != null && !parcelableArrayList.isEmpty()) {
            runInSafeBackgroundThread(new Runnable() {
                @Override
                public final void run() {
                    PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                    List friendsThatContainsName = personSelectActivity.getFriendsThatContainsName();
                    final ArrayList arrayList = new ArrayList();
                    arrayList.addAll(friendsThatContainsName);
                    arrayList.addAll(parcelableArrayList);
                    personSelectActivity.safeRunOnUIThread(new Runnable() {
                        @Override
                        public final void run() {
                            PersonSelectActivity.this.updateList(arrayList);
                        }
                    });
                }
            }, false);
        } else if (StringUtils.x(initialSearchText)) {
            performSearch(initialSearchText);
        } else {
            showFriendsAsync();
        }
    }

    @Override
    public void onDestroy() {
        this.list.setAdapter((RecyclerView.f) null);
        Task task = this.searchThreadStopper;
        if (task != null) {
            task.cancel();
        }
        SimpleProgressDialog simpleProgressDialog = this.searchingProgressDialog;
        if (simpleProgressDialog != null) {
            simpleProgressDialog.setDialogCustomListener(null);
        }
        SimpleProgressDialog.m(this.searchingProgressDialog);
        SimpleProgressDialog.m(this.selectProgressDialog);
        super.onDestroy();
    }

    public void performSearch(final String str, final boolean z, boolean z2) throws SearchIsNotAvailableExecption {
        runInSafeBackgroundThread(new Runnable() {
            @Override
            public final void run() {
                List<PersonData> list;
                final boolean z3;
                final List list2;
                boolean z4 = z;
                String str2 = str;
                PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                try {
                    list = RemoteAccountHelper.getRemoteAccountHelper(personSelectActivity.socialNetworkId).z(str2);
                } catch (SearchIsNotAvailableExecption e) {
                    if (!z4) {
                        throw e;
                    }
                    list = null;
                }
                if (Thread.interrupted()) {
                    return;
                }
                List filteredFriendList = personSelectActivity.getFilteredFriendList(str2);
                if (z4 && CollectionUtils.f(list) && CollectionUtils.f(filteredFriendList)) {
                    list2 = personSelectActivity.getSocialNetworkFriends();
                    z3 = true;
                } else {
                    ArrayList arrayList = new ArrayList();
                    LinkedHashSet linkedHashSet = new LinkedHashSet();
                    if (CollectionUtils.h(filteredFriendList)) {
                        linkedHashSet.addAll(filteredFriendList);
                    } else if (z4) {
                        linkedHashSet.addAll(personSelectActivity.getFriendsThatContainsName());
                    }
                    arrayList.addAll(linkedHashSet);
                    LinkedHashSet linkedHashSet2 = new LinkedHashSet();
                    if (CollectionUtils.h(list)) {
                        List socialNetworkFriends = personSelectActivity.getSocialNetworkFriends();
                        linkedHashSet2.addAll(socialNetworkFriends);
                        socialNetworkFriends.clear();
                        for (PersonData personData : list) {
                            if (linkedHashSet2.contains(personData) && !linkedHashSet.contains(personData)) {
                                socialNetworkFriends.add(personData);
                            }
                        }
                        personSelectActivity.sortSearchResults(socialNetworkFriends, str2);
                        arrayList.addAll(socialNetworkFriends);
                    }
                    if (CollectionUtils.h(list)) {
                        list.removeAll(linkedHashSet);
                        list.removeAll(linkedHashSet2);
                        linkedHashSet.clear();
                        personSelectActivity.sortSearchResults(list, str2);
                        linkedHashSet.addAll(list);
                        arrayList.addAll(linkedHashSet);
                    }
                    z3 = false;
                    list2 = arrayList;
                }
                final List friendsThatContainsName = personSelectActivity.getFriendsThatContainsName();
                if (Thread.interrupted()) {
                    return;
                }
                personSelectActivity.safeRunOnUIThread(new Runnable() {
                    @Override
                    public final void run() {
                        AnonymousClass3 anonymousClass3 = AnonymousClass3.this;
                        boolean z5 = z;
                        ?? r0 = PersonSelectActivity.this;
                        if (z5 && z3) {
                            if (!StringUtils.x(((PersonSelectActivity) r0).contactsFullName)) {
                                r0.setSearchText(null);
                                return;
                            }
                            List list3 = friendsThatContainsName;
                            if (CollectionUtils.h(list3)) {
                                r0.updateList(list3);
                                return;
                            } else {
                                r0.setSearchText(null);
                                return;
                            }
                        }
                        List list4 = list2;
                        if (CollectionUtils.f(list4)) {
                            FeedbackManager.get().f(17, r0.getString(R.string.no_results));
                        }
                        r0.updateList(list4);
                        if (((PersonSelectActivity) r0).openProfileIfSingleResult && ((PersonSelectActivity) r0).personSelectAdapter.getItemCount() == 1) {
                            ((PersonSelectActivity) r0).openProfileIfSingleResult = false;
                            ((AnonymousClass1) ((PersonSelectActivity) r0).itemSelectListener).a(((PersonSelectActivity) r0).personSelectAdapter.getItem(0));
                        }
                    }
                });
            }
        }, !this.hasResult, z2);
    }

    private void runInSafeBackgroundThread(Runnable runnable, boolean z) {
        runInSafeBackgroundThread(runnable, z, false);
    }

    private void runInSafeBackgroundThread(final Runnable runnable, boolean z, boolean z2) {
        final Thread thread = new Thread() {
            @Override
            public final void run() {
                ?? r0 = PersonSelectActivity.this;
                try {
                    try {
                        try {
                            ((PersonSelectActivity) r0).remoteAccountHelper.getHostToCheck();
                            if (HttpUtils.b()) {
                                runnable.run();
                            } else {
                                FeedbackManager.j(r0);
                            }
                        } catch (SearchIsNotAvailableExecption e) {
                            r0.handleSearchException(e, Activities.f(R.string.search_is_not_available, ((PersonSelectActivity) r0).socialNetworkName), false);
                        } catch (UnauthorizedAccessErrorException e2) {
                            r0.handleSearchException(e2, R.string.unknown_error_message, true);
                        }
                    } catch (QuotaReachedException unused) {
                        r0.safeRunOnUIThread(new Runnable() {
                            @Override
                            public final void run() {
                                AnonymousClass4 anonymousClass4 = AnonymousClass4.this;
                                PersonSelectActivity.this.showFriendsAsync();
                                FeedbackManager.get().f(17, Activities.f(R.string.to_search_all_of_s_try_again_later, PersonSelectActivity.this.socialNetworkName));
                            }
                        });
                    } catch (RuntimeException e3) {
                        r0.handleSearchException(e3, R.string.unknown_error_message, false);
                        AnalyticsManager.get().o(Constants.FAILED, "Person Select Search Failed");
                    }
                } finally {
                    SimpleProgressDialog.m(((PersonSelectActivity) r0).searchingProgressDialog);
                }
            }
        };
        if (z) {
            SimpleProgressDialog simpleProgressDialog = new SimpleProgressDialog();
            this.searchingProgressDialog = simpleProgressDialog;
            simpleProgressDialog.setMessage(Activities.getString(R.string.searching));
            this.searchingProgressDialog.setCancelable(true);
            this.searchingProgressDialog.setDialogCustomListener(new PersonSelectDialogSimpleListener(thread, 0));
            PopupManager.get().c(this, this.searchingProgressDialog, true);
        } else {
            this.searchingProgressDialog = null;
        }
        thread.setDaemon(true);
        thread.start();
        if (z2) {
            this.searchThreadStopper = new Task() {
                @Override
                public final void doTask() {
                    Thread thread2 = thread;
                    if (!thread2.isAlive() || thread2.isInterrupted()) {
                        return;
                    }
                    thread2.interrupt();
                    FeedbackManager.get().f(17, Activities.getString(R.string.unknown_error_message));
                    PersonSelectActivity personSelectActivity = PersonSelectActivity.this;
                    SimpleProgressDialog.m(personSelectActivity.searchingProgressDialog);
                    personSelectActivity.showFilteredFriendListAsync("");
                }
            }.schedule(15000);
        }
    }

    public void handleSearchException(Exception exc, int i, boolean z) {
        handleSearchException(exc, Activities.getString(i), z);
    }
}