Flingでjava.lang.NullPointerExceptionでアクティビティーを開始できません

Question

この例では、このエラーが発生しました。 java Nullポインター例外を使用します。 私のJavaコード

public class LearnCount extends Activity { 

private FlingGallery mGallery; 

public boolean onTouchEvent(MotionEvent event) { 
    return mGallery.onGalleryTouchEvent(event); 
} 


private String[] teststr = { 
     "test1","test2","test3","test4","test5" 
     }; 


public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 

    setContentView(R.layout.main); 
    LinearLayout productHolder = (LinearLayout) findViewById(R.id.linearLayoutOfCount); 

    mGallery = new FlingGallery(this); 


     mGallery.setAdapter(new ArrayAdapter<String>(getApplicationContext(), 
      android.R.layout.simple_list_item_1, teststr) { 

     public View getView(int position, View convertView, ViewGroup parent) { 
      System.out.println(mGallery.getCurrentPosition() + " position"); 
      if (convertView != null 
        && convertView instanceof GalleryViewItem) { 
       GalleryViewItem galleryView = (GalleryViewItem) convertView; 

       //galleryView.pImage.setImageResource(mImageIds[position]); 
       galleryView.b.setText(teststr[position]); 
       return galleryView; 
      } 

      GalleryViewItem gvi = new GalleryViewItem(getApplicationContext(), position); 
      gvi.b.setText(teststr[position]); 

      return gvi; 
     } 
    }); 
    productHolder.addView(mGallery); 

} 

public class GalleryViewItem extends TableLayout { 

    private TextView b; 

    public GalleryViewItem(Context context, int position) { 
     super(context); 

     LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
     View v = inflater.inflate(R.layout.test, null); 
     b = (TextView) v.findViewById(R.id.test); 
     this.addView(v); 

    } 
} 

public class FlingGallery extends FrameLayout { 
    // Constants 

    private final int swipe_min_distance = 120; 
    private final int swipe_max_off_path = 250; 
    private final int swipe_threshold_veloicty = 400; 

    // Properties 

    private int mViewPaddingWidth = 0; 
    private int mAnimationDuration = 250; 
    private float mSnapBorderRatio = 0.5f; 
    private boolean mIsGalleryCircular = false; 

    // Members 

    private int mGalleryWidth = 0; 
    private boolean mIsTouched = false; 
    private boolean mIsDragging = false; 
    private float mCurrentOffset = 0.0f; 
    private long mScrollTimestamp = 0; 
    private int mFlingDirection = 0; 
    public int mCurrentPosition = 0; 
    private int mCurrentViewNumber = 0; 

    private Context mContext; 
    private Adapter mAdapter; 
    private FlingGalleryView[] mViews; 
    private FlingGalleryAnimation mAnimation; 
    private GestureDetector mGestureDetector; 
    private Interpolator mDecelerateInterpolater; 

    public FlingGallery(Context context) { 
     super(context); 

     mContext = context; 
     mAdapter = null; 

     mViews = new FlingGalleryView[3]; 
     mViews[0] = new FlingGalleryView(0, this); 
     mViews[1] = new FlingGalleryView(1, this); 
     mViews[2] = new FlingGalleryView(2, this); 

     mAnimation = new FlingGalleryAnimation(); 
     mGestureDetector = new GestureDetector(new FlingGestureDetector()); 
     mDecelerateInterpolater = AnimationUtils.loadInterpolator(mContext, 
       android.R.anim.decelerate_interpolator); 
    } 

    public void setPaddingWidth(int viewPaddingWidth) { 
     mViewPaddingWidth = viewPaddingWidth; 
    } 

    public void setAnimationDuration(int animationDuration) { 
     mAnimationDuration = animationDuration; 
    } 

    public void setSnapBorderRatio(float snapBorderRatio) { 
     mSnapBorderRatio = snapBorderRatio; 
    } 

    public int getCurrentPosition() { 
     return mCurrentPosition; 
    } 

