Android Menu personnalisé de diapositives

Question

J'ai créé mon menu personnalisé. J'ai utilisé FrameLayout pour afficher mon menu personnalisé. J'ai un problème. Dans une petite division mon menu de diapos fonctionne parfaitement, mais dans un grand fragment de périphérique ne fonctionne pas. Je ne peux pas montrer les composants des fragments (par exemple les boutons, etc.). Voici mon code:

<com.android.slidingmenuexample.MainLayout xmlns:android="http://schemas.android.com/apk/res/android" 
android:layout_width="match_parent" 
android:layout_height="match_parent" > 

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="fill_parent" 
    android:layout_height="fill_parent" 
    android:background="@drawable/geo" 
    android:orientation="vertical" > 

    <ImageView 
     android:id="@+id/imageView1" 
     android:layout_width="match_parent" 
     android:layout_height="50dp" 
     android:background="@drawable/geocell" /> 

    <ListView 
     android:id="@+id/menu_listview" 
     android:layout_width="match_parent" 
     android:layout_height="wrap_content" > 
    </ListView> 
</LinearLayout> 

<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" 
    android:orientation="vertical" > 

    <LinearLayout 
     android:layout_width="match_parent" 
     android:layout_height="50dp" 
     android:background="@drawable/header" 
     android:orientation="horizontal" > 

     <Button 
      android:id="@+id/button_menu" 
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content" 
      android:background="@drawable/menumm" 
      android:onClick="toggleMenu" /> 
    </LinearLayout> 

    <FrameLayout 
     android:id="@+id/activity_main_content_fragment" 
     android:layout_width="match_parent" 
     android:layout_height="match_parent" > 
    </FrameLayout> 
</LinearLayout> 

public class MainLayout extends LinearLayout { 

private static final int SLIDING_DURATION = 500; 
private static final int QUERY_INTERVAL = 16; 
int mainLayoutWidth; 
private View menu; 
private View content; 
private static int menuRightMargin = 45; 

private enum MenuState { 
    HIDING, HIDDEN, SHOWING, SHOWN, 
}; 

private int contentXOffset; 
private MenuState currentMenuState = MenuState.HIDDEN; 
private Scroller menuScroller = new Scroller(this.getContext(), 
     new EaseInInterpolator()); 
private Runnable menuRunnable = new MenuRunnable(); 
private Handler menuHandler = new Handler(); 
int prevX = 0; 
boolean isDragging = false; 
int lastDiffX = 0; 

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

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

@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 

    mainLayoutWidth = MeasureSpec.getSize(widthMeasureSpec); 
    menuRightMargin = mainLayoutWidth * 50/100; 
} 

@Override 
protected void onAttachedToWindow() { 
    super.onAttachedToWindow(); 

    menu = this.getChildAt(0); 
    content = this.getChildAt(1); 
    content.setOnTouchListener(new OnTouchListener() { 
     @Override 
     public boolean onTouch(View v, MotionEvent event) { 
      return MainLayout.this.onContentTouch(v, event); 
     } 
    }); 
    menu.setVisibility(View.GONE); 
} 

@Override 
protected void onLayout(boolean changed, int left, int top, int right, 
     int bottom) { 
    if (changed) { 
     LayoutParams contentLayoutParams = (LayoutParams) content 
       .getLayoutParams(); 
     contentLayoutParams.height = this.getHeight(); 
     contentLayoutParams.width = this.getWidth(); 
     LayoutParams menuLayoutParams = (LayoutParams) menu 
       .getLayoutParams(); 
     menuLayoutParams.height = this.getHeight(); 
     menuLayoutParams.width = this.getWidth() - menuRightMargin; 
    } 
    menu.layout(left, top, right - menuRightMargin, bottom); 
    content.layout(left + contentXOffset, top, right + contentXOffset, 
      bottom); 

} 

public void toggleMenu() { 

    if (currentMenuState == MenuState.HIDING 
      || currentMenuState == MenuState.SHOWING) 
     return; 

    switch (currentMenuState) { 
    case HIDDEN: 
     currentMenuState = MenuState.SHOWING; 
     menu.setVisibility(View.VISIBLE); 
     menuScroller.startScroll(0, 0, menu.getLayoutParams().width, 0, 
       SLIDING_DURATION); 
     break; 
    case SHOWN: 
     currentMenuState = MenuState.HIDING; 
     menuScroller.startScroll(contentXOffset, 0, -contentXOffset, 0, 
       SLIDING_DURATION); 
     break; 
    default: 
     break; 
    } 
    menuHandler.postDelayed(menuRunnable, QUERY_INTERVAL); 
    this.invalidate(); 
} 

protected class MenuRunnable implements Runnable { 
    @Override 
    public void run() { 
     boolean isScrolling = menuScroller.computeScrollOffset(); 
     adjustContentPosition(isScrolling); 
    } 
} 

private void adjustContentPosition(boolean isScrolling) { 
    int scrollerXOffset = menuScroller.getCurrX(); 

    content.offsetLeftAndRight(scrollerXOffset - contentXOffset); 

    contentXOffset = scrollerXOffset; 
    this.invalidate(); 
    if (isScrolling) 
     menuHandler.postDelayed(menuRunnable, QUERY_INTERVAL); 
    else 
     this.onMenuSlidingComplete(); 
} 

