@onekeyfe/react-native-jpush 0.0.0-stage → 6.7.0-alpha.436

package/android/src/main/java/cn/jiguang/plugins/push/receiver/JPushBroadcastReceiver.java

@@ -0,0 +1,37 @@
+package cn.jiguang.plugins.push.receiver;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+
+import cn.jiguang.plugins.push.common.JLogger;
+import cn.jiguang.plugins.push.helper.JPushHelper;
+import cn.jpush.android.api.JPushInterface;
+
+public class JPushBroadcastReceiver extends BroadcastReceiver {
+
+  public static Bundle NOTIFICATION_BUNDLE;
+
+  @Override
+  public void onReceive(Context context, Intent data) {
+    if (data == null) {
+      return;
+    }
+    if (data.getBooleanExtra("jpush_already_dispatched", false)) {
+      return;
+    }
+    if (JPushInterface.ACTION_NOTIFICATION_OPENED.equals(data.getAction())) {
+      JLogger.d("JPushBroadcastReceiver ACTION_NOTIFICATION_OPENED");
+      try {
+        NOTIFICATION_BUNDLE = data.getExtras();
+        if (context != null) {
+          JPushHelper.launchApp(context);
+        }
+      } catch (Throwable throwable) {
+        JLogger.e("JPushBroadcastReceiver ACTION_NOTIFICATION_OPENED error:" + throwable.getMessage());
+      }
+    }
+  }
+
+}

package/android/src/main/java/cn/jiguang/plugins/push/receiver/JPushModuleReceiver.java

