@Override
public void finish() {
super.finish();
if (shouldFinishRootActivity()) {
TiApplication app = getTiApp();
if (app != null) {
TiRootActivity rootActivity = app.getRootActivity();
if (rootActivity != null && !(rootActivity.equals(this)) && !rootActivity.isFinishing()) {
rootActivity.finish();
} else if (rootActivity == null && !app.isRestartPending()) {
// When the root activity has been killed and garbage collected and the app is not
// scheduled to restart,
// we need to force finish the root activity while this activity has an intent to finish
// root.
// This happens when the "Don't keep activities" option is enabled and the user stays in
// some activity
// (eg. heavyweight window, tabgroup) other than the root activity for a while and then he
// wants to back
// out the app.
app.setForceFinishRootActivity(true);
}
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
if (willFinishFalseRootActivity(savedInstanceState)) {
return;
}
if (checkInvalidLaunch(savedInstanceState)) {
// Android bug 2373 detected and we're going to restart.
return;
}
TiApplication tiApp = getTiApp();
startedFromBoot = getIntentBoolean(TiC.INTENT_PROPERTY_ON_BOOT, false);
if (tiApp.isRestartPending()
|| TiBaseActivity.isUnsupportedReLaunch(this, savedInstanceState)) {
super.onCreate(savedInstanceState); // Will take care of scheduling restart and finishing.
return;
}
tiApp.setCurrentActivity(this, this);
Log.checkpoint(
TAG, "checkpoint, on root activity create, savedInstanceState: " + savedInstanceState);
tiApp.setRootActivity(this);
super.onCreate(savedInstanceState);
tiApp.verifyCustomModules(this);
}
@Override
/**
* When this activity restarts, this method updates the current activity to this and fires
* javascript 'restart' event.
*/
protected void onRestart() {
inForeground = true;
super.onRestart();
Log.d(TAG, "Activity " + this + " onRestart", Log.DEBUG_MODE);
TiApplication tiApp = getTiApp();
if (tiApp.isRestartPending()) {
if (!isFinishing()) {
finish();
}
return;
}
if (activityProxy != null) {
// we only want to set the current activity for good in the resume state but we need it right
// now.
// save off the existing current activity, set ourselves to be the new current activity
// temporarily
// so we don't run into problems when we give the proxy the event
Activity tempCurrentActivity = tiApp.getCurrentActivity();
tiApp.setCurrentActivity(this, this);
activityProxy.fireSyncEvent(TiC.EVENT_RESTART, null);
// set the current activity back to what it was originally
tiApp.setCurrentActivity(this, tempCurrentActivity);
}
}
@Kroll.method
public void cancelAlarmService(@Kroll.argument(optional = true) Object requestCode) {
// To cancel an alarm the signature needs to be the same as the submitting one.
utils.infoLog("Cancelling Alarm Service");
int intentRequestCode = AlarmmanagerModule.DEFAULT_REQUEST_CODE;
if (requestCode != null) {
if (requestCode instanceof Number) {
intentRequestCode = ((Number) requestCode).intValue();
}
}
// Create a placeholder for the args value
HashMap<String, Object> placeholder = new HashMap<String, Object>(0);
KrollDict args = new KrollDict(placeholder);
// Create the Alarm Manager
AlarmManager am =
(AlarmManager)
TiApplication.getInstance()
.getApplicationContext()
.getSystemService(TiApplication.ALARM_SERVICE);
Intent intent = createAlarmServiceIntent(args);
PendingIntent sender =
PendingIntent.getBroadcast(
TiApplication.getInstance().getApplicationContext(),
intentRequestCode,
intent,
PendingIntent.FLAG_UPDATE_CURRENT);
am.cancel(sender);
utils.infoLog("Alarm Service Canceled");
}
@Override
/**
* When this activity starts, this method updates the current activity to this if necessary and
* fire javascript 'start' and 'focus' events. Focus events will only fire if the activity is not
* a tab activity.
*/
protected void onStart() {
inForeground = true;
super.onStart();
if (isFinishing()) {
return;
}
// Newer versions of Android appear to turn this on by default.
// Turn if off until an activity indicator is shown.
setProgressBarIndeterminateVisibility(false);
Log.d(TAG, "Activity " + this + " onStart", Log.DEBUG_MODE);
TiApplication tiApp = getTiApp();
if (tiApp.isRestartPending()) {
if (!isFinishing()) {
finish();
}
return;
}
updateTitle();
if (activityProxy != null) {
// we only want to set the current activity for good in the resume state but we need it right
// now.
// save off the existing current activity, set ourselves to be the new current activity
// temporarily
// so we don't run into problems when we give the proxy the event
Activity tempCurrentActivity = tiApp.getCurrentActivity();
tiApp.setCurrentActivity(this, this);
activityProxy.fireEvent(TiC.EVENT_START, null);
// set the current activity back to what it was originally
tiApp.setCurrentActivity(this, tempCurrentActivity);
}
synchronized (lifecycleListeners.synchronizedList()) {
for (OnLifecycleEvent listener : lifecycleListeners.nonNull()) {
try {
TiLifecycle.fireLifecycleEvent(this, listener, TiLifecycle.LIFECYCLE_ON_START);
} catch (Throwable t) {
Log.e(TAG, "Error dispatching lifecycle event: " + t.getMessage(), t);
}
}
}
// store current configuration orientation
// This fixed bug with double orientation chnage firing when activity starts in landscape
previousOrientation = getResources().getConfiguration().orientation;
}
public SensorModule(TiContext tiContext) {
this();
if (TiApplication.getInstance().getSystemService(Context.SENSOR_SERVICE) != null) {
sensorManager =
(SensorManager) TiApplication.getInstance().getSystemService(Context.SENSOR_SERVICE);
}
}
private Object loadMethod(Class<?> source, String name) {
Object o = null;
TiApplication tiApp = weakApplication.get();
if (tiApp != null) {
o = tiApp.methodFor(source, name);
}
return o;
}
private static UrbanAirshipModule getModule() {
TiApplication appContext = TiApplication.getInstance();
UrbanAirshipModule uaModule = (UrbanAirshipModule) appContext.getModuleByName(ModuleName);
if (uaModule == null) {
Log.w(LCAT, "Urban Airship module not currently loaded");
}
return uaModule;
}
@Override
/**
* When this activity pauses, this method sets the current activity to null, fires a javascript
* 'pause' event, and if the activity is finishing, remove all dialogs associated with it.
*/
protected void onPause() {
inForeground = false;
super.onPause();
isResumed = false;
Log.d(TAG, "Activity " + this + " onPause", Log.DEBUG_MODE);
TiApplication tiApp = getTiApp();
if (tiApp.isRestartPending()) {
releaseDialogs(true);
if (!isFinishing()) {
finish();
}
return;
}
if (!windowStack.empty()) {
windowStack.peek().onWindowFocusChange(false);
}
TiApplication.updateActivityTransitionState(true);
tiApp.setCurrentActivity(this, null);
TiUIHelper.showSoftKeyboard(getWindow().getDecorView(), false);
if (this.isFinishing()) {
releaseDialogs(true);
} else {
// release non-persistent dialogs when activity hides
releaseDialogs(false);
}
if (activityProxy != null) {
activityProxy.fireSyncEvent(TiC.EVENT_PAUSE, null);
}
synchronized (lifecycleListeners.synchronizedList()) {
for (OnLifecycleEvent listener : lifecycleListeners.nonNull()) {
try {
TiLifecycle.fireLifecycleEvent(this, listener, TiLifecycle.LIFECYCLE_ON_PAUSE);
} catch (Throwable t) {
Log.e(TAG, "Error dispatching lifecycle event: " + t.getMessage(), t);
}
}
}
// Checkpoint for ti.end event
if (tiApp != null) {
tiApp.postAnalyticsEvent(TiAnalyticsEventFactory.createAppEndEvent());
}
}
/**
* Returns the content view for this tab.
*
* @return the content view or null if the tab is empty
*/
public View getContentView() {
if (contentView == null) {
TiWindowProxy windowProxy = getWindowProxy();
if (windowProxy == null) {
// If no window is provided use an empty view.
View emptyContent = new View(TiApplication.getInstance().getApplicationContext());
emptyContent.setBackgroundColor(Color.BLACK);
return emptyContent;
}
contentView = new TabContentViewProxy();
// A tab's window should be bound to the tab group's activity.
// In order for the 'activity' property to work correctly
// we need to set the content view's activity to that of the group.
Activity tabGroupActivity = ((TabProxy) proxy).getTabGroup().getActivity();
contentView.setActivity(tabGroupActivity);
// Assign parent so events bubble up correctly.
contentView.setParent(proxy);
// Allow the window to fill the content view with its children.
windowProxy.getKrollObject().setWindow(contentView);
}
return contentView.getOrCreateView().getNativeView();
}
@Kroll.method
public void remove(TiViewProxy child) {
if (child == null) {
Log.w(LCAT, "add called with null child");
return;
}
if (peekView() != null) {
if (TiApplication.isUIThread()) {
handleRemove(child);
return;
}
TiMessenger.sendBlockingMainMessage(getMainHandler().obtainMessage(MSG_REMOVE_CHILD), child);
} else {
if (children != null) {
children.remove(child);
if (child.parent != null && child.parent.get() == this) {
child.parent = null;
}
}
}
}
@Kroll.method
public void add(TiViewProxy child) {
if (child == null) {
Log.w(LCAT, "add called with null child");
return;
}
if (children == null) {
children = new ArrayList<TiViewProxy>();
}
if (peekView() != null) {
if (TiApplication.isUIThread()) {
handleAdd(child);
return;
}
TiMessenger.sendBlockingMainMessage(getMainHandler().obtainMessage(MSG_ADD_CHILD), child);
} else {
children.add(child);
child.parent = new WeakReference<TiViewProxy>(this);
}
// TODO zOrder
}
protected InputMethodManager getIMM() {
InputMethodManager imm = null;
imm =
(InputMethodManager)
TiApplication.getInstance().getSystemService(Context.INPUT_METHOD_SERVICE);
return imm;
}
@Kroll.method
@Kroll.getProperty
public String getExternalFilesDir() {
File f = m_app.getExternalFilesDir(null);
if (!f.exists()) f.mkdirs();
return f.getAbsolutePath();
}
private Activity getCurrentActivity() {
Activity currentActivity = TiApplication.getInstance().getCurrentActivity();
if (currentActivity == null) {
currentActivity = proxy.getActivity();
}
return currentActivity;
}
@Kroll.method
public Crouton makeText(String text, int style) {
Log.d(TAG, "makeText called");
return Crouton.makeText(
TiApplication.getInstance().getCurrentActivity(), text, getStyle(style));
}
@Kroll.method
public void cancelNotification(int requestCode) {
NotificationManager notificationManager =
(NotificationManager)
TiApplication.getInstance().getSystemService(TiApplication.NOTIFICATION_SERVICE);
notificationManager.cancel(requestCode);
}
private Intent createAlarmServiceIntent(KrollDict args) {
String serviceName = args.getString("service");
Intent intent =
new Intent(TiApplication.getInstance().getApplicationContext(), AlarmServiceListener.class);
intent.putExtra("alarm_service_name", serviceName);
// Pass in flag if we need to restart the service on each call
intent.putExtra("alarm_service_force_restart", (optionIsEnabled(args, "forceRestart")));
// Check if the user has selected to use intervals
boolean hasInterval = (args.containsKeyAndNotNull("interval"));
long intervalValue = 0;
if (hasInterval) {
Object interval = args.get("interval");
if (interval instanceof Number) {
intervalValue = ((Number) interval).longValue();
} else {
hasInterval = false;
}
}
intent.putExtra("alarm_service_has_interval", hasInterval);
if (hasInterval) {
intent.putExtra("alarm_service_interval", intervalValue);
}
utils.debugLog(
"created alarm service intent for "
+ serviceName
+ "(forceRestart: "
+ (optionIsEnabled(args, "forceRestart") ? "true" : "false")
+ ", intervalValue: "
+ intervalValue
+ ")");
return intent;
}
@Kroll.method
public void takeScreenshot(KrollFunction callback) {
Activity a = TiApplication.getAppCurrentActivity();
if (a == null) {
Log.w(TAG, "Could not get current activity for takeScreenshot.", Log.DEBUG_MODE);
callback.callAsync(getKrollObject(), new Object[] {null});
return;
}
while (a.getParent() != null) {
a = a.getParent();
}
Window w = a.getWindow();
while (w.getContainer() != null) {
w = w.getContainer();
}
KrollDict image = TiUIHelper.viewToImage(null, w.getDecorView());
if (callback != null) {
callback.callAsync(getKrollObject(), new Object[] {image});
}
}
@Kroll.method
protected boolean hasFlashLight() {
Activity activity = TiApplication.getAppRootOrCurrentActivity();
boolean hasFlash =
activity.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FLASH);
return hasFlash;
}
private void setImage(final Bitmap bitmap) {
if (!TiApplication.isUIThread()) {
TiMessenger.sendBlockingMainMessage(handler.obtainMessage(SET_IMAGE), bitmap);
} else {
handleSetImage(bitmap);
}
}
@Kroll.method
public void hide() {
if (TiApplication.isUIThread()) {
handleHide();
} else {
getMainHandler().obtainMessage(MSG_HIDE).sendToTarget();
}
}
@Kroll.method
public void show() {
if (TiApplication.isUIThread()) {
handleShow();
} else {
getMainHandler().obtainMessage(MSG_SHOW).sendToTarget();
}
}
@Kroll.method
public void release() {
if (TiApplication.isUIThread()) {
super.releaseViews();
} else {
getMainHandler().sendEmptyMessage(MSG_RELEASE);
}
}
@Kroll.method
public void appendItems(Object data) {
if (TiApplication.isUIThread()) {
handleAppendItems(data);
} else {
TiMessenger.sendBlockingMainMessage(getMainHandler().obtainMessage(MSG_APPEND_ITEMS), data);
}
}
@Kroll.method
public void hide(@Kroll.argument(optional = true) KrollDict options) {
if (TiApplication.isUIThread()) {
handleHide(options);
} else {
getMainHandler().obtainMessage(MSG_HIDE, options).sendToTarget();
}
}
@Kroll.method
public void blur() {
if (TiApplication.isUIThread()) {
handleBlur();
} else {
getMainHandler().sendEmptyMessage(MSG_BLUR);
}
}
@Kroll.method
public void focus() {
if (TiApplication.isUIThread()) {
handleFocus();
} else {
getMainHandler().sendEmptyMessage(MSG_FOCUS);
}
}
public void stop() {
if (!TiApplication.isUIThread()) {
Message message = handler.obtainMessage(STOP);
message.sendToTarget();
} else {
handleStop();
}
}
@Override
public void finish() {
if (finishing2373) {
super.finish();
return;
}
// Ensure we only run the finish logic once. We want to avoid an infinite loop since this method
// can be called
// from the finish method inside TiBaseActivity ( which can be triggered by
// terminateActivityStack() )
if (!finishing) {
finishing = true;
TiApplication.removeFromActivityStack(this);
TiApplication.terminateActivityStack();
super.finish();
}
}
