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);
}
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);
}
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 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);
}
}
}
}