    public void setIsGalleryCircular(boolean isGalleryCircular) { 
     if (mIsGalleryCircular != isGalleryCircular) { 
      mIsGalleryCircular = isGalleryCircular; 

      if (mCurrentPosition == getFirstPosition()) { 
       // We need to reload the view immediately to the left to 
       // change it to circular view or blank 
       mViews[getPrevViewNumber(mCurrentViewNumber)] 
         .recycleView(getPrevPosition(mCurrentPosition)); 
      } 

      if (mCurrentPosition == getLastPosition()) { 
       // We need to reload the view immediately to the right to 
       // change it to circular view or blank 
       mViews[getNextViewNumber(mCurrentViewNumber)] 
         .recycleView(getNextPosition(mCurrentPosition)); 
      } 
     } 
    } 

    public int getGalleryCount() { 
     return (mAdapter == null) ? 0 : mAdapter.getCount(); 
    } 

    public int getFirstPosition() { 
     return 0; 
    } 

    public int getLastPosition() { 
     return (getGalleryCount() == 0) ? 0 : getGalleryCount() - 1; 
    } 

    private int getPrevPosition(int relativePosition) { 
     int prevPosition = relativePosition - 1; 

     if (prevPosition < getFirstPosition()) { 
      prevPosition = getFirstPosition() - 1; 

      if (mIsGalleryCircular == true) { 
       prevPosition = getLastPosition(); 
      } 
     } 

     return prevPosition; 
    } 

    private int getNextPosition(int relativePosition) { 
     int nextPosition = relativePosition + 1; 

     if (nextPosition > getLastPosition()) { 
      nextPosition = getLastPosition() + 1; 

      if (mIsGalleryCircular == true) { 
       nextPosition = getFirstPosition(); 
      } 
     } 

     return nextPosition; 
    } 

    private int getPrevViewNumber(int relativeViewNumber) { 
     return (relativeViewNumber == 0) ? 2 : relativeViewNumber - 1; 
    } 

    private int getNextViewNumber(int relativeViewNumber) { 
     return (relativeViewNumber == 2) ? 0 : relativeViewNumber + 1; 
    } 


    protected void onLayout(boolean changed, int left, int top, int right, 
      int bottom) { 
     super.onLayout(changed, left, top, right, bottom); 

     // Calculate our view width 
     mGalleryWidth = right - left; 

     if (changed == true) { 
      // Position views at correct starting offsets 
      mViews[0].setOffset(0, 0, mCurrentViewNumber); 
      mViews[1].setOffset(0, 0, mCurrentViewNumber); 
      mViews[2].setOffset(0, 0, mCurrentViewNumber); 
     } 
    } 

    public void setAdapter(Adapter adapter) { 
     mAdapter = adapter; 
     mCurrentPosition = 0; 
     mCurrentViewNumber = 0; 

     // Load the initial views from adapter 
     mViews[0].recycleView(mCurrentPosition); 
     mViews[1].recycleView(getNextPosition(mCurrentPosition)); 
     mViews[2].recycleView(getPrevPosition(mCurrentPosition)); 

     // Position views at correct starting offsets 
     mViews[0].setOffset(0, 0, mCurrentViewNumber); 
     mViews[1].setOffset(0, 0, mCurrentViewNumber); 
     mViews[2].setOffset(0, 0, mCurrentViewNumber); 
    } 

    private int getViewOffset(int viewNumber, int relativeViewNumber) { 
     // Determine width including configured padding width 
     int offsetWidth = mGalleryWidth + mViewPaddingWidth; 

     // Position the previous view one measured width to left 
     if (viewNumber == getPrevViewNumber(relativeViewNumber)) { 
      return offsetWidth; 
     } 

     // Position the next view one measured width to the right 
     if (viewNumber == getNextViewNumber(relativeViewNumber)) { 
      return offsetWidth * -1; 
     } 

     return 0; 
    } 

    void movePrevious() { 
     // Slide to previous view 
     mFlingDirection = 1; 
     processGesture(); 
    } 

    void moveNext() { 
     // Slide to next view 
     mFlingDirection = -1; 
     processGesture(); 
    } 


    public boolean onKeyDown(int keyCode, KeyEvent event) { 
     switch (keyCode) { 
     case KeyEvent.KEYCODE_DPAD_LEFT: 
      movePrevious(); 
      return true; 

     case KeyEvent.KEYCODE_DPAD_RIGHT: 
      moveNext(); 
      return true; 

     case KeyEvent.KEYCODE_DPAD_CENTER: 
     case KeyEvent.KEYCODE_ENTER: 
     } 

     return super.onKeyDown(keyCode, event); 
    } 

