Add Slices for WifiCalling

Add Slices for WifiCalling
WifiCalling Slice Provider:
  1. If there is no activation needed or if the Wifi calling
     is currently turned on - provide the slice to toggle the
     value
  2. Else display appropriate message with further instructions
WifiCalling Slice Broadcast Receiver:
  1. If the action is turning off wifi or if there is no
     activation needed. Change the setting with ImsManager.
  2. And Ask to requery the slice in one second to display
     updated settings if 1 is valid or display appropriate message

Bug: 63731862
Bug: 78192106
Test: Use support-slices-demos-debug.apk to test on device
Test: Robotests
Change-Id: I29e1822fd24ebcff575fa48ad93f84ed91bf4d87

res/values/strings.xml

@@ -2355,6 +2355,17 @@
     <!-- Message of private dns that provides a help link. [CHAR LIMIT=NONE] -->
     <string name="private_dns_help_message"><annotation id="url">Learn more</annotation> about Private DNS features</string>
 
+    <!-- Message to display when setting wifi calling are not editable [CHAR LIMIT=NONE] -->
+    <string name="wifi_calling_pref_managed_by_carrier">Setting managed by carrier</string>
+    <!-- Message to display when wifi calling needs activation [CHAR LIMIT=NONE] -->
+    <string name="wifi_calling_settings_activation_instructions">Activate Wi\u2011Fi Calling</string>
+    <!-- Message to display when wifi calling should be on [CHAR LIMIT=NONE] -->
+    <string name="wifi_calling_turn_on">Turn on Wi\u2011Fi calling</string>
+    <!-- Message to display when carrier does not support wifi calling or doesn't want the user
+         to modify the settings [CHAR LIMIT=NONE] -->
+    <string name="wifi_calling_not_supported">Wi\u2011Fi calling is not supported for %1$s</string>
+    <!-- Carrier string to use in other messages -->
+    <string name="carrier">Carrier</string>
     <!-- Sound and alerts settings -->
     <skip/>
     <string name="display_settings_title">Display</string>

src/com/android/settings/slices/SettingsSliceProvider.java

@@ -18,6 +18,8 @@ package com.android.settings.slices;
 
 import static android.Manifest.permission.READ_SEARCH_INDEXABLES;
 
+import static com.android.settings.wifi.calling.WifiCallingSliceHelper.PATH_WIFI_CALLING;
+
 import android.app.PendingIntent;
 import android.app.slice.SliceManager;
 import android.content.ContentResolver;
@@ -32,7 +34,13 @@ import android.text.TextUtils;
 import android.util.Log;
 import android.util.Pair;
 
+import androidx.slice.Slice;
+import androidx.slice.SliceProvider;
+import androidx.slice.builders.ListBuilder;
+import androidx.slice.builders.SliceAction;
+
 import com.android.settings.R;
+import com.android.settings.overlay.FeatureFactory;
 import com.android.settingslib.utils.ThreadUtils;
 
 import java.net.URISyntaxException;
@@ -160,6 +168,11 @@ public class SettingsSliceProvider extends SliceProvider {
         switch (path) {
             case "/" + PATH_WIFI:
                 return createWifiSlice(sliceUri);
+            case "/" + PATH_WIFI_CALLING:
+                return FeatureFactory.getFactory(getContext())
+                        .getSlicesFeatureProvider()
+                        .getNewWifiCallingSliceHelper(getContext())
+                        .createWifiCallingSlice(sliceUri);
         }
 
         SliceData cachedSliceData = mSliceWeakDataCache.get(sliceUri);

src/com/android/settings/slices/SliceBroadcastReceiver.java

@@ -21,6 +21,7 @@ import static com.android.settings.slices.SettingsSliceProvider.ACTION_TOGGLE_CH
 import static com.android.settings.slices.SettingsSliceProvider.ACTION_WIFI_CHANGED;
 import static com.android.settings.slices.SettingsSliceProvider.EXTRA_SLICE_KEY;
 import static com.android.settings.slices.SettingsSliceProvider.EXTRA_SLICE_PLATFORM_DEFINED;
+import static com.android.settings.wifi.calling.WifiCallingSliceHelper.ACTION_WIFI_CALLING_CHANGED;
 
 import android.app.slice.Slice;
 import android.content.BroadcastReceiver;
@@ -79,6 +80,12 @@ public class SliceBroadcastReceiver extends BroadcastReceiver {
                     context.getContentResolver().notifyChange(uri, null);
                 }, 1000);
                 break;
