Java 如何创建和添加Imagebutton覆盖曲面视图？

我一直在尝试在曲面视图上添加一个Imagebutton，但我不知道如何添加，所以请帮助我，但我会在下面添加我的曲面视图类，很抱歉，它有点大。我正在寻找一种方法来制作一个图像按钮，然后将其显示在曲面视图的顶部

public class GamePanel extends SurfaceView implements SurfaceHolder.Callback {
    private static ImageView imgView;
    public static final int WIDTH = 856;
    public static final int HEIGHT = 480;
    public static final int MOVESPEED = -5;
    private long smokeStartTime;
    private long missileStartTime;
    private MainThread thread;
    private Background bg;
    private Player player;
    private ArrayList<Smokepuff> smoke;
    private ArrayList<Missile> missiles;
    private ArrayList<TopBorder> topborder;
    private ArrayList<BotBorder> botborder;
    private Random rand = new Random();
    private int maxBorderHeight;
    private int minBorderHeight;
    private boolean topDown = true;
    private boolean botDown = true;
    private boolean newGameCreated;
    private Animation animation = new Animation();

    MediaPlayer mSound;
    MediaPlayer mySound;

    public static SharedPreferences prefs;

    private String saveScore = "highScore";

    //increase to slow down difficulty progression, decrease to speed up difficulty progression
    private int progressDenom = 20;

    private Explosion explosion;
    private long startReset;
    private boolean reset;
    private boolean dissapear;
    private boolean started;

    public static Context mContext;

    ImageButton imgButton;