    public boolean onGalleryTouchEvent(MotionEvent event) { 
     boolean consumed = mGestureDetector.onTouchEvent(event); 

     if (event.getAction() == MotionEvent.ACTION_UP) { 
      if (mIsTouched || mIsDragging) { 
       processScrollSnap(); 
       processGesture(); 
      } 
     } 

     return consumed; 
    } 

    void processGesture() { 
     int newViewNumber = mCurrentViewNumber; 
     int reloadViewNumber = 0; 
     int reloadPosition = 0; 

     mIsTouched = false; 
     mIsDragging = false; 

     if (mFlingDirection > 0) { 
      if (mCurrentPosition > getFirstPosition() 
        || mIsGalleryCircular == true) { 
       // Determine previous view and outgoing view to recycle 
       newViewNumber = getPrevViewNumber(mCurrentViewNumber); 
       mCurrentPosition = getPrevPosition(mCurrentPosition); 
       reloadViewNumber = getNextViewNumber(mCurrentViewNumber); 
       reloadPosition = getPrevPosition(mCurrentPosition); 
      } 
     } 

     if (mFlingDirection < 0) { 
      if (mCurrentPosition < getLastPosition() 
        || mIsGalleryCircular == true) { 
       // Determine the next view and outgoing view to recycle 
       newViewNumber = getNextViewNumber(mCurrentViewNumber); 
       mCurrentPosition = getNextPosition(mCurrentPosition); 
       reloadViewNumber = getPrevViewNumber(mCurrentViewNumber); 
       reloadPosition = getNextPosition(mCurrentPosition); 
      } 
     } 

     if (newViewNumber != mCurrentViewNumber) { 
      mCurrentViewNumber = newViewNumber; 

      // Reload outgoing view from adapter in new position 
      mViews[reloadViewNumber].recycleView(reloadPosition); 
     } 

     // Ensure input focus on the current view 
     mViews[mCurrentViewNumber].requestFocus(); 

     // Run the slide animations for view transitions 
     mAnimation.prepareAnimation(mCurrentViewNumber); 
     this.startAnimation(mAnimation); 

     // Reset fling state 
     mFlingDirection = 0; 
     //checkNextBackButton(mCurrentPosition); 
     System.out.println("positionFiling" + mCurrentPosition); 
    } 

    void processScrollSnap() { 
     // Snap to next view if scrolled passed snap position 
     float rollEdgeWidth = mGalleryWidth * mSnapBorderRatio; 
     int rollOffset = mGalleryWidth - (int) rollEdgeWidth; 
     int currentOffset = mViews[mCurrentViewNumber].getCurrentOffset(); 

     if (currentOffset <= rollOffset * -1) { 
      // Snap to previous view 
      mFlingDirection = 1; 
     } 

     if (currentOffset >= rollOffset) { 
      // Snap to next view 
      mFlingDirection = -1; 
     } 
    } 

    public class FlingGalleryView { 
     private int mViewNumber; 
     private FrameLayout mParentLayout; 

     private FrameLayout mInvalidLayout = null; 
     private LinearLayout mInternalLayout = null; 
     private View mExternalView = null; 

     public FlingGalleryView(int viewNumber, FrameLayout parentLayout) { 
      mViewNumber = viewNumber; 
      mParentLayout = parentLayout; 

      // Invalid layout is used when outside gallery 
      mInvalidLayout = new FrameLayout(mContext); 
      mInvalidLayout.setLayoutParams(new LinearLayout.LayoutParams(
        LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT)); 

      // Internal layout is permanent for duration 
      mInternalLayout = new LinearLayout(mContext); 
      mInternalLayout.setLayoutParams(new LinearLayout.LayoutParams(
        LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT)); 

      mParentLayout.addView(mInternalLayout); 
     } 

