`
rocky225
  • 浏览: 11412 次
  • 性别: Icon_minigender_1
  • 来自: 珠海
社区版块
存档分类
最新评论

Live Wallpaper动态壁纸开发

 
阅读更多

Live Wallpaper动态壁纸开发

作者: Android开发网原创 时间: 2011-04-12

对于Android 2.1来说Live Wallpapers动态壁纸的加入为Android桌面加入了更好的动态效果。如何开发一个Android动态桌面呢? 下面Android123给大家一个详细的步骤创建属于你自己的Live Wallpaper吧。

1. 首先我使用Eclipse创建一个标准的Android工程这里package name我们使用cn.com.android123.cwj，然后进入工程的/res/文件夹，删除layout这个文件夹，当然里面的main.xml也会被删除的，对于Live Wallpaper来说传统的布局文件是不需要的。

2. 类似AppWidget一样，我们可以加入动态壁纸的设置界面，我们在/res/文件夹中新建一个名为xml的文件夹，新建一个utf8编码的xml文件，名为livewallpaper.xml，内容为

<?xml version="1.0" encoding="utf-8"?>
  <wallpaper xmlns:android="http://schemas.android.com/apk/res/android"
 android:settingsActivity="cn.com.android123.cwj.LiveWallpaperSettings"
 android:thumbnail="@drawable/icon"/>
这里我们可以看到上面的节点名为wallpaper，而设置的界面为 cn.com.android123.cwj.LiveWallpaperSettings这个Activity，而在添加动态壁纸时显示图标为/res/drawable/icon 这个文件，同时我们再创建一个xml文件用于LiveWallpaperSettings这个Activity的布局，我们起名为livewallpaper_settings.xml内容为
  <?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
 android:title="@string/livewallpaper_settings"
 android:key="livewallpaper_settings">

 <ListPreference
  android:key="livewallpaper_testpattern"
  android:title="标题"
  android:summary="简单描述"
  android:entries="@array/livewallpaper_testpattern_names"
  android:entryValues="@array/livewallpaper_testpattern_prefix"/>

 <CheckBoxPreference android:key="livewallpaper_movement"
  android:summary="动态描述"
  android:title="动态标题"
  android:summaryOn="动态测试"
  android:summaryOff="静止测试"/>
</PreferenceScreen>
3. 创建一个名为LiveWallpaper的类作为动态壁纸的主类，从WallpaperService父类继承，这里我们可以像写标准Android服务那样开发，代码为
public class LiveWallpaper extends WallpaperService {

	public static final String SHARED_PREFS_NAME = "livewallpapersettings";

	@Override
	public void onCreate() {
		super.onCreate();
	}

	@Override
	public void onDestroy() {
		super.onDestroy();
	}

	@Override
	public Engine onCreateEngine() {
		return new TestPatternEngine();
	}

	class TestPatternEngine extends Engine implements
			SharedPreferences.OnSharedPreferenceChangeListener {

		private final Handler mHandler = new Handler();
		private float mTouchX = -1;
		private float mTouchY = -1;
		private final Paint mPaint = new Paint();
		private final Runnable mDrawPattern = new Runnable() {
			public void run() {
				drawFrame();
			}
		};
		private boolean mVisible;
		private SharedPreferences mPreferences;

		private Rect mRectFrame;

		private Rect[] mColorRectangles;
		private int[] rectColor;
		private int mRectCount;

		// private
		private Rect mGradientRect;
		GradientDrawable mGradient;
		private boolean mHorizontal = false;
		private int mFrameCounter = 0;
		private boolean mMotion = true;
		private String mShape = "smpte";

		TestPatternEngine() {
			final Paint paint = mPaint;
			paint.setColor(0xffffffff);
			paint.setAntiAlias(true);
			paint.setStrokeWidth(2);
			paint.setStrokeCap(Paint.Cap.ROUND);
			paint.setStyle(Paint.Style.STROKE);

			mPreferences = LiveWallpaper.this.getSharedPreferences(
					SHARED_PREFS_NAME, 0);
			mPreferences.registerOnSharedPreferenceChangeListener(this);
			onSharedPreferenceChanged(mPreferences, null);
		}

		public void onSharedPreferenceChanged(SharedPreferences prefs,
				String key) {
			mShape = prefs.getString("livewallpaper_testpattern", "smpte");
			mMotion = prefs.getBoolean("livewallpaper_movement", true);
			readColors();
		}

		private void readColors() {

			int pid = getResources().getIdentifier(mShape + "colors", "array",
					getPackageName());

			rectColor = getResources().getIntArray(pid);
			mRectCount = rectColor.length;
			mColorRectangles = new Rect[mRectCount];

			System.out.println("mRectCount " + mRectCount);
			initFrameParams();
		}

		@Override
		public void onCreate(SurfaceHolder surfaceHolder) {
			super.onCreate(surfaceHolder);
			setTouchEventsEnabled(true);
		}

		@Override
		public void onDestroy() {
			super.onDestroy();
			mHandler.removeCallbacks(mDrawPattern);
		}

		@Override
		public void onVisibilityChanged(boolean visible) {
			mVisible = visible;
			if (visible) {
				drawFrame();
			} else {
				mHandler.removeCallbacks(mDrawPattern);
			}
		}

		@Override
		public void onSurfaceChanged(SurfaceHolder holder, int format,
				int width, int height) {
			super.onSurfaceChanged(holder, format, width, height);

			initFrameParams();

			drawFrame();
		}

		@Override
		public void onSurfaceCreated(SurfaceHolder holder) {
			super.onSurfaceCreated(holder);
		}

		@Override
		public void onSurfaceDestroyed(SurfaceHolder holder) {
			super.onSurfaceDestroyed(holder);
			mVisible = false;
			mHandler.removeCallbacks(mDrawPattern);
		}

		@Override
		public void onOffsetsChanged(float xOffset, float yOffset, float xStep,
				float yStep, int xPixels, int yPixels) {

			drawFrame();
		}

		@Override
		public void onTouchEvent(MotionEvent event) {
			if (event.getAction() == MotionEvent.ACTION_MOVE) {
				mTouchX = event.getX();
				mTouchY = event.getY();
			} else {
				mTouchX = -1;
				mTouchY = -1;
			}
			super.onTouchEvent(event);
		}

		void drawFrame() {
			final SurfaceHolder holder = getSurfaceHolder();

			Canvas c = null;
			try {
				c = holder.lockCanvas();
				if (c != null) {
					// draw something
					drawPattern(c);
					drawTouchPoint(c);
				}
			} finally {
				if (c != null)
					holder.unlockCanvasAndPost(c);
			}

			mHandler.removeCallbacks(mDrawPattern);
			if (mVisible) {
				mHandler.postDelayed(mDrawPattern, 1000 / 25);
			}
		}

		void drawPattern(Canvas c) {
			c.save();
			c.drawColor(0xff000000);

			Paint paint = new Paint();
			if (mMotion) {
				mFrameCounter++;
				if (mHorizontal) {
					int right;
					int left;
					if (mFrameCounter > mRectFrame.right)
						mFrameCounter = 0;

					for (int i = 0; i < mRectCount; i++) {
						paint.setColor(rectColor[i]);

						right = mColorRectangles[i].right + mFrameCounter;
						left = mColorRectangles[i].left + mFrameCounter;

						if (right > mRectFrame.right) {
							c.drawRect(left - mRectFrame.right,
									mColorRectangles[i].top, right
											- mRectFrame.right,
									mColorRectangles[i].bottom, paint);
						}

						if (left < mRectFrame.right) {
							c.drawRect(left, mColorRectangles[i].top, right,
									mColorRectangles[i].bottom, paint);
						}
					}

					if (mShape.compareToIgnoreCase("smpte") == 0) {
						right = mGradientRect.right + mFrameCounter;
						left = mGradientRect.left + mFrameCounter;
						if (right > mRectFrame.right) {
							mGradient.setBounds(left - mRectFrame.right,
									mGradientRect.top,
									right - mRectFrame.right,
									mGradientRect.bottom);
							mGradient.draw(c);
						}

						if (left < mRectFrame.right) {
							mGradient.setBounds(left, mGradientRect.top, right,
									mGradientRect.bottom);
							mGradient.draw(c);
						}
					}
				} else {
					int top;
					int bottom;
					if (mFrameCounter > mRectFrame.bottom)
						mFrameCounter = 0;

					for (int i = 0; i < mRectCount; i++) {
						paint.setColor(rectColor[i]);

						top = mColorRectangles[i].top + mFrameCounter;
						bottom = mColorRectangles[i].bottom + mFrameCounter;

						if (bottom > mRectFrame.bottom) {
							c.drawRect(mColorRectangles[i].left, top
									- mRectFrame.bottom,
									mColorRectangles[i].right, bottom
											- mRectFrame.bottom, paint);
						}

						if (top < mRectFrame.bottom) {
							c.drawRect(mColorRectangles[i].left, top,
									mColorRectangles[i].right, bottom, paint);
						}
					}

					if (mShape.compareToIgnoreCase("smpte") == 0) {
						top = mGradientRect.top + mFrameCounter;
						bottom = mGradientRect.bottom + mFrameCounter;

						if (bottom > mRectFrame.bottom) {
							mGradient.setBounds(mGradientRect.left, top
									- mRectFrame.bottom, mGradientRect.right,
									bottom - mRectFrame.bottom);
							mGradient.draw(c);
						}

						if (top < mRectFrame.bottom) {
							mGradient.setBounds(mGradientRect.left, top,
									mGradientRect.right, bottom);
							mGradient.draw(c);
						}

					}
				}
			} else {
				for (int i = 0; i < mRectCount; i++) {
					paint.setColor(rectColor[i]);
					c.drawRect(mColorRectangles[i], paint);
				}

				if (mShape.compareToIgnoreCase("smpte") == 0) {
					mGradient.setBounds(mGradientRect);
					mGradient.draw(c);
				}
			}
			c.restore();
		}

		void drawTouchPoint(Canvas c) {
			if (mTouchX >= 0 && mTouchY >= 0) {
				c.drawCircle(mTouchX, mTouchY, 80, mPaint);
			}
		}

		void initFrameParams() {
			DisplayMetrics metrics = new DisplayMetrics();
			Display display = ((WindowManager) getSystemService(WINDOW_SERVICE))
					.getDefaultDisplay();
			display.getMetrics(metrics);

			mRectFrame = new Rect(0, 0, metrics.widthPixels,
					metrics.heightPixels);

			int rotation = display.getOrientation();
			if (rotation == Surface.ROTATION_0
					|| rotation == Surface.ROTATION_180)
				mHorizontal = false;
			else
				mHorizontal = true;

			System.out.println("mHorizontal " + mHorizontal);
			System.out.println("mShape " + mShape);
			if (mShape.compareToIgnoreCase("smpte") == 0) {
				System.out.println("mShape == smpte");

				CreateSmpte();
			} else if (mShape.compareToIgnoreCase("bars") == 0) {
				System.out.println("mShape == bars");
				CreateBars();
			} else {
				System.out.println("mShape == ebu");
				CreateEbu();
			}
		}

		private void CreateSmpte() {
			if (mHorizontal) {
				int topHeight = mRectFrame.bottom * 7 / 12;
				int bottomHeight = mRectFrame.bottom * 3 / 4;
				int wideColumnWidth = mRectFrame.right / 8;
				int narrowColumnWidth = mRectFrame.right * 3 / 28;

				mColorRectangles[0] = new Rect(0, 0, wideColumnWidth, topHeight);
				for (int i = 1; i < 8; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right, 0,
							mColorRectangles[i - 1].right + narrowColumnWidth,
							topHeight);
				}

				mColorRectangles[8] = new Rect(mColorRectangles[7].right, 0,
						mRectFrame.right, topHeight);

				for (int i = 0; i < 2; i++) {
					int middleTop = mRectFrame.bottom * (7 + i) / 12;
					int middleBottom = mRectFrame.bottom * (8 + i) / 12;
					mColorRectangles[i + 9] = new Rect(0, middleTop,
							wideColumnWidth, middleBottom);
					mColorRectangles[i + 11] = new Rect(wideColumnWidth,
							middleTop, narrowColumnWidth + wideColumnWidth,
							middleBottom);
					mColorRectangles[i + 13] = new Rect(narrowColumnWidth * 7
							+ wideColumnWidth, middleTop, mRectFrame.right,
							middleBottom);
				}

				mColorRectangles[15] = new Rect(narrowColumnWidth
						+ wideColumnWidth, topHeight, narrowColumnWidth * 7
						+ wideColumnWidth, mRectFrame.bottom * 8 / 12);

				mGradientRect = new Rect(mColorRectangles[15].left,
						mColorRectangles[15].bottom,
						mColorRectangles[15].right, mRectFrame.bottom * 9 / 12);
				mGradient = new GradientDrawable(Orientation.LEFT_RIGHT,
						new int[] { 0xff050505, 0xfffdfdfd });
				mGradient.setBounds(mGradientRect);

				mColorRectangles[16] = new Rect(0, bottomHeight,
						wideColumnWidth, mRectFrame.right);
				mColorRectangles[17] = new Rect(mColorRectangles[16].right,
						bottomHeight, mRectFrame.right * 9 / 56
								+ mColorRectangles[16].right, mRectFrame.bottom);
				mColorRectangles[18] = new Rect(mColorRectangles[17].right,
						bottomHeight, mRectFrame.right * 3 / 14
								+ mColorRectangles[17].right, mRectFrame.bottom);
				mColorRectangles[19] = new Rect(mColorRectangles[18].right,
						bottomHeight, mRectFrame.right * 45 / 448
								+ mColorRectangles[18].right, mRectFrame.bottom);
				for (int i = 20; i < 25; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right, bottomHeight,
							mRectFrame.right * 15 / 448
									+ mColorRectangles[i - 1].right,
							mRectFrame.right);
				}
				mColorRectangles[25] = new Rect(mColorRectangles[24].right,
						bottomHeight, narrowColumnWidth
								+ mColorRectangles[24].right, mRectFrame.bottom);
				mColorRectangles[26] = new Rect(mColorRectangles[25].right,
						bottomHeight, mRectFrame.right, mRectFrame.bottom);
			} else {
				int topHeight = mRectFrame.right * 5 / 12;
				int bottomHeight = mRectFrame.right / 4;
				int wideColumnWidth = mRectFrame.bottom / 8;
				int narrowColumnWidth = mRectFrame.bottom * 3 / 28;

				mColorRectangles[0] = new Rect(topHeight, 0, mRectFrame.bottom,
						wideColumnWidth);

				for (int i = 1; i < 8; i++) {
					mColorRectangles[i] = new Rect(topHeight,
							mColorRectangles[i - 1].bottom, mRectFrame.right,
							narrowColumnWidth + mColorRectangles[i - 1].bottom);
				}

				mColorRectangles[8] = new Rect(topHeight,
						mColorRectangles[7].bottom, mRectFrame.right,
						mRectFrame.bottom);

				for (int i = 0; i < 2; i++) {
					int middleLeft = mRectFrame.right * (4 - i) / 12;
					int middleRight = mRectFrame.right * (5 - i) / 12;
					mColorRectangles[i + 9] = new Rect(middleLeft, 0,
							middleRight, wideColumnWidth);
					mColorRectangles[i + 11] = new Rect(middleLeft,
							wideColumnWidth, middleRight, narrowColumnWidth
									+ wideColumnWidth);
					mColorRectangles[i + 13] = new Rect(middleLeft,
							narrowColumnWidth * 7 + wideColumnWidth,
							middleRight, mRectFrame.bottom);
				}
				mColorRectangles[15] = new Rect(mRectFrame.right * 4 / 12,
						narrowColumnWidth + wideColumnWidth,
						mRectFrame.right * 5 / 12, narrowColumnWidth * 7
								+ wideColumnWidth);

				mGradientRect = new Rect(mRectFrame.right * 3 / 12,
						mColorRectangles[15].top, mColorRectangles[15].left,
						mColorRectangles[15].bottom);
				mGradient = new GradientDrawable(Orientation.TOP_BOTTOM,
						new int[] { 0xff050505, 0xfffdfdfd });
				mGradient.setBounds(mGradientRect);

				mColorRectangles[16] = new Rect(0, 0, bottomHeight,
						wideColumnWidth);
				mColorRectangles[17] = new Rect(0, mColorRectangles[16].bottom,
						bottomHeight, mRectFrame.bottom * 9 / 56
								+ mColorRectangles[16].bottom);
				mColorRectangles[18] = new Rect(0, mColorRectangles[17].bottom,
						bottomHeight, mRectFrame.bottom * 3 / 14
								+ mColorRectangles[17].bottom);
				mColorRectangles[19] = new Rect(0, mColorRectangles[18].bottom,
						bottomHeight, mRectFrame.bottom * 45 / 448
								+ mColorRectangles[18].bottom);
				for (int i = 20; i < 25; i++) {
					mColorRectangles[i] = new Rect(0,
							mColorRectangles[i - 1].bottom, bottomHeight,
							mRectFrame.bottom * 15 / 448
									+ mColorRectangles[i - 1].bottom);
				}
				mColorRectangles[25] = new Rect(0, mColorRectangles[24].bottom,
						bottomHeight, narrowColumnWidth
								+ mColorRectangles[24].bottom);
				mColorRectangles[26] = new Rect(0, mColorRectangles[25].bottom,
						bottomHeight, mRectFrame.bottom);
			}
		}

		private void CreateBars() {
			if (mHorizontal) {
				int narrowColumnWidth = mRectFrame.right / 7;
				int wideColumnWidth = mRectFrame.right * 5 / 28;
				int narrowestColumnWidth = mRectFrame.right / 21;

				int topColumnHeight = mRectFrame.bottom * 2 / 3;
				int middleColumnHeight = mRectFrame.bottom / 12;

				mColorRectangles[0] = new Rect(0, 0, narrowColumnWidth,
						topColumnHeight);
				for (int i = 1; i < 7; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right, 0,
							mColorRectangles[i - 1].right + narrowColumnWidth,
							topColumnHeight);
				}

				mColorRectangles[7] = new Rect(0, mColorRectangles[0].bottom,
						narrowColumnWidth, mColorRectangles[0].bottom
								+ middleColumnHeight);
				for (int i = 8; i < 14; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right,
							mColorRectangles[7].top,
							mColorRectangles[i - 1].right + narrowColumnWidth,
							mColorRectangles[7].bottom);
				}

				mColorRectangles[14] = new Rect(0, mColorRectangles[7].bottom,
						wideColumnWidth, mRectFrame.bottom);
				for (int i = 15; i < 18; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right,
							mColorRectangles[14].top,
							mColorRectangles[i - 1].right + wideColumnWidth,
							mRectFrame.bottom);
				}

				mColorRectangles[18] = new Rect(mColorRectangles[17].right,
						mColorRectangles[17].top, mColorRectangles[17].right
								+ narrowestColumnWidth, mRectFrame.bottom);
				for (int i = 19; i < 21; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right,
							mColorRectangles[14].top,
							mColorRectangles[i - 1].right
									+ narrowestColumnWidth, mRectFrame.bottom);
				}
				mColorRectangles[21] = new Rect(mColorRectangles[20].right,
						mColorRectangles[17].top, mColorRectangles[6].right,
						mRectFrame.bottom);

			} else {
				int narrowColumnWidth = mRectFrame.bottom / 7;
				int wideColumnWidth = mRectFrame.bottom * 5 / 28;
				int narrowestColumnWidth = mRectFrame.bottom / 21;

				int topColumnHeight = mRectFrame.right / 3;
				int middleColumnHeight = mRectFrame.right / 12;

				mColorRectangles[0] = new Rect(topColumnHeight, 0,
						mRectFrame.right, narrowColumnWidth);
				for (int i = 1; i < 7; i++) {
					mColorRectangles[i] = new Rect(topColumnHeight,
							mColorRectangles[i - 1].bottom, mRectFrame.right,
							mColorRectangles[i - 1].bottom + narrowColumnWidth);
				}

				mColorRectangles[7] = new Rect(mColorRectangles[0].left
						+ middleColumnHeight, 0, mColorRectangles[0].left,
						narrowColumnWidth);
				for (int i = 8; i < 14; i++) {
					mColorRectangles[i] = new Rect(mColorRectangles[7].left,
							mColorRectangles[i - 1].bottom,
							mColorRectangles[7].right,
							mColorRectangles[i - 1].bottom + narrowColumnWidth);
				}

				mColorRectangles[14] = new Rect(0, 0,
						mColorRectangles[7].right, wideColumnWidth);
				for (int i = 15; i < 18; i++) {
					mColorRectangles[i] = new Rect(0,
							mColorRectangles[i - 1].bottom,
							mColorRectangles[7].right,
							mColorRectangles[i - 1].bottom + wideColumnWidth);
				}

				mColorRectangles[18] = new Rect(0, mColorRectangles[17].bottom,
						mColorRectangles[7].right, mColorRectangles[17].bottom
								+ narrowestColumnWidth);
				for (int i = 19; i < 21; i++) {
					mColorRectangles[i] = new Rect(0,
							mColorRectangles[i - 1].bottom,
							mColorRectangles[7].right,
							mColorRectangles[i - 1].bottom
									+ narrowestColumnWidth);
				}
				mColorRectangles[21] = new Rect(0, mColorRectangles[20].bottom,
						mColorRectangles[7].right, mRectFrame.bottom);

			}
		}

		private void CreateEbu() {
			if (mHorizontal) {
				int narrowColumnWidth = mRectFrame.right / 8;

				mColorRectangles[0] = new Rect(0, 0, narrowColumnWidth,
						mRectFrame.bottom);
				for (int i = 1; i < 8; i++) {
					mColorRectangles[i] = new Rect(
							mColorRectangles[i - 1].right, 0,
							mColorRectangles[i - 1].right + narrowColumnWidth,
							mRectFrame.bottom);
				}

			} else {
				int narrowColumnWidth = mRectFrame.bottom / 8;

				mColorRectangles[0] = new Rect(0, 0, mRectFrame.right,
						narrowColumnWidth);
				for (int i = 1; i < 8; i++) {
					mColorRectangles[i] = new Rect(0,
							mColorRectangles[i - 1].bottom, mRectFrame.right,
							narrowColumnWidth + mColorRectangles[i - 1].bottom);
				}
			}
		}
	}
}

这里需要注意的是在androidmanifest.xml文件中加入
<service android:name=".LiveWallpaper" android:label="@string/app_name"  android:icon="@drawable/icon">
   <intent-filter>
      <action android:name="android.service.wallpaper.WallpaperService" />
    </intent-filter>
    <meta-data android:name="android.service.wallpaper" android:resource="@xml/livewallpaper" />
</service>

4. 新建类LiveWallpaperSettings从 PreferenceActivity 继承实现我们的设置界面，代码如下
public class LiveWallpaperSettings extends PreferenceActivity implements
		SharedPreferences.OnSharedPreferenceChangeListener {
	@Override
	protected void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		getPreferenceManager().setSharedPreferencesName(
				LiveWallpaper.SHARED_PREFS_NAME);
		addPreferencesFromResource(R.xml.livewallpaper_settings);
		getPreferenceManager().getSharedPreferences()
				.registerOnSharedPreferenceChangeListener(this);
	}

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

	@Override
	protected void onDestroy() {
		getPreferenceManager().getSharedPreferences()
				.unregisterOnSharedPreferenceChangeListener(this);
		super.onDestroy();
	}

	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
			String key) {
	}
}
同时仍然在androidmanifest.xml中加入 下面的代码。
<activity android:label="@string/livewallpaper_settings"
   android:name=".LiveWallpaperSettings"
   android:theme="@android:style/Theme.Light.WallpaperSettings"
   android:exported="true"
   android:icon="@drawable/icon">
  </activity>
5. 由于Android动态壁纸是2.1 API Level为7才加入的，所以设置好minSDK以及需要设备支持动态壁纸，我们在androidmanifest.xml中加入 
 <uses-sdk android:minSdkVersion="7" />
 <uses-feature android:name="android.software.live_wallpaper" />

6. 对于文中ListPreference用到的数组，及代码中涉及的颜色数组，我们在/res/values/ 文件夹中创建一个名为testpatterns.xml 的文件，内容为

<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
 <string-array name="livewallpaper_testpattern_names">
  <item>"Color Bars 16x9"</item>
  <item>"Color Bars 4x3"</item>
  <item>"EBU Color Bars"</item>
 </string-array>

 <string-array name="livewallpaper_testpattern_prefix">
  <item>"smpte"</item>
  <item>"bars"</item>
  <item>"ebu"</item>
 </string-array>

 <integer-array name="smptecolors">
  <item>0xFF696969</item>
  <item>0xFFC1C1C1</item>
  <item>0xFFC1C100</item>
  <item>0xFF00C1C1</item>
  <item>0xFF00C100</item>
  <item>0xFFC100C1</item>
  <item>0xFFC10000</item>
  <item>0xFF0000C1</item>
  <item>0xFF696969</item>
  <item>0xFF00FFFF</item>
  <item>0xFFFFFF00</item>
  <item>0xFF052550</item>
  <item>0xFF36056D</item>
  <item>0xFF0000FF</item>
  <item>0xFFFF0000</item>
  <item>0xFFC1C1C1</item>
  <item>0xFF2B2B2B</item>
  <item>0xFF050505</item>
  <item>0xFFFFFFFF</item>
  <item>0xFF050505</item>
  <item>0xFF000000</item>
  <item>0xFF050505</item>
  <item>0xFF0A0A0A</item>
  <item>0xFF050505</item>
  <item>0xFF0D0D0D</item>
  <item>0xFF050505</item>
  <item>0xFF2b2b2b</item>
 </integer-array>

 <integer-array name="barscolors">
  <item>0xFFC0C0C0</item>
  <item>0xFFC0C000</item>
  <item>0xFF00C0C0</item>
  <item>0xFF00C000</item>
  <item>0xFFC000C0</item>
  <item>0xFFC00000</item>
  <item>0xFF0000C0</item>
  <item>0xFF0000C0</item>
  <item>0xFF131313</item>
  <item>0xFFC000C0</item>
  <item>0xFF131313</item>
  <item>0xFF00C0C0</item>
  <item>0xFF131313</item>
  <item>0xFFC0C0C0</item>
  <item>0xFF00214C</item>
  <item>0xFFFFFFFF</item>
  <item>0xFF32006A</item>
  <item>0xFF131313</item>
  <item>0xFF090909</item>
  <item>0xFF131313</item>
  <item>0xFF1D1D1D</item>
  <item>0xFF131313</item>
 </integer-array>

 <integer-array name="ebucolors">
  <item>0xFFBFBFBF</item>
  <item>0xFFBFBF00</item>
  <item>0xFF00BFBF</item>
  <item>0xFF00BF00</item>
  <item>0xFFBF00BF</item>
  <item>0xFFBF0000</item>
  <item>0xFF0000BF</item>
  <item>0xFF000000</item>
 </integer-array>
</resources>



分享到：
| [转贴] 如何编写高效的Android代码
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    两个Android 动态壁纸 Live Wallpaper例子

    在Android平台上，动态壁纸（Live Wallpaper）是一种可以让用户自定义主屏幕背景的高级功能，它不仅限于静态图片，还能展示动画或者交互式效果。本压缩包提供的"两个Android 动态壁纸 Live Wallpaper-...

    X Live Wallpaper X动态壁纸v3.7 高级版.zip

    《X Live Wallpaper X动态壁纸v3.7 高级版》是一个专为手机...对于想学习这些技能或深入理解动态壁纸开发的人来说，这是一个很好的学习资源。同时，这个压缩包也提供了实际的应用实例，对于教学和研究具有很高的价值。

    Android 动态壁纸 Live Wallpaper

    Android动态壁纸，或者说“Live Wallpaper”，是Android操作系统中一种特殊的应用类型，允许用户将动态、交互式的背景设置为手机或平板电脑的主屏幕壁纸。这种壁纸不仅提供了静态图像的视觉体验，还可以根据用户的...

    Android动态桌面LiveWallpaper

    LiveWallpaper是Android系统中一种特殊的壁纸类型，它可以呈现动态效果，如动画、3D场景、实时天气信息等。与普通的静态壁纸相比，动态壁纸能够提供更丰富的视觉体验，让用户的手机桌面更具活力和个性。 **二、Live...

    动态壁纸wallpaper

    8. **发布与安装**：完成动态壁纸开发后，将其打包成APK并通过Google Play或其他应用市场发布。用户可以通过常规方式下载安装，并在设备的壁纸设置中选择使用。 9. **兼容性**：考虑到Android系统的版本多样性和...

    【安卓笔记】Live Wallpaper 二：天上掉下一只猫

    在安卓平台上，动态壁纸（Live Wallpaper）为用户提供了一种个性化的桌面体验，让用户的手机桌面不再静止不动，而是充满生机。这篇名为“【安卓笔记】Live Wallpaper 二：天上掉下一只猫”的博文，主要探讨了如何...

    2011.09.21——— android 动态壁纸开发

    总之，Android动态壁纸开发是一个结合创意和技术的领域，通过理解并实践`LiveWallpaper`的相关知识，开发者可以创造出各种各样的个性化动态壁纸，提升用户的使用体验。通过提供的博客链接和`MyLiveWallpaper`源码，...

    Video Live Wallpaper_v1.4.1

    《Video Live Wallpaper_v1.4.1》是一款专为Android用户设计的动态壁纸应用，它提供了丰富的视频背景，让用户的手机桌面生动起来。这款软件在MIUI、FM、GALAXY以及EIMU等常见Android系统上都可以流畅运行，为用户...

    android live wallpaper 教程

    在Android 2.1版本中引入了一项新功能——动态壁纸（Live Wallpaper），它为用户提供了更加生动且交互性的桌面背景。与传统的静态壁纸不同，动态壁纸不仅能够显示动画效果，还能响应用户的触摸操作。本教程旨在介绍...

    Creating Android live wallpaper

    开发动态壁纸时，还需要注意以下几点： - **性能优化**：由于壁纸会一直运行在后台，所以要确保代码高效，避免过度绘制和内存泄漏。 - **兼容性**：测试在不同设备和Android版本上的表现，确保兼容性。 - **权限...

    碧蓝档案 动态壁纸碧蓝档案 动态壁纸

    1. 系统兼容性：确保您的操作系统支持动态壁纸功能，如Windows的桌面幻灯片或Mac的Live Photos。此外，不同的动态壁纸可能对硬件配置有不同的需求，因此在下载前应查看系统要求。 2. 文件格式：文件名称...

    android动态壁纸源码

    动态壁纸的实现主要依赖于Android系统的`LiveWallpaper`服务。首先，我们需要创建一个继承自`WallpaperService`的类，并在其中重写`engine`方法。在这个`engine`中，我们将定义壁纸的绘制逻辑，通常会用到`...

    Android 动态壁纸模板。

    在Android平台上，动态壁纸（Live Wallpaper）是一种可以让用户自定义主屏幕背景的高级功能，它不仅限于静态图片，还能展示动画或者响应用户的交互。"Android动态壁纸模板"是一个非常有价值的资源，尤其对于那些想要...

    开发动态壁纸WallPaPerService.rar

    在Android平台上，动态壁纸（Live Wallpaper）是一种可以让用户在主屏幕上体验动态效果的壁纸类型。它们不仅限于静态图片，还可以包含动画、交互元素甚至简单的游戏。本教程将深入讲解如何利用Android的`...

    android 动态壁纸源码

    在Android平台上，动态壁纸是一种能够展示生动、交互式背景效果的特色功能，它为用户提供了一种自定义手机桌面的新...通过实践和调试，你可以逐步掌握动态壁纸开发的各个环节，从而为用户提供独一无二的个性化体验。

    Android动态桌面LiveWallpaper源代码

    文件名LiveWallpaper，可以循环改变Android手机的待机桌面，选择一些漂亮的图片作为桌面，喜欢个性化的手机玩家，对此是想当热衷的，Android的自定义功能和桌面应用类软件也想当丰富，此动态桌面源码可为你开发其它...

    Android-在Android上将您的Unity游戏作为动态壁纸运行

    首先，理解Android动态壁纸（Live Wallpaper）的概念是至关重要的。Android动态壁纸是一种特殊类型的壁纸应用，它不仅展示静态图像，还能展示动画或交互式内容。它们运行在Android系统的壁纸服务中，允许用户自定义...

    动态壁纸（android）

    本资源针对的是Android平台上的动态壁纸开发，适合对移动应用开发感兴趣的开发者进行学习。 在Android动态壁纸开发中，主要涉及以下几个关键知识点： 1. **服务（Service）**：动态壁纸实际上是在后台运行的一个...

    TZM-Android-LiveWallpaper:时代精神运动动态壁纸为Android-开源

    《TZM-Android-LiveWallpaper：开源精神在动态壁纸中的展现》 “TZM-Android-LiveWallpaper”是一个专为Android系统设计的开源动态壁纸应用，其核心理念是融入了“时代精神运动”（Zeitgeist Movement）的理念。这...

Magicbox
Global site tag (gtag.js) - Google Analytics