Пример #1
0
 public boolean fireAppEvent(KrollInvocation invocation, String eventName, KrollDict data) {
   boolean handled = false;
   for (KrollProxy appEventProxy : appEventProxies) {
     boolean proxyHandled = appEventProxy.fireEvent(eventName, data);
     handled = handled || proxyHandled;
   }
   return handled;
 }
Пример #2
0
 @Override
 public void eventListenerRemoved(String eventName, int count, KrollProxy proxy) {
   super.eventListenerRemoved(eventName, count, proxy);
   if (eventName.equals(TiC.EVENT_CLICK)
       && count == 0
       && proxy.equals(this)
       && !(proxy instanceof TiWindowProxy)) {
     if (proxy.hasProperty(TiC.PROPERTY_TOUCH_ENABLED)
         && !TiConvert.toBoolean(proxy.getProperty(TiC.PROPERTY_TOUCH_ENABLED))) {
       setClickable(false);
     }
   }
 }
  public void setBackgroundFromProxy(KrollProxy proxy) {
    Drawable background = null;
    Object bkgdImage = proxy.getProperty(TiC.PROPERTY_BACKGROUND_IMAGE);
    Object bkgdColor = proxy.getProperty(TiC.PROPERTY_BACKGROUND_COLOR);
    if (bkgdImage != null) {
      background = getBackgroundImageDrawable(proxy, bkgdImage.toString());
    } else if (bkgdColor != null) {
      Integer bgColor = TiConvert.toColor(bkgdColor.toString());
      background = new ColorDrawable(bgColor);
    }

    setBackgroundDrawable(proxy.getProperties(), background);
  }
Пример #4
0
  protected void initialize() throws IOException {
    try {
      mp = new MediaPlayer();
      String url = TiConvert.toString(proxy.getProperty(TiC.PROPERTY_URL));
      if (URLUtil.isAssetUrl(url)) {
        Context context = proxy.getTiContext().getTiApp();
        String path = url.substring(TiConvert.ASSET_URL.length());
        AssetFileDescriptor afd = null;
        try {
          afd = context.getAssets().openFd(path);
          // Why mp.setDataSource(afd) doesn't work is a problem for another day.
          // http://groups.google.com/group/android-developers/browse_thread/thread/225c4c150be92416
          mp.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength());
        } catch (IOException e) {
          Log.e(LCAT, "Error setting file descriptor: ", e);
        } finally {
          if (afd != null) {
            afd.close();
          }
        }
      } else {
        Uri uri = Uri.parse(url);
        if (uri.getScheme().equals(TiC.PROPERTY_FILE)) {
          mp.setDataSource(uri.getPath());
        } else {
          remote = true;
          mp.setDataSource(url);
        }
      }

      mp.setLooping(looping);
      mp.setOnCompletionListener(this);
      mp.setOnErrorListener(this);
      mp.setOnInfoListener(this);
      mp.setOnBufferingUpdateListener(this);

      mp.prepare(); // Probably need to allow for Async
      setState(STATE_INITIALIZED);

      setVolume(volume);
      if (proxy.hasProperty(TiC.PROPERTY_TIME)) {
        setTime(TiConvert.toInt(proxy.getProperty(TiC.PROPERTY_TIME)));
      }
    } catch (Throwable t) {
      Log.w(LCAT, "Issue while initializing : ", t);
      release();
      setState(STATE_STOPPED);
    }
  }
Пример #5
0
  @Override
  public void handleCreationDict(KrollDict options) {
    options = handleStyleOptions(options);
    if (langConversionTable != null) {
      KrollDict foundStrings = new KrollDict();
      for (String key : langConversionTable.keySet()) {
        // if we have it already, ignore
        if (!options.containsKey(key)) {
          String convertKey = (String) langConversionTable.get(key);
          String langKey = (String) options.get(convertKey);
          if (langKey != null) {
            try {
              String localText = getLocalizedText(langKey);
              foundStrings.put(key, localText);
            } catch (TiRHelper.ResourceNotFoundException e) {
              Log.w(LCAT, "Localized text key '" + langKey + "' is invalid.");
            }
          }
        }
      }

      if (!(foundStrings.isEmpty())) {
        extend(foundStrings);
        options.putAll(foundStrings);
      }
    }
    options = handleStyleOptions(options);
    super.handleCreationDict(options);

    // TODO eventManager.addOnEventChangeListener(this);
  }
