Blog

private void createLayoutManager(Context context, String className, AttributeSet attrs,
            int defStyleAttr, int defStyleRes) {
        if (className != null) {
            className = className.trim();
            if (className.length() != 0) {  // Can't use isEmpty since it was added in API 9.
                className = getFullClassName(context, className);
                try {
                    ClassLoader classLoader;
                    if (isInEditMode()) {
                        // Stupid layoutlib cannot handle simple class loaders.
                        classLoader = this.getClass().getClassLoader();
                    } else {
                        classLoader = context.getClassLoader();
                    }
                    Class<? extends LayoutManager> layoutManagerClass =
                            classLoader.loadClass(className).asSubclass(LayoutManager.class);
                    Constructor<? extends LayoutManager> constructor;
                    Object[] constructorArgs = null;
                    try {
                        constructor = layoutManagerClass
                                .getConstructor(LAYOUT_MANAGER_CONSTRUCTOR_SIGNATURE);
                        constructorArgs = new Object[]{context, attrs, defStyleAttr, defStyleRes};
                    } catch (NoSuchMethodException e) {
                        try {
                            constructor = layoutManagerClass.getConstructor();
                        } catch (NoSuchMethodException e1) {
                            e1.initCause(e);
                            throw new IllegalStateException(attrs.getPositionDescription() +
                                    ": Error creating LayoutManager " + className, e1);
                        }
                    }
                    constructor.setAccessible(true);
                    setLayoutManager(constructor.newInstance(constructorArgs));
                } catch (ClassNotFoundException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Unable to find LayoutManager " + className, e);
                } catch (InvocationTargetException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Could not instantiate the LayoutManager: " + className, e);
                } catch (InstantiationException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Could not instantiate the LayoutManager: " + className, e);
                } catch (IllegalAccessException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Cannot access non-public constructor " + className, e);
                } catch (ClassCastException e) {
                    throw new IllegalStateException(attrs.getPositionDescription()
                            + ": Class is not a LayoutManager " + className, e);
                }
            }
        }
    }

public void setLayoutManager(LayoutManager layout) {
        if (layout == mLayout) {
            return;
        }
        //停止滚动
        stopScroll();
        // TODO We should do this switch a dispachLayout pass and animate children. There is a good
        // chance that LayoutManagers will re-use views.
        if (mLayout != null) {
            if (mIsAttached) {
                mLayout.dispatchDetachedFromWindow(this, mRecycler);
            }
            mLayout.setRecyclerView(null);
        }
        //清空缓存
        mRecycler.clear();
        mChildHelper.removeAllViewsUnfiltered();
        mLayout = layout;
        if (layout != null) {
            if (layout.mRecyclerView != null) {
                throw new IllegalArgumentException("LayoutManager " + layout +
                        " is already attached to a RecyclerView: " + layout.mRecyclerView);
            }
            mLayout.setRecyclerView(this);
            if (mIsAttached) {
                mLayout.dispatchAttachedToWindow(this);
            }
        }
        requestLayout();
    }

