public virtual void onAliasOperatorResult(Context context, JPushMessage jPushMessage)
        {
            int sequence = jPushMessage.Sequence;

            Logger.i(TAG, "action - onAliasOperatorResult, sequence:" + sequence + ",alias:" + jPushMessage.Alias);
            init(context);
            //根据sequence从之前操作缓存中获取缓存记录
            TagAliasBean tagAliasBean = (TagAliasBean)setActionCache.Get(sequence);

            if (tagAliasBean == null)
            {
                ExampleUtil.showToast("获取缓存记录失败", context);
                return;
            }
            if (jPushMessage.ErrorCode == 0)
            {
                Logger.i(TAG, "action - modify alias Success,sequence:" + sequence);
                setActionCache.Remove(sequence);
                string logs = getActionStr(tagAliasBean.action) + " alias success";
                Logger.i(TAG, logs);
                ExampleUtil.showToast(logs, context);
            }
            else
            {
                string logs = "Failed to " + getActionStr(tagAliasBean.action) + " alias, errorCode:" + jPushMessage.ErrorCode;
                Logger.e(TAG, logs);
                if (!RetryActionIfNeeded(jPushMessage.ErrorCode, tagAliasBean))
                {
                    ExampleUtil.showToast(logs, context);
                }
            }
        }
        public virtual void init(Context context)
        {
            if (context != null)
            {
                this.context = context.ApplicationContext;
            }

            delaySendHandler = new Handler((Message msg) =>
            {
                switch (msg.What)
                {
                case DELAY_SEND_ACTION:
                    if (msg.Obj != null && msg.Obj is TagAliasBean)
                    {
                        Logger.i(TAG, "on delay time");
                        sequence++;
                        TagAliasBean tagAliasBean = (TagAliasBean)msg.Obj;
                        setActionCache.Put(sequence, tagAliasBean);
                        if (context != null)
                        {
                            handleAction(context, sequence, tagAliasBean);
                        }
                        else
                        {
                            Logger.e(TAG, "#unexcepted - context was null");
                        }
                    }
                    else
                    {
                        Logger.w(TAG, "#unexcepted - msg obj was incorrect");
                    }
                    break;

                case DELAY_SET_MOBILE_NUMBER_ACTION:
                    if (msg.Obj != null && msg.Obj is string)
                    {
                        Logger.i(TAG, "retry set mobile number");
                        sequence++;
                        string mobileNumber = (string)msg.Obj;
                        setActionCache.Put(sequence, mobileNumber);
                        if (context != null)
                        {
                            handleAction(context, sequence, mobileNumber);
                        }
                        else
                        {
                            Logger.e(TAG, "#unexcepted - context was null");
                        }
                    }
                    else
                    {
                        Logger.w(TAG, "#unexcepted - msg obj was incorrect");
                    }
                    break;
                }
            });
        }
        public virtual void onTagOperatorResult(Context context, JPushMessage jPushMessage)
        {
            int sequence = jPushMessage.Sequence;

            Logger.i(TAG, "action - onTagOperatorResult, sequence:" + sequence + ",tags:" + jPushMessage.Tags);
            Logger.i(TAG, "tags size:" + jPushMessage.Tags.Count);
            init(context);
            //根据sequence从之前操作缓存中获取缓存记录
            TagAliasBean tagAliasBean = (TagAliasBean)setActionCache.Get(sequence);

            if (tagAliasBean == null)
            {
                ExampleUtil.showToast("获取缓存记录失败", context);
                return;
            }
            if (jPushMessage.ErrorCode == 0)
            {
                Logger.i(TAG, "action - modify tag Success,sequence:" + sequence);
                setActionCache.Remove(sequence);
                string logs = getActionStr(tagAliasBean.action) + " tags success";
                Logger.i(TAG, logs);
                ExampleUtil.showToast(logs, context);
            }
            else
            {
                string logs = "Failed to " + getActionStr(tagAliasBean.action) + " tags";
                if (jPushMessage.ErrorCode == 6018)
                {
                    //tag数量超过限制,需要先清除一部分再add
                    logs += ", tags is exceed limit need to clean";
                }
                logs += ", errorCode:" + jPushMessage.ErrorCode;
                Logger.e(TAG, logs);
                if (!RetryActionIfNeeded(jPushMessage.ErrorCode, tagAliasBean))
                {
                    ExampleUtil.showToast(logs, context);
                }
            }
        }
 private bool RetryActionIfNeeded(int errorCode, TagAliasBean tagAliasBean)
 {
     if (!ExampleUtil.isConnected(context))
     {
         Logger.w(TAG, "no network");
         return(false);
     }
     //返回的错误码为6002 超时,6014 服务器繁忙,都建议延迟重试
     if (errorCode == 6002 || errorCode == 6014)
     {
         Logger.d(TAG, "need retry");
         if (tagAliasBean != null)
         {
             Message message = new Message();
             message.What = DELAY_SEND_ACTION;
             message.Obj  = tagAliasBean;
             delaySendHandler.SendMessageDelayed(message, 1000 * 60);
             string logs = getRetryStr(tagAliasBean.isAliasAction, tagAliasBean.action, errorCode);
             ExampleUtil.showToast(logs, context);
             return(true);
         }
     }
     return(false);
 }
        /// <summary>
        /// 处理设置tag
        ///
        /// </summary>
        public virtual void handleAction(Context context, int sequence, TagAliasBean tagAliasBean)
        {
            init(context);
            if (tagAliasBean == null)
            {
                Logger.w(TAG, "tagAliasBean was null");
                return;
            }
            put(sequence, tagAliasBean);
            if (tagAliasBean.isAliasAction)
            {
                switch (tagAliasBean.action)
                {
                case ACTION_GET:
                    JPushInterface.GetAlias(context, sequence);
                    break;

                case ACTION_DELETE:
                    JPushInterface.DeleteAlias(context, sequence);
                    break;

                case ACTION_SET:
                    JPushInterface.SetAlias(context, sequence, tagAliasBean.alias);
                    break;

                default:
                    Logger.w(TAG, "unsupport alias action type");
                    return;
                }
            }
            else
            {
                switch (tagAliasBean.action)
                {
                case ACTION_ADD:
                    JPushInterface.AddTags(context, sequence, tagAliasBean.tags);
                    break;

                case ACTION_SET:
                    JPushInterface.SetTags(context, sequence, tagAliasBean.tags);
                    break;

                case ACTION_DELETE:
                    JPushInterface.DeleteTags(context, sequence, tagAliasBean.tags);
                    break;

                case ACTION_CHECK:
                    //一次只能check一个tag
                    string tag = (string)tagAliasBean.tags[0];
                    JPushInterface.CheckTagBindState(context, sequence, tag);
                    break;

                case ACTION_GET:
                    JPushInterface.GetAllTags(context, sequence);
                    break;

                case ACTION_CLEAN:
                    JPushInterface.CleanTags(context, sequence);
                    break;

                default:
                    Logger.w(TAG, "unsupport tag action type");
                    return;
                }
            }
        }
