Android启动无黑屏

最新推荐文章于 2024-06-27 16:49:08 发布
最新推荐文章于 2024-06-27 16:49:08 发布
阅读量4.1k 收藏 2
点赞数
分类专栏： cocos2d-x Android应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MyArrow/article/details/40785601
版权

1. 简介

    Android启动无黑屏是通过设置Window透明来实现的。主要是通过定义启动Activity的android:theme来实现的，但android:theme的定义是有要求的。

    本方法可以实现以下两项要求：

    1）启动无黑屏

    2）启动画面全屏显示

2. 实现方案

    res下目录结构：


2.1 AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="cn.xxx.gaoxueya"
      android:versionCode="1"
      android:versionName="1.0"
      android:installLocation="auto">

    <uses-sdk android:minSdkVersion="9"/>
    <uses-feature android:glEsVersion="0x00020000" />

    <application android:label="@string/app_name"
                 android:icon="@drawable/icon">
					 
        <!-- Tell Cocos2dxActivity the name of our .so -->
        <meta-data android:name="android.app.lib_name"
	              android:value="cocos2dcpp" />

        <activity android:name="org.cocos2dx.cpp.AppActivity"
                  android:label="@string/app_name"
                  android:screenOrientation="landscape"
                  android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
                  android:configChanges="orientation">

            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
        
        <activity android:name="cn.toltech.gaoxueya.SplashScreen"
                  android:theme="@style/Theme.Transparent">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"></action>
                <category android:name="android.intent.category.LAUNCHER"></category>
            </intent-filter>
        </activity>        
    </application>

    <supports-screens android:anyDensity="true"
                      android:smallScreens="true"
                      android:normalScreens="true"
                      android:largeScreens="true"
                      android:xlargeScreens="true"/>

    <uses-permission android:name="android.permission.INTERNET"/>
</manifest>

2.2 styles.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
	<style name="Animations" parent="@android:Animation" />
	<style name="Animations.SplashScreen">
        <item name="android:windowEnterAnimation">@anim/appear</item>
        <item name="android:windowExitAnimation">@anim/disappear</item> 
    </style> 
	<style name="Theme.Transparent" parent="android:style/Theme.NoTitleBar.Fullscreen">
		<item name="android:windowIsTranslucent">true</item>
		<item name="android:windowBackground">@android:color/transparent</item>
		<item name="android:backgroundDimEnabled">false</item>
		<item name="android:windowNoTitle">true</item>
		<item name="android:windowContentOverlay">@null</item>
		<item name="android:windowAnimationStyle">@style/Animations.SplashScreen</item>				
	</style>		
</resources>

    若在Theme.Transparent中增加了<item name="android:windowIsFloating">true</item>，则此Activity无法全屏显示。


2.3  appear.xml

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
	<alpha
		android:interpolator="@android:anim/accelerate_interpolator"
		android:fromAlpha="1.0" android:toAlpha="1.0"
		android:duration="800"
	/>
</set>

    可根据效果需要设置fromAlpha和toAlpha的值。


2.4 disappear.xml

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
	<alpha
		android:interpolator="@android:anim/decelerate_interpolator"
		android:fromAlpha="1.0" android:toAlpha="1.0"
		android:duration="800"
	/>
</set>
    可根据效果需要设置fromAlpha和toAlpha的值。


2.5 splash.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:background="#FF0000"  
  android:orientation="vertical" 
  >
    <ImageView 
        android:layout_width="fill_parent" 
        android:layout_height="fill_parent" 
        android:src="@drawable/lnxins"        
        >
    </ImageView>
</LinearLayout>

2.6 SplashScreen.java

package cn.toltech.gaoxueya;;

import android.app.Activity;
import android.content.Intent;
import android.graphics.drawable.AnimationDrawable;
import android.os.Bundle;
import android.view.Menu;
import android.view.MotionEvent;
import android.widget.ImageView;

public class SplashScreen extends Activity {
    
    /**
     * The thread to process splash screen events
     */
    private Thread mSplashThread;    

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Splash screen view
        setContentView(R.layout.splash);
        
        final SplashScreen sPlashScreen = this;   
        
