android - onResume 之后的 Activity "freezed"

Question

我正在我的游戏中实现 AdMob，但存在一个问题:关闭 rewarderAd 视频后，游戏不响应触摸，也不记录任何内容。

我在 Web 上进行了搜索，找到了在广告回调中插入 gameView.requestFocus(); 的建议，但它不起作用。

MyGdxGame.java(核心):

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputProcessor;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.TextureAtlas;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.attributes.BlendingAttribute;
import com.badlogic.gdx.graphics.g3d.attributes.FloatAttribute;
import com.badlogic.gdx.graphics.g3d.attributes.TextureAttribute;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.scenes.scene2d.ui.Label;
import com.badlogic.gdx.utils.Align;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.Pool;
import com.badlogic.gdx.utils.viewport.FitViewport;
import com.badlogic.gdx.utils.viewport.Viewport;

public class MyGdxGame extends ApplicationAdapter implements InputProcessor {
    public final static float CARD_WIDTH = 1f;
    public final static float CARD_RATIO_W_H = 277f / 200f;
    public final static float CARD_HEIGHT = CARD_WIDTH * CARD_RATIO_W_H;
    public final static float MINIMUM_VIEWPORT_SIZE = 7f;

    float widthPixel;
    float heightPixel;
    float widthPixel1Card;
    float heightPixel1Card;

    CardBatch cards;
    CardActions actions;
    
    Vector3 vector3touch;

    Stage stage;
    Label labelStart;

    ModelBatch modelBatch;
    TextureAtlas atlas;
    ShapeRenderer shapeRenderer;
    OrthographicCamera cam;
    private Viewport viewport;

    private IActivityRequestHandler myRequestHandler;
    public MyGdxGame(IActivityRequestHandler handler) {
        myRequestHandler = handler;
    }

    @Override
    public void create () {
        widthPixel =  Gdx.graphics.getWidth();
        heightPixel =  Gdx.graphics.getHeight();
        widthPixel1Card = widthPixel / MINIMUM_VIEWPORT_SIZE;
        heightPixel1Card = widthPixel1Card * CARD_RATIO_W_H;

        shapeRenderer = new ShapeRenderer();

        modelBatch = new ModelBatch();
        atlas = new TextureAtlas("carddeck.atlas");
        Material material = new Material(
                TextureAttribute.createDiffuse(atlas.getTextures().first()),
                new BlendingAttribute(false, 1f),
                FloatAttribute.createAlphaTest(0.2f));
        cards = new CardBatch(material);

        cam = new OrthographicCamera(MINIMUM_VIEWPORT_SIZE, MINIMUM_VIEWPORT_SIZE * CARD_RATIO_W_H);
        viewport = new FitViewport(MINIMUM_VIEWPORT_SIZE, MINIMUM_VIEWPORT_SIZE * CARD_RATIO_W_H, cam);

        Gdx.input.setInputProcessor(this);

        actions = new CardActions();

        vector3touch = new Vector3();

        stage = new Stage(new FitViewport(Gdx.graphics.getWidth(), Gdx.graphics.getWidth() * CARD_RATIO_W_H));

        Texture texture = new Texture(Gdx.files.internal("arial32.png"), true); // true enables mipmaps
        texture.setFilter(Texture.TextureFilter.MipMapLinearNearest, Texture.TextureFilter.Linear); // linear filtering in nearest mipmap image
        BitmapFont fontDistanceField = new BitmapFont(Gdx.files.internal("arial32.fnt"), new TextureRegion(texture), false);
        Label.LabelStyle labelStyleDistanceField = new Label.LabelStyle();
        labelStyleDistanceField.font = fontDistanceField;

        labelStart = new Label("Touch to start", labelStyleDistanceField);
        labelStart.setSize(widthPixel/2, heightPixel1Card);
        labelStart.setPosition(widthPixel/2-widthPixel1Card*1.5f, (heightPixel/2f)-heightPixel1Card);
        labelStart.setAlignment(Align.left);
        labelStart.setWrap(false);
        labelStart.setColor(Color.BLACK);
        stage.addActor(labelStart);
    }

