diff --git a/core/java/android/app/admin/PasswordMetrics.java b/core/java/android/app/admin/PasswordMetrics.java
index 759597ce36dcb..4c1a36340d5d5 100644
--- a/core/java/android/app/admin/PasswordMetrics.java
+++ b/core/java/android/app/admin/PasswordMetrics.java
@@ -531,7 +531,7 @@ public final class PasswordMetrics implements Parcelable {
         }
 
         final PasswordMetrics enteredMetrics = computeForPasswordOrPin(password, isPin);
-        return validatePasswordMetrics(adminMetrics, minComplexity, isPin, enteredMetrics);
+        return validatePasswordMetrics(adminMetrics, minComplexity, enteredMetrics);
     }
 
     /**
@@ -539,15 +539,13 @@ public final class PasswordMetrics implements Parcelable {
      *
      * @param adminMetrics - minimum metrics to satisfy admin requirements.
      * @param minComplexity - minimum complexity imposed by the requester.
-     * @param isPin - whether it is PIN that should be only digits
      * @param actualMetrics - metrics for password to validate.
      * @return a list of password validation errors. An empty list means the password is OK.
      *
      * TODO: move to PasswordPolicy
      */
     public static List<PasswordValidationError> validatePasswordMetrics(
-            PasswordMetrics adminMetrics, int minComplexity, boolean isPin,
-            PasswordMetrics actualMetrics) {
+            PasswordMetrics adminMetrics, int minComplexity, PasswordMetrics actualMetrics) {
         final ComplexityBucket bucket = ComplexityBucket.forComplexity(minComplexity);
 
         // Make sure credential type is satisfactory.
@@ -561,7 +559,7 @@ public final class PasswordMetrics implements Parcelable {
             return Collections.emptyList(); // Nothing to check for pattern or none.
         }
 
-        if (isPin && actualMetrics.nonNumeric > 0) {
+        if (actualMetrics.credType == CREDENTIAL_TYPE_PIN && actualMetrics.nonNumeric > 0) {
             return Collections.singletonList(
                     new PasswordValidationError(CONTAINS_INVALID_CHARACTERS, 0));
         }
diff --git a/core/tests/coretests/src/android/app/admin/PasswordMetricsTest.java b/core/tests/coretests/src/android/app/admin/PasswordMetricsTest.java
index b2b9ab31282ca..c9a18dafe11d4 100644
--- a/core/tests/coretests/src/android/app/admin/PasswordMetricsTest.java
+++ b/core/tests/coretests/src/android/app/admin/PasswordMetricsTest.java
@@ -30,6 +30,7 @@ import static android.app.admin.PasswordMetrics.validatePasswordMetrics;
 import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_NONE;
 import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PASSWORD;
 import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PATTERN;
+import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PIN;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -284,33 +285,42 @@ public class PasswordMetricsTest {
         PasswordMetrics none = new PasswordMetrics(CREDENTIAL_TYPE_NONE);
         PasswordMetrics pattern = new PasswordMetrics(CREDENTIAL_TYPE_PATTERN);
         PasswordMetrics password = new PasswordMetrics(CREDENTIAL_TYPE_PASSWORD);
+        PasswordMetrics pin = new PasswordMetrics(CREDENTIAL_TYPE_PIN);
 
         // To pass minimal length check.
         password.length = 4;
+        pin.length = 4;
 
         // No errors expected, credential is of stronger or equal type.
         assertValidationErrors(
-                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, none));
+                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, none));
         assertValidationErrors(
-                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, pattern));
+                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, pattern));
         assertValidationErrors(
-                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, password));
+                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, password));
         assertValidationErrors(
-                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, pattern));
+                validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, pin));
         assertValidationErrors(
-                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, password));
+                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, pattern));
         assertValidationErrors(
-                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, password));
+                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, password));
+        assertValidationErrors(
+                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, password));
+        assertValidationErrors(
+                validatePasswordMetrics(pin, PASSWORD_COMPLEXITY_NONE, pin));
 
         // Now actual credential type is weaker than required:
         assertValidationErrors(
-                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, none),
+                validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, none),
                 PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
         assertValidationErrors(
-                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, none),
+                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, none),
                 PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
         assertValidationErrors(
-                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, pattern),
+                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, pattern),
+                PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
+        assertValidationErrors(
+                validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, pin),
                 PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
     }
 
diff --git a/services/core/java/com/android/server/locksettings/LockSettingsShellCommand.java b/services/core/java/com/android/server/locksettings/LockSettingsShellCommand.java
index 6a5c2d89a4e28..a73c8e0c914ad 100644
--- a/services/core/java/com/android/server/locksettings/LockSettingsShellCommand.java
+++ b/services/core/java/com/android/server/locksettings/LockSettingsShellCommand.java
@@ -311,7 +311,7 @@ class LockSettingsShellCommand extends ShellCommand {
             PasswordMetrics metrics = new PasswordMetrics(
                     credential.isPattern() ? CREDENTIAL_TYPE_PATTERN : CREDENTIAL_TYPE_NONE);
             errors = PasswordMetrics.validatePasswordMetrics(
-                    requiredMetrics, requiredComplexity, false /* isPin */, metrics);
+                    requiredMetrics, requiredComplexity, metrics);
         }
         if (!errors.isEmpty()) {
             getOutPrintWriter().println(
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
index 64cdfa65f9c56..d65a28d47e101 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
@@ -4507,8 +4507,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
 
             PasswordMetrics metrics = mLockSettingsInternal.getUserPasswordMetrics(parentUser);
             final List<PasswordValidationError> passwordValidationErrors =
-                    PasswordMetrics.validatePasswordMetrics(
-                            minMetrics, complexity, false, metrics);
+                    PasswordMetrics.validatePasswordMetrics(minMetrics, complexity, metrics);
             isSufficient = passwordValidationErrors.isEmpty();
         }
         DevicePolicyEventLogger
@@ -4585,7 +4584,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
                 maxRequiredComplexity = Math.max(maxRequiredComplexity, admin.mPasswordComplexity);
             }
             return PasswordMetrics.validatePasswordMetrics(PasswordMetrics.merge(adminMetrics),
-                    maxRequiredComplexity, false, metrics).isEmpty();
+                    maxRequiredComplexity, metrics).isEmpty();
         }
     }
 
@@ -4621,8 +4620,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
         final int complexity = getAggregatedPasswordComplexityLocked(userId);
         PasswordMetrics minMetrics = getPasswordMinimumMetricsUnchecked(userId);
         final List<PasswordValidationError> passwordValidationErrors =
-                PasswordMetrics.validatePasswordMetrics(
-                        minMetrics, complexity, false, metrics);
+                PasswordMetrics.validatePasswordMetrics(minMetrics, complexity, metrics);
         return passwordValidationErrors.isEmpty();
     }
 
@@ -4969,8 +4967,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
             // TODO: Consider changing validation API to take LockscreenCredential.
             if (password.isEmpty()) {
                 validationErrors = PasswordMetrics.validatePasswordMetrics(
-                        minMetrics, complexity, isPin,
-                        new PasswordMetrics(CREDENTIAL_TYPE_NONE));
+                        minMetrics, complexity, new PasswordMetrics(CREDENTIAL_TYPE_NONE));
             } else {
                 // TODO(b/120484642): remove getBytes() below
                 validationErrors = PasswordMetrics.validatePassword(