content: /*
   * Copyright (C) 2010 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.text;
  
  import android.annotation.UnsupportedAppUsage;
  import android.icu.lang.UCharacter;
  import android.icu.lang.UCharacterDirection;
  import android.icu.lang.UProperty;
  import android.icu.text.Bidi;
  import android.icu.text.BidiClassifier;
  import android.text.Layout.Directions;
  
  import com.android.internal.annotations.VisibleForTesting;
  
  /**
   * Access the ICU bidi implementation.
   * @hide
   */
  @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
  public class AndroidBidi {
  
      /**
       * Overrides ICU {@link BidiClassifier} in order to correctly handle character directions for
       * newest emoji that ICU is not aware of.
       */
      public static class EmojiBidiOverride extends BidiClassifier {
          public EmojiBidiOverride() {
              super(null /* No persisting object needed */);
          }
  
          // Tells ICU to use the standard Unicode value.
          private static final int NO_OVERRIDE =
                  UCharacter.getIntPropertyMaxValue(UProperty.BIDI_CLASS) + 1;
  
          @Override
          public int classify(int c) {
              if (Emoji.isNewEmoji(c)) {
                  // All new emoji characters in Unicode 10.0 are of the bidi class ON.
                  return UCharacterDirection.OTHER_NEUTRAL;
              } else {
                  return NO_OVERRIDE;
              }
          }
      }
  
      private static final EmojiBidiOverride sEmojiBidiOverride = new EmojiBidiOverride();
  
      /**
       * Runs the bidi algorithm on input text.
       */
      @UnsupportedAppUsage
      public static int bidi(int dir, char[] chs, byte[] chInfo) {
          if (chs == null || chInfo == null) {
              throw new NullPointerException();
          }
  
          final int length = chs.length;
          if (chInfo.length < length) {
              throw new IndexOutOfBoundsException();
          }
  
          final byte paraLevel;
          switch (dir) {
              case Layout.DIR_REQUEST_LTR: paraLevel = Bidi.LTR; break;
              case Layout.DIR_REQUEST_RTL: paraLevel = Bidi.RTL; break;
              case Layout.DIR_REQUEST_DEFAULT_LTR: paraLevel = Bidi.LEVEL_DEFAULT_LTR; break;
              case Layout.DIR_REQUEST_DEFAULT_RTL: paraLevel = Bidi.LEVEL_DEFAULT_RTL; break;
              default: paraLevel = Bidi.LTR; break;
          }
          final Bidi icuBidi = new Bidi(length /* maxLength */, 0 /* maxRunCount */);
          icuBidi.setCustomClassifier(sEmojiBidiOverride);
          icuBidi.setPara(chs, paraLevel, null /* embeddingLevels */);
          for (int i = 0; i < length; i++) {
              chInfo[i] = icuBidi.getLevelAt(i);
          }
          final byte result = icuBidi.getParaLevel();
          return (result & 0x1) == 0 ? Layout.DIR_LEFT_TO_RIGHT : Layout.DIR_RIGHT_TO_LEFT;
      }
  
      /**
       * Returns run direction information for a line within a paragraph.
       *
       * @param dir base line direction, either Layout.DIR_LEFT_TO_RIGHT or
       *     Layout.DIR_RIGHT_TO_LEFT
       * @param levels levels as returned from {@link #bidi}
       * @param lstart start of the line in the levels array
       * @param chars the character array (used to determine whitespace)
       * @param cstart the start of the line in the chars array
       * @param len the length of the line
       * @return the directions
       */
      public static Directions directions(int dir, byte[] levels, int lstart,
              char[] chars, int cstart, int len) {
          if (len == 0) {
              return Layout.DIRS_ALL_LEFT_TO_RIGHT;
          }
  
          int baseLevel = dir == Layout.DIR_LEFT_TO_RIGHT ? 0 : 1;
          int curLevel = levels[lstart];
          int minLevel = curLevel;
          int runCount = 1;
          for (int i = lstart + 1, e = lstart + len; i < e; ++i) {
              int level = levels[i];
              if (level != curLevel) {
                  curLevel = level;
                  ++runCount;
              }
          }
  
          // add final run for trailing counter-directional whitespace
          int visLen = len;
          if ((curLevel & 1) != (baseLevel & 1)) {
              // look for visible end
              while (--visLen >= 0) {
                  char ch = chars[cstart + visLen];
  
                  if (ch == '\n') {
                      --visLen;
                      break;
                  }
  
                  if (ch != ' ' && ch != '\t') {
                      break;
                  }
              }
              ++visLen;
              if (visLen != len) {
                  ++runCount;
              }
          }
  
          if (runCount == 1 && minLevel == baseLevel) {
              // we're done, only one run on this line
              if ((minLevel & 1) != 0) {
                  return Layout.DIRS_ALL_RIGHT_TO_LEFT;
              }
              return Layout.DIRS_ALL_LEFT_TO_RIGHT;
          }
  
          int[] ld = new int[runCount * 2];
          int maxLevel = minLevel;
          int levelBits = minLevel << Layout.RUN_LEVEL_SHIFT;
          {
              // Start of first pair is always 0, we write
              // length then start at each new run, and the
              // last run length after we're done.
              int n = 1;
              int prev = lstart;
              curLevel = minLevel;
              for (int i = lstart, e = lstart + visLen; i < e; ++i) {
                  int level = levels[i];
                  if (level != curLevel) {
                      curLevel = level;
                      if (level > maxLevel) {
                          maxLevel = level;
                      } else if (level < minLevel) {
                          minLevel = level;
                      }
                      // XXX ignore run length limit of 2^RUN_LEVEL_SHIFT
                      ld[n++] = (i - prev) | levelBits;
                      ld[n++] = i - lstart;
                      levelBits = curLevel << Layout.RUN_LEVEL_SHIFT;
                      prev = i;
                  }
              }
              ld[n] = (lstart + visLen - prev) | levelBits;
              if (visLen < len) {
                  ld[++n] = visLen;
                  ld[++n] = (len - visLen) | (baseLevel << Layout.RUN_LEVEL_SHIFT);
              }
          }
  
          // See if we need to swap any runs.
          // If the min level run direction doesn't match the base
          // direction, we always need to swap (at this point
          // we have more than one run).
          // Otherwise, we don't need to swap the lowest level.
          // Since there are no logically adjacent runs at the same
          // level, if the max level is the same as the (new) min
          // level, we have a series of alternating levels that
          // is already in order, so there's no more to do.
          //
          boolean swap;
          if ((minLevel & 1) == baseLevel) {
              minLevel += 1;
              swap = maxLevel > minLevel;
          } else {
              swap = runCount > 1;
          }
          if (swap) {
              for (int level = maxLevel - 1; level >= minLevel; --level) {
                  for (int i = 0; i < ld.length; i += 2) {
                      if (levels[ld[i]] >= level) {
                          int e = i + 2;
                          while (e < ld.length && levels[ld[e]] >= level) {
                              e += 2;
                          }
                          for (int low = i, hi = e - 2; low < hi; low += 2, hi -= 2) {
                              int x = ld[low]; ld[low] = ld[hi]; ld[hi] = x;
                              x = ld[low+1]; ld[low+1] = ld[hi+1]; ld[hi+1] = x;
                          }
                          i = e + 2;
                      }
                  }
              }
          }
          return new Directions(ld);
      }
  }