MTPush-API

              /**
     * 配置应用key，不使用AndroidManifest.xml中的配置
     *
     * 需要在Application.onCreate()方法中调用
     * 请在[init](#init)之前调用
     *
     * @param context 不为空
     * @param appKey 不为空
     */
    public static void configAppKey(Context context, String appKey)

        

          MTCorePrivatesApi.configAppKey(this,"你的appkey");

        

               /**
         * 配置应用渠道，不使用AndroidManifest.xml中的配置
         * 需要在Application.onCreate()方法中调用
         * 需在init前，并要在Application.onCreate内使用
         *
         * @param context    不为空
         * @param appChannel 不为空
         */
    public static void configAppChannel(Context context, String appChannel)

        

          MTCorePrivatesApi.configAppChannel(this,"你的appChannel");

        

              /**
     * 配置数据中心站点名称，不使用AndroidManifest.xml中的配置
     * 目前可选的节点有Singapore、USA_Virginia、DEU_Frankfurt和HongKong。
     * 需要在Application.onCreate()方法中调用
     * 请在[init](#init)之前调用
     *
     * @param context 不为空
     * @param appSiteName 不为空
     */
    public static void configAppSiteName(Context context, String appSiteName)

        

          MTCorePrivatesApi.configAppSiteName(this,"你的平台数据中心站点名称");

        

              /**
     * 设置心跳时间间隔
     *
     * 需要在Application.onCreate()方法中调用
     *
     * @param context 不为空
     * @param heartbeatInterval 时间单位为毫秒、必须大于0、默认值是4分50秒\
     */
    public static void configHeartbeatInterval(Context context, long heartbeatInterval)

        

          MTCorePrivatesApi.configHeartbeatInterval(this,3 * 60 * 1000);

        

              /**
     * 设置长连接重试次数
     *
     * 需要在Application.onCreate()方法中调用
     *
     * @param context 不为空
     * @param connectRetryCount 重试的次数、默认值为3、最少3次
     */
    public static void configConnectRetryCount(Context context, int connectRetryCount)

        

          MTCorePrivatesApi.configConnectRetryCount(this,10);

        

              /**
     * 设置长连接是否加密，默认不加密
     *
     * 需要在Application.onCreate()方法中调用
     *
     * @param isSSL true加密，false不加密
     */
    public static void setTcpSSl(Context context, boolean isSSL)

        

          MTCorePrivatesApi.setTcpSSl(context,true);

        

              /**
     * 设置是否debug模式，debug模式会打印更对详细日志
     *
     * 需要在Application.onCreate()方法中调用
     * 
     * @param context 不为空 
     * @param enable 是否调试模式，true为调试模式，false不是
     */
    public static void configDebugMode(Context context, boolean enable)

        

                  // 建议应用未上线时设置为true，方便集成
        MTCorePrivatesApi.configDebugMode(context.getApplicationContext(), true);
        
        // 建议应用上线后设置为false
        MTCorePrivatesApi.configDebugMode(context.getApplicationContext(), false);

        

              /**
     * 配置使用国密加密
     *
     * @param context 不为空
     */
    public static void configSM4(Context context)

        

              // 开启国密加密，不调用则使用默认加密方式
    MTCorePrivatesApi.configSM4(context.getApplicationContext());

        

              /**
     * 获取当前设备的userId，Engagelab唯一标识，可同于推送
     *
     * @param context 不为空
     * @return userId
     */
    public static String getUserId(Context context)

        

          String userId = MTCorePrivatesApi.getUserId(context);

        

              /**
     * 获取当前设备的registrationId，Engagelab唯一标识，可同于推送
     *
     * @param context 不为空
     * @return registrationId
     */
    public static String getRegistrationId(Context context)

        

          String registrationId = MTCorePrivatesApi.getRegistrationId(context);

        

              /**
     * 配置push版本号为3.9.X
     *
     * @param context 不为空
     */
    public static void configOldPushVersion(Context context)

        

          public class ExampleApplication extends Application {

    @Override
    public void onCreate() {
        // 打开调试模式    
        MTCorePrivatesApi.configDebugMode(context.getApplicationContext(), true);
        // 使用老版本的通知点击跳转
        MTPushPrivatesApi.configOldPushVersion(context.getApplicationContext());
        // 初始化
        MTPushPrivatesApi.init(context.getApplicationContext());   
    }
}

        

              /**
     * 配置push通知语言，在MTPushPrivatesApi.init后使用
     *
     * @param context      不为空
     * @param pushLanguage 为空字符串时，恢复使用手机语言
     */
    public static void configUserLanguage(Context context, String pushLanguage)

        

              MTPushPrivatesApi.configUserLanguage(context,"zh_CN");   

        

              /**
     * 语音播报功能设置,需要导入语音包(mt-sdk-sound-x.x.x.aar)
     *
     * @param context      不为空
     * @param enable true为打开，false为关闭，默认为false
     */
    public static void setEnablePushTextToSpeech(Context context, boolean enable)

        

              MTPushPrivatesApi.setEnablePushTextToSpeech(context,true);   

        

              /**
     * MTPush初始化
     *
     * 建议在Application.onCreate()方法中调用
     * 
     * @param context 不为空，请使用applicationContext对象
     */
    public static void init(Context context)

        

          public class ExampleApplication extends Application {

    @Override
    public void onCreate() {
        // 打开调试模式    
        MTCorePrivatesApi.configDebugMode(context.getApplicationContext(), true);
        // 初始化
        MTPushPrivatesApi.init(context.getApplicationContext());   
    }
}

        

              /**
     * 前往通知开关设置页面
     *
     * @param context 不为空
     */
    public static void goToAppNotificationSettings(Context context)

        

              // 前往通知开关设置页面，需要客户手动打开通知开关
    MTPushPrivatesApi.goToAppNotificationSettings(this);
    
    // 继承MTCommonReceiver后，复写onNotificationStatus方法，获取通知开关状态，如果enable为true说明已经开启成功
    @Override
    public void onNotificationStatus(Context context, boolean enable) {
                if(enable){
                        // 已设置通知开关为打开
                }	    
    }

        

              /**
     * 开启 Push 推送，并持久化存储开关状态为true，默认是true
     * 
     * @param context 不能为空
     */
    public static void turnOnPush(Context context)

        

          // 开启推送，默认就是打开的