        // The thread to wait for splash screen events
        mSplashThread =  new Thread(){
            @Override
            public void run(){
                try {
                    synchronized(this){
                        // Wait given period of time or exit on touch
                        wait(5000);
                    }
                }
                catch(InterruptedException ex){                    
                }

                finish();
                
                // Run next activity
                Intent intent = new Intent();
                intent.setClass(sPlashScreen, org.cocos2dx.cpp.AppActivity.class);
                startActivity(intent);
                //stop();                    
            }
        };
        
        mSplashThread.start();        
    }
        
    /**
     * Processes splash screen touch events
     */
    @Override
    public boolean onTouchEvent(MotionEvent evt)
    {
        if(evt.getAction() == MotionEvent.ACTION_DOWN)
        {
            synchronized(mSplashThread){
                mSplashThread.notifyAll();
            }
        }
        return true;
    }    
}


2.7 AppActivity.java

package org.cocos2dx.cpp;

import org.cocos2dx.lib.Cocos2dxActivity;

// added by xxx on 2014.10.28
import org.cocos2dx.lib.Cocos2dxGLSurfaceView;
import android.os.Bundle;
import android.view.SurfaceHolder;  
import android.view.SurfaceView;  
import android.view.View;  
import android.media.MediaPlayer;  
import android.util.Log;  
import java.io.IOException;  
import android.os.Message;
import android.os.Handler;


public class AppActivity extends Cocos2dxActivity {
    private static final String TAG="XXX";  

	private final static int HANDLER_MEDIA_PLAY 	= 1;
	private final static int HANDLER_MEDIA_STOP 	= 2;
	private final static int HANDLER_MEDIA_PAUSE 	= 3;
	private final static int HANDLER_MEDIA_RESUME 	= 4;
	private final static int HANDLER_MEDIA_SEEK 	= 5;
	

	private static Handler sHandler;
	private boolean mPlayerPaused = false;
	  
    private SurfaceHolder mediaSurfaceHolder = null;  
    private MediaPlayer   mMediaPlayer = null;  
	private GetPosThread  mPosThread = null;
    //private boolean isMediaPlay = false;  

	private String mCurrentPath = null;
	private int    mCurrentCount = 0;
      
    protected void onCreate(Bundle savedInstanceState){  
        super.onCreate(savedInstanceState);   
        initMedia();  
    }  

	/*  	
    public Cocos2dxGLSurfaceView onCreateView() {  
        Cocos2dxGLSurfaceView glSurfaceView = new Cocos2dxGLSurfaceView(this);  
        // Demo2 should create stencil buffer  
        glSurfaceView.setEGLConfigChooser(5, 6, 5, 0, 16, 8);  
          
        return glSurfaceView;  
    }
  
    private void initVideo(){  
        mediaSurfaceHolder = mMediaPlayView.getHolder();  
        mediaSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
        mediaSurfaceHolder.addCallback(new MediaSurfaceHolderCallBack());  
    }*/

