Esempio n. 1
0
  public boolean isValidWord(final CharSequence word) {
    if (word == null || word.length() == 0) {
      return false;
    }

    Log.v(
        TAG,
        "Suggest::isValidWord(%s) mMainDictionaryEnabled:%s mAutoTextEnabled: %s user-dictionary-enabled: %s contacts-dictionary-enabled: %s",
        word,
        mMainDictionaryEnabled,
        mAutoTextEnabled,
        mUserDictionary != null,
        mContactsDictionary != null);

    if (mMainDictionaryEnabled || mAutoTextEnabled) {
      final boolean validFromMain =
          (mMainDictionaryEnabled && mMainDict != null && mMainDict.isValidWord(word));
      final boolean validFromUser = (mUserDictionary != null && mUserDictionary.isValidWord(word));
      final boolean validFromContacts =
          (mContactsDictionary != null && mContactsDictionary.isValidWord(word));

      Log.v(
          TAG,
          "Suggest::isValidWord(%s)validFromMain: %s validFromUser: %s validFromContacts: %s",
          word,
          validFromMain,
          validFromUser,
          validFromContacts);
      return validFromMain || validFromUser || /* validFromAuto || */ validFromContacts;
    } else {
      return false;
    }
  }
Esempio n. 2
0
 public Row(Context askContext, Resources res, Keyboard parent, XmlResourceParser parser) {
   this.parent = parent;
   // some defaults
   defaultWidth = parent.mDefaultWidth;
   defaultHeightCode = parent.mDefaultHeightCode;
   defaultHorizontalGap = parent.mDefaultHorizontalGap;
   verticalGap = parent.getVerticalGap();
   // now reading from the XML
   SparseIntArray attributeIdMap = parent.attributeIdMap;
   int[] remoteKeyboardLayoutStyleable = parent.remoteKeyboardLayoutStyleable;
   TypedArray a =
       res.obtainAttributes(Xml.asAttributeSet(parser), remoteKeyboardLayoutStyleable);
   int n = a.getIndexCount();
   for (int i = 0; i < n; i++) {
     final int remoteIndex = a.getIndex(i);
     final int localAttrId = attributeIdMap.get(remoteKeyboardLayoutStyleable[remoteIndex]);
     try {
       switch (localAttrId) {
         case android.R.attr.keyWidth:
           defaultWidth =
               getDimensionOrFraction(
                   a, remoteIndex, parent.mDisplayWidth, parent.mDefaultWidth);
           break;
         case android.R.attr.keyHeight:
           defaultHeightCode = getKeyHeightCode(a, remoteIndex, parent.mDefaultHeightCode);
           break;
         case android.R.attr.horizontalGap:
           defaultHorizontalGap =
               getDimensionOrFraction(
                   a, remoteIndex, parent.mDisplayWidth, parent.mDefaultHorizontalGap);
           break;
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to set data from XML!", e);
     }
   }
   a.recycle();
   int[] remoteKeyboardRowLayoutStyleable = parent.remoteKeyboardRowLayoutStyleable;
   a = res.obtainAttributes(Xml.asAttributeSet(parser), remoteKeyboardRowLayoutStyleable);
   n = a.getIndexCount();
   for (int i = 0; i < n; i++) {
     final int remoteIndex = a.getIndex(i);
     final int localAttrId = attributeIdMap.get(remoteKeyboardRowLayoutStyleable[remoteIndex]);
     try {
       switch (localAttrId) {
         case android.R.attr.rowEdgeFlags:
           rowEdgeFlags = a.getInt(remoteIndex, 0);
           break;
         case android.R.attr.keyboardMode:
           mode = a.getResourceId(remoteIndex, 0);
           break;
       }
     } catch (Exception e) {
       Log.w(TAG, "Failed to set data from XML!", e);
     }
   }
   a.recycle();
 }
  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    synchronized (mDbName) {
      // Please note: don't use class level constants here, since they may
      // change.
      // if you upgrade from one version to another, make sure you use the
      // correct names!
      Log.d(
          TAG,
          "Upgrading WordsSQLiteConnection from version "
              + oldVersion
              + " to "
              + newVersion
              + "...");
      if (oldVersion < 4) {
        Log.d(TAG, "Upgrading WordsSQLiteConnection to version 4: Adding locale column...");
        db.execSQL("ALTER TABLE FALL_BACK_USER_DICTIONARY ADD COLUMN locale TEXT;");
      }
      if (oldVersion < 5) {
        Log.d(
            TAG,
            "Upgrading WordsSQLiteConnection to version 5: Adding _id column and populating...");
        db.execSQL("ALTER TABLE FALL_BACK_USER_DICTIONARY ADD COLUMN _id INTEGER;");
        db.execSQL("UPDATE FALL_BACK_USER_DICTIONARY SET _id=Id;");
      }
      if (oldVersion < 6) {
        Log.d(
            TAG,
            "Upgrading WordsSQLiteConnection to version 6: Matching schema with Android's User-Dictionary table...");
        db.execSQL(
            "ALTER TABLE FALL_BACK_USER_DICTIONARY RENAME TO tmp_FALL_BACK_USER_DICTIONARY;");

        db.execSQL(
            "CREATE TABLE FALL_BACK_USER_DICTIONARY ("
                + "_id INTEGER PRIMARY KEY,word TEXT,"
                + "frequency INTEGER,locale TEXT);");

        db.execSQL(
            "INSERT INTO FALL_BACK_USER_DICTIONARY(_id, word, frequency, locale) SELECT _id, Word, Freq, locale FROM tmp_FALL_BACK_USER_DICTIONARY;");

        db.execSQL("DROP TABLE tmp_FALL_BACK_USER_DICTIONARY;");
      }
      if (oldVersion < 7) {
        Log.d(TAG, "Renaming the table's name to a generic one...");
        db.execSQL("ALTER TABLE FALL_BACK_USER_DICTIONARY RENAME TO WORDS;");
      }
    }
  }
  public void addWord(String word, int freq) {
    synchronized (mDbName) {
      SQLiteDatabase db = getWritableDatabase();

      ContentValues values = new ContentValues();
      values.put(Words._ID, word.hashCode()); // ensuring that any word is inserted once
      values.put(Words.WORD, word);
      values.put(Words.FREQUENCY, freq);
      values.put(Words.LOCALE, mCurrentLocale);
      long res = db.insert(TABLE_NAME, null, values);
      if (res < 0) {
        Log.e(
            TAG,
            "Unable to insert '"
                + word
                + "' to SQLite storage ("
                + mCurrentLocale
                + "@"
                + mDbName
                + ")! Result:"
                + res);
      }
      db.close();
    }
  }
  protected void sendCrashReportViaEmail() {
    Intent callingIntent = getIntent();

    Intent sendMail = new Intent();
    sendMail.setAction(Intent.ACTION_SEND);
    sendMail.setType("plain/text");
    sendMail.putExtra(Intent.EXTRA_EMAIL, new String[] {"*****@*****.**"});
    sendMail.putExtra(Intent.EXTRA_SUBJECT, getText(R.string.ime_name) + " crashed!");
    sendMail.putExtra(Intent.EXTRA_TEXT, callingIntent.getStringExtra(CRASH_REPORT_TEXT));

    try {
      Intent sender = Intent.createChooser(sendMail, "Send bug report");
      sender.putExtra(Intent.EXTRA_EMAIL, new String[] {"*****@*****.**"});
      sender.putExtra(Intent.EXTRA_SUBJECT, getText(R.string.ime_name) + " crashed!");
      sender.putExtra(Intent.EXTRA_TEXT, callingIntent.getStringExtra(CRASH_REPORT_TEXT));

      Log.i(TAG, "Will send crash report using " + sender);
      startActivity(sender);
    } catch (android.content.ActivityNotFoundException ex) {
      Toast.makeText(
              getApplicationContext(), "Unable to send bug report via e-mail!", Toast.LENGTH_LONG)
          .show();
    }

    finish();
  }
 public static int[] parseCSV(String value) {
   int count = 0;
   int lastIndex = 0;
   if (value.length() > 0) {
     count++;
     while ((lastIndex = value.indexOf(",", lastIndex + 1)) > 0) {
       count++;
     }
   }
   int[] values = new int[count];
   count = 0;
   StringTokenizer st = new StringTokenizer(value, ",");
   while (st.hasMoreTokens()) {
     String nextToken = st.nextToken();
     try {
       // Issue 395
       // default behavior
       if (nextToken.length() != 1) {
         values[count++] = Integer.parseInt(nextToken);
       } else {
         // length == 1, assume a char!
         values[count++] = (int) nextToken.charAt(0);
       }
     } catch (NumberFormatException nfe) {
       Log.e(TAG, "Error parsing keycodes " + value);
     }
   }
   return values;
 }
 @Override
 public boolean setValueFromTheme(
     TypedArray remoteTypedArray, int[] padding, int localAttrId, int remoteTypedArrayIndex) {
   switch (localAttrId) {
     case R.attr.previewGestureTextSize:
       mGesturePreviewTextSize = remoteTypedArray.getDimensionPixelSize(remoteTypedArrayIndex, 0);
       Log.d(TAG, "AnySoftKeyboardTheme_previewGestureTextSize " + mGesturePreviewTextSize);
       break;
     case R.attr.previewGestureTextColor:
       mGesturePreviewTextColor = remoteTypedArray.getColor(remoteTypedArrayIndex, 0xFFF);
       Log.d(TAG, "AnySoftKeyboardTheme_previewGestureTextColor " + mGesturePreviewTextColor);
     default:
       return super.setValueFromTheme(
           remoteTypedArray, padding, localAttrId, remoteTypedArrayIndex);
   }
   return true;
 }
  @Override
  protected boolean onLongPress(
      AddOn keyboardAddOn, Key key, boolean isSticky, boolean requireSlideInto) {
    if (mAnimationLevel == AnimationsLevel.None) {
      mMiniKeyboardPopup.setAnimationStyle(0);
    } else if (mExtensionVisible
        && mMiniKeyboardPopup.getAnimationStyle() != R.style.ExtensionKeyboardAnimation) {
      Log.d(TAG, "Switching mini-keyboard animation to ExtensionKeyboardAnimation");
      mMiniKeyboardPopup.setAnimationStyle(R.style.ExtensionKeyboardAnimation);
    } else if (!mExtensionVisible
        && mMiniKeyboardPopup.getAnimationStyle() != R.style.MiniKeyboardAnimation) {
      Log.d(TAG, "Switching mini-keyboard animation to MiniKeyboardAnimation");
      mMiniKeyboardPopup.setAnimationStyle(R.style.MiniKeyboardAnimation);
    }

    return super.onLongPress(keyboardAddOn, key, isSticky, requireSlideInto);
  }