    public GamePanel(Context context) {
        super(context);
        this.mContext = context;

        //add the callback to the surfaceholder to intercept events
        getHolder().addCallback(this);

        //make gamePanel focusable so it can handle events
        setFocusable(true);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        boolean retry = true;
        int counter = 0;
        while (retry && counter < 1000) {
            counter++;
            try {
                thread.setRunning(false);
                thread.join();
                retry = false;
                thread = null;

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        bg = new Background(BitmapFactory.decodeResource(getResources(), R.drawable.grassbg1));
        player = new Player(BitmapFactory.decodeResource(getResources(), R.drawable.helicopter), 65, 25, 3);
        smoke = new ArrayList<Smokepuff>();
        missiles = new ArrayList<Missile>();
        topborder = new ArrayList<TopBorder>();
        botborder = new ArrayList<BotBorder>();
        smokeStartTime = System.nanoTime();
        missileStartTime = System.nanoTime();

        thread = new MainThread(getHolder(), this);
        //we can safely start the game loop
        thread.setRunning(true);
        thread.start();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            if (!player.getPlaying() && newGameCreated && reset) {
                player.setPlaying(true);
                player.setUp(true);
            }
            if (player.getPlaying()) {

                if (!started) started = true;
                reset = false;
                player.setUp(true);
            }
            mSound = MediaPlayer.create(mContext, R.raw.helicoptor);
            mSound.start();

            if (!player.getPlaying() && newGameCreated && reset) {
                mSound.stop();
            }
            return true;
        }
        if (event.getAction() == MotionEvent.ACTION_UP) {
            player.setUp(false);
            return true;
        }
        return super.onTouchEvent(event);
    }

    public void update()
    {
        if (player.getPlaying()) {
            if (botborder.isEmpty()) {
                player.setPlaying(false);
                return;
            }
            if (topborder.isEmpty()) {
                player.setPlaying(false);
                return;
            }

            bg.update();
            player.update();

            //calculate the threshold of height the border can have based on the score
            //max and min border heart are updated, and the border switched direction when either max or
            //min is met

            maxBorderHeight = 30 + player.getScore() / progressDenom;
            //cap max border height so that borders can only take up a total of 1/2 the screen
            if (maxBorderHeight > HEIGHT / 4) maxBorderHeight = HEIGHT / 4;
            minBorderHeight = 5 + player.getScore() / progressDenom;

            //check bottom border collision
            for (int i = 0; i < botborder.size(); i++) {
                if (collision(botborder.get(i), player))
                    player.setPlaying(false);
            }

            //check top border collision
            for (int i = 0; i < topborder.size(); i++) {
                if (collision(topborder.get(i), player))
                    player.setPlaying(false);
            }

            //update top border
            this.updateTopBorder();

            //udpate bottom border
            this.updateBottomBorder();

            //add missiles on timer
            long missileElapsed = (System.nanoTime() - missileStartTime) / 1000000;
            if (missileElapsed > (2000 - player.getScore() / 4)) {
                //first missile always goes down the middle
                if (missiles.size() == 0) {
                    missiles.add(new Missile(BitmapFactory.decodeResource(getResources(), R.drawable.
                            missile), WIDTH + 10, HEIGHT / 2, 45, 15, player.getScore(), 13));
                } else {
                    missiles.add(new Missile(BitmapFactory.decodeResource(getResources(), R.drawable.missile),
                            WIDTH + 10, (int) (rand.nextDouble() * (HEIGHT - (maxBorderHeight * 2)) + maxBorderHeight), 45, 15, player.getScore(), 13));
                }

                //reset timer
                missileStartTime = System.nanoTime();
            }
            //loop through every missile and check collision and remove
            for (int i = 0; i < missiles.size(); i++) {
                //update missile
                missiles.get(i).update();

                if (collision(missiles.get(i), player)) {
                    missiles.remove(i);
                    player.setPlaying(false);
                    mSound = MediaPlayer.create(mContext, R.raw.exploding);
                    mSound.start();

                    if (!player.getPlaying() && newGameCreated && reset) {
                        mSound.stop();
                    }
                    break;
                }
                //remove missile if it is way off the screen
                if (missiles.get(i).getX() < -100) {
                    missiles.remove(i);
                    break;
                }
            }

            //add smoke puffs on timer
            long elapsed = (System.nanoTime() - smokeStartTime) / 1000000;
            if (elapsed > 120) {
                smoke.add(new Smokepuff(player.getX(), player.getY() + 10));
                smokeStartTime = System.nanoTime();
            }

            for (int i = 0; i < smoke.size(); i++) {
                smoke.get(i).update();
                if (smoke.get(i).getX() < -10) {
                    smoke.remove(i);
                }
            }
        } else {
            player.resetDY();
            if (!reset) {
                newGameCreated = false;
                startReset = System.nanoTime();
                reset = true;
                dissapear = true;
                explosion = new Explosion(BitmapFactory.decodeResource(getResources(), R.drawable.explosion), player.getX(),
                        player.getY() - 30, 100, 100, 25);
            }

            explosion.update();
            long resetElapsed = (System.nanoTime() - startReset) / 1000000;

            if (resetElapsed > 2500 && !newGameCreated) {
                newGame();
            }
        }
    }

    public boolean collision(GameObject a, GameObject b) {
        if (Rect.intersects(a.getRectangle(), b.getRectangle())) {
            mSound = MediaPlayer.create(mContext, R.raw.exploding);
            mSound.start();

            if (!player.getPlaying() && newGameCreated && reset) {
                mSound.stop();
            }
            return true;
        }
        return false;
    }

    @SuppressLint("MissingSuperCall")
    @Override
    public void draw(Canvas canvas) {
        final float scaleFactorX = getWidth() / (WIDTH * 1.f);
        final float scaleFactorY = getHeight() / (HEIGHT * 1.f);

        if (canvas != null) {
            final int savedState = canvas.save();
            canvas.scale(scaleFactorX, scaleFactorY);

            bg.draw(canvas);
            if (!dissapear) {
                player.draw(canvas);
            }
            //draw smokepuffs
            for (Smokepuff sp : smoke) {
                sp.draw(canvas);
            }
            //draw missiles
            for (Missile m : missiles) {
                m.draw(canvas);
            }

            //draw topborder
            for (TopBorder tb : topborder) {
                tb.draw(canvas);
            }

            //draw botborder
            for (BotBorder bb : botborder) {
                bb.draw(canvas);
            }
            //draw explosion
            if (started) {
                explosion.draw(canvas);
            }

            drawText(canvas);
            canvas.restoreToCount(savedState);
        }
    }

    public void updateTopBorder() {
        //every 50 points, insert randomly placed top blocks that break the pattern
        if (player.getScore() % 50 == 0) {
            topborder.add(new TopBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick
            ), topborder.get(topborder.size() - 1).getX() + 20, 0, (int) ((rand.nextDouble() * (maxBorderHeight
            )) + 1)));
        }
        for (int i = 0; i < topborder.size(); i++) {
            topborder.get(i).update();
            if (topborder.get(i).getX() < -20) {
                topborder.remove(i);
                //remove element of arraylist, replace it by adding a new one
                //calculate topdown which determines the direction the border is moving (up or down)
                if (topborder.get(topborder.size() - 1).getHeight() >= maxBorderHeight) {
                    topDown = false;
                }
                if (topborder.get(topborder.size() - 1).getHeight() <= minBorderHeight) {
                    topDown = true;
                }
                //new border added will have larger height
                if (topDown) {
                    topborder.add(new TopBorder(BitmapFactory.decodeResource(getResources(),
                            R.drawable.brick), topborder.get(topborder.size() - 1).getX() + 20,
                            0, topborder.get(topborder.size() - 1).getHeight() + 1));
                }
                //new border added wil have smaller height
                else {
                    topborder.add(new TopBorder(BitmapFactory.decodeResource(getResources(),
                            R.drawable.brick), topborder.get(topborder.size() - 1).getX() + 20,
                            0, topborder.get(topborder.size() - 1).getHeight() - 1));
                }
            }
        }
    }

    public void updateBottomBorder() {
        //every 40 points, insert randomly placed bottom blocks that break pattern
        if (player.getScore() % 40 == 0) {
            botborder.add(new BotBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick),
                    botborder.get(botborder.size() - 1).getX() + 20, (int) ((rand.nextDouble()
                    * maxBorderHeight) + (HEIGHT - maxBorderHeight))));
        }

        //update bottom border
        for (int i = 0; i < botborder.size(); i++) {
            botborder.get(i).update();

            //if border is moving off screen, remove it and add a corresponding new one
            if (botborder.get(i).getX() < -20) {
                botborder.remove(i);

                //determine if border will be moving up or down
                if (botborder.get(botborder.size() - 1).getY() <= HEIGHT - maxBorderHeight) {
                    botDown = true;
                }
                if (botborder.get(botborder.size() - 1).getY() >= HEIGHT - minBorderHeight) {
                    botDown = false;
                }

                if (botDown) {
                    botborder.add(new BotBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick
                    ), botborder.get(botborder.size() - 1).getX() + 20, botborder.get(botborder.size() - 1
                    ).getY() + 1));
                } else {
                    botborder.add(new BotBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick
                    ), botborder.get(botborder.size() - 1).getX() + 20, botborder.get(botborder.size() - 1
                    ).getY() - 1));
                }
            }
        }
    }

    public void newGame() {
        dissapear = false;

        botborder.clear();
        topborder.clear();

        missiles.clear();
        smoke.clear();

        minBorderHeight = 5;
        maxBorderHeight = 30;

        player.resetDY();
        player.resetScore();
        player.setY(HEIGHT / 2);

        //create initial borders

        //initial top border
        for (int i = 0; i * 20 < WIDTH + 40; i++) {
            //first top border create
            if (i == 0) {
                topborder.add(new TopBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick
                ), i * 20, 0, 10));
            } else {
                topborder.add(new TopBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick
                ), i * 20, 0, topborder.get(i - 1).getHeight() + 1));
            }
        }
        //initial bottom border
        for (int i = 0; i * 20 < WIDTH + 40; i++) {
            //first border ever created
            if (i == 0) {
                botborder.add(new BotBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick)
                        , i * 20, HEIGHT - minBorderHeight));
            }
            //adding borders until the initial screen is filed
            else {
                botborder.add(new BotBorder(BitmapFactory.decodeResource(getResources(), R.drawable.brick),
                        i * 20, botborder.get(i - 1).getY() - 1));
            }
        }
        newGameCreated = true;
    }

    public void drawText(Canvas canvas) {
        SharedPreferences prefs = mContext.getSharedPreferences("PrefsKeys", Context.MODE_PRIVATE);
        int oldScore = prefs.getInt("highScore", 0);
        int newScore = Player.getScore() * 3;

        //update score only if new score is higher
        if (newScore > oldScore) {
            SharedPreferences.Editor editor = prefs.edit();
            editor.putInt("highScore", newScore);
            editor.commit();
        }

        Paint paint = new Paint();
        paint.setColor(Color.BLACK);
        paint.setTextSize(30);
        paint.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD));
        canvas.drawText("DISTANCE: " + newScore, 10, HEIGHT - 10, paint);
        canvas.drawText("HighScore: " + oldScore, WIDTH - 215, HEIGHT - 10, paint);

        if (!player.getPlaying() && newGameCreated && reset) {
            Paint paint1 = new Paint();
            paint1.setTextSize(40);
            paint1.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD));
            canvas.drawText("PRESS TO START", WIDTH / 2 - 50, HEIGHT / 2, paint1);
            paint1.setTextSize(20);
            canvas.drawText("PRESS AND HOLD TO GO UP", WIDTH / 2 - 50, HEIGHT / 2 + 20, paint1);
            canvas.drawText("RELEASE TO GO DOWN", WIDTH / 2 - 50, HEIGHT / 2 + 40, paint1);
       }
    }
}