     public void recycleView(int newPosition) { 
      if (mExternalView != null) { 
       mInternalLayout.removeView(mExternalView); 
      } 

      if (mAdapter != null) { 
       if (newPosition >= getFirstPosition() 
         && newPosition <= getLastPosition()) { 
        mExternalView = mAdapter.getView(newPosition, 
          mExternalView, mInternalLayout); 
       } else { 
        mExternalView = mInvalidLayout; 
       } 
      } 

      if (mExternalView != null) { 
       mInternalLayout.addView(mExternalView, 
         new LinearLayout.LayoutParams(
           LayoutParams.FILL_PARENT, 
           LayoutParams.FILL_PARENT)); 
      } 
     } 

     public void setOffset(int xOffset, int yOffset, 
       int relativeViewNumber) { 
      // Scroll the target view relative to its own position relative 
      // to currently displayed view 
      mInternalLayout.scrollTo(getViewOffset(mViewNumber, 
        relativeViewNumber) 
        + xOffset, yOffset); 
     } 

     public int getCurrentOffset() { 
      // Return the current scroll position 
      return mInternalLayout.getScrollX(); 
     } 

     public void requestFocus() { 
      mInternalLayout.requestFocus(); 
     } 
    } 

    public class FlingGalleryAnimation extends Animation { 
     private boolean mIsAnimationInProgres; 
     private int mRelativeViewNumber; 
     private int mInitialOffset; 
     private int mTargetOffset; 
     private int mTargetDistance; 

     public FlingGalleryAnimation() { 
      mIsAnimationInProgres = false; 
      mRelativeViewNumber = 0; 
      mInitialOffset = 0; 
      mTargetOffset = 0; 
      mTargetDistance = 0; 
     } 

     public void prepareAnimation(int relativeViewNumber) { 
      // If we are animating relative to a new view 
      if (mRelativeViewNumber != relativeViewNumber) { 
       if (mIsAnimationInProgres == true) { 
        // We only have three views so if requested again to 
        // animate in same direction we must snap 
        int newDirection = (relativeViewNumber == getPrevViewNumber(mRelativeViewNumber)) ? 1 
          : -1; 
        int animDirection = (mTargetDistance < 0) ? 1 : -1; 

        // If animation in same direction 
        if (animDirection == newDirection) { 
         // Ran out of time to animate so snap to the target 
         // offset 
         mViews[0].setOffset(mTargetOffset, 0, 
           mRelativeViewNumber); 
         mViews[1].setOffset(mTargetOffset, 0, 
           mRelativeViewNumber); 
         mViews[2].setOffset(mTargetOffset, 0, 
           mRelativeViewNumber); 
        } 
       } 

       // Set relative view number for animation 
       mRelativeViewNumber = relativeViewNumber; 
      } 

      // Note: In this implementation the targetOffset will always be 
      // zero 
      // as we are centering the view; but we include the calculations 
      // of 
      // targetOffset and targetDistance for use in future 
      // implementations 

      mInitialOffset = mViews[mRelativeViewNumber].getCurrentOffset(); 
      mTargetOffset = getViewOffset(mRelativeViewNumber, 
        mRelativeViewNumber); 
      mTargetDistance = mTargetOffset - mInitialOffset; 

      // Configure base animation properties 
      this.setDuration(mAnimationDuration); 
      this.setInterpolator(mDecelerateInterpolater); 

      // Start/continued animation 
      mIsAnimationInProgres = true; 
     } 


     protected void applyTransformation(float interpolatedTime, 
       Transformation transformation) { 
      // Ensure interpolatedTime does not over-shoot then calculate 
      // new offset 
      interpolatedTime = (interpolatedTime > 1.0f) ? 1.0f 
        : interpolatedTime; 
      int offset = mInitialOffset 
        + (int) (mTargetDistance * interpolatedTime); 

      for (int viewNumber = 0; viewNumber < 3; viewNumber++) { 
       // Only need to animate the visible views as the other view 
       // will always be off-screen 
       if ((mTargetDistance > 0 && viewNumber != getNextViewNumber(mRelativeViewNumber)) 
         || (mTargetDistance < 0 && viewNumber != getPrevViewNumber(mRelativeViewNumber))) { 
        mViews[viewNumber].setOffset(offset, 0, 
          mRelativeViewNumber); 
       } 
      } 
     } 


