1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.window;
18 
19 import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
20 import static android.app.WindowConfiguration.WindowingMode;
21 
22 import android.annotation.NonNull;
23 import android.annotation.TestApi;
24 import android.graphics.Rect;
25 import android.os.IBinder;
26 import android.os.Parcel;
27 import android.os.Parcelable;
28 
29 /**
30  * Data object for options to create TaskFragment with.
31  * @hide
32  */
33 @TestApi
34 public final class TaskFragmentCreationParams implements Parcelable {
35 
36     /** The organizer that will organize this TaskFragment. */
37     @NonNull
38     private final TaskFragmentOrganizerToken mOrganizer;
39 
40     /**
41      * Unique token assigned from the client organizer to identify the {@link TaskFragmentInfo} when
42      * a new TaskFragment is created with this option.
43      */
44     @NonNull
45     private final IBinder mFragmentToken;
46 
47     /**
48      * Activity token used to identify the leaf Task to create the TaskFragment in. It has to belong
49      * to the same app as the root Activity of the target Task.
50      */
51     @NonNull
52     private final IBinder mOwnerToken;
53 
54     /** The initial bounds of the TaskFragment. Fills parent if empty. */
55     @NonNull
56     private final Rect mInitialBounds = new Rect();
57 
58     /** The initial windowing mode of the TaskFragment. Inherits from parent if not set. */
59     @WindowingMode
60     private int mWindowingMode = WINDOWING_MODE_UNDEFINED;
61 
TaskFragmentCreationParams( @onNull TaskFragmentOrganizerToken organizer, @NonNull IBinder fragmentToken, @NonNull IBinder ownerToken)62     private TaskFragmentCreationParams(
63             @NonNull TaskFragmentOrganizerToken organizer,
64             @NonNull IBinder fragmentToken, @NonNull IBinder ownerToken) {
65         mOrganizer = organizer;
66         mFragmentToken = fragmentToken;
67         mOwnerToken = ownerToken;
68     }
69 
70     @NonNull
getOrganizer()71     public TaskFragmentOrganizerToken getOrganizer() {
72         return mOrganizer;
73     }
74 
75     @NonNull
getFragmentToken()76     public IBinder getFragmentToken() {
77         return mFragmentToken;
78     }
79 
80     @NonNull
getOwnerToken()81     public IBinder getOwnerToken() {
82         return mOwnerToken;
83     }
84 
85     @NonNull
getInitialBounds()86     public Rect getInitialBounds() {
87         return mInitialBounds;
88     }
89 
90     @WindowingMode
getWindowingMode()91     public int getWindowingMode() {
92         return mWindowingMode;
93     }
94 
TaskFragmentCreationParams(Parcel in)95     private TaskFragmentCreationParams(Parcel in) {
96         mOrganizer = TaskFragmentOrganizerToken.CREATOR.createFromParcel(in);
97         mFragmentToken = in.readStrongBinder();
98         mOwnerToken = in.readStrongBinder();
99         mInitialBounds.readFromParcel(in);
100         mWindowingMode = in.readInt();
101     }
102 
103     /** @hide */
104     @Override
writeToParcel(@onNull Parcel dest, int flags)105     public void writeToParcel(@NonNull Parcel dest, int flags) {
106         mOrganizer.writeToParcel(dest, flags);
107         dest.writeStrongBinder(mFragmentToken);
108         dest.writeStrongBinder(mOwnerToken);
109         mInitialBounds.writeToParcel(dest, flags);
110         dest.writeInt(mWindowingMode);
111     }
112 
113     @NonNull
114     public static final Creator<TaskFragmentCreationParams> CREATOR =
115             new Creator<TaskFragmentCreationParams>() {
116                 @Override
117                 public TaskFragmentCreationParams createFromParcel(Parcel in) {
118                     return new TaskFragmentCreationParams(in);
119                 }
120 
121                 @Override
122                 public TaskFragmentCreationParams[] newArray(int size) {
123                     return new TaskFragmentCreationParams[size];
124                 }
125             };
126 
127     @Override
toString()128     public String toString() {
129         return "TaskFragmentCreationParams{"
130                 + " organizer=" + mOrganizer
131                 + " fragmentToken=" + mFragmentToken
132                 + " ownerToken=" + mOwnerToken
133                 + " initialBounds=" + mInitialBounds
134                 + " windowingMode=" + mWindowingMode
135                 + "}";
136     }
137 
138     /** @hide */
139     @Override
describeContents()140     public int describeContents() {
141         return 0;
142     }
143 
144     /** Builder to construct the options to create TaskFragment with. */
145     public static final class Builder {
146 
147         @NonNull
148         private final TaskFragmentOrganizerToken mOrganizer;
149 
150         @NonNull
151         private final IBinder mFragmentToken;
152 
153         @NonNull
154         private final IBinder mOwnerToken;
155 
156         @NonNull
157         private final Rect mInitialBounds = new Rect();
158 
159         @WindowingMode
160         private int mWindowingMode = WINDOWING_MODE_UNDEFINED;
161 
Builder(@onNull TaskFragmentOrganizerToken organizer, @NonNull IBinder fragmentToken, @NonNull IBinder ownerToken)162         public Builder(@NonNull TaskFragmentOrganizerToken organizer,
163                 @NonNull IBinder fragmentToken, @NonNull IBinder ownerToken) {
164             mOrganizer = organizer;
165             mFragmentToken = fragmentToken;
166             mOwnerToken = ownerToken;
167         }
168 
169         /** Sets the initial bounds for the TaskFragment. */
170         @NonNull
setInitialBounds(@onNull Rect bounds)171         public Builder setInitialBounds(@NonNull Rect bounds) {
172             mInitialBounds.set(bounds);
173             return this;
174         }
175 
176         /** Sets the initial windowing mode for the TaskFragment. */
177         @NonNull
setWindowingMode(@indowingMode int windowingMode)178         public Builder setWindowingMode(@WindowingMode int windowingMode) {
179             mWindowingMode = windowingMode;
180             return this;
181         }
182 
183         /** Constructs the options to create TaskFragment with. */
184         @NonNull
build()185         public TaskFragmentCreationParams build() {
186             final TaskFragmentCreationParams result = new TaskFragmentCreationParams(
187                     mOrganizer, mFragmentToken, mOwnerToken);
188             result.mInitialBounds.set(mInitialBounds);
189             result.mWindowingMode = mWindowingMode;
190             return result;
191         }
192     }
193 }
194