1/*
2 * Copyright (C) 2014 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
17package android.support.v4.app;
18
19import android.app.Notification;
20import android.app.PendingIntent;
21import android.content.Intent;
22import android.os.Bundle;
23import android.support.tests.R;
24import android.test.AndroidTestCase;
25
26import java.util.Arrays;
27import java.util.List;
28
29/**
30 * Tests for {@link android.support.v4.app.NotificationCompat.Action.WearableExtender}.
31 */
32public class NotificationCompatActionWearableExtenderTest extends AndroidTestCase {
33
34    private int mIcon;
35    private String mTitle = "Test Title";
36    private PendingIntent mPendingIntent;
37
38    private String mInProgress = "In Progress Label";
39    private String mConfirm = "Confirmation Label";
40    private String mCancel = "Cancelation Label";
41
42    @Override
43    protected void setUp() throws Exception {
44        super.setUp();
45
46        mIcon = R.drawable.action_icon;
47        mPendingIntent = PendingIntent.getActivity(getContext(), 0, new Intent(), 0);
48    }
49
50    // Test that the default empty Extender is equal to the compat version.
51    public void testEmptyEquals() throws Exception {
52        assertExtendersEqual(new Notification.Action.WearableExtender(),
53                new NotificationCompat.Action.WearableExtender());
54    }
55
56    // Test that the fully populated Extender is equal to the compat version.
57    public void testFullEquals() throws Exception {
58        Notification.Action.WearableExtender baseExtender =
59            new Notification.Action.WearableExtender()
60                .setAvailableOffline(true)
61                .setInProgressLabel(mInProgress)
62                .setConfirmLabel(mConfirm)
63                .setCancelLabel(mCancel);
64        NotificationCompat.Action.WearableExtender compatExtender =
65            new NotificationCompat.Action.WearableExtender()
66                .setAvailableOffline(true)
67                .setInProgressLabel(mInProgress)
68                .setConfirmLabel(mConfirm)
69                .setCancelLabel(mCancel);
70        assertExtendersEqual(baseExtender, compatExtender);
71    }
72
73    // Test that the base WearableExtender from an empty Notification is equal to the compat.
74    public void testEmptyNotification() throws Exception {
75        Notification baseNotif = new Notification.Builder(getContext())
76                .build();
77        Notification compatNotif = new NotificationCompat.Builder(getContext())
78                .build();
79
80        assertExtendersFromNotificationEqual(baseNotif, baseNotif);
81        assertExtendersFromNotificationEqual(compatNotif, compatNotif);
82        assertExtendersFromNotificationEqual(baseNotif, compatNotif);
83        assertExtendersFromNotificationEqual(compatNotif, baseNotif);
84    }
85
86    public void testDefaultActionNotification() throws Exception {
87        Notification.Action.Builder baseAction =
88            new Notification.Action.Builder(mIcon, mTitle, mPendingIntent);
89        NotificationCompat.Action.Builder compatAction =
90            new NotificationCompat.Action.Builder(mIcon, mTitle, mPendingIntent);
91
92        Notification.WearableExtender baseNoteExtender =
93                new Notification.WearableExtender()
94                        .addAction(baseAction.build());
95        NotificationCompat.WearableExtender compatNoteExtender =
96                new NotificationCompat.WearableExtender()
97                        .addAction(compatAction.build());
98
99        Notification baseNotif = new Notification.Builder(getContext())
100                .extend(baseNoteExtender).build();
101        Notification compatNotif = new NotificationCompat.Builder(getContext())
102                .extend(compatNoteExtender).build();
103
104        assertExtendersFromNotificationEqual(baseNotif, baseNotif);
105        assertExtendersFromNotificationEqual(compatNotif, compatNotif);
106        assertExtendersFromNotificationEqual(baseNotif, compatNotif);
107        assertExtendersFromNotificationEqual(compatNotif, baseNotif);
108    }
109
110    public void testDefaultActionExtenderNotification() throws Exception {
111        Notification.Action.WearableExtender baseExtender =
112            new Notification.Action.WearableExtender();
113        NotificationCompat.Action.WearableExtender compatExtender =
114            new NotificationCompat.Action.WearableExtender();
115
116        Notification.Action.Builder baseAction =
117            new Notification.Action.Builder(mIcon, mTitle, mPendingIntent)
118                .extend(baseExtender);
119        NotificationCompat.Action.Builder compatAction =
120            new NotificationCompat.Action.Builder(mIcon, mTitle, mPendingIntent)
121                .extend(compatExtender);
122
123        Notification.WearableExtender baseNoteExtender =
124                new Notification.WearableExtender()
125                        .addAction(baseAction.build());
126        NotificationCompat.WearableExtender compatNoteExtender =
127                new NotificationCompat.WearableExtender()
128                        .addAction(compatAction.build());
129
130        Notification baseNotif = new Notification.Builder(getContext())
131                .extend(baseNoteExtender).build();
132        Notification compatNotif = new NotificationCompat.Builder(getContext())
133                .extend(compatNoteExtender).build();
134
135        assertExtendersFromNotificationEqual(baseNotif, baseNotif);
136        assertExtendersFromNotificationEqual(compatNotif, compatNotif);
137        assertExtendersFromNotificationEqual(baseNotif, compatNotif);
138        assertExtendersFromNotificationEqual(compatNotif, baseNotif);
139    }
140
141    public void testFullNotification() throws Exception {
142        Notification.Action.WearableExtender baseExtender =
143            new Notification.Action.WearableExtender()
144                .setAvailableOffline(true)
145                .setInProgressLabel(mInProgress)
146                .setConfirmLabel(mConfirm)
147                .setCancelLabel(mCancel);
148        NotificationCompat.Action.WearableExtender compatExtender =
149            new NotificationCompat.Action.WearableExtender()
150                .setAvailableOffline(true)
151                .setInProgressLabel(mInProgress)
152                .setConfirmLabel(mConfirm)
153                .setCancelLabel(mCancel);
154
155        Notification.Action.Builder baseAction =
156            new Notification.Action.Builder(mIcon, mTitle, mPendingIntent)
157                .extend(baseExtender);
158        NotificationCompat.Action.Builder compatAction =
159            new NotificationCompat.Action.Builder(mIcon, mTitle, mPendingIntent)
160                .extend(compatExtender);
161
162        Notification.WearableExtender baseNoteExtender =
163                new Notification.WearableExtender()
164                        .addAction(baseAction.build());
165        NotificationCompat.WearableExtender compatNoteExtender =
166                new NotificationCompat.WearableExtender()
167                        .addAction(compatAction.build());
168
169        Notification baseNotif = new Notification.Builder(getContext())
170                .extend(baseNoteExtender).build();
171        Notification compatNotif = new NotificationCompat.Builder(getContext())
172                .extend(compatNoteExtender).build();
173
174        assertExtendersFromNotificationEqual(baseNotif, baseNotif);
175        assertExtendersFromNotificationEqual(compatNotif, compatNotif);
176        assertExtendersFromNotificationEqual(baseNotif, compatNotif);
177        assertExtendersFromNotificationEqual(compatNotif, baseNotif);
178    }
179
180    public void testMultipleActionsInANotification() throws Exception {
181        Notification.Action.WearableExtender baseExtender1 =
182            new Notification.Action.WearableExtender()
183                .setAvailableOffline(true)
184                .setInProgressLabel(mInProgress)
185                .setConfirmLabel(mConfirm)
186                .setCancelLabel(mCancel);
187        NotificationCompat.Action.WearableExtender compatExtender1 =
188            new NotificationCompat.Action.WearableExtender()
189                .setAvailableOffline(true)
190                .setInProgressLabel(mInProgress)
191                .setConfirmLabel(mConfirm)
192                .setCancelLabel(mCancel);
193
194        Notification.Action.Builder baseAction1 =
195            new Notification.Action.Builder(mIcon, mTitle, mPendingIntent)
196                .extend(baseExtender1);
197        NotificationCompat.Action.Builder compatAction1 =
198            new NotificationCompat.Action.Builder(mIcon, mTitle, mPendingIntent)
199                .extend(compatExtender1);
200
201        Notification.Action.WearableExtender baseExtender2 =
202            new Notification.Action.WearableExtender()
203                .setAvailableOffline(false)
204                .setInProgressLabel("Alternate Label")
205                .setConfirmLabel("Duplicated Label")
206                .setCancelLabel("Duplicated Label");
207        NotificationCompat.Action.WearableExtender compatExtender2 =
208            new NotificationCompat.Action.WearableExtender()
209                .setAvailableOffline(false)
210                .setInProgressLabel("Alternate Label")
211                .setConfirmLabel("Duplicated Label")
212                .setCancelLabel("Duplicated Label");
213
214        Notification.Action.Builder baseAction2 =
215            new Notification.Action.Builder(mIcon, mTitle, mPendingIntent)
216                .extend(baseExtender2);
217        NotificationCompat.Action.Builder compatAction2 =
218            new NotificationCompat.Action.Builder(mIcon, mTitle, mPendingIntent)
219                .extend(compatExtender2);
220
221        Notification.WearableExtender baseNoteExtender =
222                new Notification.WearableExtender()
223                        .addAction(baseAction1.build())
224                        .addAction(new Notification.Action(R.drawable.action_icon2, "Action1",
225                                mPendingIntent))
226                        .addAction(baseAction2.build());
227        NotificationCompat.WearableExtender compatNoteExtender =
228                new NotificationCompat.WearableExtender()
229                        .addAction(compatAction1.build())
230                        .addAction(new NotificationCompat.Action(R.drawable.action_icon2,
231                                "Action1", mPendingIntent))
232                        .addAction(compatAction2.build());
233
234        Notification baseNotif = new Notification.Builder(getContext())
235                .extend(baseNoteExtender).build();
236        Notification compatNotif = new NotificationCompat.Builder(getContext())
237                .extend(compatNoteExtender).build();
238
239        assertExtendersFromNotificationEqual(baseNotif, baseNotif);
240        assertExtendersFromNotificationEqual(compatNotif, compatNotif);
241        assertExtendersFromNotificationEqual(baseNotif, compatNotif);
242        assertExtendersFromNotificationEqual(compatNotif, baseNotif);
243    }
244
245    private void assertExtendersEqual(Notification.Action.WearableExtender base,
246            NotificationCompat.Action.WearableExtender compat) {
247        assertEquals(base.isAvailableOffline(), compat.isAvailableOffline());
248        assertEquals(base.getInProgressLabel(), compat.getInProgressLabel());
249        assertEquals(base.getConfirmLabel(), compat.getConfirmLabel());
250        assertEquals(base.getCancelLabel(), compat.getCancelLabel());
251    }
252
253    // Parse the Notification using the base parser and the compat parser and confirm
254    // that the WearableExtender bundles are equivelent.
255    private void assertExtendersFromNotificationEqual(Notification first,
256                                                      Notification second) {
257        Notification.WearableExtender baseExtender = new Notification.WearableExtender(first);
258        NotificationCompat.WearableExtender compatExtender =
259            new NotificationCompat.WearableExtender(second);
260        List<Notification.Action> baseArray = baseExtender.getActions();
261        List<NotificationCompat.Action> compatArray = compatExtender.getActions();
262        assertEquals(baseArray.size(), compatArray.size());
263        for (int i = 0; i < baseArray.size(); i++) {
264            // Verify that the key value pairs are equal. We only care about
265            // the bundle in getExtras().getBundle("android.wearable.EXTENSIONS"),
266            // but it doesn't hurt to check them all as long we recurse.
267            assertBundlesEqual(baseArray.get(i).getExtras(),
268                               compatArray.get(i).getExtras());
269            // Verify that the parsed WearableExtentions are equal
270            Notification.Action.WearableExtender base =
271                new Notification.Action.WearableExtender(baseArray.get(i));
272            NotificationCompat.Action.WearableExtender compat =
273                new NotificationCompat.Action.WearableExtender(compatArray.get(i));
274            assertExtendersEqual(base, compat);
275        }
276    }
277
278    private void assertBundlesEqual(Bundle bundle1, Bundle bundle2) {
279        assertEquals(bundle1.size(), bundle2.size());
280        for (String key : bundle1.keySet()) {
281            Object value1 = bundle1.get(key);
282            Object value2 = bundle2.get(key);
283            if (value1 instanceof Bundle && value2 instanceof Bundle) {
284                assertBundlesEqual((Bundle) value1, (Bundle) value2);
285            } else {
286                assertEquals(value1, value2);
287            }
288        }
289    }
290}
291