Add support for avatar status badge (presence)

css/_avatar.scss

 .avatar {
-    align-items: center;
     background-color: #AAA;
-    display: flex;
     border-radius: 50%;
     color: rgba(255, 255, 255, 0.6);
     font-weight: 100;
-    justify-content: center;
     object-fit: cover;
+
+    &.avatar-small {
+        height: 28px !important;
+        width: 28px !important;
+    }
+
+    &.avatar-xsmall {
+        height: 16px !important;
+        width: 16px !important;
+    }
+
+    .jitsi-icon {
+        transform: translateY(50%);
+    }
 }
 
 .avatar-foreign {
 
 .defaultAvatar {
     opacity: 0.6
+}
+
+.avatar-badge {
+    position: relative;
+
+    &-available::after {
+        @include avatarBadge;
+        background-color: $presence-available;
+    }
+
+    &-away::after {
+        @include avatarBadge;
+        background-color: $presence-away;
+    }
+
+    &-busy::after {
+        @include avatarBadge;
+        background-color: $presence-busy;
+    }
+
+    &-idle::after {
+        @include avatarBadge;
+        background-color: $presence-idle;
+    }
 }

css/_mixins.scss

  */
 @mixin transparentBg($color, $alpha) {
     background-color: rgba(red($color), green($color), blue($color), $alpha);
-}
+}
+
+/**
+ * Avatar status badge mixin
+ */
+@mixin avatarBadge {
+    border-radius: 50%;
+    content: '';
+    display: block;
+    height: 35%;
+    position: absolute;
+    bottom: 0;
+    width: 35%;
+}

css/_variables.scss

 $defaultSemiDarkColor: #ACACAC;
 $defaultDarkColor: #2b3d5c;
 $defaultWarningColor: rgb(215, 121, 118);
+$presence-available: rgb(110, 176, 5);
+$presence-away: rgb(250, 201, 20);
+$presence-busy: rgb(233, 0, 27);
+$presence-idle: rgb(172, 172, 172);
 
 /**
  * Toolbar

package-lock.json

         "@atlaskit/type-helpers": "^2.0.0"
       }
     },
-    "@atlaskit/avatar": {
-      "version": "14.1.7",
-      "resolved": "https://registry.npmjs.org/@atlaskit/avatar/-/avatar-14.1.7.tgz",
-      "integrity": "sha512-KGtV0lRr3g+JX3XLZQKDGxGhtbVFRvM/Ku5C+CEJw2uDl1KFY0dJxfr2a/E32bEgUuvmqSL7D3ROrTrlHJ2fMA==",
-      "requires": {
-        "@atlaskit/analytics-next": "^3.1.2",
-        "@atlaskit/theme": "^7.0.1",
-        "@atlaskit/tooltip": "^12.1.13",
-        "@babel/runtime": "^7.0.0"
-      },
-      "dependencies": {
-        "@atlaskit/analytics-next": {
-          "version": "3.1.2",
-          "resolved": "https://registry.npmjs.org/@atlaskit/analytics-next/-/analytics-next-3.1.2.tgz",
-          "integrity": "sha512-bkYDvl3Ojsnim+bsc9BALfvOjiL7xdb2rTp/4yqUP9pfidtf5HudbOJ849+dKcRCmk/rFbfB/nhDBRU6rv1Ueg==",
-          "requires": {
-            "@babel/runtime": "^7.0.0",
-            "babel-runtime": "^6.26.0",
-            "prop-types": "^15.5.10"
-          }
-        },
-        "@atlaskit/theme": {
-          "version": "7.0.1",
-          "resolved": "https://registry.npmjs.org/@atlaskit/theme/-/theme-7.0.1.tgz",
-          "integrity": "sha512-wxXDnkUablJketNCrQuNUuazufYEA7kv0Y6Yzv6uvqfuyNpWUQt4H1psz/MW8DbZmCdku9dEYbNVK3nFP5TDGg==",
-          "requires": {
-            "@babel/runtime": "^7.0.0",
-            "prop-types": "^15.5.10"
-          }
-        }
-      }
-    },
     "@atlaskit/blanket": {
       "version": "8.0.3",
       "resolved": "https://registry.npmjs.org/@atlaskit/blanket/-/blanket-8.0.3.tgz",

package.json

   "author": "",
   "readmeFilename": "README.md",
   "dependencies": {
-    "@atlaskit/avatar": "14.1.7",
     "@atlaskit/button": "10.1.1",
     "@atlaskit/checkbox": "5.0.10",
     "@atlaskit/dropdown-menu": "6.1.25",

react/features/base/avatar/components/Avatar.js

      */
     size: number,
 