Esempio n. 9
0
  @Override
  public boolean addWord(
      final char[] word,
      final int offset,
      final int length,
      final int freq,
      final Dictionary from) {
    if (from == mAbbreviationDictionary) {
      mExplodedAbbreviations.add(new String(word, offset, length));
      return true;
    }
    int pos = 0;
    final int[] priorities = mPriorities;
    final int prefMaxSuggestions = mPrefMaxSuggestions;
    // Check if it's the same word, only caps are different
    if (compareCaseInsensitive(mLowerOriginalWord, word, offset, length)) {
      Log.v(TAG, "Suggest::addWord - forced at position 0.");
      pos = 0;
    } else {
      // Check the last one's priority and bail
      if (priorities[prefMaxSuggestions - 1] >= freq) return true;
      while (pos < prefMaxSuggestions) {
        if (priorities[pos] < freq
            || (priorities[pos] == freq && length < mSuggestions.get(pos).length())) {
          break;
        }
        pos++;
      }
    }

    if (pos >= prefMaxSuggestions) {
      return true;
    }
    System.arraycopy(priorities, pos, priorities, pos + 1, prefMaxSuggestions - pos - 1);
    priorities[pos] = freq;
    int poolSize = mStringPool.size();
    StringBuilder sb =
        poolSize > 0 ? (StringBuilder) mStringPool.remove(poolSize - 1) : new StringBuilder(32);
    sb.setLength(0);
    if (mIsAllUpperCase) {
      sb.append(new String(word, offset, length).toUpperCase(mLocale));
    } else if (mIsFirstCharCapitalized) {
      sb.append(Character.toUpperCase(word[offset]));
      if (length > 1) {
        sb.append(word, offset + 1, length - 1);
      }
    } else {
      sb.append(word, offset, length);
    }
    mSuggestions.add(pos, sb);
    if (mSuggestions.size() > prefMaxSuggestions) {
      CharSequence garbage = mSuggestions.remove(prefMaxSuggestions);
      if (garbage instanceof StringBuilder) {
        mStringPool.add(garbage);
      }
    }
    return true;
  }
 public Drawable getIcon() {
   try {
     if (mIconResId != INVALID_RES_ID) {
       return getPackageContext().getResources().getDrawable(mIconResId);
     } else {
       return null;
     }
   } catch (Resources.NotFoundException n) {
     Log.w(TAG, "Failed to load pack ICON! ResId: " + mIconResId);
     return null;
   }
 }
 public void onClick(View view) {
   try {
     String tag = getKey();
     Intent search = new Intent(Intent.ACTION_VIEW);
     search.setData(Uri.parse("market://search?q=AnySoftKeyboard " + tag));
     search.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
     getContext().startActivity(search);
   } catch (Exception ex) {
     Log.e(TAG, "Could not launch Store search!", ex);
     mStoreNotFoundView.setVisibility(View.VISIBLE);
   }
 }
