Parches existentes para la tableta de Android para permitir pestañas en el lado izquierdo?

Question

Mi empleador me está haciendo trabajar en una aplicación de Android con requisitos de IU muy específicos. Específicamente, necesitamos una interfaz que se vea exactamente como una interfaz TabWidget. Sin embargo, tener las pestañas en el lado izquierdo es una necesidad absoluta. No vamos a implementar esta aplicación en ningún teléfono Android, es un dispositivo interno y, por lo tanto, no hay ningún problema que viole las consideraciones de diseño que pueda tener la plataforma Android.

Ya tenemos un prototipo funcional que combina la funcionalidad que necesitamos usando una combinación de oyentes de enfoque y vistas de lista. No es bonito, y aún no confiamos en él, pero funciona por el momento.

Lo que realmente nos gustaría es tirar todo nuestro prototipo de código de UI a cambio de usar el integrado TabWidget. Sin embargo, dado que TabWidget está codificado de manera que solo funciona con las pestañas superiores, esta no es realmente una opción.

Por lo tanto, esperamos que alguien tenga un parche, un conjunto de parches o una clase personalizada que maneje la funcionalidad de TabWidget con las pestañas laterales.

El código relevante para la TabWidget está aquí: http://www.google.com/codesearch/p?hl=en#uX1GffpyOZk/core/java/android/widget/TabWidget.java&q=android%20package:git://android.git.kernel.org%20lang:java%20tabwidget&sa=N&cd=1&ct=rc

y la función específica que está codificado por ser las pestañas en la parte superior es

private void initTabWidget() { 
    setOrientation(LinearLayout.HORIZONTAL); 
    mGroupFlags |= FLAG_USE_CHILD_DRAWING_ORDER; 

    final Context context = mContext; 
    final Resources resources = context.getResources(); 

    if (context.getApplicationInfo().targetSdkVersion <= Build.VERSION_CODES.DONUT) { 
     // Donut apps get old color scheme 
     if (mLeftStrip == null) { 
      mLeftStrip = resources.getDrawable(
        com.android.internal.R.drawable.tab_bottom_left_v4); 
     } 
     if (mRightStrip == null) { 
      mRightStrip = resources.getDrawable(
        com.android.internal.R.drawable.tab_bottom_right_v4); 
     } 
    } else { 
     // Use modern color scheme for Eclair and beyond 
     if (mLeftStrip == null) { 
      mLeftStrip = resources.getDrawable(
        com.android.internal.R.drawable.tab_bottom_left); 
     } 
     if (mRightStrip == null) { 
      mRightStrip = resources.getDrawable(
        com.android.internal.R.drawable.tab_bottom_right); 
     } 
    } 

    // Deal with focus, as we don't want the focus to go by default 
    // to a tab other than the current tab 
    setFocusable(true); 
    setOnFocusChangeListener(this); 
} 

Si alguien tiene alguna información, yo estaría muy agradecido .

Answer 1

He tenido este problema con pestañas en la parte inferior. Terminé simplemente copiando todos los elementos dibujables de fondo de las pestañas y haciendo botones con texto dibujables y textcolor con apariencia de estado que parecían pestañas que controlaban un ViewFlipper en el panel de la IU principal para alternar entre las vistas.

Answer 2

(Tenga en cuenta que he añadido una mejor respuesta más abajo, más allá de la línea. Me voy de este top una en caso de necesidades que se ajuste mejor a alguien más.)

Sí, he estado tratando con el mismo problema. Tengo una solución algo torpe. Noté que puedes rotar casi cualquier Vista con setRotate. Desafortunadamente, esto solo gira su imagen, o algo así, y no se ocupa completamente de los problemas o la ubicación o el tamaño o la alineación. Aun así, he logrado improvisar algo que lo compense, aunque solo esté medio hecho (no funciona bien si giras a orientación vertical). Se llama a los siguientes siempre que se gira la tableta o se reorganiza el diseño o lo que sea.

private LinearLayout llMain; 
private LinearLayout ll1; 
private LinearLayout mainView; 
private TabHost myTabHost; 