     public boolean getTransformation(long currentTime, 
       Transformation outTransformation) { 
      if (super.getTransformation(currentTime, outTransformation) == false) { 
       // Perform final adjustment to offsets to cleanup animation 
       mViews[0].setOffset(mTargetOffset, 0, mRelativeViewNumber); 
       mViews[1].setOffset(mTargetOffset, 0, mRelativeViewNumber); 
       mViews[2].setOffset(mTargetOffset, 0, mRelativeViewNumber); 

       // Reached the animation target 
       mIsAnimationInProgres = false; 

       return false; 
      } 

      // Cancel if the screen touched 
      if (mIsTouched || mIsDragging) { 
       // Note that at this point we still consider ourselves to be 
       // animating 
       // because we have not yet reached the target offset; its 
       // just that the 
       // user has temporarily interrupted the animation with a 
       // touch gesture 

       return false; 
      } 

      return true; 
     } 
    } 

    private class FlingGestureDetector extends GestureDetector.SimpleOnGestureListener { 

     public boolean onDown(MotionEvent e) { 
      // Stop animation 
      mIsTouched = true; 

      // Reset fling state 
      mFlingDirection = 0; 
      return true; 
     } 


     public boolean onScroll(MotionEvent e1, MotionEvent e2, 
       float distanceX, float distanceY) { 
      if (e2.getAction() == MotionEvent.ACTION_MOVE) { 
       if (mIsDragging == false) { 
        // Stop animation 
        mIsTouched = true; 

        // Reconfigure scroll 
        mIsDragging = true; 
        mFlingDirection = 0; 
        mScrollTimestamp = System.currentTimeMillis(); 
        mCurrentOffset = mViews[mCurrentViewNumber] 
          .getCurrentOffset(); 
       } 

       float maxVelocity = mGalleryWidth 
         /(mAnimationDuration/1000.0f); 
       long timestampDelta = System.currentTimeMillis() 
         - mScrollTimestamp; 
       float maxScrollDelta = maxVelocity 
         * (timestampDelta/1000.0f); 
       float currentScrollDelta = e1.getX() - e2.getX(); 

       if (currentScrollDelta < maxScrollDelta * -1) 
        currentScrollDelta = maxScrollDelta * -1; 
       if (currentScrollDelta > maxScrollDelta) 
        currentScrollDelta = maxScrollDelta; 
       int scrollOffset = Math.round(mCurrentOffset 
         + currentScrollDelta); 

       // We can't scroll more than the width of our own frame 
       // layout 
       if (scrollOffset >= mGalleryWidth) 
        scrollOffset = mGalleryWidth; 
       if (scrollOffset <= mGalleryWidth * -1) 
        scrollOffset = mGalleryWidth * -1; 

       mViews[0].setOffset(scrollOffset, 0, mCurrentViewNumber); 
       mViews[1].setOffset(scrollOffset, 0, mCurrentViewNumber); 
       mViews[2].setOffset(scrollOffset, 0, mCurrentViewNumber); 
      } 

      return false; 
     } 


     public boolean onFling(MotionEvent e1, MotionEvent e2, 
       float velocityX, float velocityY) { 
      if (Math.abs(e1.getY() - e2.getY()) <= swipe_max_off_path) { 
       if (e2.getX() - e1.getX() > swipe_min_distance 
         && Math.abs(velocityX) > swipe_threshold_veloicty) { 
        movePrevious(); 
       } 

       if (e1.getX() - e2.getX() > swipe_min_distance 
         && Math.abs(velocityX) > swipe_threshold_veloicty) { 
        moveNext(); 
       } 
      } 

      return false; 
     } 


     public void onLongPress(MotionEvent e) { 
      // Finalise scrolling 
      mFlingDirection = 0; 
      processGesture(); 
     } 


     public void onShowPress(MotionEvent e) { 
     } 


     public boolean onSingleTapUp(MotionEvent e) { 
      // Reset fling state 
      mFlingDirection = 0; 
      return false; 
     } 
    } 
} 

}

マイログ猫のエラーメッセージは次のとおりです。

私はアンドロイド、何か間違って私のコードのための初心者ですか？

Answer 1

LinearLayout productHolder = (LinearLayout) findViewById(R.id.linearLayoutOfCount); 

nullが返されます。正しいIDを参照していることを確認してください。