@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationBehavior.java

@@ -0,0 +1,84 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import expo.modules.core.Promise;
+import expo.modules.core.arguments.ReadableArguments;
+
+import androidx.annotation.Nullable;
+import expo.modules.notifications.notifications.enums.NotificationPriority;
+import expo.modules.notifications.notifications.handling.NotificationsHandler;
+
+/**
+ * A POJO representing behavior with which the notification should be presented.
+ * <p>
+ * Used in {@link NotificationsHandler#handleNotificationAsync(String, ReadableArguments, Promise)}.
+ */
+public class NotificationBehavior implements Parcelable {
+  private final boolean mShouldShowAlert;
+  private final boolean mShouldPlaySound;
+  private final boolean mShouldSetBadge;
+
+  @Nullable
+  private final String mPriorityOverride;
+
+  public NotificationBehavior(boolean shouldShowAlert, boolean shouldPlaySound, boolean shouldSetBadge, @Nullable String priorityOverride) {
+    mShouldShowAlert = shouldShowAlert;
+    mShouldPlaySound = shouldPlaySound;
+    mShouldSetBadge = shouldSetBadge;
+    mPriorityOverride = priorityOverride;
+  }
+
+  private NotificationBehavior(Parcel in) {
+    mShouldShowAlert = in.readByte() != 0;
+    mShouldPlaySound = in.readByte() != 0;
+    mShouldSetBadge = in.readByte() != 0;
+    mPriorityOverride = in.readString();
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeByte((byte) (mShouldShowAlert ? 1 : 0));
+    dest.writeByte((byte) (mShouldPlaySound ? 1 : 0));
+    dest.writeByte((byte) (mShouldSetBadge ? 1 : 0));
+    dest.writeString(mPriorityOverride);
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  public static final Creator<NotificationBehavior> CREATOR = new Creator<NotificationBehavior>() {
+    @Override
+    public NotificationBehavior createFromParcel(Parcel in) {
+      return new NotificationBehavior(in);
+    }
+
+    @Override
+    public NotificationBehavior[] newArray(int size) {
+      return new NotificationBehavior[size];
+    }
+  };
+
+  @Nullable
+  public NotificationPriority getPriorityOverride() {
+    if (mPriorityOverride == null) {
+      return null;
+    }
+    return NotificationPriority.fromEnumValue(mPriorityOverride);
+  }
+
+  public boolean shouldShowAlert() {
+    return mShouldShowAlert;
+  }
+
+  public boolean shouldPlaySound() {
+    return mShouldPlaySound;
+  }
+
+  public boolean shouldSetBadge() {
+    return mShouldSetBadge;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationCategory.java

@@ -0,0 +1,61 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A class representing a collection of notification actions.
+ */
+public class NotificationCategory implements Parcelable, Serializable {
+  private final String mIdentifier;
+  private final List<NotificationAction> mActions;
+
+  public NotificationCategory(String identifier, List<NotificationAction> actions) {
+    mIdentifier = identifier;
+    mActions = actions;
+  }
+
+  private NotificationCategory(Parcel in) {
+    mIdentifier = in.readString();
+    mActions = in.readArrayList(NotificationAction.class.getClassLoader());
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeString(mIdentifier);
+    dest.writeList(mActions);
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  public static final Creator<NotificationCategory> CREATOR = new Creator<NotificationCategory>() {
+    @Override
+    public NotificationCategory createFromParcel(Parcel in) {
+      return new NotificationCategory(in);
+    }
+
+    @Override
+    public NotificationCategory[] newArray(int size) {
+      return new NotificationCategory[size];
+    }
+  };
+
+  public String getIdentifier() {
+    return mIdentifier;
+  }
+
+  public List<NotificationAction> getActions() {
+    if (mActions == null) {
+      return Collections.emptyList();
+    }
+    return mActions;
+  }
+
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationContent.java

@@ -0,0 +1,356 @@
+package expo.modules.notifications.notifications.model;
+
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+import androidx.annotation.Nullable;
+
+import expo.modules.notifications.notifications.enums.NotificationPriority;
+
+/**
+ * A POJO representing a notification content: title, message, body, etc. Instances
+ * should be created using {@link NotificationContent.Builder}.
+ */
+public class NotificationContent implements Parcelable, Serializable {
+  private String mTitle;
+  private String mText;
+  private String mSubtitle;
+  private Number mBadgeCount;
+  private boolean mShouldPlayDefaultSound;
+  private Uri mSound;
+  private boolean mShouldUseDefaultVibrationPattern;
+  private long[] mVibrationPattern;
+  private JSONObject mBody;
+  private NotificationPriority mPriority;
+  private Number mColor;
+  private boolean mAutoDismiss;
+  private String mCategoryId;
+  private boolean mSticky;
+
+  protected NotificationContent() {
+  }
+
+  public static final Creator<NotificationContent> CREATOR = new Creator<NotificationContent>() {
+    @Override
+    public NotificationContent createFromParcel(Parcel in) {
+      return new NotificationContent(in);
+    }
+
+    @Override
+    public NotificationContent[] newArray(int size) {
+      return new NotificationContent[size];
+    }
+  };
+
+  @Nullable
+  public String getTitle() {
+    return mTitle;
+  }
+
+  @Nullable
+  public String getText() {
+    return mText;
+  }
+
+  @Nullable
+  public String getSubtitle() {
+    return mSubtitle;
+  }
+
+  @Nullable
+  public Number getBadgeCount() {
+    return mBadgeCount;
+  }
+
+  public boolean shouldPlayDefaultSound() {
+    return mShouldPlayDefaultSound;
+  }
+
+  @Nullable
+  public Uri getSound() {
+    return mSound;
+  }
+
+  public boolean shouldUseDefaultVibrationPattern() {
+    return mShouldUseDefaultVibrationPattern;
+  }
+
+  @Nullable
+  public long[] getVibrationPattern() {
+    return mVibrationPattern;
+  }
+
+  @Nullable
+  public JSONObject getBody() {
+    return mBody;
+  }
+
+  @Nullable
+  public NotificationPriority getPriority() {
+    return mPriority;
+  }
+
+  @Nullable
+  public Number getColor() {
+    return mColor;
+  }
+
+  public boolean isAutoDismiss() {
+    return mAutoDismiss;
+  }
+
+  public String getCategoryId() {
+    return mCategoryId;
+  }
+  
+  public boolean isSticky() {
+    return mSticky;
+  }
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  protected NotificationContent(Parcel in) {
+    mTitle = in.readString();
+    mText = in.readString();
+    mSubtitle = in.readString();
+    mBadgeCount = (Number) in.readSerializable();
+    mShouldPlayDefaultSound = in.readByte() != 0;
+    mSound = in.readParcelable(getClass().getClassLoader());
+    mShouldUseDefaultVibrationPattern = in.readByte() != 0;
+    mVibrationPattern = in.createLongArray();
+    try {
+      mBody = new JSONObject(in.readString());
+    } catch (JSONException | NullPointerException e) {
+      // do nothing
+    }
+    Number priorityNumber = (Number) in.readSerializable();
+    if (priorityNumber != null) {
+      mPriority = NotificationPriority.fromNativeValue(priorityNumber.intValue());
+    }
+    mColor = (Number) in.readSerializable();
+    mAutoDismiss = in.readByte() == 1;
+    mCategoryId = in.readString();
+    mSticky = in.readByte() == 1;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeString(mTitle);
+    dest.writeString(mText);
+    dest.writeString(mSubtitle);
+    dest.writeSerializable(mBadgeCount);
+    dest.writeByte((byte) (mShouldPlayDefaultSound ? 1 : 0));
+    dest.writeParcelable(mSound, 0);
+    dest.writeByte((byte) (mShouldUseDefaultVibrationPattern ? 1 : 0));
+    dest.writeLongArray(mVibrationPattern);
+    dest.writeString(mBody != null ? mBody.toString() : null);
+    dest.writeSerializable(mPriority != null ? mPriority.getNativeValue() : null);
+    dest.writeSerializable(mColor);
+    dest.writeByte((byte) (mAutoDismiss ? 1 : 0));
+    dest.writeString(mCategoryId);
+    dest.writeByte((byte) (mSticky ? 1 : 0));
+  }
+
+  //                                           EXPONOTIFCONTENT02
+  private static final long serialVersionUID = 397666843266836802L;
+
+  private void writeObject(java.io.ObjectOutputStream out) throws IOException {
+    out.writeObject(mTitle);
+    out.writeObject(mText);
+    out.writeObject(mSubtitle);
+    out.writeObject(mBadgeCount);
+    out.writeByte(mShouldPlayDefaultSound ? 1 : 0);
+    out.writeObject(mSound == null ? null : mSound.toString());
+    out.writeByte(mShouldUseDefaultVibrationPattern ? 1 : 0);
+    if (mVibrationPattern == null) {
+      out.writeInt(-1);
+    } else {
+      out.writeInt(mVibrationPattern.length);
+      for (long duration : mVibrationPattern) {
+        out.writeLong(duration);
+      }
+    }
+    out.writeObject(mBody != null ? mBody.toString() : null);
+    out.writeObject(mPriority != null ? mPriority.getNativeValue() : null);
+    out.writeObject(mColor);
+    out.writeByte(mAutoDismiss ? 1 : 0);
+    out.writeObject(mCategoryId != null ? mCategoryId.toString() : null);
+    out.writeByte(mSticky ? 1 : 0);
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
+    mTitle = (String) in.readObject();
+    mText = (String) in.readObject();
+    mSubtitle = (String) in.readObject();
+    mBadgeCount = (Number) in.readObject();
+    mShouldPlayDefaultSound = in.readByte() == 1;
+    String soundUri = (String) in.readObject();
+    if (soundUri == null) {
+      mSound = null;
+    } else {
+      mSound = Uri.parse(soundUri);
+    }
+    mShouldUseDefaultVibrationPattern = in.readByte() == 1;
+    int vibrationPatternLength = in.readInt();
+    if (vibrationPatternLength < 0) {
+      mVibrationPattern = null;
+    } else {
+      mVibrationPattern = new long[vibrationPatternLength];
+      for (int i = 0; i < vibrationPatternLength; i++) {
+        mVibrationPattern[i] = in.readLong();
+      }
+    }
+    String bodyString = (String) in.readObject();
+    if (bodyString == null) {
+      mBody = null;
+    } else {
+      try {
+        mBody = new JSONObject(bodyString);
+      } catch (JSONException | NullPointerException e) {
+        // do nothing
+      }
+    }
+    Number priorityNumber = (Number) in.readObject();
+    if (priorityNumber != null) {
+      mPriority = NotificationPriority.fromNativeValue(priorityNumber.intValue());
+    }
+    mColor = (Number) in.readObject();
+    mAutoDismiss = in.readByte() == 1;
+    String categoryIdString = (String) in.readObject();
+    if (categoryIdString == null) {
+      mCategoryId = null;
+    } else {
+      mCategoryId = new String(categoryIdString);
+    }
+    mSticky = in.readByte() == 1;
+  }
+
+  private void readObjectNoData() throws ObjectStreamException {
+  }
+
+  public static class Builder {
+    private String mTitle;
+    private String mText;
+    private String mSubtitle;
+    private Number mBadgeCount;
+    private boolean mShouldPlayDefaultSound;
+    private Uri mSound;
+    private boolean mShouldUseDefaultVibrationPattern;
+    private long[] mVibrationPattern;
+    private JSONObject mBody;
+    private NotificationPriority mPriority;
+    private Number mColor;
+    private boolean mAutoDismiss;
+    private String mCategoryId;
+    private boolean mSticky;
+
+    public Builder() {
+      useDefaultSound();
+      useDefaultVibrationPattern();
+    }
+
+    public Builder setTitle(String title) {
+      mTitle = title;
+      return this;
+    }
+
+    public Builder setSubtitle(String subtitle) {
+      mSubtitle = subtitle;
+      return this;
+    }
+
+    public Builder setText(String text) {
+      mText = text;
+      return this;
+    }
+
+    public Builder setBody(JSONObject body) {
+      mBody = body;
+      return this;
+    }
+
+    public Builder setPriority(NotificationPriority priority) {
+      mPriority = priority;
+      return this;
+    }
+
+    public Builder setBadgeCount(Number badgeCount) {
+      mBadgeCount = badgeCount;
+      return this;
+    }
+
+    public Builder useDefaultVibrationPattern() {
+      mShouldUseDefaultVibrationPattern = true;
+      mVibrationPattern = null;
+      return this;
+    }
+
+    public Builder setVibrationPattern(long[] vibrationPattern) {
+      mShouldUseDefaultVibrationPattern = false;
+      mVibrationPattern = vibrationPattern;
+      return this;
+    }
+
+    public Builder useDefaultSound() {
+      mShouldPlayDefaultSound = true;
+      mSound = null;
+      return this;
+    }
+
+    public Builder setSound(Uri sound) {
+      mShouldPlayDefaultSound = false;
+      mSound = sound;
+      return this;
+    }
+
+    public Builder setColor(Number color) {
+      mColor = color;
+      return this;
+    }
+
+    public Builder setAutoDismiss(boolean autoDismiss) {
+      mAutoDismiss = autoDismiss;
+      return this;
+    }
+
+    public Builder setCategoryId(String categoryId) {
+      mCategoryId = categoryId;
+      return this;
+    }
+    
+    public Builder setSticky(boolean sticky) {
+      mSticky = sticky;
+      return this;
+    }
+
+    public NotificationContent build() {
+      NotificationContent content = new NotificationContent();
+      content.mTitle = mTitle;
+      content.mSubtitle = mSubtitle;
+      content.mText = mText;
+      content.mBadgeCount = mBadgeCount;
+      content.mShouldUseDefaultVibrationPattern = mShouldUseDefaultVibrationPattern;
+      content.mVibrationPattern = mVibrationPattern;
+      content.mShouldPlayDefaultSound = mShouldPlayDefaultSound;
+      content.mSound = mSound;
+      content.mBody = mBody;
+      content.mPriority = mPriority;
+      content.mColor = mColor;
+      content.mAutoDismiss = mAutoDismiss;
+      content.mCategoryId = mCategoryId;
+      content.mSticky = mSticky;
+      return content;
+    }
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationRequest.java

@@ -0,0 +1,66 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.io.Serializable;
+
+import expo.modules.notifications.notifications.interfaces.NotificationTrigger;
+
+/**
+ * A class representing notification request. A notification request has some content {@link #mContent},
+ * is triggered by some {@link #mTrigger} and is identifiable by {@link #mIdentifier}.
+ */
+public class NotificationRequest implements Parcelable, Serializable {
+  private String mIdentifier;
+  private NotificationContent mContent;
+  private NotificationTrigger mTrigger;
+
+  public NotificationRequest(String identifier, NotificationContent content, NotificationTrigger trigger) {
+    mIdentifier = identifier;
+    mContent = content;
+    mTrigger = trigger;
+  }
+
+  public NotificationContent getContent() {
+    return mContent;
+  }
+
+  public String getIdentifier() {
+    return mIdentifier;
+  }
+
+  public NotificationTrigger getTrigger() {
+    return mTrigger;
+  }
+
+  protected NotificationRequest(Parcel in) {
+    mIdentifier = in.readString();
+    mContent = in.readParcelable(getClass().getClassLoader());
+    mTrigger = in.readParcelable(getClass().getClassLoader());
+  }
+
+  public static final Creator<NotificationRequest> CREATOR = new Creator<NotificationRequest>() {
+    @Override
+    public NotificationRequest createFromParcel(Parcel in) {
+      return new NotificationRequest(in);
+    }
+
+    @Override
+    public NotificationRequest[] newArray(int size) {
+      return new NotificationRequest[size];
+    }
+  };
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeString(mIdentifier);
+    dest.writeParcelable(mContent, 0);
+    dest.writeParcelable(mTrigger, 0);
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/NotificationResponse.java

@@ -0,0 +1,60 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * A POJO representing user's response to a notification. It may be a default action,
+ * i.e. a tap on the notification ({@link #DEFAULT_ACTION_IDENTIFIER}).
+ */
+public class NotificationResponse implements Parcelable {
+  public static final String DEFAULT_ACTION_IDENTIFIER = "expo.modules.notifications.actions.DEFAULT";
+
+  private NotificationAction mAction;
+  private Notification mNotification;
+
+  public NotificationResponse(NotificationAction action, Notification notification) {
+    mAction = action;
+    mNotification = notification;
+  }
+
+  public NotificationAction getAction() {
+    return mAction;
+  }
+
+  public String getActionIdentifier() {
+    return mAction.getIdentifier();
+  }
+
+  public Notification getNotification() {
+    return mNotification;
+  }
+
+  public static final Creator<NotificationResponse> CREATOR = new Creator<NotificationResponse>() {
+    @Override
+    public NotificationResponse createFromParcel(Parcel in) {
+      return new NotificationResponse(in);
+    }
+
+    @Override
+    public NotificationResponse[] newArray(int size) {
+      return new NotificationResponse[size];
+    }
+  };
+
+  @Override
+  public int describeContents() {
+    return 0;
+  }
+
+  protected NotificationResponse(Parcel in) {
+    mAction = in.readParcelable(getClass().getClassLoader());
+    mNotification = in.readParcelable(getClass().getClassLoader());
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    dest.writeParcelable(mAction, 0);
+    dest.writeParcelable(mNotification, 0);
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/TextInputNotificationAction.java

@@ -0,0 +1,42 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+
+/**
+ * A class representing a single direct reply notification action.
+ */
+public class TextInputNotificationAction extends NotificationAction {
+  private final String mPlaceholder;
+
+  public TextInputNotificationAction(String identifier, String title, boolean opensAppToForeground, String placeholder) {
+    super(identifier, title, opensAppToForeground);
+    mPlaceholder = placeholder;
+  }
+
+  private TextInputNotificationAction(Parcel in) {
+    super(in);
+    mPlaceholder = in.readString();
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeString(mPlaceholder);
+  }
+
+  public static final Creator<TextInputNotificationAction> CREATOR = new Creator<TextInputNotificationAction>() {
+    @Override
+    public TextInputNotificationAction createFromParcel(Parcel in) {
+      return new TextInputNotificationAction(in);
+    }
+
+    @Override
+    public TextInputNotificationAction[] newArray(int size) {
+      return new TextInputNotificationAction[size];
+    }
+  };
+
+  public String getPlaceholder() {
+    return mPlaceholder;
+  }
+}

package/android/src/main/java/expo/modules/notifications/notifications/model/TextInputNotificationResponse.java

@@ -0,0 +1,42 @@
+package expo.modules.notifications.notifications.model;
+
+import android.os.Parcel;
+
+/**
+ * A POJO representing user's response to a text input notification action
+ */
+public class TextInputNotificationResponse extends NotificationResponse {
+  private String mUserText;
+
+  public TextInputNotificationResponse(NotificationAction action, Notification notification, String userText) {
+    super(action, notification);
+    mUserText = userText;
+  }
+
+  public String getUserText() {
+    return mUserText;
+  }
+
+  public static final Creator<TextInputNotificationResponse> CREATOR = new Creator<TextInputNotificationResponse>() {
+    @Override
+    public TextInputNotificationResponse createFromParcel(Parcel in) {
+      return new TextInputNotificationResponse(in);
+    }
+
+    @Override
+    public TextInputNotificationResponse[] newArray(int size) {
+      return new TextInputNotificationResponse[size];
+    }
+  };
+
+  protected TextInputNotificationResponse(Parcel in) {
+    super(in);
+    mUserText = in.readString();
+  }
+
+  @Override
+  public void writeToParcel(Parcel dest, int flags) {
+    super.writeToParcel(dest, flags);
+    dest.writeString(mUserText);
+  }
+}