que realmente no quieren usar TabHost y TabWidget en el archivo del formato XML para configurar sus pestañas.
Lo hice todo a través del código en una clase que amplía TabActivity, y para cada pestaña, solo asocié una Actividad con su propio archivo de diseño XML que se encargó del diseño de la interfaz de usuario para esa pestaña específica.
Aquí está la clase TabActivity, y también un ejemplo del XML background_selectors que se ocupa de la apariencia de la Etiqueta TAB.
package com.android.myapp;
import android.app.TabActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.View;
import android.widget.TabHost;
import android.widget.TabHost.TabSpec;
public class myMainActivity extends TabActivity {
protected static TabActivity ty;
private static TabSpec tsFirst = null;
private static TabSpec tsSecond = null;
private static TabSpec tsThird = null;
private static TabSpec tsFourth = null;
private static TabHost mytabHost = null;
private static final String FIRST_TAB_NAME = "Tab1";
private static final String SECOND_TAB_NAME = "Tab2";
private static final String THIRD_TAB_NAME = "Tab3";
private static final String FOURTH_TAB_NAME = "Tab4";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
try {
Bundle extras = getIntent().getExtras();
if (extras != null) {
String strQuitStatus = extras.getString("QUITTING");
if (strQuitStatus.equals("TRUE")) {
// exit application
System.gc();
myMainActivity.this.finish();
return;
}// end if (strQuitStatus.equals("TRUE"))
}// end if (extras != null)
this.myTabScreenSetup();
}// end try statements
catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.onCreate", "");
errExcpError = null;
}// end try/catch (Exception error)
}// end onCreate
/**
* myTabScreenSetup method
*
* Sets up the main tab screen
*
* @return void
*
*/
protected void myTabScreenSetup() {
try {
mytabHost = getTabHost();
mytabHost.setVisibility(View.GONE);
mytabHost.setCurrentTab(0);
mytabHost.clearAllTabs();
// create TabSpec instances
tsFirst = mytabHost.newTabSpec(FIRST_TAB_NAME);
tsSecond = mytabHost.newTabSpec(SECOND_TAB_NAME);
tsThird = mytabHost.newTabSpec(THIRD_TAB_NAME);
tsFourth = mytabHost.newTabSpec(FOURTH_TAB_NAME);
// create page tabs
// First list tab
Intent intentFirstList = new Intent(myMainActivity.this,
FirstListView.class);
intentFirstList.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mytabHost.addTab(tsFirst.setIndicator(
FIRST_TAB_NAME,
myMainActivity.this.getResources().getDrawable(
R.drawable.first_tab_background_selectors)).setContent(
intentFirstList));
// Second list tab
Intent intentSecondList = new Intent(myMainActivity.this,
SecondListView.class);
intentSecondList.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mytabHost.addTab(tsSecond.setIndicator(
SECOND_TAB_NAME,
myMainActivity.this.getResources().getDrawable(
R.drawable.second_tab_background_selectors)).setContent(
intentSecondList));
// Third list tab
Intent intentThirdList = new Intent(myMainActivity.this,
ThirdListView.class);
intentThirdList.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mytabHost.addTab(tsThird.setIndicator(
THIRD_TAB_NAME,
myMainActivity.this.getResources().getDrawable(
R.drawable.third_tab_background_selectors)).setContent(
intentThirdList));
// Fourth tab
Intent intentFourthTab = new Intent(myMainActivity.this,
FourthListView.class);
intentFourthTab.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
mytabHost.addTab(tsFourth.setIndicator(
FOURTH_TAB_NAME,
myMainActivity.this.getResources().getDrawable(
R.drawable.fourth_tab_background_selectors)).setContent(
intentFourthTab));
// set active tab to the first tab
mytabHost.setCurrentTab(0);
mytabHost.setVisibility(View.VISIBLE);
} catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.myTabScreenSetup", "");
errExcpError = null;
}// end try/catch (Exception error)
}// end myTabScreenSetup
/**
* onResume
*
* Called after onRestoreInstanceState(Bundle), onRestart(), or onPause(), for
* your activity to start interacting with the user.
*
* This is a good place to begin animations, open exclusive-access devices
* (such as the camera), etc.
*
* Per the conditional check results, cleanup is performed and then the
* program returns focus to the calling code.
*
*/
@Override
protected void onResume() {
super.onResume();
try {
Bundle extras = getIntent().getExtras();
if (extras != null) {
String strQuitStatus = extras.getString("QUITTING");
if (strQuitStatus.equals("TRUE")) {
// exit application
System.gc();
myMainActivity.this.finish();
return;
}// end if (strQuitStatus.equals("TRUE"))
}// end if (extras != null)
}// end try
catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.onResume", "");
errExcpError = null;
}// end try/catch (Exception error)
}// end onResume
/**
* onPause method
*
* Called as part of the activity lifecycle when an activity is going into the
* background, but has not (yet) been killed. The counterpart to onResume().
*
* This callback is mostly used for saving any persistent state the activity
* is editing, to present a "edit in place" model to the user and making sure
* nothing is lost if there are not enough resources to start the new activity
* without first killing this one.
*
* This is also a good place to do things like stop animations and other
* things that consume a noticeable mount of CPU in order to make the switch
* to the next activity as fast as possible, or to close resources that are
* exclusive access such as the camera.
*
* Checks the current state. If in "QUIT" state, then the cleanup and finish
* code is executed.
*
* "SAVEINSTANCE" is used for when the screen orientation is changed.
*
* @return void
*
*/
@Override
protected void onPause() {
super.onPause();
// The user is going somewhere else, so make sure their current
// changes are safely saved away in the provider. We don't need
// to do this if only editing.
try {
//onPause code if needed
}// end try
catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.onPause", "");
errExcpError = null;
}// end try/catch (Exception error)
}// end onPause
/**
* myAppCleanup method
*
* Sets object variables to null
*
* @return void
*
*/
protected void myAppCleanup() {
/* Set object variables to null */
tsFirst = null;
tsSecond = null;
tsThird = null;
tsFourth = null;
mytabHost = null;
System.gc();
}// end myAppCleanup
/**
* onDestroy method
*
* Perform any final cleanup before an activity is destroyed.
*
* This can happen either because the activity is finishing (someone called
* finish() on it, or because the system is temporarily destroying this
* instance of the activity to save space.
*
* You can distinguish between these two scenarios with the isFinishing()
* method.
*
* Note: do not count on this method being called as a place for saving data!
* For example, if an activity is editing data in a content provider, those
* edits should be committed in either onPause() or
* onSaveInstanceState(Bundle), not here.
*
* This method is usually implemented to free resources like threads that are
* associated with an activity, so that a destroyed activity does not leave
* such things around while the rest of its application is still running.
*
* There are situations where the system will simply kill the activity's
* hosting process without calling this method (or any others) in it, so it
* should not be used to do things that are intended to remain around after
* the process goes away.
*
* Derived classes must call through to the super class's implementation of
* this method. If they do not, an exception will be thrown.
*
* @return void
*
*/
@Override
protected void onDestroy() {
// The user is going somewhere else, so make sure their current
// changes are safely saved away in the provider. We don't need
// to do this if only editing.
myAppCleanup();
super.onDestroy();
}// end onDestroy
/**
* onSaveInstanceState method
*
* This method is called before an activity may be killed so that when it
* comes back some time in the future it can restore its state.
*
* If called, this method will occur before onStop(). There are no guarantees
* about whether it will occur before or after onPause().
*
* @param Bundle
* savedInstanceState: Bundle in which to place your saved state.
*
* @return void
*
*/
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
// Save UI state changes to the savedInstanceState.
// This bundle will be passed to onCreate if the process is
// killed and restarted.
super.onSaveInstanceState(savedInstanceState);
try {
//onSaveInstanceState code as needed
}// end try
catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error,
"myMainActivityw.onSaveInstanceState", "no prompt");
errExcpError = null;
}// end try/catch (Exception error)
}// end onSaveInstanceState
/**
* onRestoreInstanceState method
*
* This method is called after onStart() when the activity is being
* re-initialized from a previously saved state, given here in state.
*
* Most implementations will simply use onCreate(Bundle) to restore their
* state, but it is sometimes convenient to do it here after all of the
* initialization has been done or to allow subclasses to decide whether to
* use your default implementation.
*
* The default implementation of this method performs a restore of any view
* state that had previously been frozen by onSaveInstanceState(Bundle).
*
* @param Bundle
* savedInstanceState: the data most recently supplied in
* onSaveInstanceState(Bundle).
*
* @return void
*
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
// Restore UI state from the savedInstanceState.
// This bundle has also been passed to onCreate.
try {
//onRestoreInstanceState code as needed
}// end try
catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error,
"myMainActivity.onRestoreInstanceState", "");
errExcpError = null;
}// end try/catch (Exception error)
}// end onRestoreInstanceState
/**
* onStart method
*
* Perform actions before the Activity is shown
*
* @return void
*
*/
@Override
protected void onStart() {
super.onStart();
/* Set object variables to null */
try {
Bundle extras = getIntent().getExtras();
if (extras != null) {
String strQuitStatus = extras.getString("QUITTING");
if (strQuitStatus.equals("TRUE")) {
// exit application
System.gc();
myMainActivity.this.finish();
return;
}// end if (strQuitStatus.equals("TRUE"))
}// end if (extras != null)
} catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.onStart", "no alert");
errExcpError = null;
}// end try/catch (Exception error)
}// end onStart
/**
* onStop method
*
* Perform actions when the Activity is hidden from view
*
* @return void
*
*/
@Override
protected void onStop() {
super.onStop();
/* Set object variables to null */
try {
if (mytabHost != null){
mytabHost = null;
}
this.myAppCleanup();
} catch (Exception error) {
MyErrorLog<Exception> errExcpError = new MyErrorLog<Exception>(
myMainActivity.this);
errExcpError.addToLogFile(error, "myMainActivity.onStop", "no alert");
errExcpError = null;
}// end try/catch (Exception error)
}// end onStop
/**
* onKeyDown method
*
* Executes code depending on what keyCode is pressed.
*
* @param int keyCode
* @param KeyEvent
* event KeyEvent object
*
* @return true if the code completes execution, false otherwise
*
*/
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_BACK:
/* perform cleanup */
myMainActivity.mytabHost = getTabHost();
myMainActivity.mytabHost.clearAllTabs();
/* call System.gc */
System.gc();
myMainActivity.this.finish();
return true;
default:
return false;
}
}// end onKeyDown
}// end myMainActivity
Aquí está el archivo XML first_tab_background_selectors:
?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2008 The Android Open Source Project
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.
-->
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<!-- Non focused states -->
<item android:state_focused="false"
android:state_selected="false"
android:state_pressed="false"
android:drawable="@drawable/first_list_unselected_tab_icon" />
<item android:state_focused="false"
android:state_selected="true"
android:state_pressed="false"
android:drawable="@drawable/first_list_selected_tab_icon" />
<!-- Focused states -->
<item android:state_focused="true"
android:state_selected="true"
android:state_pressed="false"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:state_focused="true"
android:state_selected="false"
android:state_pressed="false"
android:drawable="@drawable/first_list_unselected_tab_icon" />
<!-- Pressed -->
<item android:state_focused="true"
android:state_selected="true"
android:state_pressed="true"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:state_focused="false"
android:state_selected="true"
android:state_pressed="true"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:state_pressed="true"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:state_enabled="true"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:state_focused="true"
android:drawable="@drawable/first_list_selected_tab_icon" />
<item android:drawable="@drawable/first_list_unselected_tab_icon" />
</selector>
El selected_tab_icon y los unselected_tab_icons son archivos de imagen PNG, dependiendo del tamaño, la resolución, directrices y otros gráficos según las instrucciones de la Guía de desarrolladores de Android.
No es una respuesta real. Simplemente sugiriendo de otra manera, eso tampoco funcionará. Y el asunto es que si usas TabActivity no puedes mostrar nada fuera de esa actividad. Por ejemplo: en la pregunta, quiere que EditText sea visible sin importar qué pestaña se seleccione. Eso no es posible con TabActivity. –