private void onMenuSlidingComplete() { 
    switch (currentMenuState) { 
    case SHOWING: 
     currentMenuState = MenuState.SHOWN; 
     break; 
    case HIDING: 
     currentMenuState = MenuState.HIDDEN; 
     menu.setVisibility(View.GONE); 
     break; 
    default: 
     return; 
    } 
} 

protected class EaseInInterpolator implements Interpolator { 
    @Override 
    public float getInterpolation(float t) { 
     return (float) Math.pow(t - 1, 5) + 1; 
    } 

} 

public boolean isMenuShown() { 
    return currentMenuState == MenuState.SHOWN; 
} 

public boolean onContentTouch(View v, MotionEvent event) { 
    if (currentMenuState == MenuState.HIDING 
      || currentMenuState == MenuState.SHOWING) 
     return false; 
    int curX = (int) event.getRawX(); 
    int diffX = 0; 

    switch (event.getAction()) { 
    case MotionEvent.ACTION_DOWN: 

     prevX = curX; 
     return true; 

    case MotionEvent.ACTION_MOVE: 
     if (!isDragging) { 
      isDragging = true; 
      menu.setVisibility(View.VISIBLE); 
     } 
     diffX = curX - prevX; 
     if (contentXOffset + diffX <= 0) { 
      diffX = -contentXOffset; 
     } else if (contentXOffset + diffX > mainLayoutWidth 
       - menuRightMargin) { 
      diffX = mainLayoutWidth - menuRightMargin - contentXOffset; 
     } 
     content.offsetLeftAndRight(diffX); 
     contentXOffset += diffX; 
     this.invalidate(); 

     prevX = curX; 
     lastDiffX = diffX; 
     return true; 

    case MotionEvent.ACTION_UP: 
     Log.d("MainLayout.java onContentTouch()", "Up lastDiffX " 
       + lastDiffX); 

     if (lastDiffX > 0) { 
      currentMenuState = MenuState.SHOWING; 
      menuScroller.startScroll(contentXOffset, 0, 
        menu.getLayoutParams().width - contentXOffset, 0, 
        SLIDING_DURATION); 
     } else if (lastDiffX < 0) { 
      currentMenuState = MenuState.HIDING; 
      menuScroller.startScroll(contentXOffset, 0, -contentXOffset, 0, 
        SLIDING_DURATION); 
     } 
     menuHandler.postDelayed(menuRunnable, QUERY_INTERVAL); 
     this.invalidate(); 
     isDragging = false; 
     prevX = 0; 
     lastDiffX = 0; 
     return true; 

    default: 
     break; 
    } 

    return false; 
} 

}

Et MainActivity classe java

ublic class MainActivity extends FragmentActivity { 

MainLayout mLayout; 

ProgressDialog dialog; 
Button btMenu; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    requestWindowFeature(Window.FEATURE_NO_TITLE); 
    mLayout = (MainLayout) this.getLayoutInflater().inflate(
      R.layout.activity_main, null); 
    setContentView(mLayout); 
    dialog = ProgressDialog.show(this, "Please Wait... ", "Loading... "); 
    dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); 
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); 


    btMenu = (Button) findViewById(R.id.button_menu); 
    btMenu.setOnClickListener(new OnClickListener() { 
     @Override 
     public void onClick(View v) { 
      // Show/hide the menu 
      toggleMenu(v); 
     } 
    }); 

    Handler handler = new Handler(); 
    handler.postDelayed(new Runnable() { 
     public void run() { 

      FragmentManager fm = MainActivity.this 
        .getSupportFragmentManager(); 
      FragmentTransaction ft = fm.beginTransaction(); 
      Layout1 fragment = new Layout1(); 
      ft.add(R.id.activity_main_content_fragment, fragment); 
      ft.commit(); 

      if (dialog != null) { 
       dialog.dismiss(); 

      } 
     } 

    }, 10000); 

} 

public void toggleMenu(View v) { 
    mLayout.toggleMenu(); 
} 



@Override 
public void onBackPressed() { 
    if (mLayout.isMenuShown()) { 
     mLayout.toggleMenu(); 
    } else { 
     super.onBackPressed(); 
    } 
} 

} J'ai un problème que grande résolution d'écran. Dans un programme de résolution d'écran petit et moyen fonctionne parfaitement. si je touche le layot ​​dans un grand écran puis fonctionne parfaitement, mais si je clique sur le bouton, vous appelez la fonction toggleMenu alors ne fonctionne pas. dans mon problème d'option est la fonction toggleMenu, mais je ne sais pas ce qui ne va pas

Answer 1

Vous devez maintenir différents dossiers pour soutenir plusieurs écrans dans Android. Voici une liste de répertoires de ressources dans une application qui fournit différentes conceptions de disposition pour différentes tailles d'écran et différents affichages bitmap pour les écrans de densité moyenne, haute et très haute densité.

res/layout/my_layout.xml    // layout for normal screen size ("default") 
res/layout-small/my_layout.xml  // layout for small screen size 
res/layout-large/my_layout.xml  // layout for large screen size 
res/layout-xlarge/my_layout.xml  // layout for extra large screen size 
res/layout-xlarge-land/my_layout.xml // layout for extra large in landscape orientation 

res/drawable-mdpi/my_icon.png  // bitmap for medium density 
res/drawable-hdpi/my_icon.png  // bitmap for high density 
res/drawable-xhdpi/my_icon.png  // bitmap for extra high density 

Pour plus d'informations se réfèrent ce link