    @Override
    public void render() {
        final float delta = Math.min(1/30f, Gdx.graphics.getDeltaTime());

        Gdx.gl.glClearColor(167/255f, 219/255f, 216/255f, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);

        drawCoordsDebug();

        actions.update(delta);

        modelBatch.begin(cam);
        modelBatch.render(cards);
        modelBatch.end();

        stage.act(Math.min(Gdx.graphics.getDeltaTime(), 1 / 30f));
        stage.draw();
    }

    public static class CardActions {
        Pool<CardAction> actionPool = new Pool<CardAction>() {
            protected CardAction newObject() {
                return new CardAction(CardActions.this);
            }
        };
        Array<CardAction> actions = new Array<>();

        public void actionComplete(CardAction action) {
            action.card.inMovimento = false;
            actions.removeValue(action, true);
            actionPool.free(action);
        }

        public void update(float delta) {
            for (CardAction action : actions) {
                action.update(delta);
            }
        }

        // ...
    }

    public static class CardAction {
        public CardActions parent;
        public Card card;
        public final Vector3 fromPosition = new Vector3();
        public float fromAngle;
        public final Vector3 toPosition = new Vector3();
        public float toAngle;
        public float speed;
        public float alpha;

        public CardAction(CardActions parent) {
            this.parent = parent;
        }

        public void update(float delta) {
            alpha += delta * speed;
            if (alpha >= 1f) {
                alpha = 1f;
                parent.actionComplete(this);
            }
            card.position.set(fromPosition).lerp(toPosition, alpha);
            card.angle = fromAngle + alpha * (toAngle - fromAngle);
            card.update();
        }
    }

    @Override
    public void resize(int width, int height) {
        cam.position.set(0, 0, 10);
        cam.lookAt(0, 0, 0);

        cam.update();

        viewport.update(width, height);

        stage.getViewport().update(width, height);
    }

    @Override
    public boolean keyDown(int keycode) {return false; }
    @Override
    public boolean keyUp(int keycode) {return false; }
    @Override
    public boolean keyTyped(char character) {return false; }
    @Override
    public boolean touchDown(int screenX, int screenY, int pointer, int button) {return false; }
    @Override
    public boolean touchUp(int screenX, int screenY, int pointer, int button) {
        Gdx.app.log("touchUp", "");

        // handle it

        return true;
    }

    @Override
    public boolean touchDragged(int screenX, int screenY, int pointer) {return false; }
    @Override
    public boolean mouseMoved(int screenX, int screenY) {return false; }
    @Override
    public boolean scrolled(int amount) {return false; }

    public void drawCoordsDebug() {
        shapeRenderer.setProjectionMatrix(cam.combined);
        shapeRenderer.begin(ShapeRenderer.ShapeType.Line);
        shapeRenderer.setColor(Color.WHITE);
        float wTot = Gdx.graphics.getWidth();
        float hTot = Gdx.graphics.getHeight();
        shapeRenderer.circle(0, 0, 1f);
        for(float w = 0; w >= -wTot; w--) {
            shapeRenderer.line(new Vector2(w,-hTot), new Vector2(w,hTot));
        }
        for(float w = 0; w <= wTot; w++) {
            shapeRenderer.line(new Vector2(w,-hTot), new Vector2(w,hTot));
        }
        for(float h = 0; h >= -hTot; h--) {
            shapeRenderer.line(new Vector2(-wTot, h), new Vector2(wTot, h));
        }
        for(float h = 0; h <= hTot; h++) {
            shapeRenderer.line(new Vector2(-wTot, h), new Vector2(wTot, h));
        }
        shapeRenderer.end();
    }

    @Override
    public void dispose () {
        modelBatch.dispose();
        atlas.dispose();
        cards.dispose();

        shapeRenderer.dispose();

        stage.dispose();
    }
}

DesktopLauncher.java:

public class DesktopLauncher implements IActivityRequestHandler {
    private static DesktopLauncher application;
    public static void main (String[] arg) {
        LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();

        if (application == null) {
            application = new DesktopLauncher();
        }
        new LwjglApplication(new MyGdxGame(application), config);
    }

