智能工厂.apk(点击下载) / c.java


package cn.jpush.android.s;

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import cn.jpush.android.api.CallBackParams;
import cn.jpush.android.api.JPushInterface;
import cn.jpush.android.api.JPushMessage;
import cn.jpush.android.helper.Logger;
import cn.jpush.android.service.TagAliasReceiver;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;

public class c {
    private static volatile c a;
    private static final Object d = new Object();
    private TagAliasReceiver b;
    private ConcurrentHashMap<Long, CallBackParams> c = new ConcurrentHashMap<>();
    private AtomicBoolean e = new AtomicBoolean(false);

    private c() {
    }

    public static c a() {
        if (a == null) {
            synchronized (d) {
                if (a == null) {
                    a = new c();
                }
            }
        }
        return a;
    }

    private String a(CallBackParams callBackParams) {
        if (callBackParams == null) {
            Logger.w("TagAliasOperator", "callBack was null");
            return null;
        }
        try {
            if (callBackParams.tags != null && callBackParams.tags.size() > 0) {
                return (String) callBackParams.tags.toArray()[0];
            }
        } catch (Throwable th) {
            Logger.d("TagAliasOperator", "get origin check tag failed, error:" + th);
        }
        return null;
    }

    private void a(Context context, int i, long j) {
        String str;
        String str2;
        if (i == JPushInterface.ErrorCode.TIMEOUT) {
            str2 = "TagAliasOperator";
            str = "action - onTimeout rid:" + j;
        } else {
            str2 = "TagAliasOperator";
            str = "action - on send data over limit";
        }
        Logger.v(str2, str);
        CallBackParams a2 = a(j);
        if (a2 == null) {
            Logger.w("TagAliasOperator", "tagalias callback is null; rid=" + j);
            return;
        }
        b(j);
        a(context, a2, i, false);
    }

    private void a(Context context, int i, long j, Intent intent) {
        String str;
        String str2;
        Logger.v("TagAliasOperator", "SetAliasAndTags finish : errorCode:" + i + " rid:" + j);
        CallBackParams a2 = a(j);
        if (a2 == null) {
            Logger.w("TagAliasOperator", "tagalias callback is null; rid=" + j);
            return;
        }
        a().b(j);
        boolean z = false;
        if (intent != null) {
            try {
                if (a2.action == 5) {
                    if (a2.protoType == 1) {
                        ArrayList<String> stringArrayListExtra = intent.getStringArrayListExtra("tags");
                        if (stringArrayListExtra != null) {
                            a2.tags = new HashSet(stringArrayListExtra);
                            str = "TagAliasOperator";
                            str2 = "all tags was loaded, value:" + a2.tags;
                        }
                    } else if (a2.protoType == 2) {
                        a2.alias = intent.getStringExtra("alias");
                        str = "TagAliasOperator";
                        str2 = "alias was loaded, value:" + a2.tags;
                    }
                    Logger.d(str, str2);
                } else if (a2.action == 6) {
                    z = intent.getBooleanExtra("validated", false);
                }
            } catch (Throwable th) {
                Logger.d("TagAliasOperator", "get tag or alias failed - error:" + th);
            }
        }
        a(context, a2, i, z);
    }

    private void a(Context context, CallBackParams callBackParams, int i, boolean z) {
        Logger.d("TagAliasOperator", "action - invokeUserCallback, errorCode:" + i + ",callBack:" + callBackParams);
        if (callBackParams.protoType != 0) {
            Logger.w("TagAliasOperator", "new proto type do not call user callback");
        } else if (callBackParams.tagAliasCallBack != null) {
            callBackParams.tagAliasCallBack.gotResult(i, callBackParams.alias, callBackParams.tags);
        }
    }

    private void c(Context context) {
        ConcurrentHashMap<Long, CallBackParams> concurrentHashMap = this.c;
        if (!(concurrentHashMap == null || concurrentHashMap.isEmpty())) {
            ArrayList arrayList = new ArrayList();
            for (Map.Entry<Long, CallBackParams> entry : this.c.entrySet()) {
                if (entry.getValue().isTimeOut(20000)) {
                    arrayList.add(entry.getKey());
                }
            }
            Iterator it = arrayList.iterator();
            while (it.hasNext()) {
                Long l = (Long) it.next();
                Logger.w("TagAliasOperator", "cleanTimeOutCallback timeout rid:" + l);
                a(context, JPushInterface.ErrorCode.TIMEOUT, l.longValue());
            }
        }
    }

    public CallBackParams a(long j) {
        return this.c.get(Long.valueOf(j));
    }