protected void onMeasure(int widthSpec, int heightSpec) {
        if (mLayout == null) {
            defaultOnMeasure(widthSpec, heightSpec);
            return;
        }
        if (mLayout.mAutoMeasure) {
            final int widthMode = MeasureSpec.getMode(widthSpec);
            final int heightMode = MeasureSpec.getMode(heightSpec);
            final boolean skipMeasure = widthMode == MeasureSpec.EXACTLY
                    && heightMode == MeasureSpec.EXACTLY;
            mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
            if (skipMeasure || mAdapter == null) {
                return;
            }
            if (mState.mLayoutStep == State.STEP_START) {
                dispatchLayoutStep1();
            }
            // set dimensions in 2nd step. Pre-layout should happen with old dimensions for
            // consistency
            mLayout.setMeasureSpecs(widthSpec, heightSpec);
            mState.mIsMeasuring = true;
            dispatchLayoutStep2();

            // now we can get the width and height from the children.
            mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);

            // if RecyclerView has non-exact width and height and if there is at least one child
            // which also has non-exact width & height, we have to re-measure.
            if (mLayout.shouldMeasureTwice()) {
                mLayout.setMeasureSpecs(
                        MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY),
                        MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY));
                mState.mIsMeasuring = true;
                dispatchLayoutStep2();
                // now we can get the width and height from the children.
                mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);
            }
        } else {
            if (mHasFixedSize) {
                mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
                return;
            }
            // custom onMeasure
            if (mAdapterUpdateDuringMeasure) {
                eatRequestLayout();
                processAdapterUpdatesAndSetAnimationFlags();

                if (mState.mRunPredictiveAnimations) {
                    mState.mInPreLayout = true;
                } else {
                    // consume remaining updates to provide a consistent state with the layout pass.
                    mAdapterHelper.consumeUpdatesInOnePass();
                    mState.mInPreLayout = false;
                }
                mAdapterUpdateDuringMeasure = false;
                resumeRequestLayout(false);
            }

            if (mAdapter != null) {
                mState.mItemCount = mAdapter.getItemCount();
            } else {
                mState.mItemCount = 0;
            }
            eatRequestLayout();
            mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);
            resumeRequestLayout(false);
            mState.mInPreLayout = false; // clear
        }
    }

/**
    * Used when onMeasure is called before layout manager is set
    */
   void defaultOnMeasure(int widthSpec, int heightSpec) {
       // calling LayoutManager here is not pretty but that API is already public and it is better
       // than creating another method since this is internal.
       final int width = LayoutManager.chooseSize(widthSpec,
               getPaddingLeft() + getPaddingRight(),
               ViewCompat.getMinimumWidth(this));
       final int height = LayoutManager.chooseSize(heightSpec,
               getPaddingTop() + getPaddingBottom(),
               ViewCompat.getMinimumHeight(this));

       setMeasuredDimension(width, height);
   }

/**
    * The first step of a layout where we;
    * - process adapter updates
    * - decide which animation should run
    * - save information about current views
    * - If necessary, run predictive layout and save its information
    */

private void dispatchLayoutStep2() {
        eatRequestLayout();
        onEnterLayoutOrScroll();
        mState.assertLayoutStep(State.STEP_LAYOUT | State.STEP_ANIMATIONS);
        mAdapterHelper.consumeUpdatesInOnePass();
        mState.mItemCount = mAdapter.getItemCount();
        mState.mDeletedInvisibleItemCountSincePreviousLayout = 0;

        // Step 2: Run layout
        mState.mInPreLayout = false;
        mLayout.onLayoutChildren(mRecycler, mState);

        mState.mStructureChanged = false;
        mPendingSavedState = null;

        // onLayoutChildren may have caused client code to disable item animations; re-check
        mState.mRunSimpleAnimations = mState.mRunSimpleAnimations && mItemAnimator != null;
        mState.mLayoutStep = State.STEP_ANIMATIONS;
        onExitLayoutOrScroll();
        resumeRequestLayout(false);
    }

@Override
   protected void onLayout(boolean changed, int l, int t, int r, int b) {
       TraceCompat.beginSection(TRACE_ON_LAYOUT_TAG);
       dispatchLayout();
       TraceCompat.endSection();
       mFirstLayoutComplete = true;
   }

void dispatchLayout() {
       if (mAdapter == null) {
           Log.e(TAG, "No adapter attached; skipping layout");
           // leave the state in START
           return;
       }
       if (mLayout == null) {
           Log.e(TAG, "No layout manager attached; skipping layout");
           // leave the state in START
           return;
       }
       mState.mIsMeasuring = false;
       if (mState.mLayoutStep == State.STEP_START) {
           dispatchLayoutStep1();
           mLayout.setExactMeasureSpecsFrom(this);
           dispatchLayoutStep2();
       } else if (mAdapterHelper.hasUpdates() || mLayout.getWidth() != getWidth() ||
               mLayout.getHeight() != getHeight()) {
           // First 2 steps are done in onMeasure but looks like we have to run again due to
           // changed size.
           mLayout.setExactMeasureSpecsFrom(this);
           dispatchLayoutStep2();
       } else {
           // always make sure we sync them (to ensure mode is exact)
           mLayout.setExactMeasureSpecsFrom(this);
       }
       dispatchLayoutStep3();
   }

