/*
* Copyright (C) 2007 Google Inc.
*
* 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 com.google.android.skeletonapp;
import android.app.Activity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
/**
* This class provides a basic demonstration of how to write an Android
* activity. Inside of its window, it places a single view: an EditText that
* displays and edits some internal text.
*/
class SkeletonActivity extends Activity {
static final private int BACK_ID = Menu.FIRST;
static final private int CLEAR_ID = Menu.FIRST + 1;
private EditText mEditor;
public SkeletonActivity() {
}
/** Called with the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
// Inflate our UI from its XML layout description.
setContentView(R.layout.skeleton_activity);
// Find the text editor view inside the layout, because we
// want to do various programmatic things with it.
mEditor = (EditText) findViewById(R.id.editor);
// Hook up button presses to the appropriate event handler.
((Button) findViewById(R.id.back)).setOnClickListener(mBackListener);
((Button) findViewById(R.id.clear)).setOnClickListener(mClearListener);
// There are two cases we are interested in here: If icicle
// is supplied, we need to place it into the text editor to
// put us back to that state. Otherwise, we need to initialize
// the text editor to its default state.
Bundle textState = icicle != null ? icicle.getBundle("text") : null;
// Note that this example is a little different than what is common
// in a "real" application, where the data being edited is stored
// in some persistent back-end content provider. Here we save and
// restore all of the text editor state, including the text itself.
// If the text was kept in persistent storage, we would instead load
// the text from storage and restoreState() would only restore
// the normal editor state (cursor position etc).
// If we have state, try to restore it; if we don't have state
// or the restore fails, initialize to default state.
if (textState == null || !mEditor.restoreState(textState)) {
mEditor.setText(getText(R.string.main_label));
}
}
/**
* Called when the activity is about to start interacting with the user.
*/
@Override
protected void onResume() {
super.onResume();
}
/**
* Called to remember the current state before the activity stops.
*/
@Override
protected void onFreeze(Bundle outState) {
super.onFreeze(outState);
// Save the current text editor state. As noted above in
// onCreate(), this is somewhat unusual in that our text
// is not in persistent storage. If we did have it in persistent
// storage, we would call mEditor.saveState() here instead.
outState.putBundle("text", mEditor.saveStateAndText());
}
/**
* Called when your activity's options menu needs to be created.
*/
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
// We are going to create two menus. Note that we assign them
// unique integer IDs, labels from our string resources, and
// given them shortcuts.
menu.add(0, BACK_ID, R.string.back).
setShortcut(KeyEvent.KEYCODE_0, 0, KeyEvent.KEYCODE_B);
menu.add(0, CLEAR_ID, R.string.clear).
setShortcut(KeyEvent.KEYCODE_1, 0, KeyEvent.KEYCODE_C);
return true;
}
/**
* Called right before your activity's option menu is displayed.
*/
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
super.onPrepareOptionsMenu(menu);
// Before showing the menu, we need to decide whether the clear
// item is enabled depending on whether there is text to clear.
menu.setItemShown(CLEAR_ID, mEditor.getText().length() > 0);
return true;
}
/**
* Called when a menu item is selected.
*/
@Override
public boolean onOptionsItemSelected(Menu.Item item) {
switch (item.getId()) {
case BACK_ID:
finish();
return true;
case CLEAR_ID:
mEditor.setText("");
return true;
}
return super.onOptionsItemSelected(item);
}
/**
* A call-back for when the user presses the back button.
*/
OnClickListener mBackListener = new OnClickListener() {
public void onClick(View v) {
finish();
}
};
/**
* A call-back for when the user presses the clear button.
*/
OnClickListener mClearListener = new OnClickListener() {
public void onClick(View v) {
mEditor.setText("");
}
};
}
|