public void setStuff() { 
    Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay(); 
    if (display.getOrientation() == 0 || display.getOrientation() == 2) { 
     ViewGroup.LayoutParams lp = myTabHost.getLayoutParams(); 
     int top = 0; 
     int left = 0; 
     int height = 696; 
     int width = 1280; 
     int centerx = (width/2) + left; 
     int centery = (height/2) + top; 
     lp.height = width; 
     lp.width = height; 
     myTabHost.setLayoutParams(lp); 
     myTabHost.setTranslationX(centerx - (height/2)); 
     myTabHost.setTranslationY(centery - (width/2)); 
     lp = mainView.getLayoutParams(); 
     lp.width = 1280; 
     lp.height = 696; 
     mainView.setLayoutParams(lp); 
     lp = llMain.getLayoutParams(); 
     lp.width = 1280; 
     lp.height = 696; 
     llMain.setLayoutParams(lp); 

     ll1.setRotation(-90); 
     lp = ll1.getLayoutParams(); 
     lp.height = 696; 
     lp.width = 1141; 
     ll1.setLayoutParams(lp); 
     left = 0; 
     top = 0; 
     height = 696; 
     width = 1141; 
     centerx = (width/2) + left; 
     centery = (height/2) + top; 
     ll1.setTranslationX(centery - (width/2)); 
     ll1.setTranslationY(centerx - (height/2)); 
     //ll1.setTranslationX(tx); 
     //ll1.setTranslationY(ty); 
    } else { 
     ViewGroup.LayoutParams lp = myTabHost.getLayoutParams(); 
     int top = 0; 
     int left = 0; 
     int height = 1280; 
     int width = 696; 
     int centerx = (width/2) + left; 
     int centery = (height/2) + top; 
     lp.height = width; 
     lp.width = height; 
     myTabHost.setLayoutParams(lp); 
     myTabHost.setTranslationX(centerx - (height/2)); 
     myTabHost.setTranslationY(centery - (width/2)); 
     lp = mainView.getLayoutParams(); 
     lp.width = 696; 
     lp.height = 1280; 
     mainView.setLayoutParams(lp); 
     lp = llMain.getLayoutParams(); 
     lp.width = 696; 
     lp.height = 1280; 
     llMain.setLayoutParams(lp); 

     ll1.setRotation(-90); 
     lp = ll1.getLayoutParams(); 
     lp.height = 1141; 
     lp.width = 696; 
     ll1.setLayoutParams(lp); 
     left = 0; 
     top = 0; 
     height = 1141; 
     width = 696; 
     centerx = (width/2) + left; 
     centery = (height/2) + top; 
     ll1.setTranslationX(centery - (width/1)); 
     ll1.setTranslationY(centerx - (height/1)); 
     //ll1.setTranslationX(tx); 
     //ll1.setTranslationY(ty); 
    } 
} 

@Override 
public void onConfigurationChanged(Configuration newConfig) { 
    super.onConfigurationChanged(newConfig); 
    setStuff(); 
    //setContentView(R.layout.main); 
} 

llMain contiene mainView contains myTabHost contains ll1; deberás haberlos asignado como tal en el código de inicialización. La idea es que el TabHost se gira en el sentido de las agujas del reloj, y sus dimensiones deben intercambiarse manualmente para que sus contenedores sepan que tiene un tamaño/forma diferente, de lo contrario los bordes se cortan. Además, algunos cálculos se realizan para que giren alrededor del punto correcto, o al menos terminen en el lugar correcto. Los resultados no siempre tuvieron sentido, así que simplemente cambié cosas hasta que funcionó, al menos en modo horizontal. El contenido del TabHost también se rota, por lo que hay un código que lo gira hacia atrás, al menos la primera pestaña, que es ll1. Otras pestañas necesitarían girarse de manera similar. Me equivoqué con esto por un tiempo, y puede haber algunas cosas que son innecesarias. Por ejemplo, la vista principal. Creo que no es necesario que esté allí. Ah, y si el TabHost está en un lugar diferente, los números deberán ajustarse de alguna manera. Buena suerte con eso. De todos modos, espero que esto ayude a alguien. Hombre, la GUI de Android es tan irritante ... desearía que lo arreglaran ...Debo admitir, sin embargo, que a pesar de todos los obstáculos y frustraciones, la rotación de cualquier componente es bastante genial. Solo desearía que todo lo demás funcionara como esperabas.

---

¡He descubierto cómo hacerlo correctamente! Las etiquetas permanecen horizontal, de manera que pueden ser o no ser una buena cosa, dependiendo de lo que quiera, pero de todos modos:

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:orientation="vertical" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent"> 
    <TabHost android:id="@android:id/tabhost" android:layout_width="match_parent" android:layout_height="match_parent"> 
     <LinearLayout android:id="@+id/linearLayout1" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="horizontal"> 
      <FrameLayout android:layout_width="fill_parent" android:layout_height="match_parent" android:layout_weight="1" android:id="@android:id/tabcontent"></FrameLayout> 
      <ScrollView android:layout_width="wrap_content" 
       android:layout_height="wrap_content" 
       android:fillViewport="true" 
       android:scrollbars="none">   
       <TabWidget android:layout_width="wrap_content" android:layout_height="wrap_content" android:orientation="vertical" android:id="@android:id/tabs"></TabWidget> 
      </ScrollView> 
     </LinearLayout> 
    </TabHost> 

</LinearLayout> 

Este archivo XML define un tabhost vacío con las pestañas de la derecha. Solo agrega las pestañas en tu código; hay publicaciones para eso. Copie/modifique/haga lo que tenga que hacer para que se ajuste a sus necesidades. Además, como es genial, agregué una vista de desplazamiento alrededor del widget de pestañas, por lo que automáticamente permitirá el desplazamiento si tienes demasiadas pestañas. Deshazte de él si no lo quieres. Obtuve el desplazamiento en su mayoría desde http://java.dzone.com/articles/scrolling-tabs-android. ¡Hurra!