Esempio n. 12
0
 @Override
 public void onDraw(Canvas canvas) {
   final boolean keyboardChanged = mKeyboardChanged;
   super.onDraw(canvas);
   // switching animation
   if (mAnimationLevel != AnimationsLevel.None && keyboardChanged && (mInAnimation != null)) {
     startAnimation(mInAnimation);
     mInAnimation = null;
   }
   // text pop out animation
   if (mPopOutText != null && mAnimationLevel != AnimationsLevel.None) {
     final int maxVerticalTravel = getHeight() / 2;
     final long animationDuration = 1200;
     final long currentAnimationTime = SystemClock.elapsedRealtime() - mPopOutTime;
     if (currentAnimationTime > animationDuration) {
       mPopOutText = null;
     } else {
       final float animationProgress =
           ((float) currentAnimationTime) / ((float) animationDuration);
       final float animationFactoredProgress = getPopOutAnimationInterpolator(animationProgress);
       final int y = mPopOutStartPoint.y - (int) (maxVerticalTravel * animationFactoredProgress);
       final int x = mPopOutStartPoint.x;
       final int alpha = 255 - (int) (255 * animationProgress);
       if (FeaturesSet.DEBUG_LOG)
         Log.d(
             TAG,
             "Drawing text popout '"
                 + mPopOutText
                 + "' at "
                 + x
                 + ","
                 + y
                 + " with alpha "
                 + alpha
                 + ". Animation progress is "
                 + animationProgress
                 + ", and factor progress is "
                 + animationFactoredProgress);
       // drawing
       setPaintToKeyText(mPaint);
       // will disappear over time
       mPaint.setAlpha(alpha);
       mPaint.setShadowLayer(5, 0, 0, Color.BLACK);
       // will grow over time
       mPaint.setTextSize(mPaint.getTextSize() * (1.0f + animationFactoredProgress));
       canvas.translate(x, y);
       canvas.drawText(mPopOutText, 0, mPopOutText.length(), 0, 0, mPaint);
       canvas.translate(-x, -y);
       // next frame
       postInvalidateDelayed(1000 / 50); // doing 50 frames per second;
     }
   }
 }
  @NonNull
  public static int[] getKeyCodesFromTypedArray(TypedArray typedArray, int index) {
    TypedValue codesValue = new TypedValue();
    typedArray.getValue(index, codesValue);

    if (codesValue.type == TypedValue.TYPE_INT_DEC || codesValue.type == TypedValue.TYPE_INT_HEX) {
      return new int[] {codesValue.data};
    } else if (codesValue.type == TypedValue.TYPE_STRING) {
      return parseCSV(codesValue.string.toString());
    } else {
      Log.w(TAG, "Unknown codes values!");
      return new int[0];
    }
  }
