fix(LoginDialog.native): no 'password incorrect' initially

Do not show the 'Password is incorrect' message when the LoginDialog
opens for the first time.

react/features/authentication/components/LoginDialog.native.js

          */
         _error: PropTypes.string,
 
+        /**
+         * The credential that the user has failed to authenticate with.
+         */
+        _errorCredentials: PropTypes.object,
+
         /**
          * Any extra details about the error provided by lib-jitsi-meet.
          */
         const {
             _connecting: connecting,
             _error: error,
+            _errorCredentials: errorCredentials,
             _errorDetails: errorDetails,
             t
         } = this.props;
         const messageOptions = {};
 
         if (error === JitsiConnectionErrors.PASSWORD_REQUIRED) {
-            messageKey = 'dialog.incorrectPassword';
+            // Show the message if there's been a user ID or password provided.
+            messageKey
+                = errorCredentials
+                        && (errorCredentials.jid || errorCredentials.password)
+                    ? 'dialog.incorrectPassword'
+                    : null;
         } else if (error) {
             messageKey = 'dialog.connectErrorWithMsg';
             messageOptions.msg = `${error} ${errorDetails}`;
                         value = { this.state.password } />
                     <Text style = { styles.loginDialogText }>
                         {
-                            error
+                            messageKey
                                 ? t(messageKey, messageOptions)
                                 : connecting
                                     ? t('connection.CONNECTING')
  *     _configHosts: Object,
  *     _connecting: boolean,
  *     _error: string,
+ *     _errorCredentials: Object,
  *     _errorDetails: string
  * }}
  */
     const { hosts: configHosts } = state['features/base/config'];
     const {
         connecting,
+        credentials,
         error: connectionError,
         errorMessage: connectionErrorMessage
     } = state['features/base/connection'];
 
     let error;
+    let errorCredentials;
     let errorDetails;
 
     if (connectionError) {
         error = connectionError;
+        errorCredentials = credentials;
         errorDetails = connectionErrorMessage;
     } else if (upgradeRoleError) {
         error
             = upgradeRoleError.connectionError
                 || upgradeRoleError.authenticationError;
+        errorCredentials = upgradeRoleError.credentials;
         errorDetails = upgradeRoleError.message;
     }
 
         _configHosts: configHosts,
         _connecting: Boolean(connecting) || Boolean(upgradeRoleInProgress),
         _error: error,
+        _errorCredentials: errorCredentials,
         _errorDetails: errorDetails
     };
 }

react/features/base/connection/actions.native.js

          * Rejects external promise when connection fails.
          *
          * @param {JitsiConnectionErrors} err - Connection error.
-         * @param {string} msg - Error message supplied by lib-jitsi-meet.
+         * @param {string} [msg] - Error message supplied by lib-jitsi-meet.
+         * @param {Object} [credentials] - The invalid credentials that were
+         * used to authenticate and the authentication failed.
+         * @param {string} [credentials.jid] - The XMPP user's ID.
+         * @param {string} [credentials.password] - The XMPP user's password.
          * @returns {void}
          * @private
          */
-        function _onConnectionFailed(err, msg) {
+        function _onConnectionFailed(err, msg, credentials) {
             unsubscribe();
             console.error('CONNECTION FAILED:', err, msg);
-            dispatch(connectionFailed(connection, err, msg));
+            dispatch(connectionFailed(connection, err, msg, credentials));
         }
 
         /**
     };
 }
 
+/* eslint-disable max-params */
+
 /**
  * Create an action for when the signaling connection could not be created.
  *
  * @param {JitsiConnection} connection - The JitsiConnection which failed.
  * @param {string} error - Error.
- * @param {string} message - Error message.
+ * @param {string} [message] - Error message.
+ * @param {Object} [credentials] - The invalid credentials that failed
+ * the authentication.
  * @public
  * @returns {{
  *     type: CONNECTION_FAILED,
  *     connection: JitsiConnection,
+ *     credentials: Object,
  *     error: string,
  *     message: string
  * }}
 export function connectionFailed(
         connection: Object,
         error: string,
-        message: ?string) {
+        message: ?string,
+        credentials: ?Object) {
     return {
         type: CONNECTION_FAILED,
         connection,
+        credentials,
         error,
         message
     };
 }
 
+/* eslint-enable max-params */
+
 /**
  * Constructs options to be passed to the constructor of {@code JitsiConnection}
  * based on the redux state.

react/features/base/connection/reducer.js

  */
 function _connectionFailed(
         state: Object,
-        { connection, error, message }: {
+        { connection, credentials, error, message }: {
             connection: Object,
+            credentials: ?Object,
             error: string,
             message: ?string
         }) {
     return assign(state, {
         connecting: undefined,
         connection: undefined,
+        credentials,
         error,
         errorMessage: message
     });
         { connection }: { connection: Object }) {
     return assign(state, {
         connecting: connection,
+        credentials: undefined,
         error: undefined,
         errorMessage: undefined
     });