示例#6
0
        /// <summary>
        ///===========================================================================* </summary>
        /// <summary>
        ///=========================TAG/ALIAS 相关=====================================* </summary>
        /// <summary>
        ///===========================================================================* </summary>

        /// <summary>
        /// 处理tag/alias相关操作的点击
        ///
        /// </summary>
        public virtual void onTagAliasAction(View view)
        {
            ISet <string> tags          = null;
            string        alias         = null;
            int           action        = -1;
            bool          isAliasAction = false;

            switch (view.Id)
            {
            //设置手机号码:
            case R.id.bt_setmobileNumber:
                handleSetMobileNumber();
                return;

            //增加tag
            case R.id.bt_addtag:
                tags = InPutTags;
                if (tags == null)
                {
                    return;
                }
                action = ACTION_ADD;
                break;

            //设置tag
            case R.id.bt_settag:
                tags = InPutTags;
                if (tags == null)
                {
                    return;
                }
                action = ACTION_SET;
                break;

            //删除tag
            case R.id.bt_deletetag:
                tags = InPutTags;
                if (tags == null)
                {
                    return;
                }
                action = ACTION_DELETE;
                break;

            //获取所有tag
            case R.id.bt_getalltag:
                action = ACTION_GET;
                break;

            //清除所有tag
            case R.id.bt_cleantag:
                action = ACTION_CLEAN;
                break;

            case R.id.bt_checktag:
                tags = InPutTags;
                if (tags == null)
                {
                    return;
                }
                action = ACTION_CHECK;
                break;

            //设置alias
            case R.id.bt_setalias:
                alias = InPutAlias;
                if (TextUtils.isEmpty(alias))
                {
                    return;
                }
                isAliasAction = true;
                action        = ACTION_SET;
                break;

            //获取alias
            case R.id.bt_getalias:
                isAliasAction = true;
                action        = ACTION_GET;
                break;

            //删除alias
            case R.id.bt_deletealias:
                isAliasAction = true;
                action        = ACTION_DELETE;
                break;

            default:
                return;
            }
            TagAliasBean tagAliasBean = new TagAliasBean();

            tagAliasBean.action = action;
            sequence++;
            if (isAliasAction)
            {
                tagAliasBean.alias = alias;
            }
            else
            {
                tagAliasBean.tags = tags;
            }
            tagAliasBean.isAliasAction = isAliasAction;
            TagAliasOperatorHelper.Instance.handleAction(ApplicationContext, sequence, tagAliasBean);
        }