页面比较

Settings.Global.putString(resolver, Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, "1");
Settings.Global.putString(resolver, Settings.Global.DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES, "1");
Settings.Global.putString(resolver, Settings.Global.DEVELOPMENT_WM_DISPLAY_SETTINGS_PATH, "vendor/etc/display_settings_freeform.xml");

<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2015 The Android Open Source Project
​
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
​
          http://www.apache.org/licenses/LICENSE-2.0
​
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
​
<permissions>
    <feature name="android.software.freeform_window_management" />
</permissions>

 public void retrieveSettings(ContentResolver resolver) {
        Settings.Global.putInt(resolver, DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 1);
        Settings.Global.putInt(resolver, DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES, 1);   

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<display-settings>
<!-- Use physical port number instead of local id -->
<config identifier="1" />
​
<!-- Set windowing mode to WINDOWING_MODE_FREEFORM -->
<display name="port:0"
    windowingMode="5" />
​
</display-settings>

 <!-- The device supports freeform window management. Windows have title bars and can be moved
         and resized. If you set this to true, you also need to add
         PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT feature to your device specification.
         The duplication is necessary, because this information is used before the features are
         available to the system.-->
    <bool name="config_freeformWindowManagement">true</bool>

PRODUCT_COPY_FILES += \
frameworks/native/data/etc/android.software.freeform_window_management.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.software.freeform_window_management.xml \
device/xxx/display_settings_freeform.xml:$(TARGET_COPY_OUT_VENDOR)/etc/display_settings_freeform.xml \

  //freeform模式
    private static final int WINDOWING_MODE_FREEFORM = 5;
​
   //获取屏幕高宽
   DisplayMetrics metric = new DisplayMetrics();
   getWindowManager().getDefaultDisplay().getMetrics(metric);
   int screenWidth = metric.widthPixels;
   int screenHeight = metric.heightPixels;
   
   Intent intent = new Intent(MainActivity.this, FreeformActivity.class);
   intent.setFlags(Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT | Intent.FLAG_ACTIVITY_NEW_TASK);
   ActivityOptions activityOptions = ActivityOptions.makeBasic();
   //设置为freeform模式
   try {
       Method method = ActivityOptions.class.getMethod("setLaunchWindowingMode", int.class);
       method.invoke(activityOptions, WINDOWING_MODE_FREEFORM);
   } catch (Exception e) {
        e.printStackTrace();
   }
   //freeform模式下自由窗口的大小
   int freeformWidth = 400;
   int freeformHeight = 400;
   //居中显示
   int left = screenWidth / 2 - freeformWidth / 2;
   int top = screenHeight / 2 - freeformHeight / 2;
   int right = screenWidth / 2 + freeformWidth / 2;
   int bottom = screenHeight / 2 + freeformHeight / 2;
   activityOptions.setLaunchBounds(new Rect(left,top,right,bottom));
   Bundle bundle = activityOptions.toBundle();
   startActivity(intent,bundle);
这是单个activity实现freeform的方式，如何实现所有activity，需要检查WMS和ATMS代码逻辑。当WMS和ATMS保存freeform的配置的时候，实际是保存到settings数据库了，那数据在哪里使用。

/frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java

        void updateFreeformWindowManagement() {
            ContentResolver resolver = mContext.getContentResolver();
            final boolean freeformWindowManagement = mContext.getPackageManager().hasSystemFeature(
                    FEATURE_FREEFORM_WINDOW_MANAGEMENT) || Settings.Global.getInt(
                    resolver, DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0;
​
            if (mAtmService.mSupportsFreeformWindowManagement != freeformWindowManagement) {
                mAtmService.mSupportsFreeformWindowManagement = freeformWindowManagement;
                synchronized (mGlobalLock) {
                    // Notify the root window container that the display settings value may change.
                    mRoot.onSettingsRetrieved();
                }
            }
        }

 void onSettingsRetrieved() {
        final int numDisplays = mChildren.size();
        for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) {
            final DisplayContent displayContent = mChildren.get(displayNdx);
            final boolean changed = mWmService.mDisplayWindowSettings.updateSettingsForDisplay(
                    displayContent);
            if (!changed) {
                continue;
            }
​
            displayContent.reconfigureDisplayLocked();
​
            // We need to update global configuration as well if config of default display has
            // changed. Do it inline because ATMS#retrieveSettings() will soon update the
            // configuration inline, which will overwrite the new windowing mode.
            if (displayContent.isDefaultDisplay) {
                final Configuration newConfig = mWmService.computeNewConfiguration(
                        displayContent.getDisplayId());
                mWmService.mAtmService.updateConfigurationLocked(newConfig, null /* starting */,
                        false /* initLocale */);
            }
        }
    }

/**
 * Implementation of {@link SettingsProvider} that reads the base settings provided in a display
 * settings file stored in /vendor/etc and then overlays those values with the settings provided in
 * /data/system.
 *
 * @see DisplayWindowSettings
 */
class DisplayWindowSettingsProvider implements SettingsProvider {
    private static final String TAG = TAG_WITH_CLASS_NAME
            ? "DisplayWindowSettingsProvider" : TAG_WM;
​
    private static final String DATA_DISPLAY_SETTINGS_FILE_PATH = "system/display_settings.xml";
    private static final String VENDOR_DISPLAY_SETTINGS_FILE_PATH = "etc/display_settings.xml";

 /**
     * Updates settings for the given display after system features are loaded into window manager
     * service, e.g. if this device is PC and if this device supports freeform.
     *
     * @param dc the given display.
     * @return {@code true} if any settings for this display has changed; {@code false} if nothing
     * changed.
     */
    boolean updateSettingsForDisplay(DisplayContent dc) {
        if (dc.getWindowingMode() != getWindowingModeLocked(dc)) {
            // For the time being the only thing that may change is windowing mode, so just update
            // that.
            dc.setWindowingMode(getWindowingModeLocked(dc));
            return true;
        }
        return false;
    }

 private int getWindowingModeLocked(SettingsProvider.SettingsEntry settings, DisplayContent dc) {
        int windowingMode = settings.mWindowingMode;
        // This display used to be in freeform, but we don't support freeform anymore, so fall
        // back to fullscreen.
        if (windowingMode == WindowConfiguration.WINDOWING_MODE_FREEFORM
                && !mService.mAtmService.mSupportsFreeformWindowManagement) {
            return WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
        }
        // No record is present so use default windowing mode policy.
        if (windowingMode == WindowConfiguration.WINDOWING_MODE_UNDEFINED) {
            windowingMode = mService.mAtmService.mSupportsFreeformWindowManagement
                    && (mService.mIsPc || dc.forceDesktopMode())
                    ? WindowConfiguration.WINDOWING_MODE_FREEFORM
                    : WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
        }
        return windowingMode;
    }

WindowManager:  WindowState:Window{18bd0d7 u0 Splash Screen com.android.messaging}
WindowManager: java.lang.Throwable
WindowManager:  at com.android.server.wm.WindowState.<init>(WindowState.java:751)
WindowManager:  at com.android.server.wm.WindowManagerService.addWindow(WindowManagerService.java:1562)
WindowManager:  at com.android.server.wm.Session.addToDisplay(Session.java:159)
WindowManager:  at android.view.ViewRootImpl.setView(ViewRootImpl.java:923)
WindowManager:  at android.view.WindowManagerGlobal.addView(WindowManagerGlobal.java:387)
WindowManager:  at android.view.WindowManagerImpl.addView(WindowManagerImpl.java:96)
WindowManager:  at com.android.server.policy.PhoneWindowManager.addSplashScreen(PhoneWindowManager.java:2802)
WindowManager:  at com.android.server.wm.SplashScreenStartingData.createStartingSurface(SplashScreenStartingData.java:56)
WindowManager:  at com.android.server.wm.AppWindowToken$1.run(AppWindowToken.java:2258)
WindowManager:  at android.os.Handler.handleCallback(Handler.java:883)
WindowManager:  at android.os.Handler.dispatchMessage(Handler.java:100)
WindowManager:  at android.os.Looper.loop(Looper.java:221)
WindowManager:  at android.os.HandlerThread.run(HandlerThread.java:67)
WindowManager:  at com.android.server.ServiceThread.run(ServiceThread.java:44)

WindowManager:  WindowState:Window{5a02cc1 u0 com.android.messaging/com.android.messaging.ui.conversationlist.ConversationListActivity}
WindowManager: java.lang.Throwable
WindowManager:  at com.android.server.wm.WindowState.<init>(WindowState.java:751)
WindowManager:  at com.android.server.wm.WindowManagerService.addWindow(WindowManagerService.java:1562)
WindowManager:  at com.android.server.wm.Session.addToDisplay(Session.java:159)
WindowManager:  at android.view.IWindowSession$Stub.onTransact(IWindowSession.java:525)
WindowManager:  at com.android.server.wm.Session.onTransact(Session.java:134)
WindowManager:  at android.os.Binder.execTransactInternal(Binder.java:1021)
WindowManager:  at android.os.Binder.execTransact(Binder.java:994)

private final Configuration mTempConfiguration = new Configuration();

public final WindowConfiguration windowConfiguration = new WindowConfiguration();

/** The current windowing mode of the configuration. */
private @WindowingMode int mWindowingMode;

void reconfigureDisplayLocked() {
    if (!isReady()) {
        return;
    }
    configureDisplayPolicy();
    setLayoutNeeded();
​
    boolean configChanged = updateOrientation();
    final Configuration currentDisplayConfig = getConfiguration();
    mTmpConfiguration.setTo(currentDisplayConfig);
    computeScreenConfiguration(mTmpConfiguration);
    final int changes = currentDisplayConfig.diff(mTmpConfiguration);
    configChanged |= changes != 0;
​
    if (configChanged) {
        mWaitingForConfig = true;
        if (mTransitionController.isShellTransitionsEnabled()) {
            requestChangeTransitionIfNeeded(changes, null /* displayChange */);
        } else if (mLastHasContent) {
            mWmService.startFreezingDisplay(0 /* exitAnim */, 0 /* enterAnim */, this);
        }
        sendNewConfiguration();
    }
​
    mWmService.mWindowPlacerLocked.performSurfacePlacement();
}

public Configuration getConfiguration() {
    // If the process has not registered to any display area to listen to the configuration
    // change, we can simply return the mFullConfiguration as default.
    if (!registeredForDisplayAreaConfigChanges()) {
        return super.getConfiguration();
    }
​
    // We use the process config this window is associated with as the based global config since
    // the process can override its config, but isn't part of the window hierarchy.
    mTempConfiguration.setTo(getProcessGlobalConfiguration());
    mTempConfiguration.updateFrom(getMergedOverrideConfiguration());
    return mTempConfiguration;
}

/**
 * Current global configuration information. Contains general settings for the entire system,
 * also corresponds to the merged configuration of the default display.
 */
Configuration getGlobalConfiguration() {
    // Return default configuration before mRootWindowContainer initialized, which happens
    // while initializing process record for system, see {@link
    // ActivityManagerService#setSystemProcess}.
    return mRootWindowContainer != null ? mRootWindowContainer.getConfiguration()
            : new Configuration();
}

private void updateDecorCaptionStatus(Configuration config) {
    final boolean displayWindowDecor = config.windowConfiguration.hasWindowDecorCaption()
            && !isFillingScreen(config);
    if (mDecorCaptionView == null && displayWindowDecor) {
        // Configuration now requires a caption.
        final LayoutInflater inflater = mWindow.getLayoutInflater();
        mDecorCaptionView = createDecorCaptionView(inflater);
        if (mDecorCaptionView != null) {
            if (mDecorCaptionView.getParent() == null) {
                addView(mDecorCaptionView, 0,
                        new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
            }
            removeView(mContentRoot);
            mDecorCaptionView.addView(mContentRoot,
                    new ViewGroup.MarginLayoutParams(MATCH_PARENT, MATCH_PARENT));
        }
    } else if (mDecorCaptionView != null) {
        // We might have to change the kind of surface before we do anything else.
        mDecorCaptionView.onConfigurationChanged(displayWindowDecor);
        enableCaption(displayWindowDecor);
    }
}

// True if the window is being dragged.
    private boolean mDragging = false;
​
    private boolean mOverlayWithAppContent = false;
​
    private View mCaption;
    private View mContent;
    private View mMaximize;
    private View mClose;
​
    // Fields for detecting drag events.
    private int mTouchDownX;
    private int mTouchDownY;
    private boolean mCheckForDragging;
    private int mDragSlop;

public boolean onSingleTapUp(MotionEvent e) {
    if (mClickTarget == mMaximize) {
        toggleFreeformWindowingMode();
    } else if (mClickTarget == mClose) {
        mOwner.dispatchOnWindowDismissed(
                true /*finishTask*/, false /*suppressWindowTransition*/);
    }
    return true;
}

  case MotionEvent.ACTION_MOVE:
      if (!mDragging && mCheckForDragging && (fromMouse || passedSlop(x, y))) {
      mCheckForDragging = false;
      mDragging = true;
      startMovingTask(e.getRawX(), e.getRawY());
      // After the above call the framework will take over the input.
      // This handler will receive ACTION_CANCEL soon (possible after a few spurious
      // ACTION_MOVE events which are safe to ignore).
    }
    break;

public final boolean startMovingTask(float startX, float startY) {
    if (ViewDebug.DEBUG_POSITIONING) {
        Log.d(VIEW_LOG_TAG, "startMovingTask: {" + startX + "," + startY + "}");
    }
    try {
        return mAttachInfo.mSession.startMovingTask(mAttachInfo.mWindow, startX, startY);
    } catch (RemoteException e) {
        Log.e(VIEW_LOG_TAG, "Unable to start moving", e);
    }
    return false;
}

@Retention(RetentionPolicy.SOURCE)
@IntDef(flag = false,
         value = {
            MODE_EMPTY,
            MODE_ROUND_RECT,
            MODE_PATH,
          })
public @interface Mode {}

// Check if the freeform window overlaps with the navigation bar area. // 查看自在窗口是否与导航栏区域堆叠。
if (!mIsFreeformWindowOverlappingWithNavBar && win.inFreeformWindowingMode()
     && win.mActivityRecord != null && isOverlappingWithNavBar(win)) {  // 假如窗口是自在窗口，而且窗口和导航栏堆叠
      mIsFreeformWindowOverlappingWithNavBar = true;
}

 /**
     * @return the current visibility flags with the nav-bar opacity related flags toggled based
     *         on the nav bar opacity rules chosen by {@link #mNavBarOpacityMode}.
     */
    private int configureNavBarOpacity(int appearance, boolean multiWindowTaskVisible,
            boolean freeformRootTaskVisible) {
        final boolean drawBackground = drawsBarBackground(mNavBarBackgroundWindow);
        if (mNavBarOpacityMode == NAV_BAR_FORCE_TRANSPARENT) {
            if (drawBackground) {
                appearance = clearNavBarOpaqueFlag(appearance);
            }
        } else if (mNavBarOpacityMode == NAV_BAR_OPAQUE_WHEN_FREEFORM_OR_DOCKED) {
            if (multiWindowTaskVisible || freeformRootTaskVisible) {
                if (mIsFreeformWindowOverlappingWithNavBar) { // 假如自在窗口和导航栏堆叠
                    appearance = clearNavBarOpaqueFlag(appearance); // 使导航栏变成不透明的纯深色背景和淡色背景。
                }

  private void updateElevation() {
        final int windowingMode =
                getResources().getConfiguration().windowConfiguration.getWindowingMode();
        final boolean renderShadowsInCompositor = mWindow.mRenderShadowsInCompositor;
        // If rendering shadows in the compositor, don't set an elevation on the view // 假如在合成器中烘托暗影，请不要在视图上设置高度
        if (renderShadowsInCompositor) {
            return;
        }
        float elevation = 0;
        final boolean wasAdjustedForStack = mElevationAdjustedForStack;
        // Do not use a shadow when we are in resizing mode (mBackdropFrameRenderer not null)
        // since the shadow is bound to the content size and not the target size. // 当咱们处于调整巨细办法（mBackdropFrameRenderer不为空）时不要运用暗影，由于暗影绑定到内容巨细而不是方针巨细。
        if ((windowingMode == WINDOWING_MODE_FREEFORM) && !isResizing()) {
            elevation = hasWindowFocus() ?
                    DECOR_SHADOW_FOCUSED_HEIGHT_IN_DIP : DECOR_SHADOW_UNFOCUSED_HEIGHT_IN_DIP; // 假如有焦点，则为DECOR_SHADOW_FOCUSED_HEIGHT_IN_DIP=20，否则为DECOR_SHADOW_UNFOCUSED_HEIGHT_IN_DIP=5
            // Add a maximum shadow height value to the top level view.
            // Note that pinned stack doesn't have focus
            // so maximum shadow height adjustment isn't needed. // 为顶级视图增加最大暗影高度值。注意，固定仓库没有焦点，因而不需求最大暗影高度调整。
            // TODO(skuhne): Remove this if clause once b/22668382 got fixed.
            if (!mAllowUpdateElevation) {
                elevation = DECOR_SHADOW_FOCUSED_HEIGHT_IN_DIP;
            }
            // Convert the DP elevation into physical pixels.
            elevation = dipToPx(elevation);
            mElevationAdjustedForStack = true;
        }

DragState
    notifyLocationLocked(float, float)
            WindowState touchedWin = mDisplayContent.getTouchableWinAtPointLocked(x, y);
    notifyDropLocked(float, float)
            final WindowState touchedWin = mDisplayContent.getTouchableWinAtPointLocked(x, y);
WindowManagerService
    updatePointerIcon(IWindow)
                        displayContent.getTouchableWinAtPointLocked(mouseX, mouseY);
    restorePointerIconLocked(DisplayContent, float, float)
                    displayContent.getTouchableWinAtPointLocked(latestX, latestY);
​