	private void initMedia(){
    	mediaSurfaceHolder = mMediaPlayView.getHolder();
    	mediaSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    	mediaSurfaceHolder.addCallback(new MediaSurfaceHolderCallBack());
        
		this.sHandler = new Handler() {
			@Override
			public void handleMessage(final Message msg) {
				switch (msg.what) {
                    
					case HANDLER_MEDIA_PLAY:
                        // set MediaPlayer status
                        mPlayerPaused = false;
                        
                        final String path = (String) msg.obj;
                        final int playNum = msg.arg1;

                        Log.d(TAG,"HANDLER_VIDEO_PLAY:" + "path=" + path + ", playNum=" + playNum);

                        // stop the thread that get cur position
                        if(mPosThread != null){
							mPosThread.stopThread(true);
							mPosThread = null;
                    	}
                        //if(mServer != null) mServer.stopHandler();

                        if (mMediaPlayer != null) {
                            mMediaPlayer.stop();
                        
                            // should set the state, if not, the following sequence will be error
                            // play -> pause -> stop -> resume
                            mPlayerPaused = false;
                        }

                        
                        if (mCurrentPath == null) {
                            // it is the first time to play media 
                            mMediaPlayer = createMediaPlayer(path);

                            // record the path and play number
                            if(mMediaPlayer != null){
                                mCurrentPath = path;
                                mCurrentCount = playNum;
                            }
                            
                        } else {
							// play new media or replay
							// release old resource and create a new one
							if (mMediaPlayer != null) {
							    mMediaPlayer.release();
							}

							mMediaPlayer = createMediaPlayer(path);

							// record the path and play number
							if(mMediaPlayer != null){
							    mCurrentPath = path;
							    mCurrentCount = playNum;
							}
                        }
                        
                        if (mMediaPlayer == null) {
                            Log.e(TAG, "ERROR: media player is null");
                        }
                        
						break;
                        
					case HANDLER_MEDIA_SEEK:
                        Log.d(TAG,"receive HANDLER_VIDEO_SEEK");
                        
						if((null != mMediaPlayer)&&(mMediaPlayer.isPlaying() || mPlayerPaused)){
                            mMediaPlayer.seekTo(msg.arg1);    
                            Log.d(TAG,"seekTo:" + msg.arg1 + "ms");
                        }
                        
						break;
					case HANDLER_MEDIA_STOP:
                        Log.d(TAG,"receive HANDLER_VIDEO_STOP");

                        // stop the thread that get cur position
                        if(mPosThread != null){
							mPosThread.stopThread(true);
							mPosThread = null;
                    	}
                        //if(mServer != null) mServer.stopHandler();

                        if (mMediaPlayer != null) {
                            mMediaPlayer.stop();
                        
                            // should set the state, if not, the following sequence will be error
                            // play -> pause -> stop -> resume
                            mPlayerPaused = false;
                        }
						break;
                        
					case HANDLER_MEDIA_PAUSE:
                        Log.d(TAG,"receive HANDLER_VIDEO_PAUSE");
                        
                        if (mMediaPlayer != null && mMediaPlayer.isPlaying()) {
                            mMediaPlayer.pause();
                            mPlayerPaused = true;
                        }
						break;

					case HANDLER_MEDIA_RESUME:
                        Log.d(TAG,"receive HANDLER_VIDEO_RESUME");
                        
                        if (mMediaPlayer != null && mPlayerPaused) {
                            mMediaPlayer.start();
                            mPlayerPaused = false;
                        }

						break;                        
				}
			}
		};        
	}
		
	public class GetPosThread extends Thread {
	
		private boolean  _run  = true;
		public void stopThread( boolean  run) {
			this ._run = !run;
		}
		