    @Override
    public void showAds(boolean show) {    
    }
}

AndroidLauncher.java:

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.provider.Settings;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.RelativeLayout;

import com.badlogic.gdx.backends.android.AndroidApplication;
import com.google.android.gms.ads.AdListener;
import com.google.android.gms.ads.AdRequest;
import com.google.android.gms.ads.AdSize;
import com.google.android.gms.ads.AdView;
import com.google.android.gms.ads.MobileAds;
import com.google.android.gms.ads.RequestConfiguration;

import java.io.UnsupportedEncodingException;
import java.security.NoSuchAlgorithmException;
import java.util.LinkedList;
import java.util.List;

public class AndroidLauncher extends AndroidApplication implements IActivityRequestHandler {

    private final int SHOW_ADS = 1;
    private final int HIDE_ADS = 0;

    protected AdView mAdView;
    
    @Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        MobileAds.initialize(this, initializationStatus -> { });
        
        // Create and setup the AdMob view
        mAdView = new AdView(this);
        mAdView.setAdSize(AdSize.BANNER);
        mAdView.setAdUnitId("");
        AdRequest adRequest = new AdRequest.Builder().build();
        mAdView.loadAd(adRequest);
        
        // Create the layout
        RelativeLayout layout = new RelativeLayout(this);

        // Do the stuff that initialize() would do for you
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);

        // Add the libGDX view
        View gameView = initializeForView(new MyGdxGame(this));
        layout.addView(gameView);

        // Add the AdMob view
        RelativeLayout.LayoutParams adParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, RelativeLayout.LayoutParams.WRAP_CONTENT);
        adParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM);
        adParams.addRule(RelativeLayout.CENTER_HORIZONTAL);
        layout.addView(mAdView, adParams);
        layout.setKeepScreenOn(true);

        setContentView(layout);
    }
    
    protected Handler handler = new Handler()
    {
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what) {
                case SHOW_ADS:
                {
                    Activity activityContext = AndroidLauncher.this;
                    if (rewardedAd.isLoaded()) {
                        RewardedAdCallback adCallback = new RewardedAdCallback() {
                            @Override
                            public void onRewardedAdOpened() {
                                // Ad opened.
                            }
    
                            @Override
                            public void onRewardedAdClosed() {
                                // Ad closed.
                                rewardedAd = createAndLoadRewardedAd();
    
                                gameView.requestFocus();
                            }
    
                            @SuppressLint("ApplySharedPref")
                            @Override
                            public void onUserEarnedReward(@NonNull RewardItem reward) {
                                gameView.requestFocus();
                            }
    
                            @Override
                            public void onRewardedAdFailedToShow(int errorCode) {
                                // Ad failed to display.
                            }
                        };
                        rewardedAd.show(activityContext, adCallback);
                    } else {
                        if (mInterstitialAd.isLoaded()) {
                            mInterstitialAd.show();
                        }
                    }
                    break;
                }
                case HIDE_ADS:
                {
                    mAdView.setVisibility(View.GONE);
                    break;
                }
            }
        }
    };

    // This is the callback that posts a message for the handler
    @Override
    public void showAds(boolean show) {
        handler.sendEmptyMessage(show ? SHOW_ADS : HIDE_ADS);
    }



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

        gameView.requestFocus();
    }
}

touchUp 方法也不会在日志中打印任何内容。

几次尝试:

将 gameView.requestFocus(); 替换为:

runOnUiThread(new Runnable() {
        @Override
        public void run() {
            gameView.requestFocus();
    }
});

奇怪的是它发生在 Android 10 上，而在 Android 6.0 上即使没有这些代码行也能正常工作。

注意:我知道只有当用户想要查看它以获得奖励时才必须使用 rewardedAd，在这里我用它来测试流程，然后再继续在游戏。

谢谢!

Answer 1

According to the documentation您应该在主线程上运行所有操作。 当您展示您的广告时，您正在从未在主线程上运行的 new Handler() 调用您的代码，要解决此问题，您需要通过更改以下内容在主线程上运行此处理程序行

protected Handler handler = new Handler()

到

protected Handler handler = new Handler(Looper.getMainLooper())