@Override
   public void onDraw(Canvas c) {
       super.onDraw(c);

       final int count = mItemDecorations.size();
       for (int i = 0; i < count; i++) {
           mItemDecorations.get(i).onDraw(c, this, mState);
       }
   }

attribute vec4 a_Position;

void main() {
	gl_Position = a_Position;
}

precision mediump float;

uniform vec4 u_Color;

void main() {
	gl_FragColor = u_Color;
}

public class TextureResourceReader {
    public static String readTextFileFromResource(Context context, int resId) {
        StringBuilder sb = new StringBuilder();

        try {
            InputStream is = context.getResources().openRawResource(resId);
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String nextLine;

            while ((nextLine = br.readLine()) != null) {
                sb.append(nextLine);
                sb.append('\n');
            }
        } catch (IOException e) {
            throw new RuntimeException("Could not open resource: " + resId, e);
        } catch (Resources.NotFoundException e) {
            throw new RuntimeException("Resource not found: " + resId, e);
        }
        return sb.toString();
    }
}

@Override protected String readVertexShader() {
        return TextureResourceReader.readTextFileFromResource(mContext, R.raw.simple_vertex_shader);
    }

    @Override protected String readFragmentShader() {
        return TextureResourceReader.readTextFileFromResource(mContext,
                                                              R.raw.simple_fragment_shader);
    }

public static int compileVertexShader(String shaderCode) {
       return compileShader(GL_VERTEX_SHADER, shaderCode);
   }

   public static int compileFragmentShader(String shaderCode) {
       return compileShader(GL_FRAGMENT_SHADER, shaderCode);
   }
   
private static int compileShader(int type, String shaderCode) {
       final int shaderObjectId = glCreateShader(type);

       if (shaderObjectId == 0) {
           LogHelper.w(TAG, "Could not create new shader.");
           return 0;
       }

       glShaderSource(shaderObjectId, shaderCode);
       glCompileShader(shaderObjectId);

       final int[] compileStatus = new int[1];
       glGetShaderiv(shaderObjectId, GL_COMPILE_STATUS, compileStatus, 0);

       LogHelper.v(TAG,
                   "Results of compiling source:" + "\n" + shaderCode + "\n" + glGetShaderInfoLog(
                           shaderObjectId));

       if (compileStatus[0] == 0) {
           glDeleteShader(shaderObjectId);

           LogHelper.w(TAG, "Compilation of shader failed");
           return 0;
       }

       return shaderObjectId;
   }

public static int linkProgram(int vertextShaderId, int fragmentShaderId) {
       final int programObjectId = glCreateProgram();

       if (programObjectId == 0) {
           LogHelper.w(TAG, "Could not create new program");
           return 0;
       }

       glAttachShader(programObjectId, vertextShaderId);
       glAttachShader(programObjectId, fragmentShaderId);

       glLinkProgram(programObjectId);

       final int[] status = new int[1];
       glGetProgramiv(programObjectId, GL_LINK_STATUS, status, 0);

       LogHelper.v(TAG, "Result of linking program: \n" + glGetProgramInfoLog(programObjectId));

       if (status[0] == 0) {
           glDeleteProgram(programObjectId);
           LogHelper.w(TAG, "Linking of program failed.");
           return 0;
       }

       return programObjectId;
   }

glGetUniformLocation(program, U_COLOR);
	

glGetAttribLocation(program, A_COLOR);

vertexData.position(0);
//****** very import method *******//
glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GL_FLOAT, false, STRIDE,
                      vertexData);

glEnableVertexAttribArray(aPositionLocation);

glClear(GL_COLOR_BUFFER_BIT);

//set triangle color
//glUniform4f(uColorLocation, 1.0f, 1.0f, 1.0f, 1.0f);
//draw two triangles
glDrawArrays(GL_TRIANGLE_FAN, 0, 6);