+    /**
+     * One of the expected status strings (e.g. 'available') to render a badge on the avatar, if necessary.
+     */
+    status?: ?string,
+
     /**
      * URL of the avatar, if any.
      */
             colorBase,
             id,
             size,
+            status,
             url
         } = this.props;
         const { avatarFailed } = this.state;
             initials: undefined,
             onAvatarLoadError: undefined,
             size,
+            status,
             url: undefined
         };
 

react/features/base/avatar/components/native/StatelessAvatar.js

 
 type Props = AbstractProps & {
 
+    /**
+     * One of the expected status strings (e.g. 'available') to render a badge on the avatar, if necessary.
+     */
+    status?: ?string,
+
     /**
      * External style passed to the componant.
      */
         }
 
         return (
-            <View
-                style = { [
-                    styles.avatarContainer(size),
-                    style
-                ] }>
-                { avatar }
+            <View>
+                <View
+                    style = { [
+                        styles.avatarContainer(size),
+                        style
+                    ] }>
+                    { avatar }
+                </View>
+                { this._renderAvatarStatus() }
             </View>
         );
     }
 
     _isIcon: (?string | ?Object) => boolean
 
+    /**
+     * Renders a badge representing the avatar status.
+     *
+     * @returns {React$Elementaa}
+     */
+    _renderAvatarStatus() {
+        const { size, status } = this.props;
+
+        if (!status) {
+            return null;
+        }
+
+        return (
+            <View style = { styles.badgeContainer }>
+                <View style = { styles.badge(size, status) } />
+            </View>
+        );
+    }
+
     /**
      * Renders the default avatar.
      *

react/features/base/avatar/components/native/styles.js

 // @flow
 
+import { StyleSheet } from 'react-native';
+
 import { ColorPalette } from '../../../styles';
 
 const DEFAULT_SIZE = 65;
         };
     },
 
+    badge: (size: number = DEFAULT_SIZE, status: string) => {
+        let color;
+
+        switch (status) {
+        case 'available':
+            color = 'rgb(110, 176, 5)';
+            break;
+        case 'away':
+            color = 'rgb(250, 201, 20)';
+            break;
+        case 'busy':
+            color = 'rgb(233, 0, 27)';
+            break;
+        case 'idle':
+            color = 'rgb(172, 172, 172)';
+            break;
+        }
+
+        return {
+            backgroundColor: color,
+            borderRadius: size / 2,
+            bottom: 0,
+            height: size * 0.3,
+            position: 'absolute',
+            width: size * 0.3
+        };
+    },
+
+    badgeContainer: {
+        ...StyleSheet.absoluteFillObject
+    },
+
     initialsContainer: {
         alignItems: 'center',
         alignSelf: 'stretch',

react/features/base/avatar/components/web/StatelessAvatar.js

     /**
      * ID of the component to be rendered.
      */