Пример #6
0
  @Override
  public boolean onInfo(MediaPlayer mp, int what, int extra) {
    String msg = "Unknown media issue.";

    switch (what) {
      case MediaPlayer.MEDIA_INFO_BAD_INTERLEAVING:
        msg = "Stream not interleaved or interleaved improperly.";
        break;
      case MediaPlayer.MEDIA_INFO_NOT_SEEKABLE:
        msg = "Stream does not support seeking";
        break;
      case MediaPlayer.MEDIA_INFO_UNKNOWN:
        msg = "Unknown media issue";
        break;
      case MediaPlayer.MEDIA_INFO_VIDEO_TRACK_LAGGING:
        msg = "Video is too complex for decoder, video lagging."; // shouldn't occur, but covering
        // bases.
        break;
    }

    KrollDict data = new KrollDict();
    data.put("code", 0);
    data.put("message", msg);
    proxy.fireEvent(EVENT_ERROR, data);

    return true;
  }
Пример #7
0
  @Override
  public void handleCreationDict(KrollDict options) {
    options = handleStyleOptions(options);
    super.handleCreationDict(options);

    // TODO eventManager.addOnEventChangeListener(this);
  }
Пример #8
0
 @Override
 public void setActivity(Activity activity) {
   super.setActivity(activity);
   if (children != null) {
     for (TiViewProxy child : children) {
       child.setActivity(activity);
     }
   }
 }
Пример #9
0
  private void setState(int state) {
    proxy.setProperty("state", state);
    String stateDescription = "";

    switch (state) {
      case STATE_BUFFERING:
        stateDescription = STATE_BUFFERING_DESC;
        break;
      case STATE_INITIALIZED:
        stateDescription = STATE_INITIALIZED_DESC;
        break;
      case STATE_PAUSED:
        stateDescription = STATE_PAUSED_DESC;
        break;
      case STATE_PLAYING:
        stateDescription = STATE_PLAYING_DESC;
        break;
      case STATE_STARTING:
        stateDescription = STATE_STARTING_DESC;
        break;
      case STATE_STOPPED:
        stateDescription = STATE_STOPPED_DESC;
        break;
      case STATE_STOPPING:
        stateDescription = STATE_STOPPING_DESC;
        break;
      case STATE_WAITING_FOR_DATA:
        stateDescription = STATE_WAITING_FOR_DATA_DESC;
        break;
      case STATE_WAITING_FOR_QUEUE:
        stateDescription = STATE_WAITING_FOR_QUEUE_DESC;
        break;
    }

    proxy.setProperty("stateDescription", stateDescription);
    if (DBG) {
      Log.d(LCAT, "Audio state changed: " + stateDescription);
    }

    KrollDict data = new KrollDict();
    data.put("state", state);
    data.put("description", stateDescription);
    proxy.fireEvent(EVENT_CHANGE, data);
  }
 @Override
 public void propertyChanged(String key, Object oldValue, Object newValue, KrollProxy proxy) {
   if (key.equals(TiC.PROPERTY_FONT)) {
     Spinner spinner = (Spinner) nativeView;
     TiSpinnerAdapter<TiViewProxy> adapter = (TiSpinnerAdapter<TiViewProxy>) spinner.getAdapter();
     adapter.setFontProperties(proxy.getProperties());
     adapter.notifyDataSetChanged();
   } else {
     super.propertyChanged(key, oldValue, newValue, proxy);
   }
 }
 @Override
 public void onPropertyChanged(String name, Object value) {
   if (Build.VERSION.SDK_INT >= TiC.API_LEVEL_ICE_CREAM_SANDWICH
       && TiC.PROPERTY_ON_HOME_ICON_ITEM_SELECTED.equals(name)) {
     // If we have a listener on the home icon item, then enable the home button (we need to do
     // this for ICS and
     // above)
     if (TiApplication.isUIThread()) {
       actionBar.setHomeButtonEnabled(true);
     } else {
       getMainHandler().obtainMessage(MSG_SET_HOME_BUTTON_ENABLED).sendToTarget();
     }
   }
   super.onPropertyChanged(name, value);
 }
