move to AS

proj.android-studio/app/.gitignore

@@ -0,0 +1 @@
+/build

proj.android-studio/app/CMakeLists.txt

@@ -0,0 +1,96 @@
+# Sets the minimum version of CMake required to build the native
+# library. You should either keep the default value or only pass a
+# value of 3.4.0 or lower.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds it for you.
+# Gradle automatically packages shared libraries with your APK.
+
+
+add_definitions(-DTARGET_ANDROID)
+
+set(BOOST_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../boost_1_63_0)
+
+set(BOOST_GIL_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/boost-gil-extension)
+
+set(ZIP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/julienr-libzip-android/jni)
+
+set(LIBPNG_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/libpng_1.4.1_android)
+
+set(LIBJPEG_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../libs/jpeg-9")
+
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../../engine)
+
+include_directories(${BOOST_PATH})
+include_directories(${LIBPNG_PATH})
+include_directories(${LIBJPEG_PATH})
+include_directories(${ZIP_PATH})
+
+include_directories(${BOOST_GIL_PATH})
+
+add_library( engine
+             SHARED
+             IMPORTED )
+			 
+set_target_properties( # Specifies the target library.
+                       engine
+
+                       # Specifies the parameter you want to define.
+                       PROPERTIES IMPORTED_LOCATION
+
+                       # Provides the path to the library you want to import.
+                       ${CMAKE_CURRENT_SOURCE_DIR}/build/intermediates/exploded-aar/proj.android-studio/SalmonEngineAndroid/unspecified/jni/${ANDROID_ABI}/libengine.so )
+					   
+
+
+
+add_library( # Sets the name of the library.
+             MountainWallpaper
+
+             # Sets the library as a shared library.
+             SHARED
+
+             # Provides a relative path to your source file(s).
+             # Associated headers in the same location as their source
+             # file are automatically included.
+             ${CMAKE_CURRENT_SOURCE_DIR}/../../game/android_api.cpp
+             ${CMAKE_CURRENT_SOURCE_DIR}/../../game/main_code.cpp
+             )
+			 
+			 
+
+# Searches for a specified prebuilt library and stores the path as a
+# variable. Because system libraries are included in the search path by
+# default, you only need to specify the name of the public NDK library
+# you want to add. CMake verifies that the library exists before
+# completing its build.
+
+find_library( # Sets the name of the path variable.
+              log-lib
+
+              # Specifies the name of the NDK library that
+              # you want CMake to locate.
+              log )
+			  
+find_library( # Sets the name of the path variable.
+              GLESv2-lib
+
+              # Specifies the name of the NDK library that
+              # you want CMake to locate.
+              GLESv2 )
+
+
+# Specifies libraries CMake should link to your target library. You
+# can link multiple libraries, such as libraries you define in the
+# build script, prebuilt third-party libraries, or system libraries.
+
+target_link_libraries( # Specifies the target library.
+                       MountainWallpaper
+
+                       # Links the target library to the log library
+                       # included in the NDK.
+                       ${log-lib} ${GLESv2-lib} engine )

proj.android-studio/app/build.gradle

@@ -0,0 +1,46 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 24
+    buildToolsVersion "24.0.1"
+    defaultConfig {
+        applicationId "fishrungames.mountainwallpaper"
+        minSdkVersion 15
+        targetSdkVersion 24
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        externalNativeBuild {
+            cmake {
+                cppFlags "-std=c++11 -frtti -fexceptions -fsigned-char -Wno-c++11-narrowing"
+            }
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    externalNativeBuild {
+        cmake {
+            path "CMakeLists.txt"
+        }
+    }
+    sourceSets {
+        main {
+            assets.srcDirs = ['../../assets/']
+        }
+    }
+}
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
+        exclude group: 'com.android.support', module: 'support-annotations'
+    })
+    compile 'com.android.support:appcompat-v7:24.2.1'
+    testCompile 'junit:junit:4.12'
+
+    compile project(':SalmonEngineAndroid')
+}

proj.android-studio/app/proguard-rules.pro

@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in C:\Android\sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

proj.android-studio/app/src/androidTest/java/fishrungames/salmonandroidtemplate/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package fishrungames.salmonandroidtemplate;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumentation test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() throws Exception {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getTargetContext();
+
+        assertEquals("fishrungames.salmonandroidtemplate", appContext.getPackageName());
+    }
+}

proj.android-studio/app/src/main/AndroidManifest.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+	package="fishrungames.mountainwallpaper" android:versionCode="1" android:versionName="1.0.0">
+	<application android:label="@string/app_name" android:icon="@drawable/icon" >
+		<activity android:launchMode="standard" android:name=".Prefs">
+			<intent-filter>
+				<category android:name="android.intent.category.PREFERENCE"/>
+				<action android:name="android.intent.action.MAIN"/>
+			</intent-filter>
+		</activity>
+
+		<service android:name="MountainWallpaperService" android:enabled="true"
+			android:icon="@drawable/icon" android:label="@string/app_name"
+			android:permission="android.permission.BIND_WALLPAPER">
+			<intent-filter android:priority="1">
+				<action android:name="android.service.wallpaper.WallpaperService" />
+			</intent-filter>
+			<meta-data android:name="android.service.wallpaper"
+				android:resource="@xml/wallpaper" />
+		</service>
+	</application>
+	<uses-sdk android:minSdkVersion="8" />
+	<uses-feature android:glEsVersion="0x00020000"/>
+
+</manifest>

proj.android-studio/app/src/main/java/fishrungames/mountainwallpaper/GLWallpaperService.java

