feat: Status notifications (#2117)

makingthematrix · web-flow · commit 55a1995f2ee0 · 2019-05-07T12:19:12.000+02:00
* feat: Status notifications

The status (availability) affects the notifications now. If the status is set to 'Away'
the notifications are not displayed at all. If it's 'Busy' the notifications are displayed
only if certain requirements are met. Calls also are affected in a similar way.
diff --git a/app/build.gradle b/app/build.gradle
@@ -22,7 +22,7 @@ ext {
     playServicesVersion = '15.0.1'
     audioVersion = System.getenv("AUDIO_VERSION") ?: '1.209.0@aar'
     stethoVersion = '1.5.0'
-    zMessagingVersion = "141.0.2269"
+    zMessagingVersion = "141.0.2271"
     paging_version = "1.0.0"
 
     avsVersion = '4.9.170@aar'
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
@@ -1069,6 +1069,21 @@
     <string name="availability_text_busy">%1$s IS BUSY</string>
     <string name="availability_setstatus">SET A STATUS</string>
 
+    <string name="availability_notification_warning_away_title">You are set to Away</string>
+    <string name="availability_notification_warning_away">You will appear as Away to other people. You will not receive notifications about any incoming calls or messages.</string>
+    <string name="availability_notification_warning_busy_title">You are set to Busy</string>
+    <string name="availability_notification_warning_busy">You will appear as Busy to other people. You will only receive notifications for mentions, replies, and calls in conversations that are not muted.</string>
+    <string name="availability_notification_warning_available_title">You are set to Available</string>
+    <string name="availability_notification_warning_available">You will appear as Available to other people. You will receive notifications for incoming calls and for messages according to the Notifications setting in each conversation.</string>
+    <string name="availability_notification_warning_nostatus_title">No status set</string>
+    <string name="availability_notification_warning_nostatus">You will receive notifications for incoming calls and for messages according to the Notifications setting in each conversation.</string>
+    <string name="availability_notification_dont_show">Do not display this information again.</string>
+    <string name="availability_notification_ok">Ok</string>
+    <string name="availability_notification_blocked_title">Notifications are disabled in %1$s</string>
+    <string name="availability_notification_blocked">Status affects notifications now. You\'re set to \"Away\" and won\'t receive any notifications.</string>
+    <string name="availability_notification_changed_title">Notifications have changed in %1$s</string>
+    <string name="availability_notification_changed">Status affects notifications now. You\'re set to \"Busy\" and will only receive notifications when someone mentions you or replies to one of your messages.</string>
+
     <string name="preferences_profile_new">New Team or Account</string>
     <string name="preferences_profile_add_account">Add an account</string>
     <string name="preferences_profile_create_team">Create a team</string>
diff --git a/app/src/main/scala/com/waz/services/calling/CallingNotificationsService.scala b/app/src/main/scala/com/waz/services/calling/CallingNotificationsService.scala
@@ -22,15 +22,15 @@ import android.content.{Context, Intent}
 import android.os.IBinder
 import com.waz.zclient.ServiceHelper
 import com.waz.zclient.notifications.controllers.CallingNotificationsController
-import com.waz.zclient.notifications.controllers.CallingNotificationsController.androidNotificationBuilder
+import com.waz.zclient.notifications.controllers.CallingNotificationsController.{NotificationAction, androidNotificationBuilder}
 
 class CallingNotificationsService extends ServiceHelper {
   private lazy val callNCtrl = inject[CallingNotificationsController]
 
   implicit lazy val cxt: Context = getApplicationContext
 
   private lazy val sub = callNCtrl.notifications.map(_.find(_.isMainCall)).onUi {
-    case Some(not) =>
+    case Some(not) if not.action != NotificationAction.Nothing =>
       val builder = androidNotificationBuilder(not)
       startForeground(not.convId.str.hashCode, builder.build())
     case _ =>
diff --git a/app/src/main/scala/com/waz/zclient/MainActivity.scala b/app/src/main/scala/com/waz/zclient/MainActivity.scala
@@ -24,10 +24,11 @@ import android.graphics.drawable.ColorDrawable
 import android.graphics.{Color, Paint, PixelFormat}
 import android.os.{Build, Bundle}
 import android.support.v4.app.{Fragment, FragmentTransaction}
+import com.waz.content.{TeamsStorage, UserPreferences}
 import com.waz.content.UserPreferences._
 import com.waz.log.BasicLogging.LogTag.DerivedLogTag
 import com.waz.model.UserData.ConnectionStatus.{apply => _}
-import com.waz.model.{ConvId, UserId}
+import com.waz.model._
 import com.waz.service.AccountManager.ClientRegistrationState.{LimitReached, PasswordMissing, Registered, Unregistered}
 import com.waz.service.ZMessaging.clock
 import com.waz.service.{AccountManager, AccountsService, ZMessaging}
@@ -48,15 +49,17 @@ import com.waz.zclient.deeplinks.DeepLinkService.Error.{InvalidToken, SSOLoginTo
 import com.waz.zclient.deeplinks.DeepLinkService._
 import com.waz.zclient.fragments.ConnectivityFragment
 import com.waz.zclient.log.LogUI._
+import com.waz.zclient.messages.UsersController
 import com.waz.zclient.messages.controllers.NavigationController
+import com.waz.zclient.notifications.controllers.MessageNotificationsController
 import com.waz.zclient.pages.main.MainPhoneFragment
 import com.waz.zclient.pages.startup.UpdateFragment
 import com.waz.zclient.preferences.PreferencesActivity
 import com.waz.zclient.preferences.dialogs.ChangeHandleFragment
 import com.waz.zclient.tracking.UiTrackingController
 import com.waz.zclient.utils.ContextUtils._
 import com.waz.zclient.utils.StringUtils.TextDrawing
-import com.waz.zclient.utils.{Emojis, IntentUtils, ViewUtils}
+import com.waz.zclient.utils.{Emojis, IntentUtils, ResString, ViewUtils}
 import com.waz.zclient.views.LoadingIndicatorView
 
 import scala.collection.JavaConverters._
@@ -86,6 +89,8 @@ class MainActivity extends BaseActivity
   private lazy val spinnerController      = inject[SpinnerController]
   private lazy val passwordController     = inject[PasswordController]
   private lazy val deepLinkService        = inject[DeepLinkService]
+  private lazy val usersController        = inject[UsersController]
+  private lazy val userPreferences        = inject[Signal[UserPreferences]]
 
   override def onAttachedToWindow(): Unit = {
     super.onAttachedToWindow()
@@ -137,6 +142,32 @@ class MainActivity extends BaseActivity
       case false =>
     }
 
+    (for {
+      Some(user) <- userAccountsController.currentUser
+      teamName   <- user.teamId.fold(Signal.const(Option.empty[Name]))(teamId => Signal.future(inject[TeamsStorage].get(teamId).map(_.map(_.name))))
+      prefs      <- userPreferences
+      shouldWarn <- prefs(UserPreferences.ShouldWarnStatusNotifications).signal
+      avVisible  <- usersController.availabilityVisible
+    } yield (shouldWarn && avVisible, user.availability, teamName)).onUi {
+      case (true, Availability.Away, Some(teamName)) =>
+        inject[MessageNotificationsController].showAppNotification(
+          ResString(R.string.availability_notification_blocked_title, teamName.str),
+          ResString(R.string.availability_notification_blocked)
+        )
+        userPreferences.head.foreach(prefs =>
+          prefs(UserPreferences.ShouldWarnStatusNotifications) := false
+        )
+      case (true, Availability.Busy, Some(teamName)) =>
+        inject[MessageNotificationsController].showAppNotification(
+          ResString(R.string.availability_notification_changed_title, teamName.str),
+          ResString(R.string.availability_notification_changed)
+        )
+        userPreferences.head.foreach(prefs =>
+          prefs(UserPreferences.ShouldWarnStatusNotifications) := false
+        )
+      case _ =>
+    }
+
     ForceUpdateActivity.checkBlacklist(this)
 
     val loadingIndicator = findViewById[LoadingIndicatorView](R.id.progress_spinner)
diff --git a/app/src/main/scala/com/waz/zclient/notifications/controllers/CallingNotificationsController.scala b/app/src/main/scala/com/waz/zclient/notifications/controllers/CallingNotificationsController.scala
@@ -25,9 +25,8 @@ import android.os.Build
 import android.support.v4.app.NotificationCompat
 import com.waz.bitmap.BitmapUtils
 import com.waz.content.UserPreferences
-import com.waz.model.{ConvId, LocalInstant, Name, UserId}
+import com.waz.model._
 import com.waz.service.assets.AssetService.BitmapResult.BitmapLoaded
-import com.waz.service.call.CallInfo
 import com.waz.service.call.CallInfo.CallState._
 import com.waz.service.{AccountManager, AccountsService, GlobalModule, ZMessaging}
 import com.waz.services.calling.CallWakeService._
@@ -65,49 +64,66 @@ class CallingNotificationsController(implicit cxt: WireContext, eventContext: Ev
   val filteredGlobalProfile: Signal[(Option[ConvId], Seq[(ConvId, (UserId, UserId))])] =
     for {
       globalProfile <- inject[GlobalModule].calling.globalCallProfile
-      curCallId     = globalProfile.activeCall.map(_.convId)
-      allCalls = globalProfile.calls.values.filter(c => c.state == OtherCalling || (curCallId.contains(c.convId) && c.state != Ongoing))
-        .map(c => c.convId -> (c.caller, c.account)).toSeq
+      curCallId     =  globalProfile.activeCall.map(_.convId)
+      allCalls      =  globalProfile
+                         .calls
+                         .values
+                         .filter(c => c.state == OtherCalling || (curCallId.contains(c.convId) && c.state != Ongoing))
+                         .map(c => c.convId -> (c.caller, c.account))
+                         .toSeq
     } yield (curCallId, allCalls)
 
   val notifications =
     for {
-      zs <- inject[AccountsService].zmsInstances
+      zs                     <- inject[AccountsService].zmsInstances
       (curCallId, allCallsF) <- filteredGlobalProfile
-      bitmaps <- Signal.sequence(allCallsF.map { case (conv, (caller, account)) =>
-        zs.find(_.selfUserId == account).fold2(Signal.const(conv -> Option.empty[Bitmap]), z => getBitmapSignal(z, caller).map(conv -> _))
-      }: _*).map(_.toMap)
-      notInfo <- Signal.sequence(allCallsF.map { case (conv, (caller, account)) =>
-        zs.find(_.selfUserId == account).fold2(Signal.const(Option.empty[CallInfo], Name.Empty, Name.Empty, false),
-          z => Signal(z.calling.joinableCallsNotMuted.map(_.get(conv)),
-            z.usersStorage.optSignal(caller).map(_.map(_.name).getOrElse(Name.Empty)),
-            z.convsStorage.optSignal(conv).map(_.map(_.displayName).getOrElse(Name.Empty)),
-            z.conversations.groupConversation(conv))).map(conv -> _)
-      }: _*)
-      notificationData = notInfo.collect {
-        case (convId, (Some(callInfo), title, msg, isGroup)) =>
-          val action = callInfo.state match {
-            case OtherCalling => NotificationAction.DeclineOrJoin
-            case SelfConnected | SelfCalling | SelfJoining => NotificationAction.Leave
-            case _ => NotificationAction.Nothing
-          }
-          CallNotification(
-            convId.str.hashCode,
-            convId,
-            callInfo.account,
-            callInfo.startTime,
-            title,
-            msg,
-            bitmaps.getOrElse(convId, None),
-            curCallId.contains(convId),
-            action,
-            callInfo.isVideoCall,
-            isGroup)
-      }
+      bitmaps                <- Signal.sequence(allCallsF.map { case (conv, (caller, account)) =>
+                                  zs.find(_.selfUserId == account)
+                                    .fold2(
+                                      Signal.const(conv -> Option.empty[Bitmap]),
+                                      z => getBitmapSignal(z, caller).map(conv -> _)
+                                    )
+                                }: _*).map(_.toMap)
+      notInfo                <- Signal.sequence(allCallsF.map { case (conv, (caller, account)) =>
+                                  zs.find(_.selfUserId == account)
+                                    .fold2(
+                                      Signal.const(None, Name.Empty, None, false, Availability.None),
+                                      z => Signal(
+                                        z.calling.joinableCallsNotMuted.map(_.get(conv)),
+                                        z.usersStorage.optSignal(caller).map(_.map(_.name).getOrElse(Name.Empty)),
+                                        z.convsStorage.optSignal(conv),
+                                        z.conversations.groupConversation(conv),
+                                        z.usersStorage.optSignal(z.selfUserId).map(_.fold[Availability](Availability.None)(_.availability))
+                                      )).map(conv -> _)
+                                }: _*)
+      notificationData        = notInfo.collect {
+                                  case (convId, (Some(callInfo), title, conv, isGroup, availability)) =>
+                                    val muteSet = conv.fold(MuteSet.AllMuted)(_.muted)
+                                    val action  = (availability, muteSet, callInfo.state) match {
+                                      case (Availability.Away, _, _)                         => NotificationAction.Nothing
+                                      case (Availability.Busy, MuteSet.AllMuted, _)          => NotificationAction.Nothing
+                                      case (_, _, OtherCalling)                              => NotificationAction.DeclineOrJoin
+                                      case (_, _, SelfConnected | SelfCalling | SelfJoining) => NotificationAction.Leave
+                                      case _                                                 => NotificationAction.Nothing
+                                    }
+                                    CallNotification(
+                                      convId.str.hashCode,
+                                      convId,
+                                      callInfo.account,
+                                      callInfo.startTime,
+                                      title,
+                                      conv.fold(Name.Empty)(_.displayName),
+                                      bitmaps.getOrElse(convId, None),
+                                      curCallId.contains(convId),
+                                      action,
+                                      callInfo.isVideoCall,
+                                      isGroup
+                                    )
+                                }
     } yield notificationData.sortWith {
       case (cn1, _) if curCallId.contains(cn1.convId) => false
       case (_, cn2) if curCallId.contains(cn2.convId) => true
-      case (cn1, cn2) => cn1.convId.str > cn2.convId.str
+      case (cn1, cn2)                                 => cn1.convId.str > cn2.convId.str
     }
 
   private lazy val currentNotificationsPref = inject[Signal[AccountManager]].map(_.userPrefs(UserPreferences.CurrentNotifications))
@@ -139,27 +155,27 @@ class CallingNotificationsController(implicit cxt: WireContext, eventContext: Ev
     verbose(l"${nots.size} call notifications")
 
     cancelNots(nots)
-    nots.foreach { not =>
-
-      val builder = androidNotificationBuilder(not)
-
-      def showNotification() = {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-          verbose(l"Adding not: ${not.id}")
-          currentNotificationsPref.head.foreach(_.mutate(_ + not.id))
+    nots.foreach {
+      case not if not.action != NotificationAction.Nothing =>
+        val builder = androidNotificationBuilder(not)
+
+        def showNotification() = {
+          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            verbose(l"Adding not: ${not.id}")
+            currentNotificationsPref.head.foreach(_.mutate(_ + not.id))
+          }
+          notificationManager.notify(CallNotificationTag, not.id, builder.build())
         }
-        notificationManager.notify(CallNotificationTag, not.id, builder.build())
-      }
 
-      Try(showNotification()).recover {
-        case NonFatal(e) =>
-          error(l"Notify failed: try without bitmap", e)
-          builder.setLargeIcon(null)
-          try showNotification()
-          catch {
-            case NonFatal(e2) => error(l"second display attempt failed, aborting", e2)
-          }
-      }
+        Try(showNotification()).recover {
+          case NonFatal(e) =>
+            error(l"Notify failed: try without bitmap", e)
+            builder.setLargeIcon(null)
+            Try(showNotification()).recover {
+              case NonFatal(e2) => error(l"second display attempt failed, aborting", e2)
+            }
+        }
+      case _ =>
     }
   }
 
diff --git a/app/src/main/scala/com/waz/zclient/notifications/controllers/MessageNotificationsController.scala b/app/src/main/scala/com/waz/zclient/notifications/controllers/MessageNotificationsController.scala
@@ -48,6 +48,7 @@ import com.waz.zclient.messages.controllers.NavigationController
 import com.waz.zclient.utils.ContextUtils.{getInt, getIntArray, toPx}
 import com.waz.zclient.utils.{ResString, RingtoneUtils}
 import com.waz.zclient.{BuildConfig, Injectable, Injector, R}
+import org.threeten.bp.Instant
 
 import scala.concurrent.Future
 import scala.concurrent.duration._
@@ -107,6 +108,35 @@ class MessageNotificationsController(bundleEnabled: Boolean = Build.VERSION.SDK_
     } yield {}
   }
 
+  def showAppNotification(title: ResString, body: ResString): Future[Unit] = {
+    val contentTitle = SpannableWrapper(title, List(Span(Span.StyleSpanBold, Span.HeaderRange)))
+    val contentText = SpannableWrapper(
+      header = ResString(""),
+      body = body,
+      spans = List(Span(Span.ForegroundColorSpanBlack, Span.HeaderRange)),
+      separator = ""
+    )
+    for {
+      accountId <- selfId.head
+      color     <- notificationColor(accountId)
+    } yield {
+      val props = NotificationProps(
+        accountId,
+        when              = Some(Instant.now().toEpochMilli),
+        showWhen          = Some(true),
+        category          = Some(NotificationCompat.CATEGORY_MESSAGE),
+        priority          = Some(NotificationCompat.PRIORITY_HIGH),
+        smallIcon         = Some(R.drawable.ic_menu_logo),
+        openAccountIntent = Some(accountId),
+        color             = color,
+        contentTitle      = Some(contentTitle),
+        contentText       = Some(contentText),
+        style             = Some(StyleBuilder(StyleBuilder.BigText, title = contentTitle, bigText = Some(contentText)))
+      )
+      notificationManager.showNotification(accountId.hashCode(), props)
+    }
+  }
+
   private def fetchTeamName(userId: UserId) =
     for {
       storage <- userStorage.head
diff --git a/app/src/main/scala/com/waz/zclient/notifications/controllers/NotificationManagerWrapper.scala b/app/src/main/scala/com/waz/zclient/notifications/controllers/NotificationManagerWrapper.scala
@@ -187,7 +187,7 @@ case class NotificationProps(accountId:                UserId,
       "priority"                 -> priority,
       "smallIcon"                -> smallIcon,
       "contentTitle"             -> contentTitle,
-      "contentText "             -> contentText,
+      "contentText"              -> contentText,
       "style"                    -> style,
       "groupSummary"             -> groupSummary,
       "openAccountIntent"        -> openAccountIntent,
diff --git a/app/src/main/scala/com/waz/zclient/pages/main/MainPhoneFragment.scala b/app/src/main/scala/com/waz/zclient/pages/main/MainPhoneFragment.scala
