13

2 つのタブを含む EditText と TabHost のレイアウトがあります。アンドロイド 1.6。

以下のケースではハードウェアキーボードを使用しています。再現する手順:

  1. アクティビティが表示されると、EditText がフォーカスされます。

  2. 任意のキーを押すとすぐに、EditText がフォーカスを失い、最初のタブが取得されます。

  3. EditText をもう一度クリックして、入力を開始します。

  4. 数字ボタンを押さない限り機能します。最初のタブが再びフォーカスされます。

  5. トラック ボールで EditText に戻ります。何でも入力できるようになりました。

手順 2 と 3 で、フォーカスされた EditText で左右にトラック ボールを使用すると、EditText のフォーカスが失われます。

これは非常に奇妙です。これをどう扱うか?

main.xml レイアウト:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent"
    android:orientation="vertical">

    <EditText android:id="@+id/textfield" android:layout_width="fill_parent"
        android:layout_height="wrap_content" android:maxLines="1"
        android:lines="1" android:hint="Search" />

    <TabHost android:id="@android:id/tabhost" android:layout_width="fill_parent"
        android:layout_height="wrap_content" android:layout_weight="1">

        <LinearLayout android:orientation="vertical"
            android:layout_width="fill_parent" android:layout_height="fill_parent">


            <FrameLayout android:id="@android:id/tabcontent"
                android:layout_width="fill_parent" android:layout_height="wrap_content"
                android:layout_weight="1">

                <LinearLayout android:id="@+id/tab1"
                    android:layout_width="fill_parent" android:layout_height="wrap_content" />

                <LinearLayout android:id="@+id/tab2"
                    android:layout_width="fill_parent" android:layout_height="wrap_content" />

            </FrameLayout>

            <TabWidget android:id="@android:id/tabs"
                android:orientation="vertical" android:layout_width="fill_parent"
                android:layout_height="wrap_content" android:gravity="bottom" />

        </LinearLayout>

    </TabHost>

</LinearLayout>

活動クラス:

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    TabHost tabs = (TabHost) this.findViewById(android.R.id.tabhost);
    tabs.setup();

    Button vBtn;

    TabSpec tspec1 = tabs.newTabSpec("label one");
    vBtn = new Button(this);
    vBtn.setText("1");
    tspec1.setIndicator(vBtn);
    tspec1.setContent(R.id.tab1);

    TabSpec tspec2 = tabs.newTabSpec("label two");
    vBtn = new Button(this);
    vBtn.setText("2");
    tspec2.setIndicator(vBtn);
    tspec2.setContent(R.id.tab1);

    tabs.addTab(tspec1);
    tabs.addTab(tspec2);
  }
4

2 に答える 2

8

Android ソースを詳しく調べたところ、バグが見つかりました。タッチ モードを終了するとき (つまり、誰かがキーを押したとき) にTabHostOnTouchModeChangeListener を登録すると、フォーカスが奪われます。onAttachedToWindow()

src/info/staticfree/workarounds/TabPatchView.javaこれを配置して、タブを使用するレイアウトにこのビューを追加するだけです。詳細については、以下の Javadoc を参照してください。

package info.staticfree.workarounds;

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.TabHost;

/**
 * <p>
 * This is a workaround for a bug in Android in which using tabs such that all the content of the
 * layout isn't in the tabs causes the TabHost to steal focus from any views outside the tab
 * content. This is most commonly found with EditTexts.
 * </p>
 * <p>
 * To use, simply place this view in your @android:id/tablayout frameview:
 * </p>
 * 
 * <pre>
 * <code>
 *             &lt;FrameLayout
 *                 android:id="@android:id/tabcontent"
 *                 android:layout_width="match_parent"
 *                 android:layout_height="match_parent" >
 * 
 *                 &lt;info.staticfree.workarounds.TabPatchView
 *                     android:layout_width="0dip"
 *                     android:layout_height="0dip" />
 *                     
 *                     [your actual content goes here]
 *                     &lt;/FrameLayout>
 * 
 * </pre>
 * 
 * </code>
 * 
 * @author <a href="mailto:steve@staticfree.info">Steve Pomeroy</a>
 * @see <a href="http://code.google.com/p/android/issues/detail?id=2516">issue 2516</a>
 */
public class TabPatchView extends View {

    public TabPatchView(Context context) {
        super(context);
    }

    public TabPatchView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public TabPatchView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        final TabHost tabhost = (TabHost) getRootView().findViewById(android.R.id.tabhost);
        tabhost.getViewTreeObserver().removeOnTouchModeChangeListener(tabhost);
    }
}

SDK 12+ をターゲットにしている場合は、OnAttachStateChangeListener代わりに使用できます。にonCreate()、次を追加します。

TabHost mTabHost = (TabHost) findViewById(android.R.id.tabhost);
mTabHost.addOnAttachStateChangeListener(new OnAttachStateChangeListener() {

    @Override
    public void onViewDetachedFromWindow(View v) {}

    @Override
    public void onViewAttachedToWindow(View v) {
        mTabHost.getViewTreeObserver().removeOnTouchModeChangeListener(mTabHost);
    }
});

以上です!

于 2012-10-04T14:18:27.583 に答える
1

タブをセットアップするために、XML レイアウト ファイルで TabHost と Tabwidget を使用したくありません。

TabActivity を拡張するクラスのコードを使用してすべてを行い、各タブについて、その特定のタブの UI レイアウトを処理する独自の XML レイアウト ファイルにアクティビティを関連付けただけです。

これは TabActivity クラスであり、TAB ラベルの外観を処理する background_selectors XML の例でもあります。

    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

first_tab_background_selectors XML ファイルは次のとおりです。

?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>

selected_tab_icon と unselected_tab_icons は .PNG 画像ファイルであり、Android デベロッパー ガイドで指示されているサイズ、解像度、その他のグラフィック ガイドラインに従っています。

于 2011-11-18T17:50:44.003 に答える