		@Override
		public void run() {
			while(_run) {
				try {
					if((mMediaPlayer != null) && (mMediaPlayer.isPlaying())){
					
						int pos = mMediaPlayer.getCurrentPosition();
						nativeUpdateCurPos(pos);
					}
					else
					{
						if(mMediaPlayer == null) Log.d(TAG, "mMediaPlayer is null");
						//if(mMediaPlayer.isPlaying()!= true) Log.d(TAG,"mMediaPlayer is not playing");
					}
					
					Thread.sleep(1000); // sleep 1s
					
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	
	}

	private MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {
		@Override
		public void onPrepared(MediaPlayer mp) {
			Log.d(TAG,"onPrepared...");
			mediaSurfaceHolder.setFixedSize(mp.getVideoWidth(), mp.getVideoHeight());

			// start play video
			mp.start();
  
	    	try{
	    		// startup Get Pos Thread
	    		mPosThread = new GetPosThread();
	    		mPosThread.start(); 
		    } catch (Exception e) {
		    	e.printStackTrace();
		    }
		}
	};

	private MediaPlayer.OnCompletionListener mCompletionListener = new MediaPlayer.OnCompletionListener() {
		public void onCompletion(MediaPlayer mp) {
			Log.d(TAG,"onCompletion...");

            if(mCurrentCount == -1){
    			mp.seekTo(0);
    			mp.start();
            }else{
                // stop the thread that get cur position
                if(mPosThread != null) mPosThread.stopThread(true);

				// notify stop video play
                nativePlayEnd();
            }
		}
	};

      
    private class MediaSurfaceHolderCallBack implements SurfaceHolder.Callback{  
  
        @Override  
        public void surfaceChanged(SurfaceHolder holder, int format, int width,  
                int height) {  
            Log.d(TAG,"surfaceChanged...,width="+width+", height="+height);  
              
        }  
  
        @Override  
        public void surfaceCreated(SurfaceHolder holder) {  
  
            Log.d(TAG,"surfaceCreated...");  
            play("/mnt/sdcard/video/cg720p.mp4");
            /*  
            mMediaPlayer = new MediaPlayer();  
            mMediaPlayer.setOnPreparedListener(mPreparedListener);  
            mMediaPlayer.setOnCompletionListener(mCompletionListener);  
              
            try {  
                mMediaPlayer.setDataSource("/sdcard/video/cg.mp4");  
            } catch (IllegalArgumentException e) {  
                e.printStackTrace();  
            } catch (IllegalStateException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            mMediaPlayer.setDisplay(mediaSurfaceHolder);  
              
            try {  
                mMediaPlayer.prepareAsync();   
            } catch (IllegalStateException e) {  
                e.printStackTrace();  
            } */  
        }  
  
        @Override  
        public void surfaceDestroyed(SurfaceHolder holder) {  
            if( mMediaPlayer != null && mMediaPlayer.isPlaying() ){  
                mMediaPlayer.stop();  
                mMediaPlayer.release();  
                mMediaPlayer = null;  
            }  
  
            if( mediaSurfaceHolder != null ){  
                mediaSurfaceHolder = null;  
            }  
        }  
    }  
          
	private MediaPlayer createMediaPlayer(final String path) {
		MediaPlayer mediaPlayer = new MediaPlayer();
		
		mediaPlayer.setOnPreparedListener(mPreparedListener);
		mediaPlayer.setOnCompletionListener(mCompletionListener);
		mediaPlayer.setDisplay(mediaSurfaceHolder);

		try {
			mediaPlayer.setDataSource(path);
			mediaPlayer.prepareAsync();
		} catch (final Exception e) {
			mediaPlayer = null;
			Log.e(TAG, "error: " + e.getMessage(), e);
		}

		return mediaPlayer;
	}

	// Video Player Interface with C++
	public static boolean play(final String path) {
		Log.d(TAG,"receive native play: path=" +path);

		final Message msg = new Message();
		msg.what = HANDLER_MEDIA_PLAY;
		msg.obj = path;
		msg.arg1 = 1;
		
		sHandler.sendMessage(msg);

		return true;
	}

	public static boolean seekTo(int msec){
		Log.d(TAG,"receive native seekTo: msec=" +msec);

		final Message msg = new Message();
		msg.what = HANDLER_MEDIA_SEEK;
		msg.arg1 = msec;
		
		sHandler.sendMessage(msg);
		return true;
	}

	public static boolean stop(){
		Log.d(TAG,"receive native stop");
		
		final Message msg = new Message();
		msg.what = HANDLER_MEDIA_STOP;
		sHandler.sendMessage(msg);
		
		return true;		  
	}

	public static boolean pause(){
		Log.d(TAG,"receive native pause");
		
		final Message msg = new Message();
		msg.what = HANDLER_MEDIA_PAUSE;
		sHandler.sendMessage(msg);
		
		return true;		  
	}

	public static boolean resume(){
		Log.d(TAG,"receive native resume");
		
		final Message msg = new Message();
		msg.what = HANDLER_MEDIA_RESUME;
		sHandler.sendMessage(msg);
		
		return true;		  
	}

	// Native method
	private static native void nativeUpdateCurPos(int curPos);
	private static native void nativePlayEnd();

}


更简单的方式：http://www.cnblogs.com/liqw/p/4263418.html


Arrow
关注
专栏目录
android从图标进入app不会黑屏和任务栏进入app会黑屏的解决办法
disanxiaoyao的博客
10-25 1205
今天遇上了一个纠结的问题，android手机从图标进入app（横屏）不会黑屏，但是点开任务栏，从任务栏进入app就会黑屏卡住一段时间，期间操作其他按键还容易产生程序崩溃的情况。 但是这可能只是试用我app的其中一个原因，不一定所有原因都是这个引起的，比如最近吐槽得比较厉害的miui系统，大部分手机都不会出现这情况，但是miui系统就出现了。。。 好了，上主菜!解决办法 更改manifest配
android应用程序重启黑屏,解决启动Android应用程序时出现白屏或者黑屏的问题
weixin_31199559的博客
05-27 1200
通过设置主题来防止白屏或者黑屏一般情况下，启动页面通常是全屏的，而且会用一张图片来展示用户打开应用程序后第一眼看到的界面。在手机中点击应用程序的图标到应用程序显示完MainActivity的视图这个过程中，通常会用一到两秒的时间。在默认activity的主题下(Light or Black)，这两秒屏幕就会出现白屏(Light)或者黑屏(Black)- 实际上是activity默认的主题中的and...
Android程序启动时出现黑屏问题的解决方法
01-06
本文实例讲述了Android程序启动时出现黑屏问题的解决方法。分享给大家供大家参考，具体如下： 关于黑屏： 默认的情况下，程序启动时，会有一个黑屏的时期，原因是，首个activity会加载一些数据，比如初始化列表数据、向服务器发送请求获取数据等等。 去除方法： 1、在style里面添加一个style: <style name=ContentOverlayparent=@android:style/Theme.Light> <itemname>true</item> <itemname=android:windowIsTransluce
Android 启动页黑屏问题
08-20
Android 启动页黑屏问题，设置style样式，添加动画，增加界面流畅度
Cocos Creator Android 原生启动优化系列 —— 自定义启动页
最新发布
nierdaye168的博客
06-27 1876
在 setContentView 之前，显示的是应用的主题 Theme。设置的 view 没有任何内容，显示出来的就是黑色，因此需要给 view 上添加一些内容。图片保存在桌面，并复制该图片logo 成功复制该图片后，进入AndroidStudio中。找到res文件夹下的drawable文件夹(没有就创建文件夹drawable)，将先前复制的图片粘贴到该文件夹下 就可用了。AppActivity 在主题被设置为了 Theme.NoTitleBar.Fullscreen，该主题没有背景，显示出来的是黑屏。
android自定义MediaPlayer视频播放器，兼容各种视频类型播放。解决视频加载不出来黑屏问题。
02-28
自定义MediaPlayer视频播放器，兼容各种视频类型播放。解决视频加载不出来黑屏问题。
android 黑屏 可点击,Android优化之启动页去黑屏实现秒启动
weixin_42508905的博客
05-26 242
Android优化之启动页去黑屏实现秒启动Android优化之启动页去黑屏实现秒启动一、消除启动时的黑屏点击桌面launcher图标启动APP，闪现的黑色背景其实是出现在我们看到界面第一帧之前。那我们就要想办法让这个黑色的背景变成用户喜欢看到的画面或者让它透明化。有了思路方法也就粗现了，我们有下面两种方案：自定义WelcomActivity的Theme说白了，就是把出现的黑屏通过android:w...
Android启动页黑屏
qq_25745699的博客
11-21 229
&lt;style name="Theme.AppStartLoad" parent="android:Theme.NoTitleBar.Fullscreen"&gt; &lt;item name="android:windowBackground"&gt;@color/background&lt;/item&gt; &lt;item name="android:w
Android app启动时黑屏或者白屏的原因及解决办法
09-01
在Android应用开发中，用户在启动应用时可能会遇到黑屏或白屏的问题。这通常是由于应用程序在加载主界面之前，屏幕上显示的是默认的窗口背景。本文将深入探讨这个问题的原因，并提供几种解决方案。 首先，我们来...
Android启动页出现白屏、黑屏的解决方案
08-28
在Android应用开发中，用户首次打开应用时可能会遇到启动页出现白屏或黑屏的现象，这是由于系统在创建新进程并加载应用资源的过程中所导致的。为了改善用户体验，Android系统会展示一个预览窗口（Preview Window），...
Android启动页黑屏的解决方案
weixin_30664539的博客
07-12 207
一般APP启动都会显示一个白屏或者黑屏的页面，再跳到欢迎页，这样子的体验效果不好。这到底是怎么回事呢？要如何解决它呢？今天我们来分析下它产生的原因，以及解决方案。 1、产生原因 当系统启动一个APP时，zygote进程首先会创建一个进程去执行这个APP，但是创建进程是需要时间的，用户点击后以为没响应会再次点击，这样的体验效果不佳。为了解决这种迷之尴尬，Android系统会根据你的manifes...
双GLSurfaceView同时显示Preview时遇到的几个坑
09-28
解决双GLSurfaceView同时显示Preview时遇到的几个坑
cocos2dx 3.x在Android的各种坑总结
denggong2014的专栏
09-23 654
1、cocos studio的listView背景设置为透明不起作用，背景表现为绿色；
安卓适配屏幕-4.x&&5.x
weixin_33720078的博客
04-25 69
//================================================ private static Cocos2dxGLSurfaceView glSurfaceView; public Cocos2dxGLSurfaceView onCreateView() { 　　glSurfaceView = new Cocos2dxGLS...
修正 Android cocos2d-x FATAL EXCEPTION: GLThread 105的错误
modabobo
04-10 219
出现FATAL EXCEPTION: GLThread 105这个错误大概有几种情况 1、运行在模拟器上 2、使用了CCClippingNode 3、其它情况 解决的方法很简单： 在Cocos2dxActivity.java里，找到this.mGLSurfaceView.setCocos2dxRenderer(new Cocos2dxRenderer())，在这一行代码前添加 ...
Android OpenGL ES（五）:GLSurfaceView
linuxheik的专栏
07-07 1385
Android OpenGL ES（五）:GLSurfaceView 分类： Android OpenGL ES基础2012-02-27 16:56 3365人阅读 评论(0) 收藏 举报 androidnullthreadinterfaceclasswrapper Android OpenGL ES 相关的包主要定义在 javax.microedition.k
OpenGLES 在几种情况下的 MSAA（Multisample Anti-aliasing）抗锯齿
热门推荐
我是一只小小小小鸟
09-19 1万+
OpenGLES 在几种情况下的 MSAA（Multisample Anti-aliasing）抗锯齿前言为了开启一个Demo的抗锯齿，OpenGL基础薄弱的我研究了半个多月。终于在同事的帮助指导下实现了。以下对三种情况的抗锯齿做个简单的介绍。他们分别是最简单的纯 Java 环境下的抗锯齿，Jni 中的抗锯齿，以及离屏渲染中的抗锯齿。抗锯齿之前忽然想起来，在学习如何开启抗锯齿时，在网上找到了不少资料
Android中保持屏幕常亮的三种使用方法
IT666DHW的博客
07-21 8925
在Android应用开发中，Wakelock被广泛应用于保持屏幕或CPU处于唤醒状态，以便应用程序可以继续执行后台任务，直到任务完成。Wakelock是为了解决一些特定的应用场景而产生的概念，它的作用是保持屏幕、CPU或者一些其他机器状态继续运行，以满足一些特定的需求。WakeLock是Android框架层提供的一套机制，应用使用该机制可以达到控制Android设备状态的目的。这里的设备状态主要指屏幕的打开关闭，CPU的保持运行。简单的理解WakeLock是让系统保持”清醒”的一种手段。
cocos creator 安卓启动黑屏几秒钟，加个logo启动页面效果更佳
BCXS1的博客
07-25 2210
1.添加一张开始图片drawable/logo 安卓工程下的res目录下新建styles.xml ?xml version=“1.0” encoding=“utf-8”?> ![在这里插入图片描述](https://img-blog.csdnimg.cn/2019072514143645.?x-oss-process=image/watermark,type_ZmFuZ3poZW...
解决Android app启动黑屏白屏问题的方案
"Android应用在启动时可能会遇到黑屏或白屏的问题，这通常是由于应用程序尚未完成布局加载就显示了窗口背景。" 在Android开发中，黑屏或白屏现象是常见的，尤其在应用启动初期。这主要是因为Android系统在加载应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值