Esempio n. 14
0
 @Nullable
 public Drawable getScreenshot() {
   try {
     if (mThemeScreenshotResId != INVALID_RES_ID) {
       Context packageContext = getPackageContext();
       if (packageContext == null) return null;
       return packageContext.getResources().getDrawable(mThemeScreenshotResId);
     } else {
       return null;
     }
   } catch (Resources.NotFoundException n) {
     Log.w(TAG, "Failed to load pack Screenshot! ResId:" + mThemeScreenshotResId);
     return null;
   }
 }
Esempio n. 15
0
 protected static int getKeyHeightCode(TypedArray a, int remoteIndex, int defaultHeightCode) {
   TypedValue value = a.peekValue(remoteIndex);
   if (value == null) {
     // means that it was not provided. So I take my parent's
     return defaultHeightCode;
   } else if (value.type >= TypedValue.TYPE_FIRST_INT
       && value.type <= TypedValue.TYPE_LAST_INT
       && value.data <= 0
       && value.data >= -3) {
     return value.data;
   } else {
     Log.w(TAG, "Key height attribute is incorrectly set! Defaulting to regular height.");
     return -1;
   }
 }
Esempio n. 16
0
 /** Sets an optional contacts dictionary resource to be loaded. */
 public void setContactsDictionary(Context context, boolean enabled) {
   if (!enabled && mContactsDictionary != null) {
     // had one, but now config says it should be off
     Log.i(TAG, "Contacts dictionary has been disabled! Closing resources.");
     mContactsDictionary.close();
     mContactsDictionary = null;
   } else if (enabled && mContactsDictionary == null) {
     // config says it should be on, but I have none.
     mContactsDictionary = mDictionaryFactory.createContactsDictionary(context);
     if (mContactsDictionary != null) { // not all devices has contacts-dictionary
       DictionaryASyncLoader loader = new DictionaryASyncLoader(null);
       loader.execute(mContactsDictionary);
     }
   }
 }