@@ -0,0 +1,960 @@
+package fishrungames.mountainwallpaper;
+
+
+import fishrungames.mountainwallpaper.BaseConfigChooser.ComponentSizeChooser;
+import fishrungames.mountainwallpaper.BaseConfigChooser.SimpleEGLConfigChooser;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.egl.EGLSurface;
+
+
+import android.service.wallpaper.WallpaperService;
+import android.util.Log;
+import android.view.SurfaceHolder;
+
+import fishrungames.salmonengineandroid.EngineWrapper;
+
+
+public class GLWallpaperService extends WallpaperService {
+	private static final String TAG = "GLWallpaperService";
+
+	@Override
+	public Engine onCreateEngine() {
+		return new GLEngine();
+	}
+
+	public class GLEngine extends Engine {
+		public final static int RENDERMODE_WHEN_DIRTY = 0;
+		public final static int RENDERMODE_CONTINUOUSLY = 1;
+
+		private GLThread mGLThread;
+		private EGLConfigChooser mEGLConfigChooser;
+		private EGLContextFactory mEGLContextFactory;
+		private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
+		
+		private int mDebugFlags;
+
+		public GLEngine() {
+			super();
+		}
+
+		@Override
+		public void onVisibilityChanged(boolean visible) {
+			if (visible) {
+				onResume();
+			} else {
+				onPause();
+			}
+			super.onVisibilityChanged(visible);
+		}
+
+		@Override
+		public void onCreate(SurfaceHolder surfaceHolder) {
+			super.onCreate(surfaceHolder);
+			// Log.d(TAG, "GLEngine.onCreate()");
+		}
+
+		@Override
+		public void onDestroy() {
+			super.onDestroy();
+			// Log.d(TAG, "GLEngine.onDestroy()");
+			mGLThread.requestExitAndWait();
+		}
+
+		@Override
+		public void onSurfaceChanged(SurfaceHolder holder, int format,
+				int width, int height) {
+			// Log.d(TAG, "onSurfaceChanged()");
+			
+
+			
+			mGLThread.onWindowResize(width, height);
+			
+			super.onSurfaceChanged(holder, format, width, height);
+		}
+
+		@Override
+		public void onSurfaceCreated(SurfaceHolder holder) {
+			Log.d(TAG, "onSurfaceCreated()");
+			mGLThread.surfaceCreated(holder);
+			super.onSurfaceCreated(holder);
+		}
+
+		@Override
+		public void onSurfaceDestroyed(SurfaceHolder holder) {
+			Log.d(TAG, "onSurfaceDestroyed()");
+			mGLThread.surfaceDestroyed();
+			super.onSurfaceDestroyed(holder);
+		}
+
+
+		public void setDebugFlags(int debugFlags) {
+			mDebugFlags = debugFlags;
+		}
+
+		public int getDebugFlags() {
+			return mDebugFlags;
+		}
+
+		public void setRenderer() {
+			checkRenderThreadState();
+			if (mEGLConfigChooser == null) {
+				mEGLConfigChooser = new SimpleEGLConfigChooser(true);
+			}
+			if (mEGLContextFactory == null) {
+				//mEGLContextFactory = new DefaultContextFactory();
+				mEGLContextFactory = new ES20ContextFactory();
+			}
+			if (mEGLWindowSurfaceFactory == null) {
+				mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
+			}
+			mGLThread = new GLThread(mEGLConfigChooser,
+					mEGLContextFactory, mEGLWindowSurfaceFactory);
+			mGLThread.start();
+		}
+
+		public void setEGLContextFactory(EGLContextFactory factory) {
+			checkRenderThreadState();
+			mEGLContextFactory = factory;
+		}
+
+		public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {
+			checkRenderThreadState();
+			mEGLWindowSurfaceFactory = factory;
+		}
+
+		public void setEGLConfigChooser(EGLConfigChooser configChooser) {
+			checkRenderThreadState();
+			mEGLConfigChooser = configChooser;
+		}
+
+		public void setEGLConfigChooser(boolean needDepth) {
+			setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));
+		}
+
+		public void setEGLConfigChooser(int redSize, int greenSize,
+				int blueSize, int alphaSize, int depthSize, int stencilSize) {
+			setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,
+					blueSize, alphaSize, depthSize, stencilSize));
+		}
+
+		public void setRenderMode(int renderMode) {
+			mGLThread.setRenderMode(renderMode);
+		}
+
+		public int getRenderMode() {
+			return mGLThread.getRenderMode();
+		}
+
+		public void requestRender() {
+			mGLThread.requestRender();
+		}
+
+		public void onPause() {
+			mGLThread.onPause();
+		}
+
+		public void onResume() {
+			mGLThread.onResume();
+		}
+
+		public void queueEvent(Runnable r) {
+			mGLThread.queueEvent(r);
+		}
+
+		private void checkRenderThreadState() {
+			if (mGLThread != null) {
+				throw new IllegalStateException(
+						"setRenderer has already been called for this instance.");
+			}
+		}
+	}
+}
+
+
+// ----------------------------------------------------------------------
+
+/**
+ * An interface for customizing the eglCreateContext and eglDestroyContext
+ * calls.
+ * 
+ * 
+ * This interface must be implemented by clients wishing to call
+ * {@link GLWallpaperService.GLEngine#setEGLContextFactory(EGLContextFactory)}
+ */
+interface EGLContextFactory {
+	EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig);
+
+	void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);
+}
+
+class DefaultContextFactory implements EGLContextFactory {
+
+	public EGLContext createContext(EGL10 egl, EGLDisplay display,
+			EGLConfig config) {
+		return egl
+				.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, null);
+	}
+
+	public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
+		egl.eglDestroyContext(display, context);
+	}
+}
+
+
+class ES20ContextFactory implements EGLContextFactory {
+
+	private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+	
+	public EGLContext createContext(EGL10 egl, EGLDisplay display,
+			EGLConfig config) {
+		
+		
+		int[] attrib_list =
+				{ EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
+
+		return egl
+				.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, attrib_list);
+	}
+
+	public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
+		egl.eglDestroyContext(display, context);
+	}
+}
+
+/**
+ * An interface for customizing the eglCreateWindowSurface and eglDestroySurface
+ * calls.
+ * 
+ * 
+ * This interface must be implemented by clients wishing to call
+ * {@link GLWallpaperService.GLEngine#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
+ */
+interface EGLWindowSurfaceFactory {
+	EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
+			EGLConfig config, Object nativeWindow);
+
+	void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);
+}
+
+class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
+
+	public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
+			EGLConfig config, Object nativeWindow) {
+		// this is a bit of a hack to work around Droid init problems - if you
+		// don't have this, it'll get hung up on orientation changes
+		EGLSurface eglSurface = null;
+		while (eglSurface == null) {
+			try {
+				eglSurface = egl.eglCreateWindowSurface(display, config,
+						nativeWindow, null);
+			} catch (Throwable t) {
+			} finally {
+				if (eglSurface == null) {
+					try {
+						Thread.sleep(10);
+					} catch (InterruptedException t) {
+					}
+				}
+			}
+		}
+		return eglSurface;
+	}
+
+	public void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface) {
+		egl.eglDestroySurface(display, surface);
+	}
+}
+
+
+class EglHelper {
+
+	private EGL10 mEgl;
+	private EGLDisplay mEglDisplay;
+	private EGLSurface mEglSurface;
+	private EGLContext mEglContext;
+	EGLConfig mEglConfig;
+
+	private EGLConfigChooser mEGLConfigChooser;
+	private EGLContextFactory mEGLContextFactory;
+	private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
+	
+
+	public EglHelper(EGLConfigChooser chooser,
+			EGLContextFactory contextFactory,
+			EGLWindowSurfaceFactory surfaceFactory) {
+		this.mEGLConfigChooser = chooser;
+		this.mEGLContextFactory = contextFactory;
+		this.mEGLWindowSurfaceFactory = surfaceFactory;
+		
+	}
+
+	/**
+	 * Initialize EGL for a given configuration spec.
+	 *
+	 *  configSpec
+	 */
+	public void start() {
+		String instanceId = "";
+		Log.d("EglHelper" + instanceId, "start()");
+		if (mEgl == null) {
+			Log.d("EglHelper" + instanceId, "getting new EGL");
+			/*
+			 * Get an EGL instance
+			 */
+			mEgl = (EGL10) EGLContext.getEGL();
+		} else {
+			Log.d("EglHelper" + instanceId, "reusing EGL");
+		}
+
+		if (mEglDisplay == null) {
+			Log.d("EglHelper" + instanceId, "getting new display");
+			/*
+			 * Get to the default display.
+			 */
+			mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+		} else {
+			Log.d("EglHelper" + instanceId, "reusing display");
+		}
+
+		if (mEglConfig == null) {
+			Log.d("EglHelper" + instanceId, "getting new config");
+			/*
+			 * We can now initialize EGL for that display
+			 */
+			int[] version = new int[2];
+			mEgl.eglInitialize(mEglDisplay, version);
+			mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
+		} else {
+			Log.d("EglHelper" + instanceId, "reusing config");
+		}
+
+		if (mEglContext == null) {
+			Log.d("EglHelper" + instanceId, "creating new context");
+			/*
+			 * Create an OpenGL ES context. This must be done only once, an
+			 * OpenGL context is a somewhat heavy object.
+			 */
+			mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay,
+					mEglConfig);
+			if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
+				throw new RuntimeException("createContext failed");
+			}
+		} else {
+			Log.d("EglHelper" + instanceId, "reusing context");
+		}
+
+		mEglSurface = null;
+	}
+
+	/*
+	 * React to the creation of a new surface by creating and returning an
+	 * OpenGL interface that renders to that surface.
+	 */
+	
+	
+	public void createSurface(SurfaceHolder holder) {
+		
+		if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
+
+			
+			mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
+					EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
+			mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay,
+					mEglSurface);
+		}
+
+		
+		mEglSurface = mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
+				mEglDisplay, mEglConfig, holder);
+
+		if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
+			throw new RuntimeException("createWindowSurface failed");
+		}
+
+	
+		if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+				mEglContext)) {
+			//throw new RuntimeException("eglMakeCurrent failed.");
+		}
+
+		
+	}
+
+	/**
+	 * Display the current render surface.
+	 * 
+	 * @return false if the context has been lost.
+	 */
+	public boolean swap() {
+		try {
+			mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
+		} catch (Exception e) {
+			return false;
+		}
+		
+		return true;
+		
+		
+		/*
+		 * Always check for EGL_CONTEXT_LOST, which means the context and all
+		 * associated data were lost (For instance because the device went to
+		 * sleep). We need to sleep until we get a new surface.
+		 */
+		
+	}
+
+	public void destroySurface() {
+		if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
+			mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
+					EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
+			mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay,
+					mEglSurface);
+			mEglSurface = null;
+		}
+	}
+
+	public void finish() {
+		if (mEglContext != null) {
+			mEGLContextFactory.destroyContext(mEgl, mEglDisplay, mEglContext);
+			mEglContext = null;
+		}
+		if (mEglDisplay != null) {
+			mEgl.eglTerminate(mEglDisplay);
+			mEglDisplay = null;
+		}
+	}
+}
+
+class GLThread extends Thread {
+	private final static boolean LOG_THREADS = false;
+	public final static int DEBUG_CHECK_GL_ERROR = 1;
+	public final static int DEBUG_LOG_GL_CALLS = 2;
+	
+	private final GLThreadManager sGLThreadManager = new GLThreadManager();
+	private GLThread mEglOwner;
+
+	private EGLConfigChooser mEGLConfigChooser;
+	private EGLContextFactory mEGLContextFactory;
+	private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
+	
+
+	public SurfaceHolder mHolder;
+	private boolean mSizeChanged = true;
+
+	// Once the thread is started, all accesses to the following member
+	// variables are protected by the sGLThreadManager monitor
+	public boolean mDone;
+	private boolean mPaused;
+	private boolean mHasSurface;
+	private boolean mWaitingForSurface;
+	private boolean mHaveEgl;
+	private int mWidth;
+	private int mHeight;
+	private int mRenderMode;
+	private boolean mRequestRender;
+	private boolean mEventsWaiting;
+	// End of member variables protected by the sGLThreadManager monitor.
+
+	//private GLWallpaperService.Renderer mRenderer;
+	
+	private ArrayList mEventQueue = new ArrayList();
+	private EglHelper mEglHelper;
+	
+	
+	static long lastTimeStamp;
+	static boolean gameIsInited = false;
+
+	GLThread(EGLConfigChooser chooser,
+			EGLContextFactory contextFactory,
+			EGLWindowSurfaceFactory surfaceFactory) {
+		super();
+		mDone = false;
+		mWidth = 0;
+		mHeight = 0;
+		mRequestRender = true;
+		mRenderMode = GLWallpaperService.GLEngine.RENDERMODE_CONTINUOUSLY;
+		
+		this.mEGLConfigChooser = chooser;
+		this.mEGLContextFactory = contextFactory;
+		this.mEGLWindowSurfaceFactory = surfaceFactory;
+		
+		Calendar c = Calendar.getInstance();
+		lastTimeStamp = c.getTimeInMillis();
+		gameIsInited = true;
+	}
+
+	@Override
+	public void run() {
+		setName("GLThread " + getId());
+		if (LOG_THREADS) {
+			Log.i("GLThread", "starting tid=" + getId());
+		}
+
+		try {
+			guardedRun();
+		} catch (InterruptedException e) {
+			// fall thru and exit normally
+		} finally {
+			sGLThreadManager.threadExiting(this);
+		}
+	}
+
+	/*
+	 * This private method should only be called inside a
+	 * synchronized(sGLThreadManager) block.
+	 */
+	private void stopEglLocked() {
+		if (mHaveEgl) {
+			mHaveEgl = false;
+			mEglHelper.destroySurface();
+			sGLThreadManager.releaseEglSurface(this);
+		}
+	}
+
+	private void guardedRun() throws InterruptedException {
+		mEglHelper = new EglHelper(mEGLConfigChooser, mEGLContextFactory,
+				mEGLWindowSurfaceFactory/*, mGLWrapper*/);
+		try {
+			
+			boolean tellRendererSurfaceCreated = true;
+			boolean tellRendererSurfaceChanged = true;
+
+			/*
+			 * This is our main activity thread's loop, we go until asked to
+			 * quit.
+			 */
+			while (!isDone()) {
+				/*
+				 * Update the asynchronous state (window size)
+				 */
+				int w = 0;
+				int h = 0;
+				boolean changed = false;
+				boolean needStart = false;
+				boolean eventsWaiting = false;
+
+				synchronized (sGLThreadManager) {
+					while (true) {
+						// Manage acquiring and releasing the SurfaceView
+						// surface and the EGL surface.
+						if (mPaused) {
+							stopEglLocked();
+						}
+						if (!mHasSurface) {
+							if (!mWaitingForSurface) {
+								stopEglLocked();
+								mWaitingForSurface = true;
+								sGLThreadManager.notifyAll();
+							}
+						} else {
+							if (!mHaveEgl) {
+								if (sGLThreadManager.tryAcquireEglSurface(this)) {
+									mHaveEgl = true;
+									mEglHelper.start();
+									mRequestRender = true;
+									needStart = true;
+								}
+							}
+						}
+
+						// Check if we need to wait. If not, update any state
+						// that needs to be updated, copy any state that
+						// needs to be copied, and use "break" to exit the
+						// wait loop.
+
+						if (mDone) {
+							return;
+						}
+
+						if (mEventsWaiting) {
+							eventsWaiting = true;
+							mEventsWaiting = false;
+							break;
+						}
+
+						if ((!mPaused)
+								&& mHasSurface
+								&& mHaveEgl
+								&& (mWidth > 0)
+								&& (mHeight > 0)
+								&& (mRequestRender || (mRenderMode == GLWallpaperService.GLEngine.RENDERMODE_CONTINUOUSLY))) {
+							changed = mSizeChanged;
+							w = mWidth;
+							h = mHeight;
+							mSizeChanged = false;
+							mRequestRender = false;
+							if (mHasSurface && mWaitingForSurface) {
+								changed = true;
+								mWaitingForSurface = false;
+								sGLThreadManager.notifyAll();
+							}
+							break;
+						}
+						
+						
+
+						// By design, this is the only place where we wait().
+
+						if (LOG_THREADS) {
+							Log.i("GLThread", "waiting tid=" + getId());
+						}
+						sGLThreadManager.wait();
+					}
+				} // end of synchronized(sGLThreadManager)
+
+				/*
+				 * Handle queued events
+				 */
+				if (eventsWaiting) {
+					Runnable r;
+					while ((r = getEvent()) != null) {
+						r.run();
+						if (isDone()) {
+							return;
+						}
+					}
+					// Go back and see if we need to wait to render.
+					continue;
+				}
+
+				if (needStart) {
+					tellRendererSurfaceCreated = true;
+					changed = true;
+				}
+				if (changed) {
+					mEglHelper.createSurface(mHolder);
+					tellRendererSurfaceChanged = true;
+				}
+				if (tellRendererSurfaceCreated) {
+					
+					tellRendererSurfaceCreated = false;
+				}
+				
+				if (tellRendererSurfaceChanged) {
+					
+					
+					//Xperimental -- VLAD KHOREV
+					JniWrapper.Init(w, h);
+				
+					tellRendererSurfaceChanged = false;
+				}
+				
+				
+				if ((w > 0) && (h > 0)) {
+					/* draw a frame here */
+					
+					if (gameIsInited)
+					{
+						Calendar c = Calendar.getInstance();
+	
+						long currentTimeStamp = c.getTimeInMillis();
+				
+						EngineWrapper.Update(currentTimeStamp - lastTimeStamp);
+					
+						lastTimeStamp = currentTimeStamp;
+
+					}
+					
+					/*
+					 * Once we're done with GL, we need to call swapBuffers() to
+					 * instruct the system to display the rendered frame
+					 */
+					mEglHelper.swap();
+				}
+			}
+		} finally {
+			/*
+			 * clean-up everything...
+			 */
+			synchronized (sGLThreadManager) {
+				stopEglLocked();
+				mEglHelper.finish();
+			}
+		}
+	}
+
+	private boolean isDone() {
+		synchronized (sGLThreadManager) {
+			return mDone;
+		}
+	}
+
+	public void setRenderMode(int renderMode) {
+		if (!((GLWallpaperService.GLEngine.RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= GLWallpaperService.GLEngine.RENDERMODE_CONTINUOUSLY))) {
+			throw new IllegalArgumentException("renderMode");
+		}
+		synchronized (sGLThreadManager) {
+			mRenderMode = renderMode;
+			if (renderMode == GLWallpaperService.GLEngine.RENDERMODE_CONTINUOUSLY) {
+				sGLThreadManager.notifyAll();
+			}
+		}
+	}
+
+	public int getRenderMode() {
+		synchronized (sGLThreadManager) {
+			return mRenderMode;
+		}
+	}
+
+	public void requestRender() {
+		synchronized (sGLThreadManager) {
+			mRequestRender = true;
+			sGLThreadManager.notifyAll();
+		}
+	}
+
+	public void surfaceCreated(SurfaceHolder holder) {
+		mHolder = holder;
+		synchronized (sGLThreadManager) {
+			if (LOG_THREADS) {
+				Log.i("GLThread", "surfaceCreated tid=" + getId());
+			}
+			mHasSurface = true;
+			sGLThreadManager.notifyAll();
+		}
+	}
+
+	public void surfaceDestroyed() {
+		synchronized (sGLThreadManager) {
+			if (LOG_THREADS) {
+				Log.i("GLThread", "surfaceDestroyed tid=" + getId());
+			}
+			mHasSurface = false;
+			sGLThreadManager.notifyAll();
+			while (!mWaitingForSurface && isAlive() && !mDone) {
+				try {
+					sGLThreadManager.wait();
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+				}
+			}
+		}
+	}
+
+	public void onPause() {
+		synchronized (sGLThreadManager) {
+			mPaused = true;
+			sGLThreadManager.notifyAll();
+		}
+	}
+
+	public void onResume() {
+		synchronized (sGLThreadManager) {
+			mPaused = false;
+			mRequestRender = true;
+			sGLThreadManager.notifyAll();
+		}
+	}
+
+	public void onWindowResize(int w, int h) {
+		synchronized (sGLThreadManager) {
+			mWidth = w;
+			mHeight = h;
+			mSizeChanged = true;
+			sGLThreadManager.notifyAll();
+		}
+	}
+
+	public void requestExitAndWait() {
+		// don't call this from GLThread thread or it is a guaranteed
+		// deadlock!
+		synchronized (sGLThreadManager) {
+			mDone = true;
+			sGLThreadManager.notifyAll();
+		}
+		try {
+			join();
+		} catch (InterruptedException ex) {
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	/**
+	 * Queue an "event" to be run on the GL rendering thread.
+	 * 
+	 * @param r
+	 *            the runnable to be run on the GL rendering thread.
+	 */
+	public void queueEvent(Runnable r) {
+		synchronized (this) {
+			mEventQueue.add(r);
+			synchronized (sGLThreadManager) {
+				mEventsWaiting = true;
+				sGLThreadManager.notifyAll();
+			}
+		}
+	}
+
+	private Runnable getEvent() {
+		synchronized (this) {
+			if (mEventQueue.size() > 0) {
+				return (Runnable) mEventQueue.remove(0);
+			}
+
+		}
+		return null;
+	}
+
+	private class GLThreadManager {
+
+		public synchronized void threadExiting(GLThread thread) {
+			if (LOG_THREADS) {
+				Log.i("GLThread", "exiting tid=" + thread.getId());
+			}
+			thread.mDone = true;
+			if (mEglOwner == thread) {
+				mEglOwner = null;
+			}
+			notifyAll();
+		}
+
+		/*
+		 * Tries once to acquire the right to use an EGL surface. Does not
+		 * block.
+		 * 
+		 * @return true if the right to use an EGL surface was acquired.
+		 */
+		public synchronized boolean tryAcquireEglSurface(GLThread thread) {
+			if (mEglOwner == thread || mEglOwner == null) {
+				mEglOwner = thread;
+				notifyAll();
+				return true;
+			}
+			return false;
+		}
+
+		public synchronized void releaseEglSurface(GLThread thread) {
+			if (mEglOwner == thread) {
+				mEglOwner = null;
+			}
+			notifyAll();
+		}
+	}
+}
+
+interface EGLConfigChooser {
+	EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);
+}
+
+abstract class BaseConfigChooser implements EGLConfigChooser {
+	public BaseConfigChooser(int[] configSpec) {
+		mConfigSpec = configSpec;
+	}
+
+	public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
+		int[] num_config = new int[1];
+		egl.eglChooseConfig(display, mConfigSpec, null, 0, num_config);
+
+		int numConfigs = num_config[0];
+
+		if (numConfigs <= 0) {
+			throw new IllegalArgumentException("No configs match configSpec");
+		}
+
+		EGLConfig[] configs = new EGLConfig[numConfigs];
+		egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
+				num_config);
+		EGLConfig config = chooseConfig(egl, display, configs);
+		if (config == null) {
+			throw new IllegalArgumentException("No config chosen");
+		}
+		return config;
+	}
+
+	abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+			EGLConfig[] configs);
+
+	protected int[] mConfigSpec;
+
+	public static class ComponentSizeChooser extends BaseConfigChooser {
+		public ComponentSizeChooser(int redSize, int greenSize, int blueSize,
+				int alphaSize, int depthSize, int stencilSize) {
+			super(new int[] { EGL10.EGL_RED_SIZE, redSize,
+					EGL10.EGL_GREEN_SIZE, greenSize, EGL10.EGL_BLUE_SIZE,
+					blueSize, EGL10.EGL_ALPHA_SIZE, alphaSize,
+					EGL10.EGL_DEPTH_SIZE, depthSize, EGL10.EGL_STENCIL_SIZE,
+					stencilSize, EGL10.EGL_NONE });
+			mValue = new int[1];
+			mRedSize = redSize;
+			mGreenSize = greenSize;
+			mBlueSize = blueSize;
+			mAlphaSize = alphaSize;
+			mDepthSize = depthSize;
+			mStencilSize = stencilSize;
+		}
+
+		@Override
+		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+				EGLConfig[] configs) {
+			EGLConfig closestConfig = null;
+			int closestDistance = 1000;
+			for (EGLConfig config : configs) {
+				int d = findConfigAttrib(egl, display, config,
+						EGL10.EGL_DEPTH_SIZE, 0);
+				int s = findConfigAttrib(egl, display, config,
+						EGL10.EGL_STENCIL_SIZE, 0);
+				if (d >= mDepthSize && s >= mStencilSize) {
+					int r = findConfigAttrib(egl, display, config,
+							EGL10.EGL_RED_SIZE, 0);
+					int g = findConfigAttrib(egl, display, config,
+							EGL10.EGL_GREEN_SIZE, 0);
+					int b = findConfigAttrib(egl, display, config,
+							EGL10.EGL_BLUE_SIZE, 0);
+					int a = findConfigAttrib(egl, display, config,
+							EGL10.EGL_ALPHA_SIZE, 0);
+					int distance = Math.abs(r - mRedSize)
+							+ Math.abs(g - mGreenSize)
+							+ Math.abs(b - mBlueSize)
+							+ Math.abs(a - mAlphaSize);
+					if (distance < closestDistance) {
+						closestDistance = distance;
+						closestConfig = config;
+					}
+				}
+			}
+			return closestConfig;
+		}
+
+		private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+				EGLConfig config, int attribute, int defaultValue) {
+
+			if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+				return mValue[0];
+			}
+			return defaultValue;
+		}
+
+		private int[] mValue;
+		// Subclasses can adjust these values:
+		protected int mRedSize;
+		protected int mGreenSize;
+		protected int mBlueSize;
+		protected int mAlphaSize;
+		protected int mDepthSize;
+		protected int mStencilSize;
+	}
+
+	/**
+	 * This class will choose a supported surface as close to RGB565 as
+	 * possible, with or without a depth buffer.
+	 * 
+	 */
+	public static class SimpleEGLConfigChooser extends ComponentSizeChooser {
+		public SimpleEGLConfigChooser(boolean withDepthBuffer) {
+			super(4, 4, 4, 0, withDepthBuffer ? 16 : 0, 0);
+			// Adjust target values. This way we'll accept a 4444 or
+			// 555 buffer if there's no 565 buffer available.
+			mRedSize = 5;
+			mGreenSize = 6;
+			mBlueSize = 5;
+		}
+	}
+}

