Examples with CompatibilityInfo android.content.res.CompatibilityInfo used on opensource projects

Example 46 with CompatibilityInfo

use of android.content.res.CompatibilityInfo in project android_frameworks_base by DirtyUnicorns.

the class DpiTestActivity method init.

public void init(boolean noCompat) {
    try {
        // This is all a dirty hack.  Don't think a real application should
        // be doing it.
        Application app = ActivityThread.currentActivityThread().getApplication();
        ApplicationInfo ai = app.getPackageManager().getApplicationInfo("com.google.android.test.dpi", 0);
        if (noCompat) {
            ai.flags |= ApplicationInfo.FLAG_SUPPORTS_XLARGE_SCREENS | ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS | ApplicationInfo.FLAG_SUPPORTS_NORMAL_SCREENS | ApplicationInfo.FLAG_SUPPORTS_SMALL_SCREENS | ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS | ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES;
            app.getResources().setCompatibilityInfo(new CompatibilityInfo(ai, getResources().getConfiguration().screenLayout, getResources().getConfiguration().smallestScreenWidthDp, false));
        }
    } catch (PackageManager.NameNotFoundException e) {
        throw new RuntimeException("ouch", e);
    }
}

Example 47 with CompatibilityInfo

use of android.content.res.CompatibilityInfo in project android_frameworks_base by DirtyUnicorns.

the class CompatModePackages method handlePackageAddedLocked.

public void handlePackageAddedLocked(String packageName, boolean updated) {
    ApplicationInfo ai = null;
    try {
        ai = AppGlobals.getPackageManager().getApplicationInfo(packageName, 0, 0);
    } catch (RemoteException e) {
    }
    if (ai == null) {
        return;
    }
    CompatibilityInfo ci = compatibilityInfoForPackageLocked(ai);
    final boolean mayCompat = !ci.alwaysSupportsScreen() && !ci.neverSupportsScreen();
    if (updated) {
        // any current settings for it.
        if (!mayCompat && mPackages.containsKey(packageName)) {
            mPackages.remove(packageName);
            scheduleWrite();
        }
    }
}

Example 48 with CompatibilityInfo

use of android.content.res.CompatibilityInfo in project android_frameworks_base by DirtyUnicorns.

the class CompatModePackages method setPackageScreenCompatModeLocked.

private void setPackageScreenCompatModeLocked(ApplicationInfo ai, int mode) {
    final String packageName = ai.packageName;
    int curFlags = getPackageFlags(packageName);
    boolean enable;
    switch(mode) {
        case ActivityManager.COMPAT_MODE_DISABLED:
            enable = false;
            break;
        case ActivityManager.COMPAT_MODE_ENABLED:
            enable = true;
            break;
        case ActivityManager.COMPAT_MODE_TOGGLE:
            enable = (curFlags & COMPAT_FLAG_ENABLED) == 0;
            break;
        default:
            Slog.w(TAG, "Unknown screen compat mode req #" + mode + "; ignoring");
            return;
    }
    int newFlags = curFlags;
    if (enable) {
        newFlags |= COMPAT_FLAG_ENABLED;
    } else {
        newFlags &= ~COMPAT_FLAG_ENABLED;
    }
    CompatibilityInfo ci = compatibilityInfoForPackageLocked(ai);
    if (ci.alwaysSupportsScreen()) {
        Slog.w(TAG, "Ignoring compat mode change of " + packageName + "; compatibility never needed");
        newFlags = 0;
    }
    if (ci.neverSupportsScreen()) {
        Slog.w(TAG, "Ignoring compat mode change of " + packageName + "; compatibility always needed");
        newFlags = 0;
    }
    if (newFlags != curFlags) {
        if (newFlags != 0) {
            mPackages.put(packageName, newFlags);
        } else {
            mPackages.remove(packageName);
        }
        // Need to get compatibility info in new state.
        ci = compatibilityInfoForPackageLocked(ai);
        scheduleWrite();
        final ActivityStack stack = mService.getFocusedStack();
        ActivityRecord starting = stack.restartPackage(packageName);
        // Tell all processes that loaded this package about the change.
        for (int i = mService.mLruProcesses.size() - 1; i >= 0; i--) {
            ProcessRecord app = mService.mLruProcesses.get(i);
            if (!app.pkgList.containsKey(packageName)) {
                continue;
            }
            try {
                if (app.thread != null) {
                    if (DEBUG_CONFIGURATION)
                        Slog.v(TAG_CONFIGURATION, "Sending to proc " + app.processName + " new compat " + ci);
                    app.thread.updatePackageCompatibilityInfo(packageName, ci);
                }
            } catch (Exception e) {
            }
        }
        if (starting != null) {
            stack.ensureActivityConfigurationLocked(starting, 0, false);
            // And we need to make sure at this point that all other activities
            // are made visible with the correct configuration.
            stack.ensureActivitiesVisibleLocked(starting, 0, !PRESERVE_WINDOWS);
        }
    }
}

