Android Framework-理解 Window & WindowManager

一、概论

    Window 是一个窗口的概念，是所有视图的载体，不管是 Activity，Dialog，还是 Toast，他们的视图都是附加在 Window 上面的。例如在桌面显示一个悬浮窗，就需要用到 Window 来实现。WindowManager 是访问 Window 的入口。

  • Window 是一个抽象类，他的实现类是 PhoneWidow
  • Activity 中的 DecorView ，Dialog 中的 View 都是在 PhoneWindow 中创建的

因此 Window 实际是 View 的直接管理者

1.1 如何新增一个window
 /**
     * 添加新窗口
     */
    fun addNewWindow() {
        val mTextView = TextView(this).apply {
            text = "window"
            textSize = 20f
            setTextColor(Color.WHITE)
            setBackgroundColor(Color.RED)
        }
        val mParent = WindowManager.LayoutParams(
            WindowManager.LayoutParams.WRAP_CONTENT,
            WindowManager.LayoutParams.WRAP_CONTENT,
            0, 0, PixelFormat.TRANSPARENT
        )
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            mParent.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
        } else {
            mParent.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT
        }
        mParent.flags =
            WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
        mParent.x = 250
        mParent.y = 450
        windowManager.addView(mTextView, mParent)
    }

以上代码就是往页面新增一个系统window，效果图如下：

需要注意的几点是：

  • 在Android O （13）上需要改对应的 TYPE
  • 在Android O （13）上需要给 悬浮窗 权限
  • 需要在清单文件中加上这句权限：
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

    上面代码中 Type 和 Flags 的属性比较重要，这里把它列出来

Type 窗口属性
Window 类型 层级范围 说明
应用 Window 1 ~ 99 对应着一个 Activity
子 Window 1000 ~ 1999 不能单独存在，需要附属在特定的 Window 之中，例如常见的 PopupDialog，就是子 Window。
系统 Window 2000 ~ 2999 需要声明权限才能创建的 Window,，例如 Toast 和 系统状态栏这些都是系统的 Window
  • 子 Window 无法单独存在，必须依赖父级 Window，例如 PopWindow 必须依赖 Activity
  • Window 分层，在显示时层级高的会覆盖层级低的窗口
Flags窗口的标志

Flags 表示 Window 的属性，它有多选项，通过这些可以通知 Window 显示的特性，例如：

Flags 特性
FLAG_NOT_FOCUSABLE 表示 Window 不需要获取焦点，也不需要各种输入事件，此标记通同时启用 FLAG_NOT_TOUCH_MODAL最终事件会直接传递给下层具有焦点的 Window。
FLAG_NOT_TOUCH_MODAL 将 Window 区域以外的单击事件传递给底层的 Window，当前 Window 内的单击事件自己处理，一般都要开启此事件，否则其他 Window 无法收到单击事件
FLAG_SHOW_WHEN_LOCKED 可以将 Window 显示在锁屏的界面上
FLAG_TURN_SCREEN_ON Window 显示时将屏幕点亮

二、源码流程解析

    上面demo的最后一句代码中通过 windowManager 在屏幕上添加了一个系统级别的 Window，通过 windowManager 的addView 方法。那我们从这里跟进去看源码，看看具体的添加流程是怎样的。

2.1 WindowManager & ViewManager
#WindowManager 
@[SystemService]
public interface WindowManager extends ViewManager

--------------------------------------------------------------------------------------

#ViewManager
public interface ViewManager{
    public void addView(View view, ViewGroup.LayoutParams params);
    public void updateViewLayout(View view, ViewGroup.LayoutParams params);
    public void removeView(View view);
}

可以看到 Windowmanger 其实是个接口，其中 (addView，updateViewLayout，removeView) 更新方法其实是继承自ViewManager。而真正实现 WindowManger 这3个方法的实现类是 WindowManagerImpl

public final class WindowManagerImpl implements WindowManager {
    
    //·····

    @Override
    public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyTokens(params);
        mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
                mContext.getUserId());
    }

    @Override
    public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyTokens(params);
        mGlobal.updateViewLayout(view, params);
    }

    @Override
    public void removeView(View view) {
        mGlobal.removeView(view, false);
    }
}

上面代码看到，真正实现操作的是 mGlobal 这个对象：

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();
2.2 WindowManagerGlobal.addView

可以看到 WindowManagerImpl 并没有直接实现 Window 三大操作，而是全部交给了 WindowManagerGlobal 来处理。