Пример #12
0
  @Override
  public boolean onError(MediaPlayer mp, int what, int extra) {
    int code = 0;
    String msg = "Unknown media error.";
    if (what == MediaPlayer.MEDIA_ERROR_SERVER_DIED) {
      msg = "Media server died";
    }
    release();

    KrollDict data = new KrollDict();
    data.put("code", code);
    data.put("message", msg);
    proxy.fireEvent(EVENT_ERROR, data);

    return true;
  }
Пример #13
0
  public void setTime(int position) {
    if (position < 0) {
      position = 0;
    }

    if (mp != null) {
      int duration = mp.getDuration();
      if (position > duration) {
        position = duration;
      }

      mp.seekTo(position);
    }

    proxy.setProperty("time", position);
  }
Пример #14
0
 public void setVolume(float volume) {
   try {
     if (volume < 0.0f) {
       this.volume = 0.0f;
       Log.w(LCAT, "Attempt to set volume less than 0.0. Volume set to 0.0");
     } else if (volume > 1.0) {
       this.volume = 1.0f;
       proxy.setProperty("volume", volume);
       Log.w(LCAT, "Attempt to set volume greater than 1.0. Volume set to 1.0");
     } else {
       this.volume = volume; // Store in 0.0 to 1.0, scale when setting hw
     }
     if (mp != null) {
       float scaledVolume = this.volume;
       mp.setVolume(scaledVolume, scaledVolume);
     }
   } catch (Throwable t) {
     Log.w(LCAT, "Issue while setting volume : ", t);
   }
 }
 public AbsListItemProxy generateCellProxy(KrollProxy proxy, final String rootType) {
   AbsListItemProxy result = (AbsListItemProxy) proxy.createTypeViewFromDict(properties, rootType);
   return result;
 }
 public Drawable getBackgroundImageDrawable(KrollProxy proxy, String path) {
   String url = proxy.resolveUrl(null, path);
   return TiFileHelper.loadDrawable(url);
 }
Пример #17
0
 public void onCompletion(MediaPlayer mp) {
   proxy.fireEvent(EVENT_COMPLETE, null);
   stop();
 }
