\n * Wrapping is typically used for debugging purposes.\n *
\n * The default value is null.\n * @param glWrapper the new GLWrapper\n */\n public void setGLWrapper(GLWrapper glWrapper) {\n mGLWrapper = glWrapper;\n }\n\n /**\n * Set the debug flags to a new value. The value is\n * constructed by OR-together zero or more\n * of the DEBUG_CHECK_* constants. The debug flags take effect\n * whenever a surface is created. The default value is zero.\n * @param debugFlags the new debug flags\n * @see #DEBUG_CHECK_GL_ERROR\n * @see #DEBUG_LOG_GL_CALLS\n */\n public void setDebugFlags(int debugFlags) {\n mDebugFlags = debugFlags;\n }\n\n /**\n * Get the current value of the debug flags.\n * @return the current value of the debug flags.\n */\n public int getDebugFlags() {\n return mDebugFlags;\n }\n\n /**\n * Control whether the EGL context is preserved when the GLSurfaceView is paused and\n * resumed.\n *
\n * If set to true, then the EGL context may be preserved when the GLSurfaceView is paused.\n * Whether the EGL context is actually preserved or not depends upon whether the\n * Android device that the program is running on can support an arbitrary number of EGL\n * contexts or not. Devices that can only support a limited number of EGL contexts must\n * release the EGL context in order to allow multiple applications to share the GPU.\n *
\n * If set to false, the EGL context will be released when the GLSurfaceView is paused,\n * and recreated when the GLSurfaceView is resumed.\n *
\n *\n * The default is false.\n *\n * @param preserveOnPause preserve the EGL context when paused\n */\n public void setPreserveEGLContextOnPause(boolean preserveOnPause) {\n mPreserveEGLContextOnPause = preserveOnPause;\n }\n\n /**\n * @return true if the EGL context will be preserved when paused\n */\n public boolean getPreserveEGLContextOnPause() {\n return mPreserveEGLContextOnPause;\n }\n\n /**\n * Set the renderer associated with this view. Also starts the thread that\n * will call the renderer, which in turn causes the rendering to start.\n *
This method should be called once and only once in the life-cycle of\n * a GLSurfaceView.\n *
The following GLSurfaceView methods can only be called before\n * setRenderer is called:\n *
\n * The following GLSurfaceView methods can only be called after\n * setRenderer is called:\n *
If this method is\n * called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
\n * If this method is not called, then by default\n * a context will be created with no shared context and\n * with a null attribute list.\n */\n public void setEGLContextFactory(EGLContextFactory factory) {\n checkRenderThreadState();\n mEGLContextFactory = factory;\n }\n\n /**\n * Install a custom EGLWindowSurfaceFactory.\n *
If this method is\n * called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
\n * If this method is not called, then by default\n * a window surface will be created with a null attribute list.\n */\n public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {\n checkRenderThreadState();\n mEGLWindowSurfaceFactory = factory;\n }\n\n /**\n * Install a custom EGLConfigChooser.\n *
If this method is\n * called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
\n * If no setEGLConfigChooser method is called, then by default the\n * view will choose an EGLConfig that is compatible with the current\n * android.view.Surface, with a depth buffer depth of\n * at least 16 bits.\n * @param configChooser\n */\n public void setEGLConfigChooser(EGLConfigChooser configChooser) {\n checkRenderThreadState();\n mEGLConfigChooser = configChooser;\n }\n\n /**\n * Install a config chooser which will choose a config\n * as close to 16-bit RGB as possible, with or without an optional depth\n * buffer as close to 16-bits as possible.\n *
If this method is\n * called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
\n * If no setEGLConfigChooser method is called, then by default the\n * view will choose an RGB_888 surface with a depth buffer depth of\n * at least 16 bits.\n *\n * @param needDepth\n */\n public void setEGLConfigChooser(boolean needDepth) {\n setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));\n }\n\n /**\n * Install a config chooser which will choose a config\n * with at least the specified depthSize and stencilSize,\n * and exactly the specified redSize, greenSize, blueSize and alphaSize.\n *
If this method is\n * called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
\n * If no setEGLConfigChooser method is called, then by default the\n * view will choose an RGB_888 surface with a depth buffer depth of\n * at least 16 bits.\n *\n */\n public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,\n int alphaSize, int depthSize, int stencilSize) {\n setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,\n blueSize, alphaSize, depthSize, stencilSize));\n }\n\n /**\n * Inform the default EGLContextFactory and default EGLConfigChooser\n * which EGLContext client version to pick.\n *
Use this method to create an OpenGL ES 2.0-compatible context.\n * Example:\n *
\n * public MyView(Context context) {\n * super(context);\n * setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context.\n * setRenderer(new MyRenderer());\n * }\n * \n * Note: Activities which require OpenGL ES 2.0 should indicate this by\n * setting @lt;uses-feature android:glEsVersion=\"0x00020000\" in the activity's\n * AndroidManifest.xml file.\n *
If this method is called, it must be called before {@link #setRenderer(Renderer)}\n * is called.\n *
This method only affects the behavior of the default EGLContexFactory and the\n * default EGLConfigChooser. If\n * {@link #setEGLContextFactory(EGLContextFactory)} has been called, then the supplied\n * EGLContextFactory is responsible for creating an OpenGL ES 2.0-compatible context.\n * If\n * {@link #setEGLConfigChooser(EGLConfigChooser)} has been called, then the supplied\n * EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible config.\n * @param version The EGLContext client version to choose. Use 2 for OpenGL ES 2.0\n */\n public void setEGLContextClientVersion(int version) {\n checkRenderThreadState();\n mEGLContextClientVersion = version;\n }\n\n /**\n * Set the rendering mode. When renderMode is\n * RENDERMODE_CONTINUOUSLY, the renderer is called\n * repeatedly to re-render the scene. When renderMode\n * is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface\n * is created, or when {@link #requestRender} is called. Defaults to RENDERMODE_CONTINUOUSLY.\n *
\n * Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance\n * by allowing the GPU and CPU to idle when the view does not need to be updated.\n *
\n * This method can only be called after {@link #setRenderer(Renderer)}\n *\n * @param renderMode one of the RENDERMODE_X constants\n * @see #RENDERMODE_CONTINUOUSLY\n * @see #RENDERMODE_WHEN_DIRTY\n */\n public void setRenderMode(int renderMode) {\n mGLThread.setRenderMode(renderMode);\n }\n\n /**\n * Get the current rendering mode. May be called\n * from any thread. Must not be called before a renderer has been set.\n * @return the current rendering mode.\n * @see #RENDERMODE_CONTINUOUSLY\n * @see #RENDERMODE_WHEN_DIRTY\n */\n public int getRenderMode() {\n return mGLThread.getRenderMode();\n }\n\n /**\n * Request that the renderer render a frame.\n * This method is typically used when the render mode has been set to\n * {@link #RENDERMODE_WHEN_DIRTY}, so that frames are only rendered on demand.\n * May be called\n * from any thread. Must not be called before a renderer has been set.\n */\n public void requestRender() {\n mGLThread.requestRender();\n }\n\n @Override\n public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {\n mGLThread.surfaceCreated();\n }\n\n @Override\n public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {\n mGLThread.onWindowResize(width, height);\n }\n\n @Override\n protected void onSizeChanged(int w, int h, int oldw, int oldh) {\n super.onSizeChanged(w, h, oldw, oldh);\n mGLThread.onWindowResize(w, h);\n }\n\n @Override\n public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {\n mGLThread.surfaceDestroyed();\n return true;\n }\n\n @Override\n public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {\n requestRender();\n }\n\n /**\n * This method is part of the SurfaceHolder.Callback interface, and is\n * not normally called or subclassed by clients of GLSurfaceView.\n */\n public void on(SurfaceHolder holder) {\n mGLThread.surfaceCreated();\n }\n\n /**\n * Inform the view that the activity is paused. The owner of this view must\n * call this method when the activity is paused. Calling this method will\n * pause the rendering thread.\n * Must not be called before a renderer has been set.\n */\n public void onPause() {\n mGLThread.onPause();\n }\n\n /**\n * Inform the view that the activity is resumed. The owner of this view must\n * call this method when the activity is resumed. Calling this method will\n * recreate the OpenGL display and resume the rendering\n * thread.\n * Must not be called before a renderer has been set.\n */\n public void onResume() {\n mGLThread.onResume();\n }\n\n /**\n * Queue a runnable to be run on the GL rendering thread. This can be used\n * to communicate with the Renderer on the rendering thread.\n * Must not be called before a renderer has been set.\n * @param r the runnable to be run on the GL rendering thread.\n */\n public void queueEvent(Runnable r) {\n mGLThread.queueEvent(r);\n }\n\n /**\n * This method is used as part of the View class and is not normally\n * called or subclassed by clients of GLSurfaceView.\n */\n @Override\n protected void onAttachedToWindow() {\n super.onAttachedToWindow();\n if (LOG_ATTACH_DETACH) {\n Log.d(TAG, \"onAttachedToWindow reattach =\" + mDetached);\n }\n if (mDetached && (mRenderer != null)) {\n int renderMode = RENDERMODE_CONTINUOUSLY;\n if (mGLThread != null) {\n renderMode = mGLThread.getRenderMode();\n }\n mGLThread = new GLThread(mThisWeakRef);\n if (renderMode != RENDERMODE_CONTINUOUSLY) {\n mGLThread.setRenderMode(renderMode);\n }\n mGLThread.start();\n }\n mDetached = false;\n }\n\n /**\n * This method is used as part of the View class and is not normally\n * called or subclassed by clients of GLSurfaceView.\n * Must not be called before a renderer has been set.\n */\n @Override\n protected void onDetachedFromWindow() {\n if (LOG_ATTACH_DETACH) {\n Log.d(TAG, \"onDetachedFromWindow\");\n }\n if (mGLThread != null) {\n mGLThread.requestExitAndWait();\n }\n mDetached = true;\n super.onDetachedFromWindow();\n }\n\n // ----------------------------------------------------------------------\n\n /**\n * An interface used to wrap a GL interface.\n *
Typically\n * used for implementing debugging and tracing on top of the default\n * GL interface. You would typically use this by creating your own class\n * that implemented all the GL methods by delegating to another GL instance.\n * Then you could add your own behavior before or after calling the\n * delegate. All the GLWrapper would do was instantiate and return the\n * wrapper GL instance:\n *
\n * class MyGLWrapper implements GLWrapper {\n * GL wrap(GL gl) {\n * return new MyGLImplementation(gl);\n * }\n * static class MyGLImplementation implements GL,GL10,GL11,... {\n * ...\n * }\n * }\n * \n * @see #setGLWrapper(GLWrapper)\n */\n public interface GLWrapper {\n /**\n * Wraps a gl interface in another gl interface.\n * @param gl a GL interface that is to be wrapped.\n * @return either the input argument or another GL object that wraps the input argument.\n */\n GL wrap(GL gl);\n }\n\n /**\n * An interface for customizing the eglCreateContext and eglDestroyContext calls.\n * \n * This interface must be implemented by clients wishing to call\n *\n */\n public interface EGLContextFactory {\n EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig);\n void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);\n }\n\n private class DefaultContextFactory implements EGLContextFactory {\n private int EGL_CONTEXT_CLIENT_VERSION = 0x3098;\n\n public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {\n int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion,\n EGL10.EGL_NONE };\n\n return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,\n mEGLContextClientVersion != 0 ? attrib_list : null);\n }\n\n public void destroyContext(EGL10 egl, EGLDisplay display,\n EGLContext context) {\n if (!egl.eglDestroyContext(display, context)) {\n Log.e(\"DefaultContextFactory\", \"display:\" + display + \" context: \" + context);\n if (LOG_THREADS) {\n Log.i(\"DefaultContextFactory\", \"tid=\" + Thread.currentThread().getId());\n }\n EglHelper.throwEglException(\"eglDestroyContex\", egl.eglGetError());\n }\n }\n }\n\n /**\n * An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.\n *
\n * This interface must be implemented by clients wishing to call\n *\n */\n public interface EGLWindowSurfaceFactory {\n /**\n * @return null if the surface cannot be constructed.\n */\n EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,\n Object nativeWindow);\n void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);\n }\n\n private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {\n\n public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,\n EGLConfig config, Object nativeWindow) {\n EGLSurface result = null;\n try {\n result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);\n } catch (IllegalArgumentException e) {\n // This exception indicates that the surface flinger surface\n // is not valid. This can happen if the surface flinger surface has\n // been torn down, but the application has not yet been\n // notified via SurfaceHolder.Callback.surfaceDestroyed.\n // In theory the application should be notified first,\n // but in practice sometimes it is not. See b/4588890\n Log.e(TAG, \"eglCreateWindowSurface\", e);\n }\n return result;\n }\n\n public void destroySurface(EGL10 egl, EGLDisplay display,\n EGLSurface surface) {\n egl.eglDestroySurface(display, surface);\n }\n }\n\n /**\n * An interface for choosing an EGLConfig configuration from a list of\n * potential configurations.\n *
\n * This interface must be implemented by clients wishing to call\n *\n */\n public interface EGLConfigChooser {\n /**\n * Choose a configuration from the list. Implementors typically\n * implement this method by calling\n * {@link javax.microedition.khronos.egl.EGL10#eglChooseConfig} and iterating through the results. Please consult the\n * EGL specification available from The Khronos Group to learn how to call eglChooseConfig.\n * @param egl the EGL10 for the current display.\n * @param display the current display.\n * @return the chosen configuration.\n */\n EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);\n }\n\n private abstract class BaseConfigChooser\n implements EGLConfigChooser {\n public BaseConfigChooser(int[] configSpec) {\n mConfigSpec = filterConfigSpec(configSpec);\n }\n\n public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {\n int[] num_config = new int[1];\n if (!egl.eglChooseConfig(display, mConfigSpec, null, 0,\n num_config)) {\n throw new IllegalArgumentException(\"eglChooseConfig failed\");\n }\n\n int numConfigs = num_config[0];\n\n if (numConfigs <= 0) {\n throw new IllegalArgumentException(\n \"No configs match configSpec\");\n }\n\n EGLConfig[] configs = new EGLConfig[numConfigs];\n if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,\n num_config)) {\n throw new IllegalArgumentException(\"eglChooseConfig#2 failed\");\n }\n EGLConfig config = chooseConfig(egl, display, configs);\n if (config == null) {\n throw new IllegalArgumentException(\"No config chosen\");\n }\n return config;\n }\n\n abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,\n EGLConfig[] configs);\n\n protected int[] mConfigSpec;\n\n private int[] filterConfigSpec(int[] configSpec) {\n if (mEGLContextClientVersion != 2) {\n return configSpec;\n }\n /* We know none of the subclasses define EGL_RENDERABLE_TYPE.\n * And we know the configSpec is well formed.\n */\n int len = configSpec.length;\n int[] newConfigSpec = new int[len + 2];\n System.arraycopy(configSpec, 0, newConfigSpec, 0, len-1);\n newConfigSpec[len-1] = EGL10.EGL_RENDERABLE_TYPE;\n newConfigSpec[len] = 4; /* EGL_OPENGL_ES2_BIT */\n newConfigSpec[len+1] = EGL10.EGL_NONE;\n return newConfigSpec;\n }\n }\n\n /**\n * Choose a configuration with exactly the specified r,g,b,a sizes,\n * and at least the specified depth and stencil sizes.\n */\n private class ComponentSizeChooser extends BaseConfigChooser {\n public ComponentSizeChooser(int redSize, int greenSize, int blueSize,\n int alphaSize, int depthSize, int stencilSize) {\n super(new int[] {\n EGL10.EGL_RED_SIZE, redSize,\n EGL10.EGL_GREEN_SIZE, greenSize,\n EGL10.EGL_BLUE_SIZE, blueSize,\n EGL10.EGL_ALPHA_SIZE, alphaSize,\n EGL10.EGL_DEPTH_SIZE, depthSize,\n EGL10.EGL_STENCIL_SIZE, stencilSize,\n EGL10.EGL_NONE});\n mValue = new int[1];\n mRedSize = redSize;\n mGreenSize = greenSize;\n mBlueSize = blueSize;\n mAlphaSize = alphaSize;\n mDepthSize = depthSize;\n mStencilSize = stencilSize;\n }\n\n @Override\n public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,\n EGLConfig[] configs) {\n for (EGLConfig config : configs) {\n int d = findConfigAttrib(egl, display, config,\n EGL10.EGL_DEPTH_SIZE, 0);\n int s = findConfigAttrib(egl, display, config,\n EGL10.EGL_STENCIL_SIZE, 0);\n if ((d >= mDepthSize) && (s >= mStencilSize)) {\n int r = findConfigAttrib(egl, display, config,\n EGL10.EGL_RED_SIZE, 0);\n int g = findConfigAttrib(egl, display, config,\n EGL10.EGL_GREEN_SIZE, 0);\n int b = findConfigAttrib(egl, display, config,\n EGL10.EGL_BLUE_SIZE, 0);\n int a = findConfigAttrib(egl, display, config,\n EGL10.EGL_ALPHA_SIZE, 0);\n if ((r == mRedSize) && (g == mGreenSize)\n && (b == mBlueSize) && (a == mAlphaSize)) {\n return config;\n }\n }\n }\n return null;\n }\n\n private int findConfigAttrib(EGL10 egl, EGLDisplay display,\n EGLConfig config, int attribute, int defaultValue) {\n\n if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {\n return mValue[0];\n }\n return defaultValue;\n }\n\n private int[] mValue;\n // Subclasses can adjust these values:\n protected int mRedSize;\n protected int mGreenSize;\n protected int mBlueSize;\n protected int mAlphaSize;\n protected int mDepthSize;\n protected int mStencilSize;\n }\n\n /**\n * This class will choose a RGB_888 surface with\n * or without a depth buffer.\n *\n */\n private class SimpleEGLConfigChooser extends ComponentSizeChooser {\n public SimpleEGLConfigChooser(boolean withDepthBuffer) {\n super(8, 8, 8, 0, withDepthBuffer ? 16 : 0, 0);\n }\n }\n\n /**\n * An EGL helper class.\n */\n\n private static class EglHelper {\n public EglHelper(WeakReferenceinBitmap is given, a sub-bitmap might be returned.\n */\n public synchronized Bitmap decodeRegion(Rect rect, Options options) {\n int unsampledInBitmapWidth = -1;\n int unsampledInBitmapHeight = -1;\n int sampleSize = Math.max(1, options != null ? options.inSampleSize : 1);\n if (options != null && options.inBitmap != null) {\n unsampledInBitmapWidth = options.inBitmap.getWidth() * sampleSize;\n unsampledInBitmapHeight = options.inBitmap.getHeight() * sampleSize;\n }\n\n // Decode with rotation\n switch (mRotation) {\n case 90:\n mTempRect.set(\n rect.top, mOriginalHeight - rect.right,\n rect.bottom, mOriginalHeight - rect.left);\n break;\n\n case 180:\n mTempRect.set(\n mOriginalWidth - rect.right, mOriginalHeight - rect.bottom,\n mOriginalWidth - rect.left, mOriginalHeight - rect.top);\n break;\n\n case 270:\n mTempRect.set(\n mOriginalWidth - rect.bottom, rect.left,\n mOriginalWidth - rect.top, rect.right);\n break;\n\n default:\n mTempRect.set(rect);\n }\n\n Bitmap bitmap = mBitmapRegionDecoder.decodeRegion(mTempRect, options);\n if (options != null && options.inBitmap != null &&\n ((mTempRect.width() != unsampledInBitmapWidth\n || mTempRect.height() != unsampledInBitmapHeight))) {\n // Need to extract the sub-bitmap\n Bitmap subBitmap = Bitmap.createBitmap(\n bitmap, 0, 0,\n mTempRect.width() / sampleSize,\n mTempRect.height() / sampleSize);\n if (bitmap != options.inBitmap) {\n bitmap.recycle();\n }\n bitmap = subBitmap;\n }\n\n if (mRotateMatrix != null) {\n // Rotate decoded bitmap\n Bitmap rotatedBitmap = Bitmap.createBitmap(bitmap, 0, 0,\n bitmap.getWidth(), bitmap.getHeight(),\n mRotateMatrix, true);\n if (options == null || bitmap != options.inBitmap) {\n bitmap.recycle();\n }\n bitmap = rotatedBitmap;\n }\n\n return bitmap;\n }\n\n public synchronized int getWidth() {\n return (mRotation == 90 || mRotation == 270) ? mOriginalHeight : mOriginalWidth;\n }\n\n public synchronized int getHeight() {\n return (mRotation == 90 || mRotation == 270) ? mOriginalWidth : mOriginalHeight;\n }\n\n public synchronized void destroy() {\n mBitmapRegionDecoder.recycle();\n mBitmapRegionDecoder = null;\n try {\n mInputStream.close();\n } catch (IOException ignored) {\n ignored.printStackTrace();\n }\n }\n}\n"
},
{
"path": "library/src/main/java/com/roger/missview/library/util/ImageBlurrer.java",
"content": "/*\n * Copyright 2014 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.roger.missview.library.util;\n\nimport android.content.Context;\nimport android.graphics.Bitmap;\nimport android.renderscript.Allocation;\nimport android.renderscript.Element;\nimport android.renderscript.Matrix3f;\nimport android.renderscript.RenderScript;\nimport android.renderscript.ScriptIntrinsicBlur;\nimport android.renderscript.ScriptIntrinsicColorMatrix;\n\npublic class ImageBlurrer {\n public static final int MAX_SUPPORTED_BLUR_PIXELS = 25;\n private RenderScript mRS;\n\n private ScriptIntrinsicBlur mSIBlur;\n private ScriptIntrinsicColorMatrix mSIGrey;\n private Allocation mTmp1;\n private Allocation mTmp2;\n\n public ImageBlurrer(Context context) {\n mRS = RenderScript.create(context);\n mSIBlur = ScriptIntrinsicBlur.create(mRS, Element.U8_4(mRS));\n mSIGrey = ScriptIntrinsicColorMatrix.create(mRS);\n }\n\n public Bitmap blurBitmap(Bitmap src, float radius, float desaturateAmount) {\n Bitmap dest = Bitmap.createBitmap(src);\n if ((int) radius == 0) {\n return dest;\n }\n\n if (mTmp1 != null) {\n mTmp1.destroy();\n }\n if (mTmp2 != null) {\n mTmp2.destroy();\n }\n\n mTmp1 = Allocation.createFromBitmap(mRS, src);\n mTmp2 = Allocation.createFromBitmap(mRS, dest);\n\n mSIBlur.setRadius((int) radius);\n mSIBlur.setInput(mTmp1);\n mSIBlur.forEach(mTmp2);\n\n if (desaturateAmount > 0) {\n desaturateAmount = MathUtil.constrain(0, 1, desaturateAmount);\n Matrix3f m = new Matrix3f(new float[]{\n MathUtil.interpolate(1, 0.299f, desaturateAmount),\n MathUtil.interpolate(0, 0.299f, desaturateAmount),\n MathUtil.interpolate(0, 0.299f, desaturateAmount),\n\n MathUtil.interpolate(0, 0.587f, desaturateAmount),\n MathUtil.interpolate(1, 0.587f, desaturateAmount),\n MathUtil.interpolate(0, 0.587f, desaturateAmount),\n\n MathUtil.interpolate(0, 0.114f, desaturateAmount),\n MathUtil.interpolate(0, 0.114f, desaturateAmount),\n MathUtil.interpolate(1, 0.114f, desaturateAmount),\n });\n mSIGrey.setColorMatrix(m);\n mSIGrey.forEach(mTmp2, mTmp1);\n mTmp1.copyTo(dest);\n } else {\n mTmp2.copyTo(dest);\n }\n return dest;\n }\n\n public void destroy() {\n mSIBlur.destroy();\n if (mTmp1 != null) {\n mTmp1.destroy();\n }\n if (mTmp2 != null) {\n mTmp2.destroy();\n }\n mRS.destroy();\n }\n}\n"
},
{
"path": "library/src/main/java/com/roger/missview/library/util/ImageUtil.java",
"content": "/*\n * Copyright 2014 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.roger.missview.library.util;\n\nimport android.graphics.Bitmap;\nimport android.graphics.Color;\n\npublic class ImageUtil {\n // Make sure input images are very small!\n public static float calculateDarkness(Bitmap bitmap) {\n if (bitmap == null) {\n return 0;\n }\n\n int width = bitmap.getWidth();\n int height = bitmap.getHeight();\n\n int totalLum = 0;\n int n = 0;\n int x, y, color;\n for (y = 0; y < height; y++) {\n for (x = 0; x < width; x++) {\n ++n;\n color = bitmap.getPixel(x, y);\n totalLum += (0.21f * Color.red(color)\n + 0.71f * Color.green(color)\n + 0.07f * Color.blue(color));\n }\n }\n\n return (totalLum / n) / 256f;\n }\n\n private ImageUtil() {\n }\n\n public static int calculateSampleSize(int rawHeight, int targetHeight) {\n int sampleSize = 1;\n while (rawHeight / (sampleSize << 1) > targetHeight) {\n sampleSize <<= 1;\n }\n return sampleSize;\n }\n}\n"
},
{
"path": "library/src/main/java/com/roger/missview/library/util/MathUtil.java",
"content": "/*\n * Copyright 2014 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.roger.missview.library.util;\n\nimport android.util.FloatMath;\n\npublic class MathUtil {\n public static float constrain(float min, float max, float v) {\n return Math.max(min, Math.min(max, v));\n }\n\n public static float interpolate(float x1, float x2, float f) {\n return x1 + (x2 - x1) * f;\n }\n\n public static float uninterpolate(float x1, float x2, float v) {\n if (x2 - x1 == 0) {\n throw new IllegalArgumentException(\"Can't reverse interpolate with domain size of 0\");\n }\n return (v - x1) / (x2 - x1);\n }\n\n public static float dist(float x, float y) {\n return FloatMath.sqrt(x * x + y * y);\n }\n\n public static int floorEven(int num) {\n return num & ~0x01;\n }\n\n public static int roundMult4(int num) {\n return (num + 2) & ~0x03;\n }\n\n public static boolean isEven(int num) {\n return num % 2 == 0;\n }\n\n private MathUtil() {\n }\n}\n"
},
{
"path": "library/src/main/java/com/roger/missview/library/util/TickingFloatAnimator.java",
"content": "/*\n * Copyright 2014 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.roger.missview.library.util;\n\nimport android.animation.TimeInterpolator;\nimport android.os.SystemClock;\nimport android.view.animation.AccelerateDecelerateInterpolator;\n\n// Non thread-safe\npublic class TickingFloatAnimator {\n private float mStartValue = 0;\n private float mCurrentValue;\n private float mEndValue;\n private boolean mRunning = false;\n private long mStartTime;\n private int mDuration = 1000;\n private Runnable mEndCallback;\n private TimeInterpolator mInterpolator = new AccelerateDecelerateInterpolator();\n\n public static TickingFloatAnimator create() {\n return new TickingFloatAnimator();\n }\n\n public TickingFloatAnimator from(float startValue) {\n cancel();\n mStartValue = startValue;\n mCurrentValue = startValue;\n return this;\n }\n\n public TickingFloatAnimator to(float endValue) {\n mEndValue = endValue;\n return this;\n }\n\n public TickingFloatAnimator withDuration(int duration) {\n mDuration = Math.max(0, duration);\n return this;\n }\n\n public TickingFloatAnimator withInterpolator(TimeInterpolator interpolator) {\n mInterpolator = interpolator;\n return this;\n }\n\n public TickingFloatAnimator withEndListener(Runnable listener) {\n mEndCallback = listener;\n return this;\n }\n\n public void cancel() {\n mRunning = false;\n mEndValue = mCurrentValue;\n }\n\n public boolean tick() {\n if (!mRunning) {\n return false;\n }\n\n float t;\n if (mDuration <= 0) {\n t = 1;\n } else {\n t = (float) (SystemClock.elapsedRealtime() - mStartTime) * 1f / mDuration;\n if (t >= 1) {\n t = 1;\n }\n }\n\n if (t >= 1) {\n // Ended\n mRunning = false;\n mCurrentValue = mEndValue;\n if (mEndCallback != null) {\n mEndCallback.run();\n }\n return false;\n }\n\n // Still running; compute value\n mCurrentValue = mStartValue + mInterpolator.getInterpolation(t) * (mEndValue - mStartValue);\n mRunning = true;\n return true;\n }\n\n public void start() {\n mRunning = true;\n mStartValue = mCurrentValue;\n mStartTime = SystemClock.elapsedRealtime();\n tick();\n }\n\n public boolean isRunning() {\n return mRunning;\n }\n\n public float currentValue() {\n return mCurrentValue;\n }\n\n private TickingFloatAnimator() {\n }\n}\n"
},
{
"path": "library/src/main/java/com/roger/missview/library/util/UriUtil.java",
"content": "package com.roger.missview.library.util;\n\nimport android.annotation.TargetApi;\nimport android.content.ContentUris;\nimport android.content.Context;\nimport android.database.Cursor;\nimport android.net.Uri;\nimport android.os.Environment;\nimport android.provider.DocumentsContract;\nimport android.provider.MediaStore;\n\n/**\n * Created by Administrator on 2015/4/28.\n */\npublic class UriUtil {\n /**\n * 根据Uri获取图片绝对路径，解决Android4.4以上版本Uri转换\n * @param context\n * @param imageUri\n */\n @TargetApi(19)\n public static String getImageAbsolutePath(Context context, Uri imageUri) {\n if (context == null || imageUri == null)\n return null;\n if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, imageUri)) {\n if (isExternalStorageDocument(imageUri)) {\n String docId = DocumentsContract.getDocumentId(imageUri);\n String[] split = docId.split(\":\");\n String type = split[0];\n if (\"primary\".equalsIgnoreCase(type)) {\n return Environment.getExternalStorageDirectory() + \"/\" + split[1];\n }\n } else if (isDownloadsDocument(imageUri)) {\n String id = DocumentsContract.getDocumentId(imageUri);\n Uri contentUri = ContentUris.withAppendedId(Uri.parse(\"content://downloads/public_downloads\"), Long.valueOf(id));\n return getDataColumn(context, contentUri, null, null);\n } else if (isMediaDocument(imageUri)) {\n String docId = DocumentsContract.getDocumentId(imageUri);\n String[] split = docId.split(\":\");\n String type = split[0];\n Uri contentUri = null;\n if (\"image\".equals(type)) {\n contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;\n } else if (\"video\".equals(type)) {\n contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;\n } else if (\"audio\".equals(type)) {\n contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;\n }\n String selection = MediaStore.Images.Media._ID + \"=?\";\n String[] selectionArgs = new String[] { split[1] };\n return getDataColumn(context, contentUri, selection, selectionArgs);\n }\n } // MediaStore (and general)\n else if (\"content\".equalsIgnoreCase(imageUri.getScheme())) {\n // Return the remote address\n if (isGooglePhotosUri(imageUri))\n return imageUri.getLastPathSegment();\n return getDataColumn(context, imageUri, null, null);\n }\n // File\n else if (\"file\".equalsIgnoreCase(imageUri.getScheme())) {\n return imageUri.getPath();\n }\n return null;\n }\n\n public static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {\n Cursor cursor = null;\n String column = MediaStore.Images.Media.DATA;\n String[] projection = { column };\n try {\n cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);\n if (cursor != null && cursor.moveToFirst()) {\n int index = cursor.getColumnIndexOrThrow(column);\n return cursor.getString(index);\n }\n } finally {\n if (cursor != null)\n cursor.close();\n }\n return null;\n }\n\n /**\n * @param uri The Uri to check.\n * @return Whether the Uri authority is ExternalStorageProvider.\n */\n public static boolean isExternalStorageDocument(Uri uri) {\n return \"com.android.externalstorage.documents\".equals(uri.getAuthority());\n }\n\n /**\n * @param uri The Uri to check.\n * @return Whether the Uri authority is DownloadsProvider.\n */\n public static boolean isDownloadsDocument(Uri uri) {\n return \"com.android.providers.downloads.documents\".equals(uri.getAuthority());\n }\n\n /**\n * @param uri The Uri to check.\n * @return Whether the Uri authority is MediaProvider.\n */\n public static boolean isMediaDocument(Uri uri) {\n return \"com.android.providers.media.documents\".equals(uri.getAuthority());\n }\n\n /**\n * @param uri The Uri to check.\n * @return Whether the Uri authority is Google Photos.\n */\n public static boolean isGooglePhotosUri(Uri uri) {\n return \"com.google.android.apps.photos.content\".equals(uri.getAuthority());\n }\n}\n"
},
{
"path": "settings.gradle",
"content": "include ':library', ':demo'\n"
}
]