private final ArrayList<View> mViews = new ArrayList<View>();
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
private final ArrayList<WindowManager.LayoutParams> mParams = new ArrayList<WindowManager.LayoutParams>();
private final ArraySet<View> mDyingViews = new ArraySet<View>();


public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
    //检测参数是否合法
    if (view == null) {
        throw new IllegalArgumentException("view must not be null");
    }
    if (display == null) {
        throw new IllegalArgumentException("display must not be null");
    }
    if (!(params instanceof WindowManager.LayoutParams)) {
        throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
    }

    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
    if (parentWindow != null) {
        parentWindow.adjustLayoutParamsForSubWindow(wparams);
    } else {
        //.... 
    }

    // 真正设置window的主
    ViewRootImpl root;
    View panelParentView = null;

    //创建 ViewRootImpl，并赋值给 root
    root = new ViewRootImpl(view.getContext(), display);
    
    //设置 View 的params
    view.setLayoutParams(wparams);
    
    //将 view，RootRootImpl，wparams 添加到列表中
    mViews.add(view);
    mRoots.add(root);
    mParams.add(wparams);

    
    try {
        //调用 ViewRootImpl 来更新界面并完成 Window 的添加过程
        root.setView(view, wparams, panelParentView);
    } catch (RuntimeException e) {
        // BadTokenException or InvalidDisplayException, clean up.
        if (index >= 0) {
            removeViewLocked(index, true);
        }
        throw e;
    }
}

首先声明了几个列表：

  • mViews 中是所有 Window 对应的 View
  • mRoots 中是所有 Window 对应的 ViewRootImpl
  • mParams 存储的是所有 Window 所对应的布局参数
  • 而 mDyingViews 中是哪些真在被删除的 View，或者说是已经调用 RemoveView 但是删除操作没有完成的 Window 对象。

上面代码中，创建了 ViewRootImpl，然后将 view，ViewRootImpl，wparams 添加到列表中。最后通过 ViewRootImpl 来完成添加 Window 的过程。

2.2 ViewRootImpl.setView

接着我们进到 ViewRootImpl 中的 setView 方法来看这里的添加过程

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    //   Binder 对象
    final IWindowSession mWindowSession;

    synchronized (this) {
        if (mView == null) {
            mView = view;

            // Schedule the first layout -before- adding to the window
            // manager, to make sure we do the relayout before receiving
            // any other events from the system.
            // 添加window之前，先进行一次刷新请求
            requestLayout();

            try {
                mOrigWindowType = mWindowAttributes.type;
                mAttachInfo.mRecomputeGlobalAttributes = true;
                collectViewAttributes();

               //调用了 mWindowSession.addToDisplay 方法，来完成最终的 Window 的添加过程
                res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                        //  ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
                        getHostVisibility(), mDisplay.getDisplayId(), mTmpFrame,
                        mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                        mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel,
                        mTempInsets);
                setFrame(mTmpFrame);
            }
            //.....
        }
    }
}

@Override
public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

在上面的代码中首先会调用 requestLayout 来进行一次刷新请求，其中 scheduleTraversals() 是 View 绘制的入口
requestLayout 调用之后，调用了 mWindowSession.addToDisplay 方法，来完成最终的 Window 的添加过程。
在上面代码中，mWindowSession 的类型是 IWindowSession，他是一个 Binder 对象，真正的实现是 Session，也就是 Window 的添加过程是一次 IPC 调用。

// IWindowSession 
interface IWindowSession { 
    int addToDisplay(IWindow window, in WindowManager.LayoutParams attrs, 
    in int viewVisibility, in int layerStackId, in InsetsVisibilities requestedVisibilities, 
    out InputChannel outInputChannel, out InsetsState insetsState, 
    out InsetsSourceControl[] activeControls, out Rect attachedFrame, 
    out float[] sizeCompatScale);
    //.......
  }

//------------------------------------------------------------------------------------------------------------------
class Session extends IWindowSession.Stub implements IBinder.DeathRecipient {

final WindowManagerService mService;