Example 49 with CompatibilityInfo

use of android.content.res.CompatibilityInfo in project XobotOS by xamarin.

the class ViewRootImpl method performTraversals.

private void performTraversals() {
    // cache mView since it is used so much below...
    final View host = mView;
    if (DBG) {
        System.out.println("======================================");
        System.out.println("performTraversals");
        host.debug();
    }
    if (host == null || !mAdded)
        return;
    mTraversalScheduled = false;
    mWillDrawSoon = true;
    boolean windowSizeMayChange = false;
    boolean fullRedrawNeeded = mFullRedrawNeeded;
    boolean newSurface = false;
    boolean surfaceChanged = false;
    WindowManager.LayoutParams lp = mWindowAttributes;
    int desiredWindowWidth;
    int desiredWindowHeight;
    int childWidthMeasureSpec;
    int childHeightMeasureSpec;
    final View.AttachInfo attachInfo = mAttachInfo;
    final int viewVisibility = getHostVisibility();
    boolean viewVisibilityChanged = mViewVisibility != viewVisibility || mNewSurfaceNeeded;
    WindowManager.LayoutParams params = null;
    int windowAttributesChanges = 0;
    if (mWindowAttributesChanged) {
        mWindowAttributesChanged = false;
        surfaceChanged = true;
        params = lp;
        windowAttributesChanges = mWindowAttributesChangesFlag;
    }
    CompatibilityInfo compatibilityInfo = mCompatibilityInfo.get();
    if (compatibilityInfo.supportsScreen() == mLastInCompatMode) {
        params = lp;
        fullRedrawNeeded = true;
        mLayoutRequested = true;
        if (mLastInCompatMode) {
            params.flags &= ~WindowManager.LayoutParams.FLAG_COMPATIBLE_WINDOW;
            mLastInCompatMode = false;
        } else {
            params.flags |= WindowManager.LayoutParams.FLAG_COMPATIBLE_WINDOW;
            mLastInCompatMode = true;
        }
    }
    mWindowAttributesChangesFlag = 0;
    Rect frame = mWinFrame;
    if (mFirst) {
        fullRedrawNeeded = true;
        mLayoutRequested = true;
        if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL) {
            // NOTE -- system code, won't try to do compat mode.
            Display disp = WindowManagerImpl.getDefault().getDefaultDisplay();
            Point size = new Point();
            disp.getRealSize(size);
            desiredWindowWidth = size.x;
            desiredWindowHeight = size.y;
        } else {
            DisplayMetrics packageMetrics = mView.getContext().getResources().getDisplayMetrics();
            desiredWindowWidth = packageMetrics.widthPixels;
            desiredWindowHeight = packageMetrics.heightPixels;
        }
        // For the very first time, tell the view hierarchy that it
        // is attached to the window.  Note that at this point the surface
        // object is not initialized to its backing store, but soon it
        // will be (assuming the window is visible).
        attachInfo.mSurface = mSurface;
        // We used to use the following condition to choose 32 bits drawing caches:
        // PixelFormat.hasAlpha(lp.format) || lp.format == PixelFormat.RGBX_8888
        // However, windows are now always 32 bits by default, so choose 32 bits
        attachInfo.mUse32BitDrawingCache = true;
        attachInfo.mHasWindowFocus = false;
        attachInfo.mWindowVisibility = viewVisibility;
        attachInfo.mRecomputeGlobalAttributes = false;
        attachInfo.mKeepScreenOn = false;
        attachInfo.mSystemUiVisibility = 0;
        viewVisibilityChanged = false;
        mLastConfiguration.setTo(host.getResources().getConfiguration());
        host.dispatchAttachedToWindow(attachInfo, 0);
        //Log.i(TAG, "Screen on initialized: " + attachInfo.mKeepScreenOn);
        host.fitSystemWindows(mAttachInfo.mContentInsets);
    } else {
        desiredWindowWidth = frame.width();
        desiredWindowHeight = frame.height();
        if (desiredWindowWidth != mWidth || desiredWindowHeight != mHeight) {
            if (DEBUG_ORIENTATION)
                Log.v(TAG, "View " + host + " resized to: " + frame);
            fullRedrawNeeded = true;
            mLayoutRequested = true;
            windowSizeMayChange = true;
        }
    }
    if (viewVisibilityChanged) {
        attachInfo.mWindowVisibility = viewVisibility;
        host.dispatchWindowVisibilityChanged(viewVisibility);
        if (viewVisibility != View.VISIBLE || mNewSurfaceNeeded) {
            destroyHardwareResources();
        }
        if (viewVisibility == View.GONE) {
            // After making a window gone, we will count it as being
            // shown for the first time the next time it gets focus.
            mHasHadWindowFocus = false;
        }
    }
    boolean insetsChanged = false;
    if (mLayoutRequested && !mStopped) {
        // Execute enqueued actions on every layout in case a view that was detached
        // enqueued an action after being detached
        getRunQueue().executeActions(attachInfo.mHandler);
        final Resources res = mView.getContext().getResources();
        if (mFirst) {
            // make sure touch mode code executes by setting cached value
            // to opposite of the added touch mode.
            mAttachInfo.mInTouchMode = !mAddedTouchMode;
            ensureTouchModeLocally(mAddedTouchMode);
        } else {
            if (!mPendingContentInsets.equals(mAttachInfo.mContentInsets)) {
                insetsChanged = true;
            }
            if (!mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets)) {
                mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                if (DEBUG_LAYOUT)
                    Log.v(TAG, "Visible insets changing to: " + mAttachInfo.mVisibleInsets);
            }
            if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT || lp.height == ViewGroup.LayoutParams.WRAP_CONTENT) {
                windowSizeMayChange = true;
                if (lp.type == WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL) {
                    // NOTE -- system code, won't try to do compat mode.
                    Display disp = WindowManagerImpl.getDefault().getDefaultDisplay();
                    Point size = new Point();
                    disp.getRealSize(size);
                    desiredWindowWidth = size.x;
                    desiredWindowHeight = size.y;
                } else {
                    DisplayMetrics packageMetrics = res.getDisplayMetrics();
                    desiredWindowWidth = packageMetrics.widthPixels;
                    desiredWindowHeight = packageMetrics.heightPixels;
                }
            }
        }
        // Ask host how big it wants to be
        if (DEBUG_ORIENTATION || DEBUG_LAYOUT)
            Log.v(TAG, "Measuring " + host + " in display " + desiredWindowWidth + "x" + desiredWindowHeight + "...");
        boolean goodMeasure = false;
        if (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT) {
            // On large screens, we don't want to allow dialogs to just
            // stretch to fill the entire width of the screen to display
            // one line of text.  First try doing the layout at a smaller
            // size to see if it will fit.
            final DisplayMetrics packageMetrics = res.getDisplayMetrics();
            res.getValue(com.android.internal.R.dimen.config_prefDialogWidth, mTmpValue, true);
            int baseSize = 0;
            if (mTmpValue.type == TypedValue.TYPE_DIMENSION) {
                baseSize = (int) mTmpValue.getDimension(packageMetrics);
            }
            if (DEBUG_DIALOG)
                Log.v(TAG, "Window " + mView + ": baseSize=" + baseSize);
            if (baseSize != 0 && desiredWindowWidth > baseSize) {
                childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
                childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
                host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                if (DEBUG_DIALOG)
                    Log.v(TAG, "Window " + mView + ": measured (" + host.getMeasuredWidth() + "," + host.getMeasuredHeight() + ")");
                if ((host.getMeasuredWidthAndState() & View.MEASURED_STATE_TOO_SMALL) == 0) {
                    goodMeasure = true;
                } else {
                    // Didn't fit in that size... try expanding a bit.
                    baseSize = (baseSize + desiredWindowWidth) / 2;
                    if (DEBUG_DIALOG)
                        Log.v(TAG, "Window " + mView + ": next baseSize=" + baseSize);
                    childWidthMeasureSpec = getRootMeasureSpec(baseSize, lp.width);
                    host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                    if (DEBUG_DIALOG)
                        Log.v(TAG, "Window " + mView + ": measured (" + host.getMeasuredWidth() + "," + host.getMeasuredHeight() + ")");
                    if ((host.getMeasuredWidthAndState() & View.MEASURED_STATE_TOO_SMALL) == 0) {
                        if (DEBUG_DIALOG)
                            Log.v(TAG, "Good!");
                        goodMeasure = true;
                    }
                }
            }
        }
        if (!goodMeasure) {
            childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
            childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
            host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
            if (mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) {
                windowSizeMayChange = true;
            }
        }
        if (DBG) {
            System.out.println("======================================");
            System.out.println("performTraversals -- after measure");
            host.debug();
        }
    }
    if (attachInfo.mRecomputeGlobalAttributes && host.mAttachInfo != null) {
        //Log.i(TAG, "Computing view hierarchy attributes!");
        attachInfo.mRecomputeGlobalAttributes = false;
        boolean oldScreenOn = attachInfo.mKeepScreenOn;
        int oldVis = attachInfo.mSystemUiVisibility;
        boolean oldHasSystemUiListeners = attachInfo.mHasSystemUiListeners;
        attachInfo.mKeepScreenOn = false;
        attachInfo.mSystemUiVisibility = 0;
        attachInfo.mHasSystemUiListeners = false;
        host.dispatchCollectViewAttributes(0);
        if (attachInfo.mKeepScreenOn != oldScreenOn || attachInfo.mSystemUiVisibility != oldVis || attachInfo.mHasSystemUiListeners != oldHasSystemUiListeners) {
            params = lp;
        }
    }
    if (attachInfo.mForceReportNewAttributes) {
        attachInfo.mForceReportNewAttributes = false;
        params = lp;
    }
    if (mFirst || attachInfo.mViewVisibilityChanged) {
        attachInfo.mViewVisibilityChanged = false;
        int resizeMode = mSoftInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST;
        // what mode to use now.
        if (resizeMode == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED) {
            final int N = attachInfo.mScrollContainers.size();
            for (int i = 0; i < N; i++) {
                if (attachInfo.mScrollContainers.get(i).isShown()) {
                    resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
                }
            }
            if (resizeMode == 0) {
                resizeMode = WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN;
            }
            if ((lp.softInputMode & WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) != resizeMode) {
                lp.softInputMode = (lp.softInputMode & ~WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) | resizeMode;
                params = lp;
            }
        }
    }
    if (params != null && (host.mPrivateFlags & View.REQUEST_TRANSPARENT_REGIONS) != 0) {
        if (!PixelFormat.formatHasAlpha(params.format)) {
            params.format = PixelFormat.TRANSLUCENT;
        }
    }
    boolean windowShouldResize = mLayoutRequested && windowSizeMayChange && ((mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight()) || (lp.width == ViewGroup.LayoutParams.WRAP_CONTENT && frame.width() < desiredWindowWidth && frame.width() != mWidth) || (lp.height == ViewGroup.LayoutParams.WRAP_CONTENT && frame.height() < desiredWindowHeight && frame.height() != mHeight));
    final boolean computesInternalInsets = attachInfo.mTreeObserver.hasComputeInternalInsetsListeners();
    boolean insetsPending = false;
    int relayoutResult = 0;
    if (mFirst || windowShouldResize || insetsChanged || viewVisibilityChanged || params != null) {
        if (viewVisibility == View.VISIBLE) {
            // If this window is giving internal insets to the window
            // manager, and it is being added or changing its visibility,
            // then we want to first give the window manager "fake"
            // insets to cause it to effectively ignore the content of
            // the window during layout.  This avoids it briefly causing
            // other windows to resize/move based on the raw frame of the
            // window, waiting until we can finish laying out this window
            // and get back to the window manager with the ultimately
            // computed insets.
            insetsPending = computesInternalInsets && (mFirst || viewVisibilityChanged);
        }
        if (mSurfaceHolder != null) {
            mSurfaceHolder.mSurfaceLock.lock();
            mDrawingAllowed = true;
        }
        boolean hwInitialized = false;
        boolean contentInsetsChanged = false;
        boolean visibleInsetsChanged;
        boolean hadSurface = mSurface.isValid();
        try {
            int fl = 0;
            if (params != null) {
                fl = params.flags;
                if (attachInfo.mKeepScreenOn) {
                    params.flags |= WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
                }
                params.subtreeSystemUiVisibility = attachInfo.mSystemUiVisibility;
                params.hasSystemUiListeners = attachInfo.mHasSystemUiListeners;
            }
            if (DEBUG_LAYOUT) {
                Log.i(TAG, "host=w:" + host.getMeasuredWidth() + ", h:" + host.getMeasuredHeight() + ", params=" + params);
            }
            final int surfaceGenerationId = mSurface.getGenerationId();
            relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
            if (params != null) {
                params.flags = fl;
            }
            if (DEBUG_LAYOUT)
                Log.v(TAG, "relayout: frame=" + frame.toShortString() + " content=" + mPendingContentInsets.toShortString() + " visible=" + mPendingVisibleInsets.toShortString() + " surface=" + mSurface);
            if (mPendingConfiguration.seq != 0) {
                if (DEBUG_CONFIGURATION)
                    Log.v(TAG, "Visible with new config: " + mPendingConfiguration);
                updateConfiguration(mPendingConfiguration, !mFirst);
                mPendingConfiguration.seq = 0;
            }
            contentInsetsChanged = !mPendingContentInsets.equals(mAttachInfo.mContentInsets);
            visibleInsetsChanged = !mPendingVisibleInsets.equals(mAttachInfo.mVisibleInsets);
            if (contentInsetsChanged) {
                if (mWidth > 0 && mHeight > 0 && mSurface != null && mSurface.isValid() && !mAttachInfo.mTurnOffWindowResizeAnim && mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled() && mAttachInfo.mHardwareRenderer.validate() && lp != null && !PixelFormat.formatHasAlpha(lp.format)) {
                    disposeResizeBuffer();
                    boolean completed = false;
                    HardwareCanvas canvas = null;
                    try {
                        if (mResizeBuffer == null) {
                            mResizeBuffer = mAttachInfo.mHardwareRenderer.createHardwareLayer(mWidth, mHeight, false);
                        } else if (mResizeBuffer.getWidth() != mWidth || mResizeBuffer.getHeight() != mHeight) {
                            mResizeBuffer.resize(mWidth, mHeight);
                        }
                        canvas = mResizeBuffer.start(mAttachInfo.mHardwareCanvas);
                        canvas.setViewport(mWidth, mHeight);
                        canvas.onPreDraw(null);
                        final int restoreCount = canvas.save();
                        canvas.drawColor(0xff000000, PorterDuff.Mode.SRC);
                        int yoff;
                        final boolean scrolling = mScroller != null && mScroller.computeScrollOffset();
                        if (scrolling) {
                            yoff = mScroller.getCurrY();
                            mScroller.abortAnimation();
                        } else {
                            yoff = mScrollY;
                        }
                        canvas.translate(0, -yoff);
                        if (mTranslator != null) {
                            mTranslator.translateCanvas(canvas);
                        }
                        mView.draw(canvas);
                        mResizeBufferStartTime = SystemClock.uptimeMillis();
                        mResizeBufferDuration = mView.getResources().getInteger(com.android.internal.R.integer.config_mediumAnimTime);
                        completed = true;
                        canvas.restoreToCount(restoreCount);
                    } catch (OutOfMemoryError e) {
                        Log.w(TAG, "Not enough memory for content change anim buffer", e);
                    } finally {
                        if (canvas != null) {
                            canvas.onPostDraw();
                        }
                        if (mResizeBuffer != null) {
                            mResizeBuffer.end(mAttachInfo.mHardwareCanvas);
                            if (!completed) {
                                mResizeBuffer.destroy();
                                mResizeBuffer = null;
                            }
                        }
                    }
                }
                mAttachInfo.mContentInsets.set(mPendingContentInsets);
                host.fitSystemWindows(mAttachInfo.mContentInsets);
                if (DEBUG_LAYOUT)
                    Log.v(TAG, "Content insets changing to: " + mAttachInfo.mContentInsets);
            }
            if (visibleInsetsChanged) {
                mAttachInfo.mVisibleInsets.set(mPendingVisibleInsets);
                if (DEBUG_LAYOUT)
                    Log.v(TAG, "Visible insets changing to: " + mAttachInfo.mVisibleInsets);
            }
            if (!hadSurface) {
                if (mSurface.isValid()) {
                    // If we are creating a new surface, then we need to
                    // completely redraw it.  Also, when we get to the
                    // point of drawing it we will hold off and schedule
                    // a new traversal instead.  This is so we can tell the
                    // window manager about all of the windows being displayed
                    // before actually drawing them, so it can display then
                    // all at once.
                    newSurface = true;
                    fullRedrawNeeded = true;
                    mPreviousTransparentRegion.setEmpty();
                    if (mAttachInfo.mHardwareRenderer != null) {
                        try {
                            hwInitialized = mAttachInfo.mHardwareRenderer.initialize(mHolder);
                        } catch (Surface.OutOfResourcesException e) {
                            Log.e(TAG, "OutOfResourcesException initializing HW surface", e);
                            try {
                                if (!sWindowSession.outOfMemory(mWindow)) {
                                    Slog.w(TAG, "No processes killed for memory; killing self");
                                    Process.killProcess(Process.myPid());
                                }
                            } catch (RemoteException ex) {
                            }
                            // ask wm for a new surface next time.
                            mLayoutRequested = true;
                            return;
                        }
                    }
                }
            } else if (!mSurface.isValid()) {
                // If the surface has been removed, then reset the scroll
                // positions.
                mLastScrolledFocus = null;
                mScrollY = mCurScrollY = 0;
                if (mScroller != null) {
                    mScroller.abortAnimation();
                }
                disposeResizeBuffer();
                // Our surface is gone
                if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
                    mAttachInfo.mHardwareRenderer.destroy(true);
                }
            } else if (surfaceGenerationId != mSurface.getGenerationId() && mSurfaceHolder == null && mAttachInfo.mHardwareRenderer != null) {
                fullRedrawNeeded = true;
                try {
                    mAttachInfo.mHardwareRenderer.updateSurface(mHolder);
                } catch (Surface.OutOfResourcesException e) {
                    Log.e(TAG, "OutOfResourcesException updating HW surface", e);
                    try {
                        if (!sWindowSession.outOfMemory(mWindow)) {
                            Slog.w(TAG, "No processes killed for memory; killing self");
                            Process.killProcess(Process.myPid());
                        }
                    } catch (RemoteException ex) {
                    }
                    // ask wm for a new surface next time.
                    mLayoutRequested = true;
                    return;
                }
            }
        } catch (RemoteException e) {
        }
        if (DEBUG_ORIENTATION)
            Log.v(TAG, "Relayout returned: frame=" + frame + ", surface=" + mSurface);
        attachInfo.mWindowLeft = frame.left;
        attachInfo.mWindowTop = frame.top;
        // !!FIXME!! This next section handles the case where we did not get the
        // window size we asked for. We should avoid this by getting a maximum size from
        // the window session beforehand.
        mWidth = frame.width();
        mHeight = frame.height();
        if (mSurfaceHolder != null) {
            // The app owns the surface; tell it about what is going on.
            if (mSurface.isValid()) {
                // XXX .copyFrom() doesn't work!
                //mSurfaceHolder.mSurface.copyFrom(mSurface);
                mSurfaceHolder.mSurface = mSurface;
            }
            mSurfaceHolder.setSurfaceFrameSize(mWidth, mHeight);
            mSurfaceHolder.mSurfaceLock.unlock();
            if (mSurface.isValid()) {
                if (!hadSurface) {
                    mSurfaceHolder.ungetCallbacks();
                    mIsCreating = true;
                    mSurfaceHolderCallback.surfaceCreated(mSurfaceHolder);
                    SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                    if (callbacks != null) {
                        for (SurfaceHolder.Callback c : callbacks) {
                            c.surfaceCreated(mSurfaceHolder);
                        }
                    }
                    surfaceChanged = true;
                }
                if (surfaceChanged) {
                    mSurfaceHolderCallback.surfaceChanged(mSurfaceHolder, lp.format, mWidth, mHeight);
                    SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                    if (callbacks != null) {
                        for (SurfaceHolder.Callback c : callbacks) {
                            c.surfaceChanged(mSurfaceHolder, lp.format, mWidth, mHeight);
                        }
                    }
                }
                mIsCreating = false;
            } else if (hadSurface) {
                mSurfaceHolder.ungetCallbacks();
                SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                mSurfaceHolderCallback.surfaceDestroyed(mSurfaceHolder);
                if (callbacks != null) {
                    for (SurfaceHolder.Callback c : callbacks) {
                        c.surfaceDestroyed(mSurfaceHolder);
                    }
                }
                mSurfaceHolder.mSurfaceLock.lock();
                try {
                    mSurfaceHolder.mSurface = new Surface();
                } finally {
                    mSurfaceHolder.mSurfaceLock.unlock();
                }
            }
        }
        if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
            if (hwInitialized || windowShouldResize || mWidth != mAttachInfo.mHardwareRenderer.getWidth() || mHeight != mAttachInfo.mHardwareRenderer.getHeight()) {
                mAttachInfo.mHardwareRenderer.setup(mWidth, mHeight);
                if (!hwInitialized) {
                    mAttachInfo.mHardwareRenderer.invalidate(mHolder);
                }
            }
        }
        if (!mStopped) {
            boolean focusChangedDueToTouchMode = ensureTouchModeLocally((relayoutResult & WindowManagerImpl.RELAYOUT_IN_TOUCH_MODE) != 0);
            if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth() || mHeight != host.getMeasuredHeight() || contentInsetsChanged) {
                childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
                childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
                if (DEBUG_LAYOUT)
                    Log.v(TAG, "Ooops, something changed!  mWidth=" + mWidth + " measuredWidth=" + host.getMeasuredWidth() + " mHeight=" + mHeight + " measuredHeight=" + host.getMeasuredHeight() + " coveredInsetsChanged=" + contentInsetsChanged);
                // Ask host how big it wants to be
                host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                // Implementation of weights from WindowManager.LayoutParams
                // We just grow the dimensions as needed and re-measure if
                // needs be
                int width = host.getMeasuredWidth();
                int height = host.getMeasuredHeight();
                boolean measureAgain = false;
                if (lp.horizontalWeight > 0.0f) {
                    width += (int) ((mWidth - width) * lp.horizontalWeight);
                    childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);
                    measureAgain = true;
                }
                if (lp.verticalWeight > 0.0f) {
                    height += (int) ((mHeight - height) * lp.verticalWeight);
                    childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
                    measureAgain = true;
                }
                if (measureAgain) {
                    if (DEBUG_LAYOUT)
                        Log.v(TAG, "And hey let's measure once more: width=" + width + " height=" + height);
                    host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                }
                mLayoutRequested = true;
            }
        }
    }
    final boolean didLayout = mLayoutRequested && !mStopped;
    boolean triggerGlobalLayoutListener = didLayout || attachInfo.mRecomputeGlobalAttributes;
    if (didLayout) {
        mLayoutRequested = false;
        mScrollMayChange = true;
        if (DEBUG_ORIENTATION || DEBUG_LAYOUT)
            Log.v(TAG, "Laying out " + host + " to (" + host.getMeasuredWidth() + ", " + host.getMeasuredHeight() + ")");
        long startTime = 0L;
        if (ViewDebug.DEBUG_PROFILE_LAYOUT) {
            startTime = SystemClock.elapsedRealtime();
        }
        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
        if (false && ViewDebug.consistencyCheckEnabled) {
            if (!host.dispatchConsistencyCheck(ViewDebug.CONSISTENCY_LAYOUT)) {
                throw new IllegalStateException("The view hierarchy is an inconsistent state," + "please refer to the logs with the tag " + ViewDebug.CONSISTENCY_LOG_TAG + " for more infomation.");
            }
        }
        if (ViewDebug.DEBUG_PROFILE_LAYOUT) {
            EventLog.writeEvent(60001, SystemClock.elapsedRealtime() - startTime);
        }
        if ((host.mPrivateFlags & View.REQUEST_TRANSPARENT_REGIONS) != 0) {
            // start out transparent
            // TODO: AVOID THAT CALL BY CACHING THE RESULT?
            host.getLocationInWindow(mTmpLocation);
            mTransparentRegion.set(mTmpLocation[0], mTmpLocation[1], mTmpLocation[0] + host.mRight - host.mLeft, mTmpLocation[1] + host.mBottom - host.mTop);
            host.gatherTransparentRegion(mTransparentRegion);
            if (mTranslator != null) {
                mTranslator.translateRegionInWindowToScreen(mTransparentRegion);
            }
            if (!mTransparentRegion.equals(mPreviousTransparentRegion)) {
                mPreviousTransparentRegion.set(mTransparentRegion);
                // reconfigure window manager
                try {
                    sWindowSession.setTransparentRegion(mWindow, mTransparentRegion);
                } catch (RemoteException e) {
                }
            }
        }
        if (DBG) {
            System.out.println("======================================");
            System.out.println("performTraversals -- after setFrame");
            host.debug();
        }
    }
    if (triggerGlobalLayoutListener) {
        attachInfo.mRecomputeGlobalAttributes = false;
        attachInfo.mTreeObserver.dispatchOnGlobalLayout();
        if (AccessibilityManager.getInstance(host.mContext).isEnabled()) {
            postSendWindowContentChangedCallback();
        }
    }
    if (computesInternalInsets) {
        // Clear the original insets.
        final ViewTreeObserver.InternalInsetsInfo insets = attachInfo.mGivenInternalInsets;
        insets.reset();
        // Compute new insets in place.
        attachInfo.mTreeObserver.dispatchOnComputeInternalInsets(insets);
        // Tell the window manager.
        if (insetsPending || !mLastGivenInsets.equals(insets)) {
            mLastGivenInsets.set(insets);
            // Translate insets to screen coordinates if needed.
            final Rect contentInsets;
            final Rect visibleInsets;
            final Region touchableRegion;
            if (mTranslator != null) {
                contentInsets = mTranslator.getTranslatedContentInsets(insets.contentInsets);
                visibleInsets = mTranslator.getTranslatedVisibleInsets(insets.visibleInsets);
                touchableRegion = mTranslator.getTranslatedTouchableArea(insets.touchableRegion);
            } else {
                contentInsets = insets.contentInsets;
                visibleInsets = insets.visibleInsets;
                touchableRegion = insets.touchableRegion;
            }
            try {
                sWindowSession.setInsets(mWindow, insets.mTouchableInsets, contentInsets, visibleInsets, touchableRegion);
            } catch (RemoteException e) {
            }
        }
    }
    if (mFirst) {
        // handle first focus request
        if (DEBUG_INPUT_RESIZE)
            Log.v(TAG, "First: mView.hasFocus()=" + mView.hasFocus());
        if (mView != null) {
            if (!mView.hasFocus()) {
                mView.requestFocus(View.FOCUS_FORWARD);
                mFocusedView = mRealFocusedView = mView.findFocus();
                if (DEBUG_INPUT_RESIZE)
                    Log.v(TAG, "First: requested focused view=" + mFocusedView);
            } else {
                mRealFocusedView = mView.findFocus();
                if (DEBUG_INPUT_RESIZE)
                    Log.v(TAG, "First: existing focused view=" + mRealFocusedView);
            }
        }
    }
    mFirst = false;
    mWillDrawSoon = false;
    mNewSurfaceNeeded = false;
    mViewVisibility = viewVisibility;
    if (mAttachInfo.mHasWindowFocus) {
        final boolean imTarget = WindowManager.LayoutParams.mayUseInputMethod(mWindowAttributes.flags);
        if (imTarget != mLastWasImTarget) {
            mLastWasImTarget = imTarget;
            InputMethodManager imm = InputMethodManager.peekInstance();
            if (imm != null && imTarget) {
                imm.startGettingWindowFocus(mView);
                imm.onWindowFocus(mView, mView.findFocus(), mWindowAttributes.softInputMode, !mHasHadWindowFocus, mWindowAttributes.flags);
            }
        }
    }
    boolean cancelDraw = attachInfo.mTreeObserver.dispatchOnPreDraw() || viewVisibility != View.VISIBLE;
    if (!cancelDraw && !newSurface) {
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).startChangingAnimations();
            }
            mPendingTransitions.clear();
        }
        mFullRedrawNeeded = false;
        final long drawStartTime;
        if (ViewDebug.DEBUG_LATENCY) {
            drawStartTime = System.nanoTime();
        }
        draw(fullRedrawNeeded);
        if (ViewDebug.DEBUG_LATENCY) {
            mLastDrawDurationNanos = System.nanoTime() - drawStartTime;
        }
        if ((relayoutResult & WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0 || mReportNextDraw) {
            if (LOCAL_LOGV) {
                Log.v(TAG, "FINISHED DRAWING: " + mWindowAttributes.getTitle());
            }
            mReportNextDraw = false;
            if (mSurfaceHolder != null && mSurface.isValid()) {
                mSurfaceHolderCallback.surfaceRedrawNeeded(mSurfaceHolder);
                SurfaceHolder.Callback[] callbacks = mSurfaceHolder.getCallbacks();
                if (callbacks != null) {
                    for (SurfaceHolder.Callback c : callbacks) {
                        if (c instanceof SurfaceHolder.Callback2) {
                            ((SurfaceHolder.Callback2) c).surfaceRedrawNeeded(mSurfaceHolder);
                        }
                    }
                }
            }
            try {
                sWindowSession.finishDrawing(mWindow);
            } catch (RemoteException e) {
            }
        }
    } else {
        // End any pending transitions on this non-visible window
        if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
            for (int i = 0; i < mPendingTransitions.size(); ++i) {
                mPendingTransitions.get(i).endChangingAnimations();
            }
            mPendingTransitions.clear();
        }
        // draw, remember it here.
        if ((relayoutResult & WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0) {
            mReportNextDraw = true;
        }
        if (fullRedrawNeeded) {
            mFullRedrawNeeded = true;
        }
        if (viewVisibility == View.VISIBLE) {
            // Try again
            scheduleTraversals();
        }
    }
}