proj.android-studio/app/src/main/java/fishrungames/mountainwallpaper/JniWrapper.java

@@ -0,0 +1,25 @@
+package fishrungames.mountainwallpaper;
+
+public class JniWrapper
+{
+
+	static
+	{
+		System.loadLibrary("MountainWallpaper");
+	}
+	
+	public static void LoadLibrary()
+	{
+		//To force loading libraries
+	}
+	
+	public static native void SetTimeOfDayPref(int timeofday);
+	
+	public static native void SetSnowPref(boolean snow);
+	
+	
+	public static native void Init(int width, int height);
+	
+	public static native void SetOffset(float offsetX, float offsetY);
+
+}

proj.android-studio/app/src/main/java/fishrungames/mountainwallpaper/MountainWallpaperService.java

@@ -0,0 +1,233 @@
+package fishrungames.mountainwallpaper;
+
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+
+import android.net.ConnectivityManager;
+
+import android.os.Handler;
+import android.preference.PreferenceManager;
+
+import android.view.MotionEvent;
+import android.view.SurfaceHolder;
+
+//import com.seb.SLWP.SLWP.GlEngine.DownloadTask;
+
+import fishrungames.salmonengineandroid.EngineWrapper;
+
+public class MountainWallpaperService extends GLWallpaperService implements
+		OnSharedPreferenceChangeListener {
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see android.app.Service#onLowMemory()
+	 */
+	static
+	{
+		EngineWrapper.LoadSalmonEngineLibrary();
+		JniWrapper.LoadLibrary();
+	}
+
+
+	public static final long SLEEPTIME = 1000 * 60 * 30; // 30 minutes
+	private GlEngine mGle;
+	
+	public static Context mContext;
+	public static boolean ShowClouds;
+	public static boolean TouchRot;
+	
+	public static int Bg;
+	public static boolean Usebg;
+	public static int Tex;
+	
+	static long Synctime;
+	
+	public boolean Slidedir;
+	public boolean Slideplanet;
+	public boolean Syncrot;
+	public static boolean Randomtex = true;
+	public static boolean visible = false;
+	
+	public static boolean useCropper = true;
+	public static int Cropaspect;
+	public static boolean loading = false;
+	
+	public static final Handler mHandler = new Handler();
+	public static final int RNDMAP = -1;
+	public static boolean destroyed;
+	public static String bgfile;
+	public ConnectivityManager cm;
+	public boolean needresume;
+	public boolean fstart;
+	public static String[] randlist;
+	public int curtexidx = -99;
+
+	static final String ACTION_FOREGROUND = "fishrungames.mountainwallpaper.FOREGROUND";
+	static final String ACTION_BACKGROUND = "fishrungames.mountainwallpaper.BACKGROUND";
+		
+
+
+	@Override
+	public void onCreate() {
+		// TODO Auto-generated method stub
+		super.onCreate();
+		
+		
+		PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(this);
+
+		EngineWrapper.SetActivityInstance(this);
+		EngineWrapper.SetupEnviroment();
+		
+		String apkFilePath = null;
+		ApplicationInfo appInfo = null;
+		PackageManager packMgmr = this.getPackageManager();
+		try {
+		        appInfo = packMgmr.getApplicationInfo("fishrungames.mountainwallpaper", 0);
+		    } catch (NameNotFoundException e) {
+		 
+	
+	
+		 e.printStackTrace();
+		throw new RuntimeException("Unable to locate assets, aborting...");
+		    }
+		apkFilePath = appInfo.sourceDir;
+		
+		EngineWrapper.SetupApkFilePath(apkFilePath);
+		
+		Init();
+	}
+
+	@Override
+	public int onStartCommand(Intent intent, int flags, int startId) {
+		// handleCommand(intent);
+		// We want this service to continue running until it is explicitly
+		// stopped, so return sticky.
+		return START_STICKY;
+	}
+
+	private void Init() {
+		try {
+			mContext = this;
+			cm = (ConnectivityManager) mContext
+					.getSystemService(Context.CONNECTIVITY_SERVICE);
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Override
+	public void onDestroy() {
+		// TODO Auto-generated method stub
+		super.onDestroy();
+	}
+
+	@Override
+	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
+			String key) {
+		
+		if (key.compareToIgnoreCase("Timeofday") == 0)
+		{
+			int time = Integer.parseInt(sharedPreferences.getString("Timeofday", "0"));
+			JniWrapper.SetTimeOfDayPref(time);
+		}
+		
+		if (key.compareToIgnoreCase("Snow") == 0) {
+			
+			JniWrapper.SetSnowPref(sharedPreferences.getBoolean("Snow", false));
+
+		}
+	}
+
+	@Override
+	public Engine onCreateEngine() {
+		if (mGle != null) {
+			mGle = null;
+		}
+		try {
+			
+			mGle = new GlEngine();
+			
+		} catch (Exception e) {
+			return null;
+		}
+
+		return mGle;
+	}
+
+	class GlEngine extends GLEngine {
+
+		public Handler mHandler = new Handler();
+		
+		long NOW;
+		
+		@Override
+		public void onCreate(SurfaceHolder surfaceHolder) {
+			super.onCreate(surfaceHolder);
+			try {
+				this.setTouchEventsEnabled(true);
+				fstart = true;
+				setRenderer();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+
+		@Override
+		public void onTouchEvent(MotionEvent e) {
+			
+			return;
+		}
+
+		@Override
+		public void onOffsetsChanged(float xOffset, float yOffset,
+				float xOffsetStep, float yOffsetStep, int xPixelOffset,
+				int yPixelOffset) {
+			
+			super.onOffsetsChanged(xOffset, yOffset, xOffsetStep, yOffsetStep,
+					xPixelOffset, yPixelOffset);
+			
+			JniWrapper.SetOffset(xPixelOffset*xOffsetStep, yPixelOffset*yOffsetStep);
+			
+		}
+
+		@Override
+		public void onVisibilityChanged(boolean visible) {
+			// TODO Auto-generated method stub
+			super.onVisibilityChanged(visible);
+			MountainWallpaperService.visible = visible;
+			if (visible) {
+
+			} else {
+
+			}
+		}
+
+		@Override
+		public void onPause() {
+			super.onPause();
+		}
+
+		@Override
+		public void onResume() {
+			
+			super.onResume();
+		}
+
+		@Override
+		public void onSurfaceChanged(SurfaceHolder holder, int format,
+				int width, int height) {
+			// TODO Auto-generated method stub
+			super.onSurfaceChanged(holder, format, width, height);
+			fstart = true;
+		}
+
+	}
+
+}

proj.android-studio/app/src/main/java/fishrungames/mountainwallpaper/Prefs.java

@@ -0,0 +1,72 @@
+package fishrungames.mountainwallpaper;
+
+import fishrungames.mountainwallpaper.R;
+import fishrungames.mountainwallpaper.JniWrapper;
+
+
+import android.content.Intent;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+
+import android.preference.Preference.OnPreferenceChangeListener;
+
+
+public class Prefs extends PreferenceActivity implements
+		OnPreferenceChangeListener {
+
+	
+	private CheckBoxPreference snowPref;
+	private ListPreference timeOfDayPref;
+	
+
+	public static Uri currImageURI;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.prefliste);
+		addPreferencesFromResource(R.xml.preferences);
+		
+		
+		snowPref = (CheckBoxPreference)this.getPreferenceManager().findPreference("Snow");
+		timeOfDayPref = (ListPreference) findPreference("Timeofday");
+		
+		if (timeOfDayPref.getKey().compareToIgnoreCase("Timeofday") == 0)
+		{
+			JniWrapper.SetTimeOfDayPref(Integer.parseInt((String) timeOfDayPref.getValue()));
+			
+		}
+		
+		if (snowPref.getKey().compareToIgnoreCase("Snow") == 0) {
+			if (!snowPref.isChecked())
+			{
+				JniWrapper.SetSnowPref(false);
+			}
+			else
+			{
+				JniWrapper.SetSnowPref(true);
+			}
+		}	
+
+	}
+
+
+	@Override
+	public boolean onPreferenceChange(Preference preference, Object newValue) {
+		
+		return true;
+
+	}
+
+
+	@Override
+	public void onActivityResult(int requestCode, int resultCode, Intent data) {
+		
+	}
+
+}

proj.android-studio/app/src/main/res/layout/main.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    >
+</LinearLayout>

proj.android-studio/app/src/main/res/layout/prefliste.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  android:orientation="vertical" android:layout_height="fill_parent" android:layout_width="fill_parent">
+<RelativeLayout android:id="@+id/LinearLayout01" android:layout_height="wrap_content" android:layout_width="fill_parent"><ImageView android:id="@+id/ImageView01" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/icon" android:layout_alignParentLeft="true" android:layout_marginLeft="3dp"></ImageView>
+</RelativeLayout>
+<ListView android:layout_width="fill_parent" android:id="@+id/android:list" android:layout_height="wrap_content"></ListView>
+<TextView android:layout_width="fill_parent" android:id="@+id/android:text_feedback" android:padding="20px" android:text="@string/feedback" android:layout_height="wrap_content"></TextView>
+
+</LinearLayout>

proj.android-studio/app/src/main/res/values-cs/strings.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Horská odražené</string>
+	<string name="description">Horská odráží ve vodě, s účinkem sněhu</string>
+	<string name="feedback">Pokud dojde k chybě aplikace, prosím, kontaktujte mě: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Sněžení</string>
+	<string name="p_snow_on">Sněžení je zapnuta</string>
+	<string name="p_snow_off">Sněžení je vypnutý</string>
+	
+	<string name="p_timeofday">Denní čas</string>
+	<string name="p_stimeofday">Vyberte si čas dne</string>
+		
+	
+	<string-array name="timeofday_id">
+		<item>Den</item>
+		<item>Přeháňky den</item>
+		<item>Noc</item>
+	</string-array>
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-de/strings.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Reflektierte Berg</string>
+	<string name="description">Berg spiegelt sich im Wasser, mit dem Effekt der Schnee</string>
+	<string name="feedback">Wenn die Anwendung abstürzt, bitte kontaktieren Sie mich: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Schneefall</string>
+	<string name="p_snow_on">Schneefall ist eingeschaltet</string>
+	<string name="p_snow_off">Schneefall ausgeschaltet</string>
+	
+	<string name="p_timeofday">Zeit des Tages</string>
+	<string name="p_stimeofday">Wählen Sie die Zeit des Tages</string>
+	
+	<string-array name="timeofday_id">
+		<item>Day</item>
+		<item>Bewölkten Day</item>
+		<item>Night</item>
+	</string-array>
+	
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-es/strings.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Montaña que se refleja</string>
+	<string name="description">Montaña que se refleja en el agua con efectos nevada</string>
+	<string name="feedback">Si la aplicación se bloquea, por favor póngase en contacto conmigo: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Las nevadas</string>
+	<string name="p_snow_on">Las nevadas se enciende</string>
+	<string name="p_snow_off">Las nevadas se apaga</string>
+	
+	<string name="p_timeofday">La hora del día</string>
+	<string name="p_stimeofday">Elija la hora del día</string>
+	
+	
+	<string-array name="timeofday_id">
+		<item>Día</item>
+		<item>Día nublado</item>
+		<item>Noche</item>
+	</string-array>
+	
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-fr/strings.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Montagne réfléchie</string>
+	<string name="description">Montagne reflète dans l\'eau avec des effets des chutes de neige</string>
+	<string name="feedback">Si l\'application se bloque, s\'il vous plaît contactez-moi : mephi1984@gmail.com</string>
+
+	<string name="p_snow">Chutes de neige</string>
+	<string name="p_snow_on">Chutes de neige est en marche</string>
+	<string name="p_snow_off">Chutes de neige est éteint</string>
+	
+	<string name="p_timeofday">L\'heure du jour</string>
+	<string name="p_stimeofday">Choisissez le moment de la journée</string>
+	
+	<string-array name="timeofday_id">
+		<item>Jour</item>
+		<item>Temps nuageux</item>
+		<item>Nuit</item>
+	</string-array>
+	
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-it/strings.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Montagna riflessa</string>
+	<string name="description">Montagna riflessa nell\'acqua, con l\'effetto di neve</string>
+	<string name="feedback">Se l\'applicazione si blocca, si prega di contattare me: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Nevicate</string>
+	<string name="p_snow_on">Nevicate si accende</string>
+	<string name="p_snow_off">Nevicata è spento</string>
+	
+	<string name="p_timeofday">Il momento della giornata</string>
+	<string name="p_stimeofday">Scegliere il momento della giornata</string>
+	
+	
+	
+	<string-array name="timeofday_id">
+		<item>Giorno</item>
+		<item>Giornata nuvolosa</item>
+		<item>Notte</item>
+	</string-array>
+	
+	
+	<string-array name="timeofday_value">
+		<item>0</item>
+		<item>1</item>
+		<item>2</item>
+	</string-array>
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-nl/strings.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Reflected berg</string>
+	<string name="description">Mountain weerspiegeld in het water met sneeuwval effecten</string>
+	<string name="feedback">Als de toepassing crasht, neem dan contact met mij op: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Sneeuwval</string>
+	<string name="p_snow_on">Sneeuwval is ingeschakeld</string>
+	<string name="p_snow_off">Sneeuwval is uitgeschakeld</string>
+	
+	<string name="p_timeofday">Tijd van de dag</string>
+	<string name="p_stimeofday">Kies de tijd van de dag</string>
+	
+	<string-array name="timeofday_id">
+		<item>Dag</item>
+		<item>Bewolkte dag</item>
+		<item>Nacht</item>
+	</string-array>
+	
+
+</resources>
+

proj.android-studio/app/src/main/res/values-pt/strings.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Montanha refletidas</string>
+	<string name="description">Montanha refletida na água com efeitos queda de neve</string>
+	<string name="feedback">Se o aplicativo falha, por favor contacte-me: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Queda de neve</string>
+	<string name="p_snow_on">Neve está ligado</string>
+	<string name="p_snow_off">Neve está desligado</string>
+	
+	<string name="p_timeofday">Hora do dia</string>
+	<string name="p_stimeofday">Escolha a hora do dia</string>
+	
+	
+	<string-array name="timeofday_id">
+		<item>Dia</item>
+		<item>Dia nublado</item>
+		<item>Noite</item>
+	</string-array>
+
+	
+</resources>
+

proj.android-studio/app/src/main/res/values-ru/strings.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Отраженная гора</string>
+	<string name="description">Гора, отраженная в воде, с эффектом снегопада</string>
+	<string name="feedback">Если приложение падает, пожалуйста, свяжитесь со мною: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Снегопад</string>
+	<string name="p_snow_on">Снегопад включен</string>
+	<string name="p_snow_off">Снегопад выключен</string>
+	
+	<string name="p_timeofday">Время суток</string>
+	<string name="p_stimeofday">Выберите время суток</string>
+	
+	
+	<string-array name="timeofday_id">
+		<item>День</item>
+		<item>Облачный день</item>
+		<item>Ночь</item>
+	</string-array>
+	
+
+</resources>
+

proj.android-studio/app/src/main/res/values/strings.xml

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+	<string name="app_name">Reflected mountain</string>
+	<string name="description">Mountain reflected in the water with snow effects</string>
+	<string name="feedback">If wallpaper crashes or something else goes wrong, please, contact with me: mephi1984@gmail.com</string>
+
+	<string name="p_snow">Snow</string>
+	<string name="p_snow_on">Snow is on</string>
+	<string name="p_snow_off">Snow is off</string>
+	
+	<string name="p_timeofday">Time of day</string>
+	<string name="p_stimeofday">Choose time of day to display</string>
+	
+	<declare-styleable name="Wallpaper">
+		<!--
+			Component name of an activity that allows the user to modify the
+			current settings for this wallpaper.
+		-->
+		<attr name="settingsActivity" format="reference" />
+		<!-- Reference to a the wallpaper's thumbnail bitmap. -->
+		<attr name="thumbnail" format="reference" />
+		<!-- Name of the author of this component, e.g. Google. -->
+		<attr name="author" format="reference" />
+		<!-- Short description of the component's purpose or behavior. -->
+		<attr name="description" format="reference" />
+	</declare-styleable>
+	
+	
+	<string-array name="timeofday_id">
+		<item>Day</item>
+		<item>Cloudy day</item>
+		<item>Night</item>
+	</string-array>
+	
+	
+	<string-array name="timeofday_value">
+		<item>0</item>
+		<item>1</item>
+		<item>2</item>
+	</string-array>
+	
+</resources>
+

proj.android-studio/app/src/main/res/xml/preferences.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen android:title="Main"
+	xmlns:android="http://schemas.android.com/apk/res/android">
+	
+	<ListPreference
+			android:key="Timeofday" android:summary="@string/p_stimeofday"
+			android:title="@string/p_timeofday" android:entries="@array/timeofday_id"
+			android:entryValues="@array/timeofday_value" android:defaultValue="0"/>
+			<CheckBoxPreference android:summaryOn="@string/p_snow_on"
+			android:key="Snow" android:title="@string/p_snow"
+			android:summaryOff="@string/p_snow_off" android:defaultValue="false" />
+
+</PreferenceScreen>

proj.android-studio/app/src/main/res/xml/wallpaper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wallpaper 
+    xmlns:android="http://schemas.android.com/apk/res/android"  
+    android:thumbnail="@drawable/thumb" 
+    android:description="@string/description"
+    android:settingsActivity="fishrungames.mountainwallpaper.Prefs"/>

proj.android-studio/app/src/test/java/fishrungames/salmonandroidtemplate/ExampleUnitTest.java

@@ -0,0 +1,17 @@
+package fishrungames.salmonandroidtemplate;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() throws Exception {
+        assertEquals(4, 2 + 2);
+    }
+}