Пример #18
0
  public void propertyChanged(String key, Object oldValue, Object newValue, KrollProxy proxy) {
    if (key.equals(TiC.PROPERTY_LEFT)) {
      if (newValue != null) {
        layoutParams.optionLeft =
            TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_LEFT);
      } else {
        layoutParams.optionLeft = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_TOP)) {
      if (newValue != null) {
        layoutParams.optionTop =
            TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_TOP);
      } else {
        layoutParams.optionTop = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_CENTER)) {
      TiConvert.updateLayoutCenter(newValue, layoutParams);
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_RIGHT)) {
      if (newValue != null) {
        layoutParams.optionRight =
            TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_RIGHT);
      } else {
        layoutParams.optionRight = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_BOTTOM)) {
      if (newValue != null) {
        layoutParams.optionBottom =
            TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_BOTTOM);
      } else {
        layoutParams.optionBottom = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_SIZE)) {
      if (newValue instanceof HashMap) {
        HashMap<String, Object> d = (HashMap) newValue;
        propertyChanged(TiC.PROPERTY_WIDTH, oldValue, d.get(TiC.PROPERTY_WIDTH), proxy);
        propertyChanged(TiC.PROPERTY_HEIGHT, oldValue, d.get(TiC.PROPERTY_HEIGHT), proxy);
      } else if (newValue != null) {
        Log.w(
            LCAT,
            "Unsupported property type ("
                + (newValue.getClass().getSimpleName())
                + ") for key: "
                + key
                + ". Must be an object/dictionary");
      }
    } else if (key.equals(TiC.PROPERTY_HEIGHT)) {
      if (newValue != null) {
        if (!newValue.equals(TiC.SIZE_AUTO)) {
          layoutParams.optionHeight =
              TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_HEIGHT);
          layoutParams.autoHeight = false;
        } else {
          layoutParams.optionHeight = null;
          layoutParams.autoHeight = true;
        }
      } else {
        layoutParams.optionHeight = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_WIDTH)) {
      if (newValue != null) {
        if (!newValue.equals(TiC.SIZE_AUTO)) {
          layoutParams.optionWidth =
              TiConvert.toTiDimension(TiConvert.toString(newValue), TiDimension.TYPE_WIDTH);
          layoutParams.autoWidth = false;
        } else {
          layoutParams.optionWidth = null;
          layoutParams.autoWidth = true;
        }
      } else {
        layoutParams.optionWidth = null;
      }
      layoutNativeView();
    } else if (key.equals(TiC.PROPERTY_ZINDEX)) {
      if (newValue != null) {
        layoutParams.optionZIndex = TiConvert.toInt(newValue);
      } else {
        layoutParams.optionZIndex = 0;
      }
      layoutNativeView(true);
    } else if (key.equals(TiC.PROPERTY_FOCUSABLE)) {
      boolean focusable = TiConvert.toBoolean(proxy.getProperty(TiC.PROPERTY_FOCUSABLE));
      nativeView.setFocusable(focusable);
      if (focusable) {
        registerForKeyClick(nativeView);
      } else {
        // nativeView.setOnClickListener(null); // ? mistake? I assume OnKeyListener was meant
        nativeView.setOnKeyListener(null);
      }
    } else if (key.equals(TiC.PROPERTY_TOUCH_ENABLED)) {
      doSetClickable(TiConvert.toBoolean(newValue));
    } else if (key.equals(TiC.PROPERTY_VISIBLE)) {
      nativeView.setVisibility(TiConvert.toBoolean(newValue) ? View.VISIBLE : View.INVISIBLE);
    } else if (key.equals(TiC.PROPERTY_ENABLED)) {
      nativeView.setEnabled(TiConvert.toBoolean(newValue));
    } else if (key.startsWith(TiC.PROPERTY_BACKGROUND_PADDING)) {
      Log.i(LCAT, key + " not yet implemented.");
    } else if (key.equals(TiC.PROPERTY_OPACITY)
        || key.startsWith(TiC.PROPERTY_BACKGROUND_PREFIX)
        || key.startsWith(TiC.PROPERTY_BORDER_PREFIX)) {
      // Update first before querying.
      proxy.setProperty(key, newValue);

      KrollDict d = proxy.getProperties();

      boolean hasImage = hasImage(d);
      boolean hasColorState = hasColorState(d);
      boolean hasBorder = hasBorder(d);

      boolean requiresCustomBackground = hasImage || hasColorState || hasBorder;

      if (!requiresCustomBackground) {
        if (background != null) {
          background.releaseDelegate();
          background.setCallback(null);
          background = null;
        }

        if (d.containsKeyAndNotNull(TiC.PROPERTY_BACKGROUND_COLOR)) {
          Integer bgColor = TiConvert.toColor(d, TiC.PROPERTY_BACKGROUND_COLOR);
          if (nativeView != null) {
            nativeView.setBackgroundColor(bgColor);
            nativeView.postInvalidate();
          }
        } else {
          if (key.equals(TiC.PROPERTY_OPACITY)) {
            setOpacity(TiConvert.toFloat(newValue));
          }
          if (nativeView != null) {
            nativeView.setBackgroundDrawable(null);
            nativeView.postInvalidate();
          }
        }
      } else {
        boolean newBackground = background == null;
        if (newBackground) {
          background = new TiBackgroundDrawable();
        }

        Integer bgColor = null;

        if (!hasColorState) {
          if (d.get(TiC.PROPERTY_BACKGROUND_COLOR) != null) {
            bgColor = TiConvert.toColor(d, TiC.PROPERTY_BACKGROUND_COLOR);
            if (newBackground
                || (key.equals(TiC.PROPERTY_OPACITY)
                    || key.equals(TiC.PROPERTY_BACKGROUND_COLOR))) {
              background.setBackgroundColor(bgColor);
            }
          }
        }

        if (hasImage || hasColorState) {
          if (newBackground || key.startsWith(TiC.PROPERTY_BACKGROUND_PREFIX)) {
            handleBackgroundImage(d);
          }
        }

        if (hasBorder) {
          if (newBackground) {
            initializeBorder(d, bgColor);
          } else if (key.startsWith(TiC.PROPERTY_BORDER_PREFIX)) {
            handleBorderProperty(key, newValue);
          }
        }
        applyCustomBackground();
      }
      if (nativeView != null) {
        nativeView.postInvalidate();
      }
    } else if (key.equals(TiC.PROPERTY_SOFT_KEYBOARD_ON_FOCUS)) {
      Log.w(
          LCAT,
          "Focus state changed to "
              + TiConvert.toString(newValue)
              + " not honored until next focus event.");
    } else if (key.equals(TiC.PROPERTY_TRANSFORM)) {
      if (nativeView != null) {
        applyTransform((Ti2DMatrix) newValue);
      }
    } else if (key.equals(TiC.PROPERTY_KEEP_SCREEN_ON)) {
      if (nativeView != null) {
        nativeView.setKeepScreenOn(TiConvert.toBoolean(newValue));
      }
    } else {
      TiViewProxy viewProxy = getProxy();
      if (viewProxy != null && viewProxy.isLocalizedTextId(key)) {
        viewProxy.setLocalizedText(key, TiConvert.toString(newValue));
      } else {
        if (DBG) {
          Log.d(LCAT, "Unhandled property key: " + key);
        }
      }
    }
  }