Example 50 with CompatibilityInfo

use of android.content.res.CompatibilityInfo in project XobotOS by xamarin.

the class Display method getMetrics.

/**
     * Gets display metrics that describe the size and density of this display.
     * <p>
     * The size is adjusted based on the current rotation of the display.
     * </p><p>
     * The size returned by this method does not necessarily represent the
     * actual raw size (native resolution) of the display.  The returned size may
     * be adjusted to exclude certain system decor elements that are always visible.
     * It may also be scaled to provide compatibility with older applications that
     * were originally designed for smaller displays.
     * </p>
     *
     * @param outMetrics A {@link DisplayMetrics} object to receive the metrics.
     */
public void getMetrics(DisplayMetrics outMetrics) {
    synchronized (mTmpPoint) {
        getSizeInternal(mTmpPoint, false);
        getMetricsWithSize(outMetrics, mTmpPoint.x, mTmpPoint.y);
    }
    CompatibilityInfo ci = mCompatibilityInfo.getIfNeeded();
    if (ci != null) {
        ci.applyToDisplayMetrics(outMetrics);
    }
    if (DEBUG_DISPLAY_SIZE)
        Slog.v(TAG, "Returning DisplayMetrics: " + outMetrics.widthPixels + "x" + outMetrics.heightPixels + " " + outMetrics.density);
}