 @Override
    public int addToDisplay(IWindow window, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, InsetsVisibilities requestedVisibilities,
            InputChannel outInputChannel, InsetsState outInsetsState,
            InsetsSourceControl[] outActiveControls, Rect outAttachedFrame,
            float[] outSizeCompatScale) {
        return mService.addWindow(this, window, attrs, viewVisibility, displayId,
                UserHandle.getUserId(mUid), requestedVisibilities, outInputChannel, outInsetsState,
                outActiveControls, outAttachedFrame, outSizeCompatScale);
    }

可以看到 IWindowSession 是个aidl文件的接口，真实的实现类是Session，在其中真正实现了addToDisplay方法，接着就交给了mService调用addWindow()方法。而这个mService就是 WindowManagerService。
如此一来，Window 的添加过程就交给了WindowManagerService去处理。WMS 会为其分配 Surface，确定窗口显示的次序，最终通过 SurfaceFlinger 将这些 Surface 绘制到屏幕上。这部分的内容我们在后续的文章进行分析。

2.3 添加window流程分析
  1. windowManager.addView
  2. WindowManagerImpl.addView 在 addView 中将实现委托给了 WindowManagerGlobal.addView()
  3. 在 addView 中创建了 ViewRootImpl 赋值给了 root 。然后将 view，params，root 全部存入了各自的列表中。最后调用了 ViewRootImpl.setView()
  4. 在 setView 中通过调用 requestLayout 完成刷新的请求，接着会通过 IWindowSession 来完成最终的 Window 添加的过程，IWindowSession 是一个 Binder 对象，真正的实现类是 Session，也就是说 Window 的添加过程试一次 IPC 的调用。在 Session 中会通过 WindowManagerService 的addWindow 方法来实现 Window 的添加。
2.4 Window 更新源码分析

上面看到window的更新也是通过 WindowManagerGlobal 这个代理类来进行操作的，那就从WindowManagerGlobal 的 updateViewLayout 进去看看底层的更新操作

public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }
        //将更新的参数设置到 view 中
        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

        view.setLayoutParams(wparams);

        synchronized (mLock) {
            //获取到 view 在列表中的索引
            int index = findViewLocked(view, true);
             //拿到 view 对应的 ViewRootImpl            
            ViewRootImpl root = mRoots.get(index);
            //从参数列表中移除旧的参数
            mParams.remove(index);
            //将新的参数添加到指定的位置中
            mParams.add(index, wparams);
            //调用 ViewRootImpl.setLayoutPrams 对参数进行更新
            root.setLayoutParams(wparams, false);
        }
    }

通过 ViewRootImpl 的setLayoutParams方法对Window进行更新操作：

void setLayoutParams(WindowManager.LayoutParams attrs, boolean newView) { 
  //..........
  scheduleTraversals();

  void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    //通过runnable进行刷新
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

final class TraversalRunnable implements Runnable {
        @Override
        public void run() {
            // 进行刷新操作
            doTraversal();
        }
    }
    final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
}

void doTraversal() {
    //.....
            // 刷新操作
            performTraversals();
    //.....
}

private void performTraversals() {
  //刷新操作
  relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);

private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,
      // 通过mWindowSession进行刷新
        int relayoutResult = mWindowSession.relayout(mWindow, mSeq, params,
                (int) (mView.getMeasuredWidth() * appScale + 0.5f),
                (int) (mView.getMeasuredHeight() * appScale + 0.5f), viewVisibility,
                insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0, frameNumber,
                mWinFrame, mPendingOverscanInsets, mPendingContentInsets, mPendingVisibleInsets,
                mPendingStableInsets, mPendingOutsets, mPendingBackDropFrame, mPendingDisplayCutout,
                mPendingMergedConfiguration, mSurface);
    }
}

在 setLayoutPrams 方法中，最终调用了 scheduleTraversals 方法来对 View 重新策略，布局，重绘。

 @Override
    public int relayout(IWindow window, WindowManager.LayoutParams attrs,
            int requestedWidth, int requestedHeight, int viewFlags, int flags, int seq,
            int lastSyncSeqId, ClientWindowFrames outFrames,
            MergedConfiguration mergedConfiguration, SurfaceControl outSurfaceControl,
            InsetsState outInsetsState, InsetsSourceControl[] outActiveControls,
            Bundle outSyncSeqIdBundle) {
      // 通过WindowManagerService来更新视图
        int res = mService.relayoutWindow(this, window, attrs,
                requestedWidth, requestedHeight, viewFlags, flags, seq,
                lastSyncSeqId, outFrames, mergedConfiguration, outSurfaceControl, outInsetsState,
                outActiveControls, outSyncSeqIdBundle);
        return res;
    }

除了 View 本身的重绘外，ViewRootImpl 还会通过 WindowSession 来更新 Window 视图，这个过程是由 WindowManagerService 的 relayoutWindow 来实现的，这同样也是一个 IPC 过程。

2.5 Window 删除源码分析

