极光推送集成与封装

说明:这里以目前官网最新版V3.0.9为例,从V3.0.7开始使用新别名与标签接口:
public static void setAlias(Context context, int sequence, String alias);
参数定义:
sequence:用户自定义的操作序列号, 同操作结果一起返回,用来标识一次操作的唯一性。
alias:每次调用设置有效的别名,覆盖之前的设置。
有效的别名组成:字母(区分大小写)、数字、下划线、汉字、特殊字符@!#$&*+=.|。
限制:alias 命名长度限制为 40 字节。(判断长度需采用UTF-8编码)
一、集成
按照极光推送开发文档进行集成配置这里不多说。
二、对Jpush初始化、设置别名、签名等进行封装

package lc.com.car;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.util.SparseArray;
import android.widget.Toast;

import java.util.Locale;
import java.util.Set;

import cn.jpush.android.api.JPushInterface;
import cn.jpush.android.api.JPushMessage;

/**
 * @author lingfeng 2017/12/21 16:58
 */

public class JPushManager {
    private static final String TAG = "JPUSH-SetAliasAndTags";
    public static int sequence = 1;
    /**
     * 增加
     */
    public static final int ACTION_ADD = 1;
    /**
     * 覆盖
     */
    public static final int ACTION_SET = 2;
    /**
     * 删除部分
     */
    public static final int ACTION_DELETE = 3;
    /**
     * 删除所有
     */
    public static final int ACTION_CLEAN = 4;
    /**
     * 查询
     */
    public static final int ACTION_GET = 5;

    public static final int ACTION_CHECK = 6;

    public static final int DELAY_SEND_ACTION = 1;
    private Context context;
    private TagAliasBean tagAliasBean = new TagAliasBean();

    private static JPushManager mInstance;

    private JPushManager() {
    }

    public static JPushManager getInstance() {
        if (mInstance == null) {
            synchronized (JPushManager.class) {
                if (mInstance == null) {
                    mInstance = new JPushManager();
                }
            }
        }
        return mInstance;
    }

    private void init(Context context) {
        if (context != null) {
            this.context = context.getApplicationContext();
        }
    }

    private SparseArray<TagAliasBean> tagAliasActionCache = new SparseArray<TagAliasBean>();


    /**
     * 初始化极光,一般可以放到程序的启动Activity或是Application的onCreate方法中调用
     *
     * @param b 设置是否开启日志,发布时请关闭日志RedDotImageView.java
     */
    public void initJPush(Context context, boolean b) {
        JPushInterface.setDebugMode(b); // 设置开启日志,发布时请关闭日志
        JPushInterface.init(context); // 初始化 JPush
    }

    /**
     * 退出极光,一般是程序退出登录时候,具体还是需要看项目的实际需求
     */
    public void stopJPush() {
        JPushInterface.stopPush(context);//调用了本方法后,JPush 推送服务完全被停止.所有的其他 API 调用都无效,不能通过 JPushInterface.init 恢复,需要调用resumePush恢复。
//        setAliasAndTags("", "");//通过清空别名来停止极光
    }

    public void resumePush() {
        JPushInterface.resumePush(context);
    }