Пример #19
0
 public void registerProxy(KrollProxy proxy) {
   String proxyId = proxy.getProxyId();
   if (!proxyMap.containsKey(proxyId)) {
     proxyMap.put(proxyId, new SoftReference<KrollProxy>(proxy));
   }
 }
 protected KrollProxySupport createProxy(String creationUrl, Object[] args) {
   return KrollProxy.createProxy(ProgressBarProxy.class, getRhinoObject(), args, creationUrl);
 }
Пример #21
0
  @Override
  public boolean dispatchKeyEvent(KeyEvent event) {
    boolean handled = false;

    TiViewProxy window;
    if (this.window != null) {
      window = this.window;
    } else {
      window = this.view;
    }

    if (window == null) {
      return super.dispatchKeyEvent(event);
    }

    switch (event.getKeyCode()) {
      case KeyEvent.KEYCODE_BACK:
        {
          if (event.getAction() == KeyEvent.ACTION_UP) {
            String backEvent = "android:back";
            KrollProxy proxy = null;
            // android:back could be fired from a tabGroup window (activityProxy)
            // or hw window (window).This event is added specifically to the activity
            // proxy of a tab group in window.js
            if (activityProxy.hasListeners(backEvent)) {
              proxy = activityProxy;
            } else if (window.hasListeners(backEvent)) {
              proxy = window;
            }

            if (proxy != null) {
              proxy.fireEvent(backEvent, null);
              handled = true;
            }
          }
          break;
        }
      case KeyEvent.KEYCODE_CAMERA:
        {
          if (window.hasListeners(TiC.EVENT_ANDROID_CAMERA)) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent(TiC.EVENT_ANDROID_CAMERA, null);
            }
            handled = true;
          }
          // TODO: Deprecate old event
          if (window.hasListeners("android:camera")) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent("android:camera", null);
            }
            handled = true;
          }

          break;
        }
      case KeyEvent.KEYCODE_FOCUS:
        {
          if (window.hasListeners(TiC.EVENT_ANDROID_FOCUS)) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent(TiC.EVENT_ANDROID_FOCUS, null);
            }
            handled = true;
          }
          // TODO: Deprecate old event
          if (window.hasListeners("android:focus")) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent("android:focus", null);
            }
            handled = true;
          }

          break;
        }
      case KeyEvent.KEYCODE_SEARCH:
        {
          if (window.hasListeners(TiC.EVENT_ANDROID_SEARCH)) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent(TiC.EVENT_ANDROID_SEARCH, null);
            }
            handled = true;
          }
          // TODO: Deprecate old event
          if (window.hasListeners("android:search")) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent("android:search", null);
            }
            handled = true;
          }

          break;
        }
      case KeyEvent.KEYCODE_VOLUME_UP:
        {
          if (window.hasListeners(TiC.EVENT_ANDROID_VOLUP)) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent(TiC.EVENT_ANDROID_VOLUP, null);
            }
            handled = true;
          }
          // TODO: Deprecate old event
          if (window.hasListeners("android:volup")) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent("android:volup", null);
            }
            handled = true;
          }

          break;
        }
      case KeyEvent.KEYCODE_VOLUME_DOWN:
        {
          if (window.hasListeners(TiC.EVENT_ANDROID_VOLDOWN)) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent(TiC.EVENT_ANDROID_VOLDOWN, null);
            }
            handled = true;
          }
          // TODO: Deprecate old event
          if (window.hasListeners("android:voldown")) {
            if (event.getAction() == KeyEvent.ACTION_UP) {
              window.fireEvent("android:voldown", null);
            }
            handled = true;
          }

          break;
        }
    }

    if (!handled) {
      handled = super.dispatchKeyEvent(event);
    }

    return handled;
  }
 // Handle creation options
 @Override
 public void handleCreationDict(KrollDict options) {
   super.handleCreationDict(options);
 }