Esempio n. 17
0
 private void collectGarbage() {
   int poolSize = mStringPool.size();
   int garbageSize = mSuggestions.size();
   while (poolSize < mPrefMaxSuggestions && garbageSize > 0) {
     CharSequence garbage = mSuggestions.get(garbageSize - 1);
     if (garbage != null && garbage instanceof StringBuilder) {
       mStringPool.add(garbage);
       poolSize++;
     }
     garbageSize--;
   }
   if (poolSize == mPrefMaxSuggestions + 1) {
     Log.w(TAG, "String pool got too big: " + poolSize);
   }
   mSuggestions.clear();
 }
Esempio n. 18
0
  public void popTextOutOfKey(CharSequence text) {
    if (TextUtils.isEmpty(text)) {
      Log.w(TAG, "Call for popTextOutOfKey with missing text argument!");
      return;
    }
    if (!AnyApplication.getConfig().workaround_alwaysUseDrawText())
      return; // not doing it with StaticLayout

    // performing "toString" so we'll have a separate copy of the CharSequence,
    // and not the original object which I fear is a reference copy (hence may be changed).
    mPopOutText = text.toString();
    mPopOutTime = SystemClock.elapsedRealtime();
    mPopOutStartPoint.x = mFirstTouchPoint.x;
    mPopOutStartPoint.y = mFirstTouchPoint.y;
    // it is ok to wait for the next loop.
    postInvalidate();
  }
Esempio n. 19
0
  public void setMainDictionary(
      Context askContext, @Nullable DictionaryAddOnAndBuilder dictionaryBuilder) {
    Log.d(
        TAG,
        "Suggest: Got main dictionary! Type: "
            + ((dictionaryBuilder == null) ? "NULL" : dictionaryBuilder.getName()));
    if (mMainDict != null) {
      mMainDict.close();
      mMainDict = null;
    }
    mLocale =
        CompatUtils.getLocaleForLanguageTag(
            dictionaryBuilder == null ? null : dictionaryBuilder.getLanguage());

    if (mAbbreviationDictionary != null) {
      mAbbreviationDictionary.close();
      mAbbreviationDictionary = null;
    }

    if (dictionaryBuilder == null) {
      mMainDict = null;
      mAutoText = null;
      mAbbreviationDictionary = null;
      mLocaleSpecificPunctuations = null;
    } else {
      try {
        System.gc();

        mMainDict = dictionaryBuilder.createDictionary();
        DictionaryASyncLoader loader = new DictionaryASyncLoader(null);
        loader.execute(mMainDict);
      } catch (Exception e) {
        e.printStackTrace();
      }
      mAutoText = dictionaryBuilder.createAutoText();
      mLocaleSpecificPunctuations = dictionaryBuilder.createInitialSuggestions();

      mAbbreviationDictionary =
          new AbbreviationsDictionary(askContext, dictionaryBuilder.getLanguage());
      DictionaryASyncLoader loader = new DictionaryASyncLoader(null);
      loader.execute(mAbbreviationDictionary);
    }
  }