Window 的删除过程和添加过程都一样，都是先通过 WindowManagerImpl 后，在进一步通过 WindowManagerGlobal 来实现的：

    @Override
    public void removeView(View view) {
        // 异步移除
        mGlobal.removeView(view, false);
    }

    @Override
    public void removeViewImmediate(View view) {
        // 同步移除
        mGlobal.removeView(view, true);
    }


public void removeView(View view, boolean immediate) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            //找到在 views 列表中的索引
            View curView = mRoots.get(index).getView();
            removeViewLocked(index, immediate);
            if (curView == view) {
                return;
            }

            throw new IllegalStateException("Calling with view " + view
                    + " but the ViewAncestor is attached to " + curView);
        }
    }

上面代码中，找到在 views 列表中的索引，然后调用了 removeViewLocked 来做进一步的删除

private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();

        if (view != null) {
            InputMethodManager imm = InputMethodManager.getInstance();
            if (imm != null) {
                imm.windowDismissed(mViews.get(index).getWindowToken());
            }
        }
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                mDyingViews.add(view);
            }
        }
    }

removeViewLocked 是通过 ViewRootImpl 来完成删除操作的。在 WindowManager 中提供了两种删除接口 removeView 和 removeViewImmedialte 分别是异步删除和同步删除。
一般不会使用 removeViewImmedialte 来删除 Window，以免发生意外错误。
所以这里使用的是 异步的删除情况，采用的是 die 方法。die 方法只是发送了一个请求删除的消息就立刻返回了，这个时候 View 并没有完成删除操作，所以最后会将其添加到 mDyingViews列表中。

#ViewRootImpl

/**
     * @param immediate True, do now if not in traversal. False, put on queue and do later.
     * @return True, request has been queued. False, request has been completed.
     */
    boolean die(boolean immediate) {
        // Make sure we do execute immediately if we are in the middle of a traversal or the damage
        // done by dispatchDetachedFromWindow will cause havoc on return.
        if (immediate && !mIsInTraversal) {
            doDie();
            return false;
        }

        if (!mIsDrawing) {
            destroyHardwareRenderer();
        } else {
            Log.e(mTag, "Attempting to destroy the window while drawing!\n" +
                    "  window=" + this + ", title=" + mWindowAttributes.getTitle());
        }
        mHandler.sendEmptyMessage(MSG_DIE);
        return true;
    }

从源码的注释看出：

  • 如果传入是true则马上移除，同时返回 false 代表移除完成（同步删除）
  • 如果传入的是false则加入到队列中等待执行，同时返回true表示等待执行。（异步删除）

这个方法里面做了判断，如果是异步删除就会发送一个 MSG_DIE 的消息，ViewRootImpl 中的 handler 会收到这个消息，并调用 doDie 方法，这就是这两种删除方式的区别。

        @Override
        public void handleMessage(Message msg) {
              case MSG_DIE:
                    doDie();
                    break
}

    void doDie() {
        checkThread();
        if (LOCAL_LOGV) Log.v(mTag, "DIE in " + this + " of " + mSurface);
        synchronized (this) {
            if (mRemoved) {
                return;
            }
            mRemoved = true;
            if (mAdded) {
                 //真正执行删除的逻辑
                dispatchDetachedFromWindow();
            }

            if (mAdded && !mFirst) {
                destroyHardwareRenderer();
              //...........
            mAdded = false;
        }
        WindowManagerGlobal.getInstance().doRemoveView(this);
    }


   void dispatchDetachedFromWindow() {
      try {
            //........
            mWindowSession.remove(mWindow);
           //........
        } catch (RemoteException e) {
        }
    }

在上面代码中最后通过ViewRootImpl 的 doDie 方法执行移除操作，接着在dispatchDetachedFromWindow方法中执行真正的移除操作。而最终还是交给了mWindowSession的remove方法。
依旧是通过IPC，最终交给Session的 remove方法来执行移除操作。

@Override
    public void remove(IWindow window) {
        mService.removeWindow(this, window);
    }

可以看到还是通过WindowManagerService来执行最后的移除操作。

三、总结

Window 的 创建，更新，移除 操作都是通 ViewRootImpl 使用 IPC与WMS（WindowManagerService ）通信来实现的。

Window 添加，更新，移除

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 205,033评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,725评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,473评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,846评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,848评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,691评论 1赞 282
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,053评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,700评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,856评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,676评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,787评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,430评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,034评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,990评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,218评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,174评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,526评论 2赞 343

推荐阅读更多精彩内容