    /**
     * 设置极光推送app别名
     * 用于给某特定用户推送消息。别名,可以近似地被认为,是用户帐号里的昵称 使用标签
     * 覆盖逻辑,而不是增量逻辑。即新的调用会覆盖之前的设置。
     *
     * @param alias
     */
    public void setAlias(Context conn, String alias) {

//        tagAliasBean.action = ACTION_SET;
//        tagAliasBean.isAliasAction = true;
//        tagAliasBean.alias =alias;
        setTagAliasBean(ACTION_SET, alias, null, true);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 删除极光推送app别名
     */
    public void deleteAlias(Context conn) {

//        tagAliasBean.action = ACTION_DELETE;
//        tagAliasBean.isAliasAction = true;
        setTagAliasBean(ACTION_DELETE, null, null, true);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 获取极光推送app别名
     */
    public void getAlias(Context conn) {
        setTagAliasBean(ACTION_GET, null, null, true);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 设置标签
     * 用于给某一群人推送消息。标签类似于博客里为文章打上 tag ,即为某资源分类。
     */
    public void setTags(Context conn, Set<String> Tags) {
        setTagAliasBean(ACTION_SET, null, Tags, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 添加标签
     */
    public void addTags(Context conn, Set<String> Tags) {
        setTagAliasBean(ACTION_ADD, null, Tags, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 删除标签
     */
    public void deleteTags(Context conn, Set<String> Tags) {
        setTagAliasBean(ACTION_DELETE, null, Tags, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 删除所有标签
     */
    public void cleanTags(Context conn) {
        setTagAliasBean(ACTION_CLEAN, null, null, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 获取所有标签
     */
    public void getAllTags(Context conn) {
        setTagAliasBean(ACTION_GET, null, null, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    /**
     * 查询标签状态
     */
    public void checkTags(Context conn, Set<String> Tags) {
        setTagAliasBean(ACTION_CHECK, null, Tags, false);
        setAliasAndTags(conn, tagAliasBean);
    }

    public void put(int sequence, TagAliasBean tagAliasBean) {
        tagAliasActionCache.put(sequence, tagAliasBean);
    }

    private Handler delaySendHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case DELAY_SEND_ACTION:
                    if (msg.obj != null && msg.obj instanceof TagAliasBean) {
                        Log.i(TAG, "on delay time");
                        sequence++;
                        TagAliasBean tagAliasBean = (TagAliasBean) msg.obj;
                        tagAliasActionCache.put(sequence, tagAliasBean);
                        if (context != null) {
                            //setAliasAndTags 里的sequence会再自增一次,保持和上面的sequence一致这里再自减一次
                            sequence--;
                            setAliasAndTags(context, tagAliasBean);
                        } else {
                            Log.i(TAG, "#unexcepted - context was null");
                        }
                    } else {
                        Log.i(TAG, "#unexcepted - msg obj was incorrect");
                    }
                    break;
            }
        }
    };


    public void setAliasAndTags(Context context, TagAliasBean tagAliasBean) {

        init(context);
        if (tagAliasBean == null) {
            Log.i(TAG, "setAliasAndTags时tagAliasBean为null");
            return;
        }
        sequence++;
        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:
                    Log.i(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.toArray()[0];
                    JPushInterface.checkTagBindState(context, sequence, tag);
                    break;
                case ACTION_GET:
                    JPushInterface.getAllTags(context, sequence);
                    break;
                case ACTION_CLEAN:
                    JPushInterface.cleanTags(context, sequence);
                    break;
                default:
                    Log.i(TAG, "unsupport tag action type");
                    return;
            }
        }
    }

    public void onTagOperatorResult(Context context, JPushMessage jPushMessage) {
        int sequence = jPushMessage.getSequence();
        Log.i(TAG, "action - onTagOperatorResult, sequence:" + sequence + ",tags:" + jPushMessage.getTags());
        Log.i(TAG, "tags size:" + jPushMessage.getTags().size());
        init(context);
        //根据sequence从之前操作缓存中获取缓存记录
        TagAliasBean tagAliasBean = tagAliasActionCache.get(sequence);
        if (tagAliasBean == null) {


            return;
        }
        if (jPushMessage.getErrorCode() == 0) {
            Log.i(TAG, "action - modify tag Success,sequence:" + sequence);
            tagAliasActionCache.remove(sequence);
            String logs = getActionStr(tagAliasBean.action) + " tags success";
            Log.i(TAG, logs);
            Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();
        } else {
            String logs = "Failed to " + getActionStr(tagAliasBean.action) + " tags";
            if (jPushMessage.getErrorCode() == 6018) {
                //tag数量超过限制,需要先清除一部分再add
                logs += ", tags is exceed limit need to clean";
            }
            logs += ", errorCode:" + jPushMessage.getErrorCode();
            Log.i(TAG, logs);
            if (!RetryActionIfNeeded(jPushMessage.getErrorCode(), tagAliasBean)) {
                Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();

            }
        }
    }

    public void onCheckTagOperatorResult(Context context, JPushMessage jPushMessage) {
        int sequence = jPushMessage.getSequence();
        Log.i(TAG, "action - onCheckTagOperatorResult, sequence:" + sequence + ",checktag:" + jPushMessage.getCheckTag());
        init(context);
        //根据sequence从之前操作缓存中获取缓存记录
        TagAliasBean tagAliasBean = tagAliasActionCache.get(sequence);
        if (tagAliasBean == null) {
            Toast.makeText(context, "获取缓存记录失败", Toast.LENGTH_SHORT).show();

            return;
        }
        if (jPushMessage.getErrorCode() == 0) {
            Log.i(TAG, "tagBean:" + tagAliasBean);
            tagAliasActionCache.remove(sequence);
            String logs = getActionStr(tagAliasBean.action) + " tag " + jPushMessage.getCheckTag() + " bind state success,state:" + jPushMessage.getTagCheckStateResult();
            Log.i(TAG, logs);
            Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();

        } else {
            String logs = "Failed to " + getActionStr(tagAliasBean.action) + " tags, errorCode:" + jPushMessage.getErrorCode();
            Log.i(TAG, logs);
            if (!RetryActionIfNeeded(jPushMessage.getErrorCode(), tagAliasBean)) {
                Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();

            }
        }
    }

    public void onAliasOperatorResult(Context context, JPushMessage jPushMessage) {
        int sequence = jPushMessage.getSequence();
        Log.i(TAG, "action - onAliasOperatorResult, sequence:" + sequence + ",alias:" + jPushMessage.getAlias());
        setCurrentAlias(jPushMessage.getAlias());
        init(context);
        //根据sequence从之前操作缓存中获取缓存记录
        TagAliasBean tagAliasBean = tagAliasActionCache.get(sequence);
        if (tagAliasBean == null) {
            Toast.makeText(context, "获取缓存记录失败", Toast.LENGTH_SHORT).show();
            return;
        }
        if (jPushMessage.getErrorCode() == 0) {
            Log.i(TAG, "action - modify alias Success,sequence:" + sequence);
            tagAliasActionCache.remove(sequence);
            String logs = getActionStr(tagAliasBean.action) + " alias success";
            Log.i(TAG, logs);
            Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();
        } else {
            String logs = "Failed to " + getActionStr(tagAliasBean.action) + " alias, errorCode:" + jPushMessage.getErrorCode();
            Log.i(TAG, logs);
            if (!RetryActionIfNeeded(jPushMessage.getErrorCode(), tagAliasBean)) {
                Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();
            }
        }
    }

    private String onAliasOperatorResultAlias;

    private void setCurrentAlias(String alias) {
        Log.i(TAG, "我后执行");
        this.onAliasOperatorResultAlias = alias;
    }

    public String getOnAliasOperatorResultAlias() {
        Log.i(TAG, "我先执行");
        return onAliasOperatorResultAlias;
    }

    /**
     * 设置 TagAliasBean
     *
     * @param action        目标操作
     * @param alias
     * @param tags
     * @param isAliasAction true 设置alias ;false设置tags
     */
    private void setTagAliasBean(int action, String alias, Set<String> tags, boolean isAliasAction) {

        tagAliasBean.action = action;
        tagAliasBean.alias = alias;
        tagAliasBean.tags = tags;
        tagAliasBean.isAliasAction = isAliasAction;

    }

    private boolean RetryActionIfNeeded(int errorCode, TagAliasBean tagAliasBean) {
        if (isConnected(context)) {
            Log.i(TAG, "no network");
            return false;
        }
        //返回的错误码为6002 超时,6014 服务器繁忙,都建议延迟重试
        if (errorCode == 6002 || errorCode == 6014) {
            Log.i(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);
                Toast.makeText(context, logs, Toast.LENGTH_SHORT).show();
                return true;
            }
        }
        return false;
    }

    private String getRetryStr(boolean isAliasAction, int actionType, int errorCode) {
        String str = "Failed to %s %s due to %s. Try again after 60s.";
        str = String.format(Locale.ENGLISH, str, getActionStr(actionType), (isAliasAction ? "alias" : " tags"), (errorCode == 6002 ? "timeout" : "server too busy"));
        return str;
    }

    public static boolean isConnected(Context context) {
        ConnectivityManager conn = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = conn.getActiveNetworkInfo();
        return (info != null && info.isConnected());
    }

    private String getActionStr(int actionType) {
        switch (actionType) {
            case ACTION_ADD:
                return "add";
            case ACTION_SET:
                return "set";
            case ACTION_DELETE:
                return "delete";
            case ACTION_GET:
                return "get";
            case ACTION_CLEAN:
                return "clean";
            case ACTION_CHECK:
                return "check";
        }
        return "unkonw operation";
    }

    public static class TagAliasBean {
        int action;
        Set<String> tags;
        String alias;
        boolean isAliasAction;

        @Override
        public String toString() {
            return "TagAliasBean{" +
                    "action=" + action +
                    ", tags=" + tags +
                    ", alias='" + alias + '\'' +
                    ", isAliasAction=" + isAliasAction +
                    '}';
        }
    }
}

使用:
(1)在Application中调用JPushManager.getInstance().initJPush(getApplicationContext(), Constants.isDebug);
(2)一般在登录成功后使用自己的唯一ID设置aliasJPushManager.getInstance().setAlias(LoginActivity.this, user_id);
注意这里设置alias需要在主线程调用
(3)在需要删除alias地方调用JPushManager.getInstance().deleteAlias(context);移除alias,同样需要在主线程调用
三、tag/alias接口设置结果回调
从3.0.7开始提供了用户自定义接收消息器即JPushMessageReceiver,目前新tag/alias接口设置结果会在该广播接收器对应的方法中回调
1、创建MyJPushMessageReceiver继承JPushMessageReceiver

package lc.com.car.jpush;

import android.content.Context;

import cn.jpush.android.api.JPushMessage;
import cn.jpush.android.service.JPushMessageReceiver;

/**
 * 自定义JPush message 接收器,包括操作tag/alias的结果返回(仅仅包含tag/alias新接口部分)
 * */
public class MyJPushMessageReceiver extends JPushMessageReceiver {

    @Override
    public void onTagOperatorResult(Context context, JPushMessage jPushMessage) {
        JPushManager.getInstance().onTagOperatorResult(context,jPushMessage);
        super.onTagOperatorResult(context, jPushMessage);
    }
    @Override
    public void onCheckTagOperatorResult(Context context, JPushMessage jPushMessage){
        JPushManager.getInstance().onCheckTagOperatorResult(context,jPushMessage);
        super.onCheckTagOperatorResult(context, jPushMessage);
    }
    @Override
    public void onAliasOperatorResult(Context context, JPushMessage jPushMessage) {
        JPushManager.getInstance().onAliasOperatorResult(context,jPushMessage);
        super.onAliasOperatorResult(context, jPushMessage);
    }
}

2、在Manifest.xml里面注册MyJPushMessageReceiver

 <receiver android:name="你自己MyJPushMessageReceiver的路径">
            <intent-filter>
                <action android:name="cn.jpush.android.intent.RECEIVE_MESSAGE" />
                <category android:name="${applicationId}"></category>
            </intent-filter>
  </receiver>

四、消息接收与处理
代码里面的LogData.i()和Utils.showToast();为自己封装的Log.i()和Toast自己换掉就好

package lc.com.car.jpush;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;


import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.Iterator;

import cn.jpush.android.api.JPushInterface;
import lc.com.car.utils.LogData;

/**
 * 自定义接收器
 * 
 * 如果不定义这个 Receiver,则:
 * 1) 默认用户会打开主界面
 * 2) 接收不到自定义消息
 */
public class MyReceiver extends BroadcastReceiver {
    private static final String TAG = "JPush";

    @Override
    public void onReceive(Context context, Intent intent) {
        Bundle bundle = intent.getExtras();
        Log.d(TAG, "[MyReceiver] onReceive - " + intent.getAction() + ", extras: " + printBundle(bundle));


        if (JPushInterface.ACTION_REGISTRATION_ID.equals(intent.getAction())) {
            String regId = bundle.getString(JPushInterface.EXTRA_REGISTRATION_ID);
            Log.d(TAG, "[MyReceiver] 接收Registration Id : " + regId);
            //send the Registration Id to your server...

        } else if (JPushInterface.ACTION_MESSAGE_RECEIVED.equals(intent.getAction())) {
            Log.d(TAG, "[MyReceiver] 接收到推送下来的自定义消息: " + bundle.getString(JPushInterface.EXTRA_MESSAGE));
//          processCustomMessage(context, bundle);

        } else if (JPushInterface.ACTION_NOTIFICATION_RECEIVED.equals(intent.getAction())) {
            Log.d(TAG, "[MyReceiver] 接收到推送下来的通知");
            int notifactionId = bundle.getInt(JPushInterface.EXTRA_NOTIFICATION_ID);
            Log.d(TAG, "[MyReceiver] 接收到推送下来的通知的ID: " + notifactionId);


        } else if (JPushInterface.ACTION_NOTIFICATION_OPENED.equals(intent.getAction())) {
            Log.d(TAG, "[MyReceiver] 用户点击打开了通知");

            //打开自定义的Activity
//          Intent i = new Intent(context, TestActivity.class);
//          i.putExtras(bundle);
//          //i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
//          i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP );
//          context.startActivity(i);

        } else if (JPushInterface.ACTION_RICHPUSH_CALLBACK.equals(intent.getAction())) {
            Log.d(TAG, "[MyReceiver] 用户收到到RICH PUSH CALLBACK: " + bundle.getString(JPushInterface.EXTRA_EXTRA));
            //在这里根据 JPushInterface.EXTRA_EXTRA 的内容处理代码,比如打开新的Activity, 打开一个网页等..

        } else if(JPushInterface.ACTION_CONNECTION_CHANGE.equals(intent.getAction())) {
            boolean connected = intent.getBooleanExtra(JPushInterface.EXTRA_CONNECTION_CHANGE, false);
            Log.w(TAG, "[MyReceiver]" + intent.getAction() +" connected state change to "+connected);
        } else {
            Log.d(TAG, "[MyReceiver] Unhandled intent - " + intent.getAction());
        }
    }
    // 打印所有的 intent extra 数据    cn.jpush.android.ALERT=ddddd
    private static String printBundle(Bundle bundle) {
        StringBuilder sb = new StringBuilder();
        for (String key : bundle.keySet()) {
            if (key.equals(JPushInterface.EXTRA_NOTIFICATION_ID)) {
                sb.append("\nkey:" + key + ", value:" + bundle.getInt(key));
            }else if(key.equals(JPushInterface.EXTRA_CONNECTION_CHANGE)){
                sb.append("\nkey:" + key + ", value:" + bundle.getBoolean(key));
            } else if (key.equals(JPushInterface.EXTRA_EXTRA)) {
                if (bundle.getString(JPushInterface.EXTRA_EXTRA).isEmpty()) {
                    Log.i(TAG, "This message has no Extra data");
                    continue;
                }

                try {
                    JSONObject json = new JSONObject(bundle.getString(JPushInterface.EXTRA_EXTRA));
                    Iterator<String> it =  json.keys();

                    while (it.hasNext()) {
                        String myKey = it.next().toString();
                        sb.append("\nkey:" + key + ", value: [" +
                                myKey + " - " +json.optString(myKey) + "]");


                    }
                } catch (JSONException e) {
                    Log.e(TAG, "Get message extra JSON error!");
                }

            } else {
                sb.append("\nkey:" + key + ", value:" + bundle.getString(key));

                if (key.equals("cn.jpush.android.ALERT")){

                    //将推送过来的消息 保存到数据库中
//                  PushMessageBean bean = new PushMessageBean();
//                  bean.setContent(bundle.getString(key));
//
//                  ArrayList<PushMessageBean> list = new ArrayList<>();
//                  list.add(bean);
//                  Long insert = AppDao.getInstance().insertAll(list);
//                  LogData.i("JPushReceiver", insert > 0 ? "保存" + insert + "条数据成功" : "保存失败");
                    LogData.i("Jpush消息:"+bundle.getString(key));
                }


            }
        }
        LogData.i("Jpush消息:"+sb.toString());
        return sb.toString();
    }

    //send msg to MainActivity
//  private void processCustomMessage(Context context, Bundle bundle) {
//      if (MainActivity.isForeground) {
//          String message = bundle.getString(JPushInterface.EXTRA_MESSAGE);
//          String extras = bundle.getString(JPushInterface.EXTRA_EXTRA);
//          Intent msgIntent = new Intent(MainActivity.MESSAGE_RECEIVED_ACTION);
//          msgIntent.putExtra(MainActivity.KEY_MESSAGE, message);
//          if (!ExampleUtil.isEmpty(extras)) {
//              try {
//                  JSONObject extraJson = new JSONObject(extras);
//                  if (null != extraJson && extraJson.length() > 0) {
//                      msgIntent.putExtra(MainActivity.KEY_EXTRAS, extras);
//                  }
//              } catch (JSONException e) {
//
//              }
//
//          }
//          context.sendBroadcast(msgIntent);
//      }
//  }
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值