Esempio n. 20
0
  public static void newSession(Context context) {
    sSessionCount++;
    sAutoSuggestCount = 0;
    sBackspaceCount = 0;
    sAutoSuggestUndoneCount = 0;
    sManualSuggestCount = 0;
    sWordNotInDictionaryCount = 0;
    sTypedChars = 0;
    sActualChars = 0;
    sState = State.START;

    if (LOGGING) {
      try {
        sKeyLocationFile = context.openFileOutput("key.txt", Context.MODE_APPEND);
        sUserActionFile = context.openFileOutput("action.txt", Context.MODE_APPEND);
      } catch (IOException ioe) {
        Log.e("TextEntryState", "Couldn't open file for output: " + ioe);
      }
    }
  }
Esempio n. 21
0
  private void parseKeyboardAttributes(
      Context askContext, Resources res, XmlResourceParser parser) {
    TypedArray a = res.obtainAttributes(Xml.asAttributeSet(parser), remoteKeyboardLayoutStyleable);
    Resources askRes = askContext.getResources();
    // some defaults
    mDefaultWidth = mDisplayWidth / 10;
    mDefaultHeightCode = -1;
    mDefaultHorizontalGap = 0;
    mDefaultVerticalGap = askRes.getDimensionPixelOffset(R.dimen.default_key_vertical_gap);
    // now reading from XML
    int n = a.getIndexCount();
    for (int i = 0; i < n; i++) {
      final int remoteIndex = a.getIndex(i);
      final int localAttrId = attributeIdMap.get(remoteKeyboardLayoutStyleable[remoteIndex]);
      try {
        switch (localAttrId) {
          case android.R.attr.keyWidth:
            mDefaultWidth =
                getDimensionOrFraction(a, remoteIndex, mDisplayWidth, mDisplayWidth / 10);
            break;
          case android.R.attr.keyHeight:
            mDefaultHeightCode = getKeyHeightCode(a, remoteIndex, -1);
            break;
          case android.R.attr.horizontalGap:
            mDefaultHorizontalGap = getDimensionOrFraction(a, remoteIndex, mDisplayWidth, 0);
            break;
          case android.R.attr.verticalGap:
            mDefaultVerticalGap =
                getDimensionOrFraction(a, remoteIndex, mDisplayWidth, mDefaultVerticalGap);
            break;
        }
      } catch (Exception e) {
        Log.w(TAG, "Failed to set data from XML!", e);
      }
    }
    a.recycle();

    mProximityThreshold = (int) (mDefaultWidth * SEARCH_DISTANCE);
    // Square it for comparison
    mProximityThreshold = mProximityThreshold * mProximityThreshold;
  }
Esempio n. 22
0
 private void setDataFromTypedArray(
     Row parent,
     KeyboardDimens keyboardDimens,
     Resources askResources,
     TypedArray a,
     int remoteIndex,
     int localAttrId) {
   try {
     switch (localAttrId) {
       case android.R.attr.keyWidth:
         width =
             getDimensionOrFraction(a, remoteIndex, keyboard.mDisplayWidth, parent.defaultWidth);
         width = Math.min(keyboardDimens.getKeyMaxWidth(), width);
         break;
       case android.R.attr.keyHeight:
         int heightCode = getKeyHeightCode(a, remoteIndex, parent.defaultHeightCode);
         height =
             KeyboardSupport.getKeyHeightFromHeightCode(
                 keyboardDimens, heightCode, askResources.getConfiguration().orientation);
         break;
       case android.R.attr.horizontalGap:
         gap =
             getDimensionOrFraction(
                 a, remoteIndex, keyboard.mDisplayWidth, parent.defaultHorizontalGap);
         break;
       case android.R.attr.codes:
         codes = KeyboardSupport.getKeyCodesFromTypedArray(a, remoteIndex);
         break;
       case android.R.attr.iconPreview:
         iconPreview = a.getDrawable(remoteIndex);
         KeyboardSupport.updateDrawableBounds(iconPreview);
         break;
       case android.R.attr.popupCharacters:
         popupCharacters = a.getText(remoteIndex);
         break;
       case android.R.attr.popupKeyboard:
         popupResId = a.getResourceId(remoteIndex, 0);
         break;
       case android.R.attr.isRepeatable:
         repeatable = a.getBoolean(remoteIndex, false);
         break;
       case R.attr.showPreview:
         showPreview = a.getBoolean(remoteIndex, true);
         break;
       case R.attr.keyDynamicEmblem:
         dynamicEmblem = a.getInt(remoteIndex, KEY_EMBLEM_NONE);
         break;
       case android.R.attr.isModifier:
         modifier = a.getBoolean(remoteIndex, false);
         break;
       case android.R.attr.isSticky:
         sticky = a.getBoolean(remoteIndex, false);
         break;
       case android.R.attr.keyEdgeFlags:
         edgeFlags = a.getInt(remoteIndex, 0);
         edgeFlags |= parent.rowEdgeFlags;
         break;
       case android.R.attr.keyIcon:
         icon = a.getDrawable(remoteIndex);
         KeyboardSupport.updateDrawableBounds(icon);
         break;
       case android.R.attr.keyLabel:
         label = a.getText(remoteIndex);
         break;
       case android.R.attr.keyOutputText:
         text = a.getText(remoteIndex);
         break;
     }
   } catch (Exception e) {
     Log.w(TAG, "Failed to load keyboard layout! ", e);
   }
 }