-    id?: string
+    id?: string,
+
+    /**
+     * One of the expected status strings (e.g. 'available') to render a badge on the avatar, if necessary.
+     */
+    status?: ?string
 };
 
 /**
         if (this._isIcon(url)) {
             return (
                 <div
-                    className = { this._getAvatarClassName() }
+                    className = { `${this._getAvatarClassName()} ${this._getBadgeClassName()}` }
                     id = { this.props.id }
                     style = { this._getAvatarStyle(this.props.color) }>
                     <Icon
 
         if (url) {
             return (
-                <img
-                    className = { this._getAvatarClassName() }
-                    id = { this.props.id }
-                    onError = { this.props.onAvatarLoadError }
-                    src = { url }
-                    style = { this._getAvatarStyle() } />
+                <div className = { this._getBadgeClassName() }>
+                    <img
+                        className = { this._getAvatarClassName() }
+                        id = { this.props.id }
+                        onError = { this.props.onAvatarLoadError }
+                        src = { url }
+                        style = { this._getAvatarStyle() } />
+                </div>
             );
         }
 
         if (initials) {
             return (
                 <div
-                    className = { this._getAvatarClassName() }
+                    className = { `${this._getAvatarClassName()} ${this._getBadgeClassName()}` }
                     id = { this.props.id }
                     style = { this._getAvatarStyle(this.props.color) }>
                     <svg
 
         // default avatar
         return (
-            <img
-                className = { this._getAvatarClassName('defaultAvatar') }
-                id = { this.props.id }
-                src = { this.props.defaultAvatar || 'images/avatar.png' }
-                style = { this._getAvatarStyle() } />
+            <div className = { this._getBadgeClassName() }>
+                <img
+                    className = { this._getAvatarClassName('defaultAvatar') }
+                    id = { this.props.id }
+                    src = { this.props.defaultAvatar || 'images/avatar.png' }
+                    style = { this._getAvatarStyle() } />
+            </div>
         );
     }
 
         return `avatar ${additional || ''} ${this.props.className || ''}`;
     }
 
+    /**
+     * Generates a class name to render a badge on the avatar, if necessary.
+     *
+     * @returns {string}
+     */
+    _getBadgeClassName() {
+        const { status } = this.props;
+
+        if (status) {
+            return `avatar-badge avatar-badge-${status}`;
+        }
+
+        return '';
+    }
+
     _isIcon: (?string | ?Object) => boolean
 }

react/features/base/react/components/native/AvatarListItem.js

      */
     avatarSize?: number,
 
+    /**
+     * One of the expected status strings (e.g. 'available') to render a badge on the avatar, if necessary.
+     */
+    avatarStatus?: ?string,
+
     /**
      * External style to be applied to the avatar (icon).
      */
         const {
             avatarOnly,
             avatarSize = AVATAR_SIZE,
+            avatarStatus,
             avatarStyle
         } = this.props;
         const { avatar, colorBase, lines, title } = this.props.item;
                     colorBase = { colorBase }
                     displayName = { title }
                     size = { avatarSize }
+                    status = { avatarStatus }
                     style = { avatarStyle }
                     url = { avatar } />
                 { avatarOnly || <Container style = { styles.listItemDetails }>

react/features/invite/components/add-people-dialog/native/AddPeopleDialog.js

                     <AvatarListItem
                         avatarOnly = { true }
                         avatarSize = { AVATAR_SIZE }
+                        avatarStatus = { item.status }
                         avatarStyle = { styles.avatar }
                         avatarTextStyle = { styles.avatarText }
                         item = { renderableItem }
                     style = { styles.itemWrapper }>
                     <AvatarListItem
                         avatarSize = { AVATAR_SIZE }
+                        avatarStatus = { item.status }
                         avatarStyle = { styles.avatar }
                         avatarTextStyle = { styles.avatarText }
                         item = { renderableItem }

react/features/invite/components/add-people-dialog/web/AddPeopleDialog.js

 // @flow
 
-import Avatar from '@atlaskit/avatar';
 import InlineMessage from '@atlaskit/inline-message';
 import React from 'react';
 import type { Dispatch } from 'redux';
 
 import { createInviteDialogEvent, sendAnalytics } from '../../../../analytics';
+import { Avatar } from '../../../../base/avatar';
 import { Dialog, hideDialog } from '../../../../base/dialog';
 import { translate, translateToHTML } from '../../../../base/i18n';
 import { Icon, IconPhone } from '../../../../base/icons';
             return {
                 content: user.name,
                 elemBefore: <Avatar
-                    size = 'small'
-                    src = { user.avatar } />,
+                    className = { 'avatar-small' }
+                    status = { user.status }
+                    url = { user.avatar } />,
                 item: user,
                 tag: {
                     elemBefore: <Avatar
-                        size = 'xsmall'
-                        src = { user.avatar } />
+                        className = { 'avatar-xsmall' }
+                        status = { user.status }
+                        url = { user.avatar } />
                 },
                 value: user.id || user.user_id
             };