//set line color
//glUniform4f(uColorLocation, 1.0f, 0.0f, 0.0f, 1.0f);
glDrawArrays(GL_LINES, 6, 2);

//draw the first blue mallets
//glUniform4f(uColorLocation, 0.0f, 0.0f, 1.0f, 1.0f);
glDrawArrays(GL_POINTS, 8, 1);

//draw the second red mallets
//glUniform4f(uColorLocation, 1.0f, 0.0f, 0.0f, 1.0f);
glDrawArrays(GL_POINTS, 9, 1);

interface Updatable {
    void update();
}
 
interface Observable {
   void addUpdatable(Updatable u);
   void removeUpdatable(Updatable u);
}

public final class DoOnUpdate implements Observable {
    final Observable source;
 
    final Runnable action;
 
    final ConcurrentHashMap<Updatable, DoOnUpdatable> map;
 
    public DoOnUpdate(Observable source, Runnable action) {
         this.source = source;
         this.action = action;
         this.map = new ConcurrentHashMap<>();
    }
 
    @Override
    public void addUpdatable(Updatable u) {
        DoOnUpdatable wrapper = new DoOnUpdatable(u, action);
        if (map.putIfAbsent(u, wrapper) != null) {
            throw new IllegalStateException("Updatable already registered");
        }
        source.addUpdatable(wrapper);
    }
 
    public void removeUpdatable(Updatable u) {
        DoOnUpdatable wrapper = map.remove(u);
        if (wrapper == null) {
            throw new IllegalStateException("Updatable already removed");
        }
        source.removeUpdatable(wrapper);
    }
 
    static final class DoOnUpdatable {
        final Updatable actual;
 
        final Runnable run;
 
        public DoOnUpdatable(Updatable actual, Runnable run) {
            this.actual = actual;
            this.run = run;
        }
 
        @Override
        public void update() {
            run.run();
            actual.update();
        }
    }
}

Observable source = ...
source.addUpdatable(() -> System.out.println("Something happened"));

source.removeUpdatable(() -> System.out.println("Something happened");

Updatable u = () -> System.out.println("Something happened");
 
source.addUpdatable(u);
 
// ...
 
source.removeUpdatable(u);

interface Removable extends Closeable {
    @Override
    void close(); // remove the necessity of try-catch around close()
}
 
public static Removable registerWith(Observable source, Updatable consumer) {
    source.addUpdatable(consumer);
    return () -> source.removeUpdatable(consumer);
}

public static Removable registerWith(Observable source, Updatable consumer) {
    source.addUpdatable(consumer);
    final AtomicBoolean once = new AtomicBoolean();
    return () -> {
        if (once.compareAndSet(false, true)) {
            source.removeUpdatable(consumer);
        }
    });
}

MutableRepository<integer> repo = Repositories.mutableRepository(0);
 
repo.addUpdatable(() -> System.out.println("Value: " + repo.get());
 
new Thread(() -> {
    repo.accept(1);
}).start();

Set<Integer> set = new HashSet<>();
 
MutableRepository<integer> repo = Repositories.mutableRepository(0);
 
repo.addUpdatable(() -> set.add(repo.get()));
 
new Thread(() -> {
    for (int i = 0; i < 100_000; i++) {
        repo.accept(i);
    }
}).start();
 
Thread.sleep(20_000);
 
System.out.println(set.size());

rx.Observable<Void> signaller = ...
 
rx.Observer<Void> consumer = ...
 
Subscription s = signaller.subscribe(consumer);
 
// ...
 
s.unsubscribe();

interface Observable {
    Removable register(Updatable u);
}
 
interface Removable {
    void remove();
}

interface Observable {
    void register(Updatable u);
}
 
interface Updatable {
    void onRegister(Removable remover);
    void update();
}
 
// or
 
interface Updatable {
    void update(Removable remover);
}

interface Updatable {
    void onRegister(Removable remover);
    void update();
    void error(Throwable ex);
}

FragmentManager.enableDebugLoggin(true)

android.os.Debug.waitForDebugger();

//trigger your service
<service
	android:name="...."
	android:exported="true"
	android:process=":sync" />