    public JPushMessage a(Context context, Intent intent) {
        String str;
        String str2;
        long longExtra = intent.getLongExtra(TagAliasReceiver.KEY_TAGALIASOPERATOR_SEQID, -1);
        boolean z = false;
        int intExtra = intent.getIntExtra(TagAliasReceiver.KEY_TAGALIASOPERATOR_CALLBACKCODE, 0);
        Logger.v("TagAliasOperator", "parseTagAliasResponse2JPushMessage, errorCode:" + intExtra + " rid:" + longExtra);
        CallBackParams a2 = a(longExtra);
        if (a2 == null) {
            Logger.w("TagAliasOperator", "tagalias callback is null; rid=" + longExtra);
            return null;
        }
        a().b(longExtra);
        if (intExtra == 0) {
            try {
                if (a2.action == 5) {
                    if (a2.protoType == 1) {
                        ArrayList<String> stringArrayListExtra = intent.getStringArrayListExtra("tags");
                        if (stringArrayListExtra != null) {
                            a2.tags = new HashSet(stringArrayListExtra);
                            str = "TagAliasOperator";
                            str2 = "all tags was loaded, value:" + a2.tags;
                        }
                    } else if (a2.protoType == 2) {
                        a2.alias = intent.getStringExtra("alias");
                        str = "TagAliasOperator";
                        str2 = "alias was loaded, value:" + a2.tags;
                    }
                    Logger.d(str, str2);
                } else if (a2.action == 6) {
                    z = intent.getBooleanExtra("validated", false);
                }
            } catch (Throwable th) {
                Logger.d("TagAliasOperator", "get tag or alias failed - error:" + th);
            }
        }
        JPushMessage jPushMessage = new JPushMessage();
        jPushMessage.setErrorCode(intExtra);
        jPushMessage.setSequence(a2.sequence);
        if (a2.protoType != 1) {
            jPushMessage.setAlias(a2.alias);
        } else if (a2.action == 6) {
            jPushMessage.setCheckTag(a(a2));
            jPushMessage.setTagCheckStateResult(z);
            jPushMessage.setTagCheckOperator(true);
        } else {
            jPushMessage.setTags(a2.tags);
        }
        return jPushMessage;
    }

    public synchronized void a(Context context) {
        if (!this.e.get()) {
            try {
                IntentFilter intentFilter = new IntentFilter();
                intentFilter.addCategory(context.getPackageName());
                intentFilter.addAction(TagAliasReceiver.ACTION_TAG_ALIAS_TIMEOUT);
                intentFilter.addAction(TagAliasReceiver.ACTION_TAG_ALIAS_CALLBACK);
                if (this.b == null) {
                    this.b = new TagAliasReceiver();
                }
                context.registerReceiver(this.b, intentFilter);
                this.e.set(true);
            } catch (Exception e2) {
                Logger.e("TagAliasOperator", "setTagAndAlias e:" + e2.getMessage());
            }
        } else {
            Logger.d("TagAliasOperator", "tag alias callback register is called");
        }
    }

    public void a(Context context, long j, int i, Intent intent) {
        Logger.v("TagAliasOperator", "action - onTagAliasResponse rid:" + j + " tagAliasCallbacks :" + a().b());
        if (TagAliasReceiver.ACTION_TAG_ALIAS_TIMEOUT.equals(intent.getAction())) {
            a(context, i, j);
        } else {
            a(context, i, j, intent);
        }
        b(context);
    }

    public void a(Context context, Long l, CallBackParams callBackParams) {
        c(context);
        this.c.put(l, callBackParams);
    }

    public ConcurrentHashMap<Long, CallBackParams> b() {
        return this.c;
    }

    public void b(long j) {
        this.c.remove(Long.valueOf(j));
    }

    public synchronized void b(Context context) {
        String str;
        String str2;
        String str3;
        String str4;
        c(context);
        if (!this.e.get() || this.c == null || !this.c.isEmpty()) {
            str = "TagAliasOperator";
            str2 = "tagAliasCallbacks is not empty";
        } else {
            try {
                if (this.b != null) {
                    context.unregisterReceiver(this.b);
                    this.b = null;
                }
            } catch (IllegalArgumentException e2) {
                e = e2;
                str3 = "TagAliasOperator";
                str4 = "Receiver not registered, cannot call unregisterReceiver";
                Logger.ww(str3, str4, e);
                this.e.set(false);
                str = "TagAliasOperator";
                str2 = "unRegister tag alias callback";
                Logger.v(str, str2);
            } catch (Exception e3) {
                e = e3;
                str3 = "TagAliasOperator";
                str4 = "other exception";
                Logger.ww(str3, str4, e);
                this.e.set(false);
                str = "TagAliasOperator";
                str2 = "unRegister tag alias callback";
                Logger.v(str, str2);
            }
            this.e.set(false);
            str = "TagAliasOperator";
            str2 = "unRegister tag alias callback";
        }
        Logger.v(str, str2);
    }
}