+            case ACTION_WIFI_CALLING_CHANGED:
+                FeatureFactory.getFactory(context)
+                      .getSlicesFeatureProvider()
+                      .getNewWifiCallingSliceHelper(context)
+                      .handleWifiCallingChanged(intent);
+                break;
         }
     }
 

src/com/android/settings/slices/SlicesFeatureProvider.java

@@ -2,6 +2,8 @@ package com.android.settings.slices;
 
 import android.content.Context;
 
+import com.android.settings.wifi.calling.WifiCallingSliceHelper;
+
 /**
  * Manages Slices in Settings.
  */
@@ -24,4 +26,9 @@ public interface SlicesFeatureProvider {
      * If the data is already indexed, the data will not change.
      */
     void indexSliceData(Context context);
-}
+
+    /**
+     * Gets new WifiCallingSliceHelper object
+     */
+    WifiCallingSliceHelper getNewWifiCallingSliceHelper(Context context);
+}

src/com/android/settings/slices/SlicesFeatureProviderImpl.java

@@ -2,6 +2,7 @@ package com.android.settings.slices;
 
 import android.content.Context;
 
+import com.android.settings.wifi.calling.WifiCallingSliceHelper;
 import com.android.settingslib.utils.ThreadUtils;
 
 /**
@@ -39,4 +40,9 @@ public class SlicesFeatureProviderImpl implements SlicesFeatureProvider {
         SlicesIndexer indexer = getSliceIndexer(context);
         indexer.indexSliceData();
     }
-}
+
+    @Override
+    public WifiCallingSliceHelper getNewWifiCallingSliceHelper(Context context) {
+        return new WifiCallingSliceHelper(context);
+    }
+}

src/com/android/settings/wifi/calling/WifiCallingSliceHelper.java

@@ -0,0 +1,363 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+package com.android.settings.wifi.calling;
+
+import static android.app.slice.Slice.EXTRA_TOGGLE_STATE;
+
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.PersistableBundle;
+import androidx.core.graphics.drawable.IconCompat;
+import android.telephony.CarrierConfigManager;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.util.Log;
+
+import androidx.slice.Slice;
+import androidx.slice.builders.ListBuilder;
+import androidx.slice.builders.SliceAction;
+
+import com.android.ims.ImsManager;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.settings.R;
+import com.android.settings.slices.SliceBroadcastReceiver;
+import com.android.settings.slices.SliceBuilderUtils;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+
+/**
+ * Helper class to control slices for wifi calling settings.
+ */
+public class WifiCallingSliceHelper {
+
+    private static final String TAG = "WifiCallingSliceHelper";
+
+    /**
+     * Settings slice path to wifi calling setting.
+     */
+    public static final String PATH_WIFI_CALLING = "wifi_calling";
+
+    /**
+     * Action passed for changes to wifi calling slice (toggle).
+     */
+    public static final String ACTION_WIFI_CALLING_CHANGED =
+            "com.android.settings.wifi.calling.action.WIFI_CALLING_CHANGED";
+
+    /**
+     * Action for Wifi calling Settings activity which
+     * allows setting configuration for Wifi calling
+     * related settings
+     */
+    public static final String ACTION_WIFI_CALLING_SETTINGS_ACTIVITY =
+            "android.settings.WIFI_CALLING_SETTINGS";
+
+    /**
+     * Timeout for querying wifi calling setting from ims manager.
+     */
+    private static final int TIMEOUT_MILLIS = 2000;
+
+    /**
+     * Time for which data contained in the slice can remain fresh.
+     */
+    private static final int SLICE_TTL_MILLIS = 60000;
+
+    protected SubscriptionManager mSubscriptionManager;
+    private final Context mContext;
+
+    @VisibleForTesting
+    public WifiCallingSliceHelper(Context context) {
+        mContext = context;
+    }
+
+    /**
+     * Returns Slice object for wifi calling settings.
+     *
+     * If wifi calling is being turned on and if wifi calling activation is needed for the current
+     * carrier, this method will return Slice with instructions to go to Settings App.
+     *
+     * If wifi calling is not supported for the current carrier, this method will return slice with
+     * not supported message.
+     *
+     * If wifi calling setting can be changed, this method will return the slice to toggle wifi
+     * calling option with ACTION_WIFI_CALLING_CHANGED as endItem.
+     */
+    public Slice createWifiCallingSlice(Uri sliceUri) {
+        final int subId = getDefaultVoiceSubId();
+        final String carrierName = getSimCarrierName();
+
+        if (subId <= SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
+            Log.d(TAG, "Invalid subscription Id");
+            return getNonActionableWifiCallingSlice(
+                    mContext.getString(R.string.wifi_calling_settings_title),
+                    mContext.getString(R.string.wifi_calling_not_supported, carrierName),
+                    sliceUri, SliceBuilderUtils.getSettingsIntent(mContext));
+        }
+
+        final ImsManager imsManager = getImsManager(subId);
+
+        if (!imsManager.isWfcEnabledByPlatform()
+                || !imsManager.isWfcProvisionedOnDevice()) {
+            Log.d(TAG, "Wifi calling is either not provisioned or not enabled by Platform");
+            return getNonActionableWifiCallingSlice(
+                    mContext.getString(R.string.wifi_calling_settings_title),
+                    mContext.getString(R.string.wifi_calling_not_supported, carrierName),
+                    sliceUri, SliceBuilderUtils.getSettingsIntent(mContext));
+        }
+
+        try {
+            final boolean isWifiCallingEnabled = isWifiCallingEnabled(imsManager);
+            final Intent activationAppIntent =
+                    getWifiCallingCarrierActivityIntent(subId);
+
+            // Send this actionable wifi calling slice to toggle the setting
+            // only when there is no need for wifi calling activation with the server
+            if (activationAppIntent != null && !isWifiCallingEnabled) {
+                Log.d(TAG, "Needs Activation");
+                // Activation needed for the next action of the user
+                // Give instructions to go to settings app
+                return getNonActionableWifiCallingSlice(
+                        mContext.getString(R.string.wifi_calling_settings_title),
+                        mContext.getString(
+                                R.string.wifi_calling_settings_activation_instructions),
+                        sliceUri, getActivityIntent(ACTION_WIFI_CALLING_SETTINGS_ACTIVITY));
+            }
+            return getWifiCallingSlice(sliceUri, mContext, isWifiCallingEnabled);
+        } catch (InterruptedException | TimeoutException | ExecutionException e) {
+            Log.e(TAG, "Unable to read the current WiFi calling status", e);
+            return getNonActionableWifiCallingSlice(
+                    mContext.getString(R.string.wifi_calling_settings_title),
+                    mContext.getString(R.string.wifi_calling_turn_on),
+                    sliceUri, getActivityIntent(ACTION_WIFI_CALLING_SETTINGS_ACTIVITY));
+        }
+    }
+
+    private boolean isWifiCallingEnabled(ImsManager imsManager)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        final FutureTask<Boolean> isWifiOnTask = new FutureTask<>(new Callable<Boolean>() {
+            @Override
+            public Boolean call() {
+                return imsManager.isWfcEnabledByUser();
+            }
+        });
+        final ExecutorService executor = Executors.newSingleThreadExecutor();
+        executor.execute(isWifiOnTask);
+
+        Boolean isWifiEnabledByUser = false;
+        isWifiEnabledByUser = isWifiOnTask.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+
+        return isWifiEnabledByUser && imsManager.isNonTtyOrTtyOnVolteEnabled();
+    }
+
+    /**
+     * Builds a toggle slice where the intent takes you to the wifi calling page and the toggle
+     * enables/disables wifi calling.
+     */
+    private Slice getWifiCallingSlice(Uri sliceUri, Context mContext,
+            boolean isWifiCallingEnabled) {
+
+        final IconCompat icon = IconCompat.createWithResource(mContext, R.drawable.wifi_signal);
+        final String title = mContext.getString(R.string.wifi_calling_settings_title);
+        return new ListBuilder(mContext, sliceUri, SLICE_TTL_MILLIS)
+                .setColor(R.color.material_blue_500)
+                .addRow(b -> b
+                        .setTitle(title)
+                        .addEndItem(
+                                new SliceAction(
+                                        getBroadcastIntent(ACTION_WIFI_CALLING_CHANGED),
+                                        null /* actionTitle */, isWifiCallingEnabled))
+                        .setPrimaryAction(new SliceAction(
+                                getActivityIntent(ACTION_WIFI_CALLING_SETTINGS_ACTIVITY),
+                                icon,
+                                title)))
+                .build();
+    }
+
+    protected ImsManager getImsManager(int subId) {
+        return ImsManager.getInstance(mContext, SubscriptionManager.getPhoneId(subId));
+    }
+
+    private Integer getWfcMode(ImsManager imsManager)
+            throws InterruptedException, ExecutionException, TimeoutException {
+        FutureTask<Integer> wfcModeTask = new FutureTask<>(new Callable<Integer>() {
+            @Override
+            public Integer call() {
+                return imsManager.getWfcMode(false);
+            }
+        });
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        executor.execute(wfcModeTask);
+        return wfcModeTask.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Handles wifi calling setting change from wifi calling slice and posts notification. Should be
+     * called when intent action is ACTION_WIFI_CALLING_CHANGED. Executed in @WorkerThread
+     *
+     * @param intent action performed
+     */
+    public void handleWifiCallingChanged(Intent intent) {
+        final int subId = getDefaultVoiceSubId();
+
+        if (subId > SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
+            final ImsManager imsManager = getImsManager(subId);
+            if (imsManager.isWfcEnabledByPlatform()
+                    || imsManager.isWfcProvisionedOnDevice()) {
+                final boolean currentValue = imsManager.isWfcEnabledByUser()
+                        && imsManager.isNonTtyOrTtyOnVolteEnabled();
+                final boolean newValue = intent.getBooleanExtra(EXTRA_TOGGLE_STATE,
+                        currentValue);
+                final Intent activationAppIntent =
+                        getWifiCallingCarrierActivityIntent(subId);
+                if (!newValue || activationAppIntent == null) {
+                    // If either the action is to turn off wifi calling setting
+                    // or there is no activation involved - Update the setting
+                    if (newValue != currentValue) {
+                        imsManager.setWfcSetting(newValue);
+                    }
+                }
+            }
+        }
+        // notify change in slice in any case to get re-queried. This would result in displaying
+        // appropriate message with the updated setting.
+        final Uri uri = SliceBuilderUtils.getUri(PATH_WIFI_CALLING, false /*isPlatformSlice*/);
+        mContext.getContentResolver().notifyChange(uri, null);
+    }
+
+    /**
+     * Returns Slice with the title and subtitle provided as arguments with wifi signal Icon.
+     *
+     * @param title Title of the slice
+     * @param subtitle Subtitle of the slice
+     * @param sliceUri slice uri
+     * @return Slice with title and subtitle
+     */
+    // TODO(b/79548264) asses different scenarios and return null instead of non-actionable slice
+    private Slice getNonActionableWifiCallingSlice(String title, String subtitle, Uri sliceUri,
+            PendingIntent primaryActionIntent) {
+        final IconCompat icon = IconCompat.createWithResource(mContext, R.drawable.wifi_signal);
+        return new ListBuilder(mContext, sliceUri, SLICE_TTL_MILLIS)
+                .setColor(R.color.material_blue_500)
+                .addRow(b -> b
+                        .setTitle(title)
+                        .setSubtitle(subtitle)
+                        .setPrimaryAction(new SliceAction(
+                                primaryActionIntent, icon,
+                                title)))
+                .build();
+    }
+
+    /**
+     * Returns {@code true} when the key is enabled for the carrier, and {@code false} otherwise.
+     */
+    private boolean isCarrierConfigManagerKeyEnabled(Context mContext, String key,
+            int subId, boolean defaultValue) {
+        final CarrierConfigManager configManager = getCarrierConfigManager(mContext);
+        boolean ret = false;
+        if (configManager != null) {
+            final PersistableBundle bundle = configManager.getConfigForSubId(subId);
+            if (bundle != null) {
+                ret = bundle.getBoolean(key, defaultValue);
+            }
+        }
+        return ret;
+    }
+
+    protected CarrierConfigManager getCarrierConfigManager(Context mContext) {
+        return mContext.getSystemService(CarrierConfigManager.class);
+    }
+
+    /**
+     * Returns the current default voice subId obtained from SubscriptionManager
+     */
+    protected int getDefaultVoiceSubId() {
+        if (mSubscriptionManager == null) {
+            mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class);
+        }
+        return SubscriptionManager.getDefaultVoiceSubscriptionId();
+    }
+
+    /**
+     * Returns Intent of the activation app required to activate wifi calling or null if there is no
+     * need for activation.
+     */
+    protected Intent getWifiCallingCarrierActivityIntent(int subId) {
+        final CarrierConfigManager configManager = getCarrierConfigManager(mContext);
+        if (configManager == null) {
+            return null;
+        }
+
+        final PersistableBundle bundle = configManager.getConfigForSubId(subId);
+        if (bundle == null) {
+            return null;
+        }
+
+        final String carrierApp = bundle.getString(
+                CarrierConfigManager.KEY_WFC_EMERGENCY_ADDRESS_CARRIER_APP_STRING);
+        if (TextUtils.isEmpty(carrierApp)) {
+            return null;
+        }
+
+        final ComponentName componentName = ComponentName.unflattenFromString(carrierApp);
+        if (componentName == null) {
+            return null;
+        }
+
+        final Intent intent = new Intent();
+        intent.setComponent(componentName);
+        return intent;
+    }
+
+    private PendingIntent getBroadcastIntent(String action) {
+        final Intent intent = new Intent(action);
+        intent.setClass(mContext, SliceBroadcastReceiver.class);
+        return PendingIntent.getBroadcast(mContext, 0 /* requestCode */, intent,
+                PendingIntent.FLAG_CANCEL_CURRENT);
+    }
+
+    /**
+     * Returns PendingIntent to start activity specified by action
+     */
+    private PendingIntent getActivityIntent(String action) {
+        final Intent intent = new Intent(action);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        return PendingIntent.getActivity(mContext, 0 /* requestCode */, intent, 0 /* flags */);
+    }
+
+    /**
+     * Returns carrier id name of the current Subscription
+     */
+    private String getSimCarrierName() {
+        final TelephonyManager telephonyManager = mContext.getSystemService(TelephonyManager.class);
+        final CharSequence carrierName = telephonyManager.getSimCarrierIdName();
+        if (carrierName == null) {
+            return mContext.getString(R.string.carrier);
+        }
+        return carrierName.toString();
+    }
+
+}

tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSliceHelperTest.java

@@ -0,0 +1,316 @@
+/*
+ * Copyright (C) 2018 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.
+ */
+
+package com.android.settings.wifi.calling;
+
+import static android.app.slice.Slice.EXTRA_TOGGLE_STATE;
+import static android.app.slice.Slice.HINT_TITLE;
+import static android.app.slice.SliceItem.FORMAT_TEXT;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.telephony.CarrierConfigManager;
+
+import androidx.slice.Slice;
+import androidx.slice.SliceItem;
+import androidx.slice.SliceMetadata;
+import androidx.slice.SliceProvider;
+import androidx.slice.core.SliceAction;
+import androidx.slice.core.SliceQuery;
+import androidx.slice.widget.SliceLiveData;
+
+import com.android.ims.ImsManager;
+import com.android.settings.R;
+import com.android.settings.slices.SettingsSliceProvider;
+import com.android.settings.slices.SliceBroadcastReceiver;
+import com.android.settings.slices.SliceBuilderUtils;
+import com.android.settings.slices.SliceData;
+import com.android.settings.slices.SlicesFeatureProvider;
+import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class WifiCallingSliceHelperTest {
+
+    private Context mContext;
+    @Mock
+    private CarrierConfigManager mMockCarrierConfigManager;
+
+    @Mock
+    private ImsManager mMockImsManager;
+
+    private final Uri mWfcURI = Uri.parse("content://com.android.settings.slices/wifi_calling");
+
+    private FakeWifiCallingSliceHelper mWfcSliceHelper;
+    private SettingsSliceProvider mProvider;
+    private SliceBroadcastReceiver mReceiver;
+    private FakeFeatureFactory mFeatureFactory;
+    private SlicesFeatureProvider mSlicesFeatureProvider;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+
+        //setup for SettingsSliceProvider tests
+        mProvider = spy(new SettingsSliceProvider());
+        doReturn(mContext).when(mProvider).getContext();
+
+        //setup for SliceBroadcastReceiver test
+        mReceiver = spy(new SliceBroadcastReceiver());
+
+        mFeatureFactory = FakeFeatureFactory.setupForTest();
+        mSlicesFeatureProvider = mFeatureFactory.getSlicesFeatureProvider();
+
+        // Prevent crash in SliceMetadata.
+        Resources resources = spy(mContext.getResources());
+        doReturn(60).when(resources).getDimensionPixelSize(anyInt());
+        doReturn(resources).when(mContext).getResources();
+
+        mWfcSliceHelper = new FakeWifiCallingSliceHelper(mContext);
+
+        // Set-up specs for SliceMetadata.
+        SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
+    }
+
+    @Test
+    public void test_CreateWifiCallingSlice_invalidSubId() {
+        mWfcSliceHelper.setDefaultVoiceSubId(-1);
+
+        final Slice slice = mWfcSliceHelper.createWifiCallingSlice(mWfcURI);
+
+        testWifiCallingSettingsUnavailableSlice(slice, null,
+                SliceBuilderUtils.getSettingsIntent(mContext));
+    }
+
+    @Test
+    public void test_CreateWifiCallingSlice_wfcNotSupported() {
+        doReturn(false).when(mMockImsManager).isWfcEnabledByPlatform();
+
+        final Slice slice = mWfcSliceHelper.createWifiCallingSlice(mWfcURI);
+
+        assertThat(mWfcSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);
+        testWifiCallingSettingsUnavailableSlice(slice, null,
+                SliceBuilderUtils.getSettingsIntent(mContext));
+    }
+
+    @Test
+    public void test_CreateWifiCallingSlice_needsActivation() {
+        /* In cases where activation is needed and the user action
+        would be turning on the wifi calling (i.e. if wifi calling is
+        turned off) we need to guide the user to wifi calling settings
+        activity so the user can perform the activation there.(PrimaryAction)
+         */
+        doReturn(true).when(mMockImsManager).isWfcEnabledByPlatform();
+        doReturn(true).when(mMockImsManager).isWfcProvisionedOnDevice();
+        doReturn(false).when(mMockImsManager).isWfcEnabledByUser();
+        doReturn(false).when(mMockImsManager).isNonTtyOrTtyOnVolteEnabled();
+        doReturn(null).when(mMockCarrierConfigManager).getConfigForSubId(1);
+        mWfcSliceHelper.setActivationAppIntent(new Intent()); // dummy Intent
+
+        final Slice slice  = mWfcSliceHelper.createWifiCallingSlice(mWfcURI);
+
+        assertThat(mWfcSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);
+        testWifiCallingSettingsUnavailableSlice(slice, null,
+                getActivityIntent(WifiCallingSliceHelper.ACTION_WIFI_CALLING_SETTINGS_ACTIVITY));
+    }
+
+    @Test
+    public void test_CreateWifiCallingSlice_success() {
+        doReturn(true).when(mMockImsManager).isWfcEnabledByPlatform();
+        doReturn(true).when(mMockImsManager).isWfcProvisionedOnDevice();
+        doReturn(true).when(mMockImsManager).isWfcEnabledByUser();
+        doReturn(true).when(mMockImsManager).isNonTtyOrTtyOnVolteEnabled();
+        doReturn(null).when(mMockCarrierConfigManager).getConfigForSubId(1);
+
+        final Slice slice = mWfcSliceHelper.createWifiCallingSlice(mWfcURI);
+
+        assertThat(mWfcSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);
+        testWifiCallingSettingsToggleSlice(slice, null);
+    }
+
+    @Test
+    public void test_SettingSliceProvider_getsRightSliceWifiCalling() {
+        doReturn(true).when(mMockImsManager).isWfcEnabledByPlatform();
+        doReturn(true).when(mMockImsManager).isWfcProvisionedOnDevice();
+        doReturn(true).when(mMockImsManager).isWfcEnabledByUser();
+        doReturn(true).when(mMockImsManager).isNonTtyOrTtyOnVolteEnabled();
+        doReturn(null).when(mMockCarrierConfigManager).getConfigForSubId(1);
+        doReturn(mWfcSliceHelper).when(mSlicesFeatureProvider)
+              .getNewWifiCallingSliceHelper(mContext);
+
+        final Slice slice = mProvider.onBindSlice(mWfcURI);
+
+        assertThat(mWfcSliceHelper.getDefaultVoiceSubId()).isEqualTo(1);
+        testWifiCallingSettingsToggleSlice(slice, null);
+    }
+
+    @Test
+    public void test_SliceBroadcastReceiver_toggleOffWifiCalling() {
+        doReturn(true).when(mMockImsManager).isWfcEnabledByPlatform();
+        doReturn(true).when(mMockImsManager).isWfcProvisionedOnDevice();
+        doReturn(false).when(mMockImsManager).isWfcEnabledByUser();
+        doReturn(true).when(mMockImsManager).isNonTtyOrTtyOnVolteEnabled();
+        doReturn(mWfcSliceHelper).when(mSlicesFeatureProvider)
+              .getNewWifiCallingSliceHelper(mContext);
+        mWfcSliceHelper.setActivationAppIntent(null);
+
+        ArgumentCaptor<Boolean> mWfcSettingCaptor = ArgumentCaptor.forClass(Boolean.class);
+
+        // turn on Wifi calling setting
+        Intent intent = new Intent(WifiCallingSliceHelper.ACTION_WIFI_CALLING_CHANGED);
+        intent.putExtra(EXTRA_TOGGLE_STATE, true);
+
+        // change the setting
+        mReceiver.onReceive(mContext, intent);
+
+        verify((mMockImsManager)).setWfcSetting(mWfcSettingCaptor.capture());
+
+        // assert the change
+        assertThat(mWfcSettingCaptor.getValue()).isTrue();
+    }
+
+    private void testWifiCallingSettingsUnavailableSlice(Slice slice,
+            SliceData sliceData, PendingIntent expectedPrimaryAction) {
+        final SliceMetadata metadata = SliceMetadata.from(mContext, slice);
+
+        //Check there is no toggle action
+        final List<SliceAction> toggles = metadata.getToggles();
+        assertThat(toggles).isEmpty();
+
+        // Check whether the primary action is to open wifi calling settings activity
+        final PendingIntent primaryPendingIntent =
+                metadata.getPrimaryAction().getAction();
+        assertThat(primaryPendingIntent).isEqualTo(expectedPrimaryAction);
+
+        // Check the title
+        final List<SliceItem> sliceItems = slice.getItems();
+        assertTitle(sliceItems, mContext.getString(R.string.wifi_calling_settings_title));
+    }
+
+    private void testWifiCallingSettingsToggleSlice(Slice slice,
+            SliceData sliceData) {
+        final SliceMetadata metadata = SliceMetadata.from(mContext, slice);
+
+        final List<SliceAction> toggles = metadata.getToggles();
+        assertThat(toggles).hasSize(1);
+
+        final SliceAction mainToggleAction = toggles.get(0);
+
+        // Check intent in Toggle Action
+        final PendingIntent togglePendingIntent = mainToggleAction.getAction();
+        final PendingIntent expectedToggleIntent = getBroadcastIntent(
+                WifiCallingSliceHelper.ACTION_WIFI_CALLING_CHANGED);
+        assertThat(togglePendingIntent).isEqualTo(expectedToggleIntent);
+
+        // Check primary intent
+        final PendingIntent primaryPendingIntent = metadata.getPrimaryAction().getAction();
+        final PendingIntent expectedPendingIntent =
+                getActivityIntent(WifiCallingSliceHelper.ACTION_WIFI_CALLING_SETTINGS_ACTIVITY);
+        assertThat(primaryPendingIntent).isEqualTo(expectedPendingIntent);
+
+        // Check the title
+        final List<SliceItem> sliceItems = slice.getItems();
+        assertTitle(sliceItems, mContext.getString(R.string.wifi_calling_settings_title));
+    }
+
+    private PendingIntent getBroadcastIntent(String action) {
+        final Intent intent = new Intent(action);
+        intent.setClass(mContext, SliceBroadcastReceiver.class);
+        return PendingIntent.getBroadcast(mContext, 0 /* requestCode */, intent,
+                PendingIntent.FLAG_CANCEL_CURRENT);
+    }
+
+    private PendingIntent getActivityIntent(String action) {
+        final Intent intent = new Intent(action);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        return PendingIntent.getActivity(mContext, 0 /* requestCode */, intent, 0 /* flags */);
+    }
+
+    private void assertTitle(List<SliceItem> sliceItems, String title) {
+        boolean hasTitle = false;
+        for (SliceItem item : sliceItems) {
+            List<SliceItem> titleItems = SliceQuery.findAll(item, FORMAT_TEXT, HINT_TITLE,
+                    null /* non-hints */);
+            if (titleItems == null) {
+                continue;
+            }
+
+            hasTitle = true;
+            for (SliceItem subTitleItem : titleItems) {
+                assertThat(subTitleItem.getText()).isEqualTo(title);
+            }
+        }
+        assertThat(hasTitle).isTrue();
+    }
+    private class FakeWifiCallingSliceHelper extends WifiCallingSliceHelper {
+        int mSubId = 1;
+
+        private Intent mActivationAppIntent;
+        FakeWifiCallingSliceHelper(Context context) {
+            super(context);
+            mActivationAppIntent = null;
+        }
+
+        @Override
+        protected CarrierConfigManager getCarrierConfigManager(Context mContext) {
+            return mMockCarrierConfigManager;
+        }
+
+        @Override
+        protected ImsManager getImsManager(int subId) {
+            return mMockImsManager;
+        }
+
+        protected int getDefaultVoiceSubId() {
+            return mSubId;
+        }
+
+        protected void setDefaultVoiceSubId(int id) {
+            mSubId = id;
+        }
+
+        @Override
+        protected Intent getWifiCallingCarrierActivityIntent(int subId) {
+            return mActivationAppIntent;
+        }
+
+        public void setActivationAppIntent(Intent intent) {
+            mActivationAppIntent = intent;
+        }
+    }
+}