MTPushPrivatesApi.turnOnPush(context);
        
// 继承MTCommonReceiver后，复写onConnectStatus方法，获取长连接的连接状态，如果enable为true说明已经开启成功
@Override
public void onConnectStatus(Context context, boolean enable){
    if(enable){
        // 开启 push 推送成功
    }				
}				

        

              /**
     * 关闭 push 推送，并持久化存储开关状态为false，默认是true
     *
     * @param context 不能为空
     */
    public static void turnOffPush(Context context)

        

          // 关闭推送，需要再调用turnOnPush才能开启推送
MTPushPrivatesApi.turnOffPush(context);
        
// 继承MTCommonReceiver后，复写onConnectStatus方法，获取长连接状态，如果enable为false说明已经关闭成功
@Override
public void onConnectStatus(Context context, boolean enable){
    if(!enable){
        // 关闭 push 推送成功
    }
}		

        

              /**
     * 增加指定tag，累加逻辑，之前设置的标签依然存在
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    public static void addTag(Context context, int sequence, String... tags)

        

                  // 这里定义一个常量，代表增加指定tag操作
        private static final int SEQUENCE_TAG_ADD = 1;
        // 增加tag:"china","guangdong","shenzhen"
        MTPushPrivatesApi.addTag(context,SEQUENCE_TAG_ADD,"china","guangdong","shenzhen")
            
        // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
        @Override
        public void onTagMessage(Context context, TagMessage tagMessage){
                if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                        // tag操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                        return;
                }
                if(tagMessage.getSequence() == SEQUENCE_TAG_ADD){
                        // 增加指定tag成功，此时可查看操作成功的tag数组
                        String[] tags = tagMessage.getTags();
                }
        }

        

              /**
     * 删除指定tag，删除逻辑，会删除指定的标签
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    public static void deleteTag(Context context, int sequence, String... tags)

        

              // 这里定义一个常量，代表删除指定tag操作
    private static final int SEQUENCE_TAG_DELETE = 2;
    // 删除tag:"china","guangdong","shenzhen"
    MTPushPrivatesApi.deleteTag(context,SEQUENCE_TAG_DELETE,"china","guangdong","shenzhen")
    
    // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
    @Override
    public void onTagMessage(Context context, TagMessage tagMessage){
            if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // tag操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(tagMessage.getSequence() == SEQUENCE_TAG_DELETE){
                    // 删除指定tag成功，此时可查看操作成功的tag数组
                    String[] tags = tagMessage.getTags();
            }
    }

        

              /**
     * 更新指定tag，覆盖逻辑，之前添加的tag会清空
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tags     标签数组，每个tag命名长度限制为40字节，最多支持设置1000个tag，且单次操作总长度不得超过5000字节
     */
    public static void updateTag(Context context, int sequence, String... tags)

        

              // 这里定义一个常量，代表更新指定tag操作
    private static final int SEQUENCE_TAG_UPDATE = 3;
    // 更新tag:"beijing","shanghai","guangzhou","shenzhen"，之前设置的tag会失效
    MTPushPrivatesApi.updateTag(context,SEQUENCE_TAG_UPDATE,"beijing","shanghai","guangzhou","shenzhen")
    
    // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
    @Override
    public void onTagMessage(Context context, TagMessage tagMessage){
            if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // tag操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(tagMessage.getSequence() == SEQUENCE_TAG_UPDATE){
                    // 更新指定tag成功，此时可查看操作成功的tag数组
                    String[] tags = tagMessage.getTags();
            }
    }

        

              /**
     * 查询指定tag
     * 
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param tag      标签，每个tag命名长度限制为40字节
     */
    public static void queryTag(Context context, int sequence, String tag)

        

              // 这里定义一个常量，代表查询指定tag操作
    private static final int SEQUENCE_TAG_QUERY = 4;
    // 查询标签
    MTPushPrivatesApi.queryTag(context,SEQUENCE_TAG_QUERY,"china")
    
    // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
    @Override
    public void onTagMessage(Context context, TagMessage tagMessage){
            if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // tag操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(tagMessage.getSequence() == SEQUENCE_TAG_QUERY){
                    // 查询指定tag成功，此时可查看操作成功的tag和状态
                    String tag = 	tagMessage.getQueryTag();
                    boolean valid = tagMessage.isQueryTagValid();
            }
    }	

        

              /**
     * 删除所有tag，清空逻辑，会删除所有的标签
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    public static void deleteAllTag(Context context, int sequence, String... tags)

        

              // 这里定义一个常量，代表删除所有tag操作
    private static final int SEQUENCE_TAG_DELETE_ALL = 5;
    // 删除所有tag
    MTPushPrivatesApi.deleteTag(context,SEQUENCE_TAG_DELETE_ALL)
    
    // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
    @Override
    public void onTagMessage(Context context, TagMessage tagMessage){
            if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // tag操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(tagMessage.getSequence() == SEQUENCE_TAG_DELETE_ALL){
                    // 删除所有tag成功
            }
    }

        

              /**
     * 查询所有tag，获取逻辑，会获取所有标签
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    public static void queryAllTag(Context context, int sequence, String... tags)

        

              // 这里定义一个常量，代表查询所有tag操作
    private static final int SEQUENCE_TAG_QUERY_ALL = 6;
    // 查询所有tag
    MTPushPrivatesApi.queryAllTag(context,SEQUENCE_TAG_QUERY_ALL)
    
    // 继承MTCommonReceiver后，复写onTagMessage方法，获取tag操作回调
    @Override
    public void onTagMessage(Context context, TagMessage tagMessage){
            if(tagMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // tag 操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(tagMessage.getSequence() == SEQUENCE_TAG_DELETE_ALL){
                    // 查询所有tag成功，此时可查看操作成功的tag数组
                    String[] tags = tagMessage.getTags();
            }
    }

        

              /**
     * 设置alias
     * 
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     * @param alias    有效的别名组成：字母（区分大小写）、数字、下划线、汉字、特殊字符@!#$&*+=.|。限制：alias命名长度限制为 40 字节（判断长度需采用 UTF-8 编码）
     *                             
     */
    public static void setAlias(Context context, int sequence, String alias) 

        

              // 这里定义一个常量，代表设置alias操作
    private static final int SEQUENCE_ALIAS_SET = 7;
    // 设置alias:"young"
    MTPushPrivatesApi.setAlias(context,SEQUENCE_ALIAS_SET,"young")
    
    // 继承MTCommonReceiver后，复写onAliasMessage方法，获取alias操作回调
    @Override
    public void onAliasMessage(Context context, AliasMessage aliasMessage){
            if(aliasMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // alias操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(aliasMessage.getSequence() == SEQUENCE_ALIAS_SET){
                    // 设置alias成功，此时可查看操作成功的alias
                    String alias = 	aliasMessage.getAlias();
            }
    }	

        

              /**
     * 获取alias
     * 
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    public static void getAlias(Context context, int sequence)

        

              // 这里定义一个常量，代表获取alias操作
    private static final int SEQUENCE_ALIAS_GET = 8;
    // 获取alias
    MTPushPrivatesApi.getAlias(context,SEQUENCE_ALIAS_GET)
    
    // 继承MTCommonReceiver后，复写onAliasMessage方法，获取alias操作回调
    @Override
    public void onAliasMessage(Context context, AliasMessage aliasMessage){
            if(aliasMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // alias 操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(aliasMessage.getSequence() == SEQUENCE_ALIAS_GET){
                    // 获取alias成功，此时可查看操作成功的alias
                    String alias = 	aliasMessage.getAlias();
            }
    }	

        

              /**
     * 清除alias
     *
     * 同一个应用程序内，对不同的用户，建议取不同的别名。这样，尽可能根据别名来唯一确定用户
     * 
     * 不限定一个别名只能指定一个用户
     *
     * @param context  不能为空
     * @param sequence 用户自定义的操作序列号，同操作结果一起返回，用来标识一次操作的唯一性
     */
    public static void clearAlias(Context context, int sequence)

        

              // 这里定义一个常量，代表清除alias操作
    private static final int SEQUENCE_ALIAS_CLEAR = 7;
    // 清除alias
    MTPushPrivatesApi.clearAlias(context,SEQUENCE_ALIAS_CLEAR)
    
    // 继承MTCommonReceiver后，复写onAliasMessage方法，获取alias操作回调
    @Override
    public void onAliasMessage(Context context, AliasMessage aliasMessage){
            if(aliasMessage.getCode != MTPushPrivatesApi.Code.Success){
                    // alias操作失败，详细错误信息可查看MTPushPrivatesApi.Code
                    return;
            }
            if(aliasMessage.getSequence() == SEQUENCE_ALIAS_CLEAR){
                    // 清除alias成功
            }
    }	

        

              /**
     * 设置通知展示时间，默认任何时间都展示
     *
     * @param context   不为空
     * @param beginHour 允许通知展示的开始时间（ 24 小时制，范围为 0 到 23 ）
     * @param endHour   允许通知展示的结束时间（ 24 小时制，范围为 0 到 23 ），beginHour不能大于等于endHour
     * @param weekDays  允许通知展示的星期数组（ 7 日制，范围为 1 到 7），空数组代表任何时候都不展示通知
     */
    public static void setNotificationShowTime(Context context, int beginHour, int endHour, int... weekDays)

        

              // 设置通知展示时间为每周1/3/5/7的早上9点到晚上9点
    MTPushPrivatesApi.setNotificationShowTime(context, 9, 21, 1,3,5,7);

        

              /**
     * 重置通知展示时间，默认任何时间都展示
     *
     * @param context 不为空
     */
    public static void resetNotificationShowTime(Context context)

        

              // 重置通知展示时间，默认任何时间都展示
    MTPushPrivatesApi.resetNotificationShowTime(context);

        

              /**
     * 设置通知静默时间，默认任何时间都不静默
     *
     * @param context     不为空
     * @param beginHour   允许通知静默的开始时间，单位小时（ 24 小时制，范围为 0 到 23 ）
     * @param beginMinute 允许通知静默的开始时间，单位分钟（ 60 分钟制，范围为 0 到 59 ）
     * @param endHour     允许通知静默的结束时间，单位小时（ 24 小时制，范围为 0 到 23 ）
     * @param endMinute   允许通知静默的结束时间，单位分钟（ 60 分钟制，范围为 0 到 59 ）
     */
    public static void setNotificationSilenceTime(Context context, int beginHour, int beginMinute, int endHour, int endMinute)

        

              // 设置通知静默时间为每天晚上9点半到第二天早上9点半
    MTPushPrivatesApi.setNotificationSilenceTime(context, 21, 30, 9, 30);

        

              /**
     * 重置通知静默时间，默认任何时间都不静默
     *
     * @param context 不为空
     */
    public static void resetNotificationSilenceTime(Context context)

        

              // 重置通知静默时间，默认任何时间都不静默
    MTPushPrivatesApi.resetNotificationSilenceTime(context);

        

              /**
     * 设置自定义通知布局，默认使用系统通知布局
     *
     * @param context            不为空
     * @param builderId          构建id
     * @param notificationLayout 自定义通知布局的对象，不为空
     */
    public static void setNotificationLayout(Context context, int builderId, NotificationLayout notificationLayout)

        

                  // 这里定义一个常量，代表构建id
        private static final int BUILDER_ID = 11;
        
        // 构建出一个notificationLayout
    NotificationLayout notificationLayout = new NotificationLayout()
            .setLayoutId(R.layout.custom_notification_layout)        // 布局layout_id
            .setIconViewId(R.id.iv_notification_icon)                // 通知图标view_id
            .setIconResourceId(R.drawable.mtpush_notification_icon)   // 通知图标source_id
            .setTitleViewId(R.id.tv_notification_title)              // 通知标题view_id
            .setContentViewId(R.id.tv_notification_content)          // 通知内容view_id
            .setTimeViewId(R.id.tv_notification_time);               // 通知时间view_id
 
    // 设置构建id为BUILDER_ID的自定义布局，下发通知时指定builderId为BUILDER_ID，即可改变通知布局        
    MTPushPrivatesApi.setNotificationLayout(this.getApplicationContext(), BUILDER_ID, notificationLayout);

        

              /**
     * 重置自定义通知布局，默认使用系统通知布局
     *
     * @param context   不为空
     * @param builderId 自定义通知布局的id
     */
    public static void resetNotificationLayout(Context context, int builderId)

        

                  // 这里定义一个常量，代表构建id
        private static final int BUILDER_ID = 11;
        
    // 重置构建id为BUILDER_ID的自定义布局，下发通知时指定builderId为BUILDER_ID，将使用系统默认布局
    MTPushPrivatesApi.resetNotificationLayout(context,BUILDER_ID);

        

              /**
     * 设置通知栏的通知数量，默认数量为5
     *
     * @param context 不为空
     * @param count   限制通知栏的通知数量，超出限制数量则移除最老通知，不能小于等于0
     */
    public static void setNotificationCount(Context context, int count)

        

              // 设置通知栏通知数量为50
    MTPushPrivatesApi.setNotificationCount(context,50);

        

              /**
     * 重置通知栏的通知数量，默认数量为5
     *
     * @param context 不为空
     */
    public static void resetNotificationCount(Context context)

        

              // 重置通知栏的通知数量，默认数量为5
    MTPushPrivatesApi.resetNotificationCount(context);

        

              /**
     * 设置应用角标数量，默认0（仅华为/荣耀生效）
     *
     * @param context 不为空
     * @param badge   应用角标数量
     */
    public static void setNotificationBadge(Context context, int badge)

        

              // 设置应用角标数量为1
    MTPushPrivatesApi.setNotificationBadge(context,1);

        

              /**
     * 重置应用角标数量，默认0（仅华为/荣耀生效）
     *
     * @param context 不为空
     */
    public static void resetNotificationBadge(Context context) {

        

              // 重置应用角标数量，默认0
    MTPushPrivatesApi.resetNotificationBadge(context);

        

              /**
     * 展示通知
     *
     * @param context             不为空
     * @param notificationMessage 构建的通知对象，不为空
     */
    public static void showNotification(Context context, NotificationMessage notificationMessage)

        

              // 构建一个基础的通知，其中messageId和content是必须，否则通知无法展示
    NotificationMessage notificationMessage = new NotificationMessage()
            .setMessageId("12345")
            .setNotificationId(12345)
            .setTitle("custom_notification_title")
            .setContent("custom_notification_content");    
    // 展示通知
    MTPushPrivatesApi.showNotification(context,notificationMessage);

        

              /**
     * 清除指定notifyId的通知
     *
     * @param context  不为空
     * @param notifyId 通知id
     */
    public static void clearNotification(Context context, int notifyId)

        

              // 清除指定notifyId的通知
    MTPushPrivatesApi.clearNotification(context,12345);

        

              /**
     * 上报厂商通道通知到达
     * 
     * 走http/https上报
     *
     * @param context           不为空
     * @param messageId         Engagelab消息id，不为空
     * @param platform          厂商，取值范围（1:mi、2:huawei、3:meizu、4:oppo、5:vivo、7:honor、8:google）
     * @param platformMessageId 厂商消息id，可为空
     */
    public static void reportNotificationArrived(Context context, String messageId, byte platform, String platformMessageId)

        

              // 上报厂商通知到达，messageId为“12345”，厂商为小米，厂商messageId为“MI-6476RHT25”
    MTPushPrivatesApi.reportNotificationArrived(context,“12345”,MTPushPrivatesApi.PLATFORM_XIAOMI,"MI-6476RHT25");

        

              /**
     * 上报厂商通道通知点击
     * 
     * 走http/https上报
     *
     * @param context           不为空
     * @param messageId         Engagelab消息id，不为空
     * @param platform          厂商，取值范围（1:mi、2:huawei、3:meizu、4:oppo、5:vivo、7:honor、8:google）
     * @param platformMessageId 厂商消息id，可为空
     */
    public static void reportNotificationClicked(Context context, String messageId, byte platform, String platformMessageId)

        

              // 上报厂商通知点击，messageId为“12345”，厂商为小米，厂商messageId为“MI-6476RHT25”
    MTPushPrivatesApi.reportNotificationClicked(context,“12345”,MTPushPrivatesApi.PLATFORM_XIAOMI,"MI-6476RHT25");

        

              /**
     * 上报厂商通道通知删除
     * 
     * 走http/https上报
     *
     * @param context           不为空
     * @param messageId         Engagelab消息id，不为空
     * @param platform          厂商，取值范围（1:mi、2:huawei、3:meizu、4:oppo、5:vivo、7:honor、8:google）
     * @param platformMessageId 厂商消息id，可为空
     */
    public static void reportNotificationDeleted(Context context, String messageId, byte platform, String platformMessageId)

        

              // 上报厂商通知删除，messageId为“12345”，厂商为mi，厂商messageId为“MI-6476RHT25”
    MTPushPrivatesApi.reportNotificationDeleted(context,“12345”,MTPushPrivatesApi.PLATFORM_XIAOMI,"MI-6476RHT25");

        

              /**
     * 上报厂商通道通知打开
     * 
     * 走http/https上报
     *
     * @param context           不为空
     * @param messageId         Engagelab消息id，不为空
     * @param platform          厂商，取值范围（1:mi、2:huawei、3:meizu、4:oppo、5:vivo、7:honor、8:google）
     * @param platformMessageId 厂商消息id，可为空
     */
    public static void reportNotificationOpened(Context context, String messageId, byte platform, String platformMessageId)

        

              Bundle bundle = intent.getExtras();
    String platformMessage = "";
    // huawei
    if (intent.getData() != null) {
        platformMessage = intent.getData().toString();
    }
    // 其他厂商
    if (TextUtils.isEmpty(platformMessage) && intent.getExtras() != null) {
        if (bundle.containsKey("JMessageExtra")) {
             platformMessage = bundle.getString("JMessageExtra");
        }else {
             platformMessage = bundle.getString("MTMessageExtra");
        }
    }
    if (TextUtils.isEmpty(platformMessage)) {
        return;
    }
    JSONObject messageJson = new JSONObject(platformMessage);
    tvMessage.setText(toLogString(messageJson));
    // 解析
    String messageId = messageJson.optString("msg_id");
    byte platform = (byte) messageJson.optInt("rom_type");
    String title = messageJson.optString("n_title");
    String content = messageJson.optString("n_content");
    // 上报通知点击activity打开，建议所有厂商跳转都加上，仅MTPush4.0.0以下版本需要
    MTPushPrivatesApi.reportNotificationOpened(this, messageId, platform, ""); 

        

              /**
     * 上传厂商token
     * 
     * 走tcp上传
     *
     * @param context  不为空
     * @param platform 厂商，取值范围（1:mi、2:huawei、3:meizu、4:oppo、5:vivo、7:honor、8:google）
     * @param token    厂商返回的token，不为空
     * @param region    海外版小米和oppo需要设置region，国际版填:"GLOBAL",非海外版的填:"NULL"
     */
    public static void uploadPlatformToken(Context context, byte platform, String token, String region)

        

              // 上报厂商token，厂商为mi，厂商token为“MI-6476s-afs-afs-afaR-HT25”
    MTPushPrivatesApi.uploadPlatformToken(context,MTPushPrivatesApi.PLATFORM_XIAOMI,"MI-6476s-afs-afs-afaR-HT25","NULL");

        

              /**
     * @param context           不为空
     * @param fragmentName      Fragment页面完整类名（this.getClass().getCanonicalName()）
     */
    public static void onFragmentResume(Context context, String fragmentName)

        

              /**
     * @param context           不为空
     * @param fragmentName      Fragment页面完整类名（this.getClass().getCanonicalName()
     */
    public static void onFragmentPause(Context context, String fragmentName)

        

              /**
     * 应用通知开关状态回调
     *
     * @param context 不为空
     * @param enable  通知开关是否开，true为打开，false为关闭
     */
    @Override
    public void onNotificationStatus(Context context, boolean enable)

        

              /**
     * 长连接是否连接成功
     *
     * 在初始化后会进行长连接，连接成功/失败均会回调此方法
     *
     * @param context 不为空
     * @param enable  长连接是否连接成功，true为成功；false为失败   
     */		
        public void onConnectStatus(Context context, boolean enable)

        

              /**
     * 通知消息送达
     *
     * 推送的通知消息送达会回调此方法
     *
     * @param context 						不为空
     * @param notificationMessage 通知消息  
     */				
    public void onNotificationArrived(Context context, NotificationMessage notificationMessage)

        

              /**
     * 通知消息在前台不显示
     *
     * @param context             不为空
     * @param notificationMessage 通知消息
     */
    @Override
    public void onNotificationUnShow(Context context, NotificationMessage notificationMessage)

        

              /**
     * 通知消息点击
     *
         * 推送的通知消息点击会回调此方法
         *
     * @param context 						不为空
     * @param notificationMessage 通知消息  
     */				
    public void onNotificationClicked(Context context, NotificationMessage notificationMessage)

        

              /**
     * 通知消息删除
     * 
         * 推送的通知消息删除会回调此方法
         *
     * @param context 						不为空
     * @param notificationMessage 通知消息  
     */				
    public void onNotificationDeleted(Context context, NotificationMessage notificationMessage)

        

              /**
     * 自定义消息送达
     *
     * 自定义消息送达时会回调此方法
     *
     * @param context 			不为空
     * @param customMessage 自定义消息  
     */				
    public void onCustomMessage(Context context, CustomMessage customMessage)

        

              /**
     * tag操作消息
     *
     * @param context    不为空
     * @param tagMessage 标签信息
     */		
    public void onTagMessage(Context context, TagMessage tagMessage)

        

              /**
     * alias操作消息
     *
     * @param context      ApplicationContext对象
     * @param aliasMessage 别名消息
     */
    public void onAliasMessage(Context context, AliasMessage aliasMessage)

        

              /**
     * 厂商操作消息
     *
     * @param context         ApplicationContext对象
     * @param platformMessage 厂商token消息
     */
    public void onPlatformToken(Context context, PlatformTokenMessage platformMessage)

        

              /**
     * 
     *
     * @param context         ApplicationContext对象
     * @param inAppMessage 应用内消息
     */
    public void onInAppMessageShow(Context context, InAppMessage inAppMessage)

        

              /**
     * 
     *
     * @param context         ApplicationContext对象
     * @param inAppMessage 应用内消息
     */
    public void onInAppMessageClick(Context context, InAppMessage inAppMessage)

        

              private void initChannel(){if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            if (nm != null){NotificationChannelGroup notificationChannelGroup = new NotificationChannelGroup("MyGroupId", "自定义通知组");
                nm.createNotificationChannelGroup(notificationChannelGroup);

                NotificationChannel notificationChannel = new NotificationChannel("MyChannelId", "自定义通知", NotificationManager.IMPORTANCE_HIGH);
                notificationChannel.setGroup("MyGroupId");
                notificationChannel.enableLights(true);
                notificationChannel.enableVibration(true);
                notificationChannel.setSound("android.resource:// 包名 /raw/ 铃声文件", null);    // 设置自定义铃声

                nm.createNotificationChannel(notificationChannel);
            }
        }
    }