public class settingsMenu extends Activity implements View.OnClickListener {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);

        FrameLayout game = new FrameLayout(this);
        GamePanel gameView = new GamePanel (this);

        ImageButton myButton = new ImageButton(this);

        myButton.setId(1);
        myButton.setImageResource(R.drawable.settings);

        RelativeLayout b1 = new RelativeLayout(this);
        RelativeLayout.LayoutParams buttonParams =
                new RelativeLayout.LayoutParams(
                        RelativeLayout.LayoutParams.WRAP_CONTENT,
                        RelativeLayout.LayoutParams.WRAP_CONTENT);

        b1.addView(myButton, buttonParams);

        game.addView(gameView);
        game.addView(b1);

        setContentView(game);
        myButton.setOnClickListener(this);
    }

    public void onClick(View v) {
        Intent intent = new Intent(this, GamePanel.class);
        startActivity(intent);
    }
}

public class GamePanel扩展了SurfaceView实现了SurfaceHolder.Callback{
私有静态图像视图imgView；
公共静态最终整数宽度=856；
公共静态最终内部高度=480；
公共静态最终移动速度=-5；
私人长时间吸烟；
私人长期任务；
私有主线程；
私人背景背景背景；
私人玩家；
私烟；
私人ArrayList导弹；
私有ArrayList topborder；
私人ArrayList botborder；
private Random rand=new Random（）；
私有整数最大边界高度；
私人身高；
私有布尔自上而下=true；
私有布尔botDown=true；
创建私有布尔值；
私有动画=新动画（）；
媒体播放器mSound；
媒体播放器mySound；
公共静态SharedReferences优先级；
私有字符串saveScore=“highScore”；
//增加以减缓难度进展，减少以加快难度进展
私有int progressDenom=20；
私人爆炸；
私人长星台；
私有布尔重置；
私有布尔不相似；
私有布尔启动；
公共静态语境；
图像按钮imgButton；
公共游戏面板（上下文）{
超级（上下文）；
this.mContext=上下文；
//将回调添加到surfaceholder以拦截事件
getHolder（）.addCallback（此）；
//使gamePanel可聚焦，以便处理事件
设置聚焦（真）；
}
@凌驾
公共空白表面更改（表面文件夹持有者、整型格式、整型宽度、整型高度）{
}
@凌驾
公共空间表面覆盖（表面覆盖物持有人）{
布尔重试=真；
int计数器=0；
while（重试&&计数器<1000）{
计数器++；
试一试{
thread.setRunning（false）；
thread.join（）；
重试=错误；
线程=null；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
@凌驾
已创建的公共空白表面（表面持有人）{
bg=新背景（BitmapFactory.decodeResource（getResources（），R.drawable.grassbg1））；
player=newplayer（BitmapFactory.decodeResource（getResources（），R.drawable.helposer），65,25,3）；
smoke=新的ArrayList（）；
导弹=新阵列列表（）；
topborder=新的ArrayList（）；
botborder=新的ArrayList（）；
smokeStartTime=System.nanoTime（）；
missileStartTime=System.nanoTime（）；
线程=新的主线程（getHolder（），this）；
//我们可以安全地开始游戏循环
thread.setRunning（true）；
thread.start（）；
}
@凌驾
公共布尔onTouchEvent（运动事件）{
if（event.getAction（）==MotionEvent.ACTION\u向下）{
如果（！player.getPlaying（）&&newGameCreated&&reset）{
player.setPlaying（true）；
player.setUp（true）；
}
if（player.getPlaying（））{
如果（！started）started=true；
重置=错误；
player.setUp（true）；
}
mSound=MediaPlayer.create（mContext，R.raw.helicoptor）；
mSound.start（）；
如果（！player.getPlaying（）&&newGameCreated&&reset）{
mSound.stop（）；
}
返回true；
}
if（event.getAction（）==MotionEvent.ACTION\u UP）{
player.setUp（false）；
返回true；
}
返回super.onTouchEvent（事件）；
}
公共无效更新（）
{
if（player.getPlaying（））{
if（botborder.isEmpty（））{
player.setPlaying（假）；
返回；
}
if（topborder.isEmpty（））{
player.setPlaying（假）；
返回；
}
bg.update（）；
player.update（）；
//根据分数计算边界可以具有的高度阈值
//“最大”和“最小”边框将更新，并且当“最大”或“最小”时，边框将切换方向
//满足了
maxBorderHeight=30+player.getScore（）/progressDenom；
//限制最大边框高度，使边框仅占屏幕总面积的1/2
如果（maxBorderHeight>HEIGHT/4）maxBorderHeight=HEIGHT/4；
minBorderHeight=5+player.getScore（）/progressDenom；
//检查底部边界碰撞
对于（int i=0；i（2000-player.getScore（）/4））{
//第一枚导弹总是从中间发射
如果（0.size（）==0）{
添加（新导弹）（BitmapFactory.decodeResource）（getResources（），R.drawable）。
导弹），宽度+10，高度/2，45，15，player.getScore（），13）；
}否则{
导弹。添加(
   <FrameLayout 
      xmlns:android="http://schemas.android.com/apk/res/android"
      layout_width="match_parent"
      layout_height="match_parent">

   <yourpackage.GamePanel 
       layout_width="match_parent"
      layout_height="match_parent" />

   <ImageButton
       layout_width="wrap_content"
      layout_height="wrap_content" />

  </FrameLayout>