Пример #23
0
 @Override
 public void propertyChanged(String key, Object oldValue, Object newValue, KrollProxy proxy) {
   if (Log.isDebugModeEnabled()) {
     Log.d(TAG, "Property: " + key + " old: " + oldValue + " new: " + newValue, Log.DEBUG_MODE);
   }
   if (key.equals(TiC.PROPERTY_ENABLED)) {
     tv.setEnabled(TiConvert.toBoolean(newValue));
   } else if (key.equals(TiC.PROPERTY_VALUE)) {
     tv.setText(TiConvert.toString(newValue));
   } else if (key.equals(TiC.PROPERTY_MAX_LENGTH)) {
     maxLength = TiConvert.toInt(newValue);
     // truncate if current text exceeds max length
     Editable currentText = tv.getText();
     if (maxLength >= 0 && currentText.length() > maxLength) {
       CharSequence truncateText = currentText.subSequence(0, maxLength);
       int cursor = tv.getSelectionStart() - 1;
       if (cursor > maxLength) {
         cursor = maxLength;
       }
       tv.setText(truncateText);
       tv.setSelection(cursor);
     }
   } else if (key.equals(TiC.PROPERTY_COLOR)) {
     tv.setTextColor(TiConvert.toColor((String) newValue));
   } else if (key.equals(TiC.PROPERTY_HINT_TEXT)) {
     tv.setHint((String) newValue);
   } else if (key.equals(TiC.PROPERTY_ELLIPSIZE)) {
     if (TiConvert.toBoolean(newValue)) {
       tv.setEllipsize(TruncateAt.END);
     } else {
       tv.setEllipsize(null);
     }
   } else if (key.equals(TiC.PROPERTY_TEXT_ALIGN) || key.equals(TiC.PROPERTY_VERTICAL_ALIGN)) {
     String textAlign = null;
     String verticalAlign = null;
     if (key.equals(TiC.PROPERTY_TEXT_ALIGN)) {
       textAlign = TiConvert.toString(newValue);
     } else if (proxy.hasProperty(TiC.PROPERTY_TEXT_ALIGN)) {
       textAlign = TiConvert.toString(proxy.getProperty(TiC.PROPERTY_TEXT_ALIGN));
     }
     if (key.equals(TiC.PROPERTY_VERTICAL_ALIGN)) {
       verticalAlign = TiConvert.toString(newValue);
     } else if (proxy.hasProperty(TiC.PROPERTY_VERTICAL_ALIGN)) {
       verticalAlign = TiConvert.toString(proxy.getProperty(TiC.PROPERTY_VERTICAL_ALIGN));
     }
     handleTextAlign(textAlign, verticalAlign);
   } else if (key.equals(TiC.PROPERTY_KEYBOARD_TYPE)
       || (key.equals(TiC.PROPERTY_AUTOCORRECT)
           || key.equals(TiC.PROPERTY_AUTOCAPITALIZATION)
           || key.equals(TiC.PROPERTY_PASSWORD_MASK)
           || key.equals(TiC.PROPERTY_EDITABLE))) {
     KrollDict d = proxy.getProperties();
     handleKeyboard(d);
   } else if (key.equals(TiC.PROPERTY_RETURN_KEY_TYPE)) {
     handleReturnKeyType(TiConvert.toInt(newValue));
   } else if (key.equals(TiC.PROPERTY_FONT)) {
     TiUIHelper.styleText(tv, (HashMap) newValue);
   } else if (key.equals(TiC.PROPERTY_AUTO_LINK)) {
     TiUIHelper.linkifyIfEnabled(tv, newValue);
   } else {
     super.propertyChanged(key, oldValue, newValue, proxy);
   }
 }