Esempio n. 23
0
  public void loadKeyboard(final KeyboardDimens keyboardDimens) {
    mDisplayWidth = keyboardDimens.getKeyboardMaxWidth();
    final float rowVerticalGap = keyboardDimens.getRowVerticalGap();
    final float keyHorizontalGap = keyboardDimens.getKeyHorizontalGap();

    mDefaultHorizontalGap = 0;
    mDefaultWidth = mDisplayWidth / 10;
    mDefaultHeightCode = -1;

    XmlResourceParser parser = mKeyboardContext.getResources().getXml(mLayoutResId);
    boolean inKey = false;
    boolean inRow = false;
    boolean inUnknown = false;
    int row = 0;
    float x = 0;
    float y = rowVerticalGap; // starts with a gap
    int rowHeight = 0;
    Key key = null;
    Row currentRow = null;
    Resources res = mKeyboardContext.getResources();
    boolean skipRow = false;
    int lastVerticalGap = 0;

    try {
      int event;
      while ((event = parser.next()) != XmlResourceParser.END_DOCUMENT) {
        if (event == XmlResourceParser.START_TAG) {
          String tag = parser.getName();
          if (TAG_ROW.equals(tag)) {
            inRow = true;
            x = 0;
            rowHeight = 0;
            currentRow = createRowFromXml(mASKContext, res, parser);
            skipRow = currentRow.mode != 0 && currentRow.mode != mKeyboardMode;
            if (skipRow) {
              skipToEndOfRow(parser);
              inRow = false;
            }
          } else if (TAG_KEY.equals(tag)) {
            inKey = true;
            x += (keyHorizontalGap / 2);
            key =
                createKeyFromXml(
                    mASKContext, res, currentRow, keyboardDimens, (int) x, (int) y, parser);
            rowHeight = Math.max(rowHeight, key.height);
            key.width -= keyHorizontalGap; // the gap is on both
            // sides
            mKeys.add(key);
            if (key.codes[0] == KeyCodes.SHIFT) {
              mShiftKey = key;
              mShiftKeyIndex = mKeys.size() - 1;
              mModifierKeys.add(key);
            } else if (key.codes[0] == KeyCodes.ALT) {
              mModifierKeys.add(key);
            }
          } else if (TAG_KEYBOARD.equals(tag)) {
            parseKeyboardAttributes(mASKContext, res, parser);
          } else {
            inUnknown = true;
            onUnknownTagStart(mKeyboardContext, res, tag, parser);
          }
        } else if (event == XmlResourceParser.END_TAG) {
          if (inKey) {
            inKey = false;
            x += key.gap + key.width;
            x += (keyHorizontalGap / 2);
            if (x > mTotalWidth) {
              mTotalWidth = (int) x;
            }
          } else if (inRow) {
            inRow = false;
            lastVerticalGap = currentRow.verticalGap;
            y += currentRow.verticalGap;
            y += rowHeight;
            y += rowVerticalGap;
            row++;
          } else if (inUnknown) {
            inUnknown = false;
            onUnknownTagEnd();
          }
        }
      }
    } catch (Exception e) {
      Log.e(TAG, "Parse error:" + e);
      e.printStackTrace();
    }
    mTotalHeight = (int) (y - lastVerticalGap);
  }
Esempio n. 24
0
 private static void displayState() {
   if (DBG) {
     Log.d(TAG, "State = " + sState);
   }
 }
Esempio n. 25
0
 public static State getState() {
   if (DBG) {
     Log.d(TAG, "Returning state = " + sState);
   }
   return sState;
 }