@@ -0,0 +1,264 @@
+package cn.jiguang.plugins.push.receiver;
+
+import android.content.Context;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import cn.jiguang.plugins.push.JPushModule;
+import cn.jiguang.plugins.push.common.JLogger;
+import cn.jiguang.plugins.push.common.JConstants;
+import cn.jiguang.plugins.push.helper.JPushHelper;
+import cn.jpush.android.api.CmdMessage;
+import cn.jpush.android.api.CustomMessage;
+import cn.jpush.android.api.JPushMessage;
+import cn.jpush.android.api.NotificationMessage;
+import cn.jpush.android.service.JPushMessageReceiver;
+import cn.jpush.android.api.NotificationCustomButton;
+
+public class JPushModuleReceiver extends JPushMessageReceiver {
+
+  private static String safeId(String value) {
+    return value != null ? value : "";
+  }
+
+  @Override
+  public void onMessage(Context context, CustomMessage customMessage) {
+    if (customMessage != null) {
+      JLogger.i(
+          "onMessage type=customMessage msgId="
+              + safeId(customMessage.messageId)
+              + " platform="
+              + customMessage.platform
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertCustomMessageToMapObject(customMessage);
+    JPushHelper.sendEventMap(JConstants.CUSTOM_MESSAGE_EVENT, map);
+  }
+
+  @Override
+  public void onNotifyMessageArrived(Context context, NotificationMessage notificationMessage) {
+    if (notificationMessage == null) {
+      return;
+    }
+    String eventType =
+        notificationMessage.notificationType == 1 ? "localNotification" : JConstants.NOTIFICATION_ARRIVED;
+    JLogger.i(
+        "onNotifyMessageArrived type="
+            + eventType
+            + " notificationType="
+            + notificationMessage.notificationType
+            + " msgId="
+            + safeId(notificationMessage.msgId)
+            + " notificationId="
+            + notificationMessage.notificationId
+    );
+    Map<String, Object> map = JPushHelper.convertNotificationToMapObject(JConstants.NOTIFICATION_ARRIVED, notificationMessage);
+    if (notificationMessage.notificationType != 1) {
+      JPushHelper.sendEventMap(JConstants.NOTIFICATION_EVENT, map);
+    } else {
+      JPushHelper.sendEventMap(JConstants.LOCAL_NOTIFICATION_EVENT, map);
+    }
+  }
+  @Override
+  public void onPropertyOperatorResult(Context context, JPushMessage jPushMessage) {
+    if (jPushMessage != null) {
+      JLogger.i(
+          "onPropertyOperatorResult seq="
+              + jPushMessage.getSequence()
+              + " code="
+              + jPushMessage.getErrorCode()
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertJPushMessageToMapObject(4, jPushMessage);
+    JPushHelper.sendEventMap(JConstants.TAG_ALIAS_EVENT, map);
+  }
+  @Override
+  public void onNotifyMessageOpened(Context context, NotificationMessage notificationMessage) {
+    JPushBroadcastReceiver.NOTIFICATION_BUNDLE = null;
+    if (notificationMessage != null) {
+      JLogger.i(
+          "onNotifyMessageOpened type="
+              + JConstants.NOTIFICATION_OPENED
+              + " notificationType="
+              + notificationMessage.notificationType
+              + " msgId="
+              + safeId(notificationMessage.msgId)
+              + " notificationId="
+              + notificationMessage.notificationId
+      );
+    }
+    if (!JPushModule.isAppForeground) {
+      JPushHelper.launchApp(context);
+    }
+    Map<String, Object> map = JPushHelper.convertNotificationToMapObject(JConstants.NOTIFICATION_OPENED, notificationMessage);
+    if (notificationMessage != null && notificationMessage.notificationType == 1) {
+      JPushHelper.sendEventMap(JConstants.LOCAL_NOTIFICATION_EVENT, map);
+    } else {
+      JPushHelper.sendEventMap(JConstants.NOTIFICATION_EVENT, map);
+    }
+  }
+  @Override
+  public void onInAppMessageShow(Context context, NotificationMessage notificationMessage) {
+    if (notificationMessage != null) {
+      JLogger.i(
+          "onInAppMessageShow type="
+              + JConstants.IN_APP_MESSAGE_SHOW
+              + " notificationType="
+              + notificationMessage.notificationType
+              + " msgId="
+              + safeId(notificationMessage.msgId)
+      );
+    }
+    if (!JPushModule.isAppForeground) {
+      JPushHelper.launchApp(context);
+    }
+    Map<String, Object> map = JPushHelper.convertInAppMessageToMapObject(JConstants.IN_APP_MESSAGE_SHOW, notificationMessage);
+    JPushHelper.sendEventMap(JConstants.INAPP_MESSAGE_EVENT, map);
+  }
+  @Override
+  public void onInAppMessageClick(Context context, NotificationMessage notificationMessage) {
+    if (notificationMessage != null) {
+      JLogger.i(
+          "onInAppMessageClick type="
+              + JConstants.IN_APP_MESSAGE_CLICK
+              + " notificationType="
+              + notificationMessage.notificationType
+              + " msgId="
+              + safeId(notificationMessage.msgId)
+      );
+    }
+    if (!JPushModule.isAppForeground) {
+      JPushHelper.launchApp(context);
+    }
+    Map<String, Object> map = JPushHelper.convertInAppMessageToMapObject(JConstants.IN_APP_MESSAGE_CLICK, notificationMessage);
+    JPushHelper.sendEventMap(JConstants.INAPP_MESSAGE_EVENT, map);
+  }
+
+  @Override
+  public void onNotifyMessageDismiss(Context context, NotificationMessage notificationMessage) {
+    if (notificationMessage != null) {
+      JLogger.i(
+          "onNotifyMessageDismiss type="
+              + JConstants.NOTIFICATION_DISMISSED
+              + " notificationType="
+              + notificationMessage.notificationType
+              + " msgId="
+              + safeId(notificationMessage.msgId)
+              + " notificationId="
+              + notificationMessage.notificationId
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertNotificationToMapObject(JConstants.NOTIFICATION_DISMISSED, notificationMessage);
+    if (notificationMessage != null && notificationMessage.notificationType == 1) {
+      JPushHelper.sendEventMap(JConstants.LOCAL_NOTIFICATION_EVENT, map);
+    } else {
+      JPushHelper.sendEventMap(JConstants.NOTIFICATION_EVENT, map);
+    }
+  }
+
+  @Override
+  public void onNotifyButtonClick(Context context, NotificationCustomButton notificationCustomButton) {
+    if (notificationCustomButton != null) {
+      JLogger.i(
+          "onNotifyButtonClick msgId="
+              + safeId(notificationCustomButton.a)
+              + " platform="
+              + notificationCustomButton.b
+              + " actionType="
+              + notificationCustomButton.d
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertNotificationCustomButtonToMapObject(notificationCustomButton);
+    JPushHelper.sendEventMap(JConstants.NOTIFY_BUTTON_CLICK_EVENT, map);
+ }
+
+  @Override
+  public void onRegister(Context context, String registrationId) {
+    JLogger.i("onRegister registrationId=" + safeId(registrationId));
+  }
+
+  @Override
+  public void onConnected(Context context, boolean state) {
+    JLogger.i("onConnected state=" + state);
+    Map<String, Object> map = new HashMap<String, Object>();
+    map.put(JConstants.CONNECT_ENABLE, Boolean.valueOf(state));
+    JPushHelper.sendEventMap(JConstants.CONNECT_EVENT, map);
+  }
+
+  @Override
+  public void onCommandResult(Context context, CmdMessage message) {
+    if (message == null) {
+      return;
+    }
+    JLogger.i("onCommandResult cmd=" + message.cmd + " errorCode=" + message.errorCode);
+    Map<String, Object> map = new HashMap<String, Object>();
+    map.put(JConstants.COMMAND, Integer.valueOf(message.cmd));
+    map.put(JConstants.COMMAND_EXTRA, message.extra != null ? message.extra.toString() : "");
+    map.put(JConstants.COMMAND_MESSAGE, message.msg != null ? message.msg : "");
+    map.put(JConstants.COMMAND_RESULT, Integer.valueOf(message.errorCode));
+    JPushHelper.sendEventMap(JConstants.COMMAND_EVENT, map);
+  }
+
+  @Override
+  public void onTagOperatorResult(Context context, JPushMessage jPushMessage) {
+    if (jPushMessage != null) {
+      JLogger.i(
+          "onTagOperatorResult seq="
+              + jPushMessage.getSequence()
+              + " code="
+              + jPushMessage.getErrorCode()
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertJPushMessageToMapObject(1, jPushMessage);
+    JPushHelper.sendEventMap(JConstants.TAG_ALIAS_EVENT, map);
+  }
+
+  @Override
+  public void onCheckTagOperatorResult(Context context, JPushMessage jPushMessage) {
+    if (jPushMessage != null) {
+      JLogger.i(
+          "onCheckTagOperatorResult seq="
+              + jPushMessage.getSequence()
+              + " code="
+              + jPushMessage.getErrorCode()
+              + " tagEnable="
+              + jPushMessage.getTagCheckStateResult()
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertJPushMessageToMapObject(2, jPushMessage);
+    JPushHelper.sendEventMap(JConstants.TAG_ALIAS_EVENT, map);
+  }
+
+  @Override
+  public void onAliasOperatorResult(Context context, JPushMessage jPushMessage) {
+    if (jPushMessage != null) {
+      JLogger.i(
+          "onAliasOperatorResult seq="
+              + jPushMessage.getSequence()
+              + " code="
+              + jPushMessage.getErrorCode()
+      );
+    }
+    Map<String, Object> map = JPushHelper.convertJPushMessageToMapObject(3, jPushMessage);
+    JPushHelper.sendEventMap(JConstants.TAG_ALIAS_EVENT, map);
+  }
+
+  @Override
+  public void onMobileNumberOperatorResult(Context context, JPushMessage jPushMessage) {
+    if (jPushMessage == null) {
+      return;
+    }
+    JLogger.i(
+        "onMobileNumberOperatorResult seq="
+            + jPushMessage.getSequence()
+            + " code="
+            + jPushMessage.getErrorCode()
+    );
+    Map<String, Object> map = new HashMap<String, Object>();
+    map.put(JConstants.CODE, Integer.valueOf(jPushMessage.getErrorCode()));
+    map.put(JConstants.SEQUENCE, Integer.valueOf(jPushMessage.getSequence()));
+    JPushHelper.sendEventMap(JConstants.MOBILE_NUMBER_EVENT, map);
+  }
+
+}

package/android/src/main/java/cn/jiguang/plugins/service/JCoreModuleService.java

@@ -0,0 +1,7 @@
+package cn.jiguang.plugins.service;
+
+import cn.jpush.android.service.JCommonService;
+
+public class JCoreModuleService extends JCommonService {
+
+}

package/android/src/main/java/cn/jpush/android/api/BasicPushNotificationBuilder.java

@@ -0,0 +1,83 @@
+package cn.jpush.android.api;
+
+import android.app.Notification;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+
+public class BasicPushNotificationBuilder extends DefaultPushNotificationBuilder {
+    public int notificationDefaults = -2;
+    public int notificationFlags = 16;
+    public int statusBarDrawable = 0;
+    public String developerArg0 = "developerArg0";
+    protected Context builderContext;
+
+    public BasicPushNotificationBuilder(Context context) {
+        if (context == null) {
+            throw new IllegalArgumentException("NULL context");
+        }
+        this.builderContext = context;
+        this.context = context;
+        try {
+            ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), 0);
+            if (appInfo != null) {
+                this.statusBarDrawable = appInfo.icon;
+            }
+        } catch (Throwable ignored) {
+        }
+    }
+
+    @Override
+    public String getDeveloperArg0() {
+        return this.developerArg0;
+    }
+
+    @Override
+    Notification getNotification(Notification.Builder builder) {
+        if (this.notificationDefaults != -2) {
+            builder.setDefaults(this.notificationDefaults);
+        }
+        if (this.statusBarDrawable != 0) {
+            builder.setSmallIcon(this.statusBarDrawable);
+        }
+        Notification notification = builder.build();
+        notification.flags = 1 | this.notificationFlags;
+        return notification;
+    }
+
+    @Override
+    void resetNotificationParams(Notification notification) {
+        notification.defaults = this.notificationDefaults;
+        notification.flags = this.notificationFlags;
+        notification.icon = this.statusBarDrawable;
+    }
+
+    @Override
+    public String toString() {
+        return "basic_____" + serializeFields();
+    }
+
+    String serializeFields() {
+        return this.notificationDefaults + "_____" + this.notificationFlags + "_____" + this.statusBarDrawable + "_____" + this.developerArg0;
+    }
+
+    void parseFields(String[] parts) {
+        if (parts.length >= 4) {
+            this.notificationDefaults = Integer.parseInt(parts[1]);
+            this.notificationFlags = Integer.parseInt(parts[2]);
+            this.statusBarDrawable = Integer.parseInt(parts[3]);
+        }
+        if (parts.length >= 5) {
+            this.developerArg0 = parts[4];
+        }
+    }
+
+    public static PushNotificationBuilder parseFromPreference(Context context, String serialized) {
+        String[] parts = serialized != null ? serialized.split("_____") : new String[0];
+        String type = parts.length > 0 ? parts[0] : "basic";
+        BasicPushNotificationBuilder builder = "custom".equals(type)
+            ? new CustomPushNotificationBuilder(context)
+            : new BasicPushNotificationBuilder(context);
+        builder.parseFields(parts);
+        return builder;
+    }
+}

package/android/src/main/java/cn/jpush/android/api/CallBackParams.java

@@ -0,0 +1,50 @@
+package cn.jpush.android.api;
+
+import java.io.Serializable;
+import java.util.Map;
+import java.util.Set;
+
+public class CallBackParams implements Serializable {
+    private static final long serialVersionUID = 1L;
+    public String alias;
+    public Set<String> tags;
+    public Map<String, Object> pros;
+    public TagAliasCallback tagAliasCallBack;
+    public long sendTime;
+    public int protoType = 0;
+    public int action = 0;
+    public int sequence;
+
+    public CallBackParams(String alias, Set<String> tags, TagAliasCallback callback, long sendTime, int protoType, int action) {
+        this.alias = alias;
+        this.tags = tags;
+        this.tagAliasCallBack = callback;
+        this.sendTime = sendTime;
+        this.protoType = protoType;
+        this.action = action;
+    }
+
+    public CallBackParams(int sequence, String alias, long sendTime, int protoType, int action) {
+        this.sequence = sequence;
+        this.alias = alias;
+        this.sendTime = sendTime;
+        this.protoType = protoType;
+        this.action = action;
+    }
+
+    public CallBackParams(int sequence, Set<String> tags, long sendTime, int protoType, int action) {
+        this.sequence = sequence;
+        this.tags = tags;
+        this.sendTime = sendTime;
+        this.protoType = protoType;
+        this.action = action;
+    }
+
+    public CallBackParams(int sequence, Map<String, Object> pros, long sendTime, int protoType, int action) {
+        this.sequence = sequence;
+        this.pros = pros;
+        this.sendTime = sendTime;
+        this.protoType = protoType;
+        this.action = action;
+    }
+}

package/android/src/main/java/cn/jpush/android/api/CmdMessage.java

@@ -0,0 +1,33 @@
+package cn.jpush.android.api;
+
+import android.os.Bundle;
+
+public class CmdMessage {
+    public int cmd;
+    public int errorCode;
+    public String msg;
+    public Bundle extra;
+
+    public CmdMessage(int cmd, int errorCode) {
+        this.cmd = cmd;
+        this.errorCode = errorCode;
+    }
+
+    public CmdMessage(int cmd, int errorCode, String msg) {
+        this.cmd = cmd;
+        this.errorCode = errorCode;
+        this.msg = msg;
+    }
+
+    public CmdMessage(int cmd, int errorCode, String msg, Bundle extra) {
+        this.cmd = cmd;
+        this.errorCode = errorCode;
+        this.msg = msg;
+        this.extra = extra;
+    }
+
+    @Override
+    public String toString() {
+        return "CmdMessage{cmd=" + cmd + ", errorCode=" + errorCode + ", msg='" + msg + "', extra=" + extra + '}';
+    }
+}

package/android/src/main/java/cn/jpush/android/api/CustomMessage.java

@@ -0,0 +1,28 @@
+package cn.jpush.android.api;
+
+import java.io.Serializable;
+
+public class CustomMessage implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    public String messageId;
+    public String extra;
+    public String message;
+    public String contentType;
+    public String title;
+    public String senderId;
+    public String appId;
+    public byte platform;
+
+    @Override
+    public String toString() {
+        return "CustomMessage{messageId='" + messageId
+            + "', extra='" + extra
+            + "', message='" + message
+            + "', contentType='" + contentType
+            + "', title='" + title
+            + "', senderId='" + senderId
+            + "', appId='" + appId
+            + "', platform='" + platform + "'}";
+    }
+}

package/android/src/main/java/cn/jpush/android/api/CustomPushNotificationBuilder.java

@@ -0,0 +1,81 @@
+package cn.jpush.android.api;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.widget.RemoteViews;
+
+public class CustomPushNotificationBuilder extends BasicPushNotificationBuilder {
+    public int layoutTimeId;
+    public int layout;
+    public int layoutIconId;
+    public int layoutTitleId;
+    public int layoutContentId;
+    public int layoutIconDrawable = 0;
+
+    CustomPushNotificationBuilder(Context context) {
+        super(context);
+    }
+
+    public CustomPushNotificationBuilder(Context context, int layout, int layoutIconId, int layoutTitleId, int layoutContentId, int layoutTimeId) {
+        super(context);
+        this.layout = layout;
+        this.layoutIconId = layoutIconId;
+        this.layoutTitleId = layoutTitleId;
+        this.layoutContentId = layoutContentId;
+        this.layoutTimeId = layoutTimeId;
+        try {
+            ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), 0);
+            if (appInfo != null) {
+                this.layoutIconDrawable = appInfo.icon;
+            }
+        } catch (Throwable ignored) {
+        }
+    }
+
+    public CustomPushNotificationBuilder(Context context, int layout, int layoutIconId, int layoutTitleId, int layoutContentId) {
+        this(context, layout, layoutIconId, layoutTitleId, layoutContentId, 0);
+    }
+
+    @Override
+    RemoteViews buildContentView(String content, String title) {
+        RemoteViews remoteViews = new RemoteViews(this.builderContext.getPackageName(), this.layout);
+        remoteViews.setTextViewText(this.layoutTitleId, title);
+        remoteViews.setImageViewResource(this.layoutIconId, this.layoutIconDrawable);
+        remoteViews.setTextViewText(this.layoutContentId, content);
+        if (this.layoutTimeId != 0) {
+            remoteViews.setLong(this.layoutTimeId, "setTime", System.currentTimeMillis());
+        }
+        return remoteViews;
+    }
+
+    @Override
+    public String toString() {
+        return "custom_____" + serializeFields();
+    }
+
+    @Override
+    String serializeFields() {
+        return super.serializeFields()
+            + "_____" + this.layout
+            + "_____" + this.layoutIconId
+            + "_____" + this.layoutTitleId
+            + "_____" + this.layoutContentId
+            + "_____" + this.layoutIconDrawable
+            + "_____" + this.layoutTimeId;
+    }
+
+    @Override
+    void parseFields(String[] parts) {
+        super.parseFields(parts);
+        if (parts.length >= 10) {
+            this.layout = Integer.parseInt(parts[5]);
+            this.layoutIconId = Integer.parseInt(parts[6]);
+            this.layoutTitleId = Integer.parseInt(parts[7]);
+            this.layoutContentId = Integer.parseInt(parts[8]);
+            this.layoutIconDrawable = Integer.parseInt(parts[9]);
+        }
+        if (parts.length >= 11) {
+            this.layoutTimeId = Integer.parseInt(parts[10]);
+        }
+    }
+}

package/android/src/main/java/cn/jpush/android/api/DefaultPushNotificationBuilder.java

@@ -0,0 +1,90 @@
+package cn.jpush.android.api;
+
+import android.app.Notification;
+import android.content.Context;
+import android.os.Build;
+import android.text.TextUtils;
+import android.widget.RemoteViews;
+import java.util.HashMap;
+import java.util.Map;
+
+public class DefaultPushNotificationBuilder implements PushNotificationBuilder {
+    public static final int NOTI_STYLE_BIG_TEXT = 1;
+    public static final int NOTI_STYLE_INBOX = 2;
+    public static final int NOTI_STYLE_BIG_PICTURE = 3;
+
+    protected Context context;
+    protected NotificationMessage notificationMessage;
+
+    @Override
+    public Notification buildNotification(Context context, NotificationMessage message) {
+        this.context = context;
+        this.notificationMessage = message;
+        Map<String, String> params = new HashMap<String, String>();
+        if (message != null) {
+            params.put(JPushInterface.EXTRA_MSG_ID, message.msgId);
+            params.put(JPushInterface.EXTRA_ALERT, message.notificationContent);
+            params.put(JPushInterface.EXTRA_ALERT_TYPE, String.valueOf(message.notificationAlertType));
+            if (!TextUtils.isEmpty(message.notificationTitle)) {
+                params.put(JPushInterface.EXTRA_NOTIFICATION_TITLE, message.notificationTitle);
+            }
+            if (!TextUtils.isEmpty(message.notificationExtras)) {
+                params.put(JPushInterface.EXTRA_EXTRA, message.notificationExtras);
+            }
+        }
+        return buildNotification(params);
+    }
+
+    @Override
+    public Notification buildNotification(Map<String, String> params) {
+        if (this.context == null || params == null) {
+            return null;
+        }
+        String alert = params.get(JPushInterface.EXTRA_ALERT);
+        if (TextUtils.isEmpty(alert)) {
+            return null;
+        }
+        String title = params.get(JPushInterface.EXTRA_NOTIFICATION_TITLE);
+        if (TextUtils.isEmpty(title)) {
+            try {
+                title = this.context.getApplicationInfo().loadLabel(this.context.getPackageManager()).toString();
+            } catch (Throwable ignored) {
+                title = "";
+            }
+        }
+
+        Notification.Builder builder = new Notification.Builder(this.context);
+        builder.setContentTitle(title).setContentText(alert).setTicker(alert);
+        int iconRes = this.context.getApplicationInfo() != null ? this.context.getApplicationInfo().icon : 0;
+        builder.setSmallIcon(iconRes != 0 ? iconRes : android.R.color.transparent);
+        if (Build.VERSION.SDK_INT >= 17) {
+            builder.setShowWhen(true);
+        }
+
+        RemoteViews customView = buildContentView(alert, title);
+        if (customView != null) {
+            builder.setContent(customView);
+        }
+        Notification notification = getNotification(builder);
+        if (notification != null) {
+            resetNotificationParams(notification);
+        }
+        return notification;
+    }
+
+    RemoteViews buildContentView(String content, String title) {
+        return null;
+    }
+
+    void resetNotificationParams(Notification notification) {
+    }
+
+    Notification getNotification(Notification.Builder builder) {
+        return builder.build();
+    }
+
+    @Override
+    public String getDeveloperArg0() {
+        return null;
+    }
+}